Gebruikersinvoer valideren met behulp van aangepast Azure Active Directory B2C-beleid

Artikel
01/11/2024

Met aangepast azure Active Directory B2C-beleid (Azure AD B2C) kunt u niet alleen gebruikersinvoer verplicht maken, maar ook valideren. U kunt gebruikersinvoer markeren als vereist, bijvoorbeeld <DisplayClaim ClaimTypeReferenceId="givenName" Required="true"/>, maar dit betekent niet dat uw gebruikers geldige gegevens invoeren. Azure AD B2C biedt verschillende manieren om gebruikersinvoer te valideren. In dit artikel leert u hoe u een aangepast beleid schrijft waarmee de gebruikersinvoer wordt verzameld en gevalideerd met behulp van de volgende methoden:

Beperk de gegevens die een gebruiker invoert door een lijst met opties op te geven waaruit u kunt kiezen. Deze benadering maakt gebruik van opgesomde waarden, die u toevoegt wanneer u een claim declareert.
Definieer een patroon dat moet overeenkomen met een gebruikersinvoer. Deze methode maakt gebruik van reguliere expressies, die u toevoegt wanneer u een claim declareert.
Definieer een set regels en vereist dat een gebruikersinvoer voldoet aan een of meer van de regels. Deze methode maakt gebruik van Predicaten, die u toevoegt wanneer u een claim declareert.
Gebruik het speciale claimtype reenterPassword om te controleren of de gebruiker het wachtwoord correct opnieuw heeft ingevoerd tijdens de gebruikersinvoerverzameling.
Configureer een technisch validatieprofiel waarmee complexe bedrijfsregels worden gedefinieerd die niet kunnen worden gedefinieerd op claimdeclaratieniveau. U verzamelt bijvoorbeeld een gebruikersinvoer die moet worden gevalideerd op basis van een waarde of een setwaarden in een andere claim.

Vereisten

Als u er nog geen hebt, maakt u een Azure AD B2C-tenant die is gekoppeld aan uw Azure-abonnement.
Registreer een webtoepassing en schakel impliciete toekenning van id-token in. Gebruik voor de omleidings-URI https://jwt.ms.
Visual Studio Code (VS Code) moet op uw computer zijn geïnstalleerd.
Voer de stappen in Het verzamelen en bewerken van gebruikersinvoer uit met behulp van aangepast Azure AD B2C-beleid. Dit artikel maakt deel uit van de reeks instructies voor het maken en uitvoeren van uw eigen aangepaste beleidsregels.

Notitie

Dit artikel maakt deel uit van de reeks instructies voor het maken en uitvoeren van uw eigen aangepaste beleidsregels in Azure Active Directory B2C. We raden u aan deze reeks te starten vanuit het eerste artikel.

Stap 1: gebruikersinvoer valideren door gebruikersinvoeropties te beperken

Als u alle mogelijke waarden kent die een gebruiker voor een bepaalde invoer kan invoeren, kunt u een eindige set waarden opgeven waaruit een gebruiker moet kiezen. Hiervoor kunt u DropdownSinglSelect, CheckboxMultiSelect en RadioSingleSelectUserInputType gebruiken. In dit artikel gebruikt u een invoertype RadioSingleSelect :

Open het bestand ContosoCustomPolicy.XMLin VS Code.
Declareer in het ClaimsSchema element van het ContosoCustomPolicy.XML bestand het volgende claimtype:
```
    <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>
```
We hebben accountType-claim gedeclareerd. Wanneer de waarde van de claim wordt verzameld van de gebruiker, moet de gebruiker Contoso-werknemersaccount selecteren voor een waardewerk of persoonlijk account voor een waarde persoonlijk.

Met Azure AD B2C kunt u uw beleid ook in verschillende talen aanpassen en de accounttypebeperkingen voor meerdere talen bieden. Raadpleeg de gebruikersinterface van het artikel Gebruikerskenmerken toevoegen voor meer informatie.
Zoek het technische profiel met Id="UserInformationCollector", voeg de accountType-claim toe als weergaveclaim met behulp van de volgende code:
```
    <DisplayClaim ClaimTypeReferenceId="accountType" Required="true"/>
```
Voeg in het technische profiel met Id="UserInformationCollector"de volgende code de accountType-claim toe als uitvoerclaim:
```
    <OutputClaim ClaimTypeReferenceId="accountType"/>
```
Als u de accounttypeclaim wilt opnemen in het toegangstoken, zoekt u het RelyingParty element, voegt u de accountType-claim toe als een tokenclaim met behulp van de volgende code:
```
    <OutputClaim ClaimTypeReferenceId="accountType" />
```

Stap 2: gebruikersinvoer valideren met behulp van reguliere expressies

Wanneer het niet mogelijk is om vooraf alle mogelijke invoerwaarden van gebruikers te kennen, kunt u de gebruiker toestaan de gegevens zelf in te voeren. In dit geval kunt u reguliere expressies (regex) of patroon gebruiken om te bepalen hoe gebruikersinvoer moet worden opgemaakt. Een e-mailbericht moet bijvoorbeeld het symbool (@) en een punt (.) ergens in de tekst hebben.

Wanneer u een claim declareert, kunt u met aangepast beleid een regex definiëren die overeenkomt met de gebruikersinvoer. U kunt desgewenst een bericht opgeven dat aan de gebruiker wordt weergegeven als de invoer niet overeenkomt met de expressie.

Zoek het ClaimsSchema element en declareer de e-mailclaim met behulp van de volgende code:

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

Zoek het technische profiel met Id="UserInformationCollector", voeg de e-mailclaim toe als weergaveclaim met behulp van de volgende code:
```
    <DisplayClaim ClaimTypeReferenceId="email" Required="true"/>
```
Voeg in het technische profiel met Id="UserInformationCollector"de volgende code de e-mailclaim toe als uitvoerclaim:
```
    <OutputClaim ClaimTypeReferenceId="email"/>
```
Zoek het RelyingParty element, voeg het e-mailbericht toe als een tokenclaim met behulp van de volgende code:
```
    <OutputClaim ClaimTypeReferenceId="email" />
```

Stap 3: gebruikersinvoer valideren met behulp van predicaten

U hebt regex gebruikt om gebruikersinvoer te valideren. Regex heeft echter één zwakke punt, dat wil gezegd, het foutbericht wordt weergegeven totdat u invoer corrigeert zonder dat u de specifieke vereiste ziet dat de invoer ontbreekt.

Met predicaten kunt u dit probleem oplossen door een set regels (predicaten) en een onafhankelijk foutbericht voor elke regel te definiëren. In aangepaste beleidsregels heeft een predicaat een ingebouwde methode, waarmee de controles worden gedefinieerd die u wilt maken. U kunt bijvoorbeeld de predicaatmethode IsLengthRange gebruiken om te controleren of een gebruikerswachtwoord binnen het bereik van de opgegeven minimum- en maximumparameters (waarden) valt.

Hoewel de predicaten de validatie definiëren om te controleren op een claimtype, groepeert predicaten een set predicaten om een validatie van gebruikersinvoer te vormen die kan worden toegepast op een claimtype. U maakt bijvoorbeeld een predicaatgroep van validatie waarmee verschillende typen toegestane tekens voor een wachtwoord worden gevalideerd. Zowel predicaten als predicaatvalidations-elementen zijn onderliggende elementen van BuildingBlocks de sectie van uw beleidsbestand.

Zoek het ClaimsSchema element en declareer de wachtwoordclaim met behulp van de volgende code:

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

Voeg een Predicates element toe als onderliggend element van de sectie met behulp van BuildingBlocks de volgende code. U voegt het Predicates element onder het ClaimsSchema element toe:
```
    <Predicates>

    </Predicates>
```

Definieer in het Predicates element predicaten met behulp van de volgende code:

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

We hebben verschillende regels gedefinieerd, die bij het samenstellen een acceptabel wachtwoord hebben beschreven. Vervolgens kunt u predicaten groeperen om een set wachtwoordbeleid te vormen die u in uw beleid kunt gebruiken.

Voeg een PredicateValidations element toe als onderliggend element van de sectie met behulp van BuildingBlocks de volgende code. U voegt het PredicateValidations element toe als onderliggend element van BuildingBlocks de sectie, maar onder het Predicates element:
```
    <PredicateValidations>

    </PredicateValidations>
```

Definieer in het PredicateValidations element PredicateValidations met behulp van de volgende 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>

We hebben drie gedefinieerde predicaatvalidatie, StrongPassword, CustomPassword en SimplePassword. Afhankelijk van de kenmerken van het wachtwoord dat uw gebruikers moeten invoeren, kunt u elk van de predicaatvalidaties gebruiken. In dit artikel gebruiken we een sterk wachtwoord.

Zoek de declaratie claimtype voor het wachtwoord en voeg de validatie van het predicaat StrongPassword toe net na de declaratie van het UserInputType-element die het bevat met behulp van de volgende code:
```
    <PredicateValidationReference Id="StrongPassword" />
```
Zoek het technische profiel met Id="UserInformationCollector", voeg de wachtwoordclaim toe als weergaveclaim met behulp van de volgende code:
```
    <DisplayClaim ClaimTypeReferenceId="password" Required="true"/>
```
Voeg in het technische profiel met Id="UserInformationCollector"de volgende code de wachtwoordclaim toe als uitvoerclaim:
```
    <OutputClaim ClaimTypeReferenceId="password"/>
```

Notitie

Om veiligheidsredenen voegen we het wachtwoord van een gebruiker niet toe als claim in het token dat door uw beleid wordt gegenereerd. Daarom voegen we de wachtwoordclaim niet toe aan het relying party-element.

Stap 4: wachtwoord valideren en wachtwoord bevestigen

U kunt vereisen dat gebruikers hun wachtwoord twee keer invoeren als een middel om te bevestigen dat de gebruiker het wachtwoord onthoudt dat hij of zij invoert. In dit geval moet u controleren of de waarden van de twee vermeldingen overeenkomen. Aangepast beleid biedt een eenvoudige manier om deze vereiste te bereiken. De claimtypen wachtwoord en reenterPassword worden beschouwd als speciaal, dus wanneer ze worden gebruikt om gebruikersinvoer te verzamelen, valideert de gebruikersinterface dat de gebruiker het wachtwoord correct opnieuw heeft ingevoerd.

Gebruik de volgende stappen om het wachtwoord opnieuw in te voeren in uw aangepaste beleid:

Declareer in uw ClaimsSchema sectie van het ContosoCustomPolicy.XML bestand de claim reenterPassword net na de wachtwoordclaim met behulp van de volgende code:

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

Als u invoer voor wachtwoordbevestiging van de gebruiker wilt verzamelen, zoekt u het UserInformationCollector zelf-asserted technische profiel, voegt u reenterPassword-claim toe als een weergaveclaim met behulp van de volgende code:
```
    <DisplayClaim ClaimTypeReferenceId="reenterPassword" Required="true"/>
```
Zoek in uw ContosoCustomPolicy.XML bestand het UserInformationCollector zelf-asserted technische profiel, voeg reenterPassword-claim toe als een uitvoerclaim met behulp van de volgende code:
```
    <OutputClaim ClaimTypeReferenceId="reenterPassword"/>
```

Stap 5: Aangepast beleidsbestand uploaden

Op dit moment hebt u uw beleid gebouwd om de eerste drie benaderingen voor validatie van gebruikersinvoer aan te pakken.

Volg de stappen in het bestand Aangepast beleid uploaden. Als u een bestand met dezelfde naam uploadt als het bestand dat zich al in de portal bevindt, moet u het aangepaste beleid overschrijven selecteren als dit al bestaat.

Stap 6: het aangepaste beleid testen

Selecteer onder Aangepast beleid B2C_1A_CONTOSOCUSTOMPOLICY.
Selecteer voor Toepassing selecteren op de overzichtspagina van het aangepaste beleid de webtoepassing, zoals web-app1 die u eerder hebt geregistreerd. Zorg ervoor dat de waarde antwoord-URL selecteren is ingesteld ophttps://jwt.ms.
Knop Nu uitvoeren selecteren.
Voer de opgegeven naam en achternaam in.
Selecteer Accounttype.
Voer voor E-mailadres een e-mailwaarde in die niet goed is opgemaakt, zoals maurice@contoso.
Voer voor Wachtwoord de wachtwoordwaarde in die niet voldoet aan alle kenmerken van een sterk wachtwoord zoals ingesteld.
Selecteer de knop Doorgaan . U ziet een scherm dat lijkt op het scherm dat hieronder wordt weergegeven:

U moet uw invoer corrigeren voordat u doorgaat.
Voer de juiste waarden in zoals voorgesteld door de foutberichten en selecteer vervolgens de knop Doorgaan opnieuw. Nadat het beleid is uitgevoerd, wordt u omgeleid naar https://jwt.msen ziet u een gedecodeerd JWT-token. Het token lijkt op het volgende JWT-tokenfragment:

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

Stap 7: gebruikersinvoer valideren met behulp van technische validatieprofielen

De validatietechnieken die we in stap 1, stap 2 en stap 3 hebben gebruikt, zijn niet van toepassing op alle scenario's. Als uw bedrijfsregels complex zijn om te worden gedefinieerd op claimdeclaratieniveau, kunt u een validatie technisch configureren en deze vervolgens aanroepen vanuit een zelf-asserted technisch profiel.

Notitie

Alleen zelf-asserted technische profielen kunnen gebruikmaken van validatie technische profielen. Meer informatie over het technische validatieprofiel

Overzicht van scenario

Als het accounttype van de gebruiker Contoso Employee Account is, moeten we ervoor zorgen dat hun e-maildomein is gebaseerd op een set vooraf gedefinieerde domeinen. Deze domeinen zijn contoso.com, fabrikam.com en woodgrove.com. Anders wordt een fout aan de gebruiker weergegeven totdat deze een geldig Contoso-werknemersaccount gebruikt of overschakelt naar persoonlijk account.

Gebruik de volgende stappen om te leren hoe u gebruikersinvoer valideert met behulp van technische validatieprofielen. U gebruikt een technisch validatieprofiel voor claimtransformatietypen, maar u kunt ook een REST API-service aanroepen om gegevens te valideren, zoals u verderop in deze reeks leert.

Declareer in uw ClaimsSchema sectie van uw ContosoCustomPolicy.XML bestand de claims domein en domainStatus met behulp van de volgende code:

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

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

Zoek de ClaimsTransformations sectie en configureer claimtransformaties met behulp van de volgende code:

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

De transformatie van claims GetDomainFromEmail extraheert een domein uit e-mail met behulp van de methode ParseDomain en slaat deze op in de domeinclaim . De Transformatie van LookupDomain Claims maakt gebruik van het geëxtraheerde domein om te controleren of het geldig is door het in de vooraf gedefinieerde domeinen op te zoeken en geldig toe te wijzen aan de domainStatus-claim.

Gebruik de volgende code om een technisch profiel toe te voegen in dezelfde claimprovider als het technische profiel met 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>

We hebben het technische profiel voor claimtransformatie gedeclareerd, waarmee de claimtransformaties GetDomainFromEmail en LookupDomain worden uitgevoerd.

Zoek het technische profiel met Id=UserInformationCollectoren een ValidationTechnicalProfile vlak na het OutputClaims element met behulp van de volgende code:

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

We hebben een validatie technisch profiel toegevoegd aan het zelfbeveiligde technische profiel userInformationCollector . Het technische profiel wordt alleen overgeslagen als de accountType-waarde niet gelijk is aan werk. Als het technische profiel wordt uitgevoerd en het e-maildomein niet geldig is, is er een fout opgetreden.

Zoek het technische profiel met Id=UserInformationCollectoren voeg de volgende code toe in de metadata tag.
```
    <Item Key="LookupNotFound">The provided email address isn't a valid Contoso Employee email.</Item>
```
Er is een aangepaste fout ingesteld voor het geval de gebruiker geen geldig e-mailbericht gebruikt.
Volg de instructies in Het aangepaste beleidsbestand uploaden om uw beleidsbestand te uploaden.
Volg de instructies in stap 6 om uw aangepaste beleid te testen:
1. Voor accounttype selecteert u Contoso-werknemersaccount
2. Voer voor e-mailadres een ongeldig e-mailadres in, zoals maurice@fourthcoffee.com.
3. Voer de rest van de details in zoals vereist en selecteer Doorgaan
Omdat maurice@fourthcoffee.com dit geen geldig e-mailbericht is, ziet u een fout die lijkt op de e-mail die in de onderstaande schermafbeelding wordt weergegeven. U moet een geldig e-mailadres gebruiken om het aangepaste beleid uit te voeren en een JWT-token te ontvangen.

Delen via

Gebruikersinvoer valideren met behulp van aangepast Azure Active Directory B2C-beleid

Vereisten

Stap 1: gebruikersinvoer valideren door gebruikersinvoeropties te beperken

Stap 2: gebruikersinvoer valideren met behulp van reguliere expressies

Stap 3: gebruikersinvoer valideren met behulp van predicaten

Stap 4: wachtwoord valideren en wachtwoord bevestigen

Stap 5: Aangepast beleidsbestand uploaden

Stap 6: het aangepaste beleid testen

Stap 7: gebruikersinvoer valideren met behulp van technische validatieprofielen

Overzicht van scenario

Volgende stappen

Feedback

Aanvullende resources