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:

  1. Protokol Dağıtım Grafiği: Bu grafik, yakalanan paket trafiğinde farklı protokollerin (örneğin TCP, UDP, ICMP) oranını gösterecektir.

  2. Paketler Zaman Çizelgesi Grafiği: Bu grafik, bir süre içinde saniyede işlenen paket sayısını gösterecektir.

  3. 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, SomationLit gösterge paneli programımızda yeni uyguladığımız tüm görselleştirmelerdir.

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:

  1. Anormallik tespiti için makine öğrenimi özellikleri ekleyin

  2. Coğrafi IP eşlemeyi uygulayın

  3. Trafik analizi modellerine göre özel uyarılar oluşturun

  4. 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!