agentstructs

type BrowserScript struct {
	ScriptPath     string `json:"-"`
	Author         string `json:"author"`
	ScriptContents string `json:"script"`
}

type BuildParameter struct {
	// Name - the name of the build parameter for use during the Payload Type's build function
	Name string `json:"name"`
	// Description - the description of the build parameter to be presented to the user during build
	Description string `json:"description"`
	// Required - indicate if this requires the user to supply a value or not
	Required bool `json:"required"`
	// VerifierRegex - if the user is supplying text and it needs to match a specific pattern, specify a regex pattern here and the UI will indicate to the user if the value is valid or not
	VerifierRegex string `json:"verifier_regex"`
	// DefaultValue - A default value to show the user when building in the Mythic UI. The type here depends on the Parameter Type - ex: for a String, supply a string. For an array, provide an array
	DefaultValue interface{} `json:"default_value"`
	// ParameterType - The type of parameter this is so that the UI can properly render components for the user to modify
	ParameterType BuildParameterType `json:"parameter_type"`
	// FormatString - If Randomize is true, this regex format string is used to generate a value when presenting the option to the user
	FormatString string `json:"format_string"`
	// Randomize - Should this value be randomized each time it's shown to the user so that each payload has a different value
	Randomize bool `json:"randomize"`
	// IsCryptoType -If this is True, then the value supplied by the user is for determining the _kind_ of crypto keys to generate (if any) and the resulting stored value in the database is a dictionary composed of the user's selected and an enc_key and dec_key value
	IsCryptoType bool `json:"crypto_type"`
	// Choices - If the ParameterType is ChooseOne or ChooseMultiple, then the options presented to the user are here.
	Choices []string `json:"choices"`
	// DictionaryChoices - if the ParameterType is Dictionary, then the dictionary choices/preconfigured data is set here
	DictionaryChoices []BuildParameterDictionary `json:"dictionary_choices"`
}

type BuildParameterDictionary C2ParameterDictionary

type BuildParameterType = string

type BuildParameters struct {
	Parameters map[string]interface{} `json:"build_parameters" mapstructure:"build_parameters"`
}

type BuildStep struct {
	Name        string `json:"step_name"`
	Description string `json:"step_description"`
}

type C2ParameterDictionary struct {
	Name         string `json:"name"`
	DefaultValue string `json:"default_value"`
	DefaultShow  bool   `json:"default_show"`
}

type C2ProfileInfo struct {
	Name       string                 `json:"name" mapstructure:"name"`
	Parameters map[string]interface{} `json:"parameters" mapstructure:"parameters"`
}

type Command struct {
	// Name - the name of the command as the user would type it
	Name string `json:"name"`
	// NeedsAdminPermissions - Does the command need elevated permissions to execute?
	NeedsAdminPermissions bool `json:"needs_admin_permissions"`
	// HelpString - When the user types 'help', what short help would you provide?
	HelpString string `json:"help_string"`
	// Description - A description of what the command does that appears in the tasking modal as well as when the user is selecting commands to include in their payload
	Description string `json:"description"`
	// Version - What version of this command is this? The version is tracked overall and per-load within a Payload and Callback. This makes it easier to see if a callback or payload has an outdated version of a command.
	Version uint32 `json:"version"`
	// SupportedUIFeatures - The list of UI features that the command supports such as 'callback_table:exit` or `file_browser:list`.
	/*
		The most common of these features can be found on the Mythic documentation website, but you can make your own custom ones as well.
		When you want to do browser scripting and support issuing a task with a button click, that task is identified based on the supported_ui_features you supply here.
		There's no required format, but typically they're in the form of `general:specific`, so maybe `registry:write` or `clipboard:set`.
	*/
	SupportedUIFeatures []string `json:"supported_ui_features"`
	// Author - the author(s) of this command
	Author string `json:"author"`
	// MitreAttackMappings - A list of MITRE Technique IDs (ex: T1033) that this command maps to
	MitreAttackMappings []string `json:"attack"`
	// ScriptOnlyCommand - Is this command only defined as a script/golang file or does it have a matching function within the payload
	ScriptOnlyCommand bool `json:"script_only"`
	// CommandAttributes - Attributes about this command that can be used to determine what commands the user can select when building the payload.
	// This also comes into play when determining commands to list for some command parameters
	CommandAttributes CommandAttribute `json:"attributes"`
	// CommandParameters - A list of the parameters associated with this command (also known as arguments)
	CommandParameters []CommandParameter `json:"parameters"`
	// AssociatedBrowserScript - If this command has a browser script to manipulate the output from this command, reference that here
	AssociatedBrowserScript *BrowserScript `json:"browserscript,omitempty"`
	// TaskFunctionOPSECPre - If you want to provide an OPSEC check before your main TaskFunctionCreateTasking function, you can define that function here
	TaskFunctionOPSECPre PtTaskFunctionOPSECPre `json:"-"`
	// TaskFunctionCreateTasking - This is the main function to do additional processing, RPC calls, and anything else before your command is ready for the agent to pick it up
	TaskFunctionCreateTasking PtTaskFunctionCreateTasking `json:"-"`
	// TaskFunctionProcessResponse - If your callback returns data in the 'process_response' key within your responses array, that data gets processed here.
	TaskFunctionProcessResponse PtTaskFunctionProcessResponse `json:"-"`
	// TaskFunctionOPSECPost - If you want to provide an OPSEC check after your TaskFunctionCreateTasking function executes but before the agent picks up the tasking, you can do that here
	TaskFunctionOPSECPost PtTaskFunctionOPSECPost `json:"-"`
	// TaskFunctionParseArgString - Parse an argument string from the user into your command's CommandParameters array
	TaskFunctionParseArgString PtTaskFunctionParseArgString `json:"-"`
	// TaskFunctionParseArgDictionary - Parse an argument dictionary from the user into your command's CommandParameters array
	TaskFunctionParseArgDictionary PtTaskFunctionParseArgDictionary `json:"-"`
	// TaskCompletionFunctions - If your TaskFunctionCreateTasking function or any of your subtasks have completion functions, define them here
	TaskCompletionFunctions map[string]PTTaskCompletionFunction `json:"-"`
}

type CommandAttribute struct {
	// SupportedOS -  Which operating systems does this command support? An empty list means all OS.
	SupportedOS []string `json:"supported_os"`
	// CommandIsBuiltin -  Is this command baked into the agent permanently?
	CommandIsBuiltin bool `json:"builtin"`
	// CommandIsSuggested - If true, this command will appear on the "included" side when building your payload by default.
	CommandIsSuggested bool `json:"suggested_command"`
	// CommandCanOnlyBeLoadedLater - If true, this command can only be loaded after you have a callback and not included in the base payload.
	CommandCanOnlyBeLoadedLater bool `json:"load_only"`
	// FilterCommandAvailabilityByAgentBuildParameters - Specify if this command is allowed to be built into the payload or not based on build parameters the user specifies.
	/*
		is of the form {"build param name": "build param value"}
	*/
	FilterCommandAvailabilityByAgentBuildParameters map[string]string `json:"filter_by_build_parameter"`
	// AdditionalAttributes - Additional, developer-supplied, key-value pairs such as a dependency note that a command relies on another comand
	AdditionalAttributes map[string]string `json:"additional_items"`
}

type CommandParameter struct {
	// Name - The name of your parameter - used when adding args or changing arg values
	Name string `json:"name"`
	// ModalDisplayName - A more friendly version of the name, most likely with captialization and spaces
	ModalDisplayName string `json:"display_name"`
	// CLIName - A more CLI friendly version of the name, potentially without dashes/underscores and no spaces
	CLIName string `json:"cli_name"`
	// ParameterType - The type of parameter - this influences how things work in the UI
	ParameterType CommandParameterType `json:"parameter_type"`
	// Description - The description of the parameter that's displayed to the user when they hover over the ModalDisplayName
	Description string `json:"description"`
	// Choices - If the ParameterType is ChooseOne or ChooseMultiple, these are the choices for the user.
	// If the ParameterType is TypedArray, these are the options for each array entry
	Choices []string `json:"choices"`
	// DefaultValue - The default value to present to the user when they pull up the modal view
	DefaultValue interface{} `json:"default_value"`
	// SupportedAgents - When using the "Payload" Parameter Type, you can filter down which payloads are presented to the operator based on this list of supported agents.
	SupportedAgents []string `json:"supported_agents"`
	// SupportedAgentBuildParameters - When using the "Payload" Parameter Type, you can filter down which payloads are presented to the operator based on specific build parameters for specific payload types.
	SupportedAgentBuildParameters map[string]string `json:"supported_agent_build_parameters"`
	// ChoicesAreAllCommands - Can be used with ChooseOne or ChooseMultiple Parameter Types to automatically populate those options in the UI with all of the commands for the payload type.
	ChoicesAreAllCommands bool `json:"choices_are_all_commands"`
	// ChoicesAreLoadedCommands - Can be used with ChooseOne or ChooseMultiple Parameter Types to automatically populate those options in the UI with all of the currently loaded commands.
	ChoicesAreLoadedCommands bool `json:"choices_are_loaded_commands"`
	// FilterCommandChoicesByCommandAttributes -  When using the ChooseOne or ChooseMultiple Parameter type along with choices_are_all_commands, you can filter down those options based on attribute values in your command's CommandAttributes field.
	FilterCommandChoicesByCommandAttributes map[string]string `json:"choice_filter_by_command_attributes"`
	// DynamicQueryFunction -  Provide a dynamic query function to be called when the user views that parameter option in the UI to populate choices for the ChooseOne or ChooseMultiple Parameter Types.
	DynamicQueryFunction PTTaskingDynamicQueryFunction `json:"dynamic_query_function"`
	// TypedArrayParseFunction - Provide a function to be called when the user types out a typedArray value on the CLI, but that needs to be parsed for a Modal Popup
	TypedArrayParseFunction PTTaskingTypedArrayParseFunction `json:"typedarray_parse_function"`
	// ParameterGroupInformation - Define 0+ different parameter groups that this parameter belongs to.
	ParameterGroupInformation []ParameterGroupInfo `json:"parameter_group_info"`
	// contains filtered or unexported fields
}

type CommandParameterType = string

type ConnectionInfo struct {
	CallbackUUID  string        `json:"callback_uuid" mapstructure:"callback_uuid"`
	AgentUUID     string        `json:"agent_uuid" mapstructure:"agent_uuid"`
	Host          string        `json:"host" mapstructure:"host"`
	C2ProfileInfo C2ProfileInfo `json:"c2_profile" mapstructure:"c2_profile"`
}

type CredentialInfo struct {
	Realm      string `json:"realm" mapstructure:"realm"`
	Account    string `json:"account" mapstructure:"account"`
	Credential string `json:"credential" mapstructure:"credential"`
	Comment    string `json:"comment" mapstructure:"comment"`
	Type       string `json:"type" mapstructure:"type"`
}

type CryptoArg struct {
	Value  string `json:"value" mapstructure:"value"`
	EncKey string `json:"enc_key" mapstructure:"enc_key"`
	DecKey string `json:"dec_key" mapstructure:"dec_key"`
}

type FileBrowserTask struct {
	Path     string `json:"path" mapstructure:"path"`
	FullPath string `json:"full_path" mapstructure:"full_path"`
	Filename string `json:"file" mapstructure:"file"`
	Host     string `json:"host" mapstructure:"host"`
}

type OPSEC_ROLE string

type PAYLOAD_BUILD_STATUS = string

type PTOnNewCallbackAllData struct {
	Callback        PTTaskMessageCallbackData            `json:"callback"`
	BuildParameters []PayloadConfigurationBuildParameter `json:"build_parameters"`
	Commands        []string                             `json:"commands"`
	Payload         PTTaskMessagePayloadData             `json:"payload"`
	C2Profiles      []PayloadConfigurationC2Profile      `json:"c2info"`
	PayloadType     string                               `json:"payload_type"`
	Secrets         map[string]interface{}               `json:"secrets"`
}

type PTOnNewCallbackResponse struct {
	AgentCallbackID string `json:"agent_callback_id"`
	Success         bool   `json:"success"`
	Error           string `json:"error"`
}

type PTRPCDynamicQueryFunctionMessage struct {
	// Command - the command name for the query function called
	Command string `json:"command" binding:"required"`
	// ParameterName - the specific parameter for the query function called
	ParameterName string `json:"parameter_name" binding:"required"`
	// PayloadType - the name of the payload type for the query function called
	PayloadType string `json:"payload_type" binding:"required"`
	// Callback - the ID of the callback where this query function is called
	Callback int `json:"callback" binding:"required"`
	// PayloadOS - the string OS selected during payload creation
	PayloadOS string `json:"payload_os"`
	// PayloadUUID - the UUID of the backing payload that can be used to fetch more information about the payload
	PayloadUUID string `json:"payload_uuid"`
	// CallbackDisplayID - the number seen on the active callbacks page for the callback in question
	CallbackDisplayID int `json:"callback_display_id"`
	// AgentCallbackID - the UUID of the callback known by the agent
	AgentCallbackID string `json:"agent_callback_id"`
	// Secrets - User supplied secrets
	Secrets map[string]interface{} `json:"secrets"`
}

type PTRPCDynamicQueryFunctionMessageResponse struct {
	// Success - indicating if the query function succeeded or not
	Success bool `json:"success"`
	// Error - if there was an error, return that message here for the user
	Error string `json:"error"`
	// Choices - the resulting choices for the user based on the dynamic query function
	Choices []string `json:"choices"`
}

type PTRPCOtherServiceRPCMessage struct {
	// Name - The name of the remote Payload type or C2 Profile
	Name string `json:"service_name"` //required
	// RPCFunction - The name of the function to call for that remote service
	RPCFunction string `json:"service_function"`
	// RPCFunctionArguments - A map of arguments to supply to that remote function
	RPCFunctionArguments map[string]interface{} `json:"service_arguments"`
}

type PTRPCOtherServiceRPCMessageResponse struct {
	// Success - An indicator if the call was successful or not
	Success bool `json:"success"`
	// Error - If the call was unsuccessful, this is an error message about what happened
	Error string `json:"error"`
	// Result - The result returned by the remote service
	Result map[string]interface{} `json:"result"`
}

type PTRPCReSyncMessage struct {
	Name string `json:"payload_type"`
}

type PTRPCReSyncMessageResponse struct {
	Success bool   `json:"success"`
	Error   string `json:"error"`
}

type PTRPCTypedArrayParseFunctionMessage struct {
	// Command - the command name for the query function called
	Command string `json:"command" binding:"required"`
	// ParameterName - the specific parameter for the query function called
	ParameterName string `json:"parameter_name" binding:"required"`
	// PayloadType - the name of the payload type for the query function called
	PayloadType string `json:"payload_type" binding:"required"`
	// Callback - the ID of the callback where this query function is called
	Callback int `json:"callback" binding:"required"`
	// InputArray - the structured input array that the user provided
	InputArray []string `json:"input_array"`
}

type PTRPCTypedArrayParseMessageResponse struct {
	// Success - indicating if the query function succeeded or not
	Success bool `json:"success"`
	// Error - if there was an error, return that message here for the user
	Error string `json:"error"`
	// TypedArray - the resulting typed array based on the formatted normal array
	TypedArray [][]string `json:"typed_array"`
}

type PTTTaskOPSECPreTaskMessageResponse struct {
	TaskID             int        `json:"task_id"`
	Success            bool       `json:"success"`
	Error              string     `json:"error"`
	OpsecPreBlocked    bool       `json:"opsec_pre_blocked"`
	OpsecPreMessage    string     `json:"opsec_pre_message"`
	OpsecPreBypassed   *bool      `json:"opsec_pre_bypassed,omitempty"`
	OpsecPreBypassRole OPSEC_ROLE `json:"opsec_pre_bypass_role"`
}

type PTTaskCompletionFunction func(*PTTaskMessageAllData, *PTTaskMessageAllData, *SubtaskGroupName) PTTaskCompletionFunctionMessageResponse

type PTTaskCompletionFunctionMessage struct {
	TaskData               *PTTaskMessageAllData `json:"task"`
	SubtaskData            *PTTaskMessageAllData `json:"subtask,omitempty"`
	SubtaskGroup           *SubtaskGroupName     `json:"subtask_group_name,omitempty"`
	CompletionFunctionName string                `json:"function_name"`
}

type PTTaskCompletionFunctionMessageResponse struct {
	TaskID                 int     `json:"task_id"`
	ParentTaskId           int     `json:"parent_task_id"`
	Success                bool    `json:"success"`
	Error                  string  `json:"error"`
	TaskStatus             *string `json:"task_status,omitempty"`
	DisplayParams          *string `json:"display_params,omitempty"`
	Stdout                 *string `json:"stdout,omitempty"`
	Stderr                 *string `json:"stderr,omitempty"`
	Completed              *bool   `json:"completed,omitempty"`
	TokenID                *int    `json:"token_id,omitempty"`
	CompletionFunctionName *string `json:"completion_function_name,omitempty"`
	Params                 *string `json:"params,omitempty"`
	ParameterGroupName     *string `json:"parameter_group_name,omitempty"`
}

type PTTaskCreateTaskingMessageResponse struct {
	// TaskID - the task associated with the create tasking function - this will be automatically filled in for you
	TaskID int `json:"task_id"`
	// Success - indicate if the create tasking function ran successfully or not
	Success bool `json:"success"`
	// Error - if you want to provide an error message about some error you hit while executing the create tasking
	Error string `json:"error"`
	// CommandName - if you want to change the associated command name that's sent down to the agent
	CommandName *string `json:"command_name,omitempty"`
	// TaskStatus - if you want to manually set the task status to be something other than default
	TaskStatus *string `json:"task_status,omitempty"`
	// DisplayParams - if you want to change the display parameters for your task to be something other than the default JSON
	DisplayParams *string `json:"display_params,omitempty"`
	// Stdout - Provide any task-based stdout
	Stdout *string `json:"stdout,omitempty"`
	// Stderr - Provide any task-based stderr
	Stderr *string `json:"stderr,omitempty"`
	// Completed - identify if the task is already completed and shouldn't be sent down to the agent
	Completed *bool `json:"completed,omitempty"`
	// TokenID - identifier for the token id associated with this task - normally doesn't need to be set unless you're changing it
	TokenID *uint64 `json:"token_id,omitempty"`
	// CompletionFunctionName - name of the completion function to call from the Command's TaskCompletionFunctions dictionary
	CompletionFunctionName *string `json:"completion_function_name,omitempty"`
	// ParameterGroupName - Don't set this explicitly. If you want to set the name of the parameter group explicitly, use
	// the taskData.Args.SetManualParameterGroup("name here") function.
	ParameterGroupName string `json:"parameter_group_name"`
}

type PTTaskMessageAllData struct {
	// Task - Read-only data about the task
	Task PTTaskMessageTaskData `json:"task"`
	// Callback - Read-only data about the callback
	Callback PTTaskMessageCallbackData `json:"callback"`
	// BuildParameters - Read-only data about the build parameters
	BuildParameters []PayloadConfigurationBuildParameter `json:"build_parameters"`
	// Commands - Read-only data about the commands built into the callback
	Commands []string `json:"commands"`
	// Payload - Read-only data about the backing payload for this task
	Payload PTTaskMessagePayloadData `json:"payload"`
	// C2Profiles - Read-only data about the c2 profiles and their values for this callback
	C2Profiles []PayloadConfigurationC2Profile `json:"c2info"`
	// PayloadType - Read-only the name of the payload type associated with this task
	PayloadType string `json:"payload_type"`
	// Secrets - Map of user supplied secrets to their values to help with tasking
	Secrets map[string]interface{} `json:"secrets"`
	// Args - Read-Write argument data for adding/removing/modifying args associated with this task instance.
	// Mainly for create tasking function to augment parameters
	Args PTTaskMessageArgsData
}

type PTTaskMessageArgsData struct {
	// contains filtered or unexported fields
}

type PTTaskMessageCallbackData struct {
	ID                  int      `json:"id"`
	DisplayID           int      `json:"display_id"`
	AgentCallbackID     string   `json:"agent_callback_id"`
	InitCallback        string   `json:"init_callback"`
	LastCheckin         string   `json:"last_checkin"`
	User                string   `json:"user"`
	Host                string   `json:"host"`
	PID                 int      `json:"pid"`
	IP                  string   `json:"ip"`
	IPs                 []string `json:"ips"`
	ExternalIp          string   `json:"external_ip"`
	ProcessName         string   `json:"process_name"`
	Description         string   `json:"description"`
	OperatorID          int      `json:"operator_id"`
	OperatorUsername    string   `json:"operator_username"`
	Active              bool     `json:"active"`
	RegisteredPayloadID int      `json:"registered_payload_id"`
	IntegrityLevel      int      `json:"integrity_level"`
	Locked              bool     `json:"locked"`
	OperationID         int      `json:"operation_id"`
	OperationName       string   `json:"operation_name"`
	CryptoType          string   `json:"crypto_type"`
	DecKey              []byte   `json:"dec_key"`
	EncKey              []byte   `json:"enc_key"`
	OS                  string   `json:"os"`
	Architecture        string   `json:"architecture"`
	Domain              string   `json:"domain"`
	ExtraInfo           string   `json:"extra_info"`
	SleepInfo           string   `json:"sleep_info"`
}

type PTTaskMessagePayloadData struct {
	OS          string `json:"os"`
	UUID        string `json:"uuid"`
	PayloadType string `json:"payload_type"`
}

type PTTaskMessageTaskData struct {
	ID                                 int    `json:"id"`
	AgentTaskID                        string `json:"agent_task_id"`
	CommandName                        string `json:"command_name"`
	Params                             string `json:"params"`
	Timestamp                          string `json:"timestamp"`
	CallbackID                         int    `json:"callback_id"`
	Status                             string `json:"status"`
	OriginalParams                     string `json:"original_params"`
	DisplayParams                      string `json:"display_params"`
	Comment                            string `json:"comment"`
	Stdout                             string `json:"stdout"`
	Stderr                             string `json:"stderr"`
	Completed                          bool   `json:"completed"`
	OperatorUsername                   string `json:"operator_username"`
	OperatorID                         int    `json:"operator_id"`
	OpsecPreBlocked                    bool   `json:"opsec_pre_blocked"`
	OpsecPreMessage                    string `json:"opsec_pre_message"`
	OpsecPreBypassed                   bool   `json:"opsec_pre_bypassed"`
	OpsecPreBypassRole                 string `json:"opsec_pre_bypass_role"`
	OpsecPostBlocked                   bool   `json:"opsec_post_blocked"`
	OpsecPostMessage                   string `json:"opsec_post_message"`
	OpsecPostBypassed                  bool   `json:"opsec_post_bypassed"`
	OpsecPostBypassRole                string `json:"opsec_post_bypass_role"`
	ParentTaskID                       int    `json:"parent_task_id"`
	SubtaskCallbackFunction            string `json:"subtask_callback_function"`
	SubtaskCallbackFunctionCompleted   bool   `json:"subtask_callback_function_completed"`
	GroupCallbackFunction              string `json:"group_callback_function"`
	GroupCallbackFunctionCompleted     bool   `json:"group_callback_function_completed"`
	CompletedCallbackFunction          string `json:"completed_callback_function"`
	CompletedCallbackFunctionCompleted bool   `json:"completed_callback_function_completed"`
	SubtaskGroupName                   string `json:"subtask_group_name"`
	TaskingLocation                    string `json:"tasking_location"`
	ParameterGroupName                 string `json:"parameter_group_name"`
	TokenID                            int    `json:"token_id"`
}

type PTTaskOPSECPostTaskMessageResponse struct {
	TaskID              int        `json:"task_id"`
	Success             bool       `json:"success"`
	Error               string     `json:"error"`
	OpsecPostBlocked    bool       `json:"opsec_post_blocked"`
	OpsecPostMessage    string     `json:"opsec_post_message"`
	OpsecPostBypassed   *bool      `json:"opsec_post_bypassed,omitempty"`
	OpsecPostBypassRole OPSEC_ROLE `json:"opsec_post_bypass_role"`
}

type PTTaskProcessResponseMessageResponse struct {
	TaskID  int    `json:"task_id"`
	Success bool   `json:"success"`
	Error   string `json:"error"`
}

type PTTaskingDynamicQueryFunction func(PTRPCDynamicQueryFunctionMessage) []string

type PTTaskingTypedArrayParseFunction func(message PTRPCTypedArrayParseFunctionMessage) [][]string

type PT_TASK_FUNCTION_STATUS = string

type ParameterGroupInfo struct {
	// ParameterIsRequired - Is this parameter required?
	ParameterIsRequired bool `json:"required"`
	// GroupName - What is the name of this parameter group (i.e. group of parameters that are grouped together)
	GroupName string `json:"group_name"`
	// UIModalPosition - If the user opens a modal to fill out parameters, which position should this parameter be shown?
	UIModalPosition uint32 `json:"ui_position"`
	// AdditionalInformation - Additional, developer-supplied, key-value pairs of information
	AdditionalInformation map[string]string `json:"additional_info"`
}

type PayloadBuildC2Profile struct {
	Name  string `json:"name" mapstructure:"name"`
	IsP2P bool   `json:"is_p2p" mapstructure:"is_p2p"`
	// parameter name: parameter value
	// Parameters - this is an interface of parameter name -> parameter value from the associated C2 profile.
	// The types for the various parameter names can be found by looking at the build parameters in the Mythic UI.
	Parameters map[string]interface{} `json:"parameters" mapstructure:"parameters"`
}

type PayloadBuildC2ProfileMessage struct {
	PayloadUUID     string                 `json:"uuid"`
	Parameters      map[string]interface{} `json:"parameters"`
	BuildParameters map[string]interface{} `json:"build_parameters"`
	SelectedOS      string                 `json:"selected_os"`
	PayloadType     string                 `json:"payload_type"`
}

type PayloadBuildC2ProfileMessageResponse struct {
	PayloadUUID  string  `json:"uuid"`
	Status       string  `json:"status"`
	Payload      *[]byte `json:"payload,omitempty"`
	BuildStdErr  string  `json:"build_stderr"`
	BuildStdOut  string  `json:"build_stdout"`
	BuildMessage string  `json:"build_message"`
}

type PayloadBuildMessage struct {
	// PayloadType - the name of the payload type for the build
	PayloadType string `json:"payload_type" mapstructure:"payload_type"`
	// Filename - the name of the file the user originally supplied for this build
	Filename string `json:"filename" mapstructure:"filename"`
	// CommandList - the list of commands the user selected to include in the build
	CommandList []string `json:"commands" mapstructure:"commands"`
	// build param name : build value
	// BuildParameters - map of param name -> build value from the user for the build parameters defined
	// File type build parameters are supplied as a string UUID to use with MythicRPC for fetching file contents
	// Array type build parameters are supplied as []string{}
	BuildParameters
	// C2Profiles - list of C2 profiles selected to include in the payload and their associated parameters
	C2Profiles []PayloadBuildC2Profile `json:"c2profiles" mapstructure:"c2profiles"`
	// WrappedPayload - bytes of the wrapped payload if one exists
	WrappedPayload *[]byte `json:"wrapped_payload,omitempty" mapstructure:"wrapped_payload"`
	// WrappedPayloadUUID - the UUID of the wrapped payload if one exists
	WrappedPayloadUUID *string `json:"wrapped_payload_uuid,omitempty" mapstructure:"wrapped_payload_uuid"`
	// SelectedOS - the operating system the user selected when building the agent
	SelectedOS string `json:"selected_os" mapstructure:"selected_os"`
	// PayloadUUID - the Mythic generated UUID for this payload instance
	PayloadUUID string `json:"uuid" mapstructure:"uuid"`
	// PayloadFileUUID - The Mythic generated File UUID associated with this payload
	PayloadFileUUID string `json:"payload_file_uuid" mapstructure:"payload_file_uuid"`
	// Secrets - User supplied secrets that get sent down with payload builds
	Secrets map[string]interface{} `json:"secrets"`
}

type PayloadBuildResponse struct {
	// PayloadUUID - The UUID associated with this payload
	PayloadUUID string `json:"uuid"`
	// Success - was this build process successful or not
	Success bool `json:"success"`
	// UpdatedFilename - Optionally updated filename based on build parameters to more closely match the return file type
	UpdatedFilename *string `json:"updated_filename,omitempty"`
	// Payload - the raw bytes of the payload that was compiled/created
	Payload *[]byte `json:"payload,omitempty"`
	// UpdatedCommandList - if you want to adjust the list of commands in this payload from what the user provided,
	// provide the updated list of command names here
	UpdatedCommandList *[]string `json:"updated_command_list,omitempty"`
	// BuildStdErr - build stderr message to associate with the build
	BuildStdErr string `json:"build_stderr"`
	// BuildStdOut - build stdout message to associate with the build
	BuildStdOut string `json:"build_stdout"`
	// BuildMessage - general message to associate with the build. Usually not as verbose as the stdout/stderr.
	BuildMessage string `json:"build_message"`
}

type PayloadConfiguration struct {
	Description        string                                `json:"description"`
	PayloadType        string                                `json:"payload_type" binding:"required"`
	C2Profiles         *[]PayloadConfigurationC2Profile      `json:"c2_profiles,omitempty"`
	BuildParameters    *[]PayloadConfigurationBuildParameter `json:"build_parameters,omitempty"`
	Commands           []string                              `json:"commands"`
	SelectedOS         string                                `json:"selected_os" binding:"required"`
	Filename           string                                `json:"filename" binding:"required"`
	WrappedPayloadUUID string                                `json:"wrapped_payload"`
}

type PayloadConfigurationBuildParameter struct {
	Name  string      `json:"name" binding:"required"`
	Value interface{} `json:"value" binding:"required"`
}

type PayloadConfigurationC2Profile struct {
	Name       string                 `json:"c2_profile"`
	IsP2P      bool                   `json:"c2_profile_is_p2p"`
	Parameters map[string]interface{} `json:"c2_profile_parameters"`
}

type PayloadType struct {
	// Name - The name of the payload type that appears in the Mythic UI
	Name string `json:"name"`
	// FileExtension - The default file extension to append to the payload type's name as a placeholder for a filename when generating a payload
	FileExtension string `json:"file_extension"`
	// Author - the name or handle of the author(s) responsible for creating this payload type
	Author string `json:"author"`
	// SupportedOS - An array of operating system names that this payload can compile for. This is used to populate that first dropdown in the Mythic UI when building a payload
	SupportedOS []string `json:"supported_os"`
	// Wrapper - Is this a payload type a wrapper for other payload types or is it a regular payload type
	Wrapper bool `json:"wrapper"`
	// CanBeWrappedByTheFollowingPayloadTypes - Which wrapper payload types does this payload type support (i.e. If this payload type can be supplied to the service_wrapper payload type, list service_wrapper here)
	CanBeWrappedByTheFollowingPayloadTypes []string `json:"supported_wrapper_payload_types"`
	// SupportsDynamicLoading - Does this payload type allow you to dynamically select which commands are loaded into the base payload? If so, set this to True, otherwise all commands are baked into the agent all the time.
	SupportsDynamicLoading bool `json:"supports_dynamic_load"`
	// Description - The description of the payload type to show in the Mythic UI
	Description string `json:"description"`
	// SupportedC2Profiles - The names of the c2 profiles that this payload type supports
	SupportedC2Profiles []string `json:"supported_c2_profiles"`
	// TranslationContainerName - If this payload type uses a translation container, this should be the name of that service
	TranslationContainerName string `json:"translation_container_name"`
	// MythicEncryptsData - If this is True, then Mythic will handle encryption/decryption in messages. If this is false, mythic expects your payload type to have a translation container to handle encryption/decryption on your behalf
	MythicEncryptsData bool `json:"mythic_encrypts"`
	// BuildParameters - A list of build parameters to show to the user during the build process to customize how your payload type's build function operates
	BuildParameters []BuildParameter `json:"build_parameters"`
	// BuildSteps - A list of steps that your build process goes through so that you can report back to the user about the state of the build while it's happening
	BuildSteps []BuildStep `json:"build_steps"`
	// AgentIcon - Don't set this directly, use the agentstructs.AllPayloadData.Get("agentName").AddIcon(filepath.Join(".", "path", "agentname.svg")) call to set this value
	AgentIcon *[]byte `json:"agent_icon"` // automatically filled in based on Name
	// CustomRPCFunctions - The RPC functions you want to expose to other PayloadTypes or C2 Profiles
	CustomRPCFunctions map[string]func(message PTRPCOtherServiceRPCMessage) PTRPCOtherServiceRPCMessageResponse `json:"-"`
	// MessageFormat identifies if the agent uses json or xml messages with Mythic. If you're using a translation container for a custom format, you'd set this to whichever (json/xml) you're going to do your conversions to.
	MessageFormat string `json:"message_format"`
	// AgentType identifies if the payload type is a standard "agent" or if it is another use case like "service" for 3rd party service agents. Currently only "agent" and "service" is valid.
	AgentType string `json:"agent_type"`
}

type PayloadTypeSyncMessage struct {
	PayloadType      PayloadType `json:"payload_type"`
	CommandList      []Command   `json:"commands"`
	ContainerVersion string      `json:"container_version"`
}

type PayloadTypeSyncMessageResponse struct {
	Success bool   `json:"success"`
	Error   string `json:"error"`
}

type PtTaskFunctionCreateTasking func(*PTTaskMessageAllData) PTTaskCreateTaskingMessageResponse

type PtTaskFunctionOPSECPost func(*PTTaskMessageAllData) PTTaskOPSECPostTaskMessageResponse

type PtTaskFunctionOPSECPre func(*PTTaskMessageAllData) PTTTaskOPSECPreTaskMessageResponse

type PtTaskFunctionParseArgDictionary func(args *PTTaskMessageArgsData, input map[string]interface{}) error

type PtTaskFunctionParseArgString func(args *PTTaskMessageArgsData, input string) error

type PtTaskFunctionProcessResponse func(PtTaskProcessResponseMessage) PTTaskProcessResponseMessageResponse

type PtTaskProcessResponseMessage struct {
	TaskData *PTTaskMessageAllData `json:"task"`
	Response interface{}           `json:"response"`
}

type RabbitmqDirectMethod struct {
	RabbitmqRoutingKey         string
	RabbitmqProcessingFunction func([]byte)
}

type RabbitmqRPCMethod struct {
	RabbitmqRoutingKey         string
	RabbitmqProcessingFunction func([]byte) interface{}
}

type SubtaskGroupName = string