前言
例如：随着加密算法的不断发展，算法这门技术也越来越重要，很多人都开启了算法学习，本文就简单介绍了常见的几种算法。
一、RSA加密是什么？
示例：是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。
1. 配置私钥
result = ''
divide = int(len(key) / 64)
divide = divide if (divide > 0) else divide + 1
line = divide if (len(key) % 64 == 0) else divide + 1
# 分段配置
for i in range(line):
result += key[i * 64:(i + 1) * 64] + '\n'
if change == 0:
result = self.decryp_start + result + self.decryp_end
else:
result = self.encryp_start + result + self.encryp_end
2. 解密数据
# 字符串指定编码（转为bytes）
text_encrypted_base64 = text_encrypted_base64.encode(encoding='UTF-8')
# base64解码
text_encrypted = base64.b64decode(text_encrypted_base64)
# 构建私钥对象
cipher_private = PKCS1_v1_5.new(RSA.importKey(private_key))
# 解密分段
decryp_split_text = []
for long_text in range(0, len(text_encrypted), 128):
cont = text_encrypted[long_text:long_text + 128]
decryp_split_text.append(cipher_private.decrypt(cont, Random.new().read))
decryp_splicing_text = b''.join(decryp_split_text).decode()
3. rsa封装加密算法
private_key = self.__handle_pub_key(private_keys)
privatekey = RSA.importKey(private_key)
pks = PKCS1_v1_5.new(privatekey)
# 分段加密
encrypt_text = []
for text in range(0, len(decrption_content), 100):
cont = decrption_content[text:text+100]
encrypt_text.append(pks.encrypt(cont.encode()))
# 加密完进行拼接
cipher_text = b''.join(encrypt_text)
# base64进行编码
result = base64.b64encode(cipher_text)
4. RSA封装调用解密
private_key = self.__handle_pub_key(private_keys) # 生成完整私钥
byte_stream_key = bytes(private_key, encoding=self.characters) # 生成字节流
encryption_content = self.__decryption(encryption_content, byte_stream_key)
二、MD5是什么？
示例：MD5是一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。
MD5是一种不可逆的加密算法，不可逆加密算法的特征是加密过程中不需要使用密钥，输入明文后由系统直接经过加密算法处理成密文，这种加密后的数据是无法被解密的，只有重新输入明文，并再次经过同样不可逆的加密算法处理，得到相同的加密密文并被系统重新识别后，才能真正解密。
hashlib.md5(encrypt_data.encode(encoding="UTF-8")).hexdigest()
三、HAMC是什么？
示例：HMAC是一种使用单向散列函数来构造消息认证码（MAC）的方法，其中H就代表了hash的意思。
HMAC中所使用的单向散列函数并不是仅仅局限于一种，任何获得认证的高强度的单向散列函数都可以用于HMAC的计算。
使用单向散列函数SHA-1、SHA-224、SHA-256、SHA-384、SHA-512等构造的HMAC，分别称为HMAC-SHA1、HMAC-SHA224、HAMC-SHA256、HMAC-SHA384、HAMC-SHA512。
1. hamc加密
hmac.new(kyes.encode(encoding="UTF-8"),encrypt_data.encode(encoding="UTF-8"),digestmod=methods).hexdigest()
四、SHA256是什么？
示例：SHA-256作为SHA-2(Secure Hash Algorithm 2，安全哈希算法2) 的一部分，目前已经是最流行的哈希算法之一。安全加密算法通过将输入文本拆分成独立的片段，并通过这些独立的片段生成最终的结果——加密算法哈希值
1. SHA256加密
hashlib.sha256(encrypt_data.encode(encoding="UTF-8")).hexdigest()
五、SHA1是什么？
示例：是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数
1. SHA1加密
hashlib.sha1(encrypt_data.encode(encoding="UTF-8")).hexdigest()
六、base64是什么？
示例：ase64是一种基于64个可打印字符来表示二进制数据的方法。
Base64编码是把二进制转换为可打印字符，Base64编码具有不可读性，需要解码后才能阅读
1. base64加密、解密
if methodes != 'en':
base64.b64decode(bytes(encrypt_data, "UTF-8").decode("UTF-8")).decode("UTF-8")
base64.b64encode(encrypt_data.encode(encoding="UTF-8")).decode(encoding="UTF-8")
七、DES是什么？
示例：DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法，1977年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），并授权在非密级政府通信中使用，随后该算法在国际上广泛流传开来。需要注意的是，在某些文献中，作为算法的DES称为数据加密算法，已与作为标准的DES区分开来。
1. DES解密
des(secret_key, CBC, secret_key, pad=None, padmode=PAD_PKCS5).decrypt(binascii.a2b_hex(encrypt_data), padmode=PAD_PKCS5).decode("UTF-8")
八、 封装所有模块
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import requests
import os
import json
import re
import time
import hashlib
from Crypto.PublicKey import RSA
import base64
from Crypto.Cipher import PKCS1_v1_5
from Crypto import Random
import hmac
import binascii
from pyDes import des, CBC, PAD_PKCS5
# 需要安装 pip install pyDes
# 算法
class Algorithm():
def __init__(self,characters: str = "UTF-8"):
"""
初始化
:param characters: 字符集
"""
self.decryp_start = '-----BEGIN RSA PRIVATE KEY-----\n'
self.decryp_end = '-----END RSA PRIVATE KEY-----'
self.encryp_start = '-----BEGIN PUBLIC KEY-----\n'
self.encryp_end = '-----END PUBLIC KEY-----'
self.characters = characters
def __handle_pub_key(self, key, change=0):
"""
私钥添加头尾
:param key: 私钥值
:return: 返回真正私钥
"""
result = ''
divide = int(len(key) / 64)
divide = divide if (divide > 0) else divide + 1
line = divide if (len(key) % 64 == 0) else divide + 1
for i in range(line):
result += key[i * 64:(i + 1) * 64] + '\n'
if change == 0:
result = self.decryp_start + result + self.decryp_end
return result
else:
result = self.encryp_start + result + self.encryp_end
return result
def __decryption(self, text_encrypted_base64: str, private_key: bytes):
"""
解密数据
:param text_encrypted_base64: 加密数据
:param private_key: 私钥，生成字节流
:return: 返回数据
"""
# 字符串指定编码（转为bytes）
text_encrypted_base64 = text_encrypted_base64.encode(encoding=self.characters)
# base64解码
text_encrypted = base64.b64decode(text_encrypted_base64)
# 构建私钥对象
cipher_private = PKCS1_v1_5.new(RSA.importKey(private_key))
# 解密分段
decryp_split_text = []
for long_text in range(0, len(text_encrypted), 128):
cont = text_encrypted[long_text:long_text + 128]
decryp_split_text.append(cipher_private.decrypt(cont, Random.new().read))
decryp_splicing_text = b''.join(decryp_split_text)
return decryp_splicing_text.decode()
def rsa_encrypt(self, private_keys, decrption_content):
"""
rsa封装加密算法
:param private_keys: 私钥
:param decrption_content: 需加密的数据
:return: 字典，数据存在data中，成功code为200，失败code为203
"""
private_key = self.__handle_pub_key(private_keys)
privatekey = RSA.importKey(private_key)
pks = PKCS1_v1_5.new(privatekey)
# 分段加密
encrypt_text = []
for text in range(0, len(decrption_content), 100):
cont = decrption_content[text:text+100]
encrypt_text.append(pks.encrypt(cont.encode()))
# 加密完进行拼接
cipher_text = b''.join(encrypt_text)
# base64进行编码
result = base64.b64encode(cipher_text)
try:
return {'code': 200, 'data': result, 'msg': 'success'}
except Exception as e:
return {'code': 203, 'data': f'加密失败，失败原因：{e}', 'msg': 'fail'}
def rsa_decrypt(self, private_keys, encryption_content):
"""
rsa封装调用解密
:param private_keys: 字节流（私钥）
:param encryption_content: 加密数据
:return:字典，数据存在data中，成功code为200，失败code为203
"""
try:
private_key = self.__handle_pub_key(private_keys) # 生成完整私钥
byte_stream_key = bytes(private_key, encoding=self.characters) # 生成字节流
encryption_content = self.__decryption(encryption_content, byte_stream_key)
return {'code': 200, 'data': encryption_content, 'msg': 'success'}
except Exception as e:
return {'code': 203, 'data': f'解密失败，失败原因：{e}', 'msg': 'fail'}
def md5_encryption(self, encrypt_data: str):
"""
md5加密算法
:param encrypt_data: 字符串参数值
:param characters: 字符格式，默认utf-8
:return: 字典，数据存在data中，成功code为200，失败code为203
"""
try:
return {'code': 200, 'data': hashlib.md5(encrypt_data.encode(encoding=self.characters)).hexdigest(), 'msg': 'success'}
except Exception as e:
return {'code': 203, 'data': f'加密失败，失败原因：{e}', 'msg': 'fail'}
def hmac_encryption(self, kyes, encrypt_data: str, methods='md5'):
"""
hamc加密
介绍：散列消息鉴别码，基于加密hash函数和共享密钥的消息认证协议，实现原来是公开函数和密钥产生一个固定长度的值作为认证标识
:param kyes: 密钥
:param encrypt_data: 待加密的字符串
:param methods: 加密方式
:return: 字典，数据存在data中，成功code为200，失败code为203
"""
try:
return {'code': 200, 'data': hmac.new(kyes.encode(encoding=self.characters),encrypt_data.encode(encoding=self.characters),digestmod=methods).hexdigest(), 'msg': 'success'}
except Exception as e:
return {'code': 203, 'data': f'加密失败，失败原因：{e}', 'msg': 'fail'}
def sha256_encryption(self, encrypt_data: str):
"""
sha256加密
:param encrypt_data: 待加密的字符串
:return: 字典，数据存在data中，成功code为200，失败code为203
"""
try:
return {'code': 200, 'data': hashlib.sha256(encrypt_data.encode(encoding=self.characters)).hexdigest(), 'msg': 'success'}
except Exception as e:
return {'code': 203, 'data': f'加密失败，失败原因：{e}', 'msg': 'fail'}
def sha1_encryption(self, encrypt_data: str):
"""
sha1加密
:param encrypt_data: 待加密的字符串
:return: 字典，数据存在data中，成功code为200，失败code为203
"""
try:
return {'code': 200, 'data': hashlib.sha1(encrypt_data.encode(encoding=self.characters)).hexdigest(), 'msg': 'success'}
except Exception as e:
return {'code': 203, 'data': f'加密失败，失败原因：{e}', 'msg': 'fail'}
def base64_de_en_cryption(self, encrypt_data: str, methodes: str = 'en'):
"""
base64加密、解密
:param encrypt_data: 待加密的字符串
:param methodes: 加密en、解密de
:return: 字典，数据存在data中，成功code为200，失败code为203
"""
try:
if methodes != 'en':
return {'code': 200, 'data': base64.b64decode(bytes(encrypt_data, self.characters).decode(self.characters)).decode(self.characters), 'msg': 'success'}
# return {'code': 200, 'data': , 'msg': 'success'}
return {'code': 200, 'data': base64.b64encode(encrypt_data.encode(encoding=self.characters)).decode(encoding=self.characters), 'msg': 'success'}
except Exception as e:
return {'code': 203, 'data': f'解密/加密失败，失败原因：{e}', 'msg': 'fail'}
def des_encrypt(self, secret_key, encrypt_data: str):
"""
des加密
:param secret_key: 加密的key
:param encrypt_data: 加密的数据
:return: 字典，数据存在data中，成功code为200，失败code为203
"""
try:
return {'code': 200, 'data': binascii.b2a_hex(des(secret_key, CBC, secret_key, pad=None, padmode=PAD_PKCS5).encrypt(encrypt_data, padmode=PAD_PKCS5)).decode(self.characters), 'msg':'success'}
except Exception as e:
return {'code': 203, 'data': f'加密失败，失败原因：{e}', 'msg': 'fail'}
def des_decrypt(self, secret_key, encrypt_data: str):
"""
des解密
:param secret_key: 加密的key
:param encrypt_data: 加密的数据
:return: 字典，数据存在data中，成功code为200，失败code为203
"""
try:
return {'code':200, 'data': des(secret_key, CBC, secret_key, pad=None, padmode=PAD_PKCS5).decrypt(binascii.a2b_hex(encrypt_data), padmode=PAD_PKCS5).decode(self.characters), 'msg': 'success'}
except Exception as e:
return {'code': 203, 'data': f'解密失败，失败原因：{e}', 'msg': 'fail'}
if __name__ == '__main__':
text_encrypted_base64 = ''
key = ''
das = ''
Algorithm().rsa_encrypt(key, das)
print(Algorithm().md5_encryption('@@@@'))
print(Algorithm().hmac_encryption('','123456', 'sha256'))
print(Algorithm().sha256_encryption('123456'))
print(Algorithm().base64_de_en_cryption('123456'))
print(Algorithm().base64_de_en_cryption('',methodes='de'))
print(Algorithm().des_encrypt('12345678','12'))
print(Algorithm().des_decrypt('12345678','e108208a06200c57'))
总结
例如：以上就是大部分的加密算法，本文仅仅简单介绍了加密与解密的使用。
724
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
