SpringSecurity+Oauth2+jwt 非对称加密实现单点登录

最新推荐文章于 2024-07-05 10:13:26 发布
最新推荐文章于 2024-07-05 10:13:26 发布
阅读量3.6k 收藏 14
点赞数 5
分类专栏： springsecurity 文章标签： spring jwt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43390114/article/details/107141056
版权

1、相关概念简单说明及总流程图

  • 非对称加密算法概念

    在这里插入图片描述

  • jwt说明
    JSON Web Token（JWT）是一个开放的行业标准（RFC 7519），它定义了一种简介的、自包含的协议格式，用于 在通信双方传递json对象，传递的信息经过数字签名可以被验证和信任。JWT可以使用HMAC算法或使用RSA的公 钥/私钥对来签名，防止被篡改。
    jwt特性：
    * 基于json，容易解析
    * 可以在令牌中自定义内容，容易扩展
    * 通过非对称加密算法以及签名技术，有效防止jwt被篡改
    * 在不通过认证服务器的情况下可以通过资源服务器完成认证
    * jwt令牌较长，占用存储空间

    jwt令牌结构
    * Header： 包括了令牌类型以及所使用的的算法
    * Payload : 存放了一些有效信息，以及自己添加的一些信息，但是不包括一些敏感的信息。
    * signature: 签名部分，防止被篡改
    完整形式:
    {
    alg: “RS256”,
    typ: “JWT”
    }.
    {
    companyId: “1”,
    userpic: null,
    user_name: “sss”,
    scope: [
    “app”
    ],
    name: “test02”,
    utype: “101002”,
    id: “49”,
    exp: 1593981062,
    authorities: [
    “course_view”,
    ],
    jti: “aba19576-8e73-430a-81cc-5c87d73012d2”,
    client_id: “ddd”
    }.
    [signature]
    Oauth2说名
    Oauth2的详细说明

  • 总体流程图
    在从这里插入图片描述

2、相关的配置

Pom文件：

 <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
        </dependency>

Application.yml文件

#自定义配置
auth:
  tokenValiditySeconds: 1200  #token存储到redis的过期时间
  clientId: XcWebApp
  clientSecret: XcWebApp
  cookieDomain: xuecheng.com
  cookieMaxAge: -1

# 鉴权服务器配置
encrypt:
  key-store:
    location: classpath:/xc.keystore
    secret: xuechengkeystore
    alias: xckey
    password: xuecheng
#资源服务器配置
security:
  oauth2:
    client:
      access-token-validity-seconds: 1200
      client-id: XcWebApp
      client-secret:  XcWebApp

3、认证服务器配置

package cn.hegongda.xuecheng.auth.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.bootstrap.encrypt.KeyProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.ClientDetailsService;
import org.springframework.security.oauth2.provider.client.JdbcClientDetailsService;
import org.springframework.security.oauth2.provider.token.DefaultAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
import org.springframework.security.oauth2.provider.token.store.KeyStoreKeyFactory;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.security.KeyPair;


@Configuration
@EnableAuthorizationServer
class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
    @Autowired
    private DataSource dataSource;
    //jwt令牌转换器
    @Autowired
    private JwtAccessTokenConverter jwtAccessTokenConverter;
    @Autowired
    UserDetailsService userDetailsService;
    @Autowired
    AuthenticationManager authenticationManager;
    @Autowired
    TokenStore tokenStore;
    @Autowired
    private CustomUserAuthenticationConverter customUserAuthenticationConverter;

    //读取密钥的配置
    @Bean("keyProp")
    public KeyProperties keyProperties(){

        return new KeyProperties();
    }

    @Resource(name = "keyProp")
    private KeyProperties keyProperties;


    //客户端配置
    @Bean
    public ClientDetailsService clientDetails() {

        return new JdbcClientDetailsService(dataSource);
    }
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.jdbc(this.dataSource).clients(this.clientDetails());
      
  
    @Bean
    @Autowired
    public TokenStore tokenStore(JwtAccessTokenConverter jwtAccessTokenConverter) {
        return new JwtTokenStore(jwtAccessTokenConverter);
    }
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter(CustomUserAuthenticationConverter customUserAuthenticationConverter) {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        KeyPair keyPair = new KeyStoreKeyFactory
                (keyProperties.getKeyStore().getLocation(), keyProperties.getKeyStore().getSecret().toCharArray())
                .getKeyPair(keyProperties.getKeyStore().getAlias(),keyProperties.getKeyStore().getPassword().toCharArray());
        converter.setKeyPair(keyPair);
    
        return converter;
    }
    //授权服务器端点配置
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {

        endpoints.accessTokenConverter(jwtAccessTokenConverter)
                .authenticationManager(authenticationManager)//认证管理器
                .tokenStore(tokenStore)//令牌存储
                .userDetailsService(userDetailsService);//用户信息service
    }

    //授权服务器的安全配置
    @Override
    public void configure(AuthorizationServerSecurityConfigurer oauthServer) throws Exception {
//        oauthServer.checkTokenAccess("isAuthenticated()");//校验token需要认证通过，可采用http basic认证
        oauthServer.allowFormAuthenticationForClients()
                .passwordEncoder(new BCryptPasswordEncoder())
                // 开启/oauth/token_key验证端口无权限访问
                .tokenKeyAccess("permitAll()")
                // 开启/oauth/check_token验证端口认证权限访问
                .checkTokenAccess("isAuthenticated()");
    }



}



@Configuration
@EnableWebSecurity
@Order(-1)
class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/userlogin","/userlogout","/userjwt");

    }
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        AuthenticationManager manager = super.authenticationManagerBean();
        return manager;
    }
    //采用bcrypt对密码进行编码
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .httpBasic().and()
                .formLogin()
                .and()
                .authorizeRequests().anyRequest().authenticated();

    }
}

4、登陆认证申请令牌

 @Autowired
    private AuthService authService;

    @Value("${auth.clientId}")
    String clientId;

    @Value("${auth.clientSecret}")
    String clientSecret;

    @Value("${auth.cookieDomain}")
    String cookieDomain;

    @Value("${auth.cookieMaxAge}")
    int cookieMaxAge;

    @PostMapping("/userlogin")
    @Override
    public LoginResult login(LoginRequest loginRequest) {

        if (loginRequest == null || StringUtils.isEmpty(loginRequest.getUsername())) {
            ExceptionCast.cast(AuthCode.AUTH_ACCOUNT_NOTEXISTS);
        }

        if (loginRequest == null || StringUtils.isEmpty(loginRequest.getPassword())) {
            ExceptionCast.cast(AuthCode.AUTH_PASSWORD_NONE);
        }

        String password = loginRequest.getPassword();
        String username = loginRequest.getUsername();

        // 申请令牌
        AuthToken authToken = authService.getAuthToken(username,password,clientId,clientSecret);

        // 将获取的authToken存入cookie中
        saveAuthTokenToCookie(authToken.getAccess_token());

        return new LoginResult(CommonCode.SUCCESS,authToken.getAccess_token());
    }

  /**
    将accessToken的唯一标识存放到浏览器cookie中,指定域名携带该cookie
  */
    private void saveAuthTokenToCookie(String access_token){
        HttpServletResponse response = ((ServletRequestAttributes)                          RequestContextHolder.getRequestAttributes()).getResponse();
       CookieUtil.addCookie(response,cookieDomain,"/","uid",access_token,cookieMaxAge,false);
    }

申请令牌代码：

@Autowired
    private RestTemplate restTemplate;

    // 获取申请令牌的地址
    @Autowired
    private LoadBalancerClient loadBalancerClient;

    @Autowired
    private RedisTemplate redisTemplate;

    @Value("${auth.tokenValiditySeconds}")
    Long tokenExpireTime;


    // 用户认证申请令牌
    public AuthToken getAuthToken(String username, String password, String clientId, String clientSecret) {

        AuthToken authToken = applyToken(username,password,clientId,clientSecret);

        // 判断令牌是否申请成功
        if (authToken == null) {
            ExceptionCast.cast(AuthCode.AUTH_TOKEN_GET_FAIL);
        }
        // 将令牌存入到redis中，并设置其过期时间
        boolean b = saveTokenToRedis(authToken,tokenExpireTime);
        if (!b){
            ExceptionCast.cast(AuthCode.AUTH_TOKEN_SAVE_FAIL);
        }
        return authToken;
    }

申请令牌的具体逻辑，通过密码的方式进行申请
http://localhost:40400/oauth/token?grant_type=password&username=xxxx&password=xxxx&clientId=xxxxx

private AuthToken applyToken(String username, String password, String clientId, String clientSecret){
        // http://localhost:40400/oauth/token 申请令牌的地址
        ServiceInstance serviceInstance = loadBalancerClient.choose(XcServiceList.XC_SERVICE_UCENTER_AUTH);

        // http://127.0.0.1:40400
        URI uri = serviceInstance.getUri();

        String url = uri + "/oauth/token";

        LinkedMultiValueMap<String,String> headers = new LinkedMultiValueMap<>();
        // 请求头携带认证信息
        headers.add("Authorization",getBasicCode(clientId,clientSecret));

        LinkedMultiValueMap<String,String> body = new LinkedMultiValueMap<>();
        // 通过密码模式获取access_token
        body.add("grant_type","password");
        body.add("username",username);
        body.add("password",password);
        body.add("client_id",clientId);
        // public HttpEntity(T body, MultiValueMap<String, String> headers) {
        HttpEntity<MultiValueMap<String,String>> httpEntity = new HttpEntity<>(body,headers);

        restTemplate.setErrorHandler(new DefaultResponseErrorHandler(){
            @Override
            public void handleError(ClientHttpResponse response) throws IOException {
                //当响应的值为400或401时候也要正常响应，不要抛出异常
                if(response.getRawStatusCode()!=400 && response.getRawStatusCode()!=401){
                    super.handleError(response);
                }
            }
        });
        ResponseEntity<Map> entity = restTemplate.exchange(url, HttpMethod.POST, httpEntity, Map.class);
        Map<String,String> map = entity.getBody();
   
        // 校验返回的信息是否存在错误
        if (map == null || map.get("refresh_token") == null ||
                map.get("access_token") == null || map.get("jti") == null) {

            String error_description = map.get("error_description");
            if (error_description.startsWith("坏的")){
                ExceptionCast.cast(AuthCode.AUTH_CREDENTIAL_ERROR);
            } else if (error_description == null) {
                ExceptionCast.cast(AuthCode.AUTH_ACCOUNT_NOTEXISTS);
            }
            ExceptionCast.cast(AuthCode.AUTH_TOKEN_GET_FAIL);
        }

        AuthToken authToken = new AuthToken();
        // 对token进行设置
        authToken.setAccess_token(map.get("jti"));
        authToken.setJwt_token(map.get("access_token"));
        authToken.setRefresh_token(map.get("refresh_token"));
        return authToken;
    }

头信息认证添加64位basic编码形式为： Basic clientId:clientSecret

// 获取basic64位编码
    private String getBasicCode(String clientId,String clientSecret){
        String string = clientId+":"+clientSecret;
        // 进行64位编码
        byte[] encode = Base64Utils.encode(string.getBytes());
        return "Basic "+new String(encode);
    }

将生成的token保存到redis中

private boolean saveTokenToRedis(AuthToken authToken,long time){
        String json = JSON.toJSONString(authToken);
        // 将token保存在redis中并设置过期时间
        redisTemplate.opsForValue().set(authToken.getAccess_token(),json,time, TimeUnit.SECONDS);

        // 判断是否存成功
        Long expire = redisTemplate.getExpire(authToken.getAccess_token());
        // 说明redis中存在
        return expire > 0;
    }

5、用户退出操作

用户退出操作主要两步：清空cookie，清空redis

 @GetMapping("/userlogout")
  public ResponseResult logout() {
        // 从cookie中取出唯一标识，根据唯一标识进行删除
        String uid = getCookie();
        // 从redis中清除token
        authService.delToken(uid);
        // 从cookie中清除token
        delToken(uid);
        return new ResponseResult(CommonCode.SUCCESS);
    }
private String getCookie(){
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        Map<String, String> map = CookieUtil.readCookie(request, "");
        if (map != null && map.get("uid") != null) {
            return map.get("uid");
        }
        return null;
    }
 private void delToken(String uid) {
        HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
        // 将cookie的时间设置为0
        CookieUtil.addCookie(response,cookieDomain,"/","uid",uid,0,false);
    }

6、资源服务配置

  资源服务器：指通过网关调用的一些其他的微服务
  在微服务中引入pom依赖 ，在resources下添加公钥文件

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
        </dependency>


package cn.hegongda.xuecheng.manage_course.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.stream.Collectors;

@Configuration
@EnableResourceServer
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true) // 进行权限校验
public class AuthenticationResourcesConfig extends ResourceServerConfigurerAdapter {

    private static final String PUBLIC_KEY = "publickey.txt";//公钥

    //定义JwtTokenStore，使用jwt令牌
    @Bean
    public TokenStore tokenStore(JwtAccessTokenConverter jwtAccessTokenConverter) {
        return new JwtTokenStore(jwtAccessTokenConverter);
    }
    //定义JJwtAccessTokenConverter，使用jwt令牌
    @Bean public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setVerifierKey(getPubKey());
        return converter;
    }


/*** 获取非对称加密公钥 Key * @return 公钥 Key */

    private String getPubKey() {
        Resource resource = new ClassPathResource(PUBLIC_KEY);
        try {
            InputStreamReader inputStreamReader = new InputStreamReader(resource.getInputStream());
            BufferedReader br = new BufferedReader(inputStreamReader);
            return br.lines().collect(Collectors.joining("\n"));
        } catch (IOException ioe) {
            return null;
        }
    }//Http安全配

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                 // 保证swagger正常使用
                .antMatchers("/v2/api-docs",
                        "/swagger-resources/configuration/ui",
                        "/swagger-resources","/swagger-resources/configuration/security",
                        "/swagger-ui.html","/webjars/**")
                .permitAll()
                .anyRequest()
                .authenticated();
    }
}

7、网关配置

添加pom依赖

 <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-zuul -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
                <version>1.4.6.RELEASE</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-eureka-client -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
                <version>2.0.3.RELEASE</version>
            </dependency>

application.yml进行配置

zuul:
  routes:
    manager-course:
      path: /course/courseview/*
      serviceId: xc-service-manage-course
      strip-prefix: false  #是否去掉前缀 /course ,false 不去掉，转发路径为 /xc-service-manage-course/course                 去掉 /xc-service-manage-course/
      sensitive-headers: # 是否将cookie传到下游服务器，不写将会全部传到下游服务器
      ignored-headers:

在路由之前需要进行认证，自定义过滤器继承ZuulFilter

@Component
public class LoginFilter extends ZuulFilter {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     *   pre：可以在请求被路由之前调用
        route：在路由请求时候被调用
        post：在route和error过滤器之后被调用
        error：处理请求时发生错误时被调用
     * @return
     */
    @Override
    public String filterType() {
        return "pre";
    }

    /**
     * 通过int值来定义过滤器的执行顺序
     * @return
     */
    @Override
    public int filterOrder() {
        return 0;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    /**
     *  用于自定义逻辑
     * @return
     */
    @Override
    public Object run() {

        // 获取request
        RequestContext currentContext = RequestContext.getCurrentContext();
        HttpServletRequest request = currentContext.getRequest();
        HttpServletResponse response = currentContext.getResponse();

        if (StringUtils.isEmpty(getJwtFromHeader(request))){
            setErrorMessage(currentContext,response);
            return null;
        }

        String accessToken = getAccessToken();
        if (checkJwt(accessToken) < 0) {
            setErrorMessage(currentContext,response);
            return null;
        }

        return null;
    }

    // 从cookie中获取accessToken
    private String getAccessToken(){
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        Map<String, String> map = CookieUtil.readCookie(request, "uid");
        if (map != null && map.get("uid") != null) {
            return map.get("uid");
        }
        return null;
    }

    // 从cookie中取出accessToken区redis中进行校验
    private Long checkJwt(String accessToken) {
        if (StringUtils.isEmpty(accessToken)){
            return -2L;
        }
        Long expire = stringRedisTemplate.getExpire(accessToken);
        return expire;
    }

    private String getJwtFromHeader(HttpServletRequest request){
        //头部取出令牌
        String authorization = request.getHeader("Authorization");
        if (StringUtils.isEmpty(authorization)){
            return null;
        }
        if (!authorization.startsWith("Bearer ")) {
            return null;
        }
        String jwt = authorization.substring(7);
        if (StringUtils.isEmpty(jwt)) {
            return null;
        }
        return jwt;
    }

/**
 封装错误信息
 */
    private void setErrorMessage(RequestContext currentContext, HttpServletResponse response){
        // 拒绝访问
        currentContext.setSendZuulResponse(false);
        // 设置返回码
        currentContext.setResponseStatusCode(200);
        // 构建响应信息
        ResponseResult responseResult = new ResponseResult(CommonCode.UNAUTHENTICATED);
        currentContext.setResponseBody(JSON.toJSONString(responseResult));
        response.setContentType("application/json;charset=utf-8");
    }
}

主要步骤：
* 从头中取出携带的令牌，判断令牌是否为空，为空则返回错误信息
* 从cookie中取出jwt的唯一标识，判断是否为空，为空，则返回错误信息
* 根据唯一标识在redis中获取jwt，判断其是否过期，过期则返回错误信息，否则，通过

完 ！ 参考资料—在线学成项目

JLRMEHSKVNZ
关注
专栏目录
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权
csweldn520的专栏
03-24 8358
一、 单点登录 1、单点登录技术方案 二、 第三方认证 1、 Oauth2认证 2、 Oauth2的应用场景 三、 Spring security Oauth2认证 1、 JWT （一） 、令牌结构 （二） 、生成私钥和公钥 （1）、生成密钥证书 （2）、查询证书信息 （3）、删除别名 （4）、导出公钥 2、 搭建Spring security认证服务器 （一）、导入Spring Security...
gateway oauth2 对称加密_Spring Security OAuth2 实现 使用JWT-不想当码农的程序员
weixin_39788386的博客
12-22 606
回过头来说一下资源服务 器的问题点吧，这里OAuth2+JWT用的是springsecurity ，具体怎么用springsecurity 搭建资源服务 器我就不说了。这里要讨论的问题是这样的，我们希望在spring mvc中，直接通过如下的形式获得登录用户信息@GetMapping("/me") public Authentication me(OAuth2Authentication...1、...
oauth2 jwt非对称加密配置_Spring Boot Security OAuth2 实现支持JWT令牌的授权服务器
weixin_36180471的博客
01-15 1089
概要之前的两篇文章，讲述了Spring Security 结合 OAuth2 、JWT 的使用，这一节要求对 OAuth2、JWT 有了解，若不清楚，先移步到下面两篇提前了解下。Spring Boot Security 整合 OAuth2 设计安全API接口服务Spring Boot Security 整合 JWT 实现 无状态的分布式API接口这一篇我们来实现 支持 JWT令牌 的授权服务器。优...
php 前后端 请求 加密_SpringBootSecurity学习（16）前后端分离版之 OAuth2.0 加密配置...
weixin_39517199的博客
11-26 179
示例代码的改进前面使用spring cloud security和spring cloud oauth2写了一个第三方授权的例子，例子非常的简单，主要目的是用来熟悉OAuth2.0 申请授权的整个流程，这个简单的示例肯定是不能直接用于生产环境的，还有很多需要改进的地方，我们来总结一下：1、只演示了授权码的形式，其它的三种(隐藏式，密码式，客户端凭证)并没有熟悉2、密码和秘钥是未加密的3、oauth...
Spring_Security+JWT+oauth2.0
最新发布
柊泓迅的博客
07-05 999
引入sercurity依赖之后，当访问后台资源，security都会判断你是否登录，没有登录就跳到登陆页面。（除了你放行的请求） 账户密码是security默认给的，user ， 密码是随机生成的。SpringSecurity 本质是一个过滤器链： 从启动是可以获取到过滤器链：遇到相关请求就会执行相关拦截判断 代码底层流程：重点看三个过滤器： FilterSecurityInterceptor：是一个方法级的权限过滤器, 基本位于过滤链的最底部。 super.beforeInvocation(fi) 表示
SpringCloud（10）使用Spring Cloud OAuth2和JWT保护微服务
weixin_34253539的博客
01-16 426
采用Spring Security AOuth2 和 JWT 的方式，避免每次请求都需要远程调度 Uaa 服务。采用Spring Security OAuth2 和 JWT 的方式，Uaa 服务只验证一次，返回JWT。返回的 JWT 包含了用户的所有信息，包括权限信息。 1.什么是JWT？ JSON Web Token（JWT）是一种开放的标准（RFC 7519），JWT定义了一种紧凑且自包含的标...
SpringBootSecurity学习（21）前后端分离版之OAuth2.0非对称加密
Blues的专栏
10-12 2583
JWT转换器 前面的例子中，都是在授权服务配置类中配置了一个很简单的jwt转换器，如下： 可以看到我们只用setSigningKey方法配置了一个秘钥，这里使用的是简单的对称加密的方式来加密jwt内容，同时资源服务器中使用的也是同样的秘钥配置jwt转换器： 除了对称加密的方式，生产环境使用非常多的是更加安全的非对称加密的方式来加密jwt。 生成公私钥 公私钥对可以使用jdk的命令 keyto...
[Spring Security] Spring Security OAuth2（密码模式）
架构探险之道
06-02 6108
[Spring Security] Spring Security OAuth2（密码模式） 目录[Spring Security] Spring Security OAuth2（密码模式）简介名词定义准备工作OAuth2流程核心配置类总结REFRENCES更多 手机用户请横屏获取最佳阅读体验，REFERENCES中是本文参考的链接，如需要链接和更多资源，可以关注其他博客发布地址。 平...
springboot整合springsecurity+oauth2.0授权认证+jwt增强
qq_40741120的博客
01-06 4057
springboot整合springsecurity+oauth2.0授权认证+jwt增强 本文将采用springboot去整合springsecurity，采用oauth2.0授权认证，使用jwt对token增强。本文仅为学习记录，如有不足多谢提出。
Spring Security OAuth2实现使用JWT的示例代码
08-27
Spring Security OAuth2 实现使用 JWT 的示例代码 在本文中，我们将讨论如何使用 Spring Security OAuth2 实现使用 JSON Web Tokens（JWT），并提供了一个完整的示例代码。 Spring Security OAuth2 介绍 Spring ...
Springcloud+ Springsecurity oauth2.0 + jwt简单实现认证
killdrsa的博客
04-09 3878
基于Springcloud+ Springsecurity oauth2.0 + jwt 实现一个认证授权手脚架 一.用户的认证与授权 什么是用户身份认证？ 用户身份认证即用户去访问系统资源时系统要求验证用户的身份信息，身份合法方可继续访问。常见的用户身份认 证表现形式有：用户名密码登录，指纹打卡等方式。 什么是用户授权？ 用户认证通过后去访问系统的资源，系统会判断用户是否拥有访问资源的权限，只允...
学成在线-第16天-讲义- Spring Security Oauth2 JWT RSA加解密
sdaujsj1的博客
05-25 2156
学成在线-第16天-讲义- Spring Security Oauth2 JWT 1 用户认证需求分析 1.1 用户认证与授权 ​ 截至目前，项目已经完成了在线学习功能，用户通过在线学习页面点播视频进行学习。如何去记录学生的学习过程呢？要想掌握学生的学习情况就需要知道用户的身份信息，记录哪个用户在什么时间学习什么课程；如果用户要购买课程也需要知道用户的身份信息。所以，去管理学生的学习过程最基本的要实现用户的身份认证。 什么是用户身份认证？ ​ 用户身份认证即用户去访问系统资源时系统要求验证用户的身份信息，身
spring-security-oauth2密码模式
u013008898的博客
06-12 1399
AuthorizationServerConfig： SecurityConfig：
SpringBoot（七）：JWT与Rsa非对称加密
千里之行，始于足下
05-06 1991
Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519)。该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。
jwt实现oauth2.0 java_SpringSecurity实现OAuth2+JWT
weixin_28696185的博客
02-17 322
一、基本概念1.1 认证方式1.1.1 基于session方式认证他的流程是：用户认证成功后，服务端生成相应的用户数据保存在session中，发给客户端的session_id保存在cookie中。这样用户请求时只要带上session_id就可以验证服务端是否存在session，以此完成用户的校验。当用户退出系统或session过期时，客户端的session_id也就无效了。1.1.2 基于toke...
十七.SpringCloud+Security+Oauth2实现微服务授权 -非对称加密生成JWT令牌
墨家巨子@俏如来
11-30 3166
仅做学习使用，老鸟飞过，欢迎交流 前言 在之前的微服务授权方案《SpringCloud+Security+Oauth2实现微服务授权 - 授权服务配置》中我们使用的是Oauth+JWT方式完成，今天介绍一下使用非对称加密方式RSA来生成JWT令牌 一.对称和非对称加密 1.对称加密 早期的加密方式都是使用对称加密即： 采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。加密算法是公开的，使用一个秘钥加密，必须使用相同的秘钥才能解密，通过秘钥来保证
学习加密(三)spring boot 使用RSA非对称加密,前后端传递参数加解密
攻城狮不是猫
02-28 3464
1.前面一篇是AES对称加密写了一个demo,为了后面的两者结合使用,今天去了解学习了下RSA非对称加密. 2.这是百度百科对(对称加密丶非对称加密)的解释: (1)对称加密算法在加密和解密时使用的是同一个秘钥。 (2)非对称加密算法需要两个密钥来进行加密和解密，这两个秘钥是公开密钥（public key，简称公钥）和私有密钥（private key，简称私钥）。 大致思路: ...
16、Spring Security Oauth2 JWT
Rsun2018的博客
05-06 573
用户认证与授权： 什么是用户身份认证？ 用户身份认证即用户去访问系统资源时系统要求验证用户的身份信息，身份合法方可继续访问。常见的用户身份认 证表现形式有：用户名密码登录，指纹打卡等方式。 什么是用户授权？ 用户认证通过后去访问系统的资源，系统会判断用户是否拥有访问资源的权限，只允许访问有权限的系统资源，没 有权限的资源将无法访问，这个过程叫用户授权。 单点登录(Single Sign On)： ...
Spring Security OAuth2 JWT资源服务器配置
OceanSky的专栏
07-16 1987
1.POM相关依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </depe...
springsecurity+oauth2+jwt实现单点登录
12-16
Spring Security 是一个功能强大的身份验证和权限控制框架，OAuth2 是一个授权框架，JWT（JSON Web Token）是一种用于跨域身份验证的开放标准。当它们结合在一起时，可以实现单点登录（SSO）功能。 首先，Spring Security 用于处理用户认证和授权，可以通过用户名密码登录或者其他方式获取访问令牌。然后，OAuth2 提供了标准的授权流程，以确保用户可以安全地获取访问令牌，并且在需要时进行刷新。JWT 则是一种用于在不同系统之间安全传输信息的方式，通常用于在不同系统之间传递身份验证信息。当用户成功登录并获得访问令牌后，可以将访问令牌嵌入在 JWT 中，然后将 JWT 传递给需要进行单点登录的其他系统。 通过这种方式，用户只需要在一个系统中登录成功后，就可以在其他系统中使用同一个访问令牌进行身份验证，从而实现了单点登录的功能。同时，由于使用了标准的 OAuth2 和 JWT，可以确保用户的身份验证与授权是安全可靠的。 总之，通过结合使用 Spring Security、OAuth2 和 JWT，可以实现单点登录功能，提供更加便捷、安全的用户体验。同时，也可以方便地集成其他系统，实现统一的用户身份验证和授权管理。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值