def decrypt_file(self, file_name):
aes = AESCipher(self.key)
with open(file_name, 'rb') as file:
text = file.read()
dec = aes.decrypt(text)
with open(file_name, 'wb') as file:
file.write(dec)
def process_outgoing_message(self, msg_raw, originates_from_console=False):
'''
Process an outgoing message before Base64 encoding
:param msg_raw: raw message
:return: message to be sent to the server
'''
# if the message has been typed into the console, record it, so it is never printed again during chatting
if originates_from_console == True:
self.update_send_ctr()
# message is already seen on the console
cipher = AESCipher(self.symm_key)
encrypted_msg = cipher.encrypt(msg_raw)
str_to_sign = MESSAGE_CODE + '|' + encrypted_msg + '|' + str(
self.send_counter)
sig = self.sign(str_to_sign)
msg_raw = str_to_sign + '|' + sig
m = Message(owner_name=self.manager.user_name, content=msg_raw)
self.printed_messages.append(m)
# process outgoing message here
# example is base64 encoding, extend this with any crypto processing of your protocol
encoded_msg = base64.encodestring(msg_raw)
# post the message to the conversation
self.manager.post_message_to_conversation(encoded_msg)
def __init__(self):
self.blocks = []
key_for_md5_aes = '#TCC2019-N2N#'
self.aes = AESCipher(key_for_md5_aes)
# Carregando com paramêtros de acesso para desenvolvedor
# Instanciando um gerenciador do banco de dados TCC
self.conexao_bd = conexao_servidor.TCC
cursor_ultimo_bloco = self.conexao_bd.HBase.aggregate([
{
"$sort": {
"timestamp": -1
},
}, {"$limit": 1}
])
last_block_from_collection = list(cursor_ultimo_bloco)
if(len(last_block_from_collection) > 0):
print('Retomando o blockchain a partir de uma hash no banco de dados.')
self.set_genesis_block(True,last_block_from_collection[0])
else:
self.set_genesis_block()
def encrypt_payload(self, decrypted_payload, user_id):
aeskey = self.get_token(user_id)
aesiv = self.get_iv(user_id)
aesc = AESCipher(aeskey)
aesc.set_iv(aesiv)
encrypted_bytes = aesc.encrypt(decrypted_payload)
return encrypted_bytes
def run_client(port):
s = socket(AF_INET, SOCK_STREAM)
s.connect((HOST, port))
cred = s.recv(RECV_SIZE)
while True:
try:
pub, sig = unpack_cred(cred)
break
except:
cred += s.recv(RECV_SIZE)
if not verify_cred(pub, sig):
return
key = RSA.importKey(pub)
rsa = PKCS1_OAEP.new(key)
sess_key = secrets.token_bytes(KEY_SIZE)
enc_sess_key = rsa.encrypt(sess_key)
s.sendall(pickle.dumps(enc_sess_key))
cipher = AESCipher(sess_key)
messages = []
data = recvall(s)
while data:
chunk = pickle.loads(data)
data = data[len(pickle.dumps(chunk)):]
messages.append(cipher.decrypt(chunk))
with open('msgs.txt', 'wb') as f:
f.write(b''.join(messages))
def get_data(image_data, bits_to_rewrite_count, key):
cipher = AESCipher(key)
image_bytes_count = int(math.ceil(64 * 8 / bits_to_rewrite_count))
i_str = StringIO()
for i in range(image_bytes_count):
i_str.write(H.get_bits(image_data[i])[-bits_to_rewrite_count:])
bin_enc_size = i_str.getvalue()[:64 * 8]
i_bytes = BytesIO()
for i in range(64):
i_bytes.write(bytes([int(bin_enc_size[8 * i:8 * i + 8], 2)]))
enc_size = i_bytes.getvalue()
size = int(cipher.decrypt(enc_size))
shift = image_bytes_count
image_bytes_count = int(math.ceil(size * 8 / bits_to_rewrite_count))
for i in range(image_bytes_count):
i_str.write(H.get_bits(image_data[i + shift])[-bits_to_rewrite_count:])
bin_enc_data = i_str.getvalue()[64 * 8:(size + 64) * 8]
i_bytes = BytesIO()
for i in range(size):
i_bytes.write(bytes([int(bin_enc_data[8 * i:8 * i + 8], 2)]))
enc_data = i_bytes.getvalue()
data = cipher.decrypt(enc_data).encode()
return data
def __init__(self, transacoes, bloco_ant, next_block=''):
bloco_anterior_formatado = '{}'.format(bloco_ant)
self._bloco_ant = bloco_ant
self._transacoes = AESCipher(bloco_anterior_formatado).encrypt(
transacoes)
def generate_token(user):
"""
token contains: (generated session key, expiry date) encrypted with system wide shared secret
ticket contains: ((generated session key), (generated session key, expiry date)) encrypted
with clients public key
"""
expiry_date = (datetime.datetime.now() +
datetime.timedelta(minutes=10)).timestamp()
token = {"gen_session_key": " ", "expiry_date": expiry_date}
token_serialised = json.dumps(token, cls=DateTimeEncoder)
cipher = AESCipher(SHARED_SECRET)
encode_hash_session_key = cipher.encrypt(token_serialised)
ticket = json.dumps({
'gen_session_key': user['gen_session_key'],
'token': encode_hash_session_key
})
# encrypting the whole ticket with client's password or public key
cipher = PKCS1_OAEP.new(user['public_key'])
encode_hash_ticket = cipher.encrypt(str.encode(ticket))
return encode_hash_ticket
def decrypt_token(ticket, privatekey):
"""
token contains: (generated session key, expiry date) encrypted with
ticket contains:
"""
privkey_path = "./client.key"
pubkey_path = "./client_pub.key"
# encrypting the whole ticket with client's password or public key
cipher = PKCS1_OAEP.new(privatekey)
ticket = cipher.decrypt(ticket)
ticket = json.loads(ticket)
print(ticket)
from AESCipher import AESCipher
cipher = AESCipher(SHARED_SECRET)
token = cipher.decrypt(ticket['token'])
token = json.loads(token)
print(token, ticket)
return
def generate_splits(self):
aes = AESCipher(self.key)
cipher = aes.encrypt(self.text)
message = aes.decrypt(cipher)
size = 255, len(self.key)
im = Image.new("1", size, "white")
pix = im.load()
for i in range(len(self.key)):
for j in range(ord(self.key[i])):
pix[j, i] = 0
im.save("original.gif")
share1 = Image.new("1", size, "white")
share1pix = share1.load()
for i in range(len(self.key)):
for j in range(255):
x = randint(0,1)
if x == 0:
share1pix[j, i] = 0
share2 = Image.new("1", size)
share2pix = share2.load()
for i in range(len(self.key)):
for j in range(255):
if pix[j, i] == share1pix[j, i]:
share2pix[j, i] = 0
else:
share2pix[j, i] = 255
output = [share1, share2, cipher]
x = Decrypter(cipher, [share1, share2])
x.decrypt_image()
return output
def DH(self, sharedKey):
print '\n############### STARTING D-H ##################'
# Create AES object with shared key
cipher = AESCipher(sharedKey)
#generate key to send to server
myDiffieHellman = DiffieHellman()
print 'g^a mod p value is: ', myDiffieHellman.public_key
print '\n'
#send key to server
sendDH = cipher.encrypt(str(myDiffieHellman.public_key))
print 'Sending encrypted value: ', sendDH.encode('hex')
self.send(str(sendDH))
print '\n'
recvDH = self.waitToRec()
#decrypt received DH value
reply = cipher.decrypt(recvDH)
print 'Received encrypted value: ', recvDH.encode('hex')
print '\n'
print 'g^b mod p value is: ', reply
print '\n'
#calculate session key
myDiffieHellman.calc_shared_key(long(reply))
print "Calculated session key:", myDiffieHellman.key
self.sessionKey = myDiffieHellman.key
print '################## D-H OVER ###################\n'
def encrypt_payload(self, pkt, aes_key, aes_iv):
#aes_key = b'\x9b\xd9\xcd\xf6\xbe+\x9dX\xfb\xd2\xef>\xd87i\xa0\xca\xf5o\xd0\xac\xc3\xe0R\xf0z\xfa\xb8\xdd\x01?E'
#aes_iv = b'\xef\xaa)\x9fHQ\x0f\x04\x18\x1e\xb5;B\xff\x1c\x01'
aesc = AESCipher(aes_key)
aesc.set_iv(aes_iv)
encrypted_bytes = aesc.encrypt(pkt)
return encrypted_bytes
def decrypt_image(self):
key = self.get_key_from_image()
cipher = self.cipher
aes = AESCipher(key)
base64_decoded = aes.decrypt(cipher)
fh = open("decryptedImage.png", "wb")
fh.write(base64_decoded.decode('base64'))
fh.close()
def __init__(self, host, port):
self.session_key = self.generate_random_key()
self.host = host
self.port = port
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.connect((host, port))
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.aes = AESCipher(self.session_key)
def decrypt_payload(self, encrypt_payload, user_id):
aeskey = self.get_token(user_id)
aesiv = self.get_iv(user_id)
aesc = AESCipher(aeskey)
aesc.set_iv(aesiv)
decrypted_bytes = aesc.decrypt(encrypt_payload)
# decrypted_bytes.hex()
return decrypted_bytes
def handleSynReq(self, resp, serverKey):
header = resp.split(';')[0]
if header != 'h':
Exception, 'header not "h" in wait state - ' + header
print 'Got syn Req'
return binascii.unhexlify(
AESCipher(serverKey).decrypt(resp.split(';')[1])).split(
';') #username,sharedKey,nounce
def save_session(self):
data = {
'username': self.username,
'passwd': self.password
}
cipher = AESCipher()
enc = cipher.encrypt(json.dumps(data))
with open('session', 'wb') as f:
f.write(enc)
def save_session(self):
data = {
'access_token': self.access_token,
'refresh_token': self.refresh_token
}
cipher = AESCipher()
enc = cipher.encrypt(json.dumps(data))
with open('session', 'wb') as f:
f.write(enc)
def register(self,username):
if self.state!='start':
raise Exception,'Can\'t register if the state is not \'start\'!'
self.nounce = randint(1, 65536)
self.random_key=binascii.hexlify(os.urandom(32))
self.server.aes=AESCipher(self.random_key)
self.username=username
self.server.send('r;' + self.username + ';' + self.random_key + ';' + str(self.nounce))
self.state='regReq'
def test_encrypt_decrypt(self):
config = utils.get_config_parser()
enc = AESCipher(config.get('AES', 'key'))
f = open("password.txt", "w+")
f.write("Password")
f.close()
enc.encrypt_file("password.txt", out_filename="password.enc")
password = enc.decrypt_file("password.enc")
assert password == "Password", "Failed to decrypt file"
def connect(self,username):
if self.state!='start':
raise Exception,'Can\'t connect if the state is not \'start\'!'
#make it send to the server the username chosen
self.nounce = randint(1, 65536)
key=self.loadKey(username)
self.server.aes = AESCipher(key)
self.username=username
self.server.send('c;' + username + ';' + self.server.aes.encrypt(binascii.hexlify(username+';' + str(int(time())))))
self.state='conReq'
def sendOkMsg(self, peer):
self.peer = peer
dhKey, self.nounce = self.peer.aes.decrypt(self.encData).split(';')
self.peer.send(
'o;' +
self.peer.aes.encrypt(self.nounce + ';' + str(self.dh.publicKey))
) #+';'+str(peer.sport)))
self.dh.genKey(int(dhKey))
self.peer.aes = AESCipher(binascii.hexlify(self.dh.getKey()))
self.state = 'okSent'
def save_record(account):
print(request.content_type)
if not request.json or not 'size' in request.json:
raise InvalidUsage('Invalid usage of this web-service detected',
status_code=400)
size = int(request.json['size'])
decoded_compressed_record = request.json.get('data', "")
symmetricKeyEncrypted = request.json.get('key', "")
compressed_record = base64.b64decode(decoded_compressed_record)
encrypted_json_record_str = zlib.decompress(compressed_record)
pks1OAEPForDecryption = PKS1_OAEPCipher()
pks1OAEPForDecryption.readDecryptionKey('decryption.key')
symmetricKeyDecrypted = pks1OAEPForDecryption.decrypt(
base64.b64decode(symmetricKeyEncrypted))
aesCipherForDecryption = AESCipher()
aesCipherForDecryption.setKey(symmetricKeyDecrypted)
json_record_str = aesCipherForDecryption.decrypt(encrypted_json_record_str)
record_as_dict = json.loads(json_record_str)
# Add the account ID to the reading here
record_as_dict["account"] = account
#print record_as_dict
post_id = mongo_collection.insert_one(record_as_dict).inserted_id
print('Saved as Id: %s' % post_id)
producer = KafkaProducer(
bootstrap_servers=['your.kafka.server.com:9092'],
value_serializer=lambda m: json.dumps(m).encode('ascii'),
retries=5)
# send the individual records to the Kafka queue for stream processing
raw_readings = record_as_dict["data"]
counter = 0
for raw_reading in raw_readings:
raw_reading["id"] = str(post_id) + str(counter)
raw_reading["account"] = account
producer.send("car_readings", raw_reading)
counter += 1
producer.flush()
# send the summary to the Kafka queue in case there is some stream processing required for that as well
raw_summary = record_as_dict["summary"]
raw_summary["id"] = str(post_id)
raw_summary["account"] = account
raw_summary["eventTime"] = record_as_dict["timestamp"]
producer.send("car_summaries", raw_summary)
producer.flush()
return jsonify({'title': str(size) + ' bytes received'}), 201
def save(key, entries):
""" Encrypt the passwords we stored in RAM and write them to the database """
db = Database()
cipher = AESCipher(key)
tmp = []
for entry in entries:
entry_2 = cipher.encrypt(entry[2])
tmp.append([entry[0], entry[1], entry_2.decode()])
# Write the encrypted passwords to the database
if (db.update(tmp)):
print_error("Couldn't save")
def desencriptar(self, mensaje, x_i, y_i):
clave_segura = self.generar_polinomio(x_i, y_i)
# Creamos un objeto de tipo AESCipher para poder utilizar los algoritmos de cifrado
aes = AESCipher()
mensaje = aes.desencriptar(mensaje, str(clave_segura))
return mensaje
def load_session(self):
loaded_session = None
cipher = AESCipher()
with open('session', 'rb') as f:
enc = f.read()
try:
plain = cipher.decrypt(enc)
loaded_session = json.loads(str(plain))
self.username = loaded_session['username']
self.password = loaded_session['passwd']
finally:
return loaded_session
def decrypt_image(self, k):
#key = self.get_key_from_image()
key = k
cipher = self.cipher
aes = AESCipher(key)
base64_decoded = aes.decrypt(cipher)
#print(type(base64_decoded))
fh = open("decryptedImage.png", "wb")
fh.write(base64.b64decode(base64_decoded))
#fh.write(base64_decoded.decode('base64'))
fh.close()
return (base64.b64decode(base64_decoded))
def receive_messages(clientSocket, key) -> None:
# because each line is sent by pickling
# it might be better to read from the socket
# as a stream and let pickle do its job
cipher = AESCipher(key)
fileObj = clientSocket.makefile(mode="b")
with open('msgs.txt', 'wb') as outFile:
for i in range(0, 10):
decryptedMessage = decryptMessage(cipher, fileObj)
outFile.write(decryptedMessage)
def __init__(self):
""" Initialize ui. Connect ui elements to functions. Initialize LoginAgent """
super(RubLogin, self).__init__()
uic.loadUi('design.ui', self)
self.pushButton_login.clicked.connect(self.login)
self.pushButton_logout.clicked.connect(self.logout)
self.checkBox_auto.clicked.connect(self.checkBoxAuto)
self.checkBox_save.clicked.connect(self.checkBoxSave)
self.checkBox_auto_onstartup.clicked.connect(
self.checkBoxAutoOnStartup)
self.loginAgent = LoginAgent(self.textArea_log,
self.checkBox_fileLogging, self.statusBar)
self.guiEnabled = True
aes_key = "Jgj-4f;5$f-d.kg&ghkDe-Fg&kSgZ5pd"
self.aesCipher = AESCipher(aes_key)
if len(sys.argv) > 1:
for x in sys.argv:
if x == "-nogui":
self.guiEnabled = False
# TODO comment
try:
data_file = open("data.bin", "rb")
self.checkBox_fileLogging.setChecked(pickle.load(data_file))
self.checkBox_auto.setChecked(pickle.load(data_file))
self.checkBox_save.setChecked(pickle.load(data_file))
self.checkBox_auto_onstartup.setChecked(pickle.load(data_file))
if self.checkBox_save.isChecked():
self.lineEdit_id.setText(
self.aesCipher.decrypt(pickle.load(data_file),
pickle.load(data_file)))
self.lineEdit_pass.setText(
self.aesCipher.decrypt(pickle.load(data_file),
pickle.load(data_file)))
elif not self.guiEnabled:
data_file.close()
self.cl_exit("No login data saved")
data_file.close()
except (FileNotFoundError, EOFError):
if not self.guiEnabled:
self.cl_exit("No login data saved")
if self.guiEnabled:
# systemtray icon
self.trayIcon = SystemTrayIcon(QtGui.QIcon("logo.png"), self)
self.show()
if self.checkBox_auto_onstartup.isChecked():
self.checkBox_auto.setChecked(True)
self.login()
def __init__(self, file_path, enc_key):
self.Path = os.path.abspath(file_path)
if not os.path.exists(self.Path):
sys.exit('File does not exist!')
if not os.path.isfile(self.Path):
sys.exit(self.Path + ' - is not file!')
try:
file = open(file_path, 'rb')
except Exception:
sys.exit('Can not open file!')
try:
self.File_bytes = file.read()
except Exception:
sys.exit('Can not read file!')
self.File_name = os.path.basename(self.Path)
file_name_bytes = self.File_name.encode()
if len(file_name_bytes) > 255:
sys.exit('File name is too long!')
self.File_name_len = bytes([len(file_name_bytes)])
self.Hash_sum = hashlib.md5(self.File_bytes).hexdigest()
byte_string = self.Hash_sum.encode() \
+ self.File_name_len \
+ file_name_bytes \
+ self.File_bytes
cipher = AESCipher(enc_key)
self.Encrypted_file = cipher.encrypt(byte_string.decode())
# The maximum number that is placed in the block
self._max_enc_file_size = 9999999999999999999999999999999
size_enc_file = len(self.Encrypted_file)
if size_enc_file > self._max_enc_file_size:
sys.exit('File too large!')
self.Encrypted_size = cipher.encrypt(str(size_enc_file))
self.Finally_byte_string = self.Encrypted_size + self.Encrypted_file
self.Finally_size = len(self.Finally_byte_string)
self.Binary_string = self.get_binary_string()
file.close()
