Security - Calculated Fields (Forge)

Overview

Calculated Fields (Forge) is a custom-field library. Most of its fields are read-only: they derive their value from issue state already present in Jira - comments, changelog entries, links, project metadata, and parent hierarchy. One field, ToDo List, is interactive - users edit its items on the issue.

The app writes the values of its own custom fields back to Jira, and the contextual configuration of its own fields when it receives settings migrated from Data Center. It does not modify native Jira fields, post comments, transition status, change permissions, or alter any other Jira configuration.

The security posture follows directly from that scope:

  • Narrow write surface. The app holds two Jira write scopes: write:app-data:jira, which lets it store the value of its own custom fields on an issue, and write:custom-field-contextual-configuration:jira, which lets it write the configuration of its own fields’ contexts. There is no write:jira-work, no manage:*, and no delete:* scope, so the app cannot edit native fields, change schemes, screens or workflows, or delete Jira data.
  • Runs on Atlassian. Every resolver, scheduled job, and storage call runs inside Atlassian Forge. There is no companion server, no Heroku, no third-party processor. The Marketplace listing carries Atlassian’s Runs on Atlassian badge.
  • Sandboxed within Forge runtime. Each installation has its own Forge runtime and its own Forge KVS namespace, isolated per-site by the platform.
  • No user-supplied executable code. Configuration is point-and-click. There is no script engine, no template engine, no eval, no formula language. Nothing a Jira admin enters becomes executable code at runtime.
  • No external services. The manifest declares no external: permissions and no Forge Remotes. The app cannot make outbound HTTP calls.
Property Mechanism
Tenant isolation Per-installation Forge runtime; per-installation Forge KVS; identity via Forge platform context
Data residency Customer’s Atlassian-managed region (Forge inherits the Jira Cloud site’s data residency configuration)
Outbound network None - the manifest declares no external: scopes and no Forge Remotes
Sub-processors One only - Atlassian (Forge platform)
Encryption at rest Forge-managed for KVS
Encryption in transit Atlassian Forge HTTPS termination
Authentication Forge platform identity for app calls; server-side Jira administrator check on recalculation, Service Info, and Migration from Connect; Browse projects check on the ToDo List panel
App REST endpoints Two Forge apiRoute endpoints (GET / PUT /todo/items) for your scripts and integrations to read and replace ToDo List items (ToDo List REST API). They are Forge-hosted, reachable only through the Atlassian platform, and guarded by app-specific custom scopes
Marketplace publication Each release passes Atlassian’s automated and human security review
User-supplied executable code None - no template engine, no scripting, no eval-style configuration

For platform-level guarantees (tenant isolation, egress controls, Marketplace review pipeline), see Forge platform & security architecture.


Why these permissions?

JBCF Forge declares 12 Jira and platform scopes, plus 2 app-specific custom scopes that guard its own REST endpoints. All of them are declared in manifest.yml and reviewed by Atlassian on every release. The consent screen shown when you install or upgrade the app is the authoritative list for that version.

The table below explains why each scope is requested, not just what it grants. Jira REST calls are made under the app’s own Forge identity (asApp()) for calculation and background work.

Scope Why JBCF Forge needs it
read:jira-work Baseline read access to issues and their fields. Required to read the source data behind every calculated field (status history, assignee, reporter, summary, parent link, sprint, etc.).
read:jira-user Resolve user-typed source data into a displayable user reference. Used by fields that return a Jira user - last commenter, last status changer, resolver, last updater, project lead, component lead. The app stores only accountId; display name and avatar are rendered by Jira at view time.
read:field:jira Read custom-field schemas and the list of registered fields on the site. Needed to bind JBCF custom fields to their per-context configuration and to support hierarchical sort fields that read the rank field.
read:custom-field-contextual-configuration:jira Read per-context configuration of custom fields. Needed so that a JBCF field configured on one project context does not leak its configuration to another project’s screens.
read:field-configuration:jira Read the contexts of the app’s own custom fields and the projects and issue types they cover. Needed to work out which field context - and so which admin configuration - applies to the issue the ToDo List panel is rendering, and by the JCMA migration receiver to find the contexts it configures.
read:issue:jira Granular issue read for comments, changelog, links, subtasks, and worklog metadata - the inputs to the comment, changelog, and link-count fields.
read:project:jira Read project metadata for the issue’s project. Used by the project-lead field and to determine the project context for component lookups.
read:project.component:jira Read component metadata for the issue’s project. Used by the component-leads field to surface component leads on each issue.
write:app-data:jira Store the value of the app’s own custom fields on an issue, so that the value is indexed and available to JQL, filters, list views, and export. This scope does not grant access to native Jira fields.
write:custom-field-contextual-configuration:jira Write the contextual configuration of the app’s own custom fields. Used by the JCMA migration receiver to put settings migrated from Data Center (the status of Date of last transition, ToDo List defaults) into the contexts of the fields.
storage:app Read and write the app’s own Forge KVS namespace. Used for app settings (field bindings, per-context settings), service state, and ToDo templates. Calculated values are not kept in KVS - they exist only in the Jira field.
report:personal-data Report the Atlassian account IDs the app stores (the assignees of ToDo List items) to Atlassian’s Personal Data Reporting API once a week, so that data of closed accounts is cleared. See Personal data.

Two additional custom scopes - read:todo-list:jbcf:custom and write:todo-list:jbcf:custom - are declared by the app itself and required on its apiRoute REST endpoints (GET and PUT /todo/items). Custom scopes are granted at install time and are meaningful only inside this app - they grant nothing in Jira.

What is not requested

Apart from write:app-data:jira and write:custom-field-contextual-configuration:jira, which are limited to the app’s own fields, JBCF Forge explicitly does not request:

Not requested What it would have allowed
write:jira-work, write:jira-user Modifying native issue fields, users, comments, links, or transitions
manage:jira-configuration, manage:jira-project Changing schemes, screens, workflows, or project configuration
delete:* Deleting Jira data
read:me Reading the viewing user’s own profile
external: permissions, Forge Remotes Outbound HTTP to any non-Atlassian endpoint

Field values are written through the Forge custom-field value channel - the standard Forge mechanism for an app to set the value of its own custom field. Native Jira fields are never touched.


Storage

Storage What is stored Where
Forge KVS (storage:app) App settings (field bindings, per-context settings), service state, and ToDo templates. No copy of calculated values Atlassian-managed, encrypted at rest, isolated per installation
Jira custom field values The value of each JBCF field, including ToDo List items, written through the Forge custom-field value channel - the only place a calculated value exists Inside the customer’s Jira instance

There is no vendor-managed database. There is no third-party storage. Forge KVS is part of the Forge platform - Atlassian operates it, encrypts it at rest, and isolates it per installation. The namespace is private to the app; no other app or vendor can read JBCF Forge’s KVS.

Retention

JBCF Forge does not maintain its own retention policy for source Jira data - it reads what Jira itself stores at calculation time. Calculated values are not kept in KVS; the value in the Jira field is overwritten on every recalculation triggered by an issue event. ToDo List items live until a user edits or removes them. When the customer uninstalls the app, Atlassian deletes the per-installation KVS namespace as part of the standard Forge uninstall lifecycle.


Access control

  • Administrator actions. Starting, cancelling, and estimating a recalculation, Service Info, and the Migration from Connect tab are available to Jira administrators only. The check runs server-side; anyone else gets You need Jira administrator permissions to use this action.
  • ToDo List panel. The panel returns the items of an issue only to a user who has the Browse projects permission on that issue.

Data residency

Forge apps inherit the Jira Cloud site’s data residency configuration. If your Jira instance is pinned to a specific Atlassian region (for example, EU or US), the Forge runtime and KVS for JBCF Forge run in that region.

JBCF Forge does not introduce any additional storage outside Atlassian, so there is no residency exception to manage. See Forge platform & security architecture - Data residency for the platform-level guarantee.


Monitoring

JBCF Forge uses Atlassian’s built-in Forge app-monitoring tooling. There is no third-party APM, analytics SDK, or telemetry beacon.

  • Diagnostic events are emitted with [MONITOR] markers and read through the Forge App Logs API (available to the vendor inside Atlassian’s UI).
  • Logging is limited to what is needed to trace a calculation or an error. The app does not implement an automatic redaction layer, so Forge App Logs should be treated as the vendor-visible operational log they are, not as a PII-free surface.
  • Forge App Logs are readable only by the vendor through Atlassian’s App Logs API, and are retained by the platform for 14 days, after which they are pruned by Atlassian.

For a wider view of the platform’s monitoring and observability surface, see Forge platform & security architecture.


Personal data

Two kinds of personal data appear in JBCF Forge values:

  • Account IDs in user fields. Ten fields return a Jira user - for example cf-user-last-commented, cf-user-resolver, cf-user-project-lead. They are user-typed fields: the field value in Jira holds the user’s accountId, and Jira renders the name and avatar at view time. The app keeps no copy of these values.
  • Account IDs in ToDo List items. ToDo List items store the accountId of the user an item is assigned to.

JBCF Forge does not store user emails or display names, and it does not push data to any non-Atlassian system.

The Atlassian Personal Data Reporting API is used: a weekly scheduled trigger reports the account identifiers the app holds, which is how Atlassian informs the app about account deletion and update events so that stored personal data can be refreshed or removed. Beyond that, personal data is refreshed at the source - the field value is overwritten on the next recalculation.

For a deeper read on what counts as personal data under Forge, see Atlassian’s Forge developer documentation and the Security reference for auditors.


Vulnerability disclosure

To report a security issue or request a security review, contact JiBrok support or see the JiBrok Trust Center and Vulnerability Disclosure policy.