Überprüfen auf Verzeichnis- und Dateischreibberechtigungen in .NET

In meiner .NET 2.0-Anwendung muss ich überprüfen, ob ausreichende Berechtigungen zum Erstellen und Schreiben von Dateien in ein Verzeichnis vorhanden sind. Zu diesem Zweck habe ich die folgende Funktion, die versucht, eine Datei zu erstellen und ein einzelnes Byte in sie zu schreiben. Anschließend löscht sie sich selbst, um zu testen, ob Berechtigungen vorhanden sind.

Ich dachte, der beste Weg, dies zu überprüfen, wäre, es tatsächlich zu versuchen und alle auftretenden Ausnahmen abzufangen. Ich bin jedoch nicht besonders glücklich über den allgemeinen Ausnahmefang. Gibt es also einen besseren oder vielleicht akzeptierteren Weg, dies zu tun?

private const string TEMP_FILE = "\\tempFile.tmp";

/// <summary>
/// Checks the ability to create and write to a file in the supplied directory.
/// </summary>
/// <param name="directory">String representing the directory path to check.</param>
/// <returns>True if successful; otherwise false.</returns>
private static bool CheckDirectoryAccess(string directory)
{
    bool success = false;
    string fullPath = directory + TEMP_FILE;

    if (Directory.Exists(directory))
    {
        try
        {
            using (FileStream fs = new FileStream(fullPath, FileMode.CreateNew, 
                                                            FileAccess.Write))
            {
                fs.WriteByte(0xff);
            }

            if (File.Exists(fullPath))
            {
                File.Delete(fullPath);
                success = true;
            }
        }
        catch (Exception)
        {
            success = false;
        }
    }

Die Antworten von Richard und Jason gehen in die richtige Richtung. Sie sollten jedoch die effektiven Berechtigungen für die Benutzeridentität berechnen, auf der Ihr Code ausgeführt wird. Keines der obigen Beispiele berücksichtigt beispielsweise die Gruppenmitgliedschaft korrekt.

Ich bin mir ziemlich sicher, dass Keith Brown in seiner Wiki-Version (zu diesem Zeitpunkt offline) des .NET-Entwicklerhandbuchs für Windows-Sicherheit Code dafür hatte . Dies wird auch in seinem Buch zur Programmierung der Windows-Sicherheit ausführlich erläutert .

Das Berechnen effektiver Berechtigungen ist nichts für schwache Nerven, und Ihr Code, der versucht, eine Datei zu erstellen und die ausgelöste Sicherheitsausnahme abzufangen, ist wahrscheinlich der Weg des geringsten Widerstands.

Directory.GetAccessControl(path) tut, wonach Sie fragen.

public static bool HasWritePermissionOnDir(string path)
{
    var writeAllow = false;
    var writeDeny = false;
    var accessControlList = Directory.GetAccessControl(path);
    if (accessControlList == null)
        return false;
    var accessRules = accessControlList.GetAccessRules(true, true, 
                                typeof(System.Security.Principal.SecurityIdentifier));
    if (accessRules ==null)
        return false;

    foreach (FileSystemAccessRule rule in accessRules)
    {
        if ((FileSystemRights.Write & rule.FileSystemRights) != FileSystemRights.Write) 
            continue;

        if (rule.AccessControlType == AccessControlType.Allow)
            writeAllow = true;
        else if (rule.AccessControlType == AccessControlType.Deny)
            writeDeny = true;
    }

    return writeAllow && !writeDeny;
}

(FileSystemRights.Write & rights) == FileSystemRights.Write verwendet übrigens etwas namens "Flags", das Sie wirklich nachlesen sollten, wenn Sie nicht wissen, was es ist :)

Denyhat Vorrang vor Allow. Lokale Regeln haben Vorrang vor geerbten Regeln. Ich habe viele Lösungen gesehen (einschließlich einiger hier gezeigter Antworten), aber keine davon berücksichtigt, ob Regeln vererbt werden oder nicht. Daher schlage ich den folgenden Ansatz vor, der die Regelvererbung berücksichtigt (ordentlich in eine Klasse verpackt):

public class CurrentUserSecurity
{
    WindowsIdentity _currentUser;
    WindowsPrincipal _currentPrincipal;

    public CurrentUserSecurity()
    {
        _currentUser = WindowsIdentity.GetCurrent();
        _currentPrincipal = new WindowsPrincipal(_currentUser);
    }

    public bool HasAccess(DirectoryInfo directory, FileSystemRights right)
    {
        // Get the collection of authorization rules that apply to the directory.
        AuthorizationRuleCollection acl = directory.GetAccessControl()
            .GetAccessRules(true, true, typeof(SecurityIdentifier));
        return HasFileOrDirectoryAccess(right, acl);
    }

    public bool HasAccess(FileInfo file, FileSystemRights right)
    {
        // Get the collection of authorization rules that apply to the file.
        AuthorizationRuleCollection acl = file.GetAccessControl()
            .GetAccessRules(true, true, typeof(SecurityIdentifier));
        return HasFileOrDirectoryAccess(right, acl);
    }

    private bool HasFileOrDirectoryAccess(FileSystemRights right,
                                          AuthorizationRuleCollection acl)
    {
        bool allow = false;
        bool inheritedAllow = false;
        bool inheritedDeny = false;

        for (int i = 0; i < acl.Count; i++) {
            var currentRule = (FileSystemAccessRule)acl[i];
            // If the current rule applies to the current user.
            if (_currentUser.User.Equals(currentRule.IdentityReference) ||
                _currentPrincipal.IsInRole(
                                (SecurityIdentifier)currentRule.IdentityReference)) {

                if (currentRule.AccessControlType.Equals(AccessControlType.Deny)) {
                    if ((currentRule.FileSystemRights & right) == right) {
                        if (currentRule.IsInherited) {
                            inheritedDeny = true;
                        } else { // Non inherited "deny" takes overall precedence.
                            return false;
                        }
                    }
                } else if (currentRule.AccessControlType
                                                  .Equals(AccessControlType.Allow)) {
                    if ((currentRule.FileSystemRights & right) == right) {
                        if (currentRule.IsInherited) {
                            inheritedAllow = true;
                        } else {
                            allow = true;
                        }
                    }
                }
            }
        }

        if (allow) { // Non inherited "allow" takes precedence over inherited rules.
            return true;
        }
        return inheritedAllow && !inheritedDeny;
    }
}

Ich habe jedoch die Erfahrung gemacht, dass dies auf Remotecomputern nicht immer funktioniert, da Sie dort nicht immer das Recht haben, die Dateizugriffsrechte abzufragen. Die Lösung in diesem Fall ist zu versuchen; Möglicherweise sogar, indem Sie nur versuchen, eine temporäre Datei zu erstellen, wenn Sie den Zugriff kennen müssen, bevor Sie mit den "echten" Dateien arbeiten.

Die von Kev akzeptierte Antwort auf diese Frage enthält keinen Code, sondern verweist nur auf andere Ressourcen, auf die ich keinen Zugriff habe. Hier ist mein bester Versuch, die Funktion zu nutzen. Es wird tatsächlich überprüft, ob es sich bei der angezeigten Berechtigung um eine Schreibberechtigung handelt und ob der aktuelle Benutzer zur entsprechenden Gruppe gehört.

Es ist möglicherweise nicht vollständig in Bezug auf Netzwerkpfade oder was auch immer, aber es ist gut genug für meinen Zweck, lokale Konfigurationsdateien unter "Programme" auf Beschreibbarkeit zu überprüfen:

using System.Security.Principal;
using System.Security.AccessControl;

private static bool HasWritePermission(string FilePath)
{
    try
    {
        FileSystemSecurity security;
        if (File.Exists(FilePath))
        {
            security = File.GetAccessControl(FilePath);
        }
        else
        {
            security = Directory.GetAccessControl(Path.GetDirectoryName(FilePath));
        }
        var rules = security.GetAccessRules(true, true, typeof(NTAccount));

        var currentuser = new WindowsPrincipal(WindowsIdentity.GetCurrent());
        bool result = false;
        foreach (FileSystemAccessRule rule in rules)
        {
            if (0 == (rule.FileSystemRights &
                (FileSystemRights.WriteData | FileSystemRights.Write)))
            {
                continue;
            }

            if (rule.IdentityReference.Value.StartsWith("S-1-"))
            {
                var sid = new SecurityIdentifier(rule.IdentityReference.Value);
                if (!currentuser.IsInRole(sid))
                {
                    continue;
                }
            }
            else
            {
                if (!currentuser.IsInRole(rule.IdentityReference.Value))
                {
                    continue;
                }
            }

            if (rule.AccessControlType == AccessControlType.Deny)
                return false;
            if (rule.AccessControlType == AccessControlType.Allow)
                result = true;
        }
        return result;
    }
    catch
    {
        return false;
    }
}

IMO, Sie müssen wie gewohnt mit solchen Verzeichnissen arbeiten, aber anstatt die Berechtigungen vor der Verwendung zu überprüfen, sollten Sie die richtige Methode zum Behandeln von UnauthorizedAccessException bereitstellen und entsprechend reagieren. Diese Methode ist einfacher und weniger fehleranfällig.

Versuchen Sie, mit diesem C # -Schnipsel zu arbeiten, den ich gerade erstellt habe:

using System;
using System.IO;
using System.Security.AccessControl;
using System.Security.Principal;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string directory = @"C:\downloads";

            DirectoryInfo di = new DirectoryInfo(directory);

            DirectorySecurity ds = di.GetAccessControl();

            foreach (AccessRule rule in ds.GetAccessRules(true, true, typeof(NTAccount)))
            {
                Console.WriteLine("Identity = {0}; Access = {1}", 
                              rule.IdentityReference.Value, rule.AccessControlType);
            }
        }
    }
}

Und hier ist eine Referenz, die Sie sich auch ansehen können. Mein Code gibt Ihnen möglicherweise eine Vorstellung davon, wie Sie nach Berechtigungen suchen können, bevor Sie versuchen, in ein Verzeichnis zu schreiben.

Da die statische Methode 'GetAccessControl' in der aktuellen Version von .Net Core / Standard zu fehlen scheint, musste ich die Antwort von @Bryce Wagner ändern (ich habe eine modernere Syntax verwendet):

public static class PermissionHelper
{
  public static bool? CurrentUserHasWritePermission(string filePath)

     => new WindowsPrincipal(WindowsIdentity.GetCurrent())
        .SelectWritePermissions(filePath)
        .FirstOrDefault();


  private static IEnumerable<bool?> SelectWritePermissions(this WindowsPrincipal user, string filePath)
     => from rule in filePath
                    .GetFileSystemSecurity()
                    .GetAccessRules(true, true, typeof(NTAccount))
                    .Cast<FileSystemAccessRule>()
        let right = user.HasRightSafe(rule)
        where right.HasValue
        // Deny takes precedence over allow
        orderby right.Value == false descending
        select right;


  private static bool? HasRightSafe(this WindowsPrincipal user, FileSystemAccessRule rule)
  {
     try
     {
        return user.HasRight(rule);
     }
     catch
     {
        return null;
     }
  }

  private static bool? HasRight(this WindowsPrincipal user,FileSystemAccessRule rule )
     => rule switch
     {
        { FileSystemRights: FileSystemRights fileSystemRights } when (fileSystemRights &
                                                                      (FileSystemRights.WriteData | FileSystemRights.Write)) == 0 => null,
        { IdentityReference: { Value: string value } } when value.StartsWith("S-1-") &&
                                                            !user.IsInRole(new SecurityIdentifier(rule.IdentityReference.Value)) => null,
        { IdentityReference: { Value: string value } } when value.StartsWith("S-1-") == false &&
                                                            !user.IsInRole(rule.IdentityReference.Value) => null,
        { AccessControlType: AccessControlType.Deny } => false,
        { AccessControlType: AccessControlType.Allow } => true,
        _ => null
     };


  private static FileSystemSecurity GetFileSystemSecurity(this string filePath)
    => new FileInfo(filePath) switch
    {
       { Exists: true } fileInfo => fileInfo.GetAccessControl(),
       { Exists: false } fileInfo => (FileSystemSecurity)fileInfo.Directory.GetAccessControl(),
       _ => throw new Exception($"Check the file path, {filePath}: something's wrong with it.")
    };
}

Laut diesem Link: http://www.authorcode.com/how-to-check-file-permission-to-write-in-c/

Es ist einfacher, die vorhandene Klasse SecurityManager zu verwenden

string FileLocation = @"C:\test.txt";
FileIOPermission writePermission = new FileIOPermission(FileIOPermissionAccess.Write, FileLocation);
if (SecurityManager.IsGranted(writePermission))
{
  // you have permission
}
else
{
 // permission is required!
}

Es scheint jedoch veraltet zu sein. Es wird empfohlen, stattdessen PermissionSet zu verwenden.

[Obsolete("IsGranted is obsolete and will be removed in a future release of the .NET Framework.  Please use the PermissionSet property of either AppDomain or Assembly instead.")]

private static void GrantAccess(string file)
        {
            bool exists = System.IO.Directory.Exists(file);
            if (!exists)
            {
                DirectoryInfo di = System.IO.Directory.CreateDirectory(file);
                Console.WriteLine("The Folder is created Sucessfully");
            }
            else
            {
                Console.WriteLine("The Folder already exists");
            }
            DirectoryInfo dInfo = new DirectoryInfo(file);
            DirectorySecurity dSecurity = dInfo.GetAccessControl();
            dSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.NoPropagateInherit, AccessControlType.Allow));
            dInfo.SetAccessControl(dSecurity);

        }