Una vía importante de errores de seguridad y de inconsistencia de datos dentro de una aplicación se produce a través de los datos que introducen los usuarios. Un fallo de seguridad muy frecuente, consiste en los errores basados en buffer overflow, se producen cuando se desborda el tamaño de una determinada variable, vector, matriz, etc. y se consigue acceder a zonas de memoria reservadas. Por ejemplo, si reservamos memoria para el nombre de usuario que ocupa 20 caracteres y, de alguna forma, el usuario consigue que la aplicación almacene más datos, se está produciendo un buffer overflow ya que los primeros 20 valores se almacenan en un lugar correcto, pero los restantes valores se almacenan en zonas de memoria destinadas a otros fines.

La validación de datos permite:

• Mantener la consistencia de los datos. Por ejemplo, si a un usuario le indicamos que debe introducir su DNI éste debe tener el mismo formato siempre.
• Evitar desbordamientos de memoria buffer overflow. Al comprobar el formato y la longitud del campo evitamos que se produzcan los desbordamientos de memoria.

Para llevar un riguroso control, sobre los datos de entrada de los usuarios hay que tener en cuenta la validación del formato y la validación del tamaño de la entrada.

Java incorpora una potente y útil librería (import java.util.regex) para utilizar la clase Pattern que nos permite definir expresiones regulares. Las expresiones regulares permiten definir exactamente el formato de la entrada de datos.

Para utilizar las expresiones regulares debemos realizar los siguientes pasos:

1. Importamos la librería:
   

   import java.util.regex.*;

2. Definimos Pattern y Matcher:

   Pattern pat=null;

   Matcher mat=null;

3. Compilamos el patrón a utilizar.
   

   pat=Pattern.compile(patron);

   donde el patrón a comprobar es la parte más importante ya que es donde tenemos que indicar el formato que va a tener la entrada.

   Elementos para la validación entradas

   Elemento	Comentario.
   x	El carácter x.
   [abc]	Los caracteres a, b o c.
   [a-z]	Una letra en minúscula.
   [A-Z]	Una letra en mayúscula.
   [a-zA-Z]	Una letra en minúscula o mayúscula.
   [0-9]	Un número comprendido entre el 0 y el 9.
   [a-zA-Z0-9]	Una letra en minúscula, mayúscula o un número.

   
   

   Operadores para la validación entradas

   Operador	Comentario
   [a-z]{2}	Hay que introducir 2 letras en minúsculas.
   [a-z]{2,5}	Hay que introducir de 2 a 5 letras en minúsculas.
   [a-z]{2,}	Hay que introducir más de 2 letras en minúsculas.
   hola|adios	Es la operación OR lógica y permite indicar que se introduzca el texto "hola" o "adios".
   XY	Es la operación AND lógica y permite indicar que se deben introducir dos expresiones X seguida de Y.
   e(n|l) campo	Los delimitadores ( ) permite hacer expresiones más complejas. En el ejemplo, el usuario debe introducir el texto "en campo" o "el campo".

   
   

   A modo de ejemplo, a continuación se muestran varios ejemplos de expresiones:

   • Teléfono (formato 000-000000)
     

     pat=Pattern.compile("[0-9]{3}-[0-9]{6}");

   • DNI
     

     pat=Pattern.compile("[0-9]{8}-[a-zA-Z]");

   • Provincias andaluzas
     

     pat=Pattern.compile("Almería","Granada","Jaén","Málaga","Sevilla","Cádiz","Córdoba","Huelva");

4. Le pasamos al evaluador de expresiones el texto a comprobar.
   

   mat=pat.matcher(texto_a_comprobar);

5. Comprobamos si hay alguna coincidencia:

   if(mat.find()){
   	// Coincide con el patrón 
   	}else{
   	// NO coincide con el patrón 
   	}