Özel Çözüm: Endpoint Central ile Veri Güvenliği İçin Acil Bilgisayar İzolasyonu

<#
.SYNOPSIS
Techaptic - Endpoint Central Emergency Lockdown Script (V1.4.0)

.DESCRIPTION
This Techaptic script applies reversible emergency access restrictions to a Windows endpoint
through ManageEngine Endpoint Central. It is designed to run as SYSTEM and supports four
operator scenarios: one specified account, multiple specified accounts, all human accounts,
or all human accounts except one strictly verified Windows LAPS recovery account.

The script stores rollback data and detailed verification evidence in the protected local state
file. Endpoint Central Remarks contains only the compact operational result.

.PARAMETER TargetUsers
Required target definition.

Supported examples:
"DOMAIN\user1"
"DOMAIN\user1;COMPUTER\localuser"
"ALL"

.PARAMETER SaveLaps
Valid only with -TargetUsers "ALL". Preserves one verified Windows LAPS local administrator as
the recovery identity. If the LAPS identity cannot be safely verified, the script stops before
applying security changes.

.EXAMPLE
.\Techaptic-EPC-EmergencyLockdown-v1.4.0.ps1 -TargetUsers "DOMAIN\user1"

.EXAMPLE
.\Techaptic-EPC-EmergencyLockdown-v1.4.0.ps1 -TargetUsers "DOMAIN\user1;COMPUTER\localuser"

.EXAMPLE
.\Techaptic-EPC-EmergencyLockdown-v1.4.0.ps1 -TargetUsers "ALL"

.EXAMPLE
.\Techaptic-EPC-EmergencyLockdown-v1.4.0.ps1 -TargetUsers "ALL" -SaveLaps

.NOTES
Author : Techaptic
Maintainer : Techaptic
Script : Endpoint Central Emergency Lockdown
Version : 1.4.0
Execution : Endpoint Central Computer Configuration / Run as SYSTEM
State File : C:\ProgramData\EmergencyLockdown\EmergencyLockdown.json

IMPORTANT SAFETY NOTES:
- This is a disruptive emergency-control script. Depending on scope, it can block console,
RDP, network, cached-domain, and online-domain access and will initiate sign-out/restart.
- Validate the complete Lockdown and Restore cycle in a representative test environment before
any production use.
- Keep the matching Techaptic Restore script available and confirm Endpoint Central agent
delivery before applying Lockdown.
- "ALL" without -SaveLaps may leave the Endpoint Central agent as the only planned remote
recovery path.
- "ALL" with -SaveLaps must be used only after the managed LAPS account and its current password
have been independently verified.
- Do not delete, rename, or manually edit the protected state file while Lockdown is active.
- Do not modify embedded Base64 components, internal task names, firewall identifiers, state
paths, or rollback logic unless the complete test matrix is repeated.
- Customer change approval, backup, rollback, access-control, and production validation
procedures remain mandatory.
#>
[CmdletBinding()]
param(
[Parameter(Mandatory = $false)]
[AllowEmptyString()]
[string]$TargetUsers,

[Parameter(Mandatory = $false)]
[switch]$SaveLaps
)

Set-StrictMode -Version 2.0
$ErrorActionPreference = 'Stop'
$ProgressPreference = 'SilentlyContinue'

$ScriptVersion = '1.4.0'
$BaseDirectory = Join-Path $env:ProgramData 'EmergencyLockdown'
$StatePath = Join-Path $BaseDirectory 'EmergencyLockdown.json'
$TemporaryStatePath = Join-Path $BaseDirectory 'EmergencyLockdown.tmp'
$FirewallRuleGroup = 'EmergencyLockdown'
$FirewallRulePrefix = 'EmergencyLockdown-ADAuth'
$RebootDelaySeconds = 60
$PostBootVerifierPath = Join-Path $BaseDirectory 'EmergencyPostBootVerify.ps1'
$PostBootTaskName = 'EmergencyLockdown-PostBootVerify-v140'
$DisruptionWorkerPath = Join-Path $BaseDirectory 'EmergencyDisruptionWorker.ps1'
$DisruptionTaskName = 'EmergencyLockdown-DisruptionWorker-v140'
$PostBootVerifierBase64 = '<#
.SYNOPSIS
    Automatic post-boot verification component for Emergency Lockdown V1.4.0.
.DESCRIPTION
    Generated and registered internally by the Lockdown/Restore scripts.
    It runs as SYSTEM after reboot, verifies effective state, updates the ACL-protected JSON, and removes its own task.
    It is not an operator-facing Endpoint Central script.
#>
param()
Set-StrictMode -Version 2.0
$ErrorActionPreference = 'Stop'
$ProgressPreference = 'SilentlyContinue'

$BaseDirectory = Join-Path $env:ProgramData 'EmergencyLockdown'
$StatePath = Join-Path $BaseDirectory 'EmergencyLockdown.json'
$TemporaryStatePath = Join-Path $BaseDirectory 'EmergencyLockdown.tmp'
$TaskName = 'EmergencyLockdown-PostBootVerify-v140'
$script:VerificationRecorded = $false
Start-Sleep -Seconds 60

function Get-UtcTimestamp { [DateTime]::UtcNow.ToString('o') }
function Get-PropertyValue {
    param($Object,[string]$Name,$Default=$null)
    if ($null -eq $Object) { return $Default }
    $property = $Object.PSObject.Properties[$Name]
    if ($null -eq $property) { return $Default }
    return $property.Value
}

function Initialize-WtsNativeType {
    if ('EmergencySecurity.PostBootWtsV140' -as [type]) { return }
    $source = @'
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.InteropServices;
namespace EmergencySecurity
{
    public static class PostBootWtsV140
    {
        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
        private struct WTS_SESSION_INFO { public int SessionID; public string pWinStationName; public int State; }
        private enum WTS_INFO_CLASS { WTSInitialProgram, WTSApplicationName, WTSWorkingDirectory, WTSOEMId, WTSSessionId, WTSUserName, WTSWinStationName, WTSDomainName }
        [DllImport("wtsapi32.dll", SetLastError=true)] private static extern bool WTSEnumerateSessions(IntPtr hServer, int Reserved, int Version, out IntPtr ppSessionInfo, out int pCount);
        [DllImport("wtsapi32.dll")] private static extern void WTSFreeMemory(IntPtr pMemory);
        [DllImport("wtsapi32.dll", CharSet=CharSet.Unicode, SetLastError=true)] private static extern bool WTSQuerySessionInformation(IntPtr hServer, int sessionId, WTS_INFO_CLASS infoClass, out IntPtr ppBuffer, out int pBytesReturned);
        private static string Query(int sessionId, WTS_INFO_CLASS infoClass) { IntPtr p=IntPtr.Zero; int bytes=0; try { if(!WTSQuerySessionInformation(IntPtr.Zero,sessionId,infoClass,out p,out bytes)) return ""; return p==IntPtr.Zero ? "" : Marshal.PtrToStringUni(p); } finally { if(p!=IntPtr.Zero) WTSFreeMemory(p); } }
        public static string[] GetSessions() { IntPtr buffer=IntPtr.Zero; int count=0; List<string> result=new List<string>(); try { if(!WTSEnumerateSessions(IntPtr.Zero,0,1,out buffer,out count)) throw new Win32Exception(Marshal.GetLastWin32Error()); int size=Marshal.SizeOf(typeof(WTS_SESSION_INFO)); for(int i=0;i<count;i++){ WTS_SESSION_INFO item=(WTS_SESSION_INFO)Marshal.PtrToStructure(IntPtr.Add(buffer,i*size),typeof(WTS_SESSION_INFO)); string user=Query(item.SessionID,WTS_INFO_CLASS.WTSUserName); string domain=Query(item.SessionID,WTS_INFO_CLASS.WTSDomainName); result.Add(item.SessionID+"|"+domain+"|"+user+"|"+item.State); } return result.ToArray(); } finally { if(buffer!=IntPtr.Zero) WTSFreeMemory(buffer); } }
    }
}
'@
    Add-Type -TypeDefinition $source -Language CSharp -ErrorAction Stop | Out-Null
}
function Get-WtsSessions {
    $items = @()
    foreach ($line in [EmergencySecurity.PostBootWtsV140]::GetSessions()) {
        $parts = $line.Split('|')
        if ($parts.Count -lt 4) { continue }
        $id = [int]$parts[0]
        $domain = [string]$parts[1]
        $user = [string]$parts[2]
        if ($id -le 0 -or [string]::IsNullOrWhiteSpace($user)) { continue }
        $account = if ([string]::IsNullOrWhiteSpace($domain)) { $user } else { "$domain\$user" }
        $items += [pscustomobject]@{sessionId=$id;accountName=$account;state=[int]$parts[3]}
    }
    return $items
}
function Normalize-SessionAccountName {
    param([string]$Name)
    if ([string]::IsNullOrWhiteSpace($Name)) { return '' }
    $value=$Name.Trim()
    if ($value.StartsWith('.\')) { return "$env:COMPUTERNAME\$($value.Substring(2))".ToLowerInvariant() }
    return $value.ToLowerInvariant()
}
function Set-SecureDirectoryAcl {
    param([string]$Path)
    if (-not (Test-Path -LiteralPath $Path)) { $null = New-Item -Path $Path -ItemType Directory -Force }
    $systemSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-18')
    $administratorsSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
    $inheritance = [System.Security.AccessControl.InheritanceFlags]::ContainerInherit -bor [System.Security.AccessControl.InheritanceFlags]::ObjectInherit
    $security = [System.Security.AccessControl.DirectorySecurity]::new()
    $security.SetAccessRuleProtection($true,$false)
    $security.SetOwner($systemSid)
    $security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($systemSid,[System.Security.AccessControl.FileSystemRights]::FullControl,$inheritance,[System.Security.AccessControl.PropagationFlags]::None,[System.Security.AccessControl.AccessControlType]::Allow))
    $security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($administratorsSid,[System.Security.AccessControl.FileSystemRights]::FullControl,$inheritance,[System.Security.AccessControl.PropagationFlags]::None,[System.Security.AccessControl.AccessControlType]::Allow))
    [System.IO.DirectoryInfo]::new($Path).SetAccessControl($security)
}
function Set-SecureFileAcl {
    param([string]$Path)
    if (-not (Test-Path -LiteralPath $Path)) { return }
    $systemSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-18')
    $administratorsSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
    $security = [System.Security.AccessControl.FileSecurity]::new()
    $security.SetAccessRuleProtection($true,$false)
    $security.SetOwner($systemSid)
    $security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($systemSid,[System.Security.AccessControl.FileSystemRights]::FullControl,[System.Security.AccessControl.AccessControlType]::Allow))
    $security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($administratorsSid,[System.Security.AccessControl.FileSystemRights]::FullControl,[System.Security.AccessControl.AccessControlType]::Allow))
    [System.IO.FileInfo]::new($Path).SetAccessControl($security)
}
function Write-State {
    param($State)
    Set-SecureDirectoryAcl -Path $BaseDirectory
    $json = $State | ConvertTo-Json -Depth 24
    [System.IO.File]::WriteAllText($TemporaryStatePath,$json,[System.Text.UTF8Encoding]::new($false))
    Set-SecureFileAcl -Path $TemporaryStatePath
    Move-Item -LiteralPath $TemporaryStatePath -Destination $StatePath -Force
    Set-SecureFileAcl -Path $StatePath
}
function New-Check {
    param([string]$Name,[ValidateSet('PASS','FAIL','WARNING','NOT_APPLICABLE')][string]$Status,[string]$Expected,[string]$Actual,[string]$Message=$null)
    [pscustomobject][ordered]@{name=$Name;status=$Status;expected=$Expected;actual=$Actual;message=$Message}
}
function Test-SecureAcl {
    param([string]$Path)
    try {
        $acl = Get-Acl -LiteralPath $Path -ErrorAction Stop
        $ownerSid = try { ([System.Security.Principal.NTAccount]$acl.Owner).Translate([System.Security.Principal.SecurityIdentifier]).Value } catch { [string]$acl.Owner }
        $allowed = @('S-1-5-18','S-1-5-32-544')
        $unexpected = @()
        foreach ($rule in @($acl.Access)) {
            $sid = try { $rule.IdentityReference.Translate([System.Security.Principal.SecurityIdentifier]).Value } catch { [string]$rule.IdentityReference }
            if ($rule.AccessControlType -ne 'Allow' -or $sid -notin $allowed) { $unexpected += $sid }
        }
        return [pscustomobject]@{Pass=($acl.AreAccessRulesProtected -and $ownerSid -eq 'S-1-5-18' -and $unexpected.Count -eq 0);Owner=$ownerSid;Protected=[bool]$acl.AreAccessRulesProtected;Unexpected=($unexpected -join ';')}
    } catch { return [pscustomobject]@{Pass=$false;Owner='UNKNOWN';Protected=$false;Unexpected=$_.Exception.Message} }
}
function Initialize-LsaNativeType {
    if ('EmergencySecurity.PostBootNativeV140' -as [type]) { return }
    $source = @'
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Security.Principal;
namespace EmergencySecurity
{
    public static class PostBootNativeV140
    {
        [StructLayout(LayoutKind.Sequential)] private struct LSA_OBJECT_ATTRIBUTES { public int Length; public IntPtr RootDirectory; public IntPtr ObjectName; public uint Attributes; public IntPtr SecurityDescriptor; public IntPtr SecurityQualityOfService; }
        [StructLayout(LayoutKind.Sequential)] private struct LSA_UNICODE_STRING { public ushort Length; public ushort MaximumLength; public IntPtr Buffer; }
        [DllImport("advapi32.dll")] private static extern uint LsaOpenPolicy(IntPtr SystemName, ref LSA_OBJECT_ATTRIBUTES ObjectAttributes, uint DesiredAccess, out IntPtr PolicyHandle);
        [DllImport("advapi32.dll")] private static extern uint LsaEnumerateAccountRights(IntPtr PolicyHandle, IntPtr AccountSid, out IntPtr UserRights, out uint CountOfRights);
        [DllImport("advapi32.dll")] private static extern uint LsaNtStatusToWinError(uint Status);
        [DllImport("advapi32.dll")] private static extern uint LsaClose(IntPtr PolicyHandle);
        [DllImport("advapi32.dll")] private static extern uint LsaFreeMemory(IntPtr Buffer);
        [DllImport("Netapi32.dll", CharSet=CharSet.Unicode)] private static extern int NetLocalGroupGetMembers(string servername, string localgroupname, int level, out IntPtr bufptr, int prefmaxlen, out int entriesread, out int totalentries, ref IntPtr resume_handle);
        [DllImport("Netapi32.dll")] private static extern int NetApiBufferFree(IntPtr Buffer);
        private const uint POLICY_LOOKUP_NAMES=0x00000800;
        private const uint STATUS_OBJECT_NAME_NOT_FOUND=0xC0000034;
        private const int MAX_PREFERRED_LENGTH=-1;
        private const int ERROR_MORE_DATA=234;
        private static IntPtr SidToPtr(string sidValue){ SecurityIdentifier sid=new SecurityIdentifier(sidValue); byte[] b=new byte[sid.BinaryLength]; sid.GetBinaryForm(b,0); IntPtr p=Marshal.AllocHGlobal(b.Length); Marshal.Copy(b,0,p,b.Length); return p; }
        public static string[] GetRights(string sidValue)
        {
            LSA_OBJECT_ATTRIBUTES loa=new LSA_OBJECT_ATTRIBUTES(); loa.Length=Marshal.SizeOf(typeof(LSA_OBJECT_ATTRIBUTES));
            IntPtr policy=IntPtr.Zero; IntPtr sid=IntPtr.Zero; IntPtr rights=IntPtr.Zero;
            try
            {
                uint status=LsaOpenPolicy(IntPtr.Zero,ref loa,POLICY_LOOKUP_NAMES,out policy);
                if(status!=0) throw new Win32Exception((int)LsaNtStatusToWinError(status));
                sid=SidToPtr(sidValue); uint count;
                status=LsaEnumerateAccountRights(policy,sid,out rights,out count);
                if(status==STATUS_OBJECT_NAME_NOT_FOUND) return new string[0];
                if(status!=0) throw new Win32Exception((int)LsaNtStatusToWinError(status));
                List<string> list=new List<string>(); int size=Marshal.SizeOf(typeof(LSA_UNICODE_STRING));
                for(int i=0;i<count;i++) { LSA_UNICODE_STRING item=(LSA_UNICODE_STRING)Marshal.PtrToStructure(IntPtr.Add(rights,i*size),typeof(LSA_UNICODE_STRING)); list.Add(Marshal.PtrToStringUni(item.Buffer,item.Length/2)); }
                return list.ToArray();
            }
            finally { if(rights!=IntPtr.Zero)LsaFreeMemory(rights); if(sid!=IntPtr.Zero)Marshal.FreeHGlobal(sid); if(policy!=IntPtr.Zero)LsaClose(policy); }
        }

        public static string[] GetLocalGroupMemberSids(string groupName)
        {
            List<string> results=new List<string>();
            IntPtr resume=IntPtr.Zero;
            int status;
            do
            {
                IntPtr buffer=IntPtr.Zero;
                int entriesRead=0;
                int totalEntries=0;
                try
                {
                    status=NetLocalGroupGetMembers(null,groupName,0,out buffer,MAX_PREFERRED_LENGTH,out entriesRead,out totalEntries,ref resume);
                    if(status!=0 && status!=ERROR_MORE_DATA) throw new Win32Exception(status);
                    for(int i=0;i<entriesRead;i++)
                    {
                        IntPtr sidPtr=Marshal.ReadIntPtr(buffer,i*IntPtr.Size);
                        if(sidPtr!=IntPtr.Zero) results.Add(new SecurityIdentifier(sidPtr).Value);
                    }
                }
                finally { if(buffer!=IntPtr.Zero)NetApiBufferFree(buffer); }
            } while(status==ERROR_MORE_DATA);
            return results.ToArray();
        }
    }
}
'@
    Add-Type -TypeDefinition $source -Language CSharp -ErrorAction Stop | Out-Null
}
function Get-CachedLogonValue {
    $path='HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon'
    try { return [string](Get-ItemProperty -Path $path -Name CachedLogonsCount -ErrorAction Stop).CachedLogonsCount } catch { return $null }
}
function Get-KdcProxyState {
    $rootPath='HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\Kerberos'
    $mappingPath=Join-Path $rootPath 'KdcProxyServer'
    $enabledExists=$false; $enabled=$null; $mappings=@()
    if (Test-Path $rootPath) {
        $item=Get-ItemProperty -Path $rootPath -ErrorAction SilentlyContinue
        if ($null -ne $item -and $item.PSObject.Properties.Name -contains 'KdcProxyServer_Enabled') { $enabledExists=$true; $enabled=$item.KdcProxyServer_Enabled }
    }
    if (Test-Path $mappingPath) {
        $map=Get-ItemProperty -Path $mappingPath -ErrorAction SilentlyContinue
        if ($null -ne $map) { $mappings=@($map.PSObject.Properties | Where-Object {$_.Name -notlike 'PS*'} | ForEach-Object {"$($_.Name)=$([string]$_.Value)"} | Sort-Object) }
    }
    [pscustomobject]@{enabledExists=$enabledExists;enabled=$enabled;mappingExists=(Test-Path $mappingPath);mappings=$mappings}
}

function Get-FirewallEngineState {
    $serviceState='UNKNOWN'
    $enabledProfiles=@()
    $disabledProfiles=@()
    try {
        $service=Get-CimInstance Win32_Service -Filter "Name='MpsSvc'" -ErrorAction Stop
        $serviceState=[string]$service.State
    } catch { }
    try {
        foreach($profile in @(Get-NetFirewallProfile -ErrorAction Stop)) {
            if([bool]$profile.Enabled){$enabledProfiles += [string]$profile.Name}else{$disabledProfiles += [string]$profile.Name}
        }
    } catch { }
    [pscustomobject]@{
        serviceState=$serviceState
        enabledProfiles=@($enabledProfiles)
        disabledProfiles=@($disabledProfiles)
        pass=($serviceState -eq 'Running' -and $enabledProfiles.Count -gt 0)
    }
}

function Normalize-StartMode {
    param([string]$Value)
    switch ($Value) { 'Automatic' {'Auto'} 'Auto' {'Auto'} 'Manual' {'Manual'} 'Disabled' {'Disabled'} default {$Value} }
}
function Compare-KdcProxyRestore {
    param($Original,$Current)
    if ($null -eq $Original) { return $true }
    $expectedEnabledExists=[bool](Get-PropertyValue $Original 'enabledValueExisted' $false)
    $expectedEnabled=Get-PropertyValue $Original 'enabledValue' $null
    $expectedMapExists=[bool](Get-PropertyValue $Original 'mappingPathExisted' $false)
    $expectedMappings=@(Get-PropertyValue $Original 'mappings' @() | ForEach-Object {"$([string](Get-PropertyValue $_ 'name' ''))=$([string](Get-PropertyValue $_ 'value' ''))"} | Sort-Object)
    if ($Current.enabledExists -ne $expectedEnabledExists) { return $false }
    if ($expectedEnabledExists -and [string]$Current.enabled -ne [string]$expectedEnabled) { return $false }
    if ($Current.mappingExists -ne $expectedMapExists) { return $false }
    return ((@($Current.mappings) -join '|') -eq ($expectedMappings -join '|'))
}
function Convert-ToNormalizedSet {
    param($Value)
    $items=@()
    foreach($entry in @($Value)) {
        if($null -eq $entry){continue}
        $items += @(([string]$entry -split ',') | ForEach-Object {$_.Trim()} | Where-Object {$_})
    }
    return @($items | Sort-Object -Unique)
}
function Convert-ProtocolName {
    param($Value)
    $text=[string]$Value
    switch($text.ToUpperInvariant()) {'6' {'TCP'} '17' {'UDP'} default {$text.ToUpperInvariant()}}
}
function Test-FirewallPlan {
    param($Plan,[string]$Operation)
    $definitions=@(Get-PropertyValue $Plan 'ruleDefinitions' @())
    if ($definitions.Count -eq 0) { return [pscustomobject]@{Pass=$true;Actual='No rules required';Failures=@()} }
    $failures=@(); $actual=@()
    foreach($definition in $definitions) {
        $name=[string](Get-PropertyValue $definition 'name' '')
        $rule=@(Get-NetFirewallRule -Name $name -ErrorAction SilentlyContinue)
        if($Operation -eq 'RESTORE') {
            if($rule.Count -gt 0){$failures += "${name}:still-present"}
            continue
        }
        if($rule.Count -ne 1){$failures += "${name}:missing-or-duplicate";continue}
        $item=$rule[0]
        if([string]$item.Enabled -ne 'True' -or [string]$item.Action -ne 'Block' -or [string]$item.Direction -ne 'Outbound'){$failures += "${name}:rule-properties"}
        $portFilter=Get-NetFirewallPortFilter -AssociatedNetFirewallRule $item -ErrorAction SilentlyContinue
        $addressFilter=Get-NetFirewallAddressFilter -AssociatedNetFirewallRule $item -ErrorAction SilentlyContinue
        if($null -eq $portFilter -or $null -eq $addressFilter){$failures += "${name}:filter-unreadable";continue}
        $expectedProtocol=Convert-ProtocolName (Get-PropertyValue $definition 'protocol' '')
        $actualProtocol=Convert-ProtocolName $portFilter.Protocol
        $expectedPorts=Convert-ToNormalizedSet (Get-PropertyValue $definition 'remotePorts' @())
        $actualPorts=Convert-ToNormalizedSet $portFilter.RemotePort
        $expectedAddresses=Convert-ToNormalizedSet (Get-PropertyValue $definition 'remoteAddresses' @())
        $actualAddresses=Convert-ToNormalizedSet $addressFilter.RemoteAddress
        if($actualProtocol -ne $expectedProtocol){$failures += "${name}:protocol"}
        if(($actualPorts -join '|') -ne ($expectedPorts -join '|')){$failures += "${name}:remote-ports"}
        if(($actualAddresses -join '|') -ne ($expectedAddresses -join '|')){$failures += "${name}:remote-addresses"}
        $actual += "${name}[${actualProtocol}:$($actualPorts -join ',')=>$($actualAddresses -join ',')]"
    }
    [pscustomobject]@{Pass=($failures.Count -eq 0);Actual=($actual -join ' | ');Failures=$failures}
}

try {
    if (-not (Test-Path -LiteralPath $StatePath)) { exit 10 }
    $state=Get-Content -LiteralPath $StatePath -Raw -ErrorAction Stop | ConvertFrom-Json -ErrorAction Stop
    $pending=Get-PropertyValue $state 'postBootVerification' $null
    $operation=[string](Get-PropertyValue $pending 'operation' '')
    if ($operation -notin @('LOCKDOWN','RESTORE')) { exit 11 }

    Initialize-LsaNativeType
    Initialize-WtsNativeType
    $checks=@()
    $os=Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    $currentBoot=([datetime]$os.LastBootUpTime).ToUniversalTime()
    $bootBeforeText = if ($operation -eq 'LOCKDOWN') { [string](Get-PropertyValue (Get-PropertyValue $state 'actions' $null) 'bootTimeBefore' '') } else { [string](Get-PropertyValue $state 'restoreBootTimeBefore' '') }
    $bootBefore=$null
    try { if (-not [string]::IsNullOrWhiteSpace($bootBeforeText)) { $bootBefore=[datetime]::Parse($bootBeforeText).ToUniversalTime() } } catch { }
    $rebootPass=($null -ne $bootBefore -and $currentBoot -gt $bootBefore)
    $checks += New-Check -Name 'REBOOT' -Status $(if($rebootPass){'PASS'}else{'FAIL'}) -Expected 'Current boot time later than pre-change boot time' -Actual $currentBoot.ToString('o')

    $directoryAclBefore=Test-SecureAcl -Path $BaseDirectory
    $directoryAclAfter=$directoryAclBefore
    $directoryAclRepaired=$false
    if(-not $directoryAclBefore.Pass){
        try{Set-SecureDirectoryAcl -Path $BaseDirectory;$directoryAclAfter=Test-SecureAcl -Path $BaseDirectory;$directoryAclRepaired=[bool]$directoryAclAfter.Pass}catch{}
    }
    $directoryAclStatus=if($directoryAclBefore.Pass){'PASS'}elseif($directoryAclRepaired){'WARNING'}else{'FAIL'}
    $checks += New-Check -Name 'STATE_DIRECTORY_ACL' -Status $directoryAclStatus -Expected 'Owner SYSTEM, protected ACL, only SYSTEM and Administrators' -Actual "BeforeOwner=$($directoryAclBefore.Owner);BeforeProtected=$($directoryAclBefore.Protected);BeforeUnexpected=$($directoryAclBefore.Unexpected);Repaired=$directoryAclRepaired;AfterUnexpected=$($directoryAclAfter.Unexpected)" -Message $(if($directoryAclRepaired){'Unexpected directory ACL entries were removed by the post-boot verifier.'}else{$null})

    $aclBefore=Test-SecureAcl -Path $StatePath
    $aclAfter=$aclBefore
    $aclRepaired=$false
    if(-not $aclBefore.Pass){
        try{Set-SecureFileAcl -Path $StatePath;$aclAfter=Test-SecureAcl -Path $StatePath;$aclRepaired=[bool]$aclAfter.Pass}catch{}
    }
    $aclStatus=if($aclBefore.Pass){'PASS'}elseif($aclRepaired){'WARNING'}else{'FAIL'}
    $checks += New-Check -Name 'STATE_FILE_ACL' -Status $aclStatus -Expected 'Owner SYSTEM, protected ACL, only SYSTEM and Administrators' -Actual "BeforeOwner=$($aclBefore.Owner);BeforeProtected=$($aclBefore.Protected);BeforeUnexpected=$($aclBefore.Unexpected);Repaired=$aclRepaired;AfterUnexpected=$($aclAfter.Unexpected)" -Message $(if($aclRepaired){'Unexpected state-file ACL entries were removed by the post-boot verifier.'}else{$null})

    $verifierAclBefore=Test-SecureAcl -Path $PSCommandPath
    $verifierAclAfter=$verifierAclBefore
    $verifierAclRepaired=$false
    if(-not $verifierAclBefore.Pass){
        try{Set-SecureFileAcl -Path $PSCommandPath;$verifierAclAfter=Test-SecureAcl -Path $PSCommandPath;$verifierAclRepaired=[bool]$verifierAclAfter.Pass}catch{}
    }
    $verifierAclStatus=if($verifierAclBefore.Pass){'PASS'}elseif($verifierAclRepaired){'WARNING'}else{'FAIL'}
    $checks += New-Check -Name 'VERIFIER_FILE_ACL' -Status $verifierAclStatus -Expected 'Owner SYSTEM, protected ACL, only SYSTEM and Administrators' -Actual "BeforeOwner=$($verifierAclBefore.Owner);BeforeProtected=$($verifierAclBefore.Protected);BeforeUnexpected=$($verifierAclBefore.Unexpected);Repaired=$verifierAclRepaired;AfterUnexpected=$($verifierAclAfter.Unexpected)" -Message $(if($verifierAclRepaired){'Unexpected verifier-file ACL entries were removed by the post-boot verifier.'}else{$null})

    $currentCache=Get-CachedLogonValue
    if ($operation -eq 'LOCKDOWN') {
        $checks += New-Check -Name 'CACHED_DOMAIN_LOGON' -Status $(if($currentCache -eq '0'){'PASS'}else{'FAIL'}) -Expected '0' -Actual $(if($null -eq $currentCache){'<VALUE_ABSENT>'}else{$currentCache})
    } else {
        $original=Get-PropertyValue (Get-PropertyValue $state 'originalState' $null) 'cachedLogonsCount' $null
        $expected=if([bool](Get-PropertyValue $original 'existed' $false)){[string](Get-PropertyValue $original 'value' '')}else{'<VALUE_ABSENT>'}
        $actual=if($null -eq $currentCache){'<VALUE_ABSENT>'}else{$currentCache}
        $checks += New-Check -Name 'CACHED_DOMAIN_LOGON' -Status $(if($actual -eq $expected){'PASS'}else{'FAIL'}) -Expected $expected -Actual $actual
    }

    $rightsFailures=@(); $rightsChecked=0; $baselineWarnings=@(); $baselineChecked=0
    $records=@(Get-PropertyValue (Get-PropertyValue $state 'originalState' $null) 'userRights' @())
    foreach($record in $records) {
        try {
            $sid=[string](Get-PropertyValue $record 'sid' '')
            if ([string]::IsNullOrWhiteSpace($sid)) { continue }
            $accountLabel=[string](Get-PropertyValue $record 'accountName' $sid)
            $currentRights=@([EmergencySecurity.PostBootNativeV140]::GetRights($sid))
            if($operation -eq 'LOCKDOWN') {
                foreach($right in @(Get-PropertyValue $record 'requiredRights' @())) {
                    $rightsChecked++
                    if($right -notin $currentRights){$rightsFailures += "${accountLabel}:${right}:missing"}
                }
            }
            else {
                foreach($right in @(Get-PropertyValue $record 'rightsAdded' @())) {
                    $rightsChecked++
                    if($right -in $currentRights){$rightsFailures += "${accountLabel}:${right}:still-present"}
                }
                foreach($right in @(Get-PropertyValue $record 'rightsBefore' @())) {
                    $baselineChecked++
                    if($right -notin $currentRights){$baselineWarnings += "${accountLabel}:${right}:original-right-missing"}
                }
            }
        } catch { $rightsFailures += "$([string](Get-PropertyValue $record 'accountName' 'unknown')):enumeration-failed:$($_.Exception.Message)" }
    }
    $checks += New-Check -Name 'USER_RIGHTS' -Status $(if($rightsFailures.Count -eq 0){'PASS'}else{'FAIL'}) -Expected $(if($operation -eq 'LOCKDOWN'){'All required deny rights present'}else{'All Lockdown-added deny rights absent'}) -Actual $(if($rightsFailures.Count -eq 0){"Checked $rightsChecked assignments"}else{$rightsFailures -join ' | '})

    $scopeGuard=Get-PropertyValue (Get-PropertyValue $state 'actions' $null) 'scopeGuard' $null
    $scopeGuardPrincipals=@(Get-PropertyValue $scopeGuard 'principals' @())
    if($operation -eq 'LOCKDOWN' -and $scopeGuardPrincipals.Count -gt 0) {
        $scopeGuardFailures=@()
        foreach($principal in $scopeGuardPrincipals) {
            $guardSid=[string](Get-PropertyValue $principal 'sid' '')
            if([string]::IsNullOrWhiteSpace($guardSid)){continue}
            try {
                $guardRights=@([EmergencySecurity.PostBootNativeV140]::GetRights($guardSid))
                foreach($right in @('SeDenyInteractiveLogonRight','SeDenyRemoteInteractiveLogonRight','SeDenyNetworkLogonRight')) {
                    if($right -notin $guardRights){$scopeGuardFailures += "${guardSid}:${right}:missing"}
                }
            } catch {$scopeGuardFailures += "${guardSid}:enumeration-failed:$($_.Exception.Message)"}
        }
        $checks += New-Check -Name 'SCOPE_GUARD' -Status $(if($scopeGuardFailures.Count -eq 0){'PASS'}else{'FAIL'}) -Expected 'All broad ALL-scope interactive/RDP/network guard rights present' -Actual $(if($scopeGuardFailures.Count -eq 0){"$($scopeGuardPrincipals.Count) guard principal(s) verified"}else{$scopeGuardFailures -join ' | '})
    } elseif($operation -eq 'RESTORE' -and $scopeGuardPrincipals.Count -gt 0) {
        $scopeGuardFailures=@()
        foreach($principal in $scopeGuardPrincipals) {
            $guardSid=[string](Get-PropertyValue $principal 'sid' '')
            if([string]::IsNullOrWhiteSpace($guardSid)){continue}
            try {
                $guardRights=@([EmergencySecurity.PostBootNativeV140]::GetRights($guardSid))
                foreach($right in @('SeDenyInteractiveLogonRight','SeDenyRemoteInteractiveLogonRight','SeDenyNetworkLogonRight')) {
                    $record=@($records | Where-Object {[string](Get-PropertyValue $_ 'sid' '') -eq $guardSid} | Select-Object -First 1)
                    if($record.Count -gt 0 -and $right -in @(Get-PropertyValue $record[0] 'rightsAdded' @()) -and $right -in $guardRights){$scopeGuardFailures += "${guardSid}:${right}:still-present"}
                }
            } catch {$scopeGuardFailures += "${guardSid}:enumeration-failed:$($_.Exception.Message)"}
        }
        $checks += New-Check -Name 'SCOPE_GUARD' -Status $(if($scopeGuardFailures.Count -eq 0){'PASS'}else{'FAIL'}) -Expected 'Lockdown-added broad scope-guard rights absent' -Actual $(if($scopeGuardFailures.Count -eq 0){"$($scopeGuardPrincipals.Count) guard principal(s) restored"}else{$scopeGuardFailures -join ' | '})
    } else {
        $checks += New-Check -Name 'SCOPE_GUARD' -Status 'NOT_APPLICABLE' -Expected 'ALL scope guard' -Actual 'No scope guard recorded'
    }

    if($operation -eq 'RESTORE') {
        $checks += New-Check -Name 'USER_RIGHTS_ORIGINAL_BASELINE' -Status $(if($baselineWarnings.Count -eq 0){'PASS'}else{'WARNING'}) -Expected 'Pre-existing user rights remain present' -Actual $(if($baselineWarnings.Count -eq 0){"Checked $baselineChecked original assignments"}else{$baselineWarnings -join ' | '})
    }
    else {
        $checks += New-Check -Name 'USER_RIGHTS_ORIGINAL_BASELINE' -Status 'NOT_APPLICABLE' -Expected 'Restore operation' -Actual 'Not evaluated during Lockdown'
    }

    if($operation -eq 'LOCKDOWN') {
        $resolvedTargets=@(Get-PropertyValue $state 'targets' @() | Where-Object {$_.resolveStatus -eq 'SUCCESS'})
        $targetNames=@()
        foreach($target in $resolvedTargets) {
            foreach($field in @('accountName','normalized','requested')) {
                $value=[string](Get-PropertyValue $target $field '')
                if(-not [string]::IsNullOrWhiteSpace($value)){$targetNames += (Normalize-SessionAccountName $value)}
            }
        }
        $targetNames=@($targetNames | Select-Object -Unique)
        $activeSessions=@(Get-WtsSessions)
        $remainingTargetSessions=@($activeSessions | Where-Object {(Normalize-SessionAccountName ([string]$_.accountName)) -in $targetNames})
        $sessionPass=($remainingTargetSessions.Count -eq 0)
        $checks += New-Check -Name 'TARGET_SESSIONS_ABSENT' -Status $(if($sessionPass){'PASS'}else{'FAIL'}) -Expected 'No resolved target identity has an interactive session after reboot' -Actual $(if($sessionPass){'0 target sessions'}else{(($remainingTargetSessions | ForEach-Object {"$($_.sessionId):$($_.accountName)"}) -join ' | ')})
        $actions=Get-PropertyValue $state 'actions' $null
        if($null -ne $actions) {
            $absentCount=[int][Math]::Max(0, ($resolvedTargets.Count - $remainingTargetSessions.Count))
            $telemetry=Get-PropertyValue $actions 'sessionTelemetry' $null
            if($null -eq $telemetry){
                $telemetry=[pscustomobject][ordered]@{targetSessionsFound=0;logoffRequestsAccepted=0;logoffRequestsFailed=0;confirmedClosedBeforeReboot=0;remainingSessionIdsBeforeReboot=@();targetIdentitiesWithoutSessionAfterReboot=0;remainingTargetSessionsAfterReboot=@();pendingLogoffSessionIds=@()}
                $actions|Add-Member -NotePropertyName sessionTelemetry -NotePropertyValue $telemetry
            }
            $telemetry.targetIdentitiesWithoutSessionAfterReboot=$absentCount
            $telemetry.remainingTargetSessionsAfterReboot=@($remainingTargetSessions)
        }
    }
    else {
        $checks += New-Check -Name 'TARGET_SESSIONS_ABSENT' -Status 'NOT_APPLICABLE' -Expected 'Lockdown operation' -Actual 'Restore does not force a user session to remain absent'
    }

    $scope=[string](Get-PropertyValue $state 'scope' '')
    if($operation -eq 'LOCKDOWN' -and $scope -eq 'ALL_USERS_SAVE_LAPS') {
        $laps=Get-PropertyValue $state 'laps' $null
        $lapsSid=[string](Get-PropertyValue $laps 'accountSid' '')
        $lapsName=[string](Get-PropertyValue $laps 'accountName' '')
        $lapsFailures=@()
        try {
            if([string]::IsNullOrWhiteSpace($lapsSid)){throw 'LAPS account SID is absent from state.'}
            $localAccount=@(Get-CimInstance Win32_UserAccount -Filter 'LocalAccount=True' -ErrorAction Stop | Where-Object {$_.SID -eq $lapsSid} | Select-Object -First 1)
            if($localAccount.Count -eq 0){$lapsFailures += 'account-not-found'}
            elseif([bool]$localAccount[0].Disabled){$lapsFailures += 'account-disabled'}
            $adminGroup=@(Get-CimInstance Win32_Group -Filter "LocalAccount=True AND SID='S-1-5-32-544'" -ErrorAction Stop | Select-Object -First 1)
            $adminSids=@()
            if($adminGroup.Count -gt 0){
                try{$adminSids=@([EmergencySecurity.PostBootNativeV140]::GetLocalGroupMemberSids([string]$adminGroup[0].Name))}catch{}
                if($adminSids.Count -eq 0){
                    try{$adminSids=@(Get-CimAssociatedInstance -InputObject $adminGroup[0] -Association Win32_GroupUser -ErrorAction Stop | ForEach-Object {[string]$_.SID})}catch{}
                }
            }
            if($lapsSid -notin $adminSids){$lapsFailures += 'not-local-administrator'}
            $lapsRights=@([EmergencySecurity.PostBootNativeV140]::GetRights($lapsSid))
            $blocking=@($lapsRights | Where-Object {$_ -in @('SeDenyInteractiveLogonRight','SeDenyRemoteInteractiveLogonRight','SeDenyNetworkLogonRight')})
            if($blocking.Count -gt 0){$lapsFailures += ('blocking-rights=' + ($blocking -join ','))}
        }
        catch {$lapsFailures += ('verification-error=' + $_.Exception.Message)}
        $checks += New-Check -Name 'SAVELAPS_RECOVERY_IDENTITY' -Status $(if($lapsFailures.Count -eq 0){'PASS'}else{'FAIL'}) -Expected 'Verified LAPS account exists, is enabled, is local administrator, and has no human-access deny rights' -Actual $(if($lapsFailures.Count -eq 0){"${lapsName};${lapsSid};usable"}else{$lapsFailures -join ' | '})
    }
    else {
        $checks += New-Check -Name 'SAVELAPS_RECOVERY_IDENTITY' -Status 'NOT_APPLICABLE' -Expected 'ALL -SaveLaps Lockdown' -Actual 'Not requested or Restore operation'
    }

    $allScope=$scope -in @('ALL_USERS','ALL_USERS_SAVE_LAPS')
    $domainContext=Get-PropertyValue (Get-PropertyValue $state 'actions' $null) 'domainContext' $null
    $partOfDomain=[bool](Get-PropertyValue $domainContext 'partOfDomain' $false)
    if($allScope -and $partOfDomain) {
        $plan=Get-PropertyValue (Get-PropertyValue $state 'actions' $null) 'authFirewall' $null
        if($operation -eq 'LOCKDOWN') {
            $firewallEngine=Get-FirewallEngineState
            $checks += New-Check -Name 'FIREWALL_ENGINE' -Status $(if($firewallEngine.pass){'PASS'}else{'FAIL'}) -Expected 'MpsSvc running and at least one Windows Firewall profile enabled' -Actual "Service=$($firewallEngine.serviceState);Enabled=$($firewallEngine.enabledProfiles -join ',');Disabled=$($firewallEngine.disabledProfiles -join ',')"
        } else {
            $checks += New-Check -Name 'FIREWALL_ENGINE' -Status 'NOT_APPLICABLE' -Expected 'Lockdown operation' -Actual 'Restore does not change firewall engine state'
        }
        $firewallResult=Test-FirewallPlan -Plan $plan -Operation $operation
        $checks += New-Check -Name 'AUTH_FIREWALL' -Status $(if($firewallResult.Pass){'PASS'}else{'FAIL'}) -Expected $(if($operation -eq 'LOCKDOWN'){'All planned emergency block rules active'}else{'All emergency block rules absent'}) -Actual $(if($firewallResult.Failures.Count -eq 0){$firewallResult.Actual}else{$firewallResult.Failures -join ' | '})

        $netlogon=Get-CimInstance Win32_Service -Filter "Name='Netlogon'" -ErrorAction Stop
        if($operation -eq 'RESTORE') {
            $originalNetlogon=Get-PropertyValue (Get-PropertyValue $state 'originalState' $null) 'netlogon' $null
            $expectedStart=Normalize-StartMode ([string](Get-PropertyValue $originalNetlogon 'startMode' 'Manual'))
            $expectedState=[string](Get-PropertyValue $originalNetlogon 'state' 'Stopped')
            if($expectedState -eq 'Running' -and $netlogon.State -ne 'Running' -and $expectedStart -ne 'Disabled') {
                try { Start-Service Netlogon -ErrorAction Stop; Start-Sleep -Seconds 2 } catch { }
                $netlogon=Get-CimInstance Win32_Service -Filter "Name='Netlogon'" -ErrorAction Stop
            }
            $netPass=((Normalize-StartMode ([string]$netlogon.StartMode)) -eq $expectedStart -and (($expectedState -ne 'Running') -or $netlogon.State -eq 'Running'))
            $checks += New-Check -Name 'NETLOGON' -Status $(if($netPass){'PASS'}else{'FAIL'}) -Expected "$expectedState/$expectedStart" -Actual "$($netlogon.State)/$(Normalize-StartMode ([string]$netlogon.StartMode))"
        } else {
            $netPass=($netlogon.State -eq 'Stopped' -and (Normalize-StartMode ([string]$netlogon.StartMode)) -eq 'Disabled')
            $checks += New-Check -Name 'NETLOGON' -Status $(if($netPass){'PASS'}else{'FAIL'}) -Expected 'Stopped/Disabled' -Actual "$($netlogon.State)/$(Normalize-StartMode ([string]$netlogon.StartMode))"
        }

        $currentKdc=Get-KdcProxyState
        if($operation -eq 'LOCKDOWN') {
            $kdcPass=($currentKdc.enabledExists -and [int]$currentKdc.enabled -eq 0 -and -not $currentKdc.mappingExists)
            $checks += New-Check -Name 'KDC_PROXY' -Status $(if($kdcPass){'PASS'}else{'FAIL'}) -Expected 'Disabled and mappings absent' -Actual "Enabled=$($currentKdc.enabled);MappingExists=$($currentKdc.mappingExists)"
        } else {
            $originalKdc=Get-PropertyValue (Get-PropertyValue $state 'originalState' $null) 'kdcProxy' $null
            $kdcPass=Compare-KdcProxyRestore -Original $originalKdc -Current $currentKdc
            $checks += New-Check -Name 'KDC_PROXY' -Status $(if($kdcPass){'PASS'}else{'FAIL'}) -Expected 'Original KDC proxy configuration' -Actual "EnabledExists=$($currentKdc.enabledExists);Enabled=$($currentKdc.enabled);MappingExists=$($currentKdc.mappingExists)"
        }
    } else {
        $checks += New-Check -Name 'AUTH_FIREWALL' -Status 'NOT_APPLICABLE' -Expected 'ALL scope on a domain-joined device' -Actual 'Not configured'
        $checks += New-Check -Name 'NETLOGON' -Status 'NOT_APPLICABLE' -Expected 'ALL scope on a domain-joined device' -Actual 'Not changed'
        $checks += New-Check -Name 'KDC_PROXY' -Status 'NOT_APPLICABLE' -Expected 'ALL scope on a domain-joined device' -Actual 'Not changed'
    }

    $failed=@($checks | Where-Object {$_.status -eq 'FAIL'})
    $warningChecks=@($checks | Where-Object {$_.status -eq 'WARNING'})
    $overall=if($failed.Count -gt 0){'FAILED_VERIFICATION'}elseif($warningChecks.Count -gt 0){'SUCCESS_WITH_WARNINGS'}else{'SUCCESS'}
    $verification=[pscustomobject][ordered]@{
        operation=$operation;status='COMPLETED';overallStatus=$overall
        scheduledUtc=Get-PropertyValue $pending 'scheduledUtc' $null;verifiedUtc=Get-UtcTimestamp
        currentBootTime=$currentBoot.ToString('o');rebootVerified=$rebootPass
        passedCheckCount=@($checks | Where-Object {$_.status -eq 'PASS'}).Count
        warningCheckCount=$warningChecks.Count;warningChecks=(($warningChecks | ForEach-Object {$_.name}) -join ';')
        failedCheckCount=$failed.Count;failedChecks=(($failed | ForEach-Object {$_.name}) -join ';')
        taskName=$TaskName;scriptPath=$PSCommandPath;checks=$checks
    }
    if($state.PSObject.Properties.Name -contains 'postBootVerification'){$state.postBootVerification=$verification}else{$state|Add-Member -NotePropertyName postBootVerification -NotePropertyValue $verification}
    if($operation -eq 'LOCKDOWN'){
        $state.status=if($overall -eq 'SUCCESS'){'ACTIVE_VERIFIED'}elseif($overall -eq 'SUCCESS_WITH_WARNINGS'){'ACTIVE_VERIFIED_WITH_WARNINGS'}else{'LOCKDOWN_PARTIAL'}
    }
    if($operation -eq 'RESTORE'){
        $state.status=if($overall -eq 'SUCCESS'){'RESTORED_VERIFIED'}elseif($overall -eq 'SUCCESS_WITH_WARNINGS'){'RESTORED_VERIFIED_WITH_WARNINGS'}else{'RESTORE_PARTIAL'}
    }
    Write-State -State $state
    $script:VerificationRecorded=$true
}
catch {
    try {
        if(Test-Path -LiteralPath $StatePath) {
            $state=Get-Content -LiteralPath $StatePath -Raw -ErrorAction Stop | ConvertFrom-Json -ErrorAction Stop
            $pending=Get-PropertyValue $state 'postBootVerification' $null
            $failure=[pscustomobject][ordered]@{operation=[string](Get-PropertyValue $pending 'operation' 'UNKNOWN');status='FAILED';overallStatus='FAILED_VERIFICATION';verifiedUtc=Get-UtcTimestamp;rebootVerified=$false;passedCheckCount=0;warningCheckCount=0;warningChecks='';failedCheckCount=1;failedChecks='POSTBOOT_VERIFIER_EXCEPTION';errorMessage=$_.Exception.Message;taskName=$TaskName;scriptPath=$PSCommandPath;checks=@()}
            if($state.PSObject.Properties.Name -contains 'postBootVerification'){$state.postBootVerification=$failure}else{$state|Add-Member -NotePropertyName postBootVerification -NotePropertyValue $failure}
            if($failure.operation -eq 'LOCKDOWN'){$state.status='LOCKDOWN_PARTIAL'}
            if($failure.operation -eq 'RESTORE'){$state.status='RESTORE_PARTIAL'}
            Write-State -State $state
            $script:VerificationRecorded=$true
        }
    } catch { }
}
finally {
    if($script:VerificationRecorded) {
        try { & "$env:SystemRoot\System32\schtasks.exe" /Delete /TN $TaskName /F | Out-Null } catch { }
        try { Remove-Item -LiteralPath $PSCommandPath -Force -ErrorAction SilentlyContinue } catch { }
    }
}
'
$DisruptionWorkerBase64 = '<#
.SYNOPSIS
    Internal disruption worker for Emergency Lockdown V1.4.0.
.DESCRIPTION
    Generated and started by the operator-facing Lockdown script.
    It runs independently as SYSTEM in Task Scheduler so that logging off the
    interactive session cannot terminate the Endpoint Central script before
    Remarks and state are returned. It schedules the mandatory reboot, logs off
    targeted sessions, records effective results, and removes its own task.
    This is not an operator-facing Endpoint Central script.
#>
param()
Set-StrictMode -Version 2.0
$ErrorActionPreference = 'Stop'
$ProgressPreference = 'SilentlyContinue'

$BaseDirectory = Join-Path $env:ProgramData 'EmergencyLockdown'
$StatePath = Join-Path $BaseDirectory 'EmergencyLockdown.json'
$TemporaryStatePath = Join-Path $BaseDirectory 'EmergencyLockdown.tmp'
$TaskName = 'EmergencyLockdown-DisruptionWorker-v140'
$script:State = $null
Start-Sleep -Seconds 8

function Get-UtcTimestamp { [DateTime]::UtcNow.ToString('o') }
function Set-SecureDirectoryAcl {
    param([string]$Path)
    if (-not (Test-Path -LiteralPath $Path)) { $null = New-Item -Path $Path -ItemType Directory -Force }
    $systemSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-18')
    $administratorsSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
    $inheritance = [System.Security.AccessControl.InheritanceFlags]::ContainerInherit -bor [System.Security.AccessControl.InheritanceFlags]::ObjectInherit
    $security = [System.Security.AccessControl.DirectorySecurity]::new()
    $security.SetAccessRuleProtection($true,$false)
    $security.SetOwner($systemSid)
    $security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($systemSid,[System.Security.AccessControl.FileSystemRights]::FullControl,$inheritance,[System.Security.AccessControl.PropagationFlags]::None,[System.Security.AccessControl.AccessControlType]::Allow))
    $security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($administratorsSid,[System.Security.AccessControl.FileSystemRights]::FullControl,$inheritance,[System.Security.AccessControl.PropagationFlags]::None,[System.Security.AccessControl.AccessControlType]::Allow))
    [System.IO.DirectoryInfo]::new($Path).SetAccessControl($security)
}
function Set-SecureFileAcl {
    param([string]$Path)
    if (-not (Test-Path -LiteralPath $Path)) { return }
    $systemSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-18')
    $administratorsSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
    $security = [System.Security.AccessControl.FileSecurity]::new()
    $security.SetAccessRuleProtection($true,$false)
    $security.SetOwner($systemSid)
    $security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($systemSid,[System.Security.AccessControl.FileSystemRights]::FullControl,[System.Security.AccessControl.AccessControlType]::Allow))
    $security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($administratorsSid,[System.Security.AccessControl.FileSystemRights]::FullControl,[System.Security.AccessControl.AccessControlType]::Allow))
    [System.IO.FileInfo]::new($Path).SetAccessControl($security)
}
function Write-State {
    Set-SecureDirectoryAcl -Path $BaseDirectory
    $json = $script:State | ConvertTo-Json -Depth 24
    [System.IO.File]::WriteAllText($TemporaryStatePath,$json,[System.Text.UTF8Encoding]::new($false))
    Set-SecureFileAcl -Path $TemporaryStatePath
    Move-Item -LiteralPath $TemporaryStatePath -Destination $StatePath -Force
    Set-SecureFileAcl -Path $StatePath
}
function Add-WorkerStage {
    param(
        [string]$Name,
        [ValidateSet('SUCCESS','WARNING','FAILED')][string]$Status,
        [datetime]$Started,
        [int]$AffectedCount = 0,
        [string]$ErrorCode = $null,
        [string]$ErrorMessage = $null,
        [string]$Expected = $null,
        [string]$Actual = $null,
        [ValidateSet('PASS','WARNING','FAIL','PENDING')][string]$Verification = 'PASS'
    )
    if ($null -eq $Started) { $Started = [DateTime]::UtcNow }
    $completed = [DateTime]::UtcNow
    $script:State.stages += [pscustomobject][ordered]@{
        name=$Name;status=$Status;verification=$Verification
        startedUtc=$Started.ToString('o');completedUtc=$completed.ToString('o')
        durationMs=[int][Math]::Max(0,($completed-$Started).TotalMilliseconds)
        affectedCount=$AffectedCount;expected=$Expected;actual=$Actual
        errorCode=$ErrorCode;errorMessage=$ErrorMessage;message='Recorded by the independent disruption worker.'
    }
    if ($Status -eq 'WARNING' -and $ErrorCode) {
        $script:State.warnings += [pscustomobject][ordered]@{code=$ErrorCode;message=$ErrorMessage;timestampUtc=Get-UtcTimestamp}
    }
    elseif ($Status -eq 'FAILED' -and $ErrorCode) {
        $script:State.errors += [pscustomobject][ordered]@{code=$ErrorCode;message=$ErrorMessage;stage=$Name;timestampUtc=Get-UtcTimestamp}
    }
    Write-State
}
function Initialize-WtsNativeType {
    if ('EmergencySecurity.DisruptionNativeV140' -as [type]) { return }
    $source = @'
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.InteropServices;
namespace EmergencySecurity
{
    public static class DisruptionNativeV140
    {
        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
        private struct WTS_SESSION_INFO { public int SessionID; public string pWinStationName; public int State; }
        private enum WTS_INFO_CLASS { WTSInitialProgram, WTSApplicationName, WTSWorkingDirectory, WTSOEMId, WTSSessionId, WTSUserName, WTSWinStationName, WTSDomainName }
        [DllImport("wtsapi32.dll", SetLastError=true)] private static extern bool WTSEnumerateSessions(IntPtr hServer, int Reserved, int Version, out IntPtr ppSessionInfo, out int pCount);
        [DllImport("wtsapi32.dll")] private static extern void WTSFreeMemory(IntPtr pMemory);
        [DllImport("wtsapi32.dll", CharSet=CharSet.Unicode, SetLastError=true)] private static extern bool WTSQuerySessionInformation(IntPtr hServer, int sessionId, WTS_INFO_CLASS infoClass, out IntPtr ppBuffer, out int pBytesReturned);
        [DllImport("wtsapi32.dll", SetLastError=true)] private static extern bool WTSLogoffSession(IntPtr hServer, int sessionId, bool wait);
        private static string Query(int sessionId, WTS_INFO_CLASS infoClass) { IntPtr p=IntPtr.Zero; int bytes=0; try { if(!WTSQuerySessionInformation(IntPtr.Zero,sessionId,infoClass,out p,out bytes)) return ""; return p==IntPtr.Zero ? "" : Marshal.PtrToStringUni(p); } finally { if(p!=IntPtr.Zero) WTSFreeMemory(p); } }
        public static string[] GetSessions() { IntPtr buffer=IntPtr.Zero; int count=0; List<string> result=new List<string>(); try { if(!WTSEnumerateSessions(IntPtr.Zero,0,1,out buffer,out count)) throw new Win32Exception(Marshal.GetLastWin32Error()); int size=Marshal.SizeOf(typeof(WTS_SESSION_INFO)); for(int i=0;i<count;i++){ WTS_SESSION_INFO item=(WTS_SESSION_INFO)Marshal.PtrToStructure(IntPtr.Add(buffer,i*size),typeof(WTS_SESSION_INFO)); string user=Query(item.SessionID,WTS_INFO_CLASS.WTSUserName); string domain=Query(item.SessionID,WTS_INFO_CLASS.WTSDomainName); result.Add(item.SessionID+"|"+domain+"|"+user+"|"+item.State); } return result.ToArray(); } finally { if(buffer!=IntPtr.Zero) WTSFreeMemory(buffer); } }
        public static void Logoff(int sessionId) { if(!WTSLogoffSession(IntPtr.Zero,sessionId,false)) throw new Win32Exception(Marshal.GetLastWin32Error()); }
    }
}
'@
    Add-Type -TypeDefinition $source -Language CSharp -ErrorAction Stop | Out-Null
}
function Get-WtsSessions {
    $items = @()
    foreach ($line in [EmergencySecurity.DisruptionNativeV140]::GetSessions()) {
        $parts = $line.Split('|')
        if ($parts.Count -lt 4) { continue }
        $id = [int]$parts[0]
        $domain = [string]$parts[1]
        $user = [string]$parts[2]
        if ($id -le 0 -or [string]::IsNullOrWhiteSpace($user)) { continue }
        $account = if ([string]::IsNullOrWhiteSpace($domain)) { $user } else { "$domain\$user" }
        $sid = $null
        try { $sid = ([System.Security.Principal.NTAccount]::new($account)).Translate([System.Security.Principal.SecurityIdentifier]).Value } catch { }
        $items += [pscustomobject]@{sessionId=$id;accountName=$account;sid=$sid;state=[int]$parts[3]}
    }
    return $items
}

try {
    if (-not (Test-Path -LiteralPath $StatePath)) { return }
    $script:State = Get-Content -LiteralPath $StatePath -Raw -ErrorAction Stop | ConvertFrom-Json -ErrorAction Stop
    if ([string]$script:State.status -notin @('ACTIVE_DISRUPTION_PENDING','ACTIVE_PENDING_REBOOT')) { return }
    Initialize-WtsNativeType

    $stageStart = [DateTime]::UtcNow
    try {
        $os = Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
        $script:State.actions.bootTimeBefore = ([datetime]$os.LastBootUpTime).ToUniversalTime().ToString('o')
        $delay = [int]$script:State.actions.rebootDelaySeconds
        if ($delay -lt 30) { $delay = 30 }
        $arguments = @('/r','/f','/t',[string]$delay,'/c','"Emergency access lockdown: mandatory restart"')
        $process = Start-Process -FilePath "$env:SystemRoot\System32\shutdown.exe" -ArgumentList $arguments -Wait -PassThru -WindowStyle Hidden
        if ($process.ExitCode -ne 0) { throw "shutdown.exe returned exit code $($process.ExitCode)." }
        $script:State.actions.rebootScheduled = $true
        $script:State.actions.rebootScheduledUtc = Get-UtcTimestamp
        Add-WorkerStage -Name 'SCHEDULE_REBOOT' -Status 'SUCCESS' -Started $stageStart -AffectedCount 1 -Expected 'shutdown.exe accepted mandatory restart' -Actual "ExitCode=0;Delay=$delay seconds" -Verification 'PENDING'
    }
    catch {
        $script:State.actions.rebootScheduled = $false
        Add-WorkerStage -Name 'SCHEDULE_REBOOT' -Status 'FAILED' -Started $stageStart -ErrorCode 'REBOOT_SCHEDULE_FAILED' -ErrorMessage $_.Exception.Message -Expected 'shutdown.exe accepted mandatory restart' -Actual 'Not scheduled' -Verification 'FAIL'
    }

    $stageStart = [DateTime]::UtcNow
    $sessions = @(Get-WtsSessions)
    $targetSids = @($script:State.targets | Where-Object { $_.resolveStatus -eq 'SUCCESS' -and -not [string]::IsNullOrWhiteSpace([string]$_.sid) } | ForEach-Object { [string]$_.sid } | Select-Object -Unique)
    $pendingIds = @()
    try { $pendingIds = @($script:State.actions.sessionTelemetry.pendingLogoffSessionIds | ForEach-Object { [int]$_ }) } catch { }
    $targetSessions = @($sessions | Where-Object { ($_.sid -and $_.sid -in $targetSids) -or $_.sessionId -in $pendingIds } | Sort-Object sessionId -Unique)
    $accepted = 0
    $requestFailures = @()
    foreach ($session in $targetSessions) {
        try { [EmergencySecurity.DisruptionNativeV140]::Logoff([int]$session.sessionId); $accepted++ }
        catch { $requestFailures += "Session $($session.sessionId) ($($session.accountName)): $($_.Exception.Message)" }
    }
    Start-Sleep -Seconds 3
    $remainingNow = @(Get-WtsSessions | Where-Object { ($_.sid -and $_.sid -in $targetSids) -or $_.sessionId -in $pendingIds })
    $confirmedAbsent = [int][Math]::Max(0, ($targetSessions.Count - $remainingNow.Count))
    $telemetry=$script:State.actions.sessionTelemetry
    $telemetry.targetSessionsFound = [int]$targetSessions.Count
    $telemetry.confirmedClosedBeforeReboot = $confirmedAbsent
    $telemetry.logoffRequestsAccepted = [int]$accepted
    $telemetry.logoffRequestsFailed = [int]$requestFailures.Count
    $telemetry.remainingSessionIdsBeforeReboot = @($remainingNow | ForEach-Object { [int]$_.sessionId })
    if ($requestFailures.Count -gt 0) {
        Add-WorkerStage -Name 'LOGOFF_SESSIONS' -Status 'WARNING' -Started $stageStart -AffectedCount $accepted -ErrorCode 'ONE_OR_MORE_LOGOFF_REQUESTS_FAILED' -ErrorMessage ($requestFailures -join ' | ') -Expected 'Windows accepts every target-session logoff request; final absence is verified after reboot' -Actual "$accepted accepted; $($requestFailures.Count) failed; $($remainingNow.Count) still visible before reboot" -Verification 'WARNING'
    }
    elseif ($remainingNow.Count -gt 0) {
        Add-WorkerStage -Name 'LOGOFF_SESSIONS' -Status 'SUCCESS' -Started $stageStart -AffectedCount $accepted -Expected 'Windows accepts every target-session logoff request; final absence is verified after reboot' -Actual "$accepted accepted; $($remainingNow.Count) still closing before reboot" -Verification 'PENDING'
    }
    else {
        Add-WorkerStage -Name 'LOGOFF_SESSIONS' -Status 'SUCCESS' -Started $stageStart -AffectedCount $accepted -Expected 'Windows accepts every target-session logoff request and target sessions disappear' -Actual "$($targetSessions.Count) targeted; 0 remain" -Verification 'PASS'
    }

    $stageStart = [DateTime]::UtcNow
    $script:State.completedUtc = Get-UtcTimestamp
    $hardFailures = @($script:State.stages | Where-Object { $_.status -eq 'FAILED' }).Count
    $script:State.status = if ([bool]$script:State.actions.rebootScheduled -and $hardFailures -eq 0) { 'ACTIVE_PENDING_REBOOT' } else { 'LOCKDOWN_PARTIAL' }
    Add-WorkerStage -Name 'FINALIZE_STATE' -Status $(if($script:State.status -eq 'ACTIVE_PENDING_REBOOT'){'SUCCESS'}else{'WARNING'}) -Started $stageStart -ErrorCode $(if($script:State.status -eq 'ACTIVE_PENDING_REBOOT'){$null}else{'LOCKDOWN_PARTIAL'}) -ErrorMessage $(if($script:State.status -eq 'ACTIVE_PENDING_REBOOT'){$null}else{'Disruption worker completed with one or more failures.'}) -Expected 'Durable pre-reboot state' -Actual ([string]$script:State.status) -Verification $(if($script:State.status -eq 'ACTIVE_PENDING_REBOOT'){'PASS'}else{'WARNING'})
}
catch {
    try {
        if ($null -eq $script:State -and (Test-Path -LiteralPath $StatePath)) { $script:State = Get-Content -LiteralPath $StatePath -Raw | ConvertFrom-Json }
        if ($null -ne $script:State) {
            $script:State.status = 'LOCKDOWN_PARTIAL'
            Add-WorkerStage -Name 'DISRUPTION_WORKER' -Status 'FAILED' -Started ([DateTime]::UtcNow) -ErrorCode 'DISRUPTION_WORKER_EXCEPTION' -ErrorMessage $_.Exception.Message -Expected 'Logoff and reboot orchestration' -Actual 'Unhandled worker failure' -Verification 'FAIL'
        }
    } catch { }
}
finally {
    try { & "$env:SystemRoot\System32\schtasks.exe" /Delete /TN $TaskName /F | Out-Null } catch { }
    try { Remove-Item -LiteralPath $PSCommandPath -Force -ErrorAction SilentlyContinue } catch { }
}
'

$script:StateWriteEnabled = $false
$script:State = [ordered]@{
schemaVersion=3;scriptVersion=$ScriptVersion;status='INITIALIZING';operation='LOCKDOWN';scope=$null
computer=$env:COMPUTERNAME;startedUtc=([DateTime]::UtcNow.ToString('o'));completedUtc=$null
requestedTargets=@();targets=@()
laps=[ordered]@{requested=[bool]$SaveLaps;detected=$false;verified=$false;accountName=$null;accountSid=$null;policySource=$null;verificationLevel=$null;accountResolutionSource=$null;lastPolicySuccessUtc=$null;lastBackupSuccessUtc=$null;lastLocalUpdateUtc=$null;blockingDenyRights=@();validationError=$null}
originalState=[ordered]@{cachedLogonsCount=$null;netlogon=$null;kdcProxy=$null;userRights=@()}
evidence=[ordered]@{sessions=@();processes=@();scheduledTasks=@();services=@();networkConnections=@()}
actions=[ordered]@{
changesApplied=$false;cachedDomainLogon='NOT_STARTED';denyRights='NOT_STARTED';protectedIdentityCount=0
scopeGuard=[ordered]@{mode='NOT_APPLICABLE';status='NOT_STARTED';principals=@();verifiedCount=0}
domainAuthIsolation='NOT_APPLICABLE';domainContext=$null;firewallEngine=$null
authFirewall=[ordered]@{mode='NOT_APPLICABLE';domainName=$null;dcNames=@();remoteAddresses=@();ruleDefinitions=@();warningCode=$null}
sessionTelemetry=[ordered]@{targetSessionsFound=0;logoffRequestsAccepted=0;logoffRequestsFailed=0;confirmedClosedBeforeReboot=0;remainingSessionIdsBeforeReboot=@();targetIdentitiesWithoutSessionAfterReboot=0;remainingTargetSessionsAfterReboot=@();pendingLogoffSessionIds=@()}
rebootScheduled=$false;rebootDelaySeconds=$RebootDelaySeconds
rebootScheduledUtc=$null;bootTimeBefore=$null;executionContext=[ordered]@{identityName=$null;identitySid=$null;processSessionId=$null;isSystem=$false;isAdministrator=$false};disruptionWorker=[ordered]@{taskName=$DisruptionTaskName;scriptPath=$DisruptionWorkerPath;installed=$false;started=$false};stateFile=$StatePath
}
stages=@();warnings=@();errors=@()
}

function Get-UtcTimestamp {
return [DateTime]::UtcNow.ToString('o')
}

function Add-WarningRecord {
param([string]$Code, [string]$Message)
$script:State.warnings += [pscustomobject][ordered]@{
code = $Code
message = $Message
timestampUtc = Get-UtcTimestamp
}
}

function Add-ErrorRecord {
param([string]$Code, [string]$Message, [string]$Stage)
$script:State.errors += [pscustomobject][ordered]@{
code = $Code
message = $Message
stage = $Stage
timestampUtc = Get-UtcTimestamp
}
}

function Set-SecureDirectoryAcl {
param([Parameter(Mandatory = $true)][string]$Path)

if (-not (Test-Path -LiteralPath $Path)) {
$null = New-Item -Path $Path -ItemType Directory -Force
}

$systemSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-18')
$administratorsSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
$inheritance = [System.Security.AccessControl.InheritanceFlags]::ContainerInherit -bor
[System.Security.AccessControl.InheritanceFlags]::ObjectInherit
$propagation = [System.Security.AccessControl.PropagationFlags]::None
$allow = [System.Security.AccessControl.AccessControlType]::Allow
$fullControl = [System.Security.AccessControl.FileSystemRights]::FullControl

$security = [System.Security.AccessControl.DirectorySecurity]::new()
$security.SetAccessRuleProtection($true, $false)
$security.SetOwner($systemSid)
$security.AddAccessRule(([System.Security.AccessControl.FileSystemAccessRule]::new($systemSid, $fullControl, $inheritance, $propagation, $allow)))
$security.AddAccessRule(([System.Security.AccessControl.FileSystemAccessRule]::new($administratorsSid, $fullControl, $inheritance, $propagation, $allow)))

$directoryInfo = [System.IO.DirectoryInfo]::new($Path)
$directoryInfo.SetAccessControl($security)
}

function Set-SecureFileAcl {
param([Parameter(Mandatory = $true)][string]$Path)

if (-not (Test-Path -LiteralPath $Path)) { return }

$systemSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-18')
$administratorsSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
$allow = [System.Security.AccessControl.AccessControlType]::Allow
$fullControl = [System.Security.AccessControl.FileSystemRights]::FullControl

$security = [System.Security.AccessControl.FileSecurity]::new()
$security.SetAccessRuleProtection($true, $false)
$security.SetOwner($systemSid)
$security.AddAccessRule(([System.Security.AccessControl.FileSystemAccessRule]::new($systemSid, $fullControl, $allow)))
$security.AddAccessRule(([System.Security.AccessControl.FileSystemAccessRule]::new($administratorsSid, $fullControl, $allow)))

$fileInfo = [System.IO.FileInfo]::new($Path)
$fileInfo.SetAccessControl($security)
}

function Write-StateCheckpoint {
if (-not $script:StateWriteEnabled) { return }

Set-SecureDirectoryAcl -Path $BaseDirectory
$json = $script:State | ConvertTo-Json -Depth 24
$utf8NoBom = [System.Text.UTF8Encoding]::new($false)
[System.IO.File]::WriteAllText($TemporaryStatePath, $json, $utf8NoBom)
Set-SecureFileAcl -Path $TemporaryStatePath
Move-Item -LiteralPath $TemporaryStatePath -Destination $StatePath -Force
Set-SecureFileAcl -Path $StatePath
}

function Add-StageResult {
param(
[Parameter(Mandatory = $true)][string]$Name,
[Parameter(Mandatory = $true)][ValidateSet('SUCCESS','WARNING','FAILED','SKIPPED','NOT_APPLICABLE','PENDING')][string]$Status,
[datetime]$Started,
[int]$AffectedCount = 0,
[string]$ErrorCode = $null,
[string]$ErrorMessage = $null,
[string]$Message = $null,
[string]$Expected = $null,
[string]$Actual = $null,
[ValidateSet('PASS','WARNING','FAIL','PENDING','NOT_CHECKED','NOT_APPLICABLE')][string]$Verification = 'NOT_CHECKED'
)
if ($null -eq $Started) { $Started = [DateTime]::UtcNow }
if ($Verification -eq 'NOT_CHECKED') {
$Verification = switch ($Status) { 'SUCCESS' {'PASS'} 'WARNING' {'WARNING'} 'FAILED' {'FAIL'} 'NOT_APPLICABLE' {'NOT_APPLICABLE'} default {'NOT_CHECKED'} }
}
$completed = [DateTime]::UtcNow
$script:State.stages += [pscustomobject][ordered]@{
name=$Name;status=$Status;verification=$Verification
startedUtc=$Started.ToString('o');completedUtc=$completed.ToString('o')
durationMs=[int][Math]::Max(0,($completed-$Started).TotalMilliseconds);affectedCount=$AffectedCount
expected=$Expected;actual=$Actual;errorCode=$ErrorCode;errorMessage=$ErrorMessage;message=$Message
}
if ($Status -eq 'WARNING' -and $ErrorCode) { Add-WarningRecord -Code $ErrorCode -Message $ErrorMessage }
elseif ($Status -eq 'FAILED' -and $ErrorCode) { Add-ErrorRecord -Code $ErrorCode -Message $ErrorMessage -Stage $Name }
Write-StateCheckpoint
}
function Get-StageStatus {
param([string]$Name)
$item=@($script:State.stages | Where-Object {$_.name -eq $Name} | Select-Object -Last 1)
if($item.Count -eq 0){return 'NOT_REACHED'}
return [string]$item[0].status
}
function Convert-StageStatusForRemarks {
param([string]$Status)
switch($Status){'SUCCESS'{'PASS'}'WARNING'{'WARN'}'FAILED'{'FAIL'}'PENDING'{'PENDING'}'NOT_APPLICABLE'{'N/A'}'SKIPPED'{'SKIP'}default{'NOT_REACHED'}}
}
function Get-CombinedCheckForRemarks {
param([string[]]$Stages)
$statuses=@($Stages | ForEach-Object { Get-StageStatus $_ })
if('FAILED' -in $statuses){return 'FAIL'}
if('WARNING' -in $statuses){return 'WARN'}
if('PENDING' -in $statuses){return 'PENDING'}
if(@($statuses | Where-Object {$_ -eq 'SUCCESS'}).Count -gt 0 -and @($statuses | Where-Object {$_ -eq 'NOT_REACHED'}).Count -eq 0){return 'PASS'}
if(@($statuses | Where-Object {$_ -eq 'NOT_APPLICABLE'}).Count -eq $statuses.Count){return 'N/A'}
if('SKIPPED' -in $statuses){return 'SKIP'}
return 'NOT_REACHED'
}
function Get-OverallStatus {
if($script:State.status -eq 'FAILED_PRECHECK'){return 'FAILED_PRECHECK'}
$failed=@($script:State.stages | Where-Object {$_.status -eq 'FAILED'}).Count
$warnings=@($script:State.stages | Where-Object {$_.status -eq 'WARNING'}).Count
if($failed -gt 0 -and -not $script:State.actions.changesApplied){return 'FAILED'}
if($failed -gt 0){return 'PARTIAL_FAILURE'}
if($warnings -gt 0 -or @($script:State.warnings).Count -gt 0){return 'SUCCESS_WITH_WARNINGS'}
if($script:State.status -eq 'ACTIVE_DISRUPTION_PENDING'){return 'SUCCESS_DISRUPTION_STARTED'}
if($script:State.status -eq 'ACTIVE_PENDING_REBOOT'){return 'SUCCESS_REBOOT_QUEUED'}
return 'SUCCESS'
}

function Write-Remarks {
$resolved=@($script:State.targets | Where-Object {$_.resolveStatus -eq 'SUCCESS'}).Count
$requested=@($script:State.requestedTargets).Count
$allScope=($script:State.scope -like 'ALL_*')
$unresolved=if($allScope){0}else{[Math]::Max(0,($requested-$resolved))}

if($allScope){
$discoveryStatus=Get-StageStatus 'DISCOVER_ALL_USERS'
$targetSummary=if($discoveryStatus -eq 'NOT_REACHED'){'NOT_REACHED'}else{"$resolved discovered"}
}else{
$targetSummary="$resolved/$requested"
}

$failedStages=@($script:State.stages | Where-Object {$_.status -eq 'FAILED'} | ForEach-Object {$_.name})
$warningStages=@($script:State.stages | Where-Object {$_.status -eq 'WARNING' -and $_.name -ne 'RESOLVE_TARGETS'} | ForEach-Object {$_.name})
$result=if($script:State.status -eq 'FAILED_PRECHECK'){'FAILED_PRECHECK'}
elseif($failedStages.Count -gt 0 -and -not [bool]$script:State.actions.changesApplied){'FAILED'}
elseif($failedStages.Count -gt 0){'ENFORCEMENT_INCOMPLETE'}
elseif($warningStages.Count -gt 0 -or @($script:State.warnings).Count -gt 0 -or $unresolved -gt 0){'ENFORCEMENT_APPLIED_WITH_WARNINGS'}
else{'ENFORCEMENT_APPLIED'}

$auth=(Get-CombinedCheckForRemarks @('DISABLE_NETLOGON','DISABLE_KDC_PROXY','APPLY_AUTH_FIREWALL'))
if($script:State.scope -like 'ALL_*' -and $auth -eq 'PASS' -and $script:State.actions.authFirewall -and $script:State.actions.authFirewall.warningCode){$auth='PASS_WITH_FALLBACK'}

$guardStage=Get-StageStatus 'PREPARE_SCOPE_GUARD'
$guard=if(-not $allScope){'N/A'}
elseif($guardStage -eq 'NOT_REACHED'){'NOT_REACHED'}
elseif([string]$script:State.actions.scopeGuard.status -eq 'VERIFIED'){'PASS'}
elseif([string]$script:State.actions.scopeGuard.status -eq 'PREPARED'){'PENDING'}
elseif([string]$script:State.actions.scopeGuard.status -eq 'UNAVAILABLE'){'WARN'}
else{'FAIL'}

$summary="EmergencyLockdown v$ScriptVersion | $result | Scope=$($script:State.scope) | Targets=$targetSummary"
if([bool]$SaveLaps){$summary += " | LAPS=$(Convert-StageStatusForRemarks (Get-StageStatus 'DETECT_LAPS'))"}
$summary += " | Guard=$guard | Rights=$(Convert-StageStatusForRemarks (Get-StageStatus 'APPLY_DENY_RIGHTS')) | CacheConfig=$(Convert-StageStatusForRemarks (Get-StageStatus 'DISABLE_CACHED_DOMAIN_LOGON')) | AuthDefense=$auth"
if($unresolved -gt 0){$summary += " | Unresolved=$unresolved"}
if($failedStages.Count -gt 0){$summary += " | Failed=$($failedStages -join ',')"}
$contextWarning=@($warningStages | Where-Object {$_ -eq 'DISCOVER_DOMAIN_CONTEXT'}).Count -gt 0
if($contextWarning){$summary += " | Context=PARTIAL"}
$otherWarnings=@($warningStages | Where-Object {$_ -ne 'DISCOVER_DOMAIN_CONTEXT'})
if($otherWarnings.Count -gt 0){$summary += " | Warn=$($otherWarnings -join ',')"}
$summary += " | State=$StatePath"
[Console]::Out.WriteLine($summary)
}

function Test-SecurePathAcl {
param([string]$Path)
$acl=Get-Acl -LiteralPath $Path -ErrorAction Stop
$ownerSid=try{([System.Security.Principal.NTAccount]$acl.Owner).Translate([System.Security.Principal.SecurityIdentifier]).Value}catch{[string]$acl.Owner}
$allowed=@('S-1-5-18','S-1-5-32-544');$unexpected=@()
foreach($rule in @($acl.Access)){
$sid=try{$rule.IdentityReference.Translate([System.Security.Principal.SecurityIdentifier]).Value}catch{[string]$rule.IdentityReference}
if($rule.AccessControlType -ne 'Allow' -or $sid -notin $allowed){$unexpected += $sid}
}
[pscustomobject]@{Pass=($acl.AreAccessRulesProtected -and $ownerSid -eq 'S-1-5-18' -and $unexpected.Count -eq 0);Owner=$ownerSid;Protected=[bool]$acl.AreAccessRulesProtected;Unexpected=($unexpected -join ';')}
}

function Test-IsSystemOrAdministrator {
$identity = [System.Security.Principal.WindowsIdentity]::GetCurrent()
if ($identity.User.Value -eq 'S-1-5-18') { return $true }
$principal = [System.Security.Principal.WindowsPrincipal]::new($identity)
return $principal.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
}

function Get-LocalMachineSidPrefix {
try {
$local = @(Get-CimInstance Win32_UserAccount -Filter "LocalAccount=True" -ErrorAction Stop |
Where-Object { $_.SID -like 'S-1-5-21-*' } |
Select-Object -First 1)
if ($local.Count -eq 0) { return $null }
return ($local[0].SID -replace '-\d+$','')
}
catch { return $null }
}

function Get-ProfileRegistryRecords {
$records = @()
$root = 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList'
if (-not (Test-Path $root)) { return $records }

foreach ($key in @(Get-ChildItem -Path $root -ErrorAction SilentlyContinue)) {
try {
$property = Get-ItemProperty -Path $key.PSPath -Name ProfileImagePath -ErrorAction Stop
$expanded = [Environment]::ExpandEnvironmentVariables([string]$property.ProfileImagePath)
$records += [pscustomobject]@{
sid = $key.PSChildName
profilePath = $expanded
leafName = Split-Path -Path $expanded -Leaf
}
}
catch { }
}
return $records
}

function Normalize-AccountName {
param([string]$Name)
$value = $Name.Trim()
if ($value.StartsWith('.\')) {
return "$env:COMPUTERNAME\$($value.Substring(2))"
}
return $value
}

function Resolve-AccountIdentity {
param([Parameter(Mandatory = $true)][string]$RequestedName)

$normalized = Normalize-AccountName -Name $RequestedName
$result = [ordered]@{
requested=$RequestedName;normalized=$normalized;sid=$null;accountName=$null;isLocal=$false
profileFound=$false;profilePath=$null;resolutionMethod=$null;resolveStatus='NOT_RESOLVED'
errorCode=$null;errorMessage=$null;sources=@('EXPLICIT_INPUT');persistenceEligible=$true
}

$resolvedFromActiveSession = $false
if ($normalized -notmatch '^S-\d-\d+(-\d+)+$' -and $normalized.Contains('\')) {
$parts=$normalized.Split('\',2)
$domainPart=[string]$parts[0]
$username=[string]$parts[1]
if($domainPart -notin @('.', $env:COMPUTERNAME)) {
try {
$sessionMatches=@([EmergencySecurity.Native]::GetSessions() | Where-Object {
-not [string]::IsNullOrWhiteSpace([string]$_.UserName) -and
("$($_.DomainName)\$($_.UserName)" -ieq $normalized)
})
if($sessionMatches.Count -gt 0) {
$localSidPrefix=Get-LocalMachineSidPrefix
$profileMatches=@(Get-ProfileRegistryRecords | Where-Object {
$_.leafName -ieq $username -and (-not $localSidPrefix -or $_.sid -notlike "$localSidPrefix-*")
})
if($profileMatches.Count -eq 1) {
$result.sid=$profileMatches[0].sid;$result.accountName=$normalized
$result.profileFound=$true;$result.profilePath=$profileMatches[0].profilePath
$result.resolutionMethod='ACTIVE_SESSION_PROFILE_MATCH';$result.resolveStatus='SUCCESS'
$resolvedFromActiveSession=$true
}
}
} catch { }
}
}

if(-not $resolvedFromActiveSession) {
try {
if ($normalized -match '^S-\d-\d+(-\d+)+$') {
$sidObject=[System.Security.Principal.SecurityIdentifier]::new($normalized)
$result.sid=$sidObject.Value
try{$result.accountName=$sidObject.Translate([System.Security.Principal.NTAccount]).Value}catch{$result.accountName=$normalized}
$result.resolutionMethod='SID_INPUT';$result.resolveStatus='SUCCESS'
} else {
$account=[System.Security.Principal.NTAccount]::new($normalized)
$sidObject=$account.Translate([System.Security.Principal.SecurityIdentifier])
$result.sid=$sidObject.Value;$result.accountName=$normalized
$result.resolutionMethod='ACCOUNT_TRANSLATION';$result.resolveStatus='SUCCESS'
}
}
catch {
$username=if($normalized.Contains('\')){$normalized.Split('\')[-1]}else{$normalized}
$domainPart=if($normalized.Contains('\')){$normalized.Split('\')[0]}else{$null}
$localSidPrefix=Get-LocalMachineSidPrefix
$profiles=@(Get-ProfileRegistryRecords)
$matches=@($profiles | Where-Object {$_.leafName -ieq $username -or $_.leafName -like "$username.*" -or $_.leafName -like "$username-*"})
if($domainPart -and $domainPart -notin @('.', $env:COMPUTERNAME) -and $localSidPrefix){$matches=@($matches | Where-Object {$_.sid -notlike "$localSidPrefix-*"})}
if($matches.Count -eq 1){
$result.sid=$matches[0].sid;$result.accountName=$normalized;$result.profileFound=$true
$result.profilePath=$matches[0].profilePath;$result.resolutionMethod='UNIQUE_PROFILE_MATCH';$result.resolveStatus='SUCCESS'
} else {
$result.errorCode=if($matches.Count -gt 1){'AMBIGUOUS_PROFILE_MATCH'}else{'SID_NOT_RESOLVED'}
$result.errorMessage=$_.Exception.Message
}
}
}

if($result.resolveStatus -eq 'SUCCESS'){
$localPrefix=Get-LocalMachineSidPrefix
if($localPrefix -and $result.sid -like "$localPrefix-*"){$result.isLocal=$true}
if(-not $result.profileFound){
$profile=@(Get-ProfileRegistryRecords | Where-Object {$_.sid -eq $result.sid} | Select-Object -First 1)
if($profile.Count -gt 0){$result.profileFound=$true;$result.profilePath=$profile[0].profilePath}
}
}
return [pscustomobject]$result
}

function Test-IsExcludedSystemSid {
param([string]$Sid, [string]$AccountName)

if ($Sid -in @('S-1-5-18','S-1-5-19','S-1-5-20')) { return $true }
if ($Sid -like 'S-1-5-80-*') { return $true }
if ($Sid -like 'S-1-5-82-*') { return $true }
if ($AccountName -like 'NT SERVICE\*') { return $true }
if ($AccountName -like 'NT AUTHORITY\*') { return $true }
if ($AccountName -match '\$$') { return $true }
return $false
}

function Get-DiscoveredHumanAccounts {
$accounts = @()

try {
foreach ($local in @(Get-CimInstance Win32_UserAccount -Filter "LocalAccount=True" -ErrorAction Stop)) {
$name = "$env:COMPUTERNAME\$($local.Name)"
if (-not (Test-IsExcludedSystemSid -Sid $local.SID -AccountName $name)) {
$accounts += [pscustomobject]@{
requested = $name
normalized = $name
sid = $local.SID
accountName = $name
isLocal = $true
profileFound = $false
profilePath = $null
resolutionMethod = 'LOCAL_SAM'
resolveStatus = 'SUCCESS'
errorCode = $null
errorMessage = $null
sources = @('LOCAL_SAM')
persistenceEligible = $false
}
}
}
}
catch { }

$localSidPrefix=Get-LocalMachineSidPrefix
foreach ($profile in @(Get-ProfileRegistryRecords)) {
if ($profile.sid -notmatch '^S-1-5-21-') { continue }
$existing = @($accounts | Where-Object { $_.sid -eq $profile.sid })
if ($existing.Count -gt 0) {
$existing[0].profileFound = $true
$existing[0].profilePath = $profile.profilePath
$existing[0].persistenceEligible = $true
$existing[0].sources = @($existing[0].sources + 'PROFILE_LIST' | Select-Object -Unique)
continue
}

# Do not translate domain SIDs here. Translation can block for a long time while the
# device is away from a DC. The SID is the enforcement key; the profile leaf is only
# a readable label and is improved later from an active session when available.
$name = if($localSidPrefix -and $profile.sid -like "$localSidPrefix-*") {
"$env:COMPUTERNAME\$($profile.leafName)"
} else {
[string]$profile.leafName
}

if (-not (Test-IsExcludedSystemSid -Sid $profile.sid -AccountName $name)) {
$accounts += [pscustomobject]@{
requested = $name
normalized = $name
sid = $profile.sid
accountName = $name
isLocal = [bool]($localSidPrefix -and $profile.sid -like "$localSidPrefix-*")
profileFound = $true
profilePath = $profile.profilePath
resolutionMethod = 'PROFILE_LIST'
resolveStatus = 'SUCCESS'
errorCode = $null
errorMessage = $null
sources = @('PROFILE_LIST')
persistenceEligible = $true
}
}
}

return @($accounts | Group-Object sid | ForEach-Object { $_.Group | Select-Object -First 1 })
}

function Get-ObjectPropertyValue {
param([object]$Object, [string]$Name, $DefaultValue = $null)
if ($null -eq $Object) { return $DefaultValue }
$property = $Object.PSObject.Properties[$Name]
if ($null -eq $property) { return $DefaultValue }
return $property.Value
}

function ConvertTo-NullableInt32Flexible {
param([object]$Value)
if ($null -eq $Value) { return $null }
$text = ([string]$Value).Trim()
if ([string]::IsNullOrWhiteSpace($text)) { return $null }

try {
if ($text -match '^0[xX]([0-9A-Fa-f]+)$') {
return [Convert]::ToInt32($matches[1], 16)
}

$parsed = 0
if ([int]::TryParse($text, [ref]$parsed)) {
return $parsed
}
}
catch { }

return $null
}

function Get-ActiveLapsPolicy {
$roots = @(
[pscustomobject]@{ Path='HKLM:\Software\Microsoft\Policies\LAPS'; Source='CSP' },
[pscustomobject]@{ Path='HKLM:\Software\Microsoft\Windows\CurrentVersion\Policies\LAPS'; Source='GPO' },
[pscustomobject]@{ Path='HKLM:\Software\Microsoft\Windows\CurrentVersion\LAPS\Config'; Source='LOCAL_CONFIG' }
)

foreach ($root in $roots) {
if (-not (Test-Path $root.Path)) { continue }
$item = Get-ItemProperty -Path $root.Path -ErrorAction SilentlyContinue
$definedProperties = @($item.PSObject.Properties | Where-Object { $_.Name -notlike 'PS*' })
if ($definedProperties.Count -gt 0) {
return [pscustomobject]@{ Path=$root.Path; Source=$root.Source; Values=$item }
}
}

$legacyPath = 'HKLM:\Software\Policies\Microsoft Services\AdmPwd'
if (Test-Path $legacyPath) {
$item = Get-ItemProperty -Path $legacyPath -ErrorAction SilentlyContinue
if ($null -ne $item) {
return [pscustomobject]@{ Path=$legacyPath; Source='LEGACY_LAPS'; Values=$item }
}
}

return $null
}

function Get-LocalAdministratorsMemberSids {
$sids = @()
$group = @()
try {
$group = @(Get-CimInstance Win32_Group -Filter "LocalAccount=True AND SID='S-1-5-32-544'" -ErrorAction Stop | Select-Object -First 1)
if ($group.Count -eq 0) { return $sids }
try { $sids = @([EmergencySecurity.Native]::GetLocalGroupMemberSids([string]$group[0].Name)) } catch { }
if ($sids.Count -eq 0) {
try {
foreach ($member in @(Get-CimAssociatedInstance -InputObject $group[0] -Association Win32_GroupUser -ErrorAction Stop)) {
if ($member.SID) { $sids += [string]$member.SID }
}
} catch { }
}
}
catch { }
return @($sids | Where-Object { $_ } | Select-Object -Unique)
}

function Get-VerifiedLapsAccount {
$policy=Get-ActiveLapsPolicy
if($null -eq $policy){return [pscustomobject]@{Verified=$false;ErrorCode='LAPS_POLICY_NOT_FOUND';ErrorMessage='No Windows LAPS or legacy-emulation policy was found.'}}

$backupDirectory=$null
if($policy.Source -eq 'LEGACY_LAPS'){
$enabled=Get-ObjectPropertyValue -Object $policy.Values -Name 'AdmPwdEnabled'
if($null -ne $enabled -and [int]$enabled -eq 0){return [pscustomobject]@{Verified=$false;ErrorCode='LAPS_POLICY_DISABLED';ErrorMessage='Legacy LAPS policy is disabled.'}}
$backupDirectory=2
}else{
$backupDirectory=Get-ObjectPropertyValue -Object $policy.Values -Name 'BackupDirectory'
if($null -eq $backupDirectory -or [int]$backupDirectory -eq 0){return [pscustomobject]@{Verified=$false;ErrorCode='LAPS_BACKUP_DISABLED';ErrorMessage='Windows LAPS BackupDirectory is disabled or undefined.'}}
}

$passwordAge=Get-ObjectPropertyValue -Object $policy.Values -Name 'PasswordAgeDays' -DefaultValue 30
try{$maxAgeDays=[Math]::Max(45,([int]$passwordAge*2)+7)}catch{$maxAgeDays=90}
$cutoff=(Get-Date).AddDays(-$maxAgeDays)
$policyIds=if($policy.Source -eq 'LEGACY_LAPS'){@(10023)}elseif([int]$backupDirectory -eq 1){@(10022)}else{@(10021)}
$backupIds=if([int]$backupDirectory -eq 1){@(10029)}else{@(10018)}
$policyEvent=$null;$backupEvent=$null;$localEvent=$null
try{$policyEvent=Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-LAPS/Operational';Id=$policyIds;StartTime=$cutoff} -MaxEvents 20 -ErrorAction Stop | Sort-Object TimeCreated -Descending | Select-Object -First 1}catch{}
try{$backupEvent=Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-LAPS/Operational';Id=$backupIds;StartTime=$cutoff} -MaxEvents 20 -ErrorAction Stop | Sort-Object TimeCreated -Descending | Select-Object -First 1}catch{}
try{$localEvent=Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-LAPS/Operational';Id=10020;StartTime=$cutoff} -MaxEvents 20 -ErrorAction Stop | Sort-Object TimeCreated -Descending | Select-Object -First 1}catch{}
if($null -eq $policyEvent){return [pscustomobject]@{Verified=$false;ErrorCode='LAPS_EFFECTIVE_POLICY_EVENT_NOT_FOUND';ErrorMessage="No recent effective LAPS policy event was found within $maxAgeDays days."}}
if($null -eq $backupEvent){return [pscustomobject]@{Verified=$false;ErrorCode='LAPS_BACKUP_SUCCESS_EVENT_NOT_FOUND';ErrorMessage="No recent successful LAPS directory-backup event was found within $maxAgeDays days."}}
if($null -eq $localEvent){return [pscustomobject]@{Verified=$false;ErrorCode='LAPS_LOCAL_UPDATE_EVENT_NOT_FOUND';ErrorMessage="No recent successful LAPS local-account update event was found within $maxAgeDays days."}}

$accountName=$null;$accountRid=$null
$accountResolutionSource=$null
$policyAccountName=$null
foreach($propertyName in @('AdministratorAccountName','AdminAccountName')){
$candidate=Get-ObjectPropertyValue -Object $policy.Values -Name $propertyName
if($null -ne $candidate -and -not [string]::IsNullOrWhiteSpace([string]$candidate)){
$policyAccountName=([string]$candidate).Trim()
break
}
}

try{
[xml]$eventXml=$localEvent.ToXml()
$eventData=@{}
foreach($item in @($eventXml.Event.EventData.Data)){
$value=([string]$item.'#text').Trim()
if([string]::IsNullOrWhiteSpace($value)){continue}
$rawName=[string]$item.Name
if(-not [string]::IsNullOrWhiteSpace($rawName)){
$normalizedKey=($rawName -replace '[^A-Za-z0-9]','').ToLowerInvariant()
if(-not $eventData.ContainsKey($normalizedKey)){$eventData[$normalizedKey]=$value}
}
}

foreach($key in @('accountname','managedaccountname','localadministratoraccountname')){
if($eventData.ContainsKey($key)-and -not [string]::IsNullOrWhiteSpace([string]$eventData[$key])){
$accountName=([string]$eventData[$key]).Trim()
$accountResolutionSource='EVENT_XML_ACCOUNT_NAME'
break
}
}
foreach($key in @('accountrid','rid')){
if($eventData.ContainsKey($key)){
$parsedRid=ConvertTo-NullableInt32Flexible -Value $eventData[$key]
if($null -ne $parsedRid){$accountRid=$parsedRid;$accountResolutionSource='EVENT_XML_ACCOUNT_RID';break}
}
}

# Rendered event messages may indent the Account name/RID lines.
if([string]::IsNullOrWhiteSpace($accountName) -and $localEvent.Message -match '(?im)^\s*Account name:\s*(.+?)\s*$'){
$accountName=$matches[1].Trim()
$accountResolutionSource='EVENT_RENDERED_ACCOUNT_NAME'
}
if($null -eq $accountRid -and $localEvent.Message -match '(?im)^\s*Account RID:\s*(0[xX][0-9A-Fa-f]+|\d+)\s*$'){
$accountRid=ConvertTo-NullableInt32Flexible -Value $matches[1]
if($null -ne $accountRid){$accountResolutionSource='EVENT_RENDERED_ACCOUNT_RID'}
}
}catch{
return [pscustomobject]@{Verified=$false;ErrorCode='LAPS_MANAGED_ACCOUNT_EVENT_UNREADABLE';ErrorMessage=$_.Exception.Message}
}

# A rendered 10021 policy event provides a second local source for the configured account name.
$policyEventAccountName=$null
if($policyEvent.Message -match '(?im)^\s*Local administrator account name:\s*(.*?)\s*$'){
$candidate=([string]$matches[1]).Trim()
if(-not [string]::IsNullOrWhiteSpace($candidate)){$policyEventAccountName=$candidate}
}

# Locale-independent fallback: combine the current effective policy with paired successful
# local-account and directory-backup events from the same processing cycle.
if([string]::IsNullOrWhiteSpace($accountName) -and
-not [string]::IsNullOrWhiteSpace($policyAccountName)){
$eventPairDelta=[Math]::Abs(($localEvent.TimeCreated-$backupEvent.TimeCreated).TotalMinutes)
if($eventPairDelta -le 15){
if([string]::IsNullOrWhiteSpace($policyEventAccountName) -or $policyAccountName -ieq $policyEventAccountName){
$accountName=$policyAccountName
$accountResolutionSource='CURRENT_POLICY_PLUS_PAIRED_SUCCESS_EVENTS'
}
}
}

# An empty managed-account name means the built-in Administrator account (RID 500)
# when automatic account management isn't enabled.
if($null -eq $accountRid -and [string]::IsNullOrWhiteSpace($accountName)){
$automaticManagement=Get-ObjectPropertyValue -Object $policy.Values -Name 'AutomaticAccountManagementEnabled' -DefaultValue 0
try{$automaticManagementEnabled=([int]$automaticManagement -ne 0)}catch{$automaticManagementEnabled=$false}
if(-not $automaticManagementEnabled){$accountRid=500;$accountResolutionSource='BUILTIN_ADMINISTRATOR_POLICY_DEFAULT'}
}

if($null -eq $accountRid -and [string]::IsNullOrWhiteSpace($accountName)){
return [pscustomobject]@{Verified=$false;ErrorCode='LAPS_MANAGED_ACCOUNT_UNRESOLVED';ErrorMessage='The successful LAPS local-update event and effective policy did not identify the managed account.'}
}

$localAccounts=@(Get-CimInstance Win32_UserAccount -Filter 'LocalAccount=True' -ErrorAction SilentlyContinue)
$account=@()
if($accountRid){$account=@($localAccounts | Where-Object {$_.SID -match "-$accountRid$"} | Select-Object -First 1)}
if($account.Count -eq 0 -and -not [string]::IsNullOrWhiteSpace($accountName)){$account=@($localAccounts | Where-Object {$_.Name -ieq $accountName} | Select-Object -First 1)}
if($account.Count -eq 0){return [pscustomobject]@{Verified=$false;ErrorCode='LAPS_ACCOUNT_NOT_FOUND';ErrorMessage='The LAPS-managed local account identified by event evidence could not be found.'}}

$adminSids=@(Get-LocalAdministratorsMemberSids)
$isAdmin=([string]$account[0].SID -in $adminSids)
$isEnabled=(-not [bool]$account[0].Disabled)
if(-not $isEnabled){return [pscustomobject]@{Verified=$false;ErrorCode='LAPS_ACCOUNT_DISABLED';ErrorMessage='The LAPS-managed local account is disabled.'}}
if(-not $isAdmin){return [pscustomobject]@{Verified=$false;ErrorCode='LAPS_ACCOUNT_NOT_ADMIN';ErrorMessage='The LAPS-managed local account is not a member of local Administrators.'}}

[pscustomobject]@{
Verified=$true;AccountName="$env:COMPUTERNAME\$($account[0].Name)";AccountSid=[string]$account[0].SID
PolicySource=$policy.Source;VerificationLevel='EVENT_CONFIRMED_DIRECTORY_BACKUP_AND_LOCAL_UPDATE';AccountResolutionSource=$accountResolutionSource
LastPolicySuccessUtc=$policyEvent.TimeCreated.ToUniversalTime().ToString('o')
LastBackupSuccessUtc=$backupEvent.TimeCreated.ToUniversalTime().ToString('o')
LastLocalUpdateUtc=$localEvent.TimeCreated.ToUniversalTime().ToString('o')
ErrorCode=$null;ErrorMessage=$null
}
}

function Initialize-NativeTypes {
if ('EmergencySecurity.Native' -as [type]) { return }

$source = @'
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Security.Principal;

namespace EmergencySecurity
{
public static class Native
{
[StructLayout(LayoutKind.Sequential)]
private struct LSA_OBJECT_ATTRIBUTES
{
public int Length;
public IntPtr RootDirectory;
public IntPtr ObjectName;
public uint Attributes;
public IntPtr SecurityDescriptor;
public IntPtr SecurityQualityOfService;
}

[StructLayout(LayoutKind.Sequential)]
private struct LSA_UNICODE_STRING
{
public ushort Length;
public ushort MaximumLength;
public IntPtr Buffer;
}

[DllImport("advapi32.dll", SetLastError = true)]
private static extern uint LsaOpenPolicy(IntPtr SystemName, ref LSA_OBJECT_ATTRIBUTES ObjectAttributes, uint DesiredAccess, out IntPtr PolicyHandle);

[DllImport("advapi32.dll")]
private static extern uint LsaAddAccountRights(IntPtr PolicyHandle, IntPtr AccountSid, LSA_UNICODE_STRING[] UserRights, uint CountOfRights);

[DllImport("advapi32.dll")]
private static extern uint LsaRemoveAccountRights(IntPtr PolicyHandle, IntPtr AccountSid, bool AllRights, LSA_UNICODE_STRING[] UserRights, uint CountOfRights);

[DllImport("advapi32.dll")]
private static extern uint LsaEnumerateAccountRights(IntPtr PolicyHandle, IntPtr AccountSid, out IntPtr UserRights, out uint CountOfRights);

[DllImport("advapi32.dll")]
private static extern uint LsaNtStatusToWinError(uint Status);

[DllImport("advapi32.dll")]
private static extern uint LsaClose(IntPtr PolicyHandle);

[DllImport("advapi32.dll")]
private static extern uint LsaFreeMemory(IntPtr Buffer);

[DllImport("Netapi32.dll", CharSet = CharSet.Unicode)]
private static extern int NetLocalGroupGetMembers(string servername, string localgroupname, int level, out IntPtr bufptr, int prefmaxlen, out int entriesread, out int totalentries, ref IntPtr resume_handle);

[DllImport("Netapi32.dll")]
private static extern int NetApiBufferFree(IntPtr Buffer);

private const uint POLICY_LOOKUP_NAMES = 0x00000800;
private const uint POLICY_CREATE_ACCOUNT = 0x00000010;
private const uint STATUS_OBJECT_NAME_NOT_FOUND = 0xC0000034;
private const int MAX_PREFERRED_LENGTH = -1;
private const int ERROR_MORE_DATA = 234;

private static IntPtr OpenPolicy()
{
LSA_OBJECT_ATTRIBUTES loa = new LSA_OBJECT_ATTRIBUTES();
loa.Length = Marshal.SizeOf(typeof(LSA_OBJECT_ATTRIBUTES));
IntPtr handle;
uint status = LsaOpenPolicy(IntPtr.Zero, ref loa, POLICY_LOOKUP_NAMES | POLICY_CREATE_ACCOUNT, out handle);
if (status != 0)
throw new Win32Exception((int)LsaNtStatusToWinError(status));
return handle;
}

private static IntPtr SidToPtr(string sidValue)
{
SecurityIdentifier sid = new SecurityIdentifier(sidValue);
byte[] bytes = new byte[sid.BinaryLength];
sid.GetBinaryForm(bytes, 0);
IntPtr ptr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, ptr, bytes.Length);
return ptr;
}

private static LSA_UNICODE_STRING NewLsaString(string value, out IntPtr buffer)
{
buffer = Marshal.StringToHGlobalUni(value);
return new LSA_UNICODE_STRING
{
Length = (ushort)(value.Length * 2),
MaximumLength = (ushort)((value.Length + 1) * 2),
Buffer = buffer
};
}

public static string[] GetRights(string sidValue)
{
IntPtr policy = IntPtr.Zero;
IntPtr sid = IntPtr.Zero;
IntPtr rightsPtr = IntPtr.Zero;
try
{
policy = OpenPolicy();
sid = SidToPtr(sidValue);
uint count;
uint status = LsaEnumerateAccountRights(policy, sid, out rightsPtr, out count);
if (status == STATUS_OBJECT_NAME_NOT_FOUND)
return new string[0];
if (status != 0)
throw new Win32Exception((int)LsaNtStatusToWinError(status));

List<string> rights = new List<string>();
int size = Marshal.SizeOf(typeof(LSA_UNICODE_STRING));
for (int i = 0; i < count; i++)
{
IntPtr itemPtr = IntPtr.Add(rightsPtr, i * size);
LSA_UNICODE_STRING item = (LSA_UNICODE_STRING)Marshal.PtrToStructure(itemPtr, typeof(LSA_UNICODE_STRING));
string text = Marshal.PtrToStringUni(item.Buffer, item.Length / 2);
rights.Add(text);
}
return rights.ToArray();
}
finally
{
if (rightsPtr != IntPtr.Zero) LsaFreeMemory(rightsPtr);
if (sid != IntPtr.Zero) Marshal.FreeHGlobal(sid);
if (policy != IntPtr.Zero) LsaClose(policy);
}
}

public static void AddRight(string sidValue, string right)
{
IntPtr policy = IntPtr.Zero;
IntPtr sid = IntPtr.Zero;
IntPtr textBuffer = IntPtr.Zero;
try
{
policy = OpenPolicy();
sid = SidToPtr(sidValue);
LSA_UNICODE_STRING item = NewLsaString(right, out textBuffer);
uint status = LsaAddAccountRights(policy, sid, new LSA_UNICODE_STRING[] { item }, 1);
if (status != 0)
throw new Win32Exception((int)LsaNtStatusToWinError(status));
}
finally
{
if (textBuffer != IntPtr.Zero) Marshal.FreeHGlobal(textBuffer);
if (sid != IntPtr.Zero) Marshal.FreeHGlobal(sid);
if (policy != IntPtr.Zero) LsaClose(policy);
}
}

public static void RemoveRight(string sidValue, string right)
{
IntPtr policy = IntPtr.Zero;
IntPtr sid = IntPtr.Zero;
IntPtr textBuffer = IntPtr.Zero;
try
{
policy = OpenPolicy();
sid = SidToPtr(sidValue);
LSA_UNICODE_STRING item = NewLsaString(right, out textBuffer);
uint status = LsaRemoveAccountRights(policy, sid, false, new LSA_UNICODE_STRING[] { item }, 1);
if (status != 0 && status != STATUS_OBJECT_NAME_NOT_FOUND)
throw new Win32Exception((int)LsaNtStatusToWinError(status));
}
finally
{
if (textBuffer != IntPtr.Zero) Marshal.FreeHGlobal(textBuffer);
if (sid != IntPtr.Zero) Marshal.FreeHGlobal(sid);
if (policy != IntPtr.Zero) LsaClose(policy);
}
}

public enum WTS_CONNECTSTATE_CLASS
{
Active, Connected, ConnectQuery, Shadow, Disconnected, Idle, Listen, Reset, Down, Init
}

[StructLayout(LayoutKind.Sequential)]
private struct WTS_SESSION_INFO
{
public int SessionID;
public IntPtr pWinStationName;
public WTS_CONNECTSTATE_CLASS State;
}

[DllImport("wtsapi32.dll", EntryPoint = "WTSEnumerateSessionsW", CharSet = CharSet.Unicode, SetLastError = true)]
private static extern bool WTSEnumerateSessions(IntPtr hServer, int Reserved, int Version, out IntPtr ppSessionInfo, out int pCount);

[DllImport("wtsapi32.dll")]
private static extern void WTSFreeMemory(IntPtr pMemory);

[DllImport("wtsapi32.dll", EntryPoint = "WTSQuerySessionInformationW", CharSet = CharSet.Unicode, SetLastError = true)]
private static extern bool WTSQuerySessionInformation(IntPtr hServer, int SessionId, int WTSInfoClass, out IntPtr ppBuffer, out int pBytesReturned);

[DllImport("wtsapi32.dll", SetLastError = true)]
private static extern bool WTSLogoffSession(IntPtr hServer, int SessionId, bool bWait);

public class SessionInfo
{
public int SessionId { get; set; }
public string StationName { get; set; }
public string State { get; set; }
public string UserName { get; set; }
public string DomainName { get; set; }
}

private static string QuerySessionString(int sessionId, int infoClass)
{
IntPtr buffer = IntPtr.Zero;
int bytes = 0;
try
{
if (!WTSQuerySessionInformation(IntPtr.Zero, sessionId, infoClass, out buffer, out bytes) || buffer == IntPtr.Zero)
return String.Empty;
return Marshal.PtrToStringUni(buffer) ?? String.Empty;
}
finally
{
if (buffer != IntPtr.Zero) WTSFreeMemory(buffer);
}
}

public static SessionInfo[] GetSessions()
{
IntPtr buffer = IntPtr.Zero;
int count = 0;
List<SessionInfo> sessions = new List<SessionInfo>();
try
{
if (!WTSEnumerateSessions(IntPtr.Zero, 0, 1, out buffer, out count))
throw new Win32Exception(Marshal.GetLastWin32Error());
int size = Marshal.SizeOf(typeof(WTS_SESSION_INFO));
for (int i = 0; i < count; i++)
{
IntPtr itemPtr = IntPtr.Add(buffer, i * size);
WTS_SESSION_INFO item = (WTS_SESSION_INFO)Marshal.PtrToStructure(itemPtr, typeof(WTS_SESSION_INFO));
sessions.Add(new SessionInfo
{
SessionId = item.SessionID,
StationName = Marshal.PtrToStringUni(item.pWinStationName) ?? String.Empty,
State = item.State.ToString(),
UserName = QuerySessionString(item.SessionID, 5),
DomainName = QuerySessionString(item.SessionID, 7)
});
}
return sessions.ToArray();
}
finally
{
if (buffer != IntPtr.Zero) WTSFreeMemory(buffer);
}
}

public static void LogoffSession(int sessionId)
{
if (!WTSLogoffSession(IntPtr.Zero, sessionId, true))
throw new Win32Exception(Marshal.GetLastWin32Error());
}

public static string[] GetLocalGroupMemberSids(string groupName)
{
List<string> results = new List<string>();
IntPtr resume = IntPtr.Zero;
int status;
do
{
IntPtr buffer = IntPtr.Zero;
int entriesRead = 0;
int totalEntries = 0;
try
{
status = NetLocalGroupGetMembers(null, groupName, 0, out buffer, MAX_PREFERRED_LENGTH, out entriesRead, out totalEntries, ref resume);
if (status != 0 && status != ERROR_MORE_DATA)
throw new Win32Exception(status);
for (int i = 0; i < entriesRead; i++)
{
IntPtr sidPtr = Marshal.ReadIntPtr(buffer, i * IntPtr.Size);
if (sidPtr != IntPtr.Zero)
results.Add(new SecurityIdentifier(sidPtr).Value);
}
}
finally
{
if (buffer != IntPtr.Zero) NetApiBufferFree(buffer);
}
} while (status == ERROR_MORE_DATA);
return results.ToArray();
}
}
}
'@

Add-Type -TypeDefinition $source -Language CSharp -ErrorAction Stop | Out-Null
}

function Get-SessionEvidence {
$sessions = @()
$profiles=@(Get-ProfileRegistryRecords)
$localSidPrefix=Get-LocalMachineSidPrefix

foreach ($session in @([EmergencySecurity.Native]::GetSessions())) {
$accountName = $null
$sid = $null

if (-not [string]::IsNullOrWhiteSpace($session.UserName)) {
$accountName = if ([string]::IsNullOrWhiteSpace($session.DomainName)) { $session.UserName } else { "$($session.DomainName)\$($session.UserName)" }
$isLocalSession=([string]$session.DomainName -ieq $env:COMPUTERNAME -or [string]::IsNullOrWhiteSpace([string]$session.DomainName))
$matches=@($profiles | Where-Object {
$_.leafName -ieq [string]$session.UserName -and (
($isLocalSession -and $localSidPrefix -and $_.sid -like "$localSidPrefix-*") -or
(-not $isLocalSession -and (-not $localSidPrefix -or $_.sid -notlike "$localSidPrefix-*"))
)
})

if($matches.Count -eq 1) {
$sid=[string]$matches[0].sid
}
elseif($isLocalSession) {
try {
$localName="$env:COMPUTERNAME\$($session.UserName)"
$sid=([System.Security.Principal.NTAccount]::new($localName)).Translate([System.Security.Principal.SecurityIdentifier]).Value
} catch { }
}
# For a domain session, avoid an online account translation fallback while the DC
# is unavailable. An interactive domain session normally has a ProfileList record.
}

$sessions += [pscustomobject][ordered]@{
sessionId = [int]$session.SessionId
stationName = [string]$session.StationName
state = [string]$session.State
accountName = $accountName
sid = $sid
}
}
return $sessions
}

function Get-TargetSessionIds {
param([object[]]$Sessions, [string[]]$TargetSids, [string]$PreservedSid)

$ids = @()
foreach ($session in $Sessions) {
if (-not $session.sid) { continue }
if ($PreservedSid -and $session.sid -eq $PreservedSid) { continue }
if ($session.sid -in $TargetSids) { $ids += [int]$session.sessionId }
}
return @($ids | Sort-Object -Unique)
}

function Get-ProcessEvidence {
param([int[]]$SessionIds)

if ($null -eq $SessionIds -or $SessionIds.Count -eq 0) { return @() }
$items = @()
try {
foreach ($process in @(Get-CimInstance Win32_Process -ErrorAction Stop | Where-Object { [int]$_.SessionId -in $SessionIds })) {
$items += [pscustomobject][ordered]@{
processId = [int]$process.ProcessId
parentId = [int]$process.ParentProcessId
sessionId = [int]$process.SessionId
name = [string]$process.Name
executable = [string]$process.ExecutablePath
commandLine = [string]$process.CommandLine
creationDate = if ($process.CreationDate) { ([datetime]$process.CreationDate).ToUniversalTime().ToString('o') } else { $null }
}
}
}
catch { throw }
return $items
}

function Get-IdentityMatchMaps {
param([object[]]$TargetIdentities)
$exact=@{};$short=@{}
foreach($identity in @($TargetIdentities | Where-Object {$_.resolveStatus -eq 'SUCCESS'})){
foreach($field in @('requested','normalized','accountName')){
$value=[string]$identity.$field
if([string]::IsNullOrWhiteSpace($value)){continue}
$normalizedName=Normalize-AccountName $value
$exact[$normalizedName.ToLowerInvariant()]=[string]$identity.sid
$leaf=if($normalizedName.Contains('\')){$normalizedName.Split('\')[-1]}else{$normalizedName}
$key=$leaf.ToLowerInvariant()
if(-not $short.ContainsKey($key)){$short[$key]=@()}
$short[$key]=@($short[$key]+[string]$identity.sid | Select-Object -Unique)
}
}
[pscustomobject]@{Exact=$exact;Short=$short}
}
function Resolve-EvidencePrincipalSid {
param([string]$Principal,$Maps)
if([string]::IsNullOrWhiteSpace($Principal)){return $null}
if($Principal -match '^S-\d-\d+(-\d+)+$'){return $Principal}
$normalizedPrincipal=Normalize-AccountName $Principal
$key=$normalizedPrincipal.ToLowerInvariant()
if($Maps.Exact.ContainsKey($key)){return [string]$Maps.Exact[$key]}
if(-not $normalizedPrincipal.Contains('\')){
$shortKey=$normalizedPrincipal.ToLowerInvariant()
if($Maps.Short.ContainsKey($shortKey) -and @($Maps.Short[$shortKey]).Count -eq 1){return [string]$Maps.Short[$shortKey][0]}
}
return $null
}

function Get-ScheduledTaskEvidence {
param([object[]]$TargetIdentities,[bool]$AllScope)

$items=@()
$targetSids=@($TargetIdentities | Where-Object {$_.resolveStatus -eq 'SUCCESS'} | ForEach-Object {[string]$_.sid})
$maps=Get-IdentityMatchMaps -TargetIdentities $TargetIdentities

try {
$scheduler=New-Object -ComObject 'Schedule.Service'
$scheduler.Connect()
$queue=New-Object System.Collections.Queue
$queue.Enqueue($scheduler.GetFolder('\'))

while($queue.Count -gt 0) {
$folder=$queue.Dequeue()

try {
$subFolders=$folder.GetFolders(0)
for($i=1;$i -le $subFolders.Count;$i++) {
$queue.Enqueue($subFolders.Item($i))
}
} catch { }

try {
$registeredTasks=$folder.GetTasks(0)
for($i=1;$i -le $registeredTasks.Count;$i++) {
$task=$registeredTasks.Item($i)
try {
[xml]$taskXml=$task.Xml
$principal=[string]$taskXml.Task.Principals.Principal.UserId
if([string]::IsNullOrWhiteSpace($principal)){continue}
if($principal -in @('SYSTEM','LOCAL SERVICE','NETWORK SERVICE','S-1-5-18','S-1-5-19','S-1-5-20')){continue}
if($principal -like 'NT SERVICE\*'){continue}

$principalSid=Resolve-EvidencePrincipalSid -Principal $principal -Maps $maps
$include=$AllScope -or ($principalSid -and $principalSid -in $targetSids)
if(-not $include){continue}

$stateName=switch([int]$task.State){0{'Unknown'}1{'Disabled'}2{'Queued'}3{'Ready'}4{'Running'}default{[string]$task.State}}
$fullPath=[string]$task.Path
$taskName=Split-Path -Path $fullPath -Leaf
$taskPath=if($fullPath.Length -gt $taskName.Length){$fullPath.Substring(0,$fullPath.Length-$taskName.Length)}else{'\'}
$items += [pscustomobject][ordered]@{
taskPath=$taskPath
taskName=$taskName
state=$stateName
principal=$principal
principalSid=$principalSid
logonType=[string]$taskXml.Task.Principals.Principal.LogonType
runLevel=[string]$taskXml.Task.Principals.Principal.RunLevel
}
} catch { }
}
} catch { }
}
}
catch {
# Evidence collection is best-effort and must never delay emergency enforcement by
# waiting on domain principal translation.
return @()
}

return $items
}

function Get-ServiceEvidence {
param([object[]]$TargetIdentities,[bool]$AllScope)
$items=@()
$targetSids=@($TargetIdentities | Where-Object {$_.resolveStatus -eq 'SUCCESS'} | ForEach-Object {[string]$_.sid})
$maps=Get-IdentityMatchMaps -TargetIdentities $TargetIdentities
foreach($service in @(Get-CimInstance Win32_Service -ErrorAction SilentlyContinue)){
$principal=[string]$service.StartName
if([string]::IsNullOrWhiteSpace($principal)){continue}
if($principal -in @('LocalSystem','NT AUTHORITY\LocalService','NT AUTHORITY\NetworkService','.\LocalSystem')){continue}
if($principal -like 'NT SERVICE\*'){continue}
$principalSid=Resolve-EvidencePrincipalSid -Principal $principal -Maps $maps
$include=$AllScope -or ($principalSid -and $principalSid -in $targetSids)
if(-not $include){continue}
$items += [pscustomobject][ordered]@{name=[string]$service.Name;displayName=[string]$service.DisplayName;state=[string]$service.State;startMode=[string]$service.StartMode;startName=$principal;principalSid=$principalSid;processId=[int]$service.ProcessId}
}
return $items
}

function Get-NetworkConnectionEvidence {
param([int[]]$ProcessIds)

$items = @()
if ($null -eq $ProcessIds -or $ProcessIds.Count -eq 0) { return $items }
if (-not (Get-Command Get-NetTCPConnection -ErrorAction SilentlyContinue)) { return $items }

foreach ($connection in @(Get-NetTCPConnection -ErrorAction SilentlyContinue | Where-Object { [int]$_.OwningProcess -in $ProcessIds })) {
$items += [pscustomobject][ordered]@{
owningProcess = [int]$connection.OwningProcess
localAddress = [string]$connection.LocalAddress
localPort = [int]$connection.LocalPort
remoteAddress = [string]$connection.RemoteAddress
remotePort = [int]$connection.RemotePort
state = [string]$connection.State
}
}
return $items
}

function Get-CachedLogonState {
$path = 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon'
$valueName = 'CachedLogonsCount'
$exists = $false
$value = $null
$kind = $null
try {
$key = [Microsoft.Win32.Registry]::LocalMachine.OpenSubKey('SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon', $false)
if ($null -ne $key) {
$names = @($key.GetValueNames())
if ($valueName -in $names) {
$exists = $true
$value = [string]$key.GetValue($valueName, $null, [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)
$kind = [string]$key.GetValueKind($valueName)
}
$key.Close()
}
}
catch { }
return [pscustomobject]@{ path=$path; valueName=$valueName; existed=$exists; value=$value; kind=$kind }
}

function Disable-CachedDomainLogon {
$path = 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon'
New-ItemProperty -Path $path -Name 'CachedLogonsCount' -Value '0' -PropertyType String -Force | Out-Null
$current = [string](Get-ItemProperty -Path $path -Name 'CachedLogonsCount' -ErrorAction Stop).CachedLogonsCount
if ($current -ne '0') { throw 'CachedLogonsCount verification failed.' }
}

function Get-NetlogonState {
$service = Get-CimInstance Win32_Service -Filter "Name='Netlogon'" -ErrorAction Stop
return [pscustomobject]@{
startMode = [string]$service.StartMode
state = [string]$service.State
}
}

function Disable-Netlogon {
$service = Get-Service -Name Netlogon -ErrorAction Stop
if ($service.Status -ne 'Stopped') { Stop-Service -Name Netlogon -Force -ErrorAction Stop }
Set-Service -Name Netlogon -StartupType Disabled -ErrorAction Stop

$current = Get-CimInstance Win32_Service -Filter "Name='Netlogon'" -ErrorAction Stop
if ($current.State -ne 'Stopped' -or $current.StartMode -ne 'Disabled') {
throw "Netlogon verification failed. State=$($current.State), StartMode=$($current.StartMode)"
}
}

function Get-KdcProxyState {
$rootPath = 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\Kerberos'
$mappingPath = Join-Path $rootPath 'KdcProxyServer'
$state = [ordered]@{
rootPath = $rootPath
rootExisted = Test-Path $rootPath
enabledValueExisted = $false
enabledValue = $null
mappingPathExisted = Test-Path $mappingPath
mappings = @()
}

if (Test-Path $rootPath) {
$item = Get-ItemProperty -Path $rootPath -ErrorAction SilentlyContinue
if ($null -ne $item -and $item.PSObject.Properties.Name -contains 'KdcProxyServer_Enabled') {
$state.enabledValueExisted = $true
$state.enabledValue = $item.KdcProxyServer_Enabled
}
}

if (Test-Path $mappingPath) {
$mapItem = Get-ItemProperty -Path $mappingPath -ErrorAction SilentlyContinue
if ($null -ne $mapItem) {
foreach ($property in @($mapItem.PSObject.Properties | Where-Object { $_.Name -notlike 'PS*' })) {
$state.mappings += [pscustomobject]@{ name=$property.Name; value=[string]$property.Value }
}
}
}

return [pscustomobject]$state
}

function Disable-KdcProxy {
$rootPath = 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\Kerberos'
$mappingPath = Join-Path $rootPath 'KdcProxyServer'
if (-not (Test-Path $rootPath)) { $null = New-Item -Path $rootPath -Force }
New-ItemProperty -Path $rootPath -Name 'KdcProxyServer_Enabled' -Value 0 -PropertyType DWord -Force | Out-Null
if (Test-Path $mappingPath) { Remove-Item -Path $mappingPath -Recurse -Force -ErrorAction Stop }
}

function Get-LocalDomainContext {
$computerSystem=Get-CimInstance Win32_ComputerSystem -ErrorAction Stop
$partOfDomain=[bool]$computerSystem.PartOfDomain
$domainName=if($partOfDomain){([string]$computerSystem.Domain).Trim().TrimEnd('.')}else{$null}
$fqdn=$null
try{$fqdn=([System.Net.Dns]::GetHostEntry($env:COMPUTERNAME).HostName).TrimEnd('.')}catch{}
$suffixes=@()
try{
foreach($adapter in @(Get-CimInstance Win32_NetworkAdapterConfiguration -Filter 'IPEnabled=True' -ErrorAction SilentlyContinue)){
if($adapter.DNSDomain){$suffixes += [string]$adapter.DNSDomain}
$suffixes += @($adapter.DNSDomainSuffixSearchOrder)
}
}catch{}
foreach($name in @('Domain','NV Domain','SearchList')){
try{$value=(Get-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters' -Name $name -ErrorAction Stop).$name;if($value){$suffixes += @([string]$value -split ',')}}catch{}
}
if($fqdn -and $fqdn.Contains('.')){$suffixes += $fqdn.Substring($fqdn.IndexOf('.')+1)}

$azureAdJoined=$false;$workplaceJoined=$false
try{
$dsreg=& (Join-Path $env:SystemRoot 'System32\dsregcmd.exe') /status 2>$null
foreach($line in @($dsreg)){
if([string]$line -match '^\s*AzureAdJoined\s*:\s*(YES|NO)\s*$'){$azureAdJoined=($matches[1] -eq 'YES')}
if([string]$line -match '^\s*WorkplaceJoined\s*:\s*(YES|NO)\s*$'){$workplaceJoined=($matches[1] -eq 'YES')}
}
}catch{}

[pscustomobject][ordered]@{
partOfDomain=$partOfDomain;domainName=$domainName;computerFqdn=$fqdn
dnsSuffixes=@($suffixes | ForEach-Object {$_.Trim().TrimEnd('.')} | Where-Object {$_} | Select-Object -Unique)
azureAdJoined=$azureAdJoined;workplaceJoined=$workplaceJoined
authoritativeSource='WIN32_COMPUTERSYSTEM';supplementalSources=@('COMPUTER_FQDN','ACTIVE_ADAPTER_DNS_SUFFIX','TCPIP_PARAMETERS','DSREGCMD')
}
}

function Get-ConfiguredDnsServerAddresses {
$addresses=@()
try {
if(Get-Command Get-DnsClientServerAddress -ErrorAction SilentlyContinue) {
foreach($item in @(Get-DnsClientServerAddress -ErrorAction Stop)) {
$addresses += @($item.ServerAddresses)
}
}
} catch { }

if($addresses.Count -eq 0) {
try {
foreach($adapter in @(Get-CimInstance Win32_NetworkAdapterConfiguration -Filter 'IPEnabled=True' -ErrorAction Stop)) {
$addresses += @($adapter.DNSServerSearchOrder)
}
} catch { }
}

$valid=@()
foreach($value in @($addresses)) {
if([string]::IsNullOrWhiteSpace([string]$value)){continue}
$ip=$null
if([System.Net.IPAddress]::TryParse([string]$value,[ref]$ip)) {
$text=$ip.IPAddressToString
if($text -notin @('0.0.0.0','127.0.0.1','::1') -and $text -notlike '169.254.*' -and $text -notlike 'fe80:*') {
$valid += $text
}
}
}
return @($valid | Select-Object -Unique)
}

function Resolve-DnsRecordsQuick {
param([string]$Name,[string]$Type)
if(-not (Get-Command Resolve-DnsName -ErrorAction SilentlyContinue)){return @()}
$parameters=@{Name=$Name;Type=$Type;ErrorAction='Stop';DnsOnly=$true}
$command=Get-Command Resolve-DnsName -ErrorAction Stop
if($command.Parameters.ContainsKey('QuickTimeout')){$parameters['QuickTimeout']=$true}
try { return @(Resolve-DnsName @parameters) } catch { return @() }
}

function Invoke-NltestDcDiscovery {
param([string]$DomainName,[int]$TimeoutMilliseconds=5000)
$output=''
try {
$startInfo=[System.Diagnostics.ProcessStartInfo]::new()
$startInfo.FileName=Join-Path $env:SystemRoot 'System32\nltest.exe'
$startInfo.Arguments="/dsgetdc:$DomainName"
$startInfo.UseShellExecute=$false
$startInfo.CreateNoWindow=$true
$startInfo.RedirectStandardOutput=$true
$startInfo.RedirectStandardError=$true
$process=[System.Diagnostics.Process]::new()
$process.StartInfo=$startInfo
if(-not $process.Start()){return [pscustomobject]@{completed=$false;exitCode=$null;output=''}}
if(-not $process.WaitForExit($TimeoutMilliseconds)) {
try{$process.Kill()}catch{}
return [pscustomobject]@{completed=$false;exitCode=$null;output=''}
}
$output=$process.StandardOutput.ReadToEnd()
return [pscustomobject]@{completed=$true;exitCode=$process.ExitCode;output=$output}
} catch {
return [pscustomobject]@{completed=$false;exitCode=$null;output=''}
}
}

function Get-DomainControllerDiscovery {
param([string]$DomainName)

$names=@()
$sources=@()
$dnsSrvSucceeded=$false
$resolvedAddresses=@()
$dnsServerCandidates=@(Get-ConfiguredDnsServerAddresses)

if([string]::IsNullOrWhiteSpace($DomainName)){
return [pscustomobject]@{
domainName=$DomainName;dcNames=@();addresses=@();resolvedAddresses=@()
dnsServerCandidates=$dnsServerCandidates;sources=@();dnsSrvSucceeded=$false
onlineDiscovery=$false;addressConfidence='NONE'
}
}

foreach($query in @("_ldap._tcp.dc._msdcs.$DomainName","_kerberos._tcp.$DomainName")) {
$records=@(Resolve-DnsRecordsQuick -Name $query -Type 'SRV')
foreach($record in $records) {
if($record.NameTarget){$names += ([string]$record.NameTarget).TrimEnd('.')}
}
if($records.Count -gt 0){$dnsSrvSucceeded=$true}
}
if($dnsSrvSucceeded){$sources += 'DNS_SRV'}

# Local historical sources are fast and remain available while the device is away from a DC.
try {
$gp=Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Group Policy\History' -Name DCName -ErrorAction Stop
if($gp.DCName){$names += ([string]$gp.DCName).TrimStart('\').TrimEnd('.');$sources += 'GROUP_POLICY_HISTORY'}
} catch { }
if($env:LOGONSERVER) {
$candidate=([string]$env:LOGONSERVER).TrimStart('\').TrimEnd('.')
if($candidate -and $candidate -ne $env:COMPUTERNAME){$names += $candidate;$sources += 'LOGONSERVER'}
}

# Nltest is useful online but must never hold emergency enforcement for minutes.
$nltest=Invoke-NltestDcDiscovery -DomainName $DomainName -TimeoutMilliseconds 5000
if($nltest.completed) {
foreach($line in @([string]$nltest.output -split "`r?`n")) {
if([string]$line -match '(?i)DC:\s+\\+([^\s]+)'){$names += $matches[1].TrimEnd('.')}
}
if($nltest.exitCode -eq 0){$sources += 'NLTEST'}
} else {
$sources += 'NLTEST_TIMEOUT_OR_UNAVAILABLE'
}

$names=@($names | Where-Object {$_} | Select-Object -Unique)

# First use the DNS client cache because it can contain the last DC address while DNS/DC is offline.
try {
if(Get-Command Get-DnsClientCache -ErrorAction SilentlyContinue) {
foreach($entry in @(Get-DnsClientCache -ErrorAction Stop)) {
$entryName=[string](Get-ObjectPropertyValue -Object $entry -Name 'Entry' -DefaultValue '')
if([string]::IsNullOrWhiteSpace($entryName)){$entryName=[string](Get-ObjectPropertyValue -Object $entry -Name 'Name' -DefaultValue '')}
if($entryName.TrimEnd('.') -notin $names){continue}
$data=[string](Get-ObjectPropertyValue -Object $entry -Name 'Data' -DefaultValue '')
$ip=$null
if([System.Net.IPAddress]::TryParse($data,[ref]$ip)){$resolvedAddresses += $ip.IPAddressToString}
}
if($resolvedAddresses.Count -gt 0){$sources += 'DNS_CLIENT_CACHE'}
}
} catch { }

foreach($name in $names) {
foreach($recordType in @('A','AAAA')) {
foreach($record in @(Resolve-DnsRecordsQuick -Name $name -Type $recordType)) {
if($record.IPAddress){$resolvedAddresses += [string]$record.IPAddress}
}
}
}
if($resolvedAddresses.Count -gt 0){$sources += 'DNS_ADDRESS_RESOLUTION'}

$resolvedAddresses=@(
$resolvedAddresses |
Where-Object {$_ -and $_ -notlike '169.254.*' -and $_ -notlike 'fe80:*' -and $_ -ne '::1'} |
Select-Object -Unique
)

$addresses=@($resolvedAddresses)
$confidence='RESOLVED_DC'
if($addresses.Count -eq 0 -and $dnsServerCandidates.Count -gt 0) {
# In standard AD deployments the configured DNS servers are commonly DC-integrated DNS.
# Treat them only as scoped fallback candidates and record the lower confidence explicitly.
$addresses=@($dnsServerCandidates)
$sources += 'CONFIGURED_DNS_SERVER_CANDIDATE'
$confidence='DNS_SERVER_CANDIDATE'
}
elseif($addresses.Count -eq 0) {
$confidence='NONE'
}

[pscustomobject][ordered]@{
domainName=$DomainName
dcNames=$names
addresses=@($addresses)
resolvedAddresses=@($resolvedAddresses)
dnsServerCandidates=@($dnsServerCandidates)
sources=@($sources | Select-Object -Unique)
dnsSrvSucceeded=$dnsSrvSucceeded
onlineDiscovery=($resolvedAddresses.Count -gt 0)
addressConfidence=$confidence
}
}

function New-AuthFirewallPlan {
param($DomainContext,$DcDiscovery)

if(-not [bool]$DomainContext.partOfDomain){
return [pscustomobject][ordered]@{
mode='NOT_APPLICABLE';domainName=$null;dcNames=@();remoteAddresses=@()
discoverySources=@();addressConfidence='NONE';ruleDefinitions=@()
warningCode='DEVICE_NOT_DOMAIN_JOINED'
}
}

$tcpFixed=@('88','135','139','389','445','464','636','3268','3269','9389')
$udpFixed=@('88','137','138','389','464')
$definitions=@()
$mode=$null
$warning=$null
$remote=@($DcDiscovery.addresses)
$confidence=[string](Get-ObjectPropertyValue -Object $DcDiscovery -Name 'addressConfidence' -DefaultValue 'NONE')

if($remote.Count -gt 0 -and $confidence -eq 'RESOLVED_DC' -and [bool]$DcDiscovery.dnsSrvSucceeded) {
$mode='DC_SCOPED'
$definitions += [pscustomobject]@{name="$FirewallRulePrefix-TCP-Fixed";protocol='TCP';remotePorts=$tcpFixed;remoteAddresses=$remote}
$definitions += [pscustomobject]@{name="$FirewallRulePrefix-UDP-Fixed";protocol='UDP';remotePorts=$udpFixed;remoteAddresses=$remote}
$definitions += [pscustomobject]@{name="$FirewallRulePrefix-TCP-RPCDynamic";protocol='TCP';remotePorts=@('49152-65535');remoteAddresses=$remote}
}
elseif($remote.Count -gt 0 -and $confidence -eq 'RESOLVED_DC') {
$mode='HYBRID_FALLBACK'
$warning='DC_DISCOVERY_PARTIAL_GLOBAL_FIXED_FALLBACK'
$definitions += [pscustomobject]@{name="$FirewallRulePrefix-TCP-Fixed";protocol='TCP';remotePorts=$tcpFixed;remoteAddresses=@('Any')}
$definitions += [pscustomobject]@{name="$FirewallRulePrefix-UDP-Fixed";protocol='UDP';remotePorts=$udpFixed;remoteAddresses=@('Any')}
$definitions += [pscustomobject]@{name="$FirewallRulePrefix-TCP-RPCDynamic";protocol='TCP';remotePorts=@('49152-65535');remoteAddresses=$remote}
}
elseif($remote.Count -gt 0 -and $confidence -eq 'DNS_SERVER_CANDIDATE') {
$mode='DNS_SERVER_CANDIDATE_FALLBACK'
$warning='DC_ADDRESS_UNRESOLVED_USING_CONFIGURED_DNS_SERVERS'
$definitions += [pscustomobject]@{name="$FirewallRulePrefix-TCP-Fixed";protocol='TCP';remotePorts=$tcpFixed;remoteAddresses=@('Any')}
$definitions += [pscustomobject]@{name="$FirewallRulePrefix-UDP-Fixed";protocol='UDP';remotePorts=$udpFixed;remoteAddresses=@('Any')}
$definitions += [pscustomobject]@{name="$FirewallRulePrefix-TCP-RPCDynamic";protocol='TCP';remotePorts=@('49152-65535');remoteAddresses=$remote}
}
else {
$mode='GLOBAL_FIXED_FALLBACK'
$warning='DC_DISCOVERY_FAILED_GLOBAL_FIXED_FALLBACK'
$definitions += [pscustomobject]@{name="$FirewallRulePrefix-TCP-Fixed";protocol='TCP';remotePorts=$tcpFixed;remoteAddresses=@('Any')}
$definitions += [pscustomobject]@{name="$FirewallRulePrefix-UDP-Fixed";protocol='UDP';remotePorts=$udpFixed;remoteAddresses=@('Any')}
}

[pscustomobject][ordered]@{
mode=$mode
domainName=[string]$DomainContext.domainName
dcNames=@($DcDiscovery.dcNames)
remoteAddresses=$remote
discoverySources=@($DcDiscovery.sources)
addressConfidence=$confidence
ruleDefinitions=$definitions
warningCode=$warning
}
}

function Convert-ToNormalizedSet {
param($Value)
$items=@()
foreach($entry in @($Value)){if($null -ne $entry){$items += @(([string]$entry -split ',') | ForEach-Object {$_.Trim()} | Where-Object {$_})}}
return @($items | Sort-Object -Unique)
}
function Convert-ProtocolName {
param($Value)
$text=[string]$Value
switch($text.ToUpperInvariant()){'6'{'TCP'}'17'{'UDP'}default{$text.ToUpperInvariant()}}
}
function Apply-AuthFirewallRules {
param($Plan)
if(-not (Get-Command New-NetFirewallRule -ErrorAction SilentlyContinue)){throw 'New-NetFirewallRule is unavailable.'}
$engine=Get-FirewallEnforcementState
$script:State.actions.firewallEngine=[ordered]@{
serviceState=$engine.serviceState
enabledProfiles=@($engine.enabledProfiles)
disabledProfiles=@($engine.disabledProfiles)
verified=[bool]$engine.pass
}
if(-not $engine.pass){throw "Windows Firewall enforcement is unavailable. Service=$($engine.serviceState);EnabledProfiles=$($engine.enabledProfiles -join ',')"}
$definitions=@($Plan.ruleDefinitions)
foreach($definition in $definitions){if(Get-NetFirewallRule -Name ([string]$definition.name) -ErrorAction SilentlyContinue){throw "Emergency firewall rule already exists: $($definition.name)"}}
$created=@()
try{
foreach($definition in $definitions){
New-NetFirewallRule -Name ([string]$definition.name) -DisplayName ([string]$definition.name) -Group $FirewallRuleGroup -Direction Outbound -Action Block -Enabled True -Profile Any -Protocol ([string]$definition.protocol) -RemoteAddress @($definition.remoteAddresses) -RemotePort @($definition.remotePorts) | Out-Null
$rule=@(Get-NetFirewallRule -Name ([string]$definition.name) -ErrorAction Stop)
if($rule.Count -ne 1){throw "Firewall rule count verification failed for $($definition.name)."}
$port=Get-NetFirewallPortFilter -AssociatedNetFirewallRule $rule[0] -ErrorAction Stop
$addr=Get-NetFirewallAddressFilter -AssociatedNetFirewallRule $rule[0] -ErrorAction Stop
$expectedProtocol=Convert-ProtocolName $definition.protocol;$actualProtocol=Convert-ProtocolName $port.Protocol
$expectedPorts=Convert-ToNormalizedSet $definition.remotePorts;$actualPorts=Convert-ToNormalizedSet $port.RemotePort
$expectedAddresses=Convert-ToNormalizedSet $definition.remoteAddresses;$actualAddresses=Convert-ToNormalizedSet $addr.RemoteAddress
if([string]$rule[0].Enabled -ne 'True' -or [string]$rule[0].Action -ne 'Block' -or [string]$rule[0].Direction -ne 'Outbound' -or $actualProtocol -ne $expectedProtocol -or ($actualPorts -join '|') -ne ($expectedPorts -join '|') -or ($actualAddresses -join '|') -ne ($expectedAddresses -join '|')){throw "Firewall effective-state verification failed for $($definition.name)."}
$created += [pscustomobject]@{name=[string]$definition.name;protocol=$actualProtocol;remotePort=$actualPorts;remoteAddress=$actualAddresses}
}
}catch{foreach($definition in $definitions){Remove-NetFirewallRule -Name ([string]$definition.name) -ErrorAction SilentlyContinue};throw}
return $created
}

function New-ScopeGuardIdentity {
param([string]$Sid,[string]$AccountName,[string]$Source)
[pscustomobject][ordered]@{
requested=$AccountName
normalized=$AccountName
sid=$Sid
accountName=$AccountName
isLocal=$false
profileFound=$false
profilePath=$null
resolutionMethod='SCOPE_GUARD_SID'
resolveStatus='SUCCESS'
errorCode=$null
errorMessage=$null
sources=@($Source)
persistenceEligible=$false
isScopeGuard=$true
}
}

function Get-AllScopeGuardIdentities {
param([object[]]$DiscoveredIdentities,[bool]$PreserveLaps)

$guards=@()
if(-not $PreserveLaps) {
# Microsoft documents that assigning Deny log on locally to Everyone prevents
# every account from signing in locally. We also apply the RDP and network deny
# rights through the same synthetic identity. Batch/service denies remain limited
# to individually discovered human identities.
$guards += New-ScopeGuardIdentity -Sid 'S-1-1-0' -AccountName 'Everyone' -Source 'ALL_SCOPE_EVERYONE_GUARD'
return $guards
}

# SaveLaps must not use Everyone because the preserved local LAPS account is also a
# member of Everyone. Instead, add broad current-domain group SIDs as a second layer
# beside DC/network isolation. Domain Users covers normal and newly created users;
# the additional privileged groups cover common administrative token paths.
$domainPrefixes=@(
$DiscoveredIdentities |
Where-Object {
-not [bool](Get-ObjectPropertyValue -Object $_ -Name 'isLocal' -DefaultValue $false) -and
[string]$_.sid -match '^S-1-5-21-\d+-\d+-\d+-\d+$'
} |
ForEach-Object { ([string]$_.sid -replace '-\d+$','') } |
Select-Object -Unique
)

foreach($prefix in $domainPrefixes) {
foreach($group in @(
@{Rid=513;Name='Domain Users'},
@{Rid=512;Name='Domain Admins'},
@{Rid=518;Name='Schema Admins'},
@{Rid=519;Name='Enterprise Admins'},
@{Rid=520;Name='Group Policy Creator Owners'},
@{Rid=525;Name='Protected Users'}
)) {
$guards += New-ScopeGuardIdentity -Sid "$prefix-$($group.Rid)" -AccountName "DOMAIN_SCOPE\$($group.Name)" -Source 'ALL_SAVELAPS_DOMAIN_GROUP_GUARD'
}
}
return @($guards | Group-Object sid | ForEach-Object {$_.Group | Select-Object -First 1})
}

function Get-FirewallEnforcementState {
$serviceState='UNKNOWN'
$enabledProfiles=@()
$disabledProfiles=@()

try {
$service=Get-CimInstance Win32_Service -Filter "Name='MpsSvc'" -ErrorAction Stop
$serviceState=[string]$service.State
} catch { }

try {
foreach($profile in @(Get-NetFirewallProfile -ErrorAction Stop)) {
if([bool]$profile.Enabled){$enabledProfiles += [string]$profile.Name}else{$disabledProfiles += [string]$profile.Name}
}
} catch { }

[pscustomobject][ordered]@{
serviceState=$serviceState
enabledProfiles=@($enabledProfiles)
disabledProfiles=@($disabledProfiles)
pass=($serviceState -eq 'Running' -and $enabledProfiles.Count -gt 0)
}
}

function Add-DenyRights {
param([object[]]$Identities,[bool]$AllScope)
$interactiveRights=@('SeDenyInteractiveLogonRight','SeDenyRemoteInteractiveLogonRight','SeDenyNetworkLogonRight')
$persistenceRights=@('SeDenyBatchLogonRight','SeDenyServiceLogonRight')
$records=@();$failures=@();$affected=0;$protectedIdentityCount=0
foreach($identity in @($Identities | Where-Object {$_.resolveStatus -eq 'SUCCESS'})){
$required=@($interactiveRights)
$persistenceEligible=(-not $AllScope) -or [bool](Get-ObjectPropertyValue -Object $identity -Name 'persistenceEligible' -DefaultValue $false)
if($persistenceEligible){$required += $persistenceRights}
try{$before=@([EmergencySecurity.Native]::GetRights([string]$identity.sid))}catch{$failures += [pscustomobject]@{sid=[string]$identity.sid;accountName=[string]$identity.accountName;right=$null;error="Unable to enumerate existing rights: $($_.Exception.Message)"};continue}
$record=[ordered]@{sid=[string]$identity.sid;accountName=[string]$identity.accountName;rightsBefore=$before;requiredRights=$required;rightsAdded=@();persistenceRightsApplied=$persistenceEligible}
foreach($right in $required){
if($right -in $before){continue}
try{[EmergencySecurity.Native]::AddRight([string]$identity.sid,$right);$record.rightsAdded += $right;$affected++}
catch{$failures += [pscustomobject]@{sid=[string]$identity.sid;accountName=[string]$identity.accountName;right=$right;error=$_.Exception.Message}}
}
$identityProtected=$true
try{$after=@([EmergencySecurity.Native]::GetRights([string]$identity.sid));foreach($right in $required){if($right -notin $after){$identityProtected=$false;$failures += [pscustomobject]@{sid=[string]$identity.sid;accountName=[string]$identity.accountName;right=$right;error='Post-change verification did not find the required deny right.'}}}}
catch{$identityProtected=$false;$failures += [pscustomobject]@{sid=[string]$identity.sid;accountName=[string]$identity.accountName;right=$null;error="Post-change right enumeration failed: $($_.Exception.Message)"}}
$record['verificationComplete']=$identityProtected;if($identityProtected){$protectedIdentityCount++}
$records += [pscustomobject]$record;$script:State.originalState.userRights=$records;Write-StateCheckpoint
}
[pscustomobject]@{Records=$records;Failures=$failures;AffectedCount=$affected;ProtectedIdentityCount=$protectedIdentityCount}
}

function Install-PostBootVerifier {
param([Parameter(Mandatory = $true)][ValidateSet('LOCKDOWN','RESTORE')][string]$Operation)
$bytes=[Convert]::FromBase64String($PostBootVerifierBase64)
[System.IO.File]::WriteAllBytes($PostBootVerifierPath,$bytes);Set-SecureFileAcl -Path $PostBootVerifierPath
$aclCheck=Test-SecurePathAcl -Path $PostBootVerifierPath
if(-not $aclCheck.Pass){throw "Post-boot verifier ACL verification failed. Owner=$($aclCheck.Owner);Protected=$($aclCheck.Protected);Unexpected=$($aclCheck.Unexpected)"}
$powerShellExe=Join-Path $env:SystemRoot 'System32\WindowsPowerShell\v1.0\powershell.exe'
$taskCommand='"{0}" -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "{1}"' -f $powerShellExe,$PostBootVerifierPath
& (Join-Path $env:SystemRoot 'System32\schtasks.exe') /Create /TN $PostBootTaskName /SC ONSTART /RU SYSTEM /RL HIGHEST /TR $taskCommand /F | Out-Null
if($LASTEXITCODE -ne 0){throw "schtasks.exe returned exit code $LASTEXITCODE while registering post-boot verification."}
& (Join-Path $env:SystemRoot 'System32\schtasks.exe') /Query /TN $PostBootTaskName | Out-Null
if($LASTEXITCODE -ne 0){throw 'Post-boot verification task could not be queried after creation.'}
$pending=[pscustomobject][ordered]@{operation=$Operation;status='PENDING';overallStatus='PENDING';scheduledUtc=Get-UtcTimestamp;verifiedUtc=$null;rebootVerified=$false;passedCheckCount=0;failedCheckCount=0;failedChecks='';taskName=$PostBootTaskName;scriptPath=$PostBootVerifierPath;checks=@()}
if($script:State.PSObject.Properties.Name -contains 'postBootVerification'){$script:State.postBootVerification=$pending}else{$script:State | Add-Member -NotePropertyName postBootVerification -NotePropertyValue $pending}
Write-StateCheckpoint
}
function Cancel-PostBootVerifier {
param([string]$Reason)
try{& (Join-Path $env:SystemRoot 'System32\schtasks.exe') /Delete /TN $PostBootTaskName /F | Out-Null}catch{}
if($script:State.PSObject.Properties.Name -contains 'postBootVerification'){$script:State.postBootVerification.status='CANCELED';$script:State.postBootVerification.overallStatus='CANCELED';if($script:State.postBootVerification.PSObject.Properties.Name -contains 'message'){$script:State.postBootVerification.message=$Reason}else{$script:State.postBootVerification | Add-Member -NotePropertyName message -NotePropertyValue $Reason}}
Write-StateCheckpoint
}

function Remove-EmergencyTaskByName {
param([string]$Name)
try { & (Join-Path $env:SystemRoot 'System32\schtasks.exe') /End /TN $Name 2>$null | Out-Null } catch { }
try { & (Join-Path $env:SystemRoot 'System32\schtasks.exe') /Delete /TN $Name /F 2>$null | Out-Null } catch { }
}
function Remove-LegacyEmergencyTasks {
foreach ($name in @('EmergencyLockdown-PostBootVerify-v13','EmergencyLockdown-PostBootVerify-v131','EmergencyLockdown-PostBootVerify-v132','EmergencyLockdown-PostBootVerify-v133','EmergencyLockdown-PostBootVerify-v134','EmergencyLockdown-PostBootVerify-v135','EmergencyLockdown-DisruptionWorker-v132','EmergencyLockdown-DisruptionWorker-v133','EmergencyLockdown-DisruptionWorker-v134','EmergencyLockdown-DisruptionWorker-v135')) { Remove-EmergencyTaskByName -Name $name }
}
function Install-DisruptionWorker {
Set-SecureDirectoryAcl -Path $BaseDirectory
$bytes = [Convert]::FromBase64String($DisruptionWorkerBase64)
[System.IO.File]::WriteAllBytes($DisruptionWorkerPath,$bytes)
Set-SecureFileAcl -Path $DisruptionWorkerPath
$aclCheck = Test-SecurePathAcl -Path $DisruptionWorkerPath
if (-not $aclCheck.Pass) { throw "Disruption worker ACL verification failed. Owner=$($aclCheck.Owner);Protected=$($aclCheck.Protected);Unexpected=$($aclCheck.Unexpected)" }
Import-Module ScheduledTasks -ErrorAction Stop
Unregister-ScheduledTask -TaskName $DisruptionTaskName -Confirm:$false -ErrorAction SilentlyContinue
$powerShellExe = Join-Path $env:SystemRoot 'System32\WindowsPowerShell\v1.0\powershell.exe'
$arguments = '-NoProfile -NonInteractive -ExecutionPolicy Bypass -File "{0}"' -f $DisruptionWorkerPath
$action = New-ScheduledTaskAction -Execute $powerShellExe -Argument $arguments
$trigger = New-ScheduledTaskTrigger -Once -At (Get-Date).AddHours(1)
$principal = New-ScheduledTaskPrincipal -UserId 'SYSTEM' -LogonType ServiceAccount -RunLevel Highest
$settings = New-ScheduledTaskSettingsSet -ExecutionTimeLimit (New-TimeSpan -Minutes 5) -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries
Register-ScheduledTask -TaskName $DisruptionTaskName -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Force | Out-Null
$task = Get-ScheduledTask -TaskName $DisruptionTaskName -ErrorAction Stop
if ($null -eq $task) { throw 'Disruption worker task could not be queried after creation.' }
$script:State.actions.disruptionWorker.installed = $true
Write-StateCheckpoint
}
function Start-DisruptionWorker {
Start-ScheduledTask -TaskName $DisruptionTaskName -ErrorAction Stop
Start-Sleep -Milliseconds 500
$task = Get-ScheduledTask -TaskName $DisruptionTaskName -ErrorAction Stop
$script:State.actions.disruptionWorker.started = $true
Write-StateCheckpoint
return [string]$task.State
}
function Cancel-DisruptionWorker {
param([string]$Reason)
try { Stop-ScheduledTask -TaskName $DisruptionTaskName -ErrorAction SilentlyContinue } catch { }
try { Unregister-ScheduledTask -TaskName $DisruptionTaskName -Confirm:$false -ErrorAction SilentlyContinue } catch { }
try { Remove-Item -LiteralPath $DisruptionWorkerPath -Force -ErrorAction SilentlyContinue } catch { }
if ($script:State -and $script:State.actions -and $script:State.actions.disruptionWorker) {
$script:State.actions.disruptionWorker.started = $false
}
Write-StateCheckpoint
}

function Schedule-Reboot {
$os=Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
$script:State.actions.bootTimeBefore=([datetime]$os.LastBootUpTime).ToUniversalTime().ToString('o')
$arguments=@('/r','/f','/t',[string]$RebootDelaySeconds,'/c','"Emergency access lockdown: mandatory restart"')
$process=Start-Process -FilePath "$env:SystemRoot\System32\shutdown.exe" -ArgumentList $arguments -Wait -PassThru -WindowStyle Hidden
if($process.ExitCode -ne 0){throw "shutdown.exe returned exit code $($process.ExitCode)."}
$script:State.actions.rebootScheduled=$true;$script:State.actions.rebootScheduledUtc=Get-UtcTimestamp
}

# Main execution
try {
$stageStart=[DateTime]::UtcNow
try{
Set-SecureDirectoryAcl -Path $BaseDirectory
$aclCheck=Test-SecurePathAcl -Path $BaseDirectory
if(-not $aclCheck.Pass){throw "ACL verification failed. Owner=$($aclCheck.Owner);Protected=$($aclCheck.Protected);Unexpected=$($aclCheck.Unexpected)"}
Add-StageResult -Name 'SECURE_STATE_STORAGE' -Status 'SUCCESS' -Started $stageStart -Expected 'Owner SYSTEM; inheritance disabled; only SYSTEM and Administrators' -Actual "Owner=$($aclCheck.Owner);Protected=$($aclCheck.Protected)"
}catch{$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'SECURE_STATE_STORAGE' -Status 'FAILED' -Started $stageStart -ErrorCode 'STATE_STORAGE_ACL_FAILED' -ErrorMessage $_.Exception.Message;Write-Remarks;exit 10}

$stageStart=[DateTime]::UtcNow
if(Test-Path -LiteralPath $StatePath){
try{$existing=Get-Content -LiteralPath $StatePath -Raw -ErrorAction Stop | ConvertFrom-Json -ErrorAction Stop;if($existing.status -in @('APPLYING','ACTIVE_DISRUPTION_PENDING','ACTIVE_PENDING_REBOOT','ACTIVE','ACTIVE_VERIFIED','ACTIVE_VERIFIED_WITH_WARNINGS','LOCKDOWN_PARTIAL','RESTORING','RESTORED_PENDING_REBOOT','RESTORE_PARTIAL','UNHANDLED_FAILURE')){$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'CHECK_EXISTING_STATE' -Status 'FAILED' -Started $stageStart -ErrorCode 'LOCKDOWN_ALREADY_ACTIVE' -ErrorMessage "Existing state status is $($existing.status). Restore or resolve it before a new lockdown.";Write-Remarks;exit 23}}
catch{$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'CHECK_EXISTING_STATE' -Status 'FAILED' -Started $stageStart -ErrorCode 'EXISTING_STATE_UNREADABLE' -ErrorMessage $_.Exception.Message;Write-Remarks;exit 24}
}
Add-StageResult -Name 'CHECK_EXISTING_STATE' -Status 'SUCCESS' -Started $stageStart
$script:StateWriteEnabled=$true;Write-StateCheckpoint

$stageStart=[DateTime]::UtcNow
$identity=[System.Security.Principal.WindowsIdentity]::GetCurrent()
$principal=[System.Security.Principal.WindowsPrincipal]::new($identity)
$isSystem=($identity.User.Value -eq 'S-1-5-18')
$isAdministrator=$principal.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
$executionSessionId=[System.Diagnostics.Process]::GetCurrentProcess().SessionId
$script:State.actions.executionContext=[ordered]@{identityName=[string]$identity.Name;identitySid=[string]$identity.User.Value;processSessionId=[int]$executionSessionId;isSystem=[bool]$isSystem;isAdministrator=[bool]$isAdministrator}
if(-not ($isSystem -or $isAdministrator)){$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'PRECHECK_ENVIRONMENT' -Status 'FAILED' -Started $stageStart -ErrorCode 'ELEVATION_REQUIRED' -ErrorMessage 'The script must run as SYSTEM or an elevated administrator.';Write-Remarks;exit 11}
try{Initialize-NativeTypes;Remove-LegacyEmergencyTasks;Add-StageResult -Name 'PRECHECK_ENVIRONMENT' -Status 'SUCCESS' -Started $stageStart -Expected 'SYSTEM/elevated context and native APIs available' -Actual "Identity=$($identity.Name);SID=$($identity.User.Value);SessionId=$executionSessionId"}catch{$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'PRECHECK_ENVIRONMENT' -Status 'FAILED' -Started $stageStart -ErrorCode 'NATIVE_API_INITIALIZATION_FAILED' -ErrorMessage $_.Exception.Message;Write-Remarks;exit 12}

$stageStart=[DateTime]::UtcNow;$tokens=@()
if(-not [string]::IsNullOrWhiteSpace($TargetUsers)){$tokens=@($TargetUsers.Split(';') | ForEach-Object {$_.Trim()} | Where-Object {-not [string]::IsNullOrWhiteSpace($_)} | Select-Object -Unique)}
if($tokens.Count -eq 0){$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'VALIDATE_PARAMETERS' -Status 'FAILED' -Started $stageStart -ErrorCode 'TARGETUSERS_REQUIRED' -ErrorMessage 'TargetUsers must be supplied and cannot be empty.';Write-Remarks;exit 20}
$allTokens=@($tokens | Where-Object {$_ -ieq 'ALL'})
if($allTokens.Count -gt 0 -and $tokens.Count -gt 1){$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'VALIDATE_PARAMETERS' -Status 'FAILED' -Started $stageStart -ErrorCode 'ALL_CANNOT_BE_COMBINED' -ErrorMessage 'ALL cannot be combined with explicit account names.';Write-Remarks;exit 21}
if($SaveLaps -and -not ($tokens.Count -eq 1 -and $tokens[0] -ieq 'ALL')){$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'VALIDATE_PARAMETERS' -Status 'FAILED' -Started $stageStart -ErrorCode 'SAVELAPS_REQUIRES_ALL' -ErrorMessage 'SaveLaps can only be used with TargetUsers ALL.';Write-Remarks;exit 22}
$script:State.requestedTargets=$tokens;Add-StageResult -Name 'VALIDATE_PARAMETERS' -Status 'SUCCESS' -Started $stageStart -AffectedCount $tokens.Count -Expected 'Valid TargetUsers and SaveLaps combination' -Actual ($tokens -join ';')

$stageStart=[DateTime]::UtcNow;$allScope=($tokens.Count -eq 1 -and $tokens[0] -ieq 'ALL')
$script:State.scope=if($allScope){if($SaveLaps){'ALL_USERS_SAVE_LAPS'}else{'ALL_USERS'}}else{'EXPLICIT_USERS'}
Add-StageResult -Name 'DETERMINE_SCOPE' -Status 'SUCCESS' -Started $stageStart -Actual $script:State.scope

$preservedLapsSid=$null;$stageStart=[DateTime]::UtcNow
if($SaveLaps){
try{$laps=Get-VerifiedLapsAccount;if(-not $laps.Verified){$script:State.laps.validationError=$laps.ErrorCode;$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'DETECT_LAPS' -Status 'FAILED' -Started $stageStart -ErrorCode $laps.ErrorCode -ErrorMessage $laps.ErrorMessage;Write-Remarks;exit 25}
$existingLapsRights=@([EmergencySecurity.Native]::GetRights([string]$laps.AccountSid))
$blockingLapsRights=@($existingLapsRights | Where-Object {$_ -in @('SeDenyInteractiveLogonRight','SeDenyRemoteInteractiveLogonRight','SeDenyNetworkLogonRight')})
if($blockingLapsRights.Count -gt 0){$script:State.laps.blockingDenyRights=$blockingLapsRights;$script:State.laps.validationError='LAPS_ACCOUNT_ALREADY_DENIED';$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'DETECT_LAPS' -Status 'FAILED' -Started $stageStart -ErrorCode 'LAPS_ACCOUNT_ALREADY_DENIED' -ErrorMessage ("The verified LAPS account already has blocking deny rights: " + ($blockingLapsRights -join ','));Write-Remarks;exit 25}
$script:State.laps.detected=$true;$script:State.laps.verified=$true;$script:State.laps.accountName=$laps.AccountName;$script:State.laps.accountSid=$laps.AccountSid;$script:State.laps.policySource=$laps.PolicySource;$script:State.laps.verificationLevel=$laps.VerificationLevel;$script:State.laps.accountResolutionSource=$laps.AccountResolutionSource;$script:State.laps.lastPolicySuccessUtc=$laps.LastPolicySuccessUtc;$script:State.laps.lastBackupSuccessUtc=$laps.LastBackupSuccessUtc;$script:State.laps.lastLocalUpdateUtc=$laps.LastLocalUpdateUtc;$script:State.laps.blockingDenyRights=@();$preservedLapsSid=$laps.AccountSid
Add-StageResult -Name 'DETECT_LAPS' -Status 'SUCCESS' -Started $stageStart -AffectedCount 1 -Expected 'Configured, backed up, enabled local administrator account without blocking deny rights' -Actual "$($laps.AccountName);$($laps.VerificationLevel);BlockingDenyRights=0"}
catch{$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'DETECT_LAPS' -Status 'FAILED' -Started $stageStart -ErrorCode 'LAPS_DETECTION_FAILED' -ErrorMessage $_.Exception.Message;Write-Remarks;exit 26}
}else{Add-StageResult -Name 'DETECT_LAPS' -Status 'NOT_APPLICABLE' -Started $stageStart}

$targetIdentities=@();$stageStart=[DateTime]::UtcNow
if(-not $allScope){
foreach($token in $tokens){$targetIdentities += Resolve-AccountIdentity -RequestedName $token}
$script:State.targets=$targetIdentities;$resolvedCount=@($targetIdentities | Where-Object {$_.resolveStatus -eq 'SUCCESS'}).Count;$failedCount=$targetIdentities.Count-$resolvedCount
if($resolvedCount -eq 0){$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'RESOLVE_TARGETS' -Status 'FAILED' -Started $stageStart -ErrorCode 'NO_TARGET_RESOLVED' -ErrorMessage 'None of the requested accounts could be resolved. No security change was applied.';Write-Remarks;exit 27}
elseif($failedCount -gt 0){Add-StageResult -Name 'RESOLVE_TARGETS' -Status 'WARNING' -Started $stageStart -AffectedCount $resolvedCount -ErrorCode 'SOME_TARGETS_NOT_RESOLVED' -ErrorMessage "$failedCount requested account(s) could not be resolved." -Expected "$($tokens.Count) resolved" -Actual "$resolvedCount resolved"}
else{Add-StageResult -Name 'RESOLVE_TARGETS' -Status 'SUCCESS' -Started $stageStart -AffectedCount $resolvedCount -Expected "$($tokens.Count) resolved" -Actual "$resolvedCount resolved"}
Add-StageResult -Name 'DISCOVER_ALL_USERS' -Status 'NOT_APPLICABLE' -Started ([DateTime]::UtcNow)
}else{
Add-StageResult -Name 'RESOLVE_TARGETS' -Status 'NOT_APPLICABLE' -Started $stageStart;$stageStart=[DateTime]::UtcNow
try{$targetIdentities=@(Get-DiscoveredHumanAccounts);if($preservedLapsSid){$targetIdentities=@($targetIdentities | Where-Object {$_.sid -ne $preservedLapsSid})};if($targetIdentities.Count -eq 0){$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'DISCOVER_ALL_USERS' -Status 'FAILED' -Started $stageStart -ErrorCode 'NO_HUMAN_ACCOUNTS_DISCOVERED' -ErrorMessage 'No human user account was discovered for ALL scope.';Write-Remarks;exit 28};$script:State.targets=$targetIdentities;Add-StageResult -Name 'DISCOVER_ALL_USERS' -Status 'SUCCESS' -Started $stageStart -AffectedCount $targetIdentities.Count -Expected 'At least one non-system identity' -Actual "$($targetIdentities.Count) discovered"}
catch{$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'DISCOVER_ALL_USERS' -Status 'FAILED' -Started $stageStart -ErrorCode 'USER_DISCOVERY_FAILED' -ErrorMessage $_.Exception.Message;Write-Remarks;exit 29}
}
$targetSids=@($targetIdentities | Where-Object {$_.resolveStatus -eq 'SUCCESS'} | ForEach-Object {$_.sid} | Select-Object -Unique)

$enforcementIdentities=@($targetIdentities)
$scopeGuardIdentities=@()
$stageStart=[DateTime]::UtcNow
if($allScope) {
try {
$scopeGuardIdentities=@(Get-AllScopeGuardIdentities -DiscoveredIdentities $targetIdentities -PreserveLaps ([bool]$SaveLaps))
if((-not [bool]$SaveLaps) -and @($scopeGuardIdentities | Where-Object {$_.sid -eq 'S-1-1-0'}).Count -ne 1) {
throw 'The mandatory Everyone scope guard could not be prepared.'
}
if([bool]$SaveLaps -and $script:State.actions.domainContext -and [bool]$script:State.actions.domainContext.partOfDomain -and $scopeGuardIdentities.Count -eq 0) {
Add-WarningRecord -Code 'SAVELAPS_DOMAIN_GROUP_GUARD_UNAVAILABLE' -Message 'No cached domain SID was available for broad domain group guards. Network authentication isolation remains mandatory.'
}
$enforcementIdentities=@($targetIdentities + $scopeGuardIdentities)
$script:State.actions.scopeGuard.mode=if([bool]$SaveLaps){'DOMAIN_GROUPS_PLUS_NETWORK'}else{'EVERYONE'}
$script:State.actions.scopeGuard.status='PREPARED'
$script:State.actions.scopeGuard.principals=@($scopeGuardIdentities | ForEach-Object {[pscustomobject]@{sid=$_.sid;accountName=$_.accountName;source=$_.sources[0]}})
Add-StageResult -Name 'PREPARE_SCOPE_GUARD' -Status 'SUCCESS' -Started $stageStart -AffectedCount $scopeGuardIdentities.Count -Expected $(if([bool]$SaveLaps){'Broad domain guards without denying the preserved LAPS account'}else{'Everyone interactive/RDP/network guard'}) -Actual "$($scopeGuardIdentities.Count) guard principal(s)"
}
catch {
$script:State.status='FAILED_PRECHECK'
Add-StageResult -Name 'PREPARE_SCOPE_GUARD' -Status 'FAILED' -Started $stageStart -ErrorCode 'SCOPE_GUARD_PREPARATION_FAILED' -ErrorMessage $_.Exception.Message
Write-Remarks
exit 30
}
} else {
Add-StageResult -Name 'PREPARE_SCOPE_GUARD' -Status 'NOT_APPLICABLE' -Started $stageStart
}

$stageStart=[DateTime]::UtcNow
try{$sessions=@(Get-SessionEvidence);$script:State.evidence.sessions=$sessions;$sessionIds=@(Get-TargetSessionIds -Sessions $sessions -TargetSids $targetSids -PreservedSid $preservedLapsSid);$script:State.actions.sessionTelemetry.targetSessionsFound=$sessionIds.Count
if($allScope){
foreach($identity in $targetIdentities){
$matchingSession=@($sessions | Where-Object {$_.sid -and $_.sid -eq $identity.sid} | Select-Object -First 1)
if($matchingSession.Count -gt 0){
$identity.persistenceEligible=$true
$identity.sources=@($identity.sources + 'ACTIVE_SESSION' | Select-Object -Unique)
if(-not [string]::IsNullOrWhiteSpace([string]$matchingSession[0].accountName)){
$identity.accountName=[string]$matchingSession[0].accountName
$identity.normalized=[string]$matchingSession[0].accountName
}
}
}
$script:State.targets=$targetIdentities
}
Add-StageResult -Name 'CAPTURE_SESSIONS' -Status 'SUCCESS' -Started $stageStart -AffectedCount $sessionIds.Count}
catch{$sessions=@();$sessionIds=@();Add-StageResult -Name 'CAPTURE_SESSIONS' -Status 'WARNING' -Started $stageStart -ErrorCode 'SESSION_CAPTURE_FAILED' -ErrorMessage $_.Exception.Message}
$stageStart=[DateTime]::UtcNow;try{$processes=@(Get-ProcessEvidence -SessionIds $sessionIds);$script:State.evidence.processes=$processes;Add-StageResult -Name 'CAPTURE_PROCESSES' -Status 'SUCCESS' -Started $stageStart -AffectedCount $processes.Count}catch{$processes=@();Add-StageResult -Name 'CAPTURE_PROCESSES' -Status 'WARNING' -Started $stageStart -ErrorCode 'PROCESS_CAPTURE_FAILED' -ErrorMessage $_.Exception.Message}
$stageStart=[DateTime]::UtcNow;try{$tasks=@(Get-ScheduledTaskEvidence -TargetIdentities $targetIdentities -AllScope $allScope);$script:State.evidence.scheduledTasks=$tasks;Add-StageResult -Name 'CAPTURE_TASKS' -Status 'SUCCESS' -Started $stageStart -AffectedCount $tasks.Count}catch{Add-StageResult -Name 'CAPTURE_TASKS' -Status 'WARNING' -Started $stageStart -ErrorCode 'TASK_CAPTURE_FAILED' -ErrorMessage $_.Exception.Message}
$stageStart=[DateTime]::UtcNow;try{$services=@(Get-ServiceEvidence -TargetIdentities $targetIdentities -AllScope $allScope);$script:State.evidence.services=$services;Add-StageResult -Name 'CAPTURE_SERVICES' -Status 'SUCCESS' -Started $stageStart -AffectedCount $services.Count}catch{Add-StageResult -Name 'CAPTURE_SERVICES' -Status 'WARNING' -Started $stageStart -ErrorCode 'SERVICE_CAPTURE_FAILED' -ErrorMessage $_.Exception.Message}
$stageStart=[DateTime]::UtcNow;try{$processIds=@($script:State.evidence.processes | ForEach-Object {[int]$_.processId});$connections=@(Get-NetworkConnectionEvidence -ProcessIds $processIds);$script:State.evidence.networkConnections=$connections;Add-StageResult -Name 'CAPTURE_NETWORK_CONNECTIONS' -Status 'SUCCESS' -Started $stageStart -AffectedCount $connections.Count}catch{Add-StageResult -Name 'CAPTURE_NETWORK_CONNECTIONS' -Status 'WARNING' -Started $stageStart -ErrorCode 'NETWORK_CAPTURE_FAILED' -ErrorMessage $_.Exception.Message}

$stageStart=[DateTime]::UtcNow
if($allScope){
try{$domainContext=Get-LocalDomainContext;$script:State.actions.domainContext=$domainContext
if((-not $domainContext.partOfDomain) -and $domainContext.azureAdJoined){$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'DISCOVER_DOMAIN_CONTEXT' -Status 'FAILED' -Started $stageStart -ErrorCode 'ENTRA_ONLY_ALL_SCOPE_UNSUPPORTED' -ErrorMessage 'ALL scope cannot guarantee full sign-in isolation on an Entra-only device in V1.4.0. No security change was applied.';Write-Remarks;exit 31}
if($domainContext.partOfDomain){
$dcDiscovery=Get-DomainControllerDiscovery -DomainName $domainContext.domainName
$plan=New-AuthFirewallPlan -DomainContext $domainContext -DcDiscovery $dcDiscovery
$script:State.actions.authFirewall=$plan
if($plan.warningCode){
$warningMessage=switch([string]$plan.warningCode){
'DC_ADDRESS_UNRESOLVED_USING_CONFIGURED_DNS_SERVERS' {'DC address resolution was unavailable. Configured DNS server addresses are used as scoped dynamic-RPC candidates while fixed AD ports are blocked globally.'}
'DC_DISCOVERY_PARTIAL_GLOBAL_FIXED_FALLBACK' {'DC addresses were obtained from local or partial sources. Fixed AD ports are blocked globally and dynamic RPC is blocked to the known addresses.'}
default {'No DC or DNS-server candidate address was available. Fixed AD ports are blocked globally; broad ALL-scope user-right guards remain the primary sign-in control.'}
}
Add-StageResult -Name 'DISCOVER_DOMAIN_CONTEXT' -Status 'WARNING' -Started $stageStart -ErrorCode $plan.warningCode -ErrorMessage $warningMessage -Expected 'Domain and DC addresses where available' -Actual "$($domainContext.domainName);Mode=$($plan.mode);IPs=$(@($plan.remoteAddresses).Count)"
}else{
Add-StageResult -Name 'DISCOVER_DOMAIN_CONTEXT' -Status 'SUCCESS' -Started $stageStart -Expected 'Domain and DC addresses' -Actual "$($domainContext.domainName);DCs=$(@($plan.dcNames).Count);IPs=$(@($plan.remoteAddresses).Count)"
}
}
else{$script:State.actions.authFirewall=New-AuthFirewallPlan -DomainContext $domainContext -DcDiscovery $null;Add-StageResult -Name 'DISCOVER_DOMAIN_CONTEXT' -Status 'NOT_APPLICABLE' -Started $stageStart -Message 'Device is not domain joined.'}}
catch{$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'DISCOVER_DOMAIN_CONTEXT' -Status 'FAILED' -Started $stageStart -ErrorCode 'DOMAIN_CONTEXT_DISCOVERY_FAILED' -ErrorMessage $_.Exception.Message;Write-Remarks;exit 29}
}else{Add-StageResult -Name 'DISCOVER_DOMAIN_CONTEXT' -Status 'NOT_APPLICABLE' -Started $stageStart}

$stageStart=[DateTime]::UtcNow
if($allScope -and [bool]$SaveLaps -and $script:State.actions.domainContext -and [bool]$script:State.actions.domainContext.partOfDomain) {
$hasDomainGroupGuard=($scopeGuardIdentities.Count -gt 0)
$hasScopedDynamicRpc=@($script:State.actions.authFirewall.ruleDefinitions | Where-Object {$_.name -like '*RPCDynamic' -and @($_.remoteAddresses).Count -gt 0}).Count -gt 0
if(-not $hasDomainGroupGuard -or -not $hasScopedDynamicRpc) {
$script:State.status='FAILED_PRECHECK'
Add-StageResult -Name 'VALIDATE_SAVELAPS_ISOLATION' -Status 'FAILED' -Started $stageStart -ErrorCode 'SAVELAPS_FULL_DOMAIN_ISOLATION_NOT_VERIFIED' -ErrorMessage 'SaveLaps requires both cached domain-group guard SIDs and a scoped dynamic-RPC firewall target. No security change was applied.' -Expected 'Domain group guards and scoped dynamic RPC rule' -Actual "DomainGuards=$($scopeGuardIdentities.Count);ScopedDynamicRpc=$hasScopedDynamicRpc"
Write-Remarks
exit 31
}
Add-StageResult -Name 'VALIDATE_SAVELAPS_ISOLATION' -Status 'SUCCESS' -Started $stageStart -Expected 'Domain group guards and scoped dynamic RPC rule' -Actual "DomainGuards=$($scopeGuardIdentities.Count);ScopedDynamicRpc=$hasScopedDynamicRpc"
} else {
Add-StageResult -Name 'VALIDATE_SAVELAPS_ISOLATION' -Status 'NOT_APPLICABLE' -Started $stageStart
}

$stageStart=[DateTime]::UtcNow
try{$script:State.originalState.cachedLogonsCount=Get-CachedLogonState;if($allScope -and [bool]$script:State.actions.domainContext.partOfDomain){$script:State.originalState.netlogon=Get-NetlogonState;$script:State.originalState.kdcProxy=Get-KdcProxyState};Add-StageResult -Name 'CAPTURE_ORIGINAL_SECURITY_STATE' -Status 'SUCCESS' -Started $stageStart}
catch{$script:State.status='FAILED_PRECHECK';Add-StageResult -Name 'CAPTURE_ORIGINAL_SECURITY_STATE' -Status 'FAILED' -Started $stageStart -ErrorCode 'SECURITY_STATE_CAPTURE_FAILED' -ErrorMessage $_.Exception.Message;Write-Remarks;exit 30}

$script:State.status='APPLYING';Write-StateCheckpoint
$stageStart=[DateTime]::UtcNow
try{
$rightsResult=Add-DenyRights -Identities $enforcementIdentities -AllScope $allScope
$script:State.originalState.userRights=$rightsResult.Records
$script:State.actions.protectedIdentityCount=[int]$rightsResult.ProtectedIdentityCount

$guardSids=@($scopeGuardIdentities | ForEach-Object {[string]$_.sid})
$guardRecords=@($rightsResult.Records | Where-Object {[string]$_.sid -in $guardSids})
$guardVerified=@($guardRecords | Where-Object {[bool]$_.verificationComplete}).Count
if($allScope){
$script:State.actions.scopeGuard.verifiedCount=$guardVerified
$script:State.actions.scopeGuard.status=if($guardVerified -eq $scopeGuardIdentities.Count -and $scopeGuardIdentities.Count -gt 0){'VERIFIED'}elseif($scopeGuardIdentities.Count -eq 0){'UNAVAILABLE'}else{'FAILED'}
}

$failureText=(@($rightsResult.Failures) | ForEach-Object {"$($_.accountName):$($_.right):$($_.error)"}) -join ' | '
$mandatoryGuardFailed=($allScope -and -not [bool]$SaveLaps -and ($guardVerified -ne 1))

if($mandatoryGuardFailed){
$script:State.actions.denyRights='FAILED'
$script:State.actions.changesApplied=($rightsResult.AffectedCount -gt 0)
Add-StageResult -Name 'APPLY_DENY_RIGHTS' -Status 'FAILED' -Started $stageStart -AffectedCount $rightsResult.AffectedCount -ErrorCode 'ALL_SCOPE_EVERYONE_GUARD_FAILED' -ErrorMessage $(if($failureText){$failureText}else{'The Everyone interactive/RDP/network deny guard was not verified.'}) -Expected "$($enforcementIdentities.Count) identities including Everyone guard verified" -Actual "$($rightsResult.ProtectedIdentityCount) verified"
}
elseif(@($rightsResult.Failures).Count -gt 0){
$script:State.actions.denyRights='PARTIAL'
$script:State.actions.changesApplied=($rightsResult.AffectedCount -gt 0)
Add-StageResult -Name 'APPLY_DENY_RIGHTS' -Status 'WARNING' -Started $stageStart -AffectedCount $rightsResult.AffectedCount -ErrorCode 'ONE_OR_MORE_DENY_RIGHTS_FAILED' -ErrorMessage $failureText -Expected "$($enforcementIdentities.Count) enforcement identities verified" -Actual "$($rightsResult.ProtectedIdentityCount) verified"
}
else{
$script:State.actions.denyRights='SUCCESS'
$script:State.actions.changesApplied=$true
Add-StageResult -Name 'APPLY_DENY_RIGHTS' -Status 'SUCCESS' -Started $stageStart -AffectedCount $rightsResult.AffectedCount -Expected "$($enforcementIdentities.Count) enforcement identities verified" -Actual "$($rightsResult.ProtectedIdentityCount) verified"
}
}
catch{$script:State.actions.denyRights='FAILED';Add-StageResult -Name 'APPLY_DENY_RIGHTS' -Status 'FAILED' -Started $stageStart -ErrorCode 'DENY_RIGHTS_FAILED' -ErrorMessage $_.Exception.Message}

$stageStart=[DateTime]::UtcNow
try{Disable-CachedDomainLogon;$current=[string](Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon' -Name CachedLogonsCount -ErrorAction Stop).CachedLogonsCount;$script:State.actions.cachedDomainLogon='DISABLED';$script:State.actions.changesApplied=$true;Add-StageResult -Name 'DISABLE_CACHED_DOMAIN_LOGON' -Status 'SUCCESS' -Started $stageStart -AffectedCount 1 -Expected '0' -Actual $current}
catch{$script:State.actions.cachedDomainLogon='FAILED';Add-StageResult -Name 'DISABLE_CACHED_DOMAIN_LOGON' -Status 'FAILED' -Started $stageStart -ErrorCode 'CACHED_LOGON_DISABLE_FAILED' -ErrorMessage $_.Exception.Message -Expected '0' -Actual 'UNVERIFIED'}

$domainIsolationRequired=$allScope -and [bool]$script:State.actions.domainContext.partOfDomain
if($domainIsolationRequired){
$stageStart=[DateTime]::UtcNow;try{Disable-Netlogon;$script:State.actions.domainAuthIsolation='PARTIAL';$script:State.actions.changesApplied=$true;$net=Get-NetlogonState;Add-StageResult -Name 'DISABLE_NETLOGON' -Status 'SUCCESS' -Started $stageStart -AffectedCount 1 -Expected 'Stopped/Disabled' -Actual "$($net.state)/$($net.startMode)"}catch{Add-StageResult -Name 'DISABLE_NETLOGON' -Status 'FAILED' -Started $stageStart -ErrorCode 'NETLOGON_DISABLE_FAILED' -ErrorMessage $_.Exception.Message}
$stageStart=[DateTime]::UtcNow;try{Disable-KdcProxy;$kdc=Get-KdcProxyState;$kdcPass=($kdc.enabledValueExisted -and [int]$kdc.enabledValue -eq 0 -and -not $kdc.mappingPathExisted);if(-not $kdcPass){throw 'KDC proxy post-change verification failed.'};Add-StageResult -Name 'DISABLE_KDC_PROXY' -Status 'SUCCESS' -Started $stageStart -Expected 'Disabled and mappings absent' -Actual 'Verified'}catch{Add-StageResult -Name 'DISABLE_KDC_PROXY' -Status 'WARNING' -Started $stageStart -ErrorCode 'KDC_PROXY_DISABLE_FAILED' -ErrorMessage $_.Exception.Message}
$stageStart=[DateTime]::UtcNow;try{$created=Apply-AuthFirewallRules -Plan $script:State.actions.authFirewall;$script:State.actions.domainAuthIsolation='SUCCESS';$script:State.actions.changesApplied=$true;Add-StageResult -Name 'APPLY_AUTH_FIREWALL' -Status 'SUCCESS' -Started $stageStart -AffectedCount $created.Count -Expected "$(@($script:State.actions.authFirewall.ruleDefinitions).Count) rules active" -Actual "$($created.Count) rules verified;Mode=$($script:State.actions.authFirewall.mode)"}catch{$script:State.actions.domainAuthIsolation='FAILED';Add-StageResult -Name 'APPLY_AUTH_FIREWALL' -Status 'FAILED' -Started $stageStart -ErrorCode 'AUTH_FIREWALL_FAILED' -ErrorMessage $_.Exception.Message}
}else{Add-StageResult -Name 'DISABLE_NETLOGON' -Status 'NOT_APPLICABLE' -Started ([DateTime]::UtcNow);Add-StageResult -Name 'DISABLE_KDC_PROXY' -Status 'NOT_APPLICABLE' -Started ([DateTime]::UtcNow);Add-StageResult -Name 'APPLY_AUTH_FIREWALL' -Status 'NOT_APPLICABLE' -Started ([DateTime]::UtcNow);$script:State.actions.domainAuthIsolation='NOT_APPLICABLE'}

$scopeGuardCritical=((-not $allScope) -or ([bool]$SaveLaps) -or ([string]$script:State.actions.scopeGuard.status -eq 'VERIFIED'))
$criticalProtectionApplied=$scopeGuardCritical -and ([int]$script:State.actions.protectedIdentityCount -gt 0) -and ((Get-StageStatus 'DISABLE_CACHED_DOMAIN_LOGON') -eq 'SUCCESS') -and ((-not $domainIsolationRequired) -or (((Get-StageStatus 'DISABLE_NETLOGON') -eq 'SUCCESS') -and ((Get-StageStatus 'APPLY_AUTH_FIREWALL') -eq 'SUCCESS')))
if(-not $criticalProtectionApplied){$script:State.status='LOCKDOWN_PARTIAL';$script:State.completedUtc=Get-UtcTimestamp;Add-StageResult -Name 'INSTALL_POSTBOOT_VERIFIER' -Status 'SKIPPED' -Started ([DateTime]::UtcNow);Add-StageResult -Name 'PREPARE_DISRUPTION_CHECKPOINT' -Status 'SKIPPED';Add-StageResult -Name 'INSTALL_DISRUPTION_WORKER' -Status 'SKIPPED';Add-StageResult -Name 'START_DISRUPTION_WORKER' -Status 'SKIPPED' -Started ([DateTime]::UtcNow);Add-StageResult -Name 'DISRUPTION_DELEGATED' -Status 'SKIPPED' -Started ([DateTime]::UtcNow);Add-StageResult -Name 'LOGOFF_SESSIONS' -Status 'SKIPPED' -Started ([DateTime]::UtcNow);Add-StageResult -Name 'SCHEDULE_REBOOT' -Status 'SKIPPED' -Started ([DateTime]::UtcNow) -ErrorCode 'CRITICAL_PROTECTION_INCOMPLETE' -ErrorMessage 'Reboot was not scheduled because one or more required protections failed.';Add-StageResult -Name 'FINALIZE_STATE' -Status 'WARNING' -Started ([DateTime]::UtcNow) -ErrorCode 'LOCKDOWN_PARTIAL' -ErrorMessage 'Review state and restore or remediate before retrying.';Write-Remarks;exit 40}

$stageStart=[DateTime]::UtcNow
try{Install-PostBootVerifier -Operation 'LOCKDOWN';Add-StageResult -Name 'INSTALL_POSTBOOT_VERIFIER' -Status 'SUCCESS' -Started $stageStart -AffectedCount 1 -Expected 'Startup task query succeeds' -Actual $PostBootTaskName}
catch{Add-StageResult -Name 'INSTALL_POSTBOOT_VERIFIER' -Status 'WARNING' -Started $stageStart -ErrorCode 'POSTBOOT_VERIFIER_INSTALL_FAILED' -ErrorMessage $_.Exception.Message}

$script:State.actions.sessionTelemetry.pendingLogoffSessionIds=@($sessionIds)
$script:State.status='ACTIVE_DISRUPTION_PENDING'
$stageStart=[DateTime]::UtcNow
Add-StageResult -Name 'PREPARE_DISRUPTION_CHECKPOINT' -Status 'SUCCESS' -Started $stageStart -Message 'All rollback and enforcement data were persisted before independent logoff/reboot orchestration.'

$workerReady=$false
$stageStart=[DateTime]::UtcNow
try{Install-DisruptionWorker;Add-StageResult -Name 'INSTALL_DISRUPTION_WORKER' -Status 'SUCCESS' -Started $stageStart -AffectedCount 1 -Expected 'ACL-protected SYSTEM task registered' -Actual $DisruptionTaskName;$workerReady=$true}
catch{Add-StageResult -Name 'INSTALL_DISRUPTION_WORKER' -Status 'FAILED' -Started $stageStart -ErrorCode 'DISRUPTION_WORKER_INSTALL_FAILED' -ErrorMessage $_.Exception.Message}

if($workerReady){
Add-StageResult -Name 'DISRUPTION_DELEGATED' -Status 'SUCCESS' -Started ([DateTime]::UtcNow) -Expected 'Independent SYSTEM worker owns logoff and reboot actions' -Actual $DisruptionTaskName -Verification 'PASS'
$stageStart=[DateTime]::UtcNow
try{$taskState=Start-DisruptionWorker;Add-StageResult -Name 'START_DISRUPTION_WORKER' -Status 'SUCCESS' -Started $stageStart -AffectedCount 1 -Expected 'Task started independently from EPC execution session' -Actual $taskState}
catch{Add-StageResult -Name 'START_DISRUPTION_WORKER' -Status 'FAILED' -Started $stageStart -ErrorCode 'DISRUPTION_WORKER_START_FAILED' -ErrorMessage $_.Exception.Message;$workerReady=$false}
}else{
Add-StageResult -Name 'START_DISRUPTION_WORKER' -Status 'SKIPPED' -Started ([DateTime]::UtcNow)
}

if(-not $workerReady){
try{Cancel-DisruptionWorker -Reason 'Worker unavailable; direct reboot fallback used.'}catch{}
$stageStart=[DateTime]::UtcNow
try{Schedule-Reboot;Add-StageResult -Name 'SCHEDULE_REBOOT' -Status 'SUCCESS' -Started $stageStart -AffectedCount 1 -Expected 'shutdown.exe accepted restart request' -Actual "ExitCode=0;Delay=$RebootDelaySeconds seconds" -Verification 'PENDING';Add-StageResult -Name 'LOGOFF_SESSIONS' -Status 'WARNING' -Started ([DateTime]::UtcNow) -ErrorCode 'LOGOFF_DEFERRED_TO_REBOOT' -ErrorMessage 'The independent worker was unavailable. Target sessions will be terminated by the forced reboot.' -Expected 'Immediate target sign-out' -Actual 'Deferred to reboot'}
catch{try{Cancel-PostBootVerifier -Reason 'Disruption worker and direct reboot fallback both failed.'}catch{};Add-StageResult -Name 'SCHEDULE_REBOOT' -Status 'FAILED' -Started $stageStart -ErrorCode 'REBOOT_SCHEDULE_FAILED' -ErrorMessage $_.Exception.Message;Add-StageResult -Name 'LOGOFF_SESSIONS' -Status 'SKIPPED' -Started ([DateTime]::UtcNow)}
}

$stageStart=[DateTime]::UtcNow
$script:State.completedUtc=Get-UtcTimestamp
$script:State.status=if($workerReady){'ACTIVE_DISRUPTION_PENDING'}elseif((Get-StageStatus 'SCHEDULE_REBOOT') -eq 'SUCCESS'){'ACTIVE_PENDING_REBOOT'}else{'LOCKDOWN_PARTIAL'}
Add-StageResult -Name 'FINALIZE_STATE' -Status $(if($script:State.status -in @('ACTIVE_DISRUPTION_PENDING','ACTIVE_PENDING_REBOOT')){'SUCCESS'}else{'WARNING'}) -Started $stageStart -ErrorCode $(if($script:State.status -in @('ACTIVE_DISRUPTION_PENDING','ACTIVE_PENDING_REBOOT')){$null}else{'LOCKDOWN_PARTIAL'}) -ErrorMessage $(if($script:State.status -in @('ACTIVE_DISRUPTION_PENDING','ACTIVE_PENDING_REBOOT')){$null}else{'Lockdown completed with warnings or failures. Review the state file.'})
Write-Remarks;exit $(if($script:State.status -in @('ACTIVE_DISRUPTION_PENDING','ACTIVE_PENDING_REBOOT')){0}else{2})
}
catch{
try{$script:State.status='UNHANDLED_FAILURE';$script:State.completedUtc=Get-UtcTimestamp;Add-ErrorRecord -Code 'UNHANDLED_EXCEPTION' -Message $_.Exception.Message -Stage 'UNHANDLED';if($script:StateWriteEnabled){Write-StateCheckpoint};Write-Remarks}catch{[Console]::Out.WriteLine((([ordered]@{script='EmergencyLockdown';version=$ScriptVersion;operation='LOCKDOWN';result='FAILED';failed='UNHANDLED_EXCEPTION;REMARKS_GENERATION_FAILED';message=$_.Exception.Message}) | ConvertTo-Json -Compress))}
exit 99
}

<#
.SYNOPSIS
Techaptic - Endpoint Central Emergency Restore Script (V1.4.0)

.DESCRIPTION
This Techaptic script restores only the access and security changes recorded by the matching
Emergency Lockdown state file. It is designed to run as SYSTEM through ManageEngine Endpoint
Central and accepts no operator parameters.

Restore removes only the recorded Lockdown deltas. It does not recreate user sessions, restart
previously running applications, or start unrelated services and scheduled tasks. A temporary
post-boot verifier script may appear in the protected state directory after restart and removes
itself after the final verification is written to the JSON state file.

.EXAMPLE
.\Techaptic-EPC-EmergencyRestore-v1.4.0.ps1

.NOTES
Author : Techaptic
Maintainer : Techaptic
Script : Endpoint Central Emergency Restore
Version : 1.4.0
Execution : Endpoint Central Computer Configuration / Run as SYSTEM
State File : C:\ProgramData\EmergencyLockdown\EmergencyLockdown.json

IMPORTANT SAFETY NOTES:
- Use this script only with a valid state file created by the corresponding Techaptic Lockdown
script.
- Do not delete, rename, replace, or manually edit EmergencyLockdown.json before Restore.
- Validate the complete Lockdown and Restore cycle in a representative test environment before
any production use.
- Restore may initiate a restart. Endpoint Central Remarks is the immediate execution result;
the final reboot verification is written to the protected JSON state file.
- A temporary EmergencyPostBootVerify.ps1 file after restart is expected and normally deletes
itself after verification completes.
- Do not modify embedded Base64 components, internal task names, state paths, or rollback logic
unless the complete test matrix is repeated.
- Customer change approval, backup, rollback, access-control, and production validation
procedures remain mandatory.
#>
[CmdletBinding()]
param()
Set-StrictMode -Version 2.0
$ErrorActionPreference='Stop'
$ProgressPreference='SilentlyContinue'
$ScriptVersion='1.4.0'
$BaseDirectory=Join-Path $env:ProgramData 'EmergencyLockdown'
$StatePath=Join-Path $BaseDirectory 'EmergencyLockdown.json'
$TemporaryStatePath=Join-Path $BaseDirectory 'EmergencyLockdown.tmp'
$RebootDelaySeconds=60
$PostBootVerifierPath=Join-Path $BaseDirectory 'EmergencyPostBootVerify.ps1'
$PostBootTaskName='EmergencyLockdown-PostBootVerify-v140'
$DisruptionWorkerPath=Join-Path $BaseDirectory 'EmergencyDisruptionWorker.ps1'
$DisruptionTaskNames=@('EmergencyLockdown-DisruptionWorker-v140','EmergencyLockdown-DisruptionWorker-v135','EmergencyLockdown-DisruptionWorker-v134','EmergencyLockdown-DisruptionWorker-v133','EmergencyLockdown-DisruptionWorker-v132','EmergencyLockdown-DisruptionWorker-v131')
$PostBootVerifierBase64 = '<#
.SYNOPSIS
    Automatic post-boot verification component for Emergency Lockdown V1.4.0.
.DESCRIPTION
    Generated and registered internally by the Lockdown/Restore scripts.
    It runs as SYSTEM after reboot, verifies effective state, updates the ACL-protected JSON, and removes its own task.
    It is not an operator-facing Endpoint Central script.
#>
param()
Set-StrictMode -Version 2.0
$ErrorActionPreference = 'Stop'
$ProgressPreference = 'SilentlyContinue'

$BaseDirectory = Join-Path $env:ProgramData 'EmergencyLockdown'
$StatePath = Join-Path $BaseDirectory 'EmergencyLockdown.json'
$TemporaryStatePath = Join-Path $BaseDirectory 'EmergencyLockdown.tmp'
$TaskName = 'EmergencyLockdown-PostBootVerify-v140'
$script:VerificationRecorded = $false
Start-Sleep -Seconds 60

function Get-UtcTimestamp { [DateTime]::UtcNow.ToString('o') }
function Get-PropertyValue {
    param($Object,[string]$Name,$Default=$null)
    if ($null -eq $Object) { return $Default }
    $property = $Object.PSObject.Properties[$Name]
    if ($null -eq $property) { return $Default }
    return $property.Value
}

function Initialize-WtsNativeType {
    if ('EmergencySecurity.PostBootWtsV140' -as [type]) { return }
    $source = @'
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.InteropServices;
namespace EmergencySecurity
{
    public static class PostBootWtsV140
    {
        [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
        private struct WTS_SESSION_INFO { public int SessionID; public string pWinStationName; public int State; }
        private enum WTS_INFO_CLASS { WTSInitialProgram, WTSApplicationName, WTSWorkingDirectory, WTSOEMId, WTSSessionId, WTSUserName, WTSWinStationName, WTSDomainName }
        [DllImport("wtsapi32.dll", SetLastError=true)] private static extern bool WTSEnumerateSessions(IntPtr hServer, int Reserved, int Version, out IntPtr ppSessionInfo, out int pCount);
        [DllImport("wtsapi32.dll")] private static extern void WTSFreeMemory(IntPtr pMemory);
        [DllImport("wtsapi32.dll", CharSet=CharSet.Unicode, SetLastError=true)] private static extern bool WTSQuerySessionInformation(IntPtr hServer, int sessionId, WTS_INFO_CLASS infoClass, out IntPtr ppBuffer, out int pBytesReturned);
        private static string Query(int sessionId, WTS_INFO_CLASS infoClass) { IntPtr p=IntPtr.Zero; int bytes=0; try { if(!WTSQuerySessionInformation(IntPtr.Zero,sessionId,infoClass,out p,out bytes)) return ""; return p==IntPtr.Zero ? "" : Marshal.PtrToStringUni(p); } finally { if(p!=IntPtr.Zero) WTSFreeMemory(p); } }
        public static string[] GetSessions() { IntPtr buffer=IntPtr.Zero; int count=0; List<string> result=new List<string>(); try { if(!WTSEnumerateSessions(IntPtr.Zero,0,1,out buffer,out count)) throw new Win32Exception(Marshal.GetLastWin32Error()); int size=Marshal.SizeOf(typeof(WTS_SESSION_INFO)); for(int i=0;i<count;i++){ WTS_SESSION_INFO item=(WTS_SESSION_INFO)Marshal.PtrToStructure(IntPtr.Add(buffer,i*size),typeof(WTS_SESSION_INFO)); string user=Query(item.SessionID,WTS_INFO_CLASS.WTSUserName); string domain=Query(item.SessionID,WTS_INFO_CLASS.WTSDomainName); result.Add(item.SessionID+"|"+domain+"|"+user+"|"+item.State); } return result.ToArray(); } finally { if(buffer!=IntPtr.Zero) WTSFreeMemory(buffer); } }
    }
}
'@
    Add-Type -TypeDefinition $source -Language CSharp -ErrorAction Stop | Out-Null
}
function Get-WtsSessions {
    $items = @()
    foreach ($line in [EmergencySecurity.PostBootWtsV140]::GetSessions()) {
        $parts = $line.Split('|')
        if ($parts.Count -lt 4) { continue }
        $id = [int]$parts[0]
        $domain = [string]$parts[1]
        $user = [string]$parts[2]
        if ($id -le 0 -or [string]::IsNullOrWhiteSpace($user)) { continue }
        $account = if ([string]::IsNullOrWhiteSpace($domain)) { $user } else { "$domain\$user" }
        $items += [pscustomobject]@{sessionId=$id;accountName=$account;state=[int]$parts[3]}
    }
    return $items
}
function Normalize-SessionAccountName {
    param([string]$Name)
    if ([string]::IsNullOrWhiteSpace($Name)) { return '' }
    $value=$Name.Trim()
    if ($value.StartsWith('.\')) { return "$env:COMPUTERNAME\$($value.Substring(2))".ToLowerInvariant() }
    return $value.ToLowerInvariant()
}
function Set-SecureDirectoryAcl {
    param([string]$Path)
    if (-not (Test-Path -LiteralPath $Path)) { $null = New-Item -Path $Path -ItemType Directory -Force }
    $systemSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-18')
    $administratorsSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
    $inheritance = [System.Security.AccessControl.InheritanceFlags]::ContainerInherit -bor [System.Security.AccessControl.InheritanceFlags]::ObjectInherit
    $security = [System.Security.AccessControl.DirectorySecurity]::new()
    $security.SetAccessRuleProtection($true,$false)
    $security.SetOwner($systemSid)
    $security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($systemSid,[System.Security.AccessControl.FileSystemRights]::FullControl,$inheritance,[System.Security.AccessControl.PropagationFlags]::None,[System.Security.AccessControl.AccessControlType]::Allow))
    $security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($administratorsSid,[System.Security.AccessControl.FileSystemRights]::FullControl,$inheritance,[System.Security.AccessControl.PropagationFlags]::None,[System.Security.AccessControl.AccessControlType]::Allow))
    [System.IO.DirectoryInfo]::new($Path).SetAccessControl($security)
}
function Set-SecureFileAcl {
    param([string]$Path)
    if (-not (Test-Path -LiteralPath $Path)) { return }
    $systemSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-18')
    $administratorsSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
    $security = [System.Security.AccessControl.FileSecurity]::new()
    $security.SetAccessRuleProtection($true,$false)
    $security.SetOwner($systemSid)
    $security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($systemSid,[System.Security.AccessControl.FileSystemRights]::FullControl,[System.Security.AccessControl.AccessControlType]::Allow))
    $security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($administratorsSid,[System.Security.AccessControl.FileSystemRights]::FullControl,[System.Security.AccessControl.AccessControlType]::Allow))
    [System.IO.FileInfo]::new($Path).SetAccessControl($security)
}
function Write-State {
    param($State)
    Set-SecureDirectoryAcl -Path $BaseDirectory
    $json = $State | ConvertTo-Json -Depth 24
    [System.IO.File]::WriteAllText($TemporaryStatePath,$json,[System.Text.UTF8Encoding]::new($false))
    Set-SecureFileAcl -Path $TemporaryStatePath
    Move-Item -LiteralPath $TemporaryStatePath -Destination $StatePath -Force
    Set-SecureFileAcl -Path $StatePath
}
function New-Check {
    param([string]$Name,[ValidateSet('PASS','FAIL','WARNING','NOT_APPLICABLE')][string]$Status,[string]$Expected,[string]$Actual,[string]$Message=$null)
    [pscustomobject][ordered]@{name=$Name;status=$Status;expected=$Expected;actual=$Actual;message=$Message}
}
function Test-SecureAcl {
    param([string]$Path)
    try {
        $acl = Get-Acl -LiteralPath $Path -ErrorAction Stop
        $ownerSid = try { ([System.Security.Principal.NTAccount]$acl.Owner).Translate([System.Security.Principal.SecurityIdentifier]).Value } catch { [string]$acl.Owner }
        $allowed = @('S-1-5-18','S-1-5-32-544')
        $unexpected = @()
        foreach ($rule in @($acl.Access)) {
            $sid = try { $rule.IdentityReference.Translate([System.Security.Principal.SecurityIdentifier]).Value } catch { [string]$rule.IdentityReference }
            if ($rule.AccessControlType -ne 'Allow' -or $sid -notin $allowed) { $unexpected += $sid }
        }
        return [pscustomobject]@{Pass=($acl.AreAccessRulesProtected -and $ownerSid -eq 'S-1-5-18' -and $unexpected.Count -eq 0);Owner=$ownerSid;Protected=[bool]$acl.AreAccessRulesProtected;Unexpected=($unexpected -join ';')}
    } catch { return [pscustomobject]@{Pass=$false;Owner='UNKNOWN';Protected=$false;Unexpected=$_.Exception.Message} }
}
function Initialize-LsaNativeType {
    if ('EmergencySecurity.PostBootNativeV140' -as [type]) { return }
    $source = @'
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Security.Principal;
namespace EmergencySecurity
{
    public static class PostBootNativeV140
    {
        [StructLayout(LayoutKind.Sequential)] private struct LSA_OBJECT_ATTRIBUTES { public int Length; public IntPtr RootDirectory; public IntPtr ObjectName; public uint Attributes; public IntPtr SecurityDescriptor; public IntPtr SecurityQualityOfService; }
        [StructLayout(LayoutKind.Sequential)] private struct LSA_UNICODE_STRING { public ushort Length; public ushort MaximumLength; public IntPtr Buffer; }
        [DllImport("advapi32.dll")] private static extern uint LsaOpenPolicy(IntPtr SystemName, ref LSA_OBJECT_ATTRIBUTES ObjectAttributes, uint DesiredAccess, out IntPtr PolicyHandle);
        [DllImport("advapi32.dll")] private static extern uint LsaEnumerateAccountRights(IntPtr PolicyHandle, IntPtr AccountSid, out IntPtr UserRights, out uint CountOfRights);
        [DllImport("advapi32.dll")] private static extern uint LsaNtStatusToWinError(uint Status);
        [DllImport("advapi32.dll")] private static extern uint LsaClose(IntPtr PolicyHandle);
        [DllImport("advapi32.dll")] private static extern uint LsaFreeMemory(IntPtr Buffer);
        [DllImport("Netapi32.dll", CharSet=CharSet.Unicode)] private static extern int NetLocalGroupGetMembers(string servername, string localgroupname, int level, out IntPtr bufptr, int prefmaxlen, out int entriesread, out int totalentries, ref IntPtr resume_handle);
        [DllImport("Netapi32.dll")] private static extern int NetApiBufferFree(IntPtr Buffer);
        private const uint POLICY_LOOKUP_NAMES=0x00000800;
        private const uint STATUS_OBJECT_NAME_NOT_FOUND=0xC0000034;
        private const int MAX_PREFERRED_LENGTH=-1;
        private const int ERROR_MORE_DATA=234;
        private static IntPtr SidToPtr(string sidValue){ SecurityIdentifier sid=new SecurityIdentifier(sidValue); byte[] b=new byte[sid.BinaryLength]; sid.GetBinaryForm(b,0); IntPtr p=Marshal.AllocHGlobal(b.Length); Marshal.Copy(b,0,p,b.Length); return p; }
        public static string[] GetRights(string sidValue)
        {
            LSA_OBJECT_ATTRIBUTES loa=new LSA_OBJECT_ATTRIBUTES(); loa.Length=Marshal.SizeOf(typeof(LSA_OBJECT_ATTRIBUTES));
            IntPtr policy=IntPtr.Zero; IntPtr sid=IntPtr.Zero; IntPtr rights=IntPtr.Zero;
            try
            {
                uint status=LsaOpenPolicy(IntPtr.Zero,ref loa,POLICY_LOOKUP_NAMES,out policy);
                if(status!=0) throw new Win32Exception((int)LsaNtStatusToWinError(status));
                sid=SidToPtr(sidValue); uint count;
                status=LsaEnumerateAccountRights(policy,sid,out rights,out count);
                if(status==STATUS_OBJECT_NAME_NOT_FOUND) return new string[0];
                if(status!=0) throw new Win32Exception((int)LsaNtStatusToWinError(status));
                List<string> list=new List<string>(); int size=Marshal.SizeOf(typeof(LSA_UNICODE_STRING));
                for(int i=0;i<count;i++) { LSA_UNICODE_STRING item=(LSA_UNICODE_STRING)Marshal.PtrToStructure(IntPtr.Add(rights,i*size),typeof(LSA_UNICODE_STRING)); list.Add(Marshal.PtrToStringUni(item.Buffer,item.Length/2)); }
                return list.ToArray();
            }
            finally { if(rights!=IntPtr.Zero)LsaFreeMemory(rights); if(sid!=IntPtr.Zero)Marshal.FreeHGlobal(sid); if(policy!=IntPtr.Zero)LsaClose(policy); }
        }

        public static string[] GetLocalGroupMemberSids(string groupName)
        {
            List<string> results=new List<string>();
            IntPtr resume=IntPtr.Zero;
            int status;
            do
            {
                IntPtr buffer=IntPtr.Zero;
                int entriesRead=0;
                int totalEntries=0;
                try
                {
                    status=NetLocalGroupGetMembers(null,groupName,0,out buffer,MAX_PREFERRED_LENGTH,out entriesRead,out totalEntries,ref resume);
                    if(status!=0 && status!=ERROR_MORE_DATA) throw new Win32Exception(status);
                    for(int i=0;i<entriesRead;i++)
                    {
                        IntPtr sidPtr=Marshal.ReadIntPtr(buffer,i*IntPtr.Size);
                        if(sidPtr!=IntPtr.Zero) results.Add(new SecurityIdentifier(sidPtr).Value);
                    }
                }
                finally { if(buffer!=IntPtr.Zero)NetApiBufferFree(buffer); }
            } while(status==ERROR_MORE_DATA);
            return results.ToArray();
        }
    }
}
'@
    Add-Type -TypeDefinition $source -Language CSharp -ErrorAction Stop | Out-Null
}
function Get-CachedLogonValue {
    $path='HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon'
    try { return [string](Get-ItemProperty -Path $path -Name CachedLogonsCount -ErrorAction Stop).CachedLogonsCount } catch { return $null }
}
function Get-KdcProxyState {
    $rootPath='HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\Kerberos'
    $mappingPath=Join-Path $rootPath 'KdcProxyServer'
    $enabledExists=$false; $enabled=$null; $mappings=@()
    if (Test-Path $rootPath) {
        $item=Get-ItemProperty -Path $rootPath -ErrorAction SilentlyContinue
        if ($null -ne $item -and $item.PSObject.Properties.Name -contains 'KdcProxyServer_Enabled') { $enabledExists=$true; $enabled=$item.KdcProxyServer_Enabled }
    }
    if (Test-Path $mappingPath) {
        $map=Get-ItemProperty -Path $mappingPath -ErrorAction SilentlyContinue
        if ($null -ne $map) { $mappings=@($map.PSObject.Properties | Where-Object {$_.Name -notlike 'PS*'} | ForEach-Object {"$($_.Name)=$([string]$_.Value)"} | Sort-Object) }
    }
    [pscustomobject]@{enabledExists=$enabledExists;enabled=$enabled;mappingExists=(Test-Path $mappingPath);mappings=$mappings}
}

function Get-FirewallEngineState {
    $serviceState='UNKNOWN'
    $enabledProfiles=@()
    $disabledProfiles=@()
    try {
        $service=Get-CimInstance Win32_Service -Filter "Name='MpsSvc'" -ErrorAction Stop
        $serviceState=[string]$service.State
    } catch { }
    try {
        foreach($profile in @(Get-NetFirewallProfile -ErrorAction Stop)) {
            if([bool]$profile.Enabled){$enabledProfiles += [string]$profile.Name}else{$disabledProfiles += [string]$profile.Name}
        }
    } catch { }
    [pscustomobject]@{
        serviceState=$serviceState
        enabledProfiles=@($enabledProfiles)
        disabledProfiles=@($disabledProfiles)
        pass=($serviceState -eq 'Running' -and $enabledProfiles.Count -gt 0)
    }
}

function Normalize-StartMode {
    param([string]$Value)
    switch ($Value) { 'Automatic' {'Auto'} 'Auto' {'Auto'} 'Manual' {'Manual'} 'Disabled' {'Disabled'} default {$Value} }
}
function Compare-KdcProxyRestore {
    param($Original,$Current)
    if ($null -eq $Original) { return $true }
    $expectedEnabledExists=[bool](Get-PropertyValue $Original 'enabledValueExisted' $false)
    $expectedEnabled=Get-PropertyValue $Original 'enabledValue' $null
    $expectedMapExists=[bool](Get-PropertyValue $Original 'mappingPathExisted' $false)
    $expectedMappings=@(Get-PropertyValue $Original 'mappings' @() | ForEach-Object {"$([string](Get-PropertyValue $_ 'name' ''))=$([string](Get-PropertyValue $_ 'value' ''))"} | Sort-Object)
    if ($Current.enabledExists -ne $expectedEnabledExists) { return $false }
    if ($expectedEnabledExists -and [string]$Current.enabled -ne [string]$expectedEnabled) { return $false }
    if ($Current.mappingExists -ne $expectedMapExists) { return $false }
    return ((@($Current.mappings) -join '|') -eq ($expectedMappings -join '|'))
}
function Convert-ToNormalizedSet {
    param($Value)
    $items=@()
    foreach($entry in @($Value)) {
        if($null -eq $entry){continue}
        $items += @(([string]$entry -split ',') | ForEach-Object {$_.Trim()} | Where-Object {$_})
    }
    return @($items | Sort-Object -Unique)
}
function Convert-ProtocolName {
    param($Value)
    $text=[string]$Value
    switch($text.ToUpperInvariant()) {'6' {'TCP'} '17' {'UDP'} default {$text.ToUpperInvariant()}}
}
function Test-FirewallPlan {
    param($Plan,[string]$Operation)
    $definitions=@(Get-PropertyValue $Plan 'ruleDefinitions' @())
    if ($definitions.Count -eq 0) { return [pscustomobject]@{Pass=$true;Actual='No rules required';Failures=@()} }
    $failures=@(); $actual=@()
    foreach($definition in $definitions) {
        $name=[string](Get-PropertyValue $definition 'name' '')
        $rule=@(Get-NetFirewallRule -Name $name -ErrorAction SilentlyContinue)
        if($Operation -eq 'RESTORE') {
            if($rule.Count -gt 0){$failures += "${name}:still-present"}
            continue
        }
        if($rule.Count -ne 1){$failures += "${name}:missing-or-duplicate";continue}
        $item=$rule[0]
        if([string]$item.Enabled -ne 'True' -or [string]$item.Action -ne 'Block' -or [string]$item.Direction -ne 'Outbound'){$failures += "${name}:rule-properties"}
        $portFilter=Get-NetFirewallPortFilter -AssociatedNetFirewallRule $item -ErrorAction SilentlyContinue
        $addressFilter=Get-NetFirewallAddressFilter -AssociatedNetFirewallRule $item -ErrorAction SilentlyContinue
        if($null -eq $portFilter -or $null -eq $addressFilter){$failures += "${name}:filter-unreadable";continue}
        $expectedProtocol=Convert-ProtocolName (Get-PropertyValue $definition 'protocol' '')
        $actualProtocol=Convert-ProtocolName $portFilter.Protocol
        $expectedPorts=Convert-ToNormalizedSet (Get-PropertyValue $definition 'remotePorts' @())
        $actualPorts=Convert-ToNormalizedSet $portFilter.RemotePort
        $expectedAddresses=Convert-ToNormalizedSet (Get-PropertyValue $definition 'remoteAddresses' @())
        $actualAddresses=Convert-ToNormalizedSet $addressFilter.RemoteAddress
        if($actualProtocol -ne $expectedProtocol){$failures += "${name}:protocol"}
        if(($actualPorts -join '|') -ne ($expectedPorts -join '|')){$failures += "${name}:remote-ports"}
        if(($actualAddresses -join '|') -ne ($expectedAddresses -join '|')){$failures += "${name}:remote-addresses"}
        $actual += "${name}[${actualProtocol}:$($actualPorts -join ',')=>$($actualAddresses -join ',')]"
    }
    [pscustomobject]@{Pass=($failures.Count -eq 0);Actual=($actual -join ' | ');Failures=$failures}
}

try {
    if (-not (Test-Path -LiteralPath $StatePath)) { exit 10 }
    $state=Get-Content -LiteralPath $StatePath -Raw -ErrorAction Stop | ConvertFrom-Json -ErrorAction Stop
    $pending=Get-PropertyValue $state 'postBootVerification' $null
    $operation=[string](Get-PropertyValue $pending 'operation' '')
    if ($operation -notin @('LOCKDOWN','RESTORE')) { exit 11 }

    Initialize-LsaNativeType
    Initialize-WtsNativeType
    $checks=@()
    $os=Get-CimInstance Win32_OperatingSystem -ErrorAction Stop
    $currentBoot=([datetime]$os.LastBootUpTime).ToUniversalTime()
    $bootBeforeText = if ($operation -eq 'LOCKDOWN') { [string](Get-PropertyValue (Get-PropertyValue $state 'actions' $null) 'bootTimeBefore' '') } else { [string](Get-PropertyValue $state 'restoreBootTimeBefore' '') }
    $bootBefore=$null
    try { if (-not [string]::IsNullOrWhiteSpace($bootBeforeText)) { $bootBefore=[datetime]::Parse($bootBeforeText).ToUniversalTime() } } catch { }
    $rebootPass=($null -ne $bootBefore -and $currentBoot -gt $bootBefore)
    $checks += New-Check -Name 'REBOOT' -Status $(if($rebootPass){'PASS'}else{'FAIL'}) -Expected 'Current boot time later than pre-change boot time' -Actual $currentBoot.ToString('o')

    $directoryAclBefore=Test-SecureAcl -Path $BaseDirectory
    $directoryAclAfter=$directoryAclBefore
    $directoryAclRepaired=$false
    if(-not $directoryAclBefore.Pass){
        try{Set-SecureDirectoryAcl -Path $BaseDirectory;$directoryAclAfter=Test-SecureAcl -Path $BaseDirectory;$directoryAclRepaired=[bool]$directoryAclAfter.Pass}catch{}
    }
    $directoryAclStatus=if($directoryAclBefore.Pass){'PASS'}elseif($directoryAclRepaired){'WARNING'}else{'FAIL'}
    $checks += New-Check -Name 'STATE_DIRECTORY_ACL' -Status $directoryAclStatus -Expected 'Owner SYSTEM, protected ACL, only SYSTEM and Administrators' -Actual "BeforeOwner=$($directoryAclBefore.Owner);BeforeProtected=$($directoryAclBefore.Protected);BeforeUnexpected=$($directoryAclBefore.Unexpected);Repaired=$directoryAclRepaired;AfterUnexpected=$($directoryAclAfter.Unexpected)" -Message $(if($directoryAclRepaired){'Unexpected directory ACL entries were removed by the post-boot verifier.'}else{$null})

    $aclBefore=Test-SecureAcl -Path $StatePath
    $aclAfter=$aclBefore
    $aclRepaired=$false
    if(-not $aclBefore.Pass){
        try{Set-SecureFileAcl -Path $StatePath;$aclAfter=Test-SecureAcl -Path $StatePath;$aclRepaired=[bool]$aclAfter.Pass}catch{}
    }
    $aclStatus=if($aclBefore.Pass){'PASS'}elseif($aclRepaired){'WARNING'}else{'FAIL'}
    $checks += New-Check -Name 'STATE_FILE_ACL' -Status $aclStatus -Expected 'Owner SYSTEM, protected ACL, only SYSTEM and Administrators' -Actual "BeforeOwner=$($aclBefore.Owner);BeforeProtected=$($aclBefore.Protected);BeforeUnexpected=$($aclBefore.Unexpected);Repaired=$aclRepaired;AfterUnexpected=$($aclAfter.Unexpected)" -Message $(if($aclRepaired){'Unexpected state-file ACL entries were removed by the post-boot verifier.'}else{$null})

    $verifierAclBefore=Test-SecureAcl -Path $PSCommandPath
    $verifierAclAfter=$verifierAclBefore
    $verifierAclRepaired=$false
    if(-not $verifierAclBefore.Pass){
        try{Set-SecureFileAcl -Path $PSCommandPath;$verifierAclAfter=Test-SecureAcl -Path $PSCommandPath;$verifierAclRepaired=[bool]$verifierAclAfter.Pass}catch{}
    }
    $verifierAclStatus=if($verifierAclBefore.Pass){'PASS'}elseif($verifierAclRepaired){'WARNING'}else{'FAIL'}
    $checks += New-Check -Name 'VERIFIER_FILE_ACL' -Status $verifierAclStatus -Expected 'Owner SYSTEM, protected ACL, only SYSTEM and Administrators' -Actual "BeforeOwner=$($verifierAclBefore.Owner);BeforeProtected=$($verifierAclBefore.Protected);BeforeUnexpected=$($verifierAclBefore.Unexpected);Repaired=$verifierAclRepaired;AfterUnexpected=$($verifierAclAfter.Unexpected)" -Message $(if($verifierAclRepaired){'Unexpected verifier-file ACL entries were removed by the post-boot verifier.'}else{$null})

    $currentCache=Get-CachedLogonValue
    if ($operation -eq 'LOCKDOWN') {
        $checks += New-Check -Name 'CACHED_DOMAIN_LOGON' -Status $(if($currentCache -eq '0'){'PASS'}else{'FAIL'}) -Expected '0' -Actual $(if($null -eq $currentCache){'<VALUE_ABSENT>'}else{$currentCache})
    } else {
        $original=Get-PropertyValue (Get-PropertyValue $state 'originalState' $null) 'cachedLogonsCount' $null
        $expected=if([bool](Get-PropertyValue $original 'existed' $false)){[string](Get-PropertyValue $original 'value' '')}else{'<VALUE_ABSENT>'}
        $actual=if($null -eq $currentCache){'<VALUE_ABSENT>'}else{$currentCache}
        $checks += New-Check -Name 'CACHED_DOMAIN_LOGON' -Status $(if($actual -eq $expected){'PASS'}else{'FAIL'}) -Expected $expected -Actual $actual
    }

    $rightsFailures=@(); $rightsChecked=0; $baselineWarnings=@(); $baselineChecked=0
    $records=@(Get-PropertyValue (Get-PropertyValue $state 'originalState' $null) 'userRights' @())
    foreach($record in $records) {
        try {
            $sid=[string](Get-PropertyValue $record 'sid' '')
            if ([string]::IsNullOrWhiteSpace($sid)) { continue }
            $accountLabel=[string](Get-PropertyValue $record 'accountName' $sid)
            $currentRights=@([EmergencySecurity.PostBootNativeV140]::GetRights($sid))
            if($operation -eq 'LOCKDOWN') {
                foreach($right in @(Get-PropertyValue $record 'requiredRights' @())) {
                    $rightsChecked++
                    if($right -notin $currentRights){$rightsFailures += "${accountLabel}:${right}:missing"}
                }
            }
            else {
                foreach($right in @(Get-PropertyValue $record 'rightsAdded' @())) {
                    $rightsChecked++
                    if($right -in $currentRights){$rightsFailures += "${accountLabel}:${right}:still-present"}
                }
                foreach($right in @(Get-PropertyValue $record 'rightsBefore' @())) {
                    $baselineChecked++
                    if($right -notin $currentRights){$baselineWarnings += "${accountLabel}:${right}:original-right-missing"}
                }
            }
        } catch { $rightsFailures += "$([string](Get-PropertyValue $record 'accountName' 'unknown')):enumeration-failed:$($_.Exception.Message)" }
    }
    $checks += New-Check -Name 'USER_RIGHTS' -Status $(if($rightsFailures.Count -eq 0){'PASS'}else{'FAIL'}) -Expected $(if($operation -eq 'LOCKDOWN'){'All required deny rights present'}else{'All Lockdown-added deny rights absent'}) -Actual $(if($rightsFailures.Count -eq 0){"Checked $rightsChecked assignments"}else{$rightsFailures -join ' | '})

    $scopeGuard=Get-PropertyValue (Get-PropertyValue $state 'actions' $null) 'scopeGuard' $null
    $scopeGuardPrincipals=@(Get-PropertyValue $scopeGuard 'principals' @())
    if($operation -eq 'LOCKDOWN' -and $scopeGuardPrincipals.Count -gt 0) {
        $scopeGuardFailures=@()
        foreach($principal in $scopeGuardPrincipals) {
            $guardSid=[string](Get-PropertyValue $principal 'sid' '')
            if([string]::IsNullOrWhiteSpace($guardSid)){continue}
            try {
                $guardRights=@([EmergencySecurity.PostBootNativeV140]::GetRights($guardSid))
                foreach($right in @('SeDenyInteractiveLogonRight','SeDenyRemoteInteractiveLogonRight','SeDenyNetworkLogonRight')) {
                    if($right -notin $guardRights){$scopeGuardFailures += "${guardSid}:${right}:missing"}
                }
            } catch {$scopeGuardFailures += "${guardSid}:enumeration-failed:$($_.Exception.Message)"}
        }
        $checks += New-Check -Name 'SCOPE_GUARD' -Status $(if($scopeGuardFailures.Count -eq 0){'PASS'}else{'FAIL'}) -Expected 'All broad ALL-scope interactive/RDP/network guard rights present' -Actual $(if($scopeGuardFailures.Count -eq 0){"$($scopeGuardPrincipals.Count) guard principal(s) verified"}else{$scopeGuardFailures -join ' | '})
    } elseif($operation -eq 'RESTORE' -and $scopeGuardPrincipals.Count -gt 0) {
        $scopeGuardFailures=@()
        foreach($principal in $scopeGuardPrincipals) {
            $guardSid=[string](Get-PropertyValue $principal 'sid' '')
            if([string]::IsNullOrWhiteSpace($guardSid)){continue}
            try {
                $guardRights=@([EmergencySecurity.PostBootNativeV140]::GetRights($guardSid))
                foreach($right in @('SeDenyInteractiveLogonRight','SeDenyRemoteInteractiveLogonRight','SeDenyNetworkLogonRight')) {
                    $record=@($records | Where-Object {[string](Get-PropertyValue $_ 'sid' '') -eq $guardSid} | Select-Object -First 1)
                    if($record.Count -gt 0 -and $right -in @(Get-PropertyValue $record[0] 'rightsAdded' @()) -and $right -in $guardRights){$scopeGuardFailures += "${guardSid}:${right}:still-present"}
                }
            } catch {$scopeGuardFailures += "${guardSid}:enumeration-failed:$($_.Exception.Message)"}
        }
        $checks += New-Check -Name 'SCOPE_GUARD' -Status $(if($scopeGuardFailures.Count -eq 0){'PASS'}else{'FAIL'}) -Expected 'Lockdown-added broad scope-guard rights absent' -Actual $(if($scopeGuardFailures.Count -eq 0){"$($scopeGuardPrincipals.Count) guard principal(s) restored"}else{$scopeGuardFailures -join ' | '})
    } else {
        $checks += New-Check -Name 'SCOPE_GUARD' -Status 'NOT_APPLICABLE' -Expected 'ALL scope guard' -Actual 'No scope guard recorded'
    }

    if($operation -eq 'RESTORE') {
        $checks += New-Check -Name 'USER_RIGHTS_ORIGINAL_BASELINE' -Status $(if($baselineWarnings.Count -eq 0){'PASS'}else{'WARNING'}) -Expected 'Pre-existing user rights remain present' -Actual $(if($baselineWarnings.Count -eq 0){"Checked $baselineChecked original assignments"}else{$baselineWarnings -join ' | '})
    }
    else {
        $checks += New-Check -Name 'USER_RIGHTS_ORIGINAL_BASELINE' -Status 'NOT_APPLICABLE' -Expected 'Restore operation' -Actual 'Not evaluated during Lockdown'
    }

    if($operation -eq 'LOCKDOWN') {
        $resolvedTargets=@(Get-PropertyValue $state 'targets' @() | Where-Object {$_.resolveStatus -eq 'SUCCESS'})
        $targetNames=@()
        foreach($target in $resolvedTargets) {
            foreach($field in @('accountName','normalized','requested')) {
                $value=[string](Get-PropertyValue $target $field '')
                if(-not [string]::IsNullOrWhiteSpace($value)){$targetNames += (Normalize-SessionAccountName $value)}
            }
        }
        $targetNames=@($targetNames | Select-Object -Unique)
        $activeSessions=@(Get-WtsSessions)
        $remainingTargetSessions=@($activeSessions | Where-Object {(Normalize-SessionAccountName ([string]$_.accountName)) -in $targetNames})
        $sessionPass=($remainingTargetSessions.Count -eq 0)
        $checks += New-Check -Name 'TARGET_SESSIONS_ABSENT' -Status $(if($sessionPass){'PASS'}else{'FAIL'}) -Expected 'No resolved target identity has an interactive session after reboot' -Actual $(if($sessionPass){'0 target sessions'}else{(($remainingTargetSessions | ForEach-Object {"$($_.sessionId):$($_.accountName)"}) -join ' | ')})
        $actions=Get-PropertyValue $state 'actions' $null
        if($null -ne $actions) {
            $absentCount=[int][Math]::Max(0, ($resolvedTargets.Count - $remainingTargetSessions.Count))
            $telemetry=Get-PropertyValue $actions 'sessionTelemetry' $null
            if($null -eq $telemetry){
                $telemetry=[pscustomobject][ordered]@{targetSessionsFound=0;logoffRequestsAccepted=0;logoffRequestsFailed=0;confirmedClosedBeforeReboot=0;remainingSessionIdsBeforeReboot=@();targetIdentitiesWithoutSessionAfterReboot=0;remainingTargetSessionsAfterReboot=@();pendingLogoffSessionIds=@()}
                $actions|Add-Member -NotePropertyName sessionTelemetry -NotePropertyValue $telemetry
            }
            $telemetry.targetIdentitiesWithoutSessionAfterReboot=$absentCount
            $telemetry.remainingTargetSessionsAfterReboot=@($remainingTargetSessions)
        }
    }
    else {
        $checks += New-Check -Name 'TARGET_SESSIONS_ABSENT' -Status 'NOT_APPLICABLE' -Expected 'Lockdown operation' -Actual 'Restore does not force a user session to remain absent'
    }

    $scope=[string](Get-PropertyValue $state 'scope' '')
    if($operation -eq 'LOCKDOWN' -and $scope -eq 'ALL_USERS_SAVE_LAPS') {
        $laps=Get-PropertyValue $state 'laps' $null
        $lapsSid=[string](Get-PropertyValue $laps 'accountSid' '')
        $lapsName=[string](Get-PropertyValue $laps 'accountName' '')
        $lapsFailures=@()
        try {
            if([string]::IsNullOrWhiteSpace($lapsSid)){throw 'LAPS account SID is absent from state.'}
            $localAccount=@(Get-CimInstance Win32_UserAccount -Filter 'LocalAccount=True' -ErrorAction Stop | Where-Object {$_.SID -eq $lapsSid} | Select-Object -First 1)
            if($localAccount.Count -eq 0){$lapsFailures += 'account-not-found'}
            elseif([bool]$localAccount[0].Disabled){$lapsFailures += 'account-disabled'}
            $adminGroup=@(Get-CimInstance Win32_Group -Filter "LocalAccount=True AND SID='S-1-5-32-544'" -ErrorAction Stop | Select-Object -First 1)
            $adminSids=@()
            if($adminGroup.Count -gt 0){
                try{$adminSids=@([EmergencySecurity.PostBootNativeV140]::GetLocalGroupMemberSids([string]$adminGroup[0].Name))}catch{}
                if($adminSids.Count -eq 0){
                    try{$adminSids=@(Get-CimAssociatedInstance -InputObject $adminGroup[0] -Association Win32_GroupUser -ErrorAction Stop | ForEach-Object {[string]$_.SID})}catch{}
                }
            }
            if($lapsSid -notin $adminSids){$lapsFailures += 'not-local-administrator'}
            $lapsRights=@([EmergencySecurity.PostBootNativeV140]::GetRights($lapsSid))
            $blocking=@($lapsRights | Where-Object {$_ -in @('SeDenyInteractiveLogonRight','SeDenyRemoteInteractiveLogonRight','SeDenyNetworkLogonRight')})
            if($blocking.Count -gt 0){$lapsFailures += ('blocking-rights=' + ($blocking -join ','))}
        }
        catch {$lapsFailures += ('verification-error=' + $_.Exception.Message)}
        $checks += New-Check -Name 'SAVELAPS_RECOVERY_IDENTITY' -Status $(if($lapsFailures.Count -eq 0){'PASS'}else{'FAIL'}) -Expected 'Verified LAPS account exists, is enabled, is local administrator, and has no human-access deny rights' -Actual $(if($lapsFailures.Count -eq 0){"${lapsName};${lapsSid};usable"}else{$lapsFailures -join ' | '})
    }
    else {
        $checks += New-Check -Name 'SAVELAPS_RECOVERY_IDENTITY' -Status 'NOT_APPLICABLE' -Expected 'ALL -SaveLaps Lockdown' -Actual 'Not requested or Restore operation'
    }

    $allScope=$scope -in @('ALL_USERS','ALL_USERS_SAVE_LAPS')
    $domainContext=Get-PropertyValue (Get-PropertyValue $state 'actions' $null) 'domainContext' $null
    $partOfDomain=[bool](Get-PropertyValue $domainContext 'partOfDomain' $false)
    if($allScope -and $partOfDomain) {
        $plan=Get-PropertyValue (Get-PropertyValue $state 'actions' $null) 'authFirewall' $null
        if($operation -eq 'LOCKDOWN') {
            $firewallEngine=Get-FirewallEngineState
            $checks += New-Check -Name 'FIREWALL_ENGINE' -Status $(if($firewallEngine.pass){'PASS'}else{'FAIL'}) -Expected 'MpsSvc running and at least one Windows Firewall profile enabled' -Actual "Service=$($firewallEngine.serviceState);Enabled=$($firewallEngine.enabledProfiles -join ',');Disabled=$($firewallEngine.disabledProfiles -join ',')"
        } else {
            $checks += New-Check -Name 'FIREWALL_ENGINE' -Status 'NOT_APPLICABLE' -Expected 'Lockdown operation' -Actual 'Restore does not change firewall engine state'
        }
        $firewallResult=Test-FirewallPlan -Plan $plan -Operation $operation
        $checks += New-Check -Name 'AUTH_FIREWALL' -Status $(if($firewallResult.Pass){'PASS'}else{'FAIL'}) -Expected $(if($operation -eq 'LOCKDOWN'){'All planned emergency block rules active'}else{'All emergency block rules absent'}) -Actual $(if($firewallResult.Failures.Count -eq 0){$firewallResult.Actual}else{$firewallResult.Failures -join ' | '})

        $netlogon=Get-CimInstance Win32_Service -Filter "Name='Netlogon'" -ErrorAction Stop
        if($operation -eq 'RESTORE') {
            $originalNetlogon=Get-PropertyValue (Get-PropertyValue $state 'originalState' $null) 'netlogon' $null
            $expectedStart=Normalize-StartMode ([string](Get-PropertyValue $originalNetlogon 'startMode' 'Manual'))
            $expectedState=[string](Get-PropertyValue $originalNetlogon 'state' 'Stopped')
            if($expectedState -eq 'Running' -and $netlogon.State -ne 'Running' -and $expectedStart -ne 'Disabled') {
                try { Start-Service Netlogon -ErrorAction Stop; Start-Sleep -Seconds 2 } catch { }
                $netlogon=Get-CimInstance Win32_Service -Filter "Name='Netlogon'" -ErrorAction Stop
            }
            $netPass=((Normalize-StartMode ([string]$netlogon.StartMode)) -eq $expectedStart -and (($expectedState -ne 'Running') -or $netlogon.State -eq 'Running'))
            $checks += New-Check -Name 'NETLOGON' -Status $(if($netPass){'PASS'}else{'FAIL'}) -Expected "$expectedState/$expectedStart" -Actual "$($netlogon.State)/$(Normalize-StartMode ([string]$netlogon.StartMode))"
        } else {
            $netPass=($netlogon.State -eq 'Stopped' -and (Normalize-StartMode ([string]$netlogon.StartMode)) -eq 'Disabled')
            $checks += New-Check -Name 'NETLOGON' -Status $(if($netPass){'PASS'}else{'FAIL'}) -Expected 'Stopped/Disabled' -Actual "$($netlogon.State)/$(Normalize-StartMode ([string]$netlogon.StartMode))"
        }

        $currentKdc=Get-KdcProxyState
        if($operation -eq 'LOCKDOWN') {
            $kdcPass=($currentKdc.enabledExists -and [int]$currentKdc.enabled -eq 0 -and -not $currentKdc.mappingExists)
            $checks += New-Check -Name 'KDC_PROXY' -Status $(if($kdcPass){'PASS'}else{'FAIL'}) -Expected 'Disabled and mappings absent' -Actual "Enabled=$($currentKdc.enabled);MappingExists=$($currentKdc.mappingExists)"
        } else {
            $originalKdc=Get-PropertyValue (Get-PropertyValue $state 'originalState' $null) 'kdcProxy' $null
            $kdcPass=Compare-KdcProxyRestore -Original $originalKdc -Current $currentKdc
            $checks += New-Check -Name 'KDC_PROXY' -Status $(if($kdcPass){'PASS'}else{'FAIL'}) -Expected 'Original KDC proxy configuration' -Actual "EnabledExists=$($currentKdc.enabledExists);Enabled=$($currentKdc.enabled);MappingExists=$($currentKdc.mappingExists)"
        }
    } else {
        $checks += New-Check -Name 'AUTH_FIREWALL' -Status 'NOT_APPLICABLE' -Expected 'ALL scope on a domain-joined device' -Actual 'Not configured'
        $checks += New-Check -Name 'NETLOGON' -Status 'NOT_APPLICABLE' -Expected 'ALL scope on a domain-joined device' -Actual 'Not changed'
        $checks += New-Check -Name 'KDC_PROXY' -Status 'NOT_APPLICABLE' -Expected 'ALL scope on a domain-joined device' -Actual 'Not changed'
    }

    $failed=@($checks | Where-Object {$_.status -eq 'FAIL'})
    $warningChecks=@($checks | Where-Object {$_.status -eq 'WARNING'})
    $overall=if($failed.Count -gt 0){'FAILED_VERIFICATION'}elseif($warningChecks.Count -gt 0){'SUCCESS_WITH_WARNINGS'}else{'SUCCESS'}
    $verification=[pscustomobject][ordered]@{
        operation=$operation;status='COMPLETED';overallStatus=$overall
        scheduledUtc=Get-PropertyValue $pending 'scheduledUtc' $null;verifiedUtc=Get-UtcTimestamp
        currentBootTime=$currentBoot.ToString('o');rebootVerified=$rebootPass
        passedCheckCount=@($checks | Where-Object {$_.status -eq 'PASS'}).Count
        warningCheckCount=$warningChecks.Count;warningChecks=(($warningChecks | ForEach-Object {$_.name}) -join ';')
        failedCheckCount=$failed.Count;failedChecks=(($failed | ForEach-Object {$_.name}) -join ';')
        taskName=$TaskName;scriptPath=$PSCommandPath;checks=$checks
    }
    if($state.PSObject.Properties.Name -contains 'postBootVerification'){$state.postBootVerification=$verification}else{$state|Add-Member -NotePropertyName postBootVerification -NotePropertyValue $verification}
    if($operation -eq 'LOCKDOWN'){
        $state.status=if($overall -eq 'SUCCESS'){'ACTIVE_VERIFIED'}elseif($overall -eq 'SUCCESS_WITH_WARNINGS'){'ACTIVE_VERIFIED_WITH_WARNINGS'}else{'LOCKDOWN_PARTIAL'}
    }
    if($operation -eq 'RESTORE'){
        $state.status=if($overall -eq 'SUCCESS'){'RESTORED_VERIFIED'}elseif($overall -eq 'SUCCESS_WITH_WARNINGS'){'RESTORED_VERIFIED_WITH_WARNINGS'}else{'RESTORE_PARTIAL'}
    }
    Write-State -State $state
    $script:VerificationRecorded=$true
}
catch {
    try {
        if(Test-Path -LiteralPath $StatePath) {
            $state=Get-Content -LiteralPath $StatePath -Raw -ErrorAction Stop | ConvertFrom-Json -ErrorAction Stop
            $pending=Get-PropertyValue $state 'postBootVerification' $null
            $failure=[pscustomobject][ordered]@{operation=[string](Get-PropertyValue $pending 'operation' 'UNKNOWN');status='FAILED';overallStatus='FAILED_VERIFICATION';verifiedUtc=Get-UtcTimestamp;rebootVerified=$false;passedCheckCount=0;warningCheckCount=0;warningChecks='';failedCheckCount=1;failedChecks='POSTBOOT_VERIFIER_EXCEPTION';errorMessage=$_.Exception.Message;taskName=$TaskName;scriptPath=$PSCommandPath;checks=@()}
            if($state.PSObject.Properties.Name -contains 'postBootVerification'){$state.postBootVerification=$failure}else{$state|Add-Member -NotePropertyName postBootVerification -NotePropertyValue $failure}
            if($failure.operation -eq 'LOCKDOWN'){$state.status='LOCKDOWN_PARTIAL'}
            if($failure.operation -eq 'RESTORE'){$state.status='RESTORE_PARTIAL'}
            Write-State -State $state
            $script:VerificationRecorded=$true
        }
    } catch { }
}
finally {
    if($script:VerificationRecorded) {
        try { & "$env:SystemRoot\System32\schtasks.exe" /Delete /TN $TaskName /F | Out-Null } catch { }
        try { Remove-Item -LiteralPath $PSCommandPath -Force -ErrorAction SilentlyContinue } catch { }
    }
}
'
$script:State=$null
$script:RestoreStages=@();$script:Warnings=@();$script:Errors=@()

function Get-UtcTimestamp { return [DateTime]::UtcNow.ToString('o') }

function Set-SecureDirectoryAcl {
param([string]$Path)
if (-not (Test-Path -LiteralPath $Path)) { $null = New-Item -Path $Path -ItemType Directory -Force }

$systemSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-18')
$administratorsSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
$inheritance = [System.Security.AccessControl.InheritanceFlags]::ContainerInherit -bor [System.Security.AccessControl.InheritanceFlags]::ObjectInherit
$propagation = [System.Security.AccessControl.PropagationFlags]::None
$allow = [System.Security.AccessControl.AccessControlType]::Allow
$fullControl = [System.Security.AccessControl.FileSystemRights]::FullControl

$security = [System.Security.AccessControl.DirectorySecurity]::new()
$security.SetAccessRuleProtection($true, $false)
$security.SetOwner($systemSid)
$security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($systemSid, $fullControl, $inheritance, $propagation, $allow))
$security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($administratorsSid, $fullControl, $inheritance, $propagation, $allow))
[System.IO.DirectoryInfo]::new($Path).SetAccessControl($security)
}

function Set-SecureFileAcl {
param([string]$Path)
if (-not (Test-Path -LiteralPath $Path)) { return }

$systemSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-18')
$administratorsSid = [System.Security.Principal.SecurityIdentifier]::new('S-1-5-32-544')
$allow = [System.Security.AccessControl.AccessControlType]::Allow
$fullControl = [System.Security.AccessControl.FileSystemRights]::FullControl

$security = [System.Security.AccessControl.FileSecurity]::new()
$security.SetAccessRuleProtection($true, $false)
$security.SetOwner($systemSid)
$security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($systemSid, $fullControl, $allow))
$security.AddAccessRule([System.Security.AccessControl.FileSystemAccessRule]::new($administratorsSid, $fullControl, $allow))
[System.IO.FileInfo]::new($Path).SetAccessControl($security)
}

function Write-State {
if ($null -eq $script:State) { return }
Set-SecureDirectoryAcl -Path $BaseDirectory
if ($script:State.PSObject.Properties.Name -contains 'restoreStages') {
$script:State.restoreStages = $script:RestoreStages
}
else {
$script:State | Add-Member -NotePropertyName restoreStages -NotePropertyValue $script:RestoreStages
}
if ($script:State.PSObject.Properties.Name -contains 'restoreWarnings') {
$script:State.restoreWarnings = $script:Warnings
}
else {
$script:State | Add-Member -NotePropertyName restoreWarnings -NotePropertyValue $script:Warnings
}
if ($script:State.PSObject.Properties.Name -contains 'restoreErrors') {
$script:State.restoreErrors = $script:Errors
}
else {
$script:State | Add-Member -NotePropertyName restoreErrors -NotePropertyValue $script:Errors
}
if([string]$script:State.operation -eq 'RESTORE'){
$script:State.warnings=@($script:Warnings)
$script:State.errors=@($script:Errors)
}

$json = $script:State | ConvertTo-Json -Depth 24
[System.IO.File]::WriteAllText($TemporaryStatePath, $json, [System.Text.UTF8Encoding]::new($false))
Set-SecureFileAcl -Path $TemporaryStatePath
Move-Item -LiteralPath $TemporaryStatePath -Destination $StatePath -Force
Set-SecureFileAcl -Path $StatePath
}

function Add-RestoreStage {
param([string]$Name,[ValidateSet('SUCCESS','WARNING','FAILED','SKIPPED','NOT_APPLICABLE')][string]$Status,[datetime]$Started,[int]$AffectedCount=0,[string]$ErrorCode=$null,[string]$ErrorMessage=$null,[string]$Message=$null,[string]$Expected=$null,[string]$Actual=$null,[ValidateSet('PASS','WARNING','FAIL','PENDING','NOT_CHECKED','NOT_APPLICABLE')][string]$Verification='NOT_CHECKED')
if($null -eq $Started){$Started=[DateTime]::UtcNow};if($Verification -eq 'NOT_CHECKED'){$Verification=switch($Status){'SUCCESS'{'PASS'}'WARNING'{'WARNING'}'FAILED'{'FAIL'}'NOT_APPLICABLE'{'NOT_APPLICABLE'}default{'NOT_CHECKED'}}}
$completed=[DateTime]::UtcNow;$script:RestoreStages += [pscustomobject][ordered]@{name=$Name;status=$Status;verification=$Verification;startedUtc=$Started.ToString('o');completedUtc=$completed.ToString('o');durationMs=[int][Math]::Max(0,($completed-$Started).TotalMilliseconds);affectedCount=$AffectedCount;expected=$Expected;actual=$Actual;errorCode=$ErrorCode;errorMessage=$ErrorMessage;message=$Message}
if($Status -eq 'WARNING' -and $ErrorCode){$script:Warnings += [pscustomobject]@{code=$ErrorCode;message=$ErrorMessage;timestampUtc=Get-UtcTimestamp}}
if($Status -eq 'FAILED' -and $ErrorCode){$script:Errors += [pscustomobject]@{code=$ErrorCode;message=$ErrorMessage;stage=$Name;timestampUtc=Get-UtcTimestamp}}
Write-State
}
function Get-RestoreStageStatus {param([string]$Name);$item=@($script:RestoreStages | Where-Object {$_.name -eq $Name} | Select-Object -Last 1);if($item.Count -eq 0){return 'NOT_REACHED'};[string]$item[0].status}
function Convert-RestoreStatusForRemarks {param([string]$Status);switch($Status){'SUCCESS'{'PASS'}'WARNING'{'WARN'}'FAILED'{'FAIL'}'NOT_APPLICABLE'{'N/A'}'SKIPPED'{'SKIP'}default{'NOT_REACHED'}}}
function Get-CombinedRestoreCheck {param([string[]]$Stages);$statuses=@($Stages | ForEach-Object {Get-RestoreStageStatus $_});if('FAILED' -in $statuses){return 'FAIL'};if('WARNING' -in $statuses){return 'WARN'};if(@($statuses | Where-Object {$_ -eq 'SUCCESS'}).Count -gt 0 -and @($statuses | Where-Object {$_ -eq 'NOT_REACHED'}).Count -eq 0){return 'PASS'};if(@($statuses | Where-Object {$_ -eq 'NOT_APPLICABLE'}).Count -eq $statuses.Count){return 'N/A'};if('SKIPPED' -in $statuses){return 'SKIP'};'NOT_REACHED'}

function Write-Remarks {
$failed=@($script:RestoreStages | Where-Object {$_.status -eq 'FAILED'} | ForEach-Object {$_.name})
$warningStages=@($script:RestoreStages | Where-Object {$_.status -eq 'WARNING'} | ForEach-Object {$_.name})
$result=if($script:State -and $script:State.status -eq 'RESTORE_PARTIAL'){'RESTORE_INCOMPLETE'}
elseif($failed.Count -gt 0){'RESTORE_INCOMPLETE'}
elseif($warningStages.Count -gt 0){'ACCESS_RESTORED_WITH_WARNINGS'}
elseif($script:State){'ACCESS_RESTORED'}
else{'FAILED'}

$auth=(Get-CombinedRestoreCheck @('REMOVE_AUTH_FIREWALL','RESTORE_KDC_PROXY','RESTORE_NETLOGON'))
$summary="EmergencyRestore v$ScriptVersion | $result | Scope=$(if($script:State){[string]$script:State.scope}else{'UNKNOWN'}) | StateLoaded=$(Get-CombinedRestoreCheck @('LOAD_STATE','VALIDATE_ACTIVE_STATE')) | Rights=$(Convert-RestoreStatusForRemarks (Get-RestoreStageStatus 'RESTORE_USER_RIGHTS')) | Cache=$(Convert-RestoreStatusForRemarks (Get-RestoreStageStatus 'RESTORE_CACHED_DOMAIN_LOGON')) | Auth=$auth"
if($failed.Count -gt 0){$summary += " | Failed=$($failed -join ',')"}
if($warningStages.Count -gt 0){$summary += " | Warn=$($warningStages -join ',')"}
$summary += " | State=$StatePath"
[Console]::Out.WriteLine($summary)
}

function Test-SecurePathAcl {
param([string]$Path)
$acl=Get-Acl -LiteralPath $Path -ErrorAction Stop
$ownerSid=try{([System.Security.Principal.NTAccount]$acl.Owner).Translate([System.Security.Principal.SecurityIdentifier]).Value}catch{[string]$acl.Owner}
$allowed=@('S-1-5-18','S-1-5-32-544');$unexpected=@()
foreach($rule in @($acl.Access)){$sid=try{$rule.IdentityReference.Translate([System.Security.Principal.SecurityIdentifier]).Value}catch{[string]$rule.IdentityReference};if($rule.AccessControlType -ne 'Allow' -or $sid -notin $allowed){$unexpected += $sid}}
[pscustomobject]@{Pass=($acl.AreAccessRulesProtected -and $ownerSid -eq 'S-1-5-18' -and $unexpected.Count -eq 0);Owner=$ownerSid;Protected=[bool]$acl.AreAccessRulesProtected;Unexpected=($unexpected -join ';')}
}

function Test-IsSystemOrAdministrator {
$identity = [System.Security.Principal.WindowsIdentity]::GetCurrent()
if ($identity.User.Value -eq 'S-1-5-18') { return $true }
return [System.Security.Principal.WindowsPrincipal]::new($identity).IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
}

function Initialize-LsaNativeType {
if('EmergencySecurity.RestoreNativeV13' -as [type]){return}
$source=@'
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Security.Principal;
namespace EmergencySecurity
{
public static class RestoreNativeV13
{
[StructLayout(LayoutKind.Sequential)] private struct LSA_OBJECT_ATTRIBUTES{public int Length;public IntPtr RootDirectory;public IntPtr ObjectName;public uint Attributes;public IntPtr SecurityDescriptor;public IntPtr SecurityQualityOfService;}
[StructLayout(LayoutKind.Sequential)] private struct LSA_UNICODE_STRING{public ushort Length;public ushort MaximumLength;public IntPtr Buffer;}
[DllImport("advapi32.dll")] private static extern uint LsaOpenPolicy(IntPtr SystemName,ref LSA_OBJECT_ATTRIBUTES ObjectAttributes,uint DesiredAccess,out IntPtr PolicyHandle);
[DllImport("advapi32.dll")] private static extern uint LsaRemoveAccountRights(IntPtr PolicyHandle,IntPtr AccountSid,bool AllRights,LSA_UNICODE_STRING[] UserRights,uint CountOfRights);
[DllImport("advapi32.dll")] private static extern uint LsaEnumerateAccountRights(IntPtr PolicyHandle,IntPtr AccountSid,out IntPtr UserRights,out uint CountOfRights);
[DllImport("advapi32.dll")] private static extern uint LsaNtStatusToWinError(uint Status);
[DllImport("advapi32.dll")] private static extern uint LsaClose(IntPtr PolicyHandle);
[DllImport("advapi32.dll")] private static extern uint LsaFreeMemory(IntPtr Buffer);
private const uint POLICY_LOOKUP_NAMES=0x00000800;private const uint POLICY_CREATE_ACCOUNT=0x00000010;private const uint STATUS_OBJECT_NAME_NOT_FOUND=0xC0000034;
private static IntPtr SidToPtr(string sidValue){SecurityIdentifier sid=new SecurityIdentifier(sidValue);byte[] b=new byte[sid.BinaryLength];sid.GetBinaryForm(b,0);IntPtr p=Marshal.AllocHGlobal(b.Length);Marshal.Copy(b,0,p,b.Length);return p;}
public static void RemoveRight(string sidValue,string right){LSA_OBJECT_ATTRIBUTES loa=new LSA_OBJECT_ATTRIBUTES();loa.Length=Marshal.SizeOf(typeof(LSA_OBJECT_ATTRIBUTES));IntPtr policy=IntPtr.Zero,sid=IntPtr.Zero,text=IntPtr.Zero;try{uint status=LsaOpenPolicy(IntPtr.Zero,ref loa,POLICY_LOOKUP_NAMES|POLICY_CREATE_ACCOUNT,out policy);if(status!=0)throw new Win32Exception((int)LsaNtStatusToWinError(status));sid=SidToPtr(sidValue);text=Marshal.StringToHGlobalUni(right);LSA_UNICODE_STRING item=new LSA_UNICODE_STRING{Length=(ushort)(right.Length*2),MaximumLength=(ushort)((right.Length+1)*2),Buffer=text};status=LsaRemoveAccountRights(policy,sid,false,new LSA_UNICODE_STRING[]{item},1);if(status!=0&&status!=STATUS_OBJECT_NAME_NOT_FOUND)throw new Win32Exception((int)LsaNtStatusToWinError(status));}finally{if(text!=IntPtr.Zero)Marshal.FreeHGlobal(text);if(sid!=IntPtr.Zero)Marshal.FreeHGlobal(sid);if(policy!=IntPtr.Zero)LsaClose(policy);}}
public static string[] GetRights(string sidValue){LSA_OBJECT_ATTRIBUTES loa=new LSA_OBJECT_ATTRIBUTES();loa.Length=Marshal.SizeOf(typeof(LSA_OBJECT_ATTRIBUTES));IntPtr policy=IntPtr.Zero,sid=IntPtr.Zero,rights=IntPtr.Zero;try{uint status=LsaOpenPolicy(IntPtr.Zero,ref loa,POLICY_LOOKUP_NAMES,out policy);if(status!=0)throw new Win32Exception((int)LsaNtStatusToWinError(status));sid=SidToPtr(sidValue);uint count;status=LsaEnumerateAccountRights(policy,sid,out rights,out count);if(status==STATUS_OBJECT_NAME_NOT_FOUND)return new string[0];if(status!=0)throw new Win32Exception((int)LsaNtStatusToWinError(status));List<string> list=new List<string>();int size=Marshal.SizeOf(typeof(LSA_UNICODE_STRING));for(int i=0;i<count;i++){LSA_UNICODE_STRING item=(LSA_UNICODE_STRING)Marshal.PtrToStructure(IntPtr.Add(rights,i*size),typeof(LSA_UNICODE_STRING));list.Add(Marshal.PtrToStringUni(item.Buffer,item.Length/2));}return list.ToArray();}finally{if(rights!=IntPtr.Zero)LsaFreeMemory(rights);if(sid!=IntPtr.Zero)Marshal.FreeHGlobal(sid);if(policy!=IntPtr.Zero)LsaClose(policy);}}
}
}
'@
Add-Type -TypeDefinition $source -Language CSharp -ErrorAction Stop | Out-Null
}

function Get-CachedLogonCurrent {
$path='HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon';try{return [pscustomobject]@{exists=$true;value=[string](Get-ItemProperty -Path $path -Name CachedLogonsCount -ErrorAction Stop).CachedLogonsCount}}catch{return [pscustomobject]@{exists=$false;value=$null}}
}
function Restore-CachedLogonState {
param($Original)
$path='HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon'
if([bool]$Original.existed){$propertyType=if([string]$Original.kind -eq 'DWord'){'DWord'}elseif([string]$Original.kind -eq 'QWord'){'QWord'}elseif([string]$Original.kind -eq 'ExpandString'){'ExpandString'}elseif([string]$Original.kind -eq 'MultiString'){'MultiString'}else{'String'};New-ItemProperty -Path $path -Name CachedLogonsCount -Value $Original.value -PropertyType $propertyType -Force | Out-Null}else{Remove-ItemProperty -Path $path -Name CachedLogonsCount -ErrorAction SilentlyContinue}
$current=Get-CachedLogonCurrent;if([bool]$Original.existed){if(-not $current.exists -or [string]$current.value -ne [string]$Original.value){throw 'CachedLogonsCount restore verification failed.'}}elseif($current.exists){throw 'CachedLogonsCount should be absent after restore.'}
}
function Restore-KdcProxyState {
param($Original)
$rootPath = [string]$Original.rootPath
if ([string]::IsNullOrWhiteSpace($rootPath)) { return }
$mappingPath = Join-Path $rootPath 'KdcProxyServer'

if ([bool]$Original.enabledValueExisted) {
if (-not (Test-Path $rootPath)) { $null = New-Item -Path $rootPath -Force }
New-ItemProperty -Path $rootPath -Name 'KdcProxyServer_Enabled' -Value $Original.enabledValue -PropertyType DWord -Force | Out-Null
}
else {
Remove-ItemProperty -Path $rootPath -Name 'KdcProxyServer_Enabled' -ErrorAction SilentlyContinue
}

if (Test-Path $mappingPath) { Remove-Item -Path $mappingPath -Recurse -Force -ErrorAction SilentlyContinue }
if ([bool]$Original.mappingPathExisted) {
$null = New-Item -Path $mappingPath -Force
foreach ($mapping in @($Original.mappings)) {
New-ItemProperty -Path $mappingPath -Name ([string]$mapping.name) -Value ([string]$mapping.value) -PropertyType String -Force | Out-Null
}
}
}
function Restore-NetlogonState {
param($Original)
$startupType = switch ([string]$Original.startMode) {
'Auto' { 'Automatic' }
'Automatic' { 'Automatic' }
'Manual' { 'Manual' }
'Disabled' { 'Disabled' }
default { 'Manual' }
}
Set-Service -Name Netlogon -StartupType $startupType -ErrorAction Stop
if ([string]$Original.state -eq 'Running' -and $startupType -ne 'Disabled') {
Start-Service -Name Netlogon -ErrorAction Stop
}
elseif ([string]$Original.state -ne 'Running') {
Stop-Service -Name Netlogon -Force -ErrorAction SilentlyContinue
}
}

function Cancel-PendingEmergencyDisruption {
foreach($name in $DisruptionTaskNames){
try{& (Join-Path $env:SystemRoot 'System32\schtasks.exe') /End /TN $name 2>$null | Out-Null}catch{}
try{& (Join-Path $env:SystemRoot 'System32\schtasks.exe') /Delete /TN $name /F 2>$null | Out-Null}catch{}
}
foreach($name in @('EmergencyLockdown-PostBootVerify-v140','EmergencyLockdown-PostBootVerify-v135','EmergencyLockdown-PostBootVerify-v134','EmergencyLockdown-PostBootVerify-v133','EmergencyLockdown-PostBootVerify-v132','EmergencyLockdown-PostBootVerify-v131','EmergencyLockdown-PostBootVerify-v13')){
try{& (Join-Path $env:SystemRoot 'System32\schtasks.exe') /Delete /TN $name /F 2>$null | Out-Null}catch{}
}
try{& (Join-Path $env:SystemRoot 'System32\shutdown.exe') /a 2>$null | Out-Null}catch{}
try{Remove-Item -LiteralPath $DisruptionWorkerPath -Force -ErrorAction SilentlyContinue}catch{}
}

function Install-PostBootVerifier {
param([ValidateSet('LOCKDOWN','RESTORE')][string]$Operation)
Set-SecureDirectoryAcl -Path $BaseDirectory
[System.IO.File]::WriteAllBytes($PostBootVerifierPath,[Convert]::FromBase64String($PostBootVerifierBase64));Set-SecureFileAcl $PostBootVerifierPath
$aclCheck=Test-SecurePathAcl -Path $PostBootVerifierPath
if(-not $aclCheck.Pass){throw "Post-boot verifier ACL verification failed. Owner=$($aclCheck.Owner);Protected=$($aclCheck.Protected);Unexpected=$($aclCheck.Unexpected)"}
$powerShellExe=Join-Path $env:SystemRoot 'System32\WindowsPowerShell\v1.0\powershell.exe';$taskCommand='"{0}" -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "{1}"' -f $powerShellExe,$PostBootVerifierPath
& (Join-Path $env:SystemRoot 'System32\schtasks.exe') /Create /TN $PostBootTaskName /SC ONSTART /RU SYSTEM /RL HIGHEST /TR $taskCommand /F | Out-Null;if($LASTEXITCODE -ne 0){throw "schtasks create returned $LASTEXITCODE"}
& (Join-Path $env:SystemRoot 'System32\schtasks.exe') /Query /TN $PostBootTaskName | Out-Null;if($LASTEXITCODE -ne 0){throw 'Post-boot task query failed.'}
$pending=[pscustomobject][ordered]@{operation=$Operation;status='PENDING';overallStatus='PENDING';scheduledUtc=Get-UtcTimestamp;verifiedUtc=$null;rebootVerified=$false;passedCheckCount=0;failedCheckCount=0;failedChecks='';taskName=$PostBootTaskName;scriptPath=$PostBootVerifierPath;checks=@()};if($script:State.PSObject.Properties.Name -contains 'postBootVerification'){$script:State.postBootVerification=$pending}else{$script:State|Add-Member -NotePropertyName postBootVerification -NotePropertyValue $pending};Write-State
}
function Cancel-PostBootVerifier {param([string]$Reason);try{& (Join-Path $env:SystemRoot 'System32\schtasks.exe') /Delete /TN $PostBootTaskName /F | Out-Null}catch{};if($script:State -and $script:State.PSObject.Properties.Name -contains 'postBootVerification'){$script:State.postBootVerification.status='CANCELED';$script:State.postBootVerification.overallStatus='CANCELED'};Write-State}
function Schedule-Reboot {
$os=Get-CimInstance Win32_OperatingSystem -ErrorAction Stop;$boot=([datetime]$os.LastBootUpTime).ToUniversalTime().ToString('o')
if($script:State.PSObject.Properties.Name -contains 'restoreBootTimeBefore'){$script:State.restoreBootTimeBefore=$boot}else{$script:State | Add-Member -NotePropertyName restoreBootTimeBefore -NotePropertyValue $boot}
$arguments=@('/r','/f','/t',[string]$RebootDelaySeconds,'/c','"Emergency access restore completed: mandatory restart"');$process=Start-Process -FilePath "$env:SystemRoot\System32\shutdown.exe" -ArgumentList $arguments -Wait -PassThru -WindowStyle Hidden;if($process.ExitCode -ne 0){throw "shutdown.exe returned exit code $($process.ExitCode)."}
if($script:State.PSObject.Properties.Name -contains 'restoreRebootScheduled'){$script:State.restoreRebootScheduled=$true}else{$script:State | Add-Member -NotePropertyName restoreRebootScheduled -NotePropertyValue $true}
if($script:State.PSObject.Properties.Name -contains 'restoreRebootScheduledUtc'){$script:State.restoreRebootScheduledUtc=Get-UtcTimestamp}else{$script:State | Add-Member -NotePropertyName restoreRebootScheduledUtc -NotePropertyValue (Get-UtcTimestamp)}
}

try {
$start=[DateTime]::UtcNow
try{Set-SecureDirectoryAcl -Path $BaseDirectory;$aclCheck=Test-SecurePathAcl -Path $BaseDirectory;if(-not $aclCheck.Pass){throw "ACL verification failed. Owner=$($aclCheck.Owner);Protected=$($aclCheck.Protected);Unexpected=$($aclCheck.Unexpected)"};Add-RestoreStage -Name 'SECURE_STATE_STORAGE' -Status 'SUCCESS' -Started $start -Expected 'Owner SYSTEM; inheritance disabled; only SYSTEM and Administrators' -Actual "Owner=$($aclCheck.Owner);Protected=$($aclCheck.Protected)"}catch{Add-RestoreStage -Name 'SECURE_STATE_STORAGE' -Status 'FAILED' -Started $start -ErrorCode 'STATE_STORAGE_ACL_FAILED' -ErrorMessage $_.Exception.Message;Write-Remarks;exit 10}
$start=[DateTime]::UtcNow
try{Cancel-PendingEmergencyDisruption;Add-RestoreStage -Name 'CANCEL_PENDING_DISRUPTION' -Status 'SUCCESS' -Started $start -Expected 'No pending lockdown worker or shutdown request' -Actual 'Canceled/absent'}catch{Add-RestoreStage -Name 'CANCEL_PENDING_DISRUPTION' -Status 'WARNING' -Started $start -ErrorCode 'PENDING_DISRUPTION_CANCEL_FAILED' -ErrorMessage $_.Exception.Message}
$start=[DateTime]::UtcNow
if(-not (Test-IsSystemOrAdministrator)){Add-RestoreStage -Name 'LOAD_STATE' -Status 'FAILED' -Started $start -ErrorCode 'ELEVATION_REQUIRED' -ErrorMessage 'Restore must run as SYSTEM or elevated administrator.';Write-Remarks;exit 11}
Initialize-LsaNativeType
if(-not (Test-Path -LiteralPath $StatePath)){Add-RestoreStage -Name 'LOAD_STATE' -Status 'FAILED' -Started $start -ErrorCode 'STATE_FILE_NOT_FOUND' -ErrorMessage $StatePath;Write-Remarks;exit 12}
try{$script:State=Get-Content -LiteralPath $StatePath -Raw -ErrorAction Stop | ConvertFrom-Json -ErrorAction Stop;Add-RestoreStage -Name 'LOAD_STATE' -Status 'SUCCESS' -Started $start -Expected 'Readable state JSON' -Actual ([string]$script:State.status)}catch{Add-RestoreStage -Name 'LOAD_STATE' -Status 'FAILED' -Started $start -ErrorCode 'STATE_FILE_UNREADABLE' -ErrorMessage $_.Exception.Message;Write-Remarks;exit 13}

$start=[DateTime]::UtcNow
if([string]$script:State.status -notin @('APPLYING','ACTIVE_DISRUPTION_PENDING','ACTIVE_PENDING_REBOOT','ACTIVE','ACTIVE_VERIFIED','ACTIVE_VERIFIED_WITH_WARNINGS','LOCKDOWN_PARTIAL','RESTORING','RESTORED_PENDING_REBOOT','RESTORE_PARTIAL','UNHANDLED_FAILURE')){Add-RestoreStage -Name 'VALIDATE_ACTIVE_STATE' -Status 'FAILED' -Started $start -ErrorCode 'NO_ACTIVE_LOCKDOWN' -ErrorMessage "State status is $($script:State.status).";Write-Remarks;exit 14}
Add-RestoreStage -Name 'VALIDATE_ACTIVE_STATE' -Status 'SUCCESS' -Started $start -Actual ([string]$script:State.status)
if($script:State.PSObject.Properties.Name -contains 'schemaVersion'){$script:State.schemaVersion=3}else{$script:State | Add-Member -NotePropertyName schemaVersion -NotePropertyValue 3}
if($script:State.PSObject.Properties.Name -contains 'postBootVerification' -and [string]$script:State.postBootVerification.operation -eq 'LOCKDOWN'){if($script:State.PSObject.Properties.Name -contains 'lockdownPostBootVerification'){$script:State.lockdownPostBootVerification=$script:State.postBootVerification}else{$script:State | Add-Member -NotePropertyName lockdownPostBootVerification -NotePropertyValue $script:State.postBootVerification}}
if(-not ($script:State.PSObject.Properties.Name -contains 'lockdownOperation')){$script:State | Add-Member -NotePropertyName lockdownOperation -NotePropertyValue ([string]$script:State.operation)}
if(-not ($script:State.PSObject.Properties.Name -contains 'lockdownScriptVersion')){$script:State | Add-Member -NotePropertyName lockdownScriptVersion -NotePropertyValue ([string]$script:State.scriptVersion)}
if(-not ($script:State.PSObject.Properties.Name -contains 'lockdownStartedUtc')){$script:State | Add-Member -NotePropertyName lockdownStartedUtc -NotePropertyValue ([string]$script:State.startedUtc)}
if(-not ($script:State.PSObject.Properties.Name -contains 'lockdownCompletedUtc')){$script:State | Add-Member -NotePropertyName lockdownCompletedUtc -NotePropertyValue ([string]$script:State.completedUtc)}
if(-not ($script:State.PSObject.Properties.Name -contains 'lockdownWarnings')){$script:State | Add-Member -NotePropertyName lockdownWarnings -NotePropertyValue @($script:State.warnings)}
if(-not ($script:State.PSObject.Properties.Name -contains 'lockdownErrors')){$script:State | Add-Member -NotePropertyName lockdownErrors -NotePropertyValue @($script:State.errors)}
if(-not ($script:State.PSObject.Properties.Name -contains 'lockdownActions')){$script:State | Add-Member -NotePropertyName lockdownActions -NotePropertyValue $script:State.actions}
$restoreActions=[pscustomobject][ordered]@{rights='NOT_STARTED';cachedDomainLogon='NOT_STARTED';authFirewall='NOT_STARTED';kdcProxy='NOT_STARTED';netlogon='NOT_STARTED';postBootVerifier='NOT_STARTED';rebootRequest='NOT_STARTED'}
if($script:State.PSObject.Properties.Name -contains 'restoreActions'){$script:State.restoreActions=$restoreActions}else{$script:State | Add-Member -NotePropertyName restoreActions -NotePropertyValue $restoreActions}
$restoreStart=Get-UtcTimestamp
$script:State.operation='RESTORE';$script:State.scriptVersion=$ScriptVersion;$script:State.startedUtc=$restoreStart;$script:State.completedUtc=$null;$script:State.warnings=@();$script:State.errors=@()
if($script:State.PSObject.Properties.Name -contains 'restoreStartedUtc'){$script:State.restoreStartedUtc=$restoreStart}else{$script:State | Add-Member -NotePropertyName restoreStartedUtc -NotePropertyValue $restoreStart};$script:State.status='RESTORING';Write-State

$start=[DateTime]::UtcNow;$removedRights=0;$rightFailures=@()
try{foreach($record in @($script:State.originalState.userRights)){foreach($right in @($record.rightsAdded)){try{[EmergencySecurity.RestoreNativeV13]::RemoveRight([string]$record.sid,[string]$right);$after=@([EmergencySecurity.RestoreNativeV13]::GetRights([string]$record.sid));if($right -in $after){throw 'Right is still present after removal.'};$removedRights++}catch{$rightFailures += "$($record.accountName):${right}:$($_.Exception.Message)"}}};if($rightFailures.Count -gt 0){Add-RestoreStage -Name 'RESTORE_USER_RIGHTS' -Status 'WARNING' -Started $start -AffectedCount $removedRights -ErrorCode 'ONE_OR_MORE_RIGHTS_NOT_REMOVED' -ErrorMessage ($rightFailures -join ' | ') -Expected 'All lockdown-added rights absent' -Actual "$removedRights removed"}else{Add-RestoreStage -Name 'RESTORE_USER_RIGHTS' -Status 'SUCCESS' -Started $start -AffectedCount $removedRights -Expected 'All lockdown-added rights absent' -Actual "$removedRights removed and verified"}}
catch{Add-RestoreStage -Name 'RESTORE_USER_RIGHTS' -Status 'FAILED' -Started $start -ErrorCode 'RIGHTS_RESTORE_FAILED' -ErrorMessage $_.Exception.Message}

$start=[DateTime]::UtcNow;try{Restore-CachedLogonState -Original $script:State.originalState.cachedLogonsCount;Add-RestoreStage -Name 'RESTORE_CACHED_DOMAIN_LOGON' -Status 'SUCCESS' -Started $start -AffectedCount 1 -Expected 'Original value/existence' -Actual 'Verified'}catch{Add-RestoreStage -Name 'RESTORE_CACHED_DOMAIN_LOGON' -Status 'FAILED' -Started $start -ErrorCode 'CACHED_LOGON_RESTORE_FAILED' -ErrorMessage $_.Exception.Message}

$allScope=[string]$script:State.scope -in @('ALL_USERS','ALL_USERS_SAVE_LAPS');$partOfDomain=$false
try{$partOfDomain=[bool]$script:State.actions.domainContext.partOfDomain}catch{}
if($allScope -and $partOfDomain){
$start=[DateTime]::UtcNow;try{$definitions=@($script:State.actions.authFirewall.ruleDefinitions);foreach($definition in $definitions){Remove-NetFirewallRule -Name ([string]$definition.name) -ErrorAction SilentlyContinue};$remaining=@($definitions | Where-Object {Get-NetFirewallRule -Name ([string]$_.name) -ErrorAction SilentlyContinue});if($remaining.Count -gt 0){throw 'One or more emergency firewall rules remain.'};Add-RestoreStage -Name 'REMOVE_AUTH_FIREWALL' -Status 'SUCCESS' -Started $start -AffectedCount $definitions.Count -Expected 'Emergency rules absent' -Actual 'Verified'}catch{Add-RestoreStage -Name 'REMOVE_AUTH_FIREWALL' -Status 'FAILED' -Started $start -ErrorCode 'AUTH_FIREWALL_RESTORE_FAILED' -ErrorMessage $_.Exception.Message}
$start=[DateTime]::UtcNow;try{Restore-KdcProxyState -Original $script:State.originalState.kdcProxy;Add-RestoreStage -Name 'RESTORE_KDC_PROXY' -Status 'SUCCESS' -Started $start -Expected 'Original KDC proxy state' -Actual 'Applied; post-boot verifier will recheck'}catch{Add-RestoreStage -Name 'RESTORE_KDC_PROXY' -Status 'WARNING' -Started $start -ErrorCode 'KDC_PROXY_RESTORE_FAILED' -ErrorMessage $_.Exception.Message}
$start=[DateTime]::UtcNow;try{Restore-NetlogonState -Original $script:State.originalState.netlogon;$net=Get-CimInstance Win32_Service -Filter "Name='Netlogon'" -ErrorAction Stop;Add-RestoreStage -Name 'RESTORE_NETLOGON' -Status 'SUCCESS' -Started $start -AffectedCount 1 -Expected "$($script:State.originalState.netlogon.state)/$($script:State.originalState.netlogon.startMode)" -Actual "$($net.State)/$($net.StartMode)"}catch{Add-RestoreStage -Name 'RESTORE_NETLOGON' -Status 'FAILED' -Started $start -ErrorCode 'NETLOGON_RESTORE_FAILED' -ErrorMessage $_.Exception.Message}
}else{Add-RestoreStage -Name 'REMOVE_AUTH_FIREWALL' -Status 'NOT_APPLICABLE' -Started ([DateTime]::UtcNow);Add-RestoreStage -Name 'RESTORE_KDC_PROXY' -Status 'NOT_APPLICABLE' -Started ([DateTime]::UtcNow);Add-RestoreStage -Name 'RESTORE_NETLOGON' -Status 'NOT_APPLICABLE' -Started ([DateTime]::UtcNow)}

$script:State | Add-Member -NotePropertyName restoreBootTimeBefore -NotePropertyValue (([datetime](Get-CimInstance Win32_OperatingSystem -ErrorAction Stop).LastBootUpTime).ToUniversalTime().ToString('o')) -Force;Write-State
$changesRestored=@($script:RestoreStages | Where-Object {$_.name -in @('RESTORE_USER_RIGHTS','RESTORE_CACHED_DOMAIN_LOGON','REMOVE_AUTH_FIREWALL','RESTORE_KDC_PROXY','RESTORE_NETLOGON') -and $_.status -in @('SUCCESS','WARNING')}).Count -gt 0
if($changesRestored){$start=[DateTime]::UtcNow;try{Install-PostBootVerifier -Operation 'RESTORE';Add-RestoreStage -Name 'INSTALL_POSTBOOT_VERIFIER' -Status 'SUCCESS' -Started $start -AffectedCount 1 -Expected 'Startup task query succeeds' -Actual $PostBootTaskName}catch{Add-RestoreStage -Name 'INSTALL_POSTBOOT_VERIFIER' -Status 'WARNING' -Started $start -ErrorCode 'POSTBOOT_VERIFIER_INSTALL_FAILED' -ErrorMessage $_.Exception.Message}
$start=[DateTime]::UtcNow;$script:State.status='RESTORED_PENDING_REBOOT';Add-RestoreStage -Name 'PREPARE_REBOOT_CHECKPOINT' -Status 'SUCCESS' -Started $start -Message 'Restore state was persisted before reboot scheduling.';Write-State
$start=[DateTime]::UtcNow;try{Schedule-Reboot;try{Add-RestoreStage -Name 'SCHEDULE_REBOOT' -Status 'SUCCESS' -Started $start -AffectedCount 1 -Expected 'shutdown.exe accepted restart request' -Actual "ExitCode=0;Delay=$RebootDelaySeconds seconds" -Verification 'PENDING'}catch{& (Join-Path $env:SystemRoot 'System32\shutdown.exe') /a 2>$null | Out-Null;throw "Restore reboot request was accepted but could not be durably recorded; the request was aborted. $($_.Exception.Message)"}}catch{try{Cancel-PostBootVerifier -Reason 'Restore reboot scheduling or durable recording failed.'}catch{};Add-RestoreStage -Name 'SCHEDULE_REBOOT' -Status 'FAILED' -Started $start -ErrorCode 'REBOOT_SCHEDULE_FAILED' -ErrorMessage $_.Exception.Message}}
else{Add-RestoreStage -Name 'INSTALL_POSTBOOT_VERIFIER' -Status 'SKIPPED' -Started ([DateTime]::UtcNow);Add-RestoreStage -Name 'PREPARE_REBOOT_CHECKPOINT' -Status 'SKIPPED' -Started ([DateTime]::UtcNow);Add-RestoreStage -Name 'SCHEDULE_REBOOT' -Status 'SKIPPED' -Started ([DateTime]::UtcNow) -Message 'No restorable security change was completed.'}

$start=[DateTime]::UtcNow;$hardFailures=@($script:RestoreStages | Where-Object {$_.status -eq 'FAILED'}).Count;$warningCount=@($script:RestoreStages | Where-Object {$_.status -eq 'WARNING'}).Count
$script:State.status=if((Get-RestoreStageStatus 'SCHEDULE_REBOOT') -eq 'SUCCESS' -and $hardFailures -eq 0){'RESTORED_PENDING_REBOOT'}else{'RESTORE_PARTIAL'}
$restoreCompleted=Get-UtcTimestamp
if($script:State.PSObject.Properties.Name -contains 'restoreCompletedUtc'){$script:State.restoreCompletedUtc=$restoreCompleted}else{$script:State | Add-Member -NotePropertyName restoreCompletedUtc -NotePropertyValue $restoreCompleted}
$script:State.completedUtc=$restoreCompleted
Add-RestoreStage -Name 'FINALIZE_RESTORE_STATE' -Status $(if($script:State.status -eq 'RESTORED_PENDING_REBOOT'){'SUCCESS'}else{'WARNING'}) -Started $start -ErrorCode $(if($script:State.status -eq 'RESTORED_PENDING_REBOOT'){$null}else{'RESTORE_PARTIAL'}) -ErrorMessage $(if($script:State.status -eq 'RESTORED_PENDING_REBOOT'){$null}else{'Restore completed with warnings or failures. Review the state file.'})
$script:State.restoreActions.rights=Convert-RestoreStatusForRemarks (Get-RestoreStageStatus 'RESTORE_USER_RIGHTS')
$script:State.restoreActions.cachedDomainLogon=Convert-RestoreStatusForRemarks (Get-RestoreStageStatus 'RESTORE_CACHED_DOMAIN_LOGON')
$script:State.restoreActions.authFirewall=Convert-RestoreStatusForRemarks (Get-RestoreStageStatus 'REMOVE_AUTH_FIREWALL')
$script:State.restoreActions.kdcProxy=Convert-RestoreStatusForRemarks (Get-RestoreStageStatus 'RESTORE_KDC_PROXY')
$script:State.restoreActions.netlogon=Convert-RestoreStatusForRemarks (Get-RestoreStageStatus 'RESTORE_NETLOGON')
$script:State.restoreActions.postBootVerifier=Convert-RestoreStatusForRemarks (Get-RestoreStageStatus 'INSTALL_POSTBOOT_VERIFIER')
$script:State.restoreActions.rebootRequest=Convert-RestoreStatusForRemarks (Get-RestoreStageStatus 'SCHEDULE_REBOOT')
Write-State
Write-Remarks;exit $(if($script:State.status -eq 'RESTORED_PENDING_REBOOT'){0}else{2})
}catch{
try{if($null -ne $script:State){$script:State.status='RESTORE_PARTIAL';$script:Errors += [pscustomobject]@{code='UNHANDLED_EXCEPTION';message=$_.Exception.Message;stage='UNHANDLED';timestampUtc=Get-UtcTimestamp};Write-State};Write-Remarks}catch{[Console]::Out.WriteLine((([ordered]@{script='EmergencyRestore';version=$ScriptVersion;operation='RESTORE';result='FAILED';failed='UNHANDLED_EXCEPTION;REMARKS_GENERATION_FAILED';message=$_.Exception.Message}) | ConvertTo-Json -Compress))};exit 99
}