class TrafficManager(threading.Thread):
def __init__(self, iface='eth1', filter="dst='192.168.137.0'", rx_port=50000, tx_port = 50001):
super().__init__()
self.log = logging.getLogger(self.__class__.__name__)
self.iface = iface
self.filter = filter
self.rx_port = rx_port
self.tx_port = tx_port
self._stopRun = False
self._is_running = False
self.transmitter = None
self.receiver = None
def start(self):
self._is_running = True
self.create_receiver()
self.create_transmiter()
def stop(self):
_stopRun = True
if self.transmitter is not None:
self.transmitter.stop()
self.transmitter = None
if self.receiver is not None:
self.receiver.stop()
self.receiver = None
self._is_running = False
def create_receiver(self):
self.receiver = Receiver(self.iface, self.filter, self.rx_port)
self.receiver.start()
def create_transmiter(self):
self.transmitter = Transmitter(self.iface, self.filter, self.tx_port)
self.transmitter.start()
def listen(ctx, verbose, home_id):
"""
Passive monitoring of network
:param ctx: shared context
:param verbose: show received frames
:param home_id: filter frames including specified home-id
"""
# initialize
signal.signal(signal.SIGINT, signal_handler)
cfg = ctx.obj[CONFIGURATION]
cfg.home_id = home_id
cfg.verbose = verbose
honeylog = ctx.obj[LOGGER]
with multiprocessing.Manager() as manager:
# initialize shared network and decoy information
network = manager.dict(load_json(cfg.networks_path + '/' + cfg.network_file))
decoys = manager.dict(load_json(cfg.networks_path + '/' + cfg.decoys_file))
# init stats
inner_stats = init_stats_dict()
stats_real = manager.dict(inner_stats.copy())
stats_malicious = manager.dict(inner_stats.copy())
stats_invalid = manager.dict(inner_stats.copy())
stats_in = manager.dict(inner_stats.copy())
stats_out = manager.dict(inner_stats.copy())
stats = {STAT_REAL: stats_real,
STAT_MALICIOUS: stats_malicious,
STAT_INVALID: stats_invalid,
STAT_IN: stats_in,
STAT_OUT: stats_out}
frames_in = list()
frames_out = list()
# initialize components
receiver = Receiver(cfg, network, decoys, honeylog, frames_in, frames_out)
monitor = Monitor(cfg, network, decoys, honeylog, stats)
receiver.monitor = monitor
monitor.receiver = receiver
# start configuration
configuration_process = Process(target=set_configuration, args=(cfg, honeylog))
configuration_process.start()
# if not verbose
if not verbose:
# show only stats
statsview_process = Process(target=stats_view, args=(stats, ctx.obj[DEBUG_LEVEL]))
statsview_process.start()
# start reception
receiver.start(False, True)
def record(ctx):
"""
Maps real network, record its communication, anonymize it.
Records are saved into pcap files. Network and decoy information are saved into json files.
:param ctx: shared context
"""
cfg = ctx.obj[CONFIGURATION]
honeylog = ctx.obj[LOGGER]
network = load_json(cfg.networks_path + '/' + cfg.network_file)
decoys = load_json(cfg.networks_path + '/' + cfg.decoys_file)
receiver = Receiver(cfg, network, decoys, honeylog, None, None)
receiver.start(recording=True)
from Image import Image
from Manager import Manager
def str2bool(v):
return v.lower() in ("true", "t")
if __name__ == '__main__':
receiver = Receiver(sys.argv[1], sys.argv[2]) # 이미지 수신 객체 ip, port
image = Image() # 이미지 처리 & 커맨드에 들어갈 요소 생성 객체
commender = Commender() # 커맨드 생성 & 전송 객체
model = Model() # tensorflow 모델 객체
sms = Manager('id', 'pw', '송신자 번호') # sms 송신 관련 객체
receiver.start() # 서버 시작
mlOption = False
timeSize = 19 # log 이름에 사용될 길이
logdate = str(datetime.now())[:timeSize] # yyyy-mm-dd hh:mm:ss
datcation = "./data/" # data 폴더 위치
logcation = datcation + "log/" # log 폴더 위치
imgcation = datcation + "img/" + logdate + "/" # 이미지 저장할 폴더 위치
if not os.path.isdir(datcation):
os.mkdir(datcation)
if not os.path.isdir(logcation):
os.mkdir(logcation)
class GUI(QWidget):
def __init__(self):
super().__init__()
# IPFS api
try:
self.api = ipfsapi.connect("127.0.0.1", 5001)
except:
QMessageBox.information(self, "Error", "Launch daemon first.",
QMessageBox.Ok, QMessageBox.Ok)
self.close()
# operation on friend list
self.ADD_MODE = 0
self.DELETE_MODE = 1
# log in frame
log = Mainframe()
self.user = ""
self.channel = ""
self.loginSuccess = False
log.signal.connect(self.getLoginStatus)
log.user.connect(self.getUserName)
log.channel.connect(self.getChannel)
log.exec_()
# add friend frame
self.friendChange = False
self.friendList = QTextEdit(self)
# chatting
self.channelText = QLineEdit(self)
self.typeText = QTextEdit(self)
self.showText = QTextEdit(self)
if (self.loginSuccess):
self.receiver = Receiver(self)
self.receiver.daemon = True
self.receiver.start()
self.initUI()
else:
self.close()
def checkHistoryLog(self):
if (not os.path.exists("history.json")):
with open("history.json", 'w', encoding="utf-8") as f:
json.dump({}, f)
def closeEvent(self, event):
self.checkHistoryLog()
history = None
historyLog = self.showText.toPlainText().split('\n')
with open("history.json", 'r', encoding="utf-8") as f:
history = json.load(f)
history[self.channel] = history.get(self.channel, []) + historyLog
with open("history.json", 'w', encoding="utf-8") as f:
json.dump(history, f)
def getChannel(self, channel):
self.channel = channel if (channel) else "IPFS"
def getUserName(self, name):
self.user = name
def getLoginStatus(self, status):
self.loginSuccess = bool(status)
def getAddFriendStatus(self, status):
self.friendChange = bool(status)
def loadImage(self, image):
if (image):
imageLoader = ImageLoader(image)
imageLoader.exec_()
def addFriend(self):
addFriendDialog = FriendDialog(self.api, self.ADD_MODE)
addFriendDialog.signal.connect(self.getAddFriendStatus)
addFriendDialog.exec_()
if (self.friendChange):
self.changeFriendList()
def deleteFriend(self):
deleteFriendDialog = FriendDialog(self.api, self.DELETE_MODE)
deleteFriendDialog.signal.connect(self.getAddFriendStatus)
deleteFriendDialog.exec_()
if (self.friendChange):
self.changeFriendList()
def clearFriend(self):
reply = QMessageBox.information(
self, "Warning",
"Are you sure you want to clear your friend list?",
QMessageBox.Yes, QMessageBox.No)
if (reply == QMessageBox.Yes):
self.api.bootstrap_rm(self.api.bootstrap_list()["Peers"])
QMessageBox.information(self, "Success", "Clear peer success.",
QMessageBox.Ok, QMessageBox.Ok)
self.changeFriendList()
def changeFriendList(self):
self.friendList.clear()
addrList = [
addr.split('/')[-1] for addr in self.api.bootstrap_list()["Peers"]
]
self.friendList.setText("\n\n".join(addrList))
self.friendChange = False
def viewHistory(self):
historyDialog = ViewHistory(self.channel)
historyDialog.exec_()
def sendImage(self):
fileType = "Bmp(*.bmp);;Jpg(*.jpg);;Jpeg(*.jpeg);;Png(*.png);;Gif(*.gif);;Icon(*.icon)"
directory = QFileDialog.getOpenFileName(self, "Select image", "./",
fileType)[0]
ret = self.api.add(directory)
content = {}
content["Type"] = "Image"
content["Hash"] = ret["Hash"]
content["Name"] = ret["Name"]
self.sendMessage(content["Type"] + '--' + content["Name"] + '--' +
content["Hash"])
def sendText(self):
fileType = "Txt(*.txt);;Docx(*.docx);;Excel(*.xlsx)"
directory = QFileDialog.getOpenFileName(self, "Select image", "./",
fileType)[0]
ret = self.api.add(directory)
content = {}
content["Type"] = "Text"
content["Hash"] = ret["Hash"]
content["Name"] = ret["Name"]
self.sendMessage(content["Type"] + '--' + content["Name"] + '--' +
content["Hash"])
def sendFile(self):
fileType = "Zip(*.zip);;Rar(*.rar);;7z(*.7z)"
directory = QFileDialog.getOpenFileName(self, "Select file", "./",
fileType)[0]
ret = self.api.add(directory)
content = {}
content["Type"] = "File"
content["Hash"] = ret["Hash"]
content["Name"] = ret["Name"]
self.sendMessage(content["Type"] + "--" + content["Name"] + "--" +
content["Hash"])
def sendMessage(self, content=""):
if (not content):
content = self.typeText.toPlainText()
if (not content):
QMessageBox.information(self, "Error",
"Content must not be empty.",
QMessageBox.Ok, QMessageBox.Ok)
return
content = "Message--" + content
self.api.pubsub_pub(self.channel, self.user + ':' + content)
self.typeText.clear()
def initUI(self):
# set window
self.setFixedSize(QSize(1000, 640))
# width, height
self.setWindowTitle("IPFS Communication Program")
self.setWindowIcon(QIcon("IPFS.png"))
# set background image
self.setWindowOpacity(1)
palette = QPalette()
palette.setBrush(self.backgroundRole(),
QBrush(QPixmap("IPFS_bg2.jpg")))
self.setPalette(palette)
# friend list
friLabel = QLabel(self)
friLabel.move(10, 0)
friLabel.resize(180, 30)
friLabel.setText("Friend list")
friLabel.setStyleSheet("color:#ffffff;border :3px ;font-weight:bold;")
self.friendList.move(10, 30)
self.friendList.resize(360, 550)
self.friendList.setEnabled(False)
self.friendList.setStyleSheet(
"color:#000000;border :1px ;background-color:rgba(250,250,250,0.7)"
)
addrList = [
addr.split('/')[-1] for addr in self.api.bootstrap_list()["Peers"]
]
self.friendList.setText("\n\n".join(addrList))
addBtn = QPushButton(self)
addBtn.setIcon(QIcon("friend.icon"))
addBtn.setToolTip("Add friend")
addBtn.move(10, 590)
addBtn.resize(40, 40)
addBtn.clicked.connect(self.addFriend)
deleteBtn = QPushButton(self)
deleteBtn.setIcon(QIcon("unfriend.icon"))
deleteBtn.setToolTip("Delete friend")
deleteBtn.move(70, 590)
deleteBtn.resize(40, 40)
deleteBtn.clicked.connect(self.deleteFriend)
clearBtn = QPushButton(self)
clearBtn.setIcon(QIcon("clear.icon"))
clearBtn.setToolTip("Clear friend list")
clearBtn.move(130, 590)
clearBtn.resize(40, 40)
clearBtn.clicked.connect(self.clearFriend)
# slogan
memorial1 = QLabel(self)
memorial1.move(180, 575)
memorial1.resize(235, 40)
memorial1.setText("Prophecy is uncertain,")
memorial1.setStyleSheet("color:#ffffff;border :3px ;font-weight:bold;")
memorial2 = QLabel(self)
memorial2.move(200, 600)
memorial2.resize(215, 40)
memorial2.setText("There is always hope.")
memorial2.setStyleSheet("color:#ffffff;border :3px ;font-weight:bold;")
# chatting
# channel selection
channelLabel = QLabel(self)
channelLabel.move(400, 0)
channelLabel.resize(60, 30)
channelLabel.setText("Channel")
channelLabel.setStyleSheet(
"color:#ffffff;border :3px ;font-weight:bold;")
self.channelText.move(500, 0)
self.channelText.resize(280, 30)
self.channelText.setText(self.channel)
self.channelText.setEnabled(False)
self.channelText.setStyleSheet(
"color:#000000;border :1px ;background-color:rgba(250,250,250,0.7)"
)
# chatting content
self.showText.move(400, 40)
self.showText.resize(580, 400)
self.showText.setStyleSheet(
"color:#000000;border :1px ;font-size:20px;background-color:rgba(250,250,250,0.7)"
)
# view history
historyBtn = QPushButton(self)
historyBtn.setIcon(QIcon("history.icon"))
historyBtn.setToolTip("View history")
historyBtn.move(580, 450)
historyBtn.resize(40, 40)
historyBtn.clicked.connect(self.viewHistory)
# typing content
self.typeText.move(400, 500)
self.typeText.resize(580, 130)
self.typeText.setStyleSheet(
"color:#000000;border :1px ;font-size:20px;background-color:rgba(250,250,250,0.7)"
)
sendBtn = QPushButton(self)
sendBtn.setIcon(QIcon("send.icon"))
sendBtn.setToolTip("Send message")
sendBtn.move(940, 450)
sendBtn.resize(40, 40)
sendBtn.clicked.connect(self.sendMessage)
# file transmission
imgBtn = QPushButton(self)
imgBtn.setIcon(QIcon("image.icon"))
imgBtn.setToolTip("Send image")
imgBtn.move(400, 450)
imgBtn.resize(40, 40)
imgBtn.clicked.connect(self.sendImage)
txtBtn = QPushButton(self)
txtBtn.setIcon(QIcon("txt.icon"))
txtBtn.setToolTip("Send txt")
txtBtn.move(460, 450)
txtBtn.resize(40, 40)
txtBtn.clicked.connect(self.sendText)
fileBtn = QPushButton(self)
fileBtn.setIcon(QIcon("file.icon"))
fileBtn.setToolTip("Send file")
fileBtn.move(520, 450)
fileBtn.resize(40, 40)
fileBtn.clicked.connect(self.sendFile)
# show window
self.show()
except:
sys.stderr.write('Invalid value of reg-port\n')
exit(invalid_arguments)
try:
chatPort = int(settings['chat-port'][0])
except:
sys.stderr.write('Invalid value of chat-port\n')
exit(invalid_arguments)
# prijem zprav a odesilani odpovedi
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sendLock = Lock()
inLonck = Lock()
sender = Sender(sock, sendLock)
receiver = Receiver(chatIp, chatPort, False, sender, settings['username'][0])
if (not receiver.start(sock)):
sys.stderr.write('Unable to start peer at adress ' + chatIp +
' and port ' + str(chatPort) + '\n')
exit(invalid_arguments)
# udrzeni spojeni s uzlem
keeper = ConnectionKeeper()
keeper.hello(sender, settings['username'][0], chatIp, chatPort, regIp, regPort)
# nacitani prikazu od rpc a uzivatele
filename = '.' + settings['id'][0] + '.peercommands'
reader = InputReader(filename, settings['username'][0])
def thisIsTheEnd(_, __):
keeper.stop()
#!/usr/bin/env python3
import socket
from time import sleep
from Receiver import Receiver
from Sender import Sender
from threading import Lock
sock = socket.socket( socket.AF_INET, socket.SOCK_DGRAM )
lock = Lock()
s = Sender( sock, lock )
receiver = Receiver( False, s )
receiver.start( sock, '0.0.0.0', 8888 )
while True:
sleep( 3600 )
class Manager:
#método construtor
def __init__(self):
#lista de conectados
self.connected = []
#lista de nomes conectados
self.names_connected = []
#instancia um cliente
self.client = Client()
#threads
#envio
self.ts = None
#recebimento multicast
self.tr = None
#recebimento privado
self.trp = None
#listener para entrada do teclado
self.tl = None
#flag de controle para que não seja enviado mais que uma mensagem (type 3)
self.is_first_message = True
#função que inicializa a threads
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()
#fecha a conexão com os sockets
def stop_threads(self):
self.ts.close()
self.tr.close()
self.trp.close()
#adiciona um usuário na lista de conectados
def add_user(self, client):
self.connected.append(client)
self.names_connected.append(client.nick)
#remove um usuário da lista de conectados
def pop_user(self, client):
if (client in self.connected):
self.connected.remove(client)
self.names_connected.remove(client.nick)
print("------------------------------")
print(client.nick, "saiu do chat")
print("------------------------------")
#imprime a lista de conectados
def show_connected(self):
print("------------------------------")
print("Lista de Conectados:")
for person in self.connected:
print(person.nick)
print("------------------------------")
#Filtra a mensagem de entrada em usuário e mensagem a ser enviada
def filter_msg(self, data, ch=" "):
cli = None
index = [i for i, ltr in enumerate(data) if ltr == ch]
name = data[index[0] + 1:index[1]]
for person in self.connected:
if person.nick == name:
cli = person
msg = data[index[1] + 1:]
return cli, msg
#define um objeto de mensagem para fazer o envio
def set_msg(self, data):
msg = None
if (len(data) == 1):
if "TO" in data[0]:
dst_cli, text = self.filter_msg(data[0])
msg = Message(4, self.client, len(text), text,
dst_cli.pvt_addr)
if (dst_cli == self.client):
print(msg.message)
elif "COMMANDS" in data[0]:
self.show_commands()
elif "SHOW_ALL" in data[0]:
self.show_connected()
elif "LEAVE" in data[0]:
msg = Message(5, self.client, len(""), "")
else:
text = data[0]
msg = Message(3, self.client, len(text), text)
else:
msg = Message(data[0], data[1], data[2], data[3])
return msg
#imprime mensagem privada
def print_pvt(self, msg):
print("------------------------------")
print("Mensagem privada de " + msg.source.nick + ": " + msg.message)
print("------------------------------")
#gerencia a mensagem
def manage_msg(self, msg):
#verifica se a mensagem é do tipo join
if (msg.type == 1):
#caso o join recebido seja do cliente
if (msg.source.nick == self.client.nick):
#se o cliente não está na lista de conectados
if (self.client.nick not in self.names_connected):
#cria o pacote a partir da mensagem
pckg = msg.get_package()
#dá o join no cliente
self.join(pckg)
#caso o join recebido não seja do cliente
else:
#adiciona a fonte da mensagem na lista de conectados
self.add_user(msg.source)
print("------------------------------")
print(msg.source.nick, "entrou no chat.")
print("------------------------------")
#envia um join_ack
self.join_ack()
#se o join_ack não for do cliente
elif (msg.type == 2 and msg.source.nick != self.client.nick):
#se a fonte do join_ack não está na lista de conectados
if (msg.source.nick not in self.names_connected):
self.add_user(msg.source)
#se a mensagem nao foi enviada por esse cliente
elif (msg.type == 3 and msg.source.nick != self.client.nick):
self.receive_message(msg)
#se a mensagem foi enviada por esse cliente
elif (msg.type == 3 and msg.source.nick == self.client.nick):
if (self.is_first_message):
self.is_first_message = False
pckg = msg.get_package()
self.ts.send(pckg)
else:
self.is_first_message = True
#caso a mensagem for privada mas é de outra fonte
elif (msg.type == 4 and msg.source.nick != self.client.nick):
self.print_pvt(msg)
#caso a mensagem seja privada e seja do mesmo cliente
elif (msg.type == 4 and msg.source.nick == self.client.nick):
pckg = msg.get_package()
self.ts.send_pvt(pckg, msg.dest)
#remove o cliente que saiu da lista
elif (msg.type == 5 and msg.source.nick != self.client.nick):
self.pop_user(msg.source)
#finaliza a conexão do cliente
elif (msg.type == 5 and msg.source.nick == self.client.nick):
pckg = msg.get_package()
self.ts.send(pckg)
self.ts.stop = True
print("------------------------------")
print("Conexão encerrada.")
print("------------------------------")
self.stop_threads()
os._exit(0)
#imprime os comandos do chat na tela
def show_commands(self):
print("------------------------------")
print("Lista de comandos:")
print(
"TO nomedousuario mensagem : Comando para enviar mensagens privadas."
)
print("SHOW_ALL : Mostra o nome de todos usuários conectados.")
print("LEAVE : Sai do chat")
print("------------------------------")
#realiza o join
def join(self, pckg):
#envia o pacote para todos os clientes
self.ts.send(pckg)
#adiciona o cliente na lista de conectados
self.add_user(self.client)
print("Olá " + self.client.nick + " você foi conectado")
print("Digite COMMANDS para ver os comandos")
print("------------------------------")
#realiza o join_ack
def join_ack(self):
#cria a mensagem a partir de uma lista
msg = self.set_msg([2, self.client, 0, ""])
#recebe o valor da mensagem em um pacote de bytes
pckg = msg.get_package()
#envia o pacote
self.ts.send(pckg)
def receive_message(self, msg):
print(msg.source.nick + " disse a todos: " + msg.message)
#conecta o cliente
def connect(self):
#cria a mensagem a partir de uma lista
msg = self.set_msg([1, self.client, 0, ""])
#define o que fazer com a mensagem
self.manage_msg(msg)
