package cloudinit import ( "bytes" "encoding/base64" "encoding/binary" "encoding/json" "strings" "testing" "git.luoli.live/root/virt/agent/publicnetwork" "github.com/bgrewell/iso-kit/pkg/iso9660" ) func validSeedRequest() Request { keyBlob := make([]byte, 4+len("ssh-ed25519")+4+32) binary.BigEndian.PutUint32(keyBlob[:4], uint32(len("ssh-ed25519"))) copy(keyBlob[4:], "ssh-ed25519") offset := 4 + len("ssh-ed25519") binary.BigEndian.PutUint32(keyBlob[offset:offset+4], 32) for index := offset + 4; index < len(keyBlob); index++ { keyBlob[index] = byte(index) } return Request{ UUID: "123e4567-e89b-42d3-a456-426614174000", Name: "vm-test", Hostname: "vm-test.example.com", GuestSSHPublicKey: "ssh-ed25519 " + base64.StdEncoding.EncodeToString(keyBlob) + " user@test", RootPassword: "StrongPassword!123", StartupScript: "#!/bin/bash\necho '中文'\n", Network: Network{ 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) linkLocal, linkLocalErr := publicnetwork.LinkLocalIPv6CIDR(request.Network.MAC) if linkLocalErr != nil { t.Fatal(linkLocalErr) } if len(addresses) != 3 || addresses[0] != request.Network.Public.IPv4.AddressCIDR || addresses[1] != request.Network.Public.IPv6.AddressCIDR || addresses[2] != linkLocal { 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) } linkLocalMode, linkLocalModeOK := public["link-local"].([]any) if public["dhcp4"] != false || public["dhcp6"] != false || public["accept-ra"] != false || !linkLocalModeOK || len(linkLocalMode) != 0 { t.Fatalf("public autoconfiguration was enabled: %#v", public) } } func TestBuildFilesEmbedsAtMostOnceStartupRunnerWithoutPlaintextPassword(t *testing.T) { request := validSeedRequest() files, err := BuildFiles(request) if err != nil { t.Fatal(err) } if bytes.Contains(files.UserData, []byte(request.RootPassword)) { t.Fatal("NoCloud user-data contains the plaintext root password") } if !bytes.HasPrefix(files.UserData, []byte("#cloud-config\n")) { t.Fatalf("unexpected user-data prefix: %q", files.UserData[:20]) } var document map[string]any if err := json.Unmarshal(bytes.TrimPrefix(files.UserData, []byte("#cloud-config\n")), &document); err != nil { t.Fatal(err) } writeFiles, ok := document["write_files"].([]any) if !ok || len(writeFiles) != 3 { t.Fatalf("write_files = %#v", document["write_files"]) } entries := make(map[string]map[string]any) for _, raw := range writeFiles { entry := raw.(map[string]any) entries[entry["path"].(string)] = entry } if entries[StartupScriptPath]["content"] != request.StartupScript || entries[StartupScriptPath]["permissions"] != "0600" { t.Fatalf("startup script entry = %#v", entries[StartupScriptPath]) } if entries[StartupRunnerPath]["content"] != StartupRunner || entries[StartupRunnerPath]["permissions"] != "0700" { t.Fatalf("startup runner entry = %#v", entries[StartupRunnerPath]) } if !strings.Contains(StartupRunner, `mkdir "$state/started"`) || !strings.Contains(StartupRunner, `printf '%s\n' "$result"`) { t.Fatalf("startup runner lost durable at-most-once markers: %q", StartupRunner) } runcmd := document["runcmd"].([]any) command := runcmd[0].([]any) if command[0] != "/bin/sh" || command[1] != StartupRunnerPath { t.Fatalf("runcmd = %#v", runcmd) } users := document["users"].([]any) hash := users[0].(map[string]any)["hashed_passwd"].(string) if !passwordHashRE.MatchString(hash) { t.Fatalf("root password hash has unexpected format: %q", hash) } } func TestBuildISOHasExactNoCloudRockRidgeNames(t *testing.T) { imageBytes, err := BuildISO(validSeedRequest()) if err != nil { t.Fatal(err) } if len(imageBytes) == 0 || len(imageBytes) > maxSeedBytes { t.Fatalf("ISO length = %d", len(imageBytes)) } image, err := iso9660.Open(bytes.NewReader(imageBytes)) if err != nil { t.Fatal(err) } for _, name := range []string{"user-data", "meta-data", "network-config"} { value, err := image.ReadFile(name) if err != nil { t.Fatalf("read %s: %v", name, err) } if len(value) == 0 { t.Fatalf("%s is empty", name) } } } func TestBuildFilesRejectsStartupOverflowAndInvalidPublicNetwork(t *testing.T) { request := validSeedRequest() request.StartupScript = strings.Repeat("x", (32<<10)+1) if _, err := BuildFiles(request); err == nil { t.Fatal("startup script over 32 KiB was accepted") } request = validSeedRequest() 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") } } func TestBuildFilesAddsRoutedPrivateInterfaceWithoutDefaultRouteOrDNS(t *testing.T) { request := validSeedRequest() request.Network.Private = &PrivateNetwork{ MAC: "02:00:00:00:00:09", PrivateIP: "10.60.0.9", CIDR: "10.60.0.0/24", Gateway: "10.60.0.1", } 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) } ethernets, ok := network["ethernets"].(map[string]any) if !ok || len(ethernets) != 2 { t.Fatalf("ethernets = %#v", network["ethernets"]) } private, ok := ethernets["private0"].(map[string]any) if !ok { t.Fatalf("private0 = %#v", ethernets["private0"]) } addresses, _ := private["addresses"].([]any) if len(addresses) != 1 || addresses[0] != "10.60.0.9/32" { t.Fatalf("private addresses = %#v", private["addresses"]) } routes, _ := private["routes"].([]any) if len(routes) != 1 { t.Fatalf("private routes = %#v", private["routes"]) } route, _ := routes[0].(map[string]any) if route["to"] != "10.60.0.0/24" || route["via"] != "10.60.0.1" || route["on-link"] != true { t.Fatalf("private route = %#v", route) } if _, exists := private["nameservers"]; exists { t.Fatalf("private interface unexpectedly owns DNS: %#v", private) } } func TestBuildFilesRejectsUnsafePrivateNetwork(t *testing.T) { for name, private := range map[string]PrivateNetwork{ "public CIDR": {MAC: "02:00:00:00:00:09", PrivateIP: "8.8.8.9", CIDR: "8.8.8.0/24", Gateway: "8.8.8.1"}, "network address": {MAC: "02:00:00:00:00:09", PrivateIP: "10.60.0.0", CIDR: "10.60.0.0/24", Gateway: "10.60.0.1"}, "wrong gateway": {MAC: "02:00:00:00:00:09", PrivateIP: "10.60.0.9", CIDR: "10.60.0.0/24", Gateway: "10.60.0.2"}, "public MAC": {MAC: "52:54:00:12:34:56", PrivateIP: "10.60.0.9", CIDR: "10.60.0.0/24", Gateway: "10.60.0.1"}, "key collision": {MAC: "02:00:00:00:00:09", PrivateIP: "10.60.0.9", CIDR: "10.60.0.0/24", Gateway: "10.60.0.1", InterfaceKey: "public0"}, } { t.Run(name, func(t *testing.T) { request := validSeedRequest() request.Network.Private = &private if _, err := BuildFiles(request); err == nil { t.Fatal("unsafe private network was accepted") } }) } } func TestBuildFilesRestoreSeedPreservesGuestCredentials(t *testing.T) { request := validSeedRequest() request.GuestSSHPublicKey = "" request.RootPassword = "" request.StartupScript = "" request.PreserveGuestCredentials = true files, err := BuildFiles(request) if err != nil { t.Fatal(err) } var document map[string]any if err := json.Unmarshal(bytes.TrimPrefix(files.UserData, []byte("#cloud-config\n")), &document); err != nil { t.Fatal(err) } for _, forbidden := range []string{"users", "chpasswd", "ssh_pwauth", "disable_root", "write_files", "runcmd"} { if _, exists := document[forbidden]; exists { t.Fatalf("credential-preserving restore seed unexpectedly contains %q: %#v", forbidden, document) } } 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.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 if err := json.Unmarshal(bytes.TrimSpace(files.MetaData), &metadata); err != nil { t.Fatal(err) } if metadata[GuestIdentityMetadata] != GuestIdentityDisk { t.Fatalf("restore seed guest identity = %#v", metadata[GuestIdentityMetadata]) } if _, exists := metadata["local-hostname"]; exists { t.Fatalf("restore seed unexpectedly replaces disk hostname: %#v", metadata) } request.RootPassword = "MustNot1!Replace" if _, err := BuildFiles(request); err == nil { t.Fatal("credential-preserving restore accepted a replacement password") } } func TestDebian12NetworkFixRunsInInitLocalWithNetworkd(t *testing.T) { request := validSeedRequest() request.Debian12NetworkFix = true files, err := BuildFiles(request) if err != nil { t.Fatal(err) } var metadata map[string]any if err := json.Unmarshal(bytes.TrimSpace(files.MetaData), &metadata); err != nil { t.Fatal(err) } if metadata["dsmode"] != "local" { t.Fatalf("dsmode = %#v", metadata["dsmode"]) } var network map[string]any if err := json.Unmarshal(bytes.TrimSpace(files.NetworkConfig), &network); err != nil { t.Fatal(err) } if network["renderer"] != "networkd" { t.Fatalf("renderer = %#v", network["renderer"]) } var userData map[string]any if err := json.Unmarshal(bytes.TrimPrefix(files.UserData, []byte("#cloud-config\n")), &userData); err != nil { t.Fatal(err) } encoded, err := json.Marshal(userData["bootcmd"]) if err != nil { t.Fatal(err) } for _, command := range []string{"systemd-machine-id-setup", "netplan generate", "systemctl start --no-block systemd-networkd.service"} { if !bytes.Contains(encoded, []byte(command)) { t.Fatalf("bootcmd missing %q: %s", command, encoded) } } request.Debian12NetworkFix = false ordinary, err := BuildFiles(request) if err != nil { t.Fatal(err) } if bytes.Contains(ordinary.MetaData, []byte(`"dsmode"`)) || bytes.Contains(ordinary.NetworkConfig, []byte(`"renderer"`)) || bytes.Contains(ordinary.UserData, []byte(`"bootcmd"`)) { t.Fatal("Debian 12 workaround leaked into ordinary templates") } }