feat: render dual-stack guest network intent

go
codex 2 weeks ago
parent e33fa0711f
commit 276f8efacb

@ -11,9 +11,11 @@ import (
"net"
"net/netip"
"regexp"
"slices"
"strings"
"unicode/utf8"
"git.luoli.live/root/virt/agent/publicnetwork"
"github.com/GehirnInc/crypt/sha512_crypt"
"github.com/bgrewell/iso-kit/pkg/iso9660"
)
@ -59,12 +61,10 @@ var (
)
type Network struct {
MAC string `json:"mac"`
PublicCIDR string `json:"public_ip_cidr"`
Gateway string `json:"gateway"`
DNSServers []string `json:"dns_servers"`
InterfaceKey string `json:"interface_key,omitempty"`
Private *PrivateNetwork `json:"private,omitempty"`
MAC string `json:"mac"`
Public publicnetwork.Intent `json:"public_network"`
InterfaceKey string `json:"interface_key,omitempty"`
Private *PrivateNetwork `json:"private,omitempty"`
}
// PrivateNetwork is an optional routed VPC interface. The guest receives a
@ -207,13 +207,19 @@ func BuildFiles(request Request) (Files, error) {
}
ethernets := map[string]any{
interfaceKey: map[string]any{
"match": map[string]string{"macaddress": strings.ToLower(request.Network.MAC)},
"dhcp4": false,
"dhcp6": false,
"accept-ra": false,
"addresses": []string{request.Network.PublicCIDR},
"routes": []map[string]string{{"to": "0.0.0.0/0", "via": request.Network.Gateway}},
"nameservers": map[string]any{"addresses": request.Network.DNSServers},
"match": map[string]string{"macaddress": strings.ToLower(request.Network.MAC)},
"dhcp4": false,
"dhcp6": false,
"accept-ra": false,
"addresses": []string{
request.Network.Public.IPv4.AddressCIDR,
request.Network.Public.IPv6.AddressCIDR,
},
"routes": []map[string]any{
publicDefaultRoute("0.0.0.0/0", request.Network.Public.IPv4),
publicDefaultRoute("::/0", request.Network.Public.IPv6),
},
"nameservers": map[string]any{"addresses": request.Network.Public.DNSServers},
},
}
if private := request.Network.Private; private != nil {
@ -321,35 +327,15 @@ func validateNetwork(value Network) error {
if err != nil || len(hardware) != 6 || hardware[0]&1 != 0 || allZero(hardware) {
return errors.New("public interface MAC is invalid")
}
prefix, err := netip.ParsePrefix(value.PublicCIDR)
if err != nil || !prefix.Addr().Is4() || prefix.Bits() < 1 || prefix.Bits() > 30 {
return errors.New("public_ip_cidr must be an IPv4 host address with /1 through /30 prefix")
}
if !isPublicIPv4(prefix.Addr()) {
return errors.New("public_ip_cidr is not a public IPv4 address")
}
network := prefix.Masked()
broadcast := lastAddress(network)
if prefix.Addr() == network.Addr() || prefix.Addr() == broadcast {
return errors.New("public_ip_cidr cannot select the network or broadcast address")
}
gateway, err := netip.ParseAddr(value.Gateway)
if err != nil || !gateway.Is4() || !network.Contains(gateway) || gateway == prefix.Addr() || gateway == network.Addr() || gateway == broadcast {
return errors.New("gateway must be another usable address in the public subnet")
}
if len(value.DNSServers) < 1 || len(value.DNSServers) > 4 {
return errors.New("one to four DNS servers are required")
canonical, err := value.Public.Canonical()
if err != nil {
return fmt.Errorf("public network is invalid: %w", err)
}
seen := make(map[netip.Addr]struct{}, len(value.DNSServers))
for _, raw := range value.DNSServers {
address, err := netip.ParseAddr(raw)
if err != nil || !address.Is4() || !isPublicIPv4(address) {
return errors.New("DNS servers must be public IPv4 addresses")
}
if _, exists := seen[address]; exists {
return errors.New("DNS servers must be unique")
}
seen[address] = struct{}{}
if canonical.Contract != value.Public.Contract ||
canonical.NetworkSelector != value.Public.NetworkSelector ||
canonical.IPv4 != value.Public.IPv4 || canonical.IPv6 != value.Public.IPv6 ||
!slices.Equal(canonical.DNSServers, value.Public.DNSServers) {
return errors.New("public network must use its canonical representation")
}
if value.InterfaceKey != "" && !regexp.MustCompile(`^[a-z][a-z0-9_-]{0,31}$`).MatchString(value.InterfaceKey) {
return errors.New("interface key is invalid")
@ -362,6 +348,14 @@ func validateNetwork(value Network) error {
return nil
}
func publicDefaultRoute(destination string, address publicnetwork.AddressIntent) map[string]any {
route := map[string]any{"to": destination, "via": address.Gateway}
if address.GatewayOnLink {
route["on-link"] = true
}
return route
}
func validatePrivateNetwork(value PrivateNetwork, publicMAC, publicKey string) error {
hardware, err := net.ParseMAC(value.MAC)
if err != nil || len(hardware) != 6 || hardware[0]&1 != 0 || allZero(hardware) ||

@ -8,6 +8,7 @@ import (
"strings"
"testing"
"git.luoli.live/root/virt/agent/publicnetwork"
"github.com/bgrewell/iso-kit/pkg/iso9660"
)
@ -28,12 +29,55 @@ func validSeedRequest() Request {
RootPassword: "StrongPassword!123",
StartupScript: "#!/bin/bash\necho '中文'\n",
Network: Network{
MAC: "52:54:00:12:34:56", PublicCIDR: "8.8.8.10/24", Gateway: "8.8.8.1",
DNSServers: []string{"1.1.1.1", "9.9.9.9"},
MAC: "52:54:00:12:34:56",
Public: 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 TestBuildFilesRendersStaticDualStackWithExplicitOffPrefixIPv6Gateway(t *testing.T) {
request := validSeedRequest()
files, err := BuildFiles(request)
if err != nil {
t.Fatal(err)
}
var network map[string]any
if err := json.Unmarshal(bytes.TrimSpace(files.NetworkConfig), &network); err != nil {
t.Fatal(err)
}
public := network["ethernets"].(map[string]any)["public0"].(map[string]any)
addresses := public["addresses"].([]any)
if len(addresses) != 2 || addresses[0] != request.Network.Public.IPv4.AddressCIDR || addresses[1] != request.Network.Public.IPv6.AddressCIDR {
t.Fatalf("dual-stack addresses = %#v", addresses)
}
routes := public["routes"].([]any)
if len(routes) != 2 {
t.Fatalf("default routes = %#v", routes)
}
if got := routes[0].(map[string]any); got["to"] != "0.0.0.0/0" || got["via"] != request.Network.Public.IPv4.Gateway {
t.Fatalf("IPv4 route = %#v", got)
}
if got := routes[1].(map[string]any); got["to"] != "::/0" || got["via"] != request.Network.Public.IPv6.Gateway || got["on-link"] != true {
t.Fatalf("IPv6 route = %#v", got)
}
if public["dhcp4"] != false || public["dhcp6"] != false || public["accept-ra"] != false {
t.Fatalf("public autoconfiguration was enabled: %#v", public)
}
}
func TestBuildFilesEmbedsAtMostOnceStartupRunnerWithoutPlaintextPassword(t *testing.T) {
request := validSeedRequest()
files, err := BuildFiles(request)
@ -110,8 +154,8 @@ func TestBuildFilesRejectsStartupOverflowAndInvalidPublicNetwork(t *testing.T) {
t.Fatal("startup script over 32 KiB was accepted")
}
request = validSeedRequest()
request.Network.PublicCIDR = "192.168.1.10/24"
request.Network.Gateway = "192.168.1.1"
request.Network.Public.IPv4.AddressCIDR = "192.168.1.10/24"
request.Network.Public.IPv4.Gateway = "192.168.1.1"
if _, err := BuildFiles(request); err == nil {
t.Fatal("private address was accepted as public network")
}
@ -196,7 +240,7 @@ func TestBuildFilesRestoreSeedPreservesGuestCredentials(t *testing.T) {
if document["preserve_hostname"] != true {
t.Fatalf("restore seed preserve_hostname = %#v", document["preserve_hostname"])
}
if !bytes.Contains(files.MetaData, []byte(request.UUID)) || !bytes.Contains(files.NetworkConfig, []byte(request.Network.PublicCIDR)) {
if !bytes.Contains(files.MetaData, []byte(request.UUID)) || !bytes.Contains(files.NetworkConfig, []byte(request.Network.Public.IPv6.AddressCIDR)) {
t.Fatalf("restore seed lost new identity or network: metadata=%s network=%s", files.MetaData, files.NetworkConfig)
}
var metadata map[string]any

Loading…
Cancel
Save