package main

// The host firewall in more detail than "found / not found": which backend is in charge, its
// default inbound policy and the inbound ports its saved rules open, as far as its files tell.
// Best effort and read-only: ufw's user.rules (the "### tuple ###" lines ufw itself writes),
// firewalld's zone files, /etc/nftables.conf and iptables-save files. Rules added at run time (by
// Docker, for example) are not in these files; Docker-published ports bypass ufw.

import (
	"bufio"
	"bytes"
	"path/filepath"
	"regexp"
	"sort"
	"strconv"
	"strings"
)

type FWOut struct {
	Backend    string `json:"backend"` // ufw | firewalld | nftables | iptables | none | unknown
	Active     bool   `json:"active"`
	DefaultIn  string `json:"default_in"` // drop | reject | accept | unknown
	Rules      int    `json:"rules"`
	Allowed    []int  `json:"allowed"`    // inbound ports open to any address
	Limited    []int  `json:"limited"`    // ufw "limit": open, rate limited
	Restricted []int  `json:"restricted"` // allowed from some addresses only
	Denied     []int  `json:"denied"`
	AllPorts   bool   `json:"all_ports,omitempty"` // a rule accepts every port
}

type portSet map[int]bool

func (s portSet) list() []int {
	out := make([]int, 0, len(s))
	for p := range s {
		out = append(out, p)
	}
	sort.Ints(out)
	if len(out) > 100 {
		out = out[:100]
	}
	return out
}

// addPorts parses "22", "80,443", "8000:8010" / "8000-8010" (ranges of at most 64 ports listed in
// full, larger ones by their first port).
func (s portSet) addPorts(spec string) {
	for _, part := range strings.Split(spec, ",") {
		part = strings.TrimSpace(strings.Trim(part, "{} "))
		if part == "" {
			continue
		}
		sep := strings.IndexAny(part, ":-")
		if sep > 0 {
			a, e1 := strconv.Atoi(part[:sep])
			b, e2 := strconv.Atoi(part[sep+1:])
			if e1 == nil && e2 == nil && a > 0 && b >= a && b < 65536 {
				if b-a > 64 {
					b = a
				}
				for p := a; p <= b && len(s) < 1000; p++ {
					s[p] = true
				}
			}
			continue
		}
		if p, err := strconv.Atoi(part); err == nil && p > 0 && p < 65536 && len(s) < 1000 {
			s[p] = true
		}
	}
}

type fwAcc struct {
	allowed, limited, restricted, denied portSet
	rules                                int
	all                                  bool
}

func newFwAcc() *fwAcc {
	return &fwAcc{allowed: portSet{}, limited: portSet{}, restricted: portSet{}, denied: portSet{}}
}

func (a *fwAcc) out(backend string, active bool, def string) *FWOut {
	return &FWOut{Backend: backend, Active: active, DefaultIn: def, Rules: a.rules, Allowed: a.allowed.list(), Limited: a.limited.list(),
		Restricted: a.restricted.list(), Denied: a.denied.list(), AllPorts: a.all}
}

func anyAddr(src string) bool {
	return src == "" || src == "any" || src == "0.0.0.0/0" || src == "::/0" || src == "anywhere"
}

// ParseUFWRules reads ufw's user.rules / user6.rules: "### tuple ### allow tcp 22 0.0.0.0/0 any 0.0.0.0/0 in"
// (action proto dport dst sport src [dapp sapp] direction).
func ParseUFWRules(b []byte, a *fwAcc) {
	sc := bufio.NewScanner(bytes.NewReader(b))
	sc.Buffer(make([]byte, 64*1024), 1024*1024)
	for sc.Scan() {
		l := strings.TrimSpace(sc.Text())
		if !strings.HasPrefix(l, "### tuple ### ") {
			continue
		}
		f := strings.Fields(strings.TrimPrefix(l, "### tuple ### "))
		if len(f) < 7 || f[len(f)-1] != "in" || strings.HasPrefix(f[0], "route:") {
			continue
		}
		a.rules++
		action := strings.TrimSuffix(f[0], "_log-all")
		action = strings.TrimSuffix(action, "_log")
		dport, src := f[2], f[5]
		target := a.allowed
		switch action {
		case "allow":
			if !anyAddr(src) {
				target = a.restricted
			}
		case "limit":
			target = a.limited
			if !anyAddr(src) {
				target = a.restricted
			}
		case "deny", "reject":
			target = a.denied
		default:
			continue
		}
		if dport == "any" {
			if action == "allow" && anyAddr(src) {
				a.all = true
			}
			continue
		}
		target.addPorts(dport)
	}
}

var ufwDefaultRe = regexp.MustCompile(`(?m)^\s*DEFAULT_INPUT_POLICY\s*=\s*"?([A-Za-z-]+)"?`)

func policyWord(s string) string {
	switch strings.ToLower(strings.TrimSpace(s)) {
	case "drop", "deny":
		return "drop"
	case "reject":
		return "reject"
	case "accept", "allow":
		return "accept"
	}
	return "unknown"
}

// firewalld services: the ports of the predefined services most often enabled.
var firewalldServices = map[string]string{
	"ssh": "22", "http": "80", "https": "443", "http3": "443", "dns": "53", "smtp": "25", "smtps": "465", "smtp-submission": "587",
	"imap": "143", "imaps": "993", "pop3": "110", "pop3s": "995", "ftp": "21", "mysql": "3306", "postgresql": "5432", "redis": "6379",
	"mongodb": "27017", "elasticsearch": "9200", "cockpit": "9090", "prometheus": "9090", "grafana": "3000", "vnc-server": "5900-5903",
	"openvpn": "1194", "wireguard": "51820", "ldap": "389", "ldaps": "636", "nfs": "2049", "rpc-bind": "111", "samba": "139,445",
	"docker-registry": "5000", "jenkins": "8080", "zabbix-agent": "10050", "zabbix-server": "10051", "kubelet": "10250",
	"kube-apiserver": "6443", "ntp": "123", "dhcpv6-client": "546", "mdns": "5353", "samba-client": "137,138",
}

var (
	xmlServiceRe = regexp.MustCompile(`<service\s+name="([^"]+)"`)
	xmlPortRe    = regexp.MustCompile(`<port\s+[^>]*port="([^"]+)"`)
	xmlTargetRe  = regexp.MustCompile(`<zone[^>]*target="([^"]+)"`)
	xmlSourceRe  = regexp.MustCompile(`<source\s+address=`)
	fwdZoneRe    = regexp.MustCompile(`(?m)^\s*DefaultZone\s*=\s*(\S+)`)
)

// ParseFirewalldZone reads one zone file: its services and ports are open to the zone's sources
// (every address for the default zone without <source>).
func ParseFirewalldZone(b []byte, a *fwAcc) string {
	s := string(b)
	target := a.allowed
	if xmlSourceRe.MatchString(s) {
		target = a.restricted
	}
	for _, m := range xmlServiceRe.FindAllStringSubmatch(s, 100) {
		a.rules++
		if p, ok := firewalldServices[m[1]]; ok {
			target.addPorts(p)
		}
	}
	for _, m := range xmlPortRe.FindAllStringSubmatch(s, 100) {
		a.rules++
		target.addPorts(m[1])
	}
	if m := xmlTargetRe.FindStringSubmatch(s); m != nil {
		switch strings.ToUpper(m[1]) {
		case "ACCEPT":
			return "accept"
		case "DROP":
			return "drop"
		case "%%REJECT%%", "REJECT":
			return "reject"
		}
	}
	return "reject" // firewalld's default target rejects what the zone does not allow
}

var (
	nftChainRe  = regexp.MustCompile(`(?s)chain\s+(\S+)\s*\{(.*?)\n\s*\}`)
	nftPolicyRe = regexp.MustCompile(`policy\s+(accept|drop|reject)`)
	nftDportRe  = regexp.MustCompile(`(tcp|udp|th)\s+dport\s+(\{[^}]*\}|\S+)`)
)

// ParseNftables reads the input chain(s) of an nftables ruleset file: the policy and the ports
// of rules that accept ("ip saddr …" makes a rule restricted).
func ParseNftables(b []byte, a *fwAcc) string {
	policy := "unknown"
	found := false
	for _, m := range nftChainRe.FindAllStringSubmatch(string(b), 50) {
		body := m[2]
		if !strings.Contains(body, "hook input") {
			continue
		}
		found = true
		if p := nftPolicyRe.FindStringSubmatch(body); p != nil {
			policy = p[1]
		} else if policy == "unknown" {
			policy = "accept"
		}
		for _, l := range strings.Split(body, "\n") {
			l = strings.TrimSpace(l)
			if l == "" || l[0] == '#' {
				continue
			}
			if strings.Contains(l, "dport") {
				a.rules++
			}
			dm := nftDportRe.FindStringSubmatch(l)
			if dm == nil {
				continue
			}
			ports := strings.Trim(dm[2], "{}")
			switch {
			case strings.HasSuffix(l, "accept") || strings.Contains(l, " accept"):
				if strings.Contains(l, "saddr") {
					a.restricted.addPorts(ports)
				} else {
					a.allowed.addPorts(ports)
				}
			case strings.Contains(l, " drop") || strings.Contains(l, " reject"):
				a.denied.addPorts(ports)
			}
		}
	}
	if !found {
		return "unknown"
	}
	return policyWord(policy)
}

var iptPolicyRe = regexp.MustCompile(`(?m)^:INPUT\s+(ACCEPT|DROP|REJECT)`)

// ParseIptablesSave reads an iptables-save file (/etc/iptables/rules.v4, /etc/sysconfig/iptables).
func ParseIptablesSave(b []byte, a *fwAcc) string {
	policy := "unknown"
	if m := iptPolicyRe.FindSubmatch(b); m != nil {
		policy = policyWord(string(m[1]))
	}
	for _, l := range strings.Split(string(b), "\n") {
		if !strings.HasPrefix(l, "-A INPUT") {
			continue
		}
		a.rules++
		f := strings.Fields(l)
		var ports, src, jump string
		for i := 0; i+1 < len(f); i++ {
			switch f[i] {
			case "--dport", "--dports", "--destination-port":
				ports = f[i+1]
			case "-s", "--source":
				src = f[i+1]
			case "-j", "--jump":
				jump = f[i+1]
			}
		}
		if ports == "" {
			continue
		}
		switch jump {
		case "ACCEPT":
			if anyAddr(src) {
				a.allowed.addPorts(ports)
			} else {
				a.restricted.addPorts(ports)
			}
		case "DROP", "REJECT":
			a.denied.addPorts(ports)
		}
	}
	return policy
}

// ReadFirewallDetail: the backend in charge (the first found of ufw, firewalld, nftables,
// iptables-persistent), with what its files say.
func ReadFirewallDetail(root string, units map[string]UnitInfo, procNames map[string]bool, found FirewallOut) *FWOut {
	j := func(p string) string { return filepath.Join(root, p) }
	has := func(n string) bool {
		for _, f := range found.Found {
			if f == n {
				return true
			}
		}
		return false
	}
	switch {
	case has("ufw"):
		a := newFwAcc()
		for _, f := range []string{"etc/ufw/user.rules", "etc/ufw/user6.rules", "lib/ufw/user.rules", "lib/ufw/user6.rules"} {
			if b, err := readSmall(j(f), 1<<20); err == nil {
				ParseUFWRules(b, a)
			}
		}
		def := "unknown"
		if b, err := readSmall(j("etc/default/ufw"), 64*1024); err == nil {
			if m := ufwDefaultRe.FindSubmatch(b); m != nil {
				def = policyWord(string(m[1]))
			}
		}
		return a.out("ufw", true, def)
	case has("firewalld"):
		a := newFwAcc()
		zone := "public"
		if b, err := readSmall(j("etc/firewalld/firewalld.conf"), 64*1024); err == nil {
			if m := fwdZoneRe.FindSubmatch(b); m != nil {
				zone = string(m[1])
			}
		}
		def := "reject"
		for _, f := range []string{"etc/firewalld/zones/" + zone + ".xml", "usr/lib/firewalld/zones/" + zone + ".xml"} {
			if b, err := readSmall(j(f), 1<<20); err == nil {
				def = ParseFirewalldZone(b, a)
				break
			}
		}
		return a.out("firewalld", true, def)
	case has("nftables"):
		a := newFwAcc()
		def := "unknown"
		for _, f := range []string{"etc/nftables.conf", "etc/sysconfig/nftables.conf"} {
			if b, err := readSmall(j(f), 1<<20); err == nil {
				def = ParseNftables(b, a)
				break
			}
		}
		return a.out("nftables", true, def)
	case has("iptables"):
		a := newFwAcc()
		def := "unknown"
		for _, f := range []string{"etc/iptables/rules.v4", "etc/sysconfig/iptables"} {
			if b, err := readSmall(j(f), 1<<20); err == nil {
				def = ParseIptablesSave(b, a)
				break
			}
		}
		return a.out("iptables", true, def)
	case len(found.Found) > 0:
		return &FWOut{Backend: found.Found[0], Active: true, DefaultIn: "unknown", Allowed: []int{}, Limited: []int{}, Restricted: []int{}, Denied: []int{}}
	case found.Known:
		return &FWOut{Backend: "none", DefaultIn: "accept", Allowed: []int{}, Limited: []int{}, Restricted: []int{}, Denied: []int{}}
	}
	return &FWOut{Backend: "unknown", DefaultIn: "unknown", Allowed: []int{}, Limited: []int{}, Restricted: []int{}, Denied: []int{}}
}
