108 lines
3.1 KiB
Go
108 lines
3.1 KiB
Go
package iptables
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/evilsocket/opensnitch/daemon/core"
|
|
"github.com/evilsocket/opensnitch/daemon/log"
|
|
"github.com/vishvananda/netlink"
|
|
)
|
|
|
|
func (ipt *Iptables) getBypassQueue() string {
|
|
if !ipt.bypassQueue {
|
|
return ""
|
|
}
|
|
|
|
return "--queue-bypass"
|
|
}
|
|
|
|
// BuildQueueDNSRule returns the iptables rule arguments for queueing DNS responses.
|
|
func BuildQueueDNSRule(queueNum uint16, bypass bool) []string {
|
|
rule := []string{
|
|
"INPUT",
|
|
"--protocol", "udp",
|
|
"--sport", "53",
|
|
"-j", "NFQUEUE",
|
|
"--queue-num", fmt.Sprintf("%d", queueNum),
|
|
}
|
|
if bypass {
|
|
rule = append(rule, "--queue-bypass")
|
|
}
|
|
return rule
|
|
}
|
|
|
|
// BuildQueueConnectionsRule returns the iptables rule arguments for queueing connections.
|
|
func BuildQueueConnectionsRule(queueNum uint16, bypass bool) []string {
|
|
rule := []string{
|
|
"OUTPUT",
|
|
"-t", "mangle",
|
|
"-m", "conntrack",
|
|
"--ctstate", "NEW,RELATED",
|
|
"-j", "NFQUEUE",
|
|
"--queue-num", fmt.Sprintf("%d", queueNum),
|
|
}
|
|
if bypass {
|
|
rule = append(rule, "--queue-bypass")
|
|
}
|
|
return rule
|
|
}
|
|
|
|
// RunRule inserts or deletes a firewall rule.
|
|
func (ipt *Iptables) RunRule(action Action, enable bool, logError bool, rule []string) (err4, err6 error) {
|
|
if enable == false {
|
|
action = "-D"
|
|
}
|
|
|
|
// If the last argument of the rule is "", the iptables command fails.
|
|
// So if the user selects "QueueBypass: false", delete the last token of the rule,
|
|
// which will be "".
|
|
args := len(rule)
|
|
if rule[args-1] == "" {
|
|
rule = append(rule[:args-1], rule[args:]...)
|
|
}
|
|
rule = append([]string{string(action)}, rule...)
|
|
|
|
ipt.Lock()
|
|
defer ipt.Unlock()
|
|
|
|
if _, err4 = core.Exec(ipt.bin, rule); err4 != nil {
|
|
if logError {
|
|
log.Error("Error while running firewall rule, ipv4 err: %s", err4)
|
|
log.Error("rule: %s", rule)
|
|
}
|
|
}
|
|
|
|
// On some systems IPv6 is disabled
|
|
if core.IPv6Enabled {
|
|
if _, err6 = core.Exec(ipt.bin6, rule); err6 != nil {
|
|
if logError {
|
|
log.Error("Error while running firewall rule, ipv6 err: %s", err6)
|
|
log.Error("rule: %s", rule)
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// QueueDNSResponses redirects DNS responses to us, in order to keep a cache
|
|
// of resolved domains.
|
|
// INPUT --protocol udp --sport 53 -j NFQUEUE --queue-num 0 --queue-bypass
|
|
func (ipt *Iptables) QueueDNSResponses(enable bool, logError bool) (err4, err6 error) {
|
|
return ipt.RunRule(INSERT, enable, logError, BuildQueueDNSRule(ipt.QueueNum, ipt.bypassQueue))
|
|
}
|
|
|
|
// QueueConnections inserts the firewall rule which redirects connections to us.
|
|
// Connections are queued until the user denies/accept them, or reaches a timeout.
|
|
// OUTPUT -t mangle -m conntrack --ctstate NEW,RELATED -j NFQUEUE --queue-num 0 --queue-bypass
|
|
func (ipt *Iptables) QueueConnections(enable bool, logError bool) (error, error) {
|
|
err4, err6 := ipt.RunRule(ADD, enable, logError, BuildQueueConnectionsRule(ipt.QueueNum, ipt.bypassQueue))
|
|
if enable {
|
|
// flush conntrack as soon as netfilter rule is set. This ensures that already-established
|
|
// connections will go to netfilter queue.
|
|
if err := netlink.ConntrackTableFlush(netlink.ConntrackTable); err != nil {
|
|
log.Error("error in ConntrackTableFlush %s", err)
|
|
}
|
|
}
|
|
return err4, err6
|
|
}
|