.NET에서 디렉토리 및 파일 쓰기 권한 확인

내 .NET 2.0 응용 프로그램에서 디렉터리에 파일을 만들고 쓸 수있는 충분한 권한이 있는지 확인해야합니다. 이를 위해 파일을 생성하고 단일 바이트를 쓰려고 시도한 다음 권한이 있는지 테스트하기 위해 나중에 자신을 삭제하는 다음 기능이 있습니다.

확인하는 가장 좋은 방법은 실제로 발생하는 예외를 포착하여 실제로 시도하는 것이라고 생각했습니다. 나는 일반적인 Exception catch에 대해 특별히 만족스럽지 않습니다. 그래서 더 나은 방법이 있습니까?

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

Richard 와 Jason 의 대답 은 일종의 올바른 방향입니다. 그러나해야 할 일은 코드를 실행하는 사용자 ID에 대한 유효 권한 을 계산 하는 것입니다. 예를 들어 위의 예 중 어느 것도 그룹 멤버십을 올바르게 설명하지 않습니다.

Keith Brown 이 .NET Developers Guide to Windows Security의 위키 버전 (현재 오프라인)에서이 작업을 수행하는 코드가 있다고 확신 합니다. 이것은 그의 프로그래밍 Windows 보안 책 에서도 합리적으로 자세히 설명 합니다.

효과적인 권한을 계산하는 것은 희미한 마음이 아니며 코드가 파일을 만들고 throw 된 보안 예외를 잡으려는 시도는 아마도 저항이 가장 적은 경로 일 것입니다.

Directory.GetAccessControl(path) 당신이 요구하는 것을합니다.

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 "Flags"btw라는 것을 사용하고 있는데 이것이 무엇인지 모른다면 실제로 읽어야합니다. :)

Deny보다 우선합니다 Allow. 로컬 규칙은 상속 된 규칙보다 우선합니다. 여기에 표시된 일부 답변을 포함하여 많은 솔루션을 보았지만 그중 어느 것도 규칙이 상속 되는지 여부를 고려 하지 않습니다. 따라서 규칙 상속 (클래스로 깔끔하게 래핑 됨)을 고려하는 다음 접근 방식을 제안합니다.

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

그러나 원격 컴퓨터에서는 항상 파일 액세스 권한을 쿼리 할 수있는 권한이 없기 때문에 이것이 항상 작동하는 것은 아니라는 경험을했습니다. 이 경우 해결책은 시도하는 것입니다. "실제"파일로 작업하기 직전에 액세스 권한을 알아야하는 경우 임시 파일을 만들려고해도 가능합니다.

이 질문에 대한 Kev의 대답은 실제로 코드를 제공하는 것이 아니라 내가 액세스 할 수없는 다른 리소스를 가리 킵니다. 그래서 여기에 기능에 대한 최선의 시도가 있습니다. 실제로보고있는 권한이 "쓰기"권한이고 현재 사용자가 적절한 그룹에 속하는지 확인합니다.

네트워크 경로 또는 기타 사항과 관련하여 완전하지 않을 수 있지만 쓰기 가능성을 위해 "프로그램 파일"아래의 로컬 구성 파일을 확인하여 내 목적에는 충분합니다.

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에서는 평소와 같이 이러한 디렉터리로 작업해야하지만 사용 전에 권한을 확인하는 대신 UnauthorizedAccessException을 처리하고 그에 따라 대응하는 올바른 방법을 제공합니다. 이 방법은 더 쉽고 오류 발생 가능성이 훨씬 적습니다.

방금 만든이 C # 스 니펫으로 작업 해보세요.

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

그리고 여기 당신이 볼 수있는 참고 자료가 있습니다. 내 코드는 디렉토리에 쓰기를 시도하기 전에 권한을 확인하는 방법에 대한 아이디어를 줄 수 있습니다.

정적 메서드 'GetAccessControl'이 현재 버전의 .Net core / Standard에서 누락 된 것으로 보이므로 @Bryce Wagner의 답변을 수정해야했습니다 (계속 진행하여 더 현대적인 구문을 사용했습니다).

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

이 링크에 따르면 : http://www.authorcode.com/how-to-check-file-permission-to-write-in-c/

기존 클래스 SecurityManager를 사용하는 것이 더 쉽습니다.

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

그러나 더 이상 사용되지 않는 것 같습니다. 대신 PermissionSet을 사용하는 것이 좋습니다.

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

        }