Refactor

Author: hupe1980

README.md

@@ -23,6 +23,38 @@ if err := client.Login("user", "pass"); err != nil {
 }
 defer client.Logout()
 ```
+## Encode data with an encoder
+```golang
+encoded, err := client.Module.Encode("AAAA", "x86/shikata_ga_nai", &gomsf.EncodeOptions{
+    Format: "c",
+})
+if err != nil {
+    panic(err)
+}
+fmt.Printf("%s\n", encoded)
+```
+This will encode 'AAAA' with shikata_ga_nai, and prints the following c code:
+```bash
+unsigned char buf[] =
+"\xbb\xc6\xee\x4d\x66\xd9\xee\xd9\x74\x24\xf4\x58\x33\xc9\xb1"
+"\x02\x31\x58\x12\x83\xe8\xfc\x03\x9e\xe0\xaf\x93\x5f\xbc\x6e"
+"\x1d";
+```
+## Get infos about a module
+```golang
+info, err := client.Module.Info(gomsf.ExploitType, "windows/smb/ms08_067_netapi")
+if err != nil {
+    panic(err)
+}
+
+fmt.Printf("Name: %s\n", info.Name)
+fmt.Printf("Rank: %s\n", info.Rank)
+```
+This gives us the metadata of ms08_067_netapi
+```bash
+Name: MS08-067 Microsoft Server Service Relative Path Stack Corruption
+Rank: great
+```
 
 ## License
 [MIT](LICENCE)

_example/main.go

@@ -28,34 +28,35 @@ func main() {
 
 	fmt.Printf("Version: %s\nRuby: %s\nAPI: %s\n\n", version.Version, version.Ruby, version.API)
 
-	// encodeResult, err := client.Module.Encode("AAAA", "x86/shikata_ga_nai", &rpc.EncodingOptions{
-	// 	Format: "c",
-	// })
-	// if err != nil {
-	// 	panic(err)
-	// }
-
-	// fmt.Println("'AAAA' encoded with shikata_ga_nai:")
-	// fmt.Printf("%s\n", encodeResult.Encoded)
+	encoded, err := client.Module.Encode("AAAA", "x86/shikata_ga_nai", &gomsf.EncodeOptions{
+		Format: "c",
+	})
+	if err != nil {
+		panic(err)
+	}
 
-	// infoResult, err := client.Module.Info(rpc.Exploit, "windows/smb/ms08_067_netapi")
-	// if err != nil {
-	// 	panic(err)
-	// }
+	fmt.Println("'AAAA' encoded with shikata_ga_nai:")
+	fmt.Printf("%s\n", encoded)
 
-	// fmt.Printf("Name: %s\n", infoResult.Name)
-	// fmt.Printf("Rank: %s\n", infoResult.Rank)
+	exploit, err := client.Module.UseExploit("multi/handler")
+	if err != nil {
+		panic(err)
+	}
 
-	// moduleOptions := rpc.NewModuleOptions()
-	// moduleOptions.SetStringOption("LHOST", "0.0.0.0")
-	// moduleOptions.SetIntOption("LPORT", 4444)
-	// moduleOptions.SetStringOption("PAYLOAD", "generic/shell_reverse_tcp")
+	fmt.Println(exploit.Options())
 
-	// executeResult, err := client.Module.Execute(rpc.Exploit, "multi/handler", moduleOptions)
+	// payloads, err := exploit.Payloads()
 	// if err != nil {
 	// 	panic(err)
 	// }
 
-	// fmt.Printf("JobID: %d\n", executeResult.JobID)
-	// fmt.Printf("UUID: %s\n", executeResult.UUID)
+	// fmt.Println(payloads)
+
+	info, err := client.Module.Info(gomsf.ExploitType, "windows/smb/ms08_067_netapi")
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Printf("Name: %s\n", info.Name)
+	fmt.Printf("Rank: %s\n", info.Rank)
 }

core.go

@@ -1,6 +1,10 @@
 package gomsf
 
-import "github.com/hupe1980/gomsf/rpc"
+import (
+	"errors"
+
+	"github.com/hupe1980/gomsf/rpc"
+)
 
 type CoreManager struct {
 	rpc *rpc.RPC
@@ -9,3 +13,17 @@ type CoreManager struct {
 func (c *CoreManager) Version() (*rpc.CoreVersionRes, error) {
 	return c.rpc.Core.Version()
 }
+
+// Stop stops the core
+func (c *CoreManager) Stop() error {
+	r, err := c.rpc.Core.Stop()
+	if err != nil {
+		return err
+	}
+
+	if r.Result == rpc.FAILURE {
+		return errors.New("cannot stop the core")
+	}
+
+	return nil
+}

go.mod

@@ -11,6 +11,7 @@ require (
 )
 
 require (
+	github.com/fatih/structs v1.1.0
 	github.com/stretchr/testify v1.7.0
 	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
 )

go.sum

@@ -1,5 +1,7 @@
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
+github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

gomsf.go

@@ -21,6 +21,7 @@ type MSF struct {
 	Health     *HealthManager
 	Plugins    *PluginManager
 	Jobs       *JobManager
+	Module     *ModuleManager
 }
 
 type MSFOptions struct {
@@ -65,6 +66,7 @@ func New(address string, optFns ...func(o *MSFOptions)) (*MSF, error) {
 		Health:     &HealthManager{rpc: rpc},
 		Plugins:    &PluginManager{rpc: rpc},
 		Jobs:       &JobManager{rpc: rpc},
+		Module:     &ModuleManager{rpc: rpc},
 	}
 
 	return msf, nil

module.go

@@ -0,0 +1,224 @@
+package gomsf
+
+import (
+	"fmt"
+
+	"github.com/fatih/structs"
+	"github.com/hupe1980/gomsf/rpc"
+)
+
+type ModuleType string
+
+const (
+	ExploitType   ModuleType = "exploit"
+	AuxiliaryType ModuleType = "auxiliary"
+	PostType      ModuleType = "post"
+	PayloadType   ModuleType = "payload"
+	EvasionType   ModuleType = "evasion"
+)
+
+type module struct {
+	rpc        *rpc.RPC
+	moduleType ModuleType
+	moduleName string
+	info       *rpc.ModuleInfoRes
+	options    *rpc.ModuleOptionsRes
+}
+
+func newModule(rpc *rpc.RPC, moduleType ModuleType, moduleName string) (*module, error) {
+	info, err := rpc.Module.Info(string(moduleType), moduleName)
+	if err != nil {
+		return nil, err
+	}
+
+	options, err := rpc.Module.Options(string(moduleType), moduleName)
+	if err != nil {
+		return nil, err
+	}
+
+	return &module{
+		rpc:        rpc,
+		moduleType: moduleType,
+		moduleName: moduleName,
+		info:       info,
+		options:    options,
+	}, nil
+}
+
+func (m *module) Options() []string {
+	keys := make([]string, len(*m.options))
+	for k := range *m.options {
+		keys = append(keys, k)
+	}
+
+	return keys
+}
+
+type Exploit struct {
+	*module
+}
+
+func (e *Exploit) Payloads() ([]string, error) {
+	r, err := e.rpc.Module.CompatiblePayloads(e.moduleName)
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Payloads, nil
+}
+
+type Post struct {
+	*module
+}
+
+type Auxiliary struct {
+	*module
+}
+
+type Payload struct {
+	*module
+}
+
+type ModuleManager struct {
+	rpc *rpc.RPC
+}
+
+func (mm *ModuleManager) Architectures() (*rpc.ModuleArchitecturesRes, error) {
+	return mm.rpc.Module.Architectures()
+}
+
+func (mm *ModuleManager) Info(moduleType ModuleType, moduleName string) (*rpc.ModuleInfoRes, error) {
+	return mm.rpc.Module.Info(string(moduleType), moduleName)
+}
+
+func (mm *ModuleManager) Execute(moduleType ModuleType, moduleName string, options map[string]string) (*rpc.ModuleExecuteRes, error) {
+	return mm.rpc.Module.Execute(string(moduleType), moduleName, options)
+}
+
+type EncodeOptions struct {
+	Format       string `structs:"format,omitempty"`        // Encoding format
+	Badchars     string `structs:"badchars,omitempty"`      // Bad characters
+	Platform     string `structs:"platform,omitempty"`      // Platform
+	Arch         string `structs:"arch,omitempty"`          // Architecture
+	ECount       int    `structs:"ecount,omitempty"`        // Number of times to encode
+	Inject       bool   `structs:"inject,omitempty"`        // Enable injection
+	Template     string `structs:"template,omitempty"`      // The template file (an executable)
+	TemplatePath string `structs:"template_path,omitempty"` // Template path
+	Addshellcode string `structs:"addshellcode,omitempty"`  // Custom shellcode
+}
+
+func (mm *ModuleManager) Encode(data string, encoderModule string, options *EncodeOptions) ([]byte, error) {
+	sMap := structs.Map(options)
+
+	optMap := make(map[string]string)
+	for k, v := range sMap {
+		optMap[k] = fmt.Sprintf("%v", v)
+	}
+
+	r, err := mm.rpc.Module.Encode(data, encoderModule, optMap)
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Encoded, nil
+}
+
+func (mm *ModuleManager) Exploits() ([]string, error) {
+	r, err := mm.rpc.Module.Exploits()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Modules, nil
+}
+
+func (mm *ModuleManager) Evasions() ([]string, error) {
+	r, err := mm.rpc.Module.Evasion()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Modules, nil
+}
+
+func (mm *ModuleManager) Payloads() ([]string, error) {
+	r, err := mm.rpc.Module.Payloads()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Modules, nil
+}
+
+func (mm *ModuleManager) Auxiliaries() ([]string, error) {
+	r, err := mm.rpc.Module.Auxiliary()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Modules, nil
+}
+
+func (mm *ModuleManager) Posts() ([]string, error) {
+	r, err := mm.rpc.Module.Post()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Modules, nil
+}
+
+func (mm *ModuleManager) Nops() ([]string, error) {
+	r, err := mm.rpc.Module.Nops()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Modules, nil
+}
+
+func (mm *ModuleManager) Encoders() ([]string, error) {
+	r, err := mm.rpc.Module.Encoders()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Modules, nil
+}
+
+func (mm *ModuleManager) Platforms() (*rpc.ModulePlatformsRes, error) {
+	return mm.rpc.Module.Platforms()
+}
+
+func (mm *ModuleManager) UseExploit(moduleName string) (*Exploit, error) {
+	m, err := newModule(mm.rpc, ExploitType, moduleName)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Exploit{
+		module: m,
+	}, nil
+}
+
+func (mm *ModuleManager) UseAuxiliary(moduleName string) (*Auxiliary, error) {
+	m, err := newModule(mm.rpc, AuxiliaryType, moduleName)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Auxiliary{
+		module: m,
+	}, nil
+}
+
+func (mm *ModuleManager) UsePost(moduleName string) (*Post, error) {
+	m, err := newModule(mm.rpc, PostType, moduleName)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Post{
+		module: m,
+	}, nil
+}