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/hypervisor/domain_xml.go

1465 lines
59 KiB
Go

package hypervisor
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"encoding/xml"
"errors"
"fmt"
"net"
"net/netip"
"path/filepath"
"regexp"
"slices"
"strconv"
"strings"
"unicode/utf8"
"git.luoli.live/root/virt/agent/publicnetwork"
"libvirt.org/go/libvirtxml"
)
var (
uuidPattern = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$`)
namePattern = regexp.MustCompile(`^[A-Za-z0-9_.-]{1,80}$`)
netPattern = regexp.MustCompile(`^[A-Za-z0-9_.:-]{1,64}$`)
templateIDPattern = regexp.MustCompile(`^[A-Za-z0-9_.-]{1,128}$`)
generationTokenPattern = regexp.MustCompile(`^[A-Za-z0-9_-]{16,128}$`)
poolKeyPattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
digestPattern = regexp.MustCompile(`^[0-9a-f]{64}$`)
hostnamePattern = regexp.MustCompile(`^[a-z0-9](?:[a-z0-9.-]{0,251}[a-z0-9])?$`)
policyIdentifier = regexp.MustCompile(`^[a-z0-9][a-z0-9_-]{0,63}$`)
shortVolumeHashPattern = regexp.MustCompile(`^[0-9a-f]{16}$`)
)
// isVMOwnedRootVolumeName recognizes only root-volume names that the Agent
// itself can derive for one VM. Metadata is not sufficient ownership proof:
// without this check a corrupted marker could make deletion remove another
// tenant's volume.
func isVMOwnedRootVolumeName(uuid, name string) bool {
if !uuidPattern.MatchString(uuid) || name != strings.ToLower(name) {
return false
}
canonicalUUID := strings.ToLower(uuid)
if name == canonicalUUID+"-root.qcow2" {
return true
}
compactUUID := strings.ReplaceAll(canonicalUUID, "-", "")
for _, prefix := range []string{"vreinstall-" + compactUUID + "-", "vrestore-" + compactUUID + "-"} {
if !strings.HasPrefix(name, prefix) || !strings.HasSuffix(name, ".qcow2") {
continue
}
digest := strings.TrimSuffix(strings.TrimPrefix(name, prefix), ".qcow2")
if shortVolumeHashPattern.MatchString(digest) {
return true
}
}
return false
}
func isVMOwnedManagedVolumeName(uuid, name string) bool {
if isVMOwnedRootVolumeName(uuid, name) {
return true
}
if !uuidPattern.MatchString(uuid) || name != strings.ToLower(name) {
return false
}
compactUUID := strings.ReplaceAll(strings.ToLower(uuid), "-", "")
for _, prefix := range []string{
"vsnap-" + compactUUID + "-",
"vbackup-" + compactUUID + "-",
} {
if !strings.HasPrefix(name, prefix) || !strings.HasSuffix(name, ".qcow2") {
continue
}
key := strings.TrimSuffix(strings.TrimPrefix(name, prefix), ".qcow2")
return catalogIDPattern.MatchString(key)
}
return false
}
func BuildDomainXML(definition DomainDefinition) (string, error) {
if err := ValidateDomainDefinition(definition); err != nil {
return "", err
}
format := definition.RootDiskFormat
if format == "" {
format = "qcow2"
}
domain := libvirtxml.Domain{
Type: "kvm",
Name: definition.Name,
UUID: strings.ToLower(definition.UUID),
Description: definition.Description,
Memory: &libvirtxml.DomainMemory{Value: uint(definition.MemoryMiB), Unit: "MiB"},
VCPU: &libvirtxml.DomainVCPU{Placement: "static", Value: definition.VCPUs},
OS: &libvirtxml.DomainOS{
Type: &libvirtxml.DomainOSType{Arch: "x86_64", Machine: "q35", Type: "hvm"},
Loader: &libvirtxml.DomainLoader{
Path: definition.Firmware.Loader, Readonly: "yes", Secure: "no", Type: "pflash",
},
NVRam: &libvirtxml.DomainNVRam{
NVRam: definition.Firmware.NVRAMPath, Template: definition.Firmware.NVRAMTemplate,
},
// FirmwareInfo is intentionally omitted. Its feature list is only
// valid with libvirt firmware autoselection, while this agent pins a
// host-validated loader and NVRAM template explicitly.
BootDevices: []libvirtxml.DomainBootDevice{{Dev: "hd"}},
},
Features: &libvirtxml.DomainFeatureList{
ACPI: &libvirtxml.DomainFeature{},
APIC: &libvirtxml.DomainFeatureAPIC{},
SMM: &libvirtxml.DomainFeatureSMM{State: "off"},
},
CPU: &libvirtxml.DomainCPU{Mode: "host-passthrough"},
OnPoweroff: "destroy",
OnReboot: "restart",
OnCrash: "destroy",
Devices: &libvirtxml.DomainDeviceList{
Disks: []libvirtxml.DomainDisk{{
Device: "disk",
Driver: &libvirtxml.DomainDiskDriver{Name: "qemu", Type: format, Cache: "none", Discard: "unmap"},
Source: &libvirtxml.DomainDiskSource{File: &libvirtxml.DomainDiskSourceFile{File: definition.RootDiskPath}},
Target: &libvirtxml.DomainDiskTarget{Dev: "vda", Bus: "virtio"},
}},
Interfaces: make([]libvirtxml.DomainInterface, 0, len(definition.Network)),
Graphics: []libvirtxml.DomainGraphic{{
VNC: &libvirtxml.DomainGraphicVNC{AutoPort: "yes", Listen: "127.0.0.1"},
}},
Videos: []libvirtxml.DomainVideo{{Model: libvirtxml.DomainVideoModel{Type: "vga"}}},
Inputs: []libvirtxml.DomainInput{{Type: "tablet", Bus: "usb"}},
Channels: []libvirtxml.DomainChannel{{
Source: &libvirtxml.DomainChardevSource{UNIX: &libvirtxml.DomainChardevSourceUNIX{}},
Target: &libvirtxml.DomainChannelTarget{VirtIO: &libvirtxml.DomainChannelTargetVirtIO{Name: "org.qemu.guest_agent.0"}},
}},
MemBalloon: &libvirtxml.DomainMemBalloon{
Model: "virtio", FreePageReporting: "on", Stats: &libvirtxml.DomainMemBalloonStats{Period: 10},
},
},
}
metadata, err := marshalDomainMetadata(definition)
if err != nil {
return "", err
}
domain.Metadata = &libvirtxml.DomainMetadata{XML: metadata}
if definition.SeedDiskPath != "" {
domain.Devices.Disks = append(domain.Devices.Disks, libvirtxml.DomainDisk{
Device: "cdrom",
Driver: &libvirtxml.DomainDiskDriver{Name: "qemu", Type: "raw"},
Source: &libvirtxml.DomainDiskSource{File: &libvirtxml.DomainDiskSourceFile{File: definition.SeedDiskPath}},
Target: &libvirtxml.DomainDiskTarget{Dev: "sda", Bus: "sata"},
ReadOnly: &libvirtxml.DomainDiskReadOnly{},
})
}
for index, attachment := range definition.Network {
iface := libvirtxml.DomainInterface{
Model: &libvirtxml.DomainInterfaceModel{Type: "virtio"},
Source: &libvirtxml.DomainInterfaceSource{},
Driver: &libvirtxml.DomainInterfaceDriver{Queues: min(definition.VCPUs, 16)},
}
if definition.BandwidthMbps > 0 {
rate := int((definition.BandwidthMbps*1_000_000 + 8191) / 8192)
iface.Bandwidth = &libvirtxml.DomainInterfaceBandwidth{
Inbound: &libvirtxml.DomainInterfaceBandwidthParams{Average: &rate, Peak: &rate},
Outbound: &libvirtxml.DomainInterfaceBandwidthParams{Average: &rate, Peak: &rate},
}
}
if attachment.MAC != "" {
iface.MAC = &libvirtxml.DomainInterfaceMAC{Address: strings.ToLower(attachment.MAC)}
}
// The first attachment is the public interface owned by the platform
// firewall. The optional VPC interface deliberately does not inherit
// user ACLs, but it does bind libvirt's clean-traffic baseline to its
// exact private IPv4 address so the guest cannot spoof another VPC
// endpoint on the routed fabric.
if definition.FilterName != "" && index == 0 {
filterRef, err := newManagedInterfaceFilterRef(definition.FilterName, definition.PublicNetwork, attachment.MAC)
if err != nil {
return "", err
}
iface.FilterRef = filterRef
iface.Target = &libvirtxml.DomainInterfaceTarget{Dev: publicInterfaceTarget(definition.UUID)}
} else if definition.VPCPort != nil && index == 1 {
iface.FilterRef = newManagedVPCInterfaceFilterRef(
definition.VPCPort.PrivateIP,
)
}
if attachment.LinkDown {
iface.Link = &libvirtxml.DomainInterfaceLink{State: "down"}
}
if attachment.Bridge != "" {
iface.Source.Bridge = &libvirtxml.DomainInterfaceSourceBridge{Bridge: attachment.Bridge}
} else {
iface.Source.Network = &libvirtxml.DomainInterfaceSourceNetwork{Network: attachment.Network}
}
domain.Devices.Interfaces = append(domain.Devices.Interfaces, iface)
}
document, err := domain.Marshal()
if err != nil {
return "", fmt.Errorf("marshal libvirt domain XML: %w", err)
}
return document, nil
}
const managedInterfaceIPParameter = "IP"
const managedInterfaceIPv6Parameter = "IPV6"
const managedInterfaceIPv6LinkLocalParameter = "IPV6_LINK_LOCAL"
const managedVPCInterfaceFilterName = "virt-cloud-vpc-antispoof-v1"
func publicInterfaceTarget(uuid string) string {
compact := strings.ReplaceAll(strings.ToLower(uuid), "-", "")
if len(compact) < 12 {
return ""
}
return "vc" + compact[:12]
}
func newManagedInterfaceFilterRef(filterName string, public publicnetwork.Intent, mac string) (*libvirtxml.DomainInterfaceFilterRef, error) {
ipv4, err := publicAddress(public.IPv4.AddressCIDR, 4)
if err != nil {
return nil, err
}
ipv6, err := publicAddress(public.IPv6.AddressCIDR, 6)
if err != nil {
return nil, err
}
linkLocal, err := publicnetwork.LinkLocalIPv6(mac)
if err != nil {
return nil, NewError(ErrInvalid, "invalid_public_mac", "public interface MAC cannot derive its link-local IPv6 identity", err)
}
return &libvirtxml.DomainInterfaceFilterRef{
Filter: filterName,
Parameters: []libvirtxml.DomainInterfaceFilterParam{
{Name: managedInterfaceIPParameter, Value: ipv4},
{Name: managedInterfaceIPv6Parameter, Value: ipv6},
{Name: managedInterfaceIPv6LinkLocalParameter, Value: linkLocal.String()},
},
}, nil
}
func publicAddress(addressCIDR string, family int) (string, error) {
prefix, err := netip.ParsePrefix(addressCIDR)
if err != nil || (family == 4 && !prefix.Addr().Is4()) || (family == 6 && !prefix.Addr().Is6()) {
return "", NewError(ErrInvalid, "invalid_public_ip", "public network address has the wrong family", err)
}
return prefix.Addr().String(), nil
}
func managedInterfaceFilterIPMatches(iface *libvirtxml.DomainInterface, filterName string, public publicnetwork.Intent) bool {
ipv4, err4 := publicAddress(public.IPv4.AddressCIDR, 4)
ipv6, err6 := publicAddress(public.IPv6.AddressCIDR, 6)
var linkLocal netip.Addr
var linkLocalErr error
if iface != nil && iface.MAC != nil {
linkLocal, linkLocalErr = publicnetwork.LinkLocalIPv6(iface.MAC.Address)
} else {
linkLocalErr = errors.New("public interface MAC is missing")
}
if err4 != nil || err6 != nil || iface == nil || iface.FilterRef == nil || iface.FilterRef.Filter != filterName || len(iface.FilterRef.Parameters) != 3 {
return false
}
return iface.FilterRef.Parameters[0].Name == managedInterfaceIPParameter &&
iface.FilterRef.Parameters[0].Value == ipv4 &&
iface.FilterRef.Parameters[1].Name == managedInterfaceIPv6Parameter &&
iface.FilterRef.Parameters[1].Value == ipv6 &&
linkLocalErr == nil &&
iface.FilterRef.Parameters[2].Name == managedInterfaceIPv6LinkLocalParameter &&
iface.FilterRef.Parameters[2].Value == linkLocal.String()
}
func newManagedVPCInterfaceFilterRef(privateIP string) *libvirtxml.DomainInterfaceFilterRef {
return &libvirtxml.DomainInterfaceFilterRef{
Filter: managedVPCInterfaceFilterName,
Parameters: []libvirtxml.DomainInterfaceFilterParam{{
Name: managedInterfaceIPParameter, Value: privateIP,
}},
}
}
func managedVPCInterfaceFilterIPMatches(iface *libvirtxml.DomainInterface,
privateIP string) bool {
address, err := netip.ParseAddr(privateIP)
if err != nil || !address.Is4() || address.String() != privateIP ||
iface == nil || iface.FilterRef == nil ||
iface.FilterRef.Filter != managedVPCInterfaceFilterName ||
len(iface.FilterRef.Parameters) != 1 {
return false
}
parameter := iface.FilterRef.Parameters[0]
return parameter.Name == managedInterfaceIPParameter &&
parameter.Value == privateIP
}
func updateManagedInterfaceFilterIP(iface *libvirtxml.DomainInterface, filterName string, current, target publicnetwork.Intent) error {
if !managedInterfaceFilterIPMatches(iface, filterName, current) {
return NewError(ErrConflict, "network_filter_binding_changed", "managed VM network filter IP binding does not match its recorded public address", nil)
}
ipv4, err := publicAddress(target.IPv4.AddressCIDR, 4)
if err != nil {
return err
}
ipv6, err := publicAddress(target.IPv6.AddressCIDR, 6)
if err != nil {
return err
}
iface.FilterRef.Parameters[0].Value = ipv4
iface.FilterRef.Parameters[1].Value = ipv6
return nil
}
const domainMetadataNamespace = "https://virt.example/schema/domain/1"
type domainMetadataXML struct {
XMLName xml.Name `xml:"virt-cloud"`
XMLNS string `xml:"xmlns,attr"`
DisplayName string `xml:"display-name,omitempty"`
DiskGiB uint64 `xml:"disk-gib"`
BandwidthMbps uint64 `xml:"bandwidth-mbps"`
Hostname string `xml:"hostname,omitempty"`
PublicNetwork domainPublicNetworkXML `xml:"public-network"`
SettingsTransitionID string `xml:"settings-transition-id,omitempty"`
ResourcesTransitionID string `xml:"resources-transition-id,omitempty"`
ResourcesOriginalPower string `xml:"resources-transition-original-power,omitempty"`
ResourcesOriginalAutostart string `xml:"resources-transition-original-autostart,omitempty"`
NetworkTransitionID string `xml:"network-transition-id,omitempty"`
VPCTransitionID string `xml:"vpc-transition-id,omitempty"`
VPCPort *domainVPCPortMetadataXML `xml:"vpc-port,omitempty"`
FirewallTransitionID string `xml:"firewall-transition-id,omitempty"`
TemplateID string `xml:"template-id"`
RootVolumeName string `xml:"root-volume"`
PlatformPolicyJSON string `xml:"platform-policy-json"`
PendingCleanupVolume string `xml:"pending-cleanup-volume,omitempty"`
DiskTransitionKind string `xml:"disk-transition-kind,omitempty"`
DiskTransitionID string `xml:"disk-transition-id,omitempty"`
DiskTransitionRunning bool `xml:"disk-transition-was-running,omitempty"`
Snapshots []domainSnapshotMetadataXML `xml:"snapshot,omitempty"`
Firewall *domainFirewallMetadataXML `xml:"firewall,omitempty"`
RescueTemplateID string `xml:"rescue-template-id,omitempty"`
RescueTemplateRevision uint64 `xml:"rescue-template-revision,omitempty"`
RescueTemplateGeneration string `xml:"rescue-template-generation,omitempty"`
RescueWasRunning bool `xml:"rescue-was-running,omitempty"`
RescueAutostart bool `xml:"rescue-original-autostart,omitempty"`
}
type domainPublicNetworkXML struct {
Contract uint64 `xml:"contract,attr"`
NetworkSelector string `xml:"network-selector,attr"`
IPv4 domainPublicAddressXML `xml:"ipv4"`
IPv6 domainPublicAddressXML `xml:"ipv6"`
DNSServers []string `xml:"dns-server"`
}
type domainPublicAddressXML struct {
PoolKey string `xml:"pool-key,attr"`
PoolCIDR string `xml:"pool-cidr,attr"`
AddressCIDR string `xml:"address-cidr,attr"`
Gateway string `xml:"gateway,attr"`
GatewayOnLink bool `xml:"gateway-on-link,attr"`
}
type domainVPCPortMetadataXML struct {
PortKey string `xml:"port-key,attr"`
VPCKey string `xml:"vpc-key,attr"`
PrivateIP string `xml:"private-ip,attr"`
CIDR string `xml:"cidr,attr"`
Gateway string `xml:"gateway,attr"`
MAC string `xml:"mac,attr"`
Bridge string `xml:"bridge,attr"`
HostRevision uint64 `xml:"host-revision,attr"`
HostDigest string `xml:"host-digest,attr"`
}
type domainSnapshotMetadataXML struct {
Key string `xml:"key,attr"`
Name string `xml:"name,attr"`
Description string `xml:"description,omitempty"`
Consistency string `xml:"consistency,attr"`
SizeBytes uint64 `xml:"size-bytes,attr"`
CreatedAt int64 `xml:"created-at,attr"`
}
type domainFirewallMetadataXML struct {
Revision uint64 `xml:"revision,attr"`
Digest string `xml:"digest,attr"`
DefaultIn string `xml:"default-in,attr"`
DefaultOut string `xml:"default-out,attr"`
Rules []domainFirewallRuleMetadataXML `xml:"rule"`
}
type domainFirewallRuleMetadataXML struct {
Direction string `xml:"direction,attr"`
Action string `xml:"action,attr"`
Protocol string `xml:"protocol,attr"`
CIDR string `xml:"cidr,attr"`
PortFrom uint16 `xml:"port-from,attr,omitempty"`
PortTo uint16 `xml:"port-to,attr,omitempty"`
}
func marshalDomainMetadata(definition DomainDefinition) (string, error) {
policyJSON, err := json.Marshal(definition.PlatformNetworkPolicy)
if err != nil {
return "", fmt.Errorf("marshal platform network policy metadata: %w", err)
}
var vpcPort *domainVPCPortMetadataXML
if definition.VPCPort != nil {
value := domainVPCPortFromPublic(*definition.VPCPort)
vpcPort = &value
}
encoded, err := xml.Marshal(domainMetadataXML{
XMLNS: domainMetadataNamespace, DisplayName: definition.DisplayName, DiskGiB: definition.DiskGiB,
BandwidthMbps: definition.BandwidthMbps, Hostname: definition.Hostname,
PublicNetwork: domainPublicNetworkFromPublic(definition.PublicNetwork),
TemplateID: definition.TemplateID,
RootVolumeName: definition.RootVolumeName, PlatformPolicyJSON: string(policyJSON),
VPCPort: vpcPort,
Snapshots: append([]domainSnapshotMetadataXML(nil), definition.Snapshots...),
})
if err != nil {
return "", fmt.Errorf("marshal domain metadata: %w", err)
}
return string(encoded), nil
}
func ValidateCreateVM(request CreateVMRequest) error {
if request.UUID != "" && !uuidPattern.MatchString(request.UUID) {
return NewError(ErrInvalid, "invalid_uuid", "uuid must be a canonical RFC 4122 value", nil)
}
if err := validateLibvirtDomainName(request.DomainName, request.UUID); err != nil {
return err
}
if request.Source != "cloud" {
return NewError(ErrInvalid, "invalid_source", "source must be cloud", nil)
}
if !namePattern.MatchString(request.Name) {
return NewError(ErrInvalid, "invalid_name", "name must contain 1-80 safe characters", nil)
}
if len(request.Description) > 1024 || strings.ContainsRune(request.Description, 0) {
return NewError(ErrInvalid, "invalid_description", "description is too long or contains NUL", nil)
}
if request.VCPUs == 0 || request.VCPUs > 512 {
return NewError(ErrInvalid, "invalid_vcpus", "vcpus must be between 1 and 512", nil)
}
if request.MemoryMiB < 128 || request.MemoryMiB > 16*1024*1024 {
return NewError(ErrInvalid, "invalid_memory", "memory_mib must be between 128 and 16777216", nil)
}
if request.DiskGiB < 1 || request.DiskGiB > 4096 {
return NewError(ErrInvalid, "invalid_disk", "disk_gib must be between 1 and 4096", nil)
}
if request.BandwidthMbps < 1 || request.BandwidthMbps > 100000 {
return NewError(ErrInvalid, "invalid_bandwidth", "bandwidth_mbps must be between 1 and 100000", nil)
}
if request.TemplateID == "" {
return NewError(ErrInvalid, "invalid_template_id", "template_id is required", nil)
}
if err := ValidateTemplateSnapshot(request.TemplateID, request.TemplateRevision, request.TemplateGenerationToken); err != nil {
return err
}
if request.Hostname != "" && (!hostnamePattern.MatchString(request.Hostname) || strings.Contains(request.Hostname, "..")) {
return NewError(ErrInvalid, "invalid_hostname", "hostname must be a lower-case DNS name", nil)
}
if err := validateGuestCredentials(request.GuestSSHPublicKey, request.RootPassword); err != nil {
return err
}
if err := ValidatePublicNetworkIntent(request.PublicNetwork); err != nil {
return err
}
if _, err := NormalizeStartupScript(request.StartupScript); err != nil {
return err
}
if err := ValidatePlatformNetworkPolicy(request.PlatformNetworkPolicy); err != nil {
return err
}
return nil
}
// ValidatePublicNetworkIntent verifies a signed PHP/IPAM allocation without
// making the host agent a second pool authority.
func ValidatePublicNetworkIntent(value publicnetwork.Intent) error {
if _, err := ParseNetworkSelector(value.NetworkSelector); err != nil {
return err
}
canonical, err := value.Canonical()
if err != nil {
return NewError(ErrInvalid, "invalid_public_network", "public_network is invalid", err)
}
if canonical.Contract != value.Contract || canonical.NetworkSelector != value.NetworkSelector ||
canonical.IPv4 != value.IPv4 || canonical.IPv6 != value.IPv6 ||
!slices.Equal(canonical.DNSServers, value.DNSServers) {
return NewError(ErrInvalid, "noncanonical_public_network", "public_network must use its canonical representation", nil)
}
return nil
}
func BuildPlatformFilterXML(name string, public publicnetwork.Intent, policy PlatformNetworkPolicySnapshot) (string, error) {
if !namePattern.MatchString(name) {
return "", NewError(ErrInvalid, "invalid_filter_name", "network filter name is invalid", nil)
}
if err := ValidatePublicNetworkIntent(public); err != nil {
return "", err
}
if err := ValidatePlatformNetworkPolicy(policy); err != nil {
return "", err
}
filter := libvirtxml.NWFilter{
Name: name, Chain: "root", Entries: platformAntiSpoofEntries(),
}
priority := -500
for _, policyRule := range policy.Rules {
for _, direction := range policyRule.Directions {
wireDirection := "in"
if direction == "egress" {
wireDirection = "out"
}
for _, protocol := range policyRule.Protocols {
v4, v6 := platformDropRules(protocol, wireDirection, policyRule, priority)
filter.Entries = append(filter.Entries,
libvirtxml.NWFilterEntry{Rule: v4},
libvirtxml.NWFilterEntry{Rule: v6},
)
priority += 2
}
}
}
filter.Entries = append(filter.Entries, platformPassEntries()...)
return filter.Marshal()
}
// BuildManagedVPCAntiSpoofFilterXML returns the one project-owned, shared VPC
// interface filter. Libvirt supplies $MAC from the attached interface and the
// domain supplies the exact private IPv4 as $IP. No rule may accept outbound
// traffic before both negative identity guards have run.
func BuildManagedVPCAntiSpoofFilterXML() (string, error) {
filter := libvirtxml.NWFilter{
Name: managedVPCInterfaceFilterName, Chain: "root",
Entries: managedVPCAntiSpoofEntries(),
}
return filter.Marshal()
}
func managedVPCAntiSpoofEntries() []libvirtxml.NWFilterEntry {
return []libvirtxml.NWFilterEntry{
{Rule: &libvirtxml.NWFilterRule{
Action: "drop", Direction: "out", Priority: -950, StateMatch: "false",
MAC: &libvirtxml.NWFilterRuleMAC{
Match: "no", NWFilterRuleCommonMAC: libvirtxml.NWFilterRuleCommonMAC{SrcMACAddr: filterVariable("MAC")},
Comment: "virt-vpc-block-spoofed-mac",
},
}},
{Rule: &libvirtxml.NWFilterRule{
Action: "drop", Direction: "out", Priority: -940, StateMatch: "false",
ARP: &libvirtxml.NWFilterRuleARP{
Match: "no", NWFilterRuleCommonMAC: libvirtxml.NWFilterRuleCommonMAC{SrcMACAddr: filterVariable("MAC")},
ARPSrcMACAddr: filterVariable("MAC"), ARPSrcIPAddr: filterVariable(managedInterfaceIPParameter),
Comment: "virt-vpc-block-spoofed-arp",
},
}},
{Rule: &libvirtxml.NWFilterRule{
Action: "drop", Direction: "out", Priority: -930, StateMatch: "false",
IP: &libvirtxml.NWFilterRuleIP{
Match: "no", NWFilterRuleCommonMAC: libvirtxml.NWFilterRuleCommonMAC{SrcMACAddr: filterVariable("MAC")},
SrcIPAddr: filterVariable(managedInterfaceIPParameter), Comment: "virt-vpc-block-spoofed-ipv4",
},
}},
{Rule: &libvirtxml.NWFilterRule{Action: "accept", Direction: "in", Priority: 900, StateMatch: "false", All: &libvirtxml.NWFilterRuleAll{Comment: "virt-vpc-pass-in"}}},
{Rule: &libvirtxml.NWFilterRule{Action: "accept", Direction: "out", Priority: 901, StateMatch: "false", ARP: &libvirtxml.NWFilterRuleARP{Comment: "virt-vpc-pass-arp"}}},
{Rule: &libvirtxml.NWFilterRule{Action: "accept", Direction: "out", Priority: 902, StateMatch: "false", IP: &libvirtxml.NWFilterRuleIP{Comment: "virt-vpc-pass-ipv4"}}},
{Rule: &libvirtxml.NWFilterRule{Action: "drop", Direction: "out", Priority: 999, StateMatch: "false", All: &libvirtxml.NWFilterRuleAll{Comment: "virt-vpc-drop-other"}}},
}
}
func platformAntiSpoofEntries() []libvirtxml.NWFilterEntry {
entries := make([]libvirtxml.NWFilterEntry, 0, 24)
add := func(rule *libvirtxml.NWFilterRule) {
entries = append(entries, libvirtxml.NWFilterEntry{Rule: rule})
}
// This negative MAC match is the first egress guard for every EtherType.
// Valid frames continue into the IP/ARP and policy layers; a positive accept
// here would bypass all later platform and user firewall rules.
add(&libvirtxml.NWFilterRule{
Action: "drop", Direction: "out", Priority: -950, StateMatch: "false",
MAC: &libvirtxml.NWFilterRuleMAC{
Match: "no", NWFilterRuleCommonMAC: libvirtxml.NWFilterRuleCommonMAC{SrcMACAddr: filterVariable("MAC")},
Comment: "block-spoofed-mac",
},
})
// A guest may consume router advertisements and redirects from its upstream
// network, but it must never impersonate a router or DHCPv6 server.
add(icmpv6TypeRule("drop", "out", -940, 134, "block-guest-router-advertisement", ""))
add(icmpv6TypeRule("drop", "out", -939, 137, "block-guest-redirect", ""))
src547, dst546 := uint(547), uint(546)
add(&libvirtxml.NWFilterRule{
Action: "drop", Direction: "out", Priority: -938, StateMatch: "false",
UDPIPv6: &libvirtxml.NWFilterRuleUDPIPv6{
NWFilterRuleCommonPort: libvirtxml.NWFilterRuleCommonPort{
SrcPortStart: libvirtxml.NWFilterField{Uint: &src547},
SrcPortEnd: libvirtxml.NWFilterField{Uint: &src547},
DstPortStart: libvirtxml.NWFilterField{Uint: &dst546},
DstPortEnd: libvirtxml.NWFilterField{Uint: &dst546},
},
Comment: "block-dhcpv6-server",
},
})
// IPv4 source identity covers both ordinary frames and ARP ownership. These
// are negative drops: valid traffic continues to provider and user policy.
add(&libvirtxml.NWFilterRule{
Action: "drop", Direction: "out", Priority: -930, StateMatch: "false",
ARP: &libvirtxml.NWFilterRuleARP{
Match: "no",
NWFilterRuleCommonMAC: libvirtxml.NWFilterRuleCommonMAC{SrcMACAddr: filterVariable("MAC")},
ARPSrcMACAddr: filterVariable("MAC"),
ARPSrcIPAddr: filterVariable(managedInterfaceIPParameter),
Comment: "block-spoofed-arp",
},
})
add(&libvirtxml.NWFilterRule{
Action: "drop", Direction: "out", Priority: -920, StateMatch: "false",
IP: &libvirtxml.NWFilterRuleIP{
Match: "no",
NWFilterRuleCommonMAC: libvirtxml.NWFilterRuleCommonMAC{SrcMACAddr: filterVariable("MAC")},
SrcIPAddr: filterVariable(managedInterfaceIPParameter),
Comment: "block-spoofed-ipv4",
},
})
// Only protocol-control messages that must remain available for IPv6
// liveness bypass the configurable firewall. Echo and ordinary ICMPv6 keep
// flowing through the provider/user policy layers.
priority := -910
for _, kind := range []uint{1, 2, 3, 4, 130, 131, 132, 133, 134, 135, 136, 137, 143} {
add(icmpv6TypeRule("accept", "in", priority, kind, "allow-required-inbound-icmpv6", ""))
priority++
}
for _, kind := range []uint{1, 2, 3, 4} {
add(icmpv6TypeRule("accept", "out", priority, kind, "allow-required-icmpv6", managedInterfaceIPv6Parameter))
priority++
add(icmpv6TypeRule("accept", "out", priority, kind, "allow-required-icmpv6", managedInterfaceIPv6LinkLocalParameter))
priority++
}
for _, kind := range []uint{130, 131, 132, 143} {
add(icmpv6TypeRule("accept", "out", priority, kind, "allow-mld", managedInterfaceIPv6LinkLocalParameter))
priority++
add(icmpv6LiteralSourceRule("accept", "out", priority, kind, "allow-mld", "::", "128"))
priority++
}
// Router solicitation and NDP may legitimately use :: or a link-local
// source before the static global address is fully usable. Neighbor
// advertisement targets are additionally constrained by the per-port bridge
// nftables guard; nwfilter cannot inspect that ICMPv6 payload field.
add(icmpv6TypeRule("accept", "out", priority, 133, "allow-ndp", managedInterfaceIPv6LinkLocalParameter))
priority++
add(icmpv6LiteralSourceRule("accept", "out", priority, 133, "allow-ndp", "::", "128"))
priority++
add(icmpv6TypeRule("accept", "out", priority, 135, "allow-ndp", managedInterfaceIPv6LinkLocalParameter))
priority++
add(icmpv6LiteralSourceRule("accept", "out", priority, 135, "allow-ndp", "::", "128"))
priority++
add(icmpv6TypeRule("accept", "out", priority, 135, "allow-ndp", managedInterfaceIPv6Parameter))
priority++
// Unlike solicitation and duplicate-address detection, an advertisement
// must originate from the assigned global or frozen link-local address. The
// bridge guard constrains its payload target to the same two identities.
add(icmpv6TypeRule("accept", "out", priority, 136, "allow-ndp", managedInterfaceIPv6Parameter))
priority++
add(icmpv6TypeRule("accept", "out", priority, 136, "allow-ndp", managedInterfaceIPv6LinkLocalParameter))
add(&libvirtxml.NWFilterRule{
Action: "drop", Direction: "out", Priority: -850, StateMatch: "false",
IPv6: &libvirtxml.NWFilterRuleIPv6{
Match: "no",
NWFilterRuleCommonMAC: libvirtxml.NWFilterRuleCommonMAC{SrcMACAddr: filterVariable("MAC")},
SrcIPAddr: filterVariable(managedInterfaceIPv6Parameter),
Comment: "block-spoofed-ipv6",
},
})
return entries
}
func platformPassEntries() []libvirtxml.NWFilterEntry {
entries := platformRequiredInboundPassEntries()
return append(entries, []libvirtxml.NWFilterEntry{
{Rule: &libvirtxml.NWFilterRule{Action: "accept", Direction: "in", Priority: 900, All: &libvirtxml.NWFilterRuleAll{Comment: "virt-platform-pass:in"}}},
{Rule: &libvirtxml.NWFilterRule{Action: "accept", Direction: "out", Priority: 901, ARP: &libvirtxml.NWFilterRuleARP{Comment: "virt-platform-pass:arp"}}},
{Rule: &libvirtxml.NWFilterRule{Action: "accept", Direction: "out", Priority: 902, RARP: &libvirtxml.NWFilterRuleRARP{Comment: "virt-platform-pass:rarp"}}},
{Rule: &libvirtxml.NWFilterRule{Action: "accept", Direction: "out", Priority: 903, IP: &libvirtxml.NWFilterRuleIP{Comment: "virt-platform-pass:ipv4"}}},
{Rule: &libvirtxml.NWFilterRule{Action: "accept", Direction: "out", Priority: 904, IPv6: &libvirtxml.NWFilterRuleIPv6{Comment: "virt-platform-pass:ipv6"}}},
{Rule: &libvirtxml.NWFilterRule{Action: "drop", Direction: "out", Priority: 999, All: &libvirtxml.NWFilterRuleAll{Comment: "virt-platform-drop:out"}}},
}...)
}
// platformRequiredInboundPassEntries preserves link-layer address resolution
// even when the user's IPv4/IPv6 ingress default is drop. These entries are
// retained when broad platform pass rules are replaced by user policy.
func platformRequiredInboundPassEntries() []libvirtxml.NWFilterEntry {
return []libvirtxml.NWFilterEntry{
{Rule: &libvirtxml.NWFilterRule{Action: "accept", Direction: "in", Priority: 790, StateMatch: "false", ARP: &libvirtxml.NWFilterRuleARP{Comment: "virt-platform-pass:in:arp"}}},
{Rule: &libvirtxml.NWFilterRule{Action: "accept", Direction: "in", Priority: 791, StateMatch: "false", RARP: &libvirtxml.NWFilterRuleRARP{Comment: "virt-platform-pass:in:rarp"}}},
}
}
func userFirewallDefaultEntries(defaultIn, defaultOut string) []libvirtxml.NWFilterEntry {
return []libvirtxml.NWFilterEntry{
// libvirt's generic <all> rule is projected only into the IPv4
// iptables-nft chain on supported hosts. Keep the ingress defaults
// family-specific so the IPv6 chain receives the same terminal policy.
{Rule: &libvirtxml.NWFilterRule{Action: defaultIn, Direction: "in", Priority: 800, IP: &libvirtxml.NWFilterRuleIP{Comment: "virt-default:in:ipv4"}}},
{Rule: &libvirtxml.NWFilterRule{Action: defaultIn, Direction: "in", Priority: 801, IPv6: &libvirtxml.NWFilterRuleIPv6{Comment: "virt-default:in:ipv6"}}},
{Rule: &libvirtxml.NWFilterRule{Action: defaultOut, Direction: "out", Priority: 802, ARP: &libvirtxml.NWFilterRuleARP{Comment: "virt-default:out:arp"}}},
{Rule: &libvirtxml.NWFilterRule{Action: defaultOut, Direction: "out", Priority: 803, RARP: &libvirtxml.NWFilterRuleRARP{Comment: "virt-default:out:rarp"}}},
{Rule: &libvirtxml.NWFilterRule{Action: defaultOut, Direction: "out", Priority: 804, IP: &libvirtxml.NWFilterRuleIP{Comment: "virt-default:out:ipv4"}}},
{Rule: &libvirtxml.NWFilterRule{Action: defaultOut, Direction: "out", Priority: 805, IPv6: &libvirtxml.NWFilterRuleIPv6{Comment: "virt-default:out:ipv6"}}},
}
}
func managedFilterSemanticsValid(document, expectedName string, policy PlatformNetworkPolicySnapshot) bool {
if ValidatePlatformNetworkPolicy(policy) != nil {
return false
}
var filter libvirtxml.NWFilter
if filter.Unmarshal(document) != nil || filter.Name != expectedName || filter.Chain != "root" {
return false
}
for _, entry := range filter.Entries {
if entry.Ref != nil {
return false
}
}
required := append([]libvirtxml.NWFilterEntry(nil), platformAntiSpoofEntries()...)
passes := platformPassEntries()
alwaysPasses := platformRequiredInboundPassEntries()
terminal := passes[len(passes)-1]
required = append(required, alwaysPasses...)
required = append(required, terminal)
priority := -500
for _, policyRule := range policy.Rules {
for _, direction := range policyRule.Directions {
wireDirection := "in"
if direction == "egress" {
wireDirection = "out"
}
for _, protocol := range policyRule.Protocols {
v4, v6 := platformDropRules(protocol, wireDirection, policyRule, priority)
required = append(required,
libvirtxml.NWFilterEntry{Rule: v4}, libvirtxml.NWFilterEntry{Rule: v6},
)
priority += 2
}
}
}
actual := make(map[string]int, len(filter.Entries))
allowedExact := make(map[string]struct{}, len(required)+len(passes))
allowedByComment := make(map[string]map[string]struct{}, len(required)+len(passes))
allowedEarlyAccept := make(map[string]struct{})
for _, entry := range append(append([]libvirtxml.NWFilterEntry(nil), required...), passes...) {
fingerprint := nwfilterRuleFingerprint(entry.Rule)
comment := nwfilterRuleComment(entry.Rule)
if fingerprint == "" || comment == "" {
return false
}
allowedExact[fingerprint] = struct{}{}
if allowedByComment[comment] == nil {
allowedByComment[comment] = make(map[string]struct{})
}
allowedByComment[comment][fingerprint] = struct{}{}
if entry.Rule.Action == "accept" && entry.Rule.Priority < 100 {
allowedEarlyAccept[fingerprint] = struct{}{}
}
}
userRules := make(map[int]struct{})
defaults := make(map[string]string)
for _, entry := range filter.Entries {
if entry.Rule == nil {
return false
}
fingerprint := nwfilterRuleFingerprint(entry.Rule)
comment := nwfilterRuleComment(entry.Rule)
if variants := allowedByComment[comment]; variants != nil {
if _, ok := variants[fingerprint]; !ok {
return false
}
}
if _, ok := allowedExact[fingerprint]; ok {
actual[fingerprint]++
continue
}
if entry.Rule.Priority < 100 && (entry.Rule.Action == "accept" ||
entry.Rule.Action == "continue" || entry.Rule.Action == "return") {
if _, ok := allowedEarlyAccept[fingerprint]; !ok {
return false
}
}
if index, ok := managedUserFirewallRuleIndex(entry.Rule); ok {
if _, duplicate := userRules[index]; duplicate {
return false
}
userRules[index] = struct{}{}
continue
}
if key, ok := managedUserFirewallDefaultKey(entry.Rule); ok {
if _, duplicate := defaults[key]; duplicate {
return false
}
defaults[key] = entry.Rule.Action
continue
}
return false
}
for _, entry := range required {
if actual[nwfilterRuleFingerprint(entry.Rule)] != 1 {
return false
}
}
userPolicy := len(userRules) > 0 || len(defaults) > 0
for _, entry := range passes[len(alwaysPasses) : len(passes)-1] {
count := actual[nwfilterRuleFingerprint(entry.Rule)]
if userPolicy && count != 0 || !userPolicy && count != 1 {
return false
}
}
if userPolicy && (!managedUserFirewallDefaultsValid(defaults) || len(userRules) > 100) {
return false
}
return true
}
func managedUserFirewallDefaultsValid(defaults map[string]string) bool {
if len(defaults) != len(userFirewallDefaultEntries("accept", "accept")) {
return false
}
inbound := defaults["virt-default:in:ipv4"]
if inbound == "" || defaults["virt-default:in:ipv6"] != inbound {
return false
}
outbound := defaults["virt-default:out:arp"]
if outbound == "" {
return false
}
for _, key := range []string{
"virt-default:out:rarp", "virt-default:out:ipv4", "virt-default:out:ipv6",
} {
if defaults[key] != outbound {
return false
}
}
return true
}
func managedUserFirewallRuleIndex(rule *libvirtxml.NWFilterRule) (int, bool) {
if rule == nil || rule.StateMatch != "" ||
(rule.Action != "accept" && rule.Action != "drop") ||
(rule.Direction != "in" && rule.Direction != "out") {
return 0, false
}
rawIndex, found := strings.CutPrefix(nwfilterRuleComment(rule), "virt-user:")
if !found {
return 0, false
}
index, err := strconv.Atoi(rawIndex)
if err != nil || index < 0 || index >= 100 ||
rawIndex != strconv.Itoa(index) || rule.Priority != 100+index {
return 0, false
}
protocols := 0
for _, present := range []bool{
rule.IP != nil, rule.TCP != nil, rule.UDP != nil, rule.ICMP != nil,
rule.IPv6 != nil, rule.TCPIPv6 != nil, rule.UDPIPv6 != nil, rule.ICMPv6 != nil,
} {
if present {
protocols++
}
}
if protocols != 1 || rule.ARP != nil || rule.RARP != nil || rule.MAC != nil ||
rule.VLAN != nil || rule.STP != nil || rule.UDPLite != nil ||
rule.ESP != nil || rule.AH != nil || rule.SCTP != nil || rule.All != nil ||
rule.IGMP != nil || rule.UDPLiteIPv6 != nil || rule.ESPIPv6 != nil ||
rule.AHIPv6 != nil || rule.SCTPIPv6 != nil || rule.AllIPv6 != nil ||
strings.Contains(nwfilterRuleFingerprint(rule), "$") {
return 0, false
}
return index, true
}
func managedUserFirewallDefaultKey(rule *libvirtxml.NWFilterRule) (string, bool) {
if rule == nil || (rule.Action != "accept" && rule.Action != "drop") {
return "", false
}
comment := nwfilterRuleComment(rule)
for _, entry := range userFirewallDefaultEntries(rule.Action, rule.Action) {
if nwfilterRuleComment(entry.Rule) == comment &&
nwfilterRuleFingerprint(entry.Rule) == nwfilterRuleFingerprint(rule) {
return comment, true
}
}
return "", false
}
func managedFilterBaselineValid(filter *libvirtxml.NWFilter) bool {
if filter == nil || filter.Chain != "root" {
return false
}
actual := make(map[string]int, len(filter.Entries))
for _, entry := range filter.Entries {
if entry.Ref != nil || entry.Rule == nil {
return false
}
actual[nwfilterRuleFingerprint(entry.Rule)]++
}
required := append([]libvirtxml.NWFilterEntry(nil), platformAntiSpoofEntries()...)
passes := platformPassEntries()
required = append(required, platformRequiredInboundPassEntries()...)
required = append(required, passes[len(passes)-1])
for _, entry := range required {
if actual[nwfilterRuleFingerprint(entry.Rule)] == 0 {
return false
}
}
return true
}
func nwfilterRuleFingerprint(rule *libvirtxml.NWFilterRule) string {
if rule == nil {
return ""
}
encoded, err := xml.Marshal(rule)
if err != nil {
return ""
}
return string(encoded)
}
func icmpv6TypeRule(action, direction string, priority int, kind uint, comment, sourceVariable string) *libvirtxml.NWFilterRule {
protocol := &libvirtxml.NWFilterRuleICMPIPv6{Type: libvirtxml.NWFilterField{Uint: &kind}, Comment: comment}
if action == "accept" && direction == "out" {
protocol.NWFilterRuleCommonIP.SrcMACAddr = filterVariable("MAC")
}
if sourceVariable != "" {
protocol.NWFilterRuleCommonIP.SrcIPAddr = filterVariable(sourceVariable)
}
return &libvirtxml.NWFilterRule{
Action: action, Direction: direction, Priority: priority, StateMatch: "false", ICMPv6: protocol,
}
}
func icmpv6LiteralSourceRule(action, direction string, priority int, kind uint,
comment, source, mask string) *libvirtxml.NWFilterRule {
rule := icmpv6TypeRule(action, direction, priority, kind, comment, "")
rule.ICMPv6.SrcIPAddr = libvirtxml.NWFilterField{Str: source}
rule.ICMPv6.SrcIPMask = libvirtxml.NWFilterField{Str: mask}
return rule
}
func filterVariable(name string) libvirtxml.NWFilterField {
// libvirtxml v1.12008.0 serializes Var using the Str member. Supplying the
// already-prefixed representation is therefore required for a functional
// libvirt variable reference rather than the invalid literal "$".
return libvirtxml.NWFilterField{Str: "$" + name}
}
func platformDropRules(protocol, direction string, policyRule PlatformNetworkPolicyRule, priority int) (*libvirtxml.NWFilterRule, *libvirtxml.NWFilterRule) {
from, to := uint(policyRule.PortFrom), uint(policyRule.PortTo)
ports := libvirtxml.NWFilterRuleCommonPort{
DstPortStart: libvirtxml.NWFilterField{Uint: &from},
DstPortEnd: libvirtxml.NWFilterField{Uint: &to},
}
v4 := &libvirtxml.NWFilterRule{Action: "drop", Direction: direction, Priority: priority, StateMatch: "false"}
v6 := &libvirtxml.NWFilterRule{Action: "drop", Direction: direction, Priority: priority + 1, StateMatch: "false"}
switch protocol {
case "tcp":
v4.TCP = &libvirtxml.NWFilterRuleTCP{NWFilterRuleCommonPort: ports, Comment: policyRule.ID}
v6.TCPIPv6 = &libvirtxml.NWFilterRuleTCPIPv6{NWFilterRuleCommonPort: ports, Comment: policyRule.ID}
case "udp":
v4.UDP = &libvirtxml.NWFilterRuleUDP{NWFilterRuleCommonPort: ports, Comment: policyRule.ID}
v6.UDPIPv6 = &libvirtxml.NWFilterRuleUDPIPv6{NWFilterRuleCommonPort: ports, Comment: policyRule.ID}
}
return v4, v6
}
func ValidateDomainDefinition(definition DomainDefinition) error {
if !uuidPattern.MatchString(definition.UUID) {
return NewError(ErrInvalid, "invalid_uuid", "uuid must be a canonical RFC 4122 value", nil)
}
if err := validateLibvirtDomainName(definition.Name, definition.UUID); err != nil {
return err
}
if !namePattern.MatchString(definition.DisplayName) {
return NewError(ErrInvalid, "invalid_name", "display name must contain 1-80 safe characters", nil)
}
if definition.VCPUs == 0 || definition.VCPUs > 512 || definition.MemoryMiB < 128 || definition.MemoryMiB > 16*1024*1024 {
return NewError(ErrInvalid, "invalid_resources", "domain CPU or memory is invalid", nil)
}
if err := validateAbsolutePath(definition.RootDiskPath, "root_disk_path"); err != nil {
return err
}
if !isVMOwnedRootVolumeName(definition.UUID, definition.RootVolumeName) || filepath.Base(definition.RootDiskPath) != definition.RootVolumeName {
return NewError(ErrInvalid, "invalid_root_volume", "root volume identity must match the managed root disk path", nil)
}
if definition.RootDiskFormat != "" && definition.RootDiskFormat != "qcow2" && definition.RootDiskFormat != "raw" {
return NewError(ErrInvalid, "invalid_disk_format", "root disk format must be qcow2 or raw", nil)
}
if definition.SeedDiskPath != "" {
if err := validateAbsolutePath(definition.SeedDiskPath, "seed_disk_path"); err != nil {
return err
}
}
if definition.Firmware.Mode != "uefi" || definition.Firmware.SecureBoot {
return NewError(ErrInvalid, "secure_boot_disabled", "UEFI is required and secure boot must remain disabled", nil)
}
if err := ValidatePublicNetworkIntent(definition.PublicNetwork); err != nil {
return err
}
for name, path := range map[string]string{
"firmware.loader": definition.Firmware.Loader, "firmware.nvram_template": definition.Firmware.NVRAMTemplate,
"firmware.nvram_path": definition.Firmware.NVRAMPath,
} {
if err := validateAbsolutePath(path, name); err != nil {
return err
}
}
if len(definition.Network) < 1 || len(definition.Network) > 2 ||
(definition.VPCPort == nil && len(definition.Network) != 1) ||
(definition.VPCPort != nil && len(definition.Network) != 2) {
return NewError(ErrInvalid, "invalid_network", "domain must contain one public interface and at most one declared VPC interface", nil)
}
for index, attachment := range definition.Network {
if (attachment.Bridge == "") == (attachment.Network == "") {
return NewError(ErrInvalid, "invalid_network", fmt.Sprintf("network[%d] must select exactly one bridge or network", index), nil)
}
selected := attachment.Bridge
if selected == "" {
selected = attachment.Network
}
if !netPattern.MatchString(selected) {
return NewError(ErrInvalid, "invalid_network", fmt.Sprintf("network[%d] has an invalid source", index), nil)
}
if attachment.MAC != "" {
parsed, err := net.ParseMAC(attachment.MAC)
if err != nil || len(parsed) != 6 {
return NewError(ErrInvalid, "invalid_mac", fmt.Sprintf("network[%d] has an invalid MAC address", index), err)
}
}
}
if definition.VPCPort != nil {
if err := validateVPCPortMetadata(*definition.VPCPort); err != nil {
return err
}
private := definition.Network[1]
if private.Bridge != definition.VPCPort.Bridge || private.Network != "" ||
!strings.EqualFold(private.MAC, definition.VPCPort.MAC) ||
strings.EqualFold(definition.Network[0].MAC, private.MAC) {
return NewError(ErrInvalid, "invalid_vpc_interface", "domain VPC interface does not match its durable metadata", nil)
}
}
if definition.FilterName != "" && !namePattern.MatchString(definition.FilterName) {
return NewError(ErrInvalid, "invalid_filter_name", "network filter name is invalid", nil)
}
if err := ValidatePlatformNetworkPolicy(definition.PlatformNetworkPolicy); err != nil {
return err
}
return nil
}
// LibvirtDomainName derives the host-local libvirt identity from authenticated
// ownership and the canonical VM UUID. It is never accepted from request JSON.
func LibvirtDomainName(userID int64, uuid string) (string, error) {
if userID <= 0 {
return "", NewError(ErrInvalid, "invalid_owner_id", "authenticated owner id must be positive", nil)
}
if !uuidPattern.MatchString(uuid) {
return "", NewError(ErrInvalid, "invalid_uuid", "uuid must be a canonical RFC 4122 value", nil)
}
compactUUID := strings.ReplaceAll(strings.ToLower(uuid), "-", "")
return strconv.FormatInt(userID, 10) + ":vm-" + compactUUID[:12], nil
}
func validateLibvirtDomainName(name, uuid string) error {
if !uuidPattern.MatchString(uuid) {
return NewError(ErrInvalid, "invalid_uuid", "uuid must be a canonical RFC 4122 value", nil)
}
owner, suffix, found := strings.Cut(name, ":")
ownerID, err := strconv.ParseInt(owner, 10, 64)
compactUUID := strings.ReplaceAll(strings.ToLower(uuid), "-", "")
if !found || err != nil || ownerID <= 0 || owner != strconv.FormatInt(ownerID, 10) || suffix != "vm-"+compactUUID[:12] {
return NewError(ErrInvalid, "invalid_domain_name", "libvirt domain name must match the authenticated owner and VM UUID", err)
}
return nil
}
func ValidatePlatformNetworkPolicy(policy PlatformNetworkPolicySnapshot) error {
if policy.SchemaVersion != 1 || policy.BasePolicyVersion == 0 || len(policy.Rules) == 0 || len(policy.Rules) > 70 || !digestPattern.MatchString(policy.Digest) {
return NewError(ErrInvalid, "invalid_platform_network_policy", "platform network policy snapshot is invalid", nil)
}
seen := make(map[string]struct{}, len(policy.Rules))
for _, rule := range policy.Rules {
if !policyIdentifier.MatchString(rule.ID) || len(rule.Label) == 0 || len(rule.Label) > 120 || len(rule.Reason) == 0 || len(rule.Reason) > 500 || rule.PortFrom < 1 || rule.PortTo < rule.PortFrom {
return NewError(ErrInvalid, "invalid_platform_network_policy", "platform network policy rule is invalid", nil)
}
if _, exists := seen[rule.ID]; exists {
return NewError(ErrInvalid, "invalid_platform_network_policy", "platform network policy rule IDs must be unique", nil)
}
seen[rule.ID] = struct{}{}
if rule.Category != "permanent" && rule.Category != "default" && rule.Category != "test" {
return NewError(ErrInvalid, "invalid_platform_network_policy", "platform network policy rule category is invalid", nil)
}
if !validPolicyValues(rule.Protocols, "tcp", "udp") || !validPolicyValues(rule.Directions, "ingress", "egress") {
return NewError(ErrInvalid, "invalid_platform_network_policy", "platform network policy protocols or directions are invalid", nil)
}
}
document := struct {
SchemaVersion uint64 `json:"schema_version"`
BasePolicyVersion uint64 `json:"base_policy_version"`
CatalogRevision uint64 `json:"catalog_revision"`
Rules []PlatformNetworkPolicyRule `json:"rules"`
}{
SchemaVersion: policy.SchemaVersion, BasePolicyVersion: policy.BasePolicyVersion,
CatalogRevision: policy.CatalogRevision, Rules: policy.Rules,
}
encoded, err := json.Marshal(document)
if err != nil {
return NewError(ErrInvalid, "invalid_platform_network_policy", "platform network policy cannot be encoded", err)
}
digest := sha256.Sum256(encoded)
if hex.EncodeToString(digest[:]) != policy.Digest {
return NewError(ErrInvalid, "invalid_platform_network_policy_digest", "platform network policy digest does not match its content", nil)
}
return nil
}
func validateGuestCredentials(publicKey, password string) error {
if publicKey == "" && password == "" {
return NewError(ErrInvalid, "guest_credentials_required", "root_password or guest_ssh_public_key is required", nil)
}
if len(publicKey) > 16384 || strings.ContainsAny(publicKey, "\r\n\x00") {
return NewError(ErrInvalid, "invalid_ssh_public_key", "guest SSH public key must be one bounded line", nil)
}
if password != "" {
if len(password) < 12 || len(password) > 128 {
return NewError(ErrInvalid, "invalid_root_password", "root password must contain 12-128 printable ASCII characters", nil)
}
var upper, lower, digit, symbol bool
for _, value := range []byte(password) {
if value < 0x21 || value > 0x7e {
return NewError(ErrInvalid, "invalid_root_password", "root password must contain printable ASCII without spaces", nil)
}
switch {
case value >= 'A' && value <= 'Z':
upper = true
case value >= 'a' && value <= 'z':
lower = true
case value >= '0' && value <= '9':
digit = true
default:
symbol = true
}
}
if !upper || !lower || !digit || !symbol {
return NewError(ErrInvalid, "invalid_root_password", "root password must contain upper, lower, digit, and symbol characters", nil)
}
}
return nil
}
func validPolicyValues(values []string, allowed ...string) bool {
if len(values) == 0 {
return false
}
allow := make(map[string]struct{}, len(allowed))
for _, value := range allowed {
allow[value] = struct{}{}
}
seen := make(map[string]struct{}, len(values))
for _, value := range values {
if _, ok := allow[value]; !ok {
return false
}
if _, duplicate := seen[value]; duplicate {
return false
}
seen[value] = struct{}{}
}
return true
}
func ValidateTemplateSnapshot(templateID string, revision uint64, generationToken string) error {
if !templateIDPattern.MatchString(templateID) {
return NewError(ErrInvalid, "invalid_template_id", "template_id is invalid", nil)
}
if revision == 0 {
return NewError(ErrInvalid, "invalid_template_revision", "template_revision must be positive", nil)
}
if !generationTokenPattern.MatchString(generationToken) {
return NewError(ErrInvalid, "invalid_template_generation_token", "template_generation_token must contain 16-128 URL-safe characters", nil)
}
return nil
}
// NormalizeStartupScript implements the immutable image-template contract:
// UTF-8, no NUL, CRLF converted to LF, no trimming, and at most 32 KiB after
// newline normalization.
func NormalizeStartupScript(script string) (string, error) {
if !utf8.ValidString(script) {
return "", NewError(ErrInvalid, "startup_script_invalid_utf8", "startup_script must be valid UTF-8", nil)
}
if strings.ContainsRune(script, 0) {
return "", NewError(ErrInvalid, "startup_script_contains_nul", "startup_script cannot contain NUL", nil)
}
normalized := strings.ReplaceAll(script, "\r\n", "\n")
if len(normalized) > 32<<10 {
return "", NewError(ErrInvalid, "startup_script_too_large", "startup_script exceeds 32768 bytes", nil)
}
return normalized, nil
}
func validateAbsolutePath(path, field string) error {
if path == "" || strings.ContainsRune(path, 0) || !filepath.IsAbs(path) || filepath.Clean(path) != path {
return NewError(ErrInvalid, "invalid_path", field+" must be a clean absolute path", nil)
}
return nil
}
func metadataFromXML(document string) (VMMetadata, error) {
var domain libvirtxml.Domain
if err := domain.Unmarshal(document); err != nil {
return VMMetadata{}, fmt.Errorf("parse libvirt domain XML: %w", err)
}
if domain.OS == nil || domain.OS.Type == nil {
return VMMetadata{}, errors.New("domain XML is missing OS type")
}
metadata := VMMetadata{
UUID: domain.UUID, Name: domain.Name, Description: domain.Description,
Machine: domain.OS.Type.Machine, Firmware: "bios",
}
if domain.Metadata != nil && domain.Metadata.XML != "" {
var stored domainMetadataXML
if err := xml.Unmarshal([]byte(domain.Metadata.XML), &stored); err != nil {
return VMMetadata{}, fmt.Errorf("parse virt-cloud domain metadata: %w", err)
}
if stored.DisplayName != "" {
metadata.Name = stored.DisplayName
}
metadata.DiskGiB = stored.DiskGiB
metadata.BandwidthMbps = stored.BandwidthMbps
metadata.Hostname = stored.Hostname
public, err := stored.PublicNetwork.public()
if err != nil {
return VMMetadata{}, fmt.Errorf("parse virt-cloud public network metadata: %w", err)
}
metadata.PublicNetwork = public
metadata.TemplateID = stored.TemplateID
if stored.VPCPort != nil {
value := stored.VPCPort.public()
metadata.VPCPort = &value
}
}
if domain.VCPU != nil {
metadata.VCPUs = domain.VCPU.Value
}
if domain.Memory != nil {
metadata.MemoryMiB = memoryToMiB(domain.Memory.Value, domain.Memory.Unit)
}
if domain.OS.Loader != nil {
metadata.Firmware = "uefi"
metadata.SecureBoot = strings.EqualFold(domain.OS.Loader.Secure, "yes")
}
if domain.Devices != nil {
for _, disk := range domain.Devices.Disks {
item := Disk{}
if disk.Source != nil && disk.Source.File != nil {
item.Path = disk.Source.File.File
}
if disk.Target != nil {
item.Device = disk.Target.Dev
}
if disk.Driver != nil {
item.Format = disk.Driver.Type
}
metadata.Disks = append(metadata.Disks, item)
}
for _, iface := range domain.Devices.Interfaces {
item := Interface{LinkUp: iface.Link == nil || iface.Link.State != "down"}
if iface.MAC != nil {
item.MAC = iface.MAC.Address
}
if iface.Source != nil {
if iface.Source.Bridge != nil {
item.Bridge = iface.Source.Bridge.Bridge
}
if iface.Source.Network != nil {
item.Network = iface.Source.Network.Network
}
}
metadata.Interfaces = append(metadata.Interfaces, item)
}
}
return metadata, nil
}
func domainVPCPortFromPublic(value VPCPortMetadata) domainVPCPortMetadataXML {
return domainVPCPortMetadataXML{
PortKey: value.PortKey, VPCKey: value.VPCKey, PrivateIP: value.PrivateIP,
CIDR: value.CIDR, Gateway: value.Gateway, MAC: value.MAC,
Bridge: value.Bridge, HostRevision: value.HostRevision,
HostDigest: value.HostDigest,
}
}
func (value domainVPCPortMetadataXML) public() VPCPortMetadata {
return VPCPortMetadata{
PortKey: value.PortKey, VPCKey: value.VPCKey, PrivateIP: value.PrivateIP,
CIDR: value.CIDR, Gateway: value.Gateway, MAC: value.MAC,
Bridge: value.Bridge, HostRevision: value.HostRevision,
HostDigest: value.HostDigest,
}
}
func domainPublicNetworkFromPublic(value publicnetwork.Intent) domainPublicNetworkXML {
return domainPublicNetworkXML{
Contract: value.Contract,
NetworkSelector: value.NetworkSelector,
IPv4: domainPublicAddressFromPublic(value.IPv4),
IPv6: domainPublicAddressFromPublic(value.IPv6),
DNSServers: append([]string(nil), value.DNSServers...),
}
}
func domainPublicAddressFromPublic(value publicnetwork.AddressIntent) domainPublicAddressXML {
return domainPublicAddressXML{
PoolKey: value.PoolKey, PoolCIDR: value.PoolCIDR,
AddressCIDR: value.AddressCIDR, Gateway: value.Gateway,
GatewayOnLink: value.GatewayOnLink,
}
}
func (value domainPublicNetworkXML) public() (publicnetwork.Intent, error) {
result := publicnetwork.Intent{
Contract: value.Contract,
NetworkSelector: value.NetworkSelector,
IPv4: value.IPv4.public(),
IPv6: value.IPv6.public(),
DNSServers: append([]string(nil), value.DNSServers...),
}
if err := ValidatePublicNetworkIntent(result); err != nil {
return publicnetwork.Intent{}, err
}
return result, nil
}
func (value domainPublicNetworkXML) publicMust() publicnetwork.Intent {
result, _ := value.public()
return result
}
func (value domainPublicAddressXML) public() publicnetwork.AddressIntent {
return publicnetwork.AddressIntent{
PoolKey: value.PoolKey, PoolCIDR: value.PoolCIDR,
AddressCIDR: value.AddressCIDR, Gateway: value.Gateway,
GatewayOnLink: value.GatewayOnLink,
}
}
func publicNetworkEqual(first, second publicnetwork.Intent) bool {
return first.Contract == second.Contract && first.NetworkSelector == second.NetworkSelector &&
first.IPv4 == second.IPv4 && first.IPv6 == second.IPv6 &&
slices.Equal(first.DNSServers, second.DNSServers)
}
func publicNetworkAddressConflict(first, second publicnetwork.Intent) bool {
first4, err14 := publicAddress(first.IPv4.AddressCIDR, 4)
second4, err24 := publicAddress(second.IPv4.AddressCIDR, 4)
first6, err16 := publicAddress(first.IPv6.AddressCIDR, 6)
second6, err26 := publicAddress(second.IPv6.AddressCIDR, 6)
return err14 == nil && err24 == nil && first4 == second4 ||
err16 == nil && err26 == nil && first6 == second6
}
func managedPublicInterfaceIndex(definition *libvirtxml.Domain,
filterName string, public publicnetwork.Intent) (int, bool) {
if definition == nil || definition.Devices == nil {
return -1, false
}
match := -1
for index := range definition.Devices.Interfaces {
if !managedInterfaceFilterIPMatches(
&definition.Devices.Interfaces[index], filterName, public,
) {
continue
}
if match >= 0 {
return -1, false
}
match = index
}
return match, match >= 0
}
func managedVPCInterfaceIndex(definition *libvirtxml.Domain,
port *domainVPCPortMetadataXML) (int, bool) {
if definition == nil || definition.Devices == nil || port == nil {
return -1, false
}
match := -1
for index := range definition.Devices.Interfaces {
iface := &definition.Devices.Interfaces[index]
if iface.MAC == nil || !strings.EqualFold(iface.MAC.Address, port.MAC) ||
iface.Source == nil || iface.Source.Bridge == nil ||
iface.Source.Bridge.Bridge != port.Bridge || iface.Source.Network != nil ||
!managedVPCInterfaceFilterIPMatches(iface, port.PrivateIP) {
continue
}
if match >= 0 {
return -1, false
}
match = index
}
return match, match >= 0
}
func managedNetworkLayoutMatches(definition *libvirtxml.Domain,
metadata *domainMetadataXML) bool {
if definition == nil || definition.Devices == nil || metadata == nil {
return false
}
publicIndex, publicFound := managedPublicInterfaceIndex(
definition, networkFilterName(definition.UUID), mustPublicNetworkMetadata(metadata),
)
if !publicFound {
return false
}
publicInterface := definition.Devices.Interfaces[publicIndex]
if publicInterface.Target == nil || publicInterface.Target.Dev != publicInterfaceTarget(definition.UUID) {
return false
}
if metadata.VPCPort == nil {
return len(definition.Devices.Interfaces) == 1 && publicIndex == 0
}
privateIndex, privateFound := managedVPCInterfaceIndex(definition, metadata.VPCPort)
return privateFound && len(definition.Devices.Interfaces) == 2 &&
publicIndex != privateIndex
}
func mustPublicNetworkMetadata(metadata *domainMetadataXML) publicnetwork.Intent {
if metadata == nil {
return publicnetwork.Intent{}
}
value, _ := metadata.PublicNetwork.public()
return value
}
func memoryToMiB(value uint, unit string) uint64 {
switch strings.ToLower(unit) {
case "b", "bytes":
return uint64(value) / (1024 * 1024)
case "kb", "kib", "":
return uint64(value) / 1024
case "mb", "mib":
return uint64(value)
case "gb", "gib":
return uint64(value) * 1024
default:
return 0
}
}