Java-Backend-Entwicklung: Erstellen sicherer APIs basierend auf OAuth2

OAuth2 ist eines der am weitesten verbreiteten Authentifizierungs- und Autorisierungsprotokolle in modernen Anwendungen. Es ermöglicht Benutzern, Anwendungen von Drittanbietern den Zugriff auf ihre Ressourcen zu genehmigen und gleichzeitig die vertraulichen Informationen der Benutzer vor der Offenlegung zu schützen. In diesem Artikel stellen wir vor, wie man mithilfe der Java-Backend-Entwicklung eine sichere API basierend auf OAuth2 erstellt.

1. Was ist OAuth2?

OAuth2 ist ein beliebtes Autorisierungsprotokoll, das zur Lösung von Autorisierungsproblemen zwischen Anwendungen entwickelt wurde. Es ermöglicht Benutzern, Drittanbieteranwendungen den Zugriff auf ihre Ressourcen wie Google Drive- oder Facebook-Konten zu autorisieren und gleichzeitig die Benutzeranmeldeinformationen vor Gefährdung zu schützen. OAuth2 enthält 4 Rollen: Ressourcenbesitzer, Client, Autorisierungsserver und Ressourcenserver. Der Ressourceneigentümer ist der Benutzer oder die Entität mit der geschützten Ressource. Der Client ist die Anwendung, die den Zugriff auf die Ressource anfordert. Der Autorisierungsserver ist der Server, der die Identität des Ressourceneigentümers überprüft und ein Zugriffstoken ausstellt Server, der Ressourcen speichert und bereitstellt. OAuth2 stellt über einen Autorisierungsserver ein Token aus, und der Client verwendet das Token, um Ressourcen vom Ressourcenserver anzufordern.

2. OAuth2-Prozess

OAuth2-Prozess besteht aus den folgenden Schritten:

1. Der Client stellt eine Anfrage an den Autorisierungsserver und gibt seine Kennung und Umleitungs-URI an.
2. Der Autorisierungsserver überprüft die Identität des Clients und fordert den Ressourceneigentümer auf, den Client für den Zugriff auf seine Ressourcen zu autorisieren.
3. Ressourcenbesitzer autorisieren Kunden, auf ihre Ressourcen zuzugreifen.
4. Der Autorisierungsserver stellt dem Client ein Zugriffstoken aus.
5. Der Client verwendet das Zugriffstoken, um vom Ressourcenserver Zugriff auf die Ressource anzufordern.
6. Der Ressourcenserver überprüft, ob das Zugriffstoken gültig ist und stellt die Ressource bereit.
7. Erstellen Sie eine sichere API basierend auf OAuth2

Um eine sichere API zu erstellen, müssen wir die folgenden Schritte implementieren:

1. OAuth2-Server erstellen: Wir müssen einen OAuth2-Server erstellen, um Zugriffstoken auszugeben, Clientidentitäten zu authentifizieren usw Anfragen genehmigen.
2. Spring Security konfigurieren: Spring Security ist das Sicherheitsframework im Spring-Ökosystem, das die Authentifizierung und Autorisierung übernimmt. Wir müssen den OAuth2-Authentifizierungs- und Autorisierungsfluss für Spring Security konfigurieren.
3. Client erstellen: Wir müssen einen Client erstellen, um Zugriff auf den Ressourcenserver anzufordern und ein Zugriffstoken vom OAuth2-Server zu erhalten.
4. Ressourcenserver erstellen: Wir müssen einen Ressourcenserver erstellen, um geschützte Ressourcen zu speichern und bereitzustellen.
5. Zugriffstoken überprüfen: Wir müssen überprüfen, ob das Zugriffstoken auf dem Ressourcenserver gültig ist, und die entsprechenden Ressourcen entsprechend dem Umfang des Tokens bereitstellen.

Das Folgende ist ein OAuth2-Beispiel basierend auf Java und Spring Framework:

1. OAuth2-Server erstellen:

@EnableAuthorizationServer
@Configuration
öffentliche Klasse OAuth2AuthorizationConfig erweitert AuthorizationServerConfigurerAdapter {

private final PasswordEncoder passwordEncoder;
private final AuthenticationManager authenticationManager;
private final UserDetailsService userDetailsService;

@Autowired
public OAuth2AuthorizationConfig(
        PasswordEncoder passwordEncoder,
        AuthenticationManager authenticationManager,
        UserDetailsService userDetailsService
) {
    this.passwordEncoder = passwordEncoder;
    this.authenticationManager = authenticationManager;
    this.userDetailsService = userDetailsService;
}

@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
    clients.inMemory()
            .withClient("client")
            .secret(passwordEncoder.encode("secret"))
            .authorizedGrantTypes("authorization_code")
            .scopes("read", "write", "trust")
            .redirectUris("http://localhost:8080/login/oauth2/code/");
}

@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
    endpoints.authenticationManager(authenticationManager)
            .userDetailsService(userDetailsService);
}

}

Spring-Sicherheit konfigurieren:

@Configuration

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig erweitert WebSecurityConfigurerAdapter {

private final UserDetailsService userDetailsService;
private final PasswordEncoder passwordEncoder;

@Autowired
public WebSecurityConfig(
        UserDetailsService userDetailsService,
        PasswordEncoder passwordEncoder
) {
    this.userDetailsService = userDetailsService;
    this.passwordEncoder = passwordEncoder;
}

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth.userDetailsService(userDetailsService)
            .passwordEncoder(passwordEncoder);
}

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
            .antMatchers("/oauth/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .oauth2Login();
}

}

Client erstellen:

@RestController

öffentlicher Client-Controller {

private final OAuth2AuthorizedClientService authorizedClientService;

@Autowired
public ClientController(OAuth2AuthorizedClientService authorizedClientService) {
    this.authorizedClientService = authorizedClientService;
}

@GetMapping("/resource")
public ResponseEntity<String> getResource(OAuth2AuthenticationToken authentication) {
    OAuth2AuthorizedClient authorizedClient = authorizedClientService.loadAuthorizedClient(
            authentication.getAuthorizedClientRegistrationId(),
            authentication.getName()
    );
    HttpHeaders headers = new HttpHeaders();
    headers.setBearerAuth(authorizedClient.getAccessToken().getTokenValue());
    HttpEntity<String> entity = new HttpEntity<>(headers);
    ResponseEntity<String> response = new RestTemplate().exchange(
            "http://localhost:8081/resource",
            HttpMethod.GET,
            entity,
            String.class
    );
    return response;
}

}

Ressourcenserver erstellt:

@RestController

public class ResourceController {

@GetMapping("/resource")
public ResponseEntity<String> getResource() {
    return ResponseEntity.ok("resource");
}

}

Zugriffstoken überprüfen:

@Configuration

@EnableResourceServer
public class ResourceServerConfig erweitert ResourceServerConfigurerAdapter {

@Override
public void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
            .antMatchers("/oauth/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .oauth2ResourceServer()
            .jwt();
}

}

Rezension

In diesem Artikel stellen wir den Prozess des OAuth2-Protokolls vor und stellen ein Beispiel basierend auf Java und dem Spring-Framework bereit. Durch die Verwendung von OAuth2 können wir sicherere APIs erstellen und die vertraulichen Informationen der Benutzer vor der Offenlegung schützen. Bei der API-Entwicklung sollten wir stets auf Sicherheit achten, um Benutzerdaten und Anwendungsressourcen zu schützen.

Das obige ist der detaillierte Inhalt vonJava-Backend-Entwicklung: Erstellen sicherer APIs basierend auf OAuth2. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!