certs: order on the domain that covers the mail host (#82) #87
No files matched your search
@@ -167,7 +167,12 @@ This is early. What is built:
|
||||
because DNS wasn't in place during the install -- or, on a domain not yet
|
||||
on ACME, ACME turned on where the managed Caddy or your own web server
|
||||
passes the challenges. It waits for the mail ports to present the new
|
||||
certificate. The console's and the webmail's certificates are the
|
||||
certificate. A mail host on another domain from the install's gets its
|
||||
certificate on that domain: the server's own, or one added for
|
||||
certificates only (no DKIM keys, nothing published), as the console's
|
||||
Order a certificate does, on the install's ACME account. A domain's
|
||||
default certificate names the server's hostname, so if that is still an
|
||||
old name it says where to change it first. The console's and the webmail's certificates are the
|
||||
proxy's, which renews them itself.
|
||||
|
||||
- **`status`** -- what is installed, what is running, and where those two
|
||||
|
||||
@@ -1179,6 +1179,13 @@ func certsCmd(args []string) int {
|
||||
fmt.Println("and paste it, or set INBUXA_API_KEY. It isn't kept.")
|
||||
return 1
|
||||
}
|
||||
// The managed Caddy forwards the challenges only for the names it was
|
||||
// installed with: a mail host it doesn't serve can't be validated (#82).
|
||||
if o.Proxy == "caddy" && found.MailHost != "" && !strings.EqualFold(found.MailHost, o.MailHost) {
|
||||
fmt.Printf("\nThe proxy here serves %s, not %s, so the order can't be validated. Move the install to\n", found.MailHost, o.MailHost)
|
||||
fmt.Printf("the new name first:\n sudo inbuxa install --mail-host %s --dry-run\n", o.MailHost)
|
||||
return 1
|
||||
}
|
||||
fmt.Println()
|
||||
o.Key = *key
|
||||
if _, err := apply.Renew(ctx, st, o, &printer{}); err != nil {
|
||||
|
||||
+94
-13
@@ -212,45 +212,126 @@ type CertsOptions struct {
|
||||
ACMEDirectory string
|
||||
}
|
||||
|
||||
// orderPlan is how Renew gets the mail host a certificate: which domain it
|
||||
// orders on, and what it does to that domain first.
|
||||
type orderPlan struct {
|
||||
Action string // retry, set (these names on this account), add (a certificate-only domain, then set), enable (ACME on the install's domain)
|
||||
DomainID string // empty for add
|
||||
DomainName string
|
||||
ProviderID string
|
||||
Names []string // for set and add; empty means the server's default set
|
||||
}
|
||||
|
||||
// planOrder picks the domain whose certificate is to name host (#82). The
|
||||
// server orders one certificate per domain, and a domain's default set of
|
||||
// names includes the server's own hostname only when it is inside that
|
||||
// domain. So a mail host on another domain from the install's needs that
|
||||
// other domain's certificate to name it: the one the server has, or one
|
||||
// added for certificates only, as the console's Order a certificate does,
|
||||
// on the install's ACME account.
|
||||
func planOrder(domains []jmap.DomainCert, installDomain, host, serverName string) (orderPlan, error) {
|
||||
host = strings.ToLower(strings.TrimSuffix(host, "."))
|
||||
var install, cover *jmap.DomainCert
|
||||
for i := range domains {
|
||||
d := &domains[i]
|
||||
name := strings.ToLower(d.Name)
|
||||
if strings.EqualFold(d.Name, installDomain) {
|
||||
install = d
|
||||
}
|
||||
if (host == name || strings.HasSuffix(host, "."+name)) && (cover == nil || len(name) > len(cover.Name)) {
|
||||
cover = d
|
||||
}
|
||||
}
|
||||
if install == nil {
|
||||
return orderPlan{}, fmt.Errorf("domain %s does not exist on this server", installDomain)
|
||||
}
|
||||
if cover == nil {
|
||||
parent := host[strings.Index(host, ".")+1:]
|
||||
if !strings.Contains(host, ".") || !strings.Contains(parent, ".") {
|
||||
return orderPlan{}, fmt.Errorf("%s isn't a name a certificate can be ordered for", host)
|
||||
}
|
||||
if install.Kind != "Automatic" || install.ProviderID == "" {
|
||||
return orderPlan{}, fmt.Errorf("%s is on another domain, and %s has no ACME account yet to order with: run `inbuxa certs` without --mail-host first, or order it in the console (Settings, Security, Certificates)", host, installDomain)
|
||||
}
|
||||
return orderPlan{Action: "add", DomainName: parent, ProviderID: install.ProviderID, Names: []string{host}}, nil
|
||||
}
|
||||
if cover.Kind != "Automatic" || cover.ProviderID == "" {
|
||||
if cover == install {
|
||||
return orderPlan{Action: "enable", DomainID: install.ID, DomainName: install.Name}, nil
|
||||
}
|
||||
if install.Kind != "Automatic" || install.ProviderID == "" {
|
||||
return orderPlan{}, fmt.Errorf("neither %s nor %s orders certificates from ACME yet: order one for %s in the console (Settings, Security, Certificates)", cover.Name, installDomain, host)
|
||||
}
|
||||
return orderPlan{Action: "set", DomainID: cover.ID, DomainName: cover.Name, ProviderID: install.ProviderID, Names: []string{host}}, nil
|
||||
}
|
||||
if len(cover.Names) == 0 {
|
||||
// The default set: it names the server's hostname, and only that one.
|
||||
if serverName != "" && !strings.EqualFold(strings.TrimSuffix(serverName, "."), host) {
|
||||
return orderPlan{}, fmt.Errorf("the server's hostname is %s, so %s's certificate names that, not %s: set the hostname to %s in the console (Settings, Network, General), then run this again", serverName, cover.Name, host, host)
|
||||
}
|
||||
return orderPlan{Action: "retry", DomainID: cover.ID, DomainName: cover.Name}, nil
|
||||
}
|
||||
for _, n := range cover.Names {
|
||||
if strings.EqualFold(strings.TrimSuffix(n, "."), host) {
|
||||
return orderPlan{Action: "retry", DomainID: cover.ID, DomainName: cover.Name}, nil
|
||||
}
|
||||
}
|
||||
return orderPlan{Action: "set", DomainID: cover.ID, DomainName: cover.Name, ProviderID: cover.ProviderID, Names: append(append([]string{}, cover.Names...), host)}, nil
|
||||
}
|
||||
|
||||
// Renew gets the server a certificate: a new order on ACME, or ACME turned
|
||||
// on first where something here can pass its challenges. It returns what the
|
||||
// mail ports present afterwards.
|
||||
func Renew(ctx context.Context, st *state.State, o CertsOptions, log Log) (*Served, error) {
|
||||
srv := &jmap.Client{BaseURL: "http://" + hostFinalBind, Token: o.Key}
|
||||
domainID, err := srv.DomainID(ctx, st.Domain)
|
||||
domains, err := srv.DomainCerts(ctx)
|
||||
if err != nil {
|
||||
var he *jmap.HTTPError
|
||||
if errors.As(err, &he) && (he.Status == 401 || he.Status == 403) {
|
||||
return nil, ErrKeyRefused
|
||||
}
|
||||
return nil, fmt.Errorf("finding %s on the server: %w", st.Domain, err)
|
||||
return nil, fmt.Errorf("reading the server's domains: %w", err)
|
||||
}
|
||||
kind, _, err := srv.CertificateManagement(ctx, domainID)
|
||||
serverName, _ := srv.ServerName(ctx) // only sharpens the advice when it can be read
|
||||
op, err := planOrder(domains, st.Domain, o.MailHost, serverName)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if kind == "Automatic" {
|
||||
if op.Action != "retry" && o.Proxy == "" {
|
||||
return nil, fmt.Errorf("nothing here passes the server's ACME challenges on port 80 "+
|
||||
"(the install has no proxy): the certificate for %s is yours to arrange", o.MailHost)
|
||||
}
|
||||
if o.Proxy == "snippets" && op.Action != "retry" {
|
||||
log.Info("the challenges reach the server through your web server, so it must be loading %s first",
|
||||
filepath.Join(st.Dir, "proxy"))
|
||||
}
|
||||
domainID := op.DomainID
|
||||
switch op.Action {
|
||||
case "retry":
|
||||
log.Step("starting a new certificate order for %s", o.MailHost)
|
||||
if err := srv.RetryCertificates(ctx, domainID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
} else {
|
||||
if o.Proxy == "" {
|
||||
return nil, fmt.Errorf("the domain's certificates are %s, and nothing here passes the server's ACME challenges on port 80 "+
|
||||
"(the install has no proxy): its certificate is yours to arrange", strings.ToLower(kind))
|
||||
}
|
||||
case "enable":
|
||||
email := o.Email
|
||||
if email == "" {
|
||||
email = "postmaster@" + st.Domain
|
||||
}
|
||||
log.Step("turning on certificates for %s, from ACME (contact %s)", o.MailHost, email)
|
||||
if o.Proxy == "snippets" {
|
||||
log.Info("the challenges reach the server through your web server, so it must be loading %s first",
|
||||
filepath.Join(st.Dir, "proxy"))
|
||||
}
|
||||
if _, err := srv.EnableACME(ctx, domainID, o.ACMEDirectory, email); err != nil {
|
||||
return nil, fmt.Errorf("enabling ACME: %w", err)
|
||||
}
|
||||
case "add", "set":
|
||||
if op.Action == "add" {
|
||||
log.Step("adding %s to the server for certificates only (no DKIM keys, nothing published)", op.DomainName)
|
||||
if domainID, err = srv.AddCertificateDomain(ctx, op.DomainName); err != nil {
|
||||
return nil, fmt.Errorf("adding %s: %w", op.DomainName, err)
|
||||
}
|
||||
}
|
||||
log.Step("ordering a certificate for %s on %s (%s)", o.MailHost, op.DomainName, strings.Join(op.Names, ", "))
|
||||
if err := srv.SetCertificates(ctx, domainID, op.ProviderID, op.Names); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
// Waited for as the mail ports present it, not as the server lists it:
|
||||
// a certificate about to expire is listed too, and is what is being
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
package apply
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/jmap"
|
||||
)
|
||||
|
||||
func auto(id, name string, names ...string) jmap.DomainCert {
|
||||
return jmap.DomainCert{ID: id, Name: name, Kind: "Automatic", ProviderID: "acme1", Names: names}
|
||||
}
|
||||
|
||||
// #82: the domain that orders a certificate naming the mail host.
|
||||
func TestPlanOrder(t *testing.T) {
|
||||
install := auto("d1", "example.com")
|
||||
cases := []struct {
|
||||
name string
|
||||
domains []jmap.DomainCert
|
||||
host, srv string
|
||||
want orderPlan
|
||||
wantErrHas string
|
||||
}{
|
||||
{"same domain, default names, server already called that", []jmap.DomainCert{install}, "mail.example.com", "mail.example.com",
|
||||
orderPlan{Action: "retry", DomainID: "d1", DomainName: "example.com"}, ""},
|
||||
{"same domain, default names, server still has its old name", []jmap.DomainCert{install}, "mx.example.com", "mail.example.com",
|
||||
orderPlan{}, "set the hostname to mx.example.com"},
|
||||
{"another domain the server doesn't have: added for certificates", []jmap.DomainCert{install}, "mail.example.net", "",
|
||||
orderPlan{Action: "add", DomainName: "example.net", ProviderID: "acme1", Names: []string{"mail.example.net"}}, ""},
|
||||
{"another domain with manual certificates: the install's account, just that name",
|
||||
[]jmap.DomainCert{install, {ID: "d2", Name: "example.net", Kind: "Manual"}}, "mail.example.net", "",
|
||||
orderPlan{Action: "set", DomainID: "d2", DomainName: "example.net", ProviderID: "acme1", Names: []string{"mail.example.net"}}, ""},
|
||||
{"names entered in the console are kept, and the host added",
|
||||
[]jmap.DomainCert{install, auto("d2", "example.net", "autoconfig.example.net")}, "mail.example.net", "",
|
||||
orderPlan{Action: "set", DomainID: "d2", DomainName: "example.net", ProviderID: "acme1", Names: []string{"autoconfig.example.net", "mail.example.net"}}, ""},
|
||||
{"names that already include it: just order again",
|
||||
[]jmap.DomainCert{install, auto("d2", "example.net", "mail.example.net")}, "MAIL.example.net.", "",
|
||||
orderPlan{Action: "retry", DomainID: "d2", DomainName: "example.net"}, ""},
|
||||
{"the closest domain wins", []jmap.DomainCert{install, auto("d2", "example.net"), {ID: "d3", Name: "eu.example.net", Kind: "Manual"}},
|
||||
"mail.eu.example.net", "", orderPlan{Action: "set", DomainID: "d3", DomainName: "eu.example.net", ProviderID: "acme1", Names: []string{"mail.eu.example.net"}}, ""},
|
||||
{"install domain on manual certificates: turn ACME on, as before", []jmap.DomainCert{{ID: "d1", Name: "example.com", Kind: "Manual"}},
|
||||
"mail.example.com", "", orderPlan{Action: "enable", DomainID: "d1", DomainName: "example.com"}, ""},
|
||||
{"another domain with no ACME account anywhere", []jmap.DomainCert{{ID: "d1", Name: "example.com", Kind: "Manual"}},
|
||||
"mail.example.net", "", orderPlan{}, "no ACME account"},
|
||||
{"install domain missing", nil, "mail.example.com", "", orderPlan{}, "does not exist"},
|
||||
}
|
||||
for _, c := range cases {
|
||||
got, err := planOrder(c.domains, "example.com", c.host, c.srv)
|
||||
if c.wantErrHas != "" {
|
||||
if err == nil || !strings.Contains(err.Error(), c.wantErrHas) {
|
||||
t.Errorf("%s: err = %v, want one saying %q", c.name, err, c.wantErrHas)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if err != nil || !reflect.DeepEqual(got, c.want) {
|
||||
t.Errorf("%s:\n got %+v, %v\nwant %+v", c.name, got, err, c.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
+113
-5
@@ -12,6 +12,7 @@ import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
@@ -211,18 +212,36 @@ func (c *Client) CertificateManagement(ctx context.Context, domainID string) (ki
|
||||
|
||||
// RetryCertificates starts a fresh ACME order for the domain. A failed order
|
||||
// is not retried on a restart; moving the domain to manual and straight back
|
||||
// is what starts a new one.
|
||||
// is what starts a new one. The names the domain's certificate covers are
|
||||
// kept: names entered in the console stay, and an empty set stays the
|
||||
// server's default one.
|
||||
func (c *Client) RetryCertificates(ctx context.Context, domainID string) error {
|
||||
kind, providerID, err := c.CertificateManagement(ctx, domainID)
|
||||
d, err := c.domainCerts(ctx, []string{domainID})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if kind != "Automatic" || providerID == "" {
|
||||
return fmt.Errorf("the domain's certificates are %q, not managed by ACME", kind)
|
||||
if len(d) != 1 {
|
||||
return errors.New("x:Domain/get did not return the domain")
|
||||
}
|
||||
if d[0].Kind != "Automatic" || d[0].ProviderID == "" {
|
||||
return fmt.Errorf("the domain's certificates are %q, not managed by ACME", d[0].Kind)
|
||||
}
|
||||
return c.SetCertificates(ctx, domainID, d[0].ProviderID, d[0].Names)
|
||||
}
|
||||
|
||||
// SetCertificates puts the domain's certificates on the ACME account with
|
||||
// exactly these names (none: the server's default set), and starts an order
|
||||
// for them by moving it to manual and straight back.
|
||||
func (c *Client) SetCertificates(ctx context.Context, domainID, providerID string, names []string) error {
|
||||
auto := automaticCertificates(providerID)
|
||||
sans := map[string]bool{}
|
||||
for _, n := range names {
|
||||
sans[n] = true
|
||||
}
|
||||
auto["certificateManagement"].(map[string]any)["subjectAlternativeNames"] = sans
|
||||
rs, err := c.Do(ctx,
|
||||
Call{"x:Domain/set", map[string]any{"update": map[string]any{domainID: map[string]any{"certificateManagement": map[string]any{"@type": "Manual"}}}}, "0"},
|
||||
Call{"x:Domain/set", map[string]any{"update": map[string]any{domainID: automaticCertificates(providerID)}}, "1"},
|
||||
Call{"x:Domain/set", map[string]any{"update": map[string]any{domainID: auto}}, "1"},
|
||||
)
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -245,6 +264,95 @@ func automaticCertificates(providerID string) map[string]any {
|
||||
}}
|
||||
}
|
||||
|
||||
// DomainCert is a domain and how its certificates are managed.
|
||||
type DomainCert struct {
|
||||
ID, Name string
|
||||
Kind string // Automatic or Manual
|
||||
ProviderID string // the ACME account, when Automatic
|
||||
Names []string // the names its certificate covers; empty is the server's default set
|
||||
}
|
||||
|
||||
// DomainCerts lists every domain with its certificate management.
|
||||
func (c *Client) DomainCerts(ctx context.Context) ([]DomainCert, error) {
|
||||
return c.domainCerts(ctx, nil)
|
||||
}
|
||||
|
||||
func (c *Client) domainCerts(ctx context.Context, ids []string) ([]DomainCert, error) {
|
||||
args := map[string]any{"properties": []string{"name", "certificateManagement"}}
|
||||
if ids != nil {
|
||||
args["ids"] = ids
|
||||
} else {
|
||||
args["ids"] = nil
|
||||
}
|
||||
rs, err := c.Do(ctx, Call{"x:Domain/get", args, "0"})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var got struct {
|
||||
List []struct {
|
||||
ID string `json:"id"`
|
||||
Name string `json:"name"`
|
||||
CertificateManagement struct {
|
||||
Type string `json:"@type"`
|
||||
AcmeProviderID string `json:"acmeProviderId"`
|
||||
SubjectAlternativeNames map[string]bool `json:"subjectAlternativeNames"`
|
||||
} `json:"certificateManagement"`
|
||||
} `json:"list"`
|
||||
}
|
||||
if err := json.Unmarshal(rs[0].Args, &got); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := make([]DomainCert, 0, len(got.List))
|
||||
for _, d := range got.List {
|
||||
cm := d.CertificateManagement
|
||||
dc := DomainCert{ID: d.ID, Name: d.Name, Kind: cm.Type, ProviderID: cm.AcmeProviderID}
|
||||
for n := range cm.SubjectAlternativeNames {
|
||||
dc.Names = append(dc.Names, n)
|
||||
}
|
||||
sort.Strings(dc.Names)
|
||||
out = append(out, dc)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// AddCertificateDomain adds a domain that is there only for certificates,
|
||||
// as the console's Order a certificate does: no DKIM keys, nothing published.
|
||||
func (c *Client) AddCertificateDomain(ctx context.Context, name string) (string, error) {
|
||||
rs, err := c.Do(ctx, Call{"x:Domain/set", map[string]any{"create": map[string]any{"d": map[string]any{
|
||||
"name": name,
|
||||
"description": "Added for certificates",
|
||||
"dkimManagement": map[string]any{"@type": "Manual"},
|
||||
"dnsManagement": map[string]any{"@type": "Manual"},
|
||||
"certificateManagement": map[string]any{"@type": "Manual"},
|
||||
}}}, "0"})
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
s, err := DecodeSet(rs[0])
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return CreatedID(s, "d")
|
||||
}
|
||||
|
||||
// ServerName is the server's own hostname, which a domain's default
|
||||
// certificate names include only when it is inside that domain.
|
||||
func (c *Client) ServerName(ctx context.Context) (string, error) {
|
||||
rs, err := c.Do(ctx, Call{"x:SystemSettings/get", map[string]any{"ids": []string{"singleton"}, "properties": []string{"defaultHostname"}}, "0"})
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
var got struct {
|
||||
List []struct {
|
||||
DefaultHostname string `json:"defaultHostname"`
|
||||
} `json:"list"`
|
||||
}
|
||||
if err := json.Unmarshal(rs[0].Args, &got); err != nil || len(got.List) != 1 {
|
||||
return "", errors.New("x:SystemSettings/get did not return the settings")
|
||||
}
|
||||
return got.List[0].DefaultHostname, nil
|
||||
}
|
||||
|
||||
// Certificate is what the tool reports about an issued certificate.
|
||||
type Certificate struct {
|
||||
Issuer string `json:"issuer"`
|
||||
|
||||
Reference in new issue
Block a user