[SpringBoot/Kotlin] E2EE: 간단한 메신저 서버 구현하기

암호화의 두 축: 대칭키 vs 비대칭키

암호화 시스템은 크게 두 가지 방식으로 나뉜다.

• 대칭키 암호화: 하나의 비밀키로 암호화와 복호화를 모두 수행. 대표적으로 AES. 빠르고 계산량이 적어 대용량 데이터 암호화에 적합.
• 비대칭키 암호화: 공개키와 비공개키라는 두 개의 키를 사용. 대표적으로 RSA가 있으며, 한 키로 암호화한 데이터는 반드시 다른 키로만 복호화 가능. 키 교환, 인증, 서명 등에 사용

⚡ 성능 측면에서의 차이

항목 대칭키 (AES) 비대칭키 (RSA)

속도	매우 빠름	상대적으로 느림
연산량	적음	많음 (큰 수 연산)
자원 사용	낮음	높음
사용 용도	메시지/파일 암호화	키 전달/서명/인증

이러한 성능 차이로 인해 실제 보안 시스템에서는 “하이브리드 암호화”라는 방식이 등장

 하이브리드 암호화란?

빠르고 효율적인 AES로 메시지를 암호화하고, 이 AES 키를 수신자의 공개키(RSA)로 암호화하는 방식

전송 흐름:

1. 클라이언트는 랜덤 AES 키를 생성
2. 메시지를 AES 키로 암호화 (IV 포함)
3. AES 키를 상대방의 공개키로 RSA 암호화
4. 암호문 + 암호화된 AES 키를 서버에 저장 또는 전송

수신자는:

1. 자신의 비공개키로 AES 키를 복호화
2. 해당 AES 키로 메시지를 복호화

이 구조를 통해 속도와 보안을 동시에 확보

 IV란? (Initialization Vector): AES 블록 암호화에서 첫 블록을 랜덤화하기 위해 사용되는 16바이트 값. 암호문에 포함되며 공개되어도 보안에 문제가 없음.

 

 실제 구현 시 암호문 구조

{
  "encryptedMessage": "<IV + AES 암호문>",
  "encryptedAesKey": "<RSA로 암호화된 AES 키>"
}

 

왜 클라이언트에서 암복호화를 할까?

• 서버에서 암복호화를 하면 서버가 평문을 보게 되므로 진정한 보안이 어려움
• 클라이언트에서 키를 생성하고, 암호화를 수행하며 서버는 단순한 전달자 역할만 수행하면 진정한 종단간 암호화 (E2EE) 구조가 완성.

클라이언트 중심 E2EE 흐름 정리

1. 클라이언트가 공개키를 서버에 등록
2. 메시지를 보내기 전 상대방의 공개키를 서버에서 조회
3. AES 키 생성 → 메시지를 암호화 → AES 키는 상대의 공개키로 암호화
4. 수신자는 자신의 비공개키로 AES 키 복호화 → 메시지 복호화

✅ 결론

• 대칭키는 빠르지만 키 전달이 문제
• 비대칭키는 느리지만 키 전달에 강력함
• 그래서 하이브리드 암호화를 통해 둘의 장점을 조합
• 클라이언트가 암복호화를 주도하면 진정한 종단간 보안(E2EE)이 가능함

---

코드로 이해하기

💡클라이언트의 역할이 너무나도 명확한 주제라 클라이언트를 함께 구현하고 싶었지만, 빠른 이해와 학습을 위해 SpringBoot로 E2EE 모든 Flow를 구현하였다.

 

코드를 구현하면서 알게된 새로운 사실이 있다.

일반 클라-서버 관계라면 서버는 단순히 클라에서 전송한 publicKey만 들고 있으며, keyPair생성, 메세지 암/복호화의 롤은 모두 클라가 갖는다. 또한, 비대칭키 암/복호화는 많은 computing 자원이 필요하기 때문에, 비대칭키로 암호화된 대칭키를 매번 변경하지 않는다.
즉, 클라에서 비대칭키로 복호화한 메세징 대칭키를 Caching 해놓고, 빠르게 메세지를 복호화 할 수 있도록 한다.

Service

@Service
class EncryptionService {
    /**
     *  AES: 대칭키 블록 암호화 알고리즘
     *  iv: 동일한 암호화 결과가 나오지 않도록 붙여주는 랜덤 값 (키랑 무관)
     */

    //  AES 대칭키 생성: 256 비트 길이 (메세지 본문 암호화 하는데 사용)
    fun generateAESKey(): SecretKey {
        val keyGen = KeyGenerator.getInstance("AES")
        keyGen.init(256)
        return keyGen.generateKey()
    }

    // 평문 메세지 암호화: 대칭키(secretKey) 사용
    fun encryptAESWithIVPrefixed(plainText: String, secretKey: SecretKey): String {
        val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")     // 암호 처리기 생성
        val ivBytes = ByteArray(16)     // 16 바이트 짜리 배열 생성
        SecureRandom().nextBytes(ivBytes)   // ivBytes 배열에 무작위 값 채움
        val ivSpec = IvParameterSpec(ivBytes)

        cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivSpec)     // 암호 처리기 초기화
        val encryptedBytes = cipher.doFinal(plainText.toByteArray(Charsets.UTF_8))

        val combined = ivBytes + encryptedBytes     // 메세지 앞에 16 바이트를 붙여서, 메세지 생성
        return Base64.getEncoder().encodeToString(combined)
    }

    // 메제지 복호화: 대칭키(SecretKey) 사용
    fun decryptAESWithIVPrefixed(encryptedCombined: String, secretKey: SecretKey): String {
        val combinedBytes = Base64.getDecoder().decode(encryptedCombined)
        val iv = combinedBytes.copyOfRange(0, 16)   // 암호화에 사용한 iv 추출
        val encrypted = combinedBytes.copyOfRange(16, combinedBytes.size)   // 암호화된 실제 메세지 추출

        val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")     // 암호 처리기 생성
        val ivSpec = IvParameterSpec(iv)
        cipher.init(Cipher.DECRYPT_MODE, secretKey, ivSpec) // 암호 처리기 초기화 - Decrypt 모드
        val decryptedBytes = cipher.doFinal(encrypted)

        return String(decryptedBytes, Charsets.UTF_8)
    }

    // 대칭키 암호화: 수신자의 공개키로 암호화 하여 전달할 수 있도록 함
    fun encryptAESKeyWithRSA(secretKey: SecretKey, publicKey: PublicKey): String {
        val cipher = Cipher.getInstance("RSA")
        cipher.init(Cipher.ENCRYPT_MODE, publicKey)
        val encryptedKey = cipher.doFinal(secretKey.encoded)
        return Base64.getEncoder().encodeToString(encryptedKey)
    }

    // 대칭키 복호화: 비공개키로 복호화
    fun decryptAESKeyWithRSA(encryptedAesKey: String, privateKey: PrivateKey): SecretKey {
        val cipher = Cipher.getInstance("RSA")
        cipher.init(Cipher.DECRYPT_MODE, privateKey)
        val decodedKey = cipher.doFinal(Base64.getDecoder().decode(encryptedAesKey))
        return SecretKeySpec(decodedKey, "AES")
    }
}

 

1. `generateAESKey`: 메세지를 암호화하기 위한 랜덤 키를 생성
2. `encryptAESKeyWithRSA` / `decryptAESKeyWithRSA`: 대칭키 암/복호화 코드
   1. 암호화: 수신자의 공개키로 대칭키를 암호화한다.
   2. 복호화: 본인의 비공개키로 대칭키를 복호화한다. 
3. `encryptAESWithIVPrefixed` / `decryptAESWithIVPrefixed`: 메세지 암/복호화 코드
   1. 암호화: 대칭키를 사용하여 메세지를 암호화한다. 이때 메세지 앞에 iv를 붙여서, 같은 내용에 대해 같은 결과가 나오지 않도록 한다.
   2. 복호화: 대칭키를 사용하여 메세지를 복호화한다. 마찬가지로 iv bytes를 제거하고, 메세지를 복호화 한다.

Controller

@RequestMapping("/api")
class MessageController(
    private val encryptionService: EncryptionService,
) {
    private val publicKeyMap: MutableMap<String, PublicKey> = mutableMapOf()
    private val privateKeyMap: MutableMap<String, PrivateKey> = mutableMapOf()
    private val messageBox: MutableMap<String, MutableList<EncryptedPayload>> = mutableMapOf()

    @PostMapping("/register")
    fun registerUser(@RequestBody request: PublicKeyRegisterRequest): String {
        // userId에 대한 KeyPair 생성
        val keyPairGen = KeyPairGenerator.getInstance("RSA")
        keyPairGen.initialize(2048)
        val keyPair = keyPairGen.generateKeyPair()

        publicKeyMap[request.userId] = keyPair.public
        privateKeyMap[request.userId] = keyPair.private

        return "User ${request.userId} registered with key pair"
    }

    @PostMapping("/send")
    fun sendMessage(@RequestBody request: MessageRequest): String {
        val receiverPublicKey = publicKeyMap[request.receiverId] ?: error("Receiver not found")
        val aesKey = encryptionService.generateAESKey()

        // 메세지 암호화(대칭키)
        val encryptedMessage = encryptionService.encryptAESWithIVPrefixed(request.message, aesKey)

        // 대칭키 암호화(비대칭키)
        val encryptedAesKey = encryptionService.encryptAESKeyWithRSA(aesKey, receiverPublicKey)

        val payload = EncryptedPayload(request.senderId, encryptedMessage, encryptedAesKey)
        messageBox.computeIfAbsent(request.receiverId) { mutableListOf() }.add(payload)

        return "Message sent securely to ${request.receiverId}"
    }

    @GetMapping("/messages/{userId}")
    fun receiveMessages(@PathVariable userId: String): List<MessageResponse> {
        val privateKey = privateKeyMap[userId] ?: error("Private key not found for $userId")
        val messages = messageBox[userId] ?: return emptyList()

        return messages.map { payload ->
            // 대칭키 복호화(비대칭키)
            val aesKey = encryptionService.decryptAESKeyWithRSA(payload.encryptedAesKey, privateKey)

            // 메세지 복호화(대칭키)
            val plainText = encryptionService.decryptAESWithIVPrefixed(payload.encryptedMessage, aesKey)
            MessageResponse("${payload.senderId}: $plainText")
        }
    }
}

 

1. sendMessage`: 메세지를 보내기 위한 API
   
   1. 대칭키를 사용해서 메세지를 암호화한다.
   2. 사용된 대칭키를 같이 보내야하기 때문에 이 대칭키를 수신자의 공개키로 암호화 한다.
   3. 해당 메세지를 메모리에 임시 저장해둔다.
2. `receiveMessages`: 수신된 메세지 확인을 위한 API
   1. 나의 비공개키를 사용하여 대칭키를 우선 복호화 한다.
   2. 복호화된 키로 메세지를 복호화한다.

---

 

👉 전체 코드는 아래에서! 👈

GitHub - jeongum/e2ee