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 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 } }