C # Test si l'utilisateur a un accès en écriture à un dossier

J'ai besoin de tester si un utilisateur peut écrire dans un dossier avant d'essayer de le faire.

J'ai implémenté la méthode suivante (en C # 2.0) qui tente de récupérer les autorisations de sécurité pour le dossier à l'aide de la méthode Directory.GetAccessControl () .

private bool hasWriteAccessToFolder(string folderPath)
{
    try
    {
        // Attempt to get a list of security permissions from the folder. 
        // This will raise an exception if the path is read only or do not have access to view the permissions. 
        System.Security.AccessControl.DirectorySecurity ds = Directory.GetAccessControl(folderPath);
        return true;
    }
    catch (UnauthorizedAccessException)
    {
        return false;
    }
}

Lorsque je cherchais sur Google comment tester l'accès en écriture, rien de tel ne s'est produit et il m'a semblé très compliqué de tester les autorisations dans Windows. Je crains de trop simplifier les choses et que cette méthode ne soit pas robuste, même si elle semble fonctionner.

Ma méthode pour tester si l'utilisateur actuel a un accès en écriture fonctionnera-t-elle correctement?

C'est un moyen parfaitement valide de vérifier l'accès aux dossiers en C #. Le seul endroit où il peut tomber est si vous devez appeler cela dans une boucle serrée où la surcharge d'une exception peut être un problème.

D'autres questions similaires ont déjà été posées.

J'apprécie que ce soit un peu tard dans la journée pour cet article, mais vous pourriez trouver ce morceau de code utile.

string path = @"c:\temp";
string NtAccountName = @"MyDomain\MyUserOrGroup";

DirectoryInfo di = new DirectoryInfo(path);
DirectorySecurity acl = di.GetAccessControl(AccessControlSections.All);
AuthorizationRuleCollection rules = acl.GetAccessRules(true, true, typeof(NTAccount));

//Go through the rules returned from the DirectorySecurity
foreach (AuthorizationRule rule in rules)
{
    //If we find one that matches the identity we are looking for
    if (rule.IdentityReference.Value.Equals(NtAccountName,StringComparison.CurrentCultureIgnoreCase))
    {
        var filesystemAccessRule = (FileSystemAccessRule)rule;

        //Cast to a FileSystemAccessRule to check for access rights
        if ((filesystemAccessRule.FileSystemRights & FileSystemRights.WriteData)>0 && filesystemAccessRule.AccessControlType != AccessControlType.Deny)
        {
            Console.WriteLine(string.Format("{0} has write access to {1}", NtAccountName, path));
        }
        else
        {
            Console.WriteLine(string.Format("{0} does not have write access to {1}", NtAccountName, path));
        }
    }
}

Console.ReadLine();

Déposez-le dans une application console et voyez s'il fait ce dont vous avez besoin.

public bool IsDirectoryWritable(string dirPath, bool throwIfFails = false)
{
    try
    {
        using (FileStream fs = File.Create(
            Path.Combine(
                dirPath, 
                Path.GetRandomFileName()
            ), 
            1,
            FileOptions.DeleteOnClose)
        )
        { }
        return true;
    }
    catch
    {
        if (throwIfFails)
            throw;
        else
            return false;
    }
}

J'ai essayé la plupart d'entre eux, mais ils donnent des faux positifs, tous pour la même raison .. Il ne suffit pas de tester le répertoire pour une autorisation disponible, vous devez vérifier que l'utilisateur connecté est membre d'un groupe qui a cela autorisation. Pour ce faire, vous obtenez l'identité des utilisateurs et vérifiez s'il est membre d'un groupe qui contient le FileSystemAccessRule IdentityReference. J'ai testé cela, fonctionne parfaitement.

    /// <summary>
    /// Test a directory for create file access permissions
    /// </summary>
    /// <param name="DirectoryPath">Full path to directory </param>
    /// <param name="AccessRight">File System right tested</param>
    /// <returns>State [bool]</returns>
    public static bool DirectoryHasPermission(string DirectoryPath, FileSystemRights AccessRight)
    {
        if (string.IsNullOrEmpty(DirectoryPath)) return false;

        try
        {
            AuthorizationRuleCollection rules = Directory.GetAccessControl(DirectoryPath).GetAccessRules(true, true, typeof(System.Security.Principal.SecurityIdentifier));
            WindowsIdentity identity = WindowsIdentity.GetCurrent();

            foreach (FileSystemAccessRule rule in rules)
            {
                if (identity.Groups.Contains(rule.IdentityReference))
                {
                    if ((AccessRight & rule.FileSystemRights) == AccessRight)
                    {
                        if (rule.AccessControlType == AccessControlType.Allow)
                            return true;
                    }
                }
            }
        }
        catch { }
        return false;
    }

À mon humble avis, le seul moyen fiable à 100% de tester si vous pouvez écrire dans un répertoire est d'y écrire et éventuellement d'attraper des exceptions.

Par exemple, pour tous les utilisateurs (Builtin \ Users), cette méthode fonctionne très bien - profitez-en.

public static bool HasFolderWritePermission(string destDir)
{
   if(string.IsNullOrEmpty(destDir) || !Directory.Exists(destDir)) return false;
   try
   {
      DirectorySecurity security = Directory.GetAccessControl(destDir);
      SecurityIdentifier users = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null);
      foreach(AuthorizationRule rule in security.GetAccessRules(true, true, typeof(SecurityIdentifier)))
      {
          if(rule.IdentityReference == users)
          {
             FileSystemAccessRule rights = ((FileSystemAccessRule)rule);
             if(rights.AccessControlType == AccessControlType.Allow)
             {
                    if(rights.FileSystemRights == (rights.FileSystemRights | FileSystemRights.Modify)) return true;
             }
          }
       }
       return false;
    }
    catch
    {
        return false;
    }
}

Essaye ça:

try
{
    DirectoryInfo di = new DirectoryInfo(path);
    DirectorySecurity acl = di.GetAccessControl();
    AuthorizationRuleCollection rules = acl.GetAccessRules(true, true, typeof(NTAccount));

    WindowsIdentity currentUser = WindowsIdentity.GetCurrent();
    WindowsPrincipal principal = new WindowsPrincipal(currentUser);
    foreach (AuthorizationRule rule in rules)
    {
        FileSystemAccessRule fsAccessRule = rule as FileSystemAccessRule;
        if (fsAccessRule == null)
            continue;

        if ((fsAccessRule.FileSystemRights & FileSystemRights.WriteData) > 0)
        {
            NTAccount ntAccount = rule.IdentityReference as NTAccount;
            if (ntAccount == null)
            {
                continue;
            }

            if (principal.IsInRole(ntAccount.Value))
            {
                Console.WriteLine("Current user is in role of {0}, has write access", ntAccount.Value);
                continue;
            }
            Console.WriteLine("Current user is not in role of {0}, does not have write access", ntAccount.Value);                        
        }
    }
}
catch (UnauthorizedAccessException)
{
    Console.WriteLine("does not have write access");
}

Votre code obtient le DirectorySecuritypour un répertoire donné et gère correctement une exception (car vous n'avez pas accès aux informations de sécurité). Cependant, dans votre exemple, vous n'interrogez pas réellement l'objet retourné pour voir quel accès est autorisé - et je pense que vous devez l'ajouter.

Voici une version modifiée de la réponse de CsabaS , qui tient compte des règles d'accès de refus explicites. La fonction parcourt toutes les FileSystemAccessRules d'un répertoire et vérifie si l'utilisateur actuel est dans un rôle qui a accès à un répertoire. Si aucun de ces rôles n'est trouvé ou si l'utilisateur est dans un rôle avec un accès refusé, la fonction renvoie false. Pour vérifier les droits de lecture, transmettez FileSystemRights.Read à la fonction; pour les droits d'écriture, transmettez FileSystemRights.Write. Si vous souhaitez vérifier les droits d'un utilisateur arbitraire et non ceux en cours, remplacez le WindowsIdentity de WindowsIdentity par currentUser WindowsIdentity. Je déconseillerais également de s'appuyer sur des fonctions comme celle-ci pour déterminer si l'utilisateur peut utiliser le répertoire en toute sécurité. Cette réponse explique parfaitement pourquoi.

    public static bool UserHasDirectoryAccessRights(string path, FileSystemRights accessRights)
    {
        var isInRoleWithAccess = false;

        try
        {
            var di = new DirectoryInfo(path);
            var acl = di.GetAccessControl();
            var rules = acl.GetAccessRules(true, true, typeof(NTAccount));

            var currentUser = WindowsIdentity.GetCurrent();
            var principal = new WindowsPrincipal(currentUser);
            foreach (AuthorizationRule rule in rules)
            {
                var fsAccessRule = rule as FileSystemAccessRule;
                if (fsAccessRule == null)
                    continue;

                if ((fsAccessRule.FileSystemRights & accessRights) > 0)
                {
                    var ntAccount = rule.IdentityReference as NTAccount;
                    if (ntAccount == null)
                        continue;

                    if (principal.IsInRole(ntAccount.Value))
                    {
                        if (fsAccessRule.AccessControlType == AccessControlType.Deny)
                            return false;
                        isInRoleWithAccess = true;
                    }
                }
            }
        }
        catch (UnauthorizedAccessException)
        {
            return false;
        }
        return isInRoleWithAccess;
    }

Les solutions ci-dessus sont bonnes mais pour moi, je trouve ce code simple et réalisable. Créez simplement un fichier temporaire. Si le fichier est créé, son utilisateur moyen a l'accès en écriture.

        public static bool HasWritePermission(string tempfilepath)
        {
            try
            {
                System.IO.File.Create(tempfilepath + "temp.txt").Close();
                System.IO.File.Delete(tempfilepath + "temp.txt");
            }
            catch (System.UnauthorizedAccessException ex)
            {

                return false;
            }

            return true;
        }

Vous pouvez essayer le bloc de code suivant pour vérifier si le répertoire dispose d'un accès en écriture. Il vérifie le FileSystemAccessRule.

string directoryPath = "C:\\XYZ"; //folderBrowserDialog.SelectedPath;
bool isWriteAccess = false;
try
{
    AuthorizationRuleCollection collection =
        Directory.GetAccessControl(directoryPath)
            .GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount));
    foreach (FileSystemAccessRule rule in collection)
    {
        if (rule.AccessControlType == AccessControlType.Allow)
        {
            isWriteAccess = true;
            break;
        }
    }
}
catch (UnauthorizedAccessException ex)
{
    isWriteAccess = false;
}
catch (Exception ex)
{
    isWriteAccess = false;
}
if (!isWriteAccess)
{
    //handle notifications 
}

Vous avez une condition de concurrence potentielle dans votre code - que se passe-t-il si l'utilisateur dispose des autorisations d'écrire dans le dossier lorsque vous vérifiez, mais avant que l'utilisateur n'écrive réellement dans le dossier, cette autorisation est retirée? L'écriture lèvera une exception que vous devrez attraper et gérer. Le contrôle initial est donc inutile. Vous pouvez aussi bien écrire et gérer les exceptions. C'est le modèle standard pour votre situation.

http://www.codeproject.com/KB/files/UserFileAccessRights.aspx

Classe très utile, vérifiez la version améliorée dans les messages ci-dessous.

Essayer simplement d'accéder au fichier en question ne suffit pas nécessairement. Le test s'exécutera avec les autorisations de l'utilisateur exécutant le programme - Ce qui n'est pas nécessairement les autorisations utilisateur que vous souhaitez tester.

Je suis d'accord avec Ash, ça devrait aller. Sinon, vous pouvez utiliser CAS déclaratif et empêcher le programme de s'exécuter en premier lieu s'ils n'y ont pas accès.

Je crois que certaines des fonctionnalités CAS peuvent ne pas être présentes dans C # 4.0 d'après ce que j'ai entendu, je ne sais pas si cela pourrait être un problème ou non.

Je n'ai pas pu obtenir GetAccessControl () pour lever une exception sur Windows 7 comme recommandé dans la réponse acceptée.

J'ai fini par utiliser une variante de la réponse de sdds :

        try
        {
            bool writeable = false;
            WindowsPrincipal principal = new WindowsPrincipal(WindowsIdentity.GetCurrent());
            DirectorySecurity security = Directory.GetAccessControl(pstrPath);
            AuthorizationRuleCollection authRules = security.GetAccessRules(true, true, typeof(SecurityIdentifier));

            foreach (FileSystemAccessRule accessRule in authRules)
            {

                if (principal.IsInRole(accessRule.IdentityReference as SecurityIdentifier))
                {
                    if ((FileSystemRights.WriteData & accessRule.FileSystemRights) == FileSystemRights.WriteData)
                    {
                        if (accessRule.AccessControlType == AccessControlType.Allow)
                        {
                            writeable = true;
                        }
                        else if (accessRule.AccessControlType == AccessControlType.Deny)
                        {
                            //Deny usually overrides any Allow
                            return false;
                        }

                    } 
                }
            }
            return writeable;
        }
        catch (UnauthorizedAccessException)
        {
            return false;
        }

J'espère que cela t'aides.

J'ai rencontré le même problème: comment vérifier si je peux lire / écrire dans un répertoire particulier. Je me suis retrouvé avec la solution simple pour ... le tester. Voici ma solution simple mais efficace.

 class Program
{

    /// <summary>
    /// Tests if can read files and if any are present
    /// </summary>
    /// <param name="dirPath"></param>
    /// <returns></returns>
    private genericResponse check_canRead(string dirPath)
    {
        try
        {
            IEnumerable<string> files = Directory.EnumerateFiles(dirPath);
            if (files.Count().Equals(0))
                return new genericResponse() { status = true, idMsg = genericResponseType.NothingToRead };

            return new genericResponse() { status = true, idMsg = genericResponseType.OK };
        }
        catch (DirectoryNotFoundException ex)
        {

            return new genericResponse() { status = false, idMsg = genericResponseType.ItemNotFound };

        }
        catch (UnauthorizedAccessException ex)
        {

            return new genericResponse() { status = false, idMsg = genericResponseType.CannotRead };

        }

    }

    /// <summary>
    /// Tests if can wirte both files or Directory
    /// </summary>
    /// <param name="dirPath"></param>
    /// <returns></returns>
    private genericResponse check_canWrite(string dirPath)
    {

        try
        {
            string testDir = "__TESTDIR__";
            Directory.CreateDirectory(string.Join("/", dirPath, testDir));

            Directory.Delete(string.Join("/", dirPath, testDir));


            string testFile = "__TESTFILE__.txt";
            try
            {
                TextWriter tw = new StreamWriter(string.Join("/", dirPath, testFile), false);
                tw.WriteLine(testFile);
                tw.Close();
                File.Delete(string.Join("/", dirPath, testFile));

                return new genericResponse() { status = true, idMsg = genericResponseType.OK };
            }
            catch (UnauthorizedAccessException ex)
            {

                return new genericResponse() { status = false, idMsg = genericResponseType.CannotWriteFile };

            }


        }
        catch (UnauthorizedAccessException ex)
        {

            return new genericResponse() { status = false, idMsg = genericResponseType.CannotWriteDir };

        }
    }


}

public class genericResponse
{

    public bool status { get; set; }
    public genericResponseType idMsg { get; set; }
    public string msg { get; set; }

}

public enum genericResponseType
{

    NothingToRead = 1,
    OK = 0,
    CannotRead = -1,
    CannotWriteDir = -2,
    CannotWriteFile = -3,
    ItemNotFound = -4

}

J'espère que ça aide !

La plupart des réponses ici ne vérifient pas l'accès en écriture. Il vérifie simplement si l'utilisateur / groupe peut «lire l'autorisation» (lire la liste ACE du fichier / répertoire).

Également itérer via ACE et vérifier s'il correspond à l'identificateur de sécurité ne fonctionne pas car l'utilisateur peut être membre d'un groupe dont il pourrait obtenir / perdre des privilèges. Pire encore, ce sont les groupes imbriqués.

Je sais que c'est un vieux fil mais il y a une meilleure façon pour quiconque regarde maintenant.

À condition que l'utilisateur dispose du privilège d'autorisation de lecture, on peut utiliser l'API Authz pour vérifier l'accès effectif.

https://docs.microsoft.com/en-us/windows/win32/secauthz/using-authz-api

https://docs.microsoft.com/en-us/windows/win32/secauthz/checking-access-with-authz-api