def rotate_data(self,username,password):
"""
This will clear all existing user and content keys. Will generate new keys and
encrypt data based on new keys.
:param username:
:param password:
:return:
"""
content = self.session.query(Data).first()
user = self.session.query(User).filter(User.username == 'Root', User.password == password).first()
if user:
content_key = Encrypter(user.encrypt_key).decrypt(user.content_key)
decrypted_text = Encrypter(content_key).decrypt(content.data)
new_content_key = generate_key()
content.data = Encrypter(new_content_key).encrypt(decrypted_text)
for user in self.session.query(User).all():
new_key = generate_key()
content_key_enc = Encrypter(new_key).encrypt(new_content_key)
user.content_key = content_key_enc
user.encrypt_key = new_key
self.session.commit()
return 'Success : Keys and data is rotated successfully.'
else:
return 'Error : Root user password not match.'
def load_sample_data():
"""
This will load sample data. The following users are created:
Root / password
Jim / bunny
Bill / gopher
:return:
"""
db = Database()
db.start_engine()
content_key = generate_key()
user1_key = generate_key()
content_key_encrypted = Encrypter(user1_key).encrypt(content_key)
user1 = User(username='******',password='******',content_key=content_key_encrypted,encrypt_key=user1_key)
db.session.add(user1)
user2_key = generate_key()
content_key_encrypted = Encrypter(user2_key).encrypt(content_key)
user2 = User(username='******',password='******',content_key=content_key_encrypted,encrypt_key=user2_key)
db.session.add(user2)
user3_key = generate_key()
content_key_encrypted = Encrypter(user3_key).encrypt(content_key)
user3 = User(username='******',password='******',content_key=content_key_encrypted,encrypt_key=user3_key)
db.session.add(user3)
db.session.commit()
def __init__(self, miner_id, blockchain, manager_qel, seed_node_pool = dict({}), node_type=None):
self.id = miner_id # for logging
self.blockchain = deepcopy(blockchain)
self.key_pair = generate_key()
self.public_key = self.key_pair.publickey()
self.node_pool = dict({}) # Nodes connected with this miner
self.node_pool_address = dict({}) # public keys of neighbours
self.seed_node_pool = seed_node_pool
self.__type = node_type # "SEED" / "NON-SEED"
self.QEL = manager_qel
self.pending_txn_pool = []
self.waiting_for_consensus_reply = (None, None)
self.received_txns = set() # txn_hash
self.received_blocks = set() # block_hash
self.compute_power = randint(3,10) # lower the number higher is the compute power coz faster will be the mining
self.start_mining = False
self.start_creating_txns = False
self.connected_with_neighbours = 1
self.run_mine = 5
self.len_list= 0
self.temp_utxo_list = []
self.first_txn = False
logging.basicConfig(filename=f'LOG-MINER-{self.id}.log', level=logging.DEBUG, format='%(asctime)s : %(levelname)s :Process- %(process)d %(processName)s: Thread- %(thread)d %(threadName)s: %(funcName)s : %(message)s')
logging.info(f'Miner {self.id} object Created')
def __init__(self, controller):
"""
Initialize a user. Generate public/private key.
"""
self.parent = controller
self.encrypt_key = crypto.generate_key()
self.address = crypto.sha256hash(crypto.extract_public_key(self.encrypt_key))
def rotate():
keys = [i for i in data()]
keys.pop()
for i in xrange(KEYRING_SIZE - len(keys)):
keys.insert(0, crypto.generate_key())
delete()
set(keys)
def search(_):
with open('target.art') as f:
target_art = f.read()
import os
_, _, art_files = next(os.walk('./keys'))
approx_file = './keys/' + sorted(art_files)[-2]
with open(approx_file) as f:
approx_art = f.read()
approx_diff = diff(target_art, approx_art)
private_key, public_key = generate_key()
newest_art = get_randomart(public_key)
newest_diff = diff(target_art, newest_art)
if newest_diff < approx_diff:
print("New approximation found! Diff = {}".format(newest_diff))
print(newest_art)
index = int(approx_file[7:-4])
approx_file = "./keys/{}.art".format(index + 1)
with open(approx_file, 'w') as f:
approx_art = f.write(newest_art)
with open(approx_file[:-3] + 'key', 'w') as f:
approx_art = f.write(str(private_key, 'utf-8'))
def login():
form = LoginForm()
if form.validate_on_submit():
user = form.user
user.authenticated = True
db.session.add(user)
db.session.commit()
# Generate and store user's half_key
user_key = generate_key(form.password.data, user.user_key_salt, 32)
half_key = xor_keys(user_key, user.companion_key)
session[generate_hash(user.user_key_salt)] = half_key
login_user(user, remember=False)
return redirect(get_referrer('.u', username=user.username))
return render_template("login.html", title = 'Sign In',form=form)
def register():
form = RegistrationForm()
if form.validate_on_submit():
# Create new user
user = User(
username=form.username.data.lower(),
password=bcrypt.generate_password_hash(form.password.data),
companion_key=generate_salt(32),
user_key_salt=generate_salt(32)
)
user.authenticated = True
db.session.add(user)
db.session.commit()
# Generate and store user's half_key
user_key = generate_key(form.password.data, user.user_key_salt, 32)
half_key = xor_keys(user_key, user.companion_key)
session[generate_hash(user.user_key_salt)] = half_key
login_user(user, remember=False)
return redirect(url_for(".index"))
return render_template("register.html", title = 'Sign In', form=form)
def __init__(self):
self.private_key = generate_key()
self.public_key = get_public_key(self.private_key)
self.public_key_serial = serialize_public_key(self.public_key)
my_print("My pub key (serial): {0}".format(self.public_key_serial))
def refresh():
keys = [crypto.generate_key() for i in xrange(KEYRING_SIZE)]
delete()
set(keys)
return keys
