Prueba de C # si el usuario tiene acceso de escritura a una carpeta

Necesito probar si un usuario puede escribir en una carpeta antes de intentar hacerlo.

Implementé el siguiente método (en C # 2.0) que intenta recuperar los permisos de seguridad para la carpeta usando el método 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;
    }
}

Cuando busqué en Google cómo probar el acceso de escritura, no apareció nada como esto y parecía muy complicado probar los permisos en Windows. Me preocupa que estoy simplificando demasiado las cosas y que este método no es robusto, aunque parece funcionar.

¿Mi método para probar si el usuario actual tiene acceso de escritura funcionará correctamente?

Esa es una forma perfectamente válida de verificar el acceso a la carpeta en C #. El único lugar donde podría caerse es si necesita llamar a esto en un ciclo cerrado donde la sobrecarga de una excepción puede ser un problema.

Ha habido otras preguntas similares formuladas anteriormente.

Aprecio que esto sea un poco tarde para esta publicación, pero es posible que este código sea útil.

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

Deje caer eso en una aplicación de consola y vea si hace lo que necesita.

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

Intenté la mayoría de estos, pero dan falsos positivos, todo por la misma razón. No es suficiente probar el directorio para obtener un permiso disponible, debe verificar que el usuario conectado sea miembro de un grupo que tiene ese permiso. Para hacer esto, obtiene la identidad de los usuarios y comprueba si es miembro de un grupo que contiene FileSystemAccessRule IdentityReference. He probado esto, funciona perfectamente ...

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

En mi humilde opinión, la única forma 100% confiable de probar si puede escribir en un directorio es escribir en él y, finalmente, detectar excepciones.

Por ejemplo, para todos los usuarios (Builtin \ Users), este método funciona bien: disfrute.

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

Prueba esto:

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

Su código obtiene el DirectorySecurityde un directorio dado y maneja una excepción (debido a que no tiene acceso a la información de seguridad) correctamente. Sin embargo, en su muestra, en realidad no interroga al objeto devuelto para ver qué acceso está permitido, y creo que debe agregarlo.

Aquí hay una versión modificada de la respuesta de CsabaS , que explica las reglas explícitas de acceso denegado . La función pasa por todos los FileSystemAccessRules para un directorio, y verifica si el usuario actual está en un rol que tiene acceso a un directorio. Si no se encuentran tales roles o el usuario está en un rol con acceso denegado, la función devuelve falso. Para verificar los derechos de lectura, pase FileSystemRights.Read a la función; para derechos de escritura, pase FileSystemRights.Write. Si desea verificar los derechos de un usuario arbitrario y no los actuales, sustituya la identidad de Windows del usuario actual por la identidad de Windows deseada. También recomendaría no confiar en funciones como esta para determinar si el usuario puede usar el directorio de manera segura. Esta respuesta explica perfectamente por qué.

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

Las soluciones anteriores son buenas, pero para mí, este código me parece simple y viable. Simplemente cree un archivo temporal. Si se crea el archivo, su usuario medio tiene acceso de escritura.

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

Puede intentar seguir el siguiente bloque de código para verificar si el directorio tiene acceso de escritura. Comprueba la 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 
}

Tiene una posible condición de carrera en su código: ¿qué sucede si el usuario tiene permisos para escribir en la carpeta cuando verifica, pero antes de que el usuario realmente escriba en la carpeta, se retira este permiso? La escritura arrojará una excepción que deberá atrapar y manejar. Entonces la verificación inicial no tiene sentido. También podría escribir y manejar cualquier excepción. Este es el patrón estándar para su situación.

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

Clase muy útil, verifique la versión mejorada en los mensajes a continuación.

Simplemente intentar acceder al archivo en cuestión no es necesariamente suficiente. La prueba se ejecutará con los permisos del usuario que ejecuta el programa, que no son necesariamente los permisos de usuario con los que desea probar.

Estoy de acuerdo con Ash, eso debería estar bien. Alternativamente, podría usar CAS declarativa y evitar que el programa se ejecute en primer lugar si no tienen acceso.

Creo que algunas de las características de CAS pueden no estar presentes en C # 4.0 por lo que he escuchado, no estoy seguro de si eso podría ser un problema o no.

No pude obtener GetAccessControl () para lanzar una excepción en Windows 7 como se recomienda en la respuesta aceptada.

Terminé usando una variación de la respuesta 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;
        }

Espero que esto ayude.

Me enfrenté al mismo problema: cómo verificar si puedo leer / escribir en un directorio en particular. Terminé con la solución fácil para ... realmente probarlo. Aquí está mi solución simple pero efectiva.

 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

}

Espero eso ayude !

La mayoría de las respuestas aquí no verifican el acceso de escritura. Simplemente verifique si el usuario / grupo puede 'Leer permiso' (Lea la lista ACE del archivo / directorio).

También iterar a través de ACE y verificar si coincide con el Identificador de seguridad no funciona porque el usuario puede ser miembro de un grupo del que podría obtener / perder privilegios. Peor que eso son los grupos anidados.

Sé que este es un hilo viejo, pero hay una mejor manera para cualquiera que busque ahora.

Siempre que el usuario tenga el privilegio de permiso de lectura, se puede usar la API Authz para verificar el acceso efectivo.

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