Partage via

Sécuriser les API utilisées pour les connecteurs d’API dans Azure AD B2C

  • Article

Lors de l'intégration d'une API REST dans un flux d'utilisateurs Azure AD B2C, vous devez protéger votre point de terminaison d'API REST en recourant à l'authentification. L'authentification par API REST garantit que seuls les services disposant des informations d'identification appropriées, comme Azure AD B2C, peuvent appeler votre point de terminaison. Cet article explique comment sécuriser une API REST.

Prérequis

Suivez les étapes décrites dans le guide Ajouter un connecteur d'API à un flux d'utilisateurs d'inscription.

Vous pouvez protéger votre point de terminaison d’API à l’aide de l’authentification de base HTTP ou de l’authentification par certificat client HTTPS. Dans les deux cas, vous fournissez les informations d’identification qu’utilise Azure AD B2C lorsqu’il appelle de votre point de terminaison d’API. Votre point de terminaison d'API vérifie ensuite les informations d'identification et prend les décisions relatives aux autorisations.

Authentification HTTP de base

L’authentification de base HTTP est définie dans le document RFC 2617. L’authentification de base fonctionne comme suit :

  • Azure AD B2C envoie une requête HTTP avec les informations d'identification du client (username et password) dans l'en-tête Authorization.

  • Les informations d'identification sont mises en forme en tant que chaîne username:password codée en base64.

  • Votre API est ensuite chargée de vérifier ces valeurs pour prendre d’autres décisions d’autorisation.

Pour configurer un connecteur d'API avec l'authentification de base HTTP, procédez comme suit :

  1. Connectez-vous au portail Azure.
  2. Sous Services Azure, sélectionnez Azure AD B2C ou recherchez et sélectionnez Azure AD B2C.
  3. Sélectionnez Connecteurs d’API, puis choisissez le Connecteur d’API que vous souhaitez configurer.
  4. Dans le champ Type d'authentification, sélectionnez De base.
  5. Entrez le Nom d'utilisateur et le Mot de passe de votre point de terminaison d'API REST. Providing basic authentication configuration for an API connector.
  6. Cliquez sur Enregistrer.

Ajouter les clés de stratégie de mot de passe et nom d’utilisateur de l’API REST

Pour configurer un profil technique API REST avec l’authentification HTTP de base, créez les clés de chiffrement suivantes pour stocker le nom d’utilisateur et le mot de passe :

  1. Connectez-vous au portail Azure.
  2. Si vous avez accès à plusieurs tenants (locataires), sélectionnez l’icône Paramètres dans le menu supérieur pour basculer vers votre tenant Azure AD B2C à partir du menu Annuaires + abonnements.
  3. Choisissez Tous les services dans le coin supérieur gauche du portail Azure, puis recherchez et sélectionnez Azure AD B2C.
  4. Dans la page de vue d’ensemble, sélectionnez Infrastructure d’expérience d’identité.
  5. Sélectionnez Clés de stratégie, puis Ajouter.
  6. Pour Options, sélectionnez Manuel.
  7. Dans Nom, indiquez RestApiUsername. Il est possible que le préfixe B2C_1A_ soit ajouté automatiquement.
  8. Dans la zone Secret, entrez le nom d’utilisateur de l’API REST.
  9. Pour Utilisation de la clé, sélectionnez Chiffrement.
  10. Sélectionnez Create (Créer).
  11. Sélectionnez de nouveau Clés de stratégie.
  12. Sélectionnez Ajouter.
  13. Pour Options, sélectionnez Manuel.
  14. Dans Nom, indiquez RestApiPassword. Il est possible que le préfixe B2C_1A_ soit ajouté automatiquement.
  15. Dans la zone Secret, entrez le mot de passe de l’API REST.
  16. Pour Utilisation de la clé, sélectionnez Chiffrement.
  17. Sélectionnez Create (Créer).

Configurer votre profil technique d’API REST afin d’utiliser l’authentification de base HTTP

Après avoir créé la clé nécessaire, configurez vos métadonnées du profil technique de l’API REST pour référencer les informations d’identification.

  1. Dans votre répertoire de travail, ouvrez le fichier de stratégie d’extension (TrustFrameworkExtensions.xml).
  2. Recherchez le profil technique API REST. Par exemple, REST-ValidateProfile ou REST-GetProfile.
  3. Recherchez l’élément <Metadata>.
  4. Définissez AuthenticationType sur Basic.
  5. Définissez AllowInsecureAuthInProduction sur false.
  6. Immédiatement après l’élément </Metadata> fermant, ajoutez l’extrait de code XML suivant : 
    <CryptographicKeys>
    <Key Id="BasicAuthenticationUsername" StorageReferenceId="B2C_1A_RestApiUsername" />
    <Key Id="BasicAuthenticationPassword" StorageReferenceId="B2C_1A_RestApiPassword" />
</CryptographicKeys>

L'extrait de code XML suivant est un exemple de profil technique RESTful configuré avec l'authentification de base HTTP :

<ClaimsProvider>
  <DisplayName>REST APIs</DisplayName>
  <TechnicalProfiles>
    <TechnicalProfile Id="REST-GetProfile">
      <DisplayName>Get user extended profile Azure Function web hook</DisplayName>
      <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.RestfulProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
      <Metadata>
        <Item Key="ServiceUrl">https://your-account.azurewebsites.net/api/GetProfile?code=your-code</Item>
        <Item Key="SendClaimsIn">Body</Item>
        <Item Key="AuthenticationType">Basic</Item>
        <Item Key="AllowInsecureAuthInProduction">false</Item>
      </Metadata>
      <CryptographicKeys>
        <Key Id="BasicAuthenticationUsername" StorageReferenceId="B2C_1A_RestApiUsername" />
        <Key Id="BasicAuthenticationPassword" StorageReferenceId="B2C_1A_RestApiPassword" />
      </CryptographicKeys>
      ...
    </TechnicalProfile>
  </TechnicalProfiles>
</ClaimsProvider>

Authentification par certificat client HTTPS

L’authentification par certificat client est une authentification mutuelle basée sur un certificat dans laquelle le client, Azure AD B2C, fournit son certificat client au serveur pour prouver son identité. Cela se produit dans le cadre de la négociation SSL. Votre API est chargée de valider les certificats appartenant à un client valide, par exemple Azure AD B2C, et de prendre des décisions d’autorisation. Le certificat client est un certificat numérique X.509.

Important

Dans les environnements de production, le certificat doit être signé par une autorité de certification.

Créer un certificat

Pour créer un certificat, vous pouvez utiliser Azure Key Vault, qui propose des options pour les certificats auto-signés et des intégrations auprès de fournisseurs d'émetteurs de certificats pour les certificats signés. Paramètres recommandés :

  • Objet : CN=<yourapiname>.<tenantname>.onmicrosoft.com
  • Type de contenu : PKCS #12
  • Type d'action de la durée de vie : Email all contacts at a given percentage lifetime ou Email all contacts a given number of days before expiry
  • Type de clé : RSA
  • Taille de la clé : 2048
  • Clé privée exportable : Yes (afin de pouvoir exporter un fichier .pfx)

Vous pouvez ensuite exporter le certificat.

Option 2 : préparer un certificat auto-signé à l’aide du module PowerShell

Si vous n’avez pas encore de certificat, vous pouvez utiliser un certificat auto-signé. Un certificat auto-signé est un certificat de sécurité qui n’est pas signé par une autorité de certification et qui n’offre pas les garanties de sécurité d’un certificat signé par une autorité de certification.

Sur Windows, utilisez l’applet de commande New-SelfSignedCertificate dans PowerShell pour générer un certificat.

  1. Exécutez la commande PowerShell suivante pour générer un certificat auto-signé. Modifiez l’argument -Subject comme il convient pour votre application et le nom de locataire Azure AD B2C, comme contosowebapp.contoso.onmicrosoft.com. Vous pouvez également ajuster la date de -NotAfter pour spécifier un délai d’expiration différent pour le certificat.

    New-SelfSignedCertificate `
    -KeyExportPolicy Exportable `
    -Subject "CN=yourappname.yourtenant.onmicrosoft.com" `
    -KeyAlgorithm RSA `
    -KeyLength 2048 `
    -KeyUsage DigitalSignature `
    -NotAfter (Get-Date).AddMonths(12) `
    -CertStoreLocation "Cert:\CurrentUser\My"

  2. Sur un ordinateur Windows, recherchez et sélectionnez Gérer les certificats utilisateur

  3. Sous Certificats - Utilisateur actuel, sélectionnez Personnel>Certificats>votrenomdappli.votrelocataire.onmicrosoft.com.

  4. Choisissez le certificat, puis sélectionnez Action>Toutes les tâches>Exporter.

  5. Sélectionnez Suivant>Oui, exporter la clé privée>Suivant.

  6. Acceptez les valeurs par défaut pour Format de fichier d’exportation, puis sélectionnez Suivant.

  7. Activez l’option Mot de passe, entrez un mot de passe pour le certificat, puis sélectionnez Suivant.

  8. Pour spécifier un emplacement d’enregistrement de votre certificat, sélectionnez Parcourir et accédez à un répertoire de votre choix.

  9. Dans la fenêtre Enregistrer sous, entrez un Nom de fichier, puis sélectionnez Enregistrer.

  10. Sélectionnez Suivant>Terminer.

Pour qu’Azure AD B2C accepte le mot de passe du fichier .pfx, celui-ci doit être chiffré à l’aide de l’option TripleDES-SHA1 de l’utilitaire d’exportation du magasin de certificats Windows, par opposition à AES256-SHA256.

Configurer votre connecteur d'API

Pour configurer un connecteur d'API avec l'authentification par certificat client, procédez comme suit :

  1. Connectez-vous au portail Azure.
  2. Sous Services Azure, sélectionnez Azure AD B2C.
  3. Sélectionnez Connecteurs d’API, puis choisissez le Connecteur d’API que vous souhaitez configurer.
  4. Dans le champ Type d'authentification, sélectionnez Certificat.
  5. Dans la zone Charger le certificat, sélectionnez le fichier .pfx de votre certificat avec une clé privée.
  6. Dans la zone Entrer le mot de passe, saisissez le mot de passe du certificat. Providing certificate authentication configuration for an API connector.
  7. Cliquez sur Enregistrer.

Prendre des décisions d’autorisation

Votre API doit implémenter l'autorisation basée sur les certificats clients envoyés afin de protéger les points de terminaison d'API. Pour Azure App Service et Azure Functions, consultez Configurer l'authentification mutuelle TLS afin de savoir comment activer et valider le certificat à partir de votre code d'API. Vous pouvez également utiliser la gestion des API Azure en tant que couche devant un service API pour vérifier les propriétés de certificat client par rapport aux valeurs souhaitées.

Renouvellement de certificats

Nous vous recommandons de définir des alertes de rappel avant la date d'expiration de votre certificat. Vous devez générer un nouveau certificat et répéter les étapes ci-dessus lorsque les certificats utilisés sont sur le point d’expirer. Pour « roder » l’utilisation d’un nouveau certificat, votre service d’API peut continuer à accepter les anciens et nouveaux certificats pendant un laps de temps limité pendant le déploiement du nouveau certificat.

Pour charger un nouveau certificat sur un connecteur d'API existant, sélectionnez le connecteur d'API sous Connecteurs d'API, puis cliquez sur Charger un nouveau certificat. Le dernier certificat chargé, qui n’a pas expiré, et dont la date de début est dépassée, sera automatiquement utilisé par Azure AD B2C.

Providing a new certificate to an API connector when one already exists.

Ajoutez une clé de stratégie de certificat client

  1. Connectez-vous au portail Azure.
  2. Si vous avez accès à plusieurs tenants (locataires), sélectionnez l’icône Paramètres dans le menu supérieur pour basculer vers votre tenant Azure AD B2C à partir du menu Annuaires + abonnements.
  3. Choisissez Tous les services dans le coin supérieur gauche du portail Azure, puis recherchez et sélectionnez Azure AD B2C.
  4. Dans la page de vue d’ensemble, sélectionnez Infrastructure d’expérience d’identité.
  5. Sélectionnez Clés de stratégie, puis Ajouter.
  6. Dans la zone Options, sélectionnez Charger.
  7. Dans la zone Nom, tapez RestApiClientCertificate. Le préfixe B2C_1A_ est ajouté automatiquement.
  8. Dans la zone Chargement de fichier, sélectionnez le fichier .pfx de votre certificat avec une clé privée.
  9. Dans la zone Mot de passe, entrez le mot de passe du certificat.
  10. Sélectionnez Create (Créer).

Configurer votre profil technique d’API REST afin d’utiliser l’authentification par certificat client

Après avoir créé la clé nécessaire, configurez vos métadonnées du profil technique de l’API REST pour référencer le certificat client.

  1. Dans votre répertoire de travail, ouvrez le fichier de stratégie d’extension (TrustFrameworkExtensions.xml).
  2. Recherchez le profil technique API REST. Par exemple, REST-ValidateProfile ou REST-GetProfile.
  3. Recherchez l’élément <Metadata>.
  4. Définissez AuthenticationType sur ClientCertificate.
  5. Définissez AllowInsecureAuthInProduction sur false.
  6. Immédiatement après l’élément </Metadata> fermant, ajoutez l’extrait de code XML suivant : 
    <CryptographicKeys>
   <Key Id="ClientCertificate" StorageReferenceId="B2C_1A_RestApiClientCertificate" />
</CryptographicKeys>

L'extrait de code XML suivant est un exemple de profil technique RESTful configuré avec un certificat client HTTP :

<ClaimsProvider>
  <DisplayName>REST APIs</DisplayName>
  <TechnicalProfiles>
    <TechnicalProfile Id="REST-GetProfile">
      <DisplayName>Get user extended profile Azure Function web hook</DisplayName>
      <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.RestfulProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
      <Metadata>
        <Item Key="ServiceUrl">https://your-account.azurewebsites.net/api/GetProfile?code=your-code</Item>
        <Item Key="SendClaimsIn">Body</Item>
        <Item Key="AuthenticationType">ClientCertificate</Item>
        <Item Key="AllowInsecureAuthInProduction">false</Item>
      </Metadata>
      <CryptographicKeys>
        <Key Id="ClientCertificate" StorageReferenceId="B2C_1A_RestApiClientCertificate" />
      </CryptographicKeys>
      ...
    </TechnicalProfile>
  </TechnicalProfiles>
</ClaimsProvider>

Authentification du porteur OAuth2

L’authentification du jeton du porteur est définie dans le document OAuth2.0 Authorization Framework: Bearer Token Usage (RFC 6750). Dans l’authentification par jeton du porteur, Azure AD B2C envoie une requête HTTP avec un jeton dans l’en-tête d’autorisation.

Authorization: Bearer <token>

Un jeton de porteur est une chaîne opaque. Il peut s’agir d’un jeton d’accès JWT ou d’une chaîne que l’API REST attend que le client Azure AD B2C envoie dans l’en-tête Authorization. Azure AD B2C prend en charge les types suivants :

  • Jeton du porteur. Pour pouvoir envoyer le jeton du porteur dans le profil technique RESTful, votre stratégie doit d’abord acquérir le jeton du porteur, puis l’utiliser dans le profil technique RESTful.
  • Jeton du porteur statique. Utilisez cette approche lorsque votre API REST émet un jeton d’accès à long terme. Pour utiliser un jeton de porteur statique, créez une clé de stratégie et faites une référence du profil technique RESTful à votre clé de stratégie.

Utilisation du porteur OAuth2

Les étapes suivantes montrent comment utiliser les informations d’identification du client pour obtenir un jeton du porteur et le transmettre à l’en-tête d’autorisation des appels de l’API REST.

Définir une revendication pour stocker le jeton du porteur

Une revendication fournit un stockage temporaire de données lors d’une exécution de stratégie Azure AD B2C. Le schéma de revendications est l’endroit où vous déclarez vos revendications. Le jeton d’accès doit être stocké dans une revendication à utiliser ultérieurement.

  1. Ouvrez le fichier d’extensions de votre stratégie. Par exemple : SocialAndLocalAccounts/TrustFrameworkExtensions.xml.
  2. Recherchez l’élément BuildingBlocks. Si l’élément n’existe pas, ajoutez-le.
  3. Localisez l’élément ClaimsSchema. Si l’élément n’existe pas, ajoutez-le.
  4. Ajoutez les revendications suivantes à l’élément ClaimsSchema.
<ClaimType Id="bearerToken">
  <DisplayName>Bearer token</DisplayName>
  <DataType>string</DataType>
</ClaimType>
<ClaimType Id="grant_type">
  <DisplayName>Grant type</DisplayName>
  <DataType>string</DataType>
</ClaimType>
<ClaimType Id="scope">
  <DisplayName>scope</DisplayName>
  <DataType>string</DataType>
</ClaimType>

Acquisition d’un jeton d’accès

Vous pouvez obtenir un jeton d’accès de l’une des manières suivantes, pour le auprès d’un fournisseur d’identité fédéré, en appelant une API REST qui retourne un jeton d’accès, à l’aide d’un flux ROPC ou à l’aide du flux d’informations d’identification du client. Le flux d’informations d’identification de client est couramment utilisé pour les interactions de serveur à serveur qui doivent s’exécuter en arrière-plan sans l’interaction immédiate d’un utilisateur.

Acquisition d’un jeton d’accès Microsoft Entra

L’exemple suivant utilise un profil technique de l’API REST pour effectuer une requête auprès du point de terminaison du jeton Microsoft Entra en tirant parti des informations d’identification du client transmises en tant qu’authentification de base HTTP. Pour plus d’informations, voir Plateforme d’identités Microsoft et flux d’informations d’identification du client OAuth 2.0.

Avant que le profil technique puisse interagir avec Microsoft Entra ID pour obtenir un jeton d'accès, vous devez inscrire une application. Azure AD B2C repose sur la plateforme Microsoft Entra. Vous pouvez créer l'application dans votre tenant (locataire) Azure AD B2C, ou dans n'importe quel tenant Microsoft Entra que vous gérez. Pour inscrire une application :

  1. Connectez-vous au portail Azure.
  2. Si vous avez accès à plusieurs tenants (locataires), sélectionnez l’icône Paramètres dans le menu supérieur pour basculer vers votre tenant Azure AD B2C à partir du menu Annuaires + abonnements.
  3. Dans le menu de gauche, sélectionnez Microsoft Entra ID. Ou sélectionnez Tous les services, puis recherchez et choisissez Microsoft Entra ID.
  4. Sélectionnez Inscriptions d’applications, puis Nouvelle inscription.
  5. Entrez un Nom pour l’application. Par exemple, Client_Credentials_Auth_app.
  6. Sous Types de comptes pris en charge, sélectionnez Comptes dans cet annuaire organisationnel uniquement.
  7. Sélectionnez Inscription.
  8. Enregistrez l’ID d’application (client) .

Pour un flux d’informations d’identification de client, vous devez créer un secret d’application. Le secret client est également appelé mot de passe d’application. Votre application utilise le secret pour acquérir un jeton d’accès.

  1. Sur la page Microsoft Entra ID – Inscriptions d’applications, sélectionnez l'application que vous avez créée, par exemple Client_Credentials_Auth_app.
  2. Dans le menu de gauche, sous Gérer, sélectionnez Certificats et secrets.
  3. Sélectionnez Nouveau secret client.
  4. Entrez une description pour la clé secrète client dans la zone Description. Par exemple, clientsecret1.
  5. Sous Expire, sélectionnez une durée pendant laquelle le secret est valide, puis sélectionnez Ajouter.
  6. Enregistrez la valeur du secret en prévision d’une utilisation dans le code de votre application cliente. Cette valeur secrète ne sera plus jamais affichée lorsque vous aurez quitté cette page. Vous utiliserez cette valeur comme secret d’application dans le code de votre application.

Créer des clés de stratégie Azure AD B2C

Vous devez stocker l’ID de client et la valeur de clé secrète du client que vous avez enregistrée dans votre locataire Azure AD B2C.

  1. Connectez-vous au portail Azure.
  2. Si vous avez accès à plusieurs tenants (locataires), sélectionnez l’icône Paramètres dans le menu supérieur pour basculer vers votre tenant Azure AD B2C à partir du menu Annuaires + abonnements.
  3. Choisissez Tous les services dans le coin supérieur gauche du portail Azure, puis recherchez et sélectionnez Azure AD B2C.
  4. Dans la page de vue d’ensemble, sélectionnez Infrastructure d’expérience d’identité.
  5. Sélectionnez Clés de stratégie, puis Ajouter.
  6. Pour Options, choisissez Manual.
  7. Entrez un Nom pour la clé de stratégie, SecureRESTClientId. Le préfixe B2C_1A_ est ajouté automatiquement au nom de votre clé.
  8. Dans Secret, entrez l’ID de client que vous avez enregistrée.
  9. Pour Utilisation de la clé, sélectionnez Signature.
  10. Cliquez sur Créer.
  11. Créez une autre clé de stratégie avec les paramètres suivants :
    • Nom : SecureRESTClientSecret.
    • Secret : entrez la clé secrète client que vous avez enregistrée

Au niveau de ServiceUrl, remplacez votre-nom-de-tenant par le nom de votre tenant Microsoft Entra. Consultez la référence Profil technique RESTful pour connaître toutes les options disponibles.

<TechnicalProfile Id="REST-AcquireAccessToken">
  <DisplayName></DisplayName>
  <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.RestfulProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
  <Metadata>
    <Item Key="ServiceUrl">https://login.microsoftonline.com/your-tenant-name.onmicrosoft.com/oauth2/v2.0/token</Item>
    <Item Key="AuthenticationType">Basic</Item>
     <Item Key="SendClaimsIn">Form</Item>
  </Metadata>
  <CryptographicKeys>
    <Key Id="BasicAuthenticationUsername" StorageReferenceId="B2C_1A_SecureRESTClientId" />
    <Key Id="BasicAuthenticationPassword" StorageReferenceId="B2C_1A_SecureRESTClientSecret" />
  </CryptographicKeys>
  <InputClaims>
    <InputClaim ClaimTypeReferenceId="grant_type" DefaultValue="client_credentials" AlwaysUseDefaultValue="true" />
    <InputClaim ClaimTypeReferenceId="scope" DefaultValue="https://graph.microsoft.com/.default" AlwaysUseDefaultValue="true" />
  </InputClaims>
  <OutputClaims>
    <OutputClaim ClaimTypeReferenceId="bearerToken" PartnerClaimType="access_token" />
  </OutputClaims>
  <UseTechnicalProfileForSessionManagement ReferenceId="SM-Noop" />
</TechnicalProfile>

Notes

Si vous utilisez les revendications grant_type ou scope dans d’autres profils techniques, elles doivent également spécifier DefaultValue et utiliser AlwaysUseDefaultValue="true" pour éviter d’éventuels conflits de liaison par rapport à la valeur incorrecte.

Modifier le profil technique REST pour utiliser l’authentification par jeton du porteur

Pour prendre en charge l’authentification par jeton du porteur dans votre stratégie personnalisée, modifiez le profil technique de l’API REST en utilisant les étapes suivantes :

  1. Dans votre répertoire de travail, ouvrez le fichier de stratégie d’extension TrustFrameworkExtensions.xml.

  2. Recherchez le nœud <TechnicalProfile> qui inclut Id="REST-API-SignUp".

  3. Recherchez l’élément <Metadata>.

  4. Définissez AuthenticationType sur Bearer, comme suit :

    <Item Key="AuthenticationType">Bearer</Item>

  5. Modifiez ou ajoutez UseClaimAsBearerToken en le définissant sur bearerToken, comme suit. bearerToken est le nom de la revendication à partir de laquelle le jeton du porteur est récupéré (revendication de sortie de REST-AcquireAccessToken).

    <Item Key="UseClaimAsBearerToken">bearerToken</Item>

  6. Ajoutez le sinistre de l'étape précédente en tant que sinistre d'entrée :

    <InputClaim ClaimTypeReferenceId="bearerToken"/>

Après avoir mis à jour votre politique, votre profil technique devrait ressembler au code XML suivant :

<ClaimsProvider>
  <DisplayName>REST APIs</DisplayName>
  <TechnicalProfiles>
    <TechnicalProfile Id="REST-GetProfile">
      <DisplayName>Get user extended profile Azure Function web hook</DisplayName>
      <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.RestfulProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
      <Metadata>
        <Item Key="ServiceUrl">https://your-account.azurewebsites.net/api/GetProfile?code=your-code</Item>
        <Item Key="SendClaimsIn">Body</Item>
        <Item Key="AuthenticationType">Bearer</Item>
        <Item Key="UseClaimAsBearerToken">bearerToken</Item>
        <Item Key="AllowInsecureAuthInProduction">false</Item>
      </Metadata>
      <InputClaims>
        <InputClaim ClaimTypeReferenceId="bearerToken"/>
      </InputClaims>
      ...
    </TechnicalProfile>
  </TechnicalProfiles>
</ClaimsProvider>

Appeler le profil technique REST

Pour appeler le profil technique REST-GetProfile, vous devez d’abord acquérir un jeton d’accès Microsoft Entra en utilisant le profil technique REST-AcquireAccessToken. L’exemple suivant montre comment appeler le profil technique REST-GetProfile à partir d’un profil technique de validation :

<ValidationTechnicalProfiles>
  <ValidationTechnicalProfile ReferenceId="REST-AcquireAccessToken" />
  <ValidationTechnicalProfile ReferenceId="REST-GetProfile" />
</ValidationTechnicalProfiles>

L’exemple suivant montre comment appeler le REST-GetProfile profil technique à partir d’un parcours utilisateur ou d’un sous-parcours :

<OrchestrationSteps>
  <OrchestrationStep Order="2" Type="ClaimsExchange">
    <ClaimsExchanges>
      <ClaimsExchange Id="REST-AcquireAccessTokens" TechnicalProfileReferenceId="REST-AcquireAccessToken" />
    </ClaimsExchanges>
  </OrchestrationStep>

  <OrchestrationStep Order="3" Type="ClaimsExchange">
    <ClaimsExchanges>
      <ClaimsExchange Id="REST-GetProfile" TechnicalProfileReferenceId="REST-GetProfile" />
    </ClaimsExchanges>
  </OrchestrationStep>
</OrchestrationSteps>

Utilisation d’un porteur OAuth2 statique

Ajouter la clé de stratégie de jeton du porteur OAuth2

Pour configurer un profil technique API REST avec un jeton du porteur OAuth2, obtenez un jeton d’accès à partir du propriétaire de l’API REST. Créez ensuite la clé de chiffrement suivante pour stocker le jeton du porteur.

  1. Connectez-vous au portail Azure.
  2. Si vous avez accès à plusieurs tenants (locataires), sélectionnez l’icône Paramètres dans le menu supérieur pour basculer vers votre tenant Azure AD B2C à partir du menu Annuaires + abonnements.
  3. Choisissez Tous les services dans le coin supérieur gauche du portail Azure, puis recherchez et sélectionnez Azure AD B2C.
  4. Dans la page de vue d’ensemble, sélectionnez Infrastructure d’expérience d’identité.
  5. Sélectionnez Clés de stratégie, puis Ajouter.
  6. Pour Options, choisissez Manual.
  7. Entrez un nom pour la clé de stratégie. Par exemple : RestApiBearerToken. Le préfixe B2C_1A_ est ajouté automatiquement au nom de votre clé.
  8. Dans Secret, entrez la clé secrète client que vous avez enregistrée.
  9. Pour Utilisation de la clé, sélectionnez Encryption.
  10. Sélectionnez Create (Créer).

Configurer votre profil technique de l’API REST pour utiliser la clé de stratégie de jeton du porteur

Après avoir créé la clé nécessaire, configurez vos métadonnées du profil technique de l’API REST pour référencer le jeton du porteur.

  1. Dans votre répertoire de travail, ouvrez le fichier de stratégie d’extension (TrustFrameworkExtensions.xml).
  2. Recherchez le profil technique API REST. Par exemple, REST-ValidateProfile ou REST-GetProfile.
  3. Recherchez l’élément <Metadata>.
  4. Définissez AuthenticationType sur Bearer.
  5. Définissez AllowInsecureAuthInProduction sur false.
  6. Immédiatement après l’élément </Metadata> fermant, ajoutez l’extrait de code XML suivant : 
    <CryptographicKeys>
   <Key Id="BearerAuthenticationToken" StorageReferenceId="B2C_1A_RestApiBearerToken" />
</CryptographicKeys>

L'extrait de code XML suivant est un exemple de profil technique RESTful configuré avec l'authentification par jeton du porteur :

<ClaimsProvider>
  <DisplayName>REST APIs</DisplayName>
  <TechnicalProfiles>
    <TechnicalProfile Id="REST-GetProfile">
      <DisplayName>Get user extended profile Azure Function web hook</DisplayName>
      <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.RestfulProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
      <Metadata>
        <Item Key="ServiceUrl">https://your-account.azurewebsites.net/api/GetProfile?code=your-code</Item>
        <Item Key="SendClaimsIn">Body</Item>
        <Item Key="AuthenticationType">Bearer</Item>
        <Item Key="AllowInsecureAuthInProduction">false</Item>
      </Metadata>
      <CryptographicKeys>
        <Key Id="BearerAuthenticationToken" StorageReferenceId="B2C_1A_RestApiBearerToken" />
      </CryptographicKeys>
      ...
    </TechnicalProfile>
  </TechnicalProfiles>
</ClaimsProvider>

Ajoutez la référence du profil technique de validation au profil technique d’inscription, qui appelle le REST-AcquireAccessToken. Ce comportement signifie qu’Azure AD B2C ne poursuit le processus en créant le compte dans le répertoire qu’une fois la validation réussie.

Par exemple :

```XML
<ValidationTechnicalProfiles>
   ....
   <ValidationTechnicalProfile ReferenceId="REST-AcquireAccessToken" />
   ....
</ValidationTechnicalProfiles>

Authentification par clé API

Certains services utilisent un mécanisme de « clé API » pour obfusquer l’accès à vos points de terminaison HTTP pendant le développement en obligeant l’appelant à inclure une clé unique comme un en-tête HTTP ou un paramètre de requête HTTP. Pour Azure Functions, vous pouvez effectuer cette opération en incluant code comme paramètre de requête dans l’URL du point de terminaison de votre connecteur d’API. Par exemple, https://contoso.azurewebsites.net/api/endpoint?code=0123456789).

Ce mécanisme ne doit pas être utilisé seul en production. Par conséquent, la configuration de l'authentification de base ou par certificat est toujours requise. Si vous ne souhaitez implémenter aucune méthode d’authentification (non recommandé) à des fins de développement, vous pouvez choisir l’authentification « de base » dans la configuration du connecteur d’API et utiliser des valeurs temporaires pour username et password, que votre API peut ignorer pendant l’implémentation de l’autorisation adéquate.

La clé API est un identificateur unique utilisé pour authentifier un utilisateur afin d’accéder à un point de terminaison d’API REST. La clé est envoyée dans un en-tête HTTP personnalisé. Par exemple, le déclencheur HTTP Azure Functions utilise l’en-tête HTTP x-functions-key pour identifier le demandeur.

Ajouter des clés de stratégie de clé API

Pour configurer un profil technique d’API REST avec l’authentification par clé API, créez la clé de chiffrement suivante pour stocker la clé API :

  1. Connectez-vous au portail Azure.
  2. Si vous avez accès à plusieurs tenants (locataires), sélectionnez l’icône Paramètres dans le menu supérieur pour basculer vers votre tenant Azure AD B2C à partir du menu Annuaires + abonnements.
  3. Choisissez Tous les services dans le coin supérieur gauche du portail Azure, puis recherchez et sélectionnez Azure AD B2C.
  4. Dans la page de vue d’ensemble, sélectionnez Infrastructure d’expérience d’identité.
  5. Sélectionnez Clés de stratégie, puis Ajouter.
  6. Pour Options, sélectionnez Manuel.
  7. Dans Nom, indiquez RestApiKey. Il est possible que le préfixe B2C_1A_ soit ajouté automatiquement.
  8. Dans la zone Secret, entrez la clé de l’API REST.
  9. Pour Utilisation de la clé, sélectionnez Chiffrement.
  10. Sélectionnez Create (Créer).

Configurer votre profil technique d’API REST afin d’utiliser l’authentification par clé API

Après avoir créé la clé nécessaire, configurez les métadonnées du profil technique de votre API REST pour référencer les informations d’identification.

  1. Dans votre répertoire de travail, ouvrez le fichier de stratégie d’extension (TrustFrameworkExtensions.xml).
  2. Recherchez le profil technique API REST. Par exemple, REST-ValidateProfile ou REST-GetProfile.
  3. Recherchez l’élément <Metadata>.
  4. Définissez AuthenticationType sur ApiKeyHeader.
  5. Définissez AllowInsecureAuthInProduction sur false.
  6. Immédiatement après l’élément </Metadata> fermant, ajoutez l’extrait de code XML suivant : 
    <CryptographicKeys>
    <Key Id="x-functions-key" StorageReferenceId="B2C_1A_RestApiKey" />
</CryptographicKeys>

L’ID de la clé de chiffrement définit l’en-tête HTTP. Dans cet exemple, la clé API est envoyée sous la forme x-functions-key.

L'extrait de code XML suivant est un exemple de profil technique RESTful configuré pour appeler une application de fonction Azure avec l'authentification par clé API :

<ClaimsProvider>
  <DisplayName>REST APIs</DisplayName>
  <TechnicalProfiles>
    <TechnicalProfile Id="REST-GetProfile">
      <DisplayName>Get user extended profile Azure Function web hook</DisplayName>
      <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.RestfulProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
      <Metadata>
        <Item Key="ServiceUrl">https://your-account.azurewebsites.net/api/GetProfile?code=your-code</Item>
        <Item Key="SendClaimsIn">Body</Item>
        <Item Key="AuthenticationType">ApiKeyHeader</Item>
        <Item Key="AllowInsecureAuthInProduction">false</Item>
      </Metadata>
      <CryptographicKeys>
        <Key Id="x-functions-key" StorageReferenceId="B2C_1A_RestApiKey" />
      </CryptographicKeys>
      ...
    </TechnicalProfile>
  </TechnicalProfiles>
</ClaimsProvider>

Étapes suivantes

  • Apprenez-en davantage sur le profil technique RESTful dans la documentation de référence sur les stratégies personnalisées.