#apachetomcat

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

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ötig 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.  

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 sharedState, Map 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 userGroups = Collections.emptyList(); private CallbackHandler callbackHandler; private Hashtable 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 sharedState, Map 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 readUserFile() throws LoginException { Hashtable 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, splittedLine); } } 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).getName(); String password = String.valueOf(((PasswordCallback) callbacks).getPassword()); if (!userTable.isEmpty()) { String regUserPw = userTable.get(name); if (regUserPw == null) { throw new LoginException("Benutzer wurde nicht gefunden!"); } else if (regUserPw != null && regUserPw.equals(generateHashValue(password))) { login = name; userGroups = new ArrayList(); 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 jedemfall 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 Wir legen also nun einen Ordner "admin" unter "webapps\" an und fügen eine Datei namens "index.xhtml" in diese ein.

Welcome Admin!

Des Weiteren muss der Ordner "META-INF" unter "webapps\" hinzugefügt werden und dort wird die Konfiguration in der Datei "context.xml" eingefügt. 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:

JSF-JAAS-Auth

Download

Hier nun das fertige Eclipse Projekt zum download.   In der Zip Datei ist die Datei "jaas.config" enthalten. Diese Datei muss in das Verzeichnis "conf" des Apache Tomcat kopiert werden.

Quellenangabe

In diesem Beitrag möchte ich erläutern wie man ein JavaServerFaces 2.2 Projekt mit Apache Maven und Eclipse einrichtet. Ihr benötigt folgende Tools: Oracle Java 8 JDK Eclipse IDE for Java EE Developers Apache Maven Apache Tomcat 7.0 Wie man Apache Maven einrichtet, habe ich bereits im Tutorial Maven: Einrichten von Apache Maven erläutert. Wichtig ist das die Umgebungsvariable "JAVA_HOME" zu einem Oracle Java JDK verweist. 

Einrichten von Eclipse

Nachdem Eclipse heruntergeladen und in einen beliebigen Ordner entpackt wurde, kann das Programm über "eclipse.exe" gestartet werden.  Troubleshooting Sollte beim starten die Fehlermeldung mit dem Fehlercode 13 erscheinen so muss in der Datei "eclipse.ini" der Pfad zur javaw.exe gesetzt werden.

Eclipse Fehlercode 13 Die Datei "eclipse.ini" liegt im selben Ordner wie die Datei "eclipse.exe" und wird mit einem beliebigen Texteditor geöffnet.  Es muss nun nach der Wert "-startup" folgende Zeile eingefügt werden: -vm C:/Program Files/Java/jdk1.8.0_152/bin/javaw.exe Auf meinem System ist Oracle Java unter dem oben genannten Pfad installiert sollte dieses bei euch anders sein muss dieser Pfad natürlich angepasst werden. Erstellen eines Workspaces Eclipse arbeitet mit Workspaces, in diese Verzeichnisse werden die Einstellungen sowie die Projekte abgelegt. Man kann beliebig viele Workspaces anlegen. 

Eclipse - erstellen eines Workspaces

Einrichten von Apache Maven (in Eclipse)

Als ersten Schritt wollen wir Apache Maven einrichten. Ich setze voraus das Apache Maven, entpackt und die Umgebungsvariable JAVA_HOME auf ein JDK zeigt. Navigieren wir also über das Hauptmenü "Window" > "Preferences" zu den Einstellungen. Dort öffnen wir im Baum den Pfad "Maven" (1) > "Installations" (2). Es sollte hier die Vorauswahl "EMBEDDED" markiert sein (der Haken ist gesetzt).

Einrichten von Apache Maven Wählen wir also nun die Schaltfläche "Add" (3). Und im neuen Dialog "Directory..." 

Einrichten Apache Maven in Eclipse Nun navigiert man zu dem entpackten Apache Maven und wählt dort den Ordner aus, der Dialog wird mit der Schaltfläche "Ordner auswählen" bestätigt. Und der Dialog "New Maven Runtime" mit der Schaltfläche "Finish" verlassen. Es muss im letzten Schritt noch der Haken bei der neu hinzugefügten Maven Version gesetzt werden und dann die Einstellungen mit "Apply and Close" übernommen und geschlossen.

Erstellen eines Web-Projektes mit Apache Maven

Wollen wir nun unser Web-Projekt mit Apache Maven erstellen, dazu navigieren wir über "File" > "New" > "Maven Project". In diesem Dialog setzen wir den Haken bei "Create a simple project ..." (1) und wählen die Schaltfläche "Next >" (2).

Erstellen eines Apache Maven Projektes (Schritt 1) Im nächsten Dialog werden die Metadaten zu dem neuen Maven Projekt gesetzt. die "Group Id" ist eine Id für das Projekt und folgt den Regeln für die Beschreibung von Packages, die "Artifact Id" wird für die Benennung des Projektes verwendet, des Weiteren wird dieser Bezeichner für das erstellen eines JAR's bzw. unserer WAR Datei verwendet, aus der Auswahlliste "Packaging" wird der Eintrag "war" ausgewählt als "Name" wird der gleiche Wert gewählt wie auch die "Artifact Id"

setzen der Metadaten zum neuen Apache Maven Projekt Die gesetzten Werte werden mit der Schaltfläche "Finish" bestätigt und Eclipse wird das Projekt erstellen und bauen. Nachdem das Projekt erstellt und gebaut wurde, wird ein Fehler und einige Warnungen angezeigt.

Eclipse - Fehler und Warnungen nach dem ersten Bauen Als erstes kümmern wir uns um den Fehler. Um diesen Fehler zu beheben, muss man in den "Project Facets" einige Einstellungen setzen. Dabei ist die Reihenfolge sehr wichtig.  Als erstes wird der Haken bei "Dynamic Web Module" entfernt und die Schaltfläche "Apply" betätigt, danach wird nun der Haken wieder gesetzt und erneut die Schaltfläche "Apply" betätigt".  Es wurde nun der Ordner "WebContent" erzeugt. In diesen neuen Ordner wird, wie der Name es erahnen lässt die Dateien für die Webansicht abgelegt. Nun werden noch die Einstellungen für JavaServerFaces 2.2 gesetzt, dazu wird aus der Auswahlliste für die "Configuration" der Eintrag "JavaServer Faces v2.2 Project".

Auswahl der Konfiguration für ein JSF 2.2 Projekt Es werden nun automatisch die Einstellungen für ein JSF 2.2 Projektes gesetzt. Für ein JSF Projekt wird die Datei "faces-config.xml" benötigt diese können wir anlegen lassen in dem wir die Hinweismeldung im unteren Bereich des Dialoges bestätigen.

Hinweismeldung zur Konfiguration von JSF Nach einem klick auf diesen Link wird der Dialog "Modify Faceted Project" geöffnet.  Als "Type" wählen wir "Disable Library Configuration" (1) und bestätigen diese Auswahl mit der Schaltfläche "OK" (2).

Dialog "Modify Project Facets" Des Weiteren muss nun noch die Java Version auf 1.8 gesetzt werden.

Project Facets setzen der Java Version auf 1.8 Zum Abschluss wird die Auswahl mit "Apply and Close" bestätigt und die Warnungen und Fehler sollten nicht mehr sichtbar sein.  Einrichten der JavaServerFaces Resourcen Wir haben im Schritt zuvor die Auswahl einer JavaServerFaces implementation abgelehnt, daher muss nun manuell eine hinzugefügt werden. Da das Projekt mit Apache Maven gebaut wird, werden wir diese als Abhängigkeiten zu diesem Projekt hinzufügen. Um diese Bibliotheken als Abhängigkeiten hinzuzufügen muss die Datei "pom.xml" wiefolgt erweitert werden: com.sun.faces jsf-api 2.2.18 com.sun.faces jsf-impl 2.2.18 javax.servlet jstl 1.2 javax.servlet servlet-api 2.5 org.glassfish.web el-impl 2.2 Bevor man jedoch das Projekt neu bauen kann und somit die Abhängigkeiten aus dem Internet geladen und lokal abgelegt werden, muss ein Plugin hinzugefügt werden. Dieses Plugin dient zum bauen der WAR Datei.  org.apache.maven.plugins maven-war-plugin WebContent\WEB-INF\web.xml Es muss hier der Pfad zur Datei "web.xml" eingerichtet werden, Apache Maven erwartet diese Datei eigentlich unter dem Pfad "src" > "main" > "webapp" > "WEB-INF". Setzen der Startseite In der Datei web.xml wird die Startseite des Web-Projektes benannt. Hier können beliebig viele Dateien benannt werden (was wenig sinn ergibt aber möglich ist). index.xhtml Zusätzlich müssen wir ein Servlet-Mapping erstellen damit der Server "weiß" mit welchen Dateien dieser im JSF Kontext arbeiten soll. Faces Servlet *.jsf Faces Servlet *.faces Faces Servlet *.xhtml Hier könnte man sich eine beliebige Dateiendung ausdenken und verwenden. Erstellen der Datei index.xhtml Damit das Web-Projekt aufgerufen werden kann muss es eine Startseite geben. Diese Datei wird zumeist mit "index" Bezeichnet und trägt für dieses JSF Projekt das Suffix ".xhtml". Es wird nun eine leere Datei in dem Ordner "WebContent" erstellt und mit index.xhtml benannt.

erstellen einer neuen Datei im Ordner WebContent Als erstes wollen wir eine "normale" HTML Datei erstellen mit einem einfachen Grundgerüst.

Hello World!

Einrichten von Apache Tomcat Damit wir unserer Web-Projekt "HelloWorld" ausführen können, benötigen wir einen Applicationserver. Der wohl bekannteste Vertreter ist Apache Tomcat. Und kann kostenfrei unter https://tomcat.apache.org/download-70.cgi heruntergeladen werden. Nachdem Download und dem entpacken des Zip Archives wird der Server in Eclipse eingerichtet. Als erstes öffnet man den Reiter "Servers".

Eclipse Reiter "Servers" Sollte dieser Reiter nicht sichtbar sein, so kann dieser über "Window" > "Show View" > "Servers" eingeblendet werden.

Eclipse Reiter "Server" einblenden Um nun einen neuen Server einzurichten muss auf den Hyperlink "No servers are available...." geklickt werden. Es wird nun der Dialog "New Server" angezeigt. Aus diesem Dialog kann man einen Server wählen und ggf. herunterladen und installieren.  Es muss nun aus dem Baum der Knoten "Apache" geöffnet werden (1) und den Eintrag "Tomcat v7.0 Server" (2) auswählen, diese Auswahl wird mit der Schaltfläche "Next >" (3) bestätigt.

Eclipse Apache Tomcat als Server einrichten (Schritt 1) Im nächsten Schritt muss nun die zuvor heruntergeladene Installation von Apache Tomcat über die Schaltfläche "Browse" (1) ausgewählt werden, diese Auswahl wird mit der Schaltfläche "Finish" (2) bestätigt.

Eclipse - Tomcat Server installation wählen   Alternativ kann man hier auch einen Apache Tomcat herunterladen und installieren (blau markierte Schaltfläche). Starten von Apache Tomcat aus Eclipse Nachdem nun das Web-Projekt und der Applicationserver Tomcat eingerichtet wurde können wir diesen erstmalig starten. Dazu klicken wir im Kontextmenü des Projektes auf "Run As" > "Run on Server" und wählen dort einen Applicationserver aus. 

Eclipse - Web-Projekt starten

Eclipse Web-Projekt starten, Server auswahl  Troubleshooting Sollte beim starten des Web-Projektes der Fehler "ClassNotFoundException: javax.faces.webapp.FacesServlet" in der Console erscheint, so muss in den "Deployment Assembly" Einstellungen zu dem Projekt das lokale Maven Repository hinzugefügt werden. Als erstes wird nun im Menübaum der Eintrag "Deployment Assembly" ausgewählt (1) danach die Schaltfläche "Add..." (2) betätigt.

Eclipse - Deployment Assembly Im neuen Dialog wählen wir den Eintrag "Java Build Path Entries" (1) und bestätigen diese Auswahl mit der Schaltfläche "Next >" (2).

Eclipse - neuen Java Build Path Eintrag hinzufügen In nächsten Dialog wird nun der Eintrag "Maven Dependencies" (1) ausgewählt und die Auswahl mit der Schaltfläche "Finish" (2) bestätigt. Danach muss diese neue Einstellung mit der Schaltfläche "Apply and Close" übernommen werden (der Dialog wird zusätzlich geschlossen). Nun muss der Server gestoppt und neu gestartet werden. Ansicht des Web-Projektes im Browser Wenn das Web-Projekt ohne Fehler im Apache Tomcat deployt wurde, so kann dieses Projekt über die Adresse http://localhost:8080/HelloWorld aufgerufen werden.

Web-Projekt "HelloWorld" im Browser Bisher haben wir jedoch keine JSF Funktionalität implementiert. Dieses wollen wir nun ändern.

JSF Namespace einrichten

Nachdem das Web-Projekt eingerichtet und erfolgreich gestartet wurde, wollen wir die JSF Funktionalität implementieren. Als erstes stellen wir das HTML Grundgerüst auf JSF um, dieses wird später benötigt damit wir Java Beans benutzen können. Insert title here

Hello World!

Es gibt neben den HTML Komponenten auch Funktionen (Schleifen, Bedingte Anweisungen usw.) welche man in dieser Datei verwenden kann. Hierzu muss man zusätzlich die JSTL (Java Standard Tag Library) implementieren. xmlns:c="http://java.sun.com/jsp/jstl/core" Mit den JSTL Funktionen können wir nun unseren Text "Hello World!" mehrfach ausgeben:

Hello World!

Eine Java Bean erstellen

Nun wollen wir eine Java Bean erstellen aus welcher wir eine einfache Begrüßung erzeugen möchten. Eine Java Bean ist eine "normale" Klasse jedoch mit einer zusätzlichen Annotation "@ManagedBean". Diese Annotation sorgt dafür das unsere Bean über den JSF Kontext verwaltet wird. package de.draegerit.helloworld; import javax.faces.bean.ManagedBean; import javax.faces.bean.RequestScoped; @ManagedBean @RequestScoped public class HelloBean { private String greeting; public String getGreeting() { return greeting; } public void setGreeting(String greeting) { this.greeting = greeting; } } Es ist wichtig auf den Java Beans konvention zu achten, d.h. es müssen zu dem Feld getter & setter bestehen. Diese Methoden können in Eclipse fast automatisch erstellt werden. Nun können wir in der XHTML Datei dieses Feld befüllen und auslesen. Setzen der Begrüßung Wir haben nun eine JavaBean "HelloBean" erzeugt und dort das Feld "greeting" mit gettern & settern.  Nun können wir in der Datei index.xhtml ein Eingabefeld erzeugen und eine "Verbindung" von der Bean zu diesem herstellen.  Es gibt den HTML Tag "input" diesem kann man als Typ den Wert "text" übergeben, und erhält dann ein Eingabefeld für Text. In JSF gibt es die Komponenten auch, jedoch werden diese über den zuvor definierten Namespace deklariert. Der Wert in dem Eingabefeld wird dann per Value Expression über die getter & setter Methoden aufgerufen. Ein solcher Aufruf startet immer mit einer Raute "#" gefolgt von einer geschweiften Klammer "{" und wird mit einer geschweiften Klammer beendet. Gibt man keinen Namen bei der Annotation @ManagedBean ein so wird der Name der Klasse verwendet, jedoch wird der erste Buchstabe klein geschrieben. Man kann jedoch einen beliebigen Namen vergeben, hierzu muss der Annotation nur ein Parameter "Name" übergeben werden. @ManagedBean(name="irgendeinNameBean") Aus HTML kennen wir bereits den Tag "form" damit lassen sich Formulardaten übersenden und eine Aktion auf dem Server aufrufen.   Damit wir im folgenden einen Seitenwechsel erzeugen können benötigen wir zusätzlich einen Button Das Attribut "action" trägt den Namen der Seite zu welcher gewechselt werden soll.  Wollen wir nun eine neue Seite "greeting.xhtml" erzeugen um den Text / Namen aus der Seite "index.html" dort anzeigen zu lassen. Insert title here

Hallo #{helloBean.greeting}

Das Ergebnis ist nun das auf der neuen Seite das Wort "Hallo" und zusätzlich unser Text aus der vorherigen Seite steht.

Fazit & Ausblick