skip to content

A canary-token document from a decoy file share called back — what does that callback actually prove?

level: middleimportance: should knowfreq 40%

answer

  1. rendered, plus egress at that moment
  2. the source address is usually your gateway
  3. user agent names the renderer, not a person
  4. silence is not evidence of no access
  5. external source address is the strong case

basics

~20 s

It proves something rendered the file and that host could reach the token service then. It names no person and proves no copying: the source address is usually your egress gateway, the user agent the renderer.

solid answer

~50 s

A canary token fires when whatever opened the document fetched a remote resource, so the callback establishes two facts: the file was processed, and the processing host had network reach to the token service at that time. Everything else is inference. The source address is usually the corporate egress or proxy address, which collapses attribution to "somewhere inside the estate"; the user agent identifies the renderer — a word processor, a preview handler, a mail security service that detonates attachments, a search indexer — not a human. Silence proves even less: a copy opened on a host with no egress, or a renderer that blocked remote content, produces nothing. The reading that carries real weight is a callback from an address outside your estate, because that says the document left the decoy share and was opened somewhere you do not control.

code

json · 10 lines
json
{
  "token_id": "9f2c1a...",
  "token_type": "word_document",
  "memo": "FS01 decoy share /HR-Archive/2024-comp-review.docx",
  "time": "2026-02-11T02:14:37Z",
  "src_ip": "203.0.113.20",
  "user_agent": "Microsoft Office Word 2016 (16.0)",
  "geo": { "country": "NL" },
  "...": "..."
}

go deeper

for a junior

Be ready to say what a token fire means at its simplest: something opened the file and could reach the token service. Do not upgrade that to a claim about who opened it or whether it was copied.

for a middle

Explain the fields and their limits: source address is usually the egress gateway, the user agent names the renderer such as a previewer or mail scanner, and the memo is what identifies which decoy fired.

for a senior

Demonstrate directional discipline in the write-up — state rendering and egress as facts, actor and copying as unproven — and single out the callback from outside the estate as the case that changes the response.

for a principal

Own the limits of tokens as a control: they cannot be verified from their own output, so decide where they belong in a detection portfolio and never let a silent token be counted as coverage.

## What the token is and how it fires A canary token is a document, spreadsheet or similar file seeded with a reference to a remote resource under your control. When something renders the file, the renderer fetches that resource, and the token service records the fetch. Put such a file in a decoy share — a share visible in the file server's share list but referenced by no mapped drive, no script and no documentation — and you have a tripwire on the path between enumerating shares and reading what is in them. The callback record is the whole observation surface. It typically carries a token identifier, a memo you set at creation, a timestamp, a source address, and a user agent string from the fetching client. That is a short list, and reading it precisely is the skill. ## The two facts you actually have 1. **Something processed the file.** Not necessarily a person opening it deliberately — processing includes previewing, indexing, scanning and detonating. 2. **The processing host could reach the token service at that instant.** The fetch happened over the network, so egress existed at that moment from wherever the render occurred. Everything else in your write-up is inference and must be labelled as such. ## What the fields do not give you **The source address is rarely the opener's address.** Inside a corporate estate the fetch usually leaves through a proxy or network address translation gateway, so the token service records the estate's egress address. That collapses attribution to "someone or something inside", and recovering the internal client means correlating against other records — which is investigation work, not something the callback hands you. **The user agent names the renderer, not the person.** A word processor, an operating system preview handler, a link-following mail security product, a data-loss-prevention crawler and a search indexer all produce different strings, and none of them is an identity. A user agent belonging to a scanning product is a strong hint the file was processed by automation rather than read by a human. **Nothing proves copying or exfiltration.** The file may have been opened in place on the decoy share. A token tells you it was *rendered*, never that it was *taken*. **Nothing proves malice.** Backup verification, content indexing, migration tooling and an administrator checking what is in an unfamiliar share all render files. This is a real fire from a real interaction that may be entirely benign. ## What silence proves: nothing Absence of a callback is not evidence that the document was untouched. The file may have been copied and opened on a segment with no egress, or on an isolated host; the renderer may have blocked the remote fetch, which is the ordinary behaviour of a document opened in a protected or read-only mode with external content disabled; or the fetch may have been blocked by your own outbound filtering. Treat the token as a one-way signal: firing is informative, silence is not. ## The reading that matters The strongest interpretation is a callback whose source address is **outside** your estate. That says the file was rendered somewhere you do not control, which for a document that lived only on an internal decoy share is close to a statement that the file left. A user agent inconsistent with your standard build strengthens it further. That is the case the token was planted for, and it deserves a different response from a fire whose source is your own egress address at 02:00 on a Tuesday. Second-order details still worth reading: repeated callbacks in a short burst suggest automated processing rather than a person; a callback for a token whose memo places it in a share nobody should have browsed tells you which enumeration path was crossed, because the memo is the only thing that identifies *which* decoy fired. ## Writing the finding honestly The direction of every claim matters here, and it is what an interviewer is listening for. Say "the document was rendered by a client that reached the token service from our egress address at 02:14; the callback does not identify the host or the user, and does not establish that the file was copied." Do not say "an attacker opened our decoy document", because you have not shown an actor, an intent or a copy — and the moment such a claim goes into a report it will be repeated by someone who never read the caveat. ## What a strong answer sounds like "It proves the file was rendered and that the renderer had egress to the token service then. The source address is probably our proxy, and the user agent tells me what opened it — possibly a mail scanner or indexer, not a person. It does not prove copying or intent. The version I would escalate is a callback from an address outside our estate, because a document that only ever lived on an internal decoy share should not be rendering anywhere else."

  • The callback's source address is your corporate proxy. What have you lost?
    The identity of the internal host. The token service saw the gateway, not the client behind it, so the callback narrows the origin to the estate and no further. Recovering the host means correlating the exact timestamp and destination against proxy or connection records; until that lands, the honest statement is that a client inside the estate rendered the document.
  • No callback ever arrives from a token you planted. What does that tell you?
    Nothing about whether the file was accessed. The document may have been copied and opened on a host with no outbound path, the renderer may have blocked external content, or your own egress filtering may have dropped the fetch. Tokens are one-way evidence: a fire is informative, silence is not, and a token is not a monitoring control you can prove is working from its own output.
  • A callback arrives with a user agent belonging to a mail security scanner. How do you read it?
    As machine processing rather than a person reading. It suggests the document travelled through a mail path where an attachment scanner detonated it — which is itself worth knowing, because a file that only lived on an internal decoy share should not be passing through mail at all. The renderer identifies the process, so the question becomes how the file reached that pipeline.

saying these in an interview costs you the question

  • Reports the callback source address as the opener's workstation
  • Claims the callback proves the file was copied or exfiltrated
  • Treats the user agent as identifying a person
  • Reads absence of a callback as proof of no access
  • Calls every token fire an intrusion without checking the renderer

context