Erkennen, ob Sie als Administrator mit oder ohne erhöhte Berechtigungen ausgeführt werden?

81

Ich habe eine Anwendung, die erkennen muss, ob sie mit erhöhten Berechtigungen ausgeführt wird oder nicht. Ich habe derzeit folgenden Code eingerichtet:

static bool IsAdministrator()
{
    WindowsIdentity identity = WindowsIdentity.GetCurrent();
    WindowsPrincipal principal = new WindowsPrincipal(identity);
    return principal.IsInRole (WindowsBuiltInRole.Administrator);
}

Dies erkennt, ob ein Benutzer ein Administrator ist oder nicht, funktioniert jedoch nicht, wenn er als Administrator ohne Erhöhung ausgeführt wird. (Zum Beispiel in vshost.exe).

Wie kann ich feststellen, ob eine Erhöhung [bereits in Kraft oder] möglich ist ?

c#  .net  windows-vista  uac  user-accounts 
— MiffTheFox
quelle

Antworten:

55

Probieren Sie es aus:

using Microsoft.Win32;
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security.Principal;

public static class UacHelper
{
    private const string uacRegistryKey = "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System";
    private const string uacRegistryValue = "EnableLUA";

    private static uint STANDARD_RIGHTS_READ = 0x00020000;
    private static uint TOKEN_QUERY = 0x0008;
    private static uint TOKEN_READ = (STANDARD_RIGHTS_READ | TOKEN_QUERY);

    [DllImport("advapi32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    static extern bool OpenProcessToken(IntPtr ProcessHandle, UInt32 DesiredAccess, out IntPtr TokenHandle);

    [DllImport("advapi32.dll", SetLastError = true)]
    public static extern bool GetTokenInformation(IntPtr TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, IntPtr TokenInformation, uint TokenInformationLength, out uint ReturnLength);

    public enum TOKEN_INFORMATION_CLASS
    {
        TokenUser = 1,
        TokenGroups,
        TokenPrivileges,
        TokenOwner,
        TokenPrimaryGroup,
        TokenDefaultDacl,
        TokenSource,
        TokenType,
        TokenImpersonationLevel,
        TokenStatistics,
        TokenRestrictedSids,
        TokenSessionId,
        TokenGroupsAndPrivileges,
        TokenSessionReference,
        TokenSandBoxInert,
        TokenAuditPolicy,
        TokenOrigin,
        TokenElevationType,
        TokenLinkedToken,
        TokenElevation,
        TokenHasRestrictions,
        TokenAccessInformation,
        TokenVirtualizationAllowed,
        TokenVirtualizationEnabled,
        TokenIntegrityLevel,
        TokenUIAccess,
        TokenMandatoryPolicy,
        TokenLogonSid,
        MaxTokenInfoClass
    }

    public enum TOKEN_ELEVATION_TYPE
    {
        TokenElevationTypeDefault = 1,
        TokenElevationTypeFull,
        TokenElevationTypeLimited
    }

    public static bool IsUacEnabled
    {
        get
        {
            RegistryKey uacKey = Registry.LocalMachine.OpenSubKey(uacRegistryKey, false);
            bool result = uacKey.GetValue(uacRegistryValue).Equals(1);
            return result;
        }
    }

    public static bool IsProcessElevated
    {
        get
        {
            if (IsUacEnabled)
            {
                IntPtr tokenHandle;
                if (!OpenProcessToken(Process.GetCurrentProcess().Handle, TOKEN_READ, out tokenHandle))
                {
                    throw new ApplicationException("Could not get process token.  Win32 Error Code: " + Marshal.GetLastWin32Error());
                }

                TOKEN_ELEVATION_TYPE elevationResult = TOKEN_ELEVATION_TYPE.TokenElevationTypeDefault;

                int elevationResultSize = Marshal.SizeOf((int)elevationResult);
                uint returnedSize = 0;
                IntPtr elevationTypePtr = Marshal.AllocHGlobal(elevationResultSize);

                bool success = GetTokenInformation(tokenHandle, TOKEN_INFORMATION_CLASS.TokenElevationType, elevationTypePtr, (uint)elevationResultSize, out returnedSize);
                if (success)
                {
                    elevationResult = (TOKEN_ELEVATION_TYPE)Marshal.ReadInt32(elevationTypePtr);
                    bool isProcessAdmin = elevationResult == TOKEN_ELEVATION_TYPE.TokenElevationTypeFull;
                    return isProcessAdmin;
                }
                else
                {
                    throw new ApplicationException("Unable to determine the current elevation.");
                }
            }
            else
            {
                WindowsIdentity identity = WindowsIdentity.GetCurrent();
                WindowsPrincipal principal = new WindowsPrincipal(identity);
                bool result = principal.IsInRole(WindowsBuiltInRole.Administrator);
                return result;
            }
        }
    }
}
— Steven
quelle
8
Funktioniert, wenn das auszuführende Konto ein lokaler Administrator ist, wenn Sie jedoch den Domänenadministrator verwenden, gibt die Variable isProcessAdmin false zurück. Die Benutzerkontensteuerung akzeptiert den Domänenadministrator jedoch als gültig, wenn Berechtigungen erhöht werden (Ordner in Windows erstellen, als Administrator ausführen usw.). Wie kann ich Ihre Funktion so ändern, dass auch dieser Fall berücksichtigt wird?
— VSP
1
Möglicherweise möchten Sie auch berücksichtigen, dass die Benutzerkontensteuerung standardmäßig erhöht wird, wenn das Konto der integrierte Administrator ist, sodass IsProcessElevated in diesem Fall false zurückgibt (da IsUacEnabled true ist und heightResult TokenElevationTypeDefault ist), obwohl der Prozess im erhöhten Modus ohne ausgeführt wird forderte den Benutzer auf. Mit anderen Worten, das Konto ist erhöht und der Prozess wird im Standarderhöhungstyp ausgeführt.
— Mister Cook
2
Dieser Code erfordert die folgenden using-Anweisungen: using System.Diagnostics; using System.Runtime.InteropServices; using System.Security.Principal; Es scheint sich auch hier
— Scott Solmer
Dies brachte mir eine Ausnahme bei Windows 8, bei dem Marshal.SizeOf((int)elevationResult)ich mir noch nicht sicher bin warum. Ausnahmemeldung ist: Methode nicht gefunden. Um:Int32 System.Runtime.InteropServices.Marshal.SizeOf(!!0).
— CularBytes
Was ist mit TokenElevationTypeLimited? Sollte nicht berücksichtigt werden, isProcessAdmin auf true zu setzen?
— Olivier MATROT
33

(neue Antwort sechs Jahre nach der Frage)

Haftungsausschluss: Dies ist nur etwas, das auf meinem speziellen Betriebssystem mit meinen speziellen Einstellungen mit meinem bestimmten Benutzer funktioniert hat:

using System.Security.Principal;

// ...

    static bool IsElevated
    {
      get
      {
        return WindowsIdentity.GetCurrent().Owner
          .IsWellKnown(WellKnownSidType.BuiltinAdministratorsSid);
      }
    }

Wenn ich also "Als Administrator ausführen" ausführe, getkehrt der Eigenschaftenzugriff zurück true. Bei normaler Ausführung (auch wenn mein Benutzer "Administrator" ist und diese bestimmte Anwendung nicht "als Administrator" ausführt) wird sie zurückgegeben false.

Dies scheint viel einfacher als viele andere Antworten.

Ich habe keine Ahnung, ob es Fälle gibt, in denen dies fehlschlägt.

PS! Dies scheint auch in Ordnung zu sein:

    static bool IsElevated
    {
      get
      {
        var id = WindowsIdentity.GetCurrent();
        return id.Owner != id.User;
      }
    }
— Jeppe Stig Nielsen
quelle
1
Danke dafür! - Ich habe dies in PowerShell [Security.Principal.WindowsIdentity] :: GetCurrent () verwendet. Owner.IsWellKnown ([System.Security.Principal.WellKnownSidType] :: BuiltinAdministratorsSid)
— Lewis
Wenn Sie Benachrichtigungen auf "Keine Benachrichtigung anzeigen" gesetzt haben, wird "true" zurückgegeben. In bestimmten Szenarien, in denen Sie die Software wirklich als Administrator ausführen müssen, kann dies möglicherweise einen falschen Hinweis geben.
— CularBytes
2
Dies unterscheidet nicht zwischen einem "halb nicht erhöhten" Prozess und einem ordnungsgemäß nicht erhöhten Prozess: Es ist möglich, dass IsElevatedfalse zurückgegeben wird, der Prozess wird jedoch möglicherweise weiterhin mit einer hohen Integritätsstufe ausgeführt. Ein wirklich nicht erhöhter Prozess hat ein mittleres Integritätsniveau. Dies ist wahrscheinlich für 99% der Anwendungen irrelevant, aber es ist erwähnenswert, da Tools wie Process Hacker einen solchen Prozess möglicherweise immer noch als erhöht deklarieren. Ein "halb unbeaufsichtigter" Prozess ist etwas, das Sie normalerweise nicht sehen würden. Dies kann auftreten, wenn jemand einen nicht erhöhten untergeordneten Prozess nicht korrekt startet.
— Roman Starkov
Was ist "Laufen mit hoher Integrität"?
— StingyJack
@StingyJack, das ist eine zu große Frage, um sie in Kommentaren zu beantworten, aber siehe hier und hier .
— Roman Starkov
19

Hier ist eine modifizierte Version dieser Antwort , die Dinge wie die ordnungsgemäße Entsorgung von Ressourcen und den Umgang mit Domänenadministratoren enthält.

public static class UacHelper
{
    private const string uacRegistryKey = "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System";
    private const string uacRegistryValue = "EnableLUA";

    private static uint STANDARD_RIGHTS_READ = 0x00020000;
    private static uint TOKEN_QUERY = 0x0008;
    private static uint TOKEN_READ = (STANDARD_RIGHTS_READ | TOKEN_QUERY);

    [DllImport("advapi32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    static extern bool OpenProcessToken(IntPtr ProcessHandle, UInt32 DesiredAccess, out IntPtr TokenHandle);

    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    static extern bool CloseHandle(IntPtr hObject);

    [DllImport("advapi32.dll", SetLastError = true)]
    public static extern bool GetTokenInformation(IntPtr TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, IntPtr TokenInformation, uint TokenInformationLength, out uint ReturnLength);

    public enum TOKEN_INFORMATION_CLASS
    {
        TokenUser = 1,
        TokenGroups,
        TokenPrivileges,
        TokenOwner,
        TokenPrimaryGroup,
        TokenDefaultDacl,
        TokenSource,
        TokenType,
        TokenImpersonationLevel,
        TokenStatistics,
        TokenRestrictedSids,
        TokenSessionId,
        TokenGroupsAndPrivileges,
        TokenSessionReference,
        TokenSandBoxInert,
        TokenAuditPolicy,
        TokenOrigin,
        TokenElevationType,
        TokenLinkedToken,
        TokenElevation,
        TokenHasRestrictions,
        TokenAccessInformation,
        TokenVirtualizationAllowed,
        TokenVirtualizationEnabled,
        TokenIntegrityLevel,
        TokenUIAccess,
        TokenMandatoryPolicy,
        TokenLogonSid,
        MaxTokenInfoClass
    }

    public enum TOKEN_ELEVATION_TYPE
    {
        TokenElevationTypeDefault = 1,
        TokenElevationTypeFull,
        TokenElevationTypeLimited
    }

    public static bool IsUacEnabled
    {
        get
        {
            using (RegistryKey uacKey = Registry.LocalMachine.OpenSubKey(uacRegistryKey, false))
            {
                bool result = uacKey.GetValue(uacRegistryValue).Equals(1);
                return result;
            }
        }
    }

    public static bool IsProcessElevated
    {
        get
        {
            if (IsUacEnabled)
            {
                IntPtr tokenHandle = IntPtr.Zero;
                if (!OpenProcessToken(Process.GetCurrentProcess().Handle, TOKEN_READ, out tokenHandle))
                {
                    throw new ApplicationException("Could not get process token.  Win32 Error Code: " +
                                                   Marshal.GetLastWin32Error());
                }

                try
                {
                    TOKEN_ELEVATION_TYPE elevationResult = TOKEN_ELEVATION_TYPE.TokenElevationTypeDefault;

                    int elevationResultSize = Marshal.SizeOf(typeof(TOKEN_ELEVATION_TYPE));
                    uint returnedSize = 0;

                    IntPtr elevationTypePtr = Marshal.AllocHGlobal(elevationResultSize);
                    try
                    {
                        bool success = GetTokenInformation(tokenHandle, TOKEN_INFORMATION_CLASS.TokenElevationType,
                                                           elevationTypePtr, (uint) elevationResultSize,
                                                           out returnedSize);
                        if (success)
                        {
                            elevationResult = (TOKEN_ELEVATION_TYPE) Marshal.ReadInt32(elevationTypePtr);
                            bool isProcessAdmin = elevationResult == TOKEN_ELEVATION_TYPE.TokenElevationTypeFull;
                            return isProcessAdmin;
                        }
                        else
                        {
                            throw new ApplicationException("Unable to determine the current elevation.");
                        }
                    }
                    finally
                    {
                        if (elevationTypePtr != IntPtr.Zero)
                            Marshal.FreeHGlobal(elevationTypePtr);
                    }
                }
                finally
                {
                    if (tokenHandle != IntPtr.Zero)
                        CloseHandle(tokenHandle);
                }
            }
            else
            {
                WindowsIdentity identity = WindowsIdentity.GetCurrent();
                WindowsPrincipal principal = new WindowsPrincipal(identity);
                bool result = principal.IsInRole(WindowsBuiltInRole.Administrator) 
                           || principal.IsInRole(0x200); //Domain Administrator
                return result;
            }
        }
    }
}
— Scott Chamberlain
quelle
Es hängt alles davon ab, unter welchem ​​Benutzer Sie den Dienst ausführen. Versuchen Sie festzustellen, ob der Dienst als lokales System, lokaler Dienst, Netzwerkdienst oder Windows-Benutzer ausgeführt wird? Das Erkennen des "Verwaltungsstatus" funktioniert nicht, um den Unterschied zwischen lokalem System und lokalem Dienst festzustellen. Sie müssen dies testen, indem Sie direkt überprüfen, welcher Benutzer den Prozess ausführt.
— Scott Chamberlain
Dies brachte mir eine Ausnahme bei Windows 8, bei dem Marshal.SizeOf((int)elevationResult)ich mir noch nicht sicher bin warum. Ausnahmemeldung ist: Methode nicht gefunden. Um:Int32 System.Runtime.InteropServices.Marshal.SizeOf(!!0).
— CularBytes
@RageCompex Verwenden Sie eine eingeschränkte Plattform wie eine universelle App oder Unity3d?
— Scott Chamberlain
1
Ah, Sie kompilieren mit 4.5.1, weil es versucht, diese Überlastung zu verwenden, aber der Benutzer hat 4.5.1 nicht installiert. Versuchen Sie es durch zu ersetzen Marshal.SizeOf(typeof(TOKEN_ELEVATION_TYPE)),
— Scott Chamberlain
2
@ScottChamberlain löst int elevationResultSize = Marshal.SizeOf(typeof(TOKEN_ELEVATION_TYPE))eine ArgumentException32-Bit-Anwendung .NET 4.0 aus, die jedoch int elevationResultSize = Marshal.SizeOf((int)elevationResult)funktioniert hat.
— Martin Braun
16

Der UAChelper des CodePlex-Projekts verfügt über Code, der die Höhe in UserAccountControl.cpp UserAccountControl::IsUserAdminüberprüft, prüft, ob die Benutzerkontensteuerung aktiviert ist, und dann prüft, ob der Prozess erhöht ist.

bool UserAccountControl::IsCurrentProcessElevated::get()
{
    return GetProcessTokenElevationType() == TokenElevationTypeFull;    //elevated
}

von der Funktion:

int UserAccountControl::GetProcessTokenElevationType()
{
    HANDLE hToken;
    try
    {
        if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
            throw gcnew Win32Exception(GetLastError());

        TOKEN_ELEVATION_TYPE elevationType;
        DWORD dwSize;
        if (!GetTokenInformation(hToken, TokenElevationType, &elevationType, sizeof(elevationType), &dwSize))
            throw gcnew Win32Exception(GetLastError());

        return elevationType;
    }
    finally
    {
        CloseHandle(hToken);
    }
}
— Preet Sangha
quelle
10

In .net Framwork 4.5 habe ich eine andere Methode gefunden, die für mich funktioniert. In Bezug auf das folgende Skript , die hier gefunden werden kann hier (in deutscher Sprache)

 rem --- Admintest.bat ---
 whoami /groups | find "S-1-5-32-544" > nul
 if errorlevel 1 goto ende
 echo Benutzer %username% ist lokaler Administrator.
 :ende

In C # sieht es so aus:

    private bool IsAdmin
    {
        get
        {
            WindowsIdentity identity = WindowsIdentity.GetCurrent();
            if (identity != null)
            {
               WindowsPrincipal principal = new WindowsPrincipal(identity);
               List<Claim> list = new List<Claim>(principal.UserClaims);
               Claim c = list.Find(p => p.Value.Contains("S-1-5-32-544"));
               if (c != null)
                  return true;
            }
            return false;
        }
    }

Aber in .net <4.5 enthält die WindowsPrincipalKlasse die UserClaimsEigenschaft nicht und ich habe keine Möglichkeit gefunden, diese Informationen abzurufen.

— Rafael
quelle
Zu
— Ihrer Information
Um zu überprüfen, ob ein Benutzer Mitglied von S-1-5-32-544 (Administratorgruppe) in .Net <4.5 ist, können Sie einfach den Code in der ursprünglichen Frage verwenden. Der Principal ist nur dann Mitglied der Gruppe Administratoren, wenn der Prozess mit erhöhten Rechten ausgeführt wird und sich der Benutzer in der Gruppe befindet. Wenn der Prozess nicht erhöht ist, befindet sich der Principal nicht in der Gruppe.
— Adam
1
Schöne Antwort, kurz und effizient, ich habe dir eine +1 dafür gegeben. NB Ich habe dies zu einer Eigenschaft in meinem Code ( private bool IsAdmin{ get { ... } }) gemacht, dann brauchen Sie die Klammern nicht, wenn Sie aufrufen IsAdmin.
— Matt
4

Die Verwendung TokenElevationTypewürde funktionieren, aber wenn Sie PInvoke CheckTokenMembership()gegen die SID der Administratorgruppe durchführen, funktioniert Ihr Code auch , wenn die Benutzerkontensteuerung deaktiviert ist und 2000 / XP / 2003 aktiviert ist, und behandelt auch die Verweigerung von SIDs.

Es gibt auch eine IsUserAnAdmin()Funktion, die die CheckTokenMembershipPrüfung für Sie durchführt, aber MSDN sagt, dass sie möglicherweise nicht für immer da ist

— Anders
quelle
Ich fand CheckTokenMembership unzureichend, wenn es der Benutzerkontensteuerung unterliegt - github.com/chocolatey/choco/blob/… gibt false zurück. Überprüfen Sie den Code (ich ersetze ihn) und sehen Sie sich die Ausgabe von Win2012R2 - i.imgur.com/gX3JP0W.png
— ferventcoder
@ferventcoder Es hängt davon ab, was Sie wirklich wissen wollen; Ist der Benutzer gerade ein erhöhter Administrator oder kann er bei Bedarf eine Erhöhung vornehmen? Sie können beispielsweise TOKEN_ELEVATION_TYPE überprüfen und am Ende Folgendes erhalten: bool is_or_can_elevate () {return process_is_elevated () || TokenElevationTypeLimited == get_current_token_elevation_type (); }. Ein weiteres Problem ist, dass die Definition von erhöht nicht überall gleich ist. Sie können ein Konsolenfenster mit dem Präfix "Administrator:" haben und gleichzeitig unter der hohen Integritätsstufe liegen! TokenElevation stimmt nicht immer mit TokenIntegrityLevel überein.
— Anders
Lustige Zeiten. Ich möchte wissen, ob ich einen erhöhten Prozess habe, der davon getrennt ist, ob der Benutzer ein Administrator ist. Hier bin ich gelandet. Lassen Sie mich wissen, wohin ich gehen soll, wenn es falsch ist - github.com/chocolatey/choco/issues/77#issuecomment-73523774 und github.com/chocolatey/choco/commit/…
— ferventcoder
@ferventcoder is_processes_elevated () {CheckTokenMembership / IsInRole || zurückgeben TokenElevation / TokenIntegrityLevel> = 0x3000; } CheckTokenMembership oder IsInRole für <Vista und Vista + bei deaktivierter Benutzerkontensteuerung. TokenElevation oder TokenIntegrityLevel> = 0x3000, je nachdem, wie genau Sie die Höhe erkennen möchten. Ich glaube, conhost.exe verwendet TokenElevation, aber es ist meiner Meinung nach kaputt und Sie sollten das tatsächliche Level überprüfen ... (Sie benötigen spezielle Tools, um ein Token zu generieren, das TokenElevation täuscht.) Siehe auch: windowssucks.wordpress.com/2011/02/07 / uac-are-you-high / #
— Anders
... und selbst das ist irgendwie falsch, theoretisch ist es möglich, ein erhöhtes Token zu haben und nicht in der Administratorgruppe zu sein. Wenn Sie also nur Personen in der Administratorgruppe haben möchten und sicherstellen möchten, dass sie erhöht sind, sollten Sie die CheckTokenMembership / IsInRole-Prüfung durchführen, und dann sollte die Token * -Überprüfung fehlschlagen (keine Benutzerkontensteuerung) oder der Wert sollte eine Erhöhung anzeigen ... Dies hängt natürlich davon ab auf was Sie eigentlich zugreifen möchten. Möglicherweise müssen Sie System / Administrator und erhöht sein oder nur erhöht, dies hängt von der ACL ab.
— Anders
4

Diese Antwort hat einige Probleme. Erstens werden keine Systemprozesse abgerufen, die als Administrator ausgeführt werden (z. B. unter NT-Authority / SYSTEM). Das folgende Codebeispiel behebt alle Probleme (erkennt, LocalAdmins, DomainAdmins und LocalSystemAdmins)

Wenn Sie nur den aktuellen Prozess möchten, ersetzen Sie ihn pHandledurchProcess.GetCurrentProcess().Handle

HINWEIS: Sie müssen über bestimmte Berechtigungen verfügen, um es ausführen zu können. (Jeder AdminProcess hat sie, muss sie aber zuerst aktivieren. Services haben sie standardmäßig aktiviert.)

internal static bool IsProcessElevatedEx(this IntPtr pHandle) {

        var token = IntPtr.Zero;
        if (!OpenProcessToken(pHandle, MAXIMUM_ALLOWED, ref token))
                throw new Win32Exception(Marshal.GetLastWin32Error(), "OpenProcessToken failed");

        WindowsIdentity identity = new WindowsIdentity(token);
        WindowsPrincipal principal = new WindowsPrincipal(identity);
        bool result = principal.IsInRole(WindowsBuiltInRole.Administrator)
                   || principal.IsInRole(0x200); //Domain Administrator
        CloseHandle(token);
        return result;
}
— John Smith
quelle
1

Ich denke, es gibt noch ein Problem. Ich habe die von Ihnen bereitgestellten Lösungen überprüft und muss sagen, dass bei der Installation von Windows 7 und der Anmeldung als Administrator die Überprüfung nicht funktioniert. Windows gibt niemals Informationen zurück, die der Prozess in einem erhöhten Modus ausführt. Also die Reihenfolge:

if (IsUacEnabled)
    return IsProcessInElevatedMode();
return IsUserAdmin();

Gibt nicht true zurück, wenn Sie als Administrator angemeldet sind, aber der Prozess verfügt über alle Berechtigungen zum Ausführen von Systemvorgängen (z. B. Stoppen von Systemdiensten). Die Arbeitssequenz ist:

if (IsUserAdmin())
    return true;

if (IsUacEnabled)
    return IsProcessInElevatedMode();

return false;

Sie sollten zunächst überprüfen, ob der Prozess im Administratorkontext ausgeführt wird. Zusätzliche Information:

IsUacEnabled() - checks if the UAC has been enabled in the system (Windows)
IsProcessInElevatedMode() - checks if the process is run in an elevated mode
IsUserAdmin() - checks if the current user has an Administrtor role

All diese Methoden wurden in früheren Beiträgen beschrieben.

— Grzegorz Dąbrowski
quelle
1
Dies ist keine Antwort, aber wohl ein Kommentar zu einem anderen Beitrag
— MickyD
1

Verwenden des UACHelper- Nuget-Pakets: https://www.nuget.org/packages/UACHelper/

if (UACHelper.IsElevated)
    // something
else
    // something else

Es gibt viele andere Eigenschaften, mit denen festgestellt werden kann, ob der Benutzer tatsächlich ein Administrator ist, ob der Prozess unter UAC-Virtualisierung ausgeführt wird oder ob der Desktop-Eigentümer der Prozess-Eigentümer ist. (Ausgehend von einem begrenzten Konto ausführen)

Weitere Informationen finden Sie unter Lesen Sie mich.

— Soroush Falahati
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.