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.
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
24 * Implementation classes for XML Encryption schema.
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"
38 #include <xercesc/util/XMLUniDefs.hpp>
40 using namespace xmlencryption;
41 using namespace xmltooling;
42 using namespace xercesc;
44 using xmlconstants::XMLENC_NS;
45 using xmlconstants::XMLSIG_NS;
47 #if defined (_MSC_VER)
48 #pragma warning( push )
49 #pragma warning( disable : 4250 4251 )
52 namespace xmlencryption {
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);
59 class XMLTOOL_DLLLOCAL EncryptionMethodImpl : public virtual EncryptionMethod,
60 public AbstractComplexElement,
61 public AbstractDOMCachingXMLObject,
62 public AbstractXMLObjectMarshaller,
63 public AbstractXMLObjectUnmarshaller
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;
76 virtual ~EncryptionMethodImpl() {
77 XMLString::release(&m_Algorithm);
80 EncryptionMethodImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
81 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
85 EncryptionMethodImpl(const EncryptionMethodImpl& src)
86 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
88 setAlgorithm(src.getAlgorithm());
90 setKeySize(src.getKeySize()->cloneKeySize());
91 if (src.getOAEPparams())
92 setOAEPparams(src.getOAEPparams()->cloneOAEPparams());
93 VectorOf(XMLObject) v=getUnknownXMLObjects();
94 for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
95 v.push_back((*i)->clone());
98 IMPL_XMLOBJECT_CLONE(EncryptionMethod);
99 IMPL_STRING_ATTRIB(Algorithm);
100 IMPL_TYPED_CHILD(KeySize);
101 IMPL_TYPED_CHILD(OAEPparams);
102 IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
105 void marshallAttributes(DOMElement* domElement) const {
106 MARSHALL_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
109 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
110 PROC_TYPED_CHILD(KeySize,XMLENC_NS,false);
111 PROC_TYPED_CHILD(OAEPparams,XMLENC_NS,false);
114 const XMLCh* nsURI=root->getNamespaceURI();
115 if (!XMLString::equals(nsURI,XMLENC_NS) && nsURI && *nsURI) {
116 getUnknownXMLObjects().push_back(childXMLObject);
120 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
123 void processAttribute(const DOMAttr* attribute) {
124 PROC_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
125 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
129 class XMLTOOL_DLLLOCAL TransformsImpl : public virtual Transforms,
130 public AbstractComplexElement,
131 public AbstractDOMCachingXMLObject,
132 public AbstractXMLObjectMarshaller,
133 public AbstractXMLObjectUnmarshaller
136 virtual ~TransformsImpl() {}
138 TransformsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
139 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
142 TransformsImpl(const TransformsImpl& src)
143 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
144 VectorOf(xmlsignature::Transform) v=getTransforms();
145 for (vector<xmlsignature::Transform*>::const_iterator i=src.m_Transforms.begin(); i!=src.m_Transforms.end(); i++) {
147 v.push_back((*i)->cloneTransform());
152 IMPL_XMLOBJECT_CLONE(Transforms);
153 IMPL_TYPED_FOREIGN_CHILDREN(Transform,xmlsignature,m_children.end());
156 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
157 PROC_TYPED_FOREIGN_CHILDREN(Transform,xmlsignature,XMLSIG_NS,false);
158 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
162 class XMLTOOL_DLLLOCAL CipherReferenceImpl : public virtual CipherReference,
163 public AbstractComplexElement,
164 public AbstractDOMCachingXMLObject,
165 public AbstractXMLObjectMarshaller,
166 public AbstractXMLObjectUnmarshaller
170 m_Transforms=nullptr;
171 m_children.push_back(nullptr);
172 m_pos_Transforms=m_children.begin();
175 virtual ~CipherReferenceImpl() {
176 XMLString::release(&m_URI);
179 CipherReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
180 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
184 CipherReferenceImpl(const CipherReferenceImpl& src)
185 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
187 setURI(src.getURI());
188 if (src.getTransforms())
189 setTransforms(src.getTransforms()->cloneTransforms());
192 IMPL_XMLOBJECT_CLONE(CipherReference);
193 IMPL_STRING_ATTRIB(URI);
194 IMPL_TYPED_CHILD(Transforms);
197 void marshallAttributes(DOMElement* domElement) const {
198 MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
201 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
202 PROC_TYPED_CHILD(Transforms,XMLENC_NS,false);
203 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
206 void processAttribute(const DOMAttr* attribute) {
207 PROC_STRING_ATTRIB(URI,URI,nullptr);
208 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
212 class XMLTOOL_DLLLOCAL CipherDataImpl : public virtual CipherData,
213 public AbstractComplexElement,
214 public AbstractDOMCachingXMLObject,
215 public AbstractXMLObjectMarshaller,
216 public AbstractXMLObjectUnmarshaller
219 m_CipherValue=nullptr;
220 m_CipherReference=nullptr;
221 m_children.push_back(nullptr);
222 m_children.push_back(nullptr);
223 m_pos_CipherValue=m_children.begin();
224 m_pos_CipherReference=m_pos_CipherValue;
225 ++m_pos_CipherReference;
228 virtual ~CipherDataImpl() {}
230 CipherDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
231 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
235 CipherDataImpl(const CipherDataImpl& src)
236 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
238 if (src.getCipherValue())
239 setCipherValue(src.getCipherValue()->cloneCipherValue());
240 if (src.getCipherReference())
241 setCipherReference(src.getCipherReference()->cloneCipherReference());
244 IMPL_XMLOBJECT_CLONE(CipherData);
245 IMPL_TYPED_CHILD(CipherValue);
246 IMPL_TYPED_CHILD(CipherReference);
249 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
250 PROC_TYPED_CHILD(CipherValue,XMLENC_NS,false);
251 PROC_TYPED_CHILD(CipherReference,XMLENC_NS,false);
252 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
256 class XMLTOOL_DLLLOCAL EncryptionPropertyImpl : public virtual EncryptionProperty,
257 public AbstractAttributeExtensibleXMLObject,
258 public AbstractComplexElement,
259 public AbstractDOMCachingXMLObject,
260 public AbstractXMLObjectMarshaller,
261 public AbstractXMLObjectUnmarshaller
264 m_Id=m_Target=nullptr;
267 virtual ~EncryptionPropertyImpl() {
268 XMLString::release(&m_Id);
269 XMLString::release(&m_Target);
272 EncryptionPropertyImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
273 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
277 EncryptionPropertyImpl(const EncryptionPropertyImpl& src)
278 : AbstractXMLObject(src),
279 AbstractAttributeExtensibleXMLObject(src),
280 AbstractComplexElement(src),
281 AbstractDOMCachingXMLObject(src) {
284 setTarget(src.getTarget());
285 VectorOf(XMLObject) v=getUnknownXMLObjects();
286 for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
287 v.push_back((*i)->clone());
290 IMPL_XMLOBJECT_CLONE(EncryptionProperty);
291 IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
292 IMPL_STRING_ATTRIB(Target);
293 IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject, m_children.end());
295 void setAttribute(const xmltooling::QName& qualifiedName, const XMLCh* value, bool ID=false) {
296 if (!qualifiedName.hasNamespaceURI()) {
297 if (XMLString::equals(qualifiedName.getLocalPart(),ID_ATTRIB_NAME)) {
301 else if (XMLString::equals(qualifiedName.getLocalPart(),TARGET_ATTRIB_NAME)) {
306 AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value, ID);
310 void marshallAttributes(DOMElement* domElement) const {
311 MARSHALL_ID_ATTRIB(Id,ID,nullptr);
312 MARSHALL_STRING_ATTRIB(Target,TARGET,nullptr);
313 marshallExtensionAttributes(domElement);
316 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
317 getUnknownXMLObjects().push_back(childXMLObject);
320 void processAttribute(const DOMAttr* attribute) {
321 PROC_ID_ATTRIB(Id,ID,nullptr);
322 unmarshallExtensionAttribute(attribute);
326 class XMLTOOL_DLLLOCAL EncryptionPropertiesImpl : public virtual EncryptionProperties,
327 public AbstractComplexElement,
328 public AbstractDOMCachingXMLObject,
329 public AbstractXMLObjectMarshaller,
330 public AbstractXMLObjectUnmarshaller
336 virtual ~EncryptionPropertiesImpl() {
337 XMLString::release(&m_Id);
340 EncryptionPropertiesImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
341 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
345 EncryptionPropertiesImpl(const EncryptionPropertiesImpl& src)
346 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
349 VectorOf(EncryptionProperty) v=getEncryptionPropertys();
350 for (vector<EncryptionProperty*>::const_iterator i=src.m_EncryptionPropertys.begin(); i!=src.m_EncryptionPropertys.end(); i++) {
352 v.push_back((*i)->cloneEncryptionProperty());
357 IMPL_XMLOBJECT_CLONE(EncryptionProperties);
358 IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
359 IMPL_TYPED_CHILDREN(EncryptionProperty,m_children.end());
362 void marshallAttributes(DOMElement* domElement) const {
363 MARSHALL_ID_ATTRIB(Id,ID,nullptr);
366 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
367 PROC_TYPED_CHILDREN(EncryptionProperty,XMLENC_NS,false);
368 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
371 void processAttribute(const DOMAttr* attribute) {
372 PROC_ID_ATTRIB(Id,ID,nullptr);
373 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
377 class XMLTOOL_DLLLOCAL ReferenceTypeImpl : public virtual ReferenceType,
378 public AbstractComplexElement,
379 public AbstractDOMCachingXMLObject,
380 public AbstractXMLObjectMarshaller,
381 public AbstractXMLObjectUnmarshaller
388 ReferenceTypeImpl() {
393 virtual ~ReferenceTypeImpl() {
394 XMLString::release(&m_URI);
397 ReferenceTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
398 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
402 ReferenceTypeImpl(const ReferenceTypeImpl& src)
403 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
405 setURI(src.getURI());
406 VectorOf(XMLObject) v=getUnknownXMLObjects();
407 for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
408 v.push_back((*i)->clone());
411 IMPL_XMLOBJECT_CLONE(ReferenceType);
412 IMPL_STRING_ATTRIB(URI);
413 IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
416 void marshallAttributes(DOMElement* domElement) const {
417 MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
420 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
421 getUnknownXMLObjects().push_back(childXMLObject);
424 void processAttribute(const DOMAttr* attribute) {
425 PROC_STRING_ATTRIB(URI,URI,nullptr);
426 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
430 class XMLTOOL_DLLLOCAL DataReferenceImpl : public virtual DataReference, public ReferenceTypeImpl
433 virtual ~DataReferenceImpl() {}
435 DataReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
436 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
438 DataReferenceImpl(const DataReferenceImpl& src) : AbstractXMLObject(src), ReferenceTypeImpl(src) {}
440 IMPL_XMLOBJECT_CLONE(DataReference);
441 ReferenceType* cloneReferenceType() const {
442 return new DataReferenceImpl(*this);
446 class XMLTOOL_DLLLOCAL KeyReferenceImpl : public virtual KeyReference, public ReferenceTypeImpl
449 virtual ~KeyReferenceImpl() {}
451 KeyReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
452 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
454 KeyReferenceImpl(const KeyReferenceImpl& src) : AbstractXMLObject(src), ReferenceTypeImpl(src) {}
456 IMPL_XMLOBJECT_CLONE(KeyReference);
457 ReferenceType* cloneReferenceType() const {
458 return new KeyReferenceImpl(*this);
462 class XMLTOOL_DLLLOCAL ReferenceListImpl : public virtual ReferenceList,
463 public AbstractComplexElement,
464 public AbstractDOMCachingXMLObject,
465 public AbstractXMLObjectMarshaller,
466 public AbstractXMLObjectUnmarshaller
469 virtual ~ReferenceListImpl() {}
471 ReferenceListImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
472 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
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++) {
479 DataReference* data=dynamic_cast<DataReference*>(*i);
481 getDataReferences().push_back(data->cloneDataReference());
485 KeyReference* key=dynamic_cast<KeyReference*>(*i);
487 getKeyReferences().push_back(key->cloneKeyReference());
494 IMPL_XMLOBJECT_CLONE(ReferenceList);
495 IMPL_TYPED_CHILDREN(DataReference,m_children.end());
496 IMPL_TYPED_CHILDREN(KeyReference,m_children.end());
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);
506 class XMLTOOL_DLLLOCAL EncryptedTypeImpl : public virtual EncryptedType,
507 public AbstractComplexElement,
508 public AbstractDOMCachingXMLObject,
509 public AbstractXMLObjectMarshaller,
510 public AbstractXMLObjectUnmarshaller
513 m_Id=m_Type=m_MimeType=m_Encoding=nullptr;
514 m_EncryptionMethod=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;
525 m_pos_CipherData=m_pos_KeyInfo;
527 m_pos_EncryptionProperties=m_pos_CipherData;
528 ++m_pos_EncryptionProperties;
531 EncryptedTypeImpl() {
536 virtual ~EncryptedTypeImpl() {
537 XMLString::release(&m_Id);
538 XMLString::release(&m_Type);
539 XMLString::release(&m_MimeType);
540 XMLString::release(&m_Encoding);
543 EncryptedTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
544 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
548 EncryptedTypeImpl(const EncryptedTypeImpl& src)
549 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
552 setType(src.getType());
553 setMimeType(src.getMimeType());
554 setEncoding(src.getEncoding());
555 if (src.getEncryptionMethod())
556 setEncryptionMethod(src.getEncryptionMethod()->cloneEncryptionMethod());
557 if (src.getKeyInfo())
558 setKeyInfo(src.getKeyInfo()->cloneKeyInfo());
559 if (src.getCipherData())
560 setCipherData(src.getCipherData()->cloneCipherData());
561 if (src.getEncryptionProperties())
562 setEncryptionProperties(src.getEncryptionProperties()->cloneEncryptionProperties());
565 IMPL_XMLOBJECT_CLONE(EncryptedType);
566 IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
567 IMPL_STRING_ATTRIB(Type);
568 IMPL_STRING_ATTRIB(MimeType);
569 IMPL_STRING_ATTRIB(Encoding);
570 IMPL_TYPED_CHILD(EncryptionMethod);
571 IMPL_TYPED_FOREIGN_CHILD(KeyInfo,xmlsignature);
572 IMPL_TYPED_CHILD(CipherData);
573 IMPL_TYPED_CHILD(EncryptionProperties);
576 void marshallAttributes(DOMElement* domElement) const {
577 MARSHALL_ID_ATTRIB(Id,ID,nullptr);
578 MARSHALL_STRING_ATTRIB(Type,TYPE,nullptr);
579 MARSHALL_STRING_ATTRIB(MimeType,MIMETYPE,nullptr);
580 MARSHALL_STRING_ATTRIB(Encoding,ENCODING,nullptr);
583 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
584 PROC_TYPED_CHILD(EncryptionMethod,XMLENC_NS,false);
585 PROC_TYPED_FOREIGN_CHILD(KeyInfo,xmlsignature,XMLSIG_NS,false);
586 PROC_TYPED_CHILD(CipherData,XMLENC_NS,false);
587 PROC_TYPED_CHILD(EncryptionProperties,XMLENC_NS,false);
588 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
591 void processAttribute(const DOMAttr* attribute) {
592 PROC_ID_ATTRIB(Id,ID,nullptr);
593 PROC_STRING_ATTRIB(Type,TYPE,nullptr);
594 PROC_STRING_ATTRIB(MimeType,MIMETYPE,nullptr);
595 PROC_STRING_ATTRIB(Encoding,ENCODING,nullptr);
596 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
600 class XMLTOOL_DLLLOCAL EncryptedDataImpl : public virtual EncryptedData, public EncryptedTypeImpl
603 virtual ~EncryptedDataImpl() {}
605 EncryptedDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
606 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
608 EncryptedDataImpl(const EncryptedDataImpl& src) : AbstractXMLObject(src), EncryptedTypeImpl(src) {}
610 IMPL_XMLOBJECT_CLONE(EncryptedData);
611 EncryptedType* cloneEncryptedType() const {
612 return new EncryptedDataImpl(*this);
616 class XMLTOOL_DLLLOCAL EncryptedKeyImpl : public virtual EncryptedKey, public EncryptedTypeImpl
620 m_ReferenceList=nullptr;
621 m_CarriedKeyName=nullptr;
622 m_children.push_back(nullptr);
623 m_children.push_back(nullptr);
624 m_pos_ReferenceList=m_pos_EncryptionProperties;
625 ++m_pos_ReferenceList;
626 m_pos_CarriedKeyName=m_pos_ReferenceList;
627 ++m_pos_CarriedKeyName;
631 virtual ~EncryptedKeyImpl() {
632 XMLString::release(&m_Recipient);
635 EncryptedKeyImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
636 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
640 EncryptedKeyImpl(const EncryptedKeyImpl& src) : AbstractXMLObject(src), EncryptedTypeImpl(src) {
644 IMPL_XMLOBJECT_CLONE(EncryptedKey);
645 EncryptedType* cloneEncryptedType() const {
646 return new EncryptedKeyImpl(*this);
648 IMPL_STRING_ATTRIB(Recipient);
649 IMPL_TYPED_CHILD(ReferenceList);
650 IMPL_TYPED_CHILD(CarriedKeyName);
653 void marshallAttributes(DOMElement* domElement) const {
654 MARSHALL_STRING_ATTRIB(Recipient,RECIPIENT,nullptr);
655 EncryptedTypeImpl::marshallAttributes(domElement);
658 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
659 PROC_TYPED_CHILD(ReferenceList,XMLENC_NS,false);
660 PROC_TYPED_CHILD(CarriedKeyName,XMLENC_NS,false);
661 EncryptedTypeImpl::processChildElement(childXMLObject,root);
664 void processAttribute(const DOMAttr* attribute) {
665 PROC_STRING_ATTRIB(Recipient,RECIPIENT,nullptr);
666 EncryptedTypeImpl::processAttribute(attribute);
672 #if defined (_MSC_VER)
673 #pragma warning( pop )
676 // Builder Implementations
678 IMPL_XMLOBJECTBUILDER(CarriedKeyName);
679 IMPL_XMLOBJECTBUILDER(CipherData);
680 IMPL_XMLOBJECTBUILDER(CipherReference);
681 IMPL_XMLOBJECTBUILDER(CipherValue);
682 IMPL_XMLOBJECTBUILDER(DataReference);
683 IMPL_XMLOBJECTBUILDER(EncryptedData);
684 IMPL_XMLOBJECTBUILDER(EncryptedKey);
685 IMPL_XMLOBJECTBUILDER(EncryptionMethod);
686 IMPL_XMLOBJECTBUILDER(EncryptionProperties);
687 IMPL_XMLOBJECTBUILDER(EncryptionProperty);
688 IMPL_XMLOBJECTBUILDER(KeyReference);
689 IMPL_XMLOBJECTBUILDER(KeySize);
690 IMPL_XMLOBJECTBUILDER(OAEPparams);
691 IMPL_XMLOBJECTBUILDER(ReferenceList);
692 IMPL_XMLOBJECTBUILDER(Transforms);
696 const XMLCh CarriedKeyName::LOCAL_NAME[] = UNICODE_LITERAL_14(C,a,r,r,i,e,d,K,e,y,N,a,m,e);
697 const XMLCh CipherData::LOCAL_NAME[] = UNICODE_LITERAL_10(C,i,p,h,e,r,D,a,t,a);
698 const XMLCh CipherData::TYPE_NAME[] = UNICODE_LITERAL_14(C,i,p,h,e,r,D,a,t,a,T,y,p,e);
699 const XMLCh CipherReference::LOCAL_NAME[] = UNICODE_LITERAL_15(C,i,p,h,e,r,R,e,f,e,r,e,n,c,e);
700 const XMLCh CipherReference::TYPE_NAME[] = UNICODE_LITERAL_19(C,i,p,h,e,r,R,e,f,e,r,e,n,c,e,T,y,p,e);
701 const XMLCh CipherReference::URI_ATTRIB_NAME[] = UNICODE_LITERAL_3(U,R,I);
702 const XMLCh CipherValue::LOCAL_NAME[] = UNICODE_LITERAL_11(C,i,p,h,e,r,V,a,l,u,e);
703 const XMLCh DataReference::LOCAL_NAME[] = UNICODE_LITERAL_13(D,a,t,a,R,e,f,e,r,e,n,c,e);
704 const XMLCh EncryptedData::LOCAL_NAME[] = UNICODE_LITERAL_13(E,n,c,r,y,p,t,e,d,D,a,t,a);
705 const XMLCh EncryptedData::TYPE_NAME[] = UNICODE_LITERAL_17(E,n,c,r,y,p,t,e,d,D,a,t,a,T,y,p,e);
706 const XMLCh EncryptedKey::LOCAL_NAME[] = UNICODE_LITERAL_12(E,n,c,r,y,p,t,e,d,K,e,y);
707 const XMLCh EncryptedKey::TYPE_NAME[] = UNICODE_LITERAL_16(E,n,c,r,y,p,t,e,d,K,e,y,T,y,p,e);
708 const XMLCh EncryptedKey::RECIPIENT_ATTRIB_NAME[] = UNICODE_LITERAL_9(R,e,c,i,p,i,e,n,t);
709 const XMLCh EncryptedType::LOCAL_NAME[] = {chNull};
710 const XMLCh EncryptedType::TYPE_NAME[] = UNICODE_LITERAL_13(E,n,c,r,y,p,t,e,d,T,y,p,e);
711 const XMLCh EncryptedType::ID_ATTRIB_NAME[] = UNICODE_LITERAL_2(I,d);
712 const XMLCh EncryptedType::TYPE_ATTRIB_NAME[] = UNICODE_LITERAL_4(T,y,p,e);
713 const XMLCh EncryptedType::MIMETYPE_ATTRIB_NAME[] = UNICODE_LITERAL_8(M,i,m,e,T,y,p,e);
714 const XMLCh EncryptedType::ENCODING_ATTRIB_NAME[] = UNICODE_LITERAL_8(E,n,c,o,d,i,n,g);
715 const XMLCh EncryptionMethod::LOCAL_NAME[] = UNICODE_LITERAL_16(E,n,c,r,y,p,t,i,o,n,M,e,t,h,o,d);
716 const XMLCh EncryptionMethod::TYPE_NAME[] = UNICODE_LITERAL_20(E,n,c,r,y,p,t,i,o,n,M,e,t,h,o,d,T,y,p,e);
717 const XMLCh EncryptionMethod::ALGORITHM_ATTRIB_NAME[] = UNICODE_LITERAL_9(A,l,g,o,r,i,t,h,m);
718 const XMLCh EncryptionProperties::LOCAL_NAME[] = UNICODE_LITERAL_20(E,n,c,r,y,p,t,i,o,n,P,r,o,p,e,r,t,i,e,s);
719 const XMLCh EncryptionProperties::TYPE_NAME[] = UNICODE_LITERAL_24(E,n,c,r,y,p,t,i,o,n,P,r,o,p,e,r,t,i,e,s,T,y,p,e);
720 const XMLCh EncryptionProperties::ID_ATTRIB_NAME[] = UNICODE_LITERAL_2(I,d);
721 const XMLCh EncryptionProperty::LOCAL_NAME[] = UNICODE_LITERAL_18(E,n,c,r,y,p,t,i,o,n,P,r,o,p,e,r,t,y);
722 const XMLCh EncryptionProperty::TYPE_NAME[] = UNICODE_LITERAL_22(E,n,c,r,y,p,t,i,o,n,P,r,o,p,e,r,t,y,T,y,p,e);
723 const XMLCh EncryptionProperty::ID_ATTRIB_NAME[] = UNICODE_LITERAL_2(I,d);
724 const XMLCh EncryptionProperty::TARGET_ATTRIB_NAME[] = UNICODE_LITERAL_6(T,a,r,g,e,t);
725 const XMLCh KeyReference::LOCAL_NAME[] = UNICODE_LITERAL_12(K,e,y,R,e,f,e,r,e,n,c,e);
726 const XMLCh KeySize::LOCAL_NAME[] = UNICODE_LITERAL_7(K,e,y,S,i,z,e);
727 const XMLCh OAEPparams::LOCAL_NAME[] = UNICODE_LITERAL_10(O,A,E,P,p,a,r,a,m,s);
728 const XMLCh ReferenceList::LOCAL_NAME[] = UNICODE_LITERAL_13(R,e,f,e,r,e,n,c,e,L,i,s,t);
729 const XMLCh ReferenceType::LOCAL_NAME[] = {chNull};
730 const XMLCh ReferenceType::TYPE_NAME[] = UNICODE_LITERAL_13(R,e,f,e,r,e,n,c,e,T,y,p,e);
731 const XMLCh ReferenceType::URI_ATTRIB_NAME[] = UNICODE_LITERAL_3(U,R,I);
732 const XMLCh Transforms::LOCAL_NAME[] = UNICODE_LITERAL_10(T,r,a,n,s,f,o,r,m,s);
733 const XMLCh Transforms::TYPE_NAME[] = UNICODE_LITERAL_14(T,r,a,n,s,f,o,r,m,s,T,y,p,e);