1. Toy模板网首页
  2. > Toy博客

Python 基于pycryptodome，实现对AES、DES、3DES、RSA等常用加密算法的使用，文末附各种加密的源码示例

8月前 分类：Toy博客 阅读(73) 违法举报

这篇具有很好参考价值的文章主要介绍了Python 基于pycryptodome，实现对AES、DES、3DES、RSA等常用加密算法的使用，文末附各种加密的源码示例。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

Python 基于pycryptodome，实现对AES、DES、3DES、RSA、blowfish、RC4等常用加密算法的使用，文末附各种加密的源码示例

（中文名：加密圆顶）pycryptodome是一个基于c实现的Python库，它在2.x中支持2.7以上版本，或3.x中支持3.5以上版本的Python。

可以使用以下命令安装它：

pip install pycryptodome

该库支持以下特性

  • 认证加密模式 Authenticated encryption modes (GCM, CCM, EAX, SIV, OCB)
  • AES加密在英特尔上的加速 Accelerated AES on Intel platforms via AES-NI
  • 一种jit编译以提高运算速度 First class support for PyPy
  • 椭圆曲线加密 Elliptic curves cryptography (NIST curves P-192, P-224, P-256, P-384 and P-521)
  • 更好更紧凑的接口 Better and more compact API (nonce and iv attributes for ciphers, automatic generation of random nonces and IVs, simplified CTR cipher mode, and more)
  • 各种hash SHA-3 hash algorithms (FIPS 202) and derived functions (NIST SP-800 185):
    • SHAKE128 and SHA256 XOFs
    • cSHAKE128 and cSHAKE256 XOFs
    • KMAC128 and KMAC256
    • TupleHash128 and TupleHash256
  • 一个兄弟提出的算法 KangarooTwelve XOF (derived from Keccak)
  • SHA散列算法 Truncated hash algorithms SHA-512/224 and SHA-512/256 (FIPS 180-4)
  • 一种散列算法 BLAKE2b and BLAKE2s hash algorithms
  • 一种流式加密 Salsa20 and ChaCha20/XChaCha20 stream ciphers
  • Google所采用的一种新式加密算法 Poly1305 MAC
  • 也是Google新算法 ChaCha20-Poly1305 and XChaCha20-Poly1305 authenticated ciphers
  • 两种加密算法以及HKDF的推导函数 scrypt, bcrypt and HKDF derivation functions
  • DSA加密 Deterministic (EC)DSA
  • 密钥保护容器 Password-protected PKCS#8 key containers
  • 密钥分享方法 Shamir’s Secret Sharing scheme
  • 基于硬件的随机数 Random numbers get sourced directly from the OS (and not from a CSPRNG in userspace)
  • 简化的安装流程并且支持windows系统 Simplified install process, including better support for Windows
  • RSA和DSA的密钥生成器 Cleaner RSA and DSA key generation (largely based on FIPS 186-4)
  • 源码很漂亮 Major clean ups and simplification of the code base

更多文档可参考【官网文档】

概述

DES、3DES、AES都是对称加密算法，即一个密钥既用于加密也用于解密。而RSA是不对称加密，需要使用公钥和私钥分别进行加解密。

对称加密中通常需要三个参数，分别是密钥key，向量iv（一种初始的数值用于变更加密的走向以得到不同的加密结果）和密文content。

不论是DES、3DES，或者还是AES的加密，常用的主要分为MODE_CBC、MODE_CFB、MODE_ECB、MODE_OFB这四种，其他的如EAX等这里不作演示。

四种分组加密模式简介

MODE_ECB ECB（Electronic Codebook）电码本

  • 是一种简单加密
  • 这种模式不需要传入iv
  • 但是可能会被明文攻击
  • 密钥需要传入8位的bytes

MODE_CBC （Cipher-block chaining）密码分组链接

  • 需要传入8位bytes的iv
  • 密钥需要传入8位的bytes
  • 它不容易被主动攻击
  • 安全性好于ECB
  • 而且就算密文有损坏也还能继续解密
  • 适合加密大数据
  • 广泛用于SSL、IPSec中。

MODE_CFB CFB(Cipher FeedBack) 密钥反馈

  • 需要传入8位bytes的iv
  • 密钥需要传入8位的bytes
  • 密文损坏了会出问题

MODE_OFB （Output Feedback）输出反馈模式

  • 需要传入8位bytes的iv
  • 密钥需要传入8位的bytes
  • 密文损坏了会出问题

对称加密

DES加密

from Crypto.Cipher import DES

def padding_to(raw: bytes, padding: int, max_length: int = None):
    '''
    部分加解密是需要补齐位数到指定padding的
    '''
    c = len(raw)/padding
    block: int = int(c)
    if block != c:
        block += 1
    result = raw.ljust(padding*block, b'\0')
    if max_length:
        result = result[0:max_length]
    return result

def test_des(key,iv,content):
  # MODE_CBC
  e = DES.new(padding_to(key,8,8), DES.MODE_CBC, padding_to(iv,8,8)).encrypt(padding_to(content,8))
  d = DES.new(padding_to(key,8,8), DES.MODE_CBC, padding_to(iv,8,8)).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
  # MODE_CFB
  e = DES.new(padding_to(key,8,8), DES.MODE_CFB, padding_to(iv,8,8)).encrypt(padding_to(content,8))
  d = DES.new(padding_to(key,8,8), DES.MODE_CFB, padding_to(iv,8,8)).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
  # MODE_ECB no need for iv
  e = DES.new(padding_to(key,8,8), DES.MODE_ECB).encrypt(padding_to(content,8))
  d = DES.new(padding_to(key,8,8), DES.MODE_ECB).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
  # MODE_OFB
  e = DES.new(padding_to(key,8,8), DES.MODE_OFB, padding_to(iv,8,8)).encrypt(padding_to(content,8))
  d = DES.new(padding_to(key,8,8), DES.MODE_OFB, padding_to(iv,8,8)).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
config = {
        "key": "SGTSerfend2022",
        "iv": "1Ssecret1Ssecret1Ssecret"
    }
content = ('0123456789abcdefAAAAAAAAAA'*5).encode()
iv = str(config['iv']).encode()
key = str(config['key']).encode()
test_des(key,iv,content)

DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法，1977年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），并授权在非密级政府通信中使用，随后该算法在国际上广泛流传开来。需要注意的是，在某些文献中，作为算法的DES称为数据加密算法（Data Encryption Algorithm,DEA），已与作为标准的DES区分开来。

DES算法的入口参数有三个：Key、Data、Mode。其中Key为7个字节共56位，是DES算法的工作密钥；Data为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式,有两种:加密或解密。

密钥需要是56位（实际使用64位），iv需要是64位

3DES加密

from Crypto.Cipher import DES3

def padding_to(raw: bytes, padding: int, max_length: int = None):
    '''
    部分加解密是需要补齐位数到指定padding的
    '''
    c = len(raw)/padding
    block: int = int(c)
    if block != c:
        block += 1
    result = raw.ljust(padding*block, b'\0')
    if max_length:
        result = result[0:max_length]
    return result

def test_3des(key,iv,content):
  # MODE_CBC
  e = DES3.new(padding_to(key,24,24), DES3.MODE_CBC, padding_to(iv,8,8)).encrypt(padding_to(content,8))
  d = DES3.new(padding_to(key,24,24), DES3.MODE_CBC, padding_to(iv,8,8)).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
  # MODE_CFB
  e = DES3.new(padding_to(key,24,24), DES3.MODE_CFB, padding_to(iv,8,8)).encrypt(padding_to(content,8))
  d = DES3.new(padding_to(key,24,24), DES3.MODE_CFB, padding_to(iv,8,8)).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
  # MODE_ECB no need for iv
  e = DES3.new(padding_to(key,24,24), DES3.MODE_ECB).encrypt(padding_to(content,8))
  d = DES3.new(padding_to(key,24,24), DES3.MODE_ECB).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
  # MODE_OFB
  e = DES3.new(padding_to(key,24,24), DES3.MODE_OFB, padding_to(iv,8,8)).encrypt(padding_to(content,8))
  d = DES3.new(padding_to(key,24,24), DES3.MODE_OFB, padding_to(iv,8,8)).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
config = {
        "key": "SGTSerfend2022",
        "iv": "1Ssecret1Ssecret1Ssecret"
    }
content = ('0123456789abcdefAAAAAAAAAA'*5).encode()
iv = str(config['iv']).encode()
key = str(config['key']).encode()
test_3des(key,iv,content)

3DES（或称为Triple DES）是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。它相当于是对每个数据块应用三次DES加密算法。

由于计算机运算能力的增强，原版DES密码的密钥长度变得容易被暴力破解；3DES即是设计用来提供一种相对简单的方法，即通过增加DES的密钥长度来避免类似的攻击，而不是设计一种全新的块密码算法。

密钥需要是3 * 56 = 168位（实际使用192位），iv需要是64位

AES加密

from Crypto.Cipher import AES

def padding_to(raw: bytes, padding: int, max_length: int = None):
    '''
    部分加解密是需要补齐位数到指定padding的
    '''
    c = len(raw)/padding
    block: int = int(c)
    if block != c:
        block += 1
    result = raw.ljust(padding*block, b'\0')
    if max_length:
        result = result[0:max_length]
    return result

def test_aes(key,iv,content):
  # MODE_CBC
  e = AES.new(padding_to(key,32,32), AES.MODE_CBC, padding_to(iv,16,16)).encrypt(padding_to(content,16))
  d = AES.new(padding_to(key,32,32), AES.MODE_CBC, padding_to(iv,16,16)).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
  # MODE_CFB
  e = AES.new(padding_to(key,32,32), AES.MODE_CFB, padding_to(iv,16,16)).encrypt(padding_to(content,16))
  d = AES.new(padding_to(key,32,32), AES.MODE_CFB, padding_to(iv,16,16)).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
  # MODE_ECB no need for iv
  e = AES.new(padding_to(key,32,32), AES.MODE_ECB).encrypt(padding_to(content,16))
  d = AES.new(padding_to(key,32,32), AES.MODE_ECB).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
  # MODE_OFB
  e = AES.new(padding_to(key,32,32), AES.MODE_OFB, padding_to(iv,16,16)).encrypt(padding_to(content,16))
  d = AES.new(padding_to(key,32,32), AES.MODE_OFB, padding_to(iv,16,16)).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
config = {
        "key": "SGTSerfend2022",
        "iv": "1Ssecret1Ssecret1Ssecret"
    }
content = ('0123456789abcdefAAAAAAAAAA'*5).encode()
iv = str(config['iv']).encode()
key = str(config['key']).encode()
test_aes(key,iv,content)

这个标准用来替代原先的DES（Data Encryption Standard），已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院 （NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一 [1] 。

该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计，结合两位作者的名字，以Rijdael之名命之，投稿高级加密标准的甄选流程。（Rijdael的发音近于 “Rhine doll”。）

密钥需要是32位，iv需要是16位

blowfish加密

from Crypto.Cipher import Blowfish

def padding_to(raw: bytes, padding: int, max_length: int = None):
    '''
    部分加解密是需要补齐位数到指定padding的
    '''
    c = len(raw)/padding
    block: int = int(c)
    if block != c:
        block += 1
    result = raw.ljust(padding*block, b'\0')
    if max_length:
        result = result[0:max_length]
    return result

def test_Blowfish(key,iv,content):
  # MODE_CBC
  e = Blowfish.new(padding_to(key,32,32), Blowfish.MODE_CBC, padding_to(iv,8,8)).encrypt(padding_to(content,8))
  d = Blowfish.new(padding_to(key,32,32), Blowfish.MODE_CBC, padding_to(iv,8,8)).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
  # MODE_CFB
  e = Blowfish.new(padding_to(key,32,32), Blowfish.MODE_CFB, padding_to(iv,8,8)).encrypt(padding_to(content,8))
  d = Blowfish.new(padding_to(key,32,32), Blowfish.MODE_CFB, padding_to(iv,8,8)).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
  # MODE_ECB no need for iv
  e = Blowfish.new(padding_to(key,32,32), Blowfish.MODE_ECB).encrypt(padding_to(content,8))
  d = Blowfish.new(padding_to(key,32,32), Blowfish.MODE_ECB).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
  # MODE_OFB
  e = Blowfish.new(padding_to(key,32,32), Blowfish.MODE_OFB, padding_to(iv,8,8)).encrypt(padding_to(content,8))
  d = Blowfish.new(padding_to(key,32,32), Blowfish.MODE_OFB, padding_to(iv,8,8)).decrypt(e)
  print(f'e = {e}\nd = {d}\n\n')
config = {
        "key": "SGTSerfend2022",
        "iv": "1Ssecret1Ssecret1Ssecret"
    }
content = ('0123456789abcdefAAAAAAAAAA'*5).encode()
iv = str(config['iv']).encode()
key = str(config['key']).encode()
test_Blowfish(key,iv,content)

Blowfish是一个对称加密块算法，由Bruce Schneider于1993年设计，现已应用在多种加密产品。Blowfish能保证很好的加密速度，并且目前为止没有发现有效地破解方法。目前为止AES比Blowfish有更广的知名度。

密钥需要是32-448位（或1-14个字符），iv需要是8位

RC4加密

from Crypto.Cipher import ARC4


def test_rc4(key: bytes, content: bytes):
    e = ARC4.new(key).encrypt(content)
    d = ARC4.new(key).decrypt(e)
    print(f'e = {e}\nd = {d}\n\n')
    assert d == content


if __name__ == '__main__':
    config = {
        "key": "SGTSerfend2022",
    }
    content = ('0123456789abcdefAAAAAAAAAA'*5).encode()
    key = str(config['key']).encode()
    test_rc4(key, content)

非对称加密

RSA加密

整体测试示例代码
from Crypto.PublicKey import RSA
from Crypto.Signature import PKCS1_v1_5 as PKCS1_signature
from Crypto.Cipher import PKCS1_v1_5 as PKCS1_cipher
from Crypto.Hash import SHA
def test_rsa(content):
  rsa = RSA.generate(2048)
  public_key = rsa.public_key().export_key()
  private_key = rsa.export_key()
  print(f'public_key: {public_key}\n\nprivate_key: {private_key}\n')
  private_key = RSA.importKey(private_key)
  public_key = RSA.importKey(public_key)

  # sign a message
  signer = PKCS1_signature.new(private_key)
  digest = SHA.new()
  digest.update(content)
  sign = signer.sign(digest)
  print(f'sign: {sign}\n')

  # check sign for a message
  verifier = PKCS1_signature.new(public_key)
  digest = SHA.new()
  digest.update(content)
  sign_result = verifier.verify(digest,sign)
  print(f'the message check sign result is :{sign_result}\n')

  # encrypt rsa
  cipher = PKCS1_cipher.new(public_key)
  encrypt_text = cipher.encrypt(content)
  print(f'encrypt_text: {encrypt_text}\n')

  # decrypt rsa
  cipher = PKCS1_cipher.new(private_key)
  decrypt_text = cipher.decrypt(encrypt_text,b'')
  print(f'decrypt_text: {decrypt_text}\n')
content = ('0123456789abcdefAAAAAAAAAA'*5).encode()
test_rsa(content)

RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的 [1] 。

RSA公开密钥密码体制的原理是：根据数论，寻求两个大素数比较简单，而将它们的乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥 [4] 。

产生密钥对

可以是产生128 224 256 512 768 1024 2048等整数位数的密钥

from Crypto.PublicKey import RSA
rsa = RSA.generate(2048)
public_key = rsa.public_key().export_key()
private_key = rsa.export_key()
print(f'public_key: {public_key}\n\nprivate_key: {private_key}\n')
private_key = RSA.importKey(private_key)
public_key = RSA.importKey(public_key)
加解密

利用产生的密钥对，调用RSA.importKey分别导入公钥和私钥

from Crypto.Signature import PKCS1_v1_5 as PKCS1_signature
from Crypto.Cipher import PKCS1_v1_5 as PKCS1_cipher
content = ('0123456789abcdefAAAAAAAAAA'*5).encode()
# sign a message
signer = PKCS1_signature.new(private_key)
digest = SHA.new()
digest.update(content)
sign = signer.sign(digest)
print(f'sign: {sign}\n')

# check sign for a message
verifier = PKCS1_signature.new(public_key)
digest = SHA.new()
digest.update(content)
sign_result = verifier.verify(digest,sign)
print(f'the message check sign result is :{sign_result}\n')
校验签名（判断数据是否是可靠的，没有被篡改的）

使用SHA1等散列算法生成一个hash，用于生成签名

from Crypto.Signature import PKCS1_v1_5 as PKCS1_signature
from Crypto.Cipher import PKCS1_v1_5 as PKCS1_cipher
content = ('0123456789abcdefAAAAAAAAAA'*5).encode()
# encrypt rsa
cipher = PKCS1_cipher.new(public_key)
encrypt_text = cipher.encrypt(content)
print(f'encrypt_text: {encrypt_text}\n')

# decrypt rsa
cipher = PKCS1_cipher.new(private_key)
decrypt_text = cipher.decrypt(encrypt_text,b'')
print(f'decrypt_text: {decrypt_text}\n')

注意事项

padding_to方法是因为有些key、iv和待加密的数据的长度是需要是一些数值的倍数，不足长度的是需要补齐的，这里使用\0对其进行补齐

max_length是补齐后的最大长度，超过这个长度的数据将会被截取

def padding_to(raw: bytes, padding: int, max_length: int = None):
    '''
    部分加解密是需要补齐位数到指定padding的
    '''
    c = len(raw)/padding
    block: int = int(c)
    if block != c:
        block += 1
    result = raw.ljust(padding*block, b'\0')
    if max_length:
        result = result[0:max_length]
    return result

其他文档

  • CTF逆向-常用的逆向工具 提取码：pnbt
  • B站教程中国某省队CTF集训(逆向工程部分)
    • 中国某省队CTF集训(逆向工程部分)(已授权)(一)
    • 基础加密方式例如 XXTEA、Base64换表
    • Python库 Z3 方程式、不定式等的 约束求解
    • 基础的假跳转花指令(脏字节)
    • 非自然程序流程
      • 扁平化程序控制流
      • OLLVM程序流程（虚拟机壳） 很难一般不考
      • ida里面按X键跟踪，寻找所有Ty为w的引用（即类型是写入的），通常就是关键位置
    • 中国某省队CTF集训(逆向工程部分)(已授权)(二)
    • ollydb动调去壳，upx为例子
    • python的逆向和自定义虚拟指令
      • 使用pycdc 提取码：dorr 解密python编译的exe或者pyc
      • 逐条去解析用py字典手动实现的指令调用
      • C++编译的程序的逆向
    • 中国某省队CTF集训(逆向工程部分)(已授权)(三)
      • 简单模运算加密
      • base58 寻找一下特别大的数，这种数通常是算法的标识，或者ida7.7版本以上自带的find crypt插件ctrl+alt+f
      • 常见的关键位置是有新的内存分配的地方通常是关键地方，或者函数中间突然return的地方也是
      • 迷宫题 注意绘制出来就好
      • 动调题
        • 注意观察会执行的反调试分支，例如出现int 3，需要跳过去
  • 基本知识
    • 大小端序

更多CTF逆向题通用性做法和常用工具下载参考该博文内容：CTF逆向Reverse题的玩法

相关逆向CTF题

  • Python

    • Python反汇编方法 Python的pyc字节码反编译反汇编相关知识
    • [CTF逆向-羊城杯 2020]Bytecode-WP-Python字节码反编译

  • 远程调试汇编

    • CTF逆向-[watevrCTF 2019]Timeout-WP-远程调试和修改程序当前运行位置RIP

  • 流程控制

    • CTF逆向-Dig the way Interesting Pointer-通过栈溢出方式覆盖变量以达到修改执行流程的目的

  • 逆向思维

    • [CTF逆向-NPUCTF2020]Baby Obfuscation-逆向思维编写脚本以及函数含义的逻辑理解
    • [CTF逆向-MRCTF2020]EasyCpp - C++类型的逆向通用操作方法
    • [CTF逆向-SUCTF2018]babyre-WP-cpp简单迭代并按表输出值的爆破

  • 安卓

    • [CTF逆向-网鼎杯 2020 青龙组]bang-安卓脱壳逆向：frida-dexdump导出得到源码

  • 虚拟机

    • [CTF逆向-GWCTF 2019]babyvm-WP-虚机模拟流程反向编码和z3约束求解器解方程工具的使用
    • [CTF逆向-WMCTF2020]easy_re-WP_虚机-perl加载器截取

  • 反调试和SMC

    • [CTF逆向-SCTF2019]creakme-WP-基于AES加密算法下的保护：反调试及except_handler和SMC

  • 加密

    • Python 基于pycryptodome，实现对AES、DES、3DES、RSA等常用加密算法的使用，文末附各种加密的源码示例
    • [CTF逆向-FlareOn2]very_success-WP_rol循环位移加密
    • base64换表
      • [CTF逆向-CISCN2018]2ex-WP_mips-32架构以及base64换表
      • [CTF逆向-De1CTF2019]Re_Sign-简单脱壳和base64换表编码的深度算法跟踪

  • 花指令

    • [CTF逆向-SCTF2019]babyre-WP_简单去花指令和流程识别

  • 流程混淆的扁平化处理

    • [CTF逆向-RoarCTF2019]polyre-WP_控制流扁平化去混淆idcpy去指令

    • CTF逆向-[SUCTF2019]hardcpp-使用优化过的deflat.py处理混淆的控制流并将cpp的lambda解析得到实际处理逻辑文章来源地址https://www.toymoban.com/news/detail-406465.html

到了这里，关于Python 基于pycryptodome，实现对AES、DES、3DES、RSA等常用加密算法的使用，文末附各种加密的源码示例的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 关于怎么使用python实现 3DES 加密/解密

    3DES (Triple DES) 是一种对称加密算法，其特点是使用三次密钥加密来提高安全性。 3DES的原理是：对明文进行三次加密，每次加密的密钥不同。加密时，首先使用第一个密钥对明文进行加密，然后使用第二个密钥对加密后的数据进行解密，最后再使用第三个密钥对解密后的数据

    2024年02月15日
    浏览(28)

  • ssh命令报错no matching cipher found. Their offer: aes128-cbc,aes192-cbc,aes256-cbc,3des-cbc

    执行 ssh user@host 报错，信息如下: 协议不匹配 可以使用如下命令 ssh -c aes128-cbc,aes192-cbc,aes256-cbc,3des-cbc user@host 也可以修改 ~/.ssh/config文件 vi ~/.ssh/config 增加配置 Ciphers +aes128-cbc,aes192-cbc,aes256-cbc

    2024年02月13日
    浏览(34)
  • 通俗易懂，十分钟读懂DES，详解DES加密算法原理，DES攻击手段以及3DES原理。Python DES实现源码

    通俗易懂，十分钟读懂DES，详解DES加密算法原理，DES攻击手段以及3DES原理。Python DES实现源码

    DES（Data Encryption Standard）是一种 对称加密 算法。它是在20世纪70年代初期由IBM研发的。它的设计目标是提供高度的数据安全性和性能，并且能够在各种硬件和软件平台上实现。 DES使用56位的密钥和64位的明文块进行加密。DES算法的分组大小是64位，因此，如果需要加密的明文长

    2024年02月03日
    浏览(62)
  • Java实现3DES加密解密（DESede/ECB/PKCS5Padding使用）

    Java实现3DES加密解密（DESede/ECB/PKCS5Padding使用）

    3DES（又叫Triple DES）是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。 它相当于是对每个数据块 应用三次DES加密算法 。密钥长度是128位，192位(bit)，如果密码位数少于等于64位，加密结果与DES相同。 原版DES容易被破解，新的3DES出现，增加了加密安全性,避

    2023年04月09日
    浏览(37)

  • python实现rsa\aes\sm2\sm4加解密

    相关依赖： gmssl==3.2.2 pycryptodome == 3.9.7 基类： Rsa分段加解密实现(适用于pkcs1/8格式的2048bit私钥)： AES加解密： SM2加解密： SM4加解密： 利用枚举扩展： 使用：

    2024年02月16日
    浏览(25)
  • 关于Triple DES（3DES）对称加密算法

    关于Triple DES（3DES）对称加密算法

    一、引言 在网络安全领域，对称加密算法作为一种常见的加密手段，被广泛应用于保障数据传输的保密性和完整性。其中，DES（Data Encryption Standard）算法作为一种经典的对称加密算法，由IBM于1970年代开发，并于1977年被美国国家标准与技术研究院（NIST）确定为联邦信息处理标

    2024年02月04日
    浏览(44)

  • PHP 3DES加密

    不多说，直接上代码类 然后自行依据实际情况调用即可 自行了解引用，有测试示例在代码中 1. 2. 3. 4. 5. 6. 7.

    2024年02月13日
    浏览(41)
  • 3DES实验 思考与练习:

    3DES实验 思考与练习:

    T1：关于3DES的分析 和 库函数的思考——完全领悟了！！！ 分析过程： T(2): 使用openssl库函数 实现 DES加密: 使用函数DES_ecb_encrypt来进行数据加解密 void DES_ecb_encrypt(const_DES_cblock *input,DES_cblock *output, DES_key_schedule *ks,int enc); 函数功能说明：DES ECB计算 参数说明： input： 输入数据；

    2024年02月03日
    浏览(30)
  • 【密码算法 之一】对称加密算法 DES \ 3DES 浅析

    【密码算法 之一】对称加密算法 DES \ 3DES 浅析

      DES（Data Encryption Standard）是1977年美国联邦信息处理标准（FIPS）中所采用的一种对称密码（FIPS 46-3）。DES一直以来被美国以及其它国家的政府和银行等广泛使用。   然而，随着计算机的进步，现在DES已经能够被暴力破解，强度大不如从前了。20世纪末，RSA公司举办过破

    2024年02月09日
    浏览(45)
  • JavaScript学习 -- 对称加密算法3DES

    JavaScript学习 -- 对称加密算法3DES

    在现代的互联网时代，数据安全性备受关注。为了保护敏感数据的机密性，对称加密算法是一种常用的方法。在JavaScript中，3DES（Triple Data Encryption Standard）是一种常用的对称加密算法。本篇博客将为您展示如何在JavaScript中使用3DES算法进行加密和解密，并提供一个实际的例子

    2024年02月14日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包