การทดสอบ C # หากผู้ใช้มีสิทธิ์การเขียนไปยังโฟลเดอร์


187

ฉันต้องทดสอบว่าผู้ใช้สามารถเขียนไปยังโฟลเดอร์ก่อนที่จะพยายามทำเช่นนั้นจริง ๆ

ผมเคยนำมาใช้วิธีการดังต่อไปนี้ (ใน C # 2.0) ว่ามีความพยายามที่จะดึงสิทธิ์การรักษาความปลอดภัยสำหรับโฟลเดอร์โดยใช้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;
    }
}

เมื่อฉันทำ Google วิธีทดสอบการเข้าถึงการเขียนไม่มีอะไรเช่นนี้เกิดขึ้นและมันซับซ้อนมากที่จะทดสอบการอนุญาตใน Windows ฉันกังวลว่าฉันทำสิ่งต่าง ๆ ให้ง่ายเกินไปและวิธีนี้ไม่ได้มีประสิทธิภาพแม้ว่ามันจะดูเหมือนใช้งานได้

วิธีการของฉันจะทดสอบว่าผู้ใช้ปัจจุบันมีการเข้าถึงการเขียนทำงานอย่างถูกต้องหรือไม่?


13
ไม่สามารถเข้าถึงเพื่อดูสิทธิ์เช่นเดียวกับที่ไม่ได้รับอนุญาตให้เขียนมันได้หรือไม่
deed02392

คำตอบ:


61

นี่เป็นวิธีที่ถูกต้องในการตรวจสอบการเข้าถึงโฟลเดอร์ใน C # สถานที่เดียวที่มันอาจล้มลงคือถ้าคุณต้องการเรียกสิ่งนี้ในการวนรอบที่แน่นซึ่งค่าใช้จ่ายของข้อยกเว้นอาจเป็นปัญหา

มีคำถามที่คล้ายกัน อื่น ๆถามก่อนหน้านี้


1
ขันพอฉันมีหนึ่งคำถามอื่น ๆ เหล่านั้นเปิดในแท็บอื่น แต่ไม่เคยเห็นคำตอบเกี่ยวกับ DirectorySecurity ที่สอนฉันจะอ่านทุกคำตอบไม่เพียง แต่ได้รับการยอมรับอย่างใดอย่างหนึ่ง ;-)
คริส B

จะไม่ล้มลงเมื่อคุณใช้เส้นทางยาวใน Windows หรือไม่
Alexandru

11
นั่นจะไม่บอกคุณว่าคุณมีสิทธิ์ในการเขียนหรือไม่มันจะบอกคุณว่าคุณสามารถค้นหาการอนุญาตในโฟลเดอร์นั้นได้หรือไม่ นอกจากนี้คุณอาจสามารถเขียน แต่ไม่สามารถค้นหาสิทธิ์
RandomEngy

65

ฉันขอขอบคุณที่นี่สายไปเล็กน้อยในวันนี้สำหรับโพสต์นี้ แต่คุณอาจพบว่าโค้ดนี้มีประโยชน์

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

วางสิ่งนั้นลงในแอพคอนโซลและดูว่ามันทำในสิ่งที่คุณต้องการหรือไม่


ถูกต้องกับเป้าหมาย! ช่วยฉันมาก!
smwikipedia

ฉันได้รับการยกเว้นในการโทรGetAccessControlแต่ซอฟต์แวร์ของฉันเป็นจริงสามารถเขียนไปยังไดเรกทอรีที่ฉันกำลังดู .. ?
Jon Cage

@ JonCage - คุณได้รับข้อยกเว้นอะไรบ้าง สิ่งแรกที่เรานึกถึงก็คือปัญหาด้านความปลอดภัย บัญชีที่แอปของคุณทำงานนั้นมีสิทธิ์ในการรับข้อมูล ACL หรือไม่
Duncan Howe

1
คุณต้องเพิ่มการตรวจสอบสำหรับประเภท FileSystemAccessRule หากเป็นกฎปฏิเสธคุณจะรายงานว่าเขียนผิดได้
อังคารที่

2
ฉันพยายามใช้สิ่งนี้ พบปัญหาอื่น หากสิทธิ์ถูกกำหนดให้กับกลุ่มเท่านั้นและไม่ใช่ผู้ใช้ที่เฉพาะเจาะจงสิ่งนี้จะรายงานอย่างไม่ถูกต้องว่าพวกเขาไม่มีสิทธิ์ในการเขียน ตัวอย่างเช่นการเข้าถึงเพื่อเขียนที่มอบให้แก่ "ผู้ใช้ที่ได้รับการรับรองความถูกต้อง"
tdemay

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

7
คำตอบนี้จะตรวจจับข้อยกเว้นทั้งหมดที่อาจเกิดขึ้นเมื่อพยายามเขียนไฟล์ไม่ใช่แค่การละเมิดสิทธิ์
Matt Ellen

7
@GY, string tempFileName = Path.GetRandomFileName();ชัด
Alexey Khoroshikh

3
@ แมทคำตอบนี้ตรงกับคำถามที่ถาม "คือไดเร็กตอรี่นั้นเขียนได้" โดยไม่คำนึงถึงสาเหตุของความล้มเหลว คุณควรตอบ " ทำไมฉันไม่สามารถเขียนไปยังไดเรกทอรี" :)
Alexey Khoroshikh

1
ฉันได้รับผลบวกปลอมด้วยรหัสนี้ File.Create () รัน OK (และออกจากไฟล์ temp หากคุณเปลี่ยนตัวเลือกสุดท้าย) แม้ว่าผู้ใช้ที่ดำเนินการจะไม่มีสิทธิ์เขียนลงในโฟลเดอร์นั้น แปลกจริงๆจริง ๆ - ใช้เวลาหนึ่งชั่วโมงเพื่อหาสาเหตุว่าทำไม
NickG

4
จากทางเลือกทั้งหมดที่ฉันได้ลองด้านล่าง (และลิงค์อ้างอิง) - นี่เป็นสิ่งเดียวที่ทำงานได้อย่างน่าเชื่อถือ
TarmoPikaro

24

ฉันลองสิ่งเหล่านี้ส่วนใหญ่ แต่พวกเขาให้ผลบวกทั้งหมดด้วยเหตุผลเดียวกัน .. มันไม่เพียงพอที่จะทดสอบไดเรกทอรีสำหรับการอนุญาตที่มีอยู่คุณต้องตรวจสอบว่าผู้ใช้ที่เข้าสู่ระบบเป็นสมาชิกของกลุ่มที่มี การอนุญาต เมื่อต้องการทำสิ่งนี้คุณจะได้รับข้อมูลประจำตัวผู้ใช้และตรวจสอบว่าเป็นสมาชิกของกลุ่มที่มี FileSystemAccessRule IdentityReference ฉันได้ทดสอบสิ่งนี้แล้วทำงานได้อย่างไร้ที่ติ ..

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

ขอบคุณ John ฉันได้รับผลบวกปลอมเช่นกันจนกระทั่งฉันใช้รหัสของคุณเพื่อตรวจสอบกลุ่มผู้ใช้อีกครั้งกฎ IdentifyReference!
Paul L

1
ฉันต้องเพิ่มการตรวจสอบเพิ่มเติมสำหรับ identity.Owner == rule.IdentityReference เนื่องจากฉันมีผู้ใช้ที่ให้การเข้าถึง แต่ไม่ได้อยู่ในกลุ่มใด ๆ เช่นบัญชีท้องถิ่นเฉพาะสำหรับบริการ
โม่ 22

2
AccessControlType ปฏิเสธจะเหนือกว่าช่วยให้เพื่อที่จะเป็นกฎระเบียบอย่างละเอียดอย่างสมบูรณ์ที่ปฏิเสธการเข้าถึงที่เหมาะสมควรจะตรวจสอบเป็นอย่างดีและเมื่อตรวจสอบการปฏิเสธประเภทมันควรจะเป็น(AccessRight & rule.FileSystemRights) > 0เพราะการเข้าถึงใด ๆ ประเภทย่อยปฏิเสธว่าเป็นส่วนหนึ่งของAccessRightวิธีการที่คุณไม่ได้เต็มรูปแบบเข้าถึงAccessRight
TJ Rockefeller

ดังที่โม่โ 22 กล่าวไว้ข้างต้นฉันต้องเปลี่ยน if (identity.Groups.Contains (rule.IdentityReference)) ถึง if (identity.Groups.Contains (rule.IdentityReference) || identity.Owner.Equals (rule.IdentityReference) เนื่องจากฉันมีผู้ใช้ที่เข้าถึง แต่ไม่ได้ ' t ในกลุ่มใดก็ได้
ehambright

13

IMHO วิธีที่เชื่อถือได้เพียง 100% ในการทดสอบว่าคุณสามารถเขียนไปยังไดเรคทอรีได้คือการเขียนลงไปในไดเร็กตอรี่จริง ๆ และตรวจจับข้อยกเว้นในที่สุด


13

ตัวอย่างเช่นสำหรับผู้ใช้ทั้งหมด (Builtin \ Users) วิธีนี้ใช้งานได้ดี - เพลิดเพลิน

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

8

ลองสิ่งนี้:

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

ถ้าฉันไม่เข้าใจผิดนี่เป็นเรื่องใกล้ แต่ก็ไม่มากนัก - มันสามารถมองเห็นความจริงที่fsAccessRule.AccessControlTypeอาจเป็นAccessControlType.Denyไปได้
โจนาธานกิลเบิร์ต

สิ่งนี้ใช้ได้กับฉันบนเครื่อง Win7 dev ของฉัน แต่ล้มเหลวใน Win10 (ทั้งสำหรับผู้ทดสอบและเครื่องทดสอบของฉันเอง) การปรับเปลี่ยนของ ssds (ดูด้านล่าง) ดูเหมือนจะแก้ไขได้
winwaed

6

รหัสของคุณได้รับDirectorySecurityสำหรับไดเรกทอรีที่กำหนดและจัดการข้อยกเว้น (เนื่องจากคุณไม่สามารถเข้าถึงข้อมูลความปลอดภัย) ได้อย่างถูกต้อง อย่างไรก็ตามในตัวอย่างของคุณคุณไม่ได้ซักถามวัตถุที่ถูกส่งคืนเพื่อดูว่าอนุญาตการเข้าถึงใด - และฉันคิดว่าคุณต้องเพิ่มสิ่งนี้ใน


+1 - ฉันเพิ่งพบปัญหานี้ที่มีข้อยกเว้นไม่ถูกโยนเมื่อโทร GetAccessControl แต่ฉันได้รับข้อยกเว้นที่ไม่ได้รับอนุญาตเมื่อพยายามเขียนไปยังไดเรกทอรีเดียวกัน
Mayo

6

นี่คือคำตอบของ CsabaSรุ่นที่แก้ไขซึ่งบัญชีสำหรับกฎการเข้าถึงปฏิเสธอย่างชัดเจน ฟังก์ชั่นจะผ่าน FileSystemAccessRules ทั้งหมดสำหรับไดเรกทอรีและตรวจสอบว่าผู้ใช้ปัจจุบันอยู่ในบทบาทที่มีการเข้าถึงไดเรกทอรี หากไม่พบบทบาทดังกล่าวหรือผู้ใช้อยู่ในบทบาทที่ปฏิเสธการเข้าถึงฟังก์ชันจะส่งคืนค่าเท็จ เพื่อตรวจสอบสิทธิ์การอ่านผ่าน FileSystemRights.Read ไปยังฟังก์ชัน สำหรับสิทธิ์ในการเขียนผ่าน FileSystemRights.Write หากคุณต้องการตรวจสอบสิทธิ์ของผู้ใช้โดยพลการและไม่ใช่ของผู้ใช้ปัจจุบันให้แทนที่ผู้ใช้ WindowsIdentity ปัจจุบันสำหรับ WindowsIdentity ที่ต้องการ ฉันยังแนะนำให้ใช้ฟังก์ชันเช่นนี้เพื่อพิจารณาว่าผู้ใช้สามารถใช้ไดเรกทอรีได้อย่างปลอดภัยหรือไม่ คำตอบนี้อธิบายได้อย่างสมบูรณ์ว่าทำไม

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

รหัสของ Csaba ล้มเหลวสำหรับฉันใน Windows 10 (แต่ใช้ได้กับเครื่อง Win7 dev ของฉัน) ด้านบนปรากฏขึ้นเพื่อแก้ไขปัญหา
winwaed

4

วิธีแก้ปัญหาข้างต้นนั้นดี แต่สำหรับฉันฉันพบว่ารหัสนี้ง่ายและใช้การได้ เพียงสร้างไฟล์ชั่วคราว หากไฟล์ถูกสร้างขึ้นผู้ใช้จะมีสิทธิ์เข้าถึงการเขียน

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

3
ดี! สิ่งหนึ่งที่ผู้ใช้นั้นอาจได้Createรับอนุญาต แต่ไม่ใช่Deleteในกรณีนี้จะส่งคืนค่าเท็จแม้ว่าผู้ใช้จะมีสิทธิ์ในการเขียน
คริส B

คำตอบที่สะดวกที่สุดสำหรับการเข้ารหัส :) ฉันยังใช้อันนี้เท่านั้น แต่เมื่อมีการร้องขอพร้อมกันจำนวนมากดังนั้นการอ่าน / เขียนจำนวนมากอาจทำให้ประสิทธิภาพลดลงดังนั้นในกรณีเหล่านั้นคุณสามารถใช้วิธีการควบคุมการเข้าถึงตามคำตอบอื่น ๆ
vibs2006

1
ใช้แทนเช่นPath.Combine Path.Combine(tempfilepath, "temp.txt")
ΩmegaMan

3

คุณสามารถลองบล็อกรหัสต่อไปนี้เพื่อตรวจสอบว่าไดเรกทอรีมีการเขียนการเข้าถึง มันตรวจสอบ 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 
}

2

คุณมีสภาวะการแข่งขันที่เป็นไปได้ในรหัสของคุณ - จะเกิดอะไรขึ้นหากผู้ใช้มีสิทธิ์ในการเขียนไปยังโฟลเดอร์เมื่อคุณตรวจสอบ แต่ก่อนที่ผู้ใช้จะเขียนลงในโฟลเดอร์จริงสิทธิ์นี้จะถูกถอนออก? การเขียนจะทำให้เกิดข้อยกเว้นซึ่งคุณจะต้องจับและจัดการ ดังนั้นการตรวจสอบครั้งแรกจึงไม่มีประโยชน์ คุณก็อาจจะเขียนและจัดการกับข้อยกเว้น นี่เป็นรูปแบบมาตรฐานสำหรับสถานการณ์ของคุณ



1

การพยายามเข้าถึงไฟล์ที่เป็นปัญหานั้นไม่เพียงพอ การทดสอบจะดำเนินการโดยได้รับอนุญาตจากผู้ใช้ที่รันโปรแกรม - ซึ่งไม่จำเป็นว่าจะต้องได้รับอนุญาตจากผู้ใช้ที่คุณต้องการทดสอบ


0

ฉันเห็นด้วยกับ Ash ที่ควรจะดี อีกทางเลือกหนึ่งคือคุณสามารถใช้ CAS ที่มีการประกาศและป้องกันไม่ให้โปรแกรมทำงานในตอนแรกหากไม่สามารถเข้าถึงได้

ฉันเชื่อว่าคุณสมบัติบางอย่างของ CAS อาจไม่ปรากฏใน C # 4.0 จากสิ่งที่ฉันได้ยินไม่แน่ใจว่าอาจเป็นปัญหาหรือไม่


0

ฉันไม่สามารถรับ GetAccessControl () เพื่อโยนข้อยกเว้นใน Windows 7 ตามที่แนะนำในคำตอบที่ยอมรับได้

ฉันลงเอยด้วยการใช้คำตอบต่าง ๆ ของ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;
        }

หวังว่านี่จะช่วยได้


0

ฉันประสบปัญหาเดียวกัน: วิธีการตรวจสอบว่าฉันสามารถอ่าน / เขียนในไดเรกทอรีเฉพาะ ฉันลงเอยด้วยวิธีง่ายๆที่จะ ... ทดสอบจริง ๆ นี่คือทางออกที่เรียบง่าย แต่มีประสิทธิภาพของฉัน

 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

}

หวังว่ามันจะช่วย!


0

คำตอบส่วนใหญ่ที่นี่ไม่ได้ตรวจสอบการเข้าถึงเพื่อเขียน มันแค่ตรวจสอบว่าผู้ใช้ / กลุ่มสามารถ 'อ่านสิทธิ์' (อ่านรายการ ACE ของไฟล์ / ไดเรกทอรี)

การวนซ้ำผ่าน ACE และการตรวจสอบว่าตรงกับตัวระบุความปลอดภัยไม่ทำงานหรือไม่เนื่องจากผู้ใช้สามารถเป็นสมาชิกของกลุ่มที่เขาอาจได้รับ / สูญเสียสิทธิ์ ยิ่งกว่านั้นคือกลุ่มที่ซ้อนกัน

ฉันรู้ว่านี่เป็นเธรดเก่า แต่มีวิธีที่ดีกว่าสำหรับผู้ที่กำลังดูอยู่

ให้ผู้ใช้มีสิทธิ์อ่านอนุญาตคือหนึ่งสามารถใช้ Authz API เพื่อตรวจสอบการเข้าถึงที่มีประสิทธิภาพ

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

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.