How to lock an executable file and prevent it from opening on Windows?

Question

I would like to create a particular program where I can block programs from running on Windows, I know that Windows itself provides something basic about this, but I wanted to create my program, someone give me a code tip that blocks any executable file on Windows.

Answer 1

Need to put in Windows registry using class RegistryKey:

using (RegistryKey chave = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer", true)) {
    chave.SetValue("DisallowRun", 1);
}
using (RegistryKey chave = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\DisallowRun", true)) {
    chave.SetValue("1", "executável que quer aqui");
}

I put in the Github for future reference.

I found the key on this page.

Documentation.

I don’t know if it has any implication but it is possible to change the CurrentUser for LocalMachine. I don’t guarantee it will work properly or it will have to touch something, but it is an attempt to do globally.

It would also be possible to make a representation (WindowsIdentity), or you can even upload a user’s profile (LoadUserProfile) but has no methods ready to use with C#, would have to make a Binding for the API.

Obviously everything requires you to have administrator privileges. There is no miracle.

Answer 2

First you must learn the basics of c# and probably of Visualstudio, there is no way to skip steps, this will only make the path harder. After learning about:

• Variables
• Function
• Classes
• Object orientation
• About methods practices in csharp classes
• Build a Helloworld with Console and one with Windows Form

So by doing this you can start studying native (and non-native libraries).

After having studied the basics, an example of killing an application that is what you want, to block is required the kill, will require an "infinite loop":

new Thread(() =>
{
    while (true)
    {
        Thread.Sleep(100);

        Process[] ps = Process.GetProcessesByName("NOME DO PROCESSO QUE DESEJA BLOQUEAR");

        foreach (Process pr in ps)
        {
            pr.Kill();
            pr.Close();
        }
    }
}).Start();

Note: Change the "NOME DO PROCESSO QUE DESEJA BLOQUEAR" by the name of the process you want to block.

With the Process.GetProcessesByName you can take the process by name, then with the foreach you can list all open instances and "kill them", probably it should stay within an infinite loop in another Thread.

Being a console I think it will not be necessary to Thread, unless you want to put Input commands, but just happen to block (I could not test):

using System;

public class BloquearProcessos
{
    public static void Main()
    {
        while (true)
        {
            Thread.Sleep(100);

            Process[] ps = Process.GetProcessesByName("NOME DO PROCESSO QUE DESEJA BLOQUEAR");

            foreach (Process pr in ps)
            {
                pr.Kill();
                pr.Close();
            }
        }
    }
}

Chance to be a Form visual studio itself already creates a basic structure, but if you don’t know where to apply the code follows an example:

using System;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Thread eventThread = new Thread(() =>
            {
                while (true)
                {
                    Thread.Sleep(100);

                    Process[] ps = Process.GetProcessesByName("NOME DO PROCESSO QUE DESEJA BLOQUEAR");

                    foreach (Process pr in ps)
                    {
                        pr.Kill();
                        pr.Close();
                    }
                }
            });

            eventThread.IsBackground = true;
            eventThread.Start();
        }
    }
}