Discussion :

[shini86161]

Bonjour à tous,

Actuellement, je suis en stage, et il m'a été demandé de créer un répertoire avec des droits spécifiques à la création d'un élève et d'un enseignant.

Après quelques heures de recherche, j'admet ne toujours rien comprendre.

La création se réalise avec CreateDirectory, mais il ya les ACL, qui m'intéresse plus particulièrement.
Il y a les DACL et SACL, avec DirectorySecurity, les ACE avec FileSystemAccesRule et les ACE d'audit avec FileSystemAuditRule.

Malheureusement, j'aimerais comprendre la différence fondamentale entre eux, et comprendre comment les utiliser. J'ai trouvé des bouts de codes grâce à Google, mais aucun tutoriel.

Je vous en prie, éclairez ma lanterne.

Je vous en remercie d'avance.

shini86161.

[hadesthanos]

Ici tu as une bonne présentation de la classe DirectorySecurity et des acl. Si tu n'es toujours pas éclairé tu peux toujours poser une question plus précise!
http://msdn.microsoft.com/fr-fr/libr...ysecurity.aspx

[shini86161]

Ici tu as une bonne présentation de la classe DirectorySecurity et des acl. Si tu n'es toujours pas éclairé tu peux toujours poser une question plus précise!
http://msdn.microsoft.com/fr-fr/libr...ysecurity.aspx

Merci beaucoup, pour ta rapidité, et pour ton temps !
Je regarde à ça tout se suite !

[shini86161]

La classe DirectorySecurity est une abstraction du système de sécurité des fichiers Microsoft Windows sous-jacent. Dans ce système, chaque répertoire a une liste de contrôle d'accès discrétionnaire (DACL), qui contrôle l'accès au répertoire, et une liste de contrôle d'accès système (SACL) qui spécifie les tentatives de contrôle d'accès qui sont auditées. Les classes FileSystemAccessRule et FileSystemAuditRule sont des abstractions des entrées de contrôle d'accès (ACE) qui comprennent les DACL et les SACL.

Voilà le genre de phrase qui rend la compréhension ardue. J'avoue que je bloque.
Je continue les recherches, je repère des méthodes qui tournent, sans vraiment comprendre.

En réalité, je dois créer un répertoire lorsque je crée un étudiant ou un professeur. Et les droits de ce répertoire doivent être adéquat.
Créer un répertoire, c'est facile. Mais la suite, je suis perdu.

Je dois modifier le propriétaire du répertoire avec un utilisateur (élève), mais comment le récupérer ?
Comment limiter les droits d'un répertoire à un groupe entier ? Et attacher un utilisateur à un groupe ?



Merci d'avance.

shini86161.

[shini86161]

Concrètement, voilà ce que je dois faire :
Créer un dossier pour une classe ou un groupe accessible par tous les utilisateurs de cette classe ou de ce groupe, pas par les autres.

Je ne comprends pas comment je peux différencier les utilisateurs du groupe de ceux qui ne le sont pas.

Je viens seulement de débuter en C#, et je patauge dans la semoule.

Merci à vous !

[shini86161]

Bon, je crois que je commence à comprendre.

Grâce à ce bout de code, j'arrive à voir les groupes d'utilisateurs. Je ne comprends pas ce que sont les groupes "BUILTIN\" mais je crois que ce sont les groupes qu'on ajoute. Les autres sont natifs.

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
63
64
65
66
67
68
69
70
71
public static void Main(String[] args)
        {
            try
            {
                string chemin = "D:\\Partages\\Groupe1";
 
                if (Directory.Exists(chemin))
                {
                    Console.WriteLine("That path exists already.");
                }
                else
                {
                    // Try to create the directory.
                    DirectoryInfo di = Directory.CreateDirectory(chemin);
                    Console.WriteLine("The directory was created successfully at {0}.", Directory.GetCreationTime(chemin));
                }
 
                Console.Out.WriteLine("\nPermission pour {0}\n", chemin);
 
                // Pouvoir voir les droits de base
                DirectorySecurity ds = Directory.GetAccessControl(chemin);
                AuthorizationRuleCollection rules = ds.GetAccessRules(true, true, typeof(NTAccount));
                foreach (FileSystemAccessRule rule in rules)
                {
                    //Console.WriteLine(rule.IdentityReference + " : " + rule.AccessControlType + "\t->\t" + rule.FileSystemRights + "\n");
                    string groupOrUser = rule.IdentityReference.Value;
                    FileSystemRights rights = rule.FileSystemRights;
                    string inherited = rule.IsInherited ? " (hérité)" : "";
                    string access = rule.AccessControlType == AccessControlType.Allow ? "autorisé" : "refusé";
                    Console.Out.WriteLine("{0} : {1}{2} : {3}", groupOrUser, rights, inherited, access);
                }
 
                /* VOIR LES GROUPES DE L'UTILISATEUR ACTUEL
                string myself = WindowsIdentity.GetCurrent().Name.ToString();
                Console.WriteLine("\nWINDOWS IDENTITY - {0}\n", myself);
                foreach (IdentityReference reference in WindowsIdentity.GetCurrent().Groups)
                {
                    string role =((NTAccount)reference.Translate(typeof(NTAccount))).Value;
                    Console.WriteLine(role);
                }
                */
 
                // Modifier les droits
                ModifierDroit(ds);
 
            }
            catch (System.IO.IOException e)
            {
                Console.WriteLine(e.Message);
            }
 
            System.Console.WriteLine("\n\n\nPress any key to exit.");
            System.Console.ReadKey();
        }
        public static void ModifierDroit(DirectorySecurity ds_)
        {
            string group1 = "Utilisateurs";
            AuthorizationRuleCollection rules = ds_.GetAccessRules(true, true, typeof (NTAccount));
            foreach (FileSystemAccessRule rule in rules)
            {
                string groupOrUser = rule.IdentityReference.Value;
                FileSystemRights rights = rule.FileSystemRights;
                string inherited = rule.IsInherited ? " (hérité)" : "";
                bool access = rule.AccessControlType == AccessControlType.Allow;
 
                if (groupOrUser.Equals("BUILTIN\\" + group1) == true)
                {
                    Console.WriteLine("\tLe groupe est présent...");
                }
            }
        }

J'ai mis "Utilisateurs" pour le groupe, car je n'ai, sur ma machine, pas d'autres groupes que celui-là et administrateurs (avec BUILTIN).

Ajout : En pièce jointe, y'a le résultat. Y'a deux fois chacun des groupes. Est-ce normal ?

Je crois qu'il ne me reste qu'à changer les permissions.

C'est correct ? Des idées ? Des commentaires ?

Merci à vous,

shini86161.