Windows shortcut (LNK) files and jump lists record which files, folders and network shares a user account reached, from which volume, and with which application, so they are one of the most dependable ways to reconstruct file and folder access on a Windows host. It walks through the structures inside a shortcut file, the two kinds of jump list, how to parse them with LECmd and JLECmd, and how to turn the output into a defensible timeline of access without overstating what the evidence proves.
For the wider set of Windows evidence sources, start with the Windows Forensic Artefacts Guide. For shortcut files used as a malware delivery method, see the Malicious LNK Files Guide. This page stays on the evidential side: what the files contain and how to read them.
Key takeaways
- The three timestamps and the file size in an LNK header describe the link target, not the shortcut file itself. Microsoft's [MS-SHLLINK] specification is explicit about this, and it is the single most common source of misreading.
- A shortcut can carry the target's local path, the volume's drive type, serial number and label, a network share name, command line arguments and the NetBIOS name of the machine that created it.
- Automatic destinations jump lists are OLE compound files with a DestList stream plus numbered streams that each hold an embedded LNK file. The DestList entry adds an entry number, a last modification time, a pin status and the host name.
- Custom destinations jump lists are a different, simpler format made of categories and embedded shortcut entries, each introduced by the LNK class identifier.
- Both jump list file names begin with an application identifier (AppID), which ties each list to the program that used it.
- Parse with at least two tools where a finding matters, keep the raw files, and record tool versions. LECmd and JLECmd both report damaged entries rather than failing silently, which you should check for.
- Treat shortcut and jump list evidence as showing that an account's shell recorded an interaction with a path. Proving a human opened a file needs corroboration.
Where shortcut files and jump lists live
According to the libyal Jump lists format documentation, automatic and custom destinations jump lists are stored under each user's profile in C:\Users\%USERNAME%\AppData\Roaming\Microsoft\Windows\Recent\. That directory contains Windows Shortcut (LNK) files and two subdirectories:
AutomaticDestinations, holding files with the extension.automaticDestinations-msCustomDestinations, holding files with the extension.customDestinations-ms
The same documentation notes that jump list information can also be stored in Explorer ProgramsCache registry values.
Because the location is inside a user profile, the evidence is per account. That matters for attribution: a jump list in one profile speaks to activity in that profile's logon sessions, whoever was at the keyboard. Collect every profile on the host, including service and administrative accounts, not only the account named in the alert. For acquisition practice, see the Disk Imaging and Forensic Acquisition Guide.
Inside an LNK file: what each structure tells you
Microsoft documents the format as the Shell Link Binary File Format, [MS-SHLLINK]. The libyal liblnk specification describes the same format from a forensic parsing view and lists its distinguishable elements: a file header, a shell item identifiers list, location information, data strings and extra data blocks. All values are little-endian and date and time values are FILETIME in UTC.
The header
The ShellLinkHeader is 76 bytes. [MS-SHLLINK] states that HeaderSize must be 0x0000004C and that LinkCLSID must be 00021401-0000-0000-C000-000000000046, which gives you a reliable signature check for carving and validation.
The header then holds data flags, file attribute flags, three FILETIME values, a file size, an icon index, a ShowWindow value and a hot key. The specification defines CreationTime, AccessTime and WriteTime as the creation, access and write times of the link target in UTC, and says a value of zero means no time is set on the link target. FileSize is the size of the link target in bytes; if the target is larger than 0xFFFFFFFF, it holds the least significant 32 bits.
This gives you two independent clocks for every shortcut:
- The shortcut file's own file system timestamps, from the master file table or file system metadata of the volume it sits on.
- The target's timestamps and size as embedded in the header at the time the shortcut was last written.
Comparing the embedded target size and times with the current state of the target, if it still exists, shows whether the file changed after the shortcut was written. If the target is gone, the embedded values may be the only record of its size and times.
Data flags
The data flags say which optional structures are present. liblnk lists, among others, HasTargetIDList, HasLinkInfo, HasName, HasRelativePath, HasWorkingDir, HasArguments, HasIconLocation and IsUnicode, plus ForceNoLinkTrack, which means the shortcut does not contain a distributed link tracking data block. Read the flags first: an absent block is not a parsing failure if its flag is clear.
Link target identifier list
When HasTargetIDList is set, the file contains a shell item identifier list describing the target as a path through the shell namespace. This is how a shortcut can describe targets that are not plain file paths. LECmd builds a full path from it, reported as TargetIDAbsolutePath in CSV output.
Location information
The location information (LinkInfo) has location flags that say whether the target was on a volume (VolumeIDAndLocalBasePath), on a network share (CommonNetworkRelativeLinkAndPathSuffix), or both. liblnk explains that the full file name is built by combining the local path with the common path, or the network share name with the common path.
The volume information carries a drive type, a drive serial number and a volume label. liblnk lists the drive type values, including DRIVE_REMOVABLE (2) for removable media, DRIVE_FIXED (3), DRIVE_REMOTE (4) and DRIVE_CDROM (5). For investigations into data moved to removable media, the drive type, serial number and label let you tie a shortcut to a specific device, which you can then correlate with the evidence in the USB Device Forensics Guide. LECmd has a -r option to process only shortcuts that point to removable drives.
The network share information holds the share name and, optionally, a device name such as a mapped drive letter. That is direct evidence that the account reached a path on a remote server, which is useful in lateral movement and data staging cases.
Data strings
Depending on the flags, up to five strings follow, in this order: description, relative path, working directory, command line arguments and icon location. Command line arguments deserve close attention. A shortcut whose target is an interpreter or script host with arguments is a different finding from a shortcut to a document. LECmd reports anomalies such as whitespace padded arguments, which is a known way to hide arguments from casual viewing.
Extra data blocks
Extra data blocks follow the strings and end with a terminal block. The one most investigators rely on is the distributed link tracker properties block. liblnk documents it as 96 bytes with the signature 0xa0000003, containing a machine identifier string and four GUIDs: droid volume identifier, droid file identifier, birth droid volume identifier and birth droid file identifier.
liblnk describes the machine identifier as an ASCII string, and the jump list DestList entry carries a comparable host name (or NetBIOS name) field. liblnk notes that the droid volume identifier can be found in the NTFS $OBJECT_ID attribute of the $Volume metadata file, and the droid file identifier in the $OBJECT_ID attribute of the target file. That means a shortcut found on one host can sometimes be matched to the volume and file it pointed to on another host or device. LECmd exports these as VolumeDroid, FileDroid, VolumeDroidBirth and FileDroidBirth, and its README says the tracker data identifies the machine and MAC address that created the shortcut.
Other blocks include environment variables location, known folder location, special folder location, the metadata property store and shim layer properties. Not all extra data blocks are controlled by the header flags, so a parser that only reads flagged blocks can miss data.
Automatic destinations jump lists
The libyal documentation describes jump lists as a Windows Taskbar feature, introduced in Windows 7, that gives the user quick access to recently accessed application files and actions. Automatic destinations files use the OLE Compound File format. Each one contains a DestList stream and a set of streams with hexadecimal names. Each numbered stream contains a Windows Shortcut (LNK) file, so everything in the previous section applies to every entry.
The DestList stream
The DestList stream starts with a 32-byte header that records a format version, the number of entries and the number of pinned entries. The documented format versions are 1, used in Windows 7, and 3 and 4, used in Windows 10. The stream can be zero bytes if the file is empty.
Each DestList entry carries fields that the embedded shortcut does not:
- Droid volume and file identifiers, and birth droid volume and file identifiers, as GUIDs containing NTFS object identifiers.
- A host name (or NetBIOS name), as a 16-byte ASCII field.
- An entry number, which links the entry to the numbered stream holding its shortcut.
- A last modification time as a FILETIME.
- A pin status, where -1 means unpinned and 0 or greater means pinned.
- The path, as a UTF-16 little-endian string.
For version 3 and later, the libyal document marks a field at offset 116 as an unknown value that may be an access count. Its meaning is not confirmed in that documentation, so report it as the value your tool labels it with and do not treat it as a proven open count.
Why the DestList time matters
The DestList last modification time belongs to the jump list entry. The embedded shortcut header times belong to the target. The OLE container and the jump list file have their own file system times. Keep these three sources separate in your timeline and label each one by where it came from. The DestList time is often the value closest to "when did this application last record this item", which is usually the question.
Custom destinations jump lists
Custom destinations files live in the CustomDestinations subdirectory. They are not OLE compound files. The libyal documentation describes a file header with a format version and number of categories, followed by zero or more categories. Category types are custom (0), known (1) and user tasks (2). Known categories use identifiers such as KDC_FREQUENT (1) and KDC_RECENT (2). Each category ends with the footer signature 0xbabffbab.
Entries are shell objects introduced by a class identifier. Windows Shortcut entries use 00021401-0000-0000-c000-000000000046, the same LNK class identifier found in a shortcut header. The libyal document warns that the file size in the embedded shortcut is not reliable for indicating the size of the shell object data, which matters if you try to carve these entries by hand.
Application identifiers
Both kinds of jump list are named after the application identifier, in the form %ID%.automaticDestinations-ms or %ID%.customDestinations-ms. The libyal documentation describes the identifier as a 64-bit CRC of the full path of the application's executable, computed after converting the path to upper case UTF-16 little-endian and normalising it using known folder identifiers.
Two consequences follow. First, the same application installed at a different path produces a different AppID, so lookup tables are not exhaustive. Second, an unknown AppID is a lead, not noise: it can indicate a portable or renamed executable. JLECmd shows "Unknown AppId" for these and accepts an --appIds file in appid|description format to extend its built-in list with your own mappings.
Parsing with LECmd and JLECmd
Eric Zimmerman's LECmd parses shortcut files and JLECmd parses jump lists, both automatic and custom, including Windows 10 and 11 versions. The versions documented at the time of writing are LECmd 2026.10.4 and JLECmd 2026.10.6. For the wider tool set and installation, see the EZ Tools Guide.
Illustrative commands
The commands below use options documented in each tool's README. Paths are examples; point them at your mounted evidence or triage collection, never at a live system you are trying to preserve.
- Parse every shortcut under a collected profile to CSV, quietly:
LECmd.exe -d "E:\triage\Users\alice" --csv "E:\out\lnk" -q - Parse only shortcuts that point to removable drives:
LECmd.exe -d "E:\triage\Users\alice" -r --csv "E:\out\lnk-removable" - Parse a user's Recent directory jump lists, with higher precision timestamps and a user column:
JLECmd.exe -d "E:\triage\Users\alice\AppData\Roaming\Microsoft\Windows\Recent" --csv "E:\out\jl" --mp --user alice - Export the shortcuts embedded in jump lists for separate parsing with LECmd:
JLECmd.exe -d "E:\triage\...\Recent" --dumpTo "E:\out\jl-lnk"
Reading the output
JLECmd writes two CSV files, one for automatic and one for custom destinations. The --ld option adds more detail about the embedded shortcuts and --fd adds all of it. The --withDir option shows contents of the directory not accounted for in DestList entries, which helps when a list has been partly cleaned. LECmd's CSV includes Name, IconLocation, ShowWindow, EnvironmentVariables, the four tracker droids and an Anomalies column.
Both tools parse damaged files as far as possible and report what they could not read. LECmd also identifies shortcuts damaged by a text mode copy. Both exit with code 0 when damaged files are reported, so do not treat a successful exit as proof that every entry parsed. Read the console log (saved by default through the --co option) and the anomaly column.
Reconstructing file and folder access: a workflow
- Scope the question. Write down what you need to show: that a specific file was reached, that a share was browsed, that data went to a removable device, or which applications an account used in a window.
- Collect per profile. Take the Recent directory, both jump list subdirectories and a sweep of
*.lnkfor every profile. Hash the collection and record the acquisition time. - Parse twice. Run LECmd and JLECmd, and validate key entries with a second parser built on a different code base, such as one using the libyal libraries.
- Build a source labelled timeline. For each entry record the shortcut or jump list file system times, the DestList time where present, and the embedded target times, each in its own column. The Forensic Timeline Analysis Guide covers merging these with other sources.
- Resolve the target. Use the local path, network share name and volume serial to identify where the target was. Use droid identifiers to match against $OBJECT_ID values on candidate volumes.
- Check the machine identifier. A machine identifier that is not the host you are examining suggests the shortcut or list was created elsewhere, for example copied in on removable media or synchronised in a roaming profile.
- Corroborate. Pair each important finding with an independent source: file system metadata on the target volume, server side file share audit logs, endpoint telemetry or application logs.
- Write findings at the right strength. Say "the account's jump list for application X contains an entry for path Y with a DestList time of Z" rather than "the user opened Y at Z" unless corroboration supports the stronger claim.
Interpreting timestamps and tracker data carefully
Most errors in shortcut analysis come from mixing up whose time a value is. A simple rule set helps:
| Value | Belongs to | Source |
|---|---|---|
| CreationTime, AccessTime, WriteTime in LNK header | The link target | [MS-SHLLINK] ShellLinkHeader |
| FileSize in LNK header | The link target (low 32 bits if larger than 0xFFFFFFFF) | [MS-SHLLINK] ShellLinkHeader |
| DestList last modification time | The jump list entry | libyal Jump lists format |
| File system times of the .lnk or jump list file | The shortcut or jump list file itself | File system metadata |
| Machine identifier and droids | Link tracking data for the target | libyal liblnk |
A header time of zero is a documented state, meaning no time was set on the target, not a parser fault. Out of range timestamps are flagged by LECmd as anomalies and should be explained before they appear in a report.
Shortcuts can be created or edited by software and by attackers. ATT&CK tracks shortcut abuse for persistence as T1547.009 Shortcut Modification. If you are examining a shortcut in a Startup folder, read its target, arguments and icon location as possible persistence, and cross check with the How to Hunt for Persistence on Windows guide.
Where identity fits
Shortcut and jump list evidence is tied to a user profile, so its value depends on knowing which identity that profile belongs to and how it was used. In incidents involving service accounts, shared administrative accounts or automation identities, a jump list in that profile shows what was reached under the identity, not which person or process drove it. Map the profile SID to the account, then check logon events and session data for the times in question.
Compare network share paths in shortcuts with what the account is supposed to reach. A service account whose profile holds shortcuts to finance shares, or an interactive jump list for an account that should never log on interactively, is a strong signal that the credential was used by someone else. This is where shortcut evidence feeds directly into non-human identity review and credential rotation decisions.
Common failure patterns
- Reporting target times as access times. The header times are the target's own timestamps as recorded, not the time the shortcut was used.
- Collecting one profile. The account in the alert is rarely the only one involved. Missing service or administrative profiles loses the most useful lists.
- Trusting AppID tables blindly. AppIDs depend on the executable path, so an unknown or mislabelled AppID needs checking, not dismissal.
- Ignoring damaged entries. Tools exit successfully while reporting damaged data. Unread anomaly columns hide partial cleaning and tampering.
- Overstating the unknown access count field. The libyal documentation marks it as unconfirmed. Do not present it as an authoritative open count.
- Single tool findings. A key conclusion resting on one parser's output is weak in review or court.
Practitioner checklist
- Collect the Recent directory, AutomaticDestinations, CustomDestinations and all
*.lnkfiles for every user profile, with hashes. - Parse with LECmd and JLECmd and validate key entries with a second, independent parser.
- Keep target times, DestList times and file system times in separate, labelled timeline columns, all in UTC.
- Review the Anomalies column, damaged entry messages and console logs for every run.
- Resolve volume serials, drive types and network share names for each target of interest.
- Match droid identifiers to $OBJECT_ID values where the target volume is available.
- Flag shortcuts with interpreter targets or unusual arguments for persistence review.
- Maintain an internal AppID list for your estate and load it with
--appIds. - Map each profile to its identity and corroborate access with logon and file server logs before reporting.
Standards and references
- Microsoft: [MS-SHLLINK] Shell Link Binary File Format, ShellLinkHeader
- libyal: Windows Shortcut File (LNK) format specification
- libyal dtformats: Jump lists format
- Eric Zimmerman: LECmd
- Eric Zimmerman: JLECmd
- MITRE ATT&CK: T1547.009 Shortcut Modification
- NIST: SP 800-86 Guide to Integrating Forensic Techniques into Incident Response
- NIST: SP 800-61 Rev. 3, Incident Response Recommendations and Considerations for Cybersecurity Risk Management
Related NHI Mgmt Group resources: Windows Forensic Artefacts Guide · Malicious LNK Files Guide · EZ Tools Guide · Digital Forensics (DFIR) Guide