func BearerAuth(name string, authenticate ScopedTokenAuthentication) runtime.Authenticator {
	const prefix = "Bearer "
	return ScopedAuthenticator(func(r *ScopedAuthRequest) (bool, interface{}, error) {
		var token string
		hdr := r.Request.Header.Get("Authorization")
		if strings.HasPrefix(hdr, prefix) {
			token = strings.TrimPrefix(hdr, prefix)
		}
		if token == "" {
			qs := r.Request.URL.Query()
			token = qs.Get("access_token")
		}
		ct, _, _ := runtime.ContentType(r.Request.Header)
		if token == "" && (ct == "application/x-www-form-urlencoded" || ct == "multipart/form-data") {
			token = r.Request.FormValue("access_token")
		}
		if token == "" {
			return false, nil, nil
		}
		rctx := context.WithValue(r.Request.Context(), oauth2SchemeName, name)
		*r.Request = *r.Request.WithContext(rctx)
		p, err := authenticate(token, r.RequiredScopes)
		return true, p, err
	})
}
BearerAuth for use with oauth2 flows
package security
import (
	"context"
	"net/http"
	"strings"
	"github.com/go-openapi/errors"
	"github.com/go-openapi/runtime"
)
const (
	query  = "query"
	header = "header"
)
func HttpAuthenticator(handler func(*http.Request) (bool, interface{}, error)) runtime.Authenticator {
	return runtime.AuthenticatorFunc(func(params interface{}) (bool, interface{}, error) {
		if request, ok := params.(*http.Request); ok {
			return handler(request)
		}
		if scoped, ok := params.(*ScopedAuthRequest); ok {
			return handler(scoped.Request)
		}
		return false, nil, nil
	})
}
func ScopedAuthenticator(handler func(*ScopedAuthRequest) (bool, interface{}, error)) runtime.Authenticator {
	return runtime.AuthenticatorFunc(func(params interface{}) (bool, interface{}, error) {
		if request, ok := params.(*ScopedAuthRequest); ok {
			return handler(request)
		}
		return false, nil, nil
	})
}
type UserPassAuthentication func(string, string) (interface{}, error)
type UserPassAuthenticationCtx func(context.Context, string, string) (context.Context, interface{}, error)
type TokenAuthentication func(string) (interface{}, error)
type TokenAuthenticationCtx func(context.Context, string) (context.Context, interface{}, error)
type ScopedTokenAuthentication func(string, []string) (interface{}, error)
type ScopedTokenAuthenticationCtx func(context.Context, string, []string) (context.Context, interface{}, error)
var DefaultRealmName = "API"
type secCtxKey uint8
const (
	failedBasicAuth secCtxKey = iota
	oauth2SchemeName
)
func FailedBasicAuth(r *http.Request) string {
	return FailedBasicAuthCtx(r.Context())
}
func FailedBasicAuthCtx(ctx context.Context) string {
	v, ok := ctx.Value(failedBasicAuth).(string)
	if !ok {
		return ""
	}
	return v
}
func OAuth2SchemeName(r *http.Request) string {
	return OAuth2SchemeNameCtx(r.Context())
}
func OAuth2SchemeNameCtx(ctx context.Context) string {
	v, ok := ctx.Value(oauth2SchemeName).(string)
	if !ok {
		return ""
	}
	return v
}
func BasicAuth(authenticate UserPassAuthentication) runtime.Authenticator {
	return BasicAuthRealm(DefaultRealmName, authenticate)
}
func BasicAuthRealm(realm string, authenticate UserPassAuthentication) runtime.Authenticator {
	if realm == "" {
		realm = DefaultRealmName
	}
	return HttpAuthenticator(func(r *http.Request) (bool, interface{}, error) {
		if usr, pass, ok := r.BasicAuth(); ok {
			p, err := authenticate(usr, pass)
			if err != nil {
				*r = *r.WithContext(context.WithValue(r.Context(), failedBasicAuth, realm))
			}
			return true, p, err
		}
		*r = *r.WithContext(context.WithValue(r.Context(), failedBasicAuth, realm))
		return false, nil, nil
	})
}
func BasicAuthCtx(authenticate UserPassAuthenticationCtx) runtime.Authenticator {
	return BasicAuthRealmCtx(DefaultRealmName, authenticate)
}
func BasicAuthRealmCtx(realm string, authenticate UserPassAuthenticationCtx) runtime.Authenticator {
	if realm == "" {
		realm = DefaultRealmName
	}
	return HttpAuthenticator(func(r *http.Request) (bool, interface{}, error) {
		if usr, pass, ok := r.BasicAuth(); ok {
			ctx, p, err := authenticate(r.Context(), usr, pass)
			if err != nil {
				ctx = context.WithValue(ctx, failedBasicAuth, realm)
			}
			*r = *r.WithContext(ctx)
			return true, p, err
		}
		*r = *r.WithContext(context.WithValue(r.Context(), failedBasicAuth, realm))
		return false, nil, nil
	})
}
func APIKeyAuth(name, in string, authenticate TokenAuthentication) runtime.Authenticator {
	inl := strings.ToLower(in)
	if inl != query && inl != header {
		panic(errors.New(500, "api key auth: in value needs to be either \"query\" or \"header\"."))
	}
	var getToken func(*http.Request) string
	switch inl {
	case header:
		getToken = func(r *http.Request) string { return r.Header.Get(name) }
	case query:
		getToken = func(r *http.Request) string { return r.URL.Query().Get(name) }
	}
	return HttpAuthenticator(func(r *http.Request) (bool, interface{}, error) {
		token := getToken(r)
		if token == "" {
			return false, nil, nil
		}
		p, err := authenticate(token)
		return true, p, err
	})
}
func APIKeyAuthCtx(name, in string, authenticate TokenAuthenticationCtx) runtime.Authenticator {
	inl := strings.ToLower(in)
	if inl != query && inl != header {
		panic(errors.New(500, "api key auth: in value needs to be either \"query\" or \"header\"."))
	}
	var getToken func(*http.Request) string
	switch inl {
	case header:
		getToken = func(r *http.Request) string { return r.Header.Get(name) }
	case query:
		getToken = func(r *http.Request) string { return r.URL.Query().Get(name) }
	}
	return HttpAuthenticator(func(r *http.Request) (bool, interface{}, error) {
		token := getToken(r)
		if token == "" {
			return false, nil, nil
		}
		ctx, p, err := authenticate(r.Context(), token)
		*r = *r.WithContext(ctx)
		return true, p, err
	})
}
type ScopedAuthRequest struct {
	Request        *http.Request
	RequiredScopes []string
}