यदि उपयोगकर्ता ने किसी फ़ोल्डर में पहुंच लिखी है तो C # टेस्ट

Question

मुझे परीक्षण करने की आवश्यकता है कि क्या वास्तव में ऐसा करने का प्रयास करने से पहले उपयोगकर्ता फ़ोल्डर में लिख सकता है।

मैंने निम्नलिखित विधि (C # 2.0 में) लागू की है जो निर्देशिका के लिए फ़ोल्डर के लिए सुरक्षा अनुमतियों को पुनः प्राप्त करने का प्रयास करता है। 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;
    }
}

जब मैं लिख रहा था कि लिखने के लिए परीक्षण कैसे किया जाए तो ऐसा कुछ नहीं हुआ और यह वास्तव में विंडोज में अनुमतियों का परीक्षण करने के लिए बहुत जटिल दिखाई दिया। मुझे चिंता है कि मैं चीजों को सरल बना रहा हूं और यह तरीका मजबूत नहीं है, हालांकि यह काम करने लगता है।

यदि वर्तमान उपयोगकर्ता ने पहुंच के काम को सही ढंग से लिखा है, तो क्या मेरी पद्धति का परीक्षण किया जाएगा?

Comments

क्या अनुमतियों को देखने की पहुंच वास्तव में वैसी नहीं है जैसी इसे लिखने की अनुमति नहीं है?

— deed02392

Answer 1

यह C # में फ़ोल्डर एक्सेस के लिए जाँच करने के लिए एक पूरी तरह से वैध तरीका है। एकमात्र स्थान यह नीचे गिर सकता है यदि आपको इसे एक तंग लूप में कॉल करने की आवश्यकता है जहां एक अपवाद का ओवरहेड एक मुद्दा हो सकता है।

ऐसे ही अन्य प्रश्न पहले भी पूछे जा चुके हैं।

Comments

मजेदार रूप से मेरे पास उन अन्य प्रश्नों में से एक था जो किसी अन्य टैब में खुले थे, लेकिन DirectorySecurity के बारे में उत्तर नहीं देखा था, मुझे सभी उत्तरों को पढ़ने के लिए सिखाएं, जो केवल स्वीकृत एक ;-)

— क्रिस बी

जब आप विंडोज में लंबे रास्तों का उपयोग करते हैं तो यह भी नहीं गिरता है?

— अलेक्जेंड्रू

यदि आपको लिखित अनुमति है तो यह आपको नहीं बताएगा, यह केवल आपको बताएगा कि आप उस फ़ोल्डर पर अनुमति देख सकते हैं या नहीं। इसके अलावा, आप लिखने में सक्षम हो सकते हैं, लेकिन अनुमति नहीं देख सकते हैं।

— randomEngy

Answer 2

मैं सराहना करता हूं कि इस पोस्ट के लिए दिन में थोड़ी देर है, लेकिन आपको यह कोड उपयोगी लग सकता है।

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

एक कंसोल ऐप में ड्रॉप करें और देखें कि क्या यह आपकी ज़रूरत है।

Comments

सीधा निशाने पर! मेरी बहुत मदद करता है!

— smwikipedia

मुझे कॉल पर अपवाद मिलता है, GetAccessControlलेकिन मेरा सॉफ़्टवेयर वास्तविक रूप से उस निर्देशिका को लिखने में सक्षम है जिसे मैं देख रहा हूं ..?

— जॉन केज

@JonCage - आपको कौन सा अपवाद मिल रहा है? पहली बात जो दिमाग में आती है, वह है, विडंबना, एक सुरक्षा समस्या। क्या खाता जो आपका ऐप चल रहा है, उसे एसीएल जानकारी प्राप्त करने की अनुमति है?

— डंकन होवे

आपको FileSystemAccessRule प्रकार के लिए एक चेक जोड़ने की आवश्यकता है। यदि यह अस्वीकार्य नियम है, तो आप इसे गलत तरीके से लिखने योग्य बताएंगे।

— tdemay

मैं इसका इस्तेमाल करने की कोशिश कर रहा हूं। एक और समस्या मिली। यदि अधिकार केवल समूहों को दिए जाते हैं और विशिष्ट उपयोगकर्ताओं को नहीं, तो यह गलत तरीके से रिपोर्ट करेगा कि उनके पास पहुंच नहीं है। उदाहरण के लिए, "प्रमाणित उपयोगकर्ता" तक पहुंच प्रदान करें

— tdemay

Answer 3

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

Comments

यह उत्तर उन सभी अपवादों को पकड़ लेगा जो किसी फ़ाइल को लिखने की कोशिश करते समय हो सकते हैं, न कि केवल अनुमति के उल्लंघन के कारण।

— मैट एलेन

@ जी, string tempFileName = Path.GetRandomFileName();जाहिर है

— एलेक्सी

@Matt, यह पूछे गए प्रश्न का सटीक उत्तर देता है "यह निर्देशिका योग्य है" हालांकि, विफलता के कारण की परवाह किए बिना। आप इसके बजाय " मैं निर्देशिका में क्यों नहीं लिख सकता हूं " का उत्तर दें। :)

— एलेक्सी खोरोशिख

मुझे इस कोड के साथ एक गलत पॉजिटिव मिला है। File.Create () ठीक चलता है (और यदि आप अंतिम विकल्प बदलते हैं तो एक अस्थायी फ़ाइल छोड़ देता है) भले ही निष्पादित उपयोगकर्ता को उस फ़ोल्डर में लिखने की कोई अनुमति नहीं है। वास्तव में वास्तव में अजीब है - एक घंटा बिताने की कोशिश कर रहा हूं कि क्यों, लेकिन मैं स्टम्प्ड हूं।

— निक

सभी विकल्पों से जो मैंने नीचे दिए गए (और संदर्भित लिंक) की कोशिश की है - यह एकमात्र ऐसा है जो मज़बूती से काम करता है।

— TarmoPikaro

Answer 4

मैंने इनमें से अधिकांश की कोशिश की, लेकिन वे एक ही कारण के लिए, सभी को झूठी सकारात्मकता देते हैं .. यह उपलब्ध अनुमति के लिए निर्देशिका का परीक्षण करने के लिए पर्याप्त नहीं है, आपको यह जांचना होगा कि लॉग इन उपयोगकर्ता उस समूह का सदस्य है जिसके पास है अनुमति। ऐसा करने के लिए आपको उपयोगकर्ताओं की पहचान मिलती है, और यह जांचें कि क्या यह किसी ऐसे समूह का सदस्य है जिसमें 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;
    }

Comments

धन्यवाद जॉन, मुझे झूठी सकारात्मक मिली है जब तक कि मैं आपके कोड का उपयोग करके उपयोगकर्ता समूह को फिर से पहचानने के लिए नियम पहचानता हूं!

— पॉल एल

मुझे पहचान के लिए एक अतिरिक्त चेक जोड़ना था। नियोजक == rule.IdentityReference क्योंकि मेरे पास एक उपयोगकर्ता था जिसने पहुंच प्रदान की थी, लेकिन किसी भी समूह में नहीं, सेवाओं के लिए एक समर्पित स्थानीय खाते की तरह

— grinder22

AccessControlType इनकार करने की अनुमति देने में पूर्वता लेता है, इसलिए पूरी तरह से पूरी तरह से नियम होने के लिए कि एक्सेस अधिकार को अस्वीकार करने के साथ ही जाँच की जानी चाहिए, और जब इनकार के प्रकारों के लिए जाँच की जानी चाहिए (AccessRight & rule.FileSystemRights) > 0क्योंकि किसी भी उप पहुँच प्रकार से इनकार किया गया है AccessRightजिसका मतलब है कि आप पूर्ण नहीं हैं। एक्सेसAccessRight

— टीजे रॉकफेलर

जैसा कि ऊपर वर्णित ग्राइंडर 22, मुझे बदलने की आवश्यकता थी; if (पहचान ।Groups.Contains (rule .dentityReference)) अगर (identity.Groups.Contains (rule.IdentityReference)) || पहचान। किसी भी समूह में टी।

— अहम्ब्राइट

Answer 5

उदाहरण के लिए सभी उपयोगकर्ताओं (अंतर्निहित उपयोगकर्ता) के लिए, यह विधि ठीक काम करती है - आनंद लें।

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

Answer 6

IMHO परीक्षण करने के लिए केवल 100% विश्वसनीय तरीका है यदि आप एक निर्देशिका में लिख सकते हैं तो वास्तव में इसे लिखना है और अंततः अपवादों को पकड़ना है।

Answer 7

इसे इस्तेमाल करे:

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

Comments

अगर मैं गलत नहीं हूं, तो यह करीब है, लेकिन काफी नहीं है - यह इस तथ्य को अनदेखा करता है जो fsAccessRule.AccessControlTypeहो सकता है AccessControlType.Deny।

— जोनाथन गिल्बर्ट

यह मेरे लिए मेरे Win7 देव मशीन पर काम कर रहा था, लेकिन Win10 (एक परीक्षक और मेरी अपनी परीक्षण मशीन दोनों के लिए) पर विफल रहता है। ssds का संशोधन (नीचे देखें) इसे ठीक करने के लिए प्रकट होता है।

— winwaed

Answer 8

आपका कोड DirectorySecurityकिसी दिए गए निर्देशिका के लिए मिलता है , और एक अपवाद को संभालता है (सुरक्षा जानकारी तक आपकी पहुंच नहीं होने के कारण) सही ढंग से। हालाँकि, आपके नमूने में आप वास्तव में लौटी हुई वस्तु से पूछताछ नहीं करते हैं कि क्या देखने की अनुमति है - और मुझे लगता है कि आपको इसे जोड़ने की आवश्यकता है।

Comments

+1 - मैं अभी इस समस्या में भाग गया था जहाँ GetAccessControl कहते समय एक अपवाद नहीं फेंका गया था, फिर भी मुझे उसी निर्देशिका में लिखने का प्रयास करते समय एक अनधिकृत अपवाद मिलता है।

— मेयो

Answer 9

यहाँ CsabaS के उत्तर का एक संशोधित संस्करण दिया गया है , जिसमें स्पष्ट अस्वीकार्य नियमों का वर्णन है। फ़ंक्शन किसी निर्देशिका के लिए सभी FileSystemAccessRules के माध्यम से जाता है, और यदि वर्तमान उपयोगकर्ता एक निर्देशिका तक पहुंच है, तो यह भूमिका निभाता है। यदि इस तरह की कोई भूमिका नहीं मिली है या उपयोगकर्ता अस्वीकृत पहुंच वाली भूमिका में है, तो फ़ंक्शन गलत है। रीड राइट्स की जांच करने के लिए, फंक्शन के लिए FileSystemRights.Read पास करें; राइट राइट्स के लिए, FileSystemRights.Write पास करें। यदि आप उपयोगकर्ता के अधिकारों की जांच करना चाहते हैं और वर्तमान को नहीं, तो वांछित WindowsIdentity के लिए currentUser 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;
    }

Comments

विंडोज 10 (लेकिन मेरे Win7 देव मशीन पर ठीक है) पर मेरे लिए Csaba का कोड विफल हो रहा था। उपरोक्त समस्या को ठीक करने के लिए प्रकट होता है।

— winwaed

Answer 10

उपरोक्त समाधान अच्छे हैं लेकिन मेरे लिए, मुझे यह कोड सरल और व्यावहारिक लगता है। बस एक अस्थायी फ़ाइल बनाएँ। यदि फ़ाइल बनाई गई है, तो इसके माध्य उपयोगकर्ता के पास लिखने की सुविधा है।

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

Comments

अच्छा! एक बात है, हालांकि उपयोगकर्ता हो सकता है Createकी अनुमति नहीं है, लेकिन Deleteजो मामले में यह गलत भी वापसी होगी ही उपयोगकर्ता करता है लिखने की अनुमति।

— क्रिस बी

कोडिंग के लिए सबसे सुविधाजनक उत्तर :) मैं यह केवल एक का उपयोग करता हूं, हालांकि, जब बड़े समवर्ती अनुरोध होते हैं तो बहुत अधिक पढ़ने / लिखने से प्रदर्शन धीमा हो सकता है इसलिए उन मामलों में आप एक्सेसकंट्रोल कार्यप्रणाली का उपयोग कर सकते हैं जैसा कि अन्य उत्तरों में दिया गया है।

— vibs2006

Path.Combineजैसे कि उपयोग करेंPath.Combine(tempfilepath, "temp.txt") ।

— 17मेगामैन

Answer 11

यदि निर्देशिका लिख ​​रहा है तो एक्सेस करने के लिए आप कोड ब्लॉक का पालन कर सकते हैं। यह 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 
}

Answer 12

आपके पास अपने कोड में एक संभावित दौड़ की स्थिति है - अगर आपके पास चेक करने के लिए उपयोगकर्ता के पास फ़ोल्डर में लिखने की अनुमति है तो क्या होगा, लेकिन उपयोगकर्ता द्वारा फ़ोल्डर में लिखने से पहले यह अनुमति वापस ले ली जाती है? लेखन एक अपवाद फेंक देगा जिसे आपको पकड़ने और संभालने की आवश्यकता होगी। इसलिए प्रारंभिक जाँच व्यर्थ है। आप केवल लेखन ही कर सकते हैं और किसी भी अपवाद को संभाल सकते हैं। यह आपकी स्थिति के लिए मानक पैटर्न है।

Answer 13

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

बहुत उपयोगी क्लास, संदेशों में बेहतर संस्करण के लिए जाँच करें।

Answer 14

बस सवाल में फ़ाइल का उपयोग करने की कोशिश करना जरूरी नहीं है। परीक्षण कार्यक्रम चलाने वाले उपयोगकर्ता की अनुमतियों के साथ चलेगा - जो जरूरी नहीं कि उपयोगकर्ता अनुमतियाँ आप के खिलाफ परीक्षण करना चाहते हैं।

Answer 15

मैं ऐश से सहमत हूं, यह ठीक होना चाहिए। वैकल्पिक रूप से आप घोषणात्मक CAS का उपयोग कर सकते हैं और वास्तव में कार्यक्रम को पहली जगह पर चलने से रोक सकते हैं यदि उनके पास पहुंच नहीं है।

मेरा मानना ​​है कि कैस के कुछ फीचर्स C # 4.0 में मौजूद नहीं हो सकते हैं, जो मैंने सुना है, यकीन नहीं होता कि यह एक मुद्दा हो सकता है या नहीं।

Answer 16

मुझे स्वीकार किए गए उत्तर में अनुशंसित के रूप में विंडोज 7 पर एक अपवाद को फेंकने के लिए GetAccessControl () नहीं मिल सका।

मैंने 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;
        }

उम्मीद है की यह मदद करेगा।

Answer 17

मुझे एक ही समस्या का सामना करना पड़ा: किसी विशेष निर्देशिका में पढ़ने / लिखने के लिए मुझे कैसे सत्यापित करना है। मैं आसान समाधान के साथ समाप्त हुआ ... वास्तव में इसका परीक्षण करें। यहाँ मेरा सरल हालांकि प्रभावी समाधान है।

 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

}

आशा करता हूँ की ये काम करेगा !

Answer 18

यहां अधिकांश उत्तर लिखने की पहुंच की जांच नहीं करते हैं। बस यह जांचें कि क्या उपयोगकर्ता / समूह Read रीड परमिशन ’(फ़ाइल / निर्देशिका की एसीई सूची पढ़ें) कर सकते हैं।

एसीई के माध्यम से पुनरावृत्ति करना और यह जाँचना कि वह सुरक्षा पहचानकर्ता से मेल खाता है या नहीं, क्योंकि उपयोगकर्ता उस समूह का सदस्य हो सकता है जहाँ से उसे विशेषाधिकार मिल सकता है / खो सकता है। इससे भी बदतर है नेस्टेड समूह।

मुझे पता है कि यह एक पुराना धागा है लेकिन अब किसी भी एक के लिए एक बेहतर तरीका है।

बशर्ते उपयोगकर्ता के पास Read Permission विशेषाधिकार है, कोई भी प्रभावी पहुंच की जांच करने के लिए 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