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 PolicyConfiguration::PrivGroupMap PolicyConfiguration::getPrivGroupMap()
 106 {
 107     if (m_privGroupMap.empty())
 108         loadPrivGroupMap();
 109     return m_privGroupMap;
 110 }
 111
 112 bool PolicyConfiguration::getIsAskuserEnabled() {
 113 #ifdef ASKUSER_ENABLED
 114     return true;
 115 #else
 116     return false;
 117 #endif
 118 }
 119
 120 PolicyConfiguration::UserDescription PolicyConfiguration::loadUserDescription(PolicyConfiguration::UserType userType) {
 121     UserDescription result;
 122     std::string path = getConfigFilePath(userType);
 123     result.privVector = loadPrivFile(path);
 124     result.groupVector = privToGroup(result.privVector);
 125     result.gidVector = groupToGid(result.groupVector);
 126     return result;
 127 }
 128
 129 PolicyConfiguration::PrivVector PolicyConfiguration::loadPrivFile(const std::string &path) {
 130     PrivVector result;
 131     std::ifstream file(path);
 132     std::string line;
 133     std::regex r("^\\*[ \t]+(.*)");
 134     while (std::getline(file, line)) {
 135         std::smatch m;
 136         if (std::regex_search(line, m, r))
 137             result.push_back(m[1]);
 138     }
 139     return result;
 140 }
 141
 142 PolicyConfiguration::GroupVector PolicyConfiguration::privToGroup(const PolicyConfiguration::PrivVector &privVector) {
 143     GroupVector result;
 144     if (m_privGroupMap.empty())
 145         loadPrivGroupMap();
 146     for (auto &e : privVector) {
 147         auto it = m_privGroupMap.find(e);
 148         if (it == m_privGroupMap.end())
 149             continue;
 150         result.push_back(it->second);
 151     }
 152     return result;
 153 }
 154
 155 void PolicyConfiguration::loadPrivGroupMap(void) {
 156     std::string pgPath(CONF_DIR CONF_GROUP_FILE);
 157     std::ifstream file(pgPath);
 158
 159     RUNNER_ASSERT_MSG(file.is_open(),
 160       "Unable to read group mapping file " << pgPath);
 161
 162     std::string line;
 163     std::regex r("^(http(.*)) +(.*)");
 164     while (std::getline(file, line)) {
 165         std::smatch m;
 166         if (std::regex_search(line, m, r))
 167             m_privGroupMap[m[1]] = m[3];
 168     }
 169 }
 170
 171 } // namespace SecurityManagerTest
 172