def test_accept(self): sock = socket.create_server((support.HOST, 0)) self.addCleanup(sock.close) port = sock.getsockname()[1] code = '\n'.join(( 'import socket, time', '', 'host = %r' % support.HOST, 'port = %s' % port, 'sleep_time = %r' % self.sleep_time, '', '# let parent block on accept()', 'time.sleep(sleep_time)', 'with socket.create_connection((host, port)):', ' time.sleep(sleep_time)', )) proc = self.subprocess(code) with kill_on_error(proc): client_sock, _ = sock.accept() client_sock.close() self.assertEqual(proc.wait(), 0)
def rcon_server(self): print('Opening TLS encrypted channel') # https://docs.python.org/3/library/ssl.html context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) context.verify_mode = ssl.CERT_NONE context.load_cert_chain(certfile='./ssl/serverCert.crt', keyfile='./ssl/serverKey.key') # REPLACE WITH VALID CERT SIGNED BY CA IP = socket.gethostbyname(socket.gethostname()) ssock = context.wrap_socket( socket.create_server((IP, self.RCON_PORT)), server_side=True ) if (ssock): # IP = socket.gethostbyname(socket.gethostname()) # sock.bind((IP, self.RCON_PORT)) print(f'Listening for RCON connections on {IP}:{self.RCON_PORT}') # sock.listen() while True: # with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock: # IP = socket.gethostbyname(socket.gethostname()) # sock.bind((IP, self.RCON_PORT)) # print(f'Listening for RCON connections on {IP}:{self.RCON_PORT}') # sock.listen() # with context.wrap_socket(sock, server_side=True) as ssock: conn, addr = ssock.accept() print (f'TLS connection from {addr}') rcon = McRconTLS(addr[0], addr[1]) self.connections.append((rcon, conn)) # start a thread with a new rcon session. threading.Thread(target=self.rcon_session, args=(rcon, conn), daemon=True).start()
def run_server(): server = socket.create_server(address) server.setblocking(False) rlist = [server] wlist = [] start = None data = {"clients": []} print("listening") while rlist: rready, _, xready = select.select(rlist, [], rlist, 0.5) if xready: print("exception occurred") return for wo in rready: if wo is server: conn, addr = server.accept() conn.setblocking(False) rlist.append(conn) print("client connected") if start is None: start = datetime.now() data["timer_start_date"] = start.isoformat(" ", "seconds") print("timer started") else: client_data = json.loads(wo.recv(1024).decode()) client_data["client_connection_date"] = datetime.now( ).isoformat(" ", "seconds") data["clients"].append(client_data) rlist.remove(wo) wlist.append(wo) if (start is not None) and ( (datetime.now() - start).total_seconds() >= timer): server.close() rlist.remove(server) start = None data = json.dumps(data).encode() print("writing collected data") while wlist: _, wready, xready = select.select([], wlist, wlist) if xready: print("exception occurred") return for wo in wready: wo.sendall(data) wo.close() wlist.remove(wo) print("done")
def test_find_unused_port(self): port = support.find_unused_port() s = socket.create_server((support.HOST, port)) s.close()
def start(self): sock = socket.create_server(('127.0.0.1', 0)) self.server = self.loop.run_until_complete( asyncio.start_server(self.handle_client, sock=sock)) return sock.getsockname()
import os import socket import dotenv dotenv.load_dotenv() # create, bind, and listen on a socket in one go. # in addition, using an empty string is equal to 0.0.0.0 with socket.create_server(("", int(os.getenv("PORT", "")))) as sock: print("server listening!") # everything else is identical while 1: conn, addr = sock.accept() print(f"received connection from {addr}") while 1: data = conn.recv(4096) if data == b"": break print(f"echoing: '{data.decode()}'") conn.send(data) print(f"connection from {addr} ended")
import socket import sys import random TCP_IP = '127.0.0.1' TCP_PORT = 5005 BUFFER_SIZE = 64 addr = (TCP_IP, TCP_PORT) s = socket.create_server(addr) s.listen(1) random.seed() secretNumber = random.randint(1, 100) conn, addr = s.accept() print("Connection address:", addr) while 1: data = conn.recv(BUFFER_SIZE) if not data: break decodedMsg = data.decode() splitMsg = decodedMsg.split(" ") print("data split:", splitMsg) if len(splitMsg) > 2: print("wrong data, recieved more") conn.sendall("wrong data, recieved more".encode()) else: if splitMsg[0] == "guess": if splitMsg[1].isdigit(): if int(splitMsg[1]) < secretNumber: conn.sendall("less".encode()) elif int(splitMsg[1]) == secretNumber: conn.sendall("correct!".encode()) elif int(splitMsg[1]) > secretNumber: conn.sendall("more".encode())
def __init__(self, addr, *args, **kwargs): super().__init__(*args, **kwargs) self.addr = addr self.s = socket.create_server(self.addr, family=socket.AF_INET, backlog=1)
def StartServer(addr): ServerSocket = socket.create_server(addr) return ServerSocket
import socket import threading import sys import pickle HEADERSIZE = 5 addr_port = ('192.168.56.1',8080) socket = socket.create_server(addr_port) socket.listen(1) print("server is ready") def translationMsg(connectionSocket): message_header = b'' message_header = connectionSocket.recv(HEADERSIZE) while(len(message_header)>0): message_payload = b'' message_length = int(message_header) message_payload = connectionSocket.recv(message_length) message = pickle.loads(message_payload) print("La data es:"+message[1]) message_header = b'' message_header = connectionSocket.recv(HEADERSIZE) connectionSocket.close() while 1: connectionSocket, addr = socket.accept()
import socket server = socket.create_server(('127.0.0.1', 8000)) server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server.listen(10) try: while True: client_socket, address = server.accept() recieved_data = client_socket.recv(1024).decode('utf-8') print("Получены данные по сокету", recieved_data) path = recieved_data.split(" ")[1] response = f"HTTP/1.1 200 OK\nContent-Type: text/html; charset=utf-8\n\n" \ f"Привет!<br /> Path: {path}" client_socket.send(response.encode("utf-8")) except KeyboardInterrupt: client_socket.shutdown(socket.SHUT_RDWR) server.close()
from pynput.keyboard import Controller import socket, pickle keyboard = Controller() host = '0.0.0.0' port = 38042 qwertyMessage = 'Enemy Controller Complete!' with socket.create_server((host, port)) as server: print('qwerty is listening at port', port) connect, address = server.accept() print('Standing by', address) with connect: connect.send(qwertyMessage.encode()) while True: qwerty = connect.recv(2048) key = pickle.loads(qwerty) if qwerty[-1] == 80: keyboard.press(key) else: keyboard.release(key)
def __init__(self, port): print(f"Listing on port localhost:{port}") self.server_socket = socket.create_server(('localhost', port))
effects.append(("swap_player_position", None)) effects.append(("floaty_physics", None)) effects.append(("floor_is_lava", None)) effects.append(("give_" + randomAmmo(), [random.randint(1, 2)])) effects.append(("invert_mouse", None)) effects.append(("invert_movement", None)) return random.choice(effects) s = socket.create_server(("localhost", 43384)) while True: print("Connecting...") conn, addr = s.accept() with conn: print("Connected to ", addr) while True: #conn.send(x) effect = pickEffect() if effect != None: msg = genMsg(effect[0], effect[1]) print("Sending " + msg) try: conn.send(msg.encode('utf-8'))
def __init__(self, port: int = 54321): self.address = ('localhost', port) self.socket = socket.create_server(self.address) self.running = False
def setUp(self): self.serverSocket = socket.create_server(('127.0.0.1', 0)) self.connections = [self.serverSocket]
def create_server_connection(ip: str, port: int) -> socket.socket: return socket.create_server((ip, port))
def test_queue_event(self): serverSocket = socket.create_server(('127.0.0.1', 0)) client = socket.socket() client.setblocking(False) try: client.connect(('127.0.0.1', serverSocket.getsockname()[1])) except OSError as e: self.assertEqual(e.args[0], errno.EINPROGRESS) else: #raise AssertionError("Connect should have raised EINPROGRESS") pass # FreeBSD doesn't raise an exception here server, addr = serverSocket.accept() kq = select.kqueue() kq2 = select.kqueue.fromfd(kq.fileno()) ev = select.kevent(server.fileno(), select.KQ_FILTER_WRITE, select.KQ_EV_ADD | select.KQ_EV_ENABLE) kq.control([ev], 0) ev = select.kevent(server.fileno(), select.KQ_FILTER_READ, select.KQ_EV_ADD | select.KQ_EV_ENABLE) kq.control([ev], 0) ev = select.kevent(client.fileno(), select.KQ_FILTER_WRITE, select.KQ_EV_ADD | select.KQ_EV_ENABLE) kq2.control([ev], 0) ev = select.kevent(client.fileno(), select.KQ_FILTER_READ, select.KQ_EV_ADD | select.KQ_EV_ENABLE) kq2.control([ev], 0) events = kq.control(None, 4, 1) events = set((e.ident, e.filter) for e in events) self.assertEqual( events, set([(client.fileno(), select.KQ_FILTER_WRITE), (server.fileno(), select.KQ_FILTER_WRITE)])) client.send(b"Hello!") server.send(b"world!!!") # We may need to call it several times for i in range(10): events = kq.control(None, 4, 1) if len(events) == 4: break time.sleep(1.0) else: self.fail('timeout waiting for event notifications') events = set((e.ident, e.filter) for e in events) self.assertEqual( events, set([(client.fileno(), select.KQ_FILTER_WRITE), (client.fileno(), select.KQ_FILTER_READ), (server.fileno(), select.KQ_FILTER_WRITE), (server.fileno(), select.KQ_FILTER_READ)])) # Remove completely client, and server read part ev = select.kevent(client.fileno(), select.KQ_FILTER_WRITE, select.KQ_EV_DELETE) kq.control([ev], 0) ev = select.kevent(client.fileno(), select.KQ_FILTER_READ, select.KQ_EV_DELETE) kq.control([ev], 0) ev = select.kevent(server.fileno(), select.KQ_FILTER_READ, select.KQ_EV_DELETE) kq.control([ev], 0, 0) events = kq.control([], 4, 0.99) events = set((e.ident, e.filter) for e in events) self.assertEqual(events, set([(server.fileno(), select.KQ_FILTER_WRITE)])) client.close() server.close() serverSocket.close()
def test_HOST(self): s = socket.create_server((socket_helper.HOST, 0)) s.close()
import socket from config import cipher, initialization_vector, CBC, OFB server_socket = socket.create_server(('', 5050)) nodeA, _ = server_socket.accept() operation_block_mode = nodeA.recv(3).decode() K_cipher = nodeA.recv(16) K_plain = cipher.decrypt(K_cipher) BlockMode = None if operation_block_mode == 'CBC': BlockMode = CBC(initialization_vector, K_plain) elif operation_block_mode == 'OFB': BlockMode = OFB(initialization_vector, K_plain) nodeA.send(b'ok') with open('nodeB_output.txt', 'wb') as f: current_block = last_block = b'' while cipher_block := nodeA.recv(16): if last_block != b'': f.write(last_block) last_block = current_block current_block = BlockMode.decrypt_block(cipher_block) f.write(last_block) # remove padding from last block current_block = current_block.rstrip() f.write(current_block) with open('nodeB_output.txt', 'r') as f:
#!/usr/bin/env python3.8 import socket HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65433 # Port to listen on (non-privileged ports are > 1023) with socket.create_server((HOST, PORT)) as s: conn, addr = s.accept() with conn: print('Connected by', (HOST, PORT)) while True: data = conn.recv(1024) print("Yasuko's server got this message: {}".format(data)) if not data: break conn.sendall(data)
def RunServer(port_id: int, connection: list): sock = socket.create_server(('localhost', port_id)) rslt = sock.accept() connection.extend(rslt)
def run(self, args): if pwncat.victim.client is not None: util.error( "connect can only be called prior to an active connection!") return if args.config: try: # Load the configuration with open(args.config, "r") as filp: pwncat.victim.command_parser.eval(filp.read(), args.config) except OSError as exc: self.parser.error(str(exc)) if args.action == "none": # No action was provided, and no connection was made in the config if pwncat.victim.client is None: self.parser.print_help() return if args.action == "listen": if not args.host: args.host = "0.0.0.0" util.progress(f"binding to {args.host}:{args.port}") # Create the socket server server = socket.create_server((args.host, args.port), reuse_port=True) try: # Wait for a connection (client, address) = server.accept() except KeyboardInterrupt: util.warn(f"aborting listener...") return util.success(f"received connection from {address[0]}:{address[1]}") pwncat.victim.connect(client) elif args.action == "connect": if not args.host: self.parser.error( "host address is required for outbound connections") util.progress(f"connecting to {args.host}:{args.port}") # Connect to the remote host client = socket.create_connection((args.host, args.port)) util.success(f"connection to {args.host}:{args.port} established") pwncat.victim.connect(client) elif args.action == "ssh": if not args.port: args.port = 22 if not args.user: self.parser.error("you must specify a user") if not (args.password or args.identity): self.parser.error( "either a password or identity file is required") try: # Connect to the remote host's ssh server sock = socket.create_connection((args.host, args.port)) except Exception as exc: util.error(str(exc)) return # Create a paramiko SSH transport layer around the socket t = paramiko.Transport(sock) try: t.start_client() except paramiko.SSHException: sock.close() util.error("ssh negotiation failed") return if args.identity: try: # Load the private key for the user key = paramiko.RSAKey.from_private_key_file(args.identity) except: password = prompt("RSA Private Key Passphrase: ", is_password=True) key = paramiko.RSAKey.from_private_key_file( args.identity, password) # Attempt authentication try: t.auth_publickey(args.user, key) except paramiko.ssh_exception.AuthenticationException as exc: util.error(f"authentication failed: {exc}") else: try: t.auth_password(args.user, args.password) except paramiko.ssh_exception.AuthenticationException as exc: util.error(f"authentication failed: {exc}") if not t.is_authenticated(): t.close() sock.close() return # Open an interactive session chan = t.open_session() chan.get_pty() chan.invoke_shell() # Initialize the session! pwncat.victim.connect(chan) elif args.action == "reconnect": if not args.host: self.parser.error( "host address or hash is required for reconnection") try: addr = ipaddress.ip_address(args.host) util.progress(f"enumerating persistence methods for {addr}") host = (pwncat.victim.session.query( pwncat.db.Host).filter_by(ip=str(addr)).first()) if host is None: util.error(f"{args.host}: not found in database") return host_hash = host.hash except ValueError: host_hash = args.host # Reconnect to the given host try: pwncat.victim.reconnect(host_hash, args.method, args.user) except PersistenceError as exc: util.error(f"{args.host}: connection failed") return elif args.action == "list": if pwncat.victim.session is not None: for host in pwncat.victim.session.query(pwncat.db.Host): if len(host.persistence) == 0: continue print( f"{Fore.MAGENTA}{host.ip}{Fore.RESET} - {Fore.RED}{host.distro}{Fore.RESET} - {Fore.YELLOW}{host.hash}{Fore.RESET}" ) for p in host.persistence: print( f" - {Fore.BLUE}{p.method}{Fore.RESET} as {Fore.GREEN}{p.user if p.user else 'system'}{Fore.RESET}" ) else: util.error(f"{args.action}: invalid action")
def free_port(self): with socket.create_server(('localhost', 0)) as s: return s.getsockname()[1]
import socket from calculator import process ADDRESS = ('', 8080) with socket.create_server(ADDRESS) as server: server.listen(1) (connection, remote) = server.accept() with connection: connection.send(b'Please input a RPN expression\n> ') while True: data = connection.recv(1024) if not data: break expression = str(data, encoding='UTF-8') if expression == '': break try: result = process(expression) print('Resolved', expression.rstrip(), 'to', result) connection.send( bytes('= ' + str(result) + '\n> ', encoding='UTF-8')) except Exception as error: result = str(error) connection.send( bytes('ERROR: ' + str(error) + '\n> ', encoding='UTF-8')) connection.send(b'See you later alligator\n')
def start_server(self, port): if not self.serverSocket: self.serverSocket = socket.create_server(("",port)) self.socketList.append(self.serverSocket) self.start()
def test_HOST(self): s = socket.create_server((support.HOST, 0)) s.close()
def run(self, args): protocol = None user = None password = None host = None port = None try_reconnect = False if not args.config and os.path.exists("./pwncatrc"): args.config = "./pwncatrc" elif not args.config and os.path.exists("./data/pwncatrc"): args.config = "./data/pwncatrc" if args.config: try: # Load the configuration with open(args.config, "r") as filp: pwncat.victim.command_parser.eval(filp.read(), args.config) except OSError as exc: console.log(f"[red]error[/red]: {exc}") return if args.list: # Grab a list of installed persistence methods for all hosts # persist.gather will retrieve entries for all hosts if no # host is currently connected. modules = list(pwncat.modules.run("persist.gather")) # Create a mapping of host hash to host object and array of # persistence methods hosts = { host.hash: (host, []) for host in pwncat.victim.session.query(pwncat.db.Host).all() } for module in modules: hosts[module.persist.host.hash][1].append(module) for host_hash, (host, modules) in hosts.items(): console.print(f"[magenta]{host.ip}[/magenta] - " f"[red]{host.distro}[/red] - " f"[yellow]{host_hash}[/yellow]") for module in modules: console.print(f" - {str(module)}") return if args.connection_string: m = self.CONNECTION_PATTERN.match(args.connection_string) protocol = m.group("protocol") user = m.group("user") password = m.group("password") host = m.group("host") port = m.group("port") if protocol is not None and args.listen: console.log( f"[red]error[/red]: --listen is not compatible with an explicit connection string" ) return if (sum([ port is not None, args.port is not None, args.pos_port is not None ]) > 1): console.log(f"[red]error[/red]: multiple ports specified") return if args.port is not None: port = args.port if args.pos_port is not None: port = args.pos_port if port is not None: try: port = int(port.lstrip(":")) except: console.log(f"[red]error[/red]: {port}: invalid port number") return # Attempt to assume a protocol based on context if protocol is None: if args.listen: protocol = "bind://" elif args.port is not None: protocol = "connect://" elif user is not None: protocol = "ssh://" try_reconnect = True elif host == "" or host == "0.0.0.0": protocol = "bind://" elif args.connection_string is None: self.parser.print_help() return else: protocol = "connect://" try_reconnect = True if protocol != "ssh://" and args.identity is not None: console.log( f"[red]error[/red]: --identity is only valid for ssh protocols" ) return if pwncat.victim.client is not None: console.log("connection [red]already active[/red]") return if protocol == "reconnect://" or try_reconnect: level = "[yellow]warning[/yellow]" if try_reconnect else "[red]error[/red]" try: addr = ipaddress.ip_address(socket.gethostbyname(host)) row = (pwncat.victim.session.query( pwncat.db.Host).filter_by(ip=str(addr)).first()) if row is None: console.log(f"{level}: {str(addr)}: not found in database") host_hash = None else: host_hash = row.hash except ValueError: host_hash = host # Reconnect to the given host if host_hash is not None: try: pwncat.victim.reconnect(host_hash, password, user) return except Exception as exc: console.log(f"{level}: {host}: {exc}") if protocol == "reconnect://" and not try_reconnect: # This means reconnection failed, and we had an explicit # reconnect protocol return if protocol == "bind://": if not host or host == "": host = "0.0.0.0" if port is None: console.log(f"[red]error[/red]: no port specified") return with Progress( f"bound to [blue]{host}[/blue]:[cyan]{port}[/cyan]", BarColumn(bar_width=None), transient=True, ) as progress: task_id = progress.add_task("listening", total=1, start=False) # Create the socket server server = socket.create_server((host, port), reuse_port=True) try: # Wait for a connection (client, address) = server.accept() except KeyboardInterrupt: progress.update(task_id, visible=False) progress.log("[red]aborting[/red] listener") return progress.update(task_id, visible=False) progress.log( f"[green]received[/green] connection from [blue]{address[0]}[/blue]:[cyan]{address[1]}[/cyan]" ) pwncat.victim.connect(client) elif protocol == "connect://": if not host: console.log("[red]error[/red]: no host address provided") return if port is None: console.log(f"[red]error[/red]: no port specified") return with Progress( f"connecting to [blue]{host}[/blue]:[cyan]{port}[/cyan]", BarColumn(bar_width=None), transient=True, ) as progress: task_id = progress.add_task("connecting", total=1, start=False) # Connect to the remote host client = socket.create_connection((host, port)) progress.update(task_id, visible=False) progress.log( f"connection to " f"[blue]{host}[/blue]:[cyan]{port}[/cyan] [green]established[/green]" ) pwncat.victim.connect(client) elif protocol == "ssh://": if port is None: port = 22 if not user or user is None: self.parser.error("you must specify a user") if not (password or args.identity): password = prompt("Password: "******"[red]error[/red]: {str(exc)}") return # Create a paramiko SSH transport layer around the socket t = paramiko.Transport(sock) try: t.start_client() except paramiko.SSHException: sock.close() console.log("[red]error[/red]: ssh negotiation failed") return if args.identity: try: # Load the private key for the user key = paramiko.RSAKey.from_private_key_file(args.identity) except: password = prompt("RSA Private Key Passphrase: ", is_password=True) key = paramiko.RSAKey.from_private_key_file( args.identity, password) # Attempt authentication try: t.auth_publickey(user, key) except paramiko.ssh_exception.AuthenticationException as exc: console.log( f"[red]error[/red]: authentication failed: {exc}") else: try: t.auth_password(user, password) except paramiko.ssh_exception.AuthenticationException as exc: console.log( f"[red]error[/red]: authentication failed: {exc}") if not t.is_authenticated(): t.close() sock.close() return # Open an interactive session chan = t.open_session() chan.get_pty() chan.invoke_shell() # Initialize the session! pwncat.victim.connect(chan) if user in pwncat.victim.users and password is not None: console.log(f"storing user password") pwncat.victim.users[user].password = password else: console.log("user not found in database; not storing password") else: console.log(f"[red]error[/red]: {args.action}: invalid action")
import socket import select server_ip = '127.0.0.1' server_port = 9997 srv = (server_ip, server_port) server = socket.create_server(srv, family=socket.AF_INET, backlog=10, reuse_port=True) inputs = [server] outputs = [] sockets = [] while True: readable, writable, _ = select.select(inputs, outputs, []) for s in readable: if s is server: conn, addr = server.accept() sockets.append(conn) print("client with address {0} connected".format(addr)) inputs.append(conn) else: data = s.recv(100) if data: for i in sockets: if i is not s: i.send(data) else:
def tcp_server_init(ip_address, port): return socket.create_server((ip_address, port), family=socket.AF_INET, backlog=10, reuse_port=True)