Security
This page is for people who run Frontforge Report Server. It says what to put in front of it, what to expose, where the secrets are, which requests reportd makes, and what bounds a render. It is a short threat model, not a certification: there has been no external penetration test yet.
What Frontforge Report Server guards against, in brief:
- People on the network who aren't signed in. They reach only reportd's sign-in, setup (with a one-time code) and public report links. Rate limits and a sign-in throttle slow guessing (rate-limits.md).
- Authors and API callers who try to make reportd reach what they can't. Every request reportd makes for a document, a data source, a webhook or a font goes through an address guard.
- Documents that try to use up the server. Every render has limits on pages, sub-report depth, size and time.
What it trusts: administrators, the machine and volume it runs on, and the services an administrator configures (identity providers, the assistant's provider, databases).
In front of reportd
reportd serves plain HTTP. It has no TLS of its own.
- Put a reverse proxy with TLS in front of it, and set
publicURLto the address people use, such ashttps://reports.example.com(custom-domain.md). With anhttpspublicURL, the session cookie is alwaysSecure, and is named__Host-session: a browser keeps such a cookie only for this exact host, withPath=/and noDomain, so a site on a sibling subdomain can't plant a session cookie for reportd. Over plain HTTP it issession, as before. Over HTTPS reportd reads only__Host-session, since asessioncookie there is just what a sibling could plant. Passkeys and sign-in providers need publicURL too. - Set
security.trustedProxiesto the proxy's address or network. Then reportd takes the client's address from the proxy's header, and believesX-Forwarded-Protoonly from the proxy. Without it, every client shares the proxy's rate limits and sign-in throttle (rate-limits.md). - Set
security.trustedOriginsonly if other sites' pages must send changes with a user's session. Empty is right for most installs. - On a workstation, plain
http://localhostis fine. Setup warns about plain http on any other host.
Ports
| Port | What | Expose it? |
|---|---|---|
| 43123 | reportd | Yes, to the proxy. With the proxy on the same machine, publish it on loopback only: 127.0.0.1:43123:43123 in docker-compose.yml. |
| 43124 | renderd | Never. |
| 5432 | Postgres (postgres.yml) | No. Compose doesn't publish it. |
renderd runs any document it is sent and has no users. In the image, reportd starts it on loopback. As its own service (split.yml, the Helm chart) it listens on the internal network and every call needs its token. renderd refuses to listen on any address but loopback without --token-file. The image exposes only 43123. A Unix socket (--unix, or renderer.unix for the renderd reportd starts) is made with mode 0660, whatever the umask, so only renderd's user and group can connect; put it in a folder that only they can reach, too.
Secrets
secret:references. A password, key or token in the config issecret:env:NAMEorsecret:file:NAME. File references are read fromsecrets.dir(/run/secrets/in the image). The administration site takes only references, never values (settings.md).Secret plugins answer references of their own name, such as
secret:vault:…(data-connections.md). reportd starts only the pluginssecrets.pluginsnames, by file name from the folders insecrets.pluginDirs, and refuses a folder or program that others can write to or that neither reportd's user nor root (on Windows, reportd's user, SYSTEM, the Administrators group or TrustedInstaller) owns;sha256pins the exact program. A plugin sees only the environment variables itsenvlists, never aREPORTD_one. Values cross only its standard input and output: never a command line, the environment or a file reportd writes. reportd keeps them in memory alone. A plugin's own network calls don't go through the address guard: you name where it signs in, and Azure's managed identity is a link-local address.The store plugin keeps the secrets typed into connection forms in
dataDir/plugins/store/store.json, sealed with AES-256-GCM under a data key its master key wraps, with a MAC over the file (data-connections.md). The master key comes only from asecret:env:orsecret:file:reference, neverconfig.yamlitself, and backups hold the file without the key. Lose the key and the stored secrets are gone: keep a copy apart from the backups, as forauth.mfaKey. No route returns a stored value, and a stored secret's reference opens only on the connection field it was set for. Onstate.driver: postgresreportd refuses to start it.The Vault plugin reads HashiCorp Vault's key/value secrets and writes none (data-connections.md). It needs a licence with
secret-vaults. Its sign-in credentials (a token, an AppRole secret id, a Kubernetes service account token) aresecret:env:orsecret:file:references, never written intoconfig.yaml. Its Vault token lives in its memory alone: it writes nothing todataDir/plugins/vault/, so backups hold none of it, and at stop it revokes the token it signed in for. Give that token a policy that reads only the paths connections need. No reference reads Vault's own paths (sys/,auth/,identity/,cubbyhole/), so a connection can't make the plugin hand over its own token. Use anhttpsaddress, withcaFilefor a private authority.The Azure Key Vault plugin reads only the key vaults its
vaultslists, and never writes to them (data-connections.md). Its client secret comes only from asecret:env:orsecret:file:reference, neverconfig.yamlitself; a managed identity needs no secret at all. It keeps its tokens in memory and writes nothing to its folder. Give its identity read access to those vaults' secrets alone.The AWS plugin reads Secrets Manager and never writes to it (data-connections.md). Its credentials come from the AWS SDK's default chain, in the variables its
envlists, or from a role it assumes through STS; it can read only what IAM grants them, so grantsecretsmanager:GetSecretValueon the secrets reportd needs and nothing wider. It keeps nothing on disk: its folder stays empty, so backups hold none of its credentials. Its calls to AWS, and to the instance or container metadata service, don't go through the address guard.The first administrator. By default there is none: reportd starts in setup mode. The one-time setup code goes to the log and to
dataDir/setup-code(mode 0600), and nowhere else. Setup deletes it. If you setadmin.passwordinstead, use asecret:reference; a literal password must be changed at the first sign-in.Keys reportd makes in
dataDiron first start, each mode 0600, when the config doesn't give one:File What it does Instead, set viewer-link.keySigns report links viewer.linkSecretmfa.keySeals the users' authenticator secrets auth.mfaKeysaml-sp.pemSigns SAML requests, decrypts assertions auth.saml.keyBackups leave these out on purpose, so a stolen backup can't make codes or sign links. Keep a copy apart from the backups, or set them as
secret:references (backup.md).dataDir/auth.jsonholds password hashes, API key hashes and sealed MFA secrets. Sessions are not in backups.Not encrypted at rest: the volume (templates, reports, data) and the keys above are plain files. Encrypt the disk.
Outbound requests
These requests go through reportd's address guard:
| Request | Allowed to | Setting for internal addresses |
|---|---|---|
| HTTP data sources | The connection's allowHosts (by default, its base URL's host); redirects to the same host only | connections[].allowPrivate |
| SQL data sources (postgres, mysql, mssql) | The address in the DSN, and the connection's allowHosts when it lists any; for SQL Server, the Browser lookup of a named instance too. Unix sockets are refused | connections[].allowPrivate |
| Data connections added in the studio (every driver but SQLite) | The hosts in data.connections.allowHosts, checked when the connection is saved, tested and opened, and on the address dialled; link-local and metadata addresses never (data-connections.md) | data.connections.allowPrivate, data.connections.allowLoopback |
| Remote assets, fetched once at publish | The environment's allowlisted origins; redirects to them only | assets.remote.<env>.allowPrivate |
| Job webhooks | The origins in jobs.webhooks.endpoints; no redirects | jobs.webhooks.endpoints[].allowPrivate |
| Font sources | The source's hosts | The source's "allow internal addresses" |
| The example gallery | examples.gallery, by default Frontforge's public releases repository on GitHub; an https gallery doesn't follow a redirect to http | None. For a gallery inside your network, use a folder (examples.md) |
| The version check, once a day | updates.releases, by default GitHub's API for that repository's releases; it sends no version, install ID or usage (updates.md) | None. Turn it off with updates.check: false |
The guard checks the address actually dialled, after DNS, so a name that resolves to an internal address is refused too. It refuses loopback, private, link-local (which includes cloud metadata at 169.254.169.254), carrier-grade NAT, multicast and reserved addresses, and IPv6 addresses that carry one of them (NAT64, 6to4). These requests use no proxy, since a proxy would hide the address. Every allowPrivate is off by default. Turn one on only for a service inside your network, and keep its hosts narrow.
On remote assets, font sources, template sources and job webhooks, allowPrivate opens loopback, private (10/8, 172.16/12, 192.168/16, fc00::/7) and carrier-grade NAT addresses only. Link-local addresses (169.254.0.0/16, fe80::/10), cloud metadata and host services (169.254.169.254, fd00:ec2::254, Alibaba's 100.100.100.200, Azure's 168.63.129.16), multicast and reserved addresses stay refused, the list studio connections use. The version check never reaches them either. Only on connections[] in config.yaml does allowPrivate still open link-local addresses too.
A database on the same machine or inside your network needs allowPrivate: true on its connection, as an internal HTTP service does. A postgres DSN should name its host: without one, on Linux, the driver looks for a Unix socket, which is refused. SQLite connections open a file and make no request.
These requests don't go through the guard, because an administrator names the address and it is often inside the network:
- sign-in providers: OIDC discovery and keys, and SAML metadata;
- the assistant's provider (the Anthropic API, or
agents.assistant.url); - renderd (
renderer.url,renderer.urls,renderer.discover).
Renders never fetch anything. renderd makes no outbound requests.
Render limits
reportd bounds what reaches it: request bodies (limits.maxBodyBytes, 20 MB), engine calls (engine.timeoutSec, else limits.timeoutSec, 30 s), the time a client has to send a request's headers (10 s), its body (5 minutes on upload routes: bundle and library files, imports, fonts, branding, whole drafts and edit batches, renders, tests, jobs, view sessions and MCP calls; 30 s on any other route), and to keep a connection open between requests (2 minutes), and the rate of requests (rate-limits.md). A body that isn't in by then is cut off, and the connection closed after the answer. Requests without a body, such as the event stream, and answers have no time limit, so a long render or stream isn't cut off.
renderd bounds what it runs:
- Bodies over 256 MB are refused (
--max-body). - Edit batches (
/v1/ops, which every draft edit goes through) hold at most 10,000 operations; a longer one is refused with413 too-largebefore any of it runs. - Work runs on as many workers as CPUs, with four times as many waiting (
--workers,--queue). When the queue is full, a call gets503 saturatedat once. - Each render stops at 2,000 pages, sub-reports 5 deep, 1,000,000 nodes, 10,000,000 expression steps, 60 seconds, 200 MB of data, and images of 20 MB or 50 megapixels. A render that passes one fails, with an error that names the limit. A request may lower these limits, but not raise them.
- reportd asks for no more time than it waits. A render's time limit is what is left of reportd's wait for it (
engine.timeoutSec, elselimits.timeoutSec), less 2 seconds for renderd to answer, when that is under renderd's own limit orrfml.limits.timeMs. With the defaults, a render stops at about 28 seconds with asecurity/limiterror, rather than running on to 60 seconds after reportd has stopped waiting. To allow longer renders, raiseengine.timeoutSecas well as the render limit. Time a render waits in renderd's queue isn't counted in its limit, so it comes out of those 2 seconds.
Documents carry no scripts. Rendered HTML is served under a policy that runs none.
Reporting a vulnerability
Write to security@frontforge.com. Please don't open a public issue. Say what you found, how to reproduce it, and which version you ran. We will answer, and agree on a date to publish once it is fixed.