Security Review — Table Audit & Export for Confluence

Reviewer: Le Hoang Quang Trung.
Target: Table Audit & Export for Confluence, Forge Custom UI app.
Method: white-box source code review.
Version 1.0 — 31 October 2026.

Read this first. I am the author of the application I am reviewing. This is a self-audit, and a self-audit is weaker evidence than an independent one. I am publishing it anyway for two reasons: a customer deciding whether to install this app is entitled to see what I found when I went looking, and anyone considering hiring me to review their code can see the method and the writing before they pay for it.

It is not a penetration test. No certification stands behind it. Section 7 states the limits in full.

1. Executive summary

The application has no backend, no database and no network egress of its own. I verified that claim against the source rather than taking it from the policy: outside Atlassian's own bridge call there is no fetch, no XMLHttpRequest, and no storage or analytics API anywhere in the shipped code. The architecture removes the categories of risk that normally dominate a review of a SaaS add-on. There is no server of mine to breach and no customer data at rest.

I found no exploitable vulnerability in the application code.

I did find five issues, and the most serious of them is not in the code. It is in my own published security policy, which claims two automated controls that do not exist. For a vendor whose argument to customers is that its claims are checkable, a claim that is not true is the worst defect available. It is listed first on purpose.

IDFindingSeverityStatus
F-01Security policy claims two automated controls that are not implementedMediumResolved 31 Oct 2026
F-02Licensing is enabled but the licence state is never checkedMediumOpen
F-03No upper bound on client-side work for a very large pageLowOpen
F-04DOM helper assigns arbitrary property names (latent sink)LowOpen
F-05Published automated-check count had drifted from the suiteInformationalPartly resolved

This document records the state at the time of review and the retest that followed. F-01 was fixed the same day, and the fix was verified rather than assumed; the finding is left in place rather than deleted, because a review that quietly removes what it found is not a review.

2. Scope

3. What the architecture rules out

Most of the value here is negative space, so it is worth stating what is absent and how I confirmed it.

PropertyHow it was verified
No egress from the appNo fetch, XMLHttpRequest, sendBeacon or WebSocket in app/static/ui/src/ or core/. The only network call in the codebase is requestConfluence, imported from @forge/bridge, which reaches Atlassian's API and nothing else.
No code evaluationNo eval, new Function, document.write, insertAdjacentHTML or srcdoc.
No HTML injection sinkNo innerHTML or outerHTML. The interface is built entirely with createElement / textContent / appendChild.
No persistenceNo localStorage, sessionStorage, IndexedDB, cookies, or Forge storage API.
Least privilegeOne scope, read:page:confluence. Read-only, and enforced by the platform rather than by my code.
No privilege escalationThe page is read through the bridge under the calling user's own Confluence permissions. The 401/403 handling path confirms this: a user without view access gets a permission error, not someone else's content.

Spreadsheet formula injection — checked, does not apply

This is the first thing I would look for in any tool that exports user-supplied text to a spreadsheet, so it is worth recording why it is not a finding.

The classic attack (CWE-1236) relies on a spreadsheet application parsing a leading =, +, - or @ as a formula. That happens with CSV, because the file is text and Excel re-parses it on open. This app does not emit CSV. Every text value is written into the worksheet XML as an inline string:

<c r="A2" t="inlineStr"><is><t xml:space="preserve">…</t></is></c>

A formula in OOXML lives in an <f> element. The writer never emits one. A cell containing =cmd|' /c calc'!A1 is carried through and displayed as that literal text.

Caveat I am not glossing over: this protects the file as delivered. It does not protect a user who afterwards copies a cell and pastes it somewhere that does re-parse it, or who re-exports the sheet to CSV. That residual path is a property of spreadsheets, not of this app, and no exporter can close it.

Output encoding and file construction

A privacy control worth naming

The feedback link is a mailto:, not a form. The subject carries only which screen the user was on. The page, its title, its id and its cell contents are never included. This is a deliberate decision recorded in the source, and it is the kind of control that is easy to erode later by adding "just a little" telemetry to a feedback form. It should be treated as load-bearing.

4. Findings

F-01 — Security policy claims two automated controls that are not implemented

SeverityMedium
CVSSNot scored. There is no exploitable condition here, so there is no honest vector to write. Assigning a CVSS score to a documentation defect would be theatre. The severity reflects contractual and reputational exposure, not attack feasibility.
Locationsecurity.html §5, "Secure development"

What the policy says:

What is true: both statements about the code are correct — the interface really does avoid innerHTML and inline script, and the bundle really does contain no secrets. Neither automated test exists. A search of the test suite for any assertion on innerHTML, inline content, or secret patterns returns nothing. The only match is a fixture string in an unrelated test.

Why it matters, in two separate ways:

  1. Accuracy. This policy is the document a customer's security review reads, and two of its sentences are not true today. That is the finding.
  2. The control's actual purpose is lost. The sentence claims the test exists so that the posture cannot be weakened by accident. Today's code is clean; nothing stops tomorrow's from not being. The guarantee was never present.

Reproduction: from the repository root, search the test directory for any assertion on the claimed properties. No result.

Recommended fix — implement the controls rather than soften the claim. Both are small, and they are worth more as tests than as prose:

// 1. CSP posture: fail the build if the bundle reintroduces a sink
const bundle = readFileSync('app/static/ui/build/main.js', 'utf8');
for (const sink of ['innerHTML', 'outerHTML', 'insertAdjacentHTML',
                    'document.write', 'eval(', 'new Function'])
  assert(!bundle.includes(sink), `bundle contains ${sink}`);

// 2. No secrets in the shipped bundle
for (const pattern of [/ATATT[A-Za-z0-9_-]{10,}/, /-----BEGIN [A-Z ]*PRIVATE KEY/,
                       /\b[A-Za-z0-9+/]{40,}={0,2}\b/])
  assert(!pattern.test(bundle), 'possible secret in bundle');

Until they exist, the two sentences should be removed from the policy. Shipping the tests is the better of the two options and is perhaps an hour of work.

Retest — 31 October 2026. Resolved.

Both controls were implemented rather than the claim being softened. test/test-bundle-safety.mjs was added to the suite and runs with it. It adds 23 checks against the build output — the file that actually reaches a customer's browser, which also covers anything arriving through @forge/bridge:

Verified by running the suite: 23 passed, 0 failed. The two sentences in §5 of the policy are now true. The deliberately narrow secret pattern is explained in the test's own comments — a scanner that cries wolf on every build is a scanner that gets deleted.

F-02 — Licensing is enabled but the licence state is never checked

SeverityMedium
CVSSNot scored. This is unauthorised use, not unauthorised access. No customer data is exposed. The loss falls on the vendor.
Locationapp/manifest.yml; app/static/ui/src/index.js

The manifest enables licensing:

app:
  licensing:
    enabled: true

Nothing in the application reads the result. A search for license, licence, active or isActive across the front end and the shared logic returns only a comment in the manifest. The comment is itself accurate and says so: "Turning it on only exposes the licence state to the app; it does not gate anything by itself."

Atlassian's own listing documentation describes the same division of labour: the manifest flag exposes the state, and the front end is expected to read license.active from the view context and decide what to do. This app never asks.

Consequence: a site whose 30-day trial has lapsed, or whose subscription has been cancelled, retains full functionality for as long as the app stays installed.

What I could not verify, stated plainly: I could not confirm from Atlassian's documentation whether the platform independently disables or uninstalls a Forge app when its subscription ends. If it does, the exposure is smaller than described. I did not assume either answer. This must be confirmed against current platform behaviour before anyone relies on it in either direction — including me.

Recommended fix. Read the licence state once, where the context is already being fetched, and render an unlicensed state instead of results:

const context = await view.getContext();
const licensed = context?.license?.active === true;
if (!licensed) return showUnlicensed();

One trap to avoid: the property is active on the front end. An older form, isActive, appears in back-end resolver examples and has been reported as permanently undefined on the front end — which fails open silently, giving the appearance of a working check. Whichever is used must be verified against the live context shape, not copied from an example.

F-03 — No upper bound on client-side work for a very large page

SeverityLow
CVSSNot scored. Self-inflicted availability only: the user must own or be able to view the page that harms their own browser tab. No cross-user impact.
Locationcore/ detectors; flow.js

The number of tables, rows and cells processed is unbounded. An 872 KB response was tested successfully, but nothing in the code refuses a pathological page, and all of the work happens synchronously in the user's tab. The realistic outcome is a frozen tab, not a compromise.

The download path has a second, smaller case: when the Blob route fails, the fallback base64-encodes the entire workbook into a data: URL in memory.

Recommended fix. Cap the number of rows examined, and say so in the interface rather than silently truncating — a tool whose purpose is accuracy must never quietly check less than it appears to.

F-04 — DOM helper assigns arbitrary property names (latent sink)

SeverityLow
CVSSNot scored. Not reachable in the current code. Recorded as defence in depth.
Locationapp/static/ui/src/index.js, el()

The element helper ends with a catch-all assignment:

for (const [k, v] of Object.entries(props || {})) {
  if (k === 'class') node.className = v;
  else if (k === 'text') node.textContent = v;
  else node[k] = v;          // <-- any property name
}

Every call site in the codebase passes literal keys, so this is not exploitable today and I am not claiming otherwise. But the helper is the single place the entire interface is built through, and a future key sourced from data — a column name, a value from a page — would make node['innerHTML'] = … reachable. The cost of closing it now is three lines.

Recommended fix. Replace the catch-all with an allow-list of the property names actually used (href, onclick, type, role), and throw on anything else.

F-05 — Published automated-check count has drifted from the suite

SeverityInformational
Locationsecurity.html §5; Marketplace listing; profile copy

The published figure was 724 automated checks. On the revision reviewed, the suite reported 720 (719 passed; one build check could not execute in the review environment because of a filesystem permission, and is counted as present).

Four checks is not a security issue. It matters because the number is offered as verifiable evidence, and a number anyone can run is a number that must be right. A figure that drifts quietly teaches a reader to discount the other figures.

Recommended fix. Either generate the number from the suite at release time, or publish it as a floor — "more than 700" — which stays true without maintenance.

Retest — 31 October 2026. Partly resolved.

With the 23 checks from F-01 added, the suite now reports 743, and the published figure has been corrected to match. The number is accurate today.

Still open: the structural part. The figure is still maintained by hand, so it will drift again. The recommendation above stands, and this entry stays open until it is either generated at release time or published as a floor.

5. What I looked for and did not find

Listing the negative results matters: it is the difference between a review and a list of whatever happened to turn up.

6. Dependencies

DependencyRoleNote
@forge/bridgeRuntime, directAtlassian's own. The only runtime dependency.
esbuildBuild timeDoes not ship to the browser.

The .xlsx writer is hand-written rather than taken from a library. That is a real security decision and not only a preference: it keeps third-party code out of a customer's browser, at the cost of owning every bug in the format handling. Section 3 is where that trade is paid for.

Limit: the transitive tree was not audited in this review.

7. Limits of this review

8. Summary for a non-technical reader

The app was built in a way that removes most of the risk rather than managing it. It keeps no copy of your data, sends your data nowhere, and can only read — never change — the single page you open it on. Those are not promises in a document; they are properties of how it is built, and this review checked each one against the code.

I found nothing an attacker could use.

I found that my own security policy claimed two safeguards I had not actually built. The safeguards were meant to stop the app getting less safe in future, not to protect it today, and today's code is clean either way. But the claim was wrong, and I would rather you read that here than discover it yourself.

That one is now fixed. I wrote the two missing tests the same day and they run with every build, so the two sentences in the policy are true. I have left the finding in this document rather than deleting it: a review that removes what it found is not worth reading.

Separately, the app does not currently check whether a customer's licence is still valid. That costs me money, not you.


Table Audit & Export for Confluence | Documentation | Security policy | Support | Privacy policy | support@trunkle.win