Custom Implementation Example

Openen in ChatGPT

Deze gids behandelt het bouwen van een complete aangepaste beveiligingsimplementatie met behulp van sessiegebaseerde authenticatie. Je leert hoe de vier kerninterfaces samenwerken door ze vanaf nul te implementeren.

De meeste apps moeten Spring Security gebruiken

De Spring Security-integratie configureert automatisch alles wat hier wordt getoond. Bouw alleen aangepaste beveiliging als je specifieke vereisten hebt of geen gebruik maakt van Spring Boot.

Wat je gaat bouwen

Een werkend beveiligingssysteem met vier klassen:

• SecurityConfiguration - Definieert beveiligingsgedrag en omleidingslocaties
• SecurityContext - Houdt bij wie is ingelogd met behulp van HTTP-sessies
• SecurityManager - Coördineert beveiligingscontroles en biedt inloggen/uitloggen
• SecurityRegistrar - Verbindt alles bij het opstarten van de app

Dit voorbeeld maakt gebruik van sessie-gebaseerde opslag, maar je kunt dezelfde interfaces implementeren met databasequery's, LDAP of een andere authenticatieback-end.

Hoe de onderdelen samenwerken

Stroom:

1. SecurityRegistrar draait bij opstarten, maakt de manager aan, registreert evaluators en koppelt de observer
2. SecurityManager coördineert alles - het biedt de context en configuratie aan evaluators
3. SecurityContext beantwoordt "Wie is ingelogd?" door uit HTTP-sessies te lezen
4. SecurityConfiguration beantwoordt "Waarheen omleiden?" voor inlog- en toegang geweigerd pagina's
5. Evaluators nemen toegangsbeslissingen met behulp van de context en configuratie

Stap 1: Definieer beveiligingsconfiguratie

De configuratie vertelt het beveiligingssysteem hoe te gedragen en waar gebruikers om te leiden:

SecurityConfiguration.java

package com.securityplain.security;

import com.webforj.router.history.Location;
import com.webforj.router.security.RouteSecurityConfiguration;
import java.util.Optional;

/**
 * Beveiligingsconfiguratie voor de toepassing.
 *
 * <p>
 * Definieert waar gebruikers naartoe omgeleid worden wanneer authenticatie vereist is of toegang wordt geweigerd.
 * </p>
 */
public class SecurityConfiguration implements RouteSecurityConfiguration {

  @Override
  public boolean isEnabled() {
    return true;
  }

  @Override
  public boolean isSecureByDefault() {
    return false;
  }

  @Override
  public Optional<Location> getAuthenticationLocation() {
    return Optional.of(new Location("/login"));
  }

  @Override
  public Optional<Location> getDenyLocation() {
    return Optional.of(new Location("/access-denied"));
  }
}

• isEnabled() = true - Beveiliging is actief
• isSecureByDefault() = false - Routes zijn openbaar tenzij geannoteerd (gebruik true om authenticatie op alle routes standaard te vereisen)
• /login - Waar niet-geauthenticeerde gebruikers naartoe gaan
• /access-denied - Waar geauthenticeerde gebruikers zonder toestemming naartoe gaan

Stap 2: Implementeer beveiligingscontext

De context houdt bij wie is ingelogd. Deze implementatie gebruikt HTTP-sessies om gebruikersinformatie op te slaan:

SecurityContext.java

package com.securityplain.security;

import com.webforj.Environment;
import com.webforj.router.security.RouteSecurityContext;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

/**
* Eenvoudige sessie-gebaseerde beveiligingscontext.
*
* <p>
* Slaat gebruikersprincipaal en rollen op in HTTP-sessie. Dit is een minimale implementatie voor onderwijsdoeleinden.
* </p>
*/
public class SecurityContext implements RouteSecurityContext {
private static final String SESSION_USER_KEY = "security.user";
private static final String SESSION_ROLES_KEY = "security.roles";
private static final String SESSION_ATTRS_KEY = "security.attributes";

Hoe het werkt:

• isAuthenticated() controleert of een gebruikersprincipaal bestaat in de sessie
• getPrincipal() haalt de gebruikersnaam op uit sessieopslag
• hasRole() controleert of de rolset van de gebruiker de gespecificeerde rol bevat
• getAttribute() / setAttribute() beheren aangepaste beveiligingsattributen
• Environment.getSessionAccessor() biedt thread-veilige sessietoegang

Stap 3: Maak beveiligingsmanager

De manager coördineert beveiligingsbeslissingen. Het breidt AbstractRouteSecurityManager uit, dat beoordelingsketens en toegang weigering afhandelt:

SecurityManager.java

package com.securityplain.security;

import com.webforj.environment.ObjectTable;
import com.webforj.environment.SessionObjectTable;
import com.webforj.router.Router;
import com.webforj.router.security.AbstractRouteSecurityManager;
import com.webforj.router.security.RouteAccessDecision;
import com.webforj.router.security.RouteSecurityConfiguration;
import com.webforj.router.security.RouteSecurityContext;

import java.util.Set;

/**
* Eenvoudige implementatie van beveiligingsmanager.
*
* <p>
* Biedt statische methoden voor inloggen/uitloggen en beheert de beveiligingscontext.
* </p>
*/
public class SecurityManager extends AbstractRouteSecurityManager {

Hoe het werkt:

• Breidt AbstractRouteSecurityManager uit om de logica van de beoordelingsketen over te nemen
• Biedt implementaties voor getConfiguration() en getSecurityContext()
• Voegt login() toe om gebruikers te authentiseren en referenties in de sessie op te slaan
• Voegt logout() toe om de sessie te wissen en om te leiden naar de inlogpagina
• Gebruikt SessionObjectTable voor eenvoudige sessieopslag
• Slaat zichzelf op in ObjectTable voor toegang in de hele app

Stap 4: Verbind alles bij opstarten

De registrar verbindt alle onderdelen wanneer de app start:

SecurityRegistrar.java

package com.securityplain.security;

import com.webforj.App;
import com.webforj.AppLifecycleListener;
import com.webforj.annotation.AppListenerPriority;
import com.webforj.router.Router;
import com.webforj.router.security.RouteSecurityObserver;
import com.webforj.router.security.evaluator.AnonymousAccessEvaluator;
import com.webforj.router.security.evaluator.DenyAllEvaluator;
import com.webforj.router.security.evaluator.PermitAllEvaluator;
import com.webforj.router.security.evaluator.RolesAllowedEvaluator;

/**
 * Registreert route-beveiligingscomponenten tijdens het opstarten van de toepassing.
 *
 * <p>
 * Stelt de beveiligingsmanager en evaluators in met de router.
 * </p>
 */
@AppListenerPriority(1)
public class SecurityRegistrar implements AppLifecycleListener {

  /**
   * {@inheritDoc}
   */
  @Override
  public void onWillRun(App app) {
    // Maak beveiligingsmanager aan
    SecurityManager securityManager = new SecurityManager();
    securityManager.saveCurrent(securityManager);

    // Registreer ingebouwde evaluators met prioriteiten
    securityManager.registerEvaluator(new DenyAllEvaluator(), 0);
    securityManager.registerEvaluator(new AnonymousAccessEvaluator(), 1);
    securityManager.registerEvaluator(new PermitAllEvaluator(), 2);
    securityManager.registerEvaluator(new RolesAllowedEvaluator(), 3);

    // Maak beveiligingsobserver en koppel aan router
    RouteSecurityObserver securityObserver = new RouteSecurityObserver(securityManager);
    Router router = Router.getCurrent();
    if (router != null) {
      router.getRenderer().addObserver(securityObserver);
    }
  }
}

Registreer de listener:

Maak src/main/resources/META-INF/services/com.webforj.AppLifecycleListener met:

com.securityplain.security.SecurityRegistrar

Dit registreert je AppLifecycleListener zodat deze draait bij het opstarten van de app.

Hoe het werkt:

• Draait vroeg (@AppListenerPriority(1)) om beveiliging op te zetten voordat routes laden
• Maakt de beveiligingsmanager en slaat deze globaal op
• Registreert ingebouwde evaluators in prioriteitsvolgorde (lagere nummers draaien eerst)
• Maakt de observer aan die navigatie onderschept
• Koppelt de observer aan de router zodat beveiligingscontroles automatisch plaatsvinden

Nadat dit is uitgevoerd, is de beveiliging actief voor alle navigatie.

Gebruik je implementatie

Maak een inlogweergave

De volgende weergave maakt gebruik van de Login component.

LoginView.java

package com.securityplain.views;

import com.securityplain.security.SecurityManager;
import com.webforj.component.Composite;
import com.webforj.component.login.Login;
import com.webforj.router.Router;
import com.webforj.router.annotation.FrameTitle;
import com.webforj.router.annotation.Route;
import com.webforj.router.history.Location;
import com.webforj.router.security.annotation.AnonymousAccess;

@Route("/login")
@FrameTitle("Inloggen")
@AnonymousAccess
public class LoginView extends Composite<Login> {
  private final Login self = getBoundComponent();

  public LoginView() {
    self.onSubmit(e -> {
      var result = SecurityManager.getCurrent().login(
        e.getUsername(), e.getPassword()
      );

      if (result.isGranted()) {
        Router.getCurrent().navigate(new Location("/"));
      } else {
        self.setError(true);
        self.setEnabled(true);
      }
    });

    self.whenAttached().thenAccept(c -> self.open());
  }
}