Security Reference for Auditors

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 same read:jira-work impersonation 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:

  1. 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.
  2. 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.