You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/agent/hypervisor/domain_dual_stack_test.go

422 lines
14 KiB
Go

package hypervisor
import (
"encoding/xml"
"strings"
"testing"
"git.luoli.live/root/virt/agent/publicnetwork"
"libvirt.org/go/libvirtxml"
)
func dualStackPublicNetwork() publicnetwork.Intent {
return publicnetwork.Intent{
Contract: publicnetwork.ContractVersion,
NetworkSelector: "bridge:br0",
IPv4: publicnetwork.AddressIntent{
PoolKey: "0123456789abcdef0123456789abcdef", PoolCIDR: "8.8.8.0/24",
AddressCIDR: "8.8.8.10/24", Gateway: "8.8.8.1",
},
IPv6: publicnetwork.AddressIntent{
PoolKey: "abcdef0123456789abcdef0123456789", PoolCIDR: "2404:c140:156:3a::/64",
AddressCIDR: "2404:c140:156:3a::1000/64", Gateway: "2404:c140:156::1",
GatewayOnLink: true,
},
DNSServers: []string{"1.1.1.1", "2606:4700:4700::1111"},
}
}
func TestDomainPublicInterfaceBindsBothAddressFamilies(t *testing.T) {
definition := validDomainDefinition()
definition.PublicNetwork = dualStackPublicNetwork()
document, err := BuildDomainXML(definition)
if err != nil {
t.Fatal(err)
}
var domain libvirtxml.Domain
if err := domain.Unmarshal(document); err != nil {
t.Fatal(err)
}
if len(domain.Devices.Interfaces) != 1 || !managedInterfaceFilterIPMatches(
&domain.Devices.Interfaces[0], definition.FilterName, definition.PublicNetwork,
) {
t.Fatalf("dual-stack filter binding is missing: %s", document)
}
parameters := domain.Devices.Interfaces[0].FilterRef.Parameters
if len(parameters) != 3 || parameters[0].Name != "IP" || parameters[0].Value != "8.8.8.10" ||
parameters[1].Name != "IPV6" || parameters[1].Value != "2404:c140:156:3a::1000" ||
parameters[2].Name != "IPV6_LINK_LOCAL" || parameters[2].Value != "fe80::5054:ff:fe12:3456" {
t.Fatalf("public filter parameters = %#v", parameters)
}
}
func TestDomainMetadataStoresOneTypedPublicNetworkContract(t *testing.T) {
definition := validDomainDefinition()
definition.PublicNetwork = dualStackPublicNetwork()
document, err := BuildDomainXML(definition)
if err != nil {
t.Fatal(err)
}
var domain libvirtxml.Domain
if err := domain.Unmarshal(document); err != nil {
t.Fatal(err)
}
if domain.Metadata == nil || strings.Contains(domain.Metadata.XML, "<public-ip-cidr>") ||
strings.Contains(domain.Metadata.XML, "<public-pool-key>") {
t.Fatalf("legacy public metadata escaped: %s", domain.Metadata.XML)
}
var stored domainMetadataXML
if err := xml.Unmarshal([]byte(domain.Metadata.XML), &stored); err != nil {
t.Fatal(err)
}
if stored.PublicNetwork.Contract != publicnetwork.ContractVersion ||
stored.PublicNetwork.IPv4.AddressCIDR != definition.PublicNetwork.IPv4.AddressCIDR ||
stored.PublicNetwork.IPv6.AddressCIDR != definition.PublicNetwork.IPv6.AddressCIDR {
t.Fatalf("typed public metadata = %#v", stored.PublicNetwork)
}
parsed, err := metadataFromXML(document)
if err != nil {
t.Fatal(err)
}
if parsed.PublicNetwork.IPv6 != definition.PublicNetwork.IPv6 {
t.Fatalf("metadata round trip = %#v", parsed.PublicNetwork)
}
}
func TestPlatformFilterOwnsDualStackAntiSpoofBaseline(t *testing.T) {
public := dualStackPublicNetwork()
document, err := BuildPlatformFilterXML(
"virt-123e4567-e89b-42d3-a456-426614174000", public, testPlatformPolicy(),
)
if err != nil {
t.Fatal(err)
}
if strings.Contains(document, "clean-traffic") {
t.Fatalf("filter still delegates its anti-spoof baseline: %s", document)
}
for _, required := range []string{
`srcipaddr="$IP"`, `srcipaddr="$IPV6"`, "<icmpv6", `type="0x87"`, `type="0x88"`,
`comment="block-guest-router-advertisement"`, `comment="block-guest-redirect"`,
`comment="block-dhcpv6-server"`, `srcportstart="0x223"`, `dstportstart="0x222"`,
} {
if !strings.Contains(document, required) {
t.Fatalf("filter is missing %q: %s", required, document)
}
}
}
func TestPlatformFilterBindsEveryAllowedOutboundICMPv6FrameToGuestMAC(t *testing.T) {
document, err := BuildPlatformFilterXML(
"virt-123e4567-e89b-42d3-a456-426614174000", dualStackPublicNetwork(), testPlatformPolicy(),
)
if err != nil {
t.Fatal(err)
}
var filter libvirtxml.NWFilter
if err := filter.Unmarshal(document); err != nil {
t.Fatal(err)
}
seenNDP := map[uint]bool{}
for _, entry := range filter.Entries {
rule := entry.Rule
if rule == nil || rule.Action != "accept" || rule.Direction != "out" || rule.ICMPv6 == nil {
continue
}
if rule.ICMPv6.SrcMACAddr.Var != "MAC" && rule.ICMPv6.SrcMACAddr.Str != "$MAC" {
t.Fatalf("outbound ICMPv6 allow rule has no guest MAC binding: %#v", rule)
}
if rule.ICMPv6.Type.Uint != nil {
seenNDP[*rule.ICMPv6.Type.Uint] = true
if *rule.ICMPv6.Type.Uint == 136 && filterFieldVariable(rule.ICMPv6.SrcIPAddr) != "IPV6" &&
filterFieldVariable(rule.ICMPv6.SrcIPAddr) != "IPV6_LINK_LOCAL" {
t.Fatalf("neighbor advertisement is not bound to the assigned IPv6 source: %#v", rule)
}
}
}
for _, kind := range []uint{133, 135, 136} {
if !seenNDP[kind] {
t.Fatalf("required NDP type %d was not allowed", kind)
}
}
}
func TestPlatformFilterUsesNegativeAntiSpoofChecksWithoutBypassingPolicy(t *testing.T) {
document, err := BuildPlatformFilterXML(
"virt-123e4567-e89b-42d3-a456-426614174000", dualStackPublicNetwork(), testPlatformPolicy(),
)
if err != nil {
t.Fatal(err)
}
var filter libvirtxml.NWFilter
if err := filter.Unmarshal(document); err != nil {
t.Fatal(err)
}
seen := map[string]bool{}
for _, entry := range filter.Entries {
rule := entry.Rule
if rule == nil || rule.Direction != "out" {
continue
}
switch {
case rule.MAC != nil && rule.MAC.Comment == "block-spoofed-mac":
seen["mac"] = rule.Action == "drop" && rule.MAC.Match == "no" && filterFieldVariable(rule.MAC.SrcMACAddr) == "MAC"
case rule.IP != nil && rule.IP.Comment == "block-spoofed-ipv4":
seen["ipv4"] = rule.Action == "drop" && rule.IP.Match == "no" &&
filterFieldVariable(rule.IP.SrcMACAddr) == "MAC" && filterFieldVariable(rule.IP.SrcIPAddr) == "IP"
case rule.IPv6 != nil && rule.IPv6.Comment == "block-spoofed-ipv6":
seen["ipv6"] = rule.Action == "drop" && rule.IPv6.Match == "no" &&
filterFieldVariable(rule.IPv6.SrcMACAddr) == "MAC" && filterFieldVariable(rule.IPv6.SrcIPAddr) == "IPV6"
case (rule.IP != nil && rule.IP.Comment == "allow-assigned-ipv4") ||
(rule.IPv6 != nil && rule.IPv6.Comment == "allow-assigned-ipv6"):
t.Fatalf("anti-spoof baseline accepts ordinary address traffic before policy rules: %#v", rule)
}
}
for _, name := range []string{"mac", "ipv4", "ipv6"} {
if !seen[name] {
t.Fatalf("negative %s anti-spoof guard is missing: %s", name, document)
}
}
}
func TestPlatformFilterAllowsRequiredMLDWithGuestMACBinding(t *testing.T) {
document, err := BuildPlatformFilterXML(
"virt-123e4567-e89b-42d3-a456-426614174000", dualStackPublicNetwork(), testPlatformPolicy(),
)
if err != nil {
t.Fatal(err)
}
var filter libvirtxml.NWFilter
if err := filter.Unmarshal(document); err != nil {
t.Fatal(err)
}
seen := map[uint]bool{}
for _, entry := range filter.Entries {
rule := entry.Rule
if rule == nil || rule.Action != "accept" || rule.Direction != "out" ||
rule.ICMPv6 == nil || rule.ICMPv6.Comment != "allow-mld" || rule.ICMPv6.Type.Uint == nil {
continue
}
if filterFieldVariable(rule.ICMPv6.SrcMACAddr) != "MAC" {
t.Fatalf("MLD type %d is not bound to the guest MAC", *rule.ICMPv6.Type.Uint)
}
seen[*rule.ICMPv6.Type.Uint] = true
}
for _, kind := range []uint{130, 131, 132, 143} {
if !seen[kind] {
t.Fatalf("required MLD type %d is missing", kind)
}
}
}
func TestPlatformFilterNeverAllowsOutboundICMPv6WithAnUnrestrictedSource(t *testing.T) {
document, err := BuildPlatformFilterXML(
"virt-123e4567-e89b-42d3-a456-426614174000", dualStackPublicNetwork(), testPlatformPolicy(),
)
if err != nil {
t.Fatal(err)
}
var filter libvirtxml.NWFilter
if err := filter.Unmarshal(document); err != nil {
t.Fatal(err)
}
seen := map[uint]bool{}
sources := map[uint]map[string]bool{}
for _, entry := range filter.Entries {
rule := entry.Rule
if rule == nil || rule.Action != "accept" || rule.Direction != "out" ||
rule.ICMPv6 == nil || rule.ICMPv6.Type.Uint == nil {
continue
}
kind := *rule.ICMPv6.Type.Uint
seen[kind] = true
if filterFieldVariable(rule.ICMPv6.SrcMACAddr) != "MAC" {
t.Fatalf("ICMPv6 type %d is not bound to the interface MAC", kind)
}
source := rule.ICMPv6.SrcIPAddr.Str
variable := filterFieldVariable(rule.ICMPv6.SrcIPAddr)
if variable != "" {
if sources[kind] == nil {
sources[kind] = map[string]bool{}
}
sources[kind][variable] = true
}
mask := rule.ICMPv6.SrcIPMask.Str
switch kind {
case 1, 2, 3, 4:
if variable != "IPV6" && variable != "IPV6_LINK_LOCAL" {
t.Fatalf("ICMPv6 type %d bypasses the assigned IPv6 source guard: %#v", kind, rule.ICMPv6)
}
case 136:
if variable != "IPV6" && variable != "IPV6_LINK_LOCAL" {
t.Fatalf("neighbor advertisement bypasses the frozen IPv6 identities: %#v", rule.ICMPv6)
}
case 130, 131, 132, 133, 135, 143:
if variable != "IPV6" && variable != "IPV6_LINK_LOCAL" && !(source == "::" && mask == "128") {
t.Fatalf("ICMPv6 type %d has an unrestricted source: %#v", kind, rule.ICMPv6)
}
default:
t.Fatalf("unexpected early outbound ICMPv6 type %d", kind)
}
}
if strings.Contains(document, `srcipaddr="fe80::"`) || strings.Contains(document, `srcipmask="10"`) {
t.Fatalf("filter allows an arbitrary link-local source: %s", document)
}
for _, kind := range []uint{1, 2, 3, 4, 130, 131, 132, 133, 135, 136, 143} {
if !seen[kind] {
t.Fatalf("required constrained ICMPv6 type %d is missing", kind)
}
}
for _, kind := range []uint{1, 2, 3, 4, 136} {
if !sources[kind]["IPV6"] || !sources[kind]["IPV6_LINK_LOCAL"] {
t.Fatalf("ICMPv6 type %d is missing one frozen global/link-local source: %#v", kind, sources[kind])
}
}
}
func TestPlatformFilterDropsUnapprovedOutboundLayerTwoTraffic(t *testing.T) {
document, err := BuildPlatformFilterXML(
"virt-123e4567-e89b-42d3-a456-426614174000", dualStackPublicNetwork(), testPlatformPolicy(),
)
if err != nil {
t.Fatal(err)
}
var filter libvirtxml.NWFilter
if err := filter.Unmarshal(document); err != nil {
t.Fatal(err)
}
allowed := map[string]bool{}
dropAll := false
for _, entry := range filter.Entries {
rule := entry.Rule
if rule == nil || rule.Direction != "out" {
continue
}
if rule.Action == "accept" {
switch {
case rule.ARP != nil && strings.HasPrefix(rule.ARP.Comment, "virt-platform-pass:"):
allowed["arp"] = true
case rule.RARP != nil && strings.HasPrefix(rule.RARP.Comment, "virt-platform-pass:"):
allowed["rarp"] = true
case rule.IP != nil && strings.HasPrefix(rule.IP.Comment, "virt-platform-pass:"):
allowed["ipv4"] = true
case rule.IPv6 != nil && strings.HasPrefix(rule.IPv6.Comment, "virt-platform-pass:"):
allowed["ipv6"] = true
case rule.All != nil:
t.Fatalf("outbound all-traffic accept bypasses the L2 allowlist: %#v", rule)
}
}
if rule.Action == "drop" && rule.All != nil && rule.All.Comment == "virt-platform-drop:out" {
dropAll = true
}
}
for _, protocol := range []string{"arp", "rarp", "ipv4", "ipv6"} {
if !allowed[protocol] {
t.Fatalf("outbound %s pass rule is missing", protocol)
}
}
if !dropAll {
t.Fatal("terminal outbound L2 drop rule is missing")
}
}
func filterFieldVariable(field libvirtxml.NWFilterField) string {
if field.Var != "" {
return field.Var
}
return strings.TrimPrefix(field.Str, "$")
}
func TestManagedFilterSemanticsRejectsCommentOnlyForgeries(t *testing.T) {
const name = "virt-123e4567-e89b-42d3-a456-426614174000"
policy := testPlatformPolicy()
document, err := BuildPlatformFilterXML(name, dualStackPublicNetwork(), policy)
if err != nil {
t.Fatal(err)
}
if !managedFilterSemanticsValid(document, name, policy) {
t.Fatal("valid project-owned filter was rejected")
}
for label, mutate := range map[string]func(*libvirtxml.NWFilterRule){
"action": func(rule *libvirtxml.NWFilterRule) {
if rule.MAC != nil && rule.MAC.Comment == "block-spoofed-mac" {
rule.Action = "accept"
}
},
"direction": func(rule *libvirtxml.NWFilterRule) {
if rule.IP != nil && rule.IP.Comment == "block-spoofed-ipv4" {
rule.Direction = "in"
}
},
"protocol": func(rule *libvirtxml.NWFilterRule) {
if rule.ICMPv6 != nil && rule.ICMPv6.Comment == "block-guest-router-advertisement" {
rule.IPv6 = &libvirtxml.NWFilterRuleIPv6{Comment: rule.ICMPv6.Comment}
rule.ICMPv6 = nil
}
},
"variable": func(rule *libvirtxml.NWFilterRule) {
if rule.IPv6 != nil && rule.IPv6.Comment == "block-spoofed-ipv6" {
rule.IPv6.SrcIPAddr = filterVariable("IP")
}
},
"platform-policy": func(rule *libvirtxml.NWFilterRule) {
if rule.TCP != nil && rule.TCP.Comment == "ssh" {
rule.Action = "accept"
}
},
} {
t.Run(label, func(t *testing.T) {
var filter libvirtxml.NWFilter
if err := filter.Unmarshal(document); err != nil {
t.Fatal(err)
}
for _, entry := range filter.Entries {
if entry.Rule != nil {
mutate(entry.Rule)
}
}
forged, err := filter.Marshal()
if err != nil {
t.Fatal(err)
}
if managedFilterSemanticsValid(forged, name, policy) {
t.Fatalf("%s forgery with unchanged comments was accepted: %s", label, forged)
}
})
}
var extra libvirtxml.NWFilter
if err := extra.Unmarshal(document); err != nil {
t.Fatal(err)
}
extra.Entries = append(extra.Entries, libvirtxml.NWFilterEntry{Rule: &libvirtxml.NWFilterRule{
Action: "accept", Direction: "out", Priority: 200,
All: &libvirtxml.NWFilterRuleAll{Comment: "unowned-bypass"},
}})
forged, err := extra.Marshal()
if err != nil {
t.Fatal(err)
}
if managedFilterSemanticsValid(forged, name, policy) {
t.Fatal("unowned high-priority accept rule was accepted")
}
var missingPass libvirtxml.NWFilter
if err := missingPass.Unmarshal(document); err != nil {
t.Fatal(err)
}
for index, entry := range missingPass.Entries {
if entry.Rule != nil && nwfilterRuleComment(entry.Rule) == "virt-platform-pass:ipv6" {
missingPass.Entries = append(missingPass.Entries[:index], missingPass.Entries[index+1:]...)
break
}
}
forged, err = missingPass.Marshal()
if err != nil {
t.Fatal(err)
}
if managedFilterSemanticsValid(forged, name, policy) {
t.Fatal("incomplete platform pass allowlist was accepted")
}
}