Délégation de scripts PowerShell avec Just Enough Administration (JEA)

Avez-vous déjà voulu déléguer une tâche, mais vous avez constaté que les autorisations nécessaires peuvent être trop risquées à distribuer? Ou, avez-vous voulu verrouiller des choses comme la création de groupes dans AD pour appliquer les conventions de dénomination des groupes?

JEA peut vous aider avec cela et bien plus encore. Dans cet article, nous allons voir comment vous pouvez déléguer vos scripts déjà créés avec PowerShell 5.1.

Qu'est-ce que JEA?

JEA est une solution PowerShell de Microsoft qui peut restreindre les utilisateurs (et administrateurs) à ne pouvoir effectuer que les tâches spécifiées dans une session PowerShell spécifique, même s'ils nécessitent un administrateur local sur ladite ressource. De plus, vous pouvez être extrêmement précis. Seules les commandes que vous spécifiez peuvent être exécutées, vous ne pouvez activer que des valeurs de paramètres spécifiques et des valeurs de paramètres qui correspondent à un modèle spécifique.

Par exemple, vous pouvez activer Servicedesk pour redémarrer uniquement un service spécifique avec Restart-Service, ou ajoutez uniquement des groupes à AD selon une convention de dénomination spécifique. Vous pouvez faire tout cela sans leur donner d'autorisations explicites sur un serveur ou dans AD. C'est un outil qui peut vous faire gagner énormément de temps et sécuriser votre environnement. Commençons par encapsuler notre script dans une fonction.

Étape 1: création d'une fonction à partir de votre script

Si vous ne l'avez pas déjà fait, la première étape consiste à créer une fonction à partir de votre script. C'est assez facile, en supposant que vous avez déjà votre parameters installer. Ci-dessous, j'ai enveloppé mon script simple «New-FolderAndShare» dans une fonction:

Function New-FolderAndShare {
    (cmdletbinding())
    param(
        # Name of the share
        (parameter(Mandatory))
        (ValidatePattern("^(Project d{5}|Team (Finance|HR|IT|Multi) (a-z )+)$"))
        (string)$ShareName,

        # Directory of the new share folder locally
        (parameter(Mandatory))
        (ValidatePattern("^(D|E|F):\Shares\$"))
        (string)$Path,

        # Who to have full access
        (parameter(Mandatory))
        (ValidateSet("^CONTOSO\"))
        (string)$FullAccess

    )

        $FullPath = Join-Path $Path $ShareName
    New-Item -ItemType Directory -Path $FullPath
    New-SmbShare -Path $FullPath -Name $ShareName -FullAccess $FullAccess

}

Vous validez les paramètres avec ValidatePattern dans la fonction, mais si cela faisait partie d'un module, vous pouvez le faire dans le fichier RoleCapabilities à la place avec VisibleFunctions.

Faire du script une fonction nous donne un meilleur contrôle des paramètres autorisés dans JEA et facilite l'exportation.

Étape 2: création de RoleCapabilities

Le fichier RoleCapabilities décide ce qu'un rôle spécifié (défini à l'étape suivante) est autorisé à faire. Cela inclut les commandes qu'ils sont autorisés à exécuter, les paramètres qu'ils peuvent utiliser et les modules à importer.

Bien que RoleCapabilities puisse être créé manuellement, il est recommandé d'utiliser le New-PSRoleCapabilityFile commande intégrée à PowerShell 5.1. C'est également dans ce fichier que vous allez charger dans la fonction que nous avons créée à l'étape précédente.

Le script suivant crée un fichier appelé FileShareCreator.psrc et ajoute le New-FolderAndShare fonction (qui doit être chargée dans la session en cours):

# RUN THIS IN THE SERVER THAT WILL BE THE JEA ENDPOINT

$RoleCapabilitiesParam = @{
    # Define a function that will be available in the cmdlet
    FunctionDefinitions = @{ 
        Name = 'New-FolderAndShare'
                # Import the code of the function
        ScriptBlock =  (ScriptBlock)::Create(
            (Get-Command New-FolderAndShare).Definition
        )
    }

    # Modules used in the function needs to be explicity imported
    ModulesToImport = @(
        "SmbShare",
        "Microsoft.PowerShell.Management"
    )
    Path = ".FileShareCreator.psrc"
}

New-PSRoleCapabilityFile @RoleCapabilitiesParam

Utiliser Get-Command pour récupérer la fonction dans le FunctionDefinitions-paramètre. Vous pouvez également ajouter le script brut avec des paramètres.

Vous spécifiez également comment vous êtes autorisé à utiliser la fonction dans le VisibleCmdlet paramètre. Pour ce faire, spécifiez le nom de la fonction et ses paramètres avec une expression régulière.

Avec cela, vous pouvez créer un contrôle extrêmement granulaire de ce qu'un utilisateur peut et ne peut pas faire. Mais il y a une mise en garde pour que cela fonctionne: vous devez ajouter le fichier psrc dans un module.

Étape 3: création d'un module pour le fichier RoleCapability

Il est temps de créer un module dans lequel vous pouvez mettre vos capacités de rôle. JEA trouve les RoleCapabilities par le nom des fichiers psrc sans son extension, donc évitez les doublons si vous comptez créer plus de capacités de rôle plus tard.

Le script suivant est une version modifiée de ce que vous trouverez dans la documentation officielle JEA. Il crée un nouveau module dans le répertoire du module, crée les fichiers et dossiers nécessaires et copie le psrc fichier que vous avez créé à l'étape 2:

# RUN THIS IN THE SERVER THAT WILL BE THE JEA ENDPOINT

# Create a folder for the module
$modulePath = Join-Path $env:ProgramFiles "WindowsPowerShellModulesFileShareJEA"
New-Item -ItemType Directory -Path $modulePath

# Create an empty script module and module manifest.
# At least one file in the module folder must have the same name as the folder itself.
New-Item -ItemType File -Path (Join-Path $modulePath "FileShareJEA.psm1")
New-ModuleManifest -Path (Join-Path $modulePath "FileShareJEA.psd1") -RootModule "FileShareJEA.psm1"

# Create the RoleCapabilities folder and copy in the PSRC file
$rcFolder = Join-Path $modulePath "RoleCapabilities"
New-Item -ItemType Directory $rcFolder
Copy-Item -Path .FileShareCreator.psrc -Destination $rcFolder

Vous avez maintenant créé une fonction de rôle et une fonction pour pouvoir l'utiliser dans JEA. Il ne reste plus qu'à créer une configuration de session PowerShell pour mapper les groupes AD aux rôles que vous venez de créer.

Étape 4: définition des rôles

Dans cette étape, vous allez créer un fichier de configuration de session PowerShell qui définit quels rôles vont être assignés quelles capacités (à partir du.psrc fichier que nous avons créé à l'étape 2).

Vous allez également créer le groupe AD et le répertoire de transcription ici.

# Create directory to store logs
New-Item -ItemType Directory -Path 'C:ProgramDataJEAConfigurationTranscripts' -Force

# Create AD group (you might need to do it on another server)
New-ADGroup -Path "OU=Groups,DC=contoso,DC=com" -Name 'JEA_FILESHARE_CREATOR' -GroupScope DomainLocal

# RUN THIS IN THE SERVER THAT WILL BE THE JEA ENDPOINT

# Define parameters for New-PSSessionConfigurationFile
$PSSessionConfigurationParams = @{
    # Run as a temporary account
    RunAsVirtualAccount = $True

    # That is a local administrator
    RunAsVirtualAccountGroups = @(
        "administrators"
    )

    # Path where to save log files of what connected users are doing
    TranscriptDirectory = 'C:ProgramDataJEAConfigurationTranscripts'

    # Map an active directory group to the capability we created
    RoleDefinitions = @{
        'CONTOSOJEA_FILESHARE_CREATOR' = @{
            RoleCapabilities = 'FileShareCreator'
        }
    }
        
        # Path of the PSSC file
    Path = ".SessionConfiguration.pssc"

}
# Create the PSSC file
New-PSSessionConfigurationFile @PSSessionConfigurationParams

Étape 5: création d'une session PowerShell

Dans cette étape, vous lirez dans le SessionConfiguration.pssc fichier que vous avez créé à l'étape précédente. Cela permet aux membres de JEA_FILESHARE_CREATOR pour se connecter via PowerShell au serveur:

PS51> Register-PSSessionConfiguration -Path .SessionConfiguration.pssc -Name 'JEAFileShare' -Force

PSPath            : Microsoft.WSMan.ManagementWSMan::localhostPluginJEAFileShare
PSParentPath      : Microsoft.WSMan.ManagementWSMan::localhostPlugin
PSChildName       : JEAFileShare
PSDrive           : WSMan
PSProvider        : Microsoft.WSMan.ManagementWSMan
PSIsContainer     : True
Keys              : {Name=JEAFileShare}
Name              : JEAFileShare
TypeNameOfElement : Container
Type              : Container

Vous avez terminé! Ajouter un utilisateur à JEA_FILESHARE_CREATOR qui n'a pas accès au serveur par des moyens normaux et essayez-le en tant qu'utilisateur en tapant:

PS51> Enter-PSSession -ComputerName fs02.contoso.com -ConfigurationName JEAFileShare
PS51> New-FolderAndShare -ShareName "Project 12345" -Path D:Share

Vous pouvez maintenant exécuter la commande en tant qu’administrateur local temporaire verrouillé et uniquement activé pour exécuter quelques commandes par défaut (visible avec Get-Command pendant la session) et le New-FolderAndShare fonction ajoutée dans le fichier des capacités de rôle.

Si vous souhaitez voir le compte créé temporairement, ajoutez VisibleExternalCommands @('c:windowssystem32whoami.exe') à vos paramètres RoleCapabilities à l'étape 2. Vous pouvez exécuter whoami et voir le nom de l'administrateur local:

PS51 >whoami
winrm virtual userswinrm va_1_contoso_joe_helpdesk

Sommaire

L'utilisation de JEA peut être un moyen génial et facile de déléguer des tâches et de sécuriser votre environnement. Cela n'inclut pas seulement vos propres scripts, mais également les modules intégrés et les modules installés. Même si JEA peut être une grande valeur ajoutée, faites attention! Vous pouvez créer un grand risque pour votre environnement si vous déléguez les mauvaises commandes ou spécifiez les mauvais paramètres à des individus inattendus.

Envie d'en savoir plus?