systemd-resolved: let a network's own servers answer while the mesh's resolvers are silent (issue 1981)

Behind a guest network's sign-in page the private network is out of reach,
and the guard sent every name to the mesh's resolvers, so the sign-in page
itself could not be found. The guard now asks the mesh's resolvers each
round and gives the links it turned off their default route back while none
answers; once one answers they lose it again.
This commit is contained in:
jochen
2026-11-19 09:31:54 +01:00
parent be993cb2c5
commit cddfeba266
5 changed files with 199 additions and 4 deletions
@@ -90,6 +90,11 @@ type Guard struct {
pending *Displacement
history []Displacement
wake chan struct{}
// keptFrom is the links the guard kept from answering every name; silent is whether none of the
// mesh's resolvers answered at the last look. Only the routes' loop reads and writes them.
keptFrom map[string]bool
silent bool
}
// NewGuard is the machine's.
@@ -330,13 +335,47 @@ func (g *Guard) Run(ctx context.Context) {
case <-g.wake:
g.Tick()
case <-routes.C:
if changed, err := g.Resolver.OnlyTheMeshIsADefaultRoute(ctx); err == nil && len(changed) > 0 {
g.Log("%s had servers answering every name; now only their own domains", strings.Join(changed, ", "))
}
g.KeepRoutes(ctx)
}
}
}
// KeepRoutes keeps every link's own servers from being a default route while one of the mesh's resolvers
// answers. While none does, as behind a network's sign-in page, the links it kept from it answer every name
// again, so the page can be found; once one answers, they are kept from it once more.
func (g *Guard) KeepRoutes(ctx context.Context) {
routes, err := g.Resolver.Routes(ctx)
if err != nil {
return
}
if !g.Resolver.TheMeshAnswers(ctx, routes.Mesh.Servers) {
if !g.silent {
g.silent = true
g.Log("none of the mesh's resolvers answers; a network's own servers answer every name until one does")
}
if changed, err := g.Resolver.ADefaultRouteAgain(ctx, routes, g.keptFrom); err == nil && len(changed) > 0 {
g.Log("%s answers every name again, while the mesh's resolvers are silent", strings.Join(changed, ", "))
}
return
}
if g.silent {
g.silent = false
g.Log("one of the mesh's resolvers answers again")
}
changed, err := g.Resolver.OnlyTheMeshIsADefaultRoute(ctx)
if len(changed) > 0 {
if g.keptFrom == nil {
g.keptFrom = map[string]bool{}
}
for _, l := range changed {
g.keptFrom[l] = true
}
}
if err == nil && len(changed) > 0 {
g.Log("%s had servers answering every name; now only their own domains", strings.Join(changed, ", "))
}
}
// Request is one call over the socket: a verb and its arguments, one JSON line.
type Request struct {
Verb string `json:"verb"`
@@ -249,3 +249,53 @@ func TestTheVerbsOnTheMachine(t *testing.T) {
t.Errorf("the mesh's domain over the socket: %+v", r)
}
}
// Behind a network's sign-in page the mesh's resolvers are out of reach, so the links the guard kept from
// answering every name answer them again until one of the mesh's resolvers answers; then they are kept
// from it once more. A routed link the guard never changed is left alone. (1981/AC1)
func TestTheNetworksServersAnswerWhileTheMeshsResolversAreSilent(t *testing.T) {
g, _, f := aGuardedMachine(t)
meshAnswers := true
g.Resolver.Answers = func(_ context.Context, server string) bool { return meshAnswers && server == "10.42.0.1" }
f.dns = "Global: 10.42.0.1 10.42.0.2\nLink 2 (wlan0): 192.168.1.1\nLink 7 (tun0): 10.9.0.1\n"
f.domain = "Global: ~.\nLink 2 (wlan0): lan\nLink 7 (tun0): ~corp.example\n"
ctx := context.Background()
step := func(defaults string, want ...string) {
t.Helper()
f.defaults, f.changed = defaults, nil
g.KeepRoutes(ctx)
var got []string
for _, c := range f.changed {
got = append(got, strings.Join(c, " "))
}
if strings.Join(got, "; ") != strings.Join(want, "; ") {
t.Errorf("changed %q, want %q", got, want)
}
}
step("Link 2 (wlan0): yes\nLink 7 (tun0): no\n", "resolvectl default-route wlan0 false")
meshAnswers = false
step("Link 2 (wlan0): no\nLink 7 (tun0): no\n", "resolvectl default-route wlan0 true")
step("Link 2 (wlan0): yes\nLink 7 (tun0): no\n")
meshAnswers = true
step("Link 2 (wlan0): yes\nLink 7 (tun0): no\n", "resolvectl default-route wlan0 false")
}
// A network joined while the mesh's resolvers are silent keeps its default route, and loses it once one answers.
// (1981/AC2)
func TestANetworkJoinedWhileTheMeshIsSilentKeepsItsDefaultRoute(t *testing.T) {
g, _, f := aGuardedMachine(t)
meshAnswers := false
g.Resolver.Answers = func(context.Context, string) bool { return meshAnswers }
f.dns = "Global: 10.42.0.1\nLink 2 (wlan0): 192.168.1.1\n"
f.domain = "Global: ~.\n"
f.defaults = "Link 2 (wlan0): yes\n"
g.KeepRoutes(context.Background())
if len(f.changed) != 0 {
t.Errorf("changed %v while the mesh was silent", f.changed)
}
meshAnswers = true
g.KeepRoutes(context.Background())
if len(f.changed) != 1 || strings.Join(f.changed[0], " ") != "resolvectl default-route wlan0 false" {
t.Errorf("changed %v once the mesh answered", f.changed)
}
}
@@ -16,6 +16,7 @@ import (
"context"
"errors"
"fmt"
"net"
"net/netip"
"os"
"os/exec"
@@ -85,11 +86,35 @@ type Resolver struct {
NetDir string
// SuffixFile holds the mesh's own domain, which is never routed elsewhere.
SuffixFile string
// Answers says whether one of the mesh's resolvers answers a name now.
Answers func(ctx context.Context, server string) bool
}
// ThisResolver is the machine's.
func ThisResolver() *Resolver {
return &Resolver{Change: execRunner, Read: readRunner, NetDir: "/sys/class/net", SuffixFile: SuffixPath}
r := &Resolver{Change: execRunner, Read: readRunner, NetDir: "/sys/class/net", SuffixFile: SuffixPath}
r.Answers = r.asks
return r
}
// AnswerWithin is how long one of the mesh's resolvers is given to answer the guard's question.
var AnswerWithin = time.Second
// asks one of the mesh's resolvers a name under the mesh's own domain, straight over the network and not
// through resolved: any answer, a name not found included, is an answer; only silence is not.
func (r *Resolver) asks(ctx context.Context, server string) bool {
ctx, cancel := context.WithTimeout(ctx, AnswerWithin)
defer cancel()
ask := &net.Resolver{PreferGo: true, Dial: func(ctx context.Context, network, _ string) (net.Conn, error) {
var d net.Dialer
if _, _, err := net.SplitHostPort(server); err == nil {
return d.DialContext(ctx, network, server)
}
return d.DialContext(ctx, network, net.JoinHostPort(server, "53"))
}}
_, err := ask.LookupHost(ctx, "node-resolver-asks."+r.suffix())
var dnsErr *net.DNSError
return err == nil || (errors.As(err, &dnsErr) && dnsErr.IsNotFound)
}
// SuffixPath is the file the mesh renders the mesh's own domain into (the manifest's fact `suffix`).
@@ -376,3 +401,35 @@ func (r *Resolver) OnlyTheMeshIsADefaultRoute(ctx context.Context) ([]string, er
}
return changed, nil
}
// TheMeshAnswers says whether one of the mesh's resolvers answers now, asking them all at once. Behind a
// network's sign-in page none does: the private network is out of reach until the person signs in.
func (r *Resolver) TheMeshAnswers(ctx context.Context, servers []string) bool {
answered := make(chan bool, len(servers))
for _, s := range servers {
go func() { answered <- r.Answers(ctx, s) }()
}
for range servers {
if <-answered {
return true
}
}
return false
}
// ADefaultRouteAgain lets the links named answer every name again, while the mesh's resolvers are silent:
// a network's own servers are then the only ones that can find its sign-in page. A link that went, or
// already answers every name, is left alone. Answers the links it changed.
func (r *Resolver) ADefaultRouteAgain(ctx context.Context, routes *Routes, links map[string]bool) ([]string, error) {
var changed []string
for _, l := range routes.Links {
if !links[l.Link] || (l.DefaultRoute != nil && *l.DefaultRoute) {
continue
}
if _, err := r.Change(ctx, "resolvectl", "default-route", l.Link, "true"); err != nil {
return changed, err
}
changed = append(changed, l.Link)
}
return changed, nil
}
@@ -2,10 +2,12 @@ package main
import (
"context"
"net"
"os"
"path/filepath"
"strings"
"testing"
"time"
)
// fakeResolved answers resolvectl as systemd-resolved would, and records what was asked of it.
@@ -170,3 +172,43 @@ func TestChangesAreEscalatedOnlyWhenNotRoot(t *testing.T) {
t.Errorf("as the account: %s %v", p, a)
}
}
// One of the mesh's resolvers answers when it says anything, a name not found included; one that is silent
// does not, and the guard does not wait on it past AnswerWithin. (1981/AC3)
func TestAResolverAnswersUnlessItIsSilent(t *testing.T) {
conn, err := net.ListenPacket("udp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer conn.Close()
go func() {
buf := make([]byte, 512)
for {
n, from, err := conn.ReadFrom(buf)
if err != nil {
return
}
reply := append([]byte{}, buf[:n]...)
reply[2], reply[3] = 0x81, 0x83 // a reply, recursion available, the name not found
conn.WriteTo(reply, from)
}
}()
silent, err := net.ListenPacket("udp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer silent.Close()
defer func(was time.Duration) { AnswerWithin = was }(AnswerWithin)
AnswerWithin = 100 * time.Millisecond
r := aMachine(t, &fakeResolved{})
if !r.asks(context.Background(), conn.LocalAddr().String()) {
t.Error("a resolver that said the name is not found did not answer")
}
start := time.Now()
if r.asks(context.Background(), silent.LocalAddr().String()) {
t.Error("a silent resolver answered")
}
if took := time.Since(start); took > AnswerWithin+200*time.Millisecond {
t.Errorf("a silent resolver was waited on %v", took)
}
}