Windows Atlas: the artifact index
297 Windows artifacts for forensic and SOC analysts, indexed by what each one proves. The full dossiers — where each lives, what normal looks like, how it is acquired and parsed, and what it does not prove — are in the console.
ACL
- Access tokens
- The object Windows actually checks when anything is accessed -- a snapshot of a principal's identity, group memberships, and privileges taken at logon, which means what an account can do is what its token said when the session started, not what the directory says now.
- AppContainer & capability SIDs
- An isolation model that gives a process its own identity and denies it everything not explicitly granted to that identity or to a capability it holds -- which inverts the usual default and is why a process running as an administrator inside one can reach almost nothing.
- Impersonation & delegation
- The mechanism by which a thread acts as a principal other than its process -- pervasive, legitimate, and the basis of a family of local escalations, where the level the impersonation was granted at decides whether it is useful or inert.
- Integrity levels
- A label on every process and object that constrains writes independently of permissions -- so a process can hold every permission it needs and still be unable to modify something, which is the mechanism behind sandboxing and behind the practical meaning of elevation.
- NTFS ACLs & DACLs
- The permission list on every file and directory -- evaluated in a specific order that determines the outcome, inherited in a way that means what you are looking at may have been set somewhere else, and overridden entirely by ownership and by several privileges.
- Privileges & their abuse
- System-wide capabilities carried in a token that bypass object permissions entirely -- several of which amount to full control of the machine, and several of which are held by default by accounts nobody thinks of as privileged.
- Registry ACLs
- The same security descriptor model applied to registry keys, where the consequential asymmetry is that a user's own hive is writable by them by design -- so the exposure is rarely a misconfigured permission and usually a privileged component consulting a location the user controls.
- Restricted & write-restricted tokens
- A token with an additional constraint layer that requires access to pass two checks rather than one -- used to harden services below what their account would otherwise permit, and encountered mainly as a reason a process cannot do something its memberships suggest it should.
- SACLs & object auditing
- The audit half of a security descriptor, which records access to an object only when two independent things are both configured in advance -- which is why object access is unrecorded almost everywhere, and why an absence of records almost never means an absence of access.
- Service accounts & virtual accounts
- The identities services run under -- where the property that matters most is that a service's local identity and its network identity are different things, so a process running with full local authority frequently authenticates onward as the machine and not as anything privileged.
- SID structure & RIDs
- The value Windows actually uses to identify a principal -- names are a display convenience layered over it, which is why a renamed account keeps its access and a deleted one leaves permissions pointing at nothing.
- Token theft & manipulation
- Taking an existing security context from another process and running as it -- which requires no password, produces no authentication record, and makes everything done afterwards attribute to a principal that never acted.
- UAC & elevation
- The mechanism that gives an administrator two tokens and requires consent to use the powerful one -- a convenience feature that the vendor explicitly does not treat as a security boundary, which is why bypassing it is not privilege escalation and reporting it as such overstates the finding.
- User rights assignment
- The policy that decides which principals hold which privileges and which may log on in which ways -- durable, centrally delivered, and the place where tiering is either enforced or quietly absent.
- Well-known SIDs
- The fixed identifiers that mean the same thing on every Windows system -- which is what lets a permission be interpreted without any lookup, and which makes the difference between two very similar-looking grants the difference between a scoped permission and an open one.
APP
- Browser cache & downloads
- The content the browser actually retrieved, kept alongside the response headers that describe it -- which makes cache the artifact that shows what a page contained rather than merely that it was visited, and downloads the record that survives the deletion of the file it describes.
- Browser credential stores
- The saved passwords, session cookies, and autofill data in a browser profile, encrypted with a key that is itself stored on the same machine and unlockable by the same user -- which makes the whole store recoverable by anything running as that user, and makes session cookies the more valuable half because they bypass authentication entirely.
- Chromium history & profiles
- A SQLite database recording every navigation with a timestamp, a transition type explaining how the user got there, and a visit chain linking each page to the one that led to it -- which makes it the artifact that distinguishes what a user chose to do from what a page did to them.
- Clipboard history
- A retained list of recently copied items, kept when the user enables history and synchronised across devices when they enable that too -- which turns the clipboard from a transient buffer into a store of the fragments people copy most, and those are disproportionately passwords.
- Cloud sync artifacts
- The local traces of storage that is not local -- sync roots, placeholder files that look like documents but contain nothing, and client databases recording what exists in an account -- which makes a synced folder both an exfiltration channel that needs no network tooling and a filesystem whose contents may never have been on the disk you imaged.
- Edge-specific artifacts
- The layer Edge adds on top of the Chromium engine -- organisational sign-in, IE mode, WebView2 embedding, and Collections -- which matters because Edge is the browser present on every Windows host by default, and because activity through it is frequently not the user browsing at all.
- Notepad TabState
- The files modern Notepad writes to preserve unsaved tabs between sessions -- which means text a user typed and never saved, and believed was never written anywhere, is sitting on disk in a location they have no idea exists.
- Office MRU & recent files
- Per-application registry lists of documents a user opened, with timestamps and full paths -- which makes them the artifact that proves a specific human opened a specific file at a specific time, and that keeps proving it long after the file, the volume, and the share have all gone.
- Office trust records
- A registry record written when a user clicks Enable Content on a document -- which makes it one of the very few artifacts on Windows that records a specific person making a specific security decision, with the file they made it about and the time they made it.
- OneDrive sync logs
- The client that ships with Windows, signs in by default, and increasingly redirects the Desktop and Documents folders into the cloud without the user noticing -- so its logs record a file history that spans a user's whole working life, and its default configuration means the machine you are imaging may not hold the user's documents at all.
- Outlook OST/PST
- A local mailbox database holding messages, attachments, and calendar items -- which makes it the artifact that still contains the phishing email after it was deleted from the server, and the file whose export to a portable format is one of the clearest data-theft signals a Windows host produces.
- Print spooler artifacts
- The queue and logs behind printing -- which record the user, the document name, and the printer for every job, and which matter twice over because printing is the exfiltration route that defeats every digital control, and because the spooler service itself has a long history as a privilege escalation target.
- RDP client bitmap cache
- Per-user tiles of the remote screen that the RDP client caches on the source host -- evidence of what was displayed in outgoing sessions, without a time for any tile or the session they came from.
- Windows Search index
- A database holding extracted text and properties from documents, mail, and files across a user's profile -- which makes it an artifact that can still hold part of a document's content after the document is gone, and the one most often left uncollected because nobody thinks of it as evidence.
- Teams artifacts
- A locally cached slice of a conversation history that lives in a service -- which makes the host a partial, lagging copy of the real evidence, and makes Teams matter mostly as the delivery channel that bypasses every control built around email.
- Thumbcache
- Explorer's cache of thumbnail images, generated automatically when a folder is viewed -- which makes it a set of pictures of files that no longer exist, including files that were only ever on a removable drive, and one of the few artifacts that shows what something looked like rather than merely that it was there.
- USB device artifacts
- The registry and log traces left when removable storage is attached -- identifying the specific physical device, when it was first and last connected, which user mounted it, and which drive letter it held, which is what turns every other artifact's reference to a vanished volume into an identified object someone can be asked to produce.
BOOT
- BCD store
- A registry-format database, stored outside the operating system volume, holding the entries and options that decide how Windows starts -- administratively writable, survivable across reinstallation, and containing several documented settings that weaken the system before any operating system protection exists.
- BitLocker & FVE metadata
- Full-volume encryption whose keys are protected by one or more protectors -- and whose security depends far less on the cipher than on which protectors exist, since a volume with an unprotected key or an escrowed recovery password is readable by anyone who can reach either.
- Boot-start driver signing
- The verification applied to drivers loaded before the operating system's own driver machinery exists -- stricter than the runtime requirement in some respects, weakened by documented boot options in others, and subject to the same signed-but-vulnerable limit as every other signature check in this domain.
- Bootkit attack surface
- The whole pre-operating-system persistence surface arranged by how accessible each layer is to examination -- because the layers differ enormously in that respect, and effort spent at the wrong end of the ladder is the characteristic failure of boot-level investigation.
- Windows Boot Manager
- The component the firmware hands control to, which reads the boot configuration, presents any menu, and loads the operating system loader -- the point at which configuration rather than code becomes the interesting attack surface.
- Early Launch Anti-Malware
- A mechanism giving an antimalware driver the first position among boot-start drivers so it can classify the others as they load -- valuable because it is the only assessment at that stage, and limited because its verdicts are advisory rather than binding in the way most analysts assume.
- EFI System Partition
- The small filesystem partition holding the boot loaders the firmware executes -- an ordinary, readable, mountable filesystem that is nevertheless invisible in normal operation, which makes it the most accessible boot-level persistence surface and the most frequently unexamined one.
- MBR/GPT structures
- The structures at the start of a disk that describe its partitions -- historically an execution surface as well, and now primarily a description that must agree with itself, since the modern layout keeps a backup copy that a partial overwrite will contradict.
- Measured Boot log
- The itemised record of what was measured during boot -- ordinary software-written data whose value comes entirely from being verifiable against hardware registers it cannot forge, and which is the only artifact in this domain that names what actually executed.
- Safe Mode as evasion
- A diagnostic boot mode that starts only a minimal set of services and drivers -- which means most security software does not start, while the actor's own persistence can be registered to start anyway.
- Secure Boot & db/dbx
- Firmware-enforced verification that each boot component is signed by an allowed key -- whose strength rests on two databases, one listing what is permitted and one listing what is revoked, and whose weakest point is that the revocation list must be kept current by someone.
- TPM & PCR measurements
- A hardware component holding registers that accumulate measurements of what executed during boot -- unforgeable because each measurement folds into the previous one, and useful to an analyst mainly as a change detector rather than as an identifier of what changed.
- UEFI firmware & SPI flash
- The code that runs before the operating system exists, stored in flash memory on the board rather than on the disk -- so it survives reinstallation and disk replacement, and nothing running inside Windows can see it reliably.
- winload.efi & kernel handoff
- The operating system loader that reads the boot options, loads the kernel and the boot-start drivers, and transfers control -- the last stage before Windows exists, and the point at which the security stack's own components are loaded alongside everything else.
- Windows Recovery Environment
- A minimal Windows installation stored on its own partition and bootable independently of the main system -- providing a full command environment with access to the operating system volume, outside every control and every monitoring agent that volume contains.
- Windows Platform Binary Table
- A firmware-supplied table naming an executable that Windows runs during startup -- a sanctioned channel from firmware into the operating system, which means firmware-level persistence can reach Windows without any implant in the operating system at all.
DEF
- AppLocker
- The older policy-based application control mechanism, organised into rule collections per file type -- still widely deployed, still generating some of the most useful execution telemetry available, and routinely undermined by the default rules it ships with.
- Attack Surface Reduction rules
- A set of behavioural rules that block or record specific abuse patterns -- Office spawning children, script interpreters writing executables, credential store access -- whose central analytic property is that each rule is independently in block, audit, or off, and audit mode records the behaviour while permitting it.
- Microsoft Defender architecture
- The antimalware stack shipped with Windows -- a service, a filesystem filter, a scanning engine, and a cloud connection, each versioned separately -- whose most consequential property for an analyst is that it can be present and running while doing almost nothing.
- Defender event IDs
- The antimalware stack's own event channel, recording detections, remediation outcomes, configuration changes, and scan activity -- where the detection events get the attention and the configuration-change events are usually the more valuable evidence.
- Defender exclusions as IOC
- The configured list of paths, extensions, and processes the scanner will not inspect -- a legitimate performance mechanism that doubles as one of the highest-value single artifacts in Windows forensics, because an attacker-created exclusion names the location of their own tooling.
- EDR blind spots
- The systematic account of what an endpoint agent cannot see -- structural, temporal, and configurational gaps that exist by design rather than by failure, and whose enumeration is what converts an agent's silence from a finding into a known unknown.
- EDR userland hooking
- The practice of injecting a monitoring library into every process and patching function prologues to observe calls -- a vantage point inside the thing being monitored, with no privilege advantage over it, which is why it is bypassable by design rather than by defect.
- Defence evasion inventory
- A systematic survey of the ways defences get weakened, ordered by how much durable evidence each leaves -- so that an investigation can work backwards from surviving artifacts rather than forwards from technique guesses.
- Exploit Protection & mitigations
- Per-process exploit mitigations configurable system-wide or per application -- a set of independent controls whose effect is entirely determined by which are applied to which process, and where the useful analytic question is always about a specific process rather than the host.
- Firewall logging
- The host firewall's own record of connections, drops, and rule changes -- off by default for packet logging, small when enabled, and most valuable not for the traffic it records but for the rule changes it captures.
- HVCI & VBS
- The hypervisor-backed security substrate that other protections are built on -- whose defining analytic property is that configured and running are entirely different states, because it has hardware and firmware prerequisites that silently prevent it starting.
- Mark of the Web
- An alternate data stream attached to files arriving from untrusted locations, recording the zone they came from and often the originating URL -- simultaneously the trigger for several downstream defences and one of the most direct provenance artifacts on the filesystem.
- MPLog forensic value
- The antimalware engine's verbose plain-text operational log -- an artifact nobody designed for forensics that routinely proves execution, records file paths the engine touched, and survives on hosts where every purpose-built log has been cleared.
- SmartScreen
- Reputation-based warning on files and sites, keyed off the Mark of the Web and answered from a cloud service -- a control whose decisions depend on prevalence rather than content, and which is therefore weakest against exactly the files an intrusion uses.
- Tamper Protection
- The mechanism that makes the antimalware stack's own settings unmodifiable by local administrators -- the control that decides whether administrative rights are sufficient to disable the defences, and therefore the single most consequential posture setting in this domain.
- Windows Defender Application Control
- Kernel-enforced application control by code integrity policy -- the strongest execution control Windows offers, whose value in practice is decided by whether the policy is enforced or in audit, and by whether its allowances are narrow enough to mean anything.
EXEC
- Accessibility feature backdoors
- A fixed set of six System32 executables -- sethc.exe, utilman.exe, osk.exe, Magnify.exe, Narrator.exe, DisplaySwitch.exe -- that Windows deliberately makes reachable by keyboard shortcut or on-screen button from the logon and lock screen, before any authentication completes, which makes them the single most valuable execution target in the OS: whoever controls what actually runs when one of these names is invoked controls a no-credential, SYSTEM-privileged shell.
- ActivitiesCache.db
- A SQLite database that the Connected Devices Platform writes per signed-in account, recording per-application 'activities' with a start AND end time plus a JSON payload that can include document titles, deep-link URIs, and content snippets, and that for Microsoft-account-linked profiles can (or historically could) carry synced rows describing activity that occurred on an entirely different device signed into the same account -- a cross-device evidentiary angle no other artifact in this corpus offers.
- AppInit_DLLs & AppCertDlls
- Two sibling registry-configured, loader-driven code-execution mechanisms: AppInit_DLLs forces a space-delimited list of DLLs into the address space of every process that loads user32.dll -- a large fraction of GUI applications and many others besides -- while AppCertDlls forces a DLL to be loaded and invoked inside the calling process on every CreateProcess call on the host, regardless of user32.dll; both require only a single administrative registry write to achieve host-wide, durable code execution with no per-target-binary tampering.
- COM hijacking
- The module-load and process-creation telemetry that proves a registry-configured CLSID hijack (WOS-REG-com-hijack-keys) was actually instantiated -- which caller triggered it, when, and in what privilege context -- since a registry override alone only ever proves what would load, never that it did.
- IFEO debugger & SilentProcessExit
- The execution-proof and second-mechanism complement to WOS-REG-ifeo -- that dossier covers the Debugger/GlobalFlag registry configuration in depth; this one covers proving a configured hijack actually FIRED (a process-creation event showing the substituted debugger launched with the original target as its command-line argument) and the separate SilentProcessExit\ReportingMode/MonitorProcess variant, a WER-based process-exit-monitoring mechanism that achieves a comparable redirection through an entirely different registry path and trigger condition.
- Jump Lists
- Per-user, per-application files behind the Windows 7+ taskbar Jump List feature -- AutomaticDestinations (an OLE/CFBF compound file holding a ranked DestList of recent/frequent targets plus one embedded shell-link structure per target) and CustomDestinations (a flat concatenation of app-pushed pinned items and custom task shortcuts) -- both keyed by an undocumented, hash-derived AppID that must be resolved through a lookup table before any entry can be attributed to an application.
- LNK shortcut files
- The Shell Link Binary File Format (.lnk) -- a relocatable shell object pointer that, whether user-authored or (far more forensically valuable) automatically generated by Explorer's Recent Items tracking, embeds a snapshot of its target's MFT reference, hosting volume serial number, and full MACB timestamps at the moment the LNK was created or last refreshed, letting the LNK outlive and independently prove the prior existence of a target that has since been deleted.
- MUICache
- Per-user shell cache of display strings keyed by executable path; Explorer writes it when a GUI window appears, so an entry places a path in a user's interactive session without saying when or as whom it ran.
- Netsh helper DLLs
- A short list of DLL paths under HKLM\SOFTWARE\Microsoft\Netsh that netsh.exe loads into its own process on every invocation, giving an attacker code execution any time anyone -- a user, a script, group policy, or another process -- runs netsh.
- Program Compatibility Assistant log files
- Plain-text PcaSvc logs on Windows 11 22H2 and later that keep one last-launch time per GUI-launched executable, plus a small rotating store of compatibility and abnormal-exit records.
- Prefetch files
- A per-executable trace file (.pf) the kernel prefetcher writes to %SystemRoot%\Prefetch on a qualifying process launch, recording which volumes and which files it touched during its first roughly-ten-second trace window -- read here for the .pf file's overall structure, hash-in-filename scheme, and standalone role as execution-presence evidence, distinct from the run-time-array/run-count detail WOS-TIME-prefetch-time-fields covers separately.
- Print processors & monitors
- A DLL registered under HKLM\SYSTEM\CurrentControlSet\Control\Print\Environments\{arch}\Print Processors\{name}\Driver -- or its sibling Port Monitors tree -- loads directly into spoolsv.exe, a near-universally-running, SYSTEM-privileged, rarely-scrutinized service, whenever the Print Spooler processes a job (for processors) or enumerates/uses a port (for monitors), making this one of the quieter durable-execution primitives in Windows precisely because almost nobody expects to find persistence hiding in printing infrastructure.
- Scheduled Task XML files
- The extensionless XML file under %SystemRoot%\System32\Tasks\{TaskPath} that is the authoritative, complete definition of a scheduled task -- its triggers, actions, run-as principal, and embedded security descriptor -- as distinct from the TaskCache registry tree the Task Scheduler service maintains alongside it purely as a faster-lookup index.
- Screensaver persistence
- A per-user HKCU value that names the executable the screen-saver subsystem launches after the configured idle timeout -- the .scr extension is a naming convention, not an enforced file-type check, so any valid PE renamed to .scr and pointed to by SCRNSAVE.EXE runs unattended, and under configurations where the screen locks straight into the saver, it can fire at the lock screen before any credential is entered.
- Service-based persistence
- The Service Control Manager's own execution-lifecycle record in System.evtx (Event IDs 7036/7040/7045 and the startup-failure family) -- the append-only proof that a configured service actually installed, started, or changed state, complementing the mutable, execution-blind configuration snapshot in the Services registry tree.
- Startup folders
- The oldest and simplest Windows autostart mechanism -- a per-user and an all-users folder whose contents launch at logon with no registry indirection at all, so that filesystem presence IS the entire configuration, making it as trivial to plant as it is to spot with a single directory listing.
- SuperFetch/SysMain databases
- Proprietary, sparsely-documented scenario databases the SysMain service writes to %SystemRoot%\Prefetch\ to learn multi-day application-usage patterns for predictive page preloading — a broader, longer-horizon sibling to Prefetch's per-executable .pf files.
- TaskCache registry tree
- The GUID-indexed registry mirror of every scheduled task under SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache -- a fast lookup and live runtime-state cache the Task Scheduler service consults on every boot, logon, and enumeration, and the only place a task's actual last-run and (build-dependent) next-run instants are recorded at all, since the XML definition file only encodes trigger rules, never resolved run instants.
- Time provider DLLs
- A DLL registered under HKLM\SYSTEM\CurrentControlSet\Services\W32Time\TimeProviders\{ProviderName}\DllName loads directly into the W32Time service process whenever that provider is active -- the DLL-registration/execution complement to WOS-TIME-w32time, which covers the service's sync hierarchy and clock-skew role; this dossier covers ONLY how a provider DLL gets loaded and executed, deliberately not re-explaining W32Time's NT5DS/NTP sync behavior.
- Winlogon Shell/Userinit persistence
- The execution-proof complement to WOS-REG-winlogon-keys -- that dossier covers the Shell/Userinit/Notify registry mechanics in depth; this one covers proving a configured hijack actually fired at a real logon event, anchored on the single most reliable signal available: winlogon.exe as the observed parent process for the substituted shell or appended Userinit program, since no ordinary application launch path produces that specific parentage.
- WMI event subscriptions
- A three-object structure (__EventFilter defining a WQL trigger condition, __EventConsumer defining the action, __FilterToConsumerBinding tying them together) registered inside the WMI repository -- not the registry or a conventional file -- that WinMgmt itself evaluates and fires on, giving the classic 'fileless' persistence mechanism its name because the entire trigger and payload can live as object properties with nothing dropped to disk as a discrete file.
IDN
- Cached domain credentials
- The verifiers Windows stores so a domain user can log on when no domain controller is reachable -- deliberately constructed so they cannot be used to authenticate anywhere, only to check a password offered locally, which makes them the one credential store where cracking is the sole route to value.
- Credential Guard internals
- Virtualisation-based isolation that moves the most sensitive credential secrets out of LSASS into a separate trust level the normal kernel cannot read -- which defeats memory extraction of those specific secrets even from kernel mode, and does nothing about credentials captured at the moment they are supplied, a distinction that decides whether it is relevant to a given incident.
- Windows Credential Manager
- The user-facing credential store that saves passwords for network resources, remote desktop targets, and web sites -- DPAPI-protected at rest, transparently readable by anything running as the owning user, and distinguished from every other store in this domain by its entries naming the systems they unlock.
- DPAPI-protected blobs
- The encrypted containers DPAPI produces -- holding saved browser passwords, Credential Manager entries, wireless keys, certificate private keys and much else -- each naming the master key GUID it needs and, where the calling application supplied optional entropy, requiring a second secret that the master key alone does not provide.
- DPAPI master keys
- The per-user and per-machine keys that sit between a password and everything DPAPI protects -- stored on disk encrypted, unlocked by a password-derived key or by a domain backup key that decrypts every master key in the domain, and cached in memory once used, which gives an attacker three independent routes to the same material.
- Group Managed Service Accounts
- Service accounts whose passwords the directory generates and rotates automatically, retrieved on demand by hosts authorised to use them -- which removes stored service credentials from every member server and concentrates the exposure into a single directory attribute governing who may retrieve them.
- Kerberos authentication flow
- The ticket-based protocol Windows prefers for domain authentication -- a client proves itself once to a domain controller, receives a ticket-granting ticket, and thereafter obtains per-service tickets without re-authenticating -- which means the domain controller sees ticket requests while the target service sees only a presented ticket, and neither alone describes what happened.
- Kerberos ticket cache
- The per-logon-session store of Kerberos tickets held in LSASS -- the ticket-granting ticket that authorises further requests and the service tickets already obtained -- which is simultaneously the record of what a session was authorised to reach and, because a ticket is a bearer credential, the material an attacker extracts to become that session elsewhere.
- Logon sessions & LUIDs
- The kernel-tracked container that ties an authentication event to everything done under it -- identified by a locally unique identifier that appears in logon records, process creations, object access, and tokens alike, making it the join key that turns scattered activity into an attributable session.
- Logon types 2-11
- The single field on every logon record that says how an authentication happened -- at the keyboard, over the network, as a service, through RDP, with cached credentials -- and therefore what the resulting session can do, what credential material it leaves resident, and what corroborating evidence should exist elsewhere.
- LSA Secrets
- The SECURITY hive's store of secrets the operating system itself needs in cleartext-recoverable form -- service account passwords, the machine account password, cached autologon credentials, and DPAPI backup key material -- which makes it the one credential store that routinely yields plaintext passwords rather than hashes.
- LSASS process & credential material
- The process that holds every credential secret the host is currently using -- ticket keys, NTLM hashes for cached sessions, and whatever the authentication packages have chosen to keep resident -- which makes its address space the single highest-value target on any Windows host and its access telemetry the highest-value detection.
- Netlogon secure channel
- The authenticated channel every domain-joined machine maintains with a domain controller -- carrying NTLM pass-through validation, machine account password rotation, and directory lookups -- whose trust rests entirely on the machine account password and whose compromise lets an actor act as the computer itself.
- NTDS.dit
- The Active Directory database file on every domain controller -- holding every account, every group, every credential hash in the domain, and the krbtgt key that underwrites Kerberos -- which makes obtaining it not a credential theft but the compromise of the entire authentication domain.
- NTLM authentication flow
- The challenge-response protocol that authenticates a client by proving it holds the NT hash without ever transmitting it -- which is exactly why possession of the hash is equivalent to possession of the password, and why the protocol's design makes both pass-the-hash and relay structural rather than implementation flaws.
- PKINIT & smartcard logon
- Certificate-based Kerberos authentication, where a private key rather than a password proves identity -- which removes the password from the authentication path entirely and, because Windows must still support NTLM for those accounts, hands back the account's NT hash inside the returned ticket.
- SAM hive & local accounts
- The registry hive holding every local account on a host -- names, RIDs, group membership, logon counters, and NT hashes encrypted under a key derived from the SYSTEM hive -- which makes the pair of hives, and nothing else, sufficient to recover local credentials entirely offline.
- Security Support Providers
- The pluggable authentication providers loaded into LSASS -- Kerberos, NTLM, Schannel and their peers -- registered through a registry value that anything with administrative write access can add to, which makes a malicious provider simultaneously boot-persistent code execution inside the most privileged process on the host and a credential capture point that sees secrets as they are supplied rather than having to extract them.
- WDigest credential caching
- The Digest authentication package and the registry value that decides whether it keeps a logged-on user's reusable password in LSASS memory; for a defender, a configuration state and a change to watch.
KRN
- Bring Your Own Vulnerable Driver
- Loading a legitimately signed driver that contains an exploitable defect and using it as a kernel access primitive -- the standard route into the kernel on a properly configured system, because nothing about it is unauthorised until the exploitation begins.
- Driver load paths & artifacts
- How code gets into the kernel -- the single gateway every kernel-mode technique has to pass through, which makes it the most productive place to watch and the one artifact that bounds what all the others could have been.
- Driver Signature Enforcement & HVCI
- The controls deciding what code may execute in the kernel -- signature checking at load time and, where enabled, hypervisor-enforced integrity thereafter, which are two quite different guarantees that get discussed as one.
- ETW Threat Intelligence provider
- A kernel-side event provider that reports operations user-mode hooking cannot see -- notably remote memory writes, remote thread creation, and protection changes -- consumed almost exclusively by security products under a restriction that keeps ordinary tooling away from it.
- Handle tables
- The per-process mapping from handle values to kernel objects, recording not only what a process has open but the access it was granted -- which makes it the clearest live statement of what a process is currently able to do to everything else on the system.
- IRP flow & device stacks
- The path an I/O request takes through a stack of layered drivers to reach a device -- the structure that makes filtering possible at all, and the reason that what a caller reads is the result of everything in the stack rather than what the device holds.
- Kernel notify callbacks
- The documented notification interface through which drivers are told about process creation, image loads, handle operations, and registry changes -- which is how nearly every security product sees anything, and therefore what an actor with kernel access removes first.
- Filesystem minifilters & altitudes
- The supported interface for interposing on filesystem operations, ordered by a numeric altitude that determines who sees a request first -- which makes the altitude ordering, not merely the list of registered filters, the thing an analyst has to read.
- MSRs & Interrupt Descriptor Table
- The processor-level structures that decide where execution goes on a system call or an interrupt -- the lowest interception points available, and now protected for the same reason and in the same way as the dispatch tables above them.
- Object Manager & namespace
- The kernel subsystem that creates, names, and reference-counts every kernel object -- processes, threads, files, sections, mutexes, devices -- and exposes them in a hierarchical namespace that is one of the few places malware routinely leaves a name behind on purpose.
- Kernel Patch Protection
- A 64-bit kernel mechanism that periodically verifies critical structures and deliberately crashes the system on detecting modification -- which makes its only forensic artifact a crash, and makes an unexplained bugcheck of the right type one of the strongest single indicators of kernel-level tampering available.
- Kernel pool allocations
- The kernel's dynamic memory, from which nearly every kernel object is allocated -- and, because allocations carry a four-character tag identifying their purpose, the substrate that makes recovering kernel objects from a memory image possible at all.
- Session Manager (smss.exe)
- The first user-mode process the kernel starts, responsible for creating sessions and performing the boot-time work that must happen before anything else runs -- which makes its configuration a persistence surface that executes earlier than almost any other.
- System Service Descriptor Table
- The kernel table mapping service numbers to the routines that implement them -- historically the canonical rootkit hooking target, and now chiefly important as a settled question: on modern 64-bit Windows it is protected, so an intact table is expected rather than reassuring.
- Syscall interface & stubs
- The boundary between user mode and the kernel, crossed by short stubs in the system library that load a service number and trap -- and the reason user-mode API hooking is structurally bypassable, since the stub is the last user-mode code and it need not be the one that ships.
- Win32k subsystem
- The kernel-mode windowing and graphics subsystem -- an unusually large attack surface reachable from ordinary user code, historically the most productive source of local privilege escalation, and the reason processes that need no windows are configured not to reach it at all.
LAT
- AD CS abuse (ESC1-ESC8)
- Obtaining a certificate that authenticates as someone else -- through a template that permits it, a relay that impersonates a request, or a stolen signing key -- producing credentials whose lifetime is measured in years and which no password reset invalidates.
- Copying a file to a target over its administrative shares -- the transfer step that precedes most remote execution, whose evidence sits almost entirely on the receiving filesystem rather than in any log, and therefore survives both the file's deletion and the loss of network telemetry.
- AS-REP roasting
- Requesting an authentication response for an account that does not require pre-authentication, and cracking the returned material offline -- an attack that needs no domain credential at all, only a username and reachability, and whose exposure is a single flag on a single account.
- DCOM lateral execution methods
- Activating a COM object on a remote host and calling a method that runs something -- execution whose spawned process is parented by whichever application hosts the object, which means the artifact looks like an ordinary desktop application doing something odd rather than like remote access at all.
- DCShadow
- Temporarily registering a machine as a domain controller and pushing directory changes in as replication -- which writes to the directory through a path that ordinary directory change auditing does not watch, and then removes the registration.
- DCSync
- Asking a domain controller to replicate account secrets to you, as a domain controller would -- which extracts every password hash in the domain without running a single line of code on the domain controller, and which is the hinge that turns a compromised account into indefinite control of the directory.
- Golden & Silver tickets
- Forging Kerberos tickets with a stolen signing key -- authentication that is cryptographically valid, that the domain controller has no basis to question, and which ends the period of an intrusion that authentication evidence can reliably reconstruct.
- Kerberoasting
- Requesting service tickets for accounts that have a service principal name, then cracking them offline to recover the service account's password -- an attack that any authenticated domain user can perform, that produces requests indistinguishable from ordinary Kerberos use, and whose payoff arrives long after anything observable has happened.
- Overpass-the-Hash
- Exchanging a stolen hash for a Kerberos ticket, which converts credential material the estate may be watching for into credential material it usually is not -- and which is the reason restricting NTLM does not close credential reuse.
- Pass-the-Hash
- Authenticating with a stolen password hash instead of a password -- which works because the hash is what the protocol actually uses, produces authentication that is protocol-correct in every respect, and is therefore detectable only by context rather than by anything wrong with the exchange itself.
- Pass-the-Ticket
- Taking a Kerberos ticket from one host and using it on another -- authentication with no credential at all, which produces service ticket requests and accesses that are genuinely valid and which the domain controller has no reason to question.
- PsExec-style service creation
- The oldest and loudest remote execution pattern on Windows -- stage a binary over an administrative share, create a service pointing at it, start it, delete it -- which leaves a durable trail in four independent places and is still used constantly because it works on everything.
- RDP lateral movement
- Moving between hosts by taking a desktop on each -- the only lateral movement technique that leaves a trail of what the intruder was looking at, and the only one whose activity on each host is indistinguishable from a person legitimately using it.
- Remote Registry service
- Reading and writing another host's registry over the network, which is how credential material, configuration, and persistence are reached without ever running code on the target -- and which leaves almost nothing behind on the target because reading a registry key is not an audited event by default.
- Remote scheduled tasks
- Creating a task on a remote host to obtain execution there -- the quieter sibling of remote service creation, which leaves an XML file on disk, a registry entry, and an event that records the task's entire definition including who created it.
- SCCM & WSUS abuse
- Using the estate's own software deployment and patching infrastructure to run code on every machine it manages -- execution that arrives through the channel every endpoint is built to trust, runs with the highest local privilege, and looks on each client exactly like a routine deployment.
- WinRM lateral movement
- Moving between hosts with remote PowerShell -- the technique whose evidence depends almost entirely on one setting nobody enabled, and whose most consequential property is that the session usually cannot reach onward from the host it lands on, which shapes how an intruder has to chain.
- WMI remote execution
- Creating a process on a remote host through the management framework -- execution that writes no file, creates no service or task, and produces a process whose parent identifies the mechanism and never the requester.
LOG
- Audit policy & subcategories
- The gate that determines whether a given Security-channel event ID is ever generated in the first place -- roughly 60 independently toggleable Success/Failure subcategories under 10 categories, configured via auditpol.exe or Group Policy, plus Global Object Access Auditing, sitting alongside a separate, older 9-category basic policy that can silently override the advanced settings if both are configured at once.
- Event channel inventory
- The full, host-specific population of Windows Event Log channels -- the four classic logs, the sprawling Microsoft-Windows-*/Operational, /Analytic, and /Debug channels (typically hundreds, most disabled by default), and the Forwarded Events WEF destination -- and how to enumerate what actually exists and its enabled/disabled/retention state on a given host, rather than assuming a fixed universal list.
- ETW architecture
- The provider/session/consumer model at the core of Windows tracing -- user- and kernel-mode components emit structured events via EventWrite into a controller-configured, buffered kernel session, which any number of real-time or file-based consumers can read -- underlying nearly every native security telemetry source, including Sysmon, PowerShell logging, AMSI, and Defender.
- ETW patching & unhooking
- An in-memory, per-process technique that overwrites the machine-code prologue of ntdll.dll!EtwEventWrite (or its AMSI-pipeline cousin, amsi.dll!AmsiScanBuffer) with a short-circuiting return instruction, so the patched process's own subsequent calls into that function silently no-op -- generating no security telemetry and (for the AMSI variant) never actually inspecting the script content it is handed -- while every other process on the host, and the on-disk DLL itself, remain completely untouched.
- ETW providers & sessions
- The concrete inventory layer above the ETW architecture: which named providers are registered on this host, which sessions have actually enabled each one, and at what keyword/level mask -- the configuration that answers 'was this activity even eligible to be recorded' before any question about whether it was recorded.
- Event ID crosswalk
- A comparative reference mapping the Security, Sysmon, and PowerShell-Operational channels' event IDs that cover the SAME underlying activity type -- process creation, network connection, image/DLL load, script execution -- so an analyst asking 'which channel(s) should I check for evidence of X' has one lookup instead of re-deriving channel coverage from four separate dossiers each time.
- EVTX binary format
- The chunked binary container -- an 'ElfFile' header followed by a sequence of self-describing, checksummed 64KB 'ElfChnk' chunks, each holding template-compressed binary XML event records -- that every .evtx log on the system is built from, and whose per-chunk independence is why a corrupted or truncated log is so often partially recoverable rather than a total loss.
- Log clearing & tampering
- The synthesis methodology for detecting deliberate Windows Event Log clearing across the independent witnesses a clear cannot avoid leaving behind -- the clear action's own self-incriminating record (Security 1102 / System 104), the EventRecordID sequence discontinuity it produces in the channel's own numbering, the behavioral anomaly of a cleared channel showing no subsequent activity at all, and multi-source corroboration from WEF collector copies and volume shadow copies of the .evtx file the actor cannot reach locally -- because clearing a log does not erase evidence, it manufactures a new, distinctive piece of it.
- PowerShell operational logs
- Three independently-configurable, off-by-default PowerShell engine logging mechanisms commonly conflated into one -- Module Logging (Event ID 4103, per-command pipeline and parameter-binding detail), Script Block Logging (Event ID 4104, the actual decoded script source text as parsed for execution), and Transcription (a separate, non-EVTX plain-text session transcript written to disk) -- of which Script Block Logging is the single highest-value PowerShell forensic source because it captures what the engine actually compiled and ran, defeating most string- and encoding-layer obfuscation regardless of how the code was assembled.
- Retention, rollover & gaps
- The methodology for reasoning about why a specific EVTX channel's surviving history does not reach as far back as an investigation needs -- each channel enforces its own configurable size ceiling and one of three retention policies, and the effective lookback window that produces is a function of that configuration divided by actual write volume, not a fixed calendar duration, meaning the resulting gap has to be actively reasoned about rather than assumed to mean nothing happened.
- Core Security log events
- A field-by-field reference to the specific Security-channel event IDs an analyst reaches for most -- logon/logoff (4624/4625/4634/4647), process creation (4688), service/task registration (4697/4698), account and group management (4720/4728/4732), special/admin logon (4672), and NTLM credential validation (4776) -- and the audit subcategory that gates each one.
- Sysmon architecture
- Sysinternals Sysmon: a kernel-mode minifilter/callback driver (SysmonDrv) paired with a user-mode service, together forming an ETW producer-and-consumer that writes its own richly detailed, config-filtered process/network/file/registry events to the Microsoft-Windows-Sysmon/Operational channel.
- Sysmon configuration
- The include/exclude rule tree that decides which of Sysmon's observable events are actually written -- authored as XML, compiled at apply time into a binary blob under the driver's Parameters key, and therefore both the authoritative record of what a host was collecting and the single edit that blinds Sysmon to a chosen activity class without stopping the service or the driver.
- Sysmon vs native telemetry
- A side-by-side comparison of what Sysmon's Operational channel adds beyond native Security/System auditing -- full command lines and file hashes on every process creation by default, network-connection visibility, and image/DLL load visibility that native auditing has no equivalent for at all -- against what native auditing alone still provides that Sysmon does not attempt to replicate, chiefly detailed logon/authentication telemetry.
- System & Application logs
- The two oldest Windows Event Log channels -- System for kernel, driver, and service-lifecycle events, Application for anything any process writes via the legacy ReportEvent API -- notable for having no dedicated audit-policy gate of their own, which makes them always-on baseline evidence even on hosts with minimal Security-channel auditing.
- User Access Logging databases
- Windows Server ESE databases that aggregate client access by user, source IP and server role, by year and day -- a long-lived record of who reached a server when per-event logs have rolled.
- Windows Event Forwarding
- The native push/pull mechanism, built on WinRM/WS-Management, that subscribes a collector host to specific event channels on one or more source hosts and writes received copies into the collector's local Forwarded Events channel -- creating a second, independently-retained copy of chosen events that can outlive local log clearing, accelerated rollover, or the source host itself.
MEM
- Crash dumps & MEMORY.DMP
- Memory written to disk when something failed -- consistent, durable, and on default settings containing kernel memory only, which is the limit most people discover after searching one for user process content.
- Heap structures
- The allocator's own bookkeeping inside a process's memory -- which turns heap analysis from searching bytes into walking a structure, and which preserves freed allocations until they are reused, making a heap the closest thing memory has to deleted data.
- hiberfil.sys
- Memory written to disk so a system can resume where it left off -- the only routinely available memory image that is genuinely consistent, and the one whose contents are most often assumed to be more complete than they are.
- Memory acquisition methods
- Getting a copy of physical memory off a running system -- an operation that changes what it is copying, takes long enough that the result is never a single consistent instant, and on modern systems silently omits regions the acquiring code is not permitted to read.
- Memory manager overview
- The subsystem that decides what is in physical memory and what is not -- which is why a memory image is a partial view by construction, and why understanding what it omits is a prerequisite for reading one.
- Memory scanning & YARA
- Searching memory content for known patterns -- which finds things that never appear on disk, and whose results mean much less than they appear to unless each hit is attributed back to a process and a region.
- Module stomping & overwriting
- Loading a legitimate library and then overwriting its code in memory -- which produces executable content in a genuinely file-backed region, defeating the unbacked-memory indicator entirely and leaving content comparison as the only thing that finds it.
- Page protections & transitions
- What a memory region permits -- read, write, execute, or combinations -- where the analytically decisive fact is that a region records its current protection and not its history, so a memory image shows where a region ended up and never how it got there.
- Pagefile as evidence
- Where memory content goes when it is not resident -- the durable route to material that has no file behind it, holding fragments with no structure, no attribution, and no timestamps, potentially from weeks ago.
- Private vs mapped memory
- Whether a memory region has a section behind it or not -- the distinction most memory-based detection rests on, and one with a hole on each side that determines how much weight it can actually carry.
- Executable private memory as IOC
- Executable memory with no file behind it -- the highest-yield memory indicator there is, and one whose false positive population is large enough that using it well is mostly a matter of knowing what legitimately produces it.
- Section objects & mapped views
- The kernel object representing a shareable block of memory and the views processes map of it -- where the distinction that matters is that a section can be backed by the pagefile rather than a file, so memory can be mapped rather than private while still having no file behind it.
- Virtual address space layout
- How a process's address space is arranged and where things land in it -- where the property that trips people up is that randomisation happens per boot rather than per process, so an address being identical across every process on a host is expected rather than suspicious.
- Working sets & trimming
- The subset of a process's memory currently resident in physical memory -- the manager's moment-to-moment decision that determines exactly what a memory image will and will not contain, and which can be influenced deliberately.
NET
- The shares Windows creates on every host by default -- each volume root, the Windows directory, and the named-pipe share -- which together give any account with administrative rights on a target full filesystem write access and a path to its remote administrative interfaces, without anything being configured or enabled.
- DNS client cache
- The in-memory record of names this host has resolved, which is the fastest route to what a compromised machine was talking to -- and which evaporates on reboot, on a one-line command, and quietly by itself as entries reach their time to live.
- Windows Filtering Platform
- The filtering engine the Windows firewall is built on, whose rule set is a durable statement of what a host permits and whose audit events are the only native record of per-connection allow and block decisions -- a record almost nobody enables, and which buries its signal in its own volume when they do.
- hosts file
- A plain text file that overrides DNS for any name it lists, which makes it the cheapest way on Windows to cut a host off from its security vendor or point it at attacker infrastructure -- and, because it is durable, timestamped, and almost never legitimately modified, one of the easiest such changes to find.
- http.sys & URL ACLs
- The kernel component that owns every HTTP port on a Windows host and routes requests to user-mode listeners by URL prefix -- which is why a listening web service shows a system component as the socket owner rather than the process actually serving it.
- IPsec policy
- The policy that decides which traffic must be authenticated or encrypted between hosts -- rarely deployed, durable when it is, and worth knowing because a rule added here can encrypt an attacker's traffic with the operating system's own machinery and make it opaque to every network sensor watching it.
- Live connection enumeration
- The list of what a host is connected to right now, with the process owning each socket -- the first thing every analyst runs on a live host, and the artifact whose limitations are most consistently forgotten in the write-up.
- NBT-NS, LLMNR & mDNS
- Three fallback name resolution protocols that ask the local network segment when DNS has no answer, and accept whichever host replies first -- which lets anyone on that segment answer for any name and collect the authentication the asking host then offers.
- netsh portproxy & interfaces
- A built-in port forwarder configured with one command and stored in the registry, which turns any Windows host into a network pivot with no file dropped, no service created, and no process an analyst can find -- because the forwarding is done by a system component on the host's behalf.
- Proxy settings & WPAD
- The configuration that decides where a host's web traffic actually goes, held in at least three independent places that different software consults -- which is why changing one of them redirects some traffic and not others, and why checking one of them proves nothing about the rest.
- RDP artifacts (bitmap cache, logs)
- The durable residue an RDP session leaves on both machines -- session lifecycle records on the destination, and on the source a connection history plus a cache of the remote screen itself, which is the only artifact in this corpus that can show an analyst what an intruder was looking at.
- RDP protocol
- The interactive remote session protocol, whose defining property for an analyst is that it gives an intruder a full desktop with a logged-on user's context -- which means everything they do afterwards looks exactly like a person using the machine.
- SMB protocol
- The file and named-pipe sharing protocol that carries most Windows lateral movement, because it is simultaneously the file transfer path, the remote administration transport, and traffic so ubiquitous inside an estate that its presence is never itself remarkable.
- SMB session artifacts
- The durable traces an SMB session leaves on both ends -- share access records and open-file state on the server, mount and shortcut history on the client -- which together are the only lasting evidence of remote file activity, since the session itself vanishes the moment it closes.
- TCP/IP stack & NDIS
- The kernel networking stack every packet passes through, whose layered driver model is what makes process-to-connection attribution possible at all -- and what makes a driver inserted into the wrong layer able to see or hide traffic that no user-mode tool will ever report.
- WinRM & WS-Man
- The remote management transport that PowerShell Remoting runs on, whose own logs say almost nothing about what was executed -- so an investigation into WinRM activity is almost always an investigation into PowerShell logging, and fails entirely where that was not enabled.
- Winsock LSP catalog
- The registry catalog of providers the Winsock layer chains together, whose layered entries load a chosen DLL into every process that opens a socket -- a largely superseded mechanism that is still worth one command to check, because the catalog and its loading behaviour outlived the era they belong to.
NTFS
- Alternate Data Streams
- NTFS's support for more than one named $DATA attribute per file -- 'file.txt:streamname' -- entirely invisible to Explorer, dir, and most everyday tooling by default, which makes it simultaneously a legitimate OS mechanism (Zone.Identifier's download-source marking is itself an ADS) and one of the oldest, still-effective ways to stash a second payload behind a completely ordinary-looking file with an unchanged size in every standard view.
- $DATA & data runs
- The compact, run-length-encoded mapping non-resident $DATA (and other non-resident attributes) use to record where their actual content lives on disk -- virtual cluster numbers mapped to logical cluster numbers in variable-length runs -- whose fragmentation pattern is itself forensic evidence, since a heavily-fragmented run list on a small file can indicate the volume was already busy and low on contiguous space at write time, useful context for timeline placement and for scoping unallocated-cluster carving after deletion.
- File deletion & recovery
- The synthesis of what 'delete' actually does on NTFS -- mark-and-release, never wipe -- and the methodology for working the five independent recovery angles it leaves behind ($I30 slack, MFT record survival, cluster reuse, $UsnJrnl history, and Recycle Bin content), each degrading on its own separate, unpredictable timeline, so that 'is this file recoverable' is never a single yes/no answer but a per-angle question worth asking five separate times.
- File carving from unallocated space
- Reconstructing deleted files from raw clusters by their content signatures, without file-system metadata -- it can recover content and a type, and cannot on its own recover a name, a timestamp or any account.
- $FILE_NAME
- The NTFS MFT attribute (type 0x30) that stores a file's name, parent directory reference, and its own copy of the four MACB timestamps -- updated only by the kernel on namespace operations, with no documented user-mode API for direct forgery, which is exactly what makes it the standard cross-check against a timestomped $STANDARD_INFORMATION.
- Filesystem tunneling
- An in-memory-only compatibility cache that makes NTFS reuse a just-deleted (or just-renamed-away) file's original creation time and 8.3 short name for a brand-new file created under the same name within a short window (15 seconds by default) -- a legacy behavior for save-as-temp-then-rename application patterns that, whenever it fires, quietly makes a genuinely new file's $SI CreationTime read as older than it actually is, with no registry key, log entry, or persistent artifact recording that tunneling occurred.
- Hard links, junctions, symlinks
- Three distinct mechanisms that all let a single piece of content appear to exist at more than one path -- hard links (multiple $FILE_NAME entries in one MFT record, same content, no reparse point involved), and junctions/symlinks (a $REPARSE_POINT attribute redirecting resolution to another path, potentially across volumes) -- each with a different forensic footprint, and each a documented way to make a naive 'which file is this' assumption wrong.
- $I30 index attributes
- The B-tree index NTFS maintains inside every directory's own MFT record to keep its child entries sorted for fast lookup -- built from cached copies of each child's $FILE_NAME attribute -- whose B-tree rebalancing leaves stale, unreferenced slack entries behind on deletion far more often than a simple linear list would, making a directory's own $I30 one of the highest-yield places to recover evidence of files that no longer exist anywhere else on the volume.
- $LogFile
- The write-ahead transaction log NTFS uses to make every metadata change crash-consistent -- redo/undo records for MFT attribute changes, index updates, and more -- that briefly retains pre-change values within a short, fixed-size, self-truncating window, making it the one artifact that can catch a timestomp or a deletion in the act rather than only after the fact.
- MFT structure & records
- The flat table of fixed-size 'FILE' records -- one per file and directory -- that every NTFS metadata attribute ($SI, $FN, and the rest) lives inside, and whose record-reuse behaviour on delete is the single biggest reason 'the file is gone' and 'the evidence is gone' are not the same claim.
- $OBJECT_ID attribute
- A 16-byte GUID NTFS assigns to a file the first time something requests one -- primarily the Distributed Link Tracking service, which uses it to keep shortcuts and OLE links resolvable across renames and moves -- structured internally like a version-1 UUID, meaning older-generation object IDs can embed the creating machine's MAC address and a creation timestamp directly in the GUID bytes, occasionally letting an analyst attribute a file's origin to a specific host years after it was copied somewhere else entirely.
- Recycle Bin ($I/$R)
- The per-user, per-volume $Recycle.Bin hierarchy where a shell-mediated delete parks a file's actual content under a randomized $R name and its original path, size, and deletion timestamp under a paired $I metadata file -- one of the few artifacts that recovers both a deleted file's content AND its full original location and deletion time together, but only for deletes that went through this specific path, never a permanent bypass.
- Resident vs non-resident data
- The size threshold that decides whether an attribute's content lives inline inside its own MFT record (resident) or out in separately-allocated clusters referenced by data runs (non-resident) -- a distinction invisible to every ordinary file API but decisive for forensics, because a small file's content survives deletion exactly as long as its MFT record does, while a large file's content survives independently, on its own separate and far less predictable recovery timeline.
- $Secure & security descriptors
- The volume-wide deduplicated store every file and directory's security descriptor (owner SID, DACL, SACL) actually lives in -- referenced from each MFT record by a compact Security ID rather than storing a full, often-large ACL inline per file -- meaning a permission or ownership change on one file can, in principle, be traced to exactly which other files on the volume share the identical descriptor, and a Security ID's own lifecycle (assigned once, reused across every file with matching permissions) is itself a distinct forensic signal from any individual file's ACL content.
- Sparse & compressed files
- Two independent, flag-controlled NTFS storage modes -- sparse (regions of logical zeros stored as unallocated 'holes' rather than actual zero-filled clusters) and compressed (per-compression-unit LZNT1 transformation, transparent to every application) -- both of which make a file's logical size a poor proxy for its actual on-disk footprint, and both of which give an actor a straightforward way to make a large payload occupy little visible disk space while every standard tool reports the full logical size as if nothing were unusual.
- $STANDARD_INFORMATION
- The NTFS MFT attribute (type 0x10) carrying a file's four MACB timestamps and DOS attribute flags -- exactly the metadata Explorer, dir, and the Win32 timestamp APIs show, and exactly the metadata any process with ordinary file-write access can silently forge.
- $UsnJrnl
- A per-volume, append-only, self-truncating log of every NTFS namespace and metadata change -- creates, deletes, renames, and reason-coded writes -- that captures events $SI and $FN alone cannot, at the cost of a fixed, usually short, retention window that rolls the oldest entries off as new ones arrive.
- Volume Shadow Copies
- Point-in-time, block-level copy-on-write snapshots of an entire volume that the Volume Shadow Copy Service creates for System Restore, backup software, and Windows Server's Previous Versions feature -- each one a mountable, browsable replica of the volume as it existed at snapshot time, meaning a file deleted, modified, or timestomped since the last snapshot may still exist in its pre-change state entirely independent of every other artifact in this corpus.
PROC
- APC injection
- Queueing a user-mode asynchronous procedure call against a thread in a target process so that injected code runs the next time that thread enters an alertable wait -- a trigger that creates no thread, generates no cross-process thread-creation event, and uniquely can be caught after the intent is staged but before anything has executed.
- Command-line capture & gaps
- A methodology dossier about where a command line can be read from and what each source can support -- the kernel's creation-time capture, taken before the process executes anything, versus the process-writable copy in the PEB that every live-inspection tool reports -- because 'was launched with' and 'currently reports' are different claims and conflating them is the most common overstatement in process analysis.
- DLL injection primitives
- The family of primitives that place attacker code into another process's address space and obtain execution there, organised by the residue each leaves rather than by API sequence -- because the difference between a loader-registered module and a manually mapped one decides which detection sees it, and a strategy built on one is structurally blind to the other.
- DLL search order
- The ordered sequence the loader walks to turn a DLL name into a file on disk, and the several mechanisms that short-circuit it entirely -- KnownDLLs, API sets, and activation contexts -- because whether a planted DLL is ever reached depends on which of those applies, and most hijacking attempts against system libraries fail for exactly that reason.
- EPROCESS structure
- The kernel's per-process object -- one nonpaged-pool structure holding a process's identity, access token, address space, handle table, and thread list -- and the ground truth that every user-mode process API is a filtered rendering of. Its layout is undocumented and shifts between builds, which is why memory-forensics tooling carries per-build symbol profiles instead of a fixed offset map.
- ETHREAD & thread states
- The kernel's per-thread object -- the unit that actually executes, carrying the thread's start address, scheduling state and wait reason, its APC queues, and any impersonation token it holds independently of its process. Processes own address spaces; threads run code, so this is the level at which the question 'what is executing right now' has an answer at all.
- Handle inheritance
- The mechanism that copies open handles from a creating process into its child at creation -- all-or-nothing across every inheritable handle unless an explicit handle list narrows it -- which makes a leaked handle both a privilege-escalation path that bypasses the access check entirely and, for an analyst, a record of what a process had open that survives in the child.
- Job objects & silos
- A kernel object that groups processes and enforces limits on them collectively -- resource caps, UI restrictions, and kill-on-close lifetime binding -- and, in its silo form, the namespace-isolation primitive Windows containers are built on, which is why a process inside one can see a different filesystem and registry than the analyst examining it.
- PEB & TEB
- The user-mode half of a process's self-description -- the PEB carries the command line, image path, environment, and loaded-module list, the TEB carries per-thread stack bounds, TLS, and exception state -- and both live in memory the process itself can write, which makes them simultaneously the richest source of process detail and the least trustworthy one.
- Parent PID spoofing
- Using a documented creation attribute to nominate which process is recorded as a new process's parent -- the kernel honours the nomination, so the process object, every enumeration API, and every mainstream telemetry source all record a lineage that never happened, and the technique defeats parent-child detection without defeating any control.
- Process creation sequence
- The multi-stage sequence that turns an image file into a running process -- section creation, kernel object allocation, address-space and PEB construction, initial thread, then user-mode loader initialisation -- and, critically for an analyst, the exact point in that sequence where creation telemetry fires, which is what decides everything a process-creation event can and cannot establish.
- Process hollowing & doppelganging
- The technique family that makes the durable creation record describe a binary which never executed -- a legitimate image is used to create a process, its contents are replaced before the first instruction runs, and every log on the host retains the original hash, path, and signature while entirely different code executes under that identity.
- Baseline process tree
- What a Windows host's process lineage looks like when nothing is wrong -- the fixed boot chain from System through the session manager to the service and shell trees, the session boundaries that separate them, and the substantial population of processes whose recorded parent identifies only the launch mechanism and says nothing at all about who asked for them.
- Protected Process Light
- A byte in the kernel process object carrying a protection type and a signer class, which the kernel consults when one process opens another -- stripping access rights rather than failing the open outright, and constraining only user-mode callers, which is why a kernel-mode adversary is entirely unaffected and why bring-your-own-vulnerable-driver is the standard route around it.
- Thread execution hijacking
- Suspending a thread that already exists, rewriting its saved instruction pointer to point at injected code, and resuming it -- the injection trigger that creates no thread, loads no module, and generates no event, making every detection built on enumerating or counting threads blind to it by construction rather than by tuning.
- Virtual Address Descriptors
- The memory manager's own balanced-tree description of every reserved and committed region in a process's user-mode address space -- what is mapped where, with what protection, and backed by which file if any -- maintained entirely independently of the loader's module lists, which is what makes comparing the two the most reliable way to find code that got into a process outside the loading path.
REG
- AmCache.hve
- Standalone registry hive recording per-file inventory metadata -- a SHA-1 capped at the first 31,457,280 bytes (a full-file hash for anything smaller), PE compile timestamp, and full path -- populated by the compatibility-appraiser inventory pipeline, independently of ShimCache's kernel shim cache.
- BAM/DAM
- Per-user registry record of the last time each executable transitioned background/foreground activity state, kept by the OS power- and network-throttling subsystem -- one of the few registry artifacts that ties an execution timestamp directly to a user SID.
- COM hijacking keys
- The CLSID-indexed registry tree the COM runtime consults to resolve a class identifier to the DLL or executable that actually implements it -- redirecting a single InprocServer32 value hijacks execution for every component and every caller (frequently a trusted, high-privilege built-in Windows process) that instantiates that CLSID, and because HKCU CLSID entries take precedence over HKLM ones, a hijack can be planted with only standard user privilege.
- Deleted key & value recovery
- The registry's own analogue of NTFS's mark-and-release deletion behavior -- a deleted key or value's cell is flagged free and its space becomes reusable, but is not zeroed, meaning the same 'is this recoverable' question NTFS deletion-recovery asks has a registry-side counterpart with its own independent set of angles: hive unallocated-space carving, transaction-log replay, RegBack/backup comparison, and shadow-copy availability.
- Hive files & their locations
- The inventory of which hive lives where -- primary system and per-user hives, their scheduled RegBack backup copies, and the less-common hives (COMPONENTS, BCD, Amcache.hve, ELAM) an investigator can miss entirely if they only know the five everyone names -- and the load/unload mechanics that let an analyst mount an offline or foreign hive for parsing.
- Hive binary structure
- The on-disk binary format of a registry hive -- a base block, HBIN allocation blocks, variable-length cells, and paired transaction logs -- that every registry-hosted artifact (ShimCache, Amcache, BAM/DAM, Run keys, service keys) inherits its recovery behaviour, multiplicity and timestamp limitations from.
- Image File Execution Options
- The per-executable-name registry tree originally built to let developers attach a debugger to a specific process at launch -- a Debugger value under this key silently replaces the named program with whatever the value points to, which makes it one of the cleanest, least-visible execution-redirection primitives in Windows and a textbook defense-tampering technique against security-product binaries by name.
- Key LastWrite semantics
- The single FILETIME the registry format stores per key -- updated whenever a value under that key changes or a direct subkey is created, renamed or deleted -- which makes it a fast, host-wide activity indicator with exactly one working precision: 'something happened here,' never 'what' or 'in what order relative to a sibling value.'
- MRU lists
- A recurring registry pattern -- a small set of item values plus a separate ordering value (MRUList or MRUListEx) -- that dozens of unrelated Windows components and applications each implement independently to remember 'what did the user pick last', from Explorer's Open/Save dialog history to Paint's recent-file list, giving analysts per-application, per-user evidence of specific values a user selected, typed, or opened, each capped and evicted on its own component-specific schedule.
- Network profiles and signatures (NetworkList)
- SOFTWARE hive record of networks a host has joined, with a first and last connection time per profile and a gateway MAC and DNS suffix per signature -- a host location history, not a session log.
- Run/RunOnce keys
- The small set of registry keys the shell reads at logon to launch a fixed list of programs -- HKLM for every user, HKCU for one -- with no execution history of its own, only the current configured list, making it the single most examined and most misread persistence location in Windows: presence proves configuration, never that anything ran.
- Services registry key
- The SYSTEM-hive subkey tree the Service Control Manager reads at boot and on demand to launch every driver and service on the host -- the canonical persistence location for anything that needs to survive reboot with SYSTEM privileges, and one of the first places any intrusion investigation checks.
- Shellbags
- The per-user registry structure Explorer uses to remember each folder's view settings (icon size, sort order, window position) -- and, as a side effect of that bookkeeping, a durable record that a specific folder was browsed, including folders on removable media, network shares, or paths that have since been deleted and left no other trace on the local volume.
- ShimCache (AppCompatCache)
- Kernel-maintained cache of file paths and $STANDARD_INFORMATION modified times, populated when the shim engine evaluates a binary — not when it runs.
- SRUM database
- An ESE (Extensible Storage Engine) database -- not a registry hive despite living alongside registry-adjacent configuration -- that logs roughly hourly snapshots of per-application network usage, energy usage, and foreground/background activity for the past 30-60 days, giving analysts a coarse-grained but durable record of which programs ran and roughly how much network traffic they moved, long after Prefetch or ShimCache evidence of the same execution may have rolled off.
- Registry transaction logs
- The .LOG1/.LOG2 companion files that journal every hive write before it is checkpointed into the primary file -- the registry's own analogue of NTFS's $LogFile -- capable, within a window that on modern builds can reach days or weeks, of both recovering writes the primary file does not yet reflect and retaining pre-change values that expose a forged key.
- TypedPaths & RunMRU
- Two sibling per-user MRU-pattern keys -- TypedPaths for paths manually typed into the Explorer address bar, RunMRU for commands typed into the Win+R Run dialog -- both capturing what a user actually TYPED rather than clicked, which makes them uniquely valuable for recovering command lines and UNC paths that never touched a file-open dialog and therefore appear nowhere in ordinary MRU or shellbag evidence.
- UserAssist
- The per-user NTUSER.DAT key the Explorer shell writes to every time a user double-clicks or otherwise launches a program from the shell -- run count, last-run time, and (on modern builds) rough focus time, all indexed under value names that are ROT13-'obfuscated' rather than encrypted, a useful user-attributed indicator of GUI launches on Windows 10+, once you know the cases where it records a launch that never ran.
- Winlogon registry keys
- The SOFTWARE-hive key winlogon.exe itself reads to learn what shell and what pre-shell initialization to launch at every logon -- Shell and Userinit are the two fields, and both are trusted absolutely, with no signature check and no default-value fallback if hijacked, making them a durable, high-privilege persistence and privilege-context abuse point that predates and outranks the ordinary Run key mechanism.
SCR
- AMSI architecture & bypasses
- An interface letting applications submit content to the installed scanner at the moment it is about to be used -- which is after deobfuscation and before execution, making it the one place a scanner sees what a script actually is, and an in-process component the script can therefore reach.
- BITS jobs & bitsadmin
- A transfer service that queues jobs surviving reboots and logoffs, performs downloads under a service identity, and can run a command when a job completes -- making it a downloader, a persistence mechanism, and a scheduler in one, with its own durable job database.
- certutil abuse
- A certificate management utility whose documented functions include fetching remote files and decoding encoded data -- giving an actor a signed downloader and a signed decoder without introducing either, and leaving a distinctive cache artifact when the download path is used.
- .NET CLR loading
- The managed runtime that any process can load, and which will execute an assembly supplied as a byte array -- providing full-capability code execution with no file on disk, no image load event for the payload, and no need for the injection primitives that memory analysis is built to find.
- Constrained Language Mode
- An engine mode restricting the language to a safe subset -- and the only genuinely strong PowerShell control, because it is enforced by application control policy rather than by a setting the script's own privilege can reach.
- .NET ETW telemetry
- The managed runtime's own event provider, which reports assembly loading and compilation from inside the runtime -- the only source that sees an assembly loaded from a byte array, and disabled by a configuration value the loading process itself can set.
- Execution policy (and why it is not security)
- A safety feature that governs whether script files run, documented by its own vendor as not a security control -- and whose real analytic value is that overriding it leaves a distinctive command-line artifact.
- LOLBin catalogue
- The shipped, signed binaries whose documented functions include downloading, executing, and proxying code -- so the artifact is never the binary's presence or signature but the argument it was given and the context it ran in.
- MSBuild abuse
- A shipped build tool that compiles and executes code embedded in a project file -- turning an XML document into arbitrary in-process execution under a signed Microsoft binary, with no compiled payload ever on disk.
- mshta & JScript
- A shipped host for HTML applications, which are web pages with full local privileges rather than browser sandboxing -- and which will execute script inline from the command line or fetched from a remote location, with no payload file required.
- Office macros & VBA
- Code embedded in documents, executed on open by an application that trusts the file's origin -- and whose defence changed fundamentally when internet-sourced macros began being blocked by default rather than merely warned about.
- PowerShell engine internals
- The scripting engine that lives in a .NET assembly rather than in powershell.exe -- which means any process can host it, and the executable everyone monitors is merely the most common way to reach it.
- PowerShell logging tiers
- Four independent logging facilities of very different value -- script block logging is the one that matters, because it records what the engine compiled rather than what the user typed, which means it captures deobfuscated content.
- regsvr32 abuse
- A shipped utility that registers components by loading a library and calling its registration export -- and which, through a documented scriptlet path, will fetch and execute code from a remote location without writing the payload to disk.
- rundll32 abuse
- A shipped utility whose documented job is to load a library and call an exported function -- which is a general-purpose code execution primitive, and which makes the exported function name in the command line the single most informative field.
- Third-party interpreters
- Scripting runtimes that are not part of Windows and therefore inherit none of its scripting controls or telemetry -- no content logging, no scan interface participation, no language mode, no execution policy -- so the script file and the process tree are the entire evidence base.
- WMIC
- The command-line interface to the management infrastructure -- a reconnaissance and remote-execution tool in one, now deprecated and progressively removed, which makes its presence and use increasingly conspicuous rather than increasingly irrelevant.
- WSH & VBScript
- The original Windows scripting host and its legacy languages -- still present, still associated with script file types by default, executed by double-click, and possessing no content logging whatever, which makes the script file itself the primary artifact.
SVC
- ALPC (Advanced Local Procedure Call)
- The kernel-mediated local IPC mechanism that almost every Windows subsystem communicates over, and which produces essentially no telemetry -- making it simultaneously the busiest communication path on the host and the one an analyst can say the least about.
- COM server model
- The registry mapping from a class identifier to the code that implements it -- a DLL loaded in-process or an executable launched out-of-process -- resolved through a per-user tree that takes precedence over the machine-wide one, which turns an unprivileged registry write into code execution inside whatever process next instantiates that class.
- DCOM activation
- The mechanism that instantiates a COM object in another process or on another host -- resolving the class, checking launch and access permissions configured per AppID, and starting the server under a configured identity -- which makes remote activation a supported administrative capability and, for anyone holding the right permissions, a remote execution primitive.
- DCOM lateral execution
- Remote code execution achieved by activating a COM class on another host and calling a method it already exposes -- no service created, no task registered, no file written -- where the resulting process is parented by the COM server that hosted the method rather than by anything identifying the actor.
- Named pipes
- Named inter-process channels reachable locally and, through the IPC$ share, remotely -- carrying most remote administration, permitting a server to impersonate the client that connects to it, and named by strings that both legitimate software and tooling choose freely, which makes the pipe name simultaneously the best available indicator and an entirely attacker-controlled one.
- RPC endpoint mapper
- The directory service that turns an RPC interface identifier into the port a server is actually listening on, which makes it both the mechanism most remote Windows administration depends on and the single most productive reconnaissance target on a Windows host.
- RPC runtime
- The call mechanism nearly every Windows administrative operation travels over -- service control, scheduled task registration, WMI, DCOM, directory replication -- addressed by interface UUID rather than by anything human-readable, and almost entirely unlogged, which makes it the substrate most remote attacks move through and the one leaving least behind.
- Service Control Manager
- The process that owns every service on a Windows host -- starting them at boot and on demand, running them under configured accounts, and restarting them when they fail -- which makes it the single most durable execution mechanism on the platform and the parent of every service-launched process regardless of what actually requested the start.
- Service configuration & types
- The registry values that define what a service is -- what it runs, when it starts, which identity it assumes, and what happens when it fails -- read by the SCM at start rather than held in memory, which makes a service definition a durable on-disk artifact and a service change a registry write with its own timestamp.
- ServiceDll & path hijacking
- The family of techniques that get attacker code running as a service without creating one -- redirecting a hosted service's DLL, exploiting an unquoted image path, or replacing the binary a service points at -- each of which produces execution as the service's identity while the service continues to appear entirely legitimate.
- Service recovery action abuse
- The command a service can be configured to run when it fails -- executed by the Service Control Manager, entirely separate from the service's own binary, invisible to standard service enumeration, and triggerable by anyone who can make the service crash.
- Service trigger events
- Conditions that start a service without anyone requesting it -- a network endpoint opening, a device arriving, a group policy refresh, a named ETW event firing -- which turns a service from something invoked into something that waits, and makes trigger configuration a form of persistence that a running-services listing will never show.
- svchost grouping & splitting
- The generic host process that runs services implemented as DLLs rather than executables -- grouped by a name passed on its command line, and on well-resourced hosts split so each service gets its own instance -- which means a svchost process's identity comes entirely from its group argument and the DLLs it loaded, never from the binary itself.
- WMI architecture
- The management framework that exposes almost every aspect of a Windows host as queryable classes with invokable methods -- reachable remotely through DCOM, executing provider code in a shared host process, and capable of creating processes, so that a single interface offers reconnaissance, execution, and persistence through entirely supported operations.
- WMI repository (OBJECTS.DATA)
- The on-disk store holding WMI's persistent class definitions and, critically, permanent event subscriptions -- a persistence mechanism that runs code on a condition with no file, no service, no scheduled task, and no registry run key, living instead inside a binary database most tooling cannot read.
TIME
- Clock skew across sources
- The genuine, underlying-clock-accuracy counterpart to the display-layer timezone pitfall -- a host's own hardware clock and its W32Time-synchronized system clock can be seconds, minutes, or (after prolonged sync failure) hours off from true time and from every other host's clock, meaning that even after every timezone-conversion pitfall this domain documents is correctly handled, two hosts' 'UTC' timestamps for the same real-world event can still genuinely disagree, and distinguishing genuine skew from every other explanation is a distinct, necessary step before cross-host timeline correlation can be trusted.
- EVTX timestamp fields
- Every Windows Event Log record carries a SystemTime field, written by the Event Log service at the moment the record was generated and never touched again -- append-only, sequentially numbered alongside it by an EventRecordID that can never be forged into a different position without breaking the log's own internal sequence, making EVTX timing one of the highest-trust corroboration sources in this entire corpus, precisely because there is no equivalent to $SI's trivial SetFileTime forgery path for an individual record.
- Limits of event ordering
- The uncomfortable fact that sorting a combined timeline by timestamp and reading top-to-bottom is not the same as reading events in the order they actually happened -- clock skew across log sources, coarse timestamp precision producing tied entries, buffered/batched writes, log-rotation reordering, and clock corrections can all silently scramble apparent sequence, meaning ORDER, not just individual timestamp accuracy, is its own distinct thing to verify before a timeline narrative can be trusted.
- Prefetch timestamp fields
- The specific timestamp semantics inside a Prefetch (.pf) file that make it a genuinely distinct execution-timing witness from every registry- or NTFS-based artifact in this corpus -- an array of up to the last eight run times (expanded from a single last-run field on Windows XP-7) plus a run count, both written through the prefetcher pipeline (kernel trace, SysMain write-out) rather than by the launched program, giving analysts a short execution history no other artifact in this domain records in quite the same shape -- harder to forge casually than $SI, but not tamper-proof.
- Registry LastWrite timing in context
- The comparative, cross-domain companion to WOS-REG-key-lastwrite -- where that dossier explains what the field is and how a single artifact behaves, this one places registry LastWriteTime on this corpus's overall precision-and-forgeability hierarchy alongside $SI, $FN, EVTX SystemTime, and Prefetch's run-time array, so an analyst weighing which timestamp to trust most in a mixed-artifact timeline has a single reference point instead of re-deriving the comparison from five separate dossiers each time.
- $SI vs $FN comparison
- The single most important comparison in NTFS timeline forensics -- $STANDARD_INFORMATION is trivially forgeable from user mode via SetFileTime, $FILE_NAME is not, so a divergence between the two beyond what a legitimate copy, rename, or restore explains is the strongest single-artifact indicator of timestomping available, and this dossier is the dedicated methodology every other dossier's correlation recipes point to rather than re-deriving.
- Super-timeline construction
- The practical methodology for merging every timestamped artifact on a host -- $SI/$FN, registry LastWriteTime, EVTX, Prefetch, browser history, and dozens more -- into a single, normalized, sortable body file, which turns dozens of separate per-artifact investigations into one queryable timeline, at the cost of inheriting every precision, skew, and ordering limitation documented elsewhere in this domain unless each source is deliberately normalized and precision-tagged during the merge.
- Timeline pivoting technique
- The core analytical technique a super-timeline exists to enable -- start from a single, well-established anchor event (a confirmed malicious file's creation, a known-bad process launch), then narrow the combined timeline to a tight window immediately around it and read across every artifact type at once, discovering related activity that no single-artifact investigation would have surfaced, provided the analyst respects exactly the precision and ordering limits documented elsewhere in this domain rather than over-reading proximity as causation.
- Timeline tooling landscape
- A comparative survey of the tools actually used to construct and analyze timelines across this corpus's domain -- log2timeline/plaso for broad-coverage super-timeline construction, KAPE for targeted collection-plus-parsing, Timeline Explorer for interactive review, and the many single-artifact Eric Zimmerman tools that feed into all of the above -- because choosing the wrong tool for a given investigative need (broad automated coverage vs. fast targeted answers vs. interactive exploration) costs more time than the tooling itself ever explains up front.
- Per-artifact timestamp semantics
- The foundational fact every other timeline claim in this corpus quietly depends on: Windows stores most timestamps as a FILETIME -- 100-nanosecond intervals since 1601-01-01T00:00:00Z, always UTC at the storage layer -- but individual artifacts diverge sharply in precision (2-second DOS-era rounding in some structures, full 100ns elsewhere), update semantics (overwritten-in-place vs. append-only), and display-layer timezone conversion, so 'the timestamp says X' is never a complete claim until the specific artifact's own semantics are named.
- Timestomp detection
- The full methodology for detecting deliberate timestamp manipulation, synthesized across every independent witness a sophisticated timestomp attempt has to defeat simultaneously to go unnoticed -- $SI/$FN divergence, $LogFile pre-change recovery, $UsnJrnl's own independent event log, shadow-copy snapshots, and the tunneling confounder that must be ruled out first -- because no single artifact in this corpus is sufficient on its own, and treating any one of them as the whole answer is the most common way a real timestomp gets missed or a benign anomaly gets over-called.
- Time zone handling
- The system-wide registry configuration -- a bias value and a set of DST transition rules, both changeable by any Administrator at any time with no logged history of prior values -- that Windows actually uses to convert stored UTC timestamps into every local-time display an analyst or user ever sees, meaning the display-layer conversion pitfall this dossier's sibling documents has a concrete, forensically examinable configuration source, and a host's OWN past timezone changes can themselves distort the meaning of any local time captured before the most recent change.
- UTC vs local time pitfalls
- The single most common source of an analyst-introduced timeline error in this entire corpus: every FILETIME value is stored and computed in UTC with no exception, but nearly every tool that displays one converts to some local timezone for readability -- and when that conversion uses the analyst's own workstation timezone rather than the SOURCE host's, or when two tools in the same investigation apply different conversions, events can appear hours apart (or even on different days) that actually happened simultaneously.
- Windows Time service (W32Time)
- The service actually responsible for keeping a Windows host's clock accurate -- a domain-joined host synchronizes hierarchically against its domain controller chain by default (never directly against an external NTP source unless deliberately reconfigured), while a standalone host relies on whatever NTP source, if any, is manually configured, and the service's own registry configuration and Time-Service event log are the primary forensic evidence for reconstructing why a host's clock was, or was not, trustworthy at any given moment.
VIRT
- Hyper-V architecture
- The platform hypervisor, whose most consequential property for an analyst is that when it is enabled the Windows installation itself becomes a partition running under it -- so the operating system an investigation examines is a guest, not the lowest layer.
- Nested virtualisation abuse
- Running a hypervisor inside a guest, which adds a layer of visibility loss on top of one that already exists -- so activity in the inner guest is invisible to the outer host, invisible to the outer host's tooling, and invisible to anything watching the intermediate guest too.
- Secure Kernel and VTL1
- A second, higher-privileged execution environment enforced by the hypervisor, in which secrets are held where the normal kernel cannot reach them -- which raises the floor on kernel-level compromise and means the most important thing about it is what your tooling can no longer see.
- Server silos and Windows containers
- Namespace isolation implemented inside a single running kernel, so a process-isolated container's processes are ordinary processes on the host with a redirected view of the world -- which means the host can see everything, and almost nothing survives the container's exit.
- VM snapshot forensics
- A stored point-in-time state of a virtual machine, including its memory -- which makes a snapshot the one place a full memory image of a compromised host may already exist without anyone having thought to collect one, and reverting to one the cleanest destruction of evidence available.
- Third-party hypervisor artifacts
- The host-side traces left by non-Microsoft virtualisation software -- installed products, guest disk files, shared folder paths, and clipboard and drag-drop channels -- which together make an endpoint hypervisor a place to run whatever you like with a documented data path back out to the host.
- VHD/VHDX artifacts
- A file that is also a volume -- mountable with a double-click, containing a filesystem whose contents are not files on the host volume, which makes it a delivery container that defeats file-based controls and a forensic container that rewards being opened.
- VM detection and sandbox evasion
- Checks malware performs to decide whether it is being analysed rather than deployed -- and the reason a sample that did nothing in a sandbox proves nothing about what it does on a real host.
- Windows Sandbox
- A disposable Windows environment that discards everything on close by design -- which makes it a legitimate testing tool and an execution environment whose contents are gone before an investigation begins, unless the host-side configuration and mapped folders are examined.
- WSL filesystem & log artifacts
- Where the evidence for Linux activity on a Windows host actually lives -- a virtual disk holding an ordinary Linux filesystem under the second implementation, ordinary Windows files under the first, and in both cases a Linux evidence set that Windows tooling will not surface for you.
- WSL1 vs WSL2
- Two entirely different implementations behind one name -- the first translates Linux system calls into Windows ones so processes are visible as Windows processes, the second runs a real Linux kernel in a partition so almost nothing is -- and which one is in use determines whether any Windows telemetry sees Linux activity at all.