python实现rsa加密解密 rsa加密算法python

数据安全HASH，AES，RSA算法实战讲解（1-概述）

//分配一段空间用于存储加密后的数据，这个空间的大小由RSA_size函数根据rsa算出

个人对数据安全理解是：

python实现rsa加密解密 rsa加密算法python

python实现rsa加密解密 rsa加密算法python

算法是公开的，在当前世界算力下，理论上不可的，是靠秘钥来保证安全的，不是算法本身。

在我们日常的开发过程中，我们开发人员保证数据安全，主要通过四个手段。

通过对数据的签名（其实就是对数据进行HASH）保证传输过程中数据不被篡改。

通过数据进行对称加密（主要是AES），保证数据传输过程中数据不被泄密。

如：微信的 “微信公众平台的接入” 的数据加密传输。

通过非对称加密（RSA）的公钥对数据进行加密，然后通过私钥对应的私钥对数据进行解密，也是保证数据传输过程中数据不被泄密，非对称加密的速度比较慢。

如：s的ssl协议

具体步骤：

注意：");

加密只能用公钥，解密只能用私钥，不要问为什么，这是被数学证明过的。

通过非对称加密（RSA）的私钥对数据进行加密，然后通过公钥对应的私钥对数据进行解密，为了证明加密着的身份，用于身份确认，

如：银行发的U盾，证书。

具体步骤：

注意：

RSA加密原理

if(flag == 0) {

RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。公钥加密--私钥解密，私钥加密--公钥解密

b = r;

在 整数 中， 离散对数 是一种基于 同余 运算和 原根 的一种 对数 运算。而在实数中对数的定义 log b a 是指对于给定的 a 和 b ，有一个数 x ，使得 b x = a 。相同地在任何群 G 中可为所有整数 k 定义一个幂数为 b K ，而 离散对数 log b a 是指使得 b K = a 的整数 k 。

当3为17的 原根 时，我们会发现一个规律

对 正整数 n，欧拉函数是小于或等于n的正整数中与n 互质 的数的数目（因此φ(1)=1）。有以下几个特点

服务端根据生成一个随机数15，根据 3 15 mod 17 计算出6，服务端将6传递给客户端，客户端生成一个随机数13，根据 3 13 mod 17 计算出12后，将12再传回给服务端，客户端收到服务端传递的6后，根据 6 13 mod 17 计算出 10 ，服务端收到客户端传递的12后，根据 12 15 mod 17 计算出 10 ，我们会发现我们通过 迪菲赫尔曼密钥交换 将 10 进行了加密传递

说明：

安全性：

除了 公钥 用到 n 和 e ，其余的4个数字是 不公开 的（p1、p2、φ(n)、d）

目前RSA得到的方式如下：

缺点

RSA加密 效率不高 ，因为是纯粹的数学算法，大数据不适合RSA加密，所以我们在加密大数据的时候，我们先用 对称加密 算法加密大数据得到 KEY ，然后再用 RSA 加密 KEY ，再把大数据和KEY一起进行传递

因为Mac系统内置了OpenSSL（开源加密库），所以我们开源直接在终端进行RSA加密解密

生成RSA私钥，密钥名为private.pem,密钥长度为1024bit

因为在iOS中是无法使用 .pem 文件进行加密和解密的，需要进行下面几个步骤

crt证书格式转换成der证书

用Python2.7.10编写凯撒密码加密和解密程序

因为这里直接在前端加解密，所以需要一对现成的密钥，我们通过 密钥在线生成器 得到：

def use_list(): str_before=input("请输入明文：") str_change=str_before.lower() str以下是使用PHP进行Rijndael方式加密的例子：_list=list(str_change) str_list_change=str_list i=0 whilei

Python加密与解密 No module named 'Crypto'

python版本：pytho{printf("decryption failuren3，系统：win

会安装很多包：chardet, certifi, lib3, idna, requests, pyyaml, Naked, shellescape, crypto

这时你会看到有crypto文件夹，将其重命名为Crypto即可;

pip uninstall pycrypto，然后安装pycryptodome，pip install pycryptodome，即可。

你会发现site-packages下的该模块的目录名已经是大写了-Crypto

这个时候pycryptodome就来了，它是pycrypto的延伸版本，用法和pycrypto是一模一样的

Python\PythoM=raw_input()n36\Lib\site-packages，找到这个路径，下面有一个文件夹叫做crypto,将小写c改成大写C就ok了。

简述RSA算法中密钥的产生，数据加密和解密的过程，并简单说明RSA算法安全性的原理。

int n = 0;

RSA方法的工作原理如下：

char d;

1) 任意选取两个不同的大质数p和q，计算乘积r=pq；

2) 任意选取一个大整数e，e与(p-1)(q-1)互质，整数e用做加密密钥。注意：e的选取是很容易的，例如，所有大于p和q的质数都可用。

3) 确定解密密钥d：

d e = 1 mod（p - 1）（q - 1）

根据e、p和q可以容易地计算出d。

4) 公开整数r和e，但是不公开d；

5) 将明文P (设P是一个小于r的整数)加密为密文C，计算方法为：

C = Pe mod r (e为幂次方)

6) 将密文C解密为明文P，计算方法为：

P = Cd mod r (d为幂次方)

然而只根据r和e（不是p和q）要计算出d是不可能的。因此，任何人都可对明文进行加密，但只有授权用户（知道d)才可对密文解密。

例：选取p=3, q=5,试计算出d和e分别是多少?定明文为整数13,请给出密文数字.

解:如果选取p=3, q=5，则r=15，（p-1）（q-1）=8。选取e=11（大于p和q的质数），通过d 11 = 1 mod 8， 计算出d =3。

定明文为整数13。则密文C为 (e为幂次方)

C = Pe mod r = 1792160394037 mod 15 = 7

复原明文P为： (d为幂次方)

P = Cd mod r = 343 mod 15 = 13

如何利用OpenSSL库进行RSA加密和解密

如：微信的 “微信公众平台的接入” 的数据签名（signature），保证消息的确来自微信，并没有被篡改过。

#includee2可以为19、31、……这里我选31好了

#include

#include

#include

#include

int main(int argc, char argv[])

{printf("openssl_test begin

RSA rsa=NULL;

char originstr[]="hello

"; //这是我们需要加密的原始数据

//allocate RSA structure，首先需要申请一个RSA结构题用于存放生成的公私钥，这里rsa就是这个结构体的指针

rsa = RSA_new();

if(rsa==NULL)

{printf("RSA_new failed

return -1;

}//generate RSA keys

BIGNUM exponent;

exponent = BN_new(); //生成RSA公私钥之前需要选择一个奇数（odd number）来用于生成公私钥

if(exponent ==NULL)

{printf("BN_new failed

goto FAIL1;

}if(0==BN_set_word(exponent,65537)) //这里选择奇数65537

goto FAIL1;

}//这里modulus的长度选择4096，小于1024的modulus长度都是不安全的，容易被

if(0==RSA_generate_key_ex(rsa,4096,exponent,NULL))

{printf("RSA_generate_key_ex failed

goto FAIL;

}char cipherstr = NULL;

cipherstr = malloc(RSA_size(rsa));

if(cipherstr==NULL)

{printf("malloc cipherstr buf failed

goto FAIL1;

}//下面是实际的加密过程，一个参数padding type，有以下几种。

/

RSA_PKCS1_PADDINGPKCS #1 v1.5 padding. This currently is the most widely used mode.

RSA_PKCS1_OAEP_PADDING

EME-OAEP as defined in PKCS #1 v2.0 with SHA-1, MGF1 and an empty encoding parameter. This mode is recommended for all new applications.

RSA_SSLV23_PADDING

PKCS #1 v1.5 padding with an SSL-specific modification that denotes that the server is SSL3 capable.

RSA_NO_PADDING

Raw RSA encryption. This mode should only be used to implement cryptographically sound padding modes in the application code. Encrypting user data directly with RSA is insecure.

/

//这里首先用公钥进行加密，选择了RSA_PKCS1_PADDING

if(RSA_size(rsa)!=RSA_public_encrypt(strlen(originstr)+1,originstr,cipherstr,rsa,RSA_PKCS1_PADDING))

{printf("encryption failure

goto FAIL2;

}printf("the original string is %s

",originstr);

printf("the encrypted string is %s

",cipherstr); //Now, let's decrypt the string with private key

//下面来用私钥解密，首先需要一个buffer用于存储解密后的数据，这个buffer的长度要足够（小于RSA_size(rsa)）

//这里分配一个长度为的字符数组，应该是够用的。

char decrypted_str[];

int decrypted_len;

if(-1=(decrypted_len=RSA_private_decrypt(256,cipherstr,decrypted_str,rsa,RSA_PKCS1_PADDING)))

goto FAIL2;

}printf("decrypted string length is %d,decryped_str is %s

",decrypted_len,decrypted_str);

FAIL2:

free(cipherstr);

FAIL1:

BN_free(exponent);

FAIL:

RSA_free(rsa);

return 0;

}以上是源代码，下面使用下面的编译命令在源码所在路径下生成可执行文件

gcc .c -o openssl_test -lcrypto -ldl -L/usr/local/ssl/lib -I/usr/local/ssl/include

其中，-lcrypto和-ldl是必须的，前者是OpenSSL中的加密算法库，后者是用于成功加载动态库。

对于下列值。使用RSA算法进行加密和解密

RSA算法很简单，就是基于欧拉定理的简单算法

M=5是明文，计算过程如下：

n=pq=33;

(p-1)(q-1)=20;

加密：y=密文，x=明文=5;

y=x^e mod n = 5^7 mod 33 = 14;

#coding=utf-8解密：

x=y^d mod n;

de= 1 [mod(p-1)(q-1)];

7d=1(mod 20)所以d=error: command 'gcc' failed with exit status 13;

所以x=y^d mod n= 14^3 mod 33 = 5;解完

加密由5~14，解密由14~5，实现了RSA算法的加密解密过程，证明了计算的正确性。

其他2题同理，自己做吧。

jsencrypt实现前端RSA非对称加密解密（vue项目）

重点来了：使用jsencrypt实现RSA非对称加解密

最近一个vue项目要求所有密码数据需要使用RSA非对称加密传输，以为挺简单，结果开发过程中还是遇到了些问题，简单做个笔记。同时也希望可以帮助到遇到同样问题的道友门。

然后在需要使用的文件中引入JSEncrypt，我是将所有工具函数都封装在一个js文件的，我就直接在该文件中引入，我看也有人是在main.js中引入的。

到这里我们的加密解密方法就完成了，在需要的地方直接拿过来用就好了！

大功告成！这样就完了？我以为这样就ok了。

当然，如果没有遇到这个bug，就可以忽略下面的内容了。

从上面截图可以看到，重启项目的时候报错： nigator is not defined

而且这个bug有点奇葩，先启动项目再引入jsencrypt就什么问题都没有，但是先引入jsencrypt再启动项目就报错。这也是我前面能顺利执行的原因所在。

通过好一通折腾，用了网上的各种方法，比如在main.h gjs引入jsencrypt、引入jsdom之类的，都没能解决这个问题，最终还是在jsencrypt的git相关 issue 下找到了这个问题的解决方案。

到这里问题就算基本解决了，但是由于项目组不止我一个前端，我不能要求每个同事或者以后接手维护项目的同事都要在node_modules中去替换文件。

所以就采用了另外一种方案：将jsencrypt.js通过在线js压缩器压缩至jsencrypt.min.js中，然后把jsencrypt.min.js放到src/assets/jsencrypt文件夹中，就不用npm install的方式了。

换了种方式，jsencrypt的引用方式需要做出相应的调整：

参考链接： RSA非对称加密传输---前端加密&解密(VUE项目)

PS：才疏学浅，如果有考虑不周之处或者有更好的解决方案，欢迎指正探讨！

rsa加密算法

in2 = b;

rsa加密算法如下：

算法原理：

RSA公开密钥密码体制的原理是：根据数论，寻求两个大素数比较简单for i in range(0,row):，而将它们的乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥

算法描述：

RSA算法的具体描述如下：

（1）任意选取两个不同的大素数p和q计算乘积

（2）任意选取一个大整数e，满足整数e用做加密钥（注意：e的选取是很容易的，例如，所有大于p和q的素数都可用）

（3）确定的解密钥d，满足 是一个任意的整数；所以，若知道e和，则很容易计算出d ；

（4）公开整数n和e，秘密保存d [5] ；

（5）将明文m（m

（6）将密文c解密为明文m，解密算法为

安全性

RSA的安全性依赖于大数分解，但是否等同于大数分解一直未能得到理论上的证明，也并没有从理论上证明破译。RSA的难度与大数分解难度等价。因为没有证明RSA就一定需要做大数分解。设存在一种无须分解大数的算法，那它肯定可以修改成为大数分解算法，即RSA的重大缺陷是无法从理论上把握它的保密性能如何，而且密码学界多数人士倾向于因子分解不是问题

RSA加解密演算与12位

菲麦前端专题，汇聚前端好文，邀您关注！

大家都知道RSA是非对称加密，解密方生成公钥和密钥，公钥公开给加密方加密，密钥留给自己解密是不公开的。

cout<<" Welcome to use RSA encoder "<1.随机选两个质数，我们用p、q来代替 （质数的数值越大位数就越多可靠性就越高）

设我们取了47与59

p = 47

q = 59

2.计算这两个质数的乘积，用n代替

n = 47 x 59 = 2773

n的长度就是密钥长度。2773写成二进制是101011010101，一共有12位，所以这个密钥就是12位。实际应用中，RSA密钥一般是1024位，重要场合则为2048位。

3.计算n的欧拉函数φ(n)

欧拉函数公式：φ(n) = (p-1)(q-1)

代入：φ(2773) = (47 - 1) x (59 - 1) = 46 x 58 = 2668

4.随机选择一个整数e，条件是1< e < φ(n)，且e与φ(n) 互质

那么我们就在1到2668之间，随机选择了17

e = 17

5.计算e对于φ(n)的模反元素d

模反元素公式: ax ≡ 1 (mod b)

这是欧拉定理推导出来的，若a、b互质则a乘以一个整数除以b的余数是1。这个整数就是a与b的模反元素。

该公式可以写成：ax - b = 1 则 x = (1 + b) / a

代入： d = (1 + φ(n)) / e = (1 + 2668) / 17 = 157

是一个整数，但很多情况下结果不一定是整数，我们为了计算的方便，在公式里追加一个整数k: x = (1 + kb) / a，加上k来乘以b并不影响余数1的结果。

重新代入： d = (1 + kφ(n)) / e = (1 + k x 2668) / 23

即得到一个线性方程

求解的坐标点(k,d)有很多 (1,157)、(18,2825)、(35,5493) ....

我们随机出一个坐标点： (1,157)

即：d = 157

6.将n和e封装成公钥，n和d封装成私钥

即公开的公钥为：n = 2773，e = 17

保密的私钥为：n = 2773，d = 157

就是这样子12位RSA的公私钥生成好了！

设我们加密一个字符"A"

转ASCII码十进制为65，我们用m来代替明文，c来代替密文

m = 65

RSA加密公式：m e ≡ c (mod n)

RSA加密公式由欧拉函数公式与反模元素公式推导出来

代入：c = 65 17 % 2773 = 601

这样密文就出来了！

RSA解密公式：c d ≡ m (mod n)

RSA解密公式由欧拉函数公式与反模元素公式推导出来

代入：m = 601 157 % 2773 = 65

这样明文就出来了！

因为p、q、n、φ(n)、e、d这六个数字之中，公钥用到了两个（n和e），其余四个数字都是不公开的。其中最关键的是d，因为n和d组成了私钥，一旦d泄漏，就等于私钥泄漏

由此可见推导出d就必须因数分解出p和q

公钥里面有n = 2773

那么的方法就是把2773因数分解出两个相乘的质数。

最简单的方法就是遍历穷举质数的乘积：

var distNum = 2773;

var numList = [];

var p = 1;

var q = 1;

for(var i = 1; i < 100; i++) {

var isGetResult = false; // 是否找到结果

var isUseful = true; // 是否质数

var isHe = false; // 是否在质数列表中存在

for(var j = 0; j < numList.length; j++) {

if(numList[j] == i) {

isHe = true;

break;

}}

for(var k = 2; k < i; k++ ) {

if(i % k == 0) {

isUseful = false;

break;

}}

if(!isHe && isUseful) {

numList.push(i); // 加入质数列表

// 匹配乘积

for(var n = 0; n < numList.length; n++) {

if(i != numList[n] && i numList[n] == distNum) {

p = i;

isGetResult = true;

break;

}}

}console.log(JSON.stringify(numList));

if(isGetResult) {

console.log('p = ' + p);

console.log('q = ' + q);

break;

}}

运行结果：

RSA加密的可靠性是基于因数分解的计算难度，但随着量子计算、云计算的发达，现在用的1024位RSA甚至2048位RSA都面临着挑战，据说40个量子比特位相当于一台超级计算机。

您的意见是我改善的东西，欢迎评论提建议，如果对您有帮助，请点个赞，谢谢~~

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至836084111@qq.com 举报，一经查实，本站将立刻删除。