Impostare le autorizzazioni degli storage rimovibili: Una guida PowerShell

Punti chiave

• Automatizza le autorizzazioni dei dispositivi: Lo script semplifica il processo di impostazione delle autorizzazioni degli storage rimovibili.
• Supporta più dispositivi: Copre una serie di dispositivi, tra cui USB, DVD, floppy, nastri e WPD.
• Richiede i diritti di amministratore: L’esecuzione dello script per impostare le autorizzazioni degli storage rimovibili richiede i privilegi di amministratore.
• Modifica le impostazioni del registro di sistema: Modifica le autorizzazioni alterando chiavi di registro e valori specifici.
• Garantisce la conformità e la sicurezza: Ideale per gli ambienti in cui la sicurezza dei dati e la conformità alle normative sono fondamentali.
• Controllo flessibile: Offre la possibilità di negare e consentire le azioni di lettura, scrittura ed esecuzione.
• Aggiornamento dei criteri di gruppo e riavvio: Termina con un aggiornamento dei criteri di gruppo e un riavvio opzionale del sistema.
• Rischio di eccessive restrizioni: L’applicazione di criteri troppo restrittivi può ostacolare i flussi di lavoro.
• Integrazione con NinjaOne: È complementare a piattaforme come NinjaOne per una gestione più completa e una maggiore sicurezza IT.

La gestione dell’accesso ai dispositivi di archiviazione rimovibili è un aspetto critico della sicurezza informatica. Questa responsabilità è particolarmente accentuata negli ambienti in cui la sicurezza e l’integrità dei dati sono fondamentali. Gli script di PowerShell, come quello che stiamo analizzando oggi per impostare le autorizzazioni degli storage rimovibili, forniscono una soluzione affidabile per controllare in modo efficiente questo aspetto della sicurezza IT.

Background

Lo script per impostare le autorizzazioni degli storage rimovibili è progettato per abilitare o disabilitare l’accesso in lettura, scrittura ed esecuzione a vari dispositivi di archiviazione rimovibili, tra cui unità floppy, unità CD/DVD, unità a nastro, Windows Portable Devices (WPD) e unità USB. Questa funzionalità è essenziale per i professionisti IT e i Managed Service Provider (MSP) che devono applicare criteri di sicurezza dei dati, prevenire le condivisioni non autorizzate o rispettare gli standard normativi.

Lo script per impostare le autorizzazioni degli storage rimovibili:

#Requires -Version 2.0

<#
.SYNOPSIS
    Disable or Enable Write, Read, and Execute access to Removable Storage devices.
.DESCRIPTION
    Disable or Enable Write, Read, and Execute access to Floppy, CD/DVD, Tape, WPD, and/or USB.
    Disable actions are does first, then allow actions are done after.
.EXAMPLE
     -Device DVD -DenyRead -DenyWrite -DenyExecute
    Disable Write, Read, and Execute access to CD/DVD drive.
.EXAMPLE
     -Device DVD -AllowRead -AllowWrite -AllowExecute
    Allow Write, Read, and Execute access to CD/DVD drive.
.EXAMPLE
     -Device DVD -DenyWrite -DenyExecute -AllowRead
    Disable Write, Read, and Execute access to CD/DVD drive, but Allow Read.
.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 7, Windows Server 2012
    Local Group Policy updates like this requires the computer to rebooted.
    Release Notes: Renamed script and added Script Variable support
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/it/condizioni-utilizzo
    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
    DataIOSecurity
#>

[CmdletBinding()]
param (
    # Supported devices Floppy, DVD, Tape, WPD, USB
    [String[]]
    $Device,
    [switch]
    $DenyRead = [System.Convert]::ToBoolean($env:DenyRead),
    [switch]
    $DenyWrite = [System.Convert]::ToBoolean($env:DenyWrite),
    [switch]
    $DenyExecute = [System.Convert]::ToBoolean($env:DenyExecute),
    [switch]
    $AllowRead = [System.Convert]::ToBoolean($env:AllowRead),
    [switch]
    $AllowWrite = [System.Convert]::ToBoolean($env:AllowWrite),
    [switch]
    $AllowExecute = [System.Convert]::ToBoolean($env:AllowExecute),
    [switch]
    $ForceReboot = [System.Convert]::ToBoolean($env:ForceReboot)
)

begin {
    function Test-StringEmpty {
        param([string]$Text)
        # Returns true if string is empty, null, or whitespace
        process { [string]::IsNullOrEmpty($Text) -or [string]::IsNullOrWhiteSpace($Text) }
    }
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        $p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
    }
    $RegSettings = @(
        [PSCustomObject]@{
            Name        = "Floppy"
            BasePath    = "HKLM:\Software\Policies\Microsoft\Windows\RemovableStorageDevices\{53f56311-b6bf-11d0-94f2-00a0c91efb8b}"
            DenyExecute = "Deny_Execute"
            DenyWrite   = "Deny_Write"
            DenyRead    = "Deny_Read"
        },
        [PSCustomObject]@{
            Name        = "DVD"
            BasePath    = "HKLM:\Software\Policies\Microsoft\Windows\RemovableStorageDevices\{53f56308-b6bf-11d0-94f2-00a0c91efb8b}"
            DenyExecute = "Deny_Execute"
            DenyWrite   = "Deny_Write"
            DenyRead    = "Deny_Read"
        },
        [PSCustomObject]@{
            Name        = "Tape"
            BasePath    = "HKLM:\Software\Policies\Microsoft\Windows\RemovableStorageDevices\{53f5630b-b6bf-11d0-94f2-00a0c91efb8b}"
            DenyExecute = "Deny_Execute"
            DenyWrite   = "Deny_Write"
            DenyRead    = "Deny_Read"
        },
        [PSCustomObject]@{
            Name      = "WPD"
            BasePath  = "HKLM:\Software\Policies\Microsoft\Windows\RemovableStorageDevices\{6AC27878-A6FA-4155-BA85-F98F491D4F33}"
            DenyWrite = "Deny_Write"
            DenyRead  = "Deny_Read"
        },
        [PSCustomObject]@{
            Name      = "WPD"
            BasePath  = "HKLM:\Software\Policies\Microsoft\Windows\RemovableStorageDevices\{F33FDC04-D1AC-4E8E-9A30-19BBD4B108AE}"
            DenyWrite = "Deny_Write"
            DenyRead  = "Deny_Read"
        },
        [PSCustomObject]@{
            Name        = "USB"
            BasePath    = "HKLM:\Software\Policies\Microsoft\Windows\RemovableStorageDevices\{53f5630d-b6bf-11d0-94f2-00a0c91efb8b}"
            DenyExecute = "Deny_Execute"
            DenyWrite   = "Deny_Write"
            DenyRead    = "Deny_Read"
        }
    )
    $Device = if ($(Test-StringEmpty -Text $env:Device)) { $Device }else { $env:Device }

    if ($(Test-StringEmpty -Text $Device)) {
        Write-Error "Device is required."
        exit 1
    }
    if ((-not $DenyRead -and -not $DenyWrite -and -not $DenyExecute) -and (-not $AllowRead -and -not $AllowWrite -and -not $AllowExecute)) {
        Write-Error "At least one Deny or Allow is required."
        exit 1
    }
}
process {
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }

    # Split any string that has a comma and validate types of devices
    $Device = $Device | ForEach-Object {
        $_ -split ',' | ForEach-Object {
            "$_".Trim()
        }
    } | Where-Object { $_ -in "Floppy", "DVD", "Tape", "WPD", "USB" }

    try {
        $Device | ForEach-Object {
            $CurDevice = $_
            # Loop through each item in $RegSettings and work on the current device($Device)
            $RegSettings | Where-Object { $_.Name -in $CurDevice } | ForEach-Object {
                $CurRegSetting = $_
                $Path = $CurRegSetting.BasePath

                # Build Deny list
                $Deny = [System.Collections.ArrayList]::new() # Older PowerShell compatible Lists
                if ($DenyRead) { $Deny.Add("Read") | Out-Null }
                if ($DenyWrite) { $Deny.Add("Write") | Out-Null }
                if ($DenyExecute) { $Deny.Add("Execute") | Out-Null }
                # Build Allow list
                $Allow = [System.Collections.ArrayList]::new() # Older PowerShell compatible Lists
                if ($AllowRead) { $Allow.Add("Read") | Out-Null }
                if ($AllowWrite) { $Allow.Add("Write") | Out-Null }
                if ($AllowExecute) { $Allow.Add("Execute") | Out-Null }

                # Loop though each $Deny item passed
                $Deny | ForEach-Object {
                    $CurDeny = $_
                    # Only act on what we have, like WPD where we only have Deny_Write and Deny_Read
                    # $CurRegSetting."Deny$CurDeny" is a method of access a property
                    if ($CurRegSetting."Deny$CurDeny") {
                        $CurDenyType = $CurRegSetting."Deny$CurDeny"
                        # Check if we need to create the path
                        if (-not (Test-Path -Path $Path -ErrorAction SilentlyContinue)) {
                            New-Item -Path ($Path | Split-Path -Parent) -Name ($Path | Split-Path -Leaf) -Force -Confirm:$false | Out-Null
                            Write-Host "Creating path: $($Path)"
                        }
                        # Check if the property already exists and update it or create the property
                        if ((Get-ItemProperty -Path $Path -Name $CurDenyType -ErrorAction SilentlyContinue)."$CurDenyType") {
                            Set-ItemProperty -Path $Path -Name $CurDenyType -Value 1 -Force -Confirm:$false | Out-Null
                            Write-Host "Setting $($Path)/$CurDenyType to 1"
                        }
                        else {
                            New-ItemProperty -Path $Path -Name $CurDenyType -Value 1 -PropertyType "DWORD" -Force -Confirm:$false | Out-Null
                            Write-Host "Creating and Setting $($Path)/$CurDenyType to 1"
                        }
                        Write-Host "Deny $CurDeny for $CurDevice set to $((Get-ItemProperty -Path $Path -Name $CurDenyType -ErrorAction SilentlyContinue)."$CurDenyType")"
                    }
                    else {
                        # Skipping this as we don't have Deny_Execute for WPD
                        Write-Host "Skipping $($CurRegSetting."Deny$CurDeny")"
                    }
                }
                # Loop though each $Allow item passed
                $Allow | ForEach-Object {
                    $CurAllow = $_
                    # Only act on what we have, like WPD where we only have Deny_Write and Deny_Read
                    # $CurRegSetting."Deny$CurAllow" is a method to access a property
                    if ($CurRegSetting."Deny$CurAllow") {
                        $CurAllowType = $CurRegSetting."Deny$CurAllow"
                        # Check if the property already exists and update it or create the property
                        if ((Get-ItemProperty -Path $Path -Name $CurAllowType -ErrorAction SilentlyContinue)."$CurAllowType") {
                            Set-ItemProperty -Path $Path -Name $CurAllowType -Value 0 -Force -Confirm:$false | Out-Null
                            Write-Host "Setting $($Path)/$CurAllowType to 0"
                        }
                        Write-Host "Allow access for $CurDevice"
                    }
                    else {
                        # Skipping this as we don't have Deny_Execute for WPD
                        Write-Host "Skipping $($CurRegSetting."Deny$CurAllow")"
                    }
                }
            }
        }
        

        Write-Host "Running: gpupdate.exe /force"
        gpupdate.exe /force
        Write-Host "Completed Running: gpupdate.exe /force"
        Write-Host "Computer will need to be rebooted for changes to take effect."

        if ($ForceReboot) {
            shutdown.exe -r -t 60
        }
        else {
            Write-Host "Computer will need to be rebooted to see changes."
        }
        exit 0
    }
    catch {
        Write-Error $_
        exit 1
    }
}
end {
    
    
    
}

 

Analisi dettagliata dello script per impostare le autorizzazioni degli storage rimovibili

Lo script per impostare le autorizzazioni degli storage rimovibili opera in diverse fasi distinte:

• Definizione dei parametri: Lo script per impostare le autorizzazioni degli storage rimovibili inizia definendo i parametri per i diversi tipi di dispositivi e le azioni (negare o consentire la lettura, la scrittura e l’esecuzione).
• Controlli pre-esecuzione: Include funzioni per controllare le stringhe vuote e verificare se lo script per impostare le autorizzazioni degli storage rimovibili viene eseguito con privilegi elevati (da amministratore).
• Modifica delle impostazioni del registro: La funzionalità principale consiste nel modificare le impostazioni del registro di sistema per ogni tipo di dispositivo. Queste impostazioni determinano le autorizzazioni per ogni azione (Lettura, Scrittura, Esecuzione).
• Logica di esecuzione: Lo script per impostare le autorizzazioni degli storage rimovibili crea o modifica le chiavi e i valori del Registro di sistema in base ai parametri inseriti. Può impostare le autorizzazioni per negare o consentire le azioni sui dispositivi specificati.
• Fasi finali: Lo script per impostare le autorizzazioni degli storage rimovibili si conclude con l’aggiornamento dei criteri di gruppo tramite gpupdate.exe e, facoltativamente, con il riavvio del sistema per rendere effettive le modifiche.

Casi d’uso potenziali

Immagina un’azienda finanziaria che deve attenersi a rigide norme di sicurezza dei dati. Un amministratore IT può utilizzare questo script per impostare le autorizzazioni degli storage rimovibili, e  disabilitare l’accesso in scrittura alle unità USB su tutte le workstation dei dipendenti, impedendo la copia di dati sensibili su dispositivi esterni.

Confronti

I metodi tradizionali di configurazione delle autorizzazioni dei dispositivi possono comportare modifiche manuali del registro di sistema o configurazioni dei criteri di gruppo. Questo script automatizza i processi per impostare le autorizzazioni degli storage rimovibili, riducendo il margine di errore e facendo risparmiare tempo.

Domande frequenti

• Lo script per impostare le autorizzazioni degli storage rimovibili è compatibile con tutte le versioni di Windows?
  • Supporta Windows 7 e versioni successive, comprese le edizioni server.

• Può controllare l’accesso alle unità di rete?
  • No, è specifico per i dispositivi di archiviazione rimovibili.

• Lo script per impostare le autorizzazioni degli storage rimovibili richiede diritti amministrativi?
  • Sì, deve essere eseguito con privilegi di amministratore.

Implicazioni

Se da un lato questo script per impostare le autorizzazioni degli storage rimovibili è uno strumento potente per migliorare la sicurezza dei dati, dall’altro comporta il rischio di limitare troppo l’accesso e di ostacolare potenzialmente i flussi di lavoro legittimi. È essenziale bilanciare le esigenze di sicurezza con i requisiti operativi.

Raccomandazioni

• Testa lo script per impostare le autorizzazioni degli storage rimovibili in un ambiente controllato prima di distribuirlo su larga scala.
• Documenta tutte le modifiche apportate con lo script per impostare le autorizzazioni degli storage rimovibili per riferimenti futuri.
• Ricontrolla e aggiorna regolarmente i criteri di accesso per allinearli alle esigenze di sicurezza in evoluzione.

Considerazioni finali

Nell’attuale panorama dinamico dell’IT, strumenti come NinjaOne possono essere complementari a script come questo, fornendo una piattaforma integrata per la gestione delle operazioni IT che comprenda anche le configurazioni di sicurezza. La capacità di NinjaOne di centralizzare le attività di gestione garantisce l’applicazione coerente dei criteri di sicurezza all’intera infrastruttura IT, migliorando la sicurezza complessiva e l’efficienza operativa.