JSON 웹 토큰(JWT) 보안

// JVM 메모리 상에 문자열로 키 정보를 담는 컨테이너를 생성
// transient 키워드를 통해 직렬화를 차단
private transient byte[] keyHMAC = ...;

...

// 요청한 토큰에 대해 유효성 검증 컨텍스트를 생성
// 명시적으로 HMAC-256 해싱 알고리즘 사용을 선언한다.
JWTVerifier verifier = JWT.require(Algorithm.HMAC256(keyHMAC)).build();

// 생성한 컨텐스트를 바탕으로 토큰을 검증하고 만약 검증이 실패한다면 예외가 발생한다.
DecodedJWT decodedToken = verifier.verify(token)

// 위와 동
private transient byte[] keyHMAC = ...;
// 임의의 데이터 생성
private SecureRandom secureRandom = new SecureRandom();

...

// 임의의 문자열을 생성 이 사용자를 위한 핑거프린트로 사용될 예정입니다
byte[] randomFgp = new byte[50];
secureRandom.nextBytes(randomFgp);
String userFingerprint = DatatypeConverter.printHexBinary(randomFgp);

// 보안 강화된 쿠키에 핑거프린트를 추가하고 쿠키를 수동으로 추가함은 SameSite 속성은 javax.servlet.http.Cookie 클래스에 의해 지원되지 않기 때문입니다. 
String fingerprintCookie = "__Secure-Fgp=" + userFingerprint 
                           + "; SameSite=Strict; HttpOnly; Secure";
response.addHeader("Set-Cookie", fingerprintCookie);

// XSS 를 예방하기 위해  SHA256 해시 값을 계산하여 핑거프린트 해시를 토큰의 데이터로 저장하고 이를 통해 핑거 프린트값을 읽어오거나 예상되는 쿠키를 설정할 수 있다.
MessageDigest digest = MessageDigest.getInstance("SHA-256"); // 해시 계산
byte[] userFingerprintDigest = digest.digest(userFingerprint.getBytes("utf-8")); // 사용자 핑거프린트 불러오기
String userFingerprintHash = DatatypeConverter.printHexBinary(userFingerprintDigest); // 헥사 바이너리로 

// 15분 유효성을 가지는 토큰을 생성하고 클라이언트 컨텍스트 정보를 생성한다.
Calendar c = Calendar.getInstance();
Date now = c.getTime();
c.add(Calendar.MINUTE, 15); // 현재의 시간에서 15분을 추가
Date expirationDate = c.getTime(); //15분이 추가된 날짜를 Date 타입으로 반환
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", userFingerprintHash) // 
   .withHeader(headerClaims)
   .sign(Algorithm.HMAC256(this.keyHMAC)); // HMAC 으로 서명

private transient byte[] keyHMAC = ...;

...

//쿠키에서 사용자 핑거프린트 정보를 가져온다. 
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();
 }
}

// 수신한 핑거프린트에서 SHA256 해시를 계산하고 토큰에 저장된 핑거프린트와 비교한다.
MessageDigest digest = MessageDigest.getInstance("SHA-256"); // SHA-256 다이제스트를 가져옴
byte[] userFingerprintDigest = digest.digest(userFingerprint.getBytes("utf-8")); // utf-8 바이트 스트림으로 변환
String userFingerprintHash = DatatypeConverter.printHexBinary(userFingerprintDigest); // 이를 헥사 바이너리 문자열로 출력

// 토큰에 대한 유효성 검증 컨텍스트를 생성
JWTVerifier verifier = JWT.require(Algorithm.HMAC256(keyHMAC))
                              .withIssuer(issuerID)
                              .withClaim("userFingerprint", userFingerprintHash)
                              .build();

// 토큰을 유효성 검증하고 유효성 검증 실패 시 예외가 던져진다.
DecodedJWT decodedToken = verifier.verify(token);

// 로그아웃 시 토큰 취소를 처리
// 다중 인스턴스로 하여금 취소 토큰을 검사할 수 있도록 DB 를 사용
// DB 수준에서 클린업을 허용
public class TokenRevoker {

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

 /**
  * 암호화된 토큰의 헥사 값으로 인코딩된 다이제스트가 존재하는지 유효성을 검증을 취소 테이블
  * (revokation table)에서 진행
  *
  * @param jwtInHex 헥사로 인코딩된 토큰 문자열
  * @return 플래그 반환
  * @throws Exception DB 통신 도중 문제를 예외로 반환
  */
 public boolean isTokenRevoked(String jwtInHex) throws Exception {
     boolean tokenIsPresent = false; // 토큰이 존재하지 않음을 우선 가정
     if (jwtInHex != null && !jwtInHex.trim().isEmpty()) {
         // 암호화된 토큰을 디코딩
         // 0x48454C4C4F2057... 와 같은 형태
         // 바이트 배열로 변환됨
         byte[] cipheredToken = DatatypeConverter.parseHexBinary(jwtInHex);

         // 암화화 토큰의 SHA256 해시 값을 계산 
         // 해시값을 계산하기 위해 SHA-256 의 다이제스트 인스턴스를 반환
         MessageDigest digest = MessageDigest.getInstance("SHA-256"); 
         // 암호화 토큰의 다이제트를 반환
         byte[] cipheredTokenDigest = digest.digest(cipheredToken);
         // Hex 바이너리 형태로 변환
         String jwtTokenDigestInHex = DatatypeConverter.printHexBinary(cipheredTokenDigest);

         // Hex 값이 DB 에 있는지 쿼리
         try (Connection con = this.storeDS.getConnection()) {
             String query = "select jwt_token_digest from revoked_token where jwt_token_digest = ?";
             // PreparedStatement 를 사용하여 파라미터 바인딩을 걸어줌
             try (PreparedStatement pStatement = con.prepareStatement(query)) {
                 pStatement.setString(1, jwtTokenDigestInHex);
                 try (ResultSet rSet = pStatement.executeQuery()) {
                     tokenIsPresent = rSet.next();
                 }
             }
         }
     }
     return tokenIsPresent;
 }


 /**
  * Hex 로 인코딩된 암호화된 토큰의 다이제스트를 취소 테이블에 추가 (INSERT 작업)
  *
  * @param jwtInHex 헥사로 인코딩된 토큰
  * @throws Exception DB 통신 상의 오류 발생 시 리턴
  */
 public void revokeToken(String jwtInHex) throws Exception {
     if (jwtInHex != null && !jwtInHex.trim().isEmpty()) {
         // 암호돤 Hex 토큰을 바이트로 변환
         byte[] cipheredToken = DatatypeConverter.parseHexBinary(jwtInHex);

         // 암호화된 토큰의 SHA256 해시 값을 계산
         MessageDigest digest = MessageDigest.getInstance("SHA-256");
         byte[] cipheredTokenDigest = digest.digest(cipheredToken);
         String jwtTokenDigestInHex = DatatypeConverter.printHexBinary(cipheredTokenDigest);

         // DB 에서 해당 Hex 값이 존재하는지 체크
         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);
                 }
             }
         }

     }
 }

import com.google.crypto.tink.DeterministicAead;
import com.google.crypto.tink.KeysetHandle;
import com.google.crypto.tink.daead.DeterministicAeadKeyTemplates;

// 1. keyset 을 생성합니다. (대칭키로 생성)
KeysetHandle keysetHandle = KeysetHandle.generateNew(
    DeterministicAeadKeyTemplates.AES256_SIV);

// 2. Primitives 를 생성합니다.
DeterministicAead daead =
    keysetHandle.getPrimitive(DeterministicAead.class);

// 3-1. Primitive 를 이용해 평문(Plain text)을 암호화 합니다.
byte[] ciphertext = daead.encryptDeterministically(plaintext, aad);

// 3-2. 암호문을 복호화합니다.
byte[] decrypted = daead.decryptDeterministically(ciphertext, aad);

/**
 * AES-GCM을 이용하여 토큰의 암호화와 복호화를 처리합니다.
 *
 * @see "https://github.com/google/tink/blob/master/docs/JAVA-HOWTO.md"
 */
public class TokenCipher {

    /**
     * 생성자 - AEAD 설정을 등록합니다.
     *
     * @throws Exception AEAD 설정 등록 과정에 문제가 발생할 경우 예외 전달
     */
    public TokenCipher() throws Exception {
        AeadConfig.register();
    }

    /**
     * JWT를 암호화
     *
     * @param jwt          암호화할 토큰
     * @param keysetHandle keyset 핸들러에 대한 레퍼런스(포인터)
     * @return HEX로 인코딩된 토큰의 암호 문자열
     * @throws Exception 토큰 암호화 작업 동안 이슈 발생 시 에외 전달
     */
    public String cipherToken(String jwt, KeysetHandle keysetHandle) throws Exception {
        // 파라미터 유효성 검증
        if (jwt == null || jwt.isEmpty() || keysetHandle == null) {
            throw new IllegalArgumentException("Both parameters must be specified !");
        }

        // AEAD 팩토리를 통해 Primitive 를 반환
        Aead aead = AeadFactory.getPrimitive(keysetHandle);

        //Cipher the token
        byte[] cipheredToken = aead.encrypt(jwt.getBytes(), null);

        return DatatypeConverter.printHexBinary(cipheredToken);
    }

    /**
     * JWT 를 복호화 합니다.
     *
     * @param jwtInHex     헥스로 인코딩된 암호화 토큰 데이터
     * @param keysetHandle Keyset 핸들에 대한 레퍼런스(포인터)
     * @return  평문으로 변환된 토큰
     * @throws Exception 복호화 과정에서 에러 발생 시 에외를 반환(throw)
     */
    public String decipherToken(String jwtInHex, KeysetHandle keysetHandle) throws Exception {
        // 파라미터 검증
        if (jwtInHex == null || jwtInHex.isEmpty() || keysetHandle == null) {
            throw new IllegalArgumentException("Both parameters must be specified !");
        }

        // 암호화 토큰을 디코딩 (=> byte array)
        byte[] cipheredToken = DatatypeConverter.parseHexBinary(jwtInHex);

        // Primitive 를 반환
        Aead aead = AeadFactory.getPrimitive(keysetHandle);

        // 토큰을 복호화
        byte[] decipheredToken = aead.decrypt(cipheredToken, null);

        // 복호화된 토큰을 반환
        return new String(decipheredToken);
    }
}

// JVM 메모리 내에서 문자열을 키로써 저장하는 것을 피하기 위해 text/json 파일들을 이용한 설정 파일로부터 키를 로드한다.
private transient byte[] keyHMAC = Files.readAllBytes(Paths.get("src", "main", "conf", "key-hmac.txt"));
private transient KeysetHandle keyCiphering = CleartextKeysetHandle.read(JsonKeysetReader.withFile(
Paths.get("src", "main", "conf", "key-ciphering.json").toFile()));

...

// 토큰 암호화 핸들러
TokenCipher tokenCipher = new TokenCipher();

// JWT API 를 이용하여 JWT 토큰을 생성
// 토큰을 암호화 (JSON 문자열 표현)
String cipheredToken = tokenCipher.cipherToken(token, this.keyCiphering);
// HEX 로 인코딩한 암호화 문자열을 클라이언트에게 HTTP 응답을 통해 전송한다.

// HEX 로 인코딩된 암호화된 토큰을 가져온다.
// 토큰을 복호화한다.
String token = tokenCipher.decipherToken(cipheredToken, this.keyCiphering);
// 접근권한 검증
// JWT API 를 사용하여 토큰 유효성 검증

 /**
 * 
 * 토큰을 서명하는데 사용된 secret 과 secret 을 매칭하는 것을 테스트
 *
 * @param token JWT 토큰
 * @param secret 테스트할 secret
 * @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) {
         // 에러 발생 시 무시하고 null 을 반환
     }
     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;
 }
});