// HMAC key - Block serialization and storage as String in JVM memory
private transient byte[] keyHMAC = ...;

...

//Create a verification context for the token requesting explicitly the use of the HMAC-256 hashing algorithm
JWTVerifier verifier = JWT.require(Algorithm.HMAC256(keyHMAC)).build();

//Verify the token, if the verification fail then a exception is throwed
DecodedJWT decodedToken = verifier.verify(token);

// HMAC key - Block serialization and storage as String in JVM memory
private transient byte[] keyHMAC = ...;
// Random data generator
private SecureRandom secureRandom = new SecureRandom();

...

//Generate a random string that will constitute the fingerprint for this user
byte[] randomFgp = new byte[50];
this.secureRandom.nextBytes(randomFgp);
String userFingerprint = DatatypeConverter.printHexBinary(randomFgp);

//Add the fingerprint in a hardened cookie - Add cookie manually because SameSite attribute is not supported by javax.servlet.http.Cookie class
String fingerprintCookie = "__Secure-Fgp=" + userFingerprint + "; SameSite=Strict; HttpOnly; Secure";
response.addHeader("Set-Cookie", fingerprintCookie);

//Create the token with a validity of 15 minutes and client context (fingerprint) information
Calendar c = Calendar.getInstance();
Date now = c.getTime();
c.add(Calendar.MINUTE, 15);
Date expirationDate = c.getTime();
Map<String, Object> headerClaims = new HashMap<>();
headerClaims.put("typ", "JWT");
String token = JWT.create().withSubject(login)
		.withExpiresAt(expirationDate)
		.withIssuer(this.issuerID)
		.withIssuedAt(now)
		.withNotBefore(now)
		.withClaim("userFingerprint", userFingerprint)
		.withHeader(headerClaims)
		.sign(Algorithm.HMAC256(this.keyHMAC));

// HMAC key - Block serialization and storage as String in JVM memory
private transient byte[] keyHMAC = ...;

...

//Retrieve the user fingerprint from the dedicated cookie
String userFingerprint = null;
if (request.getCookies() != null && request.getCookies().length > 0) {
	List<Cookie> cookies = Arrays.stream(request.getCookies()).collect(Collectors.toList());
	Optional<Cookie> cookie = cookies.stream().filter(c -> "__Secure-Fgp".equals(c.getName())).findFirst();
	if (cookie.isPresent()) {
		userFingerprint = cookie.get().getValue();
	}
}

//Create a verification context for the token
JWTVerifier verifier = JWT.require(Algorithm.HMAC256(keyHMAC))
                               .withIssuer(issuerID)
                               .withClaim("userFingerprint", userFingerprint)
                               .build();

//Verify the token, if the verification fail then a exception is throwed
DecodedJWT decodedToken = verifier.verify(token);

create table if not exists revoked_token(jwt_token_digest varchar(255) primary key, revokation_date timestamp default now());

/**
 * Handle the revokation of the token (logout).
 * Use a DB in order to allow multiple instances to check for revoked token and allow cleanup at centralized DB level.
 */
public class TokenRevoker {

  /** DB Connection */
  @Resource("jdbc/storeDS")
  private DataSource storeDS;

  /**
   * Verify if a digest encoded in HEX of the ciphered token is present in the revokation table
   *
   * @param jwtInHex Token encoded in HEX
   * @return Presence flag
   * @throws Exception If any issue occur during communication with DB
   */
  public boolean isTokenRevoked(String jwtInHex) throws Exception {
      boolean tokenIsPresent = false;
      if (jwtInHex != null && !jwtInHex.trim().isEmpty()) {
          //Decode the ciphered token
          byte[] cipheredToken = DatatypeConverter.parseHexBinary(jwtInHex);

          //Compute a SHA256 of the ciphered token
          MessageDigest digest = MessageDigest.getInstance("SHA-256");
          byte[] cipheredTokenDigest = digest.digest(cipheredToken);
          String jwtTokenDigestInHex = DatatypeConverter.printHexBinary(cipheredTokenDigest);

          //Search token digest in HEX in DB
          try (Connection con = this.storeDS.getConnection()) {
              String query = "select jwt_token_digest from revoked_token where jwt_token_digest = ?";
              try (PreparedStatement pStatement = con.prepareStatement(query)) {
                  pStatement.setString(1, jwtTokenDigestInHex);
                  try (ResultSet rSet = pStatement.executeQuery()) {
                      tokenIsPresent = rSet.next();
                  }
              }
          }
      }

      return tokenIsPresent;
  }


  /**
   * Add a digest encoded in HEX of the ciphered token to the revokation token table
   *
   * @param jwtInHex Token encoded in HEX
   * @throws Exception If any issue occur during communication with DB
   */
  public void revokeToken(String jwtInHex) throws Exception {
      if (jwtInHex != null && !jwtInHex.trim().isEmpty()) {
          //Decode the ciphered token
          byte[] cipheredToken = DatatypeConverter.parseHexBinary(jwtInHex);

          //Compute a SHA256 of the ciphered token
          MessageDigest digest = MessageDigest.getInstance("SHA-256");
          byte[] cipheredTokenDigest = digest.digest(cipheredToken);
          String jwtTokenDigestInHex = DatatypeConverter.printHexBinary(cipheredTokenDigest);

          //Check if the token digest in HEX is already in the DB and add it if it is absent
          if (!this.isTokenRevoked(jwtInHex)) {
              try (Connection con = this.storeDS.getConnection()) {
                  String query = "insert into revoked_token(jwt_token_digest) values(?)";
                  int insertedRecordCount;
                  try (PreparedStatement pStatement = con.prepareStatement(query)) {
                      pStatement.setString(1, jwtTokenDigestInHex);
                      insertedRecordCount = pStatement.executeUpdate();
                  }
                  if (insertedRecordCount != 1) {
                      throw new IllegalStateException("Number of inserted record is invalid, 1 expected but is " + insertedRecordCount);
                  }
              }
          }

      }
  }

create table if not exists nonce(jwt_token_digest varchar(255) primary key, gcm_nonce varchar(255) not null unique, gcm_aad varchar(255) not null unique);
create index if not exists idx_nonce on nonce(gcm_nonce);

/**
 * Handle ciphering and deciphering of the token using AES-GCM.
 * Use a DB in order to link a GCM NONCE to a ciphered message and ensure that a NONCE is never reused
 * and also allow use of several application nodes in load balancing.
 */
public class TokenCipher {

    /** AES-GCM parameters */
    private static final int GCM_NONCE_LENGTH = 12; // in bytes

    /** AES-GCM parameters */
    private static final int GCM_TAG_LENGTH = 16; // in bytes

    /**Secure random generator */
    private final SecureRandom secRandom = new SecureRandom();

    /** DB Connection */
    @Resource("jdbc/storeDS")
    private DataSource storeDS;

    /**
     * Cipher a JWT
     * @param jwt Token to cipher
     * @param key Ciphering key
     * @return The ciphered version of the token encoded in HEX
     * @throws Exception If any issue occur during token ciphering operation
     */
    public String cipherToken(String jwt, byte[] key) throws Exception {
        //Verify parameters
        if(jwt == null || jwt.isEmpty() || key == null || key.length == 0){
            throw new IllegalArgumentException("Both parameters must be specified !");
        }

        //Generate a NONCE
        //NOTE: As in the DB, the column to store the NONCE is flagged UNIQUE then the insert will fail
        //if the NONCE already exists, normally as we use the Java Secure Random implementation
        //it will never happen.
        final byte[] nonce = new byte[GCM_NONCE_LENGTH];
        secRandom.nextBytes(nonce);

        //Prepare ciphering key from bytes provided
        SecretKey aesKey = new SecretKeySpec(key, 0, key.length, "AES");

        //Setup Cipher
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "SunJCE");
        GCMParameterSpec spec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, nonce);
        cipher.init(Cipher.ENCRYPT_MODE, aesKey, spec);

        //Add "Additional Authentication Data" (AAD) in order to operate in AEAD mode - Generate it
        byte[] aad = new byte[32];
        secRandom.nextBytes(aad);
        cipher.updateAAD(aad);

        //Cipher the token
        byte[] cipheredToken = cipher.doFinal(jwt.getBytes("utf-8"));

        //Compute a SHA256 of the ciphered token
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] cipheredTokenDigest = digest.digest(cipheredToken);

        //Store GCM NONCE and GCM AAD
        this.storeNonceAndAAD(DatatypeConverter.printHexBinary(nonce), DatatypeConverter.printHexBinary(aad),
        DatatypeConverter.printHexBinary(cipheredTokenDigest));

        return DatatypeConverter.printHexBinary(cipheredToken);
    }

    /**
     * Decipher a JWT
     * @param jwtInHex Token to decipher encoded in HEX
     * @param key Ciphering key
     * @return The token in clear text
     * @throws Exception If any issue occur during token deciphering operation
     */
    public String decipherToken(String jwtInHex, byte[] key) throws Exception{
        //Verify parameters
        if(jwtInHex == null || jwtInHex.isEmpty() || key == null || key.length == 0){
            throw new IllegalArgumentException("Both parameters must be specified !");
        }

        //Decode the ciphered token
        byte[] cipheredToken = DatatypeConverter.parseHexBinary(jwtInHex);

        //Compute a SHA256 of the ciphered token
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] cipheredTokenDigest = digest.digest(cipheredToken);

        //Read the GCM NONCE and GCM AAD associated from the DB
        Map<String,String> gcmInfos = this.readNonceAndAAD(DatatypeConverter.printHexBinary(cipheredTokenDigest));
        if(gcmInfos == null){
            throw new Exception("Cannot found a NONCE and AAD associated to the token provided !");
        }
        byte[] nonce = DatatypeConverter.parseHexBinary(gcmInfos.get("NONCE"));
        byte[] aad = DatatypeConverter.parseHexBinary(gcmInfos.get("AAD"));

        //Prepare ciphering key from bytes provided
        SecretKey aesKey = new SecretKeySpec(key, 0, key.length, "AES");

        //Setup Cipher
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "SunJCE");
        GCMParameterSpec spec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, nonce);
        cipher.init(Cipher.DECRYPT_MODE, aesKey, spec);

        //Add "Additional Authentication Data" (AAD) in order to operate in AEAD mode
        cipher.updateAAD(aad);

        //Decipher the token
        byte[] decipheredToken = cipher.doFinal(cipheredToken);

        return new String(decipheredToken);
    }


    /**
     * Store GCM NONCE and GCM AAD in the DB
     * @param nonceInHex Nonce encoded in HEX
     * @param aadInHex AAD encoded in HEX
     * @param jwtTokenDigestInHex SHA256 of the JWT ciphered token encoded in HEX
     * @throws Exception If any issue occur during communication with DB
     */
    private void storeNonceAndAAD(String nonceInHex, String aadInHex, String jwtTokenDigestInHex) throws Exception {
        try (Connection con = this.storeDS.getConnection()) {
            String query = "insert into nonce(jwt_token_digest, gcm_nonce, gcm_aad) values(?, ?, ?)";
            int insertedRecordCount;
            try (PreparedStatement pStatement = con.prepareStatement(query)) {
                pStatement.setString(1, jwtTokenDigestInHex);
                pStatement.setString(2, nonceInHex);
                pStatement.setString(3, aadInHex);
                insertedRecordCount = pStatement.executeUpdate();
            }
            if (insertedRecordCount != 1) {
                throw new IllegalStateException("Number of inserted record is invalid, 1 expected but is " + insertedRecordCount);
            }
        }
    }

    /**
     * Read GCM NONCE and GCM AAD from the DB
     * @param jwtTokenDigestInHex SHA256 of the JWT ciphered token encoded in HEX for which we must read the NONCE and AAD
     * @return A dict containing the NONCE and AAD if they exists for the specified token
     * @throws Exception If any issue occur during communication with DB
     */
    private  Map<String,String> readNonceAndAAD(String jwtTokenDigestInHex) throws Exception{
        Map<String,String> gcmInfos = null;
        try (Connection con = this.storeDS.getConnection()) {
            String query = "select gcm_nonce, gcm_aad from nonce where jwt_token_digest = ?";
            try (PreparedStatement pStatement = con.prepareStatement(query)) {
                pStatement.setString(1, jwtTokenDigestInHex);
                try (ResultSet rSet = pStatement.executeQuery()) {
                    while (rSet.next()) {
                        gcmInfos = new HashMap<>(2);
                        gcmInfos.put("NONCE", rSet.getString(1));
                        gcmInfos.put("AAD", rSet.getString(2));
                    }
                }
            }
        }

        return gcmInfos;
    }

}

//Load keys from configuration text files in order to avoid to store keys as String in JVM memory
private transient byte[] keyHMAC = Files.readAllBytes(Paths.get("key-hmac.txt"));
private transient byte[] keyCiphering = Files.readAllBytes(Paths.get("key-ciphering.txt"));

//Load issuer ID from configuration text file
private transient String issuerID = Files.readAllLines(Paths.get("issuer-id.txt")).get(0);

//Init token ciphering handler
TokenCipher tokenCipher = new TokenCipher();

  //Generate a random string that will constitute the fingerprint for this user
  byte[] randomFgp = new byte[50];
  this.secureRandom.nextBytes(randomFgp);
  String userFingerprint = DatatypeConverter.printHexBinary(randomFgp);

  //Add the fingerprint in a hardened cookie - Add cookie manually because SameSite attribute is not supported by javax.servlet.http.Cookie class
  String fingerprintCookie = "__Secure-Fgp=" + userFingerprint + "; SameSite=Strict; HttpOnly; Secure";
  response.addHeader("Set-Cookie", fingerprintCookie);

  //Create the token with a validity of 15 minutes and client context (fingerprint) information
  Calendar c = Calendar.getInstance();
  Date now = c.getTime();
  c.add(Calendar.MINUTE, 15);
  Date expirationDate = c.getTime();
  Map<String, Object> headerClaims = new HashMap<>();
  headerClaims.put("typ", "JWT");
  String token = JWT.create().withSubject(login)
  		.withExpiresAt(expirationDate)
  		.withIssuer(this.issuerID)
  		.withIssuedAt(now)
  		.withNotBefore(now)
  		.withClaim("userFingerprint", userFingerprint)
  		.withHeader(headerClaims)
  		.sign(Algorithm.HMAC256(this.keyHMAC));
//Cipher the token
String cipheredToken = tokenCipher.cipherToken(token, keyCiphering);

//Decipher the token
String token = tokenCipher.decipherToken(cipheredToken, keyCiphering);

//Retrieve the user fingerprint from the dedicated cookie
String userFingerprint = null;
if (request.getCookies() != null && request.getCookies().length > 0) {
	List<Cookie> cookies = Arrays.stream(request.getCookies()).collect(Collectors.toList());
	Optional<Cookie> cookie = cookies.stream().filter(c -> "__Secure-Fgp".equals(c.getName())).findFirst();
	if (cookie.isPresent()) {
		userFingerprint = cookie.get().getValue();
	}
}

//Decipher the token
String token = this.tokenCipher.decipherToken(cipheredToken, this.keyCiphering);
//Create a verification context for the token
JWTVerifier verifier = JWT.require(Algorithm.HMAC256(this.keyHMAC))
		.withIssuer(this.issuerID)
		.withClaim("userFingerprint", userFingerprint)
		.build();

//Verify the token, if the verification fail then a exception is throwed
DecodedJWT decodedToken = verifier.verify(token);

  /* Handle request for JWT token and local storage*/
  function getToken(){
      var login = $("#login").val();
      var postData = "login=" + encodeURIComponent(login) + "&password=test";

      $.post("/services/authenticate", postData,function (data){
          if(data.status == "Authentication successful !"){
              ...
              sessionStorage.setItem("token", data.token);
          }else{
              ...
              sessionStorage.removeItem("token");
          }
      })
      .fail(function(jqXHR, textStatus, error){
              ...
          sessionStorage.removeItem("token");
      });
  }

  /* Handle request for JWT token validation */
  function validateToken(){
      var token = sessionStorage.getItem("token");

      if(token == undefined || token == ""){
          $("#infoZone").removeClass();
          $("#infoZone").addClass("alert alert-warning");
          $("#infoZone").text("Obtain a JWT token first :)");
          return;
      }

      $.ajax({
          url: "/services/validate",
          type: "POST",
          beforeSend: function(xhr) {
              xhr.setRequestHeader("Authorization", "bearer " + token);
          },
          success: function(data) {
            ...
          },
          error: function(jqXHR, textStatus, error) {
            ...
          },
      });
  }

  /**
  * Test if a secret match the secret used to sign the token
  *
  * @param token Source JWT token (test base)
  * @param secret Secret to test
  * @return The token decoded if the secret matche otherwise return null
  */
private DecodedJWT checkSecret(String token, String secret) {
      DecodedJWT t = null;
      try {
          Algorithm algorithm = Algorithm.HMAC256(secret);
          JWTVerifier verifier = JWT.require(algorithm).build();
          t = verifier.verify(token);
      } catch (JWTVerificationException | UnsupportedEncodingException e) {
          //ignore...
      }
      return t;
  }

final String tokenTestBase = ...;
final String[] secret = new String[1];
final DecodedJWT[] decodedToken = new DecodedJWT[1];
List<String> secrets = Files.readAllLines(Paths.get("secrets-dictionary.txt"));
secrets.parallelStream().forEach(s -> {
	DecodedJWT tentative = checkSecret(tokenTestBase, s);
	if (tentative != null) {
		secret[0] = s;
		decodedToken[0] = tentative;
	}
});