# REA MASTER INVESTIGATION ## Reverse Engineering Windows 11 — Full Operating System Architecture and Component Analysis ### MISSION Use Reverse Engineer Anything (REA) and any properly configured, authorised supporting analysis tools to conduct a comprehensive, evidence-based technical investigation of Microsoft Windows 11. **The objective is not to copy Windows 11 wholesale. It is to understand how its major components work, how they interact, which functions can be independently recreated, and which cannot currently be investigated with the available tools.** Treat Windows 11 as a collection of interconnected software subsystems rather than one enormous executable. Break the operating system into manageable components, investigate them systematically, and create a reusable investigation framework that can also be applied to other operating systems. Do not respond that the operating system is too large without first identifying which individual components can be analysed. Do not claim that something has been reverse-engineered unless the claim is supported by actual investigation evidence. --- # 1. TARGET CONFIGURATION **Primary target:** Microsoft Windows 11 **Edition:** Automatically detect (Home, Pro, Enterprise, Education or other). **Build:** Detect exact version, build number and architecture. **CPU architecture:** Detect x86-64, ARM64 or another architecture. **Source:** An authorised local Windows installation, installation image, extracted files, or controlled virtual-machine environment. **Investigation mode:** Read-only by default. **Intended outcomes:** - Operating system architecture map. - Detailed subsystem and component inventory. - Relationships and dependency mapping. - Identification of functions, APIs and workflows. - Technical findings supported by evidence. - Reimplementation feasibility assessments. - One bounded, independently implemented demonstration feature where practical. - A reusable methodology for investigating other operating systems. Do not assume that a Windows installation, VM, ISO, binary, elevated permission or supporting tool is available until verified. Use an isolated disposable test VM or authorised offline file copies where possible. --- # 2. REA CAPABILITY ASSESSMENT Before analysing Windows itself, identify the capabilities actually available in the connected REA environment. Determine: 1. Installed REA version and whether the MCP server is connected. 2. Which REA tools and operations are currently advertised. 3. Which supported analysis providers are installed. 4. Whether Ghidra, Hopper, IDA or equivalent providers are configured. 5. Whether native Windows PE binaries can actually be analysed on this host. 6. Whether managed .NET assemblies can be examined. 7. Whether PE resources, manifests and binary metadata can be inspected. 8. Whether directory, application-package and file inventories are supported. 9. Whether permitted application behaviour can be observed. 10. Whether the available tools support runtime tracing, or only static examination. 11. Whether the environment can export and retain evidence across investigations. 12. Which capabilities are unavailable due to missing permissions, prerequisites, unsupported targets or version restrictions. Use actual advertised tool schemas. Do not invent REA tool commands or assume every function described in the latest documentation is installed. Use available operations where appropriate, including examples such as: - `open_binary` - `binary_overview` - `analyze_function` - `inspect_pe_resources` - `inspect_managed_artifact` - `inspect_artifact` - `inspect_analysis_view` - `export_evidence_bundle` Call these only if present and compatible with the target. Where an appropriate tool is unavailable, give the exact blocker, the additional tool or prerequisite needed, and an alternative read-only investigation method. Do not automatically install software or modify agent configuration. **First deliverable:** A capabilities table identifying what REA can genuinely examine on this machine. --- # 3. WINDOWS 11 COMPONENT INVENTORY Investigate the following subsystems. For each, establish: - Purpose and responsibilities. - Main functional components. - Relevant executable files and libraries. - Associated processes and services. - User-facing functionality. - Interfaces and dependencies. - Available APIs and documented contracts. - Observable events and data flow. - Configuration and persistence mechanisms. - Security boundaries. - Static and runtime evidence available. - Feasibility of independent reimplementation. Do not infer that a named Windows component is present merely because it is normally associated with Windows. ## A. Boot and system startup Investigate: - UEFI and firmware interaction. - Boot Manager and Boot Configuration Data. - Operating system loader. - Kernel loading. - Driver initialisation. - Early system services. - Session initialisation. - Login and desktop startup. - Recovery and repair mechanisms. - Shutdown, restart, sleep and hibernation. Produce a high-level startup sequence and component dependency map. Use documentation or permitted offline examination for protected boot components; do not modify boot configuration or security mechanisms. ## B. Kernel and operating system core Investigate: - NT kernel architecture. - User-mode and kernel-mode separation. - Process creation and termination. - Thread scheduling. - Virtual memory management. - Memory allocation. - I/O management. - Interrupts and exceptions. - Object management and handles. - Interprocess communication. - Synchronisation. - System calls and public interfaces. Identify observable contracts and module boundaries. Distinguish documented kernel functionality from behaviours actually confirmed through binary analysis. ## C. Hardware and drivers Investigate: - Hardware abstraction. - Driver loading and management. - Plug and Play. - Device enumeration. - USB and Bluetooth. - Display hardware. - Storage controllers. - Network adapters. - Audio devices. - Printers and scanners. - Power management. - Device Manager. Map relationships between hardware, drivers, kernel services and user-facing applications. ## D. Desktop environment and graphical shell Investigate: - Windows Explorer shell. - Desktop composition. - Start menu. - Taskbar. - System tray. - Widgets. - Window management. - Multiple virtual desktops. - Snap layouts. - File and application shortcuts. - Context menus. - Dialog boxes. - Drag-and-drop. - Notifications. - Theme and personalisation. - Display scaling and multi-monitor behaviour. For each feature, trace: User action → UI component → application or service → operating system interface → observable result. Give particular attention to components that could be independently recreated as desktop software. ## E. File Explorer and storage Investigate: - File Explorer interface. - Folder navigation. - Directory enumeration. - Search and filtering. - Copy, move, rename and delete operations. - File metadata and properties. - File associations. - Access permissions. - NTFS behaviour. - ReFS where applicable. - Volumes and partitions. - Removable storage. - Network drives. - Recycle Bin. - File-system notifications. - Backup and restore functionality. Identify the relationship between the visual file manager, system APIs, file-system drivers and storage hardware. ## F. User accounts and identity Investigate: - Local users. - Microsoft account integration. - User profiles. - Session management. - Authentication workflows. - Windows Hello. - Access tokens and permissions. - User Account Control. - Groups and account policies. - Domain and Entra ID integration where present. Focus on documented interfaces, permission models and observable workflows. Do not extract credentials, authentication secrets, security tokens or protected personal information. ## G. Processes, services and background tasks Investigate: - Process lifecycle. - Windows services. - Service Control Manager. - Background processes. - Scheduled tasks. - Startup applications. - Process priorities. - Task Manager. - Resource monitoring. - Event-driven execution. - Application crash handling. Produce a relationship diagram for at least one ordinary application from launch through termination. ## H. Software installation and application compatibility Investigate: - Win32 applications. - .NET applications. - Windows App SDK. - WinUI. - COM and other documented interoperation mechanisms. - MSIX and AppX packaging. - Microsoft Store integration. - Installers and uninstallers. - Application manifests. - File associations. - Shared libraries. - Compatibility layers. - Application updates. - Sandboxing and isolation. Identify the interfaces that allow third-party applications to interact with Windows. ## I. Networking and connectivity Investigate: - Network interface management. - TCP/IP and UDP. - DNS. - DHCP. - Wi-Fi and Ethernet configuration. - Bluetooth networking. - VPN interfaces. - Windows Firewall. - SMB file sharing. - Remote Desktop. - Network discovery. - Proxy settings. - Network diagnostics. Map user configuration to the responsible operating system services and network interfaces. Use documentation, local configuration and authorised observations; do not intercept third-party traffic or attempt unauthorised network access. ## J. Security architecture Investigate at an architectural level: - Microsoft Defender. - Windows Firewall. - BitLocker. - Secure Boot. - TPM integration. - Code integrity. - Application permissions. - Windows Sandbox. - Virtualisation-based security. - User Account Control. - Software and driver signing. - Security event reporting. - Security updates. Document security boundaries and documented interactions. Do not bypass encryption, defeat code integrity, disable security protections, extract secrets or develop exploitation techniques. ## K. System settings and configuration Investigate: - Windows Settings application. - Control Panel and legacy settings. - Windows Registry. - Configuration files. - Administrative policy. - Group Policy. - WMI and CIM. - Environment variables. - Device configuration. - Time, language and region. - Accessibility settings. - Default applications. Trace how an ordinary settings change is represented and, where safely observable, persisted. ## L. Search, indexing and information retrieval Investigate: - Windows Search interface. - Search indexing. - File and application discovery. - Metadata extraction. - Search filters. - Result ranking where observable. - Start menu search. - Search integration with File Explorer. Identify the relationship between UI, indexing services, databases and file-system events. ## M. Multimedia and input Investigate: - Audio playback. - Audio recording. - Video playback. - Graphics rendering. - DirectX and other public graphics APIs. - Display composition. - Microphone and camera permissions. - Keyboard and mouse input. - Touch input. - Pen input. - Clipboard. - Printing. - Accessibility input and output. Document the application-to-operating-system interfaces. ## N. Updates, maintenance and recovery Investigate: - Windows Update. - Update orchestration. - Component servicing. - Driver updates. - Application updates. - System restore. - Recovery environment. - Backup systems. - Reliability monitoring. - Event Viewer. - Diagnostic logs. - Error reporting. Do not change update policies, modify protected system components or initiate recovery operations. ## O. Virtualisation and subsystem support Investigate: - Hyper-V. - Virtual machines. - Windows Sandbox. - Windows Subsystem for Linux. - Virtual networking. - Host-to-guest integration. - Container-related functionality where available. - Virtual storage. - Resource isolation. Only analyse components actually installed or represented by accessible artifacts. ## P. Command-line and developer interfaces Investigate: - Command Prompt. - PowerShell. - Windows Terminal. - Shell commands. - Environment variables. - Script execution interfaces. - Public system APIs. - Windows SDK interfaces. - Developer tools. - Automation interfaces. Identify opportunities for independent tools to use documented APIs rather than reconstructing their internal implementation. ## Q. Diagnostics, telemetry and administration Investigate: - Event logs. - Performance counters. - Reliability Monitor. - Crash reporting. - System diagnostics. - Administrative consoles. - Remote management interfaces. - Enterprise policy features. - Audit mechanisms. - Privacy controls. - Data collection settings. Use anonymised or synthetic evidence when preparing reports. --- # 4. INVESTIGATION METHOD FOR EVERY SUBSYSTEM For each subsystem, use the same repeatable process. ### Step 1 — Define the behaviour Describe what the subsystem does in plain English. Identify a specific user action or system event that demonstrates its function. ### Step 2 — Identify artifacts Locate relevant components using permitted filesystem discovery and package inventories. Potential artifact types include: - EXE - DLL - SYS - MSIX/AppX - .NET assemblies - resource packages - manifests - configuration files - public API documentation Record the actual locations discovered. Do not assume fixed installation paths. ### Step 3 — Identify relationships Determine what components appear to communicate. Examine, where supported: - Imports and exports. - Symbols. - Static references. - Function calls. - Library dependencies. - Public IPC contracts. - Service relationships. - Managed metadata. - Resource references. Clearly distinguish observed relationships from inferred ones. ### Step 4 — Investigate implementation Use the appropriate REA provider for the selected artifact. Where possible, examine: - Relevant functions. - Pseudocode. - Assembly. - Data structures. - Constants and strings. - Control flow. - Inputs and outputs. - Error conditions. - Dependency calls. Select focused functions rather than decompiling an entire operating system indiscriminately. ### Step 5 — Verify behaviour Compare static findings with permitted, reproducible observations or authoritative documentation. Use a controlled VM or authorised test application when runtime observation is necessary and supported. Record mismatches and unresolved questions. ### Step 6 — Assess independent reconstruction Classify each feature as: 1. Reimplementable using public APIs. 2. Reimplementable using independently developed logic. 3. Partially reimplementable. 4. Requires replacement or redesign. 5. Requires additional investigation. 6. Not established as feasible. Do not copy proprietary implementations or protected resources into a proposed replacement. ### Step 7 — Produce evidence For each important conclusion record: - Component name. - Target OS build. - File path or source. - Artifact hash where available. - REA tool and provider used. - Evidence identifier. - Relevant function, resource or observation. - What the evidence establishes. - What remains uncertain. - Confidence rating. Use **Verified**, **Inferred**, **Documented only**, **Unknown**, and **Unsupported** as distinct evidence states. --- # 5. CROSS-COMPONENT ARCHITECTURE After investigating individual components, build a system-wide architecture model. Organise the findings into these layers: **Layer 1 — Hardware and firmware** Physical devices, firmware interfaces, hardware-dependent functionality. **Layer 2 — Kernel and drivers** Scheduling, memory, drivers, core operating system services. **Layer 3 — System services** Authentication, networking, storage, service management, updates and indexing. **Layer 4 — Application and API infrastructure** Win32, .NET, application frameworks, shared libraries and public interfaces. **Layer 5 — Desktop and user interface** Window management, taskbar, Start menu, Explorer, Settings and notifications. **Layer 6 — User applications** Built-in programs, optional applications, third-party integrations and user workflows. These are conceptual layers, not a claim that Windows is strictly implemented as six layers. Document interactions between layers and any cross-cutting components. Produce: - Layered architecture diagram. - Major service relationship map. - Component dependency table. - User-action-to-result flow diagrams. - Confirmed API and interface inventory. - Unresolved dependencies list. --- # 6. PRACTICAL DEMONSTRATION To prove that REA can contribute meaningful analysis, complete one bounded real-world investigation after the initial system inventory. **Preferred example: Windows File Explorer folder navigation.** Investigate the following: 1. How File Explorer is launched. 2. Which identified component provides the visible interface. 3. How folder selection is initiated. 4. Which observable or documented APIs provide directory information. 5. How files and folders are presented. 6. How navigation history behaves. 7. How file properties are requested. 8. What happens when the user opens a file. 9. How errors and permission restrictions are communicated. 10. Which behaviours can be reproduced using public interfaces. Use REA to examine at least one actual relevant binary or resource artifact, provided its inspection is supported. Produce a concrete evidence trail that identifies the artifact, the inspection operation, the returned evidence and its limits. If an independently developed demonstration is practical using the available development tools, create a **small separate file-browser prototype** using public APIs and original code. The demonstration should, where feasible: - Display folders. - Navigate directories. - List files. - Show file metadata. - Open selected files through documented system interfaces. - Handle ordinary errors. It must not modify Windows system files or impersonate protected components. Clearly distinguish behaviour demonstrated through REA from behaviour implemented using ordinary documentation. If this example is blocked, attempt a narrower investigation of a user-accessible application component and document the reason for the substitution. --- # 7. GENERALISE THE METHOD TO OTHER OPERATING SYSTEMS The architecture and investigation process must be reusable. Treat all OS-specific names, assumptions, file formats, commands and APIs as replaceable parameters. Create an operating-system adapter profile with at least these fields: - Operating system name. - Distribution or edition. - Version/build. - Kernel family and version. - CPU architecture. - Installation or image location. - Analysis host. - Executable and package formats. - Relevant analysis providers. - Filesystem layout. - Boot infrastructure. - Kernel and driver model. - Process and service manager. - Desktop environment. - Windowing/compositor system. - Software installation model. - Configuration and settings mechanisms. - Identity and permission model. - Networking stack. - Security architecture. - Update system. - Public developer APIs. - Logging and diagnostic mechanisms. - Virtualisation and compatibility features. - Investigation restrictions and available evidence. ### Windows 11 profile Default candidates to verify: - NT kernel. - PE/COFF and .NET. - Win32 and Windows application frameworks. - Explorer shell. - Registry and filesystem configuration. - Windows Service Control Manager. - MSIX and other Windows installation technologies. - Windows security and update infrastructure. ### Linux profile Replace Windows-specific assumptions with actual distribution-specific components. Potential investigation areas: - Linux kernel. - ELF binaries. - glibc or musl. - systemd, OpenRC or another init/service manager. - X11 or Wayland. - GNOME, KDE Plasma or another desktop environment. - Filesystem Hierarchy Standard and actual distro paths. - ext4, Btrfs, XFS or other filesystems. - D-Bus. - PAM and other identity mechanisms. - Package managers such as APT, DNF or pacman. - Linux security modules, permissions and namespaces. Do not assume every Linux distribution uses systemd or the same desktop stack. ### macOS profile Replace Windows-specific assumptions with: - XNU/Darwin. - Mach-O binaries. - launchd. - Finder. - Dock. - WindowServer. - Cocoa/AppKit and Swift frameworks. - APFS. - Application bundles. - Plists and preferences. - Keychain. - Code signing and entitlements. - macOS privacy protections. - Apple update and recovery mechanisms. Respect platform security and code-signing boundaries. ### Other operating systems For FreeBSD, Android, ChromeOS and other systems, first establish the actual architecture rather than forcing Windows-specific categories onto them. Maintain comparable functional categories while permitting entirely different implementations. ### Mandatory adaptation output For every alternative OS, produce a mapping table containing: 1. Windows 11 subsystem. 2. Equivalent target-OS subsystem. 3. Relevant target-OS components. 4. File or package format. 5. Applicable REA analysis method. 6. Additional tool requirements. 7. Major architectural differences. 8. Investigation limitations. The framework should allow the target OS to be changed without rewriting the full investigation methodology. --- # 8. REPORTING REQUIREMENTS Maintain a persistent investigation report, if authorised storage is available, with these sections. ## Report A — REA capability assessment Which analysis functions actually work in this environment. ## Report B — Operating system inventory All identified subsystems and their current investigation status. ## Report C — Technical component dossiers One dossier per investigated component, supported by evidence. ## Report D — Dependency architecture Relationships between system layers, components, services and interfaces. ## Report E — Behaviour and workflow findings Specific user or system actions traced through available evidence. ## Report F — Reconstruction assessment Which behaviours can be implemented independently, what technologies are suitable, and what remains unknown. ## Report G — Demonstration results The selected feature, investigation evidence, prototype if created, and validation results. ## Report H — Cross-operating-system adaptation What must change to investigate Linux, macOS or another OS. ## Report I — Outstanding questions Unknowns, missing tools, blocked investigation paths and the next useful probe for each. ## Report J — Executive summary Explain the findings to someone without a technical background. --- # 9. EXECUTION RULES Follow these requirements throughout the investigation. 1. Perform real REA analysis rather than merely summarising general operating system knowledge. 2. Use installed, available tools and their actual schemas. 3. Start with narrow investigations and expand only when the evidence justifies doing so. 4. Do not process every operating system binary in one operation. 5. Avoid unnecessary repeated analyses of the same artifact. 6. Prefer small, focused evidence results and paginated views when supported. 7. Export evidence before closing sessions when it needs to be retained. 8. Do not fabricate tool results, process observations, file paths or decompiled code. 9. Do not treat missing symbols as proof that a function does not exist. 10. Do not confuse documented architecture with verified implementation. 11. Do not confuse a reconstructed behaviour with recovery of original source code. 12. Do not modify the operating system under investigation. 13. Do not disable security controls, alter boot components, patch protected binaries or bypass access restrictions. 14. Do not capture personal credentials, session secrets or unrelated private data. 15. Observe software licensing and intellectual-property restrictions. 16. Obtain explicit approval for installations, configuration changes, runtime actions with side effects or other operations outside the read-only scope. 17. Where access or licensing prevents investigation, clearly identify the limitation rather than attempting to bypass it. 18. If a component cannot be investigated, record exactly why and identify what would make further legitimate investigation possible. 19. Use existing public documentation to complement evidence, not to impersonate evidence. 20. Keep each investigation reproducible. --- # 10. INITIAL EXECUTION SEQUENCE **Begin now, using the environment actually available.** Do not attempt to reverse-engineer the entire operating system simultaneously. ### Phase 1 — Establish capability - Identify the target system and REA environment. - Verify actual REA tool availability. - Identify valid analysis providers and target formats. - Report blockers and limitations. ### Phase 2 — Map Windows 11 - Construct an initial subsystem inventory. - Identify available example artifacts. - Establish architectural categories and dependencies. - Distinguish verified findings from documentation-based descriptions. ### Phase 3 — Demonstrate an actual investigation - Select the File Explorer navigation example. - Identify an accessible component. - Run an appropriate REA inspection. - Show the evidence. - Trace a focused behaviour as far as supported. ### Phase 4 — Reconstruct and verify - Explain how the investigated behaviour can be independently recreated. - Develop a bounded original prototype if feasible. - Test observable behaviour. - Document implementation differences and unresolved questions. ### Phase 5 — Continue systematically - Update the investigation register. - Identify the next most useful subsystem. - Explain which techniques remain reusable. - Produce the operating-system adaptation profile. --- # 11. SUCCESS CRITERIA This investigation is successful when it demonstrates the following: **Capability:** REA has been tested against an actual accessible Windows component. **Evidence:** The investigation contains genuine tool results and traceable findings. **Understanding:** At least one component's purpose, dependencies and behaviour have been explained beyond a generic description. **Architecture:** Windows 11 has been divided into coherent subsystems suitable for continued investigation. **Reconstruction:** At least one investigated behaviour has a documented independent implementation approach, with a prototype where feasible. **Portability:** The method can be retargeted to a different operating system by replacing its adapter profile and platform-specific evidence sources. **Transparency:** Unsupported operations, missing evidence and unresolved questions are clearly recorded. Do not claim to have reconstructed Windows 11 as a whole. ### FINAL INSTRUCTION Start with the real capability assessment and the first executable File Explorer investigation. Show what REA actually discovers, which operations succeed, which fail, and what technical knowledge is produced. Demonstrate the capability rather than simply asserting that it exists. If the installed environment cannot perform the chosen analysis, present the exact blocker and the shortest legitimate route to a testable result, then continue with any supported read-only investigation. Proceed autonomously within the authorised read-only scope and report the results of the first completed investigation.