Come impostare le autorizzazioni per le cartelle con PowerShell

Garantire che le persone giuste abbiano l’accesso corretto a file e cartelle specifici è fondamentale nel settore IT. La gestione delle autorizzazioni protegge efficacemente i dati sensibili, favorisce la conformità alle normative e migliora l’efficienza operativa. Uno strumento molto diffuso per impostare le autorizzazioni per le cartelle e i file è PowerShell e oggi analizzeremo uno script che semplifica il processo di modifica dei permessi per le cartelle. 

Background

In un panorama digitale in continua evoluzione, i professionisti IT e i Managed Service Provider (MSP) si destreggiano costantemente tra le autorizzazioni di più utenti su vari file e cartelle. Lo script fornito, per impostare le autorizzazioni per le cartelle, è una manna dal cielo in questi scenari. Offre flessibilità, consentendo di assegnare o rimuovere le autorizzazioni a più utenti su più percorsi. Ciò significa che, che tu stia lavorando con singoli file o con intere directory, questo script ti sarà comunque utile.

Lo script per impostare le autorizzazioni per le cartelle e i file

#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 {}

 

Analisi dettagliata

Nel suo nucleo, lo script per impostare le autorizzazioni per le cartelle e i file opera con tre parametri obbligatori: User, Path, e Permissions.

• User: Definisce l’utente di destinazione per il quale si stanno impostando le autorizzazioni. Questo parametro viene convalidato per garantire l’esistenza dell’utente.
• Path: Indica il file o la directory i cui permessi devono essere modificati. La sua esistenza è convalidata.
• Permissions: Elenca i vari tipi di autorizzazioni che possono essere impostati, da FullControl a quelli specifici come ReadData.

Lo script oer impostare le autorizzazioni per le cartelle offre anche parametri opzionali:

• Block: Se utilizzato, nega le autorizzazioni specificate.
• Recursive: Se specificato, applica le autorizzazioni lungo una struttura di cartelle, garantendo l’ereditarietà.

Quando viene eseguito, lo script per impostare le autorizzazioni per le cartelle verifica innanzitutto se è in esecuzione con privilegi amministrativi. Quindi valuta ogni percorso per le autorizzazioni utente specificate, creando o modificando le regole di conseguenza.

Casi d’uso potenziali

Immagina una professionista IT, Jane, che supervisiona un progetto per la sua organizzazione. Jane ha una cartella con i file del progetto. Con il progredire del progetto, i diversi reparti hanno bisogno di vari livelli di accesso a questi file. Utilizzando lo script per impostare le autorizzazioni per le cartelle, Jane può garantire senza sforzo che l’ufficio risorse umane possa leggere solo determinati documenti, e che i responsabili del progetto abbiano il pieno controllo su tutti i file. Questa gestione efficiente garantisce il buon funzionamento del progetto, mantenendo la sicurezza.

Confronti

I metodi tradizionali per impostare le autorizzazioni per le cartelle spesso implicano la navigazione attraverso intricate interfacce GUI o l’utilizzo di software di terze parti. Sebbene offrano un feedback visivo, possono richiedere molto tempo ed essere meno efficienti quando si tratta di autorizzazioni da modificare in blocco. Lo script PowerShell offre un approccio più rapido e diretto per impostare le autorizzazioni per le cartelle. È particolarmente utile per i professionisti IT che hanno familiarità con la riga di comando, in quanto consente di modificare rapidamente le autorizzazioni tramite script.

Domande frequenti

• Quali sono i requisiti in termini di sistema operativo per questo script?
  Lo script per impostare le autorizzazioni per le cartelle supporta Windows 10 e Windows Server 2016 e successivi.
• Come posso assicurarmi che i permessi ricorsivi siano applicati solo alle cartelle e non ai singoli file?
  Lo script per impostare le autorizzazioni per le cartelle e i file controlla automaticamente se il percorso è un contenitore (cartella) e solo in quel caso applica i permessi ricorsivi.

Implicazioni

Una gestione efficace delle autorizzazioni è fondamentale per la sicurezza informatica. L’impostazione di un accesso troppo permissivo può esporre dati sensibili, mentre impostare le autorizzazioni per le cartelle in modo eccessivamente restrittivo può ostacolare i processi di lavoro. Questo script offre la possibilità di trovare un perfetto equilibrio, consentendo un controllo preciso delle autorizzazioni. Tuttavia, le configurazioni errate possono avere implicazioni indesiderate, per cui è bene ricontrollare sempre le impostazioni.

Raccomandazioni

• Esegui sempre un test in un ambiente controllato prima di distribuire lo script per impostare le autorizzazioni per le cartelle su larga scala.
• Esegui il backup delle impostazioni correnti delle autorizzazioni, in modo da avere una rete di sicurezza in caso di errori.
• Aggiorna e verifica regolarmente le autorizzazioni degli utenti per mantenere la sicurezza e l’efficienza operativa.

Considerazioni finali

Nel mondo IT moderno, la sfida della gestione delle autorizzazioni per le cartelle e i file non può essere sottovalutata. Gli script PowerShell, come quello che abbiamo analizzato oggi, rendono il compito più gestibile ed efficiente. Per chi è alla ricerca di soluzioni integrate di gestione IT, NinjaOne offre strumenti e funzionalità solide, che riducono ulteriormente la complessità della gestione delle autorizzazioni. Che ci si affidi a script o a piattaforme complete come NinjaOne, l’obiettivo rimane lo stesso: operazioni IT sicure, efficienti e semplificate.