-
Notifications
You must be signed in to change notification settings - Fork 0
/
key_gen.py
155 lines (139 loc) · 4.82 KB
/
key_gen.py
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
# -*- coding: utf-8 -*-
__author__ = 'whoami'
from rsa import newkeys, PublicKey, PrivateKey, encrypt, decrypt
from rsa.pkcs1 import DecryptionError
from base64 import b64decode, b64encode
from hashlib import new
from os.path import sep
from os.path import exists
def encode_md5(data):
"""
Кодирует переданную строку в md5
:param data: str строку для кодирования
:return: str md5-хэш
"""
md5 = new("md5")
md5.update(data)
return str(md5.hexdigest())
def rsa_gen_key(publicfile='public.key', privatefile='private.key'):
"""
генерируем ключи доступа
:param publicfile: имя будущего файла
:param privatefile: имя будущего файла
:return: в случае успеха возвращаем публичный и приватный ключи
"""
(pubkey, privkey) = newkeys(2048)
pckey = pubkey.save_pkcs1()
ptkey = privkey.save_pkcs1()
try:
with open(publicfile, 'wb') as f:
f.write(pckey)
with open(privatefile, 'wb') as f:
f.write(ptkey)
except IOError as e:
print("Error: %s" % e)
return None, None
else:
return pubkey, privkey
def rsa_load_key(public_file=None, private_file=None, dir=None):
"""
Загружаем ключи из файлов
:param public_file: файл публичного ключа
:param private_file: файл приватного ключа
:param dir: папка с ключами
:return: возвращаем публичный и приватный ключи
"""
try:
if dir:
if dir[-1] not in sep:
dir += sep
public_file = dir + 'public.key'
private_file = dir + 'private.key'
if not exists(public_file) or not exists(private_file):
raise IOError("Key files not found!")
with open(public_file, 'rb') as f:
public_file = f.read()
with open(private_file, 'rb') as f:
private_file = f.read()
pubkey = PublicKey.load_pkcs1(keyfile=public_file)
privkey = PrivateKey.load_pkcs1(keyfile=private_file)
return pubkey, privkey
except IOError as e:
print("Error: %s" % e)
return None, None
def rsa_encode(data, key):
"""
кодируем строку
:param data: строка для кодирования
:param key: публичный ключ
:return: результат кодирования
"""
try:
data = data.encode("utf8")
result = encrypt(data, key)
result = b64encode(result)
result = result.decode("ascii")
return result
except (UnicodeDecodeError,
UnicodeEncodeError) as e:
print(e)
return None
def rsa_decode(data, key):
"""
декодируем строку
:param data: строка
:param key: приватный ключ
:return: результат
"""
try:
data = data.encode("ascii")
data = b64decode(data)
result = decrypt(data, key)
result = result.decode("utf8")
return result
except (UnicodeDecodeError,
UnicodeEncodeError,
DecryptionError) as e:
print(e)
return None
# from base64 import b64decode, b64encode
#
# from Crypto.PublicKey import RSA
# from Crypto.Cipher import PKCS1_OAEP
#
#
# private_key = """-----BEGIN RSA PRIVATE KEY-----
# MIIBOQIBAAJBAKYbe7zyOFICAleubFhB9wxrhUmVjA6l0HHA9oV10z4dzVl9hd0v
# OVZe7kpK6X8+daRPdPHVDLmE/EReZE/8SlcCAwEAAQJAGtQLizvv/sbWTAUe+K5G
# 0Zm4IGdoBKGhZg4NgwbBxKFV9gXhykBoi3oVPJQdlHbxQeqapmt88QMhfA3WUj3+
# qQIhAPYfKjK2vqdgJLGImTBbU3z/70sAGou3KqQ2qe9QczSLAiEArMYxLgwAI2PX
# +tw3gv/3T/pn102OZ9gySAOpCFUSHuUCIDgqrIqeQawYuMb7EVqDvO3NymInR+eS
# iVyoTOecSG45AiBfnYtoDVIiQ8YqWacLA3cttsmy+IPf6mDhQ81PBC10FQIgEAuK
# 3lX7voXU2gb1xJ8yup7xvpfVhzWNjfvVSVoHZLY=
# -----END RSA PRIVATE KEY-----"""
#
# public_key = """-----BEGIN PUBLIC KEY-----
# MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKYbe7zyOFICAleubFhB9wxrhUmVjA6l
# 0HHA9oV10z4dzVl9hd0vOVZe7kpK6X8+daRPdPHVDLmE/EReZE/8SlcCAwEAAQ==
# -----END PUBLIC KEY-----"""
#
#
# def decrypt(private_key, message):
# rsa_key = RSA.importKey(private_key)
# rsa_key = PKCS1_OAEP.new(rsa_key)
# raw_cipher_data = b64decode(message)
# decrypted = rsa_key.decrypt(raw_cipher_data)
# return decrypted.decode('utf8')
#
#
# def encrypt(public_key, message):
# message = 'hello'.encode('utf8')
# rsa_key = RSA.importKey(public_key)
# rsa_key = PKCS1_OAEP.new(rsa_key)
# encrypted = rsa_key.encrypt(message)
# return b64encode(encrypted)
#
# encrypted_text = encrypt(public_key, 'привет мир')
# print(encrypted_text)
# decrypted_text = decrypt(private_key, encrypted_text)
# print(decrypted_text)