def __init__(
self,
private_key=None
): #TODO Raise mining request, approved by existing miners then can mine.
if private_key is None:
print("Starting a new chain\n")
print("Generating Genesis User Key Pair")
self.key = Key()
print("Generating Genesis User")
print("Network Key: {}".format(self.key.get_private_key()))
#TODO: store the information in config file
user = User(self.key.get_public_key(), "Network",
"*****@*****.**", '3')
self.peoplechain = Peoplechain()
self.peoplechain.add_user(user)
print("Peoplechain Created.")
print(self.peoplechain.users)
else:
print("Generating key pair from private key")
self.key = Key(private_key)
self.request_nodes_from_all()
if not self.discover_user(self.key.get_public_key()):
raise Exception()
remote_chain = self.download()
self.peoplechain = Peoplechain(remote_chain)
self.node = self.get_my_node()
self.broadcast_node(self.node)
self.full_nodes.union([self.node])
print("\n -------------- Starting Full Node Server -------------- \n")
self.app.run('0.0.0.0', self.FULL_NODE_PORT)
def __init__(self):
self.label: int = 0 # identifier string, eg. a number
self.name = '' # full name of this v
self.sname = '' # short name
self.meter = Meter() # meter
self.meter0 = Meter() # meter
self.meter1 = Meter() # meter
self.key = Key() # keysig
self.key0 = Key() # keysig
self.key1 = Key() # keysig
self.stems = 0 # +1 or -1 to force stem direction
self.staves = 0
self.brace = 0
self.bracket = 0
self.do_gch = 0 # 1 to output gchords for this v
self.sep = 0.0 # for space to next v below
self.syms = list() # number of music
self.nsym = len(self.syms)
self.draw = False # flag if want to draw this v
self.select = True # flag if selected for output
self.insert_btype = B_INVIS
self.insert_num = 0 # to split bars over linebreaks
self.insert_bnum = 0 # same for bar number
self.insert_space = 0.0 # space to insert after init syms
self.end_slur = 0 # for a-b slurs
self.insert_text = '' # string over inserted barline
self.timeinit = 0.0 # carryover time between parts
def get_key(self,
key_name,
headers=None,
version_id=None,
key_type=Key.KEY_REGULAR_FILE):
"""
Check to see if a particular key exists within the bucket.
Returns: An instance of a Key object or None
:type key_name: string
:param key_name: The name of the key to retrieve
:type version_id: string
:param version_id: Unused in this subclass.
:type stream_type: integer
:param stream_type: Type of the Key - Regular File or input/output Stream
:rtype: :class:`boto.file.key.Key`
:returns: A Key object from this bucket.
"""
if key_name == '-':
return Key(self.name, '-', key_type=Key.KEY_STREAM_READABLE)
else:
fp = open(key_name, 'rb')
return Key(self.name, key_name, fp)
def getKeys(length):
n_min = 1 << (length - 1)
n_max = (1 << length) - 1
start = 1 << (length // 2 - 1)
stop = 1 << (length // 2 + 1)
primes = getPrimes(start, stop)
while primes:
p = random.choice(primes)
primes.remove(p)
q_candidates = [q for q in primes if n_min <= p * q <= n_max]
if q_candidates:
q = random.choice(q_candidates)
break
stop = (p - 1) * (q - 1)
for e in range(3, stop, 2):
if areRelativelyPrime(e, stop):
break
for d in range(3, stop, 2):
if d * e % stop == 1:
break
return Key(p * q, e), Key(p * q, d)
def insertKey(end, key):
if end[key%100] is not None:
p = end[key%100]
while(p.getProx()):
p = p.getProx()
p.prox = Key(key)
else:
end[key%100] = Key(key)
def break_the_key(self):
A = bt.phi(self.public_key.get_modulus())
list_of_euclidean = bt.euclidean_algorithm(
self.public_key.get_exponent(), A)
inverse_list = bt.extended_euclidean_algorithm(list_of_euclidean)
if len(inverse_list) % 2 == 1:
self.private_key = Key(self.public_key.get_modulus(),
inverse_list[-1][2] + A)
else:
self.private_key = Key(self.public_key.get_modulus(),
inverse_list[-1][0])
def test_dataset_prefix(self):
key = Key(dataset=Dataset('dset'))
protokey = key.to_protobuf()
self.assertEqual('s~dset', protokey.partition_id.dataset_id)
key = Key(dataset=Dataset('s~dset'))
protokey = key.to_protobuf()
self.assertEqual('s~dset', protokey.partition_id.dataset_id)
key = Key(dataset=Dataset('e~dset'))
protokey = key.to_protobuf()
self.assertEqual('e~dset', protokey.partition_id.dataset_id)
def recursive_crack(self,p):
stime = time()
lolz=[]
parent = ""
champion = ""
candidate = ""
fr_score = 0
for x in range(0,p):
parent = parent + 'a'
for y in range(0,p):
for combo in product(ascii_lowercase, repeat=1):
liste = list(parent)
liste[y] = ''.join(combo)
candidate = ''.join(liste)
temp = Key(candidate)
lolz = decode_it(self.sliced,temp)
stringer = "".join(lolz)
if (letter_score(stringer)>fr_score):
champion = candidate
fr_score = letter_score(stringer)
fr_score = 0
parent = champion
for z in range(0,p):
for combo in product(ascii_lowercase, repeat=1):
liste = list(parent)
liste[p-(1+z)] = ''.join(combo)
candidate = ''.join(liste)
temp = Key(candidate)
lolz = decode_it(self.sliced,temp)
stringer = "".join(lolz)
if (letter_score(stringer)>fr_score):
champion = candidate
fr_score = letter_score(stringer)
fr_score = 0
parent = champion
print "The key found: %s\n" % parent
puk = Key(parent)
lolek = decode_it(self.sliced,puk)
print "Decrypted message: %s\n" % " ".join(lolek)
summ = open('summary.txt','a')
f = open('test_recursive.txt','w')
f.close()
etime = time()
summ.write("\nRecursive Test:\nTime elapsed: %s\nMax_key_lenght: %s\nFile size: %s\n"% (str(etime-stime),p,os.path.getsize("test_recursive.txt")))
summ.close()
return True
def updatefinger(self, newnode, firstnode):
'''
UPdate finger table for all ring in a clockwise around successor fashion
finger is an array of dict {resp, key}
`resp` is the Node responsible for `key`
@param newnode: new node which imply this update
@param firstnode: node which launch the update
'''
for i in range(0, self.uid.idlength):
fingerkey = self.calcfinger(i)
resp = self.lookup(fingerkey, useOnlySucc=True)
self.finger[i] = {"resp": resp, "key": Key(fingerkey)}
#self.finger[i] = self.lookupfinger(i, useOnlySucc=True)
if firstnode is not self.successor:
self.successor.updatefinger(newnode, firstnode)
def decode(file_path, out_path):
if out_path == "":
out_path = file_path.replace('.pi', '')
print("Generating array from encryption key...")
encryption_key = Key('data/pi.dat')
CHUNK_SIZE = 1
print("Reading file to decrypt...")
with open(file_path, 'rb') as infile:
indexes = infile.read().split(',')
print("Decrypting file...")
pointer_array = map(encryption_key.get_data, indexes)
print("Dumping decrypted file...")
with open(out_path, 'a') as outfile:
b64string = ''.join(map(chr, pointer_array))
missing_padding = 4 - len(b64string) % 4
if missing_padding:
b64string += b'=' * missing_padding
outfile.write(base64.decodestring(b64string))
os.remove('cache.db')
def enter():
global map
map = Map()
game_world.add_object(map, 0)
global horn
horn = Horn()
game_world.add_object(horn, 1)
global boss
boss = Boss()
game_world.add_object(boss, 1)
global character
character = Character()
game_world.add_object(character, 1)
global butterflys
butterflys = [Butterfly(character) for i in range(7)]
game_world.add_objects(butterflys, 1)
key = Key()
game_world.add_object(key, 1)
map.set_center_object(character)
character.set_background(map)
horn.set_background(map)
boss.set_background(map)
def setNote(self, noteabout, note=""):
# Format the Key.
key = Key(pub=noteabout)
noteabout = key.pubkey
newnote = {
"user": self.Keys['master'].pubkey,
"noteabout": noteabout,
"note": note
}
# Retrieve any existing note, so that the _id is the same. Then, we'll
# gut it, and put in our own values.
newnote = self.server.db.unsafe.find_one('notes', {
"user": self.Keys['master'].pubkey,
"noteabout": noteabout
})
if newnote is None:
newnote = {
"user": self.Keys['master'].pubkey,
"noteabout": noteabout,
"note": note
}
newnote['note'] = note
self.server.db.unsafe.save('notes', newnote)
self.getNote(noteabout=noteabout, invalidate=True)
def verify_password(self, guessed_password, tryinverted=True):
"""Check a proposed password, to see if it's able to open and load a
user's account."""
# The cleanest way to see if the password is accurate is to see if it successfully decodes the content in the account.
# We can do this by attempting to decode the private key.
# We can then verify it decoded properly, by re-deriving the public key, and seeing if they match.
test_passkey = self.Keys['master'].get_passkey(guessed_password)
byteprivatekey = base64.b64decode(
self.encryptedprivkey.encode('utf-8'))
# We decoded something. Check to see if we can recreate the pubkey using this.
if byteprivatekey is None:
return False
else:
test_key = Key()
test_key.gpg.import_keys(byteprivatekey)
reconstituted_pubkey = test_key.gpg.export_keys(
test_key.gpg.list_keys()[0]['fingerprint'])
test_key.pubkey = reconstituted_pubkey
test_key._format_keys()
if test_key.pubkey == user.pubkey:
return True
# Let's try one other variation before we give up.
# It's possible the user has caps lock on, and so their keys are inverted.
# Testing this doesn't substantially decrease security, but it does help make things easier for users who had a long day.
# Based on the FB-technique, as described at http://blog.agilebits.com/2011/09/13/facebook-and-caps-lock-unintuitive-security/
if tryinverted:
return self.verify_password(
guessed_password=guessed_password.swapcase(),
tryinverted=False)
def __init__(self):
self.rooms = []
self.currentRoom = 0
self.inventory = []
firstRoom = Room(
1,
"Je staat in de keuken. Er staan een aanrecht en een koelkast, en er is 1 deur.",
[Door(123, 1)],
[Key(123, "woonkamersleutel"),
Key(321, "schatkistsleutel")])
secondRoom = Room(2, "Je staat in de woonkamer, er is een deur",
[Door(123, 0)], [])
self.rooms.append(firstRoom)
self.rooms.append(secondRoom)
print(self.rooms[self.currentRoom].description)
def get_key(file_in):
"""
Estimates the key and scale for an audio file.
"""
loader = streaming.MonoLoader(filename=file_in)
framecutter = streaming.FrameCutter()
windowing = streaming.Windowing(type="blackmanharris62")
spectrum = streaming.Spectrum()
spectralpeaks = streaming.SpectralPeaks(orderBy="magnitude",
magnitudeThreshold=1e-05,
minFrequency=40,
maxFrequency=5000,
maxPeaks=10000)
pool = Pool()
hpcp = streaming.HPCP()
key = streaming.Key()
loader.audio >> framecutter.signal
framecutter.frame >> windowing.frame >> spectrum.frame
spectrum.spectrum >> spectralpeaks.spectrum
spectralpeaks.magnitudes >> hpcp.magnitudes
spectralpeaks.frequencies >> hpcp.frequencies
hpcp.hpcp >> key.pcp
key.key >> (pool, 'tonal.key_key')
key.scale >> (pool, 'tonal.key_scale')
key.strength >> (pool, 'tonal.key_strength')
run(loader)
return Key(pool['tonal.key_key'], pool['tonal.key_scale'])
def list(self, prefix=None, delimiter=None, marker=None, limit=None):
""" List objects of the bucket.
Keyword arguments:
prefix - Limits the response to keys that begin with the specified prefix
delimiter - A character you use to group keys
marker - Specifies the key to start with when listing objects
limit - The count of objects that the request returns
"""
params = {}
if prefix:
params["prefix"] = prefix
if delimiter:
params["delimiter"] = delimiter
if marker:
params["marker"] = marker
if limit:
params["limit"] = str(limit)
response = self.connection.make_request("GET",
self.name,
params=params)
if response.status == 200:
resp = json.loads(response.read())
result_set = []
for k in resp["keys"]:
key = Key(self, k["key"])
key.content_type = k["mime_type"]
result_set.append(key)
return result_set
else:
err = get_response_error(response)
raise err
def key_exchange(conn) -> tuple[int, int]:
client_public_key = conn.recv(2048).decode('utf-8')
print("Received client public key: " +
client_public_key.replace('\n', " "))
client_public_key = client_public_key.split('\n')
calc_key_client = Key(create_param(), int(client_public_key[0]),
int(client_public_key[1]))
B_attr_server = str(calc_key_client.AB) + '\n'
conn.send(B_attr_server.encode('utf-8'))
print("Sent server B attribute to the client: " +
B_attr_server.replace('\n', " "))
server_public_key = read_key("public_key_server.pem")
conn.send(server_public_key.encode('utf-8'))
print('Sent server public key to the client: ' +
server_public_key.replace('\n', " "))
B_attr_client = conn.recv(2048).decode('utf-8')
print("Received client B attribute key: " +
B_attr_client.replace('\n', " "))
B_attr_client = B_attr_client.split('\n')
server_private_key = read_key("private_key_server.pem").split('\n')
server_public_key = server_public_key.split('\n')
K_client = create_sym_key(calc_key_client.ab, int(client_public_key[2]),
calc_key_client.p)
print('Calculated common private key for the client: ' + str(K_client))
K_server = create_sym_key(int(server_private_key[0]),
int(B_attr_client[0]), int(server_public_key[1]))
print('Calculated common private key for the server: ' + str(K_server))
return K_client, K_server
def send_create_account_tx(self, new_account_id, base_block_hash=None):
self.prep_tx()
new_key = Key(new_account_id, self.key.pk, self.key.sk)
tx = sign_create_account_with_full_access_key_and_balance_tx(
self.key, new_account_id, new_key, 100 * NEAR_BASE, self.nonce,
base_block_hash or self.base_block_hash)
return self.send_tx(tx)
def parse_header(self, header_lines):
for line in header_lines:
value = line.strip('\n').split(':')
if value[0] == 'K':
# self.sigkey = Key(value[1])
self.sigkey = Key('C')
self.sigkey.calculate_scales()
elif value[0] == 'M':
if 'C' in value[1]:
if '|' in line[1]:
self.meter = [2, 2]
else:
self.meter = [4, 4]
else:
a, b = value[1].split('/')
self.meter = [int(a), int(b)]
elif value[0] == 'V':
voice = value[1].split()[0]
if voice not in self.voices:
self.voices += [voice]
elif value[0] == 'L':
self.length = value[1].split()[0]
if self.voices == []:
self.voices += ['V1']
header_lines.insert(-1, 'V:V1 treble\n')
self.voices += ['V2']
header_lines += ['V:V2 treble\n']
return header_lines
def __init__(self, world):
self.__world = world
self.__platforms = pg.sprite.Group()
self.__items = pg.sprite.Group()
self.__exit = pg.sprite.Group()
self.__bg = (BLUE)
row_count = 0
for row in self.__world:
col_count = 0
for tile in row:
if tile == 1:
wall = Platform(col_count * TILE_SIZE_W,
row_count * TILE_SIZE_H, TILE_SIZE_W,
TILE_SIZE_H, BLUE)
self.__platforms.add(wall)
#tile = (wall.image, wall.rect)
elif tile == 2:
grogu = Key(col_count * TILE_SIZE_W,
row_count * TILE_SIZE_H, 20, 20, GREEN)
self.__items.add(grogu)
elif tile == 3:
ship = Extraction_point(col_count * TILE_SIZE_W,
row_count * TILE_SIZE_H,
TILE_SIZE_W, TILE_SIZE_H, PURPLE)
self.__exit.add(ship)
col_count += 1
row_count += 1
self.__spawn_point = ((WIDTH, HEIGHT))
def test_constructor(self):
k = Key()
self.assertEqual(k.sf, 0)
self.assertEqual(k.key_type, constants.TREBLE)
self.assertEqual(k.add_pitch, 0)
self.assertEqual(k.root, 2)
self.assertEqual(k.root_acc, constants.A_NT)
def trySerialize(obj):
if isinstance(obj, basestring):
return Key(obj).serialize()
if hasattr(obj, 'serialize'):
return obj.serialize()
else:
return obj
def shack(self):
room = Room()
lantern = Item('lantern')
lantern.effects['description'] = 'You would light up the room but the lantern was too sick.'
room.inventory.add(lantern)
kitchenKey = Item("kitchen key")
kitchenKey.shortname = 'key'
kitchenKey.movable = True
kitchenKey.key = Key("kitchen key", "The door is unlocked.")
kitchenKey.effects['description'] = "It's a key to the kitchen."
room.inventory.add(kitchenKey)
room.long_description = """You are in a small shack. It has a creaky floor, leaky roof and you are scared.oh not of the room but the cage with a lion in it."""
room.short_description = """A small wooden shack."""
room.name = "Shack"
#room.exits = {'e': 1, 'w': -3}
room.exits = {
'e': Connection(1),
'w': Connection( 3,
'kitchen door',
'locked',
kitchenKey,
'The kitchen door is firmly locked. There should be a key somewhere around.') }
#room.locked = {'w': }
return room
def kitchen2(self):
room = Room()
moldyCheese = Item('moldy cheese')
moldyCheese.movable = True
moldyCheese.effects['healing'] = 5
room.inventory.add(moldyCheese)
cat = Item('cat')
cat.movable = False
cat.messages['nopickup'] = 'It seems like a cat but its actually an alien.'
room.inventory.add((cat))
wierdThing = Item('???')
wierdThing.movable = False
wierdThing.messages['nopickup'] = "Its seems to be a slimy looking thing that is stuck to the floor and tried to eat your hand when you touched it."
key2 = Item("cake key")
key2.effects["description"] = "A key the looks like a cake but is actually the key for the kings office."
key2.key = Key("cake key", "The king's office unlocks.")
room.inventory.add(key2)
room.inventory.add((wierdThing))
room.long_description = """It's the castle kitchen but its hard to tell because it also could be a pet room, for aliens, which the room is full of."""
room.short_description = """An old kitchen, or pet room, for aliens"""
room.name = "Kitchen"
room.exits = {'n': Connection(7) }
#room.exits = {'e': 0}
room.monster = Monster("Musclar spoon", 6, 3, 10)
return room
def _handle_buffer(self):
buf = self.connections[str(self)]
receive_len = 0
if len(buf) >= 4:
public_key = 'w2vCKeZTQSaUqPsQ2BGL8tCuzfGjtbtkXPKwruwu9L9X'
key = Key(public_key=public_key)
signature_length, = struct.unpack_from('<i',
buf,
offset=receive_len)
receive_len += 4
if len(buf) >= receive_len + signature_length:
receive_len += signature_length
mysignature = buf[4:receive_len]
if len(buf) >= receive_len + 4:
content_length, = struct.unpack_from('<i',
buf,
offset=receive_len)
receive_len += 4
if len(buf) >= receive_len + content_length:
receive_len += content_length
raw_mypost = buf[receive_len -
content_length:receive_len]
if key.verify(b58encode(mysignature), raw_mypost):
print('verification pass!')
else:
print('verification failed...')
print('post received:\n', raw_mypost.decode())
self.connections[str(self)] = \
self.connections[str(self)][receive_len:]
def populate_map(self, map):
# define rooms and items
# furniture
couch = Furniture("couch")
piano = Furniture("piano")
double_bed = Furniture("double bed")
queen_bed = Furniture("queen bed")
dresser = Furniture("dresser")
dining_table = Furniture("dining table")
# doors
door_a = Door("door a")
door_b = Door("door b")
door_c = Door("door c")
door_d = Door("door d")
# keys
key_a = Key("key for door a", door_a)
key_b = Key("key for door b", door_b)
key_c = Key("key for door c", door_c)
key_d = Key("key for door d", door_d)
# rooms
game_room = Room("game room")
bedroom_1 = Room("bedroom 1")
bedroom_2 = Room("bedroom 2")
living_room = Room("living room")
outside = Room("outside")
# setting start and end rooms
map.set_start_room(game_room)
map.set_end_room(outside)
# object relations
map.add_relation("game room", [couch, piano, door_a])
map.add_relation("bedroom 1", [queen_bed, door_a, door_b, door_c])
map.add_relation("bedroom 2", [double_bed, dresser, door_b])
map.add_relation("living room", [dining_table, door_c, door_d])
map.add_relation("outside", [door_d])
map.add_relation("piano", [key_a])
map.add_relation("double bed", [key_c])
map.add_relation("dresser", [key_d])
map.add_relation("queen bed", [key_b])
map.add_relation("door a", [game_room, bedroom_1])
map.add_relation("door b", [bedroom_1, bedroom_2])
map.add_relation("door c", [bedroom_1, living_room])
map.add_relation("door d", [living_room, outside])
def add_key(self, key, qtd=0):
k = Key(key)
if qtd == 0:
self.bag.append(k)
else:
for i in range(0, qtd):
self.bag.append(k)
def __init__(self, name, eth_secret_key, near_sk, near_pk):
self.name = name
self.eth_secret_key = eth_secret_key
self.near_account_name = name + '.test0'
self.tokens_expected = dict()
self.near_signer_key = Key(self.near_account_name, near_pk, near_sk)
# Following fields will be initialized when Bridge starts
self.eth_address = None
def get(self,key):
""" Gets the given key. """
try:
res = self._remoteSend(PAGE_GET, { KEY : key })
return Key(self,key,self._keyToDict(res))
except H2OException:
return None
def Start():
""" Start of game || Sets the room up """
global Plyr, instances
print("Objective: Escape the room")
print("Commands:")
print(" search, take, use, examine, exit")
print(" Try 'examine player'")
Plyr = Player("Player") # Player Obj
Exit = ExitDoor("Door_Exit") # Door_Exit Obj
instances.append(Plyr)
instances.append(Exit)
Bathroom = Room("Bathroom") # Room Obj
Plyr.moveTo(Bathroom)
instances.append(Bathroom)
Cupboard_1 = Storage("Left_Cupboard") # Storage Obj
instances.append(Cupboard_1)
Cupboard_2 = Storage("Right_Cupboard") # Storage Obj
instances.append(Cupboard_2)
Cupboard_1.locked = True # Whether its locked or not
Cupboard_1.lock_id = 61 # The Id to unlock it
Cupboard_2.lock_id = 312 # The Id to unlock it
Cupboard_2.locked = True # Whether its locked or not
Key_1 = Key("Silver_Key", Cupboard_1.lock_id) # Key Obj
instances.append(Key_1)
Plyr.inventory.append(Key_1)
Key_1.parent = Plyr # The Parent Of The Key
Exit.lock_id = 31 # The id to unlock it
Exit.locked = True # Whether its locked or not
Key_2 = Key("Gold_Key", Exit.lock_id) # Key Obj
instances.append(Key_2)
Cupboard_1.AddContent(Key_2)
Bathroom.AddContent(Cupboard_1)
Bathroom.AddContent(Cupboard_2)
Bathroom.AddContent(Exit)
while True:
op = rec() # Output from rec() function
if isinstance(op, list):
if len(op) >= 2:
# String to be executed
strng = ("op[0]" + "." + op[1] + "(Plyr, instances)")
exec(strng)
