Hi @אסף מנגוני
Thank you for the clear description of the design and its requirements.
As you asked, I have kept this at design level only, with no commands or configuration steps. Everything below is based on the public Microsoft documentation, and I point out where that documentation sets a limit.
In short
Yes. Windows 11 Pro can enforce this separation with built-in features, provided that ALFRED, the NEVO authorization component and Codex each run under their own local account and none of them is an administrator. Nothing below needs a domain, MDM or a cloud service. Two of your requirements cannot be enforced by Windows itself:
- "Approved Python scripts only". Once an account may start a Python interpreter, Windows application control does not decide which scripts it runs (see 5).
- "Temporary" permissions. NTFS permissions do not expire on their own (see 6).
1. Can separate identities, NTFS ACLs and process isolation enforce these boundaries?
Yes, for access to files, keys and processes.
- The Microsoft Security Servicing Criteria for Windows list the user, process and session boundaries as security boundaries that Microsoft intends to service. They also list "Windows Resource Access Control" as a serviced security feature: an identity cannot access a file or named pipe unless explicitly authorized. None of this is edition-specific.
- A standard account cannot change protected Windows files or system-wide settings, and it needs administrator credentials to elevate.
- The same criteria list "Administrator to Kernel" as a non-boundary and UAC as defense-in-depth only. So these guarantees hold only while all three identities are standard accounts and the administrator credentials stay out of ALFRED's reach.
- Windows decides which identity may open which object. What counts as an "approved operation" remains NEVO's decision.
2. Simplest supported way to keep ALFRED away from NEVO's keys and protected files
Run ALFRED under its own standard local account. Keep NEVO's keys, approval records and state in one folder whose permissions grant access only to NEVO's account, SYSTEM and Administrators, with inheritance from the parent folder disabled.
- No Deny entries are needed. Access that is not explicitly allowed is implicitly denied, and new files inherit the folder's permissions.
- ALFRED's account must not own the folder, because an owner implicitly has WRITE_DAC. It also must not get access through a broad group such as Users or Everyone.
- ALFRED's account must not hold privileges that bypass permissions, such as SeDebugPrivilege, SeBackupPrivilege or SeTakeOwnershipPrivilege. A standard account does not have them by default.
Windows makes this check against the account's access token, not inside ALFRED's code. The result is the same when ALFRED's process is compromised.
3. Must the NEVO authorization component use a different identity and a separate process?
Yes, both.
- Access is evaluated per access token, and every process of an account carries a copy of that account's token. Code inside one process shares one token and one address space, so there is no boundary between Python modules.
- A separate process under the same account is not enough. Both processes reach the same files and the same DPAPI scope, and a process's default security descriptor comes from its creator's token.
- Keep ALFRED off the owner's interactive desktop as well. Window messages and hooks work between processes on the same desktop. Run ALFRED as a scheduled task or service, or in its own sign-in session.
4. Can Windows protect the HMAC secret from ALFRED while NEVO verifies approvals?
Yes. Make the secret readable by NEVO's account only: a file in the protected folder, or CryptProtectData in user scope under NEVO's account. Do not use CRYPTPROTECT_LOCAL_MACHINE, because then any user on the computer can decrypt the data.
Limitations that remain:
- Windows cannot separate "verify" from "sign" for HMAC. As you noted, whatever can verify can also sign. HMAC fits where NEVO protects its own records. For an owner approval that NEVO should check but never create, use an asymmetric signature and give NEVO only the public key.
- CNG key storage does not cover an HMAC secret. The Microsoft Software Key Storage Provider lists asymmetric algorithms only, so the secret is in NEVO's memory while it is used. An asymmetric private key can stay outside the application process, or in the TPM through the Microsoft Platform Crypto Provider.
- A non-exportable key cannot be copied, but code that runs as its owner can still use it. NEVO should not offer any function that signs data supplied by ALFRED.
- Administrators and SYSTEM can still reach the secret. BitLocker, which Pro supports, covers the offline case.
5. Restricting what ALFRED can start
- AppLocker fits best, because its rules can apply to individual users or groups, and all Windows 11 editions can enforce it. An administrator can configure it locally. Once a rule collection contains rules, only files that match an allow rule run. That gives you an allow list for ALFRED's account. The other accounts then need their own allow rules, for example through a group that ALFRED is not a member of. Prefer publisher or hash conditions. Path rules are only safe for folders that non-administrators cannot write to.
- App Control for Business is designed as a security feature under the servicing criteria, and it works on Pro. Its policies are device-wide, with no per-user rules, so it would also restrict the owner and Codex. The documented approach is App Control as the base, with AppLocker added for per-user rules.
- CMD and PowerShell: leave them out of ALFRED's allow list, or deny them for its account, if ALFRED does not need them.
- Python is the gap. The App Control documentation states that it does not control scripts run through an unenlightened script host such as Python, and that allowing such a host implicitly allows every script it runs. AppLocker has the same limit for interpreted code. Neither can stop a running interpreter from evaluating new code in its own process.
So I would design on the assumption that arbitrary Python can run as ALFRED. What protects you is that this code only has ALFRED's token, and that NEVO never runs code, module paths or commands supplied by ALFRED.
6. Temporary, narrowly scoped rights for Codex
Narrow scope: yes. Make Codex a third standard account and grant it Modify only on the code folder that the approval covers. Permission entries are per identity, so nothing carries over to ALFRED.
Temporary: only by procedure. On a standalone PC, NTFS permission entries and local group memberships have no built-in expiry. The options:
- The owner adds the entry with an administrator account and removes it afterwards. That step is also the explicit approval.
- The Codex account stays disabled, or gets an expiry date, outside approved windows.
- Codex writes only to a staging folder, and the owner copies reviewed changes into the live folder. Then only the owner's administrator account ever writes live code. This is the option I would choose.
Removing a permission does not close handles that are already open, and a signed-in session keeps its group memberships, so end Codex's session when the window closes. Also give NEVO's own account Read & Execute only on its code, so that a compromised NEVO cannot rewrite itself.
7. What still holds after a compromise
If ALFRED is compromised, the attacker has ALFRED's token and nothing more.
- Still effective: the permissions on keys, records and code, the absence of administrator rights, the separation from NEVO's process and, as defense-in-depth, the AppLocker rules.
- Not protected: every file ALFRED's account may read or change, and any request it can send to NEVO. NEVO has to treat every request as untrusted input.
If the NEVO authorization component is compromised, everything that depends on its decisions fails. The HMAC secret is exposed, approvals can be forged or skipped, and records can be rewritten.
- What remains are the limits of NEVO's own account. That is the reason to run it as a non-administrator account, not as LocalSystem.
- An owner approval signed with a private key that NEVO does not hold still cannot be forged. That helps for audit, but it does not stop a compromised NEVO from acting.
If an administrator account is compromised, none of these protections can be relied on.
8. Minimum architecture
- Four local accounts: an owner administrator account used only for administration and approvals, ALFRED (standard), the NEVO authorization component (its own standard account) and Codex (standard, no write access by default).
- Three storage areas: code and the Python runtime (administrators write, the others read and execute), NEVO's secrets and records (NEVO only), and ALFRED's working folders (explicit grants only). Nothing NEVO loads may be writable by ALFRED or Codex.
- NEVO runs as a service or scheduled task under its own account. ALFRED runs in a separate process under its account, away from the owner's desktop.
- One channel between them: a named pipe with an explicit security descriptor that lets only ALFRED's account connect. The default descriptor also gives Everyone read access. NEVO can identify the caller with ImpersonateNamedPipeClient. It can also carry out file operations requested by ALFRED under ALFRED's identity, so that Windows checks ALFRED's permissions and not NEVO's.
- AppLocker rules for ALFRED's account.
- The HMAC secret only in NEVO's store, and owner approvals as asymmetric signatures.
- BitLocker enabled and Windows kept up to date.
About "no new privileged broker": in this design the NEVO authorization component is the broker, and it must be a separate process for a boundary to exist. It does not have to be privileged, and it needs no security mechanism of its own. Windows does the enforcement. NEVO decides, and acts with its own limited account. The more of your policy you express as plain folder permissions for ALFRED, the less NEVO has to broker.
Features and their limits on Windows 11 Pro
| Feature | Limit to keep in mind |
|---|---|
| Standard local accounts | No protection from administrators. UAC is not a security boundary. |
| NTFS permissions | The owner can change them. Some privileges bypass them. |
| Windows services | Services started by the Service Control Manager receive the "Impersonate a client after authentication" right by default. If ALFRED is hosted as a service, declare its required privileges so that this right is removed, or use a scheduled task. NEVO needs the right only if it impersonates ALFRED. The service accounts article describes virtual accounts (NT SERVICE\<name>) for Windows Server only, so I would use dedicated local accounts on Pro. |
| DPAPI | User scope only. No protection while the secret is in memory, or from administrators. |
| CNG key storage, TPM | The Microsoft Software KSP stores asymmetric keys only. |
| AppLocker | Listed as defense-in-depth in the servicing criteria, with no servicing commitment. Cannot control Python scripts. |
| App Control for Business | Device-wide only. Cannot control Python scripts. |
| BitLocker | Supported on Pro. Protects data only while the device is off. |
| Win32 app isolation (AppContainer), Hyper-V | Optional stronger isolation for ALFRED. Win32 app isolation is still documented as preview. Hyper-V is available on Pro. |
| Agent workspace | Uses the same model (a separate standard account and session per agent), but it is documented as experimental. I mention it as a reference only. |
Please note that this is design guidance based on public documentation, not a security review of your implementation.
I hope this helps. If you found my response helpful or informative, I would greatly appreciate it if you could follow this guide so others with the same issue can find it.