saml/saml2/metadata/impl/MetadataProvider.cpp

   1 /*
   2  *  Copyright 2001-2006 Internet2
   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 /**
  18  * MetadataProvider.cpp
  19  *
  20  * Registration of factories for built-in providers
  21  */
  22
  23 #include "internal.h"
  24 #include "SAMLArtifact.h"
  25 #include "saml2/metadata/MetadataProvider.h"
  26
  27 #include <log4cpp/Category.hh>
  28 #include <xmltooling/util/NDC.h>
  29
  30 using namespace opensaml::saml2md;
  31 using namespace opensaml;
  32 using namespace xmltooling;
  33 using namespace log4cpp;
  34 using namespace std;
  35
  36 namespace opensaml {
  37     namespace saml2md {
  38         SAML_DLLLOCAL PluginManager<MetadataProvider,const DOMElement*>::Factory FilesystemMetadataProviderFactory;
  39         SAML_DLLLOCAL PluginManager<MetadataFilter,const DOMElement*>::Factory BlacklistMetadataFilterFactory;
  40         SAML_DLLLOCAL PluginManager<MetadataFilter,const DOMElement*>::Factory WhitelistMetadataFilterFactory;
  41         SAML_DLLLOCAL PluginManager<MetadataFilter,const DOMElement*>::Factory SignatureMetadataFilterFactory;
  42     };
  43 };
  44
  45 void SAML_API opensaml::saml2md::registerMetadataProviders()
  46 {
  47     SAMLConfig& conf=SAMLConfig::getConfig();
  48     conf.MetadataProviderManager.registerFactory(FILESYSTEM_METADATA_PROVIDER, FilesystemMetadataProviderFactory);
  49     conf.MetadataProviderManager.registerFactory("edu.internet2.middleware.shibboleth.metadata.provider.XMLMetadata", FilesystemMetadataProviderFactory);
  50     conf.MetadataProviderManager.registerFactory("edu.internet2.middleware.shibboleth.common.provider.XMLMetadata", FilesystemMetadataProviderFactory);
  51 }
  52
  53 void SAML_API opensaml::saml2md::registerMetadataFilters()
  54 {
  55     SAMLConfig::getConfig().MetadataFilterManager.registerFactory(BLACKLIST_METADATA_FILTER, BlacklistMetadataFilterFactory);
  56     SAMLConfig::getConfig().MetadataFilterManager.registerFactory(WHITELIST_METADATA_FILTER, WhitelistMetadataFilterFactory);
  57     SAMLConfig::getConfig().MetadataFilterManager.registerFactory(SIGNATURE_METADATA_FILTER, SignatureMetadataFilterFactory);
  58 }
  59
  60 static const XMLCh Blacklist[] =                    UNICODE_LITERAL_23(B,l,a,c,k,l,i,s,t,M,e,t,a,d,a,t,a,F,i,l,t,e,r);
  61 static const XMLCh Whitelist[] =                    UNICODE_LITERAL_23(W,h,i,t,e,l,i,s,t,M,e,t,a,d,a,t,a,F,i,l,t,e,r);
  62 static const XMLCh SigFilter[] =                    UNICODE_LITERAL_23(S,i,g,n,a,t,u,r,e,M,e,t,a,d,a,t,a,F,i,l,t,e,r);
  63 static const XMLCh Exclude[] =                      UNICODE_LITERAL_7(E,x,c,l,u,d,e);
  64 static const XMLCh Include[] =                      UNICODE_LITERAL_7(I,n,c,l,u,d,e);
  65 static const XMLCh GenericKeyResolver[] =           UNICODE_LITERAL_11(K,e,y,R,e,s,o,l,v,e,r);
  66 static const XMLCh GenericMetadataFilter[] =        UNICODE_LITERAL_14(M,e,t,a,d,a,t,a,F,i,l,t,e,r);
  67 static const XMLCh type[] =                         UNICODE_LITERAL_4(t,y,p,e);
  68
  69 MetadataProvider::MetadataProvider(const DOMElement* e) : m_resolver(NULL)
  70 {
  71 #ifdef _DEBUG
  72     NDC ndc("MetadataProvider");
  73 #endif
  74     SAMLConfig& conf=SAMLConfig::getConfig();
  75
  76     // Locate any default recognized filters and plugins.
  77     try {
  78         DOMElement* child = e ? XMLHelper::getFirstChildElement(e) : NULL;
  79         while (child) {
  80             if (!m_resolver && XMLString::equals(child->getLocalName(),GenericKeyResolver)) {
  81                 auto_ptr_char t(child->getAttributeNS(NULL,type));
  82                 if (t.get())
  83                     m_resolver = XMLToolingConfig::getConfig().KeyResolverManager.newPlugin(t.get(),child);
  84                 else
  85                     throw UnknownExtensionException("<KeyResolver> element found with no type attribute");
  86             }
  87             else if (XMLString::equals(child->getLocalName(),GenericMetadataFilter)) {
  88                 auto_ptr_char t(child->getAttributeNS(NULL,type));
  89                 if (t.get())
  90                     m_filters.push_back(conf.MetadataFilterManager.newPlugin(t.get(),child));
  91                 else
  92                     throw UnknownExtensionException("<MetadataFilter> element found with no type attribute");
  93             }
  94             else if (XMLString::equals(child->getLocalName(),SigFilter)) {
  95                 m_filters.push_back(conf.MetadataFilterManager.newPlugin(SIGNATURE_METADATA_FILTER,child));
  96             }
  97             else if (XMLString::equals(child->getLocalName(),Whitelist)) {
  98                 m_filters.push_back(conf.MetadataFilterManager.newPlugin(WHITELIST_METADATA_FILTER,child));
  99             }
 100             else if (XMLString::equals(child->getLocalName(),Blacklist)) {
 101                 m_filters.push_back(conf.MetadataFilterManager.newPlugin(BLACKLIST_METADATA_FILTER,child));
 102             }
 103             else if (XMLString::equals(child->getLocalName(),Include)) {
 104                 m_filters.push_back(conf.MetadataFilterManager.newPlugin(WHITELIST_METADATA_FILTER,e));
 105             }
 106             else if (XMLString::equals(child->getLocalName(),Exclude)) {
 107                 m_filters.push_back(conf.MetadataFilterManager.newPlugin(BLACKLIST_METADATA_FILTER,e));
 108             }
 109             child = XMLHelper::getNextSiblingElement(child);
 110         }
 111
 112         if (!m_resolver) {
 113             m_resolver = XMLToolingConfig::getConfig().KeyResolverManager.newPlugin(INLINE_KEY_RESOLVER, child);
 114         }
 115     }
 116     catch (XMLToolingException& ex) {
 117         Category::getInstance(SAML_LOGCAT".Metadata").error("caught exception while installing plugins and filters: %s", ex.what());
 118         delete m_resolver;
 119         for_each(m_filters.begin(),m_filters.end(),xmltooling::cleanup<MetadataFilter>());
 120         throw;
 121     }
 122 }
 123
 124 MetadataProvider::~MetadataProvider()
 125 {
 126     delete m_resolver;
 127     for_each(m_filters.begin(),m_filters.end(),xmltooling::cleanup<MetadataFilter>());
 128 }
 129
 130 void MetadataProvider::doFilters(XMLObject& xmlObject) const
 131 {
 132 #ifdef _DEBUG
 133     NDC ndc("doFilters");
 134 #endif
 135     Category& log=Category::getInstance(SAML_LOGCAT".Metadata");
 136     for (std::vector<MetadataFilter*>::const_iterator i=m_filters.begin(); i!=m_filters.end(); i++) {
 137         log.info("applying metadata filter (%s)", (*i)->getId());
 138         (*i)->doFilter(xmlObject);
 139     }
 140 }
 141
 142 void MetadataProvider::index(EntityDescriptor* site, time_t validUntil)
 143 {
 144     if (validUntil < site->getValidUntilEpoch())
 145         site->setValidUntil(validUntil);
 146
 147     auto_ptr_char id(site->getEntityID());
 148     if (id.get()) {
 149         m_sites.insert(make_pair(id.get(),site));
 150     }
 151
 152     // Process each IdP role.
 153     const vector<IDPSSODescriptor*>& roles=const_cast<const EntityDescriptor*>(site)->getIDPSSODescriptors();
 154     for (vector<IDPSSODescriptor*>::const_iterator i=roles.begin(); i!=roles.end(); i++) {
 155         // SAML 1.x?
 156         if ((*i)->hasSupport(SAMLConstants::SAML10_PROTOCOL_ENUM) || (*i)->hasSupport(SAMLConstants::SAML11_PROTOCOL_ENUM)) {
 157             // Check for SourceID extension element.
 158             const Extensions* exts=(*i)->getExtensions();
 159             if (exts) {
 160                 const list<XMLObject*>& children=exts->getXMLObjects();
 161                 for (list<XMLObject*>::const_iterator ext=children.begin(); ext!=children.end(); ext++) {
 162                     SourceID* sid=dynamic_cast<SourceID*>(*ext);
 163                     if (sid) {
 164                         auto_ptr_char sourceid(sid->getID());
 165                         if (sourceid.get()) {
 166                             m_sources.insert(pair<string,const EntityDescriptor*>(sourceid.get(),site));
 167                             break;
 168                         }
 169                     }
 170                 }
 171             }
 172
 173             // Hash the ID.
 174             m_sources.insert(
 175                 pair<string,const EntityDescriptor*>(SAMLConfig::getConfig().hashSHA1(id.get(), true),site)
 176                 );
 177
 178             // Load endpoints for type 0x0002 artifacts.
 179             const vector<ArtifactResolutionService*>& locs=const_cast<const IDPSSODescriptor*>(*i)->getArtifactResolutionServices();
 180             for (vector<ArtifactResolutionService*>::const_iterator loc=locs.begin(); loc!=locs.end(); loc++) {
 181                 auto_ptr_char location((*loc)->getLocation());
 182                 if (location.get())
 183                     m_sources.insert(pair<string,const EntityDescriptor*>(location.get(),site));
 184             }
 185         }
 186
 187         // SAML 2.0?
 188         if ((*i)->hasSupport(SAMLConstants::SAML20P_NS)) {
 189             // Hash the ID.
 190             m_sources.insert(
 191                 pair<string,const EntityDescriptor*>(SAMLConfig::getConfig().hashSHA1(id.get(), true),site)
 192                 );
 193         }
 194     }
 195 }
 196
 197 void MetadataProvider::index(EntitiesDescriptor* group, time_t validUntil)
 198 {
 199     if (validUntil < group->getValidUntilEpoch())
 200         group->setValidUntil(validUntil);
 201
 202     auto_ptr_char name(group->getName());
 203     if (name.get()) {
 204         m_groups.insert(make_pair(name.get(),group));
 205     }
 206
 207     const vector<EntitiesDescriptor*>& groups=const_cast<const EntitiesDescriptor*>(group)->getEntitiesDescriptors();
 208     for (vector<EntitiesDescriptor*>::const_iterator i=groups.begin(); i!=groups.end(); i++)
 209         index(*i,group->getValidUntilEpoch());
 210
 211     const vector<EntityDescriptor*>& sites=const_cast<const EntitiesDescriptor*>(group)->getEntityDescriptors();
 212     for (vector<EntityDescriptor*>::const_iterator j=sites.begin(); j!=sites.end(); j++)
 213         index(*j,group->getValidUntilEpoch());
 214 }
 215
 216 void MetadataProvider::clearDescriptorIndex()
 217 {
 218     m_sources.clear();
 219     m_sites.clear();
 220     m_groups.clear();
 221 }
 222
 223 const EntitiesDescriptor* MetadataProvider::getEntitiesDescriptor(const char* name, bool strict) const
 224 {
 225     pair<groupmap_t::const_iterator,groupmap_t::const_iterator> range=m_groups.equal_range(name);
 226
 227     time_t now=time(NULL);
 228     for (groupmap_t::const_iterator i=range.first; i!=range.second; i++)
 229         if (now < i->second->getValidUntilEpoch())
 230             return i->second;
 231
 232     if (!strict && range.first!=range.second)
 233         return range.first->second;
 234
 235     return NULL;
 236 }
 237
 238 const EntitiesDescriptor* MetadataProvider::getEntitiesDescriptor(const XMLCh* name, bool strict) const
 239 {
 240     auto_ptr_char temp(name);
 241     return getEntitiesDescriptor(temp.get(),strict);
 242 }
 243
 244 const EntityDescriptor* MetadataProvider::getEntityDescriptor(const char* name, bool strict) const
 245 {
 246     pair<sitemap_t::const_iterator,sitemap_t::const_iterator> range=m_sites.equal_range(name);
 247
 248     time_t now=time(NULL);
 249     for (sitemap_t::const_iterator i=range.first; i!=range.second; i++)
 250         if (now < i->second->getValidUntilEpoch())
 251             return i->second;
 252
 253     if (!strict && range.first!=range.second)
 254         return range.first->second;
 255
 256     return NULL;
 257 }
 258
 259 const EntityDescriptor* MetadataProvider::getEntityDescriptor(const XMLCh* name, bool strict) const
 260 {
 261     auto_ptr_char temp(name);
 262     return getEntityDescriptor(temp.get(),strict);
 263 }
 264
 265 const EntityDescriptor* MetadataProvider::getEntityDescriptor(const SAMLArtifact* artifact) const
 266 {
 267     pair<sitemap_t::const_iterator,sitemap_t::const_iterator> range=m_sources.equal_range(artifact->getSource());
 268
 269     time_t now=time(NULL);
 270     for (sitemap_t::const_iterator i=range.first; i!=range.second; i++)
 271         if (now < i->second->getValidUntilEpoch())
 272             return i->second;
 273
 274     return NULL;
 275 }