Le blog technique

Toutes les astuces #tech des collaborateurs de PI Services.

#openblogPI

Voir tous les articles

Retrouvez les articles à la une

[Microsoft Graph] – Delegated permissions vs Application permissions

par | 2 Août 2024 | ,

 

Les permissions Microsoft Graph.

Les permissions attribuées au sein d’un Tenant Microsoft 365 (types et étendues) peuvent avoir un impact sur ce dernier, il est donc important de bien identifier votre besoin pour les attribuer.

Lorsque l’on délègue des permissions Microsoft Graph à une App dans un Tenant, celle-ci peut se voir attribuer deux types « Delegated » ou « Application« , nous allons tenter de voir la différence entre les deux.

Pour illustrer ces deux types nous allons nous référer à la présentation de Microsoft ci dessous.

Delegated Permissions

Permet à une application, d’agir en tant que l’utilisateur pour une action spécifique.

Ces permissions sont orientées pour des applications qui accèdent en tant que l’utilisateur identifié et, ne pourront excéder la porté de l’utilisateur.

Prenons par exemple l’App « Demo-DelegatedPerm » cette dernière possède le droit « Mail.Send ».

Ce qui implique que lorsque l’utilisateur va vouloir utiliser cette application un consentement va lui être demandé.

A partir du moment ou l’utilisateur aura donné son consentement l’application sera autorisé a envoyer des mails en son nom.

Attention : Dans ce type de délégation l’approbation peut être donnée soit :

  • Par l’utilisateur lorsqu’il utilise l’application.
  • Par l’Administrateur pour tous les utilisateurs du Tenant lorsqu’il donne les permissions. 

 

Application Permissions

Permet à une application d’agir en tant qu’elle même, au lieu d’un utilisateur spécifique.

Ces permissions sont orientées pour des applications qui accèdent en tant qu’application elles mêmes et, auront une porté d’action sur l’ensemble du Tenant.

Prenons ici l’App « Demo-ApplicationPerm » cette dernière possède le droit « Mail.Send ».

Ce qui implique que lorsque l’Administrateur va approuver les droits, cette application sera en mesure d’envoyer des mails depuis n’importe quelle boite aux lettres du tenant.

 

 

Qu’est ce que ça implique ?

En terme d’accès nous pouvons constater que l’un est beaucoup plus permissif que l’autre (encore que cela soit discutable si c’est l’administrateur qui a consenti) et, qu’il faut à minima restreindre la porté de l’accès.

En effet dans un contexte de moindre privilèges, l’attribution des droits via « Application Permissions » doit être contenu / restreint afin d’en limiter sa portée; ainsi nous pourrons nous prémunir d’une application avec une trop grande portée d’action sur l’environnement.

 

Intune : Désactiver le compte Administrateur local par défaut

par | 24 Juil 2024 | ,

Afin de désactiver le compte Administrateur local par défaut dans Windows, ceci peut être simple en utilisant un script de remédiation Intune.

Script de détection :

$user = (Get-WmiObject -Class Win32_UserAccount -Filter 'LocalAccount = True ' | Where-Object SID -Like 'S-1-5-*-500').Name
$Status= (Get-WmiObject -Class Win32_UserAccount -Filter 'LocalAccount = True ' | Where-Object SID -Like 'S-1-5-*-500').Disabled 
if ($Status -eq $false)
{
  Write-Host "$user is Enabled" 
  Exit 1
} 
Else {
  Write-Host "$user is not Enabled"
  Exit 0
}

Script de remédiation :

$user = (Get-WmiObject -Class Win32_UserAccount -Filter 'LocalAccount = True ' | Where-Object SID -Like 'S-1-5-*-500').Name
$Status= (Get-WmiObject -Class Win32_UserAccount -Filter 'LocalAccount = True ' | Where-Object SID -Like 'S-1-5-*-500').Disabled
if ($Status -eq $false)
{
try{

NET USER $user /active:No
Exit 0
}
Catch {
Write-Host "$user is already Disabled"
Write-error $_
Exit 1
}
}
Else {
Write-Host "$user is already Disabled"
Exit 1
}



[Powershell] – Fonction pour obtenir les membres des groupes Active Directory supérieur à 5000 objets.

par | 14 Juil 2024 | ,

Problème :

Il existe une limitation à la commande « Get-ADGroupMember » et cette dernière est de 5000, ce qui veut dire que si le groupe détient plus de 5000 membres vous obtiendrez un joli message d’erreur du type :

Get-ADGroupMember : The size limit for this resquest was exceeded

Solution :

Voici une fonction Powershell qui vous permettra de récupérer l’intégralité des membres d’un groupe même s’il y en a 10 000 dedans.

Vous pourrez choisir de retourner :

  • Les utilisateurs
  • Les groupes
  • Le tout
<pre class="wp-block-syntaxhighlighter-code">Function Get-AllMembers {
     <#
    .SYNOPSIS
    Return a list of members for a group.

    .DESCRIPTION
    Get-AllMembers is a function that returns a list of members for a specific group.
    
    .PARAMETER Name
    The name of the group you want to get the member list.

    .EXAMPLE
    Get-AllMembers "Domain Admins", "DNS Admins"

    .INPUTS
    String

    .OUTPUTS
        PSCustomObject

    .NOTES
        Author:  ADELAIDE Mathieu
    #>
    PARAM (
        [Parameter(Mandatory = $true, ValueFromPipeline = $true, Position = 0)]
        [STRING]$Name,
        [Parameter(Mandatory = $true, ValueFromPipeline = $true, Position = 1)]
        [ValidateSet("UsersOnly","GroupsOnly","All")]
        [STRING]$Return
        )
    Process {
        $Name | Foreach {
            $GroupName = $_
            $ArrayUsers = @()
            $ArrayGroups = @()
            $ArrayAll = @()
            Try {
                $DistinguishedName = Get-ADGroup -Identity $GroupName -ErrorAction Stop | select -ExpandProperty DistinguishedName
                # Searching all Users who's member of current Group
                Try {
                    $AllUsersMembers = Get-ADUser -LDAPFilter "(&(objectCategory=user)(memberOf=$DistinguishedName))" -ErrorAction Stop
                    $AllUsersMembers | foreach {
                        $ArrayUsers += New-Object psobject -Property @{
                            GroupName = $GroupName
                            DistinguishedName = $_.DistinguishedName
                            Enabled = $_.Enabled
                            GivenName = $_.GivenName
                            Name = $_.Name
                            ObjectClass = $_.ObjectClass
                            ObjectGUID = $_.ObjectGUID
                            SamAccountName = $_.SamAccountName
                            SID = $_.SID
                            Surname = $_.Surname
                            UserPrincipalName = $_.UserPrincipalName
                            }

                        # Collect All
                        $ArrayAll += New-Object psobject -Property @{
                            GroupName = $GroupName
                            DistinguishedName = $_.DistinguishedName
                            Enabled = $_.Enabled
                            GivenName = $_.GivenName
                            Name = $_.Name
                            ObjectClass = $_.ObjectClass
                            ObjectGUID = $_.ObjectGUID
                            SamAccountName = $_.SamAccountName
                            SID = $_.SID
                            Surname = $_.Surname
                            UserPrincipalName = $_.UserPrincipalName
                            }
                        }
                    }
                Catch {
                    Write-Warning -Message "Unable to find all users member of $Name"
                    }
                # Searching all Groups who's member of current Group
                Try {
                    $AllGroupsMembers = Get-ADGroup -LDAPFilter "(&(objectCategory=group)(memberOf=$DistinguishedName))" -ErrorAction Stop
                    $AllGroupsMembers | foreach {
                        $ArrayGroups += New-Object psobject -Property @{
                            GroupName = $GroupName
                            DistinguishedName = $_.DistinguishedName
                            GroupCategory = $_.GroupCategory
                            GroupScope = $_.GroupScope
                            Name = $_.Name
                            ObjectClass = $_.ObjectClass
                            ObjectGUID = $_.ObjectGUID
                            SamAccountName = $_.SamAccountName
                            SID = $_.SID
                            }

                        # Collect All
                        $ArrayAll += New-Object psobject -Property @{
                            GroupName = $GroupName
                            DistinguishedName = $_.DistinguishedName
                            Enabled = $_.Enabled
                            GivenName = $_.GivenName
                            Name = $_.Name
                            ObjectClass = $_.ObjectClass
                            ObjectGUID = $_.ObjectGUID
                            SamAccountName = $_.SamAccountName
                            SID = $_.SID
                            Surname = $_.Surname
                            UserPrincipalName = $_.UserPrincipalName
                            }
                        }
                    }
                Catch {
                    # Return an error message if member not found.
                    Write-Warning -Message "Unable to find all groups member of $Name"
                    }
                }
            Catch {
                # Return an error message if Group was not found.
                Write-Warning -Message "Unable to find $Name"
                }
            
            Switch ($Return) {
                "UsersOnly" {Return $ArrayUsers}
                "GroupsOnly" {Return $ArrayGroups}
                "All" {Return $ArrayAll}
                }

            # Release
            $GroupName = $null
            $DistinguishedName = $null
            $AllUsersMembers = $null
            $AllGroupsMembers = $null
            }
        }
    }</pre>

Derniers articles

Catégories

Archives

Auteurs/Autrices