src/security-manager-tests/common/policy_configuration.cpp

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 #include <fstream>
  18 #include <regex>
  19 #include <string>
  20 #include <vector>
  21
  22 #include <grp.h>
  23 #include <sys/types.h>
  24 #include <unistd.h>
  25
  26 #include <dpl/test/test_runner.h>
  27 #include <dpl/test/test_runner_child.h>
  28 #include <policy_configuration.h>
  29
  30 #define CONF_DIR "/usr/share/security-manager/policy/"
  31 #define CONF_GROUP_FILE "privilege-group.list"
  32 #define CONF_USER_TEMPLATE_FILE "usertype-%s.profile"
  33
  34 namespace SecurityManagerTest {
  35
  36 gid_t nameToGid(const char *name) {
  37     struct group entry, *gresult;
  38     char buffer[1024];
  39     RUNNER_ASSERT_MSG(
  40         0 == getgrnam_r(name, &entry, buffer, 1024, &gresult) && (gresult != NULL),
  41         "Error in getgrnam. Group name: " << name);
  42     return entry.gr_gid;
  43 }
  44
  45
  46 std::string PolicyConfiguration::getConfigFilePath(UserType userType) {
  47     const char *user = NULL;
  48     switch(userType) {
  49     case GUEST:  user = "guest"; break;
  50     case NORMAL: user = "normal"; break;
  51     case ADMIN:  user = "admin"; break;
  52     case SYSTEM: user = "system"; break;
  53     }
  54     char buffer[1024];
  55     snprintf(buffer, 1024, CONF_DIR CONF_USER_TEMPLATE_FILE, user);
  56     return std::string(buffer);
  57 }
  58
  59 PolicyConfiguration::PrivVector PolicyConfiguration::getUserPriv(PolicyConfiguration::UserType userType) {
  60     return getUserDescription(userType).privVector;
  61 }
  62
  63 PolicyConfiguration::GroupVector PolicyConfiguration::getUserGroup(PolicyConfiguration::UserType userType) {
  64     return getUserDescription(userType).groupVector;
  65 }
  66
  67 PolicyConfiguration::GidVector PolicyConfiguration::getUserGid(PolicyConfiguration::UserType userType) {
  68     return getUserDescription(userType).gidVector;
  69 }
  70
  71 PolicyConfiguration::GidVector PolicyConfiguration::getGid() {
  72     return groupToGid(getGroup());
  73 }
  74
  75 PolicyConfiguration::GroupVector PolicyConfiguration::getGroup() {
  76     GroupVector result;
  77     if (m_privGroupMap.empty())
  78         loadPrivGroupMap();
  79     for (auto &e : m_privGroupMap)
  80         result.push_back(e.second);
  81     return result;
  82 }
  83
  84 PolicyConfiguration::UserDescription& PolicyConfiguration::getUserDescription(PolicyConfiguration::UserType userType) {
  85     auto it = m_userDescriptionMap.find(userType);
  86     if (it == m_userDescriptionMap.end())
  87         m_userDescriptionMap[userType] = loadUserDescription(userType);
  88     return m_userDescriptionMap[userType];
  89 }
  90
  91 gid_t PolicyConfiguration::groupToGid(const std::string &gname) {
  92     auto it = m_groupGidMap.find(gname);
  93     if (it == m_groupGidMap.end())
  94         m_groupGidMap[gname] = nameToGid(gname.c_str());
  95     return m_groupGidMap[gname];
  96 }
  97
  98 PolicyConfiguration::GidVector PolicyConfiguration::groupToGid(const PolicyConfiguration::GroupVector &groupVector) {
  99     GidVector result;
 100     for (auto &e : groupVector)
 101         result.push_back(groupToGid(e));
 102     return result;
 103 }
 104
 105 bool PolicyConfiguration::getIsAskuserEnabled() {
 106 #ifdef ASKUSER_ENABLED
 107     return true;
 108 #else
 109     return false;
 110 #endif
 111 }
 112
 113 PolicyConfiguration::UserDescription PolicyConfiguration::loadUserDescription(PolicyConfiguration::UserType userType) {
 114     UserDescription result;
 115     std::string path = getConfigFilePath(userType);
 116     result.privVector = loadPrivFile(path);
 117     result.groupVector = privToGroup(result.privVector);
 118     result.gidVector = groupToGid(result.groupVector);
 119     return result;
 120 }
 121
 122 PolicyConfiguration::PrivVector PolicyConfiguration::loadPrivFile(const std::string &path) {
 123     PrivVector result;
 124     std::ifstream file(path);
 125     std::string line;
 126     std::regex r("^\\*[ \t]+(.*)");
 127     while (std::getline(file, line)) {
 128         std::smatch m;
 129         if (std::regex_search(line, m, r))
 130             result.push_back(m[1]);
 131     }
 132     return result;
 133 }
 134
 135 PolicyConfiguration::GroupVector PolicyConfiguration::privToGroup(const PolicyConfiguration::PrivVector &privVector) {
 136     GroupVector result;
 137     if (m_privGroupMap.empty())
 138         loadPrivGroupMap();
 139     for (auto &e : privVector) {
 140         auto it = m_privGroupMap.find(e);
 141         if (it == m_privGroupMap.end())
 142             continue;
 143         result.push_back(it->second);
 144     }
 145     return result;
 146 }
 147
 148 void PolicyConfiguration::loadPrivGroupMap(void) {
 149     std::string pgPath(CONF_DIR CONF_GROUP_FILE);
 150     std::ifstream file(pgPath);
 151
 152     RUNNER_ASSERT_MSG(file.is_open(),
 153       "Unable to read group mapping file " << pgPath);
 154
 155     std::string line;
 156     std::regex r("^(http(.*)) +(.*)");
 157     while (std::getline(file, line)) {
 158         std::smatch m;
 159         if (std::regex_search(line, m, r))
 160             m_privGroupMap[m[1]] = m[3];
 161     }
 162 }
 163
 164 } // namespace SecurityManagerTest
 165