Exemple #1
0
 def connect(self, addr):
     if self._sslobj:
         raise ValueError('attempt to connect already-connected SSLSocket!')
     socket.connect(self, addr)
     self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile, self.certfile, self.cert_reqs, self.ssl_version, self.ca_certs, self.ciphers)
     if self.do_handshake_on_connect:
         self.do_handshake()
Exemple #2
0
 def __init__(self,db):
   self._ipcPath=db.getSettingPath()
   SocketlikeIPC.__init__(self, self._ipcPath)
   # super(type(self),self).__init__(self._ipcPath)
   # if super(type(self),self)._connect():
   if SocketlikeIPC._connect(self):
     print('IPC connect succeed. Welcome back, administrator.')
     return
   print('IPC failed. proceeding with TCP.')
   super(type(self)) #unbound
   socket.__init__(self)
   try:
     socket.connect(self,('racu.idea.sh', PortEnum.MAIN_SERVER.value))
     lastPin = db.getConfig()
     print('lastPin =', lastPin, len(lastPin))
     pinmsg = int.to_bytes(SocketEnum.PIN.value, 1, 'big') + int.to_bytes(lastPin[0]) if 10**3<=lastPin['lastPIN']<10**4 else b''
     msg = ''
     # while not msg:
     socket.sendall(self,pinmsg)
     msg = socket.recv(self)
     if not msg:
       print('main server connect error')
       return
   except:
     print('main server connect error')
Exemple #3
0
 def listen(self):
     socket.connect(self.socket, ("tec.skotos.net", 6730))
     self.login_user()
     if self.connect:
         self.send("SKOTOS Zealous 0.7.12.2\n")
     while self.connect:
         buffer = ""
         sleep(0)
         try:
             buffer = str(self.socket.recv(4096), encoding='utf8')
         except Exception as exc:
             pass
         buffer = buffer.splitlines()
         if not buffer.__len__() == 0:
             for number, line in enumerate(buffer):
                 if line.find('SECRET') == -1:
                     self.ui.parse_output(line)
                 else:
                     if line.find('SECRET') == 0:
                         secret = line[7:].strip()
                         hash_string = self.uname + self.pwd + secret
                         zealous_hash = hashlib.md5(hash_string.encode('utf-8')).hexdigest()
                         self.send("USER " + self.uname)
                         self.send("SECRET " + secret)
                         self.send("HASH " + zealous_hash)
                         self.send("CHAR ")
                         # After a Zealotry login the server still sends a password prompt. This just responds to
                         # that with a dummy entry.
                         self.send("Nope")
         else:
             break
     if self.connect:
         self.shutdown()
Exemple #4
0
 def _real_connect(self, addr, return_errno):
     # Here we assume that the socket is client-side, and not
     # connected at the time of the call.  We connect it, then wrap it.
     if self._connected:
         raise ValueError("attempt to connect already-connected SSLSocket!")
     self._sslobj = _ssl.sslwrap(
         self._sock,
         False,
         self.keyfile,
         self.certfile,
         self.cert_reqs,
         self.ssl_version,
         self.ca_certs,
         self.ciphers,
     )
     try:
         socket.connect(self, addr)
         if self.do_handshake_on_connect:
             self.do_handshake()
     except socket_error as e:
         if return_errno:
             return e.errno
         else:
             self._sslobj = None
             raise e
     self._connected = True
     return 0
Exemple #5
0
 def listen(self):
     pprint("Starting connection!")
     socket.connect(self.socket, ("tec.skotos.net", 6730))
     self.login_user()
     self.send("SKOTOS Zealous 0.7.12.2\n")
     while self.connect:
         buffer = ""
         sleep(0)
         try:
             buffer = str(self.socket.recv(4096), encoding='utf8')
         except Exception as exc:
             pprint(exc.args)
             pprint("SOMETHING BAD HAPPENED")
         buffer = buffer.splitlines()
         if not buffer.__len__() == 0:
             for number, line in enumerate(buffer):
                 if line.find('SECRET') == -1:
                     self.ui.parse_output(line)
                 else:
                     if line.find('SECRET') == 0:
                         secret = line[7:].strip()
                         pprint(self.uname + self.pwd + secret)
                         hash_string = self.uname + self.pwd + secret
                         zealous_hash = hashlib.md5(hash_string.encode('utf-8')).hexdigest()
                         pprint(zealous_hash)
                         self.send("USER " + self.uname)
                         self.send("SECRET " + secret)
                         self.send("HASH " + zealous_hash)
                         self.send("CHAR ")
         else:
             pprint(buffer)
             break
     if self.connect:
         self.shutdown()
Exemple #6
0
    def send(self, topic, msg):
        if type(topic) != bytes:
            topic = bytes(str(topic), 'utf-8')
        messagedata = bytes(json.dumps(msg), 'utf-8')

        context = zmq.Context()
        socket = context.socket(zmq.REQ)
        socket.connect(self._relay_in)
        socket.send(topic + b' ' + messagedata)
        reply = socket.recv()
        assert reply
Exemple #7
0
    def connect(self, addr):

        """Connects to remote ADDR, and then wraps the connection in
        an SSL channel."""

        # Here we assume that the socket is client-side, and not
        # connected at the time of the call.  We connect it, then wrap it.
        if self._sslobj:
            raise ValueError("attempt to connect already-connected SSLSocket!")
        socket.connect(self, addr)
        self._sslobj = _ssl.ssl(self._sock, self.keyfile, self.certfile)
        self.do_handshake()
Exemple #8
0
    def _real_connect(self, addr, return_errno):
        if self._connected:
            raise ValueError('attempt to connect already-connected SSLSocket!')
        self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile, self.certfile, self.cert_reqs, self.ssl_version, self.ca_certs, self.ciphers, self.ca_certs_string)
        try:
            socket.connect(self, addr)
            if self.do_handshake_on_connect:
                self.do_handshake()
        except socket_error as e:
            if return_errno:
                return e.errno
            self._sslobj = None
            raise e

        self._connected = True
        return 0
Exemple #9
0
 def connect(self, addr):
     """Connects to remote ADDR, and then wraps the connection in
     an SSL channel."""
     if self.server_side:
         raise ValueError("can't connect in server-side mode")
     # Here we assume that the socket is client-side, and not
     # connected at the time of the call.  We connect it, then wrap it.
     if self._sslobj:
         raise ValueError("attempt to connect already-connected SSLSocket!")
     socket.connect(self, addr)
     self._sslobj = self.context._wrap_socket(self, False, self.server_hostname)
     try:
         if self.do_handshake_on_connect:
             self.do_handshake()
     except:
         self._sslobj = None
         raise
Exemple #10
0
    def connect(self, addr):
        """Connects to remote ADDR, and then wraps the connection in
        an SSL channel."""

        # Here we assume that the socket is client-side, and not
        # connected at the time of the call.  We connect it, then wrap it.
        if self._sslobj:
            raise ValueError("attempt to connect already-connected SSLSocket!")
        socket.connect(self, addr)
        self._sslobj = _ssl.sslwrap(self, False, self.keyfile, self.certfile,
                                    self.cert_reqs, self.ssl_version,
                                    self.ca_certs)
        try:
            if self.do_handshake_on_connect:
                self.do_handshake()
        except:
            self._sslobj = None
            raise
Exemple #11
0
    def _real_connect(self, addr, return_errno):
        if self._connected:
            raise ValueError('attempt to connect already-connected SSLSocket!')
        self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile, self.certfile, self.cert_reqs, self.ssl_version, self.ca_certs, self.ciphers)
        try:
            if return_errno:
                rc = socket.connect_ex(self, addr)
            else:
                rc = None
                socket.connect(self, addr)
            if not rc:
                if self.do_handshake_on_connect:
                    self.do_handshake()
                self._connected = True
            return rc
        except socket_error:
            self._sslobj = None
            raise

        return
Exemple #12
0
 def _real_connect(self, addr, connect_ex):
     if self.server_side:
         raise ValueError("can't connect in server-side mode")
     if self._connected:
         raise ValueError('attempt to connect already-connected SSLSocket!')
     self._sslobj = self.context._wrap_socket(self, False, self.server_hostname)
     try:
         if connect_ex:
             rc = socket.connect_ex(self, addr)
         else:
             rc = None
             socket.connect(self, addr)
         if not rc:
             if self.do_handshake_on_connect:
                 self.do_handshake()
             self._connected = True
         return rc
     except socket_error:
         self._sslobj = None
         raise
Exemple #13
0
 def _real_connect(self, addr, return_errno):
     if self.server_side:
         raise ValueError("can't connect in server-side mode")
     # Here we assume that the socket is client-side, and not
     # connected at the time of the call.  We connect it, then wrap it.
     if self._connected:
         raise ValueError("attempt to connect already-connected SSLSocket!")
     self._sslobj = self.context._wrap_socket(self, False, self.server_hostname)
     try:
         socket.connect(self, addr)
         if self.do_handshake_on_connect:
             self.do_handshake()
     except socket_error as e:
         if return_errno:
             return e.errno
         else:
             self._sslobj = None
             raise e
     self._connected = True
     return 0
Exemple #14
0
    def _real_connect(self, addr, connect_ex):
        if self.server_side:
            raise ValueError("can't connect in server-side mode")

        # Here we assume that the socket is client-side, and not
        # connected at the time of the call.  We connect it, then wrap it.
        if self._connected:
            raise ValueError("attempt to connect already-connected SSLSocket!")

        if connect_ex:
            err = socket.connect_ex(self, addr)
        else:
            err = 0
            socket.connect(self, addr)

        if err == 0:
            self._connected = True
            if self.do_handshake_on_connect:
                self.do_handshake()

        return err
Exemple #15
0
 def _real_connect(self, addr, connect_ex):
     if self.server_side:
         raise ValueError("can't connect in server-side mode")
     # Here we assume that the socket is client-side, and not
     # connected at the time of the call.  We connect it, then wrap it.
     if self._connected:
         raise ValueError("attempt to connect already-connected SSLSocket!")
     self._sslobj = self.context._wrap_socket(self, False, self.server_hostname)
     try:
         if connect_ex:
             rc = socket.connect_ex(self, addr)
         else:
             rc = None
             socket.connect(self, addr)
         if not rc:
             if self.do_handshake_on_connect:
                 self.do_handshake()
             self._connected = True
         return rc
     except OSError:
         self._sslobj = None
         raise
Exemple #16
0
    def connect(self, address, timeout=0.0):
        self.__create_socket_if_necessary()

        if timeout > 0:
            self.setblocking(False)
            fd_set = [self.fileno()]

            try:
                SOCKET.connect(self, address)
                return
            except BlockingIOError as ex:
                print('BlockingIOError:', ex.errno)
                readable, writable, exceptional = select.select([], fd_set, [], timeout)
                if self.fileno() != writable:
                    raise TimeoutError('connect() failure')
            except TimeoutError as ex:
                print('TimeoutError:', ex.errno)
                raise ex
            except Exception as ex:
                raise ex
        else:
            SOCKET.connect(self, address)
        pass
Exemple #17
0
 def _real_connect(self, addr, return_errno):
     # Here we assume that the socket is client-side, and not
     # connected at the time of the call.  We connect it, then wrap it.
     if self._connected:
         raise ValueError("attempt to connect already-connected SSLSocket!")
     self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile,
                                 self.certfile, self.cert_reqs,
                                 self.ssl_version, self.ca_certs,
                                 self.ciphers)
     try:
         if return_errno:
             rc = socket.connect_ex(self, addr)
         else:
             rc = None
             socket.connect(self, addr)
         if not rc:
             if self.do_handshake_on_connect:
                 self.do_handshake()
             self._connected = True
         return rc
     except socket_error:
         self._sslobj = None
         raise
Exemple #18
0
    def _real_connect(self, addr, return_errno):
        if self._connected:
            raise ValueError('attempt to connect already-connected SSLSocket!')
        self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile,
                                    self.certfile, self.cert_reqs,
                                    self.ssl_version, self.ca_certs,
                                    self.ciphers)
        try:
            if return_errno:
                rc = socket.connect_ex(self, addr)
            else:
                rc = None
                socket.connect(self, addr)
            if not rc:
                if self.do_handshake_on_connect:
                    self.do_handshake()
                self._connected = True
            return rc
        except socket_error:
            self._sslobj = None
            raise

        return
Exemple #19
0
 def _real_connect(self, addr, connect_ex):
     if self.server_side:
         raise ValueError("can't connect in server-side mode")
     # Here we assume that the socket is client-side, and not
     # connected at the time of the call.  We connect it, then wrap it.
     if self._connected:
         raise ValueError("attempt to connect already-connected SSLSocket!")
     sslobj = self.context._wrap_socket(self, False, self.server_hostname)
     self._sslobj = SSLObject(sslobj, owner=self)
     try:
         if connect_ex:
             rc = socket.connect_ex(self, addr)
         else:
             rc = None
             socket.connect(self, addr)
         if not rc:
             self._connected = True
             if self.do_handshake_on_connect:
                 self.do_handshake()
         return rc
     except (OSError, ValueError):
         self._sslobj = None
         raise
Exemple #20
0
#Project written by Felix Otto Trihardjo
from sys import argv, exit
from socket import socket
from itertools import product
from datetime import datetime
from json import dumps, loads
with socket() as socket, open(r'C:\Users\user\IdeaProjects\Password Hacker\Password Hacker\task\hacking\logins.txt') as logins:
    socket.connect((argv[1],int(argv[2])))
    for admin in map(lambda line: line.strip(),logins.readlines()):
        socket.send(dumps({'login':admin,'password':'******'}).encode())
        response = loads(socket.recv(1024).decode())
        if response['result'] != 'Wrong login!':
            login = admin
            break
    password = ''
    while True:
        for c in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890':
            information = dumps({'login':login,'password':password+c})
            socket.send(information.encode())
            start = datetime.now()
            response = loads(socket.recv(1024).decode())
            time = datetime.now()-start
            if response['result'] == 'Connection success!':
                print(information)
                exit(0)
            if time.microseconds >= 90000:
                password += c
Exemple #21
0
def ssh_brute(ip):
    ssh_sock = sock(family=AF_INET, type=SOCK_STREAM)
    sock.connect((ip, 22))
    for u, p in creds:
        pass
Exemple #22
0
from socket import AF_INET, SOCK_STREAM, socket, SHUT_WR
import os

socket = socket(AF_INET, SOCK_STREAM)
destination = ('127.0.0.1', 7777)
recv_buffer_length = 1024
socket.connect(destination)


def receive_file(file):
    with open(CLIENT_HOME_PATH + file, 'w') as file:
        while True:
            m = socket.recv(recv_buffer_length)
            if len(m) != 0:
                file.write(m)
            else:
                break
    return


CLIENT_HOME_PATH = os.path.dirname(
    os.path.abspath(__file__)) + '\\local_files\\'

if __name__ == '__main__':

    ##########################################
    #          Case: Create new file         #
    ##########################################

    choice = 'Open/Edit file'
    socket.sendall(choice)
Exemple #23
0
from threading import Thread
import sys

host = 'localhost'
port = 1459
buffer_size = 1500

# Create the client socket. Connect to the server.
socket = socket(AF_INET, SOCK_STREAM)

done = False

while not done:

    try:
        socket.connect((host, port))
        done = True
    except Exception:
        print(
            'No connection could be made because the target machine is either offline or is refusing the connection.'
        )
        print('Here is the current network configuration:')
        print(' - Host: ' + str(host))
        print(' - Port: ' + str(port) + '\n')
        answer = input('Would you want to change those parameters? [Yes|No] ')
        if answer[:3] == 'Yes':
            host = input('Host: ')
            Port = int(input('Port: '))
        else:
            exit()
Exemple #24
0
        pause()
        sys.exit(1)
    except GAIError:
        logger.critical('No es una dirección válida.')
        pause()
        sys.exit(1)
    # Escuchar solamente una conexión.
    logger.info('Aceptando solamente una conexión')
    socket.listen(1)
    # Acceptar la conexión.
    c, ip = socket.accept()
    logger.debug('Conexión aceptada por: "%s:%d"', *ip)
else:
    logger.debug('Conectando como cliente a la dirección "%s:%d"', *conn)
    try:
        socket.connect(conn)  # Conectar como cliente.
    except OSError:
        logger.critical('Esta dirección no tiene servidor.')
        pause()
        sys.exit(1)

# Crear el protocolo.
logger.info('Creando el manejador para el protocolo NTP')
if server: t = Transfer(c)
else: t = Transfer(socket)

# Crear e iniciar el REPL.
logger.info('Creando REPL')
repl = REPL(t, CMDS)
if nm:
    logger.debug('Estableciendo apodo del REPL a "%s"', nm)
Exemple #25
0
from socket import socket, AF_INET, SOCK_STREAM
from time import sleep

HOST = '127.0.0.1'
PORT = 48423
RETRY_TIME = 5

if __name__ == '__main__':

    connected = False
    # Create Socket
    socket = socket(AF_INET, SOCK_STREAM)
    while (not connected):
        try:
            print("Attempting to connect to {}:{}".format(HOST, PORT))
            socket.connect((HOST, PORT))
            print("Connected...")
            connected = True
        except ConnectionRefusedError:
            print("Failed to connect. \nRetrying in {} seconds".format(
                RETRY_TIME))
            sleep(RETRY_TIME)

    while (True):
        message = b'o/'
        print("sending Message: {}".format(message))
        socket.sendall(b'o/')
        sleep(1)
Exemple #26
0
from socket import AF_INET, SOCK_STREAM, socket
from zadania10.functions import get_command

socket = socket(AF_INET, SOCK_STREAM)
socket.connect(("localhost", 125))
socket.settimeout(10)
print(socket.recv(1024))

socket.sendall(b"list_images   \r\n")
list_files = socket.recv(1024).replace(b"List: ", b"")

splt_list_files = list_files.split(b"$")
for i, j in zip(splt_list_files, range(len(splt_list_files))):
    print(str(j + 1) + ":", i.decode("utf-8"))

file_name = b""
while True:
    try:
        numFile = input("Choose file: ")
        if int(numFile) < 1:
            continue
        file_name = splt_list_files[int(numFile) - 1]
    except (IndexError, ValueError):
        continue
    break

socket.sendall(b"get_image: " + file_name + b"   \r\n")
f_command = get_command(socket)

if f_command == b"Not properly file_path!!!\r\n":
    print(f_command)
Exemple #27
0
def quit():
    socket.send("quit".encode())
    exit(0)


if __name__ == '__main__':
    if len(sys.argv) != 3:
        usage()
        exit(0)
    else:
        address = (sys.argv[1], int(sys.argv[2]))

    socket = socket(AF_INET, SOCK_STREAM)
    cmd = ""
    try:
        socket.connect(address)
        while (cmd != "/quit"):
            cmd = input()
            argv = cmd.split(' ', 1)
            if len(argv) == 1:
                if argv[0] == "/quit":
                    quit()
            else:
                if argv[0] == "/send":
                    socket.send(argv[1].encode())
    except ConnectionRefusedError:
        print("try different address")
    finally:
        socket.close()
Exemple #28
0
    def connect(self, address):
        socket.connect(self, address)
        socket.setsockopt(self, IPPROTO_TCP, TCP_NODELAY, 1)

        raw_send = self.send

        def send_x(data, timeout=0):
            view = memoryview(data)
            size = len(view)
            offset = 0
            while offset < size:
                _, ready_to_write, _ = select((), (self,), (), timeout)
                while not ready_to_write:
                    _, ready_to_write, _ = select((), (self,), (), timeout)
                sent = raw_send(view[offset:])
                if sent == 0:
                    raise SocketError("Peer closed connection")
                offset += sent

        raw_recv = self.recv
        received = [b""]  # the functions below assume exactly one item in this list on entry and exit

        def recv_headers(timeout=0):
            end = received[0].find(b"\r\n\r\n")
            while end == -1:
                ready_to_read, _, _ = select((self,), (), (), timeout)
                while not ready_to_read:
                    ready_to_read, _, _ = select((self,), (), (), timeout)
                data = raw_recv(8192)
                received[0] += data
                end = received[0].find(b"\r\n\r\n")
                if data == b"" and end == -1:
                    raise SocketError("Peer closed connection")
            data, received[0] = received[0][:end], received[0][(end + 4):]
            return data.split(b"\r\n")

        def recv_content(length=None, timeout=0):
            if length is None:
                # receive until closed
                if received[0]:
                    yield received[0]
                    received[0] = b""
                more = True
                while more:
                    ready_to_read, _, _ = select((self,), (), (), timeout)
                    while not ready_to_read:
                        ready_to_read, _, _ = select((self,), (), (), timeout)
                    data = raw_recv(8192)
                    if data == b"":
                        more = False
                    else:
                        yield data
            else:
                assert length >= 0
                # receive fixed amount
                while length != 0:
                    data, received[0] = received[0][:length], received[0][length:]
                    size = len(data)
                    if size != 0:
                        yield data
                        length -= size
                    if length != 0:
                        ready_to_read, _, _ = select((self,), (), (), timeout)
                        while not ready_to_read:
                            ready_to_read, _, _ = select((self,), (), (), timeout)
                        data = raw_recv(8192)
                        if data == b"":
                            raise SocketError("Peer closed connection")
                        received[0] += data

        def recv_line(timeout=0):
            end = received[0].find(b"\r\n")
            while end == -1:
                ready_to_read, _, _ = select((self,), (), (), timeout)
                while not ready_to_read:
                    ready_to_read, _, _ = select((self,), (), (), timeout)
                data = raw_recv(8192)
                received[0] += data
                end = received[0].find(b"\r\n")
                if data == b"" and end == -1:
                    raise SocketError("Peer closed connection")
            data, received[0] = received[0][:end], received[0][(end + 2):]
            return data

        def recv_exact(length, timeout=0):
            available = len(received[0])
            while available < length:
                ready_to_read, _, _ = select((self,), (), (), timeout)
                while not ready_to_read:
                    ready_to_read, _, _ = select((self,), (), (), timeout)
                data = raw_recv(8192)
                received[0] += data
                available += len(data)
                if data == b"" and available < length:
                    raise SocketError("Peer closed connection")
            data, received[0] = received[0][:length], received[0][length:]
            return data

        def recv_chunked_content(timeout=0):
            chunk_size = -1
            while chunk_size != 0:
                chunk_size = int(recv_line(timeout=timeout), 16)
                if chunk_size != 0:
                    yield recv_exact(chunk_size, timeout=timeout)
                recv_exact(2, timeout=timeout)

        self.send_x = send_x
        self.recv_headers = recv_headers
        self.recv_content = recv_content
        self.recv_chunked_content = recv_chunked_content
Exemple #29
0
 def __init__(self, ip: str):
     socket.__init__(self, AF_INET, SOCK_STREAM)
     socket.connect(self, (ip, 19))
 def __enter__(self):
     sock = socket(self.family, self.type)
     socket.connect(self.address)
     self.connections.append(sock)
     return sock
Exemple #31
0
def getMessage(host, port):
    socket.connect((host, port))
    connected = True
    while connected:
        print(str(socket.recv(1024), 'utf-8'))
Exemple #32
0
from socket import socket, AF_INET, SOCK_STREAM
from re import compile

HOST = ('52.49.91.111', 2092)
MAX_BUFFER = 2**15
POOL_SIZE = 10

pool = [socket(AF_INET, SOCK_STREAM) for _ in range(POOL_SIZE)]
[socket.connect(HOST) for socket in pool]

while True:
	for s, socket in enumerate(pool, 1):
		msg = ''#input('(%d) >>> ' % s).strip()
		if len(msg):
			msg = msg + '\n'
			socket.send(msg.encode())
		ans = socket.recv(MAX_BUFFER).decode()
		print(ans)

# PREPARE {1000, 9} -> 1
# ACCEPT {id: {4, 5}, value: {servers: [1,2,3,4,5,6,7,8], secret_owner: 4}}
Exemple #33
0
    def connect(self, address):
        socket.connect(self, address)
        socket.setsockopt(self, IPPROTO_TCP, TCP_NODELAY, 1)

        raw_send = self.send

        def send_x(data, timeout=0):
            view = memoryview(data)
            size = len(view)
            offset = 0
            while offset < size:
                _, ready_to_write, _ = select((), (self, ), (), timeout)
                while not ready_to_write:
                    _, ready_to_write, _ = select((), (self, ), (), timeout)
                sent = raw_send(view[offset:])
                if sent == 0:
                    raise SocketError("Peer closed connection")
                offset += sent

        raw_recv = self.recv
        received = [
            b""
        ]  # the functions below assume exactly one item in this list on entry and exit

        def recv_headers(timeout=0):
            end = received[0].find(b"\r\n\r\n")
            while end == -1:
                ready_to_read, _, _ = select((self, ), (), (), timeout)
                while not ready_to_read:
                    ready_to_read, _, _ = select((self, ), (), (), timeout)
                data = raw_recv(8192)
                received[0] += data
                end = received[0].find(b"\r\n\r\n")
                if data == b"" and end == -1:
                    raise SocketError("Peer closed connection")
            data, received[0] = received[0][:end], received[0][(end + 4):]
            return data.split(b"\r\n")

        def recv_content(length=None, timeout=0):
            if length is None:
                # receive until closed
                if received[0]:
                    yield received[0]
                    received[0] = b""
                more = True
                while more:
                    ready_to_read, _, _ = select((self, ), (), (), timeout)
                    while not ready_to_read:
                        ready_to_read, _, _ = select((self, ), (), (), timeout)
                    data = raw_recv(8192)
                    if data == b"":
                        more = False
                    else:
                        yield data
            else:
                assert length >= 0
                # receive fixed amount
                while length != 0:
                    data, received[0] = received[0][:length], received[0][
                        length:]
                    size = len(data)
                    if size != 0:
                        yield data
                        length -= size
                    if length != 0:
                        ready_to_read, _, _ = select((self, ), (), (), timeout)
                        while not ready_to_read:
                            ready_to_read, _, _ = select((self, ), (), (),
                                                         timeout)
                        data = raw_recv(8192)
                        if data == b"":
                            raise SocketError("Peer closed connection")
                        received[0] += data

        def recv_line(timeout=0):
            end = received[0].find(b"\r\n")
            while end == -1:
                ready_to_read, _, _ = select((self, ), (), (), timeout)
                while not ready_to_read:
                    ready_to_read, _, _ = select((self, ), (), (), timeout)
                data = raw_recv(8192)
                received[0] += data
                end = received[0].find(b"\r\n")
                if data == b"" and end == -1:
                    raise SocketError("Peer closed connection")
            data, received[0] = received[0][:end], received[0][(end + 2):]
            return data

        def recv_exact(length, timeout=0):
            available = len(received[0])
            while available < length:
                ready_to_read, _, _ = select((self, ), (), (), timeout)
                while not ready_to_read:
                    ready_to_read, _, _ = select((self, ), (), (), timeout)
                data = raw_recv(8192)
                received[0] += data
                available += len(data)
                if data == b"" and available < length:
                    raise SocketError("Peer closed connection")
            data, received[0] = received[0][:length], received[0][length:]
            return data

        def recv_chunked_content(timeout=0):
            chunk_size = -1
            while chunk_size != 0:
                chunk_size = int(recv_line(timeout=timeout), 16)
                if chunk_size != 0:
                    yield recv_exact(chunk_size, timeout=timeout)
                recv_exact(2, timeout=timeout)

        self.send_x = send_x
        self.recv_headers = recv_headers
        self.recv_content = recv_content
        self.recv_chunked_content = recv_chunked_content
Exemple #34
0
        sock.send(a.encode(ENCODE))
        data = sock.recv()
        response = data.decode(ENCODE)
        response = response.split("$")
        
        if response[0] == WRONGMOVE:
            print("Bad move")
            print()
            continue
        elif response[0] == MOVEMADE:
            qtdRows = int(response[1])
            qtdClosebyMines = eval(response[2])
            movesRemaing = int(response[3])
        elif response[0] == HITMINE:
            print("I guess you're dead\n")
            inicio(sock)
        elif response[0] == FINISH:
            print('*** Congrats you won, not so bad ***')
            inicio(sock)
            
        printBoard(qtdRows,qtdClosebyMines)
        print('you have ',movesRemaing,' moves.')
        print()

if __name__ == "__main__":
    context = zmq.Context()
    print("Connecting to the server")
    socket = context.socket(zmq.REQ)
    socket.connect("tcp://localhost:%s" % PORT)
    client_id = random.randrange(1, 10005)
    inicio(socket)
Exemple #35
0
 def connect(self, *args, **kwargs):
   time.sleep(random.random() * seconds)
   return _socket.connect(self, *args, **kwargs)
Exemple #36
0
"""
Created on 2012-12-22

@author: Administrator
"""
from socket import socket


HOST = 'localhost'
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)

socket = socket(socket.AF_INET, socket.SOCK_STREAM)
socket.connect(ADDR)
while True:
    line = input('> ')
    if not line:
        break
    socket.send(line.encode('utf-8'))
    buffer = socket.recv(BUFSIZ)
    if not buffer:
        break
    print(buffer.decode('utf-8'))
socket.close()
Exemple #37
0
def send(event=None):
    msg = chat.getMessage()
    signedText = encrypt_msg(socket, msg)
    socket.send(bytes(signedText, 'utf8'))

    if msg == 'q':
        chat.close()


def on_close():
    socket.close()


ADDR = 'localhost'
PORT = 33000
BUFSIZ = 1024
BLOCKSIZE = 16

socket = socket(AF_INET, SOCK_STREAM)
chat = Chat()
cert = RSA()
server_cert = None

if __name__ == "__main__":

    socket.connect((ADDR, PORT))
    exchange_keys()
    recv_thread = Thread(target=receive)
    recv_thread.start()
    chat.start(send, on_close)