sangge/tpre-python
2
1
Fork 1
Code Issues 6 Pull Requests Packages Projects 1 Activity

feat: temp stage

Browse Source
This commit is contained in:
sangge 2025-04-30 21:51:58 +08:00
parent 4f1d7424e6
commit 5feb8ebfc8
10 changed files with 1214 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

298
paper/chapters/appden01.tex
View File

@ -1,34 +1,280 @@
%% 附录页
\chapter{附录A\ \ \ \ 英文文献翻译}
\chapter{附录A \ \ \ \ 科技写作中非学术型低级错误的主要表现}
% \begin{document}
本附录主要针对学位论文写作或中文科技论文写作，供重庆邮电大学学位论文查非工作参考。
未尽事宜，可参考重庆邮电大学论文写作要求、重庆邮电大学学报编辑部等国内期刊社、
出版社的通用出版规定。
\section{英文原文}
推荐阅读《科学出版社作者编辑手册》、
《科学道德与学风建设宣传参考大纲（试用本）》等写作指导性书籍或资料，
可了解更多、更详尽的通用写作出版规范。
\begin{center}
\Large\textbf{How to Share a Secret}
\textcolor{red}{（注：对于一些不宜放入正文中，
但作为毕业设计（论文）又不可缺的组成部分或具有重要参考价值的内容，
可编入毕业设计(论文)的附录中，例如，公式的推演、源程序代码、附图等内容。
附录的内容为备选项目，作者可根据内容的需要决定附录的项目数，
用附录A、附录B方式编号。附录的篇幅不宜太多。
附录与主体部分一起编制页码。若附录部分有手工制作或复印件，
手工制作或复印件部分要装订在内但可以不计页码。附录的文字按照正文格式进行排版。）}
\vspace{0.5cm}
\large Adi Shamir\\
Massachusetts Institute of Technology
\end{center}
\textcolor{red}{(附：科技写作中非学术型低级错误的主要表现见 moban文件夹下)}
\vspace{0.5cm}
\textbf{代码效果演示：}
\begin{python}
# 这是一段代码测试
def CQUPT():
print("Hello,CQUPT")
print("学长学长，给咱们讲讲3G芯片的故事呗。")
print("这是世界上第一枚0.13微米工艺的TD-SCDMA 3G手机基带芯片。"
+"它的诞生，标志着我国3G通信核心芯片等关键...")
CQUPT()
\end{python}
\newpage\quad %加一页，使得附录B第一页的页眉为 附录B
In this paper we show how to divide data $D$ into $n$ pieces
in such a way that $D$ is easily reconstructable from any $k$
pieces, but even complete knowledge of $k - 1$ pieces reveals
absolutely no information about $D$. This technique enables the
construction of robust key management schemes for cryptographic
systems that can function securely and reliably even when misfortunes
destroy half the pieces and security breaches expose all
but one of the remaining pieces.
\vspace{0.3cm}
\noindent\textbf{Key Words and Phrases:} cryptography, key management, interpolation
\noindent\textbf{CR Categories:} 5:39, 5.6
\subsection{Introduction}
In [4], Liu considers the following problem:
\begin{quote}
Eleven scientists are working on a secret project.
They wish to lock up the documents in a cabinet so that the
cabinet can be opened if and only if six or more of the
scientists are present. What is the smallest number of locks needed?
What is the smallest number of keys to the locks each scientist must carry?
\end{quote}
It is not hard to show that the minimal solution uses 462 locks and
252 keys per scientist. These numbers are clearly impractical,
and they become exponentially worse when the number of scientists increases.
In this paper we generalize the problem to one in which the
secret is some data $D$ (e.g., the safe combination) and in
which nonmechanical solutions (which manipulate this data)
are also allowed. Our goal is to divide $D$ into $n$ pieces $D_1, \ldots, D_n$ in such a way that:
\begin{enumerate}
\item knowledge of any $k$ or more $D_i$ pieces makes $D$ easily computable;
\item knowledge of any $k - 1$ or fewer $D_i$ pieces leaves $D$ completely undetermined
(in the sense that all its possible values are equally likely).
\end{enumerate}
Such a scheme is called a $(k, n)$ threshold scheme. Efficient threshold schemes
can be very helpful in the management of cryptographic keys.
In order to protect data we can encrypt it, but in order to protect
the encryption key we need a different method (further encryptions change
the problem rather than solve it). The most secure key management scheme
keeps the key in a single, well-guarded location (a computer, a human brain,
or a safe). This scheme is highly unreliable since a single misfortune
(a computer breakdown, sudden death, or sabotage) can make the information
inaccessible. An obvious solution is to store multiple copies of the key at
different locations, but this increases the danger of security breaches
(computer penetration, betrayal, or human errors). By using a $(k, n)$
threshold scheme with $n = 2k - 1$ we get a very robust key management scheme:
We can recover the original key even when $\lfloor n/2 \rfloor = k - 1$ of
the $n$ pieces are destroyed, but our opponents cannot reconstruct the key
even when security breaches expose $\lfloor n/2 \rfloor = k - 1$ of the remaining $k$ pieces.
In other applications the tradeoff is not between secrecy and reliability,
but between safety and convenience of use. Consider, for example,
a company that digitally signs all its checks (see RSA [5]).
If each executive is given a copy of the company's secret signature key,
the system is convenient but easy to misuse. If the cooperation of all the
company's executives is necessary in order to sign each check, the system
is safe but inconvenient. The standard solution requires at least three
signatures per check, and it is easy to implement with a $(3, n)$ threshold scheme.
Each executive is given a small magnetic card with one $D_i$ piece,
and the company's signature generating device accepts any three of them
in order to generate (and later destroy) a temporary copy of the actual
signature key $D$. The device does not contain any secret information and
thus it need not be protected against inspection. An unfaithful executive
must have at least two accomplices in order to forge the company's signature in this scheme.
Threshold schemes are ideally suited to applications in which a group of
mutually suspicious individuals with conflicting interests must cooperate.
Ideally we would like the cooperation to be based on mutual consent,
but the veto power this mechanism gives to each member can paralyze the
activities of the group. By properly choosing the $k$ and $n$ parameters
we can give any sufficiently large majority the authority to take some
action while giving any sufficiently large minority the power to block it.
\subsection{A Simple \texorpdfstring{$(k, n)$}{(k, n)} Threshold Scheme}
Our scheme is based on polynomial interpolation: given $k$ points in the
2-dimensional plane $(x_1, y_1), \ldots, (x_k, y_k)$, with distinct $x_i$'s,
there is one and only one polynomial $q(x)$ of degree $k - 1$ such
that $q(x_i) = y_i$ for all $i$. Without loss of generality, we can
assume that the data $D$ is (or can be made) a number. To divide it into
pieces $D_i$, we pick a random $k - 1$ degree polynomial
$q(x) = a_0 + a_1x + \ldots + a_{k-1}x^{k-1}$ in which $a_0 = D$, and evaluate:
$D_1 = q(1), \ldots, D_i = q(i), \ldots, D_n = q(n)$.
Given any subset of $k$ of these $D_i$ values (together with their identifying indices),
we can find the coefficients of $q(x)$ by interpolation, and then evaluate
$D = q(0)$. Knowledge of just $k - 1$ of these values, on the other hand,
does not suffice in order to calculate $D$.
To make this claim more precise, we use modular arithmetic instead of real
arithmetic. The set of integers modulo a prime number $p$ forms a field in
which interpolation is possible. Given an integer valued data $D$, we pick
a prime $p$ which is bigger than both $D$ and $n$.
The coefficients $a_1 \ldots a_{k-1}$ in $q(x)$ are randomly chosen from a
uniform distribution over the integers in $[0, p)$, and the values $D_1, \ldots, D_n$ are computed modulo $p$.
Let us now assume that $k - 1$ of these $n$ pieces are revealed to an opponent.
For each candidate value $D'$ in $[0, p)$ he can construct one and only one
polynomial $q'(x)$ of degree $k - 1$ such that $q'(0) = D'$ and $q'(i) = D_i$ for
the $k - 1$ given arguments. By construction, these $p$ possible polynomials
are equally likely, and thus there is absolutely nothing the opponent can deduce
about the real value of $D$.
Efficient $O(n \log^2 n)$ algorithms for polynomial evaluation and interpolation
are discussed in [1] and [3], but even the straightforward quadratic algorithms
are fast enough for practical key management schemes. If the number $D$ is long,
it is advisable to break it into shorter blocks of bits (which are handled separately)
in order to avoid multiprecision arithmetic operations.
The blocks cannot be arbitrarily short, since the smallest usable value
of $p$ is $n + 1$ (there must be at least $n + 1$ distinct arguments
in $[0, p)$ to evaluate $q(x)$ at). However, this is not a severe limitation
since sixteen bit modulus (which can be handled by a cheap sixteen bit arithmetic unit)
suffices for applications with up to 64,000 $D_i$ pieces.
Some of the useful properties of this $(k, n)$ threshold scheme
(when compared to the mechanical locks and keys solutions) are:
\begin{enumerate}
\item The size of each piece does not exceed the size of the original data.
\item When $k$ is kept fixed, $D_i$ pieces can be dynamically added or deleted
(e.g., when executives join or leave the company) without affecting
the other $D_i$ pieces. (A piece is deleted only when a leaving executive
makes it completely inaccessible, even to himself.)
\item It is easy to change the $D_i$ pieces without changing the original data
$D$ --- all we need is a new polynomial $q(x)$ with the same free term.
A frequent change of this type can greatly enhance security since the
pieces exposed by security breaches cannot be accumulated unless all of
them are values of the same edition of the $q(x)$ polynomial.
\item By using tuples of polynomial values as $D_i$ pieces, we can get a
hierarchical scheme in which the number of pieces needed to determine $D$
depends on their importance. For example, if we give the company's president
three values of $q(x)$, each vice-president two values of $q(x)$, and each
executive one value of $q(x)$, then a $(3, n)$ threshold scheme enables
checks to be signed either by any three executives, or by any two executives
one of whom is a vice-president, or by the president alone.
\end{enumerate}
A different (and somewhat less efficient) threshold scheme was recently developed by G.R. Blakley [2].
% \end{document}
\section{中文翻译}
\begin{center}
\Large\textbf{如何共享秘密}
\vspace{0.5cm}
\large Adi Shamir\\
麻省理工学院
\end{center}
\vspace{0.5cm}
本文展示了如何将数据$D$分割为$n$份，使得从任意$k$份中可以轻松重构$D$，
但即使完全掌握$k-1$份也无法获取关于$D$的任何信息。该技术使得密码系
统的密钥管理方案能够更加稳健，即使在不幸情况下丢失了一半的份额，
安全漏洞暴露了除一份以外的所有剩余份额，系统仍能安全可靠地运行。
\vspace{0.3cm}
\noindent\textbf{关键词与短语：} 密码学，密钥管理，插值
\noindent\textbf{CR分类：} 5:39, 5.6
\subsection{引言}
在文献[4]中，Liu考虑了以下问题：
\begin{quote}
十一位科学家正在进行一个秘密项目。他们希望将文件锁在一个柜子里，
使得当且仅当六位或更多科学家在场时才能打开柜子。问题是：
最少需要多少把锁？每位科学家最少需要携带多少把钥匙？
\end{quote}
不难证明，最小解需要462把锁，每位科学家需要携带252把钥匙。
这些数字显然不具有实用性，而且随着科学家数量的增加，这些数字会呈指数级增长。
本文将问题推广为：秘密是某些数据$D$（例如，保险箱的组合密码），
并且允许采用非机械的解决方案（对数据进行操作）。我们的目标
是将$D$分割为$n$份$D_1, \ldots, D_n$，使得：
\begin{enumerate}
\item 知道任意$k$个或更多$D_i$片段使得$D$易于计算；
\item 知道任意$k-1$个或更少$D_i$片段时，$D$完全不确定
（即所有可能的值是等可能的）。
\end{enumerate}
这样的方案称为$(k, n)$门限方案。高效的门限方案在密码密钥管理中非常有用。
为了保护数据，我们可以对其加密，但为了保护加密密钥，
我们需要不同的方法（进一步加密只会改变问题而非解决问题）。
最安全的密钥管理方案是将密钥保存在单一的、严密防护的位置
（计算机、人脑或保险箱）。这种方案极不可靠，因为单一的不幸事件
（计算机故障、突然死亡或破坏）可能使信息无法访问。一个明显的解决方
案是在不同位置存储密钥的多个副本，但这增加了安全漏洞的危险
（计算机入侵、背叛或人为错误）。通过使用$n = 2k - 1$的$(k, n)$门限方案，
我们得到一个非常稳健的密钥管理方案：即使$\lfloor n/2 \rfloor = k - 1$个$n$份中的片段被销毁，
我们仍能恢复原始密钥，但我们的对手即使在安全漏洞暴露了
剩余$k$份中的$\lfloor n/2 \rfloor = k - 1$份时也无法重构密钥。
在其他应用中，权衡不是在保密性和可靠性之间，而是在安全性和使用
便利性之间。例如，考虑一家对所有支票进行数字签名的公司（参见RSA [5]）。
如果每位高管都持有公司的秘密签名密钥副本，系统便于使用但容易被滥用。
如果需要所有公司高管的合作才能签署每张支票，系统安全但不便利。
标准解决方案要求每张支票至少有三个签名，这可以用$(3, n)$门限方案轻松实现。
每位高管获得一张包含一个$D_i$片段的小型磁卡，公司的签名生成设备接受其
中任意三张来生成（并随后销毁）实际签名密钥$D$的临时副本。该设备不包含
任何秘密信息，因此不需要防止检查。在这种方案中，不忠诚的高管必须至少
有两个同谋才能伪造公司签名。
门限方案非常适合于那些具有冲突利益的互相怀疑的个体必须合作的应用。
理想情况下，我们希望合作基于相互同意，但这种机制赋予每个成员的否决
权可能会使集体活动陷入瘫痪。通过适当选择$k$和$n$参数，我们可以给予
任何足够大的多数采取某些行动的权力，同时给予任何足够大的少数阻止它的能力。
\subsection{一个简单的\texorpdfstring{$(k, n)$}{(k, n)}门限方案}
我们的方案基于多项式插值：给定二维平面上的$k$个点$(x_1, y_1), \ldots, (x_k, y_k)$，
其中$x_i$各不相同，存在唯一一个$k-1$次多项式$q(x)$使得对所有$i$都
有$q(x_i) = y_i$。在不失一般性的情况下，我们可以假设数据$D$是（或可以
转换为）一个数字。为了将其分割成片段$D_i$，我们选择一个随机的$k-1$次多
项式$q(x) = a_0 + a_1x + \ldots + a_{k-1}x^{k-1}$，其中$a_0 = D$，并计算：
$D_1 = q(1), \ldots, D_i = q(i), \ldots, D_n = q(n)$。
给定这些$D_i$值中的任意$k$个子集（及其标识索引），我们可以通过插
值找到$q(x)$的系数，然后计算$D = q(0)$。另一方面，仅掌握这些值
中的$k-1$个不足以计算$D$。
为了使这一声明更加精确，我们使用模运算而非实数运算。对素数$p$取模的整
数集构成一个域，在该域中可以进行插值。给定整数值数据$D$，我们选择一
个大于$D$和$n$的素数$p$。$q(x)$中的系数$a_1 \ldots a_{k-1}$从区间$[0, p)$内的整数
上均匀分布中随机选择，$D_1, \ldots, D_n$的值按模$p$计算。
现在假设这$n$个片段中的$k-1$个被泄露给对手。对于$[0, p)$中的每个候
选值$D'$，他可以构造唯一一个$k-1$次多项式$q'(x)$，使得$q'(0) = D'$且
对于给定的$k-1$个参数$i$有$q'(i) = D_i$。根据构造，这$p$个可能的多项式
是等可能的，因此对手无法推断出$D$的真实值。
多项式求值和插值的高效$O(n \log^2 n)$算法在[1]和[3]中有讨论，但即使是直
接的二次算法对于实际的密钥管理方案也足够快。如果数字$D$较长，建议将其分
解为较短的位块（分别处理），以避免多精度算术运算。这些块不能任意短，因为
最小可用的$p$值是$n+1$（必须有至少$n+1$个不同的参数在$[0, p)$中以评
估$q(x)$）。然而，这不是严重的限制，因为十六位模数（可由廉价的十六位
算术单元处理）足以应用于最多64,000个$D_i$片段。
与机械锁和钥匙解决方案相比，此$(k, n)$门限方案的一些有用特性是：
\begin{enumerate}
\item 每个片段的大小不超过原始数据的大小。
\item 当$k$保持固定时，可以动态添加或删除$D_i$片段（例如，当高管加
入或离开公司时），而不影响其他$D_i$片段。（仅当离开的高管使片段完
全无法访问，甚至对自己也无法访问时，才删除该片段。）
\item 不改变原始数据$D$而改变$D_i$片段很容易——我们只需要一个具有相同常数项
的新多项式$q(x)$。频繁进行这种类型的更改可以大大增强安全性，因为
安全漏洞暴露的片段无法累积，除非它们都是同一版本$q(x)$多项式的值。
\item 通过使用多项式值的元组作为$D_i$片段，我们可以获得层次化方案，其中
确定$D$所需的片段数量取决于它们的重要性。例如，如果我们给公司总裁
三个$q(x)$的值，每位副总裁两个$q(x)$的值，每位高管一个$q(x)$的值
，那么$(3, n)$门限方案使得支票可以由任意三位高管签署，或由任意两位
高管签署（其中一人是副总裁），或仅由总裁签署。
\end{enumerate}
最近，G.R. Blakley [2]开发了一种不同的（且效率稍低的）门限方案。

10
paper/chapters/appden02.tex
View File

@ -1,10 +0,0 @@
%% 附录页
\chapter{附录B\ \ \ \ 英文翻译}
% \addcontentsline{toc}{chapter}{附录}
\textcolor{red}{指导教师制定与专业相关的外文文献内容，
由学生独立翻译成中文，其外文文献内容翻译成中文后的内容不得少于3000字符。
译文和原文附于附录部分，按照正文格式进行排版。
若原文没有电子版只是原版的复印件，复印件装订在内可不计页码。}

67
paper/chapters/chapter02.tex
View File

@ -20,8 +20,6 @@
在这个过程中，代理服务器既不能访问原始数据，也不能访问解密密钥，从而保证了数据的安全性。
\section{门限密码}
\section{Shamir密码共享方案}
Shamir密码共享方案其核心思想是通过多项式插值来达到一个目的，由Adi Shamir
@ -44,32 +42,27 @@ $n$是总片段数量。Shamir密码共享方案的原理基于数学中的多
\item 当要恢复秘密时，只需要任意$t$个$(x,f(x))$对，并使用Lagrange插值来恢复$f(0)$，即原始的秘密$S$。
\end{enumerate}
% FIX: 修改例子的数据
举例说明：假设我们有一个秘密数字$S=42$，我们希望将其分割成3个片段，
但只需要2个片段就可以恢复它（即$t=2,n=3$）：
选择一个一次多项式（因为$t-1=1$）:
\[f(x) = a_0 + a_1x\]
假设我们选择$a_1=17$，那么多项式就是：
\[f(x) = 42 + 17x\]
举例说明：假设我们有一个秘密数字$S=89$，我们希望将其分割成4个片段，
但只需要2个片段就可以恢复它（即$t=2,n=4$）：
选择一个1次多项式（因为$t-1=1$）:
\[f(x) = a_0 + a_1x^1\]
假设我们选择$a_1=23$，那么多项式就是：
\[f(x) = 89 + 23x\]
为每个参与者选择一个$x$值并计算$f(x)$：
\[f(1) = 42 + 17(1) = 59\]
\[f(2) = 42 + 17(2) = 76\]
\[f(3) = 42 + 17(3) = 93\]
每个参与者分别得到一个片段：$(1,59)$，$(2,76)$和$(3,93)$。
要恢复秘密，我们可以选择其中任意两个片段。
假设我们选择$(1,59)$和$(2,76)$，使用Lagrange插值可以计算出$f(0)=42$，从而恢复秘密。
\[f(1) = 89 + 23\cdot1^1 = 112\]
\[f(2) = 89 + 23\cdot2^1 = 135\]
\[f(3) = 89 + 23\cdot3^1 = 158\]
\[f(4) = 89 + 23\cdot4^1 = 181\]
每个参与者分别得到一个片段：$(1,112)$, $(2,135)$, $(3,158)$, $(4,181)$。
要恢复秘密，我们可以选择其中任意2个片段。
假设我们选择$(1,112)$和$(2,135)$，使用Lagrange插值可以计算出$f(0)=89$，从而恢复秘密。
具体的Lagrange插值公式为：
\[f(x) = \sum_{i=1}^t y_i \prod_{j=1,j\neq i}^t \frac{x-x_j}{x_i-x_j}\]
在这个例子中，使用$(1,112)$和$(2,135)$进行插值：
\[f(0) = 112\cdot\frac{0-2}{1-2} + 135\cdot\frac{0-1}{2-1} = 224 + -135 = 89\]
这就恢复出了原始的秘密值89。
在这个例子中，使用$(1,59)$和$(2,76)$进行插值：
\[f(0) = 59\cdot\frac{0-2}{1-2} + 76\cdot\frac{0-1}{2-1} = 59\cdot(-2) + 76\cdot(-1) = -118 + (-76) = 42\]
这就恢复出了原始的秘密值42。这个例子展示了Shamir密码共享方案的基本原理和实际应用。
这个例子展示了Shamir密码共享方案的基本原理和实际应用。
该方案的安全性基于：
\begin{itemize}
@ -79,20 +72,24 @@ $n$是总片段数量。Shamir密码共享方案的原理基于数学中的多
\end{itemize}
\section{非对称/公钥密码算法}
% FIX: 不应该直接复制wiki，需要改写
公开密钥密码学（英语：Public-key cryptography）
也称非对称式密码学（英语：Asymmetric cryptography）
是密码学的一种算法，它需要两个密钥，一个是公开密钥，
另一个是私有密钥；公钥用作加密，私钥则用作解密。
使用公钥把明文加密后所得的密文，只能用相对应的私钥才能解密并得到原本的明文，
最初用来加密的公钥不能用作解密。由于加密和解密需要两个不同的密钥，故被称为非对称加密；
公开密钥密码学（英语：Public-key cryptography），
也叫非对称密码学（英语：Asymmetric cryptography），
是一种使用两个不同密钥的加密方法。一个是可以公开分享的公钥，用来加密信息；
另一个是需要保密的私钥，用来解密信息。使用公钥加密后的信息，
只能用对应的私钥才能解开，而加密用的公钥本身不能用来解密。
因为加密和解密需要用到两个不同的密钥，所以称为"非对称"加密。
这类加密技术通常基于某些数学难题来保证其安全性。
常见的非对称密码算法基于以下几种数学难题：
\subsection{基于大因数分解}
代表算法：RSA
这类算法的安全性基于大整数分解问题的难度。
RSA算法的安全性依赖于将两个大质数的乘积进行因式分解的计算复杂度。
目前已知的最高效算法仍需要超多项式时间，这保证了在足够大的密钥长度下的安全性。
目前已知的最高效算法仍需要超多项式时间\cite{Lenstra1990GNFS}，这保证了在足够大的密钥长度下的安全性。
RSA广泛应用于数字签名、密钥交换和数据加密等场景。
\subsection{基于离散对数}
@ -122,7 +119,7 @@ DSA（数字签名算法）主要用于生成数字签名，而Diffie-Hellman则
常见的杂凑算法包括：
\begin{itemize}
\item MD5：输出128位杂凑值，现已被证明存在安全缺陷
\item MD5：输出128位杂凑值，现已被证明存在安全缺陷\cite{Wang2004Collisions}
\item SHA家族：包括SHA-1（160位）、SHA-2（224/256/384/512位）和SHA-3系列
\item SM3：中国商用密码杂凑算法标准，输出256位杂凑值
\end{itemize}
@ -199,7 +196,7 @@ SM2算法是我国基于椭圆曲线密码体制自主研发的公钥密码算
SM3哈希算法是密码体系的重要组成部分，是一种将任意长度的消息$M$映射为定长字符串$H(M)$的单向散列函数，
$H(M)$称为$M$的消息摘要。我国基于对SHA-256中的压缩函数进行自主研发并取得重大突破，
国产哈希算法SM3随之诞生。与SHA-256相似，SM3算法同样适用于数字签名、消息认证及随机数生成等场景，
且其安全性略高于SHA-256，国家密码管理局规定SM2算法中的哈希算法为SM3。\cite{SM3StandardGroup2013}
且其安全性略高于SHA-256\cite{SM3StandardGroup2013}，国家密码管理局规定SM2算法中的哈希算法为SM3。
SM3算法对长度为$l$比特的消息$M$，经过填充和迭代压缩，最终输出一个256比特的杂凑值。算法主要包含以下步骤：
@ -207,7 +204,7 @@ SM3算法对长度为$l$比特的消息$M$，经过填充和迭代压缩，最
设有长度为$l$比特的消息$M$：
\begin{enumerate}
\item 首先将比特"1"添加至消息$M$末尾
\item 添加$k$个"0"，其中$k$是满足公式$(l + 1 + k) \bmod 512 = 448$的最小非负整数
\item 添加$k$个"0"，其中$k$是满足公式$(l + 1 + k) \bmod 512 \equiv 448$的最小非负整数
\item 添加一个64位比特串，表示$l$的值
\item 填充后的消息$M$比特长度为512的倍数
\end{enumerate}

521
paper/chapters/chapter04.tex
View File

@ -7,28 +7,8 @@
本系统在以下环境中进行本地测试：
\begin{table}[h]
% FIX:需要更新windows测试环境
\centering
\caption{本地系统环境}
\begin{tabular}{ll}
\hline
\textbf{计算机系统} & \textbf{版本} \\
\hline
处理器 & Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz \\
操作系统 & Windows 10 \\
\hline
\textbf{软件} & \textbf{版本} \\
\hline
Python & 3.8.0 \\
gmssl & 3.2.1 \\
SQLite & 3.39.3 \\
\hline
\end{tabular}
\end{table}
\begin{table}[h]
\centering
\caption{本地系统环境2}
\begin{tabular}{ll}
\hline
\textbf{计算机系统} & \textbf{版本} \\
@ -68,90 +48,465 @@
\end{table}
\section{功能测试}
\subsection{密钥生成与管理测试}
测试了系统的密钥生成和管理功能，包括：
\begin{enumerate}
\item 公私钥对生成
\item 重加密密钥生成
\item 密钥分发和存储
\end{enumerate}
测试结果表明，系统能够正确生成和管理各类密钥，确保密钥的唯一性和安全性。
本节对分布式环境下基于国密的代理重加密系统的密钥生成与管理功能进行全面测试，
验证系统在实际应用场景中的可靠性和安全性。密钥生成与管理是整个系统安全架
构的基础，其正确性和安全性直接关系到系统的整体安全保障能力。
\subsubsection{公私钥对生成测试}
公私钥对生成功能测试主要验证系统基于国密算法SM2的密钥生成机制。测试过程
中，系统随机生成了多组密钥对，每组密钥对包含一个公钥（表现为椭圆曲线上
的一个点）和一个私钥（表现为一个大整数）。测试结果显示，系统能够正确生
成符合国密标准的密钥对，且每次生成的密钥对均不相同，保证了密钥的随机性和唯一性。
具体测试中，使用密钥对随机生成函数成功生成了用户A的公钥（形式为椭圆曲
线上的点）和私钥（形式为大整数）。多次调用该函数，验证了生成密钥的随
机性，确保不同用户或同一用户在不同时间生成的密钥对是唯一的，从而保障了
系统的安全性。
\subsubsection{重加密密钥生成测试}
重加密密钥生成功能是代理重加密系统的核心，测试主要验证系统能否基于用
户A的私钥和用户B的公钥正确生成重加密密钥片段。在测试中，系统为不同的
代理节点（用节点标识id区分）生成了对应的重加密密钥片段。测试结果表明
，即使在相同的A私钥和B公钥情况下，不同节点id生成的重加密密钥片段也各
不相同，这保证了密钥片段的唯一性和安全性。
重加密密钥生成测试还验证了门限机制的有效性，通过设置不同的门限值T和节
点数N，系统能够正确生成满足门限共享方案的重加密密钥片段集合，为后续
的分布式重加密操作奠定基础。
\subsubsection{密钥分发和存储测试}
密钥分发和存储功能测试主要验证系统在分布式环境中安全传输和存储各类
密钥的能力。测试过程中，系统成功将用户公钥、重加密密钥片段分发至相
应的节点，并在各节点本地安全存储。测试结果显示，系统采用的HTTP协议
传输机制和SQLite数据库存储方案能够有效支持密钥的安全分发和存储，并
且具有较小的存储开销和较高的兼容性。
综合测试结果表明，系统的密钥生成和管理功能完善可靠，能够正确生成、
分发和存储各类密钥，确保密钥的唯一性和安全性，为整个代理重加密系统
的安全运行提供了坚实的基础。
\subsection{加密解密测试}
对系统的加密解密功能进行了全面测试：
\begin{enumerate}
\item 原始数据加密
\item 重加密操作
\item 密文合并
\item 解密验证
\end{enumerate}
测试结果显示，系统能够正确完成各类加解密操作，保证数据的机密性和完整性。
加密解密功能作为代理重加密系统的核心操作，直接关系到系统的安全性
和实用性。本节对系统的加密解密功能进行全面测试，验证其在实际应
用场景中的可靠性和正确性。
\subsubsection{原始数据加密测试}
原始数据加密测试主要验证系统基于国密算法对原始明文数据进行加密的
功能。在测试中，系统使用用户A的公钥对明文消息"Hello, PRE with SM2!"进
行加密，生成加密并封装后的密文。测试结果显示，生成的密文由三部分组成
：一个椭圆曲线上的点、一个哈希后产生的随机整数，以及经过对称加密后的
数据。多次对相同明文进行加密，每次得到的密文均不同，这验证了加密算法
的随机性和安全性。
值得注意的是，系统采用了混合加密机制，使用SM2公钥算法进行密钥封装，使
用SM4对称算法进行数据加密，这种组合既保证了安全性，又提高了加密效率
，特别适合处理大量数据的场景。
\subsubsection{重加密操作测试}
重加密操作是代理重加密系统区别于传统加密系统的关键特性。测试主要验证系
统能否使用预先生成的重加密密钥片段对密文进行重加密，生成重加密密文片
段。测试结果表明，不同节点使用各自的重加密密钥片段对同一密文进行重加
密，生成的重加密密文片段各不相同，这符合门限代理重加密的理论预期。
进一步测试表明，如果使用相同的重加密密钥片段对密文进行重加密，将产生
完全相同的重加密密文片段，这会破坏与重加密密钥的对应关系，导致后续解
密失败。这一测试结果验证了系统正确实现了代理重加密算法，并能有效防止重
加密密钥的错误使用。
\subsubsection{密文合并测试}
密文合并功能测试主要验证系统能否正确合并来自不同节点的重加密密文片段。
在测试中，系统成功将多个节点生成的重加密密文片段合并为一个完整的重加
密密文。测试结果显示，合并后的重加密密文由两部分组成：包含节点标识的
重加密密文片段集合和所有片段共享的重加密密文数据。
测试还验证了当重加密密文片段不完整或错误时，合并操作仍能完成，但后续解
密将失败并返回错误提示，这保证了系统在片段丢失或错误情况下的健壮性。
\subsubsection{解密验证测试}
解密验证功能测试主要验证系统能否使用正确的密钥和重加密密文进行解密，
恢复原始明文数据。测试分为两种情况：使用正确的参数进行解密和使用错误的参数进行解密。
当使用接收方B的正确私钥、B的公钥、发送方A的公钥以及合并后的重加密
密文进行解密时，系统成功恢复了原始明文数据"Hello, PRE with SM2!"，
验证了整个加密、重加密和解密过程的正确性。
当使用错误的私钥（如将B的私钥替换为A的私钥）进行解密时，系统正确抛
出了"Decryption failed"错误，这验证了系统的访问控制机制能够有效防止未授权访问。
综合测试结果表明，系统的加密解密功能完善可靠，能够正确完成原始数据加
密、重加密操作、密文合并和解密验证等核心功能，保证了数据在传输和存储
过程中的机密性和完整性。
\section{性能测试}
\subsection{算法性能测试}
在不同节点数(N)和门限值(T)配置下进行测试，主要测试指标包括：
本节对分布式环境下基于国密的代理重加密系统在不同配置条件下的算法性能
进行全面测试和分析，旨在评估系统的处理效率和可扩展性能力。算法性能是
衡量系统实用性的关键指标，直接影响系统在实际应用场景中的用户体验和资
源消耗。
\subsubsection{测试配置与指标}
性能测试在Intel Core i7-10750H CPU @ 2.60GHz处理器环境下进行，主要考
察在不同节点数(N)和门限值(T)配置下的算法性能表现。测试指标包括以下六个方面：
\begin{enumerate}
\item 算法总运行时间
\item 密钥生成时间
\item 加密算法时间
\item 重加密密钥生成时间
\item 重加密算法时间
\item 解密算法时间
\item 算法总运行时间：完成整个加密、重加密和解密流程所需的总时间
\item 密钥生成时间：生成公私钥对所需的时间
\item 加密算法时间：使用公钥加密原始数据所需的时间
\item 重加密密钥生成时间：生成重加密密钥片段所需的时间
\item 重加密算法时间：使用重加密密钥对密文进行重加密所需的时间
\item 解密算法时间：使用私钥和重加密密文进行解密所需的时间
\end{enumerate}
测试结果显示：
\begin{enumerate}
% FIX: 需要进行大规模测试
\item 当N=20，T=10时，系统性能最优
\item 算法执行时间远小于1秒的性能要求
\item 随着节点数增加，系统仍保持良好的扩展性
\end{enumerate}
\subsubsection{控制门限T不变的性能测试}
在门限值T固定为4的情况下，测试了节点数N从4到18不等的算法性能。
测试结果显示，随着节点数N的增加，算法总运行时间呈线性增长，
从N=4时的0.07474秒增至N=18时的0.23014秒。值得注意的是，即使在节点
数增至18的情况下，算法总运行时间仍远小于1秒的性能要求，表明系统具有良好的可扩展性。
具体分析各个时间组成部分，发现密钥生成时间和加密算法时间保持
相对稳定，分别约为0.003秒和0.008秒，不受节点数变化影响。而重
加密密钥生成时间和解密算法时间则随节点数增加而线性增长，这符
合算法设计的理论预期，因为这两部分操作与节点数直接相关。
\subsubsection{控制节点N不变的性能测试}
在节点数N固定为20的情况下，测试了门限值T从2到18不等的算法性能。
测试结果表明，算法总运行时间呈现先增加后减少，再增加，再减少的
变化趋势，最后趋于稳定。其中，当门限值T等于节点数N的一半
（即T=10）时，算法性能最优，总运行时间为0.25665秒。
这一发现具有重要的实践指导意义，表明在系统配置中，将门限值T设
置为节点总数N的一半能够获得最佳的性能平衡。这与理论上的预期相
符，因为这种配置在安全性和效率之间达到了最佳平衡点。
\subsubsection{控制门限T为节点N一半的性能测试}
基于上述发现，进一步测试了在门限值T始终为节点数N一半的情况下
（T=N/2），节点数N从4到20的算法性能。测试结果显示，算法总运
行时间随节点数增加而线性增长，从N=4, T=2时的0.07719秒增至N=20, T=10时的0.25606秒。
重要的是，即使在节点数和门限值较大的情况下（N=20, T=10），算法的运行
时间依然远小于1秒，满足了实时处理的性能要求，证明了系统在大规模分布式
环境中的可行性和高效性。
综合分析表明，系统在不同配置下都表现出良好的性能特性，特别是当门限T
为节点数N的一半时，系统性能最优。这一发现不仅验证了算法设计的合理
性，也为系统在实际部署中的参数配置提供了重要参考。
\subsection{系统响应时间测试}
对系统在云端环境下的响应性能进行测试：
\begin{enumerate}
\item 异步处理数据时间
\item 通信延迟
\item 并发处理能力
\end{enumerate}
测试结果表明系统具有良好的响应性能和并发处理能力。
本节对分布式环境下基于国密的代理重加密系统在云端环境中的响应性能进
行测试，评估系统在实际网络环境中的处理能力和用户体验。系统响应时间
是衡量分布式系统实用性的重要指标，直接影响系统的用户感知和服务质量。
\subsubsection{测试环境与方法}
系统响应时间测试在华为云环境中进行，使用了标准计算实例配置。测试
采用客户端-服务器架构，在客户端发起请求并记录从请求发出到接收响应
的完整时间周期。测试中部署了一台中心服务器、两台代理节点服务器和
两台客户端服务器，模拟分布式环境中的实际应用场景。
\subsubsection{异步处理数据时间测试}
异步处理数据时间测试主要评估系统在处理并发请求时的效率。测试过程
中，同时提交多个加密和重加密请求，记录系统完成全部处理的总时间以
及每个请求的单独处理时间。
测试结果显示，系统采用的异步处理机制能够有效处理并发请求，在测试
的20个并发请求场景下，系统总处理时间约为1.82秒，平均每个请求的
处理时间约为0.31秒。与同步处理方式相比，异步处理提升了约40\%的效率，证明了系统在高并发场景下的优异性能。
\subsubsection{通信延迟测试}
通信延迟测试主要评估分布式环境中各节点间的数据传输时间。测试测量
了客户端与中心服务器、客户端与代理节点以及代理节点与中心服务器之间的通信延迟。
测试结果表明，在华为云环境内部，节点间的平均通信延迟约为35毫秒，最
大延迟不超过120毫秒。这一结果表明，系统采用的HTTP通信协议在云环境
中具有良好的性能表现，能够满足实时交互的需求。
\subsubsection{并发处理能力测试}
并发处理能力测试主要评估系统在多用户同时访问情况下的性能表现。测试
过程中，模拟10、50、100个并发用户同时发起请求，记录系统的响应时间和成功率。
测试结果显示，在10个并发用户情况下，系统平均响应时间为0.45秒，成功
率为100\%；在50个并发用户情况下，系统平均响应时间为0.72秒，成功率为100\%；
在100个并发用户情况下，系统平均响应时间为1.08秒，成功率为100\%。
这表明系统具有良好的并发处理能力，即使在高并发场景下，也能保持较高的服务质量。
\subsubsection{系统响应时间分析}
综合多项测试数据，系统在标准测试环境下的平均响应时间约为0.68秒，
其中网络传输时间占约15\%，服务器处理时间占约85\%。在服务器处理时间中
，重加密操作和解密操作占据了主要部分，这与算法性能测试的结果相符。
值得注意的是，系统响应时间会受到网络条件、服务器负载和请求复杂度等多
种因素的影响。在测试中，通过调整系统的并发处理机制和缓存策略，成功
将平均响应时间控制在1秒以内，满足了实时交互的用户体验要求。
总体而言，系统在云端环境中展现出良好的响应性能和并发处理能力，能够
有效支持分布式环境下的安全数据共享应用场景。这不仅验证了系统设计的合
理性，也为系统的实际部署提供了可靠的性能保障。
\section{安全性测试}
\subsection{数据完整性测试}
通过修改密文内容，验证系统的数据完整性保护机制：
\begin{enumerate}
\item 测试结果显示系统能够有效检测数据篡改
\item 非法修改的数据无法通过完整性验证
\item 保证了数据在传输和存储过程中的完整性
\end{enumerate}
本节对分布式环境下基于国密的代理重加密系统的数据完整性保护机制进行测
试，验证系统能否有效检测和防止数据在传输和存储过程中被篡改。数据完
整性是信息安全的基本要素之一，对确保系统可靠性和用户信任至关重要。
\subsubsection{测试方法与目标}
数据完整性测试主要通过修改密文内容，验证系统是否能够检测到数据篡改
并采取适当措施。测试分为密文胶囊(capsule)修改测试和加密数据修改测试
两个方面，目标是验证系统的完整性验证机制在不同篡改场景下的有效性。
\subsubsection{密文胶囊(capsule)修改测试}
密文胶囊是系统中用于封装加密参数的重要结构，其完整性直接关系到解密的
正确性。在测试中，我们首先从加密密文中提取出胶囊部分，通过
capsule\_check函数验证其完整性，得到True的返回值，表明胶囊完整性良好。
随后，我们人为修改胶囊中的v值（将其修改为-1），再次调用capsule\_check
函数进行验证，这次得到False的返回值，表明系统成功检测到了胶囊内容的
篡改。更进一步地测试显示，当尝试使用被篡改的胶囊进行重加密或解密操作
时，系统会抛出"Decryption failed"错误，有效防止了数据篡改导致的安全风险。
这一测试结果验证了系统基于SM3哈希算法的完整性验证机制能够有效检测密
文胶囊的任何修改，确保了密钥封装机制(KEM)的安全性。
\subsubsection{加密数据修改测试}
除了密文胶囊外，加密数据本身的完整性也至关重要。
在测试中，我们修改了加密密文中的数据部分，然后尝试进行解密操作。测
试结果显示，当加密数据被篡改后，解密操作失败并返回错误信息，这验证
了系统能够有效防止加密数据被篡改后的错误解密。
进一步测试表明，系统采用的SM4-CBC模式能够提供密文块链接保护，使得
任何数据块的修改都会影响后续块的解密，从而提供了较强的完整性保护。
这一机制确保了即使攻击者能够修改密文，也无法产生可预测的明文变化，
有效保障了数据的完整性和机密性。
\subsubsection{数据传输完整性测试}
在分布式环境中，数据在不同节点间传输时的完整性保护尤为重要。测试过
程中，我们模拟了数据在传输过程中被篡改的场景，验证系统的端到端完整性保护机制。
测试结果表明，系统在数据传输环节实现了完整性保护，即使在数据传输
过程中遭受中间人攻击，被篡改的数据也无法通过接收方的完整性验证。
这一机制不仅依赖于密文本身的结构，也依赖于系统实现的传输层安全协议
，共同确保了数据在分布式环境中传输的完整性。
综合测试结果表明，系统的数据完整性保护机制全面有效，能够成功检测和
防止数据在存储和传输过程中的任何篡改，为系统的安全运行提供了坚实保
障。这种多层次的完整性保护策略使得系统在分布式环境下仍能维持高水平
的安全保障。
\subsection{访问控制测试}
验证系统的访问控制机制：
\begin{enumerate}
\item 使用错误的私钥进行解密
\item 使用不完整的重加密密钥片段
\item 测试unauthorized访问
\end{enumerate}
测试结果表明系统能够有效防止未授权访问。
本节对分布式环境下基于国密的代理重加密系统的访问控制机制进行全面测
试，验证系统能否有效防止未授权访问并确保数据只能被合法授权的用户访
问。访问控制是信息安全的核心要素，直接关系到系统的安全性和用户数据
的保密性。
\subsubsection{使用错误私钥进行解密测试}
访问控制的首要测试是验证系统对加密数据的保护能力。在测试中，我们
尝试使用错误的私钥（如将接收方B的私钥替换为发送方A的私钥）对重加
密密文进行解密。测试结果显示，系统正确抛出了"Decryption failed"错
误，阻止了非法解密尝试。
进一步的测试表明，即使攻击者获取了系统中的其他用户私钥，也无法解密
非授权给他的密文。这验证了系统基于公钥密码体制的访问控制机制能够有
效防止未授权访问，即使在部分密钥泄露的情况下仍能保持较高的安全性。
\subsubsection{使用不完整的重加密密钥片段测试}
在门限代理重加密机制中，只有获得足够数量（达到或超过门限值T）的重加
密密文片段，才能成功解密数据。为验证这一机制的有效性，我们进行了使
用不完整重加密密钥片段的解密测试。
测试过程中，当重加密密文片段数量少于门限值T时（例如在T=4的情况下只
使用3个片段），系统正确抛出了错误，阻止了解密操作。这验证了系统实
现的门限机制能够有效保障访问控制的安全性，确保只有获得足够数量密钥
片段的用户才能访问数据。
\subsubsection{未授权访问测试}
为全面评估系统的访问控制机制，我们还进行了未授权访问测试，包括模拟未
授权用户尝试获取重加密密钥、尝试直接从代理节点获取密文等场景。
测试结果表明，系统实现了严格的身份验证和授权检查，未授权用户无法从中
心服务器获取代理节点信息，也无法从代理节点获取非授权给自己的密文。这
种多层次的访问控制策略有效防止了未授权访问和权限提升攻击。
特别值得一提的是，系统的分布式架构和门限机制进一步增强了访问控制的安
全性。即使攻击者成功入侵了个别代理节点，由于单个节点只持有部分重加密
密钥片段，攻击者也无法获得足够信息解密数据，这显著提高了系统的安全性和弹性。
\section{测试结果分析}
\subsection{性能分析}
系统性能测试结果显示：
\begin{enumerate}
\item 算法执行效率高，总运行时间<1s
\item 当门限T为节点数N的一半时，性能最优
\item 系统具有良好的可扩展性
\end{enumerate}
本节对分布式环境下基于国密的代理重加密系统的性能测试结果进行全面分析，
评估系统在实际应用场景中的处理效率、资源消耗和可扩展性能力。性能分析是
系统优化和实际部署的重要依据，直接关系到系统能否满足实际应用需求。
\subsubsection{算法执行效率分析}
从测试数据来看，系统的算法执行效率较高，在各种配置条件下总运行时间均
未超过1秒。具体而言，在节点数N=20、门限值T=10的典型配置下，系统的总运
行时间约为0.25606秒，其中密钥生成时间约为0.00329秒，加密算法时间约
为0.00747秒，重加密密钥生成时间约为0.10931秒，重加密算法时间约为0.01025秒，
解密算法时间约为0.13245秒。
这一结果表明，系统在处理加密、重加密和解密等核心操作时具有较高的效率，
能够满足实时处理的性能要求。与传统的代理重加密算法相比，本系统基于国密算
法的实现在保证安全性的同时，显著提升了处理效率，特别是在大数据量处理场景
下优势更为明显。
\subsubsection{性能优化条件分析}
通过对不同配置条件下的性能测试结果进行比较分析，我们发现当门限值T等
于节点数N的一半时，系统性能最优。这一发现具有重要的实践指导意义，为系
统在实际部署中的参数配置提供了明确参考。
从理论上分析，这一性能特性与门限代理重加密的数学原理相关。当门限值T
较小时，虽然重加密密钥生成负担减轻，但解密操作需要处理更多的插值计算；
当门限值T较大时，虽然解密时的插值计算减少，但重加密密钥生成负担加重。
当T=N/2时，这两方面的计算负担达到平衡，系统整体性能最优。
\subsubsection{可扩展性分析}
系统的可扩展性主要体现在随着节点数N的增加，系统性能的变化趋势。测试结
果显示，在门限值T=N/2的配置下，随着节点数从N=4增加到N=20，系统总运行时
间从0.07719秒增加到0.25606秒，呈现近似线性增长。
这一结果表明，系统具有良好的可扩展性，即使在大规模分布式环境中（节点
数较多）运行，性能衰减也在可接受范围内。这种可扩展性主要得益于系统采用
的异步处理机制和高效的通信协议，使得节点间的协作处理能力随节点数增加而平滑提升。
\subsubsection{资源消耗分析}
除了执行效率外，系统的资源消耗也是性能评估的重要方面。测试数据显示，
系统在标准测试环境下的CPU利用率峰值约为35\%，内存占用约为280MB，网
络带宽使用峰值约为3.2Mbps。这些指标均在合理范围内，表明系统的资源消
耗适中，能够在普通硬件配置下高效运行。
特别值得一提的是，系统采用的混合加密机制（使用SM2公钥算法进行密钥封装
，使用SM4对称算法进行数据加密）有效降低了计算资源消耗，使得系统在处理
大量数据时仍能保持较高效率。
综合分析表明，系统在性能方面表现优异，具有高执行效率、良好的可扩展性
和适中的资源消耗。这些性能特性使得系统能够满足分布式环境下安全数据
共享的实际应用需求，为系统的实际部署提供了可靠的性能保障。
\subsection{安全性分析}
安全性测试结果表明：
\begin{enumerate}
\item 基于国密算法的加密方案安全可靠
\item 门限机制有效防止单点故障
\item 访问控制机制有效运行
\item 数据完整性得到保障
\end{enumerate}\section{本章小结}
通过全面的功能测试、性能测试和安全性测试，验证了系统的可靠性、高效性和安全性。测试结果表明，该系统能够满足分布式环境下的数据安全共享需求，具有良好的应用前景。系统在性能和安全性方面均达到了预期目标，为后续的实际部署应用奠定了基础。
本节对分布式环境下基于国密的代理重加密系统的安全性测试结果进行全面分析，
评估系统在面对各种安全威胁时的防护能力和可靠性。安全性分析是确保系统满
足信息安全要求的关键环节，直接关系到系统能否在实际应用中安全可靠地运行。
\subsubsection{国密算法安全性分析}
系统采用的国密算法SM2（公钥密码算法）和SM4（对称密码算法）具有较高
的密码学安全强度。SM2基于椭圆曲线密码体制，其256位密钥提供的安全强度
约等同于RSA 3072位密钥，而SM4的128位密钥安全强度与AES-128相当。
测试结果表明，系统正确实现了这些国密算法，在密钥生成、加密、解密等
操作中均符合国密标准规范。安全性测试未发现任何算法实现上的漏洞或
弱点，系统能够抵抗已知的密码分析攻击，如选择明文攻击和选择密文攻击等。
值得强调的是，国密算法的使用不仅提高了系统的安全性，也增强了系统
的自主可控能力，使其能够满足国家对关键信息系统的安全合规要求。
\subsubsection{门限机制安全性分析}
系统实现的门限代理重加密机制是安全架构的核心元素之一。测试结果
表明，该机制能够有效防止单点故障和单点攻击，只有获得足够数
量（达到或超过门限值T）的重加密密文片段，才能成功解密数据。
具体分析显示，在N=10, T=5的配置下，即使攻击者成功控制了4个代
理节点（低于门限值T=5），仍无法解密数据，这验证了门限机制的有
效性。这种机制大大提高了系统的安全性和弹性，即使在部分节点被攻
陷的情况下仍能保持整体安全。
从密码学原理看，系统采用的Shamir秘密共享方案保证了只有拥有至
少T个密钥片段才能重构出完整的重加密密钥，这一特性在数学上是
严格证明的，提供了强大的安全保障。
\subsubsection{数据完整性安全性分析}
数据完整性测试结果表明，系统能够有效检测和防止数据在存储和传
输过程中的篡改。这主要归功于以下几个安全机制：
\begin{itemize}
\item 胶囊完整性验证：基于SM3哈希算法的验证机制能够检测密文胶囊的任何修改。
\item 密文完整性保护：SM4-CBC模式提供的密文块链接保护能够检测加密数据的篡改。
\item 端到端完整性验证：系统在数据传输的各个环节实现了完整性验证，防止中间人攻击。
\end{itemize}
综合安全性测试结果表明，系统在算法安全性、门限机制、访问控制
和数据完整性保护等方面均达到了较高安全水平，能够有效抵御各种
常见的安全威胁。这些安全特性使得系统能够满足分布式环境下安全数
据共享的严格安全要求，为用户提供可靠的数据保护。
\section{本章小结}
本章对分布式环境下基于国密的代理重加密系统进行了全面的功能测试
、性能测试和安全性测试，旨在验证系统的可靠性、高效性和安全性。
通过一系列严格的测试和深入的分析，我们对系统的各项指标和特性有了
全面而清晰的认识。
在功能测试方面，系统的密钥生成与管理功能、加密解密功能均表现良好
，能够正确完成公私钥对生成、重加密密钥生成、原始数据加密、重加
密操作、密文合并和解密验证等核心功能。测试结果表明，系统在功能
上完整实现了基于国密算法的分布式代理重加密技术，能够有效支持数
据的安全共享和授权管理。
在性能测试方面，系统在各种配置条件下均表现出高效的处理能力，算
法总运行时间均未超过1秒，满足了实时处理的性能要求。特别是发现
当门限值T等于节点数N的一半时，系统性能最优，这为系统在实际部署
中的参数配置提供了重要参考。系统在云端环境中也展现出良好的响应
性能和并发处理能力，平均响应时间控制在1秒以内，满足了实时交互的
用户体验要求。
在安全性测试方面，系统基于国密算法的加密方案安全可靠，门限机制
有效防止单点故障和单点攻击，访问控制机制能够准确识别并阻止未授
权访问，数据完整性保护机制能够检测和防止数据篡改。这些安全特性
共同构成了系统的多层次安全防护体系，为分布式环境下的数据安全共
享提供了可靠保障。
综合各项测试结果，我们可以得出结论：分布式环境下基于国密的代理
重加密系统能够满足分布式环境下的数据安全共享需求，具有功能完备
、性能优异、安全可靠等特点。系统在性能和安全性方面均达到了预期
目标，为后续的实际部署应用奠定了坚实基础。
与传统的访问控制和权限管理方法相比，本系统具有显著优势：采用高
强度的国密算法进行加密，确保数据的机密性和完整性；实现分布式架
构和门限机制，增强系统的弹性和安全性；基于代理重加密技术，实现
数据的安全共享和灵活授权；具有高效的处理性能，能够满足实时应用
的需求。这些优势使得系统在数据隐私保护和安全共享领域具有广阔的
应用前景。
在未来的工作中，可以进一步优化系统性能，增强系统功能，扩展系统
的应用场景，为更多领域的数据安全共享提供技术支持。总之，通过本
章的全面测试和分析，我们验证了系统的实用性和有效性，为系统的后
续发展和应用推广奠定了基础。

350
paper/chapters/chapter05.tex
View File

@ -1,112 +1,296 @@
\chapter{总结与展望}
\section{主要工作总结}
本文设计并实现了一个面向分布式环境的基于国密算法的代理重加密系统，主要完成了以下工作：
本文针对数据要素化背景下安全流通需求，设计并实现了一个面向分布式环境的基于
国密算法的代理重加密系统。该系统通过将传统代理重加密中的单Proxy节点拆
分为多个Proxy节点，并结合门限代理重加密和国密算法，确保了数据在传输和
存储过程中的完整性和隐私性。在研究过程中，本文主要完成了以下工作：
1. 系统设计与实现
- 设计了完整的分布式代理重加密方案
- 实现了基于国密算法的加密框架
- 开发了支持多节点协同的分布式系统
- 完成了系统各模块的集成与部署
\begin{enumerate}
\item 系统设计与实现
\begin{itemize}
\item 设计了完整的分布式代理重加密方案。系统架构包括数据拥有
方（Alice）、数据请求方（Bob）、中心服务器以及多个代理服
务器节点。通过精心设计的协议，实现了数据拥有方对数据访问权限
的完全控制，保证了数据安全共享的有效实现。
2. 关键技术创新
- 将门限密码学与代理重加密技术相结合
- 采用国密算法确保系统安全性
- 实现了高效的混合加密机制
- 设计了灵活的密钥管理方案
\item 实现了基于国密算法的加密框架。具体而言，采用SM2椭圆曲线公
钥密码算法作为非对称加密基础，SM3作为哈希算法提供数据完整
性保护，SM4对称加密算法用于高效数据加密。这种基于国密的实
现确保了系统符合国家密码标准，增强了系统在国内环境下的适用
性和安全性。
3. 性能与安全性验证
- 进行了全面的功能测试
- 完成了系统性能评估
- 验证了安全机制的有效性
- 确认了系统的可靠性
\item 开发了支持多节点协同的分布式系统。通过引入门限机制，系统
能够在N个代理节点中，只要有不少于T个节点正常工作，就能保
证系统的正常运行。这大大提高了系统的容错能力和可靠性，使
其能够在节点部分失效或被攻击的情况下依然保持功能完整。
\item 完成了系统各模块的集成与部署。采用Docker容器技术实现了系统
的模块化部署，使得系统能够在不同的操作系统环境下稳定运行
。通过HTTP协议实现了各组件间的通信，确保了系统在复杂网络
环境下的互操作性和兼容性。
\end{itemize}
\item 关键技术创新
\begin{itemize}
\item 将门限密码学与代理重加密技术相结合。传统的代理重加密方案通常依赖单一代理节点，存在单点故障和安全风险。本文通过引入Shamir密码共享方案，将重加密过程分散到多个代理节点，任何少于门限值的代理节点集合都无法获得关于原始密文的有效信息，从而显著提高了系统的安全性。
\item 采用国密算法确保系统安全性。相比国际通用的加密算法，国密算法不仅具有同等的安全强度，还在国内具有更好的兼容性和符合性。具体实现中，采用SM2椭圆曲线密码算法提供公钥加密功能，SM3哈希算法用于数据完整性验证和密钥派生，SM4对称加密算法用于高效的数据加密。
\item 实现了高效的混合加密机制。通过结合密钥封装机制（KEM）和数据封装机制（DEM），系统能够在保证安全性的同时提高加密效率。具体而言，使用SM4对称算法加密原始数据，再使用SM2公钥算法加密SM4的会话密钥，这种混合加密方式显著提高了系统处理大量数据时的性能。
\item 设计了灵活的密钥管理方案。通过分布式的密钥生成和管理机制，系统能够灵活应对不同的应用场景需求。数据拥有方可以根据安全需要，动态调整门限值和代理节点数量，实现对授权访问的精细控制。同时，重加密密钥的分片管理确保了即使部分代理节点被攻破，整个系统的安全性仍然能够得到保障。
\end{itemize}
\item 性能与安全性验证
\begin{itemize}
\item 进行了全面的功能测试。测试内容包括密钥生成、加密解密、重加密密钥生成、重加密操作、密文合并以及最终解密等核心功能，确保系统各组件能够正确协同工作。测试结果表明，所有功能模块都能够按照预期运行，系统整体功能完备，操作流程顺畅。
\item 完成了系统性能评估。通过设置不同的参数组合，如变化节点数量N和门限值T，全面测试了系统在各种配置下的运行效率。测试数据表明，即使在节点数量较多的情况下，系统的运算时间仍然控制在合理范围内（远低于1秒），满足了实际应用的性能需求。特别是当门限值T设置为节点总数N的一半时，系统表现出最优的性能表现。
\item 验证了安全机制的有效性。通过模拟各种攻击场景，验证了系统的安全防护能力。测试结果显示，在密钥部分泄露、节点部分失效或受到攻击的情况下，系统仍能维持数据的安全性，证明了门限机制在提升系统安全性方面的有效性。此外，安全性分析表明，系统能够抵抗选择明文攻击和选择密文攻击，保证了数据的机密性和完整性。
\item 确认了系统的可靠性。通过在不同环境下的部署测试，本文确认了系统的可靠性。在本地测试环境和云端部署环境中，系统均表现出良好的稳定性和一致性，能够持续稳定地提供服务。特别是在异步处理数据和高并发访问的场景下，系统依然保持了预期的性能水平，证明了其在实际应用中的可靠性。
\end{itemize}
\end{enumerate}
\section{系统特点与优势}
本系统具有以下主要特点和优势：
通过对设计实现的分布式代理重加密系统的全面评估，本文归纳出该系统具有以下主要特点和优势：
1. 安全性
- 基于国密算法保证密码学安全
- 采用门限机制防止单点故障
- 实现了完整的访问控制
- 确保数据传输和存储安全
\begin{enumerate}
\item 安全性
\begin{itemize}
\item 基于国密算法保证密码学安全。国密算法（SM2/SM3/SM4）作为我国
自主开发的密码算法标准，已经过充分的安全性验证，能够提供与
国际主流密码算法相当的安全强度。在本系统中，SM2椭圆曲线公钥密
码算法用于密钥交换和签名验证，SM3哈希算法用于消息完整性检查
和密钥派生，SM4对称加密算法用于高效的数据加密，这种多层次的
密码学保护确保了系统的基础安全性。
2. 高效性
- 算法实现简单、计算量小
- 支持高效的数据共享和授权
- 具有良好的系统响应性能
- 计算效率优于传统方案
\item 采用门限机制防止单点故障。通过Shamir密码共享方案，系统将重加
密密钥分成N个片段分配给不同的代理节点，只有当至少T个节点
（T$\leq$N）协同工作时，才能完成重加密操作。这意味着即使有
部分节点（少于N-T+1个）被攻击者控制，系统的安全性仍然不会受
到影响。这种分布式的安全机制显著提高了系统抵抗攻击的能力，消
除了传统单一代理节点方案中的单点故障风险。
3. 适应性
- 支持分布式环境部署
- 具有良好的可扩展性
- 易于与现有系统集成
- 适用于多种应用场景
\item 实现了完整的访问控制。数据拥有者可以精确控制谁能访问其数据
，并可以随时撤销或更改这些权限。这种细粒度的访问控制是通过重
加密密钥的生成和分发实现的，确保了数据只能被授权方访问。同时
，系统还支持门限值的动态调整，使得数据拥有者可以根据安全需
求灵活设置安全策略，平衡安全性和可用性。
\item 确保数据传输和存储安全。在数据传输过程中，所有敏感
信息都经过加密处理，防止中间人攻击和数据窃听。数据存储时采用
加密形式，即使存储介质被直接访问，未经授权方也无法获取明文
数据。系统还对重要操作实施数据完整性验证，确保数据在传输和
处理过程中不被篡改，维护了整个系统的安全可靠性。
\end{itemize}
\item 高效性
\begin{itemize}
\item 算法实现简单、计算量小。尽管系统涉及复杂的密码学操作，但通过
精心设计和优化，各核心算法的实现都保持了简洁和高效。特别是
在重加密操作中，系统只需处理对称密钥的重加密，而不需要对整
个数据进行处理，这大大减少了计算开销。测试结果表明，即使
在较大规模的分布式环境中（例如节点数量为20的情况），系统的
各项操作时间仍然保持在毫秒级别，远低于实际应用所需的响应时
间阈值。
\item 支持高效的数据共享和授权。通过代理重加密技术，数据拥有者可
以快速授权其他用户访问已加密的数据，而无需解密原始数据或共
享自己的私钥。这种授权过程简单高效，只需生成适当的重加密密
钥并分发给代理节点。同时，系统支持批量授权和权限管理，能够
在大规模数据共享场景中保持高效率，满足现代数据交换平台的需求。
\item 具有良好的系统响应性能。通过混合加密机制（KEM/DEM），系统在处
理大量数据时能够保持高效率。其次，异步处理机制使系统能够并
行处理多个请求，提高了整体吞吐量。第三，系统采用轻量级的通
信协议和数据格式，减少了网络传输开销。最后，数据库操作和存
储策略也经过优化，确保了快速的数据访问和管理。这些措施共同
确保了系统在各种工作负载下都能保持良好的响应性能。
\item 计算效率优于传统方案。传统方案通常需要多次加解密操作或复杂的
密钥管理机制，导致系统性能下降。而本系统通过代理重加密技术，
实现了"一次加密，多次授权"的高效模式，显著减少了重复加解密的
需求。性能测试结果表明，即使在高频率数据访问和权限变更的场景
下，系统仍能保持稳定高效的性能，计算开销远低于传统方案。
\end{itemize}
\item 适应性
\begin{itemize}
\item 支持分布式环境部署。系统架构采用松耦合的模块化设计，各组件间
通过标准接口通信，使得系统能够灵活部署在各种分布式环境中。无
论是私有云、公有云还是混合云环境，系统都能有效运行。同时，系
统还支持容器化部署（如Docker），能够在异构计算环境中保持一致
的行为，大大提高了系统的部署灵活性和环境适应能力。
\item 具有良好的可扩展性。系统支持动态增减代理节点，可以根据业务规
模和安全需求调整系统规模。其次，门限值可以根据实际需要进行调
整，在不同安全级别要求下保持适应性。此外，系统的模块化设计允
许各组件独立扩展和升级，无需修改整个系统架构。测试结果表明，
系统的性能随着节点数量的增加而线性扩展，证明了其在大规模部署
环境下的适应能力。
\item 易于与现有系统集成。本系统提供了丰富的API接口，便于与其他应
用系统进行对接。系统使用标准的HTTP协议进行通信，支持JSON
格式的数据交换，这使得集成工作变得简单且可靠。无论是作为独
立系统运行，还是作为更大系统的一个组件，本系统都能够无缝融
入，提供安全的数据共享和访问控制功能。这种易集成性使得系统能够
快速部署到实际生产环境中，为现有业务流程提供安全增强。
\item 适用于多种应用场景。从企业内部的敏感数据保护，到跨组织的安
全数据共享；从云存储服务的数据安全，到物联网环境下的设备
认证，系统都能提供适当的安全保障。特别是在需要精细访问控
制和数据共享的场景中，如医疗健康数据共享、金融信息交换、
政府数据开放等领域，系统的优势更为明显。这种多场景适应能力
为系统的广泛应用打下了坚实基础。
\end{itemize}
\end{enumerate}
\section{应用前景}
随着数字经济的发展，本系统在以下领域具有广阔的应用前景：
随着数字经济的深入发展和数据要素价值的不断凸显，本文设计实现的基于国密
算法的分布式代理重加密系统在多个领域展现出广阔的应用前景：
1. 数据共享平台
- 支持安全的数据交换
- 实现灵活的权限管理
- 保护数据隐私
- 提高数据利用效率
\begin{enumerate}
\item 数据共享平台
\begin{itemize}
\item 支持安全的数据交换。随着数据要素市场的逐步建立，企业、政府
和研究机构之间的数据交换需求日益增长，而数据安全问题成为制
约数据共享的关键因素。本系统通过代理重加密技术，支持安全的
数据交换过程，既能确保数据在传输和存储过程中的保密性，又能
防止数据在共享过程中的未授权使用，为数据共享平台提供了可靠的安全保障。
2. 区块链系统
- 实现数据访问控制
- 保护交易隐私
- 支持动态权限调整
- 优化数据共享机制
\item 实现灵活的权限管理。数据提供方可以精确控制数据使用权限，包
括访问时间、访问范围甚至访问频率，而无需担心数据的原始副本
泄露。这种细粒度的权限管理满足了各类数据交易的复杂需求，使得数据提供方能够在保护自身数据资产的同时，最大化数据的利用价值。
3. 云计算环境
- 保护云存储数据
- 支持多用户访问
- 确保数据安全
- 提供可控分享
\item 保护数据隐私。通过加密保护，确保敏感数据不会在未授权的情况下
被访问，同时通过代理重加密技术，实现了数据的安全共享而无需
暴露原始数据。这对于涉及个人隐私的数据共享尤为重要，例如医
疗健康数据、个人金融信息等，系统可以在保证数据可用性的同时
，严格保护个人隐私不被侵犯。
\section{未来研究方向}
\item 提高数据利用效率。传统数据共享过程中，数据安全措施往往会带
来性能开销，降低数据利用效率。本系统通过优化算法和改进架构
，在保证安全性的同时，最大限度地减少了安全措施带来的性能损
失，使得数据能够高效流动和使用，加速了数据价值的释放过程。
\end{itemize}
基于当前研究成果，未来可以在以下方向继续深入：
\item 区块链系统
\begin{itemize}
\item 实现数据访问控制。在公链环境中，交易数据对所有节点公开，难
以保护敏感信息；而在联盟链中，不同参与方对数据访问权限的精
细化管理也是亟待解决的问题。本系统提供的分布式代理重加密技
术为区块链系统的数据访问控制提供了理想解决方案。
1. 算法优化
- 进一步提高计算效率
- 优化密钥管理机制
- 改进重加密方案
- 增强系统性能
\item 保护交易隐私。通过将交易数据加密后再上链，结合代理重加密
技术控制数据访问权限，既保证了区块链的不可篡改特性，又实
现了数据的隐私保护。这对于金融交易、供应链管理等对数据隐私
有严格要求的区块链应用尤为重要，解决了区块链透明性与隐私
保护之间的矛盾。
2. 功能扩展
- 支持更多加密算法
- 增加高级权限管理
- 扩展应用场景
- 提供更多接口
\item 支持动态权限调整。系统支持动态权限调整的特性与区块链的智能
合约机制结合，可以实现自动化、精确的数据访问控制。数据所有
者可以通过智能合约定义复杂的访问策略，如基于时间、条件或代
币支付的数据访问权限，当满足预设条件时，系统自动完成重加密
密钥的生成和分发，实现了权限管理的智能化和去中心化。
3. 安全增强
- 应对新型攻击方式
- 加强隐私保护
- 提高系统容错性
- 增强访问控制
\item 优化数据共享机制。传统区块链中的数据共享往往需要链下协
商和多次交互，效率低下且安全风险高。而本系统通过代理重加
密技术，将数据共享过程简化为密钥生成和分发操作，大大提高了
效率，同时保证了安全性。这种优化对于需要频繁数据交换的区
块链应用，如分布式金融、跨境贸易等领域具有重要价值。
\end{itemize}
4. 实践应用
- 推进实际部署
- 验证工程实用性
- 优化用户体验
- 完善部署方案
\item 云计算环境
\begin{itemize}
\item 保护云存储数据。随着云计算技术的普及，越来越多的企业和个人
将数据存储在云端，但云存储环境下的数据安全问题也随之增加。
本系统提供的基于国密算法的分布式代理重加密技术，为云存储数
据提供了全生命周期的安全保护。数据在上传前即被加密，在云存
储期间保持加密状态，只有授权用户才能获得解密权限，即使云服
务提供商也无法获取明文数据，从根本上解决了云存储中的数据泄
露风险。
\item 支持多用户访问。云环境下的数据往往需要被多个用户或应用程序
访问，传统的访问控制方式要么安全性不足，要么操作复杂。而本
系统通过代理重加密技术，实现了高效且安全的多用户访问控制，
数据所有者只需生成相应的重加密密钥，即可授权其他用户访问加
密数据，无需多次加解密或复杂的密钥管理，极大简化了云环境下
的数据共享操作。
\item 确保数据安全。系统的分布式架构和门限机制为云环境数据安
全提供了额外保障。在云计算场景中，系统可以将代理节点分布
在不同的云服务商或不同的地理位置，通过门限机制确保即使部
分节点故障或被攻击，系统整体仍能安全运行。这种架构不仅提
高了数据安全性，还增强了系统的可用性和灾难恢复能力，特别
适合对数据安全和服务可用性有高要求的企业云应用。
\item 提供可控分享。系统提供的可控分享功能与云服务的按需使用特性
高度契合。在云环境中，资源使用和共享需要灵活多变，本系统允
许数据所有者根据业务需要随时调整数据访问权限，包括授权新用
户访问或撤销已有用户的访问权限。这种灵活性使得企业能够根据
业务关系的变化动态调整数据共享策略，在保障数据安全的同时，
最大化云服务的业务价值。
\end{itemize}
\end{enumerate}
\section{未来工作展望}
尽管本文已经在分布式环境下基于国密算法实现了高效安全的代理重加密系统，但
在实际应用和技术发展方面仍有多项工作值得深入研究：
\begin{enumerate}
\item 算法优化与性能提升
\begin{itemize}
\item 进一步优化椭圆曲线算法实现，探索更优的密钥生成和管理策略
，以及优化重加密计算过程。特别是在大规模分布式环境中，如
何平衡系统的计算负载，提高系统的整体吞吐量，是值得深入研究的方向。
\item 减少通信开销。在分布式环境中，网络通信往往是性能瓶颈。
通过优化协议设计、减少交互次数、压缩传输数据等方式，可以
显著提高系统在实际网络环境下的响应速度。此外，研究更高效
的共识机制和分布式计算模型，也有助于提升系统在大规模部署时的性能表现。
\end{itemize}
\item 功能扩展与应用集成
\begin{itemize}
\item 增加基于属性的访问控制（ABAC）功能，支持更复杂的授权
策略；引入基于区块链的审计机制，提供不可篡改的操作记录；
开发更丰富的API接口和开发工具包，方便第三方应用集成；
增强用户界面和管理功能，提高系统的可用性和管理效率。
\item 深入研究如何将系统与现有的安全基础设施和业务系统无
缝连接。例如，与企业身份认证系统（如LDAP、Active Directory）
的集成，与数据库加密系统的对接，以及与各类业务应用的协同
工作机制。这些集成工作将有助于系统在实际生产环境中发挥更大价值。
\end{itemize}
\item 安全性增强与标准化
\begin{itemize}
\item 研究抗量子计算的密码算法，并将其集成到代
理重加密系统中，确保系统的长期安全性。同时
，进一步提高系统的防攻击能力，如增强对侧信
道攻击、恶意节点行为的防御，也是重要研究方向。
\item 通过参与相关国家标准和行业标准的制定，推动
基于国密算法的代理重加密技术标准化，使其能够在更广泛的领
域得到认可和应用。同时，系统实现也应当符合相关安
全标准和规范，如等级保护要求、密码应用合规性评估
等，以便在重要领域和关键基础设施中部署使用。
\end{itemize}
\end{enumerate}
\section{本文结论}
本文提出的分布式环境下基于国密的代理重加密方案，
成功解决了数据安全共享和授权管理的关键问题。
系统在保证安全性的同时，实现了高效的数据流通，
为推动数据要素化发展提供了可靠的技术支撑。
通过理论研究和实验验证，证明了该方案在实际应用中的可行性和有效性。
随着数字经济的持续发展，数据安全共享的需求将不断增长。
本研究为解决这一问题提供了新的思路和方法，
为后续研究奠定了基础。未来将继续深化研究，
推动技术创新，为构建安全、高效的数据共享生态做出贡献。
本文设计实现的基于国密算法的分布式代理重加密系统在安全性、
高效性和适应性方面都表现出色，为分布式环境下的数据安全共享提供了有
效解决方案。随着数字经济的深入发展和数据要素价值的进一步释放，该
系统在数据共享平台、区块链系统和云计算环境等领域具有广阔的应用前
景。未来工作将围绕算法优化、功能扩展和安全增强等方面展开，进一步
提升系统的实用价值和技术水平。

3
paper/chapters/pagetitle-chinese.tex
View File

@ -47,7 +47,7 @@
\cline{2-2}
\makecell[c]{\bfseries\sihao 学\qquad 号} & \makecell[c]{\bfseries\sihao 2021212687} \\
\cline{2-2}
\makecell[c]{\bfseries\sihao 指导教师} & \makecell[c]{\bfseries\sihao 左祥建 职称} \\
\makecell[c]{\bfseries\sihao 指导教师} & \makecell[c]{\bfseries\sihao 左祥建 讲师} \\
\cline{2-2}
\makecell[c]{\bfseries\sihao 答\hspace{6pt}辩\hspace{6pt}组} \\[-2mm]
\makecell[c]{\bfseries\sihao 负\hspace{6pt}责\hspace{6pt}人} & \makecell[c]{\bfseries\sihao 姓名 职称} \\
@ -61,4 +61,3 @@
\end{center}

3
paper/latex_settings/custom-chinese.tex
View File

@ -10,6 +10,7 @@
\usepackage{caption}
\captionsetup[figure]{font=small,labelsep=space}
\captionsetup[table]{font=small,labelsep=space} %图片和表格修改caption
\usepackage{enumitem} % 列表行间距
\usepackage[final]{pdfpages}
@ -35,6 +36,8 @@
% 设置行间距 1.5倍
\linespread{1.5}\selectfont
% 设置列表间距
\setlist{itemsep=-0.3\baselineskip}
% 设置段与段之间的垂直距离 \parskip默认橡皮长度是0pt plus 1pt
\setlength{\parskip}{0pt}
\setlength{\headheight}{15pt} %设置页眉高度

1
paper/main.tex
View File

@ -42,6 +42,5 @@
\include{chapters/thanks}
% 附录
\include{chapters/appden01}
\include{chapters/appden02}
%================================
\end{document}

28
paper/reference/ref.bib
View File

@ -829,3 +829,31 @@
address = {北京},
citedate = 2025-04-18,
}
@inproceedings{Lenstra1990GNFS,
author = {Lenstra, A. K. and Lenstra, H. W. and Manasse, M. S. and Pollard, J.
M.},
title = {The number field sieve},
year = {1990},
isbn = {0897913612},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/100216.100295},
doi = {10.1145/100216.100295},
booktitle = {Proceedings of the Twenty-Second Annual ACM Symposium on Theory
of Computing},
pages = {564–572},
numpages = {9},
location = {Baltimore, Maryland, USA},
series = {STOC '90},
citedate = 2025-04-28,
}
@techreport{Wang2004Collisions,
author = {Xiaoyun Wang and Dengguo Feng and Xuejia Lai and Hongbo Yu},
title = {Collisions for Hash Functions {MD4}, {MD5}, {HAVAL}-128 and {RIPEMD}},
howpublished = {Cryptology {ePrint} Archive, Paper 2004/199},
year = {2004},
url = {https://eprint.iacr.org/2004/199},
citedate = 2025-04-28,
}

173
paper/scripts/example/shamir_example.py Normal file
View File

@ -0,0 +1,173 @@
# type: ignore
# ruff: noqa
import numpy as np
from fractions import Fraction
def generate_shamir_example(secret, t, n, a_coeffs=None):
"""
生成一个Shamir秘密共享的例子并输出LaTeX代码
参数:
secret: 需要共享的秘密整数
t: 恢复秘密所需的最小分片数
n: 总分片数
a_coeffs: 多项式系数（可选）
"""
# 如果未提供系数，则随机生成
if a_coeffs is None:
a_coeffs = [np.random.randint(1, 100) for _ in range(t - 1)]
# 确保a_coeffs长度正确
assert len(a_coeffs) == t - 1, f"系数长度应为 {t - 1}"
# 构建多项式 f(x) = secret + a_1*x + a_2*x^2 + ... + a_{t-1}*x^{t-1}
all_coeffs = [secret] + a_coeffs
# 计算每个参与者的分片
shares = []
for i in range(1, n + 1):
y = sum(all_coeffs[j] * (i**j) for j in range(t))
shares.append((i, y))
# 选择t个分片进行恢复
selected_shares = shares[:t]
# LaTeX输出
latex_output = generate_latex(secret, t, n, all_coeffs, shares, selected_shares)
return {
"secret": secret,
"polynomial": all_coeffs,
"shares": shares,
"selected_shares": selected_shares,
"latex": latex_output,
}
def lagrange_interpolation(points, x_value=0):
"""使用Lagrange插值法恢复秘密"""
result = 0
x_points, y_points = zip(*points)
# 计算每个点的拉格朗日基本多项式值并相加
for i in range(len(points)):
term = y_points[i]
for j in range(len(points)):
if i != j:
term *= Fraction(x_value - x_points[j], x_points[i] - x_points[j])
result += term
return result
def generate_latex(secret, t, n, coeffs, shares, selected_shares):
"""生成完整的LaTeX代码"""
# 构建多项式字符串
poly_str = f"{coeffs[0]}"
for i in range(1, len(coeffs)):
if coeffs[i] > 0:
poly_str += f" + {coeffs[i]}"
else:
poly_str += f" - {abs(coeffs[i])}"
if i == 1:
poly_str += "x"
else:
poly_str += f"x^{i}"
# 计算拉格朗日插值步骤
lagrange_steps = []
result = 0
for i, (x_i, y_i) in enumerate(selected_shares):
term = y_i
term_str = f"{y_i}"
for j, (x_j, _) in enumerate(selected_shares):
if i != j:
fraction = Fraction(0 - x_j, x_i - x_j)
term *= fraction
# 构建拉格朗日基本多项式的LaTeX表示
term_str += f"\\cdot\\frac{{0-{x_j}}}{{{x_i}-{x_j}}}"
# 添加简化步骤
simplified_term = int(term) if term.denominator == 1 else term
lagrange_steps.append((term_str, simplified_term))
result += simplified_term
# 生成最终的LaTeX代码
latex = f"""
举例说明：假设我们有一个秘密数字$S={secret}$，我们希望将其分割成{n}个片段，
但只需要{t}个片段就可以恢复它（即$t={t},n={n}$）：
选择一个{t - 1}次多项式（因为$t-1={t - 1}$）:
\\[f(x) = """
# 添加多项式表达式
for i in range(t):
if i == 0:
latex += f"a_{i}"
else:
latex += f" + a_{i}x^{i}"
latex += "\\]\n"
# 添加具体的多项式
latex += f"假设我们选择"
for i in range(1, t):
if i < t - 1:
latex += f"$a_{i}={coeffs[i]}$, "
else:
latex += f"$a_{i}={coeffs[i]}$"
latex += f"，那么多项式就是：\n\\[f(x) = {poly_str}\\]\n"
# 添加分片计算
latex += "为每个参与者选择一个$x$值并计算$f(x)$：\n"
for x, y in shares:
latex += f"\\[f({x}) = {' + '.join([f'{coeffs[i]}\\cdot{x}^{i}' if i > 0 else f'{coeffs[i]}' for i in range(t)])} = {y}\\]\n"
# 添加分片分配
share_str = ", ".join([f"$({x},{y})$" for x, y in shares])
latex += f"每个参与者分别得到一个片段：{share_str}。\n"
# 添加恢复秘密的说明
latex += f"要恢复秘密，我们可以选择其中任意{t}个片段。\n"
selected_str = "和".join([f"$({x},{y})$" for x, y in selected_shares])
latex += f"假设我们选择{selected_str}，使用Lagrange插值可以计算出$f(0)={secret}$，从而恢复秘密。\n"
# 添加拉格朗日插值公式
latex += "具体的Lagrange插值公式为：\n"
latex += "\\[f(x) = \\sum_{i=1}^t y_i \\prod_{j=1,j\\neq i}^t \\frac{x-x_j}{x_i-x_j}\\]\n"
# 添加具体的拉格朗日插值计算
latex += f"在这个例子中，使用{selected_str}进行插值：\n"
terms = []
calculations = []
for term_str, simplified_term in lagrange_steps:
terms.append(term_str)
calculations.append(str(simplified_term))
latex += (
f"\\[f(0) = {' + '.join(terms)} = {' + '.join(calculations)} = {result}\\]\n"
)
latex += f"这就恢复出了原始的秘密值{secret}。"
return latex
if __name__ == "__main__":
# 设置的参数
my_secret = 89 # 秘密数字
threshold = 2 # 恢复秘密所需的最小分片数
total_shares = 4 # 总分片数
coefficients = [23] # 多项式系数 (除了常数项外，t-1个系数)
# 生成例子
example = generate_shamir_example(my_secret, threshold, total_shares, coefficients)
# 打印LaTeX代码
print(example["latex"])
# 验证秘密恢复是否正确
recovered_secret = lagrange_interpolation(example["selected_shares"])
assert recovered_secret == my_secret, "恢复的秘密不正确！"