httpmw

Documentation

Index

• Variables
• func BasicAuth(storage string) gin.HandlerFunc
• func CORS() gin.HandlerFunc
• func Cache(p *CacheParams) gin.HandlerFunc
• func IPBasicAuth(ipRange string, authStorage string) gin.HandlerFunc
• func IpCognitoAuth(p *IpCognitoParams) gin.HandlerFunc
• func Limit(limit int, ipRanges ...string) gin.HandlerFunc
• func LimitPerUser(cmdable redis.Cmdable, limit int, key string, expiration time.Duration, ...) gin.HandlerFunc
• func LogFormatter(p gin.LogFormatterParams) string
• func NotFound() gin.HandlerFunc
• func RBAC(fn RBACAuthorizeFunc) gin.HandlerFunc
• type CacheParams
• type CognitoClaims
• type CognitoUser
  • func (cu *CognitoUser) GetGroups() []string
  • func (cu *CognitoUser) GetUsername() string
  • func (cu *CognitoUser) IsInGroup(groups ...string) bool
  • func (cu *CognitoUser) SetGroups(groups []string)
  • func (cu *CognitoUser) SetUsername(username string)
• type IpCognitoParams
• type JWK
  • func (j *JWK) Fetch(iss interface{}) error
  • func (j *JWK) Find(kid string) (*Key, error)
• type Key
  • func (k *Key) RSA256() (*rsa.PublicKey, error)
• type RBACAuthorizeFunc
  • func CasbinRBACAuthorizer(e *casbin.Enforcer) RBACAuthorizeFunc
• type RedisLimiter
  • func NewRedisLimiter(cmdable redis.Cmdable, entity string, limit int, expire time.Duration) *RedisLimiter
  • func (rl *RedisLimiter) Allow(ctx context.Context, identifier string) (bool, error)
  • func (rl *RedisLimiter) Seen(ctx context.Context, identifier string) error

Variables

var ErrNoUser = errors.New("missing user in request context")

ErrNoUser indicates there is no user (or the user is nil) in the request's context.

Functions

func BasicAuth

func BasicAuth(storage string) gin.HandlerFunc

BasicAuth middleware for basic authentication in format "user:pass,user2:pass2,user3:pass3"

func CORS

func CORS() gin.HandlerFunc

CORS middleware

func Cache

func Cache(p *CacheParams) gin.HandlerFunc

Cache middleware to cache http responses

func IPBasicAuth

func IPBasicAuth(ipRange string, authStorage string) gin.HandlerFunc

IPBasicAuth middleware for: * IP ranges verification in format "192.168.10.1-192.168.10.10,192.168.90.1-192.168.90.10" * basic authentication in format "user:pass,user2:pass2,user3:pass3"

func IpCognitoAuth

func IpCognitoAuth(p *IpCognitoParams) gin.HandlerFunc

IpCognitoAuth middleware for: * IP ranges verification in format "192.168.10.1-192.168.10.10,192.168.90.1-192.168.90.10" * cognito authentication through Authorization Bearer Token Note: If the expiration duration is less than one, the items in the cache never expire (by default), and must be deleted manually. If the cleanup interval is less than one, expired items are not deleted from the cache.

func Limit

func Limit(limit int, ipRanges ...string) gin.HandlerFunc

Limit middleware to limit number of request per second if you pass "inRanges" parameter the limit will be applied only to those IP addresses * IP ranges verification in format "192.168.10.1-192.168.10.10,192.168.90.1-192.168.90.10"

func LimitPerUser

func LimitPerUser(cmdable redis.Cmdable, limit int, key string, expiration time.Duration, groups ...string) gin.HandlerFunc

LimitPerUser middleware is used to limit number of request per second for user. Note: if expiration is set to 0 it means the key has no expiration time.

func LogFormatter

func LogFormatter(p gin.LogFormatterParams) string

LogFormatter builds a logging entry in JSON format containing these fields: - Unix timestamp of the request time - Client's IP address - Accessed API endpoint/path - Request method (GET, POST, PUT, PATCH, DELETE) - Request's response status code - Latency of the request in milliseconds - Response body size in bytes

This function will also look into the gin's context for a user instance. If a CognitoUser instance is found, the formatter will also include the following fields: - Username - User associated group(s)

func NotFound

func NotFound() gin.HandlerFunc

NotFound handler for not found routes

func RBAC

func RBAC(fn RBACAuthorizeFunc) gin.HandlerFunc

RBAC implements RBAC using the provided authorizer function.

Types

type CacheParams

type CacheParams struct {
	Cache       redis.Cmdable
	Expire      time.Duration
	Handle      gin.HandlerFunc
	ContentType string
}

type CognitoClaims

type CognitoClaims struct {
	jwt.StandardClaims
	ClientID string   `json:"client_id"`
	ISS      string   `json:"iss"`
	Groups   []string `json:"cognito:groups"`
}

CognitoClaims claims object for cognito JWT token.

type CognitoUser

type CognitoUser struct {
	Username string              `json:"username,omitempty"`
	Groups   []string            `json:"groups,omitempty"`
	Lookup   map[string]struct{} `json:"-"`
}

CognitoUser cognito user entity.

func (*CognitoUser) GetGroups

func (cu *CognitoUser) GetGroups() []string

GetGroups get user groups private property

func (*CognitoUser) GetUsername

func (cu *CognitoUser) GetUsername() string

GetUsername get private username property

func (*CognitoUser) IsInGroup

func (cu *CognitoUser) IsInGroup(groups ...string) bool

Checks if user groups contains passed groups

func (*CognitoUser) SetGroups

func (cu *CognitoUser) SetGroups(groups []string)

Set cognito groups for user

func (*CognitoUser) SetUsername

func (cu *CognitoUser) SetUsername(username string)

SetUsername sets username for user

type IpCognitoParams

type IpCognitoParams struct {
	Srv      cognitoidentityprovideriface.CognitoIdentityProviderAPI
	Cache    redis.Cmdable
	ClientID string
	IpRange  string
	Expire   time.Duration
	User     *CognitoUser
}

IpCognitoParams structure epresents middleware parameters

type JWK

type JWK struct {
	Keys []*Key `json:"keys"`
	// contains filtered or unexported fields
}

JWK JSON web keys list.

func (*JWK) Fetch

func (j *JWK) Fetch(iss interface{}) error

Fetch get keys from the source.

func (*JWK) Find

func (j *JWK) Find(kid string) (*Key, error)

Find key by identifier.

type Key

type Key struct {
	Alg string `json:"alg"`
	E   string `json:"e"`
	KID string `json:"kid"`
	KTY string `json:"kty"`
	N   string `json:"n"`
	Use string `json:"use"`
	// contains filtered or unexported fields
}

Key public key meta data.

func (*Key) RSA256

func (k *Key) RSA256() (*rsa.PublicKey, error)

RSA256 convert payload to a valid public key.

type RBACAuthorizeFunc

type RBACAuthorizeFunc func(*gin.Context) (bool, error)

RBACAuthorizeFunc is the type alias for a RBAC Authorize function signature.

func CasbinRBACAuthorizer

func CasbinRBACAuthorizer(e *casbin.Enforcer) RBACAuthorizeFunc

CasbinRBACAuthorizer uses a provided Casbin enforcer to implement RBAC middleware. This function will look up for a `CognitoUser` instance stored in the request's `gin.Context` using the `user` key, and will attempt to authorize the request using each one of the user's roles. If no match is made, the request will be rejected.

type RedisLimiter

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

RedisLimiter struct is used for storing limit, expiration and redis client

func NewRedisLimiter

func NewRedisLimiter(cmdable redis.Cmdable, entity string, limit int, expire time.Duration) *RedisLimiter

NewRedisLimiter creates new redis limiter Note: if expire is set to 0 it means the key has no expiration time

func (*RedisLimiter) Allow

func (rl *RedisLimiter) Allow(ctx context.Context, identifier string) (bool, error)

Allow checks identifier is allowed to continue depending on limit

func (*RedisLimiter) Seen

func (rl *RedisLimiter) Seen(ctx context.Context, identifier string) error

Seen increments number of actions performed by this particular identifier