tests/security-server-tests/security_server_tests_stress.cpp

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