xmltooling/encryption/impl/EncryptionImpl.cpp

   1 /*
   2  *  Copyright 2001-2010 Internet2
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * EncryptionImpl.cpp
  19  *
  20  * Implementation classes for XML Encryption schema.
  21  */
  22
  23 #include "internal.h"
  24 #include "AbstractAttributeExtensibleXMLObject.h"
  25 #include "AbstractComplexElement.h"
  26 #include "AbstractSimpleElement.h"
  27 #include "exceptions.h"
  28 #include "encryption/Encryption.h"
  29 #include "io/AbstractXMLObjectMarshaller.h"
  30 #include "io/AbstractXMLObjectUnmarshaller.h"
  31 #include "signature/KeyInfo.h"
  32 #include "util/XMLHelper.h"
  33
  34 #include <xercesc/util/XMLUniDefs.hpp>
  35
  36 using namespace xmlencryption;
  37 using namespace xmltooling;
  38 using namespace xercesc;
  39 using namespace std;
  40 using xmlconstants::XMLENC_NS;
  41 using xmlconstants::XMLSIG_NS;
  42
  43 #if defined (_MSC_VER)
  44     #pragma warning( push )
  45     #pragma warning( disable : 4250 4251 )
  46 #endif
  47
  48 namespace xmlencryption {
  49
  50     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,CarriedKeyName);
  51     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,CipherValue);
  52     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,KeySize);
  53     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,OAEPparams);
  54
  55     class XMLTOOL_DLLLOCAL EncryptionMethodImpl : public virtual EncryptionMethod,
  56         public AbstractComplexElement,
  57         public AbstractDOMCachingXMLObject,
  58         public AbstractXMLObjectMarshaller,
  59         public AbstractXMLObjectUnmarshaller
  60     {
  61         void init() {
  62             m_Algorithm=nullptr;
  63             m_KeySize=nullptr;
  64             m_OAEPparams=nullptr;
  65             m_children.push_back(nullptr);
  66             m_children.push_back(nullptr);
  67             m_pos_KeySize=m_children.begin();
  68             m_pos_OAEPparams=m_pos_KeySize;
  69             ++m_pos_OAEPparams;
  70         }
  71     public:
  72         virtual ~EncryptionMethodImpl() {
  73             XMLString::release(&m_Algorithm);
  74         }
  75
  76         EncryptionMethodImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
  77                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
  78             init();
  79         }
  80
  81         EncryptionMethodImpl(const EncryptionMethodImpl& src)
  82                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
  83             init();
  84             setAlgorithm(src.getAlgorithm());
  85             if (src.getKeySize())
  86                 setKeySize(src.getKeySize()->cloneKeySize());
  87             if (src.getOAEPparams())
  88                 setOAEPparams(src.getOAEPparams()->cloneOAEPparams());
  89             VectorOf(XMLObject) v=getUnknownXMLObjects();
  90             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
  91                 v.push_back((*i)->clone());
  92         }
  93
  94         IMPL_XMLOBJECT_CLONE(EncryptionMethod);
  95         IMPL_STRING_ATTRIB(Algorithm);
  96         IMPL_TYPED_CHILD(KeySize);
  97         IMPL_TYPED_CHILD(OAEPparams);
  98         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
  99
 100     protected:
 101         void marshallAttributes(DOMElement* domElement) const {
 102             MARSHALL_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 103         }
 104
 105         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 106             PROC_TYPED_CHILD(KeySize,XMLENC_NS,false);
 107             PROC_TYPED_CHILD(OAEPparams,XMLENC_NS,false);
 108
 109             // Unknown child.
 110             const XMLCh* nsURI=root->getNamespaceURI();
 111             if (!XMLString::equals(nsURI,XMLENC_NS) && nsURI && *nsURI) {
 112                 getUnknownXMLObjects().push_back(childXMLObject);
 113                 return;
 114             }
 115
 116             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 117         }
 118
 119         void processAttribute(const DOMAttr* attribute) {
 120             PROC_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 121             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 122         }
 123     };
 124
 125     class XMLTOOL_DLLLOCAL TransformsImpl : public virtual Transforms,
 126         public AbstractComplexElement,
 127         public AbstractDOMCachingXMLObject,
 128         public AbstractXMLObjectMarshaller,
 129         public AbstractXMLObjectUnmarshaller
 130     {
 131     public:
 132         virtual ~TransformsImpl() {}
 133
 134         TransformsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 135             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 136         }
 137
 138         TransformsImpl(const TransformsImpl& src)
 139                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 140             VectorOf(xmlsignature::Transform) v=getTransforms();
 141             for (vector<xmlsignature::Transform*>::const_iterator i=src.m_Transforms.begin(); i!=src.m_Transforms.end(); i++) {
 142                 if (*i) {
 143                     v.push_back((*i)->cloneTransform());
 144                 }
 145             }
 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     public:
 171         virtual ~CipherReferenceImpl() {
 172             XMLString::release(&m_URI);
 173         }
 174
 175         CipherReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 176                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 177             init();
 178         }
 179
 180         CipherReferenceImpl(const CipherReferenceImpl& src)
 181                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 182             init();
 183             setURI(src.getURI());
 184             if (src.getTransforms())
 185                 setTransforms(src.getTransforms()->cloneTransforms());
 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     public:
 224         virtual ~CipherDataImpl() {}
 225
 226         CipherDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 227                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 228             init();
 229         }
 230
 231         CipherDataImpl(const CipherDataImpl& src)
 232                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 233             init();
 234             if (src.getCipherValue())
 235                 setCipherValue(src.getCipherValue()->cloneCipherValue());
 236             if (src.getCipherReference())
 237                 setCipherReference(src.getCipherReference()->cloneCipherReference());
 238         }
 239
 240         IMPL_XMLOBJECT_CLONE(CipherData);
 241         IMPL_TYPED_CHILD(CipherValue);
 242         IMPL_TYPED_CHILD(CipherReference);
 243
 244     protected:
 245         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 246             PROC_TYPED_CHILD(CipherValue,XMLENC_NS,false);
 247             PROC_TYPED_CHILD(CipherReference,XMLENC_NS,false);
 248             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 249         }
 250     };
 251
 252     class XMLTOOL_DLLLOCAL EncryptionPropertyImpl : public virtual EncryptionProperty,
 253         public AbstractAttributeExtensibleXMLObject,
 254         public AbstractComplexElement,
 255         public AbstractDOMCachingXMLObject,
 256         public AbstractXMLObjectMarshaller,
 257         public AbstractXMLObjectUnmarshaller
 258     {
 259         void init() {
 260             m_Id=m_Target=nullptr;
 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             setId(src.getId());
 280             setTarget(src.getTarget());
 281             VectorOf(XMLObject) v=getUnknownXMLObjects();
 282             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 283                 v.push_back((*i)->clone());
 284         }
 285
 286         IMPL_XMLOBJECT_CLONE(EncryptionProperty);
 287         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 288         IMPL_STRING_ATTRIB(Target);
 289         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject, m_children.end());
 290
 291         void setAttribute(const xmltooling::QName& qualifiedName, const XMLCh* value, bool ID=false) {
 292             if (!qualifiedName.hasNamespaceURI()) {
 293                 if (XMLString::equals(qualifiedName.getLocalPart(),ID_ATTRIB_NAME)) {
 294                     setId(value);
 295                     return;
 296                 }
 297                 else if (XMLString::equals(qualifiedName.getLocalPart(),TARGET_ATTRIB_NAME)) {
 298                     setTarget(value);
 299                     return;
 300                 }
 301             }
 302             AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value, ID);
 303         }
 304
 305     protected:
 306         void marshallAttributes(DOMElement* domElement) const {
 307             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 308             MARSHALL_STRING_ATTRIB(Target,TARGET,nullptr);
 309             marshallExtensionAttributes(domElement);
 310         }
 311
 312         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 313             getUnknownXMLObjects().push_back(childXMLObject);
 314         }
 315
 316         void processAttribute(const DOMAttr* attribute) {
 317             PROC_ID_ATTRIB(Id,ID,nullptr);
 318             unmarshallExtensionAttribute(attribute);
 319         }
 320     };
 321
 322     class XMLTOOL_DLLLOCAL EncryptionPropertiesImpl : public virtual EncryptionProperties,
 323         public AbstractComplexElement,
 324         public AbstractDOMCachingXMLObject,
 325         public AbstractXMLObjectMarshaller,
 326         public AbstractXMLObjectUnmarshaller
 327     {
 328         void init() {
 329             m_Id=nullptr;
 330         }
 331     public:
 332         virtual ~EncryptionPropertiesImpl() {
 333             XMLString::release(&m_Id);
 334         }
 335
 336         EncryptionPropertiesImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 337             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 338             init();
 339         }
 340
 341         EncryptionPropertiesImpl(const EncryptionPropertiesImpl& src)
 342                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 343             init();
 344             setId(src.getId());
 345             VectorOf(EncryptionProperty) v=getEncryptionPropertys();
 346             for (vector<EncryptionProperty*>::const_iterator i=src.m_EncryptionPropertys.begin(); i!=src.m_EncryptionPropertys.end(); i++) {
 347                 if (*i) {
 348                     v.push_back((*i)->cloneEncryptionProperty());
 349                 }
 350             }
 351         }
 352
 353         IMPL_XMLOBJECT_CLONE(EncryptionProperties);
 354         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 355         IMPL_TYPED_CHILDREN(EncryptionProperty,m_children.end());
 356
 357     protected:
 358         void marshallAttributes(DOMElement* domElement) const {
 359             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 360         }
 361
 362         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 363             PROC_TYPED_CHILDREN(EncryptionProperty,XMLENC_NS,false);
 364             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 365         }
 366
 367         void processAttribute(const DOMAttr* attribute) {
 368             PROC_ID_ATTRIB(Id,ID,nullptr);
 369             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 370         }
 371     };
 372
 373     class XMLTOOL_DLLLOCAL ReferenceTypeImpl : public virtual ReferenceType,
 374         public AbstractComplexElement,
 375         public AbstractDOMCachingXMLObject,
 376         public AbstractXMLObjectMarshaller,
 377         public AbstractXMLObjectUnmarshaller
 378     {
 379         void init() {
 380             m_URI=nullptr;
 381         }
 382
 383     protected:
 384         ReferenceTypeImpl() {
 385             init();
 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             init();
 396         }
 397
 398         ReferenceTypeImpl(const ReferenceTypeImpl& src)
 399                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 400             init();
 401             setURI(src.getURI());
 402             VectorOf(XMLObject) v=getUnknownXMLObjects();
 403             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 404                 v.push_back((*i)->clone());
 405         }
 406
 407         IMPL_XMLOBJECT_CLONE(ReferenceType);
 408         IMPL_STRING_ATTRIB(URI);
 409         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 410
 411     protected:
 412         void marshallAttributes(DOMElement* domElement) const {
 413             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 414         }
 415
 416         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 417             getUnknownXMLObjects().push_back(childXMLObject);
 418         }
 419
 420         void processAttribute(const DOMAttr* attribute) {
 421             PROC_STRING_ATTRIB(URI,URI,nullptr);
 422             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 423         }
 424     };
 425
 426     class XMLTOOL_DLLLOCAL DataReferenceImpl : public virtual DataReference, public ReferenceTypeImpl
 427     {
 428     public:
 429         virtual ~DataReferenceImpl() {}
 430
 431         DataReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 432             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 433
 434         DataReferenceImpl(const DataReferenceImpl& src) : AbstractXMLObject(src), ReferenceTypeImpl(src) {}
 435
 436         IMPL_XMLOBJECT_CLONE(DataReference);
 437         ReferenceType* cloneReferenceType() const {
 438             return new DataReferenceImpl(*this);
 439         }
 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(KeyReference);
 453         ReferenceType* cloneReferenceType() const {
 454             return new KeyReferenceImpl(*this);
 455         }
 456     };
 457
 458     class XMLTOOL_DLLLOCAL ReferenceListImpl : public virtual ReferenceList,
 459         public AbstractComplexElement,
 460         public AbstractDOMCachingXMLObject,
 461         public AbstractXMLObjectMarshaller,
 462         public AbstractXMLObjectUnmarshaller
 463     {
 464     public:
 465         virtual ~ReferenceListImpl() {}
 466
 467         ReferenceListImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 468             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 469         }
 470
 471         ReferenceListImpl(const ReferenceListImpl& src)
 472                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 473             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 474                 if (*i) {
 475                     DataReference* data=dynamic_cast<DataReference*>(*i);
 476                     if (data) {
 477                         getDataReferences().push_back(data->cloneDataReference());
 478                         continue;
 479                     }
 480
 481                     KeyReference* key=dynamic_cast<KeyReference*>(*i);
 482                     if (key) {
 483                         getKeyReferences().push_back(key->cloneKeyReference());
 484                         continue;
 485                     }
 486                 }
 487             }
 488         }
 489
 490         IMPL_XMLOBJECT_CLONE(ReferenceList);
 491         IMPL_TYPED_CHILDREN(DataReference,m_children.end());
 492         IMPL_TYPED_CHILDREN(KeyReference,m_children.end());
 493
 494     protected:
 495         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 496             PROC_TYPED_CHILDREN(DataReference,XMLENC_NS,false);
 497             PROC_TYPED_CHILDREN(KeyReference,XMLENC_NS,false);
 498             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 499         }
 500     };
 501
 502     class XMLTOOL_DLLLOCAL EncryptedTypeImpl : public virtual EncryptedType,
 503         public AbstractComplexElement,
 504         public AbstractDOMCachingXMLObject,
 505         public AbstractXMLObjectMarshaller,
 506         public AbstractXMLObjectUnmarshaller
 507     {
 508         void init() {
 509             m_Id=m_Type=m_MimeType=m_Encoding=nullptr;
 510             m_EncryptionMethod=nullptr;
 511             m_KeyInfo=nullptr;
 512             m_CipherData=nullptr;
 513             m_EncryptionProperties=nullptr;
 514             m_children.push_back(nullptr);
 515             m_children.push_back(nullptr);
 516             m_children.push_back(nullptr);
 517             m_children.push_back(nullptr);
 518             m_pos_EncryptionMethod=m_children.begin();
 519             m_pos_KeyInfo=m_pos_EncryptionMethod;
 520             ++m_pos_KeyInfo;
 521             m_pos_CipherData=m_pos_KeyInfo;
 522             ++m_pos_CipherData;
 523             m_pos_EncryptionProperties=m_pos_CipherData;
 524             ++m_pos_EncryptionProperties;
 525         }
 526     protected:
 527         EncryptedTypeImpl() {
 528             init();
 529         }
 530
 531     public:
 532         virtual ~EncryptedTypeImpl() {
 533             XMLString::release(&m_Id);
 534             XMLString::release(&m_Type);
 535             XMLString::release(&m_MimeType);
 536             XMLString::release(&m_Encoding);
 537         }
 538
 539         EncryptedTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 540                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 541             init();
 542         }
 543
 544         EncryptedTypeImpl(const EncryptedTypeImpl& src)
 545                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 546             init();
 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(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(EncryptedData);
 607         EncryptedType* cloneEncryptedType() const {
 608             return new EncryptedDataImpl(*this);
 609         }
 610     };
 611
 612     class XMLTOOL_DLLLOCAL EncryptedKeyImpl : public virtual EncryptedKey, public EncryptedTypeImpl
 613     {
 614         void init() {
 615             m_Recipient=nullptr;
 616             m_ReferenceList=nullptr;
 617             m_CarriedKeyName=nullptr;
 618             m_children.push_back(nullptr);
 619             m_children.push_back(nullptr);
 620             m_pos_ReferenceList=m_pos_EncryptionProperties;
 621             ++m_pos_ReferenceList;
 622             m_pos_CarriedKeyName=m_pos_ReferenceList;
 623             ++m_pos_CarriedKeyName;
 624         }
 625
 626     public:
 627         virtual ~EncryptedKeyImpl() {
 628             XMLString::release(&m_Recipient);
 629         }
 630
 631         EncryptedKeyImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 632                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 633             init();
 634         }
 635
 636         EncryptedKeyImpl(const EncryptedKeyImpl& src) : AbstractXMLObject(src), EncryptedTypeImpl(src) {
 637             init();
 638         }
 639
 640         IMPL_XMLOBJECT_CLONE(EncryptedKey);
 641         EncryptedType* cloneEncryptedType() const {
 642             return new EncryptedKeyImpl(*this);
 643         }
 644         IMPL_STRING_ATTRIB(Recipient);
 645         IMPL_TYPED_CHILD(ReferenceList);
 646         IMPL_TYPED_CHILD(CarriedKeyName);
 647
 648     protected:
 649         void marshallAttributes(DOMElement* domElement) const {
 650             MARSHALL_STRING_ATTRIB(Recipient,RECIPIENT,nullptr);
 651             EncryptedTypeImpl::marshallAttributes(domElement);
 652         }
 653
 654         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 655             PROC_TYPED_CHILD(ReferenceList,XMLENC_NS,false);
 656             PROC_TYPED_CHILD(CarriedKeyName,XMLENC_NS,false);
 657             EncryptedTypeImpl::processChildElement(childXMLObject,root);
 658         }
 659
 660         void processAttribute(const DOMAttr* attribute) {
 661             PROC_STRING_ATTRIB(Recipient,RECIPIENT,nullptr);
 662             EncryptedTypeImpl::processAttribute(attribute);
 663         }
 664     };
 665
 666 };
 667
 668 #if defined (_MSC_VER)
 669     #pragma warning( pop )
 670 #endif
 671
 672 // Builder Implementations
 673
 674 IMPL_XMLOBJECTBUILDER(CarriedKeyName);
 675 IMPL_XMLOBJECTBUILDER(CipherData);
 676 IMPL_XMLOBJECTBUILDER(CipherReference);
 677 IMPL_XMLOBJECTBUILDER(CipherValue);
 678 IMPL_XMLOBJECTBUILDER(DataReference);
 679 IMPL_XMLOBJECTBUILDER(EncryptedData);
 680 IMPL_XMLOBJECTBUILDER(EncryptedKey);
 681 IMPL_XMLOBJECTBUILDER(EncryptionMethod);
 682 IMPL_XMLOBJECTBUILDER(EncryptionProperties);
 683 IMPL_XMLOBJECTBUILDER(EncryptionProperty);
 684 IMPL_XMLOBJECTBUILDER(KeyReference);
 685 IMPL_XMLOBJECTBUILDER(KeySize);
 686 IMPL_XMLOBJECTBUILDER(OAEPparams);
 687 IMPL_XMLOBJECTBUILDER(ReferenceList);
 688 IMPL_XMLOBJECTBUILDER(Transforms);
 689
 690 // Unicode literals
 691
 692 const XMLCh CarriedKeyName::LOCAL_NAME[] =              UNICODE_LITERAL_14(C,a,r,r,i,e,d,K,e,y,N,a,m,e);
 693 const XMLCh CipherData::LOCAL_NAME[] =                  UNICODE_LITERAL_10(C,i,p,h,e,r,D,a,t,a);
 694 const XMLCh CipherData::TYPE_NAME[] =                   UNICODE_LITERAL_14(C,i,p,h,e,r,D,a,t,a,T,y,p,e);
 695 const XMLCh CipherReference::LOCAL_NAME[] =             UNICODE_LITERAL_15(C,i,p,h,e,r,R,e,f,e,r,e,n,c,e);
 696 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);
 697 const XMLCh CipherReference::URI_ATTRIB_NAME[] =        UNICODE_LITERAL_3(U,R,I);
 698 const XMLCh CipherValue::LOCAL_NAME[] =                 UNICODE_LITERAL_11(C,i,p,h,e,r,V,a,l,u,e);
 699 const XMLCh DataReference::LOCAL_NAME[] =               UNICODE_LITERAL_13(D,a,t,a,R,e,f,e,r,e,n,c,e);
 700 const XMLCh EncryptedData::LOCAL_NAME[] =               UNICODE_LITERAL_13(E,n,c,r,y,p,t,e,d,D,a,t,a);
 701 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);
 702 const XMLCh EncryptedKey::LOCAL_NAME[] =                UNICODE_LITERAL_12(E,n,c,r,y,p,t,e,d,K,e,y);
 703 const XMLCh EncryptedKey::TYPE_NAME[] =                 UNICODE_LITERAL_16(E,n,c,r,y,p,t,e,d,K,e,y,T,y,p,e);
 704 const XMLCh EncryptedKey::RECIPIENT_ATTRIB_NAME[] =     UNICODE_LITERAL_9(R,e,c,i,p,i,e,n,t);
 705 const XMLCh EncryptedType::LOCAL_NAME[] =               {chNull};
 706 const XMLCh EncryptedType::TYPE_NAME[] =                UNICODE_LITERAL_13(E,n,c,r,y,p,t,e,d,T,y,p,e);
 707 const XMLCh EncryptedType::ID_ATTRIB_NAME[] =           UNICODE_LITERAL_2(I,d);
 708 const XMLCh EncryptedType::TYPE_ATTRIB_NAME[] =         UNICODE_LITERAL_4(T,y,p,e);
 709 const XMLCh EncryptedType::MIMETYPE_ATTRIB_NAME[] =     UNICODE_LITERAL_8(M,i,m,e,T,y,p,e);
 710 const XMLCh EncryptedType::ENCODING_ATTRIB_NAME[] =     UNICODE_LITERAL_8(E,n,c,o,d,i,n,g);
 711 const XMLCh EncryptionMethod::LOCAL_NAME[] =            UNICODE_LITERAL_16(E,n,c,r,y,p,t,i,o,n,M,e,t,h,o,d);
 712 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);
 713 const XMLCh EncryptionMethod::ALGORITHM_ATTRIB_NAME[] = UNICODE_LITERAL_9(A,l,g,o,r,i,t,h,m);
 714 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);
 715 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);
 716 const XMLCh EncryptionProperties::ID_ATTRIB_NAME[] =    UNICODE_LITERAL_2(I,d);
 717 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);
 718 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);
 719 const XMLCh EncryptionProperty::ID_ATTRIB_NAME[] =      UNICODE_LITERAL_2(I,d);
 720 const XMLCh EncryptionProperty::TARGET_ATTRIB_NAME[] =  UNICODE_LITERAL_6(T,a,r,g,e,t);
 721 const XMLCh KeyReference::LOCAL_NAME[] =                UNICODE_LITERAL_12(K,e,y,R,e,f,e,r,e,n,c,e);
 722 const XMLCh KeySize::LOCAL_NAME[] =                     UNICODE_LITERAL_7(K,e,y,S,i,z,e);
 723 const XMLCh OAEPparams::LOCAL_NAME[] =                  UNICODE_LITERAL_10(O,A,E,P,p,a,r,a,m,s);
 724 const XMLCh ReferenceList::LOCAL_NAME[] =               UNICODE_LITERAL_13(R,e,f,e,r,e,n,c,e,L,i,s,t);
 725 const XMLCh ReferenceType::LOCAL_NAME[] =               {chNull};
 726 const XMLCh ReferenceType::TYPE_NAME[] =                UNICODE_LITERAL_13(R,e,f,e,r,e,n,c,e,T,y,p,e);
 727 const XMLCh ReferenceType::URI_ATTRIB_NAME[] =          UNICODE_LITERAL_3(U,R,I);
 728 const XMLCh Transforms::LOCAL_NAME[] =                  UNICODE_LITERAL_10(T,r,a,n,s,f,o,r,m,s);
 729 const XMLCh Transforms::TYPE_NAME[] =                   UNICODE_LITERAL_14(T,r,a,n,s,f,o,r,m,s,T,y,p,e);