欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

shiro无状态web集成的示例代码

程序员文章站 2024-02-29 14:20:40
在一些环境中,可能需要把web应用做成无状态的,即服务器端无状态,就是说服务器端不会存储像会话这种东西,而是每次请求时带上相应的用户名进行登录。如一些rest风格的api,...

在一些环境中,可能需要把web应用做成无状态的,即服务器端无状态,就是说服务器端不会存储像会话这种东西,而是每次请求时带上相应的用户名进行登录。如一些rest风格的api,如果不使用oauth2协议,就可以使用如rest+hmac认证进行访问。hmac(hash-based message authentication code):基于散列的消息认证码,使用一个密钥和一个消息作为输入,生成它们的消息摘要。注意该密钥只有客户端和服务端知道,其他第三方是不知道的。访问时使用该消息摘要进行传播,服务端然后对该消息摘要进行验证。如果只传递用户名+密码的消息摘要,一旦被别人捕获可能会重复使用该摘要进行认证。解决办法如:

1、每次客户端申请一个token,然后使用该token进行加密,而该token是一次性的,即只能用一次;有点类似于oauth2的token机制,但是简单些;

2、客户端每次生成一个唯一的token,然后使用该token加密,这样服务器端记录下这些token,如果之前用过就认为是非法请求。

为了简单,本文直接对请求的数据(即全部请求的参数)生成消息摘要,即无法篡改数据,但是可能被别人窃取而能多次调用。解决办法如上所示。

服务器端

对于服务器端,不生成会话,而是每次请求时带上用户身份进行认证。

服务控制器

@restcontroller 
public class servicecontroller { 
  @requestmapping("/hello") 
  public string hello1(string[] param1, string param2) { 
    return "hello" + param1[0] + param1[1] + param2; 
  } 
} 

当访问/hello服务时,需要传入param1、param2两个请求参数。

加密工具类

com.github.zhangkaitao.shiro.chapter20.codec.hmacsha256utils: 

//使用指定的密码对内容生成消息摘要(散列值) 
public static string digest(string key, string content); 
//使用指定的密码对整个map的内容生成消息摘要(散列值) 
public static string digest(string key, map<string, ?> map)  

对map生成消息摘要主要用于对客户端/服务器端来回传递的参数生成消息摘要。

subject工厂  

public class statelessdefaultsubjectfactory extends defaultwebsubjectfactory { 
  public subject createsubject(subjectcontext context) { 
    //不创建session 
    context.setsessioncreationenabled(false); 
    return super.createsubject(context); 
  } 
}  

通过调用context.setsessioncreationenabled(false)表示不创建会话;如果之后调用subject.getsession()将抛出disabledsessionexception异常。

statelessauthcfilter

类似于formauthenticationfilter,但是根据当前请求上下文信息每次请求时都要登录的认证过滤器。

public class statelessauthcfilter extends accesscontrolfilter { 
 protected boolean isaccessallowed(servletrequest request, servletresponse response, object mappedvalue) throws exception { 
   return false; 
 } 
 protected boolean onaccessdenied(servletrequest request, servletresponse response) throws exception { 
  //1、客户端生成的消息摘要 
  string clientdigest = request.getparameter(constants.param_digest); 
  //2、客户端传入的用户身份 
string username = request.getparameter(constants.param_username); 
  //3、客户端请求的参数列表 
  map<string, string[]> params =  
   new hashmap<string, string[]>(request.getparametermap()); 
  params.remove(constants.param_digest); 
  //4、生成无状态token 
  statelesstoken token = new statelesstoken(username, params, clientdigest); 
  try { 
   //5、委托给realm进行登录 
   getsubject(request, response).login(token); 
  } catch (exception e) { 
   e.printstacktrace(); 
   onloginfail(response); //6、登录失败 
   return false; 
  } 
  return true; 
 } 
 //登录失败时默认返回401状态码 
 private void onloginfail(servletresponse response) throws ioexception { 
  httpservletresponse httpresponse = (httpservletresponse) response; 
  httpresponse.setstatus(httpservletresponse.sc_unauthorized); 
  httpresponse.getwriter().write("login error"); 
 } 
} 

获取客户端传入的用户名、请求参数、消息摘要,生成statelesstoken;然后交给相应的realm进行认证。

statelesstoken   

public class statelesstoken implements authenticationtoken { 
  private string username; 
  private map<string, ?> params; 
  private string clientdigest; 
  //省略部分代码 
  public object getprincipal() { return username;} 
  public object getcredentials() { return clientdigest;} 
}  

用户身份即用户名;凭证即客户端传入的消息摘要。

statelessrealm 

用于认证的realm。

public class statelessrealm extends authorizingrealm { 
  public boolean supports(authenticationtoken token) { 
    //仅支持statelesstoken类型的token 
    return token instanceof statelesstoken; 
  } 
  protected authorizationinfo dogetauthorizationinfo(principalcollection principals) { 
    //根据用户名查找角色,请根据需求实现 
    string username = (string) principals.getprimaryprincipal(); 
    simpleauthorizationinfo authorizationinfo = new simpleauthorizationinfo(); 
    authorizationinfo.addrole("admin"); 
    return authorizationinfo; 
  } 
  protected authenticationinfo dogetauthenticationinfo(authenticationtoken token) throws authenticationexception { 
    statelesstoken statelesstoken = (statelesstoken) token; 
    string username = statelesstoken.getusername(); 
    string key = getkey(username);//根据用户名获取密钥(和客户端的一样) 
    //在服务器端生成客户端参数消息摘要 
    string serverdigest = hmacsha256utils.digest(key, statelesstoken.getparams()); 
    //然后进行客户端消息摘要和服务器端消息摘要的匹配 
    return new simpleauthenticationinfo( 
        username, 
        serverdigest, 
        getname()); 
  } 
   
  private string getkey(string username) {//得到密钥,此处硬编码一个 
    if("admin".equals(username)) { 
      return "dadadswdewq2ewdwqdwadsadasd"; 
    } 
    return null; 
  } 
} 

此处首先根据客户端传入的用户名获取相应的密钥,然后使用密钥对请求参数生成服务器端的消息摘要;然后与客户端的消息摘要进行匹配;如果匹配说明是合法客户端传入的;否则是非法的。这种方式是有漏洞的,一旦别人获取到该请求,可以重复请求;可以考虑之前介绍的解决方案。

spring配置——spring-config-shiro.xml 

<!-- realm实现 --> 
<bean id="statelessrealm"  
 class="com.github.zhangkaitao.shiro.chapter20.realm.statelessrealm"> 
  <property name="cachingenabled" value="false"/> 
</bean> 
<!-- subject工厂 --> 
<bean id="subjectfactory"  
 class="com.github.zhangkaitao.shiro.chapter20.mgt.statelessdefaultsubjectfactory"/> 
<!-- 会话管理器 --> 
<bean id="sessionmanager" class="org.apache.shiro.session.mgt.defaultsessionmanager"> 
  <property name="sessionvalidationschedulerenabled" value="false"/> 
</bean> 
<!-- 安全管理器 --> 
<bean id="securitymanager" class="org.apache.shiro.web.mgt.defaultwebsecuritymanager"> 
  <property name="realm" ref="statelessrealm"/> 
  <property name="subjectdao.sessionstorageevaluator.sessionstorageenabled" 
   value="false"/> 
  <property name="subjectfactory" ref="subjectfactory"/> 
  <property name="sessionmanager" ref="sessionmanager"/> 
</bean> 
<!-- 相当于调用securityutils.setsecuritymanager(securitymanager) --> 
<bean class="org.springframework.beans.factory.config.methodinvokingfactorybean"> 
  <property name="staticmethod"  
   value="org.apache.shiro.securityutils.setsecuritymanager"/> 
  <property name="arguments" ref="securitymanager"/> 
</bean> 

sessionmanager通过sessionvalidationschedulerenabled禁用掉会话调度器,因为我们禁用掉了会话,所以没必要再定期过期会话了。 

<bean id="statelessauthcfilter"  
  class="com.github.zhangkaitao.shiro.chapter20.filter.statelessauthcfilter"/> 

每次请求进行认证的拦截器。 

<!-- shiro的web过滤器 --> 
<bean id="shirofilter" class="org.apache.shiro.spring.web.shirofilterfactorybean"> 
  <property name="securitymanager" ref="securitymanager"/> 
  <property name="filters"> 
    <util:map> 
      <entry key="statelessauthc" value-ref="statelessauthcfilter"/> 
    </util:map> 
  </property> 
  <property name="filterchaindefinitions"> 
    <value> 
      /**=statelessauthc 
    </value> 
  </property> 
</bean> 

所有请求都将走statelessauthc拦截器进行认证。

其他配置请参考源代码。

客户端

此处使用springmvc提供的resttemplate进行测试。 

此处为了方便,使用内嵌jetty服务器启动服务端: 

public class clienttest { 
  private static server server; 
  private resttemplate resttemplate = new resttemplate(); 
  @beforeclass 
  public static void beforeclass() throws exception { 
    //创建一个server 
    server = new server(8080); 
    webappcontext context = new webappcontext(); 
    string webapp = "shiro-example-chapter20/src/main/webapp"; 
    context.setdescriptor(webapp + "/web-inf/web.xml"); //指定web.xml配置文件 
    context.setresourcebase(webapp); //指定webapp目录 
    context.setcontextpath("/"); 
    context.setparentloaderpriority(true); 
    server.sethandler(context); 
    server.start(); 
  } 
  @afterclass 
  public static void afterclass() throws exception { 
    server.stop(); //当测试结束时停止服务器 
  } 
} 

在整个测试开始之前开启服务器,整个测试结束时关闭服务器。

测试成功情况 

@test 
public void testservicehellosuccess() { 
  string username = "admin"; 
  string param11 = "param11"; 
  string param12 = "param12"; 
  string param2 = "param2"; 
  string key = "dadadswdewq2ewdwqdwadsadasd"; 
  multivaluemap<string, string> params = new linkedmultivaluemap<string, string>(); 
  params.add(constants.param_username, username); 
  params.add("param1", param11); 
  params.add("param1", param12); 
  params.add("param2", param2); 
  params.add(constants.param_digest, hmacsha256utils.digest(key, params)); 
  string url = uricomponentsbuilder 
      .fromhttpurl("http://localhost:8080/hello") 
      .queryparams(params).build().touristring(); 
   responseentity responseentity = resttemplate.getforentity(url, string.class); 
  assert.assertequals("hello" + param11 + param12 + param2, responseentity.getbody()); 
}   

对请求参数生成消息摘要后带到参数中传递给服务器端,服务器端验证通过后访问相应服务,然后返回数据。

测试失败情况 

@test 
public void testservicehellofail() { 
  string username = "admin"; 
  string param11 = "param11"; 
  string param12 = "param12"; 
  string param2 = "param2"; 
  string key = "dadadswdewq2ewdwqdwadsadasd"; 
  multivaluemap<string, string> params = new linkedmultivaluemap<string, string>(); 
  params.add(constants.param_username, username); 
  params.add("param1", param11); 
  params.add("param1", param12); 
  params.add("param2", param2); 
  params.add(constants.param_digest, hmacsha256utils.digest(key, params)); 
  params.set("param2", param2 + "1"); 
 
  string url = uricomponentsbuilder 
      .fromhttpurl("http://localhost:8080/hello") 
      .queryparams(params).build().touristring(); 
  try { 
    responseentity responseentity = resttemplate.getforentity(url, string.class); 
  } catch (httpclienterrorexception e) { 
    assert.assertequals(httpstatus.unauthorized, e.getstatuscode()); 
    assert.assertequals("login error", e.getresponsebodyasstring()); 
  } 
}   

在生成请求参数消息摘要后,篡改了参数内容,服务器端接收后进行重新生成消息摘要发现不一样,报401错误状态码。

到此,整个测试完成了,需要注意的是,为了安全性,请考虑本文开始介绍的相应解决方案。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。