2022-03-24 02:29:11 +01:00
|
|
|
#pragma once
|
2015-03-21 11:47:25 +01:00
|
|
|
|
2022-06-26 16:10:12 +02:00
|
|
|
#include "fastnetmon_types.hpp"
|
2015-03-21 12:24:31 +01:00
|
|
|
|
2022-02-09 15:27:32 +01:00
|
|
|
#include <iostream>
|
|
|
|
#include <map>
|
|
|
|
#include <sstream>
|
|
|
|
#include <string>
|
2022-06-26 16:10:12 +02:00
|
|
|
|
2015-03-21 12:24:31 +01:00
|
|
|
#include <utility>
|
2022-02-09 15:27:32 +01:00
|
|
|
#include <vector>
|
2015-03-21 12:24:31 +01:00
|
|
|
|
|
|
|
#include <boost/thread.hpp>
|
2022-05-20 16:20:10 +02:00
|
|
|
#include "nlohmann/json.hpp"
|
|
|
|
|
2022-05-24 14:57:09 +02:00
|
|
|
#include "libpatricia/patricia.hpp"
|
2015-05-18 12:38:19 +02:00
|
|
|
|
2022-03-13 23:09:35 +01:00
|
|
|
#include "fastnetmon_networks.hpp"
|
|
|
|
|
2023-07-10 15:50:04 +02:00
|
|
|
#include "attack_details.hpp"
|
|
|
|
|
2015-05-07 11:48:43 +02:00
|
|
|
#define TCP_FIN_FLAG_SHIFT 1
|
|
|
|
#define TCP_SYN_FLAG_SHIFT 2
|
|
|
|
#define TCP_RST_FLAG_SHIFT 3
|
|
|
|
#define TCP_PSH_FLAG_SHIFT 4
|
|
|
|
#define TCP_ACK_FLAG_SHIFT 5
|
|
|
|
#define TCP_URG_FLAG_SHIFT 6
|
|
|
|
|
2015-05-10 20:42:49 +02:00
|
|
|
typedef std::map<std::string, uint64_t> graphite_data_t;
|
2015-05-11 17:50:01 +02:00
|
|
|
typedef std::vector<std::string> interfaces_list_t;
|
|
|
|
typedef std::vector<std::string> ip_addresses_list_t;
|
|
|
|
|
2015-08-10 12:05:53 +02:00
|
|
|
ip_addresses_list_t get_local_ip_v4_addresses_list();
|
2023-04-02 21:27:05 +02:00
|
|
|
ip_addresses_list_t get_ip_list_for_interface(const std::string& interface_name);
|
2015-05-11 17:50:01 +02:00
|
|
|
interfaces_list_t get_interfaces_list();
|
2015-05-10 20:42:49 +02:00
|
|
|
|
|
|
|
bool store_data_to_graphite(unsigned short int graphite_port, std::string graphite_host, graphite_data_t graphite_data);
|
2015-03-21 12:24:31 +01:00
|
|
|
std::string get_protocol_name_by_number(unsigned int proto_number);
|
|
|
|
uint64_t convert_speed_to_mbps(uint64_t speed_in_bps);
|
2023-02-27 00:29:01 +01:00
|
|
|
bool exec(const std::string& cmd, std::vector<std::string>& output_list, std::string& error_text);
|
2015-03-21 12:24:31 +01:00
|
|
|
std::string convert_ip_as_uint_to_string(uint32_t ip_as_integer);
|
|
|
|
std::string convert_int_to_string(int value);
|
2022-03-25 20:34:29 +01:00
|
|
|
std::string print_ipv6_address(const struct in6_addr& ipv6_address);
|
2022-02-11 13:38:08 +01:00
|
|
|
std::string print_simple_packet(simple_packet_t packet);
|
2022-05-24 14:52:24 +02:00
|
|
|
std::string convert_timeval_to_date(const timeval& tv);
|
2018-09-28 17:59:49 +02:00
|
|
|
bool convert_hex_as_string_to_uint(std::string hex, uint32_t& value);
|
2015-06-15 11:14:30 +02:00
|
|
|
|
2015-03-21 12:24:31 +01:00
|
|
|
int extract_bit_value(uint8_t num, int bit);
|
2015-06-15 11:14:30 +02:00
|
|
|
int extract_bit_value(uint16_t num, int bit);
|
|
|
|
|
|
|
|
int clear_bit_value(uint8_t& num, int bit);
|
|
|
|
int clear_bit_value(uint16_t& num, int bit);
|
|
|
|
|
|
|
|
int set_bit_value(uint8_t& num, int bit);
|
|
|
|
int set_bit_value(uint16_t& num, int bit);
|
|
|
|
|
2015-03-21 12:24:31 +01:00
|
|
|
std::string print_tcp_flags(uint8_t flag_value);
|
2015-05-15 12:55:52 +02:00
|
|
|
uint64_t MurmurHash64A(const void* key, int len, uint64_t seed);
|
2015-03-21 12:24:31 +01:00
|
|
|
std::string print_tcp_flags(uint8_t flag_value);
|
2015-05-15 12:55:52 +02:00
|
|
|
int timeval_subtract(struct timeval* result, struct timeval* x, struct timeval* y);
|
2015-03-21 12:24:31 +01:00
|
|
|
bool folder_exists(std::string path);
|
2018-08-03 00:53:47 +02:00
|
|
|
bool is_cidr_subnet(std::string subnet);
|
2015-10-16 12:16:46 +02:00
|
|
|
bool is_v4_host(std::string host);
|
2015-03-21 12:24:31 +01:00
|
|
|
bool file_exists(std::string path);
|
|
|
|
uint32_t convert_cidr_to_binary_netmask(unsigned int cidr);
|
|
|
|
std::string get_printable_protocol_name(unsigned int protocol);
|
|
|
|
std::string get_net_address_from_network_as_string(std::string network_cidr_format);
|
|
|
|
std::string print_time_t_in_fastnetmon_format(time_t current_time);
|
|
|
|
unsigned int get_cidr_mask_from_network_as_string(std::string network_cidr_format);
|
2015-03-21 11:47:25 +01:00
|
|
|
int convert_string_to_integer(std::string line);
|
|
|
|
|
2015-09-24 01:23:38 +02:00
|
|
|
bool print_pid_to_file(pid_t pid, std::string pid_path);
|
2015-05-02 22:53:45 +02:00
|
|
|
bool read_pid_from_file(pid_t& pid, std::string pid_path);
|
|
|
|
|
2022-04-20 22:45:43 +02:00
|
|
|
direction_t get_packet_direction(patricia_tree_t* lookup_tree, uint32_t src_ip, uint32_t dst_ip, subnet_cidr_mask_t& subnet);
|
2015-06-28 22:29:40 +02:00
|
|
|
|
2022-04-20 22:45:43 +02:00
|
|
|
direction_t
|
|
|
|
get_packet_direction_ipv6(patricia_tree_t* lookup_tree, struct in6_addr src_ipv6, struct in6_addr dst_ipv6, subnet_ipv6_cidr_mask_t& subnet);
|
2015-08-10 12:58:17 +02:00
|
|
|
|
2015-05-18 12:38:19 +02:00
|
|
|
std::string convert_prefix_to_string_representation(prefix_t* prefix);
|
2022-03-19 20:58:07 +01:00
|
|
|
std::string convert_subnet_to_string(subnet_cidr_mask_t my_subnet);
|
2022-03-13 16:18:21 +01:00
|
|
|
std::string get_direction_name(direction_t direction_value);
|
2022-02-09 15:27:32 +01:00
|
|
|
std::vector<std::string> split_strings_to_vector_by_comma(std::string raw_string);
|
2023-04-03 18:02:02 +02:00
|
|
|
bool convert_subnet_from_string_to_binary_with_cidr_format_safe(const std::string& subnet_cidr, subnet_cidr_mask_t& subnet_cidr_mask);
|
2015-05-18 12:38:19 +02:00
|
|
|
|
2015-06-30 11:46:49 +02:00
|
|
|
#ifdef __linux__
|
|
|
|
bool manage_interface_promisc_mode(std::string interface_name, bool switch_on);
|
2023-04-03 13:43:52 +02:00
|
|
|
bool get_interface_number_by_device_name(int socket_fd, std::string interface_name, int& interface_number);
|
2015-06-30 11:46:49 +02:00
|
|
|
#endif
|
|
|
|
|
2022-03-24 02:23:56 +01:00
|
|
|
bool ip_belongs_to_patricia_tree_ipv6(patricia_tree_t* patricia_tree, struct in6_addr client_ipv6_address);
|
2023-07-09 17:57:23 +02:00
|
|
|
std::string serialize_attack_description(const attack_details_t& current_attack);
|
|
|
|
attack_type_t detect_attack_type(const attack_details_t& current_attack);
|
2015-08-12 16:19:15 +02:00
|
|
|
std::string get_printable_attack_name(attack_type_t attack);
|
2022-06-26 16:51:31 +02:00
|
|
|
std::string serialize_network_load_to_text(subnet_counter_t& network_speed_meter, bool average);
|
2015-08-12 16:19:15 +02:00
|
|
|
|
2015-09-25 23:24:50 +02:00
|
|
|
std::string dns_lookup(std::string domain_name);
|
|
|
|
bool store_data_to_stats_server(unsigned short int graphite_port, std::string graphite_host, std::string buffer_as_string);
|
|
|
|
|
2022-06-11 21:41:07 +02:00
|
|
|
bool set_boost_process_name(boost::thread* thread, const std::string& process_name);
|
2022-04-20 22:45:43 +02:00
|
|
|
std::string convert_subnet_to_string(subnet_cidr_mask_t my_subnet);
|
2022-02-20 01:19:29 +01:00
|
|
|
|
2022-04-20 22:45:43 +02:00
|
|
|
std::string print_ipv6_cidr_subnet(subnet_ipv6_cidr_mask_t subnet);
|
2023-07-08 16:08:11 +02:00
|
|
|
std::string convert_any_ip_to_string(const subnet_ipv6_cidr_mask_t& subnet);
|
2022-03-24 02:29:11 +01:00
|
|
|
bool convert_string_to_positive_integer_safe(std::string line, int& value);
|
2022-03-25 14:40:29 +01:00
|
|
|
bool read_ipv6_host_from_string(std::string ipv6_host_as_string, in6_addr& result);
|
2022-03-25 20:34:29 +01:00
|
|
|
bool validate_ipv6_or_ipv4_host(const std::string host);
|
2022-03-28 15:58:01 +02:00
|
|
|
uint64_t get_current_unix_time_in_nanoseconds();
|
|
|
|
|
|
|
|
bool write_data_to_influxdb(std::string database,
|
|
|
|
std::string host,
|
|
|
|
std::string port,
|
|
|
|
bool enable_auth,
|
|
|
|
std::string influx_user,
|
|
|
|
std::string influx_password,
|
|
|
|
std::string query);
|
|
|
|
|
|
|
|
std::string join_by_comma_and_equal(std::map<std::string, std::string>& data);
|
2022-06-19 22:05:45 +02:00
|
|
|
bool parse_meminfo_into_map(std::map<std::string, uint64_t>& parsed_meminfo);
|
|
|
|
bool read_uint64_from_string(const std::string& line, uint64_t& value);
|
|
|
|
bool read_integer_from_file(const std::string& file_path, int& value);
|
|
|
|
bool read_file_to_string(const std::string& file_path, std::string& file_content);
|
|
|
|
bool convert_string_to_any_integer_safe(const std::string& line, int& value);
|
2022-10-02 12:09:22 +02:00
|
|
|
void exec_no_error_check(const std::string& cmd);
|
|
|
|
bool parse_os_release_into_map(std::map<std::string, std::string>& parsed_os_release);
|
2022-10-02 12:13:56 +02:00
|
|
|
unsigned int get_logical_cpus_number();
|
|
|
|
std::string get_virtualisation_method();
|
|
|
|
bool get_cpu_flags(std::vector<std::string>& flags);
|
|
|
|
bool get_linux_distro_name(std::string& distro_name);
|
|
|
|
bool get_linux_distro_version(std::string& distro_name);
|
|
|
|
bool get_kernel_version(std::string& kernel_version);
|
2022-10-04 20:08:13 +02:00
|
|
|
bool execute_web_request(const std::string& address_param,
|
|
|
|
const std::string& request_type,
|
|
|
|
const std::string& post_data,
|
|
|
|
uint32_t& response_code,
|
|
|
|
std::string& response_body,
|
|
|
|
const std::map<std::string, std::string>& headers,
|
|
|
|
std::string& error_text);
|
|
|
|
unsigned int get_total_memory();
|
|
|
|
std::string get_cpu_model();
|
2022-10-12 20:12:12 +02:00
|
|
|
bool execute_web_request_secure(std::string address,
|
|
|
|
std::string request_type,
|
|
|
|
std::string post_data,
|
|
|
|
uint32_t& response_code,
|
|
|
|
std::string& response_body,
|
|
|
|
std::map<std::string, std::string>& headers,
|
|
|
|
std::string& error_text);
|
2023-02-04 22:57:22 +01:00
|
|
|
std::string forwarding_status_to_string(forwarding_status_t status);
|
|
|
|
std::string country_static_string_to_dynamic_string(const boost::beast::static_string<2>& country_code);
|
2023-02-05 21:14:44 +01:00
|
|
|
bool serialize_simple_packet_to_json(const simple_packet_t& packet, nlohmann::json& json_packet);
|
2023-02-27 21:30:53 +01:00
|
|
|
bool convert_ip_as_string_to_uint_safe(const std::string& ip, uint32_t& ip_as_integer);
|
2023-07-03 15:08:27 +02:00
|
|
|
forwarding_status_t forwarding_status_from_integer(uint8_t forwarding_status_as_integer);
|
2023-07-03 18:08:37 +02:00
|
|
|
bool is_zero_ipv6_address(const in6_addr& ipv6_address);
|
2023-07-08 14:34:08 +02:00
|
|
|
std::string convert_ipv4_subnet_to_string(const subnet_cidr_mask_t& subnet);
|
2023-07-08 16:08:11 +02:00
|
|
|
|
|
|
|
// Represent IPv6 subnet in string form
|
|
|
|
std::string convert_ipv6_subnet_to_string(const subnet_ipv6_cidr_mask_t& subnet);
|
|
|
|
std::string convert_any_ip_to_string(uint32_t client_ip);
|
2023-07-08 17:33:34 +02:00
|
|
|
bool lookup_ip_in_integer_form_inpatricia_and_return_subnet_if_found(patricia_tree_t* patricia_tree,
|
|
|
|
uint32_t client_ip,
|
|
|
|
subnet_cidr_mask_t& subnet);
|
2023-07-09 19:20:53 +02:00
|
|
|
bool ip_belongs_to_patricia_tree(patricia_tree_t* patricia_tree, uint32_t client_ip);
|