A separate, least-privileged NEVO service identity and process must exclusively hold the authorization state; ALFRED should run as an unrelated standard user and communicate with NEVO only through a narrowly permissioned, request-specific interface.
Minimum supported architecture
- ALFRED identity
- Run ALFRED under a dedicated local standard-user account.
- Do not add that account to Administrators or grant service-management, ownership, backup, restore, or debug rights.
- Processes inherit their user’s access token, so this identity becomes the primary ACL boundary.^1^
- Keep UAC enabled. A standard user cannot elevate without administrator credentials and approval.^2^
- NEVO identity and process
- Run the trusted NEVO component as a Windows service under a unique virtual service account, service SID, or dedicated local standard account—not
LocalSystem. - Enable a service SID and grant that SID access only to NEVO’s keys, approval database, logs, and required IPC object. Service isolation exists specifically to secure files and registry keys to one service without using a highly privileged account.^3^
- Remove ALFRED,
Users, andAuthenticated Usersfrom those objects’ ACLs. NTFS supports per-identity read, write, and modify permissions; SACLs can audit attempted access.^4^ - Protect the service object itself. ALFRED must not receive
SERVICE_CHANGE_CONFIG,SERVICE_STOP, or similar rights, because those can permit service interference or code execution under its identity.^5^
- Run the trusted NEVO component as a Windows service under a unique virtual service account, service SID, or dedicated local standard account—not
- Communication boundary
- Expose only fixed operations such as
MoveApprovedFile,OpenApprovedDocument, orLaunchApprovedApplication; do not expose “run command,” “run Python,” or arbitrary path/argument execution. - A named pipe can have a DACL that permits ALFRED to connect while excluding other identities. Windows performs an access check against the client token when it connects.^6^
- The pipe ACL authenticates who may connect; NEVO must still validate every operation, target, argument, approval, freshness value, and replay identifier.
- Expose only fixed operations such as
This does constitute a trusted broker boundary. If NEVO must perform actions that ALFRED is not allowed to perform directly, no combination of ACLs and application allowlisting can eliminate that mediator. The existing NEVO component can fill the role, but its request parser and operation handlers become security-critical.
Keys and approval signatures
Prefer asymmetric signatures instead of HMAC for owner/developer approvals. Keep the private signing key outside ALFRED and give NEVO only the public verification key. CNG verification uses the public key, while signing requires the private key.^7^
With HMAC, verification and generation use the same secret. Therefore:
- ALFRED must never verify HMAC approvals locally.
- Only the NEVO service may decrypt or use the HMAC key.
- Protect the stored secret with user-scoped DPAPI under NEVO’s service identity and an NTFS ACL for that identity. By default, DPAPI data can normally be decrypted only by the same user on the same computer.^8^
- Do not use
CRYPTPROTECT_LOCAL_MACHINE: any user on that computer can then decrypt the data. - DPAPI protects the secret at rest, not after NEVO decrypts it into memory. Compromise of NEVO allows an attacker to use the HMAC key and forge approvals.
For asymmetric private keys, CNG key-storage providers offer stronger isolation. The Microsoft Platform Crypto Provider uses the TPM for hardware-backed key storage and prevents extraction of private keys.^9^ This improves key extraction resistance, but a compromised process authorized to invoke signing operations may still misuse the key.
Restricting interpreters and executables
Use App Control for Business as the device-wide executable/code-integrity layer and, where per-user differences are required, use AppLocker for ALFRED-specific restrictions. Both are available on supported Windows 11 editions, including Pro; App Control is the stronger security feature, while AppLocker provides per-user/group rules.^10^
Important limitation: allowing python.exe generally permits Python to execute arbitrary scripts. App Control does not directly control scripts interpreted by unenlightened third-party hosts; allowing such a Python host implicitly allows its scripts.^11^
Consequently, a robust design cannot simultaneously:
- run ALFRED as unrestricted Python under one identity, and
- rely on application control to prevent that compromised process from loading different Python source.
Practical choices are:
- Package ALFRED using Win32 app isolation/AppContainer and grant only declared capabilities. AppContainer is a security boundary operating at low integrity.^12^
- Place the untrusted model/runtime in Windows Sandbox or a Hyper-V VM and expose only the NEVO interface. Windows Sandbox is available on Pro and provides a separate kernel, but it is disposable and networking is enabled by default.^13^
- Remove Python from ALFRED’s allowed execution environment and deploy a fixed packaged executable whose writable data directories are separate from its protected code.
AppLocker can additionally deny ALFRED access to PowerShell, CMD, script hosts, installers, and unapproved executables. Its script collection covers .ps1, .bat, .cmd, .vbs, and .js, but AppLocker is defense in depth rather than a defensible security boundary.^14^ Never allow execution by path from a directory ALFRED can write.
Developer access
Give Codex a separate, normally standard identity. Keep NEVO code owned by an administrative maintenance identity and grant Codex Modify only on the code tree during an approved maintenance window; never grant that permission to ALFRED. Remove the ACE afterward and restart NEVO from reviewed code.
Windows 11 Pro provides ACL and group-membership mechanisms for this delegation, but the supplied documentation does not establish a built-in local just-in-time approval workflow. Automating expiration and approval would require management tooling or a trusted maintenance procedure. Existing processes retain their current access token, so identity/group changes may require a new logon or service restart.
Compromise boundaries
If ALFRED is compromised, separate identities and correctly configured ACLs continue to protect NEVO files, service configuration, and process memory. Without debug privilege, ALFRED cannot bypass another process’s DACL to read or write its memory.^15^ Application control and sandbox boundaries also remain applicable.
If NEVO is compromised, its readable files, decrypted HMAC key, approval authority, permitted operations, and writable logs must be considered compromised. NTFS, DPAPI, and a separate process do not protect resources from the identity explicitly authorized to use them. TPM-backed non-exportable keys may resist extraction, but not unauthorized use through capabilities available to the compromised NEVO process. An administrator or kernel compromise is also outside the protection offered by ordinary service identities and NTFS ACLs.
References
- Access tokens
- User Account Control overview
- Service Changes for Windows Vista
- Advanced credential protection
- Service Security and Access Rights
- Named Pipe Security and Access Rights
- Signing Data with CNG
- CryptProtectData function (dpapi.h)
- CNG Key Storage Providers
- App Control for Business and AppLocker Overview
- Script enforcement with App Control for Business
- Application isolation
- Windows Sandbox
- AppLocker
- Process Security and Access Rights