// Reducer
const SET_PARAMETER_COUNTRY_LIST = 'SET_PARAMETER_COUNTRY_LIST'
const SET_PARAMETER_POSITION_LIST = 'SET_PARAMETER_POSITION_LIST'
const SET_PARAMETER_NEWS_AGENCY_LIST = 'SET_PARAMETER_NEWS_AGENCY_LIST'
const defaultState = {
parameterCountry: [],
parameterPosition: [],
parameterNewsAgency: [],
}
export default function searchFaceReducer(state = defaultState, action) {
switch (action.type) {
case SET_PARAMETER_COUNTRY_LIST:
return {
...state,
parameterCountry: action.payload,
}
case SET_PARAMETER_POSITION_LIST:
return {
...state,
parameterPosition: action.payload,
}
case SET_PARAMETER_NEWS_AGENCY_LIST:
return {
...state,
parameterNewsAgency: action.payload,
}
default:
return state
}
}
export const setParameterCountryList = (parameterCountry) => ({type: SET_PARAMETER_COUNTRY_LIST, payload: parameterCountry})
export const setParameterPositionList = (parameterPosition) => ({type: SET_PARAMETER_POSITION_LIST, payload: parameterPosition})
export const setParameterNewsAgencyList = (parameterNewsAgency) => ({type: SET_PARAMETER_NEWS_AGENCY_LIST, payload: parameterNewsAgency})
//было
export const setParameterList = (parameter) => ({type: SET_PARAMETER_LIST, payload: parameter}) import React, { useState } from 'react';
import { useDispatch } from 'react-redux';
// ответ от БД
const sizelist = [1,2,3,4,5,6,7]
const SET_SIZE_LIST ="SET_SIZE_LIST"
const defaultState = {
items: [],
sizeList: [],
};
const setSizeList = (sizelist) => ({type: SET_SIZE_LIST, payload: sizelist})
function sizediskReducer(state = defaultState, action) {
console.log(action.type)
switch (action.type) {
case SET_SIZE_LIST:
const size=3;
return {
...state,
sizeList: [...state.sizeList, size],
}
default:
return state
}
};
function updSizeList () {
useDispatch(setSizeList());
};
const Dropdown = ({ text, children }) => {
const [isOpen, setIsOpen] = useState(false);
const toggleOpen = () => setIsOpen((isOpen) => !isOpen);
return (
<div>
<button
className={isOpen ? 'dropdown-btn-close' : 'dropdown-btn-active'}
onClick={toggleOpen}
>
{text}
<span className="fa-caret-down">▼</span>
</button>
{isOpen && <div>{children}</div>}
</div>
);
};
const App = () => (
<>
<Dropdown text="Drop 1">
<div >
<input id="1" type="checkbox" onChange={updSizeList}/>
<label htmlFor="1" >1</label>
</div>
</Dropdown>
<Dropdown text="Drop 2">
<div>
<label>
Item 4
<input type="checkbox" />
</label>
</div>
<div>
<label>
Item 5
<input type="checkbox" />
</label>
</div>
<div>
<label>
Item 6
<input type="checkbox" />
</label>
</div>
</Dropdown>
</>
);
export default App; # Все модели дисков с сортировкой по брендам
class CatalogDiskBrandsViewSet(viewsets.ReadOnlyModelViewSet):
def get_queryset(self):
parameterBrand = self.request.query_params.get('brand')
queryset = CatalogDisks.objects.all().filter(brand=parameterBrand)
return queryset
serializer_class = CatalogDisksSerializer
pagination_class = PaginationDisks
def get_serializer_class(self):
return CatalogDisksSerializer for i in range(3):
widget = Entry(frame) class MyTableRow(Frame):
def __init__(self, master, *args, **kwargs):
super().__init__(master, *args, **kwargs)
self.widgets = []
self.frames=[]
for i in range(3):
widget = Entry(frame)
widget.pack(side="left")
self.widgets.append(widget)
self.update_btn = Button(self, text="Добавить", command=self.update_clicked)
self.update_btn.pack(side="right")
self.delete_btn = Button(self, text="Удалить", command=self.delete_clicked)
self.delete_btn.pack(side="right")
def update_clicked(self):
print(self.widgets[0].get())
def delete_clicked(self):
print("whatever")
def test_dinamic():
global widgets
global frames
doth=tix.Tk()
frames = []
widgets = []
for i in range(2):
frame = MyTableRow(doth, borderwidth=2, relief="groove")
frames.append(frame)
frame.pack(side="top", fill="x") buttonFrame_update=Button(frame,text="Добавить", command=lambda arg=i: update_main_db(arg))
buttonFrame_update.pack(side="right")
def update_main_db(arg):
global widgets
print(widgets[arg].get()) for id in list_id:
table_id= str(id)
table_ip_src= "SELECT ip_src FROM session WHERE id=" + str(id)
result_ip_src=dbb.select_singl(table_ip_src)
table_ip_dst= "SELECT ip_dst FROM session WHERE id=" + str(id)
result_ip_dst=dbb.select_singl(table_ip_dst)
table_sport="SELECT sport FROM session WHERE id=" + str(id)
result_sport=dbb.select_singl(table_sport)
table_dport="SELECT dport FROM session WHERE id=" + str(id)
result_dport=dbb.select_singl(table_dport)
tree.insert("", END,text=id, values=(table_id, result_ip_src, result_ip_dst, result_sport, result_dport))
table_id=""
result_ip_src=""
result_ip_dst=""
result_sport=""
result_dport=""
# отключение бд
db.close()
txt_log.insert(INSERT, "Соединение с SQLite закрыто\n")
def on_select(event,db):
#print(tree.selection())
# Если привязывались не к событию <<TreeviewSelect>>,
# то тут нужно проверить, что вообще что-то выбрано:
if not tree.selection():
return
# Получаем id первого выделенного элемента
selected_item = tree.selection()[0]
# Получаем значения в выделенной строке
values = tree.item(selected_item, option="values")
print(db.db_name)
print(values[0])
# ГРАФИКА
window = Tk()
# Окно
window.geometry('1015x600')
window.title("SniffPcap")
# Кнопки
# Меню (Основное)
menu = Menu(window)
window.config(menu=menu)
new_item = Menu(menu, tearoff=0)
new_item.add_command(label='Авторы')
new_item.add_separator()
new_item.add_command(label='О программе')
menu.add_cascade(label='Файл', menu=new_item)
# Меню 2(база данных)
database_item = Menu(menu, tearoff=0)
database_item.add_command(label='Создать БД', command=database)
database_item.add_separator()
database_item.add_command(label='Открыть БД', command=connect(db))
database_item.add_separator()
database_item.add_command(label='Загрузить данные в БД', command=download(db))
menu.add_cascade(label='База данных', menu=database_item)
#Таблица бд
tree = Treeview(window, columns=("ID","id", "ip_src","ip_dst","sport"),height=7, selectmode='browse')
tree.heading('#0', text='ID')
tree.heading('#1', text='id')
tree.heading('#2', text='ip_src')
tree.heading('#3', text='ip_dst')
tree.heading('#4', text='sport')
tree.heading('#5', text='dport')
tree.column('#0', stretch=YES,anchor=N)
tree.column('#1', stretch=YES,anchor=N)
tree.column('#2', stretch=YES,anchor=N)
tree.column('#3', stretch=YES,anchor=N)
tree.column('#4', stretch=YES,anchor=N)
tree.column('#5', stretch=YES,anchor=N)
tree.column('#0', width=50)
tree.column('#1', width=50)
tree.column('#2', width=110)
tree.column('#3', width=110)
tree.column('#4', width=50)
tree.column('#5', width=50)
tree['show'] = 'headings'
tree.grid(row=2, columnspan=7, sticky="N")
tree.bind('<<TreeviewSelect>>', on_select)
# Поле ввода
txt_in = scrolledtext.ScrolledText(window, width=60, height=15)
txt_out = scrolledtext.ScrolledText(window, width=60, height=15)
txt_log = scrolledtext.ScrolledText(window, width=75, height=10)
txt_in.place(x=5, y=5)
txt_out.place(x=510, y=5)
txt_log.place(x=5, y=260)
tree.place(x=635,y=260)
window.mainloop() from tkinter import *
from scapy.all import *
from tkinter import scrolledtext
from tkinter import filedialog
from tkinter.ttk import Treeview
from scapy.utils import RawPcapReader
from base import Base as db
import dpkt
import sys
import sqlite3
import os
def clicked():
window.quit()
IPList = list()
IPList_and_port = list()
output_IPList = list()
List_IP = list()
one_session = list()
list_ip_for_sessions = list()
list_tcp = list()
list_for_bd = list()
requests = list()
responses = list()
list_id=list()
def database():
window_database = Tk()
window_database.title("Создание базы данных")
window_database.geometry('250x250')
lbl = Label(window_database, text="Введите имя базы данных:")
lbl.place(x=55, y=60)
txt = Entry(window_database, width=29)
txt.place(x=40, y=90)
btn_db = Button(window_database, text="Создать", command=clicked)
btn_db.place(x=100, y=120)
window_database.mainloop()
txt_database_name = txt.get()
try:
s1 = txt_database_name
s2 = '.db'
name_DB = s1 + s2
sqlite_connection = sqlite3.connect(name_DB)
cursor = sqlite_connection.cursor()
txt_log.insert(INSERT, "База данных SQLite успешно создана\n")
cursor.close()
except sqlite3.Error as error:
txt_log.insert(INSERT, "Ошибка при создании sqlite\n")
txt_log.insert(INSERT, error)
txt_log.insert(INSERT, "\n")
finally:
if (sqlite_connection):
sqlite_connection.close()
window_database.destroy()
def connect(db):
name_DB = filedialog.askopenfilename(filetypes=(("Database", ".db"),))
mdb=db
mdb.connect(name_DB)
return name_DB
def download(db):
# подключение к бд
name_DB=connect(db)
dbb=db
dbb.connect(name_DB)
txt_log.insert(INSERT, "База данных ")
name_db = os.path.basename(name_DB)
txt_log.insert(INSERT, name_db)
txt_log.insert(INSERT, " подключена\n")
sqlite_create_table_query='''CREATE TABLE session (id INTEGER PRIMARY KEY ,ip_src TEXT ,ip_dst TEXT ,sport TEXT , dport TEXT ,request TEXT ,response TEXT );'''
dbb.create_table(sqlite_create_table_query)
txt_log.insert(INSERT, "Таблица session создана\n")
file = filedialog.askopenfilename(filetypes=(("Trafic files", ".pcap"),))
with open(file, 'rb') as f:
schet = int()
temp = True
pcap = dpkt.pcap.Reader(f)
scapy_cap = rdpcap(file)
txt_log.insert(INSERT, "\n")
txt_log.insert(INSERT, "Протоколы и их количество в файле:\n")
txt_log.insert(INSERT, scapy_cap)
txt_log.insert(INSERT, "\n")
id = 0
for timestamp, buf in pcap:
eth = dpkt.ethernet.Ethernet(buf)
if not isinstance(eth.data, dpkt.ip.IP):
txt_log.insert(INSERT, "Non IP Packet type not supported ")
txt_log.insert(INSERT, eth.data.__class__.__name__)
txt_log.insert(INSERT, "\n")
continue
ip = eth.data
List_IP.append(eth.data)
list_ip_for_sessions.append(0)
if isinstance(ip.data, dpkt.tcp.TCP):
ip_src = socket.inet_ntoa(ip.src)
ip_dst = socket.inet_ntoa(ip.dst)
sport = ip.data.sport
dport = ip.data.dport
for counter in range(len(List_IP)):
ip_dst = socket.inet_ntoa(List_IP[counter].dst)
ip_src = socket.inet_ntoa(List_IP[counter].src)
sport = List_IP[counter].data.sport
dport = List_IP[counter].data.dport
one_session.clear()
for raw in List_IP:
schet += 1
if raw.data.__hdr_len__ >= 20 and raw.data.__hdr_len__ <= 60:
if (ip_dst == socket.inet_ntoa(raw.dst)) and (ip_src == socket.inet_ntoa(raw.src)) and (
sport == raw.data.sport) and (dport == raw.data.dport):
if list_ip_for_sessions[schet] == 0:
list_ip_for_sessions[schet] = 1
try:
request = dpkt.http.Request(raw.data.data)
list_id.append(id)
list_for_bd.append(id)
list_for_bd.append(ip_src)
list_for_bd.append(ip_dst)
list_for_bd.append(sport)
list_for_bd.append(dport)
requests.append(str (request))
new_string_db = tuple(list_for_bd)
query="INSERT INTO session VALUES (?,?,?,?,?,NULL,NULL)"
dbb.insert(query, new_string_db)
update_reques_db = tuple(requests)
new_string_request_db = "UPDATE session SET request= (?) WHERE id=" + str(id)
dbb.insert(new_string_request_db,update_reques_db)
list_for_bd.clear()
requests.clear()
id = id + 1
except (dpkt.dpkt.NeedData, dpkt.dpkt.UnpackError):
continue
one_session.append(request)
txt_in.insert(INSERT, one_session)
txt_in.insert(INSERT, "\n")
one_session.clear()
if (ip_src == socket.inet_ntoa(raw.dst)) and (ip_dst == socket.inet_ntoa(raw.src)) and (
dport == raw.data.sport) and (sport == raw.data.dport):
if list_ip_for_sessions[schet] == 0:
list_ip_for_sessions[schet] = 1
try:
response = dpkt.http.Response(raw.data.data)
responses.append(str(response))
if len(response)!=0:
update_response_db = tuple(responses)
new_string_response_db = "UPDATE session SET response= (?) WHERE id=" + str(id-1)
dbb.insert(new_string_response_db,update_response_db)
responses.clear()
except (dpkt.dpkt.NeedData, dpkt.dpkt.UnpackError):
continue
one_session.append(response)
txt_out.insert(INSERT, one_session)
txt_out.insert(INSERT, "\n")
else:
txt_log.insert(INSERT, "Используется протокол: ")
txt_log.insert(INSERT, raw.data.__class__.__name__)
txt_log.insert(INSERT, "\n")
schet = -1
query="SELECT ip_src,ip_dst FROM session;"
dbb.select_many(query,id)