Changed tests to use the database file argument

Reviewed-on: #7

src/fuse_operations.c

@@ -39,20 +39,20 @@
 #include "sourcefs.h"
 #include "ui-socket.h"
 
-// TODO: move this to other file
 const char *get_process_name_by_pid(const int pid) {
   char *name = (char *)calloc(1024, sizeof(char));
   if (name) {
     sprintf(name, "/proc/%d/cmdline", pid);
-    FILE *f = fopen(name, "r");
+    FILE *file = fopen(name, "r");
-    if (f) {
+    if (file) {
-      size_t size;
+      size_t size = 0;
-      size = fread(name, sizeof(char), 1024, f);
+      size = fread(name, sizeof(char), 1024, file);
       if (size > 0) {
-        if ('\n' == name[size - 1])
+        if ('\n' == name[size - 1]) {
           name[size - 1] = '\0';
+        }
       }
-      fclose(f);
+      fclose(file);
     }
   }
   return name;
@@ -70,8 +70,8 @@ static void *xmp_init(struct fuse_conn_info *conn, struct fuse_config *cfg) {
      To make parallel_direct_writes valid, need either set cfg->direct_io
      in current function (recommended in high level API) or set fi->direct_io
      in xmp_create() or xmp_open(). */
-  // cfg->direct_io = 1;
+  cfg->direct_io = 1;
-  // cfg->parallel_direct_writes = 1;
+  cfg->parallel_direct_writes = 1;
 
   /* Pick up changes from lower filesystem right away. This is
      also necessary for better hardlink support. When the kernel
@@ -88,13 +88,13 @@ static void *xmp_init(struct fuse_conn_info *conn, struct fuse_config *cfg) {
 }
 
 static int xmp_getattr(const char *path, struct stat *stbuf,
-                       struct fuse_file_info *fi) {
+                       struct fuse_file_info *file_info) {
   int res;
 
   (void)path;
 
-  if (fi)
+  if (file_info)
-    res = fstat(fi->fh, stbuf);
+    res = fstat(file_info->fh, stbuf);
   else
     res = source_stat(path, stbuf);
   if (res == -1) {
@@ -106,38 +106,39 @@ static int xmp_getattr(const char *path, struct stat *stbuf,
 }
 
 static int xmp_access(const char *path, int mask) {
-  int res;
+  int res = -1;
 
   // if mask is F_OK, then we don't need to check the permissions
   // (is that possible?)
 
   if (mask != F_OK) {
-    struct process_info pi;
+    struct process_info proc_info;
-    struct fuse_context *fc = fuse_get_context();
+    struct fuse_context *context = fuse_get_context();
 
-    pi.PID = fc->pid;
+    proc_info.PID = context->pid;
-    pi.name = get_process_name_by_pid(pi.PID);
+    proc_info.name = get_process_name_by_pid(proc_info.PID);
 
     // fprintf(stderr, "%s, %d\n", path, ask_access(path, pi));
 
-    if (!interactive_access(real_filename(path), pi, 0)) {
+    if (!interactive_access(real_filename(path), proc_info, 0)) {
-      free(pi.name);
+      free((void *)proc_info.name);
       return -EACCES;
     }
 
-    free(pi.name);
+    free((void *)proc_info.name);
   }
 
   res = source_access(path, mask);
 
-  if (res == -1)
+  if (res == -1) {
     return -errno;
+  }
 
   return 0;
 }
 
 static int xmp_readlink(const char *path, char *buf, size_t size) {
-  int res;
+  int res = -1;
 
   res = readlink(path, buf, size - 1);
   if (res == -1)
@@ -264,17 +265,18 @@ static int xmp_mknod(const char *path, mode_t mode, dev_t rdev) {
 */
 
 static int xmp_mkdir(const char *path, mode_t mode) {
-  int res;
+  int res = -1;
 
   res = source_mkdir(path, mode);
-  if (res == -1)
+  if (res == -1) {
     return -errno;
+  }
 
   return 0;
 }
 
 static int xmp_unlink(const char *path) {
-  int res;
+  int res = -1;
   struct process_info pi;
   struct fuse_context *fc = fuse_get_context();
 

src/main.c

@@ -15,9 +15,10 @@
 #define _GNU_SOURCE
 
 #include <fuse3/fuse.h>
-
 #include <stdio.h>
 #include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #include "fuse_operations.h"
 #include "sourcefs.h"
@@ -26,25 +27,35 @@
 const char *mountpoint = NULL;
 
 int main(int argc, char *argv[]) {
-  umask(0);
+  if (argc < 3) {
-
+    fprintf(stderr, "Usage: icfs <FUSE arguments> [target directory] [path to "
-  mountpoint = realpath(argv[argc - 1], NULL);
+                    "the permanent permissions database\n");
-
+    return EXIT_FAILURE;
-  int ret = source_init(mountpoint);
-  if (ret != 0) {
-    perror("source_init");
-    exit(EXIT_FAILURE);
   }
 
-  ret = init_ui_socket();
+  // if umask != 0, the filesystem will create files with more restrictive
+  // permissions than it's caller reqested
+  umask(0);
+
+  // ui socket should always be initialized before anything else, since it
+  // handles the setuid bits!
+  int ret = init_ui_socket(argv[argc - 1]);
   if (ret != 0) {
     fprintf(stderr, "Could not initalize ui-socket.\n");
     exit(EXIT_FAILURE);
   }
 
-  ret = fuse_main(argc, argv, get_fuse_operations(), NULL);
+  mountpoint = realpath(argv[argc - 2], NULL);
 
-  free(mountpoint);
+  ret = source_init(mountpoint);
+  if (ret != 0) {
+    perror("source_init");
+    exit(EXIT_FAILURE);
+  }
+
+  ret = fuse_main(argc - 1, argv, get_fuse_operations(), NULL);
+
+  free((void *)mountpoint);
   destroy_ui_socket();
   return ret;
 }

src/perm_permissions_table.c

@@ -1,10 +1,24 @@
+/*
+  ICFS: Interactively Controlled File System
+  Copyright (C) 2024-2025  Fedir Kovalov
+
+  This program can be distributed under the terms of the GNU GPLv2.
+  See the file LICENSE.
+*/
+
 #include "perm_permissions_table.h"
 #include "process_info.h"
+#include <fcntl.h>
+#include <pthread.h>
 #include <sqlite3.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/fsuid.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 sqlite3 *perm_database = NULL;
 const char *const table_name = "permissions";
@@ -12,6 +26,38 @@ const char *const table_name = "permissions";
 const int column_count = 2;
 const char *const schema[] = {"executable", "filename"};
 const char *const types[] = {"TEXT", "TEXT"};
+uid_t ruid, euid, current_pid;
+pthread_mutex_t uid_switch = PTHREAD_MUTEX_INITIALIZER;
+
+void set_db_fsuid() {
+  pthread_mutex_lock(&uid_switch);
+  if (current_pid == ruid)
+    return;
+
+  int status = -1;
+
+  status = setfsuid(ruid);
+  if (status < 0) {
+    fprintf(stderr, "Couldn't set uid to %d.\n", ruid);
+    exit(status);
+  }
+  pthread_mutex_unlock(&uid_switch);
+}
+
+void set_real_fsuid() {
+  pthread_mutex_lock(&uid_switch);
+  if (current_pid == ruid)
+    return;
+
+  int status = -1;
+
+  status = setfsuid(ruid);
+  if (status < 0) {
+    fprintf(stderr, "Couldn't set uid to %d.\n", euid);
+    exit(status);
+  }
+  pthread_mutex_unlock(&uid_switch);
+}
 
 static int check_table_col_schema(void *notused, int argc, char **argv,
                                   char **colname) {
@@ -21,15 +67,16 @@ static int check_table_col_schema(void *notused, int argc, char **argv,
     fprintf(stderr, "Unexpected amount of arguments given to the callback.\n");
     return 1;
   }
-  int i = atoi(argv[0]);
+  int column_num = atoi(argv[0]);
-  if (i >= column_count) {
+  if (column_num >= column_count) {
     fprintf(stderr, "Table contains more columns than expected.\n");
     return 1;
   }
-  if (strcmp(schema[i], argv[1]) == 0 && strcmp(types[i], argv[2]) == 0) {
+  if (strcmp(schema[column_num], argv[1]) == 0 &&
+      strcmp(types[column_num], argv[2]) == 0) {
     return 0;
   }
-  fprintf(stderr, "Column %d does not conform to the schema.\n", i);
+  fprintf(stderr, "Column %d does not conform to the schema.\n", column_num);
   return 1;
 }
 
@@ -101,14 +148,31 @@ int ensure_database_schema() {
  * @return: 0 on success, -1 on failure
  */
 int init_perm_permissions_table(const char *db_filename) {
-  if (sqlite3_open(db_filename, &perm_database)) {
+  // we don't want the group and others to access the db
-    perror("Can't open permanent permissions database:");
+  umask(0077);
+  ruid = getuid();
+  euid = geteuid();
+  fprintf(stderr, "Running with uid: %d, gid: %d\n", euid, getegid());
+
+  if (sqlite3_open_v2(db_filename, &perm_database,
+                      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
+                          SQLITE_OPEN_FULLMUTEX,
+                      NULL)) {
+    perror("Can't open permanent permissions database");
     return -1;
   }
+  umask(0);
   if (ensure_database_schema()) {
     fprintf(stderr, "Database schema is not correct.\n");
     return -1;
   }
+
+  int status = seteuid(ruid);
+  if (status < 0) {
+    fprintf(stderr, "Couldn't set euid to ruid during database setup.\n");
+    exit(status);
+  }
+
   return 0;
 }
 

src/perm_permissions_table.h

@@ -1,3 +1,10 @@
+/*
+  ICFS: Interactively Controlled File System
+  Copyright (C) 2024-2025  Fedir Kovalov
+
+  This program can be distributed under the terms of the GNU GPLv2.
+  See the file LICENSE.
+*/
 
 #ifndef PERM_PERMISSION_TABLE_H
 #define PERM_PERMISSION_TABLE_H

src/process_info.h

@@ -1,3 +1,10 @@
+/*
+  ICFS: Interactively Controlled File System
+  Copyright (C) 2024-2025  Fedir Kovalov
+
+  This program can be distributed under the terms of the GNU GPLv2.
+  See the file LICENSE.
+*/
 
 #ifndef PROCESS_INFO_H
 #define PROCESS_INFO_H

src/sourcefs.c

@@ -33,6 +33,8 @@ int source_init(const char *root_path) {
   int root_fd = open(root_path, O_PATH);
 
   if (root_fd == -1) {
+    fprintf(stderr, "Could not initialize source file system at %s", root_path);
+    perror("");
     return -1;
   }
 

src/temp_permissions_table.c

@@ -75,6 +75,7 @@ unsigned long long get_process_creation_time(pid_t pid) {
 int init_temp_permissions_table() {
   pthread_mutex_init(&temp_permissions_table_lock, PTHREAD_MUTEX_DEFAULT);
   init(&temp_permissions_table);
+  return 0;
 }
 
 /**
@@ -225,7 +226,6 @@ int give_temp_access(const char *filename, struct process_info pi) {
   push(&new_permission_entry.allowed_files, strdup(filename));
 
   insert(&temp_permissions_table, pi.PID, new_permission_entry);
-  printf("temp_permissions_table size: %ld\n", size(&temp_permissions_table));
 
   pthread_mutex_unlock(&temp_permissions_table_lock);
   return 0;

src/ui-socket.c

@@ -22,7 +22,7 @@
 #include <sys/un.h>
 #include <unistd.h>
 
-int init_ui_socket() {
+int init_ui_socket(const char *perm_permissions_db_filename) {
   char line[256];
   FILE *fp;
 
@@ -31,8 +31,7 @@ int init_ui_socket() {
     return 1;
   }
 
-  if (init_perm_permissions_table(
+  if (init_perm_permissions_table(perm_permissions_db_filename)) {
-          "/home/fedir/Developement/uni/ICFS/test/.pt.db")) {
     fprintf(stderr, "Could not initialize permanent permissions table.\n");
     return 1;
   }

src/ui-socket.h

@@ -21,7 +21,7 @@
  *
  * @return: 0 on success, -1 on faliure.
  */
-int init_ui_socket(void);
+int init_ui_socket(const char *perm_permissions_db_filename);
 
 /**
  * Close the GUI communication.

test/test.bash

@@ -16,9 +16,23 @@ PATH="$(realpath ./mock/):$PATH"
 # mount the filesystem
 
 echo "Run $(date -u +%Y-%m-%dT%H:%M:%S) "
-valgrind -s ../build/icfs -o default_permissions ./protected &
+if [[ $1 == "--setuid" ]]; then
+  echo "Setting the setuid bit..."
+  echo "root privilieges are required to create a special user and set correct ownership of the executable."
+  id -u icfs &>/dev/null || sudo useradd --system --user-group icfs
+  sudo chown icfs: ../build/icfs && sudo chmod 4777 ../build/icfs
+  chmod g+w . # needed for icfs to be able to create the database
+  echo "Valgrind will not be used due to setuid compatibility issues."
+  ../build/icfs -o default_permissions ./protected ./.pt.db &
+  sleep 1
+else
+  echo "Database protection will not be tested due to the lack of setuid capabilites."
+  echo "To test it, run this script with '--setuid'."
+  valgrind -s ../build/icfs -o default_permissions ./protected ./.pt.db &
+  sleep 5
+fi
 
-sleep 5
+#valgrind -s ../build/icfs -o default_permissions ./protected &
 
 # WARN: please don't use `>` or `>>` operators. They force **this script** to open the file, **not the program you are trying to run**. This is probably not what you mean when you want to test a specific program's access.
 # WARN: avoid using touch, since it generates errors because setting times is not implemented in icfs **yet**.
@@ -105,6 +119,13 @@ cat ./protected/motto >/dev/null 2>/dev/null &&
   echo "[ICFS-TEST]: OK" ||
   echo "[ICFS-TEST]: echo cannot read protected/motto despite access being permitted!" # OK
 
+# test database access
+if [[ -r "./.pt.db" || -w "./.pt.db" ]]; then
+  echo "[ICFS-TEST]: permanent permissions is accessible!"
+else
+  echo "[ICFS-TEST]: OK"
+fi
+
 # unmount
 
 sleep 0.5