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

Von Bedeutung

Ab dem 1. Mai 2025 steht Azure AD B2C nicht mehr für neue Kunden zur Verfügung. Weitere Informationen finden Sie in unseren HÄUFIG gestellten Fragen.

Benutzerdefinierte Azure Active Directory B2C-Richtlinie (Azure AD B2C) ermöglicht es Ihnen nicht nur, Benutzereingaben obligatorisch zu machen, sondern sie auch zu überprüfen. Sie können Benutzereingaben als erforderlich markieren, z <DisplayClaim ClaimTypeReferenceId="givenName" Required="true"/>. B. dies bedeutet jedoch nicht, dass Ihre Benutzer 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 anhand der folgenden Ansätze überprüft:

Beschränken Sie die von einem Benutzer eingegebenen Daten, indem Sie eine Liste von Optionen angeben, aus der Sie auswählen können. Bei diesem Ansatz werden aufgezählte Werte verwendet, die Sie beim Deklarieren eines Anspruchs hinzufügen.
Definieren Sie ein Muster, mit dem eine Benutzereingabe übereinstimmen muss. Bei diesem Ansatz werden reguläre Ausdrücke verwendet, die Sie hinzufügen, wenn Sie einen Anspruch deklarieren.
Definieren Sie eine Reihe von Regeln, und erfordern Sie, dass eine Benutzereingabe mindestens einer der Regeln entspricht. 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 der Benutzer sein Kennwort während der Benutzereingabesammlung ordnungsgemäß erneut eingegeben hat.
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

Wenn Sie noch keins haben, erstellen Sie einen Azure AD B2C-Mandanten , der mit Ihrem Azure-Abonnement verknüpft ist.
Registrieren Sie eine Webanwendung.
Sie müssen Visual Studio Code (VS Code) auf Ihrem Computer installiert haben.
Führen Sie die Schritte unter Sammeln und Bearbeiten von Benutzereingaben mithilfe der benutzerdefinierten Azure AD B2C-Richtlinie aus. Dieser Artikel ist Teil von Create and run your own custom policies how-to guide series.

Hinweis

Dieser Artikel ist Teil der Anleitungsreihe "Erstellen und Ausführen eigener benutzerdefinierter Richtlinien" in Azure Active Directory B2C. Es wird empfohlen, diese Reihe aus dem ersten Artikel zu starten.

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

Wenn Sie alle möglichen Werte kennen, die ein Benutzer für eine bestimmte Eingabe eingeben kann, können Sie einen begrenzten Satz von Werten bereitstellen, aus denen ein Benutzer auswählen muss. Sie können "DropdownSingleSelect", "CheckboxMultiSelect" und "RadioSingleSelectUserInputType " zu diesem Zweck verwenden. In diesem Artikel verwenden Sie einen RadioSingleSelect-Eingabetyp :

Öffnen Sie in VS Code die Datei ContosoCustomPolicy.XML.
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 accountType-Anspruch deklariert. Wenn der Wert des Anspruchs vom Benutzer erfasst wird, muss der Benutzer entweder das Contoso Employee Account für den Wert arbeit oder das Persönliche Konto für den Wert persönlich auswählen.

Azure AD B2C ermöglicht es Ihnen auch, Ihre Richtlinie in verschiedene Sprachen aufzunehmen und die Kontotypeinschränkungen für mehrere Sprachen verfügbar zu machen. Weitere Informationen finden Sie im Artikel zum Lokalisieren der Benutzeroberfläche des Artikels "Benutzerattribute hinzufügen".
Suchen Sie das technische Profil mit Id="UserInformationCollector", und fügen Sie den Anspruch accountType als Sichtbarkeitsanspruch hinzu, indem Sie den folgenden Code verwenden:
```
    <DisplayClaim ClaimTypeReferenceId="accountType" Required="true"/>
```
Fügen Sie im technischen Profil mit Id="UserInformationCollector" unter Verwendung des folgenden Codes den Anspruch accountType als Ausgabeanspruch hinzu:
```
    <OutputClaim ClaimTypeReferenceId="accountType"/>
```
Um den Kontotypanspruch in das Zugriffstoken einzuschließen, suchen Sie das RelyingParty Element, fügen Sie den accountType-Anspruch als Tokenanspruch hinzu, indem Sie den folgenden Code verwenden:
```
    <OutputClaim ClaimTypeReferenceId="accountType" />
```

Schritt 2 : Überprüfen der Benutzereingabe mithilfe regulärer Ausdrücke

Wenn es nicht möglich ist, alle möglichen Benutzereingabewerte im Voraus zu kennen, können Sie dem Benutzer erlauben, die Daten selbst einzugeben. In diesem Fall können Sie reguläre Ausdrücke (regex) oder ein Muster verwenden, um festzulegen, wie eine Benutzereingabe formatiert werden muss. Eine E-Mail muss z. B. das @ -Symbol und einen Punkt (.) an einer beliebigen Stelle 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 Nachricht angeben, die dem Benutzer angezeigt wird, wenn die Eingabe nicht mit dem Ausdruck übereinstimmt.

Suchen Sie das ClaimsSchema Element, und deklarieren Sie den E-Mail-Anspruch 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>

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"/>
```
Fügen Sie im technischen Profil mit Id="UserInformationCollector" unter Verwendung des folgenden Codes den Anspruch email als Ausgabeanspruch hinzu:
```
    <OutputClaim ClaimTypeReferenceId="email"/>
```
Suchen Sie das RelyingParty Element, fügen Sie die E-Mail als Tokenanspruch hinzu, indem Sie den folgenden Code verwenden:
```
    <OutputClaim ClaimTypeReferenceId="email" />
```

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

Sie haben regex zum Überprüfen von Benutzereingaben verwendet. Regex weist jedoch eine Schwäche auf: Die Fehlermeldung wird angezeigt, bis Sie die Eingabe korrigieren, ohne Ihnen die spezifische Anforderung zu zeigen, die der Eingabe fehlt.

Mit Prädikatüberprüfungen können Sie dieses Problem beheben, indem Sie eine Reihe von Regeln (Prädikaten) und eine unabhängige Fehlermeldung für jede Regel definieren können. In benutzerdefinierten Richtlinien verfügt ein Prädikat über eine eingebaute Methode, die die Überprüfungen definiert, die Sie durchführen möchten. Sie können z. B. die IsLengthRange-Prädikatmethode verwenden, um zu überprüfen, ob sich ein Benutzerkennwort innerhalb des angegebenen Bereichs von minimalen und maximalen Parametern (Werten) befindet.

Während die Prädikate die Überprüfung auf einen Anspruchstyp definieren, gruppiert die PredicateValidations eine Reihe von Prädikaten, um eine Benutzereingabeüberprüfung zu bilden, die auf einen Anspruchstyp angewendet werden kann. Beispielsweise erstellen Sie eine Prädikatgruppe der Überprüfung, die verschiedene Typen zulässiger Zeichen für ein Kennwort überprüft. Sowohl Prädikate als auch PredicateValidations-Elemente sind untergeordnete Elemente des BuildingBlocks Abschnitts Ihrer Richtliniendatei.

Suchen Sie das ClaimsSchema Element, und deklarieren Sie den Kennwortanspruch 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>

Fügen Sie ein Predicates Element als untergeordnetes Element des BuildingBlocks Abschnitts mithilfe des folgenden Codes hinzu. Sie fügen das Predicates Element unter dem ClaimsSchema Element hinzu:
```
    <Predicates>

    </Predicates>
```

Definieren Sie prädikate innerhalb des Predicates Elements mithilfe des folgenden Codes:

  <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 zusammen ein akzeptables Kennwort beschreiben. Als Nächstes können Sie Prädikate gruppieren, um eine Reihe von Kennwortrichtlinien zu erstellen, die Sie in Ihrer Richtlinie verwenden können.

Fügen Sie ein PredicateValidations Element als untergeordnetes Element des BuildingBlocks Abschnitts mithilfe des folgenden Codes hinzu. Sie fügen das PredicateValidations Element als untergeordnetes Element des BuildingBlocks Abschnitts hinzu, aber unter dem Predicates Element:
```
    <PredicateValidations>

    </PredicateValidations>
```

Definieren Sie innerhalb des PredicateValidations-Elements PredicateValidations mit dem folgenden Code:

    <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 Prädikatüberprüfung, StrongPassword, CustomPassword und SimplePassword definiert. Abhängig von den Merkmalen des Kennworts, das Ihre Benutzer eingeben möchten, können Sie jede der Prädikatüberprüfungen verwenden. In diesem Artikel verwenden wir ein sicheres Kennwort.

Suchen Sie die password-Anspruchstyp-Deklaration, und fügen Sie die StrongPassword-Prädikat-Überprüfung direkt nach der darin enthaltenen UserInputType-Elementdeklaration hinzu, indem Sie den folgenden Code verwenden:
```
    <PredicateValidationReference Id="StrongPassword" />
```
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"/>
```
Fügen Sie im technischen Profil mit Id="UserInformationCollector", mithilfe des folgenden Codes, den Kennwortanspruch 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. Daher fügen wir den Kennwortanspruch nicht zum Element der vertrauenden Seite hinzu.

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

Sie können verlangen, dass Ihre Benutzer ihr Kennwort zweimal als Mittel eingeben, um zu bestätigen, dass der Benutzer sich an das eingegebene Kennwort erinnert. In diesem Fall müssen Sie überprüfen, ob die Werte der beiden Einträge übereinstimmen. Eine individuelle Richtlinie bietet eine einfache Möglichkeit, diese Anforderung zu erfüllen. Die Anspruchstypen kennwort und reenterPassword werden als besonders angesehen. Wenn sie also zum Sammeln von Benutzereingaben verwendet werden, überprüft die Benutzeroberfläche, dass der Benutzer sein Kennwort ordnungsgemäß erneut eingegeben hat.

Führen Sie die folgenden Schritte aus, um die Neueingabe des Kennworts in Ihrer benutzerdefinierten Richtlinie zu validieren.

Deklarieren Sie in Ihrem ClaimsSchema Dateiabschnitt ContosoCustomPolicy.XML den ReenterPassword-Anspruch direkt nach dem Kennwortanspruch mithilfe des folgenden Codes:

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

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"/>
```
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 einer benutzerdefinierten Richtliniendatei

An diesem Punkt haben Sie Ihre Richtlinie erstellt, um die ersten drei Ansätze für die Benutzereingabeüberprüfung zu behandeln.

Führen Sie die Schritte in der Datei "Benutzerdefinierte Richtlinien hochladen" aus. Wenn Sie eine Datei mit demselben Namen wie die datei hochladen, die sich bereits im Portal befindet, stellen Sie sicher, dass Sie die benutzerdefinierte Richtlinie überschreiben, falls sie bereits vorhanden ist.

Schritt 6 : Testen der benutzerdefinierten Richtlinie

Wählen Sie unter Benutzerdefinierte Richtlinien die Richtlinie B2C_1A_CONTOSOCUSTOMPOLICY aus.
Wählen Sie auf der Übersichtsseite der benutzerdefinierten Richtlinie für Anwendung auswählen die Webanwendung aus, z. B. webapp1 , die Sie zuvor registriert haben. Stellen Sie sicher, dass der Wert Antwort-URL auswählen auf festgelegthttps://jwt.ms ist.
Wählen Sie die Schaltfläche Jetzt ausführen aus.
Geben Sie "Vorname " und "Nachname" ein.
Wählen Sie "Kontotyp" aus.
Geben Sie für E-Mail-Adresse einen E-Mail-Wert ein, der nicht gut formatiert ist, z. B. maurice@contoso.
Geben Sie für "Kennwort" den Kennwortwert ein, der nicht allen Merkmalen eines starken Kennworts entspricht, wie festgelegt.
Wählen Sie die Schaltfläche Continue aus. Es wird ein Bildschirm angezeigt, der der folgenden Abbildung ähnelt:

Sie müssen Ihre Eingaben korrigieren, bevor Sie fortfahren.
Geben Sie die richtigen Werte wie in den Fehlermeldungen vorgeschlagen ein, und wählen Sie dann erneut die Schaltfläche " Weiter " aus. Nachdem die Richtlinie die Ausführung abgeschlossen hat, werden Sie zu https://jwt.ms umgeleitet, und es wird ein dekodiertes JWT angezeigt. Das Token sieht ähnlich wie der folgende JWT-Codeausschnitt aus:

    {
      "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 der Benutzereingabe mithilfe von technischen Validierungsprofilen

Die validierungstechniken, die wir in Schritt 1, Schritt 2 und Schritt 3 verwendet haben, gelten nicht für alle Szenarien. Wenn Ihre Geschäftsregeln zu komplex sind, um auf der Anspruchsdeklarationsebene definiert zu werden, können Sie eine Validierungstechnik konfigurieren und dann aus einem Self-Asserted-Technikprofil darauf zugreifen.

Hinweis

Nur selbst behauptete technische Profile können validierungstechnische Profile verwenden. Weitere Informationen zum technischen Profil der Validierung

Beschreibung des Szenarios

Wenn der Kontotyp des Benutzers " Contoso-Mitarbeiterkonto" lautet, müssen wir sicherstellen, dass seine E-Mail-Domäne auf einer Reihe vordefinierter Domänen basiert. Diese Domänen sind contoso.com, fabrikam.com und woodgrove.com. Andernfalls wird dem Benutzer ein Fehler angezeigt, bis er ein gültiges Contoso-Mitarbeiterkonto verwendet oder zu "Persönliches Konto" wechselt.

Führen Sie die folgenden Schritte aus, um zu erfahren, wie Benutzereingaben mithilfe von technischen Validierungsprofilen überprüft werden. Sie verwenden ein technisches Profil für die Überprüfung des Anspruchstransformationstyps, aber Sie können auch einen REST-API-Dienst aufrufen, um Daten zu überprüfen, wie Sie später in dieser Reihe erfahren werden.

Deklarieren Sie im Abschnitt ClaimsSchema Ihrer ContosoCustomPolicy.XML Datei die Elemente domain und domainStatus, indem Sie den folgenden Code verwenden:

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

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

Suchen Sie den ClaimsTransformations Abschnitt, 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 GetDomainFromEmail-Anspruchstransformation extrahiert eine Domäne aus E-Mails mithilfe der ParseDomain-Methode und speichert sie im Domänenanspruch . Die LookupDomain Claims Transformation verwendet die extrahierte Domäne, um zu überprüfen, ob sie gültig ist, indem sie in den vordefinierten Domänen nachschlägt. Ist dies der Fall, wird dem Anspruch domainStatusgültig zugewiesen.

Verwenden Sie den folgenden Code, um ein technisches Profil im selben 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 ein technisches Profil für die Anspruchstransformation deklariert, das die Anspruchstransformationen GetDomainFromEmail und LookupDomain ausführt.

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 selbst bestätigten technischen Profil von UserInformationCollector ein Validierungs-technisches Profil 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.
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 einen benutzerdefinierten Fehler eingerichtet, falls der Benutzer keine gültige E-Mail verwendet.
Folgen Sie den Anweisungen in " Benutzerdefinierte Richtliniendatei hochladen", um Ihre Richtliniendatei hochzuladen.
Befolgen Sie die Anweisungen in Schritt 6 , um Ihre benutzerdefinierte Richtlinie zu testen:
1. Wählen Sie für "Kontotyp" die Option "Contoso-Mitarbeiterkonto" aus.
2. Geben Sie für E-Mail-Adresse eine ungültige E-Mail-Adresse ein, z.B. maurice@fourthcoffee.com.
3. Geben Sie die restlichen Details nach Bedarf ein, und wählen Sie "Weiter" aus.
Da es sich bei maurice@fourthcoffee.com nicht um eine gültige E-Mail-Adresse handelt, wird ein Fehler angezeigt, der dem im folgenden Screenshot ähnelt. Sie müssen eine gültige E-Mail-Adresse verwenden, um die benutzerdefinierte Richtlinie erfolgreich auszuführen und einen JWT zu erhalten.

Erfahren Sie mehr über das technische Profil der Validierung.
Erfahren Sie, wie Sie technische Profile in benutzerdefinierten Azure AD B2C-Richtlinien bedingt aktivieren oder deaktivieren.

Feedback

War diese Seite hilfreich?

Last updated on 2025-05-09

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

Voraussetzungen

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

Schritt 2 : Überprüfen der Benutzereingabe mithilfe regulärer Ausdrücke

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

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

Schritt 5 : Hochladen einer benutzerdefinierten Richtliniendatei

Schritt 6 : Testen der benutzerdefinierten Richtlinie

Schritt 7 : Überprüfen der Benutzereingabe mithilfe von technischen Validierungsprofilen

Beschreibung des Szenarios

Verwandte Inhalte

Feedback

Zusätzliche Ressourcen