You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
985 lines
34 KiB
Go
985 lines
34 KiB
Go
//go:build linux
|
|
|
|
package vpcrouting
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
// Keep every reserved name within the 17-character limit enforced by
|
|
// firewalld 2.3.x while retaining an unambiguous project namespace.
|
|
firewalldGuestZone = "virt-vpc-guest"
|
|
firewalldTransportZone = "virt-vpc-transit"
|
|
firewalldGuestToTransportPolicy = "virt-vpc-out"
|
|
firewalldTransportToGuestPolicy = "virt-vpc-in"
|
|
firewalldExpectedZoneTarget = "default"
|
|
firewalldExpectedPolicyTarget = "ACCEPT"
|
|
)
|
|
|
|
type firewalldScope struct {
|
|
permanent bool
|
|
}
|
|
|
|
type firewalldPlan struct {
|
|
active bool
|
|
}
|
|
|
|
type firewalldZoneState struct {
|
|
target string
|
|
forward bool
|
|
interfaces map[string]struct{}
|
|
sources map[string]struct{}
|
|
services map[string]struct{}
|
|
ports map[string]struct{}
|
|
protocols map[string]struct{}
|
|
forwardPorts map[string]struct{}
|
|
sourcePorts map[string]struct{}
|
|
icmpBlocks map[string]struct{}
|
|
richRules string
|
|
masquerade bool
|
|
icmpBlockInversion bool
|
|
}
|
|
|
|
type firewalldPolicyState struct {
|
|
target string
|
|
ingress map[string]struct{}
|
|
egress map[string]struct{}
|
|
services map[string]struct{}
|
|
ports map[string]struct{}
|
|
protocols map[string]struct{}
|
|
forwardPorts map[string]struct{}
|
|
sourcePorts map[string]struct{}
|
|
icmpBlocks map[string]struct{}
|
|
richRules string
|
|
masquerade bool
|
|
}
|
|
|
|
func (scope firewalldScope) arguments(arguments ...string) []string {
|
|
if !scope.permanent {
|
|
return arguments
|
|
}
|
|
return append([]string{"--permanent"}, arguments...)
|
|
}
|
|
|
|
func (scope firewalldScope) name() string {
|
|
if scope.permanent {
|
|
return "permanent"
|
|
}
|
|
return "runtime"
|
|
}
|
|
|
|
// reconcileFirewalld gives firewalld an explicit forwarding path for the
|
|
// interfaces already admitted by the exact nftables tenant boundary. It does
|
|
// not implement a user ACL: every declared member of one VPC remains mutually
|
|
// reachable, while the zone targets still prevent either interface class from
|
|
// becoming a host-input trust boundary.
|
|
func (d *linuxDriver) reconcileFirewalld(ctx context.Context, before, after map[string]Network) error {
|
|
plan, err := d.prepareFirewalld(ctx, before, after)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return d.applyFirewalld(ctx, plan, before, after)
|
|
}
|
|
|
|
func (d *linuxDriver) firewalldReadiness(ctx context.Context, current map[string]Network) error {
|
|
active, err := d.firewalldActive(ctx)
|
|
if err != nil || !active {
|
|
return err
|
|
}
|
|
desiredGuest, desiredTransport := firewalldInterfaces(current)
|
|
for _, scope := range []firewalldScope{{permanent: true}, {permanent: false}} {
|
|
err := d.firewalldReadinessScope(
|
|
ctx, scope, desiredGuest, desiredTransport, len(current) != 0,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// firewalldReadinessScope inspects each reserved object once. Capability
|
|
// reporting used to run the general mutation preflight, a complete definition
|
|
// check, and a final interface check in sequence. On real hosts that meant more
|
|
// than fifty firewall-cmd subprocesses under one five-second deadline, so a
|
|
// healthy committed projection could be reported unavailable. Keep the same
|
|
// fail-closed checks while projecting one immutable snapshot per scope.
|
|
func (d *linuxDriver) firewalldReadinessScope(
|
|
ctx context.Context,
|
|
scope firewalldScope,
|
|
desiredGuest, desiredTransport map[string]struct{},
|
|
requireComplete bool,
|
|
) error {
|
|
zones, err := d.firewalldNames(ctx, scope, "--get-zones")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
policies, err := d.firewalldNames(ctx, scope, "--get-policies")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for _, zone := range []struct {
|
|
name string
|
|
forward bool
|
|
interfaces map[string]struct{}
|
|
}{
|
|
{name: firewalldGuestZone, forward: true, interfaces: desiredGuest},
|
|
{name: firewalldTransportZone, interfaces: desiredTransport},
|
|
} {
|
|
if _, exists := zones[zone.name]; !exists {
|
|
if requireComplete {
|
|
return unavailable("vpc_firewalld_apply_unconfirmed", "committed firewalld VPC definitions are incomplete", nil)
|
|
}
|
|
continue
|
|
}
|
|
state, err := d.inspectFirewalldZone(ctx, scope, zone.name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := validateFirewalldZoneState(scope, zone.name, zone.forward, state); err != nil {
|
|
return err
|
|
}
|
|
for name := range state.interfaces {
|
|
if _, owned := zone.interfaces[name]; !owned {
|
|
return firewalldConflict(scope, "zone "+zone.name+" contains an unmanaged interface")
|
|
}
|
|
}
|
|
for _, name := range sortedStringSet(zone.interfaces) {
|
|
bound, err := d.firewalldInterfaceZone(ctx, scope, name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if bound != "" && bound != zone.name {
|
|
return firewalldConflict(scope, "interface "+name+" is already bound to zone "+bound)
|
|
}
|
|
}
|
|
if requireComplete && (state.forward != zone.forward || !equalStringSets(state.interfaces, zone.interfaces)) {
|
|
return unavailable("vpc_firewalld_apply_unconfirmed", "committed firewalld VPC interface ownership is incomplete", nil)
|
|
}
|
|
}
|
|
|
|
for _, policy := range []struct {
|
|
name string
|
|
ingress string
|
|
egress string
|
|
}{
|
|
{name: firewalldGuestToTransportPolicy, ingress: firewalldGuestZone, egress: firewalldTransportZone},
|
|
{name: firewalldTransportToGuestPolicy, ingress: firewalldTransportZone, egress: firewalldGuestZone},
|
|
} {
|
|
if _, exists := policies[policy.name]; !exists {
|
|
if requireComplete {
|
|
return unavailable("vpc_firewalld_apply_unconfirmed", "committed firewalld VPC definitions are incomplete", nil)
|
|
}
|
|
continue
|
|
}
|
|
state, err := d.inspectFirewalldPolicy(ctx, scope, policy.name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := validateFirewalldPolicyState(scope, policy.name, policy.ingress, policy.egress, state); err != nil {
|
|
return err
|
|
}
|
|
if requireComplete && (!containsExactStrings(state.ingress, policy.ingress) || !containsExactStrings(state.egress, policy.egress)) {
|
|
return unavailable("vpc_firewalld_apply_unconfirmed", "committed firewalld VPC definitions are incomplete", nil)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// prepareFirewalld runs before any bridge, route or nftables mutation. A
|
|
// foreign interface assignment or reserved-object conflict therefore fails
|
|
// the complete VPC reconcile without leaving an uncommitted host projection.
|
|
func (d *linuxDriver) prepareFirewalld(ctx context.Context, before, after map[string]Network) (firewalldPlan, error) {
|
|
active, err := d.firewalldActive(ctx)
|
|
if err != nil || !active {
|
|
return firewalldPlan{}, err
|
|
}
|
|
if len(before) == 0 && len(after) == 0 {
|
|
return firewalldPlan{}, nil
|
|
}
|
|
if err := d.preflightFirewalld(ctx, before, after); err != nil {
|
|
return firewalldPlan{}, err
|
|
}
|
|
return firewalldPlan{active: true}, nil
|
|
}
|
|
|
|
func (d *linuxDriver) applyFirewalld(ctx context.Context, plan firewalldPlan, before, after map[string]Network) error {
|
|
if !plan.active {
|
|
return nil
|
|
}
|
|
|
|
// firewalld permits creating custom zones only in permanent configuration.
|
|
// Install the definitions without adding new interface ownership. If the
|
|
// runtime objects are incomplete, all managed bindings are removed before
|
|
// reload; the exact nftables table is then restored before any interface is
|
|
// rebound. A reload can therefore interrupt VPC traffic, but can never
|
|
// expose an unvalidated forwarding path.
|
|
permanent := firewalldScope{permanent: true}
|
|
if err := d.ensureFirewalldDefinitions(ctx, permanent); err != nil {
|
|
return err
|
|
}
|
|
|
|
desiredGuest, desiredTransport := firewalldInterfaces(after)
|
|
managedGuest, managedTransport := firewalldInterfaces(mergeNetworkMaps(before, after))
|
|
|
|
complete, err := d.firewalldDefinitionsComplete(ctx, firewalldScope{})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !complete {
|
|
if err := d.clearManagedFirewalldInterfaces(ctx, firewalldScope{}, managedGuest, managedTransport); err != nil {
|
|
return err
|
|
}
|
|
if err := d.clearManagedFirewalldInterfaces(ctx, permanent, managedGuest, managedTransport); err != nil {
|
|
return err
|
|
}
|
|
// A standard reload is required only for first installation (or if an
|
|
// operator removed part of a runtime object). Subsequent reconciles are
|
|
// purely incremental and do not disturb unrelated runtime state.
|
|
if err := d.firewalldMutation(ctx, firewalldScope{}, "--reload"); err != nil {
|
|
return err
|
|
}
|
|
if err := d.confirmFirewalldDefinitions(ctx, firewalldScope{}); err != nil {
|
|
return err
|
|
}
|
|
// Some firewalld backends flush non-firewalld nftables state during a
|
|
// reload. Restore and confirm our exact tenant boundary before rebinding.
|
|
if err := d.reconcileFirewall(ctx, after); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
runtime := firewalldScope{}
|
|
if err := d.confirmFirewalldDefinitions(ctx, runtime); err != nil {
|
|
return err
|
|
}
|
|
if err := d.reconcileFirewalldInterfaces(ctx, permanent, firewalldTransportZone, desiredTransport, managedTransport); err != nil {
|
|
return err
|
|
}
|
|
if err := d.reconcileFirewalldInterfaces(ctx, permanent, firewalldGuestZone, desiredGuest, managedGuest); err != nil {
|
|
return err
|
|
}
|
|
if err := d.reconcileFirewalldInterfaces(ctx, runtime, firewalldTransportZone, desiredTransport, managedTransport); err != nil {
|
|
return err
|
|
}
|
|
if err := d.reconcileFirewalldInterfaces(ctx, runtime, firewalldGuestZone, desiredGuest, managedGuest); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// restrictFirewalld removes paths that are no longer desired before the
|
|
// authoritative nftables projection is reduced. It never creates definitions
|
|
// or adds bindings, so additions remain fail-closed until applyFirewalld.
|
|
func (d *linuxDriver) restrictFirewalld(ctx context.Context, plan firewalldPlan, before, after map[string]Network) error {
|
|
if !plan.active {
|
|
return nil
|
|
}
|
|
desiredGuest, desiredTransport := firewalldInterfaces(after)
|
|
managedGuest, managedTransport := firewalldInterfaces(mergeNetworkMaps(before, after))
|
|
for _, scope := range []firewalldScope{{}, {permanent: true}} {
|
|
if err := d.removeUndesiredFirewalldInterfaces(ctx, scope, firewalldTransportZone, desiredTransport, managedTransport); err != nil {
|
|
return err
|
|
}
|
|
if err := d.removeUndesiredFirewalldInterfaces(ctx, scope, firewalldGuestZone, desiredGuest, managedGuest); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d *linuxDriver) ensureFirewalldDefinitions(ctx context.Context, scope firewalldScope) error {
|
|
if err := d.ensureFirewalldZone(ctx, scope, firewalldGuestZone, true); err != nil {
|
|
return err
|
|
}
|
|
if err := d.ensureFirewalldZone(ctx, scope, firewalldTransportZone, false); err != nil {
|
|
return err
|
|
}
|
|
if err := d.ensureFirewalldPolicy(ctx, scope, firewalldGuestToTransportPolicy, firewalldGuestZone, firewalldTransportZone); err != nil {
|
|
return err
|
|
}
|
|
return d.ensureFirewalldPolicy(ctx, scope, firewalldTransportToGuestPolicy, firewalldTransportZone, firewalldGuestZone)
|
|
}
|
|
|
|
func (d *linuxDriver) firewalldDefinitionsComplete(ctx context.Context, scope firewalldScope) (bool, error) {
|
|
zones, err := d.firewalldNames(ctx, scope, "--get-zones")
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
policies, err := d.firewalldNames(ctx, scope, "--get-policies")
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
for _, name := range []string{firewalldGuestZone, firewalldTransportZone} {
|
|
if _, exists := zones[name]; !exists {
|
|
return false, nil
|
|
}
|
|
}
|
|
for _, name := range []string{firewalldGuestToTransportPolicy, firewalldTransportToGuestPolicy} {
|
|
if _, exists := policies[name]; !exists {
|
|
return false, nil
|
|
}
|
|
}
|
|
for _, zone := range []struct {
|
|
name string
|
|
forward bool
|
|
}{
|
|
{name: firewalldGuestZone, forward: true},
|
|
{name: firewalldTransportZone},
|
|
} {
|
|
complete, err := d.firewalldZoneComplete(ctx, scope, zone.name, zone.forward)
|
|
if err != nil || !complete {
|
|
return false, err
|
|
}
|
|
}
|
|
for _, policy := range []struct {
|
|
name string
|
|
ingress string
|
|
egress string
|
|
}{
|
|
{name: firewalldGuestToTransportPolicy, ingress: firewalldGuestZone, egress: firewalldTransportZone},
|
|
{name: firewalldTransportToGuestPolicy, ingress: firewalldTransportZone, egress: firewalldGuestZone},
|
|
} {
|
|
complete, err := d.firewalldPolicyComplete(ctx, scope, policy.name, policy.ingress, policy.egress)
|
|
if err != nil || !complete {
|
|
return false, err
|
|
}
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func (d *linuxDriver) confirmFirewalldDefinitions(ctx context.Context, scope firewalldScope) error {
|
|
complete, err := d.firewalldDefinitionsComplete(ctx, scope)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !complete {
|
|
return unavailable("vpc_firewalld_apply_unconfirmed", "firewalld VPC definitions could not be confirmed after reload", nil)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d *linuxDriver) preflightFirewalld(ctx context.Context, before, after map[string]Network) error {
|
|
desiredGuest, desiredTransport := firewalldInterfaces(after)
|
|
managedGuest, managedTransport := firewalldInterfaces(mergeNetworkMaps(before, after))
|
|
for _, scope := range []firewalldScope{{permanent: true}, {permanent: false}} {
|
|
zones, err := d.firewalldNames(ctx, scope, "--get-zones")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
policies, err := d.firewalldNames(ctx, scope, "--get-policies")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, zone := range []struct {
|
|
name string
|
|
forward bool
|
|
desired map[string]struct{}
|
|
managed map[string]struct{}
|
|
}{
|
|
{name: firewalldGuestZone, forward: true, desired: desiredGuest, managed: managedGuest},
|
|
{name: firewalldTransportZone, desired: desiredTransport, managed: managedTransport},
|
|
} {
|
|
if _, exists := zones[zone.name]; exists {
|
|
state, err := d.inspectFirewalldZone(ctx, scope, zone.name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := validateFirewalldZoneState(scope, zone.name, zone.forward, state); err != nil {
|
|
return err
|
|
}
|
|
for name := range state.interfaces {
|
|
if _, owned := zone.managed[name]; !owned {
|
|
return firewalldConflict(scope, "zone "+zone.name+" contains an unmanaged interface")
|
|
}
|
|
}
|
|
}
|
|
for _, name := range sortedStringSet(zone.desired) {
|
|
bound, err := d.firewalldInterfaceZone(ctx, scope, name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if bound != "" && bound != zone.name {
|
|
return firewalldConflict(scope, "interface "+name+" is already bound to zone "+bound)
|
|
}
|
|
}
|
|
}
|
|
for _, policy := range []struct {
|
|
name string
|
|
ingress string
|
|
egress string
|
|
}{
|
|
{name: firewalldGuestToTransportPolicy, ingress: firewalldGuestZone, egress: firewalldTransportZone},
|
|
{name: firewalldTransportToGuestPolicy, ingress: firewalldTransportZone, egress: firewalldGuestZone},
|
|
} {
|
|
if _, exists := policies[policy.name]; exists {
|
|
state, err := d.inspectFirewalldPolicy(ctx, scope, policy.name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := validateFirewalldPolicyState(scope, policy.name, policy.ingress, policy.egress, state); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d *linuxDriver) firewalldActive(ctx context.Context) (bool, error) {
|
|
if d.firewallCmdPath == "" {
|
|
present, err := d.nftTablePresent(ctx, "firewalld")
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if present {
|
|
return false, unavailable("vpc_firewalld_tool_unavailable", "firewalld is active but a trusted firewall-cmd executable is unavailable", nil)
|
|
}
|
|
return false, nil
|
|
}
|
|
raw, err := d.run.Run(ctx, d.firewallCmdPath, []string{"--state"}, nil)
|
|
if err == nil {
|
|
if strings.TrimSpace(string(raw)) == "running" {
|
|
return true, nil
|
|
}
|
|
return false, unavailable("vpc_firewalld_inspection_failed", "firewalld returned an invalid runtime state", nil)
|
|
}
|
|
if commandErrorContains(err, "not running") {
|
|
present, inspectErr := d.nftTablePresent(ctx, "firewalld")
|
|
if inspectErr != nil {
|
|
return false, inspectErr
|
|
}
|
|
if present {
|
|
return false, unavailable("vpc_firewalld_state_conflict", "firewalld is inactive but its nftables rules are still present", err)
|
|
}
|
|
return false, nil
|
|
}
|
|
return false, unavailable("vpc_firewalld_inspection_failed", "firewalld runtime state could not be inspected", err)
|
|
}
|
|
|
|
func (d *linuxDriver) nftTablePresent(ctx context.Context, name string) (bool, error) {
|
|
raw, err := d.run.Run(ctx, d.nftPath, []string{"-j", "list", "tables"}, nil)
|
|
if err != nil {
|
|
return false, unavailable("vpc_firewall_inspection_failed", "host nftables tables could not be inspected", err)
|
|
}
|
|
var document struct {
|
|
Objects []map[string]json.RawMessage `json:"nftables"`
|
|
}
|
|
if json.Unmarshal(raw, &document) != nil {
|
|
return false, unavailable("vpc_firewall_inspection_failed", "host nftables table output is invalid", nil)
|
|
}
|
|
for _, object := range document.Objects {
|
|
var table struct {
|
|
Family string `json:"family"`
|
|
Name string `json:"name"`
|
|
}
|
|
if encoded, exists := object["table"]; exists && json.Unmarshal(encoded, &table) == nil && table.Family == nftFamily && table.Name == name {
|
|
return true, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
}
|
|
|
|
func (d *linuxDriver) ensureFirewalldZone(ctx context.Context, scope firewalldScope, name string, forward bool) error {
|
|
names, err := d.firewalldNames(ctx, scope, "--get-zones")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, exists := names[name]; !exists {
|
|
if err := d.firewalldMutation(ctx, scope, "--new-zone="+name); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
state, err := d.inspectFirewalldZone(ctx, scope, name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := validateFirewalldZoneState(scope, name, forward, state); err != nil {
|
|
return err
|
|
}
|
|
if forward && !state.forward {
|
|
if err := d.firewalldMutation(ctx, scope, "--zone="+name, "--add-forward"); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
complete, err := d.firewalldZoneComplete(ctx, scope, name, forward)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !complete {
|
|
return unavailable("vpc_firewalld_apply_unconfirmed", "firewalld VPC zone could not be confirmed", nil)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d *linuxDriver) firewalldZoneComplete(ctx context.Context, scope firewalldScope, name string, forward bool) (bool, error) {
|
|
state, err := d.inspectFirewalldZone(ctx, scope, name)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if err := validateFirewalldZoneState(scope, name, forward, state); err != nil {
|
|
return false, err
|
|
}
|
|
return state.forward == forward, nil
|
|
}
|
|
|
|
func validateFirewalldZoneState(scope firewalldScope, name string, forward bool, state firewalldZoneState) error {
|
|
if state.target != firewalldExpectedZoneTarget {
|
|
return firewalldConflict(scope, "zone "+name+" has a foreign target")
|
|
}
|
|
if len(state.sources) != 0 || len(state.services) != 0 || len(state.ports) != 0 ||
|
|
len(state.protocols) != 0 || len(state.sourcePorts) != 0 || len(state.forwardPorts) != 0 ||
|
|
len(state.icmpBlocks) != 0 || state.richRules != "" {
|
|
return firewalldConflict(scope, "zone "+name+" contains foreign rules")
|
|
}
|
|
if state.masquerade || state.icmpBlockInversion {
|
|
return firewalldConflict(scope, "zone "+name+" contains a foreign feature")
|
|
}
|
|
if !forward && state.forward {
|
|
return firewalldConflict(scope, "zone "+name+" has foreign intra-zone forwarding")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d *linuxDriver) ensureFirewalldPolicy(ctx context.Context, scope firewalldScope, name, ingress, egress string) error {
|
|
names, err := d.firewalldNames(ctx, scope, "--get-policies")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, exists := names[name]; !exists {
|
|
if err := d.firewalldMutation(ctx, scope, "--new-policy="+name); err != nil {
|
|
return err
|
|
}
|
|
// A newly created firewalld policy defaults to CONTINUE. Use the
|
|
// policy target itself to admit every IP protocol across this exact
|
|
// zone pair; old firewalld releases reject a source-less rich rule.
|
|
if err := d.firewalldMutation(ctx, scope, "--policy="+name, "--set-target="+firewalldExpectedPolicyTarget); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
state, err := d.inspectFirewalldPolicy(ctx, scope, name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := validateFirewalldPolicyState(scope, name, ingress, egress, state); err != nil {
|
|
return err
|
|
}
|
|
if len(state.ingress) == 0 {
|
|
if err := d.firewalldMutation(ctx, scope, "--policy="+name, "--add-ingress-zone="+ingress); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if len(state.egress) == 0 {
|
|
if err := d.firewalldMutation(ctx, scope, "--policy="+name, "--add-egress-zone="+egress); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
complete, err := d.firewalldPolicyComplete(ctx, scope, name, ingress, egress)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !complete {
|
|
return unavailable("vpc_firewalld_apply_unconfirmed", "firewalld VPC policy could not be confirmed", nil)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validateFirewalldPolicyState(scope firewalldScope, name, ingress, egress string, state firewalldPolicyState) error {
|
|
if state.target != firewalldExpectedPolicyTarget {
|
|
return firewalldConflict(scope, "policy "+name+" has a foreign target")
|
|
}
|
|
if len(state.services) != 0 || len(state.ports) != 0 || len(state.protocols) != 0 ||
|
|
len(state.sourcePorts) != 0 || len(state.forwardPorts) != 0 || len(state.icmpBlocks) != 0 {
|
|
return firewalldConflict(scope, "policy "+name+" contains foreign rules")
|
|
}
|
|
if state.masquerade {
|
|
return firewalldConflict(scope, "policy "+name+" contains foreign masquerading")
|
|
}
|
|
if state.richRules != "" {
|
|
return firewalldConflict(scope, "policy "+name+" contains foreign rich rules")
|
|
}
|
|
if len(state.ingress) > 1 || (len(state.ingress) == 1 && !containsExactStrings(state.ingress, ingress)) {
|
|
return firewalldConflict(scope, "policy "+name+" has a foreign ingress zone")
|
|
}
|
|
if len(state.egress) > 1 || (len(state.egress) == 1 && !containsExactStrings(state.egress, egress)) {
|
|
return firewalldConflict(scope, "policy "+name+" has a foreign egress zone")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d *linuxDriver) firewalldPolicyComplete(ctx context.Context, scope firewalldScope, name, ingress, egress string) (bool, error) {
|
|
state, err := d.inspectFirewalldPolicy(ctx, scope, name)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if err := validateFirewalldPolicyState(scope, name, ingress, egress, state); err != nil {
|
|
return false, err
|
|
}
|
|
return containsExactStrings(state.ingress, ingress) && containsExactStrings(state.egress, egress), nil
|
|
}
|
|
|
|
func (d *linuxDriver) reconcileFirewalldInterfaces(ctx context.Context, scope firewalldScope, zone string, desired, managed map[string]struct{}) error {
|
|
state, err := d.inspectFirewalldZone(ctx, scope, zone)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
current := cloneSet(state.interfaces)
|
|
for _, name := range sortedStringSet(current) {
|
|
if _, keep := desired[name]; keep {
|
|
continue
|
|
}
|
|
if _, owned := managed[name]; !owned {
|
|
return firewalldConflict(scope, "zone "+zone+" contains an unmanaged interface")
|
|
}
|
|
if err := d.firewalldMutation(ctx, scope, "--zone="+zone, "--remove-interface="+name); err != nil {
|
|
return err
|
|
}
|
|
delete(current, name)
|
|
}
|
|
for _, name := range sortedStringSet(desired) {
|
|
if _, exists := current[name]; exists {
|
|
continue
|
|
}
|
|
bound, queryErr := d.firewalldInterfaceZone(ctx, scope, name)
|
|
if queryErr != nil {
|
|
return queryErr
|
|
}
|
|
if bound != "" && bound != zone {
|
|
return firewalldConflict(scope, "interface "+name+" is already bound to zone "+bound)
|
|
}
|
|
if bound != zone {
|
|
if err := d.firewalldMutation(ctx, scope, "--zone="+zone, "--add-interface="+name); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
confirmed, err := d.inspectFirewalldZone(ctx, scope, zone)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !equalStringSets(confirmed.interfaces, desired) {
|
|
return unavailable("vpc_firewalld_apply_unconfirmed", "firewalld VPC interface ownership could not be confirmed", nil)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d *linuxDriver) clearManagedFirewalldInterfaces(ctx context.Context, scope firewalldScope, guest, transport map[string]struct{}) error {
|
|
for _, zone := range []struct {
|
|
name string
|
|
managed map[string]struct{}
|
|
}{
|
|
{name: firewalldTransportZone, managed: transport},
|
|
{name: firewalldGuestZone, managed: guest},
|
|
} {
|
|
exists, err := d.firewalldObjectExists(ctx, scope, "--get-zones", zone.name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !exists {
|
|
continue
|
|
}
|
|
if err := d.reconcileFirewalldInterfaces(ctx, scope, zone.name, map[string]struct{}{}, zone.managed); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d *linuxDriver) removeUndesiredFirewalldInterfaces(ctx context.Context, scope firewalldScope, zone string, desired, managed map[string]struct{}) error {
|
|
exists, err := d.firewalldObjectExists(ctx, scope, "--get-zones", zone)
|
|
if err != nil || !exists {
|
|
return err
|
|
}
|
|
state, err := d.inspectFirewalldZone(ctx, scope, zone)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for name := range state.interfaces {
|
|
if _, keep := desired[name]; keep {
|
|
continue
|
|
}
|
|
if _, owned := managed[name]; !owned {
|
|
return firewalldConflict(scope, "zone "+zone+" contains an unmanaged interface")
|
|
}
|
|
if err := d.firewalldMutation(ctx, scope, "--zone="+zone, "--remove-interface="+name); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d *linuxDriver) firewalldNames(ctx context.Context, scope firewalldScope, argument string) (map[string]struct{}, error) {
|
|
value, err := d.firewalldValue(ctx, scope, argument)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return stringSet(words(value)), nil
|
|
}
|
|
|
|
func (d *linuxDriver) firewalldObjectExists(ctx context.Context, scope firewalldScope, listArgument, name string) (bool, error) {
|
|
names, err := d.firewalldNames(ctx, scope, listArgument)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
_, exists := names[name]
|
|
return exists, nil
|
|
}
|
|
|
|
func (d *linuxDriver) firewalldValue(ctx context.Context, scope firewalldScope, arguments ...string) (string, error) {
|
|
raw, err := d.run.Run(ctx, d.firewallCmdPath, scope.arguments(arguments...), nil)
|
|
if err != nil {
|
|
return "", unavailable("vpc_firewalld_inspection_failed", "firewalld VPC state could not be inspected", err)
|
|
}
|
|
return strings.TrimSpace(string(raw)), nil
|
|
}
|
|
|
|
// firewall-cmd reports an unbound interface as the text "no zone" with a
|
|
// non-zero exit status on supported firewalld releases. That is an ordinary
|
|
// empty state, not an inspection failure. Match the complete normalized output
|
|
// so transport errors and every other firewalld failure remain fail-closed.
|
|
func (d *linuxDriver) firewalldInterfaceZone(ctx context.Context, scope firewalldScope, name string) (string, error) {
|
|
raw, err := d.run.Run(ctx, d.firewallCmdPath, scope.arguments("--get-zone-of-interface="+name), nil)
|
|
if err != nil {
|
|
var command *commandError
|
|
if errors.As(err, &command) && strings.TrimSpace(command.output) == "no zone" {
|
|
return "", nil
|
|
}
|
|
return "", unavailable("vpc_firewalld_inspection_failed", "firewalld VPC interface ownership could not be inspected", err)
|
|
}
|
|
value := strings.TrimSpace(string(raw))
|
|
if value == "no zone" {
|
|
return "", nil
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func (d *linuxDriver) inspectFirewalldZone(ctx context.Context, scope firewalldScope, name string) (firewalldZoneState, error) {
|
|
fields, err := d.firewalldListedFields(ctx, scope, "--zone="+name)
|
|
if err != nil {
|
|
return firewalldZoneState{}, err
|
|
}
|
|
richRules, err := d.firewalldValue(ctx, scope, "--zone="+name, "--list-rich-rules")
|
|
if err != nil {
|
|
return firewalldZoneState{}, err
|
|
}
|
|
target, err := requiredFirewalldField(fields, "target")
|
|
if err != nil {
|
|
return firewalldZoneState{}, err
|
|
}
|
|
forward, err := firewalldFieldBoolean(fields, "forward")
|
|
if err != nil {
|
|
return firewalldZoneState{}, err
|
|
}
|
|
masquerade, err := firewalldFieldBoolean(fields, "masquerade")
|
|
if err != nil {
|
|
return firewalldZoneState{}, err
|
|
}
|
|
inversion, err := firewalldFieldBoolean(fields, "icmp-block-inversion")
|
|
if err != nil {
|
|
return firewalldZoneState{}, err
|
|
}
|
|
if err := requireFirewalldFields(fields, "interfaces", "sources", "services", "ports", "protocols", "forward-ports", "source-ports", "icmp-blocks"); err != nil {
|
|
return firewalldZoneState{}, err
|
|
}
|
|
return firewalldZoneState{
|
|
target: target, forward: forward, masquerade: masquerade, icmpBlockInversion: inversion,
|
|
interfaces: stringSet(words(fields["interfaces"])), sources: stringSet(words(fields["sources"])),
|
|
services: stringSet(words(fields["services"])), ports: stringSet(words(fields["ports"])),
|
|
protocols: stringSet(words(fields["protocols"])), forwardPorts: stringSet(words(fields["forward-ports"])),
|
|
sourcePorts: stringSet(words(fields["source-ports"])), icmpBlocks: stringSet(words(fields["icmp-blocks"])),
|
|
richRules: richRules,
|
|
}, nil
|
|
}
|
|
|
|
func (d *linuxDriver) inspectFirewalldPolicy(ctx context.Context, scope firewalldScope, name string) (firewalldPolicyState, error) {
|
|
fields, err := d.firewalldListedFields(ctx, scope, "--policy="+name)
|
|
if err != nil {
|
|
return firewalldPolicyState{}, err
|
|
}
|
|
richRules, err := d.firewalldValue(ctx, scope, "--policy="+name, "--list-rich-rules")
|
|
if err != nil {
|
|
return firewalldPolicyState{}, err
|
|
}
|
|
target, err := requiredFirewalldField(fields, "target")
|
|
if err != nil {
|
|
return firewalldPolicyState{}, err
|
|
}
|
|
masquerade, err := firewalldFieldBoolean(fields, "masquerade")
|
|
if err != nil {
|
|
return firewalldPolicyState{}, err
|
|
}
|
|
if err := requireFirewalldFields(fields, "ingress-zones", "egress-zones", "services", "ports", "protocols", "forward-ports", "source-ports", "icmp-blocks"); err != nil {
|
|
return firewalldPolicyState{}, err
|
|
}
|
|
return firewalldPolicyState{
|
|
target: target, masquerade: masquerade,
|
|
ingress: stringSet(words(fields["ingress-zones"])), egress: stringSet(words(fields["egress-zones"])),
|
|
services: stringSet(words(fields["services"])), ports: stringSet(words(fields["ports"])),
|
|
protocols: stringSet(words(fields["protocols"])), forwardPorts: stringSet(words(fields["forward-ports"])),
|
|
sourcePorts: stringSet(words(fields["source-ports"])), icmpBlocks: stringSet(words(fields["icmp-blocks"])),
|
|
richRules: richRules,
|
|
}, nil
|
|
}
|
|
|
|
func (d *linuxDriver) firewalldListedFields(ctx context.Context, scope firewalldScope, object string) (map[string]string, error) {
|
|
value, err := d.firewalldValue(ctx, scope, object, "--list-all")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
known := map[string]struct{}{
|
|
"target": {}, "interfaces": {}, "sources": {}, "services": {}, "ports": {}, "protocols": {},
|
|
"forward": {}, "masquerade": {}, "forward-ports": {}, "source-ports": {}, "icmp-blocks": {},
|
|
"icmp-block-inversion": {}, "ingress-zones": {}, "egress-zones": {},
|
|
}
|
|
result := make(map[string]string, len(known))
|
|
for _, line := range strings.Split(value, "\n") {
|
|
line = strings.TrimSpace(line)
|
|
separator := strings.IndexByte(line, ':')
|
|
if separator <= 0 {
|
|
continue
|
|
}
|
|
field := strings.TrimSpace(line[:separator])
|
|
if _, expected := known[field]; !expected {
|
|
continue
|
|
}
|
|
if _, duplicate := result[field]; duplicate {
|
|
return nil, unavailable("vpc_firewalld_inspection_failed", "firewalld returned duplicate VPC object fields", nil)
|
|
}
|
|
result[field] = strings.TrimSpace(line[separator+1:])
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func requiredFirewalldField(fields map[string]string, name string) (string, error) {
|
|
value, exists := fields[name]
|
|
if !exists || value == "" {
|
|
return "", unavailable("vpc_firewalld_inspection_failed", "firewalld omitted a required VPC object field", nil)
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func requireFirewalldFields(fields map[string]string, names ...string) error {
|
|
for _, name := range names {
|
|
if _, exists := fields[name]; !exists {
|
|
return unavailable("vpc_firewalld_inspection_failed", "firewalld omitted a required VPC object field", nil)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func firewalldFieldBoolean(fields map[string]string, name string) (bool, error) {
|
|
value, exists := fields[name]
|
|
if !exists {
|
|
return false, unavailable("vpc_firewalld_inspection_failed", "firewalld omitted a required VPC object field", nil)
|
|
}
|
|
switch strings.ToLower(value) {
|
|
case "yes":
|
|
return true, nil
|
|
case "no":
|
|
return false, nil
|
|
default:
|
|
return false, unavailable("vpc_firewalld_inspection_failed", "firewalld returned an invalid VPC object field", nil)
|
|
}
|
|
}
|
|
|
|
func (d *linuxDriver) firewalldMutation(ctx context.Context, scope firewalldScope, arguments ...string) error {
|
|
if _, err := d.run.Run(ctx, d.firewallCmdPath, scope.arguments(arguments...), nil); err != nil {
|
|
return unavailable("vpc_firewalld_apply_failed", "firewalld VPC forwarding could not be applied", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func firewalldConflict(scope firewalldScope, detail string) error {
|
|
return unavailable("vpc_firewalld_conflict", fmt.Sprintf("%s firewalld VPC configuration conflicts with host state: %s", scope.name(), detail), nil)
|
|
}
|
|
|
|
func firewalldInterfaces(networks map[string]Network) (map[string]struct{}, map[string]struct{}) {
|
|
guests := make(map[string]struct{}, len(networks))
|
|
transports := make(map[string]struct{}, len(networks))
|
|
for _, network := range networks {
|
|
bridge, _ := BridgeName(network.VPCKey)
|
|
guests[bridge] = struct{}{}
|
|
transports[network.Transport.Interface] = struct{}{}
|
|
}
|
|
return guests, transports
|
|
}
|
|
|
|
func mergeNetworkMaps(left, right map[string]Network) map[string]Network {
|
|
result := make(map[string]Network, len(left)+len(right))
|
|
for key, network := range left {
|
|
result[key] = network
|
|
}
|
|
for key, network := range right {
|
|
result[key] = network
|
|
}
|
|
return result
|
|
}
|
|
|
|
func words(value string) []string {
|
|
if value == "" {
|
|
return nil
|
|
}
|
|
return strings.Fields(value)
|
|
}
|
|
|
|
func stringSet(values []string) map[string]struct{} {
|
|
result := make(map[string]struct{}, len(values))
|
|
for _, value := range values {
|
|
result[value] = struct{}{}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func cloneSet(values map[string]struct{}) map[string]struct{} {
|
|
result := make(map[string]struct{}, len(values))
|
|
for value := range values {
|
|
result[value] = struct{}{}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func sortedStringSet(values map[string]struct{}) []string {
|
|
result := make([]string, 0, len(values))
|
|
for value := range values {
|
|
result = append(result, value)
|
|
}
|
|
sort.Strings(result)
|
|
return result
|
|
}
|
|
|
|
func equalStringSets(left, right map[string]struct{}) bool {
|
|
if len(left) != len(right) {
|
|
return false
|
|
}
|
|
for value := range left {
|
|
if _, exists := right[value]; !exists {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func containsExactStrings(values map[string]struct{}, expected ...string) bool {
|
|
if len(values) != len(expected) {
|
|
return false
|
|
}
|
|
for _, value := range expected {
|
|
if _, exists := values[value]; !exists {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func commandErrorContains(err error, fragment string) bool {
|
|
var command *commandError
|
|
return errors.As(err, &command) && strings.Contains(strings.ToLower(command.output), strings.ToLower(fragment))
|
|
}
|