Erreur pour FolderSecurity

Bonjour,

Depuis environ 1 ans, mon application roulait sans problème, et tout à coup, je reçois un message d'erreur sur la ligne "PurgeAccessRules"

le message est le suivant: Cette liste de contrôle d'accès n'est pas de forme canonique et ne peut donc pas être modifiée.

Ce bout de code sers à supprimer les droits d'un groupe sur un répertoire
Code:

1 2 3 4 5 6 folderSecurity = Directory.GetAccessControl(...); NTAccount acct = new NTAccount(AccountName); SecurityIdentifier id = (SecurityIdentifier)acct.Translate(typeof(SecurityIdentifier)); folderSecurity.PurgeAccessRules(id); Directory.SetAccessControl(DirectoryName, folderSecurity);
j'ai bien sûr demandé à notre admin de réseau s'il avait changé quelque chose mais il me dit que non... ce que je doute quelque peu...
quelqu'un pourrait m'aider à résoudre le problème?

Merci.

Bonjour,

le pc ou tu as l'erreur est il bien inscrit dans le domaine ?

Il faut vérifier les permission de l'AD apparemment vous êtes raillé ou vous manquer un mis a jours

Solution

En googellant, j'ai pu trouver une solution... je ne l'ai pas analyser encore car je suis dans un rush présentement...

j'exécute ce modele avant le purge, et ca fonctionne:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
static void CanonicalizeDacl(NativeObjectSecurity objectSecurity)
        {
            if (objectSecurity == null) { throw new ArgumentNullException("objectSecurity"); }
            if (objectSecurity.AreAccessRulesCanonical) { return; }
 
            // A canonical ACL must have ACES sorted according to the following order:
            //   1. Access-denied on the object
            //   2. Access-denied on a child or property
            //   3. Access-allowed on the object
            //   4. Access-allowed on a child or property
            //   5. All inherited ACEs 
            RawSecurityDescriptor descriptor = new RawSecurityDescriptor(objectSecurity.GetSecurityDescriptorSddlForm(AccessControlSections.Access));
 
            List<CommonAce> implicitDenyDacl = new List<CommonAce>();
            List<CommonAce> implicitDenyObjectDacl = new List<CommonAce>();
            List<CommonAce> inheritedDacl = new List<CommonAce>();
            List<CommonAce> implicitAllowDacl = new List<CommonAce>();
            List<CommonAce> implicitAllowObjectDacl = new List<CommonAce>();
 
            foreach (CommonAce ace in descriptor.DiscretionaryAcl)
            {
                if ((ace.AceFlags & AceFlags.Inherited) == AceFlags.Inherited) { inheritedDacl.Add(ace); }
                else
                {
                    switch (ace.AceType)
                    {
                        case AceType.AccessAllowed:
                            implicitAllowDacl.Add(ace);
                            break;
 
                        case AceType.AccessDenied:
                            implicitDenyDacl.Add(ace);
                            break;
 
                        case AceType.AccessAllowedObject:
                            implicitAllowObjectDacl.Add(ace);
                            break;
 
                        case AceType.AccessDeniedObject:
                            implicitDenyObjectDacl.Add(ace);
                            break;
                    }
                }
            }
 
            Int32 aceIndex = 0;
            RawAcl newDacl = new RawAcl(descriptor.DiscretionaryAcl.Revision, descriptor.DiscretionaryAcl.Count);
            implicitDenyDacl.ForEach(x => newDacl.InsertAce(aceIndex++, x));
            implicitDenyObjectDacl.ForEach(x => newDacl.InsertAce(aceIndex++, x));
            implicitAllowDacl.ForEach(x => newDacl.InsertAce(aceIndex++, x));
            implicitAllowObjectDacl.ForEach(x => newDacl.InsertAce(aceIndex++, x));
            inheritedDacl.ForEach(x => newDacl.InsertAce(aceIndex++, x));
 
            if (aceIndex != descriptor.DiscretionaryAcl.Count)
            {
                System.Diagnostics.Debug.Fail("The DACL cannot be canonicalized since it would potentially result in a loss of information");
                return;
            }
 
            descriptor.DiscretionaryAcl = newDacl;
            objectSecurity.SetSecurityDescriptorSddlForm(descriptor.GetSddlForm(AccessControlSections.Access), AccessControlSections.Access);
        }