同型暗号 2025 - 暗号化したまま計算する技術

同型暗号とは何か

同型暗号（Homomorphic Encryption）は、暗号化されたデータに対して直接計算を行える革新的な暗号技術です。復号することなくデータを処理でき、結果を復号すると平文で計算した場合と同じ結果が得られます。

従来の暗号化:
  暗号化データ → 復号 → 計算 → 再暗号化
  （計算時にデータが露出）

同型暗号:
  暗号化データ → 暗号化のまま計算 → 暗号化された結果
  （データは常に保護された状態）

なぜ今、注目されているのか

2025年、同型暗号は理論研究から実用段階へと移行しています。

同型暗号の種類

同型暗号には、サポートする演算の範囲によって3つのカテゴリがあります。

PHE（部分準同型暗号）

Partially Homomorphic Encryption

特徴:
・加算OR乗算のどちらか一方のみサポート
・高速で効率的
・実装がシンプル

代表的なスキーム:
・RSA暗号（乗算のみ）
・Paillier暗号（加算のみ）
・ElGamal暗号（乗算のみ）

Paillier暗号の仕組み

# Paillier暗号の概念（加法準同型）
from phe import paillier

# 鍵ペア生成
public_key, private_key = paillier.generate_paillier_keypair()

# 暗号化
salary_a = public_key.encrypt(50000)  # 従業員Aの給与
salary_b = public_key.encrypt(60000)  # 従業員Bの給与
salary_c = public_key.encrypt(55000)  # 従業員Cの給与

# 暗号化されたまま合計を計算
total_encrypted = salary_a + salary_b + salary_c

# 復号すると正しい合計が得られる
total = private_key.decrypt(total_encrypted)
print(f"給与合計: {total}")  # 165000

# スカラー乗算も可能
average_encrypted = total_encrypted * (1/3)
average = private_key.decrypt(average_encrypted)
print(f"平均給与: {average}")  # 55000

SWHE（制限付き完全準同型暗号）

Somewhat Homomorphic Encryption

特徴:
・加算と乗算の両方をサポート
・演算回数に制限あり（ノイズ蓄積問題）
・FHEより高速

代表的なスキーム:
・BGV（Brakerski-Gentry-Vaikuntanathan）
・BFV（Brakerski/Fan-Vercauteren）
・CKKS（Cheon-Kim-Kim-Song）

ノイズ蓄積の問題

flowchart TD
    A[暗号化時にノイズを付加] --> B[演算ごとにノイズが増大]
    B --> C[一定回数を超えると復号不可能に]

    subgraph noise["ノイズレベルの推移"]
        N1["████████████░░░░░░░░ 初期状態"]
        N2["████████████████░░░░ 数回の演算"]
        N3["████████████████████ 多数の演算"]
        N4["████████████████████ 限界突破"]
    end

    N1 --> N2 --> N3 --> N4
    N4 --> E[復号エラー]

FHE（完全準同型暗号）

Fully Homomorphic Encryption

特徴:
・無制限の加算と乗算が可能
・ブートストラッピングでノイズをリセット
・任意の計算が可能（チューリング完全）

代表的なスキーム:
・TFHE（Fast Fully Homomorphic Encryption over the Torus）
・CKKS（bootstrapping対応版）
・BGV/BFV（bootstrapping対応版）

ブートストラッピングの仕組み

flowchart TD
    subgraph bootstrap["ブートストラッピング = 暗号化されたまま復号を実行"]
        C1["暗号文 C（ノイズ大）"]
        C1 --> P1["秘密鍵を暗号化した評価鍵で<br/>復号回路を同型的に評価"]
        P1 --> C2["暗号文 C'（ノイズ小）"]
        C2 --> R["結果: 同じ平文を暗号化した新しい暗号文<br/>ノイズがリセットされている"]
    end

主要ライブラリの比較

Microsoft SEAL

Microsoftが開発したオープンソースFHEライブラリ。BFVとCKKSスキームをサポート。

// Microsoft SEAL による暗号化計算例
#include "seal/seal.h"

using namespace seal;

void example_bfv_basics() {
    // パラメータ設定
    EncryptionParameters parms(scheme_type::bfv);
    size_t poly_modulus_degree = 4096;
    parms.set_poly_modulus_degree(poly_modulus_degree);
    parms.set_coeff_modulus(CoeffModulus::BFVDefault(poly_modulus_degree));
    parms.set_plain_modulus(1024);

    // コンテキスト生成
    SEALContext context(parms);

    // 鍵生成
    KeyGenerator keygen(context);
    SecretKey secret_key = keygen.secret_key();
    PublicKey public_key;
    keygen.create_public_key(public_key);
    RelinKeys relin_keys;
    keygen.create_relin_keys(relin_keys);

    // 暗号化器・復号器・評価器
    Encryptor encryptor(context, public_key);
    Evaluator evaluator(context);
    Decryptor decryptor(context, secret_key);

    // 平文のエンコード
    BatchEncoder encoder(context);
    std::vector<uint64_t> matrix1 = {1, 2, 3, 4};
    std::vector<uint64_t> matrix2 = {5, 6, 7, 8};

    Plaintext plain1, plain2;
    encoder.encode(matrix1, plain1);
    encoder.encode(matrix2, plain2);

    // 暗号化
    Ciphertext encrypted1, encrypted2;
    encryptor.encrypt(plain1, encrypted1);
    encryptor.encrypt(plain2, encrypted2);

    // 暗号化されたまま乗算
    Ciphertext encrypted_result;
    evaluator.multiply(encrypted1, encrypted2, encrypted_result);
    evaluator.relinearize_inplace(encrypted_result, relin_keys);

    // 復号
    Plaintext plain_result;
    decryptor.decrypt(encrypted_result, plain_result);

    std::vector<uint64_t> result;
    encoder.decode(plain_result, result);
    // result = {5, 12, 21, 32}（要素ごとの乗算）
}

OpenFHE

DARPA資金で開発された包括的なFHEライブラリ。全ての主要スキームをサポート。

// OpenFHE による CKKS 近似計算例
#include "openfhe.h"

using namespace lbcrypto;

void example_ckks_approximate() {
    // CKKS パラメータ設定
    CCParams<CryptoContextCKKSRNS> parameters;
    parameters.SetMultiplicativeDepth(5);
    parameters.SetScalingModSize(50);
    parameters.SetBatchSize(8);

    // コンテキスト生成
    CryptoContext<DCRTPoly> cc = GenCryptoContext(parameters);
    cc->Enable(PKE);
    cc->Enable(KEYSWITCH);
    cc->Enable(LEVELEDSHE);

    // 鍵生成
    auto keys = cc->KeyGen();
    cc->EvalMultKeyGen(keys.secretKey);

    // 実数ベクトルの暗号化
    std::vector<double> x1 = {0.25, 0.5, 0.75, 1.0};
    std::vector<double> x2 = {5.0, 4.0, 3.0, 2.0};

    Plaintext ptxt1 = cc->MakeCKKSPackedPlaintext(x1);
    Plaintext ptxt2 = cc->MakeCKKSPackedPlaintext(x2);

    auto c1 = cc->Encrypt(keys.publicKey, ptxt1);
    auto c2 = cc->Encrypt(keys.publicKey, ptxt2);

    // 暗号化されたまま計算
    auto cAdd = cc->EvalAdd(c1, c2);      // 加算
    auto cMult = cc->EvalMult(c1, c2);    // 乗算
    auto cSub = cc->EvalSub(c1, c2);      // 減算

    // 多項式評価（例: x^2 + 2x + 1）
    auto cSquare = cc->EvalMult(c1, c1);
    auto cDouble = cc->EvalAdd(c1, c1);
    auto cPoly = cc->EvalAdd(cc->EvalAdd(cSquare, cDouble), 1.0);

    // 復号
    Plaintext result;
    cc->Decrypt(keys.secretKey, cMult, &result);
    result->SetLength(4);

    std::cout << "乗算結果: " << result << std::endl;
    // 約 {1.25, 2.0, 2.25, 2.0}
}

TFHE (Fast Fully Homomorphic Encryption)

ビット単位の高速演算に特化。ブートストラッピングが高速。

// TFHE-rs による論理演算例
use tfhe::boolean::prelude::*;

fn example_tfhe_boolean() {
    // 鍵生成
    let (client_key, server_key) = gen_keys();

    // ビット値の暗号化
    let a = client_key.encrypt(true);
    let b = client_key.encrypt(false);

    // 暗号化されたまま論理演算
    let and_result = server_key.and(&a, &b);    // AND
    let or_result = server_key.or(&a, &b);      // OR
    let xor_result = server_key.xor(&a, &b);    // XOR
    let not_result = server_key.not(&a);        // NOT

    // 復号
    let decrypted_and = client_key.decrypt(&and_result);  // false
    let decrypted_or = client_key.decrypt(&or_result);    // true
    let decrypted_xor = client_key.decrypt(&xor_result);  // true
    let decrypted_not = client_key.decrypt(&not_result);  // false
}

// 整数演算も可能
use tfhe::shortint::prelude::*;

fn example_tfhe_integer() {
    let (client_key, server_key) = gen_keys(PARAM_MESSAGE_2_CARRY_2);

    // 2ビット整数の暗号化
    let ct_1 = client_key.encrypt(3);  // 3 (binary: 11)
    let ct_2 = client_key.encrypt(2);  // 2 (binary: 10)

    // 暗号化されたまま算術演算
    let ct_add = server_key.unchecked_add(&ct_1, &ct_2);
    let ct_mul = server_key.unchecked_mul_lsb(&ct_1, &ct_2);

    // 復号
    let result_add = client_key.decrypt(&ct_add);  // 5 (mod 4 = 1)
    let result_mul = client_key.decrypt(&ct_mul);  // 6 (mod 4 = 2)
}

ライブラリ比較表

ユースケース

医療分野

患者データを暗号化したまま分析し、プライバシーを完全保護。

# 医療データ分析の概念コード
class EncryptedMedicalAnalysis:
    def __init__(self, fhe_context):
        self.context = fhe_context

    def analyze_patient_cohort(self, encrypted_patients):
        """
        暗号化された患者データのコホート分析
        病院はデータを復号せずに分析結果のみ取得
        """
        # 暗号化されたまま統計計算
        results = {
            # 平均年齢の計算
            "avg_age": self.encrypted_mean(
                [p.age for p in encrypted_patients]
            ),
            # 疾患発生率
            "disease_rate": self.encrypted_rate(
                [p.has_disease for p in encrypted_patients]
            ),
            # リスクスコア
            "risk_scores": [
                self.calculate_risk(p) for p in encrypted_patients
            ]
        }
        return results

    def genomic_analysis(self, encrypted_genome):
        """
        暗号化されたゲノムデータの解析
        遺伝情報を露出させずに疾患リスクを判定
        """
        # SNP（一塩基多型）の暗号化評価
        risk_variants = self.context.evaluate_circuit(
            encrypted_genome,
            self.snp_risk_circuit
        )
        return risk_variants

# 実際のユースケース
use_cases = """
1. 多施設臨床研究
   - 各病院のデータを暗号化したまま統合
   - 患者プライバシーを保護しつつ大規模分析

2. ゲノム解析サービス
   - 23andMe等の遺伝子解析
   - 遺伝情報を企業に露出させない

3. 医療AI診断
   - 画像診断AIを暗号化データで実行
   - 患者画像の漏洩リスクゼロ

4. 保険料算定
   - 健康データを開示せずにリスク評価
   - 差別的利用の防止
"""

金融分野

取引データや信用情報を保護しながら分析。

// 金融分析の概念コード
class EncryptedFinancialAnalysis {
  constructor(private fheContext: FHEContext) {}

  /**
   * 暗号化された取引データでマネーロンダリング検知
   */
  async detectAML(
    encryptedTransactions: EncryptedTransaction[]
  ): Promise<EncryptedRiskScores> {
    // 暗号化されたまま異常パターンを検出
    const scores = await this.fheContext.evaluate(
      encryptedTransactions,
      this.amlDetectionCircuit
    );
    return scores;
  }

  /**
   * 暗号化された信用情報でスコアリング
   */
  async creditScoring(
    encryptedCreditHistory: EncryptedCreditData
  ): Promise<EncryptedScore> {
    // 信用情報を開示せずにスコア算出
    return this.fheContext.evaluate(
      encryptedCreditHistory,
      this.creditScoringModel
    );
  }

  /**
   * 複数金融機関間の不正検知
   */
  async crossBankFraudDetection(
    bankAEncryptedData: EncryptedData,
    bankBEncryptedData: EncryptedData
  ): Promise<EncryptedAlerts> {
    // 各銀行のデータを暗号化したまま照合
    // 互いの顧客情報は見えない
    return this.fheContext.secureJoin(
      bankAEncryptedData,
      bankBEncryptedData,
      this.fraudPatternMatcher
    );
  }
}

// ユースケース一覧
const financialUseCases = `
1. 信用スコアリング
   - 信用情報を開示せずにスコア算出
   - データブローカーへの情報漏洩防止

2. 不正取引検知
   - 複数機関のデータを暗号化共有
   - 競合他社に顧客情報を見せない

3. リスク分析
   - ポートフォリオを暗号化したまま分析
   - 投資戦略の秘匿

4. 規制対応
   - GDPR準拠のデータ処理
   - 越境データ転送の安全化
`;

機械学習（PPML: Privacy-Preserving Machine Learning）

# プライバシー保護機械学習の例
import concrete.ml as cml
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# データ準備
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Concrete MLで暗号化対応モデルを訓練
model = cml.sklearn.LogisticRegression()
model.fit(X_train, y_train)

# FHE用にモデルをコンパイル
fhe_circuit = model.compile(X_train)

# 暗号化推論の実行
# クライアント側: データを暗号化
encrypted_input = fhe_circuit.encrypt(X_test[0])

# サーバー側: 暗号化されたまま推論
encrypted_output = fhe_circuit.run(encrypted_input)

# クライアント側: 結果を復号
prediction = fhe_circuit.decrypt(encrypted_output)
print(f"予測クラス: {prediction}")

# より複雑なニューラルネットワーク
class EncryptedNeuralNetwork:
    """
    暗号化データで動作するニューラルネットワーク
    """
    def __init__(self):
        # 活性化関数は多項式近似を使用
        # （ReLUは暗号化状態で直接計算不可）
        self.layers = [
            EncryptedLinear(784, 128),
            PolynomialActivation(degree=3),  # ReLUの近似
            EncryptedLinear(128, 10),
            EncryptedSoftmax()
        ]

    def forward(self, encrypted_input):
        x = encrypted_input
        for layer in self.layers:
            x = layer(x)
        return x

# 実際の性能（2025年現在）
performance_benchmarks = """
モデル          | 平文推論 | 暗号化推論 | オーバーヘッド
----------------|----------|------------|---------------
ロジスティック回帰 | 0.1ms   | 50ms       | 500x
決定木           | 0.5ms   | 200ms      | 400x
ランダムフォレスト | 5ms     | 2s         | 400x
小規模NN (MNIST) | 1ms     | 5s         | 5000x
CNN (画像分類)   | 10ms    | 30s        | 3000x
"""

パフォーマンス課題と改善

2025年の性能状況

timeline
    title 同型暗号の性能進化
    2009年 (Gentry初論文)
        : 1ビット演算 - 30分
        : 実用性 - なし
    2015年
        : 1ビット演算 - 数秒
        : 実用性 - 研究段階
    2020年
        : 整数演算 - ミリ秒単位
        : 実用性 - 限定的ユースケース
    2025年 ★現在
        : ブートストラップ - 100ms未満 (TFHE)
        : 機械学習推論 - 数秒〜数分
        : 実用性 - プロダクション導入開始

主要な最適化技術

# 1. SIMD (Single Instruction Multiple Data)
# 1つの暗号文で複数の値を並列処理

class SIMDOptimization:
    """
    スロットパッキングで並列処理
    """
    def __init__(self, context):
        self.context = context
        self.num_slots = 4096  # 1暗号文で4096個の値

    def batch_encrypt(self, values):
        """
        複数の値を1つの暗号文にパック
        """
        # 4096個の値を1回の暗号化で処理
        packed = self.pack_into_slots(values)
        return self.context.encrypt(packed)

    def parallel_add(self, ct1, ct2):
        """
        1回の加算で4096個の加算を同時実行
        """
        return self.context.add(ct1, ct2)


# 2. レベル管理と最適化
class LevelOptimization:
    """
    乗算回数を最小化してノイズを抑制
    """
    def optimized_polynomial(self, x, coeffs):
        """
        Hornor法でx^4 + 2x^3 + 3x^2 + 4x + 5を計算
        乗算回数を最小化
        """
        # 通常: 4 + 3 + 2 + 1 = 10回の乗算
        # Hornor法: 4回の乗算
        result = coeffs[0]
        for c in coeffs[1:]:
            result = result * x + c
        return result


# 3. GPUアクセラレーション
gpu_acceleration = """
2025年のGPU最適化状況:

ライブラリ     | GPU対応 | 高速化率
--------------|---------|----------
OpenFHE       | 〇      | 10-50x
TFHE-rs       | 〇      | 20-100x
Concrete      | 〇      | 50-200x
cuFHE         | ◎      | 100-500x

NVIDIA H100での性能:
- ブートストラップ: 10ms以下
- 大規模NN推論: 数秒
"""

ハードウェアアクセラレーション

flowchart TB
    subgraph hw["FHEハードウェアアクセラレーション 2025"]
        direction TB
        subgraph intel["1. Intel HEXL"]
            I1["AVX-512最適化NTT（数論変換）"]
        end
        subgraph ibm["2. IBM FHE Toolkit"]
            I2["Power10プロセッサ最適化"]
        end
        subgraph fpga["3. FPGA実装"]
            I3["専用回路で100x以上の高速化"]
        end
        subgraph asic["4. ASIC開発（進行中）"]
            A1["Intel: FHEアクセラレータ研究"]
            A2["DARPA DPRIVE: 専用チップ開発"]
            A3["各スタートアップ: 2026年製品化予定"]
        end
    end

クラウドサービス

主要クラウドプロバイダーのFHEサービス

# 2025年のFHEクラウドサービス状況

AWS:
  service: "AWS Clean Rooms with FHE"
  status: "GA (2024年〜)"
  features:
    - 複数パーティ間のセキュアコンピューティング
    - 暗号化データのSQL分析
    - S3統合
  pricing: "クエリ単位課金"

Google Cloud:
  service: "Confidential Computing + FHE"
  status: "Preview"
  features:
    - BigQueryとの統合
    - Vertex AI暗号化推論
    - Confidential VMとの組み合わせ

Microsoft Azure:
  service: "Azure Confidential Computing"
  status: "GA"
  features:
    - Always Encrypted with FHE
    - SEALベースの計算
    - Azure ML統合

IBM Cloud:
  service: "IBM Fully Homomorphic Encryption"
  status: "GA"
  features:
    - HElibベース
    - Macプラットフォーム対応SDK
    - ハイブリッドクラウド対応

Zama:
  service: "fhEVM (Blockchain)"
  status: "Testnet"
  features:
    - 暗号化スマートコントラクト
    - プライベートDeFi
    - EVM互換

クラウドでのFHE利用例

# AWS Clean Rooms FHE 概念コード
import boto3

class AWSCleanRoomsFHE:
    def __init__(self):
        self.client = boto3.client('cleanrooms')

    def create_collaboration(self, members):
        """
        複数組織間のセキュアな協業環境を作成
        """
        return self.client.create_collaboration(
            name="cross-company-analysis",
            members=members,
            dataEncryptionMetadata={
                "allowCleartext": False,
                "allowDuplicates": False,
                "preserveNulls": False
            },
            queryLogStatus="ENABLED"
        )

    def run_encrypted_analysis(self, collaboration_id, query):
        """
        暗号化データに対するクエリを実行
        """
        return self.client.start_protected_query(
            collaborationId=collaboration_id,
            type="SQL",
            sqlParameters={
                "queryString": query
            },
            resultConfiguration={
                "outputConfiguration": {
                    "s3": {
                        "bucket": "results-bucket",
                        "keyPrefix": "fhe-results/"
                    }
                }
            }
        )

# 使用例
fhe_client = AWSCleanRoomsFHE()

# 暗号化されたまま顧客分析
result = fhe_client.run_encrypted_analysis(
    collaboration_id="collab-123",
    query="""
        SELECT
            demographic_segment,
            AVG(purchase_amount) as avg_spend,
            COUNT(*) as customer_count
        FROM encrypted_customer_data
        GROUP BY demographic_segment
    """
)

2025年の実用化状況

導入事例

flowchart TB
    subgraph cases["FHE実用化事例 2025"]
        direction TB
        subgraph finance["金融"]
            F1["Mastercard: 暗号化クレジットスコアリング"]
            F2["JPMorgan: セキュアマルチパーティ取引分析"]
            F3["Swiss Re: 暗号化リスク評価"]
        end
        subgraph medical["医療"]
            M1["Roche: 暗号化ゲノム解析"]
            M2["NHS (英国): 患者データのFHE分析"]
            M3["23andMe: プライバシー保護遺伝子検査"]
        end
        subgraph tech["テクノロジー"]
            T1["Apple: オンデバイスFHE（Siri改善）"]
            T2["Google: 暗号化広告測定"]
            T3["Microsoft: Azure FHEサービス"]
        end
        subgraph gov["政府"]
            G1["DARPA: DPRIVE プログラム"]
            G2["EU: GDPR準拠データ処理"]
            G3["韓国: 国家統計の暗号化処理"]
        end
    end

標準化の進展

# FHE標準化状況 2025

ISO/IEC:
  - 18033-6: "同型暗号"
    status: "策定中（2025年完了予定）"
    scope:
      - スキーム定義（BGV, BFV, CKKS, TFHE）
      - セキュリティパラメータ
      - 相互運用性

HomomorphicEncryption.org:
  - "HE Standard v1.1"
    status: "発行済み"
    contents:
      - セキュリティレベル定義
      - パラメータ選択ガイド
      - ベンチマーク基準

NIST:
  - "Post-Quantum Cryptography"
    relevance: "FHEの格子暗号ベースは量子耐性"
    status: "標準化完了（ML-KEM, ML-DSA）"

今後の展望

2025年: FHE実用化元年
├── 性能: プロダクション利用可能なレベルに到達
├── ツール: 開発者フレンドリーなSDK整備
└── 導入: 先進企業での本番運用開始

2026-2027年: 普及期
├── クラウドサービス: 主要プロバイダーがGA提供
├── ハードウェア: 専用アクセラレータ製品化
└── 規制: GDPR等での「ベストプラクティス」認定

2028-2030年: 標準技術化
├── 性能: 平文処理と同等の体感速度
├── 採用: クラウドデータ処理の標準オプション
└── AI: プライバシー保護MLがデフォルト

課題と限界

現在の制約

# FHEの現実的な制約

limitations = {
    "性能オーバーヘッド": {
        "説明": "平文処理の1000〜10000倍遅い",
        "影響": "リアルタイム処理には不向き",
        "緩和策": "バッチ処理、非同期実行"
    },

    "暗号文サイズ": {
        "説明": "平文の100〜1000倍に膨張",
        "影響": "ネットワーク帯域、ストレージコスト",
        "緩和策": "圧縮、差分転送"
    },

    "計算の制約": {
        "説明": "比較演算、条件分岐が高コスト",
        "影響": "全てのアルゴリズムが効率的に動くわけではない",
        "緩和策": "FHEフレンドリーなアルゴリズム設計"
    },

    "専門知識": {
        "説明": "パラメータ選択に暗号学の知識が必要",
        "影響": "導入障壁が高い",
        "緩和策": "自動パラメータ選択ツール"
    }
}

# 適用判断のガイドライン
def should_use_fhe(use_case):
    """
    FHE採用の判断基準
    """
    criteria = {
        "データ機密性": use_case.data_sensitivity >= "HIGH",
        "規制要件": use_case.regulatory_requirement,
        "複数パーティ": use_case.multi_party_computation,
        "レイテンシ許容": use_case.latency_tolerance >= "SECONDS",
        "バッチ処理可": use_case.batch_processing_acceptable
    }

    # 推奨判定
    if all([
        criteria["データ機密性"],
        criteria["レイテンシ許容"],
        any([criteria["規制要件"], criteria["複数パーティ"]])
    ]):
        return "FHE推奨"

    return "他のPETsを検討（TEE, MPC, DP等）"

他のプライバシー技術との比較

flowchart TB
    subgraph pets["プライバシー保護技術（PETs）比較"]
        direction TB
        subgraph fhe_box["FHE（同型暗号）"]
            FHE_S["セキュリティ: 暗号学的保証<br/>データ常時暗号"]
            FHE_P["性能: 低速（1000x遅い）"]
            FHE_U["用途: 任意計算"]
        end
        subgraph tee_box["TEE（Intel SGX等）"]
            TEE_S["セキュリティ: ハードウェア<br/>サイドチャネル攻撃リスク"]
            TEE_P["性能: 高速（ほぼネイティブ）"]
            TEE_U["用途: 汎用計算"]
        end
        subgraph mpc_box["MPC（秘密分散計算）"]
            MPC_S["セキュリティ: 暗号学的保証<br/>通信コスト大"]
            MPC_P["性能: 中速（10-100x）"]
            MPC_U["用途: 複数パーティ"]
        end
        subgraph dp_box["DP（差分プライバシー）"]
            DP_S["セキュリティ: 統計的保証<br/>精度低下"]
            DP_P["性能: 高速（オーバーヘッド小）"]
            DP_U["用途: 統計分析"]
        end
        subgraph fl_box["FL（連合学習）"]
            FL_S["セキュリティ: データ移動なし<br/>勾配攻撃リスク"]
            FL_P["性能: 通信依存"]
            FL_U["用途: 分散学習"]
        end
    end

    subgraph combo["組み合わせ"]
        C1["FHE + MPC: セキュリティ強化"]
        C2["FHE + DP: プライバシー二重保護"]
        C3["FHE + FL: 完全プライベート連合学習"]
    end

参考リソース

まとめ

2025年、同型暗号は理論から実用へと大きく進化しました。性能は2009年比で100万倍以上向上し、Microsoft SEAL、OpenFHE、TFHE-rsなどの成熟したライブラリが利用可能です。

主なポイント:

• PHE/SWHE/FHEの3種類があり、用途に応じて選択
• CKKSは機械学習に、TFHEは論理演算に最適
• 医療・金融分野でプロダクション導入が開始
• クラウドサービス（AWS、Azure、GCP）で利用可能に
• パフォーマンスは改善中だが、まだ1000倍程度のオーバーヘッド

「暗号化したまま計算する」という革命的な技術は、データプライバシーとデータ活用の両立という長年の課題を解決する鍵となります。GDPR、HIPAA等の規制強化とクラウド・AI活用の拡大が続く中、同型暗号は今後ますます重要な技術となるでしょう。