mirror of
https://github.com/hanzoai/porto.git
synced 2026-11-03 18:08:27 +00:00
354 lines
12 KiB
Go
354 lines
12 KiB
Go
package gserver_test
|
|
|
|
import (
|
|
"context"
|
|
"crypto/tls"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/cockroachdb/errors"
|
|
"github.com/effective-security/porto/gserver"
|
|
"github.com/effective-security/porto/pkg/discovery"
|
|
"github.com/effective-security/porto/pkg/tlsconfig"
|
|
"github.com/effective-security/porto/tests/mockappcontainer"
|
|
"github.com/effective-security/porto/xhttp/header"
|
|
"github.com/effective-security/porto/xhttp/limits"
|
|
"github.com/effective-security/porto/xhttp/marshal"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/credentials"
|
|
"google.golang.org/grpc/status"
|
|
"google.golang.org/protobuf/types/known/wrapperspb"
|
|
)
|
|
|
|
// uploadMethod is a client-streaming RPC that returns the number of bytes
|
|
// received; it is registered from a hand-written ServiceDesc.
|
|
const uploadMethod = "/porto.test.Upload/Upload"
|
|
|
|
var uploadServices = map[string]gserver.ServiceFactory{
|
|
"upload": func(server gserver.GServer) any {
|
|
return func() {
|
|
server.AddService(uploadService{})
|
|
}
|
|
},
|
|
}
|
|
|
|
type uploadService struct{}
|
|
|
|
func (uploadService) Name() string { return "upload" }
|
|
func (uploadService) IsReady() bool { return true }
|
|
func (uploadService) Close() {}
|
|
|
|
func (uploadService) RegisterGRPC(s *grpc.Server) {
|
|
s.RegisterService(&grpc.ServiceDesc{
|
|
ServiceName: "porto.test.Upload",
|
|
HandlerType: (*any)(nil),
|
|
Streams: []grpc.StreamDesc{
|
|
{
|
|
StreamName: "Upload",
|
|
ClientStreams: true,
|
|
Handler: func(_ any, stream grpc.ServerStream) error {
|
|
var total int64
|
|
for {
|
|
msg := &wrapperspb.BytesValue{}
|
|
err := stream.RecvMsg(msg)
|
|
if errors.Is(err, io.EOF) {
|
|
return stream.SendMsg(wrapperspb.Int64(total))
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
total += int64(len(msg.GetValue()))
|
|
}
|
|
},
|
|
},
|
|
},
|
|
}, uploadService{})
|
|
}
|
|
|
|
// upload sends chunks of size bytes, pausing between them, and returns the
|
|
// byte count reported by the server.
|
|
func upload(ctx context.Context, conn *grpc.ClientConn, chunks, size int, pause time.Duration) (int64, error) {
|
|
stream, err := conn.NewStream(ctx, &grpc.StreamDesc{ClientStreams: true}, uploadMethod)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
for range chunks {
|
|
// A failed send returns io.EOF; RecvMsg reports the status.
|
|
if stream.SendMsg(wrapperspb.Bytes(make([]byte, size))) != nil {
|
|
break
|
|
}
|
|
time.Sleep(pause)
|
|
}
|
|
if err = stream.CloseSend(); err != nil {
|
|
return 0, err
|
|
}
|
|
total := &wrapperspb.Int64Value{}
|
|
if err = stream.RecvMsg(total); err != nil {
|
|
return 0, err
|
|
}
|
|
return total.GetValue(), nil
|
|
}
|
|
|
|
func TestTLSGRPCStreamLimits(t *testing.T) {
|
|
t.Parallel()
|
|
const readTimeout = 200 * time.Millisecond
|
|
cfg := &gserver.Config{
|
|
ListenURLs: []string{"https://127.0.0.1:0"},
|
|
Services: []string{"upload"},
|
|
ServerTLS: &gserver.TLSInfo{
|
|
CertFile: "testdata/test-server.pem",
|
|
KeyFile: "testdata/test-server-key.pem",
|
|
TrustedCAFile: "testdata/test-server-rootca.pem",
|
|
},
|
|
Timeouts: limits.Timeouts{
|
|
Read: readTimeout,
|
|
},
|
|
MaxRequestBody: 64 * 1024,
|
|
}
|
|
container := mockappcontainer.NewBuilder().WithDiscovery(discovery.New()).Container()
|
|
srv, err := gserver.Start("grpc-limits", cfg, container, uploadServices)
|
|
require.NoError(t, err)
|
|
defer srv.Close()
|
|
addr := srv.(*gserver.Server).Listeners[0].Addr().String()
|
|
|
|
clientTLS, err := tlsconfig.NewClientTLSFromFiles("", "", cfg.ServerTLS.TrustedCAFile)
|
|
require.NoError(t, err)
|
|
// Legacy test fixture has no SANs; only test the server transport here.
|
|
clientTLS.InsecureSkipVerify = true
|
|
conn, err := grpc.NewClient(addr, grpc.WithTransportCredentials(credentials.NewTLS(clientTLS)))
|
|
require.NoError(t, err)
|
|
defer conn.Close()
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
|
|
// A client stream may outlive Timeouts.Read, as on plaintext listeners.
|
|
total, err := upload(ctx, conn, 4, 16, readTimeout/2)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, int64(64), total)
|
|
|
|
// The stream stays bounded by MaxRequestBody in total.
|
|
_, err = upload(ctx, conn, 8, 16*1024, 0)
|
|
require.Error(t, err)
|
|
// grpc-go reports a failed body read as Unavailable.
|
|
assert.Equal(t, codes.Unavailable, status.Code(err))
|
|
assert.Contains(t, status.Convert(err).Message(), "request body too large")
|
|
}
|
|
|
|
func TestBodyLimitInsideHandlerChain(t *testing.T) {
|
|
t.Parallel()
|
|
enabled := true
|
|
cfg := &gserver.Config{
|
|
ListenURLs: []string{"http://127.0.0.1:0"},
|
|
MaxRequestBody: 6,
|
|
CORS: &gserver.CORS{
|
|
Enabled: &enabled,
|
|
AllowedOrigins: []string{"*"},
|
|
},
|
|
}
|
|
container := mockappcontainer.NewBuilder().WithDiscovery(discovery.New()).Container()
|
|
srv, err := gserver.Start("limits-chain", cfg, container, nil, gserver.WithMiddleware(func(_ http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
var body any
|
|
if marshal.DecodeBody(w, r, &body) != nil {
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusNoContent)
|
|
})
|
|
}))
|
|
require.NoError(t, err)
|
|
defer srv.Close()
|
|
addr := srv.(*gserver.Server).Listeners[0].Addr().String()
|
|
|
|
req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, "http://"+addr, strings.NewReader(`"abcde"`))
|
|
require.NoError(t, err)
|
|
req.Header.Set(header.ContentType, header.ApplicationJSON)
|
|
req.Header.Set("Origin", "https://app.example.com")
|
|
client := &http.Client{Timeout: 2 * time.Second}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
assert.Equal(t, http.StatusRequestEntityTooLarge, resp.StatusCode)
|
|
// The browser can read the 413, and the response is correlated.
|
|
assert.Equal(t, "*", resp.Header.Get("Access-Control-Allow-Origin"))
|
|
assert.NotEmpty(t, resp.Header.Get(header.XCorrelationID))
|
|
}
|
|
|
|
func TestNetworkLimits(t *testing.T) {
|
|
t.Parallel()
|
|
for _, secure := range []bool{false, true} {
|
|
scheme := "http"
|
|
if secure {
|
|
scheme = "https"
|
|
}
|
|
t.Run(scheme, func(t *testing.T) {
|
|
t.Parallel()
|
|
cfg := &gserver.Config{
|
|
ListenURLs: []string{scheme + "://127.0.0.1:0"},
|
|
Services: []string{"upload"},
|
|
Timeouts: limits.Timeouts{
|
|
Handshake: 100 * time.Millisecond,
|
|
Header: 150 * time.Millisecond,
|
|
Read: 250 * time.Millisecond,
|
|
Idle: 100 * time.Millisecond,
|
|
},
|
|
MaxRequestBody: 6,
|
|
}
|
|
var clientTLS *tls.Config
|
|
if secure {
|
|
cfg.ServerTLS = &gserver.TLSInfo{
|
|
CertFile: "testdata/test-server.pem",
|
|
KeyFile: "testdata/test-server-key.pem",
|
|
TrustedCAFile: "testdata/test-server-rootca.pem",
|
|
}
|
|
var err error
|
|
clientTLS, err = tlsconfig.NewClientTLSFromFiles("", "", cfg.ServerTLS.TrustedCAFile)
|
|
require.NoError(t, err)
|
|
// Legacy test fixture has no SANs; only test the server transport here.
|
|
clientTLS.InsecureSkipVerify = true
|
|
clientTLS.NextProtos = []string{"http/1.1"}
|
|
}
|
|
container := mockappcontainer.NewBuilder().WithDiscovery(discovery.New()).Container()
|
|
srv, err := gserver.Start("limits", cfg, container, uploadServices, gserver.WithMiddleware(func(_ http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
var body any
|
|
if marshal.DecodeBody(w, r, &body) != nil {
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusNoContent)
|
|
})
|
|
}))
|
|
require.NoError(t, err)
|
|
defer srv.Close()
|
|
addr := srv.(*gserver.Server).Listeners[0].Addr().String()
|
|
// No bytes leaves the connection in cmux or the eager TLS handshake.
|
|
conn, err := net.DialTimeout("tcp", addr, time.Second)
|
|
require.NoError(t, err)
|
|
require.NoError(t, conn.SetReadDeadline(time.Now().Add(2*time.Second)))
|
|
_, err = io.ReadAll(conn)
|
|
require.NoError(t, err, "server must close before the client deadline")
|
|
require.NoError(t, conn.Close())
|
|
|
|
dial := func() net.Conn {
|
|
var conn net.Conn
|
|
var err error
|
|
if secure {
|
|
conn, err = tls.DialWithDialer(&net.Dialer{Timeout: 2 * time.Second}, "tcp", addr, clientTLS)
|
|
} else {
|
|
conn, err = net.DialTimeout("tcp", addr, time.Second)
|
|
}
|
|
require.NoError(t, err)
|
|
require.NoError(t, conn.SetDeadline(time.Now().Add(2*time.Second)))
|
|
return conn
|
|
}
|
|
for _, request := range []string{
|
|
"GET / HTTP/1.1\r\nHost: localhost\r\nX-Slow: ",
|
|
"POST / HTTP/1.1\r\nHost: localhost\r\nContent-Length: 6\r\n\r\n\"a",
|
|
} {
|
|
conn := dial()
|
|
_, err := io.WriteString(conn, request)
|
|
require.NoError(t, err)
|
|
_, err = io.ReadAll(conn)
|
|
require.NoError(t, err, "server must close stalled request before client deadline")
|
|
require.NoError(t, conn.Close())
|
|
}
|
|
if secure {
|
|
h2Transport := &http.Transport{
|
|
TLSClientConfig: clientTLS.Clone(),
|
|
ForceAttemptHTTP2: true,
|
|
}
|
|
defer h2Transport.CloseIdleConnections()
|
|
h2Client := &http.Client{Timeout: 2 * time.Second, Transport: h2Transport}
|
|
// Unknown length must reach the body reader, not the Content-Length check.
|
|
req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, scheme+"://"+addr, strings.NewReader(`"abcde"`))
|
|
require.NoError(t, err)
|
|
req.ContentLength = -1
|
|
resp, err := h2Client.Do(req)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 2, resp.ProtoMajor)
|
|
assert.Equal(t, http.StatusRequestEntityTooLarge, resp.StatusCode)
|
|
require.NoError(t, resp.Body.Close())
|
|
|
|
// Keep a request body open; the server read deadline must produce
|
|
// a response before the client's two-second request timeout.
|
|
reader, writer := io.Pipe()
|
|
defer reader.Close()
|
|
defer writer.Close()
|
|
req, err = http.NewRequestWithContext(context.Background(), http.MethodPost, scheme+"://"+addr, reader)
|
|
require.NoError(t, err)
|
|
req.ContentLength = 6
|
|
written := make(chan error, 1)
|
|
go func() {
|
|
_, err := io.WriteString(writer, `"a`)
|
|
written <- err
|
|
}()
|
|
resp, err = h2Client.Do(req)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 2, resp.ProtoMajor)
|
|
assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
|
|
require.NoError(t, resp.Body.Close())
|
|
require.NoError(t, <-written)
|
|
|
|
// A known oversized body fails inside the handler chain: JSON
|
|
// handlers answer 413 with a correlation ID, and gRPC callers
|
|
// get a gRPC response instead of JSON.
|
|
for _, tc := range []struct {
|
|
contentType string
|
|
path string
|
|
status int
|
|
}{
|
|
{
|
|
contentType: header.ApplicationJSON,
|
|
path: "/",
|
|
status: http.StatusRequestEntityTooLarge,
|
|
},
|
|
{
|
|
contentType: header.ApplicationGRPC,
|
|
path: uploadMethod,
|
|
status: http.StatusOK,
|
|
},
|
|
{
|
|
contentType: header.ApplicationGRPCWebProto,
|
|
path: uploadMethod,
|
|
status: http.StatusOK,
|
|
},
|
|
} {
|
|
req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, scheme+"://"+addr+tc.path, strings.NewReader(`"abcde"`))
|
|
require.NoError(t, err)
|
|
req.Header.Set(header.ContentType, tc.contentType)
|
|
resp, err := h2Client.Do(req)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 2, resp.ProtoMajor)
|
|
assert.Equal(t, tc.status, resp.StatusCode, tc.contentType)
|
|
if tc.status == http.StatusRequestEntityTooLarge {
|
|
assert.NotEmpty(t, resp.Header.Get(header.XCorrelationID))
|
|
} else {
|
|
assert.True(t, strings.HasPrefix(resp.Header.Get(header.ContentType), header.ApplicationGRPC), tc.contentType)
|
|
}
|
|
require.NoError(t, resp.Body.Close())
|
|
}
|
|
}
|
|
transport := &http.Transport{TLSClientConfig: clientTLS}
|
|
defer transport.CloseIdleConnections()
|
|
client := &http.Client{Timeout: 2 * time.Second, Transport: transport}
|
|
for _, chunked := range []bool{false, true} {
|
|
req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, scheme+"://"+addr, strings.NewReader(`"abcde"`))
|
|
require.NoError(t, err)
|
|
if chunked {
|
|
req.ContentLength = -1
|
|
}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, http.StatusRequestEntityTooLarge, resp.StatusCode)
|
|
require.NoError(t, resp.Body.Close())
|
|
}
|
|
})
|
|
}
|
|
}
|