Cryptography on kenji.blog

페르마의 소정리를 활용한 암호화의 기초와 구현

Fri, 11 Sep 2026 22:00:00 +0900

1. 시작하며: 현대 암호를 지탱하는 수학의 신비

현대 디지털 사회, 특히 인터넷을 통한 통신에서 ‘암호화’는 필수 불가결한 기반 기술이 되었습니다. 우리가 웹 브라우저에서 HTTPS를 통해 안전하게 웹사이트를 탐색하고, 온라인 뱅킹으로 금융 거래를 하며, 메시징 앱으로 사적인 대화를 나눌 수 있는 것은 고도의 수학적 이론이 뒷받침된 암호 프로토콜이 배후에서 작동하고 있기 때문입니다. 그중에서도 특히 중요한 역할을 담당하고 있는 것이 ‘공개키 암호 방식’이며, 그 대표적인 예가 RSA 암호입니다.

RSA 암호를 비롯한 많은 암호 알고리즘의 안전성과 정당성은 17세기 프랑스의 수학자 피에르 드 페르마(Pierre de Fermat)가 발견한 매우 아름답고 강력한 정리에 크게 의존하고 있습니다. 그것이 바로 **페르마의 소정리(Fermat’s Little Theorem)**입니다. 더 나아가 이를 일반화한 레온하르트 오일러(Leonhard Euler)의 정리 역시 암호 이론에서 결정적인 역할을 하고 있습니다.

본 기사에서는 페르마의 소정리라는 순수 수학의 발견이 어떻게 현대의 실용적인 암호 기술, 특히 ‘소수 판별’과 ‘RSA 암호’에 응용되고 있는지를 기초부터 철저하게 해설합니다. 수학적인 증명, 암호화 및 복호화의 메커니즘, 그리고 C++와 Python을 활용한 구체적인 알고리즘 구현까지 모두 다루는 매우 상세한 기술 가이드가 될 것입니다.

2. 합동식과 모듈러 연산의 기초

페르마의 소정리를 이해하기 위해서는 먼저 ‘모듈러 연산(합동식)‘이라는 수학 개념에 친숙해질 필요가 있습니다. 모듈러 연산이란 어떤 정해진 수(법, 모듈러스라고 부름)로 나눈 ‘나머지’에 주목한 계산 체계를 말합니다. 시계의 문자판(12시간에 1바퀴를 돎)과 같은 계산이기 때문에 ‘시계 산술’이라고도 불립니다.

정수 $a$와 $b$를 양의 정수 $n$으로 나눈 나머지가 같을 때, 수학적으로는 다음과 같이 기술합니다.

$$ a \equiv b \pmod n $$

이것은 ‘$n$을 법으로 하여 $a$와 $b$는 합동이다’라고 읽습니다. 예를 들어, 17을 5로 나눈 나머지는 2이고, 12를 5로 나눈 나머지 역시 2입니다. 따라서 다음과 같이 쓸 수 있습니다.

$$ 17 \equiv 12 \pmod 5 \equiv 2 \pmod 5 $$

모듈러 연산에서는 일반적인 사칙연산(덧셈, 뺄셈, 곱셈)이 그대로 성립합니다.

덧셈: $a \equiv b \pmod n$ 이고 $c \equiv d \pmod n$ 이면, $a + c \equiv b + d \pmod n$
뺄셈: $a \equiv b \pmod n$ 이고 $c \equiv d \pmod n$ 이면, $a - c \equiv b - d \pmod n$
곱셈: $a \equiv b \pmod n$ 이고 $c \equiv d \pmod n$ 이면, $a \times c \equiv b \times d \pmod n$
거듭제곱: $a \equiv b \pmod n$ 이면, 임의의 자연수 $k$에 대해 $a^k \equiv b^k \pmod n$

단, 나눗셈에 대해서는 주의가 필요합니다. 일반적으로 $a \times c \equiv b \times c \pmod n$ 이라고 해서 양변을 $c$로 나누어 $a \equiv b \pmod n$ 으로 만들 수는 없습니다. 이것이 성립하는 것은 $c$와 $n$이 서로소(최대공약수가 1)인 경우에 한합니다. 이 ‘모듈러 역원’의 개념은 후술할 RSA 암호의 키 생성에서 극히 중요해집니다.

3. 페르마의 소정리의 수학적 배경과 증명

모듈러 연산의 기초를 다졌으니, 본 주제인 페르마의 소정리에 대해 살펴보겠습니다.

3.1 정리의 정의

페르마의 소정리는 다음과 같이 정식화됩니다.

페르마의 소정리 (Fermat’s Little Theorem) $p$를 소수라 하고, $a$를 $p$의 배수가 아닌(즉 $a$와 $p$는 서로소인) 임의의 정수라고 하자. 이때 다음의 합동식이 성립한다.
$$ a^{p-1} \equiv 1 \pmod p $$

또한, 조건 ‘$a$가 $p$의 배수가 아닐 것’을 제외하고, 모든 정수 $a$에 대해 성립하는 형태로 표현하는 것도 일반적입니다. 그 경우는 양변에 $a$를 곱하여 다음과 같이 됩니다.

$$ a^p \equiv a \pmod p $$

3.2 구체적인 예를 통한 확인

정리가 정말로 성립하는지 구체적인 숫자를 사용하여 확인해 봅시다. 소수 $p = 5$라고 합시다. $p-1 = 4$입니다. $a$로서 $p$의 배수가 아닌 정수를 선택합니다.

$a = 2$인 경우: $2^{5-1} = 2^4 = 16$. $16 \div 5 = 3$ 나머지 $1$. 따라서 $16 \equiv 1 \pmod 5$. (성립)
$a = 3$인 경우: $3^{5-1} = 3^4 = 81$. $81 \div 5 = 16$ 나머지 $1$. 따라서 $81 \equiv 1 \pmod 5$. (성립)
$a = 4$인 경우: $4^{5-1} = 4^4 = 256$. $256 \div 5 = 51$ 나머지 $1$. 따라서 $256 \equiv 1 \pmod 5$. (성립)

이처럼 어떤 $a$를 선택하든(5의 배수만 아니라면) 4제곱하여 5로 나눈 나머지는 항상 1이 됩니다. 마법처럼 보이지만, 이는 소수가 가지는 아름다운 성질에서 유래한 것입니다.

3.3 정리의 수학적 증명

어째서 이런 일이 성립하는 것일까요. 여기서는 잉여류의 집합을 이용한 우아한 증명을 소개합니다.

집합 $S = \{1, 2, 3, \dots, p-1\}$을 생각합니다. 이들은 $p$로 나눈 나머지가 $1$부터 $p-1$이 되는 정수들의 대표원입니다. 여기서 각 원소에 $p$와 서로소인 정수 $a$를 곱한 새로운 집합 $T$를 생각합니다.

$$ T = \{1a, 2a, 3a, \dots, (p-1)a\} $$

이 집합 $T$의 각 원소를 $p$로 나눈 나머지를 생각해 봅니다. 놀랍게도 이 나머지들은 순서는 바뀔지 몰라도 원래 집합 $S$의 원소들의 집합과 완전히 일치합니다. 왜냐하면:

$T$의 원소가 $p$의 배수가 되는 일은 없습니다($a$도 원래의 원소도 $p$의 배수가 아니기 때문).
$T$ 안에서 $p$를 법으로 하여 합동이 되는 서로 다른 두 원소는 존재하지 않습니다. 만약 $ia \equiv ja \pmod p$ ($i \neq j$)라고 한다면, $a$와 $p$는 서로소이므로 $a$로 나눌 수 있고, $i \equiv j \pmod p$가 되어 모순되기 때문입니다.

따라서 $S$의 원소를 모두 곱한 것과 $T$의 원소를 모두 곱한 것은 $p$를 법으로 하여 합동이 됩니다.

$$ (1a) \times (2a) \times \dots \times ((p-1)a) \equiv 1 \times 2 \times \dots \times (p-1) \pmod p $$

좌변을 정리하면 $a$가 $p-1$개 있으므로,

$$ a^{p-1} \cdot (p-1)! \equiv (p-1)! \pmod p $$

$(p-1)!$은 $p$와 서로소이므로 양변을 $(p-1)!$로 나눌 수 있으며, 최종적으로 다음의 정리가 도출됩니다.

$$ a^{p-1} \equiv 1 \pmod p $$

이것이 페르마의 소정리의 증명입니다.

4. 오일러의 피 함수와 오일러의 정리

페르마의 소정리는 ‘소수 $p$‘에 관한 정리지만, 이를 ‘임의의 양의 정수 $n$‘으로 일반화한 사람이 레온하르트 오일러입니다. RSA 암호를 이해하려면 이 확장이 필수적입니다.

4.1 오일러의 피(토션트) 함수 $\phi(n)$

오일러의 피 함수(또는 오일러의 $\phi$ 함수) $\phi(n)$은 ‘$1$부터 $n$까지의 정수 중 $n$과 서로소인 것의 개수’를 나타내는 함수입니다.

소수 $p$의 경우, $1$부터 $p-1$까지의 모든 정수가 $p$와 서로소이므로 $\phi(p) = p - 1$이 됩니다.
서로 다른 두 소수 $p, q$에 대해, 그 곱인 $n = p \times q$의 경우 $\phi(n)$은 매우 간단한 식으로 구해집니다. $$ \phi(p \times q) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

이 성질이 RSA 암호의 키 생성에 있어 근간이 되는 로직이 됩니다.

4.2 오일러의 정리

오일러는 페르마의 소정리를 다음과 같이 일반화했습니다.

오일러의 정리 (Euler’s Theorem) 양의 정수 $n$과, 그 수와 서로소인 정수 $a$에 대하여 다음이 성립한다.
$$ a^{\phi(n)} \equiv 1 \pmod n $$

만약 $n$이 소수 $p$라면 $\phi(p) = p - 1$이므로, 이것은 페르마의 소정리 자체($a^{p-1} \equiv 1 \pmod p$)가 됩니다. 즉, 페르마의 소정리는 오일러의 정리의 특수한 경우에 불과합니다.

5. 거대한 소수 찾기: 페르마의 소수 판별법

암호 기술(RSA 암호나 Diffie-Hellman 키 교환 등)에서는 수백 자리에 달하는 ‘거대한 소수’를 고속으로 찾아낼 필요가 있습니다. 하지만 거대한 수 $N$이 소수인지 판별하기 위해 $2$부터 $\sqrt{N}$까지의 모든 수로 나누어 떨어지는지 시험하는 ‘시도 나눗셈법’으로는 우주의 수명만큼의 시간이 걸려 버립니다.

그래서 등장하는 것이 페르마의 소정리를 역으로 이용한 ‘확률적 소수 판별법’인 **페르마 테스트(Fermat Primality Test)**입니다.

5.1 확률적 소수 판별법이란

페르마의 소정리에 의하면, $p$가 소수라면 임의의 $a$ ($1 < a < p$)에 대해 $a^{p-1} \equiv 1 \pmod p$ 가 반드시 성립합니다. 이의 대우를 취하면, ‘어떤 $a$에 대해 $a^{p-1} \not\equiv 1 \pmod p$ 가 될 경우, $p$는 절대로 소수가 아니다(합성수이다)‘라는 것을 말할 수 있습니다.

따라서 $N$이 소수인지 판별하고 싶은 경우, 무작위로 몇 개의 $a$를 선택하여 $a^{N-1} \pmod N$을 계산해서 $1$이 되는지를 확인합니다. 만약 한 번이라도 $1$이 아닌 답이 나오면 $N$은 합성수임이 확정됩니다. 몇 번을 시험해도 $1$이 되는 경우 $N$은 ‘아마도 소수일 것이다’라고 높은 확률로 판단할 수 있습니다.

5.2 알고리즘의 해설과 플로우차트

페르마 테스트의 알고리즘은 다음과 같습니다.

flowchart TD Start["시작"] --> Input["판별 대상의 수 p 와, 테스트 횟수 k 를 입력"] Input --> LoopStart["i = 0 부터 k-1 까지 루프"] LoopStart --> Condition{"i < k ?"} Condition -- "예" --> RandomA["1 < a < p-1 의 범위에서 무작위 정수 a 를 선택"] RandomA --> Calc["모듈러 거듭제곱 a^(p-1) mod p 를 계산"] Calc --> CheckPrime{"결과는 1 인가?"} CheckPrime -- "아니요" --> ReturnComposite["p 는 합성수이다 (확정)"] CheckPrime -- "예" --> Increment["i 를 증가시킴"] Increment --> Condition Condition -- "아니요" --> ReturnPrime["p 는 아마도 소수일 것이다 (확률적)"] ReturnComposite --> End["종료"] ReturnPrime --> End

5.3 카마이클 수(위소수)의 함정

페르마 테스트는 매우 빠르지만 중대한 단점이 있습니다. 그것은 합성수임에도 불구하고 모든 $a$에 대해 $a^{N-1} \equiv 1 \pmod N$을 만족시켜 버리는 악마와 같은 수가 존재한다는 것입니다. 이를 **카마이클 수(Carmichael numbers)**라고 부릅니다. 가장 작은 카마이클 수는 $561$ ($3 \times 11 \times 17$)입니다.

카마이클 수가 존재하기 때문에 순수한 페르마 테스트만으로는 절대적인 소수 판별을 할 수 없습니다. 그러므로 실제 암호화 시스템(OpenSSL 등)에서는 페르마 테스트를 개량한 밀러-라빈(Miller-Rabin) 소수 판별법이 표준적으로 사용되고 있습니다. 밀러-라빈 판별법은 카마이클 수를 꿰뚫어 볼 수 있어 오판 확률을 실질적으로 제로에 가깝게 만들 수 있습니다.

5.4 고속 거듭제곱 나머지 연산(분할 정복 거듭제곱)

소수 판별 알고리즘 내에서 $a^{N-1} \pmod N$을 계산해야 하지만, $N$이 거대한 경우 $a^{N-1}$은 천문학적인 자릿수가 되어 컴퓨터 메모리에 다 들어가지 않습니다. 이를 해결하는 것이 분할 정복 거듭제곱(Exponentiation by Squaring) 또는 모듈러 거듭제곱 연산입니다. 계산의 각 단계마다 나머지(mod N)를 취함으로써 항상 값을 $N$보다 작게 유지하며 매우 고속($O(\log N)$의 시간 복잡도)으로 계산 가능하게 됩니다.

6. 소수 판별과 거듭제곱 나머지 구현

그러면 페르마의 소수 판별법과 분할 정복 거듭제곱을 C++와 Python으로 구현해 보겠습니다.

6.1 C++를 이용한 구현

C++에서는 표준 정수형이 오버플로우되기 쉽기 때문에 거대한 수를 다루려면 다정밀도 정수 라이브러리(GMP 등)가 필요하지만, 여기서는 알고리즘을 이해하기 위해 64비트 정수(unsigned long long) 범위 내에서의 구현을 보여줍니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


#include <iostream>
#include <random>

using namespace std;

// 고속 거듭제곱 나머지 연산 (a^b mod m) - 분할 정복 거듭제곱
unsigned long long power_mod(unsigned long long a, unsigned long long b, unsigned long long m) {
 unsigned long long result = 1;
 a = a % m;
 while (b > 0) {
 // b의 최하위 비트가 1인 경우, 결과에 a를 곱함
 if (b % 2 == 1) {
 result = (__int128)result * a % m; // 오버플로우 방지를 위해 128비트 확장
 }
 // a를 제곱함
 a = (__int128)a * a % m;
 // b를 오른쪽 시프트 (절반으로 만듦)
 b /= 2;
 }
 return result;
}

// 페르마의 소수 판별법
bool fermat_is_prime(unsigned long long p, int iterations = 5) {
 if (p <= 1) return false;
 if (p <= 3) return true;
 if (p % 2 == 0) return false;

 random_device rd;
 mt19937_64 gen(rd());
 uniform_int_distribution<unsigned long long> dis(2, p - 2);

 for (int i = 0; i < iterations; ++i) {
 unsigned long long a = dis(gen);
 // a^(p-1) mod p 가 1 이 아니면 합성수
 if (power_mod(a, p - 1, p) != 1) {
 return false;
 }
 }
 return true; // 아마도 소수
}

int main() {
 unsigned long long num = 1000000007; // 이미 알려진 소수
 if (fermat_is_prime(num, 10)) {
 cout << num << " is probably prime." << endl;
 } else {
 cout << num << " is composite." << endl;
 }
 return 0;
}

6.2 Python을 이용한 구현

Python의 표준 정수형은 다정밀도 정수를 지원하므로 자릿수 넘침을 걱정할 필요가 없습니다. 게다가 Python의 내장 함수 pow(a, b, m)는 내부적으로 분할 정복 거듭제곱을 사용하기 때문에 매우 빠릅니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


import random

def fermat_is_prime(p, iterations=5):
 """
 페르마의 소수 판별법을 이용한 확률적 소수 판별
 """
 if p <= 1:
 return False
 if p <= 3:
 return True
 if p % 2 == 0:
 return False

 for _ in range(iterations):
 # 2 에서 p-2 사이의 무작위 수 a 를 고름
 a = random.randint(2, p - 2)
 # a^(p-1) mod p 를 계산. 내장 pow 는 고속.
 if pow(a, p - 1, p) != 1:
 return False # 합성수 확정

 return True # 아마도 소수

# 테스트
number_to_test = 104729
if fermat_is_prime(number_to_test, 10):
 print(f"{number_to_test} 는 아마도 소수입니다.")
else:
 print(f"{number_to_test} 는 합성수입니다.")

7. RSA 암호에의 응용: 페르마와 오일러가 결실을 맺는 곳

페르마의 소정리(및 오일러의 정리)의 가장 위대한 응용처가 1977년에 Rivest, Shamir, Adleman 세 사람에 의해 개발된 RSA 암호입니다. RSA 암호는 ‘공개키 암호’라는 획기적인 시스템으로, 암호화하기 위한 키(공개키)는 전 세계에 공개해 두면서, 복호화하기 위한 키(비밀키)는 수신자 본인만이 알고 있는 구조를 구현하고 있습니다.

이 비대칭성은 ‘거대한 합성수의 소인수분해는 지극히 어렵다’라는 계산 복잡도 기반 안전성에 근거하고 있습니다.

7.1 RSA 암호의 구조 (키 생성, 암호화, 복호화)

RSA 암호의 전체적인 통신 흐름을 Mermaid 시퀀스 다이어그램으로 확인해 봅시다.

sequenceDiagram participant Alice["앨리스 (수신자)"] participant Bob["밥 (송신자)"] Alice->>Alice: "거대한 소수 p, q 를 생성" Alice->>Alice: "N = p * q, φ(N) = (p-1)(q-1) 을 계산" Alice->>Alice: "공개키 e 와 비밀키 d 를 계산 (e*d ≡ 1 mod φ(N))" Alice->>Bob: "공개키 (N, e) 를 전송" Note over Bob: "평문 M 을 준비 (M < N)" Bob->>Bob: "암호문 C = M^e mod N 을 계산" Bob->>Alice: "암호문 C 를 전송" Alice->>Alice: "평문 M = C^d mod N 을 계산하여 복호화"

아래에 수학적인 세부 단계를 해설합니다.

단계 1: 키 생성 (수신자 앨리스의 작업)

두 개의 거대한 소수 $p$와 $q$를 무작위로 생성합니다(여기서 앞서 말한 소수 판별법이 사용됩니다).
그 곱인 $N = p \times q$를 계산합니다. 이 $N$은 공개됩니다.
오일러의 피 함수를 사용하여 $\phi(N) = (p-1)(q-1)$을 계산합니다.
$\phi(N)$과 서로소인 정수 $e$(공개 지수)를 선택합니다(종종 $e = 65537$이 사용됩니다).
$e$의 모듈러 역원 $d$(비밀 지수)를 계산합니다. 즉, 다음을 만족하는 $d$를 찾습니다. $$ e \cdot d \equiv 1 \pmod{\phi(N)} $$ 이 계산에는 확장 유클리드 호제법이 사용됩니다.

이것으로 공개키는 $(N, e)$, **비밀키는 $(N, d)$**가 됩니다. ($p, q, \phi(N)$은 즉시 파기하거나 엄중히 숨깁니다).

단계 2: 암호화 (송신자 밥의 작업)

밥은 앨리스에게 메시지 $M$을 보내고 싶다고 합시다($M$은 문자를 수치화한 것으로 $0 \le M < N$입니다). 밥은 앨리스의 공개키 $(N, e)$를 사용하여 다음 계산을 수행해 암호문 $C$를 만듭니다.

$$ C \equiv M^e \pmod N $$

이 $C$를 네트워크를 통해 앨리스에게 송신합니다.

단계 3: 복호화 (수신자 앨리스의 작업)

암호문 $C$를 받은 앨리스는 자신만이 알고 있는 비밀키 $d$를 사용하여 다음 계산을 수행합니다.

$$ M' \equiv C^d \pmod N $$

놀랍게도 이 계산 결과 $M'$은 원래의 메시지 $M$과 완전히 일치합니다.

7.2 왜 복호화가 가능한가? (수학적 증명)

여기서 페르마의 소정리(오일러의 정리)가 진가를 발휘합니다. 어째서 $C^d \pmod N$이 $M$으로 되돌아가는 것일까요?

복호화 식을 전개해 봅니다. $C \equiv M^e \pmod N$ 이므로,

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

키 생성 단계에서 $e \cdot d \equiv 1 \pmod{\phi(N)}$ 이 되도록 $d$를 선택했습니다. 이것은 어떤 정수 $k$가 존재하여 다음과 같이 쓸 수 있음을 의미합니다.

$$ e \cdot d = 1 + k \cdot \phi(N) $$

이것을 위의 식에 대입합니다.

$$ M^{ed} = M^{1 + k \cdot \phi(N)} = M \cdot M^{k \cdot \phi(N)} = M \cdot (M^{\phi(N)})^k \pmod N $$

여기서 오일러의 정리 ($M^{\phi(N)} \equiv 1 \pmod N$)가 등장합니다. (※엄밀히는 $M$과 $N$이 서로소여야 하지만, RSA에서는 $M$과 $N$이 서로소가 아닐 확률이 천문학적으로 낮으며 중국인의 나머지 정리를 사용하면 서로소가 아니어도 성립함이 증명 가능합니다).

오일러의 정리를 적용하면 $M^{\phi(N)} \equiv 1$ 이므로,

$$ M \cdot (1)^k \equiv M \pmod N $$

보기 좋게 $M$이 복원되었습니다! 페르마와 오일러가 수백 년 전에 발견한 수의 성질이 현대 디지털 통신의 기밀성을 완벽하게 보장하고 있는 것입니다.

8. RSA 암호의 토이 구현 (Python)

이론만으로는 실감이 나지 않기 때문에 Python을 사용하여 실제로 RSA 암호의 키 생성, 암호화, 복호화의 과정을 구현해 보겠습니다. 이것은 교육용 ‘토이(장난감) 구현’이지만 사용된 수학은 진짜와 완전히 같습니다.

모듈러 역원 $d$를 구하기 위한 ‘확장 유클리드 호제법’도 구현에 포함시킵니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


import random

# 최대공약수를 구함
def gcd(a, b):
 while b != 0:
 a, b = b, a % b
 return a

# 확장 유클리드 호제법 (ax + by = gcd(a,b) 의 x, y 를 구함)
# e*d ≡ 1 (mod φ(N)) 의 d 를 찾기 위해 사용
def extended_gcd(a, b):
 if a == 0:
 return (b, 0, 1)
 else:
 g, y, x = extended_gcd(b % a, a)
 return (g, x - (b // a) * y, y)

def mod_inverse(e, phi):
 g, x, y = extended_gcd(e, phi)
 if g != 1:
 raise Exception('역원이 존재하지 않습니다')
 else:
 return x % phi

# 소수 생성 함수 (간이판: 작은 소수를 생성)
def generate_prime(bits):
 while True:
 p = random.getrandbits(bits)
 # 앞서 말한 페르마 테스트 대신 간이로 판별
 if p > 1 and pow(2, p-1, p) == 1 and pow(3, p-1, p) == 1:
 return p

# RSA 키 생성
def generate_keypair(bits=16):
 p = generate_prime(bits)
 q = generate_prime(bits)
 # p 와 q 가 같아지지 않도록 함
 while p == q:
 q = generate_prime(bits)

 n = p * q
 phi = (p - 1) * (q - 1)

 # e 는 65537 등의 소수가 자주 사용되지만, 여기서는 무작위로 고름
 e = random.randrange(1, phi)
 g = gcd(e, phi)
 while g != 1:
 e = random.randrange(1, phi)
 g = gcd(e, phi)

 # 비밀키 d 계산
 d = mod_inverse(e, phi)

 # 공개키 (e, n), 비밀키 (d, n)
 return ((e, n), (d, n))

def encrypt(pk, plaintext):
 e, n = pk
 # plaintext^e mod n 을 계산
 cipher = [pow(ord(char), e, n) for char in plaintext]
 return cipher

def decrypt(sk, ciphertext):
 d, n = sk
 # cipher^d mod n 을 계산하고 문자로 되돌림
 plain = [chr(pow(char, d, n)) for char in ciphertext]
 return ''.join(plain)

# 실행 예시
if __name__ == '__main__':
 print("--- RSA 암호 토이 구현 ---")
 public_key, private_key = generate_keypair(bits=12) # 12비트의 소수 사용

 print(f"공개키 (e, n): {public_key}")
 print(f"비밀키 (d, n): {private_key}")

 message = "Hello Math!"
 print(f"\n원래의 메시지: {message}")

 # 암호화
 encrypted_msg = encrypt(public_key, message)
 print(f"암호문: {encrypted_msg}")

 # 복호화
 decrypted_msg = decrypt(private_key, encrypted_msg)
 print(f"복호화된 메시지: {decrypted_msg}")

이 코드를 실행하면 문자 배열이 낯선 숫자 배열(암호문)로 변환되고, 그것이 비밀키에 의해 훌륭하게 원래 문자열로 복원되는 모습을 확인할 수 있습니다.

9. 마치며: 수학의 아름다움과 실용성의 교차점

피에르 드 페르마가 이 ‘소정리’를 발견한 17세기 당시, 이것이 어딘가에 쓸모가 있을 것이라고 생각한 사람은 아무도 없었습니다. 페르마 자신도 순수한 수학적 탐구심에서 정수론 연구를 하고 있었습니다.

하지만 약 300년 후인 1970년대, 컴퓨터 네트워크의 여명기에 안전한 통신 프로토콜을 확립하기 위해 없어서는 안 될 암호 기술로서 페르마의 정리는 극적인 부활을 이뤘습니다. 페르마의 소정리에 기반한 소수 판별 기술과 오일러의 정리에 기반한 RSA 암호는 현대의 인터넷 인프라를 말 그대로 지탱하고 있습니다.

우리가 매일 무심코 보내는 메신저의 메시지도, 쇼핑몰에서의 물건 구매도, 모든 것은 이 $a^{p-1} \equiv 1 \pmod p$ 라는 심플하고 아름다운 수식 위에서 춤추고 있는 것입니다. 수학이 아무리 추상적이라 할지라도 언젠가는 반드시 인류에게 도움이 될 때가 온다는 것을 페르마의 소정리는 가르쳐 주고 있습니다.

프로그래밍이나 암호 이론을 배울 때 그 기초에 있는 수학적 구조를 이해하는 것은 블랙박스로 제공되는 라이브러리의 동작을 깊이 이해하고, 더 안전한 시스템을 설계하기 위한 큰 무기가 될 것입니다.

격자 암호(Lattice-based cryptography)의 수학적 직관

Fri, 11 Sep 2026 21:00:00 +0900

1. 도입: 포스트 양자 암호(PQC)의 여명과 격자 암호의 대두

현대 사회의 디지털 인프라를 지탱하고 있는 것은 RSA 암호나 타원곡선암호(ECC)를 비롯한 공개키 암호 기술입니다. 이러한 암호 방식은 ‘소인수분해 문제’나 ‘이산대수 문제’와 같은, 기존의 고전 컴퓨터로는 효율적으로 풀 수 없다고(지수 함수적인 시간이 소요된다고) 믿어지는 수학적 난해성에 안전성의 근거를 두고 있습니다.

그러나 1994년 피터 쇼어(Peter Shor)가 발표한 ‘쇼어 알고리즘(Shor’s algorithm)‘은 암호계에 큰 충격을 주었습니다. 이 알고리즘은 대규모 양자 컴퓨터가 실현될 경우 소인수분해 문제나 이산대수 문제를 다항식 시간 내에 풀어버린다는 것을 수학적으로 증명한 것입니다. 이는 즉, 현재 널리 이용되고 있는 공개키 암호가 장래에는 완전히 해독 가능해진다는 것을 의미합니다.

이러한 ‘양자 컴퓨터의 위협(Quantum Threat)‘에 대응하기 위해, 양자 컴퓨터를 사용해도 해독이 어려운 새로운 암호 방식의 연구가 시급해졌습니다. 이것이 ‘포스트 양자 암호(Post-Quantum Cryptography: PQC)’ 또는 ‘양자 내성 암호’라고 불리는 분야입니다.

PQC에는 몇 가지 유력한 후보가 존재합니다. 해시 기반 암호, 코드 기반 암호, 다변수 다항식 암호, 아이소제니 기반 암호 등을 들 수 있지만, 그 중에서도 현재 가장 주목받고 있으며 NIST(미국 국립표준기술연구소)의 PQC 표준화 프로세스의 중심이 되고 있는 것이 바로 ‘격자 암호(Lattice-based cryptography)‘입니다. 격자 암호는 다른 방식과 비교하여 암호화 및 복호화 처리 속도가 매우 빠르며, 또한 ‘최악의 경우 복잡도(Worst-case complexity)‘를 ‘평균적인 경우 복잡도(Average-case complexity)‘로 환원하는, 암호 이론에 있어서 극히 강력한 안전성 증명을 갖는다는 두드러진 특징을 가지고 있습니다.

본 기사에서는 이 격자 암호의 기초가 되는 ‘격자(Lattice)‘의 수학적 정의부터 출발하여, 격자 상의 어려운 문제인 SVP(최단 벡터 문제)나 CVP(최근접 벡터 문제), 그리고 현대 격자 암호의 심장부라고도 할 수 있는 ‘LWE 문제(Learning With Errors)‘에 대해 수식과 기하학적인 직관, 그리고 구체적인 수치 예를 섞어 철저하고 깊이 있게 해설하겠습니다.

2. 격자(Lattice)의 수학적 정의와 기하학적 직관

2.1 벡터 공간과 격자

수학에서 ‘격자(Lattice)‘란 $n$차원 실수 벡터 공간 $\mathbb{R}^n$ 내에 규칙적으로 늘어선 이산적인 점들의 집합을 말합니다. 선형대수학에서 배우는 벡터 공간(Vector Space)과 비슷하지만 결정적인 차이가 있습니다. 벡터 공간이 기저 벡터의 ‘실수 계수’를 통한 선형 결합으로 표현되는 연속적인 공간인 반면, 격자는 기저 벡터의 ‘정수 계수’를 통한 선형 결합으로 표현되는 이산적인 공간입니다.

수학적으로 엄밀한 정의를 내려보겠습니다. $m$차원 실수 벡터 공간 $\mathbb{R}^m$에서의 $n$개($n \le m$)의 선형 독립적인 벡터 $\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n$을 생각해 봅시다. 이들 벡터를 열벡터로 가지는 행렬을 $B = [\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n] \in \mathbb{R}^{m \times n}$이라고 합니다. 이 $B$를 격자의 ‘기저(Basis)‘라고 부릅니다.

이 기저 $B$에 의해 생성되는 격자 $\mathcal{L}(B)$는 다음과 같이 정의됩니다.

$$ \mathcal{L}(B) = \left\{ \sum_{i=1}^{n} x_i \mathbf{b}_i \mathrel{\bigg|} x_i \in \mathbb{Z} \right\} = \{ B \mathbf{x} \mid \mathbf{x} \in \mathbb{Z}^n \} $$

여기서 중요한 것은 계수 $x_i$가 실수 $\mathbb{R}$이 아니라 정수 $\mathbb{Z}$로 한정되어 있다는 점입니다. 이로 인해 공간 내에 무수히 존재하는 연속적인 점이 아니라, 일정한 간격으로 배치된 교차점과 같은 ‘이산적인 점들의 집합’이 형성됩니다.

2.2 기하학적 이미지

2차원 평면 $\mathbb{R}^2$의 예로 생각해 봅시다. 기저 벡터로서 $\mathbf{b}_1 = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$와 $\mathbf{b}_2 = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$을 선택한 경우, 이들에 의해 생성되는 격자는 좌표평면 상의 모든 정수 좌표 $(x, y) \in \mathbb{Z}^2$의 집합이 됩니다. 이는 가장 단순한 ‘정방격자’입니다.

그러나 격자가 항상 직교하는 것은 아닙니다. 예를 들어, $\mathbf{b}_1 = \begin{pmatrix} 2 \\ 1 \end{pmatrix}$과 $\mathbf{b}_2 = \begin{pmatrix} 1 \\ 3 \end{pmatrix}$이라는 기저를 생각해보면, 생성되는 점은 비스듬하게 왜곡된 그물망의 교차점처럼 됩니다.

2.3 기저의 비유일성과 유니모듈러 변환

격자 암호의 안전성 근간과 관련된 중요한 성질이 있습니다. 그것은 ‘동일한 격자를 생성하는 기저는 무수히 존재한다’는 것입니다.

예를 들어, 앞서 설명한 $\mathbf{b}_1 = (1, 0)^T, \mathbf{b}_2 = (0, 1)^T$라는 기저가 생성하는 $\mathbb{Z}^2$ 격자는 $\mathbf{b}'_1 = (1, 1)^T, \mathbf{b}'_2 = (2, 3)^T$라는 기저를 사용해도 완전히 같은 격자 $\mathbb{Z}^2$를 생성합니다.

어떤 기저 $B$와 다른 기저 $B'$가 같은 격자를 생성하기 위한 필요충분조건은, 정수 성분을 가진 행렬 $U \in \mathbb{Z}^{n \times n}$이면서 행렬식이 $\det(U) = \pm 1$이 되는 것이 존재하여,

$$ B' = B U $$

로 표현될 수 있다는 것입니다. 이러한 행렬 $U$를 ‘유니모듈러 행렬(Unimodular matrix)‘이라고 부릅니다.

암호에 응용할 때의 기본적인 아이디어는 ‘좋은 기저(직교에 가깝고 짧은 벡터로 이루어진 기저)‘를 비밀키로 하고, ‘나쁜 기저(서로 극단적으로 비스듬하게 교차하며 매우 긴 벡터로 이루어진 기저)‘를 공개키로 사용하는 것입니다. 나쁜 기저로부터 좋은 기저를 계산해내는 것은 차원이 높아질수록 매우 어려워집니다. 이것이 격자 암호의 기본적인 직관입니다.

3. 격자에서의 계산이 어려운 문제

격자 암호의 안전성은 격자 상의 특정한 수학적 문제를 푸는 것의 어려움에 의존하고 있습니다. 여기서는 가장 기본적이면서 유명한 두 가지 문제를 소개합니다.

3.1 최단 벡터 문제(Shortest Vector Problem: SVP)

SVP는 격자 이론에서 가장 고전적이고 유명한 문제입니다.

정의 (SVP): 임의의 격자 기저 $B$가 주어졌을 때, 그 격자 $\mathcal{L}(B)$에 속하는 영(zero)이 아닌 벡터 중에서 유클리드 노름(길이)이 최소가 되는 벡터 $\mathbf{v}$를 찾아라.

수식으로 표현하면, $\min_{\mathbf{v} \in \mathcal{L}(B) \setminus \{\mathbf{0}\}} \| \mathbf{v} \|$가 되는 $\mathbf{v}$를 구하는 문제입니다. 이 최소 길이를 $\lambda_1(\mathcal{L})$로 쓰고, ‘격자의 제1연속 최소값(First successive minimum)‘이라고 부릅니다.

2차원이나 3차원처럼 낮은 차원이라면, 그림을 그려서 눈으로 가장 짧은 벡터를 찾을 수 있습니다. 또는 가우스의 격자 축소 알고리즘(Gauss lattice reduction algorithm) 등을 사용하여 효율적으로 풀 수 있습니다. 그러나 차원 $n$이 수백에서 수천과 같은 고차원이 되면, SVP를 엄밀하게 푸는 것은 NP-hard임이 알려져 있습니다.

실제 암호에서는 엄밀한 최단 벡터가 아니라, ‘근사적으로 짧은 벡터’를 찾는 근사 SVP($\gamma$-SVP)가 사용됩니다. 근사 계수 $\gamma$가 다항식 크기일 경우, 이 문제는 여전히 매우 어려운 것으로 간주됩니다.

3.2 최근접 벡터 문제(Closest Vector Problem: CVP)

CVP 또한 격자 암호에 있어서 매우 중요한 문제입니다.

정의 (CVP): 임의의 격자 기저 $B$와, 공간 내의 임의의 타겟 벡터 $\mathbf{t} \in \mathbb{R}^m$ (반드시 격자점일 필요는 없음)이 주어졌을 때, 격자점 중에서 $\mathbf{t}$에 가장 가까운 격자점 $\mathbf{v} \in \mathcal{L}(B)$를 찾아라.

수식으로 표현하면, $\min_{\mathbf{v} \in \mathcal{L}(B)} \| \mathbf{v} - \mathbf{t} \|$가 되는 격자점 $\mathbf{v}$를 찾는 문제입니다.

CVP 역시 SVP와 마찬가지로 고차원에서는 NP-hard입니다. 암호에의 응용이라는 관점에서, 후술할 LWE 문제는 이 CVP의 특수한 변형(Bounded Distance Decoding: BDD)과 밀접한 관계가 있습니다.

3.3 왜 고차원이 되면 풀 수 없는가? (LLL과 BKZ의 한계)

고차원의 격자 문제를 풀기 위한 유명한 알고리즘으로 LLL 알고리즘(Lenstra-Lenstra-Lovász algorithm)이 있습니다. LLL 알고리즘은 다항식 시간에 동작하며, 격자 기저를 어느 정도 ‘좋은 기저’로 축소(Reduction)할 수 있습니다. 그러나 LLL 알고리즘이 찾을 수 있는 최단 벡터는 진정한 최단 벡터의 길이에 대해 지수 함수적인($2^{\mathcal{O}(n)}$) 근사 계수를 가지기 때문에, 암호의 안전성을 깨뜨리기에는 역부족입니다.

LLL을 개량한 BKZ(Block Korkine-Zolotarev) 알고리즘과 같은 더 강력한 기저 축소 알고리즘을 사용하면 더 짧은 벡터를 찾을 수 있지만, 그 계산량은 블록 크기에 대해 지수 함수적으로 증가합니다. 격자 암호에서는 이 BKZ 알고리즘의 실행 시간을 추정함으로써 안전한 파라미터(차원 $n$의 크기 등)를 결정하고 있습니다. 현재 PQC의 표준 파라미터에서는 차원 $n$이 500에서 1000 이상의 값으로 선택되고 있으며, 슈퍼컴퓨터나 미래의 양자 컴퓨터를 사용하더라도 해독하는 데에는 우주의 나이 이상의 시간이 걸릴 것으로 여겨집니다.

4. LWE 문제(Learning With Errors)의 수학적 정식화

현대 격자 암호의 대부분은 2005년 오데드 레게브(Oded Regev)가 제안한 ‘LWE 문제(Learning With Errors)‘를 기반으로 하고 있습니다. LWE 문제의 아름다움은 그 정식화의 단순함과 ‘최악의 경우 복잡도에서 평균적인 경우 복잡도로의 환원’이라는 강력한 수학적 증명을 가지고 있다는 점에 있습니다.

4.1 노이즈가 없는 연립 일차 방정식

LWE 문제를 이해하기 위해, 우선 노이즈가 없는 단순한 연립 일차 방정식을 생각해 봅시다. 미지의 비밀 벡터 $\mathbf{s} \in \mathbb{Z}_q^n$ (각 성분은 $0$부터 $q-1$까지의 정수)가 있다고 가정합니다. 여기서 $q$는 소수라고 합니다.

랜덤한 계수 벡터 $\mathbf{a}_1, \mathbf{a}_2, \dots \in \mathbb{Z}_q^n$을 선택하고, 비밀 벡터 $\mathbf{s}$와의 내적을 법 $q$로 계산합니다. $b_1 = \langle \mathbf{a}_1, \mathbf{s} \rangle \pmod q$ $b_2 = \langle \mathbf{a}_2, \mathbf{s} \rangle \pmod q$ $\vdots$

충분한 수($n$개 이상)의 $(\mathbf{a}_i, b_i)$ 쌍이 주어질 경우, 우리는 선형대수의 ‘가우스 소거법(Gaussian elimination)‘을 사용하여 쉽게 비밀 벡터 $\mathbf{s}$를 복원할 수 있습니다. 이는 다항식 시간 내에 간단히 풀 수 있는 문제입니다.

4.2 LWE 문제의 정의: 노이즈를 더하다

그렇다면, 이 문제에 약간의 ‘노이즈(오차)‘를 더하면 어떻게 될까요? 이것이 LWE 문제의 본질입니다.

미지의 비밀 벡터 $\mathbf{s} \in \mathbb{Z}_q^n$에 대하여, 각 방정식의 결과에 작은 오차 $e_i \in \mathbb{Z}_q$를 더합니다. $b_i = \langle \mathbf{a}_i, \mathbf{s} \rangle + e_i \pmod q$

여기서 $e_i$는 평균이 0이고 표준편차가 비교적 작은(예를 들어 정규분포와 같은, 이산 가우스 분포에서 선택된) 작은 정수값입니다. 주어지는 정보는 랜덤한 벡터 $\mathbf{a}_i$와, 거기에 오차를 더해 계산된 $b_i$ 쌍의 리스트입니다. $( \mathbf{a}_1, b_1 ), ( \mathbf{a}_2, b_2 ), \dots, ( \mathbf{a}_m, b_m )$

이를 행렬로 표현하면 매우 깔끔해집니다. 랜덤한 행렬 $A \in \mathbb{Z}_q^{m \times n}$, 비밀 벡터 $\mathbf{s} \in \mathbb{Z}_q^n$, 오차 벡터 $\mathbf{e} \in \mathbb{Z}_q^m$을 사용하여,

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q $$

라고 쓸 수 있습니다. 주어지는 것은 $A$와 $\mathbf{b}$뿐입니다. 여기서 $\mathbf{s}$를 구하는 것이 ‘탐색 LWE 문제(Search LWE problem)‘입니다.

오차 $e_i$가 들어있기 때문에, 가우스 소거법을 사용하려고 하면 방정식을 더하고 빼는 과정에서 오차가 지수 함수적으로 증폭되어 올바른 답에 도달할 수 없게 됩니다. 얼핏 보면 단순한 연립 일차 방정식처럼 보이지만, 이 작은 노이즈가 더해지는 것만으로 문제의 난이도가 NP-hard 수준으로 뛰어오르게 됩니다.

4.3 결정 LWE 문제(Decision LWE)

암호 이론의 증명에서 빈번하게 사용되는 것은 탐색 LWE 문제의 변형인 ‘결정 LWE 문제(Decision LWE problem)‘입니다.

결정 LWE 문제란, 다음의 2가지 분포에서 얻은 샘플의 리스트가 주어졌을 때, 그것이 어느 분포에서 온 것인지를 판정하는 문제입니다.

LWE 분포: 의도적으로 계산된 $(A, \mathbf{b} = A\mathbf{s} + \mathbf{e} \pmod q)$
균등 랜덤 분포: 완전히 랜덤하게 선택된 행렬 $A$와 벡터 $\mathbf{u}$로 이루어진 $(A, \mathbf{u})$

놀랍게도, LWE 문제의 파라미터를 적절히 선택하면, LWE 분포에서 얻은 쌍은 완전히 랜덤한 데이터 쌍과 ‘계산량적으로 식별 불가능(Computationally Indistinguishable)‘해집니다. 이 성질이 LWE 기반 암호가 ‘난수와 구별할 수 없는 암호문’을 생성할 수 있는 근거가 됩니다.

4.4 최악의 경우 복잡도에서 평균적인 경우 복잡도로의 환원(레게브의 정리)

오데드 레게브의 가장 큰 공적은 이 LWE 문제의 어려움을 앞서 언급한 격자 문제(SVP나 CVP)의 어려움에 수학적으로 연결시킨 것입니다.

그는 양자 환원(Quantum reduction)을 사용하여, ‘만약 LWE 문제를 평균적으로(랜덤하게 선택된 $A$와 $\mathbf{e}$에 대해) 풀 수 있는 다항식 시간 알고리즘이 존재한다면, 임의의 격자의 최악의 경우(가장 어려운 경우)의 Gap-SVP를 풀 수 있는 다항식 시간의 양자 알고리즘이 존재한다’는 것을 증명했습니다. (나중에 페이커트(Peikert) 등에 의해 고전적인 환원도 증명되었습니다.)

이는 암호 이론에 있어 꿈과 같은 성질입니다. 왜냐하면, ‘암호가 깨지는 것은 우리가 우연히 약한 키(평균적인 경우의 일부)를 선택해 버렸기 때문일지도 모른다’는 우려를 불식시키고, ‘평균적인 LWE를 풀 수 있다면, 격자의 모든 어려운 문제를 풀 수 있게 된다(그러므로 LWE는 절대적으로 어렵다)‘는 강력한 보증을 해주기 때문입니다.

graph TD A["최악의 경우 격자 문제 (Gap-SVP, SIVP)"] -->|양자/고전적 환원| B["평균적인 경우 LWE 문제"] B -->|암호학적 구성| C["LWE 기반 암호 시스템 (PKE, KEM, FHE)"] style A fill:#ffcccc,stroke:#ff0000,stroke-width:2px,color:#000 style B fill:#ccffcc,stroke:#00aa00,stroke-width:2px,color:#000 style C fill:#ccccff,stroke:#0000ff,stroke-width:2px,color:#000

5. LWE를 이용한 공개키 암호 방식(레게브 암호)의 구성

LWE 문제의 어려움을 이해했으니, 그것을 사용하여 어떻게 암호화와 복호화를 수행하는지, 오데드 레게브가 제안한 기본적인 공개키 암호 방식을 살펴봅시다. 여기서는 1비트의 메시지 $M \in \{0, 1\}$를 암호화하는 가장 기본적인 메커니즘을 설명합니다.

5.1 키 생성(Key Generation)

시스템 파라미터로서 법이 되는 소수 $q$, 차원 $n$, 방정식의 수 $m$($m > n \log q$)을 결정합니다.
비밀키로서 벡터 $\mathbf{s} \in \mathbb{Z}_q^n$를 랜덤하게 선택합니다.
랜덤한 행렬 $A \in \mathbb{Z}_q^{m \times n}$을 생성합니다.
작은 오차 벡터 $\mathbf{e} \in \mathbb{Z}_q^m$를 이산 가우스 분포 등의 오차 분포에서 선택합니다.
벡터 $\mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q$를 계산합니다.
공개키(Public Key)는 $(A, \mathbf{b})$가 됩니다.
비밀키(Secret Key)는 $\mathbf{s}$가 됩니다.

공개키는 그야말로 ‘LWE 문제의 인스턴스’ 그 자체입니다. 공개키 $(A, \mathbf{b})$로부터 비밀키 $\mathbf{s}$를 구하는 것은 탐색 LWE 문제를 푸는 것과 같기 때문에 안전성이 보장됩니다.

5.2 암호화(Encryption)

앨리스는 밥의 공개키 $(A, \mathbf{b})$를 사용하여, 1비트의 메시지 $M \in \{0, 1\}$를 암호화합니다.

랜덤한 이진 벡터(성분이 0 또는 1) $\mathbf{r} \in \{0, 1\}^m$를 선택합니다.
암호문의 전반부로서 벡터 $\mathbf{u} = A^T \mathbf{r} \pmod q$를 계산합니다. ($A^T$는 $A$의 전치 행렬입니다. 즉, $A$의 행 중에서 $\mathbf{r}$의 성분이 1인 행들을 더하는 것입니다).
암호문의 후반부로서 스칼라 $v = \mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q$를 계산합니다. (메시지 $M$이 0이면 아무것도 더하지 않고, $1$이면 $q$의 정확히 절반 값인 $\lfloor \frac{q}{2} \rfloor$를 더합니다).
암호문(Ciphertext)은 $(\mathbf{u}, v)$가 됩니다.

암호화의 직관적인 의미는 공개키의 행렬 $A$와 벡터 $\mathbf{b}$에 대하여 ‘랜덤한 부분 집합의 합’을 취하는 것입니다. 결정 LWE 문제의 어려움에 의해 이 암호문 $(\mathbf{u}, v)$는 완전히 랜덤한 벡터 및 균등 난수와 구별이 불가능한 것처럼 보입니다(의미론적 안전성: Semantic Security).

flowchart LR M["메시지 M in {0,1}"] --> Enc PK["공개키 (A, b)"] --> Enc r["랜덤 이진 벡터 r"] --> Enc subgraph Enc ["암호화 과정"] direction TB u_calc["u = A^T * r mod q"] v_calc["v = b^T * r + M * floor(q/2) mod q"] end Enc --> CT["암호문 (u, v)"]

5.3 복호화(Decryption)

밥은 비밀키 $\mathbf{s}$를 사용하여 암호문 $(\mathbf{u}, v)$를 복호화합니다.

다음 값을 계산합니다: $D = v - \mathbf{s}^T \mathbf{u} \pmod q$
계산한 결과가 $0$에 가까우면 $M=0$, $\lfloor \frac{q}{2} \rfloor$에 가까우면 $M=1$로 출력합니다.

왜 이렇게 복호화할 수 있는지 수학적으로 전개해 봅시다. $\mathbf{b} = A \mathbf{s} + \mathbf{e}$ 였음을 상기해 주십시오.

$$ \begin{aligned} v - \mathbf{s}^T \mathbf{u} &= (\mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T (A^T \mathbf{r}) \\ &= ((A \mathbf{s} + \mathbf{e})^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= (\mathbf{s}^T A^T \mathbf{r} + \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q \end{aligned} $$

여기서, 식 안에서 $\mathbf{s}^T A^T \mathbf{r}$가 깔끔하게 상쇄되어 사라졌습니다! 남은 것은 $\mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor$ 입니다.

$\mathbf{e}$는 성분이 매우 작은 노이즈 벡터이고, $\mathbf{r}$는 성분이 0 또는 1인 이진 벡터입니다. 따라서 이들의 내적인 $\mathbf{e}^T \mathbf{r}$도 (파라미터를 적절히 선택하면) 비교적 작은 값에 머물게 됩니다.

만약 $M=0$이라면 결과는 $\mathbf{e}^T \mathbf{r}$가 되어 $0$에 가까운 작은 값이 됩니다.
만약 $M=1$이라면 결과는 $\mathbf{e}^T \mathbf{r} + \lfloor \frac{q}{2} \rfloor$가 되어 $q$의 절반 값인 $\lfloor \frac{q}{2} \rfloor$의 주변에 위치하게 됩니다.

오차 $\mathbf{e}^T \mathbf{r}$의 절댓값이 $\frac{q}{4}$ 미만으로 수렴하도록 파라미터가 설계되어 있다면, 밥은 계산 결과가 $0$과 $\lfloor \frac{q}{2} \rfloor$ 중 어느 쪽에 더 가까운지를 보는 것만으로 메시지 $M$을 정확하게 판정(복호화)할 수 있습니다. 이것이 LWE 기반 암호가 기능하는 아름다운 메커니즘입니다.

flowchart LR CT["암호문 (u, v)"] --> Dec SK["비밀키 s"] --> Dec subgraph Dec ["복호화 과정"] direction TB calc["D = v - s^T * u mod q 계산"] check["D가 0 또는 q/2 중 어디에 가까운지 확인"] end calc --> check Dec --> M_out["복원된 메시지 M"]

6. 구체적인 수치를 이용한 LWE 암호의 토이 이그잼플

수식의 나열만으로는 실감하기 어려울 것이라 생각하므로, 실제로 매우 작은 수치 파라미터를 설정하여 암호화부터 복호화까지의 계산을 따라가 보겠습니다. (※실제 암호 시스템에서는 안전성 확보를 위해 $n$은 500 이상, $q$는 수천 이상의 값이 사용됩니다)

【파라미터 설정】

법 $q = 17$ (소수. 따라서 값은 $0$부터 $16$까지의 범위를 갖습니다)
차원 $n = 2$
방정식의 수 $m = 4$
메시지 $M = 1$을 암호화한다고 가정합니다.
메시지의 시프트 양: $\lfloor \frac{q}{2} \rfloor = \lfloor \frac{17}{2} \rfloor = 8$

【1. 키 생성 단계】 밥은 비밀키 $\mathbf{s}$와 행렬 $A$, 오차 벡터 $\mathbf{e}$를 랜덤하게 선택합니다.

$$ \mathbf{s} = \begin{pmatrix} 3 \\ 4 \end{pmatrix} \in \mathbb{Z}_{17}^2 $$ $$ A = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \in \mathbb{Z}_{17}^{4 \times 2} $$ $$ \mathbf{e} = \begin{pmatrix} 1 \\ -1 \\ 0 \\ 2 \end{pmatrix} \equiv \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} \pmod{17} $$

다음으로 공개키 $\mathbf{b}$를 계산합니다.

$$ A \mathbf{s} = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \begin{pmatrix} 3 \\ 4 \end{pmatrix} = \begin{pmatrix} 2\times 3 + 15\times 4 \\ 1\times 3 + 8\times 4 \\ 14\times 3 + 5\times 4 \\ 9\times 3 + 10\times 4 \end{pmatrix} = \begin{pmatrix} 6 + 60 \\ 3 + 32 \\ 42 + 20 \\ 27 + 40 \end{pmatrix} = \begin{pmatrix} 66 \\ 35 \\ 62 \\ 67 \end{pmatrix} $$

이를 법 17로 계산합니다. ($66 = 17 \times 3 + 15$ 등)

$$ A \mathbf{s} \pmod{17} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} $$

오차 벡터 $\mathbf{e}$를 더합니다.

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} + \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} = \begin{pmatrix} 16 \\ 17 \\ 11 \\ 18 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 0 \\ 11 \\ 1 \end{pmatrix} \pmod{17} $$

공개키는 $A$와 $\mathbf{b} = (16, 0, 11, 1)^T$가 됩니다.

【2. 암호화 단계】 앨리스는 메시지 $M = 1$을 암호화합니다. 랜덤한 벡터 $\mathbf{r}$를 선택합니다. 여기서는 $\mathbf{r} = (1, 0, 1, 0)^T$로 합니다.

$\mathbf{u}$를 계산합니다.

$$ \mathbf{u} = A^T \mathbf{r} = \begin{pmatrix} 2 & 1 & 14 & 9 \\ 15 & 8 & 5 & 10 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = \begin{pmatrix} 2 \times 1 + 14 \times 1 \\ 15 \times 1 + 5 \times 1 \end{pmatrix} = \begin{pmatrix} 16 \\ 20 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 3 \end{pmatrix} \pmod{17} $$

$v$를 계산합니다.

$$ \mathbf{b}^T \mathbf{r} = (16, 0, 11, 1) \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = 16 \times 1 + 11 \times 1 = 27 \equiv 10 \pmod{17} $$

메시지 $M=1$에 해당하는 값 $\lfloor 17/2 \rfloor = 8$을 더합니다.

$$ v = \mathbf{b}^T \mathbf{r} + M \cdot 8 = 10 + 1 \times 8 = 18 \equiv 1 \pmod{17} $$

앨리스는 암호문으로 $(\mathbf{u}, v) = \left( \begin{pmatrix} 16 \\ 3 \end{pmatrix}, 1 \right)$을 밥에게 전송합니다.

【3. 복호화 단계】 암호문을 받은 밥은 비밀키 $\mathbf{s} = (3, 4)^T$를 사용하여 복호화합니다. 복호화 처리식: $D = v - \mathbf{s}^T \mathbf{u} \pmod{17}$을 계산합니다.

$$ \mathbf{s}^T \mathbf{u} = (3, 4) \begin{pmatrix} 16 \\ 3 \end{pmatrix} = 3 \times 16 + 4 \times 3 = 48 + 12 = 60 \equiv 9 \pmod{17} $$ $$ D = v - \mathbf{s}^T \mathbf{u} = 1 - 9 = -8 \pmod{17} $$

여기서 법 17의 세계에서는 $-8$이 $9$와 같아집니다($-8 + 17 = 9$). 얻어진 값 $D = 9$를 $0$과 $8$($\lfloor 17/2 \rfloor$) 중 어디에 가까운지 판정합니다. $9$는 $0$보다 $8$에 명백히 더 가깝기 때문에 밥은 올바르게 $M = 1$을 복원할 수 있었습니다!

왜 $9$가 되었을까요? 앞서 설명한 증명을 상기해 봅시다. 오차 부분은 $\mathbf{e}^T \mathbf{r} = (1, -1, 0, 2) (1, 0, 1, 0)^T = 1 \times 1 + 0 \times 1 = 1$로 되어 있습니다. 따라서 계산 결과는 $\mathbf{e}^T \mathbf{r} + M \cdot 8 = 1 + 8 = 9$가 되어, 이론대로의 값이 계산되었음을 확인할 수 있었습니다.

7. 실용화를 향한 진화: Ring-LWE와 Module-LWE

지금까지 설명한 표준적인 LWE 문제(Standard LWE)는 매우 강력한 안전성 증명을 가지고 있지만, 실용상 치명적인 약점이 있습니다. 그것은 ‘키의 크기가 거대해진다는 것’과 ‘계산 비용이 높다는 것’입니다.

Standard LWE에서는 공개키에 거대한 행렬 $A \in \mathbb{Z}_q^{m \times n}$이 포함됩니다. 파라미터 $n$이 수백에서 수천이 되면 이 행렬의 크기는 수 메가바이트에 달해, 인터넷 상의 통신 프로토콜(TLS 등)에서 매번 송수신하기에는 너무 무겁습니다. 또한 행렬과 벡터의 곱셈에는 $\mathcal{O}(n^2)$의 계산량이 듭니다.

이 문제를 해결하기 위해 도입된 것이 다항식 환(Polynomial rings)이라는 대수적인 구조를 격자에 결합한 ‘Ring-LWE(RLWE)‘나 ‘Module-LWE(MLWE)‘입니다.

7.1 Ring-LWE의 직관

Ring-LWE에서는 벡터나 행렬을 다항식 환 $\mathcal{R}_q = \mathbb{Z}_q[X]/(X^n + 1)$ 상의 요소(다항식)로 대체합니다. (여기서 $n$은 2의 거듭제곱으로 선택됩니다).

Standard LWE의 공개키가 행렬 $A$였던 것에 반해, Ring-LWE에서는 단일 다항식 $a(x)$를 사용합니다. 비밀키 $s(x)$나 오차 $e(x)$도 다항식이 됩니다. 방정식은 다음과 같이 됩니다.

$$ b(x) = a(x) \cdot s(x) + e(x) \pmod q $$

이는 다항식의 곱셈이므로 고속 푸리에 변환(FFT)과 유사한 ‘수론 변환(Number Theoretic Transform: NTT)‘을 사용함으로써 계산량을 $\mathcal{O}(n \log n)$까지 극적으로 줄일 수 있습니다. 게다가 공개키의 크기도 행렬에서 단일 다항식으로 작아지기 때문에 데이터 크기가 $\mathcal{O}(n)$으로 감소합니다. 이는 통신 대역폭에 있어서 압도적인 우위를 가져옵니다.

수학적으로 보면, Ring-LWE는 일반적인 격자가 아니라 ‘아이디얼 격자(Ideal Lattice)‘라고 불리는 특수한 대칭성을 가진 격자 상의 문제로 귀결됩니다.

7.2 Module-LWE와 NIST의 표준화 (Kyber / ML-KEM)

Ring-LWE는 효율적이지만, 아이디얼 격자의 특수한 대수적 구조가 장래의 공격 실마리가 되지 않을까 하는 일말의 우려가 있었습니다. 그래서 Standard LWE의 보수적인 안전성과 Ring-LWE의 효율성의 ‘장점만을 취한’ 것이 ‘Module-LWE(MLWE)‘입니다.

Module-LWE에서는 다항식을 요소로 하는 작은 행렬과 벡터를 생각합니다. 즉, 환 상의 모듈(가군)을 다룹니다. 현재 NIST가 PQC의 키 캡슐화 메커니즘(KEM) 표준으로 선정한 ‘CRYSTALS-Kyber’(표준화 명칭: ML-KEM)는 바로 이 Module-LWE 문제의 어려움에 기반하여 구축되어 있습니다.

8. 왜 양자 컴퓨터에 대해 안전한가?

마지막으로, ‘왜 격자 암호는 양자 컴퓨터를 사용해도 해독되지 않는다고 여겨지는가?‘라는 핵심 부분을 짚고 넘어가겠습니다.

양자 컴퓨터가 RSA 암호나 타원곡선암호를 깨는 쇼어 알고리즘은 본질적으로 ‘은닉 부분군 문제(Hidden Subgroup Problem: HSP)‘를 푸는 알고리즘입니다. RSA나 ECC의 배경에 있는 수학적 구조(유한 아벨 군)는 주기성을 가지고 있으며, 양자 푸리에 변환(QFT)이라는 양자 알고리즘 특유의 조작을 사용함으로써 이 주기(숨겨진 부분군)를 단번에 추출할 수 있습니다.

그러나 격자 문제는 근본적으로 다릅니다. 격자에도 주기성은 있지만, SVP나 CVP에서 요구되는 것은 ‘최단 거리’나 ‘노이즈 제거’라는 기하학적이고 비선형적인 성질입니다. 쇼어 알고리즘과 같은 ‘아벨 군 상의 양자 푸리에 변환’을 그대로 적용하더라도 격자 문제의 해답이 되는 유용한 정보를 효율적으로 추출할 수 없습니다. 현재까지 SVP나 LWE에 대해 다항식 시간에 풀 수 있는 양자 알고리즘은 발견되지 않았으며, 양자 컴퓨터의 병렬 계산 능력을 동원하더라도 무차별 대입에 가까운 탐색(그로버 알고리즘에 의한 제곱근 수준의 고속화 정도)만이 유효한 수단이라고 널리 믿어지고 있습니다.

9. 요약

본 기사에서는 격자 암호의 수학적 직관에 대해 격자의 기하학적 정의부터 시작하여 LWE 문제의 정식화, 그리고 공개키 암호의 구성에 이르기까지 상세히 해설했습니다.

격자(Lattice) 는 기저 벡터의 정수 계수 선형 결합으로 표현되는 이산적인 공간이며, 고차원에서는 직교에 가까운 ‘좋은 기저’를 찾는 것(SVP)이 어려워집니다.
LWE 문제(Learning With Errors) 는 노이즈가 포함된 연립 일차 방정식을 푸는 문제이며, 이것이 격자의 최악의 경우 문제의 어려움에 연결되어 있기 때문에 강력한 안전성의 근거를 제공합니다.
LWE 문제를 이용함으로써 노이즈를 의도적으로 더하거나 소거하는 교묘한 메커니즘을 통해 암호화 및 복호화(레게브 암호)가 실현됩니다.
실제 프로토콜에서는 통신 효율과 계산 속도를 높이기 위해 다항식 환을 사용한 Ring-LWE나 Module-LWE가 채택되고 있으며, NIST 표준인 ML-KEM의 기반이 되고 있습니다.

양자 컴퓨터라는 전대미문의 계산 패러다임 시프트가 다가오는 가운데, 고전적인 선형대수와 정수론의 심연에서 탄생한 ‘격자 암호’가 미래 인터넷 보안의 기반을 담당한다는 것은 매우 낭만적인 이야기입니다. 격자 암호의 기초가 되는 수학은 결코 너무 난해한 것이 아니며, 선형대수와 확률에 대한 기초 지식이 있다면 충분히 그 아름다운 구조를 이해할 수 있습니다. 본 기사가 PQC의 핵심이 되는 격자 암호에 대한 이해에 도움이 되기를 바랍니다.

영지식 증명(ZKP)의 구조와 최신 Web3 및 보안에의 응용

Fri, 11 Sep 2026 19:00:00 +0900

들어가며

현대 디지털 사회에서 데이터 프라이버시와 확장성(scalability)은 가장 중요한 두 가지 과제가 되었습니다. 개인정보 유출이나 부정 사용의 위험이 높아지는 가운데, “자신에 관한 정보를 상대방에게 밝히지 않고 자신이 그 정보를 가지고 있음을 증명하는” 기술이 강력하게 요구되고 있습니다. 이를 실현하는 것이 **영지식 증명(Zero-Knowledge Proof: ZKP)**입니다.

영지식 증명은 1980년대에 Shafi Goldwasser, Silvio Micali, Charles Rackoff에 의해 처음 제창된 암호 이론의 개념이지만, 오랫동안 이론적인 연구에 머물러 있었습니다. 그러나 블록체인 기술과 Web3의 대두로 상황은 완전히 바뀌었습니다. 이더리움(Ethereum) 등의 퍼블릭 블록체인이 직면한 확장성 문제(처리 능력의 한계)와 프라이버시 문제(모든 트랜잭션이 공개되는 것)를 동시에 해결하는 “마법의 지팡이"로서 ZKP는 일약 각광받게 되었습니다.

본 기사에서는 영지식 증명의 기본적인 개념부터 현재 주류를 이루고 있는 zk-SNARKs 및 zk-STARKs의 심오한 수학적·암호학적 메커니즘, 그리고 ZK-Rollups나 분산형 신원 증명(DID)과 같은 최신 Web3·보안 응용 사례에 이르기까지 매우 상세하고 기술적으로 깊이 있게 해설합니다.

영지식 증명(ZKP)이란 무엇인가?

영지식 증명(ZKP)이란 어떤 명제가 참이라는 것을 증명자(Prover)가 검증자(Verifier)에게 증명할 때, “그 명제가 참이라는 것 이외의 어떠한 정보도 전달하지 않는” 프로토콜을 뜻합니다.

ZKP가 충족해야 할 3가지 요건

ZKP로 성립하기 위해서는 다음의 3가지 특성을 엄밀하게 충족해야 합니다.

완전성 (Completeness) 명제가 참이고 증명자와 검증자 양측이 올바르게 프로토콜을 따른다면, 검증자는 압도적인 확률로 그 증명을 수락(Accept)해야 합니다.
건전성 (Soundness) 명제가 거짓이라면, 아무리 계산 능력이 뛰어나고 악의적인 증명자라 할지라도 검증자를 속여 증명을 수락하게 만드는 것은 (무시할 수 있을 정도로 작은 확률을 제외하고) 불가능합니다.
영지식성 (Zero-Knowledge) 명제가 참인 경우, 검증자는 “명제가 참이다"라는 사실 이외의 어떠한 정보도 증명 과정에서 얻을 수 없습니다. 검증자의 관점에서 보면, 증명 과정을 시뮬레이션하는 것이 가능하다(시뮬레이터가 존재한다)는 수학적 정의에 의해 증명됩니다.

대화형 증명과 비대화형 증명

ZKP에는 증명자와 검증자가 여러 번 통신을 주고받는 **대화형 증명(Interactive ZKP)**과 증명자가 한 번만 증명 데이터를 전송하고 끝나는 **비대화형 증명(Non-Interactive ZKP)**의 두 종류가 존재합니다.

대화형 증명 (Interactive ZKP)

초기의 ZKP는 대화형 프로토콜로 설계되었습니다. 유명한 “알리바바의 동굴” 비유가 이에 해당합니다. 일반적인 프로토콜의 흐름은 다음과 같습니다.

sequenceDiagram participant Prover as "Prover (증명자)" participant Verifier as "Verifier (검증자)" Note over Prover, Verifier: "대화형 증명 프로토콜의 기본 흐름" Prover->>Verifier: "1. 커미트먼트 전송 (Commitment)" Verifier->>Prover: "2. 무작위 챌린지 전송 (Challenge)" Prover->>Verifier: "3. 응답 계산 및 전송 (Response)" Note over Verifier: "응답 검증 (Verification)" Verifier-->>Prover: "4. 수락 또는 거부 (Accept / Reject)" Note over Prover, Verifier: "※정확도를 높이기 위해 이를 수십 번 반복함"

이 방법은 강력하지만, 검증자가 온라인 상태여야 하므로 블록체인과 같은 비동기적인 분산 시스템에 적용하기에는 불편합니다. 블록체인에서는 누구나 언제든지 과거의 증명을 검증할 수 있어야 합니다.

피아트-샤미르 변환과 비대화화

대화형 증명을 비대화형 증명(Non-Interactive Zero-Knowledge Proof: NIZK)으로 변환하기 위한 획기적인 기법이 바로 **피아트-샤미르 변환(Fiat-Shamir Heuristic)**입니다.

검증자가 전송하는 “무작위 챌린지” 대신, 증명자가 자신의 커미트먼트와 공개 정보의 해시값을 사용하여 “유사 무작위 챌린지"를 스스로 생성합니다. 암호학적 해시 함수(예: SHA-256이나 Keccak 등)가 랜덤 오라클로 기능한다는 전제하에, 증명자는 챌린지를 사전에 예측하거나 조작할 수 없으며, 대화형 증명과 동등한 보안성을 유지한 채 단 한 번의 메시지 전송으로 증명을 완료할 수 있습니다.

zk-SNARKs의 기술적 세부 사항

현재 ZKP 중에서 가장 널리 사용되는 것이 zk-SNARKs(Zero-Knowledge Succinct Non-Interactive Argument of Knowledge)입니다. 이름 그대로 영지식성(zk)을 가지며, 증명 크기가 매우 작고 검증이 빠르며(Succinct), 비대화형(Non-Interactive)인 지식의 논증(Argument of Knowledge)입니다.

zk-SNARKs의 기반이 되는 것은 고도의 대수기하학과 암호 이론입니다. 프로그램의 실행이나 계산을 특정 다항식의 방정식 검증으로 변환합니다.

1. 산술 회로와 R1CS(Rank-1 Constraint System)로의 변환

먼저, 증명하고자 하는 임의의 계산(알고리즘이나 스마트 컨트랙트의 로직)을 덧셈 게이트와 곱셈 게이트로 이루어진 **산술 회로(Arithmetic Circuit)**로 변환합니다.

다음으로, 이 산술 회로를 **R1CS(Rank-1 Constraint System)**라는 행렬 방정식의 집합으로 변환합니다. R1CS는 변수 벡터 $x$에 대해 다음과 같은 제약을 만족하는 행렬 $A, B, C$를 찾는 문제입니다.

$$ (A \cdot x) \circ (B \cdot x) = C \cdot x $$

여기서 $\circ$는 아다마르 곱(요소별 곱)을 나타냅니다. 이 제약은 회로 내의 모든 논리 게이트(특히 곱셈 게이트)가 올바르게 계산되었음을 보장합니다.

2. QAP(Quadratic Arithmetic Program)로의 변환

R1CS의 행렬 제약은 무수히 존재하기 때문에 이를 개별적으로 검증하는 것은 매우 비효율적입니다. 따라서 라그랑주 보간법을 사용하여 이러한 제약들을 단일 다항식 방정식으로 압축합니다. 이것이 **QAP(Quadratic Arithmetic Program)**입니다.

QAP로의 변환을 통해 증명해야 할 문제는 “특정 다항식 $P(x)$가 미리 알려진 다른 다항식 $Z(x)$로 나누어 떨어지는가?“라는 문제로 귀결됩니다.

$$ P(x) = L(x) \cdot R(x) - O(x) $$

여기서 $L(x), R(x), O(x)$는 각각 행렬 $A, B, C$의 각 행에 해당하는 다항식을 결합한 것입니다. 만약 증명자가 올바른 해(Witness)를 알고 있다면, $P(x)$의 각 근(평가점)에서 값이 0이 되므로 $P(x)$는 타깃 다항식 $Z(x)$를 인수로 갖게 됩니다. 즉, 어떤 다항식 $H(x)$가 존재하여 다음 식이 성립합니다.

$$ P(x) = H(x) \cdot Z(x) $$

검증자는 어떤 무작위의 비밀 점 $s$에서 이 방정식 $P(s) = H(s) \cdot Z(s)$가 성립하는지 확인하는 것만으로 계산 전체가 올바르게 수행되었는지를 순식간에 검증할 수 있습니다. 이것이 “간결성(Succinct)“의 비밀입니다.

3. 타원 곡선 암호와 페어링 (Bilinear Pairings)

그러나 검증자가 비밀 점 $s$를 알고 있다면 증명자가 가짜 다항식을 날조하여 방정식을 만족시키는 것이 가능해집니다(건전성의 붕괴). 따라서 $s$를 아무도 알 수 없게 암호화(동형 암호를 이용)한 상태에서 계산을 수행해야 합니다.

이를 실현하는 것이 **타원 곡선 페어링(Bilinear Pairings)**입니다. 페어링 $e$는 암호화된 두 값으로부터 이들의 곱을 암호화한 것에 해당하는 값을 계산할 수 있는 특수한 함수입니다.

$$ e(g_1^a, g_2^b) = e(g_1, g_2)^{ab} $$

증명자는 $s$ 자체를 모르더라도 $s$의 거듭제곱이 암호화된 값(이를 CRS: Common Reference String이라 부릅니다)을 사용하여 다항식 $P(s)$나 $H(s)$의 암호화된 값을 계산합니다. 검증자는 페어링 함수를 사용하여 암호화된 값 상태 그대로 $P(s) = H(s) \cdot Z(s)$의 관계가 성립하는지를 검증합니다.

4. 신뢰할 수 있는 설정 (Trusted Setup)

zk-SNARKs(특히 초기의 Groth16 등)의 가장 큰 약점은 비밀 점 $s$를 생성하는 과정, 이른바 **신뢰할 수 있는 설정(Trusted Setup)**이 필요하다는 점입니다. 만약 $s$의 생성자가 그 값을 파기하지 않고 보유하고 있다면 임의의 가짜 증명을 생성할 수 있게 됩니다(Toxic Waste 문제).

이를 방지하기 위해 다자간 컴퓨팅(Multi-Party Computation: MPC)을 활용한 “세리머니(Ceremony)“라는 의식이 진행됩니다. 다수의 참여자가 협력하여 무작위성을 제공하고, 적어도 1명의 참여자가 정직하게 자신의 무작위 값을 파기한다면 시스템 전체의 보안이 유지되는 구조입니다. 그러나 이러한 의존성을 제거하기 위한 연구가 오랫동안 계속되어 왔습니다.

zk-STARKs의 기술적 세부 사항

신뢰할 수 있는 설정에 대한 의존성과 양자 컴퓨터에 의한 타원 곡선 암호 해독 위험에 대한 해답으로 등장한 것이 zk-STARKs(Zero-Knowledge Scalable Transparent Argument of Knowledge)입니다.

Eli Ben-Sasson 등이 개발한 STARKs는 “투명성(Transparent)“이라는 이름대로 신뢰할 수 있는 설정이 전혀 필요하지 않으며, “확장성(Scalable)“이라는 이름대로 계산량이 증가해도 증명 크기와 검증 시간이 효율적으로 유지된다는 특징을 가지고 있습니다.

1. 다항식 커미트먼트와 FRI 프로토콜

zk-STARKs는 타원 곡선 암호가 아닌, 해시 함수에만 보안의 근거를 두고 있습니다. 따라서 양자 내성 암호(Post-Quantum Cryptography)로서의 성질을 가집니다.

계산의 검증은 AIR(Algebraic Intermediate Representation)라는 형식으로 변환된 후, 1차원 또는 다차원 다항식의 성질을 이용하여 수행됩니다. STARKs의 핵심은 FRI(Fast Reed-Solomon Interactive Oracle Proof of Proximity) 프로토콜에 있습니다.

FRI 프로토콜은 “어떤 함수가 특정 차수의 다항식에 충분히 가까운가(Proximity)“를 검증하는 기술입니다. 증명자는 다항식의 값을 머클 트리(Merkle Tree)의 리프(leaf)로 커밋(다항식 커미트먼트)합니다.

graph TD Root["Merkle Root (커미트먼트)"] --> Node0["Node 0"] Root --> Node1["Node 1"] Node0 --> Leaf0["P(x_0)"] Node0 --> Leaf1["P(x_1)"] Node1 --> Leaf2["P(x_2)"] Node1 --> Leaf3["P(x_3)"]

검증자는 무작위로 몇 개의 점을 공개하도록 요구하고, 머클 프루프(Merkle Proof)를 사용하여 그것들이 커미트먼트에 포함되어 있는지 확인합니다. 이를 재귀적으로 반복함으로써 원래 다항식의 차수가 실제로 낮다는 것을 압도적인 확률로 보장합니다.

zk-SNARKs와 zk-STARKs의 비교

특징	zk-SNARKs	zk-STARKs
암호학적 가정	타원 곡선, 페어링	충돌 저항성 해시 함수
신뢰할 수 있는 설정	필요 (Plonk 등은 범용적)	불필요 (Transparent)
양자 내성	없음	있음
증명 크기	매우 작음 (~200 Byte)	다소 큼 (수십 KB)
증명 생성의 계산 비용	높음	SNARKs보다 비교적 낮음
검증 비용 (가스비)	매우 낮음 (일정함)	낮음 (대수적으로 증가)

최근에는 Plonk나 Halo2처럼 “신뢰할 수 있는 설정이 불필요하거나, 한 번만 수행하면 되는 SNARKs"가 등장하면서 SNARKs와 STARKs의 경계가 점차 모호해지고 있지만, 기본적인 수학적 접근 방식의 차이는 중요합니다.

영지식 증명의 Web3 및 보안에의 최신 응용

이론에서 실전으로 넘어온 ZKP는 현재 Web3와 사이버 보안의 최전선에서 혁명을 일으키고 있습니다.

1. ZK-Rollups를 통한 이더리움의 궁극적 스케일링

이더리움과 같은 L1(레이어1) 블록체인은 탈중앙화와 보안을 중시한 나머지 확장성에 큰 제약(트릴레마)을 안고 있습니다. 이를 해결하는 L2(레이어2) 솔루션의 결정판이 ZK-Rollups입니다.

ZK-Rollup에서는 수천 개의 트랜잭션을 오프체인(L2)에서 실행 및 처리하고, 그것들이 모두 올바르게 실행되었음을 나타내는 “하나의 ZKP(Validity Proof)“를 생성합니다. L1 체인 상의 스마트 컨트랙트는 이 증명만 검증하면 됩니다.

flowchart LR Users["Users (Tx 송신)"] --> Sequencer["Sequencer (Tx 수집 및 실행)"] Sequencer --> Prover["Prover (ZKP 생성)"] Sequencer --> L1Contract["L1 Smart Contract (Tx 데이터 공개)"] Prover --> L1Contract["ZKP (증명) 제출"] L1Contract --> Verify["검증 및 상태 업데이트"]

ZK-Rollups의 가장 큰 장점은 Optimistic Rollups(Arbitrum이나 Optimism 등)와 달리, 사기 증명(Fraud Proof)을 위한 챌린지 기간(보통 7일)이 불필요하다는 점입니다. 암호학적으로 정확성이 보장되어 있기 때문에 증명이 검증되는 순간 L1으로의 자금 인출(Finality)이 완료됩니다. 현재 zkSync, Starknet, Scroll, Polygon zkEVM 등의 프로젝트가 치열한 개발 경쟁을 펼치고 있으며, EVM(Ethereum Virtual Machine)과 호환성을 가지는 zkEVM의 구현이 생태계를 급성장시키고 있습니다.

2. 개인정보 보호 신원 증명 (ZKP for Identity)

디지털 세계에서의 개인 인증 방식도 ZKP에 의해 근본적으로 바뀝니다. 예를 들어, “당신은 18세 이상입니까?“라는 질문에 대해 기존 시스템에서는 운전면허증이나 여권을 제시하여 이름이나 주소와 같은 불필요한 개인정보까지 상대방에게 넘겨주어야 했습니다.

ZKP를 사용하면 공공기관이 발급한 디지털 인증서(Verifiable Credential)를 바탕으로, “내 생년월일로 계산했을 때 현재 날짜 기준으로 18세 이상이다"라는 사실만을 수학적으로 증명하는 것이 가능해집니다. 검증자는 인증서의 서명과 ZKP를 검증하기만 하면 되며, 사용자의 생년월일이나 신원을 알 수 없습니다.

Worldcoin과 같은 인류 증명(Proof of Personhood) 프로젝트에서도 홍채 데이터를 직접 저장하거나 공유하지 않고, ZKP를 사용하여 “고유한 인간임"만을 증명하는 시스템이 도입되어 있습니다.

3. 기밀 스마트 컨트랙트와 기업 활용

퍼블릭 블록체인의 “모든 데이터가 공개된다"는 특성은 기업이 기밀 거래나 공급망 정보를 블록체인에서 다룰 때 큰 장벽이었습니다.

ZKP 기술(예: Aleo나 Aztec 같은 프라이버시 특화 네트워크)을 사용하면 트랜잭션의 입력값, 출력값, 나아가 실행되는 스마트 컨트랙트의 로직 자체를 암호화한 채 상태 업데이트의 정당성만을 퍼블릭 체인에 기록할 수 있습니다. 이를 통해 DeFi(탈중앙화 금융)에서의 선행 매매(Front-running, MEV) 방지나 기업 간의 기밀 컨소시엄 네트워크 구축이 퍼블릭 체인의 높은 보안을 누리면서도 실현 가능해집니다.

ZKP의 향후 과제와 전망

ZKP는 틀림없는 차세대 기반 기술이지만, 몇 가지 과제도 남아 있습니다.

증명 생성의 계산 비용과 하드웨어 가속 ZKP의 생성에는 방대한 다항식 연산이나 FFT(고속 푸리에 변환), MSM(다중 스칼라 곱셈)이 필요합니다. 현재 이 증명 생성을 가속하기 위한 전용 하드웨어(FPGA나 ASIC)의 개발, 이른바 ZKP 마이닝(Prover Network) 연구가 빠르게 진행되고 있습니다.
표준화와 개발자 경험(DX) 향상 Circom, Cairo, Noir, Leo 등 ZKP 회로를 작성하기 위한 전용 언어가 난립하고 있습니다. 이들을 통일하는 표준 규격이나 기존의 Rust나 C++에서 자동으로 ZKP 회로를 생성하는 컴파일러의 성숙이 일반 소프트웨어 엔지니어들의 ZKP 도입에 핵심이 될 것입니다.

마무리

영지식 증명(ZKP)은 단순한 “암호화폐의 익명성을 높이는 기술"에서 “인터넷 전체의 신뢰(Trust)를 재정의하는 범용 기술"로 진화했습니다. 수식과 암호 이론의 깊은 곳에서 계산된 작은 증명이 블록체인의 확장성을 무한히 넓히고 우리의 프라이버시를 강력하게 지키는 방패가 됩니다.

Web3의 진정한 대중화(Mass Adoption), 그리고 안전하고 프라이빗한 차세대 인터넷 구축을 향해 영지식 증명은 가장 중요한 퍼즐 조각으로 계속 기능할 것입니다. 앞으로의 ZKP 기술 진화에서 눈을 뗄 수 없습니다.

참고 문헌 및 관련 링크

Groth, J. (2016). “On the Size of Pairing-based Non-interactive Arguments”
Ben-Sasson, E., et al. (2018). “Scalable, transparent, and post-quantum secure computational integrity”
Vitalik Buterin’s blog on zk-SNARKs and zk-STARKs

리만 가설과 소수의 분포: 현대 암호 기술과의 깊은 관계

Fri, 11 Sep 2026 16:00:00 +0900

1. 서론: 소수라는 우주의 신비와 리만 가설

‘소수(Prime Numbers)‘는 1과 자기 자신으로만 나누어 떨어지는 자연수이며, 수학 세계에서 ‘원자’라고도 불립니다. 2, 3, 5, 7, 11, 13… 으로 이어지는 이 수열은 언뜻 보면 무질서하고 무작위로 나타나는 것처럼 보입니다. 고대 그리스의 수학자 유클리드가 ‘소수가 무한히 존재한다’는 것을 증명한 이후, 수많은 수학자들이 이 소수의 배열에 숨겨진 규칙성을 밝혀내기 위해 도전해 왔습니다.

그 소수의 수수께끼에 가장 근접한 것이 1859년 독일의 수학자 베른하르트 리만(Bernhard Riemann)이 제안한 **‘리만 가설(Riemann Hypothesis)’**입니다. 리만 가설은 현대 수학에서 가장 중요하고 미해결된 난제 중 하나이며, 클레이 수학연구소가 정한 밀레니엄 현상 문제 중 하나로 100만 달러의 상금이 걸려 있습니다.

언뜻 보기에 소수의 분포에 관한 순수 수학의 난제는 우리의 일상생활과는 무관해 보일지도 모릅니다. 하지만 현대 사회의 인프라를 지탱하는 인터넷 보안, 특히 RSA 암호나 타원곡선암호(ECC) 같은 현대 암호 기술은 거대한 소수의 성질에 깊이 의존하고 있습니다.

이 글에서는 소수의 분포에서 소수 정리, 리만 제타 함수, 그리고 리만 가설의 핵심에 이르는 수학적 여정을 떠나며, 그것이 어떻게 현대 암호 기술과 연결되어 있는지, 그리고 만약 리만 가설이 증명된다면 세상은 어떻게 될지에 대해 매우 상세하고 깊이 있게 파헤쳐 설명합니다.

2. 소수 정리와 소수의 분포: 가우스의 발견

소수가 어떻게 분포되어 있는지를 이해하기 위해, 수학자들은 ‘어떤 수 $x$ 이하의 소수가 몇 개 존재하는가’를 나타내는 소수 계수 함수(Prime-counting function) $\pi(x)$ 를 고안했습니다.

예를 들어:

$\pi(10) = 4$ (2, 3, 5, 7)
$\pi(100) = 25$
$\pi(1000) = 168$

15세의 천재 수학자 카를 프리드리히 가우스(Carl Friedrich Gauss)는 방대한 소수표를 계산하여 소수의 출현 빈도가 자연로그 $\ln x$ 에 반비례하여 감소해 나간다는 것을 발견했습니다. 즉, 어떤 수 $x$ 근처에서 소수가 발견될 확률은 약 $\frac{1}{\ln x}$ 일 것이라고 예상한 것입니다.

이것을 적분을 사용하여 표현한 것이 로그 적분(Logarithmic integral) $\text{Li}(x)$ 입니다.

$$ \text{Li}(x) = \int_{2}^{x} \frac{dt}{\ln t} $$

가우스의 예상은 훗날 1896년 자크 아다마르와 샤를 장 드 라 발레 푸생에 의해 독립적으로 증명되었고, **소수 정리(Prime Number Theorem, PNT)**로서 확립되었습니다.

$$ \lim_{x \to \infty} \frac{\pi(x)}{\text{Li}(x)} = 1 $$

또는 근사적으로 다음과 같이 표현됩니다.

$$ \pi(x) \sim \frac{x}{\ln x} $$

이 정리에 의해, 소수는 거시적으로 보면 매우 매끄럽고 예측 가능한 분포를 가지고 있다는 것을 알게 되었습니다. 하지만 미시적으로 보면 $\pi(x)$ 와 $\text{Li}(x)$ 사이에는 항상 ‘오차’, 즉 ‘요동(fluctuation)‘이 존재합니다. 이 요동의 실체야말로 리만 가설이 밝혀내고자 하는 가장 큰 미스터리인 것입니다.

3. 리만 제타 함수와 오일러 곱

소수의 분포를 분석하는 데 있어 가장 강력한 무기가 되는 것이 **리만 제타 함수(Riemann Zeta Function)**입니다. 원래는 레온하르트 오일러(Leonhard Euler)에 의해 실수 $s > 1$ 에 대해 정의된 무한급수였습니다.

$$ \zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s} = 1 + \frac{1}{2^s} + \frac{1}{3^s} + \frac{1}{4^s} + \dots $$

오일러의 가장 큰 업적 중 하나는, 이 무한급수가 모든 소수 $p$ 에 대한 무한곱으로 표현될 수 있음을 증명한 것입니다. 이것이 **오일러 곱(Euler Product Formula)**입니다.

$$ \zeta(s) = \prod_{p \text{ prime}} \frac{1}{1 - p^{-s}} = \left( \frac{1}{1 - 2^{-s}} \right) \left( \frac{1}{1 - 3^{-s}} \right) \left( \frac{1}{1 - 5^{-s}} \right) \dots $$

증명의 직관적인 이해는 우변의 각 항을 등비급수로 전개하고 그것들을 곱하면, 산술의 기본 정리(모든 자연수는 소수의 곱으로 유일하게 표현된다)에 의해 좌변의 자연수의 역수 합이 완전히 재구성된다는 것입니다.

이 단 하나의 수식이 해석학(무한급수·연속함수)과 정수론(소수·이산적인 수)을 연결하는 다리가 되었습니다. 제타 함수를 조사하는 것은 소수의 분포를 조사하는 것과 같은 의미입니다.

4. 해석적 연속과 복소평면으로의 확장

리만의 천재성은 오일러가 실수로만 생각했던 $\zeta(s)$ 의 변수 $s$ 를 **복소수 $s = \sigma + it$($\sigma$ 는 실수부, $t$ 는 허수부)**로 확장한 데 있습니다.

원래의 무한급수는 $\sigma > 1$ 에서만 수렴하지만, 리만은 ‘해석적 연속(Analytic Continuation)‘이라는 기법을 사용하여 $s = 1$ 의 극을 제외한 전체 복소평면상에서 $\zeta(s)$ 가 의미를 갖도록 정의를 확장했습니다.

그는 더 나아가 제타 함수가 만족하는 아름다운 함수 방정식(Functional equation)을 이끌어냈습니다.

$$ \zeta(s) = 2^s \pi^{s-1} \sin\left(\frac{\pi s}{2}\right) \Gamma(1-s) \zeta(1-s) $$

여기서 $\Gamma(x)$ 는 감마 함수입니다. 이 방정식에 의해 우반평면의 성질로부터 좌반평면의 성질을 알 수 있습니다.

영점(Zeros of the Zeta Function)

제타 함수의 값이 0이 되는 복소수 $s$ 를 ‘영점’이라고 부릅니다. 함수 방정식에서 $s$ 가 음의 짝수($-2, -4, -6, \dots$)일 때 $\sin(\pi s / 2)$ 가 0이 되므로, $\zeta(s) = 0$ 이 됩니다. 이것들은 **자명한 영점(Trivial zeros)**이라고 불립니다.

그러나 소수의 분포에서 중요한 것은 그 외의 영점, 즉 $0 \le \sigma \le 1$ 인 ‘임계 영역(Critical strip)‘에 존재하는 **비자명한 영점(Non-trivial zeros)**입니다.

5. 리만 가설의 핵심과 명시 공식

리만은 소수의 영점을 계산하고 어떤 놀라운 가설을 세웠습니다. 이것이 리만 가설입니다.

리만 가설 (Riemann Hypothesis) 리만 제타 함수 $\zeta(s)$ 의 비자명한 영점은 모두 실수부가 $1/2$ 인 직선상($\text{Re}(s) = 1/2$)에 존재한다.

이 실수부가 1/2인 직선을 ‘임계선(Critical line)‘이라고 부릅니다.

graph TD A["리만 제타 함수 ζ(s)"] --> B["해석적 연속을 통한 복소평면으로의 확장"] B --> C["자명한 영점 (s = -2, -4, -6 ...)"] B --> D["비자명한 영점 (0 <= Re(s) <= 1)"] D --> E["리만 가설"] E --> F["모든 비자명한 영점은 Re(s) = 1/2 상에 있다"] F --> G["소수 분포의 오차항 극한 증명으로"]

왜 리만 가설이 그토록 중요한 것일까요? 그것은 제타 함수의 영점이 소수의 분포를 완전히 결정하고 있기 때문입니다.

리만과 후대의 수학자 폰 망골트(von Mangoldt)는 소수의 분포를 정확하게 기술하는 ‘명시 공식(Explicit formula)‘을 도출했습니다. 체비쇼프 함수 $\psi(x)$ 를 사용하면 다음과 같이 표현됩니다.

$$ \psi(x) = x - \sum_{\rho} \frac{x^\rho}{\rho} - \ln(2\pi) - \frac{1}{2}\ln(1 - x^{-2}) $$

여기서 $\rho$ 는 제타 함수의 모든 비자명한 영점을 지나는 합입니다. 주항은 $x$ (이것은 소수 정리에 대응)이며, 거기서 영점 $\rho$ 에 의존하는 파동 같은 항을 더하고 뺌으로써 소수의 계단형태의 정확한 분포가 복원되는 것입니다. 비자명한 영점은 소수 분포의 ‘주파수(파동)‘를 나타낸다고 할 수 있습니다.

만약 리만 가설이 맞고, 모든 비자명한 영점 $\rho$ 의 실수부가 정확히 $1/2$ 이라면, 소수 정리의 오차항은 이론상 상상할 수 있는 최소 범위 내에 수렴하게 됩니다.

$$ |\pi(x) - \text{Li}(x)| \le \frac{1}{8\pi} \sqrt{x} \ln x \quad \text{for} \quad x \ge 2657 $$

즉, 리만 가설이 참이라면, 소수는 우리가 상상할 수 있는 한 가장 ‘규칙적이고 아름답게’ 분포하고 있다는 것이 증명되는 것입니다.

6. 현대 암호 기술과 소수의 불가분한 관계

여기까지는 심오한 순수 수학의 세계였지만, 이 소수의 성질은 현대의 디지털 사회를 근본적으로 지탱하고 있습니다. 그 대표적인 예가 RSA 암호를 비롯한 공개키 암호 방식입니다.

인터넷에서의 신용카드 결제, 비밀번호 전송, 블록체인의 전자 서명 등 모든 통신의 안전성은 ‘소수’에 의존하고 있습니다.

RSA 암호의 원리

RSA 암호의 안전성은 ‘자릿수가 큰 합성수의 소인수분해는 매우 어렵다’는 수학적 사실(소인수분해 문제)에 기반하고 있습니다.

키 생성: 거대한 소수 $p$ 와 $q$ (예를 들어 각각 2048비트)를 무작위로 선택합니다. 이들을 곱하여 $N = p \times q$ 를 계산합니다. 이 $N$ 이 공개키의 일부가 됩니다. 오일러의 파이 함수 $\phi(N) = (p-1)(q-1)$ 을 사용하여 개인키 $d$ 를 생성합니다.
$$ e \times d \equiv 1 \pmod{\phi(N)} $$
암호화와 복호화: 평문 $M$ 은 공개키 $e, N$ 을 사용하여 암호문 $C$ 로 변환됩니다.
$$ C \equiv M^e \pmod{N} $$
개인키 $d$ 를 가진 사람만이 복호화할 수 있습니다.
$$ M \equiv C^d \pmod{N} $$

graph LR A["평문 (Plaintext)"] --> B["공개키(e, N)로 암호화"] B --> C["암호문 (Ciphertext)"] C --> D["개인키(d)로 복호화"] D --> E["원래의 평문"] F["공격자 (Attacker)"] -- "N의 소인수분해를 시도" --> C F -.-> G["p와 q를 모르면 d는 계산 불가"]

RSA 암호를 깨기 위해서는 거대한 $N$ 에서 원래의 소수 $p$ 와 $q$ 를 찾아내야(소인수분해해야) 합니다. 현재 주류인 알고리즘(일반 수체 체: GNFS 등)을 사용하더라도, 수백 자리의 수를 소인수분해하려면 슈퍼컴퓨터를 사용해도 우주의 나이를 훨씬 초과하는 시간이 걸리는 것으로 알려져 있습니다.

7. 리만 가설이 암호 기술에 미치는 영향

그렇다면 순수 수학의 정점에 있는 ‘리만 가설’과 ‘암호 기술’은 어떻게 교차하는 것일까요?

7.1. 소수 생성 알고리즘(소수 판별)과 일반화된 리만 가설(GRH)

RSA 암호를 운용하기 위해서는 먼저 거대한 소수 $p$ 와 $q$ 를 생성해야 합니다. 하지만 ‘어떤 수가 소수인지’를 확실하고 빠르게 판별하는 것은 쉽지 않습니다.

현재 실용적으로 사용되고 있는 것은 **밀러-라빈 소수 판별법(Miller-Rabin primality test)**이라는 확률적 알고리즘입니다. 이 알고리즘은 매우 빠르지만, 아주 낮은 확률로 합성수를 소수라고 잘못 판별하는 ‘유사소수’의 위험이 있습니다.

하지만 리만 가설을 디리클레 L-함수로 확장한 **‘일반화된 리만 가설(Generalized Riemann Hypothesis, GRH)’**이 참이라고 가정하면 이야기는 극적으로 달라집니다. GRH가 참이라면, 밀러-라빈 판별법에서의 테스트 횟수 상한이 수학적으로 보장되어 확률적 알고리즘에서 ‘결정론적 다항 시간 알고리즘’으로 승화하는 것입니다(이는 AKS 소수 판별법이 발견되기 이전부터 알려져 있던 중대한 사실이었습니다).

즉, 리만 가설(및 그 확장)은 ‘거대한 소수를 절대적인 확신을 가지고 빠르게 생성할 수 있는가’라는 암호의 기반 생성에 직접적인 보증을 부여하는 역할을 가지고 있습니다.

7.2. 소인수분해 알고리즘과의 관계

암호를 해독하는 쪽의 알고리즘(일반 수체 체 등)의 계산 복잡도를 평가할 때도 소수의 분포에 관한 지식이 필수적입니다. 소인수분해 알고리즘의 대부분은 ‘매끄러운 수(Smooth numbers: 작은 소인수만을 가지는 수)‘의 분포에 의존하고 있습니다.

매끄러운 수가 어느 정도의 빈도로 나타나는지를 엄밀하게 평가하기 위해서는 소수의 분포에 관한 깊은 이해가 필요하며, 여기서도 제타 함수나 리만 가설에 직결되는 해석적 정수론의 기법이 구사되고 있습니다. 리만 가설이 증명되어 소수 분포의 오차가 완전히 결정된다면, 소인수분해 알고리즘의 성능 한계도 더욱 정확하게 파악할 수 있게 됩니다.

8. 만약 리만 가설이 증명된다면, 암호는 뚫릴 것인가?

도시 괴담처럼 ‘리만 가설이 풀리면 RSA 암호는 순식간에 붕괴한다’고 이야기되는 경우가 있지만, 이는 수학적으로 부정확합니다.

리만 가설의 증명 자체가 즉각적으로 소인수분해를 극적으로 고속화하는 마법의 알고리즘을 만들어내는 것은 아닙니다. 리만 가설은 어디까지나 소수의 ‘거시적인 분포의 규칙성’에 대한 정리이며, 개별 수 $N$ 이 어떤 소수로 나누어떨어지는지(국소적인 성질)를 직접 가르쳐 주는 것은 아니기 때문입니다.

하지만 그 영향이 제로는 아닙니다. 리만 가설이 증명되는 과정에서 ‘새로운 수학적 도구’나 ‘미지의 해석 기법’이 발견될 가능성이 매우 높기 때문입니다. 역사를 보더라도, 페르마의 마지막 정리나 푸앵카레 추측이 증명되었을 때 그 과정에서 개발된 새로운 이론이 수학 전체를 크게 도약시켰습니다.

만약 리만 제타 함수의 영점의 성질을 완전히 조작할 수 있는 미지의 대수 기하학적 기법이나, 비가환 기하의 기법이 확립된다면, 그것이 결과적으로 소인수분해의 획기적인 알고리즘(예를 들어, 계산 복잡도를 다항 시간으로 줄이는 고전 알고리즘)의 발견으로 이어질 가능성은 부정할 수 없습니다. 그런 의미에서 암호학자들은 리만 가설의 동향에서 결코 눈을 뗄 수 없는 것입니다.

양자 컴퓨터와 쇼어의 알고리즘

암호 기술에 있어 보다 직접적이고 현실적인 위협은 리만 가설의 증명이 아니라 양자 컴퓨터입니다. 1994년 피터 쇼어(Peter Shor)가 발표한 ‘쇼어의 알고리즘’은 충분한 성능을 가진 양자 컴퓨터가 있다면 소인수분해를 다항 시간에 풀 수 있음을 증명했습니다. 이로 인해 RSA 암호나 타원곡선암호는 근본적으로 뚫리게 됩니다.

현재 전 세계적으로 양자 컴퓨터로도 해독할 수 없는 ‘양자 내성 암호(Post-Quantum Cryptography, PQC)‘로의 전환(격자 암호 등)이 추진되고 있습니다. 소수에 의존한 암호 기술은 어떤 의미에서 황금기를 끝내려 하고 있는지도 모르지만, 소수 그 자체의 수학적 가치가 사라지는 일은 영원히 없을 것입니다.

9. 결론: 수학의 추상성과 현실 사회의 교차점

graph TD A["순수 수학의 탐구"] --> B["리만 가설의 규명"] B --> C["소수 분포의 완전한 이해"] C --> D["정수론·대수 기하학의 비약적 발전"] D -.-> E["새로운 소인수분해 알고리즘의 가능성"] E -.-> F["암호 기술의 안전성 평가 갱신"] A --> G["응용 수학·컴퓨터 과학"] G --> H["소수 판별·암호 생성의 효율화"] H --> F

고대 그리스부터 이어져 온 소수에 대한 끝없는 탐구는 리만이라는 천재에 의해 복소평면상의 아름다운 심포니(제타 함수의 영점)로 승화되었습니다. 그리고 놀랍게도 그 순수무구한 수학의 결정체가 수세기의 시간을 거쳐 인터넷 사회의 안전을 담보하는 최강의 방패로서 응용되고 있습니다.

리만 가설은 수학이 가진 ‘추상적인 아름다움’과 ‘물리 세계·현실 사회에 대한 경이로운 적용력’을 동시에 상징하는 존재입니다.

아직 아무도 정상에 도달하지 못한 이 거대한 수학의 산이 언젠가 정복될 때, 우리는 소수라는 우주의 진리를 완전히 이해함과 동시에 정보화 사회의 기반에 대해 새로운 시각을 갖게 될 것입니다. 암호 기술을 배우는 것은 그대로 인류 지혜의 역사를 따라가는 여정이기도 한 것입니다.

암호 기술의 역사: 카이사르 암호에서 양자 내성 암호(PQC)까지

Fri, 11 Sep 2026 15:00:00 +0900

1. 서론: 암호 기술이란 무엇인가?

암호 기술(Cryptography)은 정보의 기밀성을 유지하기 위한 기술로, 인류의 역사와 함께 진화해 왔습니다. 고대 전쟁에서의 비밀 지령 전달부터 현대 인터넷의 신용카드 정보 보호에 이르기까지 암호의 목적은 일관됩니다. 그것은 “의도된 수신자만이 정보를 이해할 수 있게 하고, 제3자는 해독할 수 없도록 하는 것"입니다.

현대의 정보 보안에서 암호 기술은 단순한 ‘정보의 은닉(기밀성: Confidentiality)‘에 그치지 않고, 데이터의 ‘무결성(Integrity)’, ‘인증(Authentication)’, ‘부인 방지(Non-repudiation)‘와 같은 중요한 역할을 담당하고 있습니다.

본 기사에서는 고대의 단순한 환자식 암호에서 시작하여, 기계식 암호, 현대의 대칭키·공개키 암호, 그리고 양자 컴퓨터의 실용화로 도래할 ‘양자 내성 암호(PQC)’ 시대까지, 암호 기술의 진화 역사를 기술적·수학적 관점에서 상세히 풀어보겠습니다.

2. 고전 암호의 시대: 문자의 치환과 전치

암호의 기원은 기원전으로 거슬러 올라갑니다. 초기의 암호는 주로 ‘전치(자리 바꿈)‘와 ‘환자(치환)‘의 두 가지 접근 방식으로 구성되어 있었습니다.

스키테일 암호 (전치식 암호)

기원전 5세기 고대 그리스 스파르타에서 사용된 ‘스키테일(Scytale)‘은 가장 오래된 암호 도구 중 하나입니다. 특정 굵기의 나무 막대에 가늘고 긴 양피지를 감고, 그 위에 가로쓰기로 메시지를 적습니다. 종이를 풀면 글자가 의미 없는 순서로 나열되지만, 같은 굵기의 막대를 가진 수신자가 다시 종이를 감으면 원래의 메시지를 읽을 수 있는 방식이었습니다.

카이사르 암호 (단일 환자식 암호)

기원전 1세기, 고대 로마의 영웅 율리우스 카이사르(시저)가 사용했다고 전해지는 것이 ‘카이사르 암호’입니다. 이는 알파벳을 일정 수(보통 3글자)만큼 시프트시키는 단일 환자식 암호(Monoalphabetic substitution)입니다.

수학적으로는 문자를 $0$부터 $25$까지의 수치로 취급하고, 시프트 수를 $K$라고 할 때, 평문 $P$에서 암호문 $C$로의 변환은 다음 합동식으로 나타낼 수 있습니다.

$$C \equiv P + K \pmod{26}$$

복호화는 역연산을 수행합니다.

$$P \equiv C - K \pmod{26}$$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# 카이사르 암호의 간단한 Python 구현 예
def caesar_cipher(text, shift, mode="encrypt"):
 result = ""
 if mode == "decrypt":
 shift = -shift

 for char in text:
 if char.isalpha():
 base = ord('A') if char.isupper() else ord('a')
 # 시프트 계산
 result += chr((ord(char) - base + shift) % 26 + base)
 else:
 result += char
 return result

# 실행 예
plaintext = "HELLO WORLD"
ciphertext = caesar_cipher(plaintext, 3, "encrypt")
print(f"암호문: {ciphertext}") # KHOOR ZRUOG

빈도 분석과 비즈네르 암호

단일 환자식 암호는 9세기 아랍의 학자 알 킨디가 고안한 ‘빈도 분석(Frequency Analysis)‘에 의해 쉽게 해독되기 시작했습니다. 영어라면 ‘E’나 ‘T’가 자주 등장한다는 언어의 통계적 특성을 이용한 것입니다.

이에 대항하기 위해 16세기에 고안된 것이 ‘비즈네르 암호(Vigenère cipher)‘입니다. 이는 여러 개의 시프트(키)를 주기적으로 전환하여 사용하는 다중 환자식 암호(Polyalphabetic substitution)로, 약 300년 동안 ‘해독 불가능한 암호(Le Chiffre Indéchiffrable)‘라 불렸습니다.

수학적으로는 평문의 $i$번째 문자 $P_i$와 반복되는 키의 $i$번째 문자 $K_i$를 사용하여 다음과 같이 암호화합니다.

$$C_i \equiv P_i + K_i \pmod{26}$$

이 암호도 19세기에 들어 찰스 배비지와 프리드리히 카시스키에 의해 암호문 속 반복 패턴에서 키의 길이를 알아내는 ‘카시스키 검사(Kasiski examination)‘가 발견되면서 해독되게 됩니다.

graph TD subgraph "고전 암호의 분류" A["고전 암호"] --> B["전치식 암호"] A --> C["환자식 암호"] B --> D["스키테일 암호"] C --> E["단일 환자식"] C --> F["다중 환자식"] E --> G["카이사르 암호"] F --> H["비즈네르 암호"] end

3. 기계식 암호와 세계 대전: 애니그마와 그 해독

20세기에 들어 통신 수단이 편지에서 전신이나 무선으로 전환되면서 암호화의 속도와 복잡성이 요구되었습니다. 이때 등장한 것이 로터(회전판)를 조합한 ‘기계식 암호’입니다.

애니그마(Enigma)의 위협

제2차 세계 대전 중 나치 독일이 사용한 ‘애니그마’는 암호 기술 역사상 가장 유명한 암호기입니다. 애니그마는 여러 개의 로터(보통 3~4개)와 문자의 배선을 바꾸는 플러그보드(Steckerbrett), 그리고 리플렉터(반사 로터)로 구성되어 있었습니다.

키보드로 한 글자를 입력할 때마다 로터가 회전하기 때문에, 같은 글자를 연속해서 입력해도 다른 암호 문자가 출력됩니다(다중 환자식 암호의 극치). 그 키 공간(설정의 조합)은 약 $1.58 \times 10^{19}$ 가지(약 1,580경)에 달해, 당시 기술로는 무차별 대입을 통한 해독이 불가능하다고 여겨졌습니다.

앨런 튜링과 ‘봄브(Bombe)’

이 난공불락의 애니그마에 도전한 것이 폴란드의 수학자 마리안 레예프스키 등의 초기 성과를 이어받은 영국의 블레츨리 파크 암호 해독 팀입니다.

특히 앨런 튜링(Alan Turing)은 암호문 일부에 대응하는 평문의 추측(크립: Crib)을 이용하여 전기 기계식 해독기인 ‘봄브(Bombe)‘를 개발했습니다. 봄브는 논리적인 모순을 고속으로 검출하고 불가능한 로터 설정을 차례로 배제함으로써 애니그마 해독에 성공했습니다. 이 위업은 연합군의 승리를 몇 년 앞당겼다고 평가받습니다.

4. 현대 암호의 서막: 대칭키 암호 (DES와 AES)

전후 컴퓨터의 등장으로 암호는 ‘문자’의 조작에서 ‘비트(0과 1)‘의 조작으로 극적인 패러다임 전환을 이룹니다.

클로드 섀넌과 정보 이론

1949년, 클로드 섀넌은 논문 ‘비밀 통신의 통신 이론’을 발표하며 현대 암호의 수학적 기초를 다졌습니다. 그는 안전한 암호 설계의 원칙으로 ‘혼돈(Confusion)‘과 ‘확산(Diffusion)‘을 제창했습니다.

혼돈(Confusion): 키와 암호문의 관계를 가능한 한 복잡하게 만드는 것. (환자/치환, S-box를 통해 구현)
확산(Diffusion): 평문의 1비트 변경이 암호문의 많은 비트에 영향을 미치도록 하는 것. (전치, 자리 바꿈을 통해 구현)

DES (Data Encryption Standard)

1977년, 미국 국립표준기술연구소(NIST, 당시 NBS)는 IBM의 설계를 바탕으로 한 ‘DES’를 표준 암호로 제정했습니다. DES는 ‘파이스텔 구조(Feistel Network)‘라 불리는 아키텍처를 채택했으며, 64비트의 블록 길이와 56비트의 키 길이를 가집니다. 암호화와 복호화 알고리즘이 거의 같은 구조가 된다는 구현상의 이점이 있었습니다.

하지만 컴퓨터의 계산 능력이 향상됨에 따라 56비트의 키 길이(약 $7.2 \times 10^{16}$ 가지)로는 불충분하다는 것이 명백해졌습니다. 1998년에는 전자 프론티어 재단(EFF)이 전용 머신 ‘Deep Crack’을 개발하여 단 며칠 만에 DES를 해독해 보였습니다.

AES (Advanced Encryption Standard)

DES를 대체할 새로운 표준으로 2001년에 제정된 것이 ‘AES’입니다. 공모를 통해 선정된 벨기에의 암호학자가 개발한 ‘레인달(Rijndael)’ 알고리즘이 채택되었습니다.

AES는 파이스텔 구조가 아닌 ‘SPN 구조(Substitution-Permutation Network)‘를 채택하였고, 갈루아 체(유한체) $GF(2^8)$ 상의 수학적 연산을 이용합니다. 키 길이는 128, 192, 256비트 중에서 선택할 수 있으며, 현재도 전 세계적으로 표준 대칭키 암호로 널리 사용되고 있습니다.

graph TD subgraph "AES의 1라운드 처리 (SPN 구조)" A["입력 상태 (128-bit)"] --> B("SubBytes (바이트 대체 / S-Box)") B --> C("ShiftRows (행 시프트)") C --> D("MixColumns (열 믹스 / GF(2^8) 상의 곱셈)") D --> E("AddRoundKey (라운드 키와의 XOR)") E --> F["다음 라운드로"] end

5. 공개키 암호의 혁명: Diffie-Hellman에서 RSA로

대칭키 암호에는 결정적인 약점이 있었습니다. 바로 ‘키 분배 문제(Key Distribution Problem)‘입니다. 암호 통신을 시작하기 전에 멀리 떨어진 상대와 어떻게 안전하게 ‘공통의 키’를 공유할 것인가 하는 문제입니다. 이 문제를 해결한 것이 1970년대에 탄생한 ‘공개키 암호’입니다.

Diffie-Hellman 키 교환

1976년, 휫필드 디피와 마틴 헬먼은 획기적인 논문 ‘암호학의 새로운 방향(New Directions in Cryptography)‘을 발표했습니다. 이들은 ‘이산 로그 문제(Discrete Logarithm Problem)‘라는 수학적 어려움을 이용하여 도청당하고 있는 통신 경로 상에서도 안전하게 키를 공유할 수 있는 기법을 제안했습니다.

큰 소수 $p$와 생성원 $g$를 공개합니다.
Alice는 비밀 값 $a$를 선택하고, $A = g^a \pmod{p}$를 Bob에게 전송합니다.
Bob은 비밀 값 $b$를 선택하고, $B = g^b \pmod{p}$를 Alice에게 전송합니다.
Alice는 $K = B^a \pmod{p}$를 계산하고, Bob은 $K = A^b \pmod{p}$를 계산합니다.
지수 법칙에 의해 $K = (g^b)^a = (g^a)^b = g^{ab} \pmod{p}$가 되어, 훌륭하게 같은 키 $K$를 공유할 수 있습니다.

RSA 암호

이듬해인 1977년, 론 리베스트, 아디 샤미르, 레너드 애들먼의 세 사람에 의해 고안된 것이 ‘RSA 암호’입니다. 이는 “거대한 합성수의 소인수분해는 어렵다"는 성질에 기반하고 있습니다.

RSA의 수학적 원리:

2개의 거대한 소수 $p$와 $q$를 선택하고, $n = p \times q$를 계산합니다.
오일러의 피 함수 $\phi(n) = (p-1)(q-1)$을 계산합니다.
$\phi(n)$과 서로소인 정수 $e$(공개키)를 선택합니다.
$e \times d \equiv 1 \pmod{\phi(n)}$이 되는 정수 $d$(비밀키)를 계산합니다.

암호화: 평문 $M$에 대해 $C \equiv M^e \pmod{n}$ 복호화: 암호문 $C$에 대해 $M \equiv C^d \pmod{n}$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


# RSA 암호의 개념을 보여주는 Python 코드 (실무용은 아닙니다)
def ext_euclid(a, b):
 # 확장 유클리드 호제법을 이용한 모듈러 역원 계산
 if b == 0: return 1, 0, a
 x, y, g = ext_euclid(b, a % b)
 return y, x - (a // b) * y, g

def rsa_example():
 # 작은 소수를 사용한 예
 p, q = 61, 53
 n = p * q
 phi = (p - 1) * (q - 1)

 e = 17 # phi와 서로소인 값
 d, _, _ = ext_euclid(e, phi)
 if d < 0: d += phi

 print(f"공개키: (e={e}, n={n})")
 print(f"비밀키: (d={d}, n={n})")

 # 메시지의 암호화와 복호화
 message = 65
 ciphertext = pow(message, e, n)
 decrypted = pow(ciphertext, d, n)

 print(f"평문: {message} -> 암호문: {ciphertext} -> 복호화 후: {decrypted}")

rsa_example()

6. 타원 곡선 암호(ECC)의 대두

RSA 암호는 강력하지만 컴퓨터의 성능 향상에 따라 안전성을 유지하기 위해 키 길이를 늘려야 했고(현재는 2048비트나 3072비트), 계산 비용이 증가한다는 문제가 발생했습니다.

그래서 1985년에 제안된 것이 ‘타원 곡선 암호(Elliptic Curve Cryptography: ECC)‘입니다. 이는 유한체 상의 타원 곡선(일반적으로 $y^2 = x^3 + ax + b$ 형태)에서의 점 덧셈을 이용한 것입니다.

타원 곡선 상의 이산 로그 문제(ECDLP)는 소인수분해 문제보다 푸는 것이 더 어렵다고 알려져 있으며, RSA의 3072비트와 동등한 안전성을 ECC라면 불과 256비트의 키 길이로 구현할 수 있습니다. 이를 통해 스마트폰이나 IoT 기기 등 계산 자원이 제한된 환경에서도 빠르고 안전한 암호 통신(ECDSA나 ECDH 등)이 가능해졌습니다.

7. 양자 컴퓨터의 위협과 양자 내성 암호(PQC)

암호 기술은 반석처럼 보였으나, 1994년 피터 쇼어(Peter Shor)가 발표한 ‘쇼어의 알고리즘’으로 인해 큰 충격이 가해졌습니다.

양자 컴퓨터는 ‘중첩’과 ‘양자 얽힘’이라는 양자 역학의 성질을 이용하여 계산을 수행합니다. 쇼어의 알고리즘을 충분한 성능의 양자 컴퓨터에서 실행하면, 소인수분해 문제나 이산 로그 문제가 ‘다항식 시간’ 내에 풀린다는 것이 수학적으로 증명된 것입니다. 즉, 실용적인 양자 컴퓨터가 완성되는 날(Q-Day), 현재 사용되고 있는 RSA나 ECC 같은 공개키 암호는 모두 순식간에 붕괴됩니다.

PQC(Post-Quantum Cryptography)의 등장

이 전대미문의 위협에 대비해, 양자 컴퓨터로도 해독이 어려운 새로운 수학적 문제에 기반한 ‘양자 내성 암호(PQC)’ 연구가 빠른 속도로 진행되고 있습니다. NIST(미국 국립표준기술연구소)는 수년간 PQC의 표준화 과정을 진행해 왔으며, 주로 다음의 수학적 접근 방식이 유력하게 꼽히고 있습니다.

1. 격자 기반 암호 (Lattice-based Cryptography)

현재 가장 유력한 접근법으로, NIST의 표준화 알고리즘(ML-KEM / Kyber, ML-DSA / Dilithium)에도 채택되었습니다. 다차원 공간의 ‘격자(Lattice)’ 위에서 특정 점을 찾는 문제(최단 벡터 문제: SVP 등)나, LWE(Learning With Errors: 오차가 있는 학습) 문제의 어려움에 기반하고 있습니다.

LWE 문제의 개념은 연립 일차 방정식에 의도적으로 ‘작은 노이즈(오차)‘를 더하면 순간적으로 해를 구하기가 매우 어려워진다는 성질을 이용한 것입니다. 방정식계: $\mathbf{A}\mathbf{s} + \mathbf{e} \equiv \mathbf{b} \pmod{q}$ ($\mathbf{A}$와 $\mathbf{b}$는 공개, $\mathbf{s}$는 비밀키, $\mathbf{e}$는 미세한 노이즈)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


# LWE 문제의 개념적 의사 코드 (학습 목적)
import numpy as np

n = 256 # 차원
q = 3329 # 법(modulus)
m = 512 # 방정식의 수

# 비밀키 s와 작은 에러 e
s = np.random.randint(0, 5, size=n)
e = np.random.randint(-1, 2, size=m)

# 공개 행렬 A와 공개 벡터 b
A = np.random.randint(0, q, size=(m, n))
b = (np.dot(A, s) + e) % q

# 양자 컴퓨터를 사용해도 A와 b로부터 s를 복원하는 것은 매우 어렵다고 여겨짐

2. 해시 기반 암호 (Hash-based Cryptography)

해시 함수의 충돌 저항성에만 안전성의 근거를 두는 전자 서명 방식입니다. 수학적인 구조를 가지지 않기 때문에 양자 공격에 강하지만, 서명 크기가 커지는 경향이 있습니다(SPHINCS+ 등).

3. 코드 기반 암호 (Code-based Cryptography)

오류 정정 코드 이론에 기반한 암호 방식입니다. 1978년에 제안된 McEliece 암호 등이 유명하며, 역사가 길고 안전성이 입증되었으나 공개키의 크기가 매우 크다(수 메가바이트에 달하기도 함)는 과제가 있습니다.

timeline title "암호 기술과 컴퓨터의 진화 역사" "고대~중세" : "카이사르 암호" : "비즈네르 암호" : "빈도 분석의 탄생" "1930~40년대" : "애니그마의 운용과 해독" : "튜링 머신·봄브의 개발" "1970년대" : "DES 표준화 (1977)" : "Diffie-Hellman 키 교환 (1976)" : "RSA 암호의 탄생 (1977)" "1980~90년대" : "타원 곡선 암호(ECC) 제안" : "쇼어의 알고리즘 발표 (1994)" "2000년대" : "AES 표준화 (2001)" "2010년대~현재" : "양자 컴퓨터 연구 가속" : "NIST의 PQC 표준화 프로젝트 시작" "가까운 미래 (Q-Day)" : "대규모 양자 컴퓨터 실현?" : "PQC(ML-KEM/ML-DSA)로의 완전 전환"

8. 결론: 끝없는 방패와 창의 싸움

암호 기술의 역사는 새로운 암호 방식(방패)의 발명과 그것을 깨는 새로운 해독 기법(창)의 끝없는 싸움의 역사입니다.

카이사르 암호는 빈도 분석에 패배했고, 무적을 자랑하던 애니그마는 튜링의 천재적인 두뇌와 기계의 힘에 패배했습니다. 그리고 지금, 현대 인터넷 사회의 근간을 지탱하는 RSA나 ECC 같은 강력한 암호도 양자 컴퓨터라는 새로운 ‘창’ 앞에 위협을 받고 있습니다.

하지만 인류는 이미 그 너머의 미래를 바라보며 양자 내성 암호(PQC)라는 새로운 ‘방패’를 준비하고 있습니다. 현재 전 세계의 IT 인프라에서 기존의 공개키 암호로부터 PQC로의 전환 준비(Crypto Agility 확보)가 시급한 과제가 되었습니다.

암호 기술은 단순하고 난해한 수학 퍼즐이 아니라, 우리의 프라이버시, 재산, 그리고 사회 인프라 자체를 지키기 위한 최강의 방벽인 것입니다.

【수학 해설】 고등학생도 이해할 수 있는 RSA 암호의 원리

Fri, 11 Sep 2026 13:00:00 +0900

인터넷 사회의 안전을 근본적으로 지탱하고 있는 기술 중 하나가 ‘RSA 암호’입니다. 온라인 쇼핑에서의 신용카드 결제, 친구와의 SNS 대화, 회사의 기밀 정보 송수신 등 우리가 매일 무심코 사용하는 통신의 대부분은 이 RSA 암호나 그 후속 기술에 의해 보호받고 있습니다.

하지만 ‘암호’라고 하면 스파이 영화에 나올 법한 복잡한 암호기나 일부 천재만이 이해할 수 있는 초고도 수학을 상상할지도 모릅니다. 현대 암호 이론이 고도화된 수학을 바탕으로 하는 것은 사실이지만, RSA 암호의 근본적인 원리는 고등학교에서 배우는 수학(정수의 성질, 소수, 합동식 등) 지식만 있다면 충분히 이해할 수 있는 것입니다.

이 글에서는 고등학교 수학 지식을 출발점으로 삼아, RSA 암호가 어떤 수학적 원리로 작동하는지, 왜 해독하기 어려운지를 단계별로 철저하게 해설합니다. 수학을 조금 어려워하는 분들도 이해할 수 있도록 구체적인 예를 곁들여 자세히 설명하겠습니다.

1. 공통키 암호와 공개키 암호

RSA 암호의 수학적인 원리에 들어가기 전에, 먼저 암호의 기본적인 개념부터 정리해 보겠습니다. 암호 방식은 크게 나누어 ‘공통키 암호(대칭키 암호)‘와 ‘공개키 암호’ 두 가지로 나뉩니다.

1.1 공통키 암호 방식의 한계

예전부터 사용되어 온 암호의 대부분은 ‘공통키 암호 방식’이라고 불리는 것입니다. 이것은 ‘암호화(메시지를 비밀 암호문으로 변환하는 것)‘와 ‘복호화(암호문을 원래 메시지로 되돌리는 것)‘에 같은 키를 사용하는 방식입니다.

예를 들어, 앨리스가 밥에게 비밀 편지를 보낸다고 가정해 보겠습니다. 앨리스는 자물쇠(공통키)를 사용하여 상자에 편지를 넣고 잠급니다. 밥이 그 상자를 열기 위해서는 앨리스가 사용한 것과 똑같은 키를 가지고 있어야 합니다.

이 방식에는 큰 문제가 있습니다. 바로 ‘키 분배 문제’입니다. 멀리 떨어져 있는 앨리스와 밥이 처음 통신할 경우, 어떻게 도청당하지 않고 키를 공유할 수 있을까요? 만약 키를 우편으로 보내는 도중에 제3자에게 도난당한다면, 그 이후의 암호 통신은 모두 내용이 노출되고 맙니다.

1.2 획기적인 발명 ‘공개키 암호 방식’

이 키 분배 문제를 해결하기 위해 고안된 것이 ‘공개키 암호 방식’입니다. RSA 암호도 이것의 일종입니다.

공개키 암호 방식에서는 ‘암호화하기 위한 키(공개키)‘와 ‘복호화하기 위한 키(비밀키)‘라는 서로 다른 두 개의 키를 사용합니다.

수신자인 밥은 ‘공개키’와 ‘비밀키’ 쌍을 생성합니다.
밥은 ‘공개키’를 전 세계에 공개합니다 (누가 가져도 상관없습니다).
송신자인 앨리스는 밥의 ‘공개키’를 사용하여 메시지를 암호화하고 전송합니다.
암호화된 메시지는 밥만이 가지고 있는 ‘비밀키’로만 복호화할 수 있습니다.

이것을 자물쇠에 비유하자면, 밥은 ‘열려 있는 상태의 자물쇠(공개키)‘를 많이 만들어서 전 세계에 뿌립니다. 앨리스는 밥에게 보낼 메시지를 상자에 넣고, 주운 밥의 자물쇠로 찰칵하고 잠급니다. 자물쇠는 한 번 닫히면 밥이 가지고 있는 ‘마스터키(비밀키)‘로만 열 수 있습니다. 중간에 누군가 상자를 훔쳐도 마스터키가 없기 때문에 열 수 없는 것입니다.

graph TD A["앨리스 (송신자)"] --> B["평문 (메시지)"] B --> C["암호화 처리"] D["밥의 공개키 (누구나 획득 가능)"] --> C C --> E["인터넷을 통해 전송: 암호문"] E --> F["복호화 처리"] G["밥의 비밀키 (밥만 소유)"] --> F F --> H["복원된 평문 (메시지)"] H --> I["밥 (수신자)"]

이 획기적인 시스템을 구현하기 위해서는 ‘공개키로 쉽게 암호화할 수 있지만, 비밀키가 없으면 절대 복호화할 수 없다’는 일종의 **‘일방향 함수(일방통행인 수학적 퍼즐)’**가 필요합니다. 그 퍼즐의 부품으로 주목받은 것이 바로 우리가 잘 아는 ‘소수’였습니다.

2. RSA 암호를 지탱하는 수학적 기초 1: 소수와 소인수분해

RSA 암호의 안전성은 **‘거대한 수의 소인수분해는 매우 어렵다’**는 수학적 사실에 바탕을 두고 있습니다.

2.1 소수란

소수란 ‘1과 자기 자신으로밖에 나누어떨어지지 않는, 1보다 큰 자연수’를 말합니다. 예: $2, 3, 5, 7, 11, 13, 17, 19, 23...$

소수는 모든 정수의 ‘원자’와 같은 것입니다. 어떤 자연수라도 소수들의 곱셈 형태로 분해할 수 있습니다. 이것을 소인수분해라고 부릅니다. 예를 들어 $60 = 2^2 \times 3 \times 5$ 처럼, 순서를 무시하면 단 한 가지로 소인수분해할 수 있다는 것은 ‘산술의 기본 정리’로 알려져 있습니다.

2.2 소인수분해의 어려움 (일방향 함수)

여기서 중요한 것은 **‘곱셈은 쉽지만 소인수분해는 어렵다’**는 비대칭성입니다.

예를 들어, 다음 두 소수의 곱셈을 암산으로 계산해 보세요. $11 \times 13 = ?$ 이것은 쉽네요. 정답은 $143$입니다.

그럼, 다음 수는 어떨까요? $323$을 소인수분해 해 보세요. 어떠신가요? 시간이 조금 걸릴 것입니다. (정답은 $17 \times 19$입니다).

수가 작으면 사람도 어떻게든 계산할 수 있지만, 수가 커지면 컴퓨터를 사용해도 계산이 폭발적으로 어려워집니다. 현재 주류인 RSA 암호에서는 2048비트(10진수로 약 600자리)라는 터무니없이 거대한 소수 $p$와 $q$를 곱한 수 $N = p \times q$를 사용합니다.

거대한 두 소수 $p$와 $q$가 주어졌을 때, $N$을 계산하는 것은 컴퓨터에게는 순식간(밀리초 이하)입니다. 하지만 반대로 $N$만 주어지고 원래의 $p$와 $q$를 찾아내는 것은 현재 가장 빠른 슈퍼컴퓨터를 수조 년 돌려도 풀지 못할 정도로 오랜 시간이 걸립니다.

이 **‘계산의 비대칭성(한쪽 방향은 쉽지만 역방향은 어려움)’**이 공개키와 비밀키의 관계성을 만들어내는 토대가 됩니다.

3. RSA 암호를 지탱하는 수학적 기초 2: 합동식 (모듈로 연산)

RSA 암호의 계산은 우리가 평소 사용하는 무한히 숫자가 커지는 덧셈이나 곱셈이 아니라, 어떤 수로 나눈 ‘나머지’의 세계에서 이루어집니다. 이것을 **합동식(모듈로 연산)**이라고 부릅니다.

3.1 시계의 수학

모듈로 연산은 종종 ‘시계의 수학’에 비유됩니다. 현재 10시라고 할 때, 그로부터 5시간 후는 몇 시일까요? $10 + 5 = 15$시이지만, 일반적인 12시간 시계에서는 ‘3시’라고 대답합니다. 이것은 15를 12로 나눈 나머지가 3이기 때문입니다.

수학의 세계에서는 이것을 다음과 같이 표기합니다.

$$ 15 \equiv 3 \pmod{12} $$

“15와 3은 12를 법으로 하여 합동이다(12로 나눈 나머지가 같다)“라고 읽습니다.

3.2 합동식의 기본적인 성질

합동식에는 등식($=$)과 매우 비슷한 유용한 성질이 있습니다. 법(나누는 수)을 $N$이라고 하겠습니다. $a \equiv b \pmod N$ 이고 $c \equiv d \pmod N$ 일 때, 다음이 성립합니다.

덧셈: $a + c \equiv b + d \pmod N$
뺄셈: $a - c \equiv b - d \pmod N$
곱셈: $a \times c \equiv b \times d \pmod N$
거듭제곱: $a^k \equiv b^k \pmod N$ ($k$는 자연수)

특히 중요한 것은 ‘거듭제곱’의 성질입니다. 이것은 **‘나머지의 거듭제곱은 거듭제곱의 나머지와 같다’**는 것을 의미합니다. 예를 들어, $7^{100}$을 $5$로 나눈 나머지를 구하고 싶다고 합시다. 정직하게 $7$을 100번 곱한 뒤 $5$로 나누는 것은 힘들지만, 합동식의 성질을 사용하면 $7 \equiv 2 \pmod 5$ 이므로 $7^{100} \equiv 2^{100} \pmod 5$ 가 되어 계산을 비약적으로 단순하게 만들 수 있습니다. 암호의 세계에서는 매우 큰 수의 거듭제곱을 다루기 때문에 이 성질이 필수적입니다.

4. RSA 암호를 지탱하는 수학적 기초 3: 오일러 함수와 오일러의 정리

여기서부터가 RSA 암호의 핵심이 되는 마법의 수학입니다. ‘페르마의 소정리’를 일반화한 ‘오일러의 정리’가 등장합니다.

4.1 오일러의 토션트 함수 $\phi(N)$

오일러의 토션트 함수($\phi$ 함수)는 어떤 자연수 $N$에 대하여, **‘1부터 $N$까지의 자연수 중 $N$과 서로소(최대공약수가 1)인 수의 개수’**를 반환하는 함수입니다.

몇 가지 예를 살펴보겠습니다.

$\phi(5)$: 1, 2, 3, 4, 5 중에서 5와 서로소인 것은 1, 2, 3, 4의 4개. 따라서 $\phi(5) = 4$.
$\phi(6)$: 1, 2, 3, 4, 5, 6 중에서 6과 서로소인 것은 1, 5의 2개. 따라서 $\phi(6) = 2$.

【소수인 경우의 특별한 성질】 $p$가 소수인 경우, 1부터 $p-1$까지의 모든 수가 $p$와 서로소가 됩니다. 따라서,

$$ \phi(p) = p - 1 $$

이 됩니다.

【두 소수의 곱인 경우의 특별한 성질】 서로 다른 두 소수 $p$와 $q$에 대해 $N = p \times q$ 라고 할 때, $\phi(N)$은 다음 계산으로 쉽게 구할 수 있습니다.

$$ \phi(N) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

이 성질이 RSA 암호의 ‘비밀 뒷문(트랩도어)’ 역할을 합니다. $p$와 $q$를 아는 사람(키 생성자)은 $\phi(N)$을 순식간에 계산할 수 있지만, $N$밖에 모르는 제3자는 $N$을 소인수분해하지 않는 한 $\phi(N)$을 구할 수 없는 것입니다.

4.2 오일러의 정리

레온하르트 오일러는 이 $\phi(N)$을 사용하여 다음과 같은 아름다운 정리를 증명했습니다.

오일러의 정리: 정수 $a$와 $N$이 서로소일 때, 다음 합동식이 성립한다.

$$ a^{\phi(N)} \equiv 1 \pmod N $$

이것은 “어떤 수 $a$를 $\phi(N)$번 곱하여 $N$으로 나누면 나머지가 반드시 $1$이 된다"는 놀라운 성질입니다. ($N$이 소수 $p$인 경우는 $a^{p-1} \equiv 1 \pmod p$ 가 되며, 페르마의 소정리라고 부릅니다).

이 오일러의 정리를 변형해 보겠습니다. 양변에 $a$를 한 번 더 곱합니다.

$$ a^{\phi(N) + 1} \equiv a \pmod N $$

나아가 임의의 정수 $k$에 대하여 $a^{k \cdot \phi(N)}$ 도 $1^k = 1$이 되므로, 다음 식이 성립합니다.

$$ a^{k \cdot \phi(N) + 1} \equiv a \pmod N $$

이 식이야말로 RSA 암호의 **‘암호화한 뒤 복호화하면 원래대로 돌아온다’**는 마법을 성립시키는 근본 원리입니다.

5. RSA 암호 알고리즘: 키 생성・암호화・복호화 단계

기초 지식이 갖춰졌으니, 이제 드디어 RSA 암호의 구체적인 절차를 살펴보겠습니다. RSA 암호는 크게 ‘1. 키 생성’, ‘2. 암호화’, ‘3. 복호화’의 세 단계로 나뉩니다.

flowchart TD A1["1. 소수 p, q를 선택한다"] --> A2["N = p × q 를 계산한다"] A1 --> A3["φ(N) = (p-1)(q-1) 을 계산한다"] A3 --> A4["φ(N)과 서로소인 e를 선택한다"] A3 --> A5["e × d ≡ 1 (mod φ(N)) 이 되는 d를 계산한다"] A2 --> A6["공개키 (N, e)"] A4 --> A6 A5 --> A7["비밀키 d"] B1["2. 평문 메시지 M"] --> B2["C ≡ M^e (mod N) 을 계산한다"] A6 -.-> B2 B2 --> B3["암호문 C를 전송한다"] B3 --> C1["3. 수신한 암호문 C"] C1 --> C2["M ≡ C^d (mod N) 을 계산한다"] A7 -.-> C2 C2 --> C3["원래의 평문 메시지 M을 얻는다"]

5.1 키 생성 (Key Generation)

수신자인 밥은 자신을 위한 ‘공개키’와 ‘비밀키’를 생성합니다.

소수 선택: 임의의 두 큰 소수 $p$와 $q$를 선택합니다.
법 $N$ 계산: $N = p \times q$ 를 계산합니다. 이 $N$은 공개됩니다.
$\phi(N)$ 계산: 오일러 함수 $\phi(N) = (p - 1)(q - 1)$ 을 계산합니다. 이것은 밥만의 비밀 숫자입니다.
공개키 $e$ 선택: $1 < e < \phi(N)$ 이면서 $\phi(N)$과 서로소인 정수 $e$를 선택합니다.
비밀키 $d$ 계산: 다음 조건을 만족하는 정수 $d$를 찾습니다. $$ e \times d \equiv 1 \pmod{\phi(N)} $$ 이것은 즉 ‘$e \times d$를 $\phi(N)$으로 나눈 나머지가 $1$이 되는 수 $d$‘를 뜻합니다.

이것으로 키 준비는 완료되었습니다.

공개키: $(N, e)$ 쌍. 전 세계에 공개합니다.
비밀키: $d$. 절대 누구에게도 알려주지 않습니다.

5.2 암호화 (Encryption)

앨리스는 밥에게 비밀 메시지 $M$을 보내고 싶습니다. ($M$은 문자를 수치화한 것으로 $0 \le M < N$ 이라고 가정합니다). 앨리스는 밥의 공개키 $(N, e)$ 를 사용하여 다음과 같이 계산합니다.

$$ C \equiv M^e \pmod N $$

‘메시지 $M$을 $e$제곱하고, $N$으로 나눈 나머지 $C$‘를 계산합니다. 이 $C$가 암호문입니다.

5.3 복호화 (Decryption)

밥은 암호문 $C$를 받습니다. 밥은 비밀키 $d$를 사용하여 다음과 같이 계산합니다.

$$ M \equiv C^d \pmod N $$

‘암호문 $C$를 $d$제곱하고, $N$으로 나눈 나머지’를 계산하면, 놀랍게도 원래의 메시지 $M$이 복원되는 것입니다!

6. 왜 복호화하면 원래대로 돌아가는가? (수학적 증명)

“$C$를 $d$제곱하는 것만으로 어떻게 원래의 $M$으로 돌아가지?“라고 의문이 들 수 있습니다. 여기서 앞서 다룬 ‘오일러의 정리’가 위력을 발휘합니다.

복호화 계산식 $C^d \pmod N$ 에 암호화 식 $C = M^e$ 를 대입해 보겠습니다.

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

여기서 키 생성의 5단계를 떠올려 보세요. 밥은 $d$를 만들 때, $e \times d \equiv 1 \pmod{\phi(N)}$ 이 되도록 선택했습니다. 이것은 ‘$ed$는 $\phi(N)$의 배수에 $1$을 더한 수이다’라는 것을 의미합니다. 정수 $k$를 사용하여 다음과 같이 쓸 수 있습니다.

$$ ed = k \cdot \phi(N) + 1 $$

이것을 지수 부분에 대입하고, 지수 법칙을 사용하여 분해합니다.

$$ M^{ed} = M^{k \cdot \phi(N) + 1} = M^{k \cdot \phi(N)} \times M^1 = (M^{\phi(N)})^k \times M $$

여기서 메시지 $M$과 $N$이 서로소라고 가정하면, 오일러의 정리에 의해 $M^{\phi(N)} \equiv 1 \pmod N$ 이 됩니다.

$$ (M^{\phi(N)})^k \times M \equiv 1^k \times M \equiv M \pmod N $$

따라서 멋지게 다음 식이 성립하게 됩니다.

$$ C^d \equiv M \pmod N $$

앨리스는 $d$를 모르고 도청자도 $d$를 모르기 때문에, $C$에서 $M$을 꺼낼 수 있는 것은 $d$를 가지고 있는 밥뿐인 것입니다.

7. 구체적인 예: 작은 소수를 사용하여 손으로 직접 RSA를 계산해 보자

실제로 작은 숫자(소수)를 사용하여 앨리스에서 밥으로 암호 통신을 해봅시다.

【밥의 키 생성 단계】

두 소수 $p=11$, $q=13$ 을 선택합니다.
$N = 11 \times 13 = 143$ 을 계산합니다.
$\phi(N) = (11 - 1) \times (13 - 1) = 10 \times 12 = 120$ 을 계산합니다.
$\phi(N)=120$ 과 서로소인 공개키 $e$를 선택합니다. 여기서는 $e=7$ 로 하겠습니다.
비밀키 $d$를 구합니다. $7 \times d \equiv 1 \pmod{120}$ 이 되는 $d$를 찾습니다. 방정식 $7d = 120k + 1$ 에서 $k=6$ 일 때 $721$이 되며, $721 \div 7 = 103$. 따라서 $d = 103$ 이 됩니다.

공개키: $(N=143, e=7)$
비밀키: $d=103$

【앨리스의 암호화 단계】 메시지 $M = 9$ 를 보내고 싶다고 합시다. 식: $C \equiv 9^7 \pmod{143}$ $9^7 = 4,782,969$. 이것을 143으로 나누면 몫이 $33447$이고 나머지가 $48$. 암호문 $C = 48$ 이 되었습니다.

【밥의 복호화 단계】 밥은 암호문 $C = 48$ 을 받고, 비밀키 $d = 103$ 을 사용하여 복호화합니다. 식: $M \equiv 48^{103} \pmod{143}$ 계산기에서 (48 ** 103) % 143 을 실행하면, 놀랍게도 결과는 ‘9‘가 됩니다! 원래 메시지를 무사히 받을 수 있었습니다.

8. 비밀키 $d$를 구하는 방법: 확장 유클리드 호제법

수작업 계산 예제에서는 감으로 $k$를 찾아 $d=103$ 을 발견했지만, 수가 수백 자리가 되면 이 방법은 불가능합니다. 실제 프로그램에서는 **‘확장 유클리드 호제법’**이라는 알고리즘을 사용합니다.

$7d \equiv 1 \pmod{120}$ 을 푼다는 것은 $7d + 120y = 1$ 을 만족하는 정수 $d, y$ 를 찾는 것과 같습니다. 유클리드 호제법을 역산해 나감으로써 이를 기계적으로 구할 수 있습니다.

$120 \div 7 = 17$ 나머지 $1$
이것을 변형하면 $1 = 120 - 17 \times 7$
즉, $-17 \times 7 \equiv 1 \pmod{120}$

$-17$ 은 법 $120$의 세계에서는 $120 - 17 = 103$ 과 같은 의미가 됩니다. 따라서 $d = 103$ 을 순식간에 구할 수 있습니다. 이 방법은 아무리 큰 수라도 매우 빠르게 계산할 수 있습니다.

9. RSA 암호의 또 다른 얼굴: 디지털 서명

RSA 암호의 훌륭한 점은 공개키와 비밀키의 역할을 반대로 하여 **‘디지털 서명’**으로도 사용할 수 있다는 것입니다.

암호화할 때는 ‘공개키로 암호화 $\Rightarrow$ 비밀키로 복호화’였지만, 디지털 서명에서는 ‘비밀키로 암호화 $\Rightarrow$ 공개키로 복호화’라는 절차를 밟습니다.

flowchart TD A1["1. 앨리스가 비밀키로 서명 생성"] --> A2["S ≡ M^d (mod N)"] A2 --> A3["메시지 M과 서명 S를 전송"] A3 --> B1["2. 밥이 공개키로 서명 검증"] B1 --> B2["M' ≡ S^e (mod N) 을 계산"] B2 --> B3["M'과 M이 일치하는지 확인"]

앨리스가 자신의 비밀키 $d$를 사용하여 메시지를 변환하고(이것이 서명 $S$), 밥에게 보냅니다. 밥은 앨리스의 공개키 $e$를 사용하여 검증 계산을 합니다. 만약 계산 결과가 원래 메시지와 일치한다면, ‘앨리스의 비밀키로만 만들 수 있는 데이터이다’라는 것과 ‘메시지가 중간에 위조되지 않았다’는 것이 동시에 증명되는 것입니다.

10. 프로그램으로 체감하는 RSA 암호

수작업으로는 힘든 거듭제곱 계산도 파이썬을 사용하면 매우 쉽게 구현할 수 있습니다. 다음은 RSA 암호의 핵심 로직을 체험할 수 있는 파이썬 코드입니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


def gcd(a, b):
 """최대공약수를 구한다"""
 while b != 0:
 a, b = b, a % b
 return a

def mod_inverse(e, phi):
 """비밀키 d를 구한다 (Python 3.8 이후의 내장 기능 활용)"""
 return pow(e, -1, phi)

# 1. 키 생성
p, q = 11, 13
N = p * q
phi = (p - 1) * (q - 1)
e = 7
d = mod_inverse(e, phi)

print(f"공개키: (N={N}, e={e}), 비밀키: d={d}")

# 2. 암호화
message = 9
ciphertext = pow(message, e, N)
print(f"암호문: {ciphertext}")

# 3. 복호화
decrypted_message = pow(ciphertext, d, N)
print(f"복호화된 메시지: {decrypted_message}")

파이썬의 pow(base, exp, mod) 함수는 내부적으로 ‘반복 제곱법(거듭제곱법)‘이라는 고속 알고리즘을 사용하기 때문에 수백 자리의 숫자라도 순식간에 계산이 끝납니다.

11. 요약 및 미래의 암호 기술

고등학교 수학 지식을 바탕으로 RSA 암호의 원리를 밝혀 보았습니다.

소인수분해의 어려움: $p \times q = N$ 은 쉽지만, $N$에서 $p, q$를 찾는 것은 매우 어렵다.
합동식과 오일러의 정리: $a^{\phi(N)} \equiv 1 \pmod N$ 이라는 법칙에 의해, ‘어떤 수로 거듭제곱하면 원래대로 돌아가는’ 마법의 트랩도어가 완성된다.
공개키와 비밀키: 누구나 암호화할 수 있지만, 복호화할 수 있는 것은 정당한 수신자뿐이다.

현재 사용되는 RSA 암호의 $N$은 600자리 이상이며, 전 세계의 슈퍼컴퓨터를 총동원해도 소인수분해에는 우주의 나이 이상의 시간이 걸립니다. 하지만 최근 연구가 진행되고 있는 ‘양자 컴퓨터’가 장래에 실용화되면 ‘쇼어의 알고리즘(Shor’s algorithm)‘에 의해 이 소인수분해가 순식간에 풀릴 가능성이 있습니다. 따라서 현재는 양자 컴퓨터로도 해독할 수 없는 ‘양자 내성 암호(Post-Quantum Cryptography)’ 개발이 전 세계적으로 빠른 속도로 진행되고 있습니다.

‘쓸모없다’고 여겨지기 쉬운 고도화된 수학이 사실은 우리의 일상생활을 근본적으로 지켜주고 있습니다. RSA 암호는 그런 수학의 깊이와 아름다움을 가르쳐 주는 최고의 교재입니다. 이 글을 통해 암호와 수학의 재미를 조금이라도 느끼셨기를 바랍니다.

완전동형암호(FHE)란? 차세대 보안의 핵심을 해설

Fri, 11 Sep 2026 11:00:00 +0900

클라우드 컴퓨팅과 AI 기술이 사회의 기반으로 자리 잡은 가운데, ‘데이터의 프라이버시’와 ‘데이터의 활용’의 트레이드오프는 가장 중요한 과제 중 하나가 되었습니다. 의료 데이터, 금융 정보, 개인의 생체 정보 등 기밀성이 높은 데이터를 클라우드 상에서 AI에게 분석시키고자 하는 수요는 증가하고 있지만, 보안상의 우려로 데이터의 외부 전송을 주저하는 기업이 적지 않습니다.

기존의 암호화 기술(AES나 RSA 등)은 스토리지에 저장되어 있는 데이터(Data at Rest)나 네트워크 상을 흐르는 데이터(Data in Transit)를 보호하는 데에는 능숙합니다. 하지만, 서버 측에서 데이터에 대해 검색이나 기계 학습 등의 처리(계산)를 수행할 때(Data in Use)에는 한 번 암호를 복호화하여 평문으로 되돌려야 합니다. 만약 이 복호화된 타이밍에 서버가 해킹당하거나, 내부의 악의적인 관리자가 데이터를 엿본다면 정보 유출로 직결됩니다.

이 ‘처리 시의 복호화’라는 근본적인 약점을 극복하는 꿈의 기술이 **완전동형암호(Fully Homomorphic Encryption: FHE)**입니다. FHE를 이용하면 데이터를 암호화한 채로 일절 복호화하지 않고 계산 처리를 수행하고, 그 결과의 암호문만을 클라이언트에게 반환하는 것이 가능해집니다.

본 기사에서는 이 FHE의 개념부터 역사, Craig Gentry에 의한 획기적인 돌파구, 수학적인 기초(Ring-LWE 등), 최대 과제인 ‘노이즈’와 그 해결책(부트스트래핑), 그리고 최신 구현 라이브러리에 이르기까지 차세대 보안의 핵심인 FHE를 철저하고 깊이 있게 해설합니다.

1. 동형암호란 무엇인가? 기본적인 개념

‘동형(Homomorphic)‘이란 대수학의 용어로, 어떤 구조를 가진 집합 간에 연산의 구조를 유지한 채 사상할 수 있는 성질을 뜻합니다. 암호 이론에서의 ‘동형성’이란 평문 공간에서의 연산이 암호문 공간에서의 연산에 대응한다는 성질입니다.

단순한 수식으로 나타내면, 평문 $m_1$ 과 $m_2$ 에 대한 암호화 함수를 $E(\cdot)$ 라 하고, 복호화 함수를 $D(\cdot)$ 라 합니다. 평문 상에서의 연산(덧셈이나 곱셈 등)을 $\circ$ , 암호문 상에서의 연산을 $\diamond$ 라 했을 때, 이하의 관계가 성립합니다.

$$ D(E(m_1) \diamond E(m_2)) = m_1 \circ m_2 $$

즉, 암호문 $E(m_1)$ 과 $E(m_2)$ 에 대해 어떤 연산 $\diamond$ 를 가한 결과를 복호화하면, 원래의 평문끼리 연산 $\circ$ 를 한 결과와 일치한다는 것입니다.

클라우드 컴퓨팅에서의 데이터 흐름

FHE를 이용한 클라우드 처리의 아키텍처는 기존의 것과 전혀 다릅니다. 다음 그림은 FHE를 활용한 안전한 데이터 처리의 흐름을 보여줍니다.

서버는 암호화된 데이터 $E(x)$ 를 받지만, 비밀키를 가지고 있지 않기 때문에 데이터의 내용을 아는 것은 절대 불가능합니다. 그러나 FHE의 성질을 이용함으로써, 암호문에 대해 함수 $f$(예를 들어 기계 학습의 추론 모델)를 적용하여 $E(f(x))$ 를 생성할 수 있습니다. 클라이언트는 이것을 받아 자신의 비밀키로 복호화함으로써 목적하는 결과 $y = f(x)$ 를 얻게 됩니다.

2. 동형암호의 진화 역사: PHE, SHE, FHE

동형암호는 단번에 현재의 ‘완전’한 형태가 된 것은 아닙니다. 실현할 수 있는 연산의 종류나 횟수에 따라 크게 3가지 단계로 분류됩니다.

Partially Homomorphic Encryption (PHE: 부분동형암호)

PHE는 덧셈이나 곱셈 중 어느 한쪽만을 무제한으로 수행할 수 있는 암호 방식입니다. 사실 이 성질을 가진 암호는 예전부터 존재했습니다.

RSA 암호 (곱셈에 대한 동형성) RSA 암호는 의도치 않게 곱셈의 동형성을 가지고 있었습니다. 평문 $m_1, m_2$, 공개키 $(e, N)$ 이라고 하면: $$ E(m_1) = m_1^e \pmod N $$ $$ E(m_2) = m_2^e \pmod N $$ 이들을 곱하면: $$ E(m_1) \times E(m_2) = (m_1 \cdot m_2)^e \pmod N = E(m_1 \times m_2) $$ 이와 같이 암호문끼리의 곱셈이 평문의 곱셈에 대응합니다.
Paillier 암호 (덧셈에 대한 동형성) 1999년에 고안된 Paillier 암호는 덧셈에 대한 동형성을 가집니다. 전자투표(암호화된 표를 집계하고, 최종 결과만 복호화하는 등) 등에서 실용화되어 있습니다.

Somewhat Homomorphic Encryption (SHE: 유한동형암호)

덧셈과 곱셈 모두를 실행할 수 있지만, 연산할 수 있는 횟수(회로의 깊이)에 제한이 있는 방식입니다. 후술할 ‘노이즈’의 축적으로 인해 특정 횟수 이상의 곱셈을 수행하면 복호화가 불가능해집니다. 2005년의 BGN (Boneh-Goh-Nissim) 암호 등이 이에 해당하지만, 실용적이고 복잡한 계산(딥러닝 등)을 수행하기에는 한계가 있었습니다.

Fully Homomorphic Encryption (FHE: 완전동형암호)

덧셈과 곱셈 모두를 횟수 제한 없이 실행할 수 있는 암호 방식입니다. 정보 이론에서의 튜링 완전성과 마찬가지로, 덧셈(XOR에 해당)과 곱셈(AND에 해당)을 무한히 조합할 수 있다면 원리상 어떠한 계산 가능한 함수나 알고리즘도 암호화된 채로 실행할 수 있음을 의미합니다.

FHE는 오랫동안 ‘암호계의 성배’로 불리며 실현 불가능한 것이 아닌가 하는 이야기도 있었습니다. 하지만 2009년 당시 스탠포드 대학교 박사과정에 있던 Craig Gentry가 이상 격자(Ideal Lattices)를 이용한 최초의 FHE 체계를 제안하며 세계에 충격을 안겨주었습니다.

3. FHE의 수학적 기반: LWE 문제와 Ring-LWE

현재 주류가 되고 있는 FHE 체계의 대부분은 내양자 컴퓨터 암호(Post-Quantum Cryptography)로도 알려진 ‘격자 기반 암호(Lattice-based Cryptography)‘의 수학적 난제인 LWE (Learning With Errors) 문제에 기반하고 있습니다.

LWE 문제의 직관적인 이해

연립일차방정식을 푸는 것은 가우스 소거법 등을 이용하면 간단합니다.

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 \equiv 12 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 \equiv 8 \pmod{17} \\ \vdots \end{cases} $$

하지만 이 방정식의 결과에 아주 약간의 ‘무작위 오차(노이즈)’ $e$ 를 더하면 어떻게 될까요.

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 + e_1 \equiv 13 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 + e_2 \equiv 7 \pmod{17} \\ \vdots \end{cases} $$

이 오차 $e$ 가 더해지는 것만으로 비밀 변수 벡터 $\vec{s}$ 를 찾아내는 문제는 현재의 슈퍼컴퓨터나 양자컴퓨터를 이용해도 해독하기 어려운 NP-난해(NP-hard) 문제로 변모합니다. 이것이 LWE 문제입니다.

Ring-LWE 문제 (RLWE)

표준 LWE 문제는 행렬 연산을 포함하기 때문에 키의 크기가 매우 크고(기가바이트 단위가 되기도 함) 계산 효율도 나쁘다는 문제가 있었습니다. 이를 해결하기 위해 도입된 것이 다항식 환(Polynomial Ring) 위에서의 연산을 이용하는 Ring-LWE (RLWE) 문제입니다.

RLWE에서는 원소가 다항식 환 $R_q = \mathbb{Z}_q[x] / (x^N + 1)$ 에 속합니다(여기서 $N$ 은 2의 거듭제곱, $q$ 는 법이 되는 소수). 비밀키를 다항식 $s(x)$ 라 하고, 무작위 다항식 $a(x)$, 작은 노이즈 다항식 $e(x)$ 라고 하면, 공개키는 다음과 같은 쌍이 됩니다.

$$ (a(x), b(x)) \quad \text{where} \quad b(x) = -a(x) \cdot s(x) + e(x) \pmod q $$

암호화할 때는 이 다항식의 성질을 이용하여 평문 $m(x)$ 를 인코딩하고 암호문을 생성합니다.

4. 최대의 장벽 ‘노이즈’와 Gentry의 부트스트래핑

FHE의 이해에 있어 가장 중요한 개념이 **‘노이즈의 관리’**입니다.

LWE/RLWE 기반의 암호에서는 안전성을 담보하기 위해 의도적으로 작은 ‘노이즈(오차)‘를 포함하고 있습니다. 평문 $m$ 의 암호문 $c$ 를 복호화하는 과정은 대략적으로 말하면 다음과 같은 수식으로 표현됩니다.

$$ D(c) = (c \cdot s) \pmod q = m + \text{noise} $$

복호화 시에는 이 noise 를 반올림 처리 등으로 제거함으로써 올바른 평문 $m$ 을 얻습니다. 그러나 암호문끼리 동형 연산(특히 곱셈)을 수행하면 이 노이즈가 극적으로 증폭되어 버립니다.

동형 덧셈: 노이즈는 덧셈적으로 증가합니다($e_1 + e_2$). 이는 비교적 완만한 증가입니다.
동형 덧셈에 의한 동형성의 수식 표현: $$ E(m_1) \oplus E(m_2) = E(m_1 + m_2) $$
동형 곱셈: 노이즈는 곱셈적으로 폭발합니다($e_1 \times e_2$ 등을 포함하기 때문). 몇 번 곱셈하는 것만으로 노이즈가 임계값 $q/2$ 를 넘어버려 올바른 반올림 처리가 불가능해 복호화에 실패합니다.
동형 곱셈에 의한 동형성의 수식 표현: $$ E(m_1) \otimes E(m_2) = E(m_1 \times m_2) $$

이것이 오랫동안 FHE가 실현되지 못하고 SHE(횟수 제한 있음)에 머물러 있었던 이유입니다.

부트스트래핑(Bootstrapping)의 마법

Craig Gentry의 천재적인 공헌은 **‘부트스트래핑’**이라 불리는 노이즈 감소 기법을 발명한 것입니다. 이는 암호학에 있어서 패러다임 전환이었습니다.

직관적으로는 ‘암호문이 노이즈 투성이가 되어 망가지기 전에, 암호화된 채로 “복호화"하여 깨끗하게 만들고 새로운 암호문에 다시 넣는다’는 조작입니다.

노이즈가 커진 암호문 $C_{noisy}$ 가 있다고 가정합니다.
클라이언트는 비밀키 $sk$ 를 ‘공개키로 암호화한 것’ $E_{pk}(sk)$ (이를 부트스트래핑 키라고 부름)를 미리 서버에 건네줍니다.
서버는 $C_{noisy}$ 에 대해 동형적으로 **복호화 회로(Decryption Circuit)**를 실행합니다.
구체적으로는 $E_{pk}(C_{noisy})$ 에 대해 $E_{pk}(sk)$ 를 이용하여 ‘암호화된 공간 내에서의 복호화’를 수행합니다.
이 복호화 회로 자체도 동형 연산이기 때문에 새로운 노이즈를 낳지만, 출력되는 새로운 암호문 $C_{fresh}$ 의 노이즈는 일정한 ‘고정 레벨’로 초기화(리셋)됩니다.

graph LR A["높은 노이즈 암호문 C_noisy"] --> B["동형 복호화 회로 (Eval_Dec)"] C["암호화된 비밀키 E(sk)"] --> B B --> D["낮은 노이즈 암호문 C_fresh"] style B fill:#ffeeba,stroke:#ffc107

이 부트스트래핑을 계산 도중에 정기적으로 실행함으로써, 이론상으로는 무한한 깊이의 회로를 계산 가능(FHE의 달성)하게 만들었습니다. 하지만 초기의 Gentry 방식은 이 부트스트래핑 처리 1회당 수십 분에서 수 시간씩 걸리는 등 절망적일 정도로 계산 비용이 높았습니다.

5. FHE의 세대와 주요 체계의 진화

FHE의 실용화를 향해 전 세계의 암호학자들이 앞다투어 알고리즘을 개량해왔습니다. 현재 FHE는 크게 4개의 세대/제품군으로 분류됩니다.

제2세대: 정수의 정확한 연산 (BGV, BFV)

2011~2012년에 걸쳐 등장한 BGV (Brakerski-Gentry-Vaikuntanathan) 와 BFV (Brakerski/Fan-Vercauteren) 체계입니다. 이들은 RLWE를 기반으로 하고 있으며 정수의 모듈러 연산(정확한 계산)에 적합합니다. SIMD (Single Instruction, Multiple Data)와 같은 배칭(Batching) 기술을 지원하고 있어 하나의 거대한 다항식 암호문 속에 수천 개의 데이터 슬롯을 담아 한 번에 병렬 계산할 수 있는 것이 특징입니다.

제3세대: 부트스트래핑의 고속화 (GSW, FHEW, TFHE)

2013년의 GSW (Gentry-Sahai-Waters) 체계는 FHE의 구조를 보다 단순하게 만들었습니다. 그리고 이를 발전시킨 것이 현재의 주류 중 하나인 TFHE (Fast Fully Homomorphic Encryption over the Torus) 입니다. TFHE의 특징은 부트스트래핑이 매우 빠르다는(밀리초 단위) 점입니다. 게이트 단위(AND, XOR 등 논리 회로)에서의 연산에 강하며, 암호문의 크기도 비교적 작기 때문에 임의의 논리 회로를 고속으로 평가하는 데 적합합니다.

제4세대: 근사 계산과 기계 학습에의 특화 (CKKS)

2017년 Cheon 등에 의해 제안된 CKKS (Cheon-Kim-Kim-Song) 체계는 현재 AI·기계 학습의 프라이버시 보호에 있어서 결정판이라 할 수 있는 기술입니다. 지금까지의 FHE가 ‘정확한 정수 계산’을 고집했던 것에 반해, CKKS는 **‘부동소수점 수의 근사 계산’**을 암호화된 채로 지원합니다. 신경망의 학습이나 추론 등 작은 오차가 허용되는 실수 계산에 있어서 압도적인 성능을 발휘합니다.

다음 표는 목적별로 어떤 체계를 선택해야 하는지 요약한 것입니다.

체계 이름	특기인 데이터 형	권장되는 유스케이스	특징
BFV / BGV	정수 (Integer)	정확한 통계 계산, 금융 데이터 집계, DB 검색	SIMD 배칭에 의한 높은 처리량
CKKS	실수 (Real/Complex)	기계 학습 (DNN, 로지스틱 회귀), 신호 처리	근사 계산에 의한 고속화, 리스케일링
TFHE	불리언 값 (Boolean)	임의의 논리 회로, 문자열 검색, 비선형 함수의 평가	초고속 부트스트래핑 (밀리초 대)

6. 실천: FHE 라이브러리와 개념적인 코드

현재는 암호학에 대한 깊은 지식이 없어도 FHE를 이용할 수 있는 오픈소스 라이브러리가 다수 제공되고 있습니다.

Microsoft SEAL (Simple Encrypted Arithmetic Library): BFV, BGV, CKKS를 지원하는 C++ 라이브러리. 업계 표준 중 하나입니다. Python 바인딩인 TenSEAL 이 AI 엔지니어들 사이에서 인기가 있습니다.
Zama (Concrete): TFHE를 기반으로 한 프레임워크. Rust/Python으로 작성할 수 있으며 기존의 PyTorch 모델을 컴파일하여 FHE 상에서 구동하는 기능(Concrete ML)을 제공합니다.
OpenFHE: PALISADE의 후속으로, 모든 주요 체계를 지원하는 포괄적인 C++ 라이브러리입니다.

Python (TenSEAL) 을 이용한 FHE 프로그래밍 예시

여기서는 CKKS 체계를 이용해 암호화된 채로 실수 벡터를 더하고 곱하는 개념적인 Python 코드의 예시를 보여줍니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


import tenseal as ts

# 1. 컨텍스트 설정 (키 생성 포함)
# CKKS 체계를 사용하며 다항식의 차수를 8192로 설정
context = ts.context(
 ts.SCHEME_TYPE.CKKS,
 poly_modulus_degree=8192,
 coeff_mod_bit_sizes=[60, 40, 40, 60]
)
context.generate_galois_keys()
context.global_scale = 2**40 # 실수의 스케일링 팩터

# 2. 클라이언트 측: 데이터의 암호화
vector1 = [1.5, 2.5, 3.5]
vector2 = [2.0, 3.0, 4.0]

# 평문 벡터를 암호문으로 변환 (원래는 클라이언트 측에서 실행)
enc_v1 = ts.ckks_vector(context, vector1)
enc_v2 = ts.ckks_vector(context, vector2)

# 3. 서버 측: 암호화된 채로 수행하는 연산 (Data in Use 보호)
# 서버는 평문을 모르지만 덧셈과 곱셈을 실행할 수 있음
enc_add = enc_v1 + enc_v2
enc_mul = enc_v1 * enc_v2

# 4. 클라이언트 측: 결과의 복호화
# 비밀키를 가진 클라이언트만이 결과를 볼 수 있음
res_add = enc_add.decrypt()
res_mul = enc_mul.decrypt()

print(f"복호화된 덧셈 결과: {res_add}")
# 출력 예: [3.5000001, 5.5000001, 7.5000002] (근사 계산이기 때문에 미세한 오차가 포함됨)

print(f"복호화된 곱셈 결과: {res_mul}")
# 출력 예: [3.0000002, 7.5000005, 14.0000003]

위의 코드에서 알 수 있듯이, enc_v1 + enc_v2 처럼 일반적인 Python의 연산자를 오버로딩하여 직관적으로 암호문끼리의 계산을 작성할 수 있습니다. 서버 측에서는 벡터의 내용을 모른 채로 벡터 연산을 완료하고 있습니다.

7. FHE의 과제: 성능과 하드웨어 가속

FHE는 이론적으로 완벽한 보안을 제공하지만, 실용화에 있어서 최대의 과제는 **‘성능의 오버헤드’**입니다.

계산의 오버헤드: 평문에서의 계산에 비해 암호문에서의 계산은 CPU 상에서 수천 배~수만 배 느려집니다. 다항식의 곱셈이나 부트스트래핑에는 방대한 FFT(고속 푸리에 변환)나 NTT(수론 변환)의 계산이 필요합니다.
데이터 크기의 팽창 (Ciphertext Expansion): 수 바이트의 평문이 암호화되면 수 메가바이트가 될 수 있습니다. 이는 메모리 대역폭이나 네트워크 대역폭을 강하게 압박합니다.

하드웨어에 의한 해결 접근

이 오버헤드를 극복하기 위해 전 세계에서 FHE 전용 하드웨어 가속기(ASIC, FPGA, GPU 대응)의 개발이 진행되고 있습니다.

GPU 가속: NVIDIA 등의 강력한 GPU를 이용해 NTT 연산이나 부트스트래핑을 병렬화하는 연구가 진행되고 있으며 소프트웨어 구현 대비 수십 배의 고속화가 보고되고 있습니다(예: 100x.ai, Zama의 TFHE-rs CUDA backend).
DARPA DPRIVE 프로젝트: 미국 국방고등연구계획국(DARPA)은 FHE의 계산 속도를 평문 처리의 실행 속도와 동등한 수준(오버헤드 10배 이내)으로 끌어올리기 위한 전용 하드웨어 개발 프로젝트 ‘DPRIVE (Data Protection in Virtual Environments)‘를 추진하고 있으며, Intel이나 Microsoft, Intellectual Ventures 등이 참여하고 있습니다.
FPU (FHE Processing Unit) 의 등장: Cornami나 Optalysys 같은 스타트업이 광 컴퓨팅이나 특수한 실리콘 아키텍처를 이용한 FHE 전용 칩 개발에 나서고 있습니다.

가까운 미래에 AI에서의 NPU(Neural Processing Unit)처럼 서버나 클라우드 인프라에 ‘FPU’가 표준 탑재되는 시대가 올지도 모릅니다.

8. 기대되는 유스케이스

FHE가 실용적인 속도에 도달해가는 지금, 다음과 같은 분야에서의 파괴적 혁신이 기대되고 있습니다.

의료·유전체 분석의 프라이버시 보호: 여러 병원이 가진 환자의 진료 기록이나 DNA 데이터를 FHE로 암호화한 채 클라우드의 AI에게 학습시킴으로써 프라이버시 법(HIPAA나 GDPR)을 위반하지 않고 고정밀 암 진단 모델이나 신약 개발을 진행할 수 있습니다.
금융 기관의 부정 탐지·자금 세탁 방지 (AML): 경쟁하는 은행끼리 고객의 계좌 정보나 거래 내역을 밝히지 않고 암호화된 상태로 서로의 데이터를 대조하여 거대한 부정 송금 네트워크를 탐지하는 교차 은행 분석이 가능해집니다.
안전한 AI 추론 API (MaaS: Model as a Service): 사용자는 자신의 음성이나 얼굴 이미지, 프롬프트를 암호화하여 AI 서비스(ChatGPT와 같은 LLM 등)에 전송합니다. AI 제공자는 사용자의 입력을 일절 알지 못한 채로 답변을 생성하여 암호문으로 반환합니다. 이를 통해 ‘AI에게 개인 정보가 학습되거나 도난당한다’는 우려가 완전히 불식됩니다.

9. 결론: 암호의 미래는 ‘보이지 않는 계산’으로

1970년대에 공개키 암호(RSA)가 발명되어 인터넷 상의 안전한 통신(HTTPS 등)이 가능해진 것처럼, Craig Gentry에 의한 FHE의 발명은 암호의 역사에 있어서 가장 중요한 이정표 중 하나입니다.

현재 완전동형암호(FHE)는 연구실의 이론에서 벗어나 Microsoft, IBM, Intel, Google, 그리고 많은 스타트업들이 실용화를 향해 치열하게 경쟁하는 단계에 접어들었습니다. 계산 비용이나 데이터 크기라는 과제는 여전히 존재하지만 알고리즘의 세련화와 하드웨어 가속기의 진화에 의해 무어의 법칙을 뛰어넘는 속도로 성능 향상이 이어지고 있습니다.

수년 뒤, ‘데이터를 암호화한 채로 계산하는’ 것은 특별한 일이 아니라 클라우드 서비스에서의 표준적인 데이터 보호 모범 사례가 될 것입니다. FHE는 데이터 주도형 사회에서의 궁극적인 프라이버시와 데이터 활용의 양립을 실현하는 차세대 보안의 핵심입니다.

타원곡선 암호(ECC)의 수학적 기초와 C++에서의 구현

Fri, 11 Sep 2026 10:00:00 +0900

타원곡선 암호(ECC)의 수학적 기초와 C++에서의 구현

현대 암호 기술에서 **타원곡선 암호(Elliptic Curve Cryptography: ECC)**는 매우 중요한 역할을 담당하고 있습니다. 우리의 일상적인 인터넷 통신(HTTPS/TLS)부터 스마트폰의 보안 엔클레이브(Secure Enclave), SSH를 통한 서버 인증, FIDO와 같은 패스워드리스 인증, 심지어 비트코인이나 이더리움과 같은 암호화폐에 이르기까지 현대 디지털 사회의 신뢰 기반은 ECC에 의해 지탱되고 있다고 해도 과언이 아닙니다.

본 기사에서는 이 타원곡선 암호가 어떻게 기능하는지, 그 이면에 있는 아름답고도 난해한 수학적 이론(유한체 상의 대수기하학)에서 출발하여 실제 C++를 이용한 구현 방법, 나아가 부채널 공격(타이밍 공격)을 방지하기 위한 안전한 코딩 기법까지 압도적인 분량으로 철저하게 해설합니다.

1. 왜 타원곡선 암호인가? (RSA와의 비교)

공개키 암호 방식의 대명사라고 하면 오랫동안 RSA 암호를 떠올렸습니다. RSA 암호는 ‘거대한 합성수의 소인수분해의 어려움’을 안전성의 근거로 삼고 있습니다. 하지만 컴퓨터의 계산 능력이 향상됨에 따라 안전성을 유지하기 위해서는 RSA의 키 길이(모듈러스의 비트 수)를 지속적으로 늘려야 할 필요성이 생겼습니다. 현재는 최소 2048비트, 더 안전을 기한다면 3072비트나 4096비트의 키 길이가 권장되고 있습니다.

이에 반해, 타원곡선 암호(ECC)는 **‘타원곡선 상의 이산대수 문제(ECDLP)’**라는 또 다른 수학적 어려움을 안전성의 근거로 삼고 있습니다. ECDLP를 풀기 위한 효율적인 알고리즘(준지수 시간 알고리즘 등)은 현재까지 발견되지 않았으며, 알려진 가장 효율적인 공격 기법조차도 지수 함수적인 시간을 필요로 합니다.

이러한 성질로 인해 ECC는 매우 짧은 키 길이로 RSA와 동등한 보안 강도를 구현할 수 있다는 결정적인 장점을 가집니다.

보안 강도(비트)	RSA 암호의 키 길이(비트)	타원곡선 암호의 키 길이(비트)	키 길이 비율
80	1024	160	1:6
112	2048	224	1:9
128	3072	256	1:12
192	7680	384	1:20
256	15360	512	1:30

위의 표에서 알 수 있듯이, 128비트의 보안 강도(현재 표준적인 강도)를 얻기 위해 RSA에서는 3072비트의 키가 필요하지만, ECC라면 단 256비트면 충분합니다. 이를 통해 계산량 감소, 메모리 사용량 절감, 네트워크 대역폭 절약이 가능해지며, 특히 리소스가 제한된 IoT 기기나 스마트카드 환경에서 압도적인 우위를 자랑합니다.

2. 수학적 준비: 군론과 유한체의 세계

타원곡선 암호를 진정으로 이해하기 위해서는 추상대수학(군론 및 체론)의 기본 개념을 파악해 둘 필요가 있습니다. 여기서는 ECC를 구성하기 위한 사전 지식을 간결하게 정리합니다.

2.1. 군(Group)과 아벨 군

**군(Group)**이란 어떤 집합 $G$와 그 집합 상의 이항 연산(여기서는 덧셈 $+$로 합니다)의 쌍 $(G, +)$이며, 다음의 4가지 공리를 만족하는 것을 말합니다.

닫힘(Closure): 임의의 $a, b \in G$에 대해 $a + b \in G$이다.
결합 법칙(Associativity): 임의의 $a, b, c \in G$에 대해 $(a + b) + c = a + (b + c)$가 성립한다.
항등원의 존재(Identity element): 임의의 $a \in G$에 대해 $a + e = e + a = a$가 되는 원소 $e \in G$가 존재한다. 덧셈군의 경우, 이 항등원을 보통 $0$ 또는 $\mathcal{O}$로 표기합니다.
역원의 존재(Inverse element): 임의의 $a \in G$에 대해 $a + b = b + a = e$가 되는 원소 $b \in G$가 존재한다. 이 $b$를 $-a$로 표기합니다.

더 나아가 연산의 순서를 바꾸어도 결과가 변하지 않는, 즉 다음 조건을 만족하는 군을 **아벨 군(가환군)**이라고 부릅니다.

교환 법칙(Commutativity): 임의의 $a, b \in G$에 대해 $a + b = b + a$가 성립한다.

타원곡선 상의 점들의 집합은 특정한 덧셈 규칙을 정의함으로써 이 아벨 군을 구성합니다.

2.2. 유한체(Finite Field)

암호 이론에서는 실수나 복소수처럼 연속적이고 무한한 요소를 가진 체가 아니라, 원소의 개수가 유한한 유한체(Finite Field) 또는 갈루아 체(Galois Field)를 사용합니다.

가장 기본적인 유한체는 소수 $p$를 사용한 **소체 $\mathbb{F}_p$**입니다. 이는 $\{0, 1, 2, \dots, p-1\}$의 정수 집합에 모듈로 $p$($p$로 나눈 나머지)에서의 사칙연산(덧셈, 뺄셈, 곱셈, 나눗셈)을 정의한 것입니다.

덧셈: $(a + b) \pmod p$
뺄셈: $(a - b) \pmod p$
곱셈: $(a \times b) \pmod p$
나눗셈: $a \times b^{-1} \pmod p$ (여기서 $b^{-1}$은 모듈로 $p$에서의 $b$의 곱셈 역원)

**곱셈 역원(Modular Multiplicative Inverse)**의 계산은 암호 구현에서 매우 중요합니다. $b \times b^{-1} \equiv 1 \pmod p$를 만족하는 $b^{-1}$을 구하기 위해서는 주로 다음 두 가지 알고리즘이 사용됩니다.

확장 유클리드 호제법(Extended Euclidean Algorithm): 빠르지만, 구현에 따라 처리 시간이 입력값에 의존하기 때문에 타이밍 공격의 위험이 있습니다.
페르마의 소정리(Fermat’s Little Theorem): $p$가 소수이고 $b \neq 0$일 때, $b^{p-1} \equiv 1 \pmod p$가 성립합니다. 양변을 $b$로 나누면 $b^{p-2} \equiv b^{-1} \pmod p$가 됩니다. 즉, $b$의 $p-2$ 제곱을 계산함으로써 역원을 구할 수 있습니다. 거듭제곱 연산은 상수 시간(Constant-Time)으로 구현하기 쉽기 때문에, 암호 구현에서는 이 방법을 선호합니다.

3. 타원곡선의 방정식과 기하학

3.1. 바이어슈트라스의 표준형

**타원곡선(Elliptic Curve)**은 일반적으로 다음의 **바이어슈트라스 표준형(Weierstrass normal form)**이라고 불리는 방정식으로 정의되는 평면 곡선입니다.

$$ y^2 = x^3 + ax + b $$

여기서 $a$와 $b$는 상수이며, 곡선이 특이점(자기 교차점이나 뾰족점)을 가지지 않기(매끄러운 곡선이기) 위한 조건으로 다음의 **판별식(Discriminant) $\Delta$**가 0이 아니어야 합니다.

$$ \Delta = -16(4a^3 + 27b^2) \neq 0 $$

특이점을 가진 곡선은 암호학적 안전성을 손상시키기 때문에, 반드시 이 조건을 만족하는 계수 $a, b$가 선택됩니다.

3.2. 무한원점(Point at Infinity)

타원곡선을 수학적으로 완전한 군으로 만들기 위해, 평면 상의 점에 더해 **‘무한원점(Point at Infinity)’**이라고 불리는 가상의 점을 도입합니다. 이를 $\mathcal{O}$(오)라고 표기합니다.

무한원점 $\mathcal{O}$는 모든 수직선이 무한히 먼 곳에서 만나는 점으로 정의됩니다. 군론에서 이 무한원점 $\mathcal{O}$는 덧셈에 대한 항등원(0)으로 기능합니다.

즉, 곡선 상의 임의의 점 $P$에 대해 다음이 성립합니다.

$$ P + \mathcal{O} = \mathcal{O} + P = P $$

또한, 점 $P = (x, y)$의 역원 $-P$는 x축에 대해 대칭인 점 $(x, -y)$로 정의됩니다. 따라서:

$$ P + (-P) = \mathcal{O} $$

가 됩니다.

4. 타원곡선 상의 군 연산(점의 덧셈과 2배 연산)

타원곡선 암호의 근간을 이루는 것이 바로 곡선 상의 점들 간의 **‘덧셈(Addition)’**이라는 연산입니다. 이는 일반적인 정수의 덧셈과는 다르며 기하학적인 조작을 바탕으로 정의되어 있습니다.

4.1. 기하학적 덧셈(Tangent and Chord Method)

곡선 상의 서로 다른 두 점 $P$와 $Q$를 더하여 새로운 점 $R$ ($R = P + Q$)을 구하는 절차는 다음과 같습니다.

점 $P$와 점 $Q$를 지나는 직선(현)을 긋습니다.
이 직선은 타원곡선과 반드시 또 다른 한 점(이를 $-R$이라 합니다)에서 만납니다. (※ 대수기하학의 정리에 따름)
교점 $-R$을 x축에 대해 대칭으로 뒤집은 점(y좌표의 부호를 반전시킨 점)이 구하고자 하는 점 $R$이 됩니다.

graph TD Step1["P(x1, y1) 와 Q(x2, y2) 를 잇는 직선을 긋는다"] --> Step2["곡선과의 제3의 교점 -R 을 찾는다"] Step2 --> Step3["-R 을 x축으로 뒤집어, R(x3, y3) 을 얻는다"] Step3 -.-> Result["이것이 R = P + Q"]

4.2. 점의 2배 연산(Point Doubling)

점 $P$에 같은 점 $P$를 더하는 경우($P + P = 2P$), 두 점을 지나는 직선을 그을 수 없습니다. 이 경우에는 **점 $P$에서의 곡선의 접선(Tangent)**을 긋습니다.

점 $P$에서의 곡선의 접선을 긋습니다.
이 접선은 곡선과 또 다른 한 점 $-R$에서 만납니다.
교점을 x축에 대해 대칭으로 뒤집은 점이 구하고자 하는 점 $R = 2P$가 됩니다.

4.3. 대수적인 계산 공식

기하학적인 조작을 컴퓨터로 계산할 수 있도록 대수적인 공식으로 옮겨냅니다. 연산은 모두 **유한체 $\mathbb{F}_p$ 상(모듈로 $p$)**에서 이루어집니다.

점 $P = (x_1, y_1)$, 점 $Q = (x_2, y_2)$라고 합시다. 또한 계산 결과인 점을 $R = P + Q = (x_3, y_3)$이라 합시다.

직선의 기울기를 $\lambda$(람다)라고 합니다.

【케이스 1: $P \neq Q$ 인 경우 (점의 덧셈)】 기울기 $\lambda$는 두 점 사이의 변화율입니다.

$$ \lambda \equiv \frac{y_2 - y_1}{x_2 - x_1} \pmod p $$ $$ \lambda \equiv (y_2 - y_1) \cdot (x_2 - x_1)^{-1} \pmod p $$

이 $\lambda$를 사용하여 $x_3, y_3$은 다음과 같이 구합니다.

$$ x_3 \equiv \lambda^2 - x_1 - x_2 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

【케이스 2: $P = Q$ 인 경우 (점의 2배 연산)】 기울기 $\lambda$는 미분을 통해 구한 접선의 기울기가 됩니다. ($y^2 = x^3 + ax + b$를 암묵적으로 미분합니다)

$$ 2y \cdot y' = 3x^2 + a \implies y' = \frac{3x^2 + a}{2y} $$

따라서,

$$ \lambda \equiv (3x_1^2 + a) \cdot (2y_1)^{-1} \pmod p $$

$x_3, y_3$의 식은 덧셈과 같은 형태이지만, $x_2 = x_1$이므로 다음과 같이 됩니다.

$$ x_3 \equiv \lambda^2 - 2x_1 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[!IMPORTANT] 이러한 공식에는 $(x_2 - x_1)^{-1}$이나 $(2y_1)^{-1}$과 같은 **나눗셈(모듈로 역원의 계산)**이 포함되어 있습니다. 모듈로 역원의 계산은 계산 비용이 매우 높기 때문에, 실제 구현에서는 나눗셈을 지연시키는 ‘야코비 좌표계(Jacobian Coordinates)’ 등의 사영 좌표계가 일반적으로 사용됩니다.

5. 스칼라 곱셈과 타원곡선 이산대수 문제(ECDLP)

타원곡선 암호에서 가장 계산량이 많고, 동시에 보안의 핵심을 이루는 연산이 바로 **스칼라 곱셈(Scalar Multiplication)**입니다.

5.1. 스칼라 곱셈이란

어떤 점 $P$를 $k$번 더하는 조작을 스칼라 곱셈이라 부르며, $kP$라고 표기합니다.

$$ kP = \underbrace{P + P + \dots + P}_{k\text{번}} $$

여기서 $k$는 매우 큰 정수(예를 들어 256비트의 정수)입니다.

5.2. 타원곡선 이산대수 문제(ECDLP)

타원곡선 암호의 안전성은 다음 문제의 어려움에 의존하고 있습니다.

타원곡선 이산대수 문제(Elliptic Curve Discrete Logarithm Problem: ECDLP) 알려진 점 $P$(베이스 포인트)와 계산 결과인 점 $Q$가 주어졌을 때, $Q = kP$를 만족하는 스칼라 $k$를 구하시오.

$k$와 $P$로부터 $Q$를 계산하는 것(정방향)은 후술할 알고리즘을 사용하면 쉽지만(다항식 시간), $P$와 $Q$로부터 $k$를 역산하는 것(역방향)은 전수조사와 같은 무차별 대입 이외에는 효율적인 해법이 없어 사실상 불가능합니다(일방향 함수). 암호 프로토콜에서는 **$k$가 ‘개인키’, $Q$가 ‘공개키’**에 해당합니다.

5.3. Double-and-Add 알고리즘

$k$가 거대한 수(예: $2^{256}$)일 경우, $P$를 우직하게 $k$번 더하는 것은 우주의 수명이 다해도 끝나지 않습니다. 그래서 고속으로 스칼라 곱셈을 수행하기 위해 **Double-and-Add 방법(바이너리 방법)**이 사용됩니다.

이는 정수의 거듭제곱을 고속으로 계산하는 ‘반복 제곱법’의 타원곡선 버전입니다. 스칼라 $k$를 2진수로 표현하고, 최상위 비트부터 차례대로 처리합니다.

결과를 유지할 점 $R$을 $\mathcal{O}$로 초기화한다.
$k$의 최상위 비트부터 최하위 비트까지 다음을 반복한다:
- $R$을 2배로 한다 (Point Doubling: $R = 2R$)
- 만약 현재 비트가 1이라면, $R$에 $P$를 더한다 (Point Addition: $R = R + P$)

이 알고리즘을 통해 계산량은 $O(k)$에서 $O(\log_2 k)$로 극적으로 감소하며, 현실적인 시간(밀리초 단위) 내에 계산이 가능해집니다.

6. 타원곡선 디피-헬먼(ECDH) 키 교환

여기서는 ECC의 가장 대표적인 응용 사례인 ECDH(Elliptic Curve Diffie-Hellman) 키 교환 프로토콜의 작동 원리를 해설합니다. ECDH는 도청이 가능한 통신 채널 상에서 앨리스와 밥이 안전하게 공통의 비밀키(세션 키)를 생성 및 공유하기 위한 메커니즘입니다(TLS 핸드셰이크의 핵심입니다).

【전제 파라미터(도메인 파라미터)】 양측은 미리 사용할 타원곡선 $E$, 소수 $p$, 그리고 베이스 포인트 $G$를 공유하고 있습니다. (예: NIST P-256이나 secp256k1 등)

sequenceDiagram participant Alice as "Alice (앨리스)" participant Bob as "Bob (밥)" Note over Alice,Bob: "공개 파라미터: 곡선 E, 베이스 포인트 G, 소수 p" Alice->>Alice: "개인키 d_A (랜덤한 정수) 를 생성" Alice->>Alice: "공개키 Q_A = d_A * G 를 계산" Bob->>Bob: "개인키 d_B (랜덤한 정수) 를 생성" Bob->>Bob: "공개키 Q_B = d_B * G 를 계산" Alice->>Bob: "공개키 Q_A 를 전송 (평문)" Bob->>Alice: "공개키 Q_B 를 전송 (평문)" Alice->>Alice: "공유 시크릿 S = d_A * Q_B 를 계산" Bob->>Bob: "공유 시크릿 S = d_B * Q_A 를 계산" Note over Alice,Bob: "S = d_A * (d_B * G) = d_B * (d_A * G) = (d_A * d_B) * G" Note over Alice,Bob: "양측의 계산 결과 S 는 완전히 일치한다!"

도청자(이브)는 통신 경로 상에 흐르는 $G$, $Q_A$, $Q_B$를 가로챌 수 있지만, ECDLP의 어려움으로 인해 $Q_A = d_A \cdot G$로부터 앨리스의 개인키 $d_A$를 알아낼 수는 없습니다. 또한, $Q_A$와 $Q_B$를 곱해도 공유키 $S$가 되지 않으므로 도청자는 $S$를 계산할 수 없습니다.

7. 구현의 함정: 부채널 공격과 대책

이론적으로 완벽한 암호 알고리즘이라 하더라도 그것을 프로그램으로 구현하는 과정에서 취약점이 발생할 수 있습니다. 그것이 바로 **‘부채널 공격(Side-Channel Attack)’**입니다.

7.1. 타이밍 공격(Timing Attack)

앞서 언급한 Double-and-Add 알고리즘을 되돌아봅시다.

1
2
3
4
5
6
7
8


// 취약한 Double-and-Add 의 의사 코드
Point R = Point::Infinity;
for (int i = 255; i >= 0; i--) {
 R = PointDoubling(R); // 항상 실행됨
 if (bit(k, i) == 1) {
 R = PointAddition(R, P); // 비트가 1일 때만 실행됨!
 }
}

이 구현에는 치명적인 결함이 있습니다. 비트가 1일 때는 Point Addition이 실행되기 때문에 비트가 0일 때보다 계산 시간이 약간 더 길어집니다. 또한 프로세서의 분기 예측이나 캐시 메모리의 동작도 변하게 됩니다. 공격자가 이 계산 시간(혹은 소비 전력)의 미세한 차이를 수천 번 통계적으로 관측함으로써, 개인키 $k$의 비트열을 1비트씩 완전히 복원해 낼 수 있습니다. 이것이 타이밍 공격입니다.

7.2. Constant-Time 구현: Montgomery Ladder

타이밍 공격을 방지하기 위해서는, 개인키의 비트 값과 관계없이 실행되는 명령어의 시퀀스와 계산 시간이 항상 일정한(Constant-Time) 알고리즘을 채택해야 합니다.

그 대표적인 예가 **Montgomery Ladder(몽고메리 사다리)**입니다.

graph TD Start["초기화: R0 = O, R1 = P"] --> LoopStart["각 비트 i 에 대해 (최상위부터)"] LoopStart --> Cond{"k_i 의 값은?"} Cond -->|0| Branch0["R1 = R0 + R1
R0 = 2 * R0"] Cond -->|1| Branch1["R0 = R0 + R1
R1 = 2 * R1"] Branch0 --> LoopEnd["다음 비트로"] Branch1 --> LoopEnd LoopEnd --> LoopStart LoopStart -.->|"모든 비트 완료"| End["종료: R0 가 결과 (kP)"]

Montgomery Ladder의 아름다운 점은 비트가 0이든 1이든, **“항상 1번의 Point Addition과 1번의 Point Doubling”**이 실행된다는 것입니다. 이를 통해 계산 시간의 데이터 의존성이 완전히 배제됩니다.

단, 분기(if (k_i == 0)) 자체가 존재하면 컴파일러의 최적화나 CPU의 분기 예측에 의해 실행 시간이 변동할 위험이 남아 있습니다. 따라서 실제 Constant-Time 구현에서는 조건 분기(if문)를 배제하고, **비트 연산을 이용한 조건부 스왑(Conditional Swap)**을 활용합니다.

8. C++를 이용한 타원곡선 암호의 구현

이제부터는 이론을 C++ 코드로 구현해 보겠습니다. 실용적인 암호 라이브러리(OpenSSL이나 libsodium 등)는 고도화된 어셈블리 최적화나 야코비 좌표계를 사용하지만, 여기서는 수학적 이해를 돕기 위해 아핀(Affine) 좌표계를 이용한 알기 쉬운 Constant-Time 구현의 뼈대를 제시합니다.

거대한 정수의 연산에는 boost::multiprecision::cpp_int를 사용한다고 가정합니다.

8.1. 모듈로 연산과 역원

먼저 유한체 상의 연산 헬퍼 함수를 정의합니다. 페르마의 소정리에 의한 역원 계산을 구현합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <iostream>
#include <vector>
#include <stdexcept>
#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

// 예시로 secp256k1 의 소수 p 와 파라미터
const cpp_int p("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const cpp_int a = 0;
const cpp_int b = 7;

// 양의 나머지를 반환하는 모듈로 연산
cpp_int mod(cpp_int x, cpp_int m) {
 cpp_int r = x % m;
 return r < 0 ? r + m : r;
}

// 거듭제곱 나머지 계산 (x^y mod m)
cpp_int powerMod(cpp_int base, cpp_int exp, cpp_int m) {
 cpp_int res = 1;
 base = mod(base, m);
 while (exp > 0) {
 if (exp % 2 == 1) res = mod(res * base, m);
 base = mod(base * base, m);
 exp /= 2;
 }
 return res;
}

// 페르마의 소정리를 이용한 모듈로 역원
cpp_int modInverse(cpp_int n, cpp_int m) {
 // m이 소수라는 전제: n^(m-2) ≡ n^(-1) mod m
 return powerMod(n, m - 2, m);
}

8.2. 점의 표현과 군 연산(덧셈·2배 연산)

무한원점을 플래그로 관리하는 Point 구조체와 덧셈 공식을 구현합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


struct Point {
 cpp_int x;
 cpp_int y;
 bool isInfinity;

 // 무한원점의 생성
 Point() : x(0), y(0), isInfinity(true) {}

 // 일반적인 점의 생성
 Point(cpp_int x, cpp_int y) : x(x), y(y), isInfinity(false) {}
};

// 타원곡선 상의 점의 덧셈 (R = P + Q)
Point pointAdd(const Point& P, const Point& Q) {
 if (P.isInfinity) return Q;
 if (Q.isInfinity) return P;

 if (P.x == Q.x && mod(P.y + Q.y, p) == 0) {
 return Point(); // P + (-P) = 무한원점
 }

 cpp_int lambda;
 if (P.x == Q.x && P.y == Q.y) {
 // Point Doubling (P = Q 인 경우)
 // lambda = (3x^2 + a) / 2y
 cpp_int num = mod(3 * P.x * P.x + a, p);
 cpp_int den = modInverse(mod(2 * P.y, p), p);
 lambda = mod(num * den, p);
 } else {
 // Point Addition (P != Q 인 경우)
 // lambda = (y2 - y1) / (x2 - x1)
 cpp_int num = mod(Q.y - P.y, p);
 cpp_int den = modInverse(mod(Q.x - P.x, p), p);
 lambda = mod(num * den, p);
 }

 cpp_int x3 = mod(lambda * lambda - P.x - Q.x, p);
 cpp_int y3 = mod(lambda * (P.x - x3) - P.y, p);

 return Point(x3, y3);
}

8.3. Constant-Time Conditional Swap 의 구현

개인키의 비트 값에 따라 변수의 내용을 교환할 때, if문을 사용하지 않고 비트 연산(마스크)만으로 교환을 수행합니다. 이를 통해 실행 경로가 완전히 일정해집니다.

[!TIP] 실제 구현에서는 cpp_int와 같이 동적으로 할당되는 다정밀도 정수 클래스는 Constant-Time 처리에 적합하지 않습니다. 메모리 할당이나 배열 크기의 변동에 따라 타이밍 정보가 유출되기 때문입니다. 실용적인 라이브러리에서는 고정 길이(예: uint64_t × 4요소 배열)로 표현하고, 비트 단위의 마스크 처리를 구현합니다. 다음은 개념적인 예시입니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// 개념적인 Constant-Time Swap (고정 길이 정수를 가정한 경우)
// bit 가 1 이면 P1 과 P2 를 교환하고, 0 이면 교환하지 않음
void cswap(Point& P1, Point& P2, uint8_t bit) {
 // bit 는 0 또는 1. 마스크는 bit=1 이면 모든 비트가 1(0xFF..), 0이면 모든 비트가 0.
 // (여기서는 설명을 위해 고정 길이 BigInt 클래스의 각 워드를 w라 가정)
 /*
 uint64_t mask = 0 - (uint64_t)bit;
 for (int i = 0; i < NUM_WORDS; i++) {
 uint64_t dummy = mask & (P1.x.words[i] ^ P2.x.words[i]);
 P1.x.words[i] ^= dummy;
 P2.x.words[i] ^= dummy;
 // y좌표나 isInfinity 플래그도 동일하게 처리
 }
 */

 // ※ boost::multiprecision 에서 완벽한 상수 시간 스왑은 어렵지만,
 // 여기서는 로직의 이해를 위해 분기를 통한 시뮬레이션에 그칩니다.
 if (bit == 1) {
 std::swap(P1, P2);
 }
}

8.4. Montgomery Ladder 에 의한 스칼라 곱셈

앞서 설명한 pointAdd와 cswap을 결합하여 안전한 스칼라 곱셈을 구현합니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// 스칼라 곱셈 k * P (Montgomery Ladder 방식)
Point scalarMultiply(const Point& P, cpp_int k) {
 Point R0 = Point(); // 무한원점
 Point R1 = P;

 // k 의 비트 길이를 가져옴 (secp256k1 이라면 256 비트)
 int numBits = 256;

 for (int i = numBits - 1; i >= 0; i--) {
 // i번째 비트의 값을 가져옴 (0 또는 1)
 uint8_t bit = static_cast<uint8_t>(bit_test(k, i) ? 1 : 0);

 // bit == 1 이라면 R0 와 R1 을 스왑
 cswap(R0, R1, bit);

 // 항상 같은 연산을 실행 (Point Addition 과 Point Doubling)
 R1 = pointAdd(R0, R1);
 R0 = pointAdd(R0, R0);

 // bit == 1 이었던 경우, 상태를 원래대로 되돌리기 위해 다시 스왑
 cswap(R0, R1, bit);
 }

 return R0;
}

이 구현 로직을 통해, 스칼라 $k$의 각 비트가 0이든 1이든, 각 루프 이터레이션 내에서 실행되는 연산(cswap $\to$ pointAdd $\to$ pointAdd $\to$ cswap)은 완전히 동일한 흐름이 되어, 타이밍이나 캐시 액세스 패턴의 차이를 통한 비밀 정보의 유출을 강력하게 방지할 수 있습니다.

9. 요약

타원곡선 암호(ECC)는 처음 보았을 때는 “어째서 직선을 긋고 교점을 뒤집는 기하학적인 조작이 암호가 되는 걸까?” 하고 신기하게 느껴질 수도 있습니다. 하지만 유한체라는 이산적인 세계로 매핑함으로써 훌륭한 일방향 함수(이산대수 문제)를 구축할 수 있다는, 수학과 암호학의 기적적인 융합의 산물입니다.

본 기사에서는 다음의 중요한 요점들을 해설했습니다.

RSA 대비 우위성: 매우 짧은 키 길이로 강력한 보안을 제공하며, 현대의 모바일·IoT 시대에 최적화되어 있습니다.
군론과 유한체의 기초: ECC의 토대가 되는 수학적 구조.
덧셈과 2배 연산의 공식: 바이어슈트라스 방정식을 이용한 대수적인 군 연산의 구현 방법.
부채널 공격의 위협: 개인키의 비트에 의존하는 조건 분기가 치명적인 취약점을 발생시킨다는 점.
Constant-Time 구현: Montgomery Ladder와 Conditional Swap을 이용해 하드웨어 수준의 동작을 균일화하여 공격을 방지하는 C++ 코딩 기법.

실제 프로덕션 환경에서 동작하는 암호 라이브러리를 직접 만드는 것은 보안상 위험이 매우 높기 때문에 권장되지 않습니다(“Don’t roll your own crypto”). 하지만 그 내부에서 동작하고 있는 알고리즘과 수학적 배경을 깊이 이해하는 것은 더 안전하고 퍼포먼스가 높은 시스템을 설계 및 운영하는 엔지니어에게 둘도 없이 강력한 무기가 될 것입니다.

다음 기사에서는 이 타원곡선을 이용한 디지털 서명 알고리즘인 **ECDSA(Elliptic Curve Digital Signature Algorithm)**의 메커니즘이나, 비트코인에서 채택된 **Schnorr 서명(슈노르 서명)**에 대해 한층 더 깊이 파고들어 보고자 합니다.

GNFS(일반 수체 체)를 뛰어넘는 알고리즘은 존재하는가?

Fri, 11 Sep 2026 09:00:00 +0900

1. 서론: 소인수분해와 현대 암호의 근간

현대 사회에서 인터넷 통신의 안전성은 공개키 암호인 RSA 암호의 안전성에 크게 의존하고 있습니다. 그리고 RSA 암호의 안전성은 ‘거대한 합성수의 소인수분해의 어려움’이라는 수학적 가정에 기반을 두고 있습니다. 만약 극도로 효율적인 소인수분해 알고리즘이 발견된다면, 전 세계의 통신 인프라는 뿌리째 흔들리게 될 것입니다.

현재 고전 컴퓨터를 이용한 거대 정수의 소인수분해에서 가장 빠르고 강력한 알고리즘으로 군림하고 있는 것이 **일반 수체 체(GNFS: General Number Field Sieve)**입니다. GNFS는 1980년대 후반에 제안된 특수 수체 체(SNFS)를 확장하는 형태로 탄생했으며, 오늘날까지 RSA-768이나 RSA-250과 같은 거대한 합성수의 소인수분해 기록을 수립해 왔습니다.

그러나 암호학자들과 수학자들은 항상 다음과 같은 의문을 품고 있습니다. “GNFS를 뛰어넘는 고전적 알고리즘은 존재하는가?”, “고전 컴퓨터의 한계는 어디까지인가?”, 그리고 “양자 컴퓨터는 어떻게 이 상황을 타파할 것인가?”

본 기사에서는 GNFS 이면에 있는 심연의 수학적 구조를 철저하게 해부하고, 다항식 선택, 체질(Sieving) 처리, 블록 위더만(Block-Wiedemann) 방법을 통한 선형대수 단계 등 상세한 기술적 분석을 수행합니다. 나아가 Coppersmith의 개선 등을 통한 GNFS의 확장 기법에 대해 고찰하고, 고전적인 준지수 시간(Sub-exponential time) 알고리즘과 양자 다항식 시간 알고리즘의 결정적인 차이를 수리적 관점에서 비교 및 해설합니다.

2. 점근적 시간 복잡도와 L 표기법(L-notation)

소인수분해 알고리즘의 계산 복잡도를 평가할 때, 표준적인 다항식 시간 표기($O(n^k)$ 등)가 아니라 입력 $n$의 자릿수에 대한 준지수 시간을 표현하기 위해 **L 표기법(L-notation)**이 사용됩니다. L 표기법은 다음과 같이 정의됩니다.

$$ L_n[\alpha, c] = \exp \left( (c + o(1)) (\ln n)^\alpha (\ln \ln n)^{1-\alpha} \right) $$

여기서 $n$은 소인수분해의 대상이 되는 정수, $\ln n$은 자연로그이며 $n$의 비트 길이에 비례합니다.

$\alpha = 0$인 경우: $L_n[0, c] = \exp(c \ln \ln n) = (\ln n)^c$가 되어, 비트 길이에 대한 **다항식 시간(Polynomial time)**을 나타냅니다.
$\alpha = 1$인 경우: $L_n[1, c] = \exp(c \ln n) = n^c$가 되어, 비트 길이에 대한 **지수 시간(Exponential time)**을 나타냅니다.
$0 < \alpha < 1$인 경우: 다항식 시간과 지수 시간의 중간에 위치하는 **준지수 시간(Sub-exponential time)**이 됩니다.

과거 소인수분해 알고리즘의 진화는 이 $\alpha$ 값을 서서히 줄여온 역사이기도 했습니다.

연분수법(CFRAC)이나 다중 다항식 이차 체(MPQS): $\alpha = 1/2$ 클래스에 속하며, 계산 복잡도는 $L_n[1/2, 1]$ 정도입니다.
일반 수체 체(GNFS): $\alpha = 1/3$을 달성하여, 현재 알려진 고전 알고리즘 중 가장 빠른 $L_n[1/3, (64/9)^{1/3}]$이라는 계산 복잡도를 자랑합니다.

3. GNFS(일반 수체 체)의 알고리즘 전모와 수학적 구조

GNFS는 매우 복잡하고 고도화된 수학적 기반을 가지고 있습니다. 기본 아이디어는 페르마의 소정리나 이차 체(QS)의 연장선에 있으며, 합동식 $X^2 \equiv Y^2 \pmod n$을 만족하면서 $X \not\equiv \pm Y \pmod n$이 되는 자명하지 않은 쌍 $(X, Y)$를 찾음으로써 $n$의 인수 $\gcd(X-Y, n)$을 도출해내는 것입니다.

하지만 GNFS의 진수는 이를 유리수체 $\mathbb{Q}$에서만 수행하는 것이 아니라, 대수체(Algebraic Number Field)라 불리는 확대체 $\mathbb{Q}(\alpha)$와 유리수체 양쪽에서 동시에 ‘매끄러운 수(Smooth numbers)‘를 탐색하고, 준동형 사상을 통해 합동 관계를 구축한다는 점에 있습니다.

GNFS의 과정은 크게 5개의 단계로 나뉩니다.

graph TD A["소인수분해 문제 (입력 n)"] --> B["1. 다항식 선택 (Polynomial Selection)"] B --> C["2. 체질 처리 (Sieving Phase)"] C --> D["3. 필터링 (Filtering Phase)"] D --> E["4. 선형대수 (Linear Algebra Phase)"] E --> F["5. 제곱근 (Square Root Phase)"] F --> G["소인수 p, q 출력"]

3.1 1단계: 다항식 선택 (Polynomial Selection)

GNFS의 성공은 적절한 다항식의 선택에 크게 의존합니다. 목표는 공통 근 $m$을 가지는 두 개의 기약다항식 $f_1(x)$(유리수 측)와 $f_2(x)$(대수 측)를 찾는 것입니다. 즉, $f_1(m) \equiv f_2(m) \equiv 0 \pmod n$ 을 만족합니다.

통상적으로 유리수 측의 다항식은 1차식 $f_1(x) = x - m$을 선택하고, 대수 측의 다항식 $f_2(x)$는 차수 $d$(일반적으로 5나 6)의 모닉(monic) 다항식을 선택합니다. 가장 고전적인 접근법은 Base-$m$ 메서드입니다. $n$의 $1/(d+1)$ 제곱에 가까운 정수 $m = \lfloor n^{1/(d+1)} \rfloor$을 선택하고, $n$을 $m$진수로 전개합니다. $n = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$ 이를 통해 다항식 $f_2(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_0$을 얻습니다. 명백하게 $f_2(m) = n \equiv 0 \pmod n$이 됩니다.

그러나 현대의 구현에서는 Kleinjung의 알고리즘이 사용됩니다. 이는 다항식의 계수가 극단적으로 커지지 않게 하면서(Skewness 최적화), 대수적 성질(Murphy’s $E$ value나 $\alpha$-value)을 최적화하고, 체질(Sieving) 처리에서 매끄러운 수가 쉽게 생성될 수 있는 다항식을 탐색합니다. 이 단계에만 막대한 계산 자원이 투입됩니다.

3.2 2단계: 체질 처리 (Sieving Phase)

다항식이 결정되면 알고리즘에서 가장 계산 부하가 큰 ‘체(Sieving)’ 단계에 진입합니다. 여기서는 쌍 $(a, b)$를 탐색합니다. 이 쌍은 서로소이며, 다음 두 값이 동시에 ‘매끄러울(Smooth)’ 것이 요구됩니다.

유리수 측의 노름(Norm): $F_1(a, b) = b \cdot f_1(a/b) = a - bm$
대수 측의 노름(Norm): $F_2(a, b) = b^d \cdot f_2(a/b)$

‘매끄럽다’는 것은 지정된 상한(Sieve bound) 이하의 소수로만 소인수분해 가능하다는 것을 의미합니다. 유리수 측의 소수 기반(Factor base)과 대수 측의 소수 기반을 준비하여, 거대한 탐색 공간 위에서 에라토스테네스의 체와 같은 요령으로 매끄러운 수를 효율적으로 찾아냅니다. 현재는 **격자 체(Lattice Sieving)**라 불리는 기법이 주류를 이루고 있으며, 특정 소수 $q$를 고정하여 유리수 측과 대수 측 모두가 $q$의 배수가 되는 부분 격자 상의 $(a, b)$ 쌍만을 체로 걸러냄으로써 극도로 높은 효율을 실현하고 있습니다.

3.3 3단계: 필터링 (Filtering Phase)

체질 처리에서 발견된 매끄러운 관계식(Relation)의 수는 수억, 수십억 개에 달합니다. 하지만 이들은 쓸모없는 정보도 많이 포함하고 있습니다. 필터링의 목적은 거대한 희소 행렬(Sparse Matrix)을 구축하면서 그 차원을 가능한 한 작게 만드는 것입니다.

구체적으로 다음과 같은 조작을 수행합니다.

Singleton removal: 1번만 나타나는 소인수를 포함하는 관계식을 삭제합니다.
Clique removal / Merging: 2번 이상 나타나는 소인수를 가진 관계식끼리 곱하여 변수를 소거하고, 밀도는 더 높으면서도 차원이 작은 방정식계로 축약합니다.

이를 통해 수십억 행의 행렬이 수천만 행 수준의 거대한 희소 행렬 $\mathbf{A}$(원소는 체 $\mathbb{F}_2$ 위의 0과 1)로 압축됩니다.

3.4 4단계: 선형대수 (Linear Algebra Phase)

여기서는 방정식 $\mathbf{A} \mathbf{x} \equiv \mathbf{0} \pmod 2$의 자명하지 않은 해 벡터 $\mathbf{x}$를 찾습니다. 즉, 거대한 희소 행렬의 좌측 영공간(Left Nullspace)을 구하는 문제입니다.

행렬의 크기가 극단적으로 크기 때문에 통상적인 가우스 소거법($O(N^3)$)으로는 도저히 계산이 불가능합니다. 그래서 크릴로프 부분공간법(Krylov subspace method)의 일종인 반복법이 사용됩니다. 역사적으로는 **블록 란초스법(Block Lanczos)**이 사용되어 왔지만, 현재의 분산 컴퓨팅 환경에서는 통신 오버헤드를 극적으로 줄일 수 있는 **블록 위더만법(Block Wiedemann Algorithm)**이 주류입니다.

블록 위더만법은 행렬 $\mathbf{A}$와 벡터 수열로부터 최소 다항식을 계산하고, 벌리캠프-매시(Berlekamp-Massey) 알고리즘을 이용하여 영공간의 기저를 구성합니다. 이 단계는 병렬화가 매우 어려워 슈퍼컴퓨터나 대규모 클러스터의 밀결합 통신 네트워크를 요구하는, GNFS 최대의 병목 현상 중 하나입니다.

3.5 5단계: 제곱근 (Square Root Phase)

선형대수의 해로부터 유리수 측과 대수 측 각각에서 ‘완전제곱’이 되는 곱을 구성합니다. 유리수 측에서는 $\prod (a-bm)$이 어떤 정수 $X$의 제곱 $X^2$이 되고, 대수 측에서는 대응하는 이디얼(ideal)의 곱이 대수체 상에서 완전제곱 $\gamma^2$이 됩니다. 이 $\gamma$를 대수체 위에서 계산하고, 유리정수환으로의 준동형 사상 $\phi: \alpha \mapsto m \pmod n$을 적용함으로써 합동식: $X^2 \equiv \phi(\gamma)^2 \equiv Y^2 \pmod n$ 을 얻게 됩니다.

대수체 상의 제곱근 계산에는 몽고메리의 방법(Montgomery’s Method) 등의 복잡한 알고리즘이 사용되며, 대수적 정수론의 깊은 지식이 요구됩니다. 최종적으로 $\gcd(X-Y, n)$을 계산하여 자명하지 않은 인수를 얻게 되면 소인수분해가 완료됩니다.

4. GNFS를 뛰어넘는 고전 알고리즘은 존재하는가?

현재까지 일반 정수에 대한 소인수분해에서 점근적 계산 복잡도가 $L_n[1/3, c]$를 밑도는 고전 알고리즘은 발견되지 않았습니다. 그러나 이론적, 실천적 한계를 돌파하기 위한 몇 가지 시도나 파생 알고리즘이 존재합니다.

4.1 다중 수체 체 (MNFS: Multiple Number Field Sieve)

GNFS를 확장한 접근법으로 D. Coppersmith에 의한 **다중 수체 체(MNFS)**가 있습니다. GNFS에서는 2개의 다항식(유리수 측과 대수 측)을 사용하지만, MNFS에서는 1개의 유리수 측 다항식에 대해 여러 개의 다른 대수 측 다항식을 동시에 사용합니다.

$$ f_1(x), f_{2,1}(x), f_{2,2}(x), \dots, f_{2,V}(x) $$

여러 개의 대수체를 이용함으로써 각 체질 단계에서 ‘어느 한 대수체에서 매끄러워질’ 확률을 비약적으로 높일 수 있습니다. Coppersmith는 이 접근법을 통해 계산 복잡도 $L_n[1/3, c]$의 상수 $c$를 약간 감소시키는 데 성공했습니다. 구체적으로, GNFS의 상수가 $c = (64/9)^{1/3} \approx 1.923$인 반면, MNFS를 최적화하면 $c \approx 1.902$ 정도까지 계산량을 줄일 수 있음이 이론적으로 증명되었습니다. 그러나 실제 적용에 있어서는 여러 체를 관리하는 오버헤드가 크기 때문에, 실용적 규모의 RSA 모듈러스에 대한 결정적인 돌파구에는 이르지 못했습니다.

4.2 $L_n[1/4]$ 클래스의 알고리즘은 가능한가?

소인수분해의 고전적 알고리즘의 한계에 대해 수학자들 사이에서 오랜 세월 논의되어 온 주제가 “지수 $\alpha = 1/4$인 알고리즘은 존재하는가?“라는 질문입니다. 현재의 GNFS나 그 파생형은 체를 통한 ‘매끄러움의 탐색’이라는 틀에 강하게 얽매여 있으며, 이 패러다임 안에서는 $\alpha = 1/3$이 한계라고 널리 믿어지고 있습니다. 딕만 함수(Dickman function)를 이용한 매끄러운 정수의 분포 확률 해석에서도, 현재의 대수체 구성법과 체의 조합으로는 아무리 최적화해도 $O(L_n[1/3])$의 벽을 넘을 수 없다고 여겨집니다.

만약 $L_n[1/4]$ 혹은 고전적인 다항식 시간 알고리즘이 존재한다고 가정한다면, 그것은 GNFS와 같은 ‘매끄러움 기반’의 접근법과는 전혀 다른, 현재 인류가 생각지도 못한 새로운 수학적 구조(예를 들어, 타원곡선 암호에 대한 Schoof의 알고리즘과 같은 더 고차원적인 대수기하학적 접근 등)에 의존해야 할 것입니다. 그러나 현재로서는 그러한 징후가 보이지 않습니다.

5. 양자 컴퓨터에 의한 돌파구: 쇼어의 알고리즘

고전 컴퓨터가 $L_n[1/3]$의 벽에 직면해 있는 반면, 계산 모델 자체를 근본적으로 바꿈으로써 이 벽을 산산조각 낸 것이 1994년 Peter Shor가 발표한 **쇼어의 알고리즘(Shor’s Algorithm)**입니다.

5.1 양자 다항식 시간의 충격

쇼어의 알고리즘은 소인수분해 문제를 ‘위수 발견 문제(Order Finding Problem)‘로 귀결시킵니다. 어떤 정수 $a$에 대해, 함수 $f(x) = a^x \pmod n$의 주기(위수) $r$을 찾는 문제입니다. 고전 컴퓨터에서는 이 주기를 찾기 위해 지수 함수적인 시간을 요구하지만, 양자 컴퓨터 상의 **양자 위상 추정(QPE: Quantum Phase Estimation)**과 **양자 푸리에 변환(QFT: Quantum Fourier Transform)**을 이용하면 모든 상태의 중첩(Superposition)에 대해 병렬로 평가를 수행하여 높은 확률로 주기 $r$을 추출할 수 있습니다.

계산 복잡도 측면에서 볼 때, 쇼어의 알고리즘의 실행 시간은 양자 다항식 시간, 구체적으로 다음과 같습니다.

$$ O((\log n)^3) $$

최근의 최적화된 회로 구현을 고려하면 $O((\log n)^2 \log \log n)$까지 단축 가능하다고 알려져 있습니다.

graph LR A["고전 알고리즘 (GNFS)"] -->|한계| B["준지수 시간 L_n[1/3]"] C["양자 알고리즘 (Shor)"] -->|돌파구| D["다항식 시간 O((log n)^3)"] B --> E["RSA 암호의 지속적 사용 (키 길이 증가)"] D --> F["RSA 암호의 완전 붕괴"]

5.2 고전적 준지수 시간 vs 양자 다항식 시간

이 두 계산 복잡도 클래스의 차이는 현실 세계의 암호 보안에서 결정적인 의미를 갖습니다.

예를 들어 RSA-2048(2048비트의 합성수)을 소인수분해하는 경우를 생각해 봅시다.

GNFS (고전): $n \approx 2^{2048}$을 $L_n[1/3, 1.923]$에 대입하면 약 $2^{112}$번의 연산이 필요합니다. 이는 현재 지구상의 모든 계산 자원을 결집하더라도 우주의 수명 이상의 시간이 걸리는 천문학적인 계산량입니다.
Shor’s Algorithm (양자): $O((\log n)^3)$ 알고리즘에서는 $2048^3 \approx 8.5 \times 10^9$번 정도의 논리 게이트 조작으로 끝납니다. 이는 적절한 하드웨어(수백만 개의 물리 양자 비트와 오류 정정 능력을 갖춘 범용 양자 컴퓨터)가 존재한다면 단 몇 시간에서 며칠 만에 계산이 완료됨을 의미합니다.

‘지수 $\alpha=1/3$‘의 준지수 시간에서 ‘다항식 시간’으로의 패러다임 전환은, 키 길이를 늘려 안전성을 담보한다는 기존 암호학의 전략을 무력화시킵니다.

6. 결론: 차세대에 대한 전망

“GNFS를 뛰어넘는 고전 알고리즘은 존재하는가?“라는 질문에 대한 현재 과학계의 합의는 다음과 같습니다.

실용적인 개선은 계속되나 점근적인 비약은 없다: MNFS나 다항식 선택의 최적화, 블록 위더만법의 병렬화 등 GNFS의 상수항 $c$를 개선하려는 시도는 계속되고 있습니다. 그러나 $\alpha = 1/3$을 밑도는 고전적 알고리즘이 발견될 가능성은 극히 낮다고 여겨집니다.
고전 컴퓨터 상에서의 RSA 안전성은 여전히 견고하다: GNFS의 계산량은 여전히 막대하며, RSA-2048이나 RSA-4096은 고전 컴퓨터의 공격에 대해 앞으로 수십 년간 안전성을 유지할 것입니다.
진정한 위협은 양자 알고리즘이다: 계산 복잡도의 벽을 넘은 것은 양자역학의 원리에 기반한 쇼어의 알고리즘입니다. 이로 인해 세계는 양자 내성 암호(PQC: Post-Quantum Cryptography)로의 전환을 강요받고 있습니다. 격자 기반 암호나 해시 기반 암호 등 양자 컴퓨터로도 해독이 어려운(다항식 시간으로 풀 수 없는) 새로운 수학적 문제로의 전환이 현재 암호학의 최전선이 되고 있습니다.

일반 수체 체(GNFS)는 인류가 고전 수학과 알고리즘 설계의 극한까지 도전하여 도달한 ‘최고 도달점’ 중 하나입니다. GNFS의 심오한 수학적 구조를 이해하는 것은 단순히 암호 해독의 역사를 배우는 것을 넘어, 계산 복잡도 이론이나 대수적 정수론의 아름다움을 접하는 지적 탐구의 여정이기도 합니다. 양자 컴퓨터가 실용화되는 그날까지 GNFS는 최강의 소인수분해 알고리즘으로서의 왕좌를 계속 지킬 것입니다.

【도해 PQC】 양자 내성 암호의 주요 알고리즘 비교

Fri, 11 Sep 2026 07:00:00 +0900

1. 시작하며: 양자 컴퓨터가 가져올 ‘암호의 위기’

현대 인터넷 사회에서 통신의 기밀성과 데이터의 무결성을 보호하기 위해 공개키 암호 기술은 인프라로서 필수 불가결합니다. 현재 널리 사용되고 있는 RSA 암호나 타원 곡선 암호(ECC)는 각각 ‘거대한 합성수의 소인수분해의 어려움’이나 ‘타원 곡선 상의 이산대수 문제의 어려움’이라는 수학적인 장벽에 의존하여 안전성을 담보하고 있습니다. 고전적인 컴퓨터(슈퍼컴퓨터를 포함하여 현재 우리가 사용하고 있는 컴퓨터)에서는 이러한 수학적 문제를 풀기 위해서는 우주의 나이보다 더 오랜 시간이 걸린다고 증명되어 있으며, 그것이 안전성의 근거가 되어 왔습니다.

그러나 이 견고한 전제는 양자 컴퓨터의 이론과 실용화의 진전으로 인해 근본적으로 뒤집히려 하고 있습니다. 1994년에 암호학자 피터 쇼어(Peter Shor)가 발표한 ‘쇼어의 알고리즘(Shor’s Algorithm)‘은 충분한 성능을 가진 오류 내성 범용 양자 컴퓨터(CRQC: Cryptographically Relevant Quantum Computer)에서 실행함으로써 소인수분해 문제나 이산대수 문제를 ‘다항식 시간’에 해독할 수 있음을 이론적으로 증명했습니다. 이는 현재 사용되고 있는 공개키 암호가 모두 무력화됨을 의미합니다.

“양자 컴퓨터의 본격적인 완성은 아직 수십 년 후의 일이므로 문제없다"라고 생각하는 것은 매우 위험합니다. 왜냐하면, Store Now, Decrypt Later (SNDL: 지금 저장하고 나중에 복호화한다) 라고 불리는 공격 기법이 이미 현실적인 위협이 되고 있기 때문입니다. 이는 악의적인 국가나 해커 조직이 현재 암호화된 통신 데이터(TLS 트래픽 등)를 대량으로 스토리지에 저장해 두었다가, 장래에 강력한 양자 컴퓨터를 이용할 수 있게 되는 순간 그것들을 모두 복호화하는 공격입니다. 국가 기밀, 인프라 정보, 장기간 보호해야 할 의료 데이터 등은 이미 이러한 위협에 노출되어 있습니다.

또한 대칭키 암호(AES 등)나 해시 함수(SHA-256 등)에 대해서도 1996년에 발견된 그로버의 알고리즘(Grover’s Algorithm) 이 존재합니다. 이로 인해 무차별 대입 공격(브루트 포스)의 계산량이 제곱근으로 감소합니다. 즉, AES-128의 보안 수준은 실질적으로 2의 64승으로 반감되기 때문에, 양자 시대에는 AES-256이나 SHA-384와 같은 더 긴 키나 해시 길이를 사용하는 것이 권장됩니다.

이 전례 없는 암호 위기에 대항하기 위해 탄생한 것이 바로 양자 컴퓨터를 사용해도 해독이 어려운 새로운 수학적 문제에 기반한 양자 내성 암호(Post-Quantum Cryptography: PQC) 입니다. 본 기사에서는 미국 국립표준기술연구소(NIST)가 주도하여 진행해 온 PQC 표준화 프로세스의 결과에 바탕을 두고, 주요 PQC 알고리즘에 대해 그 수학적 배경부터 작동 원리, 아키텍처 비교까지 매우 상세하게 해설합니다.

2. NIST의 PQC 표준화 프로젝트의 전모와 역사

암호 기술의 전환에는 프로토콜의 재설계, 시스템 업데이트, 하드웨어 교체 등을 포함하여 수년에서 수십 년의 시간이 걸립니다. 그렇기 때문에 전 세계의 암호학자들은 초기부터 PQC 연구를 진행해 왔습니다. 그 중심적인 역할을 맡아온 곳이 미국의 NIST(국립표준기술연구소)입니다. NIST는 2016년에 PQC의 표준화 프로세스를 공모하여 전 세계의 암호 커뮤니티로부터 전혀 새로운 암호 알고리즘의 제안을 받았습니다.

표준화 대상이 된 것은 다음 두 가지 주요 카테고리입니다.

공개키 암호 / 키 캡슐화 메커니즘 (KEM: Key Encapsulation Mechanism): TLS 연결 등에서 통신 경로를 암호화하기 위한 대칭키를 안전하게 공유(분배)하기 위한 구조.
디지털 서명 (Digital Signatures): 소프트웨어 업데이트나 전자 인증서에서 데이터가 위조되지 않았음과 송신자의 스푸핑이 없음(진정성)을 증명하기 위한 구조.

약 6년에 걸친 매우 치열한 평가·분석 및 암호 해독 경쟁(Round 1~Round 3)을 거쳐, 일부 알고리즘에 대해서는 Round 4의 추가 평가가 이루어졌습니다. 그 결과, 2024년에 다음 알고리즘들이 정식 연방 정보 처리 표준(FIPS)으로 발행되어 향후 세계 표준으로 확정되었습니다.

FIPS 203 (ML-KEM): CRYSTALS-Kyber 기반 KEM
FIPS 204 (ML-DSA): CRYSTALS-Dilithium 기반 디지털 서명
FIPS 205 (SLH-DSA): SPHINCS+ 기반 상태 비저장(Stateless) 해시 기반 서명
(향후 책정 예정) FN-DSA: FALCON 기반 디지털 서명

선정된 이 알고리즘들은 의존하는 수학적인 ‘어려움 문제’가 각각 달라서, 어느 한 알고리즘에서 장래 치명적인 취약점이 발견되더라도 시스템 전체가 붕괴하지 않도록 다양성(Crypto Agility)이 확보되어 있습니다. 표준화 과정에서는 주로 성능 면에서 격자 기반 암호(Lattice-based cryptography)가 주역이 되었지만, 해시 기반 암호나 코드 기반 암호가 강력한 백업으로 채택되었습니다.

3. PQC의 주요 수학적 접근 방식 분류

PQC 알고리즘은 그 안전성의 근거가 되는 수학적 문제에 따라 주로 다음 5가지 카테고리로 크게 나뉩니다. 본 기사에서는 특히 상위 3가지에 대해 자세히 파고듭니다.

격자 기반 암호 (Lattice-based Cryptography): 다차원 격자 공간에서의 최단 벡터 문제(SVP)나 최근접 벡터 문제(CVP), 그리고 여기서 파생된 LWE 문제에 기반합니다. NIST 표준화의 중심이며, Kyber, Dilithium, FALCON이 이에 해당합니다. 처리 속도, 공개키 크기, 암호문 크기의 균형이 가장 뛰어나 범용적인 사용에 적합합니다.
해시 기반 암호 (Hash-based Cryptography): 암호학적 해시 함수(SHA-2, SHAKE 등)의 ‘충돌 저항성’과 ‘일방향성’에만 안전성의 근거를 둡니다. 디지털 서명(SPHINCS+ 등)에만 적용 가능하지만, 안전성 증명이 가장 확고하며 미지의 수학적 공격에 대한 내성이 극히 높은 것이 특징입니다.
코드 기반 암호 (Code-based Cryptography): 오류 정정 코드 이론에 기반하여 신드롬 복호화 문제(Syndrome Decoding Problem)의 어려움에 의존합니다. 1970년대에 제안된 Classic McEliece가 대표적으로, 매우 긴 역사와 입증된 안전성을 가지는 반면 공개키의 크기가 메가바이트 단위로 극단적으로 큽니다.
다변수 다항식 암호 (Multivariate Polynomial Cryptography): 유한체 상의 다변수 연립 이차방정식의 해를 구하는 것(MQ 문제)의 어려움에 기반합니다. 주로 디지털 서명(Rainbow 등)으로 제안되었으나, NIST의 최종 라운드 진행 중에 PC 1대로 며칠 만에 해독되는 강력한 공격 기법이 발견되어 많은 알고리즘이 표준화에서 탈락했습니다.
동종 사상 암호 (Isogeny-based Cryptography): 타원 곡선의 동종 사상(Isogeny) 그래프 상에서의 경로 탐색 문제에 기반합니다. 키 크기가 매우 작아 ECC의 정당한 후계자로 기대되었으나, 최종 후보였던 ‘SIKE’가 2022년에 고전적인 수학(Castryck-Decru 공격 등)을 이용하여 일반 PC에서 불과 몇 시간 만에 완전히 해독되어 PQC 설계의 어려움과 두려움을 상징하는 극적인 결말을 맞았습니다.

4. 격자 암호의 심연: LWE 문제와 Module-LWE의 수학적 기초

현재 가장 유력하게 여겨지며 표준화의 중심이 된 격자 기반 암호. 그 안전성의 근저에 있는 것이 LWE 문제 (Learning with Errors: 오차가 있는 학습 문제) 입니다. 2005년에 Oded Regev가 제창하였고, 이 획기적인 공적으로 그는 괴델상(Gödel Prize)을 수상했습니다. LWE 문제를 이해하지 않고서는 현대의 PQC를 논할 수 없습니다.

4.1. LWE 문제(Learning with Errors)란 무엇인가

먼저 간단한 연립 일차 방정식을 생각해 봅시다. 어떤 법 $q$ (모듈로 $q$) 하에서 알려진 임의의 행렬 $A$와 알려지지 않은 비밀 벡터 $\vec{s}$가 있고 그 곱인 $\vec{b}$가 주어졌다고 가정합시다.

$$ \vec{b} = A\vec{s} \pmod q $$

이때 공개 정보인 $A$와 $\vec{b}$로부터 미지의 $\vec{s}$를 구하는 것은 간단합니다. 고전적인 알고리즘인 ‘가우스 소거법’을 사용하면 다항식 시간에 쉽게 $\vec{s}$를 계산할 수 있습니다.

그러나 이 식에 ‘작고 의도적인 오차(노이즈)‘를 더하면 문제의 난이도가 극적으로 상승합니다. 이것이 바로 LWE 문제입니다.

미지의 비밀 벡터 $\vec{s} \in \mathbb{Z}_q^n$과 임의로 선택된 행렬 $A \in \mathbb{Z}_q^{m \times n}$를 준비합니다. 나아가 정규분포나 이항분포 등에 따라 선택된 ‘요소의 값이 충분히 작은’ 오차 벡터 $\vec{e} \in \mathbb{Z}_q^m$를 준비하고 다음과 같이 $\vec{b}$를 계산합니다.

$$ \vec{b} = A\vec{s} + \vec{e} \pmod q $$

Search LWE 문제란 “공개 정보 $(A, \vec{b})$로부터 비밀 정보 $\vec{s}$를 구하라"는 문제입니다. 이 오차 $\vec{e}$가 존재함으로써 가우스 소거법 등 대수학적 해법을 시도하려 하면, 방정식을 더하고 빼는 과정에서 오차 $\vec{e}$가 눈덩이처럼 증폭되어 최종적으로 무작위 값과 구별할 수 없게 되어 파탄 나고 맙니다.

LWE 문제의 대단한 점은 ‘격자 상의 최악 경우 계산 복잡도 문제(Worst-case hardness)‘인 GapSVP(판정 최단 벡터 문제)나 SIVP(최단 독립 벡터 문제)를 풀 수 있는 양자 알고리즘이 존재하지 않는 한, LWE 문제도 평균적(Average-case)으로 풀 수 없다는 강력한 이론적 증명(환원)이 존재한다는 것입니다. 즉, 무작위로 생성된 암호키라 하더라도 이론적인 한계에 의해 뒷받침되는 확고한 안전성을 가짐이 보장되어 있습니다.

4.2. Ring-LWE와 Module-LWE를 통한 극적인 효율화

일반적인 LWE 문제(Standard LWE)는 안전성의 근거가 매우 명확하지만, 행렬 $A$의 크기가 매우 커져 키 크기가 메가바이트 급이 되므로 실용적이지 않습니다. 그래서 제안된 것이 다항식 환(Polynomial Rings)을 이용하여 대수적인 구조를 갖게 하는 접근 방식입니다.

Ring-LWE 문제에서는 단순한 벡터나 행렬 대신, 어떤 다항식 환 $R_q$의 원소(다항식)를 사용합니다. NIST 표준에서 일반적으로 사용되는 것은 다음과 같은 원분 다항식 환(Cyclotomic Polynomial Ring)입니다.

$$ R_q = \mathbb{Z}_q[X]/(X^n + 1) $$

여기서 $n$은 2의 거듭제곱(예: 256), $q$는 적당한 소수입니다. 이 환 위에서 요소 $a, s, e \in R_q$를 이용하여 $b = a \cdot s + e \pmod q$를 계산합니다. 하나의 다항식 $a$가 $n$개의 계수를 갖기 때문에 데이터를 대폭 압축할 수 있으며, 나아가 NTT (Number Theoretic Transform: 수론 변환) 라는 고속 푸리에 변환(FFT)의 유한체 버전을 사용함으로써 $O(n \log n)$의 계산량으로 초고속으로 다항식 곱셈이 가능해집니다.

하지만 Ring-LWE에는 ‘환의 특수한 대수 구조로 인한 미지의 취약점이 존재할지도 모른다’는 우려가 있었습니다. 또한 보안 수준(AES-128, 192, 256 상당 등)을 변경할 때 다항식의 차수 $n$ 자체를 변경해야 하며, 이에 따라 NTT 알고리즘 등 구현 전체를 다시 작성해야 한다는 공학적인 과제가 있었습니다.

그래서 표준화 알고리즘인 Kyber나 Dilithium이 채택한 것이 바로 Module-LWE (M-LWE) 문제입니다. Module-LWE는 구조가 없는 Standard LWE와 너무 많은 구조를 가진 Ring-LWE의 딱 중간에 위치하는 절충안이며, 다항식 환 $R_q$의 요소를 성분으로 하는 $k \times k$의 행렬(모듈)을 사용합니다.

$$ \vec{b} = A\vec{s} + \vec{e} \pmod{R_q} \quad (A \in R_q^{k \times k}, \vec{s}, \vec{e} \in R_q^k) $$

Module-LWE의 가장 큰 이점은 다항식의 차수 $n$(NIST 표준에서는 $n=256$)을 고정한 채 행렬의 차원 $k$만 변경하여 쉽게 보안 수준을 확장(Scale)할 수 있다는 점입니다. 예를 들어 Kyber의 경우 다음과 같이 차원 $k$를 조정합니다.

Kyber512 (Level 1): $k = 2$ (AES-128 상당)
Kyber768 (Level 3): $k = 3$ (AES-192 상당)
Kyber1024 (Level 5): $k = 4$ (AES-256 상당)

이로 인해 기반이 되는 NTT의 코드나 다항식 연산의 하드웨어 회로를 모든 보안 수준에서 100% 재사용할 수 있게 되어 구현의 안전성과 효율성이 극적으로 향상되었습니다.

5. CRYSTALS-Kyber (ML-KEM): 차세대 키 캡슐화 메커니즘

FIPS 203 (ML-KEM) 으로 공식 표준화된 CRYSTALS-Kyber는 앞서 언급한 Module-LWE 문제에 기반한 키 캡슐화 메커니즘(KEM)입니다. 앞으로 TLS 1.3이나 SSH 등에서 세션 키를 안전하게 공유하기 위한 사실상의 세계 표준이 될 것입니다.

5.1. KEM (Key Encapsulation Mechanism) 아키텍처

PQC의 시대에서는 RSA처럼 ‘클라이언트가 대칭키를 만들어 서버의 공개키로 암호화해서 보낸다’는 직접적인 접근 방식이 아니라, KEM이라는 캡슐화의 틀이 표준이 됩니다.

sequenceDiagram participant Client as "클라이언트 (Alice)" participant Server as "서버 (Bob)" Note over Client: "ML-KEM KeyGen()" Client->>Client: "비밀키 (sk) 와 공개키 (pk) 생성" Client->>Server: "공개키 (pk) 전송" Note over Server: "ML-KEM Encaps()" Server->>Server: "무작위 대칭키 (K) 생성" Server->>Server: "K를 pk로 캡슐화하여 암호문 (c) 생성" Server->>Client: "암호문 (c) 전송" Note over Client: "ML-KEM Decaps()" Client->>Client: "비밀키 (sk) 를 사용하여 암호문 (c) 복호화" Client->>Client: "캡슐화를 해제하고 대칭키 (K) 추출" Note over Client, Server: "공유한 대칭키 (K) 를 사용하여 AES 등으로 암호화 통신 시작"

5.2. Kyber 내부 알고리즘의 원리와 후지사키-오카모토 변환(Fujisaki-Okamoto Transform)

Kyber의 설계는 매우 세련되었습니다. 먼저 CPA(선택 평문 공격)에 대해서만 안전한 공개키 암호 방식(Kyber.CPAPKE)을 구축하고, 여기에 후지사키-오카모토 변환 (Fujisaki-Okamoto Transform) 이라고 불리는 암호학적으로 매우 강력 기법을 적용함으로써 CCA(적응적 선택 암호문 공격)에 대해서도 안전한 완전한 KEM으로 업그레이드하는 설계를 채택했습니다.

CPAPKE의 핵심이 되는 암호화와 복호화의 메커니즘은 다음과 같습니다.

키 생성 (Key Generation):
- 임의의 시드 값으로부터 NTT 도메인 상의 행렬 $A \in R_q^{k \times k}$를 생성합니다. 법 $q$는 $3329$가 사용됩니다.
- 중심 이항 분포(CBD)로부터 작은 계수를 갖는 비밀 벡터 $\vec{s}$와 오차 벡터 $\vec{e}$를 샘플링합니다.
- $\vec{t} = A\vec{s} + \vec{e}$를 계산합니다. 공개키는 $(A, \vec{t})$, 비밀키는 $\vec{s}$입니다. (실제로는 $A$는 시드 값으로서 공개되어 대역폭을 절약합니다).
암호화 (Encryption):
- 공유하려는 32바이트 메시지(대칭키의 재료) $m$을 다항식으로 인코딩합니다.
- 새로운 임의의 벡터 $\vec{r}$과 작은 오차 $\vec{e_1}, e_2$를 생성합니다.
- $\vec{u} = A^T\vec{r} + \vec{e_1}$
- $v = \vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m$
- 암호문은 $(\vec{u}, v)$가 됩니다.
복호화 (Decryption):
- 수신자는 $v - \vec{s}^T\vec{u}$를 계산합니다.
- 이 식을 수식으로 전개하면 다음과 같이 됩니다. $v - \vec{s}^T\vec{u} = (\vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m) - \vec{s}^T(A^T\vec{r} + \vec{e_1})$
- 여기서 $\vec{t} = A\vec{s} + \vec{e}$를 대입하면 주항인 $\vec{s}^TA^T\vec{r}$가 상쇄됩니다.
- 남는 것은 $\lfloor q/2 \rceil \cdot m + (\vec{e}^T\vec{r} + e_2 - \vec{s}^T\vec{e_1})$이 됩니다.
- 괄호 안의 항은 ‘작은 오차끼리의 곱이나 합’이므로 전체적으로도 충분히 작은 값(노이즈)에 머무릅니다. 따라서 각 계수가 $0$에 가까운지 $q/2$에 가까운지를 임계값 판정함으로써 원래 메시지 $m$의 비트(0 또는 1)를 완전히 오류 없이 복원할 수 있습니다.

Kyber의 가장 큰 강점은 그 압도적인 처리 속도와 적절한 키 크기에 있습니다. Kyber768의 경우 공개키 크기는 1,184바이트, 암호문 크기는 1,088바이트이며, RSA-3072(키 크기 약 384바이트) 등과 비교하면 크지만 현대 인터넷 통신의 MTU(Maximum Transmission Unit) 내에 패킷 분할 없이 담는 것이 가능하여 네트워크 지연(Latency)에 거의 악영향을 주지 않습니다.

6. CRYSTALS-Dilithium (ML-DSA): 격자 기반 범용 디지털 서명

디지털 서명의 표준화에 있어서는, 같은 격자 암호 접근 방식 중에서도 다른 설계 사상을 가진 알고리즘들이 경쟁했습니다. 그중에서 범용적인 디지털 서명으로서 FIPS 204 (ML-DSA) 로 선정된 것이 CRYSTALS-Dilithium입니다.

6.1. Fiat-Shamir with Aborts 패러다임

Dilithium은 Kyber와 마찬가지로 Module-LWE(및 Module-SIS 문제)에 기반한 디지털 서명 체계입니다. 설계의 기본 바탕에는 ‘Fiat-Shamir with Aborts (중도 종료를 동반한 피아트-샤미르 변환)‘라는 매우 중요한 패러다임이 사용되었습니다.

피아트-샤미르 변환 자체는 대화형 영지식 증명 프로토콜을 비대화형 디지털 서명으로 변환하기 위한 표준적인 기법입니다. 증명자(서명자)가 약속(Commitment) $y$를 생성하고, $w = Ay$를 계산하여 해시 함수에 통과시킴으로써 임의의 챌린지(Challenge) $c$를 얻고 응답 $z = y + cs$를 계산합니다.

하지만 격자 암호에서 이를 단순히 적용하면 응답 $z$의 분포가 비밀키 $s$의 값에 의존하여 왜곡되어 버리고, 다수의 서명을 관측한 공격자에게 비밀키 $s$의 정보가 조금씩 유출되어 버리는 치명적인 문제(부채널 방식의 수학적 유출)가 있었습니다.

Dilithium의 설계팀(Lyubashevsky 등)은 서명의 계산 결과 $z$의 계수가 미리 설정된 안전한 임계값 범위 내에 들어가지 않을 경우 해당 서명 프로세스 전체를 파기(Abort)하고, 새로운 난수 $y$를 사용하여 처음부터 계산을 다시 하는 ‘기각 샘플링(Rejection Sampling)‘이라는 기법을 도입했습니다.

이를 통해 최종적으로 출력되는 서명 $z$는 비밀키에 전혀 의존하지 않는 완전한 균등 분포가 되어, 정보 유출을 수학적으로 완전히 막는 데 성공했습니다.

6.2. Dilithium의 이점과 구현의 용이성

Dilithium 설계상의 큰 이점은 서명 생성 프로세스에서 복잡한 ‘가우스 분포로부터의 샘플링’이나 ‘부동소수점 연산’을 전혀 사용하지 않는다는 점입니다. 균등 분포로부터의 샘플링과 단순한 정수 모듈로 연산, NTT 및 해시 함수(SHAKE)만으로 구현할 수 있기 때문에 임베디드 마이크로컨트롤러에서 클라우드 서버에 이르기까지 폭넓은 환경에서 안전하고 상수 시간(Constant-time)에 구현하기가 용이합니다. 이로 인해 타이밍 공격 등 물리적인 부채널 공격에 대해서도 강력한 내성을 가집니다.

7. FALCON (FN-DSA): 궁극적으로 콤팩트한 격자 서명

NIST는 Dilithium과는 다른 특성을 가진 또 다른 격자 기반 서명으로서 FALCON (Fast-Fourier Lattice-based Compact Signatures over NTRU) 을 표준화 후보로 선정했습니다(현재 FN-DSA로 초안 작성 중).

7.1. NTRU 격자와 가우스 샘플링

FALCON의 가장 큰 특징은 LWE 문제가 아니라 1996년부터 존재하는 역사가 오래된 NTRU (N-th degree Truncated polynomial Ring Units) 격자를 사용한다는 점입니다. 더 나아가 GPV (Gentry-Peikert-Vaikuntanathan) 프레임워크에 기반한 ‘해시 앤 사인 (Hash-and-Sign)’ 패러다임을 채택하고 있습니다.

해시 앤 사인(Hash-and-Sign)에서는 메시지의 해시 값을 공간 내의 타깃 점으로 삼고, 그 점에 가장 가까운 격자 상의 점(최근접 벡터 문제의 근사해)을 찾는 것으로 서명을 합니다. 여기에는 비밀키인 ‘품질이 좋은 짧은 기저(Basis)‘를 사용하여 이산 가우스 분포에 따라 점을 샘플링할 필요가 있습니다.

FALCON은 이 무거운 계산을 ‘고속 푸리에 직교화 (Fast Fourier Orthogonalization: FFO)‘라는 기법을 사용하여 극적으로 고속화했습니다.

7.2. FALCON의 장점과 단점

FALCON의 압도적인 장점은 그 서명 크기와 공개키 크기가 극히 작다(콤팩트하다) 는 것입니다. Dilithium3의 서명 크기가 약 3,309바이트인 것에 반해, FALCON-512의 서명 크기는 불과 약 666바이트입니다. 공개키 역시 897바이트로 매우 작아 통신 대역폭이 극단적으로 제한되는 환경이나 IoT 기기, 특정 네트워크 프로토콜에서는 구세주가 됩니다.

그러나 중대한 단점이 존재합니다. 서명 생성 시에 복잡한 부동소수점 연산(64-bit IEEE 754) 을 동반하는 이산 가우스 샘플링이 필수이기 때문에 타이밍 정보 유출을 방지하는 상수 시간 구현(Constant-time implementation)이 매우 어렵고 코드도 거대해집니다. 이 때문에 FALCON은 범용적인 이용(Dilithium)에 대비되는 특정 용도 지향의 강력한 특화형 알고리즘이라는 위치를 갖습니다.

graph LR A["디지털 서명의 요구사항"] --> B{"가장 우선시하는 제약은?"} B -->|"구현의 단순함·범용성·상수 시간 구현의 용이성"| C["Dilithium (ML-DSA)"] B -->|"통신 대역폭의 최소화·데이터 크기의 콤팩트함"| D["FALCON (FN-DSA)"] C --> E["범용적인 TLS 인증서, 소프트웨어의 전자 서명"] D --> F["패킷 크기 제한이 엄격한 프로토콜, 특수 환경"]

8. SPHINCS+ (SLH-DSA): 최강의 안전성을 자랑하는 해시 기반 서명

격자 암호의 안전성이 장래에 천재적인 수학자의 돌파구에 의해 무너진다는 최악의 시나리오(만약의 사태)에 대비하여, NIST는 격자 암호와는 전혀 다른 접근 방식을 가진 표준으로서 FIPS 205 (SLH-DSA), 즉 **SPHINCS+**를 책정했습니다.

SPHINCS+는 해시 기반 서명으로 분류됩니다. 그 안전성의 근거는 “사용하는 암호학적 해시 함수(SHA-2나 SHAKE256 등)가 충돌 저항성과 일방향성을 갖는다는 것"이라는 단 1점에만 의존하고 있습니다. LWE나 소인수분해와 같이 특정 대수 구조를 가진 수학적 문제에 의존하지 않기 때문에 장래에 어떤 강력한 양자 알고리즘이 등장하더라도 해시 함수의 출력 길이를 단순하게 늘리는 것만으로 대항할 수 있다는, 극히 확고한 안전성(가장 보수적인 보안)을 자랑합니다.

8.1. WOTS+ 와 FORS에 의한 상태 비저장(Stateless) 아키텍처

해시 기반 서명의 역사는 오래되어 1970년대의 램포트 서명(Lamport signature)이나 윈터니츠 일회용 서명(WOTS)으로 거슬러 올라갑니다. 이것들은 “단 1번만 안전하게 서명할 수 있다"는 일회용 키였습니다. 이를 여러 번 사용할 수 있도록 하기 위해 머클 트리(Merkle Tree)를 조합하여 무수한 일회용 키를 하나의 루트 해시로 관리하는 XMSS(eXtended Merkle Signature Scheme)나 LMS와 같은 알고리즘이 개발되었습니다.

그러나 XMSS나 LMS에는 ‘상태 저장형(Stateful)‘이라는 중대한 결점이 있었습니다. 서명할 때마다 “몇 번째 일회용 키를 사용했는가"라는 인덱스 상태를 비휘발성 메모리에 엄밀하게 계속 기록해야 하며, 만약 가상 머신의 스냅샷 복원 등으로 상태가 되돌아가 동일한 일회용 키를 두 번 사용해 버리면 비밀키가 즉시 유출되어 시스템이 붕괴하고 맙니다.

SPHINCS+는 이러한 상태 관리의 번거로움을 해결한 ‘상태 비저장형(Stateless)’ 해시 기반 서명입니다. 그 핵심 기술은 다음의 조합입니다.

WOTS+ (Winternitz One-Time Signature Plus): 기본적인 일회용 서명.
FORS (Forest of Random Subsets): 소수 회 서명(Few-Time Signature) 기술. 같은 키를 몇 번 정도는 재사용해도 안전성을 유지함.
Hyper-Tree (거대한 트리 구조): 머클 트리를 다층적으로 겹겹이 쌓아 올린 거대한 구조.

SPHINCS+에서는 서명을 할 때 상태를 관리하는 대신, Hyper-Tree 밑바닥에 있는 방대한 수의 FORS 키 중에서 의사 난수를 사용하여 임의로 하나를 골라내어 서명합니다. 트리의 잎사귀 수가 천문학적으로 많기 때문에 같은 키를 우연히 두 번 고를 확률(충돌)이 무시할 수 있을 만큼 작아져 결과적으로 상태 비저장(Stateless)을 실현하고 있습니다.

SPHINCS+의 유일하고도 가장 큰 약점은 서명 크기가 극히 크다는 것입니다. 파라미터에 따라 다르지만 서명 크기는 17킬로바이트~49킬로바이트에 달하며, 서명 생성 속도도 격자 암호에 비해 압도적으로 느려집니다. 그 때문에 일상적인 웹 브라우징에서의 사용보다는 소프트웨어 업데이트 서명이나 루트 인증기관(CA)의 인증서 등 자주 서명을 하지 않으면서도 장기간의 절대적인 안전성이 강하게 요구되는 용도에서의 사용이 상정되어 있습니다.

9. 코드 기반 암호: Classic McEliece라는 좋고 오래된 거인

NIST 표준화 프로세스에서 Round 4의 최종 후보로서 현재도 계속 평가받고 있는 중요한 접근 방식이 코드 기반 암호인 Classic McEliece입니다.

1978년 Robert McEliece가 제안한 이 알고리즘은 공개키 암호 역사 중에서도 RSA와 더불어 가장 오래된 것 중 하나입니다. ‘Goppa 코드(고파 부호)‘라고 불리는 대수 기하 코드를 이용하여 메시지에 의도적으로 오류(노이즈 벡터)를 더해 암호화하고, 비밀키로서 Goppa 코드의 패리티 검사 행렬을 가진 자만이 강력한 오류 정정 능력을 사용해 오류를 제거하고 원래의 메시지를 복호화할 수 있다는 ‘신드롬 복호화 문제 (Syndrome Decoding Problem)‘에 기반하고 있습니다.

$$ \vec{c} = \vec{m} G + \vec{e} $$

($G$는 공개키인 스크램블된 생성 행렬, $\vec{e}$는 가중치 $t$의 오류 벡터)

Classic McEliece의 놀라운 점은 제안된 지 40년 이상 지났고 전 세계의 암호학자에 의한 치열한 해독 연구에 노출되어 왔음에도 불구하고, 그 본질적인 취약점이 한 번도 발견되지 않았다는 압도적인 실적에 있습니다. PQC 중에서 가장 ‘시간이 증명한 확고한 안전성’을 가지고 있습니다.

게다가 암호문의 크기가 매우 작다(불과 100~200바이트 정도)는 이점이 있습니다. 하지만 공개키 크기가 메가바이트(MB) 단위가 된다는 치명적인 결점이 존재합니다. 가장 낮은 보안 수준(AES-128 상당)에서도 공개키가 약 250KB, 높은 수준에서는 1MB를 넘습니다.

이 때문에 TLS 핸드셰이크처럼 통신할 때마다 공개키를 네트워크 상에 전송하는 용도에는 전혀 적용할 수 없습니다. 하지만 VPN의 사전 공유 키 교환, 펌웨어에 공개키를 하드코딩하는 경우, 또는 위성 통신 등 공개키를 시스템에 사전에 배치할 수 있는 특수한 유스케이스에서는 그 확고한 안전성 덕분에 매우 유망한 선택지로 계속 검토되고 있습니다.

10. 각 PQC 알고리즘의 성능 비교 및 트레이드오프

지금까지 해설해 온 주요 알고리즘에 대해 일반적인 보안 수준(NIST Level 2~~3 상당, AES-128~~192 레벨)에서의 성능 특성을 아래 표로 정리했습니다.

알고리즘 (표준명)	카테고리	수학적 기반	공개키 크기	비밀키 크기	암호문/서명 크기	처리 속도 경향	주요 특징 및 용도
Kyber768 (ML-KEM)	KEM	Module-LWE	1,184 Bytes	2,400 Bytes	1,088 Bytes	매우 빠름	키 크기·속도의 밸런스가 최고. TLS 1.3 등 범용 KEM 표준.
Dilithium3 (ML-DSA)	서명	Module-LWE	1,952 Bytes	4,032 Bytes	3,309 Bytes	생성·검증 모두 빠름	구현이 단순. 범용적인 디지털 서명 표준.
FALCON-512 (FN-DSA)	서명	NTRU 격자	897 Bytes	1,281 Bytes	666 Bytes	서명 생성은 느린 편, 검증은 초고속	서명 크기가 극소. 단 부동소수점 연산이 필요. 임베디드·IoT용.
SPHINCS+ (SLH-DSA)	서명	해시 함수	32 Bytes	64 Bytes	약 17,000 Bytes	생성이 매우 느림	수학적 파탄 위험이 거의 제로. 루트 인증서 등 고보안 용도.
Classic McEliece	KEM	Goppa 코드	약 1.04 MB	13,568 Bytes	188 Bytes	캡슐화는 빠름	40년의 안전성 실적. 공개키가 거대. 하드코딩 가능한 환경용.

트레이드오프에 대한 이해

PQC의 세계에서는 “크기가 작고, 속도가 빠르며, 수학적 보장도 완벽한” 마법과 같은 단일 알고리즘은 존재하지 않습니다.

인터넷의 표준 (Kyber / Dilithium): 성능 밸런스가 가장 좋으며, 현재의 RSA/ECC를 드롭인 리플레이스먼트(그대로 교체하는 것) 하기에 가장 적합합니다.
궁극의 보수성 (SPHINCS+): 데이터 크기나 처리 속도를 희생해서라도 장래의 수학적 돌파구에 대한 절대적인 보험을 원할 경우에 선택됩니다.
특수 환경용 (FALCON / Classic McEliece): 통신 대역폭이 극단적으로 좁거나 혹은 사전 배포가 가능한 등, 환경 제약에 맞춰 선택되는 특화형 무기입니다.

11. 실용화를 향한 과제와 ‘하이브리드 암호’라는 현실적 해답

NIST의 표준화가 완료되고 FIPS 규격이 정식으로 발행됨에 따라 전 세계 IT 인프라의 PQC 전환(PQC 마이그레이션)이 본격적으로 시작되었습니다. Google의 Chrome 브라우저, Apple의 iMessage(PQ3 프로토콜), Cloudflare와 같은 네트워크 제공자들은 이미 프로토콜에 PQC 지원을 구현하여 실제 운용을 시작하고 있습니다.

하지만 새로운 암호 알고리즘으로 갑자기 완전히 전환하는 데에는 매우 높은 위험이 따릅니다. 만약 Kyber와 같은 격자 암호에 대해 몇 년 뒤 어떤 천재 수학자가 치명적인 공격 기법(고전 컴퓨터로도 풀 수 있는 수학적 결함)을 발견할 경우, 그에 의존하고 있는 시스템 전체가 순식간에 발가벗겨지게 됩니다.

이러한 불확실성 위험을 경감하기 위한 현실적이고 권장되는 접근 방식이 ‘하이브리드 암호(Hybrid Cryptography)‘입니다.

하이브리드 암호에서는 다년간의 실적이 있는 현행 고전적 암호(예: X25519 등의 타원 곡선 암호)와 새로운 PQC(예: Kyber768)를 모두 동시에 사용하여 키 교환을 수행합니다. 각각의 알고리즘에서 개별적으로 대칭키 성분을 생성하고 마지막으로 안전한 키 도출 함수(KDF)를 이용하여 두 성분을 혼합해 최종적인 마스터 시크릿을 생성합니다.

graph TD A["클라이언트"] -->|① X25519의 공개키 + Kyber의 공개키 전송| B["서버"] B -->|② X25519의 대칭키 + Kyber의 캡슐화 암호문 반환| A A --> C{"마스터 시크릿 도출 (KDF)"} B --> C C -->|입력: (X25519의 대칭키) || (Kyber의 대칭키)| D["안전한 통신키 (AES-256 / ChaCha20)"] D -->|"양자의 위협 & 고전적인 취약성 양쪽에 내성"| E["안전한 하이브리드 암호 통신 (TLS 1.3)"]

이를 통해 “만일 양자 컴퓨터가 실현되어 ECC가 깨지더라도 Kyber가 통신을 지키고”, 반대로 “만일 Kyber에 미지의 수학적 결함이 발견되더라도 ECC가 통신을 지킨다"는 견고한 이중 안전성을 실현할 수 있습니다. 대표적인 예로 IETF에서 표준화가 진행 중인 X25519MLKEM768 (구 X25519Kyber768) 초안이 있으며, 현재 웹 브라우저와 최첨단 서버 간의 통신은 바로 이 하이브리드 방식을 이용하여 이루어지고 있습니다.

또한 시스템 설계에 있어서 “특정 암호 알고리즘에 과도하게 의존하지 않고 알고리즘이 파탄 났을 때 신속하게 다른 알고리즘(예: Kyber에서 McEliece로, Dilithium에서 SPHINCS+로)으로 전환할 수 있는 아키텍처"를 구축하는 Crypto Agility(암호 민첩성) 의 개념이 향후 시스템 개발에 있어 필수 요건이 됩니다.

12. 맺음말: 암호 기술의 새로운 지평선

양자 컴퓨터라는 인류의 꿈의 기술은 아이러니하게도 우리가 오랫동안 신뢰해 온 ‘소인수분해’나 ‘이산대수 문제’라는 수학적 방벽을 무너뜨리는 최대의 위협이 되었습니다. 그러나 전 세계의 암호학자들은 이에 굴하지 않고 격자 이론, 해시 함수 트리, 오류 정정 코드와 같은 보다 복잡하고 심오한 다차원 수학적 영역을 개척하여 양자 내성 암호(PQC)라는 새로운 방벽을 구축했습니다.

NIST의 FIPS 203 (ML-KEM), FIPS 204 (ML-DSA), FIPS 205 (SLH-DSA) 표준화 완료는 끝이 아닙니다. 앞으로 수십 년간 이어질 PQC 마이그레이션이라는 장대한 여정의 첫걸음에 불과합니다. 소프트웨어 엔지니어나 시스템 아키텍트에게 있어서, 이 새로운 알고리즘들이 가져오는 ‘키 크기 증가’나 ‘계산 비용 변화’를 네트워크 프로토콜과 시스템에 어떻게 최적으로 적응시켜 나갈지가 앞으로의 큰 기술적 과제가 될 것입니다.

양자 컴퓨터와 암호의 싸움은 인류의 수학적 탐구와 기술의 진화가 가장 치열하게 교차하는 흥미진진한 영역입니다. 본 기사를 통해 PQC의 배후에 있는 아름다운 수학 이론과 사이버 보안의 미래를 형성할 각 알고리즘의 놀라운 메커니즘에 대해 깊이 이해하셨기를 바랍니다.

References:

NIST Post-Quantum Cryptography Standardization Program
FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard
FIPS 204: Module-Lattice-Based Digital Signature Standard
FIPS 205: Stateless Hash-Based Digital Signature Standard