Validación de entradas de usuario mediante la directiva personalizada de Azure Active Directory B2C

La directiva personalizada de Azure Active Directory B2C (Azure AD B2C) no solo permite hacer que las entradas de usuario sean obligatorias, sino también validarlas. Puede marcar las entradas de usuario como obligatorias, como <DisplayClaim ClaimTypeReferenceId="givenName" Required="true"/>, pero eso no significa que los usuarios vayan a introducir datos válidos. Azure AD B2C proporciona varias maneras de validar una entrada de usuario. En este artículo, aprenderá a escribir una directiva personalizada que recopile las entradas del usuario y las valide mediante los siguientes enfoques:

• Restrinja los datos que ingresa un usuario proporcionando una lista de opciones para elegir. Este enfoque usa valores enumerados, que se agregan al declarar una notificación.

• Defina un patrón con el que debe coincidir una entrada de usuario. Este enfoque usa expresiones regulares, que se agregan al declarar una notificación.

• Defina un conjunto de reglas y exija que una entrada de usuario obedezca una o más de las reglas. Este enfoque utiliza predicados, que se agregan al declarar una notificación.

• Use el tipo de notificación especial reenterPassword para validar que el usuario volvió a escribir correctamente su contraseña durante la recopilación de entradas de usuario.

• Configure un perfil técnico de validación que defina reglas de negocio complejas que no son posibles de definir en el nivel de declaración de notificaciones. Por ejemplo, se recopila una entrada de usuario, que debe validarse con un valor o un conjunto de valores en otra notificación.

Prerrequisitos

• Si aún no tiene una, cree un inquilino de Azure AD B2C que esté vinculado a su suscripción de Azure.

• Registre una aplicación web.

• Debe tener Visual Studio Code (VS Code) instalado en el equipo.

• Complete los pasos descritos en Recopilación y manipulación de entradas de usuario mediante la directiva personalizada de Azure AD B2C. Este artículo forma parte de la Serie de guías paso a paso para crear y ejecutar sus propias directivas personalizadas.

Paso 1: Validar la entrada del usuario limitando las opciones de entrada del usuario

Si conoce todos los valores posibles que un usuario puede especificar para una entrada determinada, puede proporcionar un conjunto finito de valores entre los que un usuario debe seleccionar. Puede usar DropdownSingleSelect, CheckboxMultiSelect y RadioSingleSelectUserInputType para este propósito. En este artículo, usará un tipo de entrada RadioSingleSelect :

1. En VS Code, abra el archivo ContosoCustomPolicy.XML.

2. En el ClaimsSchema elemento del ContosoCustomPolicy.XML archivo, declare el siguiente tipo de notificación:

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

   Hemos declarado la notificación accountType . Cuando se recopila el valor de la notificación del usuario, el usuario debe seleccionar Cuenta de empleado de Contoso para un trabajo de valor o Cuenta personal para un valor personal.

   Azure AD B2C también le permite acomodar su directiva a diferentes idiomas y proporciona las restricciones de tipo de cuenta para varios idiomas. Para obtener más información, consulte el artículo Localizar la interfaz de usuario del artículo Agregar atributos de usuario.

3. Busque el perfil técnico con Id="UserInformationCollector", agregue la notificación accountType como notificación de visualización mediante el código siguiente:

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

4. En el perfil técnico con Id="UserInformationCollector", agregue la notificación accountType como una notificación de salida mediante el código siguiente:

       <OutputClaim ClaimTypeReferenceId="accountType"/>
   

5. Para incluir la notificación de tipo de cuenta en el token de acceso, busque el RelyingParty elemento y agregue la notificación accountType como una notificación de token mediante el código siguiente:

       <OutputClaim ClaimTypeReferenceId="accountType" />
   

Paso 2: Validar la entrada del usuario mediante expresiones regulares

Cuando no es posible conocer todos los valores de entrada posibles del usuario de antemano, permite que el usuario introduzca los datos por sí mismo. En este caso, puede usar expresiones regulares (regex) o patrones para determinar cómo se debe formatear una entrada de usuario. Por ejemplo, un correo electrónico debe tener el símbolo arroba (@) y un punto (.) en algún lugar de su texto.

Al declarar una notificación, la directiva personalizada permite definir una expresión regular, con la que debe coincidir la entrada del usuario. Opcionalmente, puede proporcionar un mensaje, que se muestra al usuario, si su entrada no coincide con la expresión.

1. Busque el ClaimsSchema elemento y declare la notificación de correo electrónico mediante el código siguiente:

       <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. Busque el perfil técnico con Id="UserInformationCollector", agregue la notificación de correo electrónico como notificación de visualización mediante el código siguiente:

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

3. En el perfil técnico con Id="UserInformationCollector", agregue la notificación de correo electrónico como una notificación de salida mediante el código siguiente:

       <OutputClaim ClaimTypeReferenceId="email"/>
   

4. Busque el RelyingParty elemento, agregue el correo electrónico como una notificación de token mediante el código siguiente:

       <OutputClaim ClaimTypeReferenceId="email" />
   

Paso 3: Validar la entrada del usuario mediante predicados

Ha usado expresiones regulares para validar las entradas del usuario. Sin embargo, las expresiones regulares tienen una debilidad, es decir, el mensaje de error se muestra hasta que corrija la entrada sin mostrarle el requisito específico que falta en la entrada.

Las validaciones de predicados le permiten abordar este problema al permitirle definir un conjunto de reglas (predicados) y un mensaje de error independiente para cada regla. En las políticas personalizadas, un predicado tiene un método incorporado, que define las comprobaciones que desea realizar. Por ejemplo, puede usar el método de predicado IsLengthRange para comprobar si una contraseña de usuario se encuentra dentro del intervalo de parámetros (valores) mínimo y máximo especificado.

Mientras que los predicados definen la validación que se va a comprobar con un tipo de notificación, las PredicateValidations agrupan un conjunto de predicados para formar una validación de entrada de usuario que se puede aplicar a un tipo de notificación. Por ejemplo, se crea un grupo de predicados de validación que valida diferentes tipos de caracteres permitidos para una contraseña. Los elementos Predicates y PredicateValidations son elementos secundarios de BuildingBlocks la sección del archivo de directivas.

1. Busque el ClaimsSchema elemento y declare la notificación de contraseña mediante el código siguiente:

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

2. Agregue un Predicates elemento como elemento secundario de BuildingBlocks section mediante el código siguiente. Agregue el Predicates elemento debajo del ClaimsSchema elemento:

       <Predicates>
   
       </Predicates>
   

3. Dentro del Predicates elemento, defina predicados mediante el código siguiente:

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

   Hemos definido varias reglas, que cuando se juntan describen una contraseña aceptable. A continuación, puede agrupar predicados para formar un conjunto de políticas de contraseñas que puede usar en su política.

4. Agregue un PredicateValidations elemento como elemento secundario de BuildingBlocks section mediante el código siguiente. Agregue el PredicateValidations elemento como un elemento secundario de BuildingBlocks section, pero debajo del Predicates elemento:

       <PredicateValidations>
   
       </PredicateValidations>
   

5. Dentro del PredicateValidations elemento, defina PredicateValidations mediante el código siguiente:

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

   Hemos definido tres Predicate Validation, StrongPassword, CustomPassword y SimplePassword. En función de las características de la contraseña que desee que introduzcan los usuarios, puede utilizar cualquiera de las validaciones de predicados. En este artículo, usaremos una contraseña segura.

6. Busque la declaración de tipo de notificación de contraseña y agregue la validación de predicado StrongPassword justo después de la declaración de elemento UserInputType que contiene mediante el código siguiente:

       <PredicateValidationReference Id="StrongPassword" />
   

7. Busque el perfil técnico con Id="UserInformationCollector", agregue la notificación de contraseña como notificación de visualización mediante el código siguiente:

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

8. En el perfil técnico con Id="UserInformationCollector", agregue la notificación de contraseña como una notificación de salida mediante el código siguiente:

       <OutputClaim ClaimTypeReferenceId="password"/>
   

Paso 4 - Validar la contraseña y confirmar la contraseña

Puede solicitar a los usuarios que escriban su contraseña dos veces como medio para confirmar que el usuario recuerda la contraseña que ingresó. En este caso, debe comprobar que los valores de las dos entradas coincidan. La directiva personalizada proporciona una manera fácil de lograr este requisito. Los tipos de notificación password y reenterPassword se consideran especiales, por lo que cuando se usan para recopilar entradas de usuario, la interfaz de usuario valida que el usuario haya vuelto a escribir correctamente su contraseña.

Siga estos pasos para validar la reintroducción de contraseña en la política personalizada:

1. En la ClaimsSchema sección del archivo, declare ContosoCustomPolicy.XML justo después de la notificación de contraseña mediante el código siguiente:

       <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. Para recopilar la entrada de confirmación de contraseña del usuario, busque el UserInformationCollector perfil técnico autoafirmado, agregue la notificación reenterPassword como notificación de visualización mediante el código siguiente:

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

3. En el ContosoCustomPolicy.XML archivo, busque el UserInformationCollector perfil técnico autoafirmado, agregue la notificación reenterPassword como notificación de salida mediante el código siguiente:

       <OutputClaim ClaimTypeReferenceId="reenterPassword"/>
   

Paso 5: Carga del archivo de directiva personalizado

En este punto, ha creado su política para abordar los tres primeros enfoques para la validación de entradas de usuario.

Siga los pasos descritos en Cargar archivo de política personalizada. Si va a cargar un archivo con el mismo nombre que el que ya está en el portal, asegúrese de seleccionar Sobrescribir la directiva personalizada si ya existe.

Paso 6: Probar la directiva personalizada

1. En Directivas personalizadas, seleccione B2C_1A_CONTOSOCUSTOMPOLICY.

2. Para Seleccionar aplicación en la página de información general de la directiva personalizada, seleccione la aplicación web, como webapp1 que registró anteriormente. Asegúrese de que el valor Select reply URL (Seleccionar dirección URL de respuesta ) esté establecido enhttps://jwt.ms.

3. Seleccione el botón Ejecutar ahora .

4. Introduzca el nombre de pila y el apellido.

5. Seleccione Tipo de cuenta.

6. En Dirección de correo electrónico, introduzca un valor de correo electrónico que no tenga un formato correcto, como maurice@contoso.

7. En Contraseña, escriba el valor de la contraseña que no obedece a todas las características de una contraseña segura tal como se estableció.

8. Seleccione el botón Continuar. Verás una pantalla similar a la que se muestra a continuación:

   

   Debe corregir sus entradas antes de continuar.

9. Escriba los valores correctos según lo sugerido por los mensajes de error y, a continuación, vuelva a seleccionar el botón Continuar . Una vez finalizada la ejecución de la directiva, se le redirigirá a https://jwt.msy verá un JWT descodificado. El token tiene un aspecto similar al siguiente fragmento de 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]

Paso 7: Validar la entrada del usuario mediante perfiles técnicos de validación

Las técnicas de validación que hemos usado en los pasos 1, 2 y 3 no son aplicables a todos los escenarios. Si las reglas de negocio son demasiado complejas para definirlas en el nivel de declaración de notificación, puede configurar un técnico de validación y, a continuación, llamarlo desde un perfil técnico deSelf-Asserted.

Información general sobre el escenario

Requerimos que, si el tipo de cuenta del usuario es Cuenta de empleado de Contoso, debemos asegurarnos de que su dominio de correo electrónico se base en un conjunto de dominios predefinidos. Estos dominios son contoso.com, fabrikam.com y woodgrove.com. De lo contrario, mostramos un error al usuario hasta que use una cuenta de empleado de Contoso válida o cambie a una cuenta personal.

Siga estos pasos para aprender a validar la entrada del usuario mediante perfiles técnicos de validación. Use un perfil técnico de validación de tipo de transformación de notificaciones, pero también puede llamar a un servicio de API de REST para validar los datos, como aprenderá más adelante en esta serie.

1. En la ClaimsSchema sección del ContosoCustomPolicy.XML archivo, declare las notificaciones ___domain y domainStatus mediante el código siguiente:

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

2. Busque la ClaimsTransformations sección y configure las transformaciones de notificaciones mediante el código siguiente:

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

   La transformación de notificaciones GetDomainFromEmail extrae un dominio del correo electrónico mediante el método ParseDomain y lo almacena en la notificación de dominio . La transformación de notificaciones LookupDomain usa el dominio extraído para comprobar si es válido buscándolo en los dominios predefinidos y asignándolo valid a la notificación domainStatus .

3. Use el código siguiente para agregar un perfil técnico en el mismo proveedor de notificaciones que el perfil técnico con 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>
   

   Hemos declarado el perfil técnico de transformación de notificaciones, que ejecuta las transformaciones de notificaciones GetDomainFromEmail y LookupDomain .

4. Localice el perfil técnico con Id=UserInformationCollector, y un ValidationTechnicalProfile justo después del OutputClaims elemento mediante el siguiente código:

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

   Hemos agregado un perfil técnico de validación al perfil técnico autoafirmativo UserInformationCollector . El perfil técnico solo se omite si el valor accountType no es igual a work. Si el perfil técnico se ejecuta y el dominio de correo electrónico no es válido, se produce un error.

5. Localice el perfil técnico con Id=UserInformationCollector, y agregue el siguiente código dentro de la metadata etiqueta.

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

   Hemos configurado un error personalizado en caso de que el usuario no utilice un correo electrónico válido.

6. Siga las instrucciones de Cargar archivo de política personalizada para cargar el archivo de política.

7. Siga las instrucciones del paso 6 para probar la política personalizada:

   1. En Tipo de cuenta, seleccione Cuenta de empleado de Contoso
   2. En Dirección de correo electrónico, introduzca una dirección de correo electrónico no válida, como maurice@fourthcoffee.com.
   3. Introduzca el resto de los detalles según sea necesario y seleccione Continuar

   Dado que maurice@fourthcoffee.com no es un correo electrónico válido, verá un error similar al que se muestra en la captura de pantalla a continuación. Debe usar una dirección de correo electrónico válida para ejecutar correctamente la política personalizada y recibir un JWT.

   

Contenido relacionado

• Más información sobre el perfil técnico de validación.

• Obtenga información sobre cómo habilitar o deshabilitar condicionalmente los perfiles técnicos en las directivas personalizadas de Azure AD B2C.