The exFAT file system was designed with Unicode file names and optional vendor-specific extensions in mind. To keep things simple, the file system specification allows the usage of multiple directory entries to describe a single file (so, additional file metadata is described in additional directory entries). This solution is similar to the VFAT extension for the FAT12/16/32 file systems, which was designed as a hack to the original file system format (originally, only one directory entry was used to describe a single file, so long file names were implemented as additional directory entries, which are “invisible” to operating systems without the VFAT support).
In the exFAT file system, a typical file consists of these entries (in this order, with no other entries between):
- one file entry,
- one stream extension entry,
- one or more file name entries (as needed to store the file name),
- zero, one or more vendor-specific entries (which can be ignored if not supported).
The first two entries describe all file metadata (its attributes, timestamps, data size, first cluster, etc.), while the file name entries contain strings to form the file name (each file name entry stores no more than 15 Unicode characters and the file name is no longer than 255 characters). Together, these entries are called a directory entry set (and it must contain at least three entries).
When a file is deleted, its directory entry set is marked as free. This process is very similar to what happens to a deleted file in the FAT12/16/32 file systems: the first byte of a directory entry is changed to mark it as free.
And, of course, it is possible to recover a deleted file when its directory set and data clusters are not overwritten. If the directory entry set is partially overwritten (with new directory entries), the following can be observed:
Continue reading “exFAT: orphan file name entries”
Previously, I wrote about things you probably didn’t know about FAT. Now, let’s continue the story!
In FAT12/16/32 file systems, each directory (except the root directory) contains two special entries:
- dot (“.”);
- dot-dot (“..”).
The first one (dot) refers to the directory itself, while the second one (dot-dot) refers to the parent directory. Apparently, these entries were introduced to keep file system implementations simple, so there is no need to generate those entries on the fly (this is what happens to file systems not wasting their space to store dot and dot-dot entries in every directory).
Since two special entries are regular 8.3 directory entries, they contain timestamps (Created, Modified, Last Accessed). According to Microsoft, these timestamps should be set like this:
[…] and all of the date and time fields in both of these entries are set to the same values as they were in the directory entry for the directory that you just created.FATGEN, 1.03 (DOC)
So, the timestamps in the dot-dot directory entry have no connection to the parent directory of that directory (they aren’t copied from the corresponding timestamp fields of the parent directory). Both special entries have their timestamps set to the same values as in the directory itself.
For example, all these entries are expected to share the same timestamps:
But are these timestamps always synchronized?
Continue reading “macOS & FAT directories”
When I started researching FAT structures, I thought that FAT12/16/32 file systems are well-documented and nothing new can be discovered.
There are specifications from Microsoft (DOC), ECMA (PDF), and an extremely informative article on Wikipedia.
But there are two important things worth mentioning…
Continue reading “Things you probably didn’t know about FAT”
Recently, Microsoft warned users about compatibility issues with applications using some non-ASCII characters in names of their registry keys. According to Microsoft:
Compatibility issues have been found between apps using some non-ASCII characters in their registry keys or subkeys and Windows 11. Affected apps might be unable to open and might cause other issues or errors in Windows, including the possibility of receiving an error with a blue screen. Important Affected registry keys with non-ASCII characters might not be able to be repaired.
Before we start, here are some useful links:
Continue reading “The uppercased hell”
- Windows registry file format specification
- Measured Boot and Malware Signatures: exploring two vulnerabilities found in the Windows loader
- Playing with case-insensitive file names (a registry hive is similar to a file system)
Although NTFS has been designed with case-sensitivity in mind, it’s used mostly in the case-insensitive environment. One can natively store, within the same directory, two or more files with their names differing only in case, but Windows-based tools won’t deal with them correctly. To provide true case-sensitivity, Microsoft implemented an additional layer, per-directory case-sensitivity, as described here, here, and here.
But there are several issues with usual, case-insensitive, operations…
Continue reading “Playing with case-insensitive file names”
<offtopic>You may find this article interesting: Measured Boot and Malware Signatures: exploring two vulnerabilities found in the Windows loader. It’s about two registry-related vulnerabilities found in the Windows loader.</offtopic>
Many examiners use tools like Arsenal Image Mounter to access shadow copies on disk images. I don’t recommend this method, because you won’t see offline shadow copies, but many of us still rely on it.
And it seems there will be more caveats…
Continue reading “Shadow copies become less visible”
There are two common misconceptions about NTFS:
- A typical file has 8 timestamps.
- Windows Explorer displays $STANDARD_INFORMATION timestamps.
A file with a single name has 12 timestamps: 4 timestamps come from the $STANDARD_INFORMATION attribute in a file record, 4 timestamps come from the $FILE_NAME attribute in the same file record, and 4 timestamps come from the $FILE_NAME attribute in an index record ($I30) of a parent directory.
If there is a short file name together with a long one, the number of timestamps is 20 (8 more timestamps come from two additional $FILE_NAME attributes in a file record and in an index record of a parent directory respectively).
You can also add an UUIDv1 timestamp from the $OBJECT_ID attribute, timestamps recorded in the USN journal and in the $LogFile journal. But these aren’t always present.
Things are more complicated with timestamps displayed by Windows Explorer.
Continue reading “$STANDARD_INFORMATION vs. $FILE_NAME”
This started as an attempt to solve a puzzle:
Some virtualization software allows a user to launch a virtual machine with its real-time clock starting ticking from custom base time. For example, a user can launch a virtual machine with base time set to 2020-12-31 23:59:59 UTC, the real-time clock inside this virtual machine will start ticking from that value, regardless of the current date and time set on a host. I use this feature to test artifacts without telling Windows to move the clock.
However, if you decide to go back and restart the same virtual machine without defining custom base time (also without Internet access and without changing the date and time settings in the running operating system), the guest operating system won’t necessary use the current date and time (as set on a host). In some cases, it will continue to run using the previously defined (future) date.
How is that possible?
Continue reading “The NT kernel can ignore your hardware clock during the boot”
When triaging a live system or performing live forensic acquisition, we often need to copy registry hives from a disk. Currently, there are five common ways to do this:
- execute the “reg save <hive> <file>” command;
- call the RegSaveKeyEx/RegSaveKey routine from an acquisition tool;
- copy a hive file from an existing shadow copy;
- copy a hive file from a newly created shadow copy;
- directly read a hive file from an NTFS volume.
Are there any pros and cons of each way?
Continue reading “Exporting registry hives from a live system”
If you read my Windows registry file format specification, you might already know about layered keys. Today, let’s talk about them in more detail.
Some editions of Windows 10 are capable of running Windows containers using Docker. Each Docker container is based on an immutable image with all modified data stored in an overlay. When a Windows container is used, the system has to record modifications affecting both the file system and the registry.
In 2016, Microsoft implemented new functionality called layered keys to allow programs access a merged view of keys and values from two or more registry hives! Now, this functionality is utilized by Docker…
Continue reading “Containerized registry hives in Windows”