internal/wafprotocol writes and reads the question, the answer and the report, and declares once each header, path and limit both daemons use. rproxy no longer imports internal/waf. Nothing on the wire changes. Model: opus-5-5
205 lines
5.2 KiB
Go
205 lines
5.2 KiB
Go
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)
|
|
}
|
|
}
|