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.
422 lines
14 KiB
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")
|
|
}
|
|
}
|