ID Connect-ondersteuning voor AEM as a Cloud Service openen op publicatieniveau open-id-connect-support-for-aem-as-a-cloud-service-on-publish-tier

Inleiding introduction

Naarmate organisaties hun digitale ervaringen moderniseren, wordt een veilig en schaalbaar identiteitsbeheer een fundamentele vereiste. Adobe Experience Manager (AEM) Cloud Service biedt nu ondersteuning voor OpenID Connect (OIDC) op de publicatielaag, zodat naadloze en op standaarden gebaseerde integratie met toonaangevende identiteitsproviders (IdPs) mogelijk is, zoals EnterpriseID (Azure AD), Google, Okta, Auth0, Ping Identity, ForgeRock en OIDC ondersteunde IDP’s.

OIDC is een identiteitslaag bovenop het protocol OAuth 2.0 dat robuuste gebruikersauthentificatie terwijl het handhaven van eenvoud voor ontwikkelaars toelaat. Het wordt wijd goedgekeurd voor zaken-aan-consument (B2C), Intranet, en partnerportalscenario’s, waar veilige gebruikerslogin en identiteitsfederaties worden vereist.

Tot nu toe waren AEM-klanten verantwoordelijk voor het implementeren van hun eigen aangepaste aanmeldingslogica op de publicatielaag, die de ontwikkelingstijd verlengde en langdurige onderhouds- en beveiligingsproblemen introduceerde. Met native ondersteuning voor OIDC verwijdert AEM Cloud Service deze last door een veilig, uitbreidbaar en door Adobe ondersteund verificatiemechanisme te bieden voor eindgebruikers die toegang willen tot publicatieomgevingen.

Of u nu een gepersonaliseerde consumentenwebsite of een geverifieerd intern portaal levert, OIDC on Publish vereenvoudigt identiteitsfederatie en vermindert risico door gecentraliseerd identiteitsbeheer. Het helpt organisaties ook om aan moderne naleving en veiligheidsnormen te voldoen zonder behendigheid te offeren.

AEM voor OIDC-verificatie configureren configure-aem-oidc-authentication

Vereisten prerequisits

We gaan ervan uit dat de volgende informatie beschikbaar of gedefinieerd is:

Informatie van de Configuratie IdP:

Overzicht van de configuratiebestanden overview-of-the-configuration-files

Zoek onder een lijst met bestanden die moeten worden geconfigureerd:

Het volgende diagram toont hoe de vermelde configuratieelementen verbonden zijn. Aangezien dit ServiceFactory -componenten zijn, kan ~uniqueid elke willekeurige unieke tekenreeks zijn:

De OIDC-verbinding configureren configure-the-oidc-connection

Eerst, moeten wij de verbinding vormen OIDC. De veelvoudige verbindingen OIDC kunnen worden gevormd, en elk moet een verschillende naam hebben.

In sommige omgevingen is het mogelijk dat de identiteitsprovider (IdP) geen geldig .well-known eindpunt weergeeft.
Wanneer dit voorkomt, kunnen de vereiste eindpunten manueel worden bepaald door de volgende eigenschappen in het configuratiedossier te specificeren.
In deze configuratiemodus mag de eigenschap baseUrl niet worden ingesteld.

"authorizationEndpoint": "https://idp-url/oauth2/v1/authorize",
"tokenEndpoint": "https://idp-url/oauth2/v1/token",
"jwkSetURL":"https://idp-url/oauth2/v1/keys",
"issuer": "https://idp-url"

OIDC-verificatiehandler configureren configure-oidc-authentication-handler

Nu, vorm de OIDC authentificatiemanager. Er kunnen meerdere OIDC-verbindingen worden geconfigureerd. Elke naam moet een andere naam hebben. Als zij de zelfde ​ Externe Leverancier van de Identiteit van OAK ​ delen, kunnen zij gebruikers delen.

SlingUserInfoProcessor configureren configure-slinguserinfoprocessor

Synchronisatiehandler configureren configure-the-synchronization-handler

Minstens één manager van de Synchronisatie moet me gevormd om de gebruikers te synchroniseren die in eikel voor authentiek worden verklaard. Voor meer details, zie ​ deze ​ pagina.

Maak een bestand met de naam org.apache.jackrabbit.oak.spi.security.authentication.external.impl.DefaultSyncHandler~azure.cfg.json . Het azure achtervoegsel moet een uniek herkenningsteken zijn. Voor meer informatie over hoe te om zijn eigenschappen te vormen, raadpleeg de ​ documentatie van de Synchronisatie van de Gebruiker van Oak en van de Groep ​. Hieronder vindt u een voorbeeldconfiguratie:

{
  "user.expirationTime":"1h",
  "user.membershipExpTime":"1h",
  "group.expirationTime": "1d"
  "user.propertyMapping":[
    "profile/givenName=profile/given_name",
    "profile/familyName=profile/family_name",
    "rep:fullname=profile/name",
    "profile/email=profile/email",
    "access_token=access_token",
    "refresh_token=refresh_token"
  ],
  "user.pathPrefix":"azure",
  "handler.name":"azure"
}

Tijdens de ontwikkeling, kunnen de vervaltijden tot een lagere waarde (bijvoorbeeld worden verminderd: 1s) om het testen van gebruiker en groepssynchronisatie in eiken te versnellen.
Onder enkele van de meest relevante kenmerken die in DefaultSyncHandler moeten worden geconfigureerd. Merk op dat het Dynamische Lidmaatschap van de Groep altijd in de Diensten van de Wolk zou moeten worden toegelaten.

De externe aanmeldingsmodule configureren configure-the-external-login-module

Tot slot moet u de Externe Module van de Aanmelding vormen.

Optioneel: een aangepaste UserInfoProcessor implementeren implement-a-custom-userinfoprocessor

De gebruiker wordt voor authentiek verklaard door een Symbolisch van identiteitskaart, en de extra attributen worden gehaald van het userInfo eindpunt dat voor IdP wordt bepaald. UserInfoProcessor is verantwoordelijk voor het transformeren van de gegevens die zijn ontvangen van het identiteitsbureau naar referenties en kenmerken die AEM kan gebruiken voor gebruikerssynchronisatie.

Wanneer maakt u een aangepaste UserInfoProcessor when-to-create-custom-userinfoprocessor

Het gebrek ​ SlingUserInfoProcessorImpl ​ behandelt standaardOIDC- eisen en groepssynchronisatie. Mogelijk hebt u een aangepaste implementatie nodig als u:

De interface UserInfoProcessor understanding-userinfoprocessor-interface

De interface UserInfoProcessor van het pakket org.apache.sling.auth.oauth_client.spi definieert twee methoden:

public interface UserInfoProcessor {
    /**
     * Process the UserInfo and token response to create OIDC credentials
     *
     * @param userInfo - JSON response from the UserInfo endpoint (may be null)
     * @param tokenResponse - JSON response from the token endpoint
     * @param oidcSubject - The subject claim from the ID token
     * @param idp - The configured IDP name
     * @return OidcAuthCredentials containing user attributes and group memberships
     */
    @NotNull OidcAuthCredentials process(
        @Nullable String userInfo,
        @NotNull String tokenResponse,
        @NotNull String oidcSubject,
        @NotNull String idp
    );

    /**
     * @return The name of the OIDC connection this processor is associated with
     */
    @NotNull String connection();
}

Met het geretourneerde OidcAuthCredentials -object kunt u:

Voorbeeld: Custom UserInfoProcessor-implementatie custom-userinfoprocessor-implementation

Hieronder ziet u een volledig voorbeeld van het implementeren van een aangepaste UserInfoProcessor :

package com.mycompany.aem.auth;

import java.nio.charset.StandardCharsets;
import java.util.Base64;

import org.apache.sling.auth.oauth_client.spi.OidcAuthCredentials;
import org.apache.sling.auth.oauth_client.spi.UserInfoProcessor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.metatype.annotations.AttributeDefinition;
import org.osgi.service.metatype.annotations.Designate;
import org.osgi.service.metatype.annotations.ObjectClassDefinition;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

/**
 * Custom UserInfoProcessor that extracts additional claims from the ID token
 * and adds custom user attributes and group memberships.
 */
@Component(service = UserInfoProcessor.class, property = {"service.ranking:Integer=50"})
@Designate(ocd = CustomUserInfoProcessor.Config.class, factory = true)
public class CustomUserInfoProcessor implements UserInfoProcessor {

    private static final Logger logger = LoggerFactory.getLogger(CustomUserInfoProcessor.class);

    @ObjectClassDefinition(name = "Custom UserInfo Processor")
    @interface Config {
        @AttributeDefinition(name = "Connection Name", description = "OIDC Connection Name")
        String connection();
    }

    private final String connection;

    @Activate
    public CustomUserInfoProcessor(Config config) {
        this.connection = config.connection();
        logger.info("CustomUserInfoProcessor activated for connection: {}", connection);
    }

    @Override
    public @NotNull OidcAuthCredentials process(
            @Nullable String userInfo,
            @NotNull String tokenResponse,
            @NotNull String oidcSubject,
            @NotNull String idp) {

        // Parse the token response to extract tokens
        JsonObject tokenJson = JsonParser.parseString(tokenResponse).getAsJsonObject();
        String accessToken = tokenJson.has("access_token") ?
            tokenJson.get("access_token").getAsString() : null;
        String idToken = tokenJson.has("id_token") ?
            tokenJson.get("id_token").getAsString() : null;

        logger.debug("Processing authentication for subject: {}", oidcSubject);

        // Decode and extract claims from ID Token
        JsonObject claims = null;
        if (idToken != null) {
            claims = decodeJwtPayload(idToken);
            logger.debug("Extracted claims from ID token: {}", claims);
        }

        // Create credentials object
        OidcAuthCredentials credentials = new OidcAuthCredentials(oidcSubject, idp);
        credentials.setAttribute(".token", "");

        // Extract standard profile attributes
        if (claims != null) {
            // Standard OIDC claims
            setAttributeIfPresent(credentials, claims, "given_name", "profile/given_name");
            setAttributeIfPresent(credentials, claims, "family_name", "profile/family_name");
            setAttributeIfPresent(credentials, claims, "email", "profile/email");
            setAttributeIfPresent(credentials, claims, "name", "profile/name");

            // Custom claims from your IdP
            setAttributeIfPresent(credentials, claims, "department", "profile/department");
            setAttributeIfPresent(credentials, claims, "employee_id", "profile/employeeId");
            setAttributeIfPresent(credentials, claims, "job_title", "profile/jobTitle");
        }

        // Extract group memberships from claims
        if (claims != null && claims.has("groups")) {
            if (claims.get("groups").isJsonArray()) {
                claims.get("groups").getAsJsonArray().forEach(group -> {
                    credentials.addGroup(group.getAsString());
                });
            }
        }

        // Optionally store tokens if needed for later API calls
        // Note: Only store tokens if your application needs to call external APIs
        // on behalf of the user. Tokens are encrypted before storage.
        if (accessToken != null) {
            credentials.setAttribute("access_token", accessToken);
        }

        return credentials;
    }

    @Override
    public @NotNull String connection() {
        return connection;
    }

    /**
     * Helper method to set attribute if present in claims
     */
    private void setAttributeIfPresent(OidcAuthCredentials credentials,
                                      JsonObject claims,
                                      String claimName,
                                      String attributeName) {
        if (claims.has(claimName) && !claims.get(claimName).isJsonNull()) {
            String value = claims.get(claimName).getAsString();
            if (value != null && !value.isEmpty()) {
                credentials.setAttribute(attributeName, value);
            }
        }
    }

    /**
     * Decode JWT payload (middle part) to extract claims
     */
    private JsonObject decodeJwtPayload(String jwt) {
        try {
            String[] parts = jwt.split("\\.");
            if (parts.length != 3) {
                logger.warn("Invalid JWT format");
                return null;
            }

            // Decode the payload (second part)
            String payload = parts[1];
            // Add padding if needed
            payload = payload + "====".substring(0, (4 - payload.length() % 4) % 4);
            // Replace URL-safe characters
            payload = payload.replace('-', '+').replace('_', '/');

            byte[] decoded = Base64.getDecoder().decode(payload);
            String json = new String(decoded, StandardCharsets.UTF_8);
            return JsonParser.parseString(json).getAsJsonObject();
        } catch (Exception e) {
            logger.error("Failed to decode JWT payload", e);
            return null;
        }
    }
}

Configuratie custom-userinfoprocessor-configuration

Maak een configuratiebestand voor uw aangepaste UserInfoProcessor in uw AEM-project onder ui.config/src/main/content/jcr_root/apps/myapp/osgiconfig/config.publish/ :

com.mycompany.aem.auth.CustomUserInfoProcessor~azure.cfg.json

{
  "connection": "azure"
}

De configuratie moet overeenkomen met de naam van de verbinding die is gedefinieerd in de OidcConnectionImpl -configuratie. De eigenschap service.ranking in de @Component annotatie (ingesteld op 50 in het voorbeeld) bepaalt de prioriteit of meerdere processors zijn geregistreerd voor dezelfde verbinding. Hogere classificaties hebben voorrang op de standaardwaarde SlingUserInfoProcessorImpl (met een classificatie van 0).

Afhankelijkheden custom-userinfoprocessor-dependencies

Voeg de volgende gebiedsdelen aan uw kernmodule pom.xml toe:

<dependency>
    <groupId>org.apache.sling</groupId>
    <artifactId>org.apache.sling.auth.oauth-client</artifactId>
    <version>0.1.7</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.9</version>
    <scope>provided</scope>
</dependency>

Kenmerken synchroniseren met DefaultSyncHandler synchronizing-custom-attributes

Om ervoor te zorgen dat uw aangepaste kenmerken aan gebruikersknooppunten in het JCR blijven bestaan, werkt u uw DefaultSyncHandler -configuratie bij en voegt u de eigenschappentoewijzingen in:

org.apache.jackrabbit.oak.spi.security.authentication.external.impl.DefaultSyncHandler~azure.cfg.json

{
  "user.expirationTime": "1h",
  "user.membershipExpTime": "1h",
  "user.propertyMapping": [
    "profile/givenName=profile/given_name",
    "profile/familyName=profile/family_name",
    "rep:fullname=profile/name",
    "profile/email=profile/email",
    "profile/department=profile/department",
    "profile/employeeId=profile/employeeId",
    "profile/jobTitle=profile/jobTitle",
    "access_token=access_token"
  ],
  "user.pathPrefix": "azure",
  "handler.name": "azure"
}

De notatie is jcrPropertyPath=credentialAttributeName . Aan de linkerkant wordt de eigenschap opgeslagen in het gebruikersknooppunt onder /home/users en aan de rechterkant komt de kenmerknaam overeen die u instelt in het UserInfoProcessor using credentials.setAttribute() .

Implementatie en testen custom-userinfoprocessor-deployment

Aanbevolen procedures custom-userinfoprocessor-best-practices

ACL voor externe groepen configureren configure-acl-for-external-groups

Wanneer de gebruikers door OIDC voor authentiek worden verklaard, worden hun groepslidmaatschappen typisch gesynchroniseerd van de externe identiteitsleverancier.
Deze externe groepen worden dynamisch gemaakt in de AEM-opslagplaats, maar worden niet automatisch gekoppeld aan toegangsbeheeritems.
Om ervoor te zorgen dat de gebruikers de aangewezen toestemmingen hebben, moeten de toegangsbeheerlijsten (ACLs) uitdrukkelijk voor deze groepen worden bepaald.

Er zijn twee primaire benaderingen beschikbaar.

Optie 1 — Lokale groepen

De externe groep kan als lid van een lokale groep worden toegevoegd die reeds vereiste ACLs heeft.

Optie 2 — Directe ACLs op Externe Groepen via RepoInit

ACLs kan rechtstreeks op externe groepen worden toegepast gebruikend manuscripten RepoInit.

Voorbeeld: OIDC-verificatie configureren met Azure Active Directory

Een nieuwe toepassing configureren in de Active Directory van Azure configure-a-new-application-in-azure-ad

org.apache.sling.auth.oauth_client.impl.OidcConnectionImpl~azure.cfg.json

{
  "name":"azure",
  "scopes":[
    openid", "User.Read", "profile", "email"
  ],
  "baseUrl":"https://login.microsoftonline.com/tenant-id/v2.0",
  "clientId":"client-id",
  "clientSecret":"secret"
}

org.apache.sling.auth.oauth_client.impl.OidcAuthenticationHandler~azure.cfg.json

{
  "callbackUri":"https://www.mywebsite.com/content/wknd/us/en/adventures/j_security_check",
  "path":[
    "/content/wknd/us/en/adventures"
  ],
  "idp":"azure",
  "defaultConnectionName":"azure"
}

org.apache.jackrabbit.oak.spi.security.authentication.external.impl.ExternalLoginModuleFactory~azure.cfg.json

{
  "sync.handlerName":"azure",
  "idp.name":"azure"
}

org.apache.jackrabbit.oak.spi.security.authentication.external.impl.DefaultSyncHandler~azure.cfg.json

{
  "user.expirationTime":"1h",
  "user.membershipExpTime":"1h",
  "group.expirationTime": "1d"
  "user.propertyMapping":[
    "profile/givenName=profile/given_name",
    "profile/familyName=profile/family_name",
    "rep:fullname=profile/name",
    "profile/email=profile/email",
    "access_token=access_token",
    "refresh_token=refresh_token"
  ],
  "user.pathPrefix":"azure",
  "group.pathPrefix": "oidc",
  "user.membershipNestingDepth": "1",
  "handler.name":"azure"
}

org.apache.sling.jcr.repoinit.RepositoryInitializer~azure.cfg.json

{
  "scripts":[
    "set ACL for \"adventures;azure\"  (ACLOptions=ignoreMissingPrincipal)\r\n  allow jcr:read on /content/wknd/us/en/adventures\r\nend"
  ]
}

org.apache.sling.auth.oauth_client.impl.SlingUserInfoProcessorImpl~azure.cfg.json

{
  "groupsInIdToken": "true",
  "storeAccessToken": "false",
  "storeRefreshToken": "false",
  "connection": "azure",
  "groupsClaimName": "groups"
}

Aanvullende informatie over Azure AD-groepen additional-information-about-azure-ad-groups

Om een groep aan voor de ondernemingstoepassing in Microsoft Azure Portal te vormen, moet u de toepassing zoeken: Toepassingen van de Onderneming en de groepen toevoegen:

Om de groepseis in het Token van identiteitskaart toe te laten, voeg de eis in de Symbolische sectie van de Configuratie van het Portaal van Microsoft Azure toe:

De configuratie van SlingUserInfoProcessor moet worden gewijzigd zoals in het onderstaande voorbeeld.

De bestandsnaam die moet worden gewijzigd, is org.apache.sling.auth.oauth_client.impl.SlingUserInfoProcessorImpl.cfg.json . De inhoud moet als volgt worden geconfigureerd:

{
  "connection": "azure",
  "groupsInIdToken": "true",
  "storeAccessToken": "false",
  "storeRefreshToken": "false"
}

Aangepaste omleiding na verificatie custom-redirect-after-authentication

Standaard worden gebruikers na geslaagde OIDC-verificatie weer omgeleid naar de oorspronkelijk aangevraagde URL. U kunt dit gedrag echter aanpassen met de parameter redirect query.

Parameter omleiden gebruiken

Wanneer u verificatie start, kunt u een aangepaste omleidings-URL opgeven door de parameter redirect toe te voegen aan uw verificatieaanvraag:

/content/wknd/us/en/adventures?redirect=/content/wknd/us/en/welcome

In dit voorbeeld wordt de gebruiker, nadat de verificatie is voltooid, omgeleid naar /content/wknd/us/en/welcome in plaats van naar de oorspronkelijk aangevraagde pagina.

Beveiligingsbeperkingen

Om veiligheidsredenen heeft de parameter redirect de volgende beperkingen:

Als een ongeldige omleidings-URL wordt opgegeven, mislukt de verificatie met een fout.

Voorbeelden van gevallen

Hoe te van de Handler van de Authentificatie van Saml aan de Handler van de Authentificatie Oidc migreren

Wanneer AEM reeds met een Handler van de Authentificatie van SAML wordt gevormd, en de gebruikers in de bewaarplaats met ​ toegelaten gegevenssynchronisatie ​ aanwezig zijn, kunnen de conflicten tussen de originele gebruikers van SAML en de nieuwe gebruikers OIDC voorkomen.