diff --git a/README.md b/README.md index bb28808..73840d1 100644 --- a/README.md +++ b/README.md @@ -46,6 +46,14 @@ This is early. What is built: it is not a second installer -- and it is built on the standard library alone, like the rest. Without a terminal it says which flags to use. +- **`--proxy snippets`** -- for a machine that already runs nginx or Caddy: + nothing here takes 80 or 443, and the installer writes + `/proxy/nginx-inbuxa.conf` and `/proxy/Caddyfile.fragment` for + that web server to load, trusts it in front of the suite (its + X-Forwarded-For, and an exemption from the auto-ban), and leaves loading + and reloading to you. Once it is loaded, the mail server's own + certificates are turned on in the console. `--proxy none` writes nothing. + - **`survey`** -- the machine's facts: distribution, init, whether Docker is usable *by this user*, Node's version, which of the suite's ports are free and what holds the ones that are not, memory, disk, and whether an install @@ -100,9 +108,8 @@ This is early. What is built: asked in a script whether it still matches itself. Not built yet: host installs of the console and the webmail, `join` in the -interface (it is a command for now), `upgrade`, `uninstall`, moving the -server between a container and the host, and `--proxy snippets`, which the -plan describes but nothing writes yet. The design is in the inbuxa specification (§6.1 and +interface (it is a command for now), `upgrade`, `uninstall`, 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. inbuxa install --local --domain example.test --install-deps --yes @@ -144,6 +151,7 @@ is tested on a throwaway virtual machine rather than on anybody's desk: e2e/vm/run.sh e2e/cases/install-host.sh the server on the host, the rest beside it e2e/vm/run.sh e2e/cases/join.sh front ends joined to a server elsewhere e2e/vm/run.sh e2e/cases/interface.sh the interface, driven key by key in a terminal + e2e/vm/run.sh e2e/cases/proxy-snippets.sh behind nginx, from the configuration it writes 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= e2e/vm/run.sh e2e/cases/upgrade-volumes.sh diff --git a/cmd/inbuxa/main.go b/cmd/inbuxa/main.go index 2e1879c..f741dc9 100644 --- a/cmd/inbuxa/main.go +++ b/cmd/inbuxa/main.go @@ -226,6 +226,9 @@ func install(args []string) int { if res.ZoneFile != "" { fmt.Printf(" dns records %s\n", res.ZoneFile) } + if res.ProxyConfig != "" { + fmt.Printf(" proxy config %s (load it into your web server)\n", res.ProxyConfig) + } if len(problems) > 0 { return 1 } diff --git a/e2e/cases/proxy-snippets.sh b/e2e/cases/proxy-snippets.sh new file mode 100644 index 0000000..d9a591a --- /dev/null +++ b/e2e/cases/proxy-snippets.sh @@ -0,0 +1,74 @@ +#!/bin/bash +# SPDX-FileCopyrightText: 2026 Coffey Labs LLC +# SPDX-License-Identifier: AGPL-3.0-or-later +# +# --proxy snippets on a machine that already runs nginx: the installer takes +# neither 80 nor 443, writes the configuration for nginx, and the suite is +# then reached through nginx on its real names once that file is loaded -- +# certificates being the operator's, self-signed here. +# +# Run from the host with: e2e/vm/run.sh e2e/cases/proxy-snippets.sh +set -uo pipefail + +pass=0; fail=0 +ok() { echo " ok $*"; pass=$((pass+1)); } +bad() { echo " FAIL $*"; fail=$((fail+1)); } + +DIR=/var/lib/inbuxa +D=example.test + +echo "==> a machine with nginx already on it" +DEBIAN_FRONTEND=noninteractive apt-get install -y -qq nginx openssl >/dev/null 2>&1 +systemctl is-active --quiet nginx && ok "nginx is running, holding 80" || { bad "no nginx"; echo "==> $pass passed, $fail failed"; exit 1; } + +echo +echo "==> install behind it" +OUT="$(/tmp/inbuxa install --domain $D --proxy snippets --install-deps --yes 2>&1)"; rc=$? +echo "$OUT" | grep -v '^ |' | tail -14 | sed 's/^/ /' +[ $rc -eq 0 ] && ok "installed (exit 0)" || bad "exit $rc" +grep -q "proxy config.*$DIR/proxy" <<<"$OUT" && ok "the summary names the proxy configuration" || bad "no proxy config in the summary" +[ -f $DIR/proxy/nginx-inbuxa.conf ] && [ -f $DIR/proxy/Caddyfile.fragment ] && ok "nginx-inbuxa.conf and Caddyfile.fragment written" || bad "the configuration files are missing" +grep -q "caddy" $DIR/compose.yaml && bad "a Caddy was put here anyway" || ok "no Caddy of its own" +systemctl is-active --quiet nginx && ok "nginx was left running, untouched" || bad "nginx is not running any more" + +echo +echo "==> load it, as the operator would" +mkdir -p /etc/ssl/inbuxa +for n in mail.$D admin.$D webmail.$D; do + openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:P-256 -nodes -days 2 -subj "/CN=$n" \ + -addext "subjectAltName=DNS:$n,DNS:autoconfig.$D,DNS:autodiscover.$D,DNS:mta-sts.$D,DNS:ua-auto-config.$D" \ + -keyout /etc/ssl/inbuxa/$n.key.pem -out /etc/ssl/inbuxa/$n.fullchain.pem 2>/dev/null +done +cp $DIR/proxy/nginx-inbuxa.conf /etc/nginx/conf.d/inbuxa.conf +OUT="$(nginx -t 2>&1)" && ok "nginx -t accepts it" || { bad "nginx -t"; echo "$OUT" | sed 's/^/ /'; } +systemctl reload nginx +# A reload returns before nginx's old workers have finished; until they +# have, port 80 can still be answered from the configuration before it. +sleep 3 + +echo +echo "==> the suite, through nginx" +via() { curl -sk --resolve "$1:443:127.0.0.1" --resolve "$1:80:127.0.0.1" "${@:2}"; } +CODE=$(via mail.$D -o /dev/null -w '%{http_code}' https://mail.$D/.well-known/jmap) +case "$CODE" in 30*|200|401) ok "the mail server answers on https://mail.$D ($CODE)" ;; *) bad "https://mail.$D/.well-known/jmap answered $CODE" ;; esac +via admin.$D https://admin.$D/ | grep -q "content=\"https://mail.$D\"" && ok "the console, pointed at https://mail.$D" || bad "the console is not served through nginx" +via webmail.$D https://webmail.$D/api/health | grep -q '"ok":true' && ok "the webmail is healthy through nginx" || bad "the webmail is not healthy through nginx" +# The mail server's own 404 is a JSON problem document; nginx's is a page. +BODY=$(via mail.$D http://mail.$D/.well-known/acme-challenge/probe) +grep -q "&1 | grep -E "^[<>] |^\* Connected" | head -12 | sed 's/^/ /' + nginx -T 2>/dev/null | grep -n -E "^# configuration file|listen|server_name" | head -40 | sed 's/^/ /' +fi + +echo +echo "==> again: converges, and rewrites the file for what is here" +rm $DIR/proxy/nginx-inbuxa.conf +OUT="$(/tmp/inbuxa install --domain $D --proxy snippets --yes 2>&1)"; rc=$? +[ $rc -eq 0 ] && [ -f $DIR/proxy/nginx-inbuxa.conf ] && ok "a second run converges and writes it again" || { bad "second run exit $rc"; echo "$OUT" | tail -6 | sed 's/^/ /'; } + +echo +echo "==> $pass passed, $fail failed" +[ "$fail" -eq 0 ] diff --git a/internal/apply/apply.go b/internal/apply/apply.go index cba20cc..42c147b 100644 --- a/internal/apply/apply.go +++ b/internal/apply/apply.go @@ -60,6 +60,7 @@ type Result struct { FirstPass string ZoneFile string Certificate string // what issued the mail server's certificate, when one arrived + ProxyConfig string // where the configuration for the operator's own web server is, with --proxy snippets ConsoleURL string WebmailURL string ServerURL string @@ -250,7 +251,15 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro // moment it was configured -- which is exactly what adding or removing a // front end used to do, and why it could not. if existing, err := state.Load(); err == nil && existing.Installed() { - return converge(ctx, o, stack, cmp, hs, existing, f, log) + res, err := converge(ctx, o, stack, cmp, hs, existing, f, log) + if err == nil && !o.Local && o.Proxy == "snippets" { + // What the web server is told follows what is installed here. + if dir, err := compose.WriteProxySnippets(o.Dir, stack); err == nil { + res.ProxyConfig = dir + log.Info("rewrote %s for what is installed now: reload your web server if it changed", dir) + } + } + return res, err } // The bootstrap credential lives in an override file for this step only, @@ -430,7 +439,32 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro } } } - if stack.Webmail || stack.Proxy { + // The operator's own web server, in front of the same loopback ports: + // trusted the same way, and exempted at the address its requests + // arrive from. That is loopback for a server on the host; for one in a + // container it is the project network's gateway, because a request to + // a published loopback port reaches the container from there. + snippets := !o.Local && o.Proxy == "snippets" + if snippets { + log.Step("trusting your web server's X-Forwarded-For") + if err := srv.TrustForwardedFor(ctx); err != nil { + return res, fmt.Errorf("trusting the proxy: %w", err) + } + from := []string{"127.0.0.1"} + if !onHost { + from = append(from, stack.GatewayIP) + } + for _, addr := range from { + if allowed[addr] { + continue + } + if err := srv.AllowIP(ctx, addr, "your web server in front of the suite: its requests arrive from this address"); err != nil { + return res, fmt.Errorf("exempting your web server: %w", err) + } + allowed[addr] = true + } + } + if stack.Webmail || stack.Proxy || snippets { // Neither setting takes effect on a running server. log.Info("restarting the server so those take effect") restart := func() error { return cmp.Run(ctx, "restart", "server") } @@ -452,7 +486,16 @@ func Run(ctx context.Context, p plan.Plan, f host.Facts, log Log) (*Result, erro // which is the proxy. Asked for on a machine with no proxy, the order // can only fail -- so this says whose job it is instead of leaving a // failed ACME account behind and stopping the install over it. - if !o.Local && !stack.Proxy { + if snippets { + log.Step("writing the configuration for your web server") + dir, err := compose.WriteProxySnippets(o.Dir, stack) + if err != nil { + return res, fmt.Errorf("writing the proxy configuration: %w", err) + } + res.ProxyConfig = dir + log.Info("%s/nginx-inbuxa.conf and %s/Caddyfile.fragment: load one into your web server", dir, dir) + log.Info("once it is loaded, turn on the mail server's own certificates in the console (Settings › Overview, Certificates): its challenges reach it through port 80") + } else if !o.Local && !stack.Proxy { log.Info("no proxy here, so certificates are yours to arrange: the server's own names are %s", strings.Join(stack.ServerNames(), ", ")) } diff --git a/internal/compose/compose.go b/internal/compose/compose.go index 1da96c9..7a07159 100644 --- a/internal/compose/compose.go +++ b/internal/compose/compose.go @@ -66,6 +66,7 @@ type Stack struct { WebmailBind string Subnet string + GatewayIP string // the project network's gateway: where the host is, seen from inside it ServerIP string ConsoleIP string WebmailIP string @@ -82,6 +83,10 @@ type Stack struct { ACMEDirectory string ACMECARoot string CABundle bool + + // Dir is the deployment directory, which the proxy configuration for + // the operator's own web server names. + Dir string } // ServerNames is every name the server's certificate and the proxy need: @@ -120,6 +125,7 @@ func (s *Stack) Addresses() error { } return a.String() } + s.GatewayIP = at(1) s.ServerIP, s.ConsoleIP, s.WebmailIP, s.CaddyIP = at(10), at(11), at(12), at(13) if s.ServerIP == "" || s.CaddyIP == "" { return fmt.Errorf("subnet %q is too small for the stack", s.Subnet) @@ -298,3 +304,35 @@ func secret() (string, error) { } return base64.RawURLEncoding.EncodeToString(b), nil } + +// ProxySnippets are the files --proxy snippets writes, for the web server the +// operator already runs: an nginx configuration and a Caddyfile fragment. +var ProxySnippets = map[string]string{ + "nginx-inbuxa.conf.tmpl": "nginx-inbuxa.conf", + "Caddyfile.fragment.tmpl": "Caddyfile.fragment", +} + +// WriteProxySnippets writes them into dir/proxy and returns that directory. +// Nothing is loaded or reloaded: that web server is the operator's. +func WriteProxySnippets(dir string, s Stack) (string, error) { + out := filepath.Join(dir, "proxy") + if err := os.MkdirAll(out, 0o755); err != nil { + return "", err + } + s.Dir = dir + funcs := template.FuncMap{"join": strings.Join} + for name, file := range ProxySnippets { + t, err := template.New(name).Funcs(funcs).ParseFS(templates, "templates/"+name) + if err != nil { + return "", err + } + var b strings.Builder + if err := t.Execute(&b, s); err != nil { + return "", fmt.Errorf("%s: %w", name, err) + } + if err := os.WriteFile(filepath.Join(out, file), []byte(b.String()), 0o644); err != nil { + return "", err + } + } + return out, nil +} diff --git a/internal/compose/compose_test.go b/internal/compose/compose_test.go index 6eef177..9a6b694 100644 --- a/internal/compose/compose_test.go +++ b/internal/compose/compose_test.go @@ -119,3 +119,55 @@ func TestJoinedToALoopbackServerTheWebmailSharesTheHost(t *testing.T) { t.Errorf("the webmail would be exempted at %s", s.WebmailIP) } } + +func TestProxySnippetsPointAtLoopback(t *testing.T) { + dir := t.TempDir() + s := stack(false) + if err := s.Addresses(); err != nil { + t.Fatal(err) + } + out, err := WriteProxySnippets(dir, *s) + if err != nil { + t.Fatal(err) + } + nginx, _ := os.ReadFile(filepath.Join(out, "nginx-inbuxa.conf")) + caddy, _ := os.ReadFile(filepath.Join(out, "Caddyfile.fragment")) + for _, want := range []string{ + "server_name mail.example.com autoconfig.example.com", + "proxy_pass http://127.0.0.1:8081;", "proxy_pass http://127.0.0.1:8082;", "proxy_pass http://127.0.0.1:8080;", + "location /.well-known/acme-challenge/", + "proxy_set_header X-Forwarded-For $remote_addr;", + "server_name admin.example.com;", "server_name webmail.example.com;", + } { + if !strings.Contains(string(nginx), want) { + t.Errorf("nginx-inbuxa.conf lacks %q", want) + } + } + for _, want := range []string{"reverse_proxy 127.0.0.1:8081", "disable_http_challenge", "import " + dir + "/proxy/Caddyfile.fragment"} { + if !strings.Contains(string(caddy), want) { + t.Errorf("Caddyfile.fragment lacks %q", want) + } + } + // A fragment is imported beside other sites: no global options block + for _, line := range strings.Split(string(caddy), "\n") { + if strings.TrimSpace(line) == "{" { + t.Error("the Caddyfile fragment has a global options block") + } + } + if s.GatewayIP != "172.31.253.1" { + t.Errorf("gateway = %s", s.GatewayIP) + } +} + +func TestProxySnippetsLeaveOutWhatIsNotHere(t *testing.T) { + s := stack(true) + s.Webmail = false + out, err := WriteProxySnippets(t.TempDir(), *s) + if err != nil { + t.Fatal(err) + } + nginx, _ := os.ReadFile(filepath.Join(out, "nginx-inbuxa.conf")) + if strings.Contains(string(nginx), "webmail.example.com") { + t.Error("a webmail that isn't installed is in the nginx configuration") + } +} diff --git a/internal/compose/templates/Caddyfile.fragment.tmpl b/internal/compose/templates/Caddyfile.fragment.tmpl new file mode 100644 index 0000000..76807e2 --- /dev/null +++ b/internal/compose/templates/Caddyfile.fragment.tmpl @@ -0,0 +1,52 @@ +# Written by the inbuxa installer {{.Version}} for {{.Domain}}. +# +# For the web server already on this machine: Caddy. Import it from your +# Caddyfile (`import {{.Dir}}/proxy/Caddyfile.fragment`) and reload. It has no +# global options block, so it can sit beside your own sites. The installer +# loads nothing and restarts nothing. +# +# Everything is passed to loopback: 8081 the mail server, 8082 the console, +# 8080 the webmail. Caddy gets certificates for the console and the webmail +# itself. +{{- if .ServesServer}} + +# The mail server's names. Caddy uses TLS-ALPN-01 for them and leaves HTTP-01 +# on port 80 to the mail server, which needs a certificate of its own for +# IMAP and SMTP: so neither answers the other's challenge. +{{join .ServerNames ", "}} { + tls { + issuer acme { + email {{.Email}} + disable_http_challenge + } + } + reverse_proxy 127.0.0.1:8081 { + flush_interval -1 + } +} + +{{range $i, $n := .ServerNames}}{{if $i}}, {{end}}http://{{$n}}{{end}} { + handle /.well-known/acme-challenge/* { + reverse_proxy 127.0.0.1:8081 + } + handle { + redir https://{host}{uri} 308 + } +} +{{- end}} +{{- if .Console}} + +{{.ConsoleHost}} { + encode zstd gzip + reverse_proxy 127.0.0.1:8082 +} +{{- end}} +{{- if .Webmail}} + +{{.WebmailHost}} { + encode zstd gzip + reverse_proxy 127.0.0.1:8080 { + flush_interval -1 + } +} +{{- end}} diff --git a/internal/compose/templates/nginx-inbuxa.conf.tmpl b/internal/compose/templates/nginx-inbuxa.conf.tmpl new file mode 100644 index 0000000..49bef25 --- /dev/null +++ b/internal/compose/templates/nginx-inbuxa.conf.tmpl @@ -0,0 +1,118 @@ +# Written by the inbuxa installer {{.Version}} for {{.Domain}}. +# +# For the web server already on this machine: nginx. Include it from +# /etc/nginx/conf.d/ (or sites-enabled/), set each ssl_certificate pair to the +# certificate you have for those names, check it with `nginx -t`, and reload. +# The installer loads nothing and restarts nothing; this is yours to adjust. +# +# Everything is passed to loopback, where the installer put each program: +# 127.0.0.1:8081 the mail server's web side (JMAP, CalDAV, CardDAV, +# autoconfig, MTA-STS) +# 127.0.0.1:8082 the console +# 127.0.0.1:8080 the webmail +# +# The mail server trusts X-Forwarded-For from here, so every block sets it to +# the client's own address rather than passing on what the client sent. +{{- if .ServesServer}} + +# Port 80 for the server's names: its own certificate challenges, which it +# answers itself once certificates are turned on in the console, and a +# redirect for everything else. +server { + listen 80; + listen [::]:80; + server_name {{join .ServerNames " "}}; + + location /.well-known/acme-challenge/ { + proxy_pass http://127.0.0.1:8081; + proxy_set_header Host $host; + proxy_set_header X-Forwarded-For $remote_addr; + } + location / { + return 308 https://$host$request_uri; + } +} + +# The mail server's web side. Push arrives as a long-lived stream, so it is +# not buffered and not timed out early. +server { + listen 443 ssl; + listen [::]:443 ssl; + http2 on; + server_name {{join .ServerNames " "}}; + + ssl_certificate /etc/ssl/inbuxa/{{.MailHost}}.fullchain.pem; + ssl_certificate_key /etc/ssl/inbuxa/{{.MailHost}}.key.pem; + + client_max_body_size 100m; + + location / { + proxy_pass http://127.0.0.1:8081; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Forwarded-For $remote_addr; + proxy_set_header X-Forwarded-Proto https; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection $http_connection; + proxy_buffering off; + proxy_read_timeout 1h; + } +} +{{- end}} +{{- if .Console}} + +# The console: static files. It talks to the mail server from the browser, +# so nothing here proxies the API. +server { + listen 80; + listen [::]:80; + server_name {{.ConsoleHost}}; + return 308 https://$host$request_uri; +} +server { + listen 443 ssl; + listen [::]:443 ssl; + http2 on; + server_name {{.ConsoleHost}}; + + ssl_certificate /etc/ssl/inbuxa/{{.ConsoleHost}}.fullchain.pem; + ssl_certificate_key /etc/ssl/inbuxa/{{.ConsoleHost}}.key.pem; + + location / { + proxy_pass http://127.0.0.1:8082; + proxy_set_header Host $host; + } +} +{{- end}} +{{- if .Webmail}} + +# The webmail. Push arrives as Server-Sent Events: flushed as written, and +# held open. +server { + listen 80; + listen [::]:80; + server_name {{.WebmailHost}}; + return 308 https://$host$request_uri; +} +server { + listen 443 ssl; + listen [::]:443 ssl; + http2 on; + server_name {{.WebmailHost}}; + + ssl_certificate /etc/ssl/inbuxa/{{.WebmailHost}}.fullchain.pem; + ssl_certificate_key /etc/ssl/inbuxa/{{.WebmailHost}}.key.pem; + + client_max_body_size 100m; + + location / { + proxy_pass http://127.0.0.1:8080; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Forwarded-For $remote_addr; + proxy_set_header X-Forwarded-Proto https; + proxy_buffering off; + proxy_read_timeout 1h; + } +} +{{- end}} diff --git a/internal/plan/plan.go b/internal/plan/plan.go index 98d4e97..0763347 100644 --- a/internal/plan/plan.go +++ b/internal/plan/plan.go @@ -390,6 +390,8 @@ func Build(f host.Facts, o Options) (Plan, error) { Detail: []string{ o.Dir + "/proxy/nginx-inbuxa.conf and " + o.Dir + "/proxy/Caddyfile.fragment", "nothing is loaded or restarted: that stays yours", + "the server trusts your web server's X-Forwarded-For and exempts it from the auto-ban", + "the mail server's own certificates: turned on in the console once it is loaded", }, }) } diff --git a/internal/tui/install.go b/internal/tui/install.go index 32948fb..54b66c0 100644 --- a/internal/tui/install.go +++ b/internal/tui/install.go @@ -59,7 +59,7 @@ type Wizard struct { row int shapes map[plan.Component]plan.Shape - proxy int // 0 caddy, 1 your own + proxy int // 0 caddy, 1 snippets for your own, 2 none built plan.Plan buildErr error @@ -145,7 +145,7 @@ func (w *Wizard) Options() plan.Options { o.ACMEEmail = strings.TrimSpace(w.fields[4].text()) o.Dir = strings.TrimSpace(w.fields[5].text()) o.Local = w.fields[6].text() == "yes" - o.Proxy = []string{"caddy", "none"}[w.proxy] + o.Proxy = []string{"caddy", "snippets", "none"}[w.proxy] o.Choices = nil for _, c := range []plan.Component{plan.Server, plan.Console, plan.Webmail} { o.Choices = append(o.Choices, plan.Choice{Component: c, Shape: w.shapes[c]}) @@ -449,9 +449,13 @@ func (w *Wizard) updateReach(k Key) { } switch k.Kind { case KeyUp: - w.proxy = 0 + if w.proxy > 0 { + w.proxy-- + } case KeyDown: - w.proxy = 1 + if w.proxy < 2 { + w.proxy++ + } case KeyEnter: w.next() } @@ -633,7 +637,8 @@ func (w *Wizard) viewReach(width int) ([]string, string) { } options := []struct{ name, about string }{ {"Caddy, managed by the installer", "It holds 80 and 443, gets certificates for every name, and passes the server's own certificate challenges through."}, - {"Your own web server", "Nothing here takes 80 or 443. Point yours at 127.0.0.1:8081 for the server, 127.0.0.1:8082 for the console and 127.0.0.1:8080 for the webmail; certificates are yours to arrange."}, + {"Your own web server, with its configuration written", "Nothing here takes 80 or 443. The installer writes an nginx configuration and a Caddyfile fragment for the web server you run, and trusts it in front of the suite; loading it is yours."}, + {"Nothing in front", "Nothing here takes 80 or 443, and nothing is written. The server answers on 127.0.0.1:8081, the console on 127.0.0.1:8082, the webmail on 127.0.0.1:8080."}, } for i, opt := range options { mark := "( )" @@ -867,6 +872,9 @@ func Summary(res *apply.Result, err error, problems []string) []string { row("certificate", "issued by "+res.Certificate) } row("dns records", res.ZoneFile) + if res.ProxyConfig != "" { + row("proxy config", res.ProxyConfig+" (load it into your web server)") + } return out }