JavaServerFaces mit JAAS absichern (Java Authentication and Authorization Service)

Posted on by Stefan Draeger

In diesem Tutorial möchte ich erläutern, wie man eine Java Server Faces 2.2 Webanwendung mit JAAS absichert.

JSF Logindialog mit JAAS
JSF Logindialog mit JAAS

Was ist JAAS?

Der Java Authentication and Authorization Service (kurz JAAS) gibt dem Java Entwickler die Möglichkeit über eine API Benutzeranmeldungen vornehmen zu lassen.
Ein großer Vorteil bei der Implementierung von JAAS ist dass, das Authentifizierungsverfahren extern konfiguriert wird und dadurch einfach ausgetauscht werden kann ohne das Änderungen an der eigentlichen Anwendung entfallen.

Im nachfolgenden werde ich nun erläutern, wie ich eine einfache JSF 2.2 Webanwendung mit JAAS für den Apache Tomcat 8.5.38 eingerichtet habe.

Wie in meinen JSF Tutorials bisher bekannt, benötigt man zusätzlich die Entwicklungsumgebung Eclipse. Als ersten Schritt richten wir also nun ein einfaches JSF Projekt in Eclipse ein. Wer diesen Schritt überspringen möchte, kann sich unter nachfolgendem Link ein leeres Eclipseprojekt für dieses Tutorial herunterladen.

JavaServerFaces mit JAAS absichern – leeres Eclipse ProjektHerunterladen

Principals

Zu jedem Benutzer (welcher sich anmelden möchte) muss es neben einem Benutzernamen und Passwort auch eine Rolle gegeben.
Dieses Rechte & Rollenkonzept ist vom Betriebssystem Unix / Linux bekannt und wird in eine Webanwendung welche mit
JAAS abgesichert werden soll mit java.security.Principal erledigt.

Zunächst benötigen wir ein Principal für einen Benutzer und eine Rolle. Da beide Klassen den gleichen Code beinhalten werden erzeugen wir uns
eine gemeinsame Basisklasse “PrincipalImpl.java”

package de.draegerit.jsfjaasauth;

import java.security.Principal;

public class PrincipalImpl implements Principal {

   private String name;
   
   public PrincipalImpl(String name) {
      super();
      this.name = name;
   }

   @Override
   public String getName() { return this.name; }

   public void setName(String name) { this.name = name; }
}

Nun noch die beiden Klassen “UserPrincipla.java” und “RolePrincipal.java”.

package de.draegerit.jsfjaasauth;

public class UserPrincipal extends PrincipalImpl{

   public UserPrincipal(String name) {
      super(name);
   }
}
package de.draegerit.jsfjaasauth;

public class RolePrincipal extends PrincipalImpl {

   public RolePrincipal(String name) {
      super(name);
   }
}

LoginModule

Für den Authentifizierungsprozess benötigen wir nun noch eine Klasse, welche diesen für uns regelt. Diese Klasse muss das Interface javax.security.auth.spi.LoginModule implementieren.

Das Interface LoginModule enthält 5 abstrakte Methoden

void initialize(Subject subject, CallbackHandler callbackHandler, Map<String,?> sharedState, Map<String,?> options);
boolean login() throws LoginException;
boolean commit() throws LoginException;
boolean abort() throws LoginException;
boolean logout() throws LoginException;

Wir müssen also zunächst die oben genannten Methoden implementieren. Zusätzlich benötigen wir noch einige Felder welche wir in diesen Methoden befüllen bzw. abfragen.

private static final String PASSWORD = "password";
private static final String LOGIN = "login";

private static final String USER_GROUP_ADMIN = "admin";

private Subject subject;
private UserPrincipal userPrincipal;
private RolePrincipal rolePrincipal;
private String login;
private List<String> userGroups = Collections.emptyList();
private CallbackHandler callbackHandler;

private Hashtable<String, String> userTable;
private String userFileName;

Die initialize Methode wird im ersten Schritt aufgerufen, wenn die Adresse geladen wird.

@Override
public void initialize(Subject subject, CallbackHandler callbackHandler, Map<String, ?> sharedState, Map<String, ?> options) {
   this.callbackHandler = callbackHandler;
   this.subject = subject;
   this.userFileName = (String) options.get("userfile");
   try {
      userTable = readUserFile();
   } catch (LoginException e) {
      e.printStackTrace();
   }
}

In der JAAS Konfiguration wird eine Datei mit einer Liste von Benutzer/Passwort Kombinationen hinterlegt (dazu aber später mehr), diese Datei wird in dem Schlüssel Wertepaar “userfile” hinterlegt.

benutzer123:AF88A0AE641589B908FA8B31F0FCF6E1

Diese Datei lesen wir ein und hinterlegen die Daten in einer HashTable.

private Hashtable<String, String> readUserFile() throws LoginException {
   Hashtable<String, String> result = new Hashtable<>();
   try (BufferedReader userFile = new BufferedReader(new FileReader(userFileName));) {
      String line;
      while ((line = userFile.readLine()) != null) {
         String[] splittedLine = line.split(":");
         result.put(splittedLine[0], splittedLine[1]);
      }
    } catch (IOException e) {
       throw new LoginException("Fehler beim öffnen der Datei " + userFileName);
    }
    return result;
}

Hier wird eine Hashtable verwendet da diese synchronized ist.

@Override
public boolean login() throws LoginException {
   Callback[] callbacks = new Callback[] { new NameCallback(LOGIN), new PasswordCallback(PASSWORD, true) };
   try {
      callbackHandler.handle(callbacks);
      String name = ((NameCallback) callbacks[0]).getName();
      String password = String.valueOf(((PasswordCallback) callbacks[1]).getPassword());
      if (!userTable.isEmpty()) {
         String regUserPw = userTable.get(name);
         if (regUserPw == null) {
            throw new LoginException("Benutzer [" + name + "] wurde nicht gefunden!");
         } else if (regUserPw != null && regUserPw.equals(generateHashValue(password))) {
            login = name;
            userGroups = new ArrayList<String>();
            userGroups.add(USER_GROUP_ADMIN);
            return true;
         } else {
            throw new FailedLoginException("Authentifizierung fehlgeschlagen!");
         }
       } else {
          throw new LoginException("Es wurden keine Benutzer eingerichtet!");
       }
   } catch (IOException | UnsupportedCallbackException | NoSuchAlgorithmException e) {
      throw new LoginException(e.getMessage());
   }
}

Da das Passwort als MD5 Hash Wert hinterlegt wurde, muss das eingegebene Passwort zunächst einmal in ein MD5 Hash Wert umgewandelt werden. Hierzu kann man eine Bibliothek wie Apache Commons Codec verwenden oder aber die Java Boardmittel welche für diese kleine Aufgabe völlig ausreichen.

private String generateHashValue(String pw) throws NoSuchAlgorithmException, UnsupportedEncodingException {
   MessageDigest md = MessageDigest.getInstance("MD5");
   md.update(pw.getBytes());
   byte[] digest = md.digest();
   return DatatypeConverter.printHexBinary(digest);
}

Wenn bei der Authentifizierung ein Fehler auftritt oder aber der Benutzer nicht berechtigt wurde, so muss in jedem Fall eine Exception vom Typ javax.security.auth.login.LoginException geworfen werden.

@Override
public boolean commit() throws LoginException {
   userPrincipal = new UserPrincipal(login);
   subject.getPrincipals().add(userPrincipal);

   for (String groupName : userGroups) {
      rolePrincipal = new RolePrincipal(groupName);
      subject.getPrincipals().add(rolePrincipal);
   }
   return true;
}

@Override
public boolean abort() throws LoginException {
   return false;
}

@Override
public boolean logout() throws LoginException {
   subject.getPrincipals().remove(userPrincipal);
   subject.getPrincipals().remove(rolePrincipal);
   return true;
}

JAAS Konfiguration

Im letzten Schritt werden wir nun den Ordner bestimmen welcher durch die oben durchgeführte Konfiguration geschützt werden soll.

Projektstruktur - JSF JAAS Authentifizierung
Projektstruktur – JSF JAAS Authentifizierung

Wir legen also nun einen Ordner “admin” unter “webapps\” an und fügen eine Datei namens “index.xhtml” in diese ein.

<html>
   <body>
      <h1>Welcome Admin!</h1>
   </body>
</html>

Des Weiteren muss der Ordner “META-INF” unter “webapps\” hinzugefügt werden und dort wird die Konfiguration in der Datei “context.xml” eingefügt.

<?xml version="1.0" encoding="UTF-8"?>
<Context>
  <Realm className="org.apache.catalina.realm.JAASRealm" 
    appName="JSFJAASAuthLogin"
    userClassNames="de.draegerit.jsfjaasauth.UserPrincipal"
    roleClassNames="de.draegerit.jsfjaasauth.RolePrincipal" />
</Context>

Zusätzlich wird die Datei “jaas.config” im Apache Tomcat “conf” Ordner abgelegt.

JSFJAASAuthLogin {
    de.draegerit.jsfjaasauth.LoginModuleImpl required debug=true userfile="D:\\Software\\apache-tomcat-8.5.38\\conf\\userdb";
};

Nun muss diese Datei noch als Parameter beim starten des Tomcats übergeben werden.

-Djava.security.auth.login.config=="D:\Software\apache-tomcat-8.5.38\conf\jaas.config"

redirect auf den Adminbereich

Wenn die Webanwendung über http://localhost:8080/JSF-JAAS-Auth/ geöffnet wird, soll ein redirect auf den Adminbereich erfolgen, dieses kann man im Headbereich der XHTML Datei wie folgt erledigen:

<!DOCTYPE html>
<html 
   xmlns="http://www.w3.org/1999/xhtml"
   xmlns:f="http://java.sun.com/jsf/core"
   xmlns:h="http://java.sun.com/jsf/html"
   xmlns:c="http://xmlns.jcp.org/jsp/jstl/core">
<h:head>
   <f:metadata>
      <f:viewAction action="/admin/index?faces-redirect=true" />
   </f:metadata>
</h:head>
<h:body>
   <h2>JSF-JAAS-Auth</h2>
</h:body>
</html>

Download

Hier nun das fertige Eclipse Projekt zum download.

JavaServerFaces mit JAAS absichern – fertiges Eclipse ProjektHerunterladen

In der Zip Datei ist die Datei “jaas.config” enthalten. Diese Datei muss in das Verzeichnis “conf” des Apache Tomcat kopiert werden.

Quellenangabe

Als Grundlage für dieses Tutorial habe ich folgende Quellen genutzt

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert