shib/shib.h

   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
  51 /* shib.h - Shibboleth header file
  52
  53    Scott Cantor
  54    6/4/02
  55
  56    $History:$
  57 */
  58
  59 #ifndef __shib_h__
  60 #define __shib_h__
  61
  62 #include <saml/saml.h>
  63
  64 #ifdef WIN32
  65 # ifndef SHIB_EXPORTS
  66 #  define SHIB_EXPORTS __declspec(dllimport)
  67 # endif
  68 #else
  69 # define SHIB_EXPORTS
  70 #endif
  71
  72 namespace shibboleth
  73 {
  74 #ifdef NO_RTTI
  75   extern SHIB_EXPORTS const unsigned short RTTI_UnsupportedProtocolException;
  76   extern SHIB_EXPORTS const unsigned short RTTI_OriginSiteMapperException;
  77 #endif
  78
  79     #define DECLARE_SHIB_EXCEPTION(name,base) \
  80         class SHIB_EXPORTS name : public saml::base \
  81         { \
  82         public: \
  83             name(const char* msg) : saml::base(msg) {RTTI(name);} \
  84             name(const std::string& msg) : saml::base(msg) {RTTI(name);} \
  85             name(const saml::Iterator<saml::QName>& codes, const char* msg) : saml::base(codes,msg) {RTTI(name);} \
  86             name(const saml::Iterator<saml::QName>& codes, const std::string& msg) : saml::base(codes, msg) {RTTI(name);} \
  87             name(const saml::QName& code, const char* msg) : saml::base(code,msg) {RTTI(name);} \
  88             name(const saml::QName& code, const std::string& msg) : saml::base(code, msg) {RTTI(name);} \
  89             name(DOMElement* e) : saml::base(e) {RTTI(name);} \
  90             name(std::istream& in) : saml::base(in) {RTTI(name);} \
  91             virtual ~name() throw () {} \
  92         }
  93
  94     DECLARE_SHIB_EXCEPTION(UnsupportedProtocolException,SAMLException);
  95     DECLARE_SHIB_EXCEPTION(OriginSiteMapperException,SAMLException);
  96
  97 #ifdef SHIB_INSTANTIATE
  98 # ifdef NO_RTTI
  99     const unsigned short RTTI_UnsupportedProtocolException=     RTTI_EXTENSION_BASE;
 100     const unsigned short RTTI_OriginSiteMapperException=        RTTI_EXTENSION_BASE+1;
 101 # endif
 102     template class SHIB_EXPORTS saml::Iterator<std::pair<saml::xstring,bool> >;
 103     template class SHIB_EXPORTS saml::ArrayIterator<std::pair<saml::xstring,bool> >;
 104 #endif
 105
 106     struct SHIB_EXPORTS IOriginSiteMapper
 107     {
 108         virtual saml::Iterator<saml::xstring> getHandleServiceNames(const XMLCh* originSite)=0;
 109         virtual const saml::Key* getHandleServiceKey(const XMLCh* handleService)=0;
 110         virtual saml::Iterator<std::pair<saml::xstring,bool> > getSecurityDomains(const XMLCh* originSite)=0;
 111         virtual const char* getTrustedRoots()=0;
 112     };
 113
 114     class SHIB_EXPORTS XMLOriginSiteMapper : public IOriginSiteMapper
 115     {
 116     public:
 117         XMLOriginSiteMapper(const char* registryURI, const char* calist=NULL, const saml::X509Certificate* verifyKey=NULL);
 118         ~XMLOriginSiteMapper();
 119
 120         virtual saml::Iterator<saml::xstring> getHandleServiceNames(const XMLCh* originSite);
 121         virtual const saml::Key* getHandleServiceKey(const XMLCh* handleService);
 122         virtual saml::Iterator<std::pair<saml::xstring,bool> > getSecurityDomains(const XMLCh* originSite);
 123         virtual const char* getTrustedRoots();
 124
 125     private:
 126         void validateSignature(const saml::X509Certificate* verifyKey, DOMElement* e);
 127
 128         struct OriginSite
 129         {
 130             std::vector<saml::xstring> m_handleServices;
 131             std::vector<std::pair<saml::xstring,bool> > m_domains;
 132         };
 133
 134         std::string m_calist;
 135         std::map<saml::xstring,OriginSite*> m_sites;
 136         std::map<saml::xstring,saml::Key*> m_hsKeys;
 137     };
 138
 139     class SHIB_EXPORTS ShibPOSTProfile
 140     {
 141     public:
 142         ShibPOSTProfile(const saml::Iterator<const XMLCh*>& policies, const XMLCh* receiver, int ttlSeconds);
 143         ShibPOSTProfile(const saml::Iterator<const XMLCh*>& policies, const XMLCh* issuer);
 144         virtual ~ShibPOSTProfile();
 145
 146         virtual saml::SAMLAssertion* getSSOAssertion(const saml::SAMLResponse& r);
 147         virtual saml::SAMLAuthenticationStatement* getSSOStatement(const saml::SAMLAssertion& a);
 148         virtual saml::SAMLResponse* accept(const XMLByte* buf);
 149         virtual saml::SAMLResponse* prepare(const XMLCh* recipient,
 150                                             const XMLCh* name,
 151                                             const XMLCh* nameQualifier,
 152                                             const XMLCh* subjectIP,
 153                                             const XMLCh* authMethod,
 154                                             time_t authInstant,
 155                                             const saml::Iterator<saml::SAMLAuthorityBinding*>& bindings,
 156                                             const saml::Key& responseKey, const saml::X509Certificate* responseCert=NULL,
 157                                             const saml::Key* assertionKey=NULL, const saml::X509Certificate* assertionCert=NULL);
 158         virtual bool checkReplayCache(const saml::SAMLAssertion& a);
 159
 160     protected:
 161         virtual void verifySignature(const saml::SAMLSignedObject& obj, const XMLCh* signerName, const saml::Key* knownKey);
 162
 163         saml::SAMLSignedObject::sigs_t m_algorithm;
 164         std::vector<const XMLCh*> m_policies;
 165         XMLCh* m_issuer;
 166         XMLCh* m_receiver;
 167         int m_ttlSeconds;
 168
 169     private:
 170         ShibPOSTProfile(const ShibPOSTProfile&) {}
 171         ShibPOSTProfile& operator=(const ShibPOSTProfile&) {return *this;}
 172     };
 173
 174     class SHIB_EXPORTS ClubShibPOSTProfile : public ShibPOSTProfile
 175     {
 176     public:
 177         ClubShibPOSTProfile(const saml::Iterator<const XMLCh*>& policies, const XMLCh* receiver, int ttlSeconds);
 178         ClubShibPOSTProfile(const saml::Iterator<const XMLCh*>& policies, const XMLCh* issuer);
 179         virtual ~ClubShibPOSTProfile();
 180
 181         virtual saml::SAMLResponse* prepare(const XMLCh* recipient,
 182                                             const XMLCh* name,
 183                                             const XMLCh* nameQualifier,
 184                                             const XMLCh* subjectIP,
 185                                             const XMLCh* authMethod,
 186                                             time_t authInstant,
 187                                             const saml::Iterator<saml::SAMLAuthorityBinding*>& bindings,
 188                                             const saml::Key& responseKey, const saml::X509Certificate* responseCert=NULL,
 189                                             const saml::Key* assertionKey=NULL, const saml::X509Certificate* assertionCert=NULL);
 190
 191     protected:
 192         virtual void verifySignature(const saml::SAMLSignedObject& obj, const XMLCh* signerName, const saml::Key* knownKey);
 193     };
 194
 195     class SHIB_EXPORTS ShibPOSTProfileFactory
 196     {
 197     public:
 198         static ShibPOSTProfile* getInstance(const saml::Iterator<const XMLCh*>& policies, const XMLCh* receiver, int ttlSeconds);
 199         static ShibPOSTProfile* getInstance(const saml::Iterator<const XMLCh*>& policies, const XMLCh* issuer);
 200     };
 201
 202     class SHIB_EXPORTS ShibConfig
 203     {
 204     public:
 205         // global per-process setup and shutdown of Shibboleth runtime
 206         virtual bool init()=0;
 207         virtual void term()=0;
 208
 209         // enables runtime and clients to access configuration
 210         static ShibConfig& getConfig();
 211
 212     /* start of external configuration */
 213         IOriginSiteMapper* origin_mapper;
 214     /* end of external configuration */
 215     };
 216
 217     struct SHIB_EXPORTS Constants
 218     {
 219         static const XMLCh POLICY_CLUBSHIB[];
 220         static const XMLCh SHIB_ATTRIBUTE_NAMESPACE_URI[];
 221     };
 222
 223     class SHIB_EXPORTS XML
 224     {
 225     public:
 226         // URI constants
 227         static const XMLCh SHIB_NS[];
 228         static const XMLCh SHIB_SCHEMA_ID[];
 229
 230         struct SHIB_EXPORTS Literals
 231         {
 232             // Shibboleth vocabulary
 233             static const XMLCh Domain[];
 234             static const XMLCh HandleService[];
 235             static const XMLCh InvalidHandle[];
 236             static const XMLCh Name[];
 237             static const XMLCh OriginSite[];
 238             static const XMLCh regexp[];
 239             static const XMLCh Sites[];
 240
 241             // XML vocabulary
 242             static const XMLCh xmlns_shib[];
 243         };
 244     };
 245
 246
 247     class SHIB_EXPORTS SAMLBindingFactory
 248     {
 249     public:
 250         static saml::SAMLBinding* getInstance(const XMLCh* protocol=saml::SAMLBinding::SAML_SOAP_HTTPS);
 251     };
 252 }
 253
 254 #endif