mirror/opencloud
1
0
Fork 0
mirror of https://github.com/opencloud-eu/opencloud.git synced 2026-05-24 16:41:35 -04:00
Code Issues Packages Projects Releases Wiki Activity

feat: add CSP and other security related headers in the oCIS proxy service (#8777)

Browse Source 
* feat: add CSP and other security related headers in the oCIS proxy service

* fix: consolidate security related headers - drop middleware.Secure

* fix: use github.com/DeepDiver1975/secure

* fix: acceptance tests

* feat: support env var replacements in csp.yaml
This commit is contained in:
Thomas Müller
2024-04-26 09:10:35 +02:00
committed by GitHub
parent d3415a8c92
commit bdbba929d0
47 changed files with 2357 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
vendor/github.com/unrolled/secure/.gitignore generated vendored Normal file
View File

@@ -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

36
vendor/github.com/unrolled/secure/.golangci.yaml generated vendored Normal file
View File

@@ -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

20
vendor/github.com/unrolled/secure/LICENSE generated vendored Normal file
View File

@@ -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.

14
vendor/github.com/unrolled/secure/Makefile generated vendored Normal file
View File

@@ -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 ./...

424
vendor/github.com/unrolled/secure/README.md generated vendored Normal file
View File

@@ -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")
}
~~~

45
vendor/github.com/unrolled/secure/csp.go generated vendored Normal file
View File

@@ -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[:])
}

116
vendor/github.com/unrolled/secure/cspbuilder/builder.go generated vendored Normal file
View File

@@ -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
}

154
vendor/github.com/unrolled/secure/cspbuilder/directive_builder.go generated vendored Normal file
View File

@@ -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
}

26
vendor/github.com/unrolled/secure/doc.go generated vendored Normal file
View File

@@ -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

517
vendor/github.com/unrolled/secure/secure.go generated vendored Normal file
View File

@@ -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
}