Ověření uživatelských vstupů pomocí vlastních zásad Azure Active Directory B2C

Důležité

Od 1. května 2025 už nebude Azure AD B2C k dispozici k nákupu pro nové zákazníky. Další informace najdete v našich nejčastějších dotazech.

Vlastní zásady Azure Active Directory B2C (Azure AD B2C) umožňují nejen označit uživatelské vstupy jako povinné, ale také je ověřit. Uživatelské vstupy můžete označit jako povinné, například <DisplayClaim ClaimTypeReferenceId="givenName" Required="true"/>, ale neznamená to, že uživatelé zadají platná data. Azure AD B2C nabízí různé způsoby ověření uživatelského vstupu. V tomto článku se dozvíte, jak napsat vlastní zásadu, která shromažďuje vstupy uživatelů a ověřuje je pomocí následujících přístupů:

• Omezte data, která uživatel zadá, zadáním seznamu možností, ze které si můžete vybrat. Tento přístup používá výčtové hodnoty, které přidáte při deklaraci nároku identity.

• Definujte vzor, který se musí shodovat se vstupem uživatele. Tento přístup používá regulární výrazy, které přidáte při deklaraci nároku.

• Definujte sadu pravidel a vyžadovat, aby vstup uživatele dodržoval jedno nebo více pravidel. Tento přístup používá predikáty, které přidáte při deklaraci nároku.

• Pomocí speciálního typu deklarace identity reenterPassword ověřte, že uživatel správně znovu zadal heslo během shromažďování uživatelských vstupů.

• Nakonfigurujte technický profil ověřování, který definuje složitá obchodní pravidla, která není možné definovat na úrovni deklarace identity. Například shromáždíte uživatelský vstup, který je potřeba ověřit vůči hodnotě nebo sadě hodnot v jiném tvrzení.

Požadavky

• Pokud ho ještě nemáte, vytvořte klienta Azure AD B2C, který je propojený s vaším předplatným Azure.

• Zaregistrujte webovou aplikaci.

• Musíte mít Visual Studio Code (VS Code) nainstalovaný na svém počítači.

• Dokončete kroky v části Shromažďování uživatelských vstupů a manipulaci s nimi pomocí vlastních zásad Azure AD B2C. Tento článek je součástí seriálu průvodců o vytváření a provádění vlastních zásad.

Poznámka:

Tento článek je součástí série návodů "Vytvoření a spuštění vlastních zásad v Azure Active Directory B2C". Doporučujeme spustit tuto řadu z prvního článku.

Krok 1 – Ověření uživatelského vstupu omezením možností vstupu uživatele

Pokud znáte všechny možné hodnoty, které uživatel může zadat pro daný vstup, můžete zadat konečnou sadu hodnot, ze kterých si uživatel musí vybrat. Pro tento účel můžete použít dropdownSingleSelect, CheckboxMultiSelect a RadioSingleSelectUserInputType . V tomto článku použijete typ vstupu RadioSingleSelect :

1. V nástroji VS Code otevřete soubor ContosoCustomPolicy.XML.

2. V elementu ClaimsSchema souboru ContosoCustomPolicy.XML deklarujte následující typ nároku:

       <ClaimType Id="accountType">
           <DisplayName>Account Type</DisplayName>
           <DataType>string</DataType>
           <UserHelpText>The type of account used by the user</UserHelpText>
           <UserInputType>RadioSingleSelect</UserInputType>
           <Restriction>
               <Enumeration Text="Contoso Employee Account" Value="work" SelectByDefault="true"/>
               <Enumeration Text="Personal Account" Value="personal" SelectByDefault="false"/>
           </Restriction>
       </ClaimType>
   

   Prohlásili jsme nárok na accountType. Když se hodnota deklarace identity shromažďuje od uživatele, musí uživatel vybrat buď účet zaměstnance společnosti Contoso pro hodnotu pracovní, nebo osobní účet pro hodnotu osobní.

   Azure AD B2C také umožňuje přizpůsobit zásady různým jazykům a poskytuje omezení typu účtu pro více jazyků. Další informace najdete v části Lokalizace uživatelského rozhraní v článku o přidání atributů uživatele.

3. Vyhledejte technický profil s Id="UserInformationCollector" a přidejte deklaraci accountType jako zobrazované tvrzení pomocí následujícího kódu:

       <DisplayClaim ClaimTypeReferenceId="accountType" Required="true"/>
   

4. V technickém profilu Id="UserInformationCollector" přidejte deklaraci accountType jako výstupní deklaraci pomocí následujícího kódu:

       <OutputClaim ClaimTypeReferenceId="accountType"/>
   

5. Pokud chcete do přístupového tokenu zahrnout deklaraci identity typu účtu, vyhledejte RelyingParty element, přidejte deklaraci identity accountType jako deklaraci identity tokenu pomocí následujícího kódu:

       <OutputClaim ClaimTypeReferenceId="accountType" />
   

Krok 2 – Ověření uživatelského vstupu pomocí regulárních výrazů

Pokud není možné předem znát všechny možné uživatelské vstupní hodnoty, umožníte uživateli zadat data sama. V tomto případě můžete použít regulární výrazy (regex) nebo vzor k určení, jak je potřeba naformátovat uživatelský vstup. Například e-mail musí mít symbol at (@) a tečku (.) někde v textu.

Když deklarujete nárok, vlastní zásady umožňují definovat regulární výraz, kterému musí odpovídat vstup uživatele. Volitelně můžete zadat zprávu, která se uživateli zobrazí, pokud jeho vstup neodpovídá výrazu.

1. ClaimsSchema Vyhledejte prvek a deklarujte nárok e-mailu pomocí následujícího kódu:

       <ClaimType Id="email">
           <DisplayName>Email Address</DisplayName>
           <DataType>string</DataType>
           <DefaultPartnerClaimTypes>
               <Protocol Name="OpenIdConnect" PartnerClaimType="email"/>
           </DefaultPartnerClaimTypes>
           <UserHelpText>Your email address. </UserHelpText>
           <UserInputType>TextBox</UserInputType>
           <Restriction>
               <Pattern RegularExpression="^[a-zA-Z0-9.!#$%&amp;&apos;^_`{}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$" HelpText="Please enter a valid email address something like maurice@contoso.com"/>
           </Restriction>
       </ClaimType>
   

2. Vyhledejte technický profil pomocí Id="UserInformationCollector", přidejte e-mailový požadavek jako zobrazovaný požadavek pomocí následujícího kódu:

       <DisplayClaim ClaimTypeReferenceId="email" Required="true"/>
   

3. V technickém profilu Id="UserInformationCollector"přidejte nárok na e-mail jako výstupní nárok pomocí následujícího kódu:

       <OutputClaim ClaimTypeReferenceId="email"/>
   

4. RelyingParty Vyhledejte prvek a přidejte e-mail jako deklaraci identity tokenu pomocí následujícího kódu:

       <OutputClaim ClaimTypeReferenceId="email" />
   

Krok 3 – Ověření uživatelského vstupu pomocí predikátů

Použili jste regulární výraz k ověření uživatelských vstupů. Regulární výrazy však mají jednu slabinu: chybová zpráva se zobrazuje, dokud neopravíte vstup, aniž by vás informovala o konkrétním požadavku, který vstupu chybí.

Ověření predikátů umožňují vyřešit tento problém tím, že vám umožní definovat sadu pravidel (predikátů) a nezávislou chybovou zprávu pro každé pravidlo. Ve vlastních zásadách má predikát vestavěnou metodu, která definuje kontroly, které chcete uskutečnit. Pomocí metody predikátu IsLengthRange můžete například zkontrolovat, jestli je heslo uživatele v rozsahu zadaných minimálních a maximálních parametrů (hodnot).

Predikáty definují ověřování, které se má kontrolovat proti typu nároku, PredicateValidations seskupuje sadu predikátů, aby vytvořil ověření vstupu uživatele, které lze použít u typu nároku. Například vytvoříte predikátovou skupinu ověřování, která ověřuje různé typy povolených znaků pro heslo. Predikáty i elementy PredicateValidations jsou podřízené prvky oddílu BuildingBlocks souboru zásad.

1. Najděte prvek ClaimsSchema a deklarujte přiřazení požadavku hesla pomocí následujícího kódu:

       <ClaimType Id="password">
         <DisplayName>Password</DisplayName>
         <DataType>string</DataType>
         <AdminHelpText>Enter password</AdminHelpText>
         <UserHelpText>Enter password</UserHelpText>
         <UserInputType>Password</UserInputType>
       </ClaimType>
   

2. Pomocí následujícího kódu přidejte Predicates prvek jako podřízeného prvku do sekce BuildingBlocks. Přidáte element Predicates pod element ClaimsSchema:

       <Predicates>
   
       </Predicates>
   

3. Uvnitř elementu Predicates definujte predikáty pomocí následujícího kódu:

     <Predicate Id="IsLengthBetween8And64" Method="IsLengthRange" HelpText="The password must be between 8 and 64 characters.">
       <Parameters>
         <Parameter Id="Minimum">8</Parameter>
         <Parameter Id="Maximum">64</Parameter>
       </Parameters>
     </Predicate>
   
     <Predicate Id="Lowercase" Method="IncludesCharacters" HelpText="a lowercase letter">
       <Parameters>
         <Parameter Id="CharacterSet">a-z</Parameter>
       </Parameters>
     </Predicate>
   
     <Predicate Id="Uppercase" Method="IncludesCharacters" HelpText="an uppercase letter">
       <Parameters>
         <Parameter Id="CharacterSet">A-Z</Parameter>
       </Parameters>
     </Predicate>
   
     <Predicate Id="Number" Method="IncludesCharacters" HelpText="a digit">
       <Parameters>
         <Parameter Id="CharacterSet">0-9</Parameter>
       </Parameters>
     </Predicate>
   
     <Predicate Id="Symbol" Method="IncludesCharacters" HelpText="a symbol">
       <Parameters>
         <Parameter Id="CharacterSet">@#$%^&amp;*\-_+=[]{}|\\:',.?/`~"();!</Parameter>
       </Parameters>
     </Predicate>
   
     <Predicate Id="PIN" Method="MatchesRegex" HelpText="The password must be numbers only.">
       <Parameters>
         <Parameter Id="RegularExpression">^[0-9]+$</Parameter>
       </Parameters>
     </Predicate>
   
     <Predicate Id="AllowedCharacters" Method="MatchesRegex" HelpText="An invalid character was provided.">
       <Parameters>
         <Parameter Id="RegularExpression">(^([0-9A-Za-z\d@#$%^&amp;*\-_+=[\]{}|\\:',?/`~"();! ]|(\.(?!@)))+$)|(^$)</Parameter>
       </Parameters>
     </Predicate>
   
     <Predicate Id="DisallowedWhitespace" Method="MatchesRegex" HelpText="The password must not begin or end with a whitespace character.">
       <Parameters>
         <Parameter Id="RegularExpression">(^\S.*\S$)|(^\S+$)|(^$)</Parameter>
       </Parameters>
     </Predicate>
   

   Definovali jsme několik pravidel, která když jsou spojena dohromady, popisují přijatelné heslo. Dále můžete seskupit predikáty a vytvořit sadu zásad hesel, které můžete použít ve svých zásadách.

4. Pomocí následujícího kódu přidejte PredicateValidations prvek jako podřízeného prvku do sekce BuildingBlocks. Element PredicateValidations přidáte jako podřízený prvek do sekce BuildingBlocks, ale pod element Predicates.

       <PredicateValidations>
   
       </PredicateValidations>
   

5. Uvnitř elementu PredicateValidations definujte PredicateValidations pomocí následujícího kódu:

       <PredicateValidation Id="SimplePassword">
           <PredicateGroups>
               <PredicateGroup Id="DisallowedWhitespaceGroup">
                   <PredicateReferences>
                       <PredicateReference Id="DisallowedWhitespace"/>
                   </PredicateReferences>
               </PredicateGroup>
               <PredicateGroup Id="AllowedCharactersGroup">
                   <PredicateReferences>
                       <PredicateReference Id="AllowedCharacters"/>
                   </PredicateReferences>
               </PredicateGroup>
               <PredicateGroup Id="LengthGroup">
                   <PredicateReferences>
                       <PredicateReference Id="IsLengthBetween8And64"/>
                   </PredicateReferences>
               </PredicateGroup>
           </PredicateGroups>
       </PredicateValidation>
       <PredicateValidation Id="StrongPassword">
           <PredicateGroups>
               <PredicateGroup Id="DisallowedWhitespaceGroup">
                   <PredicateReferences>
                       <PredicateReference Id="DisallowedWhitespace"/>
                   </PredicateReferences>
               </PredicateGroup>
               <PredicateGroup Id="AllowedCharactersGroup">
                   <PredicateReferences>
                       <PredicateReference Id="AllowedCharacters"/>
                   </PredicateReferences>
               </PredicateGroup>
               <PredicateGroup Id="LengthGroup">
                   <PredicateReferences>
                       <PredicateReference Id="IsLengthBetween8And64"/>
                   </PredicateReferences>
               </PredicateGroup>
               <PredicateGroup Id="CharacterClasses">
                   <UserHelpText>The password must have at least 3 of the following:</UserHelpText>
                   <PredicateReferences MatchAtLeast="3">
                       <PredicateReference Id="Lowercase"/>
                       <PredicateReference Id="Uppercase"/>
                       <PredicateReference Id="Number"/>
                       <PredicateReference Id="Symbol"/>
                   </PredicateReferences>
               </PredicateGroup>
           </PredicateGroups>
       </PredicateValidation>
       <PredicateValidation Id="CustomPassword">
           <PredicateGroups>
               <PredicateGroup Id="DisallowedWhitespaceGroup">
                   <PredicateReferences>
                       <PredicateReference Id="DisallowedWhitespace"/>
                   </PredicateReferences>
               </PredicateGroup>
               <PredicateGroup Id="AllowedCharactersGroup">
                   <PredicateReferences>
                       <PredicateReference Id="AllowedCharacters"/>
                   </PredicateReferences>
               </PredicateGroup>
           </PredicateGroups>
       </PredicateValidation>
   

   Definovali jsme tři validace predikátů: StrongPassword, CustomPassword a SimplePassword. V závislosti na vlastnostech hesla, které mají uživatelé zadat, můžete použít jakékoli ověření predikátu. V tomto článku použijeme silné heslo.

6. Vyhledejte deklaraci typu nároku hesla a přidejte StrongPassword Predicate Validation těsně za deklaraci elementu UserInputType pomocí následujícího kódu:

       <PredicateValidationReference Id="StrongPassword" />
   

7. Vyhledejte technický profil pomocí Id="UserInformationCollector", přidejte deklaraci hesla jako zobrazovanou deklaraci pomocí následujícího kódu:

       <DisplayClaim ClaimTypeReferenceId="password" Required="true"/>
   

8. V technickém profilu Id="UserInformationCollector" přidejte deklaraci hesla jako výstupní deklaraci pomocí tohoto kódu:

       <OutputClaim ClaimTypeReferenceId="password"/>
   

Poznámka:

Z bezpečnostních důvodů nebudeme do tokenu vygenerovaného vaší zásadou přidávat heslo uživatele jako deklaraci identity. Proto do prvku důvěřující strany nepřidáme deklaraci hesla.

Krok 4 – Ověření hesla a potvrzení hesla

Můžete vyžadovat, aby uživatelé zadali heslo dvakrát jako prostředek k potvrzení, že si uživatel zapamatuje heslo, které zadal. V tomto případě je nutné zkontrolovat, zda se hodnoty těchto dvou položek shodují. Vlastní zásady poskytují snadný způsob, jak tento požadavek dosáhnout. Deklarace identity typu heslo a heslo reenterPassword jsou považovány za speciální, takže když se používají ke shromažďování uživatelských vstupů, uživatelské rozhraní ověří, že uživatel správně znovu zadal heslo.

Pomocí následujících kroků ověřte opětovné zadání hesla ve vlastní politice:

1. V části ClaimsSchema souboru ContosoCustomPolicy.XML deklarujte reenterPassword těsně za heslo pomocí následujícího kódu:

       <ClaimType Id="reenterPassword">
           <DisplayName>Confirm new password</DisplayName>
           <DataType>string</DataType>
           <AdminHelpText>Confirm new password</AdminHelpText>
           <UserHelpText>Reenter password</UserHelpText>
           <UserInputType>Password</UserInputType>
       </ClaimType>    
   

2. Pokud chcete shromáždit zadání potvrzení hesla od uživatele, vyhledejte UserInformationCollector technický profil s vlastním potvrzením, přidejte deklaraci identity reenterPassword jako zobrazovanou deklaraci identity pomocí následujícího kódu:

       <DisplayClaim ClaimTypeReferenceId="reenterPassword" Required="true"/>
   

3. V souboru vyhledejte ContosoCustomPolicy.XML self-asserted UserInformationCollector technický profil a pomocí následujícího kódu přidejte nárok reenterPassword jako výstupní nárok:

       <OutputClaim ClaimTypeReferenceId="reenterPassword"/>
   

Krok 5 : Nahrání souboru vlastních zásad

V tomto okamžiku jste vytvořili zásadu, která řeší první tři přístupy k ověřování uživatelských vstupů.

Postupujte podle kroků v Nahrání souboru vlastních zásad. Pokud nahráváte soubor se stejným názvem jako soubor, který už je na portálu, nezapomeňte vybrat Přepsat vlastní zásady, pokud už existují.

Krok 6 – otestování vlastních zásad

1. V části Vlastní zásady vyberte B2C_1A_CONTOSOCUSTOMPOLICY.

2. Pokud chcete Vybrat aplikaci na stránce přehledu vlastních politik, vyberte webovou aplikaci, například webapp1, kterou jste předtím zaregistrovali. Ujistěte se, že hodnota Vybrat adresu URL odpovědi je nastavená nahttps://jwt.ms.

3. Stiskněte tlačítko Spustit nyní.

4. Zadejte zadané jméno a příjmení.

5. Vyberte typ účtu.

6. Do pole E-mailová adresa zadejte e-mailovou hodnotu, která není dobře naformátovaná, například maurice@contoso.

7. V části Heslo zadejte hodnotu hesla, která nedodržuje všechny vlastnosti silného hesla, jak je nastaveno.

8. Vyberte tlačítko Pokračovat . Zobrazí se obrazovka podobná té, která je znázorněna níže:

   

   Než budete pokračovat, musíte svoje vstupy opravit.

9. Zadejte správné hodnoty navrhované chybovými zprávami a pak znovu vyberte tlačítko Pokračovat . Po dokončení provádění zásady budete přesměrováni na https://jwt.ms a zobrazí se dekódovaný JWT. Token vypadá podobně jako následující fragment kódu JWT:

    {
      "typ": "JWT",
      "alg": "RS256",
      "kid": "pxLOMWFg...."
    }.{
      ...
      "sub": "c7ae4515-f7a7....",
      ...
      "acr": "b2c_1a_contosocustompolicy",
      "accountType": "work",
      ...
      "email": "maurice@contoso.com",
      "name": "Maurice Paulet",
      "message": "Hello Maurice Paulet"
    }.[Signature]

Krok 7 – Ověření uživatelského vstupu pomocí technických profilů ověření

Techniky ověřování, které jsme použili v kroku 1, kroku 2 a 3, se nevztahují pro všechny scénáře. Pokud jsou vaše obchodní pravidla příliš složitá na to, aby byla definována na úrovni deklarace žádosti, můžete nakonfigurovat technické ověřování a pak ho volat z technického profiluSelf-Asserted.

Poznámka:

Pouze technické profily s vlastním prohlášením mohou používat validační technické profily. Další informace o technickém profilu ověřování

Přehled scénáře

Vyžadujeme, aby pokud je typem účtu uživatele Účet zaměstnance Contoso, musíme zajistit, aby jejich e-mailová doména vycházela ze sady předdefinovaných domén. Tyto domény jsou contoso.com, fabrikam.com a woodgrove.com. V opačném případě uživateli zobrazíme chybu, dokud nepoužije platný účet zaměstnance společnosti Contoso nebo se nepřepne na osobní účet.

Pomocí následujících kroků se dozvíte, jak ověřit uživatelský vstup pomocí technických profilů ověření. Používáte technický profil ověření typu transformace nároků, ale můžete také volat službu REST API k ověření dat. Jak se naučíte později v této sérii.

1. V části ClaimsSchema souboru ContosoCustomPolicy.XML deklarujte nároky domain a domainStatus pomocí následujícího kódu:

       <ClaimType Id="domain">
         <DataType>string</DataType>
       </ClaimType>
   
       <ClaimType Id="domainStatus">
         <DataType>string</DataType>
       </ClaimType>
   

2. Vyhledejte sekci ClaimsTransformations a pomocí následujícího kódu nakonfigurujte transformace deklarací identity.

       <ClaimsTransformation Id="GetDomainFromEmail" TransformationMethod="ParseDomain">
           <InputClaims>
               <InputClaim ClaimTypeReferenceId="email" TransformationClaimType="emailAddress"/>
           </InputClaims>
           <OutputClaims>
               <OutputClaim ClaimTypeReferenceId="domain" TransformationClaimType="domain"/>
           </OutputClaims>
       </ClaimsTransformation>
       <ClaimsTransformation Id="LookupDomain" TransformationMethod="LookupValue">
           <InputClaims>
               <InputClaim ClaimTypeReferenceId="domain" TransformationClaimType="inputParameterId"/>
           </InputClaims>
           <InputParameters>
               <InputParameter Id="contoso.com" DataType="string" Value="valid"/>
               <InputParameter Id="fabrikam.com" DataType="string" Value="valid"/>
               <InputParameter Id="woodgrove.com" DataType="string" Value="valid"/>
               <InputParameter Id="errorOnFailedLookup" DataType="boolean" Value="true"/>
           </InputParameters>
           <OutputClaims>
               <OutputClaim ClaimTypeReferenceId="domainStatus" TransformationClaimType="outputClaim"/>
           </OutputClaims>
       </ClaimsTransformation>
   

   Transformace deklarací identity GetDomainFromEmail extrahuje doménu z e-mailu pomocí metody ParseDomain a uloží ji do deklarace identity domény . Transformace nároků LookupDomain používá extrahovanou doménu ke kontrole, zda je platná, vyhledáním v předdefinovaných doménách a přiřazením platné nároku domainStatus.

3. Pomocí následujícího kódu přidejte technický profil ve stejném zprostředkovateli deklarací jako technický profil s Id=UserInformationCollector:

       <TechnicalProfile Id="CheckCompanyDomain">
           <DisplayName>Check Company validity </DisplayName>
           <Protocol Name="Proprietary" Handler="Web.TPEngine.Providers.ClaimsTransformationProtocolProvider, Web.TPEngine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>
           <InputClaimsTransformations>
               <InputClaimsTransformation ReferenceId="GetDomainFromEmail"/>
           </InputClaimsTransformations>
           <OutputClaims>
               <OutputClaim ClaimTypeReferenceId="domain"/>
           </OutputClaims>
           <OutputClaimsTransformations>
               <OutputClaimsTransformation ReferenceId="LookupDomain"/>
           </OutputClaimsTransformations>
       </TechnicalProfile>
   

   Deklarovali jsme technický profil transformace deklarací, který provádí transformace GetDomainFromEmail a LookupDomain.

4. Pomocí následujícího kódu vyhledejte technický profil s prvkem Id=UserInformationCollectora ValidationTechnicalProfile těsně za OutputClaims elementem:

       <ValidationTechnicalProfiles>
           <ValidationTechnicalProfile ReferenceId="CheckCompanyDomain">
               <Preconditions>
                   <Precondition Type="ClaimEquals" ExecuteActionsIf="false">
                       <Value>accountType</Value>
                       <Value>work</Value>
                       <Action>SkipThisValidationTechnicalProfile</Action>
                   </Precondition>
               </Preconditions>
           </ValidationTechnicalProfile>
       </ValidationTechnicalProfiles>
   

   Do samostatně tvrdícího technického profilu UserInformationCollector jsme přidali validační technický profil. Technický profil se přeskočí jenom v případě, že hodnota accountType není rovna práci. Pokud se technický profil spustí a e-mailová doména není platná, vyvolá se chyba.

5. Vyhledejte technický profil s kódem Id=UserInformationCollectora přidejte do značky metadata následující kód.

       <Item Key="LookupNotFound">The provided email address isn't a valid Contoso Employee email.</Item>
   

   Pro případ, že uživatel nepoužívá platný e-mail, jsme nastavili vlastní chybu.

6. Pokud chcete nahrát soubor zásad, postupujte podle pokynů v nahrání souboru vlastních zásad .

7. Podle pokynů v kroku 6 otestujte vlastní zásady:

   1. Jako typ účtu vyberte Účet zaměstnance contoso.
   2. Do e-mailové adresy zadejte neplatnou e-mailovou adresu, například maurice@fourthcoffee.com.
   3. Zadejte zbývající podrobnosti podle potřeby a vyberte Pokračovat.

   Vzhledem k tomu, že maurice@fourthcoffee.com není platný e-mail, zobrazí se chyba podobná té, která je zobrazená na následujícím snímku. K úspěšnému spuštění vlastní zásady a přijetí JWT musíte použít platnou e-mailovou adresu.

   

Související obsah

• Přečtěte si o technickém profilu ověřování.

• Zjistěte, jak podmíněně povolit nebo zakázat technické profily ve vlastních zásadách Azure AD B2C.