Abstract
本文提出了可用于复数的同态加密方案。本文提出了一个用于管理明文大小的RS操作，该操作可以将密文转换到更小的模数上，本质上实现的是对底层明文的舍入操作。该方案的主要思想是将噪声放在有效位后。该噪声初始是为了安全性添加的，但在方案中被认为是近似计算期间所必然发生的误差的一部分。因此本方案最后输出的结果是一个近似值，但是可以预定义精度。
本文也为基于RLWE的结构提出了一种新的批处理技术。明文多项式是特征为0的分圆环中的元素，可以通过复数canonical embedding映射将该明文多项式映射为复数向量，该映射是环同构。
本方案还可以用于评估超越函数，比如乘法逆函数，指数函数，逻辑回归函数以及离散傅里叶变换。
1. 预备知识
1.1 The Cyclotomic Ring and Canonical Embedding
(1) 分圆多项式
给定一个正整数 M M M,设 Φ M ( X ) \Phi_M(X) ΦM(X)是第M个分圆多项式，则其次数为 N = ϕ ( M ) N=\phi(M) N=ϕ(M)。
已知分圆多项式 Φ M ( X ) \Phi_M(X) ΦM(X)的单位原根是 ξ = e 2 π i / M \xi=e^{2\pi i/M} ξ=e2πi/M，其共有N个根分别为 { ξ 1 , ξ 3 , . . . , ξ 2 N − 1 } \{\xi^1,\xi^3,...,\xi^{2N-1}\} {ξ1,ξ3,...,ξ2N−1}。
给出乘法群 Z M ∗ = { x ∈ Z M : g c d ( x , M ) = 1 } \mathbb{Z}_M^*=\{x\in\mathbb{Z}_M : gcd(x,M)=1\} ZM∗={x∈ZM:gcd(x,M)=1}，由于 M M M是2的幂，所以我们可以看到这里的乘法群实际上是 Z M ∗ = { 1 , 3 , 5 , . . . , M − 1 } \mathbb{Z}_M^*=\{1,3,5,...,M-1\} ZM∗={1,3,5,...,M−1}。
(2) 分圆环
设 R = Z [ X ] / Φ M ( X ) R=\mathbb{Z}[X]/\Phi_M(X) R=Z[X]/ΦM(X)是数域 Q [ X ] / Φ M ( X ) \mathbb{Q}[X]/\Phi_M(X) Q[X]/ΦM(X)上的整数环。设 R q = R / q R R_q=R/qR Rq=R/qR是环 R R R模整数 q q q得到的商环。
设 S = R [ X ] / Φ M ( X ) S=\mathbb{R}[X]/\Phi_M(X) S=R[X]/ΦM(X)是实数环，环 S S S中的任意元素都是一个实数多项式，可以将其表示为 a ( X ) = ∑ j = 0 N − 1 a j X j a(X)=\sum_{j=0}^{N-1}a_jX^j a(X)=∑j=0N−1ajXj，可以看到 a ( X ) a(X) a(X)的次数是小于 N N N的，也可将其表示为系数向量 ( a 0 , a 1 , . . . a N − 1 ) ∈ R N (a_0,a_1,...a_{N-1})\in\mathbb{R}^N (a0,a1,...aN−1)∈RN。我们定义元素 a a a的相关范数为 ∣ ∣ a ∣ ∣ ∞ ||a||_\infty ∣∣a∣∣∞和 ∣ ∣ a ∣ ∣ 1 ||a||_1 ∣∣a∣∣1。
(3) Canonical Embedding
现在定义有复数多项式环 C [ X ] / Φ M ( X ) \mathbb{C}[X]/\Phi_M(X) C[X]/ΦM(X)和复数向量空间 C N \mathbb{C}^N CN上的canonical embedding:
Canonical Embedding :
σ
:
C
[
X
]
/
Φ
M
(
X
)
→
C
N
\sigma:\mathbb{C}[X]/\Phi_M(X)\rightarrow\mathbb{C}^N
σ:C[X]/ΦM(X)→CN
设
a
∈
C
[
X
]
/
Φ
M
(
X
)
a\in \mathbb{C}[X]/\Phi_M(X)
a∈C[X]/ΦM(X)，则有
σ
(
a
)
=
a
(
ξ
j
)
j
∈
Z
M
∗
=
(
a
(
ξ
)
,
a
(
ξ
3
)
,
.
.
.
,
a
(
ξ
2
N
−
1
)
)
=
(
z
1
,
z
2
,
.
.
.
,
z
N
)
∈
C
N
\sigma(a)=a(\xi^j)_{j\in\mathbb{Z}_M^*}=(a(\xi),a(\xi^3),...,a(\xi^{2N-1}))=(z_1,z_2,...,z_N)\in\mathbb{C}^N
σ(a)=a(ξj)j∈ZM∗=(a(ξ),a(ξ3),...,a(ξ2N−1))=(z1,z2,...,zN)∈CN
将上式分解为线性代数形式有:
[
1
ξ
1
ξ
2
⋯
ξ
N
−
1
1
(
ξ
3
)
1
(
ξ
3
)
2
⋯
(
ξ
3
)
N
−
1
1
(
ξ
5
)
1
(
ξ
5
)
2
⋯
(
ξ
5
)
N
−
1
⋮
⋮
⋮
⋱
⋮
1
(
ξ
2
N
−
1
)
1
(
ξ
2
N
−
1
)
2
⋯
(
ξ
2
N
−
1
)
N
−
1
]
[
a
0
a
1
a
2
⋮
a
N
−
1
]
=
[
z
1
z
2
z
3
⋮
z
N
]
\left[ \begin{matrix} 1 & \xi^1 & \xi^2 & \cdots & \xi^{N-1} \\ 1 & (\xi^3)^1 & (\xi^3)^2 & \cdots & (\xi^3)^{N-1} \\ 1 & (\xi^5)^1 & (\xi^5)^2 & \cdots & (\xi^5)^{N-1} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & (\xi^{2N-1})^1 & (\xi^{2N-1})^2 & \cdots & (\xi^{2N-1})^{N-1} \\ \end{matrix} \right] \left[ \begin{matrix} a_0 \\ a_1 \\ a_2 \\ \vdots \\ a_{N-1}\\ \end{matrix} \right]= \left[ \begin{matrix} z_1 \\ z_2 \\ z_3 \\ \vdots \\ z_{N}\\ \end{matrix} \right]
111⋮1ξ1(ξ3)1(ξ5)1⋮(ξ2N−1)1ξ2(ξ3)2(ξ5)2⋮(ξ2N−1)2⋯⋯⋯⋱⋯ξN−1(ξ3)N−1(ξ5)N−1⋮(ξ2N−1)N−1
a0a1a2⋮aN−1
=
z1z2z3⋮zN
现在定义实数多项式环 S S S和复数向量空间 C N \mathbb{C}^{N} CN上的canonical embedding:
Canonical Embedding:
σ
:
R
[
X
]
/
Φ
M
(
X
)
→
C
N
\sigma:\mathbb{R}[X]/\Phi_M(X)\rightarrow\mathbb{C}^{N}
σ:R[X]/ΦM(X)→CN
σ ( a ) = a ( ξ j ) j ∈ Z M ∗ = ( a ( ξ ) , a ( ξ 3 ) , . . . , a ( ξ 2 N − 1 ) ) = ( z 1 , z 2 , . . . , z N ) ∈ C N \sigma(a)=a(\xi^j)_{j\in\mathbb{Z}_M^*}=(a(\xi),a(\xi^3),...,a(\xi^{2N-1}))=(z_1,z_2,...,z_N)\in\mathbb{C}^N σ(a)=a(ξj)j∈ZM∗=(a(ξ),a(ξ3),...,a(ξ2N−1))=(z1,z2,...,zN)∈CN
由于
a
(
X
)
a(X)
a(X)现在是实数多项式，而
Φ
M
(
X
)
\Phi_M(X)
ΦM(X)的N个根有如下关系:
ξ
j
=
ξ
−
j
‾
=
ξ
2
N
−
j
‾
\xi^j=\overline{\xi^{-j}}=\overline{\xi^{2N-j}}
ξj=ξ−j=ξ2N−j
所以此时Canonical Embedding必有如下关系:
a
(
ξ
j
)
=
a
(
ξ
−
j
‾
)
=
a
(
ξ
2
N
−
j
‾
)
a(\xi^j)=a(\overline{\xi^-j})=a(\overline{\xi^{2N-j}})
a(ξj)=a(ξ−j)=a(ξ2N−j)
实际上，这里就可以认为前
N
/
2
N/2
N/2个元素(由前向后)和后
N
/
2
N/2
N/2个元素(由后向前 )提供的信息是一样的。
故我们可以重新定义这个Canonical Embedding如下:
σ
:
R
[
X
]
/
Φ
M
(
X
)
→
C
N
/
2
\sigma:\mathbb{R}[X]/\Phi_M(X)\rightarrow\mathbb{C}^{N/2}
σ:R[X]/ΦM(X)→CN/2
2. Homomorphic Encryption for Approximate Arithmetic
2.1 CKKS的解密结构
本方案的明文是一个属于特征为0的多形式环域中的多项式，为了安全性它会接受一个误差，在解密时并不会移除这个误差，实际上这正是CKKS最重要的思想，包括后续的自举等等算法，均由于接受了这个误差，使得算法设计变的非常简单。
<
c
t
,
s
k
>
=
m
+
e
<ct,sk>=m+e
<ct,sk>=m+e
2.2 Plaintext Encoding for Packing
HE中的批处理技术允许同时将多个消息加密到同一密文中，并以SIMD方式进行平行计算。下面展示CKKS如何将一个消息向量加密到单一明文多项式中。
给定Canonical Embedding :
σ
:
R
[
X
]
/
Φ
M
(
X
)
→
C
N
\sigma:\mathbb{R}[X]/\Phi_M(X)\rightarrow\mathbb{C}^{N}
σ:R[X]/ΦM(X)→CN
或
σ
:
R
[
X
]
/
Φ
M
(
X
)
→
C
N
/
2
\sigma:\mathbb{R}[X]/\Phi_M(X)\rightarrow\mathbb{C}^{N/2}
σ:R[X]/ΦM(X)→CN/2
将其表达为线性方程组的形式:
[
1
ξ
1
ξ
2
⋯
ξ
N
−
1
1
(
ξ
3
)
1
(
ξ
3
)
2
⋯
(
ξ
3
)
N
−
1
1
(
ξ
5
)
1
(
ξ
5
)
2
⋯
(
ξ
5
)
N
−
1
⋮
⋮
⋮
⋱
⋮
1
(
ξ
2
N
−
1
)
1
(
ξ
2
N
−
1
)
2
⋯
(
ξ
2
N
−
1
)
N
−
1
]
[
a
0
a
1
a
2
⋮
a
N
−
1
]
=
[
z
1
z
2
z
3
⋮
z
N
]
\left[ \begin{matrix} 1 & \xi^1 & \xi^2 & \cdots & \xi^{N-1} \\ 1 & (\xi^3)^1 & (\xi^3)^2 & \cdots & (\xi^3)^{N-1} \\ 1 & (\xi^5)^1 & (\xi^5)^2 & \cdots & (\xi^5)^{N-1} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & (\xi^{2N-1})^1 & (\xi^{2N-1})^2 & \cdots & (\xi^{2N-1})^{N-1} \\ \end{matrix} \right] \left[ \begin{matrix} a_0 \\ a_1 \\ a_2 \\ \vdots \\ a_{N-1}\\ \end{matrix} \right]= \left[ \begin{matrix} z_1 \\ z_2 \\ z_3 \\ \vdots \\ z_{N}\\ \end{matrix} \right]
111⋮1ξ1(ξ3)1(ξ5)1⋮(ξ2N−1)1ξ2(ξ3)2(ξ5)2⋮(ξ2N−1)2⋯⋯⋯⋱⋯ξN−1(ξ3)N−1(ξ5)N−1⋮(ξ2N−1)N−1
a0a1a2⋮aN−1
=
z1z2z3⋮zN
在这里可以看到我们得到了一个将多项式映射为复数消息向量的方式:
A
⋅
a
=
z
A·a=z
A⋅a=z
由此我们也可以得到一个将多项式映射到复数消息向量中具体某个值的方式:
z
i
=
a
(
ξ
2
i
−
1
)
=
[
1
(
ξ
2
i
−
1
)
1
(
ξ
2
i
−
1
)
2
⋯
(
ξ
2
i
−
1
)
N
−
1
]
[
a
0
a
1
a
2
⋮
a
N
−
1
]
z_i=a(\xi^{2i-1})=\left[ \begin{matrix} 1 & (\xi^{2i-1})^1 & (\xi^{2i-1})^2 & \cdots & (\xi^{2i-1})^{N-1} \\ \end{matrix} \right] \left[ \begin{matrix} a_0 \\ a_1 \\ a_2 \\ \vdots \\ a_{N-1}\\ \end{matrix} \right]
zi=a(ξ2i−1)=[1(ξ2i−1)1(ξ2i−1)2⋯(ξ2i−1)N−1]
a0a1a2⋮aN−1
但是我们知道实际上
z
z
z 向量中后一半元素提供的信息是重复的，而且A矩阵中前
N
/
2
N/2
N/2行和后
N
/
2
N/2
N/2是共轭的，所以我们可以将矩阵
A
A
A分解为以下两个矩阵:
U
=
[
1
ξ
1
ξ
2
⋯
ξ
N
−
1
1
(
ξ
3
)
1
(
ξ
3
)
2
⋯
(
ξ
3
)
N
−
1
1
(
ξ
5
)
1
(
ξ
5
)
2
⋯
(
ξ
5
)
N
−
1
⋮
⋮
⋮
⋱
⋮
1
(
ξ
N
−
1
)
1
(
ξ
N
−
1
)
2
⋯
(
ξ
N
−
1
)
N
−
1
]
U=\left[ \begin{matrix} 1 & \xi^1 & \xi^2 & \cdots & \xi^{N-1} \\ 1 & (\xi^3)^1 & (\xi^3)^2 & \cdots & (\xi^3)^{N-1} \\ 1 & (\xi^5)^1 & (\xi^5)^2 & \cdots & (\xi^5)^{N-1} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & (\xi^{N-1})^1 & (\xi^{N-1})^2 & \cdots & (\xi^{N-1})^{N-1} \\ \end{matrix} \right]
U=
111⋮1ξ1(ξ3)1(ξ5)1⋮(ξN−1)1ξ2(ξ3)2(ξ5)2⋮(ξN−1)2⋯⋯⋯⋱⋯ξN−1(ξ3)N−1(ξ5)N−1⋮(ξN−1)N−1
和
U
‾
\overline{U}
U
将
z
z
z向量分解为以下两个子向量:
z
′
=
[
z
1
,
z
2
,
.
.
.
,
z
N
/
2
]
z'=[z_1,z_2,...,z_{N/2}]
z′=[z1,z2,...,zN/2]
和
z
′
‾
\overline{z'}
z′
则我们现在得到一个新的将多项式映射得到复数消息向量的方式:
U
⋅
a
=
z
′
U·a=z'
U⋅a=z′
U ‾ ⋅ a = z ′ ‾ \overline{U}·a=\overline{z'} U⋅a=z′
(1) 现在可以定义由 N / 2 N/2 N/2维的消息向量 z z z到多项式 a ∈ R / Φ M ( X ) a\in \mathbb{R}/\Phi_M(X) a∈R/ΦM(X)的编码方法:
给定一个
N
/
2
N/2
N/2维的消息向量
z
′
=
[
z
1
,
z
2
,
.
.
.
,
z
N
/
2
]
z'=[z_1,z_2,...,z_{N/2}]
z′=[z1,z2,...,zN/2]，我们首先需要对其扩展为
N
N
N维的消息向量
z
=
[
z
′
,
z
′
‾
]
z=[z',\overline{z'}]
z=[z′,z′]。这里定义这个扩展的操作为
π
−
1
\pi^{-1}
π−1，即:
π
−
1
:
z
′
→
[
z
′
,
z
′
′
]
\pi^{-1}:z'\rightarrow[z',z'']
π−1:z′→[z′,z′′]
然后我们可以直接进行编码:
a
=
A
−
1
⋅
z
a=A^{-1}·z
a=A−1⋅z
或考虑A形式矩阵的一个性质:
A
−
1
=
A
‾
T
A^{-1}=\overline{A}^T
A−1=AT
编码算法又可以写为:
a
=
(
U
‾
T
⋅
z
′
+
U
T
⋅
z
′
‾
)
a=(\overline{U}^T·z'+U^T·\overline{z'})
a=(UT⋅z′+UT⋅z′)
我们定义这个编码的操作为
σ
−
1
\sigma^{-1}
σ−1，即:
σ
−
1
:
[
z
′
,
z
′
′
]
→
a
\sigma^{-1}:[z',z'']\rightarrow a
σ−1:[z′,z′′]→a
需要注意的是，这里
a
∈
S
=
R
/
Φ
M
(
X
)
a\in S=\mathbb{R}/\Phi_M(X)
a∈S=R/ΦM(X)，是一个实数多项式。
(2) "完整"的CKKS编码算法 （这里打引号，是因为这个用于编码解码的矩阵的行排列还需要变化，具体看旋转部分）
上述步骤，将 N / 2 N/2 N/2维的复数向量编码为一个实数多项式，而CKKS操作的所有元素都是整数多项式(之所以是整数多项式，是因为整数有很多好的性质)，因此我们需要对此时得到的实数多项式进行转换，转换方法如下:
给定一个缩放因子
Δ
\Delta
Δ，然后在系数级别执行下式:
m
(
x
)
=
⌊
Δ
⋅
a
(
x
)
⌉
m(x)=\lfloor\Delta·a(x)\rceil
m(x)=⌊Δ⋅a(x)⌉
可以看到，这里是存在近似的，也就是引入了近似误差。换句话说，当我们给定足够大的
Δ
\Delta
Δ时，这里引入的近似误差就会足够小。
现在我们得到了整数多项式:
m
(
X
)
∈
R
=
Z
/
Φ
M
(
X
)
m(X)\in R=\mathbb{Z}/\Phi_M(X)
m(X)∈R=Z/ΦM(X)
这里的
m
(
X
)
m(X)
m(X)即编码得到的结果，称其为明文多项式。
(3) 现在定义CKKS的解码算法
给定一个明文多项式
m
∈
R
m\in R
m∈R，首先将缩放因子
Δ
\Delta
Δ去除，即:
a
(
X
)
=
m
(
X
)
/
Δ
a(X)=m(X)/\Delta
a(X)=m(X)/Δ
然后直接利用上述Canonical Embedding进行计算:
σ
:
R
[
X
]
/
Φ
M
(
X
)
→
C
N
\sigma:\mathbb{R}[X]/\Phi_M(X)\rightarrow\mathbb{C}^{N}
σ:R[X]/ΦM(X)→CN
即:
σ
(
a
)
=
A
⋅
a
=
z
=
[
z
′
,
z
′
′
]
\sigma(a)=A·a=z=[z',z'']
σ(a)=A⋅a=z=[z′,z′′]
然后将前半部分元素投影出来，记此操作为
π
\pi
π，即:
π
:
[
z
′
,
z
′
′
]
→
z
′
\pi:[z',z'']\rightarrow z'
π:[z′,z′′]→z′
由此，得到解码后的消息向量
z
′
z'
z′。
注意: 实际上CKKS原论文乘以缩放因子 Δ \Delta Δ的步骤，执行在操作 σ − 1 \sigma^{-1} σ−1之前，但是这里两种方法实现的效果是一样的。
另外由于考虑到了CKKS的旋转操作，实际上这里编码和解码用到的矩阵A还并不是最终版本的矩阵，但是这里为了方便理解，所以可以先这么写。
2.3 CKKS的具体构造
首先选择分圆多项式的次数
M
M
M为2的幂，则
N
=
ϕ
(
M
)
N=\phi(M)
N=ϕ(M)，故:
Φ
M
(
X
)
=
X
N
+
1
\Phi_M(X)=X^N+1
ΦM(X)=XN+1
选择分圆环:
R
=
Z
[
X
]
/
(
X
N
+
1
)
R=\mathbb{Z}[X]/(X^N+1)
R=Z[X]/(XN+1)
这里指出CKKS方案的所有元素都是操作在分圆环
R
R
R上的。
选择缩放因子 Δ = p > 0 \Delta=p>0 Δ=p>0，选择模 q 0 q_0 q0，设置 q l = p l ⋅ q 0 q_l=p^l·q_0 ql=pl⋅q0，其中 0 < l ≤ L 0<l\leq L 0<l≤L。
选择一个辅助模数 P P P，需要保证足够大，以尽可能地减少KS操作中引入的误差。
K e y G e n ( 1 λ ) KeyGen(1^\lambda) KeyGen(1λ):
均匀采样 s ← χ s k s\leftarrow \chi_{sk} s←χsk， a ← R q L a \leftarrow R_{q_L} a←RqL， e ← χ e r r e \leftarrow \chi_{err} e←χerr， a ′ ← R P ⋅ q L a'\leftarrow R_{P·q_L} a′←RP⋅qL， e ′ ← χ e r r e'\leftarrow \chi_{err} e′←χerr。
生成
s
k
sk
sk和
p
k
pk
pk:
s
k
←
(
1
,
s
)
p
k
←
(
b
,
a
)
∈
R
q
L
2
,
其中
b
=
−
a
s
+
e
sk \leftarrow (1, s) \\ pk \leftarrow (b,a)\in R_{q_L}^2, 其中b=-as+e
sk←(1,s)pk←(b,a)∈RqL2,其中b=−as+e
生成
e
v
k
evk
evk:
e
v
k
←
(
b
′
,
a
′
)
∈
R
P
⋅
q
L
2
,
其中
b
′
=
−
a
′
s
+
e
′
+
P
⋅
s
′
evk\leftarrow (b',a')\in R_{P·q_L}^2,其中b'=-a's+e'+P·s'
evk←(b′,a′)∈RP⋅qL2,其中b′=−a′s+e′+P⋅s′
实际上计算公钥
e
v
k
evk
evk包含以下三类:
重现性化计算公钥:
r
l
k
←
(
b
′
,
a
′
)
∈
R
P
⋅
q
L
2
,
其中
b
′
=
−
a
′
s
+
e
′
+
P
⋅
s
2
rlk\leftarrow (b',a')\in R_{P·q_L}^2,其中b'=-a's+e'+P·s^2
rlk←(b′,a′)∈RP⋅qL2,其中b′=−a′s+e′+P⋅s2
伽罗瓦计算公钥:
g
a
l
k
e
y
←
(
b
′
,
a
′
)
∈
R
P
⋅
q
L
2
,
其中
b
′
=
−
a
′
s
+
e
′
+
P
⋅
s
(
X
r
o
t
)
galkey\leftarrow (b',a')\in R_{P·q_L}^2,其中b'=-a's+e'+P·s(X^{rot})
galkey←(b′,a′)∈RP⋅qL2,其中b′=−a′s+e′+P⋅s(Xrot)
共轭计算公钥:
c
o
n
j
k
e
y
←
(
b
′
,
a
′
)
∈
R
P
⋅
q
L
2
,
其中
b
′
=
−
a
′
s
+
e
′
+
P
⋅
s
(
X
c
u
n
j
)
conjkey\leftarrow (b',a')\in R_{P·q_L}^2,其中b'=-a's+e'+P·s(X^{cunj})
conjkey←(b′,a′)∈RP⋅qL2,其中b′=−a′s+e′+P⋅s(Xcunj)
关于
g
a
l
k
e
y
galkey
galkey和
c
o
n
j
k
e
y
conjkey
conjkey的详细构造，在之后的旋转部分进行详细介绍。
E c d ( z ; Δ ) Ecd(z;\Delta) Ecd(z;Δ)
D c d ( m ; Δ ) Dcd(m;\Delta) Dcd(m;Δ)
E n c p k ( m ) Enc_pk(m) Encpk(m):
均匀采样 v ← Z O ( 0.5 ) v\leftarrow ZO(0.5) v←ZO(0.5), e 0 , e 1 ← χ e r r e_0,e_1 \leftarrow \chi_{err} e0,e1←χerr
生成密文:
c
t
=
v
⋅
p
k
+
(
m
+
e
0
,
e
1
)
=
(
−
a
s
v
+
e
v
+
m
+
e
0
,
a
v
+
e
1
)
ct=v·pk+(m+e_0,e_1)=(-asv+ev+m+e_0,av+e_1)
ct=v⋅pk+(m+e0,e1)=(−asv+ev+m+e0,av+e1)
D e c p k ( m ) Dec_pk(m) Decpk(m):
给定一个 l l l级别的密文 c t = ( c 0 , c 1 ) ∈ R q l 2 ct=(c_0,c_1)\in R_{q_l}^2 ct=(c0,c1)∈Rql2。
解密:
<
c
t
,
s
k
>
=
c
0
+
c
1
⋅
s
=
m
+
e
<ct,sk>=c_0+c_1·s=m+e
<ct,sk>=c0+c1⋅s=m+e
A d d ( c t 1 , c t 2 ) Add(ct_1,ct_2) Add(ct1,ct2)
M u l t r l k ( c t 1 , c t 2 ) Mult_{rlk}(ct_1,ct_2) Multrlk(ct1,ct2)
R S ( c t ) RS(ct) RS(ct)
3.KS算法分析
对于KS算法，后续有需要优化，所以这应该作为一个重点来记录。下边介绍的重现性化操作，旋转操作以及共轭操作均是KS算法的实例。
3.1 重现性化操作
给定两个 l l l 级别的密文 c t 1 = ( b 1 , a 1 ) ct_1=(b_1,a_1) ct1=(b1,a1)和 c t 2 = ( b 2 , a 2 ) ct_2=(b_2,a_2) ct2=(b2,a2)。
(1) Tensor操作:
(
d
0
,
d
1
,
d
2
)
←
(
b
1
b
2
,
a
1
b
2
+
a
2
b
1
,
a
1
a
2
)
(d_0,d_1,d_2)\leftarrow (b_1b_2,a_1b_2+a_2b_1,a_1a_2)
(d0,d1,d2)←(b1b2,a1b2+a2b1,a1a2)
这里需要从解密的角度来思考:
d
0
+
d
1
⋅
s
+
d
2
⋅
s
2
=
(
m
1
+
e
1
)
⋅
(
m
2
+
e
2
)
d_0+d_1·s+d_2·s^2=(m_1+e_1)·(m_2+e_2)
d0+d1⋅s+d2⋅s2=(m1+e1)⋅(m2+e2)
可以看到如果我们有密钥
s
s
s和
s
2
s^2
s2，则现在即可以进行解密，但是我们需要只用
s
s
s就能解密。
(2) Relinearization操作:
还记得我们上边生成的重线性化密钥为:
r
l
k
←
(
b
′
,
a
′
)
∈
R
P
⋅
q
L
2
,
其中
b
′
=
−
a
′
s
+
e
′
+
P
⋅
s
2
rlk\leftarrow (b',a')\in R_{P·q_L}^2,其中b'=-a's+e'+P·s^2
rlk←(b′,a′)∈RP⋅qL2,其中b′=−a′s+e′+P⋅s2
现在执行重现性化中的KS算法:
c
t
m
u
l
t
←
(
d
0
,
d
1
)
+
⌊
P
−
1
⋅
d
2
⋅
r
l
k
⌉
(
m
o
d
q
l
)
ct_{mult}\leftarrow (d_0,d_1)+\lfloor P^{-1}·d_2·rlk\rceil \ \ \ \ \ \ \ \ \ \ \ \ \ (mod \ \ \ \ \ q_l)
ctmult←(d0,d1)+⌊P−1⋅d2⋅rlk⌉ (mod ql)
查看一下
c
t
m
u
l
t
ct_{mult}
ctmult的具体内容:
c
t
m
u
l
t
=
(
c
t
0
,
c
t
1
)
=
(
d
0
+
⌊
−
P
−
1
⋅
d
2
⋅
a
′
⋅
s
+
P
−
1
⋅
d
2
⋅
e
′
+
d
2
⋅
s
2
⌉
,
d
1
+
⌊
P
−
1
⋅
d
2
⋅
a
′
)
⌉
)
ct_{mult}=(ct_0,ct_1)=\\(d_0+\lfloor-P^{-1}·d_2·a'·s+P^{-1}·d_2·e'+d_2·s^2\rceil,d_1+\lfloor P^{-1}·d_2·a')\rceil)
ctmult=(ct0,ct1)=(d0+⌊−P−1⋅d2⋅a′⋅s+P−1⋅d2⋅e′+d2⋅s2⌉,d1+⌊P−1⋅d2⋅a′)⌉)
虽然这里看似好像内部的元素进行各种乘法之后变的复杂了，但是究其本质，这仍然是
R
R
R中的元素而已。
可以看到此时可以单独使用密钥
s
s
s来进行解密:
c
t
0
+
c
t
1
⋅
s
=
d
0
+
⌊
−
P
−
1
⋅
d
2
⋅
a
′
⋅
s
+
P
−
1
⋅
d
2
⋅
e
′
+
d
2
⋅
s
2
⌉
+
(
d
1
+
⌊
P
−
1
⋅
d
2
⋅
a
′
)
⌉
)
⋅
s
=
d
0
+
d
1
⋅
s
+
⌊
−
P
−
1
⋅
d
2
⋅
a
′
⋅
s
+
P
−
1
⋅
d
2
⋅
e
′
+
d
2
⋅
s
2
+
P
−
1
⋅
d
2
⋅
a
′
⋅
s
⌉
=
d
0
+
d
1
⋅
s
+
⌊
d
2
⋅
s
2
+
P
−
1
⋅
d
2
⋅
e
′
⌉
=
d
0
+
d
1
+
d
2
⋅
s
2
+
e
\begin{aligned} ct_0+ct_1·s = &d_0+\lfloor-P^{-1}·d_2·a'·s+P^{-1}·d_2·e'+d_2·s^2\rceil+(d_1+\lfloor P^{-1}·d_2·a')\rceil)·s \\ =&d_0+d_1·s+\lfloor-P^{-1}·d_2·a'·s+P^{-1}·d_2·e'+d_2·s^2+P^{-1}·d_2·a'·s\rceil \\ =&d_0+d_1·s+\lfloor d_2·s^2 + P^{-1}·d_2·e'\rceil \\ =&d_0+d_1+d_2·s^2+e \end{aligned}
ct0+ct1⋅s====d0+⌊−P−1⋅d2⋅a′⋅s+P−1⋅d2⋅e′+d2⋅s2⌉+(d1+⌊P−1⋅d2⋅a′)⌉)⋅sd0+d1⋅s+⌊−P−1⋅d2⋅a′⋅s+P−1⋅d2⋅e′+d2⋅s2+P−1⋅d2⋅a′⋅s⌉d0+d1⋅s+⌊d2⋅s2+P−1⋅d2⋅e′⌉d0+d1+d2⋅s2+e
只不过引入了少许误差
e
=
⌊
P
−
1
⋅
d
2
⋅
e
′
⌉
e=\lfloor P^{-1}·d_2·e'\rceil
e=⌊P−1⋅d2⋅e′⌉，该误差足够小。
3.2 旋转操作
(1)考虑旋转操作之前，我们需要再一次考虑CKKS的解码操作，如下所示:
给定Canonical Embedding :
σ
:
Z
[
X
]
/
Φ
M
(
X
)
→
C
N
\sigma:\mathbb{Z}[X]/\Phi_M(X)\rightarrow\mathbb{C}^{N}
σ:Z[X]/ΦM(X)→CN
将其表达为线性方程组的形式:
[ 1 ξ 1 ξ 2 ⋯ ξ N − 1 1 ( ξ 3 ) 1 ( ξ 3 ) 2 ⋯ ( ξ 3 ) N − 1 1 ( ξ 5 ) 1 ( ξ 5 ) 2 ⋯ ( ξ 5 ) N − 1 ⋮ ⋮ ⋮ ⋱ ⋮ 1 ( ξ 2 N − 1 ) 1 ( ξ 2 N − 1 ) 2 ⋯ ( ξ 2 N − 1 ) N − 1 ] [ a 0 a 1 a 2 ⋮ a N − 1 ] = [ z 1 z 2 z 3 ⋮ z N ] \left[ \begin{matrix} 1 & \xi^1 & \xi^2 & \cdots & \xi^{N-1} \\ 1 & (\xi^3)^1 & (\xi^3)^2 & \cdots & (\xi^3)^{N-1} \\ 1 & (\xi^5)^1 & (\xi^5)^2 & \cdots & (\xi^5)^{N-1} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & (\xi^{2N-1})^1 & (\xi^{2N-1})^2 & \cdots & (\xi^{2N-1})^{N-1} \\ \end{matrix} \right] \left[ \begin{matrix} a_0 \\ a_1 \\ a_2 \\ \vdots \\ a_{N-1}\\ \end{matrix} \right]= \left[ \begin{matrix} z_1 \\ z_2 \\ z_3 \\ \vdots \\ z_{N}\\ \end{matrix} \right] 111⋮1ξ1(ξ3)1(ξ5)1⋮(ξ2N−1)1ξ2(ξ3)2(ξ5)2⋮(ξ2N−1)2⋯⋯⋯⋱⋯ξN−1(ξ3)N−1(ξ5)N−1⋮(ξ2N−1)N−1 a0a1a2⋮aN−1 = z1z2z3⋮zN
由此我们可以得到一个将多项式映射到复数消息向量中具体某个值的方式:
z i = a ( ξ 2 i − 1 ) = [ 1 ( ξ 2 i − 1 ) 1 ( ξ 2 i − 1 ) 2 ⋯ ( ξ 2 i − 1 ) N − 1 ] [ a 0 a 1 a 2 ⋮ a N − 1 ] z_i=a(\xi^{2i-1})=\left[ \begin{matrix} 1 & (\xi^{2i-1})^1 & (\xi^{2i-1})^2 & \cdots & (\xi^{2i-1})^{N-1} \\ \end{matrix} \right] \left[ \begin{matrix} a_0 \\ a_1 \\ a_2 \\ \vdots \\ a_{N-1}\\ \end{matrix} \right] zi=a(ξ2i−1)=[1(ξ2i−1)1(ξ2i−1)2⋯(ξ2i−1)N−1] a0a1a2⋮aN−1
实际上，由于复数消息向量的后半部分不提供信息，因此我们可以简化这个解码操作为:
σ : Z [ X ] / Φ M ( X ) → C N / 2 \sigma:\mathbb{Z}[X]/\Phi_M(X)\rightarrow\mathbb{C}^{N/2} σ:Z[X]/ΦM(X)→CN/2
新的线性方程组的形式为:
[ 1 ξ 1 ξ 2 ⋯ ξ N − 1 1 ( ξ 3 ) 1 ( ξ 3 ) 2 ⋯ ( ξ 3 ) N − 1 1 ( ξ 5 ) 1 ( ξ 5 ) 2 ⋯ ( ξ 5 ) N − 1 ⋮ ⋮ ⋮ ⋱ ⋮ 1 ( ξ N − 1 ) 1 ( ξ N − 1 ) 2 ⋯ ( ξ N − 1 ) N − 1 ] [ a 0 a 1 a 2 ⋮ a N − 1 ] = [ z 1 z 2 z 3 ⋮ z N / 2 ] \left[ \begin{matrix} 1 & \xi^1 & \xi^2 & \cdots & \xi^{N-1} \\ 1 & (\xi^3)^1 & (\xi^3)^2 & \cdots & (\xi^3)^{N-1} \\ 1 & (\xi^5)^1 & (\xi^5)^2 & \cdots & (\xi^5)^{N-1} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & (\xi^{N-1})^1 & (\xi^{N-1})^2 & \cdots & (\xi^{N-1})^{N-1} \\ \end{matrix} \right] \left[ \begin{matrix} a_0 \\ a_1 \\ a_2 \\ \vdots \\ a_{N-1}\\ \end{matrix} \right]= \left[ \begin{matrix} z_1 \\ z_2 \\ z_3 \\ \vdots \\ z_{N/2}\\ \end{matrix} \right] 111⋮1ξ1(ξ3)1(ξ5)1⋮(ξN−1)1ξ2(ξ3)2(ξ5)2⋮(ξN−1)2⋯⋯⋯⋱⋯ξN−1(ξ3)N−1(ξ5)N−1⋮(ξN−1)N−1 a0a1a2⋮aN−1 = z1z2z3⋮zN/2
现在我们左侧矩阵按行向上旋转1位，则移位后的解码线性方程组为；
[
1
(
ξ
3
)
1
(
ξ
3
)
2
⋯
(
ξ
3
)
N
−
1
1
(
ξ
5
)
1
(
ξ
5
)
2
⋯
(
ξ
5
)
N
−
1
⋮
⋮
⋮
⋱
⋮
1
(
ξ
N
−
1
)
1
(
ξ
N
−
1
)
2
⋯
(
ξ
N
−
1
)
N
−
1
1
ξ
1
ξ
2
⋯
ξ
N
−
1
]
[
a
0
a
1
a
2
⋮
a
N
−
1
]
=
[
z
2
z
3
⋮
z
N
/
2
z
1
]
\left[ \begin{matrix} 1 & (\xi^3)^1 & (\xi^3)^2 & \cdots & (\xi^3)^{N-1} \\ 1 & (\xi^5)^1 & (\xi^5)^2 & \cdots & (\xi^5)^{N-1} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & (\xi^{N-1})^1 & (\xi^{N-1})^2 & \cdots & (\xi^{N-1})^{N-1} \\ 1 & \xi^1 & \xi^2 & \cdots & \xi^{N-1} \\ \end{matrix} \right] \left[ \begin{matrix} a_0 \\ a_1 \\ a_2 \\ \vdots \\ a_{N-1}\\ \end{matrix} \right]= \left[ \begin{matrix} z_2 \\ z_3 \\ \vdots \\ z_{N/2}\\ z_1 \\ \end{matrix} \right]
11⋮11(ξ3)1(ξ5)1⋮(ξN−1)1ξ1(ξ3)2(ξ5)2⋮(ξN−1)2ξ2⋯⋯⋱⋯⋯(ξ3)N−1(ξ5)N−1⋮(ξN−1)N−1ξN−1
a0a1a2⋮aN−1
=
z2z3⋮zN/2z1
可以发现解码后的消息向量也进行了1位的旋转。
同理，如果我们将左侧矩阵按行向上旋转rot位，则解码后的消息向量也会向左旋转rot位置(这里是把消息向量横着考虑)。
但是实际操作中，我们需要保证左侧矩阵是不变化的，因此我们需要再次进行变化。
观察到，明文多项式为:
a
(
X
)
=
a
0
+
a
1
⋅
X
+
a
2
⋅
X
2
+
⋅
⋅
⋅
+
a
N
−
1
⋅
X
N
−
1
a(X)=a_0+a_1·X+a_2·X^2+···+a_{N-1}·X^{N-1}
a(X)=a0+a1⋅X+a2⋅X2+⋅⋅⋅+aN−1⋅XN−1
[ z 1 z 2 z 3 ⋮ z N / 2 ] = [ a ( ξ ) a ( ξ 3 ) a ( ξ 5 ) ⋮ a ( ξ N − 1 ) ] \left[ \begin{matrix} z_1 \\ z_2 \\ z_3 \\ \vdots \\ z_{N/2} \\ \end{matrix} \right]= \left[ \begin{matrix} a(\xi) \\ a(\xi^3)\\ a(\xi^5)\\ \vdots \\ a(\xi^{N-1})\\ \end{matrix} \right] z1z2z3⋮zN/2 = a(ξ)a(ξ3)a(ξ5)⋮a(ξN−1)
即，要解码得到 z 1 z_1 z1，只需要在 ξ \xi ξ上评估 a ( X ) a(X) a(X)
则 z 1 = a ( ξ ) = a 0 + a 1 ⋅ ξ + a 2 ⋅ ξ 2 + ⋅ ⋅ ⋅ + a N − 1 ⋅ ξ N − 1 z_1=a(\xi)=a_0+a_1·\xi+a_2·\xi^2+···+a_{N-1}·\xi^{N-1} z1=a(ξ)=a0+a1⋅ξ+a2⋅ξ2+⋅⋅⋅+aN−1⋅ξN−1。
现在将明文多项式 a ( X ) a(X) a(X)变化为 a ( X 3 ) = a 0 + a 1 ⋅ ( X 3 ) + a 2 ⋅ ( X 3 ) 2 + ⋅ ⋅ ⋅ + a N − 1 ⋅ ( X 3 ) N − 1 a(X^3)=a_0+a_1·(X^3)+a_2·(X^3)^2+···+a_{N-1}·(X^3)^{N-1} a(X3)=a0+a1⋅(X3)+a2⋅(X3)2+⋅⋅⋅+aN−1⋅(X3)N−1。
则我们同样在 ξ \xi ξ上评估多项式 a ( X 3 ) a(X^3) a(X3)，此时会发现，这和在 ξ 3 \xi^3 ξ3上评估多项式 a ( X ) a(X) a(X)具有同样的效果。
也就是说，如果我们令
b
(
X
)
=
a
(
X
3
)
b(X)=a(X^3)
b(X)=a(X3)，此时我们会得到:
[
z
2
z
3
⋮
z
N
/
2
z
1
]
=
[
b
(
ξ
)
b
(
ξ
3
)
b
(
ξ
5
)
⋮
b
(
ξ
N
−
1
)
]
=
[
1
(
ξ
3
)
1
(
ξ
3
)
2
⋯
(
ξ
3
)
N
−
1
1
(
ξ
5
)
1
(
ξ
5
)
2
⋯
(
ξ
5
)
N
−
1
⋮
⋮
⋮
⋱
⋮
1
(
ξ
N
−
1
)
1
(
ξ
N
−
1
)
2
⋯
(
ξ
N
−
1
)
N
−
1
1
ξ
1
ξ
2
⋯
ξ
N
−
1
]
[
b
0
b
1
b
2
⋮
b
N
−
1
]
\left[ \begin{matrix} z_2 \\ z_3 \\ \vdots \\ z_{N/2} \\ z_1 \\ \end{matrix} \right]= \left[ \begin{matrix} b(\xi) \\ b(\xi^3)\\ b(\xi^5)\\ \vdots \\ b(\xi^{N-1})\\ \end{matrix} \right]= \left[ \begin{matrix} 1 & (\xi^3)^1 & (\xi^3)^2 & \cdots & (\xi^3)^{N-1} \\ 1 & (\xi^5)^1 & (\xi^5)^2 & \cdots & (\xi^5)^{N-1} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & (\xi^{N-1})^1 & (\xi^{N-1})^2 & \cdots & (\xi^{N-1})^{N-1} \\ 1 & \xi^1 & \xi^2 & \cdots & \xi^{N-1} \\ \end{matrix} \right] \left[ \begin{matrix} b_0 \\ b_1 \\ b_2 \\ \vdots \\ b_{N-1}\\ \end{matrix} \right]
z2z3⋮zN/2z1
=
b(ξ)b(ξ3)b(ξ5)⋮b(ξN−1)
=
11⋮11(ξ3)1(ξ5)1⋮(ξN−1)1ξ1(ξ3)2(ξ5)2⋮(ξN−1)2ξ2⋯⋯⋱⋯⋯(ξ3)N−1(ξ5)N−1⋮(ξN−1)N−1ξN−1
b0b1b2⋮bN−1
此时发现，我们不需要改变解码矩阵，也可以对消息向量进行旋转。
现在我们正式定义一下这个新的旋转方式:
我们将消息向量 [ z 0 , z 1 , . . . , z N / 2 ] [z_0,z_1,...,z_{N/2}] [z0,z1,...,zN/2]编码为明文多项式 a ( X ) a(X) a(X)，且我们现在拥有一个解码矩阵U。
我们的解码操作为:
U
⋅
a
=
z
U·a=z
U⋅a=z
若我们将
a
(
X
)
a(X)
a(X)变化为
a
(
X
3
)
a(X^3)
a(X3)，则应用上步解码操作，我们会得到左旋转1位的消息向量
[
z
2
,
z
3
,
.
.
.
z
N
/
2
,
z
1
]
[z_2,z_3,...z_{N/2},z_1]
[z2,z3,...zN/2,z1].
若我们将 a ( X ) a(X) a(X)变化为 a ( X 5 ) a(X^5) a(X5)，则解码后，得到左旋2位的消息向量 [ z 3 , z 4 , . . . z N / 2 , z 1 , z 2 ] [z_3,z_4,...z_{N/2},z_1,z_2] [z3,z4,...zN/2,z1,z2]。
……
虽然这样也可以实现旋转，但是还是存在一种问题，那就是这里不定元 X X X的次数转变是复杂的，即不能找到一个同意的步骤来实现这种次数的转化。
所以需要考虑一种新的方法。
(2)考虑上边进行旋转所有可能的次数变化，发现它们都属于下边的集合:
Z
N
∗
=
{
1
,
3
,
5
,
.
.
.
,
N
−
1
}
m
o
d
N
\mathbb{Z}_N^* = \{1,3,5,...,N-1\}\ \ \ \ mod \ \ N
ZN∗={1,3,5,...,N−1} mod N
这里N是2的幂，则乘法群
Z
N
∗
\mathbb{Z}_N^*
ZN∗有一个生成元为5，即:
Z
N
∗
=
<
5
>
=
{
5
1
,
5
2
,
5
3
,
.
.
.
,
5
N
/
2
}
m
o
d
N
\mathbb{Z}_N^* =<5>=\{5^1,5^2,5^3,...,5^{N/2}\} \ \ \ \ \ mod \ \ \ \ N
ZN∗=<5>={51,52,53,...,5N/2} mod N
所以，现在我们考虑变换解码矩阵的形式，首先，引入一个新的符号:
ζ
i
=
ξ
5
i
\zeta_i=\xi^{5^i}
ζi=ξ5i
则解码矩阵
U
U
U可以重新表示为:
U
=
[
1
(
ζ
0
)
1
(
ζ
0
)
2
⋯
(
ζ
0
)
N
−
1
1
(
ζ
1
)
1
(
ζ
1
)
2
⋯
(
ζ
1
)
N
−
1
1
(
ζ
2
)
1
(
ζ
2
)
2
⋯
(
ζ
2
)
N
−
1
⋮
⋮
⋮
⋱
⋮
1
(
ζ
N
/
2
−
1
)
1
(
ζ
N
/
2
−
1
)
2
⋯
(
ζ
N
/
2
−
1
)
N
−
1
]
U=\left[ \begin{matrix} 1 & (\zeta_0)^1 & (\zeta_0)^2 & \cdots & (\zeta_0)^{N-1} \\ 1 & (\zeta_1)^1 & (\zeta_1)^2 & \cdots & (\zeta_1)^{N-1} \\ 1 & (\zeta_2)^1 & (\zeta_2)^2 & \cdots & (\zeta_2)^{N-1} \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & (\zeta_{N/2-1})^1 & (\zeta_{N/2-1})^2 & \cdots & (\zeta_{N/2-1})^{N-1} \\ \end{matrix} \right]
U=
111⋮1(ζ0)1(ζ1)1(ζ2)1⋮(ζN/2−1)1(ζ0)2(ζ1)2(ζ2)2⋮(ζN/2−1)2⋯⋯⋯⋱⋯(ζ0)N−1(ζ1)N−1(ζ2)N−1⋮(ζN/2−1)N−1
所以我们可以重新用这个矩阵进行上述的编码操作以及解码操作。
给定消息向量 z ′ = [ z 1 , z 2 , . . , z N / 2 ] z'=[z_1,z_2,..,z_{N/2}] z′=[z1,z2,..,zN/2]，和新的编码矩阵 U U U。
则编码结果为:
a
=
(
U
‾
T
⋅
z
′
+
U
T
⋅
z
′
‾
)
a=(\overline{U}^T·z'+U^T·\overline{z'})
a=(UT⋅z′+UT⋅z′)
解码结果为:
z
′
=
U
⋅
a
z'=U·a
z′=U⋅a
现在我们如果想实现旋转操作就会简单很多。
定义一个
a
u
t
o
m
o
r
p
h
i
s
m
automorphism
automorphism操作:
κ
k
:
m
(
X
)
→
m
(
X
5
k
)
\kappa_k : m(X)\rightarrow m(X^{5^k})
κk:m(X)→m(X5k)
则可以定义明文上的旋转算法：
如果我们需要将 z ′ z' z′向量左旋 k k k位:
我们只需要对其编码的明文多项式执行一个
a
u
t
o
m
o
r
p
h
i
s
m
automorphism
automorphism操作：
b
(
X
)
←
κ
k
(
a
(
X
)
)
=
a
(
X
5
k
)
b(X)\leftarrow \kappa_k(a(X))=a(X^{5^k})
b(X)←κk(a(X))=a(X5k)
现在对
b
(
X
)
b(X)
b(X)进行解码，则得到消息向量
z
′
z'
z′左旋k位的结果。
(3)完整的CKKS旋转算法
实际上在CKKS中对消息向量旋转是在秘态下计算的，假设我们需要执行左旋 k k k位的操作。
消息向量
z
′
z'
z′被编码得到明文多项式
a
(
X
)
a(X)
a(X)，然后对
a
(
X
)
a(X)
a(X)加密得到密文
c
t
=
(
c
0
(
X
)
,
c
1
(
X
)
)
ct=(c_0(X),c_1(X))
ct=(c0(X),c1(X))，
c
t
ct
ct的解密结构如下：
<
c
t
,
s
k
>
=
c
0
(
X
)
+
c
1
(
X
)
⋅
s
(
X
)
≈
a
(
X
)
<ct,sk> = c_0(X)+c_1(X)·s(X)\approx a(X)
<ct,sk>=c0(X)+c1(X)⋅s(X)≈a(X)
现在我们对密文
c
t
ct
ct执行
a
u
t
o
m
o
r
p
h
i
c
automorphic
automorphic操作:
c
t
∗
←
κ
k
(
c
t
)
=
(
c
0
(
X
5
k
)
,
c
1
(
X
5
k
)
)
ct^*\leftarrow \kappa_k (ct)=(c_0(X^{5^k}),c_1(X^{5^k}))
ct∗←κk(ct)=(c0(X5k),c1(X5k))
很明显，此时我们需要使用
s
k
∗
=
(
1
,
s
(
X
5
k
)
)
sk^*=(1,s(X^{5^k}))
sk∗=(1,s(X5k))这个新密钥来解密:
<
c
t
∗
,
s
k
∗
>
=
c
0
(
X
5
k
)
+
c
1
(
X
5
k
)
⋅
s
(
X
5
k
)
≈
a
(
X
5
k
)
<ct^*,sk^*> = c_0(X^{5^k})+c_1(X^{5^k})·s(X^{5^k})\approx a(X^{5^k})
<ct∗,sk∗>=c0(X5k)+c1(X5k)⋅s(X5k)≈a(X5k)
但是CKKS需要从始至终只使用原始密钥
s
k
sk
sk来解密
因此我们需要KS算法:
还记得之前生成的伽罗瓦计算公钥为:
g
a
l
k
e
y
←
(
b
′
,
a
′
)
∈
R
P
⋅
q
L
2
,
其中
b
′
=
−
a
′
s
+
e
′
+
P
⋅
s
(
X
r
o
t
)
galkey\leftarrow (b',a')\in R_{P·q_L}^2,其中b'=-a's+e'+P·s(X^{rot})
galkey←(b′,a′)∈RP⋅qL2,其中b′=−a′s+e′+P⋅s(Xrot)
现在我们具体定义一个可以执行左旋
k
k
k位的伽罗瓦计算公钥为:
g
a
l
k
e
y
k
←
(
b
′
,
a
′
)
∈
R
P
⋅
q
L
2
,
其中
b
′
=
−
a
′
s
+
e
′
+
P
⋅
s
(
X
5
k
)
galkey_k\leftarrow (b',a')\in R_{P·q_L}^2,其中b'=-a's+e'+P·s(X^{5^k})
galkeyk←(b′,a′)∈RP⋅qL2,其中b′=−a′s+e′+P⋅s(X5k)
现在对旋转后的密文
c
t
∗
ct^*
ct∗执行旋转中的KS算法:
c
t
r
o
t
=
(
c
0
(
X
5
k
)
,
0
)
+
⌊
P
−
1
⋅
c
1
(
X
5
k
)
⋅
g
a
l
k
e
y
k
⌉
m
o
d
q
l
ct_{rot}=(c_0(X^{5^k}),0)+\lfloor P^{-1}·c_1(X^{5^k})·galkey_k \rceil \ \ \ \ \ mod \ \ q_l
ctrot=(c0(X5k),0)+⌊P−1⋅c1(X5k)⋅galkeyk⌉ mod ql
查看一下
c
t
r
o
t
ct_{rot}
ctrot中的具体内容:
c
t
r
o
t
=
(
c
t
r
o
t
,
0
,
c
t
r
o
t
,
1
)
=
(
c
0
(
X
5
k
)
+
⌊
−
P
−
1
⋅
c
1
(
X
5
k
)
⋅
a
′
⋅
s
+
P
−
1
⋅
c
1
(
X
5
k
)
⋅
e
′
+
c
1
(
X
5
k
)
⋅
s
(
X
5
k
)
⌉
,
⌊
P
−
1
⋅
c
1
(
X
5
k
)
⋅
a
′
)
⌉
)
ct_{rot}=(ct_{rot,0},ct_{rot,1})=\\(c_0(X^{5^k})+\lfloor-P^{-1}·c_1(X^{5^k})·a'·s+P^{-1}·c_1(X^{5^k})·e'+c_1(X^{5^k})·s(X^{5^k})\rceil,\lfloor P^{-1}·c_1(X^{5^k})·a')\rceil)
ctrot=(ctrot,0,ctrot,1)=(c0(X5k)+⌊−P−1⋅c1(X5k)⋅a′⋅s+P−1⋅c1(X5k)⋅e′+c1(X5k)⋅s(X5k)⌉,⌊P−1⋅c1(X5k)⋅a′)⌉)
虽然这里看似好像内部的元素变复杂了，但是究其本质，这仍然是
R
R
R中的元素而已。
可以看到此时可以单独使用密钥
s
s
s来进行解密:
c
t
r
o
t
,
0
+
c
t
r
o
t
,
1
⋅
s
=
c
0
(
X
5
k
)
+
⌊
−
P
−
1
⋅
c
1
(
X
5
k
)
⋅
a
′
⋅
s
+
P
−
1
⋅
c
1
(
X
5
k
)
⋅
e
′
+
c
1
(
X
5
k
)
⋅
s
(
X
5
k
)
⌉
+
⌊
P
−
1
⋅
c
1
(
X
5
k
)
⋅
a
′
)
⌉
⋅
s
=
c
0
(
X
5
k
)
+
c
1
(
X
5
k
)
⋅
s
(
X
5
k
)
+
⌊
−
P
−
1
⋅
c
1
(
X
5
k
)
⋅
a
′
⋅
s
⌉
+
⌊
−
P
−
1
⋅
c
1
(
X
5
k
)
⋅
a
′
⌉
⋅
s
+
⌊
P
−
1
⋅
c
1
(
X
5
k
)
⌉
=
c
0
(
X
5
k
)
+
c
1
(
X
5
k
)
⋅
s
(
X
5
k
)
+
e
\begin{aligned} ct_{rot,0}+ct_{rot,1}·s \\ =&c_0(X^{5^k})+\lfloor-P^{-1}·c_1(X^{5^k})·a'·s+P^{-1}·c_1(X^{5^k})·e'+c_1(X^{5^k})·s(X^{5^k})\rceil + \lfloor P^{-1}·c_1(X^{5^k})·a')\rceil·s \\ =&c_0(X^{5^k})+c_1(X^{5^k})·s(X^{5^k}) + \lfloor -P^{-1}·c_1(X^{5^k})·a'·s \rceil+\lfloor -P^{-1}·c_1(X^{5^k})·a' \rceil ·s+ \lfloor P^{-1}·c_1(X^{5^k})\rceil \\ =&c_0(X^{5^k})+c_1(X^{5^k})·s(X^{5^k}) + e \end{aligned}
ctrot,0+ctrot,1⋅s===c0(X5k)+⌊−P−1⋅c1(X5k)⋅a′⋅s+P−1⋅c1(X5k)⋅e′+c1(X5k)⋅s(X5k)⌉+⌊P−1⋅c1(X5k)⋅a′)⌉⋅sc0(X5k)+c1(X5k)⋅s(X5k)+⌊−P−1⋅c1(X5k)⋅a′⋅s⌉+⌊−P−1⋅c1(X5k)⋅a′⌉⋅s+⌊P−1⋅c1(X5k)⌉c0(X5k)+c1(X5k)⋅s(X5k)+e
这里也引入了少许误差
e
=
⌊
P
−
1
⋅
c
1
(
X
5
k
)
⌉
e=\lfloor P^{-1}·c_1(X^{5^k})\rceil
e=⌊P−1⋅c1(X5k)⌉，当
P
P
P足够大时，该误差可以足够小。
3.3共轭操作
CKKS的共轭非常简单，实际上就是旋转的特殊形式，我们只需要将旋转中的左旋 k k k位，将 k k k设置为 − 1 -1 −1，然后执行上述的旋转操作，即可得到消息向量的共轭。
标签：mathbb,xi,加密,matrix,同态,CKKS,ct,X5k,vdots From： https://blog.csdn.net/Wwj2981/article/details/136935063