Aktivera inloggning för Java WebLogic-appar med MSAL4J med Azure Active Directory B2C

Den här artikeln visar ett Java Servlet-program som autentiserar användare mot Azure Active Directory B2C (Azure AD B2C) med hjälp av Microsoft Authentication Library for Java (MSAL4J).

Följande diagram visar appens topologi:

Diagram som visar appens topologi.

Appen använder MSAL4J för att logga in användare och hämta en ID-token från Azure AD B2C. ID-token bevisar att användaren autentiseras mot en Azure AD B2C-klientorganisation.

Förutsättningar

• JDK version 8 eller senare
• Maven 3
• En Azure AD B2C-klientorganisation. Mer information finns i Självstudie: Skapa en Azure Active Directory B2C-klientorganisation
• Ett användarkonto i din Azure AD B2C-klientorganisation.

• WebLogic
• Visual Studio Code
• Azure Tools för Visual Studio Code

Rekommendationer

• Viss kunskap om Java/Jakarta Servlets.
• Viss kunskap om Linux/OSX-terminalen.
• jwt.ms för att inspektera dina token.
• Fiddler för övervakning av nätverksaktivitet och felsökning.
• Följ Microsoft Entra-bloggen för att hålla dig up-to-date med den senaste utvecklingen.

Konfigurera exemplet

I följande avsnitt visas hur du konfigurerar exempelprogrammet.

Klona eller ladda ned exempellagringsplatsen

Om du vill klona exemplet öppnar du ett Bash-fönster och använder följande kommando:

git clone https://github.com/Azure-Samples/ms-identity-msal-java-samples.git
cd 3-java-servlet-web-app/1-Authentication/sign-in-b2c

Du kan också gå till lagringsplatsen ms-identity-msal-java-samples och sedan ladda ned den som en .zip fil och extrahera den till hårddisken.

Registrera exempelprogrammet med din Azure AD B2C-klientorganisation

Exemplet levereras med ett förregistrerat program i testsyfte. Om du vill använda din egen Azure AD B2C-klientorganisation och ditt program följer du stegen i följande avsnitt för att registrera och konfigurera programmet i Azure Portal. Annars fortsätter du med stegen för Kör exemplet.

Välj den Azure AD B2C-klientorganisation där du vill skapa dina program

Använd följande steg för att välja klientorganisation:

1. Logga in på Azure-portalen.

2. Om ditt konto finns i mer än en Azure AD B2C-klientorganisation väljer du din profil i hörnet av Azure Portal och väljer sedan Växla katalog för att ändra sessionen till önskad Azure AD B2C-klientorganisation.

Skapa användarflöden och anpassade principer

Information om hur du skapar vanliga användarflöden som registrering, inloggning, profilredigering och lösenordsåterställning finns i Självstudie: Skapa användarflöden i Azure Active Directory B2C.

Du bör även överväga att skapa anpassade principer i Azure Active Directory B2C , men detta ligger utanför omfånget för den här självstudien.

Lägga till externa identitetsprovidrar

Se Självstudie: Lägga till identitetsprovidrar i dina program i Azure Active Directory B2C.

Registrera appen (ms-identity-b2c-java-servlet-webapp-authentication)

Använd följande steg för att registrera appen:

1. Gå till Azure Portal och välj Azure AD B2C.

2. Välj Appregistreringar i navigeringsfönstret och välj sedan Ny registrering.

3. På sidan Registrera ett program som visas anger du följande programregistreringsinformation:

   • I avsnittet Namn anger du ett beskrivande programnamn för visning för användare av appen , till exempel ms-identity-b2c-java-servlet-webapp-authentication.
   • Under Kontotyper som stöds väljer du Konton i valfri organisationskatalog och personliga Microsoft-konton (t.ex. Skype, Xbox Outlook.com).
   • I avsnittet Omdirigerings-URI (valfritt) väljer du Webb i kombinationsrutan och anger följande omdirigerings-URI: http://localhost:8080/ms-identity-b2c-java-servlet-webapp-authentication/auth_redirect.

4. Välj Registrera för att skapa programmet.

5. På appens registreringssida letar du upp och kopierar värdet program-ID (klient) för senare användning. Du använder det här värdet i appens konfigurationsfil eller filer.

6. Välj Spara för att spara dina ändringar.

7. På appens registreringssida väljer du Certifikat och hemligheter i navigeringsfönstret för att öppna sidan där du kan generera hemligheter och ladda upp certifikat.

8. Under avsnittet Klienthemlighet välj Ny klienthemlighet.

9. Skriv en beskrivning – till exempel apphemlighet.

10. Välj en av de tillgängliga varaktigheterna: Om ett år, Om två år eller Aldrig upphör att gälla.

11. Markera Lägga till. Det genererade värdet visas.

12. Kopiera och spara det genererade värdet för användning i senare steg. Du behöver det här värdet för kodens konfigurationsfiler. Det här värdet visas inte igen och du kan inte hämta det på något annat sätt. Se därför till att spara den från Azure Portal innan du går till någon annan skärm eller ett annat fönster.

Konfigurera appen (ms-identity-b2c-java-servlet-webapp-authentication) för att använda din appregistrering

Använd följande steg för att konfigurera appen:

1. Öppna projektet i din IDE.

2. Öppna filen ./src/main/resources/authentication.properties.

3. Leta upp aad.clientId egenskapen och ersätt det befintliga värdet med program-ID:t eller ms-identity-b2c-java-servlet-webapp-authenticationclientId programmet från Azure Portal.

4. Leta upp aad.secret egenskapen och ersätt det befintliga värdet med det värde som du sparade när programmet skapades ms-identity-b2c-java-servlet-webapp-authentication från Azure Portal.

5. Leta upp aad.scopes egenskapen och ersätt det befintliga programklient-ID:et med det värde som du placerade i aad.clientId i steg 1 i det här avsnittet.

6. Leta upp aad.authority egenskapen och ersätt den första instansen av fabrikamb2c med namnet på Azure AD B2C-klientorganisationen där du skapade ms-identity-b2c-java-servlet-webapp-authentication programmet i Azure Portal.

7. Leta upp aad.authority egenskapen och ersätt den andra instansen av fabrikamb2c med namnet på Azure AD B2C-klientorganisationen där du skapade ms-identity-b2c-java-servlet-webapp-authentication programmet i Azure Portal.

8. aad.signInPolicy Leta upp egenskapen och ersätt den med namnet på registrerings-/inloggningsprincipen för användarflöde som du skapade i Azure AD B2C-klientorganisationen där du skapade ms-identity-b2c-java-servlet-webapp-authentication programmet i Azure Portal.

9. Leta upp aad.passwordResetPolicy egenskapen och ersätt den med namnet på principen för lösenordsåterställning av användarflöde som du skapade i Azure AD B2C-klientorganisationen där du skapade ms-identity-b2c-java-servlet-webapp-authentication programmet i Azure Portal.

10. Leta upp aad.editProfilePolicy egenskapen och ersätt den med namnet på användarflödesprincipen för redigeringsprofilen som du skapade i Azure AD B2C-klientorganisationen där du skapade ms-identity-b2c-java-servlet-webapp-authentication programmet i Azure Portal.

Skapa exemplet

Om du vill skapa exemplet med Maven går du till katalogen som innehåller pom.xml-filen för exemplet och kör sedan följande kommando:

mvn clean package

Det här kommandot genererar en .war-fil som du kan köra på olika programservrar.

Kör exemplet

Dessa instruktioner förutsätter att du har installerat WebLogic och konfigurerat en serverdomän.

Innan du kan distribuera till WebLogic använder du följande steg för att göra några konfigurationsändringar i själva exemplet och sedan skapa eller återskapa paketet:

1. I exemplet hittar du filen application.properties eller authentication.properties där du konfigurerade klient-ID, klientorganisation, omdirigerings-URL och så vidare.

2. I den här filen ändrar du referenser till localhost:8080 eller localhost:8443 till den URL och port som WebLogic körs på, som som standard ska vara localhost:7001.

3. Du måste också göra samma ändring i Azure-appregistreringen, där du anger den i Azure Portal som omdirigerings-URI-värdet på fliken Autentisering.

Använd följande steg för att distribuera exemplet till WebLogic via webbkonsolen:

1. Starta WebLogic-servern med hjälp av DOMAIN_NAME\bin\startWebLogic.cmd.

2. Gå till WebLogic-webbkonsolen i webbläsaren på http://localhost:7001/console.

3. Gå till Distributioner av domänstruktur > , välj Installera, välj Ladda upp dina filer och leta upp den .war-fil som du skapade med hjälp av Maven.

4. Välj Installera den här distributionen som ett program, välj Nästa, välj Slutför och välj sedan Spara.

5. De flesta standardinställningarna bör vara bra förutom att du bör namnge programmet så att det matchar den omdirigerings-URI som du angav i exempelkonfigurationen eller Azure-appregistreringen. Om omdirigerings-URI:n är http://localhost:7001/msal4j-servlet-authbör du ge programmet msal4j-servlet-authnamnet .

6. Gå tillbaka till Distributioner av domänstruktur> och starta programmet.

7. När programmet har startat går du till http://localhost:7001/<application-name>/och du bör kunna komma åt programmet.

Utforska exemplet

Använd följande steg för att utforska exemplet:

1. Observera den inloggade eller utloggade statusen som visas i mitten av skärmen.
2. Välj den sammanhangskänsliga knappen i hörnet. Den här knappen läser Logga in när du först kör appen.
3. På nästa sida följer du anvisningarna och loggar in med ett konto för din valda identitetsprovider.
4. Observera att den sammanhangskänsliga knappen nu säger Logga ut och visar ditt användarnamn.
5. Välj ID-tokeninformation för att se några av ID-tokens avkodade anspråk.
6. Du kan också redigera din profil. Välj länken för att redigera information som ditt visningsnamn, bostadsort och yrke.
7. Använd knappen i hörnet för att logga ut.
8. När du har loggat ut går du till följande URL för sidan med tokeninformation: http://localhost:8080/ms-identity-b2c-java-servlet-webapp-authentication/auth_token_details. Här kan du se hur appen visar ett 401: unauthorized fel i stället för ID-tokenanspråken.

Om koden

Det här exemplet visar hur du använder MSAL4J för att logga in användare i din Azure AD B2C-klientorganisation.

Innehåll

I följande tabell visas innehållet i exempelprojektmappen:

ConfidentialClientApplication

En ConfidentialClientApplication instans skapas i AuthHelper.java-filen, som du ser i följande exempel. Det här objektet hjälper dig att skapa Azure AD B2C-auktoriserings-URL:en och hjälper även till att byta ut autentiseringstoken mot en åtkomsttoken.

IClientSecret secret = ClientCredentialFactory.createFromSecret(SECRET);
confClientInstance = ConfidentialClientApplication
                     .builder(CLIENT_ID, secret)
                     .b2cAuthority(AUTHORITY + policy)
                     .build();

Följande parametrar används för instansiering:

• Appens klient-ID.
• Klienthemligheten, som är ett krav för konfidentiella klientprogram.
• Azure AD B2C-utfärdaren sammanfogade med lämplig för UserFlowPolicy registrering, inloggning, profilredigering eller lösenordsåterställning.

I det här exemplet läss dessa värden från filen authentication.properties med hjälp av en egenskapsläsare i filen Config.java .

Stegvis genomgång

Följande steg innehåller en genomgång av appens funktioner:

1. Det första steget i inloggningsprocessen är att skicka en begäran till /authorize slutpunkten för din Azure Active Directory B2C-klientorganisation. MSAL4J-instansen ConfidentialClientApplication används för att konstruera en URL för auktoriseringsbegäran och appen omdirigerar webbläsaren till den här URL:en, enligt följande exempel:

   final ConfidentialClientApplication client = getConfidentialClientInstance(policy);
   final AuthorizationRequestUrlParameters parameters = AuthorizationRequestUrlParameters
       .builder(REDIRECT_URI, Collections.singleton(SCOPES)).responseMode(ResponseMode.QUERY)
       .prompt(Prompt.SELECT_ACCOUNT).state(state).nonce(nonce).build();
   
   final String redirectUrl = client.getAuthorizationRequestUrl(parameters).toString();
   Config.logger.log(Level.INFO, "Redirecting user to {0}", redirectUrl);
   resp.setStatus(302);
   resp.sendRedirect(redirectUrl);
   

   I följande lista beskrivs funktionerna i den här koden:

   • AuthorizationRequestUrlParameters: Parametrar som måste anges för att skapa en AuthorizationRequestUrl.

   • REDIRECT_URI: När Azure AD B2C omdirigerar webbläsaren – tillsammans med autentiseringskoden – efter att användarens autentiseringsuppgifter har samlats in.

   • SCOPES: Omfång är behörigheter som begärs av programmet.

     Normalt räcker det med de tre omfången openid profile offline_access för att ta emot ett ID-tokensvar. MSAL4J kräver dock att alla svar från Azure AD B2C även innehåller en åtkomsttoken.

     För att Azure AD B2C ska kunna dela ut en åtkomsttoken och en ID-token måste begäran innehålla ytterligare ett resursomfång. Eftersom den här appen inte kräver något externt resursomfång lägger den till ett eget klient-ID som ett fjärde omfång för att kunna ta emot en åtkomsttoken.

     Du hittar en fullständig lista över omfång som begärs av appen i filen authentication.properties .

   • ResponseMode.QUERY: Azure AD B2C kan returnera svaret som formulärparamer i en HTTP POST-begäran eller som frågesträngparamer i en HTTP GET-begäran.

   • Prompt.SELECT_ACCOUNT: Azure AD B2C bör be användaren att välja det konto som de tänker autentisera mot.

   • state: En unik variabel som anges av appen i sessionen för varje tokenbegäran och förstörs efter att motsvarande Azure AD B2C-återanrop har tagits emot. Tillståndsvariabeln säkerställer att Azure AD B2C-begäranden till /auth_redirect endpoint faktiskt kommer från Azure AD B2C-auktoriseringsbegäranden som kommer från den här appen och den här sessionen, vilket förhindrar CSRF-attacker. Detta görs i filen AADRedirectServlet.java .

   • nonce: En unik variabel som anges av appen i sessionen för varje tokenbegäran och förstörs när motsvarande token har tagits emot. Den här nonce transkriberas till de resulterande token som har delats ut från Azure AD B2C, vilket säkerställer att det inte sker någon tokenreprisattack.

2. Användaren får en inloggningsprompt av Azure Active Directory B2C. Om inloggningsförsöket lyckas omdirigeras användarens webbläsare till appens omdirigeringsslutpunkt. En giltig begäran till den här slutpunkten innehåller en auktoriseringskod.

3. Instansen ConfidentialClientApplication utbyter sedan den här auktoriseringskoden för en ID-token och åtkomsttoken från Azure Active Directory B2C, som du ser i följande exempel:

   final AuthorizationCodeParameters authParams = AuthorizationCodeParameters
                       .builder(authCode, new URI(REDIRECT_URI))
                       .scopes(Collections.singleton(SCOPES)).build();
   
   final ConfidentialClientApplication client = AuthHelper
           .getConfidentialClientInstance(policy);
   final Future<IAuthenticationResult> future = client.acquireToken(authParams);
   final IAuthenticationResult result = future.get();
   

   I följande lista beskrivs funktionerna i den här koden:

   • AuthorizationCodeParameters: Parametrar som måste anges för att kunna byta auktoriseringskoden mot ett ID och/eller en åtkomsttoken.
   • authCode: Auktoriseringskoden som togs emot vid omdirigeringsslutpunkten.
   • REDIRECT_URI: Omdirigerings-URI:n som användes i föregående steg måste skickas igen.
   • SCOPES: Omfången som användes i föregående steg måste skickas igen.

4. Om acquireToken det lyckas extraheras tokenanspråken och nonce-anspråket verifieras mot den nonce som lagras i sessionen, enligt följande exempel:

   parseJWTClaimsSetAndStoreResultInSession(msalAuth, result, serializedTokenCache);
   validateNonce(msalAuth)
   processSuccessfulAuthentication(msalAuth);
   

5. Om nonce har verifierats placeras autentiseringsstatusen i en session på serversidan med metoder som exponeras av MsalAuthSession klassen, enligt följande exempel:

   msalAuth.setAuthenticated(true);
   msalAuth.setUsername(msalAuth.getIdTokenClaims().get("name"));
   

Mer information

• Vad är Azure Active Directory B2C?
• Programtyper som kan användas i Active Directory B2C
• Rekommendationer och metodtips för Azure Active Directory B2C
• Azure AD B2C-session
• Microsoft Authentication Library (MSAL) för Java

Mer information om hur OAuth 2.0-protokoll fungerar i det här scenariot och andra scenarier finns i Autentiseringsscenarier för Microsoft Entra-ID.

Gå vidare

Distribuera Java WebLogic-appar till WebLogic på virtuella Azure-datorer