Como elevar privilégios apenas quando necessário?

Esta questão se aplica ao Windows Vista!

Tenho um aplicativo que normalmente funciona sem privilégios administrativos. Há uma atividade que precisa de privilégio administrativo, mas não quero iniciar o próprio aplicativo com privilégios mais altos, pois sei que na maioria das vezes o usuário nem mesmo usará esse recurso.

Estou pensando em certo método pelo qual posso elevar os privilégios de aplicação em algum evento (como pressionar um botão). Exemplo:

Se o usuário clicar neste botão, ele será solicitado com uma caixa de diálogo ou consentimento do UAC. Como posso fazer isso?

Não acredito que seja possível elevar o processo atualmente em execução. É integrado ao Windows Vista que privilégios de administrador são dados a um processo na inicialização, pelo que entendi. Se você olhar para vários programas que utilizam UAC, você verá que eles realmente iniciam um processo separado cada vez que uma ação administrativa precisa ser executada (Gerenciador de Tarefas é um, Paint.NET é outro, o último sendo um aplicativo .NET na verdade )

A solução típica para este problema é especificar argumentos de linha de comando ao iniciar um processo elevado (a sugestão de abatishchev é uma maneira de fazer isso), de modo que o processo iniciado saiba apenas para exibir uma determinada caixa de diálogo e, em seguida, saia após esta ação ter sido concluído. Assim, dificilmente deve ser notado para o usuário que um novo processo foi iniciado e, em seguida, encerrado, e prefere aparecer como se uma nova caixa de diálogo dentro do mesmo aplicativo tivesse sido aberta (especialmente se você algum hackery para tornar a janela principal do processo elevado, filho do processo pai). Se você não precisa da IU para o acesso elevado, melhor ainda.

Para uma discussão completa do UAC no Vista, recomendo que você leia este artigo completo sobre o assunto (os exemplos de código estão em C ++, mas eu suspeito que você precisará usar o WinAPI e P / Invoke para fazer a maioria das coisas em C # de qualquer forma). Esperamos que você agora pelo menos veja a abordagem certa a ser tomada, embora projetar um programa compatível com o UAC esteja longe de ser trivial ...

Como foi dito lá :

Process.StartInfo.UseShellExecute = true;
Process.StartInfo.Verb = "runas";

executará o processo como administrador para fazer o que for necessário com o registro, mas retornará ao seu aplicativo com os privilégios normais.

O seguinte artigo do MSDN KB 981778 descreve como 'auto-elevar' um aplicativo:

http://support.microsoft.com/kb/981778

Ele contém exemplos para download em Visual C ++, Visual C #, Visual Basic.NET.

Essa abordagem contorna a necessidade de iniciar um processo separado, mas na verdade é o aplicativo original que é reiniciado, executando como um usuário elevado. No entanto, isso ainda pode ser muito útil em alguns contextos onde não é prático duplicar o código em um executável separado.

Para remover a elevação, você precisa sair do aplicativo.

Você precisa de um moniker UAC e do código para executar elevado como um objeto COM.

Veja esta pergunta.

Documentação no MSDN.

Talvez alguém seja útil com este exemplo simples:

using System;
using System.Linq;
using System.Reflection;
using System.Diagnostics;
using System.Security.Principal;
using System.Windows.Forms;

namespace WindowsFormsApp1
{
    internal static class Program
    {
        private class Form1 : Form
        {
            internal Form1()
            {
                var button = new Button{ Dock = DockStyle.Fill };
                button.Click += (sender, args) => RunAsAdmin();
                Controls.Add(button);

                ElevatedAction();
            }
        }

        [STAThread]
        internal static void Main(string[] arguments)
        {
            if (arguments?.Contains("/run_elevated_action") == true)
            {
                ElevatedAction();
                return;
            }

            Application.Run(new Form1());
        }

        private static void RunAsAdmin()
        {
            var path = Assembly.GetExecutingAssembly().Location;
            using (var process = Process.Start(new ProcessStartInfo(path, "/run_elevated_action")
            {
                Verb = "runas"
            }))
            {
                process?.WaitForExit();
            }
        }

        private static void ElevatedAction()
        {
            MessageBox.Show($@"IsElevated: {IsElevated()}");
        }

        private static bool IsElevated()
        {
            using (var identity = WindowsIdentity.GetCurrent())
            {
                var principal = new WindowsPrincipal(identity);

                return principal.IsInRole(WindowsBuiltInRole.Administrator);
            }
        }

    }
}

Eu sei que este é um post antigo, mas isso é uma resposta a qualquer pessoa que venha com a sugestão de MarcP. A postagem do msdn que ele referenciou realmente reinicia os aplicativos em todos os exemplos de código. Os exemplos de código usam o runasverbo proposto já em outras sugestões.

Baixei o código para ter certeza, mas este é do artigo msdn original:

4. Clique em Sim para aprovar a elevação. Em seguida, o aplicativo original é reiniciado, executando como um administrador elevado.
5. Feche o aplicativo.