opensnitch/daemon/firewall/iptables/system.go
2023-01-30 13:43:44 +01:00

155 lines
4.8 KiB
Go

package iptables
import (
"strings"
"github.com/evilsocket/opensnitch/daemon/firewall/common"
"github.com/evilsocket/opensnitch/daemon/firewall/config"
)
// CreateSystemRule creates the custom firewall chains and adds them to the system.
func (ipt *Iptables) CreateSystemRule(rule *config.FwRule, table, chain, hook string, logErrors bool) bool {
ipt.chains.Lock()
defer ipt.chains.Unlock()
if rule == nil {
return false
}
if table == "" {
table = "filter"
}
if hook == "" {
hook = rule.Chain
}
chainName := SystemRulePrefix + "-" + hook
if _, ok := ipt.chains.Rules[table+"-"+chainName]; ok {
return false
}
ipt.RunRule(NEWCHAIN, common.EnableRule, logErrors, []string{chainName, "-t", table})
// Insert the rule at the top of the chain
if err4, err6 := ipt.RunRule(INSERT, common.EnableRule, logErrors, []string{hook, "-t", table, "-j", chainName}); err4 == nil && err6 == nil {
ipt.chains.Rules[table+"-"+chainName] = &SystemRule{
Table: table,
Chain: chain,
Rule: rule,
}
}
return true
}
// AddSystemRules creates the system firewall from configuration.
func (ipt *Iptables) AddSystemRules(reload, backupExistingChains bool) {
// Version 0 has no Enabled field, so it'd be always false
if ipt.SysConfig.Enabled == false && ipt.SysConfig.Version > 0 {
return
}
for _, cfg := range ipt.SysConfig.SystemRules {
if cfg.Rule != nil {
ipt.CreateSystemRule(cfg.Rule, cfg.Rule.Table, cfg.Rule.Chain, cfg.Rule.Chain, common.EnableRule)
ipt.AddSystemRule(ADD, cfg.Rule, cfg.Rule.Table, cfg.Rule.Chain, common.EnableRule)
continue
}
if cfg.Chains != nil {
for _, chn := range cfg.Chains {
if chn.Hook != "" && chn.Type != "" {
ipt.ConfigureChainPolicy(chn.Type, chn.Hook, chn.Policy, true)
}
}
}
}
}
// DeleteSystemRules deletes the system rules.
// If force is false and the rule has not been previously added,
// it won't try to delete the rules. Otherwise it'll try to delete them.
func (ipt *Iptables) DeleteSystemRules(force, backupExistingChains, logErrors bool) {
ipt.chains.Lock()
defer ipt.chains.Unlock()
for _, fwCfg := range ipt.SysConfig.SystemRules {
if fwCfg.Rule == nil {
continue
}
chain := SystemRulePrefix + "-" + fwCfg.Rule.Chain
if _, ok := ipt.chains.Rules[fwCfg.Rule.Table+"-"+chain]; !ok && !force {
continue
}
ipt.RunRule(FLUSH, common.EnableRule, false, []string{chain, "-t", fwCfg.Rule.Table})
ipt.RunRule(DELETE, !common.EnableRule, logErrors, []string{fwCfg.Rule.Chain, "-t", fwCfg.Rule.Table, "-j", chain})
ipt.RunRule(DELCHAIN, common.EnableRule, false, []string{chain, "-t", fwCfg.Rule.Table})
delete(ipt.chains.Rules, fwCfg.Rule.Table+"-"+chain)
for _, chn := range fwCfg.Chains {
if chn.Table == "" {
chn.Table = "filter"
}
chain := SystemRulePrefix + "-" + chn.Hook
if _, ok := ipt.chains.Rules[chn.Type+"-"+chain]; !ok && !force {
continue
}
ipt.RunRule(FLUSH, common.EnableRule, logErrors, []string{chain, "-t", chn.Type})
ipt.RunRule(DELETE, !common.EnableRule, logErrors, []string{chn.Hook, "-t", chn.Type, "-j", chain})
ipt.RunRule(DELCHAIN, common.EnableRule, logErrors, []string{chain, "-t", chn.Type})
delete(ipt.chains.Rules, chn.Type+"-"+chain)
}
}
}
// DeleteSystemRule deletes a new rule.
func (ipt *Iptables) DeleteSystemRule(action Action, rule *config.FwRule, table, chain string, enable bool) (err4, err6 error) {
chainName := SystemRulePrefix + "-" + chain
if table == "" {
table = "filter"
}
r := []string{chainName, "-t", table}
if rule.Parameters != "" {
r = append(r, strings.Split(rule.Parameters, " ")...)
}
r = append(r, []string{"-j", rule.Target}...)
if rule.TargetParameters != "" {
r = append(r, strings.Split(rule.TargetParameters, " ")...)
}
return ipt.RunRule(action, enable, true, r)
}
// AddSystemRule inserts a new rule.
func (ipt *Iptables) AddSystemRule(action Action, rule *config.FwRule, table, chain string, enable bool) (err4, err6 error) {
if rule == nil {
return nil, nil
}
ipt.RLock()
defer ipt.RUnlock()
chainName := SystemRulePrefix + "-" + chain
if table == "" {
table = "filter"
}
r := []string{chainName, "-t", table}
if rule.Parameters != "" {
r = append(r, strings.Split(rule.Parameters, " ")...)
}
r = append(r, []string{"-j", rule.Target}...)
if rule.TargetParameters != "" {
r = append(r, strings.Split(rule.TargetParameters, " ")...)
}
return ipt.RunRule(ADD, enable, true, r)
}
// ConfigureChainPolicy configures chains policy.
func (ipt *Iptables) ConfigureChainPolicy(table, hook, policy string, logError bool) {
// TODO: list all policies before modify them, and restore the original state on exit.
// still, if we exit abruptly, we might left the system badly configured.
ipt.RunRule(POLICY, true, logError, []string{
hook,
strings.ToUpper(policy),
"-t", table,
})
}