In this section

Windows Data Exfiltration Forensics: SRUM, USB Devices, Cloud Sync and Staging

Module 0

Introduction

Exfiltration is the hardest finding on an endpoint to make well. Data leaving a machine is an ordinary event: mail is sent, files sync, browsers upload.

What makes a case is the combination of a channel that should not have been used, a volume that does not fit the work, timing that lines up with access to sensitive data, and staging that shows the data was prepared to leave. Each of those is recorded somewhere different, and none of them alone says what the data was.

1. Device and channelwhich USB device, which cloud account, which network2. Volume and timinghow many bytes, by which program, in which hour3. Stagingcopied, compressed, placed in the sync folder4. Contentwhich files were inside what left

An exfiltration finding in layers, from what one endpoint answers well to what it answers worst. The bottom row usually needs a second source.

This lesson builds an exfiltration finding on the insider case: the departing engineer whose morning on 5 March lesson 0.3 reconstructed. It identifies the device, the channel and the network, measures the volume, reads the staging, and lines up all of it across six days. Module 6 teaches each channel in depth and the arithmetic of quantifying what left.

01

The Questions

What a report has to answer

The case brief asks four questions, and they are the four every exfiltration investigation answers: what data left, through which channels, over what period, and whether it was deliberate. The figure above orders the evidence by how well one endpoint answers each.

Device, channel, volume and timing are recorded directly by Windows and are usually answerable to the minute. Staging is recorded indirectly, through the tools that did it. Content, which files were inside what left, is the weakest, because the program that moved the bytes rarely records what they were.

Mapped to the records that answer them:

The four questions, and where each is answered

Order of work

What left?

content: shortcuts and archives, then a second source

Which channel?

cloud client configuration, network profiles

When?

SRUM rows, device sessions, Prefetch run times

How much?

SRUM bytes sent, by program and network

Deliberate?

setup, staging and repetition across days

First read

SRUM, because volume picks the days

That order also sets the order of work. Start with the channel and the volume, because a volume that fits ordinary use ends the investigation early and a volume that does not tells you which days to look at. Then read the staging and the device on those days. Leave content until last, and state it at the strength the evidence supports.

The SOC's own trigger in this case was SRUM: a routine health check two days after the engineer's last day noticed unusual Dropbox traffic. The investigation reads that same database first, then works outward from the days it names.

02

The Device

One USB drive through five records

Windows records a USB storage device in several places at once, each holding a different identifier, and the investigator's job is to chain them. For the device in this case:

USBSTOR         SanDisk USB 3.0, serial 4C530001030926125224
                key last written 2026-03-05T11:14:22Z
setupapi        first install 2026-01-22T09:22:14Z (local time)
MountedDevices  E: -> volume {52512672-8840-1640-4638-508817792380}
                volume serial B7E2-1A4F
MountPoints2    jmorrison, last mount 2026-03-05T11:14:22Z

Each line comes from a different place: three registry locations in the SYSTEM hive, one in the user's NTUSER.DAT, and one plain-text log file in the Windows folder. None of them shares a single field with all the others, which is why the identification is a chain rather than a lookup:

USBSTORSanDisk USB 3.0serial ...5224MountedDevicesvolume GUIDletter E:Volume serialB7E2-1A4Fof the filesystemMountPoints2in jmorrison'sown hiveLNK filessame serialfiles opened

One device followed through five records. The hardware serial leads to a volume, the volume to a drive letter and a filesystem serial, and the filesystem serial to the files the user opened from it in lesson 0.3.

USBSTOR names the device by vendor, product and its hardware serial number. The setupapi device installation log, which Microsoft documents as the record the Plug and Play manager writes each time it installs a device, gives the first time this device was ever connected: 22 January.

MountedDevices maps the device to a volume GUID and the drive letter E:, and records the volume serial of the filesystem on it. MountPoints2, in the user's own registry hive, records that this user's session mounted that volume.

The serial number deserves a check before it is relied on. A device that does not report a unique serial of its own is given one by Windows, unique only on that machine, and the parsed record flags whether that happened. Here it did not: 4C530001030926125224 is the drive's own hardware serial, the same value the device reports on any computer it is plugged into.

If the drive is recovered, it can be matched to this host by that number.

The volume serial is the link to lesson 0.3. Every shortcut to a file on E:\Engineering_Backup recorded serial B7E2-1A4F. That is this device's filesystem, so the files the user opened from E: on four February days were opened from this SanDisk drive and no other. The case's machine saw 4 distinct USB serials over its life, and this is the only one whose volume appears in the shortcuts.

03

When It Was Connected

Seven sessions

The event logs record each time the device connected and disconnected:

2026-01-22T09:22:14  connect      2026-01-22T10:38:08  disconnect
2026-02-15T14:18:33  connect      2026-02-15T15:40:24  disconnect
2026-02-20T13:08:22  connect      2026-02-20T14:48:44  disconnect
2026-02-25T10:28:11  connect      2026-02-25T11:55:16  disconnect
2026-02-28T15:18:44  connect      2026-02-28T16:15:55  disconnect
2026-03-02T16:40:11  connect      2026-03-02T17:26:53  disconnect
2026-03-05T11:14:22  connect      2026-03-05T11:46:06  disconnect

Seven sessions, each between half an hour and an hour and three quarters long. The first, on 22 January, is the first install setupapi recorded. The other six fall on six days between 15 February and 5 March, always during working hours, and none on any other day in the period the logs cover.

The disconnect times bound what could have happened. A copy from the drive could only run while it was connected, so each session's length is the window for that day's staging, and every Prefetch run of the copying tools below falls inside one of these windows. A connect with no disconnect would mean the drive was still attached at shutdown or the log had rolled; here every session closes.

The first session matters separately. The same morning, Prefetch records DropboxInstaller.exe running once at 09:17:33, and the Dropbox client's own configuration records an account being set up at 09:24:11. The device was connected at 09:22:14, between the two.

On a single morning, within seven minutes, the user installed a cloud client, connected a USB drive for the first time, and configured the client. Each of those is innocent alone. Together, three weeks before the first upload, they read as preparation.

04

The Channel

Which account the data went to

A cloud sync client keeps its configuration on the endpoint, including the account it is signed in to and the folder it syncs. This user had three clients configured:

Dropbox   Personal  jmorrison.personal@gmail.com     created 2026-01-22
OneDrive  Business  jmorrison@northgateeng.com       created 2025-06-20
OneDrive  Personal  jmorrison.personal@gmail.com     created 2025-07-14

Two are expected: the company's OneDrive for Business, created when the user joined, and a personal OneDrive. The third is a personal Dropbox account, signed in with a personal Gmail address, configured on 22 January. Its sync folder is C:\Users\jmorrison\Dropbox, which lesson 0.3's ShellBags and 7-Zip jump list showed holding archives named for dates.

The personal OneDrive holds an open thread. Its client records 47 synced files and a last sync at 11:28:44 on 5 March, in the same minute ShellBags recorded the user in the Dropbox export folder.

Without the client's own database contents there is no way to say what those files were, so the report lists the account as a second possible channel that was checked and not resolved, rather than ignoring it or counting it.

The account details matter for what happens next. A personal account on a personal email address is outside the company's reach: it cannot be suspended from the company's admin console, and its contents can only be obtained from the provider or from the user. Identifying it precisely, by email address and the account identifier the client stores, is what makes a legal request possible.

A sync client is an exfiltration channel that needs no further action once configured. Anything placed in the sync folder is uploaded in the background to an account the company does not control, and the user never opens a browser or sends a message. That is why the client's configuration, and the account it names, are the channel evidence. The upload itself is recorded somewhere else.

05

The Volume

SRUM: bytes by program, by network, by hour

The System Resource Usage Monitor keeps a database of resource use per application and per user, written in periodic rows that each cover a span of time. SrumECmd's documentation lists its tables, including network usage per app and user, and notes that given the SOFTWARE hive it fills in the Wi-Fi profile names, which is what turns an interface number into Personal-Hotspot-5G. Every row recorded on the hotspot:

Hour (UTC)         App          Interface              Sent           Received
-----------------  -----------  -------------------  -------------  ----------
2026-02-15T14:20   Dropbox.exe  Personal-Hotspot-5G  1,247,000,000      32,711
2026-02-20T13:10   Dropbox.exe  Personal-Hotspot-5G  1,856,000,000      26,041
2026-02-25T10:30   Dropbox.exe  Personal-Hotspot-5G  2,341,000,000      27,068
2026-02-28T15:20   Dropbox.exe  Personal-Hotspot-5G  2,978,000,000      31,412
2026-03-02T16:42   Dropbox.exe  Personal-Hotspot-5G  3,564,000,000      28,664
2026-03-05T11:22   Dropbox.exe  Personal-Hotspot-5G  4,814,000,000      25,562
                                total                16,800,000,000     171,458

Six rows, all Dropbox, all on the six days the USB drive was connected. Each session sends gigabytes and receives kilobytes, the signature of a one-way upload.

On the corporate network the same Dropbox client never sends more than a few megabytes in an hour, with received bytes in the same range: ordinary two-way sync. The volume grows across the six sessions from 1.25 GB to 4.81 GB, and totals 16.80 GB.

The comparison with the corporate network is the strongest single argument in the case. Across all 19 of Dropbox's rows on the corporate network over two months, it sent 77 MB in total.

On the hotspot, in six rows, it sent 16.80 GB, roughly 218 times as much. The same program on the same machine behaved completely differently depending on which network it was on, and the network it sent the most over is the one the company could not see.

Two cautions apply to every SRUM figure. It is per application, so it cannot separate one Dropbox upload from another inside the same row, and it measures bytes on the interface, which includes the protocol's own overhead. Neither weakens the finding here, but both mean the figure is reported as measured network volume rather than as the size of a set of files.

The database itself, SRUDB.dat under System32\sru, is collected with the rest of the system files in any triage collection; lesson 0.1's KAPE run would have taken it.

The application table records the same hour from the disk side:

Hour (UTC)              2026-03-05T11:22
App                     Dropbox.exe
Foreground time         43 s
Background time         2693 s
Background bytes read   4,814,000,000
Foreground bytes read   6,328

The application table is a separate measurement taken by a separate part of SRUM, so agreement between the two is corroboration rather than repetition.

Dropbox spent 2693 seconds in the background and 43 in the foreground, and read 4,814,000,000 bytes from disk in the background: exactly the number it sent over the hotspot. Nobody was watching the client work. Files were placed in its folder and it read them and sent them.

06

The Staging

Copied, then compressed

Before data leaves, it is usually gathered and packed. Prefetch records the two tools that did it here, each with six runs:

2026-02-15   robocopy 14:20:11   7-Zip 14:25:55
2026-02-20   robocopy 13:10:55   7-Zip 13:14:22
2026-02-25   robocopy 10:30:44   7-Zip 10:33:11
2026-02-28   robocopy 15:20:33   7-Zip 15:22:44
2026-03-02   robocopy 16:42:22   7-Zip 16:45:33
2026-03-05   robocopy 11:22:11   7-Zip 11:25:22

Robocopy, a command-line copying tool built into Windows, ran on each upload day, and 7-Zip's file manager ran two to six minutes later each time. Lesson 0.3's jump list for 7-Zip named the archives it handled, one per date, in the Dropbox folder. The pattern is copy, compress, place in the sync folder, let the client upload.

Prefetch does not record where robocopy copied from or to; it records that it ran and when. The destination comes from elsewhere: lesson 0.3's ShellBags place the user in E:\Engineering_Backup and then in an Export folder in Documents within minutes of the robocopy run, and the jump list places the archives in Dropbox. Put on one clock, the day reads as a sequence:

USB in11:14:22SanDisk as E:Hotspot11:20 slotphone networkrobocopy11:22:11files copied7-Zip11:25:22archive madeDropbox4.81 GBsent, hotspot

5 March from five different records. Each step uses a different program, and the program that moved the bytes off the machine is the only one SRUM measures.

On 5 March the sequence is visible to the second across five records. The drive went in at 11:14:22; the hotspot's SRUM connectivity slot begins at 11:20; robocopy ran at 11:22:11 and 7-Zip at 11:25:22; Dropbox sent 4.81 GB over the hotspot in that hour; the drive came out at 11:46:06. Lesson 0.3's ShellBags place the user browsing E:\ and then the Dropbox export folder in the same half hour.

07

Six Days, One Pattern

Joining the sources

Before joining, decide what would break the pattern, so the join is a test rather than a search for agreement. A hotspot session with no USB connect, a Dropbox upload with no robocopy run, or a robocopy run on a day the drive was not attached would each weaken the reading that the drive fed the uploads.

An investigator who writes those down first, then looks, can say afterward that the pattern held against the checks that could have broken it.

One day's sequence could be coincidence. The case turns on whether it repeats. Lined up by date across four independent sources:

Date        USB in    Hotspot slot  robocopy  Dropbox sent on hotspot
----------  --------  ------------  --------  -----------------------
2026-02-15  14:18:33  14:18         14:20:11                  1.25 GB
2026-02-20  13:08:22  13:08         13:10:55                  1.86 GB
2026-02-25  10:28:11  10:28         10:30:44                  2.34 GB
2026-02-28  15:18:44  15:18         15:20:33                  2.98 GB
2026-03-02  16:40:11  16:40         16:42:22                  3.56 GB
2026-03-05  11:14:22  11:20         11:22:11                  4.81 GB

Every row has all four. The USB drive was connected, the hotspot was joined within minutes, robocopy ran, and Dropbox sent gigabytes over the hotspot, on all six days and on no other day. SRUM's connectivity table records the hotspot profile only on those six dates. These records are written by four different parts of Windows, none of which knows about the others, and they agree.

The span is worth stating as plainly. The channel was set up on 22 January, the first upload was on 15 February, and the last on 5 March, two days before the user's last day. That is six weeks from preparation to the final session, which is the time period the case brief asks for, with the first and last dates each fixed by more than one record.

That agreement is what supports the word deliberate. A user who copied a folder to a cloud drive once, on the corporate network, might have been careless.

A user who set up a personal account and a USB drive on one morning, then on six separate days connected the drive, switched to a phone's hotspot, copied, compressed and uploaded, has followed a procedure. The investigation module later in the course adds the user's own browser searches from before the first upload, which lesson 0.10 reads.

08

What the Endpoint Cannot Say

Content, and the second source

The finding is strong on everything except the one thing an employer most wants to know: exactly which files left. Written to that limit:

Exfiltration finding: DESKTOP-NGE-ENG14

Content needs a second source

Channel

personal Dropbox, over a personal phone hotspot

Volume

16.80 GB sent in six sessions, 15 February to 5 March

Source media

SanDisk USB, volume serial B7E2-1A4F, as E:

Staging

robocopy then 7-Zip on each of the six days

Content

files opened from E: are known; archive contents are not

Not seen

no mailbox rule forwarding outside the company

SRUM counts bytes on the network interface, not files. The shortcuts in lesson 0.3 name files the user opened from E:, and the jump list names the archives, but nothing on this host records which files went into each archive. Two routes close the gap.

The provider can be asked, through legal process, for the account's file history. Or the drive, if it can be recovered, can be examined. Until one of them happens, the report says the volume and names the files known to have been accessed from the staging media, and does not claim they are the same set.

It is tempting to fill the gap with the shortcuts. The files opened from E: carry names such as client pricing and confidential load analysis, and they were opened on the upload days. But opened is not uploaded, and an archive's contents cannot be inferred from what was opened beside it. If the report needs the content, it asks for the source that holds it.

The same discipline applies to the volume. The figure is what Dropbox sent over the hotspot; it does not include anything sent over the corporate network in the same period, which the comparison above shows was small, and it cannot include anything carried out on the drive itself. A report that gives one number for what left should say which of those it covers.

The last row records a negative finding: the user's mailbox holds no rule forwarding mail outside the company. Negative findings belong in the report, because the next question from a reader is always whether there was another route, and the answer should be that it was checked.

09

What Module 6 Builds On It

Every channel, and the arithmetic

Module 6 takes each part of this lesson into depth:

Module 6, in order

Module 6

SRUM

the volume question, and what an hourly row can carry

USB

devices and removable media across every record

Browser and cloud

downloads, uploads nobody logged, sync clients

Email

exports and attachments, and when export is a decision

Staging

copying and compression before anything leaves

Quantifying

what left, in numbers a report can defend

The SRUM lesson reads the database's tables and what one row can and cannot carry. The USB lesson covers every place a device is recorded. The browser and cloud lessons cover uploads made without a sync client, which leave far less. The quantifying lesson is the arithmetic a report needs: from bytes on the wire to a defensible statement of what left, with its error bars.

Each Module 6 lesson ends with the same kind of output this one did: a finding with its sources and its limit.

The See It Done lesson runs six routes for one departing employee and two reports from the same evidence, the first of which had every timestamp right and its volume figure wrong. It is the most useful single exercise in the module for anyone who will write these findings for HR or a lawyer.

The habit to carry into it is the order this lesson used. Measure the volume and find the days. Identify the channel and the device. Read the staging on those days. Join the sources by date until the pattern either holds or breaks. Then state the content at the strength the evidence gives it, and name the second source that would make it stronger.

Do

Practice

What left, how much, and how?
prepared evidence

The prepared evidence below is the insider's channel in three views: Dropbox's recent SRUM rows on two networks, the SanDisk drive's install and connect events, and the Prefetch record for three tools. Separate ordinary sync from the uploads, state the volume, and tie the device to the setup morning.

If you have a Windows machine of your own, run SrumECmd against a copy of your own SRUDB.dat with your SOFTWARE hive and open the network usage output. Find the program that sent the most data last week and the network it used. Most people are surprised by which program it is.

An exfiltration finding is built in layers. SRUM gives the volume by program, network and hour; the cloud client's configuration gives the account; the USB records give the device and its sessions; Prefetch gives the staging. Lined up by date, they make a pattern that one endpoint can establish to the minute. Which files were inside it is the one question the endpoint answers weakly, and the finding says so.

The next lesson goes beneath the artifacts to the filesystem itself, whose own records outlast most of them.

Resources

Microsoft revises these pages; where a page and this lesson disagree, the page is newer.