Python的RSA加密和PBE加密

最近在写接口的时候,遇到了需要使用RSA加密和PBE加密的情况,对方公司提供的DEMO都是JAVA的,我需要用python来实现。

在网上搜了一下,python的RSA加密这块写的还是比较多的,但是PBE较少。所以我就讲讲我在RSA加密上面遇到的坑,大家权当一乐。PBE加密里面的盐、密钥。

RSA

什么是RSA加密呢?

其实RSA是一种非对称加密,那什么是非对称加密呢?非对称加密又叫做公开密钥加密,就是说我有一对密钥,分为公钥和私钥。私钥我悄悄的留着,不给别人看。然后把公钥给别人(无论是谁)。当别人用公钥加密了数据之后,这串加密后的数据只有我(拥有私钥的人)用私钥才能解开,其余谁都不能解开。这就是非对称加密。

这只是单向的,只是我解开数据 —— 我获取信息。

那么我怎么向别人传递信息呢?别人怎么保证我传递的信息就是我发出的呢?这时候就需要私钥来加密了,又叫做数字签名。我把数据签名之后数据和未签名的数据一齐发给别人,别人通过公钥来解密加密的数据,然后把解密后的数据和未签名的数据进行对比,相同的话就代表数据来源正确。

可能说的有点乱,我上次看到一个非常清晰明了的例子,我凭着记忆大致讲出来:

老板派员工小明去外地考察商机。

小明任务做的很棒,很快就发现了商机。这时候他要想老板汇报,但是网络是不安全的,很有可能一给老板发情报邮件,邮件就被竞争对手得到了。这次考察也就失败了。

于是,小明通过事先老板给他的公钥来加密情报。

这样,老板能够通过私钥来解密得到情报,而竞争对手只能对一堆乱码发呆。

这次情报让老板很满意,老板决定让小明继续深入考察。

但是这个继续深入考察的命令在网络中传输是不安全的,竞争对手虽然得不到情报,但是可以通过黑客来篡改命令啊,假如让小明回公司,那么这就不划算了,也浪费了时间。

这时候,老板就用私钥对自己下达的命令进行签名,把签名后的数据和明文的命令一齐发出去,小明收到邮件之后,对签名后的数据和命令用公钥进行验证,如果一致,就代表没有被篡改,可以放心大胆的事实老板的命令。

……………………………………………………分割线………………………………………………

那么我写的接口呢,是这样的。

我司要通过接口获取对方公司的数据,获取数据就要传递参数过去,对方根据参数然后返回相应的数据。

对方公司生成私钥和公钥,我司生成私钥和公钥,双方交换公钥。

1、使用对方公司的公钥对所有的参数进行加密,加密之后进行base64编码。

2、使用我司私钥对加密后的数据进行签名,签名之后进行base64编码。

3、然后把加密后的数据和签名后的数据一齐发送给对方。

坑1:RSA最长只支持117为的数据进行加密,所以需要进行分段加密,而且需要先拼接再进行base64编码,排错之前一直写的是先base64编码再拼接。

坑2:分段加密之后要进行相应的签名,是需要进行MD5转码的。

talk is more, show your code。

Java:

加密:

private static final int MAX_ENCRYPT_BLOCK = 117;
public static final String KEY_ALGORITHM = "RSA"

/** *//**
     * <p>
     * 公钥加密
     * </p>
     *
     * @param data 源数据
     * @param publicKey 公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey)
            throws Exception {
        byte[] keyBytes = Base64.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

通过这段代码,我们注意到:

1、分段加密,最后直接将加密好的密文合并(out.write(cache, 0, cache.length);)

2、直接return数据(在另一端程序里面进行base64)

签名:

public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
/** *//**
     * <p>
     * 用私钥对信息生成数字签名
     * </p>
     *
     * @param data 已加密数据
     * @param privateKey 私钥(BASE64编码)
     *
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        return Base64.encode(signature.sign());
    }

通过这段代码,我们知道了直接对封装好的密文进行签名,不需要进行分段签名的原因是加密后的密文长度小于117位。我们注意到,他的加密方法是:SIGNATURE_ALGORITHM = "MD5withRSA",所以我们的python签名也是需要进行MD5的。

那么我们的python代码:

import base64
from Crypto.Hash import MD5
from Crypto.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5
from Crypto.Signature import PKCS1_v1_5 as Signature_pkcs1_v1_5
from Crypto.PublicKey import RSA

def get_encrypt_data(params):
    """分段加密"""
    params = json.dumps(params)
    params = params.encode("utf-8")
    length = len(params)
    default_length = 117
    if length < default_length:
        return encrypt_data(params)
    offset = 0
    params_lst = []
    while length - offset > 0:
        if length - offset > default_length:
            params_lst.append(encrypt_data(params[offset:offset+default_length]))
        else:
            params_lst.append(encrypt_data(params[offset:]))
        offset += default_length
    res = "".join(params_lst)
    return res, base64.b64encode(res)

def encrypt_data(params):
    """使用公钥对数据加密"""
    key = public_key
    rsakey = RSA.importKey(base64.b64decode(key))
    cipher = Cipher_pkcs1_v1_5.new(rsakey)
    text = cipher.encrypt(params)
    return text

def sign_data(params):
    """对数据签名"""
    key = private_key
    rsakey = RSA.importKey(base64.b64decode(key))
    signer = Signature_pkcs1_v1_5.new(rsakey)
    digest = MD5.new(params)
    sign = signer.sign(digest)
    return base64.b64encode(sign)

对参数进行json化,然后进行utf-8编码,每117位长度遍进行一次加密,最后把加密密文连接起来,进行base64编码。
注意我们用了digest = MD5.new(params),表明我们的签名算法也是MD5。

PBE

PBE算法再Java里面是通过MD5和DES算法构建的,是一种对称加密。也就是说加密解密使用一套密钥来进行的。

我们来看代码:

Java:

import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.KeySpec;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;
import org.apache.commons.codec.binary.Base64;

public class DesEncrypter {
    Cipher ecipher;
    Cipher dcipher;
    byte[] salt = { (byte) 0xA9, (byte) 0x9B, (byte) 0xC8, (byte) 0x32,
            (byte) 0x56, (byte) 0x35, (byte) 0xE3, (byte) 0x03 };

    /**
     * 构造方法
     *
     * @param passPhrase
     *            apikey作为密钥传入
     * @throws Exception
     */
    public DesEncrypter(String passPhrase) throws Exception {
        int iterationCount = 2;
        KeySpec keySpec = new PBEKeySpec(passPhrase.toCharArray(), salt,
                iterationCount);
        SecretKey key = SecretKeyFactory.getInstance("PBEWithMD5AndDES")
                .generateSecret(keySpec);
        ecipher = Cipher.getInstance(key.getAlgorithm());
        dcipher = Cipher.getInstance(key.getAlgorithm());
        AlgorithmParameterSpec paramSpec = new PBEParameterSpec(salt,
                iterationCount);
        ecipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);
        dcipher.init(Cipher.DECRYPT_MODE, key, paramSpec);
    }

    /**
     * 加密
     *
     * @param str
     *            要加密的字符串
     * @return
     * @throws Exception
     */
    public String encrypt(String str) throws Exception {
        str = new String(str.getBytes(), "UTF-8");
        return Base64.encodeBase64String(ecipher.doFinal(str.getBytes()));
}

我们注意到。有一个盐:对应的python盐为:"\xA9\x9B\xC8\x32\x56\x35\xE3\x03"

对应的python2.7代码:

from Crypto.Hash import MD5
from Crypto.Cipher import DES

def get_encrypt_param(params):
    """对参数进行加密封装"""
    _salt = "\xA9\x9B\xC8\x32\x56\x35\xE3\x03"
    _iterations = 2
    data = []

    # 依次对字典中的value进行utf-8编码
    for i in params:
        data.append("{}={}".format(i, params[i].encode("utf-8")))
    str_param = "&".join(data)
    padding = 8 - len(str_param) % 8
    str_param += chr(padding) * padding

    hasher = MD5.new()
    hasher.update(apikey)
    hasher.update(_salt)
    result = hasher.digest()

    # 进行hash的次数, 由java中的iterationCount决定
    for i in range(1, _iterations):
        hasher = MD5.new()
        hasher.update(result)
        result = hasher.digest()

    encoder = DES.new(result[:8], DES.MODE_CBC, result[8:16])
    encrypted = encoder.encrypt(str_param)
    return encrypted.encode("base64")

我们将传入的参数进行utf-8编码,然后进行hash,最后进行加密。

注意:java代码中的iterationCount是多少,我们就要进行循环hash多少次。

在python3的代码中,str是不能直接进行hash的,所以要抓换成utf-8进行加密,而且最后的encrypted没有encode方法,只能手动进行Base64编码。

python3 代码如下:

import base64
from Crypto.Hash import MD5
from Crypto.Cipher import DES

def get_encrypt_param(params):
"""对参数进行加密封装"""

    # 定义_salt的时候,直接定义成bytes
    _salt = b"\xA9\x9B\xC8\x32\x56\x35\xE3\x03"
    _iterations = 2
    data = []
for i in params:
        data.append("{}={}".format(i, params[i]))
    str_param = "&".join(data)
    padding = 8 - len(str_param) % 8
    str_param += chr(padding) * padding

    hasher = MD5.new()

    # 对apikey进行utf-8编码
    hasher.update(apikey.encode())
    hasher.update(_salt)
    result = hasher.digest()
for i in range(1, _iterations):
        hasher = MD5.new()
        hasher.update(result)
        result = hasher.digest()
    encoder = DES.new(result[:8], DES.MODE_CBC, result[8:16])
    encrypted = encoder.encrypt(str_param)
    # 进行base64编码
    return base64.b64encode(encrypted)

但是有一个bug,当参数中有中文的时候,他会 报错:

ValueError: Input strings must be a multiple of 8 in length

经过检查代码发现是没有对参数进行utf-8编码。

但是经过我们编码之后:

for i in params:
    data.append("{}={}".format(i, params[i].encode("utf-8")))

由于python3的机制,编码之后中文便成了bytes,对方解码之后无法识别,于是我们只有另辟蹊径。

经过一番研究,决定使用另一个库,pyDes

代码如下:

import pyDes

def get_encrypt_param(params):
    """对参数进行加密封装"""
    _salt = b"\xA9\x9B\xC8\x32\x56\x35\xE3\x03"
    _iterations = 2
    data = []
    for i in params:
        data.append("{}={}".format(i, params[i]))
    str_param = "&".join(data)

    hasher = MD5.new()
    hasher.update(apikey.encode())
    hasher.update(_salt)
    result = hasher.digest()
    for i in range(1, _iterations):
        hasher = MD5.new()
        hasher.update(result)
        result = hasher.digest()

    despy = pyDes.des(result[:8], pyDes.CBC, padmode=pyDes.PAD_PKCS5, IV=result[8:16])
    encrypt_data = despy.encrypt(str_param.encode())
    return base64.b64encode(encrypt_data)
时间: 2024-11-06 18:51:55

Python的RSA加密和PBE加密的相关文章

Python使用rsa模块实现非对称加密与解密

Python使用rsa模块实现非对称加密与解密 1.简单介绍: RSA加密算法是一种非对称加密算法 是由已知加密密钥推导出解密密钥在计算上是不可行的"密码体制.加密密钥(即公开密钥)PK是公开信息,而解密密钥(即秘密密钥)SK是需要保密的. RSA密钥至少为500位长,一般推荐使用1024位.RSA密钥长度随着保密级别提高,增加很快. 由于RSA的特性,一个1024位的密钥只能加密117位字节数据,当数据量超过117位字节的时候,程序就会抛出异常. --来自大佬 2.代码实现: 来一段大佬的代码

python实现RSA加密和签名以及分段加解密的方案

python实现RSA加解密和签名加解签 1.生成秘钥对 在这边为了方面演示,手动生成一个密钥对(项目中的秘钥对由开发来生成,会直接给到我们) 生成秘钥对的时候,可以指定生成秘钥的长度,一般推荐使用1024bit, 1024bit的rsa公钥,加密数据时,最多只能加密117byte的数据),数据量超过这个数,则需要对数据进行分段加密,但是目前1024bit长度的秘钥已经被证明了不够安全,尽量使用2048bit长度的秘钥.2048bit长度的秘钥,最多245byte长度的数据 计算公式如下: 秘钥

python提供了一个进行hash加密的模块:hashlib

python提供了一个进行hash加密的模块:hashlib下面主要记录下其中的md5加密方式 import hashlib data1 = 'sada' #####字母和数字 m = hashlib.md5(data1.encode('utf-8')) print(m.hexdigest()) data='我是' #####中文 b = hashlib.md5(data.encode('gb2312')) print(b.hexdigest()) def md5(s): ####这是一个MD5

使用X.509数字证书加密解密实务(三)-- 使用RSA证书结合对称加密技术加密长数据

本文全部源代码下载:/Files/chnking/EncryptLongData.rar 一.  使用证书结合对称加密算法加.解密长数据 上一章节讨论了如何使用RSA证书加密数据,文中提到:“Dotnet的RSA实现有个特点,它必须要在明文中添加一些随机数,所以明文不能把128字节占满,实际测试,明文最多为117字节,留下的空间用来填充随机数”.也就是说对于1024位密钥的RSA来说,一次只能加密128字节的数据,对于Dotnet的RSA实现更是只能加密117个字节的数据. 这就引出一个问题,超

Python Show-Me-the-Code 第 0021题 密码加密

第 0021 题: 通常,登陆某个网站或者 APP,需要使用用户名和密码.密码是如何加密后存储起来的呢?请使用 Python 对密码加密. 阅读资料 用户密码的存储与 Python 示例 阅读资料 Hashing Strings with Python 阅读资料 Python's safest method to store and retrieve passwords from a database 思路: 加密技术是对信息进行编码和解码的技术,编码是把原来可读信息(又称明文)译成代码形式(又

iOS中使用RSA对数据进行加密解密

RSA算法是一种非对称加密算法,常被用于加密数据传输.如果配合上数字摘要算法, 也可以用于文件签名. 本文将讨论如何在iOS中使用RSA传输加密数据. 本文环境 mac os openssl-1.0.1j, openssl需要使用1.x版本, 推荐使用[homebrew](http://brew.sh/)安装. Java 8 RSA基本原理 RSA使用"秘匙对"对数据进行加密解密.在加密解密数据前,需要先生成公钥(public key)和私钥(private key). 公钥(publ

Delphi RSA加解密【 (RSA公钥加密,私钥解密)、(RSA私钥加密,公钥解密)、MD5加密、SHA加密】

作者QQ:(648437169) delphi RSA加解密 [Delphi RSA加解密]支持 (RSA公钥加密,私钥解密).(RSA私钥加密,公钥解密).MD5加密.SHA1加密.SHA224加密.SHA256加密.SHA384加密.SHA512加密 原文地址:https://www.cnblogs.com/zhimamaigua/p/11003504.html

对称加密和非对称加密

1.对称加密----密钥加密    DES    IDEA    AES特点:算法公开,计算量小,加密速度快,加密效率高,不足:不安全原理:在对称加密算法中,使用的密钥只有一个,发收信双方都使用这个密钥对数据进行加密和解密,这就要求解密方事先必须知道加密密钥.2.不对称加密----公钥和私钥    RSA    DSA原理:收发信双方在通信之前,收信方必须将自己早已随机生成的公钥送给发信方,而自己保留私钥.由于不对称算法拥有两个密钥,因而特别适用于分布式系统中的数据加密

https 结合使用 对称加密和非对称加密

(一)对称加密(Symmetric Cryptography) ---共享密钥加密 对称加密是最快速.最简单的一种加密方式,加密(encryption)与解密(decryption)用的是同样的密钥(secret key),这种方法在密码学中叫做对称加密算法.对称加密有很多种算法,由于它效率很高,所以被广泛使用在很多加密协议的核心当中.对称加密通常使用的是相对较小的密钥,一般小于256 bit.因为密钥越大,加密越强,但加密与解密的过程越慢.如果你只用1 bit来做这个密钥,那黑客们可以先试着用