cas实现单点登录(2)

最新推荐文章于 2024-03-19 18:15:15 发布
最新推荐文章于 2024-03-19 18:15:15 发布
阅读量645 收藏 1
点赞数
分类专栏： java 文章标签： cas
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_41634343/article/details/111631823
版权

cas实现单点登录过程（二）

上次说过了cas的实现整个流程，现在说一下cas的代码实现方式。
我这里使用的shiro+cas的方式进行实现的，生成token的方式，这里是一个事例具体得要根据你自己的项目进行改造。
也可以根据我的cas实现过程修改后使用在spring-security中
前提是你本地要搭建cas server，我本地已经搭建完成。
直接上代码
添加shiro与cas的maven依赖

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

ShiroConfig的配置

/**
 * @description: shiro配置类
 */
@Configuration
public class ShiroConfiguration {

	@Autowired
	private JwtTokenUtil jwtTokenUtil;

	/**
	 * Shiro Realm 继承自AuthorizingRealm的自定义Realm,即指定Shiro验证用户登录的类为自定义的
	 */
	@Bean(name = "userRealm")
	public UserRealm userRealm() {
		UserRealm userRealm = new UserRealm();
		userRealm.setCachingEnabled(false);
		return userRealm;
	}

	@Bean
	public FilterRegistrationBean delegatingFilterProxy() {
		FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
		DelegatingFilterProxy proxy = new DelegatingFilterProxy();
		proxy.setTargetFilterLifecycle(true);
		proxy.setTargetBeanName("shiroFilter");
		filterRegistrationBean.setFilter(proxy);
		return filterRegistrationBean;
	}

	/**
	 * Shiro的Web过滤器Factory 命名:shiroFilter
	 */
	@Bean(name = "shiroFilter")
	public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
		ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
		//Shiro的核心安全接口,这个属性是必须的
		shiroFilter.setLoginUrl("/cas/login");
		shiroFilter.setSecurityManager(securityManager);
		Map<String, Filter> filters = new LinkedHashMap<>();
		CasCallbackFilter casCallbackFilter = new CasCallbackFilter();
		casCallbackFilter.setCasServerUrlPrefix("https://localhost:8443/cas-server-webapp-tomcat-5.3.14");
		casCallbackFilter.setCasService("http://localhost:8999/cas/callback");
		casCallbackFilter.setJwtTokenUtil(jwtTokenUtil);
		filters.put("casCallback", casCallbackFilter);
		JwtAuthenticationFilter jwtAuthenticationFilter = new JwtAuthenticationFilter();
		jwtAuthenticationFilter.setRedirectUrl("https://localhost:8443/cas-server-webapp-tomcat-5.3.14/login?service=http://localhost:8999/cas/callback");
		filters.put("authc", jwtAuthenticationFilter);

		shiroFilter.setFilters(filters);
		/*定义shiro过滤链  Map结构
		 * Map中key(xml中是指value值)的第一个'/'代表的路径是相对于HttpServletRequest.getContextPath()的值来的
		 * anon：它对应的过滤器里面是空的,什么都没做,这里.do和.jsp后面的*表示参数,比方说login.jsp?main这种
		 * authc：该过滤器下的页面必须验证后才能访问,它是Shiro内置的一个拦截器org.apache.shiro.web.filter.authc.FormAuthenticationFilter
		 */
		Map<String, String> filterMap = new LinkedHashMap<>();
         /* 过滤链定义，从上向下顺序执行，一般将 / ** 放在最为下边:这是一个坑呢，一不小心代码就不好使了;
          authc:所有url都必须认证通过才可以访问; anon:所有url都都可以匿名访问 */
		filterMap.put("/", "anon");
		filterMap.put("/static/**", "anon");
		filterMap.put("/login/auth", "anon");
		filterMap.put("/login/logout", "anon");
		filterMap.put("/error", "anon");

		filterMap.put("/cas/callback", "casCallback");
		filterMap.put("/**", "authc");

		shiroFilter.setFilterChainDefinitionMap(filterMap);
		return shiroFilter;
	}

	/**
	 * Subject工厂管理器
	 * @return
	 */
	@Bean
	public DefaultWebSubjectFactory subjectFactory(){
		DefaultWebSubjectFactory subjectFactory = new StatelessDefaultSubjectFactory();
		return subjectFactory;
	}

	/**
	 * 不指定名字的话，自动创建一个方法名第一个字母小写的bean
	 */
	@Bean
	public SecurityManager securityManager() {
		DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
		securityManager.setRealm(userRealm());
		// 替换默认的DefaultSubjectFactory，用于关闭session功能
		securityManager.setSubjectFactory(subjectFactory());
		securityManager.setSessionManager(sessionManager());
		// 关闭session存储，禁用Session作为存储策略的实现，但它没有完全地禁用Session所以需要配合SubjectFactory中的context.setSessionCreationEnabled(false)
		((DefaultSessionStorageEvaluator) ((DefaultSubjectDAO)securityManager.getSubjectDAO()).getSessionStorageEvaluator()).setSessionStorageEnabled(false);
		SecurityUtils.setSecurityManager(securityManager);
		return securityManager;
	}

	/**
	 * 会话管理器
	 * @return
	 */
	public DefaultSessionManager sessionManager(){
		DefaultSessionManager sessionManager =new DefaultSessionManager();
		// 关闭session定时检查，通过setSessionValidationSchedulerEnabled禁用掉会话调度器
		sessionManager.setSessionValidationSchedulerEnabled(false);
		return  sessionManager;
	}

	/**
	 * 用户授权信息缓存
	 * @return
	 */
	@Bean
	public CacheManager cacheManager() {
		return new MemoryConstrainedCacheManager();
	}

	/**
	 * 凭证匹配器
	 * （由于我们的密码校验交给Shiro的SimpleAuthenticationInfo进行处理了
	 * 所以我们需要修改下doGetAuthenticationInfo中的代码;
	 * ）
	 * 可以扩展凭证匹配器，实现 输入密码错误次数后锁定等功能，下一次
	 */
	@Bean
	public CredentialsMatcher CredentialsMatcher() {
		HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
		//散列算法:这里使用MD5算法;
		hashedCredentialsMatcher.setHashAlgorithmName("MD5");
		//散列的次数，比如散列两次，相当于 md5(md5(""));
		hashedCredentialsMatcher.setHashIterations(1024);
		//storedCredentialsHexEncoded默认是true，此时用的是密码加密用的是Hex编码；false时用Base64编码
		hashedCredentialsMatcher.setStoredCredentialsHexEncoded(true);
		return hashedCredentialsMatcher;
	}

	/**
	 * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证
	 * 配置以下两个bean(DefaultAdvisorAutoProxyCreator(可选)和AuthorizationAttributeSourceAdvisor)即可实现此功能
	 */
	@Bean
	public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
		DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
		advisorAutoProxyCreator.setProxyTargetClass(true);
		return advisorAutoProxyCreator;
	}

	@Bean
	public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor() {
		AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
		authorizationAttributeSourceAdvisor.setSecurityManager(securityManager());
		return authorizationAttributeSourceAdvisor;
	}
}

JwtAuthenticationFilter 执行URL的转发跳转到cas server中认证 拿取token做

public class JwtAuthenticationFilter extends AuthenticatingFilter {

    private final Logger LOGGER = LoggerFactory.getLogger(getClass());

    private String redirectUrl;

    public void setRedirectUrl(String redirectUrl) {
        this.redirectUrl = redirectUrl;
    }

    @Override
    protected AuthenticationToken createToken(ServletRequest request, ServletResponse servletResponse) throws Exception {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        // 先从Header里面获取   前端将token放置在header中
        String token = httpRequest.getHeader(Constant.TOKEN);
        if(StringUtils.isEmpty(token)){
            // 获取不到再从Parameter中拿
            token = httpRequest.getParameter(Constant.TOKEN);
            // 还是获取不到再从Cookie中拿
            if(StringUtils.isEmpty(token)){
                Cookie[] cookies = httpRequest.getCookies();
                if(cookies != null){
                    for (Cookie cookie : cookies) {
                        if(Constant.TOKEN.equals(cookie.getName())){
                            token = cookie.getValue();
                            break;
                        }
                    }
                }
            }
        }
        JwtToken jwtToken = new JwtToken();
        jwtToken.setToken(token);
        return jwtToken;
    }

    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        if (isLoginRequest(request,response)) {
            // TODO 跳转到认证服务 cas server带上回调地址  便于登录认证成功后回调到自己的服务
            ((HttpServletResponse) response).sendRedirect("https://localhost:8443/cas-server-webapp-tomcat-5.3.14/login?service=http://localhost:8999/cas/callback");
        }
        return super.executeLogin(request, response);
    }

    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        //必须设置要不不能得到token  因为这里是自动以的header所以要进行设置
        if (((HttpServletRequest) request).getMethod().equals(RequestMethod.OPTIONS.name())) {
            return true;
        }
        return false;
    }

    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest)request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        // 获取请求token，如果token不存在，直接返回401
        String token = getRequestToken((HttpServletRequest) request);
        if (StringUtils.isBlank(token)) {
            return executeLogin(request, response);
        }
        try {

            return executeLogin(request, response);
        } catch (Exception e) {
           e.printStackTrace();
            return false;
        }
    }


    @Override
    protected boolean onLoginSuccess(AuthenticationToken token, Subject subject, ServletRequest request,
                                     ServletResponse response) throws Exception {
        return true;
    }

    /**
     * 获取请求的token
     */
    private String getRequestToken(HttpServletRequest httpRequest) {
        // 从header中获取token
        String token = httpRequest.getHeader("token");
        // 如果header中不存在token，则从参数中获取token
        if (StringUtils.isBlank(token)) {
            token = httpRequest.getParameter("token");
        }
        if (StringUtils.isBlank(token)) {
            token = httpRequest.getParameter("sx_sso_sessionid");
        }
        return token;
    }
}

StatelessDefaultSubjectFactory

/**
 *  通过调用context.setSessionCreationEnabled(false)表示不创建会话，
 *  如果之后调用Subject.getSession()将抛出DisabledSessionException异常。
 */
public class StatelessDefaultSubjectFactory extends DefaultWebSubjectFactory {

    @Override
    public Subject createSubject(SubjectContext context) {
        // 不创建session
        context.setSessionCreationEnabled(false);
        return super.createSubject(context);
    }
}

CasCallbackFilter 从cas server中拿取ticket并验证是否正确过期，并生成token，cas server登出销毁token

public class CasCallbackFilter extends PathMatchingFilter {

    private JwtTokenUtil jwtTokenUtil;

    private TicketValidator ticketValidator;

    private String casService;

    private String casServerUrlPrefix;

    public String getCasServerUrlPrefix() {
        return casServerUrlPrefix;
    }

    public void setCasServerUrlPrefix(String casServerUrlPrefix) {
        this.casServerUrlPrefix = casServerUrlPrefix;
    }

    public String getCasService() {
        return casService;
    }

    public void setCasService(String casService) {
        this.casService = casService;
    }

    public JwtTokenUtil getJwtTokenUtil() {
        return jwtTokenUtil;
    }

    public void setJwtTokenUtil(JwtTokenUtil jwtTokenUtil) {
        this.jwtTokenUtil = jwtTokenUtil;
    }

    public CasCallbackFilter() {
        setSuffix(Constant.DEFAULT_CALLBACK_SUFFIX);
    }

    protected TicketValidator ensureTicketValidator() {
        if (this.ticketValidator == null) {
            this.ticketValidator = createTicketValidator();
        }
        return this.ticketValidator;
    }

    protected TicketValidator createTicketValidator() {
        String urlPrefix = getCasServerUrlPrefix();
        return new Cas20ServiceTicketValidator(urlPrefix);
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        if (mustApply(servletRequest)){
            HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
            String ticket = "";
            //判断ticket是否为空
            if (isTokenRequest(httpRequest)){
                ticket = httpRequest.getParameter(Constant.TICKET_NAME);
                Assertion casAssertion = null;
                try {
                    ticketValidator = ensureTicketValidator();
                    casAssertion = ticketValidator.validate(ticket, getCasService());
                    // get principal, user id and attributes
                    AttributePrincipal casPrincipal = casAssertion.getPrincipal();
                    String username = casPrincipal.getName();

                    // 验证用户名密码成功后生成token
                    String token = jwtTokenUtil.generateToken(username);
                    //TODO 保存ticket与token

                    //跳转到前端服务并携带token
                    ((HttpServletResponse) servletResponse).sendRedirect("http://localhost:9520/#/?token=" + token);
                } catch (TicketValidationException e) {
                    e.printStackTrace();
                }
            } else if (isBackLogoutRequest(httpRequest)) {
                //得到登出标识
                final String logoutMessage = httpRequest.getParameter(Constant.LOGOUT_NAME);
                //解析得到ticket
                ticket = substring(logoutMessage,"SessionIndex>","</");
                //TODO 在数据库中删除ticket
            }
        }else {
            filterChain.doFilter(servletRequest, servletResponse);
        }
    }

    @Override
    public void destroy() {

    }

    private boolean isBackLogoutRequest(HttpServletRequest httpRequest) {
        if (StringUtils.equalsAnyIgnoreCase(HttpMethod.POST.name(), httpRequest.getMethod())){
            String contentType = "";
            Enumeration<String> headerNames = httpRequest.getHeaderNames();
            while ( headerNames.hasMoreElements()){
                String headerName = headerNames.nextElement();
                if (StringUtils.equalsAnyIgnoreCase(headerName,Constant.CONTENT_TYPE_NAME)) {
                    contentType = httpRequest.getHeader(headerName);
                    if ( !StringUtils.startsWithIgnoreCase(contentType,Constant.TICKET_MULTIPART)){
                        if (StringUtils.isNoneEmpty(httpRequest.getParameter(Constant.LOGOUT_NAME))){
                            return Boolean.TRUE;
                        }
                    }
                }
            }

        }
        return Boolean.FALSE;
    }

    public static String substring(final String str, final String open, final String close) {
        if (str == null || open == null || close == null) {
            return null;
        }
        int start = str.indexOf(open);
        if (start != Constant.INDEX_NOT_FOUND) {
            int end = str.indexOf(close, start + open.length());
            if (end != Constant.INDEX_NOT_FOUND) {
                return str.substring(start + open.length(), end);
            }
        }
        return null;
    }

    private boolean isTokenRequest(HttpServletRequest httpRequest) {
        return StringUtils.isNoneEmpty(httpRequest.getParameter(Constant.TICKET_NAME));
    }
}

PathMatchingFilter

public abstract class PathMatchingFilter implements Filter {

    protected final Logger logger = LoggerFactory.getLogger(getClass());

    private String suffix;

    protected boolean mustApply(final ServletRequest request) {
        final String path = getPath((HttpServletRequest)request);
        logger.debug("path: {} | suffix: {}", path, suffix);
        if (StringUtils.isEmpty(suffix)) {
            return true;
        } else {
            return path != null && path.endsWith(suffix);//判断后缀是否相等  相等返回true
        }
    }

    public String getPath(HttpServletRequest request) {
        final String fullPath = request.getRequestURI();
        // it shouldn't be null, but in case it is, it's better to return empty string
        if (fullPath == null) {
            return "";
        }
        final String context = request.getContextPath();
        // this one shouldn't be null either, but in case it is, then let's consider it is empty
        if (context != null) {
            return fullPath.substring(context.length());
        }
        return fullPath;
    }

    public String getSuffix() {
        return suffix;
    }

    public void setSuffix(final String suffix) {
        this.suffix = suffix;
    }

}

JwtToken

public class JwtToken implements AuthenticationToken {

    private String principal;

    private String token;

    @Override
    public String getPrincipal() {
        return principal;
    }

    @Override
    public Object getCredentials() {
        return token;
    }

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public JwtToken() {
    }

    public JwtToken(String principal, String token) {
        this.principal = principal;
        this.token = token;
    }
}

/**
 * @description: 自定义Realm
 */
public class UserRealm extends AuthorizingRealm {

	private Logger logger = LoggerFactory.getLogger(UserRealm.class);

	@Autowired
	private JwtTokenUtil jwtTokenUtil;

	@Autowired
	private LoginService loginService;

	@Override
	public boolean supports(AuthenticationToken token) {
		//表示此Realm只支持JwtToken类型
		return token instanceof JwtToken;
	}

	@Override
	@SuppressWarnings("unchecked")
	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
		// 根据用户名查找角色，请根据需求实现
		String username = (String)principals.getPrimaryPrincipal();

		Session session = SecurityUtils.getSubject().getSession();
		//查询用户的权限
		JSONObject permission = (JSONObject) session.getAttribute(Constant.SESSION_USER_PERMISSION);
		logger.info("permission的值为:" + permission);
		logger.info("本用户权限为:" + permission.get("permissionList"));
		//为当前用户设置角色和权限
		SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
		authorizationInfo.addStringPermissions((Collection<String>) permission.get("permissionList"));
		return authorizationInfo;
	}

	/**
	 * 验证当前登录的Subject
	 * LoginController.login()方法中执行Subject.login()时 执行此方法
	 */
	@Override
	protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken) throws AuthenticationException {
		JwtToken jwtToken = (JwtToken) authcToken;
		// 获取token
		String token = jwtToken.getToken();
		String username = jwtTokenUtil.getUsernameFromToken(token);

		// 获取用户密码
		//String password = new String((char[]) authcToken.getCredentials());
		JSONObject user = loginService.getUser(username);
		if (user == null) {
			//没找到帐号
			throw new UnknownAccountException();
		}
		//交给AuthenticatingRealm使用CredentialsMatcher进行密码匹配，如果觉得人家的不好可以自定义实现
		SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
				user.getString("username"),
				token,
				//user.getString("password"),
				//ByteSource.Util.bytes("salt"), salt=username+salt,采用明文访问时，不需要此句
				getName()
		);
		//session中不需要保存密码
		//user.remove("password");
		//将用户信息放入session中
		SecurityUtils.getSubject().getSession().setAttribute(Constant.SESSION_USER_INFO, user);
		return authenticationInfo;
	}

	@Override
	public void clearCachedAuthorizationInfo(PrincipalCollection principals) {
		super.clearCachedAuthorizationInfo(principals);
	}

	@Override
	public void clearCachedAuthenticationInfo(PrincipalCollection principals) {
		super.clearCachedAuthenticationInfo(principals);
	}

	@Override
	public void clearCache(PrincipalCollection principals) {
		super.clearCache(principals);
	}

	public void clearAllCachedAuthorizationInfo() {
		getAuthorizationCache().clear();
	}

	public void clearAllCachedAuthenticationInfo() {
		getAuthenticationCache().clear();
	}

	public void clearAllCache() {
		clearAllCachedAuthenticationInfo();
		clearAllCachedAuthorizationInfo();
	}
}

@Component
public class JwtTokenUtil {

    @Value("${jwt.token.secret}")
    private String secret;

    @Value("${jwt.token.expiration}")
    private Long expiration;

    public String getSecret() {
        return secret;
    }

    public void setSecret(String secret) {
        this.secret = secret;
    }

    public Long getExpiration() {
        return expiration;
    }

    public void setExpiration(Long expiration) {
        this.expiration = expiration;
    }

    private Claims getClaimsFromToken(String token) {
        Claims claims;
        try {
            claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
        } catch (Exception e) {
            claims = null;
        }
        return claims;
    }


    /**
     * 生成token
     * @param username 用户名
     * @param
     * @return
     */
    public String generateToken(String username) {
        Map<String, Object> claims = new HashMap<>();
        claims.put(Constant.CLAIM_KEY_USERNAME, username);
//        claims.put(CLAIM_KEY_AUDIENCE, generateAudience(device));
        claims.put(Constant.CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }

    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                .signWith(SignatureAlgorithm.HS512, this.secret)
                .compact();
    }

    /**
     * 生成token时间 = 当前时间 + expiration（properties中配置的失效时间）
     * @return
     */
    private Date generateExpirationDate() {
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }

//    /**
//     * 通过spring-mobile-device的device检测访问主体
//     * @param device
//     * @return
//     */
//    private String generateAudience(Device device) {
//        String audience = AUDIENCE_UNKNOWN;
//        if (device.isNormal()) {
//            audience = AUDIENCE_WEB;//PC端
//        } else if (device.isTablet()) {
//            audience = AUDIENCE_TABLET;//平板
//        } else if (device.isMobile()) {
//            audience = AUDIENCE_MOBILE;//手机
//        }
//        return audience;
//    }

    /**
     * 根据token获取用户名
     * @param token
     * @return
     */
    public String getUsernameFromToken(String token) {
        String username;
        try {
            final Claims claims = getClaimsFromToken(token);
            username = claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }

    /**
     * 判断token失效时间是否到了
     * @param token
     * @return
     */
    private Boolean isTokenExpired(String token) {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }

    /**
     * 获取设置的token失效时间
     * @param token
     * @return
     */
    public Date getExpirationDateFromToken(String token) {
        Date expiration;
        try {
            final Claims claims = getClaimsFromToken(token);
            expiration = claims.getExpiration();
        } catch (Exception e) {
            expiration = null;
        }
        return expiration;
    }

    // /**
    //  * Token失效校验
    //  * @param token token字符串
    //  * @param loginInfo 用户信息
    //  * @return
    //  */
    // public Boolean validateToken(String token, LoginInfo loginInfo) {
    //     final String username = getUsernameFromToken(token);
    //     return (
    //             username.equals(loginInfo.getUsername())
    //                     && !isTokenExpired(token));
    // }

    public String refreshToken(String token) {
        final Claims claims = this.getClaimsFromToken(token);
        claims.put(Constant.CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }
}

public class Constant {

    public static final String SUCCESS_CODE = "100";
    public static final String SUCCESS_MSG = "请求成功";

    /**
     * session中存放用户信息的key值
     */
    public static final String SESSION_USER_INFO = "userInfo";
    public static final String SESSION_USER_PERMISSION = "userPermission";


    /*------------------------------------------------cas--------------------------------------*/

    public static final String CLAIM_KEY_USERNAME = "sub";

    public static final String CLAIM_KEY_AUDIENCE = "audience";

    public static final String CLAIM_KEY_CREATED = "created";

    public static final String AUDIENCE_UNKNOWN = "unknown";

    public static final String AUDIENCE_WEB = "web";

    public static final String AUDIENCE_MOBILE = "mobile";

    public static final String AUDIENCE_TABLET = "tablet";

    public static final String TOKEN = "token";

    public final static String DEFAULT_CALLBACK_SUFFIX = "/callback";

    public static final String TICKET_NAME = "ticket";

    public static final String TICKET_MULTIPART = "multipart";

    public static final String CONTENT_TYPE_NAME = "Content-Type";

    public static final String LOGOUT_NAME = "logoutRequest";

    public static final int INDEX_NOT_FOUND = -1;
}
Curry6
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vue与shiro结合实现权限按钮
12-15
vue+shiro实现前端细颗粒按钮级权限，并且可以实现删除和禁用两种不同模式，里面需要的前置技术包括 ：vue\vue的自定义指令\vue的自定义插件\vuex
个人笔记 springboot整合shiro实现权限管理，前端使用vue 10155
u013445457的专栏
08-30 620
转载自github，地址https://github.com/Heeexy/SpringBoot-Shiro-Vue 目录结构： application.yml spring: datasource: url: jdbc:mysql://localhost:3306/example?useUnicode=true&characterEncoding=UTF-...
Springboot + shiro + jwt + vue 实现基本的认证，鉴权
saienenen的博客
03-22 2086
一，前言 最近在思考如何实现一个权限管理系统。 在查阅一些资料和开源项目后，自己模仿着写了个demo 二，概念 1，RBAC模型 RBAC（Role-Based Access Control）——基于角色的访问控制 RBAC是一套成熟的权限模型。在传统权限模型中，我们直接把权限赋予用户。而在RBAC中，增加了“角色”的概念，我们首先把权限赋予角色，再把角色赋予用户。这样，由于增加了角色，授权会更加灵活方便。在RBAC中，根据权限的复杂程度，又可分为RBAC0、RBAC1、RBAC2、RBAC3。其中，R
springboot集成mongodb
xiaowei20091124的专栏
09-13 256
springboot集成mongodb。操作流程：1.pom文件中maven的引入 2.配置文件 3.实体类 4.dao层 5.service层 6.controller层
springboot第21集：SSO
程序员哆啦A梦，蓝胖子
05-10 454
单点登录单点登出支持跨域单点登录支持跨域单点登出前台站点：业务站点A，业务站点BSSO站点：登录，退出SSO服务：登录，登录状态，登出数据库，登录状态缓存在Redis登录时序图客户端，访问需要登录的页面，从业务站点，如果未从Cookie中获取AuthToken，跳转到登录页面，访问SSO站点，提交用户名，密码，验证用户登录的 SSO 服务，访问DB验证账号，保存登录状态 Redis，返回成功Red...
springboot集成CAS实现单点登录的示例代码
08-19
SpringBoot集成CAS实现单点登录是一项常见的企业级应用技术，旨在提供用户一次登录即可访问多个系统的便捷体验。CAS（Central Authentication Service）是一个开源的身份验证框架，它允许用户在一个集中的服务器上...
集成cas实现单点登录认证.zip
12-19
本压缩包"集成cas实现单点登录认证.zip"显然包含了关于如何使用CAS（Central Authentication Service）框架集成SSO认证的资源。下面我们将详细探讨相关的知识点。 1. CAS简介：CAS是耶鲁大学开源的一个Web应用的...
基于Cas的单点登录实现
08-04
`cas-shiro-demo-app` 是一个包含CAS和Shiro整合的示例应用，用于演示如何在实际项目中实现单点登录。这个示例可能包含以下组件： 1. **CAS服务器**：部署并配置CAS服务器，处理用户登录和票证验证。 2. **应用...
CAS5.3+windows AD域实现单点登录免身份认证.docx
05-17
CAS 5.3 及 Windows AD 域实现单点登录免身份认证 CAS（Central Authentication Service）是一种流行的开源身份验证系统，旨在提供单点登录（SSO）解决方案。Windows AD（Active Directory）则是微软公司推出的目录...
基于Java集成CAS单点登录【接部署即可启用】
12-11
基于Java中CAS的单点登录，有服务端的所有源码，将tomcat目录下的所有资源直接拷到Tomcat服务中间件的webapp目录下，阅读tomcat-webapp中的read.txt文档，查看使用说明，适用于第一次开发CAS单点登录的同学们，简单...
springboot+cas5.x+shiro+pac4j实现sso集成
05-18
springboot+cas5.x+shiro+pac4j实现sso集成,请先看我的博客，如果有问题再下载此源码学习，
CAS介绍
czplplp_900725的专栏
06-17 683
耶鲁大学开发的单点登录（Single SignOn）系统称为CAS（Central AuthenticationService），是一个独立于平台的，易于理解的开源软件，支持代理功能。SpringFramework的Acegi安全系统支持CAS，并提供了易于使用的方案。 CAS的设计目标       l、为多个Web应用提供单点登录基础设施，同时可以为非Web应用但拥有Web前端的功能服务
Shiro认证-初学（二）
qq_36472439的博客
12-17 207
1:前后端分离：更改以前的ajax请求，由于目前的项目基本上都是前后端分离的，所以我们所有的数据都已JSON格式返回给前端，对没有登录的请求进行拦截，覆盖掉shiro原本的跳转到login.jsp页面，继承FormAuthenticationFilter public class AjaxPermissionsAuthorizationFilter extends FormAuthentica...
Springboot+vue+shiro前后端分离项目解决权限验证提示没有认证(Authentation)的问题
qq_43114230的博客
01-11 1725
毕设做一个系统，其中涉及管理员、教师和学生三个角色，遂决定使用Springboot+vue+shiro（这三个技术只是这个记录中涉及到的三个技术或框架）。但是使用shiro的过程中遇到了非常多的问题。最后解决的问题是一直提示当前subject没有authentication。 直接把报错信息放到网上查发现没有一个解决问题的。 先说明解决方案： （1）注解不生效，在ShiroConfig里面配置两个bean： public DefaultAdvisorAutoProxyCreator adviso
SpringBoot项目中集成Shiro进行权限管控
最新发布
m0_60607536的博客
03-19 958
/require_permission | 拥有view和edit权限的用户才可以访问 |接口是用的get请求，像这种用户名和密码一般要用post请求，我这里没有去封装接口请求参数哈。// 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态。// 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态。| /article | 所有人都可以访问，但是用户与游客看到的内容不同 || /require_auth | 登入的用户才可以进行访问 |
shiro总结
ITbasketplayer的专栏
09-06 812
今天终于了解了项目中的shiro功能流程，项目中只是用到了shiro的内置的认证功能，没有做任何自己的处理，完全通过配置文件实现。项目中只用到authc（如果继续操作，需要做对应的表单验证否则不能通过）默认过滤器，使用shiro.ini配置文件，包括4项： [main]用于配置 SecurityManager 实例[user] 用于配置用户[role] 用于配置用户角色[urls] 用于配置拦截
springboot 下将shiro-cas替换为buji-pac4j
盛夏光年的博客
10-19 9203
buji-pac4ja,shiro
cas单点登录实例生成过程详细讲解
jingqiang521的专栏
01-23 3799
版权声明：本文为博主原创文章，未经博主允许不得转载。 最近公司让我研究cas单点登录，经过一周多的研究终于做出了demo，为了方便自己以后查看也为了给需要的人提供帮助，我决定写成博客。 首先对于单点登录的原理需要有大致的了解，原理网上的帖子很多，我大致说下：   CAS Client 与受保护的客户端应用部署在一起，以 Filter 方式保护受保护的资源。对于访问受保
CAS单点登录实现与HTTP协议应用
"CAS单点登录实现与SSO技术解析" CAS（Central Authentication Service，中央认证服务）是一种广泛应用的单点登录（Single Sign-On，简称SSO）解决方案，它允许用户在一个应用系统中登录后，无需再次认证即可访问...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值