plugins

Documentation

Overview

Package plugins defines the spray-plugin contract and a global registry. Each plugin lives in its own subpackage and self-registers via init().

Index

• func Names() []string
• func Register(p Plugin)
• type Attempt
• type Outcome
• type Plugin
  • func Get(name string) (Plugin, bool)
• type ProxySource
• type Result
• type UserEnumerator

Functions

func Names

func Names() []string

func Register

func Register(p Plugin)

Register adds p to the global registry. Must be called from init(). Panics on duplicate names.

Types

type Attempt

type Attempt struct {
	URL         string
	Username    string
	Password    string
	UserAgent   string
	PluginArgs  map[string]string
	Client      *http.Client
	ProxySource ProxySource // optional; only populated when plugin needs pinned-proxy flights

	// InsecureTLS mirrors Config.HTTPOpts.InsecureTLS. Plugins that build
	// their own *http.Client (e.g. connection-pinned NTLM flows in ews,
	// owa, and httpbrute) must honor this flag by forwarding it into
	// httpclient.Options — otherwise a global --insecure-tls has no
	// effect on those plugins.
	InsecureTLS bool
}

type Outcome

type Outcome struct {
	Result    Result
	Output    string
	ValidUser bool
	// UserAbsent is true when the plugin has definitive evidence the user
	// does not exist in the target tenant/realm. The engine skips all
	// further password cycles for this username.
	UserAbsent bool
	Err        error
}

type Plugin

type Plugin interface {
	Name() string
	Validate(args map[string]string) (map[string]string, error)
	TestConnect(ctx context.Context, client *http.Client, args map[string]string, userAgent string) error
	Authenticate(ctx context.Context, a Attempt) Outcome
}

func Get

func Get(name string) (Plugin, bool)

type ProxySource

type ProxySource interface {
	Next(ctx context.Context) (*url.URL, error)
}

ProxySource is the minimum interface plugins need to pick a single proxy URL — e.g. for connection-bound NTLM/Kerberos flights where the pre-built Client's per-request proxy-rotation would split the handshake across different IPs.

type Result

type Result string

const (
	ResultSuccess   Result = "success"
	ResultFailure   Result = "failure"
	ResultPotential Result = "potential"
)

type UserEnumerator

type UserEnumerator interface {
	UserEnumOnly() bool
}

UserEnumerator is an optional interface implemented by plugins that only enumerate usernames and never consume a password. The engine drives them with a single empty-password cycle.