mirror of
https://github.com/MrAle98/sliver
synced 2026-06-08 11:54:46 +00:00
moloch
388 lines
9.2 KiB
Go
388 lines
9.2 KiB
Go
package command
|
|
|
|
import (
|
|
"fmt"
|
|
consts "sliver/client/constants"
|
|
"sliver/client/help"
|
|
|
|
"github.com/desertbit/grumble"
|
|
)
|
|
|
|
// Init - Bind commands to a App
|
|
func Init(app *grumble.App, rpc RPCServer) {
|
|
|
|
// [ Jobs ] -----------------------------------------------------------------
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.JobsStr,
|
|
Help: "Job control",
|
|
LongHelp: help.GetHelpFor(consts.JobsStr),
|
|
Flags: func(f *grumble.Flags) {
|
|
f.Int("k", "kill", -1, "kill a background job")
|
|
},
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
jobs(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.MtlsStr,
|
|
Help: "Start an mTLS listener",
|
|
LongHelp: help.GetHelpFor(consts.MtlsStr),
|
|
Flags: func(f *grumble.Flags) {
|
|
f.String("s", "server", "", "interface to bind server to")
|
|
f.Int("l", "lport", 8888, "tcp listen port")
|
|
},
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
startMTLSListener(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.DnsStr,
|
|
Help: "Start a DNS listener",
|
|
LongHelp: help.GetHelpFor(consts.DnsStr),
|
|
Flags: func(f *grumble.Flags) {
|
|
f.String("d", "domain", "", "parent domain to use for DNS C2")
|
|
},
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
startDNSListener(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
// [ Commands ] --------------------------------------------------------------
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.SessionsStr,
|
|
Help: "Session management",
|
|
LongHelp: help.GetHelpFor(consts.SessionsStr),
|
|
Flags: func(f *grumble.Flags) {
|
|
f.String("i", "interact", "", "interact with a sliver")
|
|
},
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
sessions(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.BackgroundStr,
|
|
Help: "Background an active session",
|
|
LongHelp: help.GetHelpFor(consts.BackgroundStr),
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
background(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.KillStr,
|
|
Help: "Kill a remote sliver process",
|
|
LongHelp: help.GetHelpFor(consts.KillStr),
|
|
AllowArgs: true,
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
kill(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.InfoStr,
|
|
Help: "Get info about sliver",
|
|
LongHelp: help.GetHelpFor(consts.InfoStr),
|
|
AllowArgs: true,
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
info(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.UseStr,
|
|
Help: "Switch the active sliver",
|
|
LongHelp: help.GetHelpFor(consts.UseStr),
|
|
AllowArgs: true,
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
use(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.GenerateStr,
|
|
Help: "Generate a sliver binary",
|
|
LongHelp: help.GetHelpFor(consts.GenerateStr),
|
|
Flags: func(f *grumble.Flags) {
|
|
f.String("o", "os", "windows", "operating system")
|
|
f.String("a", "arch", "amd64", "cpu architecture")
|
|
f.String("h", "lhost", "", "listen host")
|
|
f.Int("l", "lport", 8888, "listen port")
|
|
f.Bool("d", "debug", false, "enable debug features")
|
|
f.String("n", "dns", "", "dns c2 parent domain")
|
|
f.String("s", "save", "", "directory/file to the binary to")
|
|
},
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
generate(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.MsfStr,
|
|
Help: "Execute an MSF payload in the current process",
|
|
LongHelp: help.GetHelpFor(consts.MsfStr),
|
|
Flags: func(f *grumble.Flags) {
|
|
f.String("m", "payload", "meterpreter_reverse_https", "msf payload")
|
|
f.String("h", "lhost", "", "listen host")
|
|
f.Int("l", "lport", 4444, "listen port")
|
|
f.String("e", "encoder", "", "msf encoder")
|
|
f.Int("i", "iterations", 1, "iterations of the encoder")
|
|
},
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
msf(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.InjectStr,
|
|
Help: "Inject an MSF payload into a process",
|
|
LongHelp: help.GetHelpFor(consts.InjectStr),
|
|
Flags: func(f *grumble.Flags) {
|
|
f.Int("p", "pid", -1, "pid to inject into")
|
|
f.String("m", "payload", "meterpreter_reverse_https", "msf payload")
|
|
f.String("h", "lhost", "", "listen host")
|
|
f.Int("l", "lport", 4444, "listen port")
|
|
f.String("e", "encoder", "", "msf encoder")
|
|
f.Int("i", "iterations", 1, "iterations of the encoder")
|
|
},
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
msfInject(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.PsStr,
|
|
Help: "List remote processes",
|
|
LongHelp: help.GetHelpFor(consts.PsStr),
|
|
Flags: func(f *grumble.Flags) {
|
|
f.Int("p", "pid", -1, "filter based on pid")
|
|
f.String("e", "exe", "", "filter based on executable name")
|
|
f.String("o", "owner", "", "filter based on owner")
|
|
},
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
ps(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.PingStr,
|
|
Help: "Test connection to sliver",
|
|
LongHelp: help.GetHelpFor(consts.PingStr),
|
|
AllowArgs: true,
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
ping(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.GetPIDStr,
|
|
Help: "Get sliver pid",
|
|
LongHelp: help.GetHelpFor(consts.GetPIDStr),
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
getPID(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.GetUIDStr,
|
|
Help: "Get sliver UID",
|
|
LongHelp: help.GetHelpFor(consts.GetUIDStr),
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
getUID(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.GetGIDStr,
|
|
Help: "Get sliver GID",
|
|
LongHelp: help.GetHelpFor(consts.GetGIDStr),
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
getGID(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.WhoamiStr,
|
|
Help: "Get sliver user",
|
|
LongHelp: help.GetHelpFor(consts.WhoamiStr),
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
whoami(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.LsStr,
|
|
Help: "List current directory",
|
|
LongHelp: help.GetHelpFor(consts.LsStr),
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
ls(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.RmStr,
|
|
Help: "Remove a file or directory",
|
|
LongHelp: help.GetHelpFor(consts.RmStr),
|
|
AllowArgs: true,
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
rm(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.MkdirStr,
|
|
Help: "Make a directory",
|
|
LongHelp: help.GetHelpFor(consts.MkdirStr),
|
|
AllowArgs: true,
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
mkdir(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.CdStr,
|
|
Help: "Change directory",
|
|
LongHelp: help.GetHelpFor(consts.CdStr),
|
|
AllowArgs: true,
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
cd(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.PwdStr,
|
|
Help: "Print working directory",
|
|
LongHelp: help.GetHelpFor(consts.PwdStr),
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
pwd(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.CatStr,
|
|
Help: "Dump file to stdout",
|
|
LongHelp: help.GetHelpFor(consts.CatStr),
|
|
AllowArgs: true,
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
cat(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.DownloadStr,
|
|
Help: "Download a file",
|
|
LongHelp: help.GetHelpFor(consts.DownloadStr),
|
|
AllowArgs: true,
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
download(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.UploadStr,
|
|
Help: "Upload a file",
|
|
LongHelp: help.GetHelpFor(consts.UploadStr),
|
|
AllowArgs: true,
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
upload(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
app.AddCommand(&grumble.Command{
|
|
Name: consts.ProcdumpStr,
|
|
Help: "Dump process memory",
|
|
LongHelp: help.GetHelpFor(consts.ProcdumpStr),
|
|
Flags: func(f *grumble.Flags) {
|
|
f.Int("p", "pid", -1, "target pid")
|
|
f.String("n", "name", "", "target process name")
|
|
f.Int("t", "timeout", 360, "command timeout in seconds")
|
|
},
|
|
Run: func(ctx *grumble.Context) error {
|
|
fmt.Println()
|
|
procdump(ctx, rpc)
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
})
|
|
|
|
}
|