plugins update

AdaptixServer/core/connector/connector.go

@@ -27,7 +27,7 @@ type Teamserver interface {
 	TsAgentProcessData(agentId string, bodyData []byte) error
 	TsAgentGetHostedTasks(agentId string, maxDataSize int) ([]byte, error)
 	TsAgentCommand(agentName string, agentId string, clientName string, cmdline string, args map[string]any) error
-	TsAgentGenerate(agentName string, config string, listenerWM string, listenerProfile []byte) ([]byte, string, error)
+	TsAgentGenerate(agentName string, config string, operatingSystem string, listenerWM string, listenerProfile []byte) ([]byte, string, error)
 
 	TsAgentUpdateData(newAgentObject []byte) error
 	TsAgentImpersonate(agentId string, impersonated string, elevated bool) error

AdaptixServer/core/connector/tc_agents.go

@@ -14,6 +14,7 @@ type AgentConfig struct {
 	ListenerName string `json:"listener_name"`
 	ListenerType string `json:"listener_type"`
 	AgentName    string `json:"agent"`
+	Os           string `json:"operating_system"`
 	Config       string `json:"config"`
 }
 
@@ -39,7 +40,7 @@ func (tc *TsConnector) TcAgentGenerate(ctx *gin.Context) {
 		return
 	}
 
-	fileContent, fileName, err = tc.teamserver.TsAgentGenerate(agentConfig.AgentName, agentConfig.Config, listenerWM, listenerProfile)
+	fileContent, fileName, err = tc.teamserver.TsAgentGenerate(agentConfig.AgentName, agentConfig.Config, agentConfig.Os, listenerWM, listenerProfile)
 	if err != nil {
 		ctx.JSON(http.StatusOK, gin.H{"message": err.Error(), "ok": false})
 		return

AdaptixServer/core/extender/ex_agent.go

@@ -2,170 +2,114 @@ package extender
 
 import "errors"
 
-func (ex *AdaptixExtender) ExAgentGenerate(agentName string, config string, listenerWM string, listenerProfile []byte) ([]byte, string, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentGenerate(config, listenerWM, listenerProfile)
-	} else {
+func (ex *AdaptixExtender) ExAgentGenerate(agentName string, config string, operatingSystem string, listenerWM string, listenerProfile []byte) ([]byte, string, error) {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, "", errors.New("module not found")
 	}
+	return module.AgentGenerate(config, operatingSystem, listenerWM, listenerProfile)
 }
 
 func (ex *AdaptixExtender) ExAgentCreate(agentName string, beat []byte) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentCreate(beat)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.AgentCreate(beat)
 }
 
 func (ex *AdaptixExtender) ExAgentProcessData(agentName string, agentObject []byte, packedData []byte) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentProcessData(agentObject, packedData)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.AgentProcessData(agentObject, packedData)
 }
 
 func (ex *AdaptixExtender) ExAgentPackData(agentName string, agentObject []byte, maxDataSize int) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentPackData(agentObject, maxDataSize)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.AgentPackData(agentObject, maxDataSize)
 }
 
 func (ex *AdaptixExtender) ExAgentPivotPackData(agentName string, pivotId string, data []byte) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentPivotPackData(pivotId, data)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.AgentPivotPackData(pivotId, data)
 }
 
 func (ex *AdaptixExtender) ExAgentCommand(client string, cmdline string, agentName string, agentObject []byte, args map[string]any) error {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentCommand(client, cmdline, agentObject, args)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return errors.New("module not found")
 	}
+	return module.AgentCommand(client, cmdline, agentObject, args)
 }
 
 func (ex *AdaptixExtender) ExAgentDownloadChangeState(agentName string, agentObject []byte, newState int, fileId string) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentDownloadChangeState(agentObject, newState, fileId)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.AgentDownloadChangeState(agentObject, newState, fileId)
 }
 
 func (ex *AdaptixExtender) ExAgentBrowserDisks(agentName string, agentObject []byte) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentBrowserDisks(agentObject)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.AgentBrowserDisks(agentObject)
 }
 
 func (ex *AdaptixExtender) ExAgentBrowserProcess(agentName string, agentObject []byte) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentBrowserProcess(agentObject)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.AgentBrowserProcess(agentObject)
 }
 
 func (ex *AdaptixExtender) ExAgentBrowserFiles(agentName string, path string, agentObject []byte) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentBrowserFiles(path, agentObject)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.AgentBrowserFiles(path, agentObject)
 }
 
 func (ex *AdaptixExtender) ExAgentBrowserUpload(agentName string, path string, content []byte, agentObject []byte) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentBrowserUpload(path, content, agentObject)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.AgentBrowserUpload(path, content, agentObject)
 }
 
 func (ex *AdaptixExtender) ExAgentBrowserDownload(agentName string, path string, agentObject []byte) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentBrowserDownload(path, agentObject)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.AgentBrowserDownload(path, agentObject)
 }
 
 func (ex *AdaptixExtender) ExAgentBrowserJobKill(agentName string, jobId string) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentBrowserJobKill(jobId)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.AgentBrowserJobKill(jobId)
 }
 
 func (ex *AdaptixExtender) ExAgentCtxExit(agentName string, agentObject []byte) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.agentModules.Get(agentName)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.AgentBrowserExit(agentObject)
-	} else {
+	module, ok := ex.agentModules[agentName]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.AgentBrowserExit(agentObject)
 }

AdaptixServer/core/extender/ex_listener.go

@@ -3,72 +3,45 @@ package extender
 import "errors"
 
 func (ex *AdaptixExtender) ExListenerStart(listenerName string, configType string, config string, listenerCustomData []byte) ([]byte, []byte, error) {
-	var (
-		err    error
-		module *ModuleExtender
-	)
-
-	value, ok := ex.listenerModules.Get(configType)
-	if ok {
-		module = value.(*ModuleExtender)
-		err = module.ListenerValid(config)
-		if err != nil {
-			return nil, nil, err
-		}
-		return module.ListenerStart(listenerName, config, listenerCustomData)
-
-	} else {
+	module, ok := ex.listenerModules[configType]
+	if !ok {
 		return nil, nil, errors.New("module not found")
 	}
+	err := module.ListenerValid(config)
+	if err != nil {
+		return nil, nil, err
+	}
+	return module.ListenerStart(listenerName, config, listenerCustomData)
 }
 
 func (ex *AdaptixExtender) ExListenerStop(listenerName string, configType string) error {
-	var module *ModuleExtender
-
-	value, ok := ex.listenerModules.Get(configType)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.ListenerStop(listenerName)
-
-	} else {
+	module, ok := ex.listenerModules[configType]
+	if !ok {
 		return errors.New("module not found")
 	}
+	return module.ListenerStop(listenerName)
 }
 
 func (ex *AdaptixExtender) ExListenerEdit(listenerName string, configType string, config string) ([]byte, []byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.listenerModules.Get(configType)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.ListenerEdit(listenerName, config)
-
-	} else {
+	module, ok := ex.listenerModules[configType]
+	if !ok {
 		return nil, nil, errors.New("module not found")
 	}
+	return module.ListenerEdit(listenerName, config)
 }
 
 func (ex *AdaptixExtender) ExListenerGetProfile(listenerName string, configType string) ([]byte, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.listenerModules.Get(configType)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.ListenerGetProfile(listenerName)
-
-	} else {
+	module, ok := ex.listenerModules[configType]
+	if !ok {
 		return nil, errors.New("module not found")
 	}
+	return module.ListenerGetProfile(listenerName)
 }
 
 func (ex *AdaptixExtender) ExListenerInteralHandler(listenerName string, configType string, data []byte) (string, error) {
-	var module *ModuleExtender
-
-	value, ok := ex.listenerModules.Get(configType)
-	if ok {
-		module = value.(*ModuleExtender)
-		return module.ListenerInteralHandler(listenerName, data)
-	} else {
+	module, ok := ex.listenerModules[configType]
+	if !ok {
 		return "", errors.New("module not found")
 	}
+	return module.ListenerInteralHandler(listenerName, data)
 }

AdaptixServer/core/extender/extender.go

@@ -2,237 +2,171 @@ package extender
 
 import (
 	"AdaptixServer/core/utils/logs"
-	"AdaptixServer/core/utils/safe"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 	"plugin"
-	"reflect"
 )
 
 func NewExtender(teamserver Teamserver) *AdaptixExtender {
 	return &AdaptixExtender{
 		ts:              teamserver,
-		listenerModules: safe.NewMap(),
-		agentModules:    safe.NewMap(),
+		listenerModules: make(map[string]ExtListener),
+		agentModules:    make(map[string]ExtAgent),
 	}
 }
 
 func (ex *AdaptixExtender) LoadPlugins(extenderFiles []string) {
-	var (
-		pl     *plugin.Plugin
-		object plugin.Symbol
-		err    error
-	)
 
 	for _, path := range extenderFiles {
 
-		_, err = os.Stat(path)
+		_, err := os.Stat(path)
 		if err != nil {
-			logs.Error("", "Plugin %s not found", path)
+			logs.Error("", "Config %s not found", path)
+			continue
+		}
+		config_data, err := os.ReadFile(path)
+		if err != nil {
+			logs.Error("", "Read file %s error: %s", path, err.Error())
 			continue
 		}
 
-		pl, err = plugin.Open(path)
+		var config_map map[string]any
+		err = json.Unmarshal(config_data, &config_map)
 		if err != nil {
-			logs.Error("", "Plugin %s did not load: %s", path, err.Error())
+			logs.Error("", "Error config %s parse: %s", path, err.Error())
+			continue
+		}
+		extender_type, ok_type := config_map["extender_type"].(string)
+		if !ok_type {
+			logs.Error("", "Error config %s parse: extender_type not found", path)
 			continue
 		}
 
-		object, err = pl.Lookup("ModuleObject")
-		if err != nil {
-			logs.Error("", "Object %s not found in %s", "ModuleObject", path)
-			continue
-		}
-
-		_, ok := reflect.TypeOf(object).MethodByName("InitPlugin")
-		if !ok {
-			logs.Error("", "Method %s not found in %s", "InitPlugin", path)
-			continue
-		}
-
-		buffer, err := object.(CommonFunctions).InitPlugin(ex.ts)
-		if err != nil {
-			logs.Error("", "InitPlugin %s failed: %s", path, err.Error())
-			continue
-		}
-
-		var module = new(ModuleExtender)
-
-		err = json.Unmarshal(buffer, &module.Info)
-		if err != nil {
-			logs.Error("", "InitPlugin JSON Unmarshal error: "+err.Error())
-			continue
-		}
-
-		err = ex.ValidPlugin(module.Info, object)
-		if err != nil {
-			logs.Error("", "InitPlugin %s failed: %s", path, err.Error())
-			continue
-		}
-
-		absPluginPath, err := filepath.Abs(path)
-		pluginDir := filepath.Dir(absPluginPath)
-
-		err = ex.ProcessPlugin(module, object, pluginDir)
-		if err != nil {
-			logs.Error("", "InitPlugin %s failed: %s", path, err.Error())
-			continue
+		if extender_type == "listener" {
+			ex.LoadPluginListener(path, config_data)
+		} else if extender_type == "agent" {
+			ex.LoadPluginAgent(path, config_data)
+		} else {
+			logs.Error("", "Unknown extender_type in %s", path)
 		}
 	}
 }
 
-func (ex *AdaptixExtender) ValidPlugin(info ModuleInfo, object plugin.Symbol) error {
-	if info.ModuleType == TYPE_LISTENER {
-		_, ok := reflect.TypeOf(object).MethodByName("ListenerInit")
-		if !ok {
-			return errors.New("method ListenerInit not found")
-		}
-
-		_, ok = reflect.TypeOf(object).MethodByName("ListenerStart")
-		if !ok {
-			return errors.New("method ListenerStart not found")
-		}
-
-		_, ok = reflect.TypeOf(object).MethodByName("ListenerValid")
-		if !ok {
-			return errors.New("method ListenerValid not found")
-		}
-
-		_, ok = reflect.TypeOf(object).MethodByName("ListenerStop")
-		if !ok {
-			return errors.New("method ListenerStop not found")
-		}
-
-		_, ok = reflect.TypeOf(object).MethodByName("ListenerGetProfile")
-		if !ok {
-			return errors.New("method ListenerGetProfile not found")
-		}
-		return nil
+func (ex *AdaptixExtender) LoadPluginListener(config_path string, config_data []byte) {
+	var configListener ExConfigListener
+	err := json.Unmarshal(config_data, &configListener)
+	if err != nil {
+		logs.Error("", "Error config parse: %s", err.Error())
+		return
 	}
 
-	if info.ModuleType == TYPE_AGENT {
-		_, ok := reflect.TypeOf(object).MethodByName("AgentInit")
-		if !ok {
-			return errors.New("method AgentInit not found")
-		}
-
-		_, ok = reflect.TypeOf(object).MethodByName("AgentGenerate")
-		if !ok {
-			return errors.New("method AgentGenerate not found")
-		}
-
-		_, ok = reflect.TypeOf(object).MethodByName("AgentCreate")
-		if !ok {
-			return errors.New("method AgentCreate not found")
-		}
-
-		_, ok = reflect.TypeOf(object).MethodByName("AgentProcessData")
-		if !ok {
-			return errors.New("method AgentProcessData not found")
-		}
-
-		_, ok = reflect.TypeOf(object).MethodByName("AgentPackData")
-		if !ok {
-			return errors.New("method AgentPackData not found")
-		}
-		_, ok = reflect.TypeOf(object).MethodByName("AgentCommand")
-		if !ok {
-			return errors.New("method AgentCommand not found")
-		}
-		_, ok = reflect.TypeOf(object).MethodByName("AgentDownloadChangeState")
-		if !ok {
-			return errors.New("method AgentDownloadChangeState not found")
-		}
-		_, ok = reflect.TypeOf(object).MethodByName("AgentBrowserDisks")
-		if !ok {
-			return errors.New("method AgentBrowserDisks not found")
-		}
-		_, ok = reflect.TypeOf(object).MethodByName("AgentBrowserProcess")
-		if !ok {
-			return errors.New("method AgentBrowserProcess not found")
-		}
-		_, ok = reflect.TypeOf(object).MethodByName("AgentBrowserFiles")
-		if !ok {
-			return errors.New("method AgentBrowserFiles not found")
-		}
-		_, ok = reflect.TypeOf(object).MethodByName("AgentBrowserUpload")
-		if !ok {
-			return errors.New("method AgentBrowserUpload not found")
-		}
-		_, ok = reflect.TypeOf(object).MethodByName("AgentBrowserDownload")
-		if !ok {
-			return errors.New("method AgentBrowserDownload not found")
-		}
-		_, ok = reflect.TypeOf(object).MethodByName("AgentBrowserJobKill")
-		if !ok {
-			return errors.New("method AgentBrowserJobKill not found")
-		}
-		_, ok = reflect.TypeOf(object).MethodByName("AgentBrowserExit")
-		if !ok {
-			return errors.New("method AgentBrowserExit not found")
-		}
-
-		return nil
+	listenerUI, err := json.Marshal(configListener.UI)
+	if err != nil {
+		logs.Error("", "Error %s converting info to JSON: %s", config_path, err.Error())
+		return
 	}
 
-	return errors.New("unknown modules type: " + info.ModuleType)
+	listenerInfo := ListenerInfo{
+		Name:     configListener.ListenerName,
+		Type:     configListener.ListenerType,
+		Protocol: configListener.Protocol,
+		UI:       string(listenerUI),
+	}
+
+	plugin_path := filepath.Dir(config_path) + "/" + configListener.ExtenderFile
+	plug, err := plugin.Open(plugin_path)
+	if err != nil {
+		logs.Error("", "failed to open plugin %s: %s", plugin_path, err.Error())
+		return
+	}
+
+	sym, err := plug.Lookup("InitPlugin")
+	if err != nil {
+		logs.Error("", "failed to find InitPlugin in %s: %s", plugin_path, err.Error())
+		return
+	}
+
+	pl_InitPlugin, ok := sym.(func(ts any, moduleDir string, listenerDir string) any)
+	if !ok {
+		logs.Error("", "unexpected signature from InitPlugin in %s", plugin_path)
+		return
+	}
+
+	module, ok := pl_InitPlugin(ex.ts, filepath.Dir(plugin_path), logs.RepoLogsInstance.ListenerPath).(ExtListener)
+	if !ok {
+		logs.Error("", "plugin %s does not implement the ExtListener interface", plugin_path)
+		return
+	}
+
+	err = ex.ts.TsListenerReg(listenerInfo)
+	if err != nil {
+		logs.Error("", "plugin %s does not registered: %s", plugin_path, err.Error())
+		return
+	}
+
+	listenerFN := fmt.Sprintf("%v/%v/%v", listenerInfo.Type, listenerInfo.Protocol, listenerInfo.Name)
+	ex.listenerModules[listenerFN] = module
 }
 
-func (ex *AdaptixExtender) ProcessPlugin(module *ModuleExtender, object plugin.Symbol, pluginPath string) error {
-
-	if module.Info.ModuleType == TYPE_LISTENER {
-		buffer, err := object.(ListenerFunctions).ListenerInit(pluginPath, logs.RepoLogsInstance.ListenerPath)
-		if err != nil {
-			return err
-		}
-
-		var listenerInfo ListenerInfo
-		err = json.Unmarshal(buffer, &listenerInfo)
-		if err != nil {
-			logs.Error("", "ProcessPlugin JSON Unmarshal error: "+err.Error())
-			return err
-		}
-
-		err = ex.ts.TsListenerReg(listenerInfo)
-		if err != nil {
-			return err
-		}
-
-		module.ListenerFunctions = object.(ListenerFunctions)
-
-		listenerFN := fmt.Sprintf("%v/%v/%v", listenerInfo.Type, listenerInfo.ListenerProtocol, listenerInfo.ListenerName)
-		ex.listenerModules.Put(listenerFN, module)
-
-		return nil
+func (ex *AdaptixExtender) LoadPluginAgent(config_path string, config_data []byte) {
+	var configAgent ExConfigAgent
+	err := json.Unmarshal(config_data, &configAgent)
+	if err != nil {
+		logs.Error("", "Error config parse: %s", err.Error())
+		return
 	}
 
-	if module.Info.ModuleType == TYPE_AGENT {
-		buffer, err := object.(AgentFunctions).AgentInit(pluginPath)
-		if err != nil {
-			return err
-		}
-
-		var agentInfo AgentInfo
-		err = json.Unmarshal(buffer, &agentInfo)
-		if err != nil {
-			logs.Error("", "ProcessPlugin JSON Unmarshal error: "+err.Error())
-			return err
-		}
-
-		err = ex.ts.TsAgentReg(agentInfo)
-		if err != nil {
-			return err
-		}
-
-		module.AgentFunctions = object.(AgentFunctions)
-
-		ex.agentModules.Put(agentInfo.AgentName, module)
-
-		return nil
+	commandsJson, err := json.Marshal(configAgent.Commands)
+	if err != nil {
+		logs.Error("", "Error %s converting info to JSON: %s", config_path, err.Error())
+		return
 	}
 
-	return errors.New("unknown modules type: " + module.Info.ModuleType)
+	listenersJson, err := json.Marshal(configAgent.Listeners)
+	if err != nil {
+		logs.Error("", "Error %s converting info to JSON: %s", config_path, err.Error())
+		return
+	}
+
+	agentInfo := AgentInfo{
+		Name:          configAgent.AgentName,
+		Watermark:     configAgent.AgentWatermark,
+		ListenersJson: string(listenersJson),
+		CommandsJson:  string(commandsJson),
+	}
+
+	plugin_path := filepath.Dir(config_path) + "/" + configAgent.ExtenderFile
+	plug, err := plugin.Open(plugin_path)
+	if err != nil {
+		logs.Error("", "failed to open plugin %s: %s", plugin_path, err.Error())
+		return
+	}
+
+	sym, err := plug.Lookup("InitPlugin")
+	if err != nil {
+		logs.Error("", "failed to find InitPlugin in %s: %s", plugin_path, err.Error())
+		return
+	}
+
+	pl_InitPlugin, ok := sym.(func(ts any, moduleDir string, watermark string) any)
+	if !ok {
+		logs.Error("", "unexpected signature from InitPlugin in %s", plugin_path)
+		return
+	}
+
+	module, ok := pl_InitPlugin(ex.ts, filepath.Dir(plugin_path), agentInfo.Watermark).(ExtAgent)
+	if !ok {
+		logs.Error("", "plugin %s does not implement the ExtAgent interface", plugin_path)
+		return
+	}
+
+	err = ex.ts.TsAgentReg(agentInfo)
+	if err != nil {
+		logs.Error("", "plugin %s does not registered: %s", plugin_path, err.Error())
+		return
+	}
+
+	ex.agentModules[agentInfo.Name] = module
 }

AdaptixServer/core/extender/utils.go

@@ -1,29 +1,51 @@
 package extender
 
-import "AdaptixServer/core/utils/safe"
+/// ExConfig Listener
 
-const (
-	TYPE_LISTENER = "listener"
-	TYPE_AGENT    = "agent"
-)
-
-type ModuleInfo struct {
-	ModuleName string
-	ModuleType string
+type ExConfigListener struct {
+	ExtenderType string `json:"extender_type"`
+	ExtenderFile string `json:"extender_file"`
+	ListenerName string `json:"listener_name"`
+	ListenerType string `json:"listener_type"`
+	Protocol     string `json:"protocol"`
+	UI           any    `json:"ui"`
 }
 
+/// ExConfig Agent
+
+type ExConfAgentOsConfigs struct {
+	Os string `json:"operating_system"`
+	Ui any    `json:"ui"`
+}
+
+type ExConfAgentUI struct {
+	ListenerName string                 `json:"listener_name"`
+	OsConfigs    []ExConfAgentOsConfigs `json:"os_configs"`
+}
+
+type ExConfigAgent struct {
+	ExtenderType   string          `json:"extender_type"`
+	ExtenderFile   string          `json:"extender_file"`
+	AgentName      string          `json:"agent_name"`
+	AgentWatermark string          `json:"agent_watermark"`
+	Listeners      []ExConfAgentUI `json:"listeners"`
+	Commands       any             `json:"commands"`
+}
+
+/// Info
+
 type ListenerInfo struct {
-	Type             string
-	ListenerProtocol string
-	ListenerName     string
-	ListenerUI       string
+	Name     string
+	Protocol string
+	Type     string
+	UI       string
 }
 
 type AgentInfo struct {
-	AgentName    string
-	ListenerName []string
-	AgentUI      string
-	AgentCmd     string
+	Name          string
+	Watermark     string
+	ListenersJson string
+	CommandsJson  string
 }
 
 type Teamserver interface {
@@ -31,12 +53,7 @@ type Teamserver interface {
 	TsAgentReg(agentInfo AgentInfo) error
 }
 
-type CommonFunctions interface {
-	InitPlugin(ts any) ([]byte, error)
-}
-
-type ListenerFunctions interface {
-	ListenerInit(pluginPath string, listenerDataPath string) ([]byte, error)
+type ExtListener interface {
 	ListenerValid(config string) error
 	ListenerStart(name string, data string, listenerCustomData []byte) ([]byte, []byte, error)
 	ListenerEdit(name string, data string) ([]byte, []byte, error)
@@ -45,9 +62,8 @@ type ListenerFunctions interface {
 	ListenerInteralHandler(name string, data []byte) (string, error)
 }
 
-type AgentFunctions interface {
-	AgentInit(pluginPath string) ([]byte, error)
-	AgentGenerate(config string, listenerWM string, listenerProfile []byte) ([]byte, string, error)
+type ExtAgent interface {
+	AgentGenerate(config string, operatingSystem string, listenerWM string, listenerProfile []byte) ([]byte, string, error)
 	AgentCreate(beat []byte) ([]byte, error)
 	AgentProcessData(agentObject []byte, packedData []byte) ([]byte, error)
 	AgentPackData(agentObject []byte, maxDataSize int) ([]byte, error)
@@ -64,15 +80,8 @@ type AgentFunctions interface {
 	AgentBrowserExit(agentObject []byte) ([]byte, error)
 }
 
-type ModuleExtender struct {
-	Info ModuleInfo
-	CommonFunctions
-	ListenerFunctions
-	AgentFunctions
-}
-
 type AdaptixExtender struct {
 	ts              Teamserver
-	listenerModules safe.Map
-	agentModules    safe.Map
+	listenerModules map[string]ExtListener
+	agentModules    map[string]ExtAgent
 }

AdaptixServer/core/server/ts_agent.go

@@ -519,8 +519,8 @@ func (ts *Teamserver) TsAgentTickUpdate() {
 	}
 }
 
-func (ts *Teamserver) TsAgentGenerate(agentName string, config string, listenerWM string, listenerProfile []byte) ([]byte, string, error) {
-	return ts.Extender.ExAgentGenerate(agentName, config, listenerWM, listenerProfile)
+func (ts *Teamserver) TsAgentGenerate(agentName string, config string, operatingSystem string, listenerWM string, listenerProfile []byte) ([]byte, string, error) {
+	return ts.Extender.ExAgentGenerate(agentName, config, operatingSystem, listenerWM, listenerProfile)
 }
 
 /// Console

AdaptixServer/core/server/ts_plugins.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"AdaptixServer/core/extender"
-	"AdaptixServer/core/utils/krypt"
 	isvalid "AdaptixServer/core/utils/valid"
 	"errors"
 	"fmt"
@@ -14,15 +13,15 @@ func (ts *Teamserver) TsListenerReg(listenerInfo extender.ListenerInfo) error {
 		return errors.New("invalid listener type: must be internal or external")
 	}
 
-	if !isvalid.ValidSBNString(listenerInfo.ListenerProtocol) {
-		return errors.New("invalid listener protocol (must only contain letters and numbers): " + listenerInfo.ListenerProtocol)
+	if !isvalid.ValidSBNString(listenerInfo.Protocol) {
+		return errors.New("invalid listener protocol (must only contain letters and numbers): " + listenerInfo.Protocol)
 	}
 
-	if !isvalid.ValidSBNString(listenerInfo.ListenerName) {
+	if !isvalid.ValidSBNString(listenerInfo.Name) {
 		return errors.New("invalid listener name (must only contain letters and numbers): " + listenerInfo.Type)
 	}
 
-	listenerFN := fmt.Sprintf("%v/%v/%v", listenerInfo.Type, listenerInfo.ListenerProtocol, listenerInfo.ListenerName)
+	listenerFN := fmt.Sprintf("%v/%v/%v", listenerInfo.Type, listenerInfo.Protocol, listenerInfo.Name)
 
 	if ts.listener_configs.Contains(listenerFN) {
 		return fmt.Errorf("listener %v already exists", listenerFN)
@@ -34,14 +33,17 @@ func (ts *Teamserver) TsListenerReg(listenerInfo extender.ListenerInfo) error {
 }
 
 func (ts *Teamserver) TsAgentReg(agentInfo extender.AgentInfo) error {
-	if ts.agent_configs.Contains(agentInfo.AgentName) {
-		return fmt.Errorf("agent %v already exists", agentInfo.AgentName)
-	}
-	agentCrc := krypt.CRC32([]byte(agentInfo.AgentName))
-	agentMark := fmt.Sprintf("%08x", agentCrc)
 
-	ts.wm_agent_types[agentMark] = agentInfo.AgentName
-	ts.agent_configs.Put(agentInfo.AgentName, agentInfo)
+	if ts.agent_configs.Contains(agentInfo.Name) {
+		return fmt.Errorf("agent %v already exists", agentInfo.Name)
+	}
+
+	if !isvalid.ValidHex8(agentInfo.Watermark) {
+		return fmt.Errorf("agent %s has invalid watermark %s... must be 8 digit hex value", agentInfo.Name, agentInfo.Watermark)
+	}
+
+	ts.wm_agent_types[agentInfo.Watermark] = agentInfo.Name
+	ts.agent_configs.Put(agentInfo.Name, agentInfo)
 
 	return nil
 }

AdaptixServer/core/server/ts_sync.go

@@ -94,16 +94,18 @@ func (ts *Teamserver) TsPresyncExtenders() []interface{} {
 	var packets []interface{}
 	ts.listener_configs.ForEach(func(key string, value interface{}) bool {
 		listenerInfo := value.(extender.ListenerInfo)
-		p := CreateSpListenerReg(key, listenerInfo.ListenerUI)
+		p := CreateSpListenerReg(key, listenerInfo.UI)
 		packets = append(packets, p)
 		return true
 	})
+
 	ts.agent_configs.ForEach(func(key string, value interface{}) bool {
 		agentInfo := value.(extender.AgentInfo)
-		p := CreateSpAgentReg(key, agentInfo.ListenerName, agentInfo.AgentUI, agentInfo.AgentCmd)
+		p := CreateSpAgentReg(agentInfo.Name, agentInfo.Watermark, agentInfo.ListenersJson, agentInfo.CommandsJson)
 		packets = append(packets, p)
 		return true
 	})
+
 	return packets
 }
 

AdaptixServer/core/server/ts_syncpacket.go

@@ -131,14 +131,14 @@ func CreateSpListenerStop(name string) SyncPackerListenerStop {
 
 /// AGENT
 
-func CreateSpAgentReg(agent string, listeners []string, ui string, cmd string) SyncPackerAgentReg {
+func CreateSpAgentReg(agent string, watermark string, listenersJson string, commandsJson string) SyncPackerAgentReg {
 	return SyncPackerAgentReg{
 		SpType: TYPE_AGENT_REG,
 
-		Agent:     agent,
-		Listeners: listeners,
-		AgentUI:   ui,
-		AgentCmd:  cmd,
+		Agent:         agent,
+		Watermark:     watermark,
+		ListenersJson: listenersJson,
+		CommandsJson:  commandsJson,
 	}
 }
 

AdaptixServer/core/server/utils.go

@@ -156,10 +156,10 @@ type SyncPackerListenerStop struct {
 type SyncPackerAgentReg struct {
 	SpType int `json:"type"`
 
-	Agent     string   `json:"agent"`
-	Listeners []string `json:"listener"`
-	AgentUI   string   `json:"ui"`
-	AgentCmd  string   `json:"cmd"`
+	Agent         string `json:"agent"`
+	Watermark     string `json:"watermark"`
+	ListenersJson string `json:"listeners_json"`
+	CommandsJson  string `json:"commands_json"`
 }
 
 type SyncPackerAgentNew struct {