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.
314 lines
11 KiB
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")
|
|
}
|
|
}
|