springboot oauth2 授权码模式与密码模式探索

迈不过友情╰ 2022-11-29 11:59 388阅读 0赞

oauth2支持授权的方式有四种：授权码模式(authorization\_code)、密码模式(password)、隐式模式(implicit)、客户端模式(client\_credentials)。其中，比较常见的就是授权码模式和密码模式。

需要说明的是，授权码模式的过程大致如下：

1、封装参数，访问授权服务器登录与授权接口
       接口：http://localhost:8080/oauth/authorize
       参数：response_type client_id scope redirect_uri state
       返回值：code
    2、拿到code，获取token
       接口：http://localhost:8080/oauth/token
       参数：client_id client_secret grant_type code redirect_uri state
       返回值：access_token
    3、根据token，访问资源
       接口：http://localhost:8080/api/test/hello
       参数：access_token

密码模式的过程如下：

1、根据用户名密码等参数直接获取token
       接口：http://localhost:8080/oauth/token
       参数：username password grant_type client_id client_secret redirect_uri
       返回值：access_token
    2、根据token，访问资源
       接口：http://localhost:8080/api/test/hello
       参数：access_token

可以看出，授权码模式和密码模式有些区别，授权码模式多了一步就是登陆。密码模式直接把用户名和密码交给授权服务器了，所以不用再人为登陆，这也要求用户非常信任该应用。

下面我们通过代码来实际感受一下他们的使用以及区别：

也是构建一个项目，这里就不用分开授权服务和资源服务，统一放在一起：

项目依赖主要还是security和oauth2：

<parent>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-parent</artifactId>
    	<version>2.1.4.RELEASE</version>
    </parent>
    
    <dependencies>
    	<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-web</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-oauth2</artifactId>
    		<version>2.3.4.RELEASE</version>
    	</dependency>
    </dependencies>

项目结构：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70][]

主要的代码：

AuthServerConfiguration.java

package org.oauthsample.config;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.http.HttpMethod;
    import org.springframework.security.authentication.AuthenticationManager;
    import org.springframework.security.crypto.password.PasswordEncoder;
    import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
    import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
    import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
    import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
    import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
    @Configuration
    @EnableAuthorizationServer
    public class AuthServerConfiguration extends AuthorizationServerConfigurerAdapter{
    	@Autowired
    	private AuthenticationManager authenticationManager;
    	@Autowired
    	private PasswordEncoder passwordEncoder;
    	
    	@Override
    	public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
    		endpoints.authenticationManager(authenticationManager);
    		endpoints.allowedTokenEndpointRequestMethods(HttpMethod.GET,HttpMethod.POST);
    	}
    	
    	@Override
    	public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
    		security.realm("oauth2-resources")
    				.tokenKeyAccess("permitAll()")
    				.checkTokenAccess("isAuthenticated()")
    				.allowFormAuthenticationForClients();
    	}
    	
    	@Override
    	public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
    		clients.inMemory()
    			   .withClient("client")
    			   .secret(passwordEncoder.encode("secret"))
    			   .redirectUris("http://example.com")
    			   .authorizedGrantTypes("authorization_code","password","refresh_token","implicit","client_credentials")
    			   .scopes("all")
    			   .autoApprove(true)
    			   .resourceIds("oauth2-resource")
    			   .accessTokenValiditySeconds(1200)
    			   .refreshTokenValiditySeconds(50000);
    	}
    }

授权配置，这里指定了四种授权方式，外加一个刷新令牌(refresh\_token)的方式，这个是在令牌(token)失效的情况下无需重新走一遍全部流程，只需要做一次刷新请求即可获得新的access\_token。

ResourceServerConfiguration.java

package org.oauthsample.config;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
    import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
    @Configuration
    @EnableResourceServer
    public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter{
    	@Override
    	public void configure(HttpSecurity http) throws Exception {
    		http.authorizeRequests()
    			.antMatchers("/api/**").hasRole("ADMIN")
    			.antMatchers("/test/**").authenticated()
    			.anyRequest().authenticated();
    	}
    }

资源服务器设置了/api/\*\*下的接口访问需要用户登录授权，还需要ADMIN角色，而/test/\*\*仅仅需要用户登录授权即可。

SecurityConfiguration.java

package org.oauthsample.config;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.authentication.AuthenticationManager;
    import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    import org.springframework.security.core.userdetails.User;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    import org.springframework.security.crypto.password.PasswordEncoder;
    import org.springframework.security.provisioning.InMemoryUserDetailsManager;
    @Configuration
    @EnableWebSecurity
    //@Order(1)
    public class SecurityConfiguration extends WebSecurityConfigurerAdapter{
    	@Bean
    	public PasswordEncoder passwordEncoder() {
    		return new BCryptPasswordEncoder();
    	}
    	
    	@Override
    	@Bean
    	public AuthenticationManager authenticationManagerBean() throws Exception {
    		return super.authenticationManagerBean();
    	}
    	
    	@Override
    	protected UserDetailsService userDetailsService() {
    		InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
    		manager.createUser(User.withUsername("admin").password(passwordEncoder().encode("admin")).roles("ADMIN").build());
    		manager.createUser(User.withUsername("user").password(passwordEncoder().encode("123456")).roles("USER").build());
    		return manager;
    	}
    	
    	@Override
    	protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    		auth.userDetailsService(userDetailsService()).passwordEncoder(passwordEncoder());
    	}
    	
    	
    	@Override
    	protected void configure(HttpSecurity http) throws Exception {
    		http.httpBasic().and()
    			.authorizeRequests()
    			.antMatchers("/oauth/**","/login")
    			.permitAll()
    			.anyRequest()
    			.authenticated()
    			//.and()
    			//.formLogin()
    			.and()
    			.csrf().disable();
    	}
    	
    }

Security配置了两个用户，一个ADMIN角色，另外一个USER角色，稍作区分，为后面的测试做准备。

HelloController.java

package org.oauthsample.web;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    @RestController
    @RequestMapping("/api/test")
    public class HelloController {
    	@GetMapping("/hello")
    	public String hello() {
    		return "hello,authenticated() with role ADMIN.";
    	}
    }

TestController.java

package org.oauthsample.web;
    
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    @RestController
    @RequestMapping("/test")
    public class TestController {
    	
    	@GetMapping("/hello")
    	public String hello() {
    		return "hello,authenticated().";
    	}
    }

这里两个测试接口，分别对应资源服务中设置的权限/api/test/hello不仅需要用户登录授权，还需要ADMIN角色，而/test/hello只需要用户登录授权即可，不需要角色。

Application.java

package org.oauthsample;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    @SpringBootApplication
    public class Application {
        public static void main( String[] args ){
            SpringApplication.run(Application.class, args);
        }
    }

application.yaml

server:
      port: 8080

默认端口可以不用配置。

代码准备完毕，可以运行起来，然后进行相关的测试：

我个人不太理解的是，这些个模式下的验证，理论上如果实现了，肯定都是代码来运行，而不是人为的去通过浏览器或者postman来获取参数，并且验证接口请求是否满足权限要求。

因为授权码模式需要在浏览器上进行登录，所以这里需要借助浏览器，另外一些post请求就借助postman来发送，所以呢需要的测试工具就是浏览器和postman。

先来看看直接访问接口：http://localhost:8080/test/hello或者http://localhost:8080/api/test/hello

![20200820153655121.png][]

![20200820153711986.png][]

因为都需要access\_token参数才能访问，所以我们先获取，第一种通过authorization\_code即授权码模式来获取：

[http://localhost:8080/oauth/authorize?response\_type=code&state=123456&client\_id=client&scope=all&redirect\_uri=http://example.com][http_localhost_8080_oauth_authorize_response_type_code_state_123456_client_id_client_scope_all_redirect_uri_http_example.com]

这里有个参数state，他并不是一个必须的参数，有的文章说是用来防止攻击的，他可以是任意值。

通过浏览器访问以上地址，第一次没有登录，会弹出登录提示框，输入用户名密码(admin/admin)，然后会跳到redirect\_uri参数指定的页面，这里是http://example.com，地址栏会携带参数code。如下所示：

[http://example.com/?code=8QzGxv&state=123456][http_example.com_code_8QzGxv_state_123456]

以上过程截图如下：

![20200820154421760.gif][]

拿到code,我们在postman中发送post请求到http://localhost:8080/oauth/token接口，并携带如下参数：client\_id,client\_secret,grant\_type,code,state,redirect\_uri参数。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 1][]

这时候，我们再将access\_token=9536a51d-a597-415a-8aac-a220202ae460参数带上，分别访问接口/api/test/hello和/test/hello，看看效果：

![20200820155046122.png][]

因为是ADMIN角色，所以两个接口都可以访问。

![20200820155058140.png][]

我们再通过user/123456用户登录授权，获取的access\_token来看看访问的效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 2][]

返回的code是：zBY5RP，请求获取token

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 3][]

利用这个access\_token，分别访问两个接口，得到结果：

访问普通登录授权即可的接口时，是OK的：

![20200820160136301.png][]

当访问需要ADMIN角色的接口时，报访问拒绝错误。

![20200820160146632.png][]

\*\*\*\*\*\*\*\*\*\*\*密码模式验证（password）\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

密码模式我们都通过postman来测试，就不需要浏览器了。我们看看结果就好：

开始的时候，不带参数access\_token访问两个接口：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 4][]

首先通过postman访问接口http://localhost:8080/oauth/token，参数就是grant\_type,username,password,client\_id,client\_secret,redirect\_uri。与authorization\_code授权方式不同的是，这里的grant\_type=password，而且增加了参数client\_secret，和username,password，这就是密码模式的授权方式。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 5][]

利用这个access\_token=b02a9a11-1674-4bef-aaae-f334e973bbfd分别访问/api/test/hello和/test/hello接口也都正常：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 6][]

另一个接口：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 7][]

我们使用user/123456用户密码获取access\_token：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 8][]

得到的access\_token=72f55af7-aa77-4af5-9e80-fcf6d1095bbe，通过该令牌，我们访问/api/test/hello与/test/hello接口：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 9][]

访问需要ADMIN角色的接口，访问受限，而普通用户授权的就可以：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 10][]

以上，通过大篇幅的测试，验证了authorization\_code与password两种授权方式的可行性，以及他们的区别，还有两种模式下不同用户访问不同接口的不同响应。

在此，我也是体验了通过spring-boot与spring-security、spring-security-oauth2实现 oauth2的效果。个人对oauth2的理解也非常浅显，虽然验证了，但是还有很多不明白之处，尤其是资源服务器和权限管理之间启动的先后顺序，我们关注到，其实security和resource都有关于权限的部分，他们都会拦截请求url。

另外，这里虽然使用security实现了oauth2授权，但是在授权码模式下，用户登录并不是一个页面表单的形式，而是一个弹出框的表单形式，这一点我很诧异。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70]: /images/20221124/349d67984442473f917f657aedf24b25.png
[20200820153655121.png]: /images/20221124/4f139ecf6d8a481bb06c91cf3eb6af4a.png
[20200820153711986.png]: /images/20221124/017d7216ccdd441e957bd8177e48687d.png
[http_localhost_8080_oauth_authorize_response_type_code_state_123456_client_id_client_scope_all_redirect_uri_http_example.com]: http://localhost:8080/oauth/authorize?response_type=code&state=123456&client_id=client&scope=all&redirect_uri=http://example.com
[http_example.com_code_8QzGxv_state_123456]: http://example.com/?code=8QzGxv&state=123456
[20200820154421760.gif]: /images/20221124/843a66da9207492ab320013af9d2ba3d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 1]: /images/20221124/dcd1ab25e267433081e234234cacf21e.png
[20200820155046122.png]: /images/20221124/0f2f8839abdb4c8586315c9150641241.png
[20200820155058140.png]: /images/20221124/896db5010f274e9486d94a7745a294b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 2]: /images/20221124/664f489fff6249a882b192df73b1f328.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 3]: /images/20221124/122c2376e4744af6b7ea8d3939351f1f.png
[20200820160136301.png]: /images/20221124/0885a3c804a04e3d942e1627e1fdc644.png
[20200820160146632.png]: /images/20221124/6fe59d0a35ed43ec81e019b1b9811587.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 4]: /images/20221124/91953d3f27a74133b3bedaa3d8580471.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 5]: /images/20221124/483c457becfd4e4b999c72307b5a444a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 6]: /images/20221124/663c7a3da201407e994c0288d41ea116.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 7]: /images/20221124/ac758c2caeb94b38b36811cf1b075b2b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 8]: /images/20221124/fca9e4eae5d748098b7a815363284bcc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 9]: /images/20221124/2b31a8133c48449e84edddb70bbdba08.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaW5pZmk_size_16_color_FFFFFF_t_70 10]: /images/20221124/c9a3d09ab64d469d83f9807f0496a891.png