Public Access
feat: http parse optimisation (#188)
SonarQube Scan / SonarQube Trigger (push) Successful in 5m4s
Docker Build and Push / Build linux/amd64 image (push) Canceled after 0s
Docker Build and Push / Build linux/arm64 image (push) Canceled after 0s
Docker Build and Push / Create multi-architecture image (push) Canceled after 0s
Docker Build and Push / Run Tests (push) Canceled after 6m37s
SonarQube Scan / SonarQube Trigger (push) Successful in 5m4s
Docker Build and Push / Build linux/amd64 image (push) Canceled after 0s
Docker Build and Push / Build linux/arm64 image (push) Canceled after 0s
Docker Build and Push / Create multi-architecture image (push) Canceled after 0s
Docker Build and Push / Run Tests (push) Canceled after 6m37s
Reviewed-on: #188
This commit was merged in pull request #188.
This commit is contained in:
@@ -38,7 +38,7 @@ jobs:
|
||||
run: go vet ./...
|
||||
|
||||
- name: Run tests
|
||||
run: go test -v -p 4 ./...
|
||||
run: go test -v -p 4 -race ./...
|
||||
|
||||
- name: Set up QEMU
|
||||
uses: docker/setup-qemu-action@v3
|
||||
|
||||
@@ -30,7 +30,7 @@ jobs:
|
||||
|
||||
- name: Run tests with coverage
|
||||
run: |
|
||||
go test ./... -v -p 4 -coverprofile=coverage
|
||||
go test ./... -v -p 4 -race -coverprofile=coverage
|
||||
|
||||
- name: Run GolangCI-Lint Analysis
|
||||
uses: golangci/golangci-lint-action@v9
|
||||
|
||||
@@ -33,4 +33,4 @@ jobs:
|
||||
run: go vet ./...
|
||||
|
||||
- name: Run tests
|
||||
run: go test -v -p 4 ./...
|
||||
run: go test -v -p 4 -race ./...
|
||||
@@ -135,7 +135,9 @@ func parseMode() (types.ServerMode, error) {
|
||||
|
||||
func parseAllowedPorts() (uint16, uint16, error) {
|
||||
raw := getenv("ALLOWED_PORTS", "")
|
||||
if raw == "" {
|
||||
// "none" is what the docs and the standard compose file say; treat it
|
||||
// (and no value) as TCP tunneling disabled instead of a startup error.
|
||||
if raw == "" || raw == "none" {
|
||||
return 0, 0, nil
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
package header
|
||||
|
||||
import "testing"
|
||||
|
||||
// Realistic request: six fields, the shape a browser or curl sends.
|
||||
func benchHeader() []byte {
|
||||
return []byte("GET /path HTTP/1.1\r\n" +
|
||||
"Host: test.example.com\r\n" +
|
||||
"User-Agent: bench/1.0\r\n" +
|
||||
"Accept: */*\r\n" +
|
||||
"Accept-Encoding: gzip, deflate\r\n" +
|
||||
"X-Forwarded-For: 1.2.3.4\r\n" +
|
||||
"Connection: keep-alive\r\n" +
|
||||
"\r\n")
|
||||
}
|
||||
|
||||
func BenchmarkNewRequest(b *testing.B) {
|
||||
in := benchHeader()
|
||||
b.ReportAllocs()
|
||||
b.SetBytes(int64(len(in)))
|
||||
b.ResetTimer()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
if _, err := NewRequest(in); err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkFinalize(b *testing.B) {
|
||||
h, err := NewRequest(benchHeader())
|
||||
if err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
|
||||
b.ReportAllocs()
|
||||
b.ResetTimer()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = h.Finalize()
|
||||
}
|
||||
}
|
||||
@@ -7,12 +7,8 @@ type ResponseHeader interface {
|
||||
Finalize() []byte
|
||||
}
|
||||
|
||||
type responseHeader struct {
|
||||
startLine []byte
|
||||
headers map[string]string
|
||||
}
|
||||
|
||||
type RequestHeader interface {
|
||||
Count(key string) int
|
||||
Value(key string) string
|
||||
Set(key string, value string)
|
||||
Remove(key string)
|
||||
@@ -21,10 +17,3 @@ type RequestHeader interface {
|
||||
Path() string
|
||||
Version() string
|
||||
}
|
||||
type requestHeader struct {
|
||||
method string
|
||||
path string
|
||||
version string
|
||||
startLine []byte
|
||||
headers map[string]string
|
||||
}
|
||||
|
||||
@@ -2,6 +2,7 @@ package header
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
@@ -155,6 +156,29 @@ func TestNewResponse(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// 70 fields in both directions. A fixed 64-field cap used to refuse these
|
||||
// before any of the real rules were applied.
|
||||
func TestManyFieldsRoundTrip(t *testing.T) {
|
||||
req, err := NewRequest(append([]byte("GET / HTTP/1.1\r\n"), manyHeaders(70)...))
|
||||
if !assert.NoError(t, err) {
|
||||
return
|
||||
}
|
||||
reqOut := string(req.Finalize())
|
||||
for i := 0; i < 70; i++ {
|
||||
assert.Equal(t, "v", req.Value(fmt.Sprintf("X-%02d", i)))
|
||||
assert.Contains(t, reqOut, fmt.Sprintf("X-%02d: v\r\n", i))
|
||||
}
|
||||
|
||||
resp, err := NewResponse(append([]byte("HTTP/1.1 200 OK\r\n"), manyHeaders(70)...))
|
||||
if !assert.NoError(t, err) {
|
||||
return
|
||||
}
|
||||
respOut := string(resp.Finalize())
|
||||
for i := 0; i < 70; i++ {
|
||||
assert.Contains(t, respOut, fmt.Sprintf("X-%02d: v\r\n", i))
|
||||
}
|
||||
}
|
||||
|
||||
func TestResponseHeaderMethods(t *testing.T) {
|
||||
data := []byte("HTTP/1.1 200 OK\r\nServer: old\r\n\r\n")
|
||||
resp, _ := NewResponse(data)
|
||||
@@ -175,53 +199,132 @@ func TestResponseHeaderMethods(t *testing.T) {
|
||||
|
||||
func TestSetRemainingHeaders(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
data []byte
|
||||
initialHeaders map[string]string
|
||||
expectHeaders map[string]string
|
||||
name string
|
||||
data []byte
|
||||
wantErr bool
|
||||
expectKept []field
|
||||
}{
|
||||
{
|
||||
name: "various header formats",
|
||||
data: []byte("K1: V1\r\nK2:V2\r\n K3 : V3 \r\nNoColon\r\n\r\n"),
|
||||
expectHeaders: map[string]string{
|
||||
"K1": "V1",
|
||||
"K2": "V2",
|
||||
"K3": "V3",
|
||||
data: []byte("K1: V1\r\nK2:V2\r\nK3 : V3 \r\n\r\n"),
|
||||
// "Name space: value" is refused thanks to K3, RFC 7230 3.2.4.
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
name: "OWS around value trimmed",
|
||||
data: []byte("K1: V1 \t\r\n\r\n"),
|
||||
expectKept: []field{
|
||||
{"K1", "V1"},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "no colon line refused",
|
||||
data: []byte("NoColon\r\n\r\n"),
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
name: "no trailing CRLF",
|
||||
data: []byte("K1: V1"),
|
||||
expectHeaders: map[string]string{
|
||||
"K1": "V1",
|
||||
expectKept: []field{
|
||||
{"K1", "V1"},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "empty lines",
|
||||
data: []byte("\r\nK1: V1"),
|
||||
expectHeaders: map[string]string{},
|
||||
name: "empty lines",
|
||||
data: []byte("\r\nK1: V1"),
|
||||
expectKept: nil,
|
||||
},
|
||||
{
|
||||
name: "headers with only colon",
|
||||
data: []byte(": value\r\nkey:\r\n"),
|
||||
expectHeaders: map[string]string{
|
||||
"": "value",
|
||||
"key": "",
|
||||
name: "empty name refused",
|
||||
data: []byte(": value\r\n\r\n"),
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
name: "empty value allowed",
|
||||
data: []byte("key:\r\n\r\n"),
|
||||
expectKept: []field{
|
||||
{"key", ""},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "space before colon refused",
|
||||
data: []byte("Host : a\r\n\r\n"),
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
name: "tab before colon refused",
|
||||
data: []byte("Host\t: a\r\n\r\n"),
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
name: "obs-fold refused",
|
||||
data: []byte("A: one\r\n two\r\n\r\n"),
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
name: "bare CR in value refused",
|
||||
data: []byte("A: v\rl\r\n\r\n"),
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
name: "bare LF in value refused",
|
||||
data: []byte("A: v\nl\r\n\r\n"),
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
name: "NUL in value refused",
|
||||
data: []byte("A: v\x00l\r\n\r\n"),
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
name: "non-token name refused",
|
||||
data: []byte("A@B: v\r\n\r\n"),
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
// No fixed field limit: 70 Set-Cookie lines are a real response,
|
||||
// not an attack. The byte limit is the bound.
|
||||
name: "many fields kept",
|
||||
data: manyHeaders(70),
|
||||
expectKept: fieldsFromHeaders(70),
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
req := &requestHeader{headers: make(map[string]string)}
|
||||
if tt.initialHeaders != nil {
|
||||
req.headers = tt.initialHeaders
|
||||
list, err := parseLines(nil, tt.data)
|
||||
if tt.wantErr {
|
||||
assert.ErrorIs(t, err, ErrMalformedField)
|
||||
return
|
||||
}
|
||||
setRemainingHeaders(tt.data, req)
|
||||
assert.Equal(t, len(tt.expectHeaders), len(req.headers))
|
||||
for k, v := range tt.expectHeaders {
|
||||
assert.Equal(t, v, req.headers[k])
|
||||
|
||||
assert.NoError(t, err)
|
||||
|
||||
if tt.expectKept != nil {
|
||||
assert.Equal(t, tt.expectKept, list)
|
||||
return
|
||||
}
|
||||
|
||||
assert.Nil(t, list)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// manyHeaders builds n "X-NN: v" lines then the blank line, with text/template
|
||||
// out of the loop: a plain fmt format keeps the generator obvious.
|
||||
func manyHeaders(n int) []byte {
|
||||
var b bytes.Buffer
|
||||
for i := 0; i < n; i++ {
|
||||
fmt.Fprintf(&b, "X-%02d: v\r\n", i)
|
||||
}
|
||||
b.WriteString("\r\n")
|
||||
return b.Bytes()
|
||||
}
|
||||
|
||||
func fieldsFromHeaders(n int) []field {
|
||||
list := make([]field, 0, n)
|
||||
for i := 0; i < n; i++ {
|
||||
list = append(list, field{name: fmt.Sprintf("X-%02d", i), value: "v"})
|
||||
}
|
||||
return list
|
||||
}
|
||||
|
||||
+186
-48
@@ -3,11 +3,163 @@ package header
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"sync"
|
||||
)
|
||||
|
||||
func setRemainingHeaders(remaining []byte, header interface {
|
||||
Set(key string, value string)
|
||||
}) {
|
||||
var ErrMalformedField = fmt.Errorf("malformed header field")
|
||||
|
||||
type field struct {
|
||||
name string
|
||||
value string
|
||||
}
|
||||
|
||||
// fields keeps header lines in wire order. A map would drop repeated
|
||||
// Set-Cookie/Cookie lines and reorder the rest, which changes what the
|
||||
// backend sees (RFC 7230 3.2.2).
|
||||
type fields struct {
|
||||
mu sync.RWMutex
|
||||
list []field
|
||||
start []byte
|
||||
}
|
||||
|
||||
func (f *fields) Set(key, value string) {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
|
||||
for i := range f.list {
|
||||
if equalFold(f.list[i].name, key) {
|
||||
f.list[i].name = key
|
||||
f.list[i].value = value
|
||||
return
|
||||
}
|
||||
}
|
||||
f.list = append(f.list, field{name: key, value: value})
|
||||
}
|
||||
|
||||
func (f *fields) Value(key string) string {
|
||||
f.mu.RLock()
|
||||
defer f.mu.RUnlock()
|
||||
|
||||
for _, h := range f.list {
|
||||
if equalFold(h.name, key) {
|
||||
return h.value
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// Count returns how many lines carry this field name, any case.
|
||||
func (f *fields) Count(key string) int {
|
||||
f.mu.RLock()
|
||||
defer f.mu.RUnlock()
|
||||
|
||||
n := 0
|
||||
for _, h := range f.list {
|
||||
if equalFold(h.name, key) {
|
||||
n++
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func (f *fields) Remove(key string) {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
|
||||
kept := f.list[:0]
|
||||
for _, h := range f.list {
|
||||
if !equalFold(h.name, key) {
|
||||
kept = append(kept, h)
|
||||
}
|
||||
}
|
||||
f.list = kept
|
||||
}
|
||||
|
||||
func (f *fields) Finalize() []byte {
|
||||
f.mu.RLock()
|
||||
defer f.mu.RUnlock()
|
||||
|
||||
size := len(f.start) + 4
|
||||
for _, h := range f.list {
|
||||
size += len(h.name) + len(h.value) + 4
|
||||
}
|
||||
|
||||
buf := make([]byte, 0, size)
|
||||
buf = append(buf, f.start...)
|
||||
buf = append(buf, '\r', '\n')
|
||||
for _, h := range f.list {
|
||||
buf = append(buf, h.name...)
|
||||
buf = append(buf, ':', ' ')
|
||||
buf = append(buf, h.value...)
|
||||
buf = append(buf, '\r', '\n')
|
||||
}
|
||||
return append(buf, '\r', '\n')
|
||||
}
|
||||
|
||||
func equalFold(a, b string) bool {
|
||||
if len(a) != len(b) {
|
||||
return false
|
||||
}
|
||||
for i := 0; i < len(a); i++ {
|
||||
ca, cb := a[i], b[i]
|
||||
if 'A' <= ca && ca <= 'Z' {
|
||||
ca += 'a' - 'A'
|
||||
}
|
||||
if 'A' <= cb && cb <= 'Z' {
|
||||
cb += 'a' - 'A'
|
||||
}
|
||||
if ca != cb {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// isToken reports whether name is an RFC 7230 token, i.e. a valid field-name.
|
||||
func isToken(name string) bool {
|
||||
if name == "" {
|
||||
return false
|
||||
}
|
||||
for i := 0; i < len(name); i++ {
|
||||
if !isTokenChar(name[i]) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func isTokenChar(c byte) bool {
|
||||
switch {
|
||||
case 'a' <= c && c <= 'z', 'A' <= c && c <= 'Z', '0' <= c && c <= '9':
|
||||
return true
|
||||
}
|
||||
switch c {
|
||||
case '!', '#', '$', '%', '&', '\'', '*', '+', '-', '.', '^', '_', '`', '|', '~':
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// isFieldValue reports whether value holds only field-vchar, SP and HTAB
|
||||
// (RFC 7230 3.2), so a CR, LF or NUL cannot be smuggled through it.
|
||||
func isFieldValue(value []byte) bool {
|
||||
for _, c := range value {
|
||||
switch {
|
||||
case c == '\t' || c == ' ':
|
||||
case 0x21 <= c && c <= 0x7e:
|
||||
case c >= 0x80: // obs-text
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// parseLines reads CRLF header lines into dst. It is the only place header
|
||||
// lines enter the package, so validation here covers every caller. The number
|
||||
// of fields is bounded by the caller's header-size limit: lines without a
|
||||
// colon are refused, so every accepted field costs at least two bytes.
|
||||
func parseLines(dst []field, remaining []byte) ([]field, error) {
|
||||
for len(remaining) > 0 {
|
||||
lineEnd := bytes.Index(remaining, []byte("\r\n"))
|
||||
if lineEnd == -1 {
|
||||
@@ -15,63 +167,49 @@ func setRemainingHeaders(remaining []byte, header interface {
|
||||
}
|
||||
|
||||
line := remaining[:lineEnd]
|
||||
|
||||
if len(line) == 0 {
|
||||
break
|
||||
return dst, nil
|
||||
}
|
||||
|
||||
colonIdx := bytes.IndexByte(line, ':')
|
||||
if colonIdx != -1 {
|
||||
key := bytes.TrimSpace(line[:colonIdx])
|
||||
value := bytes.TrimSpace(line[colonIdx+1:])
|
||||
header.Set(string(key), string(value))
|
||||
if colonIdx <= 0 {
|
||||
return nil, ErrMalformedField
|
||||
}
|
||||
if line[0] == ' ' || line[0] == '\t' || line[colonIdx-1] == ' ' {
|
||||
return nil, ErrMalformedField
|
||||
}
|
||||
|
||||
name := string(line[:colonIdx])
|
||||
if !isToken(name) {
|
||||
return nil, ErrMalformedField
|
||||
}
|
||||
|
||||
value := bytes.Trim(line[colonIdx+1:], " \t")
|
||||
if !isFieldValue(value) {
|
||||
return nil, ErrMalformedField
|
||||
}
|
||||
|
||||
dst = append(dst, field{name: name, value: string(value)})
|
||||
|
||||
if lineEnd == len(remaining) {
|
||||
break
|
||||
return dst, nil
|
||||
}
|
||||
|
||||
remaining = remaining[lineEnd+2:]
|
||||
}
|
||||
|
||||
return dst, nil
|
||||
}
|
||||
|
||||
func parseStartLine(startLine []byte) (method, path, version string, err error) {
|
||||
firstSpace := bytes.IndexByte(startLine, ' ')
|
||||
if firstSpace == -1 {
|
||||
return "", "", "", fmt.Errorf("invalid start line: missing method")
|
||||
}
|
||||
|
||||
secondSpace := bytes.IndexByte(startLine[firstSpace+1:], ' ')
|
||||
if secondSpace == -1 {
|
||||
return "", "", "", fmt.Errorf("invalid start line: missing version")
|
||||
}
|
||||
secondSpace += firstSpace + 1
|
||||
|
||||
method = string(startLine[:firstSpace])
|
||||
path = string(startLine[firstSpace+1 : secondSpace])
|
||||
version = string(startLine[secondSpace+1:])
|
||||
|
||||
return method, path, version, nil
|
||||
// requestHeader and responseHeader embed the shared field list, so Value/Set/
|
||||
// Remove/Finalize are the same code for both directions.
|
||||
type requestHeader struct {
|
||||
method string
|
||||
path string
|
||||
version string
|
||||
startLine []byte
|
||||
fields
|
||||
}
|
||||
|
||||
func finalize(startLine []byte, headers map[string]string) []byte {
|
||||
size := len(startLine) + 2
|
||||
for key, val := range headers {
|
||||
size += len(key) + 2 + len(val) + 2
|
||||
}
|
||||
size += 2
|
||||
|
||||
buf := make([]byte, 0, size)
|
||||
buf = append(buf, startLine...)
|
||||
buf = append(buf, '\r', '\n')
|
||||
|
||||
for key, val := range headers {
|
||||
buf = append(buf, key...)
|
||||
buf = append(buf, ':', ' ')
|
||||
buf = append(buf, val...)
|
||||
buf = append(buf, '\r', '\n')
|
||||
}
|
||||
|
||||
buf = append(buf, '\r', '\n')
|
||||
return buf
|
||||
type responseHeader struct {
|
||||
fields
|
||||
}
|
||||
|
||||
@@ -6,58 +6,35 @@ import (
|
||||
)
|
||||
|
||||
func NewRequest(headerData []byte) (RequestHeader, error) {
|
||||
header := &requestHeader{
|
||||
headers: make(map[string]string, 16),
|
||||
}
|
||||
|
||||
lineEnd := bytes.Index(headerData, []byte("\r\n"))
|
||||
if lineEnd == -1 {
|
||||
return nil, fmt.Errorf("invalid request: no CRLF found in start line")
|
||||
}
|
||||
|
||||
startLine := headerData[:lineEnd]
|
||||
header.startLine = startLine
|
||||
var err error
|
||||
header.method, header.path, header.version, err = parseStartLine(startLine)
|
||||
method, path, version, err := parseStartLine(startLine)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
remaining := headerData[lineEnd+2:]
|
||||
|
||||
setRemainingHeaders(remaining, header)
|
||||
|
||||
return header, nil
|
||||
}
|
||||
|
||||
func (req *requestHeader) Value(key string) string {
|
||||
val, ok := req.headers[key]
|
||||
if !ok {
|
||||
return ""
|
||||
list, err := parseLines(nil, headerData[lineEnd+2:])
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return val
|
||||
|
||||
return &requestHeader{
|
||||
method: method,
|
||||
path: path,
|
||||
version: version,
|
||||
startLine: startLine,
|
||||
fields: fields{list: list, start: startLine},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (req *requestHeader) Set(key string, value string) {
|
||||
req.headers[key] = value
|
||||
}
|
||||
|
||||
func (req *requestHeader) Remove(key string) {
|
||||
delete(req.headers, key)
|
||||
}
|
||||
|
||||
func (req *requestHeader) Method() string {
|
||||
return req.method
|
||||
}
|
||||
|
||||
func (req *requestHeader) Path() string {
|
||||
return req.path
|
||||
}
|
||||
|
||||
func (req *requestHeader) Version() string {
|
||||
return req.version
|
||||
}
|
||||
func (req *requestHeader) Method() string { return req.method }
|
||||
func (req *requestHeader) Path() string { return req.path }
|
||||
func (req *requestHeader) Version() string { return req.version }
|
||||
|
||||
func (req *requestHeader) Finalize() []byte {
|
||||
return finalize(req.startLine, req.headers)
|
||||
return req.fields.Finalize()
|
||||
}
|
||||
|
||||
@@ -6,35 +6,16 @@ import (
|
||||
)
|
||||
|
||||
func NewResponse(headerData []byte) (ResponseHeader, error) {
|
||||
header := &responseHeader{
|
||||
startLine: nil,
|
||||
headers: make(map[string]string, 16),
|
||||
}
|
||||
|
||||
lineEnd := bytes.Index(headerData, []byte("\r\n"))
|
||||
if lineEnd == -1 {
|
||||
return nil, fmt.Errorf("invalid response: no CRLF found in start line")
|
||||
}
|
||||
|
||||
header.startLine = headerData[:lineEnd]
|
||||
remaining := headerData[lineEnd+2:]
|
||||
setRemainingHeaders(remaining, header)
|
||||
startLine := headerData[:lineEnd]
|
||||
list, err := parseLines(nil, headerData[lineEnd+2:])
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return header, nil
|
||||
}
|
||||
|
||||
func (resp *responseHeader) Value(key string) string {
|
||||
return resp.headers[key]
|
||||
}
|
||||
|
||||
func (resp *responseHeader) Set(key string, value string) {
|
||||
resp.headers[key] = value
|
||||
}
|
||||
|
||||
func (resp *responseHeader) Remove(key string) {
|
||||
delete(resp.headers, key)
|
||||
}
|
||||
|
||||
func (resp *responseHeader) Finalize() []byte {
|
||||
return finalize(resp.startLine, resp.headers)
|
||||
return &responseHeader{fields: fields{list: list, start: startLine}}, nil
|
||||
}
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
package header
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
func parseStartLine(startLine []byte) (method, path, version string, err error) {
|
||||
firstSpace := bytes.IndexByte(startLine, ' ')
|
||||
if firstSpace == -1 {
|
||||
return "", "", "", fmt.Errorf("invalid start line: missing method")
|
||||
}
|
||||
|
||||
secondSpace := bytes.IndexByte(startLine[firstSpace+1:], ' ')
|
||||
if secondSpace == -1 {
|
||||
return "", "", "", fmt.Errorf("invalid start line: missing version")
|
||||
}
|
||||
secondSpace += firstSpace + 1
|
||||
|
||||
method = string(startLine[:firstSpace])
|
||||
path = string(startLine[firstSpace+1 : secondSpace])
|
||||
version = string(startLine[secondSpace+1:])
|
||||
|
||||
return method, path, version, nil
|
||||
}
|
||||
@@ -8,6 +8,9 @@ func splitHeaderAndBody(data []byte, delimiterIdx int) ([]byte, []byte) {
|
||||
return headerByte, body
|
||||
}
|
||||
|
||||
// isHTTPHeader reports whether buf is shaped like an HTTP header block: a
|
||||
// request or status line, then fields that the header parser would also
|
||||
// accept. It is a shape test, not the parser.
|
||||
func isHTTPHeader(buf []byte) bool {
|
||||
lines := bytes.Split(buf, []byte("\r\n"))
|
||||
|
||||
@@ -24,6 +27,14 @@ func isHTTPHeader(buf []byte) bool {
|
||||
if colonIdx <= 0 {
|
||||
return false
|
||||
}
|
||||
// The same rules header.parseLines enforces: no whitespace before the
|
||||
// colon and no bare CR/LF inside a value.
|
||||
if line[0] == ' ' || line[0] == '\t' || line[colonIdx-1] == ' ' {
|
||||
return false
|
||||
}
|
||||
if bytes.IndexAny(line[colonIdx+1:], "\r\n") != -1 {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
+177
-33
@@ -2,49 +2,193 @@ package stream
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"io"
|
||||
"slices"
|
||||
"strings"
|
||||
"tunnel_pls/internal/http/header"
|
||||
)
|
||||
|
||||
func (hs *http) Read(p []byte) (int, error) {
|
||||
tmp := make([]byte, len(p))
|
||||
read, err := hs.reader.Read(tmp)
|
||||
if read == 0 && err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
tmp = tmp[:read]
|
||||
|
||||
headerEndIdx := bytes.Index(tmp, DELIMITER)
|
||||
if headerEndIdx == -1 {
|
||||
return handleNoDelimiter(p, tmp, err)
|
||||
}
|
||||
|
||||
headerByte, bodyByte := splitHeaderAndBody(tmp, headerEndIdx)
|
||||
|
||||
if !isHTTPHeader(headerByte) {
|
||||
copy(p, tmp)
|
||||
return read, nil
|
||||
}
|
||||
|
||||
return hs.processHTTPRequest(p, headerByte, bodyByte)
|
||||
// reqState is what Read has taken from the source but not handed out yet.
|
||||
type reqState struct {
|
||||
// in holds bytes read from the source and not processed yet.
|
||||
in []byte
|
||||
// out holds bytes that did not fit the caller's buffer.
|
||||
out []byte
|
||||
// err is the source error, reported after in and out are drained.
|
||||
err error
|
||||
}
|
||||
|
||||
func (hs *http) processHTTPRequest(p, headerByte, bodyByte []byte) (int, error) {
|
||||
// Read adds request headers (X-Forwarded-For) to header blocks it can see whole.
|
||||
//
|
||||
// Read never returns more than len(p): io.Copy panics on that, and a full
|
||||
// caller buffer is exactly the case where the added header overflows it. What
|
||||
// does not fit waits in hs.req and goes out on the next call.
|
||||
func (hs *http) Read(p []byte) (int, error) {
|
||||
if len(p) == 0 {
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
for {
|
||||
if len(hs.req.out) > 0 {
|
||||
n := copy(p, hs.req.out)
|
||||
hs.req.out = hs.req.out[n:]
|
||||
return n, nil
|
||||
}
|
||||
|
||||
if len(hs.req.in) > 0 {
|
||||
n := hs.emit(p)
|
||||
if len(hs.req.out) == 0 && hs.req.err != nil {
|
||||
err := hs.req.err
|
||||
hs.req.err = nil
|
||||
return n, err
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
|
||||
if hs.req.err != nil {
|
||||
err := hs.req.err
|
||||
hs.req.err = nil
|
||||
return 0, err
|
||||
}
|
||||
|
||||
if err := hs.fill(p); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// fill reads once. If that leaves a request header still arriving, it keeps
|
||||
// reading until the blank line arrives, the header limit is reached, or the
|
||||
// bytes stop looking like a request. Bounded, so a body that happens to start
|
||||
// with "GET / HTTP/1.1" cannot hold the connection open.
|
||||
func (hs *http) fill(p []byte) error {
|
||||
for {
|
||||
start := len(hs.req.in)
|
||||
hs.req.in = slices.Grow(hs.req.in, len(p))
|
||||
hs.req.in = hs.req.in[:start+len(p)]
|
||||
n, err := hs.reader.Read(hs.req.in[start:])
|
||||
hs.req.in = hs.req.in[:start+n]
|
||||
|
||||
if err != nil {
|
||||
hs.req.err = err
|
||||
return nil
|
||||
}
|
||||
if n == 0 {
|
||||
return io.ErrNoProgress
|
||||
}
|
||||
if bytes.Index(hs.req.in, DELIMITER) != -1 {
|
||||
return nil
|
||||
}
|
||||
if len(hs.req.in) >= hs.maxHeader || !couldStartRequest(hs.req.in) {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var requestMethods = []string{
|
||||
"GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS", "PATCH", "TRACE", "CONNECT",
|
||||
}
|
||||
|
||||
// couldStartRequest says whether in is consistent with the beginning of a
|
||||
// request line, so the bytes so far are a header still arriving rather than a
|
||||
// body. It accepts a partly read start line, which TCP may split anywhere.
|
||||
func couldStartRequest(in []byte) bool {
|
||||
if end := bytes.IndexByte(in, '\n'); end >= 0 {
|
||||
// The first line is complete: it must be a valid request line, or these
|
||||
// bytes are a body (or a malformed request) and must not be held.
|
||||
return requestLine.Match(bytes.TrimSuffix(in[:end], []byte("\r")))
|
||||
}
|
||||
|
||||
// A trailing CR is the half of the CRLF that has not arrived yet.
|
||||
line := bytes.TrimSuffix(in, []byte("\r"))
|
||||
sp := bytes.IndexByte(line, ' ')
|
||||
if sp < 0 {
|
||||
for _, m := range requestMethods {
|
||||
if strings.HasPrefix(m, string(line)) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
if !slices.Contains(requestMethods, string(line[:sp])) {
|
||||
return false
|
||||
}
|
||||
|
||||
rest := line[sp+1:]
|
||||
if len(rest) == 0 {
|
||||
// The path has not started yet.
|
||||
return true
|
||||
}
|
||||
sp = bytes.LastIndexByte(rest, ' ')
|
||||
if sp < 0 {
|
||||
// Still the path.
|
||||
return !bytes.ContainsAny(rest, "\r\n\x00")
|
||||
}
|
||||
if len(rest[:sp]) == 0 || bytes.ContainsAny(rest[:sp], "\r\n\x00") {
|
||||
return false
|
||||
}
|
||||
version := string(rest[sp+1:])
|
||||
for _, v := range []string{"HTTP/1.0", "HTTP/1.1", "HTTP/2.0"} {
|
||||
if strings.HasPrefix(v, version) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// emit hands out what can go now and keeps the rest.
|
||||
func (hs *http) emit(p []byte) int {
|
||||
in := hs.req.in
|
||||
idx := bytes.Index(in, DELIMITER)
|
||||
if idx == -1 {
|
||||
return hs.handOut(p, in)
|
||||
}
|
||||
|
||||
headerByte, bodyByte := splitHeaderAndBody(in, idx)
|
||||
if !isHTTPHeader(headerByte) {
|
||||
// Not a header block (a body that merely starts with a request-looking
|
||||
// line, or a malformed one): pass it through byte for byte. The backend
|
||||
// is the HTTP parser of record here; this side only adds headers to real
|
||||
// requests, and there is no channel to answer with a 400.
|
||||
return hs.handOut(p, in)
|
||||
}
|
||||
|
||||
final, err := hs.rewriteRequest(headerByte, bodyByte)
|
||||
if err != nil {
|
||||
// Hand the bytes through untouched; the error follows once they are out.
|
||||
hs.req.err = err
|
||||
return hs.handOut(p, in)
|
||||
}
|
||||
return hs.handOut(p, final)
|
||||
}
|
||||
|
||||
// handOut copies block into p, keeps the remainder for the next Read, and
|
||||
// drops what was consumed from the input.
|
||||
func (hs *http) handOut(p, block []byte) int {
|
||||
n := copy(p, block)
|
||||
hs.req.in = hs.req.in[:0]
|
||||
if n < len(block) {
|
||||
hs.req.out = append(hs.req.out[:0], block[n:]...)
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// rewriteRequest returns the header block with request middleware applied,
|
||||
// followed by the body. It builds a fresh buffer so a longer added header
|
||||
// cannot overwrite the start of a body that follows it.
|
||||
func (hs *http) rewriteRequest(headerByte, bodyByte []byte) ([]byte, error) {
|
||||
reqhf, err := header.NewRequest(headerByte)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err = hs.ApplyRequestMiddlewares(reqhf); err != nil {
|
||||
return 0, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
hs.reqHeader = reqhf
|
||||
combined := append(reqhf.Finalize(), bodyByte...)
|
||||
return copy(p, combined), nil
|
||||
}
|
||||
|
||||
func handleNoDelimiter(p, tmp []byte, err error) (int, error) {
|
||||
copy(p, tmp)
|
||||
return len(tmp), err
|
||||
final := reqhf.Finalize()
|
||||
out := make([]byte, 0, len(final)+len(bodyByte))
|
||||
out = append(out, final...)
|
||||
out = append(out, bodyByte...)
|
||||
return out, nil
|
||||
}
|
||||
|
||||
@@ -0,0 +1,173 @@
|
||||
package stream
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
"tunnel_pls/internal/http/header"
|
||||
)
|
||||
|
||||
type testAddr string
|
||||
|
||||
func (a testAddr) Network() string { return "tcp" }
|
||||
func (a testAddr) String() string { return string(a) }
|
||||
|
||||
type headerMW struct{ name, value string }
|
||||
|
||||
func (m headerMW) HandleRequest(h header.RequestHeader) error {
|
||||
h.Set(m.name, m.value)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m headerMW) HandleResponse(h header.ResponseHeader, _ []byte) error {
|
||||
h.Set(m.name, m.value)
|
||||
return nil
|
||||
}
|
||||
|
||||
// A read that fills the copy buffer used to return more bytes than the buffer
|
||||
// held, which panics io.Copy, and dropped the tail of the body. It must hand
|
||||
// out exactly the rewritten request and then the body.
|
||||
func TestReadFullBufferDoesNotOverrun(t *testing.T) {
|
||||
body := strings.Repeat("x", 40000)
|
||||
in := []byte("POST /upload HTTP/1.1\r\nHost: a.example.com\r\nContent-Length: 40000\r\n\r\n" + body)
|
||||
|
||||
var out bytes.Buffer
|
||||
hs := New(&out, bytes.NewReader(in), testAddr("203.0.113.9:1234"), 4096)
|
||||
hs.UseRequestMiddleware(headerMW{"X-Forwarded-For", "203.0.113.9"})
|
||||
|
||||
_, err := io.CopyBuffer(&out, hs, make([]byte, 32768))
|
||||
require.NoError(t, err)
|
||||
|
||||
got := out.String()
|
||||
added := "X-Forwarded-For: 203.0.113.9\r\n"
|
||||
assert.True(t, strings.HasPrefix(got, "POST /upload HTTP/1.1\r\nHost: a.example.com\r\nContent-Length: 40000\r\n"+added+"\r\n"))
|
||||
assert.True(t, strings.HasSuffix(got, body), "body must arrive whole")
|
||||
assert.Equal(t, len(in)+len(added), len(got), "not one byte lost or added")
|
||||
}
|
||||
|
||||
// A backend that never sends the blank line must not grow the response buffer
|
||||
// without limit: past the header cap the bytes are passed straight through.
|
||||
func TestWriteStopsBufferingPastHeaderCap(t *testing.T) {
|
||||
var out bytes.Buffer
|
||||
hs := New(&out, bytes.NewReader(nil), testAddr("203.0.113.9:1234"), 512)
|
||||
|
||||
frag := []byte("HTTP/1.1 200 OK\r\nX-Big: " + strings.Repeat("a", 1000))
|
||||
n, err := hs.Write(frag)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, len(frag), n)
|
||||
assert.Equal(t, string(frag), out.String(), "bytes must pass through once the cap is reached")
|
||||
assert.Empty(t, hs.(*http).buf, "nothing may stay buffered past the cap")
|
||||
|
||||
_, err = hs.Write([]byte("\r\n\r\nbody"))
|
||||
require.NoError(t, err)
|
||||
assert.True(t, strings.HasSuffix(out.String(), "\r\n\r\nbody"))
|
||||
}
|
||||
|
||||
// 70 Set-Cookie lines are a normal response, not an attack. Every line must
|
||||
// reach the client and the response middleware must still run.
|
||||
func TestWriteKeepsManySetCookieHeaders(t *testing.T) {
|
||||
var resp strings.Builder
|
||||
resp.WriteString("HTTP/1.1 200 OK\r\n")
|
||||
for i := 0; i < 70; i++ {
|
||||
fmt.Fprintf(&resp, "Set-Cookie: c%d=v\r\n", i)
|
||||
}
|
||||
resp.WriteString("\r\n")
|
||||
|
||||
var out bytes.Buffer
|
||||
hs := New(&out, bytes.NewReader(nil), testAddr("203.0.113.9:1234"), 4096)
|
||||
hs.UseResponseMiddleware(headerMW{"Server", "Tunnel Please"})
|
||||
|
||||
_, err := hs.Write([]byte(resp.String()))
|
||||
require.NoError(t, err)
|
||||
|
||||
got := out.String()
|
||||
assert.Contains(t, got, "Server: Tunnel Please\r\n")
|
||||
for i := 0; i < 70; i++ {
|
||||
assert.Contains(t, got, fmt.Sprintf("Set-Cookie: c%d=v\r\n", i))
|
||||
}
|
||||
assert.True(t, strings.HasSuffix(got, "\r\n\r\n"))
|
||||
}
|
||||
|
||||
// Same on the request side: 70 headers plus the body must all reach the app,
|
||||
// with the real X-Forwarded-For added.
|
||||
func TestReadKeepsManyHeaders(t *testing.T) {
|
||||
var req strings.Builder
|
||||
req.WriteString("POST / HTTP/1.1\r\nHost: a.example.com\r\n")
|
||||
for i := 0; i < 70; i++ {
|
||||
fmt.Fprintf(&req, "X-Custom-%02d: v\r\n", i)
|
||||
}
|
||||
req.WriteString("Content-Length: 4\r\n\r\nbody")
|
||||
|
||||
var out bytes.Buffer
|
||||
hs := New(&out, strings.NewReader(req.String()), testAddr("203.0.113.9:1234"), 4096)
|
||||
hs.UseRequestMiddleware(headerMW{"X-Forwarded-For", "203.0.113.9"})
|
||||
|
||||
_, err := io.CopyBuffer(&out, hs, make([]byte, 32768))
|
||||
require.NoError(t, err)
|
||||
|
||||
got := out.String()
|
||||
assert.Contains(t, got, "X-Forwarded-For: 203.0.113.9\r\n")
|
||||
for i := 0; i < 70; i++ {
|
||||
assert.Contains(t, got, fmt.Sprintf("X-Custom-%02d: v\r\n", i))
|
||||
}
|
||||
assert.True(t, strings.HasSuffix(got, "\r\n\r\nbody"))
|
||||
}
|
||||
|
||||
// Read and Write run in two goroutines on one connection. They must not touch
|
||||
// the same state; run this with -race.
|
||||
func TestConcurrentReadWrite(t *testing.T) {
|
||||
requests := bytes.Repeat([]byte("GET / HTTP/1.1\r\nHost: a.example.com\r\n\r\n"), 200)
|
||||
|
||||
hs := New(io.Discard, bytes.NewReader(requests), testAddr("203.0.113.9:1234"), 4096)
|
||||
hs.UseRequestMiddleware(headerMW{"X-Forwarded-For", "203.0.113.9"})
|
||||
|
||||
var wg sync.WaitGroup
|
||||
wg.Add(2)
|
||||
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
p := make([]byte, 4096)
|
||||
for {
|
||||
if _, err := hs.Read(p); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
response := []byte("HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")
|
||||
for i := 0; i < 200; i++ {
|
||||
_, _ = hs.Write(response[:20])
|
||||
_, _ = hs.Write(response[20:])
|
||||
}
|
||||
}()
|
||||
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
// The two copier goroutines used to share one buffer: a short request read
|
||||
// truncated a half-received response. Keeping them apart fixes that.
|
||||
func TestReadDoesNotTruncateBufferedResponse(t *testing.T) {
|
||||
var out bytes.Buffer
|
||||
hs := New(&out, bytes.NewReader([]byte("x")), testAddr("203.0.113.9:1234"), 4096)
|
||||
// No response middleware: the output is the header exactly as sent.
|
||||
|
||||
_, err := hs.Write([]byte("HTTP/1.1 200 OK\r\nContent-Le"))
|
||||
require.NoError(t, err)
|
||||
_, err = hs.Read(make([]byte, 8))
|
||||
require.NoError(t, err)
|
||||
_, err = hs.Write([]byte("ngth: 5\r\n\r\nhello"))
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Equal(t, "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nhello", out.String())
|
||||
}
|
||||
|
||||
var _ net.Addr = testAddr("")
|
||||
@@ -26,23 +26,39 @@ type HTTP interface {
|
||||
ApplyRequestMiddlewares(reqhf header.RequestHeader) error
|
||||
}
|
||||
|
||||
// http is used by two goroutines at once: one copies client to app (Read) and
|
||||
// one app to client (Write). Request and response state never mix.
|
||||
type http struct {
|
||||
remoteAddr net.Addr
|
||||
writer io.Writer
|
||||
reader io.Reader
|
||||
buf []byte
|
||||
|
||||
// Response side (Write).
|
||||
buf []byte
|
||||
maxHeader int
|
||||
// bodyLeft is how many body bytes the last response still owes: its
|
||||
// declared Content-Length minus what went out. While > 0 the next bytes are
|
||||
// body, never a header block, so they are written straight through.
|
||||
bodyLeft int
|
||||
respHeader header.ResponseHeader
|
||||
reqHeader header.RequestHeader
|
||||
respMW []middleware.ResponseMiddleware
|
||||
reqMW []middleware.RequestMiddleware
|
||||
|
||||
// Request side (Read).
|
||||
reqHeader header.RequestHeader
|
||||
req reqState
|
||||
|
||||
respMW []middleware.ResponseMiddleware
|
||||
reqMW []middleware.RequestMiddleware
|
||||
}
|
||||
|
||||
func New(writer io.Writer, reader io.Reader, remoteAddr net.Addr) HTTP {
|
||||
// New takes the largest header it should hold while looking for the end of a
|
||||
// header block, and the largest header it should buffer from the app's side.
|
||||
func New(writer io.Writer, reader io.Reader, remoteAddr net.Addr, maxHeader int) HTTP {
|
||||
return &http{
|
||||
remoteAddr: remoteAddr,
|
||||
writer: writer,
|
||||
reader: reader,
|
||||
buf: make([]byte, 0, 4096),
|
||||
maxHeader: maxHeader,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+183
-101
@@ -3,10 +3,12 @@ package stream
|
||||
import (
|
||||
"bytes"
|
||||
"io"
|
||||
"net"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"tunnel_pls/internal/http/header"
|
||||
"tunnel_pls/internal/middleware"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/mock"
|
||||
@@ -153,7 +155,7 @@ func TestHTTPMethods(t *testing.T) {
|
||||
addr.On("String").Return("1.2.3.4:1234")
|
||||
|
||||
rw := new(MockReadWriter)
|
||||
hs := New(rw, rw, addr)
|
||||
hs := New(rw, rw, addr, 4096)
|
||||
|
||||
assert.Equal(t, addr, hs.RemoteAddr())
|
||||
|
||||
@@ -244,7 +246,7 @@ func TestApplyMiddlewares(t *testing.T) {
|
||||
addr.On("String").Return("1.2.3.4:1234")
|
||||
|
||||
rw := new(MockReadWriter)
|
||||
hs := New(rw, rw, addr)
|
||||
hs := New(rw, rw, addr, 4096)
|
||||
|
||||
reqMW := new(MockRequestMiddleware)
|
||||
respMW := new(MockResponseMiddleware)
|
||||
@@ -335,7 +337,7 @@ func TestCloseMethods(t *testing.T) {
|
||||
addr.On("String").Return("1.2.3.4:1234")
|
||||
|
||||
w, r := tt.setup()
|
||||
hs := New(w, r, addr)
|
||||
hs := New(w, r, addr, 4096)
|
||||
|
||||
assert.NotPanics(t, func() {
|
||||
err := tt.op(hs)
|
||||
@@ -413,6 +415,21 @@ func TestIsHTTPHeader(t *testing.T) {
|
||||
buf: []byte("GET / HTTP/1.1\r\n: value\r\n\r\n"),
|
||||
expect: false,
|
||||
},
|
||||
{
|
||||
name: "obs-fold line",
|
||||
buf: []byte("GET / HTTP/1.1\r\nX-A: one\r\n two\r\n\r\n"),
|
||||
expect: false,
|
||||
},
|
||||
{
|
||||
name: "space before colon",
|
||||
buf: []byte("GET / HTTP/1.1\r\nX-A : one\r\n\r\n"),
|
||||
expect: false,
|
||||
},
|
||||
{
|
||||
name: "bare CR in value",
|
||||
buf: []byte("GET / HTTP/1.1\r\nX-A: v\rl\r\n\r\n"),
|
||||
expect: false,
|
||||
},
|
||||
{
|
||||
name: "empty header section",
|
||||
buf: []byte("GET / HTTP/1.1\r\n\r\n"),
|
||||
@@ -433,109 +450,114 @@ func TestIsHTTPHeader(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestRead(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
input []byte
|
||||
readLen int
|
||||
expectContent string
|
||||
expectRead int
|
||||
expectErr bool
|
||||
middlewareErr error
|
||||
isHTTP bool
|
||||
}{
|
||||
{
|
||||
name: "valid http request",
|
||||
input: []byte("GET / HTTP/1.1\r\nHost: test\r\n\r\nBody"),
|
||||
readLen: 100,
|
||||
expectContent: "Body",
|
||||
expectRead: 54,
|
||||
isHTTP: true,
|
||||
},
|
||||
{
|
||||
name: "non-http data",
|
||||
input: []byte("Some random data\r\n\r\nMore data"),
|
||||
readLen: 100,
|
||||
expectContent: "Some random data\r\n\r\nMore data",
|
||||
expectRead: 29,
|
||||
isHTTP: false,
|
||||
},
|
||||
{
|
||||
name: "no delimiter",
|
||||
input: []byte("Partial data without delimiter"),
|
||||
readLen: 100,
|
||||
expectContent: "Partial data without delimiter",
|
||||
expectRead: 30,
|
||||
isHTTP: false,
|
||||
},
|
||||
{
|
||||
name: "middleware error",
|
||||
input: []byte("GET / HTTP/1.1\r\nHost: test\r\n\r\n"),
|
||||
readLen: 100,
|
||||
middlewareErr: assert.AnError,
|
||||
expectErr: true,
|
||||
isHTTP: true,
|
||||
},
|
||||
}
|
||||
// requestCase is one input for TestStreamRead: what the client sends, and what
|
||||
// Read must hand out in the end.
|
||||
type requestCase struct {
|
||||
name string
|
||||
input []byte
|
||||
want string
|
||||
middleware bool
|
||||
middlewareErr error
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
var readCases = []requestCase{
|
||||
{
|
||||
name: "valid http request",
|
||||
input: []byte("GET / HTTP/1.1\r\nHost: test\r\n\r\nBody"),
|
||||
want: "GET / HTTP/1.1\r\nHost: test\r\nX-Middleware: true\r\n\r\nBody",
|
||||
middleware: true,
|
||||
},
|
||||
{
|
||||
// The rewrite adds bytes, so a full caller buffer cannot take it all:
|
||||
// the rest has to come out on the next Read, never more than len(p).
|
||||
name: "rewritten request larger than a full buffer",
|
||||
input: []byte("GET / HTTP/1.1\r\nHost: a.example.com\r\n\r\n" + strings.Repeat("x", 63000)),
|
||||
want: "GET / HTTP/1.1\r\nHost: a.example.com\r\nX-Middleware: true\r\n\r\n" + strings.Repeat("x", 63000),
|
||||
middleware: true,
|
||||
},
|
||||
{
|
||||
// A header that arrives in pieces still gets the header added. Fewer
|
||||
// than 64 fields: the parser caps those.
|
||||
name: "header split across reads",
|
||||
input: []byte("GET / HTTP/1.1\r\n" + strings.Repeat("X-Pad: "+strings.Repeat("a", 200)+"\r\n", 10) + "\r\nBody"),
|
||||
want: "GET / HTTP/1.1\r\n" + strings.Repeat("X-Pad: "+strings.Repeat("a", 200)+"\r\n", 10) + "X-Middleware: true\r\n\r\nBody",
|
||||
middleware: true,
|
||||
},
|
||||
{
|
||||
name: "non-http data",
|
||||
input: []byte("Some random data\r\n\r\nMore data"),
|
||||
want: "Some random data\r\n\r\nMore data",
|
||||
},
|
||||
{
|
||||
name: "no delimiter",
|
||||
input: []byte("Partial data without delimiter"),
|
||||
want: "Partial data without delimiter",
|
||||
},
|
||||
{
|
||||
name: "malformed block passes through untouched",
|
||||
input: []byte("GET / HTTP/1.1\r\nHost: test\r\nNoColon\r\n\r\n"),
|
||||
want: "GET / HTTP/1.1\r\nHost: test\r\nNoColon\r\n\r\n",
|
||||
},
|
||||
{
|
||||
name: "plain body passes through",
|
||||
input: []byte("GET / HTTP/1.1\r\nno colon here\r\n\r\n"),
|
||||
want: "GET / HTTP/1.1\r\nno colon here\r\n\r\n",
|
||||
},
|
||||
{
|
||||
name: "middleware error",
|
||||
input: []byte("GET / HTTP/1.1\r\nHost: test\r\n\r\n"),
|
||||
middlewareErr: assert.AnError,
|
||||
},
|
||||
}
|
||||
|
||||
// TestStreamRead reads each case with several buffer sizes. The bytes handed
|
||||
// out must always be the same, and never more than the buffer.
|
||||
func TestStreamRead(t *testing.T) {
|
||||
for _, tt := range readCases {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
addr := new(MockAddr)
|
||||
addr.On("String").Return("1.2.3.4:1234")
|
||||
for _, size := range []int{1, 7, 64, 4096, 32768} {
|
||||
addr := new(MockAddr)
|
||||
addr.On("String").Return("1.2.3.4:1234")
|
||||
hs := New(io.Discard, bytes.NewReader(tt.input), addr, 4096)
|
||||
|
||||
reader := new(MockReader)
|
||||
writer := new(MockWriterOnly)
|
||||
var reqMW *MockRequestMiddleware
|
||||
if tt.middleware || tt.middlewareErr != nil {
|
||||
reqMW = new(MockRequestMiddleware)
|
||||
if tt.middlewareErr != nil {
|
||||
reqMW.On("HandleRequest", mock.Anything).Return(tt.middlewareErr)
|
||||
} else {
|
||||
reqMW.On("HandleRequest", mock.Anything).Run(func(args mock.Arguments) {
|
||||
h := args.Get(0).(header.RequestHeader)
|
||||
h.Set("X-Middleware", "true")
|
||||
}).Return(nil)
|
||||
}
|
||||
hs.UseRequestMiddleware(reqMW)
|
||||
}
|
||||
|
||||
if tt.expectErr || tt.name == "valid http request" {
|
||||
reader.On("Read", mock.Anything).Run(func(args mock.Arguments) {
|
||||
p := args.Get(0).([]byte)
|
||||
copy(p, tt.input)
|
||||
}).Return(len(tt.input), io.EOF).Once()
|
||||
} else {
|
||||
reader.On("Read", mock.Anything).Run(func(args mock.Arguments) {
|
||||
p := args.Get(0).([]byte)
|
||||
copy(p, tt.input)
|
||||
}).Return(len(tt.input), nil).Once()
|
||||
}
|
||||
var got []byte
|
||||
var readErr error
|
||||
p := make([]byte, size)
|
||||
for i := 0; i < 100000; i++ {
|
||||
n, err := hs.Read(p)
|
||||
// Never more than the buffer: io.Copy panics on that.
|
||||
assert.LessOrEqual(t, n, size)
|
||||
got = append(got, p[:n]...)
|
||||
if err != nil {
|
||||
readErr = err
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
hs := New(writer, reader, addr)
|
||||
|
||||
reqMW := new(MockRequestMiddleware)
|
||||
if tt.isHTTP {
|
||||
if tt.middlewareErr != nil {
|
||||
reqMW.On("HandleRequest", mock.Anything).Return(tt.middlewareErr)
|
||||
assert.Error(t, readErr)
|
||||
} else {
|
||||
reqMW.On("HandleRequest", mock.Anything).Run(func(args mock.Arguments) {
|
||||
h := args.Get(0).(header.RequestHeader)
|
||||
h.Set("X-Middleware", "true")
|
||||
}).Return(nil)
|
||||
assert.Equal(t, tt.want, string(got), "buffer size %d", size)
|
||||
assert.ErrorIs(t, readErr, io.EOF)
|
||||
}
|
||||
if reqMW != nil {
|
||||
reqMW.AssertExpectations(t)
|
||||
}
|
||||
}
|
||||
hs.UseRequestMiddleware(reqMW)
|
||||
|
||||
p := make([]byte, tt.readLen)
|
||||
n, err := hs.Read(p)
|
||||
|
||||
if tt.expectErr {
|
||||
assert.Error(t, err)
|
||||
} else {
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, tt.expectRead, n)
|
||||
if tt.name == "valid http request" {
|
||||
content := string(p[:n])
|
||||
assert.Contains(t, content, "GET / HTTP/1.1\r\n")
|
||||
assert.Contains(t, content, "Host: test\r\n")
|
||||
assert.Contains(t, content, "X-Middleware: true\r\n")
|
||||
assert.True(t, bytes.HasSuffix(p[:n], []byte("\r\n\r\nBody")))
|
||||
} else {
|
||||
assert.Equal(t, tt.expectContent, string(p[:n]))
|
||||
}
|
||||
}
|
||||
|
||||
if tt.isHTTP {
|
||||
reqMW.AssertExpectations(t)
|
||||
}
|
||||
reader.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -612,7 +634,7 @@ func TestWrite(t *testing.T) {
|
||||
}, nil)
|
||||
|
||||
reader := new(MockReader)
|
||||
hs := New(writer, reader, addr)
|
||||
hs := New(writer, reader, addr, 4096)
|
||||
|
||||
respMW := new(MockResponseMiddleware)
|
||||
if tt.isHTTP {
|
||||
@@ -710,7 +732,7 @@ func TestWriteErrors(t *testing.T) {
|
||||
addr.On("String").Return("1.2.3.4:1234")
|
||||
|
||||
w, r := tt.setup()
|
||||
hs := New(w, r, addr)
|
||||
hs := New(w, r, addr, 4096)
|
||||
|
||||
_, err := hs.Write(tt.data)
|
||||
assert.Error(t, err)
|
||||
@@ -729,13 +751,15 @@ func TestReadEOF(t *testing.T) {
|
||||
expectContent string
|
||||
}{
|
||||
{
|
||||
// Read hands out what it took before the error, and the error on
|
||||
// the next call -- the io.Reader contract.
|
||||
name: "read eof",
|
||||
setup: func() io.Reader {
|
||||
reader := new(MockReader)
|
||||
reader.On("Read", mock.Anything).Run(func(args mock.Arguments) {
|
||||
p := args.Get(0).([]byte)
|
||||
copy(p, "data")
|
||||
}).Return(4, io.EOF)
|
||||
}).Return(4, io.EOF).Once()
|
||||
return reader
|
||||
},
|
||||
expectN: 4,
|
||||
@@ -750,7 +774,7 @@ func TestReadEOF(t *testing.T) {
|
||||
addr.On("String").Return("1.2.3.4:1234")
|
||||
|
||||
reader := tt.setup()
|
||||
hs := New(nil, reader, addr)
|
||||
hs := New(nil, reader, addr, 4096)
|
||||
|
||||
p := make([]byte, 100)
|
||||
n, err := hs.Read(p)
|
||||
@@ -763,3 +787,61 @@ func TestReadEOF(t *testing.T) {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
type discardWriter struct{}
|
||||
|
||||
func (discardWriter) Write(p []byte) (int, error) { return len(p), nil }
|
||||
func (discardWriter) Close() error { return nil }
|
||||
|
||||
type emptyReader struct{}
|
||||
|
||||
func (emptyReader) Read(p []byte) (int, error) { return 0, io.EOF }
|
||||
|
||||
// A response shape the tunnel actually forwards: a few headers, short body.
|
||||
func benchResponse() []byte {
|
||||
return []byte("HTTP/1.1 200 OK\r\n" +
|
||||
"Content-Type: application/json\r\n" +
|
||||
"Content-Length: 3\r\n" +
|
||||
"Connection: keep-alive\r\n" +
|
||||
"Date: Tue, 10 Nov 2026 00:00:00 GMT\r\n" +
|
||||
"Server: upstream\r\n" +
|
||||
"\r\nabc")
|
||||
}
|
||||
|
||||
func benchAddr() net.Addr {
|
||||
a, _ := net.ResolveTCPAddr("tcp", "1.2.3.4:1234")
|
||||
return a
|
||||
}
|
||||
|
||||
// One response header parsed and rewritten: the cost per tunneled response.
|
||||
func BenchmarkNewResponse(b *testing.B) {
|
||||
in := benchResponse()
|
||||
frame := in[:bytes.Index(in, DELIMITER)+len(DELIMITER)]
|
||||
|
||||
b.ReportAllocs()
|
||||
b.SetBytes(int64(len(frame)))
|
||||
b.ResetTimer()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
if _, err := header.NewResponse(frame); err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// End-to-end: stream.Write parses, runs middleware wiped and emits one response.
|
||||
func BenchmarkStreamWriteOneResponse(b *testing.B) {
|
||||
in := benchResponse()
|
||||
|
||||
b.ReportAllocs()
|
||||
b.SetBytes(int64(len(in)))
|
||||
b.ResetTimer()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
hs := New(discardWriter{}, emptyReader{}, benchAddr(), 4096)
|
||||
hs.UseResponseMiddleware(middleware.NewTunnelFingerprint())
|
||||
if _, err := hs.Write(in); err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+128
-43
@@ -2,75 +2,153 @@ package stream
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"strconv"
|
||||
"strings"
|
||||
"tunnel_pls/internal/http/header"
|
||||
)
|
||||
|
||||
// Write splits the app's output on response boundaries. The app writes headers
|
||||
// and bodies in whatever chunks it likes, so one Write may carry a header
|
||||
// block, a body, the tail of a body, or two whole responses.
|
||||
//
|
||||
// A response ends where its Content-Length says. Bytes up to that end are
|
||||
// parsed (header rewritten, middleware applied), and whatever follows is
|
||||
// as the next response: if it opens with a status line it is one, otherwise it
|
||||
// is excess body from the app and is streamed through untouched. Framing that
|
||||
// cannot be measured -- chunked, or no length -- passes through as before.
|
||||
func (hs *http) Write(p []byte) (int, error) {
|
||||
if hs.shouldBypassBuffering(p) {
|
||||
hs.respHeader = nil
|
||||
}
|
||||
// Still in the body of the last response: nothing here can be a header.
|
||||
// Write it through and never search it for "\r\n\r\n".
|
||||
if hs.bodyLeft > 0 {
|
||||
n := min(hs.bodyLeft, len(p))
|
||||
if _, err := hs.writer.Write(p[:n]); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
hs.bodyLeft -= n
|
||||
p = p[n:]
|
||||
|
||||
if hs.respHeader != nil {
|
||||
return hs.writer.Write(p)
|
||||
if len(p) == 0 {
|
||||
return n, nil
|
||||
}
|
||||
}
|
||||
|
||||
hs.buf = append(hs.buf, p...)
|
||||
|
||||
headerEndIdx := bytes.Index(hs.buf, DELIMITER)
|
||||
if headerEndIdx == -1 {
|
||||
return len(p), nil
|
||||
}
|
||||
|
||||
return hs.processBufferedResponse(p, headerEndIdx)
|
||||
}
|
||||
|
||||
func (hs *http) shouldBypassBuffering(p []byte) bool {
|
||||
return hs.respHeader != nil && len(hs.buf) == 0 && len(p) >= 5 && string(p[0:5]) == "HTTP/"
|
||||
}
|
||||
|
||||
func (hs *http) processBufferedResponse(p []byte, delimiterIdx int) (int, error) {
|
||||
headerByte, bodyByte := splitHeaderAndBody(hs.buf, delimiterIdx)
|
||||
|
||||
if !isHTTPHeader(headerByte) {
|
||||
return hs.writeRawBuffer()
|
||||
}
|
||||
|
||||
if err := hs.processHTTPResponse(headerByte, bodyByte); err != nil {
|
||||
written, rest, err := hs.drainBuffer()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
_ = written
|
||||
|
||||
hs.buf = rest
|
||||
if len(rest) == 0 {
|
||||
hs.buf = nil
|
||||
}
|
||||
|
||||
hs.buf = nil
|
||||
return len(p), nil
|
||||
}
|
||||
|
||||
func (hs *http) writeRawBuffer() (int, error) {
|
||||
_, err := hs.writer.Write(hs.buf)
|
||||
length := len(hs.buf)
|
||||
hs.buf = nil
|
||||
if err != nil {
|
||||
return 0, err
|
||||
// drainBuffer handles every complete response already in hs.buf and returns
|
||||
// what is left over (an incomplete header block).
|
||||
func (hs *http) drainBuffer() (int, []byte, error) {
|
||||
written := 0
|
||||
|
||||
for {
|
||||
// After a response has been parsed, bytes that cannot begin another
|
||||
// one are that response's excess body (the app sent more than its own
|
||||
// Content-Length said). Streaming them through is safe; holding them
|
||||
// would lose them if the connection closes before a blank line arrives.
|
||||
if hs.respHeader != nil && len(hs.buf) > 0 && !bytes.HasPrefix(hs.buf, []byte("HTTP/")) {
|
||||
if err := hs.writeRawBuffer(); err != nil {
|
||||
return written, nil, err
|
||||
}
|
||||
return written, nil, nil
|
||||
}
|
||||
|
||||
headerEndIdx := bytes.Index(hs.buf, DELIMITER)
|
||||
if headerEndIdx == -1 {
|
||||
// Too big to be a header (or one that never ends): stop holding it,
|
||||
// or the app can grow this buffer until the process runs out of
|
||||
// memory.
|
||||
if len(hs.buf) > hs.maxHeader {
|
||||
if err := hs.writeRawBuffer(); err != nil {
|
||||
return written, nil, err
|
||||
}
|
||||
return written, nil, nil
|
||||
}
|
||||
return written, hs.buf, nil
|
||||
}
|
||||
|
||||
headerByte, bodyByte := splitHeaderAndBody(hs.buf, headerEndIdx)
|
||||
if !isHTTPHeader(headerByte) {
|
||||
if err := hs.writeRawBuffer(); err != nil {
|
||||
return written, nil, err
|
||||
}
|
||||
return written, nil, nil
|
||||
}
|
||||
|
||||
// One parse per response: the headers and the body length come from it.
|
||||
resphf, err := header.NewResponse(headerByte)
|
||||
if err != nil {
|
||||
return written, nil, err
|
||||
}
|
||||
|
||||
n, known := bodyLength(resphf)
|
||||
if !known || n > len(bodyByte) {
|
||||
// The body continues past this write, or its framing is unknown:
|
||||
// write the header block and the body part in hand, and let the
|
||||
// next writes stream straight through.
|
||||
hs.bodyLeft = 0
|
||||
if known {
|
||||
hs.bodyLeft = n - len(bodyByte)
|
||||
}
|
||||
|
||||
if err := hs.processHTTPResponse(resphf, bodyByte); err != nil {
|
||||
return written, nil, err
|
||||
}
|
||||
return written, nil, nil
|
||||
}
|
||||
|
||||
if err := hs.processHTTPResponse(resphf, bodyByte[:n]); err != nil {
|
||||
return written, nil, err
|
||||
}
|
||||
written++
|
||||
|
||||
hs.buf = bodyByte[n:]
|
||||
if len(hs.buf) == 0 {
|
||||
hs.buf = nil
|
||||
return written, nil, nil
|
||||
}
|
||||
}
|
||||
return length, nil
|
||||
}
|
||||
|
||||
func (hs *http) processHTTPResponse(headerByte, bodyByte []byte) error {
|
||||
resphf, err := header.NewResponse(headerByte)
|
||||
if err != nil {
|
||||
return err
|
||||
// bodyLength is the body length the response declares. known is false when the
|
||||
// framing cannot be trusted (chunked, or absent or not a number), in which case
|
||||
// the rest of the stream is passed through untouched.
|
||||
func bodyLength(resphf header.ResponseHeader) (n int, known bool) {
|
||||
if strings.Contains(strings.ToLower(resphf.Value("Transfer-Encoding")), "chunked") {
|
||||
return 0, false
|
||||
}
|
||||
|
||||
if err = hs.ApplyResponseMiddlewares(resphf, bodyByte); err != nil {
|
||||
n, err := strconv.Atoi(strings.TrimSpace(resphf.Value("Content-Length")))
|
||||
if err != nil || n < 0 {
|
||||
return 0, false
|
||||
}
|
||||
|
||||
return n, true
|
||||
}
|
||||
|
||||
// processHTTPResponse applies the middleware to an already parsed header and
|
||||
// writes the rewritten header followed by bodyByte.
|
||||
func (hs *http) processHTTPResponse(resphf header.ResponseHeader, bodyByte []byte) error {
|
||||
if err := hs.ApplyResponseMiddlewares(resphf, bodyByte); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
hs.respHeader = resphf
|
||||
finalHeader := resphf.Finalize()
|
||||
|
||||
if err = hs.writeHeaderAndBody(finalHeader, bodyByte); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
return hs.writeHeaderAndBody(finalHeader, bodyByte)
|
||||
}
|
||||
|
||||
func (hs *http) writeHeaderAndBody(header, bodyByte []byte) error {
|
||||
@@ -86,3 +164,10 @@ func (hs *http) writeHeaderAndBody(header, bodyByte []byte) error {
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// writeRawBuffer passes the buffered bytes through untouched.
|
||||
func (hs *http) writeRawBuffer() error {
|
||||
_, err := hs.writer.Write(hs.buf)
|
||||
hs.buf = nil
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -0,0 +1,183 @@
|
||||
package stream
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"net"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"tunnel_pls/internal/http/header"
|
||||
|
||||
"github.com/stretchr/testify/mock"
|
||||
)
|
||||
|
||||
type captureWriter struct{ b bytes.Buffer }
|
||||
|
||||
func (w *captureWriter) Write(p []byte) (int, error) { return w.b.Write(p) }
|
||||
|
||||
func newCaptureWriter() (HTTP, *captureWriter) {
|
||||
w := &captureWriter{}
|
||||
addr, _ := net.ResolveTCPAddr("tcp", "1.2.3.4:1234")
|
||||
return New(w, bytes.NewReader(nil), addr, 4096), w
|
||||
}
|
||||
|
||||
func writeAll(t *testing.T, writes []string) string {
|
||||
t.Helper()
|
||||
|
||||
var out bytes.Buffer
|
||||
w := new(MockWriter)
|
||||
w.On("Write", mock.Anything).Run(func(a mock.Arguments) {
|
||||
out.Write(a.Get(0).([]byte))
|
||||
}).Return(func(p []byte) int { return len(p) }, nil)
|
||||
|
||||
addr, _ := net.ResolveTCPAddr("tcp", "1.2.3.4:1234")
|
||||
hs := New(w, bytes.NewReader(nil), addr, 4096)
|
||||
|
||||
mw := new(MockResponseMiddleware)
|
||||
mw.On("HandleResponse", mock.Anything, mock.Anything).Run(func(a mock.Arguments) {
|
||||
a.Get(0).(header.ResponseHeader).Set("Server", "Tunnel Please")
|
||||
}).Return(nil)
|
||||
hs.UseResponseMiddleware(mw)
|
||||
|
||||
for _, p := range writes {
|
||||
_, err := hs.Write([]byte(p))
|
||||
if err != nil {
|
||||
t.Fatalf("Write(%q): %v", p, err)
|
||||
}
|
||||
}
|
||||
return out.String()
|
||||
}
|
||||
|
||||
// The body may arrive across writes, not in one. Bytes after the header block
|
||||
// are body, and must be written straight through -- never buffered and looked
|
||||
// at for a "\r\n\r\n" again.
|
||||
func TestWrite_BodySplitAcrossWrites(t *testing.T) {
|
||||
var out bytes.Buffer
|
||||
|
||||
w := new(MockWriter)
|
||||
w.On("Write", mock.Anything).Run(func(a mock.Arguments) {
|
||||
out.Write(a.Get(0).([]byte))
|
||||
}).Return(func(p []byte) int { return len(p) }, nil)
|
||||
|
||||
addr, _ := net.ResolveTCPAddr("tcp", "1.2.3.4:1234")
|
||||
hs := New(w, bytes.NewReader(nil), addr, 4096)
|
||||
|
||||
writes := []string{
|
||||
"HTTP/1.1 200 OK\r\nContent-Length: 9\r\n\r\nabc",
|
||||
"def",
|
||||
"ghi",
|
||||
}
|
||||
|
||||
for _, s := range writes {
|
||||
if _, err := hs.Write([]byte(s)); err != nil {
|
||||
t.Fatalf("Write(%q): %v", s, err)
|
||||
}
|
||||
}
|
||||
|
||||
if got, want := out.String(), "HTTP/1.1 200 OK\r\nContent-Length: 9\r\n\r\nabcdefghi"; got != want {
|
||||
t.Fatalf("body bytes lost or reordered:\n got %q\nwant %q", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
// A response whose body continues across writes, where the write that finishes
|
||||
// it also carries the whole next response. bodyLeft must stop at exactly the
|
||||
// declared end, and the remainder must be parsed as a new response -- not
|
||||
// appended to the old body, which would corrupt or drop it. The middleware
|
||||
// count is what proves the second block was parsed, since the bytes alone are
|
||||
// the same either way.
|
||||
func TestWrite_BodyLeftThenNextResponseSameWrite(t *testing.T) {
|
||||
hs, out := newCaptureWriter()
|
||||
hs.UseResponseMiddleware(headerMW{"Server", "Tunnel Please"})
|
||||
|
||||
// Declares 5 body bytes, only 2 arrive.
|
||||
if _, err := hs.Write([]byte("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nab")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Finishes the body (3 bytes) and carries the next response in one write.
|
||||
if _, err := hs.Write([]byte("cdeHTTP/1.1 201 Created\r\nContent-Length: 2\r\n\r\nzz")); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
want := "HTTP/1.1 200 OK\r\nContent-Length: 5\r\nServer: Tunnel Please\r\n\r\nabcde" +
|
||||
"HTTP/1.1 201 Created\r\nContent-Length: 2\r\nServer: Tunnel Please\r\n\r\nzz"
|
||||
if got := out.b.String(); got != want {
|
||||
t.Fatalf("body split or next response mangled:\n got %q\nwant %q", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
// An app that sends a body longer than its own Content-Length used to have the
|
||||
// excess held in the buffer until a blank line arrived, so on connection close
|
||||
// those bytes were never written. They are body; stream them through.
|
||||
func TestWrite_BodyLongerThanContentLength(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
writes []string
|
||||
}{
|
||||
{
|
||||
name: "excess in the same write",
|
||||
writes: []string{"HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nabcd"},
|
||||
},
|
||||
{
|
||||
name: "excess arrives in a later write",
|
||||
writes: []string{"HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nabc", "d"},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
hs, out := newCaptureWriter()
|
||||
|
||||
for _, s := range tt.writes {
|
||||
if _, err := hs.Write([]byte(s)); err != nil {
|
||||
t.Fatalf("Write(%q): %v", s, err)
|
||||
}
|
||||
}
|
||||
|
||||
if got, want := out.b.String(), "HTTP/1.1 200 OK\r\nContent-Length: 3\r\n\r\nabcd"; got != want {
|
||||
t.Fatalf("excess body bytes were dropped or re-framed:\n got %q\nwant %q", got, want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Both responses in one Write must be parsed, not one parsed and one swallowed.
|
||||
func TestWrite_TwoResponsesInOneWrite(t *testing.T) {
|
||||
got := writeAll(t, []string{
|
||||
"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nhello" +
|
||||
"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nworld",
|
||||
})
|
||||
|
||||
if n := strings.Count(got, "Server: Tunnel Please\r\n"); n != 2 {
|
||||
t.Fatalf("want middleware on 2 responses, got %d in %q", n, got)
|
||||
}
|
||||
if !strings.Contains(got, "hello") || !strings.Contains(got, "world") {
|
||||
t.Fatalf("bodies mangled: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
// A second response arriving in a later Write must be parsed too.
|
||||
func TestWrite_HeaderInLaterWrite(t *testing.T) {
|
||||
got := writeAll(t, []string{
|
||||
"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok",
|
||||
"HTTP/1.1 404 Not Found\r\nContent-Length: 4\r\n\r\nnope",
|
||||
})
|
||||
|
||||
if n := strings.Count(got, "Server: Tunnel Please\r\n"); n != 2 {
|
||||
t.Fatalf("want middleware on both responses, got %d in %q", n, got)
|
||||
}
|
||||
if !strings.Contains(got, "ok") || !strings.Contains(got, "nope") {
|
||||
t.Fatalf("bodies mangled: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
// Body text that looks like a header must pass through untouched.
|
||||
func TestWrite_BodyLooksLikeHeader(t *testing.T) {
|
||||
got := writeAll(t, []string{
|
||||
"HTTP/1.1 200 OK\r\nContent-Length: 30\r\n\r\nHTTP/1.1 200 OK\r\nFoo: bar..",
|
||||
})
|
||||
|
||||
if !strings.HasSuffix(got, "HTTP/1.1 200 OK\r\nFoo: bar..") {
|
||||
t.Fatalf("body starting with a status line was rewritten: %q", got)
|
||||
}
|
||||
}
|
||||
@@ -18,6 +18,9 @@ func (ff *ForwardedFor) HandleRequest(header header.RequestHeader) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Replace, don't keep: the parser keeps repeated fields, so a client-sent
|
||||
// X-Forwarded-For would otherwise survive next to ours.
|
||||
header.Remove("X-Forwarded-For")
|
||||
header.Set("X-Forwarded-For", host)
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -6,12 +6,18 @@ import (
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/mock"
|
||||
"github.com/stretchr/testify/require"
|
||||
"tunnel_pls/internal/http/header"
|
||||
)
|
||||
|
||||
type mockRequestHeader struct {
|
||||
mock.Mock
|
||||
}
|
||||
|
||||
func (m *mockRequestHeader) Count(key string) int {
|
||||
return m.Called(key).Int(0)
|
||||
}
|
||||
|
||||
func (m *mockRequestHeader) Value(key string) string {
|
||||
return m.Called(key).String(0)
|
||||
}
|
||||
@@ -79,6 +85,8 @@ func TestForwardedFor_HandleRequest(t *testing.T) {
|
||||
reqHeader := new(mockRequestHeader)
|
||||
|
||||
if !tc.expectError {
|
||||
// A client-sent value must not survive next to ours.
|
||||
reqHeader.On("Remove", "X-Forwarded-For").Return()
|
||||
reqHeader.On("Set", "X-Forwarded-For", tc.expectedHost).Return()
|
||||
}
|
||||
|
||||
@@ -124,3 +132,18 @@ func TestNewForwardedFor(t *testing.T) {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// A client-sent X-Forwarded-For must not survive next to the real address:
|
||||
// the parser keeps repeated fields, so Set alone would leave the second one.
|
||||
func TestForwardedForReplacesRepeatedHeader(t *testing.T) {
|
||||
raw := []byte("GET / HTTP/1.1\r\nHost: a.example.com\r\n" +
|
||||
"X-Forwarded-For: 1.1.1.1\r\nX-Forwarded-For: 6.6.6.6\r\n\r\n")
|
||||
h, err := header.NewRequest(raw)
|
||||
require.NoError(t, err)
|
||||
|
||||
ff := NewForwardedFor(&net.TCPAddr{IP: net.ParseIP("203.0.113.9"), Port: 1234})
|
||||
require.NoError(t, ff.HandleRequest(h))
|
||||
|
||||
assert.Equal(t, 1, h.Count("X-Forwarded-For"))
|
||||
assert.Equal(t, "203.0.113.9", h.Value("X-Forwarded-For"))
|
||||
}
|
||||
|
||||
@@ -1891,15 +1891,18 @@ func TestInteraction_Start_Interactive(t *testing.T) {
|
||||
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
|
||||
i := mockInteraction.(*interaction)
|
||||
i.Stop()
|
||||
|
||||
// Start must finish before Stop: bubbletea's Program is not safe
|
||||
// against a Kill during Run's initialisation, and production never
|
||||
// stops an interaction from another goroutine.
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("Start() did not complete in time")
|
||||
}
|
||||
|
||||
i := mockInteraction.(*interaction)
|
||||
i.Stop()
|
||||
|
||||
assert.Equal(t, 1, closeCallCount, "close function should be called once")
|
||||
|
||||
mockConfig.AssertExpectations(t)
|
||||
@@ -1949,12 +1952,23 @@ func TestInteraction_Start_ProtocolSelection(t *testing.T) {
|
||||
mockChannel.On("Write", mock.Anything).Return(0, nil).Maybe()
|
||||
mockInteraction.SetChannel(mockChannel)
|
||||
|
||||
// Production never stops an interaction from another goroutine:
|
||||
// the program exits when its channel closes and Start tears the
|
||||
// program down itself. bubbletea's Program is not safe against a
|
||||
// Kill during Run's initialisation, so let Start finish first.
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
defer close(done)
|
||||
mockInteraction.Start()
|
||||
}()
|
||||
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(2 * time.Second):
|
||||
}
|
||||
|
||||
i := mockInteraction.(*interaction)
|
||||
i.Stop()
|
||||
|
||||
@@ -2007,18 +2021,27 @@ func TestInteraction_Stop(t *testing.T) {
|
||||
mockChannel.On("Write", mock.Anything).Return(0, nil).Maybe()
|
||||
mockInteraction.SetChannel(mockChannel)
|
||||
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
defer close(done)
|
||||
mockInteraction.Start()
|
||||
}()
|
||||
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(2 * time.Second):
|
||||
}
|
||||
}
|
||||
|
||||
assert.NotPanics(t, func() {
|
||||
i.Stop()
|
||||
})
|
||||
|
||||
i.programMu.Lock()
|
||||
assert.Nil(t, i.program)
|
||||
i.programMu.Unlock()
|
||||
|
||||
select {
|
||||
case <-i.ctx.Done():
|
||||
@@ -2052,15 +2075,29 @@ func TestInteraction_Start_CommandListSetup(t *testing.T) {
|
||||
mockChannel.On("Write", mock.Anything).Return(0, nil)
|
||||
mockInteraction.SetChannel(mockChannel)
|
||||
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
defer close(done)
|
||||
mockInteraction.Start()
|
||||
}()
|
||||
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
|
||||
// Start must finish before Stop: bubbletea's Program is not safe against a
|
||||
// Kill during Run's initialisation, and production never stops an
|
||||
// interaction from another goroutine.
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(2 * time.Second):
|
||||
}
|
||||
|
||||
i := mockInteraction.(*interaction)
|
||||
|
||||
assert.NotNil(t, i.program, "program should be initialized")
|
||||
// Start writes i.program on another goroutine under programMu.
|
||||
i.programMu.Lock()
|
||||
programReady := i.program != nil
|
||||
i.programMu.Unlock()
|
||||
assert.True(t, programReady, "program should be initialized")
|
||||
|
||||
i.Stop()
|
||||
}
|
||||
@@ -2087,12 +2124,21 @@ func TestInteraction_Start_TextInputSetup(t *testing.T) {
|
||||
mockChannel.On("Write", mock.Anything).Return(0, nil).Maybe()
|
||||
mockInteraction.SetChannel(mockChannel)
|
||||
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
defer close(done)
|
||||
mockInteraction.Start()
|
||||
}()
|
||||
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
|
||||
// Start must finish before Stop: bubbletea's Program is not safe against a
|
||||
// Kill during Run's initialisation.
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(2 * time.Second):
|
||||
}
|
||||
|
||||
i := mockInteraction.(*interaction)
|
||||
i.Stop()
|
||||
|
||||
@@ -2159,9 +2205,9 @@ func TestInteraction_Start_CleanupOnExit(t *testing.T) {
|
||||
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
|
||||
i := mockInteraction.(*interaction)
|
||||
i.Stop()
|
||||
|
||||
// Start must finish before Stop: bubbletea's Program is not safe
|
||||
// against a Kill during Run's initialisation, and production never
|
||||
// stops an interaction from another goroutine.
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(2 * time.Second):
|
||||
@@ -2217,12 +2263,23 @@ func TestInteraction_Start_WithDifferentChannels(t *testing.T) {
|
||||
mockInteraction.SetChannel(mockChannel)
|
||||
}
|
||||
|
||||
// Production never stops an interaction from another goroutine:
|
||||
// the program exits when its channel closes and Start tears the
|
||||
// program down itself. bubbletea's Program is not safe against a
|
||||
// Kill during Run's initialisation, so let Start finish first.
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
defer close(done)
|
||||
mockInteraction.Start()
|
||||
}()
|
||||
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(2 * time.Second):
|
||||
}
|
||||
|
||||
i := mockInteraction.(*interaction)
|
||||
i.Stop()
|
||||
|
||||
@@ -2281,7 +2338,9 @@ func TestInteraction_Stop_MultipleCallsSafe(t *testing.T) {
|
||||
i.Stop()
|
||||
})
|
||||
|
||||
i.programMu.Lock()
|
||||
assert.Nil(t, i.program)
|
||||
i.programMu.Unlock()
|
||||
}
|
||||
|
||||
func TestInteraction_Start_HeadlessMode_NoOp(t *testing.T) {
|
||||
@@ -2309,7 +2368,9 @@ func TestInteraction_Start_HeadlessMode_NoOp(t *testing.T) {
|
||||
}
|
||||
|
||||
i := mockInteraction.(*interaction)
|
||||
i.programMu.Lock()
|
||||
assert.Nil(t, i.program, "program should not be created in headless mode")
|
||||
i.programMu.Unlock()
|
||||
|
||||
mockConfig.AssertNotCalled(t, "Domain")
|
||||
mockConfig.AssertNotCalled(t, "TLSEnabled")
|
||||
|
||||
@@ -84,13 +84,14 @@ func (hh *httpHandler) Handler(conn net.Conn, isTLS bool) {
|
||||
_ = conn.SetReadDeadline(time.Now().Add(10 * time.Second))
|
||||
br := bufio.NewReaderSize(conn, hh.config.HeaderSize())
|
||||
headerBuf, err := readHTTPHeader(br, hh.config.HeaderSize())
|
||||
// Clear it before writing anything: badRequest/redirect/forward must not
|
||||
// inherit an expired deadline.
|
||||
_ = conn.SetReadDeadline(time.Time{})
|
||||
if err != nil {
|
||||
_ = hh.badRequest(conn)
|
||||
return
|
||||
}
|
||||
|
||||
_ = conn.SetReadDeadline(time.Time{})
|
||||
|
||||
reqhf, err := header.NewRequest(headerBuf)
|
||||
if err != nil {
|
||||
log.Printf("Error creating request header: %v", err)
|
||||
@@ -122,7 +123,7 @@ func (hh *httpHandler) Handler(conn net.Conn, isTLS bool) {
|
||||
return
|
||||
}
|
||||
|
||||
hw := stream.New(conn, br, conn.RemoteAddr())
|
||||
hw := stream.New(conn, br, conn.RemoteAddr(), hh.config.HeaderSize())
|
||||
defer func(hw stream.HTTP) {
|
||||
err = hw.Close()
|
||||
if err != nil {
|
||||
@@ -140,6 +141,12 @@ func (hh *httpHandler) closeConnection(conn net.Conn) {
|
||||
}
|
||||
|
||||
func (hh *httpHandler) extractSlug(reqhf header.RequestHeader) (string, error) {
|
||||
// One Host field only (RFC 7230 5.4): different proxies may route a
|
||||
// repeated header to different tunnels than the one we picked.
|
||||
if reqhf.Count("Host") != 1 {
|
||||
return "", errors.New("missing or repeated host")
|
||||
}
|
||||
|
||||
host := strings.Split(reqhf.Value("Host"), ".")
|
||||
if len(host) <= 1 {
|
||||
return "", errors.New("invalid host")
|
||||
|
||||
@@ -656,6 +656,8 @@ func TestHandler(t *testing.T) {
|
||||
responseChan := make(chan []byte, 1)
|
||||
doneChan := make(chan struct{})
|
||||
|
||||
var wg sync.WaitGroup
|
||||
|
||||
if clientConn != nil {
|
||||
go func() {
|
||||
defer close(doneChan)
|
||||
@@ -677,10 +679,13 @@ func TestHandler(t *testing.T) {
|
||||
responseChan <- res
|
||||
}()
|
||||
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
_, err := clientConn.Write(tt.request)
|
||||
if err != nil {
|
||||
t.Logf("Error writing request: %v", err)
|
||||
defer wg.Done()
|
||||
// No t.Logf here: the subtest can finish first and the
|
||||
// logger is not safe to touch after that.
|
||||
if _, err := clientConn.Write(tt.request); err != nil {
|
||||
_ = err
|
||||
}
|
||||
}()
|
||||
} else {
|
||||
@@ -688,7 +693,6 @@ func TestHandler(t *testing.T) {
|
||||
close(doneChan)
|
||||
}
|
||||
|
||||
var wg sync.WaitGroup
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
@@ -860,3 +864,60 @@ func TestRedirectStatusLine(t *testing.T) {
|
||||
// while it was free, and the reason text must name the status sent.
|
||||
assert.True(t, strings.HasPrefix(string(buf[:n]), "HTTP/1.1 302 Found\r\n"))
|
||||
}
|
||||
|
||||
// The 10s read deadline is ours until the request is parsed. If it is still
|
||||
// installed when the app is streamed to, an app that answers after 10s (or
|
||||
// sends its body slowly) dies, and SetReadDeadline on an ssh.Channel does not
|
||||
// return an error while failing. Clear it as soon as the request is in, and
|
||||
// prove that a cleared deadline really accepts an expired time.
|
||||
func TestHandlerClearsHeaderDeadlineAfterRequest(t *testing.T) {
|
||||
msr := new(MockSessionRegistry)
|
||||
mc := &MockConfig{}
|
||||
mc.On("Domain").Return("example.com")
|
||||
mc.On("FrontendURL").Return("https://example.com")
|
||||
mc.On("TLSRedirect").Return(false)
|
||||
mc.On("HeaderSize").Return(4096)
|
||||
hh := &httpHandler{sessionRegistry: msr, config: mc}
|
||||
|
||||
mockSession := new(MockSession)
|
||||
mockForwarder := new(MockForwarder)
|
||||
mockSSHChannel := new(MockSSHChannel)
|
||||
msr.On("Get", types.SessionKey{Id: "test", Type: types.TunnelTypeHTTP}).Return(mockSession, nil)
|
||||
mockSession.On("Forwarder").Return(mockForwarder)
|
||||
|
||||
reqCh := make(chan *ssh.Request)
|
||||
mockForwarder.On("OpenForwardedChannel", mock.Anything, mock.Anything).Return(mockSSHChannel, (<-chan *ssh.Request)(reqCh), nil)
|
||||
|
||||
var mu sync.Mutex
|
||||
var headers []byte
|
||||
mockSSHChannel.On("Write", mock.Anything).Run(func(a mock.Arguments) {
|
||||
mu.Lock()
|
||||
headers = append(headers, a.Get(0).([]byte)...)
|
||||
mu.Unlock()
|
||||
}).Return(0, nil)
|
||||
mockSSHChannel.On("Close").Return(nil)
|
||||
|
||||
mockForwarder.On("HandleConnection", mock.Anything, mockSSHChannel).Run(func(a mock.Arguments) {
|
||||
w := a.Get(0).(io.ReadWriter)
|
||||
_, _ = w.Write([]byte("HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok"))
|
||||
})
|
||||
|
||||
serverConn, clientConn := net.Pipe()
|
||||
defer clientConn.Close()
|
||||
addr, _ := net.ResolveTCPAddr("tcp", "127.0.0.1:12345")
|
||||
|
||||
go hh.Handler(&wrappedConn{Conn: serverConn, remoteAddr: addr}, true)
|
||||
go func() { _, _ = io.WriteString(clientConn, "GET / HTTP/1.1\r\nHost: test.domain\r\n\r\n") }()
|
||||
|
||||
buf := make([]byte, 64)
|
||||
_ = clientConn.SetReadDeadline(time.Now().Add(3 * time.Second))
|
||||
n, _ := clientConn.Read(buf)
|
||||
|
||||
assert.Contains(t, string(buf[:n]), "200 OK")
|
||||
for _, call := range mockSSHChannel.ExpectedCalls {
|
||||
assert.NotEqual(t, "SetReadDeadline", call.Method,
|
||||
"the app channel must not inherit the visitor's read deadline")
|
||||
}
|
||||
// The app channel is closed by forwardRequest, not here; what matters is
|
||||
// that nothing above ever set a deadline on it.
|
||||
}
|
||||
|
||||
@@ -0,0 +1,109 @@
|
||||
package transport
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"io"
|
||||
"net"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/stretchr/testify/mock"
|
||||
"golang.org/x/crypto/ssh"
|
||||
|
||||
"tunnel_pls/internal/types"
|
||||
)
|
||||
|
||||
// forwardThrough drives Handler for slug "test" with rawRequest and returns
|
||||
// what was written toward the tunneled app and what the visitor received.
|
||||
func forwardThrough(t *testing.T, rawRequest, backendReply string) (toApp, toVisitor []byte) {
|
||||
t.Helper()
|
||||
|
||||
sessionRegistry := new(MockSessionRegistry)
|
||||
cfg := &MockConfig{}
|
||||
cfg.On("Domain").Return("example.com")
|
||||
cfg.On("FrontendURL").Return("https://example.com")
|
||||
cfg.On("TLSRedirect").Return(false)
|
||||
cfg.On("HeaderSize").Return(4096)
|
||||
|
||||
hh := &httpHandler{sessionRegistry: sessionRegistry, config: cfg}
|
||||
mockSession := new(MockSession)
|
||||
mockForwarder := new(MockForwarder)
|
||||
mockSSHChannel := new(MockSSHChannel)
|
||||
|
||||
sessionRegistry.On("Get", types.SessionKey{Id: "test", Type: types.TunnelTypeHTTP}).Return(mockSession, nil)
|
||||
mockSession.On("Forwarder").Return(mockForwarder)
|
||||
|
||||
reqCh := make(chan *ssh.Request)
|
||||
mockForwarder.On("OpenForwardedChannel", mock.Anything, mock.Anything).Return(mockSSHChannel, (<-chan *ssh.Request)(reqCh), nil)
|
||||
|
||||
var mu sync.Mutex
|
||||
mockSSHChannel.On("Write", mock.Anything).Run(func(args mock.Arguments) {
|
||||
mu.Lock()
|
||||
toApp = append(toApp, args.Get(0).([]byte)...)
|
||||
mu.Unlock()
|
||||
}).Return(0, nil)
|
||||
mockSSHChannel.On("Close").Return(nil)
|
||||
|
||||
mockForwarder.On("HandleConnection", mock.Anything, mockSSHChannel).Run(func(args mock.Arguments) {
|
||||
w := args.Get(0).(io.ReadWriter)
|
||||
_, _ = w.Write([]byte(backendReply))
|
||||
})
|
||||
|
||||
serverConn, clientConn := net.Pipe()
|
||||
defer clientConn.Close()
|
||||
addr, _ := net.ResolveTCPAddr("tcp", "127.0.0.1:12345")
|
||||
|
||||
go hh.Handler(&wrappedConn{Conn: serverConn, remoteAddr: addr}, true)
|
||||
go func() { _, _ = io.WriteString(clientConn, rawRequest) }()
|
||||
|
||||
_ = clientConn.SetReadDeadline(time.Now().Add(2 * time.Second))
|
||||
buf := make([]byte, 4096)
|
||||
n, _ := clientConn.Read(buf)
|
||||
|
||||
return toApp, bytes.Clone(buf[:n])
|
||||
}
|
||||
|
||||
// A visitor can spell a header any way it likes. RFC 7230 3.2 says field names
|
||||
// are case-insensitive, so a forged lowercase one must not survive next to the
|
||||
// address the tunnel sets itself.
|
||||
func TestForwardsLowercaseForgedForwardedFor(t *testing.T) {
|
||||
toApp, _ := forwardThrough(t,
|
||||
"GET / HTTP/1.1\r\nHost: test.domain\r\nx-forwarded-for: 6.6.6.6\r\n\r\n",
|
||||
"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok",
|
||||
)
|
||||
|
||||
got := string(toApp)
|
||||
if strings.Contains(got, "6.6.6.6") {
|
||||
t.Fatalf("forged client address survived: %q", got)
|
||||
}
|
||||
if strings.Count(strings.ToLower(got), "x-forwarded-for: 127.0.0.1") != 1 {
|
||||
t.Fatalf("want exactly one X-Forwarded-For: 127.0.0.1, got %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestForwardsLowercaseHost(t *testing.T) {
|
||||
toApp, _ := forwardThrough(t,
|
||||
"GET / HTTP/1.1\r\nhost: test.domain\r\n\r\n",
|
||||
"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok",
|
||||
)
|
||||
|
||||
got := strings.ToLower(string(toApp))
|
||||
if strings.Count(got, "host: test.domain") != 1 {
|
||||
t.Fatalf("want exactly one host header, got %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
// Two cookies come back as two Set-Cookie lines; they must not be merged.
|
||||
func TestForwardsRepeatedSetCookie(t *testing.T) {
|
||||
_, toVisitor := forwardThrough(t,
|
||||
"GET / HTTP/1.1\r\nHost: test.domain\r\n\r\n",
|
||||
"HTTP/1.1 200 OK\r\nSet-Cookie: a=1\r\nSet-Cookie: b=2\r\n\r\nok",
|
||||
)
|
||||
|
||||
got := string(toVisitor)
|
||||
if !strings.Contains(got, "Set-Cookie: a=1\r\nSet-Cookie: b=2\r\n") {
|
||||
t.Fatalf("repeated Set-Cookie lost or reordered: %q", got)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user