Discussion :

[Climbo13]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Diablo_22]

Bonjour,

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

[charouel]

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

[Climbo13]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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