main_kppv.py
8.78 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
"""
Created on Thu Jan 11 15:22:56 2018
@author: Robin Cavalieri
IMA5SC - PFE 2018
P32 - Détection automatique de DoS sur réseau LoRa
Main avec méthode des KPPV
"""
###############################################################################
#LIBRAIRIES UTILES
###############################################################################
import time;
import serial;
import numpy as np;
import pandas as pd;
###############################################################################
###############################################################################
#VARIABLES MESUREES
###############################################################################
ping_mesured=0;
rssi_mesured=0;
result=0;
puissance_read = 0;
temp_read = 0;
trame_read = [];
###############################################################################
##############################################################################
#DEFINITION DE LA LECTURE DE PORT
##############################################################################
ser = serial.Serial(
#Pour Linux
#port='/dev/ttyACM0',
#Pour Windows
port='COM4',
#Vitesse4de communication
baudrate = 9600,
#Parité
parity=serial.PARITY_NONE,
#Bit de stop
stopbits=serial.STOPBITS_ONE,
#Taille du message
bytesize=serial.EIGHTBITS,
#Out
timeout=1
)
counter=0;
##############################################################################
###############################################################################
#TRAVAIL PRELIMINAIRE DE TRAITEMENT DES DONNEES D'APPRENTISSAGE
###############################################################################
# Ouverture des bases d'apprentissage
dataset_ping_norm = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/ping_norm.csv');
dataset_ping_attack = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/ping_attack.csv');
dataset_rssi_norm = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/rssi_norm.csv');
dataset_rssi_attack = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/rssi_attack.csv');
#Concatenation pour avoir une base de ping et une base de rssi
dataset_ping = np.concatenate((dataset_ping_attack, dataset_ping_norm), axis=0);
dataset_rssi = np.concatenate((dataset_rssi_attack, dataset_rssi_norm), axis=0);
#Récupération des tailles de matrices
[X_ping, Y_ping] = np.shape(dataset_ping);
[X_rssi, Y_rssi] = np.shape(dataset_rssi);
###############################################################################
###############################################################################
#KPPV PING
###############################################################################
def prediction_ping(ping):
cpt = 0;
k = 5;
dataset_ping_temp = np.zeros((X_ping,1));
#Remplissage des distances euclidiennes
for i in range(0, X_ping):
dataset_ping_temp[i,0] = ((dataset_ping[i,1]-ping)**2)**0.5;
#Concatenation avec distances euclidiennes
dataset_ping_temp = np.c_[dataset_ping, dataset_ping_temp];
#Tri
dataset_ping_temp = dataset_ping_temp[dataset_ping_temp[:,2].argsort()]
#Checking des k premiers voisins
for j in range(0, k-1):
if(dataset_ping_temp[j,0]==1):
cpt = cpt+1;
if(cpt >= (k/2)+1):
return 1; #Attaque
else:
return 0; #RAS
###############################################################################
###############################################################################
#KPPV RSSI
###############################################################################
def prediction_rssi(rssi):
cpt = 0;
k = 20;
dataset_rssi_temp = np.zeros((X_rssi,1));
#Remplissage des distances euclidiennes
for i in range(0, X_rssi):
dataset_rssi_temp[i,0] = ((dataset_rssi[i,1]-rssi)**2)**0.5;
#Concatenation avec distances euclidiennes
dataset_rssi_temp = np.c_[dataset_rssi, dataset_rssi_temp];
#Tri
dataset_rssi_temp = dataset_rssi_temp[dataset_rssi_temp[:,2].argsort()]
#Checking des k premiers voisins
for j in range(0, k-1):
if(dataset_rssi_temp[j,0]==1):
cpt = cpt+1;
if(cpt >= (k/2)+1):
return 1; #Attaque
else:
return 0; #RAS
###############################################################################
###############################################################################
#AFFICHAGE
###############################################################################
def Recorder():
global temp;
global temp_read;
global ping_mesured;
global puissance_read;
global trame_read;
global cpt_trames;
global cpt_trames_temp;
cpt_trames = 0;
cpt_trames_temp = 0;
temp = 0;
#REMISE A 0 DES FICHIERS
temp_file = open('C:/xampp/htdocs/temperature.csv', 'w')
ping_file = open('C:/xampp/htdocs/ping.csv', 'w')
puissance_file = open('C:/xampp/htdocs/puissance.csv', 'w')
import csv
while(1):
#RECUPERATION DES DONNEES
x = ser.readline();
#FICHIERS CSV APPLICATION WEB
temp_file = open('C:/xampp/htdocs/temperature.csv', 'a')
tempwriter = csv.writer(temp_file, delimiter=',');
ping_file = open('C:/xampp/htdocs/ping.csv', 'a')
pingwriter = csv.writer(ping_file, delimiter=',');
puissance_file = open('C:/xampp/htdocs/puissance.csv', 'a')
puissancewriter = csv.writer(puissance_file, delimiter=',');
traficping_file = open('C:/xampp/htdocs/traficPing.csv', 'w')
traficpingwriter = csv.writer(traficping_file);
traficrssi_file = open('C:/xampp/htdocs/traficRssi.csv', 'w')
traficrssiwriter = csv.writer(traficrssi_file);
if(0x7C in x):
#Lecture de la trame
trame_read = x;
#Récupération du compteur de trames
cpt_trames = (trame_read[15]-48)*100 + (trame_read[16]-48)*10 + (trame_read[17]-48);
if(0x7C in x and cpt_trames == 1):
temp = time.time();
if(0x7C in x and cpt_trames > 1):
t2 = time.time();
ping_mesured = (t2-temp)*1000;
#Récupération de la température
temp_read = (trame_read[12]-48)*10 + trame_read[13]-48;
#Récupération de la puissance
x = ser.readline();
puissance_read = (x[1]-48)*10 + x[2]-48;
#T2
temp = t2;
if(cpt_trames_temp + 1 == cpt_trames):
#BOOLEEN
state_ping = prediction_ping(ping_mesured);
state_rssi = prediction_rssi(puissance_read);
#AFFICHAGE
print("\n###############################\n");
print("TRAME : "+ "".join(map(chr, trame_read))+"\n");
print("TRAME NUM. : "+str(cpt_trames)+"\n");
print("TEMPERATURE : "+str(temp_read)+" °C\n");
print("PUISSANCE : "+str(puissance_read)+" dBm\n");
print("PING : "+str(ping_mesured)+" ms\n");
if(state_ping == 0):
print("PING NORMAL\n");
traficpingwriter.writerow([0])
elif(state_ping == 1):
print("PING ATTAQUE\n");
traficpingwriter.writerow([1])
if(state_rssi == 0):
print("RSSI NORMAL\n");
traficrssiwriter.writerow([0])
elif(state_rssi == 1):
print("RSSI ATTAQUE\n");
traficrssiwriter.writerow([1])
print("###############################\n");
##########################################
#ECRITURE DANS FICHIERS
##########################################
tempwriter.writerow([time.time(),temp_read]);
pingwriter.writerow([time.time(),ping_mesured])
puissancewriter.writerow([time.time(),puissance_read]);
##########################################
else:
print("\n###############################\n");
print("ON AIR");
print("\n###############################\n");
temp_file.close();
puissance_file.close();
ping_file.close();
traficping_file.close();
traficrssi_file.close();
cpt_trames_temp = cpt_trames;
###############################################################################
###############################################################################
#MAIN
###############################################################################
if __name__ == '__main__':
Recorder();
###############################################################################