toolbox

type AESDecrypt struct {
	EncryptedFiles map[string]*AESEncryptedFile `json:"EncryptedFiles"` // shortcut (\w+) vs file attributes
}

type AESEncryptedFile struct {
	FilePath     string `json:"FilePath"`     // Path to the AES-256-CBC file encrypted by openssl-enc with salt
	FileContent  []byte `json:"-"`            // Encrypted file content
	HexIV        string `json:"HexIV"`        // Hex-encoded AES IV
	IV           []byte `json:"-"`            // IV in bytes
	HexKeyPrefix string `json:"HexKeyPrefix"` // Hex-encoded encryption key, to be prepended to the key given in the command.
	KeyPrefix    []byte `json:"-"`            // Key prefix in bytes
}

type AppCommandRequest struct {
	Command string // Command is a complete app command following the conventional format.
}

type AppCommandResponse struct {
	// Command is the app command that was run.
	Command string
	// ReceivedAt is the timestamp of the command that was received.
	ReceivedAt time.Time
	// Response is the execution result of a previously executed app command.
	Result string
	// Duration is the number of seconds the app command took to run.
	RunDurationSec int
}

type Command struct {
	// ClientTag is the name (or identity) of the origin/actor that made this command input (e.g. caller's phone number or client IP).
	// By convention, if the report came from IP network, then the client tag should be the client IP address.
	ClientTag string
	// DaemonName is the name of daemon that received this command, this is used for logging.
	DaemonName string
	// TimeoutSec is what the daemon thinks the timeout of command execution shall be.
	TimeoutSec int
	// Content is the app command input.
	Content string
}

type CommandFilter interface {
	Transform(Command) (Command, error)
}

type CommandProcessor struct {
	Features       *FeatureSet     // Features is the aggregation of initialised toolbox feature routines.
	CommandFilters []CommandFilter // CommandFilters are applied one by one to alter input command content and/or timeout.
	ResultFilters  []ResultFilter  // ResultFilters are applied one by one to alter command execution result.

	/*
		MaxCmdPerSec is the approximate maximum number of commands allowed to be processed per second.
		The limit is a defensive measure against an attacker trying to guess the correct password by using visiting a daemon
		from large range of source IP addresses in an attempt to bypass daemon's own per-IP rate limit mechanism.
	*/
	MaxCmdPerSec int
	// contains filtered or unexported fields
}

type EnvControl struct {
}

type Feature interface {
	IsConfigured() bool                       // Return true only if configuration is present, this is called prior to Initialise().
	SelfTest() error                          // Validate and test configuration. It may work only after Initialise() succeeds.
	Initialise() error                        // Prepare internal states.
	Trigger() Trigger                         // Return a prefix string that is matched against command input to trigger a feature, each feature has a unique trigger.
	Execute(context.Context, Command) *Result // Execute the command with trigger prefix removed, and return execution result.
}

type FeatureSet struct {
	LookupByTrigger map[Trigger]Feature `json:"-"`

	AESDecrypt             AESDecrypt             `json:"AESDecrypt"`
	EnvControl             EnvControl             `json:"EnvControl"`
	IMAPAccounts           IMAPAccounts           `json:"IMAPAccounts"`
	Joke                   Joke                   `json:"Joke"`
	MessageBank            MessageBank            `json:"MessageBank"`
	NetBoundFileEncryption NetBoundFileEncryption `json:"NetBoundFileEncryption"`
	PublicContact          PublicContact          `json:"PublicContact"`
	RSS                    RSS                    `json:"RSS"`
	SendMail               SendMail               `json:"SendMail"`
	Shell                  Shell                  `json:"Shell"`
	TextSearch             TextSearch             `json:"TextSearch"`
	Twilio                 Twilio                 `json:"Twilio"`
	TwoFACodeGenerator     TwoFACodeGenerator     `json:"TwoFACodeGenerator"`
	WolframAlpha           WolframAlpha           `json:"WolframAlpha"`

	MessageProcessor MessageProcessor `json:"MessageProcessor"`
}

type IMAPAccounts struct {
	Accounts map[string]*IMAPS `json:"Accounts"` // IMAP account name vs account connectivity details
}

type IMAPS struct {
	Host               string `json:"Host"`               // Server name or IP address of IMAPS server
	Port               int    `json:"Port"`               // Port number of IMAPS service
	MailboxName        string `json:"MailboxName"`        // Name of mailbox (e.g. "INBOX")
	InsecureSkipVerify bool   `json:"InsecureSkipVerify"` // Do not verify server name against its certificate
	AuthUsername       string `json:"AuthUsername"`       // Username for plain authentication
	AuthPassword       string `json:"AuthPassword"`       // Password for plain authentication
}

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

type IncomingAppCommand struct {
	Request        SubjectReportRequest
	RunDurationSec int
	Result         Result
}

type Joke struct {
}

type LintText struct {
	TrimSpaces              bool `json:"TrimSpaces"`
	CompressToSingleLine    bool `json:"CompressToSingleLine"`
	KeepVisible7BitCharOnly bool `json:"KeepVisible7BitCharOnly"`
	CompressSpaces          bool `json:"CompressSpaces"`
	BeginPosition           int  `json:"BeginPosition"`
	MaxLength               int  `json:"MaxLength"`
}

type Message struct {
	Time    time.Time
	Content interface{}
}

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

type MessageProcessor struct {
	// SubjectReports is a map of subject's self-reported host name and its most recent reports. The reports are sorted from earliest to latest.
	SubjectReports map[string]*[]SubjectReport `json:"-"`
	// SubjectClientTags is a set of all subject tags collected from the subjects kept in memory.
	// By convention, reports collected over IP network will use the client IP addresses as tag content.
	SubjectClientTags map[string]struct{} `json:"-"`
	// IncomingAppCommands is a map of subject's self reported host name and an app command the subject would like the message processor to run.
	IncomingAppCommands map[string]*IncomingAppCommand `json:"-"`
	/*
		OutgoingAppCommands is a map of subject's self reported host name and an app command that this message processor would like the subject to run.
		This command is delivered to the subject when it sends the next report.
	*/
	OutgoingAppCommands map[string]string `json:"-"`
	// CmdProcessor processes app commands as requested by a remote server.
	CmdProcessor *CommandProcessor `json:"-"`

	/*
		MaxReportsPerHostName is the maximum number of reports to be kept in memory per each subject, each report is identified by the subject's
		self reported host name.
	*/
	MaxReportsPerHostName int `json:"MaxReportsPerHostName"`
	// OwnerName is the name of the component that carries this message processor. This is used for logging purpose.
	OwnerName string `json:"-"`
	// ForwardReportsToKinesis is an optional kinesis client that will get a copy of every subject report.
	ForwardReportsToKinesisFirehose *awsinteg.KinesisHoseClient `json:"-"`
	// KinesisFirehoseStreamName is an optional name of kinesis firehose stream that will get a copy of every subject report.
	KinesisFirehoseStreamName string `json:"-"`
	// ForwardReportsToSNS is an optional SNS client that will get a copy of every subject report.
	ForwardReportsToSNS *awsinteg.SNSClient `json:"-"`
	// SNSTopicARN is an optional ARN (Amazon Resource Name) of an SNS topic that will get a copy of every subject report.
	SNSTopicARN string `json:"-"`
	// contains filtered or unexported fields
}

type NetBoundFileEncryption struct {
	// MaxIntents is the maximum number of password unlocking intents that will be kept in memory to be fulfilled.
	MaxIntents int `json:"MaxIntents"`
	// MaxCallsPerSec is the approximate number of RPC calls a client (identified by its IP) may make in a second.
	MaxCallsPerSec int `json:"MaxCallsPerSec"`
	*netboundfileenc.PasswordRegister
}

type NotifyViaEmail struct {
	Recipients []string        `json:"Recipients"` // Email recipient addresses
	MailClient inet.MailClient `json:"-"`          // MTA that delivers outgoing notification email
	// contains filtered or unexported fields
}

type PINAndShortcuts struct {
	Passwords []string          `json:"Passwords"`
	Shortcuts map[string]string `json:"Shortcuts"`
}

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

type RSS struct {
	/*
		Sources are URLs pointing toward RSS feeds in XML format. If left unspecified, the built-in list of sources that
		point to news headlines will be used.
	*/
	Sources []string `json:"Sources"`
}

type RSSChannel struct {
	Items []RSSItem `xml:"item"`
}

type RSSItem struct {
	Title       string     `xml:"title"`
	Description string     `xml:"description"`
	PubDate     RSSPubDate `xml:"pubDate"`
}

type RSSPubDate struct {
	time.Time
}

type RSSRoot struct {
	Channel RSSChannel `xml:"channel"`
}

type Result struct {
	Command        Command // Help CommandProcessor to keep track of command in execution result
	Error          error   // Result error if there is any
	Output         string  // Human readable normal output excluding error text
	CombinedOutput string  // Human readable error text + normal output. This is set when calling SetCombinedText() function.
}

type ResultFilter interface {
	Transform(*Result) error // Operate on the command result. Return an error if no further transformation shall be done.
	SetLogger(*lalog.Logger) // Assign a logger to use
}

type SARContact struct {
	RegionAbbr string // RegionAbbr is the abbreviation of region name managed/represented by the institution.

	/*
		Type is the institution type:
		GEOS - the home of the International Emergency Response Coordination Centre (IERCC)
		ARCC - aeronautical rescue coordination centre
		MRCC - marine rescue coordination centre
		NMOC - national maritime operation centre
		MSAR - maritime search and rescue
		ASAR - aeronautical search and rescue
		JRCC - joint rescue coordination centre
		MCC - mission control centre
		RCC - rescue coordination centre
	*/
	Type string

	Telephone string // Telephone number of the institution. This is only for voice calls, not for SMS texts.
	Email     string // Email address of the institution.
}

type SayEmptyOutput struct {
}

type SendMail struct {
	MailClient      inet.MailClient `json:"MailClient"`      // MailClient offers mail transport configuration for this toolbox feature.
	SOSPersonalInfo string          `json:"SOSPersonalInfo"` // SOSPersonalInfo is a free-style human-readable text to be sent along with rest of SOS email body.
	// contains filtered or unexported fields
}

type Shell struct {
	// Unrestricted enables execution of all free-form shell statements without
	// limitation.
	// By default only the commands in SafeShellCommands set are permitted.
	Unrestricted bool `json:"Unrestricted"`
	// InterpreterPath is the executable of shell interpreter.
	// It defaults to the shell interpreter auto-discovered from the OS host.
	InterpreterPath string `json:"InterpreterPath"`
}

type SubjectReport struct {
	OriginalRequest SubjectReportRequest // OriginalRequest is the agent's report received by the message processor.

	// SubjectClientTag is the name or identity of the subject as observed by the server daemon (e.g. caller's phone number or client IP).
	// By convention, if the report was collected by the daemon over IP network, then the client tag should be the client IP address.
	SubjectClientTag string
	ServerTime       time.Time // ServerClock is the system time of this computer upon receiving the report.
	DaemonName       string    // DaemonName is the name of server daemon that received this report.
}

type SubjectReportRequest struct {
	// SubjectHostName is the self-reported host name of the subject's computer. Message processor uses the name to uniquely identify the monitored subject.
	SubjectHostName string
	// SubjectIP is the subject's self-reported public IP address. It may potentially differ from the client IP observed by the server daemon receiving this report.
	SubjectIP string
	// SubjectPlatform is the OS and CPU architecture of the subject's computer (GOOS/GOARCH).
	SubjectPlatform string
	// SubjectComment is a free from JSON object/string the subject voluntarily includes in this report.
	SubjectComment interface{}

	// ServerTime is overwritten by server upon receiving the request, it is not supplied by a subject, and only used by the server internally.
	ServerTime time.Time `json:"-"`

	// CommandRequest is an app command that the subject (remote) would like this message processor (local) to run, if any.
	CommandRequest AppCommandRequest
	// CommandResponse is result of app command execution the subject (remote) made in response to command request originated from this message processor (local).
	CommandResponse AppCommandResponse
}

type SubjectReportResponse struct {
	// CommandRequest is an app command that this message processor (local) would like subject (remote) to run.
	CommandRequest AppCommandRequest
	// CommandResponse is the result from app command that subject (remote) previously asked local to execute.
	CommandResponse AppCommandResponse
}

type TOTPWithCommand struct {
	TOTP           string
	ToolboxCommand string
}

type TextSearch struct {
	FilePaths map[string]string `json:"FilePaths"` // FilePaths contains shortcut name VS text file path
}

type TranslateSequences struct {
	Sequences [][]string `json:"Sequences"`
}

type Trigger string // Trigger is a prefix string that is matched against command input to trigger a feature, each feature has a unique trigger.

type Twilio struct {
	PhoneNumber string `json:"PhoneNumber"` // Twilio telephone country code and number (the number you purchased from Twilio)
	AccountSID  string `json:"AccountSID"`  // Twilio account SID ("Account Settings - LIVE Credentials - Account SID")
	AuthToken   string `json:"AuthToken"`   // Twilio authentication secret token ("Account Settings - LIVE Credentials - Auth Token")

	TestPhoneNumber string `json:"-"` // Set by init_test.go for running test case, not a configuration.
}

type TwoFACodeGenerator struct {
	SecretFile *AESEncryptedFile `json:"SecretFile"` // SecretFile has encrypted account name and 2fa secrets
}

type WolframAlpha struct {
	AppID string `json:"AppID"` // WolframAlpha API AppID ("Developer Portal - My Apps - <name> - AppID")
}