您的位置:

ecb加密在python中,ecb加密算法

本文目录一览:

java生成的rsa公钥 能在python上使用吗

肯定可以,这个跟语言是无关的

Python上RSA加密的库挺多的,最开始使用的是rsa,因为比较简单嘛!测试的时候也是用 python模拟App的访问,顺利通过!

然而App开发者反馈,python测试脚本没法移植到java上,因为java的加密解密模块需要更加精细的算法细节指定,否则java加密过的数据python是解不出来的。

当初就是因为rsa模块简单,不需要注重细节才选的,自己又不是专业搞加密解密的。没办法了,只能硬着头皮,捋了一遍RSA的加密原理。网上还是有比较多的讲述比较好的文章,比如RSA算法原理

原理是懂了,但具体到python和java的区别上,还是一头雾水。最终python的RSA模块换成Crypto,因为支持的参数比较多。搜了很多网站讲的都不是很详细,stackflow上有几篇还可以,借鉴了一下,最后测试通过了。还是直接上代码吧。

Java代码

//下面这行指定了RSA算法的细节,必须更python对应

private static String RSA_CONFIGURATION = "RSA/ECB/OAEPWithSHA-256AndMGF1Padding";

//这个貌似需要安装指定的provider模块,这里没有使用

private static String RSA_PROVIDER = "BC";

//解密 Key:私钥

public static String decrypt(Key key, String encryptedString){

try {

Cipher c = Cipher.getInstance(RSA_CONFIGURATION);

c.init(Cipher.DECRYPT_MODE, key, new OAEPParameterSpec("SHA-256", "MGF1", MGF1ParameterSpec.SHA256,

PSource.PSpecified.DEFAULT));

byte[] decodedBytes;

decodedBytes = c.doFinal(Base64.decode(encryptedString.getBytes("UTF-8")));

return new String(decodedBytes, "UTF-8");

} catch (IllegalBlockSizeException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BadPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (Base64DecodingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (UnsupportedEncodingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidKeyException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidAlgorithmParameterException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

//加密 Key一般是公钥

public static String encrypt(Key key, String toBeEncryptedString){

try {

Cipher c = Cipher.getInstance(RSA_CONFIGURATION);

c.init(Cipher.ENCRYPT_MODE, key, new OAEPParameterSpec("SHA-256", "MGF1", MGF1ParameterSpec.SHA256,

PSource.PSpecified.DEFAULT));

byte[] encodedBytes;

encodedBytes = c.doFinal(toBeEncryptedString.getBytes("UTF-8"));

return Base64.encode(encodedBytes);

} catch (IllegalBlockSizeException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BadPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (UnsupportedEncodingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidKeyException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidAlgorithmParameterException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

//通过Pem格式的字符串(PKCS8)生成私钥,base64是去掉头和尾的b64编码的字符串

//Pem格式私钥一般有2种规范:PKCS8和PKCS1.注意java在生成私钥时的不同

static PrivateKey generatePrivateKeyFromPKCS8(String base64)

{

byte[] privateKeyBytes;

try {

privateKeyBytes = Base64.decode(base64.getBytes("UTF-8"));

KeyFactory kf = KeyFactory.getInstance("RSA");

PKCS8EncodedKeySpec ks = new PKCS8EncodedKeySpec(privateKeyBytes);

PrivateKey privateKey = kf.generatePrivate(ks);

return privateKey;

} catch (Base64DecodingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (UnsupportedEncodingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidKeySpecException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

//通过Pem格式的字符串(PKCS1)生成私钥,base64是去掉头和尾的b64编码的字符串

static PrivateKey generatePrivateKeyFromPKCS1(String base64)

{

byte[] privateKeyBytes;

try {

privateKeyBytes = Base64.decode(base64.getBytes("UTF-8"));

KeyFactory kf = KeyFactory.getInstance("RSA");

X509EncodedKeySpec ks = new X509EncodedKeySpec(privateKeyBytes);

PrivateKey privateKey = kf.generatePrivate(ks);

return privateKey;

} catch (Base64DecodingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (UnsupportedEncodingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidKeySpecException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

//通过Pem格式的字符串(PKCS1)生成公钥,base64是去掉头和尾的b64编码的字符串

//Pem格式公钥一般采用PKCS1格式

static PublicKey generatePublicKeyFromPKCS1(String base64)

{

byte[] publicKeyBytes;

try {

publicKeyBytes = Base64.decode(base64.getBytes("UTF-8"));

KeyFactory kf = KeyFactory.getInstance("RSA");

X509EncodedKeySpec ks = new X509EncodedKeySpec(publicKeyBytes);

PublicKey publicKey = kf.generatePublic(ks);

return publicKey;

} catch (Base64DecodingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (UnsupportedEncodingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidKeySpecException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

//通过modulus和exponent生成公钥

//参数含义就是RSA算法里的意思

public static RSAPublicKey getPublicKey(String modulus, String exponent) {

try {

BigInteger b1 = new BigInteger(modulus);

BigInteger b2 = new BigInteger(exponent);

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);

return (RSAPublicKey) keyFactory.generatePublic(keySpec);

} catch (Exception e) {

e.printStackTrace();

return null;

}

} 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169

Python 代码

from Config import config

from Crypto.Hash import SHA256

from Crypto.PublicKey import RSA

from Crypto.Cipher import PKCS1_OAEP

key = RSA.generate(1024)

pubkey = key.publickey().key

def Decrypt(prikey,data):

try:

cipher = PKCS1_OAEP.new(prikey, hashAlgo=SHA256)

return cipher.decrypt(data)

except:

traceback.print_exc()

return None

def Encrypt(pubkey,data):

try:

cipher = PKCS1_OAEP.new(pubkey, hashAlgo=SHA256)

return cipher.encrypt(data)

except:

traceback.print_exc()

return None

1234567891011121314151617181920212223

总结

主要是对RSA算法不是很熟悉,其中很多术语不懂,导致跟java里的加密模块的函数和类对应不上。

RSA算法的细节到现在也是一知半解,但真的没时间去深入学习了。

密码学基础之对称加密(一)

就不给定义了,我简单解释下,就是我的信息不想让别人知道,使用 秘钥(key) 对我的信息进行 加密(encrypt) ,变成鬼符一样的 秘文(ciphertext) 。别人就算看到了,也无法识别,只有有了秘钥,把秘文 解密(decrypt) 后才能看懂信息,秘钥呢?一般人我不告诉他。我的秘钥是私密信息,所以也叫 私钥(private key) ,加密和解密用的秘钥是相同的,所以叫 “对称加密” ,也叫 “私钥加密” 。

对于明文plaintext,和对称秘钥key

加密过程 E(plaintext, key) = ciphertext

解密过程 D(ciphertext, key) = plaintext

对称加密的分为 分组密码(block cipher) 和 流密码(stream cipher) 两种类型。本文只介绍分组密码。

分组密码是每次只能处理特定长度的一块(block)数据的一类加解密算法。AES就是一种分组密码算法。AES加密算法每次可以加密的块长度是128位(bit)。

ECB模式

使用AES加密算法ECB模式,每次能加密128位数据,即16个字节。如果要加密48个字节内容,我们需要把数据分为3组,每组16个字节,分别为P1、P2、P3。P1、P2、P3加密后形成的秘文分别为C1、C2、C3,我们把C1、C2、C3依次拼接起来就成为最终的加密结果。

CBC模式

《对称加密之对称加密二》正在写作,会包含分组密码的更多模式,流密码及AES的更多知识。

DES加密:旧的加密算法,NIST规定仅能用于遗留系统和TDEA。(参考文献[CNS] 3.2章)

TDEA(Triple DEA)加密:很多资料也叫3DES(Triple DES)。(参考文献[SP800-67])

Python 可以使用 pycrypto 模块进行AES加解密。安装 pycrypto 可使用命令 pip install pycrypto 安装。

下面AES演示第一版,先看下,紧接着就会升级到第二版本。

运行一下,能正常加解密。但是,如果你把要加密的文本,从 aesAlgorithmDemo 改为 hello ,就会运行报错:

这是因为,AES的分组长度是128位,即16个字节。有些AES实现,要加密的消息长度不是16个字节的倍数需要填充。

填充的方法一般是按照PKCS#7填充标准。

如果要数据的长度不是分组的整数倍,需要填充数据到分组的倍数,如果数据的长度是分组的倍数,需要填充分组长度的数据,填充的每个字节值为填充的长度。PKCS#7支持的分组长度为1到255个字节。

举一些例子:

AES的分组长度为16个字节,不管秘钥是128位、192位还是256位。如果要加密的数据长度是5个字节,你需要填充11个字节,填充的内容位填充的长度0x0b。填充后类似下面表示

如果数据长度是30个字节,需要填充2个字节,每个字节的内容为0x02,如果数据成都恰好为16的倍数,需要填充16个字节,每个字节的内容为0x10。

弄明白填充的概念后,我们重写加解密函数如下:

这样填充后会不会可其它系统不兼容?不会。一般的AES程序都是支持PKCS#7填充的。

密码学基础之RSA与不对称秘钥

密码学基础系列

[CNS] 《密码编码学与网络安全》(第六版)

[SP800-67] NIST Special Publication 800-67 Revision 1, Recommendation for Triple Data Encryption Algorithm (TDEA) Block Cipher, January 2012.

[SSH] OpenSSH CBC模式信息泄露漏洞

[NIST SP 800-57 Part 1 Rev. 4] Recommendation for Key Management, Part 1: General

python语言可以加密吗

我们所说的加密方式都是对二进制编码的格式进行加密,对应到python中,则是我们的bytes.

所以当我们在Python中进行加密操作的时候,要确保我们的操作是bytes,否则就会报错.

将字符串和bytes互相转换可以用encode()和decode()方法,如下所示:

注:两位十六进制常常用来显示一个二进制字节.

推荐学习《python教程》。

python中AES 用ECB模式加密之后为什么和C#加密之后的结果不一样

AES是美国国家标准技术研究所NIST旨在取代DES的21世纪的加密标准。 AES的基本要求是,采用对称分组密码体制,密钥长度的最少支持为128、192、256,分组长度128位,算法应易于各种硬件和软件实现。1998年NIST开始AES第一轮分析、测试和征集

怎么样给python文件加密

简单模式:

from hashlib import md5

def md5_file(name):

m = md5()

a_file = open(name, 'rb') #需要使用二进制格式读取文件内容

m.update(a_file.read())

a_file.close()

return m.hexdigest()

if __main__ == '__init__':

print md5_file('d:/test.txt')

大文件速度更快一点的方式

#!/usr/bin/python

#encoding=utf-8

import io

import sys

import hashlib

import string

def printUsage():

print ('''''Usage: [python] pymd5sum.py ''')

def main():

if(sys.argv.__len__()==2):

#print(sys.argv[1])

m = hashlib.md5()

file = io.FileIO(sys.argv[1],'r')

bytes = file.read(1024)

while(bytes != b''):

m.update(bytes)

bytes = file.read(1024)

file.close()

#md5value = ""

md5value = m.hexdigest()

print(md5value+"\t"+sys.argv[1])

#dest = io.FileIO(sys.argv[1]+".CHECKSUM.md5",'w')

#dest.write(md5value)

#dest.close()

else:

printUsage()

main()

Python进行 AES CBC-128bit PKCS7/PKCS5 填充加密解密

你看一下这个例子吧。可以参考下面的地址:前面加上http,把句号改成点。

likang。me/blog/2013/06/05/python-pycrypto-aes-ecb-pkcs-5/

# -*- coding: utf-8 -*-

from Crypto.Cipher import AES

import os

BS = AES.block_size

pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS)

unpad = lambda s : s[0:-ord(s[-1])]

key = os.urandom(16) # the length can be (16, 24, 32)

text = 'to be encrypted'

cipher = AES.new(key)

encrypted = cipher.encrypt(pad(text)).encode('hex')

print encrypted  # will be something like 'f456a6b0e54e35f2711a9fa078a76d16'

decrypted = unpad(cipher.decrypt(encrypted.decode('hex')))

print decrypted  # will be 'to be encrypted'