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

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 deklarace 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 deklarace identity.

• 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 deklarace identity.

• 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 deklarací deklarací identity. Například shromáždíte uživatelský vstup, který je potřeba ověřit vůči hodnotě nebo nastaveným hodnotám v jiné deklaraci identity.

Předpoklady

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

• Zaregistrujte webovou aplikaci a povolte implicitní udělení tokenu ID. Pro identifikátor URI přesměrování použijte https://jwt.ms.

• V počítači musíte mít nainstalovaný Visual Studio Code (VS Code ).

• 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í vytváření a spouštění vlastních zásad, které vás provedou řadou návodů.

Poznámka:

Tento článek je součástí řady s návody k 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 DropdownSinglSelect, CheckboxMultiSelect a RadioSingleSelect UserInputType. V tomto článku použijete typ vstupu RadioSingleSelect :

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

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

       <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>
   

   Deklarovali jsme deklaraci identity accountType . Když se hodnota deklarace identity shromažďuje od uživatele, musí uživatel vybrat účet zaměstnance společnosti Contoso pro hodnotu pracovní nebo osobní účet pro osobní hodnotu.

   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 článku o přidání atributů uživatele v uživatelském rozhraní.

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

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

4. V technickém profilu Id="UserInformationCollector"přidejte deklaraci identity accountType jako výstupní deklaraci identity 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 deklaraci identity, vlastní zásady umožňují definovat regulární výraz, který musí vstup uživatele odpovídat. Volitelně můžete zadat zprávu, která se uživateli zobrazí, pokud jeho vstup neodpovídá výrazu.

1. ClaimsSchema Vyhledejte prvek a deklarujte deklaraci identity 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říkazu , přidejte deklaraci identity e-mailu jako zobrazovanou deklaraci identity pomocí následujícího kódu:

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

3. V technickém profilu Id="UserInformationCollector"přidejte deklaraci identity e-mailu jako výstupní deklaraci identity 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ýraz však má jednu slabinu, to znamená, že chybová zpráva se zobrazí, dokud neopravíte vstup, aniž byste ukázali konkrétní požadavek, že vstup 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 předem připravenou metodu, která definuje kontroly, které chcete provést. 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 deklarace identity, predikateValidations seskupí sadu predikátů, aby vytvořily ověření vstupu uživatele, které lze použít u typu deklarace identity. 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. ClaimsSchema Vyhledejte prvek a deklarujte deklaraci identity 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. Predicates Přidejte prvek jako podřízený oddíl BuildingBlocks pomocí následujícího kódu. Pod element přidáte Predicates 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>
   

   Nadefinovali jsme několik pravidel, která při společném vytvoření popsala 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. PredicateValidations Přidejte prvek jako podřízený oddíl BuildingBlocks pomocí následujícího kódu. Element přidáte PredicateValidations jako podřízený BuildingBlocks oddíl, ale pod Predicates element:

       <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 definice Predikát Validation, 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 deklarace identity hesla a přidejte StrongPassword Predicate Validation těsně za deklaraci elementu UserInputType, který obsahuje pomocí následujícího kódu:

       <PredicateValidationReference Id="StrongPassword" />
   

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

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

8. V technickém profilu Id="UserInformationCollector"přidejte deklaraci identity hesla jako výstupní deklaraci identity pomocí následujícího 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 elementu předávají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 do vlastních zásad:

1. ClaimsSchema V části ContosoCustomPolicy.XML souboru deklarujte deklaraci deklarace identity reenterPassword těsně za deklarací hesla 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.XMLUserInformationCollector technický profil s vlastním kontrolním výrazem a pomocí následujícího kódu přidejte deklaraci identity reenterPassword jako výstupní deklaraci identity:

       <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 Možnost Přepsat vlastní zásadu, pokud už existuje.

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

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

2. V části Vybrat aplikaci na stránce přehledu vlastních zásad vyberte webovou aplikaci, například webovou aplikaci1 , kterou jste předtím zaregistrovali. Ujistěte se, že je nastavená https://jwt.mshodnota Vybrat adresu URL odpovědi.

3. Vyberte tlačítko Spustit.

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.msa zobrazí se dekódovaný token JWT. Token vypadá podobně jako následující fragment tokenu 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 obchodní pravidla složitá tak, aby byla definována na úrovni deklarace deklarací, můžete nakonfigurovat ověření technického profilu a pak ho volat z technického profilu s vlastním uplatněním.

Poznámka:

Technické profily s vlastním kontrolním výrazem můžou používat ověřovací 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 účetcontoso zaměstnanec, musíme zajistit, aby jejich e-mailová doména byla založena na sadě 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žijete technický profil ověření typu transformace deklarací identity, ale můžete také volat službu REST API k ověření dat, jak se dozvíte později v této sérii.

1. ClaimsSchema V části souboru ContosoCustomPolicy.XML deklarujte deklarace identity domény a domainStatus pomocí následujícího kódu:

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

2. ClaimsTransformations Vyhledejte oddíl 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 deklarací identity lookupDomain používá extrahovaná doména ke kontrole, jestli je platná, vyhledáním v předdefinovaných doménách a přiřazením platné deklarace identity domainStatus .

3. Pomocí následujícího kódu přidejte technický profil ve stejném zprostředkovateli deklarací identity 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í deklarací identity, který provádí transformace deklarací identity 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 technického profilu UserInformationCollector jsme přidali technický profil ověření. 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 maurice@fourthcoffee.com , že není platný e-mail, zobrazí se chyba podobná té, která je zobrazená na následujícím snímku obrazovky. K úspěšnému spuštění vlastní zásady a přijetí tokenu JWT musíte použít platnou e-mailovou adresu.

   

Další kroky

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

• Informace o podmíněném povolení nebo zakázání technických profilů ve vlastních zásadách Azure AD B2C