secretpack's blog

1. from crypto.PublicKey import RSA  
2.   
3. def rsa_encrypt(msg):  
4.     private_key = RSA.generate(1024)  
5.     public_key = private_key.publickey()  
6.     encdata = public_key.encrypt(msg, 32)  
7.   
8.     print encdata  
9.   
10.     decdata = private_key.decrypt(encdata)  
11.     print decdata  
12.   
13. if __name__ == '__main__':  
14.     msg = "very very lovely python"  
15.     rsa_encrypt(msg)  
16.     rsa_decrypt(msg)  

[ 코드 1 ] RSA 공개키 암호 

[ 코드 1 ]을 실행하면 다음과 같은 결과가 화면에 출력된다.

공개키로 암호화 한 결과는 튜플로 리턴되며 튜플의 첫번째 멤버가 암호 결과이다. 암호 결과는 128byte이다.

그런데 위의 코드는 실용적이지 못하다. 

프로그램이 종료되면 생성한 개인키와 공개키가 사라져 버리기 때문이다.

공개키는 잃어버려도 개인키만 있으면 공개키를 다시 부활시킬 수 있으니 개인 키만 잘 저장하면 된다.

가장 간단한 방법은 개인키를 파일로 저장하는 것이다.

[ RSA 개인키 파일 생성 ]

1. from Crypto.PublicKey import RSA  
2.   
3. def createPEM():  
4.     private_key = RSA.generate(1024)  
5.     f = open('mykey.pem', 'wb+')  
6.     f.write(private_key.exportKey('PEM'))  
7.     f.close()  
8.   
9. if __name__ == '__main__':  
10.     createPEM()  

[ 코드 2 ] RSA 개인키 파일 만들기

[ 코드 2 ] 는 128byte 개인키를 생성하고 'mykey.pem' 이라는 파일에 

개인키를 암호화된 정보로 저장하는 코드이다.

1. from Crypto.PublicKey import RSA  
2.   
3. def createPEM():  
4.     private_key = RSA.generate(1024)  
5.     f = open('mykey.pem', 'wb+')  
6.     f.write(private_key.exportKey('PEM'))  
7.     f.close()  
8.   
9. def readPEM():  
10.     h = open('mykey.pem', 'r')  
11.     key = RSA.importKey(h.read())  
12.     h.close()  
13.     return key  
14.   
15. def rsa_enc(msg):  
16.     private_key = readPEM()  
17.     Public_key = private_key.publickey()  
18.     encdata = Public_key.encrypt(msg, 32)  
19.   
20.     return encdata  
21.   
22. def rsa_dec(msg):  
23.     private_key = readPEM()  
24.     decdata = private_key.decrypt(msg)  
25.     return decdata  
26.   
27. if __name__ == '__main__':  
28.     msg = 'very very lovely python'  
29.       
30.     ciphered = rsa_enc(smg.encode('utf-8'))  
31.     print ciphered  
32.       
33.     deciphered = rsa_dec(ciphered)  
34.     print deciphered  

[ 코드 3 ] 개인키 파일을 이용한 RSA 공개키 암호 - rsa.py

1. from Crypto.Cipher import*  
2. from Crypto.Hash import SHA256 as SHA  
3. import os  
4.   
5. KSIZE = 1024  
6.   
7. class myDES():  
8.     def __init__(self, keytext, ivtext):  
9.         hash = SHA.new()  
10.         hash.update(keytext.encode('utf-8'))  
11.         key = hash.digest()  
12.         self.key = key[:24]  
13.   
14.         hash.update(ivtext.encode('utf-8'))  
15.         iv = hash.digest()  
16.         self.iv = iv[:8]  
17.   
18.     def makeEncInfo(self, filename):  
19.         fillersize = 0  
20.         filesize = os.path.getsize(filename)  
21.         if filesize % 8 != 0:  
22.             fillersize = 8 - filesize % 8  
23.         filler = '0'*fillersize  
24.         header = '%d'%(fillersize)  
25.         gap = 8 - len(header)  
26.         header += '#'*gap  
27.   
28.         return header, filler  
29.   
30.     def enc(self, filename):  
31.         encfilename = filename + '.enc'  
32.         header, filler = self.makeEncInfo(filename)  
33.         des3 = DES3.new(self.key, DES3.MODE_CBC, self.iv)  
34.   
35.         f = open(filename, 'rb')  
36.         p = open(encfilename, 'wb+')  
37.   
38.         enc = header.encode('utf-8')  
39.         content = f.read(KSIZE)  
40.         content = enc + content  
41.   
42.         while content:  
43.             if len(content) < KSIZE:  
44.                 content += filler.encode('utf-8')  
45.             enc = des3.encrypt(content)  
46.             p.write(enc)  
47.             content = f.read(KSIZE)  
48.         f.close()  
49.         p.close()  
50.   
51.     def dec(self, encfilename):  
52.         filename = encfilename + '.dec'  
53.         des3 = DES3.new(self.key, DES3.MODE_CBC, self. )  
54.   
55.         f = open(filename, 'wb+')  
56.         p = open(filename, 'rb')  
57.   
58.         content = p.read(8)  
59.         dec = des3.decrypt(content)  
60.         header = dec.decode()  
61.         fillersize = int(header.split('#')[0])  
62.   
63.         content = p.read(KSIZE)  
64.         while content:  
65.             dec = des3.decrpyt(content)  
66.             if len(dec) < KSIZE:  
67.                 if fillersize != 0:  
68.                     dec = dec[:-fillersize]  
69.             f.write(dec)  
70.             content = p.reae(KSIZE)  
71.         f.close()  
72.         p.close()  
73.   
74. if __name__ == "__main__":  
75.     keytext = 'iloveyou'  
76.     ivtext = '1234'  
77.     filename = 'plain.txt'  
78.     encfilename = filename + '.enc'  
79.   
80.     myCipher = myDES(keytext, ivtext)  
81.     myCipher.enc(filename)  
82.     myCipher.dec(encfilename)  

[코드 1] 3DES 파일 암 복호화 코드 - 3desforfile.py

설명

모든 크기의 파일에 대해 3DES로 암호화, 복호화 가능한 코드이다.

단문 메세지 암호화 코드와의 차이점은 지정된 파일에 있는 모든 내용을 읽고 암호화 한후 새로운 파일에 기록하는 부분이다. 단문 메세지 암호화 코드와 대비되는 코드를 살펴보자.

1.     def makeEncInfo(self, filename):  

지정된 파일 크기를 구하고 파일 크기가 8byte 배수가 아닐 경우 8바이트 배수로 만들기 위해 추가할 '0' 문자열을 구성한다. 그리고 추가할 문자 '0'의 개수에 대한 정보를 헤더로 만든다. 

헤더, 추가할 '0' 문자열을 리턴한다.

[ 암호화 로직 ]

1.         encfilename = filename + '.enc'  
2.         header, filler = self.makeEncInfo(filename)  

지정된 파일 내용을 1KB씩 읽어서 3DES로 암호화 한 후 새로운 파일에 저장한다.

암호화 된 내용을 저장할 파일 이름은 원래 파일 이름에 .enc 확장자를 추가하여 만든다.

self.makeEncInfo(filename)을 호출하여 헤더와 '0' 문자열을 얻고 각각 변수 header와 filler에 할당한다.

1.         enc = header.encode('utf-8')  
2.         content = f.read(KSIZE)  
3.         content = enc + content  

파일에서 1KB 씩 읽어서 content에 할당한다. header를 content 앞에 추가한다.

만약 파일 내용이 1KB 미만이면 file.read( )는 남아 있는 크기만큼 모두 읽는다.

1.         while content:  
2.             if len(content) < KSIZE:  
3.                 content += filler.encode('utf-8')  
4.             enc = des3.encrypt(content)  
5.             p.write(enc)  
6.             content = f.read(KSIZE)  

content에 내용이 없을 때 까지 while 구문을 수행한다.

만약 content의 크기가 KSIZE, 즉 1KB보다 작다면 파일의 끝까지 읽었다는 의미이다.

따라서 이부분에서 '0' 문자열을 content에 추가한다.

content를 3DES로 암호화하고 파일에 저장한 후, 파일에 다시 1KB만큼 읽어  content에 할당한다.

[ 복호화 로직 ]

dec(self, encfilename)은 encfilename 으로 지정된 암호화된 파일 내용을 

1KB 씩 읽어서 3DES로 복호화 한 후 새로운 파일에 저장한다.

1.         content = p.read(8)  
2.         dec = des3.decrypt(content)  
3.         header = dec.decode()  
4.         fillersize = int(header.split('#')[0])  

암호화 파일에서 최초 8byte를 읽어 3DES로 복호화 한다. 최초 8byte는 헤더이므로 '#'을 구분자로 헤더를 분리한 후 첫번째 멤버를 정수로 변환하면 이 파일의 끝부분에 추가된 문자 '0'의 개수를 얻을 수 있다.

1.         content = p.read(KSIZE)  
2.         while content:  
3.             dec = des3.decrpyt(content)  
4.             if len(dec) < KSIZE:  
5.                 if fillersize != 0:  
6.                     dec = dec[:-fillersize]  
7.             f.write(dec)  
8.             content = p.reae(KSIZE) 

암호화 파일에서 1KB를 먼저 읽고 content에 할당한다. content에 내용이 없을때 까지 반복 수행한다.

content를 3DES로 복호화 하고 파일에 저장한다.만약 복호화 한 결과가 1KB 보다 작으면 복호화 파일의 마지막 부분이므로 암호화 때 추가한 '0' 문자열을 제거하고 파일에 저장한다.

[ AES로 구현하기 ]

코드는 크게 틀리지 않다. 틀린 부분을 굵은 글씨로 표시하였다.

1. #-*- coding: utf-8 -*-  
2. from Crypto.Cipher import AES  
3. from Crypto.Hash import SHA256 as SHA  
4. import os  
5. KSIZE = 1024  
6.   
7. class myAES():  
8.     def __init__(self, keytext, ivtext):  
9.         hash = SHA.new()  
10.         hash.update(keytext.encode('utf-8'))  
11.         key = hash.digest()  
12.         self.key = key[:16]  
13.   
14.         hash.update(ivtext.encode('utf-8'))  
15.         iv = hash.digest()  
16.         self.iv = iv[:16]  
17.   
18.     def makeEncInfo(slef, filename):  
19.         fillersize = 0  
20.         filesize = os.path.getsize(filename)  
21.         if filesize % 16 != 0:  
22.             fillersize = 16 - filesize % 16  
23.   
24.         filler = '0'*fillersize  
25.         header = '%d' %(fillersize)  
26.         gap = 16 - len(header)  
27.         header += '#'*gap  
28.   
29.         return header, filler  
30.   
31.     def enc(self, filename):  
32.         encfilename = filename + '.enc'  
33.         header, filler = self.makfeEncInfo(filename)  
34.         aes = AES.new(self.key, AES.MODE_CBC, self.iv)  
35.   
36.         f = open(filename, 'rb')  
37.         p = open(encfilename, 'wb+')  
38.   
39.         enc = header.encode('utf-8')  
40.         content = f.read  
41.         content = enc + content  
42.   
43.         while content:  
44.             if len(content) < KSIZE:  
45.                 content += filler.encode('utf-8')  
46.   
47.             enc = aes.encrypt(content)  
48.             p = write(enc)  
49.             content = f.read(KSIZE)  
50.   
51.         f.close()  
52.         p.close()  
53.   
54.     def dec(self, encfilename):  
55.         filename = encfilename + '.dec'  
56.         aes = AES.new(self.key, AES.MODE_CBC, self.iv)  
57.   
58.         f.open(filename, 'wb+')  
59.         p = open(encfilename, 'rb')  
60.   
61.         content = p.read(16)  
62.         dec = aes.decrypt(content)  
63.         header = dec.decode()  
64.         fillersize = int(header.split('#')[0])  
65.   
66.         content = p.read(KSIZE)  
67.         while content:  
68.             dec = aes.decrypt(content)  
69.             if fillersize != 0:  
70.                 dec = dec[:-fillersize]  
71.             f.write(dec)  
72.             content = p.read(KSIZE)  
73.   
74.         f.close()  
75.         p.close()  

[코드 2] AES 파일 암 복호화 코드 - aesforfile.py

pycrypto는 스트림 암호를 위해 ARC4(Alleged RC4) 알고리즘을 제공한다.

스트림 암호는 보통 8bit 단위로 암호화를 수행하므로 암호 블록 크기는 1byte이다.

운영 모드로는 EBC 모드만 사용 가능하므로 초기화 벡터는 필요 없다.

따라서 ARC4 암호는 암호키만 정의되면 1문자 이상의 임의의 메세지에 대해 암 복호화가 가능하다.

1. from Crypto.Cipher import ARC4  
2. from Crypto.Hash import SHA256 as SHA  
3.   
4. class myARC4():  
5.     def __init__(self, keytext):  
6.         self.key = keytext  
7.   
8.     def enc(self, plaintext):  
9.         arc4 = ARC4.new(self.key)  
10.         encmsg = arc4.encrypt(plaintext)  
11.           
12.         return encmsg  
13.   
14.     def dec(self, ciphertext):  
15.         arc4 = ARC4.new(self.key)  
16.         decmsg = arc4.decrypt(ciphertext)  
17.   
18.         return decmsg  
19.   
20. if __name__ == "__main__":  
21.     keytext = 'iloveyou'  
22.     msg = 'imhapppy'  
23.   
24.     myCipher = myARC4(keytext)  
25.     ciphered = myCipher.enc(msg)  
26.     deciphered = myCipher.dec(ciphered)  
27.   
28.     print "ORIGINAL   : \t%s" %msg  
29.     print "CIPHERED   : \t%s" %ciphered  
30.     print "DECIPHERED : \t%s" %deciphered  

[코드 1] ARC4 단문 메세지 암 복호화 코드 - arc4.py

설명

1. class myARC4():  
2.     def __init__(self, keytext):  
3.         self.key = keytext  

myARC4라는 이름으로 클래스를 정의한다. keytext를 self.key에 변경 없이 그대로 할당한다.

나머지 부분은 이전에 사용했던 부분과 거의 동일하다. (3DES , AES 글 참고)

AES 단문 메세지 암 복호화

1. from Crypto.Cipher import AES  
2. from Crypto.Hash import SHA256 as SHA  
3.   
4. class myAES():  
5.     def __init__(self, keytext, ivtext):  
6.         hash = SHA.new()  
7.         hash.update(keytext.encode('utf-8'))  
8.         key = hash.digest()  
9.         self.key = key[:16]  
10.   
11.         hash.update(ivtext.encode('utf-8'))  
12.         iv = hash.digest()  
13.         self.iv = iv[:16]  
14.   
15.     def makeEnabled(self, palintext):  
16.         fillersize = 0  
17.         textsize = len(plaintext)  
18.   
19.         if textsize % 16 != 0:  
20.             fillersize = 16 - textsize % 16  
21.   
22.         filler = '0' * fillersize  
23.         header = '%d' % (fillersize)  
24.         gap = 16 - len(header)  
25.   
26.         return header + plaintext + filler  
27.   
28.     def enc(self, plaintext):  
29.         plaintext = self.makeEnabled(plaintext)  
30.         aes = AES.new(self.key, AES.MODE_CBC, self.iv)  
31.         encmsg = aes.encrypt(plaintext)  
32.   
33.         return encmsg  
34.   
35.     def dec(self, ciphertext):  
36.         aes = AES.new(self.key, AES.MODE_CBC, self.iv)  
37.         decmsg = aes.decrypt(ciphertext)  
38.   
39.         header = decmsg[:16].decode()  
40.         fillersize = int(header.split('#')[0])  
41.   
42.         if fillersize != 0:  
43.             decmsg = decmsg[16:-fillersize]  
44.   
45.         return decmsg  

[코드 1] AES 단문 메세지 암 복호화 코드 aesformsg.py

AES의 활용 예는 key의 크기(128, 192, 256 bit) 와 암호화 블록 크기(128bit)가 다른것 빼고는

3DES와 비슷하다. (3DES - pycrypto 3desformsg.py 참고)

설명

1.         self.key = key[:16]  

myAES 클래스의 생성자에서 self.key 값을 16byte로 만든다.

AES는 192bit, 256bit 키를 지원하므로, 키 크기를 바꾸고자 하는 경우 다음과 같이 한다.

1.     def makeEnabled(self, palintext):  

인자로 입력되는 plaintext의 크기가 16byte 배수가 아닐 경우 문자 '0'을 plaintext 끝에 추가하여 16byte의 배수로 만들고 이에 대한 정보를 헤더로 구성한 후 결과를 리턴한다.

헤더 구조는 3DES와 동일하게 구성하되, 헤더 크기는 16byte로 한다.

만약 plaintext를 16byte 배수로 만들기 위해 추가된 '0'의 개수가 12개일 경우 헤더는 다음과 같이 구성된다.

header = '12##############'

1.         plaintext = self.makeEnabled(plaintext)  

AES로 암호화하기 전

myAES 클래스의 makeEnabled( )로 plaintext를 "헤더 + 원래 정보 + '0' + 문자열" 로 변환한다.

1.         header = decmsg[:16].decode()  
2.         fillersize = int(header.split('#')[0])  
3.   
4.         if fillersize != 0:  
5.             decmsg = decmsg[16:-fillersize]  

복호화된 정보 decmsg의 처음 16byte를 변수 header에 할당한다.

split('#')으로 header를 '#'을 구분자로 분리한다. 

분리된 값 중 첫 번째를 정수로 변환하여 fillersize에 할당한다.

fillersize는 원래 정보 뒤에 추가한 문자 '0'의 개수이므로 

decmsg를 16에서 -fillersize까지 슬라이싱 하면 원래 정보가 추출된다.

[ pycrypto를 이용하여 3DES를 활용한 단문 메세지 암호화 도구 구현 ]

1. from Crypto.Cipher import DES3  
2. from Crypto.Hash import SHA256 as SHA  
3.   
4. class myDES():  
5.     def __init__(self, keytext, ivtext):  
6.         hash = SHA.new()  
7.         hash.update(keytext.encode('utf-8'))  
8.         key = hash.digest()  
9.         self.key = key[:24]  
10.   
11.         hash.update(ivtext.encode('utf-8'))  
12.         iv = hash.digest()  
13.         self.iv = iv[:8]  
14.   
15.     def enc(self, plaintext):  
16.         des3 = DES3.new(self.key, DES3.MODE_CBC, self.iv)  
17.         encmsg = des3.encrypt(plaintext)  
18.   
19.         return encmsg  
20.   
21.     def dec(self, ciphertext):  
22.         des3 = DES3.new(self.key, DES3.MODE_CBC, self.iv)  
23.         decmsg = des3.decrypt(ciphertext)  
24.   
25.         return decmsg  
26.   
27. if __name__ == '__main__':  
28.   
29.     keytext = 'iloveyou'  
30.     ivtext = '1234'  
31.     msg = 'imhapppy'  
32.   
33.     myCipher = myDES(keytext, ivtext)  
34.     ciphered = myCipher.enc(msg)  
35.     deciphered = myCipher.dec(ciphered)  
36.   
37.     print "Original   : \t%s" % msg  
38.     print "Ciphered   : \t%s" % ciphered  
39.     print "Deciphered : \t%s" % deciphered 

[코드 1] 3DES 단문 메세지 암복호화 코드 - 3desformsg.py

[ 설명 ]

'imhapppy'라는 8자리의 문장을 3DES CBC 모드로 암호화 하고

암호화된 문장을 3DES로 복호화 하는 소스코드 이다.

[ 코드 해석 ]

1. from Crypto.Cipher import DES3  
2. from Crypto.Hash import SHA256 as SHA  

3DES 라이브러리 사용을 위해 pycrypto의 필요한 모듈을 import 한다.
pycrypto의 3DES 모듈은 Crypto.Cipher.DES3 이다.

Crypto.Hash.SHA256 모듈은 3DES의 암호키와 초기화 백터를 만들때 활용한다.

SHA를 SHA256의 별명으로 사용한다.

1. class myDES():  

3DES를 위해 myDES라는 이름의 클래스를 정의한다.

이 클래스에는 암호화를 수행하는 enc( )와 복호화를 수행하는 dec( ) 메소드가 정의되어 있다.

1.     def __init__(self, keytext, ivtext):  

__init__( )은 클래스 생성자 이다.

인자 keytext는 3DES 암호키 생성을 위한 문자열이며 ivtext는 초기화 벡터를 위한 문자열이다.

클래스 생성자에서 3DES 객체 생성 시 사용할 키와 초기화 백터를 구한다.

keytext를 3DES가 지원하는 길이로 만들어서 이를 3DES의 키로 활용하면 보다 편리하다.

SHA256 해시는 이런 작업을 수행할 수 있는 훌륭한 도구이다.

1.         hash = SHA.new()  
2.         hash.update(keytext.encode('utf-8'))  
3.         key = hash.digest()  
4.         self.key = key[:24]  

SHA256.new( )를 이용해 SHA256 객체를 만들고 hash에 할당한다.

hash.update( )를 이용해 SHA256해시를 갱신하고 갱신하기 위해 사용된 인자는 keytext이다.

입력된 인자 값에 따라 갱신되는 해시값이 결정 된다.

SHA256.update( )의 인자로 유니코드로 된 문자열을 입력 받으면 오류메세지가 발생한다.

따라서 인자로 UTF-8로 인코딩한 문자열을 입력한다. 

hash.digest( )로 해시 값을 추출하여 변수 key에 할당한다.

SHA256은 256bit 해시를 생성하므로 변수 key는 256bit = 32byte 이다.

pycrypto에서 제공하는 3DES의 key 크기는 16byte 또는 24byte이다.

따라서 변수 key를 16byte 또는 24byte만큼 슬라이싱 하여 3DES의 key로 사용한다.

1.         hash.update(ivtext.encode('utf-8'))  
2.         iv = hash.digest()  
3.         self.iv = iv[:8] 

3DES는 64bit 암호화 블록 크기를 가진다. 따라서 초기화 벡터 또한 반드시 64bit가 되어야 한다.

암호키 생성기와 마찬가지로 초기화 벡터를 생성하기 위해서 SHA256 해시를 사용한다.

hash.update( ivtext )로 초기화 벡터를 위한 해시를 갱신하고 hash.digest( ) 해시값을 얻는다.

iv의 처음 8바이트를 초기화 벡터값으로 할당한다.

1.     def enc(self, plaintext):  
2.         des3 = DES3.new(self.key, DES3.MODE_CBC, self.iv)  
3.         encmsg = des3.encrypt(plaintext)  
4.   
5.         return encmsg  

enc( )는 인자로 입력된 plaintext에 담긴 문자열을 3DES로 암호화 한다.

암호화를 위해 먼저 DES3.new( )로 3DES 객체를 생성한다. 

DES3.new( )의 인자는 암호키, 운영모드, 초기화 벡터 순서이다

1.     def dec(self, ciphertext):  
2.         des3 = DES3.new(self.key, DES3.MODE_CBC, self.iv)  
3.         decmsg = des3.decrypt(ciphertext)  
4.   
5.         return decmsg  

복호화 또한 마찬가지로 DES3.new( )를 이용해 DES3 객체를 생성한다.

des3.decrypt( )로 암호문을 복호화 한다.

※ enc( )와 dec( )가 동일한 코드라서 객체를 만들어 활용하면 안된다.

1. if __name__ == '__main__':  
2.   
3.     keytext = 'iloveyou'  
4.     ivtext = '1234'  
5.     msg = 'imhapppy'  
6.   
7.     myCipher = myDES(keytext, ivtext)  
8.     ciphered = myCipher.enc(msg)  
9.     deciphered = myCipher.dec(ciphered)  
10.   
11.     print "Original   : \t%s" % msg  
12.     print "Ciphered   : \t%s" % ciphered  
13.     print "Deciphered : \t%s" % deciphered 

암호키 생성을 위한 keytext로 'iloveyou'를, 초기화 벡터 생성을 위한 ivtext로 '1234'를 이용한다.

우리가 기억하는 암호키는 'iloveyou'가 된다. 

실제 운영되는 암호키는 암호키의 SHA256해시값 중 처음 24byte가 된다. ivtext또한 마찬가지이다.

암호화 하려는 메세지는 'imhapppy' 이다.

[ 결과 ]

※ DOS 설정으로 인해 암호화된 문자들이 깨져 보이나 성공적으로 암호화 되었습니다.