diff --git a/.golangci.yml b/.golangci.yml
index 8ed29e0343..af560657a5 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -49,6 +49,7 @@ linters-settings:
     replace-allow-list:
       - github.com/studio-b12/gowebdav
       - github.com/egirna/icap-client
+      - github.com/unrolled/secure
   interfacebloat:
     max: 15
 
diff --git a/changelog/unreleased/csp.md b/changelog/unreleased/csp.md
new file mode 100644
index 0000000000..a25f8fe503
--- /dev/null
+++ b/changelog/unreleased/csp.md
@@ -0,0 +1,5 @@
+Enhancement: Add CSP and other security related headers to oCIS
+
+General hardening of oCIS
+
+https://github.com/owncloud/ocis/pull/8777
diff --git a/deployments/examples/ocis_wopi/config/ocis/csp.yaml b/deployments/examples/ocis_wopi/config/ocis/csp.yaml
new file mode 100644
index 0000000000..518f906f14
--- /dev/null
+++ b/deployments/examples/ocis_wopi/config/ocis/csp.yaml
@@ -0,0 +1,35 @@
+directives:
+  child-src:
+    - '''self'''
+  connect-src:
+    - '''self'''
+  default-src:
+    - '''none'''
+  font-src:
+    - '''self'''
+  frame-ancestors:
+    - '''none'''
+  frame-src:
+    - '''self'''
+    - 'https://embed.diagrams.net/'
+    - 'https://${ONLYOFFICE_DOMAIN:-onlyoffice.owncloud.test}/'
+    - 'https://${COLLABORA_DOMAIN:-collabora.owncloud.test}/'
+  img-src:
+    - '''self'''
+    - 'data:'
+    - 'blob:'
+    - 'https://${ONLYOFFICE_DOMAIN:-onlyoffice.owncloud.test}/'
+    - 'https://${COLLABORA_DOMAIN:-collabora.owncloud.test}/'
+  manifest-src:
+    - '''self'''
+  media-src:
+    - '''self'''
+  object-src:
+    - '''self'''
+    - 'blob:'
+  script-src:
+    - '''self'''
+    - '''unsafe-inline'''
+  style-src:
+    - '''self'''
+    - '''unsafe-inline'''
diff --git a/deployments/examples/ocis_wopi/docker-compose.yml b/deployments/examples/ocis_wopi/docker-compose.yml
index 00a41ee1f8..f9ce508b48 100644
--- a/deployments/examples/ocis_wopi/docker-compose.yml
+++ b/deployments/examples/ocis_wopi/docker-compose.yml
@@ -88,8 +88,10 @@ services:
       MICRO_REGISTRY_ADDRESS: 127.0.0.1:9233
       NATS_NATS_HOST: 0.0.0.0
       NATS_NATS_PORT: 9233
+      PROXY_CSP_CONFIG_FILE_LOCATION: /etc/ocis/csp.yaml
     volumes:
       - ./config/ocis/app-registry.yaml:/etc/ocis/app-registry.yaml
+      - ./config/ocis/csp.yaml:/etc/ocis/csp.yaml
       - ./config/ocis/${COMPANION_WEB_CONFIG_FILE_NAME:-web.yaml}:/etc/ocis/web.yaml
       - ocis-config:/etc/ocis
       - ocis-data:/var/lib/ocis
diff --git a/go.mod b/go.mod
index a8bbb6b5c4..b7b5372cae 100644
--- a/go.mod
+++ b/go.mod
@@ -9,6 +9,7 @@ require (
 	github.com/Masterminds/semver v1.5.0
 	github.com/MicahParks/keyfunc v1.9.0
 	github.com/Nerzal/gocloak/v13 v13.9.0
+	github.com/a8m/envsubst v1.4.2
 	github.com/bbalet/stopwords v1.0.0
 	github.com/blevesearch/bleve/v2 v2.4.0
 	github.com/cenkalti/backoff v2.2.1+incompatible
@@ -86,6 +87,7 @@ require (
 	github.com/thejerf/suture/v4 v4.0.5
 	github.com/tidwall/gjson v1.17.1
 	github.com/tus/tusd v1.13.0
+	github.com/unrolled/secure v1.14.0
 	github.com/urfave/cli/v2 v2.27.1
 	github.com/xhit/go-simple-mail/v2 v2.16.0
 	go-micro.dev/v4 v4.10.2
@@ -355,6 +357,8 @@ replace github.com/studio-b12/gowebdav => github.com/aduffeck/gowebdav v0.0.0-20
 
 replace github.com/egirna/icap-client => github.com/fschade/icap-client v0.0.0-20240123094924-5af178158eaf
 
+replace github.com/unrolled/secure => github.com/DeepDiver1975/secure v0.0.0-20240424132259-5b29166734cb
+
 // exclude the v2 line of go-sqlite3 which was released accidentally and prevents pulling in newer versions of go-sqlite3
 // see https://github.com/mattn/go-sqlite3/issues/965 for more details
 exclude github.com/mattn/go-sqlite3 v2.0.3+incompatible
diff --git a/go.sum b/go.sum
index 3701d0d1f9..355d58d8ee 100644
--- a/go.sum
+++ b/go.sum
@@ -798,6 +798,8 @@ github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym
 github.com/CiscoM31/godata v1.0.10 h1:DZdJ6M8QNh4HquvDDOqNLu6h77Wl86KGK7Qlbmb90sk=
 github.com/CiscoM31/godata v1.0.10/go.mod h1:ZMiT6JuD3Rm83HEtiTx4JEChsd25YCrxchKGag/sdTc=
 github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
+github.com/DeepDiver1975/secure v0.0.0-20240424132259-5b29166734cb h1:Ugrv7ivJ035zunmhmGEBSXL76tyxRNH5XaBSQUTqf38=
+github.com/DeepDiver1975/secure v0.0.0-20240424132259-5b29166734cb/go.mod h1:BmF5hyM6tXczk3MpQkFf1hpKSRqCyhqcbiQtiAF7+40=
 github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c/go.mod h1:X0CRv0ky0k6m906ixxpzmDRLvX58TFUKS2eePweuyxk=
 github.com/KimMachineGun/automemlimit v0.6.0 h1:p/BXkH+K40Hax+PuWWPQ478hPjsp9h1CPDhLlA3Z37E=
 github.com/KimMachineGun/automemlimit v0.6.0/go.mod h1:T7xYht7B8r6AG/AqFcUdc7fzd2bIdBKmepfP2S1svPY=
@@ -824,6 +826,8 @@ github.com/RoaringBitmap/roaring v1.2.3 h1:yqreLINqIrX22ErkKI0vY47/ivtJr6n+kMhVO
 github.com/RoaringBitmap/roaring v1.2.3/go.mod h1:plvDsJQpxOC5bw8LRteu/MLWHsHez/3y6cubLI4/1yE=
 github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
 github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
+github.com/a8m/envsubst v1.4.2 h1:4yWIHXOLEJHQEFd4UjrWDrYeYlV7ncFWJOCBRLOZHQg=
+github.com/a8m/envsubst v1.4.2/go.mod h1:MVUTQNGQ3tsjOOtKCNd+fl8RzhsXcDvvAEzkhGtlsbY=
 github.com/aduffeck/gowebdav v0.0.0-20231215102054-212d4a4374f6 h1:ws0yvsikTQdmheKINP16tBzAHdttrHwbz/q3Fgl9X1Y=
 github.com/aduffeck/gowebdav v0.0.0-20231215102054-212d4a4374f6/go.mod h1:bHA7t77X/QFExdeAnDzK6vKM34kEZAcE1OX4MfiwjkE=
 github.com/agnivade/levenshtein v1.1.1 h1:QY8M92nrzkmr798gCo3kmMyqXFzdQVpxLlGPRBij0P8=
diff --git a/ocis-pkg/middleware/header.go b/ocis-pkg/middleware/header.go
index 9db2908148..2e82d65931 100644
--- a/ocis-pkg/middleware/header.go
+++ b/ocis-pkg/middleware/header.go
@@ -38,22 +38,3 @@ func Cors(opts ...cors.Option) func(http.Handler) http.Handler {
 		AllowCredentials: options.AllowCredentials,
 	})
 }
-
-// Secure writes required access headers to all requests.
-func Secure(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Indicates whether the browser is allowed to render this page in a <frame>, <iframe>, <embed> or <object>.
-		w.Header().Set("X-Frame-Options", "DENY")
-		// Does basically the same as X-Frame-Options.
-		w.Header().Set("Content-Security-Policy", "frame-ancestors 'none'")
-		// This header inidicates that MIME types advertised in the Content-Type headers should not be changed and be followed.
-		w.Header().Set("X-Content-Type-Options", "nosniff")
-
-		if r.TLS != nil {
-			// Tell browsers that the website should only be accessed  using HTTPS.
-			w.Header().Set("Strict-Transport-Security", "max-age=31536000")
-		}
-
-		next.ServeHTTP(w, r)
-	})
-}
diff --git a/ocis-pkg/service/debug/service.go b/ocis-pkg/service/debug/service.go
index 56e7e882b0..651856f42a 100644
--- a/ocis-pkg/service/debug/service.go
+++ b/ocis-pkg/service/debug/service.go
@@ -68,7 +68,6 @@ func NewService(opts ...Option) *http.Server {
 				cors.AllowedHeaders(dopts.CorsAllowedHeaders),
 				cors.AllowCredentials(dopts.CorsAllowCredentials),
 			),
-			middleware.Secure,
 			middleware.Version(
 				dopts.Name,
 				dopts.Version,
diff --git a/services/graph/pkg/server/http/server.go b/services/graph/pkg/server/http/server.go
index 53f987f38c..4e7d02e2f4 100644
--- a/services/graph/pkg/server/http/server.go
+++ b/services/graph/pkg/server/http/server.go
@@ -79,7 +79,6 @@ func Server(opts ...Option) (http.Service, error) {
 			cors.AllowedHeaders(options.Config.HTTP.CORS.AllowedHeaders),
 			cors.AllowCredentials(options.Config.HTTP.CORS.AllowCredentials),
 		),
-		middleware.Secure,
 	}
 	// how do we secure the api?
 	var requireAdminMiddleware func(stdhttp.Handler) stdhttp.Handler
diff --git a/services/idp/pkg/server/http/server.go b/services/idp/pkg/server/http/server.go
index 74b248181a..cdd1f23c4b 100644
--- a/services/idp/pkg/server/http/server.go
+++ b/services/idp/pkg/server/http/server.go
@@ -61,7 +61,6 @@ func Server(opts ...Option) (http.Service, error) {
 			chimiddleware.RequestID,
 			middleware.TraceContext,
 			middleware.NoCache,
-			middleware.Secure,
 			middleware.Version(
 				options.Config.Service.Name,
 				version.GetString(),
diff --git a/services/invitations/pkg/server/http/server.go b/services/invitations/pkg/server/http/server.go
index 744b1fb262..5c50b00507 100644
--- a/services/invitations/pkg/server/http/server.go
+++ b/services/invitations/pkg/server/http/server.go
@@ -55,7 +55,6 @@ func Server(opts ...Option) (ohttp.Service, error) {
 			cors.AllowedHeaders(options.Config.HTTP.CORS.AllowedHeaders),
 			cors.AllowCredentials(options.Config.HTTP.CORS.AllowCredentials),
 		))
-	mux.Use(middleware.Secure)
 
 	mux.Use(middleware.Version(
 		options.Name,
diff --git a/services/ocs/pkg/server/http/server.go b/services/ocs/pkg/server/http/server.go
index d7d8837fff..fe4e1da59a 100644
--- a/services/ocs/pkg/server/http/server.go
+++ b/services/ocs/pkg/server/http/server.go
@@ -69,7 +69,6 @@ func Server(opts ...Option) (http.Service, error) {
 				cors.AllowedHeaders(options.Config.HTTP.CORS.AllowedHeaders),
 				cors.AllowCredentials(options.Config.HTTP.CORS.AllowCredentials),
 			),
-			middleware.Secure,
 			middleware.Version(
 				options.Config.Service.Name,
 				version.GetString(),
diff --git a/services/proxy/pkg/command/server.go b/services/proxy/pkg/command/server.go
index dea2597c9f..10221eed33 100644
--- a/services/proxy/pkg/command/server.go
+++ b/services/proxy/pkg/command/server.go
@@ -300,6 +300,11 @@ func loadMiddlewares(ctx context.Context, logger log.Logger, cfg *config.Config,
 		Now:                time.Now,
 	})
 
+	cspConfig, err := middleware.LoadCSPConfig(cfg)
+	if err != nil {
+		logger.Fatal().Err(err).Msg("Failed to load CSP configuration.")
+	}
+
 	return alice.New(
 		// first make sure we log all requests and redirect to https if necessary
 		otelhttp.NewMiddleware("proxy",
@@ -315,6 +320,7 @@ func loadMiddlewares(ctx context.Context, logger log.Logger, cfg *config.Config,
 		chimiddleware.RequestID,
 		middleware.AccessLog(logger),
 		middleware.HTTPSRedirect,
+		middleware.Security(cspConfig),
 		router.Middleware(cfg.PolicySelector, cfg.Policies, logger),
 		middleware.Authentication(
 			authenticators,
diff --git a/services/proxy/pkg/config/config.go b/services/proxy/pkg/config/config.go
index 837a14740f..ce96d5c1e3 100644
--- a/services/proxy/pkg/config/config.go
+++ b/services/proxy/pkg/config/config.go
@@ -42,6 +42,7 @@ type Config struct {
 	BackendHTTPSCACert    string             `yaml:"backend_https_cacert" env:"PROXY_HTTPS_CACERT" desc:"Path/File for the root CA certificate used to validate the server’s TLS certificate for https enabled backend services." introductionVersion:"pre5.0"`
 	AuthMiddleware        AuthMiddleware     `yaml:"auth_middleware"`
 	PoliciesMiddleware    PoliciesMiddleware `yaml:"policies_middleware"`
+	CSPConfigFileLocation string             `yaml:"csp_config_file_location" env:"PROXY_CSP_CONFIG_FILE_LOCATION" desc:"The location of the CSP configuration file." introductionVersion:"6.0"`
 
 	Context context.Context `yaml:"-" json:"-"`
 }
@@ -140,7 +141,7 @@ type RoleAssignment struct {
 	OIDCRoleMapper OIDCRoleMapper `yaml:"oidc_role_mapper"`
 }
 
-// OIDCRoleMapper contains the configuration for the "oidc" role assignment driber
+// OIDCRoleMapper contains the configuration for the "oidc" role assignment driver
 type OIDCRoleMapper struct {
 	RoleClaim string        `yaml:"role_claim" env:"PROXY_ROLE_ASSIGNMENT_OIDC_CLAIM" desc:"The OIDC claim used to create the users role assignment." introductionVersion:"pre5.0"`
 	RolesMap  []RoleMapping `yaml:"role_mapping" desc:"A list of mappings of ocis role names to PROXY_ROLE_ASSIGNMENT_OIDC_CLAIM claim values. This setting can only be configured in the configuration file and not via environment variables."`
diff --git a/services/proxy/pkg/config/csp.go b/services/proxy/pkg/config/csp.go
new file mode 100644
index 0000000000..9a3fc6e0b0
--- /dev/null
+++ b/services/proxy/pkg/config/csp.go
@@ -0,0 +1,13 @@
+package config
+
+import (
+	_ "embed"
+)
+
+// CSP defines CSP header directives
+type CSP struct {
+	Directives map[string][]string `yaml:"directives"`
+}
+
+//go:embed csp.yaml
+var DefaultCSPConfig string
diff --git a/services/proxy/pkg/config/csp.yaml b/services/proxy/pkg/config/csp.yaml
new file mode 100644
index 0000000000..a006a2ff89
--- /dev/null
+++ b/services/proxy/pkg/config/csp.yaml
@@ -0,0 +1,31 @@
+directives:
+  child-src:
+    - '''self'''
+  connect-src:
+    - '''self'''
+  default-src:
+    - '''none'''
+  font-src:
+    - '''self'''
+  frame-ancestors:
+    - '''none'''
+  frame-src:
+    - '''self'''
+    - 'https://embed.diagrams.net/'
+  img-src:
+    - '''self'''
+    - 'data:'
+    - 'blob:'
+  manifest-src:
+    - '''self'''
+  media-src:
+    - '''self'''
+  object-src:
+    - '''self'''
+    - 'blob:'
+  script-src:
+    - '''self'''
+    - '''unsafe-inline'''
+  style-src:
+    - '''self'''
+    - '''unsafe-inline'''
diff --git a/services/proxy/pkg/config/defaults/defaultconfig.go b/services/proxy/pkg/config/defaults/defaultconfig.go
index 17d11e9a19..2911be0560 100644
--- a/services/proxy/pkg/config/defaults/defaultconfig.go
+++ b/services/proxy/pkg/config/defaults/defaultconfig.go
@@ -86,6 +86,7 @@ func DefaultConfig() *config.Config {
 		AutoprovisionAccounts: false,
 		EnableBasicAuth:       false,
 		InsecureBackends:      false,
+		CSPConfigFileLocation: "",
 	}
 }
 
diff --git a/services/proxy/pkg/middleware/security.go b/services/proxy/pkg/middleware/security.go
new file mode 100644
index 0000000000..13f2e5beb1
--- /dev/null
+++ b/services/proxy/pkg/middleware/security.go
@@ -0,0 +1,61 @@
+package middleware
+
+import (
+	"github.com/a8m/envsubst"
+	"github.com/owncloud/ocis/v2/services/proxy/pkg/config"
+	"github.com/unrolled/secure"
+	"github.com/unrolled/secure/cspbuilder"
+	"gopkg.in/yaml.v2"
+	"net/http"
+	"os"
+)
+
+// LoadCSPConfig loads CSP header configuration from a yaml file.
+func LoadCSPConfig(proxyCfg *config.Config) (*config.CSP, error) {
+	yamlContent, err := loadCSPYaml(proxyCfg)
+	if err != nil {
+		return nil, err
+	}
+	// replace env vars ..
+	yamlContent, err = envsubst.Bytes(yamlContent)
+	if err != nil {
+		return nil, err
+	}
+
+	// read yaml
+	cspConfig := config.CSP{}
+	err = yaml.Unmarshal(yamlContent, &cspConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	return &cspConfig, nil
+}
+
+func loadCSPYaml(proxyCfg *config.Config) ([]byte, error) {
+	if proxyCfg.CSPConfigFileLocation == "" {
+		return []byte(config.DefaultCSPConfig), nil
+	}
+	return os.ReadFile(proxyCfg.CSPConfigFileLocation)
+}
+
+// Security is a middleware to apply security relevant http headers like CSP.
+func Security(cspConfig *config.CSP) func(h http.Handler) http.Handler {
+	cspBuilder := cspbuilder.Builder{
+		Directives: cspConfig.Directives,
+	}
+
+	secureMiddleware := secure.New(secure.Options{
+		BrowserXssFilter:        true,
+		ContentSecurityPolicy:   cspBuilder.MustBuild(),
+		ContentTypeNosniff:      true,
+		CustomFrameOptionsValue: "SAMEORIGIN",
+		FrameDeny:               true,
+		ReferrerPolicy:          "strict-origin-when-cross-origin",
+		STSSeconds:              315360000,
+		STSPreload:              true,
+	})
+	return func(next http.Handler) http.Handler {
+		return secureMiddleware.Handler(next)
+	}
+}
diff --git a/services/settings/pkg/server/http/server.go b/services/settings/pkg/server/http/server.go
index d523fc94a6..6870b0936f 100644
--- a/services/settings/pkg/server/http/server.go
+++ b/services/settings/pkg/server/http/server.go
@@ -52,7 +52,6 @@ func Server(opts ...Option) (ohttp.Service, error) {
 		cors.AllowedHeaders(options.Config.HTTP.CORS.AllowedHeaders),
 		cors.AllowCredentials(options.Config.HTTP.CORS.AllowCredentials),
 	))
-	mux.Use(middleware.Secure)
 	mux.Use(middleware.ExtractAccountUUID(
 		account.Logger(options.Logger),
 		account.JWTSecret(options.Config.TokenManager.JWTSecret)),
diff --git a/services/sse/pkg/server/http/server.go b/services/sse/pkg/server/http/server.go
index 010d63ed98..1040c09240 100644
--- a/services/sse/pkg/server/http/server.go
+++ b/services/sse/pkg/server/http/server.go
@@ -64,7 +64,6 @@ func Server(opts ...Option) (http.Service, error) {
 			cors.AllowedHeaders(options.Config.HTTP.CORS.AllowedHeaders),
 			cors.AllowCredentials(options.Config.HTTP.CORS.AllowCredentials),
 		),
-		middleware.Secure,
 	}
 
 	mux := chi.NewMux()
diff --git a/services/thumbnails/pkg/server/http/server.go b/services/thumbnails/pkg/server/http/server.go
index 7dfa8adb14..660e85d5d6 100644
--- a/services/thumbnails/pkg/server/http/server.go
+++ b/services/thumbnails/pkg/server/http/server.go
@@ -39,7 +39,6 @@ func Server(opts ...Option) (http.Service, error) {
 		svc.Middleware(
 			middleware.RealIP,
 			middleware.RequestID,
-			// ocismiddleware.Secure,
 			ocismiddleware.Version(
 				options.Config.Service.Name,
 				version.GetString(),
diff --git a/services/userlog/pkg/server/http/server.go b/services/userlog/pkg/server/http/server.go
index 1766f1d566..7939e9d65c 100644
--- a/services/userlog/pkg/server/http/server.go
+++ b/services/userlog/pkg/server/http/server.go
@@ -63,7 +63,6 @@ func Server(opts ...Option) (http.Service, error) {
 			cors.AllowedHeaders(options.Config.HTTP.CORS.AllowedHeaders),
 			cors.AllowCredentials(options.Config.HTTP.CORS.AllowCredentials),
 		),
-		middleware.Secure,
 	}
 
 	mux := chi.NewMux()
diff --git a/services/web/pkg/middleware/silentrefresh.go b/services/web/pkg/middleware/silentrefresh.go
index fa2033fc31..703313a1a9 100644
--- a/services/web/pkg/middleware/silentrefresh.go
+++ b/services/web/pkg/middleware/silentrefresh.go
@@ -7,7 +7,6 @@ import (
 // SilentRefresh allows the oidc client lib to silently refresh the token in an iframe
 func SilentRefresh(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("X-Frame-Options", "SAMEORIGIN")
 		w.Header().Set("Content-Security-Policy", "frame-ancestors 'self'")
 		next.ServeHTTP(w, r)
 	})
diff --git a/services/web/pkg/server/http/server.go b/services/web/pkg/server/http/server.go
index 417d17849c..6ecc0c774c 100644
--- a/services/web/pkg/server/http/server.go
+++ b/services/web/pkg/server/http/server.go
@@ -84,7 +84,6 @@ func Server(opts ...Option) (http.Service, error) {
 			chimiddleware.RealIP,
 			chimiddleware.RequestID,
 			middleware.NoCache,
-			middleware.Secure,
 			webmid.SilentRefresh,
 			middleware.Version(
 				"web",
diff --git a/services/webdav/pkg/server/http/server.go b/services/webdav/pkg/server/http/server.go
index acb36a0570..c39ea3cce7 100644
--- a/services/webdav/pkg/server/http/server.go
+++ b/services/webdav/pkg/server/http/server.go
@@ -48,7 +48,6 @@ func Server(opts ...Option) (http.Service, error) {
 				cors.AllowedHeaders(options.Config.HTTP.CORS.AllowedHeaders),
 				cors.AllowCredentials(options.Config.HTTP.CORS.AllowCredentials),
 			),
-			middleware.Secure,
 			middleware.Version(
 				options.Config.Service.Name,
 				version.GetString(),
diff --git a/services/webfinger/pkg/server/http/server.go b/services/webfinger/pkg/server/http/server.go
index 7fe7d1740b..45e49f76fd 100644
--- a/services/webfinger/pkg/server/http/server.go
+++ b/services/webfinger/pkg/server/http/server.go
@@ -57,7 +57,6 @@ func Server(opts ...Option) (ohttp.Service, error) {
 			cors.AllowedHeaders(options.Config.HTTP.CORS.AllowedHeaders),
 			cors.AllowCredentials(options.Config.HTTP.CORS.AllowCredentials),
 		))
-	mux.Use(middleware.Secure)
 
 	mux.Use(middleware.Version(
 		options.Name,
diff --git a/tests/acceptance/features/coreApiWebdavOperations/downloadFile.feature b/tests/acceptance/features/coreApiWebdavOperations/downloadFile.feature
index ccf5d2e5f3..d682aefb1e 100644
--- a/tests/acceptance/features/coreApiWebdavOperations/downloadFile.feature
+++ b/tests/acceptance/features/coreApiWebdavOperations/downloadFile.feature
@@ -271,7 +271,7 @@ Feature: download file
     And the following headers should be set
       | header                            | value                                                              |
       | Content-Disposition               | attachment; filename*=UTF-8''"<file-name>"; filename="<file-name>" |
-      | Content-Security-Policy           | default-src 'none';                                                |
+      | Content-Security-Policy           | child-src 'self'; connect-src 'self'; default-src 'none'; font-src 'self'; frame-ancestors 'none'; frame-src 'self' https://embed.diagrams.net/; img-src 'self' data: blob:; manifest-src 'self'; media-src 'self'; object-src 'self' blob:; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'                                                |
       | X-Content-Type-Options            | nosniff                                                            |
       | X-Download-Options                | noopen                                                             |
       | X-Frame-Options                   | SAMEORIGIN                                                         |
@@ -304,7 +304,7 @@ Feature: download file
     And the following headers should be set
       | header                            | value                                                                            |
       | Content-Disposition               | attachment; filename*=UTF-8''""quote"double".txt"; filename=""quote"double".txt" |
-      | Content-Security-Policy           | default-src 'none';                                                              |
+      | Content-Security-Policy           | child-src 'self'; connect-src 'self'; default-src 'none'; font-src 'self'; frame-ancestors 'none'; frame-src 'self' https://embed.diagrams.net/; img-src 'self' data: blob:; manifest-src 'self'; media-src 'self'; object-src 'self' blob:; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'                                                              |
       | X-Content-Type-Options            | nosniff                                                                          |
       | X-Download-Options                | noopen                                                                           |
       | X-Frame-Options                   | SAMEORIGIN                                                                       |
diff --git a/tests/parallelDeployAcceptance/features/apiWebdavOperations/downloadFile.feature b/tests/parallelDeployAcceptance/features/apiWebdavOperations/downloadFile.feature
index ed9034d6c8..52e2573b2f 100644
--- a/tests/parallelDeployAcceptance/features/apiWebdavOperations/downloadFile.feature
+++ b/tests/parallelDeployAcceptance/features/apiWebdavOperations/downloadFile.feature
@@ -132,7 +132,7 @@ Feature: download file
     Then the following headers should be set
       | header                            | value                                                              |
       | Content-Disposition               | attachment; filename*=UTF-8''textfile.txt; filename="textfile.txt" |
-      | Content-Security-Policy           | default-src 'none';                                                |
+      | Content-Security-Policy           | child-src 'self'; connect-src 'self'; default-src 'none'; font-src 'self'; frame-ancestors 'none'; frame-src 'self' https://embed.diagrams.net/; img-src 'self' data: blob:; manifest-src 'self'; media-src 'self'; object-src 'self' blob:; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'                                                |
       | X-Content-Type-Options            | nosniff                                                            |
       | X-Download-Options                | noopen                                                             |
       | X-Frame-Options                   | SAMEORIGIN                                                         |
diff --git a/vendor/github.com/a8m/envsubst/.travis.yml b/vendor/github.com/a8m/envsubst/.travis.yml
new file mode 100644
index 0000000000..78df272d55
--- /dev/null
+++ b/vendor/github.com/a8m/envsubst/.travis.yml
@@ -0,0 +1,7 @@
+language: go
+go:
+  - 1.13
+  - 1.14
+  - tip
+scripts:
+  - go test
diff --git a/vendor/github.com/a8m/envsubst/LICENSE b/vendor/github.com/a8m/envsubst/LICENSE
new file mode 100644
index 0000000000..8d89ecb65e
--- /dev/null
+++ b/vendor/github.com/a8m/envsubst/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 envsubst contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/a8m/envsubst/README.md b/vendor/github.com/a8m/envsubst/README.md
new file mode 100644
index 0000000000..52e64636f3
--- /dev/null
+++ b/vendor/github.com/a8m/envsubst/README.md
@@ -0,0 +1,107 @@
+# envsubst
+[![GoDoc][godoc-img]][godoc-url]
+[![License][license-image]][license-url]
+[![Build status][travis-image]][travis-url]
+[![Github All Releases][releases-image]][releases]
+
+> Environment variables substitution for Go. see docs [below](#docs)
+
+#### Installation:
+
+##### From binaries
+Latest stable `envsubst` [prebuilt binaries for 64-bit Linux, or Mac OS X][releases] are available via Github releases.
+
+###### Linux and MacOS
+```console
+curl -L https://github.com/a8m/envsubst/releases/download/v1.2.0/envsubst-`uname -s`-`uname -m` -o envsubst
+chmod +x envsubst
+sudo mv envsubst /usr/local/bin
+```
+
+###### Windows
+Download the latest prebuilt binary from [releases page][releases], or if you have curl installed:
+```console
+curl -L https://github.com/a8m/envsubst/releases/download/v1.2.0/envsubst.exe
+```
+
+##### With go
+You can install via `go get` (provided you have installed go):
+```console
+go get github.com/a8m/envsubst/cmd/envsubst
+```
+
+
+#### Using via cli
+```sh
+envsubst < input.tmpl > output.text
+echo 'welcome $HOME ${USER:=a8m}' | envsubst
+envsubst -help
+```
+
+#### Imposing restrictions
+There are three command line flags with which you can cause the substitution to stop with an error code, should the restriction associated with the flag not be met. This can be handy if you want to avoid creating e.g. configuration files with unset or empty parameters.
+Setting a `-fail-fast` flag in conjunction with either no-unset or no-empty or both will result in a faster feedback loop, this can be especially useful when running through a large file or byte array input, otherwise a list of errors is returned.
+
+The flags and their restrictions are: 
+
+|__Option__     | __Meaning__    | __Type__ | __Default__  |
+| ------------| -------------- | ------------ | ------------ |
+|`-i`  | input file  | ```string | stdin``` | `stdin`
+|`-o`  | output file | ```string | stdout``` |  `stdout` 
+|`-no-digit`  | do not replace variables starting with a digit, e.g. $1 and ${1} | `flag` |  `false` 
+|`-no-unset`  | fail if a variable is not set | `flag` |  `false` 
+|`-no-empty`  | fail if a variable is set but empty | `flag` | `false`
+|`-fail-fast`  | fails at first occurence of an error, if `-no-empty` or `-no-unset` flags were **not** specified this is ignored | `flag` | `false`
+
+These flags can be combined to form tighter restrictions. 
+
+#### Using `envsubst` programmatically ?
+You can take a look on [`_example/main`](https://github.com/a8m/envsubst/blob/master/_example/main.go) or see the example below.
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/a8m/envsubst"
+)
+
+func main() {
+    input := "welcom $HOME"
+    str, err := envsubst.String(input)
+    // ...
+    buf, err := envsubst.Bytes([]byte(input))
+    // ...
+    buf, err := envsubst.ReadFile("filename")
+}
+```
+### Docs
+> api docs here: [![GoDoc][godoc-img]][godoc-url]
+
+|__Expression__     | __Meaning__    |
+| ----------------- | -------------- |
+|`${var}`           | Value of var (same as `$var`)
+|`${var-$DEFAULT}`  | If var not set, evaluate expression as $DEFAULT
+|`${var:-$DEFAULT}` | If var not set or is empty, evaluate expression as $DEFAULT
+|`${var=$DEFAULT}`  | If var not set, evaluate expression as $DEFAULT
+|`${var:=$DEFAULT}` | If var not set or is empty, evaluate expression as $DEFAULT
+|`${var+$OTHER}`    | If var set, evaluate expression as $OTHER, otherwise as empty string
+|`${var:+$OTHER}`   | If var set, evaluate expression as $OTHER, otherwise as empty string
+|`$$var`            | Escape expressions. Result will be `$var`. 
+
+<sub>Most of the rows in this table were taken from [here](http://www.tldp.org/LDP/abs/html/refcards.html#AEN22728)</sub>
+
+### See also
+
+* `os.ExpandEnv(s string) string` - only supports `$var` and `${var}` notations
+
+#### License
+MIT
+
+[releases]: https://github.com/a8m/envsubst/releases
+[releases-image]: https://img.shields.io/github/downloads/a8m/envsubst/total.svg?style=for-the-badge
+[godoc-url]: https://godoc.org/github.com/a8m/envsubst
+[godoc-img]: https://img.shields.io/badge/godoc-reference-blue.svg?style=for-the-badge
+[license-image]: https://img.shields.io/badge/license-MIT-blue.svg?style=for-the-badge
+[license-url]: LICENSE
+[travis-image]: https://img.shields.io/travis/a8m/envsubst.svg?style=for-the-badge
+[travis-url]: https://travis-ci.org/a8m/envsubst
diff --git a/vendor/github.com/a8m/envsubst/envsubst.go b/vendor/github.com/a8m/envsubst/envsubst.go
new file mode 100644
index 0000000000..22b5bb8384
--- /dev/null
+++ b/vendor/github.com/a8m/envsubst/envsubst.go
@@ -0,0 +1,74 @@
+package envsubst
+
+import (
+	"io/ioutil"
+	"os"
+
+	"github.com/a8m/envsubst/parse"
+)
+
+// String returns the parsed template string after processing it.
+// If the parser encounters invalid input, it returns an error describing the failure.
+func String(s string) (string, error) {
+	return StringRestricted(s, false, false)
+}
+
+// StringRestricted returns the parsed template string after processing it.
+// If the parser encounters invalid input, or a restriction is violated, it returns
+// an error describing the failure.
+// Errors on first failure or returns a collection of failures if failOnFirst is false
+func StringRestricted(s string, noUnset, noEmpty bool) (string, error) {
+	return StringRestrictedNoDigit(s, noUnset, noEmpty , false)
+}
+
+// Like StringRestricted but additionally allows to ignore env variables which start with a digit.
+func StringRestrictedNoDigit(s string, noUnset, noEmpty bool, noDigit bool) (string, error) {
+	return parse.New("string", os.Environ(),
+		&parse.Restrictions{noUnset, noEmpty, noDigit}).Parse(s)
+}
+
+// Bytes returns the bytes represented by the parsed template after processing it.
+// If the parser encounters invalid input, it returns an error describing the failure.
+func Bytes(b []byte) ([]byte, error) {
+	return BytesRestricted(b, false, false)
+}
+
+// BytesRestricted returns the bytes represented by the parsed template after processing it.
+// If the parser encounters invalid input, or a restriction is violated, it returns
+// an error describing the failure.
+func BytesRestricted(b []byte, noUnset, noEmpty bool) ([]byte, error) {
+	return BytesRestrictedNoDigit(b, noUnset, noEmpty, false)
+}
+
+// Like BytesRestricted but additionally allows to ignore env variables which start with a digit.
+func BytesRestrictedNoDigit(b []byte, noUnset, noEmpty bool, noDigit bool) ([]byte, error) {
+	s, err := parse.New("bytes", os.Environ(),
+		&parse.Restrictions{noUnset, noEmpty, noDigit}).Parse(string(b))
+	if err != nil {
+		return nil, err
+	}
+	return []byte(s), nil
+}
+
+// ReadFile call io.ReadFile with the given file name.
+// If the call to io.ReadFile failed it returns the error; otherwise it will
+// call envsubst.Bytes with the returned content.
+func ReadFile(filename string) ([]byte, error) {
+	return ReadFileRestricted(filename, false, false)
+}
+
+// ReadFileRestricted calls io.ReadFile with the given file name.
+// If the call to io.ReadFile failed it returns the error; otherwise it will
+// call envsubst.Bytes with the returned content.
+func ReadFileRestricted(filename string, noUnset, noEmpty bool) ([]byte, error) {
+	return ReadFileRestrictedNoDigit(filename, noUnset, noEmpty, false)
+}
+
+// Like ReadFileRestricted but additionally allows to ignore env variables which start with a digit.
+func ReadFileRestrictedNoDigit(filename string, noUnset, noEmpty bool, noDigit bool) ([]byte, error) {
+	b, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+	return BytesRestrictedNoDigit(b, noUnset, noEmpty, noDigit)
+}
diff --git a/vendor/github.com/a8m/envsubst/parse/env.go b/vendor/github.com/a8m/envsubst/parse/env.go
new file mode 100644
index 0000000000..99a8ceee5d
--- /dev/null
+++ b/vendor/github.com/a8m/envsubst/parse/env.go
@@ -0,0 +1,27 @@
+package parse
+
+import (
+	"strings"
+)
+
+type Env []string
+
+func (e Env) Get(name string) string {
+	v, _ := e.Lookup(name)
+	return v
+}
+
+func (e Env) Has(name string) bool {
+	_, ok := e.Lookup(name)
+	return ok
+}
+
+func (e Env) Lookup(name string) (string, bool) {
+	prefix := name + "="
+	for _, pair := range e {
+		if strings.HasPrefix(pair, prefix) {
+			return pair[len(prefix):], true
+		}
+	}
+	return "", false
+}
diff --git a/vendor/github.com/a8m/envsubst/parse/lex.go b/vendor/github.com/a8m/envsubst/parse/lex.go
new file mode 100644
index 0000000000..5cd4c4699e
--- /dev/null
+++ b/vendor/github.com/a8m/envsubst/parse/lex.go
@@ -0,0 +1,269 @@
+package parse
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// itemType identifies the type of lex items.
+type itemType int
+
+// Pos represents a byte position in the original input text from which
+// this template was parsed.
+type Pos int
+
+// item represents a token or text string returned from the scanner.
+type item struct {
+	typ itemType // The type of this item.
+	pos Pos      // The starting position, in bytes, of this item in the input string.
+	val string   // The value of this item.
+}
+
+func (i item) String() string {
+	typ := "OP"
+	if t, ok := tokens[i.typ]; ok {
+		typ = t
+	}
+	return fmt.Sprintf("%s: %.40q", typ, i.val)
+}
+
+const (
+	eof                = -1
+	itemError itemType = iota // error occurred; value is text of error
+	itemEOF
+	itemText        // plain text
+	itemPlus        // plus('+')
+	itemDash        // dash('-')
+	itemEquals      // equals
+	itemColonEquals // colon-equals (':=')
+	itemColonDash   // colon-dash(':-')
+	itemColonPlus   // colon-plus(':+')
+	itemVariable    // variable starting with '$', such as '$hello' or '$1'
+	itemLeftDelim   // left action delimiter '${'
+	itemRightDelim  // right action delimiter '}'
+)
+
+var tokens = map[itemType]string{
+	itemEOF:        "EOF",
+	itemError:      "ERROR",
+	itemText:       "TEXT",
+	itemVariable:   "VAR",
+	itemLeftDelim:  "START EXP",
+	itemRightDelim: "END EXP",
+}
+
+// stateFn represents the state of the lexer as a function that returns the next state.
+type stateFn func(*lexer) stateFn
+
+// lexer holds the state of the scanner
+type lexer struct {
+	input     string    // the string being lexed
+	state     stateFn   // the next lexing function to enter
+	pos       Pos       // current position in the input
+	start     Pos       // start position of this item
+	width     Pos       // width of last rune read from input
+	lastPos   Pos       // position of most recent item returned by nextItem
+	items     chan item // channel of lexed items
+	subsDepth int       // depth of substitution
+	noDigit   bool      // if the lexer skips variables that start with a digit
+}
+
+// next returns the next rune in the input.
+func (l *lexer) next() rune {
+	if int(l.pos) >= len(l.input) {
+		l.width = 0
+		return eof
+	}
+	r, w := utf8.DecodeRuneInString(l.input[l.pos:])
+	l.width = Pos(w)
+	l.pos += l.width
+	return r
+}
+
+// peek returns but does not consume the next rune in the input.
+func (l *lexer) peek() rune {
+	r := l.next()
+	l.backup()
+	return r
+}
+
+// backup steps back one rune. Can only be called once per call of next.
+func (l *lexer) backup() {
+	l.pos -= l.width
+}
+
+// emit passes an item back to the client.
+func (l *lexer) emit(t itemType) {
+	l.items <- item{t, l.start, l.input[l.start:l.pos]}
+	l.lastPos = l.start
+	l.start = l.pos
+}
+
+// ignore skips over the pending input before this point.
+func (l *lexer) ignore() {
+	l.start = l.pos
+}
+
+// errorf returns an error token and terminates the scan by passing
+// back a nil pointer that will be the next state, terminating l.nextItem.
+func (l *lexer) errorf(format string, args ...interface{}) stateFn {
+	l.items <- item{itemError, l.start, fmt.Sprintf(format, args...)}
+	return nil
+}
+
+// nextItem returns the next item from the input.
+// Called by the parser, not in the lexing goroutine.
+func (l *lexer) nextItem() item {
+	item := <-l.items
+	return item
+}
+
+// lex creates a new scanner for the input string.
+func lex(input string, noDigit bool) *lexer {
+	l := &lexer{
+		input:   input,
+		items:   make(chan item),
+		noDigit: noDigit,
+	}
+	go l.run()
+	return l
+}
+
+// run runs the state machine for the lexer.
+func (l *lexer) run() {
+	for l.state = lexText; l.state != nil; {
+		l.state = l.state(l)
+	}
+	close(l.items)
+}
+
+// lexText scans until encountering with "$" or an opening action delimiter, "${".
+func lexText(l *lexer) stateFn {
+Loop:
+	for {
+		switch r := l.next(); r {
+		case '$':
+			l.pos--
+			// emit the text we've found until here, if any.
+			if l.pos > l.start {
+				l.emit(itemText)
+			}
+			l.pos++
+			switch r := l.peek(); {
+			case l.noDigit && unicode.IsDigit(r):
+				// ignore variable starting with digit like $1.
+				l.next()
+				l.emit(itemText)
+			case r == '$':
+				// ignore the previous '$'.
+				l.ignore()
+				l.next()
+				l.emit(itemText)
+			case r == '{':
+				l.next()
+				r2 := l.peek()
+				if l.noDigit && unicode.IsDigit(r2) {
+					// ignore variable starting with digit like ${1}.
+					l.next()
+					l.emit(itemText)
+					break
+				}
+				l.subsDepth++
+				l.emit(itemLeftDelim)
+				return lexSubstitutionOperator
+			case isAlphaNumeric(r):
+				return lexVariable
+			}
+		case eof:
+			break Loop
+		}
+	}
+	// Correctly reached EOF.
+	if l.pos > l.start {
+		l.emit(itemText)
+	}
+	l.emit(itemEOF)
+	return nil
+}
+
+// lexVariable scans a Variable: $Alphanumeric.
+// The $ has been scanned.
+func lexVariable(l *lexer) stateFn {
+	var r rune
+	for {
+		r = l.next()
+		if !isAlphaNumeric(r) {
+			l.backup()
+			break
+		}
+	}
+	if v := l.input[l.start:l.pos]; v == "_" || v == "$_" {
+		return lexText
+	}
+	l.emit(itemVariable)
+	if l.subsDepth > 0 {
+		return lexSubstitutionOperator
+	}
+	return lexText
+}
+
+// lexSubstitutionOperator scans a starting substitution operator (if any) and continues with lexSubstitution
+func lexSubstitutionOperator(l *lexer) stateFn {
+	switch r := l.next(); {
+	case r == '}':
+		l.subsDepth--
+		l.emit(itemRightDelim)
+		return lexText
+	case r == eof || isEndOfLine(r):
+		return l.errorf("closing brace expected")
+	case isAlphaNumeric(r) && strings.HasPrefix(l.input[l.lastPos:], "${"):
+		return lexVariable
+	case r == '+':
+		l.emit(itemPlus)
+	case r == '-':
+		l.emit(itemDash)
+	case r == '=':
+		l.emit(itemEquals)
+	case r == ':':
+		switch l.next() {
+		case '-':
+			l.emit(itemColonDash)
+		case '=':
+			l.emit(itemColonEquals)
+		case '+':
+			l.emit(itemColonPlus)
+		}
+	}
+	return lexSubstitution
+}
+
+// lexSubstitution scans the elements inside substitution delimiters.
+func lexSubstitution(l *lexer) stateFn {
+	switch r := l.next(); {
+	case r == '}':
+		l.subsDepth--
+		l.emit(itemRightDelim)
+		return lexText
+	case r == eof || isEndOfLine(r):
+		return l.errorf("closing brace expected")
+	case isAlphaNumeric(r) && strings.HasPrefix(l.input[l.lastPos:], "${"):
+		fallthrough
+	case r == '$':
+		return lexVariable
+	default:
+		l.emit(itemText)
+	}
+	return lexSubstitution
+}
+
+// isEndOfLine reports whether r is an end-of-line character.
+func isEndOfLine(r rune) bool {
+	return r == '\r' || r == '\n'
+}
+
+// isAlphaNumeric reports whether r is an alphabetic, digit, or underscore.
+func isAlphaNumeric(r rune) bool {
+	return r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r)
+}
diff --git a/vendor/github.com/a8m/envsubst/parse/node.go b/vendor/github.com/a8m/envsubst/parse/node.go
new file mode 100644
index 0000000000..e566d70557
--- /dev/null
+++ b/vendor/github.com/a8m/envsubst/parse/node.go
@@ -0,0 +1,107 @@
+package parse
+
+import (
+	"fmt"
+)
+
+type Node interface {
+	Type() NodeType
+	String() (string, error)
+}
+
+// NodeType identifies the type of a node.
+type NodeType int
+
+// Type returns itself and provides an easy default implementation
+// for embedding in a Node. Embedded in all non-trivial Nodes.
+func (t NodeType) Type() NodeType {
+	return t
+}
+
+const (
+	NodeText NodeType = iota
+	NodeSubstitution
+	NodeVariable
+)
+
+type TextNode struct {
+	NodeType
+	Text string
+}
+
+func NewText(text string) *TextNode {
+	return &TextNode{NodeText, text}
+}
+
+func (t *TextNode) String() (string, error) {
+	return t.Text, nil
+}
+
+type VariableNode struct {
+	NodeType
+	Ident    string
+	Env      Env
+	Restrict *Restrictions
+}
+
+func NewVariable(ident string, env Env, restrict *Restrictions) *VariableNode {
+	return &VariableNode{NodeVariable, ident, env, restrict}
+}
+
+func (t *VariableNode) String() (string, error) {
+	if err := t.validateNoUnset(); err != nil {
+		return "", err
+	}
+	value := t.Env.Get(t.Ident)
+	if err := t.validateNoEmpty(value); err != nil {
+		return "", err
+	}
+	return value, nil
+}
+
+func (t *VariableNode) isSet() bool {
+	return t.Env.Has(t.Ident)
+}
+
+func (t *VariableNode) validateNoUnset() error {
+	if t.Restrict.NoUnset && !t.isSet() {
+		return fmt.Errorf("variable ${%s} not set", t.Ident)
+	}
+	return nil
+}
+
+func (t *VariableNode) validateNoEmpty(value string) error {
+	if t.Restrict.NoEmpty && value == "" && t.isSet() {
+		return fmt.Errorf("variable ${%s} set but empty", t.Ident)
+	}
+	return nil
+}
+
+type SubstitutionNode struct {
+	NodeType
+	ExpType  itemType
+	Variable *VariableNode
+	Default  Node // Default could be variable or text
+}
+
+func (t *SubstitutionNode) String() (string, error) {
+	if t.ExpType >= itemPlus && t.Default != nil {
+		switch t.ExpType {
+		case itemColonDash, itemColonEquals:
+			if s, _ := t.Variable.String(); s != "" {
+				return s, nil
+			}
+			return t.Default.String()
+		case itemPlus, itemColonPlus:
+			if t.Variable.isSet() {
+				return t.Default.String()
+			}
+			return "", nil
+		default:
+			if !t.Variable.isSet() {
+				return t.Default.String()
+			}
+		}
+	}
+	return t.Variable.String()
+}
diff --git a/vendor/github.com/a8m/envsubst/parse/parse.go b/vendor/github.com/a8m/envsubst/parse/parse.go
new file mode 100644
index 0000000000..8b9b427a5d
--- /dev/null
+++ b/vendor/github.com/a8m/envsubst/parse/parse.go
@@ -0,0 +1,189 @@
+// Most of the code in this package taken from golang/text/template/parse
+package parse
+
+import (
+	"errors"
+	"strings"
+)
+
+// A mode value is a set of flags (or 0). They control parser behavior.
+type Mode int
+
+// Mode for parser behaviour
+const (
+	Quick     Mode = iota // stop parsing after first error encoutered and return
+	AllErrors             // report all errors
+)
+
+// The restrictions option controls the parsring restriction.
+type Restrictions struct {
+	NoUnset bool
+	NoEmpty bool
+	NoDigit bool
+}
+
+// Restrictions specifier
+var (
+	Relaxed = &Restrictions{false, false, false}
+	NoEmpty = &Restrictions{false, true, false}
+	NoUnset = &Restrictions{true, false, false}
+	Strict  = &Restrictions{true, true, false}
+)
+
+// Parser type initializer
+type Parser struct {
+	Name     string // name of the processing template
+	Env      Env
+	Restrict *Restrictions
+	Mode     Mode
+	// parsing state;
+	lex       *lexer
+	token     [3]item // three-token lookahead
+	peekCount int
+	nodes     []Node
+}
+
+// New allocates a new Parser with the given name.
+func New(name string, env []string, r *Restrictions) *Parser {
+	return &Parser{
+		Name:     name,
+		Env:      Env(env),
+		Restrict: r,
+	}
+}
+
+// Parse parses the given string.
+func (p *Parser) Parse(text string) (string, error) {
+	p.lex = lex(text, p.Restrict.NoDigit)
+	// Build internal array of all unset or empty vars here
+	var errs []error
+	// clean parse state
+	p.nodes = make([]Node, 0)
+	p.peekCount = 0
+	if err := p.parse(); err != nil {
+		switch p.Mode {
+		case Quick:
+			return "", err
+		case AllErrors:
+			errs = append(errs, err)
+		}
+	}
+	var out string
+	for _, node := range p.nodes {
+		s, err := node.String()
+		if err != nil {
+			switch p.Mode {
+			case Quick:
+				return "", err
+			case AllErrors:
+				errs = append(errs, err)
+			}
+		}
+		out += s
+	}
+	if len(errs) > 0 {
+		var b strings.Builder
+		for i, err := range errs {
+			if i > 0 {
+				b.WriteByte('\n')
+			}
+			b.WriteString(err.Error())
+		}
+		return "", errors.New(b.String())
+	}
+	return out, nil
+}
+
+// parse is the top-level parser for the template.
+// It runs to EOF and return an error if something isn't right.
+func (p *Parser) parse() error {
+Loop:
+	for {
+		switch t := p.next(); t.typ {
+		case itemEOF:
+			break Loop
+		case itemError:
+			return p.errorf(t.val)
+		case itemVariable:
+			varNode := NewVariable(strings.TrimPrefix(t.val, "$"), p.Env, p.Restrict)
+			p.nodes = append(p.nodes, varNode)
+		case itemLeftDelim:
+			if p.peek().typ == itemVariable {
+				n, err := p.action()
+				if err != nil {
+					return err
+				}
+				p.nodes = append(p.nodes, n)
+				continue
+			}
+			fallthrough
+		default:
+			textNode := NewText(t.val)
+			p.nodes = append(p.nodes, textNode)
+		}
+	}
+	return nil
+}
+
+// Parse substitution. first item is a variable.
+func (p *Parser) action() (Node, error) {
+	var expType itemType
+	var defaultNode Node
+	varNode := NewVariable(p.next().val, p.Env, p.Restrict)
+Loop:
+	for {
+		switch t := p.next(); t.typ {
+		case itemRightDelim:
+			break Loop
+		case itemError:
+			return nil, p.errorf(t.val)
+		case itemVariable:
+			defaultNode = NewVariable(strings.TrimPrefix(t.val, "$"), p.Env, p.Restrict)
+		case itemText:
+			n := NewText(t.val)
+		Text:
+			for {
+				switch p.peek().typ {
+				case itemRightDelim, itemError, itemEOF:
+					break Text
+				default:
+					// patch to accept all kind of chars
+					n.Text += p.next().val
+				}
+			}
+			defaultNode = n
+		default:
+			expType = t.typ
+		}
+	}
+	return &SubstitutionNode{NodeSubstitution, expType, varNode, defaultNode}, nil
+}
+
+func (p *Parser) errorf(s string) error {
+	return errors.New(s)
+}
+
+// next returns the next token.
+func (p *Parser) next() item {
+	if p.peekCount > 0 {
+		p.peekCount--
+	} else {
+		p.token[0] = p.lex.nextItem()
+	}
+	return p.token[p.peekCount]
+}
+
+// backup backs the input stream up one token.
+func (p *Parser) backup() {
+	p.peekCount++
+}
+
+// peek returns but does not consume the next token.
+func (p *Parser) peek() item {
+	if p.peekCount > 0 {
+		return p.token[p.peekCount-1]
+	}
+	p.peekCount = 1
+	p.token[0] = p.lex.nextItem()
+	return p.token[0]
+}
diff --git a/vendor/github.com/unrolled/secure/.gitignore b/vendor/github.com/unrolled/secure/.gitignore
new file mode 100644
index 0000000000..f22e73faa5
--- /dev/null
+++ b/vendor/github.com/unrolled/secure/.gitignore
@@ -0,0 +1,27 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+
+*.pem
+.DS_Store
+*.swp
diff --git a/vendor/github.com/unrolled/secure/.golangci.yaml b/vendor/github.com/unrolled/secure/.golangci.yaml
new file mode 100644
index 0000000000..392b4b34dc
--- /dev/null
+++ b/vendor/github.com/unrolled/secure/.golangci.yaml
@@ -0,0 +1,36 @@
+run:
+  timeout: 5m
+
+linters:
+  enable-all: true
+  disable:
+    # Deprecated linters
+    - varcheck
+    - exhaustivestruct
+    - ifshort
+    - structcheck
+    - golint
+    - maligned
+    - interfacer
+    - nosnakecase
+    - deadcode
+    - scopelint
+    - rowserrcheck
+    - sqlclosecheck
+    - structcheck
+    - wastedassign
+    # Ignoring
+    - lll
+    - varnamelen
+    - paralleltest
+    - testpackage
+    - goerr113
+    - exhaustruct
+    - nestif
+    - funlen
+    - goconst
+    - cyclop
+    - gocyclo
+    - gocognit
+    - maintidx
+    - contextcheck
diff --git a/vendor/github.com/unrolled/secure/LICENSE b/vendor/github.com/unrolled/secure/LICENSE
new file mode 100644
index 0000000000..9c62063ec1
--- /dev/null
+++ b/vendor/github.com/unrolled/secure/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Cory Jacobsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/unrolled/secure/Makefile b/vendor/github.com/unrolled/secure/Makefile
new file mode 100644
index 0000000000..4838c65afc
--- /dev/null
+++ b/vendor/github.com/unrolled/secure/Makefile
@@ -0,0 +1,14 @@
+.PHONY: help test ci
+.DEFAULT_GOAL := help
+
+help: ## Displays this help message.
+	@awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST)
+
+test: ## Runs the tests, vetting, and golangci linter.
+	golangci-lint run ./...
+	go test -v -cover -race -count=1 ./...
+	go vet .
+
+ci: ## Runs on the tests and vetting checks (specific for CI).
+	go test -cover -race -count=1 ./...
+	go vet ./...
diff --git a/vendor/github.com/unrolled/secure/README.md b/vendor/github.com/unrolled/secure/README.md
new file mode 100644
index 0000000000..4ec82d5f96
--- /dev/null
+++ b/vendor/github.com/unrolled/secure/README.md
@@ -0,0 +1,424 @@
+# Secure [![GoDoc](https://godoc.org/github.com/unrolled/secure?status.svg)](http://godoc.org/github.com/unrolled/secure) [![Test](https://github.com/unrolled/secure/workflows/tests/badge.svg?branch=v1)](https://github.com/unrolled/secure/actions)
+
+Secure is an HTTP middleware for Go that facilitates some quick security wins. It's a standard net/http [Handler](http://golang.org/pkg/net/http/#Handler), and can be used with many [frameworks](#integration-examples) or directly with Go's net/http package.
+
+## Usage
+
+~~~ go
+// main.go
+package main
+
+import (
+    "net/http"
+
+    "github.com/unrolled/secure"
+)
+
+var myHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    w.Write([]byte("hello world"))
+})
+
+func main() {
+    secureMiddleware := secure.New(secure.Options{
+        AllowedHosts:          []string{"example\\.com", ".*\\.example\\.com"},
+        AllowedHostsAreRegex:  true,
+        HostsProxyHeaders:     []string{"X-Forwarded-Host"},
+        SSLRedirect:           true,
+        SSLHost:               "ssl.example.com",
+        SSLProxyHeaders:       map[string]string{"X-Forwarded-Proto": "https"},
+        STSSeconds:            31536000,
+        STSIncludeSubdomains:  true,
+        STSPreload:            true,
+        FrameDeny:             true,
+        ContentTypeNosniff:    true,
+        BrowserXssFilter:      true,
+        ContentSecurityPolicy: "script-src $NONCE",
+    })
+
+    app := secureMiddleware.Handler(myHandler)
+    http.ListenAndServe("127.0.0.1:3000", app)
+}
+~~~
+
+Be sure to include the Secure middleware as close to the top (beginning) as possible (but after logging and recovery). It's best to do the allowed hosts and SSL check before anything else.
+
+The above example will only allow requests with a host name of 'example.com', or 'ssl.example.com'. Also if the request is not HTTPS, it will be redirected to HTTPS with the host name of 'ssl.example.com'.
+Once those requirements are satisfied, it will add the following headers:
+~~~ go
+Strict-Transport-Security: 31536000; includeSubdomains; preload
+X-Frame-Options: DENY
+X-Content-Type-Options: nosniff
+X-XSS-Protection: 1; mode=block
+Content-Security-Policy: script-src 'nonce-a2ZobGFoZg=='
+~~~
+
+### Set the `IsDevelopment` option to `true` when developing!
+When `IsDevelopment` is true, the AllowedHosts, SSLRedirect, and STS header will not be in effect. This allows you to work in development/test mode and not have any annoying redirects to HTTPS (ie. development can happen on HTTP), or block `localhost` has a bad host.
+
+### Available options
+Secure comes with a variety of configuration options (Note: these are not the default option values. See the defaults below.):
+
+~~~ go
+// ...
+s := secure.New(secure.Options{
+    AllowedHosts: []string{"ssl.example.com"}, // AllowedHosts is a list of fully qualified domain names that are allowed. Default is empty list, which allows any and all host names.
+    AllowedHostsAreRegex: false,  // AllowedHostsAreRegex determines, if the provided AllowedHosts slice contains valid regular expressions. Default is false.
+    AllowRequestFunc: nil, // AllowRequestFunc is a custom function type that allows you to determine if the request should proceed or not based on your own custom logic. Default is nil.
+    HostsProxyHeaders: []string{"X-Forwarded-Hosts"}, // HostsProxyHeaders is a set of header keys that may hold a proxied hostname value for the request.
+    SSLRedirect: true, // If SSLRedirect is set to true, then only allow HTTPS requests. Default is false.
+    SSLTemporaryRedirect: false, // If SSLTemporaryRedirect is true, the a 302 will be used while redirecting. Default is false (301).
+    SSLHost: "ssl.example.com", // SSLHost is the host name that is used to redirect HTTP requests to HTTPS. Default is "", which indicates to use the same host.
+    SSLHostFunc: nil, // SSLHostFunc is a function pointer, the return value of the function is the host name that has same functionality as `SSHost`. Default is nil. If SSLHostFunc is nil, the `SSLHost` option will be used.
+    SSLProxyHeaders: map[string]string{"X-Forwarded-Proto": "https"}, // SSLProxyHeaders is set of header keys with associated values that would indicate a valid HTTPS request. Useful when using Nginx: `map[string]string{"X-Forwarded-Proto": "https"}`. Default is blank map.
+    STSSeconds: 31536000, // STSSeconds is the max-age of the Strict-Transport-Security header. Default is 0, which would NOT include the header.
+    STSIncludeSubdomains: true, // If STSIncludeSubdomains is set to true, the `includeSubdomains` will be appended to the Strict-Transport-Security header. Default is false.
+    STSPreload: true, // If STSPreload is set to true, the `preload` flag will be appended to the Strict-Transport-Security header. Default is false.
+    ForceSTSHeader: false, // STS header is only included when the connection is HTTPS. If you want to force it to always be added, set to true. `IsDevelopment` still overrides this. Default is false.
+    FrameDeny: true, // If FrameDeny is set to true, adds the X-Frame-Options header with the value of `DENY`. Default is false.
+    CustomFrameOptionsValue: "SAMEORIGIN", // CustomFrameOptionsValue allows the X-Frame-Options header value to be set with a custom value. This overrides the FrameDeny option. Default is "".
+    ContentTypeNosniff: true, // If ContentTypeNosniff is true, adds the X-Content-Type-Options header with the value `nosniff`. Default is false.
+    BrowserXssFilter: true, // If BrowserXssFilter is true, adds the X-XSS-Protection header with the value `1; mode=block`. Default is false.
+    CustomBrowserXssValue: "1; report=https://example.com/xss-report", // CustomBrowserXssValue allows the X-XSS-Protection header value to be set with a custom value. This overrides the BrowserXssFilter option. Default is "".
+    ContentSecurityPolicy: "default-src 'self'", // ContentSecurityPolicy allows the Content-Security-Policy header value to be set with a custom value. Default is "". Passing a template string will replace `$NONCE` with a dynamic nonce value of 16 bytes for each request which can be later retrieved using the Nonce function.
+    ReferrerPolicy: "same-origin", // ReferrerPolicy allows the Referrer-Policy header with the value to be set with a custom value. Default is "".
+    FeaturePolicy: "vibrate 'none';", // Deprecated: this header has been renamed to PermissionsPolicy. FeaturePolicy allows the Feature-Policy header with the value to be set with a custom value. Default is "".
+    PermissionsPolicy: "fullscreen=(), geolocation=()", // PermissionsPolicy allows the Permissions-Policy header with the value to be set with a custom value. Default is "".
+    CrossOriginOpenerPolicy: "same-origin", // CrossOriginOpenerPolicy allows the Cross-Origin-Opener-Policy header with the value to be set with a custom value. Default is "".
+
+    IsDevelopment: true, // This will cause the AllowedHosts, SSLRedirect, and STSSeconds/STSIncludeSubdomains options to be ignored during development. When deploying to production, be sure to set this to false.
+})
+// ...
+~~~
+
+### Default options
+These are the preset options for Secure:
+
+~~~ go
+s := secure.New()
+
+// Is the same as the default configuration options:
+
+l := secure.New(secure.Options{
+    AllowedHosts: []string,
+    AllowedHostsAreRegex: false,
+    AllowRequestFunc: nil,
+    HostsProxyHeaders: []string,
+    SSLRedirect: false,
+    SSLTemporaryRedirect: false,
+    SSLHost: "",
+    SSLProxyHeaders: map[string]string{},
+    STSSeconds: 0,
+    STSIncludeSubdomains: false,
+    STSPreload: false,
+    ForceSTSHeader: false,
+    FrameDeny: false,
+    CustomFrameOptionsValue: "",
+    ContentTypeNosniff: false,
+    BrowserXssFilter: false,
+    ContentSecurityPolicy: "",
+    PublicKey: "",
+    ReferrerPolicy: "",
+    FeaturePolicy: "",
+    PermissionsPolicy: "",
+    CrossOriginOpenerPolicy: "",
+    IsDevelopment: false,
+})
+~~~
+The default bad host handler returns the following error:
+~~~ go
+http.Error(w, "Bad Host", http.StatusInternalServerError)
+~~~
+Call `secure.SetBadHostHandler` to set your own custom handler.
+
+The default bad request handler returns the following error:
+~~~ go
+http.Error(w, "Bad Request", http.StatusBadRequest)
+~~~
+Call `secure.SetBadRequestHandler` to set your own custom handler.
+
+### Allow Request Function
+Secure allows you to set a custom function (`func(r *http.Request) bool`) for the `AllowRequestFunc` option. You can use this function as a custom filter to allow the request to continue or simply reject it. This can be handy if you need to do any dynamic filtering on any of the request properties. It should be noted that this function will be called on every request, so be sure to make your checks quick and not relying on time consuming external calls (or you will be slowing down all requests). See above on how to set a custom handler for the rejected requests.
+
+### Redirecting HTTP to HTTPS
+If you want to redirect all HTTP requests to HTTPS, you can use the following example.
+
+~~~ go
+// main.go
+package main
+
+import (
+    "log"
+    "net/http"
+
+    "github.com/unrolled/secure"
+)
+
+var myHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+    w.Write([]byte("hello world"))
+})
+
+func main() {
+    secureMiddleware := secure.New(secure.Options{
+        SSLRedirect: true,
+        SSLHost:     "localhost:8443", // This is optional in production. The default behavior is to just redirect the request to the HTTPS protocol. Example: http://github.com/some_page would be redirected to https://github.com/some_page.
+    })
+
+    app := secureMiddleware.Handler(myHandler)
+
+    // HTTP
+    go func() {
+        log.Fatal(http.ListenAndServe(":8080", app))
+    }()
+
+    // HTTPS
+    // To generate a development cert and key, run the following from your *nix terminal:
+    // go run $GOROOT/src/crypto/tls/generate_cert.go --host="localhost"
+    log.Fatal(http.ListenAndServeTLS(":8443", "cert.pem", "key.pem", app))
+}
+~~~
+
+### Strict Transport Security
+The STS header will only be sent on verified HTTPS connections (and when `IsDevelopment` is false). Be sure to set the `SSLProxyHeaders` option if your application is behind a proxy to ensure the proper behavior. If you need the STS header for all HTTP and HTTPS requests (which you [shouldn't](http://tools.ietf.org/html/rfc6797#section-7.2)), you can use the `ForceSTSHeader` option. Note that if `IsDevelopment` is true, it will still disable this header even when `ForceSTSHeader` is set to true.
+
+* The `preload` flag is required for domain inclusion in Chrome's [preload](https://hstspreload.appspot.com/) list.
+
+### Content Security Policy
+You can utilize the CSP Builder to create your policies:
+
+~~~ go
+import (
+	"github.com/unrolled/secure"
+	"github.com/unrolled/secure/cspbuilder"
+)
+
+cspBuilder := cspbuilder.Builder{
+	Directives: map[string][]string{
+		cspbuilder.DefaultSrc: {"self"},
+		cspbuilder.ScriptSrc:  {"self", "www.google-analytics.com"},
+		cspbuilder.ImgSrc:     {"*"},
+	},
+}
+
+opt := secure.Options{
+	ContentSecurityPolicy: cspBuilder.MustBuild(),
+}
+~~~
+
+## Integration examples
+
+### [chi](https://github.com/pressly/chi)
+~~~ go
+// main.go
+package main
+
+import (
+    "net/http"
+
+    "github.com/pressly/chi"
+    "github.com/unrolled/secure"
+)
+
+func main() {
+    secureMiddleware := secure.New(secure.Options{
+        FrameDeny: true,
+    })
+
+    r := chi.NewRouter()
+    r.Use(secureMiddleware.Handler)
+
+    r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+        w.Write([]byte("X-Frame-Options header is now `DENY`."))
+    })
+
+    http.ListenAndServe("127.0.0.1:3000", r)
+}
+~~~
+
+### [Echo](https://github.com/labstack/echo)
+~~~ go
+// main.go
+package main
+
+import (
+    "net/http"
+
+    "github.com/labstack/echo"
+    "github.com/unrolled/secure"
+)
+
+func main() {
+    secureMiddleware := secure.New(secure.Options{
+        FrameDeny: true,
+    })
+
+    e := echo.New()
+    e.GET("/", func(c echo.Context) error {
+        return c.String(http.StatusOK, "X-Frame-Options header is now `DENY`.")
+    })
+
+    e.Use(echo.WrapMiddleware(secureMiddleware.Handler))
+    e.Logger.Fatal(e.Start("127.0.0.1:3000"))
+}
+~~~
+
+### [Gin](https://github.com/gin-gonic/gin)
+~~~ go
+// main.go
+package main
+
+import (
+    "github.com/gin-gonic/gin"
+    "github.com/unrolled/secure"
+)
+
+func main() {
+    secureMiddleware := secure.New(secure.Options{
+        FrameDeny: true,
+    })
+    secureFunc := func() gin.HandlerFunc {
+        return func(c *gin.Context) {
+            err := secureMiddleware.Process(c.Writer, c.Request)
+
+            // If there was an error, do not continue.
+            if err != nil {
+                c.Abort()
+                return
+            }
+
+            // Avoid header rewrite if response is a redirection.
+            if status := c.Writer.Status(); status > 300 && status < 399 {
+                c.Abort()
+            }
+        }
+    }()
+
+    router := gin.Default()
+    router.Use(secureFunc)
+
+    router.GET("/", func(c *gin.Context) {
+        c.String(200, "X-Frame-Options header is now `DENY`.")
+    })
+
+    router.Run("127.0.0.1:3000")
+}
+~~~
+
+### [Goji](https://github.com/zenazn/goji)
+~~~ go
+// main.go
+package main
+
+import (
+    "net/http"
+
+    "github.com/unrolled/secure"
+    "github.com/zenazn/goji"
+    "github.com/zenazn/goji/web"
+)
+
+func main() {
+    secureMiddleware := secure.New(secure.Options{
+        FrameDeny: true,
+    })
+
+    goji.Get("/", func(c web.C, w http.ResponseWriter, req *http.Request) {
+        w.Write([]byte("X-Frame-Options header is now `DENY`."))
+    })
+    goji.Use(secureMiddleware.Handler)
+    goji.Serve() // Defaults to ":8000".
+}
+~~~
+
+### [Iris](https://github.com/kataras/iris)
+~~~ go
+//main.go
+package main
+
+import (
+    "github.com/kataras/iris/v12"
+    "github.com/unrolled/secure"
+)
+
+func main() {
+    app := iris.New()
+
+    secureMiddleware := secure.New(secure.Options{
+        FrameDeny: true,
+    })
+
+    app.Use(iris.FromStd(secureMiddleware.HandlerFuncWithNext))
+    // Identical to:
+    // app.Use(func(ctx iris.Context) {
+    //     err := secureMiddleware.Process(ctx.ResponseWriter(), ctx.Request())
+    //
+    //     // If there was an error, do not continue.
+    //     if err != nil {
+    //         return
+    //     }
+    //
+    //     ctx.Next()
+    // })
+
+    app.Get("/home", func(ctx iris.Context) {
+        ctx.Writef("X-Frame-Options header is now `%s`.", "DENY")
+    })
+
+    app.Listen(":8080")
+}
+~~~
+
+### [Mux](https://github.com/gorilla/mux)
+~~~ go
+//main.go
+package main
+
+import (
+    "log"
+    "net/http"
+
+    "github.com/gorilla/mux"
+    "github.com/unrolled/secure"
+)
+
+func main() {
+    secureMiddleware := secure.New(secure.Options{
+        FrameDeny: true,
+    })
+
+    r := mux.NewRouter()
+    r.Use(secureMiddleware.Handler)
+    http.Handle("/", r)
+    log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", 8080), nil))
+}
+~~~
+
+### [Negroni](https://github.com/urfave/negroni)
+Note this implementation has a special helper function called `HandlerFuncWithNext`.
+~~~ go
+// main.go
+package main
+
+import (
+    "net/http"
+
+    "github.com/urfave/negroni"
+    "github.com/unrolled/secure"
+)
+
+func main() {
+    mux := http.NewServeMux()
+    mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
+        w.Write([]byte("X-Frame-Options header is now `DENY`."))
+    })
+
+    secureMiddleware := secure.New(secure.Options{
+        FrameDeny: true,
+    })
+
+    n := negroni.Classic()
+    n.Use(negroni.HandlerFunc(secureMiddleware.HandlerFuncWithNext))
+    n.UseHandler(mux)
+
+    n.Run("127.0.0.1:3000")
+}
+~~~
diff --git a/vendor/github.com/unrolled/secure/csp.go b/vendor/github.com/unrolled/secure/csp.go
new file mode 100644
index 0000000000..948358f0b8
--- /dev/null
+++ b/vendor/github.com/unrolled/secure/csp.go
@@ -0,0 +1,45 @@
+package secure
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/base64"
+	"io"
+	"net/http"
+)
+
+type key int
+
+const cspNonceKey key = iota
+
+// CSPNonce returns the nonce value associated with the present request. If no nonce has been generated it returns an empty string.
+func CSPNonce(c context.Context) string {
+	if val, ok := c.Value(cspNonceKey).(string); ok {
+		return val
+	}
+
+	return ""
+}
+
+// WithCSPNonce returns a context derived from ctx containing the given nonce as a value.
+//
+// This is intended for testing or more advanced use-cases;
+// For ordinary HTTP handlers, clients can rely on this package's middleware to populate the CSP nonce in the context.
+func WithCSPNonce(ctx context.Context, nonce string) context.Context {
+	return context.WithValue(ctx, cspNonceKey, nonce)
+}
+
+func withCSPNonce(r *http.Request, nonce string) *http.Request {
+	return r.WithContext(WithCSPNonce(r.Context(), nonce))
+}
+
+func cspRandNonce() string {
+	var buf [cspNonceSize]byte
+
+	_, err := io.ReadFull(rand.Reader, buf[:])
+	if err != nil {
+		panic("CSP Nonce rand.Reader failed" + err.Error())
+	}
+
+	return base64.RawStdEncoding.EncodeToString(buf[:])
+}
diff --git a/vendor/github.com/unrolled/secure/cspbuilder/builder.go b/vendor/github.com/unrolled/secure/cspbuilder/builder.go
new file mode 100644
index 0000000000..595c0f0d26
--- /dev/null
+++ b/vendor/github.com/unrolled/secure/cspbuilder/builder.go
@@ -0,0 +1,116 @@
+package cspbuilder
+
+import (
+	"sort"
+	"strings"
+)
+
+const (
+	// Fetch Directives.
+	ChildSrc      = "child-src"
+	ConnectSrc    = "connect-src"
+	DefaultSrc    = "default-src"
+	FontSrc       = "font-src"
+	FrameSrc      = "frame-src"
+	ImgSrc        = "img-src"
+	ManifestSrc   = "manifest-src"
+	MediaSrc      = "media-src"
+	ObjectSrc     = "object-src"
+	PrefetchSrc   = "prefetch-src"
+	ScriptSrc     = "script-src"
+	ScriptSrcAttr = "script-src-attr"
+	ScriptSrcElem = "script-src-elem"
+	StyleSrc      = "style-src"
+	StyleSrcAttr  = "style-src-attr"
+	StyleSrcElem  = "style-src-elem"
+	WorkerSrc     = "worker-src"
+
+	// Document Directives.
+	BaseURI = "base-uri"
+	Sandbox = "sandbox"
+
+	// Navigation directives.
+	FormAction     = "form-action"
+	FrameAncestors = "frame-ancestors"
+	NavigateTo     = "navigate-to"
+
+	// Reporting directives.
+	ReportURI = "report-uri"
+	ReportTo  = "report-to"
+
+	// Other directives.
+	RequireTrustedTypesFor  = "require-trusted-types-for"
+	TrustedTypes            = "trusted-types"
+	UpgradeInsecureRequests = "upgrade-insecure-requests"
+)
+
+type Builder struct {
+	Directives map[string]([]string)
+}
+
+// MustBuild is like Build but panics if an error occurs.
+func (builder *Builder) MustBuild() string {
+	policy, err := builder.Build()
+	if err != nil {
+		panic(err)
+	}
+
+	return policy
+}
+
+// Build creates a content security policy string from the specified directives.
+// If any directive contains invalid values, an error is returned instead.
+func (builder *Builder) Build() (string, error) {
+	var sb strings.Builder
+	var keys []string
+	for k := range builder.Directives {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, directive := range keys {
+		if sb.Len() > 0 {
+			sb.WriteString("; ")
+		}
+
+		switch directive {
+		case Sandbox:
+			err := buildDirectiveSandbox(&sb, builder.Directives[directive])
+			if err != nil {
+				return "", err
+			}
+		case FrameAncestors:
+			err := buildDirectiveFrameAncestors(&sb, builder.Directives[directive])
+			if err != nil {
+				return "", err
+			}
+		case ReportTo:
+			err := buildDirectiveReportTo(&sb, builder.Directives[directive])
+			if err != nil {
+				return "", err
+			}
+		case RequireTrustedTypesFor:
+			err := buildDirectiveRequireTrustedTypesFor(&sb, builder.Directives[directive])
+			if err != nil {
+				return "", err
+			}
+		case TrustedTypes:
+			err := buildDirectiveTrustedTypes(&sb, builder.Directives[directive])
+			if err != nil {
+				return "", err
+			}
+		case UpgradeInsecureRequests:
+			err := buildDirectiveUpgradeInsecureRequests(&sb, builder.Directives[directive])
+			if err != nil {
+				return "", err
+			}
+		default:
+			// no special handling of directive values needed
+			err := buildDirectiveDefault(&sb, directive, builder.Directives[directive])
+			if err != nil {
+				return "", err
+			}
+		}
+	}
+
+	return sb.String(), nil
+}
diff --git a/vendor/github.com/unrolled/secure/cspbuilder/directive_builder.go b/vendor/github.com/unrolled/secure/cspbuilder/directive_builder.go
new file mode 100644
index 0000000000..9082082767
--- /dev/null
+++ b/vendor/github.com/unrolled/secure/cspbuilder/directive_builder.go
@@ -0,0 +1,154 @@
+package cspbuilder
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+func buildDirectiveSandbox(sb *strings.Builder, values []string) error {
+	if len(values) == 0 {
+		sb.WriteString(Sandbox)
+
+		return nil
+	}
+
+	if len(values) > 1 {
+		return fmt.Errorf("too many values set for directive %s", Sandbox)
+	}
+
+	sandboxVal := values[0]
+
+	switch sandboxVal {
+	case "allow-downloads-without-user-activation":
+	case "allow-downloads":
+	case "allow-forms":
+	case "allow-modals":
+	case "allow-orientation-lock":
+	case "allow-pointer-lock":
+	case "allow-popups-to-escape-sandbox":
+	case "allow-popups":
+	case "allow-presentation":
+	case "allow-same-origin":
+	case "allow-scripts":
+	case "allow-storage-access-by-user-activation":
+	case "allow-top-navigation-by-user-activation":
+	case "allow-top-navigation-to-custom-protocols":
+	case "allow-top-navigation":
+	default:
+		return fmt.Errorf("unallowed value %s for directive %s", sandboxVal, Sandbox)
+	}
+
+	sb.WriteString(Sandbox)
+	sb.WriteString(" ")
+	sb.WriteString(sandboxVal)
+
+	return nil
+}
+
+func buildDirectiveFrameAncestors(sb *strings.Builder, values []string) error {
+	if len(values) == 0 {
+		return fmt.Errorf("no values set for directive %s", FrameAncestors)
+	}
+
+	sb.WriteString(FrameAncestors)
+
+	for _, val := range values {
+		if strings.HasPrefix(val, "'") && strings.HasSuffix(val, "'") {
+			switch val {
+			case "'self'":
+			case "'none'":
+			default:
+				return fmt.Errorf("unallowed value %s for directive %s", val, FrameAncestors)
+			}
+		}
+
+		sb.WriteString(" ")
+		sb.WriteString(val)
+	}
+
+	return nil
+}
+
+func buildDirectiveReportTo(sb *strings.Builder, values []string) error {
+	if len(values) == 0 {
+		return fmt.Errorf("no values set for directive %s", ReportTo)
+	}
+
+	if len(values) > 1 {
+		return fmt.Errorf("too many values set for directive %s", ReportTo)
+	}
+
+	sb.WriteString(ReportTo)
+	sb.WriteString(" ")
+	sb.WriteString(values[0])
+
+	return nil
+}
+
+func buildDirectiveRequireTrustedTypesFor(sb *strings.Builder, values []string) error {
+	const allowedValue = "'script'"
+	if len(values) != 1 || values[0] != allowedValue {
+		return fmt.Errorf("value for directive %s must be %s", RequireTrustedTypesFor, allowedValue)
+	}
+
+	sb.WriteString(RequireTrustedTypesFor)
+	sb.WriteString(" ")
+	sb.WriteString(values[0])
+
+	return nil
+}
+
+func buildDirectiveTrustedTypes(sb *strings.Builder, values []string) error {
+	sb.WriteString(TrustedTypes)
+
+	for _, val := range values {
+		sb.WriteString(" ")
+
+		switch val {
+		case "'none'":
+			if len(values) != 1 {
+				return fmt.Errorf("'none' must be only value for directive %s", TrustedTypes)
+			}
+		case "'allow-duplicates'":
+			// nothing to do
+		case "*":
+			// nothing to do
+		default:
+			// value is policy name
+			regex := regexp.MustCompile(`^[A-Za-z0-9\-#=_/@\.%]*$`)
+			if !regex.MatchString(val) {
+				return fmt.Errorf("unallowed value %s for directive %s", val, TrustedTypes)
+			}
+		}
+
+		sb.WriteString(val)
+	}
+
+	return nil
+}
+
+func buildDirectiveUpgradeInsecureRequests(sb *strings.Builder, values []string) error {
+	if len(values) != 0 {
+		return fmt.Errorf("directive %s must not contain values", UpgradeInsecureRequests)
+	}
+
+	sb.WriteString(UpgradeInsecureRequests)
+
+	return nil
+}
+
+func buildDirectiveDefault(sb *strings.Builder, directive string, values []string) error {
+	if len(values) == 0 {
+		return fmt.Errorf("no values set for directive %s", directive)
+	}
+
+	sb.WriteString(directive)
+
+	for i := range values {
+		sb.WriteString(" ")
+		sb.WriteString(values[i])
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/unrolled/secure/doc.go b/vendor/github.com/unrolled/secure/doc.go
new file mode 100644
index 0000000000..371bf0bdbe
--- /dev/null
+++ b/vendor/github.com/unrolled/secure/doc.go
@@ -0,0 +1,26 @@
+/*
+Package secure is an HTTP middleware for Go that facilitates some quick security wins.
+
+	package main
+
+	import (
+	    "net/http"
+
+	    "github.com/unrolled/secure"
+	)
+
+	var myHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	    w.Write([]byte("hello world"))
+	})
+
+	func main() {
+	    secureMiddleware := secure.New(secure.Options{
+	        AllowedHosts: []string{"www.example.com", "sub.example.com"},
+	        SSLRedirect:  true,
+	    })
+
+	    app := secureMiddleware.Handler(myHandler)
+	    http.ListenAndServe("127.0.0.1:3000", app)
+	}
+*/
+package secure
diff --git a/vendor/github.com/unrolled/secure/secure.go b/vendor/github.com/unrolled/secure/secure.go
new file mode 100644
index 0000000000..0efcc617e4
--- /dev/null
+++ b/vendor/github.com/unrolled/secure/secure.go
@@ -0,0 +1,517 @@
+package secure
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"regexp"
+	"strings"
+)
+
+type secureCtxKey string
+
+const (
+	stsHeader               = "Strict-Transport-Security"
+	stsSubdomainString      = "; includeSubDomains"
+	stsPreloadString        = "; preload"
+	frameOptionsHeader      = "X-Frame-Options"
+	frameOptionsValue       = "DENY"
+	contentTypeHeader       = "X-Content-Type-Options"
+	contentTypeValue        = "nosniff"
+	xssProtectionHeader     = "X-XSS-Protection"
+	xssProtectionValue      = "1; mode=block"
+	cspHeader               = "Content-Security-Policy"
+	cspReportOnlyHeader     = "Content-Security-Policy-Report-Only"
+	hpkpHeader              = "Public-Key-Pins"
+	referrerPolicyHeader    = "Referrer-Policy"
+	featurePolicyHeader     = "Feature-Policy"
+	permissionsPolicyHeader = "Permissions-Policy"
+	coopHeader              = "Cross-Origin-Opener-Policy"
+
+	ctxDefaultSecureHeaderKey = secureCtxKey("SecureResponseHeader")
+	cspNonceSize              = 16
+)
+
+// SSLHostFunc is a custom function type that can be used to dynamically set the SSL host of a request.
+type SSLHostFunc func(host string) (newHost string)
+
+// AllowRequestFunc is a custom function type that can be used to dynamically determine if a request should proceed or not.
+type AllowRequestFunc func(r *http.Request) bool
+
+func defaultBadHostHandler(w http.ResponseWriter, _ *http.Request) {
+	http.Error(w, "Bad Host", http.StatusInternalServerError)
+}
+
+func defaultBadRequestHandler(w http.ResponseWriter, _ *http.Request) {
+	http.Error(w, "Bad Request", http.StatusBadRequest)
+}
+
+// Options is a struct for specifying configuration options for the secure.Secure middleware.
+type Options struct {
+	// If BrowserXssFilter is true, adds the X-XSS-Protection header with the value `1; mode=block`. Default is false.
+	BrowserXssFilter bool //nolint:stylecheck,revive
+	// If ContentTypeNosniff is true, adds the X-Content-Type-Options header with the value `nosniff`. Default is false.
+	ContentTypeNosniff bool
+	// If ForceSTSHeader is set to true, the STS header will be added even when the connection is HTTP. Default is false.
+	ForceSTSHeader bool
+	// If FrameDeny is set to true, adds the X-Frame-Options header with the value of `DENY`. Default is false.
+	FrameDeny bool
+	// When developing, the AllowedHosts, SSL, and STS options can cause some unwanted effects. Usually testing happens on http, not https, and on localhost, not your production domain... so set this to true for dev environment.
+	// If you would like your development environment to mimic production with complete Host blocking, SSL redirects, and STS headers, leave this as false. Default if false.
+	IsDevelopment bool
+	// nonceEnabled is used internally for dynamic nouces.
+	nonceEnabled bool
+	// If SSLRedirect is set to true, then only allow https requests. Default is false.
+	SSLRedirect bool
+	// If SSLForceHost is true and SSLHost is set, requests will be forced to use SSLHost even the ones that are already using SSL. Default is false.
+	SSLForceHost bool
+	// If SSLTemporaryRedirect is true, the a 302 will be used while redirecting. Default is false (301).
+	SSLTemporaryRedirect bool
+	// If STSIncludeSubdomains is set to true, the `includeSubdomains` will be appended to the Strict-Transport-Security header. Default is false.
+	STSIncludeSubdomains bool
+	// If STSPreload is set to true, the `preload` flag will be appended to the Strict-Transport-Security header. Default is false.
+	STSPreload bool
+	// ContentSecurityPolicy allows the Content-Security-Policy header value to be set with a custom value. Default is "".
+	ContentSecurityPolicy string
+	// ContentSecurityPolicyReportOnly allows the Content-Security-Policy-Report-Only header value to be set with a custom value. Default is "".
+	ContentSecurityPolicyReportOnly string
+	// CustomBrowserXssValue allows the X-XSS-Protection header value to be set with a custom value. This overrides the BrowserXssFilter option. Default is "".
+	CustomBrowserXssValue string //nolint:stylecheck,revive
+	// Passing a template string will replace `$NONCE` with a dynamic nonce value of 16 bytes for each request which can be later retrieved using the Nonce function.
+	// Eg: script-src $NONCE -> script-src 'nonce-a2ZobGFoZg=='
+	// CustomFrameOptionsValue allows the X-Frame-Options header value to be set with a custom value. This overrides the FrameDeny option. Default is "".
+	CustomFrameOptionsValue string
+	// ReferrerPolicy allows sites to control when browsers will pass the Referer header to other sites. Default is "".
+	ReferrerPolicy string
+	// FeaturePolicy allows to selectively enable and disable use of various browser features and APIs. Default is "".
+	// Deprecated: This header has been renamed to Permissions-Policy.
+	FeaturePolicy string
+	// PermissionsPolicy allows to selectively enable and disable use of various browser features and APIs. Default is "".
+	PermissionsPolicy string
+	// CrossOriginOpenerPolicy allows you to ensure a top-level document does not share a browsing context group with cross-origin documents. Default is "".
+	// Reference: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cross-Origin-Opener-Policy
+	CrossOriginOpenerPolicy string
+	// SSLHost is the host name that is used to redirect http requests to https. Default is "", which indicates to use the same host.
+	SSLHost string
+	// AllowedHosts is a slice of fully qualified domain names that are allowed. Default is an empty slice, which allows any and all host names.
+	AllowedHosts []string
+	// AllowedHostsAreRegex determines, if the provided `AllowedHosts` slice contains valid regular expressions. If this flag is set to true, every request's host will be checked against these expressions. Default is false.
+	AllowedHostsAreRegex bool
+	// AllowRequestFunc is a custom function that allows you to determine if the request should proceed or not based on your own custom logic. Default is nil.
+	AllowRequestFunc AllowRequestFunc
+	// HostsProxyHeaders is a set of header keys that may hold a proxied hostname value for the request.
+	HostsProxyHeaders []string
+	// SSLHostFunc is a function pointer, the return value of the function is the host name that has same functionality as `SSHost`. Default is nil.
+	// If SSLHostFunc is nil, the `SSLHost` option will be used.
+	SSLHostFunc *SSLHostFunc
+	// SSLProxyHeaders is set of header keys with associated values that would indicate a valid https request. Useful when using Nginx: `map[string]string{"X-Forwarded-Proto": "https"}`. Default is blank map.
+	SSLProxyHeaders map[string]string
+	// STSSeconds is the max-age of the Strict-Transport-Security header. Default is 0, which would NOT include the header.
+	STSSeconds int64
+	// SecureContextKey allows a custom key to be specified for context storage.
+	SecureContextKey string
+}
+
+// Secure is a middleware that helps setup a few basic security features. A single secure.Options struct can be
+// provided to configure which features should be enabled, and the ability to override a few of the default values.
+type Secure struct {
+	// Customize Secure with an Options struct.
+	opt Options
+
+	// badHostHandler is the handler used when an incorrect host is passed in.
+	badHostHandler http.Handler
+
+	// badRequestHandler is the handler used when the AllowRequestFunc rejects a request.
+	badRequestHandler http.Handler
+
+	// cRegexAllowedHosts saves the compiled regular expressions of the AllowedHosts
+	// option for subsequent use in processRequest
+	cRegexAllowedHosts []*regexp.Regexp
+
+	// ctxSecureHeaderKey is the key used for context storage for request modification.
+	ctxSecureHeaderKey secureCtxKey
+}
+
+// New constructs a new Secure instance with the supplied options.
+func New(options ...Options) *Secure {
+	var o Options
+	if len(options) == 0 {
+		o = Options{}
+	} else {
+		o = options[0]
+	}
+
+	o.ContentSecurityPolicy = strings.ReplaceAll(o.ContentSecurityPolicy, "$NONCE", "'nonce-%[1]s'")
+	o.ContentSecurityPolicyReportOnly = strings.ReplaceAll(o.ContentSecurityPolicyReportOnly, "$NONCE", "'nonce-%[1]s'")
+
+	o.nonceEnabled = strings.Contains(o.ContentSecurityPolicy, "%[1]s") || strings.Contains(o.ContentSecurityPolicyReportOnly, "%[1]s")
+
+	s := &Secure{
+		opt:               o,
+		badHostHandler:    http.HandlerFunc(defaultBadHostHandler),
+		badRequestHandler: http.HandlerFunc(defaultBadRequestHandler),
+	}
+
+	if s.opt.AllowedHostsAreRegex {
+		// Test for invalid regular expressions in AllowedHosts
+		for _, allowedHost := range o.AllowedHosts {
+			regex, err := regexp.Compile(fmt.Sprintf("^%s$", allowedHost))
+			if err != nil {
+				panic(fmt.Sprintf("Error parsing AllowedHost: %s", err))
+			}
+
+			s.cRegexAllowedHosts = append(s.cRegexAllowedHosts, regex)
+		}
+	}
+
+	s.ctxSecureHeaderKey = ctxDefaultSecureHeaderKey
+	if len(s.opt.SecureContextKey) > 0 {
+		s.ctxSecureHeaderKey = secureCtxKey(s.opt.SecureContextKey)
+	}
+
+	return s
+}
+
+// SetBadHostHandler sets the handler to call when secure rejects the host name.
+func (s *Secure) SetBadHostHandler(handler http.Handler) {
+	s.badHostHandler = handler
+}
+
+// SetBadRequestHandler sets the handler to call when the AllowRequestFunc rejects a request.
+func (s *Secure) SetBadRequestHandler(handler http.Handler) {
+	s.badRequestHandler = handler
+}
+
+// Handler implements the http.HandlerFunc for integration with the standard net/http lib.
+func (s *Secure) Handler(h http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Let secure process the request. If it returns an error,
+		// that indicates the request should not continue.
+		responseHeader, r, err := s.processRequest(w, r)
+		addResponseHeaders(responseHeader, w)
+
+		// If there was an error, do not continue.
+		if err != nil {
+			return
+		}
+
+		h.ServeHTTP(w, r)
+	})
+}
+
+// HandlerForRequestOnly implements the http.HandlerFunc for integration with the standard net/http lib.
+// Note that this is for requests only and will not write any headers.
+func (s *Secure) HandlerForRequestOnly(h http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Let secure process the request. If it returns an error,
+		// that indicates the request should not continue.
+		responseHeader, r, err := s.processRequest(w, r)
+		if err != nil {
+			return
+		}
+
+		// Save response headers in the request context.
+		ctx := context.WithValue(r.Context(), s.ctxSecureHeaderKey, responseHeader)
+
+		// No headers will be written to the ResponseWriter.
+		h.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+// HandlerFuncWithNext is a special implementation for Negroni, but could be used elsewhere.
+func (s *Secure) HandlerFuncWithNext(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
+	// Let secure process the request. If it returns an error,
+	// that indicates the request should not continue.
+	responseHeader, r, err := s.processRequest(w, r)
+	addResponseHeaders(responseHeader, w)
+
+	// If there was an error, do not call next.
+	if err == nil && next != nil {
+		next(w, r)
+	}
+}
+
+// HandlerFuncWithNextForRequestOnly is a special implementation for Negroni, but could be used elsewhere.
+// Note that this is for requests only and will not write any headers.
+func (s *Secure) HandlerFuncWithNextForRequestOnly(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
+	// Let secure process the request. If it returns an error,
+	// that indicates the request should not continue.
+	responseHeader, r, err := s.processRequest(w, r)
+
+	// If there was an error, do not call next.
+	if err == nil && next != nil {
+		// Save response headers in the request context
+		ctx := context.WithValue(r.Context(), s.ctxSecureHeaderKey, responseHeader)
+
+		// No headers will be written to the ResponseWriter.
+		next(w, r.WithContext(ctx))
+	}
+}
+
+// addResponseHeaders Adds the headers from 'responseHeader' to the response.
+func addResponseHeaders(responseHeader http.Header, w http.ResponseWriter) {
+	for key, values := range responseHeader {
+		for _, value := range values {
+			w.Header().Set(key, value)
+		}
+	}
+}
+
+// Process runs the actual checks and writes the headers in the ResponseWriter.
+func (s *Secure) Process(w http.ResponseWriter, r *http.Request) error {
+	responseHeader, _, err := s.processRequest(w, r)
+	addResponseHeaders(responseHeader, w)
+
+	return err
+}
+
+// ProcessAndReturnNonce runs the actual checks and writes the headers in the ResponseWriter.
+// In addition, the generated nonce for the request is returned as well as the error value.
+func (s *Secure) ProcessAndReturnNonce(w http.ResponseWriter, r *http.Request) (string, error) {
+	responseHeader, newR, err := s.processRequest(w, r)
+	if err != nil {
+		return "", err
+	}
+
+	addResponseHeaders(responseHeader, w)
+
+	return CSPNonce(newR.Context()), err
+}
+
+// ProcessNoModifyRequest runs the actual checks but does not write the headers in the ResponseWriter.
+func (s *Secure) ProcessNoModifyRequest(w http.ResponseWriter, r *http.Request) (http.Header, *http.Request, error) {
+	return s.processRequest(w, r)
+}
+
+// processRequest runs the actual checks on the request and returns an error if the middleware chain should stop.
+func (s *Secure) processRequest(w http.ResponseWriter, r *http.Request) (http.Header, *http.Request, error) {
+	// Setup nonce if required.
+	if s.opt.nonceEnabled {
+		r = withCSPNonce(r, cspRandNonce())
+	}
+
+	// Resolve the host for the request, using proxy headers if present.
+	host := r.Host
+
+	for _, header := range s.opt.HostsProxyHeaders {
+		if h := r.Header.Get(header); h != "" {
+			host = h
+
+			break
+		}
+	}
+
+	// Allowed hosts check.
+	if len(s.opt.AllowedHosts) > 0 && !s.opt.IsDevelopment {
+		isGoodHost := false
+
+		if s.opt.AllowedHostsAreRegex {
+			for _, allowedHost := range s.cRegexAllowedHosts {
+				if match := allowedHost.MatchString(host); match {
+					isGoodHost = true
+
+					break
+				}
+			}
+		} else {
+			for _, allowedHost := range s.opt.AllowedHosts {
+				if strings.EqualFold(allowedHost, host) {
+					isGoodHost = true
+
+					break
+				}
+			}
+		}
+
+		if !isGoodHost {
+			s.badHostHandler.ServeHTTP(w, r)
+
+			return nil, nil, fmt.Errorf("bad host name: %s", host)
+		}
+	}
+
+	// Determine if we are on HTTPS.
+	ssl := s.isSSL(r)
+
+	// SSL check.
+	if s.opt.SSLRedirect && !ssl && !s.opt.IsDevelopment {
+		url := r.URL
+		url.Scheme = "https"
+		url.Host = host
+
+		if s.opt.SSLHostFunc != nil {
+			if h := (*s.opt.SSLHostFunc)(host); len(h) > 0 {
+				url.Host = h
+			}
+		} else if len(s.opt.SSLHost) > 0 {
+			url.Host = s.opt.SSLHost
+		}
+
+		status := http.StatusMovedPermanently
+		if s.opt.SSLTemporaryRedirect {
+			status = http.StatusTemporaryRedirect
+		}
+
+		http.Redirect(w, r, url.String(), status)
+
+		return nil, nil, fmt.Errorf("redirecting to HTTPS")
+	}
+
+	if s.opt.SSLForceHost {
+		tempSSLHost := host
+
+		if s.opt.SSLHostFunc != nil {
+			if h := (*s.opt.SSLHostFunc)(host); len(h) > 0 {
+				tempSSLHost = h
+			}
+		} else if len(s.opt.SSLHost) > 0 {
+			tempSSLHost = s.opt.SSLHost
+		}
+
+		if tempSSLHost != host {
+			url := r.URL
+			url.Scheme = "https"
+			url.Host = tempSSLHost
+
+			status := http.StatusMovedPermanently
+			if s.opt.SSLTemporaryRedirect {
+				status = http.StatusTemporaryRedirect
+			}
+
+			http.Redirect(w, r, url.String(), status)
+
+			return nil, nil, fmt.Errorf("redirecting to HTTPS")
+		}
+	}
+
+	// If the AllowRequestFunc is set, call it and exit early if needed.
+	if s.opt.AllowRequestFunc != nil && !s.opt.AllowRequestFunc(r) {
+		s.badRequestHandler.ServeHTTP(w, r)
+
+		return nil, nil, fmt.Errorf("request not allowed")
+	}
+
+	// Create our header container.
+	responseHeader := make(http.Header)
+
+	// Strict Transport Security header. Only add header when we know it's an SSL connection.
+	// See https://tools.ietf.org/html/rfc6797#section-7.2 for details.
+	if s.opt.STSSeconds != 0 && (ssl || s.opt.ForceSTSHeader) && !s.opt.IsDevelopment {
+		stsSub := ""
+		if s.opt.STSIncludeSubdomains {
+			stsSub = stsSubdomainString
+		}
+
+		if s.opt.STSPreload {
+			stsSub += stsPreloadString
+		}
+
+		responseHeader.Set(stsHeader, fmt.Sprintf("max-age=%d%s", s.opt.STSSeconds, stsSub))
+	}
+
+	// Frame Options header.
+	if len(s.opt.CustomFrameOptionsValue) > 0 {
+		responseHeader.Set(frameOptionsHeader, s.opt.CustomFrameOptionsValue)
+	} else if s.opt.FrameDeny {
+		responseHeader.Set(frameOptionsHeader, frameOptionsValue)
+	}
+
+	// Content Type Options header.
+	if s.opt.ContentTypeNosniff {
+		responseHeader.Set(contentTypeHeader, contentTypeValue)
+	}
+
+	// XSS Protection header.
+	if len(s.opt.CustomBrowserXssValue) > 0 {
+		responseHeader.Set(xssProtectionHeader, s.opt.CustomBrowserXssValue)
+	} else if s.opt.BrowserXssFilter {
+		responseHeader.Set(xssProtectionHeader, xssProtectionValue)
+	}
+
+	// Content Security Policy header.
+	if len(s.opt.ContentSecurityPolicy) > 0 {
+		if s.opt.nonceEnabled {
+			responseHeader.Set(cspHeader, fmt.Sprintf(s.opt.ContentSecurityPolicy, CSPNonce(r.Context())))
+		} else {
+			responseHeader.Set(cspHeader, s.opt.ContentSecurityPolicy)
+		}
+	}
+
+	// Content Security Policy Report Only header.
+	if len(s.opt.ContentSecurityPolicyReportOnly) > 0 {
+		if s.opt.nonceEnabled {
+			responseHeader.Set(cspReportOnlyHeader, fmt.Sprintf(s.opt.ContentSecurityPolicyReportOnly, CSPNonce(r.Context())))
+		} else {
+			responseHeader.Set(cspReportOnlyHeader, s.opt.ContentSecurityPolicyReportOnly)
+		}
+	}
+
+	// Referrer Policy header.
+	if len(s.opt.ReferrerPolicy) > 0 {
+		responseHeader.Set(referrerPolicyHeader, s.opt.ReferrerPolicy)
+	}
+
+	// Feature Policy header.
+	if len(s.opt.FeaturePolicy) > 0 {
+		responseHeader.Set(featurePolicyHeader, s.opt.FeaturePolicy)
+	}
+
+	// Permissions Policy header.
+	if len(s.opt.PermissionsPolicy) > 0 {
+		responseHeader.Set(permissionsPolicyHeader, s.opt.PermissionsPolicy)
+	}
+
+	// Cross Origin Opener Policy header.
+	if len(s.opt.CrossOriginOpenerPolicy) > 0 {
+		responseHeader.Set(coopHeader, s.opt.CrossOriginOpenerPolicy)
+	}
+
+	return responseHeader, r, nil
+}
+
+// isSSL determine if we are on HTTPS.
+func (s *Secure) isSSL(r *http.Request) bool {
+	ssl := strings.EqualFold(r.URL.Scheme, "https") || r.TLS != nil
+	if !ssl {
+		for k, v := range s.opt.SSLProxyHeaders {
+			if r.Header.Get(k) == v {
+				ssl = true
+
+				break
+			}
+		}
+	}
+
+	return ssl
+}
+
+// ModifyResponseHeaders modifies the Response.
+// Used by http.ReverseProxy.
+func (s *Secure) ModifyResponseHeaders(res *http.Response) error {
+	if res != nil && res.Request != nil {
+		// Fix Location response header http to https:
+		// When SSL is enabled,
+		// And SSLHost is defined,
+		// And the response location header includes the SSLHost as the domain with a trailing slash,
+		// Or an exact match to the SSLHost.
+		location := res.Header.Get("Location")
+		if s.isSSL(res.Request) &&
+			len(s.opt.SSLHost) > 0 &&
+			(strings.HasPrefix(location, fmt.Sprintf("http://%s/", s.opt.SSLHost)) || location == fmt.Sprintf("http://%s", s.opt.SSLHost)) {
+			location = strings.Replace(location, "http:", "https:", 1)
+			res.Header.Set("Location", location)
+		}
+
+		responseHeader := res.Request.Context().Value(s.ctxSecureHeaderKey)
+		if responseHeader != nil {
+			headers, _ := responseHeader.(http.Header)
+			for header, values := range headers {
+				if len(values) > 0 {
+					res.Header.Set(header, strings.Join(values, ","))
+				}
+			}
+		}
+	}
+
+	return nil
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 3e8bd72abe..a72220c816 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -69,6 +69,10 @@ github.com/ProtonMail/go-crypto/openpgp/s2k
 github.com/RoaringBitmap/roaring
 github.com/RoaringBitmap/roaring/internal
 github.com/RoaringBitmap/roaring/roaring64
+# github.com/a8m/envsubst v1.4.2
+## explicit; go 1.17
+github.com/a8m/envsubst
+github.com/a8m/envsubst/parse
 # github.com/agnivade/levenshtein v1.1.1
 ## explicit; go 1.13
 github.com/agnivade/levenshtein
@@ -1793,6 +1797,10 @@ github.com/trustelem/zxcvbn/scoring
 # github.com/tus/tusd v1.13.0
 ## explicit; go 1.16
 github.com/tus/tusd/pkg/handler
+# github.com/unrolled/secure v1.14.0 => github.com/DeepDiver1975/secure v0.0.0-20240424132259-5b29166734cb
+## explicit; go 1.13
+github.com/unrolled/secure
+github.com/unrolled/secure/cspbuilder
 # github.com/urfave/cli/v2 v2.27.1
 ## explicit; go 1.18
 github.com/urfave/cli/v2
@@ -2340,3 +2348,4 @@ stash.kopano.io/kgol/oidc-go
 stash.kopano.io/kgol/rndm
 # github.com/studio-b12/gowebdav => github.com/aduffeck/gowebdav v0.0.0-20231215102054-212d4a4374f6
 # github.com/egirna/icap-client => github.com/fschade/icap-client v0.0.0-20240123094924-5af178158eaf
+# github.com/unrolled/secure => github.com/DeepDiver1975/secure v0.0.0-20240424132259-5b29166734cb