def test_encrypted_block(self): from crypt import key from crypt import encrypted from userid import my_id key.InitMyKey() data1 = os.urandom(1024) b1 = encrypted.Block( CreatorID=my_id.getLocalIDURL(), BackupID='BackupABC', BlockNumber=123, SessionKey=key.NewSessionKey(), SessionKeyType=key.SessionKeyType(), LastBlock=True, Data=data1, ) self.assertTrue(b1.Valid()) raw1 = b1.Serialize() b2 = encrypted.Unserialize(raw1) self.assertTrue(b2.Valid()) raw2 = b2.Serialize() data2 = b2.Data() self.assertEqual(data1, data2) self.assertEqual(raw1, raw2)
def _create_new_identity(self): """ Generate new Private key and new identity file. Reads some extra info from config files. """ login = strng.to_bin(bpio.ReadTextFile(settings.UserNameFilename())) externalIP = strng.to_bin(misc.readExternalIP()) or b'127.0.0.1' if self.free_idurls[0].count(b'127.0.0.1'): externalIP = b'127.0.0.1' lg.out( 4, 'id_registrator._create_new_identity %s %s ' % (login, externalIP)) my_id.forgetLocalIdentity() my_id.eraseLocalIdentity(do_backup=True) key.ForgetMyKey(erase_file=True, do_backup=True) key.InitMyKey() if not key.isMyKeyReady(): key.GenerateNewKey() lg.out(4, ' my key is ready') ident = my_id.buildDefaultIdentity(name=login, ip=externalIP, idurls=self.free_idurls) my_identity_xmlsrc = ident.serialize(as_text=True) newfilename = settings.LocalIdentityFilename() + '.new' bpio.WriteTextFile(newfilename, my_identity_xmlsrc) try: id_url.identity_cached(ident) except: lg.exc() self.new_identity = ident lg.out( 4, ' wrote %d bytes to %s' % (len(my_identity_xmlsrc), newfilename))
def _create_new_identity(self): """ Generate new Private key and new identity file. Reads some extra info from config files. """ login = strng.to_bin(bpio.ReadTextFile(settings.UserNameFilename())) externalIP = strng.to_bin(misc.readExternalIP()) or b'127.0.0.1' if self.free_idurls[0].count(b'127.0.0.1'): externalIP = b'127.0.0.1' lg.out( 4, 'id_registrator._create_new_identity %s %s ' % (login, externalIP)) key.InitMyKey() if not key.isMyKeyReady(): key.GenerateNewKey() lg.out(4, ' my key is ready') ident = my_id.buildDefaultIdentity(name=login, ip=externalIP, idurls=self.free_idurls) # my_id.rebuildLocalIdentity( # identity_object=ident, revision_up=True, save_identity=False) # localIP = bpio.ReadTextFile(settings.LocalIPFilename()) my_identity_xmlsrc = ident.serialize(as_text=True) newfilename = settings.LocalIdentityFilename() + '.new' bpio.WriteTextFile(newfilename, my_identity_xmlsrc) self.new_identity = ident lg.out( 4, ' wrote %d bytes to %s' % (len(my_identity_xmlsrc), newfilename))
def main(): """ This should print a current identity or create a new one. """ settings.init(base_dir='/tmp/fake_id') from userid import my_id my_id.loadLocalIdentity() if my_id.isLocalIdentityReady(): my_id.getLocalIdentity().sign() print(my_id.getLocalIdentity().serialize()) print('Valid is: ', my_id.getLocalIdentity().Valid()) else: if not key.InitMyKey(): key.GenerateNewKey() ipaddr = '127.0.0.1' if len(sys.argv) > 2: ipaddr = sys.argv[2] rev = 0 if len(sys.argv) > 3: rev = int(sys.argv[3]) idurls = [] if len(sys.argv) > 4: idurls = sys.argv[4:] my_id.setLocalIdentity( my_id.buildDefaultIdentity(name=sys.argv[1], ip=ipaddr, idurls=idurls, revision=rev)) my_id.saveLocalIdentity() print(my_id.getLocalIdentity().serialize()) print('Valid is: ', my_id.getLocalIdentity().Valid()) my_id._LocalIdentity = None my_id.loadLocalIdentity() settings.shutdown()
def _create_new_identity(self): """ Generate new Private key and new identity file. Reads some extra info from config files. """ login = bpio.ReadTextFile(settings.UserNameFilename()) externalIP = misc.readExternalIP( ) # bpio.ReadTextFile(settings.ExternalIPFilename()) lg.out( 4, 'id_registrator._create_new_identity %s %s ' % (login, externalIP)) key.InitMyKey() lg.out(4, ' my key is ready') ident = my_id.buildDefaultIdentity(name=login, ip=externalIP, idurls=self.free_idurls) # localIP = bpio.ReadTextFile(settings.LocalIPFilename()) my_identity_xmlsrc = ident.serialize() newfilename = settings.LocalIdentityFilename() + '.new' bpio.WriteFile(newfilename, my_identity_xmlsrc) self.new_identity = ident lg.out( 4, ' wrote %d bytes to %s' % (len(my_identity_xmlsrc), newfilename))
def main(): lg.life_begins() bpio.init() settings.init() misc.init() my_id.init() identitycache.init() from crypt import key key.InitMyKey() (options, args) = parseCommandLine() settings.override('transport.transport-tcp.transport-tcp-port', options.tcpport) settings.override('transport.transport-udp.transport-udp-port', options.udpport) settings.override('network.network-dht-port', options.dhtport) lg.set_debug_level(options.debug) tmpfile.init() if True: import lib.udp lib.udp.listen(options.udpport) import dht.dht_service dht.dht_service.init(options.dhtport) reactor.addSystemEventTrigger('before', 'shutdown', shutdown) # @UndefinedVariable init() start() globals()['num_in'] = 0 def _in(a, b, c, d): lg.out(2, 'INBOX %d : %r' % (globals()['num_in'], a)) globals()['num_in'] += 1 return False callback.insert_inbox_callback(0, _in) if len(args) > 0: globals()['num_out'] = 0 def _s(): p = signed.Packet(commands.Data(), my_id.getLocalID(), my_id.getLocalID(), my_id.getLocalID(), bpio.ReadBinaryFile(args[1]), args[0]) outbox(p, wide=True) lg.out(2, 'OUTBOX %d : %r' % (globals()['num_out'], p)) globals()['num_out'] += 1 old_state_changed = transport('udp').state_changed def new_state_changed(oldstate, newstate, event, *args, **kwargs): old_state_changed(oldstate, newstate, event, *args, **kwargs) if newstate == 'LISTENING': reactor.callLater(1, _s) # @UndefinedVariable transport('udp').state_changed = new_state_changed # t = task.LoopingCall(_s) # reactor.callLater(5, t.start, 60, True) # reactor.callLater(2, t.stop) reactor.run() # @UndefinedVariable settings.shutdown()
def _check_install(self): """ Return True if Private Key and local identity files exists and both is valid. """ if _Debug: lg.out(_DebugLevel, 'initializer._check_install') from userid import identity from crypt import key keyfilename = settings.KeyFileName() keyfilenamelocation = settings.KeyFileNameLocation() if os.path.exists(keyfilenamelocation): keyfilename = bpio.ReadTextFile(keyfilenamelocation) if not os.path.exists(keyfilename): keyfilename = settings.KeyFileName() idfilename = settings.LocalIdentityFilename() if not os.path.exists(keyfilename) or not os.path.exists(idfilename): if _Debug: lg.out(_DebugLevel, 'initializer._check_install local key or local id not exists') return False current_key = bpio.ReadTextFile(keyfilename) current_id = bpio.ReadTextFile(idfilename) if not current_id: if _Debug: lg.out(_DebugLevel, 'initializer._check_install local identity is empty ') return False if not current_key: if _Debug: lg.out(_DebugLevel, 'initializer._check_install private key is empty ') return False try: key.InitMyKey() except: if _Debug: lg.out(_DebugLevel, 'initializer._check_install fail loading private key ') return False try: ident = identity.identity(xmlsrc=current_id) except: if _Debug: lg.out(_DebugLevel, 'initializer._check_install fail init local identity ') return False if not ident.isCorrect(): lg.err('local identity is not correct !!!') return False try: res = ident.Valid() except: if _Debug: lg.out(_DebugLevel, 'failed to validate local identity') return False if not res: lg.err('local identity is not valid !!!') return False if _Debug: lg.out(_DebugLevel, 'initializer._check_install SUCCESS!!!') return True
def _check_install(self): """ Return True if Private Key and local identity files exists and both is valid. """ lg.out(2, 'initializer._check_install') from userid import identity from crypt import key keyfilename = settings.KeyFileName() keyfilenamelocation = settings.KeyFileNameLocation() if os.path.exists(keyfilenamelocation): keyfilename = bpio.ReadTextFile(keyfilenamelocation) if not os.path.exists(keyfilename): keyfilename = settings.KeyFileName() idfilename = settings.LocalIdentityFilename() if not os.path.exists(keyfilename) or not os.path.exists(idfilename): lg.out( 2, 'initializer._check_install local key or local id not exists') return False current_key = bpio.ReadBinaryFile(keyfilename) current_id = bpio.ReadBinaryFile(idfilename) if current_id == '': lg.out(2, 'initializer._check_install local identity is empty ') return False if current_key == '': lg.out(2, 'initializer._check_install private key is empty ') return False try: key.InitMyKey() except: lg.out(2, 'initializer._check_install fail loading private key ') return False try: ident = identity.identity(xmlsrc=current_id) except: lg.out(2, 'initializer._check_install fail init local identity ') return False try: res = ident.Valid() and ident.isCorrect() except: lg.out( 2, 'initializer._check_install wrong data in local identity ') return False if not res: lg.out(2, 'initializer._check_install local identity is not valid ') return False lg.out(2, 'initializer._check_install done') return True
def test_signed_packet(self): key.InitMyKey() payload_size = 1024 attempts = 10 for i in range(attempts): data1 = os.urandom(payload_size) p1 = signed.Packet( 'Data', my_id.getIDURL(), my_id.getIDURL(), 'SomeID', data1, self.bob_ident.getIDURL(), ) self.assertTrue(p1.Valid()) raw1 = p1.Serialize() p2 = signed.Unserialize(raw1) self.assertTrue(p2.Valid())
def test_signed_packet(self): key.InitMyKey() data1 = os.urandom(1024) p1 = signed.Packet( 'Data', my_id.getIDURL(), my_id.getIDURL(), 'SomeID', data1, 'RemoteID:abc', ) self.assertTrue(p1.Valid()) raw1 = p1.Serialize() p2 = signed.Unserialize(raw1) self.assertTrue(p2.Valid()) raw2 = p2.Serialize() data2 = p2.Payload self.assertEqual(data1, data2) self.assertEqual(raw1, raw2)
def test_signed_packet(self): from crypt import key from crypt import signed from userid import my_id key.InitMyKey() data1 = os.urandom(1024) p1 = signed.Packet( 'Data', my_id.getLocalID(), my_id.getLocalID(), 'SomeID', data1, 'RemoteID:abc', ) self.assertTrue(p1.Valid()) raw1 = p1.Serialize() p2 = signed.Unserialize(raw1) self.assertTrue(p2.Valid()) raw2 = p2.Serialize() data2 = p2.Payload self.assertEqual(data1, data2) self.assertEqual(raw1, raw2)
result = Packet(Command, OwnerID, CreatorID, PacketID, Payload, RemoteID) return result def MakePacketInThread(CallBackFunc, Command, OwnerID, CreatorID, PacketID, Payload, RemoteID): """ Signing packets is not atomic operation, so can be moved out from the main thread. """ d = threads.deferToThread(MakePacket, Command, OwnerID, CreatorID, PacketID, Payload, RemoteID) d.addCallback(CallBackFunc) def MakePacketDeferred(Command, OwnerID, CreatorID, PacketID, Payload, RemoteID): """ Another nice way to create a signed packet . """ return threads.deferToThread(MakePacket, Command, OwnerID, CreatorID, PacketID, Payload, RemoteID) #------------------------------------------------------------------------------ if __name__ == '__main__': bpio.init() lg.set_debug_level(18) from main import settings settings.init() key.InitMyKey() p = Unserialize(bpio.ReadBinaryFile(sys.argv[1])) print(p)
def main(): lg.set_debug_level(18) lg.life_begins() from crypt import key key.InitMyKey() from contacts import identitycache identitycache.init() from system import tmpfile tmpfile.init() from services import driver required_services = [ 'service_http_connections', 'service_http_transport', 'service_gateway', 'service_network', ] available_services_dir = os.path.join(bpio.getExecutableDir(), 'services') for filename in os.listdir(available_services_dir): if not filename.endswith('.py') and not filename.endswith( '.pyo') and not filename.endswith('.pyc'): continue if not filename.startswith('service_'): continue name = str(filename[:filename.rfind('.')]) if name in required_services: continue driver.disabled_services().add(name) driver.init() driver.enabled_services().clear() driver.enabled_services().add('service_http_transport') driver.enabled_services().add('service_http_connections') driver.enabled_services().add('service_gateway') driver.enabled_services().add('service_network') driver.start() # options = { 'idurl': my_id.getIDURL(),} # options['host'] = nameurl.GetName(my_id.getIDURL())+'@'+'somehost.org' # options['dht_port'] = int(settings.getDHTPort()) # options['udp_port'] = int(settings.getUDPPort()) # udp.listen(int(settings.getUDPPort())) # dht_service.init(settings.getDHTPort()) # dht_service.connect() # udp_node.A('go-online', options) reactor.addSystemEventTrigger('before', 'shutdown', gateway.shutdown) gateway.init() gateway.start() def _ok_to_send(transport, oldstate, newstate): if newstate != 'LISTENING': return # [filename] [peer idurl] if len(sys.argv) >= 3: pass # bpio.WriteFile(sys.argv[1]+'.signed', p.Serialize()) # def _try_reconnect(): # sess = udp_session.get_by_peer_id(sys.argv[2]) # reconnect = False # if not sess: # reconnect = True # print 'sessions', udp_session.sessions_by_peer_id().keys() # print map(lambda s: s.peer_id, udp_session.sessions().values()) # else: # if sess.state != 'CONNECTED': # print 'state: ', sess.state # reconnect = True # if reconnect: # print 'reconnect', sess # udp_session.add_pending_outbox_file( # sys.argv[1] + '.signed', sys.argv[2], 'descr', Deferred(), False) # udp_node.A('connect', sys.argv[2]) # reactor.callLater(0.5, _try_reconnect) # # def _try_connect(): # if udp_node.A().state == 'LISTEN': # print 'connect' # gateway.stop_packets_timeout_loop() # udp_session.add_pending_outbox_file( # sys.argv[1] + '.signed', sys.argv[2], 'descr', Deferred(), False) # udp_node.A('connect', sys.argv[2]) # reactor.callLater(5, _try_reconnect) # else: # reactor.callLater(1, _try_connect) # # _try_connect() # # def _send(c): # from transport.udp import udp_stream # for idurl in sys.argv[2:]: # print '_send', udp_stream.streams().keys() # p = signed.Packet(commands.Data(), # my_id.getIDURL(), # my_id.getIDURL(), # 'packet%d' % c, # bpio.ReadBinaryFile(sys.argv[1]), # idurl) # gateway.outbox(p) # if c > 1: # reactor.callLater(0.01, _send, c - 1) # reactor.callLater(0, _send, 15) gateway.add_transport_state_changed_callback(_ok_to_send) reactor.run()
def main(): lg.set_debug_level(18) lg.life_begins() from crypt import key key.InitMyKey() from contacts import identitycache identitycache.init() from system import tmpfile tmpfile.init() from services import driver driver.disabled_services().add('service_tcp_connections') driver.disabled_services().add('service_p2p_hookups') driver.disabled_services().add('service_nodes_lookup') driver.disabled_services().add('service_identity_propagate') driver.disabled_services().add('service_ip_port_responder') driver.init() driver.enabled_services().clear() driver.enabled_services().add('service_udp_transport') driver.enabled_services().add('service_udp_datagrams') driver.enabled_services().add('service_my_ip_port') driver.enabled_services().add('service_gateway') driver.enabled_services().add('service_entangled_dht') driver.enabled_services().add('service_network') driver.start() # options = { 'idurl': my_id.getLocalID(),} # options['host'] = nameurl.GetName(my_id.getLocalID())+'@'+'somehost.org' # options['dht_port'] = int(settings.getDHTPort()) # options['udp_port'] = int(settings.getUDPPort()) # udp.listen(int(settings.getUDPPort())) # dht_service.init(settings.getDHTPort()) # dht_service.connect() # udp_node.A('go-online', options) reactor.addSystemEventTrigger('before', 'shutdown', gateway.shutdown) gateway.init() gateway.start() def _ok_to_send(transport, oldstate, newstate): if newstate != 'LISTENING': return # [filename] [peer idurl] if len(sys.argv) >= 3: # bpio.WriteFile(sys.argv[1]+'.signed', p.Serialize()) def _try_reconnect(): sess = udp_session.get_by_peer_id(sys.argv[2]) reconnect = False if not sess: reconnect = True print('sessions', list(udp_session.sessions_by_peer_id().keys())) print([ s.peer_id for s in list(udp_session.sessions().values()) ]) else: if sess.state != 'CONNECTED': print('state: ', sess.state) reconnect = True if reconnect: print('reconnect', sess) udp_session.add_pending_outbox_file( sys.argv[1] + '.signed', sys.argv[2], 'descr', Deferred(), False) udp_node.A('connect', sys.argv[2]) reactor.callLater(0.5, _try_reconnect) def _try_connect(): if udp_node.A().state == 'LISTEN': print('connect') gateway.stop_packets_timeout_loop() udp_session.add_pending_outbox_file( sys.argv[1] + '.signed', sys.argv[2], 'descr', Deferred(), False) udp_node.A('connect', sys.argv[2]) reactor.callLater(5, _try_reconnect) else: reactor.callLater(1, _try_connect) # _try_connect() def _send(c): from transport.udp import udp_stream for idurl in sys.argv[2:]: print('_send', list(udp_stream.streams().keys())) p = signed.Packet(commands.Data(), my_id.getLocalID(), my_id.getLocalID(), 'packet%d' % c, bpio.ReadBinaryFile(sys.argv[1]), idurl) gateway.outbox(p) if c > 1: reactor.callLater(0.01, _send, c - 1) reactor.callLater(0, _send, 15) gateway.add_transport_state_changed_callback(_ok_to_send) reactor.run()
def main(): from system import bpio from storage import backup_tar bpio.init() settings.init() lg.set_debug_level(24) lg.life_begins() automat.LifeBegins(lg.when_life_begins()) automat.OpenLogFile(settings.AutomatsLog()) key.InitMyKey() my_id.init() sourcePath = sys.argv[1] compress_mode = 'none' # 'gz' backupID = sys.argv[2] raid_worker.A('init') if bpio.pathIsDir(sourcePath): backupPipe = backup_tar.backuptardir_thread(sourcePath, compress=compress_mode) else: backupPipe = backup_tar.backuptarfile_thread(sourcePath, compress=compress_mode) def _bk_done(bid, result): from crypt import signed customer, remotePath = packetid.SplitPacketID(bid) try: os.mkdir( os.path.join(settings.getLocalBackupsDir(), customer, remotePath + '.out')) except: pass for filename in os.listdir( os.path.join(settings.getLocalBackupsDir(), customer, remotePath)): filepath = os.path.join(settings.getLocalBackupsDir(), customer, remotePath, filename) payld = bpio.ReadBinaryFile(filepath) newpacket = signed.Packet('Data', my_id.getLocalID(), my_id.getLocalID(), filename, payld, 'http://megafaq.ru/cvps1010.xml') newfilepath = os.path.join(settings.getLocalBackupsDir(), customer, remotePath + '.out', filename) bpio.WriteBinaryFile(newfilepath, newpacket.Serialize()) def _bk_closed(*args, **kwargs): # job.automat('fail') # del job reactor.stop() # @UndefinedVariable def _bk_start(): job = backup(backupID, backupPipe, blockSize=16 * 1024 * 1024) job.finishCallback = _bk_done # lambda bid, result: _bk_done(bid, result, job) job.addStateChangedCallback(_bk_closed, oldstate=None, newstate='DONE') reactor.callLater(1, job.automat, 'start') # @UndefinedVariable reactor.callLater(0, _bk_start) # @UndefinedVariable reactor.run() # @UndefinedVariable settings.shutdown()
def doVerifyAndRestore(self, arg): global _WorkingKey lg.out(4, 'identity_restorer.doVerifyAndRestore') remote_identity_src = arg if os.path.isfile(settings.KeyFileName()): lg.out( 4, 'identity_restorer.doVerifyAndRestore will backup and remove ' + settings.KeyFileName()) bpio.backup_and_remove(settings.KeyFileName()) if os.path.isfile(settings.LocalIdentityFilename()): lg.out( 4, 'identity_restorer.doVerifyAndRestore will backup and remove ' + settings.LocalIdentityFilename()) bpio.backup_and_remove(settings.LocalIdentityFilename()) try: remote_ident = identity.identity(xmlsrc=remote_identity_src) local_ident = identity.identity(xmlsrc=remote_identity_src) except: # lg.exc() reactor.callLater(0.1, self.automat, 'restore-failed', ('remote identity have incorrect format', 'red')) return lg.out( 4, 'identity_restorer.doVerifyAndRestore checking remote identity') try: res = remote_ident.isCorrect() except: lg.exc() res = False if not res: lg.out( 4, 'identity_restorer.doVerifyAndRestore remote identity is not correct FAILED!!!!' ) reactor.callLater(0.1, self.automat, 'restore-failed', ('remote identity format is not correct', 'red')) return lg.out( 4, 'identity_restorer.doVerifyAndRestore validate remote identity') try: res = remote_ident.Valid() except: lg.exc() res = False if not res: lg.out( 4, 'identity_restorer.doVerifyAndRestore validate remote identity FAILED!!!!' ) reactor.callLater(0.1, self.automat, 'restore-failed', ('remote identity is not valid', 'red')) return key.ForgetMyKey() bpio.WriteFile(settings.KeyFileName(), _WorkingKey) try: key.InitMyKey() except: key.ForgetMyKey() # lg.exc() try: os.remove(settings.KeyFileName()) except: pass reactor.callLater(0.1, self.automat, 'restore-failed', ('private key is not valid', 'red')) return try: local_ident.sign() except: # lg.exc() reactor.callLater(0.1, self.automat, 'restore-failed', ('error while signing identity', 'red')) return if remote_ident.signature != local_ident.signature: reactor.callLater( 0.1, self.automat, 'restore-failed', ('signature did not match, key verification failed!', 'red')) return my_id.setLocalIdentity(local_ident) my_id.saveLocalIdentity() bpio.WriteFile(settings.UserNameFilename(), my_id.getIDName()) if os.path.isfile(settings.KeyFileName() + '.backup'): lg.out( 4, 'identity_restorer.doVerifyAndRestore will remove backup file for ' + settings.KeyFileName()) bpio.remove_backuped_file(settings.KeyFileName()) if os.path.isfile(settings.LocalIdentityFilename() + '.backup'): lg.out( 4, 'identity_restorer.doVerifyAndRestore will remove backup file for ' + settings.LocalIdentityFilename()) bpio.remove_backuped_file(settings.LocalIdentityFilename()) reactor.callLater(0.1, self.automat, 'restore-success')