xmlproviders/XMLMetadata.cpp

   1 /*
   2  * The Shibboleth License, Version 1.
   3  * Copyright (c) 2002
   4  * University Corporation for Advanced Internet Development, Inc.
   5  * All rights reserved
   6  *
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are met:
  10  *
  11  * Redistributions of source code must retain the above copyright notice, this
  12  * list of conditions and the following disclaimer.
  13  *
  14  * Redistributions in binary form must reproduce the above copyright notice,
  15  * this list of conditions and the following disclaimer in the documentation
  16  * and/or other materials provided with the distribution, if any, must include
  17  * the following acknowledgment: "This product includes software developed by
  18  * the University Corporation for Advanced Internet Development
  19  * <http://www.ucaid.edu>Internet2 Project. Alternately, this acknowledegement
  20  * may appear in the software itself, if and wherever such third-party
  21  * acknowledgments normally appear.
  22  *
  23  * Neither the name of Shibboleth nor the names of its contributors, nor
  24  * Internet2, nor the University Corporation for Advanced Internet Development,
  25  * Inc., nor UCAID may be used to endorse or promote products derived from this
  26  * software without specific prior written permission. For written permission,
  27  * please contact shibboleth@shibboleth.org
  28  *
  29  * Products derived from this software may not be called Shibboleth, Internet2,
  30  * UCAID, or the University Corporation for Advanced Internet Development, nor
  31  * may Shibboleth appear in their name, without prior written permission of the
  32  * University Corporation for Advanced Internet Development.
  33  *
  34  *
  35  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  36  * AND WITH ALL FAULTS. ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  37  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  38  * PARTICULAR PURPOSE, AND NON-INFRINGEMENT ARE DISCLAIMED AND THE ENTIRE RISK
  39  * OF SATISFACTORY QUALITY, PERFORMANCE, ACCURACY, AND EFFORT IS WITH LICENSEE.
  40  * IN NO EVENT SHALL THE COPYRIGHT OWNER, CONTRIBUTORS OR THE UNIVERSITY
  41  * CORPORATION FOR ADVANCED INTERNET DEVELOPMENT, INC. BE LIABLE FOR ANY DIRECT,
  42  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  43  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  44  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  45  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  46  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  47  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48  */
  49
  50 /* XMLMetadata.cpp - a metadata implementation that uses an XML-based registry
  51
  52    Scott Cantor
  53    9/27/02
  54
  55    $History:$
  56 */
  57
  58 #include "internal.h"
  59
  60 #include <sys/types.h>
  61 #include <sys/stat.h>
  62
  63 #include <log4cpp/Category.hh>
  64 #include <xsec/enc/OpenSSL/OpenSSLCryptoX509.hpp>
  65
  66 using namespace shibboleth;
  67 using namespace saml;
  68 using namespace log4cpp;
  69 using namespace std;
  70
  71 namespace {
  72
  73     class XMLMetadataImpl : public ReloadableXMLFileImpl
  74     {
  75     public:
  76         XMLMetadataImpl(const char* pathname) : ReloadableXMLFileImpl(pathname) { init(); }
  77         XMLMetadataImpl(const DOMElement* e) : ReloadableXMLFileImpl(e) { init(); }
  78         void init();
  79         ~XMLMetadataImpl();
  80
  81         class ContactPerson : public IContactPerson
  82         {
  83         public:
  84             ContactPerson(const DOMElement* e);
  85             ~ContactPerson() {}
  86
  87             ContactType getType() const { return m_type; }
  88             const char* getCompany() const { return NULL; }
  89             const char* getName() const { return m_name.get(); }
  90             Iterator<string> getEmails() const { return m_emails; }
  91             Iterator<string> getTelephones() const { return EMPTY(string); }
  92             const DOMElement* getElement() const { return m_root; }
  93
  94         private:
  95             const DOMElement* m_root;
  96             ContactType m_type;
  97             auto_ptr_char m_name;
  98             vector<string> m_emails;
  99         };
 100
 101         class Provider;
 102
 103         class KeyDescriptor : public IKeyDescriptor
 104         {
 105         public:
 106             KeyDescriptor() : m_klist(NULL) {}
 107             ~KeyDescriptor() {}
 108
 109             KeyUse getUse() const { return signing; }
 110             const XMLCh* getEncryptionMethod() const { return NULL; }
 111             int getKeySize() const { return 0; }
 112             DSIGKeyInfoList* getKeyInfo() const { return &m_klist; }
 113             const DOMElement* getElement() const { return NULL; }
 114
 115         private:
 116             mutable DSIGKeyInfoList m_klist;
 117             friend class Provider;
 118         };
 119
 120         class Role : public virtual IProviderRole
 121         {
 122         public:
 123             Role(const Provider* provider, const DOMElement* e) : m_provider(provider), m_root(e) { }
 124             ~Role();
 125
 126             // External contract
 127             const IProvider* getProvider() const {return m_provider;}
 128             Iterator<const XMLCh*> getProtocolSupportEnumeration() const {return m_protocolEnum;}
 129             bool hasSupport(const XMLCh* version) const;
 130             Iterator<const IKeyDescriptor*> getKeyDescriptors() const {return m_keys;}
 131             const IOrganization* getOrganization() const {return NULL;}
 132             Iterator<const IContactPerson*> getContacts() const {return m_provider->getContacts();}
 133             Iterator<const IEndpoint*> getDefaultEndpoints() const {return EMPTY(const IEndpoint*);}
 134             const char* getErrorURL() const {return m_provider->getErrorURL();}
 135             const DOMElement* getElement() const {return m_root;}
 136
 137         protected:
 138             vector<const XMLCh*> m_protocolEnum;
 139
 140         private:
 141             const Provider* m_provider;
 142             const DOMElement* m_root;
 143             vector<const IKeyDescriptor*> m_keys;
 144             friend class Provider;
 145         };
 146
 147         class Endpoint : public IEndpoint
 148         {
 149         public:
 150             Endpoint(const XMLCh* binding, const XMLCh* loc) : m_binding(binding), m_location(loc) {}
 151             ~Endpoint() {}
 152
 153             const XMLCh* getBinding() const { return m_binding; }
 154             const XMLCh* getVersion() const { return NULL; }
 155             const XMLCh* getLocation() const { return m_location; }
 156             const XMLCh* getResponseLocation() const { return NULL; }
 157             const DOMElement* getElement() const { return NULL; }
 158
 159         private:
 160             const XMLCh* m_binding;
 161             const XMLCh* m_location;
 162         };
 163
 164         class SSORole : public Role, public virtual ISSOProviderRole
 165         {
 166         public:
 167             SSORole(const Provider* provider, const DOMElement* e) : Role(provider,e) {}
 168             ~SSORole() {}
 169             Iterator<const IEndpoint*> getSingleLogoutServices() const {return EMPTY(const IEndpoint*);}
 170             Iterator<const IEndpoint*> getManageNameIdentifierServices() const {return EMPTY(const IEndpoint*);}
 171         };
 172
 173         class IDPRole : public SSORole, public virtual IIDPProviderRole
 174         {
 175         public:
 176             IDPRole(const Provider* provider, const DOMElement* e) : SSORole(provider,e) {m_protocolEnum.push_back(::XML::SHIB_NS);}
 177             ~IDPRole() {}
 178             Iterator<const IEndpoint*> getSingleSignOnServices() const {return m_pepv;}
 179
 180         private:
 181             vector<Endpoint> m_epv;
 182             vector<const IEndpoint*> m_pepv;
 183             friend class Provider;
 184         };
 185
 186         class AARole : public Role, public virtual IAttributeAuthorityRole
 187         {
 188         public:
 189             AARole(const Provider* provider, const DOMElement* e) : Role(provider,e) {m_protocolEnum.push_back(saml::XML::SAMLP_NS);}
 190             ~AARole() {}
 191             Iterator<const IEndpoint*> getAttributeServices() const {return m_pepv;}
 192
 193         private:
 194             vector<Endpoint> m_epv;
 195             vector<const IEndpoint*> m_pepv;
 196             friend class Provider;
 197         };
 198
 199         class Provider : public IProvider
 200         {
 201         public:
 202             Provider(const DOMElement* e);
 203             ~Provider();
 204
 205             // External contract
 206             const XMLCh* getId() const {return m_id;}
 207             Iterator<const XMLCh*> getGroups() const {return m_groups;}
 208             const IOrganization* getOrganization() const {return NULL;}
 209             Iterator<const IContactPerson*> getContacts() const {return m_contacts;}
 210             Iterator<const IProviderRole*> getRoles() const {return m_roles;}
 211             const DOMElement* getElement() const {return m_root;}
 212             Iterator<std::pair<const XMLCh*,bool> > getSecurityDomains() const {return m_domains;}
 213
 214             // Used internally
 215             const char* getErrorURL() const {return m_errorURL.get();}
 216         private:
 217             friend class XMLMetadataImpl;
 218             const XMLCh* m_id;
 219             const DOMElement* m_root;
 220             auto_ptr_char m_errorURL;
 221             vector<const IContactPerson*> m_contacts;
 222             vector<const IProviderRole*> m_roles;
 223             IDPRole* m_IDP;
 224             AARole* m_AA;
 225             vector<pair<const XMLCh*,bool> > m_domains;
 226             vector<const XMLCh*> m_groups;
 227         };
 228
 229     #ifdef HAVE_GOOD_STL
 230         typedef map<xstring,Provider*> sitemap_t;
 231     #else
 232         typedef map<string,Provider*> sitemap_t;
 233     #endif
 234         sitemap_t m_sites;
 235     };
 236
 237     class XMLMetadata : public IMetadata, public ReloadableXMLFile
 238     {
 239     public:
 240         XMLMetadata(const DOMElement* e) : ReloadableXMLFile(e) {}
 241         ~XMLMetadata() {}
 242
 243         const IProvider* lookup(const XMLCh* providerId) const;
 244
 245     protected:
 246         virtual ReloadableXMLFileImpl* newImplementation(const char* pathname, bool first=true) const;
 247         virtual ReloadableXMLFileImpl* newImplementation(const DOMElement* e, bool first=true) const;
 248     };
 249 }
 250
 251 IPlugIn* XMLMetadataFactory(const DOMElement* e)
 252 {
 253     XMLMetadata* m=new XMLMetadata(e);
 254     try {
 255         m->getImplementation();
 256     }
 257     catch (...) {
 258         delete m;
 259         throw;
 260     }
 261     return m;
 262 }
 263
 264 ReloadableXMLFileImpl* XMLMetadata::newImplementation(const DOMElement* e, bool first) const
 265 {
 266     return new XMLMetadataImpl(e);
 267 }
 268
 269 ReloadableXMLFileImpl* XMLMetadata::newImplementation(const char* pathname, bool first) const
 270 {
 271     return new XMLMetadataImpl(pathname);
 272 }
 273
 274 XMLMetadataImpl::Role::~Role()
 275 {
 276     for (vector<const IKeyDescriptor*>::iterator i=m_keys.begin(); i!=m_keys.end(); i++)
 277         delete const_cast<IKeyDescriptor*>(*i);
 278 }
 279
 280 bool XMLMetadataImpl::Role::hasSupport(const XMLCh* version) const
 281 {
 282     Iterator<const XMLCh*> i(m_protocolEnum);
 283     while (i.hasNext()) {
 284         if (!XMLString::compareString(version,i.next()))
 285             return true;
 286     }
 287     return false;
 288 }
 289
 290 XMLMetadataImpl::ContactPerson::ContactPerson(const DOMElement* e) : m_root(e), m_name(e->getAttributeNS(NULL,SHIB_L(Name)))
 291 {
 292     ContactPerson::ContactType type;
 293     if (!XMLString::compareString(e->getAttributeNS(NULL,SHIB_L(Type)),SHIB_L(technical)))
 294         m_type=IContactPerson::technical;
 295     else if (!XMLString::compareString(e->getAttributeNS(NULL,SHIB_L(Type)),SHIB_L(support)))
 296         type=IContactPerson::support;
 297     else if (!XMLString::compareString(e->getAttributeNS(NULL,SHIB_L(Type)),SHIB_L(administrative)))
 298         type=IContactPerson::administrative;
 299     else if (!XMLString::compareString(e->getAttributeNS(NULL,SHIB_L(Type)),SHIB_L(billing)))
 300         type=IContactPerson::billing;
 301     else if (!XMLString::compareString(e->getAttributeNS(NULL,SHIB_L(Type)),SHIB_L(other)))
 302         type=IContactPerson::other;
 303
 304     auto_ptr_char temp(e->getAttributeNS(NULL,SHIB_L(Email)));
 305     if (temp.get())
 306         m_emails.push_back(temp.get());
 307 }
 308
 309 XMLMetadataImpl::Provider::Provider(const DOMElement* e) : m_root(e), m_IDP(NULL), m_AA(NULL),
 310     m_id(e->getAttributeNS(NULL,SHIB_L(Name))), m_errorURL(e->getAttributeNS(NULL,SHIB_L(ErrorURL)))
 311 {
 312     // Record all the SiteGroups containing this site.
 313     DOMNode* group=e->getParentNode();
 314     while (group && group->getNodeType()==DOMNode::ELEMENT_NODE) {
 315         m_groups.push_back(static_cast<DOMElement*>(group)->getAttributeNS(NULL,SHIB_L(Name)));
 316         group=group->getParentNode();
 317     }
 318
 319     DOMElement* child=saml::XML::getFirstChildElement(e);
 320     while (child) {
 321         // Process the various kinds of OriginSite children that we care about...
 322         if (saml::XML::isElementNamed(child,::XML::SHIB_NS,SHIB_L(Contact))) {
 323             m_contacts.push_back(new ContactPerson(child));
 324         }
 325         else if (saml::XML::isElementNamed(child,::XML::SHIB_NS,SHIB_L(HandleService))) {
 326             // Create the IDP role if needed.
 327             if (!m_IDP) {
 328                 m_IDP=new IDPRole(this, child);
 329                 m_IDP->m_keys.push_back(new KeyDescriptor());
 330             }
 331             m_roles.push_back(m_IDP);
 332
 333             // Manufacture an endpoint for this role.
 334             m_IDP->m_epv.push_back(Endpoint(::XML::SHIB_NS,child->getAttributeNS(NULL,SHIB_L(Location))));
 335             m_IDP->m_pepv.push_back(&(m_IDP->m_epv.back()));
 336
 337             // We're going to "mock up" a KeyInfo that contains the specified Name as KeyName.
 338             DOMElement* kne=e->getOwnerDocument()->createElementNS(saml::XML::XMLSIG_NS,SHIB_L(KeyName));
 339             kne->appendChild(e->getOwnerDocument()->createTextNode(child->getAttributeNS(NULL,SHIB_L(Name))));
 340             KeyDescriptor* kd=const_cast<KeyDescriptor*>(static_cast<const KeyDescriptor*>(m_IDP->m_keys.back()));
 341             if (!kd->m_klist.addXMLKeyInfo(kne))
 342                 throw MetadataException("Provider::Provider() unable to mock up ds:KeyName");
 343         }
 344         else if (saml::XML::isElementNamed(child,::XML::SHIB_NS,SHIB_L(AttributeAuthority))) {
 345             // Create the AA role if needed.
 346             if (!m_AA) {
 347                 m_AA=new AARole(this, child);
 348                 m_AA->m_keys.push_back(new KeyDescriptor());
 349             }
 350             m_roles.push_back(m_AA);
 351
 352             // Manufacture an endpoint for this role.
 353             m_AA->m_epv.push_back(Endpoint(SAMLBinding::SAML_SOAP_HTTPS,child->getAttributeNS(NULL,SHIB_L(Location))));
 354             m_AA->m_pepv.push_back(&(m_AA->m_epv.back()));
 355
 356             // We're going to "mock up" a KeyInfo that contains the specified Name as KeyName.
 357             DOMElement* kne=e->getOwnerDocument()->createElementNS(saml::XML::XMLSIG_NS,SHIB_L(KeyName));
 358             kne->appendChild(e->getOwnerDocument()->createTextNode(child->getAttributeNS(NULL,SHIB_L(Name))));
 359             KeyDescriptor* kd=const_cast<KeyDescriptor*>(static_cast<const KeyDescriptor*>(m_AA->m_keys.back()));
 360             if (!kd->m_klist.addXMLKeyInfo(kne))
 361                 throw MetadataException("Provider::Provider() unable to mock up ds:KeyName");
 362         }
 363         else if (saml::XML::isElementNamed(child,::XML::SHIB_NS,SHIB_L(Domain))) {
 364             const XMLCh* dom=child->getFirstChild()->getNodeValue();
 365             if (dom && *dom) {
 366                 static const XMLCh one[]={ chDigit_1, chNull };
 367                 static const XMLCh tru[]={ chLatin_t, chLatin_r, chLatin_u, chLatin_e, chNull };
 368                 const XMLCh* regexp=child->getAttributeNS(NULL,SHIB_L(regexp));
 369                 bool flag=(!XMLString::compareString(regexp,one) || !XMLString::compareString(regexp,tru));
 370                 m_domains.push_back(pair<const XMLCh*,bool>(dom,flag));
 371             }
 372         }
 373         child = saml::XML::getNextSiblingElement(child);
 374     }
 375 }
 376
 377 XMLMetadataImpl::Provider::~Provider()
 378 {
 379     for (vector<const IContactPerson*>::iterator i=m_contacts.begin(); i!=m_contacts.end(); i++)
 380         delete const_cast<IContactPerson*>(*i);
 381     delete m_IDP;
 382     delete m_AA;
 383 }
 384
 385 void XMLMetadataImpl::init()
 386 {
 387     NDC ndc("XMLMetadataImpl");
 388     Category& log=Category::getInstance(XMLPROVIDERS_LOGCAT".XMLMetadataImpl");
 389
 390     try
 391     {
 392         if (!saml::XML::isElementNamed(m_root,::XML::SHIB_NS,SHIB_L(SiteGroup))) {
 393             log.error("Construction requires a valid site file: (shib:SiteGroup as root element)");
 394             throw MetadataException("Construction requires a valid site file: (shib:SiteGroup as root element)");
 395         }
 396
 397         // Loop over the OriginSite elements.
 398         DOMNodeList* nlist = m_root->getElementsByTagNameNS(::XML::SHIB_NS,SHIB_L(OriginSite));
 399         for (int i=0; nlist && i<nlist->getLength(); i++) {
 400             const XMLCh* os_name=static_cast<DOMElement*>(nlist->item(i))->getAttributeNS(NULL,SHIB_L(Name));
 401             if (!os_name || !*os_name)
 402                 continue;
 403
 404             Provider* p = new Provider(static_cast<DOMElement*>(nlist->item(i)));
 405 #ifdef HAVE_GOOD_STL
 406             m_sites[os_name]=p;
 407 #else
 408             auto_ptr_char os_name2(os_name);
 409             m_sites[os_name2.get()]=p;
 410 #endif
 411         }
 412     }
 413     catch (SAMLException& e)
 414     {
 415         log.errorStream() << "Error while parsing site configuration: " << e.what() << CategoryStream::ENDLINE;
 416         for (sitemap_t::iterator i=m_sites.begin(); i!=m_sites.end(); i++)
 417             delete i->second;
 418         throw;
 419     }
 420     catch (...)
 421     {
 422         log.error("Unexpected error while parsing site configuration");
 423         for (sitemap_t::iterator i=m_sites.begin(); i!=m_sites.end(); i++)
 424             delete i->second;
 425         throw;
 426     }
 427 }
 428
 429 XMLMetadataImpl::~XMLMetadataImpl()
 430 {
 431     for (sitemap_t::iterator i=m_sites.begin(); i!=m_sites.end(); i++)
 432         delete i->second;
 433 }
 434
 435 const IProvider* XMLMetadata::lookup(const XMLCh* providerId) const
 436 {
 437     XMLMetadataImpl* impl=dynamic_cast<XMLMetadataImpl*>(getImplementation());
 438 #ifdef HAVE_GOOD_STL
 439     XMLMetadataImpl::sitemap_t::const_iterator i=impl->m_sites.find(providerId);
 440 #else
 441     auto_ptr_char temp(providerId);
 442     XMLMetadataImpl::sitemap_t::const_iterator i=impl->m_sites.find(temp.get());
 443 #endif
 444     return (i==impl->m_sites.end()) ? NULL : i->second;
 445 }