Gérer les autorisations d’accès aux lecteurs amovibles : un guide PowerShell

Points à retenir

• Automatise les autorisations des appareils: Le script simplifie et optimise le processus de définition des autorisations sur les périphériques de stockage amovibles.
• Prise en charge de plusieurs appareils: Il couvre une multitude d’appareils, notamment USB, DVD, disquette, lecteur de bande et appareil portable Windows (WPD).
• Nécessite des droits d’administrateur: L’exécution du script nécessite des privilèges d’administrateur.
• Modifie les paramètres du registre: Il ajuste les autorisations en modifiant des clés et des valeurs spécifiques du registre.
• Assurer la conformité et la sécurité: Idéal pour les environnements où la sécurité des données et la conformité sont cruciales.
• Contrôle flexible: Permet de refuser et d’autoriser des actions de lecture, d’écriture et d’exécution.
• Mise à jour de la stratégie de groupe et redémarrage: Il se termine par une mise à jour de la stratégie de groupe et un redémarrage facultatif du système.
• Risque de restriction excessive: L’application de politiques trop restrictives risque d’entraver les flux de travail.
• Intégration à NinjaOne: Complète des plateformes comme NinjaOne pour une gestion et une sécurité informatiques plus larges.

La gestion de l’accès aux périphériques de stockage amovibles est un aspect essentiel de la sécurité informatique. Cette responsabilité est particulièrement prononcée dans les environnements où la sécurité et l’intégrité des données sont primordiales. Les scripts PowerShell, comme celui que nous présentons ici, constituent une solution performante pour contrôler efficacement ces autorisations.

Contexte

Le script en question est conçu pour activer ou désactiver l’accès en lecture, en écriture et en exécution à divers périphériques de stockage amovibles, notamment les lecteurs de disquettes, les lecteurs de CD/DVD, les lecteurs de bandes, les appareils portables Windows (WPD) et les lecteurs USB. Cette fonctionnalité est essentielle pour les professionnels de l’informatique et les fournisseurs de services gérés (MSP) qui doivent appliquer des politiques de sécurité des données, prévenir les fuites de données ou se conformer aux normes réglementaires.

Le script :

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

 

Description détaillée

Le script fonctionne en plusieurs phases distinctes :

• Définition des paramètres: Il commence par définir des paramètres pour différents types de périphériques et d’actions (refuser ou autoriser la lecture, l’écriture, l’exécution).
• Contrôles préalables à l’exécution: Il comprend des fonctions permettant de vérifier la présence de chaînes vides et de vérifier si le script est exécuté avec des privilèges élevés (administrateur).
• Ajustement des paramètres du registre: La fonctionnalité principale consiste à modifier les paramètres du registre pour chaque type d’appareil. Ces paramètres déterminent les autorisations pour chaque action (lecture, écriture, exécution).
• Logique d’exécution: Le script crée ou modifie les clés et les valeurs du registre en fonction des paramètres d’entrée. Il peut définir des autorisations pour refuser ou autoriser des actions sur les dispositifs spécifiés.
• Dernières étapes: Le script se termine par la mise à jour des stratégies de groupe à l’aide de gpupdate.exe et, éventuellement, par un redémarrage du système pour que les modifications soient prises en compte.

Cas d’utilisation potentiels

Pensez à une société financière qui doit respecter des règles strictes en matière de sécurité des données. Un administrateur informatique peut utiliser ce script pour désactiver l’accès en écriture aux lecteurs USB sur tous les postes de travail des employés, empêchant ainsi la copie de données sensibles sur des périphériques externes.

Comparaisons

Les méthodes traditionnelles de configuration des autorisations des appareils peuvent impliquer des modifications manuelles du registre ou des configurations de stratégie de groupe. Ce script automatise ces processus, ce qui réduit la marge d’erreur et permet de gagner du temps.

FAQ

• Le script est-il compatible avec toutes les versions de Windows ?
  • Il est compatible avec Windows 7 et les versions plus récentes, y compris les éditions pour serveur.

• Peut-il contrôler l’accès aux lecteurs du réseau ?
  • Non, il s’agit spécifiquement des périphériques de stockage amovibles.

• Le script nécessite-t-il des droits d’administration ?
  • Oui, il doit être exécuté avec des privilèges d’administrateur.

Implications

Bien que ce script est un outil puissant pour renforcer la sécurité des données, il comporte également le risque de restreindre l’accès de manière trop stricte, ce qui pourrait entraver les flux de travail légitimes. Il est essentiel de trouver un équilibre entre les besoins de sécurité et les exigences opérationnelles.

Recommandations

• Testez le script dans un environnement contrôlé avant de le déployer à grande échelle.
• Documentez toutes les modifications apportées à l’aide du script pour référence ultérieure.
• Révisez et mettez à jour régulièrement les politiques d’accès pour les adapter à l’évolution des besoins en matière de sécurité.

Conclusion :

Face la dynamicité du secteur informatique, des outils comme NinjaOne peuvent compléter des scripts de ce type en fournissant une plateforme intégrée pour la gestion des opérations informatiques, y compris les configurations de sécurité. La capacité de NinjaOne à centraliser les tâches de gestion garantit que les politiques de sécurité sont appliquées de manière cohérente dans l’ensemble de l’infrastructure informatique, améliorant ainsi la sécurité globale et l’efficacité opérationnelle.