Problem mit Login in einem Dynamischen Webprojekt

[Datacron]

Hi,

unser Kunde hat 2 web Anwendungen. Eine in der sich Mitarbeiter und externe Mitarbeiter per login einloggen müssen und die andere ist ohne Login (für Leute die sich aus dem Intranet verbinden).
Der Login funktioniert mit j_security_check und form-login. Funktioniert soweit alles.

Meine Aufgabe ist es aus 2 Anwendugen eine zu machen. Bis jetzt habe ich mir folgendes überlegt. In der web.xml die URL /intranet auf ein weiteres Servlet zu mappen, das den Loginvorgang übernimmt und eine speziellen User mit speziellen Rechten einloggt bzw. einloggen soll.

<servlet>
    <servlet-name>intranet</servlet-name>
    <servlet-class>servlets.IntranetConfiguration</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>intranet</servlet-name>
    <url-pattern>/intranet</url-pattern>
  </servlet-mapping>

Zum Einen frage ich mich nun wie ich den User setze mit seinen Rechten, denn die werden doch mit j_security_check validiert oder? Verstehen ich das falsch?

Die Anzeige und der Inhalt wird je nach Userrechten generiert, also irgendwie muss ich es schaffen den User und die Principals zu setzen.

Hoffentlich kann mir einer weiter helfen.

 

[Datacron]

Ich bin weiter gekommen aber nicht am Ziel:rtfm:

Ich habe gelesen im HttpServletRequest werden bei der Formbased-Authorization, Parameter in einer Map Gespeichert, wie j_username und j_password.

Ich dachte erst, dass bei jedem Seitenaufruf im geschützten Bereich, nun geprüft wird ob die Parameter j_username und j_password in der map vorhanden sind und somit erkannt wird ob man eingeloggt ist, oder nicht.

also habe ich mir einen Filter gebastelt, der bei "/" aufgerufen wird und den request wrappt.
Hier der Wrapper-Aufruf in meinem Filter:

...

@Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)  thows IOException, ServletException {
        HttpServletRequest http_request = (HttpServletRequest) request;  
        HttpServletResponse http_response = (HttpServletResponse) response;
        HttpSession session = http_request.getSession();
        String atr_intra = (String) session.getAttribute("intranet");
        
        if(atr_intra != null && atr_intra.equals("true")) {
            additionalParams.put("j_username", new String[] { "intranet_user" });
            additionalParams.put("j_password", new String[] { "test" });
            HttpServletRequest myRequest = new MyRequestWrapper(http_request, additionalParams);
            myRequest.getParameterMap();
            http_request.getRequestDispatcher("/dataquery.do").forward(myRequest, response);
        } else {                
            http_response.sendRedirect(http_request.getRequestURI() + "dataquery.do");    
        }

und hier mein RequestWrapper:

public class MyRequestWrapper extends HttpServletRequestWrapper {

    private final Map<String, String[]> modifiableParameters;
    private Map<String, String[]> allParameters;

    public MyRequestWrapper(HttpServletRequest request, Map<String, String[]> additionalParams) {
        super(request);
        modifiableParameters = new HashMap<String, String[]>();
        modifiableParameters.putAll(additionalParams);        
    }
    
    @Override
    public String getParameter(String name) {
        String[] strings = getParameterMap().get(name);
        if (strings != null)
        {
            return strings[0];
        }
        return super.getParameter(name);
    }

    @SuppressWarnings("unchecked")
    @Override
    public Map<String, String[]> getParameterMap() {
        allParameters = new HashMap<String, String[]>();
        allParameters.putAll(super.getParameterMap());
        allParameters.putAll(modifiableParameters);   
        return Collections.unmodifiableMap(allParameters);
    }

    @Override
    public Enumeration<String> getParameterNames()
    {
        return Collections.enumeration(getParameterMap().keySet());
    }

    @Override
    public String[] getParameterValues(String name)
    {
        return getParameterMap().get(name);
    }
        
    @Override
    public String getRemoteUser() {
       String remoteUser = super.getRemoteUser();
       if(remoteUser == null) {           
           return "intranet_user";
       }
        return super.getRemoteUser();
    }
    
}

der Wrapper fügt also zur eigentlichen Liste meine j_username und j_password Daten hinzu und der Filter forwardet dann meine request mit der eigentlichen response.

Ergebnis:
Es hat den Anschein zu funktionieren, aber nur bei der ersten Query. Daran ist der forward Schuld, er umgeht den j_security_chek in der dataquery.jsp. Sobald ich aber einen weiteren Aufruf starte muss ich mich einloggen.
Ich habe nun rausbekommen das der j_security_check vor allen Filtern aufgerufen wird und einen Flag setzt ob eingeloggt oder nicht wurde. Es ist also unmöglich auf diese Art und Weise den j_secuirty_check zu manipulieren oder?

Nun Frage ich mich soll ich bei der Formbased Authorization bleiben?
Was soll ich statt dessen für meinen Fall einbinden?

Ich würde mich über eure Erfahrungen und Hilfe freuen.:idea:
Grüße