xmltooling/encryption/impl/EncryptionImpl.cpp

   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  * EncryptionImpl.cpp
  23  *
  24  * Implementation classes for XML Encryption schema.
  25  */
  26
  27 #include "internal.h"
  28 #include "AbstractAttributeExtensibleXMLObject.h"
  29 #include "AbstractComplexElement.h"
  30 #include "AbstractSimpleElement.h"
  31 #include "exceptions.h"
  32 #include "encryption/Encryption.h"
  33 #include "io/AbstractXMLObjectMarshaller.h"
  34 #include "io/AbstractXMLObjectUnmarshaller.h"
  35 #include "signature/KeyInfo.h"
  36 #include "util/XMLHelper.h"
  37
  38 #include <xercesc/util/XMLUniDefs.hpp>
  39
  40 using namespace xmlencryption;
  41 using namespace xmltooling;
  42 using namespace xercesc;
  43 using namespace std;
  44 using xmlconstants::XMLENC_NS;
  45 using xmlconstants::XMLSIG_NS;
  46
  47 #if defined (_MSC_VER)
  48     #pragma warning( push )
  49     #pragma warning( disable : 4250 4251 )
  50 #endif
  51
  52 namespace xmlencryption {
  53
  54     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,CarriedKeyName);
  55     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,CipherValue);
  56     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,KeySize);
  57     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,OAEPparams);
  58
  59     class XMLTOOL_DLLLOCAL EncryptionMethodImpl : public virtual EncryptionMethod,
  60         public AbstractComplexElement,
  61         public AbstractDOMCachingXMLObject,
  62         public AbstractXMLObjectMarshaller,
  63         public AbstractXMLObjectUnmarshaller
  64     {
  65         void init() {
  66             m_Algorithm=nullptr;
  67             m_KeySize=nullptr;
  68             m_OAEPparams=nullptr;
  69             m_children.push_back(nullptr);
  70             m_children.push_back(nullptr);
  71             m_pos_KeySize=m_children.begin();
  72             m_pos_OAEPparams=m_pos_KeySize;
  73             ++m_pos_OAEPparams;
  74         }
  75     public:
  76         virtual ~EncryptionMethodImpl() {
  77             XMLString::release(&m_Algorithm);
  78         }
  79
  80         EncryptionMethodImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
  81                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
  82             init();
  83         }
  84
  85         EncryptionMethodImpl(const EncryptionMethodImpl& src)
  86                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
  87             init();
  88             setAlgorithm(src.getAlgorithm());
  89             if (src.getKeySize())
  90                 setKeySize(src.getKeySize()->cloneKeySize());
  91             if (src.getOAEPparams())
  92                 setOAEPparams(src.getOAEPparams()->cloneOAEPparams());
  93             VectorOf(XMLObject) v=getUnknownXMLObjects();
  94             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
  95                 v.push_back((*i)->clone());
  96         }
  97
  98         IMPL_XMLOBJECT_CLONE(EncryptionMethod);
  99         IMPL_STRING_ATTRIB(Algorithm);
 100         IMPL_TYPED_CHILD(KeySize);
 101         IMPL_TYPED_CHILD(OAEPparams);
 102         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 103
 104     protected:
 105         void marshallAttributes(DOMElement* domElement) const {
 106             MARSHALL_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 107         }
 108
 109         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 110             PROC_TYPED_CHILD(KeySize,XMLENC_NS,false);
 111             PROC_TYPED_CHILD(OAEPparams,XMLENC_NS,false);
 112
 113             // Unknown child.
 114             const XMLCh* nsURI=root->getNamespaceURI();
 115             if (!XMLString::equals(nsURI,XMLENC_NS) && nsURI && *nsURI) {
 116                 getUnknownXMLObjects().push_back(childXMLObject);
 117                 return;
 118             }
 119
 120             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 121         }
 122
 123         void processAttribute(const DOMAttr* attribute) {
 124             PROC_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 125             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 126         }
 127     };
 128
 129     class XMLTOOL_DLLLOCAL TransformsImpl : public virtual Transforms,
 130         public AbstractComplexElement,
 131         public AbstractDOMCachingXMLObject,
 132         public AbstractXMLObjectMarshaller,
 133         public AbstractXMLObjectUnmarshaller
 134     {
 135     public:
 136         virtual ~TransformsImpl() {}
 137
 138         TransformsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 139             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 140         }
 141
 142         TransformsImpl(const TransformsImpl& src)
 143                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 144             VectorOf(xmlsignature::Transform) v=getTransforms();
 145             for (vector<xmlsignature::Transform*>::const_iterator i=src.m_Transforms.begin(); i!=src.m_Transforms.end(); i++) {
 146                 if (*i) {
 147                     v.push_back((*i)->cloneTransform());
 148                 }
 149             }
 150         }
 151
 152         IMPL_XMLOBJECT_CLONE(Transforms);
 153         IMPL_TYPED_FOREIGN_CHILDREN(Transform,xmlsignature,m_children.end());
 154
 155     protected:
 156         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 157             PROC_TYPED_FOREIGN_CHILDREN(Transform,xmlsignature,XMLSIG_NS,false);
 158             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 159         }
 160     };
 161
 162     class XMLTOOL_DLLLOCAL CipherReferenceImpl : public virtual CipherReference,
 163         public AbstractComplexElement,
 164         public AbstractDOMCachingXMLObject,
 165         public AbstractXMLObjectMarshaller,
 166         public AbstractXMLObjectUnmarshaller
 167     {
 168         void init() {
 169             m_URI=nullptr;
 170             m_Transforms=nullptr;
 171             m_children.push_back(nullptr);
 172             m_pos_Transforms=m_children.begin();
 173         }
 174     public:
 175         virtual ~CipherReferenceImpl() {
 176             XMLString::release(&m_URI);
 177         }
 178
 179         CipherReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 180                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 181             init();
 182         }
 183
 184         CipherReferenceImpl(const CipherReferenceImpl& src)
 185                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 186             init();
 187             setURI(src.getURI());
 188             if (src.getTransforms())
 189                 setTransforms(src.getTransforms()->cloneTransforms());
 190         }
 191
 192         IMPL_XMLOBJECT_CLONE(CipherReference);
 193         IMPL_STRING_ATTRIB(URI);
 194         IMPL_TYPED_CHILD(Transforms);
 195
 196     protected:
 197         void marshallAttributes(DOMElement* domElement) const {
 198             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 199         }
 200
 201         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 202             PROC_TYPED_CHILD(Transforms,XMLENC_NS,false);
 203             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 204         }
 205
 206         void processAttribute(const DOMAttr* attribute) {
 207             PROC_STRING_ATTRIB(URI,URI,nullptr);
 208             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 209         }
 210     };
 211
 212     class XMLTOOL_DLLLOCAL CipherDataImpl : public virtual CipherData,
 213         public AbstractComplexElement,
 214         public AbstractDOMCachingXMLObject,
 215         public AbstractXMLObjectMarshaller,
 216         public AbstractXMLObjectUnmarshaller
 217     {
 218         void init() {
 219             m_CipherValue=nullptr;
 220             m_CipherReference=nullptr;
 221             m_children.push_back(nullptr);
 222             m_children.push_back(nullptr);
 223             m_pos_CipherValue=m_children.begin();
 224             m_pos_CipherReference=m_pos_CipherValue;
 225             ++m_pos_CipherReference;
 226         }
 227     public:
 228         virtual ~CipherDataImpl() {}
 229
 230         CipherDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 231                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 232             init();
 233         }
 234
 235         CipherDataImpl(const CipherDataImpl& src)
 236                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 237             init();
 238             if (src.getCipherValue())
 239                 setCipherValue(src.getCipherValue()->cloneCipherValue());
 240             if (src.getCipherReference())
 241                 setCipherReference(src.getCipherReference()->cloneCipherReference());
 242         }
 243
 244         IMPL_XMLOBJECT_CLONE(CipherData);
 245         IMPL_TYPED_CHILD(CipherValue);
 246         IMPL_TYPED_CHILD(CipherReference);
 247
 248     protected:
 249         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 250             PROC_TYPED_CHILD(CipherValue,XMLENC_NS,false);
 251             PROC_TYPED_CHILD(CipherReference,XMLENC_NS,false);
 252             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 253         }
 254     };
 255
 256     class XMLTOOL_DLLLOCAL EncryptionPropertyImpl : public virtual EncryptionProperty,
 257         public AbstractAttributeExtensibleXMLObject,
 258         public AbstractComplexElement,
 259         public AbstractDOMCachingXMLObject,
 260         public AbstractXMLObjectMarshaller,
 261         public AbstractXMLObjectUnmarshaller
 262     {
 263         void init() {
 264             m_Id=m_Target=nullptr;
 265         }
 266     public:
 267         virtual ~EncryptionPropertyImpl() {
 268             XMLString::release(&m_Id);
 269             XMLString::release(&m_Target);
 270         }
 271
 272         EncryptionPropertyImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 273             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 274             init();
 275         }
 276
 277         EncryptionPropertyImpl(const EncryptionPropertyImpl& src)
 278                 : AbstractXMLObject(src),
 279                     AbstractAttributeExtensibleXMLObject(src),
 280                     AbstractComplexElement(src),
 281                     AbstractDOMCachingXMLObject(src) {
 282             init();
 283             setId(src.getId());
 284             setTarget(src.getTarget());
 285             VectorOf(XMLObject) v=getUnknownXMLObjects();
 286             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 287                 v.push_back((*i)->clone());
 288         }
 289
 290         IMPL_XMLOBJECT_CLONE(EncryptionProperty);
 291         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 292         IMPL_STRING_ATTRIB(Target);
 293         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject, m_children.end());
 294
 295         void setAttribute(const xmltooling::QName& qualifiedName, const XMLCh* value, bool ID=false) {
 296             if (!qualifiedName.hasNamespaceURI()) {
 297                 if (XMLString::equals(qualifiedName.getLocalPart(),ID_ATTRIB_NAME)) {
 298                     setId(value);
 299                     return;
 300                 }
 301                 else if (XMLString::equals(qualifiedName.getLocalPart(),TARGET_ATTRIB_NAME)) {
 302                     setTarget(value);
 303                     return;
 304                 }
 305             }
 306             AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value, ID);
 307         }
 308
 309     protected:
 310         void marshallAttributes(DOMElement* domElement) const {
 311             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 312             MARSHALL_STRING_ATTRIB(Target,TARGET,nullptr);
 313             marshallExtensionAttributes(domElement);
 314         }
 315
 316         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 317             getUnknownXMLObjects().push_back(childXMLObject);
 318         }
 319
 320         void processAttribute(const DOMAttr* attribute) {
 321             PROC_ID_ATTRIB(Id,ID,nullptr);
 322             unmarshallExtensionAttribute(attribute);
 323         }
 324     };
 325
 326     class XMLTOOL_DLLLOCAL EncryptionPropertiesImpl : public virtual EncryptionProperties,
 327         public AbstractComplexElement,
 328         public AbstractDOMCachingXMLObject,
 329         public AbstractXMLObjectMarshaller,
 330         public AbstractXMLObjectUnmarshaller
 331     {
 332         void init() {
 333             m_Id=nullptr;
 334         }
 335     public:
 336         virtual ~EncryptionPropertiesImpl() {
 337             XMLString::release(&m_Id);
 338         }
 339
 340         EncryptionPropertiesImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 341             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 342             init();
 343         }
 344
 345         EncryptionPropertiesImpl(const EncryptionPropertiesImpl& src)
 346                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 347             init();
 348             setId(src.getId());
 349             VectorOf(EncryptionProperty) v=getEncryptionPropertys();
 350             for (vector<EncryptionProperty*>::const_iterator i=src.m_EncryptionPropertys.begin(); i!=src.m_EncryptionPropertys.end(); i++) {
 351                 if (*i) {
 352                     v.push_back((*i)->cloneEncryptionProperty());
 353                 }
 354             }
 355         }
 356
 357         IMPL_XMLOBJECT_CLONE(EncryptionProperties);
 358         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 359         IMPL_TYPED_CHILDREN(EncryptionProperty,m_children.end());
 360
 361     protected:
 362         void marshallAttributes(DOMElement* domElement) const {
 363             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 364         }
 365
 366         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 367             PROC_TYPED_CHILDREN(EncryptionProperty,XMLENC_NS,false);
 368             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 369         }
 370
 371         void processAttribute(const DOMAttr* attribute) {
 372             PROC_ID_ATTRIB(Id,ID,nullptr);
 373             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 374         }
 375     };
 376
 377     class XMLTOOL_DLLLOCAL ReferenceTypeImpl : public virtual ReferenceType,
 378         public AbstractComplexElement,
 379         public AbstractDOMCachingXMLObject,
 380         public AbstractXMLObjectMarshaller,
 381         public AbstractXMLObjectUnmarshaller
 382     {
 383     protected:
 384         ReferenceTypeImpl() {
 385             m_URI=nullptr;
 386         }
 387
 388     public:
 389         virtual ~ReferenceTypeImpl() {
 390             XMLString::release(&m_URI);
 391         }
 392
 393         ReferenceTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 394             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 395             m_URI=nullptr;
 396         }
 397
 398         ReferenceTypeImpl(const ReferenceTypeImpl& src)
 399                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 400             m_URI=nullptr;
 401         }
 402
 403         void _clone(const ReferenceTypeImpl& src) {
 404             setURI(src.getURI());
 405             VectorOf(XMLObject) v=getUnknownXMLObjects();
 406             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 407                 v.push_back((*i)->clone());
 408         }
 409
 410         IMPL_XMLOBJECT_CLONE_EX(ReferenceType);
 411         IMPL_STRING_ATTRIB(URI);
 412         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 413
 414     protected:
 415         void marshallAttributes(DOMElement* domElement) const {
 416             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 417         }
 418
 419         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 420             getUnknownXMLObjects().push_back(childXMLObject);
 421         }
 422
 423         void processAttribute(const DOMAttr* attribute) {
 424             PROC_STRING_ATTRIB(URI,URI,nullptr);
 425             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 426         }
 427     };
 428
 429     class XMLTOOL_DLLLOCAL DataReferenceImpl : public virtual DataReference, public ReferenceTypeImpl
 430     {
 431     public:
 432         virtual ~DataReferenceImpl() {}
 433
 434         DataReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 435             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 436
 437         DataReferenceImpl(const DataReferenceImpl& src) : AbstractXMLObject(src), ReferenceTypeImpl(src) {}
 438
 439         IMPL_XMLOBJECT_CLONE_EX(DataReference);
 440     };
 441
 442     class XMLTOOL_DLLLOCAL KeyReferenceImpl : public virtual KeyReference, public ReferenceTypeImpl
 443     {
 444     public:
 445         virtual ~KeyReferenceImpl() {}
 446
 447         KeyReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 448             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 449
 450         KeyReferenceImpl(const KeyReferenceImpl& src) : AbstractXMLObject(src), ReferenceTypeImpl(src) {}
 451
 452         IMPL_XMLOBJECT_CLONE_EX(KeyReference);
 453     };
 454
 455     class XMLTOOL_DLLLOCAL ReferenceListImpl : public virtual ReferenceList,
 456         public AbstractComplexElement,
 457         public AbstractDOMCachingXMLObject,
 458         public AbstractXMLObjectMarshaller,
 459         public AbstractXMLObjectUnmarshaller
 460     {
 461     public:
 462         virtual ~ReferenceListImpl() {}
 463
 464         ReferenceListImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 465             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 466         }
 467
 468         ReferenceListImpl(const ReferenceListImpl& src)
 469                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 470             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 471                 if (*i) {
 472                     DataReference* data=dynamic_cast<DataReference*>(*i);
 473                     if (data) {
 474                         getDataReferences().push_back(data->cloneDataReference());
 475                         continue;
 476                     }
 477
 478                     KeyReference* key=dynamic_cast<KeyReference*>(*i);
 479                     if (key) {
 480                         getKeyReferences().push_back(key->cloneKeyReference());
 481                         continue;
 482                     }
 483                 }
 484             }
 485         }
 486
 487         IMPL_XMLOBJECT_CLONE(ReferenceList);
 488         IMPL_TYPED_CHILDREN(DataReference,m_children.end());
 489         IMPL_TYPED_CHILDREN(KeyReference,m_children.end());
 490
 491     protected:
 492         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 493             PROC_TYPED_CHILDREN(DataReference,XMLENC_NS,false);
 494             PROC_TYPED_CHILDREN(KeyReference,XMLENC_NS,false);
 495             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 496         }
 497     };
 498
 499     class XMLTOOL_DLLLOCAL EncryptedTypeImpl : public virtual EncryptedType,
 500         public AbstractComplexElement,
 501         public AbstractDOMCachingXMLObject,
 502         public AbstractXMLObjectMarshaller,
 503         public AbstractXMLObjectUnmarshaller
 504     {
 505         void init() {
 506             m_Id=m_Type=m_MimeType=m_Encoding=nullptr;
 507             m_EncryptionMethod=nullptr;
 508             m_KeyInfo=nullptr;
 509             m_CipherData=nullptr;
 510             m_EncryptionProperties=nullptr;
 511             m_children.push_back(nullptr);
 512             m_children.push_back(nullptr);
 513             m_children.push_back(nullptr);
 514             m_children.push_back(nullptr);
 515             m_pos_EncryptionMethod=m_children.begin();
 516             m_pos_KeyInfo=m_pos_EncryptionMethod;
 517             ++m_pos_KeyInfo;
 518             m_pos_CipherData=m_pos_KeyInfo;
 519             ++m_pos_CipherData;
 520             m_pos_EncryptionProperties=m_pos_CipherData;
 521             ++m_pos_EncryptionProperties;
 522         }
 523     protected:
 524         EncryptedTypeImpl() {
 525             init();
 526         }
 527
 528     public:
 529         virtual ~EncryptedTypeImpl() {
 530             XMLString::release(&m_Id);
 531             XMLString::release(&m_Type);
 532             XMLString::release(&m_MimeType);
 533             XMLString::release(&m_Encoding);
 534         }
 535
 536         EncryptedTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 537                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 538             init();
 539         }
 540
 541         EncryptedTypeImpl(const EncryptedTypeImpl& src)
 542                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 543             init();
 544         }
 545
 546         void _clone(const EncryptedTypeImpl& src) {
 547             setId(src.getId());
 548             setType(src.getType());
 549             setMimeType(src.getMimeType());
 550             setEncoding(src.getEncoding());
 551             if (src.getEncryptionMethod())
 552                 setEncryptionMethod(src.getEncryptionMethod()->cloneEncryptionMethod());
 553             if (src.getKeyInfo())
 554                 setKeyInfo(src.getKeyInfo()->cloneKeyInfo());
 555             if (src.getCipherData())
 556                 setCipherData(src.getCipherData()->cloneCipherData());
 557             if (src.getEncryptionProperties())
 558                 setEncryptionProperties(src.getEncryptionProperties()->cloneEncryptionProperties());
 559         }
 560
 561         IMPL_XMLOBJECT_CLONE_EX(EncryptedType);
 562         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 563         IMPL_STRING_ATTRIB(Type);
 564         IMPL_STRING_ATTRIB(MimeType);
 565         IMPL_STRING_ATTRIB(Encoding);
 566         IMPL_TYPED_CHILD(EncryptionMethod);
 567         IMPL_TYPED_FOREIGN_CHILD(KeyInfo,xmlsignature);
 568         IMPL_TYPED_CHILD(CipherData);
 569         IMPL_TYPED_CHILD(EncryptionProperties);
 570
 571     protected:
 572         void marshallAttributes(DOMElement* domElement) const {
 573             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 574             MARSHALL_STRING_ATTRIB(Type,TYPE,nullptr);
 575             MARSHALL_STRING_ATTRIB(MimeType,MIMETYPE,nullptr);
 576             MARSHALL_STRING_ATTRIB(Encoding,ENCODING,nullptr);
 577         }
 578
 579         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 580             PROC_TYPED_CHILD(EncryptionMethod,XMLENC_NS,false);
 581             PROC_TYPED_FOREIGN_CHILD(KeyInfo,xmlsignature,XMLSIG_NS,false);
 582             PROC_TYPED_CHILD(CipherData,XMLENC_NS,false);
 583             PROC_TYPED_CHILD(EncryptionProperties,XMLENC_NS,false);
 584             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 585         }
 586
 587         void processAttribute(const DOMAttr* attribute) {
 588             PROC_ID_ATTRIB(Id,ID,nullptr);
 589             PROC_STRING_ATTRIB(Type,TYPE,nullptr);
 590             PROC_STRING_ATTRIB(MimeType,MIMETYPE,nullptr);
 591             PROC_STRING_ATTRIB(Encoding,ENCODING,nullptr);
 592             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 593         }
 594     };
 595
 596     class XMLTOOL_DLLLOCAL EncryptedDataImpl : public virtual EncryptedData, public EncryptedTypeImpl
 597     {
 598     public:
 599         virtual ~EncryptedDataImpl() {}
 600
 601         EncryptedDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 602             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 603
 604         EncryptedDataImpl(const EncryptedDataImpl& src) : AbstractXMLObject(src), EncryptedTypeImpl(src) {}
 605
 606         IMPL_XMLOBJECT_CLONE_EX(EncryptedData);
 607     };
 608
 609     class XMLTOOL_DLLLOCAL EncryptedKeyImpl : public virtual EncryptedKey, public EncryptedTypeImpl
 610     {
 611         void init() {
 612             m_Recipient=nullptr;
 613             m_ReferenceList=nullptr;
 614             m_CarriedKeyName=nullptr;
 615             m_children.push_back(nullptr);
 616             m_children.push_back(nullptr);
 617             m_pos_ReferenceList=m_pos_EncryptionProperties;
 618             ++m_pos_ReferenceList;
 619             m_pos_CarriedKeyName=m_pos_ReferenceList;
 620             ++m_pos_CarriedKeyName;
 621         }
 622
 623     public:
 624         virtual ~EncryptedKeyImpl() {
 625             XMLString::release(&m_Recipient);
 626         }
 627
 628         EncryptedKeyImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 629                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 630             init();
 631         }
 632
 633         EncryptedKeyImpl(const EncryptedKeyImpl& src) : AbstractXMLObject(src), EncryptedTypeImpl(src) {
 634             init();
 635         }
 636
 637         void _clone(const EncryptedKeyImpl& src) {
 638             EncryptedTypeImpl::_clone(src);
 639             setRecipient(src.getRecipient());
 640             if (src.getReferenceList())
 641                 setReferenceList(src.getReferenceList()->cloneReferenceList());
 642             if (src.getCarriedKeyName())
 643                 setCarriedKeyName(src.getCarriedKeyName()->cloneCarriedKeyName());
 644         }
 645
 646         IMPL_XMLOBJECT_CLONE_EX(EncryptedKey);
 647
 648         IMPL_STRING_ATTRIB(Recipient);
 649         IMPL_TYPED_CHILD(ReferenceList);
 650         IMPL_TYPED_CHILD(CarriedKeyName);
 651
 652     protected:
 653         void marshallAttributes(DOMElement* domElement) const {
 654             MARSHALL_STRING_ATTRIB(Recipient,RECIPIENT,nullptr);
 655             EncryptedTypeImpl::marshallAttributes(domElement);
 656         }
 657
 658         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 659             PROC_TYPED_CHILD(ReferenceList,XMLENC_NS,false);
 660             PROC_TYPED_CHILD(CarriedKeyName,XMLENC_NS,false);
 661             EncryptedTypeImpl::processChildElement(childXMLObject,root);
 662         }
 663
 664         void processAttribute(const DOMAttr* attribute) {
 665             PROC_STRING_ATTRIB(Recipient,RECIPIENT,nullptr);
 666             EncryptedTypeImpl::processAttribute(attribute);
 667         }
 668     };
 669
 670 };
 671
 672 #if defined (_MSC_VER)
 673     #pragma warning( pop )
 674 #endif
 675
 676 // Builder Implementations
 677
 678 IMPL_XMLOBJECTBUILDER(CarriedKeyName);
 679 IMPL_XMLOBJECTBUILDER(CipherData);
 680 IMPL_XMLOBJECTBUILDER(CipherReference);
 681 IMPL_XMLOBJECTBUILDER(CipherValue);
 682 IMPL_XMLOBJECTBUILDER(DataReference);
 683 IMPL_XMLOBJECTBUILDER(EncryptedData);
 684 IMPL_XMLOBJECTBUILDER(EncryptedKey);
 685 IMPL_XMLOBJECTBUILDER(EncryptionMethod);
 686 IMPL_XMLOBJECTBUILDER(EncryptionProperties);
 687 IMPL_XMLOBJECTBUILDER(EncryptionProperty);
 688 IMPL_XMLOBJECTBUILDER(KeyReference);
 689 IMPL_XMLOBJECTBUILDER(KeySize);
 690 IMPL_XMLOBJECTBUILDER(OAEPparams);
 691 IMPL_XMLOBJECTBUILDER(ReferenceList);
 692 IMPL_XMLOBJECTBUILDER(Transforms);
 693
 694 // Unicode literals
 695
 696 const XMLCh CarriedKeyName::LOCAL_NAME[] =              UNICODE_LITERAL_14(C,a,r,r,i,e,d,K,e,y,N,a,m,e);
 697 const XMLCh CipherData::LOCAL_NAME[] =                  UNICODE_LITERAL_10(C,i,p,h,e,r,D,a,t,a);
 698 const XMLCh CipherData::TYPE_NAME[] =                   UNICODE_LITERAL_14(C,i,p,h,e,r,D,a,t,a,T,y,p,e);
 699 const XMLCh CipherReference::LOCAL_NAME[] =             UNICODE_LITERAL_15(C,i,p,h,e,r,R,e,f,e,r,e,n,c,e);
 700 const XMLCh CipherReference::TYPE_NAME[] =              UNICODE_LITERAL_19(C,i,p,h,e,r,R,e,f,e,r,e,n,c,e,T,y,p,e);
 701 const XMLCh CipherReference::URI_ATTRIB_NAME[] =        UNICODE_LITERAL_3(U,R,I);
 702 const XMLCh CipherValue::LOCAL_NAME[] =                 UNICODE_LITERAL_11(C,i,p,h,e,r,V,a,l,u,e);
 703 const XMLCh DataReference::LOCAL_NAME[] =               UNICODE_LITERAL_13(D,a,t,a,R,e,f,e,r,e,n,c,e);
 704 const XMLCh EncryptedData::LOCAL_NAME[] =               UNICODE_LITERAL_13(E,n,c,r,y,p,t,e,d,D,a,t,a);
 705 const XMLCh EncryptedData::TYPE_NAME[] =                UNICODE_LITERAL_17(E,n,c,r,y,p,t,e,d,D,a,t,a,T,y,p,e);
 706 const XMLCh EncryptedKey::LOCAL_NAME[] =                UNICODE_LITERAL_12(E,n,c,r,y,p,t,e,d,K,e,y);
 707 const XMLCh EncryptedKey::TYPE_NAME[] =                 UNICODE_LITERAL_16(E,n,c,r,y,p,t,e,d,K,e,y,T,y,p,e);
 708 const XMLCh EncryptedKey::RECIPIENT_ATTRIB_NAME[] =     UNICODE_LITERAL_9(R,e,c,i,p,i,e,n,t);
 709 const XMLCh EncryptedType::LOCAL_NAME[] =               {chNull};
 710 const XMLCh EncryptedType::TYPE_NAME[] =                UNICODE_LITERAL_13(E,n,c,r,y,p,t,e,d,T,y,p,e);
 711 const XMLCh EncryptedType::ID_ATTRIB_NAME[] =           UNICODE_LITERAL_2(I,d);
 712 const XMLCh EncryptedType::TYPE_ATTRIB_NAME[] =         UNICODE_LITERAL_4(T,y,p,e);
 713 const XMLCh EncryptedType::MIMETYPE_ATTRIB_NAME[] =     UNICODE_LITERAL_8(M,i,m,e,T,y,p,e);
 714 const XMLCh EncryptedType::ENCODING_ATTRIB_NAME[] =     UNICODE_LITERAL_8(E,n,c,o,d,i,n,g);
 715 const XMLCh EncryptionMethod::LOCAL_NAME[] =            UNICODE_LITERAL_16(E,n,c,r,y,p,t,i,o,n,M,e,t,h,o,d);
 716 const XMLCh EncryptionMethod::TYPE_NAME[] =             UNICODE_LITERAL_20(E,n,c,r,y,p,t,i,o,n,M,e,t,h,o,d,T,y,p,e);
 717 const XMLCh EncryptionMethod::ALGORITHM_ATTRIB_NAME[] = UNICODE_LITERAL_9(A,l,g,o,r,i,t,h,m);
 718 const XMLCh EncryptionProperties::LOCAL_NAME[] =        UNICODE_LITERAL_20(E,n,c,r,y,p,t,i,o,n,P,r,o,p,e,r,t,i,e,s);
 719 const XMLCh EncryptionProperties::TYPE_NAME[] =         UNICODE_LITERAL_24(E,n,c,r,y,p,t,i,o,n,P,r,o,p,e,r,t,i,e,s,T,y,p,e);
 720 const XMLCh EncryptionProperties::ID_ATTRIB_NAME[] =    UNICODE_LITERAL_2(I,d);
 721 const XMLCh EncryptionProperty::LOCAL_NAME[] =          UNICODE_LITERAL_18(E,n,c,r,y,p,t,i,o,n,P,r,o,p,e,r,t,y);
 722 const XMLCh EncryptionProperty::TYPE_NAME[] =           UNICODE_LITERAL_22(E,n,c,r,y,p,t,i,o,n,P,r,o,p,e,r,t,y,T,y,p,e);
 723 const XMLCh EncryptionProperty::ID_ATTRIB_NAME[] =      UNICODE_LITERAL_2(I,d);
 724 const XMLCh EncryptionProperty::TARGET_ATTRIB_NAME[] =  UNICODE_LITERAL_6(T,a,r,g,e,t);
 725 const XMLCh KeyReference::LOCAL_NAME[] =                UNICODE_LITERAL_12(K,e,y,R,e,f,e,r,e,n,c,e);
 726 const XMLCh KeySize::LOCAL_NAME[] =                     UNICODE_LITERAL_7(K,e,y,S,i,z,e);
 727 const XMLCh OAEPparams::LOCAL_NAME[] =                  UNICODE_LITERAL_10(O,A,E,P,p,a,r,a,m,s);
 728 const XMLCh ReferenceList::LOCAL_NAME[] =               UNICODE_LITERAL_13(R,e,f,e,r,e,n,c,e,L,i,s,t);
 729 const XMLCh ReferenceType::LOCAL_NAME[] =               {chNull};
 730 const XMLCh ReferenceType::TYPE_NAME[] =                UNICODE_LITERAL_13(R,e,f,e,r,e,n,c,e,T,y,p,e);
 731 const XMLCh ReferenceType::URI_ATTRIB_NAME[] =          UNICODE_LITERAL_3(U,R,I);
 732 const XMLCh Transforms::LOCAL_NAME[] =                  UNICODE_LITERAL_10(T,r,a,n,s,f,o,r,m,s);
 733 const XMLCh Transforms::TYPE_NAME[] =                   UNICODE_LITERAL_14(T,r,a,n,s,f,o,r,m,s,T,y,p,e);