def enter_secure_desktop(self): """function ran when entering a secure desktop.""" if self.slave_transport is None: return if not os.path.exists(self.temp_location): os.makedirs(self.temp_location) channel = str(uuid.uuid4()) self.sd_server = server.Server(port=0, password=channel, bind_host='127.0.0.1') port = self.sd_server.server_socket.getsockname()[1] server_thread = threading.Thread(target=self.sd_server.run) server_thread.daemon = True server_thread.start() self.sd_relay = RelayTransport(address=('127.0.0.1', port), serializer=serializer.JSONSerializer(), channel=channel) self.sd_relay.callback_manager.register_callback( 'msg_client_joined', self.on_master_display_change) self.slave_transport.callback_manager.register_callback( 'msg_set_braille_info', self.on_master_display_change) self.sd_bridge = bridge.BridgeTransport(self.slave_transport, self.sd_relay) relay_thread = threading.Thread(target=self.sd_relay.run) relay_thread.daemon = True relay_thread.start() data = [port, channel] with open(self.ipc_file, 'wb') as fp: json.dump(data, fp)
def enter_secure_desktop(self): """function ran when entering a secure desktop.""" if self.control_connector is None: return if not os.path.exists(self.temp_location): os.makedirs(self.temp_location) channel = str(uuid.uuid4()) self.sd_server = server.Server(port=0, password=channel, bind_host='127.0.0.1') port = self.sd_server.server_socket.getsockname()[1] server_thread = threading.Thread(target=self.sd_server.run) server_thread.daemon = True server_thread.start() self.sd_relay = RelayTransport(address=('127.0.0.1', port), serializer=serializer.JSONSerializer(), channel=channel) self.sd_bridge = bridge.BridgeTransport(self.control_connector, self.sd_relay) relay_thread = threading.Thread(target=self.sd_relay.run) relay_thread.daemon = True relay_thread.start() data = [port, channel] with open(self.ipc_file, 'wb') as fp: json.dump(data, fp)
def export(self): index = self._ui.toolBox.currentIndex() fields = [o.data() for o in self._ui.lvFields.selectedIndexes()] if index == 0: writer = serializer.CSVSerializer(self._db, self._table) options = { 'delimiter': self._ui.eDelimeter.text(), 'lineterminator': self._ui.eLineTerminator.text(), 'escapechar': self._ui.eEscapeChar.text(), 'quotechar': self._ui.eQuoteChar.text(), 'columns': self._ui.ckAddColumns.isChecked(), } elif index == 1: writer = serializer.JSONSerializer(self._db, self._table) options = { 'indent': self._ui.sIndent.value(), 'columns': self._ui.ckColumnTypes.isChecked() } else: writer = serializer.SQLSerializer(self._db, self._table) options = { 'columns': self._ui.rbStructure.isChecked() or self._ui.rbStructureData.isChecked(), 'data': self._ui.rbData.isChecked() or self._ui.rbStructureData.isChecked(), } if self._file: text = writer.dumps(fields, options) fh = open(self._file, 'wb+') fh.write(text) fh.close()
def enter_secure_desktop(self): """function ran when entering a secure desktop. So far as I can tell, this function does a few things: * checks if any connections are active. If not, returns * If a temp directory doesn't exist, makes one, starts a local relay with a random (4 character?) id and writes that info to a file. I assume that this is somehow connecting back to the client running in a non-secure environment """ if self.control_connector is None: # No connections are open return if not os.path.exists(self.temp_location): os.makedirs(self.temp_location) channel = str(uuid.uuid4()) self.sd_server = server.Server(port=0, password=channel, bind_host='127.0.0.1') port = self.sd_server.server_socket.getsockname()[1] server_thread = threading.Thread(target=self.sd_server.run) server_thread.daemon = True server_thread.start() self.sd_relay = RelayTransport(address=('127.0.0.1', port), serializer=serializer.JSONSerializer(), channel=channel) self.sd_bridge = bridge.BridgeTransport(self.control_connector, self.sd_relay) relay_thread = threading.Thread(target=self.sd_relay.run) relay_thread.daemon = True relay_thread.start() data = [port, channel] with open(self.ipc_file, 'wb') as fp: json.dump(data, fp)
def on_generate_key(self, evt): evt.Skip() address = socket_utils.address_to_hostport(self.host.GetValue()) self.key_connector = transport.RelayTransport( address=address, serializer=serializer.JSONSerializer()) self.key_connector.callback_manager.register_callback( 'msg_generate_key', self.handle_key_generated) t = threading.Thread(target=self.key_connector.run) t.start()
def connect_as_slave(self, address, key): transport = RelayTransport(serializer=serializer.JSONSerializer(), address=address, channel=key, connection_type='slave') self.slave_session = SlaveSession(transport=transport, local_machine=self.local_machine) self.slave_transport = transport self.slave_transport.callback_manager.register_callback( 'transport_connected', self.on_connected_as_slave) self.slave_transport.reconnector_thread.start() self.disconnect_item.Enable(True) self.connect_item.Enable(False)
def connect_slave(self, address, channel): transport = RelayTransport(address=address, serializer=serializer.JSONSerializer(), channel=channel) self.master_session = MasterSession(transport=transport, local_machine=self.local_machine) transport.callback_manager.register_callback( 'transport_connected', self.on_connected_to_slave) transport.callback_manager.register_callback( 'transport_connection_failed', self.on_slave_connection_failed) transport.callback_manager.register_callback( 'transport_disconnected', self.on_disconnected_from_slave) self.connector = transport self.connector_thread = ConnectorThread(connector=transport) self.connector_thread.start()
def connect_as_master(self, address, key): transport = RelayTransport(address=address, serializer=serializer.JSONSerializer(), channel=key, connection_type='master') self.master_session = MasterSession(transport=transport, local_machine=self.local_machine) transport.callback_manager.register_callback( 'transport_connected', self.on_connected_as_master) transport.callback_manager.register_callback( 'transport_connection_failed', self.on_connected_as_master_failed) transport.callback_manager.register_callback( 'transport_closing', self.disconnecting_as_master) transport.callback_manager.register_callback( 'transport_disconnected', self.on_disconnected_as_master) self.master_transport = transport self.master_transport.reconnector_thread.start()
def connect_control(self, address=SERVER_ADDR, key=None): if self.control_connector_thread is not None: self.control_connector_thread.running = False if self.control_connector is not None: self.control_connector.close() self.control_connector_thread = None transport = RelayTransport(serializer=serializer.JSONSerializer(), address=address, channel=key) self.slave_session = SlaveSession(transport=transport, local_machine=self.local_machine) self.control_connector = transport self.control_connector.callback_manager.register_callback( 'transport_connected', self.connected_to_relay) self.control_connector_thread = ConnectorThread( connector=self.control_connector) self.control_connector_thread.start() self.disconnect_item.Enable(True) self.connect_item.Enable(False)