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.
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.
| ID | Finding | Severity | Status |
|---|---|---|---|
| F-01 | Security policy claims two automated controls that are not implemented | Medium | Resolved 31 Oct 2026 |
| F-02 | Licensing is enabled but the licence state is never checked | Medium | Open |
| F-03 | No upper bound on client-side work for a very large page | Low | Open |
| F-04 | DOM helper assigns arbitrary property names (latent sink) | Low | Open |
| F-05 | Published automated-check count had drifted from the suite | Informational | Partly 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.
app/static/ui/src/), and the shared logic it imports
(core/) — the ADF table reader, the defect detectors, and the hand-written
.xlsx writer.Most of the value here is negative space, so it is worth stating what is absent and how I confirmed it.
| Property | How it was verified |
|---|---|
| No egress from the app | No 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 evaluation | No eval, new Function, document.write, insertAdjacentHTML or srcdoc. |
| No HTML injection sink | No innerHTML or outerHTML. The interface is built entirely with createElement / textContent / appendChild. |
| No persistence | No localStorage, sessionStorage, IndexedDB, cookies, or Forge storage API. |
| Least privilege | One scope, read:page:confluence. Read-only, and enforced by the platform rather than by my code. |
| No privilege escalation | The 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. |
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.
xmlEscape escapes & < > " ' and strips
the C0 control characters that XML 1.0 forbids. Without the second step a single
\u0001 pasted into a Confluence cell would produce a file Excel calls
corrupt — a correctness bug that would have read as a security one.xl/worksheets/sheetN.xml and
friends). No user input reaches an archive path, so archive-path manipulation
("zip slip") has no entry point.sheetNames() —
[ ] : * ? / \ removed, control characters stripped, truncated to Excel's
31-character limit, de-duplicated case-insensitively, and never blank.fileName() strips path separators, Windows
reserved characters and control characters, collapses whitespace, caps at 80 characters,
and falls back to a fixed name when the result is empty.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.
| Severity | Medium |
|---|---|
| CVSS | Not 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. |
| Location | security.html §5, "Secure development" |
What the policy says:
innerHTML, no inline
script and no inline styles. An automated test asserts this on every build, so the
Custom UI content-security constraints cannot be weakened by accident."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:
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:
innerHTML, outerHTML,
insertAdjacentHTML, document.write, eval(,
new Function, srcdoc) must be absent from every shipped file;index.html must contain no inline script body, no inline
<style>, no style="" attribute and no inline event
handler;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.
| Severity | Medium |
|---|---|
| CVSS | Not scored. This is unauthorised use, not unauthorised access. No customer data is exposed. The loss falls on the vendor. |
| Location | app/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.
| Severity | Low |
|---|---|
| CVSS | Not 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. |
| Location | core/ 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.
| Severity | Low |
|---|---|
| CVSS | Not scored. Not reachable in the current code. Recorded as defence in depth. |
| Location | app/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.
| Severity | Informational |
|---|---|
| Location | security.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.
Listing the negative results matters: it is the difference between a review and a list of whatever happened to turn up.
| Dependency | Role | Note |
|---|---|---|
@forge/bridge | Runtime, direct | Atlassian's own. The only runtime dependency. |
esbuild | Build time | Does 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.
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