Rechercher et verrouiller les autorisations de partage Windows laxistes – Bien choisir son serveur d impression

Jusqu'à présent, vous pouvez obtenir une liste de tous les partages de fichiers et vérifier tous les fichiers avec le wrapper PowerShell pour Invoke-AccessChk. L'une des nombreuses forces de PowerShell est sa capacité à évoluer. La communication à distance PowerShell portera le code que nous avons produit au niveau supérieur pour recueillir les informations de plusieurs ordinateurs à la fois.

Tout d'abord, nous avons besoin d'une liste d'ordinateurs et de serveurs à analyser. Si possible, le moyen le plus simple consiste à utiliser le module Active Directory de RSAT:

$ Computers = (Get-ADComputer -Filter *). DnsHostName

Cette méthode n'est peut-être pas une option dans les environnements plus vastes fortement segmentés. Une autre approche consiste à obtenir des données de votre base de données de gestion de configuration ou à les saisir manuellement à l'aide de l'exemple suivant:

$ Ordinateurs = @ (
            'Server1',
            «Server2»,
            «Server3»,
            «Server4»,
            «Server5»,
        «PC1»
        # etc
    )

Il est maintenant temps de lier tous ces composants dans un script qui utilise des travaux d'arrière-plan PowerShell pour effectuer les actions suivantes sur les machines spécifiées dans le $ Ordinateurs paramètre:

• Obtenez tous les partages partagés avec l'un des principaux dans $ RiskPrincipals.
• Téléchargez AccessChk s'il n'existe pas déjà.
• Vérifiez l'autorisation NTFS de tous les partages rassemblés par AccessChk.
• Renvoyer un objet avec une liste avec tous les fichiers où les principaux de sécurité dans $ RiskPrincipals avoir des autorisations de lecture ou d'écriture.

L'ordinateur exécutant le script collectera ensuite les résultats de tous les travaux et les affichera dans un fichier CSV portant le nom ShareAccessReport.

N'oubliez pas d'exécuter ce qui suit en tant qu'administrateur sur un ordinateur disposant d'un accès réseau auxdites machines et d'accepter le CLUF pour AccessChk en modifiant $ AcceptEula à vrai:

$ Ordinateurs = @ (
            «Serveur-1»,
            «Serveur-2»,
            «PC-1»
    )
    # Accepter le CLUF pour AccessChk
    # CHANGER EN VRAI
    $ AcceptEula = $ false
    if (! $ AcceptEula) 
            Write-Warning "N'a pas accepté le CLUF pour AccessChk, ne peut pas continuer"
        Pause
    
    # Principaux que nous voulons rechercher
    $ RiskPrincipals = @ (
            'Toutes les personnes',
            «Utilisateurs du domaine»,
            «Ordinateurs de domaine»,
            'Utilisateurs authentifiés',
            'Utilisateurs'
    )
    # Liste des partages que nous voulons ignorer.
    # Définir un nom de partage lié juste au cas où, car il devrait presque toujours être ce chemin
    $ IgnoreShares = @ (
            'print $'
    )
    # Scriptblock que nous enverrons avec Invoke-Command
    $ Scriptblock = {
            $ RiskPrincipals = $ args[0].RiskPrincipals
            $ IgnoreShares = $ args[1].IgnoreShares
            $ AcceptEula = $ args[2].AccepterEula
            # Fonctions pour télécharger et utiliser AccessChk
            # Il utilise un objet shell au lieu de Expand-Archive pour une compatibilité descendante
            Fonction Download-AccessChk 
                    param (
                            $ Url = "https://download.sysinternals.com/files/AccessChk.zip",
                            $ Dest = $ env: temp
                    )
                    if (Test-Path "$ dest  accesschk.zip") 
                            rm $ Dest  AccessCHK.zip -Force
                    
                    (New-Object System.Net.WebClient) .DownloadFile ($ url, "$ env: temp  AccessChk.zip")
                    $ Shell = New-Object -ComObject Shell.Application
                    $ Zip = $ shell.NameSpace ("$ env: temp  AccessChk.zip")
                    $ Destination = $ shell.NameSpace ("$ env: windir  system32 ")
                    $ copyFlags = 0x00
                    $ copyFlags + = 0x04
                    $ copyFlags + = 0x10
                    $ Destination.CopyHere ($ Zip.Items (), $ copyFlags)
            
            # La fonction qui utilise accesschk de la partie 2
            Fonction Invoke-AccessChk {
                    param (
                            $ Path,
                            $ Directeurs,
                            $ AccessChkPath = "$ env: windir  system32  accesschk64.exe",
              [switch]$ Répertoires
              [switch]$ AcceptEula
          
                    )
                    if (! (Test-Path "$ env: windir  system32  accesschk64.exe")) 
                            Download-AccessChk
                    
                    # Accepter le CLUF 
                    if ($ AcceptEula) 
                            & $ AccessChkPath / accepteula 
                    $ Argument = "uqs"
                    if ($ DirectoriesOnly) 
                            $ Argument = "udqs"
                    
                    $ Output = & $ AccessChkPath -nobanner - $ Argument $ Path
      
                    Foreach ($ Row dans $ Output) 
                            # Si c'est une ligne avec un chemin de fichier, sortez l'objet précédent et créez-en un nouveau
                            if ($ Row -match "^  S") 
                                    If ($ Null -ne $ Object) 
                                            if ($ Object.Access.Keys.Count -gt 0) 
                                                    $ Object
                                            
                                    
                                    $ Object = [PSCustomObject]@ 
                                            Chemin = $ Ligne
                                            Accès = @ 
                                    
                            
                            # S'il s'agit d'une ligne avec des autorisations
                            if ($ Row -match "^  [R ][W ]") "))  Out-Null        
                  
                                            $ Object.Access[$Matches.Principal] = @ 
                                                    Read = $ Matches.Read -eq 'R'
                                                    Write = $ Matches.Read -eq 'W'
                                            
                                    
                            
                    
                    # Si c'est la dernière ligne - sortez l'objet une fois de plus
                    if ($ Object.Access.Keys.Count -gt 0) 
                            $ Object
                    
            }
            # Obtenez tous les partages en utilisant WMI
            $ Shares = Get-WmiObject -Class win32_share
            # Créez un objet que nous reviendrons plus tard lorsque nous aurons terminé
            $ ReturnObject = [PSCustomObject]@ 
                    ComputerName = $ ComputerName
                    NetworkShares = [System.Collections.Generic.List[PSCustomObject]]::Nouveau()
                    AccessibleObjects = @ 
            
            # Ignorez les partages par défaut en filtrant '2147483648'
            # Ignorer les parts de $ IgnoreShares
            foreach ($ Part en $ Actions |? $ _. Tapez -ne '2147483648' |? $ _. Nom -notin $ IgnoreShares) {
                    $ ShareObject = [PSCustomObject]@ 
                            Nom = $ Share.Name
                            Description = $ Share.Description
                            LocalPath = $ Share.Path
                            ACL = [System.Collections.ArrayList]::Nouveau()
                    
                    $ ShareSecurity = Get-WMIObject -Class Win32_LogicalShareSecuritySetting -Filter "name = '$ ($ Share.Name)'" "
                    if ($ Null -ne $ ShareSecurity) {
                            Essayer  
                                    $ SecurityDescriptor = $ ShareSecurity.GetSecurityDescriptor (). Descriptor    
          
                                    foreach ($ AccessControl dans $ SecurityDescriptor.DACL)  Out-Null
                                    
                                    # Ajouter un partage réseau uniquement s'il contient un utilisateur / groupe à risque
              
                                    $ Match = $ False
                                    Foreach ($ IdentityReference dans $ ShareObject.ACL.IdentityReference.Value) 
                                            Foreach ($ Pattern in $ RiskPrincipals) 
                                                    if ($ IdentityReference -Match $ Pattern)                
                                                            $ Match = $ True
                                                    
                                            
                                    
                                    if ($ Match) 
                                            $ ReturnObject.NetworkShares.Add ($ ShareObject)    
                                    
                                    Autre 
                                            Write-Verbose "Aucune correspondance pour les groupes à risque, n'ajoutant pas"
                                    
                 
                            
                            Capture
                                    Erreur d'écriture $ Erreur[0]
                            
                    }
                    Autre 
                            Write-Information "Aucune autorisation trouvée pour $ ($ Share.Name) sur $ ComputerName"
                    
        
            }
            # Obtenez tous les fichiers de NetworkShares où un principal de $ RiskPrincipals a un accès en lecture ou en écriture
            $ ReturnObject.NetworkShares | Pour chaque 
                    $ ReturnObject.AccessibleObjects[$_.Name] = Invoke-AccessChk -Path $ _. LocalPath -Principals $ RiskPrincipals -AcceptEula: $ AcceptEula
            
            # Terminé! Permet de renvoyer l'objet de retour:
            $ ReturnObject
    }
    # À ajouter à la liste d'arguments d'Invoke-Job car le travail PowerShell distant n'a pas accès à notre espace variable.
    $ InvokeParam = @ 
            RiskPrincipals = $ RiskPrincipals
            IgnoreShares = $ IgnoreShares
            AcceptEula = $ AcceptEULA
    
    # Commencer les travaux
    $ Job = Invoke-Command -AsJob -ComputerName $ Computers -ArgumentList $ InvokeParam -ScriptBlock $ Scriptblock
    # Attendez la fin des travaux
    $ Job | Wait-Job
    # Collecte des données de tous les travaux
    $ Output = Get-Job | Receive-Job
    # Sortie de la sortie dans un CSV
    $ ToCSV = Foreach ($ Résultat dans $ Output) {
            Foreach ($ Entrez $ Result.AccessibleObjects.Keys)  Sélectionnez @ Name = 'ShareName'; Expression = $ Key, Path, $ ReadAccess, $ WriteAccess
            
    }
    # Exporter le CSV
    $ ToCSV | Export-Csv -Path.  ShareAccessReport.csv

Lorsque le travail PowerShell se termine, il crée un rapport complet de l'accès des principaux dans le $ RiskyPrincipals variable.