mirror of
https://github.com/vmware-tanzu/pinniped.git
synced 2026-01-03 11:45:45 +00:00
Force the use of secure TLS config
This change updates the TLS config used by all pinniped components. There are no configuration knobs associated with this change. Thus this change tightens our static defaults. There are four TLS config levels: 1. Secure (TLS 1.3 only) 2. Default (TLS 1.2+ best ciphers that are well supported) 3. Default LDAP (TLS 1.2+ with less good ciphers) 4. Legacy (currently unused, TLS 1.2+ with all non-broken ciphers) Highlights per component: 1. pinniped CLI - uses "secure" config against KAS - uses "default" for all other connections 2. concierge - uses "secure" config as an aggregated API server - uses "default" config as a impersonation proxy API server - uses "secure" config against KAS - uses "default" config for JWT authenticater (mostly, see code) - no changes to webhook authenticater (see code) 3. supervisor - uses "default" config as a server - uses "secure" config against KAS - uses "default" config against OIDC IDPs - uses "default LDAP" config against LDAP IDPs Signed-off-by: Monis Khan <mok@vmware.com>
This commit is contained in:
Monis Khan
118
internal/net/phttp/debug.go
Normal file
118
internal/net/phttp/debug.go
Normal file
@@ -0,0 +1,118 @@
|
||||
// Copyright 2021 the Pinniped contributors. All Rights Reserved.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
package phttp
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/url"
|
||||
|
||||
"k8s.io/client-go/transport"
|
||||
|
||||
"go.pinniped.dev/internal/httputil/roundtripper"
|
||||
)
|
||||
|
||||
func safeDebugWrappers(rt http.RoundTripper, f transport.WrapperFunc, shouldLog func() bool) http.RoundTripper {
|
||||
return roundtripper.WrapFunc(rt, func(req *http.Request) (*http.Response, error) {
|
||||
// minor optimization to avoid the cleaning logic when the debug wrappers are unused
|
||||
// note: do not make this entire wrapper conditional on shouldLog() - the output is allowed to change at runtime
|
||||
if !shouldLog() {
|
||||
return rt.RoundTrip(req)
|
||||
}
|
||||
|
||||
var (
|
||||
resp *http.Response
|
||||
err error
|
||||
)
|
||||
debugRT := f(roundtripper.Func(func(_ *http.Request) (*http.Response, error) {
|
||||
// this call needs to be inside this closure so that the debug wrappers can time it
|
||||
// note also that it takes the original (real) request
|
||||
resp, err = rt.RoundTrip(req)
|
||||
|
||||
cleanedResp := cleanResp(resp) // do not leak the user's password during the password grant
|
||||
|
||||
return cleanedResp, err
|
||||
}))
|
||||
|
||||
// run the debug wrappers for their side effects (i.e. logging)
|
||||
// the output is ignored because the input is not the real request
|
||||
cleanedReq := cleanReq(req) // do not leak the user's password during the password grant
|
||||
_, _ = debugRT.RoundTrip(cleanedReq)
|
||||
|
||||
return resp, err
|
||||
})
|
||||
}
|
||||
|
||||
func cleanReq(req *http.Request) *http.Request {
|
||||
// only pass back things we know to be safe to log
|
||||
return &http.Request{
|
||||
Method: req.Method,
|
||||
URL: cleanURL(req.URL),
|
||||
Header: cleanHeader(req.Header),
|
||||
}
|
||||
}
|
||||
|
||||
func cleanResp(resp *http.Response) *http.Response {
|
||||
if resp == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
// only pass back things we know to be safe to log
|
||||
return &http.Response{
|
||||
Status: resp.Status,
|
||||
Header: cleanHeader(resp.Header),
|
||||
}
|
||||
}
|
||||
|
||||
func cleanURL(u *url.URL) *url.URL {
|
||||
var user *url.Userinfo
|
||||
if len(u.User.Username()) > 0 {
|
||||
user = url.User("masked_username")
|
||||
}
|
||||
|
||||
var opaque string
|
||||
if len(u.Opaque) > 0 {
|
||||
opaque = "masked_opaque_data"
|
||||
}
|
||||
|
||||
var fragment string
|
||||
if len(u.Fragment) > 0 || len(u.RawFragment) > 0 {
|
||||
fragment = "masked_fragment"
|
||||
}
|
||||
|
||||
// only pass back things we know to be safe to log
|
||||
return &url.URL{
|
||||
Scheme: u.Scheme,
|
||||
Opaque: opaque,
|
||||
User: user,
|
||||
Host: u.Host,
|
||||
Path: u.Path,
|
||||
RawPath: u.RawPath,
|
||||
ForceQuery: u.ForceQuery,
|
||||
RawQuery: cleanQuery(u.Query()),
|
||||
Fragment: fragment,
|
||||
}
|
||||
}
|
||||
|
||||
func cleanQuery(query url.Values) string {
|
||||
if len(query) == 0 {
|
||||
return ""
|
||||
}
|
||||
|
||||
out := url.Values(cleanHeader(http.Header(query))) // cast so we can re-use logic
|
||||
return out.Encode()
|
||||
}
|
||||
|
||||
func cleanHeader(header http.Header) http.Header {
|
||||
if len(header) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
mask := []string{"masked_value"}
|
||||
out := make(http.Header, len(header))
|
||||
for key := range header {
|
||||
out[key] = mask // only copy the keys
|
||||
}
|
||||
|
||||
return out
|
||||
}
|
||||
340
internal/net/phttp/debug_test.go
Normal file
340
internal/net/phttp/debug_test.go
Normal file
@@ -0,0 +1,340 @@
|
||||
// Copyright 2021 the Pinniped contributors. All Rights Reserved.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
package phttp
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/require"
|
||||
|
||||
"go.pinniped.dev/internal/constable"
|
||||
"go.pinniped.dev/internal/httputil/roundtripper"
|
||||
)
|
||||
|
||||
func Test_safeDebugWrappers_shouldLog(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
var rtFuncCalled, wrapFuncCalled, innerRTCalled int
|
||||
var shouldLog, skipInnerRT bool
|
||||
|
||||
shouldLogFunc := func() bool { return shouldLog }
|
||||
|
||||
rtFunc := roundtripper.Func(func(_ *http.Request) (*http.Response, error) {
|
||||
rtFuncCalled++
|
||||
return nil, nil
|
||||
})
|
||||
|
||||
wrapFunc := func(rt http.RoundTripper) http.RoundTripper {
|
||||
wrapFuncCalled++
|
||||
return roundtripper.Func(func(r *http.Request) (*http.Response, error) {
|
||||
innerRTCalled++
|
||||
if skipInnerRT {
|
||||
return nil, nil
|
||||
}
|
||||
return rt.RoundTrip(r)
|
||||
})
|
||||
}
|
||||
|
||||
r := testReq(t, nil, nil)
|
||||
|
||||
out := safeDebugWrappers(rtFunc, wrapFunc, shouldLogFunc)
|
||||
|
||||
// assert that shouldLogFunc is dynamically honored
|
||||
|
||||
_, _ = out.RoundTrip(r) //nolint:bodyclose
|
||||
|
||||
require.Equal(t, 1, rtFuncCalled)
|
||||
require.Equal(t, 0, wrapFuncCalled)
|
||||
require.Equal(t, 0, innerRTCalled)
|
||||
|
||||
shouldLog = true
|
||||
|
||||
_, _ = out.RoundTrip(r) //nolint:bodyclose
|
||||
|
||||
require.Equal(t, 2, rtFuncCalled)
|
||||
require.Equal(t, 1, wrapFuncCalled)
|
||||
require.Equal(t, 1, innerRTCalled)
|
||||
|
||||
shouldLog = false
|
||||
|
||||
_, _ = out.RoundTrip(r) //nolint:bodyclose
|
||||
|
||||
require.Equal(t, 3, rtFuncCalled)
|
||||
require.Equal(t, 1, wrapFuncCalled)
|
||||
require.Equal(t, 1, innerRTCalled)
|
||||
|
||||
shouldLog = true
|
||||
|
||||
_, _ = out.RoundTrip(r) //nolint:bodyclose
|
||||
|
||||
require.Equal(t, 4, rtFuncCalled)
|
||||
require.Equal(t, 2, wrapFuncCalled)
|
||||
require.Equal(t, 2, innerRTCalled)
|
||||
|
||||
// assert that wrapFunc controls rtFunc being called
|
||||
|
||||
skipInnerRT = true
|
||||
|
||||
_, _ = out.RoundTrip(r) //nolint:bodyclose
|
||||
|
||||
require.Equal(t, 4, rtFuncCalled)
|
||||
require.Equal(t, 3, wrapFuncCalled)
|
||||
require.Equal(t, 3, innerRTCalled)
|
||||
|
||||
skipInnerRT = false
|
||||
|
||||
_, _ = out.RoundTrip(r) //nolint:bodyclose
|
||||
|
||||
require.Equal(t, 5, rtFuncCalled)
|
||||
require.Equal(t, 4, wrapFuncCalled)
|
||||
require.Equal(t, 4, innerRTCalled)
|
||||
}
|
||||
|
||||
func Test_safeDebugWrappers_clean(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
shouldLog bool
|
||||
inReq, wantReq *http.Request
|
||||
inResp, wantResp *http.Response
|
||||
inErr error
|
||||
}{
|
||||
{
|
||||
name: "header cleaned",
|
||||
shouldLog: true,
|
||||
inReq: testReq(t, http.Header{"hello": {"from", "earth"}}, nil),
|
||||
wantReq: testCleanReq(http.Header{"hello": {"masked_value"}}, nil),
|
||||
inResp: testResp(t, http.Header{"bye": {"for", "now"}}), //nolint:bodyclose
|
||||
wantResp: testCleanResp(http.Header{"bye": {"masked_value"}}), //nolint:bodyclose
|
||||
inErr: nil,
|
||||
},
|
||||
{
|
||||
name: "header cleaned error",
|
||||
shouldLog: true,
|
||||
inReq: testReq(t, http.Header{"see": {"from", "mars"}}, nil),
|
||||
wantReq: testCleanReq(http.Header{"see": {"masked_value"}}, nil),
|
||||
inResp: testResp(t, http.Header{"bear": {"is", "a"}}), //nolint:bodyclose
|
||||
wantResp: testCleanResp(http.Header{"bear": {"masked_value"}}), //nolint:bodyclose
|
||||
inErr: constable.Error("some error"),
|
||||
},
|
||||
{
|
||||
name: "header cleaned error nil resp",
|
||||
shouldLog: true,
|
||||
inReq: testReq(t, http.Header{"see": {"from", "mars"}}, nil),
|
||||
wantReq: testCleanReq(http.Header{"see": {"masked_value"}}, nil),
|
||||
inResp: nil,
|
||||
wantResp: nil,
|
||||
inErr: constable.Error("some other error"),
|
||||
},
|
||||
{
|
||||
name: "header cleaned no log",
|
||||
shouldLog: false,
|
||||
inReq: testReq(t, http.Header{"sky": {"is", "blue"}}, nil),
|
||||
wantReq: nil,
|
||||
inResp: testResp(t, http.Header{"night": {"is", "dark"}}), //nolint:bodyclose
|
||||
wantResp: nil,
|
||||
inErr: nil,
|
||||
},
|
||||
{
|
||||
name: "url cleaned, all fields",
|
||||
shouldLog: true,
|
||||
inReq: testReq(t, nil, &url.URL{
|
||||
Scheme: "sc",
|
||||
Opaque: "op",
|
||||
User: url.UserPassword("us", "pa"),
|
||||
Host: "ho",
|
||||
Path: "pa",
|
||||
RawPath: "rap",
|
||||
ForceQuery: true,
|
||||
RawQuery: "key1=val1&key2=val2",
|
||||
Fragment: "fra",
|
||||
RawFragment: "rawf",
|
||||
}),
|
||||
wantReq: testCleanReq(nil, &url.URL{
|
||||
Scheme: "sc",
|
||||
Opaque: "masked_opaque_data",
|
||||
User: url.User("masked_username"),
|
||||
Host: "ho",
|
||||
Path: "pa",
|
||||
RawPath: "rap",
|
||||
ForceQuery: true,
|
||||
RawQuery: "key1=masked_value&key2=masked_value",
|
||||
Fragment: "masked_fragment",
|
||||
RawFragment: "",
|
||||
}),
|
||||
inResp: testResp(t, http.Header{"sun": {"yellow"}}), //nolint:bodyclose
|
||||
wantResp: testCleanResp(http.Header{"sun": {"masked_value"}}), //nolint:bodyclose
|
||||
inErr: nil,
|
||||
},
|
||||
{
|
||||
name: "url cleaned, some fields",
|
||||
shouldLog: true,
|
||||
inReq: testReq(t, nil, &url.URL{
|
||||
Scheme: "sc",
|
||||
Opaque: "",
|
||||
User: nil,
|
||||
Host: "ho",
|
||||
Path: "pa",
|
||||
RawPath: "rap",
|
||||
ForceQuery: false,
|
||||
RawQuery: "key3=val3&key4=val4",
|
||||
Fragment: "",
|
||||
RawFragment: "",
|
||||
}),
|
||||
wantReq: testCleanReq(nil, &url.URL{
|
||||
Scheme: "sc",
|
||||
Opaque: "",
|
||||
User: nil,
|
||||
Host: "ho",
|
||||
Path: "pa",
|
||||
RawPath: "rap",
|
||||
ForceQuery: false,
|
||||
RawQuery: "key3=masked_value&key4=masked_value",
|
||||
Fragment: "",
|
||||
RawFragment: "",
|
||||
}),
|
||||
inResp: testResp(t, http.Header{"sun": {"yellow"}}), //nolint:bodyclose
|
||||
wantResp: testCleanResp(http.Header{"sun": {"masked_value"}}), //nolint:bodyclose
|
||||
inErr: nil,
|
||||
},
|
||||
{
|
||||
name: "header and url cleaned, all fields with error",
|
||||
shouldLog: true,
|
||||
inReq: testReq(t, http.Header{"zone": {"of", "the", "enders"}, "welcome": {"home"}}, &url.URL{
|
||||
Scheme: "sc2",
|
||||
Opaque: "op2",
|
||||
User: url.UserPassword("us2", "pa2"),
|
||||
Host: "ho2",
|
||||
Path: "pa2",
|
||||
RawPath: "rap2",
|
||||
ForceQuery: true,
|
||||
RawQuery: "a=b&c=d&e=f&a=1&a=2",
|
||||
Fragment: "fra2",
|
||||
RawFragment: "rawf2",
|
||||
}),
|
||||
wantReq: testCleanReq(http.Header{"zone": {"masked_value"}, "welcome": {"masked_value"}}, &url.URL{
|
||||
Scheme: "sc2",
|
||||
Opaque: "masked_opaque_data",
|
||||
User: url.User("masked_username"),
|
||||
Host: "ho2",
|
||||
Path: "pa2",
|
||||
RawPath: "rap2",
|
||||
ForceQuery: true,
|
||||
RawQuery: "a=masked_value&c=masked_value&e=masked_value",
|
||||
Fragment: "masked_fragment",
|
||||
RawFragment: "",
|
||||
}),
|
||||
inResp: testResp(t, http.Header{"moon": {"white"}}), //nolint:bodyclose
|
||||
wantResp: testCleanResp(http.Header{"moon": {"masked_value"}}), //nolint:bodyclose
|
||||
inErr: constable.Error("yay pandas"),
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
tt := tt
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
var rtCalled, wrapCalled, innerCalled bool
|
||||
|
||||
rtFunc := roundtripper.Func(func(r *http.Request) (*http.Response, error) {
|
||||
rtCalled = true
|
||||
require.Equal(t, tt.inReq, r)
|
||||
return tt.inResp, tt.inErr
|
||||
})
|
||||
|
||||
var gotReq *http.Request
|
||||
var gotResp *http.Response
|
||||
var gotErr error
|
||||
|
||||
wrapFunc := func(rt http.RoundTripper) http.RoundTripper {
|
||||
wrapCalled = true
|
||||
return roundtripper.Func(func(r *http.Request) (*http.Response, error) {
|
||||
innerCalled = true
|
||||
|
||||
gotReq = r
|
||||
|
||||
resp, err := rt.RoundTrip(r) //nolint:bodyclose
|
||||
|
||||
gotResp = resp
|
||||
gotErr = err
|
||||
|
||||
return resp, err
|
||||
})
|
||||
}
|
||||
|
||||
out := safeDebugWrappers(rtFunc, wrapFunc, func() bool { return tt.shouldLog })
|
||||
|
||||
resp, err := out.RoundTrip(tt.inReq) //nolint:bodyclose
|
||||
|
||||
require.Equal(t, tt.inResp, resp)
|
||||
require.Equal(t, tt.inErr, err)
|
||||
require.True(t, rtCalled)
|
||||
require.Equal(t, tt.shouldLog, wrapCalled)
|
||||
require.Equal(t, tt.shouldLog, innerCalled)
|
||||
|
||||
require.Equal(t, tt.wantReq, gotReq)
|
||||
require.Equal(t, tt.wantResp, gotResp)
|
||||
require.Equal(t, tt.inErr, gotErr)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func testReq(t *testing.T, header http.Header, u *url.URL) *http.Request {
|
||||
t.Helper()
|
||||
|
||||
r, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "https://overwritten.com", nil)
|
||||
require.NoError(t, err)
|
||||
|
||||
if u == nil {
|
||||
u = &url.URL{}
|
||||
}
|
||||
|
||||
r.URL = u
|
||||
r.Header = header
|
||||
|
||||
// something non-nil for testing
|
||||
r.Body = io.NopCloser(&bytes.Buffer{})
|
||||
r.Form = url.Values{"a": {"b"}}
|
||||
r.PostForm = url.Values{"c": {"d"}}
|
||||
|
||||
return r
|
||||
}
|
||||
|
||||
func testResp(t *testing.T, header http.Header) *http.Response {
|
||||
t.Helper()
|
||||
|
||||
return &http.Response{
|
||||
Status: "pandas are the best",
|
||||
Header: header,
|
||||
|
||||
// something non-nil for testing
|
||||
Body: io.NopCloser(&bytes.Buffer{}),
|
||||
Request: testReq(t, header, nil),
|
||||
}
|
||||
}
|
||||
|
||||
func testCleanReq(header http.Header, u *url.URL) *http.Request {
|
||||
if u == nil {
|
||||
u = &url.URL{}
|
||||
}
|
||||
|
||||
return &http.Request{
|
||||
Method: http.MethodGet,
|
||||
URL: u,
|
||||
Header: header,
|
||||
}
|
||||
}
|
||||
|
||||
func testCleanResp(header http.Header) *http.Response {
|
||||
return &http.Response{
|
||||
Status: "pandas are the best",
|
||||
Header: header,
|
||||
}
|
||||
}
|
||||
48
internal/net/phttp/phttp.go
Normal file
48
internal/net/phttp/phttp.go
Normal file
@@ -0,0 +1,48 @@
|
||||
// Copyright 2021 the Pinniped contributors. All Rights Reserved.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
package phttp
|
||||
|
||||
import (
|
||||
"crypto/x509"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"k8s.io/apimachinery/pkg/util/net"
|
||||
"k8s.io/client-go/rest"
|
||||
"k8s.io/client-go/transport"
|
||||
|
||||
"go.pinniped.dev/internal/crypto/ptls"
|
||||
"go.pinniped.dev/internal/plog"
|
||||
)
|
||||
|
||||
func Default(rootCAs *x509.CertPool) *http.Client {
|
||||
return buildClient(ptls.Default, rootCAs)
|
||||
}
|
||||
|
||||
func Secure(rootCAs *x509.CertPool) *http.Client {
|
||||
return buildClient(ptls.Secure, rootCAs)
|
||||
}
|
||||
|
||||
func buildClient(tlsConfigFunc ptls.ConfigFunc, rootCAs *x509.CertPool) *http.Client {
|
||||
baseRT := defaultTransport()
|
||||
baseRT.TLSClientConfig = tlsConfigFunc(rootCAs)
|
||||
|
||||
return &http.Client{
|
||||
Transport: defaultWrap(baseRT),
|
||||
Timeout: 3 * time.Hour, // make it impossible for requests to hang indefinitely
|
||||
}
|
||||
}
|
||||
|
||||
func defaultTransport() *http.Transport {
|
||||
baseRT := http.DefaultTransport.(*http.Transport).Clone()
|
||||
net.SetTransportDefaults(baseRT)
|
||||
baseRT.MaxIdleConnsPerHost = 25 // copied from client-go
|
||||
return baseRT
|
||||
}
|
||||
|
||||
func defaultWrap(rt http.RoundTripper) http.RoundTripper {
|
||||
rt = safeDebugWrappers(rt, transport.DebugWrappers, func() bool { return plog.Enabled(plog.LevelTrace) })
|
||||
rt = transport.NewUserAgentRoundTripper(rest.DefaultKubernetesUserAgent(), rt)
|
||||
return rt
|
||||
}
|
||||
116
internal/net/phttp/phttp_test.go
Normal file
116
internal/net/phttp/phttp_test.go
Normal file
@@ -0,0 +1,116 @@
|
||||
// Copyright 2021 the Pinniped contributors. All Rights Reserved.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
package phttp
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/tls"
|
||||
"crypto/x509"
|
||||
"net/http"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
"k8s.io/apimachinery/pkg/util/net"
|
||||
"k8s.io/client-go/util/cert"
|
||||
|
||||
"go.pinniped.dev/internal/crypto/ptls"
|
||||
"go.pinniped.dev/internal/testutil/tlsserver"
|
||||
)
|
||||
|
||||
// TestUnwrap ensures that the http.Client structs returned by this package contain
|
||||
// a transport that can be fully unwrapped to get access to the underlying TLS config.
|
||||
func TestUnwrap(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
f func(*x509.CertPool) *http.Client
|
||||
}{
|
||||
{
|
||||
name: "default",
|
||||
f: Default,
|
||||
},
|
||||
{
|
||||
name: "secure",
|
||||
f: Secure,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
tt := tt
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
p, err := x509.SystemCertPool()
|
||||
require.NoError(t, err)
|
||||
|
||||
c := tt.f(p)
|
||||
|
||||
tlsConfig, err := net.TLSClientConfig(c.Transport)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, tlsConfig)
|
||||
|
||||
require.NotEmpty(t, tlsConfig.NextProtos)
|
||||
require.GreaterOrEqual(t, tlsConfig.MinVersion, uint16(tls.VersionTLS12))
|
||||
require.Equal(t, p, tlsConfig.RootCAs)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestClient(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
clientFunc func(*x509.CertPool) *http.Client
|
||||
configFunc ptls.ConfigFunc
|
||||
}{
|
||||
{
|
||||
name: "default",
|
||||
clientFunc: Default,
|
||||
configFunc: ptls.Default,
|
||||
},
|
||||
{
|
||||
name: "secure",
|
||||
clientFunc: Secure,
|
||||
configFunc: ptls.Secure,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
tt := tt
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
var sawRequest bool
|
||||
server := tlsserver.TLSTestServer(t, http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) {
|
||||
tlsserver.AssertTLS(t, r, tt.configFunc)
|
||||
assertUserAgent(t, r)
|
||||
sawRequest = true
|
||||
}), tlsserver.RecordTLSHello)
|
||||
|
||||
rootCAs, err := cert.NewPoolFromBytes(tlsserver.TLSTestServerCA(server))
|
||||
require.NoError(t, err)
|
||||
|
||||
c := tt.clientFunc(rootCAs)
|
||||
|
||||
req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, server.URL, nil)
|
||||
require.NoError(t, err)
|
||||
|
||||
resp, err := c.Do(req)
|
||||
require.NoError(t, err)
|
||||
require.NoError(t, resp.Body.Close())
|
||||
|
||||
require.True(t, sawRequest)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func assertUserAgent(t *testing.T, r *http.Request) {
|
||||
t.Helper()
|
||||
|
||||
ua := r.Header.Get("user-agent")
|
||||
|
||||
// use assert instead of require to not break the http.Handler with a panic
|
||||
assert.Contains(t, ua, ") kubernetes/")
|
||||
}
|
||||
Reference in New Issue
Block a user