Cara menggunakan rangka kerja OAuth2 pengurusan keselamatan SpringBoot

Pengenalan kepada OAuth3

OAuth ialah standard terbuka yang membolehkan pengguna membenarkan aplikasi pihak ketiga mengakses sumber peribadi pengguna (seperti avatar, foto, video, dll.) yang disimpan di tapak web ini Tidak perlu memberikan nama pengguna dan kata laluan kepada aplikasi pihak ketiga semasa proses.

Mengakses data yang disimpan dalam pembekal perkhidmatan tertentu dicapai menggunakan token dan bukannya nama pengguna dan kata laluan. Setiap token membenarkan tapak web tertentu untuk mengakses sumber tertentu untuk tempoh masa tertentu.

OAuth membenarkan pengguna membenarkan tapak web pihak ketiga untuk mengakses maklumat tertentu secara fleksibel yang disimpan pada pelayan sumber lain, dan bukannya semua maklumat. Contohnya, jika pengguna ingin log masuk ke Zhihu melalui QQ, maka Zhihu ialah aplikasi pihak ketiga Jika Zhihu ingin mengakses beberapa maklumat asas pengguna, ia memerlukan kebenaran pengguna Jika pengguna memberitahu Zhihu pengguna QQnya nama dan kata laluan, maka Zhihu boleh mengakses semua data pengguna, dan hanya pengguna yang boleh membatalkan kebenaran dengan menukar kata laluan mereka Kaedah kebenaran ini mempunyai risiko keselamatan yang besar Jika anda menggunakan OAuth, masalah ini boleh diselesaikan dengan baik.

Penggunaan token membolehkan pengguna memberi kebenaran atau menarik balik kebenaran secara fleksibel daripada aplikasi pihak ketiga. OAuth 2 ialah versi protokol OAuth yang seterusnya, tetapi tidak serasi ke belakang dengan OAuth 1.0.

OAuth 2 memfokuskan pada kesederhanaan untuk pembangun pelanggan, sambil menyediakan proses pengesahan khusus untuk aplikasi web, aplikasi desktop, peranti mudah alih dan peranti ruang tamu. Pengesahan log masuk pembangunan web tradisional biasanya berdasarkan Sesi, tetapi meneruskan penggunaan Sesi dalam seni bina dipisahkan bahagian hadapan dan belakang akan menyebabkan banyak kesulitan, kerana terminal mudah alih (Android, IOS, applet WeChat, dll.) sama ada tidak sokong Cookie (WeChat applet) , atau sangat menyusahkan untuk digunakan Untuk masalah ini, menggunakan pengesahan OAuth 2 boleh menyelesaikannya.

Peranan OAuth3

Mula-mula faham beberapa peranan asas dalam OAuth 2

• Pemilik sumber: iaitu pengguna, dengan avatar, foto, video, dsb. Sumber

• Pelanggan: iaitu, aplikasi pihak ketiga

• Pelayan kebenaran: digunakan untuk mengesahkan sama ada maklumat yang diberikan oleh pengguna adalah betulkan dan kembalikan token Untuk aplikasi pihak ketiga

• Pelayan sumber: Pelayan yang menyediakan sumber pengguna, seperti avatar, foto, video dan sumber lain

Secara umumnya, Pelayan kebenaran dan pelayan sumber boleh menjadi pelayan yang sama.

Proses kebenaran OAuth3

Langkah 01: Pelanggan (aplikasi pihak ketiga) meminta kebenaran daripada pengguna.

Apabila pengguna mengklik butang Setuju Kebenaran pada halaman kebenaran perkhidmatan, pelayan akan mengembalikan sijil kebenaran kepada pelanggan.

Langkah 03: Pelanggan mengambil lesen kebenaran ke pelayan kebenaran untuk memohon token.

Langkah 04: Selepas pelayan kebenaran mengesahkan bahawa maklumat adalah betul, ia mengeluarkan token kepada pelanggan.

Langkah 05: Pelanggan membawa token ke pelayan sumber untuk mengakses sumber.

Langkah 06: Pelayan sumber membuka sumber selepas mengesahkan bahawa token itu betul.

Mod kebenaran

Mod kebenaran protokol OAuth dibahagikan kepada 4 jenis, seperti berikut

• Mod kebenaran kod kebenaran ialah kaedah kebenaran paling lengkap Proses ini adalah yang paling ketat, dan kod kebenarannya adalah kuncinya. Ciri mod ini ialah pelayan pelanggan berinteraksi dengan pelayan kebenaran Fungsi log masuk platform pihak ketiga domestik biasa pada asasnya menggunakan kaedah ini

• Mod ringkas: Mod ringkas tidak memerlukan pelanggan. Pelayan akhir mengambil bahagian dan memohon token terus daripada pelayan kebenaran dalam penyemak imbas Secara amnya, jika ia adalah halaman statik semata-mata, kaedah ini boleh digunakan

• Dalam mod kata laluan. pengguna secara langsung meminta klien Dengan menyediakan nama pengguna dan kata laluannya, pelanggan menggunakan maklumat ini untuk meminta token akses daripada pelayan kebenaran. Pengguna perlu mengetahui maklumat peringkat tinggi tentang pelanggan, seperti sama ada aplikasi pelanggan dan pembekal perkhidmatan adalah syarikat yang sama

• Dalam mod pelanggan, pembekal perkhidmatan membenarkan pelanggan dan bukannya pengguna tertentu. Tegasnya, mod klien tidak boleh dianggap sebagai penyelesaian kepada masalah yang diselesaikan oleh protokol OAuth Walau bagaimanapun, bagi pembangun, adalah berguna untuk menggunakan kaedah ini dalam beberapa aplikasi pemisahan bahagian hadapan dan belakang atau pelayan pengesahan dan kebenaran yang disediakan. untuk terminal mudah alih. Mod ini masih sangat mudah

4 mod tersebut mempunyai kelebihan tersendiri dan sesuai untuk senario pembangunan yang berbeza Pembangun boleh memilih mengikut situasi sebenar

Amalan

Apa yang diperkenalkan di sini ialah cara membina perkhidmatan OAuth dalam pelayan pengesahan yang disediakan untuk aplikasi pemisahan bahagian hadapan dan belakang (atau untuk terminal mudah alih, applet WeChat, dll.), jadi kata laluan mod terutamanya diperkenalkan.

1 Cipta projek dan tambah kebergantungan

Buat projek Web Spring Boot dan tambahkan kebergantungan berikut

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
  <exclusions>
    <exclusion>
      <groupId>io.lettuce</groupId>
      <artifactId>lettuce-core</artifactId>
    </exclusion>
  </exclusions>
</dependency>
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.security.oauth</groupId>
  <artifactId>spring-security-oauth3</artifactId>
  <version>2.3.3.RELEASE</version>
</dependency>

Memandangkan protokol OAuth dalam Spring Boot selesai berdasarkan asas daripada Spring Security , jadi pertama anda perlu menambah kebergantungan Spring Security, yang memerlukan OAuth 2, jadi tambahkan kebergantungan berkaitan OAuth 2 Token boleh disimpan pada pelayan cache Redis Pada masa yang sama, Redis mempunyai fungsi seperti tamat tempoh sangat sesuai untuk penyimpanan token, jadi Redis juga ditambah.

Aplikasi konfigurasi.sifat

spring.redis.database=0
spring.redis.host=ip地址
spring.redis.port=6379
spring.redis.password=root
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.max-idle=8
spring.redis.jedis.pool.max-wait=-1ms
spring.redis.jedis.pool.min-idle=0

2. 配置授权服务器

授权服务器和资源服务器可以是同一台服务器，也可以是不同服务器，此处假设是同一台服务器，通过不同的配置分别开启授权服务器和资源服务器，首先是授权服务器：

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
    @Autowired
    AuthenticationManager authenticationManager;
    @Autowired
    RedisConnectionFactory redisConnectionFactory;
    @Autowired
    UserDetailsService userDetailsService;
    @Bean
    PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient("password")
                .authorizedGrantTypes("password", "refresh_token")
                .accessTokenValiditySeconds(1800)
                .resourceIds("rid")
                .scopes("all")
                .secret("$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq");
    }
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.tokenStore(new RedisTokenStore(redisConnectionFactory))
                .authenticationManager(authenticationManager)
                .userDetailsService(userDetailsService);
    }
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security.allowFormAuthenticationForClients();
    }
}

代码解释：

• 自定义类继承自 AuthorizationServerConfigurerAdapter ，完成对授权服务器的配置，然后通过 @EnableAuthorizationServer 注解开启授权服务器

• 注入 AuthenticationManager 用来支持 password 模式

• 注入 RedisConnectionFactory 用来完成 Redis 缓存，将令牌信息储存到 Redis 缓存中

• 注入 UserDetailsService 该对象为刷新 token 提供支持

• 在 configure(ClientDetailsServiceConfigurer clients) 方法中配置 password 授权模式，authorizedGrantTypes 表示 OAuth 2 中的授权模式为 password 和 refresh_token 两种，在标准的 OAuth 2 协议中，授权模式并不包括 refresh_token ，但是在 Spring Security 的实现中将其归为一种，因此如果要实现 access_token 的刷新，就需要添加这样一种授权模式；accessTokenValiditySeconds 方法配置了 access_token 的过期时间；resourceIds 配置了资源 id；secret 方法配置了加密后的密码，明文是 123

• configure(AuthorizationServerEndpointsConfigurer endpoints) 方法配置了令牌的存储，AuthenticationManager 和 UserDetailsService 主要用于支持 password 模式以及令牌的刷新

• configure(AuthorizationServerSecurityConfigurer security) 方法配置表示支持 client_id 和 client_secret 做登录认证

3. 配置资源服务器

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.resourceId("rid").stateless(true);
    }
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("admin")
                .antMatchers("/user/**").hasRole("user")
                .anyRequest().authenticated();
    }
}

代码解释：

• 自定义类继承自 ResourceServerConfigurerAdapter ，并添加 @EnableResourceServer 注解开启资源服务器配置

• resources.resourceId(“rid”).stateless(true); 配置资源 id，这里的资源 id 和授权服务器中的资源 id 一直，然后设置这些资源仅基于令牌认证

• configure(HttpSecurity http) 方法配置 HttpSecurity

4. 配置 Security

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
    @Bean
    @Override
    protected UserDetailsService userDetailsService() {
        return super.userDetailsService();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
                .withUser("admin")
                .password("$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq")
                .roles("admin")
                .and()
                .withUser("sang")
                .password("$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq")
                .roles("user");
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.antMatcher("/oauth/**").authorizeRequests()
                .antMatchers("/oauth/**").permitAll()
                .and().csrf().disable();
    }
}

这里两个 Bean 将注入授权服务器配置类中使用，另外，这里的 HttpSecurity 配置主要是配置 /oauth/** 模式的 URL ，这一类的请求直接放行。在 Spring Security 配置和资源服务器配置中，一共涉及两个 HttpSecurity ，其中 Spring Security 中的配置优先级高于资源服务器中的配置，即请求地址先经过 Spring Security 的 HttpSecurity ，再经过资源服务器的 HttpSecurity。

5. 验证测试

首先创建三个简单的请求地址

@RestController
public class HelloController {
    @GetMapping("/admin/hello")
    public String admin() {
        return "Hello admin!";
    }
    @GetMapping("/user/hello")
    public String user() {
        return "Hello user!";
    }
    @GetMapping("/hello")
    public String hello() {
        return "hello";
    }
}

根据前文的配置，要请求这三个地址，分别需要 admin 角色、user 角色以及登录后访问。

所有都配置完成后，启动 Redis 服务器，再启动 Spring Boot 项目，首先发送一个 POST 请求获取 token，请求地址如下（注意这里是一个 POST 请求，为了显示方便，将参数写在地址栏中）：http://localhost:8080/oauth/token?username=sang&password=123&grant_type=password&client_id=password&scope=all&client_secret=123

请求地址中包含的参数有用户名、密码、授权模式、客户端 id 、scope 以及客户端密码，基本就是授权服务器中所配置的数据，请求结果如图

其中 access_token 是获取其它资源时要用的令牌，refresh_token 用来刷新令牌，expires_in 表示 access_token 过期时间，当 access_token 过期后，使用 refresh_token 重新获取新的 access_token （前提是 refresh_token 未过期），请求地址（注意也是POST请求）：http://localhost:8080/oauth/token?grant_type=refresh_token&refresh_token=693b0e36-4515-442a-8c5d-90bade3c74d2&client_id=password&client_secret=123

获取新的 access_token 时需要携带上 refresh_token ，同事授权模式设置为 refresh_token ，在获取的结果中 access_token 会变化，同时 access_token 有效期也会变化，如图

接下来访问所有资源，携带上 access_token 参数即可，例如 /user/hello 接口：http://localhost:8080/user/hello?access_token=0497e4bc-df37-460e-8755-b813b9dbf36a，访问结果如图

Jika sumber diakses secara haram, contohnya, pengguna sang mengakses antara muka /admin/hello, hasilnya adalah seperti yang ditunjukkan dalam rajah

Pada ketika ini, Sistem pengesahan OAuth mod kata laluan berjaya diwujudkan.

Terdapat 4 mod pengesahan dalam OAuth Pembangun perlu memilih salah satu daripadanya berdasarkan situasi sebenar pembangunan mereka sendiri Mod kata laluan yang biasa digunakan dalam aplikasi pemisahan bahagian hadapan dan belakang diperkenalkan di sini. Mod kebenaran lain juga Setiap mempunyai senario penggunaannya sendiri.

Secara umumnya, penggunaan Spring Security OAuth 2 masih agak rumit, dan konfigurasi juga agak rumit Jika senario aplikasi pembangun agak mudah, anda boleh membina sistem pengesahan OAuth 2 anda sendiri mengikut senario. proses kebenaran diperkenalkan di sini.

Atas ialah kandungan terperinci Cara menggunakan rangka kerja OAuth2 pengurusan keselamatan SpringBoot. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!