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.
virt/agent/vpcrouting/firewalld_linux.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))
}