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()
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')
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()
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
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()
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
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()
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
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
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
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
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
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
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
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
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
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
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
#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
def ssh_brute(ip): ssh_sock = sock(family=AF_INET, type=SOCK_STREAM) sock.connect((ip, 22)) for u, p in creds: pass
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)
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()
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)
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)
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)
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()
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
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
def getMessage(host, port): socket.connect((host, port)) connected = True while connected: print(str(socket.recv(1024), 'utf-8'))
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}}
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
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)
def connect(self, *args, **kwargs): time.sleep(random.random() * seconds) return _socket.connect(self, *args, **kwargs)
""" 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()
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)