clientip

type BlacklistRangeOption ¶

type BlacklistRangeOption interface {
	// contains filtered or unexported methods
}

func ExcludeLinkLocal(enable bool) BlacklistRangeOption

func ExcludeLoopback(enable bool) BlacklistRangeOption

func ExcludePrivateNet(enable bool) BlacklistRangeOption

type Chain ¶

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

Chain attempts to use the given resolvers in order. If the first one returns an error, the second one is tried, and so on, until a good IP is found or the resolvers are exhausted. A common use for this is if a server is both directly connected to the internet and expecting a header to check. It might be called like:

var chain = NewChain(NewLeftmostNonPrivate(XForwardedForKey), NewRemoteAddr())

func NewChain(resolvers ...fox.ClientIPResolver) Chain

func (s Chain) ClientIP(c fox.RequestContext) (*net.IPAddr, error)

type HeaderKey ¶

type HeaderKey uint8

const (
	XForwardedForKey HeaderKey = iota
	ForwardedKey
)

func (h HeaderKey) String() string

type LeftmostNonPrivate ¶

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

LeftmostNonPrivate derives the client IP from the leftmost valid and non-private/non-internal IP address in the X-Forwarded-For or Forwarded header. This resolver should be used when a valid, non-private IP closest to the client is desired. By default, loopback, link local and private net ip range are blacklisted. Note that this MUST NOT BE USED FOR SECURITY PURPOSES. This IP can be TRIVIALLY SPOOFED.

func NewLeftmostNonPrivate(key HeaderKey, limit uint, opts ...BlacklistRangeOption) (LeftmostNonPrivate, error)

func (s LeftmostNonPrivate) ClientIP(c fox.RequestContext) (*net.IPAddr, error)

type RemoteAddr ¶

type RemoteAddr struct{}

RemoteAddr returns the client socket IP, stripped of port. This resolver should be used if the server accept direct connections, rather than through a reverse proxy.

func NewRemoteAddr() RemoteAddr

func (s RemoteAddr) ClientIP(c fox.RequestContext) (*net.IPAddr, error)

type RightmostNonPrivate ¶

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

RightmostNonPrivate derives the client IP from the rightmost valid, non-private/non-internal IP address in the X-Fowarded-For or Forwarded header. This resolver should be used when all reverse proxies between the internet and the server have private-space IP addresses. By default, loopback, link local and private net ip range are trusted.

func NewRightmostNonPrivate(key HeaderKey, opts ...TrustedRangeOption) (RightmostNonPrivate, error)

func (s RightmostNonPrivate) ClientIP(c fox.RequestContext) (*net.IPAddr, error)

type RightmostTrustedCount ¶

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

RightmostTrustedCount derives the client IP from the valid IP address added by the first trusted reverse proxy to the X-Forwarded-For or Forwarded header. This resolver should be used when there is a fixed number of trusted reverse proxies that are appending IP addresses to the header.

func NewRightmostTrustedCount(key HeaderKey, trustedCount uint) (RightmostTrustedCount, error)

func (s RightmostTrustedCount) ClientIP(c fox.RequestContext) (*net.IPAddr, error)

type RightmostTrustedRange ¶

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

RightmostTrustedRange derives the client IP from the rightmost valid IP address in the X-Forwarded-For or Forwarded header which is not in a set of trusted IP ranges. This resolver should be used when the IP ranges of the reverse proxies between the internet and the server are known. If a third-party WAF, CDN, etc., is used, you SHOULD use a method of verifying its access to your origin that is stronger than checking its IP address (e.g., using authenticated pulls). Failure to do so can result in scenarios like: You use AWS CloudFront in front of a server you host elsewhere. An attacker creates a CF distribution that points at your origin server. The attacker uses Lambda@Edge to spoof the Host and X-Forwarded-For headers. Now your "trusted" reverse proxy is no longer trustworthy.

func NewRightmostTrustedRange(key HeaderKey, resolver TrustedIPRange) (RightmostTrustedRange, error)

func (s RightmostTrustedRange) ClientIP(c fox.RequestContext) (*net.IPAddr, error)

type SingleIPHeader ¶

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

SingleIPHeader derives an IP address from a single-IP header. A non-exhaustive list of such single-IP headers is: X-Real-IP, CF-Connecting-IP, True-Client-IP, Fastly-Client-IP, X-Azure-ClientIP, X-Azure-SocketIP. This resolver should be used when the given header is added by a trusted reverse proxy. You must ensure that this header is not spoofable (as is possible with Akamai's use of True-Client-IP, Fastly's default use of Fastly-Client-IP, and Azure's X-Azure-ClientIP).

func NewSingleIPHeader(headerName string) (SingleIPHeader, error)

func (s SingleIPHeader) ClientIP(c fox.RequestContext) (*net.IPAddr, error)

type TrustedIPRange ¶

type TrustedIPRange interface {
	TrustedIPRange() ([]net.IPNet, error)
}

TrustedIPRange returns a set of trusted IP ranges. Implementations of this interface must be thread-safe as it will be invoked whenever the client IP needs to be resolved, potentially from multiple goroutines.

type TrustedIPRangeFunc ¶

type TrustedIPRangeFunc func() ([]net.IPNet, error)

The TrustedIPRangeFunc type is an adapter to allow the use of ordinary functions as TrustedIPRange. If f is a function with the appropriate signature, TrustedIPRangeFunc() is a TrustedIPRange that calls f.

func (f TrustedIPRangeFunc) TrustedIPRange() ([]net.IPNet, error)

type TrustedRangeOption ¶

type TrustedRangeOption interface {
	// contains filtered or unexported methods
}

func TrustLinkLocal(enable bool) TrustedRangeOption

func TrustLoopback(enable bool) TrustedRangeOption

func TrustPrivateNet(enable bool) TrustedRangeOption