2nd/10_Wiki/Topics/AI_and_ML/Homomorphic-Encryption.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-homomorphic-encryption	Homomorphic Encryption (HE)	10_Wiki/Topics	verified	self	HE FHE homomorphic encryption fully homomorphic CKKS BFV BGV TFHE privacy-preserving ML	none	A	0.93	applied	cryptography fhe privacy encryption ml-privacy secure-computation		2026-05-10	pending	language framework C++ / Python Microsoft SEAL / OpenFHE / Concrete / TFHE-rs

Homomorphic Encryption

매 한 줄

"매 encrypted data 의 의 의 직접 의 compute". 매 plaintext 의 reveal X. 매 Gentry 2009 (FHE breakthrough). 매 modern: 매 CKKS (real / approximate), BFV/BGV (integer), TFHE (Boolean). 매 응용: 매 privacy-preserving ML, 매 cloud, 매 medical.

매 핵심

매 levels

• Partial HE (PHE): 매 single op (add or mul).
• Somewhat HE (SHE): 매 limited depth.
• Leveled HE: 매 known depth.
• Fully HE (FHE): 매 unlimited depth via bootstrapping.

매 schemes

• CKKS: 매 approximate arithmetic on real / complex (modern ML).
• BFV / BGV: 매 exact integer.
• TFHE: 매 fast bootstrapping, Boolean.
• NTRU, GSW: 매 historical / specialized.

매 modern library

• Microsoft SEAL (CKKS, BFV).
• OpenFHE (모든 schemes).
• Concrete (Zama, TFHE).
• TFHE-rs (Rust).
• PySEAL, TenSEAL (Python).

매 응용

1. Privacy-preserving ML inference.
2. Medical (encrypted genomic).
3. Financial (encrypted query).
4. Cloud compute (zero-knowledge).
5. Federated learning + HE.
6. Smart contract (FHEVM).

매 cost

• 매 100x-10000x slowdown vs plaintext.
• 매 modern hardware (GPU FHE) 의 의 의 reduce.
• 매 ciphertext 매 100-1000x larger.

💻 패턴

TenSEAL (CKKS, Python)

import tenseal as ts

context = ts.context(ts.SCHEME_TYPE.CKKS, poly_modulus_degree=8192,
                      coeff_mod_bit_sizes=[60, 40, 40, 60])
context.global_scale = 2**40
context.generate_galois_keys()

# 매 encrypt
v1 = ts.ckks_vector(context, [1.0, 2.0, 3.0])
v2 = ts.ckks_vector(context, [4.0, 5.0, 6.0])

# 매 compute on ciphertext
add = v1 + v2  # 매 [5, 7, 9]
mul = v1 * v2  # 매 [4, 10, 18]
dot = v1.dot(v2)  # 매 32

# 매 decrypt only when needed
print(add.decrypt())

Microsoft SEAL (BFV, C++)

#include "seal/seal.h"
using namespace seal;

EncryptionParameters parms(scheme_type::bfv);
parms.set_poly_modulus_degree(4096);
parms.set_coeff_modulus(CoeffModulus::BFVDefault(4096));
parms.set_plain_modulus(1024);

SEALContext context(parms);
KeyGenerator keygen(context);
PublicKey public_key; keygen.create_public_key(public_key);
SecretKey secret_key = keygen.secret_key();

Encryptor encryptor(context, public_key);
Evaluator evaluator(context);
Decryptor decryptor(context, secret_key);

Plaintext x_plain("5"); Ciphertext x_encrypted;
encryptor.encrypt(x_plain, x_encrypted);

Ciphertext result;
evaluator.square(x_encrypted, result);  // 매 5² = 25 (encrypted)

Encrypted ML inference (logistic regression)

def encrypted_logistic_regression(encrypted_x, weights_plaintext, bias_plaintext):
    """매 매 매 weights / bias 매 plaintext, 매 input 매 encrypted."""
    z = encrypted_x.dot(weights_plaintext) + bias_plaintext
    # 매 sigmoid approximation (poly degree 3)
    z2 = z * z
    z3 = z2 * z
    sigmoid_approx = 0.5 + 0.197 * z - 0.004 * z3  # 매 around 0
    return sigmoid_approx

Sigmoid polynomial approx (CKKS)

def sigmoid_poly_approx(z):
    """매 매 [-5, 5] 의 의 의 valid."""
    # 매 deg 3 Taylor-like
    z2 = z * z
    z3 = z2 * z
    z5 = z3 * z2
    return 0.5 + 0.197 * z - 0.004 * z3 + 0.0001 * z5

Encrypted neural net (CKKS)

def encrypted_dense_layer(enc_x, weights, bias):
    """매 매 layer 의 linear part 는 가능, 매 ReLU 는 polynomial approx."""
    z = enc_x.mm(weights) + bias  # 매 matrix-vector
    return polynomial_relu_approx(z)

def polynomial_relu_approx(z):
    """매 ReLU(x) ≈ a + b*x + c*x²."""
    z2 = z * z
    return 0.375 * z + 0.5 + 0.125 * z2  # 매 매 small range

Bootstrapping (FHE refresh)

# 매 SEAL CKKS 의 native bootstrap
# 매 OpenFHE
import openfhe
parameters = openfhe.CCParamsCKKSRNS()
parameters.SetMultiplicativeDepth(20)
cc = openfhe.GenCryptoContext(parameters)
cc.Enable(openfhe.PKESchemeFeature.PKE)
cc.Enable(openfhe.PKESchemeFeature.LEVELEDSHE)
cc.Enable(openfhe.PKESchemeFeature.ADVANCEDSHE)
cc.Enable(openfhe.PKESchemeFeature.FHE)

# 매 bootstrap
ct_refreshed = cc.EvalBootstrap(ct)

TFHE (Boolean fast)

use tfhe::boolean::prelude::*;

let (client_key, server_key) = gen_keys();
let ct1 = client_key.encrypt(true);
let ct2 = client_key.encrypt(false);

// 매 server side
let result = server_key.and(&ct1, &ct2);

// 매 client side
let dec = client_key.decrypt(&result);  // 매 false

Concrete-ML (Zama)

from concrete.ml.sklearn import LogisticRegression

model = LogisticRegression(n_bits=8)
model.fit(X_train, y_train)

# 매 compile to FHE
model.compile(X_train)

# 매 encrypted inference
y_pred = model.predict(X_test_encrypted)

Multi-party (HE + secret share)

def hybrid_compute(encrypted_data_party_a, encrypted_data_party_b, secure_aggregator):
    # 매 매 party 매 encrypt own data
    # 매 aggregator 의 의 의 sum (HE)
    sum_encrypted = encrypted_data_party_a + encrypted_data_party_b
    # 매 only authorized 매 decrypt
    return sum_encrypted

Performance benchmark

import time
def benchmark_he(scheme='ckks'):
    setup_t = time.perf_counter()
    context = create_context(scheme)
    keys = setup_keys(context)
    setup_t = time.perf_counter() - setup_t
    
    enc_t = time.perf_counter()
    ct = encrypt([1, 2, 3], context, keys.pub)
    enc_t = time.perf_counter() - enc_t
    
    op_t = time.perf_counter()
    ct2 = ct * ct
    op_t = time.perf_counter() - op_t
    
    return {'setup': setup_t, 'encrypt': enc_t, 'op': op_t}

Threshold HE (multi-key)

# 매 multi-party with shared secret
# 매 매 party 매 partial decryption share
def threshold_decrypt(ciphertext, partial_shares, threshold):
    if len(partial_shares) >= threshold:
        return combine_shares(partial_shares, ciphertext)
    raise ThresholdNotMet()

FHEVM (smart contract on encrypted)

// 매 fhEVM (Zama)
import "fhevm/lib/TFHE.sol";

contract EncryptedAuction {
    euint64 highestBid;  // 매 encrypted
    
    function bid(bytes calldata encryptedAmount) public {
        euint64 amount = TFHE.asEuint64(encryptedAmount);
        highestBid = TFHE.max(highestBid, amount);
    }
}

매 결정 기준

상황	Scheme
ML inference (real)	CKKS
Exact integer	BFV / BGV
Boolean / lookup	TFHE
Smart contract	FHEVM (TFHE-based)
Multi-party	Threshold HE
Best library	OpenFHE / SEAL / Concrete

기본값: 매 ML = CKKS + 매 polynomial activation. 매 boolean = TFHE. 매 always benchmark before commit (100-1000x cost).

🔗 Graph

• 부모: Cryptography · Privacy-Preserving
• 변형: Fully-HE · Partial-HE · Threshold-HE
• 응용: Privacy-Preserving-ML · Federated-Learning
• Adjacent: Differential-Privacy · Secure-Multiparty-Computation · Zero-Knowledge-Proof

🤖 LLM 활용

언제: 매 medical / financial. 매 cloud trust. 매 multi-party compute. 언제 X: 매 latency-critical. 매 plaintext 의 가능.

❌ 안티패턴

• FHE for everything: 매 cost overkill.
• No polynomial approx of activation: 매 deep ReLU 의 hard.
• Wrong scheme: 매 BFV for real-valued ML.
• No bootstrap when deep: 매 noise overflow.

🧪 검증 / 중복

• Verified (Gentry 2009, CKKS 2017, OpenFHE / SEAL / Concrete docs).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-04-26	Auto
2026-05-08	Phase 1
2026-05-10	Manual cleanup — schemes + 매 TenSEAL / SEAL / TFHE / Concrete / FHEVM code