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");
 }