Teilen über

Überprüfen von Benutzereingaben mithilfe einer benutzerdefinierten Azure Active Directory B2C-Richtlinie

  • Artikel

Mit einer benutzerdefinierten Azure Active Directory B2C-Richtlinie (Azure AD B2C) können Sie Benutzereingaben nicht nur notwendig machen, sondern sie auch überprüfen. Sie können Benutzereingaben als erforderlich markieren, z. B. <DisplayClaim ClaimTypeReferenceId="givenName" Required="true"/>. Dies bedeutet jedoch nicht, dass die Benutzer*innen gültige Daten eingeben. Azure AD B2C bietet verschiedene Möglichkeiten zum Überprüfen einer Benutzereingabe. In diesem Artikel erfahren Sie, wie Sie eine benutzerdefinierte Richtlinie schreiben, die die Benutzereingaben erfasst und unter Verwendung der folgenden Ansätze überprüft:

  • Schränken Sie die Daten ein, die Benutzer*innen eingeben können, indem Sie eine Liste von Optionen zur Auswahl stellen. Bei diesem Ansatz werden aufgezählte Werte verwendet, die Sie hinzufügen, wenn Sie einen Anspruch deklarieren.

  • Definieren Sie ein Muster, mit dem eine Benutzereingabe übereinstimmen muss. Dieser Ansatz verwendet reguläre Ausdrücke, die Sie hinzufügen, wenn Sie einen Anspruch deklarieren.

  • Definieren Sie einen Satz von Regeln, und verlangen Sie, dass Benutzereingaben mindestens einer dieser Regeln entsprechen. Bei diesem Ansatz werden Prädikate verwendet, die Sie hinzufügen, wenn Sie einen Anspruch deklarieren.

  • Verwenden Sie den speziellen Anspruchstyp reenterPassword, um zu überprüfen, ob Benutzer*innen ihr Kennwort während der Benutzereingabesammlung ordnungsgemäß eingegeben haben.

  • Konfigurieren Sie ein technisches Validierungsprofil, das komplexe Geschäftsregeln definiert, die auf Anspruchsdeklarationsebene nicht definiert werden können. Beispielsweise erfassen Sie eine Benutzereingabe, die anhand eines Werts oder einer Reihe von Werten in einem anderen Anspruch überprüft werden muss.

Voraussetzungen

Hinweis

Dieser Artikel ist Teil der Schrittanleitungsreihe „Erstellen und Ausführen Ihrer eigenen benutzerdefinierten Richtlinien in Azure Active Directory B2C“. Wir empfehlen Ihnen, diese Reihe mit dem ersten Artikel zu beginnen.

Schritt 1: Überprüfen der Benutzereingabe durch Einschränkung der Benutzereingabeoptionen

Wenn Sie alle möglichen Werte kennen, die Benutzer*innen für eine bestimmte Eingabe eingeben können, können Sie einen endlichen Satz von Werten angeben, aus dem die Benutzer*innen auswählen müssen. Zu diesem Zweck können Sie DropdownSinglSelect, CheckboxMultiSelect und RadioSingleSelect als UserInputType verwenden. In diesem Artikel verwenden Sie den Eingabetyp RadioSingleSelect:

  1. Öffnen Sie in VS Code die Datei ContosoCustomPolicy.XML.

  2. Deklarieren Sie im ClaimsSchema-Element der ContosoCustomPolicy.XML-Datei den folgenden Anspruchstyp:

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

    Wir haben den Anspruch accountType deklariert. Wenn der Wert des Anspruchs von den Benutzer*innen erfasst wird, müssen sie entweder Contoso Employee Account als Option für den Wert work oder Personal Account als Option für den Wert personal auswählen.

    Azure AD B2C ermöglicht es Ihnen auch, eine Richtlinie an verschiedene Sprachen anzupassen und die Kontotypeinschränkungen für mehrere Sprachen bereitzustellen. Weitere Informationen finden Sie unter Lokalisieren der Benutzeroberfläche im Artikel Hinzufügen von Benutzerattributen.

  3. Suchen Sie das technische Profil mit Id="UserInformationCollector", und fügen Sie den Anspruch accountType als anzuzeigenden Anspruch hinzu, indem Sie den folgenden Code verwenden:

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

  4. Fügen Sie im technischen Profil mit Id="UserInformationCollector" unter Verwendung des folgenden Codes den Anspruch accountType als Ausgabeanspruch hinzu:

        <OutputClaim ClaimTypeReferenceId="accountType"/>

  5. Um den Kontotypanspruch in das Zugriffstoken einzuschließen, suchen Sie das RelyingParty-Element, und fügen Sie mit folgendem Code den Anspruch accountType als Tokenanspruch hinzu:

        <OutputClaim ClaimTypeReferenceId="accountType" />

Schritt 2: Überprüfen von Benutzereingaben mithilfe von regulären Ausdrücken

Wenn es nicht möglich ist, alle möglichen Benutzereingabewerte im Voraus zu kennen, erlauben Sie den Benutzer*innen, die Daten selbst einzugeben. In diesem Fall können Sie reguläre Ausdrücke (RegEx) oder Muster verwenden, um vorzuschreiben, welches Format eine Benutzereingabe haben muss. Beispielsweise muss eine E-Mail das Symbol @ und einen Punkt (.) im Text enthalten.

Wenn Sie einen Anspruch deklarieren, können Sie mit einer benutzerdefinierten Richtlinie einen RegEx definieren, dem die Benutzereingabe entsprechen muss. Sie können optional eine Meldung bereitstellen, die angezeigt wird, wenn die Benutzereingabe nicht mit dem Ausdruck übereinstimmt.

  1. Suchen Sie das ClaimsSchema-Element, und deklarieren Sie den Anspruch email mithilfe des folgenden Codes:

        <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. Suchen Sie das technische Profil mit Id="UserInformationCollector", und fügen Sie den Anspruch email als anzuzeigenden Anspruch hinzu, indem Sie den folgenden Code verwenden:

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

  3. Fügen Sie im technischen Profil mit Id="UserInformationCollector" unter Verwendung des folgenden Codes den Anspruch email als Ausgabeanspruch hinzu:

        <OutputClaim ClaimTypeReferenceId="email"/>

  4. Suchen Sie das RelyingParty-Element, und fügen Sie mit folgendem Code den Anspruchemail als Tokenanspruch hinzu:

        <OutputClaim ClaimTypeReferenceId="email" />

Schritt 3: Überprüfen von Benutzereingaben mithilfe von Prädikaten

Sie haben einen regulären Ausdruck verwendet, um Benutzereingaben zu überprüfen. Reguläre Ausdrücke weisen jedoch eine Schwäche auf: Die Fehlermeldung wird so lange angezeigt, bis Sie die Eingabe korrigieren, doch wird die spezifische Anforderung, der die Eingabe nicht entspricht, nicht angezeigt.

Mit Prädikatvalidierungen können Sie dieses Problem beheben, indem Sie einen Satz von Regeln (Prädikaten) und eine unabhängige Fehlermeldung für jede Regel definieren. In benutzerdefinierten Richtlinien verfügt ein Prädikat über eine integrierte Methode, die die durchzuführenden Überprüfungen definiert. Sie können beispielsweise mit der IsLengthRange-Prädikatmethode überprüfen, ob ein Benutzerkennwort innerhalb des angegebenen Bereichs von minimalen und maximalen Parametern (Werten) liegt.

Während mit dem Predicates-Element die Überprüfung anhand eines Anspruchstyps definiert wird, werden mit dem PredicateValidations-Element mehrere Prädikate zu einer Benutzereingabe-Überprüfung gruppiert, die auf einen Anspruchstyp angewendet werden kann. Beispielsweise erstellen Sie eine Prädikatgruppe zur Validierung, die verschiedene Typen von zulässigen Zeichen für ein Kennwort überprüft. Sowohl Predicates- als auch PredicateValidations-Elemente sind untergeordnete Elemente des Abschnitts BuildingBlocks Ihrer Richtliniendatei.

  1. Suchen Sie das ClaimsSchema-Element, und deklarieren Sie den Anspruch password mithilfe des folgenden Codes:

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

  2. Fügen Sie mit folgendem Code ein Predicates-Element als untergeordnetes Element im Abschnitt BuildingBlocks hinzu. Sie fügen das Predicates-Element unter dem ClaimsSchema-Element hinzu:

        <Predicates>

    </Predicates>

  3. Definieren Sie im Predicates-Element mithilfe des folgenden Codes Prädikate:

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

    Wir haben mehrere Regeln definiert, die zusammengenommen ein akzeptables Kennwort beschreiben. Als Nächstes können Sie Prädikate gruppieren, um einen Satz von Kennwortrichtlinien zu bilden, den Sie in Ihrer Richtlinie verwenden können.

  4. Fügen Sie mit folgendem Code ein PredicateValidations-Element als untergeordnetes Element im Abschnitt BuildingBlocks hinzu. Sie fügen das PredicateValidations-Element als untergeordnetes Element des Abschnitts BuildingBlocks hinzu, allerdings unter dem Predicates-Element:

        <PredicateValidations>

    </PredicateValidations>

  5. Definieren Sie im PredicateValidations-Element mithilfe des folgenden Codes PredicateValidations-Elemente:

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

    Wir haben drei definierte PredicateValidations-Elemente: StrongPassword, CustomPassword und SimplePassword. Abhängig von den Merkmalen des Kennworts, das die Benutzer*innen eingeben sollen, können Sie eines dieser PredicateValidations-Elemente verwenden. In diesem Artikel verwenden wir ein sicheres Kennwort.

  6. Suchen Sie die Deklaration des Anspruchstyps password, und fügen Sie mit folgendem Code das PredicateValidations-Element StrongPassword direkt nach der darin enthaltenen UserInputType-Elementdeklaration hinzu:

        <PredicateValidationReference Id="StrongPassword" />

  7. Suchen Sie das technische Profil mit Id="UserInformationCollector", fügen Sie den Anspruch password als anzuzeigenden Anspruch hinzu, indem Sie den folgenden Code verwenden:

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

  8. Fügen Sie im technischen Profil mit Id="UserInformationCollector" unter Verwendung des folgenden Codes den Anspruch password als Ausgabeanspruch hinzu:

        <OutputClaim ClaimTypeReferenceId="password"/>

Hinweis

Aus Sicherheitsgründen fügen wir das Benutzerkennwort nicht als Anspruch in dem von Ihrer Richtlinie generierten Token hinzu. Wir fügen daher den Anspruch „password“ nicht dem Element der vertrauenden Seite hinzu.

Schritt 4: Überprüfen und Bestätigen des Kennworts

Sie können Benutzer*innen auffordern, ihr Kennwort zweimal einzugeben, um zu bestätigen, dass sich die Benutzer*innen an das eingegebene Kennwort erinnern. In diesem Fall müssen Sie überprüfen, ob die Werte der beiden Eingaben übereinstimmen. Mit einer benutzerdefinierten Richtlinie lässt sich diese Anforderung einfach erfüllen. Die Anspruchstypen password und reenterPassword haben eine besondere Bedeutung. Wenn sie zum Sammeln von Benutzereingaben verwendet werden, überprüft die Benutzeroberfläche, ob die Benutzer*innen ihr Kennwort korrekt eingegeben haben.

Führen Sie die folgenden Schritte aus, um die erneute Kennworteingabe in Ihrer benutzerdefinierten Richtlinie zu überprüfen:

  1. Deklarieren Sie im Abschnitt ClaimsSchema Ihrer ContosoCustomPolicy.XML-Datei den Anspruch reenterPassword direkt nach dem Anspruch password, indem Sie den folgenden Code verwenden:

        <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. Um Benutzereingaben zur Kennwortbestätigung zu sammeln, suchen Sie das selbstbestätigte technische Profil UserInformationCollector, und fügen Sie mit folgendem Code den Anspruch reenterPassword als anzuzeigenden Anspruch hinzu:

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

  3. Suchen Sie in Ihrer ContosoCustomPolicy.XML-Datei das selbstbestätigte technische Profil UserInformationCollector, und fügen Sie mit folgendem Code den Anspruch reenterPassword als Ausgabeanspruch hinzu:

        <OutputClaim ClaimTypeReferenceId="reenterPassword"/>

Schritt 5: Hochladen der benutzerdefinierten Richtliniendatei

Bislang haben Sie Ihre Richtlinie so aufgebaut, dass sie die ersten drei Ansätze zur Überprüfung von Benutzereingaben berücksichtigt.

Führen Sie die Schritte unter Hochladen der benutzerdefinierten Richtliniendatei aus. Wenn Sie eine Datei hochladen, die denselben Namen wie die bereits im Portal vorhandene Datei hat, stellen Sie sicher, dass Sie Benutzerdefinierte Richtlinie überschreiben, sofern bereits vorhanden auswählen.

Schritt 6: Testen der benutzerdefinierten Richtlinie

  1. Wählen Sie unter Benutzerdefinierte Richtlinien die Richtlinie B2C_1A_CONTOSOCUSTOMPOLICY aus.

  2. Wählen Sie auf der Übersichtsseite der benutzerdefinierten Richtlinie unter Anwendung auswählen die Webanwendung aus, die Sie zuvor registriert haben, z. B. webapp1. Stellen Sie sicher, dass der Wert von Antwort-URL auswählen auf https://jwt.ms festgelegt ist.

  3. Wählen Sie die Schaltfläche Jetzt ausführen aus.

  4. Geben Sie für Given Name einen Vornamen und für Surname einen Nachnamen ein.

  5. Wählen Sie Account Type aus.

  6. Geben Sie für Email Address einen E-Mail-Wert ein, der kein ordnungsgemäßes Format hat, z. B. maurice@contoso.

  7. Geben Sie unter Password einen Kennwortwert ein, der nicht alle festgelegten Merkmale eines sicheren Kennworts erfüllt.

  8. Wählen Sie die Schaltfläche Continue aus. Es wird ein Bildschirm angezeigt, der dem unten abgebildeten ähnelt:

    screenshot of validating user inputs.

    Sie müssen Ihre Eingaben korrigieren, bevor Sie fortfahren.

  9. Geben Sie die korrekten Werte ein, wie in den Fehlermeldungen vorgeschlagen, und wählen Sie anschließend erneut die Schaltfläche Continue aus. Nachdem die Ausführung der Richtlinie abgeschlossen ist, werden Sie zu https://jwt.ms weitergeleitet, und es wird ein decodiertes JWT-Token angezeigt. Das Token ähnelt dem folgenden JWT-Tokenausschnitt:

    {
      "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]

Schritt 7: Überprüfen von Benutzereingaben mithilfe von technischen Validierungsprofilen

Die Validierungstechniken, die wir in Schritt 1, Schritt 2 und Schritt 3 verwendet haben, eignen sich nicht für alle Szenarien. Wenn Ihre Geschäftsregeln zu komplex sind, um auf Anspruchsdeklarationsebene definiert zu werden, können Sie eine technische Validierung konfigurieren und diese dann aus einem selbstbestätigten technischen Profil aufrufen.

Hinweis

Nur selbstbestätigte technische Profile können technische Validierungsprofile verwenden. Erfahren Sie mehr über technische Validierungsprofile.

Übersicht über das Szenario

Wenn Benutzer*innen als Account Type die Option Contoso Employee Account auswählen, müssen wir gemäß unserer Richtlinie sicherstellen, dass die E-Mail-Domäne auf einer Reihe vordefinierter Domänen basiert. Diese Domänen lauten contoso.com, fabrikam.com und woodgrove.com. Andernfalls wird so lange ein Fehler angezeigt, bis ein gültiger Wert für Contoso Employee Account verwendet oder zu Personal Account gewechselt wird.

Anhand der folgenden Schritte erfahren Sie, wie Sie Benutzereingaben mit technischen Validierungsprofilen überprüfen können. Sie verwenden ein technisches Validierungsprofil zur Überprüfung des Anspruchstransformationstyps, aber wie Sie später in dieser Reihe erfahren werden, können Sie auch einen REST-API-Dienst aufrufen, um die Daten zu überprüfen.

  1. Deklarieren Sie im Abschnitt ClaimsSchema Ihrer ContosoCustomPolicy.XML-Datei die Ansprüche domain und domainStatus, indem Sie den folgenden Code verwenden:

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

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

  2. Suchen Sie den Abschnitt ClaimsTransformations, und konfigurieren Sie Anspruchstransformationen mithilfe des folgenden Codes:

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

    Die Anspruchstransformation GetDomainFromEmail extrahiert mithilfe der ParseDomain-Methode eine Domäne aus der E-Mail-Adresse und speichert sie im Anspruch domain. Die Anspruchstransformation LookupDomain prüft, ob die extrahierte Domäne gültig ist, indem sie die Domäne in den vordefinierten Domänen nachschlägt und bei erfolgreicher Suche dem Anspruch domainStatus den Wert valid zuweist.

  3. Verwenden Sie den folgenden Code, um ein technisches Profil dem gleichen Anspruchsanbieter wie das technische Profil mit Id=UserInformationCollector hinzuzufügen:

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

    Wir haben das technische Profil für die Anspruchstransformation deklariert, das die Anspruchstransformationen GetDomainFromEmail und LookupDomain ausführt.

  4. Suchen Sie das technische Profil mit Id=UserInformationCollectorund einem ValidationTechnicalProfile-Element direkt nach dem OutputClaims-Element, indem Sie den folgenden Code verwenden:

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

    Wir haben dem selbstbestätigten technischen Profil userInformationCollector ein technisches Validierungsprofil hinzugefügt. Das technische Profil wird nur übersprungen, wenn der AccountType-Wert nicht gleich work ist. Wenn das technische Profil ausgeführt wird und die E-Mail-Domäne ungültig ist, wird ein Fehler ausgelöst.

  5. Suchen Sie das technische Profil mit Id=UserInformationCollector, und fügen Sie den folgenden Code innerhalb des metadata-Tags hinzu.

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

    Wir haben eine benutzerdefinierte Fehlermeldung für den Fall eingerichtet, dass Benutzer*innen keine gültige E-Mail-Adresse angeben.

  6. Führen Sie die Schritte unter Hochladen einer benutzerdefinierten Richtliniendatei aus.

  7. Befolgen Sie die Anweisungen in Schritt 6, um Ihre benutzerdefinierte Richtlinie zu testen:

    1. Wählen Sie unter Account Type die Option Contoso Employee Account aus.
    2. Geben Sie unter Email Address eine ungültige E-Mail-Adresse ein, z. B. maurice@fourthcoffee.com.
    3. Geben Sie die restlichen benötigten Details ein, und wählen Sie anschließend Continue aus.

    Da maurice@fourthcoffee.com keine gültige E-Mail-Adresse ist, wird ein Fehler ähnlich wie im folgenden Screenshot angezeigt. Sie müssen eine gültige E-Mail-Adresse verwenden, um die benutzerdefinierte Richtlinie erfolgreich auszuführen und ein JWT-Token zu erhalten.

    screenshot of error due to invalid email address.

Nächste Schritte