def main():
global data, passwords1
udp = False
if '-u' in sys.argv:
sys.argv.remove('-u')
udp = True
#end if
# Deterministic.
if len(sys.argv) > 1:
random.seed(sys.argv[1])
else:
random.seed('0x31337')
#end if
data = get_ton_unic0de()
passwords = 'A a aa aal aalii aam Aani aardvark aardwolf Aaron Aaronic Aaronical Aaronite Aaronitic Aaru Ab aba Ababdeh Ababua abac'.split(
' ')
passwords1 = []
for password in passwords:
# add junk to it
p = data[random.randint(0, len(data) - 1)]
passwords1.append(password + p)
#next password
if udp:
port = 2044
addr = ('0.0.0.0', port)
server = ThreadingUDPServer(addr, Unic0de_Handler)
server.serve_forever()
else:
res = get_unic0de(data)
print(res.encode('utf-7'))
class DNSServer:
def __init__(self,
blacklist=[],
redirect_ip=None,
port=PORT,
addr="",
max_cache_size=2048):
self.blacklist = blacklist
self.redirect_ip = redirect_ip
self.port = port
self.dns_addr = addr
self.max_cache_size = int(max_cache_size)
self.cache = {}
handler = Handler
handler.host = self
self.server = ThreadingUDPServer((HOST_IP, self.port), Handler)
def start(self):
print("dnsruse running on {} port {} ...".format(HOST_IP, self.port))
self.server.serve_forever()
def log(self, info):
print(info)
def add_cache(self, domain, ip):
if sys.getsizeof(self.cache) < self.max_cache_size:
self.cache[domain] = ip
return "cached."
else:
return "unable to cache, full"
def main():
udp = False
if '-u' in sys.argv:
sys.argv.remove('-u')
udp = True
#end if
# Deterministic.
if len(sys.argv) > 1:
random.seed(sys.argv[1])
else:
random.seed('0x31337')
#end if
if udp:
port = 6811
addr = ('0.0.0.0', port)
server = ThreadingUDPServer(addr, M68HC11_Handler)
server.serve_forever()
else:
file_iteration = 3
while os.path.exists('test1e{0}.S'.format(file_iteration)):
file_iteration += 1
#loop
filename = 'test1e{0}.S'.format(file_iteration)
iterations = 200
source = gen_flag(get_flag(), filename, iterations)
open(filename, 'w').write(source)
print(filename)
class service_udpserver(BaseRequestHandler):
recv_queue: msg_queue
port: int
name: str
udpserver: ThreadingUDPServer
def listen(self, recv_queue: msg_queue, port: int, name: str):
self.recv_queue = recv_queue
self.port = port
self.name = name
# Start udp server
self.udpserver = ThreadingUDPServer(('', self.port), self)
logger.info("Start udpserver, [name]: %s, [port]: %s" %
(self.name, self.port))
self.udpserver.serve_forever()
def handle(self):
ip_port = f"{self.client_address[0]}:{self.client_address[1]}"
# logger.info("[%s][%s]device connected."
# % (self.name, ip_port))
# Get message and client socket
udp_msg, sock = self.request
# Replay
sock.sendto(udp_replay_str, self.client_address)
# Packet msg
logger.debug("UDP receive data [%s] from %s" % (udp_msg, ip_port))
recv_pkt = udp_packet_item(server_port=self.port,
recv_time=datetime.now(),
recv_address=ip_port,
recv_msg=udp_msg)
# Add msg to the queue
if self.recv_queue is not None:
self.recv_queue.put(recv_pkt.to_dict())
def main():
host = '127.0.0.1'
port = 6001
try:
server = ThreadingUDPServer((host, port), StatsHandler)
server.serve_forever()
except KeyboardInterrupt:
print('Interrupted...')
#-*- coding:utf-8 -*-
'''
创建UDPServer
'''
from socketserver import BaseRequestHandler,ThreadingUDPServer,UDPServer
import time
class TimeHandler(BaseRequestHandler):
def handle(self):
print('Got connection from ',self.client_address)
msg,sock=self.request
resp=time.ctime()
sock.sendto(resp.encode('ascii'),self.client_address)
if __name__=='__main__':
# #单线程模式（一次只能响应一个连接请求）
# serv=UDPServer(('',20000),TimeHandler)
#多线程模式（响应多个客户端的连接）
serv=ThreadingUDPServer(('',20000),TimeHandler)
serv.serve_forever()
from socketserver import BaseRequestHandler, ThreadingUDPServer
import time
class TimeHandler(BaseRequestHandler):
def handle(self):
print('Got connection from', self.client_address)
msg, sock = self.request
resp = time.ctime()
sock.sendto(resp.encode(), self.client_address)
if __name__ == '__main__':
serv = ThreadingUDPServer(('', 20000), TimeHandler)
serv.serve_forever()
from socketserver import ThreadingUDPServer
from socketserver import BaseRequestHandler, DatagramRequestHandler
import socket
import logging
import time, datetime
class UdpHandle(BaseRequestHandler):
COUNT = 0
def handle(self):
# t = threading.Thread(target=self.dealPacket, args=(self.client_address, self.request[0]))
# t.start()
packet = self.request[0]
# print(datetime.datetime.now().isoformat()+str(UdpHandle.COUNT))
self.server.socket.sendto(packet, self.client_address)
UdpHandle.COUNT += 1
UDPSERVER = ThreadingUDPServer(('0.0.0.0', 50001), UdpHandle)
UDPSERVER.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
UDPSERVER.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 60000)
UDPSERVER.serve_forever()
user.client_address)
except:
pass
db.close_shop(shop.owner_id)
reply += "已关闭此店"
elif header == "/users":
if user is None or user.user_id != 999:
reply += "您没有该权限"
else:
reply += "有以下用户\n"
print(db.users)
for each in db.users:
a = "用户ID: {0} 用户名: {1} \n".format(
each.user_id, each.user_name)
reply += a
print(reply)
except AssertionError:
reply += "指令参数错误！"
ans.reply = reply
self.request[1].sendto(ans.send(), self.client_address)
if __name__ == '__main__':
print("Data Version:", db["version"])
print(db)
server = ThreadingUDPServer(('0.0.0.0', 25365),
Handler) # 参数为监听地址和已建立连接的处理类
print('listening')
server.serve_forever() # 监听，建立好UCP连接后，为该连接创建新的socket和线程，并由处理类中的handle方法处理
print(server)
default="Empty")
parser.add_argument("--port",
help="set listen port",
action="store",
type=int,
default=53)
parser.add_argument("--debug",
help="enable debug logging",
action="store_true")
args = parser.parse_args()
if str(args.ip).upper() == "ENV":
args.ip = environ.get("PUB_IP")
if args.debug:
print('IP: %s Port: %s' % (args.ip, args.port))
if environ.get("DNS_ALLOW_ALL") == "YES" or args.whitelist == "ALL":
allow_all = True
else:
if args.whitelist != "Empty":
with open(args.whitelist) as f:
w_list.extend(f.read().splitlines())
try:
udp_sock = ThreadingUDPServer(("0.0.0.0", args.port), PacketHandler)
udp_sock.serve_forever()
except KeyboardInterrupt:
if args.debug:
print("done.")
from socketserver import BaseRequestHandler, ThreadingUDPServer
from base_datos import clientes
from sys import argv, exit
if len(argv) != 2:
print("you are idiot")
exit(1)
class QueHacerUdp(BaseRequestHandler):
def handle(self):
#print("Conexion de {}".format(self.client_address))
data, conn = self.request
conn.sendto("501\n".encode(), self.client_address)
data = data.decode().split(";")
cuenta = int(data[0]) - 3
cobro = int(data[1]) + 3
user = clientes.obtener_key(cuenta)
if clientes.retire_saldo(user, cobro):
conn.sendto("True\n".encode(), self.client_address)
else:
conn.sendto("False\n".encode(), self.client_address)
#def decodificar(self)
ip = str(argv[1])
udp = ThreadingUDPServer((ip, 6689), QueHacerUdp)
udp.serve_forever()
with sqlite3.connect('botnet.sqlite3') as db:
db.execute("""
CREATE TABLE IF NOT EXISTS ping (
id INTEGER PRIMARY KEY AUTOINCREMENT,
datetime DATETIME,
host TEXT,
port INTEGER)""")
class UDPHandler(BaseRequestHandler):
def handle(self):
host, port = self.client_address
data = json.loads(self.request[0])
log.info(f'Received ping from {host}:{port}/UDP')
with sqlite3.connect('botnet.sqlite3') as db:
db.execute(
'INSERT INTO ping VALUES (NULL, :datetime, :host, :port)', {
'datetime': datetime.now(tz=timezone.utc),
'host': data['host'],
'port': data['port'],
})
if __name__ == '__main__':
log.info(f'Listening for pings on {HOST}:{PORT}/UDP...')
listener = ThreadingUDPServer((HOST, PORT), UDPHandler)
listener.serve_forever()
class Listener:
def __init__(self, ip, port):
self.server = ThreadingUDPServer((ip, port), UdpHandler)
def run(self):
self.server.serve_forever()
def run_server() -> None:
"""
Run a threaded UDP server that logs DNS packets with detail
"""
server = ThreadingUDPServer(HOST_PORT, DNSUDPHandler)
server.serve_forever()
