From 74bfda70040f330cbee116bbed88412a01982c5b Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Sun, 25 Oct 2026 22:59:45 +0100 Subject: [PATCH] f-76: vm: filtrage nftables par tap, champ dhcp_server, watchdog #76 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Chaque NIC a sa chaîne pre-tap, posée avant le tap et retirée après : MAC, ARP et IPv4 source limités à ceux de la NIC (0.0.0.0 pour le client DHCP et la sonde ARP), réponses DHCP refusées sauf si dhcp_server, seuls IPv4, ARP et IPv6 émis. Le watchdog vérifie la chaîne de chaque NIC. Signed-off-by: GnomeZworc --- api/agent.yaml | 11 +++++ internal/api/agent/models.go | 9 ++-- internal/api/agent/vm.go | 2 + internal/api/agent/vm_test.go | 56 ++++++++++++++++++++++++ internal/api/agent/vms.go | 2 +- internal/dispatcher/agent/vm_commands.go | 14 ++++-- internal/nft/nft.go | 31 +++++++++++++ internal/nft/nft_test.go | 21 +++++++-- internal/vm/create.go | 12 +++++ internal/vm/data.go | 2 + internal/vm/data_test.go | 17 +++++++ internal/vm/delete.go | 12 +++++ internal/vm/filter.go | 28 ++++++++++++ internal/vm/filter_test.go | 53 ++++++++++++++++++++++ internal/watchdog/check_vm.go | 19 +++++++- internal/watchdog/check_vm_test.go | 21 +++++++++ 16 files changed, 295 insertions(+), 15 deletions(-) create mode 100644 internal/vm/filter.go create mode 100644 internal/vm/filter_test.go diff --git a/api/agent.yaml b/api/agent.yaml index 40e0400..c7a546f 100644 --- a/api/agent.yaml +++ b/api/agent.yaml @@ -562,6 +562,17 @@ components: primary: type: boolean example: true + dhcp_server: + type: boolean + default: false + description: > + Lets the VM answer DHCP (UDP from port 67) on this interface, for + instance a PXE server for diskless hosts on a `bridge` subnet. Every + other interface may not send DHCP answers. The interface still sends + only from its own MAC and IP. The agent applies it whatever the mode + of the subnet: restricting it is the caller's job. Always returned + by GET. + example: false VMStorage: type: object diff --git a/internal/api/agent/models.go b/internal/api/agent/models.go index be152f6..c033a16 100644 --- a/internal/api/agent/models.go +++ b/internal/api/agent/models.go @@ -40,10 +40,11 @@ type Subnet struct { } type VMInterface struct { - Subnet string `json:"subnet"` - IP string `json:"ip"` - MAC string `json:"mac"` - Primary bool `json:"primary"` + Subnet string `json:"subnet"` + IP string `json:"ip"` + MAC string `json:"mac"` + Primary bool `json:"primary"` + DHCPServer bool `json:"dhcp_server"` } type VMStorage struct { diff --git a/internal/api/agent/vm.go b/internal/api/agent/vm.go index fe734ea..1819196 100644 --- a/internal/api/agent/vm.go +++ b/internal/api/agent/vm.go @@ -104,6 +104,8 @@ func interfacesFromDB(prefix string, entries map[string]string) []VMInterface { byIndex[idx].MAC = value case "primary": byIndex[idx].Primary = value == "true" + case "dhcp_server": + byIndex[idx].DHCPServer = value == "true" } } diff --git a/internal/api/agent/vm_test.go b/internal/api/agent/vm_test.go index 9761917..44981a2 100644 --- a/internal/api/agent/vm_test.go +++ b/internal/api/agent/vm_test.go @@ -360,6 +360,62 @@ func TestStartVM_StoresAllInterfaces(t *testing.T) { } } +func TestStartVM_StoresDHCPServerOnlyWhenRequested(t *testing.T) { + s, db := newTestServer(t) + for sn, cidr := range map[string]string{"sn-1": "10.1.0.0/24", "sn-2": "10.2.0.0/24"} { + kv.AddInDB(db, "subnet/"+sn+"/state", "running") + kv.AddInDB(db, "subnet/"+sn+"/vpc", "vpc-1") + kv.AddInDB(db, "subnet/"+sn+"/cidr", cidr) + } + + body, _ := json.Marshal(VMCreateRequest{ + Name: "vm-pxe", + Interfaces: []VMInterface{ + {Subnet: "sn-1", IP: "10.1.0.5", MAC: "52:54:00:00:00:05", Primary: true}, + {Subnet: "sn-2", IP: "10.2.0.5", MAC: "52:54:00:aa:bb:cc", DHCPServer: true}, + }, + Storage: []VMStorage{{Path: "/data/root.qcow2", Dev: "vda"}}, + }) + + w := httptest.NewRecorder() + s.VmsHandler(w, httptest.NewRequest(http.MethodPost, "/vms", bytes.NewReader(body))) + if w.Code != http.StatusAccepted { + t.Fatalf("attendu 202, obtenu %d : %s", w.Code, w.Body.String()) + } + if got, _ := kv.GetFromDB(db, "vm/vm-pxe/nic/1/dhcp_server"); got != "true" { + t.Errorf("dhcp_server de la seconde interface non stocké : %q", got) + } + if _, err := kv.GetFromDB(db, "vm/vm-pxe/nic/0/dhcp_server"); err == nil { + t.Error("une interface sans dhcp_server ne doit pas porter la clé") + } +} + +func TestVmFromDB_ReturnsDHCPServer(t *testing.T) { + vm, err := vmFromDB("vm-pxe", map[string]string{ + "vm/vm-pxe/state": "running", + "vm/vm-pxe/nic/0/subnet": "sn-1", + "vm/vm-pxe/nic/0/ip": "10.1.0.5", + "vm/vm-pxe/nic/0/primary": "true", + "vm/vm-pxe/nic/1/subnet": "sn-2", + "vm/vm-pxe/nic/1/ip": "10.2.0.5", + "vm/vm-pxe/nic/1/dhcp_server": "true", + "vm/vm-pxe/disk/vda": "/data/root.qcow2", + }) + if err != nil { + t.Fatalf("vmFromDB : %v", err) + } + if len(vm.Interfaces) != 2 { + t.Fatalf("2 interfaces attendues : %+v", vm.Interfaces) + } + if vm.Interfaces[0].DHCPServer || !vm.Interfaces[1].DHCPServer { + t.Errorf("dhcp_server attendu sur l'index 1 seulement : %+v", vm.Interfaces) + } + raw, _ := json.Marshal(vm.Interfaces[0]) + if !strings.Contains(string(raw), `"dhcp_server":false`) { + t.Errorf("dhcp_server faux absent du JSON : %s", raw) + } +} + func TestStartVM_RejectsZeroOrTwoPrimaries(t *testing.T) { cases := map[string][]VMInterface{ "aucune primaire": {{Subnet: "sn-1", IP: "10.1.0.5", MAC: "52:54:00:00:00:05"}}, diff --git a/internal/api/agent/vms.go b/internal/api/agent/vms.go index 03b617f..f679919 100644 --- a/internal/api/agent/vms.go +++ b/internal/api/agent/vms.go @@ -78,7 +78,7 @@ func (s *Server) startVM(w http.ResponseWriter, r *http.Request) { json.NewEncoder(w).Encode(ErrorResponse{Error: fmt.Sprintf("interface %d: mac is required", i)}) return } - nics[i] = dispatcher.VMNIC{Subnet: iface.Subnet, IP: iface.IP, MAC: iface.MAC, Primary: iface.Primary} + nics[i] = dispatcher.VMNIC{Subnet: iface.Subnet, IP: iface.IP, MAC: iface.MAC, Primary: iface.Primary, DHCPServer: iface.DHCPServer} if iface.Primary { primaries++ } diff --git a/internal/dispatcher/agent/vm_commands.go b/internal/dispatcher/agent/vm_commands.go index bcd8b61..314d112 100644 --- a/internal/dispatcher/agent/vm_commands.go +++ b/internal/dispatcher/agent/vm_commands.go @@ -22,10 +22,11 @@ type VMDisk struct { } type VMNIC struct { - Subnet string - IP string - MAC string - Primary bool + Subnet string + IP string + MAC string + Primary bool + DHCPServer bool } type StartVMCommand struct { @@ -70,6 +71,11 @@ func (c StartVMCommand) Prepare(db *badger.DB, _ *configuration.Config) error { return fmt.Errorf("store nic %d primary: %w", i, err) } } + if n.DHCPServer { + if err := kv.AddInDB(db, prefix+"dhcp_server", "true"); err != nil { + return fmt.Errorf("store nic %d dhcp_server: %w", i, err) + } + } } kv.AddInDB(db, "vm/"+c.Name+"/metadata_port", strconv.Itoa(port)) for _, d := range c.Disks { diff --git a/internal/nft/nft.go b/internal/nft/nft.go index 5d6311c..d859268 100644 --- a/internal/nft/nft.go +++ b/internal/nft/nft.go @@ -59,6 +59,37 @@ func DropDHCPFrom(ip string) string { return "ip saddr " + ip + " udp sport 67-68 udp dport 67-68 drop" } +func DropSourceMACOtherThan(mac string) string { + return "ether saddr != " + mac + " drop" +} + +func DropEtherTypesOtherThanIPAndARP() string { + return "ether type != { ip, arp, ip6 } drop" +} + +func DropARPSenderMACOtherThan(mac string) string { + return "arp saddr ether != " + mac + " drop" +} + +func DropARPSenderIPOtherThan(ip string) string { + return "arp saddr ip != { 0.0.0.0, " + ip + " } drop" +} + +func DropDHCPServer() string { + return "udp sport 67 drop" +} + +func DropIPSourceOtherThan(ip string) string { + return "ip saddr != { 0.0.0.0, " + ip + " } drop" +} + +func DropUnspecifiedSourceOutsideDHCP() []string { + return []string{ + "ip saddr 0.0.0.0 ip protocol != udp drop", + "ip saddr 0.0.0.0 udp dport != 67 drop", + } +} + func run(args []string, script string) ([]byte, error) { cmd := exec.Command("nft", args...) if script != "" { diff --git a/internal/nft/nft_test.go b/internal/nft/nft_test.go index be01273..c5c7e6a 100644 --- a/internal/nft/nft_test.go +++ b/internal/nft/nft_test.go @@ -36,10 +36,16 @@ func mustParse(t *testing.T, data string) table { func TestRuleTexts(t *testing.T) { for got, want := range map[string]string{ - DropSourceMAC("02:01:00:00:0b:5f"): "ether saddr 02:01:00:00:0b:5f drop", - DropARPRequestTo("10.33.0.1"): "arp operation request arp daddr ip 10.33.0.1 drop", - DropARPFrom("10.33.0.1"): "arp saddr ip 10.33.0.1 drop", - DropDHCPFrom("10.33.0.1"): "ip saddr 10.33.0.1 udp sport 67-68 udp dport 67-68 drop", + DropSourceMAC("02:01:00:00:0b:5f"): "ether saddr 02:01:00:00:0b:5f drop", + DropARPRequestTo("10.33.0.1"): "arp operation request arp daddr ip 10.33.0.1 drop", + DropARPFrom("10.33.0.1"): "arp saddr ip 10.33.0.1 drop", + DropDHCPFrom("10.33.0.1"): "ip saddr 10.33.0.1 udp sport 67-68 udp dport 67-68 drop", + DropSourceMACOtherThan("52:54:00:00:0a:05"): "ether saddr != 52:54:00:00:0a:05 drop", + DropEtherTypesOtherThanIPAndARP(): "ether type != { ip, arp, ip6 } drop", + DropARPSenderMACOtherThan("52:54:00:00:0a:05"): "arp saddr ether != 52:54:00:00:0a:05 drop", + DropARPSenderIPOtherThan("10.0.0.5"): "arp saddr ip != { 0.0.0.0, 10.0.0.5 } drop", + DropDHCPServer(): "udp sport 67 drop", + DropIPSourceOtherThan("10.0.0.5"): "ip saddr != { 0.0.0.0, 10.0.0.5 } drop", } { if got != want { t.Errorf("%q, %q attendu", got, want) @@ -47,6 +53,13 @@ func TestRuleTexts(t *testing.T) { } } +func TestDropUnspecifiedSourceOutsideDHCP(t *testing.T) { + want := "ip saddr 0.0.0.0 ip protocol != udp drop|ip saddr 0.0.0.0 udp dport != 67 drop" + if got := strings.Join(DropUnspecifiedSourceOutsideDHCP(), "|"); got != want { + t.Errorf("%q, %q attendu", got, want) + } +} + func TestSetScriptOnAnEmptyNetns(t *testing.T) { want := `add table bridge two add map bridge two pre_ports { type ifname : verdict; } diff --git a/internal/vm/create.go b/internal/vm/create.go index 17c709d..83462b5 100644 --- a/internal/vm/create.go +++ b/internal/vm/create.go @@ -15,6 +15,7 @@ import ( "git.g3e.fr/syonad/two/internal/metadata" "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" + "git.g3e.fr/syonad/two/internal/nft" "git.g3e.fr/syonad/two/internal/qemu" "git.g3e.fr/syonad/two/internal/state" @@ -41,6 +42,17 @@ func StartVM(db *badger.DB, name string, cfg *configuration.Config) error { return err } + if err := netns.Call(nic.vpcName, func() error { + for _, n := range d.nics { + if err := nft.SetPort(n.tapPort()); err != nil { + return fmt.Errorf("interface %d: %w", n.index, err) + } + } + return nil + }); err != nil { + return fmt.Errorf("filter taps: %w", err) + } + for _, n := range d.nics { if err := netif.CreateTap(n.tapID, n.bridge, n.vpcName, cfg.Network.VM()); err != nil { return fmt.Errorf("create tap of interface %d: %w", n.index, err) diff --git a/internal/vm/data.go b/internal/vm/data.go index 7b39b06..d30611d 100644 --- a/internal/vm/data.go +++ b/internal/vm/data.go @@ -27,6 +27,7 @@ type nicData struct { mac string tapID int primary bool + dhcpServer bool mode string vpcCIDR *net.IPNet } @@ -179,6 +180,7 @@ func loadNIC(db *badger.DB, name string, idx int, entries map[string]string) (ni } n.bridge = "br-" + strings.SplitN(n.subnetName, "-", 2)[1] n.primary = entries[prefix+"primary"] == "true" + n.dhcpServer = entries[prefix+"dhcp_server"] == "true" vpcName, err := kv.GetFromDB(db, "subnet/"+n.subnetName+"/vpc") if err != nil { diff --git a/internal/vm/data_test.go b/internal/vm/data_test.go index d7f7a62..2a4a111 100644 --- a/internal/vm/data_test.go +++ b/internal/vm/data_test.go @@ -125,6 +125,23 @@ func TestLoadVM_SingleNIC(t *testing.T) { } } +func TestLoadVM_ReadsDHCPServer(t *testing.T) { + db := newVMInDB(t) + addNIC(t, db, 1, "sn-000002", "10.2.0.5", "00:22:33:00:02:05", false) + kv.AddInDB(db, "vm/vm-1/nic/1/dhcp_server", "true") + + d, err := loadVM(db, "vm-1") + if err != nil { + t.Fatalf("loadVM : %v", err) + } + if len(d.nics) != 2 { + t.Fatalf("2 interfaces attendues, obtenu %d", len(d.nics)) + } + if d.nics[0].dhcpServer || !d.nics[1].dhcpServer { + t.Errorf("dhcp_server attendu sur l'index 1 seulement : %+v", d.nics) + } +} + func TestLoadVM_MultipleNICsSortedByIndex(t *testing.T) { db := newVMInDB(t) addNIC(t, db, 2, "sn-000003", "10.3.0.9", "00:22:33:00:03:09", false) diff --git a/internal/vm/delete.go b/internal/vm/delete.go index be87a2a..597aed4 100644 --- a/internal/vm/delete.go +++ b/internal/vm/delete.go @@ -16,6 +16,7 @@ import ( "git.g3e.fr/syonad/two/internal/metadata" "git.g3e.fr/syonad/two/internal/netif" "git.g3e.fr/syonad/two/internal/netns" + "git.g3e.fr/syonad/two/internal/nft" "git.g3e.fr/syonad/two/internal/qmp" "git.g3e.fr/syonad/two/internal/state" @@ -79,6 +80,17 @@ func StopVM(db *badger.DB, name string, cfg *configuration.Config) error { } } + if err := netns.Call(nic.vpcName, func() error { + for _, n := range d.nics { + if err := nft.DeletePort(n.tapPort().Name); err != nil { + return fmt.Errorf("interface %d: %w", n.index, err) + } + } + return nil + }); err != nil { + return fmt.Errorf("unfilter taps: %w", err) + } + if err := removeDHCPFiles(d, name, backend); err != nil { return err } diff --git a/internal/vm/filter.go b/internal/vm/filter.go new file mode 100644 index 0000000..f28fa29 --- /dev/null +++ b/internal/vm/filter.go @@ -0,0 +1,28 @@ +package vm + +import ( + "fmt" + "strings" + + "git.g3e.fr/syonad/two/internal/nft" +) + +func TapPort(tapID int, mac, ip string, dhcpServer bool) nft.Port { + mac = strings.ToLower(mac) + rules := []string{ + nft.DropSourceMACOtherThan(mac), + nft.DropEtherTypesOtherThanIPAndARP(), + nft.DropARPSenderMACOtherThan(mac), + nft.DropARPSenderIPOtherThan(ip), + nft.DropIPSourceOtherThan(ip), + } + rules = append(rules, nft.DropUnspecifiedSourceOutsideDHCP()...) + if !dhcpServer { + rules = append(rules, nft.DropDHCPServer()) + } + return nft.Port{Name: fmt.Sprintf("tap%d", tapID), Prerouting: rules} +} + +func (n nicData) tapPort() nft.Port { + return TapPort(n.tapID, n.mac, n.ip, n.dhcpServer) +} diff --git a/internal/vm/filter_test.go b/internal/vm/filter_test.go new file mode 100644 index 0000000..3b0db73 --- /dev/null +++ b/internal/vm/filter_test.go @@ -0,0 +1,53 @@ +package vm + +import ( + "strings" + "testing" +) + +func TestTapPortFiltersEverythingTheVMMustNotSend(t *testing.T) { + p := TapPort(12345678, "52:54:00:00:0A:05", "10.0.0.5", false) + if p.Name != "tap12345678" { + t.Errorf("port %q, tap12345678 attendu", p.Name) + } + want := []string{ + "ether saddr != 52:54:00:00:0a:05 drop", + "ether type != { ip, arp, ip6 } drop", + "arp saddr ether != 52:54:00:00:0a:05 drop", + "arp saddr ip != { 0.0.0.0, 10.0.0.5 } drop", + "ip saddr != { 0.0.0.0, 10.0.0.5 } drop", + "ip saddr 0.0.0.0 ip protocol != udp drop", + "ip saddr 0.0.0.0 udp dport != 67 drop", + "udp sport 67 drop", + } + if strings.Join(p.Prerouting, "\n") != strings.Join(want, "\n") { + t.Errorf("règles :\n%s\nattendues :\n%s", strings.Join(p.Prerouting, "\n"), strings.Join(want, "\n")) + } + if len(p.Forward) != 0 || len(p.Output) != 0 { + t.Errorf("seul ce qu'émet la VM est filtré : forward %q, output %q", p.Forward, p.Output) + } +} + +func TestTapPortLetsAnAuthorizedNICAnswerDHCP(t *testing.T) { + allowed := TapPort(12345678, "52:54:00:00:0a:05", "10.0.0.5", true) + denied := TapPort(12345678, "52:54:00:00:0a:05", "10.0.0.5", false) + for _, r := range allowed.Prerouting { + if r == "udp sport 67 drop" { + t.Errorf("la NIC autorisée garde le blocage du serveur DHCP") + } + } + if len(allowed.Prerouting) != len(denied.Prerouting)-1 { + t.Errorf("seul le blocage du serveur DHCP doit disparaître : %q", allowed.Prerouting) + } +} + +func TestNICTapPortUsesItsOwnData(t *testing.T) { + n := nicData{tapID: 87654321, mac: "52:54:00:00:0b:07", ip: "10.0.1.7", dhcpServer: true} + p := n.tapPort() + if p.Name != "tap87654321" || p.Prerouting[0] != "ether saddr != 52:54:00:00:0b:07 drop" || p.Prerouting[3] != "arp saddr ip != { 0.0.0.0, 10.0.1.7 } drop" { + t.Errorf("port %+v", p) + } + if strings.Contains(strings.Join(p.Prerouting, "|"), "udp sport 67 drop") { + t.Errorf("dhcpServer de la NIC ignoré") + } +} diff --git a/internal/watchdog/check_vm.go b/internal/watchdog/check_vm.go index 7d9713c..96036bf 100644 --- a/internal/watchdog/check_vm.go +++ b/internal/watchdog/check_vm.go @@ -10,9 +10,11 @@ import ( configuration "git.g3e.fr/syonad/two/internal/config/agent" "git.g3e.fr/syonad/two/internal/netns" + "git.g3e.fr/syonad/two/internal/nft" "git.g3e.fr/syonad/two/internal/qemu" "git.g3e.fr/syonad/two/internal/qmp" "git.g3e.fr/syonad/two/internal/state" + "git.g3e.fr/syonad/two/internal/vm" "git.g3e.fr/syonad/two/internal/watchdog/notify" "git.g3e.fr/syonad/two/pkg/db/kv" @@ -71,7 +73,7 @@ func checkVM(db *badger.DB, cfg *configuration.Config, name string, u unitChecke n.Notify(kindVM, name, fmt.Sprintf("vpc of subnet %s unreadable in database: %v", subnetName, err)) continue } - checkVMTap(entries[prefix+"tap_id"], name, vpc, idx, n) + checkVMTap(entries, prefix, name, vpc, idx, n) } checkVMQemu(cfg, name, n) @@ -99,7 +101,12 @@ func nicIndexes(entries map[string]string, prefix string) []int { return indexes } -func checkVMTap(raw, name, vpc string, idx int, n notify.Notifier) { +func tapPortFromEntries(entries map[string]string, prefix string, tapID int) nft.Port { + return vm.TapPort(tapID, entries[prefix+"mac"], entries[prefix+"ip"], entries[prefix+"dhcp_server"] == "true") +} + +func checkVMTap(entries map[string]string, prefix, name, vpc string, idx int, n notify.Notifier) { + raw := entries[prefix+"tap_id"] if raw == "" { n.Notify(kindVM, name, fmt.Sprintf("interface %d has no tap_id in database", idx)) return @@ -119,6 +126,14 @@ func checkVMTap(raw, name, vpc string, idx int, n notify.Notifier) { if p := linkProblem(tapName(tapID)); p != "" { n.Notify(kindVM, name, p+" (in netns "+vpc+")") } + missing, err := nft.MissingRules(tapPortFromEntries(entries, prefix, tapID)) + if err != nil { + n.Notify(kindVM, name, fmt.Sprintf("interface %d: nftables rules unreadable in netns %s: %v", idx, vpc, err)) + return nil + } + for _, rule := range missing { + n.Notify(kindVM, name, fmt.Sprintf("interface %d: nftables rule missing in netns %s: %s", idx, vpc, rule)) + } return nil }); err != nil { n.Notify(kindVM, name, fmt.Sprintf("cannot enter netns %s: %v", vpc, err)) diff --git a/internal/watchdog/check_vm_test.go b/internal/watchdog/check_vm_test.go index 569b896..46a7e20 100644 --- a/internal/watchdog/check_vm_test.go +++ b/internal/watchdog/check_vm_test.go @@ -34,6 +34,27 @@ func TestTapName(t *testing.T) { } } +func TestTapPortFromEntries(t *testing.T) { + prefix := prefixVM + "i-pxe/nic/1/" + entries := map[string]string{ + prefix + "mac": "52:54:00:00:0B:07", + prefix + "ip": "10.0.1.7", + prefix + "dhcp_server": "true", + } + p := tapPortFromEntries(entries, prefix, 87654321) + got := strings.Join(p.Prerouting, "|") + if p.Name != "tap87654321" || !strings.Contains(got, "ether saddr != 52:54:00:00:0b:07 drop") || !strings.Contains(got, "ip saddr != { 0.0.0.0, 10.0.1.7 } drop") { + t.Errorf("port %+v", p) + } + if strings.Contains(got, "udp sport 67 drop") { + t.Errorf("dhcp_server lu en base ignoré : %s", got) + } + delete(entries, prefix+"dhcp_server") + if !strings.Contains(strings.Join(tapPortFromEntries(entries, prefix, 87654321).Prerouting, "|"), "udp sport 67 drop") { + t.Errorf("sans dhcp_server, le blocage du serveur DHCP doit être attendu") + } +} + func TestCheckVMs_ConfigNil(t *testing.T) { db := newTestDB(t) r := &recorder{}