SET(TARGET_SEC_SRV_CLIENT_SMACK_TESTS "security-server-tests-client-smack")
SET(TARGET_SEC_SRV_TC_SERVER_TESTS "security-server-tests-server")
SET(TARGET_SEC_SRV_PWD_TESTS "security-server-tests-password")
+SET(TARGET_SEC_SRV_STRESS_TESTS "security-server-tests-stress")
SET(TARGET_SEC_SRV_MT_TESTS "security-server-tests-mt")
SET(TARGET_SEC_SRV_DBUS_TESTS "security-server-tests-dbus")
SET(TARGET_SEC_SRV_MEASURER "security-server-tests-api-speed")
${PROJECT_SOURCE_DIR}/tests/security-server-tests/security_server_clean_env.cpp
)
+SET(SEC_SRV_STRESS_SOURCES
+ ${PROJECT_SOURCE_DIR}/tests/security-server-tests/security_server_tests_stress.cpp
+ )
+
SET(SEC_SRV_MT_SOURCES
${PROJECT_SOURCE_DIR}/tests/security-server-tests/security_server_tests_mt.cpp
)
ADD_EXECUTABLE(${TARGET_SEC_SRV_CLIENT_SMACK_TESTS} ${SEC_SRV_CLIENT_SMACK_SOURCES})
ADD_EXECUTABLE(${TARGET_SEC_SRV_TC_SERVER_TESTS} ${SEC_SRV_TC_SERVER_SOURCES})
ADD_EXECUTABLE(${TARGET_SEC_SRV_PWD_TESTS} ${SEC_SRV_PWD_SOURCES})
+ADD_EXECUTABLE(${TARGET_SEC_SRV_STRESS_TESTS} ${SEC_SRV_STRESS_SOURCES})
ADD_EXECUTABLE(${TARGET_SEC_SRV_MT_TESTS} ${SEC_SRV_MT_SOURCES})
ADD_EXECUTABLE(${TARGET_SEC_SRV_DBUS_TESTS} ${SEC_SRV_DBUS_SOURCES})
ADD_EXECUTABLE(${TARGET_SEC_SRV_MEASURER} ${SEC_SRV_MEASURER_SOURCES})
${SEC_SRV_TESTS_DEP_LIBRARIES}
tests-common)
+TARGET_LINK_LIBRARIES(${TARGET_SEC_SRV_STRESS_TESTS}
+ ${SEC_SRV_TESTS_DEP_LIBRARIES}
+ tests-common)
+
TARGET_LINK_LIBRARIES(${TARGET_SEC_SRV_MT_TESTS}
${SEC_SRV_TESTS_DEP_LIBRARIES}
tests-common)
INSTALL(TARGETS ${TARGET_SEC_SRV_CLIENT_SMACK_TESTS} DESTINATION /usr/bin)
INSTALL(TARGETS ${TARGET_SEC_SRV_TC_SERVER_TESTS} DESTINATION /usr/bin)
INSTALL(TARGETS ${TARGET_SEC_SRV_PWD_TESTS} DESTINATION /usr/bin)
+INSTALL(TARGETS ${TARGET_SEC_SRV_STRESS_TESTS} DESTINATION /usr/bin)
INSTALL(TARGETS ${TARGET_SEC_SRV_MT_TESTS} DESTINATION /usr/bin)
INSTALL(TARGETS ${TARGET_SEC_SRV_DBUS_TESTS} DESTINATION /usr/bin)
INSTALL(TARGETS ${TARGET_SEC_SRV_MEASURER} DESTINATION /usr/bin)
--- /dev/null
+/*
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved
+ */
+/*
+ * @file security_server_tests_stress.cpp
+ * @author Pawel Polawski (p.polawski@partner.samsung.com)
+ * @version 1.0
+ * @brief Test cases for security server stress tests
+ *
+ */
+
+#include <dpl/test/test_runner.h>
+#include <dpl/test/test_runner_multiprocess.h>
+#include <tests_common.h>
+#include <iostream>
+#include <sys/smack.h>
+#include <cstddef>
+#include <thread>
+#include <mutex>
+#include <string>
+#include <sys/types.h>
+#include "security-server.h"
+
+
+std::mutex g_mutex;
+std::mutex g_msgMutex;
+size_t g_successes = 0;
+
+//number of threads
+const size_t g_threadsNumber = 100;
+
+//environment setup
+const std::string g_subject("woda");
+const std::string g_object("wiadro");
+const std::string g_rule("rwx");
+
+//for storing errors
+std::string g_errors;
+
+
+void appendError(const std::string &message)
+{
+ std::lock_guard<std::mutex> lock(g_msgMutex);
+ g_errors += message;
+ g_errors += "\n";
+}
+
+void cookie_api_thread_function(bool isSmack)
+{
+ /*
+ Tested API functions:
+
+ int security_server_get_cookie_size(void);
+ int security_server_request_cookie(char *cookie, size_t bufferSize);
+ int security_server_check_privilege(const char *cookie, gid_t privilege);
+ int security_server_check_privilege_by_cookie(const char *cookie,
+ const char *object,
+ const char *access_rights);
+ int security_server_get_cookie_pid(const char *cookie);
+ char *security_server_get_smacklabel_cookie(const char *cookie);
+ int security_server_get_uid_by_cookie(const char *cookie, uid_t *uid);
+ int security_server_get_gid_by_cookie(const char *cookie, gid_t *gid);
+ */
+
+ int ret;
+ size_t COOKIE_SIZE;
+ pid_t pid;
+ uid_t uid;
+ gid_t gid;
+
+ //security_server_get_cookie_size()
+ COOKIE_SIZE = security_server_get_cookie_size();
+ if (COOKIE_SIZE != 20) {
+ appendError("Error in security_server_get_cookie_size(): " + std::to_string(COOKIE_SIZE));
+ return;
+ }
+
+ //security_server_request_cookie()
+ std::vector<char> cookie(COOKIE_SIZE);
+ ret = security_server_request_cookie(cookie.data(), COOKIE_SIZE);
+ if (ret < 0) {
+ appendError("Error in security_server_request_cookie(): " + std::to_string(ret));
+ return;
+ }
+
+ //security_server_check_privilege()
+ ret = security_server_check_privilege(cookie.data(), 0);
+ if (ret < 0) {
+ appendError("Error in security_server_check_privilege(): " + std::to_string(ret));
+ return;
+ }
+
+ //security_server_check_privilege_by_cookie()
+ ret = security_server_check_privilege_by_cookie(cookie.data(), g_object.data(), g_rule.data());
+ if (ret < 0) {
+ appendError("Error in security_server_check_privilege_by_cookie(): " + std::to_string(ret));
+ return;
+ }
+
+ //security_server_get_cookie_pid
+ pid = getpid();
+ ret = security_server_get_cookie_pid(cookie.data());
+ if (ret < 0) {
+ appendError("Error in security_server_get_cookie_pid(): " + std::to_string(ret));
+ return;
+ }
+
+ if (isSmack) {
+ //security_server_get_smacklabel_cookie()
+ char *tmp = security_server_get_smacklabel_cookie(cookie.data());
+ std::string labelFromCookie(tmp ? tmp : "");
+ free(tmp);
+ if (labelFromCookie.size() == 0) {
+ appendError("Error in security_server_get_smacklabel_cookie(): " + labelFromCookie);
+ return;
+ }
+
+ char *labelFromSelfTmp = NULL;
+ ret = smack_new_label_from_self(&labelFromSelfTmp);
+ if (ret < 0) {
+ appendError("Error in smack_new_label_from_self(): " + std::to_string(ret));
+ return;
+ }
+
+ std::string labelFromSelf(labelFromSelfTmp ? labelFromSelfTmp : "");
+ free(labelFromSelfTmp);
+ if (labelFromSelf != labelFromCookie) {
+ appendError("Error in comparing SMACK label: " + std::to_string(ret));
+ return;
+ }
+ }
+
+ //security_server_get_uid_by_cookie()
+ ret = security_server_get_uid_by_cookie(cookie.data(), &uid);
+ if (ret < 0) {
+ appendError("Error in security_server_get_uid_by_cookie(): " + std::to_string(ret));
+ return;
+ }
+ uid_t trueUid = getuid();
+ if (trueUid != uid) {
+ appendError("Error in UID match");
+ return;
+ }
+
+ //security_server_get_gid_by_cookie()
+ ret = security_server_get_gid_by_cookie(cookie.data(), &gid);
+ if (ret < 0) {
+ appendError("Error in security_server_get_gid_by_cookie(): " + std::to_string(ret));
+ return;
+ }
+ gid_t trueGid = getgid();
+ if (trueGid != gid) {
+ appendError("Error in GID match");
+ return;
+ }
+
+ std::lock_guard<std::mutex> lock(g_mutex);
+ ++g_successes;
+}
+
+void testFunction(bool isSmack)
+{
+ std::vector<std::thread> threadsVector;
+
+ if (isSmack) {
+ //preapre environment
+ int ret = smack_set_label_for_self(g_subject.data());
+ RUNNER_ASSERT_MSG(ret == 0, "Error in smack_set_label_for_self()");
+
+ struct smack_accesses *rulesRaw = NULL;
+ ret = smack_accesses_new(&rulesRaw);
+ RUNNER_ASSERT_MSG(ret == 0, "Error in smack_accesses_new()");
+ AccessesUniquePtr rules(rulesRaw, smack_accesses_free);
+ ret = smack_accesses_add(rules.get(), g_subject.data(), g_object.data(), g_rule.data());
+ RUNNER_ASSERT_MSG(ret == 0, "Error in smack_accesses_add()");
+ ret = smack_accesses_apply(rules.get());
+ RUNNER_ASSERT_MSG(ret == 0, "Error in smack_accesses_apply()");
+ }
+
+ //spawning threads
+ for (size_t i = 0 ; i < g_threadsNumber; ++i)
+ threadsVector.push_back(std::thread(cookie_api_thread_function, isSmack));
+
+ //waiting for threads end
+ for (auto itr = threadsVector.begin(); itr != threadsVector.end(); ++itr)
+ itr->join();
+}
+
+
+RUNNER_TEST_GROUP_INIT(stress_tests)
+
+RUNNER_CHILD_TEST_SMACK(tc_stress_cookie_api_smack)
+{
+ testFunction(true);
+
+ RUNNER_ASSERT_MSG(g_successes == g_threadsNumber,
+ "Not all threads exit with success: "
+ << g_successes << "/ " << g_threadsNumber
+ << std::endl << "Errors:" << std::endl << g_errors);
+}
+
+RUNNER_CHILD_TEST_NOSMACK(tc_stress_cookie_api_no_smack)
+{
+ testFunction(false);
+
+ RUNNER_ASSERT_MSG(g_successes == g_threadsNumber,
+ "Not all threads exit with success: "
+ << g_successes << "/ " << g_threadsNumber
+ << std::endl << "Errors:" << std::endl << g_errors);
+}
+
+
+
+int main (int argc, char *argv[])
+{
+ int status = DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
+ return status;
+}
+
projects / platform / core / test / security-tests.git / commitdiff