项目总结之Oauth2.0免登陆及相关知识点总结

时间:2023-03-08 16:14:54

简介Oauth2.0授权步骤

授权码模式的基本步骤

原文链接地址

(A)用户访问客户端,后者将前者导向认证服务器。

(B)用户选择是否给予客户端授权。

(C)假设用户给予授权,认证服务器将用户导向客户端事先指定的"重定向URI"(redirection URI),同时附上一个授权码。

(D)客户端收到授权码,附上早先的"重定向URI",向认证服务器申请令牌。这一步是在客户端的后台的服务器上完成的,对用户不可见。

(E)认证服务器核对了授权码和重定向URI,确认无误后,向客户端发送访问令牌(access token)和更新令牌(refresh token)。

各步骤详细解析

A步骤中,客户端申请认证的URI,包含以下参数:

  • response_type:表示授权类型,必选项,此处的值固定为"code"
  • client_id:表示客户端的ID,必选项
  • redirect_uri:表示重定向URI,可选项
  • scope:表示申请的权限范围,可选项
  • state:表示客户端的当前状态,可以指定任意值,认证服务器会原封不动地返回这个值。
  • 下面是一个例子。

    /authorize?response_type=code&client_id=s6BhdRkqt3&state=xyz

    &redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb

C步骤中,服务器回应客户端的URI,包含以下参数:

  • code:表示授权码,必选项。该码的有效期应该很短,通常设为10分钟,客户端只能使用该码一次,否则会被授权服务器拒绝。该码与客户端ID和重定向URI,是一一对应关系。
  • state:如果客户端的请求中包含这个参数,认证服务器的回应也必须一模一样包含这个参数
  • 下面是一个例子。 https://client.example.com/cb?code=SplxlOBeZQQYbYS6WxSbIA

    &state=xyz

D步骤中,客户端向认证服务器申请令牌的HTTP请求,包含以下参数:

  • grant_type:表示使用的授权模式,必选项,此处的值固定为"authorization_code"。
  • code:表示上一步获得的授权码,必选项。
  • redirect_uri:表示重定向URI,必选项,且必须与A步骤中的该参数值保持一致。
  • client_id:表示客户端ID,必选项。
  • 下面是一个例子。 /token?grant_type=authorization_code&code=SplxlOBeZQQYbYS6WxSbIA

    &redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb

E步骤中,认证服务器发送的HTTP回复,包含以下参数:

  • access_token:表示访问令牌,必选项。
  • token_type:表示令牌类型,该值大小写不敏感,必选项,可以是bearer类型或mac类型。
  • expires_in:表示过期时间,单位为秒。如果省略该参数,必须其他方式设置过期时间。
  • refresh_token:表示更新令牌,用来获取下一次的访问令牌,可选项。
  • scope:表示权限范围,如果与客户端申请的范围一致,此项可省略。
  • 下面是一个例子。{

    "access_token":"2YotnFZFEjr1zCsicMWpAA",

    "token_type":"example",

    "expires_in":3600,

    "refresh_token":"tGzv3JOkF0XG5Qx2TlKWIA",

    "example_parameter":"example_value"

    }

项目实战总结

项目背景简介

  • 项目用的spring全家桶+shiro+oauth2.0,不懂shiro也没关系
  • A系统为门户系统,需要用户登录;
  • B系统是一个业务系统,嵌在A系统里面,所以不需要再重新登陆,不提供相关登陆接口;

具体代码及流程

先介绍B网站登陆认证流程

第一步

  • 有一个filter,继承自shiro的【UserFilter】,onAccessDenied方法(即未登录状态下访问B接口)
@Override
protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
0. 获取当前请求的requestUri=requestUri()
1. 生成uuid
2. 将request保存到redis,有效期30秒,redis.set(uuid,request)
3. loginUrl = getLoginUrl()="/B/login?oauth";配置文件
4. 重定向到loginUrl?redirect_uri=/B/proxy?_oauth=uuid
即/B/login?oauth&redirect_uri=/B/proxy?_oauth=uuid 总结:单纯系统内拦截未登录的请求,并将请求信息保存下来,然后跳转到B系统的登陆url,附加了一些参数,方便回调
}

第二步

@RequestMapping("/login")
public void login(
HttpServletRequest request,
HttpServletResponse response
) throws URISyntaxException, IOException{ String code=request.getParameter("code");
if(StringUtils.isNotBlank(code)){
// ...
// 判断code的先省略,一会再看
// code不为空,代表是从A系统授权过来的请求
// ....
}else{
else 部分的方法见下面 } // else 部分的方法 // 获取loginUrl=http://localhost:8080/B/login相当于是写死的
1.loginUrl=String.format("%s://%s:%d%s/%s",request.getScheme(),request.getServerName(),request.getServerPort(),request.getContextPath(),"login");
2.取第一步中的传过来的参数redirect_uri,拼接到loginUrl的后面,
3.新的loginUrl=http://localhost:8080/B/login?redirect_uri=/B/proxy?_oauth=b54896bc-2c26-4763-a2a6-7cbfb9223c76
// 以上都只是在自己的系统中拼装参数之类的
// 接下来就是应用Oauth2相关的协议了
我们在B系统的配置文件中配置了以下配置项
oauth2.url=http://localhost:8080/A
oauth2.loginUrl=http://localhost/A
oauth2.resource.charset=utf-8
oauth2.authorize=/oauth2/authorize
oauth2.access_token=/oauth2/access_token
oauth2.resource=/oauth2/resource
oauth2.client_id=c3991093-f25c-11e6-b7ab-524f72a73ffc
oauth2.client_secret=d02153b8-f25c-11e6-b7ab-524f72a73ffc
4.接下来就要调用/A系统中的方法授权方法了,取{oauth2.loginUrl}和{oauth2.authorize}俩个参数,拼装成:http://localhost/portal.web/oauth2/authorize。
5.接下来再拼装Oauth的参数
4和5俩不代码如下
URIBuilder uriBuilder=new URIBuilder((StringUtils.isBlank(loginUrl)?url:loginUrl)+authorizeUrl);
uriBuilder.addParameter("response_type", "code");
uriBuilder.addParameter("client_id", clientId);
//参数logoutUrl的获取方式与本方法的loginUrl获取方式一致
uriBuilder.addParameter("logout_uri",logoutUrl);
uriBuilder.addParameter("state", "portal");
// reUrl就是本方法步骤3生成的loginUrl
uriBuilder.addParameter("redirect_uri", reUrl); 6.最后一步就是跳转到A系统请求授权redirect(URIBuilder.toString)
}

第三步

  • A系统的方法
    1. A系统同样有一个filter用来拦截请求,继承自shiro的UserFilter,当遇到没有登陆的请求时,
    @Override
protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
// 获取请求
String requestURI = getPathWithinApplication(request);
// 判断请求,如果是登陆请求则直接拦截(意味着shiro会将重定向到登陆页面);如果不是登陆请求,则保存请求,然后重定向
boolean isLogin=requestURI.indexOf(getLoginUrl())>-1;
if(!isLogin){ String url=request.getRequestURI().toLowerCase();
if(url.indexOf("?")>0){ //去掉?后面的参数
url=url.substring(0,url.indexOf("?"));
}
if(url.endsWith(DEFAULT_REQUEST_JSON) || isJsonRequest(request)){
forwardResponseJson(request, response);
}else if(url.endsWith(DEFAULT_REQUEST_JSONP)){
forwardResponseJsonp(request, response);
}else if(url.endsWith(DEFAULT_REQUEST_XML)){
forwardResponseXml(request, response);
}else{
//判断是否是oauth2请求,否则返回局部界面
String requestURI = getPathWithinApplication(request);
if(requestURI.equals("/oauth2/authorize")) {
// 第二步中发起的授权请求会进入此处
saveRequestAndRedirectToLogin(request, response);
}else{
redirectToLogin(request, response);
}
}
}
return isLogin;
}

第3.1步 saveRequestAndRedirectToLogin方法

   // shiro的方法
@Override
protected void saveRequestAndRedirectToLogin(ServletRequest request, ServletResponse response) throws IOException {
saveRequest(request);
redirectToLogin(request, response);
}

第4步

经过3.1步后,此时系统跳转到A系统的登陆页面,用户输入账号密码后,登陆成功后判断是否是非登陆的请求,是的话则跳转到之前的请求。登陆代码略过,
private void addRedirectUrl(LoginVo lv) {
Subject subject =SecurityUtils.getSubject();
SavedRequest savedRequest=(SavedRequest)subject.getSession().getAttribute(WebUtils.SAVED_REQUEST_KEY);
if(savedRequest!=null) {
// 此时uri = /portal.web/oauth2/authorize,就是3.1步中保存下来的请求
String uri=savedRequest.getRequestURI();
if(uri.endsWith("/oauth2/authorize")){
// 取即将跳转的url
// url=/portal.web/oauth2/authorize?response_type=code&client_id=c3991093-f25c-11e6-b7ab-524f72a73ffc&logout_uri=http%3A%2F%2Flocalhost%3A8080%2Fcrm-web%2Flogout&state=portal&redirect_uri=http%3A%2F%2Flocalhost%3A8080%2Fcrm-web%2Flogin%3Fredirect_uri%3D%2Fcrm-web%2Fproxy%3F_oauth%3D9041035e-8cd1-48fb-9c90-adc46f9abcae
//
String url=savedRequest.getRequestUrl();
// 这里就是关键了,前端会根据这个字段来判断跳转到哪里,如果不为空就会跳转到url所在的url。前端代码
lv.setRedirectUrl(url); // 再从shiro的session中移除该请求的信息
Subject subject =SecurityUtils.getSubject();
subject.getSession().removeAttribute(WebUtils.SAVED_REQUEST_KEY);
}
}
}

第5步

此时肯定是已经登陆了A系统,即将访问A系统的/oauth2/authorize方法如下

这里先把第3/4步的请求本方法的参数打开,方便观看,携带的参数如下

{

response_type=code,

client_id=c3991093-f25c-11e6-b7ab-524f72a73ffc,

logout_uri=http://localhost:8080/crm-web/logout,

state=portal,

redirect_uri=redirect_uri=http://localhost:8080/crm-web/login?redirect_uri=/crm-web/proxy?_oauth=9041035e-8cd1-48fb-9c90-adc46f9abcae

}

这个redirect_uri参数注意一下,它还接着一个redirect_uri,带着了一会登陆B系统后再跳转到后接着的这个redirect_uri参数

@RequestMapping(value = "/authorize",method = RequestMethod.GET)
protected void authorize(HttpServletRequest request,HttpServletResponse response){
OAuthResponse resp=null;
OAuthAuthzRequest oauthRequest = oauthRequest = new OAuthAuthzRequest(request);
// 判断clientId是否存在
if(exists(oauthRequest.getClientId())){
// 生成一个授权code
MD5Generator generator=new MD5Generator();
OAuthIssuer oauthIssuer = new OAuthIssuerImpl(generator);
String authCode = oauthIssuer.authorizationCode();
// OAuth.OAUTH_REDIRECT_URI = "redirect_uri"
String redirectUri=oauthRequest.getParam(OAuth.OAUTH_REDIRECT_URI);
// 然后将刚生成的code与redirect_uri拼在一起生成一个新的code
String code=generator.generateValue(String.format("%s@%s",authCode,redirectUri));
// 将新生成的code封装成code参数拼装到redirectUri的后面
redirectUri=String.format("%s&code=%s",redirectUri,code);
// 这一串看着挺吓人,就是bean的builder模式,简单说就是根据属性值生成一个bean而已
resp = OAuthASResponse
.setCode(code)
.setParam("rs-platform-id", String.valueOf(platId))
.location(redirectUri)
.buildQueryMessage(); //将clientId,code,redirectUri, user封成一个对象,存储到redis
redis.save(clientId,code,redirectUri, user) // 跳转到resp.getLocationUri()
// http://localhost:8080/B/login?redirect_uri=/B/proxy?_oauth=549c9e2e-f74a-4a53-8029-b8f8ceb144cb&code=224d33890c31c78070e151897c6f2882&code=224d33890c31c78070e151897c6f2882&state=portal
//至此,终于又跳回到B系统的login方法了,相比第一次,多了一个code参数
response.sendRedirect(resp.getLocationUri()); }
}

第6步

补全B系统的login方法

@RequestMapping("/login")
public void login(
HttpServletRequest request,
HttpServletResponse response
) throws URISyntaxException, IOException{
// 补全判断code相关的方法,其余方法见第2步
String code=request.getParameter("code");
if(StringUtils.isNotBlank(code)){
String host=request.getRemoteHost();
String reutrnUri=request.getParameter(OAuth2Utils.OAUTH_RETURN_URI); RunsaOAuthToken token=new RunsaOAuthToken(code,false,host);
ResourceVo resource=new ResourceVo();
try {
// 用code换access_token
OAuth2Response oauthResponse = OAuth2Utils.accessToken(code);
// 用access_token换资源,我们项目中只用到了免登陆,所以取的是登陆信息
resource=OAuth2Utils.resource(oauthResponse);
token.setPrincipal(new PrincipalVo(resource.getUser(),resource.getAuthz()));
// 系统B的登陆
subject.login(token);
//调转到访问路径
if(StringUtils.isNotBlank(reutrnUri)){
response.sendRedirect(reutrnUri);
}
}catch (Exception e) {
logger.error(ExceptionUtils.getStackTrace(e));
OutputStream outputStream=response.getOutputStream();
IOUtils.write(ExceptionUtils.getStackTrace(e), outputStream);
IOUtils.closeQuietly(outputStream);
}
}else{
// 剩下的方法详细代码见第2步
}
}

到这里整个大概的流程就结束

下面介绍用code换取token和用token换取source这俩个方法。在我们项目中不太重视这个,我们俩个A/B俩个项目用的一个数据库,想取啥数据直接数据库取就好了。只是免登陆,减少用户操作罢了,没有用到oauth的精髓。我们后来又有了一个项目C,就没有再用oauth这种重量级的东西来仅仅做一个免登陆功能了,用的jwt。用户登录A后将登陆信息生成一个jwt放在cookie里,请求C接口时带上jwt就好了。仅仅一个免登陆就要用oauth2来实现,有点大材小用的感觉。当然这不妨碍我们学习。我们项目还自写了类似mybatis的东西;为了一个搜索,还引入了es,可惜最后没有投入使用,只进行了一半。(es做一半离职了)炫技的结果

第7步 code换access_token

@RequestMapping(value = "/access_token",method = RequestMethod.POST)
protected void token(HttpServletRequest request,
HttpServletResponse response) throws OAuthSystemException, IOException {
OAuthTokenRequest oauthRequest = null;
OAuthResponse oauthResponse=null;
OAuthIssuer oauthIssuerImpl = new OAuthIssuerImpl(new MD5Generator());
try {
oauthRequest = new OAuthTokenRequest(request);
String authzCode = oauthRequest.getCode();
OAuth2Secret oAuth2Secret=oAuth2Service.selectSecretById(oauthRequest.getClientId(), oauthRequest.getClientSecret());
if(null!=oAuth2Secret){
OAuth2Vo vo=oAuthTokenUtils.select(authzCode);
if(null!=vo){
// 生成令牌,简单理解其实就是uuid
String accessToken = oauthIssuerImpl.accessToken();
String refreshToken = oauthIssuerImpl.refreshToken();
// 拼装一个json
oauthResponse = OAuthASResponse
.tokenResponse(HttpServletResponse.SC_OK)
.setAccessToken(accessToken)
.setExpiresIn("3600")
.setTokenType("Bearer")
.setRefreshToken(refreshToken)
.buildJSONMessage();
// 安全考虑,场景限制,只请求一次就足够了,用完就删
oAuthTokenUtils.clear(authzCode); oAuthTokenUtils.save(oauthRequest.getClientId(),
oauthRequest.getClientSecret(),
accessToken,
refreshToken,
vo.getUsers(),
oAuth2Secret.getMeId());
}
}
} catch (OAuthProblemException ex) {
oauthResponse = OAuthResponse
.errorResponse(HttpServletResponse.SC_UNAUTHORIZED)
.error(ex)
.buildJSONMessage();
}finally{
response.setStatus(oauthResponse.getResponseStatus());
OutputStream outputStream=response.getOutputStream();
IOUtils.write(oauthResponse.getBody(), outputStream);
IOUtils.closeQuietly(outputStream);
}
}

第8步 access_token换source

场景限制,只能访问这一种资源,所有直接写成一个方法了,否则肯定要隔离
@RequestMapping("/resource")
protected void resource(HttpServletRequest request, HttpServletResponse response)throws OAuthSystemException, IOException{
try {
OAuthAccessResourceRequest oauthRequest = new OAuthAccessResourceRequest(request, ParameterStyle.HEADER);
String accessToken =decodeBase64(oauthRequest.getAccessToken());
// 之前用code换取access_token时保存在redis里的
OAuth2Vo vo=oAuthTokenUtils.select(accessToken);
if(null!=vo){
Map<String, Object> map= 各种操作
response.setContentType("application/json;charset=UTF-8");
response.setStatus(HttpServletResponse.SC_OK);
OutputStream outputStream=response.getOutputStream();
IOUtils.write(JSON.toJSONString(map), outputStream);
IOUtils.closeQuietly(outputStream);
// 老规矩,用完就删
oAuthTokenUtils.clear(accessToken);
}else{
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
response.addHeader(OAuth.HeaderType.WWW_AUTHENTICATE, "failure access_token");
}
} catch(OAuthProblemException e) {
logger.error(e.getMessage());
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
response.addHeader(OAuth.HeaderType.WWW_AUTHENTICATE, "authorization header error");
}
}

项目总结

  • 只用来做免登陆有点可惜;
  • 因场景限制,项目中流程有一定的局限性;
  • 后面会考虑写一个demo放到github上

个人demo实例

前言

为了更好的理解oauth2,有了这个demo,

主要功能:

  • 支持动态添加合作网站
  • 支持token的级别隔离,目前常见的都只有一种token,尝试打造支持多级别的token