mirror of
https://github.com/Yamato-Security/WELA.git
synced 2026-11-16 01:44:10 +01:00
Add guarded value-only recovery for named logging DWORDs
This commit is contained in:
1 parent
fd7a7924aa
commit
9327d04fc9
12 files changed
+390
-6
No files matched your search
@@ -1,4 +1,5 @@
|
||||
# Conservative, explicitly selected recovery of completed audit-policy writes.
|
||||
. (Join-Path $PSScriptRoot 'NamedRegistryRecovery.ps1')
|
||||
function ConvertFrom-WelaRecoveryJson {
|
||||
param([string]$Text)
|
||||
# ConvertFrom-Json accepts some JavaScript extensions (including single-quoted
|
||||
@@ -103,9 +104,10 @@ function New-WelaRecoveryPlan {
|
||||
$precedenceId='Registry/HKLM:\SYSTEM\CurrentControlSet\Control\Lsa/SCENoApplyLegacyAuditPolicy'
|
||||
$rows=New-Object 'System.Collections.Generic.List[object]'
|
||||
$targets=@{}
|
||||
$named=@{}; foreach ($item in Get-WelaNamedRecoveryCatalog) {$named[$item.Id]=$item}
|
||||
foreach ($id in ($ControlId | Sort-Object)) {
|
||||
if (-not $byId.ContainsKey($id) -or -not $final.ContainsKey($id)) {throw "Missing journal/final evidence for $id"}
|
||||
$entry=$byId[$id]; $last=$final[$id]
|
||||
$entry=$byId[$id]; $last=$final[$id];$namedControl=$false
|
||||
if ($last.Status -cne 'Applied' -or $last.Id -cne $entry.Id -or $last.Kind -cne $entry.Kind) {throw "Only completed Applied writes can be recovered: $id"}
|
||||
foreach ($field in @('Before','Desired','Target')) {if ((Get-WelaRecoveryKey $entry.$field) -cne (Get-WelaRecoveryKey $last.$field)) {throw "Journal/final $field mismatch: $id"}}
|
||||
if ($entry.Kind -ceq 'AuditPolicy' -and $catalog.ContainsKey($id)) {
|
||||
@@ -119,10 +121,23 @@ function New-WelaRecoveryPlan {
|
||||
# Never disable precedence while leaving another journaled subcategory unrestored.
|
||||
foreach ($other in $entries) {if ($other.Kind -eq 'AuditPolicy' -and $other.Id -notin $ControlId) {throw 'Precedence recovery requires every journaled audit subcategory to be selected.'}}
|
||||
$target=$entry.Before
|
||||
} elseif ($entry.Kind -ceq 'Registry' -and $named.ContainsKey($id)) {
|
||||
$definition=$named[$id]
|
||||
if ($id -cne $definition.Id -or $entry.Target.Path -cne $definition.Path -or $entry.Target.Name -cne $definition.Name -or $entry.Desired.Type -cne 'DWord' -or ($entry.Desired.Value -isnot [int] -and $entry.Desired.Value -isnot [long]) -or $entry.Desired.Value -ne 1) {throw 'Unsupported named logging registry recovery target.'}
|
||||
Assert-WelaNamedRecoveryValue $entry.Before; Assert-WelaNamedRecoveryValue $last.After
|
||||
if (-not $last.After.ValueExists -or $last.After.Value -ne 1) {throw 'Final logging switch is not enabled.'}
|
||||
$target=[pscustomobject]@{KeyExists=$true;ValueExists=$entry.Before.ValueExists;Value=$entry.Before.Value;Type=$entry.Before.Type}
|
||||
$namedControl=$true
|
||||
} else {throw "Unsupported control requires manual recovery: $id"}
|
||||
$rows.Add([pscustomobject][ordered]@{Id=$id;Kind=$entry.Kind;Target=$entry.Target;Expected=$last.After;RecoverTo=$target})
|
||||
$row=[pscustomobject][ordered]@{Id=$id;Kind=$entry.Kind;Target=$entry.Target;Expected=$last.After;RecoverTo=$target}
|
||||
if ($namedControl) {
|
||||
$row.Kind='NamedLoggingRegistry'
|
||||
$row | Add-Member NoteProperty OriginalKeyExisted $entry.Before.KeyExists
|
||||
$row | Add-Member NoteProperty RegistryGuard (Get-WelaNamedRecoveryGuard (Get-WelaNamedRecoveryObservation $entry.Target))
|
||||
}
|
||||
$rows.Add($row)
|
||||
}
|
||||
[pscustomobject][ordered]@{
|
||||
$plan=[pscustomobject][ordered]@{
|
||||
Kind='WelaAuditRecoveryPlan';SchemaVersion=1
|
||||
Host=$hostState;Journal=[pscustomobject]@{Path=$journal.Path;Sha256=$journal.Sha256}
|
||||
OriginalResults=[pscustomobject]@{Path=$resultFile.Path;Sha256=$resultFile.Sha256}
|
||||
@@ -132,6 +147,8 @@ function New-WelaRecoveryPlan {
|
||||
UnsupportedJournalControls=@($entries | Where-Object {$_.Id -notin $ControlId} | Select-Object Id,Kind)
|
||||
ReadyRuleCredit=0
|
||||
}
|
||||
if (@($rows | Where-Object Kind -eq 'NamedLoggingRegistry').Count) {$plan | Add-Member NoteProperty NamedSources @(Get-WelaNamedRecoverySources)}
|
||||
return $plan
|
||||
}
|
||||
function Get-WelaRecoveryOutputDriveType {
|
||||
param([string]$Root)
|
||||
@@ -172,17 +189,24 @@ function Write-WelaRecoveryArtifact {
|
||||
function Get-WelaRecoveryCurrent {
|
||||
param($Control)
|
||||
if ($Control.Kind -eq 'AuditPolicy') {return Get-WelaAuditPolicyMask $Control.Target.Guid}
|
||||
if ($Control.Kind -eq 'NamedLoggingRegistry') {
|
||||
$observation=Get-WelaNamedRecoveryObservation $Control.Target
|
||||
Assert-WelaNamedRecoveryGuard $Control $observation
|
||||
return Get-WelaNamedRecoveryState $observation
|
||||
}
|
||||
Get-WelaRegistryState 'HKLM:\SYSTEM\CurrentControlSet\Control\Lsa' SCENoApplyLegacyAuditPolicy
|
||||
}
|
||||
function Set-WelaRecoveryCurrent {
|
||||
param($Control)
|
||||
if ($Control.Kind -eq 'AuditPolicy') {Set-WelaEffectiveAuditPolicy -Guid $Control.Target.Guid -Mask $Control.RecoverTo -Mode exact;return}
|
||||
if ($Control.Kind -eq 'NamedLoggingRegistry') {Set-WelaNamedRecoveryValue $Control;return}
|
||||
$path='HKLM:\SYSTEM\CurrentControlSet\Control\Lsa'
|
||||
if ($Control.RecoverTo.ValueExists) {Set-ItemProperty -LiteralPath $path -Name SCENoApplyLegacyAuditPolicy -Value $Control.RecoverTo.Value -Type DWord -ErrorAction Stop}
|
||||
else {Remove-ItemProperty -LiteralPath $path -Name SCENoApplyLegacyAuditPolicy -ErrorAction Stop}
|
||||
}
|
||||
function Assert-WelaRecoverySources {
|
||||
param($Plan)
|
||||
if ($Plan.PSObject.Properties.Name -contains 'NamedSources' -and (Get-WelaRecoveryKey @(Get-WelaNamedRecoverySources)) -cne (Get-WelaRecoveryKey $Plan.NamedSources)) {throw 'Named registry recovery implementation changed.'}
|
||||
foreach ($source in @($Plan.Journal,$Plan.OriginalResults)) {if ((Get-WelaRecoveryFile $source.Path).Sha256 -cne $source.Sha256) {throw 'Original recovery evidence changed.'}}
|
||||
if ((Get-FileHash -LiteralPath (Join-Path $PSScriptRoot '../config/audit_profiles.json')).Hash.ToLowerInvariant() -cne $Plan.CatalogSha256) {throw 'Canonical catalog changed.'}
|
||||
if ((Get-WelaRecoveryKey (Get-WelaRecoveryHost)) -cne (Get-WelaRecoveryKey $Plan.Host)) {throw 'Actual host changed since recovery planning.'}
|
||||
@@ -232,7 +256,7 @@ function Invoke-WelaAuditRecovery {
|
||||
if ($control.Kind -eq 'AuditPolicy') {
|
||||
$p=Get-WelaRegistryState 'HKLM:\SYSTEM\CurrentControlSet\Control\Lsa' SCENoApplyLegacyAuditPolicy
|
||||
if (-not $p.ValueExists -or $p.Type -ne 'DWord' -or $p.Value -ne 1) {throw 'Audit precedence changed before recovery write.'}
|
||||
} else {
|
||||
} elseif ($control.Kind -eq 'Registry') {
|
||||
foreach ($prior in $plan.Controls | Where-Object Kind -eq 'AuditPolicy') {if ((Get-WelaRecoveryKey (Get-WelaRecoveryCurrent $prior)) -cne (Get-WelaRecoveryKey $prior.RecoverTo)) {throw 'An audit mask changed before precedence recovery.'}}
|
||||
}
|
||||
Set-WelaRecoveryCurrent $control
|
||||
@@ -252,7 +276,7 @@ function Invoke-WelaAuditRecovery {
|
||||
if ((Get-WelaRecoveryKey $row.After) -cne (Get-WelaRecoveryKey $control.RecoverTo)) {throw 'State changed during final recovery verification.'}
|
||||
} catch {$row.Status='Failed';$row.Diagnostic=$_.Exception.Message;$blocked=$true}
|
||||
}
|
||||
$report=[pscustomobject]@{Status=$(if ($blocked) {'Incomplete'} elseif ($DryRun) {'DryRun'} else {'Recovered'});ExitCode=[int]$blocked;DryRun=[bool]$DryRun;OutputPath=$output;Results=@($results.ToArray());ReadyRuleCredit=0;Scope='Selected audit masks and typed audit precedence only; no persistence or event-generation proof.'}
|
||||
$report=[pscustomobject]@{Status=$(if ($blocked) {'Incomplete'} elseif ($DryRun) {'DryRun'} else {'Recovered'});ExitCode=[int]$blocked;DryRun=[bool]$DryRun;OutputPath=$output;Results=@($results.ToArray());ReadyRuleCredit=0;Scope='Selected audit masks, typed audit precedence and three named logging DWORDs only; value-only registry recovery retains keys. No persistence or event-generation proof.'}
|
||||
if (-not $DryRun) {Write-WelaRecoveryArtifact (Join-Path $output 'results.json') $report}
|
||||
return $report
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
# Value-only recovery for three built-in logging switches. No arbitrary registry replay.
|
||||
function Get-WelaNamedRecoveryCatalog {
|
||||
foreach ($item in @(
|
||||
@('HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\Audit','ProcessCreationIncludeCmdLine_Enabled'),
|
||||
@('HKLM:\SOFTWARE\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging','EnableScriptBlockLogging'),
|
||||
@('HKLM:\SOFTWARE\Policies\Microsoft\Windows\PowerShell\ModuleLogging','EnableModuleLogging')
|
||||
)) {[pscustomobject]@{Id=('Registry/'+$item[0]+'/'+$item[1]);Path=$item[0];Name=$item[1]}}
|
||||
}
|
||||
function Get-WelaNamedRecoverySources {
|
||||
foreach ($relative in @('scripts/NamedRegistryRecovery.ps1','scripts/NamedRegistryRecoveryNative.cs','scripts/AuditRecovery.ps1','scripts/Configuration.ps1')) {
|
||||
[pscustomobject]@{Path=$relative;Sha256=(Get-FileHash -LiteralPath (Join-Path $PSScriptRoot ('../'+$relative)) -Algorithm SHA256 -ErrorAction Stop).Hash.ToLowerInvariant()}
|
||||
}
|
||||
}
|
||||
function Initialize-WelaNamedRecoveryNative {
|
||||
$path=Join-Path $PSScriptRoot 'NamedRegistryRecoveryNative.cs'
|
||||
$bytes=[IO.File]::ReadAllBytes($path);$hash=Get-WelaRecoveryHash $bytes
|
||||
if ('Wela.NamedRegistryRecovery.Key' -as [type]) {
|
||||
if ([Wela.NamedRegistryRecovery.Key]::SourceSha256 -cne $hash) {throw 'Loaded named-registry native source differs; start a fresh process.'}
|
||||
return
|
||||
}
|
||||
$source=(New-Object Text.UTF8Encoding($false,$true)).GetString($bytes).Replace('__WELA_SOURCE_SHA256__',$hash)
|
||||
Add-Type -TypeDefinition $source -ErrorAction Stop
|
||||
}
|
||||
function Assert-WelaNamedRecoveryValue {
|
||||
param($State)
|
||||
if ($State.KeyExists -isnot [bool] -or $State.ValueExists -isnot [bool]) {throw 'Logging registry state requires typed existence flags.'}
|
||||
if ($State.ValueExists) {
|
||||
if (-not $State.KeyExists -or $State.Type -cne 'DWord' -or ($State.Value -isnot [int] -and $State.Value -isnot [long]) -or $State.Value -notin @(0,1)) {throw 'Only prior DWORD 0/1 or value absence is supported.'}
|
||||
} elseif ($null -ne $State.Value -or $null -ne $State.Type) {throw 'Absent logging value has inconsistent state.'}
|
||||
}
|
||||
function Get-WelaNamedRecoveryGuard {
|
||||
param($Observation)
|
||||
[pscustomobject][ordered]@{ObjectName=$Observation.ObjectName;OtherValues=$Observation.OtherValues;Children=$Observation.Children;Security=$Observation.Security}
|
||||
}
|
||||
function Get-WelaNamedRecoveryState {
|
||||
param($Observation)
|
||||
[pscustomobject]@{KeyExists=$true;ValueExists=[bool]$Observation.Exists;Value=$(if ($Observation.Exists) {[int]$Observation.Value} else {$null});Type=$(if ($Observation.Exists) {'DWord'} else {$null})}
|
||||
}
|
||||
function Open-WelaNamedRecoveryKey {
|
||||
param($Target,[bool]$Write=$false)
|
||||
$known=@(Get-WelaNamedRecoveryCatalog | Where-Object {$_.Path -ceq $Target.Path -and $_.Name -ceq $Target.Name})
|
||||
if ($known.Count -ne 1) {throw 'Unknown logging recovery target.'}
|
||||
Initialize-WelaNamedRecoveryNative
|
||||
[Wela.NamedRegistryRecovery.Key]::new($Target.Path,$Write)
|
||||
}
|
||||
function Get-WelaNamedRecoveryObservation {
|
||||
param($Target)
|
||||
$key=Open-WelaNamedRecoveryKey $Target
|
||||
try {
|
||||
$observation=$key.Read($Target.Name)
|
||||
if ($observation.ObjectName -ine ('\REGISTRY\MACHINE\'+$Target.Path.Substring(6))) {throw 'Native registry name does not match the selected path.'}
|
||||
$observation
|
||||
} finally {$key.Dispose()}
|
||||
}
|
||||
function Assert-WelaNamedRecoveryGuard {
|
||||
param($Control,$Observation)
|
||||
if ((Get-WelaRecoveryKey (Get-WelaNamedRecoveryGuard $Observation)) -cne (Get-WelaRecoveryKey $Control.RegistryGuard)) {throw 'Logging registry path, other values, children or security changed since planning.'}
|
||||
}
|
||||
function Set-WelaNamedRecoveryValue {
|
||||
param($Control)
|
||||
$key=Open-WelaNamedRecoveryKey $Control.Target $true
|
||||
try {
|
||||
$before=$key.Read($Control.Target.Name)
|
||||
Assert-WelaNamedRecoveryGuard $Control $before
|
||||
if ((Get-WelaRecoveryKey (Get-WelaNamedRecoveryState $before)) -cne (Get-WelaRecoveryKey $Control.Expected)) {throw 'Logging value changed before recovery.'}
|
||||
$value=if ($Control.RecoverTo.ValueExists) {[int]$Control.RecoverTo.Value} else {0}
|
||||
$after=$key.Restore($Control.Target.Name,$before,$Control.RecoverTo.ValueExists,$value)
|
||||
Assert-WelaNamedRecoveryGuard $Control $after
|
||||
# Reopen the selected path after the handle-based write to detect visible path drift.
|
||||
$fresh=Get-WelaNamedRecoveryObservation $Control.Target
|
||||
Assert-WelaNamedRecoveryGuard $Control $fresh
|
||||
if ((Get-WelaRecoveryKey (Get-WelaNamedRecoveryState $fresh)) -cne (Get-WelaRecoveryKey $Control.RecoverTo)) {throw 'Reopened logging value differs after recovery.'}
|
||||
} finally {$key.Dispose()}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.ComponentModel;
|
||||
using System.IO;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
namespace Wela.NamedRegistryRecovery {
|
||||
public sealed class Observation {
|
||||
public bool Exists; public int Value; public string ObjectName, OtherValues, Children, Security, LastWrite;
|
||||
}
|
||||
public sealed class Key : IDisposable {
|
||||
public const string SourceSha256 = "__WELA_SOURCE_SHA256__";
|
||||
IntPtr handle;
|
||||
[DllImport("advapi32.dll",CharSet=CharSet.Unicode)] static extern int RegOpenKeyEx(IntPtr key,string sub,uint options,uint access,out IntPtr result);
|
||||
[DllImport("advapi32.dll")] static extern int RegCloseKey(IntPtr key);
|
||||
[DllImport("advapi32.dll",CharSet=CharSet.Unicode)] static extern int RegQueryValueEx(IntPtr key,string name,IntPtr reserved,out uint type,byte[] data,ref uint size);
|
||||
[DllImport("advapi32.dll",CharSet=CharSet.Unicode)] static extern int RegEnumValue(IntPtr key,uint index,StringBuilder name,ref uint nameLength,IntPtr reserved,out uint type,byte[] data,ref uint size);
|
||||
[DllImport("advapi32.dll",CharSet=CharSet.Unicode)] static extern int RegEnumKeyEx(IntPtr key,uint index,StringBuilder name,ref uint nameLength,IntPtr reserved,IntPtr cls,IntPtr clsLength,out long lastWrite);
|
||||
[DllImport("advapi32.dll",CharSet=CharSet.Unicode)] static extern int RegQueryInfoKey(IntPtr key,IntPtr cls,IntPtr clsLength,IntPtr reserved,out uint subkeys,IntPtr maxSub,IntPtr maxClass,out uint values,IntPtr maxName,IntPtr maxValue,IntPtr security,out long lastWrite);
|
||||
[DllImport("advapi32.dll")] static extern int RegGetKeySecurity(IntPtr key,uint information,byte[] descriptor,ref uint size);
|
||||
[DllImport("advapi32.dll",CharSet=CharSet.Unicode)] static extern int RegSetValueEx(IntPtr key,string name,int reserved,uint type,byte[] data,uint size);
|
||||
[DllImport("advapi32.dll",CharSet=CharSet.Unicode)] static extern int RegDeleteValue(IntPtr key,string name);
|
||||
[DllImport("ntdll.dll")] static extern int NtQueryKey(IntPtr key,int informationClass,byte[] information,int length,out int resultLength);
|
||||
static void Check(int error){if(error!=0)throw new Win32Exception(error);}
|
||||
static string Hash(byte[] bytes){using(var sha=SHA256.Create())return BitConverter.ToString(sha.ComputeHash(bytes)).Replace("-","").ToLowerInvariant();}
|
||||
static string HashStrings(List<string> values){values.Sort(StringComparer.Ordinal);return Hash(Encoding.UTF8.GetBytes(String.Join("\n",values.ToArray())));}
|
||||
static string Enc(string value){return Convert.ToBase64String(Encoding.UTF8.GetBytes(value));}
|
||||
public Key(string path,bool write) {
|
||||
if(!Environment.Is64BitProcess || !path.StartsWith("HKLM:\\SOFTWARE\\",StringComparison.Ordinal) || path.IndexOfAny(new char[]{'/', '*','?','\0'})>=0)throw new InvalidOperationException("Only reviewed native HKLM SOFTWARE paths are supported.");
|
||||
string[] parts=path.Substring(6).Split('\\');IntPtr parent=new IntPtr(unchecked((int)0x80000002));bool owned=false;
|
||||
try {
|
||||
for(int i=0;i<parts.Length;i++) {
|
||||
if(parts[i].Length==0 || parts[i]=="." || parts[i]=="..")throw new InvalidOperationException("Ambiguous registry path.");
|
||||
IntPtr next;Check(RegOpenKeyEx(parent,parts[i],8,0x20119U | ((write && i==parts.Length-1)?2U:0U),out next));
|
||||
if(owned)RegCloseKey(parent);parent=next;owned=true;
|
||||
uint type,size=0;int error=RegQueryValueEx(parent,"SymbolicLinkValue",IntPtr.Zero,out type,null,ref size);
|
||||
if(error!=0 && error!=2 && error!=234)Check(error);
|
||||
if((error==0 || error==234) && type==6)throw new InvalidOperationException("Registry links are unsupported.");
|
||||
}
|
||||
handle=parent;owned=false;
|
||||
} finally {if(owned)RegCloseKey(parent);}
|
||||
}
|
||||
string Name() {
|
||||
int required;int status=NtQueryKey(handle,3,null,0,out required);
|
||||
if(status!=unchecked((int)0xC0000023) && status!=unchecked((int)0x80000005))throw new InvalidOperationException("Cannot size native registry identity: "+status);
|
||||
if(required<4 || required>65536)throw new InvalidOperationException("Native registry name bound exceeded.");
|
||||
byte[] bytes=new byte[required];status=NtQueryKey(handle,3,bytes,bytes.Length,out required);
|
||||
if(status!=0)throw new InvalidOperationException("Cannot read native registry identity: "+status);
|
||||
int length=BitConverter.ToInt32(bytes,0);if(length<0 || length>bytes.Length-4 || (length%2)!=0)throw new InvalidOperationException("Invalid native registry name.");
|
||||
return Encoding.Unicode.GetString(bytes,4,length);
|
||||
}
|
||||
public Observation Read(string selected) {
|
||||
var result=new Observation();result.ObjectName=Name();
|
||||
uint subkeys,values;long time;Check(RegQueryInfoKey(handle,IntPtr.Zero,IntPtr.Zero,IntPtr.Zero,out subkeys,IntPtr.Zero,IntPtr.Zero,out values,IntPtr.Zero,IntPtr.Zero,IntPtr.Zero,out time));
|
||||
if(subkeys>256 || values>256)throw new InvalidOperationException("Registry inventory exceeds 256 children/values.");result.LastWrite=time.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
||||
var other=new List<string>();long total=0;
|
||||
for(uint i=0;i<values;i++) {
|
||||
var name=new StringBuilder(16384);uint nameLength=16384,type,size=65536;byte[] data=new byte[size];Check(RegEnumValue(handle,i,name,ref nameLength,IntPtr.Zero,out type,data,ref size));
|
||||
total+=size;if(total>1048576)throw new InvalidOperationException("Registry value inventory exceeds one MiB.");Array.Resize(ref data,(int)size);
|
||||
if(String.Equals(name.ToString(),selected,StringComparison.OrdinalIgnoreCase)) {
|
||||
if(name.ToString()!=selected || type!=4 || size!=4)throw new InvalidOperationException("Selected logging value has an unknown name/type/length.");
|
||||
uint value=BitConverter.ToUInt32(data,0);if(value>1)throw new InvalidOperationException("Selected logging DWORD is outside 0/1.");result.Exists=true;result.Value=(int)value;
|
||||
} else other.Add(Enc(name.ToString())+"|"+type+"|"+size+"|"+Hash(data));
|
||||
}
|
||||
result.OtherValues=HashStrings(other);
|
||||
var children=new List<string>();
|
||||
for(uint i=0;i<subkeys;i++){var name=new StringBuilder(256);uint length=256;long childTime;Check(RegEnumKeyEx(handle,i,name,ref length,IntPtr.Zero,IntPtr.Zero,IntPtr.Zero,out childTime));children.Add(Enc(name.ToString()));}
|
||||
result.Children=HashStrings(children);
|
||||
uint securitySize=0;int code=RegGetKeySecurity(handle,7,null,ref securitySize);if(code!=122)Check(code);
|
||||
if(securitySize<20 || securitySize>65536)throw new InvalidOperationException("Registry security descriptor size is unsupported.");
|
||||
byte[] security=new byte[securitySize];Check(RegGetKeySecurity(handle,7,security,ref securitySize));Array.Resize(ref security,(int)securitySize);result.Security=Hash(security);
|
||||
uint endSubkeys,endValues;long endTime;Check(RegQueryInfoKey(handle,IntPtr.Zero,IntPtr.Zero,IntPtr.Zero,out endSubkeys,IntPtr.Zero,IntPtr.Zero,out endValues,IntPtr.Zero,IntPtr.Zero,IntPtr.Zero,out endTime));
|
||||
if(endTime!=time || endSubkeys!=subkeys || endValues!=values || result.ObjectName!=Name())throw new InvalidOperationException("Registry key changed during bounded observation.");
|
||||
return result;
|
||||
}
|
||||
public static bool Preserved(Observation a,Observation b){return a.ObjectName==b.ObjectName && a.OtherValues==b.OtherValues && a.Children==b.Children && a.Security==b.Security;}
|
||||
public Observation Restore(string name,Observation expected,bool exists,int value) {
|
||||
if(value<0 || value>1)throw new InvalidOperationException("Unknown recovery value.");
|
||||
Observation before=Read(name);
|
||||
if(!Preserved(before,expected) || before.LastWrite!=expected.LastWrite || before.Exists!=expected.Exists || (before.Exists && before.Value!=expected.Value))throw new InvalidOperationException("Registry guard changed before value-only recovery.");
|
||||
if(exists)Check(RegSetValueEx(handle,name,0,4,BitConverter.GetBytes(value),4));else Check(RegDeleteValue(handle,name));
|
||||
Observation after=Read(name);
|
||||
if(!Preserved(before,after) || after.Exists!=exists || (exists && after.Value!=value))throw new InvalidOperationException("Registry recovery readback or preservation failed.");
|
||||
return after;
|
||||
}
|
||||
public void Dispose(){if(handle!=IntPtr.Zero){RegCloseKey(handle);handle=IntPtr.Zero;}}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user