共识异常注入兼容方案

// ModuledataParser 通过moduledata获取运行时函数信息
type ModuledataParser interface {
    // GetFuncUintPtrByName 通过函数名获取函数起始地址
    GetFuncUintPtrByName(string) uintptr
    // GetVarUintPtrByName 通过变量名称获取变量地址
    GetVarUintPtrByName(string) uintptr
    // SupportVersions 获取当前支持的golang版本
    SupportVersions() []string
}

var (
    // parser118 支持的版本列表
    parser118SupportVersion = []string{Version118, Version119}
)

// parser118 实现了ModuledataParser接口
type parser118 struct {
    supportVersions []string
}

func NewParser118() ModuledataParser {
    return &parser118{
        supportVersions: parser118SupportVersion,
    }
}

// GetFuncUintPtrByName 通过函数名称获取函数起始地址
func (h *parser118) GetFuncUintPtrByName(name string) uintptr {
    for dataP := &firstmoduledata; dataP != nil; dataP = dataP.next {
        for i := 0; i < len(dataP.ftab); i++ {
            fp := runtime.FuncForPC(uintptr(dataP.ftab[i].entryoff) + dataP.text)
            if name == fp.Name() {
                //file, line := fp.FileLine(uintptr(dataP.filetab[i]))
                //fmt.Printf("name: %s, entry: %x, file:%s, line:%d\n", fp.Name(), fp.Entry(), file, line)
                entry := fp.Entry()
                return entry
            }
        }
    }
    return 0
}

// GetVarUintPtrByName 通过变量名称获取变量的地址
func (h *parser118) GetVarUintPtrByName(name string) uintptr {
    return 0
}

// SupportVersions 支持的版本列表
func (h *parser118) SupportVersions() []string {
    return h.supportVersions
}

// versionCtrl 版本控制器
type versionCtrl struct {
    parsers []func() ModuledataParser
}

// ChooseHackerByGoVersion 根据当前环境go版本，选择对应的hacker
func (v *versionCtrl) ChooseParserByGoVersion() ModuledataParser {
    versionParts := strings.Split(runtime.Version(), ".")
    major, _ := strconv.Atoi(versionParts[0][2:])
    minor, _ := strconv.Atoi(versionParts[1])
    if major < 1 || (major == 1 && minor < 18) {
        // 版本小于1.18
        return v.getParserByVersion(Version116)
    }
    return v.getParserByVersion(Version118)
}

func (v *versionCtrl) getParserByVersion(version string) ModuledataParser {
    for _, hack := range v.parsers {
        hacker := hack()
        versions := hacker.SupportVersions()
        for _, ver := range versions {
            if ver == version {
                return hacker
            }
        }
    }
    return nil
}

const (
    // InjectTypeFunc 注入类型为函数或者方法
    InjectTypeFunc = InjectType("func")
    // InjectTypeVar 注入类型为 变量
    InjectTypeVar = InjectType("var")
)

// InjectType 注入类型
type InjectType string

type Injection interface {
    // InjectReplacerMap 攻击函数映射: 目标函数名 => 新函数
    // 例如：main.(*person).say => {Type:"func", Replacer:attackSay()}
    InjectReplacerMap() map[string]InjectReplacer
    // ConsensusType 共识类型
    ConsensusType() consensus.Type
    // ConsensusVersion 共识版本
    ConsensusVersion() consensus.Version
}

// InjectReplacer 替换的新结构
// Type：func 时： Replacer : attackSay()
// Type: var 时：Replacer：var
type InjectReplacer struct {
    Type     InjectType
    Replacer interface{}
}

// hacker 注入攻击
type hacker interface {
    // Attack 攻击指定的函数
    Attack(targetName string)
    // Recover 撤销指定函数的攻击
    Recover(targetName string)
    // AttackingList 正在被攻击的函数列表
    AttackingList() []string
    // RecoverAll 撤销所有攻击
    RecoverAll()
}

func NewConsensusHacker(injection consensus.Injection, logger *logger.CMLogger) *consensusHacker {
    ch := &consensusHacker{
        logger: logger,
    }
    // 检查注入的共识和版本是否合法
    ty := injection.ConsensusType()
    ver := injection.ConsensusVersion()
    if !consensus.CheckTypeAndVersionValid(ty, ver) {
        ch.logger.Errorf("check type [%s] and version [%s] failed! ", ty, ver)
        return nil
    }
    ch.ConsensusInjection = injection
    // 通过版本控制器，获取合适的解析器
    versionCtrl := parser.NewVersionCtrl()
    ch.Parser = versionCtrl.ChooseParserByGoVersion()
    ch.logger.Infof("New Consensus Hacker For [%s : %s]", ty, ver)
    return ch
}

// consensusHacker 共识算法入侵
type consensusHacker struct {
    ConsensusInjection consensus.Injection
    Parser             parser.ModuledataParser
    monkeyPatches      map[string]*monkey.Patches
    logger             *logger.CMLogger
}

// Attack 攻击目标函数
func (c *consensusHacker) Attack(targetName string) {
    funcMap := c.ConsensusInjection.InjectReplacerMap()
    if f, exist := funcMap[targetName]; exist {
        var uintPtr uintptr
        switch f.Type {
        case consensus.InjectTypeFunc:
            uintPtr = c.Parser.GetFuncUintPtrByName(targetName)
            // TODO 对 f.Replacer 类型检查

        case consensus.InjectTypeVar:
            uintPtr = c.Parser.GetVarUintPtrByName(targetName)
            // TODO 对 f.Replacer 类型检查
        }
        c.monkeyPatches[targetName] = monkey.ApplyUintPtr(uintPtr, f)
    }
}

// Recover 恢复目标函数
func (c *consensusHacker) Recover(targetName string) {
    if patches, exist := c.monkeyPatches[targetName]; exist {
        patches.Reset()
        delete(c.monkeyPatches, targetName)
    }
}

// RecoverAll 恢复所有正在攻击的函数
func (c *consensusHacker) RecoverAll() {
    for _, patches := range c.monkeyPatches {
        patches.Reset()
    }
    c.monkeyPatches = make(map[string]*monkey.Patches)
}

// AttackingList 获取正在被攻击的函数名称列表
func (c *consensusHacker) AttackingList() []string {
    var names []string
    for targetName, _ := range c.monkeyPatches {
        names = append(names, targetName)
    }
    return names
}