mod_secure_link

Documentation

Index

• Variables
• type Checker
  • func NewChecker(cc *CheckerConfig) (*Checker, error)
  • func (cs *Checker) Check(request *bfe_basic.Request) error
• type CheckerConfig
• type ConfModSecureLink
  • func ConfLoad(filePath string, confRoot string) (*ConfModSecureLink, error)
• type Data
  • func DataLoad(filename string) (*Data, error)
  • func NewData(cf *DataFile) (*Data, error)
• type DataFile
• type Expression
  • func NewExpression(cc *CheckerConfig) (*Expression, error)
  • func (exp *Expression) Value(req *bfe_basic.Request) string
• type ExpressionNode
  • func NewNode(enf ExpressionNodeFile) (ExpressionNode, error)
• type ExpressionNodeFile
• type ModuleSecureLink
  • func NewModuleSecureLink() *ModuleSecureLink
  • func (m *ModuleSecureLink) Init(cbs *bfe_module.BfeCallbacks, whs *web_monitor.WebHandlers, cr string) error
  • func (m *ModuleSecureLink) Name() string
• type ModuleSecureLinkState
• type NodeConfig
• type ProductRules
• type ProductRulesFile
• type Rule
  • func NewRule(rf *RuleFile) (*Rule, error)
  • func (rule *Rule) Check(req *bfe_basic.Request) error
• type RuleFile
• type SecureLinkTable
  • func NewSecureLinkTable() *SecureLinkTable
  • func (t *SecureLinkTable) Search(product string) ([]*Rule, bool)
  • func (t *SecureLinkTable) Update(conf *Data)

Variables

var (
	ErrReqWithoutExpiresKey   = fmt.Errorf("bad req: without expires key")
	ErrReqInvalidExpiresValue = fmt.Errorf("bad req: invalid expires val")
	ErrReqWithoutChecksumKey  = fmt.Errorf("bad req: without checksum key")
	ErrReqInvalidChecksum     = fmt.Errorf("bad req: invalid checksum key")
	ErrReqExpired             = fmt.Errorf("req overdue")
)

Types

type Checker

type Checker struct {
	Config *CheckerConfig
	// contains filtered or unexported fields
}

func NewChecker

func NewChecker(cc *CheckerConfig) (*Checker, error)

NewChecker gen

func (*Checker) Check

func (cs *Checker) Check(request *bfe_basic.Request) error

Check validate request

type CheckerConfig

type CheckerConfig struct {
	ChecksumKey     string
	ExpiresKey      string
	ExpressionNodes []ExpressionNodeFile
}

type ConfModSecureLink

type ConfModSecureLink struct {
	Basic struct {
		DataPath string // path of config data (mod_secure_link)
	}

	Log struct {
		OpenDebug bool
	}
}

func ConfLoad

func ConfLoad(filePath string, confRoot string) (*ConfModSecureLink, error)

type Data

type Data struct {
	Version string       // version of the config
	Config  ProductRules // product rules for header
}

func DataLoad

func DataLoad(filename string) (*Data, error)

DataLoad loads config of header from file.

func NewData

func NewData(cf *DataFile) (*Data, error)

type DataFile

type DataFile struct {
	Version *string // version of the config
	Config  ProductRulesFile
}

type Expression

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

func NewExpression

func NewExpression(cc *CheckerConfig) (*Expression, error)

func (*Expression) Value

func (exp *Expression) Value(req *bfe_basic.Request) string

type ExpressionNode

type ExpressionNode interface {
	Value(req *bfe_basic.Request) string
}

func NewNode

func NewNode(enf ExpressionNodeFile) (ExpressionNode, error)

type ExpressionNodeFile

type ExpressionNodeFile struct {
	Type  string
	Param string
}

type ModuleSecureLink

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

ModuleSecureLink mean secure link module

func NewModuleSecureLink

func NewModuleSecureLink() *ModuleSecureLink

NewModuleSecureLink create module

func (*ModuleSecureLink) Init

func (m *ModuleSecureLink) Init(cbs *bfe_module.BfeCallbacks, whs *web_monitor.WebHandlers, cr string) error

Init init mode, will be invoked by framework

func (*ModuleSecureLink) Name

func (m *ModuleSecureLink) Name() string

Name return module name

type ModuleSecureLinkState

type ModuleSecureLinkState struct {
	ReqTotal  *metrics.Counter // all request in
	ReqAccept *metrics.Counter // request accept

	ReqWithoutExpiresKey   *metrics.Counter
	ReqInvalidExpiresValue *metrics.Counter
	ReqWithoutChecksumKey  *metrics.Counter
	ReqInvalidChecksum     *metrics.Counter
	ReqExpired             *metrics.Counter
}

type NodeConfig

type NodeConfig struct {
	ChecksumKey string
	ExpiresKey  string
	Expr        string
}

type ProductRules

type ProductRules map[string][]*Rule

type ProductRulesFile

type ProductRulesFile map[string][]*RuleFile

type Rule

type Rule struct {
	Cond condition.Condition // condition for header

	ChecksumKey string
	ExpiresKey  string

	Expression *Expression

	Checker *Checker
}

func NewRule

func NewRule(rf *RuleFile) (*Rule, error)

NewRule get Rule by RuleFile

func (*Rule) Check

func (rule *Rule) Check(req *bfe_basic.Request) error

type RuleFile

type RuleFile struct {
	Cond *string

	ChecksumKey     *string
	ExpiresKey      *string
	ExpressionNodes []ExpressionNodeFile
}

RuleFile define how to validate secure link

type SecureLinkTable

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

func NewSecureLinkTable

func NewSecureLinkTable() *SecureLinkTable

func (*SecureLinkTable) Search

func (t *SecureLinkTable) Search(product string) ([]*Rule, bool)

func (*SecureLinkTable) Update

func (t *SecureLinkTable) Update(conf *Data)