Skip to content

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 publicURL to the address people use, such as https://reports.example.com (custom-domain.md). With an https publicURL, the session cookie is always Secure, and is named __Host-session: a browser keeps such a cookie only for this exact host, with Path=/ and no Domain, so a site on a sibling subdomain can't plant a session cookie for reportd. Over plain HTTP it is session, as before. Over HTTPS reportd reads only __Host-session, since a session cookie there is just what a sibling could plant. Passkeys and sign-in providers need publicURL too.
  • Set security.trustedProxies to the proxy's address or network. Then reportd takes the client's address from the proxy's header, and believes X-Forwarded-Proto only from the proxy. Without it, every client shares the proxy's rate limits and sign-in throttle (rate-limits.md).
  • Set security.trustedOrigins only if other sites' pages must send changes with a user's session. Empty is right for most installs.
  • On a workstation, plain http://localhost is fine. Setup warns about plain http on any other host.

Ports ​

PortWhatExpose it?
43123reportdYes, 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.
43124renderdNever.
5432Postgres (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 is secret:env:NAME or secret:file:NAME. File references are read from secrets.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 plugins secrets.plugins names, by file name from the folders in secrets.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; sha256 pins the exact program. A plugin sees only the environment variables its env lists, never a REPORTD_ 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 a secret:env: or secret:file: reference, never config.yaml itself, 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 for auth.mfaKey. No route returns a stored value, and a stored secret's reference opens only on the connection field it was set for. On state.driver: postgres reportd 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) are secret:env: or secret:file: references, never written into config.yaml. Its Vault token lives in its memory alone: it writes nothing to dataDir/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 an https address, with caFile for a private authority.

  • The Azure Key Vault plugin reads only the key vaults its vaults lists, and never writes to them (data-connections.md). Its client secret comes only from a secret:env: or secret:file: reference, never config.yaml itself; 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 env lists, or from a role it assumes through STS; it can read only what IAM grants them, so grant secretsmanager:GetSecretValue on 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 set admin.password instead, use a secret: reference; a literal password must be changed at the first sign-in.

  • Keys reportd makes in dataDir on first start, each mode 0600, when the config doesn't give one:

    FileWhat it doesInstead, set
    viewer-link.keySigns report linksviewer.linkSecret
    mfa.keySeals the users' authenticator secretsauth.mfaKey
    saml-sp.pemSigns SAML requests, decrypts assertionsauth.saml.key

    Backups 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.json holds 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:

RequestAllowed toSetting for internal addresses
HTTP data sourcesThe connection's allowHosts (by default, its base URL's host); redirects to the same host onlyconnections[].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 refusedconnections[].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 publishThe environment's allowlisted origins; redirects to them onlyassets.remote.<env>.allowPrivate
Job webhooksThe origins in jobs.webhooks.endpoints; no redirectsjobs.webhooks.endpoints[].allowPrivate
Font sourcesThe source's hostsThe source's "allow internal addresses"
The example galleryexamples.gallery, by default Frontforge's public releases repository on GitHub; an https gallery doesn't follow a redirect to httpNone. For a gallery inside your network, use a folder (examples.md)
The version check, once a dayupdates.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 with 413 too-large before 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 gets 503 saturated at 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, else limits.timeoutSec), less 2 seconds for renderd to answer, when that is under renderd's own limit or rfml.limits.timeMs. With the defaults, a render stops at about 28 seconds with a security/limit error, rather than running on to 60 seconds after reportd has stopped waiting. To allow longer renders, raise engine.timeoutSec as 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.