mirror of
https://github.com/MrAle98/sliver
synced 2026-06-08 11:54:46 +00:00
Raf
1767 lines
72 KiB
Go
1767 lines
72 KiB
Go
package command
|
||
|
||
/*
|
||
Sliver Implant Framework
|
||
Copyright (C) 2023 Bishop Fox
|
||
|
||
This program is free software: you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation, either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
import (
|
||
"os"
|
||
|
||
"github.com/reeflective/console"
|
||
"github.com/reeflective/console/commands/readline"
|
||
"github.com/rsteube/carapace"
|
||
"github.com/spf13/cobra"
|
||
"github.com/spf13/pflag"
|
||
|
||
"github.com/bishopfox/sliver/client/command/alias"
|
||
"github.com/bishopfox/sliver/client/command/armory"
|
||
"github.com/bishopfox/sliver/client/command/beacons"
|
||
"github.com/bishopfox/sliver/client/command/builders"
|
||
"github.com/bishopfox/sliver/client/command/crack"
|
||
"github.com/bishopfox/sliver/client/command/creds"
|
||
"github.com/bishopfox/sliver/client/command/exit"
|
||
"github.com/bishopfox/sliver/client/command/generate"
|
||
"github.com/bishopfox/sliver/client/command/help"
|
||
"github.com/bishopfox/sliver/client/command/hosts"
|
||
"github.com/bishopfox/sliver/client/command/info"
|
||
"github.com/bishopfox/sliver/client/command/jobs"
|
||
"github.com/bishopfox/sliver/client/command/loot"
|
||
"github.com/bishopfox/sliver/client/command/monitor"
|
||
"github.com/bishopfox/sliver/client/command/operators"
|
||
operator "github.com/bishopfox/sliver/client/command/prelude-operator"
|
||
"github.com/bishopfox/sliver/client/command/reaction"
|
||
"github.com/bishopfox/sliver/client/command/sessions"
|
||
"github.com/bishopfox/sliver/client/command/settings"
|
||
sgn "github.com/bishopfox/sliver/client/command/shikata-ga-nai"
|
||
"github.com/bishopfox/sliver/client/command/update"
|
||
"github.com/bishopfox/sliver/client/command/use"
|
||
"github.com/bishopfox/sliver/client/command/websites"
|
||
"github.com/bishopfox/sliver/client/command/wireguard"
|
||
client "github.com/bishopfox/sliver/client/console"
|
||
consts "github.com/bishopfox/sliver/client/constants"
|
||
"github.com/bishopfox/sliver/client/licenses"
|
||
)
|
||
|
||
// ServerCommands returns all commands bound to the server menu, optionally
|
||
// accepting a function returning a list of additional (admin) commands.
|
||
func ServerCommands(con *client.SliverConsoleClient, serverCmds func() []*cobra.Command) console.Commands {
|
||
serverCommands := func() *cobra.Command {
|
||
server := &cobra.Command{
|
||
Short: "Server commands",
|
||
CompletionOptions: cobra.CompletionOptions{
|
||
HiddenDefaultCmd: true,
|
||
},
|
||
}
|
||
|
||
// Load Reactions
|
||
n, err := reaction.LoadReactions()
|
||
if err != nil && !os.IsNotExist(err) {
|
||
con.PrintErrorf("Failed to load reactions: %s\n", err)
|
||
} else if n > 0 {
|
||
con.PrintInfof("Loaded %d reaction(s) from disk\n", n)
|
||
}
|
||
|
||
// [ Groups ] ----------------------------------------------
|
||
groups := []*cobra.Group{
|
||
{ID: consts.GenericHelpGroup, Title: consts.GenericHelpGroup},
|
||
{ID: consts.NetworkHelpGroup, Title: consts.NetworkHelpGroup},
|
||
{ID: consts.PayloadsHelpGroup, Title: consts.PayloadsHelpGroup},
|
||
{ID: consts.SliverHelpGroup, Title: consts.SliverHelpGroup},
|
||
}
|
||
server.AddGroup(groups...)
|
||
|
||
// [ Exit ] ---------------------------------------------------------------
|
||
exitCmd := &cobra.Command{
|
||
Use: "exit",
|
||
Short: "Exit the program",
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
exit.ExitCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.GenericHelpGroup,
|
||
}
|
||
server.AddCommand(exitCmd)
|
||
|
||
// [ Aliases ] ---------------------------------------------
|
||
|
||
aliasCmd := &cobra.Command{
|
||
Use: consts.AliasesStr,
|
||
Short: "List current aliases",
|
||
Long: help.GetHelpFor([]string{consts.AliasesStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
alias.AliasesCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.GenericHelpGroup,
|
||
}
|
||
server.AddCommand(aliasCmd)
|
||
|
||
aliasLoadCmd := &cobra.Command{
|
||
Use: consts.LoadStr + " [ALIAS]",
|
||
Short: "Load a command alias",
|
||
Long: help.GetHelpFor([]string{consts.AliasesStr, consts.LoadStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
alias.AliasesLoadCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(aliasLoadCmd).PositionalCompletion(
|
||
carapace.ActionDirectories().Tag("alias directory").Usage("path to the alias directory"))
|
||
aliasCmd.AddCommand(aliasLoadCmd)
|
||
|
||
aliasInstallCmd := &cobra.Command{
|
||
Use: consts.InstallStr + " [ALIAS]",
|
||
Short: "Install a command alias",
|
||
Long: help.GetHelpFor([]string{consts.AliasesStr, consts.InstallStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
alias.AliasesInstallCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(aliasInstallCmd).PositionalCompletion(carapace.ActionFiles().Tag("alias file"))
|
||
aliasCmd.AddCommand(aliasInstallCmd)
|
||
|
||
aliasRemove := &cobra.Command{
|
||
Use: consts.RmStr + " [ALIAS]",
|
||
Short: "Remove an alias",
|
||
Long: help.GetHelpFor([]string{consts.RmStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
alias.AliasesRemoveCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(aliasRemove).PositionalCompletion(alias.AliasCompleter())
|
||
aliasCmd.AddCommand(aliasRemove)
|
||
|
||
// [ Armory ] ---------------------------------------------
|
||
|
||
armoryCmd := &cobra.Command{
|
||
Use: consts.ArmoryStr,
|
||
Short: "Automatically download and install extensions/aliases",
|
||
Long: help.GetHelpFor([]string{consts.ArmoryStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
armory.ArmoryCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.GenericHelpGroup,
|
||
}
|
||
Flags("armory", true, armoryCmd, func(f *pflag.FlagSet) {
|
||
f.BoolP("insecure", "I", false, "skip tls certificate validation")
|
||
f.StringP("proxy", "p", "", "specify a proxy url (e.g. http://localhost:8080)")
|
||
f.BoolP("ignore-cache", "c", false, "ignore metadata cache, force refresh")
|
||
f.StringP("timeout", "t", "15m", "download timeout")
|
||
})
|
||
server.AddCommand(armoryCmd)
|
||
|
||
armoryInstallCmd := &cobra.Command{
|
||
Use: consts.InstallStr,
|
||
Short: "Install an alias or extension",
|
||
Long: help.GetHelpFor([]string{consts.ArmoryStr, consts.InstallStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
armory.ArmoryInstallCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(armoryInstallCmd).PositionalCompletion(
|
||
armory.AliasExtensionOrBundleCompleter().Usage("name of the extension or alias to install"))
|
||
armoryCmd.AddCommand(armoryInstallCmd)
|
||
|
||
armoryUpdateCmd := &cobra.Command{
|
||
Use: consts.UpdateStr,
|
||
Short: "Update installed an aliases and extensions",
|
||
Long: help.GetHelpFor([]string{consts.ArmoryStr, consts.UpdateStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
armory.ArmoryUpdateCmd(cmd, con, args)
|
||
},
|
||
}
|
||
armoryCmd.AddCommand(armoryUpdateCmd)
|
||
|
||
armorySearchCmd := &cobra.Command{
|
||
Use: consts.SearchStr,
|
||
Short: "Search for aliases and extensions by name (regex)",
|
||
Long: help.GetHelpFor([]string{consts.ArmoryStr, consts.SearchStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
armory.ArmorySearchCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(armorySearchCmd).PositionalCompletion(carapace.ActionValues().Usage("a name regular expression"))
|
||
armoryCmd.AddCommand(armorySearchCmd)
|
||
|
||
// [ Update ] --------------------------------------------------------------
|
||
|
||
updateCmd := &cobra.Command{
|
||
Use: consts.UpdateStr,
|
||
Short: "Check for updates",
|
||
Long: help.GetHelpFor([]string{consts.UpdateStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
update.UpdateCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.GenericHelpGroup,
|
||
}
|
||
Flags("update", false, updateCmd, func(f *pflag.FlagSet) {
|
||
f.BoolP("prereleases", "P", false, "include pre-released (unstable) versions")
|
||
f.StringP("proxy", "p", "", "specify a proxy url (e.g. http://localhost:8080)")
|
||
f.StringP("save", "s", "", "save downloaded files to specific directory (default user home dir)")
|
||
f.BoolP("insecure", "I", false, "skip tls certificate validation")
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
server.AddCommand(updateCmd)
|
||
|
||
versionCmd := &cobra.Command{
|
||
Use: consts.VersionStr,
|
||
Short: "Display version information",
|
||
Long: help.GetHelpFor([]string{consts.VersionStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
update.VerboseVersionsCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.GenericHelpGroup,
|
||
}
|
||
Flags("update", false, versionCmd, func(f *pflag.FlagSet) {
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
server.AddCommand(versionCmd)
|
||
|
||
// [ Jobs ] -----------------------------------------------------------------
|
||
|
||
jobsCmd := &cobra.Command{
|
||
Use: consts.JobsStr,
|
||
Short: "Job control",
|
||
Long: help.GetHelpFor([]string{consts.JobsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
jobs.JobsCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.NetworkHelpGroup,
|
||
}
|
||
Flags("jobs", true, jobsCmd, func(f *pflag.FlagSet) {
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
Flags("jobs", false, jobsCmd, func(f *pflag.FlagSet) {
|
||
f.Int32P("kill", "k", -1, "kill a background job")
|
||
f.BoolP("kill-all", "K", false, "kill all jobs")
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
FlagComps(jobsCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["kill"] = jobs.JobsIDCompleter(con)
|
||
})
|
||
server.AddCommand(jobsCmd)
|
||
|
||
mtlsCmd := &cobra.Command{
|
||
Use: consts.MtlsStr,
|
||
Short: "Start an mTLS listener",
|
||
Long: help.GetHelpFor([]string{consts.MtlsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
jobs.MTLSListenerCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.NetworkHelpGroup,
|
||
}
|
||
Flags("mTLS listener", false, mtlsCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("lhost", "L", "", "interface to bind server to")
|
||
f.Uint32P("lport", "l", generate.DefaultMTLSLPort, "tcp listen port")
|
||
f.BoolP("persistent", "p", false, "make persistent across restarts")
|
||
})
|
||
server.AddCommand(mtlsCmd)
|
||
|
||
wgCmd := &cobra.Command{
|
||
Use: consts.WGStr,
|
||
Short: "Start a WireGuard listener",
|
||
Long: help.GetHelpFor([]string{consts.WGStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
jobs.WGListenerCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.NetworkHelpGroup,
|
||
}
|
||
Flags("WireGuard listener", false, wgCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("lhost", "L", "", "interface to bind server to")
|
||
f.Uint32P("lport", "l", generate.DefaultWGLPort, "udp listen port")
|
||
f.Uint32P("nport", "n", generate.DefaultWGNPort, "virtual tun interface listen port")
|
||
f.Uint32P("key-port", "x", generate.DefaultWGKeyExPort, "virtual tun interface key exchange port")
|
||
f.BoolP("persistent", "p", false, "make persistent across restarts")
|
||
})
|
||
server.AddCommand(wgCmd)
|
||
|
||
dnsCmd := &cobra.Command{
|
||
Use: consts.DnsStr,
|
||
Short: "Start a DNS listener",
|
||
Long: help.GetHelpFor([]string{consts.DnsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
jobs.DNSListenerCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.NetworkHelpGroup,
|
||
}
|
||
Flags("DNS listener", false, dnsCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("domains", "d", "", "parent domain(s) to use for DNS c2")
|
||
f.BoolP("no-canaries", "c", false, "disable dns canary detection")
|
||
f.StringP("lhost", "L", "", "interface to bind server to")
|
||
f.Uint32P("lport", "l", generate.DefaultDNSLPort, "udp listen port")
|
||
f.BoolP("disable-otp", "D", false, "disable otp authentication")
|
||
f.BoolP("persistent", "p", false, "make persistent across restarts")
|
||
})
|
||
server.AddCommand(dnsCmd)
|
||
|
||
httpCmd := &cobra.Command{
|
||
Use: consts.HttpStr,
|
||
Short: "Start an HTTP listener",
|
||
Long: help.GetHelpFor([]string{consts.HttpStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
jobs.HTTPListenerCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.NetworkHelpGroup,
|
||
}
|
||
Flags("HTTP listener", false, httpCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("domain", "d", "", "limit responses to specific domain")
|
||
f.StringP("website", "w", "", "website name (see websites cmd)")
|
||
f.StringP("lhost", "L", "", "interface to bind server to")
|
||
f.Uint32P("lport", "l", generate.DefaultHTTPLPort, "tcp listen port")
|
||
f.BoolP("disable-otp", "D", false, "disable otp authentication")
|
||
f.StringP("long-poll-timeout", "T", "1s", "server-side long poll timeout")
|
||
f.StringP("long-poll-jitter", "J", "2s", "server-side long poll jitter")
|
||
f.BoolP("persistent", "p", false, "make persistent across restarts")
|
||
})
|
||
server.AddCommand(httpCmd)
|
||
|
||
httpsCmd := &cobra.Command{
|
||
Use: consts.HttpsStr,
|
||
Short: "Start an HTTPS listener",
|
||
Long: help.GetHelpFor([]string{consts.HttpsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
jobs.HTTPSListenerCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.NetworkHelpGroup,
|
||
}
|
||
Flags("HTTPS listener", false, httpsCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("domain", "d", "", "limit responses to specific domain")
|
||
f.StringP("website", "w", "", "website name (see websites cmd)")
|
||
f.StringP("lhost", "L", "", "interface to bind server to")
|
||
f.Uint32P("lport", "l", generate.DefaultHTTPSLPort, "tcp listen port")
|
||
f.BoolP("disable-otp", "D", false, "disable otp authentication")
|
||
f.StringP("long-poll-timeout", "T", "1s", "server-side long poll timeout")
|
||
f.StringP("long-poll-jitter", "J", "2s", "server-side long poll jitter")
|
||
|
||
f.StringP("cert", "c", "", "PEM encoded certificate file")
|
||
f.StringP("key", "k", "", "PEM encoded private key file")
|
||
f.BoolP("lets-encrypt", "e", false, "attempt to provision a let's encrypt certificate")
|
||
f.BoolP("disable-randomized-jarm", "E", false, "disable randomized jarm fingerprints")
|
||
|
||
f.BoolP("persistent", "p", false, "make persistent across restarts")
|
||
})
|
||
server.AddCommand(httpsCmd)
|
||
|
||
stageCmd := &cobra.Command{
|
||
Use: consts.StageListenerStr,
|
||
Short: "Start a stager listener",
|
||
Long: help.GetHelpFor([]string{consts.StageListenerStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
jobs.StageListenerCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.NetworkHelpGroup,
|
||
}
|
||
Flags("stage listener", false, stageCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("profile", "p", "", "implant profile name to link with the listener")
|
||
f.StringP("url", "u", "", "URL to which the stager will call back to")
|
||
f.StringP("cert", "c", "", "path to PEM encoded certificate file (HTTPS only)")
|
||
f.StringP("key", "k", "", "path to PEM encoded private key file (HTTPS only)")
|
||
f.BoolP("lets-encrypt", "e", false, "attempt to provision a let's encrypt certificate (HTTPS only)")
|
||
f.String("aes-encrypt-key", "", "encrypt stage with AES encryption key")
|
||
f.String("aes-encrypt-iv", "", "encrypt stage with AES encryption iv")
|
||
f.StringP("compress", "C", "none", "compress the stage before encrypting (zlib, gzip, deflate9, none)")
|
||
f.BoolP("prepend-size", "P", false, "prepend the size of the stage to the payload (to use with MSF stagers)")
|
||
})
|
||
FlagComps(stageCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["profile"] = generate.ProfileNameCompleter(con)
|
||
(*comp)["cert"] = carapace.ActionFiles().Tag("certificate file")
|
||
(*comp)["key"] = carapace.ActionFiles().Tag("key file")
|
||
(*comp)["compress"] = carapace.ActionValues([]string{"zlib", "gzip", "deflate9", "none"}...).Tag("compression formats")
|
||
})
|
||
server.AddCommand(stageCmd)
|
||
|
||
// [ Operators ] --------------------------------------------------------------
|
||
|
||
operatorsCmd := &cobra.Command{
|
||
Use: consts.OperatorsStr,
|
||
Short: "Manage operators",
|
||
Long: help.GetHelpFor([]string{consts.OperatorsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
operators.OperatorsCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.GenericHelpGroup,
|
||
}
|
||
Flags("operators", false, operatorsCmd, func(f *pflag.FlagSet) {
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
server.AddCommand(operatorsCmd)
|
||
|
||
// Server-only commands.
|
||
if serverCmds != nil {
|
||
server.AddGroup(&cobra.Group{ID: consts.MultiplayerHelpGroup, Title: consts.MultiplayerHelpGroup})
|
||
server.AddCommand(serverCmds()...)
|
||
}
|
||
|
||
// [ Sessions ] --------------------------------------------------------------
|
||
|
||
sessionsCmd := &cobra.Command{
|
||
Use: consts.SessionsStr,
|
||
Short: "Session management",
|
||
Long: help.GetHelpFor([]string{consts.SessionsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
sessions.SessionsCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.SliverHelpGroup,
|
||
}
|
||
Flags("sessions", true, sessionsCmd, func(f *pflag.FlagSet) {
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
Flags("sessions", false, sessionsCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("interact", "i", "", "interact with a session")
|
||
f.StringP("kill", "k", "", "kill the designated session")
|
||
f.BoolP("kill-all", "K", false, "kill all the sessions")
|
||
f.BoolP("clean", "C", false, "clean out any sessions marked as [DEAD]")
|
||
f.BoolP("force", "F", false, "force session action without waiting for results")
|
||
|
||
f.StringP("filter", "f", "", "filter sessions by substring")
|
||
f.StringP("filter-re", "e", "", "filter sessions by regular expression")
|
||
})
|
||
FlagComps(sessionsCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["interact"] = use.BeaconAndSessionIDCompleter(con)
|
||
(*comp)["kill"] = use.BeaconAndSessionIDCompleter(con)
|
||
})
|
||
server.AddCommand(sessionsCmd)
|
||
|
||
sessionsPruneCmd := &cobra.Command{
|
||
Use: consts.PruneStr,
|
||
Short: "Kill all stale/dead sessions",
|
||
Long: help.GetHelpFor([]string{consts.SessionsStr, consts.PruneStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
sessions.SessionsPruneCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("prune", false, sessionsPruneCmd, func(f *pflag.FlagSet) {
|
||
f.BoolP("force", "F", false, "Force the killing of stale/dead sessions")
|
||
})
|
||
sessionsCmd.AddCommand(sessionsPruneCmd)
|
||
|
||
// [ Use ] --------------------------------------------------------------
|
||
|
||
useCmd := &cobra.Command{
|
||
Use: consts.UseStr,
|
||
Short: "Switch the active session or beacon",
|
||
Long: help.GetHelpFor([]string{consts.UseStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
use.UseCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.SliverHelpGroup,
|
||
}
|
||
Flags("use", true, useCmd, func(f *pflag.FlagSet) {
|
||
f.Int64P("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
carapace.Gen(useCmd).PositionalCompletion(use.BeaconAndSessionIDCompleter(con))
|
||
server.AddCommand(useCmd)
|
||
|
||
useSessionCmd := &cobra.Command{
|
||
Use: consts.SessionsStr,
|
||
Short: "Switch the active session",
|
||
Long: help.GetHelpFor([]string{consts.UseStr, consts.SessionsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
use.UseSessionCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(useSessionCmd).PositionalCompletion(use.SessionIDCompleter(con))
|
||
useCmd.AddCommand(useSessionCmd)
|
||
|
||
useBeaconCmd := &cobra.Command{
|
||
Use: consts.BeaconsStr,
|
||
Short: "Switch the active beacon",
|
||
Long: help.GetHelpFor([]string{consts.UseStr, consts.BeaconsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
use.UseBeaconCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(useBeaconCmd).PositionalCompletion(use.BeaconIDCompleter(con))
|
||
useCmd.AddCommand(useBeaconCmd)
|
||
|
||
// [ Settings ] --------------------------------------------------------------
|
||
|
||
settingsCmd := &cobra.Command{
|
||
Use: consts.SettingsStr,
|
||
Short: "Manage client settings",
|
||
Long: help.GetHelpFor([]string{consts.SettingsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
settings.SettingsCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.GenericHelpGroup,
|
||
}
|
||
settingsCmd.AddCommand(&cobra.Command{
|
||
Use: consts.SaveStr,
|
||
Short: "Save the current settings to disk",
|
||
Long: help.GetHelpFor([]string{consts.SettingsStr, consts.SaveStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
settings.SettingsSaveCmd(cmd, con, args)
|
||
},
|
||
})
|
||
settingsCmd.AddCommand(&cobra.Command{
|
||
Use: consts.TablesStr,
|
||
Short: "Modify tables setting (style)",
|
||
Long: help.GetHelpFor([]string{consts.SettingsStr, consts.TablesStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
settings.SettingsTablesCmd(cmd, con, args)
|
||
},
|
||
})
|
||
settingsCmd.AddCommand(&cobra.Command{
|
||
Use: "beacon-autoresults",
|
||
Short: "Automatically display beacon task results when completed",
|
||
Long: help.GetHelpFor([]string{consts.SettingsStr, "beacon-autoresults"}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
settings.SettingsBeaconsAutoResultCmd(cmd, con, args)
|
||
},
|
||
})
|
||
settingsCmd.AddCommand(&cobra.Command{
|
||
Use: "autoadult",
|
||
Short: "Automatically accept OPSEC warnings",
|
||
Long: help.GetHelpFor([]string{consts.SettingsStr, "autoadult"}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
settings.SettingsAutoAdultCmd(cmd, con, args)
|
||
},
|
||
})
|
||
settingsCmd.AddCommand(&cobra.Command{
|
||
Use: "always-overflow",
|
||
Short: "Disable table pagination",
|
||
Long: help.GetHelpFor([]string{consts.SettingsStr, "always-overflow"}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
settings.SettingsAlwaysOverflow(cmd, con, args)
|
||
},
|
||
})
|
||
settingsCmd.AddCommand(&cobra.Command{
|
||
Use: "small-terminal",
|
||
Short: "Set the small terminal width",
|
||
Long: help.GetHelpFor([]string{consts.SettingsStr, "small-terminal"}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
settings.SettingsSmallTerm(cmd, con, args)
|
||
},
|
||
})
|
||
settingsCmd.AddCommand(&cobra.Command{
|
||
Use: "user-connect",
|
||
Short: "Enable user connections/disconnections (can be very verbose when they use CLI)",
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
settings.SettingsUserConnect(cmd, con, args)
|
||
},
|
||
})
|
||
settingsCmd.AddCommand(&cobra.Command{
|
||
Use: "console-logs",
|
||
Short: "Log console output (toggle)",
|
||
Long: help.GetHelpFor([]string{consts.SettingsStr, "console-logs"}),
|
||
Run: func(ctx *cobra.Command, args []string) {
|
||
settings.SettingsConsoleLogs(ctx, con)
|
||
},
|
||
})
|
||
server.AddCommand(settingsCmd)
|
||
|
||
// [ Info ] --------------------------------------------------------------
|
||
|
||
infoCmd := &cobra.Command{
|
||
Use: consts.InfoStr,
|
||
Short: "Get info about session",
|
||
Long: help.GetHelpFor([]string{consts.InfoStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
info.InfoCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.SliverHelpGroup,
|
||
}
|
||
Flags("use", false, infoCmd, func(f *pflag.FlagSet) {
|
||
f.Int64P("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
carapace.Gen(infoCmd).PositionalCompletion(use.BeaconAndSessionIDCompleter(con))
|
||
server.AddCommand(infoCmd)
|
||
|
||
// [ Shellcode Encoders ] --------------------------------------------------------------
|
||
|
||
shikataGaNaiCmd := &cobra.Command{
|
||
Use: consts.ShikataGaNai,
|
||
Short: "Polymorphic binary shellcode encoder (ノ ゜Д゜)ノ ︵ 仕方がない",
|
||
Long: help.GetHelpFor([]string{consts.ShikataGaNai}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
sgn.ShikataGaNaiCmd(cmd, con, args)
|
||
},
|
||
Args: cobra.ExactArgs(1),
|
||
GroupID: consts.PayloadsHelpGroup,
|
||
}
|
||
server.AddCommand(shikataGaNaiCmd)
|
||
Flags("shikata ga nai", false, shikataGaNaiCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("save", "s", "", "save output to local file")
|
||
f.StringP("arch", "a", "amd64", "architecture of shellcode")
|
||
f.IntP("iterations", "i", 1, "number of iterations")
|
||
f.StringP("bad-chars", "b", "", "hex encoded bad characters to avoid (e.g. 0001)")
|
||
f.Int64P("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
FlagComps(shikataGaNaiCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["arch"] = carapace.ActionValues("386", "amd64").Tag("shikata-ga-nai architectures")
|
||
(*comp)["save"] = carapace.ActionFiles().Tag("directory/file to save shellcode")
|
||
})
|
||
carapace.Gen(shikataGaNaiCmd).PositionalCompletion(carapace.ActionFiles().Tag("shellcode file"))
|
||
|
||
// [ Generate ] --------------------------------------------------------------
|
||
|
||
generateCmd := &cobra.Command{
|
||
Use: consts.GenerateStr,
|
||
Short: "Generate an implant binary",
|
||
Long: help.GetHelpFor([]string{consts.GenerateStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.GenerateCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.PayloadsHelpGroup,
|
||
}
|
||
Flags("generate", true, generateCmd, func(f *pflag.FlagSet) {
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
Flags("session", false, generateCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("os", "o", "windows", "operating system")
|
||
f.StringP("arch", "a", "amd64", "cpu architecture")
|
||
f.StringP("name", "N", "", "agent name")
|
||
f.BoolP("debug", "d", false, "enable debug features")
|
||
f.StringP("debug-file", "O", "", "path to debug output")
|
||
f.BoolP("evasion", "e", false, "enable evasion features (e.g. overwrite user space hooks)")
|
||
f.BoolP("skip-symbols", "l", false, "skip symbol obfuscation")
|
||
f.StringP("template", "I", "sliver", "implant code template")
|
||
f.BoolP("external-builder", "E", false, "use an external builder")
|
||
f.BoolP("disable-sgn", "G", false, "disable shikata ga nai shellcode encoder")
|
||
|
||
f.StringP("canary", "c", "", "canary domain(s)")
|
||
|
||
f.StringP("mtls", "m", "", "mtls connection strings")
|
||
f.StringP("wg", "g", "", "wg connection strings")
|
||
f.StringP("http", "b", "", "http(s) connection strings")
|
||
f.StringP("dns", "n", "", "dns connection strings")
|
||
f.StringP("named-pipe", "p", "", "named-pipe connection strings")
|
||
f.StringP("tcp-pivot", "i", "", "tcp-pivot connection strings")
|
||
|
||
f.Uint32P("key-exchange", "X", generate.DefaultWGKeyExPort, "wg key-exchange port")
|
||
f.Uint32P("tcp-comms", "T", generate.DefaultWGNPort, "wg c2 comms port")
|
||
|
||
f.BoolP("run-at-load", "R", false, "run the implant entrypoint from DllMain/Constructor (shared library only)")
|
||
f.BoolP("netgo", "q", false, "force the use of netgo")
|
||
f.StringP("traffic-encoders", "A", "", "comma separated list of traffic encoders to enable")
|
||
|
||
f.StringP("strategy", "Z", "", "specify a connection strategy (r = random, rd = random domain, s = sequential)")
|
||
f.Int64P("reconnect", "j", generate.DefaultReconnect, "attempt to reconnect every n second(s)")
|
||
f.Int64P("poll-timeout", "P", generate.DefaultPollTimeout, "long poll request timeout")
|
||
f.Uint32P("max-errors", "k", generate.DefaultMaxErrors, "max number of connection errors")
|
||
|
||
f.StringP("limit-datetime", "w", "", "limit execution to before datetime")
|
||
f.BoolP("limit-domainjoined", "x", false, "limit execution to domain joined machines")
|
||
f.StringP("limit-username", "y", "", "limit execution to specified username")
|
||
f.StringP("limit-hostname", "z", "", "limit execution to specified hostname")
|
||
f.StringP("limit-fileexists", "F", "", "limit execution to hosts with this file in the filesystem")
|
||
f.StringP("limit-locale", "L", "", "limit execution to hosts that match this locale")
|
||
|
||
f.StringP("format", "f", "exe", "Specifies the output formats, valid values are: 'exe', 'shared' (for dynamic libraries), 'service' (see: `psexec` for more info) and 'shellcode' (windows only)")
|
||
f.StringP("save", "s", "", "directory/file to the binary to")
|
||
})
|
||
FlagComps(generateCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["debug-file"] = carapace.ActionFiles()
|
||
(*comp)["os"] = generate.OSCompleter(con)
|
||
(*comp)["arch"] = generate.ArchCompleter(con)
|
||
(*comp)["strategy"] = carapace.ActionValuesDescribed([]string{"r", "random", "rd", "random domain", "s", "sequential"}...).Tag("C2 strategy")
|
||
(*comp)["format"] = generate.FormatCompleter()
|
||
(*comp)["save"] = carapace.ActionFiles().Tag("directory/file to save implant")
|
||
})
|
||
server.AddCommand(generateCmd)
|
||
|
||
generateBeaconCmd := &cobra.Command{
|
||
Use: consts.BeaconStr,
|
||
Short: "Generate a beacon binary",
|
||
Long: help.GetHelpFor([]string{consts.GenerateStr, consts.BeaconStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.GenerateBeaconCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("beacon", false, generateBeaconCmd, func(f *pflag.FlagSet) {
|
||
f.Int64P("days", "D", 0, "beacon interval days")
|
||
f.Int64P("hours", "H", 0, "beacon interval hours")
|
||
f.Int64P("minutes", "M", 0, "beacon interval minutes")
|
||
f.Int64P("seconds", "S", 60, "beacon interval seconds")
|
||
f.Int64P("jitter", "J", 30, "beacon interval jitter in seconds")
|
||
|
||
// Generate flags
|
||
f.StringP("os", "o", "windows", "operating system")
|
||
f.StringP("arch", "a", "amd64", "cpu architecture")
|
||
f.StringP("name", "N", "", "agent name")
|
||
f.BoolP("debug", "d", false, "enable debug features")
|
||
f.StringP("debug-file", "O", "", "path to debug output")
|
||
f.BoolP("evasion", "e", false, "enable evasion features (e.g. overwrite user space hooks)")
|
||
f.BoolP("skip-symbols", "l", false, "skip symbol obfuscation")
|
||
f.StringP("template", "I", "sliver", "implant code template")
|
||
f.BoolP("external-builder", "E", false, "use an external builder")
|
||
f.BoolP("disable-sgn", "G", false, "disable shikata ga nai shellcode encoder")
|
||
|
||
f.StringP("canary", "c", "", "canary domain(s)")
|
||
|
||
f.StringP("mtls", "m", "", "mtls connection strings")
|
||
f.StringP("wg", "g", "", "wg connection strings")
|
||
f.StringP("http", "b", "", "http(s) connection strings")
|
||
f.StringP("dns", "n", "", "dns connection strings")
|
||
f.StringP("named-pipe", "p", "", "named-pipe connection strings")
|
||
f.StringP("tcp-pivot", "i", "", "tcp-pivot connection strings")
|
||
|
||
f.Uint32P("key-exchange", "X", generate.DefaultWGKeyExPort, "wg key-exchange port")
|
||
f.Uint32P("tcp-comms", "T", generate.DefaultWGNPort, "wg c2 comms port")
|
||
|
||
f.BoolP("run-at-load", "R", false, "run the implant entrypoint from DllMain/Constructor (shared library only)")
|
||
f.BoolP("netgo", "q", false, "force the use of netgo")
|
||
f.StringP("traffic-encoders", "A", "", "comma separated list of traffic encoders to enable")
|
||
|
||
f.StringP("strategy", "Z", "", "specify a connection strategy (r = random, rd = random domain, s = sequential)")
|
||
f.Int64P("reconnect", "j", generate.DefaultReconnect, "attempt to reconnect every n second(s)")
|
||
f.Int64P("poll-timeout", "P", generate.DefaultPollTimeout, "long poll request timeout")
|
||
f.Uint32P("max-errors", "k", generate.DefaultMaxErrors, "max number of connection errors")
|
||
|
||
f.StringP("limit-datetime", "w", "", "limit execution to before datetime")
|
||
f.BoolP("limit-domainjoined", "x", false, "limit execution to domain joined machines")
|
||
f.StringP("limit-username", "y", "", "limit execution to specified username")
|
||
f.StringP("limit-hostname", "z", "", "limit execution to specified hostname")
|
||
f.StringP("limit-fileexists", "F", "", "limit execution to hosts with this file in the filesystem")
|
||
f.StringP("limit-locale", "L", "", "limit execution to hosts that match this locale")
|
||
|
||
f.StringP("format", "f", "exe", "Specifies the output formats, valid values are: 'exe', 'shared' (for dynamic libraries), 'service' (see: `psexec` for more info) and 'shellcode' (windows only)")
|
||
f.StringP("save", "s", "", "directory/file to the binary to")
|
||
})
|
||
FlagComps(generateBeaconCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["debug-file"] = carapace.ActionFiles()
|
||
(*comp)["os"] = generate.OSCompleter(con)
|
||
(*comp)["arch"] = generate.ArchCompleter(con)
|
||
(*comp)["strategy"] = carapace.ActionValuesDescribed([]string{"r", "random", "rd", "random domain", "s", "sequential"}...).Tag("C2 strategy")
|
||
(*comp)["format"] = generate.FormatCompleter()
|
||
(*comp)["save"] = carapace.ActionFiles().Tag("directory/file to save implant")
|
||
})
|
||
generateCmd.AddCommand(generateBeaconCmd)
|
||
|
||
generateStagerCmd := &cobra.Command{
|
||
Use: consts.MsfStagerStr,
|
||
Short: "Generate a stager using Metasploit (requires local Metasploit installation)",
|
||
Long: help.GetHelpFor([]string{consts.MsfStagerStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.GenerateStagerCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("stager", false, generateStagerCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("os", "o", "windows", "operating system")
|
||
f.StringP("arch", "a", "amd64", "cpu architecture")
|
||
f.StringP("lhost", "L", "", "Listening host")
|
||
f.Uint32P("lport", "l", 8443, "Listening port")
|
||
f.StringP("protocol", "r", "tcp", "Staging protocol (tcp/http/https)")
|
||
f.StringP("format", "f", "raw", "Output format (msfvenom formats, see help generate msf-stager for the list)")
|
||
f.StringP("badchars", "b", "", "bytes to exclude from stage shellcode")
|
||
f.StringP("save", "s", "", "directory to save the generated stager to")
|
||
f.StringP("advanced", "d", "", "Advanced options for the stager using URI query syntax (option1=value1&option2=value2...)")
|
||
})
|
||
generateCmd.AddCommand(generateStagerCmd)
|
||
|
||
generateInfoCmd := &cobra.Command{
|
||
Use: consts.CompilerInfoStr,
|
||
Short: "Get information about the server's compiler",
|
||
Long: help.GetHelpFor([]string{consts.CompilerInfoStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.GenerateInfoCmd(cmd, con, args)
|
||
},
|
||
}
|
||
generateCmd.AddCommand(generateInfoCmd)
|
||
|
||
// Traffic Encoder SubCommands
|
||
trafficEncodersCmd := &cobra.Command{
|
||
Use: consts.TrafficEncodersStr,
|
||
Short: "Manage implant traffic encoders",
|
||
Long: help.GetHelpFor([]string{consts.GenerateStr, consts.TrafficEncodersStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.TrafficEncodersCmd(cmd, con, args)
|
||
},
|
||
}
|
||
generateCmd.AddCommand(trafficEncodersCmd)
|
||
|
||
trafficEncodersAddCmd := &cobra.Command{
|
||
Use: consts.AddStr,
|
||
Short: "Add a new traffic encoder to the server from the local file system",
|
||
Long: help.GetHelpFor([]string{consts.GenerateStr, consts.TrafficEncodersStr, consts.AddStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.TrafficEncodersAddCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("", false, trafficEncodersAddCmd, func(f *pflag.FlagSet) {
|
||
f.BoolP("skip-tests", "s", false, "skip testing the traffic encoder (not recommended)")
|
||
})
|
||
carapace.Gen(trafficEncodersAddCmd).PositionalCompletion(carapace.ActionFiles("wasm").Tag("wasm files").Usage("local file path (expects .wasm)"))
|
||
trafficEncodersCmd.AddCommand(trafficEncodersAddCmd)
|
||
|
||
trafficEncodersRmCmd := &cobra.Command{
|
||
Use: consts.RmStr,
|
||
Short: "Remove a traffic encoder from the server",
|
||
Long: help.GetHelpFor([]string{consts.GenerateStr, consts.TrafficEncodersStr, consts.RmStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.TrafficEncodersRemoveCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(trafficEncodersRmCmd).PositionalCompletion(generate.TrafficEncodersCompleter(con).Usage("traffic encoder to remove"))
|
||
trafficEncodersCmd.AddCommand(trafficEncodersRmCmd)
|
||
|
||
// [ Regenerate ] --------------------------------------------------------------
|
||
|
||
regenerateCmd := &cobra.Command{
|
||
Use: consts.RegenerateStr,
|
||
Short: "Regenerate an implant",
|
||
Long: help.GetHelpFor([]string{consts.RegenerateStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.RegenerateCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.PayloadsHelpGroup,
|
||
}
|
||
Flags("regenerate", false, regenerateCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("save", "s", "", "directory/file to the binary to")
|
||
})
|
||
FlagComps(regenerateCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["save"] = carapace.ActionFiles().Tag("directory/file to save implant")
|
||
})
|
||
carapace.Gen(regenerateCmd).PositionalCompletion(generate.ImplantBuildNameCompleter(con))
|
||
server.AddCommand(regenerateCmd)
|
||
|
||
// [ Profiles ] --------------------------------------------------------------
|
||
|
||
profilesCmd := &cobra.Command{
|
||
Use: consts.ProfilesStr,
|
||
Short: "List existing profiles",
|
||
Long: help.GetHelpFor([]string{consts.ProfilesStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.ProfilesCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.PayloadsHelpGroup,
|
||
}
|
||
Flags("profiles", true, profilesCmd, func(f *pflag.FlagSet) {
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
server.AddCommand(profilesCmd)
|
||
|
||
profilesGenerateCmd := &cobra.Command{
|
||
Use: consts.GenerateStr,
|
||
Short: "Generate implant from a profile",
|
||
Long: help.GetHelpFor([]string{consts.ProfilesStr, consts.GenerateStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.ProfilesGenerateCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("profiles", false, profilesGenerateCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("save", "s", "", "directory/file to the binary to")
|
||
f.BoolP("disable-sgn", "G", false, "disable shikata ga nai shellcode encoder")
|
||
})
|
||
FlagComps(profilesGenerateCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["save"] = carapace.ActionFiles().Tag("directory/file to save implant")
|
||
})
|
||
carapace.Gen(profilesGenerateCmd).PositionalCompletion(generate.ProfileNameCompleter(con))
|
||
profilesCmd.AddCommand(profilesGenerateCmd)
|
||
|
||
profilesNewCmd := &cobra.Command{
|
||
Use: consts.NewStr,
|
||
Short: "Create a new implant profile (interactive session)",
|
||
Long: help.GetHelpFor([]string{consts.ProfilesStr, consts.NewStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.ProfilesNewCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("session", false, profilesNewCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("os", "o", "windows", "operating system")
|
||
f.StringP("arch", "a", "amd64", "cpu architecture")
|
||
|
||
f.BoolP("debug", "d", false, "enable debug features")
|
||
f.StringP("debug-file", "O", "", "path to debug output")
|
||
f.BoolP("evasion", "e", false, "enable evasion features (e.g. overwrite user space hooks)")
|
||
f.BoolP("skip-symbols", "l", false, "skip symbol obfuscation")
|
||
f.BoolP("disable-sgn", "G", false, "disable shikata ga nai shellcode encoder")
|
||
|
||
f.StringP("canary", "c", "", "canary domain(s)")
|
||
|
||
f.StringP("name", "N", "", "agent name")
|
||
f.StringP("mtls", "m", "", "mtls connection strings")
|
||
f.StringP("wg", "g", "", "wg connection strings")
|
||
f.StringP("http", "b", "", "http(s) connection strings")
|
||
f.StringP("dns", "n", "", "dns connection strings")
|
||
f.StringP("named-pipe", "p", "", "named-pipe connection strings")
|
||
f.StringP("tcp-pivot", "i", "", "tcp-pivot connection strings")
|
||
|
||
f.Uint32P("key-exchange", "X", generate.DefaultWGKeyExPort, "wg key-exchange port")
|
||
f.Uint32P("tcp-comms", "T", generate.DefaultWGNPort, "wg c2 comms port")
|
||
|
||
f.BoolP("run-at-load", "R", false, "run the implant entrypoint from DllMain/Constructor (shared library only)")
|
||
f.StringP("strategy", "Z", "", "specify a connection strategy (r = random, rd = random domain, s = sequential)")
|
||
|
||
f.BoolP("netgo", "q", false, "force the use of netgo")
|
||
f.StringP("traffic-encoders", "A", "", "comma separated list of traffic encoders to enable")
|
||
|
||
f.StringP("template", "I", "sliver", "implant code template")
|
||
|
||
f.Int64P("reconnect", "j", generate.DefaultReconnect, "attempt to reconnect every n second(s)")
|
||
f.Int64P("poll-timeout", "P", generate.DefaultPollTimeout, "long poll request timeout")
|
||
f.Uint32P("max-errors", "k", generate.DefaultMaxErrors, "max number of connection errors")
|
||
|
||
f.StringP("limit-datetime", "w", "", "limit execution to before datetime")
|
||
f.BoolP("limit-domainjoined", "x", false, "limit execution to domain joined machines")
|
||
f.StringP("limit-username", "y", "", "limit execution to specified username")
|
||
f.StringP("limit-hostname", "z", "", "limit execution to specified hostname")
|
||
f.StringP("limit-fileexists", "F", "", "limit execution to hosts with this file in the filesystem")
|
||
f.StringP("limit-locale", "L", "", "limit execution to hosts that match this locale")
|
||
|
||
f.StringP("format", "f", "exe", "Specifies the output formats, valid values are: 'exe', 'shared' (for dynamic libraries), 'service' (see: `psexec` for more info) and 'shellcode' (windows only)")
|
||
})
|
||
FlagComps(profilesNewCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["debug-file"] = carapace.ActionFiles()
|
||
(*comp)["os"] = generate.OSCompleter(con)
|
||
(*comp)["arch"] = generate.ArchCompleter(con)
|
||
(*comp)["strategy"] = carapace.ActionValuesDescribed([]string{"r", "random", "rd", "random domain", "s", "sequential"}...).Tag("C2 strategy")
|
||
(*comp)["format"] = generate.FormatCompleter()
|
||
(*comp)["save"] = carapace.ActionFiles().Tag("directory/file to save implant")
|
||
})
|
||
carapace.Gen(profilesNewCmd).PositionalCompletion(carapace.ActionValues().Usage("name of the session profile (optional)"))
|
||
profilesCmd.AddCommand(profilesNewCmd)
|
||
|
||
// New Beacon Profile Command
|
||
profilesNewBeaconCmd := &cobra.Command{
|
||
Use: consts.BeaconStr,
|
||
Short: "Create a new implant profile (beacon)",
|
||
Long: help.GetHelpFor([]string{consts.ProfilesStr, consts.NewStr, consts.BeaconStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.ProfilesNewBeaconCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("beacon", false, profilesNewBeaconCmd, func(f *pflag.FlagSet) {
|
||
f.Int64P("days", "D", 0, "beacon interval days")
|
||
f.Int64P("hours", "H", 0, "beacon interval hours")
|
||
f.Int64P("minutes", "M", 0, "beacon interval minutes")
|
||
f.Int64P("seconds", "S", 60, "beacon interval seconds")
|
||
f.Int64P("jitter", "J", 30, "beacon interval jitter in seconds")
|
||
f.BoolP("disable-sgn", "G", false, "disable shikata ga nai shellcode encoder")
|
||
|
||
// Generate flags
|
||
f.StringP("os", "o", "windows", "operating system")
|
||
f.StringP("arch", "a", "amd64", "cpu architecture")
|
||
|
||
f.BoolP("debug", "d", false, "enable debug features")
|
||
f.StringP("debug-file", "O", "", "path to debug output")
|
||
f.BoolP("evasion", "e", false, "enable evasion features (e.g. overwrite user space hooks)")
|
||
f.BoolP("skip-symbols", "l", false, "skip symbol obfuscation")
|
||
|
||
f.StringP("canary", "c", "", "canary domain(s)")
|
||
|
||
f.StringP("name", "N", "", "agent name")
|
||
f.StringP("mtls", "m", "", "mtls connection strings")
|
||
f.StringP("wg", "g", "", "wg connection strings")
|
||
f.StringP("http", "b", "", "http(s) connection strings")
|
||
f.StringP("dns", "n", "", "dns connection strings")
|
||
f.StringP("named-pipe", "p", "", "named-pipe connection strings")
|
||
f.StringP("tcp-pivot", "i", "", "tcp-pivot connection strings")
|
||
f.StringP("strategy", "Z", "", "specify a connection strategy (r = random, rd = random domain, s = sequential)")
|
||
|
||
f.Uint32P("key-exchange", "X", generate.DefaultWGKeyExPort, "wg key-exchange port")
|
||
f.Uint32P("tcp-comms", "T", generate.DefaultWGNPort, "wg c2 comms port")
|
||
|
||
f.BoolP("run-at-load", "R", false, "run the implant entrypoint from DllMain/Constructor (shared library only)")
|
||
f.BoolP("netgo", "q", false, "force the use of netgo")
|
||
f.StringP("traffic-encoders", "A", "", "comma separated list of traffic encoders to enable")
|
||
|
||
f.StringP("template", "I", "sliver", "implant code template")
|
||
|
||
f.Int64P("reconnect", "j", generate.DefaultReconnect, "attempt to reconnect every n second(s)")
|
||
f.Int64P("poll-timeout", "P", generate.DefaultPollTimeout, "long poll request timeout")
|
||
f.Uint32P("max-errors", "k", generate.DefaultMaxErrors, "max number of connection errors")
|
||
|
||
f.StringP("limit-datetime", "w", "", "limit execution to before datetime")
|
||
f.BoolP("limit-domainjoined", "x", false, "limit execution to domain joined machines")
|
||
f.StringP("limit-username", "y", "", "limit execution to specified username")
|
||
f.StringP("limit-hostname", "z", "", "limit execution to specified hostname")
|
||
f.StringP("limit-fileexists", "F", "", "limit execution to hosts with this file in the filesystem")
|
||
f.StringP("limit-locale", "L", "", "limit execution to hosts that match this locale")
|
||
|
||
f.StringP("format", "f", "exe", "Specifies the output formats, valid values are: 'exe', 'shared' (for dynamic libraries), 'service' (see: `psexec` for more info) and 'shellcode' (windows only)")
|
||
})
|
||
FlagComps(profilesNewBeaconCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["debug-file"] = carapace.ActionFiles()
|
||
(*comp)["os"] = generate.OSCompleter(con)
|
||
(*comp)["arch"] = generate.ArchCompleter(con)
|
||
(*comp)["strategy"] = carapace.ActionValuesDescribed([]string{"r", "random", "rd", "random domain", "s", "sequential"}...).Tag("C2 strategy")
|
||
(*comp)["format"] = generate.FormatCompleter()
|
||
(*comp)["save"] = carapace.ActionFiles().Tag("directory/file to save implant")
|
||
})
|
||
carapace.Gen(profilesNewBeaconCmd).PositionalCompletion(carapace.ActionValues().Usage("name of the beacon profile (optional)"))
|
||
profilesNewCmd.AddCommand(profilesNewBeaconCmd)
|
||
|
||
profilesRmCmd := &cobra.Command{
|
||
Use: consts.RmStr,
|
||
Short: "Remove a profile",
|
||
Long: help.GetHelpFor([]string{consts.ProfilesStr, consts.RmStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.ProfilesRmCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(profilesRmCmd).PositionalCompletion(generate.ProfileNameCompleter(con))
|
||
profilesCmd.AddCommand(profilesRmCmd)
|
||
|
||
profilesInfoCmd := &cobra.Command{
|
||
Use: consts.InfoStr,
|
||
Short: "Details about a profile",
|
||
Long: help.GetHelpFor([]string{consts.ProfilesStr, consts.RmStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.PrintProfileInfo(args[0], con)
|
||
},
|
||
}
|
||
carapace.Gen(profilesInfoCmd).PositionalCompletion(generate.ProfileNameCompleter(con))
|
||
profilesCmd.AddCommand(profilesInfoCmd)
|
||
|
||
implantBuildsCmd := &cobra.Command{
|
||
Use: consts.ImplantBuildsStr,
|
||
Short: "List implant builds",
|
||
Long: help.GetHelpFor([]string{consts.ImplantBuildsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.ImplantsCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.PayloadsHelpGroup,
|
||
}
|
||
Flags("implants", true, implantBuildsCmd, func(f *pflag.FlagSet) {
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
Flags("implants", false, implantBuildsCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("os", "o", "", "filter builds by operating system")
|
||
f.StringP("arch", "a", "", "filter builds by cpu architecture")
|
||
f.StringP("format", "f", "", "filter builds by artifact format")
|
||
f.BoolP("only-sessions", "s", false, "filter interactive sessions")
|
||
f.BoolP("only-beacons", "b", false, "filter beacons")
|
||
f.BoolP("no-debug", "d", false, "filter builds by debug flag")
|
||
})
|
||
FlagComps(profilesNewBeaconCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["os"] = generate.OSCompleter(con)
|
||
(*comp)["arch"] = generate.ArchCompleter(con)
|
||
(*comp)["format"] = generate.FormatCompleter()
|
||
})
|
||
server.AddCommand(implantBuildsCmd)
|
||
|
||
implantsRmCmd := &cobra.Command{
|
||
Use: consts.RmStr,
|
||
Short: "Remove implant build",
|
||
Long: help.GetHelpFor([]string{consts.ImplantBuildsStr, consts.RmStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.ImplantsRmCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(implantsRmCmd).PositionalCompletion(generate.ImplantBuildNameCompleter(con))
|
||
implantBuildsCmd.AddCommand(implantsRmCmd)
|
||
|
||
canariesCmd := &cobra.Command{
|
||
Use: consts.CanariesStr,
|
||
Short: "List previously generated canaries",
|
||
Long: help.GetHelpFor([]string{consts.CanariesStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
generate.CanariesCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.PayloadsHelpGroup,
|
||
}
|
||
Flags("canaries", false, canariesCmd, func(f *pflag.FlagSet) {
|
||
f.BoolP("burned", "b", false, "show only triggered/burned canaries")
|
||
f.Int64P("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
|
||
// [ Websites ] ---------------------------------------------
|
||
|
||
websitesCmd := &cobra.Command{
|
||
Use: consts.WebsitesStr,
|
||
Short: "Host static content (used with HTTP C2)",
|
||
Long: help.GetHelpFor([]string{consts.WebsitesStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
websites.WebsitesCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.NetworkHelpGroup,
|
||
}
|
||
server.AddCommand(websitesCmd)
|
||
Flags("websites", true, websitesCmd, func(f *pflag.FlagSet) {
|
||
f.Int64P("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
carapace.Gen(websitesCmd).PositionalCompletion(websites.WebsiteNameCompleter(con))
|
||
|
||
websitesRmCmd := &cobra.Command{
|
||
Use: consts.RmStr,
|
||
Short: "Remove an entire website and all of its contents",
|
||
Long: help.GetHelpFor([]string{consts.WebsitesStr, consts.RmStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
websites.WebsiteRmCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(websitesRmCmd).PositionalCompletion(websites.WebsiteNameCompleter(con))
|
||
websitesCmd.AddCommand(websitesRmCmd)
|
||
|
||
websitesRmWebContentCmd := &cobra.Command{
|
||
Use: consts.RmWebContentStr,
|
||
Short: "Remove specific content from a website",
|
||
Long: help.GetHelpFor([]string{consts.WebsitesStr, consts.RmWebContentStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
websites.WebsitesRmContent(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("websites", false, websitesRmWebContentCmd, func(f *pflag.FlagSet) {
|
||
f.BoolP("recursive", "r", false, "recursively add/rm content")
|
||
f.StringP("website", "w", "", "website name")
|
||
f.StringP("web-path", "p", "", "http path to host file at")
|
||
})
|
||
websitesCmd.AddCommand(websitesRmWebContentCmd)
|
||
FlagComps(websitesRmWebContentCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["website"] = websites.WebsiteNameCompleter(con)
|
||
})
|
||
|
||
websitesContentCmd := &cobra.Command{
|
||
Use: consts.AddWebContentStr,
|
||
Short: "Add content to a website",
|
||
Long: help.GetHelpFor([]string{consts.WebsitesStr, consts.RmWebContentStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
websites.WebsitesAddContentCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("websites", false, websitesContentCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("website", "w", "", "website name")
|
||
f.StringP("content-type", "m", "", "mime content-type (if blank use file ext.)")
|
||
f.StringP("web-path", "p", "/", "http path to host file at")
|
||
f.StringP("content", "c", "", "local file path/dir (must use --recursive for dir)")
|
||
f.BoolP("recursive", "r", false, "recursively add/rm content")
|
||
})
|
||
FlagComps(websitesContentCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["content"] = carapace.ActionFiles().Tag("content directory/files")
|
||
(*comp)["website"] = websites.WebsiteNameCompleter(con)
|
||
})
|
||
websitesCmd.AddCommand(websitesContentCmd)
|
||
|
||
websitesContentTypeCmd := &cobra.Command{
|
||
Use: consts.WebContentTypeStr,
|
||
Short: "Update a path's content-type",
|
||
Long: help.GetHelpFor([]string{consts.WebsitesStr, consts.WebContentTypeStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
websites.WebsitesUpdateContentCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("websites", false, websitesContentTypeCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("website", "w", "", "website name")
|
||
f.StringP("content-type", "m", "", "mime content-type (if blank use file ext.)")
|
||
f.StringP("web-path", "p", "/", "http path to host file at")
|
||
})
|
||
websitesCmd.AddCommand(websitesContentTypeCmd)
|
||
FlagComps(websitesContentTypeCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["website"] = websites.WebsiteNameCompleter(con)
|
||
})
|
||
|
||
// [ Beacons ] ---------------------------------------------
|
||
|
||
beaconsCmd := &cobra.Command{
|
||
Use: consts.BeaconsStr,
|
||
Short: "Manage beacons",
|
||
Long: help.GetHelpFor([]string{consts.BeaconsStr}),
|
||
GroupID: consts.SliverHelpGroup,
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
beacons.BeaconsCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("beacons", true, beaconsCmd, func(f *pflag.FlagSet) {
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
Flags("beacons", false, beaconsCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("kill", "k", "", "kill the designated beacon")
|
||
f.BoolP("kill-all", "K", false, "kill all beacons")
|
||
f.BoolP("force", "F", false, "force killing the beacon")
|
||
|
||
f.StringP("filter", "f", "", "filter beacons by substring")
|
||
f.StringP("filter-re", "e", "", "filter beacons by regular expression")
|
||
})
|
||
FlagComps(beaconsCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["kill"] = use.BeaconIDCompleter(con)
|
||
})
|
||
beaconsRmCmd := &cobra.Command{
|
||
Use: consts.RmStr,
|
||
Short: "Remove a beacon",
|
||
Long: help.GetHelpFor([]string{consts.BeaconsStr, consts.RmStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
beacons.BeaconsRmCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(beaconsRmCmd).PositionalCompletion(use.BeaconIDCompleter(con))
|
||
beaconsCmd.AddCommand(beaconsRmCmd)
|
||
|
||
beaconsWatchCmd := &cobra.Command{
|
||
Use: consts.WatchStr,
|
||
Short: "Watch your beacons",
|
||
Long: help.GetHelpFor([]string{consts.BeaconsStr, consts.WatchStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
beacons.BeaconsWatchCmd(cmd, con, args)
|
||
},
|
||
}
|
||
beaconsCmd.AddCommand(beaconsWatchCmd)
|
||
|
||
beaconsPruneCmd := &cobra.Command{
|
||
Use: consts.PruneStr,
|
||
Short: "Prune stale beacons automatically",
|
||
Long: help.GetHelpFor([]string{consts.BeaconsStr, consts.PruneStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
beacons.BeaconsPruneCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("beacons", false, beaconsPruneCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("duration", "d", "1h", "duration to prune beacons that have missed their last checkin")
|
||
})
|
||
beaconsCmd.AddCommand(beaconsPruneCmd)
|
||
server.AddCommand(beaconsCmd)
|
||
|
||
// [ Licenses ] ---------------------------------------------
|
||
|
||
server.AddCommand(&cobra.Command{
|
||
Use: consts.LicensesStr,
|
||
Short: "Open source licenses",
|
||
Long: help.GetHelpFor([]string{consts.LicensesStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
con.Println(licenses.All)
|
||
},
|
||
GroupID: consts.GenericHelpGroup,
|
||
})
|
||
|
||
// [ WireGuard ] --------------------------------------------------------------
|
||
|
||
wgConfigCmd := &cobra.Command{
|
||
Use: consts.WgConfigStr,
|
||
Short: "Generate a new WireGuard client config",
|
||
Long: help.GetHelpFor([]string{consts.WgConfigStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
wireguard.WGConfigCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.NetworkHelpGroup,
|
||
}
|
||
server.AddCommand(wgConfigCmd)
|
||
|
||
Flags("wg-config", true, wgConfigCmd, func(f *pflag.FlagSet) {
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
Flags("wg-config", false, wgConfigCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("save", "s", "", "save configuration to file (.conf)")
|
||
})
|
||
FlagComps(wgConfigCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["save"] = carapace.ActionFiles().Tag("directory/file to save config")
|
||
})
|
||
|
||
// [ Monitor ] --------------------------------------------------------------
|
||
|
||
monitorCmd := &cobra.Command{
|
||
Use: consts.MonitorStr,
|
||
Short: "Monitor threat intel platforms for Sliver implants",
|
||
GroupID: consts.SliverHelpGroup,
|
||
}
|
||
monitorCmd.AddCommand(&cobra.Command{
|
||
Use: "start",
|
||
Short: "Start the monitoring loops",
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
monitor.MonitorStartCmd(cmd, con, args)
|
||
},
|
||
})
|
||
monitorCmd.AddCommand(&cobra.Command{
|
||
Use: "stop",
|
||
Short: "Stop the monitoring loops",
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
monitor.MonitorStopCmd(cmd, con, args)
|
||
},
|
||
})
|
||
server.AddCommand(monitorCmd)
|
||
|
||
// [ Loot ] --------------------------------------------------------------
|
||
|
||
lootCmd := &cobra.Command{
|
||
Use: consts.LootStr,
|
||
Short: "Manage the server's loot store",
|
||
Long: help.GetHelpFor([]string{consts.LootStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
loot.LootCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.SliverHelpGroup,
|
||
}
|
||
Flags("loot", true, lootCmd, func(f *pflag.FlagSet) {
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
Flags("loot", false, lootCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("filter", "f", "", "filter based on loot type")
|
||
})
|
||
|
||
lootAddCmd := &cobra.Command{
|
||
Use: consts.LootLocalStr,
|
||
Short: "Add a local file to the server's loot store",
|
||
Long: help.GetHelpFor([]string{consts.LootStr, consts.LootLocalStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
loot.LootAddLocalCmd(cmd, con, args)
|
||
},
|
||
Args: cobra.ExactArgs(1),
|
||
}
|
||
lootCmd.AddCommand(lootAddCmd)
|
||
Flags("loot", false, lootAddCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("name", "n", "", "name of this piece of loot")
|
||
f.StringP("type", "T", "", "force a specific loot type (file/cred)")
|
||
f.StringP("file-type", "F", "", "force a specific file type (binary/text)")
|
||
})
|
||
FlagComps(lootAddCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["type"] = carapace.ActionValues("file", "cred").Tag("loot type")
|
||
(*comp)["file-type"] = carapace.ActionValues("binary", "text").Tag("loot file type")
|
||
})
|
||
carapace.Gen(lootAddCmd).PositionalCompletion(
|
||
carapace.ActionFiles().Tag("local loot file").Usage("The local file path to the loot"))
|
||
|
||
lootRemoteCmd := &cobra.Command{
|
||
Use: consts.LootRemoteStr,
|
||
Short: "Add a remote file from the current session to the server's loot store",
|
||
Long: help.GetHelpFor([]string{consts.LootStr, consts.LootRemoteStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
loot.LootAddRemoteCmd(cmd, con, args)
|
||
},
|
||
Args: cobra.ExactArgs(1),
|
||
}
|
||
lootCmd.AddCommand(lootRemoteCmd)
|
||
Flags("loot", false, lootRemoteCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("name", "n", "", "name of this piece of loot")
|
||
f.StringP("type", "T", "", "force a specific loot type (file/cred)")
|
||
f.StringP("file-type", "F", "", "force a specific file type (binary/text)")
|
||
})
|
||
FlagComps(lootRemoteCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["type"] = carapace.ActionValues("file", "cred").Tag("loot type")
|
||
(*comp)["file-type"] = carapace.ActionValues("binary", "text").Tag("loot file type")
|
||
})
|
||
carapace.Gen(lootRemoteCmd).PositionalCompletion(carapace.ActionValues().Usage("The file path on the remote host to the loot"))
|
||
|
||
lootRenameCmd := &cobra.Command{
|
||
Use: consts.RenameStr,
|
||
Short: "Re-name a piece of existing loot",
|
||
Long: help.GetHelpFor([]string{consts.LootStr, consts.RenameStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
loot.LootRenameCmd(cmd, con, args)
|
||
},
|
||
}
|
||
lootCmd.AddCommand(lootRenameCmd)
|
||
|
||
lootFetchCmd := &cobra.Command{
|
||
Use: consts.FetchStr,
|
||
Short: "Fetch a piece of loot from the server's loot store",
|
||
Long: help.GetHelpFor([]string{consts.LootStr, consts.FetchStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
loot.LootFetchCmd(cmd, con, args)
|
||
},
|
||
}
|
||
lootCmd.AddCommand(lootFetchCmd)
|
||
Flags("loot", false, lootFetchCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("save", "s", "", "save loot to a local file")
|
||
f.StringP("filter", "f", "", "filter based on loot type")
|
||
})
|
||
FlagComps(lootFetchCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["save"] = carapace.ActionFiles().Tag("directory/file to save loot")
|
||
})
|
||
|
||
lootRmCmd := &cobra.Command{
|
||
Use: consts.RmStr,
|
||
Short: "Remove a piece of loot from the server's loot store",
|
||
Long: help.GetHelpFor([]string{consts.LootStr, consts.RmStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
loot.LootRmCmd(cmd, con, args)
|
||
},
|
||
}
|
||
lootCmd.AddCommand(lootRmCmd)
|
||
Flags("loot", false, lootRmCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("filter", "f", "", "filter based on loot type")
|
||
})
|
||
|
||
server.AddCommand(lootCmd)
|
||
|
||
// [ Credentials ] ------------------------------------------------------------
|
||
credsCmd := &cobra.Command{
|
||
Use: consts.CredsStr,
|
||
Short: "Manage the database of credentials",
|
||
Long: help.GetHelpFor([]string{consts.CredsStr}),
|
||
GroupID: consts.GenericHelpGroup,
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
creds.CredsCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("creds", true, credsCmd, func(f *pflag.FlagSet) {
|
||
f.IntP("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
server.AddCommand(credsCmd)
|
||
|
||
credsAddCmd := &cobra.Command{
|
||
Use: consts.AddStr,
|
||
Short: "Add a credential to the database",
|
||
Long: help.GetHelpFor([]string{consts.CredsStr, consts.AddStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
creds.CredsAddCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("", false, credsAddCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("collection", "c", "", "name of collection")
|
||
f.StringP("username", "u", "", "username for the credential")
|
||
f.StringP("plaintext", "p", "", "plaintext for the credential")
|
||
f.StringP("hash", "P", "", "hash of the credential")
|
||
f.StringP("hash-type", "H", "", "hash type of the credential")
|
||
})
|
||
FlagComps(credsAddCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["hash-type"] = creds.CredsHashTypeCompleter(con)
|
||
})
|
||
credsCmd.AddCommand(credsAddCmd)
|
||
|
||
credsAddFileCmd := &cobra.Command{
|
||
Use: consts.FileStr,
|
||
Short: "Add a credential to the database",
|
||
Long: help.GetHelpFor([]string{consts.CredsStr, consts.AddStr, consts.FileStr}),
|
||
Args: cobra.ExactArgs(1),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
creds.CredsAddHashFileCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("", false, credsAddFileCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("collection", "c", "", "name of collection")
|
||
f.StringP("file-format", "F", creds.HashNewlineFormat, "file format of the credential file")
|
||
f.StringP("hash-type", "H", "", "hash type of the credential")
|
||
})
|
||
FlagComps(credsAddFileCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["collection"] = creds.CredsCollectionCompleter(con)
|
||
(*comp)["file-format"] = creds.CredsHashFileFormatCompleter(con)
|
||
(*comp)["hash-type"] = creds.CredsHashTypeCompleter(con)
|
||
})
|
||
carapace.Gen(credsAddFileCmd).PositionalCompletion(carapace.ActionFiles().Tag("credential file"))
|
||
credsAddCmd.AddCommand(credsAddFileCmd)
|
||
|
||
credsRmCmd := &cobra.Command{
|
||
Use: consts.RmStr,
|
||
Short: "Remove a credential to the database",
|
||
Long: help.GetHelpFor([]string{consts.CredsStr, consts.RmStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
creds.CredsRmCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(credsRmCmd).PositionalCompletion(creds.CredsCredentialIDCompleter(con).Usage("id of credential to remove (leave empty to select)"))
|
||
credsCmd.AddCommand(credsRmCmd)
|
||
|
||
// [ Hosts ] ---------------------------------------------------------------------
|
||
|
||
hostsCmd := &cobra.Command{
|
||
Use: consts.HostsStr,
|
||
Short: "Manage the database of hosts",
|
||
Long: help.GetHelpFor([]string{consts.HostsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
hosts.HostsCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.SliverHelpGroup,
|
||
}
|
||
server.AddCommand(hostsCmd)
|
||
Flags("hosts", true, hostsCmd, func(f *pflag.FlagSet) {
|
||
f.Int64P("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
|
||
hostsRmCmd := &cobra.Command{
|
||
Use: consts.RmStr,
|
||
Short: "Remove a host from the database",
|
||
Long: help.GetHelpFor([]string{consts.HostsStr, consts.RmStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
hosts.HostsRmCmd(cmd, con, args)
|
||
},
|
||
}
|
||
hostsCmd.AddCommand(hostsRmCmd)
|
||
|
||
hostsIOCCmd := &cobra.Command{
|
||
Use: consts.IOCStr,
|
||
Short: "Manage tracked IOCs on a given host",
|
||
Long: help.GetHelpFor([]string{consts.HostsStr, consts.IOCStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
hosts.HostsIOCCmd(cmd, con, args)
|
||
},
|
||
}
|
||
hostsCmd.AddCommand(hostsIOCCmd)
|
||
|
||
hostsIOCRmCmd := &cobra.Command{
|
||
Use: consts.RmStr,
|
||
Short: "Delete IOCs from the database",
|
||
Long: help.GetHelpFor([]string{consts.HostsStr, consts.IOCStr, consts.RmStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
hosts.HostsIOCRmCmd(cmd, con, args)
|
||
},
|
||
}
|
||
hostsIOCCmd.AddCommand(hostsIOCRmCmd)
|
||
|
||
// [ Reactions ] -----------------------------------------------------------------
|
||
|
||
reactionCmd := &cobra.Command{
|
||
Use: consts.ReactionStr,
|
||
Short: "Manage automatic reactions to events",
|
||
Long: help.GetHelpFor([]string{consts.ReactionStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
reaction.ReactionCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.SliverHelpGroup,
|
||
}
|
||
server.AddCommand(reactionCmd)
|
||
|
||
reactionSetCmd := &cobra.Command{
|
||
Use: consts.SetStr,
|
||
Short: "Set a reaction to an event",
|
||
Long: help.GetHelpFor([]string{consts.ReactionStr, consts.SetStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
reaction.ReactionSetCmd(cmd, con, args)
|
||
},
|
||
}
|
||
reactionCmd.AddCommand(reactionSetCmd)
|
||
Flags("reactions", false, reactionSetCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("event", "e", "", "specify the event type to react to")
|
||
})
|
||
|
||
FlagComps(reactionSetCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["event"] = carapace.ActionValues(
|
||
consts.SessionOpenedEvent,
|
||
consts.SessionClosedEvent,
|
||
consts.SessionUpdateEvent,
|
||
consts.BeaconRegisteredEvent,
|
||
consts.CanaryEvent,
|
||
consts.WatchtowerEvent,
|
||
)
|
||
})
|
||
|
||
reactionUnsetCmd := &cobra.Command{
|
||
Use: consts.UnsetStr,
|
||
Short: "Unset an existing reaction",
|
||
Long: help.GetHelpFor([]string{consts.ReactionStr, consts.UnsetStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
reaction.ReactionUnsetCmd(cmd, con, args)
|
||
},
|
||
}
|
||
reactionCmd.AddCommand(reactionUnsetCmd)
|
||
Flags("reactions", false, reactionUnsetCmd, func(f *pflag.FlagSet) {
|
||
f.IntP("id", "i", 0, "the id of the reaction to remove")
|
||
})
|
||
FlagComps(reactionUnsetCmd, func(comp *carapace.ActionMap) {
|
||
(*comp)["id"] = reaction.ReactionIDCompleter(con)
|
||
})
|
||
|
||
reactionSaveCmd := &cobra.Command{
|
||
Use: consts.SaveStr,
|
||
Short: "Save current reactions to disk",
|
||
Long: help.GetHelpFor([]string{consts.ReactionStr, consts.SaveStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
reaction.ReactionSaveCmd(cmd, con, args)
|
||
},
|
||
}
|
||
reactionCmd.AddCommand(reactionSaveCmd)
|
||
|
||
reactionReloadCmd := &cobra.Command{
|
||
Use: consts.ReloadStr,
|
||
Short: "Reload reactions from disk, replaces the running configuration",
|
||
Long: help.GetHelpFor([]string{consts.ReactionStr, consts.ReloadStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
reaction.ReactionReloadCmd(cmd, con, args)
|
||
},
|
||
}
|
||
reactionCmd.AddCommand(reactionReloadCmd)
|
||
|
||
// [ Prelude's Operator ] ------------------------------------------------------------
|
||
operatorCmd := &cobra.Command{
|
||
Use: consts.PreludeOperatorStr,
|
||
Short: "Manage connection to Prelude's Operator",
|
||
Long: help.GetHelpFor([]string{consts.PreludeOperatorStr}),
|
||
GroupID: consts.GenericHelpGroup,
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
operator.OperatorCmd(cmd, con, args)
|
||
},
|
||
}
|
||
server.AddCommand(operatorCmd)
|
||
|
||
operatorConnectCmd := &cobra.Command{
|
||
Use: consts.ConnectStr,
|
||
Short: "Connect with Prelude's Operator",
|
||
Long: help.GetHelpFor([]string{consts.PreludeOperatorStr, consts.ConnectStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
operator.ConnectCmd(cmd, con, args)
|
||
},
|
||
Args: cobra.ExactArgs(1),
|
||
}
|
||
operatorCmd.AddCommand(operatorConnectCmd)
|
||
Flags("operator", false, operatorConnectCmd, func(f *pflag.FlagSet) {
|
||
f.BoolP("skip-existing", "s", false, "Do not add existing sessions as Operator Agents")
|
||
f.StringP("aes-key", "a", "abcdefghijklmnopqrstuvwxyz012345", "AES key for communication encryption")
|
||
f.StringP("range", "r", "sliver", "Agents range")
|
||
})
|
||
carapace.Gen(operatorConnectCmd).PositionalCompletion(
|
||
carapace.ActionValues().Usage("connection string to the Operator Host (e.g. 127.0.0.1:1234)"))
|
||
|
||
// [ Builders ] ---------------------------------------------
|
||
|
||
buildersCmd := &cobra.Command{
|
||
Use: consts.BuildersStr,
|
||
Short: "List external builders",
|
||
Long: help.GetHelpFor([]string{consts.BuildersStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
builders.BuildersCmd(cmd, con, args)
|
||
},
|
||
GroupID: consts.PayloadsHelpGroup,
|
||
}
|
||
server.AddCommand(buildersCmd)
|
||
Flags("builders", false, buildersCmd, func(f *pflag.FlagSet) {
|
||
f.Int64P("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
|
||
// [ Crack ] ------------------------------------------------------------
|
||
crackCmd := &cobra.Command{
|
||
Use: consts.CrackStr,
|
||
Short: "Crack: GPU password cracking",
|
||
Long: help.GetHelpFor([]string{consts.CrackStr}),
|
||
GroupID: consts.GenericHelpGroup,
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
crack.CrackCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("", true, crackCmd, func(f *pflag.FlagSet) {
|
||
f.Int64P("timeout", "t", defaultTimeout, "grpc timeout in seconds")
|
||
})
|
||
server.AddCommand(crackCmd)
|
||
|
||
crackStationsCmd := &cobra.Command{
|
||
Use: consts.StationsStr,
|
||
Short: "Manage crackstations",
|
||
Long: help.GetHelpFor([]string{consts.CrackStr, consts.StationsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
crack.CrackStationsCmd(cmd, con, args)
|
||
},
|
||
}
|
||
crackCmd.AddCommand(crackStationsCmd)
|
||
|
||
wordlistsCmd := &cobra.Command{
|
||
Use: consts.WordlistsStr,
|
||
Short: "Manage wordlists",
|
||
Long: help.GetHelpFor([]string{consts.CrackStr, consts.WordlistsStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
crack.CrackWordlistsCmd(cmd, con, args)
|
||
},
|
||
}
|
||
crackCmd.AddCommand(wordlistsCmd)
|
||
|
||
wordlistsAddCmd := &cobra.Command{
|
||
Use: consts.AddStr,
|
||
Short: "Add a wordlist",
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
crack.CrackWordlistsAddCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("", false, wordlistsAddCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("name", "n", "", "wordlist name (blank = filename)")
|
||
})
|
||
carapace.Gen(wordlistsAddCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to local wordlist file"))
|
||
wordlistsCmd.AddCommand(wordlistsAddCmd)
|
||
|
||
wordlistsRmCmd := &cobra.Command{
|
||
Use: consts.RmStr,
|
||
Short: "Remove a wordlist",
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
crack.CrackWordlistsRmCmd(cmd, con, args)
|
||
},
|
||
}
|
||
wordlistsCmd.AddCommand(wordlistsRmCmd)
|
||
carapace.Gen(wordlistsRmCmd).PositionalCompletion(crack.CrackWordlistCompleter(con).Usage("wordlist to remove"))
|
||
|
||
rulesCmd := &cobra.Command{
|
||
Use: consts.RulesStr,
|
||
Short: "Manage rule files",
|
||
Long: help.GetHelpFor([]string{consts.CrackStr, consts.RulesStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
crack.CrackRulesCmd(cmd, con, args)
|
||
},
|
||
}
|
||
crackCmd.AddCommand(rulesCmd)
|
||
|
||
rulesAddCmd := &cobra.Command{
|
||
Use: consts.AddStr,
|
||
Short: "Add a rules file",
|
||
Long: help.GetHelpFor([]string{consts.CrackStr, consts.RulesStr, consts.AddStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
crack.CrackRulesAddCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("", false, rulesAddCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("name", "n", "", "rules name (blank = filename)")
|
||
})
|
||
carapace.Gen(rulesAddCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to local rules file"))
|
||
rulesCmd.AddCommand(rulesAddCmd)
|
||
|
||
rulesRmCmd := &cobra.Command{
|
||
Use: consts.RmStr,
|
||
Short: "Remove rules",
|
||
Long: help.GetHelpFor([]string{consts.CrackStr, consts.RulesStr, consts.RmStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
crack.CrackRulesRmCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(rulesRmCmd).PositionalCompletion(crack.CrackRulesCompleter(con).Usage("rules to remove"))
|
||
rulesCmd.AddCommand(rulesRmCmd)
|
||
|
||
hcstat2Cmd := &cobra.Command{
|
||
Use: consts.Hcstat2Str,
|
||
Short: "Manage markov hcstat2 files",
|
||
Long: help.GetHelpFor([]string{consts.CrackStr, consts.Hcstat2Str}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
crack.CrackHcstat2Cmd(cmd, con, args)
|
||
},
|
||
}
|
||
crackCmd.AddCommand(hcstat2Cmd)
|
||
|
||
hcstat2AddCmd := &cobra.Command{
|
||
Use: consts.AddStr,
|
||
Short: "Add a hcstat2 file",
|
||
Long: help.GetHelpFor([]string{consts.CrackStr, consts.Hcstat2Str, consts.AddStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
crack.CrackHcstat2AddCmd(cmd, con, args)
|
||
},
|
||
}
|
||
Flags("", false, hcstat2AddCmd, func(f *pflag.FlagSet) {
|
||
f.StringP("name", "n", "", "hcstat2 name (blank = filename)")
|
||
})
|
||
carapace.Gen(hcstat2AddCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to local hcstat2 file"))
|
||
hcstat2Cmd.AddCommand(hcstat2AddCmd)
|
||
|
||
hcstat2RmCmd := &cobra.Command{
|
||
Use: consts.RmStr,
|
||
Short: "Remove hcstat2 file",
|
||
Long: help.GetHelpFor([]string{consts.CrackStr, consts.Hcstat2Str, consts.RmStr}),
|
||
Run: func(cmd *cobra.Command, args []string) {
|
||
crack.CrackHcstat2RmCmd(cmd, con, args)
|
||
},
|
||
}
|
||
carapace.Gen(hcstat2RmCmd).PositionalCompletion(crack.CrackHcstat2Completer(con).Usage("hcstat2 to remove"))
|
||
hcstat2Cmd.AddCommand(hcstat2RmCmd)
|
||
|
||
// [ Post-command declaration setup]-----------------------------------------
|
||
|
||
// Everything below this line should preferably not be any command binding
|
||
// (unless you know what you're doing). If there are any final modifications
|
||
// to make to the sliver menu command tree, it time to do them here.
|
||
|
||
server.InitDefaultHelpCmd()
|
||
server.SetHelpCommandGroupID(consts.GenericHelpGroup)
|
||
|
||
// Bind a readline subcommand to the `settings` one, for allowing users to
|
||
// manipulate the shell instance keymaps, bindings, macros and global options.
|
||
settingsCmd.AddCommand(readline.Commands(con.App.Shell()))
|
||
|
||
return server
|
||
}
|
||
|
||
return serverCommands
|
||
}
|