Accorder l’accès uniquement via application Azure AD

Lorsque vous utilisez SharePoint Online, vous pouvez définir des applications dans Azure AD et ces applications peuvent se voir octroyées des autorisations dans SharePoint, mais aussi dans tous les autres services Office 365. Ce modèle est le modèle préféré dans le cas où vous utilisez SharePoint Online. Si vous utilisez SharePoint localement, vous devez utiliser le modèle SharePoint uniquement via Azure ACS basé, comme décrit ici.

Configuration d’une application Azure AD pour l’accès aux applications uniquement

Dans Azure AD, lorsque vous effectuez une application uniquement, vous utilisez généralement un certificat pour demander l’accès : toute personne disposant du certificat et de sa clé privée peut utiliser l’application et les autorisations accordées à l’application. Les étapes ci-dessous vous guident tout au long de la configuration de ce modèle.

Vous êtes maintenant prêt à configurer l’application Azure AD pour appeler SharePoint Online avec un jeton d’accès Application uniquement. Pour ce faire, vous devez créer et configurer un certificat X.509 auto-signé, qui sera utilisé pour authentifier votre application auprès d’Azure AD, tout en demandant le jeton d’accès Application uniquement. Tout d’abord, vous devez créer le certificat X.509 auto-signé, qui peut être créé à l’aide de l’outil makecert.exe disponible dans le SDK Windows, via un script PowerShell fourni qui n’a pas de dépendance à makecert ou avec une commande PowerShell PnP. L’utilisation du script PowerShell est la méthode recommandée et est expliquée dans ce chapitre.

Pour créer un certificat auto-signé avec ce script :

.\Create-SelfSignedCertificate.ps1 -CommonName "MyCompanyName" -StartDate 2017-10-01 -EndDate 2019-10-01

Le script réel peut être copié à partir d’ici :

#Requires -RunAsAdministrator
<#
.SYNOPSIS
Creates a Self Signed Certificate for use in server to server authentication
.DESCRIPTION
.EXAMPLE
PS C:\> .\Create-SelfSignedCertificate.ps1 -CommonName "MyCert" -StartDate 2015-11-21 -EndDate 2017-11-21
This will create a new self signed certificate with the common name "CN=MyCert". During creation you will be asked to provide a password to protect the private key.
.EXAMPLE
PS C:\> .\Create-SelfSignedCertificate.ps1 -CommonName "MyCert" -StartDate 2015-11-21 -EndDate 2017-11-21 -Password (ConvertTo-SecureString -String "MyPassword" -AsPlainText -Force)
This will create a new self signed certificate with the common name "CN=MyCert". The password as specified in the Password parameter will be used to protect the private key
.EXAMPLE
PS C:\> .\Create-SelfSignedCertificate.ps1 -CommonName "MyCert" -StartDate 2015-11-21 -EndDate 2017-11-21 -Force
This will create a new self signed certificate with the common name "CN=MyCert". During creation you will be asked to provide a password to protect the private key. If there is already a certificate with the common name you specified, it will be removed first.
#>
Param(

   [Parameter(Mandatory=$true)]
   [string]$CommonName,

   [Parameter(Mandatory=$true)]
   [DateTime]$StartDate,

   [Parameter(Mandatory=$true)]
   [DateTime]$EndDate,

   [Parameter(Mandatory=$false, HelpMessage="Will overwrite existing certificates")]
   [Switch]$Force,

   [Parameter(Mandatory=$false)]
   [SecureString]$Password
)

# DO NOT MODIFY BELOW

function CreateSelfSignedCertificate(){

    #Remove and existing certificates with the same common name from personal and root stores
    #Need to be very wary of this as could break something
    if($CommonName.ToLower().StartsWith("cn="))
    {
        # Remove CN from common name
        $CommonName = $CommonName.Substring(3)
    }
    $certs = Get-ChildItem -Path Cert:\LocalMachine\my | Where-Object{$_.Subject -eq "CN=$CommonName"}
    if($certs -ne $null -and $certs.Length -gt 0)
    {
        if($Force)
        {

            foreach($c in $certs)
            {
                remove-item $c.PSPath
            }
        } else {
            Write-Host -ForegroundColor Red "One or more certificates with the same common name (CN=$CommonName) are already located in the local certificate store. Use -Force to remove them";
            return $false
        }
    }

    $name = new-object -com "X509Enrollment.CX500DistinguishedName.1"
    $name.Encode("CN=$CommonName", 0)

    $key = new-object -com "X509Enrollment.CX509PrivateKey.1"
    $key.ProviderName = "Microsoft RSA SChannel Cryptographic Provider"
    $key.KeySpec = 1
    $key.Length = 2048
    $key.SecurityDescriptor = "D:PAI(A;;0xd01f01ff;;;SY)(A;;0xd01f01ff;;;BA)(A;;0x80120089;;;NS)"
    $key.MachineContext = 1
    $key.ExportPolicy = 1 # This is required to allow the private key to be exported
    $key.Create()

    $serverauthoid = new-object -com "X509Enrollment.CObjectId.1"
    $serverauthoid.InitializeFromValue("1.3.6.1.5.5.7.3.1") # Server Authentication
    $ekuoids = new-object -com "X509Enrollment.CObjectIds.1"
    $ekuoids.add($serverauthoid)
    $ekuext = new-object -com "X509Enrollment.CX509ExtensionEnhancedKeyUsage.1"
    $ekuext.InitializeEncode($ekuoids)

    $cert = new-object -com "X509Enrollment.CX509CertificateRequestCertificate.1"
    $cert.InitializeFromPrivateKey(2, $key, "")
    $cert.Subject = $name
    $cert.Issuer = $cert.Subject
    $cert.NotBefore = $StartDate
    $cert.NotAfter = $EndDate
    $cert.X509Extensions.Add($ekuext)
    $cert.Encode()

    $enrollment = new-object -com "X509Enrollment.CX509Enrollment.1"
    $enrollment.InitializeFromRequest($cert)
    $certdata = $enrollment.CreateRequest(0)
    $enrollment.InstallResponse(2, $certdata, 0, "")
    return $true
}

function ExportPFXFile()
{
    if($CommonName.ToLower().StartsWith("cn="))
    {
        # Remove CN from common name
        $CommonName = $CommonName.Substring(3)
    }
    if($Password -eq $null)
    {
        $Password = Read-Host -Prompt "Enter Password to protect private key" -AsSecureString
    }
    $cert = Get-ChildItem -Path Cert:\LocalMachine\my | where-object{$_.Subject -eq "CN=$CommonName"}

    Export-PfxCertificate -Cert $cert -Password $Password -FilePath "$($CommonName).pfx"
    Export-Certificate -Cert $cert -Type CERT -FilePath "$CommonName.cer"
}

function RemoveCertsFromStore()
{
    # Once the certificates have been been exported we can safely remove them from the store
    if($CommonName.ToLower().StartsWith("cn="))
    {
        # Remove CN from common name
        $CommonName = $CommonName.Substring(3)
    }
    $certs = Get-ChildItem -Path Cert:\LocalMachine\my | Where-Object{$_.Subject -eq "CN=$CommonName"}
    foreach($c in $certs)
    {
        remove-item $c.PSPath
    }
}

if(CreateSelfSignedCertificate)
{
    ExportPFXFile
    RemoveCertsFromStore
}

Vous serez invité à fournir un mot de passe pour chiffrer votre clé privée, ainsi que le . Fichier PFX et . Le fichier CER sera exporté vers le dossier actif.

L’étape suivante consiste à inscrire une application Azure AD dans le locataire Azure Active Directory lié à votre locataire Office 365. Pour ce faire, ouvrez le Centre Office 365 Admin (https://admin.microsoft.com) à l’aide du compte d’un utilisateur membre du groupe Administrateurs généraux du locataire. Cliquez sur le lien « Azure Active Directory » disponible sous le groupe « centres Administration » dans l’arborescence de gauche du centre Office 365 Admin. Dans l’onglet du nouveau navigateur qui sera ouvert, vous trouverez microsoft Portail Azure. Si c’est la première fois que vous accédez au Portail Azure avec votre compte, vous devez inscrire un nouvel abonnement Azure, en fournissant des informations et un carte de crédit pour tout besoin de paiement. Mais ne vous inquiétez pas, pour jouer avec Azure AD et inscrire une application Office 365, vous ne payerez rien. En fait, il s’agit de fonctionnalités gratuites. Une fois que vous avez accès à la Portail Azure, sélectionnez la section « Azure Active Directory », puis choisissez l’option « inscriptions d'applications ». Pour plus d’informations, consultez la figure suivante.

Dans l’onglet « inscriptions d'applications », vous trouverez la liste des applications Azure AD inscrites dans votre locataire. Cliquez sur le bouton « Nouvelle inscription » dans la partie supérieure gauche du panneau. Ensuite, fournissez un nom pour votre application et cliquez sur « Inscrire » en bas du panneau.

Cliquez maintenant sur « Autorisations d’API » dans la barre de menus de gauche, puis cliquez sur le bouton « Ajouter une autorisation ». Un nouveau panneau s’affiche. Ici, vous choisissez les autorisations que vous accorderez à cette application. Choisissez par exemple :

• SharePoint
  • Autorisations de l’application
    • Sites
      • Sites.FullControl.All

Cliquez sur le bouton bleu « Ajouter des autorisations » en bas pour ajouter les autorisations à votre application. Les « autorisations d’application » sont celles accordées à l’application lors de l’exécution en tant qu’application uniquement.

La dernière étape consiste à « connecter » le certificat que nous avons créé précédemment à l’application. Cliquez sur « Certificats & secrets » dans la barre de menus de gauche. Cliquez sur le bouton « Charger le certificat », puis sélectionnez . Fichier CER que vous avez généré précédemment, puis cliquez sur « Ajouter » pour le charger.

Pour vérifier que le certificat a été correctement inscrit, cliquez sur « Manifeste » dans la barre de menus de gauche. Recherchez la propriété keyCredentials . Il doit se présenter comme suit :

  "keyCredentials": [
    {
      "customKeyIdentifier": "<$base64CertHash>",
      "endDate": "2021-05-01T00:00:00Z",
      "keyId": "<$guid>",
      "startDate": "2019-05-01T00:00:00Z",
      "type": "AsymmetricX509Cert",
      "usage": "Verify",
      "value": "<$base64Cert>",
      "displayName": "CN=<$name of your cert>"
     }
  ],

Si vous voyez une section semblable à celle-ci, le certificat a été ajouté avec succès.

Dans cet exemple, l’autorisation d’application Sites.FullControl.All nécessite le consentement de l’administrateur dans un locataire avant de pouvoir être utilisée. Pour ce faire, cliquez à nouveau sur « Autorisations d’API » dans le menu de gauche. En bas, vous verrez une section « Accorder le consentement ». Cliquez sur le bouton « Accorder le consentement administrateur pour {{organization name}} » et confirmez l’action en cliquant sur le bouton « Oui » qui s’affiche en haut.

Utilisation de ce principal avec PnP PowerShell

Si vous souhaitez utiliser ce principal d’application AAD uniquement avec PnP PowerShell, une fois que vous avez installé le module PowerShell PnP, vous pouvez vous connecter à votre environnement SharePoint Online à l’aide de :

Connect-PnPOnline -ClientId <$application client id as copied over from the AAD app registration above> -CertificatePath '<$path to the PFX file generated by the PowerShell script above>' -CertificatePassword (ConvertTo-SecureString -AsPlainText "<$password assigned to the generated certificate pair above>" -Force) -Url https://<$yourtenant>.sharepoint.com -Tenant "<$tenantname>.onmicrosoft.com"

Vous pouvez maintenant effectuer des opérations via PnP PowerShell sur votre environnement SharePoint Online à l’aide de ce certificat Approbation d’application uniquement.

Utilisation de ce principal dans votre application à l’aide de la bibliothèque SharePoint PnP Framework

Dans une première étape, vous ajoutez le package NuGet de la bibliothèque PnP Framework : https://www.nuget.org/packages/PnP.Framework.

Une fois cette opération effectuée, vous pouvez utiliser la construction de code ci-dessous :

using PnP.Framework;
using System;

namespace AzureADCertAuth
{
    class Program
    {
        static void Main(string[] args)
        {
            var authManager = new AuthenticationManager("<application id>", "c:\\temp\\mycert.pfx", "<password>", "contoso.onmicrosoft.com");
            using (var cc = authManager.GetContext("https://contoso.sharepoint.com/sites/demo"))
            {
                cc.Load(cc.Web, p => p.Title);
                cc.ExecuteQuery();
                Console.WriteLine(cc.Web.Title);
            };
        }
    }
}

Utilisation de ce principal dans votre script PowerShell à l’aide de la bibliothèque PnP Framework

Lorsque vous utilisez Azure Automation Runbooks, ajoutez d’abord le certificat (.pfx) à l’aide de l’option Certificats (sous Ressources partagées), puis utilisez l’applet de commande Get-AutomationCertificate pour récupérer le certificat à utiliser dans le script.

# path to installed modules
$path = "C:\Modules\User\SharePointPnPPowerShellOnline"

# reference to needed assemblies
Add-Type -Path "$path\Microsoft.SharePoint.Client.dll"
Add-Type -Path "$path\Microsoft.SharePoint.Client.Runtime.dll"
Add-Type -Path "$path\PnP.Framework.dll"
Add-Type -Path "$path\PnP.Core.dll"
Add-Type -Path "$path\Microsoft.Identity.Client.dll"

# reference to the certificate
$cert = Get-AutomationCertificate -Name 'NameOfCertificate'

# set the variables
$siteUrl = "https://<tenant>.sharepoint.com"
$appId = "<guid of the App>"
$domain = "<tenant>.onmicrosoft.com"
$azureEnv = [PnP.Framework.AzureEnvironment]::Production

try {
    # instantiate the object
    $clientContext = $null
    $authManager = new-object PnP.Framework.AuthenticationManager($appId, $cert, $domain, $null, $azureEnv)

    # configure the object
    $clientContext = $authManager.GetContext($siteUrl)

    # do some stuff
    $clientContext.Load($clientContext.Web)
    $clientContext.ExecuteQuery()
    $clientContext.Web.Title
}
catch {
    # catch error if needed
}
finally {
    $clientContext.Dispose()
}

Utilisation de ce principal dans votre application et utilisation d’Azure KeyVault pour stocker le certificat et le récupérer à l’aide d’une fonction Azure

Ajoutez une identité managée à la fonction Azure et accordez à cette identité l’accès (autorisation GET sur les secrets) au coffre de clés.

Vous trouverez ci-dessous un appel légèrement différent à la même méthode AuthenticationManager où nous transmettons un certificat réel au lieu d’un chemin d’accès au certificat. Une fonction supplémentaire est ajoutée pour récupérer le certificat à partir du coffre de clés à l’aide de l’identité managée de la fonction Azure. Cette récupération est transparente et transparente, car la « magie » se produit dans DefaultAzureCredential.

Cet exemple utilise deux bibliothèques pour accéder à la Key Vault :

• Azure.Identity pour l’authentification auprès du Key Vault
• Azure.Security.KeyVault.Secrets pour obtenir le certificat

using Azure.Identity;
using Azure.Security.KeyVault.Secrets;
using Microsoft.SharePoint.Client;
using System.Security.Cryptography.X509Certificates;

using (var cc = new PnP.Framework.AuthenticationManager(
    "<application id>",
    GetKeyVaultCertificate("kv-spo", "AzureAutomationSPOAccess"),
    "contoso.onmicrosoft.com").GetContext("https://contoso.sharepoint.com/sites/demo"))
{
    cc.Load(cc.Web, p => p.Title);
    cc.ExecuteQuery();
    log.Info("Via PnP, we have site: " + cc.Web.Title);
};

static X509Certificate2 GetKeyVaultCertificate(string keyvaultName, string name)
{
    // Some steps need to be taken to make this work
    // 1. Create a KeyVault and upload the certificate
    // 2. Give the Function App the permission to GET certificates via Access Policies in the KeyVault
    // 3. Call an explicit access token request to the management resource to https://vault.azure.net and use the URL of our Keyvault in the GetSecret method
    Uri keyVaultUri = new Uri($"https://{keyvaultName}.vault.azure.net/");

    var client = new SecretClient(keyVaultUri, new DefaultAzureCredential());
    KeyVaultSecret secret = client.GetSecret(name);

    return new X509Certificate2(Convert.FromBase64String(secret.Value), string.Empty, X509KeyStorageFlags.MachineKeySet);
}

Utilisation de ce principal avec le scanneur de modernisation Pnp

Maintenant que vous avez créé l’inscription d’application Azure Active Directory, suivez les étapes ici pour utiliser ce principal avec l’outil.

Forum aux questions

Puis-je utiliser d’autres moyens que les certificats pour obtenir un accès d’application uniquement pour mon application Azure AD ?

Non, toutes les autres options sont bloquées par SharePoint Online et entraînent un message Accès refusé.