Come elevare i privilegi solo quando richiesto?

Questa domanda si applica a Windows Vista!

Ho un'applicazione che normalmente funziona senza privilegi amministrativi. C'è un'attività che richiede privilegi amministrativi, ma non voglio avviare l'applicazione stessa con privilegi più elevati quando so che la maggior parte delle volte l'utente non utilizzerà nemmeno quella funzione.

Sto pensando a un certo metodo con cui posso elevare i privilegi di applicazione su alcuni eventi (come la pressione di un pulsante). Esempio:

Se l'utente fa clic su questo pulsante, viene richiesto con la finestra di dialogo UAC o il consenso. Come posso fare questo?

Non credo che sia possibile elevare il processo attualmente in esecuzione. È integrato in Windows Vista che i privilegi di amministratore vengono assegnati a un processo all'avvio, a quanto ho capito. Se guardi vari programmi che utilizzano l'UAC, dovresti vedere che in realtà avviano un processo separato ogni volta che deve essere eseguita un'azione amministrativa (Task Manager è uno, Paint.NET è un altro, quest'ultimo è infatti un'applicazione .NET ).

La soluzione tipica a questo problema è specificare gli argomenti della riga di comando quando si avvia un processo con privilegi elevati (il suggerimento di abatishchev è un modo per farlo), in modo che il processo avviato sappia solo di visualizzare una certa finestra di dialogo e quindi uscire dopo che questa azione è stata eseguita completato. Quindi non dovrebbe quasi essere notato all'utente che un nuovo processo è stato avviato e poi chiuso, e sembrerebbe piuttosto come se fosse stata aperta una nuova finestra di dialogo all'interno della stessa app (specialmente se hai qualche hacker per rendere la finestra principale del processo elevato un figlio del processo genitore). Se non hai bisogno dell'interfaccia utente per l'accesso elevato, ancora meglio.

Per una discussione completa sull'UAC su Vista, ti consiglio di leggere questo articolo molto approfondito sull'argomento (gli esempi di codice sono in C ++, ma sospetto che dovrai usare WinAPI e P / Invoke per fare la maggior parte delle cose in C # Comunque). Spero che ora tu veda almeno l'approccio giusto da adottare, anche se la progettazione di un programma conforme all'UAC è tutt'altro che banale ...

Come è stato detto lì :

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

eseguirà il processo come amministratore per fare tutto ciò di cui hai bisogno con il registro, ma tornerà alla tua app con i normali privilegi.

Il seguente articolo della Knowledge Base di MSDN 981778 descrive come "elevare automaticamente" un'applicazione:

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

Contiene esempi scaricabili in Visual C ++, Visual C #, Visual Basic.NET.

Questo approccio aggira la necessità di avviare un processo separato, ma in realtà è l'applicazione originale che viene riavviata, in esecuzione come utente con privilegi elevati. Tuttavia questo può essere ancora molto utile in alcuni contesti in cui non è pratico duplicare il codice in un eseguibile separato.

Per rimuovere l'elevazione, è necessario chiudere l'applicazione.

È necessario un moniker UAC e il codice per eseguire con privilegi elevati come oggetto COM.

Vedi questa domanda.

Documentazione su MSDN.

Forse qualcuno torna utile questo semplice esempio:

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);
            }
        }

    }
}

So che questo è un vecchio post, ma è in risposta a chiunque altro incontri il suggerimento di MarcP. Il post msdn a cui fa riferimento effettivamente riavvia le applicazioni in tutti gli esempi di codice. Gli esempi di codice utilizzano il runasverbo proposto già in altri suggerimenti.

Ho scaricato il codice per esserne sicuro, ma questo è tratto dall'articolo originale di msdn:

4. Fare clic su Sì per approvare l'elevazione. Quindi, l'applicazione originale viene riavviata, in esecuzione come amministratore con privilegi elevati.
5. Chiudere l'applicazione.