From ee04435426a5d50f4841b1f21c01310c0cb6980f Mon Sep 17 00:00:00 2001 From: rekby Date: Sun, 8 Mar 2020 00:44:23 +0300 Subject: [PATCH] Add custom subdomains --- cmd/a_main-packr.go | 2 +- cmd/config.go | 1 + cmd/main.go | 6 ++++++ cmd/static/default-config.toml | 3 +++ .../cert_manager/cert_description_test.go | 2 +- internal/cert_manager/cert_desctiption.go | 20 ++++++++++++++++--- internal/cert_manager/manager.go | 6 +++++- .../cert_manager/manager_functional_test.go | 2 ++ 8 files changed, 36 insertions(+), 6 deletions(-) diff --git a/cmd/a_main-packr.go b/cmd/a_main-packr.go index 05d1b9a0..4ebf3120 100644 --- a/cmd/a_main-packr.go +++ b/cmd/a_main-packr.go @@ -7,5 +7,5 @@ import "github.com/gobuffalo/packr" // You can use the "packr clean" command to clean up this, // and any other packr generated files. func init() { - packr.PackJSONBytes("static", "default-config.toml", "\"## ATTENTION
# it is example file only. It builtin in binary and don't read from file system.
# changes in config_default.toml have no real effect.

[General]

# Seconds for issue every certificate. Cancel issue and return error if timeout.
IssueTimeout = 300

# Path to dir, which will store state and certificates
StorageDir = "storage"

# Store .json info with certificate metadata near certificate.
StoreJSONMetadata = true

# Directory url of acme server.
#Test server: https://acme-staging-v02.api.letsencrypt.org/directory
AcmeServer = "https://acme-v02.api.letsencrypt.org/directory"

# Include other config files
# It support glob syntax
# If it has path without template - the file must exist.
# For allow optional include file - it can contain some glob symbol
# Included configs merge with current readed state.
# example=[ "config.tom[l]" ]
IncludeConfigs = []

# For prevent infinite loop and consume all memory if cycle in includes
MaxConfigFilesRead = 10000

[Log]
EnableLogToFile = true
EnableLogToStdErr = true

# verbose level of log, one of: debug, info, warning, error, fatal
LogLevel = "info"

# Enable self log rotating
EnableRotate = true

# Enable developer mode: more stacktraces and panic (stop program) on some internal errors.
DeveloperMode = false

# Path to log file
File = "lets-proxy.log"

# Rotate log if current file size more than X MB
RotateBySizeMB = 100

# Compress old log with gzip after rotate
CompressRotated = false

# Delete old backups after X days. 0 for disable.
MaxDays = 10

# Delete old backups if old file number more then X. 0 for disable.
MaxCount = 10

[Proxy]

# Default rule of select destination address.
# It can be: IP (with default port 80), :Port (default - same IP as receive connection), IPv4:Port or [IPv6]:Port
# Must define port force if HTTPSBackend is true
DefaultTarget = ":80"

# After KeepAliveTimeoutSeconds of inactive incoming connection will close.
KeepAliveTimeoutSeconds = 900

# Array of '-' separated pairs or IP:Port. For example:
# [
#   "1.2.3.4:443-2.2.2.2:1234",
#   "3.3.3.3:333-[::1]:94"
# "]
# Mean: connections, accepted on 1.2.3.4:443 send to server 2.2.2.2:1234
# and connections accepted on 3.3.3.3:333 send to ipv6 ::1 port 94
TargetMap = []

# Array of colon separated HeaderName:HeaderValue for add to request for backend. {{Value}} is special forms, which can
# internally parsing. Now it support only special values:
# {{CONNECTION_ID}} - Id of accepted connection, generated by lets-proxy
# {{HTTP_PROTO}} - set to http/https dependence incoming connections handled
# {{SOURCE_IP}} - Remote IP of incoming connection
# {SOURCE_PORT}} - Remote port of incoming connection
# {{SOURCE_IP}}:{{SOURCE_PORT}} - Remote IP:Port of incoming connection.
# Now it accepted only this special values, which must be exaxlty equal to examples. All other values send as is.
# But it can change and extend in future. Doesn't use {{...}} as own values.
# Example:
# ["IP:{{SOURCE_IP}}", "Proxy:lets-proxy", "Protocol:{{HTTP_PROTO}}" ]
Headers = []

# Use https requests to backend instead of http
HTTPSBackend = false

# Ignore backend https certificate validations if HTTPSBackend is true
HTTPSBackendIgnoreCert = true

[CheckDomains]

# Allow domain if it resolver for one of public IPs of this server.
IPSelf = true

# How detect public ips of the server.
# it use if IPSelf is true
# auto | local | aws  | yandex
# auto - best effort for detect IP. Algoritm may change from time to time.
#        it good for default.
# bind - detect public IP binded to local interfaces
# aws - detect public IPs by query to AWS EC2 metadata
# external - detect self ip by request to external server IPSelfExternalDetector
# yandex - detect public IPs by query to Yandex cloud metadata (now alias for aws)
IPSelfDetectMethod = "auto"

# Server for use as external detector of server IP (need for detect IP behind NAT
# Server must response as plain text IP address.
# For every detect lets-proxy make two requests: by ipv4 and ipv6 networks
IPSelfExternalDetectorURL="http://ifconfig.io/ip"

# Allow domain if it resolver for one of the ips.
IPWhiteList = ""

# Regexp in golang syntax of blacklisted domain for issue certificate.
#This list overrided by whitelist.
BlackList = ""

# Regexp in golang syntax of whitelist domains for issue certificate.
#Whitelist need for allow part of domains, which excluded by blacklist.
#
WhiteList = ""

# Comma separated dns server, used for resolve ip:port address of domains while check it.
# if empty - use system dns resolver (usually include hosts file, cache, etc)
# if set - use direct dns queries for servers, without self cache.
# if set more, than one dns server - send queries in parallel to all servers.
# error results from part of servers - ignore. Need minimum one answer.
# if different dns servers return different ip addresses - all of them use for check
# Example: "8.8.8.8:53,1.1.1.1:53,77.88.8.8:53,[2a02:6b8::feed:0ff]:53,[2001:4860:4860::8888]:53"
Resolver = ""



[Listen]

# Bind addresses for TLS listeners
TLSAddresses = [":443"]

# Bind addresses without TLS secure (for HTTP reverse proxy and http-01 validation without redirect to https)
TCPAddresses = []


[Metrics]
# Enable metrics in prometheous formath by http.
Enable = false

# Bind addresses for get by https
TLSAddresses = []

# Bind addresses without TLS secure (for HTTP reverse proxy and http-01 validation without redirect to https)
TCPAddresses = [ "[::]:62100" ]

# IP networks for allow to get metrics.
# Default - allow from all.
# Example:
# [ "1.2.3.4/32", "192.168.0.0/24", "::1/128" ]
AllowedNetworks = []

# Password for get metrics, add as get param ?password=...
Password        = ""

# Allow set password to empty string
AllowEmptyPassword  = false



[Profiler]
Enable = false

# IP networks for allow to use profiler.
# Default - allow from all.
# Example:
# [ "1.2.3.4/32", "192.168.0.0/24", "::1/128" ]
AllowedNetworks = []
BindAddress = "localhost:31344"
Password        = ""
AllowEmptyPassword  = false
\"") + packr.PackJSONBytes("static", "default-config.toml", "\"## ATTENTION
# it is example file only. It builtin in binary and don't read from file system.
# changes in config_default.toml have no real effect.

[General]

# Seconds for issue every certificate. Cancel issue and return error if timeout.
IssueTimeout = 300

# Path to dir, which will store state and certificates
StorageDir = "storage"

# Store .json info with certificate metadata near certificate.
StoreJSONMetadata = true

# Subdomains, auto-included within certificate of main domain name
Subdomains = ["www."]

# Directory url of acme server.
#Test server: https://acme-staging-v02.api.letsencrypt.org/directory
AcmeServer = "https://acme-v02.api.letsencrypt.org/directory"

# Include other config files
# It support glob syntax
# If it has path without template - the file must exist.
# For allow optional include file - it can contain some glob symbol
# Included configs merge with current readed state.
# example=[ "config.tom[l]" ]
IncludeConfigs = []

# For prevent infinite loop and consume all memory if cycle in includes
MaxConfigFilesRead = 10000

[Log]
EnableLogToFile = true
EnableLogToStdErr = true

# verbose level of log, one of: debug, info, warning, error, fatal
LogLevel = "info"

# Enable self log rotating
EnableRotate = true

# Enable developer mode: more stacktraces and panic (stop program) on some internal errors.
DeveloperMode = false

# Path to log file
File = "lets-proxy.log"

# Rotate log if current file size more than X MB
RotateBySizeMB = 100

# Compress old log with gzip after rotate
CompressRotated = false

# Delete old backups after X days. 0 for disable.
MaxDays = 10

# Delete old backups if old file number more then X. 0 for disable.
MaxCount = 10

[Proxy]

# Default rule of select destination address.
# It can be: IP (with default port 80), :Port (default - same IP as receive connection), IPv4:Port or [IPv6]:Port
# Must define port force if HTTPSBackend is true
DefaultTarget = ":80"

# After KeepAliveTimeoutSeconds of inactive incoming connection will close.
KeepAliveTimeoutSeconds = 900

# Array of '-' separated pairs or IP:Port. For example:
# [
#   "1.2.3.4:443-2.2.2.2:1234",
#   "3.3.3.3:333-[::1]:94"
# "]
# Mean: connections, accepted on 1.2.3.4:443 send to server 2.2.2.2:1234
# and connections accepted on 3.3.3.3:333 send to ipv6 ::1 port 94
TargetMap = []

# Array of colon separated HeaderName:HeaderValue for add to request for backend. {{Value}} is special forms, which can
# internally parsing. Now it support only special values:
# {{CONNECTION_ID}} - Id of accepted connection, generated by lets-proxy
# {{HTTP_PROTO}} - set to http/https dependence incoming connections handled
# {{SOURCE_IP}} - Remote IP of incoming connection
# {SOURCE_PORT}} - Remote port of incoming connection
# {{SOURCE_IP}}:{{SOURCE_PORT}} - Remote IP:Port of incoming connection.
# Now it accepted only this special values, which must be exaxlty equal to examples. All other values send as is.
# But it can change and extend in future. Doesn't use {{...}} as own values.
# Example:
# ["IP:{{SOURCE_IP}}", "Proxy:lets-proxy", "Protocol:{{HTTP_PROTO}}" ]
Headers = []

# Use https requests to backend instead of http
HTTPSBackend = false

# Ignore backend https certificate validations if HTTPSBackend is true
HTTPSBackendIgnoreCert = true

[CheckDomains]

# Allow domain if it resolver for one of public IPs of this server.
IPSelf = true

# How detect public ips of the server.
# it use if IPSelf is true
# auto | local | aws  | yandex
# auto - best effort for detect IP. Algoritm may change from time to time.
#        it good for default.
# bind - detect public IP binded to local interfaces
# aws - detect public IPs by query to AWS EC2 metadata
# external - detect self ip by request to external server IPSelfExternalDetector
# yandex - detect public IPs by query to Yandex cloud metadata (now alias for aws)
IPSelfDetectMethod = "auto"

# Server for use as external detector of server IP (need for detect IP behind NAT
# Server must response as plain text IP address.
# For every detect lets-proxy make two requests: by ipv4 and ipv6 networks
IPSelfExternalDetectorURL="http://ifconfig.io/ip"

# Allow domain if it resolver for one of the ips.
IPWhiteList = ""

# Regexp in golang syntax of blacklisted domain for issue certificate.
#This list overrided by whitelist.
BlackList = ""

# Regexp in golang syntax of whitelist domains for issue certificate.
#Whitelist need for allow part of domains, which excluded by blacklist.
#
WhiteList = ""

# Comma separated dns server, used for resolve ip:port address of domains while check it.
# if empty - use system dns resolver (usually include hosts file, cache, etc)
# if set - use direct dns queries for servers, without self cache.
# if set more, than one dns server - send queries in parallel to all servers.
# error results from part of servers - ignore. Need minimum one answer.
# if different dns servers return different ip addresses - all of them use for check
# Example: "8.8.8.8:53,1.1.1.1:53,77.88.8.8:53,[2a02:6b8::feed:0ff]:53,[2001:4860:4860::8888]:53"
Resolver = ""



[Listen]

# Bind addresses for TLS listeners
TLSAddresses = [":443"]

# Bind addresses without TLS secure (for HTTP reverse proxy and http-01 validation without redirect to https)
TCPAddresses = []


[Metrics]
# Enable metrics in prometheous formath by http.
Enable = false

# Bind addresses for get by https
TLSAddresses = []

# Bind addresses without TLS secure (for HTTP reverse proxy and http-01 validation without redirect to https)
TCPAddresses = [ "[::]:62100" ]

# IP networks for allow to get metrics.
# Default - allow from all.
# Example:
# [ "1.2.3.4/32", "192.168.0.0/24", "::1/128" ]
AllowedNetworks = []

# Password for get metrics, add as get param ?password=...
Password        = ""

# Allow set password to empty string
AllowEmptyPassword  = false



[Profiler]
Enable = false

# IP networks for allow to use profiler.
# Default - allow from all.
# Example:
# [ "1.2.3.4/32", "192.168.0.0/24", "::1/128" ]
AllowedNetworks = []
BindAddress = "localhost:31344"
Password        = ""
AllowEmptyPassword  = false
\"") } diff --git a/cmd/config.go b/cmd/config.go index d34d8515..d0fc13af 100644 --- a/cmd/config.go +++ b/cmd/config.go @@ -30,6 +30,7 @@ import ( type ConfigGeneral struct { IssueTimeout int StorageDir string + Subdomains []string AcmeServer string StoreJSONMetadata bool IncludeConfigs []string diff --git a/cmd/main.go b/cmd/main.go index e298b6c2..dd254aaf 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -9,6 +9,7 @@ import ( "net/http" "os" "runtime" + "strings" "time" "golang.org/x/xerrors" @@ -124,6 +125,11 @@ func startProgram(config *configType) { certManager := cert_manager.New(acmeClient, storage, registry) certManager.CertificateIssueTimeout = time.Duration(config.General.IssueTimeout) * time.Second certManager.SaveJSONMeta = config.General.StoreJSONMetadata + for _, subdomain := range config.General.Subdomains { + subdomain = strings.TrimSpace(subdomain) + subdomain = strings.TrimSuffix(subdomain, ".") + "." // must ends with dot + certManager.AutoSubdomains = append(certManager.AutoSubdomains, subdomain) + } certManager.DomainChecker, err = config.CheckDomains.CreateDomainChecker(ctx) log.DebugFatal(logger, err, "Config domain checkers.") diff --git a/cmd/static/default-config.toml b/cmd/static/default-config.toml index 921b1a86..38c9ae55 100644 --- a/cmd/static/default-config.toml +++ b/cmd/static/default-config.toml @@ -13,6 +13,9 @@ StorageDir = "storage" # Store .json info with certificate metadata near certificate. StoreJSONMetadata = true +# Subdomains, auto-included within certificate of main domain name +Subdomains = ["www."] + # Directory url of acme server. #Test server: https://acme-staging-v02.api.letsencrypt.org/directory AcmeServer = "https://acme-v02.api.letsencrypt.org/directory" diff --git a/internal/cert_manager/cert_description_test.go b/internal/cert_manager/cert_description_test.go index bd612686..eb14ae02 100644 --- a/internal/cert_manager/cert_description_test.go +++ b/internal/cert_manager/cert_description_test.go @@ -15,7 +15,7 @@ func TestCertDescription_CertStoreName(t *testing.T) { func TestCertDescription_DomainNames(t *testing.T) { td := testdeep.NewT(t) - td.Cmp(CertDescription{MainDomain: "asd.ru", KeyType: KeyRSA}.DomainNames(), []DomainName{"asd.ru", "www.asd.ru"}) + td.Cmp(CertDescription{MainDomain: "asd.ru", KeyType: KeyRSA, Subdomains: []string{"www."}}.DomainNames(), []DomainName{"asd.ru", "www.asd.ru"}) } func TestCertDescription_KeyStoreName(t *testing.T) { diff --git a/internal/cert_manager/cert_desctiption.go b/internal/cert_manager/cert_desctiption.go index 806c7a79..fd20acbb 100644 --- a/internal/cert_manager/cert_desctiption.go +++ b/internal/cert_manager/cert_desctiption.go @@ -10,6 +10,7 @@ import ( type CertDescription struct { MainDomain string KeyType KeyType + Subdomains []string } func (n CertDescription) CertStoreName() string { @@ -17,7 +18,12 @@ func (n CertDescription) CertStoreName() string { } func (n CertDescription) DomainNames() []DomainName { - return []DomainName{DomainName(n.MainDomain), DomainName("www." + n.MainDomain)} + domains := make([]DomainName, 1, len(n.Subdomains)+1) + domains[0] = DomainName(n.MainDomain) + for _, subdomain := range n.Subdomains { + domains = append(domains, DomainName(subdomain+n.MainDomain)) + } + return domains } func (n CertDescription) KeyStoreName() string { @@ -40,9 +46,17 @@ func (n CertDescription) ZapField() zap.Field { return zap.Stringer("cert_name", n) } -func CertDescriptionFromDomain(domain DomainName, keyType KeyType) CertDescription { +func CertDescriptionFromDomain(domain DomainName, keyType KeyType, autoSubDomains []string) CertDescription { + mainDomain := domain.String() + for _, subdomain := range autoSubDomains { + if strings.HasPrefix(mainDomain, subdomain) { + mainDomain = strings.TrimPrefix(mainDomain, subdomain) + break + } + } return CertDescription{ - MainDomain: strings.TrimPrefix(domain.String(), "www."), + MainDomain: mainDomain, KeyType: keyType, + Subdomains: autoSubDomains, } } diff --git a/internal/cert_manager/manager.go b/internal/cert_manager/manager.go index beeb10aa..dde9298b 100644 --- a/internal/cert_manager/manager.go +++ b/internal/cert_manager/manager.go @@ -81,6 +81,10 @@ type Manager struct { CertificateIssueTimeout time.Duration Cache cache.Bytes + // Subdomains, auto-issued with main domain. + // Every subdomain must have suffix dot. For example: "www." + AutoSubdomains []string + // Client is used to perform low-level operations, such as account registration // and requesting new certificates. // @@ -164,7 +168,7 @@ func (m *Manager) GetCertificate(hello *tls.ClientHelloInfo) (resultCert *tls.Ce //nolint:funlen,gocognit func (m *Manager) getCertificate(ctx context.Context, needDomain DomainName, certType KeyType) (resultCert *tls.Certificate, err error) { - certDescription := CertDescriptionFromDomain(needDomain, certType) + certDescription := CertDescriptionFromDomain(needDomain, certType, m.AutoSubdomains) logger := zc.L(ctx).With(certDescription.ZapField()) ctx = zc.WithLogger(ctx, zc.L(ctx).With(certDescription.ZapField())) diff --git a/internal/cert_manager/manager_functional_test.go b/internal/cert_manager/manager_functional_test.go index 6ed19aee..c7321e32 100644 --- a/internal/cert_manager/manager_functional_test.go +++ b/internal/cert_manager/manager_functional_test.go @@ -38,6 +38,7 @@ func TestManager_GetCertificateHttp01(t *testing.T) { defer mc.Finish() manager := New(createTestClient(t), newCacheMock(mc), nil) + manager.AutoSubdomains = []string{"www."} manager.EnableTLSValidation = false manager.EnableHTTPValidation = true @@ -86,6 +87,7 @@ func TestManager_GetCertificateTls(t *testing.T) { defer mc.Finish() manager := New(createTestClient(t), newCacheMock(mc), nil) + manager.AutoSubdomains = []string{"www."} lisneter, err := net.ListenTCP("tcp", &net.TCPAddr{Port: 5001})