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.
1439 lines
58 KiB
Go
1439 lines
58 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{
|
|
{Rule: &libvirtxml.NWFilterRule{Action: defaultIn, Direction: "in", Priority: 800, All: &libvirtxml.NWFilterRuleAll{Comment: "virt-default:in"}}},
|
|
{Rule: &libvirtxml.NWFilterRule{Action: defaultOut, Direction: "out", Priority: 801, ARP: &libvirtxml.NWFilterRuleARP{Comment: "virt-default:out:arp"}}},
|
|
{Rule: &libvirtxml.NWFilterRule{Action: defaultOut, Direction: "out", Priority: 802, RARP: &libvirtxml.NWFilterRuleRARP{Comment: "virt-default:out:rarp"}}},
|
|
{Rule: &libvirtxml.NWFilterRule{Action: defaultOut, Direction: "out", Priority: 803, IP: &libvirtxml.NWFilterRuleIP{Comment: "virt-default:out:ipv4"}}},
|
|
{Rule: &libvirtxml.NWFilterRule{Action: defaultOut, Direction: "out", Priority: 804, 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]struct{})
|
|
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] = struct{}{}
|
|
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 && (len(defaults) != 5 || len(userRules) > 100) {
|
|
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
|
|
}
|
|
}
|