Commit 484606bd authored by Filip Bartek's avatar Filip Bartek
Browse files

first version of filters

parent e5969d2b

hw03/capture.c

+114 −45
Original line number Diff line number Diff line
@@ -224,18 +224,7 @@ int filter_sanitize_input(const struct capture_t *const original, 
    return 0;

}



int filter_protocol(

        const struct capture_t *const original,

        struct capture_t *filtered,

        uint8_t protocol)

{

    if (filter_sanitize_input(original, filtered) == -1) {

        return -1;

    }



    struct node *current_node = original->packets->head;

    while (current_node != NULL) {

        if (current_node->data->ip_header->protocol == protocol) {

int create_new_node(struct capture_t *filtered, struct node *current_node) {

    struct packet_t *new_packet = malloc(sizeof(struct packet_t));

    if (new_packet == NULL) {

        destroy_capture(filtered);
@@ -264,6 +253,24 @@ int filter_protocol( 
        filtered->packets->tail->next = new_node;

        filtered->packets->tail = new_node;

    }

    return 0;

}



int filter_protocol(

        const struct capture_t *const original,

        struct capture_t *filtered,

        uint8_t protocol)

{

    if (filter_sanitize_input(original, filtered) == -1) {

        return -1;

    }



    struct node *current_node = original->packets->head;

    while (current_node != NULL) {

        if (current_node->data->ip_header->protocol == protocol) {

            if (create_new_node(filtered, current_node) == -1) {

                return -1;

            }

        }

        current_node = current_node->next;

    }
@@ -275,11 +282,30 @@ int filter_larger_than( 
        struct capture_t *filtered,

        uint32_t size)

{

    UNUSED(original);

    UNUSED(filtered);

    UNUSED(size);

    if (filter_sanitize_input(original, filtered) == -1) {

        return -1;

    }



    struct node *current_node = original->packets->head;

    while (current_node != NULL) {

        if (current_node->data->packet_header->orig_len >= size) {

            if (create_new_node(filtered, current_node) == -1) {

                return -1;

            }

        }

        current_node = current_node->next;

    }

    return 0;

}



bool ip_address_equals(uint8_t first[4], uint8_t second[4]) {

    for (int i = 0; i < 4; ++i) {

        if (first[i] != second[i]) {

            return false;

        }

    }

    return true;

}



int filter_from_to(

        const struct capture_t *const original,
@@ -287,12 +313,37 @@ int filter_from_to( 
        uint8_t source_ip[4],

        uint8_t destination_ip[4])

{

    UNUSED(original);

    UNUSED(filtered);

    UNUSED(source_ip);

    UNUSED(destination_ip);

    if (filter_sanitize_input(original, filtered) == -1) {

        return -1;

    }



    struct node *current_node = original->packets->head;

    while (current_node != NULL) {

        if (ip_address_equals(current_node->data->ip_header->src_addr, source_ip) &&

        ip_address_equals(current_node->data->ip_header->dst_addr, destination_ip)) {

            if (create_new_node(filtered, current_node) == -1) {

                return -1;

            }

        }

        current_node = current_node->next;

    }

    return 0;

}



bool mask_conforms(const uint8_t ip[4], const uint8_t network_prefix[4], uint8_t mask_length) {

    uint32_t mask = 0xFFFF << (32 - mask_length);

    uint32_t ip_address = 0x0000;

    for (int i = 0; i < 4; ++i) {

        ip_address <<= 8;

        ip_address |= ip[i];

    }

    uint32_t network = 0x0000;

    for (int i = 0; i < 4; ++i) {

        network <<= 8;

        network |= network_prefix[i];

    }

    return (ip_address & mask) == (network & mask);

}



int filter_from_mask(

        const struct capture_t *const original,
@@ -300,12 +351,21 @@ int filter_from_mask( 
        uint8_t network_prefix[4],

        uint8_t mask_length)

{

    UNUSED(original);

    UNUSED(filtered);

    UNUSED(network_prefix);

    UNUSED(mask_length);

    if (filter_sanitize_input(original, filtered) == -1) {

        return -1;

    }



    struct node *current_node = original->packets->head;

    while (current_node != NULL) {

        if (mask_conforms(current_node->data->ip_header->src_addr, network_prefix, mask_length)) {

            if (create_new_node(filtered, current_node) == -1) {

                return -1;

            }

        }

        current_node = current_node->next;

    }

    return 0;

}



int filter_to_mask(

        const struct capture_t *const original,
@@ -313,13 +373,22 @@ int filter_to_mask( 
        uint8_t network_prefix[4],

        uint8_t mask_length)

{

    UNUSED(original);

    UNUSED(filtered);

    UNUSED(network_prefix);

    UNUSED(mask_length);

    if (filter_sanitize_input(original, filtered) == -1) {

        return -1;

    }



    struct node *current_node = original->packets->head;

    while (current_node != NULL) {

        if (mask_conforms(current_node->data->ip_header->dst_addr, network_prefix, mask_length)) {

            if (create_new_node(filtered, current_node) == -1) {

                return -1;

            }

        }

        current_node = current_node->next;

    }

    return 0;

}



int print_flow_stats(const struct capture_t *const capture)

{

    UNUSED(capture);

hw03/capture.h

+12 −0
Original line number Diff line number Diff line
@@ -20,6 +20,18 @@ struct capture_t { 
    struct list *packets;

};



struct ip_node {

    struct ip_node *prev;

    struct ip_node *next;

    uint8_t *src[4];

    uint8_t *dst[4];

};



struct ip_list {

    struct ip_node *head;

    struct ip_node *tail;

};





/**

 * @brief Loads entire capture from a pcap file

hw03/nft.c

+18 −11
Original line number Diff line number Diff line
@@ -2,26 +2,33 @@ 


#include "capture.h"



#define MY_DUMP "../mydump.pcap"

#define TEST_FILE "../test.pcap"



int main()

{

    struct capture_t capture[1];

    load_capture(capture, TEST_FILE);



    struct capture_t filtered[1];

    filtered->header = NULL;

    filtered->packets = NULL;

    filter_protocol(capture, filtered, 6);



//    struct capture_t capture[1];

//    load_capture(capture, MY_DUMP);

//

//    struct capture_t filtered[1];

//    filtered->header = NULL;

//    filtered->packets = NULL;

//    filter_protocol(capture, filtered, 17);

//    filter_larger_than(capture, filtered, 1514);

//    filter_from_to(capture, filtered, (uint8_t[4]){172U, 31U, 19U, 73U}, (uint8_t[4]){172U, 31U, 19U, 255U});

//    filter_from_mask(capture, filtered, (uint8_t[4]){127U, 147U, 200U, 0U}, 16);

//    filter_to_mask(capture, filtered, (uint8_t[4]){239U, 255U, 0U, 0U}, 16);

//

//    struct node *current_node = filtered->packets->head;

//    while (current_node != NULL) {

//        print_packet_info(current_node->data);

//        current_node = current_node->next;

//    }



    destroy_capture(capture);

    destroy_capture(filtered);

//

//    printf("------\n%zu", packet_count(filtered));

//

//    destroy_capture(capture);

//    destroy_capture(filtered);



    return 0;

}