I got interested in DocAccess while looking at the JavaScript loaded by the City of Danville, Virginia. One of the scripts handled PDF links. A little further in, I found that another browser window could ask the page a question about a PDF. So I gave the page a 335-byte PDF of my own. The interesting part was which window got the answer.
A quick note on scope up front. Danville is where I found the include. I used my own pages and documents for the browser work, and an endpoint I controlled to record requests from the DocAccess service. I didn’t test any Danville accounts or protected city documents. City of Danville
What’s opening my PDF?
DocAccess is a CivicPlus document accessibility service. A publisher adds a script called docbox.js to its site. You click a document link and the helper can open it in a viewer. Behind that click, two different machines can have a reason to read a document. Your browser can check whether a PDF has changed. A DocAccess worker can fetch a document submitted for processing. DocAccess
That distinction mattered enough that I used a different kind of evidence for each. For the browser findings I had Chromium record what happened on my test pages. For the backend finding I wanted a request in my own server logs. An API telling me it queued a job would only get me halfway there.
Vuln 1 — The wrong window gets the fingerprint
The version checker has a perfectly reasonable job. If a publisher replaces a PDF at the same URL, the viewer needs some way to tell the two versions apart. The helper can read the file and calculate a fingerprint of its contents. The security decision comes one step earlier. Who gets to ask for that calculation, and for which document?
The main helper handles cross-window messages with postMessage. In the August snapshot, it recognized trusted senders by matching text in the origin. It could also queue a hash check when it failed to associate the sending window with the expected viewer frame. The customer page then had enough authority to read a PDF on its own site and enough information to send a result back to the window that asked.
This is the result the version checker builds after it reads the file. You can see exactly what a successful check reveals in docbox-check-document-version.js, lines 325–330.
return {
success: true,
md5: md5Hash,
sha256: sha256Hash,
fileSize: buffer.byteLength
};
I compared what the second window received with the file I had on disk.
File size reported to the second origin 335 bytes
SHA-256 reported to the second origin 90cbc9af3e4e57377a46845d5f7a50183c4f06b4efe0ccad3a85d4d57efb77b8
SHA-256 calculated from my copy on disk 90cbc9af3e4e57377a46845d5f7a50183c4f06b4efe0ccad3a85d4d57efb77b8
I used two local origins for that exchange. I checked the hostname-matching issue separately with a synthetic origin. Those tests answer different questions. The first shows the reply actually crossed an origin boundary. The second shows why the production trust check could mistake an unrelated hostname for one it recognized.
So what do you get out of a hash? Say you already have two editions of a document. You can hash both yourself. A matching reply tells you which edition the reader’s browser could see at that URL. That’s what I mean by a hash oracle. If the reader is signed in, the potential exposure depends on what their session can read. My capture shows a digest, a byte count and a success result for my test file. The other window never received the PDF itself.
I’d fix this where the page accepts the message. Check the exact origin and the identity of the viewer window, then bind the request to the document already open in that viewer. All three matter. Even a legitimate viewer shouldn’t get to nominate an unrelated file for the customer page to read.
Vuln 2 — A document link executes JavaScript
The second finding showed up in direct mode. Normally the helper builds a viewer URL. For a force-enabled link in direct mode, it can pass the link destination through to the viewer frame. That left the browser to interpret what kind of URL it had been handed.
These three lines are where the two modes diverge. In ordinary viewer mode, the PDF URL becomes a query parameter. In direct mode, it becomes the starting value for the navigation URL. From docbox.js, lines 1706–1708.
let url = direct
? pdfUrl
: `${base}/docviewer.html?url=${encodeURIComponent(pdfUrl)}`;
I used a marker on the top-level test page to settle a specific question. Would Chromium merely accept the URL as a frame attribute, or would it execute script? The page marker changed to direct-xss. Reading the attribute alone would have missed the most important part of that result.
There’s a prerequisite here worth spelling out. Someone needs a separate way to influence a force-enabled link on the publisher’s page, and a reader has to open it. I controlled the link on my page. Whether an outside user can supply one on a particular deployment depends on how that publisher accepts and renders content. Where both conditions hold, a link presented as a document can run script in the page context demonstrated by the test.
The place I’d fix this is the handoff to the frame. Parse the destination, allow only the web schemes the viewer actually needs, and apply the same rule to direct mode and ordinary viewer navigation. A shortcut in how you display the document shouldn’t change what the browser is allowed to execute.
Vuln 3 — DocAccessBot calls back
This time the browser could leave the picture. DocAccess accepted a document URL for processing without requiring a caller account. Fetching documents is part of the product. What I wanted to establish was how much control the caller had over where the worker went, and what I could actually observe from the other end.
The browser sends two distinct pieces of information here. One identifies the document and the other records the page where the helper found it. Here’s the request body as the helper starts building it in docbox.js, lines 1227–1230.
const requestBody = {
doc_url: normalizedHref,
found_on: foundOnUrl
};
The intake service returned a queued response. A few seconds later my endpoint recorded an HTTP GET carrying the path and query marker from my submission. The user agent identified itself as DocAccessBot/1.0. The marker is the detail I care about here. It ties a particular submission to a particular outbound request, even though the job ran asynchronously.
The August 21 capture contained 263 DNS events and six HTTP events. Three of the HTTP requests identified themselves as DocAccessBot. Those are event counts, so I wouldn’t read them as 269 separate fetch jobs. I also observed DNS activity for a controlled hostname configured to resolve to a link-local address. A DNS lookup establishes that a name was investigated. It tells me nothing on its own about whether the worker connected to the resolved address.
That’s the extent of my blind SSRF finding. An unauthenticated caller could direct a backend fetch to a server they controlled and observe the request there. Retrieval of loopback, private-network or cloud-metadata content was outside the test. I have no internal response body to show you.
For this one I’d start with the worker’s network access. Limit it to the destinations the service needs, validate the resolved address it will actually connect to, and repeat validation if the worker follows a redirect. A submission-time check alone leaves the worker making a second security decision later, when DNS or the destination may have changed.
Which version did I look at?
The municipal page loaded a script at an unversioned URL. I recorded hashes because somebody reading this later could visit the same URL and get different code.
| Main helper snapshot | Bytes | SHA-256 |
|---|---|---|
| Original August research copy | 142,199 | 4c6ff0a4dabad351345690804d7e15ff781b16222e40df8df21059c79d260f59 |
| August 22, 2026 recheck | 142,288 | f2c4aa0dad6089919a7585eefe3ef8947e7c0916dc755663d3f4f58bce97b54f |
The extra 89 bytes turned out to be a DiligentOne URL-normalization change. The relevant message handling, direct-mode navigation and intake code matched across the two copies. The August 22 review also recorded another backend callback. That’s the last behavior check covered by this write-up.
One other integration deserved a mention. I saw questionable URL forwarding in the SharePoint helper locally. I didn’t have a corresponding SharePoint deployment to follow it all the way through, so it remains an open question.
Research and disclosure timeline
- August 21, 2026 — Reviewed the browser helpers, captured both local Chromium results and recorded the backend HTTP and DNS interactions.
- August 22, 2026 — I emailed DocAccess to disclose the three issues. That day I also compared the updated bundle, rechecked the findings and prepared the CVE request material.
- September 24, 2026 — I sent DocAccess a follow-up email about the three issues.
- October 26, 2026 — I emailed DocAccess again about the disclosure.
CVE status — CVE numbers for all three findings are pending with VINCE-NT/MITRE.
The three classifications in my report were CWE-346 for the cross-origin hash reply, CWE-79 for direct-mode script execution and CWE-918 for the backend fetch. The detail I’d want a site owner to take away is where each fix belongs. The publisher’s page decides who can ask about a file and what a document link can open. DocAccess controls where its worker can connect. Changing one of those decisions still leaves the other two to address.
END TRANSMISSION
