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