FilesExpand file tree

master

/

util.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

65 lines (56 loc) · 1.95 KB

master

/

util.py

Copy path

Top

File metadata and controls

• Code
• Blame

65 lines (56 loc) · 1.95 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

'''

Cryptographic functions to encrypt/decrypt data like CryptoJS

Adapted from

http://stackoverflow.com/questions/36762098/how-to-decrypt-password-from-javascript-cryptojs-aes-encryptpassword-passphras

'''

from Crypto import Random

from Crypto.Cipher import AES

import base64

import string

import random

from hashlib import md5

BLOCK_SIZE = 16

def pad(data):

length = BLOCK_SIZE - (len(data) % BLOCK_SIZE)

return data + (chr(length)*length).encode()

def unpad(data):

return data[:-(data[-1] if type(data[-1]) == int else ord(data[-1]))]

def bytes_to_key(data, salt, output=48):

# extended from https://gist.github.com/gsakkis/4546068

assert len(salt) == 8, len(salt)

data += salt

key = md5(data).digest()

final_key = key

while len(final_key) < output:

key = md5(key + data).digest()

final_key += key

return final_key[:output]

def encrypt(message, passphrase):

salt = Random.new().read(8)

key_iv = bytes_to_key(passphrase, salt, 32+16)

key = key_iv[:32]

iv = key_iv[32:]

aes = AES.new(key, AES.MODE_CBC, iv)

aes = AES.new(key, AES.MODE_CBC, iv)

return base64.b64encode(b"Salted__" + salt + aes.encrypt(pad(message)))

def decrypt(encrypted, passphrase):

encrypted = base64.b64decode(encrypted)

assert encrypted[0:8] == b"Salted__"

salt = encrypted[8:16]

key_iv = bytes_to_key(passphrase, salt, 32+16)

key = key_iv[:32]

iv = key_iv[32:]

aes = AES.new(key, AES.MODE_CBC, iv)

return unpad(aes.decrypt(encrypted[16:]))

def generate_passphrase(length):

chars = string.letters + string.digits

return ''.join(random.choice(chars) for _ in range(length))

if __name__ == "__main__":

passphrase = generate_passphrase(8)

pt = b'Hi Blockonomics!'

ct = encrypt(pt, passphrase)

decrypted_ct = decrypt(ct, passphrase)

print("Plain text: " + pt)

print("Cipher text: " + ct.encode('hex'))

assert decrypted_ct == pt

#print("pt", decrypt(encrypt(pt, password), password))