Menggunakan Spring Security OAuth untuk kebenaran selamat dalam pembangunan API Java

Keperluan biasa dalam pembangunan API Java adalah untuk melaksanakan fungsi pengesahan dan kebenaran pengguna. Untuk menyediakan perkhidmatan API yang lebih selamat dan boleh dipercayai, fungsi kebenaran telah menjadi sangat penting. Spring Security OAuth ialah rangka kerja sumber terbuka yang sangat baik yang boleh membantu kami melaksanakan fungsi keizinan dalam API Java. Artikel ini akan memperkenalkan cara menggunakan Spring Security OAuth untuk kebenaran selamat.

1. Apakah Spring Security OAuth?

Spring Security OAuth ialah lanjutan daripada rangka kerja Spring Security, yang boleh membantu kami melaksanakan fungsi pengesahan dan kebenaran OAuth.

OAuth ialah standard terbuka untuk membenarkan aplikasi pihak ketiga mengakses sumber. Ia boleh membantu kami mencapai penyahgandingan logik perniagaan dan aplikasi selamat. Proses kebenaran OAuth biasanya merangkumi peranan berikut:

• Pengguna: pemilik sumber;
• Klien: aplikasi yang digunakan untuk mengakses sumber pengguna; Pelayan kebenaran: Pelayan yang mengendalikan kebenaran pengguna;
• Pelayan sumber: pelayan yang menyimpan sumber pengguna; melaksanakan OAuth Four titik akhir dalam proses kebenaran:
• /oauth/authorize: titik akhir kebenaran pelayan kebenaran;

/oauth/confirm_access: Titik akhir untuk pelanggan mengesahkan kebenaran;
2. /oauth/error: Titik akhir untuk maklumat ralat pelayan kebenaran; OAuth melaksanakan empat aspek mod kebenaran besar OAuth 2.0:

Mod kod kebenaran: Senario penggunaan ialah kebenaran pengguna diperlukan apabila aplikasi dimulakan

• Mod kata laluan: The senario penggunaan ialah pelanggan mengurus bukti kelayakan pengguna secara bebas;
• Mod ringkas: Senario penggunaan ialah klien dijalankan dalam penyemak imbas, dan pelanggan tidak perlu melindungi kelayakan pengguna; mod: Senario penggunaan ialah pelanggan tidak memerlukan kebenaran pengguna, dan token akses yang diminta Ia hanya mewakili klien itu sendiri;
Tambahkan pergantungan OAuth Spring Security dalam projek. Konfigurasikan yang berikut dalam pom.xml:

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

• Konfigurasikan pelayan kebenaran

Kami perlu mentakrifkan pelayan kebenaran untuk kebenaran. Dalam Spring Security OAuth, anda boleh menentukan pelayan kebenaran dengan mendayakan pelayan pengesahan OAuth2 dan melaksanakan antara muka AuthorizationServerConfigurer.

@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);
    }
}

Dalam kod di atas, kami mentakrifkan perkhidmatan butiran pelanggan berasaskan memori, mengkonfigurasi jenis keizinan sebagai kelayakan_klien dan kata laluan, dan juga menentukan tempoh sah token akses dan token muat semula. Selain itu, kami mentakrifkan titik akhir dan tokenStore dan authenticationManager yang diperlukan.
• Konfigurasikan pelayan sumber
Untuk menggunakan kebenaran keselamatan Spring Security OAuth, kami juga perlu mengkonfigurasi pelayan sumber. Dalam Spring Security OAuth, kami boleh mentakrifkan pelayan sumber dengan melaksanakan antara muka ResourceServerConfigurer.

• @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");
      }
  }

Dalam kod di atas kami takrifkan /api/** untuk memberikan pengesahan manakala permintaan lain membenarkan akses tanpa nama. Kami juga mengkonfigurasi ID sumber "my_resource_id" untuk digunakan dalam proses kebenaran berikutnya.

3. Konfigurasikan keselamatan web

Untuk menggunakan kebenaran keselamatan OAuth Spring Security, kami juga perlu mengkonfigurasi keselamatan web. Dalam Spring Security OAuth, keselamatan boleh ditakrifkan dengan melaksanakan antara muka SecurityConfigurer.

@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();
    }
}

Dalam kod di atas, kami mentakrifkan perkhidmatan butiran pengguna berasaskan memori dan mengisytiharkan permintaan yang memerlukan pengesahan (iaitu, semua laluan yang mengikuti /oauth/** memerlukan pengesahan, laluan lain boleh diakses tanpa nama). Kami juga mengkonfigurasi log masuk borang mudah untuk pengguna log masuk ke aplikasi.

Laksanakan UserDetailsService

Kami perlu melaksanakan antara muka UserDetailsService untuk digunakan dalam kebenaran keselamatan. Di sini kami terus menggunakan memori untuk menyimpan akaun pengguna dan kata laluan, dan tidak melibatkan operasi pangkalan data.

@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");
        }
    }
}

5. Melaksanakan API

Seterusnya kita perlu melaksanakan API mudah. Kami menambahkan getGreeting() API di bawah laluan /api/** untuk membalas salam kepada pelanggan.

@RestController
@RequestMapping("/api")
public class ApiController {

    @GetMapping("/greeting")
    public String getGreeting() {
        return "Hello, World!";
    }
}

Menguji proses kebenaran

Akhir sekali, kita perlu menguji sama ada proses kebenaran berfungsi seperti yang diharapkan. Pertama, kami menggunakan mod kod kebenaran untuk mendapatkan kod kebenaran:

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

Akses URL di atas dalam penyemak imbas anda, anda akan diminta memasukkan nama pengguna dan kata laluan anda untuk kebenaran. Masukkan nama pengguna dan kata laluan kata laluan dan klik Kebenaran, anda akan dialihkan ke http://localhost:8080/?code=xxx, di mana xxx ialah kod kebenaran.

Seterusnya, kami mendapat token akses menggunakan corak kata laluan:

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'

Anda akan menerima respons JSON yang mengandungi token akses dan token muat semula:

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

Kini anda boleh mengakses perkhidmatan API menggunakan token akses ini:

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

di mana xxx ialah token akses anda. Anda akan menerima respons JSON yang mengandungi ucapan "Hello, World!".

Dalam artikel ini, kami memperkenalkan cara menggunakan Spring Security OAuth untuk kebenaran selamat. Spring Security OAuth ialah rangka kerja yang sangat berkuasa yang boleh membantu kami melaksanakan semua peranan dalam proses kebenaran OAuth. Dalam aplikasi praktikal, kita boleh memilih mod kebenaran dan konfigurasi perkhidmatan yang berbeza mengikut keperluan keselamatan yang berbeza.

Atas ialah kandungan terperinci Menggunakan Spring Security OAuth untuk kebenaran selamat dalam pembangunan API Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!