package wafprotocol_test import ( "io" "net/http" "net/http/httptest" "net/netip" "net/url" "strings" "testing" "sneak.berlin/go/smallwebwaf/internal/wafprotocol" ) // requestID is the id the tests' questions and reports give. const requestID = "an-id" // questionRead is what the server startQuestionReader starts read of a // question: the question, and the body it carries. type questionRead struct { question wafprotocol.Question body string } // startQuestionReader starts a server that reads each question it gets with // ReadQuestion. It returns the server's URL and the channel what it reads goes // to. func startQuestionReader(t *testing.T) (*url.URL, <-chan questionRead) { t.Helper() read := make(chan questionRead, 1) server := httptest.NewServer(http.HandlerFunc( func(w http.ResponseWriter, r *http.Request) { question, err := wafprotocol.ReadQuestion(w, r) if err != nil { t.Errorf("read the question: %v", err) } var body []byte if question.Visitor != nil { body, _ = io.ReadAll(question.Visitor.Body) } read <- questionRead{question, string(body)} }, )) t.Cleanup(server.Close) serverURL, err := url.Parse(server.URL) if err != nil { t.Fatalf("parse the server's URL: %v", err) } return serverURL, read } // TestQuestionReadsAsWritten sends a question NewQuestion writes over HTTP, // and checks that ReadQuestion gives back the visitor's request and what // rproxy added. func TestQuestionReadsAsWritten(t *testing.T) { t.Parallel() const ( target = "/a%2Fb?q=1" body = "name=value" held = "name" ) client := netip.MustParseAddr("2001:db8::1") peer := netip.MustParseAddr("192.0.2.1") backend, read := startQuestionReader(t) visitor := httptest.NewRequestWithContext( t.Context(), http.MethodPost, "http://site.example.com"+target, strings.NewReader(body), ) visitor.Header.Set("Content-Length", "10") visitor.Header.Set("User-Agent", "a visitor") visitor.Header.Set(wafprotocol.PeerHeader, "the visitor's own") question, err := wafprotocol.NewQuestion( t.Context(), wafprotocol.QuestionParams{ Visitor: visitor, PathAsSent: "/a%2Fb", Body: []byte(held), WAFBackend: backend, Client: client, Peer: peer, RequestID: requestID, Scheme: "https", }, ) if err != nil { t.Fatalf("write the question: %v", err) } res, err := http.DefaultTransport.RoundTrip(question) if err != nil { t.Fatalf("send the question: %v", err) } _ = res.Body.Close() got := <-read if got.question.Visitor == nil { t.FailNow() } if got.question.Client != client || got.question.Peer != peer || got.question.RequestID != requestID { t.Errorf("read %+v", got.question) } sent := got.question.Visitor if sent.Host != "site.example.com" || sent.RequestURI != target || sent.ContentLength != int64(len(body)) || got.body != held { t.Errorf( "read %s at %s, of length %d, carrying %q", sent.RequestURI, sent.Host, sent.ContentLength, got.body, ) } for name, want := range map[string]string{ "Content-Length": "10", "User-Agent": "a visitor", "X-Forwarded-Proto": "https", wafprotocol.RequestIDHeader: requestID, wafprotocol.ClientHeader: "", wafprotocol.PeerHeader: "", wafprotocol.ContentLengthHeader: "", } { if sent.Header.Get(name) != want { t.Errorf("%s is %q, want %q", name, sent.Header.Get(name), want) } } } // TestAnswerReadsAsWritten checks that ReadAnswer gives back what // SetAnswerHeaders sets, and that headers without a valid disposition give // nothing. func TestAnswerReadsAsWritten(t *testing.T) { t.Parallel() for _, want := range []wafprotocol.Answer{ {Disposition: wafprotocol.DispositionAllow, ASN: "64496", Country: "DE"}, {Disposition: wafprotocol.DispositionAllow, Country: "DE"}, {Disposition: wafprotocol.DispositionDeny}, {Disposition: wafprotocol.DispositionClose}, } { header := http.Header{} wafprotocol.SetAnswerHeaders(header, want) got, valid := wafprotocol.ReadAnswer(header) if !valid || got != want { t.Errorf("read %+v (valid: %t), want %+v", got, valid, want) } } header := http.Header{} header.Set(wafprotocol.DispositionHeader, "maybe") header.Set(wafprotocol.ASNHeader, "64496") got, valid := wafprotocol.ReadAnswer(header) if valid || got != (wafprotocol.Answer{}) { t.Errorf("read %+v (valid: %t), want nothing", got, valid) } } // TestReportReadsAsWritten checks that ReadReport gives back the report // NewReportRequest posts. func TestReportReadsAsWritten(t *testing.T) { t.Parallel() want := wafprotocol.Report{ RequestID: requestID, Status: http.StatusOK, RequestBytes: 10, ResponseBytes: 20, DurationTotalMS: 1.5, DurationUpstreamTotalMS: 0.5, } req, err := wafprotocol.NewReportRequest( t.Context(), "http://waf.example.com"+wafprotocol.ReportPath, &want, ) if err != nil { t.Fatalf("write the report: %v", err) } if req.Method != http.MethodPost || req.URL.Path != wafprotocol.ReportPath { t.Errorf("the report is %s %s", req.Method, req.URL.Path) } got, err := wafprotocol.ReadReport(httptest.NewRecorder(), req) if err != nil || got != want { t.Errorf("read %+v (%v), want %+v", got, err, want) } }