inbuxa certs: read the mail server's certificate, and with an API key renew it #24
No files matched your search
@@ -132,13 +132,25 @@ This is early. What is built:
|
||||
delete. Docker, and the configuration your own web server loads, are left
|
||||
alone. To take one component off, run `install` again with it skipped.
|
||||
|
||||
- **`certs [--key KEY]`** -- the mail server's own certificate, the one its
|
||||
mail ports present: who issued it, until when, for which names, whether
|
||||
it verifies, and where the mail host resolves. Reading it needs nothing.
|
||||
Fixing it needs an API key made in the console, as `join` does (`--key -`
|
||||
or `INBUXA_API_KEY`; never written down): a new ACME order, which the
|
||||
server doesn't start again by itself once one has failed -- typically
|
||||
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
|
||||
proxy's, which renews them itself.
|
||||
|
||||
- **`status`** -- what is installed, what is running, and where those two
|
||||
disagree: a container stopped by hand, or a deployment nothing recorded
|
||||
installing. It exits non-zero when they disagree, so a machine can be
|
||||
asked in a script whether it still matches itself.
|
||||
|
||||
Not built yet: `join` in the interface (it is a command for now) and of
|
||||
front ends on the host, `certs`, and moving the server between a container
|
||||
front ends on the host, and moving the server between a container
|
||||
and the host. The design is in the inbuxa specification (§6.1 and
|
||||
the installer draft); the phases are there too.
|
||||
|
||||
@@ -194,6 +206,7 @@ is tested on a throwaway virtual machine rather than on anybody's desk:
|
||||
install run again: restarted when it must be, only then
|
||||
e2e/vm/run.sh e2e/cases/uninstall-containers.sh uninstalled, installed again on the data, purged
|
||||
e2e/vm/run.sh e2e/cases/uninstall-host.sh the same with the server and the webmail on the host
|
||||
e2e/vm/run.sh e2e/cases/certs.sh a failed order, reported, then fixed with a key
|
||||
e2e/vm/run.sh e2e/cases/topology.sh growing and shrinking from a file
|
||||
e2e/vm/run.sh e2e/cases/status-export.sh intent against reality, and the file
|
||||
OLD_REF=<commit> e2e/vm/run.sh e2e/cases/upgrade-volumes.sh
|
||||
|
||||
@@ -12,6 +12,7 @@ import (
|
||||
"bufio"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
@@ -20,6 +21,7 @@ import (
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/apply"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/deps"
|
||||
@@ -52,6 +54,9 @@ const usage = `inbuxa -- install the inbuxa suite on this machine
|
||||
--no-backup
|
||||
inbuxa uninstall take the programs away, keep the data:
|
||||
--dry-run, --yes, --purge (the data too)
|
||||
inbuxa certs [--key KEY] the mail server's certificate: what its mail
|
||||
ports present, and with an API key a new
|
||||
order when it needs one
|
||||
inbuxa export [-o FILE] write a topology file from what is here
|
||||
inbuxa version this program's version
|
||||
|
||||
@@ -90,6 +95,16 @@ join flags:
|
||||
--exempt-address IP the address the server sees the webmail at, when
|
||||
it is not what the webmail's name resolves to
|
||||
|
||||
certs flags:
|
||||
--key KEY an API key made in the console by a server
|
||||
administrator, needed only to change anything;
|
||||
"-" reads it from standard input, and
|
||||
INBUXA_API_KEY works too
|
||||
--mail-host NAME the server's name, if the install didn't record it
|
||||
--email ADDRESS the ACME contact, if ACME is turned on here;
|
||||
default: postmaster@DOMAIN
|
||||
--dry-run report, and say what it would do
|
||||
|
||||
deps flags:
|
||||
--server/--console/--webmail SHAPE the shapes to work out the needs for
|
||||
--install do it, rather than only saying what it would do
|
||||
@@ -134,6 +149,8 @@ func main() {
|
||||
os.Exit(upgradeCmd(os.Args[2:]))
|
||||
case "uninstall":
|
||||
os.Exit(uninstallCmd(os.Args[2:]))
|
||||
case "certs":
|
||||
os.Exit(certsCmd(os.Args[2:]))
|
||||
case "version":
|
||||
fmt.Println(version)
|
||||
case "-h", "--help", "help":
|
||||
@@ -819,6 +836,120 @@ func uninstallCmd(args []string) int {
|
||||
return 0
|
||||
}
|
||||
|
||||
func certsCmd(args []string) int {
|
||||
fs := flag.NewFlagSet("certs", flag.ContinueOnError)
|
||||
fs.Usage = func() { fmt.Print(usage) }
|
||||
var (
|
||||
key = fs.String("key", os.Getenv("INBUXA_API_KEY"), "")
|
||||
mailHost = fs.String("mail-host", "", "")
|
||||
email = fs.String("email", "", "")
|
||||
acmeDir = fs.String("acme-directory", "", "")
|
||||
dryRun = fs.Bool("dry-run", false, "")
|
||||
)
|
||||
if err := fs.Parse(args); err != nil {
|
||||
return 2
|
||||
}
|
||||
ctx := context.Background()
|
||||
st, err := state.Load()
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, err.Error())
|
||||
return 1
|
||||
}
|
||||
if _, ok := st.Shapes["server"]; !ok || st.Removed() {
|
||||
fmt.Println("The mail server isn't installed on this machine, so its certificate is looked after where it runs.")
|
||||
if st.ServerURL != "" {
|
||||
fmt.Println("The console's and the webmail's certificates here are Caddy's, which renews them itself.")
|
||||
}
|
||||
return 0
|
||||
}
|
||||
if apply.LocalInstall(st) {
|
||||
fmt.Println("This is a --local install: the mail ports are on loopback and have the server's own")
|
||||
fmt.Println("self-signed certificate, which is all a local evaluation needs. A real certificate comes")
|
||||
fmt.Println("with installing for a domain that points here.")
|
||||
return 0
|
||||
}
|
||||
f := host.Survey(ctx)
|
||||
found := discover.Run(ctx, f, st.Dir)
|
||||
o := apply.CertsOptions{
|
||||
MailHost: apply.CertsMailHost(*mailHost, st, found.MailHost),
|
||||
Email: *email, ACMEDirectory: *acmeDir,
|
||||
}
|
||||
switch {
|
||||
case found.Proxy:
|
||||
o.Proxy = "caddy"
|
||||
case fileExists(filepath.Join(st.Dir, "proxy", "nginx-inbuxa.conf")):
|
||||
o.Proxy = "snippets"
|
||||
}
|
||||
|
||||
roots := apply.CertRoots(st.Dir)
|
||||
s, err := apply.ReadServed(ctx, o.MailHost, roots)
|
||||
problem := ""
|
||||
if err != nil {
|
||||
problem = err.Error()
|
||||
} else {
|
||||
fmt.Printf("The mail server's certificate for %s, as port %s presents it:\n", o.MailHost, s.Port)
|
||||
issuer := s.Issuer
|
||||
if s.SelfSigned {
|
||||
issuer = "itself (self-signed)"
|
||||
}
|
||||
until := s.NotAfter.Format("2006-01-02")
|
||||
// A self-signed certificate is often dated to the end of time, where
|
||||
// a count of days says nothing.
|
||||
if days := int(time.Until(s.NotAfter).Hours() / 24); days < 3650 {
|
||||
until += fmt.Sprintf(" (%d days)", days)
|
||||
}
|
||||
fmt.Printf(" issued by %s\n valid until %s\n names %s\n",
|
||||
issuer, until, strings.Join(s.Names, ", "))
|
||||
problem = s.Problem(o.MailHost, time.Now())
|
||||
}
|
||||
if addrs, err := net.DefaultResolver.LookupHost(ctx, o.MailHost); err == nil && len(addrs) > 0 {
|
||||
fmt.Printf("\n%s resolves to %s.\n", o.MailHost, strings.Join(addrs, ", "))
|
||||
} else {
|
||||
fmt.Printf("\n%s doesn't resolve. A certificate can't be issued until it points here: the records\n"+
|
||||
"are in %s.\n", o.MailHost, filepath.Join(st.Dir, "dns.zone"))
|
||||
}
|
||||
if problem == "" {
|
||||
fmt.Println("\nNothing to do: the server renews it itself, well before it expires.")
|
||||
return 0
|
||||
}
|
||||
fmt.Printf("\nThe problem: %s.\n", problem)
|
||||
if *dryRun {
|
||||
fmt.Println("\nWith an API key, this would start a new certificate order for " + o.MailHost + " and wait for it.")
|
||||
return 0
|
||||
}
|
||||
if *key == "-" {
|
||||
line, err := bufio.NewReader(os.Stdin).ReadString('\n')
|
||||
if err != nil && line == "" {
|
||||
fmt.Fprintln(os.Stderr, "reading the key from standard input: "+err.Error())
|
||||
return 2
|
||||
}
|
||||
*key = strings.TrimSpace(line)
|
||||
}
|
||||
if *key == "" {
|
||||
fmt.Println("\nA new order needs an API key: make one in the console (your account, API keys), then")
|
||||
fmt.Println(" sudo inbuxa certs --key -")
|
||||
fmt.Println("and paste it, or set INBUXA_API_KEY. It isn't kept.")
|
||||
return 1
|
||||
}
|
||||
fmt.Println()
|
||||
o.Key = *key
|
||||
if _, err := apply.Renew(ctx, st, o, &printer{}); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "\nstopped: "+err.Error())
|
||||
if !errors.Is(err, apply.ErrKeyRefused) {
|
||||
fmt.Fprintln(os.Stderr, " the server's log says why: "+apply.CertsLogHint(st))
|
||||
}
|
||||
return 1
|
||||
}
|
||||
s, _ = apply.ReadServed(ctx, o.MailHost, roots)
|
||||
if s != nil {
|
||||
fmt.Printf("\nDone: port %s now presents a certificate for %s from %s, valid until %s.\n",
|
||||
s.Port, o.MailHost, s.Issuer, s.NotAfter.Format("2006-01-02"))
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func fileExists(p string) bool { _, err := os.Stat(p); return err == nil }
|
||||
|
||||
func shapeComponent(s string) (string, error) {
|
||||
switch strings.ToLower(s) {
|
||||
case "server", "console", "webmail":
|
||||
|
||||
Executable
+175
@@ -0,0 +1,175 @@
|
||||
#!/bin/bash
|
||||
# SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
# SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
#
|
||||
# inbuxa certs: the install's order fails because the mail host points
|
||||
# somewhere else, as it does when DNS isn't in place yet; certs reports that
|
||||
# without a key, refuses a wrong one, fails while DNS is still wrong, and
|
||||
# gets the certificate once it is fixed. The same lab as install-public.sh
|
||||
# (Pebble for Let's Encrypt, a DNS stub), with the server on the host.
|
||||
#
|
||||
# Run from the host with: e2e/vm/run.sh e2e/cases/certs.sh
|
||||
set -uo pipefail
|
||||
|
||||
pass=0; fail=0
|
||||
ok() { echo " ok $*"; pass=$((pass+1)); }
|
||||
bad() { echo " FAIL $*"; fail=$((fail+1)); }
|
||||
|
||||
DOMAIN=lab.test
|
||||
MAIL=mx.lab.test # not "mail": proves the names follow --mail-host
|
||||
CONSOLE=console.lab.test
|
||||
WEBMAIL=webmail.lab.test
|
||||
DIR=/var/lib/inbuxa
|
||||
|
||||
# Whichever runtime this machine has. The installer picks docker where there
|
||||
# is one and podman on the Red Hat family; a case that says "docker" only
|
||||
# tests half the distributions it is run on.
|
||||
#
|
||||
# Asked at each call, not once at the top: these cases start on a machine
|
||||
# with no runtime at all and install one along the way, so anything decided
|
||||
# up here is decided before the answer exists.
|
||||
rt() { command -v docker >/dev/null 2>&1 && echo docker || echo podman; }
|
||||
compose() {
|
||||
if [ "$(rt)" = docker ]; then
|
||||
docker compose -f "$DIR/compose.yaml" "$@"
|
||||
else
|
||||
DOCKER_HOST=unix:///run/podman/podman.sock \
|
||||
/usr/local/lib/docker/cli-plugins/docker-compose -f "$DIR/compose.yaml" "$@"
|
||||
fi
|
||||
}
|
||||
WORK=/tmp/lab
|
||||
LABNET=inbuxa-e2e
|
||||
LABSUBNET=172.31.254.0/24
|
||||
HOSTIP=172.31.254.1 # this machine, as the lab network sees it
|
||||
|
||||
rm -rf "$WORK"; mkdir -p "$WORK"
|
||||
|
||||
echo "==> what the installer needs, before the lab"
|
||||
/tmp/inbuxa deps --console container --webmail container --install >/dev/null 2>&1 || true
|
||||
{ docker version >/dev/null 2>&1 || podman version >/dev/null 2>&1; } && ok "a container runtime is usable" || { bad "no docker"; exit 1; }
|
||||
|
||||
echo
|
||||
echo "==> standing up a private CA and a DNS stub"
|
||||
docker network create --subnet "$LABSUBNET" "$LABNET" >/dev/null 2>&1
|
||||
# Pebble's own certificate names localhost and "pebble"; the server and Caddy
|
||||
# reach it at this machine's address from another network, so it gets one for
|
||||
# that address, signed by the test root that ships with it.
|
||||
docker create --name inbuxa-e2e-extract ghcr.io/letsencrypt/pebble:latest >/dev/null 2>&1
|
||||
docker cp inbuxa-e2e-extract:/test/certs "$WORK/pebble-certs" >/dev/null
|
||||
docker cp inbuxa-e2e-extract:/test/config/pebble-config.json "$WORK/pebble-config.json" >/dev/null
|
||||
docker rm inbuxa-e2e-extract >/dev/null
|
||||
openssl req -new -newkey ec -pkeyopt ec_paramgen_curve:P-256 -nodes -subj "/CN=pebble" \
|
||||
-keyout "$WORK/pebble-key.pem" -out "$WORK/pebble.csr" 2>/dev/null
|
||||
openssl x509 -req -in "$WORK/pebble.csr" -days 2 -CA "$WORK/pebble-certs/pebble.minica.pem" \
|
||||
-CAkey "$WORK/pebble-certs/pebble.minica.key.pem" -CAcreateserial \
|
||||
-extfile <(printf 'subjectAltName=IP:%s\nextendedKeyUsage=serverAuth\n' "$HOSTIP") \
|
||||
-out "$WORK/pebble-cert.pem" 2>/dev/null
|
||||
python3 - "$WORK/pebble-config.json" <<'PY'
|
||||
import json, sys
|
||||
c = json.load(open(sys.argv[1]))
|
||||
c["pebble"].update(httpPort=80, tlsPort=443,
|
||||
certificate="/work/pebble-cert.pem", privateKey="/work/pebble-key.pem")
|
||||
json.dump(c, open(sys.argv[1], "w"))
|
||||
PY
|
||||
chmod -R a+r "$WORK"
|
||||
docker run -d --name inbuxa-e2e-dns --network "$LABNET" --ip 172.31.254.3 \
|
||||
ghcr.io/letsencrypt/pebble-challtestsrv:latest \
|
||||
-defaultIPv4 "$HOSTIP" -defaultIPv6 "" -http01 "" -https01 "" -tlsalpn01 "" -doh "" >/dev/null
|
||||
# Nonce rejection off: Pebble refuses 5% of nonces on purpose, and the server
|
||||
# gives up an order on the first one rather than retrying.
|
||||
docker run -d --name inbuxa-e2e-pebble --network "$LABNET" --ip 172.31.254.2 \
|
||||
-p 14000:14000 -p 15000:15000 -v "$WORK:/work:ro" \
|
||||
-e PEBBLE_VA_NOSLEEP=1 -e PEBBLE_WFE_NONCEREJECT=0 \
|
||||
ghcr.io/letsencrypt/pebble:latest -config /work/pebble-config.json -dnsserver 172.31.254.3:8053 >/dev/null
|
||||
for _ in $(seq 1 30); do
|
||||
curl -sf --cacert "$WORK/pebble-certs/pebble.minica.pem" "https://$HOSTIP:14000/dir" >/dev/null && break
|
||||
sleep 1
|
||||
done
|
||||
curl -sf --cacert "$WORK/pebble-certs/pebble.minica.pem" "https://$HOSTIP:14000/dir" >/dev/null \
|
||||
&& ok "Pebble answers at https://$HOSTIP:14000/dir" || { bad "Pebble did not come up"; exit 1; }
|
||||
|
||||
# The mail host points nowhere useful, so the server's HTTP-01 challenge
|
||||
# can't reach it. The console's and the webmail's names point here, so
|
||||
# Caddy's own certificates are not what fails.
|
||||
BOGUS=172.31.254.99
|
||||
curl -s -X POST -d "{\"host\":\"$MAIL\",\"addresses\":[\"$BOGUS\"]}" http://172.31.254.3:8055/add-a >/dev/null \
|
||||
&& ok "the DNS stub sends $MAIL to $BOGUS" || bad "the DNS stub's management API"
|
||||
# The CA resolves names through the stub; this machine, as an operator's
|
||||
# would, through its own resolver, which is told the same.
|
||||
echo "$BOGUS $MAIL" >> /etc/hosts
|
||||
|
||||
CA="$WORK/pebble-certs/pebble.minica.pem"
|
||||
curl -sf --cacert "$CA" "https://$HOSTIP:15000/roots/0" > "$WORK/root.pem"
|
||||
curl -sf --cacert "$CA" "https://$HOSTIP:15000/intermediates/0" > "$WORK/int.pem"
|
||||
cat "$WORK/int.pem" "$WORK/root.pem" > "$WORK/chain.pem"
|
||||
# The machine trusts the CA, as a real one trusts Let's Encrypt.
|
||||
cp "$WORK/root.pem" /usr/local/share/ca-certificates/inbuxa-e2e-pebble.crt && update-ca-certificates >/dev/null 2>&1
|
||||
|
||||
echo
|
||||
echo "==> installing, with the mail host pointing elsewhere"
|
||||
OUT="$(/tmp/inbuxa install --domain "$DOMAIN" --mail-host "$MAIL" --console-host "$CONSOLE" \
|
||||
--webmail-host "$WEBMAIL" --server host --acme-directory "https://$HOSTIP:14000/dir" \
|
||||
--acme-ca-root "$CA" --install-deps --yes 2>&1)"; rc=$?
|
||||
echo "$OUT" | grep -v '^ |' | tail -6 | sed 's/^/ /'
|
||||
[ $rc -eq 0 ] && ok "installed (exit 0)" || bad "exit $rc"
|
||||
grep -q "no certificate yet for $MAIL" <<<"$OUT" && ok "it said there was no certificate yet" || bad "it did not say so"
|
||||
grep -q "\"mailHost\": \"$MAIL\"" /etc/inbuxa/install.json && ok "the install recorded the mail host" || bad "no mailHost in install.json"
|
||||
|
||||
echo
|
||||
echo "==> certs, with no key"
|
||||
OUT="$(/tmp/inbuxa certs 2>&1)"; rc=$?
|
||||
echo "$OUT" | sed 's/^/ /'
|
||||
[ $rc -eq 1 ] && ok "exit 1: there is a problem" || bad "exit $rc"
|
||||
grep -q "self-signed" <<<"$OUT" && ok "it names the self-signed certificate" || bad "no mention of self-signed"
|
||||
grep -q "$MAIL resolves to $BOGUS" <<<"$OUT" && ok "it shows where $MAIL points" || bad "no resolution shown"
|
||||
grep -q "needs an API key" <<<"$OUT" && ok "it says a key is needed" || bad "no word about a key"
|
||||
OUT="$(/tmp/inbuxa certs --dry-run 2>&1)"; rc=$?
|
||||
[ $rc -eq 0 ] && grep -q "would start a new certificate order" <<<"$OUT" && ok "--dry-run says what it would do" || bad "dry run exit $rc"
|
||||
|
||||
echo
|
||||
echo "==> an API key, as an administrator makes one in the console"
|
||||
SERVER=http://127.0.0.1:8081
|
||||
wait_server() { for _ in $(seq 1 60); do [ "$(curl -s -o /dev/null -w '%{http_code}' $SERVER/.well-known/jmap)" != 000 ] && return 0; sleep 2; done; return 1; }
|
||||
AUSER=$(awk '/^administrator/ {print $2}' "$DIR/credentials.txt")
|
||||
APASS=$(awk '/^administrator/{getline; print $2}' "$DIR/credentials.txt")
|
||||
echo "INBUXA_HTTP_BASIC_AUTH=all" >> "$DIR/server.env"
|
||||
systemctl restart inbuxa-server; wait_server
|
||||
EXPIRES=$(date -u -d '+1 hour' +%Y-%m-%dT%H:%M:%SZ)
|
||||
ANSWER=$(curl -s -u "$AUSER:$APASS" -H 'Content-Type: application/json' \
|
||||
-d "{\"using\":[\"urn:ietf:params:jmap:core\",\"urn:inbuxa:jmap:registry\"],\"methodCalls\":[[\"x:ApiKey/set\",{\"create\":{\"k\":{\"description\":\"certs test\",\"expiresAt\":\"$EXPIRES\",\"permissions\":{\"@type\":\"Inherit\"}}}},\"0\"]]}" $SERVER/jmap/)
|
||||
KEY=$(sed -n 's/.*"secret":"\([^"]*\)".*/\1/p' <<<"$ANSWER")
|
||||
sed -i '/^INBUXA_HTTP_BASIC_AUTH=/d' "$DIR/server.env"
|
||||
systemctl restart inbuxa-server; wait_server
|
||||
[ -n "$KEY" ] && ok "an API key for the administrator" || { bad "no API key"; head -c 300 <<<"$ANSWER" | sed 's/^/ /'; }
|
||||
|
||||
OUT="$(INBUXA_API_KEY=wrong-key /tmp/inbuxa certs 2>&1)"; rc=$?
|
||||
[ $rc -eq 1 ] && grep -q "refused the API key" <<<"$OUT" && ok "a wrong key is refused, and says so" || { bad "wrong key: exit $rc"; echo "$OUT" | tail -4 | sed 's/^/ /'; }
|
||||
|
||||
echo
|
||||
echo "==> with a key, while DNS is still wrong"
|
||||
OUT="$(echo "$KEY" | /tmp/inbuxa certs --key - 2>&1)"; rc=$?
|
||||
echo "$OUT" | tail -5 | sed 's/^/ /'
|
||||
[ $rc -eq 1 ] && grep -q "no certificate for $MAIL after three minutes" <<<"$OUT" && ok "it gives up, and says why" || bad "exit $rc"
|
||||
grep -q "journalctl -u inbuxa-server" <<<"$OUT" && ok "and where the server's log is" || bad "no log hint"
|
||||
|
||||
echo
|
||||
echo "==> DNS fixed, with a key"
|
||||
curl -s -X POST -d "{\"host\":\"$MAIL\"}" http://172.31.254.3:8055/clear-a >/dev/null
|
||||
sed -i "s/^$BOGUS $MAIL\$/$HOSTIP $MAIL/" /etc/hosts
|
||||
OUT="$(echo "$KEY" | /tmp/inbuxa certs --key - 2>&1)"; rc=$?
|
||||
echo "$OUT" | sed 's/^/ /'
|
||||
[ $rc -eq 0 ] && ok "exit 0" || bad "exit $rc"
|
||||
grep -q "starting a new certificate order" <<<"$OUT" && ok "it started a new order" || bad "no new order"
|
||||
grep -q "Done: port 993 now presents a certificate for $MAIL" <<<"$OUT" && ok "it reports the new certificate" || bad "no Done line"
|
||||
out=$(echo | timeout 20 openssl s_client -connect "127.0.0.1:993" -servername "$MAIL" -verify_hostname "$MAIL" -CAfile "$WORK/chain.pem" 2>&1)
|
||||
grep -q "Verify return code: 0 (ok)" <<<"$out" && ok "993 verifies for $MAIL" || bad "993 does not verify"
|
||||
grep -rqF "$KEY" "$DIR" /etc/inbuxa 2>/dev/null && bad "the API key was written down" || ok "the API key was not kept"
|
||||
|
||||
echo
|
||||
echo "==> certs again, nothing to do"
|
||||
OUT="$(/tmp/inbuxa certs 2>&1)"; rc=$?
|
||||
[ $rc -eq 0 ] && grep -q "Nothing to do" <<<"$OUT" && ok "nothing to do, without a key" || { bad "exit $rc"; echo "$OUT" | sed 's/^/ /'; }
|
||||
|
||||
echo
|
||||
echo "==> $pass passed, $fail failed"
|
||||
[ "$fail" -eq 0 ]
|
||||
@@ -575,7 +575,7 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro
|
||||
// intent rather than guessing from what happens to be up.
|
||||
st, err := state.Load()
|
||||
if err == nil {
|
||||
st.Machine, st.Dir, st.Domain = o.Machine, dir, o.Domain
|
||||
st.Machine, st.Dir, st.Domain, st.MailHost, st.Local = o.Machine, dir, o.Domain, o.MailHost, o.Local
|
||||
st.Runtime, st.Topology = f.Runtime.Kind, o.TopologyPath
|
||||
st.Shapes = map[string]string{}
|
||||
for _, c := range []plan.Component{plan.Server, plan.Console, plan.Webmail} {
|
||||
@@ -746,7 +746,7 @@ func convergeHost(ctx context.Context, o plan.Options, stack compose.Stack, cmp
|
||||
}
|
||||
|
||||
func saveState(st *state.State, o plan.Options, f host.Facts, log Log) {
|
||||
st.Machine, st.Dir, st.Domain = o.Machine, o.Dir, o.Domain
|
||||
st.Machine, st.Dir, st.Domain, st.MailHost, st.Local = o.Machine, o.Dir, o.Domain, o.MailHost, o.Local
|
||||
st.Runtime, st.Topology = f.Runtime.Kind, o.TopologyPath
|
||||
st.Installer = "server " + release.ServerVersion
|
||||
st.RemovedAt = nil // installed again, on what was kept
|
||||
|
||||
@@ -0,0 +1,295 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
package apply
|
||||
|
||||
// Certs is the mail server's own certificate: the one its mail ports present
|
||||
// to clients, which the proxy in front never sees. The console's and the
|
||||
// webmail's are the proxy's, and it renews those itself.
|
||||
//
|
||||
// Looking needs nothing: the certificate is read off port 993 the way a mail
|
||||
// client reads it. Doing something about it needs an API key made in the
|
||||
// console, as join does. The server takes no password on its API once it is
|
||||
// set up, and switching that back on for a moment, as the install's setup
|
||||
// does, is not something to do to a server that is already live.
|
||||
//
|
||||
// What it does about it: a domain whose certificates are on ACME gets a new
|
||||
// order, which is the one thing the server does not do by itself once an
|
||||
// order has failed -- the usual story is that DNS was not in place during
|
||||
// the install. A domain not on ACME is put on it, if something here answers
|
||||
// the server's challenges on port 80: the managed Caddy, or the operator's
|
||||
// own web server loading the configuration written for it.
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/tls"
|
||||
"crypto/x509"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/jmap"
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/state"
|
||||
)
|
||||
|
||||
// Served is a certificate as a mail client is given it.
|
||||
type Served struct {
|
||||
Port string
|
||||
Issuer string
|
||||
NotBefore time.Time
|
||||
NotAfter time.Time
|
||||
Names []string
|
||||
SelfSigned bool
|
||||
Trust error // why it doesn't verify for the mail host; nil when it does
|
||||
}
|
||||
|
||||
// stuckBelow is how little of its lifetime a certificate may have left
|
||||
// before that is reported as a problem. The server renews with a third left
|
||||
// (ACME's renewBefore is two thirds of the way through), so a certificate
|
||||
// down to a sixth has missed its renewal. A fraction rather than a number of
|
||||
// days, because lifetimes differ: Let's Encrypt's are moving from 90 days
|
||||
// towards six, and a test CA's are shorter still.
|
||||
const stuckBelow = 6
|
||||
|
||||
// Problem is what is wrong with it for host, in a phrase; "" when nothing is.
|
||||
func (s *Served) Problem(host string, now time.Time) string {
|
||||
switch {
|
||||
case s.SelfSigned:
|
||||
return "it is the server's own self-signed certificate, which mail clients refuse"
|
||||
case now.After(s.NotAfter):
|
||||
return "it expired on " + s.NotAfter.Format("2006-01-02")
|
||||
case !covers(s.Names, host):
|
||||
return "it does not name " + host
|
||||
case s.Trust != nil:
|
||||
return "it does not verify: " + s.Trust.Error()
|
||||
case s.NotAfter.Sub(now) < s.NotAfter.Sub(s.NotBefore)/stuckBelow:
|
||||
return "it expires " + inWords(s.NotAfter.Sub(now)) + " and has not been renewed"
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func inWords(d time.Duration) string {
|
||||
if d >= 48*time.Hour {
|
||||
return fmt.Sprintf("in %d days", int(d.Hours()/24))
|
||||
}
|
||||
return fmt.Sprintf("in %d hours", int(d.Hours()))
|
||||
}
|
||||
|
||||
func covers(names []string, host string) bool {
|
||||
for _, n := range names {
|
||||
if strings.EqualFold(n, host) {
|
||||
return true
|
||||
}
|
||||
if rest, ok := strings.CutPrefix(n, "*."); ok {
|
||||
if _, parent, ok := strings.Cut(host, "."); ok && strings.EqualFold(parent, rest) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// ServedCertificate reads the certificate the server presents for host at
|
||||
// addr (host:port), as a client would, and checks it against roots: the
|
||||
// system's when nil.
|
||||
func ServedCertificate(ctx context.Context, addr, host string, roots *x509.CertPool) (*Served, error) {
|
||||
d := tls.Dialer{Config: &tls.Config{ServerName: host, InsecureSkipVerify: true}}
|
||||
d.NetDialer = &net.Dialer{Timeout: 10 * time.Second}
|
||||
ctx, cancel := context.WithTimeout(ctx, 15*time.Second)
|
||||
defer cancel()
|
||||
conn, err := d.DialContext(ctx, "tcp", addr)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer conn.Close()
|
||||
chain := conn.(*tls.Conn).ConnectionState().PeerCertificates
|
||||
if len(chain) == 0 {
|
||||
return nil, errors.New("no certificate was presented")
|
||||
}
|
||||
leaf := chain[0]
|
||||
_, port, _ := net.SplitHostPort(addr)
|
||||
s := &Served{
|
||||
Port: port,
|
||||
Issuer: issuerName(leaf),
|
||||
NotBefore: leaf.NotBefore,
|
||||
NotAfter: leaf.NotAfter,
|
||||
Names: leaf.DNSNames,
|
||||
SelfSigned: bytes.Equal(leaf.RawIssuer, leaf.RawSubject),
|
||||
}
|
||||
inter := x509.NewCertPool()
|
||||
for _, c := range chain[1:] {
|
||||
inter.AddCert(c)
|
||||
}
|
||||
_, s.Trust = leaf.Verify(x509.VerifyOptions{DNSName: host, Roots: roots, Intermediates: inter})
|
||||
return s, nil
|
||||
}
|
||||
|
||||
func issuerName(c *x509.Certificate) string {
|
||||
name := c.Issuer.CommonName
|
||||
if len(c.Issuer.Organization) > 0 && !strings.Contains(name, c.Issuer.Organization[0]) {
|
||||
if name == "" {
|
||||
return c.Issuer.Organization[0]
|
||||
}
|
||||
name += " (" + c.Issuer.Organization[0] + ")"
|
||||
}
|
||||
if name == "" {
|
||||
name = c.Issuer.String()
|
||||
}
|
||||
return name
|
||||
}
|
||||
|
||||
// CertRoots are the roots this machine trusts, plus the private CA's root an
|
||||
// install with --acme-ca-root was given, which the server was told to trust
|
||||
// and so should this.
|
||||
func CertRoots(dir string) *x509.CertPool {
|
||||
pool, err := x509.SystemCertPool()
|
||||
if err != nil {
|
||||
pool = x509.NewCertPool()
|
||||
}
|
||||
if b, err := os.ReadFile(filepath.Join(dir, "ca-bundle.crt")); err == nil {
|
||||
pool.AppendCertsFromPEM(b)
|
||||
}
|
||||
return pool
|
||||
}
|
||||
|
||||
// MailPorts are where the certificate is read: IMAP over TLS, then
|
||||
// submission over TLS, whichever answers first.
|
||||
var MailPorts = []string{"993", "465"}
|
||||
|
||||
// ReadServed reads the certificate off the first mail port that answers.
|
||||
func ReadServed(ctx context.Context, host string, roots *x509.CertPool) (*Served, error) {
|
||||
var errs []string
|
||||
for _, p := range MailPorts {
|
||||
s, err := ServedCertificate(ctx, net.JoinHostPort("127.0.0.1", p), host, roots)
|
||||
if err == nil {
|
||||
return s, nil
|
||||
}
|
||||
errs = append(errs, p+": "+err.Error())
|
||||
}
|
||||
return nil, fmt.Errorf("the mail ports don't answer with TLS (%s)", strings.Join(errs, "; "))
|
||||
}
|
||||
|
||||
// CertsMailHost is the server's name: as given, as recorded, as the
|
||||
// deployment says, or the default.
|
||||
func CertsMailHost(given string, st *state.State, found string) string {
|
||||
for _, h := range []string{given, st.MailHost, found} {
|
||||
if h != "" {
|
||||
return h
|
||||
}
|
||||
}
|
||||
return "mail." + st.Domain
|
||||
}
|
||||
|
||||
// LocalInstall is whether the install here was --local: recorded since
|
||||
// 2026.10.13, and before that read off the address the server was given for
|
||||
// itself, which only a local install sets.
|
||||
func LocalInstall(st *state.State) bool {
|
||||
if st.Local {
|
||||
return true
|
||||
}
|
||||
for _, f := range []string{"compose.yaml", "server.env"} {
|
||||
if b, err := os.ReadFile(filepath.Join(st.Dir, f)); err == nil && strings.Contains(string(b), "INBUXA_PUBLIC_URL") {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// ErrKeyRefused is an API key the server doesn't take.
|
||||
var ErrKeyRefused = errors.New("the server refused the API key: make one in the console (your account, API keys) as an administrator")
|
||||
|
||||
// CertsOptions are what Renew needs beyond the install record.
|
||||
type CertsOptions struct {
|
||||
MailHost string
|
||||
Key string
|
||||
Proxy string // "caddy", "snippets" or "" for none: what answers on port 80
|
||||
Email string // the ACME contact when ACME is turned on here
|
||||
ACMEDirectory string
|
||||
}
|
||||
|
||||
// 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)
|
||||
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)
|
||||
}
|
||||
kind, _, err := srv.CertificateManagement(ctx, domainID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if kind == "Automatic" {
|
||||
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))
|
||||
}
|
||||
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)
|
||||
}
|
||||
}
|
||||
// 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
|
||||
// replaced. A new order is asked for again every so often, as the
|
||||
// install does, since one that fails is not retried.
|
||||
log.Info("waiting for the certificate (up to three minutes)")
|
||||
roots := CertRoots(st.Dir)
|
||||
deadline := time.Now().Add(3 * time.Minute)
|
||||
nextRetry := time.Now().Add(45 * time.Second)
|
||||
var last string
|
||||
for {
|
||||
s, err := ReadServed(ctx, o.MailHost, roots)
|
||||
if err == nil {
|
||||
if last = s.Problem(o.MailHost, time.Now()); last == "" {
|
||||
return s, nil
|
||||
}
|
||||
} else {
|
||||
last = err.Error()
|
||||
}
|
||||
if time.Now().After(deadline) {
|
||||
return s, fmt.Errorf("no certificate for %s after three minutes (%s): check that it resolves to this machine and that port 80 reaches it", o.MailHost, last)
|
||||
}
|
||||
if time.Now().After(nextRetry) {
|
||||
log.Info("asking again")
|
||||
_ = srv.RetryCertificates(ctx, domainID)
|
||||
nextRetry = time.Now().Add(45 * time.Second)
|
||||
}
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return s, ctx.Err()
|
||||
case <-time.After(3 * time.Second):
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// CertsLogHint is where the server says why an order failed.
|
||||
func CertsLogHint(st *state.State) string {
|
||||
if st.Shapes["server"] == "host" {
|
||||
return "journalctl -u " + HostServerUnit + " | grep -i acme"
|
||||
}
|
||||
return "docker compose --project-directory " + st.Dir + " logs server | grep -i acme"
|
||||
}
|
||||
@@ -0,0 +1,171 @@
|
||||
// SPDX-FileCopyrightText: 2026 Coffey Labs LLC
|
||||
// SPDX-License-Identifier: AGPL-3.0-or-later
|
||||
|
||||
package apply
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/ecdsa"
|
||||
"crypto/elliptic"
|
||||
"crypto/rand"
|
||||
"crypto/tls"
|
||||
"crypto/x509"
|
||||
"crypto/x509/pkix"
|
||||
"math/big"
|
||||
"net"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.coffeylabs.org/inbuxa/inbuxa-installer/internal/state"
|
||||
)
|
||||
|
||||
type issued struct {
|
||||
cert *x509.Certificate
|
||||
key *ecdsa.PrivateKey
|
||||
der []byte
|
||||
}
|
||||
|
||||
// mint makes a certificate for names, signed by parent, or by itself when
|
||||
// parent is nil.
|
||||
func mint(t *testing.T, cn string, names []string, notAfter time.Time, ca bool, parent *issued) *issued {
|
||||
t.Helper()
|
||||
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
tmpl := &x509.Certificate{
|
||||
SerialNumber: big.NewInt(time.Now().UnixNano()),
|
||||
Subject: pkix.Name{CommonName: cn, Organization: []string{"Lab"}},
|
||||
NotBefore: time.Now().Add(-time.Hour),
|
||||
NotAfter: notAfter,
|
||||
DNSNames: names,
|
||||
KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
|
||||
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
|
||||
IsCA: ca, BasicConstraintsValid: true,
|
||||
}
|
||||
signer, signerKey := tmpl, key
|
||||
if parent != nil {
|
||||
signer, signerKey = parent.cert, parent.key
|
||||
}
|
||||
der, err := x509.CreateCertificate(rand.Reader, tmpl, signer, &key.PublicKey, signerKey)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
c, _ := x509.ParseCertificate(der)
|
||||
return &issued{c, key, der}
|
||||
}
|
||||
|
||||
// serve presents leaf (and its chain) on a loopback port and returns the
|
||||
// address.
|
||||
func serve(t *testing.T, chain ...*issued) string {
|
||||
t.Helper()
|
||||
cert := tls.Certificate{PrivateKey: chain[0].key}
|
||||
for _, c := range chain {
|
||||
cert.Certificate = append(cert.Certificate, c.der)
|
||||
}
|
||||
ln, err := tls.Listen("tcp", "127.0.0.1:0", &tls.Config{Certificates: []tls.Certificate{cert}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { ln.Close() })
|
||||
go func() {
|
||||
for {
|
||||
c, err := ln.Accept()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
go func(c net.Conn) { c.(*tls.Conn).Handshake(); c.Close() }(c)
|
||||
}
|
||||
}()
|
||||
return ln.Addr().String()
|
||||
}
|
||||
|
||||
func TestTheCertificateOnTheMailPortsIsReadAsAClientSeesIt(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
in := time.Now().Add(60 * 24 * time.Hour)
|
||||
root := mint(t, "Lab Root", nil, in.Add(time.Hour), true, nil)
|
||||
leaf := mint(t, "mx.lab.test", []string{"mx.lab.test", "autoconfig.lab.test"}, in, false, root)
|
||||
roots := x509.NewCertPool()
|
||||
roots.AddCert(root.cert)
|
||||
|
||||
s, err := ServedCertificate(ctx, serve(t, leaf), "mx.lab.test", roots)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if p := s.Problem("mx.lab.test", time.Now()); p != "" {
|
||||
t.Errorf("a trusted certificate for the name, two months out, is a problem: %s", p)
|
||||
}
|
||||
if s.SelfSigned || s.Issuer != "Lab Root" || len(s.Names) != 2 {
|
||||
t.Errorf("read back as %+v", s)
|
||||
}
|
||||
|
||||
// The same certificate without its root trusted.
|
||||
s, _ = ServedCertificate(ctx, serve(t, leaf), "mx.lab.test", x509.NewCertPool())
|
||||
if p := s.Problem("mx.lab.test", time.Now()); !strings.Contains(p, "does not verify") {
|
||||
t.Errorf("an untrusted issuer reads %q", p)
|
||||
}
|
||||
|
||||
// The server's own, before any order succeeded.
|
||||
self := mint(t, "mx.lab.test", []string{"mx.lab.test"}, in, false, nil)
|
||||
s, _ = ServedCertificate(ctx, serve(t, self), "mx.lab.test", roots)
|
||||
if p := s.Problem("mx.lab.test", time.Now()); !strings.Contains(p, "self-signed") {
|
||||
t.Errorf("a self-signed certificate reads %q", p)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWhatIsWrongWithACertificateIsSaidInOnePhrase(t *testing.T) {
|
||||
now := time.Now()
|
||||
for _, c := range []struct {
|
||||
name string
|
||||
s Served
|
||||
want string
|
||||
}{
|
||||
{"fine", Served{NotBefore: now.Add(-24 * time.Hour), NotAfter: now.Add(60 * 24 * time.Hour), Names: []string{"mx.lab.test"}}, ""},
|
||||
{"wildcard", Served{NotBefore: now.Add(-24 * time.Hour), NotAfter: now.Add(60 * 24 * time.Hour), Names: []string{"*.lab.test"}}, ""},
|
||||
{"expired", Served{NotAfter: now.Add(-time.Hour), Names: []string{"mx.lab.test"}}, "expired"},
|
||||
{"other name", Served{NotBefore: now.Add(-24 * time.Hour), NotAfter: now.Add(60 * 24 * time.Hour), Names: []string{"mail.lab.test"}}, "does not name mx.lab.test"},
|
||||
{"renewal stuck", Served{NotBefore: now.Add(-85 * 24 * time.Hour), NotAfter: now.Add(5 * 24 * time.Hour), Names: []string{"mx.lab.test"}}, "in 5 days and has not been renewed"},
|
||||
{"short-lived, new", Served{NotBefore: now.Add(-time.Hour), NotAfter: now.Add(5 * 24 * time.Hour), Names: []string{"mx.lab.test"}}, ""},
|
||||
{"short-lived, stuck", Served{NotBefore: now.Add(-110 * time.Hour), NotAfter: now.Add(10 * time.Hour), Names: []string{"mx.lab.test"}}, "in 10 hours"},
|
||||
} {
|
||||
got := c.s.Problem("mx.lab.test", now)
|
||||
if (c.want == "") != (got == "") || !strings.Contains(got, c.want) {
|
||||
t.Errorf("%s: %q, wanted %q", c.name, got, c.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestTheMailHostComesFromWhatIsKnownBeforeTheDefault(t *testing.T) {
|
||||
st := &state.State{Domain: "lab.test"}
|
||||
if h := CertsMailHost("", st, ""); h != "mail.lab.test" {
|
||||
t.Errorf("nothing known: %s", h)
|
||||
}
|
||||
if h := CertsMailHost("", st, "mx.lab.test"); h != "mx.lab.test" {
|
||||
t.Errorf("from the deployment: %s", h)
|
||||
}
|
||||
st.MailHost = "smtp.lab.test"
|
||||
if h := CertsMailHost("", st, "mx.lab.test"); h != "smtp.lab.test" {
|
||||
t.Errorf("recorded: %s", h)
|
||||
}
|
||||
if h := CertsMailHost("given.lab.test", st, "mx.lab.test"); h != "given.lab.test" {
|
||||
t.Errorf("given: %s", h)
|
||||
}
|
||||
}
|
||||
|
||||
func TestALocalInstallIsKnownEvenIfItWasNotRecorded(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
st := &state.State{Dir: dir}
|
||||
if LocalInstall(st) {
|
||||
t.Fatal("an empty directory is local")
|
||||
}
|
||||
os.WriteFile(filepath.Join(dir, "server.env"), []byte("INBUXA_PUBLIC_URL=http://localhost:8081\n"), 0o600)
|
||||
if !LocalInstall(st) {
|
||||
t.Error("a server told its own loopback address is not local")
|
||||
}
|
||||
if !LocalInstall(&state.State{Dir: t.TempDir(), Local: true}) {
|
||||
t.Error("a recorded --local is not local")
|
||||
}
|
||||
}
|
||||
+20
-10
@@ -184,10 +184,9 @@ func (c *Client) EnableACME(ctx context.Context, domainID, directory, contact st
|
||||
return id, nil
|
||||
}
|
||||
|
||||
// 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.
|
||||
func (c *Client) RetryCertificates(ctx context.Context, domainID string) error {
|
||||
// CertificateManagement says how the domain's certificates are managed:
|
||||
// "Automatic" with the ACME provider's id, or "Manual" with none.
|
||||
func (c *Client) CertificateManagement(ctx context.Context, domainID string) (kind, providerID string, err error) {
|
||||
var got struct {
|
||||
List []struct {
|
||||
CertificateManagement struct {
|
||||
@@ -198,18 +197,29 @@ func (c *Client) RetryCertificates(ctx context.Context, domainID string) error {
|
||||
}
|
||||
rs, err := c.Do(ctx, Call{"x:Domain/get", map[string]any{"ids": []string{domainID}, "properties": []string{"certificateManagement"}}, "0"})
|
||||
if err != nil {
|
||||
return err
|
||||
return "", "", err
|
||||
}
|
||||
if err := json.Unmarshal(rs[0].Args, &got); err != nil || len(got.List) != 1 {
|
||||
return errors.New("x:Domain/get did not return the domain")
|
||||
return "", "", errors.New("x:Domain/get did not return the domain")
|
||||
}
|
||||
cm := got.List[0].CertificateManagement
|
||||
if cm.Type != "Automatic" || cm.AcmeProviderID == "" {
|
||||
return fmt.Errorf("the domain's certificates are %q, not managed by ACME", cm.Type)
|
||||
return cm.Type, cm.AcmeProviderID, nil
|
||||
}
|
||||
|
||||
// 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.
|
||||
func (c *Client) RetryCertificates(ctx context.Context, domainID string) error {
|
||||
kind, providerID, err := c.CertificateManagement(ctx, domainID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rs, err = c.Do(ctx,
|
||||
if kind != "Automatic" || providerID == "" {
|
||||
return fmt.Errorf("the domain's certificates are %q, not managed by ACME", kind)
|
||||
}
|
||||
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(cm.AcmeProviderID)}}, "1"},
|
||||
Call{"x:Domain/set", map[string]any{"update": map[string]any{domainID: automaticCertificates(providerID)}}, "1"},
|
||||
)
|
||||
if err != nil {
|
||||
return err
|
||||
|
||||
@@ -30,6 +30,8 @@ type State struct {
|
||||
Dir string `json:"dir"` // the deployment directory
|
||||
Runtime string `json:"runtime,omitempty"` // docker or podman
|
||||
Domain string `json:"domain,omitempty"` //
|
||||
MailHost string `json:"mailHost,omitempty"` // the server's name; installs before 2026.10.13 did not record it
|
||||
Local bool `json:"local,omitempty"` // --local: loopback only, no certificates
|
||||
Shapes map[string]string `json:"shapes"` // component -> container|host
|
||||
Topology string `json:"topology,omitempty"` // the file this came from, if any
|
||||
ServerURL string `json:"serverUrl,omitempty"` // the server on another machine these front ends were joined to
|
||||
|
||||
Reference in new issue
Block a user