321 lines
12 KiB
C++
321 lines
12 KiB
C++
/*
|
|
This file contains functions to load and process settings from the settings file.
|
|
|
|
Functions:
|
|
- load_settings(): This function loads the settings from the settings file.
|
|
- get_setting(): This function returns the value of a setting.
|
|
- get_setting_string(): This function returns the value of a setting as a string.
|
|
- load_included_folders(): This function loads the included folders from the included folders file.
|
|
- load_excluded_folders(): This function loads the excluded folders from the excluded folders file.
|
|
- load_disallowed_start_folders(): This function loads the disallowed start folders from the disallowed start folders file.
|
|
- is_folder_included(): This function checks if a folder is included in the included folders.
|
|
- is_folder_excluded(): This function checks if a folder is excluded in the excluded folders.
|
|
- is_disallowed_start_folder(): This function checks if a folder is disallowed in the disallowed start folders.
|
|
- print_inclusions(): This function prints the included folders.
|
|
- log_timeout_get(): This function gets the log timeout.
|
|
- log_timeout_set(): This function sets the log timeout.
|
|
- log_timeout_reset_set(): This function sets the log timeout reset.
|
|
- log_timeout_reset_get(): This function gets the log timeout reset.
|
|
|
|
*/
|
|
|
|
#ifndef SETTINGS_CPP
|
|
#define SETTINGS_CPP
|
|
|
|
#include "settings.h"
|
|
#include "well_known.h"
|
|
#include "log.h"
|
|
#include "utils.h"
|
|
#include <mutex> // Include the mutex header
|
|
|
|
// Define mutexes for thread synchronization
|
|
std::mutex settingsMutex;
|
|
std::mutex logMutex;
|
|
|
|
int setting_virus_ctrl_virus_found_action = 0;
|
|
std::string setting_server_server_url = "nan";
|
|
std::string excluded_folders[1000];
|
|
int excluded_folders_size = 0;
|
|
std::string included_folders[1000];
|
|
int included_folders_size = 0;
|
|
std::string disallowed_start_folders[1000];
|
|
int disallowed_start_folders_size = 0;
|
|
bool setting_rtp_folder_scan_status = true; // 0=off, 1=on
|
|
bool setting_rtp_folder_scan_use_deepscan = true; // 0=off, 1=on
|
|
bool setting_rtp_process_scan_use_deepscan = true; // 0=off, 1=on
|
|
bool setting_rtp_process_scan_status = true; // 0=off, 1=on
|
|
bool setting_virus_ctrl_virus_process_found_kill = true; // 0=do not kill, 1=kill
|
|
bool setting_ac_status = true; // 0=off, 1=on
|
|
bool setting_communication_unsafe_tls = false; // 0=do not allow communication via unsafe, self-signed certs, 1=allow communication via unsafe, self-signed certs
|
|
int srv_log_timeout = 0;
|
|
int log_timeout_reset = 0;
|
|
|
|
void load_included_folders();
|
|
void load_excluded_folders();
|
|
void load_disallowed_start_folders();
|
|
|
|
int load_settings() {
|
|
std::ifstream file(SETTINGS_DB);
|
|
|
|
if (!file.is_open()) {
|
|
log(LOGLEVEL::ERR, "[load_settings()]: Could not open settings file. ", SETTINGS_DB);
|
|
setting_server_server_url = "nan";
|
|
return 1;
|
|
}
|
|
|
|
std::string settings_cmd, settings_arg;
|
|
file>>settings_cmd;//the firs tline is our cert, which is used to determine if we can trust this file. This trust check has already been done after the file has been downloaded from the server
|
|
while (file >> settings_cmd) {
|
|
file >> settings_arg;
|
|
|
|
// Process settings
|
|
if (settings_cmd == "virus_ctrl:virus_found:action") {
|
|
if (settings_arg == "remove") {
|
|
setting_virus_ctrl_virus_found_action = 1;
|
|
}
|
|
else if (settings_arg == "quarantine") {
|
|
setting_virus_ctrl_virus_found_action = 2;
|
|
}
|
|
else if (settings_arg == "ignore") {
|
|
setting_virus_ctrl_virus_found_action = 3;
|
|
}
|
|
else if (settings_arg == "call_srv") {
|
|
setting_virus_ctrl_virus_found_action = 4;
|
|
}
|
|
}
|
|
else if (settings_cmd == "server:server_url") {
|
|
setting_server_server_url = settings_arg;
|
|
}
|
|
else if (settings_cmd == "rtp_folder_scan:status") {
|
|
setting_rtp_folder_scan_status = (settings_arg == "true");
|
|
}
|
|
else if (settings_cmd == "rtp_process_scan:status") {
|
|
setting_rtp_process_scan_status = (settings_arg == "true");
|
|
}
|
|
else if (settings_cmd == "rtp_process_scan:use_deepscan") {
|
|
setting_rtp_process_scan_use_deepscan = (settings_arg == "true");
|
|
}
|
|
else if (settings_cmd == "rtp_folder_scan:use_deepscan") {
|
|
setting_rtp_folder_scan_use_deepscan = (settings_arg == "true");
|
|
}
|
|
else if (settings_cmd == "communication:unsafe_tls") {
|
|
setting_communication_unsafe_tls = (settings_arg == "allow");
|
|
}
|
|
else if (settings_cmd == "application_control:status") {
|
|
setting_ac_status = (settings_arg == "true");
|
|
}
|
|
else if (settings_cmd == "virus_ctrl:virus_process_found:kill") {
|
|
setting_virus_ctrl_virus_process_found_kill = (settings_arg == "true");
|
|
}
|
|
}
|
|
|
|
file.close();
|
|
|
|
// Load included and excluded folders (=for RTP)
|
|
load_included_folders();
|
|
load_excluded_folders();
|
|
// Load disallowed start folders (=folders from where no app is allowed to start)
|
|
load_disallowed_start_folders();
|
|
|
|
return 0;
|
|
}
|
|
|
|
// We have two different get_setting functions. One for int and one for std::string return values
|
|
//return the settings which are integer based
|
|
int get_setting(const std::string& setting_name) {
|
|
std::lock_guard<std::mutex> lock(settingsMutex);
|
|
|
|
if (setting_name == "virus_ctrl:virus_found:action") {
|
|
return setting_virus_ctrl_virus_found_action;
|
|
}
|
|
if (setting_name == "virus_ctrl:virus_process_found:kill") {
|
|
return setting_virus_ctrl_virus_process_found_kill;
|
|
}
|
|
else if (setting_name == "rtp_folder_scan:status") {
|
|
return setting_rtp_folder_scan_status;
|
|
}
|
|
else if (setting_name == "rtp_process_scan:status") {
|
|
return setting_rtp_process_scan_status;
|
|
}
|
|
else if (setting_name == "rtp_process_scan:use_deepscan") {
|
|
return setting_rtp_process_scan_use_deepscan;
|
|
}
|
|
else if (setting_name == "rtp_folder_scan:use_deepscan") {
|
|
return setting_rtp_folder_scan_use_deepscan;
|
|
}
|
|
else if (setting_name == "communication:unsafe_tls") {
|
|
return setting_communication_unsafe_tls;
|
|
}
|
|
else if (setting_name == "application_control:status") {
|
|
return setting_ac_status;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
//return the settings which are string based
|
|
std::string get_setting_string(const std::string& setting_name) {
|
|
std::lock_guard<std::mutex> lock(settingsMutex);
|
|
|
|
if (setting_name == "server:server_url") {
|
|
return setting_server_server_url;
|
|
}
|
|
|
|
return "nan";
|
|
}
|
|
|
|
void load_included_folders() {
|
|
std::lock_guard<std::mutex> lock(settingsMutex);
|
|
|
|
std::ifstream file(INCLUDED_FOLDERS);
|
|
|
|
if (!file.is_open()) {
|
|
log(LOGLEVEL::ERR, "[load_included_files()]: Could not open included folders file. ", INCLUDED_FOLDERS);
|
|
return;
|
|
}
|
|
|
|
//the paths are stored as follows in the file "<path>", so we have to parse the text between "" to get the path
|
|
std::string line;
|
|
std::getline(file, line); // Skip the first line, because it is the certificate
|
|
while (std::getline(file, line)) {
|
|
size_t start_pos = line.find('"'); // Find the position of the first double quote
|
|
if (start_pos != std::string::npos) {
|
|
size_t end_pos = line.find('"', start_pos + 1); // Find the position of the second double quote
|
|
if (end_pos != std::string::npos) {
|
|
std::string path = line.substr(start_pos + 1, end_pos - start_pos - 1); // Extract the path between double quotes
|
|
included_folders[included_folders_size++] = to_lower(path);
|
|
}
|
|
}
|
|
}
|
|
|
|
file.close();
|
|
}
|
|
|
|
// Load the excluded folders from the excluded folders file, works the same as load_included_folders
|
|
void load_excluded_folders() {
|
|
std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables
|
|
|
|
std::ifstream file(EXCLUDED_FOLDERS);
|
|
|
|
if (!file.is_open()) {
|
|
log(LOGLEVEL::ERR, "[load_included_files()]: Could not open excluded folders file. ", INCLUDED_FOLDERS);
|
|
return;
|
|
}
|
|
|
|
std::string line;
|
|
std::getline(file, line); // Skip the first line
|
|
while (std::getline(file, line)) {
|
|
size_t start_pos = line.find('"'); // Find the position of the first double quote
|
|
if (start_pos != std::string::npos) {
|
|
size_t end_pos = line.find('"', start_pos + 1); // Find the position of the second double quote
|
|
if (end_pos != std::string::npos) {
|
|
std::string path = line.substr(start_pos + 1, end_pos - start_pos - 1); // Extract the path between double quotes
|
|
excluded_folders[excluded_folders_size++] = to_lower(path);
|
|
}
|
|
}
|
|
}
|
|
|
|
file.close();
|
|
}
|
|
|
|
// Load the disallowed start folders from the disallowed start folders file, works the same as load_included_folders
|
|
void load_disallowed_start_folders() {
|
|
std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables
|
|
std::ifstream file(DISALLOWED_START_FOLDERS);
|
|
if (!file.is_open()) {
|
|
printf("Could not open disallowed start folders file. %s\n", DISALLOWED_START_FOLDERS);
|
|
log(LOGLEVEL::ERR, "[load_disallowed_start_folders()]: Could not open disallowed start folders file. ", DISALLOWED_START_FOLDERS);
|
|
return;
|
|
}
|
|
|
|
std::string line;
|
|
std::getline(file, line); // Skip the first line
|
|
while (std::getline(file, line)) {
|
|
size_t start_pos = line.find('"'); // Find the position of the first double quote
|
|
if (start_pos != std::string::npos) {
|
|
size_t end_pos = line.find('"', start_pos + 1); // Find the position of the second double quote
|
|
if (end_pos != std::string::npos) {
|
|
std::string path = line.substr(start_pos + 1, end_pos - start_pos - 1); // Extract the path between double quotes
|
|
disallowed_start_folders[disallowed_start_folders_size++] = to_lower(path);
|
|
}
|
|
}
|
|
}
|
|
|
|
file.close();
|
|
}
|
|
|
|
// Check if a folder is included in the included_folders
|
|
bool is_folder_included(const std::string& path) {
|
|
std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables
|
|
std::string lower_path=to_lower(path);
|
|
for (int i = 0; i < included_folders_size; i++) {
|
|
if ((lower_path.find(included_folders[i]) != std::string::npos) or matches_pattern(lower_path, included_folders[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Check if a folder is excluded in the excluded_folders
|
|
bool is_folder_excluded(const std::string& path) {
|
|
std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables
|
|
std::string lower_path = to_lower(path);
|
|
for (int i = 0; i < excluded_folders_size; i++) {
|
|
if ((lower_path.find(excluded_folders[i]) != std::string::npos) or matches_pattern(lower_path, excluded_folders[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Check if a folder is disallowed in the disallowed start folders. This function also supports patterns like c:\users\*\blabla
|
|
bool is_disallowed_sart_folder(const std::string& path) {
|
|
std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables
|
|
std::string lower_path = to_lower(path);
|
|
for (int i = 0; i < disallowed_start_folders_size; i++) {
|
|
if ((lower_path.find(disallowed_start_folders[i]) != std::string::npos) or matches_pattern(lower_path, disallowed_start_folders[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
// only for debug purposes, prints the included folders
|
|
void print_inclusions() {
|
|
std::lock_guard<std::mutex> lock(logMutex); // Lock access to log printing
|
|
|
|
for (int i = 0; i < excluded_folders_size; i++) {
|
|
log(LOGLEVEL::INFO, "[print_exclusions()]: Excluded folder: ", excluded_folders[i]);
|
|
}
|
|
}
|
|
|
|
//return the log timeout. namely for how long we werent able to send a log entry to the server
|
|
int log_timeout_get() {
|
|
std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables
|
|
|
|
return srv_log_timeout;
|
|
}
|
|
|
|
//set the log timeout
|
|
void log_timeout_set(int timeout) {
|
|
std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables
|
|
|
|
srv_log_timeout = timeout;
|
|
}
|
|
|
|
//set the log timeout reset => after how long should the log timeout be reset
|
|
void log_timeout_reset_set(int timeout) {
|
|
std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables
|
|
|
|
log_timeout_reset = timeout;
|
|
}
|
|
|
|
//get the log timeout reset
|
|
int log_timeout_reset_get() {
|
|
std::lock_guard<std::mutex> lock(settingsMutex); // Lock access to settings variables
|
|
|
|
return log_timeout_reset;
|
|
}
|
|
|
|
#endif // SETTINGS_CPP
|