def send_and_get_msg(sock: socket, values):
"""
Function handles communication between client and server and returns it.
:param sock: socket for comm
:param values: values to specify city and api_key used in communication
:return: server response
"""
ret = None
try:
sock.send(
bytes(
broadcast_data.format(values.city, values.api_key, host_name),
"utf-8"))
except Exception as err:
print("Failed to send a request. Details:\n",
err.__repr__(),
file=sys.stderr)
exit(1)
try:
ret = str(sock.recv(2048), "utf-8")
except Exception as err:
print(
"An exception during receiving a response has occurred. Details: \n",
err.__repr__(),
file=sys.stderr)
exit(1)
return ret
def receive_state(self,
job_id: str,
state: CythonBackend,
sock: socket,
overwrite: bool = False,
chunk_size: int = 2048,
max_inflight: int = 4):
syncaccept = SyncAccept()
syncaccept.job_id = job_id
syncaccept.chunk_size = chunk_size
syncaccept.max_inflight = max_inflight
# Let the other side know we are ready to receive and how to send info.
sock.send(syncaccept.SerializeToString())
running = True
while running:
syncstate = SyncState.FromString(sock.recv())
relstart = syncstate.rel_start_index
data = pbvec_to_vec(syncstate.data)
# Break abstraction barrier now
# TODO: unbreak it
if overwrite:
state.overwrite_relative_range(relstart, relstart + len(data),
data)
# state.state[relstart:relstart+len(data)] = data
else:
state.addto_relative_range(relstart, relstart + len(data),
data)
# state.state[relstart:relstart+len(data)] += data
sock.send(syncaccept.SerializeToString())
running = not syncstate.done
def ascii_str_by_socket(sock: socket):
"""Messages are received through sock and converted into ascii equivalent strings using str_to_ascii_str, and sent back via sock
Args:
sock: socket
The socket connection by which communication with the
client is implemented (AF_INET, SOCK_STREAM)
Returns:
(none)
Raises:
(none)
"""
msg_out: str = ' '
msg_in: str = ' '
while True:
msg_in = sock.recv(DEFAULT_BUFFER_SIZE)
if (msg_in.decode(UTF_8) == END_OF_FILE):
break
print('[S]: Message received from client: \'{}\''.format(
msg_in.decode(UTF_8)))
msg_out = str_to_ascii_str(msg_in.decode(UTF_8), '_')
print('[S]: Message sending to client: \'{}\''.format(msg_out))
sock.send(msg_out.encode(UTF_8))
def client_send(client_socket: socket):
while True:
print(
'1. register topic, 2. remove topic, 3. keep alive, 4. get match list, 5. publish'
)
command = input()
if command == '1':
type = input('type:')
name = input('name:')
period = input('period:')
msg = f'register_topic {type} {name} {period}'
elif command == '2':
name = input('name:')
msg = f'remove_topic {name}'
elif command == '3':
type = input('type:')
name = input('name:')
msg = f'keep_alive {type} {name}'
elif command == '4':
msg = f'get_match_list'
elif command == '5':
name = input('name:')
filename = 'text'
value = input('message:')
filesize = len(value)
msg = f'publish {name} {filename} {str(filesize)} {value}'
else:
print('Wrong command.')
client_socket.send(msg.encode('utf-8'))
def handle_outgoing_msgs(self, s: socket):
if self.server_state == E4ServerState.NEW__:
# request devices list
print('Getting list of devices...')
s.send(msg(E4ServerCommand.DEVICE_LIST__))
self.server_state = E4ServerState.WAITING__
elif self.server_state == E4ServerState.NO_DEVICES__:
print('No devices found!')
exit(1)
elif self.server_state == E4ServerState.DEVICES_FOUND__:
# connect to device
print('Connecting to device...')
s.send(
msg("%s %s" %
(E4ServerCommand.DEVICE_CONNECT__, self.device_id)))
self.server_state = E4ServerState.WAITING__
elif self.server_state == E4ServerState.CONNECTED_TO_DEVICE__:
# pause streaming initially
print('Initializing...')
s.send(msg("%s ON" % E4ServerCommand.PAUSE__))
self.server_state = E4ServerState.WAITING__
elif self.server_state == E4ServerState.READY_TO_SUBSCRIBE__:
# subscribe to streams
stream = self.stream_ids[self.sub_streams]
print('Subscribing to stream: %s' % stream)
s.send(
msg("%s %s ON" % (E4ServerCommand.DEVICE_SUBSCRIBE__, stream)))
self.server_state = E4ServerState.WAITING__
elif self.server_state == E4ServerState.SUBSCRIBE_COMPLETED__:
# begin streaming data
print('Requesting data')
s.send(msg("%s OFF" % E4ServerCommand.PAUSE__))
self.server_state = E4ServerState.STREAMING__
def handle_to(sock: socket, message: str):
# get the name of the client who this socket belongs to
global verbose
fromname = get_name_by_sock(sock)
if verbose:
print("\x1B[1;34mFrom:", fromname)
# Decode the message from <dest> <mesg> and send it to the dest client
splitmessage = message.split(" ", maxsplit=1)
print("Splitmessage:", splitmessage)
toname = splitmessage[0]
if (users.get(toname) != None):
destsock = users.get(toname)[1]
else:
edne = "EDNE " + toname + "\r\n\r\n"
sock.send(edne.encode())
return 0
# read the whole mesage and write to the dest
frommsg = "FROM " + fromname + " " + splitmessage[1]
while "\r\n\r\n" not in frommsg:
frommsg = frommsg + (sock.recv(32)).decode("utf-8")
if verbose:
print("\x1B[1;34m" + frommsg)
destsock.send(frommsg.encode())
return 0
def handle_reply(current_socket: socket, request: str) -> dict:
"""
Отправляет сообщение на сервер, получает и обрабатывает ответ
:param current_socket: сокет для общения с сервером
:param request: сформированный запрос на сервер
:return: ответ о проверке лабораторной работы
"""
logger.info("Sending request on server to check the lab...")
logger.debug("The request is: {request}".format(request=request))
current_socket.send(request.encode())
try:
reply_data: dict = json.loads(current_socket.recv(1024).decode())
logger.info("Got a reply from server!")
message_type: int = reply_data.pop('messageType')
if message_type == MessageType.WRONG_REQUEST.value:
raise SystemError(
"We've got problems: an error \n {error} \n occurred with a key '{key}'"
.format(error=reply_data['text'], key=reply_data['key']))
elif message_type == MessageType.SERVER_ERROR.value:
raise SystemError("Server has got a problem: {error}".format(
error=reply_data['errorMessage']))
elif message_type == MessageType.DEFAULT_ANSWER.value:
logger.debug("The lab was successfully checked, moving on..")
return reply_data
except TypeError as err:
raise TypeError(
"Error reading data from server: {error} \n with traceback {tb}".
format(error=err, tb=traceback.format_exc()))
def send_file(filename: str, conn: socket) -> None:
f = open(filename, 'rb')
l = f.read(1024)
while(l):
conn.send(l)
l = f.read(1024)
f.close()
def send_int(sock: socket, value: int) -> bool:
message = value.to_bytes(4, byteorder='big')
message_length = len(message)
to_send = message_length.to_bytes(4, byteorder='big')
len_sent = 0
while len_sent < len(to_send):
try:
sent = sock.send(to_send[len_sent:])
except BrokenPipeError:
print("Connection has been closed.")
return False
if sent == 0:
print("Connection has been closed.")
return False
len_sent += sent
len_sent = 0
while len_sent < message_length:
try:
sent = sock.send(message[len_sent:])
except BrokenPipeError:
print("Connection has been closed.")
return False
if sent == 0:
print("Connection has been closed.")
return False
len_sent += sent
def send_message(sock: socket, message: str) -> bool:
send_string = message.encode('utf-8')
message_length = len(send_string)
to_send = message_length.to_bytes(4, byteorder='big')
len_sent = 0
while len_sent < len(to_send):
try:
sent = sock.send(to_send[len_sent:])
except BrokenPipeError:
print("Connection has been closed.")
return False
if sent == 0:
print("Connection has been closed.")
return False
len_sent += sent
len_sent = 0
while len_sent < message_length:
try:
sent = sock.send(send_string[len_sent:])
except BrokenPipeError:
print("Connection has been closed.")
return False
if sent == 0:
print("Connection has been closed.")
return False
len_sent += sent
def dictionaryattack(connection: socket) -> None:
"""
Perform a dictionary attack, reading each line from a list of passwords and then mixes the letters,
both lowercase and uppercase, for realistic matters, using a generator.\n
When a password gives the correct response from the servers, it then prints a json string
with the correct user and password.
:param connection: Current connection
:return: None
"""
with open(
'C:/Users/intel/PycharmProjects/Password Hacker/Password Hacker/task/hacking/passwords.txt',
'r') as f:
user = getuser(connection)
for raw_pwd in f:
clean_pwd = raw_pwd.strip()
mixed_letters = map(
lambda x: ''.join(x),
product(*([letter.lower(), letter.upper()]
for letter in clean_pwd)))
for attempt in mixed_letters:
data = {"login": user, "password": attempt}
encoder = json.dumps(data)
start = datetime.now()
connection.send(encoder.encode())
if checkresponse(connection, start) == 200:
raise TypeError(json.dumps(data))
def charloop(user: str,
charset: list,
connection: socket,
charprevious='') -> str:
"""
Uses time vulnerability.\n
Will loop through a set of characters until the server takes too long to respond.\n
(Meaning a character of the password was found.)\n
Uses recursion to append the characters until the server returns a successful connection.
:param user: The already found username
:param charset: Set of characters
:param connection: Current connection
:param charprevious: (For recursion purposes) Previous character found
:return: String with full password if any is found
"""
for char in charset:
attempt = charprevious + char
data = {"login": user, "password": attempt}
encoder = json.dumps(data)
start = datetime.now()
connection.send(encoder.encode())
status = checkresponse(connection, start)
if status == 200:
return attempt
elif status == 500:
return charloop(user, charset, connection, charprevious=attempt)
def crack_user(sock: socket) -> str:
# Define a list of common admin usernames.
common_usernames = [
'admin', 'Admin', 'admin1', 'admin2', 'admin3', 'user1', 'user2',
'root', 'default', 'new_user', 'some_user', 'new_admin',
'administrator', 'Administrator', 'superuser', 'super', 'su', 'alex',
'suser', 'rootuser', 'adminadmin', 'useruser', 'superadmin',
'username', 'username'
]
# Attempt to login via the specified socket with each of the common admin usernames.
for usr in common_usernames:
# Create a dictionary of the current credentials being tested.
credentials = {"login": usr, "password": "******"}
# Create a JSON string from the credentials, encode it and send it to the specified socket.
sock.send(dumps(credentials).encode())
# Decode the site's response, load a dictionary from that JSON string and retrieve the value paired with the
# 'result' key.
result = loads(sock.recv(1024).decode())['result']
# If the result is 'Wrong password!', the correct username was found.
if result == 'Wrong password!':
return usr
# If none of the common admin usernames are the correct one, raise an exception.
raise AssertionError('Unable to determine admin username.')
def ascii_list_by_socket(sock: socket, lines: [str]) -> [str]:
"""Sends str from lines: [str] through client socket connection sock: socket and returns a new [str] with equivalent ascii-formatted strings
from lines, generated by a server program
Args:
sock: socket
The client socket connection by which communication with the
server is implemented (AF_INET, SOCK_STREAM)
lines: [str]
str elements parsed from an input file, using function file_to_list, that will be sent to a server via sock
Returns:
A [str] with ascii-formatted strings equivalent to the elements from within lines: [str]
Raises:
(none)
"""
msg_out: str = ' '
msg_in: str = ' '
output: [str] = []
for element in lines:
msg_out = element
print('[C]: Message sending to server: \'{}\''.format(msg_out))
sock.send(msg_out.encode(UTF_8))
msg_in = sock.recv(DEFAULT_BUFFER_SIZE)
print('[C]: Message received from server: \'{}\''.format(
msg_in.decode('utf-8')))
output.append(msg_in.decode(UTF_8))
return output
def send_recv(sock: socket, command: bytes):
try:
sock.send(command)
data = sock.recv(1024)
except Exception as e:
return b"Connection error " + str(e).encode()
return data
def deal_client(newSocket: socket, addr):
global queue_
status = False
while True:
sleep(1)
try:
if status and not queue_.empty():
submissionId_proId = queue_.get()
print(submissionId_proId)
newSocket.send(("judge|%s" % submissionId_proId).encode())
data = newSocket.recv(1024)
recv_data = data.decode()
if recv_data == 'gotten':
status = False
else:
queue_.put(submissionId_proId)
else:
newSocket.send('get_status'.encode())
data = newSocket.recv(1024)
recv_data = data.decode()
if recv_data == "ok":
status = True
print(addr, status)
except socket.error:
newSocket.close()
except Exception as e_:
newSocket.close()
print(e_)
def send_state(self, job_id: str, state: StateType, sock: socket):
syncaccept = SyncAccept.FromString(sock.recv())
if syncaccept.job_id != job_id:
raise Exception("Job ids do not match: {}/{}".format(
job_id, syncaccept.job_id))
inflight = 0
last_index = 0
total_size = state.get_state_size()
while last_index < total_size:
while inflight < syncaccept.max_inflight and last_index < total_size:
end_index = last_index + min(total_size - last_index,
syncaccept.chunk_size)
syncstate = SyncState()
syncstate.job_id = job_id
syncstate.rel_start_index = last_index
vec_to_pbvec(state.get_relative_range(last_index, end_index),
pbvec=syncstate.data)
inflight += 1
last_index = end_index
syncstate.done = last_index == total_size
sock.send(syncstate.SerializeToString())
# Overwrite syncaccept to allow live changes to inflight and chunk_size.
syncaccept = SyncAccept.FromString(sock.recv())
inflight -= 1
if syncaccept.job_id != job_id:
raise Exception("Job ids do not match: {}/{}".format(
job_id, syncaccept.job_id))
def client_thread(conn: socket, addr):
question = json.dumps({
'hour': time.localtime().tm_hour + 3,
'minute': time.localtime().tm_min,
'nick': 'server',
'message': 'What\'s your name?'
})
conn.send(bytes(question, encoding='utf8'))
username = conn.recv(1024).decode("utf-8")
if len(username) == 0 or username[0:14] != token:
remove(curr_connection=conn)
conn.close()
greeting_message = "Welcome to the club " + username[14:]
greeting = json.dumps({
'hour': time.localtime().tm_hour + 3,
'minute': time.localtime().tm_min,
'nick': 'server',
'message': greeting_message
})
try:
conn.send(bytes(greeting, encoding='utf8'))
except Exception as e:
print("User not auth")
conn.close()
remove(conn)
broadcast_meeting(username=username[14:], connection=conn)
try:
while True:
message = conn.recv(1024).decode("utf-8")
auth(message=message)
if len(message) > 0:
message_to_send = json.dumps({
'hour':
time.localtime().tm_hour - 3,
'minute':
time.localtime().tm_min,
'nick':
username[14:],
'message':
message[14:]
})
print("cool")
broadcast(message_to_send, conn)
else:
conn.close()
remove(conn)
except ConnectionResetError:
print("Connection lost")
conn.close()
remove(conn)
except Exception as e:
print(str(e))
conn.close()
remove(conn)
def send_greeting(app: str, sock: socket):
"""
Send greeting message for initial connection
:app: Which application is sending the data
:sock: Socket to send greeting on
"""
sock.send(bytes("-- CONNECTION ESTABLISHED --", "utf-8"))
def SavePublicKey(key, csocket: socket):
csocket.send(server_services['SaveKey'])
csocket.send(bytes(key, 'utf-8'))
response = csocket.recv(1024)
if response == b'OK':
return True
else:
return False
def receive_server_response(s: socket, response: HttpRequestInfo) -> list:
s.send(response.to_byte_array(response.to_http_string()))
received_data = s.recv(Constants.MAX_RECEIVE)
server_response = []
while len(received_data) > 0:
server_response.append(received_data)
received_data = s.recv(Constants.MAX_RECEIVE)
s.close()
return server_response
def write_event(s: socket):
"""写事件处理流程"""
try:
# 非阻塞获取该套接字上的任务
next_msg = message[s].get_nowait()
except queue.Empty:
outputs.remove(s) # 如果该套接字上任务全完成 移出该套接字
else:
s.send(next_msg) # 发送消息
def __tunnelling(self, src: socket, dst: socket):
try:
data = src.recv(16384)
if data:
dst.send(data)
else:
raise NameError("ConnectionClosed")
except BlockingIOError:
return
def RegisterListener(csocket: socket, port):
csocket.send(server_services['RegisterListener'])
resp = csocket.recv(1024)
if resp == server_services['RegisterListener']:
csocket.send(bytes(str(port), 'utf-8'))
response = csocket.recv(1024)
if response == b'OK':
return True
else:
return False
def _handle_request(self, client: socket, address):
try:
data = self._retrieve_request_data(client)
request = HttpRequest(data)
response = HttpResponse(request)
Dispatcher.dispatch(response)
client.send(response.render())
client.close()
except:
sys.exit()
def send_to_client(client_socket: socket, data=str):
try:
client_socket.send(bytes.fromhex(data))
sleep(0.5)
except ConnectionAbortedError as ce:
traceback.print_exc()
print(ce)
except ConnectionResetError as cr:
traceback.print_exc()
print(cr)
def delete(self, sock: socket, port: int):
"""
"""
delete_cmd = "{vertex}, DELETE, {port}, {ip}".format(
vertex=self.vertex_id, port=port, ip="0.0.0.0")
self.logging.debug(
"Sending DELETE command to controller: [{}]".format(delete_cmd))
sock.send(bytes(delete_cmd, "utf-8"))
data = self.recv_data(sock)
self.parse_fwd_table(data)
def send_data_pickle(conn: socket, data: tuple):
"""
Send data turned into pickle to conn
:param conn: socket
:param data: data to send (MessageType Enum, DATA)
:return: None
"""
data_pickle = pickle.dumps(data)
conn.send(make_header(data_pickle))
conn.sendall(data_pickle)
def get_login(client_socket: socket):
logins = set()
with open("C:\\logins.txt", "r") as f:
for line in f:
logins.add(line.strip())
for login in logins:
request = json.dumps({"login": login, "password": "******"}).encode()
client_socket.send(request)
response = client_socket.recv(1024).decode()
if response == json.dumps({"result": "Wrong password!"}):
return login
def exit(self, sock: socket):
"""
Closes a clients connection safely
:sock: Socket of the connection to close on
"""
self.logging.debug("Closing sockets and preparing to exit")
print("\nClosing connections")
sock.send(bytes("{}, EXIT, 0, 0.0.0.0".format(self.vertex_id),
"utf-8"))
sock.close()
def AI(s: socket, command: str, column_number: int) -> None:
'''receive actions from server'''
if command == 'A':
s.send(str('DROP ' + str(column_number) + '\r\n').encode(encoding = 'utf-8'))
c = s.recv(4096).decode(encoding = 'utf-8')
reply_A = s.recv(4096).decode(encoding = 'utf-8')
return reply_A
elif command == 'B':
s.send(str('POP ' + str(column_number) + '\r\n').encode(encoding = 'utf-8'))
c = s.recv(4096).decode(encoding = 'utf-8')
reply_B = s.recv(4096).decode(encoding = 'utf-8')
return reply_B
def handleClient(clientSocket:socket):
received = clientSocket.recv(1024)
print('Received data', received)
clientSocket.send('hello')
clientSocket.close()
