gorules

README

gorules

golang rules filter

based on flora-kit

Code Example

package main

import (
	"fmt"
	"github.com/koomox/goproxy/tunnel"
	"github.com/koomox/gorules"
)

var (
	config = []byte(`
[General]
loglevel = notify
replica = false
skip-Proxy = 127.0.0.1, 192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12, 100.64.0.0/10, localhost, *.local

[Rule]
DOMAIN-KEYWORD,google,PROXY
DOMAIN-KEYWORD,facebook,PROXY
DOMAIN-KEYWORD,youtube,PROXY
DOMAIN-KEYWORD,twitter,PROXY
DOMAIN-SUFFIX,baidu.com,DIRECT
DOMAIN-SUFFIX,google.com,PROXY
DOMAIN-SUFFIX,google.co.jp,PROXY
IP-CIDR,91.108.4.0/22,PROXY
GEOIP,CN,DIRECT
FINAL,DIRECT
`)
	extensions = []byte(`
DOMAIN,scholar.google.com,US
DOMAIN-SUFFIX,.cn,DIRECT
DOMAIN-SUFFIX,.us,PROXY
DOMAIN-SUFFIX,.ca,PROXY
DOMAIN-SUFFIX,netflix.com,NETFLIX
DOMAIN-SUFFIX,nflxext.com,NETFLIX
DOMAIN-SUFFIX,nflxso.net,NETFLIX
DOMAIN-SUFFIX,nflxvideo.net,NETFLIX
DOMAIN-SUFFIX,nflximg.net,NETFLIX
DST-PORT,20,FTP
DST-PORT,21,FTP
DST-PORT,53,DNS
DST-PORT,123,NTP
DST-PORT,80,HTTP
DST-PORT,443,HTTPS
`)
)

func MatchRule(host string, rules gorules.Match) {
	addr, _ := tunnel.FromAddr("tcp", host+":443")
	r := rules.MatchRule(addr)
	fmt.Println(host, r.String(), r.Adapter())
}

func main() {
	rules := gorules.New(config)
	rules.FromHosts()
	// if err := rules.FromGeoIP("GeoLite2-Country.mmdb"); err != nil {
	// 	fmt.Println(err.Error())
	// 	return
	// }

	rules.FromPort("80", "443")
	rules.FromFinal(gorules.ActionDirect)
	rules.FromExtensions(extensions)

	fmt.Println(rules.MatchBypass("localhost"))
	MatchRule("google.com", rules)
	MatchRule("scholar.google.com", rules)
	MatchRule("github.com", rules)
	MatchRule("china.com.cn", rules)
	MatchRule("netflix.com", rules)
	MatchRule("pinterest.ca", rules)

	rules.SetHosts("0.0.0.0", "activate.adobe.com")
	fmt.Println(rules.MatchHosts("activate.adobe.com"))
	fmt.Println(rules.MatchPort("443"))
}

License

GPL v3.0

Documentation

Index

• Constants
• func FromGeoIP(name string) (db *geoip2.Reader, err error)
• func RuleType(rt byte) string
• type Filter
  • func New(rules []byte) (element *Filter)
  • func (c *Filter) AddGeoIP(match, adapter string)
  • func (c *Filter) AddHosts(addr, host string)
  • func (c *Filter) FromExtensions(b []byte)
  • func (c *Filter) FromFinal(adapter string)
  • func (c *Filter) FromGeoIP(name string) (err error)
  • func (c *Filter) FromHosts()
  • func (c *Filter) FromPort(elements ...string)
  • func (c *Filter) FromRules(b []byte)
  • func (c *Filter) GeoIP(ip net.IP) string
  • func (c *Filter) GeoIPString(ipaddr string) string
  • func (c *Filter) GeoIPs(ips []net.IP) string
  • func (c *Filter) MatchBypass(addr string) bool
  • func (c *Filter) MatchHosts(host string) string
  • func (c *Filter) MatchPort(port string) bool
  • func (c *Filter) MatchRule(m Metadata) Rules
  • func (c *Filter) SetGeoIP(match, adapter string)
  • func (c *Filter) SetHosts(addr, host string)
• type Match
• type Metadata
• type Rule
  • func (r *Rule) Adapter() string
  • func (r *Rule) RuleType() byte
  • func (r *Rule) String() string
• type RuleHost
  • func FromHosts() (hosts []*RuleHost)
• type RuleIPCIDR
• type Rules

Constants

const (
	AddrTypeIPv4       byte = 0x01
	AddrTypeDomainName byte = 0x03
	AddrTypeIPv6       byte = 0x04

	ActionAccept = "ACCEPT"
	ActionProxy  = "PROXY"
	ActionReject = "REJECT"
	ActionDirect = "DIRECT"

	RuleTypeBypass         byte = 0x01
	RuleTypeHosts          byte = 0x02
	RuleTypeDomains        byte = 0x03
	RuleTypeSuffixDomains  byte = 0x04
	RuleTypeKeywordDomains byte = 0x05
	RuleTypeUserAgent      byte = 0x06
	RuleTypeIPCIDR         byte = 0x07
	RuleTypeGeoIP          byte = 0x08
	RuleTypePort           byte = 0x09
	RuleTypeFinal          byte = 0x0A
	RuleTypeMATCH          byte = 0x0B
)

Functions

func FromGeoIP

func FromGeoIP(name string) (db *geoip2.Reader, err error)

func RuleType

func RuleType(rt byte) string

Types

type Filter

type Filter struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

func New

func New(rules []byte) (element *Filter)

func (*Filter) AddGeoIP

func (c *Filter) AddGeoIP(match, adapter string)

func (*Filter) AddHosts

func (c *Filter) AddHosts(addr, host string)

func (*Filter) FromExtensions

func (c *Filter) FromExtensions(b []byte)

func (*Filter) FromFinal

func (c *Filter) FromFinal(adapter string)

func (*Filter) FromGeoIP

func (c *Filter) FromGeoIP(name string) (err error)

func (*Filter) FromHosts

func (c *Filter) FromHosts()

func (*Filter) FromPort

func (c *Filter) FromPort(elements ...string)

func (*Filter) FromRules

func (c *Filter) FromRules(b []byte)

func (*Filter) GeoIP

func (c *Filter) GeoIP(ip net.IP) string

Return Country code

func (*Filter) GeoIPString

func (c *Filter) GeoIPString(ipaddr string) string

func (*Filter) GeoIPs

func (c *Filter) GeoIPs(ips []net.IP) string

func (*Filter) MatchBypass

func (c *Filter) MatchBypass(addr string) bool

func (*Filter) MatchHosts

func (c *Filter) MatchHosts(host string) string

func (*Filter) MatchPort

func (c *Filter) MatchPort(port string) bool

func (*Filter) MatchRule

func (c *Filter) MatchRule(m Metadata) Rules

func (*Filter) SetGeoIP

func (c *Filter) SetGeoIP(match, adapter string)

func (*Filter) SetHosts

func (c *Filter) SetHosts(addr, host string)

type Match

type Match interface {
	MatchBypass(string) bool
	MatchHosts(string) string
	MatchPort(string) bool
	MatchRule(Metadata) Rules
}

type Metadata

type Metadata interface {
	AddrType() byte
	Port() string
	Host() string
	String() string
}

type Rule

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

func (*Rule) Adapter

func (r *Rule) Adapter() string

func (*Rule) RuleType

func (r *Rule) RuleType() byte

func (*Rule) String

func (r *Rule) String() string

type RuleHost

type RuleHost struct {
	Addr string
	Host string
}

func FromHosts

func FromHosts() (hosts []*RuleHost)

type RuleIPCIDR

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

type Rules

type Rules interface {
	RuleType() byte
	Adapter() string
	String() string
}