package configuration import ( "fmt" "strconv" "strings" "github.com/containous/traefik/old/log" "github.com/containous/traefik/old/tls" "github.com/containous/traefik/old/types" ) // EntryPoint holds an entry point configuration of the reverse proxy (ip, port, TLS...) type EntryPoint struct { Address string TLS *tls.TLS `export:"true"` Redirect *types.Redirect `export:"true"` Auth *types.Auth `export:"true"` WhiteList *types.WhiteList `export:"true"` Compress *Compress `export:"true"` ProxyProtocol *ProxyProtocol `export:"true"` ForwardedHeaders *ForwardedHeaders `export:"true"` ClientIPStrategy *types.IPStrategy `export:"true"` } // Compress contains compress configuration type Compress struct{} // ProxyProtocol contains Proxy-Protocol configuration type ProxyProtocol struct { Insecure bool `export:"true"` TrustedIPs []string } // ForwardedHeaders Trust client forwarding headers type ForwardedHeaders struct { Insecure bool `export:"true"` TrustedIPs []string } // EntryPoints holds entry points configuration of the reverse proxy (ip, port, TLS...) type EntryPoints map[string]*EntryPoint // String is the method to format the flag's value, part of the flag.Value interface. // The String method's output will be used in diagnostics. func (ep EntryPoints) String() string { return fmt.Sprintf("%+v", map[string]*EntryPoint(ep)) } // Get return the EntryPoints map func (ep *EntryPoints) Get() interface{} { return *ep } // SetValue sets the EntryPoints map with val func (ep *EntryPoints) SetValue(val interface{}) { *ep = val.(EntryPoints) } // Type is type of the struct func (ep *EntryPoints) Type() string { return "entrypoints" } // Set is the method to set the flag value, part of the flag.Value interface. // Set's argument is a string to be parsed to set the flag. // It's a comma-separated list, so we split it. func (ep *EntryPoints) Set(value string) error { result := parseEntryPointsConfiguration(value) var compress *Compress if len(result["compress"]) > 0 { compress = &Compress{} } configTLS, err := makeEntryPointTLS(result) if err != nil { return err } (*ep)[result["name"]] = &EntryPoint{ Address: result["address"], TLS: configTLS, Auth: makeEntryPointAuth(result), Redirect: makeEntryPointRedirect(result), Compress: compress, WhiteList: makeWhiteList(result), ProxyProtocol: makeEntryPointProxyProtocol(result), ForwardedHeaders: makeEntryPointForwardedHeaders(result), ClientIPStrategy: makeIPStrategy("clientipstrategy", result), } return nil } func makeWhiteList(result map[string]string) *types.WhiteList { if rawRange, ok := result["whitelist_sourcerange"]; ok { return &types.WhiteList{ SourceRange: strings.Split(rawRange, ","), IPStrategy: makeIPStrategy("whitelist_ipstrategy", result), } } return nil } func makeIPStrategy(prefix string, result map[string]string) *types.IPStrategy { depth := toInt(result, prefix+"_depth") excludedIPs := result[prefix+"_excludedips"] if depth == 0 && len(excludedIPs) == 0 { return nil } return &types.IPStrategy{ Depth: depth, ExcludedIPs: strings.Split(excludedIPs, ","), } } func makeEntryPointAuth(result map[string]string) *types.Auth { var basic *types.Basic if v, ok := result["auth_basic_users"]; ok { basic = &types.Basic{ Realm: result["auth_basic_realm"], Users: strings.Split(v, ","), RemoveHeader: toBool(result, "auth_basic_removeheader"), } } var digest *types.Digest if v, ok := result["auth_digest_users"]; ok { digest = &types.Digest{ Users: strings.Split(v, ","), RemoveHeader: toBool(result, "auth_digest_removeheader"), } } var forward *types.Forward if address, ok := result["auth_forward_address"]; ok { var clientTLS *types.ClientTLS cert := result["auth_forward_tls_cert"] key := result["auth_forward_tls_key"] insecureSkipVerify := toBool(result, "auth_forward_tls_insecureskipverify") if len(cert) > 0 && len(key) > 0 || insecureSkipVerify { clientTLS = &types.ClientTLS{ CA: result["auth_forward_tls_ca"], CAOptional: toBool(result, "auth_forward_tls_caoptional"), Cert: cert, Key: key, InsecureSkipVerify: insecureSkipVerify, } } var authResponseHeaders []string if v, ok := result["auth_forward_authresponseheaders"]; ok { authResponseHeaders = strings.Split(v, ",") } forward = &types.Forward{ Address: address, TLS: clientTLS, TrustForwardHeader: toBool(result, "auth_forward_trustforwardheader"), AuthResponseHeaders: authResponseHeaders, } } var auth *types.Auth if basic != nil || digest != nil || forward != nil { auth = &types.Auth{ Basic: basic, Digest: digest, Forward: forward, HeaderField: result["auth_headerfield"], } } return auth } func makeEntryPointProxyProtocol(result map[string]string) *ProxyProtocol { var proxyProtocol *ProxyProtocol ppTrustedIPs := result["proxyprotocol_trustedips"] if len(result["proxyprotocol_insecure"]) > 0 || len(ppTrustedIPs) > 0 { proxyProtocol = &ProxyProtocol{ Insecure: toBool(result, "proxyprotocol_insecure"), } if len(ppTrustedIPs) > 0 { proxyProtocol.TrustedIPs = strings.Split(ppTrustedIPs, ",") } } if proxyProtocol != nil && proxyProtocol.Insecure { log.Warn("ProxyProtocol.insecure:true is dangerous. Please use 'ProxyProtocol.TrustedIPs:IPs' and remove 'ProxyProtocol.insecure:true'") } return proxyProtocol } func makeEntryPointForwardedHeaders(result map[string]string) *ForwardedHeaders { forwardedHeaders := &ForwardedHeaders{} if _, ok := result["forwardedheaders_insecure"]; ok { forwardedHeaders.Insecure = toBool(result, "forwardedheaders_insecure") } fhTrustedIPs := result["forwardedheaders_trustedips"] if len(fhTrustedIPs) > 0 { // TODO must be removed in the next breaking version. forwardedHeaders.Insecure = toBool(result, "forwardedheaders_insecure") forwardedHeaders.TrustedIPs = strings.Split(fhTrustedIPs, ",") } return forwardedHeaders } func makeEntryPointRedirect(result map[string]string) *types.Redirect { var redirect *types.Redirect if len(result["redirect_entrypoint"]) > 0 || len(result["redirect_regex"]) > 0 || len(result["redirect_replacement"]) > 0 { redirect = &types.Redirect{ EntryPoint: result["redirect_entrypoint"], Regex: result["redirect_regex"], Replacement: result["redirect_replacement"], Permanent: toBool(result, "redirect_permanent"), } } return redirect } func makeEntryPointTLS(result map[string]string) (*tls.TLS, error) { var configTLS *tls.TLS if len(result["tls"]) > 0 { certs := tls.Certificates{} if err := certs.Set(result["tls"]); err != nil { return nil, err } configTLS = &tls.TLS{ Certificates: certs, } } else if len(result["tls_acme"]) > 0 { configTLS = &tls.TLS{ Certificates: tls.Certificates{}, } } if configTLS != nil { if len(result["ca"]) > 0 { files := tls.FilesOrContents{} files.Set(result["ca"]) optional := toBool(result, "ca_optional") configTLS.ClientCA = tls.ClientCA{ Files: files, Optional: optional, } } if len(result["tls_minversion"]) > 0 { configTLS.MinVersion = result["tls_minversion"] } if len(result["tls_ciphersuites"]) > 0 { configTLS.CipherSuites = strings.Split(result["tls_ciphersuites"], ",") } if len(result["tls_snistrict"]) > 0 { configTLS.SniStrict = toBool(result, "tls_snistrict") } if len(result["tls_defaultcertificate_cert"]) > 0 && len(result["tls_defaultcertificate_key"]) > 0 { configTLS.DefaultCertificate = &tls.Certificate{ CertFile: tls.FileOrContent(result["tls_defaultcertificate_cert"]), KeyFile: tls.FileOrContent(result["tls_defaultcertificate_key"]), } } } return configTLS, nil } func parseEntryPointsConfiguration(raw string) map[string]string { sections := strings.Fields(raw) config := make(map[string]string) for _, part := range sections { field := strings.SplitN(part, ":", 2) name := strings.ToLower(strings.Replace(field[0], ".", "_", -1)) if len(field) > 1 { config[name] = field[1] } else { if strings.EqualFold(name, "TLS") { config["tls_acme"] = "TLS" } else { config[name] = "" } } } return config } func toBool(conf map[string]string, key string) bool { if val, ok := conf[key]; ok { return strings.EqualFold(val, "true") || strings.EqualFold(val, "enable") || strings.EqualFold(val, "on") } return false } func toInt(conf map[string]string, key string) int { if val, ok := conf[key]; ok { intVal, err := strconv.Atoi(val) if err != nil { return 0 } return intVal } return 0 }