- 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). 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 48 OAuth scopes and what each enables.
- The Trust Center for SOC 2 Type II certification, CAIQ Lite, vulnerability disclosure policy, and certifications.
- The Forge Platform & Security Architecture for Atlassian-platform-level guarantees that apply to every Forge app.
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.
Related documents
- Permissions Reference - Every OAuth scope explained
- Admin Hardening Guide - Production checklist
- Security Overview - Sandbox, API restrictions, audit
- Forge Platform & Security Architecture - Platform-level protections
- Trust Center - SOC 2, GDPR, certifications
- DPA - JiBrok Studio for Jira Cloud - Data Processing Agreement
- Provider-Specific Terms - Studio
