1 #!/usr/bin/env python
2
3 '''
4
5 Python Crypto Wrapper - By Chase Schultz
6
7 Currently Supports: AES-256, RSA Public Key, RSA Signing, ECC Public Key, ECC Signing
8
9 Dependencies: pyCrypto - https://github.com/dlitz/pycrypto
10 PyECC - https://github.com/rtyler/PyECC
11
12
13 Python Cryptography Wrapper based on pyCrypto
14 Copyright (C) 2011 Chase Schultz - chaschul@uat.edu
15
16 This program is free software: you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation, either version 3 of the License, or
19 (at your option) any later version.
20
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
25
26 You should have received a copy of the GNU General Public License
27 along with this program. If not, see <http://www.gnu.org/licenses/>.
28
29
30 '''
31
32 __author__ = 'Chase Schultz'
33 __version__ = '0.1'
34
35 import os
36 import base64
37 from Crypto.Cipher import AES
38 from Crypto.PublicKey import RSA
39 from Crypto.Hash import SHA256
40 from pyecc import ECC
41
42 class CryptoWrapper():
43
44 '''AES Cipher Specifics'''
45 blockSize = 16 #Block Size
46 keySize = 32 #keySize in Bytes - 32 bytes = 256bit Encryption
47 mode = AES.MODE_CBC #Cipher Block Mode
48
49 def __init__(self):
50
51 pass
52
53 def __generateAESKeystring__(self):
54 '''Generates Pseudo Random AES Key and Base64 Encodes Key - Returns AES Key'''
55 key = os.urandom(self.keySize)
56 keyString = base64.urlsafe_b64encode(str(key))
57 return keyString
58
59 def __extractAESKey__(self, keyString):
60 '''Extracts Key from Base64 Encoding'''
61 key = base64.urlsafe_b64decode(keyString)
62 if len(key) != self.keySize:
63 raise Exception('Error: Key Invalid')
64 os._exit(1)
65 return key
66
67 def __extractCrypto__(self, encryptedContent):
68 '''Decodes Base64 Encoded Crypto'''
69 cipherText = base64.urlsafe_b64decode(encryptedContent)
70 return cipherText
71
72 def __encodeCrypto__(self, encryptedContent):
73 '''Encodes Crypto with Base64'''
74 encodedCrypto = base64.urlsafe_b64encode(str(encryptedContent))
75 return encodedCrypto
76
77 def aesEncrypt(self, data):
78 '''Encrypts Data w/ pseudo randomly generated key and base64 encodes cipher - Returns Encrypted Content and AES Key'''
79 key = self.__generateAESKeystring__()
80 encryptionKey = self.__extractAESKey__(key)
81 pad = self.blockSize - len(data) % self.blockSize
82 data = data + pad * chr(pad)
83 iv = os.urandom(self.blockSize)
84 cipherText = AES.new(encryptionKey, self.mode, iv).encrypt(data)
85 encryptedContent = iv + cipherText
86 encryptedContent = self.__encodeCrypto__(encryptedContent)
87 return encryptedContent, key
88
89 def aesDecrypt(self, key, data):
90 '''Decrypts AES(base64 encoded) Crypto - Returns Decrypted Data'''
91 decryptionKey = self.__extractAESKey__(key)
92 encryptedContent = self.__extractCrypto__(data)
93 iv = encryptedContent[:self.blockSize]
94 cipherText = encryptedContent[self.blockSize:]
95 plainTextwithpad = AES.new(decryptionKey, self.mode, iv).decrypt(cipherText)
96 pad = ord(plainTextwithpad[-1])
97 plainText = plainTextwithpad[:-pad]
98 return plainText
99
100 def generateRSAKeys(self,keyLength):
101 '''Generates Public/Private Key Pair - Returns Public / Private Keys'''
102 private = RSA.generate(keyLength)
103 public = private.publickey()
104 privateKey = private.exportKey()
105 publicKey = public.exportKey()
106 return privateKey, publicKey
107
108 def rsaPublicEncrypt(self, pubKey, data):
109 '''RSA Encryption Function - Returns Encrypted Data'''
110 publicKey = RSA.importKey(pubKey)
111 encryptedData = publicKey.encrypt(data,'')
112 return encryptedData
113
114 def rsaPrivateDecrypt(self, privKey, data):
115 '''RSA Decryption Function - Returns Decrypted Data'''
116 privateKey = RSA.importKey(privKey)
117 decryptedData = privateKey.decrypt(data)
118 return decryptedData
119
120 def rsaSign(self, privKey, data):
121 '''RSA Signing - Returns an RSA Signature'''
122 privateKey = RSA.importKey(privKey)
123 if privateKey.can_sign() == True:
124 digest = SHA256.new(data).digest()
125 signature = privateKey.sign(digest,'')
126 return signature
127 else:
128 raise Exception("Error: Can't Sign with Key")
129
130 def rsaVerify(self, pubKey, data, signature):
131 '''Verifies RSA Signature based on Data received - Returns a Boolean Value'''
132 publicKey = RSA.importKey(pubKey)
133 digest = SHA256.new(data).digest()
134 return publicKey.verify(digest, signature)
135
136 def eccGenerate(self):
137 '''Generates Elliptic Curve Public/Private Keys'''
138 ecc = ECC.generate()
139 publicKey = ecc._public
140 privateKey = ecc._private
141 curve = ecc._curve
142 return privateKey, publicKey, curve
143
144 def eccEncrypt(self,publicKey, curve, data):
145 '''Encrypts Data with ECC using public key'''
146 ecc = ECC(1, public=publicKey, private='', curve=curve)
147 encrypted = ecc.encrypt(data)
148 return encrypted
149
150 def eccDecrypt(self,privateKey, curve, data):
151 '''Decrypts Data with ECC private key'''
152 ecc = ECC(1, public='', private=privateKey, curve=curve)
153 decrypted = ecc.decrypt(data)
154 return decrypted
155
156 def eccSign(self, privateKey, curve, data):
157 '''ECC Signing - Returns an ECC Signature'''
158 ecc = ECC(1, public='', private=privateKey, curve=curve)
159 signature = ecc.sign(data)
160 return signature
161
162 def eccVerify(self, publicKey, curve, data, signature):
163 '''Verifies ECC Signature based on Data received - Returns a Boolean Value'''
164 ecc = ECC(1, public=publicKey, private='', curve=curve)
165 return ecc.verify(data, signature)
166
167 if __name__ == '__main__':
168 '''Usage Examples'''
169
170 print '''
171
172 Python Crypto Wrapper - By Chase Schultz
173
174 Currently Supports: AES-256, RSA Public Key, RSA Signing, ECC Public Key, ECC Signing
175
176 Dependencies: pyCrypto - https://github.com/dlitz/pycrypto
177 PyECC - https://github.com/rtyler/PyECC
178
179 '''
180
181 '''Instantiation of Crypto Wrapper and Message'''
182 crypto = CryptoWrapper();
183 message = 'Crypto Where art Thou... For ye art a brother...'
184 print 'Message to be Encrypted: %s\n' % message
185
186
187 '''AES ENCRYPTION USAGE'''
188 '''***Currently Supporting AES-256***'''
189 encryptedAESContent, key = crypto.aesEncrypt(message)
190 print 'Encrypted AES Message: %s\nEncrypted with Key: %s' % (encryptedAESContent, key)
191 decryptedAESMessage = crypto.aesDecrypt(key, encryptedAESContent)
192 print '\nDecrypted AES Content: %s\n' % decryptedAESMessage
193
194
195 '''RSA ENCRYPTION USAGE'''
196 privateKey, publicKey = crypto.generateRSAKeys(2048)
197
198 encryptedRSAContent = crypto.rsaPublicEncrypt(publicKey, message)
199 print 'Encrypted RSA Message with RSA Public Key: %s\n' % encryptedRSAContent
200 decryptedRSAMessage = crypto.rsaPrivateDecrypt(privateKey, encryptedRSAContent)
201 print '\nDecrypted RSA Content with RSA Private Key: %s\n' % decryptedRSAMessage
202
203
204 '''RSA SIGNING USAGE'''
205 signature = crypto.rsaSign(privateKey, message)
206 print 'Signature for message is: %s\n ' % signature
207 if crypto.rsaVerify(publicKey, message, signature) is False:
208 print 'Could not Verify Message\n'
209 else:
210 print 'Verified RSA Content\n'
211
212 '''ECC ENCRYPTION USAGE'''
213 eccPrivateKey, eccPublicKey, eccCurve = crypto.eccGenerate()
214
215 encryptedECCContent = crypto.eccEncrypt(eccPublicKey, eccCurve , message)
216 print 'Encrypted ECC Message with ECC Public Key: %s\n' % encryptedECCContent
217 decryptedECCContent = crypto.eccDecrypt(eccPrivateKey, eccCurve, encryptedECCContent)
218 print 'Decrypted ECC Content with ECC Private: %s\n' % decryptedECCContent
219
220 '''ECC SIGNING USAGE'''
221 signature = crypto.eccSign(eccPrivateKey, eccCurve, message)
222 print 'Signature for message is: %s\n ' % signature
223 if crypto.eccVerify(eccPublicKey, eccCurve, message, signature) is False:
224 print 'Could not Verify Message\n'
225 else:
226 print 'Verified ECC Content\n'
227
228
229
