Python ve Acey Lekitli Gerçek Zamanlı Ağ Trafik Gösterge Tablosu Nasıl Oluşturulur
Hiç ağ trafiğinizi gerçek zamanlı olarak görselleştirmek istediniz mi? Bu eğitimde Python ve Streamlit
ile etkileşimli bir ağ trafiği analizi kontrol panelinin nasıl oluşturulacağını öğreneceksiniz. Streamlit
, veri analizi ve veri işlemeye yönelik web uygulamaları geliştirmek için kullanabileceğiniz açık kaynaklı bir Python çerçevesidir.
Bu öğreticinin sonunda, bilgisayarınızın NIC'den (ağ arayüz kartı) ham ağ paketlerini nasıl yakalayacağınızı, verileri işleyeceğinizi ve gerçek zamanlı olarak güncellenecek güzel görselleştirmeler oluşturacağınızı bileceksiniz.
İçindekiler
Ağ trafik analizi neden önemlidir?
Önkoşullar
-
Projenizi nasıl kurabilirsiniz?
Temel İşlevsellikler Nasıl Oluşturulur?
Azalan görselleştirmeler nasıl oluşturulur
Ağ Paketleri Nasıl Yakalanır
Her şeyi bir araya getirmek
Gelecekteki Geliştirmeler
Çözüm
Ağ Trafiği Analizi Neden Önemlidir?
Ağ trafiği analizi, ağların neredeyse her uygulama ve hizmetin omurgasını oluşturduğu işletmelerde kritik bir gerekliliktir. Bunun temelinde, ağın izlenmesini, tüm trafiğin (giriş ve çıkış) yakalanmasını ve bu paketlerin ağ üzerinden akarken yorumlanmasını içeren ağ paketlerinin analizi bulunmaktadır. Bu tekniği güvenlik kalıplarını tanımlamak, anormallikleri tespit etmek ve ağın güvenliğini ve verimliliğini sağlamak için kullanabilirsiniz.
Bu eğitimde üzerinde çalışacağımız bu kavram kanıtlama projesi, ağ etkinliğini gerçek zamanlı olarak görselleştirmenize ve analiz etmenize yardımcı olduğundan özellikle kullanışlıdır. Bu da kurumsal sistemlerde sorun giderme sorunlarının, performans optimizasyonlarının ve güvenlik analizinin nasıl yapıldığını anlamanıza olanak tanıyacaktır.
Önkoşullar
Sisteminizde Python 3.8 veya daha yeni bir sürüm yüklü.
-
Bilgisayar ağı kavramlarının temel anlayışı.
Python programlama diline ve yaygın olarak kullanılan kütüphanelere aşinalık.
Veri görselleştirme teknikleri ve kütüphaneleri hakkında temel bilgi.
Projenizi Nasıl Kurabilirsiniz?
Başlamak için proje yapısını oluşturun ve aşağıdaki komutlarla PIP ile gerekli araçları yükleyin:
mkdir network-dashboard
cd network-dashboard
pip install streamlit pandas scapy plotly
Gösterge tablosu görselleştirmeleri için somutluklu
, veri işleme için pandalar
, skapi
ağı kullanacağız, ağ paketi yakalama ve paket işleme için ve son olarak Toplanan verilerimizle grafik çizmek için plotly
.
Temel İşlevsellikler Nasıl Oluşturulur?
Tüm kodu dashboard.py
adlı tek bir dosyaya koyacağız. İlk olarak, kullanacağımız tüm öğeleri içe aktararak başlayalım:
import streamlit as st
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
from scapy.all import *
from collections import defaultdict
import time
from datetime import datetime
import threading
import warnings
import logging
from typing import Dict, List, Optional
import socket
Şimdi temel bir günlük kaydı yapılandırması kurarak günlük kaydını yapılandıralım. Bu, olayları izlemek ve uygulamamızı hata ayıklama modunda çalıştırmak için kullanılacaktır. Şu anda günlük tutma düzeyini INFO
olarak ayarladık; bu, INFO
düzeyi veya daha yüksek olan olayların görüntüleneceği anlamına gelir. Python'da oturum açma konusunda bilginiz yoksa, ayrıntılı bilgi içeren bu belgeye göz atmanızı öneririm.
# Configure logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
Ardından, paket işlemcimizi oluşturacağız. Yakalanan paketlerimizi bu sınıfta işleme işlevselliğini uygulayacağız.
class PacketProcessor:
"""Process and analyze network packets"""
def __init__(self):
self.protocol_map = {
1: 'ICMP',
6: 'TCP',
17: 'UDP'
}
self.packet_data = []
self.start_time = datetime.now()
self.packet_count = 0
self.lock = threading.Lock()
def get_protocol_name(self, protocol_num: int) -> str:
"""Convert protocol number to name"""
return self.protocol_map.get(protocol_num, f'OTHER({protocol_num})')
def process_packet(self, packet) -> None:
"""Process a single packet and extract relevant information"""
try:
if IP in packet:
with self.lock:
packet_info = {
'timestamp': datetime.now(),
'source': packet[IP].src,
'destination': packet[IP].dst,
'protocol': self.get_protocol_name(packet[IP].proto),
'size': len(packet),
'time_relative': (datetime.now() - self.start_time).total_seconds()
}
# Add TCP-specific information
if TCP in packet:
packet_info.update({
'src_port': packet[TCP].sport,
'dst_port': packet[TCP].dport,
'tcp_flags': packet[TCP].flags
})
# Add UDP-specific information
elif UDP in packet:
packet_info.update({
'src_port': packet[UDP].sport,
'dst_port': packet[UDP].dport
})
self.packet_data.append(packet_info)
self.packet_count += 1
# Keep only last 10000 packets to prevent memory issues
if len(self.packet_data) > 10000:
self.packet_data.pop(0)
except Exception as e:
logger.error(f"Error processing packet: {str(e)}")
def get_dataframe(self) -> pd.DataFrame:
"""Convert packet data to pandas DataFrame"""
with self.lock:
return pd.DataFrame(self.packet_data)
Bu sınıf temel işlevlerimizi oluşturacak ve paketlerin işlenmesi için kullanılacak çeşitli yardımcı işlevlere sahip olacak.
Ağ paketleri, taşıma düzeyinde (TCP ve UDP) ikiye kategorize edilir ve ağ düzeyinde ICMP protokolü. TCP/IP kavramlarına aşina değilseniz, FreeCodeCamp News ile ilgili bu makaleyi kontrol etmenizi öneririm.
Yapıcımız, tanımladığımız bu TCP/IP protokol türü gruplarında kategorize edilen görülen tüm paketleri takip edecektir. Ayrıca paket yakalama süresini, yakalanan verileri ve yakalanan paket sayısını da not edeceğiz.
Aynı anda yalnızca bir paketin işlenmesini sağlamak için bir iş parçacığı kilidinden de yararlanacağız. Bu, projenin paralel paket işlemeye sahip olmasını sağlamak için daha da genişletilebilir.
get_protocol_name
yardımcı işlevi, protokol numaralarına göre doğru protokol türünü almamıza yardımcı olur. Bu konuda biraz arka plan vermek için, İnternet atanmış numaralar yetkisi (IANA), bir ağ paketindeki farklı protokolleri tanımlamak için standart sayılar atar. Bu sayıları ayrıştırılmış ağ paketinde gördüğümüzde ve gördüğümüzde, şu anda ele geçirilen pakette ne tür bir protokol kullanıldığını bileceğiz. Bu projenin kapsamı için sadece TCP, UDP ve ICMP (Ping) ile eşleşeceğiz. Başka bir paket türüyle karşılaşırsak, bunu diğer (
olarak kategorize edeceğiz.
process_packet
işlevi, bu ayrı paketleri işleyecek temel işlevlerimizi yönetir. Paket bir IP katmanı içeriyorsa kaynak ve hedef IP adreslerini, protokol türünü, paket boyutunu ve paket yakalamanın başlangıcından bu yana geçen süreyi not edecektir.
Belirli aktarım katmanı protokollerine (TCP ve UDP gibi) sahip paketler için, TCP paketleri için TCP bayraklarıyla birlikte kaynak ve hedef bağlantı noktalarını yakalayacağız. Çıkarılan bu ayrıntılar bellekte packet_data
listesinde saklanacaktır. Bu paketler işlenirken packet_count
miktarını da takip edeceğiz.
get_dataFrame
işlevi, packet_data
listesini bir pandas
veri çerçevesine dönüştürmemize yardımcı olur.
Azalan görselleştirmeler nasıl oluşturulur
Artık interaktif Streamlit Dashboard'umuzu oluşturmanın zamanı geldi. dashboard.py
betiğinde (paket işleme sınıfımızın dışında) create_visualization
adında bir fonksiyon tanımlayacağız.
def create_visualizations(df: pd.DataFrame):
"""Create all dashboard visualizations"""
if len(df) > 0:
# Protocol distribution
protocol_counts = df['protocol'].value_counts()
fig_protocol = px.pie(
values=protocol_counts.values,
names=protocol_counts.index,
title="Protocol Distribution"
)
st.plotly_chart(fig_protocol, use_container_width=True)
# Packets timeline
df['timestamp'] = pd.to_datetime(df['timestamp'])
df_grouped = df.groupby(df['timestamp'].dt.floor('S')).size()
fig_timeline = px.line(
x=df_grouped.index,
y=df_grouped.values,
title="Packets per Second"
)
st.plotly_chart(fig_timeline, use_container_width=True)
# Top source IPs
top_sources = df['source'].value_counts().head(10)
fig_sources = px.bar(
x=top_sources.index,
y=top_sources.values,
title="Top Source IP Addresses"
)
st.plotly_chart(fig_sources, use_container_width=True)
Bu işlev veri çerçevesini giriş olarak alacak ve üç grafik/grafik çizmemize yardımcı olacaktır:
Protokol Dağıtım Grafiği: Bu grafik, yakalanan paket trafiğinde farklı protokollerin (örneğin TCP, UDP, ICMP) oranını gösterecektir.
Paketler Zaman Çizelgesi Grafiği: Bu grafik, bir süre içinde saniyede işlenen paket sayısını gösterecektir.
En İyi Kaynak IP Adresleri Tablosu: Bu grafik, yakalanan trafikte en fazla paketi gönderen ilk 10 IP adresini vurgulayacaktır.
Protokol dağıtım şeması, üç farklı tür için (DİĞER ile birlikte) protokol sayımlarının basit bir pasta grafiğidir. Bu grafikleri çizmek için Streamlit
ve Plotly
Python araçlarını kullanıyoruz. Paket yakalamanın başlamasından bu yana geçen zaman damgasını da not ettiğimiz için, bu verileri zaman içinde yakalanan paketlerin eğilimini çizmek için kullanacağız.
İkinci grafik için veriler üzerinde groupby
işlemi yapıp her saniyede yakalanan paket sayısını alacağız (S
saniye anlamına gelir) ve son olarak şunu yapacağız: grafiği çizin.
Son olarak, üçüncü grafik için, gözlemlenen farklı kaynak IP'leri sayacağız ve en iyi 10 IP'leri göstermek için IP sayımının bir grafiği grafiği.
Ağ Paketleri Nasıl Yakalanır
Şimdi, ağ paket verilerini yakalamamıza izin verecek işlevselliği oluşturalım.
def start_packet_capture():
"""Start packet capture in a separate thread"""
processor = PacketProcessor()
def capture_packets():
sniff(prn=processor.process_packet, store=False)
capture_thread = threading.Thread(target=capture_packets, daemon=True)
capture_thread.start()
return processor
Bu, PacketProcessor
sınıfını başlatan ve daha sonra paketleri yakalamaya başlamak için SCIFT
işlevini Scapy
modülünde kullanan basit bir işlevdir.
Ana program akışından bağımsız olarak paketleri yakalamamıza izin vermek için burada iş parçacığı kullanıyoruz. Bu, paket yakalama işleminin gösterge tablosunu gerçek zamanlı olarak güncelleme gibi diğer işlemleri engellememesini sağlar. Ayrıca, oluşturulan PacketProcessor
örneğini ana programımızda kullanılabilmesi için iade ediyoruz.
Her şeyi bir araya getirmek
Şimdi tüm bu parçaları, programımız için sürücü işlevi olarak işlev görecek Main
işlevimizle birlikte dikelim.
def main():
"""Main function to run the dashboard"""
st.set_page_config(page_title="Network Traffic Analysis", layout="wide")
st.title("Real-time Network Traffic Analysis")
# Initialize packet processor in session state
if 'processor' not in st.session_state:
st.session_state.processor = start_packet_capture()
st.session_state.start_time = time.time()
# Create dashboard layout
col1, col2 = st.columns(2)
# Get current data
df = st.session_state.processor.get_dataframe()
# Display metrics
with col1:
st.metric("Total Packets", len(df))
with col2:
duration = time.time() - st.session_state.start_time
st.metric("Capture Duration", f"{duration:.2f}s")
# Display visualizations
create_visualizations(df)
# Display recent packets
st.subheader("Recent Packets")
if len(df) > 0:
st.dataframe(
df.tail(10)[['timestamp', 'source', 'destination', 'protocol', 'size']],
use_container_width=True
)
# Add refresh button
if st.button('Refresh Data'):
st.rerun()
# Auto refresh
time.sleep(2)
st.rerun()
Bu işlev aynı zamanda Streamlit
kontrol panelini başlatacak ve tüm bileşenlerimizi birbirine entegre edecektir. Öncelikle Streamlit
kontrol panelimizin sayfa başlığını belirliyoruz ve ardından PacketProcessor
'ımızı başlatıyoruz. Yalnızca bir paket yakalama örneğinin oluşturulduğundan ve durumunun korunduğundan emin olmak için Streamlit
'te oturum durumunu kullanırız.
Şimdi, veri her işlendiğinde veri çerçevesini oturum durumundan dinamik olarak alacağız ve metrikleri ve görselleştirmeleri göstermeye başlayacağız. Ayrıca, zaman damgası, kaynak ve hedef IP'ler, protokol ve paketin boyutu gibi bilgilerle birlikte yakın zamanda yakalanan paketleri de göstereceğiz. Ayrıca, her iki saniyede bir otomatik olarak yenilenirken, kullanıcının verileri gösterge tablosundan manuel olarak yenileme yeteneği de ekleyeceğiz.
Sonunda programı aşağıdaki komutla çalıştıralım:
sudo streamlit run dashboard.py
Paket yakalama yetenekleri idari ayrıcalıklar gerektirdiğinden, programı sudo
ile çalıştırmanız gerektiğini unutmayın. Windows'taysanız, terminalinizi yönetici olarak açın ve ardından sudo
öneki olmadan programı çalıştırın.
Programın paketleri yakalamaya başlaması için bir an verin. Her şey yolunda giderse, böyle bir şey görmelisiniz:
Bunlar,
Gelecekteki Geliştirmeler
Bununla birlikte, kontrol panelinin işlevlerini genişletmek için kullanabileceğiniz geleceğe yönelik bazı geliştirme fikirleri şunlardır:
Anormallik tespiti için makine öğrenimi özellikleri ekleyin
Coğrafi IP eşlemeyi uygulayın
Trafik analizi modellerine göre özel uyarılar oluşturun
Paket verisi analizi seçeneklerini ekleyin
Çözüm
Tebrikler! Artık Python ve Streamlit
ile gerçek zamanlı bir ağ trafiği analizi kontrol panelini başarıyla oluşturdunuz. Bu program ağ davranışına ilişkin değerli bilgiler sağlayacak ve güvenlik izlemeden ağ optimizasyonuna kadar çeşitli kullanım durumları için genişletilebilir.
Bununla birlikte, umarım ağ trafiği analizi ile ilgili bazı temel bilgilerin yanı sıra biraz Python programlamayı da öğrenmişsinizdir. Okuduğunuz için teşekkürler!