veles

type DetectionEngine ¶

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

DetectionEngine combines multiple Veles Detectors into a single engine that can read from an io.Reader. It outputs the results of applying all Detectors to that stream.

Future optimizations might change how the engine works under the hood but its API should stay stable. It makes no guarantee about the order in which Secrets are found so calling code should not depend on it.

func NewDetectionEngine(ds []Detector, opts ...DetectionEngineOption) (*DetectionEngine, error)

func (e *DetectionEngine) Detect(ctx context.Context, r io.Reader) ([]Secret, error)

type DetectionEngineOption ¶

type DetectionEngineOption func(*DetectionEngine)

DetectionEngineOption is an option to configure a DetectionEngine during creation via NewDetectionEngine.

This allows user to fine tune the engine by overriding its defaults. For most use-cases, the defaults should be sensible enough.

func WithReadLen(readLen uint32) DetectionEngineOption

func WithRetainLen(retainLen uint32) DetectionEngineOption

type Detector ¶

type Detector interface {
	// MaxSecretLen is the maximum length a secret from this detector can have.
	//
	// It can be set to 0 but then the detector isn't guaranteed any minimum input
	// length and should instead implement its own mechanism to ensure it can find
	// its secrets; i.e. maintain an internal buffer.
	MaxSecretLen() uint32
	// Detect finds Secrets inside data and returns them alongside indices to the
	// start of the corresponding match.
	// The latter is only used internally to avoid duplicates.
	Detect(data []byte) ([]Secret, []int)
}

Detector finds instances of Secrets inside a chunk of text.

While most commonly a detector will emit one specific type of secret, we also allow for Detectors to return multiple distinct types - thus the []Secret return type.

type Secret ¶

type Secret any

Secret is a secret that can be found by a Detector and validated by a Validator.

Detectors return slices of Secret and validators accept concrete types. That allows them to be used independently with maximum flexibility.

While the interface is empty, each Secret should be convertible to and from the Veles protocol buffer message format; see the velesproto package. In order to not have the library explicitly depend on protocol buffers, we did not make that requirement part of the interface.

type ValidationEngine ¶

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

ValidationEngine bundles a number of Validators together.

There can only be one Validator[S] for each concrete S.

func NewValidationEngine(opts ...ValidationEngineOption) *ValidationEngine

func (e *ValidationEngine) Validate(ctx context.Context, s Secret) (ValidationStatus, error)

type ValidationEngineOption ¶

type ValidationEngineOption func(*ValidationEngine)

ValidationEngineOption is an option that can be used to configure a ValidationEngine at creation via NewValidationEngine.

func WithValidator[S Secret](v Validator[S]) ValidationEngineOption

type ValidationStatus ¶

type ValidationStatus string

ValidationStatus represents the result status of validating a Secret using a corresponding Validator.

const (
	// ValidationUnspecified is the default value for ValidationStatus. It should
	// not be returned by a concrete Validator.
	//
	// The value of ValidationUnspecified is the empty string instead of a
	// meaningful value so it is the automatic default.
	ValidationUnspecified ValidationStatus = ""
	// ValidationUnsupported occurs only if a ValidationEngine has no Validator
	// for a given Secret type.
	ValidationUnsupported ValidationStatus = "VALIDATION_UNSUPPORTED"
	// ValidationFailed occurs if a Validator was not able to make a validation
	// decision because an error occurred.
	// This will be returned alongside the error so calling code can decide
	// whether it's worth retrying.
	ValidationFailed ValidationStatus = "VALIDATION_FAILED"
	// ValidationInvalid occurs if a validation was successful but the result is
	// negative: the Secret is not valid.
	ValidationInvalid ValidationStatus = "VALIDATION_INVALID"
	// ValidationValid occurs if the validation was successful and the result is
	// positive: the Secret is valid.
	ValidationValid ValidationStatus = "VALIDATION_VALID"
)

type Validator ¶

type Validator[S Secret] interface {
	Validate(ctx context.Context, secret S) (ValidationStatus, error)
}

Validator is a Validator for the concrete Secret type S.

It is used to validate Secrets of type S and returns the corresponding ValidationStatus or an error (in which case the ValidationStatus is ValidationStatusFailed).