【题目】

实现 CBC 模式和 OFB 模式的 AES 算法，具体要求：

    A. 实现 AES 算法的上述两种模式的加密过程，由用户输入密钥，可以对任
意输入的不小于 10M 的文本文件内容进行加密；

    B. 根据用户输入的密钥，对不小于 10M 的文本文件对应的密文进行解密；

【代码实现】

#!/usr/bin/env python
# -*- coding:utf-8 -*- 
# Author: sjk
# coding:utf-8
import random
import time
import copy
import codecs

class AESE():
	def __init__(self, blk, key, Nr):  # 构造函数 blk:传入明文asc码列表，最大16字节，key:传入密码asc码列表，Nr:轮数
		self.blk = blk  # 明文列表
		self.key = key  # 密码列表
		self.Nr = Nr
		self.sbox = (0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
		             0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
		             0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
		             0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
		             0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
		             0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
		             0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
		             0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
		             0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
		             0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
		             0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
		             0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
		             0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
		             0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
		             0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
		             0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16)

	# xtime process
	def xtime(self, x):
		# 如果a7为1，进行亦或运算，与0x1b亦或
		if (x & 0x80):
			return (((x << 1) ^ 0x1b) & 0xff)
		return x << 1

	# 列混合
	def MixColumns(self):
		tmp = [0 for t in range(4)]
		xt = [0 for q in range(4)]
		n = 0
		for x in range(4):
			xt[0] = self.xtime(self.blk[n])
			xt[1] = self.xtime(self.blk[n + 1])
			xt[2] = self.xtime(self.blk[n + 2])
			xt[3] = self.xtime(self.blk[n + 3])
			tmp[0] = xt[0] ^ xt[1] ^ self.blk[n + 1] ^ self.blk[n + 2] ^ self.blk[n + 3]
			tmp[1] = self.blk[n] ^ xt[1] ^ xt[2] ^ self.blk[n + 2] ^ self.blk[n + 3]
			tmp[2] = self.blk[n] ^ self.blk[n + 1] ^ xt[2] ^ xt[3] ^ self.blk[n + 3]
			tmp[3] = xt[0] ^ self.blk[n] ^ self.blk[n + 1] ^ self.blk[n + 2] ^ xt[3]
			self.blk[n] = tmp[0]
			self.blk[n + 1] = tmp[1]
			self.blk[n + 2] = tmp[2]
			self.blk[n + 3] = tmp[3]
			n = n + 4

     #行移位
	def ShiftRows(self):
		# 2nd row
		t = self.blk[1]
		self.blk[1] = self.blk[5]
		self.blk[5] = self.blk[9]
		self.blk[9] = self.blk[13]
		self.blk[13] = t
		# 3nd row
		t = self.blk[2]
		self.blk[2] = self.blk[10]
		self.blk[10] = t
		t = self.blk[6]
		self.blk[6] = self.blk[14]
		self.blk[14] = t
		# 4nd row
		t = self.blk[15]
		self.blk[15] = self.blk[11]
		self.blk[11] = self.blk[7]
		self.blk[7] = self.blk[3]
		self.blk[3] = t

	# 字节替换
	def SubBytes(self):
		for x in range(16):
			self.blk[x] = self.sbox[self.blk[x]]
     
     #轮密钥加
	def AddRoundKey(self, key):
		x = 0
		k = [0 for m in range(16)]
		for c in range(4):
			for r in range(4):
				k[x] = key[r][c]
				x = x + 1
		for y in range(16):
			self.blk[y] ^= int(k[y])
		# 打印

	def show(self):
		for i in range(16):
			print(hex(self.blk[i]))
		# Schedule a secret key for use.
  
    #密钥扩展
	def ScheduleKey(self, w, Nk):
         #轮常量值表
		Rcon = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]

         #w横着排  初始化初始密钥
		for r in range(4):
			for c in range(4):
				w[0][r][c] = self.key[r + c * 4]

         #初始化剩余10轮密钥  i是轮数， j列， r是行
		for i in range(1, self.Nr + 1, 1):
			for j in range(Nk):
				t = [0 for x in range(4)]
				for r in range(4):
					if j:
						t[r] = w[i][r][j - 1]
					else:
						t[r] = w[i - 1][r][3]
				if j == 0:
					temp = t[0]
					for r in range(3):
						t[r] = self.sbox[t[(r + 1) % 4]]
					t[3] = self.sbox[temp]
					t[0] ^= int(Rcon[i - 1])
				for r in range(4):
					w[i][r][j] = w[i - 1][r][j] ^ t[r]

	# 加密函数
	def AesEncrypt(self):

		outkey = [[[0 for col in range(4)] for row in range(4)] for s in range(11)]
		self.ScheduleKey(outkey, 4)
		self.AddRoundKey(outkey[0])
		for x in range(1, self.Nr, 1):
			self.SubBytes()
			self.ShiftRows()
			self.MixColumns()
			self.AddRoundKey(outkey[x])
		self.SubBytes()
		self.ShiftRows()
		self.AddRoundKey(outkey[10])
		return self.blk
  


class AESD():
	def __init__(self, blk, key, Nr):
		self.blk = blk
		self.key = key
		self.Nr = Nr
		self.sbox = (0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
		             0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
		             0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
		             0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
		             0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
		             0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
		             0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
		             0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
		             0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
		             0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
		             0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
		             0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
		             0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
		             0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
		             0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
		             0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16)

	def xtime(self, x):
		if (x & 0x80):
			return (((x << 1) ^ 0x1b) & 0xff)
		return x << 1

	def ReMixColumns(self):
		tmp = [0 for q in range(4)]
		xt1 = [0 for w in range(4)]
		xt2 = [0 for e in range(4)]
		xt3 = [0 for r in range(4)]
		n = 0
		for x in range(4):
			xt1[0] = self.xtime(self.blk[n])
			xt1[1] = self.xtime(self.blk[n + 1])
			xt1[2] = self.xtime(self.blk[n + 2])
			xt1[3] = self.xtime(self.blk[n + 3])
			xt2[0] = self.xtime(self.xtime(self.blk[n]))
			xt2[1] = self.xtime(self.xtime(self.blk[n + 1]))
			xt2[2] = self.xtime(self.xtime(self.blk[n + 2]))
			xt2[3] = self.xtime(self.xtime(self.blk[n + 3]))
			xt3[0] = self.xtime(self.xtime(self.xtime(self.blk[n])))
			xt3[1] = self.xtime(self.xtime(self.xtime(self.blk[n + 1])))
			xt3[2] = self.xtime(self.xtime(self.xtime(self.blk[n + 2])))
			xt3[3] = self.xtime(self.xtime(self.xtime(self.blk[n + 3])))
			tmp[0] = xt1[0] ^ xt2[0] ^ xt3[0] ^ self.blk[n + 1] ^ xt1[1] ^ xt3[1] ^ self.blk[n + 2] ^ xt2[2] ^ xt3[2] ^ \
			         self.blk[n + 3] ^ xt3[3]
			tmp[1] = self.blk[n] ^ xt3[0] ^ xt1[1] ^ xt2[1] ^ xt3[1] ^ self.blk[n + 2] ^ xt1[2] ^ xt3[2] ^ self.blk[
				n + 3] ^ xt2[3] ^ xt3[3]
			tmp[2] = self.blk[n] ^ xt2[0] ^ xt3[0] ^ self.blk[n + 1] ^ xt3[1] ^ xt1[2] ^ xt2[2] ^ xt3[2] ^ self.blk[
				n + 3] ^ xt1[3] ^ xt3[3]
			tmp[3] = self.blk[n] ^ xt1[0] ^ xt3[0] ^ self.blk[n + 1] ^ xt2[1] ^ xt3[1] ^ self.blk[n + 2] ^ xt3[2] ^ xt1[
				3] ^ xt2[3] ^ xt3[3]
			self.blk[n] = tmp[0]
			self.blk[n + 1] = tmp[1]
			self.blk[n + 2] = tmp[2]
			self.blk[n + 3] = tmp[3]
			n = n + 4

	def ReShiftRows(self):
		# 2nd row
		t = self.blk[13]
		self.blk[13] = self.blk[9]
		self.blk[9] = self.blk[5]
		self.blk[5] = self.blk[1]
		self.blk[1] = t
		# 3rd row
		t = self.blk[2]
		self.blk[2] = self.blk[10]
		self.blk[10] = t
		t = self.blk[6]
		self.blk[6] = self.blk[14]
		self.blk[14] = t
		# 4th row
		t = self.blk[3]
		self.blk[3] = self.blk[7]
		self.blk[7] = self.blk[11]
		self.blk[11] = self.blk[15]
		self.blk[15] = t

	def ReSubBytes(self):
		for i in range(16):
			for j in range(256):
				if (self.sbox[j] == self.blk[i]):
					self.blk[i] = j
					break

	def AddRoundKey(self, key):
		x = 0
		k = [0 for m in range(16)]
		for c in range(4):
			for r in range(4):
				k[x] = key[r][c]
				x = x + 1
		for y in range(16):
			self.blk[y] ^= k[y]

	def ScheduleKey(self, w, Nk):
		Rcon = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]
		for r in range(4):
			for c in range(4):
				w[0][r][c] = self.key[r + c * 4]
		for i in range(1, self.Nr + 1, 1):
			for j in range(Nk):
				t = [0 for x in range(4)]
				for r in range(4):
					if j:
						t[r] = w[i][r][j - 1]
					else:
						t[r] = w[i - 1][r][3]
				if j == 0:
					temp = t[0]
					for r in range(3):
						t[r] = self.sbox[t[(r + 1) % 4]]
					t[3] = self.sbox[temp]
					t[0] ^= int(Rcon[i - 1])
				for r in range(4):
					w[i][r][j] = w[i - 1][r][j] ^ t[r]

	def AesDecrpyt(self, sign='ECB'):
		outkey = []
		outkey = [[[0 for col in range(4)] for row in range(4)] for s in range(11)]  # 改
		self.ScheduleKey(outkey, 4)
		self.AddRoundKey(outkey[10])
		self.ReShiftRows()
		self.ReSubBytes()

		for x in range(self.Nr - 1, 0, -1):
			self.AddRoundKey(outkey[x])
			self.ReMixColumns()  # 第二次循环出问题了
			self.ReShiftRows()
			self.ReSubBytes()
		self.AddRoundKey(outkey[0])
		if (sign == 'ECB'):
			mText = ""
			for x in range(16):
				mText += chr(self.blk[x])
			return mText
		elif sign == 'CBC':
			return self.blk

#把每个字符变成对应的10进制数， 返回列表
def StringToListN(string):
	s = [0 for x in range(16)]
	l = len(string)
	for x in range(l):
		s[x] = int(ord(string[x]))
	return s


def octToHex(oct):
	out = []
	hex_list = [hex(x) for x in oct]
	for i in hex_list:
		out.append("%02x" % int(i[2:], 16))
	hex_cipher = ""
	for i in out:
		hex_cipher += i
	return hex_cipher

def HexToOctList(route):
	with codecs.open(route,'r') as f:
		content=f.read()
	octList=[]
	length=len(content)
	for i in range(0, length, 2):
		octList.append(int(content[i:i + 2], 16))
	return octList
 
#读取文本字符串
def getPlainText(route):
	with codecs.open(route,'r') as f:
		plainText=f.read()
	return plainText
def ECB(route,skey):
	stratTime=time.time()
	# --------------加密--------------------
	plainText = getPlainText(route) #我加的
	key = StringToListN(skey)
	length = len(plainText)
	cipher = []
	if length <= 16:
		blk = StringToListN(plainText)
		a = AESE(blk, key, 10)
		rblk = a.AesEncrypt()
		cipher.extend(rblk)
	else:
		for group in range(0, length, 16):
			blk = StringToListN(plainText[group:group + 16])
			a = AESE(blk, key, 10)
			cipher.extend(a.AesEncrypt())
	print("16进制密文为:")
	hex_cipher = octToHex(cipher)
	print(hex_cipher)
	runTime=round(time.time()-stratTime,2)
	print("加密时长为%f s"%runTime)
	# ----------------------------解密-------------------
	stratTime = time.time()
	plain = ""
	c_length = len(cipher)
	if c_length <= 16:
		blk = cipher
		a = AESD(blk, key, 10)
		rblk = a.AesDecrpyt()
		plain += rblk
	else:
		for group in range(0, c_length, 16):
			blk = cipher[group:group + 16]
			# print(blk)
			a = AESD(blk, key, 10)
			rblk = a.AesDecrpyt()
			plain += rblk
		# print(plain)
	print("解密密文为:")
	print(plain)
	runTime = round(time.time() - stratTime, 2)
	print("解密时长为%f"%runTime)

def CBC(route,skey):
	# 构造初始化向量
	random.seed(time.time())
	vector = [random.randint(20, 126) for y in range(16)] #16个10进制数作为初始向量
	print("初始向量为:", end="------")
	print(vector)
	original_vector = copy.deepcopy(vector) #深拷贝
	print("开始加密")
	plainText = getPlainText(route)  #得到明文字符串read()
	stratTime = time.time()
	# ------------------加密--------------------
	key = StringToListN(skey) #16个asccii码作为key
	length = len(plainText)
	cipher = []
	xor_blk = [0 for x in range(16)]
    #明文长度不超过16个字符
	if length <= 16:
		blk = StringToListN(plainText)
		print(blk)
		for i in range(16):
			xor_blk[i] = (blk[i] ^ vector[i])
		a = AESE(xor_blk, key, 10)
		rblk = a.AesEncrypt()
		cipher.extend(rblk)
	else:
		for group in range(0, length, 16):
			blk = StringToListN(plainText[group:group + 16])
			for i in range(16):
				xor_blk[i] = (blk[i] ^ vector[i])
			a = AESE(xor_blk, key, 10)
			group_cypher = a.AesEncrypt()
			cipher.extend(group_cypher)
			vector = copy.deepcopy(group_cypher)
	# print(cipher)
	hex_cipher = octToHex(cipher)
	with codecs.open(r"C:\Users\HP\Desktop\aes密文.txt",'w','utf-8') as f:
		f.write(hex_cipher)
	runTime = round(time.time() - stratTime, 2)
	print("加密时长为%f s" % runTime)
	# ----------------------------解密---------------------
	# print(original_vector)
	cipher=HexToOctList(r"C:\Users\HP\Desktop\aesCBC密文.txt")
	print("开始解密")
	stratTime = time.time()
	plain = ""
	c_length = len(cipher)
	# print(c_length)
	if c_length <= 16:
		blk = cipher
		a = AESD(blk, key, 10)
		rblk = a.AesDecrpyt('CBC')
		for i in range(16):
			xor_blk[i] = original_vector[i] ^ rblk[i]
		mText = ""
		for x in range(16):
			mText += chr(xor_blk[x])
		plain += mText
	else:
		for group in range(0, c_length, 16):
			newblk = cipher[group:group + 16]  # 原密文
			# print(newblk)
			a = AESD(newblk, key, 10)
			rblk = a.AesDecrpyt('CBC')  # 解密后密文
			for i in range(16):
				xor_blk[i] = original_vector[i] ^ rblk[i]
			original_vector = cipher[group:group + 16]  # 更新异或密文
			# print(original_vector)
			mText = ""
			for x in range(16):
				mText += chr(xor_blk[x])
			plain += mText
	with codecs.open(r"C:\Users\love锋\Desktop\aesCBC解密明文.txt",'w','utf-8') as f:
		f.write(plain)
	runTime = round(time.time() - stratTime, 2)
	print("解密时长为%f" % runTime)

def OFB(route,skey):
	# 构造初始化向量
	random.seed(time.time())
	vector = [random.randint(20, 126) for y in range(16)]
	original_vector = copy.deepcopy(vector)
	print("初始向量为:", end="-----")
	print(vector)
	print("开始加密")
	stratTime = time.time()
	plainText = getPlainText(route)
	# -------------------------加密--------------------------
	key = StringToListN(skey)
	length = len(plainText)
	cipher = []
	xor_blk = [0 for x in range(16)]
	if length <= 16:
		blk = StringToListN(plainText)
		a = AESE(vector, key, 10)  # 加密初始化向量
		rblk = a.AesEncrypt()
		for i in range(16):
			xor_blk[i] = blk[i] ^ rblk[i]
		cipher.extend(xor_blk)
	else:
		for group in range(0, length, 16):
			blk = StringToListN(plainText[group:group + 16])
			a = AESE(vector, key, 10)
			# print(vector)
			rblk = a.AesEncrypt()
			for i in range(16):
				xor_blk[i] = blk[i] ^ rblk[i]
			cipher.extend(xor_blk)
	# print(cipher)
	hex_cipher = octToHex(cipher)
	with codecs.open(r"C:\Users\HP\Desktop\aesOFB密文.txt",'w','utf-8') as f:
		f.write(hex_cipher)
	runTime = round(time.time() - stratTime, 2)
	print("加密时长为%f s" % runTime)
	# ------------------------解密--------------------
	stratTime = time.time()
	plain = ""
	c_length = len(cipher)
	# print(c_length)
	if c_length <= 16:
		blk = cipher
		# print(original_vector)
		a = AESE(original_vector, key, 10)
		rblk = a.AesEncrypt()
		for i in range(16):
			xor_blk[i] = original_vector[i] ^ blk[i]
		# print(xor_blk)
		mText = ""
		for x in range(16):
			mText += chr(xor_blk[x])
		plain += mText
	else:
		for group in range(0, c_length, 16):
			blk = cipher[group:group + 16]  # 原密文
			# print(newblk)
			a = AESE(original_vector, key, 10)
			rblk = a.AesEncrypt()  # 解密后密文
			for i in range(16):
				xor_blk[i] = rblk[i] ^ blk[i]
			# print(original_vector)
			mText = ""
			for x in range(16):
				mText += chr(xor_blk[x])
			plain += mText
	with codecs.open(r"C:\Users\HP\Desktop\aes解密OFB明文.txt",'w','utf-8') as f:
		f.write(plain)
	runTime = round(time.time() - stratTime, 2)
	print("解密时长为%f" % runTime)

def main():
	choice = '''
	选择加密方式
	(E)CB
	(C)BC
	(O)FB
	(Q)uit
	'''
	while True:
		your_choice = input(choice).lower()
		if your_choice not in "ecqo":
			print("你的输入不符合要求，请重新输入:")
			continue
		route = input("请输入要加密的文件路径")
		skey = input("请输入加密秘钥")
		if your_choice == 'e':
			ECB(route,skey)
		elif your_choice == 'c':
			CBC(route,skey)
		elif your_choice == 'o':
			OFB(route,skey)
		elif your_choice == 'q':
			break
if __name__ == "__main__":
	main()