Voici le résultat de quelques uns de mes essais / amusements sur Powershell sur Linux. Deux scripts, le premier Get-LinuxUsers permet de récupérer la liste des utilisateurs, en effectuant des filtres sur certains critères, le second Get-LinuxGroups permet de récupérer les différents groupes disponibles sur la machine Linux, de filtrer également, et surtout pour les deux, d'afficher dans un format moins "sale" le contenu du fichier (cat /etc/groups , plus JAMAIS).

Vous pouvez juste copier / coller les scripts (disponibles en fin d'article) dans une fenêtre powershell linux pour pouvoir vous servir ensuite des fonctions.

Enjoy :)

Get-LinuxUsers

Ce script permet de lister l'intégralité des comptes utilisateurs, ou de filtrer par certains critères en utilisant une syntaxe précise.

Par exemple : Get-LinuxUsers nicolas

Il est également possible de filtrer selon l'ensemble des paramètres disponibles sur un utilisateur.

Afin de rester cohérent avec l'univers Linux et Powershell, les filtres ne sont pas sensibles à la casse, mais j'ai mis en place l'utilisation de -ceq (Case sensitive Equals) et -clike (Case sensitive Like) afin de prendre en compte la casse. Dans l'exemple ci-dessous, notez la majuscule à "Bash".

Les opérateurs disponibles sont :

• -like
• -eq
• -ceq
• -clike

Get-LinuxGroups

Ce script permet de lister les groupes disponibles sur l'ordinateur, de les filtrer et de les traiter comme des objets plutôt que du texte. Il se base sur les informations recueillies dans le fichier /etc/group qu'il retranscrit sous forme d'objets.

Par exemple : Get-LinuxGroups

Un filtre est disponible sur le nom, l'id ou alors le membre du groupe.

Supposons que nous cherchons un groupe dans lequel l'utilisateur nicolas est.

Ou alors un groupe commençant par "a"

Et le mieux? Il est possible de mixer les deux commandes! Par exemple, obtenir les informations de tous les utilisateurs dans le groupe 'adm'

![gluglg](gluglg.png#center "Infos d'utilisateurs du groupe "adm"")

Ou (en inversant les deux commandes), obtenir les informations de groupes portant le nom des utilisateurs

Voila pour la démonstration!

En espérant que ça vous sera utile.

Voici les deux scripts, n'hésitez pas à me faire part de vos remarques et idées. Je compte bientôt travailler sur un script permettant d'ajouter / modifier / supprimer des utilisateurs sous Linux, je vous le partagerai dès qu'il sera fini.

Les deux scripts sont disponibles sur mon espace git personnel :

• Get-LinuxUsers
• Get-LinuxGroups

Script Get-LinuxUsers

function Get-LinuxUsers
{
    [CmdletBinding(
        SupportsShouldProcess=$false,
        HelpUri="http://nicolaslang.blogspot.com"
    )]
    param(
        [Parameter (Position=0, ValueFromPipeline=$true)]
        [ValidateNotNullOrEmpty()]
        [string]$name,
        [Parameter (Mandatory=$false)]
        [ValidateNotNullOrEmpty()]
        [ValidatePattern('(?&ltpropertyname&gt(Name|Pass|ID_User|ID_Group|Comment|Home|Shell))\s+(?&ltoperator&gt(-like|-eq|-ceq|-clike))\s+"(?&ltvalue&gt.*)"')]
        [string]$filter,
        [Parameter (DontShow,ValueFromPipelineByPropertyName=$true)]
        [AllowNull()]
        $totallist
    )

    $users = Get-content /etc/passwd
    $userarray = New-Object System.Collections.ArrayList
    foreach ($user in $users)
    {
        $splitted = $user.split(":")
        $object = [PSCustomObject]@{
            "Name" = $splitted[0]
            "Pass" = $splitted[1]
            "ID_User" = $splitted[2]
            "ID_Group" = $splitted[3]
            "Comment" = $splitted[4]
            "Home" = $splitted[5]
            "Shell" = $splitted[6]
        }
        $userarray.Add($object) | Out-Null    

    }
    if($totallist)
    {
        $return = $userarray | Where-Object {$_.name -in $totallist.split(",")}
        return $return
    }
    if ($filter)
    {
        $filter -match '(?&ltpropertyname&gt(Name|Pass|ID_User|ID_Group|Comment|Home|Shell))\s+(?&ltoperator&gt(-like|-eq|-ceq|-clike))\s+"(?&ltvalue&gt.*)"' | Out-Null

        Switch ($matches.operator)
        {
            "-like" {$return = $userarray | Where-Object {$_.$($matches.propertyname) -like "$($matches.value)"}}
            "-clike"{$return = $userarray | Where-Object {$_.$($matches.propertyname) -clike "$($matches.value)"}}
            "-eq"   {$return = $userarray | Where-Object {$_.$($matches.propertyname) -eq "$($matches.value)"}}
            "-ceq"  {$return = $userarray | Where-Object {$_.$($matches.propertyname) -ceq "$($matches.value)"}}
        }
        return ($return)

    }
    elseif ($name) {
        $return = $userarray | Where-Object {$_.name -eq $name}
        return ($return)
    }
    else {
        return $userarray    
    }

}

Script Get-LinuxGroups

function Get-LinuxGroups 
{
    [CmdletBinding(
        SupportsShouldProcess=$false,
        HelpUri="http://nicolaslang.blogspot.com"
    )]
    param(
    [Parameter (Position=0, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true)]
    [ValidateNotNullOrEmpty()]
    [string]$Name,
    [Parameter (Mandatory=$false)]
    [ValidateNotNullOrEmpty()]
    [ValidatePattern('(?&ltpropertyname&gt(Name|ID_Group|Member))\s+(?&ltoperator&gt(-like|-eq|-ceq|-clike))\s+"(?&ltvalue&gt.*)"')]
    [string]$filter
    )
    begin
    {
        $groups = Get-Content /etc/group
        $grouparray = New-Object System.Collections.ArrayList

        $maxgroup = 0
        #Calcul de la valeur maxgroup
        foreach ($group in $groups)
        {
            $splitted = $group.split(":")
            $count = $splitted[-1].split(",")

            if ($count.count -gt $maxgroup)
            {
                $maxgroup = $count.count

            }
        }

        foreach ($group in $groups)
        {
            $splitted = $group.split(":")
            $count = $splitted[-1].split(",")
            $object = [PSCustomObject]@{
                "Name" = $splitted[0]
                "ID_Group" = $splitted[2]
            }
            $loop = 0

            foreach ($member in $count)
            {
                $object | Add-Member -Name "Member $($loop + 1)" -MemberType NoteProperty -Value $member 
                $loop++
            }
            while ($loop -lt $maxgroup)
            {
                $object | Add-Member -Name "Member $($loop + 1)" -MemberType NoteProperty -Value ""
                $loop++

            }

            $object | Add-Member -name "TotalList" -MemberType NoteProperty -Value $count
            $grouparray.Add($object) | Out-Null    
        }

            #Définition des paramètres affichés par défaut

            $defaultProperties = ($grouparray | Get-Member | Where-Object {$_.membertype -eq "NoteProperty" -and $_.name -like "Member*"}).Name
            $defaultDisplayPropertySet = New-Object System.Management.Automation.PSPropertySet(‘DefaultDisplayPropertySet’,[string[]]$defaultProperties)
            $defaultdisplaypropertyset.ReferencedPropertyNames.insert(0,"ID_Group")
            $defaultdisplaypropertyset.ReferencedPropertyNames.insert(0,"Name")
            $PSStandardMembers = [System.Management.Automation.PSMemberInfo[]]@($defaultDisplayPropertySet)

            $grouparray | Add-Member MemberSet PSStandardMembers $PSStandardMembers

    }

    Process
    {
        if ($filter)
        {
            $filter -match '(?&ltpropertyname&gt(Name|ID_Group|Member))\s+(?&ltoperator&gt(-like|-eq|-ceq|-clike))\s+"(?&ltvalue&gt.*)"' | Out-Null

            if ($matches.propertyname -eq "Member")
            {

                Switch ($matches.operator)
                {
                    "-like" {
                                $return = $grouparray | Where-object {$_.totallist.split(",") -like "$($matches.value)"}
                            }
                    "-clike"{
                                $return = $grouparray | Where-object {$_.totallist.split(",") -clike "$($matches.value)"}
                            }
                    "-eq"   {
                                $return = $grouparray | Where-object {$_.totallist.split(",") -eq "$($matches.value)"}
                            }   
                    "-ceq"  {
                                $return = $grouparray | Where-object {$_.totallist.split(",") -ceq "$($matches.value)"}
                            }
                }

                return $return
            }
            else 
            {
                Switch ($matches.operator)
                {
                    "-like" {$return = $grouparray | Where-Object {$_.$($matches.propertyname) -like "$($matches.value)"}}
                    "-clike"{$return = $grouparray | Where-Object {$_.$($matches.propertyname) -clike "$($matches.value)"}}
                    "-eq"   {$return = $grouparray | Where-Object {$_.$($matches.propertyname) -eq "$($matches.value)"}}
                    "-ceq"  {$return = $grouparray | Where-Object {$_.$($matches.propertyname) -ceq "$($matches.value)"}}
                }
                return $return
            }
        }
        elseif ($name)
        {
            return $($grouparray | Where-Object {$_.name -eq $name})
        }
        else 
        {
            return $grouparray    
        }
    }
}