python结课程序课设（RSA加密解密内附源码及结果）

励志吃菊猫的咸鱼

于 2024-03-17 17:36:26 发布

阅读量1k

点赞数 26

文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_63333972/article/details/134921626

版权

三程序设计的所需环境和遇到的问题及解决思路

摘要

随着科学技术的不断发展，密码学的深入应用以及网络数据的广泛普及，人们之间的信息交流不只局限于书信、电话，更多的是通过网络数据进行线上交流。早时的书信和电话传递信息会有信息被劫持的情况，如今信息交流依然处在，同时信息被监视和劫持依然存在，特别是商业金融、国防军事、行政司法等重要领域和部门信息泄露的风险更大。

因此，为提高信息系统和数据的安全性和保密性，防止秘密数据被不法分子破解和利用，对信息采取了加密过程。而按照作用的不同，数据加密技术可分为数据传输加密技术、数据存储加密技术、数据完整性的鉴别技术和密钥管理技术。

而本文主要针对的是数据传输加密中的RSA加密，同时在RSA加密的基础上混合一些简单的对称加密技术进行效率更高的加密，其次简单介绍一下Python语言、加密的一些发展情况、RSA加密的一些优缺点和一点简单的GUI设计和应用。

本文最终的目的是设计一个RSA混合加密的程序实现对对称密钥进行RSA加密和通过对称密钥对文本进行对称加密的效率高效的加密过程。

关键字：Python，RSA加密，对称加密，GUI

绪论

程序设计背景与目的

近百年来计算机网络的发展可谓是日新月异，不仅在科学领域广泛应用，在军事领域同样发挥了不可替代的作用，逐渐成为国防建设的一个重要方向，然而在民用领域更是作用广泛。

例如，计算机网络的发展推动了各大电子商务平台的出现，成为现代人购物的重要渠道之一。在电子商务平台的电子商务交易中，主要环境是计算机网络。在交易期间，双方会传递彼此的信息。如果不能保证网络环境的安全，就会造成信息（个人身份信息、银行卡账户）的泄露和严重的经济损失，因此，实施数据加密技术非常重要。

而数据加密是计算机系统对信息进行保护的一种最可靠的办法，它利用密码学的知识，对信息进行加密，实现真实信息的隐藏，假信息在网络中的交流传送，从而实现保护信息安全的作用，同时，在解密过程中利用密码学的原理，对信息进行还原。

然而这种信息加密与解密的现象并不只存在于电子商务，同时在VPN上也有广泛的应用——建立自己的局域网LAN。

面对数据加密如此广泛的应用，频繁且庞大的数据交流对于加密算法的安全性和效率性提出了更高的要求。所以在保证RSA加密安全性的情况下，我选择利用对称性加密提高加密的效率。

本文旨在利用RSA加密的安全性和对称加密的效率性，俩者相结合提高加密的实用性。

论文结构和内容

第一章绪论主要说明了程序设计的背景和目的，同时简单交代了数据加密的应用。
第二章相关技术介绍主要说明了Python语言的简介、加密与解密处理的简介、GUI相关知识和Tkinter库的介绍，并简单交代了Python的发展和优缺点，介绍了加密与解密的一些信息，阐述GUI的相关知识，同时介绍了Tkinter库。
第三章程序设计所需的环境和遇到的问题及解决思路主要说明了程序设计的环境构建要求，和程序设计的详解与遇到的问题，简单说明了程序设计过程中衔接的地方和逻辑，介绍了问题解决的思路
第四章程序运行和测试主要说明了程序运行的结果和运行所需要的数据
第五章结论主要说明了程序的一些作用和新的想法
第六章致谢主要说了程序设计过程中所获得的帮助以及感谢语
第七章参考文献主要说明了本文参考的一些贴和搞

程序设计的所需环境和遇到的问题及解决思路

程序设计的环境构建

程序设计与运行都需要一个环境，而我们设计的这个RSA混合对称加密程序也是需要一个环境的。

首先得配置好python环境问题，可以去python官网下载python3.7版本。

进入python官方网站，找到这个界面

点击Downloads进入界面如下图所示：

选择python3.7.9并且下载

其次为了更好的编程我们可以下载pycharm：

进入pycharm官网

找到所需的软件并下载

按照提示安装（建议安装在D盘中，没有特殊原因首选D盘，C盘是安装操作系统的盘符，也叫作系统盘，一般，我们不会在系统盘上安装其他应用程序，因为它可能会降低计算机的运行速度。）

按照提示选，并且默认选择安装，直接点击install

选的是社区版本所以可以免费使用，不用激活，可以正常的编程，运行等。其中所需的tkinter库和os库大部分pycharm自带，不需安装，如果没有的话，可以通过命令指示符cmd来pip install os（或者其他库），也可以通过快捷方式，报错地方会有提示，有几个解决方法，其中一个就是重新安装os（其他库名）库

程序设计详解与遇到的问题

此程序需要涉及到RSA算法和最简单的对称算法，所以在开始程序编写之前，首先要学一下RSA算法和程序涉及到的简单的对称算法，了解其本质。

RSA算法：RSA算法也称为非对称加密，是密码学的一种算法，他需要俩个密钥，一个是公开密钥，另一个是私有密钥，公开密钥用作加密的时候，私有密钥用作解密。简单来说就是，公开密钥是公开给人们看的，而私有密钥则是你自己知道的，不选择公开的。这可以看作是一个被锁住的邮箱，邮箱地点大家都知道，所有人都可以给那个邮箱投稿，给那个邮箱投稿就相当于公开密钥加密的过程，邮箱就相当于公开密钥，但是打开邮箱的过程可以看作是私有密钥解密的过程，钥匙就是私有密钥。因此只有拿着钥匙的人才可以打开那个邮箱，看到里面的内容。

RSA的加密与解密过程其实可以分别通过一个通式来表达：

明文：需要加密的内容，称为明文。（注意：此公式的明文是指需要加密的文本对应的ASCII值，所以文本需要转换！！！！！！）

密文：使用密钥把明文加密后的内容。只能用相应的另一个密钥才能解密得到原来的明文。甚至连最初用来加密的密钥也不能用作解密。（注意：解密之后的信息是明文ASCII值，需要转换！！！！！！）

公钥对：（E，N）

私钥对：（D，N）

N=p*q

(p,q是俩个互质数，(质数：大于1的自然数中，除了1和它本身以外没有其他因子的自然数)建议p和q取值不要太小，否则容易被破解，一般N足够大，大概1024足矣，基本上不可能从公钥信息推出私钥信息)

L = (p-1) * (q-1)

(欧拉函数，既取（p-1）和（q-1）的最小公倍数）

1 < E < L

（E为质数且不是L的因子，即E是一个比1大比L小的数，E和L的最大公约数是1，E可能有多种取值，不必惊讶，选一个就行，python支持大整数运算，所以选取的时候可以随心一点）

( D * E ) % T = 1

(D是由E算出来的，D必须保证足够大）

小结：

p,q	p,q均为质数，且互质
N	*N = p q ，N为质数之积**
L	*L = （p-1）（q-1），L是欧拉函数**
E	1 < E < L ，E是公钥
D	*( D E ) % L = 1 ，D为私钥**

因此，解决RSA算法的首要前提是选取俩个互质的p，q,然后通过互质的p,q计算质数之积N和欧拉函数L，再通过欧拉函数L与公钥E的关系计算E，最后通过公钥E和欧拉函数计算私钥D。

简单的对称加密：是采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密。虽然此加密方法速度快，效率高，但是安全性低，密钥需要先协商好，容易被破解，引发信息泄露风险。

对称加密的常用算法有：DES、3DES、TDEA、Blowfish、RC2等等

而本程序采用的是最简单的对称加密法，加密过程是通过把需要的加密的文本先转换成ASCII值，再在这的基础上面加上密钥，在把它转换成对应的汉字，解密则恰好相反，先把汉字通过ord(i)转为ASCII值，再把加进来的密钥减去，就能得到对应文本的ASCII值，通过chr(i)转回来就行（值得注意的是，首先要判断转化为ASCII的值是不是为10，若是10的话，就不用加上密钥或者减去密钥，因为ord（i）== 10 ，所以i是换行，不用加密）。

程序设计思路

此程序目的是对文本进行加密与解密，同时可以对文件进行加密修改和解密查看。而单纯的RSA加密算法效率太低，因此引入对称加密来优化效率，简单来说就是通过混合RSA算法和对称加密算法形成新的算法来安全快速的加密与解密。

其中RSA算法是对对称加密的对称密钥进行加密与解密，解决了对称密钥的安全问题，而对称加密则是对所需加密的明文进行加密，解决了RSA文本加密的效率低问题。通过窗体结构的模式，直观真实的提高程序运行的感受。

程序设计的过程

通过import 模块，直接引入函数库，调用其中的函数时则需要在前面加上模块名 . 。并且模块名可以简化成用户觉得使用方便的名称，例如名称太长可以简化成几个字母，不过需要注意的是，不要和设置的变量的重名了。

通过from 模块名 import * ,这种方式引入模块时可以直接使用其中的函数

以上俩种引入了包含所有的函数，有时候我们只会用其中一个或几个函数，这时候我们可以from 模块名 import 函数名

为了更直观的感受引入的方式多样化，本文程序除了from模块名 import as 未使用以外，分别使用了以上几种引入方式，因为import * 存在很大的隐患，若是多个函数库里面有名字相同的函数时，就难以区分函数最终来自哪个函数库。

建立俩个互质的数p和q

自己建立一个creat_zhishu()函数，函数内部是一个自然生成一个随机数并且判断生成的数是不是质数的过程。利用random函数库里面的randint(a,b)随机在4-180中生成一个数，然后判断是否是质数，若是则返回质数，不是则继续生成。（注意注意：函数括号里面须有参数，若是没有定义参数则是默认参数，多个参数可以采用*加参数的方式，这是可变参数，简单来叔就是参数个数可变。**加参数则是关键字参数！！！！！！）

creat_zhishu()函数首先利用while生成一个死循环，只有返回值不是True才能跳出循环，然后利用random这个随机数生成模块中的randint(a,b),随机返回一个[a,b]的整数，简单来说就是在[a,b]范围内随机生成一个数，然后通过if语句判别生成的数是否是质数，其中if 判别过程是通过一个check_zhishu(zhishu)的函数来进行的，zhishu就是联结check_zhishu()的桥梁,将zhishu的值代check_zhishu中去判断。

因为zhishu既是自变量又是传入check_zhishu()的实参，而check_zhishu()中zhishu又是是实参，所以zhishu的值就是原来的值，而check_zhishu()首先通过一个for循环来依次取从2开始到zhishu-1值对应的数，需要注意的是range(a,b)中范围是[a,b),b不取的。将zhishu除去取得的每个数，看余数是否为0，其实%是取余的意思,得到的结果是余数。(/是正常的除，//是整除的意思)若所有的余数都是0，则check_zhishu()返回False，所以creat_zhishu()返回zhishu的值，若是余数有一个不为0，则check_zhishu()返回True，所以creat_zhishu()得重新随机形成一个新的数，再判断是否为质数。

设置欧拉函数

由前面可得p，q为质数，及也可以互质，设个oulahanshu()函数来计算欧拉函数，通过参数p，q，返回欧拉函数值((p-1)*(q-1))。（注意返回的是一个字符串！）

形成公钥

还是设置一个gong_yao()函数，由公钥关系公式知，公钥是一个质数且不是欧拉函数的因子，所以再利用while的死循环来解决公钥的取值，利用参数是实参oula的便捷性，将其值赋给定义的变量top，在从2开始取到top-1，如果满足下面的要求的话，那么i就是公钥。

其中要注意的是为了提高便利性，又设置了一个新的check_huzhi()函数，传入实参i和top，利用if语句和互质的前提余数为0来对传入的i和top进行判断。

同前面一样，需要都满足余数为0，才能跳出gong_yao()函数中while的循环，返回公钥i。

形成私钥

前面知道的私钥的关系式，设置新的si_yao()函数，传入实参oula和gongyao（注意：目前给出的条件中还没有出现gongyao这个变量，更不用说实参了，但是gongyao在下文会有，所以不必惊讶），通过while循环的特点和私钥关系式的特点。逐一计算私钥可能的值！当不符合要求时，siyao就加1，逐渐增大，直到满足要求。那么从这里就可以看出，公钥推出私钥的难度很大，所以RSA算法的安全性远远高于对称加密的安全性。

确保只进行一次公钥和私钥的运算

我们只要求计算一次公钥与私钥就行了，所以还要进行次数统计。可以通过设置yx_yici()函数来保证公私钥形成的次数。

其实通过设置一个函数是为了更好更直观的看出公私钥计算的过程。首先可以选择对俩次调用creat_zhishu()函数，生成俩个随机质数，判断若是p和q要是相等，则q在重新调用函数赋值。

也可以通过将p的值直接赋给q再利用while循环。

然后算出质数之积n,调用oula_hanshu(p,q)算出oula值，调用gong_yao (oula)算出gongyao，调用si_yao(oula,gongyao)算出siyao，在逐一返回其值。

然后再利用一个if的判断语句，将公钥，私钥，和质数之积分别输出。其中很重要的一点是三个值得记住，特别是私钥！！！这也是我设置一个if语句输出的原因。

自此，RSA算法的公钥、私钥以及质数之积已经求出来了。接下来就只需要对窗体布局和具体加密公式的设置，需要注意的是窗体布局是一个全局问题，所以顺序可能不一样。

建立窗口

前面已经调用了tkinter的函数库和简单介绍了怎么对窗体进行布局。先通过tkinter.Tk()创建一个tk窗口，然后通过tk.gemotry对窗口的大小进行设置，为了更方便的输入和观察，我将窗口大小设成(“500x750”)的，同时通过tk.title对窗口命名，名为“RSA算法加密对称密钥，对称加密加密文本”。

对对称密钥进行RSA加密

先设立一个RSAjmpd的变量，保证对对称密钥只进行一次加密。然后设置RSA_jiami(*o)(注意可变参数！！！)，将RSAjmpd转为全局变量(全局变量：可以被本程序所有对象或函数引用)，通过if语句来判定需不需要对对称密钥加密，然后定义一个空列表存放RSA加密后的对称密钥，之后通过get将iitext(窗口中文本框接受的信息赋值结果)值赋值给keey，其中要注意的是get得到的是从第一行下标为0的元素到最后一个元素，也就是全部获取并复制给keey，这里可以通过一个print()输出，看对称密钥的赋值是否出现错误。

再定义一个新的列表newkey储存对称密钥对应的ASCII值，通过for循环逐一遍历keey，然后判断是否有换行，（其实这里应该可以不用判断，因为是人为控制对称密钥的输入），最后将对应的ASCII值通过append扩展进newkey中(这里append会带来问题，后面会解决)。

然后如法炮制的将公钥和质数之积分别赋值给ikey和new，（同样可以输出看看对应的ASCII值、公钥和质数之积是否正确。）

通过len()计算newkey的长度，（一般字符串和列表都能够计算长度）再利用for语句和try-except语句进行对称密钥的RSA加密,（注意！！！！利用try试错是一个很重要的步骤，可以检查问题所在）同时可以通过输出加密后的对称密钥的类型和值，从而为下面的程序做准备。

因为加密后的对称密钥是一个列表，而我们输出的必须是一个字符串，所以还要经过去除列表中括号和直接转换为字符串的操作。又append会在添加的元素前面自动加一个“ ”的原因，所以需要通过replace(a,b)将a替换成b的效果解决问题。

同时因为文本输入框的信息需要被修改，才能将加密过后的对称密钥在屏幕上面展现出来，所以就得用delete()将文本框里面的所有信息删掉，然后再利用insert()插入新的加密后的信息，(注意信息得是字符串！！！)最后将RSAjmpd的值改成True。

同时若是加密过一次，则会输出“程序已经加密一次，不需加密第二次”

对称加密加密文本

同前面一样先设一个保险，保证加密只进行一次。

也需要设置一个jiamihanshu()函数，key获取对称加密密钥，将jmpd和erro设为全局变量，其中的erro是判断加密错误的原因的。

我们可以规定对称密钥的长度限度，通过if语句来控制程序的运行，然后text由从文本框得到信息的itext赋值，建立一个新的字符串存储加密后的文本。

建立空列表newkey储存对称密钥对应的ASCII值。

先定义一个计数的js变量，目的是解决对称密钥长度与文本长度不一致的问题。由前面简单的对称加密知识可知，加密过程中需要特别关注一个点，那就是文本中的换行。因为机器加密过程中是不会自动换行的，所以需要避开那个问题，就得利用if语句的便利性。(注意文本也需转换为ASCII 值，才可以进行加密运算，至于文本中的换行问题，前面有说）

又因为对称密钥长度和文本长度不一致，所以就需要再对称密钥形成一个循环，简单来说就是对称密钥长度索引值js超出对称密钥长度时，对称密钥对应的索引值js从头再来，而文本的遍历继续增大。

同时还有一个当对称密钥输入格式不对时，造成的影响，不会直接报错，但是会有一个输出提醒。

同样文本需要删除之前的所有信息，插入新的信息。Jmpd值也需要修改。

加密窗口的布局

首先先命名单行文本显示的标签并且定位在水平起始位置10像素和垂直位置0像素的地方，注意其中的tk是为了将控件规定在tk的窗口中，而不是其他窗口

布局公钥输入的控件，先利用Label命名并固定在水平10像素，垂直30像素的地方，在通过StringVar建立ik的字符串变量，同时单行文本输入框Entry的值在输入之后又赋给了iikey，以便加密计算，其中Entry内部还含有其他属性，比如textvarible是为了将变量ik跟文本捆绑在一起，跟踪变量的值变化，保证值的变更随时可以显示在窗口上。而width则是文本控件的宽，此控件宽为36行。最后定位。

依次布局输入质数之积的控件和加密对象的控件，其中加密对象的输入框控件高10行。

然后通过按钮Button控件来触发事件，通过command参数绑定RSA_jiami函数（特别注意！！！！command=的是一个函数名，而不是一个函数调用，而函数名是函数指针，这里需要的是函数名，而不是一个回调函数RSA_jiami()，若是这里的command等于的是一个回调函数，那么程序会在你未输入任何东西之前就先运行一次，更糟糕的是此次运行的返回值是一个None，因此无论如何按动鼠标，都无法触发事件，也就不会有加密的过程），即当按钮事件触发时就执行RSA_jiami 函数。

再如法炮制般布局对称加密的控件，只需要注意控件的摆放。

自此一个完整的文本加密窗口就完成了，接下来就是解密和文件加密与解密。

对对称密钥的RSA解密

RSA解密对称密钥和RSA加密对称密钥差不多，先上保险然后设置空的列表nnewkey和dcmy来分别储存新的对称密钥对应的ASCII值和对称密钥，不过需要注意的是，加密后的对称密钥输入进来是字符串，若是直接取其长度用来索引，会造成很大的麻烦，因为我们无法估测出数字与符号之间的距离，所以需要用split(“,”)去掉逗号，也可以输出检查。

以同样的方法获取需要的信息，再通过私钥，质数之积和加密后的对称密钥之间的关系式算出对称密钥的ASCII值，并判断并输出一些程序出错的原因。

需要注意的是解密后的值是对称密钥对应的ASCII值，所以我们还需要通过chr(i)和for循环的遍历来进行转换。

然后输出的只能是字符串，所以还得通过for语句对对称密钥进行字符串转换。

转完之后就是删除信息和插入信息

并输出解密多次的提示以及保险的值改变

对称解密解密文本

与对称加密非常相似，只要把对称密钥的ASCII值减去就行。

解密窗口的布局

同加密窗口布局一样操作，只需要注意command=是一个函数名，而不是回调函数。

文件加密与解密

首先还是先命名一个新的窗口和设定窗口的大小

先定义文件路径和内容的变量，然后布局文本输入框控件，其中font是控制字体的属性，字体名字有严格要求，不能随便自己造，Arial是等线体，并且设置其字体大小为12。需要注意的是这里我们没有使用place来定位控件的位置，而是通过pack(默认先使用的放到上面，然后依次向下排列，默认方式它会给我们的组件一个自认为合适的位置和大小)来布局，极大的减轻了我们控件摆放的时间。

通过设置open_file()函数来实现文件打开的过程，老样子，先将file_path和file_text转为全局变量，这样才能调用。而活得文件路径则是通过tkinter中的filedialog(一般是打开文件，保存文件和选择目录等关于文件操作的首选)对话框来打开文件，通过filedialog函数中askopenfilename函数来打开用户文件窗口，并且将窗口命名为“打开文件”，然后选择所需文件，后程序自动返回文件路径。

如果文件路径里面没信息，则通过with open as file 将文件用“utf-8”进行重新进行转换，再读写(r+是既进行读也可以改写)，所以文件file路径还是原路径，只是加了信息，后读写的文件信息传递给file_text,通过insert的特点将信息插入。

通过设置save_file()函数来进行保存文件的操作。这里可以不用进行全局变量的转换，因为前面已经执行过了。同前面一样，利用asksavefilename函数的特点打开一个窗口选择保存路径后返回保存到路径。同样可以选择输出保存路径。

先获取文本输入框的信息。注意tkinter.END效果和“end”一样，而且通过“a+”实现打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

至于文件加密和解密就是简单的对称加密和解密，所以同前面一样，只需要修改一下其中的变量。

然后就是控件布局，注意command所关联的函数就行，特别注意command的要求！其中“输入公钥就是输入对称密钥”

最后通过mainloop将窗口呈现出来。

自此所有的程序设计就完结了，接下来只需要对程序运行进行数据测试就行了。

程序运行及测试

运行实例：

文本加密数据(公钥3，私钥1083，质数之积1711，加密对象123456)输入后：

数据(对称密钥123456，文本python课设好难啊)输入后：

文件加密数据(文件python文件练习专用文件.txt，加密密钥123456)：

数据测试结果如上所示，所测结果一切正常顺利

结论

程序设计过程中任有不足之处，例如程序过于繁琐，设计的函数过多，没有充分利用之间的关联性解决函数多的问题，同时，程序一运行就会同时出现三个窗口，还没有解决需要运行哪个就执行哪个的要求。不过总的来说，还是不错的，解决了一些安全性和效率性问题。

参考文献

Python的特点（优点和缺点） (biancheng.net)http://c.biancheng.net/view/4129.html

TIOBE Index - TIOBEhttps://www.tiobe.com/tiobe-index/

(83条消息) 加密技术和的发展与变革_cnsinda_sdc的博客-CSDN博客https://blog.csdn.net/cnsinda_sdc/article/details/122035857

(84条消息) GUI是什么_风清竹叶青的博客-CSDN博客_什么是guihttps://blog.csdn.net/weixin_43160039/article/details/82942107?ops_request_misc=&request_id=&biz_id=102&utm_term=GUI&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-1-82942107.142%5Ev24%5Ehuaweicloudv2,157%5Ev15%5Enew_3&spm=1018.2226.3001.4187

(84条消息) Python-Tkinter图形化界面设计（详细教程）_王张飞的博客-CSDN博客_tkinter界面https://blog.csdn.net/RNG_uzi_/article/details/89792518?ops_request_misc=%7B%22request_id%22%3A%22165640612416781667829362%22%2C%22scm%22%3A%2220140713.130102334..%22%7D&request_id=165640612416781667829362&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-89792518-null-null.142%5Ev24%5Ehuaweicloudv2,157%5Ev15%5Enew_3&utm_term=tkinter&spm=1018.2226.3001.4187

(84条消息) RSA加密算法原理_张维鹏的博客-CSDN博客_rsa加密算法原理https://blog.csdn.net/a745233700/article/details/102341542

源码

# 源代码
# RSA非对称加密与对称加密混合加密算法
import tkinter#调用tkinter函数库
import random as rd# 调用random库并将random简化成rd
from tkinter import filedialog# 只调用tkinter库中的filedialog
# import os

# 建立质数
def creat_zhishu():
    while True:
        zhishu=rd.randint(18,1800)#质数起点设置高一点，让私钥数更大不容易被破解
        if check_zhishu(zhishu):
            # print("质数是",zhishu)
            return zhishu

# 判断是否为质数
def check_zhishu(zhishu):
    for i in range (2,zhishu):
        if zhishu % i == 0 :
            return False
    return True

# 判断是否互质
def check_huzhi(i,top):
    for e in range (2,i+1):
        if i % e == 0 and top % e == 0:# 互质是公约数只有1的两个整数，叫做互质整数。
            return False
    return True

# 设置欧拉函数
def oulahanshu(p,q):
    return (p-1)*(q-1)

# 设置公钥   条件：1<公钥<oula,质数,不是欧拉函数的因子（用互质来代替）
def gong_yao(oula):
    top=oula
    while True:
        for i in range (2,top):
            if check_huzhi(i,top):
                return i

# 设置私钥
def si_yao(oula,gongyao):
    siyao=1
    while (siyao*gongyao)%oula != 1:
        siyao+=1
    return siyao

# 对对称密钥进行RSA加密
RSAjmpd=False
def RSA_jiami(*o):
    global RSAjmpd
    if RSAjmpd == False :
        newkey = []
        nnewkey=[]
        keey = iitext.get("1.0", "end")
        # print("对称密钥是：",keey)
        for i in keey:
            if ord(i) != 10 :
                newkey.append(ord(i))
        ikey=iikey.get()
        new=newn.get()
        # print("对称密钥对应的ASCII值为：",newkey)
        # print("公钥是：",ikey)
        # print("质数之积是：",new)
        lnewkey=len(newkey)
        for i in range (lnewkey):
            try :
                nnewkey.append((newkey[i]**int(ikey))%int(new))
            except :
                print("程序崩溃")
        # print(nnewkey)
        # print(type(nnewkey))
        nnewkey = str(nnewkey)[1:-1]
        nnewkey = nnewkey.replace(" ","")
        iitext.delete("1.0","end")
        iitext.insert("insert",nnewkey)
        RSAjmpd=True
    else :
        print("程序已经加密一次，不需加密第二次！")

#对称加密文本
jmpd=False #为了防止点击多次加密出现bug
#加密算法,参数：秘钥，文本
def jiamihanshu():#设置加密函数
    key=ikey.get()#将输入的“密钥”全部传给key
    global jmpd,erro#将jmpd,erro设成全局变量，方便调用和修改
    erro="输入的密钥没有遵循规则，不能实现加密处理！！！"#用来判断加密错误
    if len(key)>2 and len(key)<10 and jmpd == False:#规定输入的“密钥”长度应该在3-10之间，并且保证只点击了一次“加密”，解决多次点击出现重复”加密“的问题
        text=itext.get(1.0, 'end')#从itext的第一行下标为0的元素到最后一个元素全部复制给新变量text
        newtext=''#建立一个newtext的变量储存“加密”后的文本
        #将key转化成ascii码列表
        newkey=[]#建立一个新的变量储存key对应的ascii值
        for i in key:#遍历“密钥”，将key值转化为ascii表
            newkey.append(ord(i))#转化成功之后的ascii表一个一个添加到新的
        js=0
        for i in text:#遍历输入的“文本”
            if ord(i)!=10:#判断”文本“中是否存在ascii值为10的特殊情况
                newtext=newtext+chr(ord(i)+newkey[js])#关键部分，加密公式
            else:
                newtext=newtext+chr(10)#特殊情况的加密公式
            js+=1#输入的”密钥“ascii值下标加1，
            if js >= len(newkey):#保证js的最大值不会超过newkey中最后一个元素的下标，不会越界
                js=0#重置js的值
    elif len(key) <= 2 or len(key) >= 10 and jmpd :#判断加密错误
        print(erro)#输出加密错误原因
        return
    else :#输出其他错误
        print("其他错误")
        return
    itext.delete("1.0", 'end')#删除itext中原本储存的”文本“信息
    itext.insert('insert', newtext)#在itext插入”加密“以后的”文本“
    jmpd=True

# 对对称密钥进行RSA解密
RSAjiemipd=False
def RSA_jiemi(*o):
    global RSAjiemipd
    if RSAjiemipd == False :
        nnewkey=[]
        dcmy=[]
        miyao=""
        yushu = dcmiyao.get("1.0", "end")
        # print(yushu)
        listyushu = yushu.split(",")
        # print(type(listyushu))
        # print(listyushu)
        # print("对称密钥RSA加密后的余数为:",listyushu)
        newsiyao=siyao.get()
        # print("私钥是：",newsiyao)
        new=newn2.get()
        # print("质数之积是：",new)
        lyushu=len(listyushu)
        for i in range (lyushu):
            print(listyushu[i])
            try :
                nnewkey.append((int(listyushu[i])**int(newsiyao))%int(new))
            except :
                 print("程序崩溃")
                 break
        # print(nnewkey)
        for i in nnewkey :
            dcmy.append(chr(i))
        for i in range(len(dcmy)):
            miyao+=str(dcmy[i])
        dcmiyao.delete("1.0","end")
        dcmiyao.insert("insert",miyao)
    else :
        print("程序已经解密一次，不需解密第二次！")
    RSAjiemipd = True

#对称解密
jiemipd=False #为了防止点击多次解密出现bug
#解密算法,参数：秘钥，文本
def jiemihanshu():#建立解密函数
    key=newikey.get()#保证加密密钥与解密密钥一致
    global jiemipd
    if len(key)>2 and len(key)<10 and jiemipd == False:
        text=newitext.get(1.0, 'end')
        text2=''
        #将key转化成ascii码列表
        newkey=[]
        for i in key:
            newkey.append(ord(i))
        ii=0
        for i in text:
            if ord(i)!=10:
                text2=text2+chr(ord(i)-newkey[ii])#关键部分，解密公式
            else:
                text2=text2+chr(10)
            ii=ii+1
            if ii>=len(newkey):
                ii=0
        newitext.delete(1.0, 'end')
        newitext.insert('insert', text2)
    else :
        print("解密重复或者密钥不合要求")
    jiemipd=True

def open_file():
    global file_path
    global file_text
    file_path = filedialog.askopenfilename(title='选择文件')
    # print('打开文件：', file_path)#输出打开文件的路径
    if file_path is not None:
        with open(file=file_path, mode='r+', encoding='utf-8') as file:
            file_text = file.read()
        text1.insert('insert', file_text)

def save_file():
    # global file_path
    # global file_text
    file_path = filedialog.asksaveasfilename(title='保存文件')
    # print('保存文件：', file_path)
    file_text = text1.get('1.0', tkinter.END)
    if file_path is not None:
        with open(file=file_path, mode='a+', encoding='utf-8') as file:
            file.write(file_text)
        text1.delete('1.0', tkinter.END)
        print('保存完成')

#对称加密文本
jmpd2 = False #为了防止点击多次加密出现bug
#加密算法,参数：秘钥，文本
def wbjiamihanshu():#设置加密函数
    key=iikeyy.get()#将输入的“密钥”全部传给key
    global jmpd2,erro#将jmpd,erro设成全局变量，方便调用和修改
    erro="输入的密钥没有遵循规则，不能实现加密处理！！！"#用来判断加密错误
    if len(key)>2 and len(key)<10 and jmpd2 == False:#规定输入的“密钥”长度应该在3-10之间，解决多次点击出现重复”加密“的问题
        text=text1.get(1.0, 'end')#从text1的第一行下标为0的元素到最后一个元素全部复制给新变量text
        newtext=''#建立一个newtext的变量储存“加密”后的文本
        #将key转化成ascii码列表
        newkey=[]#建立一个新的变量储存key对应的ascii值
        for i in key:#遍历“密钥”，将key值转化为ascii表
            newkey.append(ord(i))#转化成功之后的ascii表一个一个添加到新的
        js=0
        for i in text:#遍历输入的“文本”
            if ord(i)!=10:#判断”文本“中是否存在ascii值为10的特殊情况
                newtext=newtext+chr(ord(i)+newkey[js])#关键部分，加密公式
            else:
                newtext=newtext+chr(10)#特殊情况的加密公式
            js+=1#输入的”密钥“ascii值下标加1，
            if js >= len(newkey):#保证js的最大值不会超过newkey中最后一个元素的下标，不会越界
                js=0#重置js的值
    elif len(key) <= 2 or len(key) >= 10 and jmpd :#判断加密错误
        print(erro)#输出加密错误原因
        return
    else :#输出其他错误
        print("其他错误")
        return
    text1.delete(1.0, 'end')#删除itext中原本储存的”文本“信息
    text1.insert('insert', newtext)#在itext插入”加密“以后的”文本“a
    jmpd2=True

#对称解密
jiemipd2=False #为了防止点击多次解密出现bug
def wbjiemihanshu():#建立解密函数
    key=iikeyy.get()#保证加密密钥与解密密钥一致
    global jiemipd2
    if len(key)>2 and len(key)<10 and jiemipd2 == False:
        text=text1.get(1.0, 'end')
        text2=''
        #将key转化成ascii码列表
        newkey=[]
        for i in key:
            newkey.append(ord(i))
        ii=0
        for i in text:
            if ord(i)!=10:
                text2=text2+chr(ord(i)-newkey[ii])#关键部分，解密公式
            else:
                text2=text2+chr(10)
            ii=ii+1
            if ii>=len(newkey):
                ii=0
        text1.delete(1.0, 'end')
        text1.insert('insert', text2)
    jiemipd2=True


# 开始生成公钥，私钥，质数之积
def yx_yici():# 只允许运行一次，产生对应的公钥和私钥，多次运行会形成多对公私钥
    p = creat_zhishu()
    q = p
    # q = creat_zhishu()
    while p == q:
        q = creat_zhishu()
    n = p * q
    oula = oulahanshu(p, q)
    gongyao = gong_yao(oula)
    siyao = si_yao(oula, gongyao)
    return p, q, gongyao, siyao, n, oula

# 判断生成公钥，私钥，质数之积的次数
# print("加密程序请输入： 0")
# print("是否确认加密：",end="")
print("1:进行此程序")
print("2:退出")
print("输入指令：",end="")
jishu = int(input())
if  jishu == 1 :
    gsn=yx_yici()
    gongyao=gsn[2]
    siyao=gsn[3]
    n=gsn[4]
    print("---" * 50)
    print("输出重要信息：")
    print("1：公钥是：",gongyao)
    print("2：千万要记住!!!!!!!!!!私钥是：",siyao)
    print("3：质数之积：",n)
    print("---" * 50)
    # 判断是什么类型的程序任务
    print("1：加密", end="\n")
    print("2：解密", end="\n")
    print("3：文本加密与解密", end="\n")
    print("4:同时进行加密解密", end="\n")
    print("5:同时进行文本加密解密与输入型加密解密", end="\n")
    print("6:退出", end="\n")
    print("输入想要完成的操作：", end="")
    work = int(input())
    if work == 1 :
        # 建立窗口
        tk = tkinter.Tk()  # 创建tk窗口
        tk.geometry("500x750")  # 设置窗口的大小
        tk.title('RSA算法加密对称密钥，对称加密加密文本')  # 给窗口命名为“RSA算法加密对称密钥，对称加密加密文本”

        # 对窗口命名
        tkinter.Label(tk, text='------------------------------------RSA 加 密------------------------------------').place(
            x=10, y=0)

        # 设置秘钥
        tkinter.Label(tk, text="请输入公钥").place(x=10, y=30)  # 添加标签并命名标签，固定标签的位置
        ik = tkinter.StringVar()  # 建立变量ik为字符串变量
        iikey = tkinter.Entry(tk, textvariable=ik, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        iikey.place(x=150, y=30)

        # 设置质数之积
        tkinter.Label(tk, text="请输入质数之积").place(x=10, y=60)  # 添加标签并命名标签，固定标签的位置
        ik2 = tkinter.StringVar()  # 建立变量ik为字符串变量
        newn = tkinter.Entry(tk, textvariable=ik2, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        newn.place(x=150, y=60)

        # 输入要加密的文本
        tkinter.Label(tk, text="请输入要加密的对象").place(x=10, y=100)  #
        iitext = tkinter.Text(tk, width=36, height=10)
        iitext.place(x=150, y=100)

        # 点击加密
        tkinter.Button(tk, text='点击加密', width=14, command=RSA_jiami).place(x=10,
                                                                           y=198)  # 设置按钮控件，命名为“点击加密”，用command参数绑定jiamihanshu函数

        # 设置加密窗口的名称
        tkinter.Label(tk, text='------------------------------------对 称 加 密------------------------------------').place(
            x=10, y=250)

        # 设置秘钥
        tkinter.Label(tk, text="请输入3-9位的秘钥").place(x=10, y=280)  # 添加标签并命名标签，固定标签的位置
        ik = tkinter.StringVar()  # 建立变量ik为字符串变量
        ikey = tkinter.Entry(tk, textvariable=ik, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        ikey.place(x=150, y=280)

        # 输入要加密的文本
        tkinter.Label(tk, text="请输入要加密的文本").place(x=10, y=350)  #
        itext = tkinter.Text(tk, width=36)
        itext.place(x=150, y=350)

        # 点击加密
        tkinter.Button(tk, text='点击加密', width=14, command=jiamihanshu).place(x=10,
                                                                             y=448)  # 设置按钮控件，命名为“点击加密”，用command参数绑定jiamihanshu函数
        tk.mainloop()

    elif work == 2 :
        tk2 = tkinter.Tk()
        tk2.title("RSA解密")
        tk2.geometry("500x750")

        tkinter.Label(tk2,
                      text='------------------------------------RSA 解 密------------------------------------').place(
            x=10, y=0)

        # 设置秘钥
        tkinter.Label(tk2, text="请输入私钥").place(x=10, y=30)  # 添加标签并命名标签，固定标签的位置
        ik = tkinter.StringVar()  # 建立变量ik为字符串变量
        siyao = tkinter.Entry(tk2, textvariable=ik, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        siyao.place(x=150, y=30)

        # 设置质数之积
        tkinter.Label(tk2, text="请输入质数之积").place(x=10, y=60)  # 添加标签并命名标签，固定标签的位置
        ik2 = tkinter.StringVar()  # 建立变量ik为字符串变量
        newn2 = tkinter.Entry(tk2, textvariable=ik2, width=36)  # 将变量ik2跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        newn2.place(x=150, y=60)

        # 输入要加密的文本
        tkinter.Label(tk2, text="请输入要解密的对象").place(x=10, y=100)  #
        dcmiyao = tkinter.Text(tk2, width=36, height=10)
        dcmiyao.place(x=150, y=100)

        tkinter.Button(tk2, text='点击解密', width=14, command=RSA_jiemi).place(x=10,
                                                                            y=198)  # 设置按钮控件，命名为“点击加密”，用command参数绑定jiamihanshu函数

        # 设置秘钥
        tkinter.Label(tk2, text="请输入3-9位的秘钥").place(x=10, y=280)
        ik2 = tkinter.StringVar()
        newikey = tkinter.Entry(tk2, textvariable=ik2, width=36)
        newikey.place(x=150, y=280)

        # 输入要解密的文本
        tkinter.Label(tk2, text="请输入要解密的文本").place(x=10, y=350)
        newitext = tkinter.Text(tk2, width=36)
        newitext.place(x=150, y=350)

        # 点击解密
        tkinter.Button(tk2, text='点击解密', width=14, command=jiemihanshu).place(x=10, y=448)
        tk2.mainloop()

    elif work == 3 :
        window = tkinter.Tk()
        window.title('文件加密与解密')  # 标题
        window.geometry('500x500')  # 设置窗口尺寸
        file_path = ''  # 定义路径
        file_text = ''  # 定义文件内容
        text1 = tkinter.Text(window, width=50, height=10, font=('Arial', 12))
        text1.pack()

        # 设置秘钥
        n = tkinter.Label(window, text="请输入公钥")
        n.pack()
        ik = tkinter.StringVar()  # 建立变量ik为字符串变量
        iikeyy = tkinter.Entry(window, textvariable=ik, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        iikeyy.pack()

        bt1 = tkinter.Button(window, text='打开文件', width=15, height=2, command=open_file)
        bt1.pack()
        bt2 = tkinter.Button(window, text='保存文件', width=15, height=2, command=save_file)
        bt2.pack()
        bt3 = tkinter.Button(window, text='加密文件', width=15, height=2, command=wbjiamihanshu)
        bt3.pack()
        bt4 = tkinter.Button(window, text='解密文件', width=15, height=2, command=wbjiemihanshu)
        bt4.pack()
        window.mainloop()  # 显示窗口

    elif work == 4 :
        # 建立窗口
        tk = tkinter.Tk()  # 创建tk窗口
        tk.geometry("500x750")  # 设置窗口的大小
        tk.title('RSA算法加密对称密钥，对称加密加密文本')  # 给窗口命名为“RSA算法加密对称密钥，对称加密加密文本”

        # 对窗口命名
        tkinter.Label(tk, text='------------------------------------RSA 加 密------------------------------------').place(
            x=10, y=0)

        # 设置秘钥
        tkinter.Label(tk, text="请输入公钥").place(x=10, y=30)  # 添加标签并命名标签，固定标签的位置
        ik = tkinter.StringVar()  # 建立变量ik为字符串变量
        iikey = tkinter.Entry(tk, textvariable=ik, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        iikey.place(x=150, y=30)

        # 设置质数之积
        tkinter.Label(tk, text="请输入质数之积").place(x=10, y=60)  # 添加标签并命名标签，固定标签的位置
        ik2 = tkinter.StringVar()  # 建立变量ik为字符串变量
        newn = tkinter.Entry(tk, textvariable=ik2, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        newn.place(x=150, y=60)

        # 输入要加密的文本
        tkinter.Label(tk, text="请输入要加密的对象").place(x=10, y=100)  #
        iitext = tkinter.Text(tk, width=36, height=10)
        iitext.place(x=150, y=100)

        # 点击加密
        tkinter.Button(tk, text='点击加密', width=14, command=RSA_jiami).place(x=10,y=198)  # 设置按钮控件，命名为“点击加密”，用command参数绑定jiamihanshu函数

        # 设置加密窗口的名称
        tkinter.Label(tk, text='------------------------------------对 称 加 密------------------------------------').place(
            x=10, y=250)

        # 设置秘钥
        tkinter.Label(tk, text="请输入3-9位的秘钥").place(x=10, y=280)  # 添加标签并命名标签，固定标签的位置
        ik = tkinter.StringVar()  # 建立变量ik为字符串变量
        ikey = tkinter.Entry(tk, textvariable=ik, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        ikey.place(x=150, y=280)

        # 输入要加密的文本
        tkinter.Label(tk, text="请输入要加密的文本").place(x=10, y=350)  #
        itext = tkinter.Text(tk, width=36)
        itext.place(x=150, y=350)

        # 点击加密
        tkinter.Button(tk, text='点击加密', width=14, command=jiamihanshu).place(x=10,
                                                                             y=448)  # 设置按钮控件，命名为“点击加密”，用command参数绑定jiamihanshu函数
        tk.mainloop()


        tk2 = tkinter.Tk()
        tk2.title("RSA解密")
        tk2.geometry("500x750")

        tkinter.Label(tk2,
                      text='------------------------------------RSA 解 密------------------------------------').place(
            x=10, y=0)

        # 设置秘钥
        tkinter.Label(tk2, text="请输入私钥").place(x=10, y=30)  # 添加标签并命名标签，固定标签的位置
        ik = tkinter.StringVar()  # 建立变量ik为字符串变量
        siyao = tkinter.Entry(tk2, textvariable=ik, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        siyao.place(x=150, y=30)

        # 设置质数之积
        tkinter.Label(tk2, text="请输入质数之积").place(x=10, y=60)  # 添加标签并命名标签，固定标签的位置
        ik2 = tkinter.StringVar()  # 建立变量ik为字符串变量
        newn2 = tkinter.Entry(tk2, textvariable=ik2, width=36)  # 将变量ik2跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        newn2.place(x=150, y=60)

        # 输入要加密的文本
        tkinter.Label(tk2, text="请输入要解密的对象").place(x=10, y=100)  #
        dcmiyao = tkinter.Text(tk2, width=36, height=10)
        dcmiyao.place(x=150, y=100)

        tkinter.Button(tk2, text='点击解密', width=14, command=RSA_jiemi).place(x=10,
                                                                            y=198)  # 设置按钮控件，命名为“点击加密”，用command参数绑定jiamihanshu函数

        # 设置秘钥
        tkinter.Label(tk2, text="请输入3-9位的秘钥").place(x=10, y=280)
        ik2 = tkinter.StringVar()
        newikey = tkinter.Entry(tk2, textvariable=ik2, width=36)
        newikey.place(x=150, y=280)

        # 输入要解密的文本
        tkinter.Label(tk2, text="请输入要解密的文本").place(x=10, y=350)
        newitext = tkinter.Text(tk2, width=36)
        newitext.place(x=150, y=350)

        # 点击解密
        tkinter.Button(tk2, text='点击解密', width=14, command=jiemihanshu).place(x=10, y=448)
        tk2.mainloop()

    elif work == 5 :

        # 建立窗口
        tk = tkinter.Tk()  # 创建tk窗口
        tk.geometry("500x750")  # 设置窗口的大小
        tk.title('RSA算法加密对称密钥，对称加密加密文本')  # 给窗口命名为“RSA算法加密对称密钥，对称加密加密文本”

        # 对窗口命名
        tkinter.Label(tk, text='------------------------------------RSA 加 密------------------------------------').place(
            x=10, y=0)

        # 设置秘钥
        tkinter.Label(tk, text="请输入公钥").place(x=10, y=30)  # 添加标签并命名标签，固定标签的位置
        ik = tkinter.StringVar()  # 建立变量ik为字符串变量
        iikey = tkinter.Entry(tk, textvariable=ik, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        iikey.place(x=150, y=30)

        # 设置质数之积
        tkinter.Label(tk, text="请输入质数之积").place(x=10, y=60)  # 添加标签并命名标签，固定标签的位置
        ik2 = tkinter.StringVar()  # 建立变量ik为字符串变量
        newn = tkinter.Entry(tk, textvariable=ik2, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        newn.place(x=150, y=60)

        # 输入要加密的文本
        tkinter.Label(tk, text="请输入要加密的对象").place(x=10, y=100)  #
        iitext = tkinter.Text(tk, width=36, height=10)
        iitext.place(x=150, y=100)

        # 点击加密
        tkinter.Button(tk, text='点击加密', width=14, command=RSA_jiami).place(x=10,
                                                                           y=198)  # 设置按钮控件，命名为“点击加密”，用command参数绑定jiamihanshu函数

        # 设置加密窗口的名称
        tkinter.Label(tk, text='------------------------------------对 称 加 密------------------------------------').place(
            x=10, y=250)

        # 设置秘钥
        tkinter.Label(tk, text="请输入3-9位的秘钥").place(x=10, y=280)  # 添加标签并命名标签，固定标签的位置
        ik = tkinter.StringVar()  # 建立变量ik为字符串变量
        ikey = tkinter.Entry(tk, textvariable=ik, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        ikey.place(x=150, y=280)

        # 输入要加密的文本
        tkinter.Label(tk, text="请输入要加密的文本").place(x=10, y=350)  #
        itext = tkinter.Text(tk, width=36)
        itext.place(x=150, y=350)

        # 点击加密
        tkinter.Button(tk, text='点击加密', width=14, command=jiamihanshu).place(x=10,
                                                                             y=448)  # 设置按钮控件，命名为“点击加密”，用command参数绑定jiamihanshu函数
        tk.mainloop()

        tk2 = tkinter.Tk()
        tk2.title("RSA解密")
        tk2.geometry("500x750")

        tkinter.Label(tk2,
                      text='------------------------------------RSA 解 密------------------------------------').place(
            x=10, y=0)

        # 设置秘钥
        tkinter.Label(tk2, text="请输入私钥").place(x=10, y=30)  # 添加标签并命名标签，固定标签的位置
        ik = tkinter.StringVar()  # 建立变量ik为字符串变量
        siyao = tkinter.Entry(tk2, textvariable=ik, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        siyao.place(x=150, y=30)

        # 设置质数之积
        tkinter.Label(tk2, text="请输入质数之积").place(x=10, y=60)  # 添加标签并命名标签，固定标签的位置
        ik2 = tkinter.StringVar()  # 建立变量ik为字符串变量
        newn2 = tkinter.Entry(tk2, textvariable=ik2, width=36)  # 将变量ik2跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        newn2.place(x=150, y=60)

        # 输入要加密的文本
        tkinter.Label(tk2, text="请输入要解密的对象").place(x=10, y=100)  #
        dcmiyao = tkinter.Text(tk2, width=36, height=10)
        dcmiyao.place(x=150, y=100)

        tkinter.Button(tk2, text='点击解密', width=14, command=RSA_jiemi).place(x=10,
                                                                            y=198)  # 设置按钮控件，命名为“点击加密”，用command参数绑定jiamihanshu函数

        # 设置秘钥
        tkinter.Label(tk2, text="请输入3-9位的秘钥").place(x=10, y=280)
        ik2 = tkinter.StringVar()
        newikey = tkinter.Entry(tk2, textvariable=ik2, width=36)
        newikey.place(x=150, y=280)

        # 输入要解密的文本
        tkinter.Label(tk2, text="请输入要解密的文本").place(x=10, y=350)
        newitext = tkinter.Text(tk2, width=36)
        newitext.place(x=150, y=350)

        # 点击解密
        tkinter.Button(tk2, text='点击解密', width=14, command=jiemihanshu).place(x=10, y=448)
        tk2.mainloop()


        window = tkinter.Tk()
        window.title('文件加密与解密')  # 标题
        window.geometry('500x500')  # 设置窗口尺寸
        file_path = ''  # 定义路径
        file_text = ''  # 定义文件内容
        text1 = tkinter.Text(window, width=50, height=10, font=('Arial', 12))
        text1.pack()

        # 设置秘钥
        n = tkinter.Label(window, text="请输入公钥")
        n.pack()
        ik = tkinter.StringVar()  # 建立变量ik为字符串变量
        iikeyy = tkinter.Entry(window, textvariable=ik, width=36)  # 将变量ik跟文本绑定在一起，跟踪变量的值的变化，保证值的变更随时可以显示在界面上
        iikeyy.pack()

        bt1 = tkinter.Button(window, text='打开文件', width=15, height=2, command=open_file)
        bt1.pack()
        bt2 = tkinter.Button(window, text='保存文件', width=15, height=2, command=save_file)
        bt2.pack()
        bt3 = tkinter.Button(window, text='加密文件', width=15, height=2, command=wbjiamihanshu)
        bt3.pack()
        bt4 = tkinter.Button(window, text='解密文件', width=15, height=2, command=wbjiemihanshu)
        bt4.pack()
        window.mainloop()  # 显示窗口

    elif work == 6 :
        print("操作完成，确认退出！")

    else:
        print("输入有误！")

elif jishu==2 :
    print("退出成功！")

else :
    print("指令错误！")

print("---"*50)

# 测试用例
# 公钥：11
# 私钥：289991
# 质数之积：639773
# 对称密钥：121212                   46595,494155,46595,494155,46595,494155          121212
# 加密文本：我爱python1212！！！Aa     扂牣¡«¥  bdbdＲＳＲs                         我爱python1212！！！Aa

励志吃菊猫的咸鱼

关注

26
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
python结课程序课设（RSA加密解密内附源码及结果）

随着科学技术的不断发展，密码学的深入应用以及网络数据的广泛普及，人们之间的信息交流不只局限于书信、电话，更多的是通过网络数据进行线上交流。早时的书信和电话传递信息会有信息被劫持的情况，如今信息交流依然处在，同时信息被监视和劫持依然存在，特别是商业金融、国防军事、行政司法等重要领域和部门信息泄露的风险更大。因此，为提高信息系统和数据的安全性和保密性，防止秘密数据被不法分子破解和利用，对信息采取了加密过程。而按照作用的不同，数据加密技术可分为数据传输加密技术、数据存储加密技术、数据完整性的鉴别技术和。
复制链接

扫一扫