class CTR:
def __init__(self, key, ctr, block_size=16):
self.crypto = LEA(key)
self.ctr = to_bytearray(ctr)
self.bloc_size = block_size
'''
ctr을 +1 씩 업데이트 하는 함수
'''
def cal_ctr(self):
for i in range((self.bloc_size - 1),
(self.bloc_size - 1) - self.bloc_size, -1):
if self.ctr[i] != 0xff:
self.ctr[i] += 1
break
else:
self.ctr[i] = 0
def encrypt(self, pt):
self.buffer = bytearray() #return buffer
self.pt = to_bytearray(pt)
self.ptlength = len(pt) #return length
'''
16의 배수에 맞게 cnt 설정
'''
cnt = int(len(self.pt) / self.bloc_size)
if ((len(self.pt) / self.bloc_size) != 0):
cnt = len(pad(self.pt))
for i in range(cnt):
self.buffer += xorAr(self.crypto.encrypt(
self.ctr), self.pt[(self.bloc_size * i):(self.bloc_size * i) +
self.bloc_size]) #암호화 진행
self.cal_ctr() #ctr update
return self.buffer[:self.ptlength]
def decrypt(self, ct):
self.buffer = bytearray() #return buffer
self.ct = ct
self.ctlength = len(ct) #return length
'''
16의 배수에 맞게 cnt 설정
'''
cnt = int(len(self.ct) / self.bloc_size)
if ((len(self.ct) / self.bloc_size) != 0):
cnt = len(pad(self.ct))
for i in range(cnt):
self.buffer += xorAr(self.crypto.encrypt(
self.ctr), self.ct[(self.bloc_size * i):(self.bloc_size * i) +
self.bloc_size]) #암호화 진행
self.cal_ctr() #ctr update
return self.buffer[:self.ctlength]
class ECB:
def __init__(self, key, block_size=16):
self.crypto = LEA(key) #암호 알고리즘 호출
self.block_size = block_size #block size
def encrypt(self, pt):
self.buffer = bytearray() #리턴할 buffer
self.pt = pad(pt) #padding
self.pt = to_bytearray(self.pt) #to bytearray
cnt = int(len(self.pt) / self.block_size) #count
'''
암호화 진행
'''
for i in range(cnt):
buf = self.pt[(self.block_size * i):(self.block_size * i) +
self.block_size] #block 자르기
enc = self.crypto.encrypt(buf)
self.buffer += enc
return self.buffer
def decrypt(self, ct):
self.buffer = bytearray() #리턴할 buffer
self.ct = ct
cnt = int(len(self.ct) / self.block_size) #count
'''
복호화 진행
'''
for i in range(cnt):
buf = self.ct[(self.block_size * i):(self.block_size * i) +
self.block_size] #block 자르기
dec = self.crypto.decrypt(buf)
self.buffer += dec
self.buffer = unpad(self.buffer) #unpadding
return self.buffer
def __init__(self, key, block_size=16):
self.crypto = LEA(key) #암호 알고리즘 호출
self.block_size = block_size #block size
def __init__(self, key, iv, block_size=16):
self.crypto = LEA(key)
self.iv = to_bytearray(iv)
self.block_size = block_size
class OFB:
def __init__(self, key, iv, block_size=16):
self.crypto = LEA(key)
self.iv = to_bytearray(iv)
self.block_size = block_size
def encrypt(self, pt):
self.buffer = bytearray() #return할 buffer
self.enciv = bytearray() #암호화 시킨 iv를 한꺼번에 저장할 buffer
self.pt = to_bytearray(pt)
self.ptlength = len(pt) #리턴시킬 암호문 길이
'''
block count 설정
16배수면 그대로
16배수가 아니면 padding을 통해 16배수로 만들어주고 count 설정
'''
cnt = int(len(pad(self.pt)) / self.block_size)
if ((len(self.pt) % self.block_size) != 0):
cnt = len(pad(self.pt)) / self.block_size
'''
iv 미리 계산
'''
tmp = self.iv #입력 iv
for i in range(cnt - 1):
tmp = self.crypto.encrypt(tmp)
self.enciv += tmp #iv계산 저장
'''
암호화 진행
'''
for i in range(cnt):
buf1 = self.enciv[(self.block_size * i):(self.block_size * i) +
self.block_size] #block size에 맞게 미리 계산한 iv 자르기
buf2 = self.pt[(self.block_size * i):(self.block_size * i) +
self.block_size] #block size로 평문 자르기
self.buffer += xorAr(buf1, buf2) #xor 진행
return self.buffer[:self.ptlength] #평문 길이만큼 return
def decrypt(self, ct):
self.buffer = bytearray() #return buffer
self.enciv = bytearray() #계산한 iv를 한꺼번에 저장할 buffer
self.ctlength = len(ct) #return할 cipher text의 길이 저장
self.ct = ct
'''
16배수이면 그대로
16배수가 아니면 패딩해서 16배수로 맞춘다음 count 설정
'''
cnt = int(len(pad(self.ct)) / self.block_size)
if ((len(self.ct) % self.block_size) != 0):
cnt = len(pad(self.ct)) / self.block_size
'''
iv 미리 계산
'''
tmp = self.iv
for i in range(cnt - 1):
tmp = self.crypto.encrypt(tmp)
self.enciv += tmp
for i in range(cnt):
buf1 = self.enciv[
(self.block_size * i):(self.block_size * i) +
self.block_size] #미리 계산한 enciv buffer를 block size에 맞게 자르기
buf2 = self.ct[(self.block_size * i):(self.block_size * i) +
self.block_size] #block size에 맞게 cipher text 자르기
self.buffer += xorAr(buf1, buf2) #xor 진행
return self.buffer[:self.ctlength]
def __init__(self, key, ctr, block_size=16):
self.crypto = LEA(key)
self.ctr = to_bytearray(ctr)
self.bloc_size = block_size
def __init__(self, key,iv, block_size = 16):
self.crypto = LEA(key) #암호 알고리즘 선언
self.iv = to_bytearray(iv) #iv convert to byte array
self.block_size = block_size #block size setting
class CFB:
def __init__(self, key,iv, block_size = 16):
self.crypto = LEA(key) #암호 알고리즘 선언
self.iv = to_bytearray(iv) #iv convert to byte array
self.block_size = block_size #block size setting
def encrypt(self, pt):
self.buffer = bytearray() #return buffer
self.pt = to_bytearray(pt) #plain text convert to bytearray
self.ptlength = len(pt) #return할 cipher ptext 길이
'''
평문의 길이가 16의 배수이면 그대로 cnt설정
16의 배수가 아니면 padding을 해서 16의 배수로 만든 다음 cnt 설정
'''
cnt = int(len(self.pt)/self.block_size)
if((len(self.pt)/self.block_size) != 0):
cnt = len(pad(self.pt))
c0 = self.iv #cipher block
for i in range(cnt-1):
buf = self.pt[(self.block_size * i) : (self.block_size*i) + self.block_size] #block size로 plain text 자르기
c0 = self.crypto.encrypt(c0) #암호화
c0 = xorAr(buf, c0) #xor 진행 and cipher block update
self.buffer += c0 #adding block
return self.buffer[:self.ptlength]
def decrypt(self, ct):
self.buffer = bytearray() #return buffer
self.enciv = bytearray() #미리 계산할 iv를 저장하는 buffer
self.ct = ct
self.ctlength = len(ct) #return length
'''
만약 cipher block의 크기가 16의 배수가 아니면 padding해서 16배수로 맞춘다.
'''
if len(self.ct)%self.block_size != 0:
self.ct = pad(ct)
cnt = int(len(self.ct)/self.block_size) #count setting
c0 = self.iv #초기 입력
'''
iv 미리 계산
'''
self.enciv += self.crypto.encrypt(c0) #cipher block 저장 (미리 iv 계산)
for i in range(cnt-1):
buf = self.ct[(self.block_size * i) : (self.block_size * i) + self.block_size] #cipher text 자르기
self.enciv += self.crypto.encrypt(buf) #cipher block 추가
'''
복호화 진행
'''
for i in range(cnt):
buf1 = self.enciv[(self.block_size * i) : (self.block_size*i) + self.block_size] #미리 계산한 iv를 block size에 맞게 자르기
buf2 = self.ct[(self.block_size * i) : (self.block_size*i) + self.block_size] #block size에 맞게 cipher text 자르기
self.buffer += xorAr(buf1,buf2) #xor 진행
return self.buffer[:self.ctlength]