2020-03-17 22:00:45 -05:00
// Copyright 2015 Matthew Holt and The Caddy Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package httpcaddyfile
import (
"bytes"
httpcaddyfile, caddytls: Multiple edge case fixes; add tests
- Create two default automation policies; if the TLS app is used in
isolation with the 'automate' certificate loader, it will now use
an internal issuer for internal-only names, and an ACME issuer for
all other names by default.
- If the HTTP Caddyfile adds an 'automate' loader, it now also adds an
automation policy for any names in that loader that do not qualify
for public certificates so that they will be issued internally. (It
might be nice if this wasn't necessary, but the alternative is to
either make auto-HTTPS logic way more complex by scanning the names in
the 'automate' loader, or to have an automation policy without an
issuer switch between default issuer based on the name being issued
a certificate - I think I like the latter option better, right now we
do something kind of like that but at a level above each individual
automation policies, we do that switch only when no automation
policies match, rather than when a policy without an issuer does
match.)
- Set the default LoggerName rather than a LoggerNames with an empty
host value, which is now taken literally rather than as a catch-all.
- hostsFromKeys, the function that gets a list of hosts from server
block keys, no longer returns an empty string in its resulting slice,
ever.
2020-04-08 15:46:44 -05:00
"encoding/json"
2020-03-17 22:00:45 -05:00
"fmt"
"reflect"
"sort"
2020-04-24 19:58:28 -05:00
"strconv"
caddytls: Add support for ZeroSSL; add Caddyfile support for issuers (#3633)
* caddytls: Add support for ZeroSSL; add Caddyfile support for issuers
Configuring issuers explicitly in a Caddyfile is not easily compatible
with existing ACME-specific parameters such as email or acme_ca which
infer the kind of issuer it creates (this is complicated now because
the ZeroSSL issuer wraps the ACME issuer)... oh well, we can revisit
that later if we need to.
New Caddyfile global option:
{
cert_issuer <name> ...
}
Or, alternatively, as a tls subdirective:
tls {
issuer <name> ...
}
For example, to use ZeroSSL with an API key:
{
cert_issuser zerossl API_KEY
}
For now, that still uses ZeroSSL's ACME endpoint; it fetches EAB
credentials for you. You can also provide the EAB credentials directly
just like any other ACME endpoint:
{
cert_issuer acme {
eab KEY_ID MAC_KEY
}
}
All these examples use the new global option (or tls subdirective). You
can still use traditional/existing options with ZeroSSL, since it's
just another ACME endpoint:
{
acme_ca https://acme.zerossl.com/v2/DV90
acme_eab KEY_ID MAC_KEY
}
That's all there is to it. You just can't mix-and-match acme_* options
with cert_issuer, because it becomes confusing/ambiguous/complicated to
merge the settings.
* Fix broken test
This test was asserting buggy behavior, oops - glad this branch both
discovers and fixes the bug at the same time!
* Fix broken test (post-merge)
* Update modules/caddytls/acmeissuer.go
Fix godoc comment
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
* Add support for ZeroSSL's EAB-by-email endpoint
Also transform the ACMEIssuer into ZeroSSLIssuer implicitly if set to
the ZeroSSL endpoint without EAB (the ZeroSSLIssuer is needed to
generate EAB if not already provided); this is now possible with either
an API key or an email address.
* go.mod: Use latest certmagic, acmez, and x/net
* Wrap underlying logic rather than repeating it
Oops, duh
* Form-encode email info into request body for EAB endpoint
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
2020-08-11 09:58:06 -05:00
"strings"
2020-03-17 22:00:45 -05:00
"github.com/caddyserver/caddy/v2"
"github.com/caddyserver/caddy/v2/caddyconfig"
2020-04-24 19:58:28 -05:00
"github.com/caddyserver/caddy/v2/modules/caddyhttp"
2020-03-17 22:00:45 -05:00
"github.com/caddyserver/caddy/v2/modules/caddytls"
"github.com/caddyserver/certmagic"
2020-07-30 16:18:14 -05:00
"github.com/mholt/acmez/acme"
2020-03-17 22:00:45 -05:00
)
func ( st ServerType ) buildTLSApp (
pairings [ ] sbAddrAssociation ,
options map [ string ] interface { } ,
warnings [ ] caddyconfig . Warning ,
) ( * caddytls . TLS , [ ] caddyconfig . Warning , error ) {
tlsApp := & caddytls . TLS { CertificatesRaw : make ( caddy . ModuleMap ) }
var certLoaders [ ] caddytls . CertificateLoader
2020-04-24 19:58:28 -05:00
httpsPort := strconv . Itoa ( caddyhttp . DefaultHTTPSPort )
if hsp , ok := options [ "https_port" ] . ( int ) ; ok {
httpsPort = strconv . Itoa ( hsp )
}
// count how many server blocks have a TLS-enabled key with
// no host, and find all hosts that share a server block with
// a hostless key, so that they don't get forgotten/omitted
2020-03-17 22:00:45 -05:00
// by auto-HTTPS (since they won't appear in route matchers)
2020-04-24 19:58:28 -05:00
var serverBlocksWithTLSHostlessKey int
2020-03-17 22:00:45 -05:00
hostsSharedWithHostlessKey := make ( map [ string ] struct { } )
for _ , pair := range pairings {
for _ , sb := range pair . serverBlocks {
2020-04-02 15:20:30 -05:00
for _ , addr := range sb . keys {
2020-03-17 22:00:45 -05:00
if addr . Host == "" {
2020-04-24 19:58:28 -05:00
// this address has no hostname, but if it's explicitly set
// to HTTPS, then we need to count it as being TLS-enabled
if addr . Scheme == "https" || addr . Port == httpsPort {
serverBlocksWithTLSHostlessKey ++
}
2020-03-17 22:00:45 -05:00
// this server block has a hostless key, now
// go through and add all the hosts to the set
2020-04-02 15:20:30 -05:00
for _ , otherAddr := range sb . keys {
if otherAddr . Original == addr . Original {
2020-03-17 22:00:45 -05:00
continue
}
2020-04-02 15:20:30 -05:00
if otherAddr . Host != "" {
httpcaddyfile, caddytls: Multiple edge case fixes; add tests
- Create two default automation policies; if the TLS app is used in
isolation with the 'automate' certificate loader, it will now use
an internal issuer for internal-only names, and an ACME issuer for
all other names by default.
- If the HTTP Caddyfile adds an 'automate' loader, it now also adds an
automation policy for any names in that loader that do not qualify
for public certificates so that they will be issued internally. (It
might be nice if this wasn't necessary, but the alternative is to
either make auto-HTTPS logic way more complex by scanning the names in
the 'automate' loader, or to have an automation policy without an
issuer switch between default issuer based on the name being issued
a certificate - I think I like the latter option better, right now we
do something kind of like that but at a level above each individual
automation policies, we do that switch only when no automation
policies match, rather than when a policy without an issuer does
match.)
- Set the default LoggerName rather than a LoggerNames with an empty
host value, which is now taken literally rather than as a catch-all.
- hostsFromKeys, the function that gets a list of hosts from server
block keys, no longer returns an empty string in its resulting slice,
ever.
2020-04-08 15:46:44 -05:00
hostsSharedWithHostlessKey [ otherAddr . Host ] = struct { } { }
2020-03-17 22:00:45 -05:00
}
}
break
}
}
}
}
2020-10-28 21:36:00 -05:00
// a catch-all automation policy is used as a "default" for all subjects that
// don't have custom configuration explicitly associated with them; this
// is only to add if the global settings or defaults are non-empty
2020-03-17 22:00:45 -05:00
catchAllAP , err := newBaseAutomationPolicy ( options , warnings , false )
if err != nil {
return nil , warnings , err
}
2020-10-28 21:36:00 -05:00
if catchAllAP != nil {
if tlsApp . Automation == nil {
tlsApp . Automation = new ( caddytls . AutomationConfig )
}
tlsApp . Automation . Policies = append ( tlsApp . Automation . Policies , catchAllAP )
}
2020-03-17 22:00:45 -05:00
for _ , p := range pairings {
for _ , sblock := range p . serverBlocks {
// get values that populate an automation policy for this block
2020-10-28 21:36:00 -05:00
ap , err := newBaseAutomationPolicy ( options , warnings , true )
if err != nil {
return nil , warnings , err
}
2020-03-17 22:00:45 -05:00
httpcaddyfile, caddytls: Multiple edge case fixes; add tests
- Create two default automation policies; if the TLS app is used in
isolation with the 'automate' certificate loader, it will now use
an internal issuer for internal-only names, and an ACME issuer for
all other names by default.
- If the HTTP Caddyfile adds an 'automate' loader, it now also adds an
automation policy for any names in that loader that do not qualify
for public certificates so that they will be issued internally. (It
might be nice if this wasn't necessary, but the alternative is to
either make auto-HTTPS logic way more complex by scanning the names in
the 'automate' loader, or to have an automation policy without an
issuer switch between default issuer based on the name being issued
a certificate - I think I like the latter option better, right now we
do something kind of like that but at a level above each individual
automation policies, we do that switch only when no automation
policies match, rather than when a policy without an issuer does
match.)
- Set the default LoggerName rather than a LoggerNames with an empty
host value, which is now taken literally rather than as a catch-all.
- hostsFromKeys, the function that gets a list of hosts from server
block keys, no longer returns an empty string in its resulting slice,
ever.
2020-04-08 15:46:44 -05:00
sblockHosts := sblock . hostsFromKeys ( false )
2020-10-28 21:36:00 -05:00
if len ( sblockHosts ) == 0 && catchAllAP != nil {
2020-03-17 22:00:45 -05:00
ap = catchAllAP
}
// on-demand tls
if _ , ok := sblock . pile [ "tls.on_demand" ] ; ok {
ap . OnDemand = true
}
// certificate issuers
if issuerVals , ok := sblock . pile [ "tls.cert_issuer" ] ; ok {
2020-11-16 13:05:55 -05:00
var issuers [ ] certmagic . Issuer
2020-03-17 22:00:45 -05:00
for _ , issuerVal := range issuerVals {
2020-11-16 13:05:55 -05:00
ap . Issuers = append ( ap . Issuers , issuerVal . Value . ( certmagic . Issuer ) )
}
if ap == catchAllAP && ! reflect . DeepEqual ( ap . Issuers , issuers ) {
return nil , warnings , fmt . Errorf ( "automation policy from site block is also default/catch-all policy because of key without hostname, and the two are in conflict: %#v != %#v" , ap . Issuers , issuers )
2020-03-17 22:00:45 -05:00
}
}
2020-04-06 13:24:35 -05:00
// custom bind host
for _ , cfgVal := range sblock . pile [ "bind" ] {
2020-11-16 13:05:55 -05:00
for _ , iss := range ap . Issuers {
// if an issuer was already configured and it is NOT an ACME issuer,
// skip, since we intend to adjust only ACME issuers; ensure we
// include any issuer that embeds/wraps an underlying ACME issuer
var acmeIssuer * caddytls . ACMEIssuer
if acmeWrapper , ok := iss . ( acmeCapable ) ; ok {
caddytls: Add support for ZeroSSL; add Caddyfile support for issuers (#3633)
* caddytls: Add support for ZeroSSL; add Caddyfile support for issuers
Configuring issuers explicitly in a Caddyfile is not easily compatible
with existing ACME-specific parameters such as email or acme_ca which
infer the kind of issuer it creates (this is complicated now because
the ZeroSSL issuer wraps the ACME issuer)... oh well, we can revisit
that later if we need to.
New Caddyfile global option:
{
cert_issuer <name> ...
}
Or, alternatively, as a tls subdirective:
tls {
issuer <name> ...
}
For example, to use ZeroSSL with an API key:
{
cert_issuser zerossl API_KEY
}
For now, that still uses ZeroSSL's ACME endpoint; it fetches EAB
credentials for you. You can also provide the EAB credentials directly
just like any other ACME endpoint:
{
cert_issuer acme {
eab KEY_ID MAC_KEY
}
}
All these examples use the new global option (or tls subdirective). You
can still use traditional/existing options with ZeroSSL, since it's
just another ACME endpoint:
{
acme_ca https://acme.zerossl.com/v2/DV90
acme_eab KEY_ID MAC_KEY
}
That's all there is to it. You just can't mix-and-match acme_* options
with cert_issuer, because it becomes confusing/ambiguous/complicated to
merge the settings.
* Fix broken test
This test was asserting buggy behavior, oops - glad this branch both
discovers and fixes the bug at the same time!
* Fix broken test (post-merge)
* Update modules/caddytls/acmeissuer.go
Fix godoc comment
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
* Add support for ZeroSSL's EAB-by-email endpoint
Also transform the ACMEIssuer into ZeroSSLIssuer implicitly if set to
the ZeroSSL endpoint without EAB (the ZeroSSLIssuer is needed to
generate EAB if not already provided); this is now possible with either
an API key or an email address.
* go.mod: Use latest certmagic, acmez, and x/net
* Wrap underlying logic rather than repeating it
Oops, duh
* Form-encode email info into request body for EAB endpoint
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
2020-08-11 09:58:06 -05:00
acmeIssuer = acmeWrapper . GetACMEIssuer ( )
2020-04-06 13:24:35 -05:00
}
2020-11-16 13:05:55 -05:00
if acmeIssuer == nil {
continue
}
2020-04-06 13:24:35 -05:00
2020-11-16 13:05:55 -05:00
// proceed to configure the ACME issuer's bind host, without
// overwriting any existing settings
if acmeIssuer . Challenges == nil {
acmeIssuer . Challenges = new ( caddytls . ChallengesConfig )
}
if acmeIssuer . Challenges . BindHost == "" {
// only binding to one host is supported
var bindHost string
if bindHosts , ok := cfgVal . Value . ( [ ] string ) ; ok && len ( bindHosts ) > 0 {
bindHost = bindHosts [ 0 ]
}
acmeIssuer . Challenges . BindHost = bindHost
2020-04-06 13:24:35 -05:00
}
}
}
2020-10-28 21:36:00 -05:00
// first make sure this block is allowed to create an automation policy;
// doing so is forbidden if it has a key with no host (i.e. ":443")
// and if there is a different server block that also has a key with no
// host -- since a key with no host matches any host, we need its
// associated automation policy to have an empty Subjects list, i.e. no
// host filter, which is indistinguishable between the two server blocks
// because automation is not done in the context of a particular server...
// this is an example of a poor mapping from Caddyfile to JSON but that's
// the least-leaky abstraction I could figure out
if len ( sblockHosts ) == 0 {
if serverBlocksWithTLSHostlessKey > 1 {
// this server block and at least one other has a key with no host,
// making the two indistinguishable; it is misleading to define such
// a policy within one server block since it actually will apply to
// others as well
return nil , warnings , fmt . Errorf ( "cannot make a TLS automation policy from a server block that has a host-less address when there are other TLS-enabled server block addresses lacking a host" )
2020-04-24 19:58:28 -05:00
}
2020-10-28 21:36:00 -05:00
if catchAllAP == nil {
// this server block has a key with no hosts, but there is not yet
// a catch-all automation policy (probably because no global options
// were set), so this one becomes it
catchAllAP = ap
2020-03-17 22:00:45 -05:00
}
2020-10-28 21:36:00 -05:00
}
2020-03-17 22:00:45 -05:00
2020-10-28 21:36:00 -05:00
// associate our new automation policy with this server block's hosts
ap . Subjects = sblockHosts
sort . Strings ( ap . Subjects ) // solely for deterministic test results
// if a combination of public and internal names were given
// for this same server block and no issuer was specified, we
// need to separate them out in the automation policies so
// that the internal names can use the internal issuer and
// the other names can use the default/public/ACME issuer
var ap2 * caddytls . AutomationPolicy
2020-11-16 13:05:55 -05:00
if len ( ap . Issuers ) == 0 {
2020-10-28 21:36:00 -05:00
var internal , external [ ] string
for _ , s := range ap . Subjects {
if ! certmagic . SubjectQualifiesForCert ( s ) {
return nil , warnings , fmt . Errorf ( "subject does not qualify for certificate: '%s'" , s )
2020-03-17 22:00:45 -05:00
}
2020-10-28 21:36:00 -05:00
// we don't use certmagic.SubjectQualifiesForPublicCert() because of one nuance:
// names like *.*.tld that may not qualify for a public certificate are actually
// fine when used with OnDemand, since OnDemand (currently) does not obtain
// wildcards (if it ever does, there will be a separate config option to enable
// it that we would need to check here) since the hostname is known at handshake;
// and it is unexpected to switch to internal issuer when the user wants to get
// regular certificates on-demand for a class of certs like *.*.tld.
if ! certmagic . SubjectIsIP ( s ) && ! certmagic . SubjectIsInternal ( s ) && ( strings . Count ( s , "*." ) < 2 || ap . OnDemand ) {
external = append ( external , s )
} else {
internal = append ( internal , s )
2020-03-17 22:00:45 -05:00
}
}
2020-10-28 21:36:00 -05:00
if len ( external ) > 0 && len ( internal ) > 0 {
ap . Subjects = external
apCopy := * ap
ap2 = & apCopy
ap2 . Subjects = internal
2020-11-16 13:05:55 -05:00
ap2 . IssuersRaw = [ ] json . RawMessage { caddyconfig . JSONModuleObject ( caddytls . InternalIssuer { } , "module" , "internal" , & warnings ) }
2020-10-28 21:36:00 -05:00
}
}
if tlsApp . Automation == nil {
tlsApp . Automation = new ( caddytls . AutomationConfig )
}
tlsApp . Automation . Policies = append ( tlsApp . Automation . Policies , ap )
if ap2 != nil {
tlsApp . Automation . Policies = append ( tlsApp . Automation . Policies , ap2 )
2020-03-17 22:00:45 -05:00
}
// certificate loaders
2020-05-29 12:49:21 -05:00
if clVals , ok := sblock . pile [ "tls.cert_loader" ] ; ok {
2020-03-17 22:00:45 -05:00
for _ , clVal := range clVals {
certLoaders = append ( certLoaders , clVal . Value . ( caddytls . CertificateLoader ) )
}
}
}
}
// group certificate loaders by module name, then add to config
if len ( certLoaders ) > 0 {
loadersByName := make ( map [ string ] caddytls . CertificateLoader )
for _ , cl := range certLoaders {
name := caddy . GetModuleName ( cl )
// ugh... technically, we may have multiple FileLoader and FolderLoader
// modules (because the tls directive returns one per occurrence), but
// the config structure expects only one instance of each kind of loader
// module, so we have to combine them... instead of enumerating each
// possible cert loader module in a type switch, we can use reflection,
// which works on any cert loaders that are slice types
if reflect . TypeOf ( cl ) . Kind ( ) == reflect . Slice {
combined := reflect . ValueOf ( loadersByName [ name ] )
if ! combined . IsValid ( ) {
combined = reflect . New ( reflect . TypeOf ( cl ) ) . Elem ( )
}
clVal := reflect . ValueOf ( cl )
for i := 0 ; i < clVal . Len ( ) ; i ++ {
2020-04-08 16:31:51 -05:00
combined = reflect . Append ( combined , clVal . Index ( i ) )
2020-03-17 22:00:45 -05:00
}
loadersByName [ name ] = combined . Interface ( ) . ( caddytls . CertificateLoader )
}
}
for certLoaderName , loaders := range loadersByName {
tlsApp . CertificatesRaw [ certLoaderName ] = caddyconfig . JSON ( loaders , & warnings )
}
}
// set any of the on-demand options, for if/when on-demand TLS is enabled
if onDemand , ok := options [ "on_demand_tls" ] . ( * caddytls . OnDemandConfig ) ; ok {
if tlsApp . Automation == nil {
tlsApp . Automation = new ( caddytls . AutomationConfig )
}
tlsApp . Automation . OnDemand = onDemand
}
httpcaddyfile, caddytls: Multiple edge case fixes; add tests
- Create two default automation policies; if the TLS app is used in
isolation with the 'automate' certificate loader, it will now use
an internal issuer for internal-only names, and an ACME issuer for
all other names by default.
- If the HTTP Caddyfile adds an 'automate' loader, it now also adds an
automation policy for any names in that loader that do not qualify
for public certificates so that they will be issued internally. (It
might be nice if this wasn't necessary, but the alternative is to
either make auto-HTTPS logic way more complex by scanning the names in
the 'automate' loader, or to have an automation policy without an
issuer switch between default issuer based on the name being issued
a certificate - I think I like the latter option better, right now we
do something kind of like that but at a level above each individual
automation policies, we do that switch only when no automation
policies match, rather than when a policy without an issuer does
match.)
- Set the default LoggerName rather than a LoggerNames with an empty
host value, which is now taken literally rather than as a catch-all.
- hostsFromKeys, the function that gets a list of hosts from server
block keys, no longer returns an empty string in its resulting slice,
ever.
2020-04-08 15:46:44 -05:00
// if any hostnames appear on the same server block as a key with
// no host, they will not be used with route matchers because the
// hostless key matches all hosts, therefore, it wouldn't be
// considered for auto-HTTPS, so we need to make sure those hosts
// are manually considered for managed certificates; we also need
// to make sure that any of these names which are internal-only
// get internal certificates by default rather than ACME
var al caddytls . AutomateLoader
internalAP := & caddytls . AutomationPolicy {
2020-11-16 13:05:55 -05:00
IssuersRaw : [ ] json . RawMessage { json . RawMessage ( ` { "module":"internal"} ` ) } ,
httpcaddyfile, caddytls: Multiple edge case fixes; add tests
- Create two default automation policies; if the TLS app is used in
isolation with the 'automate' certificate loader, it will now use
an internal issuer for internal-only names, and an ACME issuer for
all other names by default.
- If the HTTP Caddyfile adds an 'automate' loader, it now also adds an
automation policy for any names in that loader that do not qualify
for public certificates so that they will be issued internally. (It
might be nice if this wasn't necessary, but the alternative is to
either make auto-HTTPS logic way more complex by scanning the names in
the 'automate' loader, or to have an automation policy without an
issuer switch between default issuer based on the name being issued
a certificate - I think I like the latter option better, right now we
do something kind of like that but at a level above each individual
automation policies, we do that switch only when no automation
policies match, rather than when a policy without an issuer does
match.)
- Set the default LoggerName rather than a LoggerNames with an empty
host value, which is now taken literally rather than as a catch-all.
- hostsFromKeys, the function that gets a list of hosts from server
block keys, no longer returns an empty string in its resulting slice,
ever.
2020-04-08 15:46:44 -05:00
}
for h := range hostsSharedWithHostlessKey {
al = append ( al , h )
if ! certmagic . SubjectQualifiesForPublicCert ( h ) {
internalAP . Subjects = append ( internalAP . Subjects , h )
}
}
if len ( al ) > 0 {
tlsApp . CertificatesRaw [ "automate" ] = caddyconfig . JSON ( al , & warnings )
}
if len ( internalAP . Subjects ) > 0 {
if tlsApp . Automation == nil {
tlsApp . Automation = new ( caddytls . AutomationConfig )
}
tlsApp . Automation . Policies = append ( tlsApp . Automation . Policies , internalAP )
}
2020-11-16 13:05:55 -05:00
// if there are any global options set for issuers (ACME ones in particular), make sure they
// take effect in every automation policy that does not have any issuers
if tlsApp . Automation != nil {
globalEmail := options [ "email" ]
globalACMECA := options [ "acme_ca" ]
globalACMECARoot := options [ "acme_ca_root" ]
globalACMEDNS := options [ "acme_dns" ]
globalACMEEAB := options [ "acme_eab" ]
hasGlobalACMEDefaults := globalEmail != nil || globalACMECA != nil || globalACMECARoot != nil || globalACMEDNS != nil || globalACMEEAB != nil
if hasGlobalACMEDefaults {
for _ , ap := range tlsApp . Automation . Policies {
if len ( ap . Issuers ) == 0 {
acme , zerosslACME := new ( caddytls . ACMEIssuer ) , new ( caddytls . ACMEIssuer )
zerossl := & caddytls . ZeroSSLIssuer { ACMEIssuer : zerosslACME }
ap . Issuers = [ ] certmagic . Issuer { acme , zerossl } // TODO: keep this in sync with Caddy's other issuer defaults elsewhere, like in caddytls/automation.go (DefaultIssuers).
// if a non-ZeroSSL endpoint is specified, we assume we can't use the ZeroSSL issuer successfully
if globalACMECA != nil && ! strings . Contains ( globalACMECA . ( string ) , "zerossl" ) {
ap . Issuers = [ ] certmagic . Issuer { acme }
}
}
}
}
}
2020-10-28 21:36:00 -05:00
// finalize and verify policies; do cleanup
if tlsApp . Automation != nil {
2020-11-16 13:05:55 -05:00
for i , ap := range tlsApp . Automation . Policies {
// ensure all issuers have global defaults filled in
for j , issuer := range ap . Issuers {
err := fillInGlobalACMEDefaults ( issuer , options )
if err != nil {
return nil , warnings , fmt . Errorf ( "filling in global issuer defaults for AP %d, issuer %d: %v" , i , j , err )
}
}
// encode all issuer values we created, so they will be rendered in the output
if len ( ap . Issuers ) > 0 && ap . IssuersRaw == nil {
for _ , iss := range ap . Issuers {
issuerName := iss . ( caddy . Module ) . CaddyModule ( ) . ID . Name ( )
ap . IssuersRaw = append ( ap . IssuersRaw , caddyconfig . JSONModuleObject ( iss , "module" , issuerName , & warnings ) )
}
2020-10-28 21:36:00 -05:00
}
2020-03-17 22:00:45 -05:00
}
2020-07-07 09:10:37 -05:00
// consolidate automation policies that are the exact same
tlsApp . Automation . Policies = consolidateAutomationPolicies ( tlsApp . Automation . Policies )
2020-03-17 22:00:45 -05:00
// ensure automation policies don't overlap subjects (this should be
// an error at provision-time as well, but catch it in the adapt phase
// for convenience)
automationHostSet := make ( map [ string ] struct { } )
for _ , ap := range tlsApp . Automation . Policies {
for _ , s := range ap . Subjects {
if _ , ok := automationHostSet [ s ] ; ok {
return nil , warnings , fmt . Errorf ( "hostname appears in more than one automation policy, making certificate management ambiguous: %s" , s )
}
automationHostSet [ s ] = struct { } { }
}
}
2020-10-28 21:36:00 -05:00
// if nothing remains, remove any excess values to clean up the resulting config
if len ( tlsApp . Automation . Policies ) == 0 {
tlsApp . Automation . Policies = nil
}
if reflect . DeepEqual ( tlsApp . Automation , new ( caddytls . AutomationConfig ) ) {
tlsApp . Automation = nil
}
2020-03-17 22:00:45 -05:00
}
return tlsApp , warnings , nil
}
2020-11-16 13:05:55 -05:00
type acmeCapable interface { GetACMEIssuer ( ) * caddytls . ACMEIssuer }
func fillInGlobalACMEDefaults ( issuer certmagic . Issuer , options map [ string ] interface { } ) error {
acmeWrapper , ok := issuer . ( acmeCapable )
if ! ok {
return nil
}
acmeIssuer := acmeWrapper . GetACMEIssuer ( )
if acmeIssuer == nil {
return nil
}
globalEmail := options [ "email" ]
globalACMECA := options [ "acme_ca" ]
globalACMECARoot := options [ "acme_ca_root" ]
globalACMEDNS := options [ "acme_dns" ]
globalACMEEAB := options [ "acme_eab" ]
if globalEmail != nil && acmeIssuer . Email == "" {
acmeIssuer . Email = globalEmail . ( string )
}
if globalACMECA != nil && acmeIssuer . CA == "" {
acmeIssuer . CA = globalACMECA . ( string )
}
if globalACMECARoot != nil && ! sliceContains ( acmeIssuer . TrustedRootsPEMFiles , globalACMECARoot . ( string ) ) {
acmeIssuer . TrustedRootsPEMFiles = append ( acmeIssuer . TrustedRootsPEMFiles , globalACMECARoot . ( string ) )
}
if globalACMEDNS != nil && ( acmeIssuer . Challenges == nil || acmeIssuer . Challenges . DNS == nil ) {
acmeIssuer . Challenges = & caddytls . ChallengesConfig {
DNS : & caddytls . DNSChallengeConfig {
2021-01-05 16:39:30 -05:00
ProviderRaw : caddyconfig . JSONModuleObject ( globalACMEDNS , "name" , globalACMEDNS . ( caddy . Module ) . CaddyModule ( ) . ID . Name ( ) , nil ) ,
2020-11-16 13:05:55 -05:00
} ,
}
}
if globalACMEEAB != nil && acmeIssuer . ExternalAccount == nil {
acmeIssuer . ExternalAccount = globalACMEEAB . ( * acme . EAB )
}
return nil
}
2020-03-17 22:00:45 -05:00
// newBaseAutomationPolicy returns a new TLS automation policy that gets
// its values from the global options map. It should be used as the base
// for any other automation policies. A nil policy (and no error) will be
// returned if there are no default/global options. However, if always is
// true, a non-nil value will always be returned (unless there is an error).
func newBaseAutomationPolicy ( options map [ string ] interface { } , warnings [ ] caddyconfig . Warning , always bool ) ( * caddytls . AutomationPolicy , error ) {
caddytls: Add support for ZeroSSL; add Caddyfile support for issuers (#3633)
* caddytls: Add support for ZeroSSL; add Caddyfile support for issuers
Configuring issuers explicitly in a Caddyfile is not easily compatible
with existing ACME-specific parameters such as email or acme_ca which
infer the kind of issuer it creates (this is complicated now because
the ZeroSSL issuer wraps the ACME issuer)... oh well, we can revisit
that later if we need to.
New Caddyfile global option:
{
cert_issuer <name> ...
}
Or, alternatively, as a tls subdirective:
tls {
issuer <name> ...
}
For example, to use ZeroSSL with an API key:
{
cert_issuser zerossl API_KEY
}
For now, that still uses ZeroSSL's ACME endpoint; it fetches EAB
credentials for you. You can also provide the EAB credentials directly
just like any other ACME endpoint:
{
cert_issuer acme {
eab KEY_ID MAC_KEY
}
}
All these examples use the new global option (or tls subdirective). You
can still use traditional/existing options with ZeroSSL, since it's
just another ACME endpoint:
{
acme_ca https://acme.zerossl.com/v2/DV90
acme_eab KEY_ID MAC_KEY
}
That's all there is to it. You just can't mix-and-match acme_* options
with cert_issuer, because it becomes confusing/ambiguous/complicated to
merge the settings.
* Fix broken test
This test was asserting buggy behavior, oops - glad this branch both
discovers and fixes the bug at the same time!
* Fix broken test (post-merge)
* Update modules/caddytls/acmeissuer.go
Fix godoc comment
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
* Add support for ZeroSSL's EAB-by-email endpoint
Also transform the ACMEIssuer into ZeroSSLIssuer implicitly if set to
the ZeroSSL endpoint without EAB (the ZeroSSLIssuer is needed to
generate EAB if not already provided); this is now possible with either
an API key or an email address.
* go.mod: Use latest certmagic, acmez, and x/net
* Wrap underlying logic rather than repeating it
Oops, duh
* Form-encode email info into request body for EAB endpoint
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
2020-08-11 09:58:06 -05:00
issuer , hasIssuer := options [ "cert_issuer" ]
2020-11-16 13:05:55 -05:00
_ , hasLocalCerts := options [ "local_certs" ]
2020-04-08 12:09:38 -05:00
keyType , hasKeyType := options [ "key_type" ]
2020-03-17 22:00:45 -05:00
2020-11-16 13:05:55 -05:00
hasGlobalAutomationOpts := hasIssuer || hasLocalCerts || hasKeyType
2020-03-17 22:00:45 -05:00
// if there are no global options related to automation policies
// set, then we can just return right away
if ! hasGlobalAutomationOpts {
if always {
return new ( caddytls . AutomationPolicy ) , nil
}
return nil , nil
}
ap := new ( caddytls . AutomationPolicy )
2020-11-16 13:05:55 -05:00
if hasKeyType {
caddytls: Add support for ZeroSSL; add Caddyfile support for issuers (#3633)
* caddytls: Add support for ZeroSSL; add Caddyfile support for issuers
Configuring issuers explicitly in a Caddyfile is not easily compatible
with existing ACME-specific parameters such as email or acme_ca which
infer the kind of issuer it creates (this is complicated now because
the ZeroSSL issuer wraps the ACME issuer)... oh well, we can revisit
that later if we need to.
New Caddyfile global option:
{
cert_issuer <name> ...
}
Or, alternatively, as a tls subdirective:
tls {
issuer <name> ...
}
For example, to use ZeroSSL with an API key:
{
cert_issuser zerossl API_KEY
}
For now, that still uses ZeroSSL's ACME endpoint; it fetches EAB
credentials for you. You can also provide the EAB credentials directly
just like any other ACME endpoint:
{
cert_issuer acme {
eab KEY_ID MAC_KEY
}
}
All these examples use the new global option (or tls subdirective). You
can still use traditional/existing options with ZeroSSL, since it's
just another ACME endpoint:
{
acme_ca https://acme.zerossl.com/v2/DV90
acme_eab KEY_ID MAC_KEY
}
That's all there is to it. You just can't mix-and-match acme_* options
with cert_issuer, because it becomes confusing/ambiguous/complicated to
merge the settings.
* Fix broken test
This test was asserting buggy behavior, oops - glad this branch both
discovers and fixes the bug at the same time!
* Fix broken test (post-merge)
* Update modules/caddytls/acmeissuer.go
Fix godoc comment
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
* Add support for ZeroSSL's EAB-by-email endpoint
Also transform the ACMEIssuer into ZeroSSLIssuer implicitly if set to
the ZeroSSL endpoint without EAB (the ZeroSSLIssuer is needed to
generate EAB if not already provided); this is now possible with either
an API key or an email address.
* go.mod: Use latest certmagic, acmez, and x/net
* Wrap underlying logic rather than repeating it
Oops, duh
* Form-encode email info into request body for EAB endpoint
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
2020-08-11 09:58:06 -05:00
ap . KeyType = keyType . ( string )
}
2020-03-17 22:00:45 -05:00
2020-11-16 13:05:55 -05:00
if hasIssuer && hasLocalCerts {
return nil , fmt . Errorf ( "global options are ambiguous: local_certs is confusing when combined with cert_issuer, because local_certs is also a specific kind of issuer" )
}
caddytls: Add support for ZeroSSL; add Caddyfile support for issuers (#3633)
* caddytls: Add support for ZeroSSL; add Caddyfile support for issuers
Configuring issuers explicitly in a Caddyfile is not easily compatible
with existing ACME-specific parameters such as email or acme_ca which
infer the kind of issuer it creates (this is complicated now because
the ZeroSSL issuer wraps the ACME issuer)... oh well, we can revisit
that later if we need to.
New Caddyfile global option:
{
cert_issuer <name> ...
}
Or, alternatively, as a tls subdirective:
tls {
issuer <name> ...
}
For example, to use ZeroSSL with an API key:
{
cert_issuser zerossl API_KEY
}
For now, that still uses ZeroSSL's ACME endpoint; it fetches EAB
credentials for you. You can also provide the EAB credentials directly
just like any other ACME endpoint:
{
cert_issuer acme {
eab KEY_ID MAC_KEY
}
}
All these examples use the new global option (or tls subdirective). You
can still use traditional/existing options with ZeroSSL, since it's
just another ACME endpoint:
{
acme_ca https://acme.zerossl.com/v2/DV90
acme_eab KEY_ID MAC_KEY
}
That's all there is to it. You just can't mix-and-match acme_* options
with cert_issuer, because it becomes confusing/ambiguous/complicated to
merge the settings.
* Fix broken test
This test was asserting buggy behavior, oops - glad this branch both
discovers and fixes the bug at the same time!
* Fix broken test (post-merge)
* Update modules/caddytls/acmeissuer.go
Fix godoc comment
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
* Add support for ZeroSSL's EAB-by-email endpoint
Also transform the ACMEIssuer into ZeroSSLIssuer implicitly if set to
the ZeroSSL endpoint without EAB (the ZeroSSLIssuer is needed to
generate EAB if not already provided); this is now possible with either
an API key or an email address.
* go.mod: Use latest certmagic, acmez, and x/net
* Wrap underlying logic rather than repeating it
Oops, duh
* Form-encode email info into request body for EAB endpoint
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
2020-08-11 09:58:06 -05:00
if hasIssuer {
2020-11-16 13:05:55 -05:00
ap . Issuers = [ ] certmagic . Issuer { issuer . ( certmagic . Issuer ) }
} else if hasLocalCerts {
ap . Issuers = [ ] certmagic . Issuer { new ( caddytls . InternalIssuer ) }
2020-03-17 22:00:45 -05:00
}
return ap , nil
}
caddytls: Add support for ZeroSSL; add Caddyfile support for issuers (#3633)
* caddytls: Add support for ZeroSSL; add Caddyfile support for issuers
Configuring issuers explicitly in a Caddyfile is not easily compatible
with existing ACME-specific parameters such as email or acme_ca which
infer the kind of issuer it creates (this is complicated now because
the ZeroSSL issuer wraps the ACME issuer)... oh well, we can revisit
that later if we need to.
New Caddyfile global option:
{
cert_issuer <name> ...
}
Or, alternatively, as a tls subdirective:
tls {
issuer <name> ...
}
For example, to use ZeroSSL with an API key:
{
cert_issuser zerossl API_KEY
}
For now, that still uses ZeroSSL's ACME endpoint; it fetches EAB
credentials for you. You can also provide the EAB credentials directly
just like any other ACME endpoint:
{
cert_issuer acme {
eab KEY_ID MAC_KEY
}
}
All these examples use the new global option (or tls subdirective). You
can still use traditional/existing options with ZeroSSL, since it's
just another ACME endpoint:
{
acme_ca https://acme.zerossl.com/v2/DV90
acme_eab KEY_ID MAC_KEY
}
That's all there is to it. You just can't mix-and-match acme_* options
with cert_issuer, because it becomes confusing/ambiguous/complicated to
merge the settings.
* Fix broken test
This test was asserting buggy behavior, oops - glad this branch both
discovers and fixes the bug at the same time!
* Fix broken test (post-merge)
* Update modules/caddytls/acmeissuer.go
Fix godoc comment
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
* Add support for ZeroSSL's EAB-by-email endpoint
Also transform the ACMEIssuer into ZeroSSLIssuer implicitly if set to
the ZeroSSL endpoint without EAB (the ZeroSSLIssuer is needed to
generate EAB if not already provided); this is now possible with either
an API key or an email address.
* go.mod: Use latest certmagic, acmez, and x/net
* Wrap underlying logic rather than repeating it
Oops, duh
* Form-encode email info into request body for EAB endpoint
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
2020-08-11 09:58:06 -05:00
// disambiguateACMEIssuer returns an issuer based on the properties of acmeIssuer.
// If acmeIssuer implicitly configures a certain kind of ACMEIssuer (for example,
// ZeroSSL), the proper wrapper over acmeIssuer will be returned instead.
func disambiguateACMEIssuer ( acmeIssuer * caddytls . ACMEIssuer ) certmagic . Issuer {
// as a special case, we integrate with ZeroSSL's ACME endpoint if it looks like an
2021-01-04 13:25:29 -05:00
// implicit ZeroSSL configuration (this requires a wrapper type over ACMEIssuer
caddytls: Add support for ZeroSSL; add Caddyfile support for issuers (#3633)
* caddytls: Add support for ZeroSSL; add Caddyfile support for issuers
Configuring issuers explicitly in a Caddyfile is not easily compatible
with existing ACME-specific parameters such as email or acme_ca which
infer the kind of issuer it creates (this is complicated now because
the ZeroSSL issuer wraps the ACME issuer)... oh well, we can revisit
that later if we need to.
New Caddyfile global option:
{
cert_issuer <name> ...
}
Or, alternatively, as a tls subdirective:
tls {
issuer <name> ...
}
For example, to use ZeroSSL with an API key:
{
cert_issuser zerossl API_KEY
}
For now, that still uses ZeroSSL's ACME endpoint; it fetches EAB
credentials for you. You can also provide the EAB credentials directly
just like any other ACME endpoint:
{
cert_issuer acme {
eab KEY_ID MAC_KEY
}
}
All these examples use the new global option (or tls subdirective). You
can still use traditional/existing options with ZeroSSL, since it's
just another ACME endpoint:
{
acme_ca https://acme.zerossl.com/v2/DV90
acme_eab KEY_ID MAC_KEY
}
That's all there is to it. You just can't mix-and-match acme_* options
with cert_issuer, because it becomes confusing/ambiguous/complicated to
merge the settings.
* Fix broken test
This test was asserting buggy behavior, oops - glad this branch both
discovers and fixes the bug at the same time!
* Fix broken test (post-merge)
* Update modules/caddytls/acmeissuer.go
Fix godoc comment
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
* Add support for ZeroSSL's EAB-by-email endpoint
Also transform the ACMEIssuer into ZeroSSLIssuer implicitly if set to
the ZeroSSL endpoint without EAB (the ZeroSSLIssuer is needed to
generate EAB if not already provided); this is now possible with either
an API key or an email address.
* go.mod: Use latest certmagic, acmez, and x/net
* Wrap underlying logic rather than repeating it
Oops, duh
* Form-encode email info into request body for EAB endpoint
Co-authored-by: Francis Lavoie <lavofr@gmail.com>
2020-08-11 09:58:06 -05:00
// because of the EAB generation; if EAB is provided, we can use plain ACMEIssuer)
if strings . Contains ( acmeIssuer . CA , "acme.zerossl.com" ) && acmeIssuer . ExternalAccount == nil {
return & caddytls . ZeroSSLIssuer { ACMEIssuer : acmeIssuer }
}
return acmeIssuer
}
2020-03-17 22:00:45 -05:00
// consolidateAutomationPolicies combines automation policies that are the same,
// for a cleaner overall output.
func consolidateAutomationPolicies ( aps [ ] * caddytls . AutomationPolicy ) [ ] * caddytls . AutomationPolicy {
2020-10-28 21:36:00 -05:00
// sort from most specific to least specific; we depend on this ordering
sort . SliceStable ( aps , func ( i , j int ) bool {
if automationPolicyIsSubset ( aps [ i ] , aps [ j ] ) {
return true
}
if automationPolicyIsSubset ( aps [ j ] , aps [ i ] ) {
return false
}
return len ( aps [ i ] . Subjects ) > len ( aps [ j ] . Subjects )
} )
// remove any empty policies (except subjects, of course)
emptyAP := new ( caddytls . AutomationPolicy )
2020-03-17 22:00:45 -05:00
for i := 0 ; i < len ( aps ) ; i ++ {
2020-10-28 21:36:00 -05:00
emptyAP . Subjects = aps [ i ] . Subjects
if reflect . DeepEqual ( aps [ i ] , emptyAP ) {
aps = append ( aps [ : i ] , aps [ i + 1 : ] ... )
i --
}
}
2020-03-17 22:00:45 -05:00
2020-10-28 21:36:00 -05:00
// remove or combine duplicate policies
for i := 0 ; i < len ( aps ) ; i ++ {
2020-12-07 16:22:47 -05:00
// compare only with next policies; we sorted by specificity so we must not delete earlier policies
2020-10-28 21:36:00 -05:00
for j := i + 1 ; j < len ( aps ) ; j ++ {
2020-03-17 22:00:45 -05:00
// if they're exactly equal in every way, just keep one of them
if reflect . DeepEqual ( aps [ i ] , aps [ j ] ) {
aps = append ( aps [ : j ] , aps [ j + 1 : ] ... )
i --
break
}
// if the policy is the same, we can keep just one, but we have
// to be careful which one we keep; if only one has any hostnames
// defined, then we need to keep the one without any hostnames,
// otherwise the one without any subjects (a catch-all) would be
// eaten up by the one with subjects; and if both have subjects, we
// need to combine their lists
2020-11-16 13:05:55 -05:00
if reflect . DeepEqual ( aps [ i ] . IssuersRaw , aps [ j ] . IssuersRaw ) &&
2020-03-17 22:00:45 -05:00
bytes . Equal ( aps [ i ] . StorageRaw , aps [ j ] . StorageRaw ) &&
aps [ i ] . MustStaple == aps [ j ] . MustStaple &&
aps [ i ] . KeyType == aps [ j ] . KeyType &&
aps [ i ] . OnDemand == aps [ j ] . OnDemand &&
2020-03-26 15:02:29 -05:00
aps [ i ] . RenewalWindowRatio == aps [ j ] . RenewalWindowRatio {
2020-10-28 21:36:00 -05:00
if len ( aps [ i ] . Subjects ) > 0 && len ( aps [ j ] . Subjects ) == 0 {
// later policy (at j) has no subjects ("catch-all"), so we can
// remove the identical-but-more-specific policy that comes first
// AS LONG AS it is not shadowed by another policy before it; e.g.
// if policy i is for example.com, policy i+1 is '*.com', and policy
// j is catch-all, we cannot remove policy i because that would
// cause example.com to be served by the less specific policy for
// '*.com', which might be different (yes we've seen this happen)
if automationPolicyShadows ( i , aps ) >= j {
aps = append ( aps [ : i ] , aps [ i + 1 : ] ... )
2021-01-04 13:25:29 -05:00
i --
2020-10-28 21:36:00 -05:00
}
2020-03-17 22:00:45 -05:00
} else {
2020-08-06 14:56:23 -05:00
// avoid repeated subjects
for _ , subj := range aps [ j ] . Subjects {
if ! sliceContains ( aps [ i ] . Subjects , subj ) {
aps [ i ] . Subjects = append ( aps [ i ] . Subjects , subj )
}
}
2020-03-17 22:00:45 -05:00
aps = append ( aps [ : j ] , aps [ j + 1 : ] ... )
2020-12-07 16:22:47 -05:00
j --
2020-03-17 22:00:45 -05:00
}
}
}
}
return aps
}
2020-10-28 21:36:00 -05:00
// automationPolicyIsSubset returns true if a's subjects are a subset
// of b's subjects.
func automationPolicyIsSubset ( a , b * caddytls . AutomationPolicy ) bool {
if len ( b . Subjects ) == 0 {
return true
}
if len ( a . Subjects ) == 0 {
return false
}
for _ , aSubj := range a . Subjects {
var inSuperset bool
for _ , bSubj := range b . Subjects {
if certmagic . MatchWildcard ( aSubj , bSubj ) {
inSuperset = true
break
}
}
if ! inSuperset {
return false
}
}
return true
}
// automationPolicyShadows returns the index of a policy that aps[i] shadows;
// in other words, for all policies after position i, if that policy covers
// the same subjects but is less specific, that policy's position is returned,
// or -1 if no shadowing is found. For example, if policy i is for
// "foo.example.com" and policy i+2 is for "*.example.com", then i+2 will be
// returned, since that policy is shadowed by i, which is in front.
func automationPolicyShadows ( i int , aps [ ] * caddytls . AutomationPolicy ) int {
for j := i + 1 ; j < len ( aps ) ; j ++ {
if automationPolicyIsSubset ( aps [ i ] , aps [ j ] ) {
return j
}
}
return - 1
}