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