fix: the web service starts again after its first start with 0.39.0, and the name server's domains can be changed from any process.

ADR.md

@@ -481,11 +481,14 @@ standard attributes, are the display name and the description of a service accou
 `account` cannot hold. Manager-only accounts have the class from their creation, so an e-mail
 address can be added later without changing their classes; VPN users get it once scopes are used.
 `vpnrouter_ldap.provision` replaces the definitions in `cn=config` that differ, so an extended class
-reaches an existing directory at the next setup run.
+reaches an existing directory at the next setup run. The structural class `vpnRouterRole`,
+`MUST cn MAY ( description $ member )`, is a role of a resource of the OpenID Provider (ADR-37),
+an entry `cn=<resource>:<role>` of `ou=roles`, which provision makes; the manager account manages
+that subtree, and every account reads it.
 
-Consequences: The schema check stays strict. New attributes extend `vpnRouterAccount`, and their
-OIDs continue the arcs. The scope `service` marks a service account (ADR-23). The OID must never
-be reused for anything else.
+Consequences: The schema check stays strict. New attributes of accounts extend
+`vpnRouterAccount`, and their OIDs continue the arcs. The scope `service` marks a service account
+(ADR-23). The OID must never be reused for anything else.
 
 ## ADR-20: Users manage their own account through /account, proving who they are again
 
@@ -531,11 +534,17 @@ package's drop-in for `caddy.service` points it at that file and keeps it from s
 the file exists, so `/etc/caddy/Caddyfile`, a configuration file of the `caddy` package, is left
 unchanged. Both services always listen on `127.0.0.1` as well as on the interfaces their
 `listen` settings name, and trust `X-Forwarded-For` from it, which Caddy sets from the peer and
-never takes from the client.
+never takes from the client. Let's Encrypt issues at most 5 certificates a week for the same
+names, which routers rebuilt for tests reach; `https.acme_staging` sets Caddy's global `acme_ca`
+to Let's Encrypt's staging directory, which replaces Caddy's default CAs for every site, so no
+test certificate comes from a production CA. `PUT /https/settings` changes `acme_staging` alone:
+the other settings of the section switch HTTPS off or move its ports, which would end the
+connection the Router Manager makes the change on.
 
 Consequences: HTTPS needs `wan.local_fqdn` in public DNS pointing at the router and port 80
 reachable from the internet; until then Caddy retries and the HTTPS ports do not answer. The
-certificate and the ACME account are in `/var/lib/caddy`. Plain HTTP stays as the `listen`
+certificate and the ACME account are in `/var/lib/caddy`. A router on the staging CA has a
+certificate no client trusts. Plain HTTP stays as the `listen`
 settings set it, so `internal` keeps passwords off the internet. Caddy's admin endpoint listens
 on `localhost:2019`, which `caddy reload` uses. Port 80 and the HTTPS ports are not available
 to Docker containers while HTTPS is on. The Manager's HTTPS port is a setting of the router, not
@@ -908,8 +917,14 @@ Decision: `/shell` of the web service is off until `web.shell` is set on the rou
 Manager cannot set it. The shell runs as the console account of the signed-in user (ADR-34), so
 it is never root and each administrator's shell is the administrator's own; a user without
 console login gets none. `POST /shell` signs the user in again with the password
-and TOTP code and gives a one-time ticket valid 30 seconds; a WebSocket on `GET /shell` with that
-ticket gets the shell. Asking for the password and code at every opening of the page is tiresome,
+and TOTP code, or with one of the user's own passkeys (ADR-36), and gives a one-time ticket valid 30
+seconds; a WebSocket on `GET /shell` with that ticket gets the shell. A passkey with user
+verification is a possession and a PIN or biometric in one step and cannot be phished, so it is
+as good as the password and the code; `POST /shell/passkey` begins a proof bound to the signed-in
+user and its credentials, and python3-fido2 refuses an answer without the user-verified flag. The
+TOTP enrolment stays required with a passkey: the PAM login session of the shell, through the
+`pam_authz_search` of nslcd for a directory account, and sudo in it need it, and loosening that
+filter would let such a user log in over SSH with the password alone. Asking for the password and code at every opening of the page is tiresome,
 so within `web.shell_auth_timeout` minutes of the user's last sign-in or keystroke a ticket is given
 without them; the times are kept in the web service's memory only, so a restart asks again, and 0
 keeps the sign-in at every opening. The WebSocket of RFC 6455 is implemented on the standard library inside the
@@ -920,9 +935,10 @@ makes the terminal its controlling terminal so window sizes reach the shell. A s
 Manager checks the session and the WebSocket's origin, and relays the bytes to the router after
 both handshakes.
 
-Consequences: Who can sign in as a member of `admins` and knows the password and the current code
-can get a shell when the router allows one and the user's console login is on; a session alone
-cannot. The ticket travels in the URL and appears in request logs, used up. The shell's sessions
+Consequences: Who can sign in as a member of `admins` and knows the password and the current code,
+or holds one of the user's passkeys and unlocks it, can get a shell when the router allows one and
+the user's console login is on; a session alone cannot. A failed passkey proof is refused but not
+counted as a failed login, as with the passkey sign-in. The ticket travels in the URL and appears in request logs, used up. The shell's sessions
 show up as `vpn-router-shell-<id>` units and logind sessions of the console account. The shell's
 traffic is as protected as the Router Manager's: HTTPS to Caddy, plain HTTP on the internal
 network to the web service.
@@ -1006,43 +1022,97 @@ Router Manager on another name, or in development on `localhost`, cannot use the
 sign-ins do not count towards the directory's lockout, but the sign-in calls are rate limited.
 Browsers without the JSON methods of WebAuthn Level 3 cannot add or use passkeys.
 
-## ADR-37: The web service is an OpenID Provider built on python3-oauthlib; its clients are service accounts
+## ADR-37: The web service is an OpenID Provider built on python3-oauthlib; its clients and resources are service accounts
 
 Status: Accepted
 
-Context: Other systems, such as dashboards, should sign the router's users in with the directory's
-passwords, TOTP codes and passkeys, without a second user store. The Ubuntu archive has no
-packaged identity provider. `python3-oauthlib` and `python3-jwt` are in main for noble and
-resolute; oauthlib implements the OpenID Connect flows and leaves the checks, the storage and the
-ID token's signature to the application. `python3-authlib` and `python3-jwcrypto` are in universe
-only. The web service already checks passwords and passkeys, rate limits sign-ins and keeps
-tokens in PostgreSQL, and Caddy serves it over HTTPS on `wan.local_fqdn`. ADR-3's HS256 key must
-not leave the router, but a relying party verifies an ID token itself.
+Context:
 
-Decision: The web service is the OpenID Provider, in `vpnrouter_oidc`, while `oidc.enabled` is
-true; its issuer is its HTTPS site, `https://<wan.local_fqdn>:<https.web_port>`, without the port
-on 443, and it answers the provider's paths only on `127.0.0.1`, where Caddy passes them. Only
-the authorization code flow with PKCE S256 and the refresh token grant are allowed. A client is a
-service account with redirect URIs, kept with the account in the new attributes
-`vpnRouterRedirectUri`, `vpnRouterPostLogoutRedirectUri` and `vpnRouterAllowedGroup` of
-`vpnRouterAccount`: its name is the client ID and its password the secret, checked with a bind.
-Allowed groups limit who may sign in; without them every user may. A registered client is
-trusted, so there is no consent page. The sign-in page is the web service's own, a Jinja2
-template with the password, the code and a passkey, so the provider works without the Router
-Manager. ID tokens are RS256, signed with an RSA key the web service makes on its first run
-(`/etc/vpn-router/oidc.key`), published as a JWK named by its RFC 7638 thumbprint; `sub` is the
-entry's `entryUUID`. Codes, access and refresh tokens and sessions are kept as their SHA-256 in
-the database of the refresh tokens, defined in `/usr/share/vpn-router/sql/oidc.sql` with
-procedures and functions the module calls; a process loads the file at its first connection. The
-operations that revoke the refresh tokens of `/auth` also revoke them, and every use of a code or
-token checks the user and the client's allowed groups again.
+- **What is needed:** other systems, such as dashboards, should sign the router's users in with the
+  directory's passwords, TOTP codes and passkeys, without a second user store. Programs on hosts
+  without a browser, and jobs without a user, need tokens as well. Services such as an S3 gateway
+  should learn from a token what its holder may do there, as resources of Entra ID do with app
+  roles and scopes.
+- **What the archive has:** no packaged identity provider. `python3-oauthlib` and `python3-jwt`
+  are in main for noble and resolute; `python3-authlib` and `python3-jwcrypto` are in universe
+  only.
+- **What oauthlib does:** it implements the OAuth 2.0 and OpenID Connect flows, including the
+  client credentials grant, and leaves the checks, the storage and the signatures to the
+  application. Noble's 3.2.2 has no device authorization grant (RFC 8628). Resolute's 3.3.1 has
+  one, as has the current 4.0.0, but it checks no device code and never answers
+  `authorization_pending` or `slow_down`.
+- **What the web service has:** it already checks passwords and passkeys, rate limits sign-ins and
+  keeps tokens in PostgreSQL, and Caddy serves it over HTTPS on `wan.local_fqdn`. ADR-3's HS256
+  key must not leave the router, but a relying party or a resource verifies a token itself.
 
-Consequences: The package depends on `python3-oauthlib` and `python3-jwt`. The provider needs
-HTTPS, a public name and the web service. Clients are managed like service accounts, by the CLI,
-`/service-accounts` and the Router Manager; a group a client allows cannot be removed, and renaming
-it renames it in the clients. The signing key does not rotate; replacing it invalidates every ID
-token issued. Wrong client secrets lock the client like any account. The implicit and hybrid
-flows, dynamic client registration and public clients without a secret are not offered.
+Decision:
+
+- **Where it runs:** the web service is the OpenID Provider, in `vpnrouter_oidc`, while
+  `oidc.enabled` is true. Its issuer is its HTTPS site, `https://<wan.local_fqdn>:<https.web_port>`,
+  without the port on 443, and it answers the provider's paths only on `127.0.0.1`, where Caddy
+  passes them.
+- **Clients:**
+  - A client is a service account with redirect URIs or grants, kept with the account in
+    attributes of `vpnRouterAccount`: `vpnRouterRedirectUri`, `vpnRouterPostLogoutRedirectUri`,
+    `vpnRouterAllowedGroup`, `vpnRouterGrantType`, `vpnRouterPublicClient` and
+    `vpnRouterClientScope`.
+  - Its name is the client ID and its password the secret, checked with a bind; a public client has
+    none.
+  - Allowed groups limit who may sign in; without them every user may.
+- **Grants:**
+  - the authorization code with PKCE S256, which redirect URIs give;
+  - `client_credentials`, for confidential clients only;
+  - the device code;
+  - the refresh token for the first and the last.
+
+  The device grant is the router's own grant class on oauthlib's token endpoint, with its
+  authorization endpoint and pages, so it works the same with every oauthlib release. A loopback
+  redirect URI matches with any port (RFC 8252).
+- **Consent:** a registered client is trusted, so there is no consent page, except for a device:
+  the user who enters its code is asked to allow it, as RFC 8628 advises against remote phishing.
+- **The sign-in page:** the web service's own, a Jinja2 template with the password, the code and a
+  passkey, so the provider works without the Router Manager.
+- **Resources, as Entra ID:**
+  - Every service account is a resource. Its scopes are in `vpnRouterResourceScope`, and its roles
+    are `vpnRouterRole` entries (ADR-19) whose members are groups and accounts.
+  - A token request names its resource with `resource` (RFC 8707) or by the resource's scopes,
+    `<resource>:<scope>`, which the client's scopes must allow.
+  - Without a resource, the tokens are for the client.
+  - The grant keeps the resource, so a code, a device code or a refresh token gives tokens for that
+    resource only.
+- **Tokens:**
+  - Both kinds are RS256 JWTs, signed with an RSA key the web service makes on its first run
+    (`/etc/vpn-router/oidc.key`), published as a JWK named by its RFC 7638 thumbprint; `sub` is
+    the entry's `entryUUID`.
+  - An ID token is for the client and carries the user's roles of the client.
+  - An access token follows RFC 9068: it is for the resource and carries the holder's roles there
+    and the scopes granted, so a resource needs nothing from the router but the JWKS.
+  - Roles are read at every issue.
+- **Storage:**
+  - Codes, device codes, access and refresh tokens and sessions are kept as their SHA-256 in the
+    database of the refresh tokens.
+  - They are defined in `/usr/share/vpn-router/sql/oidc.sql`, with the procedures and functions
+    the module calls; a process loads the file at its first connection.
+  - The operations that revoke the refresh tokens of `/auth`, of users and of service accounts,
+    also revoke them, and every use of a code, a device code or a token checks the user and the
+    client's allowed groups again.
+
+Consequences:
+
+- **Requirements:** the package depends on `python3-oauthlib` and `python3-jwt`. The provider needs
+  HTTPS, a public name and the web service.
+- **Management:** clients, resources and their roles are managed like service accounts, by the
+  CLI, `vpn-router-role`, `/service-accounts` and the Router Manager.
+- **The directory keeps itself consistent:**
+  - a group a client allows cannot be removed, and renaming it renames it in the clients and the
+    roles;
+  - a resource scope a client may ask for cannot be removed.
+- **Revocation:** an access token, a JWT, is valid at a resource until it expires, 5 minutes after
+  issue, whatever the router revokes. The signing key does not rotate; replacing it invalidates
+  every token issued.
+- **Lockout:** wrong client secrets lock the client like any account.
+- **Not offered:** the implicit and hybrid flows, the password grant and dynamic client
+  registration.
 
 ## ADR-38: Bash completions are files per command in bash-completion's completions directory
 
@@ -1141,8 +1211,9 @@ later. S3 and Azure Blob clients are not served.
 
 Status: Accepted
 
-Context: The router hosts authoritative domains as their primary, with optional secondary name
-servers, and a domain can give the sites their records without a registrar change per site. Ubuntu
+Context: The router hosts authoritative domains as their primary, with a secondary name server, and
+a domain can give the sites their records without a registrar change per site. The router's own
+name, `wan.local_fqdn`, belongs to a domain of its own, wherever that is hosted. Ubuntu
 has BIND, Knot and PowerDNS; only PowerDNS's gpgsql backend reads records
 from PostgreSQL, so changes are rows, without zone files or reloads. systemd-resolved's stub holds
 127.0.0.53 and 127.0.0.54, and the remote access clients' resolver answered on the external
@@ -1152,25 +1223,33 @@ just as well, through the tunnel when it is in `local.cidrs` (ADR-43).
 Decision: While `dns.enabled` is true, setup runs `pdns.service` with
 `/etc/powerdns/pdns.d/vpn-router.conf`, written before the packages are installed, on the
 addresses of `dns.listen`, with the gpgsql backend on the database `vpn-router-dns` and PowerDNS's
-own schema, and `primary=yes`. The domains, their secondaries and manual records are rows of the
-router's tables in that database, like the sites in `vpn-router-sites`, not settings of
-`vpn-router.json`: they are many and change through the web service. `dns.nameserver` and
-`dns.addresses` stay settings, the router's one identity as the primary NS of every domain. Setup
+own schema, and `primary=yes`. The domains and their manual records are rows of the router's tables
+in that database, like the sites in `vpn-router-sites`, not settings of `vpn-router.json`: they are
+many and change through the web service. The name servers are settings, the same for every domain:
+`wan.local_fqdn`, the router's one name, is the primary, and `dns.secondary` the secondary. Setup
 writes each domain as a MASTER zone through the procedure `dns_apply` of
-`/usr/share/vpn-router/sql/dns.sql`: SOA, NS of the router and the secondaries, A and AAAA records
-of `dns.addresses` for the apex, the name server and, with the domain's site records switch, every
-site host name whose closest domain it is, and the manual records; the serial grows only when the
-records change, which makes PowerDNS notify. A secondary is a name, its NS, and an address, which
-goes to the domain's `ALSO-NOTIFY` and `ALLOW-AXFR-FROM` metadata, so the global
-`allow-axfr-ips` stays the loopback default. A host name belongs to its closest domain only, and a
+`/usr/share/vpn-router/sql/dns.sql`: SOA with `wan.local_fqdn`, NS of `wan.local_fqdn` and
+`dns.secondary`, an A or AAAA record of every host name of a site with `dns` `router` whose closest
+domain it is, with the router's address the site chooses (`wan.public_address`, the internal or the
+external interface's), and the manual records; the serial grows only when the records change, which
+makes PowerDNS notify. `wan.local_fqdn` gets no record in the domains: its A record is in the DNS of
+its own domain, which the router does not manage. A site of `dns` `user` gets no records, as its
+names are served elsewhere. The addresses `dns.secondary` resolves to at each run go to every
+domain's `ALSO-NOTIFY` and `ALLOW-AXFR-FROM` metadata, so the global `allow-axfr-ips` stays the
+loopback default. The public address is a setting, since the router sees only private addresses on
+its interfaces behind a cloud's NAT and resolving `wan.local_fqdn` would answer from its own DNS
+when it hosts that name. `dns.nameserver` and `dns.addresses` of an earlier configuration are left
+out when it is read, so that it loads; a missing `dns.secondary` makes setup warn, not fail, so that
+a router keeps running until it is set. A host name belongs to its closest domain only, and a
 domain inside another is delegated from it with NS records, so a name is never answered by two
 zones. The remote access clients' resolver answers on the addresses of the setting
 `p2s.dns_listen`, by default the internal one; a `dns.listen` that shares an interface with it is
 refused while P2S or OpenVPN is enabled.
 
-Consequences: The domains follow the sites at each setup run. Transfers are authorized by address,
-without TSIG, and there is no DNSSEC; the delegation of each domain is made at its parent zone by
-hand.
+Consequences: The domains follow the sites at each setup run. Transfers are authorized by the
+address the secondary's name resolves to, without TSIG, and there is no DNSSEC; the delegation of
+each domain, with glue for the name servers inside it, is made at its parent zone by hand. Every
+domain has the same two name servers.
 
 ## ADR-43: The remote access clients' resolver is dnsmasq, not systemd-resolved
 
@@ -1278,3 +1357,42 @@ method.
 Consequences: A change to one family of paths touches one module and the routing in `handler`.
 State shared between requests, such as the open shells, lives in the module that owns it; other
 modules change it and never rebind it.
+
+## ADR-48: Exceptions are handled; no traceback reaches the logs
+
+Status: Accepted
+
+Context: The services log to the journal, which administrators read through the Logs page and
+`journalctl`. Python prints a traceback for an exception nothing handles: `socketserver` for a
+failed request, `threading` for a failed thread and the interpreter for the process. A client
+that closes its connection before the answer is written, as a page does when it is left or
+reloaded, raises `BrokenPipeError` or `ConnectionResetError` in the handler. A traceback is many
+lines of internals for one event and hides the lines around it.
+
+Decision: The code handles the exceptions it can expect where they occur, and answers or logs
+them with their reason in one line. An exception left unhandled is a defect to be fixed. As the
+last line of defence, every server replaces the default reports:
+
+- `vpnrouter_serve.serve`, which the web service and the metrics service run, sets the servers'
+  `handle_error`, `threading.excepthook` and `sys.excepthook`.
+- The bootstrap server sets its server's `handle_error` and `sys.excepthook`.
+
+A `ConnectionError` of a client that went away is not logged; any other exception is logged in
+one line with its type and message.
+
+Consequences: The logs hold one line per failure, without its stack. A failure that reaches the
+last line of defence is found by its message and fixed where it occurs, with its own handling.
+
+## ADR-49: A changelog summary is a paragraph wrapped at 80 columns
+
+Status: Accepted
+
+Context: The summary of an entry of `debian/changelog` is the commit message of its release,
+which `release.py` reads from the changelog. Summaries are often longer than the 80 columns
+Debian's tools expect of a changelog line.
+
+Decision: The summary is the entry's first paragraph, indented by two spaces and wrapped at 80
+columns. `release.py` joins its lines with single spaces into the commit message.
+
+Consequences: The commit message is one line however the summary is wrapped, so a summary
+rewrapped later still matches the commit of its release.

README.md

@@ -15,7 +15,7 @@ A Debian package that configures a Linux host or virtual machine as a VPN router
 - metrics of the router kept in PostgreSQL, served for an OpenTelemetry Collector and pushed
   over OTLP
 - static web sites served by Caddy, uploaded through the web service or WebDAV, and an optional
-  primary name server (PowerDNS) of the router's domains, with secondaries and records for the sites
+  primary name server (PowerDNS) of the router's domains, with a secondary and records for the sites
 
 Nothing in the package is specific to a cloud provider. It is built on the external and
 internal NIC names, and a `mode` setting says how much of the rest you are supplying and
@@ -108,7 +108,8 @@ must have the type shown below; an unknown section or setting is an error.
 | `general` | `mode` | string | `manual` | How much you supply: `manual`, `interfaces` or `auto` |
 | `interfaces` | `external` | string | | Name of the NIC facing the untrusted network |
 | `interfaces` | `internal` | string | | Name of the NIC facing the protected network |
-| `wan` | `local_fqdn` | string | | This router's name or IP address: its IKE identity in `fqdn` mode, the name resolved in `public_ip` mode, and the name of HTTPS, IKEv2 and OpenVPN |
+| `wan` | `local_fqdn` | string | | This router's name or IP address: its IKE identity in `fqdn` mode, the name resolved in `public_ip` mode, the name of HTTPS, IKEv2 and OpenVPN, and the primary name server of its domains |
+| `wan` | `public_address` | string | | The router's public IP address, which its own interfaces do not show behind a cloud's NAT: the address of the records of the sites with `dns_address` `public` |
 | `local` | `cidrs` | list | | Local subnets routed via the internal side, masqueraded to the external one, and offered to IKEv2 and OpenVPN clients |
 | `local` | `int_addr` | string | | This host's address on the internal network |
 | `local` | `int_gateway_ip` | string | | Next hop on the internal side |
@@ -141,15 +142,15 @@ must have the type shown below; an unknown section or setting is an error.
 | `https` | `email` | string | | The e-mail address of the Let's Encrypt account |
 | `https` | `web_port` | integer | `7444` | HTTPS port of the status web service |
 | `https` | `manager_port` | integer | `7443` | HTTPS port of the Router Manager |
+| `https` | `acme_staging` | boolean | `false` | Caddy takes its certificates from Let's Encrypt's staging environment alone, whose certificates no browser trusts and whose rate limits are higher, for routers rebuilt often (see HTTPS) |
 | `https` | `caddy_source` | string | `ubuntu` | Where Caddy is installed from: `ubuntu`, the Ubuntu archive, or `upstream`, Caddy's own repository (see HTTPS) |
 | `oidc` | `enabled` | boolean | `false` | The OpenID Provider at the status web service's HTTPS site, which needs `web.enabled`, `https.enabled` and `wan.local_fqdn` (see OpenID Provider) |
 | `sites` | `enabled` | boolean | `false` | Caddy serves the web sites (see Web sites) |
 | `sites` | `upload_max_mb` | integer | `512` | The largest upload of a site's file or zip archive, in MiB, 1 to 10240 |
 | `sites` | `webdav` | boolean | `false` | WebDAV of the sites' folders, which needs `https.enabled` and `wan.local_fqdn` (see WebDAV) |
 | `sites` | `webdav_port` | integer | `7445` | HTTPS port of WebDAV |
-| `dns` | `enabled` | boolean | `false` | The primary name server of the router's domains, which needs `dns.nameserver` and `dns.addresses` (see Name server) |
-| `dns` | `nameserver` | string | | The name server's host name, the primary NS of every domain |
-| `dns` | `addresses` | list | | The public addresses of the name server, the domains' apexes and the sites' host names |
+| `dns` | `enabled` | boolean | `false` | The primary name server of the router's domains, `wan.local_fqdn`, which must then be a DNS name (see Name server) |
+| `dns` | `secondary` | string | | The secondary name server of every domain, a host name other than `wan.local_fqdn`; it may transfer the domains |
 | `dns` | `listen` | string | `external` | The interfaces the name server answers on: `internal`, `external` or `both` |
 | `dns` | `ttl` | integer | `300` | TTL of the records, 60 to 86400 seconds |
 | `pki` | `root_name` | string | `VPN Router Root CA` | Common name of the root CA, when the router creates it |
@@ -375,7 +376,7 @@ refused request exits with status 2, any other failure with 1.
 ## Bash completion
 
 Bash completes the commands, options and arguments of `vpn-router-user`, `vpn-router-group`,
-`vpn-router-token`, `vpn-config-edit`, `vpn-router-backup`, `vpn-router-ca`, `vpn-router-caddy`
+`vpn-router-role`, `vpn-router-token`, `vpn-config-edit`, `vpn-router-backup`, `vpn-router-ca`, `vpn-router-caddy`
 and `vpn-router-site` with the Tab key. The package installs a file per command in
 `/usr/share/bash-completion/completions`, which the `bash-completion` package, recommended by
 `vpn-router`, loads on the first Tab after the command. For root, who can read them, the
@@ -702,8 +703,9 @@ it is added:
 - a service account, a Manager-only account whose `vpnRouterScope` is `service`, which another
   system signs in with to use a router service, such as an OpenTelemetry Collector reading
   `/metrics`; it cannot sign in to `/auth`. Besides its name, it has a display name and a
-  description, and a service account with redirect URIs is a client of the OpenID Provider (see
-  OpenID Provider). `add --service` adds one, and the web service manages them at `/service-accounts`,
+  description, a service account with redirect URIs or grants is a client of the OpenID Provider,
+  and every one is a resource of it, with its scopes and roles (see OpenID Provider). `add
+  --service` adds one, and the web service manages them at `/service-accounts`,
   not at `/users`. Internal service accounts are those the router creates and manages for its own
   services, display name and description included; at present that is the metrics service's, the
   account `metrics.service_account` names while metrics are enabled (see Metrics), which
@@ -741,9 +743,9 @@ vpn-router-user otp-remove alice
 | `list` | The users with their kind, names and e-mail addresses, whether each is enabled or locked, has a certificate and is enrolled for TOTP, the number of passkeys and the console login |
 | `add <name> --first-name F --last-name L --email E` | Adds a VPN user and issues the certificate |
 | `add <name> [--email E]` | Adds a Manager-only account, with the e-mail address when given; one name without the other two options is refused |
-| `add <name> --service [--display-name N] [--description D] [--email E] [--redirect-uri U ...] [--post-logout-redirect-uri U ...] [--allowed-group G ...]` | Adds a service account, with its display name, description, e-mail address and OpenID Provider client settings when given; the names are refused |
+| `add <name> --service [--display-name N] [--description D] [--email E] [--redirect-uri U ...] [--post-logout-redirect-uri U ...] [--allowed-group G ...] [--grant G ...] [--public-client yes\|no] [--client-scope R:S ...] [--resource-scope S ...]` | Adds a service account, with its display name, description, e-mail address and OpenID Provider settings when given; the names are refused |
 | `update <name> [--first-name F] [--last-name L] [--email E]` | Changes the names or the e-mail address |
-| `update <name> [--display-name N] [--description D] [--email E] [--redirect-uri U ...] [--post-logout-redirect-uri U ...] [--allowed-group G ...]` | Changes the display name, the description, the e-mail address or the OpenID Provider client settings of a service account; `''` removes one; a repeated client option gives all values of its kind |
+| `update <name> [--display-name N] [--description D] [--email E] [--redirect-uri U ...] [--post-logout-redirect-uri U ...] [--allowed-group G ...] [--grant G ...] [--public-client yes\|no] [--client-scope R:S ...] [--resource-scope S ...]` | Changes the display name, the description, the e-mail address or the OpenID Provider settings of a service account; `''` removes one; a repeated option gives all values of its kind |
 | `passwd <name>` | Sets the password |
 | `disable <name>`, `enable <name>` | Locks the user out of OpenVPN and `/auth`, and lets the user in again |
 | `unlock <name>` | Ends a lockout after failed logins and clears the failure count; a disabled user stays disabled |
@@ -855,9 +857,10 @@ A disabled or locked user is refused a passkey sign-in too.
 `vpn-router-group` manages the groups. A group has a name, with the rules of a user name, an
 optional description of at most 256 printable characters, and at least one member, each a user
 of the directory. The group `admins` grants the management of the router, and the allowed groups
-of a client of the OpenID Provider admit their members to it; other groups record membership
-only. Renaming a group renames it in the clients that allow it, and a group a client allows
-cannot be removed. The output, `--json`, `-h` and `--help` work as for `vpn-router-user`.
+of a client of the OpenID Provider admit their members to it, and a role of a resource assigned to
+a group is a role of its members; other groups record membership only. Renaming a group renames it
+in the clients that allow it and in its roles, a group a client allows cannot be removed, and
+removing a group takes it out of its roles. The output, `--json`, `-h` and `--help` work as for `vpn-router-user`.
 
 ```sh
 vpn-router-group add ops --member alice --member bob --description 'Operations team'
@@ -1015,7 +1018,7 @@ curl http://10.0.0.4:7081/status
 
 ### Tokens and signing in
 
-`/config`, `/metrics/history`, `/metrics/settings`, `/users`, `/service-accounts`, `/groups`, `/site-to-site`, `/backup`, `/remote-access`, `/ca`, `/logs`, `/sites`, `/dns`, `/shell` and `/account` need a JWT in an `Authorization: Bearer` header, signed with
+`/config`, `/metrics/history`, `/metrics/settings`, `/https/settings`, `/users`, `/service-accounts`, `/groups`, `/site-to-site`, `/backup`, `/remote-access`, `/ca`, `/logs`, `/sites`, `/dns`, `/shell` and `/account` need a JWT in an `Authorization: Bearer` header, signed with
 HS256 by the key the web service makes on its first run, `/etc/vpn-router/web.key` (root only).
 The key never leaves the router; while it does not exist these paths and `/auth` are not served
 (404). A missing, expired or wrongly signed token, or one of another algorithm, gets 401 with
@@ -1080,8 +1083,9 @@ every service and tunnel while the public status page shows less.
 ### The shell
 
 While `web.shell` is `true`, `/shell` gives a member of `admins` whose console login is on and
-who is enrolled for TOTP (see Console login and SSH) a login shell on the router, as the user's console account, for the
-Router Manager's Shell page. It is off by default and switched on and off on the router only:
+who is enrolled for TOTP (see Console login and SSH) a login shell on the router, as the user's
+console account, for the Router Manager's Shell page. It is off by default and switched on and
+off on the router only:
 
 ```sh
 vpn-router-user console alice --posix
@@ -1090,20 +1094,29 @@ vpn-config-edit set web.shell true
 
 | Request | Body | Answer |
 | --- | --- | --- |
-| `POST /shell` | `{"password", "code"}`; `{}` within `web.shell_auth_timeout` | `{"ticket", "expires_in": 30}` |
+| `POST /shell/passkey` | `{}` | `{"id", "options"}`, `options` those of `navigator.credentials.get` for the user's own passkeys |
+| `POST /shell` | `{"password", "code"}`, or `{"passkey": {"id", "credential"}}`; `{}` within `web.shell_auth_timeout` | `{"ticket", "expires_in": 30}` |
 | `GET /shell?ticket=<ticket>` | a WebSocket handshake | the terminal |
 
 `POST /shell` needs an access token of `/auth`, not one of `vpn-router-token`, and signs its user
-in again: a wrong password or code gets 403 and counts as a failed login; it gets 403 too while
-`web.shell` is `false`, the user's console login is off or the user is not enrolled for TOTP. Without a password it gives a ticket
-while the user's last sign-in of `POST /shell` or keystroke in a shell is less than
-`web.shell_auth_timeout` minutes ago, and `{"ticket": null}` otherwise. The ticket opens one
+in again, with the password and the TOTP code, or with a passkey: `POST /shell/passkey` begins a
+proof for one of the user's own passkeys with user verification, which the browser answers within
+two minutes, and `POST /shell` takes its `id` and the browser's answer as `credential`. A passkey
+with user verification is two factors in one, so it takes the place of the password and the code.
+A wrong password or code gets 403 and counts as a failed login, and a passkey that is not accepted
+gets 403. `POST /shell` gets 403 too while `web.shell` is `false`, the user's console login is off
+or the user is not enrolled for TOTP: also with a passkey, the PAM login session of the shell,
+`pam_authz_search` of nslcd for a directory account, and sudo need the enrolment. Without a
+password or a passkey it gives a ticket while the user's last sign-in of
+`POST /shell` or keystroke in a shell is less than `web.shell_auth_timeout` minutes ago, and
+`{"ticket": null}` otherwise. The ticket opens one
 shell for the same user within 30 seconds. Over the WebSocket, binary messages of the client
 are keystrokes, a text message `{"cols", "rows"}` sets the window size, and binary messages of
 the router are the terminal's output. The shell is a PAM login session of the console account,
-run by `systemd-run` in a transient unit `vpn-router-shell-<id>`; sudo works as for SSH. It is closed after `web.shell_idle_minutes` without a keystroke, when the shell
-exits, when the connection closes, or within a minute of the user's console login being switched
-off or the TOTP enrolment removed; the router then sends a close frame with the reason. The
+run by `systemd-run` in a transient unit `vpn-router-shell-<id>`; sudo works as for SSH, with the
+password and the TOTP code. It is closed after `web.shell_idle_minutes` without a keystroke, when
+the shell exits, when the connection closes, or within a minute of the user's console login being
+switched off or the TOTP enrolment removed; the router then sends a close frame with the reason. The
 journal of `vpn-router-web` records who opened each shell, from which address, in which unit,
 when it ended and why, and each refused ticket or shell with the reason.
 
@@ -1148,6 +1161,7 @@ vre /etc/vpn-router/vpn-router.json ~/notes.txt
 | `docker` | `docker.exposed_ports` and the rules of the `VPN-ROUTER-DOCKER` chain |
 | `postgresql` | `clusters`: each PostgreSQL cluster of `pg_lsclusters` with its version, name, port, status and data directory, and for one that is online its `settings`: `server_version`, `listen_addresses`, `port`, `max_connections`, `shared_buffers`, `effective_cache_size`, `work_mem`, `password_encryption`, `ssl` and `timezone`; `null` when `pg_lsclusters` fails |
 | `caddy` | The installed Caddy: `version`, `source`, `upstream` once Caddy's repository is configured and `ubuntu` otherwise, and `service`, the state of `caddy.service`; `null` when Caddy is not installed |
+| `oidc` | The OpenID Provider: `enabled`, and `issuer`, its issuer URL, `null` while it is disabled |
 
 ### The /postgresql page
 
@@ -1212,13 +1226,11 @@ curl -X PUT -H "Authorization: Bearer $TOKEN" --data-binary @site.zip \
 
 | Request | Answer |
 | --- | --- |
-| `GET /dns` | `{"settings", "installed", "running", "domains", "problem"}`: the `dns` section, whether PowerDNS is installed and runs, the domains, each `{"name", "sites", "ttl", "secondaries", "manual", "records"}` with its secondaries `{"nameserver", "address"}`, its manual records and the records it serves, and why they cannot be read, `null` when they can |
-| `PUT /dns` | Changes any of the settings of the `dns` section |
-| `POST /dns/domains` | Adds a domain: `{"name", "sites"?, "ttl"?}`; an existing name is 409 |
-| `PUT /dns/domains/<domain>` | Changes `sites` or `ttl` of the domain |
-| `DELETE /dns/domains/<domain>` | Removes the domain with its secondaries and manual records |
-| `POST /dns/domains/<domain>/secondaries` | Adds a secondary name server, or changes its address: `{"nameserver", "address"}` |
-| `DELETE /dns/domains/<domain>/secondaries/<nameserver>` | Removes the secondary name server |
+| `GET /dns` | `{"settings", "nameserver", "public_address", "installed", "running", "domains", "problem"}`: the `dns` section, `wan.local_fqdn`, the primary name server, `wan.public_address`, whether PowerDNS is installed and runs, the domains, each `{"name", "ttl", "manual", "records"}` with its manual records and the records it serves, and why they cannot be read, `null` when they can |
+| `PUT /dns` | Changes any of the settings of the `dns` section, and with `public_address` `wan.public_address`; answers `{"settings", "public_address"}` |
+| `POST /dns/domains` | Adds a domain: `{"name", "ttl"?}`; an existing name is 409 |
+| `PUT /dns/domains/<domain>` | Changes `ttl` of the domain |
+| `DELETE /dns/domains/<domain>` | Removes the domain with its manual records |
 | `POST /dns/domains/<domain>/records` | Adds a manual record: `{"name", "type", "content", "ttl"?}`; `name` is relative to the domain, `@` for the domain itself, or absolute with a final dot, and `ttl` is the domain's without it |
 | `DELETE /dns/domains/<domain>/records?name=&type=&content=` | Removes the manual records of the name and type, only the one of `content` when it is given |
 
@@ -1268,22 +1280,33 @@ curl -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
 
 | Request | Body | Answer |
 | --- | --- | --- |
-| `GET /service-accounts` | | `{"service_accounts": [{"name", "display_name", "description", "internal", "enabled", "locked", "email", "redirect_uris", "post_logout_redirect_uris", "allowed_groups", ...}, ...], "oidc": {"enabled", "issuer"}}`, each as `/users` shows a user, and the issuer of the OpenID Provider, `null` while it is disabled |
-| `POST /service-accounts` | `{"name", "password", "display_name"?, "description"?, "email"?, "redirect_uris"?, "post_logout_redirect_uris"?, "allowed_groups"?}` | 201 and the account |
-| `PUT /service-accounts/<name>` | any of `{"display_name", "description", "email", "redirect_uris", "post_logout_redirect_uris", "allowed_groups"}`; `""` removes one of the first three, `[]` the values of the others | the account |
+| `GET /service-accounts` | | `{"service_accounts": [{"name", "display_name", "description", "internal", "enabled", "locked", "email", "redirect_uris", "post_logout_redirect_uris", "allowed_groups", "grants", "public_client", "client_scopes", "resource_scopes", "roles", ...}, ...], "oidc": {"enabled", "issuer"}}`, each as `/users` shows a user, and the issuer of the OpenID Provider, `null` while it is disabled |
+| `POST /service-accounts` | `{"name", "password", "display_name"?, "description"?, "email"?, "redirect_uris"?, "post_logout_redirect_uris"?, "allowed_groups"?, "grants"?, "public_client"?, "client_scopes"?, "resource_scopes"?, "roles"?}` | 201 and the account |
+| `PUT /service-accounts/<name>` | any of `{"display_name", "description", "email", "redirect_uris", "post_logout_redirect_uris", "allowed_groups", "grants", "public_client", "client_scopes", "resource_scopes", "roles"}`; `""` removes one of the first three, `[]` the values of the lists, `false` the public client | the account |
 | `PUT /service-accounts/<name>/password` | `{"password": ...}` | the account |
 | `POST /service-accounts/<name>/disable` | | the account |
 | `POST /service-accounts/<name>/enable` | | the account |
 | `POST /service-accounts/<name>/unlock` | | the account |
 | `DELETE /service-accounts/<name>` | | `{"name", "removed": true}` |
 
-A display name has at most 64 printable characters and a description at most 256. The client
-settings are lists of at most 16 values: URIs of `https`, or of `http` for `localhost`,
-`127.0.0.1` or `::1`, without a fragment and of at most 1024 characters, and names of existing
-groups (see OpenID Provider). The internal
-service accounts, `internal` true, are only listed: every other request on one gets 403, as the
-router manages them, their display name and description included. A failure is otherwise as for
-`/users`, with 404 also for a name that is not a service account.
+A display name has at most 64 printable characters and a description at most 256. The settings of
+the OpenID Provider (see OpenID Provider) are:
+
+- **URIs and allowed groups:** lists of at most 16 values: URIs of `https`, or of `http` for
+  `localhost`, `127.0.0.1` or `::1`, without a fragment and of at most 1024 characters, and names
+  of existing groups;
+- **`grants`:** `client_credentials` and `device_code`; `public_client`, `true` or `false`;
+- **`client_scopes`:** at most 16 scopes of resources, `<resource>:<scope>`;
+- **`resource_scopes`:** at most 16 scope names of lowercase letters, digits, dots, underscores and
+  hyphens;
+- **`roles`:** `[{"name", "description", "groups", "accounts"}]`, which replaces the account's roles:
+  role names of letters, digits, dots, underscores and hyphens, and existing groups and accounts.
+
+The internal service accounts, `internal` true, are only listed: every other request on one, and
+a role assigned to one, gets 403, as the router manages them, their display name and description
+included. A password change, disabling, unlocking and removing revoke the tokens the account was
+issued. A failure is otherwise as for `/users`, with 404 also for a name that is not a service
+account.
 
 ### The /account API
 
@@ -1380,6 +1403,18 @@ A change is made, checked and applied as for `/site-to-site`.
 
 A change is made, checked and applied as for `/site-to-site`.
 
+### The /https/settings API
+
+`/https/settings` shows the settings of HTTPS and changes the CA of Caddy's certificates, with the
+same token as `/users`.
+
+| Request | Body | Answer |
+| --- | --- | --- |
+| `GET /https/settings` | | `{"settings"}`: the `https` section |
+| `PUT /https/settings` | `{"acme_staging"}`; any other setting of the `https` section is 400, as it is changed on the router with `vpn-config-edit` | `{"settings"}` |
+
+A change is made, checked and applied as for `/site-to-site`.
+
 ### The /remote-access API
 
 `/remote-access` shows and changes the remote access systems, IKEv2 (`p2s`),
@@ -1447,7 +1482,20 @@ while metrics are enabled the metrics service on `metrics.https_port` (9465), al
 and renews the certificate from Let's Encrypt with the HTTP challenge, so `wan.local_fqdn` must
 resolve to the router's public address and port 80 must be reachable from the internet; the
 certificate and the ACME account are kept in `/var/lib/caddy`. Port 80 answers the challenge only;
-it does not redirect to HTTPS.
+it does not redirect to HTTPS. Caddy's default CAs are Let's Encrypt and ZeroSSL, which it takes
+when Let's Encrypt refuses, such as for its rate limit of 5 certificates a week for the same name.
+
+While `https.acme_staging` is `true`, Caddy's only CA is Let's Encrypt's staging environment, for
+routers that are rebuilt often. Its rate limits are far higher, but no browser or client trusts
+its certificates, so they are for tests only. The setting applies to every certificate Caddy
+obtains from an ACME CA, those of the web sites with `tls` `acme` included.
+
+```sh
+vpn-config-edit set --restart https.acme_staging true
+```
+
+The Router Manager switches it on the Overview, and `PUT /https/settings` changes it (see The
+/https/settings API).
 
 `vpn-router-setup` writes Caddy's configuration to `/etc/caddy/vpn-router.Caddyfile` (root, group
 `caddy`, the group Caddy runs as, mode 0640), which the
@@ -1511,22 +1559,33 @@ curl https://router.example.com:7444/.well-known/openid-configuration
 | Endpoint | Purpose |
 | --- | --- |
 | `GET /.well-known/openid-configuration` | The discovery document |
-| `GET /oidc/jwks` | The public key ID tokens are signed with |
+| `GET /oidc/jwks` | The public key ID tokens and access tokens are signed with |
 | `GET`, `POST /oidc/authorize` | The authorization code flow; the sign-in page while the browser has no session |
-| `POST /oidc/token` | Exchanges a code or a refresh token for tokens |
+| `POST /oidc/token` | Exchanges a code, a refresh token, a device code or a client's credentials for tokens |
+| `POST /oidc/device_authorization` | Begins the device authorization grant: a device code and a user code |
+| `GET`, `POST /oidc/device` | The page where a user enters a device's user code, signs in and allows the device |
 | `GET`, `POST /oidc/userinfo` | The claims of the user of an access token |
 | `GET /oidc/logout` | Ends the session (RP-initiated logout) |
 
-A client is a service account with at least one redirect URI: its name is the `client_id` and its
+**Clients**
+
+A client is a service account with a redirect URI or a grant. Its name is the `client_id` and its
 password the `client_secret`, sent with HTTP Basic authentication (`client_secret_basic`) or in
 the body of the token request (`client_secret_post`). The password is checked with a bind, so 5
-wrong secrets lock the client for 15 minutes. Its settings are:
+wrong secrets lock the client for 15 minutes. A public client sends only its `client_id` (`none`).
+Its settings are:
 
-- redirect URIs, where the provider sends the browser back with a code, matched exactly; a URI
-  uses `https`, or `http` for `localhost`, `127.0.0.1` or `::1`;
-- post-logout redirect URIs, where `/oidc/logout` may send the browser afterwards;
-- allowed groups: only their members may sign in to the client; without any, every user who is
-  not a service account may.
+- **redirect URIs:** where the provider sends the browser back with a code; they give the client
+  the authorization code grant. A URI uses `https`, or `http` for `localhost`, `127.0.0.1` or
+  `::1`, and is matched exactly, but the port of an `http` one, which a native program chooses
+  when it starts (RFC 8252);
+- **post-logout redirect URIs:** where `/oidc/logout` may send the browser afterwards;
+- **allowed groups:** only their members may sign in to the client; without any, every user who
+  is not a service account may;
+- **grants:** `client_credentials` and `device_code`, besides the authorization code;
+- **public client:** the client has no secret, as a native program or a CLI, which cannot keep
+  one; it cannot have `client_credentials`;
+- **client scopes:** the scopes of resources the client may ask for, `<resource>:<scope>`.
 
 ```sh
 echo 'cl1ent-s3cret' | vpn-router-user add 3f2b8c1e-9a4d-4e6f-8b2a-1c5d7e9f0a3b --service \
@@ -1535,34 +1594,131 @@ echo 'cl1ent-s3cret' | vpn-router-user add 3f2b8c1e-9a4d-4e6f-8b2a-1c5d7e9f0a3b
 vpn-router-user update 3f2b8c1e-9a4d-4e6f-8b2a-1c5d7e9f0a3b --allowed-group ''
 ```
 
-The flow is the authorization code flow with PKCE, whose `code_challenge_method` must be `S256`;
-the implicit and hybrid flows, and the password and client credentials grants, are refused. A
-registered client is trusted, so a user is not asked for consent. A user signs in on the
-provider's page with the name, the password and, when enrolled, the TOTP code, or with a passkey
-(see Passkeys); failed sign-ins count towards the lockout, and `POST /oidc/login` takes at most
-10 calls a minute from one client address, as `/auth` does. A
-disabled, locked or removed user, a service account, and a user outside the client's allowed
-groups cannot sign in, and the codes and tokens already issued to such a user stop working. The
-sign-in starts a session, a cookie of the issuer's `/oidc/` path valid for 8 hours, so later
-requests of any client go on without the page; `prompt=login` and `max_age` ask for a new sign-in,
-and `prompt=none` answers `login_required` without a session.
+**Grants**
+
+| Grant | Who signs in | Tokens |
+| --- | --- | --- |
+| `authorization_code` | A user, in the browser, with PKCE (`S256`) | Access, refresh and ID token |
+| `urn:ietf:params:oauth:grant-type:device_code` | A user, on another device | Access, refresh and ID token |
+| `client_credentials` | The service account itself, with its secret | Access token |
+| `refresh_token` | | A new access and refresh token |
+
+The implicit and hybrid flows, the password grant and dynamic registration are refused. A
+registered client is trusted, so a user is not asked for consent, except for a device.
+
+**Signing in**
+
+- **The page:** a user signs in on the provider's page with the name, the password and, when
+  enrolled, the TOTP code, or with a passkey (see Passkeys).
+- **Lockout and rate limit:** failed sign-ins count towards the lockout. `POST /oidc/login`,
+  `/oidc/device` and `/oidc/device_authorization` take at most 10 calls a minute from one client
+  address, as `/auth` does.
+- **Who may not sign in:** a disabled, locked or removed user, a service account, and a user
+  outside the client's allowed groups. The codes and tokens already issued to such a user stop
+  working.
+- **The session:** the sign-in starts a cookie of the issuer's `/oidc/` path, valid for 8 hours,
+  so later requests of any client go on without the page. `prompt=login` and `max_age` ask for a
+  new sign-in, and `prompt=none` answers `login_required` without a session.
+
+**Device authorization (RFC 8628)**
+
+A client with `device_code`, such as a CLI on a host without a browser, signs a user in like this:
+
+1. It posts `client_id` (and its secret, unless it is public), `scope` and optionally `resource` to
+   `/oidc/device_authorization`. The answer holds `device_code`, `user_code` (8 letters, shown as
+   `XXXX-XXXX`), `verification_uri`, `verification_uri_complete`, `expires_in` (600 seconds) and
+   `interval` (5 seconds).
+2. It shows the user the code and the URI, then polls `/oidc/token` with
+   `grant_type=urn:ietf:params:oauth:grant-type:device_code` and `device_code`. Until the user
+   decides, the answer is `authorization_pending`; a poll sooner than the interval answers
+   `slow_down` and adds 5 seconds to it.
+3. The user opens the URI on any device, enters the code, signs in, and allows or denies the
+   client, the resource and the scopes shown. The next poll answers the tokens, or
+   `access_denied`; an expired code answers `expired_token`.
+
+```sh
+curl -d client_id=backup-cli -d 'scope=openid profile' \
+    https://router.example.com:7444/oidc/device_authorization
+```
+
+**Client credentials**
+
+A confidential client with `client_credentials` gets an access token as its own service account,
+without a user. The scopes are those of a resource, and the profile scopes give the service
+account's claims; `openid` is refused, and no refresh token is issued.
+
+```sh
+curl -u backup-job:'j0b-s3cret' -d grant_type=client_credentials -d resource=s3 -d scope=s3:read \
+    https://router.example.com:7444/oidc/token
+```
+
+**Resources, roles and scopes**
+
+Every service account is also a resource, an application that checks the router's tokens, as an
+API registration of Entra ID:
+
+- **Scopes:** the resource scopes the account defines, such as `read`, which clients ask for as
+  `<resource>:<scope>` (`s3:read`) when their client scopes allow them.
+- **Roles:** named roles, such as `Reader`, each assigned to groups, users and service accounts;
+  `vpn-router-role` manages them.
+
+```sh
+echo 's3-s3cret' | vpn-router-user add s3 --service --resource-scope read --resource-scope write
+vpn-router-role add s3 Reader --description 'Reads every bucket'
+vpn-router-role member-add s3 Reader --group backup
+vpn-router-user update backup-job --grant client_credentials --client-scope s3:read
+```
+
+A request is for a resource when it names it with `resource` (RFC 8707), its name or
+`<issuer>/<name>`, or asks for its scopes; more than one resource, or one that is not a
+resource, is `invalid_target`. A scope the client may not ask for is `invalid_scope`. Without a
+resource, the tokens are for the client itself. The resource is kept with the code, the device code
+and the refresh token, and a token request naming another one is `invalid_target`.
+
+| Command | What it does |
+| --- | --- |
+| `vpn-router-role list [<resource>]` | The roles with the groups and accounts they are assigned to |
+| `vpn-router-role add <resource> <role> [--description D]` | Add a role |
+| `vpn-router-role remove <resource> <role>` | Remove a role |
+| `vpn-router-role member-add <resource> <role> --group G\|--account A` | Assign the role |
+| `vpn-router-role member-remove <resource> <role> --group G\|--account A` | Take the role away |
+
+A scope a client may ask for cannot be removed from its resource, nor the resource while a client
+may ask for its scopes. Removing a service account removes its roles and takes it out of the
+others; removing or renaming a group does the same in the roles.
+
+**Tokens**
 
 | Scope | Claims |
 | --- | --- |
-| `openid` (required) | `sub`, the `entryUUID` of the user's entry |
+| `openid` (required but by `client_credentials`, which refuses it) | `sub`, the `entryUUID` of the user's entry |
 | `profile` | `preferred_username` (the user name), `name`, `given_name`, `family_name` |
 | `email` | `email` |
 | `groups` | `groups`, the names of the user's groups |
+| `<resource>:<scope>` | None; the scope is in the access token's `scope` |
 
-The claims of the scopes granted are in the ID token and in the answer of `/oidc/userinfo`. ID
-tokens are RS256 JWTs, valid for 5 minutes, with `auth_time` and `amr` (`pwd`, `pwd` and `otp`, or
-`hwk` and `user` for a passkey), signed with an RSA key of 3072 bits that the web service makes on
-its first run, `/etc/vpn-router/oidc.key` (root only), and named in the JWKS by its RFC 7638
-thumbprint. A code is valid for 1 minute and used once, an access token for 5 minutes, and a
-refresh token for 8 hours and used once: each refresh answers a new one with a new ID token. The
-codes, tokens and sessions are kept, as their SHA-256, in the database of the refresh tokens of
-`/auth`. Changing a user's password, disabling, unlocking or removing the user ends its sessions
-and revokes its codes and tokens.
+- **ID tokens:** RS256 JWTs for the client (`aud`), valid for 5 minutes, with the claims of the
+  scopes, `auth_time`, `amr` (`pwd`, `pwd` and `otp`, or `hwk` and `user` for a passkey), and
+  `roles`, the user's roles of the client itself. `/oidc/userinfo` answers the same claims.
+- **Access tokens:** RS256 JWTs of RFC 9068 (`typ` `at+jwt`), valid for 5 minutes, which a
+  resource verifies with the JWKS. Their claims:
+  - `iss`, `sub`, `iat`, `exp` and `jti`;
+  - `aud`, the resource, or the client without one, and `client_id`, the client;
+  - `scope`, the scopes granted;
+  - `roles`, the roles of the resource the user or the service account holds, directly or by a
+    group;
+  - the claims of the scopes, and of a user `auth_time` and `amr`.
+- **Roles are read at every issue,** refresh included, so a role taken away is gone from the next
+  token.
+- **The key:** tokens are signed with an RSA key of 3072 bits that the web service makes on its
+  first run, `/etc/vpn-router/oidc.key` (root only), and named in the JWKS by its RFC 7638
+  thumbprint.
+- **Lifetimes:** a code is valid for 1 minute and used once, a device code for 10 minutes, and a
+  refresh token for 8 hours and used once: each refresh answers a new one.
+- **Storage and revocation:** the codes, device codes, tokens and sessions are kept, as their
+  SHA-256, in the database of the refresh tokens of `/auth`. Changing the password of a user or a
+  service account, disabling, unlocking or removing it ends its sessions and revokes its codes and
+  tokens.
 
 ## Web sites
 
@@ -1583,10 +1739,15 @@ Router Manager, each change applied by restarting `vpn-router-setup`. A site has
 | `index_file` | The file served for a folder, `index.html` by default |
 | `spa` | Whether a path without a file is served the site's `index_file`, for single-page applications |
 | `editors` | The group whose members may change the site's files besides the admins |
+| `dns` | Who serves the records of its host names: `user` (the default), a DNS provider outside the router, or `router`, the router's name server (see Name server) |
+| `dns_address` | With `dns` `router`, the router's address in the records: `public` (the default, `wan.public_address`), `internal` or `external` |
 
 A site may not take a port of the router's own services (SSH, `web.port`, the HTTPS ports, the
 metrics ports, the Router Manager's, `sites.webdav_port`, 7446, 53, the bootstrap ports, a TCP
-`openvpn.port` and `docker.exposed_ports`) or `wan.local_fqdn`. Enabled sites on one port need host
+`openvpn.port` and `docker.exposed_ports`). It may use `wan.local_fqdn` as a host name, on a port
+of its own, such as 443, which the router's services leave free; its record is then kept where the
+domain of `wan.local_fqdn` is, so `dns` `router` takes neither it, nor wildcards or addresses, and
+`public` needs `wan.public_address`. Enabled sites on one port need host
 names of their own, the same `listen` and the same kind of TLS (plain HTTP or HTTPS). A site of
 `acme` needs host names, without wildcards or addresses, that resolve to the router, and port 80,
 which setup opens on the external interface. The certificate of `file` must be the key's and name
@@ -1645,32 +1806,43 @@ missing, without the recommended bind backend.
 
 | Setting | Meaning |
 | --- | --- |
-| `dns.nameserver` | The name server's host name, the primary NS and the SOA's primary of every domain |
-| `dns.addresses` | The public addresses of the domains' apexes, of the name server in a domain it is inside, and of the sites' host names |
+| `wan.local_fqdn` | The primary name server of every domain: the SOA's primary and the first NS |
+| `dns.secondary` | The secondary name server of every domain, the second NS; the addresses it resolves to are notified of every change and may transfer the domains (AXFR) |
 | `dns.ttl` | The TTL of the records and the SOA's negative TTL of a domain without its own, 60 to 86400 seconds, 300 by default |
 
+A domain the router hosts, for example `example.com`, with `wan.local_fqdn` `router.other.net`,
+`dns.secondary` `ns2.provider.net` and a site of `www.example.com` and `example.com` with `dns`
+`router` and `dns_address` `public` (`wan.public_address` `203.0.113.10`):
+
+```text
+example.com.      SOA  router.other.net. hostmaster.example.com. <serial> 10800 3600 604800 300
+example.com.      NS   router.other.net.
+example.com.      NS   ns2.provider.net.
+example.com.      A    203.0.113.10
+www.example.com.  A    203.0.113.10
+```
+
 The domains are added with `/dns` or the Router Manager, each with:
 
-- **Site records**: every host name of an enabled site gets A and AAAA records of `dns.addresses`
-  in the closest domain it is in, when that domain has site records;
 - **TTL**: the TTL of its records, `dns.ttl` when not set;
-- **Secondaries**: name servers, each a host name, which becomes an NS of the domain, and the
-  address it transfers the domain from. The router notifies that address of every change and
-  allows it zone transfers (AXFR); a secondary's name inside the domain gets an A or AAAA record of
-  that address;
 - **Manual records** (A, AAAA, CNAME, TXT, MX, SRV, CAA), served too, but not those of a name and
   type the domain's own records have.
 
-A domain inside another domain of the router is delegated from it with NS records. Setup writes the
-domains at each run, and after each change through `/dns`; the SOA's serial grows only when the
-records change. While IKEv2, OpenVPN or WireGuard is enabled, dnsmasq answers their clients on port 53
-of the addresses of `p2s.dns_listen`, by default the internal address, so `dns.listen` must not
-share an interface with it. The parent zone of each domain must delegate it to `dns.nameserver` and
-the secondaries, with glue records for name servers inside the domain.
+The host names of an enabled site with `dns` `router` get an A or AAAA record of its `dns_address`
+in the closest domain they are in; a site with `dns` `user` gets none, and a host name in no domain
+of the router gets none either. `wan.local_fqdn` gets no record in the domains: its A record is kept
+by the DNS of its own domain, wherever that is. A domain inside another domain of the router is
+delegated from it with NS records. Setup writes the domains at each run, and after each change
+through `/dns`; the SOA's serial grows only when the records change. While IKEv2, OpenVPN or
+WireGuard is enabled, dnsmasq answers their clients on port 53 of the addresses of
+`p2s.dns_listen`, by default the internal address, so `dns.listen` must not share an interface with
+it. The parent zone of each domain must delegate it to `wan.local_fqdn` and `dns.secondary`, with
+glue records for those of them inside the domain. While `dns.secondary` is not set, the domains have
+`wan.local_fqdn` as their only name server, and setup warns.
 
 ```sh
-vpn-config-edit set dns.nameserver ns1.example.com
-vpn-config-edit set dns.addresses 203.0.113.10
+vpn-config-edit set dns.secondary ns2.provider.net
+vpn-config-edit set wan.public_address 203.0.113.10
 vpn-config-edit set --restart dns.enabled true
 ```
 
@@ -1919,4 +2091,6 @@ cd debian-package
 ```
 
 The build runs in a container and writes the package to `debian-package/out/`.
-`./publish.sh` uploads it to the configured repository.
+`./publish.sh` uploads it to the component `main` of the distributions `noble` and `resolute` of
+the configured repository, skipping a distribution that has the version already;
+`DISTRIBUTIONS` names others.

debian-package/debian/changelog

@@ -1,6 +1,178 @@
+vpn-router (0.39.1-1) unstable; urgency=medium
+
+  fix: the web service starts again after its first start with 0.39.0, and the
+  name server's domains can be changed from any process.
+
+  * The schemas of the web sites and of the name server can be applied any
+    number of times, so the web service no longer keeps retrying with
+    'function "site_put" already exists' and never listening, and
+    vpn-router-site and setup no longer fail the same way.
+
+ -- Slawomir Koszewski <slawek@koszewscy.waw.pl>  Fri, 06 Nov 2026 20:16:57 +0100
+
+vpn-router (0.39.0-2) unstable; urgency=medium
+
+  update: vpn-router is published in the koszewscy package registry.
+
+  * publish.sh uploads to the owner koszewscy unless OWNER names another.
+  * repo_url of the Azure and GCP examples defaults to
+    https://gitea.koszewscy.waw.pl/api/packages/koszewscy/debian.
+
+ -- Slawomir Koszewski <slawek@koszewscy.waw.pl>  Fri, 06 Nov 2026 20:08:29 +0100
+
+vpn-router (0.39.0-1) unstable; urgency=medium
+
+  feature: the name server's domains have wan.local_fqdn and dns.secondary as
+  their name servers, and a site with dns router gets records of the router's
+  public, internal or external address.
+
+  * The SOA and the first NS of every domain are wan.local_fqdn, and the
+    second NS is dns.secondary, a host name, whose addresses are notified
+    of every change and may transfer the domains; dns.nameserver is gone.
+  * wan.local_fqdn gets no record in the domains; its record is kept in
+    the DNS of its own domain.
+  * A site has dns, user (the default), served elsewhere, or router, whose
+    host names get an A or AAAA record in their closest domain, with
+    dns_address public (wan.public_address, new), internal or external.
+    dns.addresses, the domains' site records switch and the per-domain
+    secondaries with their routes are gone; dns.nameserver and
+    dns.addresses of an earlier configuration are left out when read.
+  * A site may use wan.local_fqdn as a host name on a port of its own.
+  * GET /dns answers nameserver, wan.local_fqdn, and public_address,
+    which PUT /dns changes.
+  * The summaries of the changelog entries are wrapped at 80 columns, and
+    release.py joins the lines of a summary into the commit message.
+
+ -- Slawomir Koszewski <slawek@koszewscy.waw.pl>  Fri, 30 Oct 2026 21:30:01 +0100
+
+vpn-router (0.38.1-1) unstable; urgency=medium
+
+  fix: /https/settings shows the https section and switches https.acme_staging,
+  for the Router Manager.
+
+  * GET /https/settings shows the https section, and PUT /https/settings
+    changes acme_staging; the other settings of the section stay with
+    vpn-config-edit.
+
+ -- Slawomir Koszewski <slawek@koszewscy.waw.pl>  Fri, 30 Oct 2026 02:43:22 +0100
+
+vpn-router (0.38.0-1) unstable; urgency=medium
+
+  feature: https.acme_staging takes Caddy's certificates from Let's Encrypt's
+  staging environment.
+
+  * While https.acme_staging is true, Caddy's only CA is Let's Encrypt's
+    staging environment, for the router's services and the web sites
+    with tls acme; its certificates are not trusted by browsers.
+
+ -- Slawomir Koszewski <slawek@koszewscy.waw.pl>  Fri, 30 Oct 2026 02:34:01 +0100
+
+vpn-router (0.37.3-1) unstable; urgency=medium
+
+  fix: an answer whose client went away ends quietly, and a shell whose client
+  left before it opened is stopped.
+
+  * The web service, the metrics service and the bootstrap server stop
+    writing an answer when its client closes the connection, and a site
+    file whose download is left no longer gets a second answer.
+  * A shell whose client closed the connection before it opened is
+    stopped and its end is logged, instead of running on.
+
+ -- Slawomir Koszewski <slawek@koszewscy.waw.pl>  Fri, 30 Oct 2026 02:03:26 +0100
+
+vpn-router (0.37.2-1) unstable; urgency=medium
+
+  fix: the web service, the metrics service and the bootstrap server log a
+  failure in one line instead of a traceback, and nothing when a client goes
+  away.
+
+  * A request whose client closed the connection is no longer logged.
+  * Any other failure of a request, a thread or the service is logged in
+    one line with the exception's type and message.
+
+ -- Slawomir Koszewski <slawek@koszewscy.waw.pl>  Fri, 30 Oct 2026 01:59:19 +0100
+
+vpn-router (0.37.1-1) unstable; urgency=medium
+
+  fix: /config answers the OpenID Provider's state and issuer.
+
+  * /config has oidc: enabled, and issuer, the issuer URL, null while the
+    provider is disabled.
+
+ -- Slawomir Koszewski <slawek@koszewscy.waw.pl>  Fri, 30 Oct 2026 01:53:55 +0100
+
+vpn-router (0.37.0-1) unstable; urgency=medium
+
+  feature: the OpenID Provider has the client credentials and device
+  authorization grants, public clients, and service accounts as resources with
+  roles and scopes in JWT access tokens.
+
+  * A client may have the grants client_credentials, by which a
+    confidential client gets an access token as its own service account,
+    and the device code (RFC 8628): POST /oidc/device_authorization gives
+    a device code and a user code, the user enters the code on
+    /oidc/device, signs in and allows or denies the device, and the device
+    polls /oidc/token. A public client has no secret.
+  * An http loopback redirect URI matches with any port.
+  * Every service account is a resource: it defines scopes, which clients
+    ask for as <resource>:<scope> when their client scopes allow them, and
+    roles, assigned to groups, users and service accounts. A token request
+    names its resource with resource (RFC 8707) or by its scopes.
+  * Access tokens are RS256 JWTs of RFC 9068 for the resource, or the
+    client, with client_id, scope, roles and the claims of the scopes; ID
+    tokens and /oidc/userinfo carry the user's roles of the client.
+  * vpn-router-user takes --grant, --public-client, --client-scope and
+    --resource-scope; the new vpn-router-role manages the roles; and
+    /service-accounts takes and answers grants, public_client,
+    client_scopes, resource_scopes and roles.
+  * Changing the password of a service account, disabling, unlocking or
+    removing it through /service-accounts revokes its tokens.
+  * POST /oidc/device and /oidc/device_authorization are rate limited as
+    /oidc/login is.
+
+ -- Slawomir Koszewski <slawek@koszewscy.waw.pl>  Fri, 30 Oct 2026 00:57:11 +0100
+
+vpn-router (0.36.0-1) unstable; urgency=medium
+
+  feature: a shell opens with one of the user's passkeys in place of the
+  password and the TOTP code.
+
+  * POST /shell/passkey begins a proof for one of the signed-in user's own
+    passkeys, with user verification; POST /shell takes the browser's
+    answer as {"passkey": {"id", "credential"}} in place of the password
+    and the code, and gives the ticket of the shell.
+  * A passkey that is not accepted is refused with 403. The shell still
+    needs the user's TOTP enrolment, which its login session and sudo in
+    it need.
+
+ -- Slawomir Koszewski <slawek@koszewscy.waw.pl>  Thu, 29 Oct 2026 23:09:43 +0100
+
+vpn-router (0.35.2-2) unstable; urgency=medium
+
+  update: the package is published for Ubuntu 26.04 (resolute) as well as 24.04
+  (noble).
+
+  * publish.sh uploads the package to the distributions noble and resolute
+    of the repository, component main, skipping a distribution that has
+    the version already; DISTRIBUTIONS names others. A router on Ubuntu
+    26.04 installs vpn-router from the distribution resolute.
+
+ -- Slawomir Koszewski <slawek@koszewscy.waw.pl>  Thu, 29 Oct 2026 21:41:32 +0100
+
+vpn-router (0.35.2-1) unstable; urgency=medium
+
+  fix: the web service answers /, /status and /status/full again while IKEv2
+  runs.
+
+  * The status of IKEv2 clients is collected again; the requests that
+    collect the status were dropped with a NameError since 0.35.1.
+
+ -- Slawomir Koszewski <slawek@koszewscy.waw.pl>  Thu, 29 Oct 2026 19:03:16 +0100
+
 vpn-router (0.35.1-1) unstable; urgency=medium
 
-  update: the router web service is split into the package vpnrouter_web, with one module per family of paths.
+  update: the router web service is split into the package vpnrouter_web, with
+  one module per family of paths.
 
   * /usr/lib/vpn-router/web initializes and serves; the package
     /usr/lib/vpn-router/vpnrouter_web/ answers the requests, with a module
@@ -12,7 +184,8 @@ vpn-router (0.35.1-1) unstable; urgency=medium
 
 vpn-router (0.35.0-1) unstable; urgency=medium
 
-  feature: vre opens files from the Router Manager's shell in the editor of its Shell page.
+  feature: vre opens files from the Router Manager's shell in the editor of its
+  Shell page.
 
   * vpn-router-editor FILE..., or vre, in the shell of the Router Manager
     opens the files in the editor of the Shell page and returns at once;
@@ -27,7 +200,9 @@ vpn-router (0.35.0-1) unstable; urgency=medium
 
 vpn-router (0.34.0-1) unstable; urgency=medium
 
-  feature: the web service shows and changes the settings of the metrics service at /metrics/settings, and OpenVPN starts on a new router, as setup installs CRLs that revoke nothing.
+  feature: the web service shows and changes the settings of the metrics service
+  at /metrics/settings, and OpenVPN starts on a new router, as setup installs
+  CRLs that revoke nothing.
 
   * GET and PUT /metrics/settings show and change the metrics section;
     otlp_password is never shown, an empty one keeps it, and an empty
@@ -60,7 +235,8 @@ vpn-router (0.33.2-1) unstable; urgency=medium
 
 vpn-router (0.33.1-1) unstable; urgency=medium
 
-  fix: the name server is the primary of any number of domains, each with secondary name servers and a switch for the records of the sites.
+  fix: the name server is the primary of any number of domains, each with
+  secondary name servers and a switch for the records of the sites.
 
   * The domains, their secondaries and manual records are kept in the
     vpn-router-dns database and changed through /dns/domains; dns.zone is
@@ -78,7 +254,8 @@ vpn-router (0.33.1-1) unstable; urgency=medium
 
 vpn-router (0.33.0-1) unstable; urgency=medium
 
-  feature: road-warrior clients resolve the domains of the new setting p2s.dns_domains with the router's resolver.
+  feature: road-warrior clients resolve the domains of the new setting
+  p2s.dns_domains with the router's resolver.
 
   * p2s.dns_domains lists up to 16 domains; setup pushes them to IKEv2
     clients as INTERNAL_DNS_DOMAIN (RFC 8598, attribute 25) of the
@@ -90,7 +267,8 @@ vpn-router (0.33.0-1) unstable; urgency=medium
 
 vpn-router (0.32.1-1) unstable; urgency=medium
 
-  fix: a VPN user downloads the own OpenVPN client profile through /account, with the current password and code.
+  fix: a VPN user downloads the own OpenVPN client profile through /account,
+  with the current password and code.
 
   * POST /account/profile answers the user's OpenVPN client profile; it
     needs the current password and, when enrolled, a code.
@@ -99,7 +277,8 @@ vpn-router (0.32.1-1) unstable; urgency=medium
 
 vpn-router (0.32.0-1) unstable; urgency=medium
 
-  feature: the web service gives Apple VPN profiles that set up IKEv2 road-warrior access on macOS, iOS and iPadOS.
+  feature: the web service gives Apple VPN profiles that set up IKEv2
+  road-warrior access on macOS, iOS and iPadOS.
 
   * POST /users/<name>/apple-profile and POST /account/apple-profile answer
     an unsigned .mobileconfig with the P2S CA and the root CA, the user's
@@ -113,7 +292,9 @@ vpn-router (0.32.0-1) unstable; urgency=medium
 
 vpn-router (0.31.3-1) unstable; urgency=medium
 
-  fix: WireGuard clients may use the router's DNS resolver, which runs while WireGuard does, and /remote-access names its addresses for their configuration.
+  fix: WireGuard clients may use the router's DNS resolver, which runs while
+  WireGuard does, and /remote-access names its addresses for their
+  configuration.
 
   * The firewall opens port 53 of the remote access clients' resolver for
     the WireGuard network, as it does for the IKEv2 and OpenVPN pools.
@@ -127,7 +308,8 @@ vpn-router (0.31.3-1) unstable; urgency=medium
 
 vpn-router (0.31.2-1) unstable; urgency=medium
 
-  fix: dnsmasq answers the remote access clients' DNS queries, so they no longer get the router's own host name with all its addresses from systemd-resolved.
+  fix: dnsmasq answers the remote access clients' DNS queries, so they no longer
+  get the router's own host name with all its addresses from systemd-resolved.
 
   * vpn-router-resolver.service runs dnsmasq on the addresses of
     p2s.dns_listen, forwarding to systemd-resolved's stub on 127.0.0.53;
@@ -142,7 +324,9 @@ vpn-router (0.31.2-1) unstable; urgency=medium
 
 vpn-router (0.31.1-1) unstable; urgency=medium
 
-  fix: the remote access clients' resolver answers on the internal address by default, chosen by p2s.dns_listen, so the name server can take port 53 of the external addresses.
+  fix: the remote access clients' resolver answers on the internal address by
+  default, chosen by p2s.dns_listen, so the name server can take port 53 of the
+  external addresses.
 
   * The new setting p2s.dns_listen chooses the addresses of the resolver the
     road-warrior and OpenVPN clients are given: internal, the default,
@@ -155,7 +339,9 @@ vpn-router (0.31.1-1) unstable; urgency=medium
 
 vpn-router (0.31.0-1) unstable; urgency=medium
 
-  feature: Caddy serves static web sites from folders on the router, defined in their own database, with files uploaded through the web service or WebDAV, and an optional PowerDNS name server answers for a zone of the sites.
+  feature: Caddy serves static web sites from folders on the router, defined in
+  their own database, with files uploaded through the web service or WebDAV, and
+  an optional PowerDNS name server answers for a zone of the sites.
 
   * The new database vpn-router-sites holds the web sites: host names,
     port, interfaces, TLS (none, Let's Encrypt, an issuing CA or a
@@ -191,7 +377,8 @@ vpn-router (0.31.0-1) unstable; urgency=medium
 
 vpn-router (0.30.0-1) unstable; urgency=medium
 
-  feature: the web service serves the last lines of the journal of the router's units and of the log files web.log_files lists, at /logs.
+  feature: the web service serves the last lines of the journal of the router's
+  units and of the log files web.log_files lists, at /logs.
 
   * GET /logs lists the units whose journal and the files whose lines it
     serves; GET /logs/journal?unit=&lines= and /logs/file?path=&lines=
@@ -204,7 +391,8 @@ vpn-router (0.30.0-1) unstable; urgency=medium
 
 vpn-router (0.29.0-1) unstable; urgency=medium
 
-  feature: vpn-config-edit set and remove take --restart, which applies the change with vpn-router-setup and waits for it.
+  feature: vpn-config-edit set and remove take --restart, which applies the
+  change with vpn-router-setup and waits for it.
 
   * vpn-config-edit set --restart and remove --restart restart
     vpn-router-setup after writing the configuration and wait until it has
@@ -215,7 +403,8 @@ vpn-router (0.29.0-1) unstable; urgency=medium
 
 vpn-router (0.28.0-1) unstable; urgency=medium
 
-  feature: bash completes the vpn-* commands, their options and the names they take.
+  feature: bash completes the vpn-* commands, their options and the names they
+  take.
 
   * Bash completes the commands, options and arguments of vpn-router-user,
     vpn-router-group, vpn-router-token, vpn-config-edit, vpn-router-backup,
@@ -228,7 +417,9 @@ vpn-router (0.28.0-1) unstable; urgency=medium
 
 vpn-router (0.27.0-1) unstable; urgency=medium
 
-  feature: the web service is an OpenID Provider, which signs the directory's users in to other systems, the clients being service accounts with redirect URIs.
+  feature: the web service is an OpenID Provider, which signs the directory's
+  users in to other systems, the clients being service accounts with redirect
+  URIs.
 
   * oidc.enabled turns on the OpenID Provider at the issuer
     https://<wan.local_fqdn>:<https.web_port>, with discovery, JWKS,
@@ -257,7 +448,8 @@ vpn-router (0.27.0-1) unstable; urgency=medium
 
 vpn-router (0.26.2-1) unstable; urgency=medium
 
-  fix: a service account may be named by a GUID in lowercase, as the Router Manager proposes for a new one.
+  fix: a service account may be named by a GUID in lowercase, as the Router
+  Manager proposes for a new one.
 
   * vpn-router-user add --service and POST /service-accounts take a GUID
     in lowercase as the name, besides a user name; users and groups keep
@@ -267,7 +459,8 @@ vpn-router (0.26.2-1) unstable; urgency=medium
 
 vpn-router (0.26.1-1) unstable; urgency=medium
 
-  fix: the package installs vpnrouter_passkeys, without which the web service and vpn-router-user do not start.
+  fix: the package installs vpnrouter_passkeys, without which the web service
+  and vpn-router-user do not start.
 
   * /usr/lib/vpn-router/vpnrouter_passkeys.py is part of the package.
 
@@ -275,7 +468,8 @@ vpn-router (0.26.1-1) unstable; urgency=medium
 
 vpn-router (0.26.0-1) unstable; urgency=medium
 
-  feature: users sign in to the Router Manager with passkeys, and console login needs a TOTP token, so a user without one is refused the shell, SSH and sudo.
+  feature: users sign in to the Router Manager with passkeys, and console login
+  needs a TOTP token, so a user without one is refused the shell, SSH and sudo.
 
   * Console login is switched on only for a user enrolled for TOTP. A user
     whose console login is on without a token is refused POST /shell, the
@@ -299,7 +493,8 @@ vpn-router (0.26.0-1) unstable; urgency=medium
 
 vpn-router (0.25.4-1) unstable; urgency=medium
 
-  fix: a shell opens without the password and code again while the user's last use of a shell is within web.shell_auth_timeout minutes.
+  fix: a shell opens without the password and code again while the user's last
+  use of a shell is within web.shell_auth_timeout minutes.
 
   * New setting web.shell_auth_timeout, 15 minutes by default, 0 to 1440:
     POST /shell without a password gives a ticket while the user's last
@@ -310,7 +505,8 @@ vpn-router (0.25.4-1) unstable; urgency=medium
 
 vpn-router (0.25.3-1) unstable; urgency=medium
 
-  fix: /config gives the state of caddy.service with the installed Caddy, for the Router Manager's Web page.
+  fix: /config gives the state of caddy.service with the installed Caddy, for
+  the Router Manager's Web page.
 
   * caddy of /config is {"version", "source", "service"}.
 
@@ -318,7 +514,9 @@ vpn-router (0.25.3-1) unstable; urgency=medium
 
 vpn-router (0.25.2-1) unstable; urgency=medium
 
-  fix: wireguard.address must be the router's own address in its network, not the network or broadcast address, from which the peers' addresses are told apart.
+  fix: wireguard.address must be the router's own address in its network, not
+  the network or broadcast address, from which the peers' addresses are told
+  apart.
 
   * A wireguard.address that is the network or the broadcast address of a
     network larger than /31, such as 192.168.232.0/24, is refused with the
@@ -328,7 +526,8 @@ vpn-router (0.25.2-1) unstable; urgency=medium
 
 vpn-router (0.25.1-1) unstable; urgency=medium
 
-  fix: /remote-access gives the router's WireGuard public key, endpoint and allowed IPs, which a peer's configuration needs.
+  fix: /remote-access gives the router's WireGuard public key, endpoint and
+  allowed IPs, which a peer's configuration needs.
 
   * GET /remote-access answers wireguard_server: {"public_key",
     "endpoint", "allowed_ips"}.
@@ -337,7 +536,8 @@ vpn-router (0.25.1-1) unstable; urgency=medium
 
 vpn-router (0.25.0-1) unstable; urgency=medium
 
-  feature: a VPN user has WireGuard peers, each a device with its public key and IPs, kept in the directory and written into wg0.conf by setup.
+  feature: a VPN user has WireGuard peers, each a device with its public key and
+  IPs, kept in the directory and written into wg0.conf by setup.
 
   * PUT /users/<name> takes wireguard_peers, [{"public_key", "ips"}],
     which replaces the user's peers; keys are unique and IPs may not
@@ -353,7 +553,8 @@ vpn-router (0.25.0-1) unstable; urgency=medium
 
 vpn-router (0.24.1-1) unstable; urgency=medium
 
-  fix: the status gives the number of connected OpenVPN clients at most 5 seconds old instead of up to a minute.
+  fix: the status gives the number of connected OpenVPN clients at most 5
+  seconds old instead of up to a minute.
 
   * The OpenVPN server writes its status file every 5 seconds, so a
     refresh of the status shows clients that connected or left since.
@@ -362,7 +563,9 @@ vpn-router (0.24.1-1) unstable; urgency=medium
 
 vpn-router (0.24.0-1) unstable; urgency=medium
 
-  feature: /remote-access of the web service shows and changes the settings of IKEv2 road-warrior, OpenVPN and WireGuard access and whether each runs, for the Router Manager's Remote access page.
+  feature: /remote-access of the web service shows and changes the settings of
+  IKEv2 road-warrior, OpenVPN and WireGuard access and whether each runs, for
+  the Router Manager's Remote access page.
 
   * GET /remote-access answers the p2s, openvpn and wireguard sections,
     which of them setup runs, and wan.local_fqdn; PUT
@@ -374,7 +577,9 @@ vpn-router (0.24.0-1) unstable; urgency=medium
 
 vpn-router (0.23.2-1) unstable; urgency=medium
 
-  fix: the shell of a user's own POSIX account opens on the first setup that sets up console login, and the journal records each refused shell with the reason.
+  fix: the shell of a user's own POSIX account opens on the first setup that
+  sets up console login, and the journal records each refused shell with the
+  reason.
 
   * Setup restarts vpn-router-web when it adds ldap to the name service
     switch, so the web service finds the POSIX accounts of the directory.
@@ -385,7 +590,9 @@ vpn-router (0.23.2-1) unstable; urgency=medium
 
 vpn-router (0.23.1-1) unstable; urgency=medium
 
-  fix: the shell runs as the console account of each member of admins, a local account or the user's own POSIX account in the directory, which also signs in with SSH and sudo, instead of one web.shell_user.
+  fix: the shell runs as the console account of each member of admins, a local
+  account or the user's own POSIX account in the directory, which also signs in
+  with SSH and sudo, instead of one web.shell_user.
 
   * vpn-router-user console <name> --posix | --account LOCAL | --off, and
     PUT /users/<name>/console with a token of vpn-router-token, switch a
@@ -403,7 +610,9 @@ vpn-router (0.23.1-1) unstable; urgency=medium
 
 vpn-router (0.23.0-1) unstable; urgency=medium
 
-  feature: web.shell lets /shell of the web service open a login shell of web.shell_user over a WebSocket for the Router Manager's Shell page, after the user signs in again.
+  feature: web.shell lets /shell of the web service open a login shell of
+  web.shell_user over a WebSocket for the Router Manager's Shell page, after the
+  user signs in again.
 
   * web.shell (false), web.shell_user and web.shell_idle_minutes (15).
   * POST /shell takes the password and the TOTP code and answers a
@@ -415,7 +624,8 @@ vpn-router (0.23.0-1) unstable; urgency=medium
 
 vpn-router (0.22.1-1) unstable; urgency=medium
 
-  fix: the status gives the number of site-to-site connections set up and established, not each connection by name.
+  fix: the status gives the number of site-to-site connections set up and
+  established, not each connection by name.
 
   * site_to_site of the status document is {"connections", "established"},
     and the status page shows "Site to site: N of M established".
@@ -424,7 +634,9 @@ vpn-router (0.22.1-1) unstable; urgency=medium
 
 vpn-router (0.22.0-1) unstable; urgency=medium
 
-  feature: pki.extended_key_usages adds custom extended key usages by their OIDs, which templates give by name, and a template's policies put certificate policy OIDs into its certificates.
+  feature: pki.extended_key_usages adds custom extended key usages by their
+  OIDs, which templates give by name, and a template's policies put certificate
+  policy OIDs into its certificates.
 
   * pki.extended_key_usages maps a name to the OID of a custom extended
     key usage; a template's extended_key_usage takes the built-in and the
@@ -438,7 +650,8 @@ vpn-router (0.22.0-1) unstable; urgency=medium
 
 vpn-router (0.21.5-1) unstable; urgency=medium
 
-  fix: /status/full of the status web service gives an authenticated client the whole status, whatever web.status_content says.
+  fix: /status/full of the status web service gives an authenticated client the
+  whole status, whatever web.status_content says.
 
   * /status/full takes the token of /config and answers the status
     document as web.status_content full shows it.
@@ -447,7 +660,8 @@ vpn-router (0.21.5-1) unstable; urgency=medium
 
 vpn-router (0.21.4-1) unstable; urgency=medium
 
-  fix: vpn-router-setup, vpn-router-ca and /ca read a CA's key and CRL from the directory each as itself, instead of failing on a CA with a CRL.
+  fix: vpn-router-setup, vpn-router-ca and /ca read a CA's key and CRL from the
+  directory each as itself, instead of failing on a CA with a CRL.
 
   * A CA's CRL was read as its key and its key as its CRL, so every
     operation on a CA with a CRL failed with "Could not deserialize key
@@ -457,7 +671,10 @@ vpn-router (0.21.4-1) unstable; urgency=medium
 
 vpn-router (0.21.3-1) unstable; urgency=medium
 
-  fix: the PKI is kept in ou=pki of the router's directory instead of files under /etc/vpn-router/pki, and the router's site-to-site certificate names only the identities its connections present, and /ca/bundle gives the certificate bundle of a CA.
+  fix: the PKI is kept in ou=pki of the router's directory instead of files
+  under /etc/vpn-router/pki, and the router's site-to-site certificate names
+  only the identities its connections present, and /ca/bundle gives the
+  certificate bundle of a CA.
 
   * The CAs with their certificates, keys, CSRs and CRLs, and every
     certificate issued with its revocation, are entries of the
@@ -481,7 +698,8 @@ vpn-router (0.21.3-1) unstable; urgency=medium
 
 vpn-router (0.21.2-1) unstable; urgency=medium
 
-  fix: pki.root_key_warning silences the warning of vpn-router-ca status and /ca about the root key on the router.
+  fix: pki.root_key_warning silences the warning of vpn-router-ca status and /ca
+  about the root key on the router.
 
   * pki.root_key_warning, true by default, set to false silences the
     warning that the root key is on the router.
@@ -490,7 +708,8 @@ vpn-router (0.21.2-1) unstable; urgency=medium
 
 vpn-router (0.21.1-1) unstable; urgency=medium
 
-  fix: vpn-router-ca status and /ca warn about a CRL the router signs only once vpn-router-pki.timer has not renewed it in time.
+  fix: vpn-router-ca status and /ca warn about a CRL the router signs only once
+  vpn-router-pki.timer has not renewed it in time.
 
   * A CRL whose CA key is on the router is reported once past half of its
     validity, when the timer should have signed it again; a root CRL
@@ -500,7 +719,10 @@ vpn-router (0.21.1-1) unstable; urgency=medium
 
 vpn-router (0.21.0-1) unstable; urgency=medium
 
-  feature: the router has a two-level CA with an optional offline root, issuing CAs for P2S, site-to-site and general use, templates, published certificates and CRLs and an ACME server, site-to-site connections authenticate with certificates, and setup installs Caddy from Ubuntu or Caddy's repository.
+  feature: the router has a two-level CA with an optional offline root, issuing
+  CAs for P2S, site-to-site and general use, templates, published certificates
+  and CRLs and an ACME server, site-to-site connections authenticate with
+  certificates, and setup installs Caddy from Ubuntu or Caddy's repository.
 
   * The root CA signs the issuing CAs p2s, which issues the router's VPN
     server certificate and the users' certificates, s2s, which issues
@@ -539,7 +761,9 @@ vpn-router (0.21.0-1) unstable; urgency=medium
 
 vpn-router (0.20.0-1) unstable; urgency=medium
 
-  feature: the router makes scheduled backups to a local folder, copied to the cloud with rclone, or to a Proxmox Backup Server, and vpn-router-backup restores them.
+  feature: the router makes scheduled backups to a local folder, copied to the
+  cloud with rclone, or to a Proxmox Backup Server, and vpn-router-backup
+  restores them.
 
   * The backup section of vpn-router.json switches on backups and sets
     the schedule (hourly, daily or weekly), the target (local or pbs),
@@ -572,7 +796,8 @@ vpn-router (0.20.0-1) unstable; urgency=medium
 
 vpn-router (0.19.1-3) unstable; urgency=medium
 
-  update: ADR-24 names Ubuntu's apt-daily timer, not a cron job, as what updates the package lists.
+  update: ADR-24 names Ubuntu's apt-daily timer, not a cron job, as what updates
+  the package lists.
 
   * ADR-24 says that Ubuntu's apt-daily timer updates the package lists
     twice a day, and that apt-daily or unattended-upgrades may hold the
@@ -591,7 +816,8 @@ vpn-router (0.19.1-2) unstable; urgency=medium
 
 vpn-router (0.19.1-1) unstable; urgency=medium
 
-  fix: /metrics/history gives the availability of each site-to-site connection as the percentage of time it was up in slots of the view.
+  fix: /metrics/history gives the availability of each site-to-site connection
+  as the percentage of time it was up in slots of the view.
 
   * site_to_site_up of /metrics/history divides the view into slots of 5
     minutes for an hour, 1 hour for a day, 1 day for a month and 1 month
@@ -602,7 +828,8 @@ vpn-router (0.19.1-1) unstable; urgency=medium
 
 vpn-router (0.19.0-1) unstable; urgency=medium
 
-  feature: service accounts have a display name and a description, which the router sets for its internal ones.
+  feature: service accounts have a display name and a description, which the
+  router sets for its internal ones.
 
   * vpnRouterAccount of the package's schema also takes displayName and
     description; vpn-router-setup updates the schema of an existing
@@ -620,7 +847,9 @@ vpn-router (0.19.0-1) unstable; urgency=medium
 
 vpn-router (0.18.3-1) unstable; urgency=medium
 
-  fix: internal service accounts are the router's own, of which the metrics service's is the one at present, and the documentation says what a service account is.
+  fix: internal service accounts are the router's own, of which the metrics
+  service's is the one at present, and the documentation says what a service
+  account is.
 
   * /service-accounts, /groups and the internal field of the answers
     take every internal service account, the accounts the router creates
@@ -635,7 +864,8 @@ vpn-router (0.18.3-1) unstable; urgency=medium
 
 vpn-router (0.18.2-1) unstable; urgency=medium
 
-  fix: service accounts are managed at /service-accounts, not /users, and the internal one of the metrics service is only listed.
+  fix: service accounts are managed at /service-accounts, not /users, and the
+  internal one of the metrics service is only listed.
 
   * /service-accounts, for members of admins and admin tokens, lists the
     service accounts, adds one with a password and an optional e-mail
@@ -652,7 +882,9 @@ vpn-router (0.18.2-1) unstable; urgency=medium
 
 vpn-router (0.18.1-1) unstable; urgency=medium
 
-  fix: vpn-router-setup owns only the creation of the metrics service's account, which is marked internal, and administrators add service accounts with vpn-router-user add --service and /users.
+  fix: vpn-router-setup owns only the creation of the metrics service's account,
+  which is marked internal, and administrators add service accounts with
+  vpn-router-user add --service and /users.
 
   * POST /users takes "service": true and adds a service account, which
     cannot sign in to /auth; vpn-router-user add takes --service.
@@ -676,7 +908,8 @@ vpn-router (0.18.0-2) unstable; urgency=medium
 
 vpn-router (0.18.0-1) unstable; urgency=medium
 
-  feature: site_to_site holds any number of named site-to-site connections, which /site-to-site lists, adds, changes and removes.
+  feature: site_to_site holds any number of named site-to-site connections,
+  which /site-to-site lists, adds, changes and removes.
 
   * site_to_site maps a connection name to addrs, id, cidrs, local_cidrs,
     local_id_mode, psk and psk_file; it replaces remote and
@@ -716,7 +949,8 @@ vpn-router (0.18.0-1) unstable; urgency=medium
 
 vpn-router (0.17.0-1) unstable; urgency=medium
 
-  feature: /config shows the router's PostgreSQL clusters and their settings, and /postgresql their databases with their sizes.
+  feature: /config shows the router's PostgreSQL clusters and their settings,
+  and /postgresql their databases with their sizes.
 
   * /config has a postgresql section: each cluster of pg_lsclusters with
     its version, name, port, status and data directory, and the main
@@ -728,7 +962,8 @@ vpn-router (0.17.0-1) unstable; urgency=medium
 
 vpn-router (0.16.0-1) unstable; urgency=medium
 
-  feature: the router keeps its metrics in PostgreSQL, serves them for an OpenTelemetry Collector and pushes them over OTLP.
+  feature: the router keeps its metrics in PostgreSQL, serves them for an
+  OpenTelemetry Collector and pushes them over OTLP.
 
   * vpn-router-metrics takes a sample every minute: CPU, memory, free
     space of /, bytes per second on the external and the internal
@@ -780,7 +1015,8 @@ vpn-router (0.14.1-1) unstable; urgency=medium
 
 vpn-router (0.14.0-1) unstable; urgency=medium
 
-  feature: the status page shows the Client IP, and web.status_content sets how much it shows.
+  feature: the status page shows the Client IP, and web.status_content sets how
+  much it shows.
 
   * / and /status show the Client IP, the address the request came from:
     the last X-Forwarded-For entry for a request from a trusted proxy, so
@@ -795,7 +1031,8 @@ vpn-router (0.14.0-1) unstable; urgency=medium
 
 vpn-router (0.13.0-1) unstable; urgency=medium
 
-  feature: Caddy serves the status page and the Router Manager over HTTPS with a certificate from Let's Encrypt.
+  feature: Caddy serves the status page and the Router Manager over HTTPS with a
+  certificate from Let's Encrypt.
 
   * The package depends on caddy. While https.enabled is true, the
     default, and wan.local_fqdn is set, vpn-router-setup writes
@@ -818,7 +1055,8 @@ vpn-router (0.13.0-1) unstable; urgency=medium
 
 vpn-router (0.12.3-1) unstable; urgency=medium
 
-  fix: the web service listens on the internal address, the external address or both.
+  fix: the web service listens on the internal address, the external address or
+  both.
 
   * web.listen in vpn-router.json sets the interfaces the web service
     listens on: internal, external or both, the default. It is read
@@ -904,7 +1142,8 @@ vpn-router (0.9.2-1) unstable; urgency=medium
 
 vpn-router (0.9.1-1) unstable; urgency=medium
 
-  fix: the web service waits for the PostgreSQL driver instead of failing at start.
+  fix: the web service waits for the PostgreSQL driver instead of failing at
+  start.
 
   * The web service imports psycopg as the first step of its
     initialization, retrying every 15 seconds and logging the failure while
@@ -934,7 +1173,8 @@ vpn-router (0.9.0-1) unstable; urgency=medium
 
 vpn-router (0.8.0-1) unstable; urgency=medium
 
-  feature: the web service creates its key and database itself and shows its starting phase.
+  feature: the web service creates its key and database itself and shows its
+  starting phase.
 
   * vpn-router-web makes its signing key and creates the refresh tokens'
     database on its first run, retrying every 15 seconds until PostgreSQL
@@ -949,7 +1189,8 @@ vpn-router (0.8.0-1) unstable; urgency=medium
 
 vpn-router (0.7.1-1) unstable; urgency=medium
 
-  fix: a failing user directory or token database no longer leaves the tunnels down.
+  fix: a failing user directory or token database no longer leaves the tunnels
+  down.
 
   * vpn-router-setup brings up strongSwan and WireGuard before it provisions
     the user directory and the token database. A failure of either no
@@ -959,7 +1200,8 @@ vpn-router (0.7.1-1) unstable; urgency=medium
 
 vpn-router (0.7.0-1) unstable; urgency=medium
 
-  feature: users sign in to the web service, and only members of admins manage the router.
+  feature: users sign in to the web service, and only members of admins manage
+  the router.
 
   * POST /auth signs a user in with the password, and the TOTP code for an
     enrolled user, and answers a 5 minute access token and an 8 hour refresh

debian-package/debian/install

@@ -21,6 +21,7 @@ src/usr/lib/vpn-router/editor-file                    usr/lib/vpn-router/
 src/usr/bin/vpn-router-editor                         usr/bin/
 src/usr/sbin/vpn-router-user                          usr/sbin/
 src/usr/sbin/vpn-router-group                         usr/sbin/
+src/usr/sbin/vpn-router-role                          usr/sbin/
 src/usr/sbin/vpn-router-token                         usr/sbin/
 src/usr/sbin/vpn-config-edit                          usr/sbin/
 src/usr/sbin/vpn-router-backup                        usr/sbin/

debian-package/publish.sh

@@ -8,9 +8,11 @@ case "$(uname -s)" in
     *)      printf 'ERROR: unsupported platform %s\n' "$(uname -s)" >&2; exit 1 ;;
 esac
 
-OWNER="${OWNER:-slawek}"
+OWNER="${OWNER:-koszewscy}"
 SERVER_URL="${SERVER_URL:-https://gitea.koszewscy.waw.pl}"
 PACKAGES_TOKEN="${PACKAGES_TOKEN:-$(cat ~/.gitea-packages-token)}"
+# The Ubuntu releases whose distribution of the repository gets the package, in its component main.
+DISTRIBUTIONS="${DISTRIBUTIONS:-noble resolute}"
 
 # Reads the changelog copied into the builder image, so no bind mount is needed.
 changelog_field() {
@@ -27,14 +29,17 @@ if [ ! -f "$DEB" ]; then
     exit 1
 fi
 
-STATUS="$(curl -s -o /dev/null -w '%{http_code}' --user "$OWNER:$PACKAGES_TOKEN" \
-    "$SERVER_URL/api/v1/packages/$OWNER/debian/$PACKAGE/$VERSION")"
-case "$STATUS" in
-    200) printf '%s %s is already published, skipping.\n' "$PACKAGE" "$VERSION"; exit 0 ;;
-    404) ;;
-    *)   printf 'ERROR: version check returned HTTP %s.\n' "$STATUS" >&2; exit 1 ;;
-esac
+BODY="$(mktemp)"
+trap 'rm -f "$BODY"' EXIT
 
-curl --fail-with-body --user "$OWNER:$PACKAGES_TOKEN" \
-    --upload-file "$DEB" \
-    "$SERVER_URL/api/packages/$OWNER/debian/pool/noble/main/upload"
+# Gitea answers 409 for a version that is in the distribution already.
+for DISTRIBUTION in $DISTRIBUTIONS; do
+    STATUS="$(curl -s -o "$BODY" -w '%{http_code}' --user "$OWNER:$PACKAGES_TOKEN" \
+        --upload-file "$DEB" \
+        "$SERVER_URL/api/packages/$OWNER/debian/pool/$DISTRIBUTION/main/upload")"
+    case "$STATUS" in
+        2??) printf '%s %s is published in %s/main.\n' "$PACKAGE" "$VERSION" "$DISTRIBUTION" ;;
+        409) printf '%s %s is already in %s/main, skipping.\n' "$PACKAGE" "$VERSION" "$DISTRIBUTION" ;;
+        *)   printf 'ERROR: the upload to %s/main returned HTTP %s: %s\n' "$DISTRIBUTION" "$STATUS" "$(cat "$BODY")" >&2; exit 1 ;;
+    esac
+done

debian-package/src/usr/lib/vpn-router/bootstrap

@@ -8,6 +8,7 @@ the logs.
 """
 
 import subprocess
+import sys
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 
 PORT = 17081
@@ -42,14 +43,28 @@ def report():
 class Handler(BaseHTTPRequestHandler):
     def do_GET(self):
         body = report().encode()
-        self.send_response(200)
-        self.send_header('Content-Type', 'text/plain; charset=utf-8')
-        self.send_header('Content-Length', str(len(body)))
-        self.send_header('Cache-Control', 'no-store')
-        self.send_header('Refresh', '10')
-        self.end_headers()
-        self.wfile.write(body)
+        try:
+            self.send_response(200)
+            self.send_header('Content-Type', 'text/plain; charset=utf-8')
+            self.send_header('Content-Length', str(len(body)))
+            self.send_header('Cache-Control', 'no-store')
+            self.send_header('Refresh', '10')
+            self.end_headers()
+            self.wfile.write(body)
+        except ConnectionError:
+            # The client went away before the answer was written.
+            self.close_connection = True
+
+
+def failed(request, client_address):
+    """Log a failed request in one line, and nothing when the client went away."""
+    failure = sys.exc_info()[1]
+    if not isinstance(failure, ConnectionError):
+        print(f'a request from {client_address[0]} failed: {type(failure).__name__}: {failure}', file=sys.stderr, flush=True)
 
 
 if __name__ == '__main__':
-    ThreadingHTTPServer(('', PORT), Handler).serve_forever()
+    sys.excepthook = lambda kind, value, _: print(f'failed: {kind.__name__}: {value}', file=sys.stderr, flush=True)
+    server = ThreadingHTTPServer(('', PORT), Handler)
+    server.handle_error = failed
+    server.serve_forever()

debian-package/src/usr/lib/vpn-router/metrics

@@ -405,15 +405,19 @@ class Handler(BaseHTTPRequestHandler):
                     registry = CollectorRegistry()
                     registry.register(Sample(current))
                     body, kind, code = generate_latest(registry), CONTENT_TYPE_LATEST, 200
-        self.send_response(code)
-        self.send_header('Content-Type', kind)
-        self.send_header('Content-Length', str(len(body)))
-        self.send_header('Cache-Control', 'no-store')
-        for name, value in extra:
-            self.send_header(name, value)
-        self.end_headers()
-        if send_body:
-            self.wfile.write(body)
+        try:
+            self.send_response(code)
+            self.send_header('Content-Type', kind)
+            self.send_header('Content-Length', str(len(body)))
+            self.send_header('Cache-Control', 'no-store')
+            for name, value in extra:
+                self.send_header(name, value)
+            self.end_headers()
+            if send_body:
+                self.wfile.write(body)
+        except ConnectionError:
+            # The client went away before the answer was written.
+            self.close_connection = True
 
     def do_GET(self):
         self.answer(True)

debian-package/src/usr/lib/vpn-router/setup

@@ -820,13 +820,33 @@ def manage_webdav(ctx):
     run(['systemctl', 'enable', '--now', WEBDAV_UNIT], check=False)
 
 
+def site_addresses(cfg, ctx):
+    """The pairs of a host name and the router's address of dns_address of each enabled site with dns router: public,
+    wan.public_address; internal, the internal interface's; external, the external interface's first. A site whose
+    address is not known gets none, with a warning."""
+    addresses = {'public': cfg['wan']['public_address'].strip(), 'internal': ctx['int_addr'],
+                 'external': next(iter(ctx['local_addr_list']), '')}
+    pairs = []
+    for site in ctx['sites']:
+        if site['dns'] != 'router':
+            continue
+        address = addresses[site['dns_address']]
+        if not address:
+            warn(f'site {site["name"]}: the router has no {site["dns_address"]} address, so its host names get no '
+                 'records')
+            continue
+        pairs += [(host, address) for host in site['hosts']]
+    return pairs
+
+
 def manage_dns(cfg, ctx):
     """Run PowerDNS, the primary name server of the domains of vpnrouter_dns, on the addresses of dns.listen while DNS
     is enabled, and stop it when not; its packages are installed when they are missing.
 
     The settings, vpnrouter_dns.PDNS_CONF, are written before the packages are installed, so the server their
-    installation starts answers on those addresses only, beside systemd-resolved's stub on 127.0.0.53. The domains
-    with site records get the host names of the enabled sites, and keep those they have while the sites cannot be read.
+    installation starts answers on those addresses only, beside systemd-resolved's stub on 127.0.0.53. The host names
+    of the enabled sites with dns router get records of the router's address they choose (site_addresses), and the
+    domains keep those they have while the sites cannot be read.
     """
     if not vpnrouter.dns_ready(ctx):
         if unit_is_active(vpnrouter_dns.UNIT):
@@ -854,7 +874,7 @@ def manage_dns(cfg, ctx):
         os.chown(vpnrouter_dns.PDNS_CONF, 0, grp.getgrnam(vpnrouter_dns.GROUP).gr_gid)
         vpnrouter_dns.provision()
         if ctx['sites'] is not None:
-            vpnrouter_dns.apply(cfg, [host for site in ctx['sites'] for host in site['hosts']])
+            vpnrouter_dns.apply(cfg, site_addresses(cfg, ctx))
     except (OSError, KeyError, vpnrouter_dns.DatabaseError) as exc:
         warn(f'the name server cannot be set up: {exc}')
         return

debian-package/src/usr/lib/vpn-router/vpnrouter.py

@@ -55,7 +55,7 @@ OPENVPN_LDAP   = pathlib.Path('/etc/openvpn/server/vpn-router-ldap.conf')
 SCHEMA = {
     'general':    {'platform': 'none', 'mode': 'manual'},
     'interfaces': {'external': '', 'internal': ''},
-    'wan':        {'local_fqdn': ''},
+    'wan':        {'local_fqdn': '', 'public_address': ''},
     'local':      {'cidrs': [], 'int_addr': '', 'int_gateway_ip': ''},
     'site_to_site': {},
     'p2s':        {'enabled': False, 'address_pool': '', 'dns_listen': 'internal', 'dns_domains': []},
@@ -66,10 +66,11 @@ SCHEMA = {
                    'status_content': 'basic', 'shell': False, 'shell_idle_minutes': 15, 'shell_auth_timeout': 15,
                    'log_files': []},
     'ssh':        {'ldap_login': False},
-    'https':      {'enabled': True, 'email': '', 'web_port': 7444, 'manager_port': 7443, 'caddy_source': 'ubuntu'},
+    'https':      {'enabled': True, 'email': '', 'web_port': 7444, 'manager_port': 7443, 'caddy_source': 'ubuntu',
+                   'acme_staging': False},
     'oidc':       {'enabled': False},
     'sites':      {'enabled': False, 'upload_max_mb': 512, 'webdav': False, 'webdav_port': 7445},
-    'dns':        {'enabled': False, 'nameserver': '', 'addresses': [], 'listen': 'external', 'ttl': 300},
+    'dns':        {'enabled': False, 'secondary': '', 'listen': 'external', 'ttl': 300},
     'pki':        {'root_name': 'VPN Router Root CA', 'root_days': 7300, 'ca_days': 3650, 'key': 'rsa-4096',
                    'crl_days': 7, 'root_crl_days': 180, 'publish': ['http'], 'p2s_name': 'VPN Router P2S CA',
                    's2s_name': 'VPN Router Site-to-Site CA', 'issuing_cas': {}, 'templates': {},
@@ -143,10 +144,14 @@ WEBDAV_LOOPBACK_PORT = 7446
 #: The largest sites.upload_max_mb, 10 GiB.
 UPLOAD_MAX_MB = 10240
 
+#: Settings that no longer exist, section -> options, left out when the file is read so that a file of an earlier
+#: version loads: the name server is wan.local_fqdn and a site chooses the address of its records.
+RETIRED = {'dns': ('nameserver', 'addresses')}
+
 #: The shortest and the longest dns.ttl, in seconds.
 DNS_TTL_RANGE = (60, 86400)
 
-#: A DNS name without a wildcard, in lowercase, of dns.nameserver and the domains of the name server.
+#: A DNS name without a wildcard, in lowercase, of the name servers and the domains of the name server.
 ZONE_NAME = re.compile(r'^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+$')
 
 #: A domain of p2s.dns_domains, one label or more, and the most domains.
@@ -164,6 +169,9 @@ MANAGER_PORT   = 7080
 #: Where vpn-router-setup installs Caddy from, https.caddy_source: the Ubuntu archive or Caddy's own repository.
 CADDY_SOURCES = ('ubuntu', 'upstream')
 
+#: The ACME directory of Let's Encrypt's staging environment, Caddy's only CA while https.acme_staging is true.
+ACME_STAGING_CA = 'https://acme-staging-v02.api.letsencrypt.org/directory'
+
 #: Caddy's own repository, which https.caddy_source upstream configures: the source, its signing key and their URLs.
 CADDY_APT_SOURCE = pathlib.Path('/etc/apt/sources.list.d/caddy-stable.sources')
 CADDY_KEYRING    = pathlib.Path('/etc/apt/keyrings/caddy-stable.asc')
@@ -296,6 +304,9 @@ def read_settings(path=None):
     for section, options in data.items():
         if not isinstance(options, dict):
             raise ConfigError(f'cannot parse {path}: {section} is not an object')
+    for section, options in RETIRED.items():
+        for option in options:
+            data.get(section, {}).pop(option, None)
     return data
 
 
@@ -577,14 +588,17 @@ def validate(cfg):
         raise ConfigError('sites.webdav: WebDAV is served by Caddy at https://<wan.local_fqdn>:<sites.webdav_port>, '
                           'which needs https.enabled and wan.local_fqdn')
 
+    _check_address(_get(cfg, 'wan', 'public_address'), 'wan.public_address')
     dns = cfg['dns']
-    if dns['enabled']:
-        if not ZONE_NAME.match(dns['nameserver'].strip()):
-            raise ConfigError(f'dns.nameserver: {dns["nameserver"]!r} is not a DNS name in lowercase')
-        if not _get_list(cfg, 'dns', 'addresses'):
-            raise ConfigError('dns.enabled needs dns.addresses, the public addresses of the name server and the sites')
-    for item in _get_list(cfg, 'dns', 'addresses'):
-        _check_address(item, 'dns.addresses')
+    if dns['enabled'] and not (ZONE_NAME.match(_get(cfg, 'wan', 'local_fqdn'))
+                               and not re.search(r'\.[0-9]+$', _get(cfg, 'wan', 'local_fqdn'))):
+        raise ConfigError('dns.enabled needs wan.local_fqdn, a DNS name in lowercase: the primary name server of the '
+                          'domains')
+    secondary = _get(cfg, 'dns', 'secondary')
+    if secondary and not ZONE_NAME.match(secondary):
+        raise ConfigError(f'dns.secondary: {secondary!r} is not a DNS name in lowercase')
+    if secondary and secondary == _get(cfg, 'wan', 'local_fqdn'):
+        raise ConfigError('dns.secondary: the secondary name server is not wan.local_fqdn, the primary')
     if dns['listen'] not in LISTEN_CHOICES:
         raise ConfigError(f'dns.listen: {dns["listen"]!r} is not one of {", ".join(LISTEN_CHOICES)}')
     if not DNS_TTL_RANGE[0] <= dns['ttl'] <= DNS_TTL_RANGE[1]:
@@ -1034,6 +1048,7 @@ def build_context(cfg, public_ip=None):
         'web_port':        _get(cfg, 'web', 'port'),
         'https_enabled':   _get(cfg, 'https', 'enabled'),
         'https_email':     _get(cfg, 'https', 'email'),
+        'https_acme_ca':   ACME_STAGING_CA if _get(cfg, 'https', 'acme_staging') else '',
         'https_web_port':  _get(cfg, 'https', 'web_port'),
         'https_manager_port': _get(cfg, 'https', 'manager_port'),
         'pki_publish':     _get_list(cfg, 'pki', 'publish'),

debian-package/src/usr/lib/vpn-router/vpnrouter_dns.py

@@ -1,17 +1,17 @@
 """The router's authoritative name server, PowerDNS with its gpgsql backend, for vpn-router-setup and the web service.
 
 The name server is the primary of its domains and answers on the addresses of the interfaces of dns.listen. The
-domains, their secondary name servers and the records an administrator added (manual records) are in the
-vpn-router-dns database, which provision() creates with its role and the password in DATABASE_SECRET, and fills with
-the schema of pdns-backend-pgsql, PDNS_SCHEMA; DNS_SQL defines the router's own tables and procedures, and the first
-connection of a process loads it.
+domains and the records an administrator added (manual records) are in the vpn-router-dns database, which
+provision() creates with its role and the password in DATABASE_SECRET, and fills with the schema of
+pdns-backend-pgsql, PDNS_SCHEMA; DNS_SQL defines the router's own tables and procedures, and the first connection of a
+process loads it.
 
-apply() writes every domain as a primary zone: its SOA with dns.nameserver, its NS, dns.nameserver and the name
-servers of its secondaries, the NS of the domains directly below it, A and AAAA records of dns.addresses for its apex,
-for those name servers inside it that are the router, and, when the domain has site records, for every host name of an
-enabled site whose closest domain it is, and the manual records, but those of a name and type the records before them
-have. A secondary's address is notified of every change (ALSO-NOTIFY) and may transfer the zone (ALLOW-AXFR-FROM); the
-serial of the SOA grows only when the records change.
+apply() writes every domain as a primary zone: its SOA with wan.local_fqdn as the primary name server, its NS,
+wan.local_fqdn and dns.secondary, the NS of the domains directly below it, an A or AAAA record for every host name of
+an enabled site with dns router whose closest domain it is, with the router's address the site chooses, and the manual
+records, but those of a name and type the records before them have. wan.local_fqdn gets no record in the zones: its
+record is kept where its own domain is. The addresses dns.secondary resolves to are notified of every change
+(ALSO-NOTIFY) and may transfer the zones (ALLOW-AXFR-FROM); the serial of the SOA grows only when the records change.
 
 Every failure of the database raises DatabaseError; a request that cannot be done raises Failure.
 """
@@ -20,6 +20,7 @@ import contextlib
 import ipaddress
 import pathlib
 import re
+import socket
 
 import psycopg
 from psycopg.rows import dict_row
@@ -44,9 +45,8 @@ GROUP = 'pdns'
 #: The types of the manual records.
 TYPES = ('A', 'AAAA', 'CNAME', 'TXT', 'MX', 'SRV', 'CAA')
 
-#: The most domains, secondaries of a domain, and manual records of a domain.
+#: The most domains, and manual records of a domain.
 DOMAINS_MAX = 100
-SECONDARIES_MAX = 8
 MANUAL_MAX = 1000
 
 #: The refresh, retry and expire times of the SOA, in seconds.
@@ -73,8 +73,7 @@ class DatabaseError(Exception):
 
 
 class Failure(Exception):
-    """A request that cannot be done; status is 2 invalid, 3 no such domain, secondary or record, 4 the domain
-    exists."""
+    """A request that cannot be done; status is 2 invalid, 3 no such domain or record, 4 the domain exists."""
 
     def __init__(self, message, status=2):
         super().__init__(message)
@@ -211,13 +210,10 @@ def domain(connection, name):
 
 
 def listing():
-    """Every domain with its secondaries, its manual records and the records the name server answers for it."""
+    """Every domain with its manual records and the records the name server answers for it."""
     with database() as connection:
-        secondaries = connection.execute('SELECT * FROM dns_secondaries_list()').fetchall()
         manual = connection.execute('SELECT * FROM dns_records_list()').fetchall()
         return [{**row,
-                 'secondaries': [{key: item[key] for key in ('nameserver', 'address')}
-                                 for item in secondaries if item['domain'] == row['name']],
                  'manual': [{key: item[key] for key in ('name', 'type', 'content', 'ttl')}
                             for item in manual if item['domain'] == row['name']],
                  'records': connection.execute('SELECT * FROM dns_served(%s)', (row['name'],)).fetchall()}
@@ -225,71 +221,52 @@ def listing():
 
 
 def domain_add(body):
-    """Add the domain {name, sites, ttl?}; the domain."""
-    if not isinstance(body, dict) or not isinstance(body.get('sites', False), bool):
-        raise Failure('a domain is an object of name, sites and ttl')
-    name, sites, ttl = check_domain(body.get('name')), body.get('sites', False), check_ttl(body.get('ttl'))
+    """Add the domain {name, ttl?}; the domain."""
+    if not isinstance(body, dict) or not set(body) <= {'name', 'ttl'}:
+        raise Failure('a domain is an object of name and ttl')
+    name, ttl = check_domain(body.get('name')), check_ttl(body.get('ttl'))
     with database() as connection:
         names = [row['name'] for row in connection.execute('SELECT * FROM dns_domains_list()').fetchall()]
         if name in names:
             raise Failure(f'the domain {name} exists', 4)
         if len(names) >= DOMAINS_MAX:
             raise Failure(f'the name server has {DOMAINS_MAX} domains')
-        connection.execute('CALL dns_domain_put(%s, %s, %s)', (name, sites, ttl))
-    return {'name': name, 'sites': sites, 'ttl': ttl}
+        connection.execute('CALL dns_domain_put(%s, %s)', (name, ttl))
+    return {'name': name, 'ttl': ttl}
 
 
 def domain_change(name, body):
-    """Change the sites and ttl of the domain; the domain."""
-    if not isinstance(body, dict) or not set(body) <= {'sites', 'ttl'} or \
-            not isinstance(body.get('sites', False), bool):
-        raise Failure('a change of a domain is an object of sites and ttl')
+    """Change the ttl of the domain; the domain."""
+    if not isinstance(body, dict) or not set(body) <= {'ttl'}:
+        raise Failure('a change of a domain is an object of ttl')
     with database() as connection:
         row = domain(connection, name)
-        sites, ttl = body.get('sites', row['sites']), check_ttl(body.get('ttl', row['ttl']))
-        connection.execute('CALL dns_domain_put(%s, %s, %s)', (name, sites, ttl))
-    return {'name': name, 'sites': sites, 'ttl': ttl}
+        ttl = check_ttl(body.get('ttl', row['ttl']))
+        connection.execute('CALL dns_domain_put(%s, %s)', (name, ttl))
+    return {'name': name, 'ttl': ttl}
 
 
 def domain_remove(name):
-    """Remove the domain with its secondaries and manual records."""
+    """Remove the domain with its manual records."""
     with database() as connection:
         domain(connection, name)
         connection.execute('CALL dns_domain_remove(%s)', (name,))
     return {'name': name}
 
 
-def secondary_add(name, body):
-    """Add the secondary name server {nameserver, address} of the domain, or set its address; the secondary."""
-    if not isinstance(body, dict):
-        raise Failure('a secondary is an object of nameserver and address')
-    nameserver = body.get('nameserver')
-    if not isinstance(nameserver, str) or not vpnrouter.ZONE_NAME.match(nameserver.strip().lower().rstrip('.')):
-        raise Failure(f'{nameserver!r} is not a name server name')
-    nameserver = nameserver.strip().lower().rstrip('.')
+def secondary_addresses(cfg):
+    """The addresses dns.secondary resolves to, which are notified of the zones' changes and may transfer them; none,
+    with a warning, while it is not set or does not resolve."""
+    secondary = cfg['dns']['secondary'].strip()
+    if not secondary:
+        vpnrouter.warn('dns.secondary is not set: the domains have no secondary name server')
+        return []
     try:
-        address = str(ipaddress.ip_address(str(body.get('address', '')).strip()))
-    except ValueError as exc:
-        raise Failure(f'{body.get("address")!r} is not an IP address') from exc
-    with database() as connection:
-        domain(connection, name)
-        others = [row for row in connection.execute('SELECT * FROM dns_secondaries_list()').fetchall()
-                  if row['domain'] == name and row['nameserver'] != nameserver]
-        if len(others) >= SECONDARIES_MAX:
-            raise Failure(f'the domain {name} has {SECONDARIES_MAX} secondaries')
-        connection.execute('CALL dns_secondary_put(%s, %s, %s)', (name, nameserver, address))
-    return {'domain': name, 'nameserver': nameserver, 'address': address}
-
-
-def secondary_remove(name, nameserver):
-    """Remove the secondary name server of the domain."""
-    with database() as connection:
-        domain(connection, name)
-        if not any(row['domain'] == name and row['nameserver'] == nameserver
-                   for row in connection.execute('SELECT * FROM dns_secondaries_list()').fetchall()):
-            raise Failure(f'no secondary {nameserver} of {name}', 3)
-        connection.execute('CALL dns_secondary_remove(%s, %s)', (name, nameserver))
-    return {'domain': name, 'nameserver': nameserver}
+        found = socket.getaddrinfo(secondary, 53, proto=socket.IPPROTO_UDP)
+    except OSError as exc:
+        vpnrouter.warn(f'dns.secondary {secondary} does not resolve, so it may not transfer the domains: {exc}')
+        return []
+    return list(dict.fromkeys(str(ipaddress.ip_address(item[4][0])) for item in found))
 
 
 def add(cfg, name, record):
@@ -332,25 +309,20 @@ def remove(name, record_name, kind, content):
     return {'name': full, 'type': kind, 'removed': len(found)}
 
 
-def records(cfg, row, zones, secondaries, hosts, manual_records):
+def records(cfg, row, zones, hosts, manual_records):
     """The records of the domain row besides its SOA, as (name, type, content, ttl): the NS of the domain and of the
-    domains directly below it, the A and AAAA records of dns.addresses for its apex, dns.nameserver when it is inside
-    and, with site records, each host name whose closest domain it is, the glue of the secondaries inside it, and its
-    manual records. secondaries maps a domain to its secondaries."""
+    domains directly below it, wan.local_fqdn and dns.secondary, the A or AAAA record of each host name of hosts, pairs
+    of a host name and an address, whose closest domain it is, and its manual records."""
     dns = cfg['dns']
-    zone, nameserver, ttl = row['name'], dns['nameserver'].strip(), row['ttl'] or dns['ttl']
-    addresses = [ipaddress.ip_address(item.strip()) for item in dns['addresses'] if item.strip()]
+    zone, ttl = row['name'], row['ttl'] or dns['ttl']
+    servers = [cfg['wan']['local_fqdn'].strip(), *([dns['secondary'].strip()] if dns['secondary'].strip() else [])]
     children = [name for name in zones
                 if name != zone and closest([item for item in zones if item != name], name) == zone]
-    found = [(name, 'NS', server, ttl) for name in [zone, *children]
-             for server in [nameserver, *(item['nameserver'] for item in secondaries.get(name, []))]]
-    for name in dict.fromkeys([zone, *([nameserver] if in_zone(zone, nameserver) else []),
-                               *(host for host in hosts if row['sites'] and closest(zones, host) == zone)]):
-        found += [(name, 'A' if address.version == 4 else 'AAAA', str(address), ttl) for address in addresses]
-    for item in (item for name in [zone, *children] for item in secondaries.get(name, [])):
-        if in_zone(zone, item['nameserver']) and item['nameserver'] != nameserver:
-            address = ipaddress.ip_address(item['address'])
-            found.append((item['nameserver'], 'A' if address.version == 4 else 'AAAA', str(address), ttl))
+    found = [(name, 'NS', server, ttl) for name in [zone, *children] for server in servers]
+    for host, address in hosts:
+        if closest(zones, host) == zone:
+            address = ipaddress.ip_address(address)
+            found.append((host, 'A' if address.version == 4 else 'AAAA', str(address), ttl))
     taken = {(name, kind) for name, kind, _, _ in found}
     found += [(item['name'], item['type'], item['content'], item['ttl']) for item in manual_records
               if (item['name'], item['type']) not in taken]
@@ -358,7 +330,8 @@ def records(cfg, row, zones, secondaries, hosts, manual_records):
 
 
 def apply(cfg, hosts):
-    """Make the name server the primary of every domain with records(), and of none while dns.enabled is false."""
+    """Make the name server the primary of every domain with records(), hosts being the pairs of a host name and an
+    address of the sites with dns router, and of none while dns.enabled is false."""
     with database() as connection:
         if not cfg['dns']['enabled']:
             connection.execute('CALL dns_retain(%s::text[])', ([],))
@@ -366,20 +339,21 @@ def apply(cfg, hosts):
         dns = cfg['dns']
         domains = connection.execute('SELECT * FROM dns_domains_list()').fetchall()
         zones = [row['name'] for row in domains]
-        secondaries, manual = {}, {}
-        for item in connection.execute('SELECT * FROM dns_secondaries_list()').fetchall():
-            secondaries.setdefault(item['domain'], []).append(item)
+        for host, _ in hosts:
+            if closest(zones, host) is None:
+                vpnrouter.warn(f'{host} is in none of the domains, so the name server has no record of it')
+        manual = {}
         for item in connection.execute('SELECT * FROM dns_records_list()').fetchall():
             manual.setdefault(item['domain'], []).append(item)
+        transfers = secondary_addresses(cfg) if domains else []
         for row in domains:
             zone, ttl = row['name'], row['ttl'] or dns['ttl']
-            rows = records(cfg, row, zones, secondaries, hosts, manual.get(zone, []))
-            soa = f'{dns["nameserver"].strip()} hostmaster.{zone} {{serial}} {SOA_TIMES} {ttl}'
+            rows = records(cfg, row, zones, hosts, manual.get(zone, []))
+            soa = f'{cfg["wan"]["local_fqdn"].strip()} hostmaster.{zone} {{serial}} {SOA_TIMES} {ttl}'
             connection.execute('CALL dns_apply(%s, %s, %s, %s::text[], %s::text[], %s::text[], %s::integer[], '
                                '%s::text[])',
                                (zone, soa, ttl, [item[0] for item in rows], [item[1] for item in rows],
-                                [item[2] for item in rows], [item[3] for item in rows],
-                                [item['address'] for item in secondaries.get(zone, [])]))
+                                [item[2] for item in rows], [item[3] for item in rows], transfers))
         connection.execute('CALL dns_retain(%s::text[])', (zones,))
 
 

debian-package/src/usr/lib/vpn-router/vpnrouter_ldap.py

@@ -18,6 +18,9 @@ vpnRouterConsoleLogin TRUE to the system over the local socket.
 
 ou=pki holds the router's PKI (vpnrouter_pki): an entry per CA, and under it an entry per
 certificate the CA issued. Private keys are readable by root alone, the database's root DN.
+
+ou=roles holds the roles of the resources of the OpenID Provider: an entry per role,
+cn=<resource>:<role>, whose members are the groups, users and service accounts it is assigned to.
 """
 
 import os
@@ -39,6 +42,7 @@ GROUPS = f'ou=groups,{BASE}'
 SERVICES = f'ou=services,{BASE}'
 POLICIES = f'ou=policies,{BASE}'
 PKI = f'ou=pki,{BASE}'
+ROLES = f'ou=roles,{BASE}'
 DEFAULT_POLICY = f'cn=default,{POLICIES}'
 TOTP_PARAMS = f'cn=totp,{POLICIES}'
 MANAGER = f'cn=user-manager,{SERVICES}'
@@ -71,7 +75,12 @@ OVERLAYS = ('ppolicy', 'otp')
 #: passkey of the user as JSON (vpnrouter_passkeys). A service account with vpnRouterRedirectUri
 #: is a client of the OpenID Provider (vpnrouter_oidc): the URIs it is sent back to after a sign-in
 #: and, vpnRouterPostLogoutRedirectUri, after a sign-out, and vpnRouterAllowedGroup, the DNs of the
-#: groups whose members may sign in to it. vpnRouterAuthority is a CA of the PKI: its
+#: groups whose members may sign in to it; vpnRouterGrantType, the further grants it may use,
+#: vpnRouterPublicClient, whether it has no secret, and vpnRouterClientScope, the scopes of
+#: resources it may ask for, as <resource>:<scope>. A service account with vpnRouterResourceScope
+#: is a resource of the OpenID Provider with those scopes. vpnRouterRole is a role of a resource,
+#: named cn=<resource>:<role>, with the DNs of the groups and accounts it is assigned to in
+#: member. vpnRouterAuthority is a CA of the PKI: its
 #: certificate and CRL (cACertificate and certificateRevocationList of RFC 4523), its key, the
 #: CSR it waits with for the offline root, the number of its last CRL, where the CRL came from,
 #: and when it was retired. vpnRouterCertificate is a certificate a CA issued, named by its
@@ -112,18 +121,29 @@ SCHEMA_ATTRIBUTE_TYPES = (
     "OpenID Connect client' EQUALITY caseExactMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{1024} )",
     f"( {SCHEMA_OID}.1.19 NAME 'vpnRouterAllowedGroup' DESC 'VPN router: a group whose members may sign in to an "
     "OpenID Connect client' EQUALITY distinguishedNameMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 )",
+    f"( {SCHEMA_OID}.1.20 NAME 'vpnRouterGrantType' DESC 'VPN router: a grant an OpenID Connect client may use besides "
+    "the authorization code' EQUALITY caseExactMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{64} )",
+    f"( {SCHEMA_OID}.1.21 NAME 'vpnRouterPublicClient' DESC 'VPN router: whether an OpenID Connect client has no secret' "
+    "EQUALITY booleanMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 SINGLE-VALUE )",
+    f"( {SCHEMA_OID}.1.22 NAME 'vpnRouterClientScope' DESC 'VPN router: a scope of a resource an OpenID Connect client "
+    "may ask for' EQUALITY caseExactMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{128} )",
+    f"( {SCHEMA_OID}.1.23 NAME 'vpnRouterResourceScope' DESC 'VPN router: a scope of a resource of the OpenID Provider' "
+    "EQUALITY caseExactMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{64} )",
 )
 SCHEMA_OBJECT_CLASSES = (
     f"( {SCHEMA_OID}.2.1 NAME 'vpnRouterAccount' DESC 'VPN router: properties of a user or a Manager-only account' "
     "SUP top AUXILIARY MAY ( mail $ vpnRouterScope $ displayName $ description $ vpnRouterConsoleLogin $ "
     "vpnRouterConsoleAccount $ vpnRouterWireGuardPeer $ vpnRouterPasskey $ vpnRouterRedirectUri $ "
-    "vpnRouterPostLogoutRedirectUri $ vpnRouterAllowedGroup ) )",
+    "vpnRouterPostLogoutRedirectUri $ vpnRouterAllowedGroup $ vpnRouterGrantType $ vpnRouterPublicClient $ "
+    "vpnRouterClientScope $ vpnRouterResourceScope ) )",
     f"( {SCHEMA_OID}.2.2 NAME 'vpnRouterAuthority' DESC 'VPN router: a CA of the PKI' SUP top STRUCTURAL MUST cn "
     "MAY ( cACertificate $ certificateRevocationList $ vpnRouterPrivateKey $ vpnRouterCertificateRequest $ "
     "vpnRouterCRLNumber $ vpnRouterCRLSource $ vpnRouterRetired ) )",
     f"( {SCHEMA_OID}.2.3 NAME 'vpnRouterCertificate' DESC 'VPN router: a certificate a CA of the PKI issued' SUP top "
     "STRUCTURAL MUST serialNumber MAY ( cn $ userCertificate $ vpnRouterPrivateKey $ vpnRouterKind $ vpnRouterTemplate $ "
     "vpnRouterSubjectAltName $ vpnRouterNotAfter $ vpnRouterRevoked $ vpnRouterRevocationReason ) )",
+    f"( {SCHEMA_OID}.2.4 NAME 'vpnRouterRole' DESC 'VPN router: a role of a resource of the OpenID Provider' SUP top "
+    "STRUCTURAL MUST cn MAY ( description $ member ) )",
 )
 
 #: The TOTP parameters: digits, the OID of HMAC-SHA1, seconds per time step, and the time steps accepted before and after now.
@@ -152,6 +172,7 @@ ACCESS = (
     f'to attrs=oathSecret by dn.exact="{MANAGER}" =w by * none',
     f'to dn.subtree="{USERS}" by dn.exact="{MANAGER}" manage by * read',
     f'to dn.subtree="{GROUPS}" by dn.exact="{MANAGER}" manage by * read',
+    f'to dn.subtree="{ROLES}" by dn.exact="{MANAGER}" manage by * read',
     'to * by * read',
 )
 
@@ -333,7 +354,7 @@ def provision():
         database = _ensure_database(connection)
         _ensure_overlays(connection, database)
         _ensure_entry(connection, BASE, {'objectClass': [b'dcObject', b'organization'], 'dc': [b'vpn-router'], 'o': [b'vpn-router']})
-        for unit in (USERS, GROUPS, SERVICES, POLICIES, PKI):
+        for unit in (USERS, GROUPS, SERVICES, POLICIES, PKI, ROLES):
             _ensure_entry(connection, unit, {'objectClass': [b'organizationalUnit'], 'ou': [unit.split(',')[0][3:].encode()]})
         _ensure_entry(connection, DEFAULT_POLICY, {
             'objectClass': [b'organizationalRole', b'pwdPolicy'],

debian-package/src/usr/lib/vpn-router/vpnrouter_oidc.py

@@ -3,28 +3,45 @@
 While oidc.enabled is true, the web service answers OpenID Connect at the issuer vpnrouter.oidc_issuer, its HTTPS site
 that Caddy serves; the web service answers it only on the loopback address, where Caddy passes the requests. The users
 of the router's directory sign in, with the password and the TOTP code or with a passkey (vpnrouter_passkeys), to its
-clients, the service accounts with redirect URIs (vpnrouter_users.client_settings): a client's ID is its name and its
-secret its password, sent with HTTP Basic authentication or in the body of the token request. A client with allowed
-groups admits only their members; a service account never signs in as a user.
+clients, the service accounts with redirect URIs or grants (vpnrouter_users.client_settings): a client's ID is its name
+and its secret its password, sent with HTTP Basic authentication or in the body of the token request; a public client
+sends only its ID. A client with allowed groups admits only their members; a service account never signs in as a user.
 
   GET  /.well-known/openid-configuration   the discovery document
-  GET  /oidc/jwks                         the public key the ID tokens are signed with
+  GET  /oidc/jwks                         the public key the ID tokens and the access tokens are signed with
   GET, POST /oidc/authorize               the authorization code flow, PKCE with S256 required; the sign-in page while
                                           the browser has no session, or with prompt=login or an older one than max_age
   POST /oidc/login                        the sign-in page's form: the name, the password and the code, or a passkey
   POST /oidc/passkey                      begin a sign-in with a passkey: {"id", "options"}
-  POST /oidc/token                        exchange a code or a refresh token for tokens
+  POST /oidc/token                        exchange a code, a refresh token or a device code for tokens, or a client's
+                                          credentials for an access token
+  POST /oidc/device_authorization         begin the device authorization grant (RFC 8628): a device code and a user code
+  GET, POST /oidc/device                  the page where the user enters the user code, signs in and is asked to allow
+                                          the device
+  POST /oidc/device/decide                allow or deny the device
   GET, POST /oidc/userinfo                the claims of the user an access token was issued for
   GET  /oidc/logout                       end the session, then go to a post-logout redirect URI of the client
 
-ID tokens are RS256 JWTs signed with KEY, an RSA key the web service makes on its first run on the router, named by
-the RFC 7638 thumbprint of its public key. sub is the entryUUID of the user's entry, so a user added again under the
-same name is another subject. The scopes: openid, required; profile, preferred_username and the names; email; groups,
-the names of the user's groups; their claims are in the ID token and the userinfo answer. A code is valid
-CODE_SECONDS, an access token and an ID token ACCESS_SECONDS, a refresh token REFRESH_SECONDS, used once. A session,
-the cookie COOKIE of the issuer's /oidc/ path, lasts SESSION_SECONDS. Codes, tokens and sessions are kept in the
-database of vpnrouter_auth as their SHA-256 (vpnrouter_auth.OIDC_SQL); vpnrouter_auth.revoke removes a user's. A
-client is registered by an administrator, so a user is not asked for consent.
+The grants: authorization_code for a client with redirect URIs, client_credentials, by which a confidential client
+gets an access token as itself, and the device code, as the client's grants give them, each with refresh_token but
+client_credentials. A client asks for tokens for a resource, a service account, with resource (RFC 8707), its name or
+<issuer>/<name>, or by the resource's scopes it asks for, <resource>:<scope>, of its client scopes; without one the
+tokens are for the client itself.
+
+ID tokens are RS256 JWTs signed with KEY, an RSA key the web service makes on its first run on the router, named by the
+RFC 7638 thumbprint of its public key, for the client. Access tokens are RS256 JWTs of RFC 9068 with the same key, for
+the resource or the client: iss, sub, aud, client_id, iat, exp, jti, scope, roles, the claims of the scopes, and of a
+user auth_time and amr. sub is the entryUUID of the user's entry, so a user added again under the same name is another
+subject. The scopes: openid, required but with client_credentials, which refuses it; profile, preferred_username and
+the names; email; groups, the names of the user's groups; their claims are in the ID token, the access token and the
+userinfo answer; and the scopes of the resources. roles are the roles of the resource assigned to the user or service
+account or a group of it (vpnrouter_users.roles_held), read at every issue; the ID token and the userinfo answer have
+those of the client. A code is valid CODE_SECONDS, an access token and an ID token ACCESS_SECONDS, a refresh token
+REFRESH_SECONDS, used once, and a device code DEVICE_SECONDS, polled at most every DEVICE_INTERVAL seconds, 5 more after
+each poll that came too soon. A session, the cookie COOKIE of the issuer's /oidc/ path, lasts SESSION_SECONDS. Codes,
+tokens, device codes and sessions are kept in the database of vpnrouter_auth as their SHA-256
+(vpnrouter_auth.OIDC_SQL); vpnrouter_auth.revoke removes a user's or a service account's. A client is registered by an
+administrator, so a user is not asked for consent, but for a device, which the user allows on the router's page.
 """
 
 import base64
@@ -45,8 +62,13 @@ import jwt
 import ldap
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric import rsa
-from oauthlib.common import add_params_to_uri
-from oauthlib.oauth2 import AccessDeniedError, FatalClientError, InvalidRequestError, OAuth2Error
+from oauthlib.common import Request, add_params_to_uri
+from oauthlib.oauth2 import (AccessDeniedError, FatalClientError, InvalidClientError, InvalidGrantError,
+                             InvalidRequestError, InvalidScopeError, OAuth2Error, UnauthorizedClientError,
+                             UnsupportedGrantTypeError)
+from oauthlib.oauth2.rfc6749 import utils
+from oauthlib.oauth2.rfc6749.grant_types.base import GrantTypeBase
+from oauthlib.oauth2.rfc6749.tokens import random_token_generator
 from oauthlib.openid import RequestValidator, Server
 from oauthlib.openid.connect.core.exceptions import LoginRequired
 
@@ -63,6 +85,14 @@ CODE_SECONDS = 60
 ACCESS_SECONDS = 300
 REFRESH_SECONDS = 8 * 3600
 SESSION_SECONDS = 8 * 3600
+DEVICE_SECONDS = 600
+DEVICE_INTERVAL = 5
+
+#: The grant type of the device authorization grant.
+DEVICE_GRANT = 'urn:ietf:params:oauth:grant-type:device_code'
+#: A user code: USER_CODE_LENGTH of these letters, shown in two halves.
+USER_CODE_LETTERS = 'BCDFGHJKLMNPQRSTVWXZ'
+USER_CODE_LENGTH = 8
 
 COOKIE = 'vpn_router_oidc'
 
@@ -75,10 +105,11 @@ SCOPE_CLAIMS = {
 SCOPES = ('openid', *SCOPE_CLAIMS)
 
 #: The authentication methods (RFC 8176) of a sign-in with a password, with a password and a TOTP code, and with a
-#: passkey, which verifies the user.
+#: passkey, which verifies the user; a service account's client credentials are its password.
 PASSWORD_AMR = ['pwd']
 OTP_AMR = ['pwd', 'otp']
 PASSKEY_AMR = ['hwk', 'user']
+SERVICE_AMR = ['pwd']
 
 TEMPLATE = 'oidc-page.html.j2'
 
@@ -96,6 +127,26 @@ _pages = jinja2.Environment(loader=jinja2.FileSystemLoader(str(vpnrouter.TEMPLAT
                             undefined=jinja2.StrictUndefined)
 
 
+class InvalidTarget(OAuth2Error):
+    """A resource that is unknown, or more than one (RFC 8707)."""
+    error = 'invalid_target'
+
+
+class AuthorizationPending(OAuth2Error):
+    """A device code the user has not yet allowed or denied (RFC 8628)."""
+    error = 'authorization_pending'
+
+
+class SlowDown(OAuth2Error):
+    """A device code polled sooner than its interval (RFC 8628)."""
+    error = 'slow_down'
+
+
+class ExpiredToken(OAuth2Error):
+    """A device code that has expired (RFC 8628)."""
+    error = 'expired_token'
+
+
 def ensure_key():
     """Make the signing key when it is missing."""
     if KEY.is_file() and KEY.stat().st_size:
@@ -122,30 +173,33 @@ def public_jwk(key):
     return {**jwk, 'kid': vpnrouter_auth.b64encode(thumbprint), 'use': 'sig', 'alg': 'RS256'}
 
 
-def sign(claims):
+def sign(claims, headers=None):
+    """The claims as an RS256 JWT with the key's kid and the headers given."""
     key = private_key()
-    return jwt.encode(claims, key, algorithm='RS256', headers={'kid': public_jwk(key)['kid']})
+    return jwt.encode(claims, key, algorithm='RS256', headers={'kid': public_jwk(key)['kid'], **(headers or {})})
 
 
-def discovery(issuer):
-    """The discovery document of OpenID Connect Discovery 1.0."""
+def discovery(issuer, resource_scopes):
+    """The discovery document of OpenID Connect Discovery 1.0, with the device authorization endpoint of RFC 8628;
+    resource_scopes are the scopes of the resources."""
     return {
         'issuer': issuer,
         'authorization_endpoint': f'{issuer}/oidc/authorize',
         'token_endpoint': f'{issuer}/oidc/token',
+        'device_authorization_endpoint': f'{issuer}/oidc/device_authorization',
         'userinfo_endpoint': f'{issuer}/oidc/userinfo',
         'jwks_uri': f'{issuer}/oidc/jwks',
         'end_session_endpoint': f'{issuer}/oidc/logout',
-        'scopes_supported': list(SCOPES),
+        'scopes_supported': [*SCOPES, *resource_scopes],
         'response_types_supported': ['code'],
         'response_modes_supported': ['query'],
-        'grant_types_supported': ['authorization_code', 'refresh_token'],
+        'grant_types_supported': ['authorization_code', 'refresh_token', 'client_credentials', DEVICE_GRANT],
         'subject_types_supported': ['public'],
         'id_token_signing_alg_values_supported': ['RS256'],
-        'token_endpoint_auth_methods_supported': ['client_secret_basic', 'client_secret_post'],
+        'token_endpoint_auth_methods_supported': ['client_secret_basic', 'client_secret_post', 'none'],
         'code_challenge_methods_supported': ['S256'],
-        'claims_supported': ['iss', 'sub', 'aud', 'exp', 'iat', 'auth_time', 'nonce', 'amr', 'at_hash',
-                             *(claim for claims in SCOPE_CLAIMS.values() for claim in claims)],
+        'claims_supported': ['iss', 'sub', 'aud', 'exp', 'iat', 'auth_time', 'nonce', 'amr', 'at_hash', 'client_id',
+                             'scope', 'roles', *(claim for claims in SCOPE_CLAIMS.values() for claim in claims)],
     }
 
 
@@ -159,19 +213,52 @@ def directory():
         connection.unbind_s()
 
 
-def client_of(client_id):
-    """The client of the ID, a namespace of its vpnrouter_users.summary with client_id, when it is an enabled service
-    account with redirect URIs; else None."""
-    if not isinstance(client_id, str):
+def account_of(name):
+    """A namespace of the vpnrouter_users.summary of the service account of the name, else None."""
+    if not isinstance(name, str):
         return None
     with directory() as connection:
         try:
-            user = vpnrouter_users.summary(vpnrouter_users.entry(connection, client_id))
+            user = vpnrouter_users.summary(vpnrouter_users.entry(connection, name))
         except vpnrouter_users.Failure:
             return None
-    if not user['service'] or not user['enabled'] or not user['redirect_uris']:
+    return types.SimpleNamespace(**user) if user['service'] else None
+
+
+def client_of(client_id):
+    """The client of the ID, a namespace of its vpnrouter_users.summary with client_id, when it is an enabled service
+    account with redirect URIs or grants; else None."""
+    account = account_of(client_id)
+    if account is None or not account.enabled or not (account.redirect_uris or account.grants):
         return None
-    return types.SimpleNamespace(client_id=client_id, **user)
+    account.client_id = client_id
+    return account
+
+
+def resource_of(name):
+    """The resource of the name, a namespace of its vpnrouter_users.summary, when it is an enabled service account that
+    is not internal; else None."""
+    account = account_of(name)
+    return account if account is not None and account.enabled and not account.internal else None
+
+
+def resource_scopes():
+    """The scopes of every resource, <resource>:<scope>, sorted."""
+    with directory() as connection:
+        users = vpnrouter_users.list_users(connection)['users']
+    return sorted(f'{user["name"]}:{scope}' for user in users
+                  if user['service'] and user['enabled'] and not user['internal'] for scope in user['resource_scopes'])
+
+
+def account_claims(connection, name):
+    """The summary of the entry of the name and its claims of every scope, with sub; Failure when there is none."""
+    user = vpnrouter_users.summary(vpnrouter_users.entry(connection, name))
+    groups = sorted(vpnrouter_users.groups_of(connection, name))
+    uuid = connection.search_s(vpnrouter_users.dn_of(name), ldap.SCOPE_BASE, attrlist=['entryUUID'])[0][1]['entryUUID']
+    full = ' '.join(part for part in (user['first_name'], user['last_name']) if part)
+    claims = {'sub': uuid[0].decode(), 'preferred_username': name, 'name': full or None, 'given_name': user['first_name'],
+              'family_name': user['last_name'], 'email': user['email'], 'groups': groups}
+    return user, {claim: value for claim, value in claims.items() if value is not None}
 
 
 def subject(name, client):
@@ -179,20 +266,26 @@ def subject(name, client):
     user who is not a service account, a member of one of the client's allowed groups when it has any; else None."""
     with directory() as connection:
         try:
-            attributes = vpnrouter_users.entry(connection, name)
+            user, claims = account_claims(connection, name)
         except vpnrouter_users.Failure:
             return None
-        user = vpnrouter_users.summary(attributes)
-        groups = sorted(vpnrouter_users.groups_of(connection, name))
-        uuid = connection.search_s(vpnrouter_users.dn_of(name), ldap.SCOPE_BASE, attrlist=['entryUUID'])[0][1]['entryUUID']
     if user['service'] or not user['enabled'] or user['locked']:
         return None
-    if client.allowed_groups and not set(client.allowed_groups) & set(groups):
+    if client.allowed_groups and not set(client.allowed_groups) & set(claims['groups']):
         return None
-    full = ' '.join(part for part in (user['first_name'], user['last_name']) if part)
-    claims = {'sub': uuid[0].decode(), 'preferred_username': name, 'name': full or None, 'given_name': user['first_name'],
-              'family_name': user['last_name'], 'email': user['email'], 'groups': groups}
-    return {claim: value for claim, value in claims.items() if value is not None}
+    return claims
+
+
+def service_subject(name):
+    """The claims of every scope of the service account, with sub."""
+    with directory() as connection:
+        return account_claims(connection, name)[1]
+
+
+def roles_at(resource, name):
+    """The roles of the resource the user or service account holds."""
+    with directory() as connection:
+        return vpnrouter_users.roles_held(connection, resource, name)
 
 
 def claims_of(person, scopes):
@@ -201,6 +294,46 @@ def claims_of(person, scopes):
                                      if claim in person}}
 
 
+def target_of(issuer, resource, scopes):
+    """The name of the resource a request with the resource parameter, None when absent, and the scopes names, None
+    for none; InvalidTarget when they name more than one or one that is not a resource."""
+    names = {scope.partition(':')[0] for scope in scopes if scope not in SCOPES}
+    if resource is not None:
+        names.add(resource[len(issuer) + 1:] if isinstance(resource, str) and resource.startswith(f'{issuer}/') else resource)
+    if not names:
+        return None
+    if len(names) > 1:
+        raise InvalidTarget(description='the resource and the scopes name more than one resource')
+    name = names.pop()
+    if resource_of(name) is None:
+        raise InvalidTarget(description=f'{name} is not a resource')
+    return name
+
+
+def scopes_allowed(client, scopes, target, grant_type):
+    """Whether the client may ask for the scopes: openid, required but by client_credentials, which refuses it, the
+    other scopes of SCOPES, and those of its client scopes that belong to the target."""
+    for scope in scopes:
+        if scope not in SCOPES and (scope not in client.client_scopes or scope.partition(':')[0] != target):
+            return False
+    return ('openid' not in scopes) if grant_type == 'client_credentials' else ('openid' in scopes)
+
+
+def same_redirect(registered, given):
+    """Whether the redirect URI given is the registered one; an http URI of a loopback host may have any port (RFC 8252
+    7.3)."""
+    if registered == given:
+        return True
+    try:
+        wanted, found = urllib.parse.urlsplit(registered), urllib.parse.urlsplit(given)
+        # A port that is not a number makes .port raise ValueError.
+        wanted.port, found.port
+    except (ValueError, TypeError, AttributeError):
+        return False
+    return wanted.scheme == 'http' and wanted.hostname in vpnrouter_users.LOOPBACK_HOSTS and not found.fragment and \
+        (wanted.scheme, wanted.hostname, wanted.path, wanted.query) == (found.scheme, found.hostname, found.path, found.query)
+
+
 def cookie_value(cookies):
     """The value of the session cookie in a Cookie header, or ''."""
     try:
@@ -220,11 +353,31 @@ def session_of(cfg, cookies):
     return Session(*row) if row else None
 
 
+def access_token(cfg, request):
+    """The access token of a token request: a JWT of RFC 9068 for the request's target, or the client."""
+    now = int(time.time())
+    client_id = request.client.client_id
+    service = request.grant_type == 'client_credentials'
+    name = client_id if service else request.user
+    person = service_subject(client_id) if service else request.oidc_person
+    target = getattr(request, 'oidc_target', None)
+    claims = {**claims_of(person, request.scopes), 'iss': vpnrouter.oidc_issuer(cfg), 'aud': target or client_id,
+              'client_id': client_id, 'iat': now, 'exp': now + ACCESS_SECONDS, 'jti': secrets.token_urlsafe(16),
+              'scope': ' '.join(request.scopes)}
+    roles = roles_at(target or client_id, name)
+    if roles:
+        claims['roles'] = roles
+    if not service:
+        claims.update({'auth_time': int(request.auth_time.timestamp()), 'amr': request.amr})
+    return sign(claims, {'typ': 'at+jwt'})
+
+
 class Validator(RequestValidator):
     """The checks and the storage of oauthlib's server for the router's clients, users and database.
 
-    Only the authorization code grant with PKCE S256 and the refresh token grant are allowed. The values of a code, a
-    token or a session found are kept on the request as oidc_code, oidc_scopes and oidc_person.
+    The grants are those of validate_grant_type, with PKCE S256 for the authorization code. The values of a code, a
+    token, a device code or a session found are kept on the request as oidc_code, oidc_scopes and oidc_person, the
+    resource the tokens are for as oidc_target.
     """
 
     def __init__(self, cfg):
@@ -243,6 +396,14 @@ class Validator(RequestValidator):
     def session(self, request):
         return session_of(self.cfg, request.headers.get('Cookie'))
 
+    def check_target(self, request, stored):
+        """Refuse a resource parameter that names another resource than the one the grant was made for."""
+        resource = getattr(request, 'resource', None)
+        if 'resource' in request.duplicate_params or \
+                resource is not None and target_of(vpnrouter.oidc_issuer(self.cfg), resource, []) != stored:
+            raise InvalidTarget(description='the grant was made for another resource', request=request)
+        request.oidc_target = stored
+
     # Clients.
 
     def validate_client_id(self, client_id, request, *args, **kwargs):
@@ -250,7 +411,7 @@ class Validator(RequestValidator):
         return request.client is not None
 
     def validate_redirect_uri(self, client_id, redirect_uri, request, *args, **kwargs):
-        return redirect_uri in request.client.redirect_uris
+        return any(same_redirect(uri, redirect_uri) for uri in request.client.redirect_uris)
 
     def get_default_redirect_uri(self, client_id, request, *args, **kwargs):
         return None
@@ -259,17 +420,29 @@ class Validator(RequestValidator):
         return response_type == 'code'
 
     def validate_scopes(self, client_id, scopes, client, request, *args, **kwargs):
-        return 'openid' in scopes and set(scopes) <= set(SCOPES)
+        """Whether the client may ask for the scopes; the resource they are for is kept as oidc_target."""
+        if 'resource' in request.duplicate_params:
+            raise InvalidTarget(description='give one resource', request=request)
+        try:
+            request.oidc_target = target_of(vpnrouter.oidc_issuer(self.cfg), getattr(request, 'resource', None), scopes)
+        except InvalidTarget as error:
+            raise InvalidTarget(description=error.description, request=request)
+        return scopes_allowed(client, scopes, request.oidc_target, request.grant_type)
 
     def get_default_scopes(self, client_id, request, *args, **kwargs):
-        return ['openid']
+        return [] if request.grant_type == 'client_credentials' else ['openid']
 
     def is_pkce_required(self, client_id, request):
         return True
 
+    def client_authentication_required(self, request, *args, **kwargs):
+        """Whether the client must sign the request with its secret: unless it is a public client named by client_id."""
+        client = client_of(request.client_id)
+        return client is None or not client.public_client
+
     def authenticate_client(self, request, *args, **kwargs):
         """Check the client's secret, the password of its service account, given with HTTP Basic authentication, its
-        ID and secret form-encoded (RFC 6749 2.3.1), or in the body."""
+        ID and secret form-encoded (RFC 6749 2.3.1), or in the body; a public client has none."""
         name, secret = request.client_id, request.client_secret
         header = request.headers.get('Authorization', '')
         if header[:6].lower() == 'basic ':
@@ -279,7 +452,7 @@ class Validator(RequestValidator):
                 return False
             name, secret = urllib.parse.unquote_plus(name), urllib.parse.unquote_plus(secret)
         client = client_of(name)
-        if client is None:
+        if client is None or client.public_client:
             return False
         try:
             vpnrouter_users.login(name, secret, None)
@@ -289,10 +462,24 @@ class Validator(RequestValidator):
         return True
 
     def authenticate_client_id(self, client_id, request, *args, **kwargs):
-        return False
+        """Accept a public client by its ID."""
+        client = client_of(client_id)
+        if client is None or not client.public_client:
+            return False
+        request.client = client
+        return True
 
     def validate_grant_type(self, client_id, grant_type, client, request, *args, **kwargs):
-        return grant_type in ('authorization_code', 'refresh_token')
+        """The grants of the client: authorization_code with redirect URIs, client_credentials but for a public client,
+        the device code, and refresh_token with either of the first and the last."""
+        grants = set(client.grants) - ({'client_credentials'} if client.public_client else set())
+        if client.redirect_uris:
+            grants.add('authorization_code')
+        if 'device_code' in grants:
+            grants.add(DEVICE_GRANT)
+        if grants & {'authorization_code', DEVICE_GRANT}:
+            grants.add('refresh_token')
+        return grant_type in grants
 
     def validate_user(self, username, password, client, request, *args, **kwargs):
         return False
@@ -300,15 +487,15 @@ class Validator(RequestValidator):
     # Codes.
 
     def save_authorization_code(self, client_id, code, request, *args, **kwargs):
-        self.call(('CALL oidc_code_save(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)',
+        self.call(('CALL oidc_code_save(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)',
                    (vpnrouter_auth.digest(code['code']), client_id, request.user, request.redirect_uri, request.scopes,
                     request.nonce, request.code_challenge, request.code_challenge_method, request.auth_time, request.amr,
-                    CODE_SECONDS)))
+                    getattr(request, 'oidc_target', None), CODE_SECONDS)))
 
     def code(self, code):
         row = self.fetch('SELECT * FROM oidc_code_get(%s)', (vpnrouter_auth.digest(code),)) if isinstance(code, str) else None
         return dict(zip(('client_id', 'name', 'redirect_uri', 'scopes', 'nonce', 'code_challenge', 'code_challenge_method',
-                         'auth_time', 'amr'), row)) if row else None
+                         'auth_time', 'amr', 'resource'), row)) if row else None
 
     def get_authorization_code_scopes(self, client_id, code, redirect_uri, request):
         found = self.code(code)
@@ -321,6 +508,7 @@ class Validator(RequestValidator):
         person = subject(found['name'], client)
         if person is None:
             return False
+        self.check_target(request, found['resource'])
         request.user, request.scopes, request.auth_time, request.amr = found['name'], found['scopes'], found['auth_time'], found['amr']
         request.oidc_code, request.oidc_person = found, person
         return True
@@ -340,20 +528,53 @@ class Validator(RequestValidator):
     def invalidate_authorization_code(self, client_id, code, request, *args, **kwargs):
         self.call(('CALL oidc_code_delete(%s)', (vpnrouter_auth.digest(code),)))
 
+    # Device codes.
+
+    def poll_device(self, code, request):
+        """Poll the device code for the request's client: with the user's sign-in on the request when the user allowed
+        it, else the error RFC 8628 gives."""
+        row = self.fetch('SELECT * FROM oidc_device_poll(%s)', (vpnrouter_auth.digest(code),)) \
+            if isinstance(code, str) and code else None
+        found = dict(zip(('client_id', 'scopes', 'resource', 'state', 'name', 'auth_time', 'amr', 'expired', 'too_soon'),
+                         row)) if row else None
+        if found is None or found['client_id'] != request.client.client_id:
+            raise InvalidGrantError(description='the device code is unknown', request=request)
+        if found['expired']:
+            raise ExpiredToken(description='the device code has expired', request=request)
+        if found['state'] == 'pending':
+            raise (SlowDown if found['too_soon'] else AuthorizationPending)(request=request)
+        if found['state'] == 'denied':
+            self.call(('CALL oidc_device_delete(%s)', (vpnrouter_auth.digest(code),)))
+            raise AccessDeniedError(description='the user denied the device', request=request)
+        person = subject(found['name'], request.client)
+        if person is None:
+            raise AccessDeniedError(description=f'{found["name"]} may not sign in to this client', request=request)
+        self.check_target(request, found['resource'])
+        request.user, request.scopes, request.auth_time, request.amr = found['name'], found['scopes'], found['auth_time'], found['amr']
+        request.oidc_person = person
+
+    def delete_device(self, code):
+        self.call(('CALL oidc_device_delete(%s)', (vpnrouter_auth.digest(code),)))
+
     # Tokens.
 
     def token(self, token, kind):
         row = self.fetch('SELECT * FROM oidc_token_get(%s, %s)', (vpnrouter_auth.digest(token), kind)) \
             if isinstance(token, str) and token else None
-        return dict(zip(('client_id', 'name', 'scopes', 'auth_time', 'amr'), row)) if row else None
+        return dict(zip(('client_id', 'name', 'scopes', 'auth_time', 'amr', 'resource'), row)) if row else None
 
     def save_bearer_token(self, token, request, *args, **kwargs):
-        """Keep the access token and the refresh token; a refresh token that was exchanged is used up."""
-        values = (request.client.client_id, request.user, request.scopes, request.auth_time, request.amr)
-        statements = [('CALL oidc_token_save(%s, %s, %s, %s, %s, %s, %s, %s)',
+        """Keep the access token and the refresh token; a refresh token that was exchanged is used up. A token of
+        client_credentials is kept for its service account."""
+        if request.grant_type == 'client_credentials':
+            name, auth_time, amr = request.client.client_id, datetime.datetime.now(datetime.timezone.utc), SERVICE_AMR
+        else:
+            name, auth_time, amr = request.user, request.auth_time, request.amr
+        values = (request.client.client_id, name, request.scopes, auth_time, amr, getattr(request, 'oidc_target', None))
+        statements = [('CALL oidc_token_save(%s, %s, %s, %s, %s, %s, %s, %s, %s)',
                        (vpnrouter_auth.digest(token['access_token']), 'access', *values, ACCESS_SECONDS))]
         if token.get('refresh_token'):
-            statements.append(('CALL oidc_token_save(%s, %s, %s, %s, %s, %s, %s, %s)',
+            statements.append(('CALL oidc_token_save(%s, %s, %s, %s, %s, %s, %s, %s, %s)',
                                (vpnrouter_auth.digest(token['refresh_token']), 'refresh', *values, REFRESH_SECONDS)))
         if request.grant_type == 'refresh_token':
             statements.append(('CALL oidc_token_delete(%s)', (vpnrouter_auth.digest(request.refresh_token),)))
@@ -366,6 +587,7 @@ class Validator(RequestValidator):
         person = subject(found['name'], client)
         if person is None:
             return False
+        self.check_target(request, found['resource'])
         request.user, request.auth_time, request.amr = found['name'], found['auth_time'], found['amr']
         request.oidc_scopes, request.oidc_person = found['scopes'], person
         return True
@@ -385,7 +607,9 @@ class Validator(RequestValidator):
         return True
 
     def get_userinfo_claims(self, request):
-        return claims_of(request.oidc_person, request.oidc_scopes)
+        claims = claims_of(request.oidc_person, request.oidc_scopes)
+        roles = roles_at(request.client.client_id, request.user)
+        return {**claims, 'roles': roles} if roles else claims
 
     # OpenID Connect.
 
@@ -394,6 +618,9 @@ class Validator(RequestValidator):
         id_token.update(claims_of(request.oidc_person, request.scopes))
         id_token.update({'iss': vpnrouter.oidc_issuer(self.cfg), 'exp': now + ACCESS_SECONDS,
                          'auth_time': int(request.auth_time.timestamp()), 'amr': request.amr})
+        roles = roles_at(request.client.client_id, request.user)
+        if roles:
+            id_token['roles'] = roles
         return sign(id_token)
 
     def validate_silent_login(self, request):
@@ -417,10 +644,100 @@ class Validator(RequestValidator):
         return person is not None and hint.get('sub') == person['sub']
 
 
-def page(status, cfg, title, message='', error='', form=False, request='', name='', headers=()):
-    """An HTML page of TEMPLATE: a message, an error, and with form the sign-in form for the authorization request."""
+class DeviceCodeGrant(GrantTypeBase):
+    """The token request of the device authorization grant (RFC 8628): a device code the user allowed gives an access
+    token, a refresh token and, with openid, an ID token; until then the request is answered authorization_pending or
+    slow_down."""
+
+    def create_token_response(self, request, token_handler):
+        headers = self._get_default_headers()
+        try:
+            self.validate_token_request(request)
+        except OAuth2Error as error:
+            headers.update(error.headers)
+            return headers, error.json, error.status_code
+        token = token_handler.create_token(request, refresh_token=True)
+        if 'openid' in request.scopes:
+            token['id_token'] = self.request_validator.finalize_id_token(
+                {'aud': request.client.client_id, 'iat': int(time.time())}, token, token_handler, request)
+        self.request_validator.save_token(token, request)
+        self.request_validator.delete_device(request.device_code)
+        return headers, json.dumps(token), 200
+
+    def validate_token_request(self, request):
+        if request.grant_type != DEVICE_GRANT:
+            raise UnsupportedGrantTypeError(request=request)
+        for param in ('grant_type', 'device_code'):
+            if param in request.duplicate_params:
+                raise InvalidRequestError(description=f'Duplicate {param} parameter.', request=request)
+        request.device_code = getattr(request, 'device_code', None)
+        if not request.device_code:
+            raise InvalidRequestError(description='Missing device_code parameter.', request=request)
+        if self.request_validator.client_authentication_required(request):
+            if not self.request_validator.authenticate_client(request):
+                raise InvalidClientError(request=request)
+        elif not self.request_validator.authenticate_client_id(request.client_id, request):
+            raise InvalidClientError(request=request)
+        self.validate_grant_type(request)
+        self.request_validator.poll_device(request.device_code, request)
+
+
+def user_code_of(value):
+    """The user code a user typed, without the dash and spaces, in capitals; '' when it is not one."""
+    code = ''.join(character for character in (value or '').upper() if character.isalnum())
+    return code if len(code) == USER_CODE_LENGTH and all(character in USER_CODE_LETTERS for character in code) else ''
+
+
+def device_authorization(validator, cfg, text, headers):
+    """Answer a device authorization request (RFC 8628 3.1): the client, public by client_id or confidential with its
+    secret, with the device_code grant, the scopes and the resource; the device code, the user code and the
+    verification URIs."""
+    issuer = vpnrouter.oidc_issuer(cfg)
+    request = Request(f'{issuer}/oidc/device_authorization', 'POST', text, headers)
+    for param in ('scope', 'resource'):
+        if param in request.duplicate_params:
+            raise InvalidRequestError(description=f'Duplicate {param} parameter.', request=request)
+    if validator.client_authentication_required(request):
+        if not validator.authenticate_client(request):
+            raise InvalidClientError(request=request)
+    elif not validator.authenticate_client_id(request.client_id, request):
+        raise InvalidClientError(request=request)
+    if not validator.validate_grant_type(request.client.client_id, DEVICE_GRANT, request.client, request):
+        raise UnauthorizedClientError(description='the client may not use the device authorization grant', request=request)
+    scopes = utils.scope_to_list(request.scope) or ['openid']
+    target = target_of(issuer, getattr(request, 'resource', None), scopes)
+    if not scopes_allowed(request.client, scopes, target, DEVICE_GRANT):
+        raise InvalidScopeError(description='the client may not ask for these scopes; openid is required', request=request)
+    device_code = secrets.token_urlsafe(32)
+    user_code = ''.join(secrets.choice(USER_CODE_LETTERS) for _ in range(USER_CODE_LENGTH))
+    with vpnrouter_auth.database(cfg) as connection:
+        connection.execute('CALL oidc_device_save(%s, %s, %s, %s, %s, %s, %s)',
+                           (vpnrouter_auth.digest(device_code), vpnrouter_auth.digest(user_code), request.client.client_id,
+                            scopes, target, DEVICE_INTERVAL, DEVICE_SECONDS))
+    shown = f'{user_code[:USER_CODE_LENGTH // 2]}-{user_code[USER_CODE_LENGTH // 2:]}'
+    return document(200, {'device_code': device_code, 'user_code': shown, 'verification_uri': f'{issuer}/oidc/device',
+                          'verification_uri_complete': f'{issuer}/oidc/device?' + urllib.parse.urlencode({'user_code': shown}),
+                          'expires_in': DEVICE_SECONDS, 'interval': DEVICE_INTERVAL})
+
+
+def device_of(cfg, user_code):
+    """The waiting device code of a user code, {client_id, scopes, resource}, or None."""
+    code = user_code_of(user_code)
+    if not code:
+        return None
+    with vpnrouter_auth.database(cfg) as connection:
+        row = connection.execute('SELECT * FROM oidc_device_find(%s)', (vpnrouter_auth.digest(code),)).fetchone()
+    return dict(zip(('client_id', 'scopes', 'resource'), row)) if row else None
+
+
+def page(status, cfg, title, message='', error='', form=False, request='', name='', headers=(), action='/oidc/login',
+         device=False, user_code='', decide=False, items=()):
+    """An HTML page of TEMPLATE: a message, an error and items; with form the sign-in form, posted to action with the
+    authorization request, or with device the user code field, with or without the sign-in fields; with decide the
+    Allow and Deny buttons of the device of the user code."""
     body = _pages.get_template(TEMPLATE).render(title=title, message=message, error=error, form=form, request=request,
-                                                name=name, issuer=vpnrouter.oidc_issuer(cfg))
+                                                name=name, issuer=vpnrouter.oidc_issuer(cfg), action=action, device=device,
+                                                user_code=user_code, decide=decide, items=list(items))
     return status, 'text/html; charset=utf-8', body.encode(), [*PAGE_HEADERS, *headers]
 
 
@@ -443,6 +760,30 @@ def cookie(value, seconds):
     return 'Set-Cookie', f'{COOKIE}={value}; Path=/oidc/; Max-Age={seconds}; Secure; HttpOnly; SameSite=Lax'
 
 
+def sign_in(form):
+    """The name and the amr of a sign-in with the form's name, password and code, or its passkey; Failure when it is
+    refused, ValueError when the passkey's answer is not JSON."""
+    if form.get('passkey_id'):
+        with vpnrouter_users.session() as connection:
+            name = vpnrouter_passkeys.login_complete(connection, form['passkey_id'], json.loads(form.get('credential', '')))
+        return name, PASSKEY_AMR
+    name, code = form.get('name', '').strip(), form.get('code', '').strip()
+    vpnrouter_users.login(name, form.get('password', ''), code or None)
+    with directory() as connection:
+        if vpnrouter_users.service(vpnrouter_users.entry(connection, name)):
+            raise vpnrouter_users.Failure('the name, the password or the code is wrong', 5)
+    return name, OTP_AMR if code else PASSWORD_AMR
+
+
+def start_session(cfg, name, amr):
+    """Start a session of the user: a namespace of the Session and the header that sets its cookie."""
+    value = secrets.token_urlsafe(32)
+    with vpnrouter_auth.database(cfg) as connection:
+        connection.execute('CALL oidc_session_save(%s, %s, %s, %s)', (vpnrouter_auth.digest(value), name, amr, SESSION_SECONDS))
+    return types.SimpleNamespace(session=Session(name, datetime.datetime.now(datetime.timezone.utc), amr),
+                                 cookie=cookie(value, SESSION_SECONDS))
+
+
 def authorize(server, cfg, params, headers, fresh=None, name='', error=''):
     """Answer an authorization request, the query or the form params: the sign-in page while the browser has no
     session, or with prompt=login or max_age older than the session, else a redirect to the client with a code.
@@ -491,27 +832,72 @@ def login(server, cfg, form, headers):
     params = form.get('request', '')
     name = form.get('name', '').strip()
     try:
-        if form.get('passkey_id'):
-            with vpnrouter_users.session() as connection:
-                name = vpnrouter_passkeys.login_complete(connection, form['passkey_id'], json.loads(form.get('credential', '')))
-            amr = PASSKEY_AMR
-        else:
-            code = form.get('code', '').strip()
-            vpnrouter_users.login(name, form.get('password', ''), code or None)
-            with directory() as connection:
-                if vpnrouter_users.service(vpnrouter_users.entry(connection, name)):
-                    raise vpnrouter_users.Failure('the name, the password or the code is wrong', 5)
-            amr = OTP_AMR if code else PASSWORD_AMR
+        name, amr = sign_in(form)
     except vpnrouter_users.Failure as failure:
         return authorize(server, cfg, params, headers, name=name, error=str(failure))
     except ValueError:
         return authorize(server, cfg, params, headers, name=name, error='the passkey is not accepted')
-    value = secrets.token_urlsafe(32)
+    return authorize(server, cfg, params, headers, fresh=start_session(cfg, name, amr))
+
+
+def device_page(cfg, status=200, signed_in=False, user_code='', name='', error='', headers=()):
+    """The page where the user enters the user code of a device, with the sign-in fields unless signed_in."""
+    return page(status, cfg, 'Sign in on a device', message='Enter the code the device shows.', error=error,
+                form=not signed_in, name=name, headers=headers, action='/oidc/device', device=True, user_code=user_code)
+
+
+def device(cfg, form, headers):
+    """The device page's form: sign in when the browser has no session, then ask the user to allow the device of the
+    user code."""
+    user_code, fresh = form.get('user_code', ''), None
+    session = session_of(cfg, headers.get('Cookie'))
+    if session is None:
+        try:
+            name, amr = sign_in(form)
+        except vpnrouter_users.Failure as failure:
+            return device_page(cfg, 401, user_code=user_code, name=form.get('name', '').strip(), error=str(failure))
+        except ValueError:
+            return device_page(cfg, 401, user_code=user_code, name=form.get('name', '').strip(),
+                               error='the passkey is not accepted')
+        fresh = start_session(cfg, name, amr)
+        session = fresh.session
+    extra = [fresh.cookie] if fresh else []
+    found = device_of(cfg, user_code)
+    client = client_of(found['client_id']) if found else None
+    if client is None:
+        return device_page(cfg, 400, signed_in=True, user_code=user_code, error='the code is wrong or has expired',
+                           headers=extra)
+    shown = client.display_name or client.client_id
+    if subject(session.name, client) is None:
+        return device_page(cfg, 403, signed_in=True, user_code=user_code, headers=extra,
+                           error=f'{session.name} may not sign in to {shown}')
+    items = ([f'resource: {found["resource"]}'] if found['resource'] else []) + [f'scope: {scope}' for scope in found['scopes']]
+    return page(200, cfg, f'Allow {shown}?', message=f'{shown} asks to sign in as {session.name} on a device.',
+                items=items, decide=True, user_code=user_code_of(user_code), headers=extra)
+
+
+def decide(cfg, form, headers):
+    """Allow or deny the device of the user code as the user of the session."""
+    session = session_of(cfg, headers.get('Cookie'))
+    if session is None:
+        return device_page(cfg, 401, user_code=form.get('user_code', ''), error='sign in first')
+    found = device_of(cfg, form.get('user_code', ''))
+    client = client_of(found['client_id']) if found else None
+    if client is None or subject(session.name, client) is None:
+        return device_page(cfg, 400, signed_in=True, user_code=form.get('user_code', ''),
+                           error='the code is wrong or has expired')
+    allowed = form.get('decision') == 'allow'
     with vpnrouter_auth.database(cfg) as connection:
-        connection.execute('CALL oidc_session_save(%s, %s, %s, %s)', (vpnrouter_auth.digest(value), name, amr, SESSION_SECONDS))
-    fresh = types.SimpleNamespace(session=Session(name, datetime.datetime.now(datetime.timezone.utc), amr),
-                                  cookie=cookie(value, SESSION_SECONDS))
-    return authorize(server, cfg, params, headers, fresh=fresh)
+        decided = connection.execute('SELECT oidc_device_decide(%s, %s, %s, %s, %s)',
+                                     (vpnrouter_auth.digest(user_code_of(form['user_code'])), session.name,
+                                      session.auth_time, session.amr, allowed)).fetchone()[0]
+    if not decided:
+        return device_page(cfg, 400, signed_in=True, error='the code is wrong or has expired')
+    shown = client.display_name or client.client_id
+    if allowed:
+        return page(200, cfg, 'The device is signed in', message=f'{shown} is signed in as {session.name}. You can return '
+                                                                  'to the device.')
+    return page(200, cfg, 'The device is denied', message=f'{shown} is not signed in.')
 
 
 def logout(cfg, query, headers):
@@ -552,9 +938,12 @@ def answer(method, target, headers, body):
         issuer = vpnrouter.oidc_issuer(cfg)
         headers = dict(headers.items())
         text = body.decode('utf-8', 'replace') if body else ''
-        server = Server(Validator(cfg), token_expires_in=ACCESS_SECONDS)
+        validator = Validator(cfg)
+        server = Server(validator, token_expires_in=ACCESS_SECONDS, token_generator=lambda request: access_token(cfg, request),
+                        refresh_token_generator=random_token_generator)
+        server.grant_types[DEVICE_GRANT] = DeviceCodeGrant(validator)
         if (method, path) == ('GET', '/.well-known/openid-configuration'):
-            return document(200, discovery(issuer))
+            return document(200, discovery(issuer, resource_scopes()))
         if (method, path) == ('GET', '/oidc/jwks'):
             return document(200, {'keys': [public_jwk(private_key())]})
         if path == '/oidc/authorize' and method in ('GET', 'POST'):
@@ -565,6 +954,15 @@ def answer(method, target, headers, body):
             return document(200, vpnrouter_passkeys.login_begin())
         if (method, path) == ('POST', '/oidc/token'):
             return relayed(*server.create_token_response(f'{issuer}{path}', 'POST', text, headers))
+        if (method, path) == ('POST', '/oidc/device_authorization'):
+            return device_authorization(validator, cfg, text, headers)
+        if (method, path) == ('GET', '/oidc/device'):
+            signed_in = session_of(cfg, headers.get('Cookie')) is not None
+            return device_page(cfg, signed_in=signed_in, user_code=dict(urllib.parse.parse_qsl(query)).get('user_code', ''))
+        if (method, path) == ('POST', '/oidc/device'):
+            return device(cfg, dict(urllib.parse.parse_qsl(text)), headers)
+        if (method, path) == ('POST', '/oidc/device/decide'):
+            return decide(cfg, dict(urllib.parse.parse_qsl(text)), headers)
         if path == '/oidc/userinfo' and method in ('GET', 'POST'):
             return relayed(*server.create_userinfo_response(f'{issuer}{target}', method, text or None, headers))
         if (method, path) == ('GET', '/oidc/logout'):

debian-package/src/usr/lib/vpn-router/vpnrouter_passkeys.py

@@ -1,5 +1,5 @@
 """The passkeys of the router's users, for signing in to the Router Manager and the OpenID Provider (vpnrouter_oidc),
-with python3-fido2.
+and for opening a shell, with python3-fido2.
 
 A passkey is a discoverable WebAuthn credential with user verification, of the relying party
 wan.local_fqdn, so the browser offers it at the HTTPS addresses on that name.
@@ -8,10 +8,11 @@ user entry: a JSON object {"id", "credential", "label", "created"}, id the crede
 credential the attested credential data (with the public key), both base64url. A user has at
 most PASSKEYS_MAX passkeys; service accounts have none.
 
-Registration and sign-in are two steps each: begin answers the options for the browser and a
-pending id, whose state the web service keeps in memory for PENDING_SECONDS; complete takes the
-id and the browser's answer. A request that cannot be done raises vpnrouter_users.Failure, with
-the statuses of that module; a sign-in that fails gives status 5 whatever the reason.
+Registration, sign-in and the proof of a signed-in user for a shell are two steps each: begin
+answers the options for the browser and a pending id, whose state the web service keeps in memory
+for PENDING_SECONDS; complete takes the id and the browser's answer. A request that cannot be done
+raises vpnrouter_users.Failure, with the statuses of that module; a sign-in or a proof that fails
+gives status 5 whatever the reason.
 """
 
 import json
@@ -172,3 +173,30 @@ def login_complete(connection, pending, response):
     except (ValueError, KeyError, TypeError):
         raise refused
     return name
+
+
+def shell_begin(connection, name):
+    """Begin the proof of the signed-in user for a shell: {"id", "options"}, options those of navigator.credentials.get
+    for the user's own passkeys, with user verification."""
+    own = credentials(vpnrouter_users.entry(connection, name))
+    if not own:
+        raise vpnrouter_users.Failure(f'{name} has no passkey; add one on the Account page', 2)
+    options, state = server().authenticate_begin(own, user_verification=UserVerificationRequirement.REQUIRED)
+    return {'id': keep('shell', name, state), 'options': dict(options)}
+
+
+def shell_complete(connection, name, pending, response):
+    """Check the browser's answer to a begun proof of the user for a shell: one of the user's own passkeys, with the
+    user verified, while the user is enabled and not locked."""
+    refused = vpnrouter_users.Failure('the passkey is not accepted', 5)
+    state = take('shell', name, pending)
+    if state is None or not isinstance(response, dict):
+        raise refused
+    current = vpnrouter_users.entry(connection, name)
+    user = vpnrouter_users.summary(current)
+    if not user['enabled'] or user['locked']:
+        raise refused
+    try:
+        server().authenticate_complete(state, credentials(current), response)
+    except (ValueError, KeyError, TypeError):
+        raise refused

debian-package/src/usr/lib/vpn-router/vpnrouter_serve.py

@@ -4,6 +4,7 @@ Only the Python standard library is used, so the bootstrap server, which must ru
 is broken, can use it.
 """
 
+import sys
 import threading
 import time
 from http.server import ThreadingHTTPServer
@@ -14,9 +15,21 @@ def serve(wanted, handler, log, interval):
 
     wanted answers ([(address, port), ...], '') or ([], the reason not to listen). A server whose
     place is no longer wanted is stopped, and a new one listens at each new place; a place that
-    cannot be bound is tried again the next round. Every new message is logged with log. Does
-    not return.
+    cannot be bound is tried again the next round. Every new message is logged with log. A request
+    whose client went away is not logged; any other exception a request, a thread or the process
+    does not handle is logged with log in one line, without a traceback. Does not return.
     """
+    def failed(request, client_address):
+        failure = sys.exc_info()[1]
+        if not isinstance(failure, ConnectionError):
+            log(f'a request from {client_address[0]} failed: {type(failure).__name__}: {failure}')
+
+    def thread_failed(hook):
+        if not issubclass(hook.exc_type, (SystemExit, ConnectionError)):
+            log(f'{hook.thread.name if hook.thread else "a thread"} failed: {hook.exc_type.__name__}: {hook.exc_value}')
+
+    threading.excepthook = thread_failed
+    sys.excepthook = lambda kind, value, _: log(f'failed: {kind.__name__}: {value}')
     servers, reported = {}, None
     while True:
         targets, reason = wanted()
@@ -34,6 +47,7 @@ def serve(wanted, handler, log, interval):
             except OSError as exc:
                 messages.append(f'cannot listen on {target[0]}:{target[1]}: {exc}')
                 continue
+            server.handle_error = failed
             thread = threading.Thread(target=server.serve_forever, name=f'server {target[0]}', daemon=True)
             thread.start()
             servers[target] = (server, thread)

debian-package/src/usr/lib/vpn-router/vpnrouter_sites.py

@@ -7,7 +7,11 @@ Caddy answers on its port (hosts, the names TLS clients send as SNI; none answer
 firewall opens the port (listen), and TLS: none (plain HTTP), acme (a certificate of Let's Encrypt), ca (certificates
 Caddy issues with one of pki.issuing_cas) or file (a certificate and key given with the site). Caddy serves the files of
 the folder, index_file for a folder, and with spa index_file of the site for any path without a file. editors names
-the group whose members change the site's files besides the admins, through the web service and WebDAV.
+the group whose members change the site's files besides the admins, through the web service and WebDAV. dns says who
+serves the records of its host names: user, a DNS provider outside the router, or router, the router's name server,
+which gives each of them in the closest of its domains an A or AAAA record of the router's address of dns_address:
+public (wan.public_address), internal or external. A site may use wan.local_fqdn, on a port of its own; its record
+stays where the domain of wan.local_fqdn is.
 
 The sites are served while sites.enabled is true; vpn-router-setup writes Caddy's configuration and opens the ports. A
 site is changed only through this module, which checks it (check), and its callers then restart vpn-router-setup.
@@ -55,6 +59,11 @@ INDEX = re.compile(r'^[A-Za-z0-9_-][A-Za-z0-9._-]{0,63}$')
 LISTEN = vpnrouter.LISTEN_CHOICES
 TLS = ('none', 'acme', 'ca', 'file')
 
+#: Who serves the records of a site's host names: user, elsewhere, or router, the router's name server, with the
+#: router's address of DNS_ADDRESSES.
+DNS = ('user', 'router')
+DNS_ADDRESSES = ('public', 'internal', 'external')
+
 #: The most host names of one site.
 HOSTS_MAX = 16
 
@@ -66,7 +75,8 @@ CHUNK = 65536
 
 #: The settings of a site and their defaults; the type of a default is the required type.
 SETTINGS = {'enabled': True, 'hosts': [], 'port': 443, 'listen': 'external', 'tls': 'acme', 'ca': '', 'certificate': '',
-            'private_key': '', 'index_file': 'index.html', 'spa': False, 'editors': ''}
+            'private_key': '', 'index_file': 'index.html', 'spa': False, 'editors': '', 'dns': 'user',
+            'dns_address': 'public'}
 
 #: Whether this process has loaded SITES_SQL.
 _loaded = False
@@ -215,8 +225,17 @@ def check(cfg, sites, site):
     for host in hosts:
         if not (vpnrouter_pki.DNS_NAME.match(host) or vpnrouter_pki.is_address(host)):
             raise Failure(f'hosts: {host!r} is not a host name in lowercase or an IP address', 2)
-        if host == cfg['wan']['local_fqdn'].strip():
-            raise Failure(f'hosts: {host} is wan.local_fqdn, the name of the router\'s own services', 2)
+    if site['dns'] not in DNS:
+        raise Failure(f'dns: {site["dns"]!r} is not one of {", ".join(DNS)}', 2)
+    if site['dns_address'] not in DNS_ADDRESSES:
+        raise Failure(f'dns_address: {site["dns_address"]!r} is not one of {", ".join(DNS_ADDRESSES)}', 2)
+    if site['dns'] == 'router':
+        local_fqdn = cfg['wan']['local_fqdn'].strip()
+        if any(vpnrouter_pki.is_address(host) or host.startswith('*.') or host == local_fqdn for host in hosts):
+            raise Failure('dns router takes host names only, without wildcards and other than wan.local_fqdn, whose '
+                          'record is kept where its domain is', 2)
+        if site['dns_address'] == 'public' and not cfg['wan']['public_address'].strip():
+            raise Failure('dns_address public needs wan.public_address', 2)
     port = site['port']
     if not 1 <= port <= 65535:
         raise Failure(f'port: {port} is not a port', 2)
@@ -285,7 +304,7 @@ def save(cfg, name, values, create):
         if site['tls'] != 'ca':
             site['ca'] = ''
         check(cfg, rows, site)
-        connection.execute('CALL site_put(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)',
+        connection.execute(f'CALL site_put({", ".join(["%s"] * (len(SETTINGS) + 1))})',
                            tuple(site[key] for key in ('name', *SETTINGS)))
         ensure_folders([name])
         return shown(get(connection, name))

debian-package/src/usr/lib/vpn-router/vpnrouter_users.py

@@ -15,10 +15,18 @@ internal service accounts are those the router creates and manages for its own s
 included (internal_accounts); vpn-router-setup keeps the metrics service's.
 Users exist whether or not a P2S system is enabled.
 
-A service account with redirect URIs is a client of the OpenID Provider (vpnrouter_oidc), its name the client ID and
-its password the client secret (client_settings): redirect_uris, where the provider sends a user back after a sign-in,
-post_logout_redirect_uris, after a sign-out, and allowed_groups, the groups whose members may sign in to it, every
-user who is not a service account when there are none.
+A service account with redirect URIs or grants is a client of the OpenID Provider (vpnrouter_oidc), its name the
+client ID and its password the client secret (client_settings): redirect_uris, where the provider sends a user back
+after a sign-in, post_logout_redirect_uris, after a sign-out, allowed_groups, the groups whose members may sign in to it,
+every user who is not a service account when there are none, grants, those of GRANTS it may use besides the
+authorization code, public_client, whether it signs no request with its secret, which a client with client_credentials
+must, and client_scopes, the scopes of resources it may ask for, as <resource>:<scope>.
+
+A service account is also a resource of the OpenID Provider, the audience of the tokens issued for it: resource_scopes
+are the scopes it defines, and its roles (roles_of_resource) are entries cn=<resource>:<role> of vpnrouter_ldap.ROLES
+whose members are the groups and accounts the role is assigned to. A scope a client may ask for cannot be removed, nor
+the resource while a client may ask for its scopes; removing an account removes its roles and takes it out of the
+others, and removing or renaming a group does the same in the roles.
 
 A group is a groupOfNames in ou=groups with a name, which follows the rules of user names, an
 optional description and at least one member; a group cannot be empty, so the last member
@@ -105,9 +113,20 @@ LABELS = (('display_name', 'displayName'), ('description', 'description'))
 ATTRIBUTES = ['uid', 'objectClass', 'pwdAccountLockedTime', 'givenName', 'sn', 'mail', 'oathTOTPToken', 'vpnRouterScope',
               'displayName', 'description', 'userCertificate;binary', 'vpnRouterConsoleLogin', 'vpnRouterConsoleAccount',
               'uidNumber', 'vpnRouterWireGuardPeer', 'vpnRouterPasskey', 'vpnRouterRedirectUri',
-              'vpnRouterPostLogoutRedirectUri', 'vpnRouterAllowedGroup']
+              'vpnRouterPostLogoutRedirectUri', 'vpnRouterAllowedGroup', 'vpnRouterGrantType', 'vpnRouterPublicClient',
+              'vpnRouterClientScope', 'vpnRouterResourceScope']
+#: The grants an OpenID Provider client may have besides the authorization code, which its redirect URIs give it.
+GRANTS = ('client_credentials', 'device_code')
+#: The name of a role of a resource, and of a scope a resource defines.
+ROLE_NAME = re.compile(r'^[A-Za-z][A-Za-z0-9._-]{0,63}$')
+SCOPE_NAME = re.compile(r'^[a-z][a-z0-9._-]{0,63}$')
+#: The attributes read for a role.
+ROLE_ATTRIBUTES = ['cn', 'description', 'member']
 #: The keys of the URIs of an OpenID Provider client and their LDAP attributes.
 CLIENT_URIS = (('redirect_uris', 'vpnRouterRedirectUri'), ('post_logout_redirect_uris', 'vpnRouterPostLogoutRedirectUri'))
+#: The keys of the OpenID Provider settings of a service account (client_settings, and roles of set_roles).
+CLIENT_KEYS = ('redirect_uris', 'post_logout_redirect_uris', 'allowed_groups', 'grants', 'public_client', 'client_scopes',
+               'resource_scopes', 'roles')
 #: The most URIs of each kind and allowed groups of one client, and the longest URI.
 CLIENT_VALUES_MAX = 16
 URI_MAX = 1024
@@ -218,11 +237,13 @@ def labels(values):
 
 
 def client_settings(connection, values):
-    """The OpenID Provider client settings of a service account in values ({redirect_uris, post_logout_redirect_uris,
-    allowed_groups}), checked, as {LDAP attribute: [value, ...]}; a key whose value is None is not given, [] means none.
+    """The OpenID Provider settings of a service account in values ({redirect_uris, post_logout_redirect_uris,
+    allowed_groups, grants, public_client, client_scopes, resource_scopes}), checked, as {LDAP attribute: [value, ...]};
+    a key whose value is None is not given, [] or false means none.
 
-    A URI is absolute, has no fragment and uses https, or http for a host of LOOPBACK_HOSTS; an allowed group exists. Each
-    list has at most CLIENT_VALUES_MAX values.
+    A URI is absolute, has no fragment and uses https, or http for a host of LOOPBACK_HOSTS; an allowed group exists; a
+    grant is one of GRANTS; a client scope is a scope of a resource, <resource>:<scope>; a resource scope is a
+    SCOPE_NAME. Each list has at most CLIENT_VALUES_MAX values.
     """
     found = {}
     for key, attribute in CLIENT_URIS:
@@ -249,13 +270,68 @@ def client_settings(connection, values):
         for group in allowed:
             group_entry(connection, group)
         found['vpnRouterAllowedGroup'] = [group_dn(group).encode() for group in sorted(set(allowed))]
+    grants = values.get('grants')
+    if grants is not None:
+        if not isinstance(grants, list) or not all(isinstance(grant, str) and grant in GRANTS for grant in grants):
+            raise Failure(f'grants must be a list of {", ".join(GRANTS)}', 2)
+        found['vpnRouterGrantType'] = [grant.encode() for grant in GRANTS if grant in grants]
+    public = values.get('public_client')
+    if public is not None:
+        if not isinstance(public, bool):
+            raise Failure('public_client must be true or false', 2)
+        found['vpnRouterPublicClient'] = [b'TRUE'] if public else []
+    scopes = values.get('client_scopes')
+    if scopes is not None:
+        if not isinstance(scopes, list) or len(scopes) > CLIENT_VALUES_MAX or not all(isinstance(scope, str) for scope in scopes):
+            raise Failure(f'client_scopes must be a list of at most {CLIENT_VALUES_MAX} scopes', 2)
+        for scope in scopes:
+            resource, _, name = scope.partition(':')
+            if name not in resource_scopes(connection, resource):
+                raise Failure(f'{scope!r} is not a scope of a resource, <resource>:<scope>', 2)
+        found['vpnRouterClientScope'] = [scope.encode() for scope in sorted(set(scopes))]
+    defined = values.get('resource_scopes')
+    if defined is not None:
+        if not isinstance(defined, list) or len(defined) > CLIENT_VALUES_MAX or \
+                not all(isinstance(scope, str) and SCOPE_NAME.match(scope) for scope in defined):
+            raise Failure(f'resource_scopes must be a list of at most {CLIENT_VALUES_MAX} scope names: lowercase letters, '
+                          'digits, dots, underscores and hyphens, starting with a letter, at most 64', 2)
+        found['vpnRouterResourceScope'] = [scope.encode() for scope in sorted(set(defined))]
     return found
 
 
 def refuse_client_settings(name, values):
-    """Refuse OpenID Provider client settings for a user who is not a service account."""
-    if any(values.get(key) is not None for key in ('redirect_uris', 'post_logout_redirect_uris', 'allowed_groups')):
-        raise Failure(f'{name} is not a service account; only a service account is a client of the OpenID Provider', 2)
+    """Refuse OpenID Provider settings for a user who is not a service account."""
+    if any(values.get(key) is not None for key in CLIENT_KEYS):
+        raise Failure(f'{name} is not a service account; only a service account is a client or a resource of the OpenID '
+                      'Provider', 2)
+
+
+def check_client(name, current, changes):
+    """Refuse the client settings an entry's attributes would have with changes ({LDAP attribute: [value, ...]}) when the
+    client is public and has client_credentials, which needs its secret."""
+    merged = {**current, **changes}
+    if merged.get('vpnRouterPublicClient') == [b'TRUE'] and b'client_credentials' in merged.get('vpnRouterGrantType', []):
+        raise Failure(f'{name}: a public client has no secret, so it cannot use client_credentials', 2)
+
+
+def resource_scopes(connection, name):
+    """The scopes the service account defines as a resource, [] when the name is not that of a service account."""
+    if not isinstance(name, str) or not (NAME.match(name) or GUID.match(name)):
+        return []
+    try:
+        attributes = entry(connection, name)
+    except Failure:
+        return []
+    return [value.decode() for value in attributes.get('vpnRouterResourceScope', [])] if service(attributes) else []
+
+
+def asking(connection, scopes):
+    """The names of the clients whose client scopes have any of the scopes, <resource>:<scope>, sorted."""
+    if not scopes:
+        return []
+    condition = ''.join(f'(vpnRouterClientScope={ldap.filter.escape_filter_chars(scope)})' for scope in scopes)
+    found = connection.search_s(vpnrouter_ldap.USERS, ldap.SCOPE_ONELEVEL, f'(|{condition})', ['uid'])
+    return sorted(attributes['uid'][0].decode() for _, attributes in found)
 
 
 def dn_of(name):
@@ -310,7 +386,7 @@ def summary(attributes):
     """A user as the answers show it; a person attribute or a label the entry does not have is None.
 
     internal is whether it is an internal service account (internal_accounts). A service account also has its OpenID
-    Provider client settings (client_settings), allowed_groups as group names.
+    Provider settings (client_settings), allowed_groups as group names; with_roles adds its roles.
     """
     name = attributes['uid'][0].decode()
     lock = attributes.get('pwdAccountLockedTime', [None])[0]
@@ -336,9 +412,18 @@ def summary(attributes):
         suffix = f',{vpnrouter_ldap.GROUPS}'
         user['allowed_groups'] = sorted(value.decode()[3:-len(suffix)] for value in attributes.get('vpnRouterAllowedGroup', [])
                                         if value.decode().startswith('cn=') and value.decode().endswith(suffix))
+        user['grants'] = [value.decode() for value in attributes.get('vpnRouterGrantType', [])]
+        user['public_client'] = attributes.get('vpnRouterPublicClient') == [b'TRUE']
+        user['client_scopes'] = [value.decode() for value in attributes.get('vpnRouterClientScope', [])]
+        user['resource_scopes'] = [value.decode() for value in attributes.get('vpnRouterResourceScope', [])]
     return user
 
 
+def with_roles(connection, user):
+    """The summary of a service account with roles, its roles as a resource (roles_of_resource)."""
+    return {**user, 'roles': roles_of_resource(connection, user['name'])}
+
+
 def console_of(attributes):
     """The console login of an entry as the answers show it: None when it was never set, else {enabled, account, local,
     uid}: account the system account the console runs as, the local one of vpnRouterConsoleAccount (local true) or the
@@ -536,8 +621,8 @@ def list_users(connection):
 def add(connection, name, password, values, service=False):
     """Add a user: a VPN user with its certificate when values gives all three person attributes, a Manager-only account
     with at most the e-mail address when it gives neither name, and, with service, a service account, with at most the
-    e-mail address, its labels (labels) and its OpenID Provider client settings (client_settings); only a service
-    account may be named by a GUID."""
+    e-mail address, its labels (labels), its OpenID Provider settings (client_settings) and its roles (set_roles); only
+    a service account may be named by a GUID."""
     check_name(name, service)
     details = person(values, required=False)
     vpn_user = 'givenName' in details or 'sn' in details
@@ -547,6 +632,9 @@ def add(connection, name, password, values, service=False):
     if service:
         details.update({attribute: value for attribute, value in labels(values).items() if value})
         client = {attribute: found for attribute, found in client_settings(connection, values).items() if found}
+        check_client(name, {}, client)
+        if values.get('roles') is not None:
+            checked_roles(connection, values['roles'])
     else:
         refuse_client_settings(name, values)
     if vpn_user and len(details) != len(PERSON):
@@ -574,6 +662,10 @@ def add(connection, name, password, values, service=False):
             vpnrouter_pki.issue_user(vpnrouter.load_config(), name, details['mail'])
         except vpnrouter_pki.Failure as failure:
             raise Failure(f'the certificate cannot be issued: {failure}', failure.status)
+    if service:
+        if values.get('roles') is not None:
+            set_roles(connection, name, values['roles'])
+        return with_roles(connection, summary(entry(connection, name)))
     return summary(entry(connection, name))
 
 
@@ -628,20 +720,37 @@ def apply_wireguard():
 
 
 def update_service(connection, name, values):
-    """Change any of the e-mail address, the labels (labels) and the OpenID Provider client settings (client_settings) of
-    a service account that values gives; '' removes the e-mail address or a label, [] the values of a client setting."""
-    if not service(entry(connection, name)):
+    """Change any of the e-mail address, the labels (labels), the OpenID Provider settings (client_settings) and the
+    roles (set_roles) of a service account that values gives; '' removes the e-mail address or a label, [] the values
+    of a setting. A resource scope a client may ask for is not removed."""
+    current = entry(connection, name)
+    if not service(current):
         raise Failure(f'{name} is not a service account', 3)
+    settings = client_settings(connection, values)
+    check_client(name, current, settings)
+    if 'vpnRouterResourceScope' in settings:
+        removed = {value.decode() for value in current.get('vpnRouterResourceScope', [])} - \
+            {value.decode() for value in settings['vpnRouterResourceScope']}
+        clients = asking(connection, [f'{name}:{scope}' for scope in sorted(removed)])
+        if clients:
+            raise Failure(f'the clients {", ".join(clients)} may ask for the scopes of {name} being removed; take them out '
+                          'of their client scopes first', 2)
+    roles = values.get('roles')
+    if roles is not None:
+        checked_roles(connection, roles)
     changes = [(ldap.MOD_REPLACE, attribute, [value.encode()] if value else []) for attribute, value in labels(values).items()]
-    changes += [(ldap.MOD_REPLACE, attribute, found) for attribute, found in client_settings(connection, values).items()]
+    changes += [(ldap.MOD_REPLACE, attribute, found) for attribute, found in settings.items()]
     email = values.get('email')
     if email is not None:
         address = '' if isinstance(email, str) and email.strip() == '' else person({'email': email}, required=False)['mail']
         changes.append((ldap.MOD_REPLACE, 'mail', [address.encode()] if address else []))
-    if not changes:
-        raise Failure('give email, display_name, description, redirect_uris, post_logout_redirect_uris or allowed_groups', 2)
-    connection.modify_s(dn_of(name), changes)
-    return summary(entry(connection, name))
+    if not changes and roles is None:
+        raise Failure(f'give email, display_name, description or {", ".join(CLIENT_KEYS)}', 2)
+    if changes:
+        connection.modify_s(dn_of(name), changes)
+    if roles is not None:
+        set_roles(connection, name, roles)
+    return with_roles(connection, summary(entry(connection, name)))
 
 
 def passwd(connection, name, password):
@@ -761,15 +870,24 @@ def remove(connection, name):
     """Remove the user from its groups and the directory, revoke the certificate and end the sessions of its own
     posixAccount.
 
-    A user who is the last member of a group is not removed.
+    A user who is the last member of a group is not removed, nor a resource whose scopes a client may ask for. The roles
+    of a removed service account are removed, and the account is taken out of the other roles.
     """
     current = entry(connection, name)
     groups = groups_of(connection, name)
     alone = sorted(group for group, members in groups.items() if members == [name])
     if alone:
         raise Failure(f'user {name} is the last member of {", ".join(alone)}; remove the group first', 2)
+    clients = sorted(set(asking(connection, [f'{name}:{scope.decode()}' for scope in current.get('vpnRouterResourceScope', [])]))
+                     - {name})
+    if clients:
+        raise Failure(f'the clients {", ".join(clients)} may ask for the scopes of {name}; take them out of their client '
+                      'scopes first', 2)
     for group in groups:
         connection.modify_s(group_dn(group), [(ldap.MOD_DELETE, 'member', [dn_of(name).encode()])])
+    for role in roles_of_resource(connection, name):
+        connection.delete_s(role_dn(name, role['name']))
+    leave_roles(connection, dn_of(name))
     try:
         vpnrouter_pki.revoke_user(vpnrouter.load_config(), name)
     except vpnrouter_pki.Failure as failure:
@@ -977,7 +1095,7 @@ def group_add(connection, name, description, members):
 def group_update(connection, name, new_name=None, description=None):
     """Rename the group or change its description ('' removes it); at least one must be given. Renaming ADMIN_GROUP
     switches the console login of its members off; renaming a group a client of the OpenID Provider allows renames it
-    there, and renaming the editors group of web sites renames it in the sites."""
+    there, as in the roles it is assigned, and renaming the editors group of web sites renames it in the sites."""
     import vpnrouter_sites
     if new_name is None and description is None:
         raise Failure('give a new name or a description', 2)
@@ -996,6 +1114,9 @@ def group_update(connection, name, new_name=None, description=None):
         for client in allowing(connection, name):
             connection.modify_s(dn_of(client), [(ldap.MOD_DELETE, 'vpnRouterAllowedGroup', [group_dn(name).encode()]),
                                                 (ldap.MOD_ADD, 'vpnRouterAllowedGroup', [group_dn(new_name).encode()])])
+        for dn in assigned(connection, group_dn(name)):
+            connection.modify_s(dn, [(ldap.MOD_DELETE, 'member', [group_dn(name).encode()]),
+                                     (ldap.MOD_ADD, 'member', [group_dn(new_name).encode()])])
         try:
             vpnrouter_sites.rename_group(name, new_name)
         except vpnrouter_sites.DatabaseError as exc:
@@ -1007,8 +1128,8 @@ def group_update(connection, name, new_name=None, description=None):
 
 
 def group_remove(connection, name):
-    """Remove the group, unless a client of the OpenID Provider allows it or it is the editors group of web sites;
-    removing ADMIN_GROUP switches the console login of its members off."""
+    """Remove the group, unless a client of the OpenID Provider allows it or it is the editors group of web sites, and
+    take it out of the roles it is assigned; removing ADMIN_GROUP switches the console login of its members off."""
     import vpnrouter_sites
     members = member_names(group_entry(connection, name))
     clients = allowing(connection, name)
@@ -1021,6 +1142,7 @@ def group_remove(connection, name):
     if sites:
         raise Failure(f'group {name} is the editors group of the web sites {", ".join(sites)}; change them first', 2)
     connection.delete_s(group_dn(name))
+    leave_roles(connection, group_dn(name))
     if name == ADMIN_GROUP:
         console_off(connection, members)
     return {'name': name, 'removed': True}
@@ -1049,6 +1171,186 @@ def group_member_remove(connection, name, user):
     return group_summary(group_entry(connection, name))
 
 
+def role_dn(resource, role):
+    return f'cn={resource}:{role},{vpnrouter_ldap.ROLES}'
+
+
+def check_resource(connection, resource):
+    """Refuse a name that is not that of a service account."""
+    if not service(entry(connection, resource)):
+        raise Failure(f'{resource} is not a service account; only a service account is a resource of the OpenID Provider', 2)
+
+
+def check_role_name(role):
+    if not isinstance(role, str) or not ROLE_NAME.match(role):
+        raise Failure('a role name is 1 to 64 letters, digits, dots, underscores and hyphens, starting with a letter', 2)
+
+
+def role_summary(attributes):
+    """A role as the answers show it: {name, description, groups, accounts}, the groups and accounts it is assigned to."""
+    groups, accounts = [], []
+    for value in attributes.get('member', []):
+        dn = value.decode()
+        if dn.startswith('cn=') and dn.endswith(f',{vpnrouter_ldap.GROUPS}'):
+            groups.append(dn[3:-len(f',{vpnrouter_ldap.GROUPS}')])
+        elif dn.startswith('uid=') and dn.endswith(f',{vpnrouter_ldap.USERS}'):
+            accounts.append(dn[4:-len(f',{vpnrouter_ldap.USERS}')])
+    values = attributes.get('description')
+    return {'name': attributes['cn'][0].decode().partition(':')[2], 'description': values[0].decode() if values else '',
+            'groups': sorted(groups), 'accounts': sorted(accounts)}
+
+
+def role_search(connection, resource, condition=''):
+    """The entries of the resource's roles that also match the LDAP filter condition, as [(DN, attributes)]."""
+    prefix = ldap.filter.escape_filter_chars(f'{resource}:')
+    found = connection.search_s(vpnrouter_ldap.ROLES, ldap.SCOPE_ONELEVEL,
+                                f'(&(objectClass=vpnRouterRole)(cn={prefix}*){condition})', ROLE_ATTRIBUTES)
+    return [(dn, attributes) for dn, attributes in found if attributes['cn'][0].decode().startswith(f'{resource}:')]
+
+
+def roles_of_resource(connection, resource):
+    """The roles of the resource, sorted by name."""
+    return sorted((role_summary(attributes) for _, attributes in role_search(connection, resource)),
+                  key=lambda role: role['name'])
+
+
+def role_entry(connection, resource, role):
+    """The attributes of the role's entry; Failure with status 3 when there is none."""
+    check_role_name(role)
+    try:
+        return connection.search_s(role_dn(resource, role), ldap.SCOPE_BASE, attrlist=ROLE_ATTRIBUTES)[0][1]
+    except ldap.NO_SUCH_OBJECT:
+        raise Failure(f'{resource} has no role {role}', 3)
+
+
+def role_add(connection, resource, role, description=''):
+    """Add a role to the resource, with a description ('' for none) and no members."""
+    check_resource(connection, resource)
+    check_role_name(role)
+    description = check_description(description if description is not None else '')
+    record = {'objectClass': [b'vpnRouterRole'], 'cn': [f'{resource}:{role}'.encode()]}
+    if description:
+        record['description'] = [description.encode()]
+    try:
+        connection.add_s(role_dn(resource, role), ldap.modlist.addModlist(record))
+    except ldap.ALREADY_EXISTS:
+        raise Failure(f'{resource} has a role {role}', 4)
+    return role_summary(role_entry(connection, resource, role))
+
+
+def role_remove(connection, resource, role):
+    role_entry(connection, resource, role)
+    connection.delete_s(role_dn(resource, role))
+    return {'resource': resource, 'name': role, 'removed': True}
+
+
+def member_dn(connection, group=None, account=None):
+    """The DN of the existing group or account a role is assigned to; exactly one is given."""
+    if (group is None) == (account is None):
+        raise Failure('give a group or an account', 2)
+    if group is not None:
+        group_entry(connection, group)
+        return group_dn(group)
+    entry(connection, account)
+    return dn_of(account)
+
+
+def role_member_add(connection, resource, role, group=None, account=None):
+    """Assign the role to the group or the account."""
+    attributes = role_entry(connection, resource, role)
+    dn = member_dn(connection, group, account)
+    if dn.encode() not in attributes.get('member', []):
+        connection.modify_s(role_dn(resource, role), [(ldap.MOD_ADD, 'member', [dn.encode()])])
+    return role_summary(role_entry(connection, resource, role))
+
+
+def role_member_remove(connection, resource, role, group=None, account=None):
+    """Take the role from the group or the account."""
+    attributes = role_entry(connection, resource, role)
+    if (group is None) == (account is None):
+        raise Failure('give a group or an account', 2)
+    dn = group_dn(group) if group is not None else dn_of(account)
+    if dn.encode() not in attributes.get('member', []):
+        raise Failure(f'role {role} of {resource} is not assigned to {group or account}', 3)
+    connection.modify_s(role_dn(resource, role), [(ldap.MOD_DELETE, 'member', [dn.encode()])])
+    return role_summary(role_entry(connection, resource, role))
+
+
+def checked_roles(connection, roles):
+    """The roles of set_roles, checked: [{name, description, groups, accounts}], names unique, every group and account
+    existing; description, groups and accounts may be left out."""
+    if not isinstance(roles, list) or not all(isinstance(role, dict) for role in roles):
+        raise Failure('roles must be a list of {"name", "description", "groups", "accounts"}', 2)
+    checked = []
+    for role in roles:
+        check_role_name(role.get('name'))
+        groups, accounts = role.get('groups') or [], role.get('accounts') or []
+        if not isinstance(groups, list) or not isinstance(accounts, list):
+            raise Failure(f'the groups and the accounts of role {role["name"]} must be lists of names', 2)
+        for group in groups:
+            group_entry(connection, group)
+        for account in accounts:
+            entry(connection, account)
+        checked.append({'name': role['name'], 'description': check_description(role.get('description') or ''),
+                        'members': sorted({*(group_dn(group) for group in groups), *(dn_of(account) for account in accounts)})})
+    if len({role['name'] for role in checked}) != len(checked):
+        raise Failure('each role name may appear once', 2)
+    return checked
+
+
+def set_roles(connection, resource, roles):
+    """Make the resource's roles those of roles (checked_roles): roles left out are removed, new ones added, and the
+    others get the description and the members given."""
+    check_resource(connection, resource)
+    wanted = {role['name']: role for role in checked_roles(connection, roles)}
+    for role in roles_of_resource(connection, resource):
+        if role['name'] not in wanted:
+            connection.delete_s(role_dn(resource, role['name']))
+    present = {role['name'] for role in roles_of_resource(connection, resource)}
+    for name, role in wanted.items():
+        members = [dn.encode() for dn in role['members']]
+        description = [role['description'].encode()] if role['description'] else []
+        if name in present:
+            connection.modify_s(role_dn(resource, name), [(ldap.MOD_REPLACE, 'description', description),
+                                                          (ldap.MOD_REPLACE, 'member', members)])
+            continue
+        record = {'objectClass': [b'vpnRouterRole'], 'cn': [f'{resource}:{name}'.encode()]}
+        if description:
+            record['description'] = description
+        if members:
+            record['member'] = members
+        connection.add_s(role_dn(resource, name), ldap.modlist.addModlist(record))
+    return roles_of_resource(connection, resource)
+
+
+def assigned(connection, dn):
+    """The DNs of the roles assigned to the group or account of the DN."""
+    found = connection.search_s(vpnrouter_ldap.ROLES, ldap.SCOPE_ONELEVEL,
+                                f'(&(objectClass=vpnRouterRole)(member={ldap.filter.escape_filter_chars(dn)}))', ['1.1'])
+    return [role for role, _ in found]
+
+
+def leave_roles(connection, dn):
+    """Take the group or account of the DN out of every role."""
+    for role in assigned(connection, dn):
+        connection.modify_s(role, [(ldap.MOD_DELETE, 'member', [dn.encode()])])
+
+
+def list_roles(connection, resource=None):
+    """The roles of every resource, or of one, as {"roles": [{resource, name, description, groups, accounts}]}."""
+    found = connection.search_s(vpnrouter_ldap.ROLES, ldap.SCOPE_ONELEVEL, '(objectClass=vpnRouterRole)', ROLE_ATTRIBUTES)
+    roles = [{'resource': attributes['cn'][0].decode().partition(':')[0], **role_summary(attributes)} for _, attributes in found]
+    return {'roles': sorted((role for role in roles if resource is None or role['resource'] == resource),
+                            key=lambda role: (role['resource'], role['name']))}
+
+
+def roles_held(connection, resource, name):
+    """The names of the resource's roles assigned to the account or to a group it is a member of, sorted."""
+    members = [dn_of(name), *(group_dn(group) for group in groups_of(connection, name))]
+    condition = '(|' + ''.join(f'(member={ldap.filter.escape_filter_chars(dn)})' for dn in members) + ')'
+    return sorted(role_summary(attributes)['name'] for _, attributes in role_search(connection, resource, condition))
+
+
 def extract_pem(text):
     """The PEM blocks of the certificates in a file that also holds their text form."""
     begin, end = '-----BEGIN CERTIFICATE-----', '-----END CERTIFICATE-----'

debian-package/src/usr/lib/vpn-router/vpnrouter_web/__init__.py

@@ -34,9 +34,10 @@ Pages:
            the DER certificate and CRL of the root (root) and of each issuing CA, which the
            certificates name in their AIA and CRL distribution points; no authentication
   /shell   while web.shell is true, a login shell of the user's console account on a terminal, for
-           a member of admins whose console login is on and who has a TOTP token: POST signs the user in again, unless
-           the user used a shell within web.shell_auth_timeout minutes, for a one-time ticket
-           (see shell_ticket()), GET with it is a WebSocket
+           a member of admins whose console login is on and who has a TOTP token: POST signs the user in again,
+           with the password and the TOTP code or with a passkey whose proof POST /shell/passkey begins,
+           unless the user used a shell within web.shell_auth_timeout minutes, for a one-time ticket
+           (see shell_ticket() and shell_passkey()), GET with it is a WebSocket
            that carries the terminal (see Handler.shell()); /shell/editor/<session>/<id> reads, saves and
            closes a file the shell opened with vpn-router-editor (vre) over EDITOR_SOCKET (see
            shell_editor() and editor_request())
@@ -54,7 +55,7 @@ Pages:
            and the files of each: list, download, upload, extract a zip archive, create a folder, rename and
            remove (see Handler.site_files()); a member of a site's editors group may use the site's files
   /dns     the primary name server of the router's domains: its settings, and the domains: add, change and
-           remove, each with its secondaries, the records it serves, and its manual records (see dns())
+           remove, each with the records it serves and its manual records (see dns())
   /postgresql
            the databases of each PostgreSQL cluster on the router with their sizes, as JSON (see
            postgresql_databases()); /config has the clusters' settings

debian-package/src/usr/lib/vpn-router/vpnrouter_web/dns.py

@@ -10,22 +10,20 @@ from .common import section_change, unit_state
 def dns(method, path, query, body):
     """Answer a /dns request with vpnrouter_dns: the HTTP status and the JSON document.
 
-      GET    /dns           {"settings", "installed", "running", "domains", "problem"}: the dns section of the
-                            configuration, whether PowerDNS is installed and runs, the domains, each {"name", "sites",
-                            "ttl", "secondaries", "manual", "records"} with its secondaries {"nameserver", "address"},
-                            its manual records and the records the name server serves, and why the domains cannot be
-                            read, null when they can
-      PUT    /dns           change any of the settings of the dns section
-      POST   /dns/domains   add a domain: {"name", "sites"?, "ttl"?}; sites gives the host names of the enabled sites
-                            in it records; ttl is dns.ttl when null or absent; an existing name is 409
+      GET    /dns           {"settings", "nameserver", "public_address", "installed", "running", "domains",
+                            "problem"}: the dns section of the configuration, wan.local_fqdn, the primary name server
+                            of the domains, wan.public_address, the address of the records of the sites with
+                            dns_address public, whether PowerDNS is installed and runs, the domains, each {"name",
+                            "ttl", "manual", "records"} with its manual records and the records the name server
+                            serves, and why the domains cannot be read, null when they can
+      PUT    /dns           change any of the settings of the dns section, and with "public_address"
+                            wan.public_address; {"settings", "public_address"}
+      POST   /dns/domains   add a domain: {"name", "ttl"?}; ttl is dns.ttl when null or absent; an existing name is
+                            409
       PUT    /dns/domains/<domain>
-                            change "sites" or "ttl" of the domain
+                            change "ttl" of the domain
       DELETE /dns/domains/<domain>
-                            remove the domain with its secondaries and manual records
-      POST   /dns/domains/<domain>/secondaries
-                            add a secondary name server of the domain, or change its address: {"nameserver", "address"}
-      DELETE /dns/domains/<domain>/secondaries/<nameserver>
-                            remove the secondary name server
+                            remove the domain with its manual records
       POST   /dns/domains/<domain>/records
                             add a manual record: {"name", "type", "content", "ttl"?}; name is relative to the domain,
                             @ for the domain itself, or absolute with a final dot; ttl is the domain's without it
@@ -47,22 +45,27 @@ def dns(method, path, query, body):
                 domains = vpnrouter_dns.listing()
             except vpnrouter_dns.DatabaseError as exc:
                 problem = str(exc)
-            return 200, {'settings': cfg['dns'], 'installed': vpnrouter_dns.PDNS_SERVER.exists(),
+            return 200, {'settings': cfg['dns'], 'nameserver': cfg['wan']['local_fqdn'].strip(),
+                         'public_address': cfg['wan']['public_address'].strip(),
+                         'installed': vpnrouter_dns.PDNS_SERVER.exists(),
                          'running': unit_state(vpnrouter_dns.UNIT) == 'active', 'domains': domains,
                          'problem': problem}
         if route == ('PUT', 'dns'):
+            wan = cfg['wan']
+            if 'public_address' in body:
+                wan = section_change('wan', {'public_address': body.pop('public_address')})
+                if isinstance(wan, tuple):
+                    return wan
             changed = section_change('dns', body)
-            return changed if isinstance(changed, tuple) else (200, {'settings': changed})
+            if isinstance(changed, tuple):
+                return changed
+            return 200, {'settings': changed, 'public_address': wan['public_address'].strip()}
         if route == ('POST', 'dns', 'domains') and len(parts) == 2:
             document, code = vpnrouter_dns.domain_add(body), 201
         elif route == ('PUT', 'dns', 'domains') and len(parts) == 3:
             document, code = vpnrouter_dns.domain_change(parts[2], body), 200
         elif route == ('DELETE', 'dns', 'domains') and len(parts) == 3:
             document, code = vpnrouter_dns.domain_remove(parts[2]), 200
-        elif route == ('POST', 'dns', 'domains', 'secondaries') and len(parts) == 4:
-            document, code = vpnrouter_dns.secondary_add(parts[2], body), 201
-        elif route == ('DELETE', 'dns', 'domains', 'secondaries') and len(parts) == 5:
-            document, code = vpnrouter_dns.secondary_remove(parts[2], parts[4]), 200
         elif route == ('POST', 'dns', 'domains', 'records') and len(parts) == 4:
             document, code = vpnrouter_dns.add(cfg, parts[2], body), 201
         elif route == ('DELETE', 'dns', 'domains', 'records') and len(parts) == 4:

debian-package/src/usr/lib/vpn-router/vpnrouter_web/handler.py

@@ -22,9 +22,10 @@ from .connectivity import remote_access, site_to_site
 from .dns import dns
 from .identities import account, groups, service_accounts, users
 from .logs import logs
+from .https import https_settings
 from .metrics import metrics_history, metrics_settings
 from .pki import PUBLISHED, ca
-from .shell import EDITOR_BODY_LIMIT, shell, shell_editor, shell_ticket
+from .shell import EDITOR_BODY_LIMIT, shell, shell_editor, shell_passkey, shell_ticket
 from .sites import SITE_FILES, site_files, sites
 from .status import cached, details, html_of, postgresql_databases, shown, text_of
 
@@ -66,7 +67,8 @@ class Handler(BaseHTTPRequestHandler):
         directory = next((name for name in ('users', 'service-accounts', 'groups', 'account', 'site-to-site', 'backup',
                                             'ca', 'shell', 'remote-access', 'logs', 'sites', 'dns')
                           if path == f'/{name}' or path.startswith(f'/{name}/')), None)
-        protected = path in ('/status/full', '/config', '/metrics/history', '/metrics/settings', '/postgresql') or \
+        protected = path in ('/status/full', '/config', '/metrics/history', '/metrics/settings', '/https/settings',
+                             '/postgresql') or \
             directory is not None
         signing = path in ('/auth', '/auth/passkey', '/auth/passkey/complete', '/auth/refresh', '/auth/logout')
         oidc = (path == '/.well-known/openid-configuration' or path.startswith('/oidc/')) and \
@@ -113,6 +115,9 @@ class Handler(BaseHTTPRequestHandler):
         elif path == '/metrics/settings':
             code, document = metrics_settings(self.command, payload)
             body, kind = json.dumps(document, indent=2).encode() + b'\n', 'application/json'
+        elif path == '/https/settings':
+            code, document = https_settings(self.command, payload)
+            body, kind = json.dumps(document, indent=2).encode() + b'\n', 'application/json'
         elif directory == 'shell' and (path, self.command) == ('/shell', 'GET'):
             return shell(self, claims.get('sub'))
         elif directory == 'shell' and path.startswith('/shell/editor/'):
@@ -120,6 +125,7 @@ class Handler(BaseHTTPRequestHandler):
             body, kind = json.dumps(document).encode() + b'\n', 'application/json'
         elif directory == 'shell':
             code, document = shell_ticket(claims.get('sub'), payload) if (path, self.command) == ('/shell', 'POST') \
+                else shell_passkey(claims.get('sub')) if (path, self.command) == ('/shell/passkey', 'POST') \
                 else (404, {'error': f'no route {self.command} {path}'})
             if code != 200:
                 log(f'shell ticket of {claims.get("sub")} from {self.client()} refused: {document["error"]}')
@@ -161,7 +167,8 @@ class Handler(BaseHTTPRequestHandler):
             code, document = (users if directory == 'users' else groups)(state, self.command, path, payload)
             body, kind = json.dumps(document, indent=2).encode() + b'\n', 'application/json'
         elif oidc:
-            wait = auth_wait(self.client()) if (self.command, path) == ('POST', '/oidc/login') else 0
+            wait = auth_wait(self.client()) if self.command == 'POST' and path in (
+                '/oidc/login', '/oidc/device', '/oidc/device_authorization') else 0
             if wait:
                 code, kind = 429, 'application/json'
                 body = json.dumps({'error': f'too many sign-in calls; retry in {wait} seconds'}).encode() + b'\n'
@@ -186,15 +193,19 @@ class Handler(BaseHTTPRequestHandler):
             code = 200
         else:
             body, kind, code = b'Not found\n', 'text/plain; charset=utf-8', 404
-        self.send_response(code)
-        self.send_header('Content-Type', kind)
-        self.send_header('Content-Length', str(len(body)))
-        self.send_header('Cache-Control', 'no-store')
-        for name, value in extra:
-            self.send_header(name, value)
-        self.end_headers()
-        if send_body:
-            self.wfile.write(body)
+        try:
+            self.send_response(code)
+            self.send_header('Content-Type', kind)
+            self.send_header('Content-Length', str(len(body)))
+            self.send_header('Cache-Control', 'no-store')
+            for name, value in extra:
+                self.send_header(name, value)
+            self.end_headers()
+            if send_body:
+                self.wfile.write(body)
+        except ConnectionError:
+            # The client went away before the answer was written.
+            self.close_connection = True
 
     def raw_body(self):
         """The request body's bytes, b'' without one or over BODY_LIMIT."""

debian-package/src/usr/lib/vpn-router/vpnrouter_web/https.py

@@ -0,0 +1,33 @@
+"""/https/settings: the settings of HTTPS, of which the API changes the CA of Caddy's certificates."""
+
+import vpnrouter
+
+from .common import section_change
+
+#: The settings of the https section PUT /https/settings changes.
+CHANGEABLE = ('acme_staging',)
+
+
+def https_settings(method, body):
+    """Answer a /https/settings request: the HTTP status and the JSON document.
+
+      GET /https/settings  {"settings"}: the https section
+      PUT /https/settings  change acme_staging; the other settings of the section are changed on the router with
+                           vpn-config-edit, and a body naming one is 400
+
+    A change is applied by restarting vpn-router-setup without waiting for it.
+    """
+    if body == 'invalid' or (body is not None and not isinstance(body, dict)):
+        return 400, {'error': 'the body must be a JSON object'}
+    if method in ('GET', 'HEAD'):
+        try:
+            return 200, {'settings': vpnrouter.load_config()['https']}
+        except SystemExit as exc:
+            return 500, {'error': str(exc.code)}
+    if method != 'PUT':
+        return 404, {'error': f'no route {method} /https/settings'}
+    others = sorted(set(body or {}) - set(CHANGEABLE))
+    if others:
+        return 400, {'error': f'https.{", https.".join(others)}: changed on the router with vpn-config-edit only'}
+    changed = section_change('https', body or {})
+    return changed if isinstance(changed, tuple) else (200, {'settings': changed})

debian-package/src/usr/lib/vpn-router/vpnrouter_web/identities.py

@@ -99,22 +99,29 @@ def oidc_settings():
 def service_accounts(method, path, body):
     """Answer a /service-accounts request with vpnrouter_users: the HTTP status and the JSON document.
 
-      GET    /service-accounts                   the service accounts: {"service_accounts": [...], "oidc": {"enabled",
-                                                 "issuer"}}, issuer that of the OpenID Provider, null while it is disabled
+      GET    /service-accounts                   the service accounts, each with its roles: {"service_accounts": [...],
+                                                 "oidc": {"enabled", "issuer"}}, issuer that of the OpenID Provider, null
+                                                 while it is disabled
       POST   /service-accounts                   add one: {"name", "password", "display_name"?, "description"?, "email"?,
-                                                 "redirect_uris"?, "post_logout_redirect_uris"?, "allowed_groups"?}
+                                                 "redirect_uris"?, "post_logout_redirect_uris"?, "allowed_groups"?,
+                                                 "grants"?, "public_client"?, "client_scopes"?, "resource_scopes"?,
+                                                 "roles"?}
       PUT    /service-accounts/<name>            change any of {"display_name", "description", "email", "redirect_uris",
-                                                 "post_logout_redirect_uris", "allowed_groups"}; "" removes one of the
-                                                 first three, [] the values of the others
+                                                 "post_logout_redirect_uris", "allowed_groups", "grants",
+                                                 "public_client", "client_scopes", "resource_scopes", "roles"}; ""
+                                                 removes one of the first three, [] the values of the lists
       PUT    /service-accounts/<name>/password   set the password: {"password": ...}
       POST   /service-accounts/<name>/disable    lock it out
       POST   /service-accounts/<name>/enable     let it in again
       POST   /service-accounts/<name>/unlock     end a lockout after failed logins
       DELETE /service-accounts/<name>            remove it
 
-    A service account with redirect URIs is a client of the OpenID Provider (vpnrouter_users.client_settings). A name
-    that is not a service account is 404. The internal service accounts (vpnrouter_users.internal_accounts), which
-    the router manages, are only listed: every other request on one is refused with 403.
+    A service account with redirect URIs or grants is a client of the OpenID Provider, and every service account a
+    resource (vpnrouter_users.client_settings); roles, [{"name", "description", "groups", "accounts"}], replaces its
+    roles (vpnrouter_users.set_roles). A name that is not a service account is 404. The internal service accounts
+    (vpnrouter_users.internal_accounts), which the router manages, are only listed: every other request on one, and a
+    role assigned to one, is refused with 403. A password change, disabling, unlocking and removing revoke the tokens
+    the account was issued.
     """
     if body == 'invalid' or (body is not None and not isinstance(body, dict)):
         return 400, {'error': 'the body must be a JSON object'}
@@ -122,11 +129,11 @@ def service_accounts(method, path, body):
     parts = path.strip('/').split('/')
     route = (method, len(parts), parts[2] if len(parts) == 3 else None)
     name = parts[1] if len(parts) > 1 else None
-    settings = {key: body.get(key) for key in ('email', 'display_name', 'description', 'redirect_uris',
-                                               'post_logout_redirect_uris', 'allowed_groups')}
+    settings = {key: body.get(key) for key in ('email', 'display_name', 'description', *vpnrouter_users.CLIENT_KEYS)}
     actions = {
         ('GET', 1, None): lambda connection: {
-            'service_accounts': [user for user in vpnrouter_users.list_users(connection)['users'] if user['service']],
+            'service_accounts': [vpnrouter_users.with_roles(connection, user)
+                                 for user in vpnrouter_users.list_users(connection)['users'] if user['service']],
             'oidc': oidc_settings()},
         ('POST', 1, None): lambda connection: vpnrouter_users.add(connection, body.get('name'), body.get('password'), settings,
                                                                   service=True),
@@ -137,19 +144,34 @@ def service_accounts(method, path, body):
         ('POST', 3, 'unlock'): lambda connection: vpnrouter_users.unlock(connection, name),
         ('DELETE', 2, None): lambda connection: vpnrouter_users.remove(connection, name),
     }
+    # The vpnrouter_users operation of each route that may revoke tokens.
+    operations = {('PUT', 3, 'password'): 'passwd', ('POST', 3, 'disable'): 'disable', ('POST', 3, 'unlock'): 'unlock',
+                  ('DELETE', 2, None): 'remove'}
     if route not in actions:
         return 404, {'error': f'no route {method} {path}'}
-    if name is not None and name in vpnrouter_users.internal_accounts():
+    internal = vpnrouter_users.internal_accounts()
+    if name is not None and name in internal:
         return 403, {'error': f'{name} is an internal service account, which the router manages'}
+    roles = settings['roles'] if isinstance(settings['roles'], list) else []
+    assigned = sorted(set(internal).intersection(account for role in roles if isinstance(role, dict)
+                                                 for account in (role.get('accounts') or [])
+                                                 if isinstance(account, str)))
+    if assigned:
+        return 403, {'error': f'{", ".join(assigned)}: internal service accounts, which the router manages, are not '
+                              'assigned roles'}
     try:
         with vpnrouter_users.session() as connection:
             if name is not None and not vpnrouter_users.service(vpnrouter_users.entry(connection, name)):
                 raise vpnrouter_users.Failure(f'{name} is not a service account', 3)
             document = actions[route](connection)
+        if operations.get(route) in vpnrouter_auth.REVOKING:
+            vpnrouter_auth.revoke(vpnrouter.load_config(), name)
     except vpnrouter_users.Failure as failure:
         return USER_STATUS.get(failure.status, 500), {'error': str(failure)}
     except (ldap.LDAPError, OSError) as exc:
         return 500, {'error': f'the user directory failed: {exc}'}
+    except vpnrouter_auth.DatabaseError as exc:
+        return 500, {'error': str(exc)}
     except SystemExit as exc:
         return 500, {'error': str(exc.code)}
     return (201 if route == ('POST', 1, None) else 200), document

debian-package/src/usr/lib/vpn-router/vpnrouter_web/shell.py

@@ -1,5 +1,6 @@
-"""/shell: the ticket, the WebSocket of the terminal (shell), and the editor of the shell: the socket vpn-router-editor
-names files on (editor_listen) and /shell/editor/... (shell_editor)."""
+"""/shell: the ticket (shell_ticket), with the passkey proof it may take (shell_passkey), the WebSocket of the terminal
+(shell), and the editor of the shell: the socket vpn-router-editor names files on (editor_listen) and /shell/editor/...
+(shell_editor)."""
 
 import base64
 import fcntl
@@ -20,6 +21,7 @@ import urllib.parse
 import ldap
 
 import vpnrouter
+import vpnrouter_passkeys
 import vpnrouter_users
 from vpnrouter_status import run
 
@@ -74,11 +76,14 @@ _shell_sessions = {}
 def shell_ticket(name, body):
     """Answer POST /shell: the HTTP status and the JSON document.
 
-    The user named by the token signs in again with {"password", "code"?}; a wrong password or code is 403 and counts
-    as a failed login. Without a password, the user is not asked to sign in while its last use of a shell (see
-    _shell_used) is less than web.shell_auth_timeout minutes ago. The answer is {"ticket", "expires_in"}: a ticket that
-    opens one shell (GET /shell) for the same user within SHELL_TICKET_SECONDS, or a null ticket when the user must
-    sign in. 403 while web.shell is false, the user's console login is not on or the user has no TOTP token.
+    The user named by the token signs in again with {"password", "code"}, its password and TOTP code, or with
+    {"passkey": {"id", "credential"}}, the answer of the browser to a proof begun by POST /shell/passkey (see
+    shell_passkey) with one of its own passkeys and the user verified. A wrong password or code counts as a failed
+    login; it and a passkey that is not accepted are 403. Without either, the user is not asked to sign in while its
+    last use of a shell (see _shell_used) is less than web.shell_auth_timeout minutes ago. The answer is {"ticket",
+    "expires_in"}: a ticket that opens one shell (GET /shell) for the same user within SHELL_TICKET_SECONDS, or a null
+    ticket when the user must sign in. 403 while web.shell is false, the user's console login is not on or the user has
+    no TOTP token.
     """
     if not isinstance(name, str):
         return 403, {'error': 'the shell needs a token of a signed-in user'}
@@ -91,16 +96,20 @@ def shell_ticket(name, body):
         refusal = console_account(name)[1]
         if refusal:
             return 403, {'error': refusal}
-        if 'password' not in body:
+        if 'passkey' in body:
+            passkey = body['passkey'] if isinstance(body['passkey'], dict) else {}
+            with vpnrouter_users.session() as connection:
+                vpnrouter_passkeys.shell_complete(connection, name, passkey.get('id'), passkey.get('credential'))
+        elif 'password' in body:
+            vpnrouter_users.login(name, body.get('password'), body.get('code'))
+        else:
             with _shell_lock:
                 used = _shell_used.get(name)
             if used is None or time.monotonic() - used >= options['shell_auth_timeout'] * 60:
                 return 200, {'ticket': None, 'expires_in': 0}
-        else:
-            vpnrouter_users.login(name, body.get('password'), body.get('code'))
     except vpnrouter_users.Failure as failure:
         if failure.status == 5:
-            return 403, {'error': 'the password or the code is wrong'}
+            return 403, {'error': 'the passkey is not accepted' if 'passkey' in body else 'the password or the code is wrong'}
         return USER_STATUS.get(failure.status, 500), {'error': str(failure)}
     except (ldap.LDAPError, OSError) as exc:
         return 500, {'error': f'the user directory failed: {exc}'}
@@ -116,9 +125,32 @@ def shell_ticket(name, body):
     return 200, {'ticket': ticket, 'expires_in': SHELL_TICKET_SECONDS}
 
 
+def shell_passkey(name):
+    """Answer POST /shell/passkey: begin the proof of the signed-in user with one of its own passkeys for POST /shell,
+    {"id", "options"}, options those of navigator.credentials.get; the HTTP status and the JSON document. 403 while
+    the user may not use a shell (console_account), 400 for a user without a passkey."""
+    if not isinstance(name, str):
+        return 403, {'error': 'the shell needs a token of a signed-in user'}
+    try:
+        if not vpnrouter.load_config()['web']['shell']:
+            return 403, {'error': 'the shell is disabled; vpn-config-edit set web.shell true enables it'}
+        refusal = console_account(name)[1]
+        if refusal:
+            return 403, {'error': refusal}
+        with vpnrouter_users.session() as connection:
+            return 200, vpnrouter_passkeys.shell_begin(connection, name)
+    except vpnrouter_users.Failure as failure:
+        return USER_STATUS.get(failure.status, 500), {'error': str(failure)}
+    except (ldap.LDAPError, OSError) as exc:
+        return 500, {'error': f'the user directory failed: {exc}'}
+    except SystemExit as exc:
+        return 500, {'error': str(exc.code)}
+
+
 def console_account(name):
     """The system account the console of the user runs as and None, or None and the reason the user may not use a
-    console: its console login is off, or it has no TOTP token."""
+    console: its console login is off, or it has no TOTP token, which the PAM login session of the shell and sudo need
+    also when a passkey opens the shell."""
     with vpnrouter_users.session() as connection:
         user = vpnrouter_users.summary(vpnrouter_users.entry(connection, name))
     if not user['console'] or not user['console']['enabled']:
@@ -335,11 +367,14 @@ def shell(handler, name):
     def refuse(code, message):
         log(f'shell of {name} from {handler.client()} refused: {message}')
         body = json.dumps({'error': message}).encode() + b'\n'
-        handler.send_response(code)
-        handler.send_header('Content-Type', 'application/json')
-        handler.send_header('Content-Length', str(len(body)))
-        handler.end_headers()
-        handler.wfile.write(body)
+        try:
+            handler.send_response(code)
+            handler.send_header('Content-Type', 'application/json')
+            handler.send_header('Content-Length', str(len(body)))
+            handler.end_headers()
+            handler.wfile.write(body)
+        except ConnectionError:
+            handler.close_connection = True
 
     key = handler.headers.get('Sec-WebSocket-Key', '').strip()
     if handler.headers.get('Upgrade', '').lower() != 'websocket' or 'upgrade' not in handler.headers.get('Connection', '').lower() \
@@ -376,12 +411,21 @@ def shell(handler, name):
     finally:
         os.close(terminal)
     accept = base64.b64encode(hashlib.sha1((key + WEBSOCKET_GUID).encode()).digest()).decode()
-    handler.send_response(101, 'Switching Protocols')
-    handler.send_header('Upgrade', 'websocket')
-    handler.send_header('Connection', 'Upgrade')
-    handler.send_header('Sec-WebSocket-Accept', accept)
-    handler.end_headers()
     handler.close_connection = True
+    try:
+        handler.send_response(101, 'Switching Protocols')
+        handler.send_header('Upgrade', 'websocket')
+        handler.send_header('Connection', 'Upgrade')
+        handler.send_header('Sec-WebSocket-Accept', accept)
+        handler.end_headers()
+    except ConnectionError:
+        # The client went away before the shell opened; the shell started for it is stopped.
+        run('systemctl', 'stop', unit)
+        os.close(master)
+        process.kill()
+        process.wait()
+        log(f'shell of {name} from {handler.client()} ended before it opened: the client closed the connection')
+        return
     client, started, idle = handler.client(), time.monotonic(), options['shell_idle_minutes'] * 60
     log(f'shell of {name} from {client} opened as {account.pw_name} in {unit}')
 

debian-package/src/usr/lib/vpn-router/vpnrouter_web/sites.py

@@ -25,7 +25,8 @@ def sites(method, path, query, body):
                              settings but private_key, with private_key_set, modified and its folder
       PUT    /sites          change any of the settings of the sites section
       POST   /sites          add a site: {"name", and any of "enabled", "hosts", "port", "listen", "tls", "ca",
-                             "certificate", "private_key", "index_file", "spa", "editors"}; an existing name is 409
+                             "certificate", "private_key", "index_file", "spa", "editors", "dns",
+                             "dns_address"}; an existing name is 409
       GET    /sites/<name>   the site
       PUT    /sites/<name>   change any of the settings of POST but name; an empty or absent private_key keeps the key
       DELETE /sites/<name>   remove the site, with content=true also its folder
@@ -112,15 +113,19 @@ def site_files(handler, name, relative, query, payload, send_body):
                 return 404, {'error': f'{relative} does not exist'}
             with open(target, 'rb') as handle:
                 size = os.fstat(handle.fileno()).st_size
-                handler.send_response(200)
-                handler.send_header('Content-Type', mimetypes.guess_type(target.name)[0] or 'application/octet-stream')
-                handler.send_header('Content-Length', str(size))
-                handler.send_header('Content-Disposition',
-                                    f"attachment; filename*=UTF-8''{urllib.parse.quote(target.name)}")
-                handler.send_header('Cache-Control', 'no-store')
-                handler.end_headers()
-                if send_body:
-                    shutil.copyfileobj(handle, handler.wfile, vpnrouter_sites.CHUNK)
+                try:
+                    handler.send_response(200)
+                    handler.send_header('Content-Type', mimetypes.guess_type(target.name)[0] or 'application/octet-stream')
+                    handler.send_header('Content-Length', str(size))
+                    handler.send_header('Content-Disposition',
+                                        f"attachment; filename*=UTF-8''{urllib.parse.quote(target.name)}")
+                    handler.send_header('Cache-Control', 'no-store')
+                    handler.end_headers()
+                    if send_body:
+                        shutil.copyfileobj(handle, handler.wfile, vpnrouter_sites.CHUNK)
+                except ConnectionError:
+                    # The client went away before the file was sent.
+                    handler.close_connection = True
             return None
         if handler.command == 'PUT':
             length = handler.headers.get('Content-Length')

debian-package/src/usr/lib/vpn-router/vpnrouter_web/status.py

@@ -7,7 +7,7 @@ import time
 from html import escape
 
 import vpnrouter
-from vpnrouter_status import established_each, openvpn_clients, run, swanctl, wireguard_peers
+from vpnrouter_status import established, established_each, openvpn_clients, run, swanctl, wireguard_peers
 
 from .common import current, unit_state
 
@@ -211,9 +211,11 @@ def postgresql_databases():
 
 def details(state):
     """What /config shows: the configuration without its secrets, and what the router resolved and runs; caddy is the
-    installed Caddy, {version, source, service}, service the state of caddy.service, null when it is not installed."""
+    installed Caddy, {version, source, service}, service the state of caddy.service, null when it is not installed; oidc
+    is {enabled, issuer} of the OpenID Provider, issuer null while it is disabled."""
     configuration = state.get('configuration', {})
     caddy = package_version('caddy')
+    oidc = configuration.get('oidc', {}).get('enabled') is True
     return {
         'configuration': configuration,
         'network': dict(state.get('network', {}), routes=routes()),
@@ -230,6 +232,7 @@ def details(state):
         # Caddy is upstream's once its repository is configured (vpn-router-caddy).
         'caddy': {'version': caddy, 'source': 'upstream' if vpnrouter.CADDY_APT_SOURCE.is_file() else 'ubuntu',
                   'service': unit_state('caddy.service')} if caddy else None,
+        'oidc': {'enabled': oidc, 'issuer': vpnrouter.oidc_issuer(configuration) if oidc else None},
     }
 
 

debian-package/src/usr/sbin/vpn-router-role

@@ -0,0 +1,121 @@
+#!/usr/bin/python3
+"""Manage the roles of the resources of the router's OpenID Provider from the command line, with vpnrouter_users.
+
+A resource is a service account; a role of it has a name, an optional description, and the groups and accounts it is
+assigned to, whose tokens for the resource carry it in their roles claim. The answer is text for people on standard
+output, and a failure is a message on standard error. With --json the answer is JSON on standard output, and a failure
+is {"error": ...} there too. The exit status says what failed: 2 the request is invalid, 3 the resource, the role, the
+group or the account does not exist, 4 the role exists, 1 anything else. -h or --help shows the commands and their
+options.
+
+  vpn-router-role [--json] list [<resource>]
+  vpn-router-role [--json] add <resource> <role> [--description D]
+  vpn-router-role [--json] remove <resource> <role>
+  vpn-router-role [--json] member-add <resource> <role> (--group G | --account A)
+  vpn-router-role [--json] member-remove <resource> <role> (--group G | --account A)
+"""
+
+import argparse
+import json
+import sys
+
+sys.path.insert(0, '/usr/lib/vpn-router')
+
+import ldap
+
+import vpnrouter_users
+from vpnrouter_users import Failure
+
+#: The help line of each command.
+HELP = {
+    'list': 'list the roles of every resource, or of one, with the groups and accounts they are assigned to',
+    'add': 'add a role to a resource',
+    'remove': 'remove a role of a resource',
+    'member-add': 'assign the role to a group or an account',
+    'member-remove': 'take the role from a group or an account',
+}
+
+
+class Parser(argparse.ArgumentParser):
+    """An argument parser whose errors are Failures with status 2, so that --json answers them as JSON."""
+
+    def error(self, message):
+        raise Failure(f'{message}; see {self.prog} --help', 2)
+
+
+def parse(argv):
+    parser = Parser(prog='vpn-router-role', description='Manage the roles of the resources of the OpenID Provider.')
+    parser.add_argument('--json', action='store_true', help='answer in JSON')
+    commands = parser.add_subparsers(dest='command', required=True, metavar='command', parser_class=Parser)
+    for command, text in HELP.items():
+        sub = commands.add_parser(command, help=text, description=text[0].upper() + text[1:] + '.')
+        if command == 'list':
+            sub.add_argument('resource', nargs='?', help='the service account whose roles are listed')
+            continue
+        sub.add_argument('resource', help='the service account the role belongs to')
+        sub.add_argument('role', help='the role name')
+        if command == 'add':
+            sub.add_argument('--description', metavar='TEXT', help='the description')
+        if command in ('member-add', 'member-remove'):
+            member = sub.add_mutually_exclusive_group(required=True)
+            member.add_argument('--group', metavar='GROUP', help='the group')
+            member.add_argument('--account', metavar='USER', help='the user or service account')
+    return parser.parse_args(argv)
+
+
+def run(connection, options):
+    """The answer of the command the options name."""
+    command = options.command
+    if command == 'list':
+        if options.resource is not None:
+            vpnrouter_users.check_resource(connection, options.resource)
+        return vpnrouter_users.list_roles(connection, options.resource)
+    if command == 'add':
+        role = vpnrouter_users.role_add(connection, options.resource, options.role, options.description)
+    elif command == 'remove':
+        return vpnrouter_users.role_remove(connection, options.resource, options.role)
+    elif command == 'member-add':
+        role = vpnrouter_users.role_member_add(connection, options.resource, options.role, options.group, options.account)
+    else:
+        role = vpnrouter_users.role_member_remove(connection, options.resource, options.role, options.group, options.account)
+    return {'resource': options.resource, **role}
+
+
+def text_of(answer):
+    """The answer as text for people."""
+    if answer.get('removed'):
+        return f'role {answer["name"]} of {answer["resource"]} removed'
+    roles = answer['roles'] if 'roles' in answer else [answer]
+    if not roles:
+        return 'no roles'
+    head = ('RESOURCE', 'ROLE', 'GROUPS', 'ACCOUNTS', 'DESCRIPTION')
+    rows = [(role['resource'], role['name'], ', '.join(role['groups']) or '-', ', '.join(role['accounts']) or '-',
+             role['description'] or '-') for role in roles]
+    widths = [max(len(row[column]) for row in (head, *rows)) for column in range(len(head))]
+    return '\n'.join('  '.join(cell.ljust(width) for cell, width in zip(row, widths)).rstrip() for row in (head, *rows))
+
+
+def main(argv):
+    # A request that cannot be parsed is answered in JSON when --json is among the arguments.
+    as_json = '--json' in argv
+    try:
+        options = parse(argv)
+        as_json = options.json
+        with vpnrouter_users.session() as connection:
+            answer = run(connection, options)
+    except Failure as failure:
+        message, status = str(failure), failure.status
+    except (ldap.LDAPError, OSError) as exc:
+        message, status = f'the user directory failed: {exc}', 1
+    else:
+        print(json.dumps(answer) if as_json else text_of(answer))
+        return 0
+    if as_json:
+        print(json.dumps({'error': message}))
+    else:
+        print(f'vpn-router-role: {message}', file=sys.stderr)
+    return status
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))

debian-package/src/usr/sbin/vpn-router-site

@@ -3,7 +3,9 @@
 
 A site has a name, which also names its folder in /var/lib/vpn-router/sites, host names, a port, the interfaces whose
 firewall opens it, TLS (none, acme, ca with --ca, or file with --certificate and --key), the file served for a folder,
-whether any path without a file is served that file of the site (--spa), and the group whose members change its files.
+whether any path without a file is served that file of the site (--spa), the group whose members change its files, and
+who serves the records of its host names (--dns user, elsewhere, or router, the router's name server, with the router's
+address of --dns-address).
 A change is applied by restarting vpn-router-setup without waiting for it. The answer is text for people on standard
 output, and a failure is a message on standard error. With --json the answer is JSON on standard output, and a failure
 is {"error": ...} there too. The exit status says what failed: 2 the request is invalid, 3 the site does not exist, 4
@@ -17,7 +19,8 @@ the site exists, 1 anything else. -h or --help shows the commands and their opti
 
   options: [--host H ...] [--no-hosts] [--port P] [--listen internal|external|both] [--tls none|acme|ca|file]
            [--ca NAME] [--certificate FILE] [--key FILE] [--index FILE] [--spa | --no-spa]
-           [--enabled | --no-enabled] [--editors GROUP]
+           [--enabled | --no-enabled] [--editors GROUP] [--dns user|router]
+           [--dns-address public|internal|external]
 """
 
 import argparse
@@ -73,6 +76,9 @@ def parse(argv):
                              'path without a file')
             sub.add_argument('--enabled', action=argparse.BooleanOptionalAction, help='serve the site')
             sub.add_argument('--editors', metavar='GROUP', help="the group whose members change the files; '' for none")
+            sub.add_argument('--dns', choices=vpnrouter_sites.DNS, help='who serves the records of the host names')
+            sub.add_argument('--dns-address', choices=vpnrouter_sites.DNS_ADDRESSES,
+                             help="the router's address in the records of dns router")
         if command == 'remove':
             sub.add_argument('--content', action='store_true', help='remove the site\'s folder too')
     return parser.parse_args(argv)
@@ -82,7 +88,8 @@ def values_of(options):
     """The settings the options give."""
     values = {key: getattr(options, option) for key, option in (('port', 'port'), ('listen', 'listen'), ('tls', 'tls'),
                                                                ('ca', 'ca'), ('index_file', 'index'), ('spa', 'spa'),
-                                                               ('enabled', 'enabled'), ('editors', 'editors'))
+                                                               ('enabled', 'enabled'), ('editors', 'editors'),
+                                                               ('dns', 'dns'), ('dns_address', 'dns_address'))
               if getattr(options, option) is not None}
     if options.no_hosts:
         values['hosts'] = []
@@ -120,9 +127,10 @@ def text_of(answer):
     sites = answer['sites'] if 'sites' in answer else [answer]
     if not sites:
         return 'no sites'
-    head = ('SITE', 'ENABLED', 'HOSTS', 'PORT', 'LISTEN', 'TLS', 'EDITORS')
+    head = ('SITE', 'ENABLED', 'HOSTS', 'PORT', 'LISTEN', 'TLS', 'EDITORS', 'DNS')
     rows = [(site['name'], 'yes' if site['enabled'] else 'no', ', '.join(site['hosts']) or '*', str(site['port']),
-             site['listen'], site['tls'] + (f' {site["ca"]}' if site['tls'] == 'ca' else ''), site['editors'] or '-')
+             site['listen'], site['tls'] + (f' {site["ca"]}' if site['tls'] == 'ca' else ''), site['editors'] or '-',
+             site['dns'] + (f' {site["dns_address"]}' if site['dns'] == 'router' else ''))
             for site in sites]
     widths = [max(len(row[column]) for row in (head, *rows)) for column in range(len(head))]
     return '\n'.join('  '.join(cell.ljust(width) for cell, width in zip(row, widths)).rstrip() for row in (head, *rows))

debian-package/src/usr/sbin/vpn-router-user

@@ -13,14 +13,17 @@ user exists, 1 anything else. -h or --help shows the commands and their options.
   vpn-router-user [--json] add <name> [--email E]   (a Manager-only account; password on stdin)
   vpn-router-user [--json] add <name> --service [--display-name N] [--description D] [--email E]
                   [--redirect-uri U ...] [--post-logout-redirect-uri U ...] [--allowed-group G ...]
+                  [--grant G ...] [--public-client yes|no] [--client-scope R:S ...] [--resource-scope S ...]
                                                   (a service account; password on stdin)
   vpn-router-user [--json] update <name> [--first-name F] [--last-name L] [--email E]
   vpn-router-user [--json] update <name> [--display-name N] [--description D] [--email E]
                   [--redirect-uri U ...] [--post-logout-redirect-uri U ...] [--allowed-group G ...]
+                  [--grant G ...] [--public-client yes|no] [--client-scope R:S ...] [--resource-scope S ...]
                                                   (a service account)
 
-A service account with a redirect URI is a client of the OpenID Provider; each of the three options may be repeated,
-and replaces all values of its kind; one '' removes them.
+A service account with a redirect URI or a grant (client_credentials, device_code) is a client of the OpenID Provider,
+and one with a resource scope a resource; each of the repeatable options replaces all values of its kind, and one ''
+removes them. vpn-router-role manages the roles of a resource.
   vpn-router-user [--json] passwd <name>       (password on stdin)
   vpn-router-user [--json] disable <name>
   vpn-router-user [--json] enable <name>
@@ -80,6 +83,9 @@ CLIENT_OPTIONS = (
     ('redirect_uris', 'redirect-uri', 'a redirect URI of the OpenID Provider client'),
     ('post_logout_redirect_uris', 'post-logout-redirect-uri', 'a post-logout redirect URI of the OpenID Provider client'),
     ('allowed_groups', 'allowed-group', 'a group whose members may sign in to the OpenID Provider client'),
+    ('grants', 'grant', 'a grant the client may use besides the authorization code: client_credentials or device_code'),
+    ('client_scopes', 'client-scope', 'a scope of a resource the client may ask for, <resource>:<scope>'),
+    ('resource_scopes', 'resource-scope', 'a scope the service account defines as a resource'),
 )
 
 
@@ -104,6 +110,8 @@ def parse(argv):
             for key, option, text in CLIENT_OPTIONS:
                 sub.add_argument(f'--{option}', dest=key, action='append', metavar='VALUE',
                                  help=f"{text}, of a service account; repeat it for more, '' for none")
+            sub.add_argument('--public-client', choices=('yes', 'no'),
+                             help='whether the client of a service account is public, without a secret')
         if command == 'add':
             sub.add_argument('--service', action='store_true', help='add a service account, which cannot sign in to the web service')
         if command == 'otp-enrol':
@@ -131,6 +139,8 @@ def run(connection, options, secret):
         given = getattr(options, key, None)
         if given is not None:
             values[key] = [value for value in given if value]
+    if getattr(options, 'public_client', None) is not None:
+        values['public_client'] = options.public_client == 'yes'
     if command == 'add':
         return vpnrouter_users.add(connection, options.name, secret, values, service=options.service)
     if command == 'update':
@@ -157,12 +167,20 @@ def console_text(user):
 
 
 def client_text(user):
-    """The OpenID Provider client settings of a service account as a cell: -, or the numbers of its URIs and its allowed
-    groups."""
-    if not user.get('redirect_uris'):
-        return '-'
-    groups = ','.join(user['allowed_groups']) or 'all users'
-    return f'{len(user["redirect_uris"])} redirect, {len(user["post_logout_redirect_uris"])} logout, {groups}'
+    """The OpenID Provider settings of a service account as a cell: -, or the numbers of its URIs, its allowed groups,
+    grants, public, its client scopes and its resource scopes."""
+    parts = []
+    if user.get('redirect_uris'):
+        groups = ','.join(user['allowed_groups']) or 'all users'
+        parts.append(f'{len(user["redirect_uris"])} redirect, {len(user["post_logout_redirect_uris"])} logout, {groups}')
+    parts += user.get('grants') or []
+    if user.get('public_client'):
+        parts.append('public')
+    if user.get('client_scopes'):
+        parts.append('asks ' + ','.join(user['client_scopes']))
+    if user.get('resource_scopes'):
+        parts.append('defines ' + ','.join(user['resource_scopes']))
+    return '; '.join(parts) or '-'
 
 
 def text_of(answer):

debian-package/src/usr/share/bash-completion/completions/vpn-router-role.bash

@@ -0,0 +1,94 @@
+# bash completion for vpn-router-role                                  -*- shell-script -*-
+
+# The service accounts, the users, the groups and the roles of a resource of the router's directory, read as root;
+# nothing for other users.
+_vpn_router_role_resources()
+{
+    vpn-router-user --json list 2>/dev/null |
+        python3 -c 'import json, sys; print("\n".join(user["name"] for user in json.load(sys.stdin)["users"] if user["service"]))' 2>/dev/null
+}
+
+_vpn_router_role_accounts()
+{
+    vpn-router-user --json list 2>/dev/null |
+        python3 -c 'import json, sys; print("\n".join(user["name"] for user in json.load(sys.stdin)["users"]))' 2>/dev/null
+}
+
+_vpn_router_role_groups()
+{
+    vpn-router-group --json list 2>/dev/null |
+        python3 -c 'import json, sys; print("\n".join(group["name"] for group in json.load(sys.stdin)["groups"]))' 2>/dev/null
+}
+
+_vpn_router_role_names()
+{
+    vpn-router-role --json list "$1" 2>/dev/null |
+        python3 -c 'import json, sys; print("\n".join(role["name"] for role in json.load(sys.stdin)["roles"]))' 2>/dev/null
+}
+
+_vpn_router_role()
+{
+    local cur prev words cword split
+    _init_completion -s || return
+
+    # The command is the first word that is not an option; the arguments are the words after it but option values.
+    local i command='' args=0 resource=''
+    for ((i = 1; i < cword; i++)); do
+        if [[ -z $command ]]; then
+            [[ ${words[i]} != -* ]] && command=${words[i]}
+            continue
+        fi
+        case ${words[i]} in
+            --description | --group | --account) ((i++)) ;;
+            -*) ;;
+            *)
+                ((args == 0)) && resource=${words[i]}
+                ((args++))
+                ;;
+        esac
+    done
+
+    if [[ -z $command ]]; then
+        if [[ $cur == -* ]]; then
+            COMPREPLY=($(compgen -W '--json --help' -- "$cur"))
+        else
+            COMPREPLY=($(compgen -W 'list add remove member-add member-remove' -- "$cur"))
+        fi
+        return
+    fi
+
+    case $prev in
+        --group)
+            COMPREPLY=($(compgen -W "$(_vpn_router_role_groups)" -- "$cur"))
+            return
+            ;;
+        --account)
+            COMPREPLY=($(compgen -W "$(_vpn_router_role_accounts)" -- "$cur"))
+            return
+            ;;
+        --description)
+            return
+            ;;
+    esac
+    $split && return
+
+    if [[ $cur == -* ]]; then
+        local options='--help'
+        case $command in
+            add) options+=' --description' ;;
+            member-add | member-remove) options+=' --group --account' ;;
+        esac
+        COMPREPLY=($(compgen -W "$options" -- "$cur"))
+        return
+    fi
+
+    # The resource, then the role, which add takes new.
+    if ((args == 0)); then
+        COMPREPLY=($(compgen -W "$(_vpn_router_role_resources)" -- "$cur"))
+    elif ((args == 1)) && [[ $command != @(list|add) ]]; then
+        COMPREPLY=($(compgen -W "$(_vpn_router_role_names "$resource")" -- "$cur"))
+    fi
+} &&
+    complete -F _vpn_router_role vpn-router-role
+
+# ex: filetype=sh

debian-package/src/usr/share/bash-completion/completions/vpn-router-site.bash

@@ -64,6 +64,14 @@ _vpn_router_site()
             COMPREPLY=($(compgen -W "$(_vpn_router_site_groups)" -- "$cur"))
             return
             ;;
+        --dns)
+            COMPREPLY=($(compgen -W 'user router' -- "$cur"))
+            return
+            ;;
+        --dns-address)
+            COMPREPLY=($(compgen -W 'public internal external' -- "$cur"))
+            return
+            ;;
         --certificate | --key)
             _filedir
             return
@@ -78,7 +86,7 @@ _vpn_router_site()
         local options='--help'
         case $command in
             add | update) options+=' --host --no-hosts --port --listen --tls --ca --certificate --key --index --spa
-                --no-spa --enabled --no-enabled --editors' ;;
+                --no-spa --enabled --no-enabled --editors --dns --dns-address' ;;
             remove) options+=' --content' ;;
         esac
         COMPREPLY=($(compgen -W "$options" -- "$cur"))

debian-package/src/usr/share/bash-completion/completions/vpn-router-user.bash

@@ -13,6 +13,14 @@ _vpn_router_user_groups()
         python3 -c 'import json, sys; print("\n".join(group["name"] for group in json.load(sys.stdin)["groups"]))' 2>/dev/null
 }
 
+# The scopes of the resources, <resource>:<scope>, read as root.
+_vpn_router_user_scopes()
+{
+    vpn-router-user --json list 2>/dev/null |
+        python3 -c 'import json, sys; print("\n".join(user["name"] + ":" + scope for user in json.load(sys.stdin)["users"]
+                                                       for scope in user.get("resource_scopes", [])))' 2>/dev/null
+}
+
 _vpn_router_user()
 {
     local cur prev words cword split
@@ -30,7 +38,8 @@ _vpn_router_user()
         fi
         case ${words[i]} in
             --first-name | --last-name | --email | --display-name | --description | --redirect-uri | \
-                --post-logout-redirect-uri | --allowed-group | --account) ((i++)) ;;
+                --post-logout-redirect-uri | --allowed-group | --account | --grant | --public-client | --client-scope | \
+                --resource-scope) ((i++)) ;;
             -*) ;;
             *) ((args++)) ;;
         esac
@@ -50,6 +59,21 @@ _vpn_router_user()
             COMPREPLY=($(compgen -W "$(_vpn_router_user_groups)" -- "$cur"))
             return
             ;;
+        --grant)
+            COMPREPLY=($(compgen -W 'client_credentials device_code' -- "$cur"))
+            return
+            ;;
+        --public-client)
+            COMPREPLY=($(compgen -W 'yes no' -- "$cur"))
+            return
+            ;;
+        --client-scope)
+            COMPREPLY=($(compgen -W "$(_vpn_router_user_scopes)" -- "$cur"))
+            return
+            ;;
+        --resource-scope)
+            return
+            ;;
         --account)
             # The local accounts console --account takes: a uid from 1000 to 19999, not nobody.
             COMPREPLY=($(compgen -W "$(getent passwd | awk -F: '$3 >= 1000 && $3 < 20000 && $1 != "nobody" { print $1 }')" -- "$cur"))
@@ -65,9 +89,9 @@ _vpn_router_user()
         local options='--help'
         case $command in
             add) options+=' --first-name --last-name --email --service --display-name --description --redirect-uri
-                --post-logout-redirect-uri --allowed-group' ;;
+                --post-logout-redirect-uri --allowed-group --grant --public-client --client-scope --resource-scope' ;;
             update) options+=' --first-name --last-name --email --display-name --description --redirect-uri
-                --post-logout-redirect-uri --allowed-group' ;;
+                --post-logout-redirect-uri --allowed-group --grant --public-client --client-scope --resource-scope' ;;
             console) options+=' --posix --account --off' ;;
         esac
         COMPREPLY=($(compgen -W "$options" -- "$cur"))

debian-package/src/usr/share/doc/vpn-router/vpn-router.json.example

@@ -8,7 +8,8 @@
     "internal": "eth1"
   },
   "wan": {
-    "local_fqdn": "router.example.com"
+    "local_fqdn": "router.example.com",
+    "public_address": ""
   },
   "local": {
     "cidrs": ["10.0.0.0/24"],
@@ -89,8 +90,7 @@
   },
   "dns": {
     "enabled": false,
-    "nameserver": "",
-    "addresses": [],
+    "secondary": "",
     "listen": "external",
     "ttl": 300
   },

debian-package/src/usr/share/vpn-router/sql/dns.sql

@@ -6,21 +6,21 @@ SELECT pg_advisory_xact_lock(hashtext('vpn-router dns schema'));
 
 DROP TABLE IF EXISTS dns_manual_records;
 
--- A domain the router serves as its primary name server; sites says whether the host names of the enabled sites in
--- it get records, ttl is the TTL of its records, null for dns.ttl.
+-- The secondaries of each domain and the domain's switch of site records: the secondary is dns.secondary, the same
+-- for every domain, and each site says whether the router serves its records.
+DROP PROCEDURE IF EXISTS dns_secondary_put(text, text, inet);
+DROP PROCEDURE IF EXISTS dns_secondary_remove(text, text);
+DROP FUNCTION IF EXISTS dns_secondaries_list();
+DROP TABLE IF EXISTS dns_secondaries;
+DROP FUNCTION IF EXISTS dns_domains_list();
+DROP PROCEDURE IF EXISTS dns_domain_put(text, boolean, integer);
+
+-- A domain the router serves as its primary name server; ttl is the TTL of its records, null for dns.ttl.
 CREATE TABLE IF NOT EXISTS dns_domains (
     name text PRIMARY KEY,
-    sites boolean NOT NULL,
     ttl integer
 );
-
--- A secondary name server of a domain: its NS name and the address it transfers the domain from.
-CREATE TABLE IF NOT EXISTS dns_secondaries (
-    domain text NOT NULL REFERENCES dns_domains (name) ON DELETE CASCADE,
-    nameserver text NOT NULL,
-    address inet NOT NULL,
-    PRIMARY KEY (domain, nameserver)
-);
+ALTER TABLE dns_domains DROP COLUMN IF EXISTS sites;
 
 -- A record an administrator added to a domain, besides those of the domain itself and of the sites.
 CREATE TABLE IF NOT EXISTS dns_records (
@@ -40,42 +40,24 @@ CREATE TABLE IF NOT EXISTS dns_state (
 );
 
 CREATE OR REPLACE FUNCTION dns_domains_list()
-RETURNS TABLE (name text, sites boolean, ttl integer)
+RETURNS TABLE (name text, ttl integer)
 LANGUAGE sql STABLE AS $$
-    SELECT name, sites, ttl FROM dns_domains ORDER BY name;
+    SELECT name, ttl FROM dns_domains ORDER BY name;
 $$;
 
--- Add the domain, or set its sites and TTL.
-CREATE OR REPLACE PROCEDURE dns_domain_put(p_name text, p_sites boolean, p_ttl integer)
+-- Add the domain, or set its TTL.
+CREATE OR REPLACE PROCEDURE dns_domain_put(p_name text, p_ttl integer)
 LANGUAGE sql AS $$
-    INSERT INTO dns_domains VALUES (p_name, p_sites, p_ttl)
-    ON CONFLICT (name) DO UPDATE SET sites = p_sites, ttl = p_ttl;
+    INSERT INTO dns_domains (name, ttl) VALUES (p_name, p_ttl)
+    ON CONFLICT (name) DO UPDATE SET ttl = p_ttl;
 $$;
 
--- Remove the domain with its secondaries and records.
+-- Remove the domain with its records.
 CREATE OR REPLACE PROCEDURE dns_domain_remove(p_name text)
 LANGUAGE sql AS $$
     DELETE FROM dns_domains WHERE name = p_name;
 $$;
 
-CREATE OR REPLACE FUNCTION dns_secondaries_list()
-RETURNS TABLE (domain text, nameserver text, address text)
-LANGUAGE sql STABLE AS $$
-    SELECT domain, nameserver, host(address) FROM dns_secondaries ORDER BY domain, nameserver;
-$$;
-
--- Add the secondary of the domain, or set its address.
-CREATE OR REPLACE PROCEDURE dns_secondary_put(p_domain text, p_nameserver text, p_address inet)
-LANGUAGE sql AS $$
-    INSERT INTO dns_secondaries VALUES (p_domain, p_nameserver, p_address)
-    ON CONFLICT (domain, nameserver) DO UPDATE SET address = p_address;
-$$;
-
-CREATE OR REPLACE PROCEDURE dns_secondary_remove(p_domain text, p_nameserver text)
-LANGUAGE sql AS $$
-    DELETE FROM dns_secondaries WHERE domain = p_domain AND nameserver = p_nameserver;
-$$;
-
 CREATE OR REPLACE FUNCTION dns_records_list()
 RETURNS TABLE (domain text, name text, type text, content text, ttl integer)
 LANGUAGE sql STABLE AS $$
@@ -97,7 +79,7 @@ LANGUAGE sql AS $$
 $$;
 
 -- Serve the zone as its primary and give it the records, its SOA first, whose content has {serial} for the serial,
--- and the addresses of its secondaries, which are notified of its changes and may transfer it. The serial grows, to
+-- and the addresses of its secondary, which are notified of its changes and may transfer it. The serial grows, to
 -- at least the current Unix time, only when the records differ from those last written.
 CREATE OR REPLACE PROCEDURE dns_apply(p_zone text, p_soa text, p_ttl integer, p_names text[], p_types text[],
                                       p_contents text[], p_ttls integer[], p_secondaries text[])

debian-package/src/usr/share/vpn-router/sql/oidc.sql

@@ -1,10 +1,12 @@
 -- The state of the router's OpenID Provider (vpnrouter_oidc) in the database of web.database.
--- Codes, tokens and sessions are kept as the SHA-256 of their values; expired rows are purged when new ones are saved.
--- The whole file runs as one transaction, serialized by an advisory lock, so that two processes can load it at once.
+-- Codes, tokens, device codes and sessions are kept as the SHA-256 of their values; expired rows are purged when new
+-- ones are saved. The whole file runs as one transaction, serialized by an advisory lock, so that two processes can
+-- load it at once.
 
 SELECT pg_advisory_xact_lock(hashtext('vpn-router oidc schema'));
 
--- An authorization code, valid until it is exchanged for tokens or expires.
+-- An authorization code, valid until it is exchanged for tokens or expires; resource is the resource the tokens are
+-- for, null for the client itself.
 CREATE TABLE IF NOT EXISTS oidc_codes (
     hash text PRIMARY KEY,
     client_id text NOT NULL,
@@ -16,10 +18,13 @@ CREATE TABLE IF NOT EXISTS oidc_codes (
     code_challenge_method text NOT NULL,
     auth_time timestamptz NOT NULL,
     amr text[] NOT NULL,
-    expires timestamptz NOT NULL
+    expires timestamptz NOT NULL,
+    resource text
 );
+ALTER TABLE oidc_codes ADD COLUMN IF NOT EXISTS resource text;
 
--- An access token or a refresh token (kind) a client was issued for a user.
+-- An access token or a refresh token (kind) a client was issued for a user, or for itself as a service account with
+-- client credentials; resource as in oidc_codes.
 CREATE TABLE IF NOT EXISTS oidc_tokens (
     hash text PRIMARY KEY,
     kind text NOT NULL CHECK (kind IN ('access', 'refresh')),
@@ -28,9 +33,30 @@ CREATE TABLE IF NOT EXISTS oidc_tokens (
     scopes text[] NOT NULL,
     auth_time timestamptz NOT NULL,
     amr text[] NOT NULL,
+    expires timestamptz NOT NULL,
+    resource text
+);
+ALTER TABLE oidc_tokens ADD COLUMN IF NOT EXISTS resource text;
+CREATE INDEX IF NOT EXISTS oidc_tokens_name ON oidc_tokens (name);
+
+-- A device code of the device authorization grant and its user code (user_hash): pending until the user allows or
+-- denies it, then the user, when and how they signed in; poll_seconds is the least time between two polls, polled
+-- the last poll.
+CREATE TABLE IF NOT EXISTS oidc_devices (
+    hash text PRIMARY KEY,
+    user_hash text NOT NULL UNIQUE,
+    client_id text NOT NULL,
+    scopes text[] NOT NULL,
+    resource text,
+    state text NOT NULL DEFAULT 'pending' CHECK (state IN ('pending', 'allowed', 'denied')),
+    name text,
+    auth_time timestamptz,
+    amr text[],
+    poll_seconds integer NOT NULL,
+    polled timestamptz,
     expires timestamptz NOT NULL
 );
-CREATE INDEX IF NOT EXISTS oidc_tokens_name ON oidc_tokens (name);
+CREATE INDEX IF NOT EXISTS oidc_devices_name ON oidc_devices (name);
 
 -- A user's sign-in at the OpenID Provider, which the session cookie names.
 CREATE TABLE IF NOT EXISTS oidc_sessions (
@@ -41,22 +67,30 @@ CREATE TABLE IF NOT EXISTS oidc_sessions (
     expires timestamptz NOT NULL
 );
 
+-- The functions and procedures whose parameters or results differ from those of the same name.
+DROP PROCEDURE IF EXISTS oidc_code_save(text, text, text, text, text[], text, text, text, timestamptz, text[], integer);
+DROP FUNCTION IF EXISTS oidc_code_get(text);
+DROP PROCEDURE IF EXISTS oidc_token_save(text, text, text, text, text[], timestamptz, text[], integer);
+DROP FUNCTION IF EXISTS oidc_token_get(text, text);
+
 CREATE OR REPLACE PROCEDURE oidc_code_save(p_hash text, p_client_id text, p_name text, p_redirect_uri text,
                                            p_scopes text[], p_nonce text, p_code_challenge text,
                                            p_code_challenge_method text, p_auth_time timestamptz, p_amr text[],
-                                           p_seconds integer)
+                                           p_resource text, p_seconds integer)
 LANGUAGE sql AS $$
     DELETE FROM oidc_codes WHERE expires < now();
-    INSERT INTO oidc_codes VALUES (p_hash, p_client_id, p_name, p_redirect_uri, p_scopes, p_nonce, p_code_challenge,
-                                   p_code_challenge_method, p_auth_time, p_amr, now() + make_interval(secs => p_seconds));
+    INSERT INTO oidc_codes (hash, client_id, name, redirect_uri, scopes, nonce, code_challenge, code_challenge_method,
+                            auth_time, amr, resource, expires)
+    VALUES (p_hash, p_client_id, p_name, p_redirect_uri, p_scopes, p_nonce, p_code_challenge, p_code_challenge_method,
+            p_auth_time, p_amr, p_resource, now() + make_interval(secs => p_seconds));
 $$;
 
 -- The unexpired code.
 CREATE OR REPLACE FUNCTION oidc_code_get(p_hash text)
 RETURNS TABLE (client_id text, name text, redirect_uri text, scopes text[], nonce text, code_challenge text,
-               code_challenge_method text, auth_time timestamptz, amr text[])
+               code_challenge_method text, auth_time timestamptz, amr text[], resource text)
 LANGUAGE sql STABLE AS $$
-    SELECT client_id, name, redirect_uri, scopes, nonce, code_challenge, code_challenge_method, auth_time, amr
+    SELECT client_id, name, redirect_uri, scopes, nonce, code_challenge, code_challenge_method, auth_time, amr, resource
     FROM oidc_codes WHERE hash = p_hash AND expires > now();
 $$;
 
@@ -66,18 +100,19 @@ LANGUAGE sql AS $$
 $$;
 
 CREATE OR REPLACE PROCEDURE oidc_token_save(p_hash text, p_kind text, p_client_id text, p_name text, p_scopes text[],
-                                            p_auth_time timestamptz, p_amr text[], p_seconds integer)
+                                            p_auth_time timestamptz, p_amr text[], p_resource text, p_seconds integer)
 LANGUAGE sql AS $$
     DELETE FROM oidc_tokens WHERE expires < now();
-    INSERT INTO oidc_tokens VALUES (p_hash, p_kind, p_client_id, p_name, p_scopes, p_auth_time, p_amr,
-                                    now() + make_interval(secs => p_seconds));
+    INSERT INTO oidc_tokens (hash, kind, client_id, name, scopes, auth_time, amr, resource, expires)
+    VALUES (p_hash, p_kind, p_client_id, p_name, p_scopes, p_auth_time, p_amr, p_resource,
+            now() + make_interval(secs => p_seconds));
 $$;
 
 -- The unexpired token of the kind.
 CREATE OR REPLACE FUNCTION oidc_token_get(p_hash text, p_kind text)
-RETURNS TABLE (client_id text, name text, scopes text[], auth_time timestamptz, amr text[])
+RETURNS TABLE (client_id text, name text, scopes text[], auth_time timestamptz, amr text[], resource text)
 LANGUAGE sql STABLE AS $$
-    SELECT client_id, name, scopes, auth_time, amr FROM oidc_tokens
+    SELECT client_id, name, scopes, auth_time, amr, resource FROM oidc_tokens
     WHERE hash = p_hash AND kind = p_kind AND expires > now();
 $$;
 
@@ -86,6 +121,59 @@ LANGUAGE sql AS $$
     DELETE FROM oidc_tokens WHERE hash = p_hash;
 $$;
 
+CREATE OR REPLACE PROCEDURE oidc_device_save(p_hash text, p_user_hash text, p_client_id text, p_scopes text[],
+                                             p_resource text, p_poll_seconds integer, p_seconds integer)
+LANGUAGE sql AS $$
+    DELETE FROM oidc_devices WHERE expires < now();
+    INSERT INTO oidc_devices (hash, user_hash, client_id, scopes, resource, poll_seconds, expires)
+    VALUES (p_hash, p_user_hash, p_client_id, p_scopes, p_resource, p_poll_seconds,
+            now() + make_interval(secs => p_seconds));
+$$;
+
+-- The unexpired device code of the user code while it waits for the user.
+CREATE OR REPLACE FUNCTION oidc_device_find(p_user_hash text)
+RETURNS TABLE (client_id text, scopes text[], resource text)
+LANGUAGE sql STABLE AS $$
+    SELECT client_id, scopes, resource FROM oidc_devices
+    WHERE user_hash = p_user_hash AND state = 'pending' AND expires > now();
+$$;
+
+-- Allow or deny the waiting device code of the user code as the user; whether there was one.
+CREATE OR REPLACE FUNCTION oidc_device_decide(p_user_hash text, p_name text, p_auth_time timestamptz, p_amr text[],
+                                              p_allowed boolean)
+RETURNS boolean
+LANGUAGE sql AS $$
+    WITH decided AS (
+        UPDATE oidc_devices SET state = CASE WHEN p_allowed THEN 'allowed' ELSE 'denied' END, name = p_name,
+                                auth_time = p_auth_time, amr = p_amr
+        WHERE user_hash = p_user_hash AND state = 'pending' AND expires > now()
+        RETURNING 1
+    )
+    SELECT count(*) > 0 FROM decided;
+$$;
+
+-- A poll of the device code: the row, whether it has expired, and whether it came sooner than poll_seconds after the
+-- last one, which adds 5 seconds to poll_seconds.
+CREATE OR REPLACE FUNCTION oidc_device_poll(p_hash text)
+RETURNS TABLE (client_id text, scopes text[], resource text, state text, name text, auth_time timestamptz, amr text[],
+               expired boolean, too_soon boolean)
+LANGUAGE sql AS $$
+    UPDATE oidc_devices AS device
+    SET polled = now(),
+        poll_seconds = device.poll_seconds +
+            CASE WHEN device.polled + make_interval(secs => device.poll_seconds) > now() THEN 5 ELSE 0 END
+    FROM (SELECT hash, polled, poll_seconds FROM oidc_devices WHERE hash = p_hash) AS previous
+    WHERE device.hash = previous.hash
+    RETURNING device.client_id, device.scopes, device.resource, device.state, device.name, device.auth_time, device.amr,
+              device.expires <= now(),
+              previous.polled IS NOT NULL AND previous.polled + make_interval(secs => previous.poll_seconds) > now();
+$$;
+
+CREATE OR REPLACE PROCEDURE oidc_device_delete(p_hash text)
+LANGUAGE sql AS $$
+    DELETE FROM oidc_devices WHERE hash = p_hash;
+$$;
+
 CREATE OR REPLACE PROCEDURE oidc_session_save(p_hash text, p_name text, p_amr text[], p_seconds integer)
 LANGUAGE sql AS $$
     DELETE FROM oidc_sessions WHERE expires < now();
@@ -104,10 +192,11 @@ LANGUAGE sql AS $$
     DELETE FROM oidc_sessions WHERE hash = p_hash;
 $$;
 
--- Remove every code, token and session of the user.
+-- Remove every code, token, device code and session of the user or service account.
 CREATE OR REPLACE PROCEDURE oidc_revoke(p_name text)
 LANGUAGE sql AS $$
     DELETE FROM oidc_codes WHERE name = p_name;
     DELETE FROM oidc_tokens WHERE name = p_name;
+    DELETE FROM oidc_devices WHERE name = p_name;
     DELETE FROM oidc_sessions WHERE name = p_name;
 $$;

debian-package/src/usr/share/vpn-router/sql/sites.sql

@@ -3,7 +3,9 @@
 
 SELECT pg_advisory_xact_lock(hashtext('vpn-router sites schema'));
 
--- A static web site: its host names, port, interfaces and TLS, and the group whose members change its files.
+-- A static web site: its host names, port, interfaces and TLS, the group whose members change its files, and its
+-- DNS: user, the router serves no records of its host names, or router, its name server serves A or AAAA records of
+-- them with the router's public, internal or external address (dns_address).
 CREATE TABLE IF NOT EXISTS sites (
     name text PRIMARY KEY,
     enabled boolean NOT NULL,
@@ -19,44 +21,60 @@ CREATE TABLE IF NOT EXISTS sites (
     editors text NOT NULL,
     modified timestamptz NOT NULL
 );
+ALTER TABLE sites ADD COLUMN IF NOT EXISTS dns text NOT NULL DEFAULT 'user' CHECK (dns IN ('user', 'router'));
+ALTER TABLE sites ADD COLUMN IF NOT EXISTS dns_address text NOT NULL DEFAULT 'public'
+    CHECK (dns_address IN ('public', 'internal', 'external'));
+
+-- The functions whose columns and the procedure whose arguments changed with dns and dns_address.
+DROP FUNCTION IF EXISTS sites_list();
+DROP FUNCTION IF EXISTS site_get(text);
+DROP FUNCTION IF EXISTS sites_served();
+DROP PROCEDURE IF EXISTS site_put(text, boolean, text[], integer, text, text, text, text, text, text, boolean, text);
 
 -- Every site, by name; the private key is left out.
 CREATE OR REPLACE FUNCTION sites_list()
 RETURNS TABLE (name text, enabled boolean, hosts text[], port integer, listen text, tls text, ca text,
-               certificate text, index_file text, spa boolean, editors text, modified timestamptz)
+               certificate text, index_file text, spa boolean, editors text, dns text, dns_address text,
+               modified timestamptz)
 LANGUAGE sql STABLE AS $$
-    SELECT name, enabled, hosts, port, listen, tls, ca, certificate, index_file, spa, editors, modified
+    SELECT name, enabled, hosts, port, listen, tls, ca, certificate, index_file, spa, editors, dns, dns_address, modified
     FROM sites ORDER BY name;
 $$;
 
 -- The site with its private key.
 CREATE OR REPLACE FUNCTION site_get(p_name text)
 RETURNS TABLE (name text, enabled boolean, hosts text[], port integer, listen text, tls text, ca text,
-               certificate text, private_key text, index_file text, spa boolean, editors text, modified timestamptz)
+               certificate text, private_key text, index_file text, spa boolean, editors text, dns text,
+               dns_address text, modified timestamptz)
 LANGUAGE sql STABLE AS $$
-    SELECT name, enabled, hosts, port, listen, tls, ca, certificate, private_key, index_file, spa, editors, modified
+    SELECT name, enabled, hosts, port, listen, tls, ca, certificate, private_key, index_file, spa, editors, dns,
+           dns_address, modified
     FROM sites WHERE name = p_name;
 $$;
 
 -- The enabled sites with their private keys, by name, for Caddy's configuration and certificate files.
 CREATE OR REPLACE FUNCTION sites_served()
 RETURNS TABLE (name text, enabled boolean, hosts text[], port integer, listen text, tls text, ca text,
-               certificate text, private_key text, index_file text, spa boolean, editors text, modified timestamptz)
+               certificate text, private_key text, index_file text, spa boolean, editors text, dns text,
+               dns_address text, modified timestamptz)
 LANGUAGE sql STABLE AS $$
-    SELECT name, enabled, hosts, port, listen, tls, ca, certificate, private_key, index_file, spa, editors, modified
+    SELECT name, enabled, hosts, port, listen, tls, ca, certificate, private_key, index_file, spa, editors, dns,
+           dns_address, modified
     FROM sites WHERE enabled ORDER BY name;
 $$;
 
 -- Add the site, or replace all its settings.
 CREATE OR REPLACE PROCEDURE site_put(p_name text, p_enabled boolean, p_hosts text[], p_port integer, p_listen text,
                                      p_tls text, p_ca text, p_certificate text, p_private_key text, p_index_file text,
-                                     p_spa boolean, p_editors text)
+                                     p_spa boolean, p_editors text, p_dns text, p_dns_address text)
 LANGUAGE sql AS $$
-    INSERT INTO sites VALUES (p_name, p_enabled, p_hosts, p_port, p_listen, p_tls, p_ca, p_certificate, p_private_key,
-                              p_index_file, p_spa, p_editors, now())
+    INSERT INTO sites (name, enabled, hosts, port, listen, tls, ca, certificate, private_key, index_file, spa, editors,
+                       dns, dns_address, modified)
+    VALUES (p_name, p_enabled, p_hosts, p_port, p_listen, p_tls, p_ca, p_certificate, p_private_key, p_index_file,
+            p_spa, p_editors, p_dns, p_dns_address, now())
     ON CONFLICT (name) DO UPDATE SET enabled = p_enabled, hosts = p_hosts, port = p_port, listen = p_listen,
         tls = p_tls, ca = p_ca, certificate = p_certificate, private_key = p_private_key, index_file = p_index_file,
-        spa = p_spa, editors = p_editors, modified = now();
+        spa = p_spa, editors = p_editors, dns = p_dns, dns_address = p_dns_address, modified = now();
 $$;
 
 CREATE OR REPLACE PROCEDURE site_remove(p_name text)

debian-package/src/usr/share/vpn-router/templates/Caddyfile.j2

@@ -4,6 +4,9 @@
 {%- if https_email %}
 	email {{ https_email }}
 {%- endif %}
+{%- if https_acme_ca %}
+	acme_ca {{ https_acme_ca }}
+{%- endif %}
 {%- if pki_cas %}
 	skip_install_trust
 	pki {

debian-package/src/usr/share/vpn-router/templates/oidc-page.html.j2

@@ -15,6 +15,8 @@ input { box-sizing: border-box; width: 100%; padding: 0.5rem; border: 1px solid
 button { width: 100%; margin-top: 1.25rem; padding: 0.6rem; border: 0; border-radius: 0.25rem; font-size: 1rem; cursor: pointer; background: #1d4ed8; color: #fff; }
 button.secondary { background: #fff; color: #1d4ed8; border: 1px solid #1d4ed8; margin-top: 0.75rem; }
 .error { background: #fee2e2; color: #991b1b; padding: 0.5rem 0.75rem; border-radius: 0.25rem; margin-bottom: 1rem; }
+ul { margin: 0 0 1rem; padding-left: 1.25rem; color: #4b5563; }
+#user_code { text-transform: uppercase; letter-spacing: 0.15em; font-family: ui-monospace, monospace; }
 .issuer { font-size: 0.75rem; color: #6b7280; margin: 1.5rem 0 0; }
 </style>
 </head>
@@ -27,25 +29,52 @@ button.secondary { background: #fff; color: #1d4ed8; border: 1px solid #1d4ed8;
 {%- if error %}
 <div class="error" role="alert">{{ error }}</div>
 {%- endif %}
-{%- if form %}
-<form method="post" action="/oidc/login">
+{%- if items %}
+<ul>
+{%- for item in items %}
+<li>{{ item }}</li>
+{%- endfor %}
+</ul>
+{%- endif %}
+{%- if decide %}
+<form method="post" action="/oidc/device/decide">
+<input type="hidden" name="user_code" value="{{ user_code }}">
+<button type="submit" name="decision" value="allow">Allow</button>
+<button class="secondary" type="submit" name="decision" value="deny">Deny</button>
+</form>
+{%- endif %}
+{%- if form or device %}
+<form id="sign-in" method="post" action="{{ action }}">
+{%- if device %}
+<label for="user_code">Code shown on the device</label>
+<input id="user_code" name="user_code" value="{{ user_code }}" autocapitalize="characters" autocomplete="off" spellcheck="false" required{% if not form %} autofocus{% endif %}>
+{%- else %}
 <input type="hidden" name="request" value="{{ request }}">
+{%- endif %}
+{%- if form %}
 <label for="name">Name</label>
-<input id="name" name="name" value="{{ name }}" autocomplete="username webauthn" autocapitalize="none" spellcheck="false" required autofocus>
+<input id="name" name="name" value="{{ name }}" autocomplete="username webauthn" autocapitalize="none" spellcheck="false" required{% if not device %} autofocus{% endif %}>
 <label for="password">Password</label>
 <input id="password" name="password" type="password" autocomplete="current-password" required>
 <label for="code">Code from the authenticator, when you have one</label>
 <input id="code" name="code" inputmode="numeric" pattern="[0-9]{6}" maxlength="6" autocomplete="one-time-code">
 <button type="submit">Sign in</button>
+{%- else %}
+<button type="submit">Continue</button>
+{%- endif %}
 </form>
-<form id="passkey-form" method="post" action="/oidc/login" hidden>
+{%- endif %}
+{%- if form %}
+<form id="passkey-form" method="post" action="{{ action }}" hidden>
 <input type="hidden" name="request" value="{{ request }}">
+<input type="hidden" name="user_code">
 <input type="hidden" name="passkey_id">
 <input type="hidden" name="credential">
 </form>
 <button id="passkey" class="secondary" type="button" hidden>Sign in with a passkey</button>
 <script>
-// A passkey sign-in begins at /oidc/passkey and posts the browser's answer to /oidc/login with the authorization request.
+// A passkey sign-in begins at /oidc/passkey and posts the browser's answer to the form's action with the authorization
+// request, or with the user code the sign-in form holds.
 (function () {
   var button = document.getElementById('passkey');
   if (!window.PublicKeyCredential || !PublicKeyCredential.parseRequestOptionsFromJSON) {
@@ -53,11 +82,16 @@ button.secondary { background: #fff; color: #1d4ed8; border: 1px solid #1d4ed8;
   }
   button.hidden = false;
   button.addEventListener('click', async function () {
+    var code = document.getElementById('user_code');
+    if (code && !code.reportValidity()) {
+      return;
+    }
     button.disabled = true;
     try {
       var begun = await (await fetch('/oidc/passkey', { method: 'POST' })).json();
       var credential = await navigator.credentials.get({ publicKey: PublicKeyCredential.parseRequestOptionsFromJSON(begun.options.publicKey) });
       var form = document.getElementById('passkey-form');
+      form.elements.user_code.value = code ? code.value : '';
       form.elements.passkey_id.value = begun.id;
       form.elements.credential.value = JSON.stringify(credential.toJSON());
       form.submit();

examples/azure/variables.tf

@@ -140,7 +140,7 @@ variable "deploy_workload_vm" {
 variable "repo_url" {
   description = "Base URL of the Debian package repository the router pulls vpn-router from."
   type        = string
-  default     = "https://gitea.koszewscy.waw.pl/api/packages/slawek/debian"
+  default     = "https://gitea.koszewscy.waw.pl/api/packages/koszewscy/debian"
 }
 
 variable "ubuntu_codename" {

examples/gcp/variables.tf

@@ -137,7 +137,7 @@ variable "deploy_workload_vm" {
 variable "repo_url" {
   description = "Base URL of the Debian package repository the router pulls vpn-router from."
   type        = string
-  default     = "https://gitea.koszewscy.waw.pl/api/packages/slawek/debian"
+  default     = "https://gitea.koszewscy.waw.pl/api/packages/koszewscy/debian"
 }
 
 variable "ubuntu_codename" {

release.py

@@ -32,19 +32,26 @@ def git(*args):
 
 
 def summary():
-    """The summary line of the first changelog entry, or None when it has none.
+    """The summary of the first changelog entry joined into one line, or None when it has none.
 
-    The summary is the entry's first text line: indented by two spaces, not a "*" item,
-    with a blank line between it and the header and a blank line after it.
+    The summary is the entry's first paragraph: lines indented by exactly two spaces, the
+    first not a "*" item, with a blank line between it and the header and a blank line after it.
     """
     lines = CHANGELOG.read_text(encoding='utf-8').splitlines()
-    if len(lines) < 4 or lines[1].strip() or lines[3].strip():
+    if len(lines) < 4 or lines[1].strip():
         return None
-    line = lines[2]
-    text = line.strip()
-    if not line.startswith('  ') or line.startswith('   ') or not text or text.startswith('*') or line.startswith(' -- '):
+    paragraph = []
+    for line in lines[2:]:
+        if not line.strip():
+            break
+        if not line.startswith('  ') or line.startswith('   ') or line.startswith(' -- '):
+            return None
+        paragraph.append(line.strip())
+    else:
         return None
-    return text
+    if not paragraph or paragraph[0].startswith('*'):
+        return None
+    return ' '.join(paragraph)
 
 
 def version():
@@ -61,7 +68,7 @@ def version():
 def main():
     global DRY_RUN
     parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument('-m', '--message', help='commit message; default: the summary line of the newest changelog entry, a line without "*" between blank lines right after its header')
+    parser.add_argument('-m', '--message', help='commit message; default: the summary of the newest changelog entry, a paragraph not starting with "*" between blank lines right after its header')
     parser.add_argument('-n', '--dry-run', action='store_true', help='print the git commands instead of running them')
     parser.add_argument('--no-push', action='store_true', help='commit and tag, but do not push')
     args = parser.parse_args()
@@ -69,8 +76,8 @@ def main():
 
     message = args.message or summary()
     if not message:
-        sys.exit(f'no commit message: pass -m, or start the newest entry of {CHANGELOG} with a summary line '
-                 'without "*", indented by two spaces, with a blank line above and below it')
+        sys.exit(f'no commit message: pass -m, or start the newest entry of {CHANGELOG} with a summary paragraph '
+                 'not starting with "*", indented by two spaces, with a blank line above and below it')
     tag = version()
     if subprocess.run(['git', 'rev-parse', '-q', '--verify', f'refs/tags/{tag}'], cwd=ROOT,
                       capture_output=True).returncode == 0: