JWT的Spring Security

最新推荐文章于 2022-02-15 23:07:25 发布
最新推荐文章于 2022-02-15 23:07:25 发布
阅读量919 收藏
点赞数
文章标签： json java 数据库

Spring Security的默认行为易于用于标准Web应用程序。 它使用基于cookie的身份验证和会话。 此外，它会自动为您处理CSRF令牌（以防止中间人攻击）。 在大多数情况下，您只需要为特定路由设置授权权限即可，这是一种从数据库中检索用户的方法。

另一方面，如果您仅构建将由外部服务或SPA /移动应用程序使用的REST API，则可能不需要完整的会话。 JWT（JSON Web令牌）是一个小型的数字签名令牌。 所有需要的信息都可以存储在令牌中，因此您的服务器可以没有会话。

JWT需要附加到每个HTTP请求，以便服务器可以授权您的用户。 关于如何发送令牌，有一些选项。 例如，作为URL参数或使用承载模式在HTTP授权标头中： 

Authorization: Bearer <token string>

JSON Web令牌包含三个主要部分：

  1. 标头-通常包括令牌的类型和哈希算法。有效负载–通常包括有关用户的数据以及为其颁发令牌的数据。签名–用于验证邮件在此过程中是否未更改。

Example token

授权标头中的JWT令牌可能如下所示： 

Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9.eyJpc3MiOiJzZWN1cmUtYXBpIiwiYXVkIjoic2VjdXJlLWFwcCIsInN1YiI6InVzZXIiLCJleHAiOjE1NDgyNDI1ODksInJvbCI6WyJST0xFX1VTRVIiXX0.GzUPUWStRofrWI9Ctfv2h-XofGZwcOog9swtuqg1vSkA8kDWLcY3InVgmct7rq4ZU3lxI6CGupNgSazypHoFOA

如您所见，用逗号分隔三个部分–标头，声明和签名。 标头和有效负载是Base64编码的JSON对象。

Header: 
{
  "typ": "JWT",
  "alg": "HS512"
}
Claims/Payload: 
{
  "iss": "secure-api",
  "aud": "secure-app",
  "sub": "user",
  "exp": 1548242589,
  "rol": [
    "ROLE_USER"
  ]
}

Example application

在下面的示例中，我们将创建一个简单的API，该API包含2条路由-其中1条公开可用，而1条仅用于授权用户。

We will use page start.spring.io to create our application skeleton and select Security and Web dependencies. Rest of the options are up to your preferences.

Spring Initializr screenshot

JWT support for Java is provided by the library ĴJWT so we also need to add following dependencies to the pom.xml file:

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.10.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.10.5</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.10.5</version>
    <scope>runtime</scope>
</dependency>

Controllers

我们的示例应用程序中的控制器将尽可能简单。 如果用户未被授权，他们只会返回一条消息或HTTP 403错误代码。 

@RestController
@RequestMapping("/api/public")
public class PublicController {

    @GetMapping
    public String getMessage() {
        return "Hello from public API controller";
    }
}

@RestController
@RequestMapping("/api/private")
public class PrivateController {

    @GetMapping
    public String getMessage() {
        return "Hello from private API controller";
    }
}

Filters

首先，我们将定义一些可重用的常量和默认值，以生成和验证JWT。

注意：不应将JWT签名密钥硬编码到应用程序代码中（在示例中，我们现在将其忽略）。 您应该使用环境变量或.properties文件。 另外，密钥需要具有适当的长度。 例如，HS512算法需要大小至少为512个字节的密钥。 

public final class SecurityConstants {

    public static final String AUTH_LOGIN_URL = "/api/authenticate";

    // Signing key for HS512 algorithm
    // You can use the page http://www.allkeysgenerator.com/ to generate all kinds of keys
    public static final String JWT_SECRET = "n2r5u8x/A%D*G-KaPdSgVkYp3s6v9y$B&E(H+MbQeThWmZq4t7w!z%C*F-J@NcRf";

    // JWT token defaults
    public static final String TOKEN_HEADER = "Authorization";
    public static final String TOKEN_PREFIX = "Bearer ";
    public static final String TOKEN_TYPE = "JWT";
    public static final String TOKEN_ISSUER = "secure-api";
    public static final String TOKEN_AUDIENCE = "secure-app";

    private SecurityConstants() {
        throw new IllegalStateException("Cannot create instance of static util class");
    }
}

第一个过滤器将直接用于用户身份验证。 它将检查URL中的用户名和密码参数，并调用Spring的身份验证管理器进行验证。

如果用户名和密码正确，那么过滤器将创建一个JWT令牌并在HTTP授权标头中将其返回。 

public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

    private final AuthenticationManager authenticationManager;

    public JwtAuthenticationFilter(AuthenticationManager authenticationManager) {
        this.authenticationManager = authenticationManager;

        setFilterProcessesUrl(SecurityConstants.AUTH_LOGIN_URL);
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) {
        var username = request.getParameter("username");
        var password = request.getParameter("password");
        var authenticationToken = new UsernamePasswordAuthenticationToken(username, password);

        return authenticationManager.authenticate(authenticationToken);
    }

    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response,
                                            FilterChain filterChain, Authentication authentication) {
        var user = ((User) authentication.getPrincipal());

        var roles = user.getAuthorities()
            .stream()
            .map(GrantedAuthority::getAuthority)
            .collect(Collectors.toList());

        var signingKey = SecurityConstants.JWT_SECRET.getBytes();

        var token = Jwts.builder()
            .signWith(Keys.hmacShaKeyFor(signingKey), SignatureAlgorithm.HS512)
            .setHeaderParam("typ", SecurityConstants.TOKEN_TYPE)
            .setIssuer(SecurityConstants.TOKEN_ISSUER)
            .setAudience(SecurityConstants.TOKEN_AUDIENCE)
            .setSubject(user.getUsername())
            .setExpiration(new Date(System.currentTimeMillis() + 864000000))
            .claim("rol", roles)
            .compact();

        response.addHeader(SecurityConstants.TOKEN_HEADER, SecurityConstants.TOKEN_PREFIX + token);
    }
}

第二个过滤器处理所有HTTP请求，并检查是否存在带有正确令牌的Authorization标头。 例如，如果令牌未过期或签名密钥正确。

如果令牌有效，则过滤器会将身份验证数据添加到Spring的安全上下文中。 

public class JwtAuthorizationFilter extends BasicAuthenticationFilter {

    private static final Logger log = LoggerFactory.getLogger(JwtAuthorizationFilter.class);

    public JwtAuthorizationFilter(AuthenticationManager authenticationManager) {
        super(authenticationManager);
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
                                    FilterChain filterChain) throws IOException, ServletException {
        var authentication = getAuthentication(request);
        if (authentication == null) {
            filterChain.doFilter(request, response);
            return;
        }

        SecurityContextHolder.getContext().setAuthentication(authentication);
        filterChain.doFilter(request, response);
    }

    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        var token = request.getHeader(SecurityConstants.TOKEN_HEADER);
        if (StringUtils.isNotEmpty(token) && token.startsWith(SecurityConstants.TOKEN_PREFIX)) {
            try {
                var signingKey = SecurityConstants.JWT_SECRET.getBytes();

                var parsedToken = Jwts.parser()
                    .setSigningKey(signingKey)
                    .parseClaimsJws(token.replace("Bearer ", ""));

                var username = parsedToken
                    .getBody()
                    .getSubject();

                var authorities = ((List<?>) parsedToken.getBody()
                    .get("rol")).stream()
                    .map(authority -> new SimpleGrantedAuthority((String) authority))
                    .collect(Collectors.toList());

                if (StringUtils.isNotEmpty(username)) {
                    return new UsernamePasswordAuthenticationToken(username, null, authorities);
                }
            } catch (ExpiredJwtException exception) {
                log.warn("Request to parse expired JWT : {} failed : {}", token, exception.getMessage());
            } catch (UnsupportedJwtException exception) {
                log.warn("Request to parse unsupported JWT : {} failed : {}", token, exception.getMessage());
            } catch (MalformedJwtException exception) {
                log.warn("Request to parse invalid JWT : {} failed : {}", token, exception.getMessage());
            } catch (SignatureException exception) {
                log.warn("Request to parse JWT with invalid signature : {} failed : {}", token, exception.getMessage());
            } catch (IllegalArgumentException exception) {
                log.warn("Request to parse empty or null JWT : {} failed : {}", token, exception.getMessage());
            }
        }

        return null;
    }
}

Security configuration

我们需要配置的最后一部分是Spring Security本身。 配置很简单，我们只需要设置一些细节即可：

  • Password encoder – in our case bcrypt
  • CORS configuration
  • Authentication manager – in our case simple in-memory authentication but in real life, you’ll need something like UserDetailsService
  • Set which endpoints are secure and which are publicly available
  • Add our 2 filters into the security context
  • Disable session management – we don’t need sessions so this will prevent the creation of session cookies 
@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true)
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.cors().and()
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/api/public").permitAll()
            .anyRequest().authenticated()
            .and()
            .addFilter(new JwtAuthenticationFilter(authenticationManager()))
            .addFilter(new JwtAuthorizationFilter(authenticationManager()))
            .sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }

    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user")
            .password(passwordEncoder().encode("password"))
            .authorities("ROLE_USER");
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        final UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", new CorsConfiguration().applyPermitDefaultValues());

        return source;
    }
}

Test

Request to public API 
GET http://localhost:8080/api/public

HTTP/1.1 200 
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-Frame-Options: DENY
Content-Type: text/plain;charset=UTF-8
Content-Length: 32
Date: Sun, 13 Jan 2019 12:22:14 GMT

Hello from public API controller

Response code: 200; Time: 18ms; Content length: 32 bytes
Authenticate user 
POST http://localhost:8080/api/authenticate?username=user&password=password

HTTP/1.1 200 
Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9.eyJpc3MiOiJzZWN1cmUtYXBpIiwiYXVkIjoic2VjdXJlLWFwcCIsInN1YiI6InVzZXIiLCJleHAiOjE1NDgyNDYwNzUsInJvbCI6WyJST0xFX1VTRVIiXX0.yhskhWyi-PgIluYY21rL0saAG92TfTVVVgVT1afWd_NnmOMg__2kK5lcna3lXzYI4-0qi9uGpI6Ul33-b9KTnA
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-Frame-Options: DENY
Content-Length: 0
Date: Sun, 13 Jan 2019 12:21:15 GMT

<Response body is empty>

Response code: 200; Time: 167ms; Content length: 0 bytes
Request to private API with token 
GET http://localhost:8080/api/private
Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9.eyJpc3MiOiJzZWN1cmUtYXBpIiwiYXVkIjoic2VjdXJlLWFwcCIsInN1YiI6InVzZXIiLCJleHAiOjE1NDgyNDI1ODksInJvbCI6WyJST0xFX1VTRVIiXX0.GzUPUWStRofrWI9Ctfv2h-XofGZwcOog9swtuqg1vSkA8kDWLcY3InVgmct7rq4ZU3lxI6CGupNgSazypHoFOA

HTTP/1.1 200 
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-Frame-Options: DENY
Content-Type: text/plain;charset=UTF-8
Content-Length: 33
Date: Sun, 13 Jan 2019 12:22:48 GMT

Hello from private API controller

Response code: 200; Time: 12ms; Content length: 33 bytes
Request to private API without token

如果您在没有有效JWT的情况下调用安全端点，则会收到HTTP 403消息。 

GET http://localhost:8080/api/private

HTTP/1.1 403 
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-Frame-Options: DENY
Content-Type: application/json;charset=UTF-8
Transfer-Encoding: chunked
Date: Sun, 13 Jan 2019 12:27:25 GMT

{
  "timestamp": "2019-01-13T12:27:25.020+0000",
  "status": 403,
  "error": "Forbidden",
  "message": "Access Denied",
  "path": "/api/private"
}

Response code: 403; Time: 28ms; Content length: 125 bytes

Conclusion

本文的目的不是展示一种在Spring Security中使用JWT的正确方法。 这是如何在实际应用中实现此目标的示例。 另外，我不想深入探讨该主题，因此缺少诸如令牌刷新，无效等之类的东西，但将来可能会涉及这些主题。

Ťl;dr You can find the full source code of this example API in my GiŤHub repository.

from: https://dev.to//keysh/spring-security-with-jwt-3j76

cunxiedian8614
关注
Spring Security+JWT简述
m0_67266585的博客
09-08 2177
Spring Security是Spring家族的一个安全管理框架, 相比于另一个安全框架Shiro, 它具有更丰富的功能。一般中大型项目都是使用SpringSecurity做安全框架, 而Shiro上手比较简单spring security 的核心功能:认证(你是谁): 只有你的用户名或密码正确才能访问某些资源授权(你能干嘛): 当前用户具有哪些功能, 将资源进行划分, 如在公司中分为普通资料和高级资料, 只有经理用户以上才能访文高级资料, 其他人只能拥有访问普通资料的权限。
SpringBoot+Spring Security+JWT（三更草堂）
Roc的博客
09-12 7830
Springsecurity是Spring家族中的一个安全管理框架。相比与另外一个安全框架shiro，它提供了更丰富的功能，社区资源也比Shiro丰富。一般来说中大型的项目都是使用来做安全框架。小项目有Shiro的比较多，因为相比与SpringSecurity，Shiro的上手更加的简单。—般Web应用的需要进行认证和授权。认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户授权：经过认证后判断当前用户是否有权限进行某个操作而认证和授权也是SpringSecurity作为安全框架的核心功能。
springSecurityJwt
05-17
Spring Security JWT样本-v1
SpringSecurity学习三 SpringSecurity 结合jwt
YellowShite的博客
06-01 475
相关依赖 <!-- jwt依赖 --> <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.16.0</version> </dependency> <!-- 基本依赖 --> <dependency&g
spring secruity实现jwt
qq_44756582的博客
06-30 250
jwt jwt(jSON Web Token)相关知识自行百度 什么是 JWT – JSON WEB TOKEN jwt官网 spring secruity实现jwt步骤 导入jwt实现框架 重写
整合SpringSecurity+JWT实现登录认证
豪华的博客
05-21 801
整合步骤 这里我们以mall-portal改造为例来说说如何实现。 第一步，给需要登录认证的模块添加mall-security依赖： <dependency> <groupId>com.macro.mall</groupId> <artifactId>mall-security</artifactId> </dependency> 第二步，添加MallSecurityConfig配置类，继承mall
spring-security-jwt, 演示如何在 Spring Security 中使用 JWT.zip
09-18
spring-security-jwt, 演示如何在 Spring Security 中使用 JWT Spring Security 和JWT教程这里代码主要用于使用 Spring Security 和 JWT 教程补充无状态身份验证。如果你选择了代码，还可以使用这个库发现添加XSRF保护的策略，以及在Java项目中注册/登录功能的策
Spring Boot(四)之使用JWT和Spring Security保护REST API
08-30
"Spring Boot使用JWT和Spring Security保护REST API" Spring Boot中的REST API保护是非常重要的，因为直接暴露API可能会带来很大的风险。因此，本文将介绍使用JWT（Json Web Token）和Spring Security来保护REST ...
解析SpringSecurity+JWT认证流程实现
08-18
SpringSecurity+JWT认证流程实现 作为一名IT行业大师，我将对SpringSecurity+JWT认证流程实现进行详细的解释，并生成相关知识点。 一、SpringSecurity的工作流程 SpringSecurity的工作流程是基于标准servlet过滤...
Spring Security基于JWT实现SSO单点登录详解
08-25
Spring Security 基于 JWT 实现 SSO 单点登录详解 基于 Spring Security 框架和 JWT（JSON Web Token）技术，可以实现 SSO（Single Sign-On）单点登录系统。SSO 是一种常见的身份验证机制，允许用户使用同一个...
Spring Boot集成JWT&Spring Security进行接口安全认证
我们的征途是星辰大海
10-31 1万+
一，协议token验证未通过返回：{ "header": { "errorinfo": "无效的token", "errorcode": "8001" } }页面上对这种情况的处理，都跳转到登陆页面；登陆验证未通过返回：{ "header": { "errorinfo": "用户名或密码错误，请重新输入！", "
http状态码
weixin_34203426的博客
05-24 1232
从网上找资料整理的的http状态码 200（成功） 服务器已成功处理了请求。通常，这表示服务器提供了请求的网页。 201（已创建） 请求成功且服务器已创建了新的资源。 202（已接受） 服务器已接受了请求，但尚未对其进行处理。 203（非授权信息） 服务器已成功处理了请求，但返回了可能来自另一来源的信息。 204（无内容） 服务器成功处理了请求，但未返回任...
新code为aadb010476_Fabric学习笔记(六) - chaincode开发模式
weixin_39526546的博客
12-21 920
启动网络 terminal1cd /opt/gopath/src/github.com/hyperledger/fabric-samples/chaincode-docker-devmodedocker-compose -f docker-compose-simple.yaml up查看启动是否成功 terminal2docker psCONTAINER ID IMAGE ...
后端架构token授权认证机制：spring security JSON Web Token（JWT）简例（2）
Zhang Phil
02-15 1391
这里有一个简单例子实现token认证授权访问： 后端架构token授权认证机制：spring security JSON Web Token（JWT）简例_Zhang Phil-CSDN博客 再写一个例子，该例中，假设 /api需要登录且具有有效token才能访问的接口。 /home是公开的接口，无须登录授权均可访问。 /login是登录接口，用户通过/login提交用户名和密码进行鉴权验证。 import org.springframework.beans.factory.annotat
java jwt框架_Spring安全框架——jwt的集成(服务器端)
weixin_39598308的博客
03-04 344
新建用户表——users，并完成数据库增删查改一、新建表二、持久化映射，建立模型类，添加主键生成器//指定生成器名称@GeneratedValue(generator = "uuid2" )@GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator" )三、建立Dao层package edu.ynmd.c...
SpringBoot + JWT token验证
雍正写BUG
10-27 269
引入JWT依赖： <!--jwt--> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version&...
OpenSSH
热门推荐
Gf19991225的博客
09-25 3万+
文章目录一： OpenSSH 简介二：OpenSSH的作用三：OpenSSH的工作模式四：OpenSSH使用五 SSH 主机密钥六：配置基于 SSH 密钥的身份验证七：自定义 SSH 服务配置八：SSH 安全注意事项 一： OpenSSH 简介 OpenSSH这一术语指系统中使用的Secure Shell软件的软件实施。用于在远程系统上安全运行shell。如果您在可提供ssh服务的远程Linux系统中拥有用户帐户，则ssh是通常用来远程登录到该系统的命令。ssh命令也可用于在远程系统中运行命令。 常用的远程
栈和队列实验
sunshine9958的专栏
11-02 2万+
#include"SeqStack.h" template SeqStack::SeqStack() { top=-1; } template void SeqStack::Push(DataType x) { if(top==StackSize-1)throw"上溢"; top++; data[top]=x; } template DataType SeqStack::Pop()
50 Useful CSS Snippets Every Designer Should Have
一个Java菜鸟(同微信公众号)
05-30 2万+
With so many new trends advancing every year it can be difficult keeping up with the industry. Website designers and frontend developers have been deeply ingrained into the newer CSS3 properties,
Spring Security OAuth2整合JWT实战教程
"这篇教程详细介绍了如何在Spring Security OAuth2框架中集成JWT（JSON Web Tokens）的示例代码。" 在现代Web应用中，安全性和权限管理是至关重要的部分，Spring Security OAuth2提供了强大的安全解决方案。同时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值