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 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 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)
YOUR_NVDAREMOTE_KEY = "key"
# Make the NVDA Remote modules importable
sys.path.insert(0, YOUR_ORCA_SCRIPTS_FOLDER)
from orca.speechdispatcherfactory import SpeechServer
from serializer import JSONSerializer
from transport import RelayTransport
import traceback
import threading
mySerializer = JSONSerializer()
transport = RelayTransport(
mySerializer,
(YOUR_NVDAREMOTE_SERVER_ADDRESS, YOUR_NVDAREMOTE_SERVER_PORT),
channel=YOUR_NVDAREMOTE_KEY,
connection_type="slave")
def try_run_thread():
try:
transport.run()
except Exception:
print("Error in thread")
traceback.print_exc()
# Starts the thread that connects to the NVDA Remote server
t = threading.Thread(target=try_run_thread)
t.daemon = True
