def __init__(self, wallets):
self.__private_key, self.public_key = generate_keys()
self.blockchain = Blockchain()
self.wallets = wallets
self.transactions_cache = []
self.last_transaction = None
self.genesis()
def get(self):
"""
Return top 100 words
:return:
"""
try:
# Check if public key is generated
publickey_file = open("pub.pem", "rb")
except FileNotFoundError:
# lets generate public and private key files
privatekey, publickey = generate_keys()
export_private_key(privatekey)
export_public_key(publickey)
else:
publickey_file.close()
words = []
try:
words = yield get_top_words(limit=True)
except err.ProgrammingError:
# In case of ProgrammingError we need to create words & urls tables
sql = "CREATE TABLE IF NOT EXISTS words (WordHash VARCHAR(100) NOT NULL ," " \
" "Word VARCHAR(255) NOT NULL," " \
" "TotalFrequency INT NOT NULL," " \
" "PRIMARY KEY (WordHash)" " \
" ");"
yield safe_create_table('words', sql)
sql = "CREATE TABLE IF NOT EXISTS urls (UrlHash VARCHAR(100) NOT NULL ," " \
" "Url VARCHAR(100) NOT NULL," " \
" "Sentiment VARCHAR(10) NOT NULL," " \
" "PRIMARY KEY (UrlHash, Url)" " \
" ");"
yield safe_create_table('urls', sql)
self.render("templates/home.html", words=words)
from node import Node
from node import new_sender
from node import new_listener
from constants import ADDRESS_MC
from constants import ADDRESS_CM
import utils as utils
utils.generate_keys(False)
core = Node()
core.add_listener(new_listener(ADDRESS_CM), ADDRESS_CM)
core.accept_connection(ADDRESS_CM)
encrypted_symmetric_key = core.receive_message(ADDRESS_CM)
ciphertext = core.receive_message(ADDRESS_CM)
core.close_connection(ADDRESS_CM)
symmetric_session_key = utils.decrypt_rsa('keys/merchant_private_key.pem',
encrypted_symmetric_key)
client_public_key = utils.decrypt_aes(symmetric_session_key, ciphertext)
print(client_public_key)
print("-------------")
# print(utils.decrypt_aes(symmetric_session_key, ciphertext))
# core.add_sender(new_sender(ADDRESS_MC), ADDRESS_MC)
# core.send_message_to_address(ADDRESS_MC, "test test")
# core.close_connection(ADDRESS_MC)
def run_protocol(n_processes, regions, restricted, instance_type):
'''Runs the protocol.'''
start = time()
parallel = n_processes > 1
if regions == 'badger_regions':
regions = badger_regions()
if regions == 'all':
regions = available_regions()
# note: there are only 5 t2.micro machines in 'sa-east-1', 'ap-southeast-2' each
color_print('launching machines')
nhpr = n_processes_per_regions(n_processes, regions, restricted)
launch_new_instances(nhpr, instance_type)
color_print('waiting for transition from pending to running')
wait('running', regions)
color_print('generating keys')
# generate signing and keys
generate_keys(n_processes)
color_print('generating addresses file')
# prepare address file
ip_list = instances_ip(regions)
with open('ip_addresses', 'w') as f:
f.writelines([ip + '\n' for ip in ip_list])
color_print('waiting till ports are open on machines')
wait('open 22', regions)
color_print('installing dependencies')
# install dependencies on hosts
run_task('inst-dep', regions, parallel)
color_print('packing local repo')
# pack testing repo
with Connection('localhost') as c:
zip_repo(c)
color_print('wait till installation finishes')
# wait till installing finishes
wait_install(regions)
color_print('sending testing repo')
# send testing repo
run_task('send-testing-repo', regions, parallel)
color_print('syncing files')
# send files: addresses, signing_keys, light_nodes_public_keys
run_task('sync-files', regions, parallel)
color_print('sending parameters')
# send parameters
run_task('send-params', regions, parallel)
color_print(f'establishing the environment took {round(time()-start, 2)}s')
color_print('running the experiment')
# run the experiment
run_task('run-protocol', regions, parallel)
def __init__(self):
self.__private_key, self.public_key = generate_keys()
self.id = self.public_key
from utils import get_safe_prime_and_generator
from utils import generate_keys
from utils import sign
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
port = 11111
# connect to the verifier
s.connect(('127.0.0.1', port))
#no of bits of security
k = 8
#use pre-computed safe prime and generator or generate the pair
#prime, generator = 2337337002729225098572093778426340936344769375016804739, 408301515976774063741225363930200775333880949653971216
prime, generator = get_safe_prime_and_generator(k)
keys = generate_keys(prime, generator)
print('Enter message to apply signature to : ')
message = input()
signature = sign(message, keys['secret_key'], prime, generator)
complete_message = str(prime) + '/' + str(generator) + '/' + str(
keys['public_key']) + '/' + message + '/' + str(signature)
s.send(complete_message.encode('ascii'))
s.close()
import base64
from constants import ADDRESS_CM
from constants import ADDRESS_MC
from node import Node
from node import new_listener
from node import new_sender
from Crypto.Cipher import AES
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from os import path
import os.path
import utils as utils
from Crypto.Random import get_random_bytes
utils.generate_keys(True)
merchant_public_key = utils.load_public_keys(False)
client_public_key = utils.load_public_keys(True)
# Hybrid encryption of a message m with the key k means that the message m is encrypted using a symmetric session key
# s, which is in turn encrypted using an asymmetric key k (the digital envelope).
symmetric_session_key = get_random_bytes(32)
cipher_asymmetric = PKCS1_OAEP.new(RSA.import_key(merchant_public_key))
encrypted_symmetric_key = cipher_asymmetric.encrypt(symmetric_session_key)
ind_1 = client_public_key.find('\n')
ind_2 = client_public_key.rfind('\n')
client_public_key = client_public_key[ind_1 + 1:ind_2]