saml/saml2/core/Assertions.h

   1 /**
   2  * Licensed to the University Corporation for Advanced Internet
   3  * Development, Inc. (UCAID) under one or more contributor license
   4  * agreements. See the NOTICE file distributed with this work for
   5  * additional information regarding copyright ownership.
   6  *
   7  * UCAID licenses this file to you under the Apache License,
   8  * Version 2.0 (the "License"); you may not use this file except
   9  * in compliance with the License. You may obtain a copy of the
  10  * License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  17  * either express or implied. See the License for the specific
  18  * language governing permissions and limitations under the License.
  19  */
  20
  21 /**
  22  * @file saml/saml2/core/Assertions.h
  23  *
  24  * XMLObjects representing the SAML 2.0 Assertions schema.
  25  */
  26
  27 #ifndef __saml2_assertions_h__
  28 #define __saml2_assertions_h__
  29
  30 #include <saml/Assertion.h>
  31 #include <saml/util/SAMLConstants.h>
  32
  33 #include <xmltooling/ConcreteXMLObjectBuilder.h>
  34 #include <xmltooling/ElementProxy.h>
  35
  36 #define DECL_SAML2OBJECTBUILDER(cname) \
  37     DECL_XMLOBJECTBUILDER(SAML_API,cname,samlconstants::SAML20_NS,samlconstants::SAML20_PREFIX)
  38
  39 namespace xmltooling {
  40     class XMLTOOL_API CredentialCriteria;
  41     class XMLTOOL_API CredentialResolver;
  42     class XMLTOOL_API DateTime;
  43 };
  44
  45 namespace xmlencryption {
  46     class XMLTOOL_API EncryptedData;
  47     class XMLTOOL_API EncryptedKey;
  48 };
  49
  50 namespace xmlsignature {
  51     class XMLTOOL_API KeyInfo;
  52     class XMLTOOL_API Signature;
  53 };
  54
  55 namespace opensaml {
  56
  57     namespace saml2md {
  58         class SAML_API MetadataProvider;
  59         class SAML_API MetadataCredentialCriteria;
  60     };
  61
  62     /**
  63      * @namespace opensaml::saml2
  64      * SAML 2.0 assertion namespace
  65      */
  66     namespace saml2 {
  67
  68         // Forward references
  69         class SAML_API Assertion;
  70         class SAML_API EncryptedAssertion;
  71
  72         /**
  73          * Marker interface for SAML types that can be encrypted.
  74          */
  75         class SAML_API EncryptableObject : public virtual xmltooling::XMLObject
  76         {
  77         protected:
  78             EncryptableObject() {}
  79             virtual ~EncryptableObject() {}
  80         };
  81
  82         DECL_XMLOBJECT_SIMPLE(SAML_API,AssertionIDRef,AssertionID,SAML 2.0 AssertionIDRef element);
  83         DECL_XMLOBJECT_SIMPLE(SAML_API,AssertionURIRef,AssertionURI,SAML 2.0 AssertionURIRef element);
  84         DECL_XMLOBJECT_SIMPLE(SAML_API,Audience,AudienceURI,SAML 2.0 Audience element);
  85         DECL_XMLOBJECT_SIMPLE(SAML_API,AuthnContextClassRef,Reference,SAML 2.0 AuthnContextClassRef element);
  86         DECL_XMLOBJECT_SIMPLE(SAML_API,AuthnContextDeclRef,Reference,SAML 2.0 AuthnContextDeclRef element);
  87         DECL_XMLOBJECT_SIMPLE(SAML_API,AuthenticatingAuthority,ID,SAML 2.0 AuthenticatingAuthority element);
  88
  89         BEGIN_XMLOBJECT(SAML_API,EncryptedElementType,xmltooling::XMLObject,SAML 2.0 EncryptedElementType type);
  90             DECL_TYPED_FOREIGN_CHILD(EncryptedData,xmlencryption);
  91             DECL_TYPED_FOREIGN_CHILDREN(EncryptedKey,xmlencryption);
  92             /** EncryptedElementType local name */
  93             static const XMLCh TYPE_NAME[];
  94
  95             /**
  96              * Encrypts an object to a single recipient using this object as a container.
  97              *
  98              * @param xmlObject         object to encrypt
  99              * @param metadataProvider  a locked MetadataProvider to supply encryption keys
 100              * @param criteria          metadata-based CredentialCriteria to use
 101              * @param compact           true iff compact KeyInfo should be used
 102              * @param algorithm         optionally specifies data encryption algorithm if none can be determined from metadata
 103              * @return  the encrypted object
 104              */
 105             virtual void encrypt(
 106                 const EncryptableObject& xmlObject,
 107                 const saml2md::MetadataProvider& metadataProvider,
 108                 saml2md::MetadataCredentialCriteria& criteria,
 109                 bool compact=false,
 110                 const XMLCh* algorithm=nullptr
 111                 );
 112
 113             /**
 114              * Encrypts an object to multiple recipients using this object as a container.
 115              *
 116              * @param xmlObject     object to encrypt
 117              * @param recipients    pairs containing a locked MetadataProvider to supply encryption keys,
 118              *                      and a metadata-based CredentialCriteria to use
 119              * @param compact       true iff compact KeyInfo should be used
 120              * @param algorithm     optionally specifies data encryption algorithm if none can be determined from metadata
 121              * @return  the encrypted object
 122              */
 123             virtual void encrypt(
 124                 const EncryptableObject& xmlObject,
 125                 const std::vector< std::pair<const saml2md::MetadataProvider*, saml2md::MetadataCredentialCriteria*> >& recipients,
 126                 bool compact=false,
 127                 const XMLCh* algorithm=nullptr
 128                 );
 129
 130             /**
 131              * Decrypts the element using the supplied CredentialResolver.
 132              *
 133              * <p>The object returned will be unmarshalled around the decrypted DOM element in a
 134              * new Document owned by the object.
 135              *
 136              * @param credResolver  locked resolver supplying decryption keys
 137              * @param recipient     identifier naming the recipient (the entity performing the decryption)
 138              * @param criteria      optional external criteria to use with resolver
 139              * @return  the decrypted and unmarshalled object
 140              */
 141             virtual xmltooling::XMLObject* decrypt(
 142                 const xmltooling::CredentialResolver& credResolver, const XMLCh* recipient, xmltooling::CredentialCriteria* criteria=nullptr
 143                 ) const;
 144         END_XMLOBJECT;
 145
 146         BEGIN_XMLOBJECT(SAML_API,EncryptedID,EncryptedElementType,SAML 2.0 EncryptedID element);
 147         END_XMLOBJECT;
 148
 149         BEGIN_XMLOBJECT(SAML_API,BaseID,EncryptableObject,SAML 2.0 BaseID abstract element);
 150             DECL_STRING_ATTRIB(NameQualifier,NAMEQUALIFIER);
 151             DECL_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER);
 152         END_XMLOBJECT;
 153
 154         BEGIN_XMLOBJECT(SAML_API,NameIDType,xmltooling::XMLObject,SAML 2.0 NameIDType type);
 155             DECL_STRING_ATTRIB(NameQualifier,NAMEQUALIFIER);
 156             DECL_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER);
 157             DECL_STRING_ATTRIB(Format,FORMAT);
 158             DECL_STRING_ATTRIB(SPProvidedID,SPPROVIDEDID);
 159             DECL_SIMPLE_CONTENT(Name);
 160             /** NameIDType local name */
 161             static const XMLCh TYPE_NAME[];
 162             /** Unspecified name format ID */
 163             static const XMLCh UNSPECIFIED[];
 164             /** Email address name format ID */
 165             static const XMLCh EMAIL[];
 166             /** X.509 subject name format ID */
 167             static const XMLCh X509_SUBJECT[];
 168             /** Windows domain qualified name format ID */
 169             static const XMLCh WIN_DOMAIN_QUALIFIED[];
 170             /** Kerberos principal name format ID */
 171             static const XMLCh KERBEROS[];
 172             /** Entity identifier name format ID */
 173             static const XMLCh ENTITY[];
 174             /** Persistent identifier name format ID */
 175             static const XMLCh PERSISTENT[];
 176             /** Transient identifier name format ID */
 177             static const XMLCh TRANSIENT[];
 178         END_XMLOBJECT;
 179
 180         BEGIN_XMLOBJECT2(SAML_API,NameID,NameIDType,EncryptableObject,SAML 2.0 NameID element);
 181         END_XMLOBJECT;
 182
 183         BEGIN_XMLOBJECT(SAML_API,Issuer,NameIDType,SAML 2.0 Issuer element);
 184         END_XMLOBJECT;
 185
 186         BEGIN_XMLOBJECT(SAML_API,Condition,xmltooling::XMLObject,SAML 2.0 Condition element);
 187         END_XMLOBJECT;
 188
 189         BEGIN_XMLOBJECT(SAML_API,AudienceRestriction,Condition,SAML 2.0 AudienceRestriction element);
 190             DECL_TYPED_CHILDREN(Audience);
 191             /** AudienceRestrictionType local name */
 192             static const XMLCh TYPE_NAME[];
 193         END_XMLOBJECT;
 194
 195         BEGIN_XMLOBJECT(SAML_API,OneTimeUse,Condition,SAML 2.0 OneTimeUse element);
 196             /** OneTimeUseType local name */
 197             static const XMLCh TYPE_NAME[];
 198         END_XMLOBJECT;
 199
 200         BEGIN_XMLOBJECT(SAML_API,ProxyRestriction,Condition,SAML 2.0 ProxyRestriction element);
 201             DECL_INTEGER_ATTRIB(Count,COUNT);
 202             DECL_TYPED_CHILDREN(Audience);
 203             /** ProxyRestrictionType local name */
 204             static const XMLCh TYPE_NAME[];
 205         END_XMLOBJECT;
 206
 207         BEGIN_XMLOBJECT(SAML_API,Delegate,xmltooling::XMLObject,SAML 2.0 Delegation Restriction Condition Delegate element);
 208             DECL_STRING_ATTRIB(ConfirmationMethod,CONFIRMATIONMETHOD);
 209             DECL_DATETIME_ATTRIB(DelegationInstant,DELEGATIONINSTANT);
 210             DECL_TYPED_CHILD(BaseID);
 211             DECL_TYPED_CHILD(NameID);
 212             DECL_TYPED_CHILD(EncryptedID);
 213             /** DelegateType local name */
 214             static const XMLCh TYPE_NAME[];
 215         END_XMLOBJECT;
 216
 217         BEGIN_XMLOBJECT(SAML_API,DelegationRestrictionType,Condition,SAML 2.0 Delegation Restriction Condition type);
 218             DECL_TYPED_CHILDREN(Delegate);
 219             /** DelegationRestrictionType local name */
 220             static const XMLCh TYPE_NAME[];
 221         END_XMLOBJECT;
 222
 223         BEGIN_XMLOBJECT(SAML_API,Conditions,xmltooling::XMLObject,SAML 2.0 Conditions element);
 224             DECL_DATETIME_ATTRIB(NotBefore,NOTBEFORE);
 225             DECL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER);
 226             DECL_TYPED_CHILDREN(AudienceRestriction);
 227             DECL_TYPED_CHILDREN(OneTimeUse);
 228             DECL_TYPED_CHILDREN(ProxyRestriction);
 229             DECL_TYPED_CHILDREN(Condition);
 230             /** ConditionsType local name */
 231             static const XMLCh TYPE_NAME[];
 232         END_XMLOBJECT;
 233
 234         BEGIN_XMLOBJECT(SAML_API,SubjectConfirmationDataType,xmltooling::XMLObject,SAML 2.0 SubjectConfirmationDataType base type);
 235             DECL_DATETIME_ATTRIB(NotBefore,NOTBEFORE);
 236             DECL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER);
 237             DECL_STRING_ATTRIB(Recipient,RECIPIENT);
 238             DECL_STRING_ATTRIB(InResponseTo,INRESPONSETO);
 239             DECL_STRING_ATTRIB(Address,ADDRESS);
 240         END_XMLOBJECT;
 241
 242         BEGIN_XMLOBJECT2(SAML_API,SubjectConfirmationData,SubjectConfirmationDataType,xmltooling::ElementProxy,SAML 2.0 SubjectConfirmationData element);
 243             DECL_SIMPLE_CONTENT(Data);
 244         END_XMLOBJECT;
 245
 246         BEGIN_XMLOBJECT2(SAML_API,KeyInfoConfirmationDataType,SubjectConfirmationDataType,xmltooling::AttributeExtensibleXMLObject,SAML 2.0 KeyInfoConfirmationDataType type);
 247             DECL_TYPED_FOREIGN_CHILDREN(KeyInfo,xmlsignature);
 248             /** KeyInfoConfirmationDataType local name */
 249             static const XMLCh TYPE_NAME[];
 250         END_XMLOBJECT;
 251
 252         BEGIN_XMLOBJECT(SAML_API,SubjectConfirmation,xmltooling::XMLObject,SAML 2.0 SubjectConfirmation element);
 253             DECL_STRING_ATTRIB(Method,METHOD);
 254             DECL_TYPED_CHILD(BaseID);
 255             DECL_TYPED_CHILD(NameID);
 256             DECL_TYPED_CHILD(EncryptedID);
 257             DECL_XMLOBJECT_CHILD(SubjectConfirmationData);
 258             /** SubjectConfirmationType local name */
 259             static const XMLCh TYPE_NAME[];
 260             /** Bearer confirmation method */
 261             static const XMLCh BEARER[];
 262             /** Holder of key confirmation method */
 263             static const XMLCh HOLDER_KEY[];
 264             /** Sender vouches confirmation method */
 265             static const XMLCh SENDER_VOUCHES[];
 266         END_XMLOBJECT;
 267
 268         BEGIN_XMLOBJECT(SAML_API,Subject,xmltooling::XMLObject,SAML 2.0 Subject element);
 269             DECL_TYPED_CHILD(BaseID);
 270             DECL_TYPED_CHILD(NameID);
 271             DECL_TYPED_CHILD(EncryptedID);
 272             DECL_TYPED_CHILDREN(SubjectConfirmation);
 273             /** SubjectType local name */
 274             static const XMLCh TYPE_NAME[];
 275         END_XMLOBJECT;
 276
 277         BEGIN_XMLOBJECT(SAML_API,Statement,xmltooling::XMLObject,SAML 2.0 Statement element);
 278         END_XMLOBJECT;
 279
 280         BEGIN_XMLOBJECT(SAML_API,SubjectLocality,xmltooling::XMLObject,SAML 2.0 SubjectLocality element);
 281             DECL_STRING_ATTRIB(Address,ADDRESS);
 282             DECL_STRING_ATTRIB(DNSName,DNSNAME);
 283             /** SubjectLocalityType local name */
 284             static const XMLCh TYPE_NAME[];
 285         END_XMLOBJECT;
 286
 287         BEGIN_XMLOBJECT(SAML_API,AuthnContextDecl,xmltooling::ElementProxy,SAML 2.0 AuthnContextDecl element);
 288         END_XMLOBJECT;
 289
 290         BEGIN_XMLOBJECT(SAML_API,AuthnContext,xmltooling::XMLObject,SAML 2.0 AuthnContext element);
 291             DECL_TYPED_CHILD(AuthnContextClassRef);
 292             DECL_XMLOBJECT_CHILD(AuthnContextDecl);
 293             DECL_TYPED_CHILD(AuthnContextDeclRef);
 294             DECL_TYPED_CHILDREN(AuthenticatingAuthority);
 295             /** AuthnContextType local name */
 296             static const XMLCh TYPE_NAME[];
 297         END_XMLOBJECT;
 298
 299         BEGIN_XMLOBJECT(SAML_API,AuthnStatement,Statement,SAML 2.0 AuthnStatement element);
 300             DECL_DATETIME_ATTRIB(AuthnInstant,AUTHNINSTANT);
 301             DECL_STRING_ATTRIB(SessionIndex,SESSIONINDEX);
 302             DECL_DATETIME_ATTRIB(SessionNotOnOrAfter,SESSIONNOTONORAFTER);
 303             DECL_TYPED_CHILD(SubjectLocality);
 304             DECL_TYPED_CHILD(AuthnContext);
 305             /** AuthnStatementType local name */
 306             static const XMLCh TYPE_NAME[];
 307         END_XMLOBJECT;
 308
 309         BEGIN_XMLOBJECT(SAML_API,Action,xmltooling::XMLObject,SAML 2.0 Action element);
 310             DECL_STRING_ATTRIB(Namespace,NAMESPACE);
 311             DECL_SIMPLE_CONTENT(Action);
 312             /** ActionType local name */
 313             static const XMLCh TYPE_NAME[];
 314             /** Read/Write/Execute/Delete/Control Action Namespace */
 315             static const XMLCh RWEDC_NEG_ACTION_NAMESPACE[];
 316             /** Read/Write/Execute/Delete/Control with Negation Action Namespace */
 317             static const XMLCh RWEDC_ACTION_NAMESPACE[];
 318             /** Get/Head/Put/Post Action Namespace */
 319             static const XMLCh GHPP_ACTION_NAMESPACE[];
 320             /** UNIX File Permissions Action Namespace */
 321             static const XMLCh UNIX_ACTION_NAMESPACE[];
 322         END_XMLOBJECT;
 323
 324         BEGIN_XMLOBJECT(SAML_API,Evidence,xmltooling::XMLObject,SAML 2.0 Evidence element);
 325             DECL_TYPED_CHILDREN(AssertionIDRef);
 326             DECL_TYPED_CHILDREN(AssertionURIRef);
 327             DECL_TYPED_CHILDREN(Assertion);
 328             DECL_TYPED_CHILDREN(EncryptedAssertion);
 329             /** EvidenceType local name */
 330             static const XMLCh TYPE_NAME[];
 331         END_XMLOBJECT;
 332
 333         BEGIN_XMLOBJECT(SAML_API,AuthzDecisionStatement,Statement,SAML 2.0 AuthzDecisionStatement element);
 334             DECL_STRING_ATTRIB(Resource,RESOURCE);
 335             DECL_STRING_ATTRIB(Decision,DECISION);
 336             DECL_TYPED_CHILDREN(Action);
 337             DECL_TYPED_CHILD(Evidence);
 338             /** AuthzDecisionStatementType local name */
 339             static const XMLCh TYPE_NAME[];
 340             /** Permit Decision */
 341             static const XMLCh DECISION_PERMIT[];
 342             /** Deny Decision */
 343             static const XMLCh DECISION_DENY[];
 344             /** Indeterminate Decision */
 345             static const XMLCh DECISION_INDETERMINATE[];
 346         END_XMLOBJECT;
 347
 348         BEGIN_XMLOBJECT(SAML_API,AttributeValue,xmltooling::ElementProxy,SAML 2.0 AttributeValue element);
 349         END_XMLOBJECT;
 350
 351         BEGIN_XMLOBJECT2(SAML_API,Attribute,xmltooling::AttributeExtensibleXMLObject,EncryptableObject,SAML 2.0 Attribute element);
 352             DECL_STRING_ATTRIB(Name,NAME);
 353             DECL_STRING_ATTRIB(NameFormat,NAMEFORMAT);
 354             DECL_STRING_ATTRIB(FriendlyName,FRIENDLYNAME);
 355             DECL_XMLOBJECT_CHILDREN(AttributeValue);
 356             /** AttributeType local name */
 357             static const XMLCh TYPE_NAME[];
 358             /** Unspecified attribute name format ID */
 359             static const XMLCh UNSPECIFIED[];
 360             /** URI reference attribute name format ID */
 361             static const XMLCh URI_REFERENCE[];
 362             /** Basic attribute name format ID */
 363             static const XMLCh BASIC[];
 364         END_XMLOBJECT;
 365
 366         BEGIN_XMLOBJECT(SAML_API,EncryptedAttribute,EncryptedElementType,SAML 2.0 EncryptedAttribute element);
 367         END_XMLOBJECT;
 368
 369         BEGIN_XMLOBJECT(SAML_API,AttributeStatement,Statement,SAML 2.0 AttributeStatement element);
 370             DECL_TYPED_CHILDREN(Attribute);
 371             DECL_TYPED_CHILDREN(EncryptedAttribute);
 372             /** AttributeStatementType local name */
 373             static const XMLCh TYPE_NAME[];
 374         END_XMLOBJECT;
 375
 376         BEGIN_XMLOBJECT(SAML_API,EncryptedAssertion,EncryptedElementType,SAML 2.0 EncryptedAssertion element);
 377         END_XMLOBJECT;
 378
 379         BEGIN_XMLOBJECT(SAML_API,Advice,xmltooling::ElementExtensibleXMLObject,SAML 2.0 Advice element);
 380             DECL_TYPED_CHILDREN(AssertionIDRef);
 381             DECL_TYPED_CHILDREN(AssertionURIRef);
 382             DECL_TYPED_CHILDREN(Assertion);
 383             DECL_TYPED_CHILDREN(EncryptedAssertion);
 384             /** AdviceType local name */
 385             static const XMLCh TYPE_NAME[];
 386         END_XMLOBJECT;
 387
 388         /**
 389          * SAML 2.0 assertion or protocol message.
 390          */
 391         class SAML_API RootObject : virtual public opensaml::RootObject
 392         {
 393         protected:
 394             RootObject() {}
 395         public:
 396             virtual ~RootObject() {}
 397
 398             /** Gets the Version attribute. */
 399             virtual const XMLCh* getVersion() const=0;
 400
 401             /** Gets the Issuer. */
 402             virtual Issuer* getIssuer() const=0;
 403         };
 404
 405         BEGIN_XMLOBJECT3(SAML_API,Assertion,saml2::RootObject,opensaml::Assertion,EncryptableObject,SAML 2.0 Assertion element);
 406             DECL_INHERITED_STRING_ATTRIB(Version,VER);
 407             DECL_INHERITED_STRING_ATTRIB(ID,ID);
 408             DECL_INHERITED_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT);
 409             DECL_INHERITED_TYPED_CHILD(Issuer);
 410             DECL_TYPED_CHILD(Subject);
 411             DECL_TYPED_CHILD(Conditions);
 412             DECL_TYPED_CHILD(Advice);
 413             DECL_TYPED_CHILDREN(Statement);
 414             DECL_TYPED_CHILDREN(AuthnStatement);
 415             DECL_TYPED_CHILDREN(AttributeStatement);
 416             DECL_TYPED_CHILDREN(AuthzDecisionStatement);
 417             /** AssertionType local name */
 418             static const XMLCh TYPE_NAME[];
 419         END_XMLOBJECT;
 420
 421         DECL_SAML2OBJECTBUILDER(Action);
 422         DECL_SAML2OBJECTBUILDER(Advice);
 423         DECL_SAML2OBJECTBUILDER(Assertion);
 424         DECL_SAML2OBJECTBUILDER(AssertionIDRef);
 425         DECL_SAML2OBJECTBUILDER(AssertionURIRef);
 426         DECL_SAML2OBJECTBUILDER(Attribute);
 427         DECL_SAML2OBJECTBUILDER(AttributeStatement);
 428         DECL_SAML2OBJECTBUILDER(AttributeValue);
 429         DECL_SAML2OBJECTBUILDER(Audience);
 430         DECL_SAML2OBJECTBUILDER(AudienceRestriction);
 431         DECL_SAML2OBJECTBUILDER(AuthenticatingAuthority);
 432         DECL_SAML2OBJECTBUILDER(AuthnContext);
 433         DECL_SAML2OBJECTBUILDER(AuthnContextClassRef);
 434         DECL_SAML2OBJECTBUILDER(AuthnContextDecl);
 435         DECL_SAML2OBJECTBUILDER(AuthnContextDeclRef);
 436         DECL_SAML2OBJECTBUILDER(AuthnStatement);
 437         DECL_SAML2OBJECTBUILDER(AuthzDecisionStatement);
 438         DECL_SAML2OBJECTBUILDER(Conditions);
 439         DECL_SAML2OBJECTBUILDER(EncryptedAssertion);
 440         DECL_SAML2OBJECTBUILDER(EncryptedAttribute);
 441         DECL_SAML2OBJECTBUILDER(EncryptedID);
 442         DECL_SAML2OBJECTBUILDER(Evidence);
 443         DECL_SAML2OBJECTBUILDER(Issuer);
 444         DECL_SAML2OBJECTBUILDER(NameID);
 445         DECL_SAML2OBJECTBUILDER(OneTimeUse);
 446         DECL_SAML2OBJECTBUILDER(ProxyRestriction);
 447         DECL_SAML2OBJECTBUILDER(Subject);
 448         DECL_SAML2OBJECTBUILDER(SubjectConfirmation);
 449         DECL_SAML2OBJECTBUILDER(SubjectConfirmationData);
 450         DECL_SAML2OBJECTBUILDER(SubjectLocality);
 451
 452         DECL_XMLOBJECTBUILDER(SAML_API,Delegate,samlconstants::SAML20_DELEGATION_CONDITION_NS,samlconstants::SAML20_DELEGATION_CONDITION_PREFIX);
 453
 454         /**
 455          * Builder for NameIDType objects.
 456          *
 457          * This is customized to force the element name to be specified.
 458          */
 459         class SAML_API NameIDTypeBuilder : public xmltooling::XMLObjectBuilder {
 460         public:
 461             virtual ~NameIDTypeBuilder() {}
 462             /** Builder that allows element/type override. */
 463 #ifdef HAVE_COVARIANT_RETURNS
 464             virtual NameIDType* buildObject(
 465 #else
 466             virtual xmltooling::XMLObject* buildObject(
 467 #endif
 468                 const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=nullptr, const xmltooling::QName* schemaType=nullptr
 469                 ) const;
 470
 471             /** Singleton builder. */
 472             static NameIDType* buildNameIDType(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=nullptr) {
 473                 const NameIDTypeBuilder* b = dynamic_cast<const NameIDTypeBuilder*>(
 474                     XMLObjectBuilder::getBuilder(xmltooling::QName(samlconstants::SAML20_NS,NameIDType::TYPE_NAME))
 475                     );
 476                 if (b) {
 477                     xmltooling::QName schemaType(samlconstants::SAML20_NS,NameIDType::TYPE_NAME,samlconstants::SAML20_PREFIX);
 478 #ifdef HAVE_COVARIANT_RETURNS
 479                     return b->buildObject(nsURI, localName, prefix, &schemaType);
 480 #else
 481                     return dynamic_cast<NameIDType*>(b->buildObject(nsURI, localName, prefix, &schemaType));
 482 #endif
 483                 }
 484                 throw xmltooling::XMLObjectException("Unable to obtain typed builder for NameIDType.");
 485             }
 486         };
 487
 488         /**
 489          * Builder for Condition extension objects.
 490          *
 491          * This is customized to force the schema type to be specified.
 492          */
 493         class SAML_API ConditionBuilder : public xmltooling::XMLObjectBuilder {
 494         public:
 495             virtual ~ConditionBuilder() {}
 496             /** Builder that allows element/type override. */
 497 #ifdef HAVE_COVARIANT_RETURNS
 498             virtual Condition* buildObject(
 499 #else
 500             virtual xmltooling::XMLObject* buildObject(
 501 #endif
 502                 const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=nullptr, const xmltooling::QName* schemaType=nullptr
 503                 ) const;
 504
 505             /** Singleton builder. */
 506             static Condition* buildCondition(const xmltooling::QName& schemaType) {
 507                 const ConditionBuilder* b = dynamic_cast<const ConditionBuilder*>(
 508                     XMLObjectBuilder::getBuilder(xmltooling::QName(samlconstants::SAML20_NS,Condition::LOCAL_NAME))
 509                     );
 510                 if (b) {
 511 #ifdef HAVE_COVARIANT_RETURNS
 512                     return b->buildObject(samlconstants::SAML20_NS, Condition::LOCAL_NAME, samlconstants::SAML20_PREFIX, &schemaType);
 513 #else
 514                     return dynamic_cast<Condition*>(b->buildObject(samlconstants::SAML20_NS, Condition::LOCAL_NAME, samlconstants::SAML20_PREFIX, &schemaType));
 515 #endif
 516                 }
 517                 throw xmltooling::XMLObjectException("Unable to obtain typed builder for Condition.");
 518             }
 519         };
 520
 521         /**
 522          * Builder for DelegationRestrictionType objects.
 523          *
 524          * This is customized to return a Condition element with an xsi:type of DelegationRestrictionType.
 525          */
 526         class SAML_API DelegationRestrictionTypeBuilder : public xmltooling::ConcreteXMLObjectBuilder {
 527         public:
 528             virtual ~DelegationRestrictionTypeBuilder() {}
 529             /** Default builder. */
 530 #ifdef HAVE_COVARIANT_RETURNS
 531             virtual DelegationRestrictionType* buildObject() const {
 532 #else
 533             virtual xmltooling::XMLObject* buildObject() const {
 534 #endif
 535                 xmltooling::QName schemaType(
 536                     samlconstants::SAML20_DELEGATION_CONDITION_NS,
 537                     DelegationRestrictionType::TYPE_NAME,
 538                     samlconstants::SAML20_DELEGATION_CONDITION_PREFIX
 539                     );
 540                 return buildObject(
 541                     samlconstants::SAML20_DELEGATION_CONDITION_NS,
 542                     DelegationRestrictionType::LOCAL_NAME,
 543                     samlconstants::SAML20_DELEGATION_CONDITION_PREFIX,
 544                     &schemaType
 545                     );
 546             }
 547             /** Builder that allows element/type override. */
 548 #ifdef HAVE_COVARIANT_RETURNS
 549             virtual DelegationRestrictionType* buildObject(
 550 #else
 551             virtual xmltooling::XMLObject* buildObject(
 552 #endif
 553                 const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=nullptr, const xmltooling::QName* schemaType=nullptr
 554                 ) const;
 555
 556             /** Singleton builder. */
 557             static DelegationRestrictionType* buildDelegationRestrictionType() {
 558                 const DelegationRestrictionTypeBuilder* b = dynamic_cast<const DelegationRestrictionTypeBuilder*>(
 559                     XMLObjectBuilder::getBuilder(xmltooling::QName(samlconstants::SAML20_DELEGATION_CONDITION_NS,DelegationRestrictionType::TYPE_NAME))
 560                     );
 561                 if (b)
 562 #ifdef HAVE_COVARIANT_RETURNS
 563                     return b->buildObject();
 564 #else
 565                     return dynamic_cast<DelegationRestrictionType*>(b->buildObject());
 566 #endif
 567                 throw xmltooling::XMLObjectException("Unable to obtain typed builder for DelegationRestrictionType.");
 568             }
 569         };
 570
 571         /**
 572          * Builder for KeyInfoConfirmationDataType objects.
 573          *
 574          * This is customized to return a SubjectConfirmationData element with an
 575          * xsi:type of KeyInfoConfirmationDataType.
 576          */
 577         class SAML_API KeyInfoConfirmationDataTypeBuilder : public xmltooling::ConcreteXMLObjectBuilder {
 578         public:
 579             virtual ~KeyInfoConfirmationDataTypeBuilder() {}
 580             /** Default builder. */
 581 #ifdef HAVE_COVARIANT_RETURNS
 582             virtual KeyInfoConfirmationDataType* buildObject() const {
 583 #else
 584             virtual xmltooling::XMLObject* buildObject() const {
 585 #endif
 586                 xmltooling::QName schemaType(
 587                     samlconstants::SAML20_NS,KeyInfoConfirmationDataType::TYPE_NAME,samlconstants::SAML20_PREFIX
 588                     );
 589                 return buildObject(
 590                     samlconstants::SAML20_NS,KeyInfoConfirmationDataType::LOCAL_NAME,samlconstants::SAML20_PREFIX,&schemaType
 591                     );
 592             }
 593             /** Builder that allows element/type override. */
 594 #ifdef HAVE_COVARIANT_RETURNS
 595             virtual KeyInfoConfirmationDataType* buildObject(
 596 #else
 597             virtual xmltooling::XMLObject* buildObject(
 598 #endif
 599                 const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=nullptr, const xmltooling::QName* schemaType=nullptr
 600                 ) const;
 601
 602             /** Singleton builder. */
 603             static KeyInfoConfirmationDataType* buildKeyInfoConfirmationDataType() {
 604                 const KeyInfoConfirmationDataTypeBuilder* b = dynamic_cast<const KeyInfoConfirmationDataTypeBuilder*>(
 605                     XMLObjectBuilder::getBuilder(xmltooling::QName(samlconstants::SAML20_NS,KeyInfoConfirmationDataType::TYPE_NAME))
 606                     );
 607                 if (b)
 608 #ifdef HAVE_COVARIANT_RETURNS
 609                     return b->buildObject();
 610 #else
 611                     return dynamic_cast<KeyInfoConfirmationDataType*>(b->buildObject());
 612 #endif
 613                 throw xmltooling::XMLObjectException("Unable to obtain typed builder for KeyInfoConfirmationDataType.");
 614             }
 615         };
 616
 617         /**
 618          * Builder for Statement extension objects.
 619          *
 620          * This is customized to force the schema type to be specified.
 621          */
 622         class SAML_API StatementBuilder : public xmltooling::XMLObjectBuilder {
 623         public:
 624             virtual ~StatementBuilder() {}
 625             /** Builder that allows element/type override. */
 626 #ifdef HAVE_COVARIANT_RETURNS
 627             virtual Statement* buildObject(
 628 #else
 629             virtual xmltooling::XMLObject* buildObject(
 630 #endif
 631                 const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=nullptr, const xmltooling::QName* schemaType=nullptr
 632                 ) const;
 633
 634             /** Singleton builder. */
 635             static Statement* buildStatement(const xmltooling::QName& schemaType) {
 636                 const StatementBuilder* b = dynamic_cast<const StatementBuilder*>(
 637                     XMLObjectBuilder::getBuilder(xmltooling::QName(samlconstants::SAML20_NS,Statement::LOCAL_NAME))
 638                     );
 639                 if (b) {
 640 #ifdef HAVE_COVARIANT_RETURNS
 641                     return b->buildObject(samlconstants::SAML20_NS, Statement::LOCAL_NAME, samlconstants::SAML20_PREFIX, &schemaType);
 642 #else
 643                     return dynamic_cast<Statement*>(b->buildObject(samlconstants::SAML20_NS, Statement::LOCAL_NAME, samlconstants::SAML20_PREFIX, &schemaType));
 644 #endif
 645                 }
 646                 throw xmltooling::XMLObjectException("Unable to obtain typed builder for Statement.");
 647             }
 648         };
 649
 650         /**
 651          * Registers builders and validators for SAML 2.0 Assertion classes into the runtime.
 652          */
 653         void SAML_API registerAssertionClasses();
 654     };
 655 };
 656
 657 #endif /* __saml2_assertions_h__ */