public Integrity(int pid)
{
InitializeComponent();
procid = pid;
textBox2.Text = procid.ToString();
label3.Visible = false;
comboBox1.Items.Add("LOW");
comboBox1.Items.Add("MEDIUM");
comboBox1.Items.Add("HIGH");
comboBox1.Items.Add("SYSTEM");
comboBox3.Items.Add("ENABLE");
comboBox3.Items.Add("DISABLE");
System.Diagnostics.Process process = System.Diagnostics.Process.GetProcessById(pid);
PrivilegeAndAttributesCollection privileges = process.GetPrivileges();
if (privileges.Count == 0)
{
comboBox2.Items.Add("NO PRIVS");
}
else
{
int maxPrivilegeLebgth = privileges.Max(privilege => privilege.Privilege.ToString().Length);
foreach (PrivilegeAndAttributes PrivNAtrr in privileges)
{
Privilege privilege = PrivNAtrr.Privilege;
PrivilegeState privilegeState = PrivNAtrr.PrivilegeState;
string StrComboBox2 = privilege.ToString();
comboBox2.Items.Add(StrComboBox2);
}
}
}
private void button3_Click_2(object sender, EventArgs e)
{
int id = Convert.ToInt32(textBox2.Text);
//System.Diagnostics.Process proc = System.Diagnostics.Process.GetProcessById(id);
//string argument = Convert.ToString(id);
//var info = new System.Diagnostics.ProcessStartInfo(@"C:\Users\abuly_000\Documents\Visual Studio 2015\Projects\mbks2lab\x64\Debug\GetProcessPrivileges.exe", argument);
//System.Diagnostics.Process.Start(info);
//string text = System.IO.File.ReadAllText("C:\\Users\\abuly_000\\Documents\\Visual Studio 2015\\Projects\\mbks2lab\\Privileges.txt");
//MessageBox.Show(text);
System.Diagnostics.Process process = Process.GetProcessById(id);
PrivilegeAndAttributesCollection privileges = process.GetPrivileges();
if (privileges.Count == 0)
{
MessageBox.Show("NO PRIVILEGES");
}
else
{
int maxPrivilegeLength = privileges.Max(privilege => privilege.Privilege.ToString().Length);
string Out = null;
foreach (PrivilegeAndAttributes privilegeAndAttributes in privileges)
{
Privilege privilege = privilegeAndAttributes.Privilege;
PrivilegeState privilegeState = privilegeAndAttributes.PrivilegeState;
string PaddingString = GetPadding(privilege.ToString().Length, maxPrivilegeLength);
Out += privilege + " " + PaddingString + " => " + privilegeState + "\n";
}
MessageBox.Show(Out);
}
}
internal static PrivilegeAttributes GetPrivilegeAttributes(Privilege privilege, PrivilegeAndAttributesCollection privileges)
{
foreach (PrivilegeAndAttributes privilegeAndAttributes in privileges)
{
if (privilegeAndAttributes.Privilege == privilege)
{
return privilegeAndAttributes.PrivilegeAttributes;
}
}
GetLuid(privilege);
return PrivilegeAttributes.Removed;
}
protected void EnableFileSystemPrivileges(bool quite = true)
{
privileges = (new PrivilegeControl()).GetPrivileges();
if (!TryEnablePrivilege(Privilege.TakeOwnership))
{
WriteDebug("The privilige 'TakeOwnership' could not be enabled. Make sure your user account does have this privilige");
}
if (!TryEnablePrivilege(Privilege.Restore))
{
WriteDebug("The privilige 'Restore' could not be enabled. Make sure your user account does have this privilige");
}
if (!TryEnablePrivilege(Privilege.Backup))
{
WriteDebug("The privilige 'Backup' could not be enabled. Make sure your user account does have this privilige");
}
if (!TryEnablePrivilege(Privilege.Security))
{
WriteDebug("The privilige 'Security' could not be enabled. Make sure your user account does have this privilige");
}
if (!quite)
{
if (privControl.GetPrivileges()
.Where(p => p.PrivilegeState == PrivilegeState.Enabled)
.Where(p =>
(p.Privilege == Privilege.TakeOwnership) |
(p.Privilege == Privilege.Restore) |
(p.Privilege == Privilege.Backup) |
(p.Privilege == Privilege.Security)).Count() == 4)
{
WriteVerbose("The privileges 'Backup', 'Restore', 'TakeOwnership' and 'Security' are now enabled giving you access to all files and folders. Use Disable-Privileges to disable them and Get-Privileges for an overview.");
}
else
{
WriteError(new ErrorRecord(new AdjustPriviledgeException("Could not enable requested privileges. Cmdlets of NTFSSecurity will only work on resources you have access to."), "Enable Privilege Error", ErrorCategory.SecurityError, null));
return;
}
}
}
protected void EnablePrivilege(Privilege privilege)
{
//throw an exception if the specified prililege is not held by the client
if (!privileges.Any(p => p.Privilege == privilege))
{
throw new System.Security.AccessControl.PrivilegeNotHeldException(privilege.ToString());
}
//if the privilege is disabled
if (privileges.Single(p => p.Privilege == privilege).PrivilegeState == PrivilegeState.Disabled)
{
WriteDebug(string.Format("The privilege {0} is disabled...", privilege));
//activate it
privControl.EnablePrivilege(privilege);
WriteDebug(string.Format("..enabled"));
//remember the privilege so that we can automatically disable it after the cmdlet finished processing
enabledPrivileges.Add(privilege.ToString());
privileges = privControl.GetPrivileges();
}
}
private static string GetPrivil(Process process)
{
string allPriv = "";
//Process p;
//p = Process.GetProcessById(Int32.Parse(process.Id));
PrivilegeAndAttributesCollection privileges = process.GetPrivileges();
int maxPrivilegeLength = privileges.Max(privilege => privilege.Privilege.ToString().Length);
foreach (PrivilegeAndAttributes privilegeAndAttributes in privileges)
{
Privilege privilege = privilegeAndAttributes.Privilege;
PrivilegeState privilegeState = privilegeAndAttributes.PrivilegeState;
if (privilegeState.ToString() == "Enabled")
{
allPriv += privilege + "; ";
}
}
return(allPriv);
}
private void Table_CellClick(object sender, DataGridViewCellEventArgs e)
{
int PID = 0;
try
{
#region Получение DLL и вывод в TextBox
PID = Int32.Parse(Table.CurrentCell.Value.ToString());
DLLBox.Clear();
Process proc = Process.GetProcessById(PID);
DLLBox.Text += "Процесс: " + proc.ProcessName + Environment.NewLine;
foreach (ProcessModule module in proc.Modules)
{
DLLBox.Text += module.FileName + Environment.NewLine;
}
#endregion
#region Получение привелегий процесса
Priveleges_dataGridView.Rows.Clear();
PrivilegeAndAttributesCollection privileges = proc.GetPrivileges();
//int maxPrivilegeLength = privileges.Max(privilege => privilege.Privilege.ToString().Length);
foreach (PrivilegeAndAttributes privilegeAndAttributes in privileges)
{
Privilege privilege = privilegeAndAttributes.Privilege;
PrivilegeState privilegeState = privilegeAndAttributes.PrivilegeState;
Priveleges_dataGridView.Rows.Add(privilege /*+ GetPadding(privilege.ToString().Length, maxPrivilegeLength)*/, privilegeState);
}
#endregion
}
catch (Win32Exception) { }
catch (ArgumentException) { }
catch (FormatException) { }
catch (InvalidOperationException) { }
}
/// <summary>
/// Ativar() - Cria instancia do servico, para uso local ou como WCF
/// </summary>
public void Ativar()
{
bool bSingleton = false;
try
{
if (bAtivado)
{
logger.Info("Servico já ativado por outra interface, ignorando");
return;
}
// Cria o tipo da interface
Assembly[] assemblies = System.AppDomain.CurrentDomain.GetAssemblies();
foreach (string nomeInterface in this.ServicoInfo.NomeInterface)
{
logger.Debug("Servico.Ativar(): procurando interface nos assemblies:" + nomeInterface);
foreach (Assembly assembly in assemblies)
{
Type Interface = assembly.GetType(nomeInterface);
if (Interface != null)
{
_interfaces.Add(Interface);
}
}
}
// Melhorar....
if (_interfaces.Count == 0 || _interfaces.Count < this.ServicoInfo.NomeInterface.Count)
{
foreach (string nomeInterface in this.ServicoInfo.NomeInterface)
{
logger.Info("Interface " + nomeInterface + " nao encontrada direto, usando Type.GetType()");
Type Interface = Type.GetType(nomeInterface);
if (Interface != null)
{
_interfaces.Add(Interface);
}
else
{
logger.Error("Interface " + nomeInterface + " nao encontrada em nenhum dos assemblies.");
return;
}
}
}
if (this.ServicoInfo.NomeInstancia == null || this.ServicoInfo.NomeInstancia.Length == 0)
{
throw new Exception("Erro em Ativar(): Nome da instancia nao pode ser nula! Verifique a tag <NomeInstancia>");
}
// ATP: verificar esse ponto: se nao achou a interface, nao deve continuar aqui.
// Tem instancia criada?
if (this.Instancia == null)
{
this.TipoInstancia = Type.GetType(this.ServicoInfo.NomeInstancia);
if (this.TipoInstancia != null)
{
this.Instancia = Activator.CreateInstance(this.TipoInstancia);
}
else
{
string msg = "Ativar(): ClassType da instancia nao encontrado para " + this.ServicoInfo.NomeInstancia;
msg += "\nVerifique Assemblies/Namespace da classe: " + this.ServicoInfo.NomeInstancia;
throw new Exception(msg);
}
}
// Registra o canal de comunicação se necessário (casos de wcf)
if (this.ServicoInfo.AtivarWCF && this.Instancia != null)
{
logger.Info("Ativando " + this.ServicoInfo.NomeInstancia + " como WCF");
ServiceBehaviorAttribute [] srvbehavior = this.Instancia.GetType().GetCustomAttributes(typeof(ServiceBehaviorAttribute), true) as ServiceBehaviorAttribute[];
if (srvbehavior != null && srvbehavior.Length > 0)
{
foreach (ServiceBehaviorAttribute attribute in srvbehavior)
{
logger.Info("InstanceContextMode : " + attribute.InstanceContextMode.ToString());
if (attribute.InstanceContextMode == InstanceContextMode.Single)
{
bSingleton = true;
logger.Info("ConcurrencyMode: " + attribute.ConcurrencyMode.ToString());
//if (attribute.ConcurrencyMode == ConcurrencyMode.Single)
//{
// attribute.ConcurrencyMode = ConcurrencyMode.Multiple;
// logger.Info("Novo ConcurrencyMode: " + attribute.ConcurrencyMode.ToString());
//}
}
else
{
logger.Warn("********************************************************");
logger.Warn("InstanceContextMode para a classe " + this.ServicoInfo.NomeInstancia);
logger.Warn("Esta definida como: " + attribute.InstanceContextMode.ToString());
logger.Warn("NÃO É UM SINGLETON!!! VERIFIQUE SE SUA CLASSE FOI PENSADA");
logger.Warn("PARA TER MAIS DE UMA INSTANCIA ATIVA");
logger.Warn("********************************************************");
}
}
}
// Faz a ativação WCF
if (bSingleton)
{
this.Host = new ServiceHost(this.Instancia);
}
else
{
this.Host = new ServiceHost(this.Instancia.GetType());
}
this.Host.OpenTimeout = new TimeSpan(0, 2, 0);
this.Host.Faulted += new EventHandler(_hostFaulted);
logger.Info("Adicionando MetaData Behavior para " + this.ServicoInfo.NomeInstancia);
//ATP: Adicionando informacoes do MEX
ServiceMetadataBehavior metadataBehavior;
metadataBehavior = this.Host.Description.Behaviors.Find <ServiceMetadataBehavior>();
if (metadataBehavior == null)
{
logger.Info("Criando MetaData Behavior para " + this.ServicoInfo.NomeInstancia);
metadataBehavior = new ServiceMetadataBehavior();
string mexendpointaddr = this.MexBaseAddress + "/" + this.Instancia.ToString();
metadataBehavior.HttpGetUrl = new Uri(mexendpointaddr);
metadataBehavior.HttpGetEnabled = true;
this.Host.Description.Behaviors.Add(metadataBehavior);
}
// Se configurado, acrescenta as configurações de throttling
if (this.ServicoInfo.MaxConcurrentCalls > 0 &&
this.ServicoInfo.MaxConcurrentInstances > 0 &&
this.ServicoInfo.MaxConcurrentSessions > 0)
{
logger.Info("Adicionando ServiceThrottleBehavior para " + this.ServicoInfo.NomeInstancia);
ServiceThrottlingBehavior throttleBehavior = new ServiceThrottlingBehavior();
throttleBehavior.MaxConcurrentCalls = this.ServicoInfo.MaxConcurrentCalls.Value;
throttleBehavior.MaxConcurrentInstances = this.ServicoInfo.MaxConcurrentInstances.Value;
throttleBehavior.MaxConcurrentSessions = this.ServicoInfo.MaxConcurrentSessions.Value;
logger.Info("MaxConcurrentCalls ......: " + throttleBehavior.MaxConcurrentCalls);
logger.Info("MaxConcurrentInstances ..: " + throttleBehavior.MaxConcurrentInstances);
logger.Info("MaxConcurrentSessions ...: " + throttleBehavior.MaxConcurrentSessions);
this.Host.Description.Behaviors.Add(throttleBehavior);
}
logger.Info("Adicionando ErrorServiceBehavior para " + this.ServicoInfo.NomeInstancia);
this.Host.Description.Behaviors.Add(new ErrorServiceBehavior());
logger.Info("Configurando ServiceDebugBehavior para " + this.ServicoInfo.NomeInstancia);
ServiceDebugBehavior debugBehavior = this.Host.Description.Behaviors.Find <ServiceDebugBehavior>();
if (debugBehavior != null)
{
debugBehavior.IncludeExceptionDetailInFaults = true;
}
else
{
debugBehavior = new ServiceDebugBehavior();
debugBehavior.IncludeExceptionDetailInFaults = true;
this.Host.Description.Behaviors.Add(debugBehavior);
}
// Cria endpoint se nao tiver algum definido no app.config
logger.Info("Adicionando endpoints para " + this.ServicoInfo.NomeInstancia);
if (this.Host.Description.Endpoints.Count == 0)
{
logger.Info("Nenhum endpoint declarado para o servico : " + this.ServicoInfo.NomeInstancia);
foreach (string baseAddress in this.BaseAddress)
{
Binding tcpBinding = null;
#if PRIVILEDGED_NAMED_PIPE
// NAO REMOVER O CODIGO ABAIXO
// PODERA SER USADO PARA ESCALAR A CAPACIDADE DO AMBIENTE
if (!baseAddress.StartsWith("net.pipe"))
{
tcpBinding = Utilities.GetBinding(baseAddress);
}
else
{
Process myproc = Process.GetCurrentProcess();
// Get the privileges and associated attributes.
PrivilegeAndAttributesCollection privileges = myproc.GetPrivileges();
//int maxPrivilegeLength = privileges..Max(privilege => privilege.Privilege.ToString().Length);
foreach (PrivilegeAndAttributes privilegeAndAttributes in privileges)
{
// The privilege.
Privilege privilege = privilegeAndAttributes.Privilege;
// The privilege state.
PrivilegeState privilegeState = privilegeAndAttributes.PrivilegeState;
// Write out the privilege and its state.
logger.DebugFormat(
"{0}{1} => {2}",
privilege,
privilege.ToString(),
privilegeState);
}
// Enable the TakeOwnership privilege on it.
AdjustPrivilegeResult result = myproc.EnablePrivilege(Privilege.CreateGlobal);
tcpBinding = new AclSecuredNamedPipeBinding();
try
{
SecurityIdentifier allow = (SecurityIdentifier)(new NTAccount("Everyone").Translate(typeof(SecurityIdentifier)));
((AclSecuredNamedPipeBinding)tcpBinding).AddUserOrGroup(allow);
}
catch (Exception ex)
{
logger.Error(ex);
}
try
{
SecurityIdentifier allow = (SecurityIdentifier)(new NTAccount("Todos").Translate(typeof(SecurityIdentifier)));
((AclSecuredNamedPipeBinding)tcpBinding).AddUserOrGroup(allow);
}
catch (Exception ex)
{
logger.Error(ex);
}
logger.Debug("Apos setar privilegios");
// Get the privileges and associated attributes.
privileges = myproc.GetPrivileges();
foreach (PrivilegeAndAttributes privilegeAndAttributes in privileges)
{
// The privilege.
Privilege privilege = privilegeAndAttributes.Privilege;
// The privilege state.
PrivilegeState privilegeState = privilegeAndAttributes.PrivilegeState;
// Write out the privilege and its state.
logger.DebugFormat(
"{0}{1} => {2}",
privilege,
privilege.ToString(),
privilegeState);
}
}
#else
tcpBinding = Utilities.GetBinding(baseAddress);
#endif
foreach (Type iface in this._interfaces)
{
string endpointaddr = baseAddress + "/" + iface.ToString();
logger.Info("Criando endpoint: Interface=[" + iface.ToString() + "] Instancia=[" + this.Instancia.ToString() + "] Address=[" + endpointaddr + "]");
this.Host.AddServiceEndpoint(iface, tcpBinding, endpointaddr);
}
}
}
// Adiciona o enpoint MEX para o fim da lista
logger.Info("Criando endpoint MEX para " + this.ServicoInfo.NomeInstancia);
this.Host.AddServiceEndpoint(typeof(IMetadataExchange), new BasicHttpBinding(), this.MexBaseAddress + "/" + this.Instancia.ToString());
// Popula as informacoes dos endpoints para o servico Localizador
// Ver Ativador.Get<>()
if (this.Host.Description.Endpoints.Count > 0)
{
// Para cada endpoint do wcf, cria na colecao do ServicoInfo para publicar no localizador
foreach (System.ServiceModel.Description.ServiceEndpoint endPoint in this.Host.Description.Endpoints)
{
logger.Info("Verificando validade do endpoint [" + endPoint.Address.Uri.ToString() + "] tipo: [" + endPoint.Binding.GetType().FullName + "] para localizador");
if (endPoint.Address.Uri.ToString().Contains("/MEX") == false)
{
logger.Info("Adicionando informacoes do endpoint [" + endPoint.Address.Uri.ToString() + "] tipo: [" + endPoint.Binding.GetType().FullName + "] para localizador");
this.ServicoInfo.EndPoints.Add(
new ServicoEndPointInfo()
{
Endereco = endPoint.Address.Uri.ToString(),
//NomeBindingType = endPoint.Binding.GetType().FullName
NomeBindingType = Utilities.GetBindingType(endPoint.Address.Uri.ToString())
});
}
ContractDescription cd = endPoint.Contract;
foreach (OperationDescription od in cd.Operations)
{
DataContractSerializerOperationBehavior serializerBh = od.Behaviors.Find <DataContractSerializerOperationBehavior>();
if (serializerBh == null)
{
logger.Info("Adicionando DataContractSerializerOperationBehavior");
serializerBh = new DataContractSerializerOperationBehavior(od);
od.Behaviors.Add(serializerBh);
}
logger.Info("Setando MaxItemsInObjectGraph para operacao: " + od.Name);
serializerBh.MaxItemsInObjectGraph = 8000000;
}
}
}
logger.Info("Servico: " + this.ServicoInfo.NomeInstancia + " opening host...");
// Inicia o ServiceHost
this.Host.Open();
}
// Marca servico como ativo.
bAtivado = true;
// Registra no localizador se necessário
if (this.ServicoInfo.RegistrarLocalizador)
{
logger.Info("Registrando servico no Localizador");
LocalizadorCliente.Registrar(this.ServicoInfo);
}
logger.Info("***");
logger.Info(" ");
}
catch (Exception ex)
{
logger.Error("Erro em Servico.Ativar(): ", ex);
throw ex;
}
}
private void button3_Click(object sender, EventArgs e)
{
int number = 0;
var processList = Process.GetProcesses();
foreach (var proc in processList)
{
try
{
ListViewItem lvi = new ListViewItem(String.Format("{0}.exe", proc.ProcessName));
lvi.SubItems.Add(String.Format("{0}", proc.Id));
string a, b;
lvi.SubItems.Add(String.Format("{0}", GetProcessInfoByPID(proc.Id, out a, out b) + " " + a));
try
{
string s = parrent(proc.Id);
number = Convert.ToInt32(s, 10);
try
{
lvi.SubItems.Add(String.Format(Process.GetProcessById(number).ProcessName + ".exe " + "(" + number + ")"));
}
catch { lvi.SubItems.Add(String.Format("{0}", " ")); };
}
catch (Win32Exception)
{
lvi.SubItems.Add(String.Format("{0}", " "));
}
MyGlobal = proc.Id;
if (InternalCheckIsWow64())
{
lvi.SubItems.Add(String.Format("{0}", "x32"));
}
else if (MyGlobal < 0)
{
lvi.SubItems.Add(String.Format("{0}", " "));
}
else
{
lvi.SubItems.Add(String.Format("{0}", "x64"));
}
try
{
string sdll = "";
ProcessModule dll;
ProcessModuleCollection myProcessModuleCollection = proc.Modules;
for (int i = 1; i < myProcessModuleCollection.Count; i++)
{
dll = myProcessModuleCollection[i];
sdll = sdll + " " + String.Format("{0}", dll.ModuleName);
// lvi.SubItems.Add(String.Format("{0}", dll.ModuleName));
}
lvi.SubItems.Add(sdll);
}
catch (Win32Exception) {
lvi.SubItems.Add(String.Format("{0}", " "));
}
try
{
// Get and display the process integrity level.
int IL = GetProcessIntegrityLevel(proc.Id);
switch (IL)
{
case NativeMethod.SECURITY_MANDATORY_UNTRUSTED_RID:
lvi.SubItems.Add(String.Format("{0}", "Untrusted")); break;
case NativeMethod.SECURITY_MANDATORY_LOW_RID:
lvi.SubItems.Add(String.Format("{0}", "Low")); break;
case NativeMethod.SECURITY_MANDATORY_MEDIUM_RID:
lvi.SubItems.Add(String.Format("{0}", "Medium")); break;
case NativeMethod.SECURITY_MANDATORY_HIGH_RID:
lvi.SubItems.Add(String.Format("{0}", "High")); break;
case NativeMethod.SECURITY_MANDATORY_SYSTEM_RID:
lvi.SubItems.Add(String.Format("{0}", "System")); break;
default:
lvi.SubItems.Add(String.Format("{0}", "Unknown")); break;
}
}
catch (Exception)
{
lvi.SubItems.Add(String.Format("{0}", "System"));
}
PrivilegeAndAttributesCollection privileges = proc.GetPrivileges();
lvi.SubItems.Add(String.Format("{0}", privileges));
listView1.Items.Add(lvi);
}
catch { };
}
}
private void button4_Click_1(object sender, EventArgs e)
{
int id = Convert.ToInt32(textBox2.Text);
string StrPrivilege = comboBox2.SelectedItem.ToString();
string StrState = comboBox3.SelectedItem.ToString();
System.Diagnostics.Process process = System.Diagnostics.Process.GetProcessById(id);
PrivilegeAndAttributesCollection privileges = process.GetPrivileges();
if (privileges.Count == 0)
{
MessageBox.Show("NO PRIVILEGES");
return;
}
int maxPrivilegeLength = privileges.Max(privilege => privilege.ToString().Length);
foreach (PrivilegeAndAttributes privilegeNattributes in privileges)
{
if (StrPrivilege == Privilege.AssignPrimaryToken.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.AssignPrimaryToken) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.AssignPrimaryToken);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.AssignPrimaryToken) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.AssignPrimaryToken);
}
}
}
else if (StrPrivilege == Privilege.Audit.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.Audit) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.Audit);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.Audit) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.Audit);
}
}
}
else if (StrPrivilege == Privilege.Backup.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.Backup) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.Backup);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.Backup) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.Backup);
}
}
}
else if (StrPrivilege == Privilege.ChangeNotify.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.ChangeNotify) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.ChangeNotify);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.ChangeNotify) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.ChangeNotify);
}
}
}
else if (StrPrivilege == Privilege.CreateGlobal.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.CreateGlobal) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.CreateGlobal);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.CreateGlobal) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.CreateGlobal);
}
}
}
else if (StrPrivilege == Privilege.CreatePageFile.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.CreatePageFile) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.CreatePageFile);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.CreatePageFile) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.CreatePageFile);
}
}
}
else if (StrPrivilege == Privilege.CreatePermanent.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.CreatePermanent) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.CreatePermanent);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.CreatePermanent) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.CreatePermanent);
}
}
}
else if (StrPrivilege == Privilege.CreateSymbolicLink.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.CreateSymbolicLink) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.CreateSymbolicLink);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.CreateSymbolicLink) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.CreateSymbolicLink);
}
}
}
else if (StrPrivilege == Privilege.CreateToken.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.CreateToken) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.CreateToken);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.CreateToken) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.CreateToken);
}
}
}
else if (StrPrivilege == Privilege.Debug.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.Debug) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.Debug);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.Debug) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.Debug);
}
}
}
else if (StrPrivilege == Privilege.EnableDelegation.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.EnableDelegation) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.EnableDelegation);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.EnableDelegation) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.EnableDelegation);
}
}
}
else if (StrPrivilege == Privilege.Impersonate.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.Impersonate) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.Impersonate);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.Impersonate) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.Impersonate);
}
}
}
else if (StrPrivilege == Privilege.IncreaseBasePriority.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.IncreaseBasePriority) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.IncreaseBasePriority);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.IncreaseBasePriority) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.IncreaseBasePriority);
}
}
}
else if (StrPrivilege == Privilege.IncreaseQuota.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.IncreaseQuota) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.IncreaseQuota);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.IncreaseQuota) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.IncreaseQuota);
}
}
}
else if (StrPrivilege == Privilege.IncreaseWorkingSet.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.IncreaseWorkingSet) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.IncreaseWorkingSet);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.IncreaseWorkingSet) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.IncreaseWorkingSet);
}
}
}
else if (StrPrivilege == Privilege.LoadDriver.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.LoadDriver) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.LoadDriver);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.LoadDriver) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.LoadDriver);
}
}
}
else if (StrPrivilege == Privilege.LockMemory.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.LockMemory) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.LockMemory);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.LockMemory) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.LockMemory);
}
}
}
else if (StrPrivilege == Privilege.MachineAccount.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.MachineAccount) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.MachineAccount);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.MachineAccount) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.MachineAccount);
}
}
}
else if (StrPrivilege == Privilege.ManageVolume.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.ManageVolume) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.ManageVolume);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.ManageVolume) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.ManageVolume);
}
}
}
else if (StrPrivilege == Privilege.ProfileSingleProcess.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.ProfileSingleProcess) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.ProfileSingleProcess);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.ProfileSingleProcess) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.ProfileSingleProcess);
}
}
}
else if (StrPrivilege == Privilege.Relabel.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.Relabel) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.Relabel);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.Relabel) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.Relabel);
}
}
}
else if (StrPrivilege == Privilege.RemoteShutdown.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.RemoteShutdown) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.RemoteShutdown);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.RemoteShutdown) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.RemoteShutdown);
}
}
}
else if (StrPrivilege == Privilege.Restore.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.Restore) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.Restore);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.Restore) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.Restore);
}
}
}
else if (StrPrivilege == Privilege.Security.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.Security) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.Security);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.Security) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.Security);
}
}
}
else if (StrPrivilege == Privilege.Shutdown.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.Shutdown) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.Shutdown);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.Shutdown) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.Shutdown);
}
}
}
else if (StrPrivilege == Privilege.SyncAgent.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.SyncAgent) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.SyncAgent);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.SyncAgent) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.SyncAgent);
}
}
}
else if (StrPrivilege == Privilege.SystemEnvironment.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.SystemEnvironment) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.SystemEnvironment);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.SystemEnvironment) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.SystemEnvironment);
}
}
}
else if (StrPrivilege == Privilege.SystemProfile.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.SystemProfile) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.SystemProfile);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.SystemProfile) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.SystemProfile);
}
}
}
else if (StrPrivilege == Privilege.SystemTime.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.SystemTime) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.SystemTime);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.SystemTime) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.SystemTime);
}
}
}
else if (StrPrivilege == Privilege.TakeOwnership.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.TakeOwnership) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.TakeOwnership);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.TakeOwnership) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.TakeOwnership);
}
}
}
else if (StrPrivilege == Privilege.TimeZone.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.TimeZone) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.TimeZone);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.TimeZone) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.TimeZone);
}
}
}
else if (StrPrivilege == Privilege.TrustedComputerBase.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.TrustedComputerBase) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.TrustedComputerBase);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.TrustedComputerBase) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.TrustedComputerBase);
}
}
}
else if (StrPrivilege == Privilege.TrustedCredentialManagerAccess.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.TrustedCredentialManagerAccess) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.TrustedCredentialManagerAccess);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.TrustedCredentialManagerAccess) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.TrustedCredentialManagerAccess);
}
}
}
else if (StrPrivilege == Privilege.Undock.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.Undock) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.Undock);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.Undock) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.Undock);
}
}
}
else if (StrPrivilege == Privilege.UnsolicitedInput.ToString())
{
if (StrState == "ENABLE")
{
if (process.GetPrivilegeState(Privilege.UnsolicitedInput) == PrivilegeState.Disabled)
{
AdjustPrivilegeResult result = process.EnablePrivilege(Privilege.UnsolicitedInput);
}
}
else if (StrState == "DISABLE")
{
if (process.GetPrivilegeState(Privilege.UnsolicitedInput) == PrivilegeState.Enabled)
{
AdjustPrivilegeResult result = process.DisablePrivilege(Privilege.UnsolicitedInput);
}
}
}
}
}
