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)
