ebpf/ebpftracer/tracer/inject/inject_linux_amd64.go

package inject

/*
#cgo CFLAGS: -I include
#cgo amd64 LDFLAGS: ${SRCDIR}/lib/libhotpatch_amd64.a
#cgo arm64 LDFLAGS: ${SRCDIR}/lib/libhotpatch_arm64.a
#include "hotpatch.h"
#include <stdlib.h>
*/
import "C"

import (
	"bufio"
	"debug/elf"
	"fmt"
	klog "github.com/sirupsen/logrus"
	"golang.org/x/arch/x86/x86asm"
	"log"
	"os"
	"strings"
	"syscall"
	"time"
	"unsafe"
)

const (
	IO_FD_FDID_SYM_OFFSET = 129
	NET_SEND_SYM_OFFSET   = 518
)

type InstInfo struct {
	SymName          string
	SymSize          uint64
	SymAddr          uint64
	PC               uint64
	Inst             x86asm.Inst
	OriginInst       x86asm.Inst
	OriginCode       []byte
	TargetAddr       uint64
	OriginTargetAddr uint64
}

type InnerSymbolInfo struct {
	IO_fd_fdID InstInfo
	NET_Send   InstInfo
}

type LibNetInfo struct {
	LibName     string
	LibPath     string
	FuncSymbol  InstInfo
	InnerSymbol InnerSymbolInfo
}

type UprobeData struct {
	Offset  int
	Func    string
	ELFPath string
}

type JvmInjector struct {
	Pid               int
	ReleaseLibNetInfo LibNetInfo
	DebugLibNetInfo   LibNetInfo
	RecodeInfo        LibNetInfo
	// 原方法首个指令不为jmp | ReleaseLibNetInfo 读取无异常
	PreCheck struct {
		NeedInjectionCheck bool // 原指令校验 true表示可以继续执行注入
		LoadingCheck       bool // true 表示加载成功
		IoFdCheck          bool // fd地址校验
		NetSendFuncCheck   bool // netsend校验
		EbpfCanInjection   bool // 满足则注入ebpf
	}
	AfterCheck struct {
		IoFdCheck        bool
		NetSendFuncCheck bool
	}
	Uprobe UprobeData
}

func (j *JvmInjector) findReleaseAddressInfoFromMem() error {
	funcAbsAddress := j.ReleaseLibNetInfo.FuncSymbol.SymAddr
	releaseFuncSym := InnerSymbolInfo{}
	code, err := j.readMemory(funcAbsAddress, j.ReleaseLibNetInfo.FuncSymbol.SymSize)
	if err != nil {
		return err
	}
	pc := uint64(0)
	callCount := 0
	preContext := InstInfo{}
	for pc < uint64(len(code)) {

		inst, err := x86asm.Decode(code[pc:], 64)
		if err != nil {
			fmt.Printf("Decode error at offset 0x%x: %v\n", pc, err)
			pc++ // Skip this byte and try to decode again
			continue
		}
		//fmt.Printf("Decoded instuction at 0x%x: %v\n", funcAbsAddress+pc, Inst)
		//fmt.Printf("Decoded x86 instuction at 0x%x: %v\n", funcAbsAddress+pc, x86asm.IntelSyntax(inst, 0, nil))
		//fmt.Printf("Decoded GNU instuction at 0x%x: %v\n", funcAbsAddress+pc, x86asm.GNUSyntax(Inst, 0, nil))
		currentData := InstInfo{
			PC:      pc,
			SymAddr: funcAbsAddress + pc,
			Inst:    inst,
			//IntelInst: x86asm.IntelSyntax(inst, 0, nil),
		}
		if pc == 0 && inst.Op == x86asm.JMP {
			// 已经被修改过的首指令
			j.PreCheck.EbpfCanInjection = true
			klog.Infof("[inject] Inst already modified. <%s>", x86asm.IntelSyntax(inst, 0, nil))
			return nil
		}
		if pc == 0 {
			j.ReleaseLibNetInfo.FuncSymbol.PC = currentData.PC
			j.ReleaseLibNetInfo.FuncSymbol.Inst = currentData.Inst
			j.ReleaseLibNetInfo.FuncSymbol.OriginInst = currentData.Inst
		}

		if inst.Op == x86asm.MOV {
			if dst, okDst := inst.Args[0].(x86asm.Mem); okDst {
				if dst.Base == x86asm.RBP {
					if src, okSrc := inst.Args[1].(x86asm.Reg); okSrc {
						if src == x86asm.R9L {
							// debug so
							j.PreCheck.EbpfCanInjection = true
							return fmt.Errorf("MOV from register %v to memory %v\n", src, dst)
						}
					}
				}
			}

			//src, okSrc := inst.Args[1].(x86asm.Reg)
			//fmt.Println(inst.Args)
			//fmt.Printf("Instruction: %+v\n", inst)
			//
			//fmt.Println(okSrc)

			//if okDst && okSrc && dst == x86asm.RBP && src == x86asm.R9L {
			//	fmt.Println("Instruction is 'mov %r9d, %rbp'")
			//}

		}

		if inst.Op == x86asm.CALL {
			//fmt.Printf("Pre instuction at 0x%x: %v\n", preContext.PC, preContext.Inst)
			if callCount == 0 {
				releaseFuncSym.IO_fd_fdID = preContext
				releaseFuncSym.IO_fd_fdID.SymName = "<IO_fd_fdID>(Release)"
				preInst := preContext.Inst
				fmt.Println(preInst.Op)
				fmt.Println((preInst.Args))
				// 计算目标地址
				if preInst.Op == x86asm.MOV &&
					len(preInst.Args) == 4 &&
					preInst.Args[0] != nil &&
					preInst.Args[0] == x86asm.RDX &&
					preInst.Args[1] != nil {
					if mem, ok := preInst.Args[1].(x86asm.Mem); ok && mem.Base == x86asm.RIP {
						relOffset := mem.Disp // 直接从Mem结构体中读取偏移
						targetAddress := preContext.SymAddr + uint64(preInst.Len) + uint64(relOffset)
						fmt.Printf("Target address: 0x%x\n", targetAddress)
						releaseFuncSym.IO_fd_fdID.TargetAddr = targetAddress
					} else {
						return fmt.Errorf("The instruction does not use RIP-relative addressing.")
					}
				} else {
					return fmt.Errorf("The decoded instruction is not a MOV to RDX.")
				}

				//os.Exit(1)
			}
			callCount++
			if callCount == 4 {
				releaseFuncSym.NET_Send = currentData
				fmt.Printf("4 call Decoded instuction at 0x%x: %v\n", funcAbsAddress+pc, inst)

				relOffset, ok := inst.Args[0].(x86asm.Rel)
				if !ok {
					return fmt.Errorf("The instruction does not use RIP-relative addressing.")
				}
				targetAddress := currentData.SymAddr + uint64(inst.Len) + uint64(relOffset)
				releaseFuncSym.NET_Send.TargetAddr = targetAddress
				fmt.Println(releaseFuncSym.NET_Send)
				releaseFuncSym.NET_Send.SymName = "<NET_Send>(Release)"
				fmt.Printf("Target address: 0x%x\n", targetAddress)
			}
		}
		preContext = InstInfo{
			PC:      pc,
			SymAddr: funcAbsAddress + pc,
			Inst:    inst,
		}
		pc += uint64(inst.Len)
	}
	j.ReleaseLibNetInfo.InnerSymbol = releaseFuncSym
	j.ReleaseLibNetInfo.FuncSymbol.OriginCode = code[0:5]
	return nil
}

func (j *JvmInjector) findDebugAddressInfoFromMem() (uint64, error) {
	funcAbsAddress := j.DebugLibNetInfo.FuncSymbol.SymAddr
	debugFuncSym := InnerSymbolInfo{}
	//debugFuncSym.FuncSymbol.SymAddr = funcAbsAddress
	//offset := sym.Value
	size := j.DebugLibNetInfo.FuncSymbol.SymSize
	code, err := j.readMemory(funcAbsAddress, size)
	//fmt.Println(code, err)
	if err != nil {
		return 0, err
	}

	pc := uint64(0)
	preContext := InstInfo{}

	for pc < uint64(len(code)) {
		inst, err := x86asm.Decode(code[pc:], 64)
		if err != nil {
			fmt.Printf("Decode error at offset 0x%x: %v\n", pc, err)
			pc++ // Skip this byte and try to decode again
			continue
		}
		//fmt.Printf("Decoded instuction at 0x%x: %v\n", funcAbsAddress+pc, Inst)
		//fmt.Printf("Decoded x86 instuction at 0x%x: %v\n", funcAbsAddress+pc, x86asm.IntelSyntax(inst, 0, nil))
		//fmt.Printf("Decoded GNU instuction at 0x%x: %v\n", funcAbsAddress+pc, x86asm.GNUSyntax(Inst, 0, nil))
		currentData := InstInfo{
			PC:      pc,
			SymAddr: funcAbsAddress + pc,
			Inst:    inst,
		}
		if pc == 0 {
			j.DebugLibNetInfo.FuncSymbol.PC = currentData.PC
			j.DebugLibNetInfo.FuncSymbol.Inst = currentData.Inst
			j.DebugLibNetInfo.FuncSymbol.OriginInst = currentData.Inst
		}
		if pc == IO_FD_FDID_SYM_OFFSET {
			fmt.Printf("Instuction at 0x%x: %v\n", preContext.PC, preContext.Inst)
			debugFuncSym.IO_fd_fdID = currentData
			debugFuncSym.IO_fd_fdID.SymName = "<IO_fd_fdID>(Debug)"
			// 计算目标地址
			if currentData.Inst.Op == x86asm.MOV &&
				len(currentData.Inst.Args) == 4 &&
				currentData.Inst.Args[0] != nil &&
				currentData.Inst.Args[0] == x86asm.RDX &&
				currentData.Inst.Args[1] != nil {
				if mem, ok := currentData.Inst.Args[1].(x86asm.Mem); ok && mem.Base == x86asm.RIP {
					// 直接从Mem结构体中读取偏移
					relOffset := mem.Disp
					targetAddress := currentData.SymAddr + uint64(currentData.Inst.Len) + uint64(relOffset)
					fmt.Printf("Find %s Target address: 0x%x\n", debugFuncSym.IO_fd_fdID.SymName, targetAddress)
					debugFuncSym.IO_fd_fdID.TargetAddr = targetAddress
					// 保存原始数据
					debugFuncSym.IO_fd_fdID.OriginTargetAddr = targetAddress
					debugFuncSym.IO_fd_fdID.OriginInst = currentData.Inst
					j.PreCheck.IoFdCheck = true
				} else {
					return 0, fmt.Errorf("The instruction does not use RIP-relative addressing.")
				}
			} else {
				return 0, fmt.Errorf("The decoded instruction is not a MOV to RDX.")
			}
		}
		if pc == NET_SEND_SYM_OFFSET {
			debugFuncSym.NET_Send = currentData
			fmt.Printf("4 call Decoded instuction at 0x%x: %v\n", funcAbsAddress+pc, inst)
			relOffset, ok := (inst.Args[0].(x86asm.Rel))
			if !ok {
				return 0, fmt.Errorf("The decoded instruction is not a Rel.")
			}
			targetAddress := currentData.SymAddr + uint64(inst.Len) + uint64(relOffset)
			debugFuncSym.NET_Send.TargetAddr = targetAddress
			debugFuncSym.NET_Send.SymName = "<NET_Send>(Debug)"
			fmt.Printf("Find %s Target address: 0x%x\n", debugFuncSym.NET_Send.SymName, targetAddress)

			// 保存原始数据
			debugFuncSym.NET_Send.OriginTargetAddr = targetAddress
			debugFuncSym.NET_Send.OriginInst = currentData.Inst

			j.PreCheck.NetSendFuncCheck = true
		}

		preContext = InstInfo{
			PC:      pc,
			SymAddr: funcAbsAddress + pc,
			Inst:    inst,
		}
		pc += uint64(inst.Len)
	}
	j.DebugLibNetInfo.InnerSymbol = debugFuncSym
	return 0, nil
}

func (j *JvmInjector) checkDebugFuncSymAfterChange() (uint64, error) {
	funcAbsAddress := j.DebugLibNetInfo.FuncSymbol.SymAddr
	debugFuncSym := InnerSymbolInfo{}
	code, err := j.readMemory(funcAbsAddress, j.DebugLibNetInfo.FuncSymbol.SymSize)
	if err != nil {
		return 0, err
	}

	pc := uint64(0)
	preContext := InstInfo{}

	for pc < uint64(len(code)) {
		inst, err := x86asm.Decode(code[pc:], 64)
		if err != nil {
			fmt.Printf("Decode error at offset 0x%x: %v\n", pc, err)
			pc++ // Skip this byte and try to decode again
			continue
		}
		//fmt.Printf("Decoded instuction at 0x%x: %v\n", funcAbsAddress+pc, Inst)
		//fmt.Printf("Decoded x86 instuction at 0x%x: %v\n", funcAbsAddress+pc, x86asm.IntelSyntax(inst, 0, nil))
		//fmt.Printf("Decoded GNU instuction at 0x%x: %v\n", funcAbsAddress+pc, x86asm.GNUSyntax(Inst, 0, nil))
		currentData := InstInfo{
			PC:      pc,
			SymAddr: funcAbsAddress + pc,
			Inst:    inst,
		}
		if pc == NET_SEND_SYM_OFFSET {
			fmt.Printf("Instuction at 0x%x: %v\n", preContext.PC, preContext.Inst)
			debugFuncSym.IO_fd_fdID = currentData
			debugFuncSym.IO_fd_fdID.SymName = "<IO_fd_fdID>(Debug)"
			// 计算目标地址
			if currentData.Inst.Op == x86asm.MOV &&
				len(currentData.Inst.Args) == 4 &&
				currentData.Inst.Args[0] != nil &&
				currentData.Inst.Args[0] == x86asm.RDX &&
				currentData.Inst.Args[1] != nil {
				if mem, ok := currentData.Inst.Args[1].(x86asm.Mem); ok && mem.Base == x86asm.RIP {
					// 直接从Mem结构体中读取偏移
					relOffset := mem.Disp
					targetAddress := currentData.SymAddr + uint64(currentData.Inst.Len) + uint64(relOffset)
					fmt.Printf("Find %s Target address: 0x%x\n", debugFuncSym.IO_fd_fdID.SymName, targetAddress)
					debugFuncSym.IO_fd_fdID.TargetAddr = targetAddress
					//j.PreCheck.IoFdCheck = true

					if targetAddress == j.ReleaseLibNetInfo.InnerSymbol.IO_fd_fdID.TargetAddr {
						j.DebugLibNetInfo.InnerSymbol.IO_fd_fdID.TargetAddr = targetAddress
						j.DebugLibNetInfo.InnerSymbol.IO_fd_fdID.Inst = currentData.Inst
						j.AfterCheck.IoFdCheck = true
						fmt.Println("ok")
					}
				} else {
					return 0, fmt.Errorf("The instruction does not use RIP-relative addressing.")
				}
			} else {
				return 0, fmt.Errorf("The decoded instruction is not a MOV to RDX.")
			}
		}
		if pc == NET_SEND_SYM_OFFSET {
			debugFuncSym.NET_Send = currentData
			//fmt.Println(currentData.IntelInst)
			//fmt.Printf("4 call Decoded instuction at 0x%x: %v\n", funcAbsAddress+pc, inst)
			relOffset, ok := (inst.Args[0].(x86asm.Rel))
			if !ok {
				return 0, fmt.Errorf("The decoded instruction is not a Rel.")
			}
			targetAddress := currentData.SymAddr + uint64(inst.Len) + uint64(relOffset)
			debugFuncSym.NET_Send.TargetAddr = targetAddress
			debugFuncSym.NET_Send.SymName = "<NET_Send>(Debug)"
			fmt.Printf("Find %s Target address: 0x%x\n", debugFuncSym.NET_Send.SymName, targetAddress)

			if targetAddress == j.ReleaseLibNetInfo.InnerSymbol.NET_Send.TargetAddr {
				j.DebugLibNetInfo.InnerSymbol.NET_Send.TargetAddr = targetAddress
				j.DebugLibNetInfo.InnerSymbol.NET_Send.Inst = currentData.Inst
				j.AfterCheck.NetSendFuncCheck = true
			}
		}

		preContext = InstInfo{
			PC:      pc,
			SymAddr: funcAbsAddress + pc,
			Inst:    inst,
		}
		pc += uint64(inst.Len)
	}
	return 0, nil
}

func (j *JvmInjector) checkReleaseFuncSymAfterChange() error {
	funcAbsAddress := j.ReleaseLibNetInfo.FuncSymbol.SymAddr
	code, err := j.readMemory(funcAbsAddress, j.ReleaseLibNetInfo.FuncSymbol.SymSize)
	if err != nil {
		return fmt.Errorf("readMemory error in checkReleaseFuncSymAfterChange <%v>", err)
	}
	inst, err := x86asm.Decode(code[0:], 64)
	if err != nil {
		return fmt.Errorf("Decode error in checkReleaseFuncSymAfterChange <%v>", err)
	}
	if inst.Op != x86asm.JMP {
		return fmt.Errorf("The instruction does not JMP.")
	}
	relOffset, ok := inst.Args[0].(x86asm.Rel)
	if !ok {
		return fmt.Errorf("The instruction does not use RIP-relative addressing.")
	}
	// 验证target与Debug入口是否一致
	targetAddress := funcAbsAddress + uint64(inst.Len) + uint64(relOffset)
	if targetAddress != j.DebugLibNetInfo.FuncSymbol.SymAddr {
		return fmt.Errorf("Function entry jmp address does not match expectations.")
	}
	return nil
}

// readMemory 用于读取指定地址的内存数据
func (j *JvmInjector) readMemory(address uint64, size uint64) ([]byte, error) {
	memFile := fmt.Sprintf("/proc/%d/mem", j.Pid)
	file, err := os.Open(memFile)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	data := make([]byte, size)
	_, err = file.ReadAt(data, int64(address))
	if err != nil {
		return nil, err
	}

	return data, nil
}

// findLibraryBases 用于在 /proc/[pid]/maps 文件中查找库的所有基地址

func findLibraryBasesList(pid int, libraryName string, libPath string) ([]uint64, error) {
	mapsFile := fmt.Sprintf("/proc/%d/maps", pid)
	file, err := os.Open(mapsFile)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	var bases []uint64
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := scanner.Text()
		if strings.Contains(line, libraryName) && strings.Contains(line, libPath) {
			var start, end uint64
			fmt.Sscanf(line, "%x-%x", &start, &end)
			bases = append(bases, start)
		}
	}

	if len(bases) == 0 {
		return nil, fmt.Errorf("library %s not found", libraryName)
	}

	return bases, nil
}

func (j *JvmInjector) findLibBaseFromProcMaps(libName string) (uint64, string, error) {
	mapsFile := fmt.Sprintf("/proc/%d/maps", j.Pid)
	file, err := os.Open(mapsFile)
	if err != nil {
		return 0, "", err
	}
	defer file.Close()
	var start, end uint64
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := scanner.Text()
		if strings.Contains(line, "/"+libName) {
			fmt.Sscanf(line, "%x-%x", &start, &end)
			fields := strings.Fields(line)
			if len(fields) > 5 {
				path := fields[5]
				if strings.HasSuffix(path, ".so") {
					klog.Infof("[inject] found library %s", path)
					return start, path, nil
				}
			}
		}
	}

	return 1, "", fmt.Errorf("library %s not found", libName)
}

func (j *JvmInjector) getFunctionOffset(libPath, functionName string) (elf.Symbol, error) {
	elfFile, err := elf.Open(libPath)
	if err != nil {
		return elf.Symbol{}, fmt.Errorf("failed to open ELF file: %v", err)
	}
	defer elfFile.Close()

	symbols, err := elfFile.DynamicSymbols()
	if err != nil {
		return elf.Symbol{}, fmt.Errorf("failed to read dynamic symbols: %v", err)
	}

	for _, sym := range symbols {
		if sym.Name == functionName {
			fmt.Println("size:", sym.Size)
			return sym, nil
		}
	}

	//textSection := elfFile.Section(".text")
	//if textSection == nil {
	//	fmt.Println("textSection is null")
	//	//return nil
	//}
	//textSectionData, err := textSection.Data()
	//if err != nil {
	//	fmt.Println("textSectionData error is", err)
	//	//return nil
	//}
	//textSectionLen := uint64(len(textSectionData) - 1)

	return elf.Symbol{}, fmt.Errorf("function %s not found", functionName)
}

//var PID string

func (j *JvmInjector) findReleaseFuncContextFromLibPath() error {
	// 获取release库的基地址
	baseAddress, libPath, err := j.findLibBaseFromProcMaps(j.ReleaseLibNetInfo.LibName)
	functionName := j.ReleaseLibNetInfo.FuncSymbol.SymName
	j.ReleaseLibNetInfo.LibPath = libPath
	libName := j.ReleaseLibNetInfo.LibName
	if err != nil {
		log.Fatalf("Error finding base addresses: %v", err)
		return err
	}
	klog.Infof("[inject] Base address of %s: %x", libName, baseAddress)

	// 获取函数的偏移量
	functionSym, err := j.getFunctionOffset(libPath, functionName)

	// 计算函数的实际内存地址
	j.ReleaseLibNetInfo.FuncSymbol.SymAddr = baseAddress + functionSym.Value
	j.ReleaseLibNetInfo.FuncSymbol.SymSize = functionSym.Size
	if err != nil {
		klog.WithError(err).Errorf("Error getting function offset")
		return err
	}
	klog.Infof("[inject] Actual memory address of %s at base 0x%x: 0x%x", functionName, baseAddress, j.ReleaseLibNetInfo.FuncSymbol.SymAddr)
	err = j.findReleaseAddressInfoFromMem()

	if err != nil {
		return err
	} else {
		j.PreCheck.NeedInjectionCheck = true
	}

	return nil
}

func (j *JvmInjector) findDebugFuncContextFromLibPath() error {
	libName := j.DebugLibNetInfo.LibName

	// 获取release库的基地址
	baseAddress, libPath, err := j.findLibBaseFromProcMaps(libName)
	fmt.Println(libPath)
	functionName := j.DebugLibNetInfo.FuncSymbol.SymName
	j.DebugLibNetInfo.LibPath = libPath
	if err != nil {
		log.Fatalf("Error finding base addresses: %v", err)
		return err
	}

	// 获取函数的偏移量
	functionSym, err := j.getFunctionOffset(libPath, functionName)
	// 计算函数的实际内存地址
	j.DebugLibNetInfo.FuncSymbol.SymAddr = baseAddress + functionSym.Value
	j.DebugLibNetInfo.FuncSymbol.SymSize = functionSym.Size

	if err != nil {
		log.Fatalf("Error getting function offset: %v", err)
		return err
	}
	fmt.Printf("Actual memory address of %s at base 0x%x: 0x%x\n", functionName, baseAddress, j.DebugLibNetInfo.FuncSymbol.SymAddr)

	_, err = j.findDebugAddressInfoFromMem()
	if err != nil {
		log.Printf("Error finding first CALL instuction: %v", err)
		return err
	}
	fmt.Printf("First CALL instuction o1f %s at base 0x%x\n", functionName, baseAddress)
	return nil
}

func printCodeData(data LibNetInfo) {
	fmt.Printf("========FuncEnter <0x%x> \n", data.FuncSymbol.SymAddr)
	fmt.Printf("Name %s | CurrentAddr:<0x%x>\nOrigin-TargetAddr:<0x%x> | TargetAddr:<0x%x> \nOrigin-Inst:<%s> | Inst:<%s> \n",
		data.InnerSymbol.IO_fd_fdID.SymName,
		data.InnerSymbol.IO_fd_fdID.SymAddr,
		data.InnerSymbol.IO_fd_fdID.OriginTargetAddr,
		data.InnerSymbol.IO_fd_fdID.TargetAddr,
		x86asm.IntelSyntax(data.InnerSymbol.IO_fd_fdID.OriginInst, 0, nil),
		x86asm.IntelSyntax(data.InnerSymbol.IO_fd_fdID.Inst, 0, nil))
	fmt.Printf("\nName %s | CurrentAddr:<0x%x>\nOrigin-TargetAddr:<0x%x> | TargetAddr:<0x%x>\nOrigin-Inst:<%s> | Inst:<%s> \n",
		data.InnerSymbol.NET_Send.SymName,
		data.InnerSymbol.NET_Send.SymAddr,
		data.InnerSymbol.NET_Send.OriginTargetAddr,
		data.InnerSymbol.NET_Send.TargetAddr,
		x86asm.IntelSyntax(data.InnerSymbol.NET_Send.OriginInst, 0, nil),
		x86asm.IntelSyntax(data.InnerSymbol.NET_Send.Inst, 0, nil))
	fmt.Println("========")
}

func (j *JvmInjector) jvmInjectLib() int {
	dll := C.CString(j.DebugLibNetInfo.LibPath) // 替换为实际的DLL路径
	defer C.free(unsafe.Pointer(dll))           // 确保在使用完字符串后释放内存
	result := C.cw_inject_library(C.int(j.Pid), C.int(1), dll)
	fmt.Printf("Result: %d\n", result)
	return int(result)
}

func (j *JvmInjector) validateAllPreCheck() bool {
	return j.PreCheck.NeedInjectionCheck && j.PreCheck.LoadingCheck && j.PreCheck.IoFdCheck && j.PreCheck.NetSendFuncCheck
}

func (j *JvmInjector) validateAllModifyCheck() bool {
	return j.AfterCheck.IoFdCheck && j.AfterCheck.NetSendFuncCheck
}

/*修改部分*/
func readData(pid int, addr uintptr) (uint64, error) {
	var data uint64
	if _, err := syscall.PtracePeekData(pid, addr, (*[8]byte)(unsafe.Pointer(&data))[:]); err != nil {
		return 0, fmt.Errorf("ptrace PEEKDATA: %v", err)
	}
	return data, nil
}

func writeData(pid int, addr uintptr, data uint64) error {
	if _, err := syscall.PtracePokeData(pid, addr, (*[8]byte)(unsafe.Pointer(&data))[:]); err != nil {
		return fmt.Errorf("ptrace POKEDATA: %v", err)
	}
	return nil
}

func modifyIoFdTargetAddr(pid int, insertAddr, distAddr uintptr) error {
	newOffset := distAddr - (insertAddr + 7)
	targetAddr := insertAddr + 3
	// 获取目标地址处的数据
	originalData, err := readData(pid, targetAddr)
	if err != nil {
		return err
	}

	// 更新数据中的目标偏移
	updatedData := (originalData & 0xFFFFFFFF00000000) | uint64(newOffset&0xFFFFFFFF)
	err = writeData(pid, targetAddr, updatedData)
	if err != nil {
		return err
	}
	return nil
}

func modifyNetSetTargetAddr(pid int, sendDebugAddr, sendReleaseAddr uintptr) error {
	sendOffset := sendReleaseAddr - sendDebugAddr - 5

	// 读取原始数据
	alignedAddr := sendDebugAddr & ^(uintptr(unsafe.Sizeof(uintptr(0))) - 1)
	originalData, err := readData(pid, alignedAddr)
	if err != nil {
		return err
	}

	bytes := (*[8]byte)(unsafe.Pointer(&originalData))
	offsetLocation := (sendDebugAddr % uintptr(unsafe.Sizeof(uintptr(0)))) + 1
	*(*uint32)(unsafe.Pointer(&bytes[offsetLocation])) = uint32(sendOffset)

	err = writeData(pid, alignedAddr, originalData)
	if err != nil {
		return err
	}
	return nil
}

func modifyReleaseFuncEnter(pid int, originEnterAddr, debugEnterAddr uintptr) error {
	offset := debugEnterAddr - (originEnterAddr + 5)

	// 读取原始数据
	alignedAddr := originEnterAddr & ^(uintptr(unsafe.Sizeof(uintptr(0))) - 1)
	originalData, err := readData(pid, alignedAddr)
	if err != nil {
		return err
	}

	bytes := (*[8]byte)(unsafe.Pointer(&originalData))
	bytes[originEnterAddr%uintptr(unsafe.Sizeof(uintptr(0)))] = 0xe9
	*(*uint32)(unsafe.Pointer(&bytes[(originEnterAddr%uintptr(unsafe.Sizeof(uintptr(0))))+1])) = uint32(offset)
	err = writeData(pid, alignedAddr, originalData)
	if err != nil {
		return err
	}
	return nil
}

func restoreOriginalInstructions(pid int, addr uintptr, instructions []byte) error {
	alignedAddr := addr & ^(uintptr(unsafe.Sizeof(uintptr(0))) - 1)
	originalData, err := readData(pid, alignedAddr)
	if err != nil {
		return err
	}

	bytes := (*[8]byte)(unsafe.Pointer(&originalData))
	for i := 0; i < len(instructions); i++ {
		bytes[addr%uintptr(unsafe.Sizeof(uintptr(0)))+uintptr(i)] = instructions[i]
	}

	err = writeData(pid, alignedAddr, originalData)
	if err != nil {
		return err
	}
	return nil
}

//func main() {
//	flag.StringVar(&PID, "p", "", "PID")
//	flag.Parse()
//	pidStr := PID // 替换为目标进程的 PID
//	pid, err := strconv.Atoi(pidStr)
//	if err != nil {
//		log.Fatalf("Invalid PID: %v", err)
//	}
//	functionName := "Java_java_net_SocketOutputStream_socketWrite0"
//	libraryName := "libnet.so"
//
//	cwLibraryName := "cwlibnet.so"
//	cwLibraryPath := "/root/cwlibnet.so"
//
//	jvmInjector := &JvmInjector{
//		pid: pid,
//		ReleaseLibNetInfo: LibNetInfo{
//			libName: libraryName,
//			FuncSymbol: instInfo{
//				SymName: functionName,
//			},
//		},
//		DebugLibNetInfo: LibNetInfo{
//			// TODO 根据版本设置
//			libName: cwLibraryName,
//			// TODO 根据版本设置
//			libPath: cwLibraryPath,
//			FuncSymbol: instInfo{
//				SymName: functionName,
//			},
//		},
//	}
//
//	err = jvmInject(jvmInjector)
//	fmt.Println(err)
//}

func JvmInject(jvmInjector *JvmInjector) error {
	pid := jvmInjector.Pid
	var err error
	err = jvmInjector.findReleaseFuncContextFromLibPath()

	// Debug版本无需修改寄存器
	// 已经加载so并指令修改正确的
	if jvmInjector.PreCheck.EbpfCanInjection {
		klog.Infoln("[inject] eBPF can injection.")
		return nil
	}

	if err != nil {
		klog.WithError(err).Errorf("[inject] Error message during release phase.")
		return err
	}

	// 原指令校验通过
	if !jvmInjector.PreCheck.NeedInjectionCheck {
		return err
	}
	printCodeData(jvmInjector.ReleaseLibNetInfo)
	_type, _, err := jvmInjector.findLibBaseFromProcMaps(jvmInjector.DebugLibNetInfo.LibName)
	if err != nil {
		// load so
		if _type == 1 {
			fmt.Println(err, "Load it.")
			if jvmInjector.jvmInjectLib() == 0 {
				jvmInjector.PreCheck.LoadingCheck = true
			} else {
				return err
			}
		}
	} else {
		jvmInjector.PreCheck.LoadingCheck = true
	}

	if !jvmInjector.PreCheck.LoadingCheck {
		fmt.Println("Failed load so")
		return err
	}

	err = jvmInjector.findDebugFuncContextFromLibPath()
	if err != nil {
		log.Fatalf("Failed to find debug Context: %v", err)
	}

	if !jvmInjector.validateAllPreCheck() {
		fmt.Println("failed validateAllPreCheck ")
		return err
	}
	// 修改
	debugFuncEnterAddr := uintptr(jvmInjector.DebugLibNetInfo.FuncSymbol.SymAddr)
	debugIoFdAddr := uintptr(jvmInjector.DebugLibNetInfo.InnerSymbol.IO_fd_fdID.SymAddr)
	debugNetSendAddr := uintptr(jvmInjector.DebugLibNetInfo.InnerSymbol.NET_Send.SymAddr)

	originFuncEnterAddr := uintptr(jvmInjector.ReleaseLibNetInfo.FuncSymbol.SymAddr)
	ioFdReleaseTargetAddr := uintptr(jvmInjector.ReleaseLibNetInfo.InnerSymbol.IO_fd_fdID.TargetAddr)
	netSendReleaseTargetAddr := uintptr(jvmInjector.ReleaseLibNetInfo.InnerSymbol.NET_Send.TargetAddr)

	fmt.Printf("<0x%x> -> <0x%x>\n", originFuncEnterAddr, debugFuncEnterAddr)
	fmt.Printf("<0x%x> -> <0x%x>\n", debugIoFdAddr, ioFdReleaseTargetAddr)
	fmt.Printf("<0x%x> -> <0x%x>\n", debugNetSendAddr, netSendReleaseTargetAddr)

	// 附加到目标进程
	err = syscall.PtraceAttach(pid)
	if err != nil {
		fmt.Printf("ptrace ATTACH: %v", err)
	}

	// 等待目标进程停止
	if _, err := syscall.Wait4(pid, nil, 0, nil); err != nil {
		fmt.Printf("wait4: %v", err)
		return err
	}
	time.Now().UnixNano()
	// 修改目标的内存
	err = modifyIoFdTargetAddr(pid, debugIoFdAddr, ioFdReleaseTargetAddr)
	if err != nil {
		fmt.Println(err)
		return err
	}

	err = modifyNetSetTargetAddr(pid, debugNetSendAddr, netSendReleaseTargetAddr)
	fmt.Println(err)
	if err != nil {
		fmt.Println(err)
		return err
	}
	// 二次效验 读取并验证地址
	_, err = jvmInjector.checkDebugFuncSymAfterChange()
	printCodeData(jvmInjector.ReleaseLibNetInfo)
	printCodeData(jvmInjector.DebugLibNetInfo)

	// 效验目标函数内地址是否与预期一致
	if !jvmInjector.validateAllModifyCheck() && err == nil {
		return err
	}
	// 更新函数入口
	err = modifyReleaseFuncEnter(pid, originFuncEnterAddr, debugFuncEnterAddr)
	if err != nil {
		fmt.Println(err)
		return err
	}
	// 校验jmp地址修改正确
	err = jvmInjector.checkReleaseFuncSymAfterChange()
	if err != nil {
		fmt.Println(err)
		if len(jvmInjector.ReleaseLibNetInfo.FuncSymbol.OriginCode) == 5 {
			err = restoreOriginalInstructions(pid, originFuncEnterAddr, jvmInjector.ReleaseLibNetInfo.FuncSymbol.OriginCode)
			if err != nil {
				fmt.Println(err)
				return err
			}
		}
	}

	// 恢复执行
	if err = syscall.PtraceDetach(pid); err != nil {
		fmt.Printf("ptrace DETACH: %v", err)
		return err
	}
	return nil
}