Listes d'accès (2/2).

Dans cette partie je vous propose un scripte complet qui permet de donner des droits sur un dossier et ses sous-dossiers. Ce programme réalise les actions suivantes.

Sur le Dossier :
- Le groupe Administrateurs prend le rôle de propriétaire.
- Donne le droit FullControl au groupe Administrateurs.
- Désactive l'héritage et supprime les droits (sauf "Administrateurs").
- Donne les droits du tableau "$global:droits" sur le dossier.

Sur les sous-dossier et fichiers :
- Le groupe Administrateurs prend le rôle de propriétaire.
- Réactive l'héritage (s'il n'est pas activé).
- Supprime les droits non-hérité du parent.

Usage :
Dans la variable "$dossier" entrez le chemin du dossier à modifier.
Dans le tableau "$global:droits" ajouté vos droits en suivant les exemples.

Je vous conseil de ne pas supprimer les lignes suivantes :
$global:droits  =  @()            #Initialisation du tableau (indispensable).
$global:droits += ,@("BUILTIN\Administrateurs","FullControl")
$global:droits += ,@("AUTORITE NT\SYSTEM","FullControl")

 

###################################################
#      Réinitialiser les droits d'un dossier
#       et de ses sous-dossiers et fichiers
###################################################

#Dossier à traiter.
$dossier = "C:\dossier1"

#Liste des groupes/utilisateurs et des droits.
#ReadAndExecute, Modify, FullControl.
$global:droits  =  @()   #Initialisation du tableau.
$global:droits += ,@("BUILTIN\Administrateurs","FullControl")
$global:droits += ,@("AUTORITE NT\SYSTEM","FullControl")
$global:droits += ,@("Utilisateurs","ReadAndExecute")
$global:droits += ,@("Jumbor12","Modify")

###################################################
#                    Fonctions
###################################################

### Définit le propriétaire d'un dossier.
function rd_owner([string] $roDossier,[string] $roGroupe)
 {
   #Je récupère les informations de mon dossier.
   $gdossier = Get-Item $roDossier
   #Je récupère la liste d'accès de mon dossier.
   $acl = $gdossier.GetAccessControl()
   #Je crée un objet $groupe.
   $groupe = New-Object System.Security.Principal.NTAccount($roGroupe)
   #Je modifie mon Acl.
   $acl.SetOwner($groupe)
   #Et j'applique l'Acl modifiée sur mon dossier.
   $gdossier.SetAccessControl($acl)
 }

### Initialise les droits sur le dossier racine.
function rd_racine([string] $rrDossier)
 {
   #Je réinitialise le propriétaire du dossier.
   rd_owner $rrDossier "BUILTIN\Administrateurs"

   #J'ajoute le groupe administrateurs à l'acl du dossier.
   rd_droit $rrDossier "BUILTIN\Administrateurs" "FullControl"

   #Je désactive l'héritage sur le dossier.
   $acl = get-acl -path $rrDossier             #Lecture de l'Acl.
   $acl.SetAccessRuleProtection($true,$true)   #Désactive l'héritage.
   Set-Acl -Path $rrDossier -AclObject $acl    #Mise à jour du dossier.

   #Puis je supprime les droits (sauf "Administrateurs").
   $acl = get-acl -path $rrDossier
   Foreach ($ace in $acl.Access)
     {
       #Lecture du droit de l'utilisateur.
       $groupe = [string] $ace.IdentityReference
       $droit = [string] $ace.FileSystemRights
       $type = [string] $ace.AccessControlType
       $heriter = $ace.IsInherited
       $IFlag = $ace.InheritanceFlags
       $PFlag = $ace.PropagationFlags 

       #Suppression des droits et de l'utilisateur.
       if ($groupe -ne "BUILTIN\Administrateurs")
         {
           $aco = new-object Security.AccessControl.FileSystemAccessRule($groupe,$droit,$IFlag,$PFlag,$type)
           $acl.RemoveAccessRuleAll($aco)
         }
     }

   #Mise à jour des droits sur le dossier.
   Set-Acl -Path $rrDossier -AclObject $acl
 }

### Réinitialise l'héritage sur les sous-dossiers. Les sous-dossiers
### et fichiers prendrons les mêmes droits que notre dossier.
function rd_heritage([string] $rhDossier)
 {
   #Je réinitialise le propriétaire du dossier.
   rd_owner $rhDossier "BUILTIN\Administrateurs"

   #J'active l'héritage sur le dossier.
   $acl = get-acl -path $rhDossier               #Lecture Acl.
   $acl.SetAccessRuleProtection($false,$false)   #Active l'héritage.
   Set-Acl -Path $rhDossier -AclObject $acl      #Mise à jour dossier.

   #Puis je supprime les droits non-hérité.
   $acl = get-acl -path $rhDossier
   Foreach ($ace in $acl.Access)
     {
       #Lecture du droit de l'utilisateur.
       $groupe = [string] $ace.IdentityReference
       $droit = [string] $ace.FileSystemRights
       $type = [string] $ace.AccessControlType
       $heritage = $ace.IsInherited
       $IFlag = $ace.InheritanceFlags
       $PFlag = $ace.PropagationFlags 
   
       #Suppression des droits non-hérité du parent.
       if (!$heritage)
         {
           $test = Get-Item $rhDossier
           if ($test.gettype().Name -eq "FileInfo")
             {
               $aco = new-object Security.AccessControl.FileSystemAccessRule($groupe,$droit,,,$type)
             }
           else
             {
               $aco = new-object Security.AccessControl.FileSystemAccessRule($groupe,$droit,$IFlag,$PFlag,$type)
             }
           $acl.RemoveAccessRuleAll($aco)
         }
     }

   #Mise à jour des droits sur le dossier.
   Set-Acl -Path $rhDossier -AclObject $acl
 }

### Défini les droits sur le dossier.
function rd_droit([string] $rdDossier,[string] $rdgroupe, [string] $rddroit)
 {
   #InheritOnly, None, NoPropagateInherit.
   $PFlag = [System.Security.AccessControl.PropagationFlags]::None

   #ContainerInherit, ObjectInherit, None.
   $IFlag = ([System.Security.AccessControl.InheritanceFlags]::ContainerInherit) -bor ([System.Security.AccessControl.InheritanceFlags]::ObjectInherit)

   #Je prepare le droit à positionner.
   $aco = new-object Security.AccessControl.FileSystemAccessRule($rdgroupe,$rddroit,$IFlag,$PFlag,"Allow")

   #Et je l'ajoute au dossier racine.
   $acl = get-acl -path $rdDossier            #Lecture de l'Acl.
   $acl.AddAccessRule($aco)                   #Mise à jour Acl.
   Set-Acl -Path $rdDossier -AclObject $acl   #Mise à jour du dossier.
 }

### Programme principale.
function rd_main([string] $rmDossier)
 {
   #J'initialise le dossier racine (owner/droit/héritage).
   rd_racine $rmDossier

   #Je donne les droits sur le dossier racine.
   foreach($droit in $global:droits)
    {
      rd_droit $rmDossier $droit[0] $droit[1]
    }

   #Je réinitialise l'héritage sur tout sous-dossiers afin
   #d'être sur que tout les sous-dossiers/fichiers prennent
   #les mêmes droits que notre dossier.
   Get-ChildItem $rmDossier -recurse -Force | foreach { rd_heritage($_.FullName) }
 }

###################################################
#                      Mains
###################################################

#Lancement du programme principale.
rd_main $dossier

#Fin.