Festlegen von Ordnerberechtigungen mit PowerShell

Die Sicherstellung, dass die richtigen Personen den richtigen Zugriff auf bestimmte Dateien und Ordner haben, ist in der IT von größter Bedeutung. Durch die Verwaltung von Berechtigungen werden sensible Daten wirksam geschützt, die Einhaltung von Vorschriften unterstützt und die betriebliche Effizienzgesteigert. Ein beliebtes Tool zur Bewältigung solcher Aufgaben ist PowerShell, und heute tauchen wir tief in ein Skript ein, das den Prozess der Änderung von Ordnerberechtigungen rationalisiert.

Hintergrund

In einer sich ständig weiterentwickelnden digitalen Landschaft jonglieren IT-Expert:innen und Managed Service Provider (MSPs) ständig mit mehreren Benutzerberechtigungen für verschiedene Dateien und Ordner. Das bereitgestellte Skript ist in solchen Szenarien ein Geschenk des Himmels. Es bietet Flexibilität und ermöglicht die Zuweisung oder Sperrung von Berechtigungen für mehrere Benutzer:innen über mehrere Pfade. Egal, ob Sie mit einzelnen Dateien oder ganzen Verzeichnissen arbeiten, dieses Skript ist für Sie da.

Das Skript

#Requires -Version 5.1

<#
.SYNOPSIS
    Modify User Permissions for files and folder.
.DESCRIPTION
    Modify User Permissions for files and folder. You can assign or block multiple permissions to multiple users, and multiple files and folders.
.EXAMPLE
     -User "Test" -Path "C:Test" -Permissions FullControl
    Gives FullControl permissions to the user Test for just the folder C:Test
.EXAMPLE
     -User "Test1", "Test2" -Path "C:Test" -Permissions FullControl
    Gives FullControl permissions to the user Test1 and Test2 for just the folder C:Test
.EXAMPLE
     -User "Test1", "Test2" -Path "C:Test", "C:Temp" -Permissions FullControl
    Gives FullControl permissions to the user Test1 and Test2 for just the folders C:Test and C:Temp
.EXAMPLE
     -User "Test" -Path "C:TestDocument.docx" -Permissions FullControl
    Gives FullControl permissions to the user Test for just the file C:TestDocument.docx
.EXAMPLE
     -User "Test" -Path "C:TestDocument.docx" -Permissions ReadData, Modify
    Gives ReadData and Modify permissions to the user Test for just the file C:TestDocument.docx
.EXAMPLE
     -User "Test" -Path "C:TestDocument.docx" -Permissions FullControl -Block
    Blocks FullControl permissions from the user Test for just the file C:TestDocument.docx
.EXAMPLE
     -User "Test" -Path "C:Test" -Permissions FullControl -Recursive
    Gives FullControl permissions to the user Test for the folder C:Test and any folder or file under it will inherit FullControl
.EXAMPLE
    PS C:> .Modify-User-Permissions.ps1 -User "Test" -Path "C:Test" -Permissions FullControl -Recursive
    Gives FullControl permissions to the user Test for the folder C:Test and any folder or file under it will inherit FullControl
.INPUTS
    Inputs (User,Path,Permissions)
.OUTPUTS
    FileSecurity
.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes:
    Initial Release
By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
    Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
    Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
    Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
    Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
    Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
    Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
    EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
.COMPONENT
    ManageUsers
#>

[CmdletBinding()]
param (
    [Parameter(Mandatory = $true)]
    [ValidateScript(
        {
            # Validate that the User(s) exist
            if ($(Get-LocalUser -Name $_)) { $true } else { $false }
        }
    )]
    [String[]]
    # The user name of the user you want to apply Permissions to a Path(s)
    $User,
    [Parameter(Mandatory = $true)]
    [ValidateScript({ Test-Path -Path $_ })]
    [String[]]
    # File path that you want to apply Permissions to
    $Path,
    [Parameter(Mandatory = $true)]
    # Permission to set the path(s) for the user(s)
    # This accepts the following:
    #  ListDirectory, ReadData, WriteData, CreateFiles, CreateDirectories, AppendData, ReadExtendedAttributes,
    #  WriteExtendedAttributes, Traverse, ExecuteFile, DeleteSubdirectoriesAndFiles, ReadAttributes,
    #  WriteAttributes, Write, Delete, ReadPermissions, Read, ReadAndExecute, Modify, ChangePermissions,
    #  TakeOwnership, Synchronize, FullControl
    [System.Security.AccessControl.FileSystemRights[]]
    $Permissions,
    # Block the specified Permissions for the specified $User
    [Switch]
    $Block,
    # Apply the Permissions down through a folder structure, i.e. inheritance
    [Switch]
    $Recursive
)

begin {
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        if ($p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator))
        { Write-Output $true }
        else
        { Write-Output $false }
    }
}

process {
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }
    $Acl = Get-Acl -Path $Path
    if ($true -in $Acl.AreAccessRulesProtected) {
        Write-Error "ACL rules are protected for one of the specified paths."
        exit 1
    }
    $script:HasError = $false
    $Path | ForEach-Object {
        $CurPath = Get-Item -Path $_
        $User | ForEach-Object {
            $NewAcl = Get-Acl -Path $CurPath
            # Set properties
            $identity = Get-LocalUser -Name $_
            $fileSystemRights = $Permissions
            $type = $(if ($Block) { [System.Security.AccessControl.AccessControlType]::Deny }else { [System.Security.AccessControl.AccessControlType]::Allow })
            $fileSystemRights | ForEach-Object {
                # Create new rule
                Write-Host "Creating $type $_ rule for user: $identity"
                # Check if Recursive was used and that the current path is a folder
                if ($CurPath.PSIsContainer -and $Recursive) {
                    $inheritanceFlags = 'ObjectInherit,ContainerInherit'
                    $NewAcl.SetAccessRuleProtection($false, $true)
                }
                else {
                    $inheritanceFlags = [System.Security.AccessControl.InheritanceFlags]::None
                }
                $propagationFlags = [System.Security.AccessControl.PropagationFlags]::None
                $fileSystemAccessRuleArgumentList = $identity, $_, $inheritanceFlags, $propagationFlags, $type
                $fileSystemAccessRule = New-Object -TypeName System.Security.AccessControl.FileSystemAccessRule -ArgumentList $fileSystemAccessRuleArgumentList

                # Apply new rule
                $NewAcl.SetAccessRule($fileSystemAccessRule)
                try {
                    Set-Acl -Path $CurPath -AclObject $NewAcl -Passthru
                }
                catch {
                    Write-Error $_
                    $script:HasError = $true
                }
            }
        }
    }
    if ($script:HasError) {
        exit 1
    }
}

end {}

 

Detailansicht

Im Kern arbeitet das Skript mit drei obligatorischen Parametern: Benutzer:innen, Pfad und Berechtigungen.

• Benutzer:innen: Legt den Zielbenutzer:innen fest, für den die Berechtigungen festgelegt werden. Dieser Parameter wird einer Validierung unterzogen, um sicherzustellen, dass die/der Benutzer:in existiert.
• Pfad: Gibt die Datei oder das Verzeichnis an, dessen Berechtigungen geändert werden müssen. Seine Existenz wird bestätigt.
• Berechtigungen: Listet die verschiedenen Arten von Berechtigungen auf, die festgelegt werden können, von FullControl bis hin zu spezifischen wie ReadData.

Das Skript bietet auch optionale Parameter:

• Block: Verweigert bei Aufruf die angegebenen Berechtigungen.
• Rekursiv: Falls angegeben, werden die Berechtigungen in einer Ordnerstruktur nach unten vererbt, um die Vererbung zu gewährleisten.

Wenn das Skript ausgeführt wird, prüft es zunächst, ob es mit administrativen Rechten ausgeführt wird. Anschließend prüft es jeden Pfad auf die angegebenen Benutzerrechte und erstellt oder ändert die Regeln entsprechend.

Potenzielle Anwendungsfälle

Stellen Sie sich eine IT-Fachkraft, Jane, vor, die ein Projekt für ihr Unternehmen beaufsichtigt. Jane hat einen Ordner mit Projektdateien. Im Laufe des Projekts benötigen die verschiedenen Abteilungen unterschiedliche Zugriffsrechte auf diese Dateien. Mit Hilfe des Skripts kann Jane mühelos sicherstellen, dass die Personalabteilung nur bestimmte Dokumente lesen kann, während die Projektleiter:innen die volle Kontrolle über alle Dateien haben. Dieses effiziente Management sorgt für einen reibungslosen Projektablauf bei gleichzeitiger Wahrung der Sicherheit.

Vergleiche

Herkömmliche Methoden zum Festlegen von Ordnerberechtigungen erfordern oft die Navigation durch komplizierte grafische Benutzeroberflächen oder den Einsatz von Drittanbietersoftware. Sie bieten zwar ein visuelles Feedback, können aber zeitaufwändig und weniger effizient sein, wenn es um Massengenehmigungen geht. Das PowerShell-Skript bietet einen schnelleren, direkteren Ansatz. Es ist besonders praktisch für IT-Profis, die mit der Befehlszeile vertraut sind, da es schnelle, skriptgesteuerte Berechtigungsänderungen ermöglicht.

FAQs

• Was sind die Betriebssystemanforderungen für dieses Skript? 
  Das Skript unterstützt Windows 10 und Windows Server 2016 und höher.
• Wie kann ich sicherstellen, dass die rekursiven Berechtigungen nur auf Ordner und nicht auf einzelne Dateien angewendet werden? 
  Das Skript prüft automatisch, ob der Pfad ein Container (Ordner) ist, und wendet erst dann rekursive Berechtigungen an.

Auswirkungen

Eine wirksame Verwaltung von Berechtigungen ist für die IT-Sicherheit entscheidend. Ein zu freizügiger Zugriff kann zur Preisgabe sensibler Daten führen, während restriktive Berechtigungen Arbeitsabläufe behindern können. Dieses Skript sorgt für ein ausgewogenes Verhältnis und ermöglicht eine präzise Kontrolle der Genehmigungen. Falsche Konfigurationen können jedoch unbeabsichtigte Auswirkungen haben, daher sollten Sie Ihre Einstellungen immer überprüfen.

Empfehlungen

• Führen Sie immer einen Test in einer kontrollierten Umgebung durch, bevor Sie das Skript in großem Umfang einsetzen.
• Sicherung der aktuellen Berechtigungseinstellungen als Sicherheitsnetz für den Fall von Fehlern.
• Regelmäßige Aktualisierung und Prüfung der Benutzerrechte, um Sicherheit und betriebliche Effizienz zu gewährleisten.

Abschließende Überlegungen

In der modernen IT-Welt ist die Verwaltung von Ordner- und Dateiberechtigungen eine unschätzbare Herausforderung. PowerShell-Skripte, wie das heute vorgestellte, machen diese Aufgabe überschaubarer und effizienter. Für diejenigen, die nach integrierten IT-Management-Lösungen suchen, bietet NinjaOne robuste Werkzeuge und Funktionen, die die Komplexität des Berechtigungsmanagements weiter vereinfachen. Ob Sie sich nun auf Skripte oder umfassende Plattformen wie NinjaOne stützen, das Ziel bleibt dasselbe: ein sicherer, effizienter und optimierter IT-Betrieb.