springsecurity oauth2实现前后端分离项目的SSO技术点总结

参考：

https://www.jianshu.com/p/b549220e7b34?ivk_sa=1024320u

一、基于cookie+session的SSO基本实现

1、认证中心的授权服务器配置

配置类继承AuthorizationServerConfigurerAdapter，解决可以将哪些资源进行授权、怎么授权的问题。

1）服务安全配置

对授权服务相关的接口进行安全访问的相关设置，如/oauth/token_key,/oauth/token等。

public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
    security.allowFormAuthenticationForClients()
        .tokenKeyAccess("isAuthenticated()");
}

2）客户端信息配置

加载注册的客户端信息，可以从数据库中加载。

@Bean
public ClientDetailsService inMemoryClientDetailsService() throws Exception {
	return new InMemoryClientDetailsServiceBuilder()
			// client oa application
			.withClient("client1")
			.secret(passwordEncoder.encode("client1_secret"))
			.scopes("all")
			.authorizedGrantTypes("authorization_code", "refresh_token")
			.redirectUris("http://client1.com/client1/login")
			.accessTokenValiditySeconds(7200)
            // 自动授权
			.autoApprove(true)

			.and()

			// client crm application
			.withClient("client2")
			.secret(passwordEncoder.encode("client2_secret"))
			.scopes("all")
			.authorizedGrantTypes("authorization_code", "refresh_token")
			.redirectUris("http://client2.com/client2/login")
			.accessTokenValiditySeconds(7200)
            // 自动授权
			.autoApprove(true)

			.and()
			.build();
} 
@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
	clients.withClientDetails(inMemoryClientDetailsService());
}

3）服务端点token配置

配置token的管理器及存储器，存储方式可以是jwt、jdbc、redis。

@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
				//指定token的管理器
	endpoints.accessTokenConverter(jwtAccessTokenConverter())
				//指定token的存储器
			.tokenStore(jwtTokenStore());
}

@Bean
public JwtTokenStore jwtTokenStore() {
	return new JwtTokenStore(jwtAccessTokenConverter());
}

@Bean
public JwtAccessTokenConverter jwtAccessTokenConverter() {
	JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
	jwtAccessTokenConverter.setSigningKey("123456");
	return jwtAccessTokenConverter;
}

2、认证中心的web安全配置

配置对用户的认证和对项目相关资源的访问配置，加载用户及权限，主要解决是谁和有哪些权限的问题。

1）认证管理配置

需要指定用户获取的服务，以及密码编码器。

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    // 配置用户信息获取的服务，及密码编码器（用于将前端传过来的密码参数进行编码）
	auth.userDetailsService(userDetailsServiceBean()).passwordEncoder(passwordEncoder());
}

@Bean
@Override
public UserDetailsService userDetailsServiceBean() {
	Collection users = buildUsers();

	return new InMemoryUserDetailsManager(users);
}

// 可以从数据库中进行获取
private Collection buildUsers() {
	String password = passwordEncoder().encode("123456");

	List users = new ArrayList<>();

	UserDetails user_admin = User.withUsername("admin").password(password).authorities("ADMIN", "USER").build();
	UserDetails user_user1 = User.withUsername("user1").password(password).authorities("USER").build();

	users.add(user_admin);
	users.add(user_user1);

	return users;
}

@Bean
public PasswordEncoder passwordEncoder() {
	return new BCryptPasswordEncoder();
}

2）http安全配置

指定表单登录、手机验证登录等方式，并配置对应的未登录认证的入口、登录成功和失败的处理器等。

自定义未登录认证入口，解决跳转到认证中心前端登录页面（需要由异常处理器进行处理）

@Component("unauthorizedEntryPoint")
public class UnauthorizedEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
        Map paramMap = request.getParameterMap();
        StringBuilder param = new StringBuilder();
        paramMap.forEach((k, v) -> {
            param.append("&").append(k).append("=").append(v[0]);
        });
        param.deleteCharAt(0);
        String isRedirectValue = request.getParameter("isRedirect");
        if (!StringUtils.isEmpty(isRedirectValue) && Boolean.valueOf(isRedirectValue)) {
            response.sendRedirect("http://oauth.com/authPage/login?"+param.toString());
            return;
        }
		// 如果前端ajax请求兼容处理了登录页面的响应（即text/html，而非application/json，前端处理见5、客户端前端配置），
		// 可以不需要返回json结果，直接response.sendRedirect到登录界面，
        // 建议前端ajax兼容处理sendRedirect方式返回的页面，方便非ajax请求直接重定向到登录页面，
        // 因为在这里很难判断最原始的请求（客户端的前端请求）是否为ajax请求
        String authUrl = "http://oauth.com/auth/oauth/authorize?"+param.toString()+"&isRedirect=true";
        Result result = new Result();
        result.setCode(800);
        result.setData(authUrl);
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        PrintWriter writer = response.getWriter();
        ObjectMapper mapper = new ObjectMapper();
        writer.print(mapper.writeValueAsString(result));
        writer.flush();
        writer.close();
    }
}

自定义登录成功处理

@Component("successAuthentication")
public class SuccessAuthentication extends SavedRequestAwareAuthenticationSuccessHandler {

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws ServletException, IOException {
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        PrintWriter writer = response.getWriter();
        Result result = new Result();
        result.setCode(0);
        result.setMsg("成功");
        ObjectMapper mapper = new ObjectMapper();
        writer.println(mapper.writeValueAsString(result));
        writer.flush();
        writer.close();
    }
}

自定义登录失败处理

@Component("failureAuthentication")
public class FailureAuthentication extends SimpleUrlAuthenticationFailureHandler {

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        PrintWriter writer = response.getWriter();
        Result result = new Result();
        result.setCode(1000);
        result.setMsg("登录失败");
        ObjectMapper mapper = new ObjectMapper();
        writer.println(mapper.writeValueAsString(result));
        writer.flush();
        writer.close();
    }
}

http安全配置

@Override
protected void configure(HttpSecurity http) throws Exception {
	http.cors().and().csrf().disable()
			.exceptionHandling().authenticationEntryPoint(unauthorizedEntryPoint)
			.and()
			.authorizeRequests()
			.antMatchers("/login").permitAll()
			.anyRequest().authenticated()
			.and()
			.formLogin().successHandler(successAuthentication).failureHandler(failureAuthentication);
}

3）web安全配置

指定访问哪些资源的请求可以不需要进行认证。

@Override
public void configure(WebSecurity web) throws Exception {
	web.ignoring().antMatchers("/assets/**", "/css/**", "/images/**");
}

3、 认证中心跨域处理

从客户端的前端重定向到认证中心的授权服务/oauth/authorize，如果在nginx代理设置了跨域，则这个过滤器必须设置成无效，因为相同的跨域配置只能配置一次。

@Order(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnProperty(prefix = "server.cors",name = "enable",havingValue = "true")//可让该filter失效，即不加载此filter
public class CORSFilter implements Filter {

    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        HttpServletResponse response = (HttpServletResponse) res;
        HttpServletRequest request = (HttpServletRequest) req;
        //允许所有的域访问，可以设置只允许自己的域访问
        response.setHeader("Access-Control-Allow-Origin", "*");
        //允许所有方式的请求
        response.setHeader("Access-Control-Allow-Methods", "*");
        //头信息缓存有效时长（如果不设 Chromium 同时规定了一个默认值 5 秒），没有缓存将已OPTIONS进行预请求
        response.setHeader("Access-Control-Max-Age", "3600");
        //允许的头信息
        response.setHeader("Access-Control-Allow-Headers", "x-requested-with, authorization");

        if ("OPTIONS".equalsIgnoreCase(request.getMethod())) {
            response.setStatus(HttpServletResponse.SC_OK);
        } else {
            chain.doFilter(req, res);
        }
    }
}

4、客户端配置

1）启用SSO客户端

继承WebSecurityConfigurerAdapter，开启@EnableOAuth2Sso

@EnableOAuth2Sso
@Configuration
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(WebSecurity web) throws Exception {
        super.configure(web);
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.logout()
                .and()
                .authorizeRequests()
                .anyRequest().authenticated()
                .and()
                .csrf().disable();
    }
}

2）配置OAUTH2服务相关配置

server:
  port: 8081
  servlet:
    context-path: /client1

security:
  oauth2:
    client:
      client-id: client1
      client-secret: client1_secret
      access-token-uri: http://oauth.com/auth/oauth/token
      user-authorization-uri: http://oauth.com/auth/oauth/authorize
    resource:
      jwt:
        key-uri: http://oauth.com:8080/auth/oauth/token_key

5、认证中心前端设置

如果客户端的前端ajax重定向到认证中心的前端登录页面，需要对认证中心的前端（nginx）设置允许跨域访问。

server {
	listen          80;
	server_name     oauth.com;

	location /auth/ {
		proxy_set_header Host $host;
		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
		proxy_pass http://localhost:8080/auth/;
	}
	
	location ^~ /authPage {
		try_files $uri $uri/ /authPage/index.html;
        # 设置允许跨域访问，即客户端的前端ajax请求回调处理时，可以使用window.location.href访问认证中心的前端登录页面
        # 这种情况是认证中心在判断未登录时直接重定向到认证中心的前端登录页面
		add_header 'Access-Control-Allow-Origin' $http_origin;
		add_header 'Access-Control-Allow-Credentials' 'true';
	}
}

1）登录请求处理

前端使用的ajax框架是axios。登录成功重定向到授权服务。

postRequest('/auth/login', this.loginForm).then(resp => {
  if (resp.data.code === 0) {
	var pageUrl = window.location.href
	var param = pageUrl.split('?')[1]
	window.location.href = '/auth/oauth/authorize?'+param
  } else {
	console.log('登录失败：'+resp.data.msg)
  }
})

6、客户端前端配置

前端使用的ajax框架是axios。

1）请求客户端服务器受保护的资源

请求受保护的资源/client1/test

getRequest('/client1/test').then(resp=>{
	// 如果认证中心直接返回页面信息（认证中心的登录页面），则直接进行重定向（建议使用这种）
	if(resp.headers['content-type']=="text/html" && resp.request.responseURL){
	  window.location.href = resp.request.responseURL;
	}
	if (resp.data.code === 0) {
	  this.msg = resp.data.data
	  // 如果认证中心返回了json，且返回码为800表示未登录
	}else if (resp.data.code === 800) {
	  window.location.href = resp.data.data
	} else {
	  console.log('失败：'+resp.data)
	}
})

2）代理nginx配置

server {
	listen          80;
	server_name     client1.com;

	location /client1/ {
        # 设置代理后的Host仍然为请求的域名
		proxy_set_header Host $host;
		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
		proxy_pass http://localhost:8081/client1/;
	}
	
	location ^~ /client1Page {
        # 尝试查找uri地址所表示的文件目录，如果没找到，则返回文件/client1Page/index.html
		try_files $uri $uri/ /client1Page/index.html;
	}
}

二、理解http协议响应码302

302重定向是暂时的重定向，搜索引擎会抓取新的内容而保存旧的网址。

通常与location一起使用，搜索引擎根据location所指向的地址，临时重定向到该地址，但不会覆盖旧的网址，此时新网址的返回结果可以在旧网址发起请求的地方获取到，如ajax的返回处理。如果中间会有多次302，则会将最后一次拿到的结果返回到旧网址发起请求的地方，即ajax可以接收到多次重定向后返回的最终结果（最终结果就是最后一次返回非302）后，进行进一步的处理，如后端通过response.sendRedirect（默认的http返回码是200），设置重定向地址是登录页面，则可以使用window.location.href进行重定向。

见客户端的前端处理逻辑：

// 如果认证中心直接返回页面信息（认证中心的登录页面），则直接进行重定向（建议使用这种）
if(resp.headers['content-type']=="text/html" && resp.request.responseURL){
	window.location.href = resp.request.responseURL;
}

三、跨域请求的处理

认证中心后端服务，可以配置支持跨域请求的过滤器CorsFilter，或者在代理服务器nginx中进行配置，只允许配置一次。

认证中心前端服务器nginx，如果是由客户端的前端ajax请求后需要使用window.location.href访问认证中心前端的登录页面，那么认证中心前端服务器nginx需要设置允许跨域访问。

四、ajax遇到重定向问题

通过ajax请求受保护的资源时，浏览器会经过多次302处理，即多次临时重定向后，直到返回非302状态码时，ajax可以获取到结果，如果结果不是json格式，而是html即text/html格式，则此时可以使用window.location.href重定向到返回结果中所指定的url地址。

五、整个登录授权处理过程梳理

三个阶段：

1、ajax请求客户端受保护的资源，直到返回认证中心的登录页面，中间过程会在客户端后端服务和认证中心后端服务之间进行多次302的重定向； 

2、用户输入登录信息并ajax提交给认证中心后台服务，返回响应码200； 

3、ajax处理返回结果，登录成功重新请求认证中心的授权接口，直到返回响应码和客户端的前端主页，中间过程会在客户端后端服务和认证中心后端服务之间进行多次302的重定向。