%attr(755, security_test_user,users) %{TZ_SYS_HOME}/security_test_user/apps_rw/*
/usr/bin/cynara-test
/usr/bin/ckm-tests
-/usr/bin/ckm-privileged-tests
-/usr/bin/ckm-tests-on-onlycap.sh
-/usr/bin/ckm-integration-tests
+%caps(cap_mac_admin=ep) /usr/bin/ckm-privileged-tests
+%caps(cap_mac_admin=ep) /usr/bin/ckm-integration-tests
/usr/bin/yaca-test
%{ckm_test_dir}/*
/etc/security-tests
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2015 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/*
* @file change-smack.cpp
* @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
* @version 1.0
*/
#include <sys/smack.h>
#include <tests_common.h>
#include <process-settings/change-smack.h>
+#include <scoped_process_label.h>
namespace ProcessSettings {
{}
void ChangeSmack::Apply() {
- char *my_label = nullptr;
-
- RUNNER_ASSERT(-1 != smack_new_label_from_self(&my_label));
-
- if (my_label)
- m_originalLabel = my_label;
-
- free(my_label);
-
- RUNNER_ASSERT_MSG(0 == smack_set_label_for_self(m_policy.GetSmackLabel().c_str()),
- "Error in smack_set_label_for_self(" << m_policy.GetSmackLabel() << ")");
+ m_processLabel.reset(new ScopedProcessLabel(m_policy.GetSmackLabel()));
}
void ChangeSmack::Revoke() {
- RUNNER_ASSERT_MSG(0 == smack_set_label_for_self(m_originalLabel.c_str()),
- "Error in smack_set_label_for_self(" << m_originalLabel << ")");
+ m_processLabel.reset();
}
ChangeSmack::~ChangeSmack() {}
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2015 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/*
* @file change-smack.h
* @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
* @version 1.0
*/
#pragma once
#include <string>
+#include <memory>
#include <process-settings/policy.h>
+class ScopedProcessLabel;
+
namespace ProcessSettings {
class ChangeSmack {
virtual ~ChangeSmack();
private:
const Policy &m_policy;
- std::string m_originalLabel;
+ std::unique_ptr<ScopedProcessLabel> m_processLabel;
};
} // namespace ProcessSettings
-# Copyright (c) 2013-2018 Samsung Electronics Co., Ltd All Rights Reserved
+# Copyright (c) 2013-2019 Samsung Electronics Co., Ltd All Rights Reserved
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
)
INSTALL(TARGETS ${TARGET_CKM_PRIVILEGED_TESTS} DESTINATION bin)
-INSTALL(FILES ckm-tests-on-onlycap.sh
- DESTINATION bin
- PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
- GROUP_READ GROUP_EXECUTE
- WORLD_READ WORLD_EXECUTE
-)
/*
- * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2013 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/*
* @file access_provider.cpp
* @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
* @version 1.0
* @brief Common functions and macros used in security-tests package.
*/
#include <access_provider2.h>
#include <tests_common.h>
#include <ckm-common.h>
+#include <scoped_process_label.h>
namespace {
applyAndSwithToUser(uid, gid);
}
+AccessProvider::~AccessProvider()
+{
+
+}
+
void AccessProvider::allowAPI(const std::string &api, const std::string &rule) {
m_smackAccess.add(m_mySubject, api, rule);
}
{
RUNNER_ASSERT_MSG(m_inSwitchContext == false, "already switched context");
- // get calling label
- char* my_label = NULL;
- RUNNER_ASSERT(smack_new_label_from_self(&my_label) > 0);
- if(my_label)
- {
- m_origLabel = std::string(my_label);
- free(my_label);
- }
- RUNNER_ASSERT(m_origLabel.size() > 0);
-
RUNNER_ASSERT_MSG(0 == smack_revoke_subject(m_mySubject.c_str()),
"Error in smack_revoke_subject(" << m_mySubject << ")");
apply();
- RUNNER_ASSERT_MSG(0 == smack_set_label_for_self(m_mySubject.c_str()),
- "Error in smack_set_label_for_self.");
+
+ m_processLabel.reset(new ScopedProcessLabel(m_mySubject));
m_origUid = getuid();
m_origGid = getgid();
RUNNER_ASSERT_MSG(0 == seteuid(m_origUid), "Error in setuid.");
RUNNER_ASSERT_MSG(0 == smack_revoke_subject(m_mySubject.c_str()),
"Error in smack_revoke_subject(" << m_mySubject << ")");
- RUNNER_ASSERT_MSG(0 == smack_set_label_for_self(m_origLabel.c_str()),
- "Error in smack_set_label_for_self.");
+ m_processLabel.reset();
m_inSwitchContext = false;
}
}
/*
- * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2013 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#define _ACCESS_FOR_DUMMIES_H_
#include <string>
+#include <memory>
#include <smack_access.h>
+class ScopedProcessLabel;
+
class AccessProvider {
public:
explicit AccessProvider(const std::string &ownerId);
AccessProvider(const std::string &ownerId, int uid, int gid);
- virtual ~AccessProvider() {}
+ virtual ~AccessProvider();
AccessProvider(const AccessProvider &second) = delete;
AccessProvider& operator=(const AccessProvider &second) = delete;
std::string m_mySubject;
uid_t m_origUid;
gid_t m_origGid;
- std::string m_origLabel;
+ std::unique_ptr<ScopedProcessLabel> m_processLabel;
bool m_inSwitchContext;
};
#include <ckm-common.h>
#include <ckm/ckm-manager.h>
#include <ckm/ckm-control.h>
+#include <scoped_process_label.h>
using namespace CKM;
using namespace std;
MdppState::MdppState()
{
- ScopedLabel sl(USER_LABEL);
+ ScopedProcessLabel spl(USER_LABEL);
m_original = vconf_get_str(VCONFKEY_SECURITY_MDPP_STATE);
}
MdppState::~MdppState()
{
- ScopedLabel sl(USER_LABEL);
+ ScopedProcessLabel spl(USER_LABEL);
if (!m_original)
vconf_set_str(VCONFKEY_SECURITY_MDPP_STATE, UNSET);
else {
void MdppState::set(const char* const value)
{
- ScopedLabel sl(USER_LABEL);
+ ScopedProcessLabel spl(USER_LABEL);
if (value)
{
int ret = vconf_set_str(VCONFKEY_SECURITY_MDPP_STATE, value);
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2016 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
"central-key-manager.service"
};
-void changeLabel(const char *label)
-{
- int ret = smack_set_label_for_self(label);
- RUNNER_ASSERT_MSG(0 == ret,
- "Error in smack_set_label_for_self(" << label << "). Error: " << ret);
-}
-
-} // namespace anonymous
-
-ScopedLabel::ScopedLabel(const char *label) : m_original_label(getLabel())
-{
- changeLabel(label);
-}
-
-ScopedLabel::~ScopedLabel()
-{
- /*
- * Let it throw. If we can't restore label then remaining tests results will be
- * unreliable anyway.
- */
- changeLabel(m_original_label.c_str());
}
void start_service(ServiceIdx idx)
void start_service(ServiceIdx idx);
void stop_service(ServiceIdx idx);
-
-// changes process label upon construction and restores it upon destruction
-class ScopedLabel
-{
-public:
- ScopedLabel(const char* label);
- ~ScopedLabel();
-
-private:
- std::string m_original_label;
-};
+++ /dev/null
-#!/bin/sh
-
-# Copyright (c) 2016-2018 Samsung Electronics Co., Ltd All Rights Reserved
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# @file ckm-tests-on-onlycap.sh
-# @author Kyungwook Tak (k.tak@samsung.com)
-# @brief Run ckm-tests on onlycap environment
-#
-
-# save old label and onlycap
-OLD_LABEL=`cat /proc/self/attr/current`
-OLD_ONLYCAP=`cat /sys/fs/smackfs/onlycap`
-
-# make sure we're in onlycap so original state can be restored later
-# (assume that OLD_LABEL is allowed to change the label)
-echo "System::Privileged" > /proc/self/attr/current || exit
-
-# push test app lables to onlycap label list
-echo "System::Privileged \
- User::Pkg::test_label \
- User::Pkg::test_label_2 \
- User::Pkg::test_label_3 \
- User::Pkg::test_label_4 \
- User::Pkg::test_label_5 \
- System" > /sys/fs/smackfs/onlycap || exit
-
-# set capability for changing smack label of self and add/remove smack rules
-setcap cap_mac_admin=eip /usr/bin/ckm-privileged-tests || exit
-
-# run test
-ckm-privileged-tests "${@}" # propagate all arguments
-
-# restore old onlycap
-echo -n $OLD_ONLYCAP > /sys/fs/smackfs/onlycap
-
-# restore old label
-# (assume that System::Privileged is allowed to do it with $OLD_ONLYCAP)
-echo $OLD_LABEL > /proc/self/attr/current
${PROJECT_SOURCE_DIR}/src/common/sm_policy_request.cpp
${PROJECT_SOURCE_DIR}/src/common/tzplatform.cpp
${PROJECT_SOURCE_DIR}/src/common/privilege_manager.cpp
+ ${PROJECT_SOURCE_DIR}/src/common/scoped_process_label.cpp
)
#system and local includes
/*
- * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2013 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <tests_common.h>
#include <access_provider.h>
+#include <scoped_process_label.h>
namespace SecurityServer {
RUNNER_ASSERT_MSG(0 == smack_revoke_subject(m_myLabel.c_str()),
"Error in smack_revoke_subject(" << m_myLabel << ")");
apply();
- RUNNER_ASSERT_MSG(0 == smack_set_label_for_self(m_myLabel.c_str()),
- "Error in smack_set_label_for_self.");
+ ScopedProcessLabel spl(m_myLabel, false);
RUNNER_ASSERT_MSG(0 == setgid(gid),
"Error in setgid.");
RUNNER_ASSERT_MSG(0 == setuid(uid),
--- /dev/null
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+/*
+ * @file scoped_process_label.cpp
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ * @brief
+ */
+
+#include <scoped_process_label.h>
+
+#include <stdlib.h>
+#include <sys/smack.h>
+
+#include <utility>
+#include <memory>
+#include <fstream>
+
+#include <dpl/test/test_runner.h>
+
+namespace {
+
+const std::string& getOnlycapPath()
+{
+ static std::string onlycapPath;
+
+ if (onlycapPath.empty()) {
+ const char* smackfs = smack_smackfs_path();
+ if (smackfs != nullptr) {
+ onlycapPath.assign(smackfs);
+ onlycapPath.append("/onlycap");
+ }
+ }
+ return onlycapPath;
+}
+
+const char* SEPARATORS = " ";
+
+OnlycapSet smackGetOnlycap()
+{
+ std::ifstream ifs(getOnlycapPath());
+
+ RUNNER_ASSERT_MSG(ifs, "Opening " << getOnlycapPath() << " failed.");
+
+ std::string onlycap((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
+ ifs.close();
+
+ OnlycapSet onlycapSet;
+
+ size_t first = 0;
+ size_t last = 0;
+ while (last != std::string::npos) {
+ first = onlycap.find_first_not_of(SEPARATORS, last);
+ if (first == std::string::npos)
+ break;
+
+ last = onlycap.find_first_of(SEPARATORS, first + 1);
+ onlycapSet.insert(onlycap.substr(first, last - first));
+ }
+ return onlycapSet;
+}
+
+void smackSetOnlycap(const OnlycapSet& onlycapSet)
+{
+ if (onlycapSet.empty()) {
+ int ret = smack_set_onlycap(NULL, 0);
+ RUNNER_ASSERT_MSG(ret == 0, "Error in smack_set_onlycap():" << ret);
+ return;
+ }
+
+ const char* labels[onlycapSet.size()];
+ size_t i = 0;
+ for (const auto& label : onlycapSet) {
+ labels[i] = label.c_str();
+ i++;
+ }
+
+ int ret = smack_set_onlycap(labels, i);
+ RUNNER_ASSERT_MSG(ret == 0, "Error in smack_set_onlycap():" << ret);
+}
+
+void smackSetLabelForSelf(const std::string& label)
+{
+ int ret = smack_set_label_for_self(label.c_str());
+ RUNNER_ASSERT_MSG(ret == 0, "Error in smack_set_label_for_self('" << label << "'): " << ret);
+}
+
+} // namespace anonymous
+
+ScopedProcessLabel::ScopedProcessLabel(std::string label, bool restore) :
+ m_label(std::move(label))
+{
+ if (restore) {
+ // store the current process label
+ char* originalLabel = NULL;
+ ssize_t size = smack_new_label_from_self(&originalLabel);
+ RUNNER_ASSERT_MSG(size > 0 || originalLabel != nullptr,
+ "Error in smack_new_label_from_self():" << size);
+
+ std::unique_ptr<char, decltype(&free)> originalLabelPtr(originalLabel, free);
+ m_originalLabel.assign(originalLabel, size);
+
+ m_originalOnlycap = smackGetOnlycap();
+
+ // add new label to onlycap so that it's able to restore the label
+ if (!m_originalOnlycap.empty()
+ && m_originalOnlycap.find(m_label) == m_originalOnlycap.end()) {
+ OnlycapSet newOnlycap = m_originalOnlycap;
+ newOnlycap.insert(m_label);
+ smackSetOnlycap(newOnlycap);
+ } else {
+ m_originalLabel.clear();
+ m_originalOnlycap.clear();
+ }
+ }
+ smackSetLabelForSelf(m_label);
+}
+
+ScopedProcessLabel::~ScopedProcessLabel()
+{
+ // it has to be restored
+ if (!m_originalLabel.empty()) {
+ try {
+ smackSetLabelForSelf(m_originalLabel);
+ smackSetOnlycap(m_originalOnlycap);
+ } catch (const DPL::Test::TestException& e) {
+ RUNNER_ERROR_MSG("Test exception occurred: " << e.GetMessage());
+ } catch (const std::exception& e) {
+ RUNNER_ERROR_MSG("Std exception occurred: " << e.what());
+ } catch (...) {
+ RUNNER_ERROR_MSG("Unknown exception occurred.");
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+/*
+ * @file scoped_process_label.h
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ * @brief
+ */
+
+#pragma once
+
+#include <string>
+#include <unordered_set>
+
+#include <dpl/noncopyable.h>
+
+typedef std::unordered_set<std::string> OnlycapSet;
+
+class ScopedProcessLabel: public DPL::Noncopyable
+{
+public:
+ // if restore == true the original label will be restored
+ explicit ScopedProcessLabel(std::string label, bool restore = true);
+ ~ScopedProcessLabel();
+
+private:
+ std::string m_label;
+ std::string m_originalLabel;
+ OnlycapSet m_originalOnlycap;
+};
/*
- * Copyright (c) 2013-2015 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2013 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
return 1;
}
-void setLabelForSelf(const int line, const char *label)
-{
- int ret = smack_set_label_for_self(label);
- RUNNER_ASSERT_MSG(ret == 0, "Error in smack_set_label_for_self(): " << ret << ", line: " << line);
-}
-
/*
* Add a new group to the current process groups.
*/
"Child process exited abnormally" <<
": ret=" << ret << ", errno=" << errno << ", status=" << status);
}
-// changes process label
-void change_label(const char* label)
-{
- int ret = smack_set_label_for_self(label);
- RUNNER_ASSERT_MSG(0 == ret, "Error in smack_set_label_for_self("<<label<<"). Error: " << ret);
-}
pid_t runInChild(const std::function<void(void)> &process) {
pid_t pid = fork();
/*
- * Copyright (c) 2013-2015 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2013 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
bool smack_check(void);
int drop_root_privileges(uid_t appUid = APP_UID, gid_t appGid = APP_GID);
-void setLabelForSelf(const int line, const char *label);
void add_process_group(const char* group_name);
void remove_process_group(const char* group_name);
std::string formatCstr(const char *cstr);
void symlinkSafe(const std::string &targetPath, const std::string &linkPath);
void removeDir(const std::string &path);
void waitPid(pid_t pid);
-void change_label(const char* label);
pid_t runInChild(const std::function<void(void)> &process);
void runInChildParentWait(const std::function<void(void)> &process);
/*
- * Copyright (c) 2015-2018 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2015-2019 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <cynara-creds-gdbus.h>
#include <cynara-creds-self.h>
+#include <scoped_process_label.h>
class ProcessCredentials {
public:
void testSelfClientSmack(cynara_client_creds method = CLIENT_METHOD_SMACK) {
std::string label = "test-label";
- change_label(label.c_str());
+ ScopedProcessLabel spl(label, false);
testCredsClientSelf(method, label);
}
+++ /dev/null
-/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <sys/smack.h>
-
-class ScopedProcessLabel {
-public:
- ScopedProcessLabel() {
- smack_new_label_from_self(&label);
- }
-
- ~ScopedProcessLabel() {
- smack_set_label_for_self(label);
- free(label);
- }
-
-private:
- char *label;
-};
/*
- * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2016 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <app-runtime.h>
#include <sys/smack.h>
#include <privilege_info.h>
+#include <scoped_process_label.h>
#include <cynara_test_client.h>
#include <dpl/test/test_runner.h>
const std::string &testPath, int accessType) {
auto fun = [&](){
int oppositeAccessType = getOppositeAccessType(accessType);
- change_label(label.c_str());
+ ScopedProcessLabel spl(label, false);
RUNNER_ASSERT_ERRNO_MSG(0 == drop_root_privileges(uid, gid),
"drop_root_privileges failed.");
/*
- * Copyright (c) 2016-2017 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2016 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <message_pipe.h>
#include <policy_configuration.h>
#include <scoped_installer.h>
-#include <scoped_label.h>
#include <service_manager.h>
#include <sm_api.h>
#include <sm_commons.h>
#include <tests_common.h>
#include <tzplatform.h>
#include <uds.h>
+#include <scoped_process_label.h>
using namespace SecurityManagerTest;
AppInstallHelper app("sm_test_25e");
- change_label("_");
+ ScopedProcessLabel spl("_", false);
RUNNER_ASSERT_ERRNO_MSG(drop_root_privileges(testUser.getUid(), testUser.getGid()) == 0,
"drop_root_privileges failed");
AppInstallHelper app("sm_test_25f");
- change_label("_");
+ ScopedProcessLabel spl("_", false);
RUNNER_ASSERT_ERRNO_MSG(drop_root_privileges(testUser.getUid(), testUser.getGid()) == 0,
"drop_root_privileges failed");
InstallRequest invalidReq;
#!/bin/sh
#####################################################################
-# Copyright (c) 2012-2018 Samsung Electronics Co., Ltd All Rights Reserved
+# Copyright (c) 2012 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
echo "========================================================================="
echo "KEY MANAGER PRIVILEGED TESTS"
echo
- ckm-tests-on-onlycap.sh $ARGS
+ ckm-privileged-tests $ARGS
;;
"yaca")
echo "========================================================================="
projects / platform / core / test / security-tests.git / commitdiff