shibsp/impl/XMLAccessControl.cpp

   1 /*\r
   2  *  Copyright 2001-2007 Internet2\r
   3  * \r
   4  * Licensed under the Apache License, Version 2.0 (the "License");\r
   5  * you may not use this file except in compliance with the License.\r
   6  * You may obtain a copy of the License at\r
   7  *\r
   8  *     http://www.apache.org/licenses/LICENSE-2.0\r
   9  *\r
  10  * Unless required by applicable law or agreed to in writing, software\r
  11  * distributed under the License is distributed on an "AS IS" BASIS,\r
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  13  * See the License for the specific language governing permissions and\r
  14  * limitations under the License.\r
  15  */\r
  16 \r
  17 /**\r
  18  * XMLAccessControl.cpp\r
  19  *\r
  20  * XML-based access control syntax\r
  21  */\r
  22 \r
  23 #include "internal.h"\r
  24 #include "exceptions.h"\r
  25 #include "AccessControl.h"\r
  26 #include "SessionCache.h"\r
  27 #include "SPRequest.h"\r
  28 #include "attribute/Attribute.h"\r
  29 \r
  30 #include <xmltooling/util/ReloadableXMLFile.h>\r
  31 #include <xmltooling/util/XMLHelper.h>\r
  32 #include <xercesc/util/XMLUniDefs.hpp>\r
  33 \r
  34 #ifndef HAVE_STRCASECMP\r
  35 # define strcasecmp _stricmp\r
  36 #endif\r
  37 \r
  38 using namespace shibsp;\r
  39 using namespace xmltooling;\r
  40 using namespace std;\r
  41 \r
  42 namespace {\r
  43     \r
  44     class Rule : public AccessControl\r
  45     {\r
  46     public:\r
  47         Rule(const DOMElement* e);\r
  48         ~Rule() {}\r
  49 \r
  50         Lockable* lock() {return this;}\r
  51         void unlock() {}\r
  52 \r
  53         aclresult_t authorized(const SPRequest& request, const Session* session) const;\r
  54     \r
  55     private:\r
  56         string m_alias;\r
  57         vector <string> m_vals;\r
  58     };\r
  59     \r
  60     class Operator : public AccessControl\r
  61     {\r
  62     public:\r
  63         Operator(const DOMElement* e);\r
  64         ~Operator();\r
  65 \r
  66         Lockable* lock() {return this;}\r
  67         void unlock() {}\r
  68 \r
  69         aclresult_t authorized(const SPRequest& request, const Session* session) const;\r
  70         \r
  71     private:\r
  72         enum operator_t { OP_NOT, OP_AND, OP_OR } m_op;\r
  73         vector<AccessControl*> m_operands;\r
  74     };\r
  75 \r
  76 #if defined (_MSC_VER)\r
  77     #pragma warning( push )\r
  78     #pragma warning( disable : 4250 )\r
  79 #endif\r
  80 \r
  81     class XMLAccessControl : public AccessControl, public ReloadableXMLFile\r
  82     {\r
  83     public:\r
  84         XMLAccessControl(const DOMElement* e)\r
  85                 : ReloadableXMLFile(e, Category::getInstance(SHIBSP_LOGCAT".AccessControl")), m_rootAuthz(NULL) {\r
  86             load(); // guarantees an exception or the policy is loaded\r
  87         }\r
  88         \r
  89         ~XMLAccessControl() {\r
  90             delete m_rootAuthz;\r
  91         }\r
  92 \r
  93         aclresult_t authorized(const SPRequest& request, const Session* session) const;\r
  94 \r
  95     protected:\r
  96         pair<bool,DOMElement*> load();\r
  97 \r
  98     private:\r
  99         AccessControl* m_rootAuthz;\r
 100     };\r
 101 \r
 102 #if defined (_MSC_VER)\r
 103     #pragma warning( pop )\r
 104 #endif\r
 105 \r
 106     AccessControl* SHIBSP_DLLLOCAL XMLAccessControlFactory(const DOMElement* const & e)\r
 107     {\r
 108         return new XMLAccessControl(e);\r
 109     }\r
 110 \r
 111     static const XMLCh _AccessControl[] =    UNICODE_LITERAL_13(A,c,c,e,s,s,C,o,n,t,r,o,l);\r
 112     static const XMLCh require[] =          UNICODE_LITERAL_7(r,e,q,u,i,r,e);\r
 113     static const XMLCh NOT[] =              UNICODE_LITERAL_3(N,O,T);\r
 114     static const XMLCh AND[] =              UNICODE_LITERAL_3(A,N,D);\r
 115     static const XMLCh OR[] =               UNICODE_LITERAL_2(O,R);\r
 116     static const XMLCh _Rule[] =            UNICODE_LITERAL_4(R,u,l,e);\r
 117 }\r
 118 \r
 119 void SHIBSP_API shibsp::registerAccessControls()\r
 120 {\r
 121     SPConfig& conf=SPConfig::getConfig();\r
 122     conf.AccessControlManager.registerFactory(XML_ACCESS_CONTROL, XMLAccessControlFactory);\r
 123     conf.AccessControlManager.registerFactory("edu.internet2.middleware.shibboleth.sp.provider.XMLAccessControl", XMLAccessControlFactory);\r
 124 }\r
 125 \r
 126 Rule::Rule(const DOMElement* e)\r
 127 {\r
 128     xmltooling::auto_ptr_char req(e->getAttributeNS(NULL,require));\r
 129     if (!req.get() || !*req.get())\r
 130         throw ConfigurationException("Access control rule missing require attribute");\r
 131     m_alias=req.get();\r
 132     \r
 133     xmltooling::auto_ptr_char vals(e->hasChildNodes() ? e->getFirstChild()->getNodeValue() : NULL);\r
 134 #ifdef HAVE_STRTOK_R\r
 135     char* pos=NULL;\r
 136     const char* token=strtok_r(const_cast<char*>(vals.get())," ",&pos);\r
 137 #else\r
 138     const char* token=strtok(const_cast<char*>(vals.get())," ");\r
 139 #endif\r
 140     while (token) {\r
 141         m_vals.push_back(token);\r
 142 #ifdef HAVE_STRTOK_R\r
 143         token=strtok_r(NULL," ",&pos);\r
 144 #else\r
 145         token=strtok(NULL," ");\r
 146 #endif\r
 147     }\r
 148 }\r
 149 \r
 150 AccessControl::aclresult_t Rule::authorized(const SPRequest& request, const Session* session) const\r
 151 {\r
 152     // We can make this more complex later using pluggable comparison functions,\r
 153     // but for now, just a straight port to the new Attribute API.\r
 154 \r
 155     // Map alias in rule to the attribute.\r
 156     if (!session) {\r
 157         request.log(SPRequest::SPWarn, "AccessControl plugin not given a valid session to evaluate, are you using lazy sessions?");\r
 158         return shib_acl_false;\r
 159     }\r
 160     \r
 161     if (m_alias == "valid-user") {\r
 162         if (session) {\r
 163             request.log(SPRequest::SPDebug,"AccessControl plugin accepting valid-user based on active session");\r
 164             return shib_acl_true;\r
 165         }\r
 166         return shib_acl_false;\r
 167     }\r
 168     if (m_alias == "user") {\r
 169         for (vector<string>::const_iterator i=m_vals.begin(); i!=m_vals.end(); ++i) {\r
 170             if (*i == request.getRemoteUser()) {\r
 171                 request.log(SPRequest::SPDebug, string("AccessControl plugin expecting REMOTE_USER (") + *i + "), authz granted");\r
 172                 return shib_acl_true;\r
 173             }\r
 174         }\r
 175         return shib_acl_false;\r
 176     }\r
 177     else if (m_alias == "authnContextClassRef") {\r
 178         const char* ref = session->getAuthnContextClassRef();\r
 179         for (vector<string>::const_iterator i=m_vals.begin(); ref && i!=m_vals.end(); ++i) {\r
 180             if (!strcmp(i->c_str(),ref)) {\r
 181                 request.log(SPRequest::SPDebug, string("AccessControl plugin expecting authnContextClassRef (") + *i + "), authz granted");\r
 182                 return shib_acl_true;\r
 183             }\r
 184         }\r
 185         return shib_acl_false;\r
 186     }\r
 187     else if (m_alias == "authnContextDeclRef") {\r
 188         const char* ref = session->getAuthnContextDeclRef();\r
 189         for (vector<string>::const_iterator i=m_vals.begin(); ref && i!=m_vals.end(); ++i) {\r
 190             if (!strcmp(i->c_str(),ref)) {\r
 191                 request.log(SPRequest::SPDebug, string("AccessControl plugin expecting authnContextDeclRef (") + *i + "), authz granted");\r
 192                 return shib_acl_true;\r
 193             }\r
 194         }\r
 195         return shib_acl_false;\r
 196     }\r
 197 \r
 198     // Find the attribute(s) matching the require rule.\r
 199     pair<multimap<string,const Attribute*>::const_iterator, multimap<string,const Attribute*>::const_iterator> attrs =\r
 200         session->getIndexedAttributes().equal_range(m_alias);\r
 201     if (attrs.first == attrs.second) {\r
 202         request.log(SPRequest::SPWarn, string("rule requires attribute (") + m_alias + "), not found in session");\r
 203         return shib_acl_false;\r
 204     }\r
 205 \r
 206     for (; attrs.first != attrs.second; ++attrs.first) {\r
 207         bool caseSensitive = attrs.first->second->isCaseSensitive();\r
 208 \r
 209         // Now we have to intersect the attribute's values against the rule's list.\r
 210         const vector<string>& vals = attrs.first->second->getSerializedValues();\r
 211         for (vector<string>::const_iterator i=m_vals.begin(); i!=m_vals.end(); ++i) {\r
 212             for (vector<string>::const_iterator j=vals.begin(); j!=vals.end(); ++j) {\r
 213                 if ((caseSensitive && *i == *j) || (!caseSensitive && !strcasecmp(i->c_str(),j->c_str()))) {\r
 214                     request.log(SPRequest::SPDebug, string("AccessControl plugin expecting (") + *j + "), authz granted");\r
 215                     return shib_acl_true;\r
 216                 }\r
 217             }\r
 218         }\r
 219     }\r
 220 \r
 221     return shib_acl_false;\r
 222 }\r
 223 \r
 224 Operator::Operator(const DOMElement* e)\r
 225 {\r
 226     if (XMLString::equals(e->getLocalName(),NOT))\r
 227         m_op=OP_NOT;\r
 228     else if (XMLString::equals(e->getLocalName(),AND))\r
 229         m_op=OP_AND;\r
 230     else if (XMLString::equals(e->getLocalName(),OR))\r
 231         m_op=OP_OR;\r
 232     else\r
 233         throw ConfigurationException("Unrecognized operator in access control rule");\r
 234     \r
 235     try {\r
 236         e=XMLHelper::getFirstChildElement(e);\r
 237         if (XMLString::equals(e->getLocalName(),_Rule))\r
 238             m_operands.push_back(new Rule(e));\r
 239         else\r
 240             m_operands.push_back(new Operator(e));\r
 241         \r
 242         if (m_op==OP_NOT)\r
 243             return;\r
 244         \r
 245         e=XMLHelper::getNextSiblingElement(e);\r
 246         while (e) {\r
 247             if (XMLString::equals(e->getLocalName(),_Rule))\r
 248                 m_operands.push_back(new Rule(e));\r
 249             else\r
 250                 m_operands.push_back(new Operator(e));\r
 251             e=XMLHelper::getNextSiblingElement(e);\r
 252         }\r
 253     }\r
 254     catch (exception&) {\r
 255         for_each(m_operands.begin(),m_operands.end(),xmltooling::cleanup<AccessControl>());\r
 256         throw;\r
 257     }\r
 258 }\r
 259 \r
 260 Operator::~Operator()\r
 261 {\r
 262     for_each(m_operands.begin(),m_operands.end(),xmltooling::cleanup<AccessControl>());\r
 263 }\r
 264 \r
 265 AccessControl::aclresult_t Operator::authorized(const SPRequest& request, const Session* session) const\r
 266 {\r
 267     switch (m_op) {\r
 268         case OP_NOT:\r
 269             switch (m_operands.front()->authorized(request,session)) {\r
 270                 case shib_acl_true:\r
 271                     return shib_acl_false;\r
 272                 case shib_acl_false:\r
 273                     return shib_acl_true;\r
 274                 default:\r
 275                     return shib_acl_indeterminate;\r
 276             }\r
 277         \r
 278         case OP_AND:\r
 279         {\r
 280             for (vector<AccessControl*>::const_iterator i=m_operands.begin(); i!=m_operands.end(); i++) {\r
 281                 if ((*i)->authorized(request,session) != shib_acl_true)\r
 282                     return shib_acl_false;\r
 283             }\r
 284             return shib_acl_true;\r
 285         }\r
 286         \r
 287         case OP_OR:\r
 288         {\r
 289             for (vector<AccessControl*>::const_iterator i=m_operands.begin(); i!=m_operands.end(); i++) {\r
 290                 if ((*i)->authorized(request,session) == shib_acl_true)\r
 291                     return shib_acl_true;\r
 292             }\r
 293             return shib_acl_false;\r
 294         }\r
 295     }\r
 296     request.log(SPRequest::SPWarn,"unknown operation in access control policy, denying access");\r
 297     return shib_acl_false;\r
 298 }\r
 299 \r
 300 pair<bool,DOMElement*> XMLAccessControl::load()\r
 301 {\r
 302     // Load from source using base class.\r
 303     pair<bool,DOMElement*> raw = ReloadableXMLFile::load();\r
 304     \r
 305     // If we own it, wrap it.\r
 306     XercesJanitor<DOMDocument> docjanitor(raw.first ? raw.second->getOwnerDocument() : NULL);\r
 307 \r
 308     // Check for AccessControl wrapper and drop a level.\r
 309     if (XMLString::equals(raw.second->getLocalName(),_AccessControl))\r
 310         raw.second = XMLHelper::getFirstChildElement(raw.second);\r
 311     \r
 312     AccessControl* authz;\r
 313     if (XMLString::equals(raw.second->getLocalName(),_Rule))\r
 314         authz=new Rule(raw.second);\r
 315     else\r
 316         authz=new Operator(raw.second);\r
 317 \r
 318     delete m_rootAuthz;\r
 319     m_rootAuthz = authz;\r
 320     return make_pair(false,(DOMElement*)NULL);\r
 321 }\r
 322 \r
 323 AccessControl::aclresult_t XMLAccessControl::authorized(const SPRequest& request, const Session* session) const\r
 324 {\r
 325     return m_rootAuthz ? m_rootAuthz->authorized(request,session) : shib_acl_false;\r
 326 }\r