Autenticación Web

Estoy desarrollando una aplicación web, y tengo una gran duda al momento de manejar la autenticación actualmente luego que un usuario se logea hago un request.getSession().setAttribute(user, user), y luego cuando necesito el usuario hago un getAttribute(user); lo que quiero es que el usuario se loguee, y según eso pueda acceder a otras paginas donde solo lo haría un usuario logeado; había pensado encriptar el nombre de usuario y tenerlo en sesión y usarlo asi pero no estoy seguro si es correcto; me podrían por favor indicar si esta forma es correcta o existe otro abordaje que sea mejor para manejar el tema de autenticación - autorización.

También he revisado Spring Security y Apache Shiro, pero me gustaría implementarlo yo mismo y que esto sea seguro.

Gracias.

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de neko069

Es para tu trabajo? o es por

Es para tu trabajo? o es por hobby? bien puedes revisar los fuentes de ambos proyectos, para saber cómo funciona.
Si es algo de tu trabajo, y te están pagando para programar negocio, para qué te desgastas en programar infraestructura, pudiendo aprovechar el tiempo en programar tareas que tienen mayor prioridad.
Nada más no vayas a salir como un tipo de aquí que dijo que Hibernate se le hacía muy complicado, y por ello quería implementar su propio ORM; tú vas a querer implementar tu propio módulo de seguridad.

Hibernate es muy complicado, voy a crear mi propio ORM

por aprender

Para aprender por eso tengo pensando hacer algo sencillo, básico pero no dejando de lado la intención, que sea seguro

Imagen de ingscjoshua

podrias!!

hola pues mira podrias implementar un filter y asi validar si el usario ha iniciado sesion no necesitas encriptalo con saber si tiene o no sesison bastaria
para que lo regreses si el usuario tiene sesion ya de ahi incloso podrias limitar el accesos a ciertas pantallas dependiendo del perfil en un rato cuando llegue a casa busco el ejemplo y te lo pongo para que te guies yo te recomiendo que si estas empezando a aprender veas lo basico y vayas avanzando lento pero seguro si ya esta chambenado como decian mis profres de la universidad el cafe es barato y las noches son largas y pues a estudiar..

gracias

gracias

Imagen de ingscjoshua

lo prometido es deuda

hola te voy anexando el ejemplo esto se pone en el web.xml

<session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    <filter>
        <filter-name>struts</filter-name>
        <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
    </filter>
    <filter>
        <filter-name>SecurityFilter</filter-name>
        <filter-class>com.seguridad.filter.SecurityFilter</filter-class> <!-- aqui va el nombre de la calse que tiene implementado el filtro-->
    </filter>
    <filter-mapping>
        <filter-name>SecurityFilter</filter-name>
        <url-pattern>/*</url-pattern>
        <dispatcher>REQUEST</dispatcher>
    </filter-mapping>
    <filter-mapping>
        <filter-name>struts</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
Imagen de ingscjoshua

clase del flitro

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.seguridad.filter;

import com.seguridad.DTO.UsuarioDTO;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

/**
 *
 * @author Josue
 */

public class SecurityFilter implements Filter {
   
    private static final boolean debug = false;
    private FilterConfig filterConfig = null;
   
    /**
     *
     * @param request The servlet request we are processing
     * @param response The servlet response we are creating
     * @param chain The filter chain we are processing
     *
     * @exception IOException if an input/output error occurs
     * @exception ServletException if a servlet error occurs
     */

    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain)
            throws IOException, ServletException {
       
        RequestWrapper wrappedRequest = new RequestWrapper((HttpServletRequest) request);
        ResponseWrapper wrappedResponse = new ResponseWrapper((HttpServletResponse) response);
       
        UsuarioDTO usuario = ( UsuarioDTO ) wrappedRequest.getSession().getAttribute( "user" );
        String url = wrappedRequest.getRequestURI();
       
        String contextName = request.getServletContext().getContextPath();
        Throwable problem = null;
       
        try {
           
            boolean redirect = true;
           
            if( !url.toLowerCase().endsWith( ".css" )
                    && !url.toLowerCase().endsWith( ".png" )
                    && !url.toLowerCase().endsWith( ".gif" )
                    && !url.toLowerCase().endsWith( ".ico" )
                    && !url.toLowerCase().endsWith( ".jpg" )
                    && !url.toLowerCase().endsWith( ".js" )//
                    && !url.equals( contextName + "/login.action")
                    && !url.equals( contextName + "/closeSession.action")
                    && !url.equals( contextName + "/mail.action")
                    && !url.equals( contextName + "/enviaMail.action" )){
               
                if( ( usuario == null || usuario.getIdUsuario().isEmpty() ) && !url.equals( contextName + "/" ) ){
                    redirect = true;
                } else {
                    redirect = false;
                }
               
            } else {
                redirect = false;
            }
           
            if( redirect ){
                request.getServletContext().getRequestDispatcher( "/accessDenied.jsp" ).forward(request, response);
            } else {
                chain.doFilter( wrappedRequest, wrappedResponse );
            }
           
        } catch (Exception t) {
           
            problem = t;
            t.printStackTrace();
           
            if (problem instanceof ServletException) {
                throw (ServletException) problem;
            }
            if (problem instanceof IOException) {
                throw (IOException) problem;
            }
            sendProcessingError(problem, response);
           
        }
       
    }

    public void destroy() {        
    }

    /**
     * Init method for this filter
     */

    public void init(FilterConfig filterConfig) {        
       
    }
   
    private void sendProcessingError(Throwable t, ServletResponse response) {
        String stackTrace = getStackTrace(t);        
       
        if (stackTrace != null && !stackTrace.equals("")) {
            try {
               
                response.setContentType("text/html");
                PrintStream ps = new PrintStream(response.getOutputStream());
                PrintWriter pw = new PrintWriter(ps);                
                pw.print("<html>\n<head>\n<title>Error</title>\n</head>\n<body>\n"); //NOI18N

                // PENDING! Localize this for next official release
                pw.print("<h1>The resource did not process correctly</h1>\n<pre>\n");                
                pw.print(stackTrace);                
                pw.print("</pre></body>\n</html>"); //NOI18N
                pw.close();
                ps.close();
                response.getOutputStream().close();
               
            } catch (Exception ex) {
            }
           
        } else {
           
            try {
               
                PrintStream ps = new PrintStream(response.getOutputStream());
                t.printStackTrace(ps);
                ps.close();
                response.getOutputStream().close();
               
            } catch (Exception ex) {
            }
           
        }
       
    }
   
    public static String getStackTrace(Throwable t) {
        String stackTrace = null;
        try {
            StringWriter sw = new StringWriter();
            PrintWriter pw = new PrintWriter(sw);
            t.printStackTrace(pw);
            pw.close();
            sw.close();
            stackTrace = sw.getBuffer().toString();
        } catch (Exception ex) {
        }
        return stackTrace;
    }
   
    public void log(String msg) {
        filterConfig.getServletContext().log(msg);        
    }

    /**
     * This request wrapper class extends the support class HttpServletRequestWrapper,
     * which implements all the methods in the HttpServletRequest interface, as
     * delegations to the wrapped request.
     * You only need to override the methods that you need to change.
     * You can get access to the wrapped request using the method getRequest()
     */

    class RequestWrapper extends HttpServletRequestWrapper {
       
        public RequestWrapper(HttpServletRequest request) {
            super(request);
        }
        // You might, for example, wish to add a setParameter() method. To do this
        // you must also override the getParameter, getParameterValues, getParameterMap,
        // and getParameterNames methods.
        protected Hashtable localParams = null;
       
        public void setParameter(String name, String[] values) {
            if (debug) {
                System.out.println("SecurityFilter::setParameter(" + name + "=" + values + ")" + " localParams = " + localParams);
            }
           
            if (localParams == null) {
                localParams = new Hashtable();
                // Copy the parameters from the underlying request.
                Map wrappedParams = getRequest().getParameterMap();
                Set keySet = wrappedParams.keySet();
                for (Iterator it = keySet.iterator(); it.hasNext();) {
                    Object key = it.next();
                    Object value = wrappedParams.get(key);
                    localParams.put(key, value);
                }
            }
            localParams.put(name, values);
        }
       
        @Override
        public String getParameter(String name) {
            if (debug) {
                System.out.println("SecurityFilter::getParameter(" + name + ") localParams = " + localParams);
            }
            if (localParams == null) {
                return getRequest().getParameter(name);
            }
            Object val = localParams.get(name);
            if (val instanceof String) {
                return (String) val;
            }
            if (val instanceof String[]) {
                String[] values = (String[]) val;
                return values[0];
            }
            return (val == null ? null : val.toString());
        }
       
        @Override
        public String[] getParameterValues(String name) {
            if (debug) {
                System.out.println("SecurityFilter::getParameterValues(" + name + ") localParams = " + localParams);
            }
            if (localParams == null) {
                return getRequest().getParameterValues(name);
            }
            return (String[]) localParams.get(name);
        }
       
        @Override
        public Enumeration getParameterNames() {
            if (debug) {
                System.out.println("SecurityFilter::getParameterNames() localParams = " + localParams);
            }
            if (localParams == null) {
                return getRequest().getParameterNames();
            }
            return localParams.keys();
        }        
       
        @Override
        public Map getParameterMap() {
            if (debug) {
                System.out.println("SecurityFilter::getParameterMap() localParams = " + localParams);
            }
            if (localParams == null) {
                return getRequest().getParameterMap();
            }
            return localParams;
        }
    }

    /**
     * This response wrapper class extends the support class HttpServletResponseWrapper,
     * which implements all the methods in the HttpServletResponse interface, as
     * delegations to the wrapped response.
     * You only need to override the methods that you need to change.
     * You can get access to the wrapped response using the method getResponse()
     */

    class ResponseWrapper extends HttpServletResponseWrapper {
       
        public ResponseWrapper(HttpServletResponse response) {
            super(response);            
        }

    }
}

Imagen de ingscjoshua

Implementando el ejemplo

UsuarioDTO user = (UsuarioDTO) ServletActionContext.getRequest().getSession().getAttribute("user"); // bajamos el usuario de la session

//validacion de seguridad  aqui valido que el usuario exista y que se tenga acceso a la pantalla segun ell perfil
             if (securityBO.allowAccess(user, ArticuloAction.ID_OPCION_MENU)) {
}
else {
                forward = "accessDenied";
            }

Espero que te sirva yo lo implemente en Struts2
si se te complica o algo asi me dices y te subo un ejemplo al github

muchas gracias, entonces ya

muchas gracias, entonces ya sé que estaba yendo por buen camino :)

logout

Me podrías decir por favor que necesito para hacer el logout?, pense que haciendo un request.getSession().invalidate(); sería suficiente sin embargo aun tiene al usuario en session cuando hago un logout

@Controller
public class Logout {
        @RequestMapping(value = "/logout", method = RequestMethod.GET)
        public String doLogout(HttpServletRequest request, HttpServletResponse response) {
                request.getSession(false).setAttribute(USER, null);
                request.getSession().invalidate();
               
                response.setHeader("Cache-Control", "no-cache");
                response.setHeader("Cache-Control", "no-store");
                response.setDateHeader("Expires", 0);
                response.setHeader("Pragma", "no-cache");
                return "redirect:/index";
        }
Imagen de ingscjoshua

ah muy sencillo

yo generalmente hago esto
request.getSession().removeAttribute("usuario");

lo que pasa es que efectivamente la sesion ya no es valida pero los objetos de sesion siguen ahi hasta q muera la sesion por lo que en este sentido debes tener mucho cuidado de no dejar cosas en la sesion si no las vas a utilizar.

Es un gusto poder ser util y ayudar da mucho gusto jejejeje XD espero esto te sirva

ya habia intentado eso al

ya habia intentado eso al comienzo y seguia teniendo session al usuario, voy a continuar con ese tema ahora, gracias otra vez por la ayuda :)

Imagen de ingscjoshua

mmm haber lo que yo te pase

lo que te pase elimina el atrbuto usuario es decir ya no podras hacaer uso de el en ningun momento
entonces si tu bajas la sesion y le das un get Usuario y si preguntas que si es diferente de null como no lo es te daras cuenta que cerrarron la sesion no?

Imagen de ingscjoshua

ejemplo

esto es como yo lo tenia implementado

public class CloseSession extends ActionSupport {
   
    public String execute(){
       
        ServletActionContext.getRequest().getSession().invalidate();
        return "success";
       
    }
   
}

Imagen de ingscjoshua

mm estas usando springmvc?

mmmmm nose si springmvc lo maneje diferente dejame buscarte un ejemplo haber si te sirve yo no he usado springmvc

si

si estoy usando spring mvc, el problema ese era por un error mio, no estaba llamando al logout; bueno eso, gracias.