Tomcat7 cifrare password per autenticazione basic web application

Per abilitare l'autenticazione BASIC (con prompt del browser per username e password) in una web application occorre agire sul web.xml e quindi sull'application server.
In Tomcat è possibile utilizzare il file tomcat-users.xml presente nella directory conf di Tomcat.
Ad esempio supponiamo di avere il seguente codice nel web.xml della nostra web app:

 <login-config>
    <auth-method>BASIC</auth-method>
    <realm-name>Richiesta autenticazione per gestione utenze</realm-name>
  </login-config>
  <security-constraint>
    <web-resource-collection>
      <web-resource-name>restricted methods</web-resource-name>
      <url-pattern>/index.jsf</url-pattern>
      <http-method>GET</http-method>
      <http-method>POST</http-method>
    </web-resource-collection>
    <auth-constraint>
      <role-name>APP_ADMIN</role-name>
    </auth-constraint>
  </security-constraint>
  <security-role>
    <role-name>APP_ADMIN</role-name>
  </security-role>

Quindi nel Tomcat devono essere definite le credenziali dell'utente APP_ADMIN.

Tipicamente nel file tomcat-users.xml si inseriranno le seguenti indicazioni:

<role rolename="LEASING_ADMIN"/>
  <user password="qawsedrf" roles="APP_ADMIN" username="master"/>

Come possiamo vedere l'inconveniente di questo approccio è che la password è memorizzata in chiaro dentro Tomcat.

E' possibile cifrare la password utilizzando i seguenti algoritmi di cifratura

• SHA;
• MD2;
• MD5 

Si può utilizzare l'utility digest.bat per cifrare la password (digest.sh su sistemi linux).
Digitando quindi da prompt di dos il comando

digest.bat -a md5 qawsedrf  

premendo invio si ottiene la risposta

qawsedrf:d1c2dcfcbfd41ce1103a25475b64f7a5

Quindi dobbiamo inserire la password cifrata al posto di quella in chiaro nel tomcat-users.xml.

Ora dobbiamo comunicare a Tomcat che la modalità di controllo password deve passare per un hash md5 della password digitata dall'utente.

Nel file conf/server.xml occorre cercare il Realm UserDataBaseRealm ed inserire l'attributo digest="md5" in questo modo:

<Realm className="org.apache.catalina.realm.LockOutRealm">
    <!-- This Realm uses the UserDatabase configured in the global JNDI
         resources under the key "UserDatabase".  Any edits
         that are performed against this UserDatabase are immediately
         available for use by the Realm.  -->
    <Realm className="org.apache.catalina.realm.UserDatabaseRealm" resourceName="UserDatabase" digest="md5"/>
</Realm>

Gestire sessione non valida con JSF 2.0

Quando in JSF la sessione scade si incappa nella tipica eccezione di tipo

javax.faces.application.ViewExpiredException

Questo errore si verifica quando l'utente richiede una pagina ma la sessione è ormai scaduta, per cui non si riesce a ricostruire l'alberatura degli oggetti propria di JSF.

Un modo molto semplice per ovviare a questa eccezione è quello di dichiararla nel web.xml in questo modo:

<error-page>
    <exception-type>javax.faces.application.ViewExpiredException</exception-type>
    <location>/viewExpired.xhtml</location>
</error-page>

Il problema di questo approccio è che non gestisce i casi di chiamate ajax, ed essendo ormai il supporto di ajax il comportamento base di tutti i componenti di JSF 2.0 la dichiarazione nel web.xml non basta.

E' necessario quindi creare una classe che estenda

javax.faces.context.ExceptionHandlerWrapper

in questo modo

package it.exceptionHandler;
import it.util.Costanti;
import it.util.Utility;
import java.io.IOException;
import java.util.Iterator;
import javax.faces.FacesException;
import javax.faces.application.ViewExpiredException;
import javax.faces.context.ExceptionHandler;
import javax.faces.context.ExceptionHandlerWrapper;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.event.ExceptionQueuedEvent;
import org.apache.log4j.Logger;
public class ViexExpiredExceptionHandler extends ExceptionHandlerWrapper {
 private static final Logger log=Logger.getLogger(Costanti.LOGGER);
 private ExceptionHandler parent;
 public ViexExpiredExceptionHandler(ExceptionHandler parent){
  this.parent=parent;
 }

 @Override
 public ExceptionHandler getWrapped() {
  return this.parent;
 }
 @Override
 public void handle() throws FacesException{
   FacesContext facesContext = FacesContext.getCurrentInstance();
         for (Iterator<ExceptionQueuedEvent> iter = getUnhandledExceptionQueuedEvents().iterator(); iter.hasNext();) {
           Throwable exception = iter.next().getContext().getException();

if (exception instanceof ViewExpiredException) {


    final ExternalContext externalContext = facesContext
            .getExternalContext();

    try {


        facesContext.setViewRoot(facesContext.getApplication()
                .getViewHandler()
                .createView(facesContext, "/viewExpired.jsf"));     
        externalContext.redirect("viewExpired.jsf");             
        facesContext.getPartialViewContext().setRenderAll(true);
        facesContext.renderResponse();

    } 
    catch(IOException ioex){
     log.error(Utility.stackToString(ioex));
    }
    finally {
        iter.remove();
    }
}

}

getWrapped().handle();
 }

}

Quindi occorre creare una classe che estenda

javax.faces.context.ExceptionHandlerFactory e che faccia l'override del metodo getExceptionHandler tornando il nostro Handler personalizzato che gestisce la ViewExpiredException.

package it.exceptionHandler;
import javax.faces.context.ExceptionHandler;
import javax.faces.context.ExceptionHandlerFactory;
public class MyExceptionHandlerFactory extends ExceptionHandlerFactory {
    private ExceptionHandlerFactory parent;
    public MyExceptionHandlerFactory(ExceptionHandlerFactory parent){
     this.parent=parent;
    }
 @Override
 public ExceptionHandler getExceptionHandler() {
  ExceptionHandler result=parent.getExceptionHandler();
  result=new ViexExpiredExceptionHandler(result);
  return result;
 }

}

Quindi nel faces-config.xml dobbiamo dichiarare questa factory in questo modo:

<factory>
<exception-handler-factory>it.exceptionHandler.MyExceptionHandlerFactory</exception-handler-factory>
</factory>