feature: SecurityInterceptor eingebaut

Thomas Ziemer
1 parent 32cb9414
Showing 4 changed files with 151 additions and 8 deletions
pom.xml
src/main/java/net/ziemers/swxercise/lg/user/service/UserService.java
src/main/java/net/ziemers/swxercise/ui/SecurityInterceptor.java
src/main/java/net/ziemers/swxercise/ui/UserViewController.java
@@ -14,7 +14,8 @@
 		<mvn-compiler-plugin-version>3.3</mvn-compiler-plugin-version>
 		<jee-version>7.0</jee-version>
 		<java-version>1.8</java-version>
-		<jaxrs-version>2.0</jaxrs-version>
+		<jaxrs-version>2.0.1</jaxrs-version>
+		<resteasy-version>3.1.3.Final</resteasy-version>
 		<mysql-version>5.1.41</mysql-version>
 		<hibernate-version>5.2.1.Final</hibernate-version>
 		<junit-version>4.12</junit-version>
@@ -45,6 +46,12 @@
 			<version>${jaxrs-version}</version>
 			<scope>provided</scope>
 		</dependency>
+        <dependency>
+            <groupId>org.jboss.resteasy</groupId>
+            <artifactId>resteasy-jaxrs</artifactId>
+            <version>${resteasy-version}</version>
+            <scope>provided</scope>
+        </dependency>
 		<dependency>
 			<groupId>junit</groupId>
 			<artifactId>junit</artifactId>
 package net.ziemers.swxercise.lg.user.service;
  
 import java.util.Collection;
+import java.util.Set;
  
 import javax.ejb.Stateless;
 import javax.inject.Inject;
@@ -22,23 +23,50 @@ public class UserService {
     @Inject
     private SessionContext sessionContext;
  
+    /**
+     * Meldet den Benutzer im SessionContext an.
+     *
+     * @param dto das {@link UserDto} enthält die Eigenschaften des anzumeldenden Benutzers
+     * @return <code>true</code>, wenn die Anmeldung erfolgreich war.
+     */
     public boolean loginUser(UserDto dto) {
         final User user = dao.findByUsername(dto.getUsername());
         return user != null && user.getProfile().isValidPassword(dto.getPassword()) && sessionContext.login(user);
     }
  
+    /**
+     * Meldet den Benutzer vom SessionContext ab.
+     *
+     * @return <code>true</code>, wenn die Abmeldung erfolgreich war.
+     */
     public boolean logoutUser() {
-       return sessionContext.logout();
+        return sessionContext.logout();
     }
  
+    /**
+     * Findet den Benutzer mit der übergebenen Id.
+     *
+     * @param id die Id des gesuchten Benutzes.
+     * @return den gesuchten Benutzer, oder <code>null</code>, falls ein solcher nicht existiert.
+     */
     public User findUser(final Long id) {
         return dao.findById(id);
     }
  
+    /**
+     * Findet alle existierenden Benutzer.
+     * @return alle Benutzer, oder eine leere Collection, falls keine existieren.
+     */
     public Collection<User> findAllUsers() {
         return dao.findAll(User.class);
     }
  
+    /**
+     * Erstellt einen neuen Benutzer, sofern noch keiner mit dem selben Benutzernamen existiert.
+     *
+     * @param userDto das {@link UserDto} enthält die Eigenschaften des zu erstellenden Benutzers
+     * @return die Id des neuen Benutzers, wenn die Erstellung erfolgreich war.
+     */
     public Long createUser(final UserDto userDto) {
         User user = dao.findByUsername(userDto.getUsername());
         if (user == null) {
@@ -53,21 +81,48 @@ public class UserService {
         return null;
     }
  
-    public void deleteUser(final Long id) {
-        dao.remove(User.class, id);
+    /**
+     * Löscht den Benutzer mit der übergebenen Id.
+     *
+     * @param id die Id des zu löschenden Benutzers
+     */
+    public User deleteUser(final Long id) {
+        return dao.remove(User.class, id);
     }
  
+    /**
+     * Löscht den zurzeit angemeldeten Benutzer.
+     *
+     * @return <code>true</code>, wenn das Löschen des angemeldeten Benutzers erfolgreich war.
+     */
     public boolean deleteUser() {
         // ist zurzeit ein Benutzer angemeldet, können wir ihn löschen
         final User user = sessionContext.getUser();
-        if (user != null) {
-            return dao.remove(User.class, user.getId()) != null;
-        }
-        return false;
+        return user != null && dao.remove(User.class, user.getId()) != null;
     }
  
+    /**
+     * Liefert das {@link User}-Objekt des zurzeit angemeldeten Benutzers zurück.
+     * @return das User-Objekt des zurzeit angemeldeten Benutzers.
+     */
     public User getSessionUser() {
         return sessionContext.getUser();
     }
  
+    /**
+     * Prüft, ob der zurzeit angemeldete Benutzer eine Rolle aus der Liste der übergebenen Rollen besitzt.
+     *
+     * @param rolesSet die Rollenliste
+     * @return <code>true</code>, falls der zurzeit angemeldete Benutzer eine der übergebenen Rollen besitzt.
+     */
+    public boolean isUserAllowed(final Set<String> rolesSet) {
+        final User user = getSessionUser();
+
+        // ist überhaupt ein Benutzer angemeldet?
+        if (user != null) {
+            // TODO muss noch implementiert werden
+            return true;
+        }
+        return false;
+    }
 }
+package net.ziemers.swxercise.ui;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.security.DenyAll;
+import javax.annotation.security.PermitAll;
+import javax.annotation.security.RolesAllowed;
+import javax.inject.Inject;
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.container.ContainerRequestFilter;
+import javax.ws.rs.ext.Provider;
+import java.lang.reflect.AnnotatedElement;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import net.ziemers.swxercise.lg.user.service.UserService;
+import org.jboss.resteasy.core.Headers;
+import org.jboss.resteasy.core.ResourceMethodInvoker;
+import org.jboss.resteasy.core.ServerResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Dies ist ein Interceptor für die Annotationen @PermitAll, @DenyAll und @RolesAllowed. Er stellt sicher,
+ * dass die REST-Methoden, welche mit den genannten Annotationen versehen wurden, nur von authorisierten
+ * Benutzern aufgerufen werden können.
+ */
+@Provider
+public class SecurityInterceptor implements ContainerRequestFilter {
+
+    private static final String PROPERTY_RMI = "org.jboss.resteasy.core.ResourceMethodInvoker";
+
+    // 401: The request has not been applied because it lacks valid authentication credentials for the target resource.
+    private static final ServerResponse ACCESS_DENIED = new ServerResponse("Access denied for this rest method", 401, new Headers<>());
+
+    // 403: The server understood the request but refuses to authorize it.
+    private static final ServerResponse ACCESS_FORBIDDEN = new ServerResponse("Nobody can access this rest method", 403, new Headers<>());
+
+    private Logger logger;
+
+    @Inject
+    private UserService userService;
+
+    @PostConstruct
+    public void initialize() {
+        logger = LoggerFactory.getLogger(SecurityInterceptor.class);
+    }
+
+    @Override
+    public void filter(ContainerRequestContext requestContext) {
+        final ResourceMethodInvoker methodInvoker = (ResourceMethodInvoker) requestContext.getProperty(PROPERTY_RMI);
+        final AnnotatedElement element = methodInvoker.getMethod();
+
+        // Zugriff auf die Methode ist für alle erlaubt (obsolet)
+        if (element.isAnnotationPresent(PermitAll.class)) {
+            logger.debug("@PermitAll");
+        }
+
+        // Zugriff auf die Methode ist für niemanden erlaubt
+        else if (element.isAnnotationPresent(DenyAll.class)) {
+            requestContext.abortWith(ACCESS_FORBIDDEN);
+            logger.debug("@DenyAll");
+        }
+
+        // Zugriff auf die Methode muss anhand ihrer Rollen geprüft werden
+        else if (element.isAnnotationPresent(RolesAllowed.class)) {
+            final RolesAllowed rolesAllowed = element.getAnnotation(RolesAllowed.class);
+            final Set<String> rolesSet = new HashSet<>(Arrays.asList(rolesAllowed.value()));
+
+            if (!userService.isUserAllowed(rolesSet)) {
+                requestContext.abortWith(ACCESS_DENIED);
+            }
+            logger.debug("@RolesAllowed({})", rolesSet.toString());
+        }
+    }
+
+}
@@ -2,6 +2,7 @@ package net.ziemers.swxercise.ui;
  
 import java.util.Collection;
  
+import javax.annotation.security.RolesAllowed;
 import javax.enterprise.context.ApplicationScoped;
 import javax.inject.Inject;
 import javax.ws.rs.*;
@@ -70,6 +71,7 @@ public class UserViewController {
     @Path("v1/user")
     @Consumes(MediaType.APPLICATION_JSON)
     @Produces(MediaType.APPLICATION_JSON)
+    @RolesAllowed("ADMIN")
     public RestResponse createUser(UserDto dto) {
         final Long id = userService.createUser(dto);
         if (id != null) {
@@ -94,6 +96,7 @@ public class UserViewController {
     @Path("v1/user/{id}")
     @Consumes(MediaType.APPLICATION_JSON)
     @Produces(MediaType.APPLICATION_JSON)
+    @RolesAllowed("ADMIN")
     public RestResponse updateUser(@PathParam("id") Long id, UserDto dto) {
         // TODO noch zu implementieren
         return new RestResponse(ResponseState.FAILED);
@@ -111,6 +114,7 @@ public class UserViewController {
     @DELETE
     @Path("v1/user/{id}")
     @Produces(MediaType.APPLICATION_JSON)
+    @RolesAllowed("ADMIN")
     public RestResponse deleteUser(@PathParam("id") Long id) {
         userService.deleteUser(id);
         return new RestResponse();