- How to read this
- Architectural foundation
- Threat model
- Scope to data category mapping
- Data flow
- GDPR and data subject rights
- Compensating controls
- Verification and evidence
- Contact
- Related documents
How to read this
This page consolidates the technical and privacy detail required for an external security review or a Data Protection Impact Assessment (DPIA) of Message Field for Jira Cloud (Atlassian Forge). It is written for security architects, CISOs, DPOs, and external auditors.
The authoritative references are:
- The Data Processing Agreement for legal categories of personal data, retention, sub-processors, and TOMs (Annex 1, 2, 3).
- The Permissions Reference for the full list of 32 OAuth scopes and what each enables.
- The Trust Center for SOC 2 Type II certification, CAIQ Lite, vulnerability disclosure policy, and certifications.
- The official Atlassian Forge documentation for platform-level guarantees that apply to every Forge app (tenant isolation, runtime sandbox, declarative permissions).
Where this page summarizes a fact from one of the references above, the reference is linked.
Architectural foundation
Message Field for Jira Cloud is Forge-native. Every component (UI, resolver, scheduled jobs, Rovo agents) runs inside Atlassian Forge. There is no companion service, no external database, no third-party processor.
| Property | Mechanism |
|---|---|
| Tenant isolation | Per-installation Forge runtime; per-installation Forge KV storage; identity via Forge platform context |
| Data residency | App data is held in Atlassian-hosted Forge storage; residency follows Atlassian’s Forge data residency support for the app as shown on the Marketplace listing |
| Outbound network | No external: scopes declared, so the app cannot call arbitrary hosts. The Forge runtime makes exactly one outbound call: the weekly account-ID submission to the Atlassian Personal Data Reporting API, an Atlassian-owned endpoint. Module icon images are served from jibrok.com to the end user’s browser and carry no data. See Outbound and DPA section 5.2 |
| Sub-processors | One only - Atlassian (Forge platform). See DPA Annex 3 |
| Encryption at rest | Forge-managed for app properties and KV |
| Encryption in transit | Atlassian Forge HTTPS termination |
| Authentication | Forge platform identity for app calls; Jira identity for impersonated calls (two read scopes: read:jira-work, and read:cmdb-object:jira for Assets object names) |
| Marketplace publication | Every release is distributed through Atlassian Marketplace, where Forge apps are subject to Atlassian’s automated security scanning; a release that changes declared scopes requires site-administrator approval before it takes effect |
| Issue mutation by app | None - the app does not declare write:jira-work and cannot create, update, transition, or delete work items. It does hold five write scopes, all administrative: app properties, UI Modifications and Message custom-field registration, field configuration, field default value, screen-tab placement. See What the app writes |
Other JiBrok Cloud apps. JiBrok’s other published Forge apps - JiBrok Studio for Jira Cloud and Time in Status for Jira Cloud (Forge) - inherit the same platform-level guarantees (tenant isolation, no external infrastructure, declarative permissions, single sub-processor) and are documented separately. The Forge builds of Timer field, Stopwatch field, Time between dates, Display Linked Issues, Fields panel for JSM and Calculated fields (JBCF) are also published on the Atlassian Marketplace, inherit the same platform-level guarantees and are covered by the DPA - JiBrok Cloud Apps (Atlassian Forge); Calculated fields (JBCF) has its own security reference. The Atlassian Connect builds of JiBrok’s Cloud apps run on JiBrok-operated infrastructure and are covered by the DPA - JiBrok Connect Apps. JiBrok maintains SOC 2 Type II certification for its organizational controls; evidence may be shared under NDA where appropriate.
Threat model
The table below enumerates the principal threats relevant to a Forge app of this class and the controls that mitigate them.
| Threat | Mitigation | Reference |
|---|---|---|
| Cross-tenant data leak | Forge per-installation runtime and storage; no shared memory, queues, or filesystem between tenants | Atlassian Forge - Tenancy |
Sandbox escape via eval / new Function |
Custom template interpreter; eval and Function constructors are not exposed to templates |
Template security |
| Sandbox escape via prototype pollution | Forbidden property keys (__proto__, constructor, prototype) blocked in template variables |
Template security |
| Resource exhaustion / denial of service via templates | 10,000-iteration cap on loops; 800 ms timeout per render | Template security |
| JQL injection via template variables | JQL built from template variables is escaped automatically; the jqlRaw filter is used only for values you construct and validate yourself, such as project IDs and issue keys |
Template Filters - jqlRaw |
| Unauthorized issue read via panel rendering | Default Actor (Viewing user) inherits the requesting user’s Jira permissions through impersonation on read:jira-work. Users only see panel content for issues they have Browse Projects permission on |
Impersonation in practice |
| Misconfigured actor exposing data to viewers | Only site administrators can choose the Actor; project admins (with delegation) cannot. A non-default actor is opt-in per panel. Note that the actor is not limited to the app identity - a site admin can pin a panel to any named Jira account, and every viewer of that panel then reads through that account’s permissions. Enumerating the non-default actors is a required review step | Admin Hardening - Day 1 |
| JSM portal data leak to unlicensed customers | JSM portal modules carry unlicensedAccess: customer, unlicensed, which the Forge JSM module specification requires for portal rendering. A portal panel renders only for the projects and request types selected in its configuration (context filters and display conditions), and the JSM portal modules can be disabled globally |
JSM portal specifics |
| Data exfiltration via outbound HTTP | Manifest declares no external: permissions. The app cannot make arbitrary outbound HTTP calls. The only egress is the Atlassian Personal Data Reporting API for the weekly GDPR job |
Architectural foundation |
| Privilege escalation via project-admin delegation | Delegation is opt-in per project, controlled exclusively by site admins. Delegated project admins cannot choose the actor, edit global or cross-project configurations, or modify global module toggles. They can read global and multi-project configurations that reach their project, so treat a global configuration’s message and JQL as visible to every delegated admin | Delegation playbook |
| Issue mutation by a malicious panel | Impossible - the app does not declare write:jira-work and has no scope to mutate work item content. The five write scopes it does hold reach only app properties, UI Modifications, and the Message custom field’s own registration and value; a panel configuration cannot direct a write at any other field |
What the app writes |
| IDOR via resolver payload | Resolvers take project, issue and account identifiers from the Forge request context rather than from client-supplied payload; payload-supplied identifiers are validated against the user’s access before any read or write | Source review under NDA (see Verification and evidence) |
| Rovo agent prompt injection | Rovo agents execute structured actions, not free-form code; each action passes through the same authorization checks as the equivalent admin-page resolver. The two agents are scoped to read/CRUD configurations and analyze panel data, never to mutate issue data | Rovo Integration |
| Scheduled trigger abuse | The three scheduled triggers (personal-data-report, uim-sync-scheduler, custom-field-cleanup-scheduler) run as the app, not as any user. They have fixed implementations and cannot be reconfigured by admins or users |
Data flow - Scheduled triggers |
| Webhook token disclosure | None - the app declares no webhook triggers and stores no webhook tokens | (Not applicable) |
| Compromised Marketplace publication chain | Releases are published only through Atlassian Marketplace with automated security scanning; declared permissions cannot expand without a new major version approved by the site administrator | Atlassian Marketplace - App review |
| Personal data over-collection | Manifest scopes are minimum necessary; only accountId is persisted (creator, updater and actor attribution); PII redaction in diagnostic logs |
DPA Annex 1.C, DPA Annex 2 |
Scope to data category mapping
The 32 declared scopes map to four data classes for DPIA purposes. The classification is based on what the scope exposes by design - not what an individual customer’s instance happens to contain.
| Data class | Definition |
|---|---|
| Personal Data | Identifies a natural person directly (account ID, display name) or by combination |
| Business metadata | Jira issue, project, sprint, version, component, label, status data and JSM Assets object names created by the customer |
| Configuration | Customer-controlled Jira administrative configuration (fields, screens, schemes) |
| System internal | Message Field’s own runtime state (license, app storage, app properties, agent integration) |
Mapping by category
| Category | Scopes | Data class | Notes |
|---|---|---|---|
| App Internal | storage:app, write:app-data:jira, read:license:jira |
System internal | App-owned KV storage, Jira app properties for module visibility, license info |
| Compliance | report:personal-data |
Personal Data | Account IDs only (creator, updater, actor); outbound to Atlassian Personal Data Reporting API |
| Issue & User Data | read:jira-work, read:issue:jira |
Business metadata + Personal Data when issues reference users (assignee, reporter, watchers) | read:jira-work is one of two impersonation-aware scopes (the other is read:cmdb-object:jira); read:issue:jira is its granular companion used in admin tooling |
| Issue & User Data | read:jira-user, read:user:jira |
Personal Data | Account ID and display name; Jira itself controls email visibility |
| Issue & User Data | read:issue-status:jira |
Configuration | Status vocabulary; not personal data |
| Project & Metadata | read:project:jira, read:project.component:jira, read:project-version:jira, read:issue-type:jira, read:priority:jira, read:label:jira, read:epic:jira-software |
Business metadata | Project structure and configuration vocabulary |
| Project & Metadata | read:user-configuration:jira |
Configuration | User locale only; no personal identifiers |
| Field & Screen Configuration | All 12 scopes | Configuration | Custom field, screen, and screen-scheme administration, plus the four write scopes Forge requires for the jira:uiModifications module. None of these scopes can read or write work item data - only the configuration metadata that determines how the Message custom field and the app’s UI Modifications are registered and rendered |
| JSM | read:servicedesk-request |
Configuration | Request-type metadata for JSM portal panel configuration |
| JSM Assets | read:cmdb-object:jira |
Business metadata | Object name only; read as the viewer, on the JSM portal as the app for fields of the customer’s own request |
| Rovo | read:chat:rovo |
System internal | Receives Rovo agent invocations |
For per-scope detail and impersonation flags, see the Permissions Reference. For the legal classification of personal data, see DPA Annex 1.C.
Data flow
All Message Field data resides inside Atlassian Forge. The diagram below shows where each data class is stored and how it leaves the perimeter (it does not, except for the GDPR account report).
+------------------------------+
| Customer Jira Cloud site |
| (per-installation Forge) |
| |
Admin UI <----> | Message Field functions |
Issue panel --> | (resolver, schedulers, |
JSM portal ---> | Rovo agents, custom field) |
| | |
| v |
| Forge KV + Jira app |
| properties + custom field |
| (configuration reference) |
+------------------------------+
|
| weekly batch
v
+------------------------------+
| Atlassian Personal Data |
| Reporting API |
| (account IDs only) |
+------------------------------+
Forge KV (storage:app)
The app’s primary persistent store. Configurations and per-module state are stored as namespaced keys; storage is isolated per Jira-site installation.
| Namespace / key family | Purpose |
|---|---|
| Panel configurations | Per-configuration record: name, message body, render type, JQL, link types, display fields, projects, issue types, request types, modal settings, actor setting |
| Module status | Module enable/disable flags consumed by displayConditions Jira expressions |
| Configuration matrix | Pre-computed module-to-configuration mapping for fast displayConditions evaluation |
| Delegation policy | List of projects where project-admin delegation is enabled |
| Custom field configuration mapping | Mapping between Message custom-field instances and panel configurations |
| UIM registration state | Per-config UI Modifications registration metadata used by the uim-sync-scheduler |
| Account tracking | Set of account IDs the app has stored (creator, updater and actor attribution), used by the personal-data-report scheduled trigger |
Jira app properties (write:app-data:jira)
The app writes module-status and configuration-matrix metadata as Jira app properties so that Forge displayConditions Jira expressions can evaluate panel visibility without invoking a resolver. App properties are scoped to the app’s installation; they are not arbitrary writes against issue or project entities. The app does not write entity properties on issues, projects, or users.
Custom field values (write:field.default-value:jira)
What the app publishes as the Message custom field’s value is a configuration identifier - a reference to the configuration to render. The rendered message is never written into the work item as text; the field renderer produces it at view time from the referenced configuration. An auditor reading the raw field value through the REST API, the issue navigator or an XML export sees the identifier, not message content.
This is the only write the app performs that is visible on a work item, and it targets a custom field the app itself owns - it is not a write against arbitrary work item fields. See Custom fields.
Outbound
The only outbound HTTP call from the app is to the Atlassian Personal Data Reporting API:
- Endpoint:
https://api.atlassian.com/app/report-accounts/ - Frequency: weekly scheduled trigger (
personal-data-report) - Payload: array of
{accountId, updatedAt}from the in-app account-tracking set - Purpose: required by Atlassian’s privacy compliance framework so account closures and updates are propagated back to the app
No customer data, panel configurations, or business metadata leaves Atlassian Forge. See DPA section 5.2.
One browser-side request exists and is not app egress: the app’s Jira module icons are declared as images hosted on jibrok.com, so the end user’s browser fetches them when a module renders. No app data and no Jira data is transmitted, and blocking the host does not affect how the app works. See the network allowlist.
Scheduled triggers
Three Forge scheduledTrigger modules are registered:
| Trigger | Cadence | What it does | Data touched |
|---|---|---|---|
personal-data-report |
Weekly | Submits stored account IDs to the Atlassian Personal Data Reporting API. Acts on responses (closed/updated) by clearing or refreshing local references | Account-tracking set in Forge KV; outbound HTTPS to Atlassian |
uim-sync-scheduler |
Hourly | Reconciles UI Modifications registrations with field-context changes. Re-registers stale UIM contexts and removes orphaned ones | UIM registration state in Forge KV; Jira app properties; Jira UIM API |
custom-field-cleanup-scheduler |
Hourly | Detects custom fields and contexts that have been deleted or trashed in Jira and disables orphaned panel configurations | Custom field configuration mappings in Forge KV; Jira field/screen catalogs (read only) |
All three run as the app (no impersonation) and have fixed implementations. They cannot be reconfigured at runtime; an admin cannot inject custom logic into them.
Rovo agents
Two rovo:agent modules are registered:
- Message Panel Agent (analyzer) - 7 actions:
getMessagePanel,getStatusSummary,searchLinkedByField,buildRelationshipTree,analyzeImpact,findBlockedIssues,detectCycles. Reads issue data through the sameread:jira-workimpersonation as the panel-rendering pipeline. - Message Panel Admin Agent - 23 actions: configuration CRUD (list / get / create / update / clone / toggle / bulk import / bulk export), reference data (
listProjects,listIssueTypes,listFields,listLinkTypes,listRequestTypes), help (getConfigSchema,getTemplateHelp,getConfigExamples,getTroubleshootingHelp,getFieldReference,getWizardStep), validation (validateConfiguration,validateExistingConfig), and diagnostics (healthCheck,findBrokenConfigs).
Each agent invocation passes through the same authorization layer as the equivalent admin-page resolver: a delegated project admin can use the admin agent only against their delegated projects; analyzer actions inherit Jira permissions on every issue read.
Prompt-injection mitigation: actions accept structured, typed inputs (issue keys, field IDs, configuration IDs) - not free-form natural-language commands. The agent prompt determines which action to invoke; the action handler enforces authorization in code, not in prompt.
GDPR and data subject rights
Roles and sub-processors
| Role | Party | Reference |
|---|---|---|
| Controller | Customer | DPA section 2.1 |
| Processor | JiBrok | DPA section 2.2 |
| Sub-processor | Atlassian (Forge platform) - sole sub-processor | DPA Annex 3 |
Categories of personal data
Two categories, defined in DPA Annex 1.C:
- Atlassian
accountId- stored as creator, updater and actor attribution for configuration items. The actor identifier is the account whose permissions a configuration’s Jira reads execute under. All three roles land in the same account-tracking set, so all three are submitted to the Atlassian Personal Data Reporting API and react to closures. - Configuration free-text fields - name, description, message content, JQL queries. Customer-controlled inputs; the customer determines whether any personal data is entered. The app does not parse these fields for personal data.
The app reads Jira issue and user data to render panel content but does not persist a copy. Issue data is fetched at render time and discarded after the response.
Data subject request handling
Message Field implements Atlassian’s Personal Data Reporting and erasure workflow. Atlassian’s central pipeline is the canonical source for closure and update notifications.
| Right | Mechanism |
|---|---|
| Right to be forgotten (Art. 17) | When the Personal Data Reporting API responds closed for an account ID, the app clears the relevant creator/updater references on configurations and removes the row from the account-tracking set |
| Right to rectification (Art. 16) | When the API responds updated, the app refreshes its updated_at timestamp for the account ID |
| Right of access (Art. 15) | Handled on the Customer’s documented instruction via privacy@jibrok.com (DPA section 8.1). The data held per account ID is limited to creator/updater attribution on configurations, which the Customer can also read from a configuration export |
| Right to data portability (Art. 20) | Configurations are exportable as JSON via Bulk Operations; JiBrok provides the remaining categories on the Customer’s instruction (DPA section 8.1) |
| Right to restriction (Art. 18) | The app supports per-configuration disablement and per-module global disablement, both controlled by site admins |
Retention
Per DPA Annex 1.E: configurations and account-tracking data persist while the app is installed. Uninstalling the app triggers Forge-platform-managed deletion of all app-owned storage, and JiBrok additionally deletes app data on written request to privacy@jibrok.com (DPA section 10.2). The app does not retain copies of issue or user data outside the active rendering pipeline.
PII redaction
In production the app emits diagnostic logs at the error and warn levels; warn is always on, and informational and debug logging is not emitted. Sensitive fields (account IDs, tokens, session-derived values) are redacted automatically at every level. See DPA Annex 2.
Compensating controls
Beyond the platform-level and architectural controls, customers can apply the following on the customer side. Each is documented in detail in the Admin Hardening Guide.
| Control | What it limits |
|---|---|
| Actor (impersonation) policy | Default Viewing user ensures every issue read passes through read:jira-work impersonation; non-default actors are opt-in per panel and configurable only by site admins. The alternatives are the app identity or any named Jira account, so the control is “review the non-default actors”, not “the app can only run as itself” |
| Delegation policy | Project-admin access is opt-in per project. The site admin controls which projects allow delegation and can revoke it at any time. Scope note: a delegated project admin can read global and multi-project configurations that reach their project, and can edit only the ones scoped to it |
| Module toggles | One toggle per rendering module, 14 in total: Issue Panel, Issue Activity, Issue Context, Issue Action, the six JSM portal modules (panel, header, subheader, footer, and the two create-form modules), the Dashboard Gadget, the app’s own Global Page and Project Page, and the Message custom field. Each toggle removes a class of rendering surface. There is no UI Modifications toggle and no Rovo toggle - UIM registration follows the configurations that need it, and Rovo agent availability is governed at the Atlassian site level rather than by this app |
| Display conditions | Per-configuration Jira expressions evaluated by the platform before resolver invocation; reduce rendering surface to specific projects, issue types, request types |
| Context filters | Per-configuration project / issue-type / request-type filters; complement display conditions with admin-friendly UI |
| Template engine sandbox | Always on; no admin toggle. No eval, no network, iteration cap, render timeout, JQL auto-escaping |
| Bulk export for forensics | Configurations exportable as JSON for offline review and incident-response artifacts |
Verification and evidence
Where to verify each claim:
| Claim | Where to verify |
|---|---|
| 32 declared scopes | The Marketplace listing’s installation prompt; the Permissions Reference; the manifest reviewed by Atlassian |
| SOC 2 Type II | JiBrok maintains SOC 2 Type II certification for its organizational controls; evidence may be shared under NDA where appropriate - see Security and SOC Reports |
| CAIQ Lite | Public PDF from Trust Center |
| GDPR DPA | Public DPA - Message Field for Jira Cloud |
| Vulnerability disclosure policy | Public Vulnerability Disclosure page |
| Forge platform guarantees | Atlassian Forge documentation |
| Sub-processor list | DPA Annex 3 |
| No outbound network beyond GDPR report | Manifest review (no external: block); the single runtime endpoint and the browser-side icon request are listed under Data flow - Outbound |
| No work item mutation capability | Manifest review (no write:jira-work declared); the five declared write scopes and their targets are listed under What the app writes |
| Source code review (under NDA) | Available for enterprise customers on request via security@jibrok.com |
Contact
- Security inquiries:
security@jibrok.com - Privacy and DPO inquiries:
privacy@jibrok.com - Vulnerability reports: see Vulnerability Disclosure
JiBrok is registered in the European Union (Republic of Cyprus). For legal entity details, see the Trust Center.
Related documents
- Permissions Reference - Every OAuth scope explained
- Admin Hardening Guide - Production checklist
- Delegation - Project-admin access control
- Modules - Per-module enable/disable
- Trust Center - SOC 2, GDPR, certifications
- DPA - Message Field for Jira Cloud - Data Processing Agreement
- Atlassian Forge documentation - Platform-level architecture

