538 lines
15 KiB
Go
538 lines
15 KiB
Go
package hostsvc
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"errors"
|
|
"net"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.g3e.fr/syonad/two/pkg/db/statefile"
|
|
)
|
|
|
|
type fakeClock struct {
|
|
now time.Time
|
|
synced bool
|
|
maxError time.Duration
|
|
err error
|
|
}
|
|
|
|
func (c fakeClock) Now() time.Time { return c.now }
|
|
func (c fakeClock) Sync() (bool, time.Duration, error) {
|
|
return c.synced, c.maxError, c.err
|
|
}
|
|
|
|
type netnsRecorder struct {
|
|
mu sync.Mutex
|
|
entered []string
|
|
fail error
|
|
}
|
|
|
|
func (r *netnsRecorder) enter(vpc string, fn func() error) error {
|
|
r.mu.Lock()
|
|
r.entered = append(r.entered, vpc)
|
|
r.mu.Unlock()
|
|
if err := fn(); err != nil {
|
|
return err
|
|
}
|
|
return r.fail
|
|
}
|
|
|
|
func (r *netnsRecorder) calls() []string {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
return append([]string{}, r.entered...)
|
|
}
|
|
|
|
func emptyResolv(t *testing.T) string {
|
|
t.Helper()
|
|
path := filepath.Join(t.TempDir(), "resolv.conf")
|
|
if err := os.WriteFile(path, nil, 0o644); err != nil {
|
|
t.Fatalf("WriteFile: %v", err)
|
|
}
|
|
return path
|
|
}
|
|
|
|
func newService(t *testing.T, opts Options) (*Service, *netnsRecorder, string) {
|
|
t.Helper()
|
|
rec := &netnsRecorder{}
|
|
opts.DNSListen = "127.0.0.1:0"
|
|
opts.NTPListen = "127.0.0.1:0"
|
|
if opts.Rate == 0 {
|
|
opts.Rate = 100
|
|
}
|
|
if opts.Resolv == "" {
|
|
opts.Resolv = emptyResolv(t)
|
|
}
|
|
if opts.Clock == nil {
|
|
opts.Clock = fakeClock{now: time.Unix(2000, 0), synced: true}
|
|
}
|
|
if opts.Timeout == 0 {
|
|
opts.Timeout = 300 * time.Millisecond
|
|
}
|
|
opts.Enter = rec.enter
|
|
if opts.Exists == nil {
|
|
opts.Exists = func(string) bool { return true }
|
|
}
|
|
statePath := filepath.Join(t.TempDir(), "hostsvc.state")
|
|
s, err := New(opts, statePath)
|
|
if err != nil {
|
|
t.Fatalf("New: %v", err)
|
|
}
|
|
t.Cleanup(func() { s.Shutdown() })
|
|
return s, rec, statePath
|
|
}
|
|
|
|
func (s *Service) addrs(t *testing.T, vpc string) (dnsUDP, dnsTCP, ntp string) {
|
|
t.Helper()
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
inst, ok := s.vpcs[vpc]
|
|
if !ok {
|
|
t.Fatalf("vpc %s is not open", vpc)
|
|
}
|
|
return inst.udpDNS.LocalAddr().String(), inst.tcpDNS.Addr().String(), inst.udpNTP.LocalAddr().String()
|
|
}
|
|
|
|
func savedVPCs(t *testing.T, path string) []string {
|
|
t.Helper()
|
|
st, err := statefile.New[State](path).Load()
|
|
if err != nil {
|
|
t.Fatalf("load state: %v", err)
|
|
}
|
|
return st.VPCs
|
|
}
|
|
|
|
func udpUpstream(t *testing.T, reply func(req []byte) [][]byte) (string, func() int) {
|
|
t.Helper()
|
|
conn, err := net.ListenPacket("udp4", "127.0.0.1:0")
|
|
if err != nil {
|
|
t.Fatalf("ListenPacket: %v", err)
|
|
}
|
|
t.Cleanup(func() { conn.Close() })
|
|
var mu sync.Mutex
|
|
count := 0
|
|
go func() {
|
|
buf := make([]byte, 65535)
|
|
for {
|
|
n, from, err := conn.ReadFrom(buf)
|
|
if err != nil {
|
|
return
|
|
}
|
|
mu.Lock()
|
|
count++
|
|
mu.Unlock()
|
|
for _, r := range reply(append([]byte{}, buf[:n]...)) {
|
|
conn.WriteTo(r, from)
|
|
}
|
|
}
|
|
}()
|
|
return conn.LocalAddr().String(), func() int {
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
return count
|
|
}
|
|
}
|
|
|
|
func tcpUpstream(t *testing.T) string {
|
|
t.Helper()
|
|
l, err := net.Listen("tcp4", "127.0.0.1:0")
|
|
if err != nil {
|
|
t.Fatalf("Listen: %v", err)
|
|
}
|
|
t.Cleanup(func() { l.Close() })
|
|
go func() {
|
|
for {
|
|
conn, err := l.Accept()
|
|
if err != nil {
|
|
return
|
|
}
|
|
go func() {
|
|
defer conn.Close()
|
|
q, err := readTCPMessage(conn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
writeTCPMessage(conn, answerTo(q))
|
|
}()
|
|
}
|
|
}()
|
|
return l.Addr().String()
|
|
}
|
|
|
|
func deadAddr(t *testing.T) string {
|
|
t.Helper()
|
|
conn, err := net.ListenPacket("udp4", "127.0.0.1:0")
|
|
if err != nil {
|
|
t.Fatalf("ListenPacket: %v", err)
|
|
}
|
|
addr := conn.LocalAddr().String()
|
|
conn.Close()
|
|
return addr
|
|
}
|
|
|
|
func ask(t *testing.T, addr string, msg []byte, wait time.Duration) ([]byte, error) {
|
|
t.Helper()
|
|
conn, err := net.Dial("udp4", addr)
|
|
if err != nil {
|
|
t.Fatalf("Dial: %v", err)
|
|
}
|
|
defer conn.Close()
|
|
conn.SetDeadline(time.Now().Add(wait))
|
|
if _, err := conn.Write(msg); err != nil {
|
|
t.Fatalf("Write: %v", err)
|
|
}
|
|
buf := make([]byte, 65535)
|
|
n, err := conn.Read(buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf[:n], nil
|
|
}
|
|
|
|
func TestNew_RefusesANullRate(t *testing.T) {
|
|
if _, err := New(Options{Rate: 0}, filepath.Join(t.TempDir(), "s")); err == nil || !strings.Contains(err.Error(), "rate limit 0") {
|
|
t.Errorf("error %v: a null rate would silently drop every request", err)
|
|
}
|
|
}
|
|
|
|
func TestOpen_EntersTheVPCNetnsAndSavesIt(t *testing.T) {
|
|
s, rec, statePath := newService(t, Options{})
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
if got := rec.calls(); !reflect.DeepEqual(got, []string{"vpc-00001"}) {
|
|
t.Errorf("netns entered = %v, want the vpc's", got)
|
|
}
|
|
if got := savedVPCs(t, statePath); !reflect.DeepEqual(got, []string{"vpc-00001"}) {
|
|
t.Errorf("state = %v", got)
|
|
}
|
|
if got := s.List(); !reflect.DeepEqual(got, []string{"vpc-00001"}) {
|
|
t.Errorf("List = %v", got)
|
|
}
|
|
}
|
|
|
|
func TestOpen_IsIdempotent(t *testing.T) {
|
|
s, rec, _ := newService(t, Options{})
|
|
for i := 0; i < 2; i++ {
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open %d: %v", i+1, err)
|
|
}
|
|
}
|
|
if got := rec.calls(); len(got) != 1 {
|
|
t.Errorf("netns entered %d times, want once: a second open must not bind again", len(got))
|
|
}
|
|
}
|
|
|
|
func TestOpen_InvalidNamesAreRefusedWithoutEnteringAnything(t *testing.T) {
|
|
s, rec, statePath := newService(t, Options{})
|
|
for _, name := range []string{"", ".", "..", "../etc", "a/b", "x\x00y"} {
|
|
if err := s.Open(name); err == nil || !strings.Contains(err.Error(), "invalid vpc name") {
|
|
t.Errorf("Open(%q): error %v", name, err)
|
|
}
|
|
if err := s.Close(name); err == nil || !strings.Contains(err.Error(), "invalid vpc name") {
|
|
t.Errorf("Close(%q): error %v", name, err)
|
|
}
|
|
}
|
|
if got := rec.calls(); len(got) != 0 {
|
|
t.Errorf("netns entered for an invalid name: %v", got)
|
|
}
|
|
if got := savedVPCs(t, statePath); len(got) != 0 {
|
|
t.Errorf("state = %v, want empty", got)
|
|
}
|
|
}
|
|
|
|
func TestOpen_FailureLeavesNothingBehind(t *testing.T) {
|
|
s, rec, statePath := newService(t, Options{})
|
|
rec.fail = errors.New("boom")
|
|
if err := s.Open("vpc-00001"); err == nil || !strings.Contains(err.Error(), "open vpc vpc-00001: boom") {
|
|
t.Fatalf("error %v", err)
|
|
}
|
|
if got := s.List(); len(got) != 0 {
|
|
t.Errorf("List = %v, want empty after a failed open", got)
|
|
}
|
|
if got := savedVPCs(t, statePath); len(got) != 0 {
|
|
t.Errorf("state = %v, want empty", got)
|
|
}
|
|
}
|
|
|
|
func TestClose_StopsServingAndForgetsTheVPC(t *testing.T) {
|
|
up, _ := udpUpstream(t, func(q []byte) [][]byte { return [][]byte{answerTo(q)} })
|
|
s, _, statePath := newService(t, Options{DNS: []string{up}})
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
dns, _, _ := s.addrs(t, "vpc-00001")
|
|
if _, err := ask(t, dns, query(1), time.Second); err != nil {
|
|
t.Fatalf("witness: the open vpc must answer: %v", err)
|
|
}
|
|
if err := s.Close("vpc-00001"); err != nil {
|
|
t.Fatalf("Close: %v", err)
|
|
}
|
|
if _, err := ask(t, dns, query(2), 300*time.Millisecond); err == nil {
|
|
t.Error("a closed vpc still answers")
|
|
}
|
|
if got := savedVPCs(t, statePath); len(got) != 0 {
|
|
t.Errorf("state = %v, want empty", got)
|
|
}
|
|
if err := s.Close("vpc-00001"); err != nil {
|
|
t.Errorf("closing twice must succeed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRestore_ReopensOnlyTheVPCsWhoseNetnsExists(t *testing.T) {
|
|
statePath := filepath.Join(t.TempDir(), "hostsvc.state")
|
|
if err := statefile.New[State](statePath).Save(State{VPCs: []string{"vpc-gone", "vpc-here"}}); err != nil {
|
|
t.Fatalf("Save: %v", err)
|
|
}
|
|
rec := &netnsRecorder{}
|
|
s, err := New(Options{
|
|
Rate: 10, DNSListen: "127.0.0.1:0", NTPListen: "127.0.0.1:0", Resolv: emptyResolv(t),
|
|
Enter: rec.enter,
|
|
Exists: func(vpc string) bool { return vpc == "vpc-here" },
|
|
}, statePath)
|
|
if err != nil {
|
|
t.Fatalf("New: %v", err)
|
|
}
|
|
t.Cleanup(func() { s.Shutdown() })
|
|
if err := s.Restore(); err != nil {
|
|
t.Fatalf("Restore: %v", err)
|
|
}
|
|
if got := rec.calls(); !reflect.DeepEqual(got, []string{"vpc-here"}) {
|
|
t.Errorf("netns entered = %v, want only vpc-here", got)
|
|
}
|
|
if got := savedVPCs(t, statePath); !reflect.DeepEqual(got, []string{"vpc-here"}) {
|
|
t.Errorf("state = %v, the vanished vpc must be dropped", got)
|
|
}
|
|
}
|
|
|
|
func TestDNS_UDPQueryIsRelayedToTheUpstream(t *testing.T) {
|
|
var got []byte
|
|
var mu sync.Mutex
|
|
up, _ := udpUpstream(t, func(q []byte) [][]byte {
|
|
mu.Lock()
|
|
got = q
|
|
mu.Unlock()
|
|
return [][]byte{answerTo(q)}
|
|
})
|
|
s, _, _ := newService(t, Options{DNS: []string{up}})
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
dns, _, _ := s.addrs(t, "vpc-00001")
|
|
reply, err := ask(t, dns, query(0x4242), time.Second)
|
|
if err != nil {
|
|
t.Fatalf("no answer: %v", err)
|
|
}
|
|
if !bytes.Equal(reply, answerTo(query(0x4242))) {
|
|
t.Errorf("reply = %x, want the upstream's answer untouched", reply)
|
|
}
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
if !bytes.Equal(got, query(0x4242)) {
|
|
t.Errorf("upstream received %x, want the query untouched", got)
|
|
}
|
|
}
|
|
|
|
func TestDNS_SpoofedAnswerIsIgnored(t *testing.T) {
|
|
up, _ := udpUpstream(t, func(q []byte) [][]byte {
|
|
bad := answerTo(q)
|
|
bad[0] ^= 0xff
|
|
return [][]byte{bad, answerTo(q)}
|
|
})
|
|
s, _, _ := newService(t, Options{DNS: []string{up}})
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
dns, _, _ := s.addrs(t, "vpc-00001")
|
|
reply, err := ask(t, dns, query(0x1000), time.Second)
|
|
if err != nil {
|
|
t.Fatalf("no answer: %v", err)
|
|
}
|
|
if binary.BigEndian.Uint16(reply[0:2]) != 0x1000 {
|
|
t.Errorf("reply id = %#x, the answer with a foreign id must be skipped", binary.BigEndian.Uint16(reply[0:2]))
|
|
}
|
|
}
|
|
|
|
func TestDNS_NextUpstreamWhenTheFirstIsDown(t *testing.T) {
|
|
up, _ := udpUpstream(t, func(q []byte) [][]byte { return [][]byte{answerTo(q)} })
|
|
s, _, _ := newService(t, Options{DNS: []string{deadAddr(t), up}})
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
dns, _, _ := s.addrs(t, "vpc-00001")
|
|
if _, err := ask(t, dns, query(3), 2*time.Second); err != nil {
|
|
t.Fatalf("the second upstream must answer: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDNS_HostResolverComesAfterTheConfiguredUpstreams(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), "resolv.conf")
|
|
if err := os.WriteFile(path, []byte("nameserver 192.0.2.1\n"), 0o644); err != nil {
|
|
t.Fatalf("WriteFile: %v", err)
|
|
}
|
|
s, _, _ := newService(t, Options{DNS: []string{"198.51.100.1:53"}, Resolv: path})
|
|
if got, want := s.dnsServers(), []string{"198.51.100.1:53", "192.0.2.1:53"}; !reflect.DeepEqual(got, want) {
|
|
t.Errorf("dnsServers = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestDNS_InvalidQueryGetsNoAnswerAndIsNotRelayed(t *testing.T) {
|
|
up, count := udpUpstream(t, func(q []byte) [][]byte { return [][]byte{answerTo(q)} })
|
|
s, _, _ := newService(t, Options{DNS: []string{up}})
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
dns, _, _ := s.addrs(t, "vpc-00001")
|
|
if _, err := ask(t, dns, answerTo(query(5)), 300*time.Millisecond); err == nil {
|
|
t.Error("a response sent to the relay must not be answered")
|
|
}
|
|
if _, err := ask(t, dns, query(6), time.Second); err != nil {
|
|
t.Fatalf("witness: a valid query must be answered: %v", err)
|
|
}
|
|
if n := count(); n != 1 {
|
|
t.Errorf("upstream saw %d messages, want only the valid one", n)
|
|
}
|
|
}
|
|
|
|
func TestDNS_TCPQueryIsRelayed(t *testing.T) {
|
|
s, _, _ := newService(t, Options{DNS: []string{tcpUpstream(t)}})
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
_, tcp, _ := s.addrs(t, "vpc-00001")
|
|
conn, err := net.Dial("tcp4", tcp)
|
|
if err != nil {
|
|
t.Fatalf("Dial: %v", err)
|
|
}
|
|
defer conn.Close()
|
|
conn.SetDeadline(time.Now().Add(2 * time.Second))
|
|
for id := uint16(1); id <= 2; id++ {
|
|
if err := writeTCPMessage(conn, query(id)); err != nil {
|
|
t.Fatalf("write: %v", err)
|
|
}
|
|
reply, err := readTCPMessage(conn)
|
|
if err != nil {
|
|
t.Fatalf("query %d: no answer: %v", id, err)
|
|
}
|
|
if !bytes.Equal(reply, answerTo(query(id))) {
|
|
t.Errorf("query %d: reply %x", id, reply)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDNS_RateLimitPerVPC(t *testing.T) {
|
|
up, _ := udpUpstream(t, func(q []byte) [][]byte { return [][]byte{answerTo(q)} })
|
|
s, _, _ := newService(t, Options{DNS: []string{up}, Rate: 2})
|
|
for _, vpc := range []string{"vpc-00001", "vpc-00002"} {
|
|
if err := s.Open(vpc); err != nil {
|
|
t.Fatalf("Open %s: %v", vpc, err)
|
|
}
|
|
}
|
|
dns1, _, _ := s.addrs(t, "vpc-00001")
|
|
dns2, _, _ := s.addrs(t, "vpc-00002")
|
|
for i := 0; i < 2; i++ {
|
|
if _, err := ask(t, dns1, query(uint16(i)), time.Second); err != nil {
|
|
t.Fatalf("query %d within the burst: %v", i+1, err)
|
|
}
|
|
}
|
|
if _, err := ask(t, dns1, query(9), 200*time.Millisecond); err == nil {
|
|
t.Error("the third query in a row must be dropped at 2 per second")
|
|
}
|
|
if _, err := ask(t, dns2, query(10), time.Second); err != nil {
|
|
t.Errorf("another vpc has its own bucket: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNTP_HostClockWithoutUpstream(t *testing.T) {
|
|
clock := fakeClock{now: time.Unix(5000, 0), synced: true, maxError: time.Second}
|
|
s, _, _ := newService(t, Options{Clock: clock})
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
_, _, ntp := s.addrs(t, "vpc-00001")
|
|
req := ntpRequest(4, 0xabcdef)
|
|
reply, err := ask(t, ntp, req, time.Second)
|
|
if err != nil {
|
|
t.Fatalf("no answer: %v", err)
|
|
}
|
|
if err := validNTPAnswer(req, reply); err != nil {
|
|
t.Fatalf("invalid answer: %v", err)
|
|
}
|
|
if got := binary.BigEndian.Uint64(reply[40:48]); got != ntpTimestamp(clock.now) {
|
|
t.Errorf("transmit = %#x, want the host clock %#x", got, ntpTimestamp(clock.now))
|
|
}
|
|
if reply[0]>>6 != 0 || reply[1] != 3 {
|
|
t.Errorf("li %d stratum %d, want 0 and 3 for a synced host", reply[0]>>6, reply[1])
|
|
}
|
|
}
|
|
|
|
func TestNTP_UnreadableClockStatusIsAnsweredAsUnsynced(t *testing.T) {
|
|
s, _, _ := newService(t, Options{Clock: fakeClock{now: time.Unix(5000, 0), synced: true, err: errors.New("eperm")}})
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
_, _, ntp := s.addrs(t, "vpc-00001")
|
|
reply, err := ask(t, ntp, ntpRequest(4, 1), time.Second)
|
|
if err != nil {
|
|
t.Fatalf("no answer: %v", err)
|
|
}
|
|
if reply[0]>>6 != 3 {
|
|
t.Errorf("li = %d, want 3 when the clock status cannot be read", reply[0]>>6)
|
|
}
|
|
}
|
|
|
|
func TestNTP_UpstreamIsPreferredAndChecked(t *testing.T) {
|
|
up, _ := udpUpstream(t, func(req []byte) [][]byte {
|
|
spoofed := hostReply(ntpRequest(4, 0), time.Unix(0, 0), time.Unix(0, 0), true, 0)
|
|
real := hostReply(req, time.Unix(7000, 0), time.Unix(7000, 0), true, 0)
|
|
real[1] = 1
|
|
return [][]byte{spoofed, real}
|
|
})
|
|
s, _, _ := newService(t, Options{NTP: []string{up}})
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
_, _, ntp := s.addrs(t, "vpc-00001")
|
|
req := ntpRequest(4, 0x55)
|
|
reply, err := ask(t, ntp, req, time.Second)
|
|
if err != nil {
|
|
t.Fatalf("no answer: %v", err)
|
|
}
|
|
if reply[1] != 1 {
|
|
t.Errorf("stratum = %d, want the upstream's 1 (spoofed answer skipped, host clock unused)", reply[1])
|
|
}
|
|
}
|
|
|
|
func TestNTP_HostClockWhenUpstreamsFail(t *testing.T) {
|
|
clock := fakeClock{now: time.Unix(6000, 0), synced: true}
|
|
s, _, _ := newService(t, Options{NTP: []string{deadAddr(t)}, Clock: clock})
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
_, _, ntp := s.addrs(t, "vpc-00001")
|
|
reply, err := ask(t, ntp, ntpRequest(4, 2), 2*time.Second)
|
|
if err != nil {
|
|
t.Fatalf("no answer: %v", err)
|
|
}
|
|
if got := binary.BigEndian.Uint64(reply[40:48]); got != ntpTimestamp(clock.now) {
|
|
t.Errorf("transmit = %#x, want the host clock as fallback", got)
|
|
}
|
|
}
|
|
|
|
func TestNTP_InvalidRequestGetsNoAnswer(t *testing.T) {
|
|
s, _, _ := newService(t, Options{})
|
|
if err := s.Open("vpc-00001"); err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
_, _, ntp := s.addrs(t, "vpc-00001")
|
|
if _, err := ask(t, ntp, []byte("not ntp"), 300*time.Millisecond); err == nil {
|
|
t.Error("a short packet must not be answered")
|
|
}
|
|
}
|