Código C# para comprobar permisos de un fichero

Si eres uno de los que está más que harto de no encontrar un código en condiciones para comprobar si un fichero tiene permisos de lectura y escritura entonces has llegado al sitio indicado.

private static bool TienePermisosUsuarioImpersonalizado(string rutaFisica)
{
    bool resultado = false;

    // Esta variable pretende evitar que salte la excepción de no tener permniso cuando se lanza File.Exists
    bool existeRuta = false;

    // Obtiene el usuario que lanza la aplicación en la máquina
    WindowsIdentity identity = WindowsIdentity.GetCurrent();
            
    try
    {
        // NOTA : RublenX - Se podría comprobar por FileIOPermission para comprobar File.Exists pero como da una excepción igualmente no se hace así
        // Más info en : http://msdn.microsoft.com/es-es/library/vstudio/system.security.permissions.fileiopermission(v=vs.100).aspx
        existeRuta = File.Exists(rutaFisica);
    }
    catch (SecurityException)
    {
        // Si no hay permisos ni siquiera para acceder al fichero entonces se da por excluido
        existeRuta = false;
    }

    if (!string.IsNullOrEmpty(rutaFisica) && identity != null && existeRuta)
    {
        // Primero comprueba que el fichero no esté en modo sólo lectura
        FileAttributes atributos = File.GetAttributes(rutaFisica);
        if ((atributos & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
        {
            resultado = false;
        }
        else
        {
            // Ahora comprueba que el usuario logado tiene permisos de escritura y lectura
            FileSecurity fSecurity = File.GetAccessControl(rutaFisica);
            if (fSecurity != null)
            {
                AuthorizationRuleCollection rules = fSecurity.GetAccessRules(true, true, typeof(SecurityIdentifier));

                // Recorre las reglas para todos los usuarios incluidos
                foreach (AuthorizationRule rule in rules)
                {
                    FileSystemAccessRule ruleConvertida = rule as FileSystemAccessRule;

                    if (ruleConvertida != null)
                    {
                        // NOTA : RublenX Tal vez se podía haber hecho con Environment.UserName, pero esta forma me gusta mucho más ya que es el usuario que
                        // ha lanzado la aplicación
                        if (ruleConvertida.IdentityReference.Value == identity.Owner.Value && ruleConvertida.AccessControlType == AccessControlType.Allow && (ruleConvertida.FileSystemRights & (FileSystemRights.Read | FileSystemRights.Write)) == (FileSystemRights.Read | FileSystemRights.Write))
                        {
                            // Una de sus reglas es del usuario que ha lanzado la aplicación con permisos de lectura y escritura
                            resultado = true;
                            break;
                        }
                    }
                }
            }
        }
    }
    return resultado;
}

El código es capaz de comprobar si el usuario que lanza la aplicación es capaz de llegar primero al fichero, luego comprueba que no está en modo de sólo lectura, para terminar recorriendo los permisos de ese usuario y ver si son de lectura y escritura.

También puede pasar que necesitéis suplantar el usuario original que ha lanzado la aplicación por otro que tenga permisos de lectura y escritura. En ese caso la siguiente clase os puede ser muy útil:

using System;
using System.Runtime.InteropServices;
using System.Security.Principal;

namespace RublenX.PermisosDeAcceso
{
    /// <summary>
    /// Clase que permite suplantar el usuario identificado que ejecuta la aplicación en la máquina servidora
    /// </summary>
    public class SuplantarUsuarioIISBL : IDisposable
    {
        #region Librerías Externas
        public const int LOGON32_LOGON_INTERACTIVE = 2;
        public const int LOGON32_PROVIDER_DEFAULT = 0;

        WindowsImpersonationContext impersonationContext;

        [DllImport("advapi32.dll")]
        public static extern int LogonUserA(String lpszUserName,
            String lpszDomain,
            String lpszPassword,
            int dwLogonType,
            int dwLogonProvider,
            ref IntPtr phToken);
        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        public static extern int DuplicateToken(IntPtr hToken,
            int impersonationLevel,
            ref IntPtr hNewToken);

        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        public static extern bool RevertToSelf();

        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        public static extern bool CloseHandle(IntPtr handle); 
        #endregion

        #region Métodos Públicos
        /// <summary>
        /// Inicia la suplantación de usuario por el indicado en los parámetros
        /// </summary>
        /// <param name="userName">Usuario</param>
        /// <param name="domain">Dominio de autenticación</param>
        /// <param name="password">Contraseña</param>
        /// <returns>True si consigue validar al usuario e impersonalizarlo</returns>
        public bool ImpersonateValidUser(String userName, String domain, String password)
        {
            if (!string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(domain))
            {
                WindowsIdentity tempWindowsIdentity;
                IntPtr token = IntPtr.Zero;
                IntPtr tokenDuplicate = IntPtr.Zero;

                if (RevertToSelf())
                {
                    if (LogonUserA(userName, domain, password, LOGON32_LOGON_INTERACTIVE,
                        LOGON32_PROVIDER_DEFAULT, ref token) != 0)
                    {
                        if (DuplicateToken(token, 2, ref tokenDuplicate) != 0)
                        {
                            tempWindowsIdentity = new WindowsIdentity(tokenDuplicate);
                            impersonationContext = tempWindowsIdentity.Impersonate();
                            if (impersonationContext != null)
                            {
                                CloseHandle(token);
                                CloseHandle(tokenDuplicate);
                                return true;
                            }
                        }
                    }
                }
                if (token != IntPtr.Zero)
                    CloseHandle(token);
                if (tokenDuplicate != IntPtr.Zero)
                    CloseHandle(tokenDuplicate); 
            }
            return false;
        }

        /// <summary>
        /// Devuelve la suplantación del usuario al original
        /// </summary>
        public void UndoImpersonation()
        {
            if (impersonationContext != null)
            {
                impersonationContext.Undo();
                impersonationContext.Dispose();
                impersonationContext = null;
            }
        }
        #endregion

        #region Implementación de la interfaz
        /// <summary>
        /// Revierte la suplantación de identidad si es que se ha producido y libera todos los recursos utilizados
        /// </summary>
        public void Dispose()
        {
            UndoImpersonation();
        } 
        #endregion
    }
}

Y por tanto la forma correcta de invocarlo uniendo los dos sería de esta forma:

/// <summary>
/// Comprueba si el fichero tiene permisos de lectura y escritura para el usuario indicado
/// </summary>
/// <param name="rutaFisica">Ruta del fichero</param>
/// <param name="identity">Usuario del que se obtendrán los permiosos (por ejemplo el actual WindowsIdentity.GetCurrent())</param>
/// <returns>Verdadero si tiene los permisos de lectura y escritura</returns>
public static bool TienePermisosLecturaEscritura(string rutaFisica)
{
    // Resultado de la validación
    bool resultado = false;

    // Datos del usuario a autenticar
    string u = ConfigurationManager.AppSettings["UsuariosAppLocalAutorizados.LecturaEscrituraDiscoUsuario"];
    string d = ConfigurationManager.AppSettings["UsuariosAppLocalAutorizados.LecturaEscrituraDiscoDominio"];
    string p = ConfigurationManager.AppSettings["UsuariosAppLocalAutorizados.LecturaEscrituraDiscoPassword"];

    using (SuplantarUsuarioIISBL suplantarUsuarioBL = new SuplantarUsuarioIISBL())
    {
        if (string.IsNullOrEmpty(u))
        {
            resultado = TienePermisosUsuarioImpersonalizado(rutaFisica);
        }
        else if (suplantarUsuarioBL.ImpersonateValidUser(u, d, p))
        {
            resultado = TienePermisosUsuarioImpersonalizado(rutaFisica);
        }
        else
        {
            // Personalizar la excepción como os venga en gana             
            throw new Exception("Error en la aplicación");
        }
    }

    // Devuelve el resultaod de la validación de permisos
    return resultado;
}

Espero que os guste.

Anuncio publicitario