Skip to content

Install and deploy AEMS

Applies to AEMS 1.0.8.0

This documentation describes AEMS 1.0.8.0 (service 0.1.9.0, driver 1.0.8.0, Allow-list Tool 1.3.0.0), released 2026-11-20. Install 1.0.8.0. Text marked "from 1.0.8.0" does not apply to earlier versions. Where the text says "from 1.0.6.0", it applies to 1.0.7.0 and 1.0.8.0 as well.

AEMS ships as one MSI (AEMS.msi) that contains the service and the kernel driver. This page covers a manual or silent install, deployment with Microsoft Intune or Configuration Manager, baking your allow-list into the MSI, upgrades (including the move from AEMS 1.0.5.0 or earlier), repair and uninstall.

Typical order for a new deployment:

  1. Get a license key from Logic Unknown ApS; see Licensing.
  2. Install the MSI with the key on a pilot device and approve one application (Configure).
  3. Deploy the MSI and your allow-list to the pilot ring, then to all kiosks.

Install the MSI

AEMS ships as a single MSI (AEMS.msi) containing the service (AEMSvc.exe) and the kernel driver (AEMSDriver.{inf,cat,sys}).

:: interactive
msiexec /i AEMS.msi

:: silent, for deployment tools (Intune / SCCM / your RMM)
msiexec /i AEMS.msi /qn

:: silent, with the license key (1.0.6.0 and later; see the Licensing page)
msiexec /i AEMS.msi /qn LICENSEKEY=<key>

AEMS 1.0.6.0 and later elevate only with a valid license key; see Licensing. A new installation without a key does not elevate anything: allow-listed programs start unelevated and AEMSvc logs error 3013 (missing). Only a device that ran AEMS 1.0.5.0 or earlier gets the 30-day upgrade grace.

The MSI: - installs AEMSvc.exe to C:\Program Files\AEMS\ (the driver's device can be opened by SYSTEM only; in addition the driver accepts a caller only when its image path ends in \Program Files\AEMS\AEMSvc.exe - a path check, not a signature check), - installs + registers the AEMSDriver kernel-driver service from the INF, - creates the AEMSvc service (LocalSystem, auto-start) and registers the AEMS Windows Event Log source, - seeds HKLM\SOFTWARE\Logic Unknown\AEMS with an empty Applications subkey.

Publisher: Logic Unknown ApS (logic-unknown.com). Apps and features shows that publisher and the AEMS icon; the code-signing certificate subject reads "Logic Unknown Aps". Since 1.0.6.0 the registry key is HKLM\SOFTWARE\Logic Unknown\AEMS; upgrading from 1.0.5.0 or earlier is covered in Upgrading from 1.0.5.0 or earlier.

Driver signing: on stock Windows 10/11 the driver must be signed by Microsoft to load. If the AEMSDriver service fails to start with STATUS_INVALID_IMAGE_HASH (0x241), the shipped driver wasn't Microsoft-signed - see Driver Diagnostics.

Deploy with Intune or Configuration Manager

Deploy AEMS.msi as an Intune Win32 app or as a Configuration Manager application with an MSI deployment type. AEMS installs per machine and runs as LocalSystem, so install it in the system context.

Setting Value
Install command msiexec /i AEMS.msi /qn - deliver the license key as the policy value License (Group Policy, or an Intune configuration or script that writes the registry value) or bundle it into a customer MSI (see below). msiexec /i AEMS.msi /qn LICENSEKEY=<key> also works, but puts the key in the install command.
Uninstall command msiexec /x {ProductCode} /qn with the ProductCode of the installed AEMS MSI
Install behaviour System
Device restart Normally not needed: a new installation starts the driver, and an upgrade stops the old driver and starts the new one. For an upgrade from 1.0.5.0 or earlier, restart the device once after the upgrade (see Rollout order). If AEMSvc logs 2236, 2014, 3011 or 2220 after an upgrade, the old driver is still loaded: restart the device (see Upgrade and repair). If the old driver cannot be unloaded the upgrade fails and asks for a restart. A repair can return 3010 (restart required).
Detection rule The MSI ProductCode of the AEMS version you deploy, with the MSI product version check "Greater than or equal to" that version. In a script rule or in Configuration Manager: the product version for the AEMS UpgradeCode, optionally combined with "service AEMSvc exists".

Do not use a file or registry detection rule. Do not detect AEMS with a file-exists rule (C:\Program Files\AEMS\AEMSvc.exe), with an "any AEMS product installed" rule or with a registry rule on InstallDir. After a failed upgrade such rules can be satisfied while no AEMS service runs, so the deployment would never be retried. Details are in Detection rule for the deployment.

The license key is confidential: it is not bound to a device. The MSI log masks LICENSEKEY, but Intune and other management tools store the install command and log it on the device, and process-creation auditing, Sysmon and EDR telemetry record command lines. For fleets, prefer the policy value License or a customer MSI built with Build-MsiWithSettings.cmd (provided by Logic Unknown ApS); see Where the key is visible and Apply a key.

Deploy the allow-list separately (a .reg import or a policy, see Deploy settings at scale) or bake it into the MSI (Bundle settings into the MSI).

Start every new AEMS version with a pilot ring that contains at least one kiosk of every hardware and image type before you assign it broadly.

Deploy settings at scale

  1. .reg import via your deployment tool (Intune Win32 app, SCCM package, RMM script) into the base or Policies hive. Simple and immediate.
  2. Bake the allow-list into a customer-specific MSI so a fresh install already has your policy - see Bundle settings into the MSI.

Bundle settings into the MSI

What it does: builds a customer-specific AEMS.msi with a chosen allow-list (.reg files) baked in, so a fresh install already has your policy - no separate reg import step on each endpoint.

Run the tool

Build-MsiWithSettings.cmd is provided by Logic Unknown ApS. Start it:

Build-MsiWithSettings.cmd

A window opens listing every .reg file in its Examples folder. It flags each as HKLM or HKCU (see the caveat below) and shows a preview when you click a row.

Steps

  1. Check the allow-list .reg files you want in the installer - e.g. NetworkSettings.reg, or your own apps.reg.
  2. Click Build MSI.
  3. The tool combines your selections into one settings bundle and packages it into AEMS.msi.
  4. A result box confirms success and the output path.

On install, the MSI applies the bundle with reg import (after files land, before the service starts).

Bundle a license key (optional, 1.0.6.0+)

The window has a masked License key field. When you fill it in:

  • the key is verified first with the AEMSvc.exe the MSI packages; a key that build would reject (malformed, bad signature, another product, expired) stops the build and nothing is written. Only licenses issued by Logic Unknown ApS are accepted;
  • the key is added to the bundle as REG_SZ License under HKLM\SOFTWARE\Logic Unknown\AEMS only for this build, and removed from the bundle file again afterwards (also when the build fails), so the bundle file does not keep a license. The bundle header and the console never show the key;
  • the resulting MSI carries the license: treat it as confidential.

If a run is interrupted (window closed, process ended), the key can remain in the bundle file until the tool is started again; start the tool once more, or delete the License line from the bundle file.

LICENSEKEY=<key> on the msiexec command line overrides a bundled key. See the Licensing for the license states and events.

HKLM vs HKCU - important

  • HKLM settings work perfectly. The install-time import runs as SYSTEM and writes to HKLM. The AEMS allow-list lives entirely under HKLM\SOFTWARE\Logic Unknown\AEMS, so this covers everything AEMS reads.
  • HKCU settings do NOT reach the real user. The SYSTEM import writes HKCU into SYSTEM's profile, not the installing user's. The tool flags HKCU files with a warning. AEMS itself uses no HKCU settings; ship any such file as a per-user logon script instead.

Legacy key in older .reg files

From AEMS 1.0.6.0 the configuration lives under HKLM\SOFTWARE\Logic Unknown\AEMS. A customer .reg file written for 1.0.5.0 or earlier names the legacy key HKLM\SOFTWARE\Circle Of Bytes\AEMS, which AEMS 1.0.6.0 no longer reads. The bundler handles such files for you:

  • Key lines that name exactly HKEY_LOCAL_MACHINE\SOFTWARE\Circle Of Bytes\AEMS or a key below it (also the Policies twin and [-...] delete lines) are rewritten to ...\Logic Unknown\AEMS in the bundle. Your source files are not changed; the bundle header and the result dialog list every rewrite.
  • Any other non-comment line that still names Circle Of Bytes (the bare vendor key, another product, the WOW6432Node view, value data) makes the bundler REFUSE the build; no bundle is written. Fix the file and run it again.
  • Check the rules without the GUI: powershell -NoProfile -ExecutionPolicy Bypass -File Build-MsiWithSettings.ps1 -SelfTest.

Sign the result

The bundled MSI is unsigned. Sign it with your code-signing certificate before you distribute it.

Notes

  • Editing a .reg (e.g. tailoring the allow-list in NetworkSettings.reg) before bundling is how you produce a per-customer installer.

Verify the installation

  • Confirm the AEMSvc service is Running (sc query AEMSvc) and set to auto-start.
  • Confirm the AEMSDriver driver service is Running (sc query AEMSDriver).
  • In the Application log, source AEMS, the service start shows event 1007 (driver connected) and 1008 (allow-list sent to the driver). Their absence, or an error such as 3005 or 3006, points to a driver problem - see Driver Diagnostics.
  • Launch an allow-listed app as the kiosk (non-admin) user: the original launch is caught and the app reappears running elevated, with no prompt. Confirm the elevation event 1009 under the AEMS source.

Upgrade and repair

  • To 1.0.8.0: install the AEMS 1.0.8.0 MSI over the installed version in one run (msiexec /i AEMS.msi /qn). There is no need to install an intermediate version first.
  • From 1.0.6.0 or 1.0.7.0: settings, allow-list and license are kept. The upgrade replaces driver 1.0.6.0 with driver 1.0.8.0 and loads it at once (see "Driver after an upgrade" below).
  • From 1.0.5.0 or earlier: the upgrade also moves the settings from the legacy registry key to HKLM\SOFTWARE\Logic Unknown\AEMS and, without a license key, starts the 30-day upgrade grace. Follow Upgrading from 1.0.5.0 or earlier, which applies to the 1.0.8.0 MSI as written for 1.0.6.0, and restart the device once after the upgrade.

  • Upgrade: install the newer AEMS.msi over the old one (msiexec /i AEMS.msi /qn). The old version is removed first and the new one installed; the allow-list under HKLM\SOFTWARE\Logic Unknown\AEMS\Applications is kept (from 1.0.2.0 onwards). An allow-list bundled into the new MSI is imported again on upgrade. Exception: upgrading from 1.0.1.0 removes the base allow-list (1.0.1.0's own uninstall logic) - reg export the key first if that applies.

  • Driver after an upgrade: run the MSI once. The old version's uninstall stops and unloads its driver and the new installation starts the new one, so driver 1.0.8.0 runs right after the upgrade; a restart is not needed for it. Children in place, wildcard rules and the hold of programs that finish very quickly need the new driver. If the old driver cannot be unloaded (for example a handle is held open), the upgrade fails and asks for a restart (see Upgrading from 1.0.5.0 or earlier). If the old driver is nevertheless still loaded after a completed upgrade (not expected), AEMSvc logs warning 2236 (the loaded driver does not hold caught programs) or 3011, 2014 or 2220 ("... the loaded AEMS driver ... is not the one installed with this AEMS version. Restart the device ..."): restart the device, and restart it again if the event is still logged after the restart.
  • Upgrading from 1.0.5.0 or earlier (registry move): 1.0.6.0 and later (also the 1.0.8.0 MSI) move the configuration from the legacy key HKLM\SOFTWARE\Circle Of Bytes\AEMS to HKLM\SOFTWARE\Logic Unknown\AEMS. The upgrade copies all values and the whole Applications subtree and verifies the copy. The legacy key is removed at MSI commit (or by AEMSvc after its driver handshake), never while the old driver may still protect it, and only while it still matches the fingerprint recorded at the copy; a legacy key without a pending migration is never deleted (warning 2005). On any failure it keeps the legacy key and logs an error event, so the allow-list is never lost. Upgrade the devices BEFORE you move Intune scripts or the Allow-list Tool 1.3.0.0 to the new path, and start with a pilot ring (a failing copy step leaves no AEMS on the device). Intune detection rule: the ProductCode of the MSI you deploy (1.0.8.0) with the MSI product version check >= 1.0.8.0 (or product version >= 1.0.8.0 for the AEMS UpgradeCode); never a file-exists or "any AEMS installed" rule, which a failed upgrade can satisfy without a running service, so the deployment would never be retried. Events 1011, 1012, 2005, 2006, 2007 and 3012 are new in 1.0.6.0 (see New and changed events). The legacy policy key HKLM\SOFTWARE\Policies\Circle Of Bytes\AEMS is never touched: re-target your GPO / Intune policy to HKLM\SOFTWARE\Policies\Logic Unknown\AEMS (AEMSvc logs a warning at each start while the legacy policy key still holds values). Update saved .reg files and scripts to the new path. Details, event ids and the TamperProtection case: Upgrading from 1.0.5.0 or earlier.
  • Repair (msiexec /fa AEMS.msi /qn) restores the files and registry values; it can return 3010 (restart required) because the running AEMSvc.exe / AEMSDriver.sys are replaced at the next reboot. It does not recreate services that were deleted by hand - uninstall and reinstall instead. With TamperProtection on, the 1.0.6.0 repair skips its registry write (the driver would deny it with Error 1406); see the Settings reference.

Upgrading from 1.0.5.0 or earlier

The move described here was introduced with AEMS 1.0.6.0. The AEMS 1.0.8.0 MSI does the same migration, so a device on 1.0.5.0 or earlier is upgraded directly to 1.0.8.0; where this section names the 1.0.6.0 MSI or a 1.0.6.0 device, the same applies to 1.0.8.0.

AEMS 1.0.6.0 moves the AEMS registry settings from the historical Circle Of Bytes vendor key to the Logic Unknown vendor key, in the <Vendor>\<Product> format. The MSI migrates installed devices automatically. This section describes what moves, what an administrator has to do, and what happens in the edge cases.

What moves

Use Up to 1.0.5.0 (legacy) From 1.0.6.0
Settings HKLM\SOFTWARE\Circle Of Bytes\AEMS HKLM\SOFTWARE\Logic Unknown\AEMS
Allow-list HKLM\SOFTWARE\Circle Of Bytes\AEMS\Applications\* HKLM\SOFTWARE\Logic Unknown\AEMS\Applications\*
Policy override HKLM\SOFTWARE\Policies\Circle Of Bytes\AEMS HKLM\SOFTWARE\Policies\Logic Unknown\AEMS

Unchanged: the service name AEMSvc, the event source AEMS, the install folder C:\Program Files\AEMS, the driver service AEMSDriver and device \\.\AEMS, and every value name and its meaning.

AEMS 1.0.6.0 reads ONLY the new keys. The legacy keys are not read as a fallback.

What the upgrade does

The MSI (1.0.6.0, same UpgradeCode, major upgrade) runs the migration as LocalSystem:

  1. Old product removal, first (before anything of 1.0.6.0 is installed). The 1.0.5.0 uninstall stops and deletes its service and driver and removes its files. During an upgrade it does NOT delete the settings: only its InstallDir value goes; the allow-list, LogLevel, AdminPassthrough, TamperProtection and everything else stay in the legacy key. Its driver is unloaded here, so it can no longer protect the legacy key. This holds for 1.0.2.0 to 1.0.5.0. Exception: 1.0.1.0. Its own uninstall deletes the whole legacy settings key, and it runs before the copy, so nothing is left to migrate. Before upgrading a 1.0.1.0 device, export the key (reg export "HKLM\SOFTWARE\Circle Of Bytes\AEMS" aems-legacy.reg), and after the upgrade import it again with every key line rewritten to HKLM\SOFTWARE\Logic Unknown\AEMS (or upgrade it to 1.0.5.0 first, which keeps the key, then to 1.0.6.0).
  2. Copy (right after the installer has copied its files, the installer runs the installed, signed AEMSvc.exe --migrate). When HKLM\SOFTWARE\Logic Unknown\AEMS does not exist yet and the legacy settings key does, the legacy tree is read, a marker value LegacyMigrationPending (REG_BINARY, state "copying") is written into the new key first, then every value of the legacy key and the whole Applications subtree (all subkeys, all values, exact types and bytes). The copy is read back and compared value by value, the legacy key is re-read to make sure it did not change meanwhile, TamperProtection is written last, and the marker is set to "complete". The marker holds a SHA-256 fingerprint of the legacy content that was copied and of the content the new key received. If anything fails, what this run wrote is removed again, the legacy key is left untouched, event 3012 is logged and the install aborts.
  3. New product install. The new driver service and AEMSvc service are created, the installer writes InstallDir into the new key, imports any bundled settings, and only THEN starts the new driver and the service.
  4. Removal of the legacy key, after the transaction committed (AEMSvc.exe --migrate-cleanup, run when the installation commits). The legacy key is removed only when the copy is complete and the legacy key STILL matches the fingerprint in the marker. A flag value LegacyRemovalInProgress is written into the legacy key first, then its subkeys and the key itself are deleted. Its parent HKLM\SOFTWARE\Circle Of Bytes is deleted only when it is then completely empty (other products may live there). Event 1012.
  5. If the install fails after step 1, the rollback removes what 1.0.6.0 created: it stops and deletes the new AEMSvc and AEMSDriver services, and the rollback deletes the new settings key again while it is still an unmodified copy of the legacy key. The device is then left WITHOUT an AEMS product (Add/Remove Programs and ProductCode detection report "not installed", so Intune or ConfigMgr retry), with the legacy key intact. Reboot and run the AEMS MSI again. AEMS is not running until then.

Why the old product is removed first: none of the 1.0.x MSIs can restore its own services and driver registration when a removal is rolled back. Removing it inside the 1.0.6.0 transaction would turn a late failure into a 1.0.5.0 that Add/Remove Programs reports as installed but that has no service and no driver, which no deployment tool would repair.

Reading a verbose MSI log (msiexec /i AEMS.msi /qn /l*vx upgrade.log). After a failed upgrade (exit code 1603) search the log for these action names; the step that logged "Return value 3" is the one that failed:

Step Action name in the MSI log
Check that the previous driver is not still loaded and marked for deletion ("Restart the computer" message) AppSearch (registry search AemsDriverDeleteFlagSearch) and the launch conditions
Old product removal, first RemoveExistingProducts, right after InstallValidate
Copy of the legacy settings MigrateLegacySettings, or MigrateLegacySettingsMerge when the new key existed before the upgrade
Rollback of that copy RollbackMigrateLegacySettings
Driver package and driver service InstallDriver, CreateDriverService (error 1072 here = the old driver is still marked for deletion: reboot, then run the MSI again)
AEMSvc service InstallService, SetAemsvcDependency
Bundled settings and license key ImportBundledSettings, WriteLicenseKey (only with LICENSEKEY; the key itself is not logged)
Start of the driver and the service StartDriverService, StartAemsService
Removal of the legacy key at commit CleanupLegacySettings

The undo steps of a rollback have the same names with the prefix Rollback (for example RollbackCreateDriverService, RollbackInstallService).

The migration is idempotent: when the new key already holds a complete copy nothing is copied again, and a device without a legacy key (fresh install) is a no-op.

The marker and the fingerprint

The legacy key is never removed because of the marker alone. Every run compares the legacy key with the fingerprint recorded at the copy:

Situation at a later run What happens
Legacy key unchanged since the copy Removal proceeds (MSI commit, or AEMSvc after its driver handshake).
Legacy key changed (for example a failed upgrade, then further edits under the old path), new key still holds only the migrated content (InstallDir ignored) The new key is refreshed from the legacy key (InstallDir kept), event 1011 "the unmodified copy was refreshed". Only the MSI copy step and AEMSvc after its driver handshake (outside an installer transaction) refresh; the MSI commit step leaves it to them.
Legacy key changed AND the new key changed too Nothing is copied or removed. Warning 2005 explains; AEMS keeps using the new key. Move what you still need from the legacy key, then delete it by hand.
A removal was interrupted (LegacyRemovalInProgress in the legacy key) The removal continues; the missing parts are not treated as an edit.
Marker still "copying" (an earlier copy could not finish or could not be undone) The copy is verified again: when only TamperProtection is missing it is written now; otherwise the MSI copy step or AEMSvc after its handshake copies again. The legacy key is not removed before that.
Marker of an unknown format Nothing is removed; warning 2005.

A new key that existed before the upgrade (merge)

If something created HKLM\SOFTWARE\Logic Unknown\AEMS while the device still ran 1.0.5.0 (an Intune script moved to the new path too early, AEMSAllowlist.exe 1.3.0.0 --apply), the MSI merges instead of skipping the migration: it runs AEMSvc.exe --migrate --merge-into-existing when AppSearch, which runs before the old product is removed, found no InstallDir in the new key (property AEMSNEWKEYINSTALLDIR empty: no 1.0.6.0 install ever completed on the device). Because that is device state, not "an old product is installed", a retry after a failed first attempt (old product already removed) merges as well, and an upgrade from 1.0.6.0 to a later version (InstallDir present before the old removal) never merges a stale legacy key. A new key that has neither InstallDir nor a marker receives every legacy value and every Applications\<entry> it does not have yet; whatever the new key already holds wins (an entry is taken whole or not at all). Event 1011 lists what was kept from the new key, for example 2 items kept from the new key: LogLevel, Applications\Notepad. The merge is verified like a copy and the legacy key is then removed like after a copy. AEMSvc itself never merges, and the MSI never merges into a key that has InstallDir (an installed 1.0.6.0).

Safety net at service start

AEMSvc 0.1.7.0 and later repeat the migration at every start:

  • Before its first configuration read: new key missing and legacy key present -> copy (event 1011, or 3012 on failure). This covers devices where the files were replaced by hand instead of through the MSI. It also completes a "copying" marker when only TamperProtection is missing.
  • After its driver handshake (the registered service process is exempt from the driver's registry protection): refresh an unmodified copy whose legacy key changed, and remove a pending legacy key (event 1012), unless a Windows Installer transaction is running (the MSI's own steps then do it). A legacy key that cannot be removed stays in place and is retried at the next start (event 2005). A legacy key that exists next to the new key WITHOUT the marker is never deleted by AEMS; event 2005 asks the administrator to move whatever still writes it.

What an administrator must do

Rollout order

  1. Pilot ring first. Assign the AEMS MSI (1.0.8.0) to a small pilot group before broad assignment, including at least one kiosk of every hardware/image type, one with TamperProtection=1, one with a WDAC or AppLocker policy and one with pre-written new-path settings, and check events 1011/1012/3012/2005/2007 there. A systematic failure of the copy step (for example a blocked AEMSvc.exe or an unreadable legacy subkey) aborts the install AFTER the old product was removed, so it would leave NO AEMS on every targeted device.
  2. Upgrade the devices first: run the AEMS 1.0.8.0 MSI once (msiexec /i AEMS.msi /qn, optionally with LICENSEKEY=<key>), then restart the device. After the restart, events 1007 and 1008 must appear and 3011, 2014, 2220 and 2236 must not; a device without a key shows the upgrade grace (2010, and --license-status reports UpgradeGrace).
  3. Only then move anything that writes AEMS settings (Intune remediation and platform scripts, configuration profiles, .reg files, AEMSAllowlist.exe 1.3.0.0) to the new path, scoped to devices that run 1.0.6.0 or later (for example by the MSI ProductVersion, or by the presence of InstallDir in HKLM\SOFTWARE\Logic Unknown\AEMS). During the transition it is safe to write BOTH paths.

A device on 1.0.5.0 reads only the legacy key; a 1.0.6.0 device only the new one. If a writer reaches a 1.0.5.0 device early, the upgrade merges (see above), so nothing is lost, but the 1.0.5.0 device ignores the new key until it is upgraded.

Group Policy (or any other policy source)

The legacy policy key HKLM\SOFTWARE\Policies\Circle Of Bytes\AEMS is GPO-owned. AEMS never reads, changes or deletes it. AEMS 1.0.6.0 ignores it; its settings no longer apply.

  1. In the GPO (Group Policy Preferences registry items, or an ADMX/ADML you maintain), change the key path from SOFTWARE\Policies\Circle Of Bytes\AEMS to SOFTWARE\Policies\Logic Unknown\AEMS. Value names and data stay the same; the Applications subtree moves the same way.
  2. Remove the old registry items from the GPO (with "Remove this item when it is no longer applied" or a delete action) so the legacy policy key disappears from the clients.
  3. Check a client after gpupdate /force: reg query "HKLM\SOFTWARE\Policies\Logic Unknown\AEMS" /s.

While the legacy policy key still holds any value or subkey, AEMSvc logs warning 2006 at every service start.

Do the GPO change together with (or right after) the 1.0.6.0 rollout: a 1.0.5.0 device reads only the legacy policy key, a 1.0.6.0 device only the new one. Deploying both paths during the transition is safe.

Detection rule for the deployment

Use the MSI you deploy (AEMS 1.0.8.0), so that devices still on 1.0.5.0, 1.0.6.0 or 1.0.7.0 are updated. Use one of these for the Intune Win32 app (or the ConfigMgr deployment type):

  • MSI ProductCode of the 1.0.8.0 package (Intune Win32 app: detection rule type "MSI", the ProductCode from the MSI's Property table; tick "MSI product version check", "Greater than or equal to" 1.0.8.0), or
  • product version >= 1.0.8.0 for UpgradeCode {7F3C1A28-9D6B-4E51-AE2C-5B0E9A1F7C34} in a script rule or ConfigMgr (for example Windows Installer RelatedProducts of that UpgradeCode, then ProductVersion of the product found), optionally combined with "service AEMSvc exists".

Do NOT use a file-exists rule (C:\Program Files\AEMS\AEMSvc.exe), an "any AEMS product installed" / UpgradeCode-only rule or a registry rule on InstallDir: after a failed upgrade (old driver stuck, see the TamperProtection caveats) 1.0.5.0 can stay listed with its files restored while no AEMS service runs, and such rules are satisfied, so the deployment is never retried.

Intune, scripts, detection rules, .reg files

Anything that writes or reads HKLM\SOFTWARE\Circle Of Bytes\AEMS must move to HKLM\SOFTWARE\Logic Unknown\AEMS (in the order above): Intune remediation or platform scripts, Win32-app detection rules, configuration profiles (OMA-URI registry writes), allow-list .reg files, monitoring checks. Writes to the legacy key after the upgrade are ignored (warning 2005), and the legacy key is removed at the end of the upgrade.

  • The AEMS Allow-list Tool 1.3.0.0 (the tool version for AEMS 1.0.6.0) writes the new path.
  • Build-MsiWithSettings.cmd (customer MSI bundling, provided by Logic Unknown ApS) rewrites key lines that name exactly ...\Circle Of Bytes\AEMS or ...\Circle Of Bytes\AEMS\... (also the Policies twin) to the new key in the bundle, and refuses to build when a selected file still names Circle Of Bytes anywhere else outside a comment (the bare vendor key, another product, the WOW6432Node view, value data). Check without the GUI: powershell -NoProfile -ExecutionPolicy Bypass -File Build-MsiWithSettings.ps1 -SelfTest.

Kiosks with WDAC or AppLocker

The migration runs C:\Program Files\AEMS\AEMSvc.exe, the same signed file the service runs (signed by Logic Unknown Aps); nothing is extracted to and run from C:\Windows\Installer or a temp folder. A policy that admits AEMSvc therefore admits the migration. pnputil, sc.exe, reg.exe and powershell.exe from System32 are run as before. Test on one device first.

TamperProtection and the old driver

TamperProtection (REG_DWORD, settings key) makes the AEMS driver deny registry changes under the protected key to every process except the registered AEMSvc.

Driver Protected key Flag read from
1.0.5.0 and older (protocol 0x00020000) the WHOLE HKLM\SOFTWARE\Circle Of Bytes vendor key HKLM\SOFTWARE\Circle Of Bytes\AEMS
1.0.6.0 (driver 1.0.6.0, protocol 0x00020003) exactly HKLM\SOFTWARE\Logic Unknown\AEMS and its subkeys (component boundary: ...\Logic Unknown\<other product>, ...\Logic Unknown\AEMSx and the vendor key itself are NOT protected) HKLM\SOFTWARE\Logic Unknown\AEMS

The new driver also lets KeySetHandleTagsInformation through (the fix for registry opens with a 32-bit or 64-bit view flag), so reads with KEY_WOW64_64KEY / KEY_WOW64_32KEY (reg.exe /reg:64, .NET Registry64, MSI RegistrySearch Win64, Intune detection rules) work under TamperProtection. When AEMSvc 0.1.7.0 or later finds an older driver loaded it logs warning 2007 at every start, because TamperProtection then has no effect on the new key.

What happens on a device with TamperProtection=1 during the upgrade:

  1. The old product removal stops and deletes the old driver before anything of 1.0.6.0 runs. If the old driver cannot be unloaded (stuck handle) it stays loaded, marked for deletion; the copy still works (reading the legacy key is allowed and the new key is outside the old driver's prefix), but creating the new driver service then fails (1072) and the install rolls back: no AEMS product, legacy key intact. Reboot and run the upgrade again (until the reboot the launch condition below refuses the retry). With TamperProtection=1 the old uninstall usually fails earlier, see the caveat on the old product's own uninstall below.
  2. The copy writes TamperProtection last, after the read-back check.
  3. The new driver is started only after every installer write to the new key (the installer's own registry values and the bundled settings it imports); a migrated TamperProtection=1 therefore cannot make the new driver deny the installer's own writes.
  4. The legacy key is removed at commit. The new driver does not protect the legacy path, so the removal succeeds. The commit step is not the registered service, so its delete of the marker value in the (now protected) new key is denied: the marker stays until the next AEMSvc start, normally the next reboot, which removes it without an event. This is expected.
  5. If the removal of the legacy key is denied for any other reason, the legacy key and the marker stay, nothing is lost (the verified copy is in the new key), event 2005 is logged, and AEMSvc retries after its next driver handshake, as the registered (exempt) process.

The allow-list is never deleted before a verified copy exists, and never while the legacy key differs from what was copied. (Upgrades from 1.0.1.0 are the exception: that version's own uninstall deletes the legacy key before the copy, see step 1 of "What the upgrade does".)

Caveats:

  • Rollback disabled. With the DisableRollback machine policy or DISABLEROLLBACK=1, Windows Installer runs neither rollback nor commit actions. The legacy key and the marker then stay after the upgrade; AEMSvc removes the legacy key at its next start outside an installer transaction (the start right after the install happens while the installer still runs and leaves it), and a failed install is not cleaned up.
  • Repair with TamperProtection=1. A repair (msiexec /fa, ARP Repair, REINSTALL=ALL) would have to rewrite InstallDir under the protected key (Error 1406, repair rolled back). The 1.0.6.0 MSI skips its registry write during a repair while TamperProtection is non-zero (found by AppSearch); files are still repaired. To let a repair restore a deleted InstallDir or Applications key, set TamperProtection to 0 first.
  • Uninstall with TamperProtection=1: the uninstall stops the driver before it removes the settings key. If the driver cannot be unloaded, the key removal is denied and the key stays; delete it after a reboot.
  • The old product's own uninstall with TamperProtection=1 and a stuck old driver (the old product's own script, not fixable from 1.0.6.0): if the 1.0.5.0 driver cannot be unloaded, it still protects the whole legacy vendor key and denies the old uninstall's own delete of InstallDir. The old uninstall then fails and rolls back, and the AEMS install stops before it changes anything. The settings are safe (the legacy key is untouched), but 1.0.5.0 stays listed in Add/Remove Programs while its AEMSvc service is already removed (that step cannot be rolled back) and its driver is marked for deletion: AEMS does not run until the device reboots and the AEMS MSI runs again. A detection rule on the deployed MSI's ProductCode or version (below) reports "not installed" and retries.
  • "Restart first" launch condition. The SCM writes DeleteFlag=1 into a service's key when the service is deleted while it is still loaded; the key and the flag go away at the next boot. The 1.0.6.0 MSI reads HKLM\SYSTEM\CurrentControlSet\Services\AEMSDriver, value DeleteFlag (before anything is removed) and refuses to start while it is non-zero: "The AEMS driver from the previous installation is still loaded and is marked for deletion. Restart the computer, then run this installation again." (exit 1603 in /qn). A retry before the reboot therefore fails at once instead of tearing down again. The flag is SCM behaviour, not a documented API contract; if it is ever missing the install still fails safely (error 1072 when the new driver service is created, rolled back), and a stale value cannot outlive a reboot.

License key and upgrade grace

AEMS 1.0.6.0 is also the first licensed version (see Licensing). Without a valid license key it does not elevate. Devices that ran 1.0.5.0 or earlier get a one-time upgrade grace of 30 days, so the upgrade itself never stops elevation:

  1. Evidence of an upgrade is a COMPLETED settings migration: the new key holds the marker LegacyMigrationPending in state complete (copy or merge) and the legacy tree it recorded was not empty. That marker exists between the copy step and the removal of the legacy key, which is exactly when the grace marker is written. A legacy key that merely exists is not evidence: an empty legacy key that the copy step copies, or a legacy key next to an installed 1.0.6.0 (no copy, no marker), gives no grace.
  2. After a successful MSI copy step (AEMSvc.exe --migrate, right after the files are installed; copy or merge) that evidence is checked and, when present, REG_SZ LicenseUpgradeGraceStartUtc = the current UTC time is written into HKLM\SOFTWARE\Logic Unknown\AEMS, once, with event 1015 naming the end date. This happens before the new driver starts, so a migrated TamperProtection=1 cannot deny it. An existing marker is never overwritten.
  3. AEMSvc repeats this at its start (safety net, for example after a manual file replacement): after its own copy step it checks the evidence and writes the marker into the existing key (never creating the key: the copy must create it itself), and, when TamperProtection=1 denied that write, again right after its driver handshake (the evidence seen before the handshake is kept, because the handshake step removes the legacy key and the marker).
  4. For 30 days AEMS keeps elevating without a license (state UpgradeGrace, warning 2010 every day naming the end date). Apply a license key within that time: type aems-license.txt | "C:\Program Files\AEMS\AEMSvc.exe" --set-license, the MSI property LICENSEKEY on the upgrade itself (msiexec /i AEMS.msi /qn LICENSEKEY=<key>), or the policy value License in HKLM\SOFTWARE\Policies\Logic Unknown\AEMS.

A standard user cannot write or delete the marker (HKLM). With TamperProtection=1 the driver of AEMS 1.0.6.0 denies changes to it to everyone but AEMSvc. Licensing is enforced against standard users; it relies on administrators not tampering with the device.

Ordering: the grace marker is always written BEFORE the legacy key and the migration marker are removed (they are the evidence), and the removal is held back until it is written. This matters when AEMSvc itself does the copy with TamperProtection=1 and the driver of AEMS 1.0.6.0 loaded: the copy then cannot finalise its migration marker and the grace write is denied until the driver handshake; right after the handshake AEMSvc writes the grace marker first and only then removes the legacy key. A crash at any point neither loses the grace nor grants it twice. A legacy key with any value (for example InstallDir) or any subkey (also an empty Applications key) counts as an upgrade; a completely empty one does not.

Rollout note: plan the license keys with the upgrade. A fresh 1.0.6.0 install has no grace, and an upgraded device stops elevating 30 days after its upgrade unless a key was applied.

Wildcard path rules need the new driver

AEMS 1.0.6.0 adds wildcard path rules (DataPath with * or ?, plus the new values Publisher and PublisherThumbprint; see Wildcard path rules). The matching happens in the driver, so wildcard rules work only with driver 1.0.3.0 or later (protocol 0x00020002 or later; AEMS 1.0.6.0 ships driver 1.0.6.0, protocol 0x00020003). The upgrade normally unloads the old driver (the old version's uninstall stops it) and starts the new one, so the new driver runs right after the upgrade. If the old driver cannot be unloaded, the upgrade fails and asks for a restart (see "TamperProtection and the old driver"). If the old driver is nevertheless still loaded after an upgrade:

  • AEMSvc 0.1.7.0 and later do not send wildcard rules to it and logs warning 2014 once at start ("wildcard rules are inactive until the driver is updated"); exact entries keep working;
  • reboot the device; the wildcard rules become active without any other step.

Two behaviour changes in 1.0.6.0 that also affect existing exact entries:

  • an entry whose HashSHA is not exactly 64 hex digits (or whose PublisherThumbprint is not 40 hex digits) logs warning 2012 at service start and refuses every launch it matches (2013 [MalformedRule]; administrators: 2016); an entry with an empty DataPath is dropped (2012). Check the event log after the upgrade, correct such entries and restart the AEMSvc service;
  • when the driver catches a launch for a standard user but AEMSvc finds no matching entry, the program is no longer elevated: it keeps running unelevated (warning 2003, then 2004).

Do not deploy wildcard rules to devices that still run 1.0.5.0 or earlier: AEMSvc 0.1.4.0 and earlier read only the legacy key, and even a hand-written legacy entry would be treated as a literal path that never matches; Publisher and PublisherThumbprint are ignored there, so an exact entry that relies on them for its identity check is NOT checked on an old version. Use AEMSAllowlist.exe 1.3.0.0 (or the example file WildcardRules.reg) only after the device runs 1.0.6.0.

Example file WildcardRules.reg (provided by Logic Unknown ApS)
Windows Registry Editor Version 5.00

; ============================================================================
; WildcardRules.reg
;
; Example AEMS wildcard path rules (AEMS 1.0.6.0 and later).
; Publisher: Logic Unknown ApS - https://logic-unknown.com
; Documentation: https://docs.logic-unknown.com/aems/
;
; A wildcard rule approves an executable by a path PATTERN instead of one exact
; path. An entry is a wildcard rule when DataPath contains * or ?.
;   ?  matches exactly one character that is not a backslash
;   *  matches zero or more characters that are not a backslash
;   Wildcards never cross a folder boundary; the pattern must match the WHOLE
;   path (case-insensitive).
;
; Rules (an entry that breaks one is rejected at service start, with a warning):
;   - local path X:\... with a literal drive letter (no UNC, \\?\ or devices)
;   - the drive and the first folder are literal; no file directly in X:\
;   - no / " < > |, control characters or a second colon; no empty, . or ..
;     folder component
;   - the file name ends with the literal .exe
;   - at most 251 characters (refused, never truncated)
;   - Publisher or HashSHA is set, and GlobalApplication = 1
; A malformed HashSHA (not 64 hex digits) or PublisherThumbprint (not 40 hex
; digits) does not drop the entry: it is kept as a refusing entry (warning
; 2012) and every launch it matches is refused (2013 [MalformedRule]).
; Use a folder under C:\Program Files: a new folder directly in the drive root
; (for example C:\Tools) normally lets users write and fails the check below.
;
; At launch AEMS elevates a matching file only when BOTH guards pass:
;   1. trusted location: a fixed drive on an accepted storage bus (removable
;      media and USB, FireWire, SD/eMMC, iSCSI, Fibre Channel and mounted
;      virtual disks are refused; the check is by bus, so an external NVMe or
;      eSATA enclosure is NOT detected - use the system drive) with a global
;      drive letter
;      (a drive letter created or redirected for one user, for example with
;      subst or a mapped drive, is refused), no junction/symbolic link in the
;      path, the file and every folder above it owned by and writable only by
;      Administrators, SYSTEM or TrustedInstaller;
;   2. identity: valid EMBEDDED Authenticode signature whose leaf certificate
;      CN equals Publisher (and SHA-1 thumbprint equals PublisherThumbprint
;      when set), and/or SHA-256 equals HashSHA.
; Otherwise the program runs unelevated and AEMS logs a warning with the
; reason. Elevation happens when a user launches the file, never when a file
; merely appears in the folder.
;
; New per-app values:
;   Publisher            REG_SZ - leaf certificate CN of the embedded signature
;   PublisherThumbprint  REG_SZ - optional SHA-1 thumbprint (40 hex) of that
;                                 certificate, checked in addition to Publisher
;
; Requires the AEMS 1.0.6.0 driver (protocol 0x00020002), started by the
; upgrade (reboot if warning 2014 says the old driver is still loaded). Contoso and Fabrikam are placeholder vendors: replace the
; paths, the publisher names and the thumbprint with the real values
; (Get-AuthenticodeSignature, or "Read from file..." in AEMSAllowlist.exe).
;
; Apply (elevated):   reg import WildcardRules.reg
;                     Restart-Service AEMSvc
; Details: https://docs.logic-unknown.com/aems/configure/ (Wildcard path rules).
; ============================================================================

; Example 1 - a vendor setup program with a changing version in the file name,
; pinned by publisher. Matches C:\Program Files\Contoso\Tools\setup_2.4.1.exe
; and setup_x64.exe; does not match C:\Program Files\Contoso\Tools\old\setup_1.exe.
[HKEY_LOCAL_MACHINE\SOFTWARE\Logic Unknown\AEMS\Applications\Contoso setup]
"FriendlyName"="Contoso setup (any version)"
"DataPath"="C:\\Program Files\\Contoso\\Tools\\setup_*.exe"
"Publisher"="Contoso Ltd"
"GlobalApplication"=dword:00000001

; Example 2 - one program in a versioned folder, pinned by publisher and
; certificate thumbprint. Matches ...\Console 7.2\console.exe and
; ...\Console 8.0\console.exe; not ...\Console 10.1\console.exe (? is exactly
; one character). The thumbprint changes when the vendor renews its
; certificate; leave PublisherThumbprint out to survive renewals.
[HKEY_LOCAL_MACHINE\SOFTWARE\Logic Unknown\AEMS\Applications\Fabrikam console]
"FriendlyName"="Fabrikam console"
"DataPath"="C:\\Program Files\\Fabrikam\\Console ?.?\\console.exe"
"Publisher"="Fabrikam, Inc."
"PublisherThumbprint"="0123456789ABCDEF0123456789ABCDEF01234567"
"GlobalApplication"=dword:00000001

; ----------------------------------------------------------------------------
; Example 3 (commented out) - a file that is only catalog-signed or unsigned
; cannot satisfy Publisher; pin its SHA-256 instead. The rule then elevates
; only files with exactly this content.
; ----------------------------------------------------------------------------
;[HKEY_LOCAL_MACHINE\SOFTWARE\Logic Unknown\AEMS\Applications\Contoso updater]
;"FriendlyName"="Contoso updater"
;"DataPath"="C:\\Program Files\\Contoso\\Updater\\update*.exe"
;"HashSHA"="0000000000000000000000000000000000000000000000000000000000000000"
;"GlobalApplication"=dword:00000001

; ----------------------------------------------------------------------------
; To remove these entries:
;   reg delete "HKLM\SOFTWARE\Logic Unknown\AEMS\Applications\Contoso setup" /f
;   reg delete "HKLM\SOFTWARE\Logic Unknown\AEMS\Applications\Fabrikam console" /f
; ----------------------------------------------------------------------------

New and changed events

The licensing events (1013, 1014, 1015, 2008, 2009, 2010, 2011, 2015, 3013, 3014) are listed in the Licensing events table.

Id Level When Text
1011 Information The legacy settings key was copied to the new key (MSI copy step, or service start safety net) Settings migration: migrated (<n> keys, <m> values copied from HKLM\SOFTWARE\Circle Of Bytes\AEMS to HKLM\SOFTWARE\Logic Unknown\AEMS, verified); legacy key kept, removal pending. (the tail reads legacy key removed when the copy and the removal happened in one service start)
1011 Information An unmodified copy was refreshed because the legacy key changed after it Settings migration: migrated (the legacy key changed after the earlier copy, the unmodified copy was refreshed: <n> keys, <m> values copied from ... to ..., verified); ...
1011 Information Merge into a new key that existed before the upgrade (MSI only) Settings migration: migrated (merged into the existing HKLM\SOFTWARE\Logic Unknown\AEMS: <n> keys and <m> values added from HKLM\SOFTWARE\Circle Of Bytes\AEMS, verified; <k> items kept from the new key: <names>); legacy key kept, removal pending.
1012 Information The legacy settings key was removed after a verified copy Settings migration: already migrated; legacy key removed. or ... legacy key removed (and the then-empty HKLM\SOFTWARE\Circle Of Bytes).
2005 Warning The legacy settings key could not be removed The legacy settings key HKLM\SOFTWARE\Circle Of Bytes\AEMS could not be removed (error <n>). It is ignored: AEMS reads only HKLM\SOFTWARE\Logic Unknown\AEMS. The removal is retried at the next service start. (from the MSI commit step: Settings migration: ...; legacy key could NOT be removed (error <n>), it is kept and ignored. The service retries the removal at its next start.)
2005 Warning A legacy settings key exists next to the new key without a pending migration (something still writes the old path) The legacy settings key HKLM\SOFTWARE\Circle Of Bytes\AEMS exists next to HKLM\SOFTWARE\Logic Unknown\AEMS and is ignored: AEMS 1.0.6.0 and later read only the new key. Move anything that still writes to the old path (scripts, Intune, .reg files) to the new path, then delete the old key.
2005 Warning The legacy key changed after the copy and the new key changed too (or after a merge) The legacy settings key ... changed after it was copied to ..., and ... was changed too. Both are kept and nothing is removed; AEMS reads only .... Move the changes you still want from the legacy key into the new key, then delete the legacy key by hand. (merge: ... changed after it was merged into ...)
2005 Warning A refresh is needed but not done by this step, or was denied ... which still holds only the copied content. The new key is refreshed from the legacy key by the next MSI copy step or by AEMSvc after its driver handshake ... / ... refreshing the new key was denied (error <n>; with TamperProtection=1 only the registered AEMSvc may change it) ...
2005 Warning A copy whose marker still says "copying" cannot be completed here; TamperProtection could not be completed; unknown marker format; legacy key unreadable The copy of ... in ... was never verified (its marker still says 'copying'). The legacy key is kept. ... / ... TamperProtection could not be completed in ... (error <n>) ... / ... the migration marker LegacyMigrationPending in ... has an unknown format ... / ... could not be read to check it against the migration marker (error <n>) ...
2006 Warning Every service start while the legacy policy key holds any value or subkey The legacy policy key HKLM\SOFTWARE\Policies\Circle Of Bytes\AEMS holds settings, but AEMS 1.0.6.0 and later read policy only from HKLM\SOFTWARE\Policies\Logic Unknown\AEMS. The old policy is IGNORED. Move the GPO (or other policy source) to the new path; AEMS never changes or deletes policy keys.
2007 Warning Every service start while the loaded driver is older than 1.0.3.0 (protocol minor 0) The loaded AEMS driver speaks protocol 0x00020000; this AEMSvc 0.1.9 expects minor 1 (driver 1.0.3.0 or later). That older driver protects and reads TamperProtection from the pre-1.0.6.0 settings key, not from HKLM\SOFTWARE\Logic Unknown\AEMS, and lacks the fix that lets registry opens with a 32-bit or 64-bit view flag pass under TamperProtection: TamperProtection is NOT enforced[ although TamperProtection=1 is set in the new key]. Elevation works. Install an AEMS MSI that ships driver 1.0.3.0 or later.
3012 Error The copy, refresh or merge failed Migration of HKLM\SOFTWARE\Circle Of Bytes\AEMS to HKLM\SOFTWARE\Logic Unknown\AEMS FAILED at step '<step>' (error <n>). followed by exactly one of: Nothing was changed; the legacy key is untouched. / What this run wrote to the new key was removed again; the legacy key is untouched. / What this run wrote to the new key could NOT be removed again (error <n>). [The new key holds a verified copy of everything except TamperProtection.] It keeps its migration marker in state 'copying', so it is not treated as a completed migration and the legacy key is not removed; the next MSI copy step or AEMSvc start completes or redoes the copy. The legacy key is untouched.
2000 Warning changed text Config key HKLM\SOFTWARE\Logic Unknown\AEMS not found; running with defaults. or Config key HKLM\SOFTWARE\Logic Unknown\AEMS could not be opened (error <n>); running with defaults.
1002 Information changed text (registry view-flag fix) When the first configuration read found no key or failed to open it, AEMSvc reads again once after its driver registration and logs AEMSvc 0.1.9 config loaded (reloaded after the driver registration): .... In that case 2000/2001/1002 are logged after event 1007 instead of before it.

Uninstall and downgrade

  • A real uninstall (from 1.0.6.0) removes HKLM\SOFTWARE\Logic Unknown\AEMS and any leftover HKLM\SOFTWARE\Circle Of Bytes\AEMS, then HKLM\SOFTWARE\Logic Unknown and HKLM\SOFTWARE\Circle Of Bytes only when they are completely empty (other Logic Unknown products can live there). Policies keys are never touched.
  • A downgrade over 1.0.6.0 is blocked by the MSI. To go back to 1.0.5.0, export the allow-list (reg export "HKLM\SOFTWARE\Logic Unknown\AEMS" aems.reg), uninstall 1.0.6.0, install 1.0.5.0 and import the file after replacing Logic Unknown with Circle Of Bytes in its key lines.

Uninstall

msiexec /x AEMS.msi /qn

Uninstall stops and deletes the AEMSvc service and removes its event source (AEMSvc.exe --uninstall), stops and deletes the AEMSDriver driver service, removes the driver package from the driver store, and removes the HKLM\SOFTWARE\Logic Unknown\AEMS subtree (including the allow-list) plus any leftover legacy key from 1.0.5.0 or earlier. The Policies hive is GPO-owned and is not removed. Other Logic Unknown products under HKLM\SOFTWARE\Logic Unknown are kept. What stays afterwards: the AEMS entries in the Application log. On a device that ran on a Windows build newer than the validated ones, the uninstall of 1.0.8.0 also removes the empty key HKLM\SOFTWARE\Logic Unknown\AEMS-DriverBindGuard (and then the Logic Unknown vendor key when nothing else is in it); the key stays when it holds the value BindAttemptBuild (see the guard key after an uninstall). The uninstall of 1.0.7.0 or earlier leaves the empty key; it is harmless and may be deleted. If TamperProtection is set, read the uninstall caveat in the Settings reference.