python 3des加密_DES/3DES之ECB模式和CBC模式加解密 及 Python 实现

概念说明

DES：Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法。

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

ECB模式：ECB(Electronic Codebook，电码本)模式是分组密码的一种最基本的工作模式。

CBC模式：Cipher Block Chaining，密文分组链接模式。

DES在ECB模式和CBC模式加解密的流程框图：

3DES在ECB模式和CBC模式加解密的流程框图：

原理其实和DES的是差不多的，算法上只是多做了两步加解密步骤，如算法所示

加密过程：C=DES{(DES-1[(DES(KL8&P)&KR8]&KL8},P为明文，KL8密钥的左8字节，KL8密钥的右8字节,C为密文

解密过程：P=DES{(DES-1[(DES(KL8&C)&KR8]&KL8}

python 实现

pyDes.py

#############################################################################

# Documentation #

#############################################################################

# Author: Todd Whiteman

# Date: 16th March, 2009

# Verion: 2.0.0

# License: Public Domain - free to do as you wish

# Homepage: http://twhiteman.netfirms.com/des.html

#

# This is a pure python implementation of the DES encryption algorithm.

# It's pure python to avoid portability issues, since most DES

# implementations are programmed in C (for performance reasons).

#

# Triple DES class is also implemented, utilising the DES base. Triple DES

# is either DES-EDE3 with a 24 byte key, or DES-EDE2 with a 16 byte key.

#

# See the README.txt that should come with this python module for the

# implementation methods used.

#

# Thanks to:

# * David Broadwell for ideas, comments and suggestions.

# * Mario Wolff for pointing out and debugging some triple des CBC errors.

# * Santiago Palladino for providing the PKCS5 padding technique.

# * Shaya for correcting the PAD_PKCS5 triple des CBC errors.

#

"""A pure python implementation of the DES and TRIPLE DES encryption algorithms.

Class initialization

--------------------

pyDes.des(key, [mode], [IV], [pad], [padmode])

pyDes.triple_des(key, [mode], [IV], [pad], [padmode])

key -> Bytes containing the encryption key. 8 bytes for DES, 16 or 24 bytes

for Triple DES

mode -> Optional argument for encryption type, can be either

pyDes.ECB (Electronic Code Book) or pyDes.CBC (Cypher Block Chaining)

IV -> Optional Initial Value bytes, must be supplied if using CBC mode.

Length must be 8 bytes.

pad -> Optional argument, set the pad character (PAD_NORMAL) to use during

all encrypt/decrpt operations done with this instance.

padmode -> Optional argument, set the padding mode (PAD_NORMAL or PAD_PKCS5)

to use during all encrypt/decrpt operations done with this instance.

I recommend to use PAD_PKCS5 padding, as then you never need to worry about any

padding issues, as the padding can be removed unambiguously upon decrypting

data that was encrypted using PAD_PKCS5 padmode.

Common methods

--------------

encrypt(data, [pad], [padmode])

decrypt(data, [pad], [padmode])

data -> Bytes to be encrypted/decrypted

pad -> Optional argument. Only when using padmode of PAD_NORMAL. For

encryption, adds this characters to the end of the data block when

data is not a multiple of 8 bytes. For decryption, will remove the

trailing characters that match this pad character from the last 8

bytes of the unencrypted data block.

padmode -> Optional argument, set the padding mode, must be one of PAD_NORMAL

or PAD_PKCS5). Defaults to PAD_NORMAL.

Example

-------

from pyDes import *

data = "Please encrypt my data"

k = des("DESCRYPT", CBC, "\0\0\0\0\0\0\0\0", pad=None, padmode=PAD_PKCS5)

# For Python3, you'll need to use bytes, i.e.:

# data = b"Please encrypt my data"

# k = des(b"DESCRYPT", CBC, b"\0\0\0\0\0\0\0\0", pad=None, padmode=PAD_PKCS5)

d = k.encrypt(data)

print "Encrypted: %r" % d

print "Decrypted: %r" % k.decrypt(d)

assert k.decrypt(d, padmode=PAD_PKCS5) == data

See the module source (pyDes.py) for more examples of use.

You can also run the pyDes.py file without and arguments to see a simple test.

Note: This code was not written for high-end systems needing a fast

implementation, but rather a handy portable solution with small usage.

"""

import sys

# _pythonMajorVersion is used to handle Python2 and Python3 differences.

_pythonMajorVersion = sys.version_info[0]

# Modes of crypting / cyphering

ECB = 0

CBC = 1

# Modes of padding

PAD_NORMAL = 1

PAD_PKCS5 = 2

# PAD_PKCS5: is a method that will unambiguously remove all padding

# characters after decryption, when originally encrypted with

# this padding mode.

# For a good description of the PKCS5 padding technique, see:

# http://www.faqs.org/rfcs/rfc1423.html

# The base class shared by des and triple des.

class _baseDes(object):

def __init__(self, mode=ECB, IV=None, pad=None, padmode=PAD_NORMAL):

if IV:

IV = self._guardAgainstUnicode(IV)

if pad:

pad = self._guardAgainstUnicode(pad)

self.block_size = 8

# Sanity checking of arguments.

if pad and padmode == PAD_PKCS5:

raise ValueError("Cannot use a pad character with PAD_PKCS5")

if IV and len(IV) != self.block_size:

raise ValueError("Invalid Initial Value (IV), must be a multiple of " + str(self.block_size) + " bytes")

# Set the passed in variables

self._mode = mode

self._iv = IV

self._padding = pad

self._padmode = padmode

def getKey(self):

"""getKey() -> bytes"""

return self.__key

def setKey(self, key):

"""Will set the crypting key for this object."""

key = self._guardAgainstUnicode(key)

self.__key = key

def getMode(self):

"""getMode() -> pyDes.ECB or pyDes.CBC"""

return self._mode

def setMode(self, mode):

"""Sets the type of crypting mode, pyDes.ECB or pyDes.CBC"""

self._mode = mode

def getPadding(self):

"""getPadding() -> bytes of length 1. Padding character."""

return self._padding

def setPadding(self, pad):

"""setPadding() -> bytes of length 1. Padding character."""

if pad is not None:

pad = self._guardAgainstUnicode(pad)

self._padding = pad

def getPadMode(self):

"""getPadMode() -> pyDes.PAD_NORMAL or pyDes.PAD_PKCS5"""

return self._padmode

def setPadMode(self, mode):

"""Sets the type of padding mode, pyDes.PAD_NORMAL or pyDes.PAD_PKCS5"""

self._padmode = mode

def getIV(self):

"""getIV() -> bytes"""

return self._iv

def setIV(self, IV):

"""Will set the Initial Value, used in conjunction with CBC mode"""

if not IV or len(IV) != self.block_size:

raise ValueError("Invalid Initial Value (IV), must be a multiple of " + str(self.block_size) + " bytes")

IV = self._guardAgainstUnicode(IV)

self._iv = IV

def _padData(self, data, pad, padmode):

# Pad data depending on the mode

if padmode is None:

# Get the default padding mode.

padmode = self.getPadMode()

if pad and padmode == PAD_PKCS5:

raise ValueError("Cannot use a pad character with PAD_PKCS5")

if padmode == PAD_NORMAL:

if len(data) % self.block_size == 0:

# No padding required.

return data

if not pad:

# Get the default padding.

pad = self.getPadding()

if not pad:

raise ValueError("Data must be a multiple of " + str(

self.block_size) + " bytes in length. Use padmode=PAD_PKCS5 or set the pad character.")

data += (self.block_size - (len(data) % self.block_size)) * pad

elif padmode == PAD_PKCS5:

pad_len = 8 - (len(data) % self.block_size)

if _pythonMajorVersion < 3:

data += pad_len * chr(pad_len)

else:

data += bytes([pad_len] * pad_len)

return data

def _unpadData(self, data, pad, padmode):

# Unpad data depending on the mode.

if not data:

return data

if pad and padmode == PAD_PKCS5:

raise ValueError("Cannot us