saml/binding/impl/SecurityPolicy.cpp

   1 /*
   2  *  Copyright 2001-2009 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  * SecurityPolicy.cpp
  19  *
  20  * Overall policy used to verify the security of an incoming message.
  21  */
  22
  23 #include "internal.h"
  24 #include "exceptions.h"
  25 #include "binding/SecurityPolicyRule.h"
  26 #include "saml2/core/Assertions.h"
  27
  28 using namespace opensaml::saml2md;
  29 using namespace opensaml::saml2;
  30 using namespace opensaml;
  31 using namespace xmltooling;
  32 using namespace std;
  33
  34 namespace opensaml {
  35     SAML_DLLLOCAL PluginManager<SecurityPolicyRule,string,const DOMElement*>::Factory ClientCertAuthRuleFactory;
  36     SAML_DLLLOCAL PluginManager<SecurityPolicyRule,string,const DOMElement*>::Factory MessageFlowRuleFactory;
  37     SAML_DLLLOCAL PluginManager<SecurityPolicyRule,string,const DOMElement*>::Factory NullSecurityRuleFactory;
  38     SAML_DLLLOCAL PluginManager<SecurityPolicyRule,string,const DOMElement*>::Factory SimpleSigningRuleFactory;
  39     SAML_DLLLOCAL PluginManager<SecurityPolicyRule,string,const DOMElement*>::Factory XMLSigningRuleFactory;
  40 };
  41
  42 void SAML_API opensaml::registerSecurityPolicyRules()
  43 {
  44     SAMLConfig& conf=SAMLConfig::getConfig();
  45     conf.SecurityPolicyRuleManager.registerFactory(CLIENTCERTAUTH_POLICY_RULE, ClientCertAuthRuleFactory);
  46     conf.SecurityPolicyRuleManager.registerFactory(MESSAGEFLOW_POLICY_RULE, MessageFlowRuleFactory);
  47     conf.SecurityPolicyRuleManager.registerFactory(NULLSECURITY_POLICY_RULE, NullSecurityRuleFactory);
  48     conf.SecurityPolicyRuleManager.registerFactory(SIMPLESIGNING_POLICY_RULE, SimpleSigningRuleFactory);
  49     conf.SecurityPolicyRuleManager.registerFactory(XMLSIGNING_POLICY_RULE, XMLSigningRuleFactory);
  50 }
  51
  52 SecurityPolicy::IssuerMatchingPolicy SecurityPolicy::m_defaultMatching;
  53
  54 SecurityPolicy::~SecurityPolicy()
  55 {
  56     XMLString::release(&m_messageID);
  57     delete m_metadataCriteria;
  58     delete m_issuer;
  59 }
  60
  61 void SecurityPolicy::reset(bool messageOnly)
  62 {
  63     _reset();
  64 }
  65
  66 void SecurityPolicy::_reset(bool messageOnly)
  67 {
  68     XMLString::release(&m_messageID);
  69     m_messageID=NULL;
  70     m_issueInstant=0;
  71     if (!messageOnly) {
  72         delete m_issuer;
  73         m_issuer=NULL;
  74         m_issuerRole=NULL;
  75         m_authenticated=false;
  76     }
  77 }
  78
  79 MetadataProvider::Criteria& SecurityPolicy::getMetadataProviderCriteria() const
  80 {
  81     if (!m_metadataCriteria)
  82         m_metadataCriteria=new MetadataProvider::Criteria();
  83     else
  84         m_metadataCriteria->reset();
  85     return *m_metadataCriteria;
  86 }
  87
  88 void SecurityPolicy::setMetadataProviderCriteria(saml2md::MetadataProvider::Criteria* criteria)
  89 {
  90     if (m_metadataCriteria)
  91         delete m_metadataCriteria;
  92     m_metadataCriteria=criteria;
  93 }
  94
  95 void SecurityPolicy::evaluate(const XMLObject& message, const GenericRequest* request)
  96 {
  97     for (vector<const SecurityPolicyRule*>::const_iterator i=m_rules.begin(); i!=m_rules.end(); ++i)
  98         (*i)->evaluate(message,request,*this);
  99 }
 100
 101 void SecurityPolicy::setIssuer(const Issuer* issuer)
 102 {
 103     if (!getIssuerMatchingPolicy().issuerMatches(m_issuer, issuer))
 104         throw SecurityPolicyException("An Issuer was supplied that conflicts with previous results.");
 105
 106     if (!m_issuer) {
 107         if (m_entityOnly && issuer->getFormat() && !XMLString::equals(issuer->getFormat(), NameIDType::ENTITY))
 108             throw SecurityPolicyException("A non-entity Issuer was supplied, violating policy.");
 109         m_issuerRole = NULL;
 110         m_issuer=issuer->cloneIssuer();
 111     }
 112 }
 113
 114 void SecurityPolicy::setIssuer(const XMLCh* issuer)
 115 {
 116     if (!getIssuerMatchingPolicy().issuerMatches(m_issuer, issuer))
 117         throw SecurityPolicyException("An Issuer was supplied that conflicts with previous results.");
 118
 119     if (!m_issuer && issuer && *issuer) {
 120         m_issuerRole = NULL;
 121         m_issuer = IssuerBuilder::buildIssuer();
 122         m_issuer->setName(issuer);
 123     }
 124 }
 125
 126 void SecurityPolicy::setIssuerMetadata(const RoleDescriptor* issuerRole)
 127 {
 128     if (issuerRole && m_issuerRole && issuerRole!=m_issuerRole)
 129         throw SecurityPolicyException("A rule supplied a RoleDescriptor that conflicts with previous results.");
 130     m_issuerRole=issuerRole;
 131 }
 132
 133 bool SecurityPolicy::IssuerMatchingPolicy::issuerMatches(const Issuer* issuer1, const Issuer* issuer2) const
 134 {
 135     // NULL matches anything for the purposes of this interface.
 136     if (!issuer1 || !issuer2)
 137         return true;
 138
 139     const XMLCh* op1=issuer1->getName();
 140     const XMLCh* op2=issuer2->getName();
 141     if (!op1 || !op2 || !XMLString::equals(op1,op2))
 142         return false;
 143
 144     op1=issuer1->getFormat();
 145     op2=issuer2->getFormat();
 146     if (!XMLString::equals(op1 ? op1 : NameIDType::ENTITY, op2 ? op2 : NameIDType::ENTITY))
 147         return false;
 148
 149     op1=issuer1->getNameQualifier();
 150     op2=issuer2->getNameQualifier();
 151     if (!XMLString::equals(op1 ? op1 : &chNull, op2 ? op2 : &chNull))
 152         return false;
 153
 154     op1=issuer1->getSPNameQualifier();
 155     op2=issuer2->getSPNameQualifier();
 156     if (!XMLString::equals(op1 ? op1 : &chNull, op2 ? op2 : &chNull))
 157         return false;
 158
 159     return true;
 160 }
 161
 162 bool SecurityPolicy::IssuerMatchingPolicy::issuerMatches(const Issuer* issuer1, const XMLCh* issuer2) const
 163 {
 164     // NULL matches anything for the purposes of this interface.
 165     if (!issuer1 || !issuer2 || !*issuer2)
 166         return true;
 167
 168     const XMLCh* op1=issuer1->getName();
 169     if (!op1 || !XMLString::equals(op1,issuer2))
 170         return false;
 171
 172     op1=issuer1->getFormat();
 173     if (op1 && *op1 && !XMLString::equals(op1, NameIDType::ENTITY))
 174         return false;
 175
 176     op1=issuer1->getNameQualifier();
 177     if (op1 && *op1)
 178         return false;
 179
 180     op1=issuer1->getSPNameQualifier();
 181     if (op1 && *op1)
 182         return false;
 183
 184     return true;
 185 }