pringSecurity

SpringSecurity是一个强大的可高度定制的认证和授权框架，对于Spring应用来说它是一套Web安全标准。SpringSecurity注重于为Java应用提供认证和授权功能，像所有的Spring项目一样，它对自定义需求具有强大的扩展性。

JWT

JWT是JSON WEB TOKEN的缩写，它是基于 RFC 7519
标准定义的一种可以安全传输的的JSON对象，由于使用了数字签名，所以是可信任和安全的。

JWT的组成

• WT token的格式：header.payload.signature
• header中用于存放签名的生成算法

{"alg": "HS512"}

• payload中用于存放用户名、token的生成时间和过期时间

{"sub":"admin","created":1489079981393,"exp":1489684781}

• signature为以header和payload生成的签名

String signature=HMACSHA512(base64UrlEncode(header) + "." +base64UrlEncode(payload),secret)

JWT实例

eyJhbGciOiJIUzUxMiJ9.eyJzdWIiOiJhZG1pbiIsImNyZWF0ZWQiOjE1NTY3NzkxMjUzMDksImV4cCI6MTU1NzM4MzkyNX0.d-iki0193X0bBOETf2UN3r3PotNIEAV7mzIxxeI5IxFyzzkOZxS0PGfF_SK6wxCv2K8S0cZjMkv6b5bCqc0VBw

JWT实现认证和授权的原理

• 用户调用登录接口，登录成功后获取到JWT的token；
• 之后用户每次调用接口都在http的header中添加一个叫Authorization的头，值为JWT的token；
• 后台程序通过对Authorization头中信息的解码及数字签名校验来获取其中的用户信息，从而实现认证和授权。

项目实战

1. 依赖引入

<!--SpringSecurity依赖配置-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!--JWT(Json Web Token)登录支持-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.0</version>
</dependency>

2. JWT工具类

• generateToken(UserDetails userDetails) :用于根据登录用户信息生成token
• getUserNameFromToken(String token)：从token中获取登录用户的信息
• validateToken(String token, UserDetails userDetails)：判断token是否还有效

    /**
     * 根据负责生成JWT的token
     */
    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }
    /**
     * 从token中获取登录用户名
     */
    public String getUserNameFromToken(String token) {
        String username;
        try {
            Claims claims=getClaimsFromToken(token);
            username=claims.getSubject();
        } catch (Exception e) {
            username=null;
        }
        return username;
    }

    /**
     * 验证token是否还有效
     *
     * @param token       客户端传入的token
     * @param userDetails 从数据库中查询出来的用户信息
     */
    public boolean validateToken(String token, UserDetails userDetails) {
        String username=getUserNameFromToken(token);
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }

3. SpringSecurity配置

@Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity.csrf()// 由于使用的是JWT，我们这里不需要csrf
                .disable()
                .sessionManagement()// 基于token，所以不需要session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                .antMatchers(HttpMethod.GET, // 允许对于网站静态资源的无授权访问
                        "/", "/*.html", "/favicon.ico","/**/*.html",
                        "/**/*.css","/**/*.js","/swagger-resources/**", "/v2/api-docs/**"
                )
                .permitAll()
                .antMatchers("/admin/login", "/admin/register")// 对登录注册要允许匿名访问
                .permitAll()
                .antMatchers(HttpMethod.OPTIONS)//跨域请求会先进行一次options请求
                .permitAll()
               // .antMatchers("/**")//测试时全部运行访问
              // .permitAll()
                .anyRequest()// 除上面外的所有请求全部需要鉴权认证
                .authenticated();
        // 禁用缓存
        httpSecurity.headers().cacheControl();
        // 添加JWT filter
        httpSecurity.addFilterBefore(jwtAuthenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class);
        
      //添加自定义未授权和未登录结果返回
        httpSecurity.exceptionHandling()
                .accessDeniedHandler(restfulAccessDeniedHandler)
                .authenticationEntryPoint(restAuthenticationEntryPoint);
    }

4.JwtAuthenticationTokenFilter

在用户名和密码校验前添加的过滤器，如果请求中有jwt的token且有效，会取出token中的用户名，然后调用SpringSecurity的API进行登录操作。

@Override
    protected void doFilterInternal(HttpServletRequest request,  HttpServletResponse response,
                                    FilterChain chain) throws ServletException, IOException {
        String authHeader=request.getHeader(this.tokenHeader);
        if (authHeader !=null && authHeader.startsWith(this.tokenHead)) {
              // The part after "Bearer "
            String authToken=authHeader.substring(this.tokenHead.length());
            String username=jwtTokenUtil.getUserNameFromToken(authToken);
            LOGGER.info("checking username:{}", username);
          
            if (username !=null && SecurityContextHolder.getContext().getAuthentication()==null) {
                UserDetails userDetails=this.userDetailsService.loadUserByUsername(username);
                if (jwtTokenUtil.validateToken(authToken, userDetails)) {
                    UsernamePasswordAuthenticationToken authentication=new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    LOGGER.info("authenticated user:{}", username);
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
            }
        }
        chain.doFilter(request, response);
    }

5. 备注说明

• configure(HttpSecurity httpSecurity)：用于配置需要拦截的url路径、jwt过滤器及出异常后的处理器；
• configure(AuthenticationManagerBuilder auth)：用于配置UserDetailsService及PasswordEncoder；
• RestfulAccessDeniedHandler：当用户没有访问权限时的处理器，用于返回JSON格式的处理结果；
• RestAuthenticationEntryPoint：当未登录或token失效时，返回JSON格式的结果；
• UserDetailsService:SpringSecurity定义的核心接口，用于根据用户名获取用户信息，需要自行实现；
• UserDetails：SpringSecurity定义用于封装用户信息的类（主要是用户信息和权限），需要自行实现；
• PasswordEncoder：SpringSecurity定义的用于对密码进行编码及比对的接口，目前使用的是BCryptPasswordEncoder；
• JwtAuthenticationTokenFilter：在用户名和密码校验前添加的过滤器，如果有jwt的token，会自行根据token信息进行登录。

端部分（使用Vue.js框架和axios库）：

htmlCopy code<!-- 登录表单 -->
<template>
  <form>
    <input v-model="username" type="text" placeholder="用户名">
    <input v-model="password" type="password" placeholder="密码">
    <button @click.prevent="login">登录</button>
  </form>
</template>

<script>
  import axios from 'axios'

  export default {
    data() {
      return {
        username: '',
        password: ''
      }
    },
    methods: {
      login() {
        axios.post('/api/login', {
          username: this.username,
          password: this.password
        })
        .then(response=> {
          // 登录成功，保存Token到本地存储
          localStorage.setItem('token', response.data.token)
          // 跳转到用户信息页面
          this.$router.push('/user')
        })
        .catch(error=> {
          // 登录失败，提示错误信息
          alert(error.response.data.message)
        })
      }
    }
  }
</script>

后端部分（使用Node.js和Express框架）：

javascriptCopy codeconst express=require('express')
const jwt=require('jsonwebtoken')
const bcrypt=require('bcrypt')
const app=express()

// 用户信息，实际中应该从数据库中查询
const users=[
  { id: 1, username: 'admin', password: '$2b$10$PUg2e7Qf.nEIkLIl7hww1erx5D5VFXP5K6EqZ0BlzKU6N8U6YJcDu' } // 密码为123456
]

// 生成JWT Token
function generateToken(user) {
  return jwt.sign({ id: user.id, username: user.username }, 'secret', { expiresIn: '1h' })
}

// 校验密码
function verifyPassword(password, hash) {
  return bcrypt.compareSync(password, hash)
}

// 用户登录
app.post('/api/login', (req, res)=> {
  const { username, password }=req.body
  const user=users.find(u=> u.username===username)
  if (!user) {
    res.status(401).json({ message: '用户名不存在' })
    return
  }
  if (!verifyPassword(password, user.password)) {
    res.status(401).json({ message: '密码错误' })
    return
  }
  const token=generateToken(user)
  res.json({ token })
})

// 获取用户信息
app.get('/api/user', (req, res)=> {
  const token=req.headers.authorization?.split(' ')[1]
  try {
    const decoded=jwt.verify(token, 'secret')
    res.json({ id: decoded.id, username: decoded.username })
  } catch (err) {
    res.status(401).json({ message: '认证失败' })
  }
})

app.listen(3000, ()=> console.log('Server started'))

以上示例中，前端使用axios库发送POST请求到后端的/api/login接口进行登录验证，后端根据请求中的用户名和密码进行校验，如果验证成功则生成JWT Token并返回给前端，前端保存Token到本地存储，并使用路由跳转到用户信息页面。后续的请求中，前端在请求头中带上Token，后端在后续的请求中，前端在请求头中带上Token，后端在/api/user接口中解析Token并返回用户信息。

在示例中，我们使用了JWT（JSON Web Token）作为登录凭证，它具有以下优点：

• 无状态：JWT是基于Token的认证方式，因此不需要在服务端存储会话信息，每个请求都包含认证信息，服务端只需要验证Token的有效性即可。
• 可扩展性：JWT中可以包含任意的JSON数据，因此可以将用户的一些基本信息（如ID、用户名等）放入Token中，便于在服务端解析使用。
• 安全性：JWT中包含了签名信息，服务端可以根据签名验证Token是否被篡改过。

在实际应用中，为了提高安全性，我们还可以采用以下一些措施：

• 使用HTTPS协议传输数据，防止数据被窃听和篡改。
• 对密码进行加密处理，可以使用bcrypt等加密算法。
• 设置Token的有效期，防止Token长期有效带来的安全风险。
• 使用黑名单机制，记录已失效的Token，在认证时检查Token是否在黑名单中。
• 针对敏感操作，如修改密码等，可以要求用户输入原密码进行验证。

另外，需要注意以下几点：

1. 不要将用户密码明文存储在数据库中，应该采用加密方式存储，如使用bcrypt等加密算法，确保用户密码的安全性。
2. 在登录验证成功后，返回的Token应该包含一些必要的用户信息，如用户ID、用户名等，方便后续在服务端中使用。
3. 对于需要进行认证的接口，需要在服务端对Token进行验证，并且限制只有已登录的用户才能访问。同时，需要限制Token的有效期，防止Token长时间有效带来的安全风险。
4. 在用户登录成功后，需要将Token存储在客户端，可以采用localStorage等方式存储。在每次发送请求时，需要将Token放入请求头中，并在服务端进行验证。
5. 在服务端对Token进行验证时，需要注意Token是否过期，是否被篡改等情况，可以使用JWT库等工具进行验证。

总之，用户登录验证是应用中非常重要的一部分，需要在设计时充分考虑安全性和可扩展性等因素，并采取相应的安全措施。用户登录验证是一个比较复杂的问题，需要综合考虑安全性和可扩展性等因素，同时采取相应的安全措施。

 Cookie[] cookies=request.getCookies();
 if (cookies !=null) {
 for (Cookie cookie : cookies) {
 System.out.println(
 cookie.getName() +
 cookie.getValue() +
 cookie.getMaxAge() +
 cookie.getPath() +
 cookie.getDomain() +
 cookie.getSecure() +
 cookie.isHttpOnly()//客户端js是否可以获取
 );
 }
 }

 Cookie cookie=new Cookie("myCookieName","myCookieValue");
 cookie.setHttpOnly(false);//Javascript不能处理
 //一个正值表示cookie将在经过许多秒之后过期。注意，值是cookie过期的最大时间，而不是cookie当前的时间。
 //负值表示cookie没有持久存储，在Web浏览器退出时将被删除。零值会导致删除cookie。
 cookie.setMaxAge(-1000);
 cookie.setSecure(false);//如果为true，仅支持HTTPS协议
 //cookie对指定目录中的所有页面以及该目录子目录中的所有页面都可见。
 cookie.setPath("/");
 //cookie.setDomain("www.a.com");//默认情况下，cookie只返回给发送cookie的服务器。
 response.addCookie(cookie);

<script type="text/javascript" src="http://www.b.com/setCookie?cname=token&cval=123456"></script>

@WebServlet(name="tg")
public class Servlet extends HttpServlet {
 protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
 //获取请求的目标域
 String from=request.getParameter("from");
 //生成token，
 String token="123456";
 //重定向到目标域
 response.sendRedirect(from + "?cname=token&cval=" + token);
 }
 ...
 }

 //将要写入的cookie项，调用者通过参数传递
 String cookieName=request.getParameter("cname");
 String cookieValue=request.getParameter("cval");
 //生成cookie
 Cookie cookie=new Cookie(cookieName,cookieValue);
 cookie.setPath("/");
 //一般可以将domain设置到顶级域
 //cookie.setDomain("www.b.com");
 response.addCookie(cookie);

<script type="text/javascript" src="http://www.b.com/reaf_cookies"></script>

<script>
alert(token);
</script>

 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 Cookie[] cookies=request.getCookies();
 StringBuilder stringBuilder=new StringBuilder();
 //一定要设置响应类型，否则可能导致IE不解析js直接进行下载操作
 response.setContentType("application/javascript");
 if (cookies !=null) {
 for (Cookie cookie : cookies) {
 //结果类似于这样 var token='123456';
 stringBuilder.append("var ")
 .append(cookie.getName())
 .append("=")
 .append("'")
 .append(cookie.getValue())
 .append("'")
 .append(";");
 }
 response.getWriter().append(stringBuilder.toString());
 }
 }

 <script type="text/javascript" src="http://www.b.com/user_info_2"></script>

 //要正确设置响应类型,避免IE出现下载
 response.setContentType("application/javascript");
 String userInfo="{\"id\":1,\"name\":\"zhangsan\"}";
 //返回拼接的javascript语句字符串，语句本身执行一个调用函数的操作
 String ret="showResult("+userInfo+")";

showResult({"id":1,"name":"zhangsan"})

 <script>
 function showResult(ret){
 console.log(ret)
 }
 </script>

 //通过参数传递回调函数名，一定程度降低了前后端代码的耦合度
 String callback=request.getParameter("callback");
 //返回拼接的javascript语句字符串，语句本身执行一个调用函数的操作
 String ret=callback+"("+userInfo+")";

 <script>
 var script=document.createElement("script");
 script.src="http://www.b.com/user_info_2?callback=showResult";
 document.body.appendChild(script);
 script.onload=function () {
 document.body.removeChild(script);
 }
 </script>

 $.ajax({
 url: "http://localhost:9090/query",
 type: "GET",
 dataType: "jsonp", //指定服务器返回的数据类型
 jsonpCallback: "showData", //指定回调函数名称
 success: function (data) {
 console.info("调用success");
 }
 });
 function showData(data){
 var result=JSON.stringify(data);
 }

 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 //简单请求，直接设置Access-Control-Allow-Origin就可以了
 response.setHeader("Access-Control-Allow-Origin","*");
 //要正确设置响应类型,避免IE出现下载
 response.setContentType("application/json");
 response.getWriter().write("{\"id\":1,\"name\":\"zhangsan\"}");
 }

 protected void doOptions(HttpServletRequest req, HttpServletResponse response) {
 response.setHeader("Access-Control-Allow-Origin","*");
 response.setHeader("Access-Control-Allow-Methods","GET,POST,OPTIONS,DELETE");
 response.setHeader("Access-Control-Allow-Headers","reqid,xxx");
 }