More Optimizations!

- Replaced 'errors.New' with the 'xerr.New' (Less imports than the 'errors' package)
- Replaced 'errors.New' in the "data" package with a number specific error values, include whence values.
- Fixed LICENSE file
- Added a test file to show the improvements of "xerr" over "fmt.Errorf"

Author: iDigitalFlame

LICENSE

@@ -1,7 +1,6 @@
 package c2
 
 import (
-	"errors"
 	"io"
 	"strconv"
 	"time"
@@ -82,13 +81,13 @@ var (
 
 	// ErrMultipleHints is an error returned by the 'Profile' function if more that one Connection Hint Setting is
 	// attempted to be applied by the Config.
-	ErrMultipleHints = errors.New("config attempted to add multiple transforms")
+	ErrMultipleHints = xerr.New("config attempted to add multiple transforms")
 	// ErrInvalidSetting is an error returned by the 'Profile' function if any of the specified Settings are invalid
 	// or do contain valid information. The error returned will be a wrapped version of this error.
-	ErrInvalidSetting = errors.New("config setting is invalid")
+	ErrInvalidSetting = xerr.New("config setting is invalid")
 	// ErrMultipleTransforms is an error returned by the 'Profile' function if more that one Transform Setting is
 	// attempted to be applied by the Config. Unlink Wrappers, Transforms cannot be stacked.
-	ErrMultipleTransforms = errors.New("config attempted to add multiple transforms")
+	ErrMultipleTransforms = xerr.New("config attempted to add multiple transforms")
 )
 
 // Setting is an alias for a byte array that represents a setting in binary form. This can be used inside a

c2/config.go

@@ -2,18 +2,18 @@ package c2
 
 import (
 	"context"
-	"errors"
 	"net"
 	"sync/atomic"
 	"time"
 
 	"github.com/iDigitalFlame/xmt/com"
 	"github.com/iDigitalFlame/xmt/device"
+	"github.com/iDigitalFlame/xmt/util/xerr"
 )
 
 // ErrInvalidPacketCount is returned when attempting to read a packet marked
 // as multi or frag an the total count returned is zero.
-var ErrInvalidPacketCount = errors.New("frag total is zero on a multi or frag packet")
+var ErrInvalidPacketCount = xerr.New("frag total is zero on a multi or frag packet")
 
 // Listener is a struct that is passed back when a C2 Listener is added to the Server. The Listener struct
 // allows for controlling the Listener and setting callback functions to be used when a client connects,

c2/listener.go

@@ -2,7 +2,6 @@ package c2
 
 import (
 	"context"
-	"errors"
 	"net"
 	"sync/atomic"
 
@@ -344,7 +343,7 @@ func (s *Session) Proxy(b string, c serverListener, p *Profile) (*Proxy, error)
 		return nil, xerr.Wrap("unable to listen on "+b, err)
 	}
 	if h == nil {
-		return nil, errors.New("unable to listen on " + b)
+		return nil, xerr.New("unable to listen on " + b)
 	}
 	if s.log == nil {
 		s.log = logx.NOP

c2/proxy.go

@@ -2,18 +2,18 @@ package c2
 
 import (
 	"context"
-	"errors"
 	"strconv"
 	"time"
 
 	"github.com/iDigitalFlame/xmt/c2/task"
 	"github.com/iDigitalFlame/xmt/com"
 	"github.com/iDigitalFlame/xmt/util"
+	"github.com/iDigitalFlame/xmt/util/xerr"
 )
 
 // ErrCannotAssign is an error returned by the 'Schedule' function when the random loop cannot find a valid
 // JobID (unused). This may occur in random circumstances when the Scheduler is overused.
-var ErrCannotAssign = errors.New("unable to assign a unused JobID (is Scheduler full?)")
+var ErrCannotAssign = xerr.New("unable to assign a unused JobID (is Scheduler full?)")
 
 // Job is a struct that is used to track and manage Tasks given to Session Clients. This struct has function callbacks
 // that can be used to watch for completion and also offers a Wait function to pause execution until a response is received.
@@ -149,7 +149,7 @@ func (x *Scheduler) Schedule(s *Session, p *com.Packet) (*Job, error) {
 		p.Device = s.Device.ID
 	}
 	if _, ok := x.jobs[p.Job]; ok {
-		return nil, errors.New("job ID " + strconv.Itoa(int(p.Job)) + " is already being tracked")
+		return nil, xerr.New("job ID " + strconv.Itoa(int(p.Job)) + " is already being tracked")
 	}
 	if err := s.Write(p); err != nil {
 		return nil, err

c2/schedule.go

@@ -2,7 +2,6 @@ package c2
 
 import (
 	"context"
-	"errors"
 	"strings"
 
 	"github.com/PurpleSec/logx"
@@ -26,10 +25,10 @@ const (
 var (
 	// ErrNoConnector is a error returned by the Connect and Listen functions when the Connector is nil and the
 	// provided Profile is also nil or does not contain a connection hint.
-	ErrNoConnector = errors.New("invalid or missing connector")
+	ErrNoConnector = xerr.New("invalid or missing connector")
 	// ErrEmptyPacket is a error returned by the Connect function when the expected return result from the
 	// server was invalid or not expected.
-	ErrEmptyPacket = errors.New("server sent an invalid response")
+	ErrEmptyPacket = xerr.New("server sent an invalid response")
 )
 
 // Server is the manager for all C2 Listener and Sessions connection and states. This struct also manages all
@@ -259,14 +258,14 @@ func (s *Server) Listen(n, b string, c serverListener, p *Profile) (*Listener, e
 	}
 	x := strings.ToLower(n)
 	if _, ok := s.active[x]; ok {
-		return nil, errors.New("listener " + x + " is already active")
+		return nil, xerr.New("listener " + x + " is already active")
 	}
 	h, err := c.Listen(b)
 	if err != nil {
 		return nil, xerr.Wrap("unable to listen on "+b, err)
 	}
 	if h == nil {
-		return nil, errors.New("unable to listen on " + b)
+		return nil, xerr.New("unable to listen on " + b)
 	}
 	if s.Log == nil {
 		s.Log = logx.NOP

c2/server.go

@@ -2,7 +2,6 @@ package c2
 
 import (
 	"context"
-	"errors"
 	"io"
 	"net"
 	"strconv"
@@ -22,9 +21,9 @@ const maxErrors = 2
 var (
 	// ErrUnable is an error returned for a generic action if there is some condition that prevents the action
 	// from running.
-	ErrUnable = errors.New("cannot preform this action")
+	ErrUnable = xerr.New("cannot preform this action")
 	// ErrFullBuffer is returned from the WritePacket function when the send buffer for Session is full.
-	ErrFullBuffer = errors.New("cannot add a Packet to a full send buffer")
+	ErrFullBuffer = xerr.New("cannot add a Packet to a full send buffer")
 )
 
 // Session is a struct that represents a connection between the client and the Listener. This struct does some
@@ -301,7 +300,7 @@ func (c *cluster) add(p *com.Packet) error {
 		return nil
 	}
 	if len(c.data) > 0 && !c.data[0].Belongs(p) {
-		return errors.New("packet ID " + strconv.FormatUint(uint64(p.ID), 16) + " does not match combining Packet ID")
+		return xerr.New("packet ID " + strconv.FormatUint(uint64(p.ID), 16) + " does not match combining Packet ID")
 	}
 	if p.Flags.Len() > c.max {
 		c.max = p.Flags.Len()

c2/session.go

@@ -2,12 +2,12 @@ package task
 
 import (
 	"context"
-	"errors"
 	"reflect"
 	"strconv"
 
 	"github.com/iDigitalFlame/xmt/com"
 	"github.com/iDigitalFlame/xmt/device"
+	"github.com/iDigitalFlame/xmt/util/xerr"
 )
 
 // Engine is an interface that allows for extending XMT with non-compiled code for easy deployability and flexibility.
@@ -57,10 +57,10 @@ func (s scriptTasker) Do(x context.Context, p *com.Packet) (*com.Packet, error)
 // See the 'cmd/script' package for scripting engines.
 func RegisterEngine(i uint8, s Engine) error {
 	if i < 21 {
-		return errors.New("script mapping ID " + strconv.Itoa(int(i)) + " is invalid")
+		return xerr.New("script mapping ID " + strconv.Itoa(int(i)) + " is invalid")
 	}
 	if Mappings[i] != nil {
-		return errors.New("script mapping ID " + strconv.Itoa(int(i)) + " is currently used by " + reflect.TypeOf(Mappings[i]).String())
+		return xerr.New("script mapping ID " + strconv.Itoa(int(i)) + " is currently used by " + reflect.TypeOf(Mappings[i]).String())
 	}
 	Mappings[i] = scriptTasker{s}
 	return nil

c2/task/script.go

@@ -1,12 +1,12 @@
 package transform
 
 import (
-	"errors"
 	"io"
 	"strings"
 	"sync"
 
 	"github.com/iDigitalFlame/xmt/util"
+	"github.com/iDigitalFlame/xmt/util/xerr"
 )
 
 const (
@@ -38,7 +38,7 @@ var (
 	// ErrInvalidLength is an error raised by the Read and Write functions
 	// if the byte array supplied is smaller than the required byte size to
 	// Transform into a DNS packet.
-	ErrInvalidLength = errors.New("length of byte array is invalid")
+	ErrInvalidLength = xerr.New("length of byte array is invalid")
 
 	bufs = sync.Pool{
 		New: func() interface{} {

c2/transform/dns.go

@@ -3,7 +3,6 @@ package c2
 import (
 	"bytes"
 	"context"
-	"errors"
 	"io"
 	"net"
 	"sync"
@@ -155,7 +154,7 @@ func notify(l *Listener, s *Session, p *com.Packet) error {
 		if p.ID == MvRegister {
 			p.Device = s.Device.ID
 		} else {
-			return errors.New(`received a Session ID "` + p.Device.String() + `"that does not match our own ID "` + s.ID.String() + `"`)
+			return xerr.New(`received a Session ID "` + p.Device.String() + `"that does not match our own ID "` + s.ID.String() + `"`)
 		}
 	}
 	if l != nil && p.Flags&com.FlagOneshot != 0 {

c2/vars.go

@@ -3,9 +3,10 @@ package wrapper
 import (
 	"compress/gzip"
 	"compress/zlib"
-	"errors"
 	"io"
 	"strconv"
+
+	"github.com/iDigitalFlame/xmt/util/xerr"
 )
 
 const (
@@ -28,7 +29,7 @@ type GzipWrap int8
 // is invalid.
 func NewZlib(level int) (ZlibWrap, error) {
 	if level < zlib.HuffmanOnly || level > zlib.BestCompression {
-		return 0, errors.New("invalid compression level " + strconv.Itoa(level))
+		return 0, xerr.New("invalid compression level " + strconv.Itoa(level))
 	}
 	return ZlibWrap(level), nil
 }
@@ -37,7 +38,7 @@ func NewZlib(level int) (ZlibWrap, error) {
 // is invalid.
 func NewGzip(level int) (GzipWrap, error) {
 	if level < gzip.HuffmanOnly || level > gzip.BestCompression {
-		return 0, errors.New("invalid compression level " + strconv.Itoa(level))
+		return 0, xerr.New("invalid compression level " + strconv.Itoa(level))
 	}
 	return GzipWrap(level), nil
 }

c2/wrapper/compress.go

@@ -2,15 +2,15 @@ package wrapper
 
 import (
 	"crypto/cipher"
-	"errors"
 	"io"
 
 	"github.com/iDigitalFlame/xmt/data/crypto"
+	"github.com/iDigitalFlame/xmt/util/xerr"
 )
 
 // ErrInvalid is returned when the arguments provided to any of the New* functions when the
 // arguments are nil or empty.
-var ErrInvalid = errors.New("provided crypto arguments cannot be nil")
+var ErrInvalid = xerr.New("provided crypto arguments cannot be nil")
 
 // Block is a struct that contains an IV and Block-based Cipher that can be used to Wrap/Unwrap with the specified
 // encryption algorithm.

c2/wrapper/crypto.go

@@ -3,7 +3,6 @@ package cmd
 import (
 	"bytes"
 	"context"
-	"errors"
 	"io"
 	"os"
 	"strconv"
@@ -18,20 +17,20 @@ const exitStopped uint32 = 0x1337
 
 var (
 	// ErrEmptyCommand is an error returned when attempting to start a Process that has an empty 'Args' array.
-	ErrEmptyCommand = errors.New("process arguments are empty")
+	ErrEmptyCommand = xerr.New("process arguments are empty")
 	// ErrNotCompleted is returned when attempting to access the exit code on a running process or wait on a
 	// non-stared proess.
-	ErrNotCompleted = errors.New("the process has not yet completed or was not started")
+	ErrNotCompleted = xerr.New("the process has not yet completed or was not started")
 	// ErrAlreadyStarted is an error returned by the 'Start' or 'Run' functions when attempting to start a process
 	// that has already been started via a 'Start' or 'Run' function call.
-	ErrAlreadyStarted = errors.New("process has already been started")
+	ErrAlreadyStarted = xerr.New("process has already been started")
 	// ErrNoProcessFound is returned by the SetParent* functions on Windows devices when a specified parent process
 	// could not be found.
-	ErrNoProcessFound = errors.New("could not find a suitable parent process")
+	ErrNoProcessFound = xerr.New("could not find a suitable parent process")
 
-	errStdinSet  = errors.New("process Stdin already set")
-	errStderrSet = errors.New("process Stderr already set")
-	errStdoutSet = errors.New("process Stdout already set")
+	errStdinSet  = xerr.New("process Stdin already set")
+	errStderrSet = xerr.New("process Stderr already set")
+	errStdoutSet = xerr.New("process Stdout already set")
 )
 
 // Process is a struct that represents an executable command and allows for setting

cmd/cmd.go

@@ -3,13 +3,13 @@
 package cmd
 
 import (
-	"errors"
 	"os"
 	"os/exec"
 	"sync/atomic"
 	"syscall"
 
 	"github.com/iDigitalFlame/xmt/device/devtools"
+	"github.com/iDigitalFlame/xmt/util/xerr"
 )
 
 const (
@@ -51,7 +51,7 @@ func (p *Process) wait() {
 // Fork will attempt to use built-in system utilities to fork off the process into a separate, but similar process.
 // If successful, this function will return the PID of the new process.
 func Fork() (uint32, error) {
-	return 0, errors.New("currently unimplemented on *nix systems (WIP)")
+	return 0, xerr.New("currently unimplemented on *nix systems (WIP)")
 }
 
 // Pid returns the current process PID. This function returns zero if the process has not been started.

cmd/cmd_nix.go

@@ -3,7 +3,6 @@
 package cmd
 
 import (
-	"errors"
 	"io"
 	"os"
 	"reflect"
@@ -30,7 +29,7 @@ var (
 
 	funcAllocConsole                      = dllKernel32.NewProc("AllocConsole")
 	funcCreateProcess                     = dllKernel32.NewProc("CreateProcessW")
-	funcCreateProcessAsUser               = dllKernel32.NewProc("CreateProcessAsUserA")
+	funcCreateProcessAsUser               = dllKernel32.NewProc("CreateProcessAsUserW")
 	funcUpdateProcThreadAttribute         = dllKernel32.NewProc("UpdateProcThreadAttribute")
 	funcInitializeProcThreadAttributeList = dllKernel32.NewProc("InitializeProcThreadAttributeList")
 )
@@ -122,7 +121,7 @@ func createEnv(s []string) (*uint16, error) {
 	var t, i, l int
 	for _, s := range s {
 		if q := strings.IndexByte(s, 61); q <= 0 {
-			return nil, errors.New(`invalid environment string "` + s + `"`)
+			return nil, xerr.New(`invalid environment string "` + s + `"`)
 		}
 		t += len(s) + 1
 	}
@@ -308,8 +307,7 @@ func newParentEx(p windows.Handle, i *windows.StartupInfo) (*startupInfoEx, erro
 	x.StartupInfo.Cb = uint32(unsafe.Sizeof(x))
 	r, _, err = funcUpdateProcThreadAttribute.Call(
 		uintptr(unsafe.Pointer(x.AttributeList)), 0, 0x00020000,
-		uintptr(unsafe.Pointer(&p)), uintptr(unsafe.Sizeof(p)),
-		uintptr(unsafe.Pointer(nil)), uintptr(unsafe.Pointer(nil)),
+		uintptr(unsafe.Pointer(&p)), uintptr(unsafe.Sizeof(p)), 0, 0,
 	)
 	if r == 0 {
 		return nil, xerr.Wrap("winapi UpdateProcThreadAttribute error", err)

cmd/zcmd_windows.go

@@ -2,7 +2,6 @@ package com
 
 import (
 	"bytes"
-	"errors"
 	"strconv"
 
 	"github.com/iDigitalFlame/xmt/data"
@@ -71,7 +70,7 @@ func (p *Packet) Add(n *Packet) error {
 		return nil
 	}
 	if p.ID != n.ID {
-		return errors.New("Packet ID " + strconv.FormatUint(uint64(n.ID), 16) + " does not match combining Packet ID " + strconv.FormatUint(uint64(p.ID), 16))
+		return xerr.New("Packet ID " + strconv.FormatUint(uint64(n.ID), 16) + " does not match combining Packet ID " + strconv.FormatUint(uint64(p.ID), 16))
 	}
 	if _, err := n.WriteTo(p); err != nil {
 		return xerr.Wrap("unable to write to Packet", err)