From 1df0d2dad639881bb48ef49d231cbec98c42210a Mon Sep 17 00:00:00 2001 From: GnomeZworc Date: Fri, 30 Oct 2026 00:23:40 +0100 Subject: [PATCH] =?UTF-8?q?f-42:=20vpc:=20br-public=20du=20netns=20ferm?= =?UTF-8?q?=C3=A9,=20br=5Fnetfilter=20coup=C3=A9=20dans=20le=20netns=20#42?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GnomeZworc --- docs/concepts/vpc-subnet-vm.rst | 8 ++++++++ internal/nft/guard.go | 28 ++++++++++++++++++++++++++++ internal/nft/guard_test.go | 17 +++++++++++++++++ internal/sysctl/sysctl.go | 12 ++++++++++++ internal/sysctl/sysctl_test.go | 22 ++++++++++++++++++++++ internal/vpc/create.go | 4 ++++ internal/vpc/guard.go | 26 ++++++++++++++++++++++++++ release_notes/0.3.0.md | 11 +++++++++++ 8 files changed, 128 insertions(+) create mode 100644 internal/nft/guard.go create mode 100644 internal/nft/guard_test.go create mode 100644 internal/vpc/guard.go diff --git a/docs/concepts/vpc-subnet-vm.rst b/docs/concepts/vpc-subnet-vm.rst index 14d8665..3d27bf9 100644 --- a/docs/concepts/vpc-subnet-vm.rst +++ b/docs/concepts/vpc-subnet-vm.rst @@ -25,6 +25,14 @@ public est celui de ``interfaces.internet``, ``br-public`` si la clé est absent accroche ``vxlan-public``, le VXLAN du segment public partagé avec les bordures (:doc:`/demarrage/installation`) ; sans ce bridge, toute création de VPC échoue. +Le ``br-public`` du netns n'est qu'un point de raccordement : rien n'entre dans le VPC par lui. +L'agent y pose ``arp_ignore=1`` (il ne répond pas à l'ARP pour les adresses du netns) et, dans la +table nftables ``ip two``, rejette tout IP arrivé par ``br-public`` (chaînes ``in-br-public`` et +``fwd-br-public``). Seules les interfaces publiques prévues — passerelle NAT, IP flottante — y +reçoivent du trafic. Il désactive aussi ``br_netfilter`` dans le netns +(``net.bridge.bridge-nf-call-{iptables,ip6tables,arptables}=0``, quand le module est chargé) : sinon +conntrack voit chaque trame pontée et le SNAT de la passerelle NAT ne s'applique plus. + Dans le netns, l'agent pose aussi la ``dummy`` ``hostsvc`` (``169.254.169.253/32``) et la chaîne iptables ``TWO-HOSTSVC``, puis demande à ``two-hostsvc`` de servir le VPC : c'est le chemin du DNS et du NTP des VM (voir :doc:`dns-ntp`). Si ``two-hostsvc`` ne répond pas, la création du VPC diff --git a/internal/nft/guard.go b/internal/nft/guard.go new file mode 100644 index 0000000..9bfa39f --- /dev/null +++ b/internal/nft/guard.go @@ -0,0 +1,28 @@ +package nft + +import ( + "fmt" + "strings" +) + +var guardChains = []natChain{ + {"in-", "filter", "input", "filter"}, + {"fwd-", "filter", "forward", "filter"}, +} + +func guardScript(bridge string) string { + var b strings.Builder + fmt.Fprintf(&b, "add table ip %s\n", Table) + for _, c := range guardChains { + name := c.declare(&b, bridge) + fmt.Fprintf(&b, "add rule ip %s %s iifname %q drop\n", Table, name, bridge) + } + return b.String() +} + +func SetBridgeGuard(bridge string) error { + if err := apply(guardScript(bridge)); err != nil { + return fmt.Errorf("guard %s: %w", bridge, err) + } + return nil +} diff --git a/internal/nft/guard_test.go b/internal/nft/guard_test.go new file mode 100644 index 0000000..95e1b46 --- /dev/null +++ b/internal/nft/guard_test.go @@ -0,0 +1,17 @@ +package nft + +import "testing" + +func TestGuardScript(t *testing.T) { + want := `add table ip two +add chain ip two in-br-public { type filter hook input priority filter; policy accept; } +flush chain ip two in-br-public +add rule ip two in-br-public iifname "br-public" drop +add chain ip two fwd-br-public { type filter hook forward priority filter; policy accept; } +flush chain ip two fwd-br-public +add rule ip two fwd-br-public iifname "br-public" drop +` + if got := guardScript("br-public"); got != want { + t.Errorf("script :\n%s\nattendu :\n%s", got, want) + } +} diff --git a/internal/sysctl/sysctl.go b/internal/sysctl/sysctl.go index 50f0a1a..9b7c599 100644 --- a/internal/sysctl/sysctl.go +++ b/internal/sysctl/sysctl.go @@ -1,7 +1,9 @@ package sysctl import ( + "errors" "fmt" + "io/fs" "os" "path/filepath" "strings" @@ -21,3 +23,13 @@ func Set(key, value string) error { } return f.Close() } + +func SetIfPresent(key, value string) (bool, error) { + path := filepath.Join(root, strings.ReplaceAll(key, ".", "/")) + if _, err := os.Stat(path); errors.Is(err, fs.ErrNotExist) { + return false, nil + } else if err != nil { + return false, fmt.Errorf("sysctl %s: %w", key, err) + } + return true, Set(key, value) +} diff --git a/internal/sysctl/sysctl_test.go b/internal/sysctl/sysctl_test.go index e07674f..6566f47 100644 --- a/internal/sysctl/sysctl_test.go +++ b/internal/sysctl/sysctl_test.go @@ -46,3 +46,25 @@ func TestSetRefusesAnUnknownKeyWithoutCreatingIt(t *testing.T) { t.Errorf("clé inconnue créée : %v", err) } } + +func TestSetIfPresentSkipsAnAbsentKey(t *testing.T) { + dir := fakeRoot(t) + set, err := SetIfPresent("net.bridge.bridge-nf-call-iptables", "0") + if err != nil || set { + t.Errorf("clé absente : %v, %v ; false, nil attendus", set, err) + } + if _, err := os.Stat(filepath.Join(dir, "net", "bridge")); err == nil { + t.Error("répertoire créé pour une clé absente") + } +} + +func TestSetIfPresentWritesAPresentKey(t *testing.T) { + dir := fakeRoot(t) + set, err := SetIfPresent("net.ipv4.ip_forward", "1") + if err != nil || !set { + t.Fatalf("clé présente : %v, %v", set, err) + } + if got, _ := os.ReadFile(filepath.Join(dir, "net", "ipv4", "ip_forward")); string(got) != "1" { + t.Errorf("contenu %q", got) + } +} diff --git a/internal/vpc/create.go b/internal/vpc/create.go index 8020a79..6d18437 100644 --- a/internal/vpc/create.go +++ b/internal/vpc/create.go @@ -32,6 +32,10 @@ func CreateVPC(db *badger.DB, name string, cfg *configuration.Config) error { return err } + if err := netns.Call(name, guardPublicBridge); err != nil { + return err + } + if err := netif.BridgeSetMaster("vp-"+vpcID+"-e", cfg.PublicBridge()); err != nil { return err } diff --git a/internal/vpc/guard.go b/internal/vpc/guard.go new file mode 100644 index 0000000..d6f9cbd --- /dev/null +++ b/internal/vpc/guard.go @@ -0,0 +1,26 @@ +package vpc + +import ( + "git.g3e.fr/syonad/two/internal/nft" + "git.g3e.fr/syonad/two/internal/sysctl" +) + +const netnsPublicBridge = "br-public" + +var bridgeNetfilterKeys = []string{ + "net.bridge.bridge-nf-call-iptables", + "net.bridge.bridge-nf-call-ip6tables", + "net.bridge.bridge-nf-call-arptables", +} + +func guardPublicBridge() error { + for _, key := range bridgeNetfilterKeys { + if _, err := sysctl.SetIfPresent(key, "0"); err != nil { + return err + } + } + if err := sysctl.Set("net.ipv4.conf."+netnsPublicBridge+".arp_ignore", "1"); err != nil { + return err + } + return nft.SetBridgeGuard(netnsPublicBridge) +} diff --git a/release_notes/0.3.0.md b/release_notes/0.3.0.md index ad333b1..dc46da6 100644 --- a/release_notes/0.3.0.md +++ b/release_notes/0.3.0.md @@ -107,6 +107,14 @@ `delete vxlan: Link not found` et le watchdog a signalé `br-000000` et des VRF absents. L'agent revient désormais au netns du thread courant, et un thread qui ne peut pas y revenir est détruit au lieu d'être réutilisé. La création d'un netns est corrigée de la même façon +- **Rien n'entre plus dans un VPC par le `br-public` de son netns (#42).** Ce bridge, qui relie le + netns au segment public de l'hôte, répondait à l'ARP pour toutes les adresses du netns + (`arp_ignore=0`) et laissait entrer l'IP : un équipement du segment public pouvait router vers + les VM du VPC (mesuré en lab). L'agent pose désormais `arp_ignore=1` sur ce bridge et rejette en + nftables tout IP arrivé par lui +- **`br_netfilter` est désactivé dans le netns de chaque VPC (#42)** quand le module est chargé + (`bridge-nf-call-iptables`, `-ip6tables`, `-arptables` à 0) : conntrack voyait chaque trame + pontée, et le SNAT de la passerelle NAT ne s'appliquait pas (mesuré en lab) - **Le serveur de métadonnées crée sa socket dans le netns du VPC (#92).** Il faisait entrer un seul thread dans le VPC, puis créait sa socket sur le thread où il s'exécutait à cet instant : sur un autre thread, la socket était créée dans le netns de l'hôte, l'écoute échouait et le @@ -139,6 +147,9 @@ la fuite vers l'underlay décrite plus haut reste possible. Pour la fermer sans recréer le VPC, la poser à la main sur chaque hyperviseur, la table étant le `l3vni` du VPC : `ip route replace unreachable default metric 4278198272 table ` +- **`br-public` du netns (#42) : seuls les VPC créés par la 0.3.0 sont protégés.** L'agent ne + reprend pas les VPC existants au démarrage : recréer chaque VPC pour fermer l'entrée par le + segment public - **Passerelle NAT (#42) : seuls les VPC créés par la 0.3.0 peuvent s'en servir.** Les VPC routés existants n'envoient pas leur route par défaut vers la VRF et leur route-map n'exporte pas celle de la passerelle ; l'agent ne les reprend pas au démarrage. Recréer le VPC avant de