/// <summary> /// Deletes a given subkey and all of its subkeys /// </summary> /// <param name="registryKeyRoot">Enum of the root key to delete from (e.g. HKEY_LOCAL_MACHINE = LocalMachine)</param> /// <param name="subKey">Path of the subkey to be deleted</param> /// <param name="registryVersion">Version of the registry to delete from. Can be 32-Bit, 64-Bit, or both</param> public void DeleteSubKeyTree(RegistryKeyRoot registryKeyRoot, string subKey, RegistryVersion registryVersion) { RegistryKey rk; RegistryHive rh; RegistryView rv; switch (registryVersion) { case RegistryVersion.Both: rh = DetermineRegistryHive(registryKeyRoot); rv = DetermineRegistryView(RegistryVersion.Only32Bit); rk = RegistryKey.OpenBaseKey(rh, rv); rk.DeleteSubKeyTree(subKey); rk = DetermineRootKey(registryKeyRoot); rk.DeleteSubKeyTree(subKey); break; case RegistryVersion.Only32Bit: rh = DetermineRegistryHive(registryKeyRoot); rv = DetermineRegistryView(RegistryVersion.Only32Bit); rk = RegistryKey.OpenBaseKey(rh, rv); rk.DeleteSubKeyTree(subKey); break; default: rk = DetermineRootKey(registryKeyRoot); rk.DeleteSubKeyTree(subKey); break; } rk.Flush(); }
/// <summary> /// SetTheme method implementation /// </summary> internal void SetTheme(PSHost host, int _kind, string _theme, bool _dynparam) { RegistryVersion reg = new RegistryVersion(); ManagementService.Initialize(true); MFAConfig cfg = ManagementService.Config; if (reg.IsWindows2019) { cfg.UiKind = (ADFSUserInterfaceKind)_kind; if ((ADFSUserInterfaceKind)_kind == ADFSUserInterfaceKind.Default) { cfg.UseUIPaginated = false; } else { cfg.UseUIPaginated = _dynparam; } ManagementService.ADFSManager.SetADFSTheme(host, _theme, cfg.UseUIPaginated, true); ManagementService.ADFSManager.WriteConfiguration(host); } else { cfg.UiKind = ADFSUserInterfaceKind.Default; cfg.UseUIPaginated = false; ManagementService.ADFSManager.SetADFSTheme(host, _theme, false, false); ManagementService.ADFSManager.WriteConfiguration(host); } }
/// <summary> /// GetADFSAccounts method implmentation /// </summary> private static bool GetADFSAccounts(ref SIDsParametersRecord rec) { RegistryVersion reg = new RegistryVersion(); ADFSAdminPolicies pol = new ADFSAdminPolicies(); try { rec.ADFSAccountSID = GetADFSAccountSID(); rec.ADFSAccountName = GetADFSAccountName(); rec.ADFSServiceAccountSID = GetADFSServiceSID(); rec.ADFSServiceAccountName = GetADFSServiceName(); if (!reg.IsWindows2012R2) { rec.ADFSAdministrationGroupName = GetADFSAdminsGroupName(ref pol); rec.ADFSAdministrationGroupSID = GetADFSAdminsGroupSID(rec.ADFSAdministrationGroupName); rec.ADFSDelegateServiceAdministrationAllowed = pol.DelegateServiceAdministrationAllowed; rec.ADFSLocalAdminServiceAdministrationAllowed = pol.LocalAdminsServiceAdministrationAllowed; rec.ADFSSystemServiceAdministrationAllowed = pol.SystemServiceAdministrationAllowed; } else { rec.ADFSAdministrationGroupName = string.Empty; rec.ADFSAdministrationGroupSID = string.Empty; rec.ADFSDelegateServiceAdministrationAllowed = false; rec.ADFSLocalAdminServiceAdministrationAllowed = true; rec.ADFSSystemServiceAdministrationAllowed = true; } return(true); } catch (Exception) { return(false); } }
/// <summary> /// GetADFSAccounts method implmentation /// </summary> private static bool GetADFSAccounts(ref SIDsParametersRecord rec) { RegistryVersion reg = new RegistryVersion(); ADFSAdminPolicies pol = new ADFSAdminPolicies(); try { rec.ADFSAccountSID = GetADFSAccountSID(); rec.ADFSAccountName = GetADFSAccountName(); rec.ADFSServiceAccountSID = GetADFSServiceSID(); rec.ADFSServiceAccountName = GetADFSServiceName(); if (!reg.IsWindows2012R2) { rec.ADFSAdministrationGroupName = GetADFSAdminsGroupName(ref pol); rec.ADFSAdministrationGroupSID = GetADFSAdminsGroupSID(rec.ADFSAdministrationGroupName); rec.ADFSDelegateServiceAdministrationAllowed = pol.DelegateServiceAdministrationAllowed; rec.ADFSLocalAdminServiceAdministrationAllowed = pol.LocalAdminsServiceAdministrationAllowed; rec.ADFSSystemServiceAdministrationAllowed = pol.SystemServiceAdministrationAllowed; } else { rec.ADFSAdministrationGroupName = string.Empty; rec.ADFSAdministrationGroupSID = string.Empty; rec.ADFSDelegateServiceAdministrationAllowed = false; rec.ADFSLocalAdminServiceAdministrationAllowed = true; rec.ADFSSystemServiceAdministrationAllowed = true; } return(true); } catch (Exception ex) { Log.WriteEntry("Error loading SIDs informations : \r" + ex.Message, EventLogEntryType.Error, 666); return(false); } }
/// <summary> /// InitFarmNodeConfiguration method implementation /// </summary> public string InitServerNodeConfiguration() { string result = null; try { RegistryVersion reg = new RegistryVersion(); if (reg.IsWindows2019) { result = InitServerNodeConfiguration2019(reg); } else if (reg.IsWindows2016) { result = InitServerNodeConfiguration2016(reg); } else if (reg.IsWindows2012R2) { result = InitServerNodeConfiguration2012(reg); } } catch (Exception ex) { throw ex; } return(result); }
/// <summary> /// VerifyADFSServer2019 method implementation /// </summary> internal static void VerifyADFSServer2019() { RegistryVersion reg = new RegistryVersion(); if (!reg.IsWindows2019) { throw new InvalidOperationException("PS0033: This Cmdlet must be executed on Windows 2019 server and up only !"); } }
/// <summary> /// Static constructor implementation /// </summary> internal ReplayManager(IDependency dep) { _log = dep.GetEventLog(); _blobUrl = SystemUtilities.PayloadDownloadBlobUrl; _threatUrl = SystemUtilities.ThreatDownloadBlobUrl; _httpClient = new HttpClient(); RegistryVersion reg = new RegistryVersion(); isbehavior4 = reg.IsADFSBehavior4; }
/// <summary> /// GetLocalNodeInformations method implementation /// </summary> private ADFSNodeInformation GetLocalNodeInformations(RegistryVersion reg, string servername) { if (reg.IsWindows2012R2) { return(new ADFSNodeInformation() { BehaviorLevel = 1, HeartbeatTmeStamp = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, 0, DateTimeKind.Local) }); } else { Runspace SPRunSpace = null; PowerShell SPPowerShell = null; try { SPRunSpace = RunspaceFactory.CreateRunspace(); SPPowerShell = PowerShell.Create(); SPPowerShell.Runspace = SPRunSpace; SPRunSpace.Open(); Pipeline pipeline = SPRunSpace.CreatePipeline(); Command exportcmd = new Command("(Get-AdfsFarmInformation).FarmNodes", true); pipeline.Commands.Add(exportcmd); Collection <PSObject> PSOutput = pipeline.Invoke(); foreach (var result in PSOutput) { string fqdn = result.Members["FQDN"].Value.ToString(); if (servername.ToLower().Equals(fqdn.ToLower())) { ADFSNodeInformation props = new ADFSNodeInformation { BehaviorLevel = Convert.ToInt32(result.Members["BehaviorLevel"].Value), HeartbeatTmeStamp = Convert.ToDateTime(result.Members["HeartbeatTimeStamp"].Value), }; return(props); } } return(new ADFSNodeInformation()); } finally { if (SPRunSpace != null) { SPRunSpace.Close(); } if (SPPowerShell != null) { SPPowerShell.Dispose(); } } } }
/// <summary> /// GetAllComputerInformations method implementation /// </summary> internal Dictionary <string, ADFSServerHost> GetAllComputerInformations(Dictionary <string, bool> servers) { string fqdn = Dns.GetHostEntry("localhost").HostName.ToLower(); List <string> servernames = (from server in servers where (server.Key.ToLower() != fqdn.ToLower()) select server.Key.ToLower()).ToList <string>(); Dictionary <string, ADFSServerHost> dict = new Dictionary <string, ADFSServerHost>(); RegistryVersion reg = new RegistryVersion(); string nodetype = GetLocalNodeType(); ADFSNodeInformation node = GetLocalNodeInformations(reg, fqdn); node.NodeType = nodetype; dict.Add(fqdn, new ADFSServerHost() { FQDN = fqdn, BehaviorLevel = node.BehaviorLevel, HeartbeatTmeStamp = node.HeartbeatTmeStamp, NodeType = node.NodeType, CurrentVersion = reg.CurrentVersion, CurrentBuild = reg.CurrentBuild, InstallationType = reg.InstallationType, ProductName = reg.ProductName, CurrentMajorVersionNumber = reg.CurrentMajorVersionNumber, CurrentMinorVersionNumber = reg.CurrentMinorVersionNumber }); foreach (string srv in servernames) { WebAdminClient manager = new WebAdminClient(); manager.Initialize(srv); try { IWebAdminServices client = manager.Open(); try { dict.Add(srv, client.GetComputerInformations(srv, false)); } catch (EndpointNotFoundException nf) { _log.WriteEntry(nf.Message, EventLogEntryType.Error, 2010); continue; } finally { manager.Close(client); } } finally { manager.UnInitialize(); } } return(dict); }
/// <summary> /// GetNodeInformations method implementation /// </summary> public ADFSNodeInformation GetNodeInformations(RegistryVersion reg, string servername = "localhost", bool dispatch = true) { try { return(_manager.GetNodeInformations(reg, servername, dispatch)); } catch (Exception e) { _log.WriteEntry(string.Format("Error on WebAdminService Service GetNodeInformations method : {0}.", e.Message), EventLogEntryType.Error, 2010); throw e; } }
/// <summary> /// Writes a value to given key /// </summary> /// <param name="registryKeyRoot">Enum of the root key to read from (e.g. HKEY_LOCAL_MACHINE = LocalMachine)</param> /// <param name="key">Path to the key to write to. If part of the given key does not already exist it will be written</param> /// <param name="registryVersion">Version of the registry to write to. Can be 32-Bit, 64-Bit, or both</param> /// <param name="valueToWrite">Value to write to the key. should be given in the structure (Name, Data)</param> public void WriteValue(RegistryKeyRoot registryKeyRoot, string key, RegistryVersion registryVersion, List <KeyValuePair <string, object> > valueToWrite) { RegistryHive rh; RegistryView rv; RegistryKey rk; RegistryKey subKey; switch (registryVersion) { case RegistryVersion.Both: rh = DetermineRegistryHive(registryKeyRoot); rv = DetermineRegistryView(RegistryVersion.Only32Bit); rk = RegistryKey.OpenBaseKey(rh, rv); subKey = rk.CreateSubKey(key); foreach (var item in valueToWrite) { subKey.SetValue(item.Key, item.Value); } rk = DetermineRootKey(registryKeyRoot); subKey = rk.CreateSubKey(key); foreach (var item in valueToWrite) { subKey.SetValue(item.Key, item.Value); } rk.Flush(); break; case RegistryVersion.Only32Bit: rh = DetermineRegistryHive(registryKeyRoot); rv = DetermineRegistryView(RegistryVersion.Only32Bit); rk = RegistryKey.OpenBaseKey(rh, rv); subKey = rk.CreateSubKey(key); foreach (var item in valueToWrite) { subKey.SetValue(item.Key, item.Value); } rk.Flush(); break; default: rk = DetermineRootKey(registryKeyRoot); subKey = rk.CreateSubKey(key); foreach (var item in valueToWrite) { subKey.SetValue(item.Key, item.Value); } rk.Flush(); break; } }
/// <summary> /// Returns the registry key at the path specified /// </summary> /// <param name="keyPath">Full path of the key to be read</param> /// <param name="registryVersion">Version of the registry to be read from</param> /// <returns>A key container with the values</returns> public RegistryKeyContainer ReadKey(string keyPath, RegistryVersion registryVersion) { var keyPathSplit = keyPath.Split('\\'); var rootKeyString = keyPathSplit[0]; var registryKeyRoot = DetermineRootKey(rootKeyString); keyPath = ""; for (var i = 1; i < keyPathSplit.Length; i++) { var t = keyPathSplit[i]; keyPath += (t + "\\"); } return(ReadKey(registryKeyRoot, keyPath, registryVersion)); }
/// <summary> /// GetComputerInformations method implementation /// </summary> internal ADFSNodeInformation GetNodeInformations(RegistryVersion reg, string servername, bool dispatch = true) { string fqdn = Dns.GetHostEntry("localhost").HostName.ToLower(); if (fqdn.ToLower().Equals(servername.ToLower())) { string nodetype = GetLocalNodeType(); ADFSNodeInformation node = GetLocalNodeInformations(reg, servername); node.NodeType = nodetype; return(node); } else { if (dispatch) { WebAdminClient manager = new WebAdminClient(); manager.Initialize(servername); try { IWebAdminServices client = manager.Open(); try { string nodetype = client.GetNodeType(servername, false); ADFSNodeInformation node = node = GetLocalNodeInformations(reg, servername); node.NodeType = nodetype; return(node); } finally { manager.Close(client); } } catch (Exception e) { _log.WriteEntry(string.Format("Error on WebAdminService Service GetNodeInformations method : {0} / {1}.", servername, e.Message), EventLogEntryType.Error, 2010); throw e; } finally { manager.UnInitialize(); } } else { throw new Exception(); } } }
/// <summary> /// VerifyADFSServer2019 method implementation /// </summary> internal static void VerifyADFSServer2019(PSHost host = null) { RegistryVersion reg = new RegistryVersion(); if (!reg.IsADFSBehavior4) { if (host == null) { throw new InvalidOperationException("Must be executed on Windows 2019 server and up only !"); } else { throw new InvalidOperationException("PS0033: This Cmdlet must be executed on Windows 2019 server and up only !"); } } }
/// <summary> /// DoOnReceiveServerConfiguration method implementation (Server) /// </summary> private NamedPipeRegistryRecord DoOnReceiveServerConfiguration(string requestor) { RegistryVersion reg = new RegistryVersion(); NamedPipeRegistryRecord rec = default(NamedPipeRegistryRecord); rec.FQDN = Dns.GetHostEntry("LocalHost").HostName; rec.CurrentVersion = reg.CurrentVersion; rec.CurrentBuild = reg.CurrentBuild; rec.CurrentMajorVersionNumber = reg.CurrentMajorVersionNumber; rec.CurrentMinorVersionNumber = reg.CurrentMinorVersionNumber; rec.InstallationType = reg.InstallationType; rec.ProductName = reg.ProductName; rec.IsWindows2012R2 = reg.IsWindows2012R2; rec.IsWindows2016 = reg.IsWindows2016; rec.IsWindows2019 = reg.IsWindows2019; rec.NodeType = FarmUtilities.InitServerNodeType(); return(rec); }
/// <summary> /// InitServerNodeConfiguration2012 method implementation /// </summary> private string InitServerNodeConfiguration2012(RegistryVersion reg) { string nodetype = string.Empty; Runspace SPRunSpace = null; PowerShell SPPowerShell = null; try { RunspaceConfiguration SPRunConfig = RunspaceConfiguration.Create(); SPRunSpace = RunspaceFactory.CreateRunspace(SPRunConfig); SPPowerShell = PowerShell.Create(); SPPowerShell.Runspace = SPRunSpace; SPRunSpace.Open(); Pipeline pipeline = SPRunSpace.CreatePipeline(); Command exportcmd = new Command("(Get-AdfsSyncProperties).Role", true); pipeline.Commands.Add(exportcmd); Collection <PSObject> PSOutput = pipeline.Invoke(); foreach (var prop in PSOutput) { nodetype = prop.BaseObject.ToString(); break; } } finally { if (SPRunSpace != null) { SPRunSpace.Close(); } } string result = reg.VersionAsString(); result += "|"; result += Dns.GetHostEntry("LocalHost").HostName + ";"; result += "1;"; result += new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, 0, DateTimeKind.Local) + ";"; result += nodetype + ";"; return(result); }
/// <summary> /// Determines the version of the registry to be accessed (64-Bit or 32-Bit) /// </summary> /// <param name="registryVersion"></param> /// <returns>Returns the appropriate RegistryView</returns> internal RegistryView DetermineRegistryView(RegistryVersion registryVersion) { RegistryView rv; switch (registryVersion) { case RegistryVersion.Only32Bit: rv = RegistryView.Registry32; break; case RegistryVersion.Only64Bit: rv = RegistryView.Registry64; break; default: rv = RegistryView.Default; break; } return(rv); }
/// <summary> /// InitServerNodeConfiguration2019 method implementation /// </summary> private string InitServerNodeConfiguration2019(RegistryVersion reg) { string result = string.Empty; Runspace SPRunSpace = null; PowerShell SPPowerShell = null; try { RunspaceConfiguration SPRunConfig = RunspaceConfiguration.Create(); SPRunSpace = RunspaceFactory.CreateRunspace(SPRunConfig); SPPowerShell = PowerShell.Create(); SPPowerShell.Runspace = SPRunSpace; SPRunSpace.Open(); Pipeline pipeline = SPRunSpace.CreatePipeline(); Command exportcmd = new Command("(Get-AdfsFarmInformation).FarmNodes", true); pipeline.Commands.Add(exportcmd); Collection <PSObject> PSOutput = pipeline.Invoke(); foreach (var item in PSOutput) { result = reg.VersionAsString(); result += "|"; result += item.Members["FQDN"].Value.ToString() + ";"; result += item.Members["BehaviorLevel"].Value.ToString() + ";"; result += item.Members["HeartbeatTimeStamp"].Value.ToString() + ";"; result += item.Members["NodeType"].Value.ToString() + ";"; } } finally { if (SPRunSpace != null) { SPRunSpace.Close(); } } return(result); }
/// <summary> /// GetCompterInformations method informations /// </summary> public static ADFSNodeInformation GetNodeformations(RegistryVersion reg, string fqdn) { WebAdminClient manager = new WebAdminClient(); manager.Initialize(); try { IWebAdminServices client = manager.Open(); try { return(client.GetNodeInformations(reg, fqdn, true)); } finally { manager.Close(client); } } finally { manager.UnInitialize(); } }
/// <summary> /// UnPackServerNodeConfiguration method implementation /// </summary> public ADFSServerHost UnPackServerNodeConfiguration(string data) { ADFSServerHost host = new ADFSServerHost(); string[] ps = data.Split('|'); RegistryVersion reg = new RegistryVersion(); reg.VersionFromString(ps[0]); host.CurrentBuild = reg.CurrentBuild; host.CurrentMajorVersionNumber = reg.CurrentMajorVersionNumber; host.CurrentMinorVersionNumber = reg.CurrentMinorVersionNumber; host.CurrentVersion = reg.CurrentVersion; host.InstallationType = reg.InstallationType; host.ProductName = reg.ProductName; string[] px = ps[1].Split(';'); host.FQDN = px[0]; host.BehaviorLevel = Convert.ToInt32(px[1]); host.HeartbeatTmeStamp = Convert.ToDateTime(px[2]); host.NodeType = px[3]; return(host); }
/// <summary> /// Deletes a value from a given subkey /// </summary> /// <param name="registryKeyRoot">Enum of the root key to delete from (e.g. HKEY_LOCAL_MACHINE = LocalMachine)</param> /// <param name="subKey">Path of the subkey to delete the value from</param> /// <param name="value">Value to be deleted</param> /// <param name="registryVersion">Version of the registry to delete from. Can be 32-Bit, 64-Bit, or both</param> public void DeleteValue(RegistryKeyRoot registryKeyRoot, string subKey, string value, RegistryVersion registryVersion) { RegistryKey rk; RegistryHive rh; RegistryView rv; RegistryKey sk; switch (registryVersion) { case RegistryVersion.Both: rh = DetermineRegistryHive(registryKeyRoot); rv = DetermineRegistryView(RegistryVersion.Only32Bit); rk = RegistryKey.OpenBaseKey(rh, rv); try { sk = rk.OpenSubKey(subKey, true); sk.DeleteValue(value, true); } catch (UnauthorizedAccessException e) { throw new UnauthorizedAccessException("You do not have permission to write to this key." + "Try running as administrator.", e); } rk = DetermineRootKey(registryKeyRoot); try { sk = rk.OpenSubKey(subKey, true); sk.DeleteValue(value, true); } catch (UnauthorizedAccessException e) { throw new UnauthorizedAccessException(UnauthorizedAccessMsg, e); } break; case RegistryVersion.Only32Bit: rh = DetermineRegistryHive(registryKeyRoot); rv = DetermineRegistryView(RegistryVersion.Only32Bit); rk = RegistryKey.OpenBaseKey(rh, rv); try { sk = rk.OpenSubKey(subKey, true); sk.DeleteValue(value, true); } catch (UnauthorizedAccessException e) { throw new UnauthorizedAccessException(UnauthorizedAccessMsg, e); } break; default: rk = DetermineRootKey(registryKeyRoot); try { sk = rk.OpenSubKey(subKey, true); sk.DeleteValue(value, true); } catch (UnauthorizedAccessException e) { throw new UnauthorizedAccessException(UnauthorizedAccessMsg, e); } break; } rk.Flush(); }
/// <summary> /// Returns the registry key at the path specified /// </summary> /// <param name="registryKeyRoot">Enum of the root key to read from (e.g. HKEY_LOCAL_MACHINE = LocalMachine)</param> /// <param name="keyPath">Path to the key to read from (without the root key)</param> /// <param name="registryVersion">Version of the registry to read from. Can be 32-Bit, 64-Bit, or both</param> /// <returns></returns> public RegistryKeyContainer ReadKey(RegistryKeyRoot registryKeyRoot, string keyPath, RegistryVersion registryVersion) { var _32BitValues = new List <KeyValuePair <string, object> >(); var _64BitValues = new List <KeyValuePair <string, object> >(); RegistryHive rh; RegistryView rv; RegistryKey rk; RegistryKey sk; switch (registryVersion) { case RegistryVersion.Both: rh = DetermineRegistryHive(registryKeyRoot); rv = RegistryView.Registry32; rk = RegistryKey.OpenBaseKey(rh, rv); try { sk = rk.OpenSubKey(keyPath); foreach (var valueName in sk.GetValueNames()) { _32BitValues.Add(new KeyValuePair <string, object>(valueName, sk.GetValue(valueName))); } } catch (NullReferenceException) {} rk = DetermineRootKey(registryKeyRoot); try { sk = rk.OpenSubKey(keyPath); foreach (var valueName in sk.GetValueNames()) { _64BitValues.Add(new KeyValuePair <string, object>(valueName, sk.GetValue(valueName))); } } catch (NullReferenceException) {} break; case RegistryVersion.Only32Bit: rh = DetermineRegistryHive(registryKeyRoot); rv = RegistryView.Registry32; rk = RegistryKey.OpenBaseKey(rh, rv); try { sk = rk.OpenSubKey(keyPath); foreach (var valueName in sk.GetValueNames()) { _32BitValues.Add(new KeyValuePair <string, object>(valueName, sk.GetValue(valueName))); } } catch (NullReferenceException) {} break; default: rk = DetermineRootKey(registryKeyRoot); try { sk = rk.OpenSubKey(keyPath); foreach (var valueName in sk.GetValueNames()) { _64BitValues.Add(new KeyValuePair <string, object>(valueName, sk.GetValue(valueName))); } } catch (NullReferenceException) {} break; } var keyContainer = new RegistryKeyContainer(registryKeyRoot, keyPath, _64BitValues, _32BitValues, registryVersion); return(keyContainer); }
/// <summary> /// GetComputerInformations method implementation /// </summary> internal ADFSServerHost GetComputerInformations(string servername, bool dispatch = true) { string fqdn = Dns.GetHostEntry("localhost").HostName.ToLower(); if (fqdn.ToLower().Equals(servername.ToLower())) { RegistryVersion reg = new RegistryVersion(); string nodetype = GetLocalNodeType(); ADFSNodeInformation node = GetLocalNodeInformations(reg, fqdn); node.NodeType = nodetype; return(new ADFSServerHost() { FQDN = fqdn, BehaviorLevel = node.BehaviorLevel, HeartbeatTmeStamp = node.HeartbeatTmeStamp, NodeType = node.NodeType, CurrentVersion = reg.CurrentVersion, CurrentBuild = reg.CurrentBuild, InstallationType = reg.InstallationType, ProductName = reg.ProductName, CurrentMajorVersionNumber = reg.CurrentMajorVersionNumber, CurrentMinorVersionNumber = reg.CurrentMinorVersionNumber }); } else { if (dispatch) { WebAdminClient manager = new WebAdminClient(); manager.Initialize(servername); try { IWebAdminServices client = manager.Open(); try { return(client.GetComputerInformations(servername, false)); } catch (CommunicationException nf) { _log.WriteEntry(nf.Message, EventLogEntryType.Error, 2010); return(null); } finally { manager.Close(client); } } catch (Exception e) { _log.WriteEntry(string.Format("Error on WebAdminService Service GetComputerInformations method : {0} / {1}.", servername, e.Message), EventLogEntryType.Error, 2010); throw e; } finally { manager.UnInitialize(); } } else { throw new Exception(); } } }
/// <summary> /// Deletes a given subkey /// </summary> /// <param name="registryKeyRoot">Enum of the root key to delete from (e.g. HKEY_LOCAL_MACHINE = LocalMachine)</param> /// <param name="subKey">Path of the subkey to be deleted</param> /// <param name="registryVersion">Version of the registry to delete from. Can be 32-Bit, 64-Bit, or both</param> /// <param name="forceSubKeyTreeDeletion">Can be used to force deletion of subkey tree. Defaults to false</param> public void DeleteSubKey(RegistryKeyRoot registryKeyRoot, string subKey, RegistryVersion registryVersion, [Optional] bool forceSubKeyTreeDeletion) { RegistryKey rk; RegistryHive rh; RegistryView rv; switch (registryVersion) { case RegistryVersion.Both: rh = DetermineRegistryHive(registryKeyRoot); rv = DetermineRegistryView(RegistryVersion.Only32Bit); rk = RegistryKey.OpenBaseKey(rh, rv); try { rk.DeleteSubKey(subKey); } catch (NullReferenceException e) { throw new NullReferenceException(NullRefMsg, e); } catch (InvalidOperationException e) { if (forceSubKeyTreeDeletion) { DeleteSubKeyTree(registryKeyRoot, subKey, registryVersion); } else { throw new InvalidOperationException(InvalidOpMsg, e); } } rk = DetermineRootKey(registryKeyRoot); try { rk.DeleteSubKey(subKey); } catch (NullReferenceException e) { throw new NullReferenceException(NullRefMsg, e); } catch (InvalidOperationException e) { if (forceSubKeyTreeDeletion) { DeleteSubKeyTree(registryKeyRoot, subKey, registryVersion); } else { throw new InvalidOperationException(InvalidOpMsg, e); } } break; case RegistryVersion.Only32Bit: rh = DetermineRegistryHive(registryKeyRoot); rv = DetermineRegistryView(RegistryVersion.Only32Bit); rk = RegistryKey.OpenBaseKey(rh, rv); try { rk.DeleteSubKey(subKey); } catch (NullReferenceException e) { throw new NullReferenceException(NullRefMsg, e); } catch (InvalidOperationException e) { if (forceSubKeyTreeDeletion) { DeleteSubKeyTree(registryKeyRoot, subKey, registryVersion); } else { throw new InvalidOperationException(InvalidOpMsg, e); } } break; default: rk = DetermineRootKey(registryKeyRoot); try { rk.DeleteSubKey(subKey); } catch (NullReferenceException e) { throw new NullReferenceException(NullRefMsg, e); } catch (InvalidOperationException e) { if (forceSubKeyTreeDeletion) { DeleteSubKeyTree(registryKeyRoot, subKey, registryVersion); } else { throw new InvalidOperationException(InvalidOpMsg, e); } } break; } rk.Flush(); }
/// <summary> /// Writes a subkey to a given key /// </summary> /// <param name="registryKeyRoot">Enum of the root key to read from (e.g. HKEY_LOCAL_MACHINE = LocalMachine)</param> /// <param name="subKey">Path of the subkey to be written to. Allows for nested subkeys to be written even if parts of the path /// do not already exist.</param> /// <param name="registryVersion">Version of the registry to write to. Can be 32-Bit, 64-Bit, or both</param> /// <param name="valuesToWrite">Values to be written to the given subkey</param> public void WriteSubKey(RegistryKeyRoot registryKeyRoot, string subKey, RegistryVersion registryVersion, [Optional] List <KeyValuePair <string, object> > valuesToWrite) { RegistryKey rk; RegistryHive rh; RegistryView rv; RegistryKey newSk; switch (registryVersion) { case RegistryVersion.Both: rh = DetermineRegistryHive(registryKeyRoot); rv = DetermineRegistryView(RegistryVersion.Only32Bit); rk = RegistryKey.OpenBaseKey(rh, rv); newSk = rk.CreateSubKey(subKey); if (valuesToWrite != null) { foreach (var item in valuesToWrite) { newSk.SetValue(item.Key, item.Value); } } rk = DetermineRootKey(registryKeyRoot); newSk = rk.CreateSubKey(subKey); if (valuesToWrite != null) { foreach (var item in valuesToWrite) { newSk.SetValue(item.Key, item.Value); } } break; case RegistryVersion.Only32Bit: rh = DetermineRegistryHive(registryKeyRoot); rv = DetermineRegistryView(RegistryVersion.Only32Bit); rk = RegistryKey.OpenBaseKey(rh, rv); newSk = rk.CreateSubKey(subKey); if (valuesToWrite != null) { foreach (var item in valuesToWrite) { newSk.SetValue(item.Key, item.Value); } } break; default: rk = DetermineRootKey(registryKeyRoot); newSk = rk.CreateSubKey(subKey); if (valuesToWrite != null) { foreach (var item in valuesToWrite) { newSk.SetValue(item.Key, item.Value); } } break; } rk.Flush(); }