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/cloudinit/seed_test.go

314 lines
11 KiB
Go

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")
}
}