精华内容
下载资源
问答
  • 最近的看的一个项目用到了Shiro安全框架来认证,授权,在某课网上找到了这门课程:Shiro安全框架入门,里面的代码都是手动敲的,能够完全运行。
  • Shiro安全框架

    2021-03-01 16:28:48
    ApacheShiro是一个强大易用的Java安全框架,提供了认证、授权、加密和会话管理等功能。对于任何一个应用程序,Shiro都可以提供全面的安全管理服务。其不仅可以用在JavaSE环境,也可以用在JavaEE环境。1.从外部来看...
  • shiro安全框架

    2018-09-19 11:24:56
    shiro安全框架+spring的完整oa项目开发,简单应用。。
  • shiro安全框架jar包.zip

    2020-05-30 09:58:00
    shiro安全框架jar包.zip
  • 原文:https://blog.csdn.net/u013142781/article/details/50629708
  • 必须配有maven,使用mysql,Myeclipse,jdk1.7,账号:admin,密码:123456,里面实现了医院的基本业务,数据表大概为50章,有基本数据,这是大学时期的毕业设计,登录管理员帐号就能使用。
  • 慕课中Shiro安全框架入门源代码,望各位大神多多指教!
  • Apache Shiro 是java的一个安全框架。它相当简单,对比Spring Security,可能没有Spring Security做的功能强大,但是在实际工作时可能并不需要那么复杂的东西,所以使用小而简单的Shiro就足够了。对于它俩到底哪个好...
  • shiro 安全框架 最全中文配置文档
  • Apache Shiro(发音为“shee-roh”,日语为“castle”)是一种功能强大且易于使用的Java安全框架,可执行身份验证,授权,加密和会话管理,可用于保护任何应用程序的安全-从命令行应用程序,移动应用程序到最大的Web...
  • 主要介绍了spring boot整合shiro安全框架过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Shiro是一个强大的简单易用的Java安全框架,主要用来更便捷的认证,授权,加密,会话管理。Shiro首要的和最重要的目标就是容易使用并且容易理解,通过Shiro易于理解的API,您可以快速、轻松地获得任何应用程序——从...

    一、什么是Shiro

    Shiro是一个强大的简单易用的Java安全框架,主要用来更便捷的认证,授权,加密,会话管理。Shiro首要的和最重要的目标就是容易使用并且容易理解,通过Shiro易于理解的API,您可以快速、轻松地获得任何应用程序——从最小的移动应用程序最大的网络和企业应用程序。

    二、Shiro架构

    2.1 Shiro架构图

    shiro架构图

    • Authentication:身份认证/登录
    • Authorization:验证权限,即,验证某个人是否有做某件事的权限。
    • Session Management:会话管理。管理用户特定的会话,支持web,非web,ejb。
    • Cryptography: 加密,保证数据安全。
    • Web Support:web支持,更容易继承web应用。
    • Caching:缓存
    • Concurrency :多线程应用的并发验证,即如在一个线程中开启另一个线程,能把权限自动传播过去;
    • Testing:提供测试支持。
    • Run As:允许一个用户假装为另一个用户(如果他们允许)的身份进行访问;
    • Remember Me:记住我,即记住登录状态,一次登录后,下次再来的话不用登录了

    2.2 Shiro 工作原理

    Shiro的架构有三个主要概念:Subject, SecurityManager 和 Realms。
    shiro工作原理

    • Subject: 当前参与应用安全部分的主角。可以是用户,可以试第三方服务,可以是cron 任务,或者任何东西。主要指一个正在与当前软件交互的东西。所有Subject都需要SecurityManager,当你与Subject进行交互,这些交互行为实际上被转换为与SecurityManager的交互。
    • SecurityManager:安全管理员,Shiro架构的核心,它就像Shiro内部所有原件的保护伞。然而一旦配置了SecurityManager,SecurityManager就用到的比较少,开发者大部分时间都花在Subject上面。当你与Subject进行交互的时候,实际上是SecurityManager在背后帮你举起Subject来做一些安全操作。
    • Realms: Realms作为Shiro和你的应用的连接桥,当需要与安全数据交互的时候,像用户账户,或者访问控制,Shiro就从一个或多个Realms中查找。Shiro提供了一些可以直接使用的Realms,如果默认的Realms不能满足你的需求,你也可以定制自己的Realms。

    2.3 Shiro详细架构图

    Shiro详细架构

    • Subject:与应用交互的主体,例如用户,第三方应用等。
    • SecurityManager:shiro的核心,负责整合所有的组件,使他们能够方便快捷完成某项功能。例如:身份验证,权限验证等。
    • Authenticator:认证器,负责主体认证的,这是一个扩展点,如果用户觉得Shiro默认的不好,可以自定义实现;其需要认证策略(Authentication Strategy),即什么情况下算用户认证通过了。
    • Authorizer:决定主体是否有权限进行相应的操作;即控制着用户能访问应用中的哪些功能。
    • SessionManager:会话管理。
    • SessionDAO:数据访问对象,对session进行CRUD。
    • CacheManager:缓存管理器。创建和管理缓存,为 authentication, authorization 和 session management 提供缓存数据,避免直接访问数据库,提高效率。
    • Cryptography;密码模块,提供加密组件。
    • Realms:可以有1个或多个Realm,可以认为是安全实体数据源,即用于获取安全实体的;可以是JDBC实现,也可以是LDAP实现,或者内存实现等等;由用户提 供;注意:Shiro不知道你的用户/权限存储在哪及以何种格式存储;所以我们一般在应用中都需要实现自己的Realm。

    三、SpringBoot 整合Shiro

    3.1 引入依赖

    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-spring</artifactId>
        <version>1.4.0</version>
    </dependency>
    

    3.2 编写自定义Realm

    Realm是shiro进行登录或者权限校验的关键位置,我们需要重写里面的方法,分别是:

    1. doGetAuthorizationInfo:权限校验
    2. doGetAuthenticationInfo:登录认证校验
    /**
     * @Author: oyc
     * @Date: 2020-06-02 16:12
     * @Description:
     */
    public class CustomRealm extends AuthorizingRealm {
    
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
            //获取登录用户名
            String name = (String) principalCollection.getPrimaryPrincipal();
            //根据用户名去数据库查询用户信息,此处模拟
            User user = new User(1,name,"123456");
            // 添加角色和权限
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
    		//添加角色
    		simpleAuthorizationInfo.addRole(user.getAccount());
    		//添加权限,admin:add/user:add
    		simpleAuthorizationInfo.addStringPermission(user.getAccount()+":add");
            return simpleAuthorizationInfo;
        }
    
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
            //加这一步的目的是在Post请求的时候会先进认证,然后在到请求
            if (authenticationToken.getPrincipal() == null) {
                return null;
            }
            //获取用户信息
            String name = authenticationToken.getPrincipal().toString();
            // 根据用户名获取用户信息,此处模拟
            User user = new User(1,name,"123456");
            if (user == null) {
                //这里返回后会报出对应异常
                return null;
            } else {
                //这里验证authenticationToken和simpleAuthenticationInfo的信息
                return new SimpleAuthenticationInfo(name, user.getPassword(), getName());
            }
        }
    }
    

    3.3 配置Shiro

    /**
     * @Author: oyc
     * @Date: 2020-06-02 16:11
     * @Description: Shiro 配置
     */
    @Configuration
    public class ShiroConfig {
    	@Bean
    	public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
    		ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
    		shiroFilterFactoryBean.setSecurityManager(securityManager);
    		//拦截器
    		Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
    		//配置退出 过滤器,其中的具体的退出代码Shiro已经替我们实现了
    		filterChainDefinitionMap.put("/login", "anon");
    		filterChainDefinitionMap.put("/logout", "logout");
    		//过滤链定义,从上向下顺序执行,一般将/**放在最为下边
    		//authc:所有url都必须认证通过才可以访问; anon:所有url都都可以匿名访问-->
    		filterChainDefinitionMap.put("/static/**", "anon");
    		filterChainDefinitionMap.put("/**", "authc");
    		//未登录,重定向到登录页面,如果是前后端分离,不需要
    		shiroFilterFactoryBean.setLoginUrl("/login");
    		return shiroFilterFactoryBean;
    	}
    
    	/**
    	 * 将自己的验证方式加入容器
    	 */
    	@Bean
    	public CustomRealm myShiroRealm() {
    		CustomRealm customRealm = new CustomRealm();
    		return customRealm;
    	}
    
    	/**
    	 * 安全管理器
    	 */
    	@Bean
    	public SecurityManager securityManager(CustomRealm myShiroRealm) {
    		DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    		// 设置realm
    		securityManager.setRealm(myShiroRealm);
    		return securityManager;
    	}
    
    	@Bean(name = "lifecycleBeanPostProcessor")
    	public static LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
    		return new LifecycleBeanPostProcessor();
    	}
    
    	/**
    	 * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
    	 * 配置以下两个bean(DefaultAdvisorAutoProxyCreator(可选)和AuthorizationAttributeSourceAdvisor)即可实现此功能
    	 *
    	 * @return
    	 */
    	@Bean
    	@DependsOn({"lifecycleBeanPostProcessor"})
    	public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
    		DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
    		advisorAutoProxyCreator.setProxyTargetClass(true);
    		return advisorAutoProxyCreator;
    	}
    
    	@Bean
    	public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor() {
    		AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
    		authorizationAttributeSourceAdvisor.setSecurityManager(securityManager(myShiroRealm()));
    		return authorizationAttributeSourceAdvisor;
    	}
    }
    

    3.4 全局异常处理

    /**
     * @Author: oyc
     * @Date: 2020-06-02 16:41
     * @Description: 全局异常处理
     */
    @RestControllerAdvice
    @Slf4j
    public class ExceptionController {
    
    	@ResponseStatus(HttpStatus.FORBIDDEN)
        @ExceptionHandler(AuthorizationException.class)
        public ResponseEntity ErrorHandler401(AuthorizationException e) {
            log.error("没有通过权限验证!", e);
    		Map<String, String> result = new HashMap<String, String>();
    		result.put("status", "401");
    		//获取错误中中括号的内容
    		String message = e.getMessage();
    		String msg=message.substring(message.indexOf("[")+1,message.indexOf("]"));
    		//判断是角色错误还是权限错误
    		if (message.contains("role")) {
    			result.put("msg", "对不起,您没有" + msg + "角色");
    		} else if (message.contains("permission")) {
    			result.put("msg", "对不起,您没有" + msg + "权限");
    		} else {
    			result.put("msg", "对不起,您的权限有误");
    		}
    		return new ResponseEntity(result, HttpStatus.FORBIDDEN);
        }
    
        /**
         * shiro的异常
         */
        @ResponseStatus(HttpStatus.UNAUTHORIZED)
        @ExceptionHandler(ShiroException.class)
        public ResponseEntity handleShiroException(ShiroException e) {
    		log.error("系统发生异常!", e);
            return new ResponseEntity(e.getMessage(), HttpStatus.UNAUTHORIZED);
        }
    
    	/**
    	 * 	捕捉其他所有异常
     	 */
        @ExceptionHandler(Exception.class)
        public ResponseEntity globalException(HttpServletRequest request, Throwable e) {
    		log.error("系统发生异常!", e);
            return new ResponseEntity(e.getMessage(), HttpStatus.valueOf(getStatus(request).value()));
        }
    
        private HttpStatus getStatus(HttpServletRequest request) {
            Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
            if (statusCode == null) {
                return HttpStatus.INTERNAL_SERVER_ERROR;
            }
            return HttpStatus.valueOf(statusCode);
        }
    }
    

    链接不存在异常处理:

    /**
     * @Description: 404 异常处理
     * @Author oyc
     * @Date 2020/6/6 12:14 上午
     */
    @RestController
    public class NotFoundException implements ErrorController {
    
        private static final String ERROR_PATH = "/error";
    
        @Override
        public String getErrorPath() {
            return ERROR_PATH;
        }
    
        @RequestMapping(ERROR_PATH)
        public ResponseEntity error(){
            return ResponseEntity.badRequest().body("接口不存在!");
        }
    }
    

    3.5 编写登录类

    /**
     * @Author: oyc
     * @Date: 2020-06-02 16:39
     * @Description: 登录控制类
     */
    @RestController
    public class LoginController {
    
    	@GetMapping("/login")
    	public String login(User user) {
    		//添加用户认证信息
    		Subject subject = SecurityUtils.getSubject();
    		UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(user.getAccount(), user.getPassword());
    		try {
    			//进行验证,这里可以捕获异常,然后返回对应信息
    			subject.login(usernamePasswordToken);
    		} catch (AuthenticationException e) {
    			e.printStackTrace();
    			return "账号或密码错误!";
    		} catch (AuthorizationException e) {
    			e.printStackTrace();
    			return "没有权限!";
    		}
    		return "用户["+SecurityUtils.getSubject().getPrincipal()+"]登录成功";
    	}
    
    	/**
    	 * 注解检验角色-admin
    	 */
    	@RequiresRoles("admin")
    	@RequestMapping("role/admin")
    	public String roleAdmin() {
    		return "当前登录用户拥有admin角色";
    	}
    
    	/**
    	 * 注解检验角色-user
    	 */
    	@RequiresRoles("user")
    	@RequestMapping("role/user")
    	public String roleUser() {
    		return "当前登录用户拥有user角色";
    	}
    
    	/**
    	 * 注解检验权限 -- admin:add
    	 */
    	@RequiresPermissions("admin:add")
    	@RequestMapping("perm/adminAdd")
    	public String userAdd() {
    		return "当前登录用户拥有user:add权限";
    	}
    
    	/**
    	 * 注解检验权限 -- user:add
    	 */
    	@RequiresPermissions("user:add")
    	@RequestMapping("perm/userAdd")
    	public String userView() {
    		return "当前登录用户拥有user:add权限";
    	}
    	/**
    	 * 注解检验权限 --user user:add
    	 */
    	@RequiresRoles("user")
    	@RequiresPermissions("user:add")
    	@RequestMapping("role/perm/userAdd")
    	public String rolePermserAdd() {
    		return "当前登录用户拥有admin角色和user:add权限";
    	}
    }
    

    3.6 登录以及权限测试

    用户登录admin
    admin
    role admin权限
    admin角色权限
    role user角色
    在这里插入图片描述
    user:add 权限
    检验user:add权限
    参考源码:https://github.com/oycyqr/springboot-learning-demo/tree/master/springboot-shiro

    展开全文
  • Shiro安全框架面试题

    2020-11-10 23:17:13
    Apache Shiro是一个强大易用的java安全框架,提供了认证、授权、加密和会话管理功能,可为任何应用提供安全保障-从命令应用、移动应用到大型网络及企业应用。 Shiro已将安全认证相关的功能抽取出来组成一个框架,...

    1.什么是Shiro框架

    Apache Shiro是一个强大易用的java安全框架,提供了认证、授权、加密和会话管理功能,可为任何应用提供安全保障-从命令应用、移动应用到大型网络及企业应用。
    Shiro已将安全认证相关的功能抽取出来组成一个框架,使用Shiro就可以非常快速的完成认证、授权等功能,降低系统开发成本。
    shiro使用广泛,shiro可以运行在web应用、非web应用、集群分布式应用中越来越多的用户开始使用shiro。
    java领域中spring security也是一个开源的权限管理框架,但是spring security依赖spring运行,
    而shiro就相对独立,最主要因为shiro使用简单、灵活。

    总结

    Apache Shiro 是 Java 的一个安全(权限)框架。

    Shiro 可以非常容易的开发出足够好的应用,其不仅可以用在JavaSE 环境,也可以用在 JavaEE环境。

    Shiro 可以完成:认证、授权、加密、会话管理、与Web 集成、缓存 等。

    描述Shiro认证流程

    1、收集用户身份/凭证
    2、调用 Subject.login 进行登录
    3、创建自定义的 Realm类,继承 org.apache.shiro.realm.AuthorizingRealm 类,实现 doGetAuthenticationInfo() 方法
    4、提供 principals (身份)和 credentials(证 明)给 shiro,从而应用能验证用户身份

    描述Shiro授权流程

    1、在spring_shiro.xml中配置资源和页面相应信息
    2、创建自定义的 Realm类,继承 org.apache.shiro.realm.AuthorizingRealm 类,实现 doGetAuthorizationInfo() 方法
    3、编码实现:

    (1) 获取登录用户基本信息principal
    
    (2) 查询对应的角色进行循环存入Set集合中
    
    (3) 创建AuthorizationInfo,对应设置Roles并返回即可
    

    Shiro常用的哪些过滤器?分别是什么作用?

    1.身份验证相关的

    authc:证后访问
    
    anon:匿名访问
    
    logout:退出登录
    

    2.授权相关的

    roles[]:角色授权
    

    什么是加密?

    加密技术是对信息进行编码和解码的技术,编码是把原来可读信息(又称明文)译成代码形式(又称密文),其逆过程就是解码(解密)。加密技术的要点是加密算法,加密算法可以分为对称加密、非对称加密和不可逆加密三类算法。

    描述什么是对称式加密?哪些常用加密算法?

    对称加密:
    数据加密和解密采用的都是同一个密钥,因而其安全性依赖于所持有密钥的安全性。
    对称加密算法的主要优点是加密和解密速度快,加密强度高,且算法公开.
    常用算法名称:DES (Data Encryption Standard)、 AES(Advanced Encryption Standard)

    描述什么是非对称加密?哪些常用加密算法?

    非对称加密:
    使用两把完全不同但又是完全匹配的一对钥匙(即一把公开密钥或加密密钥和专用密钥或解密密钥)—公钥和私钥。在使用不对称加密算法加密文件时,只有使用匹配的一对公钥和私钥,才能完成对明文的加密和解密过程。加密明文时采用公钥加密,解密密文时使用私钥才能完成
    常用算法名称:SHS, RSA

    描述什么是不可逆加密?哪些常用加密算法?

    不可逆加密算法的特征是加密过程中不需要使用密钥,输入明文后由系统直接经过加密算法处理成密文,这种加密后的数据是无法被解密的,只有重新输入明文,并再次经过同样不可逆的加密算法处理,得到相同的加密密文并被系统重新识别后,才能真正解密。
    常用算法名称:MD5(32bit) SHA256(64bit) SHA512(生成128bit)

    什么是加盐加密?

    加盐加密是一种对系统登录口令的加密方式,它实现的方式是将每一个口令同一个叫做”盐“(salt)的n位随机数相关联

    shiro框架的核心功能?

    Authentication,Authorization,Cryptography,Session Management

    shiro框架的核心组件?

    Subject, SecurityManager 和 Realms

    展开全文
  • shiro安全框架流程: 1.Apache Shiro (更轻量, 使用更简单, 并不完全依赖 spring,可以独立使用 ),Spring Security (使用复杂, 依赖 Spring) 2.体系结构分为6大类: Authentication 认证 ---- 用户登录,身份...

    shiro安全框架流程:

    1.Apache Shiro (更轻量, 使用更简单, 并不完全依赖 spring,可以独立使用 ),Spring Security (使用复杂, 依赖 Spring)

    2.体系结构分为6大类:

    Authentication 认证 ---- 用户登录,身份识别 who are you
    Authorization 授权 --- 用户具有哪些权限、角色 what can you do  			  
    Cryptography 安全数据
    Session Manaement 会话
    Web Integration web 系统集成
    Interations 集成其它应用,spring、缓存
    

    3.使用:

    在maven的pom。xml中引入坐标,依赖(dependency);Shiro-All	
    Shiro运行流程:
    ApplicationCode 用户编写
    Subject 就是 shiro 管理的
    SecurityManager 安全管理器,是 shiro 权限控制核心对象,在编程时,只需要操作Subject 方法, 底层调用 SecurityManager 方法,无需直接编程操作 SecurityManager 
    Realm 应用程序和安全数据之间连接器 ,
    

    4.四种主要方式:

    1、 在程序中 通过 Subject 编程方式进行权限
    2、 配置 Filter 实现 URL 级别粗粒度权限控制
    3、 配置代理,基于注解实现细粒度权限
    4、 在页面中使用 shiro 自定义标签实现 页面显示权限
    

    用户登录功能的实现:
    在web.xml中配置 ShiroFilter,用/*拦截所有请求
    applicationContext-shiro.xml 中配置shiroFilter的bean文件

    anon 未认证可以访问
    authc 认证后可以访问
    perms 需要特定权限才能访问
    roles 需要特定角色才能访问user 需要特定用户才能
    user 需要特定用户才能
    
    最后在配置一个安全管理器 SecurityManager
    基本上的配置就完成了
    数据库最少需要的5张表结构
    权限表,角色表,权限角色表,用户表,用户角色关系表
    
    展开全文
  • 权限管理&Shiro安全框架

    千次阅读 2019-05-15 15:03:21
    权限管理属于系统安全的范畴,是实现对用户访问系统的控制,可以按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。 权限管理包括用户身份认证和授权两部分,简称认证授权。对于需要访问...
    • 权限管理简介权限管理概述

        权限管理属于系统安全的范畴,是实现对用户访问系统的控制,可以按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。

        权限管理包括用户身份认证和授权两部分,简称认证授权。对于需要访问控制的资源用户首先经过身份认证,认证通过后用户具有该资源的访问权限方可访问。

    • 用户身份认证

    认证概述:

        身份认证,就是判断一个用户是否为合法用户。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令,看其是否与系统中存储的该用户的用户名和口令一致,来判断用户身份是否正确。对于采用指纹等系统,则出示指纹;对于硬件Key等刷卡系统,则需要刷卡。

    认证流程:

         在实际项目中有些资源用户可以直接访问,有些资源必须对用户什么进行认证(检测用户的合法性),认证通过则可以访问,认证失败则不允许访问.

    关键术语:

    Subject:主体(被要求认证和授权管理的主体)

        访问系统的用户,主体可以是用户、程序等,进行认证的都称为主体;

    Principal:身份信息

        是主体(subject)进行身份认证的标识,标识必须具有唯一性,如用户名、手机号、邮箱地址等,

    一个主体可以有多个身份,但是必须有一个主身份(Primary Principal)。

    credential:凭证信息

        是只有主体自己知道的安全信息,如密码、证书等。

    • 用户身份授权

    授权概述:

    授权,即访问控制,控制谁能访问哪些资源。主体进行身份认证后需要分配权限方可访问系统的资源,对于某些资源没有权限是无法访问的。

    授权流程:

    关键术语:

    授权一般指允许who(Subject)对what(Resource)执行how(Permission)操作。

    Resource:系统中的资源,一般会对应一个Url,这个url的表现一般为菜单。

    Permission:对资源的访问标识(例如user:add,user:update,user:delete,user:view)

    主题,资源,权限在权限管理系统中通常会划分为不同的模块,例如其描述图如下:

    权限设计模型:

    权限设计模型如图所示:

    实际应用中经常还会将权限和资源合为一张表:权限(权限名称、资源名称、资源访问地址)

    权限访问控制:

    基于角色的访问控制(RBAC -Role-Based Access Control):扩展性相对较差

    基于资源的访问控制(RBAC-Resource-Based Access Control):扩展性比较好

    在使用RBAC时,实际应用中又分粗粒度权限控制和细粒度的权限控制,粗粒度一般指对资源类型的访问控制(例如用户可以导出所有订单明细),细粒度一般对具体某个资源实例的访问控制(例如只能导出自己工资信息),对于粗粒度的权限控制可以使用过滤器或spring拦截器都可以,对于细粒度的权限控制一般都会在业务层进行相关判定。

     

    • Shiro安全框架
    • Shiro基础:

    Shiro 概述:

          Shiro是apache旗下一个开源安全框架,它将软件系统的安全认证相关的功能抽取出来,实现用户身份认证,权限授权、加密、会话管理等功能,组成了一个通用的安全认证框架,使用shiro就可以非常快速的完成认证、授权等功能的开发,降低系统成本。

    课后了解:Spring security 安全框架

    Shiro 基本架构

    通过Shiro框架进行权限管理时,要涉及到的一些核心对象,主要包括:

    认证管理对象,授权管理对象,会话管理对象,缓存管理对象,加密管理对象

    以及Realm管理对象(领域对象:负责处理认证和授权领域的数据访问题)

     

    Shiro 认证流程:

    具体流程分析如下:

     

    1、首先调用Subject.login(token)进行登录,其会自动委托给Security Manager,调用之前必须通过SecurityUtils. setSecurityManager()设置;

    2、SecurityManager负责真正的身份验证逻辑;它会委托给Authenticator进行身份验证;

    3、Authenticator才是真正的身份验证者,Shiro API中核心的身份认证入口点,此处可以自定义插入自己的实现;

    4、Authenticator可能会委托给相应的AuthenticationStrategy进行多Realm身份验证,默认ModularRealmAuthenticator会调用AuthenticationStrategy进行多Realm身份验证;

    5、Authenticator会把相应的token传入Realm,从Realm获取身份验证信息,如果没有返回/抛出异常表示身份验证失败了。此处可以配置多个Realm,将按照相应的顺序及策略进行访问。

     

     

    Shiro 授权流程:

    Shiro 应用实践:

     

    shiro应用目前主要讲解shiro是集成到spring如何实现权限控制

     

     

    添加shiro依赖

    假设本项目spring配置已经基本实现

    <dependency>
    
          <groupId>org.apache.shiro</groupId>
    
          <artifactId>shiro-spring</artifactId>
    
          <version>1.3.2</version>
    
          </dependency>
    
          <dependency>
    
          <groupId>org.apache.shiro</groupId>
    
          <artifactId>shiro-ehcache</artifactId>
    
          <version>1.3.2</version>
    
    </dependency>


      构建Realm类:

    通过Realm实现基本认证及权限控制

    public class ShiroUserRealm extends AuthorizingRealm{
    	@Resource
    	private SysUserDao sysUserDao;
    	@Override
    	protected AuthorizationInfo doGetAuthorizationInfo(
    PrincipalCollection principals) {
    		System.out.println("==doGetAuthorizationInfo==");
    		SysUser user = (SysUser) SecurityUtils.getSubject()
    .getSession().getAttribute("currentUser");
    		int userId = user.getId();		
    		List<String> permsList = new ArrayList<>();
    		permsList = sysUserDao.findUserPermissions(userId);
    		//用户权限列表
    		Set<String> permsSet = new HashSet<String>();
    		for(String perm : permsList){
    			if(perm!=null && !("".equals(perm))){
    				permsSet.add(perm);
    			}
    		}
    		System.out.println("permsSet="+permsSet);
    		SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    		info.setStringPermissions(permsSet);
    		return info;
    	}
    	@Override
    	protected AuthenticationInfo doGetAuthenticationInfo(
    AuthenticationToken token) throws AuthenticationException {
            System.out.println("==doGetAuthenticationInfo==");
    		//1. 把 AuthenticationToken 转换为 UsernamePasswordToken 
    		UsernamePasswordToken upToken = (UsernamePasswordToken) token;
    		//2. 从 UsernamePasswordToken 中来获取 username
    		String username = upToken.getUsername();
    		//判断用户名是否存在,若存在,返回user对象
    		SysUser user =sysUserDao.findObjectByName(username);
    		//盐值. 
    		ByteSource credentialsSalt = ByteSource.Util.bytes(user.getSalt());
    		//自动完成密码比对   - 密码的比对:
    		//通过 AuthenticatingRealm 的 credentialsMatcher 属性来进行的密码的比对!
    		SimpleAuthenticationInfo info =
    		new SimpleAuthenticationInfo(
    		username, user.getPassword(),credentialsSalt,getName());
    		SecurityUtils.getSubject().getSession()
    		.setAttribute("currentUser",user);
    		return info;
    	}
    }

     

     

    登录认证Service实现:

    @Service
    public class SysShiroServiceImpl  implements SysShiroService {
    	@Override
    	public void login(String username, String password) {
    		Subject subject = SecurityUtils.getSubject();
    		if(subject.isAuthenticated())return;
    		// 把用户名和密码封装为 UsernamePasswordToken 对象
            UsernamePasswordToken token = 
            new UsernamePasswordToken(username, password);
            try{//登录认证 - 调用userRealm
            	subject.login(token);
            }catch (IncorrectCredentialsException ice) {
            throw new ServiceException("密码错误!");
            } catch(AuthenticationException ae){
            ae.printStackTrace();
            throw new ServiceException("认证失败");
            }
    	}
    }

    登录认证Controller实现:

    @Controller
    public class SysLoginController {
    	@Autowired
    	private SysShiroService loginService;
    	@RequestMapping("/loginUI")
    	public String login(){
    		return "login";
    	}
    	/**登录操作*/
    	@RequestMapping("/login")
    	@ResponseBody
    	public JsonResult login(String username,String password){
    		System.out.println(username+"/"+password);
    	    loginService.login(username, password);
    		return new JsonResult();
    	}
    }

    Shiro 注解应用:

    Shiro中通过使用@RequiresPermissions注解实现对某些方法的标识权限标识,例如

    修改Web.xml:

    <!-- spring整合shiro安全框架 -->
    
    <filter>
    
            <filter-name>DelegatingFilterProxy</filter-name>
    
            <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    
            <!-- 初始化参数 -->
    
            <init-param>
    
                <param-name>targetBeanName</param-name>
    
                <param-value>shiroFilter</param-value>
    
            </init-param>
    
    </filter>
    
    <filter-mapping>
    
          <filter-name>DelegatingFilterProxy</filter-name>
    
          <url-pattern>/*</url-pattern>
    
    </filter-mapping>

     

    添加spring-shiro配置文件:

    <!-- shiro工厂bean配置 -->
         <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
             <!-- shiro的核心安全接口 -->
             <property name="securityManager" ref="securityManager"/>
              <!-- 要求登录时的连接 -->
            <property name="loginUrl" value="/toLogin.do"></property>
             <!-- 登录成功后要跳转的连接(此处已经在登录中处理了) -->
             <!-- <property name="successUrl" value="/index.jsp"></property> -->
             <!-- 访问未对其授权的资源时,要跳转的连接 
             <property name="unauthorizedUrl" value="/default.html"></property>-->
             <!-- shiro连接约束配置 -->
             <property name="filterChainDefinitions">
                 <value>
                     <!-- 对静态资源设置允许匿名访问 -->
                     /images/** = anon
                     /js/** = anon
                     /css/** = anon
                     /static/** = anon
                     /bootstrap/** = anon
                     /jquery/** = anon
                     <!-- 可匿名访问路径,例如:验证码、登录连接、退出连接等 -->
                     /confirmUser.do = anon
                     <!-- 退出 -->
                     /logout.do = logout  <!-- 会调用Subject的logout方法,此方法会将session清空 -->
                     <!-- 剩余其他路径,必须认证通过才可以访问 -->
                     /** = authc
                 </value>
             </property>
         </bean>
         
         <!-- 配置shiro安全管理器 -->
         <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
             <property name="realm" ref="userRealm"></property>
         </bean>
         
         <!-- 自定义Realm -->
        <bean id="userRealm" class="com.jt.system.service.ShiroUserRealm">
        	<!-- 配置凭证算法匹配器 -->
        	<property name="credentialsMatcher">
        		<bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
        			<property name="hashAlgorithmName" value="MD5"/>
        			<!-- <property name="hashIterations" value="1024"/> -->
        		</bean>
        	</property>
        </bean>
    	<!--Shiro生命周期处理器-->
    	<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
    	
    	<!--启用shiro注解权限检查-->
    	<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
    	    depends-on="lifecycleBeanPostProcessor"/>
    	<bean  class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
    	    <property name="securityManager" ref="securityManager"/>
    	</bean>

     

    展开全文
  • shiro安全框架简介 Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。 三个核心组件:Subject, SecurityManager 和 Realms. Subject:代表了当前用户的安全操作,...
  • Shiro安全框架的使用

    千次阅读 2019-08-06 12:31:06
    Shiro安全框架 1.介绍 Shiro有三个核心的概念:Subject、SecurityManager和Realms。 Subject(主体):subject本质上是当前正在执行的用户的特定于安全的“view”。它也可以表示第三方服务、守护进程帐户、cron...
  • 照例又去官网扒了扒介绍:ApacheShiroisapowerfulandeasy-to-useJavasecurityframeworkthatperformsauthentication,authorization,cryptography,andsessionmanagement.WithShiro’seasy-to-understandAPI,...
  • (SpringBoot)Shiro安全框架深入解析

    千次阅读 2018-10-06 03:39:38
    最近在学习Shiro安全框架的使用,深入研究其原理,让自己更得心应手的使用这个框架。 内容目录 Shiro的整体架构介绍 框架验证流程与原理分析 Url匹配模式 加密机制 缓存机制 1.Shiro的整体架构介绍  1.1从...
  • 1.Shiro 概述Shiro是apache旗下一个开源安全框架,它将软件系统的安全认证相关的功能抽取出来,实现用户身份认证,权限授权、加密、会话管理等功能,组成了一个通用的安全认证框架,使用shiro就可以非常快速的完成...
  • 描述: 下面实现例子,实现简单,权限只控制到模块,模块勾选,模块下的功能全部通过。 其实要控制到方法,只需要添加一些标记字符即可。 详情查看博客: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,857
精华内容 8,342
关键字:

shiro安全框架