tests/security-server-tests/security_server_tests_stress.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  */
   4 /*
   5  * @file    security_server_tests_stress.cpp
   6  * @author  Pawel Polawski (p.polawski@partner.samsung.com)
   7  * @version 1.0
   8  * @brief   Test cases for security server stress tests
   9  *
  10  */
  11
  12 #include <dpl/test/test_runner.h>
  13 #include <dpl/test/test_runner_multiprocess.h>
  14 #include <tests_common.h>
  15 #include <iostream>
  16 #include <sys/smack.h>
  17 #include <cstddef>
  18 #include <thread>
  19 #include <mutex>
  20 #include <string>
  21 #include <sys/types.h>
  22 #include <unistd.h>
  23 #include "security-server.h"
  24 #include <memory.h>
  25
  26 std::mutex g_mutex;
  27 std::mutex g_msgMutex;
  28 size_t g_successes = 0;
  29
  30 //number of threads
  31 const size_t g_threadsNumber = 5;
  32
  33 //environment setup
  34 const std::string g_subject("woda");
  35 const std::string g_object("wiadro");
  36 const std::string g_rule("rwx");
  37
  38 //for storing errors
  39 std::string g_errors;
  40
  41
  42 void appendError(const std::string &message)
  43 {
  44     std::lock_guard<std::mutex> lock(g_msgMutex);
  45     g_errors += message;
  46     g_errors += "\n";
  47 }
  48
  49 void cookie_api_thread_function(bool isSmack)
  50 {
  51     /*
  52     Tested API functions:
  53
  54     int security_server_get_cookie_size(void);
  55     int security_server_request_cookie(char *cookie, size_t bufferSize);
  56     int security_server_check_privilege(const char *cookie, gid_t privilege);
  57     int security_server_check_privilege_by_cookie(const char *cookie,
  58                                               const char *object,
  59                                               const char *access_rights);
  60     int security_server_get_cookie_pid(const char *cookie);
  61     char *security_server_get_smacklabel_cookie(const char *cookie);
  62     */
  63
  64     int ret;
  65     size_t COOKIE_SIZE;
  66
  67     //security_server_get_cookie_size()
  68     COOKIE_SIZE = security_server_get_cookie_size();
  69     if (COOKIE_SIZE != 20) {
  70         appendError("Error in security_server_get_cookie_size(): " + std::to_string(COOKIE_SIZE));
  71         return;
  72     }
  73
  74     //security_server_request_cookie()
  75     std::vector<char> cookie(COOKIE_SIZE);
  76     ret = security_server_request_cookie(cookie.data(), COOKIE_SIZE);
  77     if (ret < 0) {
  78         appendError("Error in security_server_request_cookie(): " + std::to_string(ret));
  79         return;
  80     }
  81
  82     //security_server_check_privilege()
  83     ret = security_server_check_privilege(cookie.data(), 0);
  84     if (ret < 0) {
  85         appendError("Error in security_server_check_privilege(): " + std::to_string(ret));
  86         return;
  87     }
  88
  89     //security_server_check_privilege_by_cookie()
  90     ret = security_server_check_privilege_by_cookie(cookie.data(), g_object.data(), g_rule.data());
  91     if (ret < 0) {
  92         appendError("Error in security_server_check_privilege_by_cookie(): " + std::to_string(ret));
  93         return;
  94     }
  95
  96     //security_server_get_cookie_pid
  97     ret = security_server_get_cookie_pid(cookie.data());
  98     if (ret < 0) {
  99         appendError("Error in security_server_get_cookie_pid(): " + std::to_string(ret));
 100         return;
 101     }
 102
 103     if (isSmack) {
 104         //security_server_get_smacklabel_cookie()
 105         char *tmp = security_server_get_smacklabel_cookie(cookie.data());
 106         std::string labelFromCookie(tmp ? tmp : "");
 107         free(tmp);
 108         if (labelFromCookie.size() == 0) {
 109             appendError("Error in security_server_get_smacklabel_cookie(): " + labelFromCookie);
 110             return;
 111         }
 112
 113         char *labelFromSelfTmp = nullptr;
 114         ret = smack_new_label_from_self(&labelFromSelfTmp);
 115         if (ret < 0) {
 116             appendError("Error in smack_new_label_from_self(): " + std::to_string(ret));
 117             return;
 118         }
 119
 120         std::string labelFromSelf(labelFromSelfTmp ? labelFromSelfTmp : "");
 121         free(labelFromSelfTmp);
 122         if (labelFromSelf != labelFromCookie) {
 123             appendError("Error in comparing SMACK label: " + std::to_string(ret));
 124             return;
 125         }
 126     }
 127
 128     std::lock_guard<std::mutex> lock(g_mutex);
 129     ++g_successes;
 130 }
 131
 132 void testFunction(bool isSmack)
 133 {
 134     std::vector<std::thread> threadsVector;
 135
 136     if (isSmack) {
 137         //preapre environment
 138         int ret = smack_set_label_for_self(g_subject.data());
 139         RUNNER_ASSERT_MSG(ret == 0, "Error in smack_set_label_for_self()");
 140
 141         struct smack_accesses *rulesRaw = nullptr;
 142         ret = smack_accesses_new(&rulesRaw);
 143         RUNNER_ASSERT_MSG(ret == 0, "Error in smack_accesses_new()");
 144         SmackAccessesPtr rules(rulesRaw);
 145         ret = smack_accesses_add(rules.get(), g_subject.data(), g_object.data(), g_rule.data());
 146         RUNNER_ASSERT_MSG(ret == 0, "Error in smack_accesses_add()");
 147         ret = smack_accesses_apply(rules.get());
 148         RUNNER_ASSERT_MSG(ret == 0, "Error in smack_accesses_apply()");
 149     }
 150
 151     //spawning threads
 152     for (size_t i = 0 ; i < g_threadsNumber; ++i)
 153         threadsVector.push_back(std::thread(cookie_api_thread_function, isSmack));
 154
 155     //waiting for threads end
 156     for (auto itr = threadsVector.begin(); itr != threadsVector.end(); ++itr)
 157         itr->join();
 158 }
 159
 160
 161 RUNNER_TEST_GROUP_INIT(stress_tests)
 162
 163 RUNNER_CHILD_TEST_SMACK(tc_stress_cookie_api_smack)
 164 {
 165     testFunction(true);
 166
 167     RUNNER_ASSERT_MSG(g_successes == g_threadsNumber,
 168                       "Not all threads exit with success: "
 169                       << g_successes << "/ " << g_threadsNumber
 170                       << std::endl << "Errors:" << std::endl << g_errors);
 171 }
 172
 173 RUNNER_CHILD_TEST_NOSMACK(tc_stress_cookie_api_no_smack)
 174 {
 175     testFunction(false);
 176
 177     RUNNER_ASSERT_MSG(g_successes == g_threadsNumber,
 178                       "Not all threads exit with success: "
 179                       << g_successes << "/ " << g_threadsNumber
 180                       << std::endl << "Errors:" << std::endl << g_errors);
 181 }
 182
 183
 184
 185 int main (int argc, char *argv[])
 186 {
 187     return DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
 188 }
 189