Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Merhaba sana vereceğim kodu cxxdroid de çalıştırınca bu yanıtı termuxda çalıştırınca bu…

  1. User

    Merhaba sana vereceğim kodu cxxdroid de çalıştırınca bu yanıtı termuxda çalıştırınca bu yanıtı alıyorum termuxdaki çıktı pcap dosyasının DPI analizini göre çok az ve yetersiz termuxdaki çıktı:UDP Source Port: 40802, Destination Port: 53 UDP Data: ��cloudflare-dnscomA UDP Source Port: 44493, Destination Port: 53 UDP Data: .�exampleorg UDP Source Port: 17831, Destination Port: 53 UDP Data: [ipv4onlyarpa UDP Source Port: 53, Destination Port: 44493 UDP Data: .���exampleorg� �]�� UDP Source Port: 53, Destination Port: 17831 UDP Data: [Ёipv4onlyarpa� EN��� EN�� UDP Source Port: 57974, Destination Port: 53 UDP Data: D�assetsmozillanet UDP Source Port: 15041, Destination Port: 53 UDP Data: Mkfirefosettingservicesmozillacom UDP Source Port: 53, Destination Port: 15041 UDP Data: Mk��firefosettingservicesmozillacom� ;2prodremote-settingsprod webservicesmozgcpnet�C<"�d� Cxxdroiddeki çıktı:Kullanım: /data/user/0/ru.iiec.cxxdroid/files/iiec_tmp_binary <pcap_dosyası>

    [Program finished] DPI analizator olan kod:// main.cpp

    #include #include #include #include #include #include <openssl/ssl.h> #include <openssl/err.h> #include <openssl/x509.h> #include <openssl/pem.h> #include #include #include #include <arpa/inet.h> // ntohs ve ntohl için eklenmiştir #include #include #include #include <unordered_map> #include #include #include #include <condition_variable> #include // std::istringstream için #include // std::function için

    // nlohmann/json.hpp dosyasını doğru şekilde dahil edin #include "nlohmann/json.hpp" // JSON loglama için

    #include <sqlite3.h> // SQLite veritabanı için // #include <pcap.h> // libpcap kullanılmayacak

    using json = nlohmann::json;

    // Yapısal tanımlamalar #pragma pack(push, 1) // Struct üyelerinin hizalanmasını sağlamak için

    struct pcap_global_header { uint32_t magic_number; // Magic number uint16_t version_major; // Major version number uint16_t version_minor; // Minor version number int32_t thiszone; // GMT to local correction uint32_t sigfigs; // Accuracy of timestamps uint32_t snaplen; // Max length of captured packets, in octets uint32_t network; // Data link type };

    struct pcap_packet_header { uint32_t ts_sec; // Timestamp seconds uint32_t ts_usec; // Timestamp microseconds uint32_t incl_len; // Number of octets of packet saved in file uint32_t orig_len; // Actual length of packet };

    struct ethernet_header { uint8_t dest_mac[6]; uint8_t source_mac[6]; uint16_t ethertype; };

    struct ip_header { unsigned char version_ihl; unsigned char tos; unsigned short total_length; unsigned short identification; unsigned short flags_fragment_offset; unsigned char ttl; unsigned char protocol; unsigned short header_checksum; uint32_t source_address; uint32_t destination_address; };

    struct tcp_header { unsigned short source_port; unsigned short dest_port; uint32_t sequence_number; uint32_t ack_number; unsigned char data_offset_reserved; // Üst 4 bit: data_offset, Alt 4 bit: reserved unsigned char flags; unsigned short window_size; unsigned short checksum; unsigned short urgent_pointer; };

    struct udp_header { unsigned short source_port; unsigned short dest_port; unsigned short length; unsigned short checksum; };

    #pragma pack(pop) // Struct hizalamasını geri almak için

    // TCP segment yapısı struct tcp_segment { uint32_t seq_num; std::vector data; };

    // StreamKey yapısı struct StreamKey { uint32_t source_ip; uint32_t dest_ip; uint16_t source_port; uint16_t dest_port;

    bool operator==(const StreamKey& other) const {
        return std::tie(source_ip, dest_ip, source_port, dest_port) ==
               std::tie(other.source_ip, other.dest_ip, other.source_port, other.dest_port);
    }
    

    };

    // Hash fonksiyonu StreamKey için namespace std { template <> struct hash { std::size_t operator()(const StreamKey& k) const { return ((std::hash<uint32_t>()(k.source_ip) ^ (std::hash<uint32_t>()(k.dest_ip) << 1)) >> 1) ^ ((std::hash<uint16_t>()(k.source_port) << 1) >> 1) ^ (std::hash<uint16_t>()(k.dest_port) << 1); } }; }

    // TCP Stream yapısı struct tcp_stream { uint32_t next_seq_num = 0; std::vector<tcp_segment> segments; std::vector<std::pair<time_t, size_t>> timings; std::vector buffer; // Yeniden düzenlenen veriyi tutmak için buffer size_t parse_offset = 0; // Ayrıştırma için sonraki pozisyon bool is_http = false;

    std::string source_ip_str; // Eklenen üye
    std::string dest_ip_str;   // Eklenen üye
    

    };

    // PCAP işlemesi ve protokol ayrıştırma sınıfı class PacketProcessor { public: PacketProcessor(); ~PacketProcessor();

    // Pcap dosyasını işleme fonksiyonu
    void process_pcap_file(const std::string& filename);
    
    // Paketi işleme fonksiyonu (PCAP ve Live Capture ile kullanılabilir)
    void process_packet(const std::vector<char>& packet_data, std::ostream& output, time_t timestamp);
    

    private: // Benzersiz akışları saklamak için unordered_map kullanımı std::unordered_map<StreamKey, tcp_stream> streams; std::mutex stream_mutex; // Thread güvenliği için

    // AnomalyDetector sınıfının örneği
    class AnomalyDetector {
    public:
        AnomalyDetector();
        ~AnomalyDetector();
    
        void log_anomaly(const std::string& anomaly_type, uint32_t /*source_ip*/, uint32_t /*dest_ip*/,
                         uint16_t /*source_port*/, uint16_t /*dest_port*/, size_t /*packet_size*/,
                         time_t /*timestamp*/, const std::string& /*src_ip_str*/, const std::string& /*dst_ip_str*/);
    
        void process_packet(uint32_t source_ip, uint32_t dest_ip, uint16_t source_port,
                            uint16_t dest_port, size_t packet_size, time_t timestamp,
                            const std::string& src_ip_str, const std::string& dst_ip_str);
    
    private:
        struct IPStat {
            size_t packet_count = 0;
            size_t byte_count = 0;
            std::deque<std::pair<time_t, size_t>> packet_times; // Paket zamanlarını tutmak için
        };
    
        size_t MAX_PACKETS_PER_IP = 1000;
        size_t MAX_BYTES_PER_IP = 1000000;
        // size_t RATE_THRESHOLD = 1000; // Paket/saniye (Kullanılmıyorsa yorum satırı yapıldı)
        std::set<uint16_t> SUSPICIOUS_PORTS = {23, 2323, 23232, 443, 53, 80};
        std::map<uint32_t, IPStat> ip_stats;
        std::mutex stat_mutex;
    
        // Veritabanı
        sqlite3* db = nullptr;
    
        void init_db(sqlite3** db_ptr);
        bool is_suspicious_port(uint16_t port) const;
        void reset_ip_stats(uint32_t ip);
    };
    
    AnomalyDetector anomaly_detector;
    
    // IP adresini string'e çevirme fonksiyonu
    std::string ip_to_string(uint32_t ip) const;
    
    // TCP segment ekleme fonksiyonu
    void add_segment(tcp_stream& stream, uint32_t seq_num, const std::vector<char>& segment_data);
    
    // TLS record parsing fonksiyonu
    bool parse_tls_record(const std::vector<char>& data, size_t& offset, std::vector<char>& record_data, uint8_t& content_type);
    
    // TLS handshake message türleri
    enum TLSHandshakeType {
        HelloRequest = 0,
        ClientHello = 1,
        ServerHello = 2,
        Certificate = 11,
        ServerKeyExchange = 12,
        CertificateRequest = 13,
        ServerHelloDone = 14,
        CertificateVerify = 15,
        ClientKeyExchange = 16,
        Finished = 20
    };
    
    // TLS handshake analizi fonksiyonu
    void analyze_tls_packet(const std::vector<char>& buffer, size_t& parse_offset, tcp_stream& stream);
    
    // Sertifika geçerlilik kontrol fonksiyonu
    bool is_certificate_valid(X509* cert);
    
    // HTTP paketlerini ayrıştırma ve analiz etme fonksiyonu
    void analyze_http_packet(const std::vector<char>& buffer, size_t& parse_offset, tcp_stream& stream);
    
    // UDP paketlerini ayrıştırma fonksiyonu
    void parse_udp(const std::vector<char>& packet_data, std::ostream& output);
    

    };

    // Constructor PacketProcessor::PacketProcessor() : anomaly_detector() { // Constructor içeriği }

    // Destructor PacketProcessor::~PacketProcessor() { // Destructor içeriği }

    // IP adresini string'e çevirme fonksiyonu std::string PacketProcessor::ip_to_string(uint32_t ip) const { struct in_addr ip_addr; ip_addr.s_addr = ip; return std::string(inet_ntoa(ip_addr)); }

    // TCP segment ekleme fonksiyonu void PacketProcessor::add_segment(tcp_stream& stream, uint32_t seq_num, const std::vector& segment_data) { std::lock_guardstd::mutex lock(stream_mutex);

    if (stream.next_seq_num == 0 || seq_num == stream.next_seq_num) {
        // İlk segment veya beklenen segment
    
        if (stream.next_seq_num == 0) {
            stream.next_seq_num = seq_num;
        }
    
        stream.buffer.insert(stream.buffer.end(), segment_data.begin(), segment_data.end());
        stream.next_seq_num += static_cast<uint32_t>(segment_data.size());
    
        // Sıradaki segmentleri kontrol et
        auto it = stream.segments.begin();
        while (it != stream.segments.end()) {
            if (it->seq_num == stream.next_seq_num) {
                stream.buffer.insert(stream.buffer.end(), it->data.begin(), it->data.end());
                stream.next_seq_num += static_cast<uint32_t>(it->data.size());
                it = stream.segments.erase(it);
            } else {
                ++it;
            }
        }
    } else if (seq_num > stream.next_seq_num) {
        // Gelecekteki segment, sakla
        tcp_segment new_segment{ seq_num, segment_data };
        stream.segments.push_back(new_segment);
    }
    // Eski veya tekrarlanan segmentler göz ardı edilir
    

    }

    // TLS record parsing fonksiyonu bool PacketProcessor::parse_tls_record(const std::vector& data, size_t& offset, std::vector& record_data, uint8_t& content_type) { if (offset + 5 > data.size()) { return false; }

    // Content Type
    content_type = static_cast<uint8_t>(data[offset]);
    
    // Version (bytes 1 ve 2)
    // KULLANILMIYORSA ÇIKARDIK
    // uint16_t version = (static_cast<uint8_t>(data[offset + 1]) << 8) | static_cast<uint8_t>(data[offset + 2]);
    
    // Length (bytes 3 ve 4)
    uint16_t length = (static_cast<uint8_t>(data[offset + 3]) << 8) | static_cast<uint8_t>(data[offset + 4]);
    
    offset += 5;
    
    if (offset + length > data.size()) {
        return false;
    }
    
    record_data.assign(data.begin() + offset, data.begin() + offset + length);
    offset += length;
    
    return true;
    

    }

    // TLS handshake analizi fonksiyonu void PacketProcessor::analyze_tls_packet(const std::vector& buffer, size_t& parse_offset, tcp_stream& stream) { std::cout << "analyze_tls_packet çağrıldı. Buffer Boyutu: " << buffer.size() << ", Parse Offset: " << parse_offset << std::endl;

    size_t offset = parse_offset;
    std::vector<char> record_data;
    uint8_t content_type;
    bool clientHelloFound = false;
    
    while (parse_tls_record(buffer, offset, record_data, content_type)) {
        std::cout << "Content Type: " << static_cast<int>(content_type) << std::endl;
    
        if (content_type == 22) { // Handshake
            std::cout << "TLS Handshake Record Detected. Size: " << record_data.size() << " bytes" << std::endl;
    
            if (record_data.size() >= 4) { // handshake_type (1) + handshake_length (3)
                TLSHandshakeType handshake_type = static_cast<TLSHandshakeType>(static_cast<uint8_t>(record_data[0]));
    
                size_t current_offset = 4;
    
                if (handshake_type == ClientHello) {
                    clientHelloFound = true;
                    std::cout << "Client Hello Message Found." << std::endl;
                }
                else if (handshake_type == Certificate && clientHelloFound) {
                    std::cout << "Server Certificate Message Found." << std::endl;
    
                    if (current_offset + 3 > record_data.size()) {
                        std::cerr << "Not enough data for certificate length." << std::endl;
                        continue;
                    }
    
                    size_t certificates_length = (static_cast<uint8_t>(record_data[current_offset]) << 16) |
                                                (static_cast<uint8_t>(record_data[current_offset + 1]) << 8) |
                                                static_cast<uint8_t>(record_data[current_offset + 2]);
                    current_offset += 3;
    
                    if (current_offset + certificates_length > record_data.size()) {
                        std::cerr << "Certificate data incomplete." << std::endl;
                        continue;
                    }
    
                    const unsigned char* cert_data = reinterpret_cast<const unsigned char*>(record_data.data() + current_offset);
                    const unsigned char* cert_data_end = cert_data + certificates_length;
    
                    const unsigned char* p = cert_data;
    
                    // Sertifikaları ayrıştır
                    while (p + 3 <= cert_data_end) { // En az 3 byte gereklidir
                        size_t cert_len = (p[0] << 16) | (p[1] << 8) | p[2];
                        p += 3;
    
                        if (p + cert_len > cert_data_end) {
                            std::cerr << "Certificate length exceeds available data." << std::endl;
                            break;
                        }
    
                        // X509 sertifikasını ayrıştır
                        X509* cert = d2i_X509(NULL, &p, cert_len);
                        if (cert) {
                            char* subject = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
                            char* issuer = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0);
    
                            std::cout << "Certificate Subject: " << (subject ? subject : "Not Specified") << std::endl;
                            std::cout << "Certificate Issuer: " << (issuer ? issuer : "Not Specified") << std::endl;
    
                            ASN1_TIME* notBefore = X509_get_notBefore(cert);
                            ASN1_TIME* notAfter = X509_get_notAfter(cert);
    
                            // ASN1_TIME'ı okunabilir formata çevirme
                            BIO* bio = BIO_new(BIO_s_mem());
                            ASN1_TIME_print(bio, notBefore);
                            char notBeforeStr[64] = {0};
                            BIO_read(bio, notBeforeStr, sizeof(notBeforeStr) - 1);
                            BIO_free(bio);
    
                            bio = BIO_new(BIO_s_mem());
                            ASN1_TIME_print(bio, notAfter);
                            char notAfterStr[64] = {0};
                            BIO_read(bio, notAfterStr, sizeof(notAfterStr) - 1);
                            BIO_free(bio);
    
                            std::cout << "Validity Start: " << notBeforeStr << std::endl;
                            std::cout << "Validity End: " << notAfterStr << std::endl;
    
                            // Sertifika geçerliliğini kontrol et
                            if (!is_certificate_valid(cert)) {
                                anomaly_detector.log_anomaly("Sertifika Geçerlilik Hatası", 0, 0, 0, 0, 0, time(NULL), "Unknown", "Unknown");
                            }
    
                            OPENSSL_free(subject);
                            OPENSSL_free(issuer);
                            X509_free(cert);
                        }
                        else {
                            std::cerr << "Failed to parse certificate: " << ERR_error_string(ERR_get_error(), NULL) << std::endl;
                            break;
                        }
    
                        if (p >= cert_data_end) {
                            break;
                        }
                    }
                    clientHelloFound = false; // Gelecek ClientHello için sıfırla
                }
            }
    
            time_t now = time(NULL);
            stream.timings.emplace_back(now, record_data.size());
    
            if (stream.timings.size() > 1) {
                auto& last = stream.timings[stream.timings.size() - 2];
                double delay = difftime(now, last.first);
                std::cout << "Delay since last packet: " << delay
                          << " seconds, Data Size: " << record_data.size()
                          << " bytes" << std::endl;
            }
        }
    }
    
    // parse_offset'u güncelle
    parse_offset = offset;
    

    }

    // Sertifika geçerlilik kontrol fonksiyonu bool PacketProcessor::is_certificate_valid(X509* cert) { time_t current_time = time(NULL); if (X509_cmp_time(X509_get_notBefore(cert), &current_time) > 0 || X509_cmp_time(X509_get_notAfter(cert), &current_time) < 0) { return false; } // Diğer geçerlilik kontrolleri eklenebilir return true; }

    // HTTP paketlerini ayrıştırma ve analiz etme fonksiyonu void PacketProcessor::analyze_http_packet(const std::vector& buffer, size_t& parse_offset, tcp_stream& stream) { std::cout << "analyze_http_packet çağrıldı. Buffer Boyutu: " << buffer.size() << ", Parse Offset: " << parse_offset << std::endl;

    // Basit HTTP ayrıştırma (isteğin tamamen burada olduğunu varsayar)
    if (parse_offset >= buffer.size()) {
        return;
    }
    
    std::string data_str(buffer.begin() + parse_offset, buffer.end());
    size_t end_of_headers = data_str.find("\r\n\r\n");
    if (end_of_headers != std::string::npos) {
        std::istringstream stream_data(data_str.substr(0, end_of_headers + 2));
    
        std::string request_line;
        std::getline(stream_data, request_line);
        if (request_line.find("GET") != std::string::npos) {
            size_t uri_start = request_line.find("GET") + 4;
            size_t uri_end = request_line.find("HTTP");
            if (uri_end > uri_start) {
                std::string uri = request_line.substr(uri_start, uri_end - uri_start - 1);
                std::cout << "HTTP GET Request URI: " << uri << std::endl;
                // Şüpheli URI kontrolü
                if (uri.find("malicious") != std::string::npos) {
                    anomaly_detector.log_anomaly("Şüpheli HTTP GET isteği", 0, 0, 0, 0, 0, time(NULL), "Unknown", "Unknown");
                }
            }
        }
    
        // parse_offset'u güncelle
        parse_offset += end_of_headers + 4;
    }
    

    }

    // UDP paketlerini ayrıştırma fonksiyonu void PacketProcessor::parse_udp(const std::vector& packet_data, std::ostream& output) { size_t offset = 0;

    // Ethernet başlığını atla (14 byte)
    if (packet_data.size() < 14) {
        std::cerr << "Insufficient data, cannot process Ethernet header." << std::endl;
        return;
    }
    offset += 14;
    
    if (packet_data.size() < offset + sizeof(ip_header) + sizeof(udp_header)) {
        std::cerr << "Insufficient data, cannot process UDP packet." << std::endl;
        return;
    }
    
    const ip_header* ip = reinterpret_cast<const ip_header*>(packet_data.data() + offset);
    offset += (ip->version_ihl & 0x0F) * 4;
    
    const udp_header* udp = reinterpret_cast<const udp_header*>(packet_data.data() + offset);
    offset += sizeof(udp_header);
    
    uint16_t source_port = ntohs(udp->source_port);
    uint16_t dest_port = ntohs(udp->dest_port);
    
    std::cerr << "UDP Source Port: " << source_port << ", Destination Port: " << dest_port << std::endl;
    
    std::vector<char> udp_data(packet_data.begin() + offset, packet_data.end());
    
    // Güvenli veri yazımı için kontrol ekleyebilirsiniz
    std::string udp_data_str(udp_data.begin(), udp_data.end());
    output << "UDP Data: " << udp_data_str << std::endl;
    

    }

    // process_packet fonksiyonunun tanımı void PacketProcessor::process_packet(const std::vector& packet_data, std::ostream& output, time_t timestamp) { size_t offset = 0;

    // Ethernet başlığını atla (14 byte)
    if (packet_data.size() < 14) {
        std::cerr << "Paket boyutu çok küçük, işlenemiyor." << std::endl;
        return;
    }
    offset += 14;
    
    if (packet_data.size() < offset + sizeof(ip_header)) {
        std::cerr << "Paket boyutu çok küçük, işlenemiyor." << std::endl;
        return;
    }
    
    const ip_header* ip = reinterpret_cast<const ip_header*>(packet_data.data() + offset);
    unsigned int ip_header_len = (ip->version_ihl & 0x0F) * 4;
    offset += ip_header_len;
    
    uint32_t source_ip = ip->source_address;
    uint32_t dest_ip = ip->destination_address;
    std::string source_ip_str = ip_to_string(source_ip);
    std::string dest_ip_str = ip_to_string(dest_ip);
    
    if (ip->protocol == IPPROTO_TCP) {
        if (packet_data.size() < offset + sizeof(tcp_header)) {
            std::cerr << "Paket TCP başlığını içermiyor." << std::endl;
            return;
        }
    
        const tcp_header* tcp = reinterpret_cast<const tcp_header*>(packet_data.data() + offset);
        unsigned int tcp_header_len = ((tcp->data_offset_reserved >> 4) & 0x0F) * 4;
        offset += tcp_header_len;
    
        uint16_t source_port = ntohs(tcp->source_port);
        uint16_t dest_port = ntohs(tcp->dest_port);
    
        if (packet_data.size() < offset) {
            std::cerr << "Paket TCP yükünü içermiyor." << std::endl;
            return;
        }
    
        std::vector<char> tcp_payload(packet_data.begin() + offset, packet_data.end());
    
        StreamKey key = {source_ip, dest_ip, source_port, dest_port};
    
        std::lock_guard<std::mutex> lock(stream_mutex);
        tcp_stream& stream = streams[key];
        stream.source_ip_str = source_ip_str;
        stream.dest_ip_str = dest_ip_str;
    
        uint32_t seq_num = ntohl(tcp->sequence_number);
    
        add_segment(stream, seq_num, tcp_payload);
    
        // Anomali tespiti için paketi işleyin
        anomaly_detector.process_packet(source_ip, dest_ip, source_port, dest_port, tcp_payload.size(), timestamp, source_ip_str, dest_ip_str);
    
        // Protokol ayrıştırma ve analiz işlemleri
        if (!stream.is_http && (source_port == 443 || dest_port == 443)) {
            analyze_tls_packet(stream.buffer, stream.parse_offset, stream);
        }
        else {
            analyze_http_packet(stream.buffer, stream.parse_offset, stream);
        }
    }
    else if (ip->protocol == IPPROTO_UDP) {
        parse_udp(packet_data, output);
    }
    else {
        std::cerr << "Desteklenmeyen protokol: " << static_cast<int>(ip->protocol) << std::endl;
    }
    

    }

    // Pcap dosyasını işleme fonksiyonu void PacketProcessor::process_pcap_file(const std::string& filename) { std::ifstream file(filename, std::ios::binary); if (!file) { std::cerr << "Could not open file: " << filename << std::endl; return; }

    pcap_global_header global_header;
    file.read(reinterpret_cast<char*>(&global_header), sizeof(global_header));
    if (file.gcount() != sizeof(global_header)) {
        std::cerr << "Incomplete global header." << std::endl;
        return;
    }
    
    // Check magic number for endianess
    bool is_little_endian = false;
    if (global_header.magic_number == 0xa1b2c3d4) {
        is_little_endian = false;
    }
    else if (global_header.magic_number == 0xd4c3b2a1) {
        is_little_endian = true;
    }
    else {
        std::cerr << "Invalid pcap file or unsupported format." << std::endl;
        return;
    }
    
    while (file) {
        pcap_packet_header packet_header;
        file.read(reinterpret_cast<char*>(&packet_header), sizeof(packet_header));
    
        if (file.gcount() != sizeof(packet_header)) {
            break; // İnce paket veya dosya sonu
        }
    
        // Convert header fields to host byte order if little endian
        if (is_little_endian) {
            packet_header.ts_sec = ntohl(packet_header.ts_sec);
            packet_header.ts_usec = ntohl(packet_header.ts_usec);
            packet_header.incl_len = ntohl(packet_header.incl_len);
            packet_header.orig_len = ntohl(packet_header.orig_len);
        }
    
        std::vector<char> packet_data(packet_header.incl_len);
        file.read(packet_data.data(), packet_header.incl_len);
        if (file.gcount() != packet_header.incl_len) {
            std::cerr << "Incomplete packet data." << std::endl;
            break;
        }
    
        time_t timestamp = packet_header.ts_sec;
    
        process_packet(packet_data, std::cout, timestamp);
    }
    

    }

    // ----------------------- AnomalyDetector Üye Fonksiyonlarının Tanımları -----------------------

    // Constructor PacketProcessor::AnomalyDetector::AnomalyDetector() { init_db(&db); }

    // Destructor PacketProcessor::AnomalyDetector::~AnomalyDetector() { if (db) sqlite3_close(db); }

    // log_anomaly fonksiyonu void PacketProcessor::AnomalyDetector::log_anomaly(const std::string& anomaly_type, uint32_t /source_ip/, uint32_t /dest_ip/, uint16_t /source_port/, uint16_t /dest_port/, size_t /packet_size/, time_t /timestamp/, const std::string& /src_ip_str/, const std::string& /dst_ip_str/) { std::cerr << "[Anomali Tespit Edildi] " << anomaly_type << std::endl; // Diğer uyarılar için benzer şekilde düzenleyebilirsiniz

    // JSON loglama
    json log_entry = {
        {"anomaly_type", anomaly_type},
        // Diğer alanlar burada dahil edilebilir
    };
    std::cout << log_entry.dump() << std::endl;
    
    // Veritabanına kaydetme kısmı...
    

    }

    void PacketProcessor::AnomalyDetector::process_packet(uint32_t source_ip, uint32_t dest_ip, uint16_t source_port, uint16_t dest_port, size_t packet_size, time_t timestamp, const std::string& src_ip_str, const std::string& dst_ip_str) { std::lock_guardstd::mutex lock(stat_mutex);

    // IP başına paket ve byte sayısını güncelle
    IPStat& stat = ip_stats[source_ip];
    stat.packet_count += 1;
    stat.byte_count += packet_size;
    stat.packet_times.emplace_back(timestamp, packet_size);
    
    // Eski paketleri temizle (örneğin 60 saniye öncesi)
    while (!stat.packet_times.empty() && difftime(timestamp, stat.packet_times.front().first) > 60) {
        stat.packet_count -= 1;
        stat.byte_count -= stat.packet_times.front().second;
        stat.packet_times.pop_front();
    }
    
    // Eşik kontrolü
    if (stat.packet_count > MAX_PACKETS_PER_IP) {
        log_anomaly("Yüksek paket sayısı", source_ip, dest_ip, source_port, dest_port, packet_size, timestamp, src_ip_str, dst_ip_str);
        reset_ip_stats(source_ip);
    }
    
    if (stat.byte_count > MAX_BYTES_PER_IP) {
        log_anomaly("Yüksek byte sayısı", source_ip, dest_ip, source_port, dest_port, packet_size, timestamp, src_ip_str, dst_ip_str);
        reset_ip_stats(source_ip);
    }
    
    // Şüpheli port kullanımı
    if (is_suspicious_port(source_port) || is_suspicious_port(dest_port)) {
        log_anomaly("Şüpheli port kullanımı", source_ip, dest_ip, source_port, dest_port, packet_size, timestamp, src_ip_str, dst_ip_str);
    }
    

    }

    void PacketProcessor::AnomalyDetector::init_db(sqlite3** db_ptr) { if (sqlite3_open("anomalies.db", db_ptr)) { std::cerr << "Cannot open database: " << sqlite3_errmsg(db_ptr) << std::endl; db_ptr = nullptr; } else { const char create_table_sql = "CREATE TABLE IF NOT EXISTS anomalies (" "id INTEGER PRIMARY KEY AUTOINCREMENT," "anomaly_type TEXT," "source_ip TEXT," "dest_ip TEXT," "source_port INTEGER," "dest_port INTEGER," "packet_size INTEGER," "timestamp TEXT);"; char errmsg = nullptr; if (sqlite3_exec(*db_ptr, create_table_sql, 0, 0, &errmsg) != SQLITE_OK) { std::cerr << "SQL error: " << errmsg << std::endl; sqlite3_free(errmsg); } } }

    bool PacketProcessor::AnomalyDetector::is_suspicious_port(uint16_t port) const { return SUSPICIOUS_PORTS.find(port) != SUSPICIOUS_PORTS.end(); }

    void PacketProcessor::AnomalyDetector::reset_ip_stats(uint32_t ip) { ip_stats[ip].packet_count = 0; ip_stats[ip].byte_count = 0; while (!ip_stats[ip].packet_times.empty()) ip_stats[ip].packet_times.pop_front(); }

    // ----------------------- Main Fonksiyon -----------------------

    int main(int argc, char* argv[]) { // OpenSSL'i başlat SSL_library_init(); OpenSSL_add_all_algorithms(); SSL_load_error_strings();

    // Argüman kontrolü
    if (argc < 2) {
        std::cerr << "Kullanım: " << argv[0] << " <pcap_dosyası>" << std::endl;
        return 1;
    }
    
    std::string pcap_file = argv[1];
    PacketProcessor packet_processor;
    packet_processor.process_pcap_file(pcap_file);
    
    // OpenSSL temizliği (opsiyonel)
    EVP_cleanup();
    ERR_free_strings();
    
    return 0;
    

    }

  2. Assistant

    Merhaba!

    Sorununuzu anlıyorum; yazdığınız DPI analizör kodunu Termux'ta çalıştırdığınızda, beklediğinizden daha az ve yetersiz bir çıktı alıyorsunuz. Ayrıca cxxdroid'de çalıştırdığınızda, program kullanım bilgisini gösterip bitiyor.

    Öncelikle, cxxdroid'de aldığınız çıktı:

    Kullanım: /data/user/0/ru.iiec.cxxdroid/files/iiec_tmp_binary <pcap_dosyası>
    
    [Program finished]
    

    Bu, programın bir pcap dosyası argümanı alması gerektiğini, ancak cxxdroid'de çalıştırırken bu argümanı sağlamadığınızı gösteriyor. Dolayısıyla, program kullanım bilgisini gösterip çıkıyor. Bunu düzeltmek için cxxdroid'de programı çalıştırırken pcap dosyası argümanını vermeniz gerekiyor.

    Termux'ta ise, programınız bir pcap dosyasıyla çalışıyor, ancak çıktı beklentilerinizi karşılamıyor. Çıktıda sadece bazı UDP paketlerine ait bilgiler var ve derinlemesine analiz yapılmamış görünüyor.

    Sorunun kaynağını bulmak ve çözümlemek için adım adım ilerleyelim.

    1. pcap Dosyasının Bağlantı Katmanı Tipi

    Programınızda pcap dosyasını işleyen ve paketleri ayrıştıran kodu incelediğimizde, Ethernet başlığını atlayarak ilerlediğini görüyoruz:

    // Ethernet başlığını atla (14 byte)
    if (packet_data.size() < 14) {
        std::cerr << "Paket boyutu çok küçük, işlenemiyor." << std::endl;
        return;
    }
    offset += 14;
    

    Burada, her paketin Ethernet başlığı içerdiği varsayılıyor. Ancak pcap dosyaları farklı bağlantı katmanı (link-layer) tiplerine sahip olabilir. pcap global başlığındaki network alanı (veya "data link type"), paketlerin hangi bağlantı katmanı protokolünü kullandığını belirtir.

    Eğer pcap dosyanız Ethernet değil de başka bir bağlantı katmanı kullanıyorsa (örneğin, Raw IP), programınız paketleri yanlış şekilde ayrıştırıyor olabilir, bu da yetersiz veya hatalı çıktılara neden olur.

    Çözüm:

    • pcap global başlığındaki network alanını okuyun ve bağlantı katmanı tipini belirleyin.
    • process_packet fonksiyonunda, bağlantı katmanı tipine göre paketlerin nasıl işleneceğini ayarlayın.

    Kodu nasıl güncelleyeceğinizi gösterelim:

    A. pcap Global Başlığındaki network Alanını Okuma ve Saklama

    process_pcap_file fonksiyonunda, global_header.network değerini bir değişkende saklayalım:

    uint32_t linktype = global_header.network;
    

    B. process_packet Fonksiyonunu Bağlantı Katmanı Tipine Göre Ayarlama

    process_packet fonksiyonuna linktype parametresini ekleyelim:

    void PacketProcessor::process_packet(const std::vector<char>& packet_data, std::ostream& output, time_t timestamp, uint32_t linktype) {
        size_t offset = 0;
    
        if (linktype == 1) { // DLT_EN10MB, Ethernet
            // Ethernet başlığını atla (14 byte)
            if (packet_data.size() < 14) {
                std::cerr << "Paket boyutu çok küçük, işlenemiyor." << std::endl;
                return;
            }
            offset += 14;
        } else if (linktype == 101) { // DLT_RAW, Raw IP
            // Ethernet başlığı yok, doğrudan IP başlığına geç
            offset += 0;
        } else if (linktype == 0) { // DLT_NULL
            // Loopback veya NULL başlığı (genellikle 4 bayt)
            if (packet_data.size() < 4) {
                std::cerr << "Paket boyutu çok küçük, işlenemiyor." << std::endl;
                return;
            }
            offset += 4;
        } else {
            std::cerr << "Desteklenmeyen link-layer tipi: " << linktype << std::endl;
            return;
        }
    
        // Devamında paket işleme kodu...
    }
    

    C. process_pcap_file Fonksiyonunda process_packet Çağrısını Güncelleme

    process_packet(packet_data, std::cout, timestamp, linktype);
    

    D. pcap Global Başlığındaki network Alanını Kontrol Etme

    Programınızın pcap dosyasının kullandığı bağlantı katmanı tipini doğru şekilde belirleyip belirlemediğini kontrol etmek için, network alanını çıktılayalım:

    std::cout << "Link-layer type: " << linktype << std::endl;
    

    2. Paket Başlıklarının Doğru Şekilde Okunması (Endianess Sorunu)

    pcap dosyaları farklı endianess (byte sıralaması) ile saklanabilirler. magic_number alanını kontrol ederek dosyanın byte sıralamasını belirliyoruz:

    • 0xa1b2c3d4: Big-endian
    • 0xd4c3b2a1: Little-endian

    Ancak, packet_header alanlarını işlerken endianess dönüşümünü doğru yapmalıyız. Şu anki kodda, endianess kontrolünde ntohl fonksiyonu kullanılıyor:

    if (is_little_endian) {
        packet_header.ts_sec = ntohl(packet_header.ts_sec);
        packet_header.ts_usec = ntohl(packet_header.ts_usec);
        packet_header.incl_len = ntohl(packet_header.incl_len);
        packet_header.orig_len = ntohl(packet_header.orig_len);
    }
    

    Bu kullanım hatalı çünkü ntohl ağ byte sıralamasından sistem sıralamasına dönüştürür, ancak ağ byte sıralaması genellikle big-endian'dır. Bu nedenle, endianess dönüşümü için özel fonksiyonlar kullanmalıyız.

    Çözüm:

    Endianess dönüşümünü yapmak için aşağıdaki gibi bir fonksiyon tanımlayabiliriz:

    uint32_t swap_uint32(uint32_t val) {
        return ((val & 0x000000FF) << 24) |
               ((val & 0x0000FF00) << 8)  |
               ((val & 0x00FF0000) >> 8)  |
               ((val & 0xFF000000) >> 24);
    }
    

    Sonra, pcap dosyasının endianess'ine göre paket başlıklarındaki alanları dönüştürürüz:

    if (is_little_endian) {
        // Dosya little-endian, sistem big-endian ise dönüştür
        packet_header.ts_sec = swap_uint32(packet_header.ts_sec);
        packet_header.ts_usec = swap_uint32(packet_header.ts_usec);
        packet_header.incl_len = swap_uint32(packet_header.incl_len);
        packet_header.orig_len = swap_uint32(packet_header.orig_len);
    } else {
        // Dosya big-endian, sistem little-endian ise dönüştür
    #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
        packet_header.ts_sec = swap_uint32(packet_header.ts_sec);
        packet_header.ts_usec = swap_uint32(packet_header.ts_usec);
        packet_header.incl_len = swap_uint32(packet_header.incl_len);
        packet_header.orig_len = swap_uint32(packet_header.orig_len);
    #endif
    }
    

    Bu sayede, paket başlıklarındaki alanları doğru şekilde okuyabiliriz.

    3. pcap Dosyasının Doğruluğunu Kontrol Etme

    pcap dosyanızın gerçekten beklediğiniz trafiği içerdiğinden emin olun. Örneğin, Wireshark gibi bir araçla pcap dosyasını açarak içerdiği paketleri inceleyin:

    • Paketlerin bağlantı katmanı tipini kontrol edin.
    • İçerdiği protokolleri kontrol edin (TCP, UDP, HTTP, TLS vb.).
    • Paketlerin sayısını ve türlerini inceleyin.

    Eğer pcap dosyanızda TCP paketleri yoksa veya analiz etmek istediğiniz protokoller bulunmuyorsa, programınız uygun çıktıları üretemez.

    4. UDP Paketlerini Ayrıntılı Analiz Etme

    Programınız UDP paketlerini sadece temel seviyede işliyor gibi görünüyor:

    void PacketProcessor::parse_udp(const std::vector<char>& packet_data, std::ostream& output) {
        // UDP başlığını ayrıştırma ve temel verileri yazdırma
    }
    

    Eğer UDP paketlerinin içerdiği protokolleri (örneğin, DNS, QUIC) daha ayrıntılı olarak analiz etmek istiyorsanız, ilgili protokollerin ayrıştırma fonksiyonlarını yazmanız gerekiyor.

    Örneğin, DNS paketlerini analiz etmek için:

    • UDP yükünü DNS mesajı olarak ayrıştırın.
    • DNS sorgularını ve yanıtlarını analiz edin.
    • Şüpheli etkinlikleri tespit edin.

    5. Hata ve Uyarı Mesajlarını Kontrol Etme

    Programınız çalışırken std::cerr kullanarak hata mesajları yazdırıyor. Termux'ta programı çalıştırırken bu hata mesajlarını görebiliyor musunuz?

    Yapmanız gerekenler:

    • Programı çalıştırırken standart hata çıktısını (stderr) görmek için konsolu kontrol edin.
    • Hata mesajları varsa, bunları dikkate alın ve sorunu gidermeye çalışın.

    6. Daha Fazla Loglama ve Hata Ayıklama Bilgisi Ekleme

    Programınıza daha fazla loglama ve hata ayıklama çıktısı ekleyerek, programın hangi aşamada sorun yaşadığını tespit edebilirsiniz.

    Örneğin:

    • Paketlerin sırasıyla hangi aşamalardan geçtiğini yazdırın.
    • Her paketin başlangıcında ve sonunda loglama yapın.
    • Değişkenlerin değerlerini ve durumlarını yazdırın.

    Sonuç

    Sorunun büyük olasılıkla pcap dosyasının bağlantı katmanı tipi ve endianess ile ilgili olduğunu düşünüyorum. Programınızı yukarıdaki öneriler doğrultusunda güncelleyerek, Termux'ta doğru şekilde çalışmasını sağlayabilirsiniz.

    Özetle yapılması gerekenler:

    1. pcap dosyasının network alanını okuyarak, bağlantı katmanı tipini belirleyin ve paketleri buna göre işleyin.
    2. Endianess dönüşümlerini doğru şekilde yapın.
    3. pcap dosyasını kontrol edin ve beklediğiniz protokolleri içerdiğinden emin olun.
    4. UDP paketlerini daha ayrıntılı analiz etmek istiyorsanız, ilgili protokoller için ayrıştırma fonksiyonları ekleyin.
    5. Hata ve uyarı mesajlarını kontrol edin.
    6. Daha fazla loglama ve hata ayıklama çıktısı ekleyin.

    Umarım bu bilgiler sorununuzu çözmek için yardımcı olur. Daha fazla sorunuz olursa lütfen sormaktan çekinmeyin!