Linux Test On-Line Blog

 

Autorizacion

Una sesión es una serie de  comunicaciones entre un cliente y un servidor en la que se realiza un intercambio de información. Por medio de una sesión se puede hacer seguimiento de un usuario a través  de la aplicación.
El tiempo de vida de una sesión comienza cuando un usuario se conecta por primera vez a
un sitio web pero su finalización puede estar relacionada con tres circunstancias:

• Cuando se abandona el sitio web.
• Cuando se alcanza un tiempo de inactividad que es previamente establecido, en este caso la sesión es automáticamente eliminada. Si el usuario siguiera navegando se             crearía una nueva sesión
• Se ha cerrado o reiniciado el servidor

También se utilizan para la identificación de usuarios, en la que se deben de introducir un login y un password. Después de haber hecho esto el usuario tendrá una serie de permisos sobre las páginas que va a visitar.
Para poder hacer uso de las sesiones en JSP hay que poner el atributo session de la directiva page a true, de esta forma se notifica al contenedor que la página interviene en un
proceso que utiliza las sesiones del protocolo HTTP:

<%@page session=’true’%>
El manejo de las sesiones impide el intercambio de datos entre ellas ya que se trata información específica para cada usuario e incluso si se trata del mismo usuario.
Manejo de las Sesiones:
En JSP las acciones que se pueden realizar sobre las sesiones se lleva a cabo mediante la interface HttpSession y los métodos que implementa incluida dentro del paquete javax.servlet.http y es utilizada por el contenedor de paginas JSP para crear una sesión entre el servidor y el cliente

Para obtener la sesión de un usuario se utiliza el método getSession() que devuelve una
interfaz de tipo HttpSession.
<%
HttpSession sesion=request.getSession();
%>
Una vez creado el objeto de tipo sesión es posible acceder a una serie de datos sobre la
misma. Uno de estos datos es idSession que devuelve un identificador único asociado a una
sesión:
<%
HttpSession sesion=request.getSession();
out.println(“IdSesion: ”+sesion.getId());
%>
Cada interprete de JSP generará un identificador diferente. El resultadore seria similar

Es posible conocer el momento en el que se creó la sesión:

<%@page import=”java.util.*” session=”true”%>
<%
HttpSession sesion=request.getSession();
out.println(“Creación: “+sesion.getCreationTime());
Date momento=new Date(sesion.getCreationTime());
out.println(“<BR>Creación: “+momento);
%>
Seria el resultado:

Guardar objetos en una sesión
Para guardar un objeto en una sesión se utiliza el método setAttribute(), que ha sustituido al
método putValue(). Este método utiliza dos argumentos:

• El primero es el nombre que identificará a esa variable.
• El segundo es el dato que se va a guardar.

SetAttribute(java.lang.String name, java.lang.Object value)
Un ejemplo de cómo guardar una cadena de texto en la sesión:

<%@page import=”java.util.*” session=”true” %>
<%
HttpSession sesion=request.getSession();
sesion.setAttribute(“trabajo”,”Paginas de JSP”);
%>
Si se quiere pasar un parámetro que no sea un objeto es necesario realizar una conversión:
<%@page import=”java.util.*” session=”true” %>
<%
HttpSession sesion=request.getSession();
Integer edad=new Integer(26);
sesion.setAttribute(“edad”,edad);
%>

En caso de tratarse objeto de tipo Vector. ejemplo que almacena los 7 días de la semana. El código seria el siguiente:
<%@page import=”java.util.*” session=”true” %>
<%
HttpSession sesion=request.getSession();
Vector v=new Vector();
v.addElement(new String(“Lunes”));
v.addElement(new String(“Martes”));
v.addElement(new String(“Miercoles”));
v.addElement(new String(“Jueves”));
v.addElement(new String(“Viernes”));
v.addElement(new String(“Sábado”));
v.addElement(new String(“Domingo”));
sesion.setAttribute(“diasSemana”,v);
%>
Recuperar objetos de una sesión
Los datos que se guardan en la sesión permanecen ahí a la espera de ser utilizados. Para ello es necesario realizar el proceso contrario a cuando se graban, comenzando por la recuperación del
objeto de la sesión para empezar a ser tratado.
Para poder realizar este paso se utiliza el método getAttribute() (anteriormente se utilizaba el método getValue(), pero este método se encuentra en desuso), utilizando como argumento el nombre que identifica al objeto que se quiere recuperar.

getAttribute(java.lang,String nombre)

Un ejemplo de recuperación de objetos almacenados en la sesión:
<%
HttpSession sesion=request.getSession();
Sesion.getAttribute(“nombre”);
%>
Cuando este método devuelve el objeto no establece en ningún momento de qué tipo de objeto se trata. Por ello si se conoce previamente el tipo de objeto que puede devolver tras ser recuperado de la sesión es necesario realizar un casting, para convertir el objeto de tipo genérico al objeto exacto que se va a usar. Para realizar esta operación se añade el tipo de objeto al lado de tipo HttpSession que utiliza el método getAttribute() para obtener el objeto que devuelve:

<%
HttpSession sesion=request.getSession();
String nombre=(String)sesion.getAttribute(“nombre”);
out.println(“Contenido de nombre: “+nombre);
%>

 

Si no existe ningún objeto almacenado en la sesión bajo el identificador que se utiliza en el
método getAttribute(), el valor devuelto será null. Lo mejor en
estos casos es adelantarse a los posibles errores que pueda haber.

<%
if(sesion.getAttribute(“nombre”)!=null)
{
String nombre=(String)sesion.getAttribute(“nombre”);
out.println(“Contenido de nombre: “+nombre);
}
%>

En el caso de tipos primitivos deben de ser convertidos a objetos previamente a su integración sesión de tal forma que su proceso de extracción viene a ser similar:

<%
HttpSession sesion=request.getSession();
Integer edad=(Integer)sesion.getAttribute(“edad”);
out.println(“Edad: “+edad.intValue());
%>
En esta ocasión el objeto devuelto y convertido a Integer no es del todo válido ya que es necesario obtener de él el valor entero. Para ello se utiliza el método intValue() que devuelve el
valor que realmente se había guardado previamente en la sesión.

Como se destruye una sesión:

Como se ha visto, los datos almacenados por las sesiones pueden destruirse en tres casos

• El usuario abandona aplicación web (cambia de web o cierra el navegador)
• Se alcanza el tiempo máximo permitido de inactividad de un usuario (timeout).
• El servidor se para o se reincia.

Pero la situación más probable es querer iniciar las sesiones o dar por finalizada una si se ha cumplido una o varias condiciones. En este caso no es necesario esperar a que ocurra alguno
de los tres casos citados anteriormente, ya que mediante el método invalidate() es posible destruir una sesión concreta.
En el siguiente caso la sesión “sesión” se destruye al invocar el método invalidate(); y por la tanto el valor u objeto que está asociado a la misma.
<%
[...]
sesion.invalidate();
%>
Nosotros utilizamos una función que se encontraba en inventario en jsp
 if (!isSession(request) && !op.equals("users")){            
           module = "index.jsp";
 }
La cual deniega y o redirecciona al index en caso de no haber iniciado la sesión.

Ataque “XSS”

Cross-site scripting es un tipo de inseguridad informática o agujero de seguridad típico de las aplicaciones Web, que permite a una tercera parte inyectar en páginas web vistas por el usuario código JavaScript o en otro lenguaje script similar (ej: VBScript), evitando medidas de control como la Política del mismo origen. Este tipo de vulnerabilidad se conoce en español con el nombre de Secuencias de comandos en sitios cruzados.
Para evitar este tipo de ataques, pueden ser usadas diferentes técnicas, la mas comúnmente usada sobre la tecnología JSP es con el uso del api Jsoup el cual permite de manera sencilla filtrar las entradas de datos que pensamos son susceptibles a ataques, para tal fin creamos un filtro que diferenciara entradas “normales” a ataques, por ejemplo:
Stringunsafe = "<p><a href='http://example.com/' onclick='stealCookies()'>Link</a></p>";

Stringsafe = Jsoup.clean(unsafe, Whitelist.basic());

Donde Whitelist.basic() es usado como filtro.

Inyección SQL

Se define la inyección de SQL, como el proceso de insertar código SQL dentro de otro código SQL, con el objetivo de alterar el funcionamiento normal de una sentencia SQL.
Algunas técnicas, comúnmente recomendadas para la filtración de los valores enviados por el usuario son:

• Limitar, siempre que se pueda, el tamaño del valor ingresado. De esta manera, limitamos la cantidad de código SQL que un atacante puede inyectar. En especial si se trata de una consulta anidada.

• No permitir, o en su defecto escapar, todos los caracteres que puedan llegar a ser usados como parte de una inyección SQL: comilla simple (’), punto y coma (;) y caracteres de comentario (/* */ y –).

• Filtrar con expresiones regulares todo lo que ingrese el usuario. Por ejemplo, en un formulario de registro, el campo mail sólo debería aceptar letras en minúsculas, números y un arroba. Al igual que en un número de teléfono sólo deberían aceptarse números.

En el siguiente video se muestra una forma de proteger paginasjsp de las inyecciones sql:
http://vimeo.com/10663349#at=0