768 lines
19 KiB
Go
768 lines
19 KiB
Go
package server
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/Adaptix-Framework/axc2"
|
|
)
|
|
|
|
const (
|
|
SP_TYPE_NOTIFICATION = 0x13
|
|
)
|
|
|
|
const (
|
|
NOTIFY_CLIENT_CONNECT = 1
|
|
NOTIFY_CLIENT_DISCONNECT = 2
|
|
NOTIFY_LISTENER_START = 3
|
|
NOTIFY_LISTENER_STOP = 4
|
|
NOTIFY_AGENT_NEW = 5
|
|
NOTIFY_TUNNEL_START = 6
|
|
NOTIFY_TUNNEL_STOP = 7
|
|
)
|
|
|
|
const (
|
|
TYPE_SYNC_START = 0x11
|
|
TYPE_SYNC_FINISH = 0x12
|
|
TYPE_SYNC_BATCH = 0x14
|
|
TYPE_SYNC_CATEGORY_BATCH = 0x15
|
|
|
|
TYPE_CHAT_MESSAGE = 0x18
|
|
TYPE_SERVICE_DATA = 0x19
|
|
|
|
TYPE_LISTENER_REG = 0x21
|
|
TYPE_AGENT_REG = 0x22
|
|
TYPE_SERVICE_REG = 0x23
|
|
|
|
TYPE_LISTENER_START = 0x31
|
|
TYPE_LISTENER_EDIT = 0x32
|
|
TYPE_LISTENER_STOP = 0x33
|
|
|
|
TYPE_AGENT_NEW = 0x41
|
|
TYPE_AGENT_UPDATE = 0x42
|
|
TYPE_AGENT_REMOVE = 0x43
|
|
TYPE_AGENT_TICK = 0x44
|
|
TYPE_AGENT_LINK = 0x45
|
|
|
|
TYPE_AGENT_TASK_SYNC = 0x49
|
|
TYPE_AGENT_TASK_UPDATE = 0x4a
|
|
TYPE_AGENT_TASK_SEND = 0x4b
|
|
TYPE_AGENT_TASK_REMOVE = 0x4c
|
|
TYPE_AGENT_TASK_HOOK = 0x4d
|
|
|
|
TYPE_DOWNLOAD_CREATE = 0x51
|
|
TYPE_DOWNLOAD_UPDATE = 0x52
|
|
TYPE_DOWNLOAD_DELETE = 0x53
|
|
TYPE_DOWNLOAD_ACTUAL = 0x54
|
|
|
|
TYPE_TUNNEL_CREATE = 0x57
|
|
TYPE_TUNNEL_EDIT = 0x58
|
|
TYPE_TUNNEL_DELETE = 0x59
|
|
|
|
TYPE_SCREEN_CREATE = 0x5b
|
|
TYPE_SCREEN_UPDATE = 0x5c
|
|
TYPE_SCREEN_DELETE = 0x5d
|
|
|
|
TYPE_BROWSER_DISKS = 0x61
|
|
TYPE_BROWSER_FILES = 0x62
|
|
TYPE_BROWSER_FILES_STATUS = 0x63
|
|
TYPE_BROWSER_PROCESS = 0x64
|
|
|
|
TYPE_AGENT_CONSOLE_LOCAL = 0x67
|
|
TYPE_AGENT_CONSOLE_ERROR = 0x68
|
|
TYPE_AGENT_CONSOLE_OUT = 0x69
|
|
TYPE_AGENT_CONSOLE_TASK_SYNC = 0x6a
|
|
TYPE_AGENT_CONSOLE_TASK_UPD = 0x6b
|
|
|
|
TYPE_PIVOT_CREATE = 0x71
|
|
TYPE_PIVOT_DELETE = 0x72
|
|
|
|
TYPE_CREDS_CREATE = 0x81
|
|
TYPE_CREDS_EDIT = 0x82
|
|
TYPE_CREDS_DELETE = 0x83
|
|
TYPE_CREDS_SET_TAG = 0x84
|
|
|
|
TYPE_TARGETS_CREATE = 0x87
|
|
TYPE_TARGETS_EDIT = 0x88
|
|
TYPE_TARGETS_DELETE = 0x89
|
|
TYPE_TARGETS_SET_TAG = 0x8a
|
|
|
|
TYPE_AXSCRIPT_COMMANDS = 0x91
|
|
)
|
|
|
|
func CreateSpNotification(notifyType int, message string) SpNotification {
|
|
return SpNotification{
|
|
Type: SP_TYPE_NOTIFICATION,
|
|
|
|
NotifyType: notifyType,
|
|
Message: message,
|
|
Date: time.Now().UTC().Unix(),
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/// SYNC
|
|
|
|
func CreateSpSyncStart(count int, addrs []string) SyncPackerStart {
|
|
return SyncPackerStart{
|
|
SpType: TYPE_SYNC_START,
|
|
|
|
Count: count,
|
|
Addresses: addrs,
|
|
}
|
|
}
|
|
|
|
func CreateSpSyncFinish() SyncPackerFinish {
|
|
return SyncPackerFinish{
|
|
SpType: TYPE_SYNC_FINISH,
|
|
}
|
|
}
|
|
|
|
func CreateSpSyncBatch(packets []interface{}) SyncPackerBatch {
|
|
return SyncPackerBatch{
|
|
SpType: TYPE_SYNC_BATCH,
|
|
Packets: packets,
|
|
}
|
|
}
|
|
|
|
func CreateSpSyncCategoryBatch(category string, packets []interface{}) SyncPackerCategoryBatch {
|
|
return SyncPackerCategoryBatch{
|
|
SpType: TYPE_SYNC_CATEGORY_BATCH,
|
|
Category: category,
|
|
Packets: packets,
|
|
}
|
|
}
|
|
|
|
/// LISTENER
|
|
|
|
func CreateSpListenerReg(name string, protocol string, l_type string, ax string) SyncPackerListenerReg {
|
|
return SyncPackerListenerReg{
|
|
SpType: TYPE_LISTENER_REG,
|
|
|
|
Name: name,
|
|
Protocol: protocol,
|
|
Type: l_type,
|
|
AX: ax,
|
|
}
|
|
}
|
|
|
|
func CreateSpListenerStart(listenerData adaptix.ListenerData) SyncPackerListenerStart {
|
|
return SyncPackerListenerStart{
|
|
SpType: TYPE_LISTENER_START,
|
|
|
|
ListenerName: listenerData.Name,
|
|
ListenerRegName: listenerData.RegName,
|
|
ListenerProtocol: listenerData.Protocol,
|
|
ListenerType: listenerData.Type,
|
|
BindHost: listenerData.BindHost,
|
|
BindPort: listenerData.BindPort,
|
|
AgentAddrs: listenerData.AgentAddr,
|
|
CreateTime: listenerData.CreateTime,
|
|
ListenerStatus: listenerData.Status,
|
|
Data: listenerData.Data,
|
|
}
|
|
}
|
|
|
|
func CreateSpListenerEdit(listenerData adaptix.ListenerData) SyncPackerListenerStart {
|
|
packet := CreateSpListenerStart(listenerData)
|
|
packet.SpType = TYPE_LISTENER_EDIT
|
|
return packet
|
|
}
|
|
|
|
func CreateSpListenerStop(name string) SyncPackerListenerStop {
|
|
return SyncPackerListenerStop{
|
|
SpType: TYPE_LISTENER_STOP,
|
|
|
|
ListenerName: name,
|
|
}
|
|
}
|
|
|
|
/// AGENT
|
|
|
|
func CreateSpAgentReg(agent string, ax string, listeners []string, multiListeners bool, groups []AxCommandBatch) SyncPackerAgentReg {
|
|
return SyncPackerAgentReg{
|
|
SpType: TYPE_AGENT_REG,
|
|
|
|
Agent: agent,
|
|
AX: ax,
|
|
Listeners: listeners,
|
|
MultiListeners: multiListeners,
|
|
Groups: groups,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentNew(agentData adaptix.AgentData) SyncPackerAgentNew {
|
|
return SyncPackerAgentNew{
|
|
SpType: TYPE_AGENT_NEW,
|
|
|
|
Id: agentData.Id,
|
|
Name: agentData.Name,
|
|
Listener: agentData.Listener,
|
|
Async: agentData.Async,
|
|
ExternalIP: agentData.ExternalIP,
|
|
InternalIP: agentData.InternalIP,
|
|
GmtOffset: agentData.GmtOffset,
|
|
WorkingTime: agentData.WorkingTime,
|
|
KillDate: agentData.KillDate,
|
|
Sleep: agentData.Sleep,
|
|
Jitter: agentData.Jitter,
|
|
ACP: agentData.ACP,
|
|
OemCP: agentData.OemCP,
|
|
Pid: agentData.Pid,
|
|
Tid: agentData.Tid,
|
|
Arch: agentData.Arch,
|
|
Elevated: agentData.Elevated,
|
|
Process: agentData.Process,
|
|
Os: agentData.Os,
|
|
OsDesc: agentData.OsDesc,
|
|
Domain: agentData.Domain,
|
|
Computer: agentData.Computer,
|
|
Username: agentData.Username,
|
|
Impersonated: agentData.Impersonated,
|
|
LastTick: agentData.LastTick,
|
|
CreateTime: agentData.CreateTime,
|
|
Tags: agentData.Tags,
|
|
Mark: agentData.Mark,
|
|
Color: agentData.Color,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentUpdate(agentData adaptix.AgentData) SyncPackerAgentUpdate {
|
|
return SyncPackerAgentUpdate{
|
|
SpType: TYPE_AGENT_UPDATE,
|
|
|
|
Id: agentData.Id,
|
|
Sleep: &agentData.Sleep,
|
|
Jitter: &agentData.Jitter,
|
|
WorkingTime: &agentData.WorkingTime,
|
|
KillDate: &agentData.KillDate,
|
|
Impersonated: &agentData.Impersonated,
|
|
Tags: &agentData.Tags,
|
|
Mark: &agentData.Mark,
|
|
Color: &agentData.Color,
|
|
InternalIP: &agentData.InternalIP,
|
|
ExternalIP: &agentData.ExternalIP,
|
|
GmtOffset: &agentData.GmtOffset,
|
|
ACP: &agentData.ACP,
|
|
OemCP: &agentData.OemCP,
|
|
Pid: &agentData.Pid,
|
|
Tid: &agentData.Tid,
|
|
Arch: &agentData.Arch,
|
|
Elevated: &agentData.Elevated,
|
|
Process: &agentData.Process,
|
|
Os: &agentData.Os,
|
|
OsDesc: &agentData.OsDesc,
|
|
Domain: &agentData.Domain,
|
|
Computer: &agentData.Computer,
|
|
Username: &agentData.Username,
|
|
Listener: &agentData.Listener,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentTick(agents []string) SyncPackerAgentTick {
|
|
return SyncPackerAgentTick{
|
|
SpType: TYPE_AGENT_TICK,
|
|
|
|
Id: agents,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentRemove(agentId string) SyncPackerAgentRemove {
|
|
return SyncPackerAgentRemove{
|
|
SpType: TYPE_AGENT_REMOVE,
|
|
|
|
AgentId: agentId,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentTaskSync(taskData adaptix.TaskData) SyncPackerAgentTaskSync {
|
|
return SyncPackerAgentTaskSync{
|
|
SpType: TYPE_AGENT_TASK_SYNC,
|
|
|
|
AgentId: taskData.AgentId,
|
|
TaskId: taskData.TaskId,
|
|
StartTime: taskData.StartDate,
|
|
CmdLine: taskData.CommandLine,
|
|
TaskType: taskData.Type,
|
|
Client: taskData.Client,
|
|
User: taskData.User,
|
|
Computer: taskData.Computer,
|
|
FinishTime: taskData.FinishDate,
|
|
MessageType: taskData.MessageType,
|
|
Message: taskData.Message,
|
|
Text: taskData.ClearText,
|
|
Completed: taskData.Completed,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentTaskUpdate(taskData adaptix.TaskData) SyncPackerAgentTaskUpdate {
|
|
return SyncPackerAgentTaskUpdate{
|
|
SpType: TYPE_AGENT_TASK_UPDATE,
|
|
|
|
AgentId: taskData.AgentId,
|
|
TaskId: taskData.TaskId,
|
|
TaskType: taskData.Type,
|
|
FinishTime: taskData.FinishDate,
|
|
MessageType: taskData.MessageType,
|
|
Message: taskData.Message,
|
|
Text: taskData.ClearText,
|
|
Completed: taskData.Completed,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentTaskSend(tasksId []string) SyncPackerAgentTaskSend {
|
|
return SyncPackerAgentTaskSend{
|
|
SpType: TYPE_AGENT_TASK_SEND,
|
|
|
|
TaskId: tasksId,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentTaskRemove(taskData adaptix.TaskData) SyncPackerAgentTaskRemove {
|
|
return SyncPackerAgentTaskRemove{
|
|
SpType: TYPE_AGENT_TASK_REMOVE,
|
|
|
|
TaskId: taskData.TaskId,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentTaskHook(taskData adaptix.TaskData, jobIndex int) SyncPackerAgentTaskHook {
|
|
return SyncPackerAgentTaskHook{
|
|
SpType: TYPE_AGENT_TASK_HOOK,
|
|
|
|
AgentId: taskData.AgentId,
|
|
TaskId: taskData.TaskId,
|
|
HookId: taskData.HookId,
|
|
JobIndex: jobIndex,
|
|
MessageType: taskData.MessageType,
|
|
Message: taskData.Message,
|
|
Text: taskData.ClearText,
|
|
Completed: taskData.Completed,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentConsoleOutput(agentId string, messageType int, message string, text string) SyncPackerAgentConsoleOutput {
|
|
return SyncPackerAgentConsoleOutput{
|
|
SpCreateTime: time.Now().UTC().Unix(),
|
|
SpType: TYPE_AGENT_CONSOLE_OUT,
|
|
|
|
AgentId: agentId,
|
|
MessageType: messageType,
|
|
Message: message,
|
|
ClearText: text,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentErrorCommand(agentId string, cmdline string, message string, HookId string, HandlerId string) SyncPackerAgentErrorCommand {
|
|
return SyncPackerAgentErrorCommand{
|
|
SpType: TYPE_AGENT_CONSOLE_ERROR,
|
|
|
|
AgentId: agentId,
|
|
Cmdline: cmdline,
|
|
Message: message,
|
|
HookId: HookId,
|
|
HandlerId: HandlerId,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentLocalCommand(agentId string, cmdline string, message string, text string) SyncPackerAgentLocalCommand {
|
|
return SyncPackerAgentLocalCommand{
|
|
SpCreateTime: time.Now().UTC().Unix(),
|
|
SpType: TYPE_AGENT_CONSOLE_LOCAL,
|
|
|
|
AgentId: agentId,
|
|
Cmdline: cmdline,
|
|
Message: message,
|
|
Text: text,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentConsoleTaskSync(taskData adaptix.TaskData) SyncPackerAgentConsoleTaskSync {
|
|
return SyncPackerAgentConsoleTaskSync{
|
|
SpType: TYPE_AGENT_CONSOLE_TASK_SYNC,
|
|
|
|
AgentId: taskData.AgentId,
|
|
TaskId: taskData.TaskId,
|
|
StartTime: taskData.StartDate,
|
|
CmdLine: taskData.CommandLine,
|
|
Client: taskData.Client,
|
|
FinishTime: taskData.FinishDate,
|
|
MessageType: taskData.MessageType,
|
|
Message: taskData.Message,
|
|
Text: taskData.ClearText,
|
|
Completed: taskData.Completed,
|
|
}
|
|
}
|
|
|
|
func CreateSpAgentConsoleTaskUpd(taskData adaptix.TaskData) SyncPackerAgentConsoleTaskUpd {
|
|
return SyncPackerAgentConsoleTaskUpd{
|
|
SpType: TYPE_AGENT_CONSOLE_TASK_UPD,
|
|
|
|
AgentId: taskData.AgentId,
|
|
TaskId: taskData.TaskId,
|
|
FinishTime: taskData.FinishDate,
|
|
MessageType: taskData.MessageType,
|
|
Message: taskData.Message,
|
|
Text: taskData.ClearText,
|
|
Completed: taskData.Completed,
|
|
}
|
|
}
|
|
|
|
/// PIVOT
|
|
|
|
func CreateSpPivotCreate(pivotData adaptix.PivotData) SyncPackerPivotCreate {
|
|
return SyncPackerPivotCreate{
|
|
SpType: TYPE_PIVOT_CREATE,
|
|
|
|
PivotId: pivotData.PivotId,
|
|
PivotName: pivotData.PivotName,
|
|
ParentAgentId: pivotData.ParentAgentId,
|
|
ChildAgentId: pivotData.ChildAgentId,
|
|
}
|
|
}
|
|
|
|
func CreateSpPivotDelete(pivotId string) SyncPackerPivotDelete {
|
|
return SyncPackerPivotDelete{
|
|
SpType: TYPE_PIVOT_DELETE,
|
|
|
|
PivotId: pivotId,
|
|
}
|
|
}
|
|
|
|
/// CHAT
|
|
|
|
func CreateSpChatMessage(chatData adaptix.ChatData) SyncPackerChatMessage {
|
|
return SyncPackerChatMessage{
|
|
SpType: TYPE_CHAT_MESSAGE,
|
|
|
|
Username: chatData.Username,
|
|
Message: chatData.Message,
|
|
Date: chatData.Date,
|
|
}
|
|
}
|
|
|
|
/// DOWNLOAD
|
|
|
|
func CreateSpDownloadCreate(downloadData adaptix.DownloadData) SyncPackerDownloadCreate {
|
|
return SyncPackerDownloadCreate{
|
|
SpType: TYPE_DOWNLOAD_CREATE,
|
|
|
|
AgentId: downloadData.AgentId,
|
|
AgentName: downloadData.AgentName,
|
|
FileId: downloadData.FileId,
|
|
User: downloadData.User,
|
|
Computer: downloadData.Computer,
|
|
File: downloadData.RemotePath,
|
|
Size: downloadData.TotalSize,
|
|
Date: downloadData.Date,
|
|
}
|
|
}
|
|
|
|
func CreateSpDownloadUpdate(downloadData adaptix.DownloadData) SyncPackerDownloadUpdate {
|
|
return SyncPackerDownloadUpdate{
|
|
SpType: TYPE_DOWNLOAD_UPDATE,
|
|
|
|
FileId: downloadData.FileId,
|
|
RecvSize: downloadData.RecvSize,
|
|
State: downloadData.State,
|
|
}
|
|
}
|
|
|
|
func CreateSpDownloadDelete(fileId []string) SyncPackerDownloadDelete {
|
|
return SyncPackerDownloadDelete{
|
|
SpType: TYPE_DOWNLOAD_DELETE,
|
|
|
|
FileId: fileId,
|
|
}
|
|
}
|
|
|
|
func CreateSpDownloadActual(downloadData adaptix.DownloadData) SyncPackerDownloadActual {
|
|
return SyncPackerDownloadActual{
|
|
SpType: TYPE_DOWNLOAD_ACTUAL,
|
|
|
|
AgentId: downloadData.AgentId,
|
|
AgentName: downloadData.AgentName,
|
|
FileId: downloadData.FileId,
|
|
User: downloadData.User,
|
|
Computer: downloadData.Computer,
|
|
File: downloadData.RemotePath,
|
|
Size: downloadData.TotalSize,
|
|
Date: downloadData.Date,
|
|
RecvSize: downloadData.RecvSize,
|
|
State: downloadData.State,
|
|
}
|
|
}
|
|
|
|
/// SCREEN
|
|
|
|
func CreateSpScreenshotCreate(screenData adaptix.ScreenData) SyncPackerScreenshotCreate {
|
|
return SyncPackerScreenshotCreate{
|
|
SpType: TYPE_SCREEN_CREATE,
|
|
|
|
ScreenId: screenData.ScreenId,
|
|
User: screenData.User,
|
|
Computer: screenData.Computer,
|
|
Note: screenData.Note,
|
|
Date: screenData.Date,
|
|
Content: screenData.Content,
|
|
}
|
|
}
|
|
|
|
func CreateSpScreenshotUpdate(screenId string, note string) SyncPackerScreenshotUpdate {
|
|
return SyncPackerScreenshotUpdate{
|
|
SpType: TYPE_SCREEN_UPDATE,
|
|
|
|
ScreenId: screenId,
|
|
Note: note,
|
|
}
|
|
}
|
|
|
|
func CreateSpScreenshotDelete(screenId string) SyncPackerScreenshotDelete {
|
|
return SyncPackerScreenshotDelete{
|
|
SpType: TYPE_SCREEN_DELETE,
|
|
|
|
ScreenId: screenId,
|
|
}
|
|
}
|
|
|
|
/// CREDS
|
|
|
|
func CreateSpCredentialsAdd(creds []*adaptix.CredsData) SyncPackerCredentialsAdd {
|
|
var syncCreds []SyncPackerCredentials
|
|
|
|
for _, credsData := range creds {
|
|
t := SyncPackerCredentials{
|
|
CredId: credsData.CredId,
|
|
Username: credsData.Username,
|
|
Password: credsData.Password,
|
|
Realm: credsData.Realm,
|
|
Type: credsData.Type,
|
|
Tag: credsData.Tag,
|
|
Date: credsData.Date,
|
|
Storage: credsData.Storage,
|
|
AgentId: credsData.AgentId,
|
|
Host: credsData.Host,
|
|
}
|
|
syncCreds = append(syncCreds, t)
|
|
}
|
|
|
|
return SyncPackerCredentialsAdd{
|
|
SpType: TYPE_CREDS_CREATE,
|
|
Creds: syncCreds,
|
|
}
|
|
}
|
|
|
|
func CreateSpCredentialsUpdate(credsData adaptix.CredsData) SyncPackerCredentialsUpdate {
|
|
return SyncPackerCredentialsUpdate{
|
|
SpType: TYPE_CREDS_EDIT,
|
|
|
|
CredId: credsData.CredId,
|
|
Username: credsData.Username,
|
|
Password: credsData.Password,
|
|
Realm: credsData.Realm,
|
|
Type: credsData.Type,
|
|
Tag: credsData.Tag,
|
|
Storage: credsData.Storage,
|
|
Host: credsData.Host,
|
|
}
|
|
}
|
|
|
|
func CreateSpCredentialsDelete(credsId []string) SyncPackerCredentialsDelete {
|
|
return SyncPackerCredentialsDelete{
|
|
SpType: TYPE_CREDS_DELETE,
|
|
|
|
CredsId: credsId,
|
|
}
|
|
}
|
|
|
|
func CreateSpCredentialsSetTag(credsId []string, tag string) SyncPackerCredentialsTag {
|
|
return SyncPackerCredentialsTag{
|
|
SpType: TYPE_CREDS_SET_TAG,
|
|
|
|
CredsId: credsId,
|
|
Tag: tag,
|
|
}
|
|
}
|
|
|
|
/// TARGETS
|
|
|
|
func CreateSpTargetsAdd(targetsData []*adaptix.TargetData) SyncPackerTargetsAdd {
|
|
var syncTargets []SyncPackerTarget
|
|
|
|
for _, targetData := range targetsData {
|
|
t := SyncPackerTarget{
|
|
TargetId: targetData.TargetId,
|
|
Computer: targetData.Computer,
|
|
Domain: targetData.Domain,
|
|
Address: targetData.Address,
|
|
Os: targetData.Os,
|
|
OsDesk: targetData.OsDesk,
|
|
Tag: targetData.Tag,
|
|
Info: targetData.Info,
|
|
Date: targetData.Date,
|
|
Alive: targetData.Alive,
|
|
Agents: targetData.Agents,
|
|
}
|
|
syncTargets = append(syncTargets, t)
|
|
}
|
|
|
|
return SyncPackerTargetsAdd{
|
|
SpType: TYPE_TARGETS_CREATE,
|
|
Targets: syncTargets,
|
|
}
|
|
}
|
|
|
|
func CreateSpTargetUpdate(targetData adaptix.TargetData) SyncPackerTargetUpdate {
|
|
return SyncPackerTargetUpdate{
|
|
SpType: TYPE_TARGETS_EDIT,
|
|
|
|
TargetId: targetData.TargetId,
|
|
Computer: targetData.Computer,
|
|
Domain: targetData.Domain,
|
|
Address: targetData.Address,
|
|
Os: targetData.Os,
|
|
OsDesk: targetData.OsDesk,
|
|
Tag: targetData.Tag,
|
|
Info: targetData.Info,
|
|
Date: targetData.Date,
|
|
Alive: targetData.Alive,
|
|
Agents: targetData.Agents,
|
|
}
|
|
}
|
|
|
|
func CreateSpTargetDelete(targetsId []string) SyncPackerTargetDelete {
|
|
return SyncPackerTargetDelete{
|
|
SpType: TYPE_TARGETS_DELETE,
|
|
|
|
TargetsId: targetsId,
|
|
}
|
|
}
|
|
|
|
func CreateSpTargetSetTag(targetsId []string, tag string) SyncPackerTargetTag {
|
|
return SyncPackerTargetTag{
|
|
SpType: TYPE_TARGETS_SET_TAG,
|
|
|
|
TargetsId: targetsId,
|
|
Tag: tag,
|
|
}
|
|
}
|
|
|
|
/// BROWSER
|
|
|
|
func CreateSpBrowserDisks(taskData adaptix.TaskData, data string) SyncPacketBrowserDisks {
|
|
return SyncPacketBrowserDisks{
|
|
SpType: TYPE_BROWSER_DISKS,
|
|
|
|
AgentId: taskData.AgentId,
|
|
Time: time.Now().UTC().Unix(),
|
|
MessageType: taskData.MessageType,
|
|
Message: taskData.Message,
|
|
Data: data,
|
|
}
|
|
}
|
|
|
|
func CreateSpBrowserFiles(taskData adaptix.TaskData, path string, data string) SyncPacketBrowserFiles {
|
|
return SyncPacketBrowserFiles{
|
|
SpType: TYPE_BROWSER_FILES,
|
|
|
|
AgentId: taskData.AgentId,
|
|
Time: time.Now().UTC().Unix(),
|
|
MessageType: taskData.MessageType,
|
|
Message: taskData.Message,
|
|
Path: path,
|
|
Data: data,
|
|
}
|
|
}
|
|
|
|
func CreateSpBrowserFilesStatus(taskData adaptix.TaskData) SyncPacketBrowserFilesStatus {
|
|
return SyncPacketBrowserFilesStatus{
|
|
SpType: TYPE_BROWSER_FILES_STATUS,
|
|
|
|
AgentId: taskData.AgentId,
|
|
Time: time.Now().UTC().Unix(),
|
|
MessageType: taskData.MessageType,
|
|
Message: taskData.Message,
|
|
}
|
|
}
|
|
|
|
func CreateSpBrowserProcess(taskData adaptix.TaskData, data string) SyncPacketBrowserProcess {
|
|
return SyncPacketBrowserProcess{
|
|
SpType: TYPE_BROWSER_PROCESS,
|
|
|
|
AgentId: taskData.AgentId,
|
|
Time: time.Now().UTC().Unix(),
|
|
MessageType: taskData.MessageType,
|
|
Message: taskData.Message,
|
|
Data: data,
|
|
}
|
|
}
|
|
|
|
/// TUNNEL
|
|
|
|
func CreateSpTunnelCreate(tunnelData adaptix.TunnelData) SyncPackerTunnelCreate {
|
|
return SyncPackerTunnelCreate{
|
|
SpType: TYPE_TUNNEL_CREATE,
|
|
|
|
TunnelId: tunnelData.TunnelId,
|
|
AgentId: tunnelData.AgentId,
|
|
Username: tunnelData.Username,
|
|
Computer: tunnelData.Computer,
|
|
Process: tunnelData.Process,
|
|
Type: tunnelData.Type,
|
|
Info: tunnelData.Info,
|
|
Interface: tunnelData.Interface,
|
|
Port: tunnelData.Port,
|
|
Client: tunnelData.Client,
|
|
Fport: tunnelData.Fport,
|
|
Fhost: tunnelData.Fhost,
|
|
}
|
|
}
|
|
|
|
func CreateSpTunnelEdit(tunnelData adaptix.TunnelData) SyncPackerTunnelEdit {
|
|
return SyncPackerTunnelEdit{
|
|
SpType: TYPE_TUNNEL_EDIT,
|
|
|
|
TunnelId: tunnelData.TunnelId,
|
|
Info: tunnelData.Info,
|
|
}
|
|
}
|
|
|
|
func CreateSpTunnelDelete(tunnelData adaptix.TunnelData) SyncPackerTunnelDelete {
|
|
return SyncPackerTunnelDelete{
|
|
SpType: TYPE_TUNNEL_DELETE,
|
|
|
|
TunnelId: tunnelData.TunnelId,
|
|
}
|
|
}
|
|
|
|
/// SERVICE
|
|
|
|
func CreateSpServiceReg(name string, ax string) SyncPackerServiceReg {
|
|
return SyncPackerServiceReg{
|
|
SpType: TYPE_SERVICE_REG,
|
|
|
|
Name: name,
|
|
AX: ax,
|
|
}
|
|
}
|
|
|
|
func CreateSpServiceData(service string, data string) SyncPackerServiceData {
|
|
return SyncPackerServiceData{
|
|
SpType: TYPE_SERVICE_DATA,
|
|
|
|
Service: service,
|
|
Data: data,
|
|
}
|
|
}
|
|
|
|
/// AXSCRIPT
|
|
|
|
func CreateSpAxScriptData(name string, content string, groups []AxCommandBatch) SyncPackerAxScriptData {
|
|
return SyncPackerAxScriptData{
|
|
SpType: TYPE_AXSCRIPT_COMMANDS,
|
|
Name: name,
|
|
Content: content,
|
|
Groups: groups,
|
|
}
|
|
}
|