"rsync for cloud storage" - Google Drive, S3, Dropbox, Backblaze B2, One Drive, Swift, Hubic, Wasabi, Google Cloud Storage, Azure Blob, Azure Files, Yandex Files
Go azure-blobazure-blob-storageazure-filesbackblaze-b2cloud-storagedropboxencryptionftpfuse-filesystemgogolanggoogle-cloud-storagegoogle-driveonedriveopenstack-swiftrclones3sftpsyncwebdav
lib/http: use TLS on all --addr listeners when --cert and --key are set GHSA-mfvx-7rcj-9m5g
Nick Craig-Wood043e58b83c37
diff --git a/lib/http/middleware.go b/lib/http/middleware.goindex a9ccf4e2e..e72668f8d 100644--- a/lib/http/middleware.go+++ b/lib/http/middleware.go@@ -79,11 +79,15 @@ func basicAuth(authenticator *LoggedBasicAuth) func(next http.Handler) http.Handfunc MiddlewareAuthCertificateUser() Middleware {return func(next http.Handler) http.Handler {return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- for _, cert := range r.TLS.PeerCertificates {- if cert.Subject.CommonName != "" {- r = r.WithContext(context.WithValue(r.Context(), ctxKeyUser, cert.Subject.CommonName))- next.ServeHTTP(w, r)- return+ // r.TLS is nil on a plain HTTP listener (http:// prefix) where+ // there can be no client certificate+ if r.TLS != nil {+ for _, cert := range r.TLS.PeerCertificates {+ if cert.Subject.CommonName != "" {+ r = r.WithContext(context.WithValue(r.Context(), ctxKeyUser, cert.Subject.CommonName))+ next.ServeHTTP(w, r)+ return+ }}}code := http.StatusUnauthorizeddiff --git a/lib/http/middleware_test.go b/lib/http/middleware_test.goindex d9ff11cf6..2623c0253 100644--- a/lib/http/middleware_test.go+++ b/lib/http/middleware_test.go@@ -6,6 +6,7 @@ import ("errors""fmt""net/http"+ "net/http/httptest""strings""testing"@@ -208,6 +209,15 @@ func TestMiddlewareAuth(t *testing.T) {}}+// A request arriving over a plain HTTP listener has no TLS state so it can't+// carry a client certificate and must be rejected.+func TestMiddlewareAuthCertificateUserNoTLS(t *testing.T) {+ handler := MiddlewareAuthCertificateUser()(testEchoHandler([]byte("ok")))+ rec := httptest.NewRecorder()+ handler.ServeHTTP(rec, httptest.NewRequest("GET", "http://example.com/", nil))+ require.Equal(t, http.StatusUnauthorized, rec.Code)+}+func TestMiddlewareAuthCertificateUser(t *testing.T) {serverCertBytes := testReadTestdataFile(t, "local.crt")serverKeyBytes := testReadTestdataFile(t, "local.key")diff --git a/lib/http/server.go b/lib/http/server.goindex f94cd8a5e..2df99ebbc 100644--- a/lib/http/server.go+++ b/lib/http/server.go@@ -78,6 +78,11 @@ https. You will need to supply the ` + "`--{{ .Prefix }}cert` and `--{{ .PrefixIf you wish to do client side certificate validation then you will need tosupply ` + "`--{{ .Prefix }}client-ca`" + ` also.+When TLS is configured every listener given with ` + "`--{{ .Prefix }}addr`" + ` serves TLS.+An individual listener can be prefixed with ` + "`http://`" + ` to serve unencrypted+HTTP on that address, or with ` + "`tls://`" + ` to state explicitly that it must serve+TLS. Using a ` + "`tls://`" + ` address without ` + "`--{{ .Prefix }}cert` and `--{{ .Prefix }}key`" + ` is an error.+` + "`--{{ .Prefix }}cert`" + ` must be set to the path of a file containingeither a PEM encoded certificate, or a concatenation of that with the CAcertificate. ` + "`--{{ .Prefix }}key`" + ` must be set to the path of a file@@ -404,7 +409,12 @@ func NewServer(ctx context.Context, options ...Option) (*Server, error) {return nil, err}instance = newInstance(ctx, s, listener, s.tlsConfig, addr)- } else if strings.HasPrefix(addr, "tls://") || (len(s.cfg.ListenAddr) == 1 && s.tlsConfig != nil) {+ } else if strings.HasPrefix(addr, "tls://") || (!strings.HasPrefix(addr, "http://") && s.tlsConfig != nil) {+ // If TLS is configured all listeners serve TLS unless+ // explicitly marked http://.+ if s.tlsConfig == nil {+ return nil, fmt.Errorf("can't listen on %q: %w", addr, ErrTLSConfigRequired)+ }addr = strings.TrimPrefix(addr, "tls://")listener, err := net.Listen("tcp", addr)if err != nil {@@ -486,6 +496,8 @@ var (ErrTLSFileMismatch = errors.New("need both --cert and --key to use TLS")// ErrTLSParseCA - hard coded errors, allowing for easier testingErrTLSParseCA = errors.New("unable to parse client certificate authority")+ // ErrTLSConfigRequired - hard coded errors, allowing for easier testing+ ErrTLSConfigRequired = errors.New("need both --cert and --key to use a tls:// address"))func (s *Server) initTLS() error {diff --git a/lib/http/server_test.go b/lib/http/server_test.goindex d675420d1..1bf67a452 100644--- a/lib/http/server_test.go+++ b/lib/http/server_test.go@@ -551,6 +551,91 @@ func TestNewServerTLS(t *testing.T) {}}+// TestNewServerTLSMultipleListeners checks that when TLS is configured it+// applies to every listener, with the http:// and tls:// prefixes selecting+// the protocol for an individual listener.+func TestNewServerTLSMultipleListeners(t *testing.T) {+ serverCertBytes := testReadTestdataFile(t, "local.crt")+ serverKeyBytes := testReadTestdataFile(t, "local.key")++ for _, ss := range []struct {+ name string+ addrs []string+ schemes []string+ }{+ {+ name: "AllTLSByDefault",+ addrs: []string{"127.0.0.1:0", "127.0.0.1:0"},+ schemes: []string{"https://", "https://"},+ },+ {+ name: "ExplicitHTTP",+ addrs: []string{"127.0.0.1:0", "http://127.0.0.1:0"},+ schemes: []string{"https://", "http://"},+ },+ {+ name: "ExplicitTLS",+ addrs: []string{"tls://127.0.0.1:0", "http://127.0.0.1:0"},+ schemes: []string{"https://", "http://"},+ },+ } {+ t.Run(ss.name, func(t *testing.T) {+ cfg := DefaultCfg()+ cfg.ListenAddr = ss.addrs+ cfg.TLSCertBody = serverCertBytes+ cfg.TLSKeyBody = serverKeyBytes++ s, err := NewServer(context.Background(), WithConfig(cfg))+ require.NoError(t, err)+ defer func() {+ require.NoError(t, s.Shutdown())+ }()++ expected := []byte("secret-page")+ s.Router().Mount("/", testEchoHandler(expected))+ s.Serve()++ urls := s.URLs()+ require.Equal(t, len(ss.schemes), len(urls), "should have one URL per listener")+ for i, url := range urls {+ require.Truef(t, strings.HasPrefix(url, ss.schemes[i]), "url %q should have scheme %q", url, ss.schemes[i])++ // Check the listener really speaks the protocol its URL claims+ client := &http.Client{}+ reqURL := url+ if ss.schemes[i] == "https://" {+ dest := strings.TrimSuffix(strings.TrimPrefix(url, "https://"), "/")+ client.Transport = &http.Transport{+ DialContext: func(_ context.Context, _, _ string) (net.Conn, error) {+ return net.Dial("tcp", dest)+ },+ TLSClientConfig: &tls.Config{InsecureSkipVerify: true},+ }+ reqURL = "https://dev.rclone.org"+ }+ req, err := http.NewRequest("GET", reqURL, nil)+ require.NoError(t, err)++ resp, err := client.Do(req)+ require.NoError(t, err)++ require.Equal(t, http.StatusOK, resp.StatusCode, "should return ok")+ testExpectRespBody(t, resp, expected)+ require.NoError(t, resp.Body.Close())+ }+ })+ }+}++// A tls:// address without a TLS config must be an error rather than silently+// serving cleartext.+func TestNewServerTLSListenerRequiresConfig(t *testing.T) {+ cfg := DefaultCfg()+ cfg.ListenAddr = []string{"tls://127.0.0.1:0"}+ _, err := NewServer(context.Background(), WithConfig(cfg))+ require.ErrorIs(t, err, ErrTLSConfigRequired)+}+func TestH2CServer(t *testing.T) {ctx := context.Background()