Udostępnij za pośrednictwem


Weryfikowanie danych wejściowych użytkownika przy użyciu niestandardowych zasad usługi Azure Active Directory B2C

Niestandardowe zasady usługi Azure Active Directory B2C (Azure AD B2C) nie tylko umożliwiają wprowadzanie danych wejściowych użytkownika jako obowiązkowe, ale także ich weryfikowanie. Możesz oznaczyć dane wejściowe użytkownika jako wymagane, takie jak <DisplayClaim ClaimTypeReferenceId="givenName" Required="true"/>, ale nie oznacza to, że użytkownicy będą wprowadzać prawidłowe dane. Usługa Azure AD B2C oferuje różne sposoby weryfikowania danych wejściowych użytkownika. Z tego artykułu dowiesz się, jak napisać zasady niestandardowe, które zbierają dane wejściowe użytkownika i weryfikują je przy użyciu następujących metod:

  • Ogranicz dane wprowadzane przez użytkownika, podając listę opcji do wyboru. W tym podejściu użyto wartości wyliczonych, które są dodawane podczas deklarowania oświadczenia.

  • Zdefiniuj wzorzec, który musi być zgodny z danymi wejściowymi użytkownika. To podejście używa wyrażeń regularnych, które są dodawane podczas deklarowania oświadczenia.

  • Zdefiniuj zestaw reguł i wymagaj, aby dane wejściowe użytkownika przestrzegały co najmniej jednej reguły. To podejście korzysta z predykatów, które są dodawane podczas deklarowania oświadczenia.

  • Użyj specjalnego typu oświadczenia reenterPassword , aby sprawdzić, czy użytkownik poprawnie wprowadził swoje hasło podczas zbierania danych wejściowych użytkownika.

  • Skonfiguruj profil techniczny weryfikacji , który definiuje złożone reguły biznesowe, które nie są możliwe do zdefiniowania na poziomie deklaracji oświadczenia. Na przykład zbierasz dane wejściowe użytkownika, które należy zweryfikować względem wartości lub zestawu wartości w innym oświadczeniu.

Wymagania wstępne

Uwaga

Ten artykuł jest częścią serii przewodników Jak tworzyć i uruchamiać własne polityki niestandardowe w usłudze Azure Active Directory B2C . Zalecamy rozpoczęcie tej serii od pierwszego artykułu.

Krok 1. Weryfikowanie danych wejściowych użytkownika przez ograniczenie opcji danych wejściowych użytkownika

Jeśli znasz wszystkie możliwe wartości, które użytkownik może wprowadzić dla danego danych wejściowych, możesz podać skończony zestaw wartości, z których użytkownik musi wybrać. W tym celu można użyć opcji DropdownSingleSelect, CheckboxMultiSelect i RadioSingleSelectUserInputType . W tym artykule użyjesz typu danych wejściowych RadioSingleSelect :

  1. W programie VS Code otwórz plik ContosoCustomPolicy.XML.

  2. W elemencie ClaimsSchema pliku ContosoCustomPolicy.XML zadeklaruj następujący typ roszczenia:

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

    Zadeklarowaliśmy roszczenie accountType. Gdy wartość oświadczenia jest zbierana od użytkownika, użytkownik musi wybrać konto pracownika Firmy Contoso dla wartości służbowej lub osobiste konto dla wartości osobistej.

    Usługa Azure AD B2C umożliwia również dostosowanie zasad do różnych języków i zapewnia ograniczenia typu konta dla wielu języków. Aby uzyskać więcej informacji, zapoznaj się z artykułem Lokalizowanie interfejsuużytkownika w artykule Dodawanie atrybutów użytkownika.

  3. Znajdź techniczny profil Id="UserInformationCollector", dodaj oświadczenie accountType jako widoczne oświadczenie, używając następującego kodu:

        <DisplayClaim ClaimTypeReferenceId="accountType" Required="true"/>
    
  4. W profilu technicznym z elementem Id="UserInformationCollector"dodaj oświadczenie accountType jako oświadczenie wyjściowe, używając następującego kodu:

        <OutputClaim ClaimTypeReferenceId="accountType"/>
    
  5. Aby uwzględnić oświadczenie typu konta w tokenie dostępu, znajdź RelyingParty element, dodaj oświadczenie accountType jako oświadczenie tokenu przy użyciu następującego kodu:

        <OutputClaim ClaimTypeReferenceId="accountType" />
    

Krok 2. Weryfikowanie danych wejściowych użytkownika przy użyciu wyrażeń regularnych

Jeśli nie jest możliwe wcześniejsze poznanie wszystkich możliwych wartości wejściowych użytkownika, możesz zezwolić użytkownikowi na wprowadzanie danych samodzielnie. W takim przypadku można użyć wyrażeń regularnych (regex) lub wzorca , aby określić sposób formatowania danych wejściowych użytkownika. Na przykład adres e-mail musi mieć symbol at (@) i kropkę (.) w tekście.

Podczas deklarowania oświadczenia zasady niestandardowe umożliwiają zdefiniowanie wyrażenia regularnego, z którym dane wejściowe użytkownika muszą być zgodne. Opcjonalnie możesz podać komunikat, który jest wyświetlany użytkownikowi, jeśli ich dane wejściowe nie są zgodne z wyrażeniem.

  1. Zlokalizuj element ClaimsSchema i zadeklaruj roszczenie e-mail za pomocą następującego kodu:

        <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. Znajdź techniczny profil Id="UserInformationCollector", dodaj roszczenie e-mail jako roszczenie wyświetlane przy użyciu następującego kodu:

        <DisplayClaim ClaimTypeReferenceId="email" Required="true"/>
    
  3. W profilu technicznym z elementem Id="UserInformationCollector"dodaj oświadczenie e-mail jako oświadczenie wyjściowe przy użyciu następującego kodu:

        <OutputClaim ClaimTypeReferenceId="email"/>
    
  4. Znajdź element RelyingParty, dodaj email jako żądanie tokenu, używając następującego kodu:

        <OutputClaim ClaimTypeReferenceId="email" />
    

Krok 3. Weryfikowanie danych wejściowych użytkownika przy użyciu predykatów

Użyłeś wyrażeń regularnych do sprawdzania poprawności danych wejściowych użytkownika. Jednak wyrażenia regularne mają jedną słabość: komunikat o błędzie jest wyświetlany, dopóki nie poprawisz danych wejściowych, ale nie pokazuje, które konkretne wymagania nie są spełnione.

Walidacje predykatów umożliwiają rozwiązanie tego problemu, umożliwiając zdefiniowanie zestawu reguł (predykatów) i niezależnego komunikatu o błędzie dla każdej reguły. W zasadach niestandardowych predykat ma wbudowaną metodę, która definiuje kontrole, które chcesz wykonać. Na przykład można użyć metody predykatu IsLengthRange , aby sprawdzić, czy hasło użytkownika mieści się w zakresie minimalnych i maksymalnych parametrów (wartości).

Podczas gdy predykaty określają walidację do sprawdzenia w stosunku do typu roszczenia, PredicateValidations grupuje zestaw predykatów, aby stworzyć walidację danych wejściowych użytkownika, którą można zastosować do typu roszczenia. Na przykład tworzysz grupę predykatów weryfikacji, która weryfikuje różne typy dozwolonych znaków dla hasła. Zarówno predykaty, jak i elementy PredicateValidations są elementami podrzędnymi BuildingBlocks.

  1. Znajdź element ClaimsSchema, a następnie zadeklaruj roszczenie hasła przy użyciu następującego kodu:

        <ClaimType Id="password">
          <DisplayName>Password</DisplayName>
          <DataType>string</DataType>
          <AdminHelpText>Enter password</AdminHelpText>
          <UserHelpText>Enter password</UserHelpText>
          <UserInputType>Password</UserInputType>
        </ClaimType>
    
  2. Dodaj element Predicates jako element podrzędny sekcji BuildingBlocks przy użyciu następującego kodu. Należy dodać element Predicates poniżej elementu ClaimsSchema.

        <Predicates>
    
        </Predicates>
    
  3. Wewnątrz elementu zdefiniuj Predicates predykaty przy użyciu następującego kodu:

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

    Zdefiniowaliśmy kilka reguł, które po połączeniu opisały akceptowalne hasło. Następnie możesz grupować predykaty, aby utworzyć zestaw polityk haseł, których można użyć w twojej polityce.

  4. Dodaj element PredicateValidations jako element podrzędny sekcji BuildingBlocks, używając następującego kodu. Należy dodać element PredicateValidations jako podrzędny do sekcji BuildingBlocks, ale umieścić go poniżej elementu Predicates.

        <PredicateValidations>
    
        </PredicateValidations>
    
  5. Wewnątrz elementu PredicateValidations, zdefiniuj PredicateValidations przy użyciu następującego kodu:

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

    Zdefiniowaliśmy trzy predykaty walidacji, StrongPassword, CustomPassword i SimplePassword. W zależności od właściwości hasła, które chcesz, aby wprowadzali użytkownicy, możesz użyć dowolnej z walidacji predykatywnej. W tym artykule użyjemy silnego hasła.

  6. Znajdź deklarację typu oświadczenia hasła i dodaj weryfikację predykatu StrongPassword tuż po deklaracji elementu UserInputType, która zawiera, używając następującego kodu:

        <PredicateValidationReference Id="StrongPassword" />
    
  7. Zlokalizuj profil techniczny Id="UserInformationCollector", dodaj oświadczenie hasła jako wyświetlane przy użyciu następującego kodu:

        <DisplayClaim ClaimTypeReferenceId="password" Required="true"/>
    
  8. W profilu technicznym Id="UserInformationCollector" dodaj żądanie hasła jako żądanie wyjściowe przy użyciu następującego kodu:

        <OutputClaim ClaimTypeReferenceId="password"/>
    

Uwaga

Ze względów bezpieczeństwa nie dodamy hasła użytkowników jako roszczenia w tokenie wygenerowanym przez Twoją politykę. Dlatego nie dodajemy oświadczenia hasła do elementu strony zaufanej.

Krok 4. Weryfikowanie hasła i potwierdzanie hasła

Aby potwierdzić, że użytkownik zapamiętuje wprowadzone hasło, może wymagać od użytkowników wprowadzenia hasła dwa razy. W takim przypadku należy sprawdzić, czy wartości dwóch wpisów są zgodne. Zasady niestandardowe umożliwiają łatwe osiągnięcie tego wymagania. Typy oświadczeń hasła i reenterPassword są uważane za specjalne, więc gdy są używane do zbierania danych wejściowych użytkownika, interfejs użytkownika sprawdza, czy użytkownik poprawnie wprowadził swoje hasło.

Aby ponownie wprowadzić hasło w zasadach niestandardowych, wykonaj następujące kroki:

  1. ClaimsSchema W sekcji pliku ContosoCustomPolicy.XML zadeklaruj atrybut reenterPassword tuż po atrybucie password przy użyciu następującego kodu:

        <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. Aby zebrać dane wejściowe potwierdzenia hasła od użytkownika, znajdź UserInformationCollector profil techniczny samoaserowany, dodaj żądanie reenterPassword jako oświadczenie do wyświetlenia przy użyciu następującego kodu:

        <DisplayClaim ClaimTypeReferenceId="reenterPassword" Required="true"/>
    
  3. ContosoCustomPolicy.XML W pliku znajdź UserInformationCollector samonadeklarowany profil techniczny, dodaj atrybut reenterPassword jako atrybut wyjściowy przy użyciu następującego kodu:

        <OutputClaim ClaimTypeReferenceId="reenterPassword"/>
    

Krok 5 - Prześlij plik niestandardowej polityki

W tym momencie utworzono zasady w celu rozwiązania pierwszych trzech podejść do weryfikacji danych wejściowych użytkownika.

Wykonaj kroki opisane w temacie Przekazywanie pliku zasad niestandardowych. Jeśli przesyłasz plik o tej samej nazwie co plik już znajdujący się w portalu, upewnij się, że wybrano opcję Zastąp zasady niestandardowe, jeśli już one istnieją.

Krok 6 - Przetestuj zasady niestandardowe

  1. W obszarze Zasady niestandardowe wybierz pozycję B2C_1A_CONTOSOCUSTOMPOLICY.

  2. Na stronie przeglądu zasad niestandardowych, w obszarze Wybierz aplikację, wybierz aplikację webową, taką jak webapp1, którą wcześniej zarejestrowałeś. Upewnij się, że wartość Wybierz adres URL odpowiedzi jest ustawiona na https://jwt.ms.

  3. Wybierz przycisk Uruchom teraz .

  4. Wprowadź imię i nazwisko.

  5. Wybierz pozycję Typ konta.

  6. W polu Adres e-mail wprowadź wartość adresu e-mail, która nie jest dobrze sformatowana, na przykład maurice@contoso.

  7. W polu Hasło wprowadź wartość hasła, która nie przestrzega wszystkich cech silnego hasła zgodnie z ustawionym ustawieniem.

  8. Wybierz przycisk Kontynuuj . Zostanie wyświetlony ekran podobny do przedstawionego poniżej:

    zrzut ekranu przedstawiający weryfikowanie danych wejściowych użytkownika.

    Zanim przejdziesz dalej, musisz poprawić swoje dane wejściowe.

  9. Wprowadź poprawne wartości sugerowane przez komunikaty o błędach, a następnie ponownie wybierz przycisk Kontynuuj . Po zakończeniu wykonywania polityki nastąpi przekierowanie do https://jwt.ms, i zostanie wyświetlony zdekodowany JWT. Token wygląda podobnie do następującego fragmentu kodu 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. Weryfikowanie danych wejściowych użytkownika przy użyciu profilów technicznych weryfikacji

Techniki walidacji, które zostały użyte w kroku 1, krok 2 i krok 3, nie mają zastosowania w przypadku wszystkich scenariuszy. Jeśli reguły biznesowe są zbyt złożone, aby można je było zdefiniować na poziomie deklaracji oświadczenia, można skonfigurować weryfikację techniczną, a następnie wywołać je z profilu technicznegoSelf-Asserted.

Uwaga

Tylko samodzielnie zadeklarowane profile techniczne mogą używać profilów technicznych do weryfikacji. Dowiedz się więcej o profilu technicznym weryfikacji

Omówienie scenariusza

Wymagamy, aby jeśli typ konta użytkownika to Konto pracownika firmy Contoso, musimy upewnić się, że domena poczty e-mail jest oparta na zestawie wstępnie zdefiniowanych domen. Te domeny są contoso.com, fabrikam.com i woodgrove.com. W przeciwnym razie pokazujemy użytkownikowi błąd, dopóki nie użyje prawidłowego konta pracownika firmy Contoso lub przełączy się na konto osobiste.

Wykonaj poniższe kroki, aby dowiedzieć się, jak zweryfikować dane wejściowe użytkownika przy użyciu profilów technicznych weryfikacji. Używasz profilu technicznego weryfikacji typu przekształcania oświadczeń, ale możesz również wywołać usługę interfejsu API REST, aby zweryfikować dane w dalszej części tej serii.

  1. W sekcji ClaimsSchema pliku ContosoCustomPolicy.XML zadeklaruj oświadczenia domain i domainStatus przy użyciu następującego kodu:

        <ClaimType Id="domain">
          <DataType>string</DataType>
        </ClaimType>
    
        <ClaimType Id="domainStatus">
          <DataType>string</DataType>
        </ClaimType>
    
  2. Znajdź sekcję ClaimsTransformations i skonfiguruj transformacje roszczeń za pomocą następującego kodu:

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

    Przekształcenie GetDomainFromEmail wyodrębnia domenę z adresu e-mail przy użyciu metody ParseDomain i przechowuje ją w twierdzeniu domain. Przekształcenie oświadczeń LookupDomain używa wyodrębnionej domeny, aby sprawdzić, czy jest ona prawidłowa, wyszukując ją we wstępnie zdefiniowanych domenach i przypisując prawidłowe do oświadczenia domainStatus.

  3. Użyj następującego kodu, aby dodać profil techniczny do tego samego dostawcy oświadczeń co profil techniczny oznaczony jako 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>
    

    Zadeklarowaliśmy profil techniczny przekształcania oświadczeń, który wykonuje przekształcenia GetDomainFromEmail i LookupDomain.

  4. Zlokalizuj profil techniczny z elementem Id=UserInformationCollector, oraz ValidationTechnicalProfile tuż po elemencie OutputClaims, używając następującego kodu.

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

    Do profilu technicznego UserInformationCollector dodaliśmy profil weryfikacyjny. Profil techniczny jest pomijany tylko wtedy, gdy wartość accountType nie jest równa praca. Jeśli profil techniczny się uruchomi, a domena poczty e-mail nie jest prawidłowa, błąd zostanie wygenerowany.

  5. Znajdź profil techniczny z Id=UserInformationCollector i dodaj następujący kod wewnątrz tagu metadata.

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

    Przygotowaliśmy błąd niestandardowy w przypadku, gdy użytkownik nie używa prawidłowego adresu e-mail.

  6. Postępuj zgodnie z instrukcjami w Przekazywanie pliku zasad niestandardowych, aby załadować swój plik zasad.

  7. Postępuj zgodnie z instrukcjami w kroku 6, aby przetestować Twoją niestandardową politykę.

    1. W polu Typ konta wybierz pozycję Konto pracownika firmy Contoso
    2. W polu Adres e-mail wprowadź nieprawidłowy adres e-mail, taki jak maurice@fourthcoffee.com.
    3. Wprowadź pozostałe szczegóły zgodnie z wymaganiami i wybierz pozycję Kontynuuj

    Ponieważ maurice@fourthcoffee.com nie jest to prawidłowa wiadomość e-mail, zobaczysz błąd podobny do tego, który pokazano na poniższym zrzucie ekranu. Aby pomyślnie uruchomić zasady niestandardowe i otrzymać JWT, musisz użyć prawidłowego adresu e-mail.

    zrzut ekranu przedstawiający błąd spowodowany nieprawidłowym adresem e-mail.