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)
