参考文献：

1. [GHPS12] Gentry C, Halevi S, Peikert C, et al. Ring switching in BGV-style homomorphic encryption[C]//International Conference on Security and Cryptography for Networks. Berlin, Heidelberg: Springer Berlin Heidelberg, 2012: 19-37.
2. [GHPS13] Gentry C, Halevi S, Peikert C, et al. Field switching in BGV-style homomorphic encryption[J]. Journal of Computer Security, 2013, 21(5): 663-684.
3. [BCK+23] Bae Y, Cheon J H, Kim J, et al. HERMES: Efficient Ring Packing Using MLWE Ciphertexts and Application to Transciphering[C]//Annual International Cryptology Conference. Cham: Springer Nature Switzerland, 2023: 37-69.

[BCK+23] 发现：对于大模数，环打包的开销会高于自举的开销。因此，他们先在小模数、小维度上打包，然后再合并为大维度，并利用自举提升模数。此外，他们提出在打包算法中插入 MLWE 中点，从而大幅减少 KSK 的规模，计算复杂度略微提升。

Ring Packing

环打包的任务是在 LWE-format 以及 RLWE-format 之间转换。应用的场景为：异构的数据类型、异构的运算宽度/数据量、细粒度存储数据、减小通信带宽。

环打包的实质就是同态计算 $C\cdot s(\mathrm{mod}q)$，其中 $C\in {\mathbb{Z}}_q^{N\times (K+1)}$ 是由 $N$ 个维度 $K$ 的 LWE 密文堆叠出的矩阵，$s\in {\mathbb{Z}}^{K+1}$ 是 LWE 私钥（表示为 $s=(1,s^{\prime }),s^{\prime }\in {\mathbb{Z}}^K$）。[HS14] 提出了矩阵-向量乘积的三种算法：假设 RLWE 是强线性同态的（[BV11] 或者 [GHS12]）

1. column method，
   • 令 $c_j\in {\mathbb{Z}}_q^N$ 是矩阵 $C$ 的列矢，那么 $C\cdot s={\sum }_j{c}_j\cdot s_j$
   • 将 $c_j$ 系数编码为多项式，将 $s_j$ 分别作为常数多项式被加密，那么计算 $K$ 次同态数乘以及加法，就得到了 coefficients-encoding 的打包密文
   • Pub-KS of TFHE、[MS18]、Chimera 都是这个方法
2. row method，
   • 令 $c_i\in {\mathbb{Z}}_q^{K+1}$ 是矩阵 $C$ 的行矢，那么 $C\cdot s=[⟨c_i,s⟩{]}_i$
   • 将 $c_i$ 系数编码为多项式，将 $s$ 也系数编码为多项式并加密，那么计算单次同态数乘，它的常数项就是 $⟨c_i,s⟩$，使用 Galois 自同构计算 Trace 消除其他的系数，就得到了 coefficients-encoding 的打包密文
   • LWE-to-RLWE 就是这个方法
3. diagonal method，
   • 令 $d_i\in {\mathbb{Z}}_q^{K+1}$ 是矩阵 $C$ 的对角线，那么 $C\cdot s={\sum }_i{d}_i\odot (s⋘i)$
   • 将 $d_i$ 槽打包为多项式，将 $s$ 也槽打包为多项式并加密，使用 Galois 自同构实现 Rotate 以 BSGS 方式运算，就得到了 slots-encoding 的打包密文
   • Pegasus 就是这个方法

[BCK+23] 的目标是：将大量的 LWE 密文高效地打包成为 slots-encoded RLWE-format pure-FHE。自举要求巨大的模数，从而维度也会很大，之前的那些打包算法存在诸多限制：系数打包、速度慢、仅支持少量 LWE 密文。

Moduli optimization

[BCK+23] 观察到：由 LWE 密文堆叠出的矩阵 $C$ 没有特殊结构，因此计算 $C\cdot s$ 需要大量的同态运算，每个同态操作都是在大模数上运行，都需要很多的 NTT 运算。

[BCK+23] 将打包操作放在尽可能小的模数上，然后用自举提升模数。他们观察到，对于大规模电路，模数编排所带来的收益，远大于自举的开销。类似于 RtF Framework，使用 HalfBTS 将系数打包的小模数 CKKS 密文转化为槽打包的大模数 CKKS 密文。

一些记号：

• $LW{E}_q^K$ 是维度 $K$ 模数 $q$ 的 LWE 密文，私钥 $s\in {\mathbb{Z}}^K$
• $RLW{E}_{q,N}$ 是维度 $N$ 模数 $q$ 的 RLWE 密文，私钥 $s\in R_N$
• $Q_{Enc}$ 是 Level 0 模数（保证解密正确），$Q_{KS}$ 是 Level 1 模数（做 KS 后解密仍正确），$Q_{top}$ 是 ModRaise 输出模数，$Q_{refresh}$ 是自举之前的模数，$Q_{comp}$ 是自举之后的模数，
• $N_{Enc},N_{KS},N_{BTS}$ 是保证安全强度的必要维度
• 对于 HalfBTS，步骤是 ModRasie、CtS、EvalMod，第一步 StC 被省略，因此可以 $Q_{refresh}=Q_{Enc}$

Moduli-optimized ring packing：

1. 将 LWE 密文使用 base ring packing 获得 coefficients-encoding RLWE 密文，模数是 $Q_{Enc}$，维度是 $N_{BTS}$
2. 调用 HalfBTS 将模数提升到 $Q_{comp}$，并且成为 slots-encoding RLWE 密文

这里的 base ring packing 可以是上述的三种打包方法，但是 column method 不需要 Galois 自同构，因此不消耗 Levels，获得的收益会更大。

Ring switching

由于 base ring packing 只工作在很小的模数上，因此只要较低的维度就足够保证安全性。[BCK+23] 使用 Ring-Switch 技术，将 LWE 密文分成几组，每一组打包到低维度 RLWE 密文，然后再把它们合成出高维度 RLWE 密文。

目标的分圆环是 $R_{q,N}$，维度 $N$ 是二的幂次。假设 $k\mid N$，那么根据：
$$\sum _{i=0}^{N-1}{a}_i{X}^i=\sum _{i=0}^{k-1}{X}^i\cdot \sum _{j=0}^{N/k-1}{a}_{i+jN/k}{X}^{jN/k}=\sum _{i=0}^{k-1}{X}^i\cdot a_{(i)}(X^{N/k})$$
我们可以将 $R_{q,N}$ 视为 rank-$k$ $R_{q,N/k}$-module，确切地说：
$$R_{q,N}={\mathbb{Z}}_q[X]/(X^N+1)\cong ({\mathbb{Z}}_q[Y]/(Y^{N/k}+1))[X]/(X^k-Y)=R_{q,N/k}[X]/(X^k-Y)$$
方便起见，我们用 $X_N$ 表示 $R_{q,N}$ 的本原单位根，简记 ${\beta }_i=X_N^i,0\le i\le k-1$，那么 { β i } \{\beta_i\} {βi​} 是一组 $R_{q,N/k}$-basis，
$$R_{q,N}=\sum _{i=0}^{k-1}{R}_{q,N/k}\cdot {\beta }_i$$
定义 ${\pi }_{q,N}^k:R_{q,N}\to (R_{q,N/k}{)}^k$ 是模分解（module decomposition map），具体是 ${\pi }_{q,N}^k(a)=(a_{(0)},\cdots ,a_{(k-1)})$，满足 $a={\sum }_j{a}_{(j)}\cdot {\beta }_j$，这是一个 $R_{q,N/k}$-线性映射。定义 ${\iota }_{q,N}^k:R_{q,N/k}\to R_{q,N}$ 是环嵌入（ring embedding），具体是 ${\iota }_{q,N}^k(X_{N/k})=X_N^k$，这是一个 $R_{q,N/k}$-单同态。

假如 RLWE 密文 $(a,b)\in R_{q,N}^2$ 的私钥是 $s=s_{(0)}\in R_{q,N/k}$，相位是 $b+as=m$，那么就有 $b_{(j)}+a_{(j)}{s}_{(0)}=m_{(j)}$，从而可以把 $(a_{(j)},b_{(j)})\in R_{q,N/k}^2$ 视为 $m_{(j)}\in R_{q,N/k}$ 的密文。定义如下的两个函数，

• Split：输入 $(a,b)\in R_{q,N}^2$，计算 ${\varphi }_{q,N}^k(a)=(a_{(0)},\cdots ,a_{(k-1)})$ 以及 ${\pi }_{q,N}^k(a)=(a_{(0)},\cdots ,a_{(k-1)})$，输出 $(a_{(j)},b_{(j)})\in R_{q,N/k}^2$
• Combine：输入 $(a_{(j)},b_{(j)})\in R_{q,N/k}^2$，计算 $a={\sum }_j{\iota }_{q,N}^k(a_{(j)})\cdot {\beta }_j$ 以及 $b={\sum }_j{\iota }_{q,N}^k(b_{(j)})\cdot {\beta }_j$，输出 $(a,b)\in R_{q,N}^2$

它们就是系数的置换，计算开销可忽略。

[BCK+23] 将 $N$ 个维度 $K$ 的 LWE 密文分成 $N/n$ 组，每一组打包成维度 $n$ 的 RLWE 密文，然后将 $N/n$ 个 RLWE 密文合成为维度 $N$ 的 RLWE 密文，最后用 HalfBTS 提升模数。如图所示：

额外的优势是，低维度的环打包，所需的 KSK 规模也会更小一些。

Hermes

在三种打包算法中，列方法是最快的，并且更加适合上述的模数优化策略。然而，列方法需要分别加密 $s_j\in {\mathbb{Z}}_q,0\le j\le K-1$，导致 KSK 规模的较大。为了进一步减小密钥规模，[BCK+23] 将上述的 Ring packing 推广到 Module packing，在 LWE 密文和 RLWE 密文之间插入 MLWE 密文，多层迭代。

一些记号：

• $MLW{E}_{q,n}^k$ 是一个 MLWE 密文，模数 $q$，度数 $n$，秩 $k$，维度 $N=n\cdot k$
• 密文是 $c=(c[0],c[1],\cdots ,c[k])\in R_{q,n}^{k+1}$，简记 $b=c[0]$ 以及 $a=(c[1],\cdots ,c[k])\in R_{q,n}^k$，对应的私钥是 $s\in R_{q,n}^k$
• 易知，$MLW{E}_{q,1}^K=LW{E}_q^K$，$MLW{E}_{q,N}^1=RLW{E}_{q,N}$

MLWE Module-switch

假设 $l,k,n$ 都是二的幂次，密文 $MLW{E}_{q,nl}^k$ 私钥是 $s\in R_n^k\le R_{nl}^k$，那么类似于 Ring Switch，可以定义如下的模切换（注意区分，模数切换，Modulus-Switching）：

• $Spli{t}_{n,l}^k:MLW{E}_{q,nl}^k\to l\times MLW{E}_{q,n}^k$，
  • 输入 $c=MLW{E}_{q,nl}^k(m)$
  • 计算 ${\pi }_{q,nl}^l(c[j])=(c_0[j],\cdots ,c_{l-1}[j]),0\le j\le k$
  • 输出 $c_t=(c_t[0],\cdots ,c_t[k])\in R_{q,n}^{k+1},0\le t\le l-1$，它们分别加密了 $m_{(t)}$
• $Combin{e}_{n,l}^k:l\times MLW{E}_{q,n}^k\to MLW{E}_{q,nl}^k$，
  • 输入 $c_t=MLW{E}_{q,n}^k(m_t),0\le t\le l-1$
  • 计算 $c[j]=({\pi }_{q,nl}^l{)}^{-1}(c_0[j],\cdots ,c_{l-1}[j]),0\le j\le k$
  • 输出 $c=(c[0],\cdots ,c[k])\in R_{q,nl}^{k+1}$，它加密了 $m={\sum }_t{m}_t\cdot {\beta }_t$

MLWE Key-switch

类似于 [CDKS21] 中的 LWE-to-LWE 算法，我们可以将 MLWE 上的 KS 过程也嵌入到 RLWE 上实现。

给定 $a,s\in R_{q,N}\cong R_{q,n}[X_N]/(X_N^k-X_n)$，其中 $n=N/k$，分别写作 $a={\sum }_i{a}_{(i)}\cdot X_N^i$ 以及 $s={\sum }_j{s}_{(j)}\cdot X_N^j$，那么
$$\begin{array}{rl}a\cdot s& =\left(\sum _{i=0}^{k-1}{a}_{(i)}\cdot X_N^i\right)\cdot \left(\sum _{j=0}^{k-1}{s}_{(j)}\cdot X_N^j\right)\\ & =\sum _{t=0}^{k-1}{X}_N^t\cdot \left(\sum _{i+j=t}{a}_{(i)}{s}_{(j)}+X_n\cdot \sum _{i+j=k+t}{a}_{(i)}{s}_{(j)}\right)\end{array}$$
它的常数项是 $a_{(0)}{s}_{(0)}+X_n\cdot {\sum }_{i=1}^{k-1}{a}_{(k-i)}{s}_{(i)}$，我们定义 $a\in R_{q,N}$ 的扭曲（twist）：
$$a^{tw,k}=({\pi }_{q,N}^k{)}^{-1}(a_{(0)},X_{N/k}\cdot a_{k-1},\cdots ,X_{N/k}\cdot a_1)\in R_{q,N}$$
定义映射 ${ϵ}_{q,N}^k:R_{q,N}\to R_{q,N/k}$，它计算 ${ϵ}_{q,N}^k(a)={\pi }_{q,N}^k(a)[0]=a_{(0)}$，那么就有：
$${ϵ}_{q,N}^k(a^{tw,k}\cdot s)=⟨{\pi }_{q,N}^k(a),{\pi }_{q,N}^k(s)⟩$$
也就是说，想要计算 $⟨{\pi }_{q,N}^k(a),{\pi }_{q,N}^k(s)⟩$ 内积，可以计算 $a^{tw,k}\cdot s$ 多项式乘积，然后再提取出 $R_{q,N/k}$-常数项。我们可以把 $MLW{E}_{q,n}^k$ 的线性解密视为 $R_{q,n}$ 上的内积，嵌入到 $RLW{E}_{q,N}$ 上计算多项式乘积，最后提取出 $MLW{E}_{q,n}^k$ 作为 KS 结果。对应的嵌入映射是：
$$\begin{array}{rl}Embe{d}_{q,N}^k:MLW{E}_{q,n}^k& \to RLW{E}_{q,N}\\ (b,a)\in R_{q,n}^{k+1}& \mapsto \left({\iota }_{q,N}^k(b),({\pi }_{q,N}^k(a){)}^{tw,k}\right)\in R_{q,N}^2\end{array}$$
前者的相位是 $m\in R_{q,n}$，后者的相位是 $M\in R_{q,N}$，满足 ${ϵ}_{q,N}^k(M)=M_{(0)}=m$，其余的 $M_{(j)},1\le j\le k-1$ 是随机数。做完 RLWE KS 之后，需要提取出 $m$ 对应的 MLWE 密文。对应的提取映射是：
$$\begin{array}{rl}Extrac{t}_{q,N}^k:RLW{E}_{q,N}& \to MLW{E}_{q,n}^k\\ (b,a)\in R_{q,N}^2& \mapsto \left({ϵ}_{q,N}^k(b),({\pi }_{q,N}^k(a){)}^{(tw,k{)}^{-1}}\right)\in R_{q,n}^{k+1}\end{array}$$
那么 MLWE-to-MLWE 过程就是：

ModPack

利用上述的 $Combin{e}_{n,l}^k$ 以及 $Embe{d}_{q,N}^k$ 和 $Extrac{t}_{q,N}^k$，可以实现 Module-packing 算法，记为 $ModPac{k}_{q,N}^{K,k,k^{\prime }}$。它将若干个 $MLW{E}_{q,N/k}^K$ 打包到单个 $MLW{E}_{q,N/k^{\prime }}^{k^{\prime }}$，其中 $1\le k^{\prime }<k\le N$ 都是二的幂次，并且 $k^{\prime }\mid K$ 是某整数。

由于 $MLW{E}_{q,N/k}^K$ 加密了 $N/k$ 个数据，$MLW{E}_{q,N/k^{\prime }}^{k^{\prime }}$ 加密了 $N/k^{\prime }$ 个数据，因此我们可以先将 $k/k^{\prime }$ 个 $MLW{E}_{q,N/k}^K(m_j)$ 密文，利用 Module-switch 合并为单个 $C=MLW{E}_{q,N/k^{\prime }}^K\left(({\pi }_{q,N/k^{\prime }}^{k/k^{\prime }}{)}^{-1}(m_0,\cdots ,m_{k/k^{\prime }-1})\right)$ 密文，它的线性解密是：
$$\begin{array}{r}C[0]+\sum _{i=1}^{K}C[i]\cdot s[i]=\left(C[0]+\sum _{i=1}^{k^{\prime }}C[i]\cdot s[i]\right)+\sum _{j=1}^{K/k^{\prime }-1}\left(0+\sum _{i=1}^{k^{\prime }}C[k^{\prime }j+i]\cdot s[k^{\prime }j+i]\right)\end{array}$$
我们将 $C$ 视为 $K/k^{\prime }$ 个 $MLW{E}_{q,N/k^{\prime }}^{k^{\prime }}$ 密文的加和，然后利用 MLWE-to-MLWE 将它们分别切换到 $MLW{E}_{q,N/k^{\prime }}^{k^{\prime }}$ 密文。这里可以使用 hoisting 技术优化。

使用 [GHS12] 版本的 RLWE KS 算法，那么 ModPack 算法为：

算法 $ModPac{k}_{q,N}^{K,k,k^{\prime }}$ 的 step 6 中，首先执行 $K/k^{\prime }$ 次 ModUp（从 $q$ 扩展到 $qp$），然后执行 $2K/k^{\prime }$ 次阿达玛乘法（线性解密），接着先计算它们的加和，最后执行 $1$ 次 ModDown（从 $qp$ 切换到 $q$）。其中的 ModUp 和 ModDown 需要执行 RNSConv 以及 NTT，占据主要开销。KSK 包含 $K/k^{\prime }$ 个 swk，每个都是 $R_{qp,N}^2$ 中元素，总大小是 $2N\log (qp)$（如果使用 Hybrid KS 呢？）

BaseHERMES

给定 $N$ 个维度 $K\ge N_{Enc}$ 模数 $Q_{Enc}$ 的 LWE 密文，将它打包成单个维度 $N\ge N_{KS}$ 模数 $Q_{Enc}$ 的 RLWE 密文。[BCK+23] 插入 $t$ 层 MLWE 中间密文，对应的参数 κ = { N = k 0 > k 1 > ⋯ > k t > 1 = k t + 1 } \kappa=\{N=k_0 >k_1 > \cdots > k_t > 1=k_{t+1}\} κ={N=k0​>k1​>⋯>kt​>1=kt+1​}，算法 $BaseHERME{S}_N^{K,\kappa }$ 的计算流程是：

其中的 step $i$ 都是将 $k_{i-1}$ 个 $MLW{E}_{Q,N/k_{i-1}}^{k_{i-1}}$ 密文分成 $k_i$ 组，并行执行它们的 ModPack 得到 $k_i$ 个 $MLW{E}_{Q,N/k_i}^{k_i}$ 密文。算法是：

计算复杂度和密钥规模是：

对于 $t=1$ 的情况，为了尽可能减小 KSK 规模，最优的选取是 κ = { N } \kappa=\{\sqrt N\} κ={N ​}，此时只需要 $2\sqrt{N}$ 的存储开销，计算复杂度略微增长。对于一般的 $t\ge 2$，设置等比数列 $k_i=K^{1-i/(t+1)}$，那么存储开销是 $(t+1)\cdot K^{1/(t+1)}$，计算开销 $\le 3K+1$ 也不会变得很大。

为了实现 $N\ge N_{BTS}$ 的环打包，可以将 LWE 密文分成 $N_{BTS}/N_{KS}$ 组，每一组都并行执行 BaseHERMES 获得维度 $N_{KS}$ 的 RLWE 密文，最后再 Ring-switch 合成单个维度 $N_{BTS}$ 的 RLWE 密文。最后，执行 HalfBTS 提升模数，完成打包运算。

Implementation

[BCK+23] 在 HEaaN 实现了 HERMES 环打包算法。使用 $t=1$ 时效率依旧很高，并且此时的 KSK 就足够小了，BTS 密钥占据了主要的存储开销（667 MB）

它和 Pegasus 的对比：

吞吐率提高了 27-41 倍，计算延迟减小了 1.7-5.1 倍。

HHE

利用 HERMES 可以直接使用 LWE 去加密浮点数，不需要像 RtF Framework 那样使用 BGV/BFV 作为 SE 解密的桥梁。利用 [CDK+21] 的 (M)LWE-based SE，使用 XOF 和 seed 生成 $a_i\in {\mathbb{Z}}_q^K$，细粒度地加密 $b_i=⟨a_i,s⟩+m_i\in {\mathbb{Z}}_q$，并使用 ModDown 尽可能降低 $q$ 的大小。服务器将它们按照功能需要打包成 RLWE 密文。

它和 HERA 以及 Rubato 对比，服务端的解密速度快，解密精度更高，但是密文扩展因子略大。但是客户端的加密效率呢？MLWE-based SE 需要大量的 XOF 运算，这应该是很慢的。