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). It is written for security architects, CISOs, DPOs, and external auditors.

The authoritative references are:

Where this page summarizes a fact from one of the references above, the reference is linked.


Architectural foundation

JiBrok Studio for Jira Cloud is Forge-native. Every component (UI, resolver, storage, scheduled jobs) 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 SQL and 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 One endpoint only - the Atlassian Personal Data Reporting API (weekly account ID submission)
Sub-processors One only - Atlassian (Forge platform). See DPA Annex 3
Encryption at rest Forge-managed for SQL and KV; webhook tokens additionally encrypted by the app with AES-256-GCM, the key held in Forge secret storage
Encryption in transit Atlassian Forge HTTPS termination
Authentication Forge platform identity for app calls; Jira identity for impersonated calls
Marketplace publication Published through Atlassian’s Marketplace approval process; any change to declared scopes requires a new review and explicit administrator approval

For deeper architectural detail, see Forge Platform & Security Architecture.

Other JiBrok Cloud apps. JiBrok Studio is part of a portfolio of Cloud apps. The other published Forge builds - Message Field 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 those products 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 Tenant isolation
Sandbox escape via eval / new Function Custom interpreter with no Function constructor and no string-based eval - the eval builtin accepts only the ID of a saved script Script sandbox
Sandbox escape via prototype pollution Forbidden properties (__proto__, constructor, prototype, __defineGetter__, __defineSetter__, __lookupGetter__, __lookupSetter__); internal class metadata protected via Symbol Forge Platform & Security - Custom interpreter
Sandbox escape via coercion (e.g. {toString:'__proto__'}) Static analysis rejects computed and concatenated property keys that resolve to forbidden names, call / apply / bind on protected targets, and dunder overrides in the Python and Groovy engines Script sandbox
Resource exhaustion / DoS Per-trigger resource guards: execution time, AST node count, loop iterations, call depth, string and collection sizes, API call counts, and the size and number of generated downloadable files (scripts have no filesystem access) Limits
Data exfiltration via Jira REST API Six-level API access pipeline. A permanent blacklist that cannot be disabled blocks the sensitive endpoint families (webhooks, app properties, audit logs, license, user emails, account migration, expression evaluation) REST API restrictions
SSRF or arbitrary outbound HTTP Manifest declares no external: permissions. The sandbox has no fetch, XMLHttpRequest, or any HTTP client Egress controls
Privilege escalation via Application actor Application Run As mode is off by default. When enabled, it blocks all DELETE operations, issue notifications, group creation and membership changes, and create/update of workflow schemes, permission schemes, notification schemes and roles - the full list is in Application actor restrictions Application actor restrictions
Webhook token disclosure Tokens encrypted at rest with AES-256-GCM; the encryption key is held in Forge secret storage; timing-safe validation; per-webhook rate limits Webhook security
Compromised Jira admin account Compensating controls: full audit trail (Settings audit, Script Runs audit), Compliance Baselines with SHA-256 hashes, scheduled Drift Detection (auto-check) Audit Logs, Compliance & Drift
Compromised Marketplace publication chain Releases are published only through Atlassian Marketplace with Atlassian’s automated security scanning; declared permissions cannot expand without a new review and explicit administrator approval Scoped permissions
Personal data over-collection Manifest scopes are minimum necessary; impersonation-aware scopes inherit Jira-level permission checks; PII redaction in diagnostic logs DPA Annex 2

Scope to data category mapping

The 48 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, board, version, component, label, status data created by the customer
Configuration Customer-controlled Jira administrative configuration (fields, screens, schemes)
System internal Studio’s own runtime state (license, app storage, agent integration)

Mapping by category

Category Scopes Data class Notes
App Internal storage:app, write:app-data:jira, read:license:jira System internal Studio’s own KV storage, UI Modification entity properties, license info
App Internal report:personal-data Personal Data Account IDs only; outbound to Atlassian Personal Data Reporting API
Rovo read:chat:rovo System internal Receives Rovo agent invocations
Issue Data read:jira-work, write:jira-work, read:issue:jira, read:issue-details:jira Business metadata + Personal Data when the issue body references users (assignee, reporter, watchers) Impersonation-aware; checked against actor’s Jira permissions
Issue Data read:jira-user, read:user:jira Personal Data Account ID and display name; Jira itself controls email visibility
Issue Data read:issue-status:jira, read:issue-type:jira, read:priority:jira, read:label:jira Business metadata Configuration vocabulary; not personal data
Project Data read:project:jira, read:project.component:jira, read:project-version:jira Business metadata Project structure
Jira Software read:epic:jira-software, read:board-scope:jira-software, read:sprint:jira-software, write:sprint:jira-software Business metadata Agile artifacts
JSM read:servicedesk-request, write:servicedesk-request Business metadata + Personal Data when a request body or comment references users Customer requests and their comments, plus request-type metadata for UIM and recipe configuration
JSM manage:servicedesk-customer Personal Data Service desk customer accounts (account ID, display name) read or created by scripts
JSM Assets / CMDB All 7 CMDB scopes Business metadata + Personal Data when assets store user references Customer-controlled content
Field & Screen Configuration All 14 scopes Configuration Custom field, screen, and scheme administration
Jira Administration manage:jira-configuration, manage:jira-project Configuration UI Modification context registration

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 Studio 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 <----> |  Studio Forge functions      |
   Scripts  ---->  |  (resolver, triggers,        |
                   |   scheduled jobs, Rovo)      |
                   |          |                   |
                   |          v                   |
                   |  Forge SQL  +  Forge KV      |
                   |  + Forge Secrets             |
                   |  + Issue Entity Properties   |
                   +------------------------------+
                              |
                              | weekly batch
                              v
                   +------------------------------+
                   |  Atlassian Personal Data     |
                   |  Reporting API               |
                   |  (account IDs only)          |
                   +------------------------------+

Forge SQL

Studio stores structured data in Forge SQL. The data falls into the following groups:

Group Purpose Retention
Scripts and versions Source code, version history, folders and labels Until the script is deleted by an admin
Triggers and runs Trigger configuration, execution logs, run audit Rolling per-category limits (Limits)
GDPR tracking Account IDs Studio has stored, with their last-updated timestamp Until the account is closed by Atlassian or the record is deleted
User data Customer-controlled structured storage (custom tables) and issue links Until deleted
Field and UIM registrations Scripted Custom Field state and UIM context registrations Until removed
Async event processing Event deduplication, message queues, batch jobs Short-lived: bounded by event and job lifetimes
Scenarios Multi-step scenario execution state Until the scenario completes
API restrictions Per-script API restriction profiles Until deleted
Compliance Settings audit log, baselines, drift check results Rolling window for the audit log; baselines and drift results until deleted by an admin
Webhook security Encrypted webhook tokens, rate limit windows Until the webhook is deleted
Usage tracking Usage aggregates, issue-execution correlation Refreshed periodically

Forge KV (storage:app)

Content Purpose
Global API whitelist configuration Admin-configurable allowed endpoint patterns
Global API blacklist configuration Admin-configurable blocked endpoint patterns
Settings Trigger type toggles, event type toggles, Run As policy
Folder and label metadata Script organization
Parsed script cache The interpreter’s own parsed representation of saved scripts; scripts never become native JavaScript

Forge Secrets

Secret Purpose
Webhook token encryption key 256-bit AES-GCM key, generated per installation and held in Forge secret storage

Issue Entity Properties

Property Fields Purpose
studio-executions (per issue) lastRunAt, lastScriptId, runCount, hasErrors, scriptIds Lightweight execution tracking; no PII

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
  • Payload: the stored account IDs with their last-updated timestamps, sent in batches
  • Purpose: required by Atlassian’s privacy compliance framework so account closures and updates are propagated back to the app

No customer data, scripts, run results, or business metadata leaves Atlassian Forge. See DPA section 5.2.


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

The seven categories are defined in DPA Annex 1.C: account IDs, user display names, script metadata, script execution history, audit records, custom-table and queue data (customer-determined), and configuration metadata.

Data subject request handling

Studio 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, Studio removes the account from every place it is referenced - script, run and version author fields, the pre-configured Run As list, issue-link and service-project references, usage statistics - and deletes its account tracking record
Right to rectification (Art. 16) When the API responds updated, Studio refreshes the last-updated timestamp it holds for that account ID
Right of access (Art. 15) Handled on request: JiBrok assists the Customer with access requests via privacy@jibrok.com on the Customer’s documented instruction (DPA section 8.1)
Right to data portability (Art. 20) Scripts and configuration are exportable as JSON via Import & Export; JiBrok provides the remaining categories on the Customer’s instruction (DPA section 8.1)
Right to restriction (Art. 18) Studio supports per-script disablement and per-trigger-type freezing, both auditable

Retention

Per DPA Annex 1.F: execution history, audit records, and script versions are automatically pruned when reaching configured limits. See Limits for current values. Account-related data is anonymized upon account closure through the GDPR workflow described above. On uninstall, the Forge platform deletes all app-owned storage; JiBrok additionally deletes app data on written request to privacy@jibrok.com (DPA section 10).

PII redaction

In normal operation the app emits only error-level diagnostic logs. When an admin enables time-limited Diagnostic Logging, info-level trigger events are added for the chosen window and switched off automatically at the end of it. In both cases sensitive fields (account IDs, tokens, session-derived values) are redacted, and source code, issue data and PII are never logged. See DPA section 5.5.


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
Run As policy Which execution identities are available; restricting to Current User only removes the option to run as the application or as another user. Specific User is on by default and must be turned off explicitly
API Restrictions (whitelist) Reduces the set of Jira REST endpoints any script can call, even if the scope permits the call
API Restrictions (blacklist) Blocks specific endpoint patterns at admin discretion
Compliance Baselines Captures point-in-time SHA-256 hashes of scripts, settings, whitelists, globals, labels
Drift Detection Auto-checks current state against a baseline; alerts on changes
Audit Logs Settings audit and Script Runs audit are append-only and cannot be edited by admins
Trigger type toggles Disable trigger categories not in active use (UIM, Webtrigger, Rovo are off by default)
Webhook rate limits Per-webhook throttling in a fixed one-minute window; the limit is hardcoded and not admin-configurable
Diagnostic Logging Time-bounded; auto-disables; recorded in audit

Verification and evidence

Where to verify each claim:

Claim Where to verify
48 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
Vulnerability disclosure policy Public Vulnerability Disclosure page; participation in the Atlassian Marketplace Security Bug Bounty Program (Bugcrowd)
Forge platform guarantees Atlassian Forge documentation
Sub-processor list DPA Annex 3
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.



JiBrok Studio for Jira Cloud JiBrok Studio for Jira Cloud
Release notes
Core Features
Triggers
Extensions
Data Storage
Scripting Overview
JavaScript Engine
Python Engine
Groovy Engine
Scripting API
Administration
Guides