安全控制

    在使用Jboot的shiro模块之前，我假定您已经学习并了解shiro的基础知识。在Jboot中使用shiro非常简单，只需要在resources目录下配置上您的shiro.ini文件即可。在shiro.ini文件里，需要在自行扩展realm等信息。

    Jboot的shiro模块为您提供了以下12个模板指令，同时支持shiro的5个Requires注解功能。方便您使用shiro。

    shiroAuthenticated的使用

    shiroGuest的使用

    2.   游客您好
    3. #end

    shiroHasAllPermission的使用

    1. #shiroHasAllPermission(permissionName1,permissionName2)
    2.   您好，您拥有了权限 permissionName1和permissionName2
    3. #end

    shiroHasAllRoles的使用

    1. #shiroHasAllRoles(role1, role2)
    2.   您好，您拥有了角色 role1和role2
    3. #end

    shiroHasAnyPermission的使用

    1. #shiroHasAnyPermission(permissionName1,permissionName2)
    2.   您好，您拥有了权限 permissionName1 或 permissionName2 
    3. #end

    shiroHasAnyRoles的使用

    1. #shiroHasAllRoles(role1, role2)
    2.   您好，您拥有了角色 role1 或 role2
    3. #end

    shiroHasPermission的使用

    1. #shiroHasPermission(permissionName1)
    2.   您好，您拥有了权限 permissionName1 
    3. #end

    shiroHasRole的使用

    1. #shiroHasRole(role1)
    2.   您好，您拥有了角色 role1 
    3. #end

    shiroNoAuthenticated的使用

    1. #shiroNoAuthenticated()
    2.   您好，您还没有登陆
    3. #end

    shiroNotHasPermission的使用

    1. #shiroNotHasPermission(permissionName1)
    2.   您好，您没有权限 permissionName1 
    3. #end

    shiroNotHasRole的使用

    1. #shiroNotHasRole(role1)
    2.   您好，您没有角色role1
    3. #end

    shiroPrincipal的使用

    5个Requires注解功能（用在Controller上）

    RequiresPermissions的使用

    1. public class MyController extends JbootController{
    3.       @RequiresPermissions("permission1")
    4.       public void index(){
    6.       }
    8.       @RequiresPermissions(value={"permission1","permission2"},logical=Logincal.AND)
    9.       public void index1(){
    11.       }
    12. }

    RequiresRoles的使用

    1. public class MyController extends JbootController{
    3.       @RequiresRoles("role1")
    4.       public void index(){
    6.       }
    8.       @RequiresRoles(value = {"role1","role2"},logical=Logincal.AND)
    9.       public void userctener(){
    11.       }
    12. }

    RequiresUser、RequiresGuest、RequiresAuthentication的使用

    1. public class MyController extends JbootController{
    3.       @RequiresUser
    4.       public void userCenter(){
    6.       }
    8.       @RequiresGuest
    9.       public void login(){
    11.       }
    13.       @RequiresAuthentication
    14.       public void my(){
    16.       }
    17. }

    Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。

    JWT的使用

    在server段使用JWT

    在Server端使用JWT非常简单，代码如下：

    1. public class JwtController extends JbootController {
    3.     public void index() {
    4.         setJwtAttr("key1", "test1");
    5.         setJwtAttr("key2", "test2");
    7.         //do your sth
    8.     }
    10.     public void show() {
    11.         String value = getJwtPara("key1");
    12.         // value : test1
    13.     }
    14. }

    注意： 在Server端使用JWT，必须在jboot.properties配置文件中配置上 jwt 的秘钥，代码如下：

    1. jboot.web.jwt.secret = your_secret

    关于JWT的方法：

    在客户端使用JWT

    在客户端使用JWT的场景一般是用于非浏览器的第三方进行认证，例如：APP客户端，前后端分离的AJAX请求等。

    编写一个类实现 实现接口 io.jboot.component.shiro.JbootShiroInvokeListener，例如：

    1.   public class MyshiroListener implements  JbootShiroInvokeListener {
    4.         private JbootShiroConfig config = Jboot.config(JbootShiroConfig.class);
    7.         @Override
    8.         public void onInvokeBefore(FixedInvocation inv) {
    9.             //do nothing
    10.         }
    12.         @Override
    13.         public void onInvokeAfter(FixedInvocation inv, AuthorizeResult result) {
    14.             if (result == null || result.isOk()) {
    15.                 inv.invoke();
    16.                 return;
    17.             }
    19.             int errorCode = result.getErrorCode();
    20.             switch (errorCode) {
    21.                 case AuthorizeResult.ERROR_CODE_UNAUTHENTICATED:
    22.                     doProcessUnauthenticated(inv.getController());
    23.                     break;
    24.                 case AuthorizeResult.ERROR_CODE_UNAUTHORIZATION:
    25.                     doProcessuUnauthorization(inv.getController());
    26.                     break;
    27.                 default:
    28.                     inv.getController().renderError(404);
    29.             }
    30.         }
    33.         public void doProcessUnauthenticated(Controller controller) {
    34.             // 处理认证失败
    35.         }
    37.         public void doProcessuUnauthorization(Controller controller) {
    38.             // 处理授权失败
    39.         }
    41.     };

    其次在jboot.properties中配置即可

    1. jboot.shiro.invokeListener=com.xxx.MyshiroListener

    shiro 和 jwt 整合

    和自定义shiro错误处理一样。 编写一个类实现 实现接口 io.jboot.component.shiro.JbootShiroInvokeListener，例如：

    1.   public class MyshiroListener implements  JbootShiroInvokeListener {
    3.         @Override
    4.         public void onInvokeBefore(FixedInvocation inv) {
    5.             String userId = String.valueOf(inv.getController.getJwtPara(USER_ID));
    7.             JwtAuthenticationToken token = new JwtAuthenticationToken();
    8.             token.setUserId(userId);
    9.             token.setToken(userId);
    10.             Subject subject = SecurityUtils.getSubject();
    11.             subject.login(token);
    13.             return subject;
    14.         }
    16.         @Override
    17.         public void onInvokeAfter(FixedInvocation inv, AuthorizeResult result) {
    18.             // ....
    19.         }
    21.     };

    同时在jboot.properties中配置即可

    1. jboot.shiro.invokeListener=com.xxx.MyshiroListener

    自定义JwtAuthenticationToken

    1. public class JwtAuthenticationToken implements AuthenticationToken {
    2.     /** 用户id */
    3.     private String userId;
    4.     /** token */
    5.     private String token;
    8.     public Object getPrincipal() {
    9.         return userId;
    10.     }
    12.     @Override
    13.     public Object getCredentials() {
    14.         return token;
    15.     }
    17.     ... getter setter
    18. }

    实现shiro realm JwtAuthorizingRealm

    实现jwt 无状态化，JwtSubjectFactory

    1. public class JwtSubjectFactory extends DefaultWebSubjectFactory {
    3.     @Override
    4.     public Subject createSubject(SubjectContext context) {
    5.         if (context.getAuthenticationToken() instanceof JwtAuthenticationToken) {
    6.             // jwt 不创建 session
    7.             context.setSessionCreationEnabled(false);
    8.         }
    10.         return super.createSubject(context);
    11.     }
    12. }
    1. #---------------------------------------------------------------------------------#
    2. jboot.web.jwt.httpHeaderName=Jwt
    3. jboot.web.jwt.secret=xxxxxxxxx
    4. jboot.web.jwt.validityPeriod=1800000
    5. #---------------------------------------------------------------------------------#
    2. shiro.ini中配置
    4. ```xml
    6.     [main]
    7.     #cache Manager
    8.     shiroCacheManager = io.jboot.component.shiro.cache.JbootShiroCacheManager
    9.     securityManager.cacheManager = $shiroCacheManager
    11.     #realm
    12.     dbRealm=xxx.JwtAuthorizingRealm
    13.     dbRealm.authorizationCacheName=shiro-authorizationCache
    15.     securityManager.realm=$dbRealm
    17.     #session manager
    18.     sessionManager=org.apache.shiro.session.mgt.DefaultSessionManager
    19.     sessionManager.sessionValidationSchedulerEnabled=false
    21.     #use jwt
    22.     subjectFactory=xxx.JwtSubjectFactory
    23.     securityManager.subjectFactory=$subjectFactory
    24.     securityManager.sessionManager=$sessionManager
    26.     #session storage false
    27.     securityManager.subjectDAO.sessionStorageEvaluator.sessionStorageEnabled=false

    认证服务端配置

    服务端主要作用为对用户名密码做认证，通过后构建jwt，与正常认证无太大区别，所以下面只给出认证后构建jwt的demo

    1. @RequestMapping("/")
    2. public class MainController extends BaseController {
    4.     /**
    5.      * 登录 基于 jwt
    6.      */
    7.     public void postLogin(String loginName, String pwd) {
    8.         // 此处判断用户名密码是否正确
    10.         String userId = "userId"; //返回用户ID
    11.         setJwtAttr("userId", userId); //构建jwt
    12.         renderJson(); //返回成功
    13.     }
    14. }

    和上面介绍的 jwt 的桥接器类似，主要作用是接收 sso 请求，完成客户端应用的局部认证与授权。

    以下是一个基于jboot 实现 sso服务端 与 sso客户端的 demo

    SSO客户端配置

    自定义 SSOAuthenticationToken

    1. public class SSOAuthenticationToken implements AuthenticationToken {
    3.     /** 用户id */
    4.     private String userId;
    6.     /** 全局会话 code */
    7.     private String ssoCode;
    9.     @Override
    10.     public Object getPrincipal() {
    11.         return userId;
    12.     }
    14.     @Override
    15.     public Object getCredentials() {
    16.         return ssoCode;
    17.     }
    18.     ... getter setter

    实现 JbootShiroInvokeListener 接口：

    1.  public class MyshiroListener implements  JbootShiroInvokeListener {
    3.         @Override
    4.         public void onInvokeBefore(FixedInvocation inv) {
    5.         String ssoCode = inv.getController().getPara("ssoCode");
    6.         String userId = inv.getController().getPara("userId");
    8.         if (StringUtils.isBlank(ssoCode) || StringUtils.isBlank(userId)) {
    9.             return;
    10.         }
    12.         SSOAuthenticationToken token = new SSOAuthenticationToken();
    13.         token.setUserId(userId);
    14.         token.setSsoCode(ssoCode);
    16.         try {
    17.             Subject subject = SecurityUtils.getSubject();
    18.             subject.login(token);
    19.         } catch (Exception e) {
    20.             e.printStackTrace();
    21.             log.error(e.getMessage());
    22.         }
    23.     }
    24. }

    实现shiro realm SSOAuthorizingRealm

    1. public class SSOAuthorizingRealm extends AuthorizingRealm {
    3.     @Override
    4.     public boolean supports(AuthenticationToken token) {
    5.         return token instanceof SSOAuthenticationToken;
    6.     }
    8.     @Override
    9.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
    10.         SSOAuthenticationToken ssoToken = (SSOAuthenticationToken) token;
    11.         String uid = (String) ssoToken.getPrincipal();
    12.         String ssoCode = token.getCredentials().toString();
    14.         //判断ssoCode是否为 sso 系统颁发
    16.         // 此处判断 uid 是否存在，可以访问等操作
    18.         return new SimpleAuthenticationInfo(uid, ssoToken.getCredentials(), this.getName());
    19.     }
    21.     @Override
    22.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
    23.         // 此处获取 uid 角色权限
    24.         return null;
    25.     }
    26. }

    实现 shiro 无认证请求重定向到 sso系统，SSOShiroErrorProcess

    1. public class MyshiroListener implements  JbootShiroInvokeListener {
    3.         @Override
    4.         public void onInvokeAfter(FixedInvocation inv, AuthorizeResult result) {
    5.         if (result.isOk()) {
    6.                 inv.invoke();
    7.                 return;
    8.             }
    9.         int errorCode = result.getErrorCode();
    11.         switch (errorCode) {
    12.             case AuthorizeResult.ERROR_CODE_UNAUTHENTICATED:
    13.                 break;
    14.             case AuthorizeResult.ERROR_CODE_UNAUTHORIZATION:
    15.                 doProcessuUnauthorization(inv.getController());
    16.                 break;
    17.             default:
    18.                 inv.getController().renderError(404);
    19.         }
    20.     }
    23.     public void doProcessUnauthenticated(Controller controller) {
    24.         UpmsConfig upmsConfig = Jboot.config(UpmsConfig.class);
    26.         StringBuilder ssoServerUrl = new StringBuilder(upmsConfig.getServerUrl());
    27.         ssoServerUrl.append("/sso/index").append("?").append("appid").append("=").append(upmsConfig.getAppId()).append("sysid").append("=").append(upmsConfig.getSystemId());
    29.         // 回跳地址
    30.         StringBuffer backurl = controller.getRequest().getRequestURL();
    31.         String queryString = controller.getRequest().getQueryString();
    32.         if (StringUtils.isNotBlank(queryString)) {
    33.             backurl.append("?").append(queryString);
    34.         }
    35.         ssoServerUrl.append("&").append("backurl").append("=").append(StringUtils.urlEncode(backurl.toString()));
    37.         controller.redirect(ssoServerUrl.toString());
    38.     }
    40.     public void doProcessuUnauthorization(Controller controller) {
    41.         controller.renderError(403);
    42.     }
    43. }
    1. [main]
    3. #cache Manager
    4. shiroCacheManager = io.jboot.component.shiro.cache.JbootShiroCacheManager
    5. securityManager.cacheManager = $shiroCacheManager
    7. #realm
    8. dbRealm=xxx.SSOAuthorizingRealm
    9. dbRealm.authorizationCacheName=shiro-authorizationCache
    11. securityManager.realm=$dbRealm
    13. #session 基于缓存sessionDao，如果缓存已经实现共享，那么session也同样实现共享
    14. sessionDAO=xxx.SessionDAO
    15. sessionDAO.activeSessionsCacheName=shiro-active-session
    17. #设置sessionCookie
    18. sessionIdCookie=org.apache.shiro.web.servlet.SimpleCookie
    19. sessionIdCookie.name=ssotestaid
    20. #sessionIdCookie.domain=demo.com
    21. #sessionIdCookie.path=
    22. #cookie最大有效期，单位秒，默认30天
    23. sessionIdCookie.maxAge=1800
    24. sessionIdCookie.httpOnly=true
    26. #设置session会话管理
    27. sessionManager=org.apache.shiro.web.session.mgt.DefaultWebSessionManager
    28. sessionManager.sessionDAO=$sessionDAO
    29. sessionManager.sessionIdCookie=$sessionIdCookie
    30. sessionManager.sessionIdCookieEnabled=true
    31. sessionManager.sessionIdUrlRewritingEnabled=false
    32. securityManager.sessionManager=$sessionManager
    33. #session过期时间，单位毫秒，默认两天
    34. securityManager.sessionManager.globalSessionTimeout=1800000

    SSO服务端配置

    SSO服务端，主要包括登录认证、全局code认证、退出等操作。

    1. @RequestMapping("/sso")
    2. @EnableCORS
    3. public class SSOController extends BaseController {
    5.     public void index(String appid, String backurl) {
    6.         // 判断 appid 是否正确，backurl 是否正确
    8.         redirect("/sso/login?backurl=" + StringUtils.urlEncode(backurl));
    9.     }
    11.     @Before(GET.class)
    12.     public void login() {
    13.         Subject subject = SecurityUtils.getSubject();
    14.         String backurl = getPara("backurl");
    16.         if (subject.isAuthenticated()) {
    17.             String loginName = (String) subject.getPrincipal();
    19.             // 判断用户id
    21.             String code = (String) subject.getSession(false).getId().toString();
    23.             if (StringUtils.isBlank(backurl)) {
    24.                 renderJson(JsonResult.buildSuccess(code));
    25.             } else {
    26.                 if (backurl.contains("?")) {
    27.                     backurl += "&ssoCode=" + code + "&userId=" + upmsUser.getId();
    28.                 } else {
    29.                     backurl += "?ssoCode=" + code + "&userId=" + upmsUser.getId();
    30.                 }
    31.             }
    33.             redirect(backurl);
    34.         } else {
    35.             setAttr("backurl", backurl);
    36.             render("login.html");
    37.         }
    38.     }
    40.     @Before(POST.class)
    41.     @EmptyValidate(value = {
    42.             @Form(name = "loginName", message = "用户名不能为空"),
    43.             @Form(name = "password", message = "密码不能为空"),
    44.     }, renderType = ValidateRenderType.JSON)
    45.     public void postLogin(String loginName, String password) {
    46.         Subject subject = SecurityUtils.getSubject();
    48.         String backUrl = getPara("backUrl", "");
    49.         Ret ret = JsonResult.buildSuccess("登录成功", backUrl);
    51.         if (!subject.isAuthenticated()) {
    52.             UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(loginName, password);
    53.             subject.login(usernamePasswordToken);
    55.             // 获取用户 id
    57.             Session session = subject.getSession(true);
    58.             String code = session.getId().toString();
    60.             String backurl = getPara("backurl");
    61.             if (StringUtils.isBlank(backurl)) {
    62.                 renderJson(JsonResult.buildSuccess(code));
    63.             } else {
    64.                 if (backurl.contains("?")) {
    65.                     backurl += "&ssoCode=" + code + "&userId=" + upmsUser.getId();
    66.                 } else {
    67.                     backurl += "?ssoCode=" + code + "&userId=" + upmsUser.getId();
    68.                 }
    69.             }
    71.             redirect(backurl);
    72.             return;
    74.         }
    76.         renderJson(ret);
    77.     }
    79.     @Before(POST.class)
    80.     @EmptyValidate(value = {
    81.             @Form(name = "code", message = "参数错误"),
    82.     }, renderType = ValidateRenderType.JSON)
    83.     public void code(String code) {
    84.         Object codeCache = null; // 获取缓存全局code
    86.         if (codeCache == null) {
    87.             renderJson(JsonResult.buildError("invalid"));
    88.         } else {
    89.             renderJson(JsonResult.buildSuccess("success"));
    90.         }
    91.     }
    94.     public void logout() {
    95.         // shiro退出登录
    96.         SecurityUtils.getSubject().logout();
    97.         // 跳回原地址
    98.         String redirectUrl = getRequest().getHeader("Referer");
    99.         if (null == redirectUrl) {
    100.             redirectUrl = "/";
    101.         }
    103.         redirect(redirectUrl);
    104.     }