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.
149 lines
5.3 KiB
Go
149 lines
5.3 KiB
Go
//go:build linux
|
|
|
|
package publicguard
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
emptyTablesJSON = `{"nftables":[]}`
|
|
ownedTableJSON = `{"nftables":[{"table":{"family":"bridge","name":"virt_cloud_public_guard"}},` +
|
|
`{"chain":{"family":"bridge","table":"virt_cloud_public_guard","name":"owner_v1"}}]}`
|
|
foreignTableJSON = `{"nftables":[{"table":{"family":"bridge","name":"virt_cloud_public_guard"}},` +
|
|
`{"chain":{"family":"bridge","table":"virt_cloud_public_guard","name":"foreign"}}]}`
|
|
)
|
|
|
|
type runnerCall struct {
|
|
arguments []string
|
|
input string
|
|
}
|
|
|
|
type projectionRunner struct {
|
|
mu sync.Mutex
|
|
t *testing.T
|
|
tables string
|
|
current string
|
|
calls []runnerCall
|
|
}
|
|
|
|
func (runner *projectionRunner) Run(_ context.Context, _ string, arguments []string, input []byte) ([]byte, error) {
|
|
runner.mu.Lock()
|
|
defer runner.mu.Unlock()
|
|
runner.calls = append(runner.calls, runnerCall{arguments: append([]string(nil), arguments...), input: string(input)})
|
|
switch strings.Join(arguments, " ") {
|
|
case "--check -f -":
|
|
return nil, nil
|
|
case "-f -":
|
|
runner.current = string(guardProjectionJSON(runner.t, []Binding{guardTestBinding()}))
|
|
return nil, nil
|
|
case "-j list tables":
|
|
return []byte(runner.tables), nil
|
|
case "-j list table bridge virt_cloud_public_guard":
|
|
return []byte(runner.current), nil
|
|
default:
|
|
return nil, errors.New("unexpected nft invocation")
|
|
}
|
|
}
|
|
|
|
func (runner *projectionRunner) snapshot() []runnerCall {
|
|
runner.mu.Lock()
|
|
defer runner.mu.Unlock()
|
|
return append([]runnerCall(nil), runner.calls...)
|
|
}
|
|
|
|
func TestLinuxDriverAtomicallyChecksAndReplacesAnOwnedExistingTable(t *testing.T) {
|
|
runner := &projectionRunner{t: t, tables: ownedTableJSON, current: ownedTableJSON}
|
|
driver := &linuxDriver{nftPath: "/usr/sbin/nft", run: runner}
|
|
if err := driver.Reconcile(context.Background(), []Binding{guardTestBinding()}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := driver.Verify(context.Background(), []Binding{guardTestBinding()}); err != nil {
|
|
t.Fatalf("freshly applied projection was not verifiable: %v", err)
|
|
}
|
|
|
|
var checked, applied string
|
|
for _, call := range runner.snapshot() {
|
|
if !strings.Contains(call.input, "delete table bridge virt_cloud_public_guard") {
|
|
continue
|
|
}
|
|
switch strings.Join(call.arguments, " ") {
|
|
case "--check -f -":
|
|
checked = call.input
|
|
case "-f -":
|
|
applied = call.input
|
|
}
|
|
}
|
|
if checked == "" || applied == "" || checked != applied {
|
|
t.Fatalf("owned table replacement was not checked and applied as one identical batch: checked=%q applied=%q", checked, applied)
|
|
}
|
|
if strings.Contains(applied, "flush ruleset") || strings.Contains(applied, "flush table") ||
|
|
!strings.Contains(applied, "delete table bridge virt_cloud_public_guard\nadd table bridge virt_cloud_public_guard") {
|
|
t.Fatalf("unsafe or incomplete owned table replacement: %s", applied)
|
|
}
|
|
}
|
|
|
|
func TestLinuxDriverCreatesAMissingTableWithoutDeletingAnything(t *testing.T) {
|
|
runner := &projectionRunner{t: t, tables: emptyTablesJSON, current: ownedTableJSON}
|
|
driver := &linuxDriver{nftPath: "/usr/sbin/nft", run: runner}
|
|
if err := driver.Reconcile(context.Background(), []Binding{guardTestBinding()}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, call := range runner.snapshot() {
|
|
if strings.Join(call.arguments, " ") == "-f -" {
|
|
if strings.Contains(call.input, "delete table") || strings.Contains(call.input, "flush") ||
|
|
!strings.HasPrefix(call.input, "add table bridge virt_cloud_public_guard\n") {
|
|
t.Fatalf("missing table projection was unsafe: %s", call.input)
|
|
}
|
|
return
|
|
}
|
|
}
|
|
t.Fatal("missing table projection was not applied")
|
|
}
|
|
|
|
func TestLinuxDriverRefusesAReservedForeignTableBeforeMutation(t *testing.T) {
|
|
runner := &projectionRunner{t: t, tables: ownedTableJSON, current: foreignTableJSON}
|
|
driver := &linuxDriver{nftPath: "/usr/sbin/nft", run: runner}
|
|
if err := driver.Reconcile(context.Background(), []Binding{guardTestBinding()}); err == nil ||
|
|
!strings.Contains(err.Error(), "foreign") {
|
|
t.Fatalf("foreign reserved table error = %v", err)
|
|
}
|
|
for _, call := range runner.snapshot() {
|
|
if strings.Join(call.arguments, " ") == "-f -" {
|
|
t.Fatalf("foreign table was mutated: %#v", call)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRealNFTCheckAcceptsDeleteAndRecreateInOneBatch(t *testing.T) {
|
|
path := trustedBinary([]string{"/usr/sbin/nft", "/usr/bin/nft", "/sbin/nft", "/bin/nft"})
|
|
if path == "" {
|
|
t.Skip("nft executable is not installed")
|
|
}
|
|
name := "virt_cloud_pg_check_" + strconv.Itoa(os.Getpid())
|
|
script := "add table bridge " + name + "\n" +
|
|
"add chain bridge " + name + " owner_v1\n" +
|
|
"delete table bridge " + name + "\n" +
|
|
"add table bridge " + name + "\n" +
|
|
"add chain bridge " + name + " owner_v1\n" +
|
|
"add chain bridge " + name + " ingress { type filter hook prerouting priority -320; policy accept; }\n" +
|
|
"add rule bridge " + name + " ingress ether type ip6 icmpv6 type nd-neighbor-advert icmpv6 taddr != 2001:db8::1 drop\n" +
|
|
"delete table bridge " + name + "\n"
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
_, err := (execRunner{}).Run(ctx, path, []string{"--check", "-f", "-"}, []byte(script))
|
|
if err != nil && os.Getenv("VIRT_PUBLIC_GUARD_NFT_CHECK_REQUIRED") == "" {
|
|
t.Skipf("real nft --check requires host bridge-netfilter privileges: %v", err)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("real nft rejected atomic owned-table replacement: %v", err)
|
|
}
|
|
}
|