def start_transmission(self):
if self.client_mode == MainWindow.RECEIVER_MODE:
foldername = self.path_line_edit.text()
if foldername == '':
foldername = '.'
self.worker = Receiver(foldername, self.SIGNALS)
if self.client_mode == MainWindow.SENDER_MODE:
filename = self.path_line_edit.text()
parameters = self.parameters()
self.worker = Sender(filename, parameters, self.SIGNALS)
self.log_signal.connect(self.log)
self.on_finish_signal.connect(self.on_finish)
dispatcher.connect(self.trigger_log_signal,
self.LOG_SIGNAL,
weak=False)
dispatcher.connect(self.trigger_on_finish_signal,
self.FINISH_SIGNAL,
weak=False)
self.worker.start()
self.stacked_widget.setCurrentIndex(MainWindow.LOG_PAGE)
def onRecAppendEntriesRPCReply(message):
if(not message.success):
Leader.setMatchIndex(message.followerId, message.matchIndex)
Leader.setMatchSuccess(message.followerId, False)
Leader.decrementNextIndex(message.followerId)
#print("Retry AppendEntriesRPC "+str(State.nextIndex[message.followerId])+" to: "+str(message.followerId))
print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): '+'Datacenter '+str(message.followerId)+' unmatched! '+'Retry Entry '+str(State.nextIndex[message.followerId]))
sender=Sender('AppendEntriesRPC',Leader.heartbeat(message.followerId))
sender.setConn(State.dc_list[message.followerId])
sender.start()
Leader.setPeriod(message.followerId)
else:
if(not State.matchSuccess[message.followerId]):
#print('matched the case!!!!')
pass
else:
Leader.incrementNextIndex(message.followerId)
if(message.matchIndex==State.matchIndex[message.followerId]):
pass
else:
print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): '+'Datacenter '+str(message.followerId)+' matched with Entry '+str(message.matchIndex))
#print('matched')
Leader.setMatchIndex(message.followerId,message.matchIndex)
Leader.setMatchSuccess(message.followerId, True)
if(message.matchIndex>State.commitIndex):
Leader.checkCommit(message.matchIndex)
def start_test(chosen_algorithm, control_method, probability, windows_size,
packet_size, model, P01, P10):
img = Image.open("test.jpg")
receiver = Receiver()
sender = Sender(receiver, control_method, windows_size, packet_size)
sender.set_ts_interference(probability, model, P01, P10)
img_array = np.asarray(img)
sender.data_to_binary(img_array)
sender.split_array()
sender.send_frames(chosen_algorithm)
error_counter = 0
ber = 0
for j in range(0, len(receiver.result)):
final_pack = receiver.result[j].astype(np.uint8)
start_pack = sender.packets[j]
for i in range(0, packet_size):
if start_pack[i] != final_pack[i]:
error_counter += 1
j += 1
ber = error_counter / (len(receiver.result) * packet_size) * 100
final_img = receiver.finalize_img()
return receiver.numberOfAcceptedPackets, receiver.numberOfRejectedPackets, ber
def sendFile(file, url='localhost', queue='default'):
s = Sender(url)
text = os.path.basename(file) + '?\n'
with open(file, 'r') as f:
text += f.read()
s.send(text, queue)
def malware_train(line):
global malware_train_nb
if (mta.check_if_link_is_in_downloaded_file(line) is False):
pcap_file_name = mta.download_pcap([line])
for pcap in pcap_file_name:
if (pcap is not None):
if (check_if_already_trained(pcap) is False):
attacker = AttackerCalc(pcap=mta.get_folder_name() + "/" +
pcap)
ip_to_consider = attacker.compute_attacker()
flow_type = "malware"
filter_1.set_ip_whitelist_filter(ip_to_consider)
filter_2.set_ip_whitelist_filter(ip_to_consider)
filter_3.set_ip_whitelist_filter(ip_to_consider)
featuresCalc = FeaturesCalc(flow_type=flow_type,
min_window_size=5)
csv = CSV(file_name="features_" + flow_type,
folder_name="Features")
csv.create_empty_csv()
csv.add_row(featuresCalc.get_features_name())
argument = {
"features_calc": featuresCalc,
"packets": [],
'filter': [filter_1, filter_2, filter_3],
'csv_obj': csv
}
sniffer = Sniffer(iface_sniffer,
callback_prn=callback_sniffer,
callback_prn_kwargs=argument)
sniffer.start()
while (sniffer.get_started_flag() is False):
pass
try:
sender = Sender(iface_sender,
fast=False,
verbose=False,
time_to_wait=10)
sender.send(mta.get_folder_name() + "/" + pcap)
sniffer.stop()
except Exception as e:
print(e)
csv.close_csv()
env.set_csv(csv.get_folder_name() + "/" +
csv.get_current_file_name())
agent.train_agent(
steps=csv.get_number_of_rows() - 1,
log_interval=csv.get_number_of_rows() - 1,
verbose=2,
nb_max_episode_steps=csv.get_number_of_rows() - 1)
malware_train_nb -= 1
trained_file.write(pcap + "\n")
else:
print("\nPcap gia' utilizzato in passato. Saltato.\n")
else:
pass
else:
pass
def request_post(self, number, addr):
try:
post = self.to_view[-number]
except IndexError:
raise exception.NonExistingPost
sender = Sender(self, post, addr)
sender.start()
print(self.ans_sock)
return self.ans_sock
def updateStats():
global sessionId
stater = Stater(sessionId)
sender = Sender(sessionId)
while True:
sender.sendRequests(stater.getCurrentService())
time.sleep(sender.getPoll())
if sessionId == None:
break
def testSenderSend(self, mock_pika, mock_dec, mock_print):
s = Sender()
mock_pika.BasicProperties.return_value = ''
s.send("some message")
mock_pika.BlockingConnection.return_value.channel.return_value.basic_publish.assert_called_with(
body="some message",
exchange='',
properties='',
routing_key='default')
def initialise_connection(self):
self.local_socket = socket.socket()
self.local_socket.bind((self.address, self.port))
self.local_socket.listen(5)
if self.address == 'localhost':
self.address = '127.0.0.1'
self.address_list.append(self.address + ':' + str(self.port))
self.sender = Sender(self.local_socket, self.addresses)
self.sender.start()
def onRecAppendEntriesRPC(self, message):
#print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Receive AppendEntriesRPC from: '+\
#str(message.leaderId)+" term"+str(message.term))
if (StateController.eql(State.state, 'follower')):
reply = Follower.onRecAppendEntriesRPC(message)
else:
reply = Receiver.onRecAppendEntriesRPC(message)
sender = Sender('AppendEntriesRPCReply', reply)
sender.send(self.dc_list[message.leaderId])
def onRecAppendEntriesRPC(self,message):
#print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Receive AppendEntriesRPC from: '+\
#str(message.leaderId)+" term"+str(message.term))
if(StateController.eql(State.state,'follower')):
reply=Follower.onRecAppendEntriesRPC(message)
else:
reply=Receiver.onRecAppendEntriesRPC(message)
sender=Sender('AppendEntriesRPCReply',reply)
sender.send(self.dc_list[message.leaderId])
def get_info(self, _method, _url, _params):
_params = self._loc_f.format_input(_params)
__data, __cookie = self._loc_f.deal_params(_params)
_sender = Sender()
_sender.send(_method, _url, __data, __cookie)
self.status_code = _sender.status_code
self.feed_back = _sender.feedback
self.error_msg = _sender.error_msg
self.cookie = _sender.cookie
if self.error_msg:
Errors(self.error_msg)
def set_threads(self, manager):
self.ts = Sender(self.client.multicast_addr, self.client.port,
self.client.pvt_port)
self.ts.start()
self.tr = Receiver(self.client.multicast_addr, self.client.port,
manager)
self.tr.start()
self.trp = Receiver_pvt(manager)
self.trp.start()
self.tl = Listener(manager)
self.tl.start()
class UserInterface(threading.Thread):
def __init__(self, Debug=False):
self.debug = Debug
threading.Thread.__init__(self)
self.setName("GUI")
self.fenetre = Tk()
self.fenetre.title("Commande")
self.senderbox = Frame(self.fenetre)
self.senderbox.pack(side="left", expand=False, padx=5, pady=5)
self.sender = Sender(self, self.senderbox, Debug=self.debug)
self.receiverbox = Frame(self.fenetre)
self.receiverbox.pack(side="right", expand=True, fill="x", padx=5, pady=5)
self.receiver = Receiver(self.receiverbox, Debug=self.debug)
self.start()
def run(self):
if self.debug is True:
print("[GUI] : GUI >> Interface Graphique operationnel")
self.fenetre.mainloop()
def quitter(self):
self.fenetre.quit()
def setConnexion(self, conn):
self.sender.setConnexion(conn)
def log(self, provenance, message):
provenance = provenance+"/GUI"
try:
self.receiver.log(provenance, message)
except:
if self.debug is True:
print("[GUI] : GUI >> Attention connexion avec le logger non existant !")
print("message: " + message)
def __init__(s,x,y):
#Dane:
Sender.__init__(s)
s.__x,s.__y=x,y
s.__X,s.__Y=x,y
s.__visible=1
s.__exist=1
s.__selected=0
#Definicje:
s.create()
s.show()
s.select()
def __init__(s, todo, master, text, x, y):
#Dane:
Sender.__init__(s)
s.__noteM = NoteManager()
s.__todo = todo
s.__master = master
s.__text = text
s.__x, s.__y = x, y
s.__h = 20
s.__selected = 0
s.__visible = 1
s.__exist = 1
def onRecReqVoteRPC(self,message):
#print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Receive ReqVoteRPC from: '+\
#str(message.candidateId)+" term"+str(message.term))
if(StateController.eql(State.state,'follower')):
reply=Follower.onRecReqVoteRPC(message)
else:
reply=Receiver.onRecReqVoteRPC(message)
#print(reply.voteGranted)
sender=Sender('RequestVoteRPCReply',reply)
sender.send(self.dc_list[message.candidateId])
def onRecReqVoteRPC(self, message):
#print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Receive ReqVoteRPC from: '+\
#str(message.candidateId)+" term"+str(message.term))
if (StateController.eql(State.state, 'follower')):
reply = Follower.onRecReqVoteRPC(message)
else:
reply = Receiver.onRecReqVoteRPC(message)
#print(reply.voteGranted)
sender = Sender('RequestVoteRPCReply', reply)
sender.send(self.dc_list[message.candidateId])
def __init__(self, filename, timer):
Sender.__init__(self, filename)
self.fwdr_actions = {
('1', '1'): self.run_oneFwdr_oneImage,
('1', 'n'): self.run_oneFwdr_manyImages
}
if timer is None:
self._timer = int(self.get_timer())
else:
self._timer = int(timer)
self._aux_publisher = self.get_publisher('AUX_PUB', 'AUX_PUB')
def sendReqVoteRPC(dcNum):
lastLogIndex=State.log.getLastIndex()
lastLogTerm=State.log.getLastTerm()
reqRPC=RequestVoteRPC(State.currentTerm,State.dc_ID,lastLogIndex,lastLogTerm)
if(State.receiverList[dcNum]):
#print("Send ReqVoteRPC to: "+str(dcNum))
print("("+str(State.dc_ID)+","+State.state+","+str(State.currentTerm)+'): Send Request to datacenter '+str(dcNum))
sender=Sender('RequestVoteRPC',reqRPC)
sender.setConn(State.dc_list[dcNum])
sender.start()
def test_sender_negative(self):
sample_input_json = {
"date": "2020-08-09",
"name": "cycle1",
"components": {
"frame": ["top_tube", "down_tube", "seat_tube"],
"wheel": ["spokes", "hub", "rim"],
"seat": ["saddle"],
"handlebar": ["handlebar_grip", "fork"],
"chain": ["chain", "chain_rings"]
}
}
S = Sender()
self.assertEqual(S.test_fetch(sample_input_json).status_code, 500)
def sale(self) -> None:
while True:
req = self.input_request()
profit, node = self.caculate_profit(req)
if profit > 0:
self.lock.acquire()
req.offtime = time.time() + req.duration
heapq.heappush(self.requests, req)
self.lock.release()
self.reply_customers()
msg = Sender().makeSFCMsg(req)
Sender().sendsfc(node.addr, msg)
print(msg)
if not config.FLAG:
break
class PyToPyChat:
def __init__(self):
self.sender = Sender()
self.listener = Listener(event_handler=self)
self.peers = []
def launch(self, port):
"""Launch the threads and get the user's name"""
self.name = input('What is your name? ')
# Prepare the threads
listener_thread = threading.Thread(target=self.listener.launch, args=(port, ))
listener_thread.daemon = True
ui_thread = threading.Thread(target=self.user_input)
# Start the threads
listener_thread.start()
ui_thread.start()
self.user_input()
def add_peer(self, location):
"""Add a peer for broadcasting. Should be done prior to launch"""
self.peers.append(location)
def broadcast(self, message):
"""Broadcast to all added peers"""
# Don't send an empty message
if message is '':
return
# Package up so everyone knows your name
payload = {'name': self.name,'content': message}
# Now send to everyone
for peer in self.peers:
self.sender.send(payload, peer)
def user_input(self):
"""Wait for the user to input a message, then broadcast"""
text_to_send = ''
while text_to_send != '/exit':
self.broadcast(text_to_send)
text_to_send = input('')
def handle_message(self, message):
"""event_handler method"""
decoded = json.loads(message.decode('utf-8'))['message']
print('{0}: {1}'.format(decoded['name'],decoded['content']))
def __init__(self, line: str):
self.line = line
self.command = ""
self.sender = None
self.params = []
if line == "":
return
if line[0] == ':':
line = line[1:]
words = line.split(maxsplit=1)
self.sender = Sender(words.pop(0))
if len(words) == 0:
# this is actually a malformed message
return
line = words[0]
words = line.split(maxsplit=1)
self.command = words.pop(0)
if len(words) == 0:
return
# want to preserve whitespace in :params
words = words[0].split(" ")
while len(words) > 0:
if not words[0]:
words.pop(0)
continue
if words[0][0] == ":":
self.params.append(" ".join(words)[1:])
break
else:
self.params.append(words.pop(0))
def sendAppendEntriesRPC(dcNum):
if(Leader.isSelf(dcNum)):
return
if(State.matchSuccess[dcNum]):
#print("Send AppendEntriesRPC Entry"+str(State.nextIndex[dcNum])+" to: "+str(dcNum))
sender=Sender('AppendEntriesRPC',Leader.entry(dcNum))
sender.setConn(State.dc_list[dcNum])
sender.start()
else:
#print("Send AppendEntriesRPC Heartbeat"+str(State.nextIndex[dcNum])+" to: "+str(dcNum))
sender=Sender('AppendEntriesRPC',Leader.heartbeat(dcNum))
sender.setConn(State.dc_list[dcNum])
sender.start()
def __createSender__(self):
"""
Initializes the sender object. Used by the constructor.
"""
# Sender is not a new thread, so it does not need a lock
params = {}
params["addresses"] = self.addresses
params["port"] = "8030"
if hasattr(self.myconfig.RemoteMsg, "senderPort"):
params["port"] = self.myconfig.RemoteMsg.senderPort
params["service"] = "msg"
if hasattr(self.myconfig.RemoteMsg, "senderService"):
params["service"] = self.myconfig.RemoteMsg.senderService
params["user"] = None
if hasattr(self.myconfig.RemoteMsg, "senderUser"):
params["user"] = self.myconfig.RemoteMsg.senderUser
params["pwd"] = None
if hasattr(self.myconfig.RemoteMsg, "senderPwd"):
params["pwd"] = self.myconfig.RemoteMsg.senderPwd
params["realm"] = "RemoteMsg"
if hasattr(self.myconfig.RemoteMsg, "realm"):
params["realm"] = self.myconfig.RemoteMsg.senderRealm
self.sender = Sender(self.msgQueue, params)
def test_server():
# Message class should process leading :
s = "Prothid.CA.US.GameSurge.net"
sender = Sender(s)
assert sender.full == s
assert sender.host == ""
assert sender.nick == s
assert sender.ident == ""
def test_chatter():
s = "Bruk!~Bruk@Bruk_.user.gamesurge"
sender = Sender(s)
assert sender.full == s
assert sender.nick == "Bruk"
assert sender.ident == "~Bruk"
assert sender.host == "Bruk_.user.gamesurge"
sender = Sender("knivey")
assert sender.full == "knivey"
assert sender.nick == "knivey"
assert sender.ident == ""
assert sender.host == ""
sender = Sender("foo!bar")
assert sender.nick == "foo"
assert sender.ident == "bar"
assert sender.host == ""
def test_mask():
s = "Bruk!~Bruk@Bruk_.user.gamesurge"
sender = Sender(s)
assert sender.hostmask_match("*!*@*")
assert sender.hostmask_match("*!?*@*")
assert sender.hostmask_match("*")
assert sender.hostmask_match("*!?bruk@*")
assert False == sender.hostmask_match("*!?bruk@*k")
def verify_hacker():
for name, cipher in cipher_list.items():
key_encrypt, key_decrypt = cipher.generate_keys()
sender = Sender(cipher=cipher, key=key_encrypt)
receiver = Receiver(cipher=cipher, key=key_decrypt)
hacker = Hacker(cipher=cipher)
clear_text = "Hello World"
encrypted_message = sender.send_message(clear_text)
decrypted_message = receiver.receive_message(encrypted_message)
decrypted_hacker = hacker.receive_message(encrypted_message)
print(" ")
print(f"Current cipher: {name}")
print("Clear text: ", clear_text)
print("Hacked: ", decrypted_hacker)
def legitimate_train(line):
global legitimate_train_nb
if (check_if_already_trained(line) is False):
flow_type = "legitimate"
filter_1.set_ip_whitelist_filter([])
filter_2.set_ip_whitelist_filter([])
filter_3.set_ip_whitelist_filter([])
featuresCalc = FeaturesCalc(flow_type=flow_type, min_window_size=5)
csv = CSV(file_name="features_" + flow_type, folder_name="Features")
csv.create_empty_csv()
csv.add_row(featuresCalc.get_features_name())
argument = {
"features_calc": featuresCalc,
"packets": [],
'filter': [filter_1, filter_2, filter_3],
'csv_obj': csv
}
sniffer = Sniffer(iface_sniffer,
callback_prn=callback_sniffer,
callback_prn_kwargs=argument)
sniffer.start()
while (sniffer.get_started_flag() is False):
pass
try:
sender = Sender(iface_sender,
fast=False,
verbose=False,
time_to_wait=10)
sender.send(lg.get_folder_name() + "/" + line)
sniffer.stop()
except Exception as e:
print(e)
csv.close_csv()
env.set_csv(csv.get_folder_name() + "/" + csv.get_current_file_name())
agent.train_agent(steps=csv.get_number_of_rows() - 1,
log_interval=csv.get_number_of_rows() - 1,
verbose=2,
nb_max_episode_steps=csv.get_number_of_rows() - 1)
legitimate_train_nb -= 1
trained_file.write(line + "\n")
else:
print("\nPcap gia' utilizzato in passato. Saltato.\n")
def SR_Sender(sock, receiverIP, receiverPort, payload, debug, parent):
#create filepath to parent's (Server/Client) sending temp file
fileName = 'temp.txt'
fileTemp = os.path.join(os.getcwd(), parent, "Data", "Sender")
file = os.path.join(os.getcwd(), fileTemp, fileName)
#write payload to temp file that will be read on a per packet basis
with open(file, "w") as f:
f.write(payload)
#initialize sender object
sender = Sender(sock, debug, parent)
#send payload contained in temp file via selective repeat
try:
sender.send(fileName, receiverIP, receiverPort)
except Exception as e:
print("Exception Occured: " + str(e))
#delete temp file
os.remove(file)
def main(system):
# Filename of the "clues", full path and filename for the log, logging level,
#scp or rcp, User name under which to send "clues", Machine where to send the "clues"
(clues_name, logname, log_level, copying, user, host) = sys.argv[1:]
# Enable logging
logger = Logger(logname, log_level, "CCS")
logger = logger.getLogger()
logger.info("Beginning of CCS program (system %s) on " % (system) +
str(localhost))
if system == 'PDS':
# Obtain infos ("clues") from the PDS on which this software is running
manager = PDSManager("CCS")
manager.makeClientDict() # Clues about PDS clients
manager.makeInputDirDict() # Clues about input directories
elif system == 'PX':
# Obtain infos ("clues") from the PX on which this software is running
manager = NCSManager("CCS")
manager.makeCircuitDict() # Clues about PX
# Useful printing for debugging purpose
if (DEBUG and system == 'PDS'):
print
manager.printClientDict()
print
manager.printInputDirDict()
# Serialization of the clues
clues_filename = CLUES + "/" + clues_name + '.' + manager.machine
manager.archiveInfos(clues_filename)
# Sending of the clues to the CIR host
sender = Sender('CCS')
sender.send(copying, user, host, clues_filename, INPUT_CLUES)
logger.info("Ending of CCS program (system %s) on " % (system) +
str(localhost))
def __init__(self, buff_size, serve_per_timestep, ttl, sender_num,
long_time, path):
self.log = open(path, "w")
self.dest = Receiver(self, buff_size, serve_per_timestep)
self.senders = [
Sender(self, self.dest, long_time, ttl, i, ttl / sender_num)
for i in range(sender_num)
]
# self.senders += [CompetitiveSender(self, self.dest, long_time, ttl, i + sender_num, ttl/sender_num)
# for i in range(sender_num)]
self.messages = deque()
self.ttl = ttl
self.time = 0
def main(system):
# Filename of the "clues", full path and filename for the log, logging level,
#scp or rcp, User name under which to send "clues", Machine where to send the "clues"
(clues_name, logname, log_level, copying, user, host) = sys.argv[1:]
# Enable logging
logger = Logger(logname, log_level, "CCS")
logger = logger.getLogger()
logger.info("Beginning of CCS program (system %s) on " % (system) + str(localhost))
if system == 'PDS':
# Obtain infos ("clues") from the PDS on which this software is running
manager = PDSManager("CCS")
manager.makeClientDict() # Clues about PDS clients
manager.makeInputDirDict() # Clues about input directories
elif system == 'PX':
# Obtain infos ("clues") from the PX on which this software is running
manager = NCSManager("CCS")
manager.makeCircuitDict() # Clues about PX
# Useful printing for debugging purpose
if (DEBUG and system == 'PDS'):
print
manager.printClientDict()
print
manager.printInputDirDict()
# Serialization of the clues
clues_filename = CLUES + "/" + clues_name + '.' + manager.machine
manager.archiveInfos(clues_filename)
# Sending of the clues to the CIR host
sender = Sender('CCS')
sender.send(copying, user, host, clues_filename, INPUT_CLUES)
logger.info("Ending of CCS program (system %s) on " % (system) + str(localhost))
class TextHandler(object):
sendBot = Sender()
# name
# job
def process(self, message, phoneNumber):
newMessage = ' '.join(message.split()[1:])
if message.split()[0].lower() == "name:":
TextHandler.processName(self, newMessage, phoneNumber)
elif message.split()[0].lower() == "jobs:":
TextHandler.processJobs(self, newMessage, phoneNumber)
else:
TextHandler.processDescription(self, message, phoneNumber)
# name
def processName(self, message, phoneNumber):
messageItem = Message()
messageItem.senderName = message
messageItem.senderNo = phoneNumber
# responds
TextHandler.sendBot.send(
"Hi " + messageItem.senderName + "(" + messageItem.senderNo + "). What Jobs are you interested in?", messageItem.senderNo)
return messageItem
def processJobs(self, message, phoneNumber):
messageItem = Message()
messageItem.senderNo = phoneNumber
messageItem.jobs = message.split()
# responds
TextHandler.sendBot.send(
"You are interested in: " + ', '.join(messageItem.jobs), messageItem.senderNo)
return messageItem
def processDescription(self, message, phoneNumber):
messageItem = Message()
messageItem.senderNo = phoneNumber
messageItem.description = message
# responds
TextHandler.sendBot.send(
"Your profile: " + messageItem.description, messageItem.senderNo)
return messageItem
def main(self):
command_helper = InputHelper(
["caesar", "multiplicative", "affine", "unbreakable", "rsa", "exit"]
)
try:
next_command = command_helper.get_legal_input("Please enter a command: \n")
sender = Sender()
receiver = Receiver()
hacker = Hacker()
cipher_algorithm = None
if next_command == "caesar":
cipher_algorithm = Caesar()
if next_command == "multiplicative":
cipher_algorithm = Multiplicative()
if next_command == "affine":
cipher_algorithm = Affine()
if next_command == "unbreakable":
cipher_algorithm = Unbreakable()
if next_command == "rsa":
cipher_algorithm = RSA()
hacker = None
if next_command == "exit":
sys.exit(0)
sender.set_cipher_algorithm(cipher_algorithm)
receiver.set_cipher_algorithm(cipher_algorithm)
keys = cipher_algorithm.generate_keys()
self.__logger.info(f"Keyset: {keys}")
sender.set_key(keys["encryption"])
receiver.set_key(keys["decryption"])
message = input("Please input a message to be encrypt:\n")
encrypted_text = sender.operate_cipher(message)
if hacker is not None:
hacker.set_cipher_algorithm(cipher_algorithm)
self.__logger.info(
f"Hackerman found: {hacker.hack(encrypted_text, next_command)}"
)
decrypted_text = receiver.operate_cipher(encrypted_text)
self.__logger.info(
f"{message} => {encrypted_text} => {decrypted_text} (Success={cipher_algorithm.verify(sender.get_key(), receiver.get_key(),message)})"
)
except KeyboardInterrupt:
return self.main()
def simulate(self):
self.sender = Sender(self.source_size, self.distribution)
self.receiver = Receiver(self.source_size, self.error_rate, fast_mode=self.fast_mode)
successful_decode = False
successful_send = False
while not self.receiver.decoded:
# Send a packet and attempt to decode if it is received
if not successful_decode:
successful_send = self.send_packet()
if successful_send:
successful_decode = self.decode(pckt1_sent=self.packet_len_1_sent)
self.packet_len_1_sent = False
# print(self.receiver.result_message)
# print(self.receiver.total_received)
return self.receiver.total_received
def sendReqVoteRPC(dcNum):
lastLogIndex = State.log.getLastIndex()
lastLogTerm = State.log.getLastTerm()
reqRPC = RequestVoteRPC(State.currentTerm, State.dc_ID, lastLogIndex,
lastLogTerm)
if (State.receiverList[dcNum]):
#print("Send ReqVoteRPC to: "+str(dcNum))
print("(" + str(State.dc_ID) + "," + State.state + "," +
str(State.currentTerm) + '): Send Request to datacenter ' +
str(dcNum))
sender = Sender('RequestVoteRPC', reqRPC)
sender.setConn(State.dc_list[dcNum])
sender.start()
def __init__(self, Debug=False):
self.debug = Debug
threading.Thread.__init__(self)
self.setName("GUI")
self.fenetre = Tk()
self.fenetre.title("Commande")
self.senderbox = Frame(self.fenetre)
self.senderbox.pack(side="left", expand=False, padx=5, pady=5)
self.sender = Sender(self, self.senderbox, Debug=self.debug)
self.receiverbox = Frame(self.fenetre)
self.receiverbox.pack(side="right", expand=True, fill="x", padx=5, pady=5)
self.receiver = Receiver(self.receiverbox, Debug=self.debug)
self.start()
def main():
args = get_args()
path = args.file
interval = args.interval
if not os.path.exists(path):
print('{} does not exist.'.format(path))
sys.exit(1)
# MIDIファイルからMIDIイベントを読み込む
events = MidiEvents(path)
# MIDIイベントを送信
sender = Sender()
sender.send_events(events, interval)
# 送信したMIDIイベントと送信時刻を表示
sender.show_send_events_and_times()
def send(self):
sender=Sender('TestMessage','Hello')
sender.send(('0.0.0.0',12345))
class RemoteMsg(object):
"""
_RemoteMsg_
Main interface of the RemoteMsg module. Clients wishing to use the
RemoteMsg should instantiate an object of this class and interface
it using the public methods declared by it.
"""
def __init__(self, config, addresses=[], queue=True):
"""
Constructor.
Requires a WMCore.Configuration object with configuration
information. The addresses of recipients and the flag for
queue/handling mode can be set with setAdress or setQueue methods
also (have a look at their docstring for further help). The
listener for messages needs to be started with the startListener
method, meanwhile only publication capabilities are available.
"""
self.myconfig = config
sections = self.myconfig.listSections_()
if not "RemoteMsg" in sections:
msg = "Cannot create RemoteMsg object without "
msg += "RemoteMsg section in config file"
raise Exception(msg)
self.mylogger = None
self.logMsg = None
self.__setLogging__()
self.mylogger.info("\n\n>>>>>RemoteMsg object being created <<<<<<\n")
self.myComp = None
if hasattr(self.myconfig.RemoteMsg, "inComponent"):
self.myComp = self.myconfig.RemoteMsg.inComponent
self.queueMode = queue
self.addresses = addresses
self.user = None
self.passwd = None
self.msgLock = threading.Lock()
self.handlerLock = threading.Lock()
self.factory = WMFactory("RemoteMsg")
# If this is instantiated by a WMCore component, get its DB interface
if self.myComp:
# Get a reference to our invoking component's DB factory
myThread = threading.currentThread()
self.dbFactory = myThread.dbFactory
self.dialect = myThread.dialect
# TODO: Our msg queue is just in memo for now, but it might be in a DB
# We already have the DB interface, but we would need our own Create
# and Queries modules (in principle, different from those of the comp)
# self.factory = WMFactory("threadPool", "WMCore.ThreadPool."+ \
# myThread.dialect)
# self.queries = factory.loadObject(self.myComp+"Database"+ \
# myThread.dialect+"Queries")
self.msgQueue = []
self.handlerMap = {}
# Formatter for responses (change only if in synchronous mode)
formatter = "RemoteMsgComp.DefaultFormatter"
if hasattr(self.myconfig.RemoteMsg, "formatter"):
formatter = self.myconfig.RemoteMsg.formatter
formatterObj = self.factory.loadObject(formatter)
params = {
"msgQueue": self.msgQueue,
"handlerMap": self.handlerMap,
"msgLock": self.msgLock,
"formatter": formatterObj,
"queueMode": self.queueMode,
}
if self.myComp:
params["component"] = self.myComp
params["dbFactory"] = self.dbFactory
params["dialect"] = self.dialect
self.httpTree = HttpTree(params)
self.sender = None
self.__createSender__()
self.listener = None
def __del__(self):
# Tell cherrypy to die
self.mylogger.info("Asking listener to die")
if self.listener:
self.listener.terminate()
self.listener.join()
def __setLogging__(self):
"""
Initializes logging. Use by the constructor.
"""
compSect = self.myconfig.RemoteMsg
# Logging
if not hasattr(compSect, "logFile"):
compSect.logFile = os.path.join(compSect.RemoteMsgDir, "remoteMsg.log")
print("Log file is: " + compSect.logFile)
if not hasattr(compSect, "listenerLogFile"):
compSect.listenerLogFile = os.path.join(compSect.RemoteMsgDir, "listener.log")
print("Listener log file is: " + compSect.listenerLogFile)
logHandler = RotatingFileHandler(compSect.logFile, "a", 1000000, 3)
logFormatter = logging.Formatter("%(asctime)s:%(levelname)s:%(filename)s:%(message)s")
logHandler.setFormatter(logFormatter)
self.mylogger = logging.getLogger("RemoteMsg")
self.mylogger.addHandler(logHandler)
self.mylogger.setLevel(logging.INFO)
# map log strings to integer levels:
self.logMsg = {
"DEBUG": logging.DEBUG,
"ERROR": logging.ERROR,
"NOTSET": logging.NOTSET,
"CRITICAL": logging.CRITICAL,
"WARNING": logging.WARNING,
"INFO": logging.INFO,
}
## 'SQLDEBUG' : logging.SQLDEBUG }
if hasattr(compSect, "logLevel") and compSect.logLevel in self.logMsg.keys():
self.mylogger.setLevel(self.logMsg[compSect.logLevel])
def __createSender__(self):
"""
Initializes the sender object. Used by the constructor.
"""
# Sender is not a new thread, so it does not need a lock
params = {}
params["addresses"] = self.addresses
params["port"] = "8030"
if hasattr(self.myconfig.RemoteMsg, "senderPort"):
params["port"] = self.myconfig.RemoteMsg.senderPort
params["service"] = "msg"
if hasattr(self.myconfig.RemoteMsg, "senderService"):
params["service"] = self.myconfig.RemoteMsg.senderService
params["user"] = None
if hasattr(self.myconfig.RemoteMsg, "senderUser"):
params["user"] = self.myconfig.RemoteMsg.senderUser
params["pwd"] = None
if hasattr(self.myconfig.RemoteMsg, "senderPwd"):
params["pwd"] = self.myconfig.RemoteMsg.senderPwd
params["realm"] = "RemoteMsg"
if hasattr(self.myconfig.RemoteMsg, "realm"):
params["realm"] = self.myconfig.RemoteMsg.senderRealm
self.sender = Sender(self.msgQueue, params)
def startListener(self):
"""
Starts a listener for incoming remote messages. The method will refuse
to create a listener if there is already one
"""
if not self.listener:
self.mylogger.info("Starting listener")
self.listener = Listener(self.httpTree, self.myconfig)
self.listener.start()
else:
msg = "Refusing to start listener (there is already one)."
self.mylogger.info(msg)
def setAddress(self, addresses):
"""
Sets the addresses of the remote ends. Argument should be a list of
IPs or hostnames. The publish method will send messages to all members
of this list.
"""
self.addresses = addresses
self.sender.setAddress(self.addresses)
def setAuthentication(self, user, passwd):
"""
Sets the user/password for authentication
with the remote application. Has to be done
before sending a message.
"""
self.mylogger.debug("Setting user and passwd")
self.user = user
self.passwd = passwd
def setQueue(self, value):
"""
This is an option that either allows messages that are being received
to be put in a local queue (so a get method can retrieve them), or if
set to False messages are handled directly through the handler framework.
"""
self.queueMode = value
self.httpTree.setQueue(self.queueMode)
def get(self):
"""
Gets messages from the local buffer (those not handled as explained
in the setQueue method).
The first message of the queue is retrieved and returned. This method
is only used when the queue is set to True. If queue is set to False
or there are no stored messages, None is returned.
"""
if self.queueMode:
self.msgLock.acquire()
if self.msgQueue:
result = self.msgQueue.pop(0)
else:
result = None
self.msgLock.release()
return result
else:
return None
def publish(self, msgType, payload, sync=False):
"""
Sends a message to the remote end.
If sync is set to True, the remote server will complete the message
handling before replying with some generated data. Otherwise, the
remote end will immediately reply with some "Message received"
indication and execute the handler asynchronously (if the remote end
is in queue mode, there is no handler execution, so this flag is
meaningless).
In any case, the response of the message (e.g. a json string product
of the handling of the HTTP request) is returned.
Can throw an HTTP exception in case of error connecting with the remote
end.
"""
return self.sender.send(msgType, payload, sync)
def setHandler(self, msgType, handler):
"""
Maps the specified handler to the indicated message type.
The handler must be the name of a class which can be called (e.g.
RemoteMsg.SimpleHandler). The handler will only be called if
queue mode is set to False.
"""
msg = "Setting new handler %s for msgType %s" % (handler, msgType)
self.mylogger.debug(msg)
# Factory to dynamically load handlers
params = {}
if self.myComp:
params["component"] = self.myComp
newHandler = self.factory.loadObject(handler, params)
self.handlerLock.acquire()
self.handlerMap[msgType] = newHandler
self.handlerLock.release()
results_filename = RESULTS + "/" + results_name
merger.archiveResults(results_filename)
logger.debug("Results have been put by CIR in: " + results_filename)
# Creation of log files that will contain errors that will be displayed by CS
# and also of errors logs that will be used by Wams
if system == 'PDS':
merger.logPDSErrors()
elif system == 'PX':
merger.auditCircuit(errorLogger, errorLog, wamsLogFile) # Checks for error and log them
#############################################################################################
# 3) Send the merged infos to ColumboShow Host (as defined in the config. file)
#############################################################################################
sender = Sender('CIR') # log to 'CIR' logger
sender.send(copying, user, host, results_filename, INPUT_RESULTS)
logger.info("Ending of CIR program (system %s)" % system)
logger.info("")
#logger.removeHandler(hdlr)
#############################################################################################
# 4) Special section for PX: Do the jobs of step 2 and 3 for the frontend
#############################################################################################
if system == 'PX' and frontend:
machines = [frontend.split(".")[0]] # Only the frontend
merger = CircuitMerger(logger, machines)
def __init__(self):
self.sender = Sender()
self.listener = Listener(event_handler=self)
self.peers = []
#############################################################################################
# 1) Obtain infos (listing) concerning a running PDS
#############################################################################################
clientDir = DirectoryLister(pathname, startDate, endDate, regex, maxFiles)
logger.info("Listing: " + clientName + ", " + startDate + ", " + endDate + ", " + regex)
myDict = clientDir.getNameTimeDict()
manager = Manager("CCS")
archiveName = CLUES + '/' + clientName + "_listing." + manager.machine
clientDir.archiveInfos(archiveName)
#############################################################################################
# 2) Send the infos (listing) to CIR Host
#############################################################################################
sender = Sender('CCS')
sender.send(copying, user, host, archiveName, INPUT_CLUES)
logger.info("Ending of DirectoryLister program on " + str(localhost))
if DEBUG:
for file in myDict.keys():
print "%30s : %d %s " % (file, myDict[file][0], myDict[file][1])
print pathname
print clientDir.startDate, epochFormatted(clientDir.startDate)
print clientDir.endDate, epochFormatted(clientDir.endDate)
print regex
print clientDir.maxFiles
def __init__(s):
#Dane:
Sender.__init__(s)
s.__dominator=None
s.__saveString=""
s.__noteF=NoteFactory()
