Verwendung von Spring Security OAuth für sichere Autorisierung in der Java-API-Entwicklung

Eine häufige Anforderung bei der Java-API-Entwicklung ist die Implementierung von Benutzerauthentifizierungs- und Autorisierungsfunktionen. Um sicherere und zuverlässigere API-Dienste bereitzustellen, ist die Autorisierungsfunktion besonders wichtig geworden. Spring Security OAuth ist ein hervorragendes Open-Source-Framework, das uns bei der Implementierung von Autorisierungsfunktionen in Java-APIs helfen kann. In diesem Artikel wird erläutert, wie Sie Spring Security OAuth für die sichere Autorisierung verwenden.

1. Was ist Spring Security OAuth?

Spring Security OAuth ist eine Erweiterung des Spring Security-Frameworks, die uns bei der Implementierung von OAuth-Authentifizierungs- und Autorisierungsfunktionen helfen kann.

OAuth ist ein offener Standard zur Autorisierung von Drittanbieteranwendungen für den Zugriff auf Ressourcen. Es kann uns helfen, die Entkopplung der Geschäftslogik und sichere Anwendungen zu erreichen. Der OAuth-Autorisierungsprozess umfasst normalerweise die folgenden Rollen:

• Benutzer: der Eigentümer der Ressource;
• Client: die Anwendung, die für den Zugriff auf Benutzerressourcen gilt;
• Ressourcenserver : Speichert Benutzerressourcenserver;

Autorisierungsprozess

2. Spring Security OAuth implementiert vier Endpunkte im OAuth-Autorisierungsprozess:

/oauth/authorize: der Autorisierungsendpunkt des Autorisierungsservers;

• /oauth/token: Der Token-Endpunkt des Autorisierungsservers;
• /oauth/confirm_access: Der Endpunkt für den Client zur Bestätigung der Autorisierung;
• Spring Security OAuth implementiert die vier Autorisierungsmodi von OAuth 2.0:

Autorisierungscodemodus: Das Verwendungsszenario besteht darin, dass beim Starten der Anwendung eine Benutzerautorisierung erforderlich ist.

Passwortmodus: Das Verwendungsszenario besteht darin, dass der Client Benutzeranmeldeinformationen unabhängig verwaltet.

• Vereinfachter Modus: dass der Client im Browser ausgeführt wird und keinen Client-seitigen Schutz der Benutzeranmeldeinformationen erfordert
• Client-Modus: Das Verwendungsszenario besteht darin, dass der Client keine Benutzerautorisierung erfordert und das angeforderte Zugriffstoken nur den Client selbst darstellt;
• Spring Security OAuth-Abhängigkeit hinzufügen

Fügen Sie Spring zu den Security OAuth-Abhängigkeiten des Projekts hinzu. Konfigurieren Sie Folgendes in pom.xml:

3. <dependency>
       <groupId>org.springframework.security.oauth</groupId>
       <artifactId>spring-security-oauth2</artifactId>
       <version>2.3.4.RELEASE</version>
   </dependency>

Konfigurieren Sie den Autorisierungsserver

Wir müssen den Autorisierungsserver für die Autorisierung definieren. In Spring Security OAuth können Sie einen Autorisierungsserver definieren, indem Sie einen OAuth2-Authentifizierungsserver aktivieren und die Schnittstelle AuthorizationServerConfigurer implementieren.

4. @Configuration
   @EnableAuthorizationServer
   public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
   
       @Autowired
       TokenStore tokenStore;
   
       @Autowired
       AuthenticationManager authenticationManager;
   
       @Override
       public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
           clients.inMemory()
               .withClient("client")
               .secret("{noop}secret")
               .authorizedGrantTypes("client_credentials", "password")
               .scopes("read", "write")
               .accessTokenValiditySeconds(3600)
               .refreshTokenValiditySeconds(7200);
       }
   
       @Override
       public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
           endpoints.tokenStore(tokenStore)
               .authenticationManager(authenticationManager);
       }
   }

Im obigen Code definieren wir einen speicherbasierten Client-Detaildienst und konfigurieren den Autorisierungstyp als „client_credentials“ und „password“. Wir geben außerdem den Gültigkeitszeitraum des Zugriffstokens und den Gültigkeitszeitraum des Aktualisierungstokens an. Darüber hinaus definieren wir die Endpunkte und ihren erforderlichen tokenStore und AuthenticationManager.

Ressourcenserver konfigurieren

Um die Spring Security OAuth-Sicherheitsautorisierung zu verwenden, müssen wir auch den Ressourcenserver konfigurieren. In Spring Security OAuth können wir Ressourcenserver definieren, indem wir die Schnittstelle ResourceServerConfigurer implementieren.

5. @Configuration
   @EnableResourceServer
   public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
   
       @Override
       public void configure(HttpSecurity http) throws Exception {
           http.authorizeRequests()
               .antMatchers("/api/**").authenticated()
               .anyRequest().permitAll();
       }
   
       @Override
       public void configure(ResourceServerSecurityConfigurer config) throws Exception {
           config.resourceId("my_resource_id");
       }
   }

Im obigen Code haben wir /api/** für die Authentifizierung definiert, während andere Anfragen anonymen Zugriff ermöglichen. Wir konfigurieren auch die Ressourcen-ID „my_resource_id“ für die Verwendung in nachfolgenden Autorisierungsprozessen.

Web-Sicherheit konfigurieren

Um die Spring Security OAuth-Sicherheitsautorisierung verwenden zu können, müssen wir auch die Web-Sicherheit konfigurieren. In Spring Security OAuth kann die Sicherheit durch Implementierung der SecurityConfigurer-Schnittstelle definiert werden.

6. @Configuration
   public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
   
       @Override
       protected void configure(AuthenticationManagerBuilder auth) throws Exception {
           auth.inMemoryAuthentication()
               .withUser("user")
               .password("{noop}password")
               .roles("USER");
       }
   
       @Override
       @Bean
       public AuthenticationManager authenticationManagerBean() throws Exception {
           return super.authenticationManagerBean();
       }
   
       @Override
       protected void configure(HttpSecurity http) throws Exception {
           http.authorizeRequests()
               .antMatchers("/oauth/**")
               .permitAll()
               .anyRequest()
               .authenticated()
               .and()
               .formLogin()
               .permitAll();
       }
   }

Im obigen Code definieren wir einen speicherbasierten Benutzerdetaildienst und deklarieren Anforderungen, die eine Authentifizierung erfordern (d. h. die Pfade nach /oauth/** erfordern alle eine Authentifizierung, andere Pfade sind in Ordnung. Anonymer Zugriff). Wir haben außerdem eine einfache Formularanmeldung konfiguriert, mit der sich Benutzer bei der Anwendung anmelden können.

UserDetailsService implementieren

Wir müssen die UserDetailsService-Schnittstelle für die Verwendung bei der Sicherheitsautorisierung implementieren. Hier verwenden wir den Speicher direkt zum Speichern von Benutzerkonten und Passwörtern und beziehen keine Datenbankoperationen mit ein.

7. @Service
   public class UserDetailsServiceImpl implements UserDetailsService {
   
       @Override
       public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
           if ("user".equals(username)) {
               return new User("user", "{noop}password",
                       AuthorityUtils.createAuthorityList("ROLE_USER"));
           } else {
               throw new UsernameNotFoundException("username not found");
           }
       }
   }

API implementieren

Als nächstes müssen wir eine einfache API implementieren. Wir haben eine getGreeting()-API unter dem Pfad /api/** hinzugefügt, um eine Begrüßung an den Client zurückzugeben.

8. @RestController
   @RequestMapping("/api")
   public class ApiController {
   
       @GetMapping("/greeting")
       public String getGreeting() {
           return "Hello, World!";
       }
   }

Testen des Autorisierungsprozesses

Abschließend müssen wir testen, ob der Autorisierungsprozess wie erwartet funktioniert. Zuerst verwenden wir den Autorisierungscode-Modus, um den Autorisierungscode zu erhalten:

9. http://localhost:8080/oauth/authorize?response_type=code&client_id=client&redirect_uri=http://localhost:8080&scope=read

Besuchen Sie die obige URL in Ihrem Browser. Sie werden aufgefordert, Ihren Benutzernamen und Ihr Passwort zur Autorisierung einzugeben. Geben Sie den Benutzernamen und das Passwort ein und klicken Sie auf „Autorisieren“. Sie werden zu http://localhost:8080/?code=xxx weitergeleitet, wobei xxx der Autorisierungscode ist.

Als nächstes erhalten wir das Zugriffstoken mit dem Passwortmuster:

curl -X POST 
  http://localhost:8080/oauth/token 
  -H 'content-type: application/x-www-form-urlencoded' 
  -d 'grant_type=password&username=user&password=password&client_id=client&client_secret=secret'

Sie erhalten eine JSON-Antwort mit dem Zugriffstoken und dem Aktualisierungstoken:

{
    "access_token":"...",
    "token_type":"bearer",
    "refresh_token":"...",
    "expires_in":3600,
    "scope":"read"
}

Jetzt können Sie dieses Zugriffstoken verwenden, um auf den API-Dienst zuzugreifen:

curl -X GET 
  http://localhost:8080/api/greeting 
  -H 'authorization: Bearer xxx'

Dabei ist xxx Ihr Zugriffstoken. Sie erhalten eine JSON-Antwort mit der Begrüßung „Hello, World!“.

In diesem Artikel stellen wir vor, wie Sie Spring Security OAuth für die sichere Autorisierung verwenden. Spring Security OAuth ist ein sehr leistungsfähiges Framework, das uns bei der Implementierung aller Rollen im OAuth-Autorisierungsprozess helfen kann. In praktischen Anwendungen können wir je nach Sicherheitsanforderungen unterschiedliche Autorisierungsmodi und Dienstkonfigurationen auswählen.

Das obige ist der detaillierte Inhalt vonVerwendung von Spring Security OAuth für sichere Autorisierung in der Java-API-Entwicklung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!