515 lines
16 KiB
Go
515 lines
16 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func testStore(t *testing.T) *sql.DB {
|
|
t.Helper()
|
|
t.Setenv("ZAPRET_AUTOTUNE_DB", filepath.Join(t.TempDir(), "data", "autotune.db"))
|
|
db, err := openStore(databasePath())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { db.Close() })
|
|
return db
|
|
}
|
|
|
|
func saveProposal(t *testing.T, db *sql.DB, args string) string {
|
|
t.Helper()
|
|
report := combinedReportFixture(args)
|
|
output, err := combinedBlockcheckOutput(strings.NewReader(report), args)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := saveRun(db, time.Now(), args, output, []byte(report), nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return output
|
|
}
|
|
|
|
func assertRowCounts(t *testing.T, db *sql.DB, runs, results int) {
|
|
t.Helper()
|
|
for table, want := range map[string]int{"tune_runs": runs, "protocol_results": results} {
|
|
var got int
|
|
if err := db.QueryRow("SELECT count(*) FROM " + table).Scan(&got); err != nil || got != want {
|
|
t.Fatalf("%s: count=%d want=%d err=%v", table, got, want, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func assertProposedRun(t *testing.T, args, output string) {
|
|
t.Helper()
|
|
db, err := openStore(databasePath())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer db.Close()
|
|
r, err := latestRun(db)
|
|
if err != nil || r.State != "PROPOSED" || r.Args.String != args || r.Output.String != output || r.Error.Valid {
|
|
t.Fatalf("latest=%+v err=%v", r, err)
|
|
}
|
|
assertRowCounts(t, db, 1, 2)
|
|
assertSavedCandidate(t, db, r.ID, args)
|
|
for _, protocol := range []string{"tls12", "tls13"} {
|
|
var ok, total int
|
|
if err := db.QueryRow("SELECT passes_ok, passes_total FROM protocol_results WHERE run_id = ? AND protocol = ?", r.ID, protocol).Scan(&ok, &total); err != nil || ok != 3 || total != 3 {
|
|
t.Fatalf("%s: %d/%d err=%v", protocol, ok, total, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStoreFilePermissions(t *testing.T) {
|
|
for _, name := range []string{"new", "existing"} {
|
|
t.Run(name, func(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), "data", "autotune.db")
|
|
wantRuns := 0
|
|
if name == "existing" {
|
|
db, err := openStore(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := saveRun(db, time.Now(), "", "", nil, errors.New("scan failed")); err != nil {
|
|
db.Close()
|
|
t.Fatal(err)
|
|
}
|
|
if err := db.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Chmod(path, 0666); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wantRuns = 1
|
|
}
|
|
db, err := openStore(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer db.Close()
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := info.Mode().Perm(); got != 0600 {
|
|
t.Fatalf("database mode = %04o, want 0600", got)
|
|
}
|
|
assertRowCounts(t, db, wantRuns, 0)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDatabasePathEnvironment(t *testing.T) {
|
|
t.Setenv("ZAPRET_AUTOTUNE_DB", "")
|
|
if got := databasePath(); got != "/var/lib/zapret-autotune/autotune.db" {
|
|
t.Fatalf("default database path = %q", got)
|
|
}
|
|
t.Setenv("ZAPRET_AUTOTUNE_DB", "data/custom?.db")
|
|
if got := databasePath(); got != "data/custom?.db" {
|
|
t.Fatalf("configured database path = %q", got)
|
|
}
|
|
}
|
|
|
|
func TestStoreRejectsDSNs(t *testing.T) {
|
|
for _, path := range []string{"", ":memory:", ":memory:?cache=shared", "file::memory:?cache=shared", "file:test.db?mode=memory", "file:///tmp/test.db", "FILE:test.db"} {
|
|
t.Run(path, func(t *testing.T) {
|
|
db, err := openStore(path)
|
|
if db != nil {
|
|
db.Close()
|
|
}
|
|
if err == nil {
|
|
t.Fatalf("accepted SQLite DSN %q", path)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestStoreFilesystemPaths(t *testing.T) {
|
|
for _, name := range []string{"plain.db", "question?.db", "options.db?mode=memory&cache=shared", "pragma.db?_pragma=query_only(1)", "hash#.db", "percent%3f.db", "space + ü.db"} {
|
|
t.Run(name, func(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), name)
|
|
cwd, err := os.Getwd()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
relative, err := filepath.Rel(cwd, path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Setenv("ZAPRET_AUTOTUNE_DB", relative)
|
|
db, err := openStore(databasePath())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer db.Close()
|
|
var sequence int
|
|
var schema, filename string
|
|
if err := db.QueryRow("PRAGMA database_list").Scan(&sequence, &schema, &filename); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if filename != path {
|
|
t.Fatalf("SQLite opened %q, want %q", filename, path)
|
|
}
|
|
if err := saveRun(db, time.Now(), "", "", nil, errors.New("persisted failure")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := db.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if info.Size() == 0 || info.Mode().Perm() != 0600 {
|
|
t.Fatalf("database size=%d mode=%04o", info.Size(), info.Mode().Perm())
|
|
}
|
|
entries, err := os.ReadDir(filepath.Dir(path))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(entries) != 1 || entries[0].Name() != name {
|
|
t.Fatalf("unexpected database files: %v", entries)
|
|
}
|
|
db, err = openStore(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer db.Close()
|
|
assertRowCounts(t, db, 1, 0)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestConcurrentFirstOpens(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), "autotune.db")
|
|
const callers = 8
|
|
start := make(chan struct{})
|
|
type openResult struct {
|
|
db *sql.DB
|
|
err error
|
|
}
|
|
results := make(chan openResult, callers)
|
|
var ready sync.WaitGroup
|
|
ready.Add(callers)
|
|
for i := 0; i < callers; i++ {
|
|
go func() {
|
|
ready.Done()
|
|
<-start
|
|
db, err := openStore(path)
|
|
results <- openResult{db, err}
|
|
}()
|
|
}
|
|
ready.Wait()
|
|
close(start)
|
|
// Collect every result before assertions so failures still close all stores.
|
|
stores := make([]*sql.DB, 0, callers)
|
|
for i := 0; i < callers; i++ {
|
|
result := <-results
|
|
if result.err != nil {
|
|
t.Errorf("concurrent open: %v", result.err)
|
|
continue
|
|
}
|
|
stores = append(stores, result.db)
|
|
defer result.db.Close()
|
|
}
|
|
for _, db := range stores {
|
|
var version, objects int
|
|
if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 7 {
|
|
t.Fatalf("version=%d err=%v", version, err)
|
|
}
|
|
if err := db.QueryRow(`SELECT count(*) FROM sqlite_master WHERE
|
|
(type = 'table' AND name IN ('tune_runs', 'protocol_results')) OR
|
|
(type = 'trigger' AND name = 'proposed_results_only')`).Scan(&objects); err != nil || objects != 3 {
|
|
t.Fatalf("schema objects=%d err=%v", objects, err)
|
|
}
|
|
assertRowCounts(t, db, 0, 0)
|
|
var integrity string
|
|
if err := db.QueryRow("PRAGMA integrity_check").Scan(&integrity); err != nil || integrity != "ok" {
|
|
t.Fatalf("integrity=%q err=%v", integrity, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMigrationAndLatest(t *testing.T) {
|
|
db := testStore(t)
|
|
if err := migrate(db); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := latestRun(db); !errors.Is(err, sql.ErrNoRows) {
|
|
t.Fatalf("empty latest: %v", err)
|
|
}
|
|
args := "--lua-desync=multisplit"
|
|
output := saveProposal(t, db, args)
|
|
if err := migrate(db); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assertProposedRun(t, args, output)
|
|
if err := saveRun(db, time.Now(), "", "", nil, errors.New("scan failed")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r, err := latestRun(db)
|
|
if err != nil || r.ID != 2 || r.State != "FAILED" || r.Error.String != "scan failed" || r.Args.Valid || r.Output.Valid {
|
|
t.Fatalf("latest=%+v err=%v", r, err)
|
|
}
|
|
assertRowCounts(t, db, 2, 2)
|
|
var stdout, stderr bytes.Buffer
|
|
if status(&stdout, &stderr) != 0 || !strings.Contains(stdout.String(), "FAILED") || strings.Contains(stdout.String(), output) {
|
|
t.Fatalf("failed status: %q %q", stdout.String(), stderr.String())
|
|
}
|
|
}
|
|
|
|
func TestStatusNoDataAndProposed(t *testing.T) {
|
|
db := testStore(t)
|
|
var stdout, stderr bytes.Buffer
|
|
if run([]string{"status"}, &stdout, &stderr) != 0 || !strings.Contains(stdout.String(), "no recorded tune run") || strings.Contains(stdout.String(), "NFQWS2_OPT") {
|
|
t.Fatalf("empty status: %q %q", stdout.String(), stderr.String())
|
|
}
|
|
output := saveProposal(t, db, "--lua-desync=multisplit")
|
|
stdout.Reset()
|
|
if run([]string{"status"}, &stdout, &stderr) != 0 {
|
|
t.Fatal(stderr.String())
|
|
}
|
|
for _, want := range []string{"PROPOSED, not active", "TLS1.2 3/3", "TLS1.3 3/3", output, "apply: BLOCKED", "NOT CHECKED"} {
|
|
if !strings.Contains(stdout.String(), want) {
|
|
t.Errorf("status %q missing %q", stdout.String(), want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPersistenceRollback(t *testing.T) {
|
|
db := testStore(t)
|
|
output := saveProposal(t, db, "--lua-desync=multisplit")
|
|
if _, err := db.Exec(`CREATE TRIGGER reject_tls13 BEFORE INSERT ON protocol_results WHEN NEW.protocol = 'tls13' BEGIN SELECT RAISE(ABORT, 'injected persistence failure'); END`); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
args := "--lua-desync=multisplit"
|
|
if err := saveRun(db, time.Now(), args, output, []byte(combinedReportFixture(args)), nil); err == nil {
|
|
t.Fatal("expected persistence failure")
|
|
}
|
|
assertRowCounts(t, db, 1, 2)
|
|
r, err := latestRun(db)
|
|
if err != nil || r.ID != 1 {
|
|
t.Fatalf("rollback changed latest: %+v %v", r, err)
|
|
}
|
|
}
|
|
|
|
func TestMigrationRollback(t *testing.T) {
|
|
db, err := sql.Open("sqlite", filepath.Join(t.TempDir(), "broken.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer db.Close()
|
|
db.SetMaxOpenConns(1)
|
|
if _, err := db.Exec("CREATE TABLE protocol_results (id INTEGER)"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := migrate(db); err == nil {
|
|
t.Fatal("expected conflicting schema failure")
|
|
}
|
|
var version, tables int
|
|
if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 0 {
|
|
t.Fatalf("version=%d err=%v", version, err)
|
|
}
|
|
if err := db.QueryRow("SELECT count(*) FROM sqlite_master WHERE name = 'tune_runs'").Scan(&tables); err != nil || tables != 0 {
|
|
t.Fatalf("partial schema count=%d err=%v", tables, err)
|
|
}
|
|
if _, err := db.Exec("DROP TABLE protocol_results"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := migrate(db); err != nil {
|
|
t.Fatalf("migration after rollback: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDatabaseFailureFailsClosed(t *testing.T) {
|
|
parent := filepath.Join(t.TempDir(), "not-a-directory")
|
|
if err := os.WriteFile(parent, []byte("x"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Setenv("ZAPRET_AUTOTUNE_DB", filepath.Join(parent, "autotune.db"))
|
|
var stdout, stderr bytes.Buffer
|
|
scan := func(context.Context, string, string, io.Writer, io.Writer) (string, error) {
|
|
t.Fatal("scan must not start with an unavailable database")
|
|
return "", nil
|
|
}
|
|
if tuneYoutube(&stdout, &stderr, scan) != 1 || stdout.Len() != 0 || !strings.Contains(stderr.String(), "database") {
|
|
t.Fatalf("tune: out=%q err=%q", stdout.String(), stderr.String())
|
|
}
|
|
stderr.Reset()
|
|
if run([]string{"status"}, &stdout, &stderr) != 1 || stdout.Len() != 0 || !strings.Contains(stderr.String(), "database") {
|
|
t.Fatalf("status: out=%q err=%q", stdout.String(), stderr.String())
|
|
}
|
|
}
|
|
|
|
func TestSchemaConstraintsAndIncompleteEvidence(t *testing.T) {
|
|
db := testStore(t)
|
|
saveProposal(t, db, "--lua-desync=multisplit")
|
|
for _, statement := range []string{
|
|
`INSERT INTO protocol_results VALUES (999, 'tls12', 3, 3)`,
|
|
`UPDATE protocol_results SET protocol = 'quic' WHERE protocol = 'tls12'`,
|
|
`UPDATE protocol_results SET passes_ok = 2 WHERE protocol = 'tls12'`,
|
|
`UPDATE protocol_results SET passes_total = 4 WHERE protocol = 'tls12'`,
|
|
`UPDATE tune_runs SET state = 'ACTIVE'`,
|
|
`UPDATE tune_runs SET args = NULL`,
|
|
} {
|
|
if _, err := db.Exec(statement); err == nil {
|
|
t.Fatalf("constraint accepted %s", statement)
|
|
}
|
|
}
|
|
if _, err := db.Exec(`DELETE FROM protocol_results WHERE protocol = 'tls13'`); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var stdout, stderr bytes.Buffer
|
|
if status(&stdout, &stderr) != 1 || stdout.Len() != 0 || !strings.Contains(stderr.String(), "incomplete protocol evidence") {
|
|
t.Fatalf("incomplete status: %q %q", stdout.String(), stderr.String())
|
|
}
|
|
}
|
|
|
|
func TestUnsupportedSchemaVersion(t *testing.T) {
|
|
db := testStore(t)
|
|
if _, err := db.Exec("PRAGMA user_version = 8"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := migrate(db); err == nil || !strings.Contains(err.Error(), "unsupported") {
|
|
t.Fatalf("future schema accepted: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestFingerprintSchemaConstraints(t *testing.T) {
|
|
for _, source := range []string{"v0", "v1"} {
|
|
t.Run(source, func(t *testing.T) {
|
|
var db *sql.DB
|
|
if source == "v1" {
|
|
db = populatedV1Store(t, "--lua-desync=fake")
|
|
if err := migrate(db); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
} else {
|
|
db = testStore(t)
|
|
}
|
|
valid := strings.Repeat("a", 64)
|
|
for _, state := range []string{"PROPOSED", "FAILED"} {
|
|
var args, output, failure interface{}
|
|
if state == "PROPOSED" {
|
|
args, output = "--lua-desync=fake", "output"
|
|
} else {
|
|
failure = "failure"
|
|
}
|
|
var initial interface{}
|
|
if state == "PROPOSED" {
|
|
initial = valid
|
|
}
|
|
result, err := db.Exec(`INSERT INTO tune_runs (started_at, finished_at, target, state, args, output, error, fingerprint) VALUES ('start', 'finish', 'youtube.com', ?, ?, ?, ?, ?)`, state, args, output, failure, initial)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
id, err := result.LastInsertId()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
invalid := []interface{}{"", strings.Repeat("a", 63), strings.Repeat("a", 65), strings.Repeat("A", 64), strings.Repeat("g", 64), valid + "\x00x"}
|
|
if state == "PROPOSED" {
|
|
invalid = append(invalid, nil)
|
|
} else {
|
|
invalid = append(invalid, valid)
|
|
}
|
|
for _, fingerprint := range invalid {
|
|
if _, err := db.Exec(`INSERT INTO tune_runs (started_at, finished_at, target, state, args, output, error, fingerprint) VALUES ('start', 'finish', 'youtube.com', ?, ?, ?, ?, ?)`, state, args, output, failure, fingerprint); err == nil {
|
|
t.Fatalf("INSERT accepted %s fingerprint %q", state, fingerprint)
|
|
}
|
|
if _, err := db.Exec("UPDATE tune_runs SET fingerprint = ? WHERE id = ?", fingerprint, id); err == nil {
|
|
t.Fatalf("UPDATE accepted %s fingerprint %q", state, fingerprint)
|
|
}
|
|
}
|
|
// Change all other state-dependent fields too: only the hash is wrong.
|
|
statement := "UPDATE tune_runs SET state = 'FAILED', args = NULL, output = NULL, error = 'failure' WHERE id = ?"
|
|
if state == "FAILED" {
|
|
statement = "UPDATE tune_runs SET state = 'PROPOSED', args = '--lua-desync=fake', output = 'output', error = NULL WHERE id = ?"
|
|
}
|
|
if _, err := db.Exec(statement, id); err == nil {
|
|
t.Fatalf("accepted state change from %s with mismatched fingerprint", state)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMalformedV1SchemaRollback(t *testing.T) {
|
|
for name, damage := range map[string]string{
|
|
"missing protocol table": "DROP TABLE protocol_results",
|
|
"altered protocol column": "ALTER TABLE protocol_results RENAME COLUMN passes_total TO unexpected",
|
|
"altered run column": "ALTER TABLE tune_runs RENAME COLUMN error TO unexpected",
|
|
"altered protocol type": `ALTER TABLE protocol_results RENAME TO old_results;
|
|
CREATE TABLE protocol_results (run_id INTEGER, protocol TEXT, passes_ok TEXT, passes_total INTEGER);
|
|
INSERT INTO protocol_results SELECT * FROM old_results; DROP TABLE old_results;`,
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
db := populatedV1Store(t, "--lua-desync=fake")
|
|
if _, err := db.Exec(damage); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
snapshot := func() (string, string) {
|
|
t.Helper()
|
|
var schema, history string
|
|
if err := db.QueryRow(`SELECT group_concat(sql, ';') FROM (SELECT sql FROM sqlite_master ORDER BY name)`).Scan(&schema); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, table := range []string{"tune_runs", "protocol_results"} {
|
|
if table == "protocol_results" && name == "missing protocol table" {
|
|
continue
|
|
}
|
|
rows, err := db.Query("SELECT * FROM " + table + " ORDER BY 1, 2")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
columns, err := rows.Columns()
|
|
if err != nil {
|
|
rows.Close()
|
|
t.Fatal(err)
|
|
}
|
|
values := make([]interface{}, len(columns))
|
|
pointers := make([]interface{}, len(columns))
|
|
for i := range values {
|
|
pointers[i] = &values[i]
|
|
}
|
|
for rows.Next() {
|
|
if err := rows.Scan(pointers...); err != nil {
|
|
rows.Close()
|
|
t.Fatal(err)
|
|
}
|
|
history += fmt.Sprintf("%s:%#v;", table, values)
|
|
}
|
|
err = rows.Err()
|
|
rows.Close()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
return schema, history
|
|
}
|
|
beforeSchema, beforeHistory := snapshot()
|
|
if err := migrate(db); err == nil || !strings.Contains(err.Error(), "invalid v1 schema") {
|
|
t.Fatalf("malformed schema accepted: %v", err)
|
|
}
|
|
var version int
|
|
if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 1 {
|
|
t.Fatalf("version=%d err=%v", version, err)
|
|
}
|
|
afterSchema, afterHistory := snapshot()
|
|
if afterSchema != beforeSchema || afterHistory != beforeHistory {
|
|
t.Fatal("failed migration changed schema or history")
|
|
}
|
|
})
|
|
}
|
|
}
|