command

Documentation

Index

• Variables
• type Iter
  • func NewIter() *Iter
  • func (iter *Iter) Next() byte

Variables

var EvalCommand = &artillery.Command{
	Name:        "eval",
	Description: "evaluate basic arithmatic expression",
	Arguments: []*artillery.Argument{
		{
			Name:        "expression",
			Description: "arithmatic expression",
		},
	},
	Options: []*artillery.Option{
		{
			Name:        "dec",
			ShortName:   'd',
			Description: "output result in decimal format",
			Type:        artillery.Bool,
			Value:       true,
		},
	},
	OnExecute: evalExpressionCmd,
}

var PatternCommand = &artillery.Command{
	Name:        "pattern",
	Description: "pattern generation / offset detection",
	SubCommands: []*artillery.Command{
		{
			Name:        "create",
			Description: "create an n-byte length pattern suitable for offset detection",
			Arguments: []*artillery.Argument{
				{
					Name:        "length",
					Description: "number of bytes to generate",
					Type:        artillery.Int,
				},
			},
			Options: []*artillery.Option{
				{
					Name:        "fixed",
					ShortName:   'f',
					Description: "fixed portion of pattern for extra large buffers",
					Type:        artillery.Int,
				},
				{
					Name:        "char",
					ShortName:   'c',
					Description: "character to use for fixed portion of pattern (single character or hex value)",
					Type:        artillery.String,
				},
			},
			OnExecute: generateBytes,
		},
		{
			Name:        "offset",
			Description: "report offset given the supplied pattern fragement",
			Arguments: []*artillery.Argument{
				{
					Name:        "pattern",
					Description: "pattern fragment from which to calculate the offset",
				},
			},
			Options: []*artillery.Option{
				{
					Name:        "fixed",
					ShortName:   'f',
					Description: "number of fixed bytes used in pattern creation",
					Type:        artillery.Int,
				},
				{
					Name:        "hex",
					ShortName:   'h',
					Description: "output offset in hex format",
					Type:        artillery.Bool,
					Value:       true,
				},
			},
			OnExecute: calculateOffset,
		},
	},
}

var PayloadCommand = &artillery.Command{
	Name:        "payload",
	Description: "generates a shellcode payload for a buffer overflow",
	Arguments: []*artillery.Argument{
		{
			Name:        "offset",
			Description: "buffer offset where return address will be written",
			Type:        artillery.Int,
		},
		{
			Name:        "returnAddress",
			Description: "return address in highest-to-lowest hex format (eg. \\xed\\x32\\x44\\x55)",
		},
		{
			Name:        "shellcode",
			Description: "shellcode in hex string format (eg. \\xed\\x32\\x44\\x55\\xed\\x32\\x44\\x55)",
		},
	},
	Options: []*artillery.Option{
		{
			Name:        "append",
			ShortName:   'a',
			Description: "append shellcode after return address",
			Type:        artillery.Bool,
			Value:       true,
		},
		{
			Name:        "nsb",
			ShortName:   'n',
			Description: "number of nopsled bytes to insert (defaults to half the remaining buffer space)",
			Type:        artillery.Int,
		},
		{
			Name:        "hex",
			ShortName:   'h',
			Description: "output in hex format for visualization purposes",
			Type:        artillery.Bool,
			Value:       true,
		},
		{
			Name:        "big",
			ShortName:   'b',
			Description: "specify big-endian byte order",
			Type:        artillery.Bool,
			Value:       true,
		},
	},
	OnExecute: makePayload,
}

var StripeCommand = &artillery.Command{
	Name:        "stripe",
	Description: "generates a buffer of characters for visual buffer recognition",
	Arguments: []*artillery.Argument{
		{
			Name:        "offset",
			Description: "offset of return address in bytes",
			Type:        artillery.Int,
		},
	},
	Options: []*artillery.Option{
		{
			Name:        "hex",
			ShortName:   'h',
			Description: "output in hex format for visualization purposes",
			Type:        artillery.Bool,
			Value:       true,
		},
		{
			Name:        "align",
			ShortName:   'a',
			Description: "align the stripe pattern by prepending n bytes of data",
			Type:        artillery.Int,
		},
		{
			Name:        "extend",
			ShortName:   'e',
			Description: "extend the stripe pattern after the return address by n bytes",
			Type:        artillery.Int,
		},
	},
	OnExecute: generateStripe,
}

var Version string

var VersionCommand = &artillery.Command{
	Name:        "version",
	Description: "display version information",
	OnExecute: func(n artillery.Namespace, p *artillery.Processor) error {
		fmt.Println(Version)
		return nil
	},
}

Types

type Iter

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

func NewIter

func NewIter() *Iter

func (*Iter) Next

func (iter *Iter) Next() byte