def __init__(self,
ssh_channel,
sock,
sockname,
peername,
target,
info=None):
SocketConnection.__init__(self, ssh_channel, sockname, peername,
target, "ssh", info)
self._raw_socket = sock
def main():
import time
import sys
assert len(sys.argv)==2, "usage: %s :DISPLAY" % sys.argv[0]
display = sys.argv[1]
from xpra.scripts.config import make_defaults_struct
opts = make_defaults_struct()
from xpra.platform.dotxpra import DotXpra
target = DotXpra().socket_path(display)
print("will attempt to connect to socket: %s" % target)
import socket
sock = socket.socket(socket.AF_UNIX)
sock.connect(target)
from xpra.net.bytestreams import SocketConnection
conn = SocketConnection(sock, sock.getsockname(), sock.getpeername(), target, "scroll-test")
print("socket connection=%s" % conn)
app = ServerMessenger(conn, opts)
window = ScrolledWindowExample()
vscroll_events = deque(maxlen=1000)
hscroll_events = deque(maxlen=1000)
def vscroll(scrollbar, scrolltype, value):
#print("vscroll(%s) n=%s" % ((scrollbar, scrolltype, value), len(vscroll_events)))
now = time.time()
needs_reset = False
if len(vscroll_events)>0:
#get the previous event
t, _ = vscroll_events[-1]
#print("last vscroll event was %sms ago" % (now-t))
if now-t<1:
#last event was less than a second ago
print("lowering quality to jpeg @ 1%!")
app.send("command_request", "encoding", "jpeg", "strict")
app.send("command_request", "quality", 1, "*")
app.send("command_request", "speed", 100, "*")
needs_reset = True
vscroll_events.append((now, value))
if needs_reset:
def may_reset_quality(*args):
#if no new events since, reset quality:
t, _ = vscroll_events[-1]
if now==t:
print("resetting quality to h264")
app.send("command_request", "encoding", "h264", "nostrict")
app.send("command_request", "quality", -1, "*") #means auto
app.send("command_request", "speed", -1, "*") #means auto
gobject.timeout_add(1000, may_reset_quality)
def hscroll(scrollbar, scrolltype, value):
print("hscroll(%s)" % (scrollbar, scrolltype, value))
hscroll_events.append((time.time(), value))
window.vscroll.connect("change-value", vscroll)
window.hscroll.connect("change-value", hscroll)
try:
app.run()
finally:
app.cleanup()
def new_control_connection(self, sock, address):
if len(self.potential_protocols) >= self.max_connections:
log.error("too many connections (%s), ignoring new one",
len(self.potential_protocols))
sock.close()
return True
try:
peername = sock.getpeername()
except OSError:
peername = str(address)
sockname = sock.getsockname()
target = peername or sockname
#sock.settimeout(0)
log(
"new_control_connection() sock=%s, sockname=%s, address=%s, peername=%s",
sock, sockname, address, peername)
sc = SocketConnection(sock, sockname, address, target, "unix-domain")
log.info("New proxy instance control connection received:")
log.info(" '%s'", sc)
protocol = Protocol(self, sc, self.process_control_packet)
protocol.large_packets.append(b"info-response")
self.potential_protocols.append(protocol)
protocol.enable_default_encoder()
protocol.start()
self.timeout_add(SOCKET_TIMEOUT * 1000,
self.verify_connection_accepted, protocol)
return True
def test_DoS(client_class_constructor, args):
""" utility method for running DoS tests
See: test_DoS_*_client.py
"""
assert len(args) == 2, "usage: test_DoS_client :DISPLAY"
log.enable_debug()
opts = make_defaults_struct()
opts.password_file = ""
opts.encoding = "rgb24"
opts.jpegquality = 70
opts.quality = 70
opts.compression_level = 1
opts.encryption = ""
display = sys.argv[1]
target = DotXpra().socket_path(display)
print("will attempt to connect to socket: %s" % target)
sock = socket.socket(socket.AF_UNIX)
sock.connect(target)
conn = SocketConnection(sock, sock.getsockname(), sock.getpeername(),
target, "test_DoS")
print("socket connection=%s" % conn)
app = client_class_constructor(conn, opts)
try:
app.run()
finally:
app.cleanup()
print("ended")
print("")
def makeSocketConnection(sock, name):
try:
peername = sock.getpeername()
except:
peername = str(sock)
return SocketConnection(sock, sock.getsockname(), peername,
"test-client-socket")
def _new_connection(self, listener, *args):
socktype = self.socket_types.get(listener, "")
sock, address = listener.accept()
if len(self._potential_protocols) >= self._max_connections:
log.error("too many connections (%s), ignoring new one",
len(self._potential_protocols))
sock.close()
return True
try:
peername = sock.getpeername()
except:
peername = str(address)
sockname = sock.getsockname()
target = peername or sockname
sock.settimeout(self._socket_timeout)
log("new_connection(%s) sock=%s, sockname=%s, address=%s, peername=%s",
args, sock, sockname, address, peername)
sc = SocketConnection(sock, sockname, address, target, socktype)
log.info("New connection received: %s", sc)
protocol = Protocol(self, sc, self.process_packet)
protocol.large_packets.append("info-response")
protocol.authenticator = None
protocol.invalid_header = self.invalid_header
protocol.receive_aliases.update(self._aliases)
self._potential_protocols.append(protocol)
protocol.start()
self.timeout_add(SOCKET_TIMEOUT * 1000,
self.verify_connection_accepted, protocol)
return True
def _new_connection(self, listener, *args):
if self._closing:
netlog.warn("ignoring new connection during shutdown")
return False
socktype = self.socket_types.get(listener)
assert socktype, "cannot find socket type for %s" % listener
try:
sock, address = listener.accept()
except socket.error as e:
netlog.error("Error: cannot accept new connection:")
netlog.error(" %s", e)
return True
if len(self._potential_protocols) >= self._max_connections:
netlog.error("too many connections (%s), ignoring new one",
len(self._potential_protocols))
sock.close()
return True
try:
peername = sock.getpeername()
except:
peername = str(address)
sockname = sock.getsockname()
target = peername or sockname
sock.settimeout(self._socket_timeout)
netlog(
"new_connection(%s) sock=%s, timeout=%s, sockname=%s, address=%s, peername=%s",
args, sock, self._socket_timeout, sockname, address, peername)
conn = SocketConnection(sock, sockname, address, target, socktype)
netlog("socket connection: %s", conn)
frominfo = ""
if peername:
frominfo = " from %s" % pretty_socket(peername)
elif socktype == "unix-domain":
frominfo = " on %s" % sockname
return self.make_protocol(socktype, conn, frominfo)
def __init__(self):
dotxpra = DotXpra()
display = os.environ.get("DISPLAY")
from xpra.scripts.config import make_defaults_struct
opts = make_defaults_struct()
target = dotxpra.socket_path(display)
log.info("attempting to connect to socket: %s", target)
sock = socket.socket(socket.AF_UNIX)
sock.connect(target)
conn = SocketConnection(sock, sock.getsockname(), sock.getpeername(),
target, "scroll-test")
log.info("successfully created our socket connection: %s", conn)
self.server = ServerMessenger(conn, opts)
self.vscroll_events = deque(maxlen=1000)
self.hscroll_events = deque(maxlen=1000)
browser = WebBrowser()
#hook some events:
browser.content_tabs.connect("focus-view-title-changed",
self.title_changed)
vscroll_listeners.append(self.vscroll)
hscroll_listeners.append(self.hscroll)
#the things we tune:
self.quality = -1
self.speed = -1
self.encoding = None
self.strict = False
def wait_for_connection():
conn, addr = sock.accept()
s = SocketConnection(conn, sockpath, addr, sockpath, "unix")
pc = self._init_auth("peercred", options={}, username="******", connection=s)
assert not pc.requires_challenge()
assert pc.get_uid()==os.getuid()
verified.append(True)
to_close.append(s)
def makeSocketConnection(sock, name):
try:
peername = sock.getpeername()
except:
peername = str(sock)
sockname = sock.getsockname()
target = peername or sockname
return SocketConnection(sock, sockname, peername, target, "test-client-socket")
def _new_connection(self, listener, *args):
if self._closing:
netlog.warn("ignoring new connection during shutdown")
return False
socktype = self.socket_types.get(listener)
assert socktype, "cannot find socket type for %s" % listener
sock, address = listener.accept()
if len(self._potential_protocols) >= self._max_connections:
netlog.error("too many connections (%s), ignoring new one",
len(self._potential_protocols))
sock.close()
return True
try:
peername = sock.getpeername()
except:
peername = str(address)
sockname = sock.getsockname()
target = peername or sockname
sock.settimeout(self._socket_timeout)
netlog(
"new_connection(%s) sock=%s, timeout=%s, sockname=%s, address=%s, peername=%s",
args, sock, self._socket_timeout, sockname, address, peername)
sc = SocketConnection(sock, sockname, address, target, socktype)
netlog("socket connection: %s", sc)
frominfo = ""
if peername:
frominfo = " from %s" % pretty_socket(peername)
elif socktype == "unix-domain":
frominfo = " on %s" % sockname
netlog.info("New %s connection received%s", socktype, frominfo)
protocol = Protocol(self, sc, self.process_packet)
self._potential_protocols.append(protocol)
protocol.large_packets.append("info-response")
protocol.challenge_sent = False
protocol.authenticator = None
if socktype == "tcp":
protocol.auth_class = self.tcp_auth_class
protocol.encryption = self.tcp_encryption
protocol.keyfile = self.tcp_encryption_keyfile
else:
protocol.auth_class = self.auth_class
protocol.encryption = self.encryption
protocol.keyfile = self.encryption_keyfile
protocol.socket_type = socktype
protocol.invalid_header = self.invalid_header
protocol.receive_aliases.update(self._aliases)
authlog("socktype=%s, auth class=%s, encryption=%s, keyfile=%s",
socktype, protocol.auth_class, protocol.encryption,
protocol.keyfile)
if protocol.encryption and ENCRYPT_FIRST_PACKET:
password = self.get_encryption_key(None, protocol.keyfile)
protocol.set_cipher_in(protocol.encryption, DEFAULT_IV, password,
DEFAULT_SALT, DEFAULT_ITERATIONS,
INITIAL_PADDING)
protocol.start()
self.timeout_add(SOCKET_TIMEOUT * 1000,
self.verify_connection_accepted, protocol)
return True
def get_info(self) -> dict:
i = SocketConnection.get_info(self)
s = self._socket
if s:
i["ssh-channel"] = {
"id" : s.get_id(),
"name" : s.get_name(),
}
return i
def start_try():
sock = socket.socket(socket.AF_UNIX)
sock.connect(target)
conn = SocketConnection(sock, sock.getsockname(), sock.getpeername(), target, "trylogin")
def stop_cb(client):
try:
clients.remove(client)
except:
pass
if len(clients)<MAX_CLIENTS:
start_try()
def cracked_cb(password):
sys.exit(0)
tl = TryLogin(conn, opts, gen_password(), stop_cb, cracked_cb)
clients.append(tl)
tl.run()
def accept_connection(socktype, listener, timeout=None):
log = get_network_logger()
try:
sock, address = listener.accept()
except socket.error as e:
log("rejecting new connection on %s", listener, exc_info=True)
log.error("Error: cannot accept new connection:")
log.error(" %s", e)
return None
#log("peercred(%s)=%s", sock, get_peercred(sock))
try:
peername = sock.getpeername()
except (OSError, IOError):
peername = address
sock.settimeout(timeout)
sockname = sock.getsockname()
from xpra.net.bytestreams import SocketConnection
conn = SocketConnection(sock, sockname, address, peername, socktype)
log("accept_connection(%s, %s, %s)=%s", listener, socktype, timeout, conn)
return conn
def _new_connection(self, listener, *args):
socktype = self.socket_types.get(listener)
assert socktype, "cannot find socket type for %s" % listener
sock, address = listener.accept()
if len(self._potential_protocols) >= self._max_connections:
netlog.error("too many connections (%s), ignoring new one",
len(self._potential_protocols))
sock.close()
return True
try:
peername = sock.getpeername()
except:
peername = str(address)
sockname = sock.getsockname()
target = peername or sockname
sock.settimeout(self._socket_timeout)
netlog(
"new_connection(%s) sock=%s, timeout=%s, sockname=%s, address=%s, peername=%s",
args, sock, self._socket_timeout, sockname, address, peername)
sc = SocketConnection(sock, sockname, address, target, socktype)
netlog("socket connection: %s", sc)
frominfo = ""
if peername:
frominfo = " from %s" % str(peername)
netlog.info("New %s connection received%s", socktype, frominfo)
protocol = Protocol(self, sc, self.process_packet)
self._potential_protocols.append(protocol)
protocol.large_packets.append("info-response")
protocol.challenge_sent = False
protocol.authenticator = None
if socktype == "tcp":
protocol.auth_class = self.tcp_auth_class
else:
protocol.auth_class = self.auth_class
protocol.socket_type = socktype
protocol.invalid_header = self.invalid_header
protocol.receive_aliases.update(self._aliases)
protocol.start()
self.timeout_add(SOCKET_TIMEOUT * 1000,
self.verify_connection_accepted, protocol)
return True
def _socket_connect(sock, endpoint, description, dtype):
sock.connect(endpoint)
sock.settimeout(None)
return SocketConnection(sock, sock.getsockname(), sock.getpeername(),
description, dtype)
def __init__(self, *args):
SocketConnection.__init__(self, *args)
def __init__(self, socket, local, remote, target, info, ws_handler):
SocketConnection.__init__(self, socket, local, remote, target, info)
self.protocol_type = "websocket"
self.ws_handler = ws_handler
def __init__(self, socket, local, remote, target, socktype, ws_handler):
SocketConnection.__init__(self, socket, local, remote, target,
socktype)
self.protocol_type = "websocket"
self.ws_handler = ws_handler
self.pending_read = Queue()
def close(self):
self.pending_read = Queue()
SocketConnection.close(self)
def __init__(self, ssh_channel, sock, target, info={}):
SocketConnection.__init__(self, ssh_channel, sock.getsockname(), sock.getpeername(), target, "ssh", info)
self._raw_socket = sock
def __init__(self, socket, local, remote, target, info, ws_handler):
SocketConnection.__init__(self, socket, local, remote, target, info)
self.protocol_type = "websocket"
self.ws_handler = ws_handler