xmltooling/signature/impl/KeyInfoImpl.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  * KeyInfoImpl.cpp
  23  *
  24  * Implementation classes for KeyInfo schema.
  25  */
  26
  27 #include "internal.h"
  28 #include "AbstractComplexElement.h"
  29 #include "AbstractSimpleElement.h"
  30 #include "exceptions.h"
  31 #include "io/AbstractXMLObjectMarshaller.h"
  32 #include "io/AbstractXMLObjectUnmarshaller.h"
  33 #include "signature/KeyInfo.h"
  34 #include "util/XMLHelper.h"
  35
  36 #include <xercesc/util/XMLUniDefs.hpp>
  37
  38 using namespace xmlsignature;
  39 using namespace xmltooling;
  40 using namespace xercesc;
  41 using namespace std;
  42 using xmlconstants::XMLSIG_NS;
  43 using xmlconstants::XMLSIG11_NS;
  44
  45 #if defined (_MSC_VER)
  46     #pragma warning( push )
  47     #pragma warning( disable : 4250 4251 )
  48 #endif
  49
  50 namespace xmlsignature {
  51
  52     class XMLTOOL_DLLLOCAL DSAKeyValueImpl : public virtual DSAKeyValue,
  53         public AbstractComplexElement,
  54         public AbstractDOMCachingXMLObject,
  55         public AbstractXMLObjectMarshaller,
  56         public AbstractXMLObjectUnmarshaller
  57     {
  58     public:
  59         virtual ~DSAKeyValueImpl() {}
  60
  61         DSAKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
  62             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
  63             init();
  64         }
  65
  66         DSAKeyValueImpl(const DSAKeyValueImpl& src)
  67                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
  68             init();
  69             if (src.getP())
  70                 setP(src.getP()->cloneP());
  71             if (src.getQ())
  72                 setQ(src.getQ()->cloneQ());
  73             if (src.getG())
  74                 setG(src.getG()->cloneG());
  75             if (src.getY())
  76                 setY(src.getY()->cloneY());
  77             if (src.getJ())
  78                 setJ(src.getJ()->cloneJ());
  79             if (src.getSeed())
  80                 setSeed(src.getSeed()->cloneSeed());
  81             if (src.getPgenCounter())
  82                 setPgenCounter(src.getPgenCounter()->clonePgenCounter());
  83         }
  84
  85         void init() {
  86             m_P=nullptr;
  87             m_Q=nullptr;
  88             m_G=nullptr;
  89             m_Y=nullptr;
  90             m_J=nullptr;
  91             m_Seed=nullptr;
  92             m_PgenCounter=nullptr;
  93             m_children.push_back(nullptr);
  94             m_children.push_back(nullptr);
  95             m_children.push_back(nullptr);
  96             m_children.push_back(nullptr);
  97             m_children.push_back(nullptr);
  98             m_children.push_back(nullptr);
  99             m_children.push_back(nullptr);
 100             m_pos_P=m_children.begin();
 101             m_pos_Q=m_pos_P;
 102             ++m_pos_Q;
 103             m_pos_G=m_pos_Q;
 104             ++m_pos_G;
 105             m_pos_Y=m_pos_G;
 106             ++m_pos_Y;
 107             m_pos_J=m_pos_Y;
 108             ++m_pos_J;
 109             m_pos_Seed=m_pos_J;
 110             ++m_pos_Seed;
 111             m_pos_PgenCounter=m_pos_Seed;
 112             ++m_pos_PgenCounter;
 113         }
 114
 115         IMPL_XMLOBJECT_CLONE(DSAKeyValue);
 116         IMPL_TYPED_CHILD(P);
 117         IMPL_TYPED_CHILD(Q);
 118         IMPL_TYPED_CHILD(G);
 119         IMPL_TYPED_CHILD(Y);
 120         IMPL_TYPED_CHILD(J);
 121         IMPL_TYPED_CHILD(Seed);
 122         IMPL_TYPED_CHILD(PgenCounter);
 123
 124     protected:
 125         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 126             PROC_TYPED_CHILD(P,XMLSIG_NS,false);
 127             PROC_TYPED_CHILD(Q,XMLSIG_NS,false);
 128             PROC_TYPED_CHILD(G,XMLSIG_NS,false);
 129             PROC_TYPED_CHILD(Y,XMLSIG_NS,false);
 130             PROC_TYPED_CHILD(J,XMLSIG_NS,false);
 131             PROC_TYPED_CHILD(Seed,XMLSIG_NS,false);
 132             PROC_TYPED_CHILD(PgenCounter,XMLSIG_NS,false);
 133             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 134         }
 135     };
 136
 137     class XMLTOOL_DLLLOCAL RSAKeyValueImpl : public virtual RSAKeyValue,
 138         public AbstractComplexElement,
 139         public AbstractDOMCachingXMLObject,
 140         public AbstractXMLObjectMarshaller,
 141         public AbstractXMLObjectUnmarshaller
 142     {
 143     public:
 144         virtual ~RSAKeyValueImpl() {}
 145
 146         RSAKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 147                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 148             init();
 149         }
 150
 151         RSAKeyValueImpl(const RSAKeyValueImpl& src)
 152                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 153             init();
 154             if (src.getModulus())
 155                 setModulus(src.getModulus()->cloneModulus());
 156             if (src.getExponent())
 157                 setExponent(src.getExponent()->cloneExponent());
 158         }
 159
 160         void init() {
 161             m_Modulus=nullptr;
 162             m_Exponent=nullptr;
 163             m_children.push_back(nullptr);
 164             m_children.push_back(nullptr);
 165             m_pos_Modulus=m_children.begin();
 166             m_pos_Exponent=m_pos_Modulus;
 167             ++m_pos_Exponent;
 168         }
 169
 170         IMPL_XMLOBJECT_CLONE(RSAKeyValue);
 171         IMPL_TYPED_CHILD(Modulus);
 172         IMPL_TYPED_CHILD(Exponent);
 173
 174     protected:
 175         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 176             PROC_TYPED_CHILD(Modulus,XMLSIG_NS,false);
 177             PROC_TYPED_CHILD(Exponent,XMLSIG_NS,false);
 178             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 179         }
 180     };
 181
 182     class XMLTOOL_DLLLOCAL NamedCurveImpl : public virtual NamedCurve,
 183         public AbstractComplexElement,
 184         public AbstractDOMCachingXMLObject,
 185         public AbstractXMLObjectMarshaller,
 186         public AbstractXMLObjectUnmarshaller
 187     {
 188     public:
 189         virtual ~NamedCurveImpl() {
 190             XMLString::release(&m_URI);
 191         }
 192
 193         NamedCurveImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 194             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 195             m_URI=nullptr;
 196         }
 197
 198         NamedCurveImpl(const NamedCurveImpl& src)
 199                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 200             m_URI=nullptr;
 201             setURI(getURI());
 202         }
 203
 204         IMPL_XMLOBJECT_CLONE(NamedCurve);
 205         IMPL_STRING_ATTRIB(URI);
 206
 207     protected:
 208         void marshallAttributes(DOMElement* domElement) const {
 209             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 210         }
 211
 212         void processAttribute(const DOMAttr* attribute) {
 213             PROC_STRING_ATTRIB(URI,URI,nullptr);
 214             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 215         }
 216     };
 217
 218     class XMLTOOL_DLLLOCAL ECKeyValueImpl : public virtual ECKeyValue,
 219         public AbstractComplexElement,
 220         public AbstractDOMCachingXMLObject,
 221         public AbstractXMLObjectMarshaller,
 222         public AbstractXMLObjectUnmarshaller
 223     {
 224     public:
 225         virtual ~ECKeyValueImpl() {
 226             XMLString::release(&m_Id);
 227         }
 228
 229         ECKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 230                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 231             init();
 232         }
 233
 234         ECKeyValueImpl(const ECKeyValueImpl& src)
 235                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 236             init();
 237             m_Id=XMLString::replicate(src.m_Id);
 238             if (src.getECParameters())
 239                 setECParameters(src.getECParameters()->clone());
 240             if (src.getNamedCurve())
 241                 setNamedCurve(src.getNamedCurve()->cloneNamedCurve());
 242             if (src.getPublicKey())
 243                 setPublicKey(src.getPublicKey()->clonePublicKey());
 244         }
 245
 246         void init() {
 247             m_Id=nullptr;
 248             m_ECParameters=nullptr;
 249             m_NamedCurve=nullptr;
 250             m_PublicKey=nullptr;
 251             m_children.push_back(nullptr);
 252             m_children.push_back(nullptr);
 253             m_children.push_back(nullptr);
 254             m_pos_ECParameters=m_children.begin();
 255             m_pos_NamedCurve=m_pos_ECParameters;
 256             ++m_pos_NamedCurve;
 257             m_pos_PublicKey=m_pos_NamedCurve;
 258             ++m_pos_PublicKey;
 259         }
 260
 261         IMPL_XMLOBJECT_CLONE(ECKeyValue);
 262         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 263         IMPL_XMLOBJECT_CHILD(ECParameters);
 264         IMPL_TYPED_CHILD(NamedCurve);
 265         IMPL_TYPED_CHILD(PublicKey);
 266
 267     protected:
 268         void marshallAttributes(DOMElement* domElement) const {
 269             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 270         }
 271
 272         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 273             PROC_TYPED_CHILD(NamedCurve,XMLSIG11_NS,false);
 274             PROC_TYPED_CHILD(PublicKey,XMLSIG11_NS,false);
 275
 276             // Not really "unknown", but currently unwrapped.
 277             static const XMLCh _ECParameters[] = UNICODE_LITERAL_12(E,C,P,a,r,a,m,e,t,e,r,s);
 278             if (XMLString::equals(root->getLocalName(), _ECParameters) && XMLString::equals(root->getNamespaceURI(), XMLSIG11_NS)) {
 279                 setECParameters(childXMLObject);
 280                 return;
 281             }
 282
 283             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 284         }
 285
 286         void processAttribute(const DOMAttr* attribute) {
 287             PROC_ID_ATTRIB(Id,ID,nullptr);
 288             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 289         }
 290     };
 291
 292     class XMLTOOL_DLLLOCAL KeyValueImpl : public virtual KeyValue,
 293         public AbstractComplexElement,
 294         public AbstractDOMCachingXMLObject,
 295         public AbstractXMLObjectMarshaller,
 296         public AbstractXMLObjectUnmarshaller
 297     {
 298     public:
 299         virtual ~KeyValueImpl() {}
 300
 301         KeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 302                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 303             init();
 304         }
 305
 306         KeyValueImpl(const KeyValueImpl& src)
 307                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 308             init();
 309             if (src.getDSAKeyValue())
 310                 setDSAKeyValue(src.getDSAKeyValue()->cloneDSAKeyValue());
 311             if (src.getRSAKeyValue())
 312                 setRSAKeyValue(src.getRSAKeyValue()->cloneRSAKeyValue());
 313             if (src.getECKeyValue())
 314                 setECKeyValue(src.getECKeyValue()->cloneECKeyValue());
 315             if (src.getUnknownXMLObject())
 316                 setUnknownXMLObject(src.getUnknownXMLObject()->clone());
 317         }
 318
 319         void init() {
 320             m_DSAKeyValue=nullptr;
 321             m_RSAKeyValue=nullptr;
 322             m_ECKeyValue=nullptr;
 323             m_UnknownXMLObject=nullptr;
 324             m_children.push_back(nullptr);
 325             m_children.push_back(nullptr);
 326             m_children.push_back(nullptr);
 327             m_children.push_back(nullptr);
 328             m_pos_DSAKeyValue=m_children.begin();
 329             m_pos_RSAKeyValue=m_pos_DSAKeyValue;
 330             ++m_pos_RSAKeyValue;
 331             m_pos_ECKeyValue=m_pos_RSAKeyValue;
 332             ++m_pos_ECKeyValue;
 333             m_pos_UnknownXMLObject=m_pos_ECKeyValue;
 334             ++m_pos_UnknownXMLObject;
 335         }
 336
 337         IMPL_XMLOBJECT_CLONE(KeyValue);
 338         IMPL_TYPED_CHILD(DSAKeyValue);
 339         IMPL_TYPED_CHILD(RSAKeyValue);
 340         IMPL_TYPED_CHILD(ECKeyValue);
 341         IMPL_XMLOBJECT_CHILD(UnknownXMLObject);
 342
 343     protected:
 344         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 345             PROC_TYPED_CHILD(DSAKeyValue,XMLSIG_NS,false);
 346             PROC_TYPED_CHILD(RSAKeyValue,XMLSIG_NS,false);
 347             PROC_TYPED_CHILD(ECKeyValue,XMLSIG11_NS,false);
 348
 349             // Unknown child.
 350             const XMLCh* nsURI=root->getNamespaceURI();
 351             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 352                 setUnknownXMLObject(childXMLObject);
 353                 return;
 354             }
 355
 356             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 357         }
 358     };
 359
 360     class XMLTOOL_DLLLOCAL DEREncodedKeyValueImpl : public virtual DEREncodedKeyValue,
 361         public AbstractSimpleElement,
 362         public AbstractDOMCachingXMLObject,
 363         public AbstractXMLObjectMarshaller,
 364         public AbstractXMLObjectUnmarshaller
 365     {
 366     public:
 367         virtual ~DEREncodedKeyValueImpl() {
 368             XMLString::release(&m_Id);
 369         }
 370
 371         DEREncodedKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 372                 : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Id(nullptr) {
 373         }
 374
 375         DEREncodedKeyValueImpl(const DEREncodedKeyValueImpl& src)
 376                 : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src), m_Id(nullptr) {
 377             setId(src.getId());
 378         }
 379
 380         IMPL_XMLOBJECT_CLONE(DEREncodedKeyValue);
 381         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 382
 383     protected:
 384         void marshallAttributes(DOMElement* domElement) const {
 385             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 386         }
 387
 388         void processAttribute(const DOMAttr* attribute) {
 389             PROC_ID_ATTRIB(Id,ID,nullptr);
 390             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 391         }
 392     };
 393
 394     class XMLTOOL_DLLLOCAL TransformImpl : public virtual Transform,
 395         public AbstractComplexElement,
 396         public AbstractDOMCachingXMLObject,
 397         public AbstractXMLObjectMarshaller,
 398         public AbstractXMLObjectUnmarshaller
 399     {
 400     public:
 401         virtual ~TransformImpl() {
 402             XMLString::release(&m_Algorithm);
 403         }
 404
 405         TransformImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 406             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Algorithm(nullptr) {
 407         }
 408
 409         TransformImpl(const TransformImpl& src)
 410                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src),
 411                     m_Algorithm(XMLString::replicate(src.m_Algorithm)) {
 412             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 413                 if (*i) {
 414                     XPath* x=dynamic_cast<XPath*>(*i);
 415                     if (x) {
 416                         getXPaths().push_back(x->cloneXPath());
 417                         continue;
 418                     }
 419                     getUnknownXMLObjects().push_back((*i)->clone());
 420                 }
 421             }
 422         }
 423
 424         IMPL_XMLOBJECT_CLONE(Transform);
 425         IMPL_STRING_ATTRIB(Algorithm);
 426         IMPL_TYPED_CHILDREN(XPath,m_children.end());
 427         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 428
 429     protected:
 430         void marshallAttributes(DOMElement* domElement) const {
 431             MARSHALL_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 432         }
 433
 434         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 435             PROC_TYPED_CHILDREN(XPath,XMLSIG_NS,false);
 436
 437             // Unknown child.
 438             const XMLCh* nsURI=root->getNamespaceURI();
 439             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 440                 getUnknownXMLObjects().push_back(childXMLObject);
 441                 return;
 442             }
 443
 444             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 445         }
 446
 447         void processAttribute(const DOMAttr* attribute) {
 448             PROC_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 449             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 450         }
 451     };
 452
 453     class XMLTOOL_DLLLOCAL TransformsImpl : public virtual Transforms,
 454         public AbstractComplexElement,
 455         public AbstractDOMCachingXMLObject,
 456         public AbstractXMLObjectMarshaller,
 457         public AbstractXMLObjectUnmarshaller
 458     {
 459     public:
 460         virtual ~TransformsImpl() {}
 461
 462         TransformsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 463             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 464         }
 465
 466         TransformsImpl(const TransformsImpl& src)
 467                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 468             VectorOf(Transform) v=getTransforms();
 469             for (vector<Transform*>::const_iterator i=src.m_Transforms.begin(); i!=src.m_Transforms.end(); i++) {
 470                 if (*i) {
 471                     v.push_back((*i)->cloneTransform());
 472                 }
 473             }
 474         }
 475
 476         IMPL_XMLOBJECT_CLONE(Transforms);
 477         IMPL_TYPED_CHILDREN(Transform,m_children.end());
 478
 479     protected:
 480         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 481             PROC_TYPED_CHILDREN(Transform,XMLSIG_NS,false);
 482             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 483         }
 484     };
 485
 486     class XMLTOOL_DLLLOCAL RetrievalMethodImpl : public virtual RetrievalMethod,
 487         public AbstractComplexElement,
 488         public AbstractDOMCachingXMLObject,
 489         public AbstractXMLObjectMarshaller,
 490         public AbstractXMLObjectUnmarshaller
 491     {
 492     public:
 493         virtual ~RetrievalMethodImpl() {
 494             XMLString::release(&m_URI);
 495             XMLString::release(&m_Type);
 496         }
 497
 498         RetrievalMethodImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 499             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 500             init();
 501         }
 502
 503         RetrievalMethodImpl(const RetrievalMethodImpl& src)
 504                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 505             init();
 506             setURI(getURI());
 507             setType(getType());
 508             if (src.getTransforms())
 509                 setTransforms(src.getTransforms()->cloneTransforms());
 510         }
 511
 512         void init() {
 513             m_URI=m_Type=nullptr;
 514             m_Transforms=nullptr;
 515             m_children.push_back(nullptr);
 516             m_pos_Transforms=m_children.begin();
 517         }
 518
 519         IMPL_XMLOBJECT_CLONE(RetrievalMethod);
 520         IMPL_STRING_ATTRIB(URI);
 521         IMPL_STRING_ATTRIB(Type);
 522         IMPL_TYPED_CHILD(Transforms);
 523
 524     protected:
 525         void marshallAttributes(DOMElement* domElement) const {
 526             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 527             MARSHALL_STRING_ATTRIB(Type,TYPE,nullptr);
 528         }
 529
 530         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 531             PROC_TYPED_CHILD(Transforms,XMLSIG_NS,false);
 532             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 533         }
 534
 535         void processAttribute(const DOMAttr* attribute) {
 536             PROC_STRING_ATTRIB(URI,URI,nullptr);
 537             PROC_STRING_ATTRIB(Type,TYPE,nullptr);
 538             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 539         }
 540     };
 541
 542     class XMLTOOL_DLLLOCAL X509IssuerSerialImpl : public virtual X509IssuerSerial,
 543         public AbstractComplexElement,
 544         public AbstractDOMCachingXMLObject,
 545         public AbstractXMLObjectMarshaller,
 546         public AbstractXMLObjectUnmarshaller
 547     {
 548     public:
 549         virtual ~X509IssuerSerialImpl() {}
 550
 551         X509IssuerSerialImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 552                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 553             init();
 554         }
 555
 556         X509IssuerSerialImpl(const X509IssuerSerialImpl& src)
 557                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 558             init();
 559             if (src.getX509IssuerName())
 560                 setX509IssuerName(src.getX509IssuerName()->cloneX509IssuerName());
 561             if (src.getX509SerialNumber())
 562                 setX509SerialNumber(src.getX509SerialNumber()->cloneX509SerialNumber());
 563         }
 564
 565         void init() {
 566             m_X509IssuerName=nullptr;
 567             m_X509SerialNumber=nullptr;
 568             m_children.push_back(nullptr);
 569             m_children.push_back(nullptr);
 570             m_pos_X509IssuerName=m_children.begin();
 571             m_pos_X509SerialNumber=m_pos_X509IssuerName;
 572             ++m_pos_X509SerialNumber;
 573         }
 574
 575         IMPL_XMLOBJECT_CLONE(X509IssuerSerial);
 576         IMPL_TYPED_CHILD(X509IssuerName);
 577         IMPL_TYPED_CHILD(X509SerialNumber);
 578
 579     protected:
 580         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 581             PROC_TYPED_CHILD(X509IssuerName,XMLSIG_NS,false);
 582             PROC_TYPED_CHILD(X509SerialNumber,XMLSIG_NS,false);
 583             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 584         }
 585     };
 586
 587     class XMLTOOL_DLLLOCAL X509DigestImpl : public virtual X509Digest,
 588         public AbstractComplexElement,
 589         public AbstractDOMCachingXMLObject,
 590         public AbstractXMLObjectMarshaller,
 591         public AbstractXMLObjectUnmarshaller
 592     {
 593     public:
 594         virtual ~X509DigestImpl() {
 595             XMLString::release(&m_Algorithm);
 596         }
 597
 598         X509DigestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 599             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Algorithm(nullptr) {
 600         }
 601
 602         X509DigestImpl(const X509DigestImpl& src)
 603                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src), m_Algorithm(nullptr) {
 604             setAlgorithm(src.getAlgorithm());
 605         }
 606
 607         IMPL_XMLOBJECT_CLONE(X509Digest);
 608         IMPL_STRING_ATTRIB(Algorithm);
 609
 610     protected:
 611         void marshallAttributes(DOMElement* domElement) const {
 612             MARSHALL_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 613         }
 614
 615         void processAttribute(const DOMAttr* attribute) {
 616             PROC_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 617             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 618         }
 619     };
 620
 621
 622     class XMLTOOL_DLLLOCAL X509DataImpl : public virtual X509Data,
 623         public AbstractComplexElement,
 624         public AbstractDOMCachingXMLObject,
 625         public AbstractXMLObjectMarshaller,
 626         public AbstractXMLObjectUnmarshaller
 627     {
 628     public:
 629         virtual ~X509DataImpl() {}
 630
 631         X509DataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 632             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 633         }
 634
 635         X509DataImpl(const X509DataImpl& src)
 636                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 637             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 638                 if (*i) {
 639                     X509Certificate* xcert=dynamic_cast<X509Certificate*>(*i);
 640                     if (xcert) {
 641                         getX509Certificates().push_back(xcert->cloneX509Certificate());
 642                         continue;
 643                     }
 644
 645                     X509CRL* xcrl=dynamic_cast<X509CRL*>(*i);
 646                     if (xcrl) {
 647                         getX509CRLs().push_back(xcrl->cloneX509CRL());
 648                         continue;
 649                     }
 650
 651                     X509SubjectName* xsn=dynamic_cast<X509SubjectName*>(*i);
 652                     if (xsn) {
 653                         getX509SubjectNames().push_back(xsn->cloneX509SubjectName());
 654                         continue;
 655                     }
 656
 657                     X509IssuerSerial* xis=dynamic_cast<X509IssuerSerial*>(*i);
 658                     if (xis) {
 659                         getX509IssuerSerials().push_back(xis->cloneX509IssuerSerial());
 660                         continue;
 661                     }
 662
 663                     X509SKI* xski=dynamic_cast<X509SKI*>(*i);
 664                     if (xski) {
 665                         getX509SKIs().push_back(xski->cloneX509SKI());
 666                         continue;
 667                     }
 668
 669                     X509Digest* xdig=dynamic_cast<X509Digest*>(*i);
 670                     if (xdig) {
 671                         getX509Digests().push_back(xdig->cloneX509Digest());
 672                         continue;
 673                     }
 674
 675                     OCSPResponse* ocsp=dynamic_cast<OCSPResponse*>(*i);
 676                     if (ocsp) {
 677                         getOCSPResponses().push_back(ocsp->cloneOCSPResponse());
 678                         continue;
 679                     }
 680
 681                     getUnknownXMLObjects().push_back((*i)->clone());
 682                 }
 683             }
 684         }
 685
 686         IMPL_XMLOBJECT_CLONE(X509Data);
 687         IMPL_TYPED_CHILDREN(X509IssuerSerial,m_children.end());
 688         IMPL_TYPED_CHILDREN(X509SKI,m_children.end());
 689         IMPL_TYPED_CHILDREN(X509SubjectName,m_children.end());
 690         IMPL_TYPED_CHILDREN(X509Certificate,m_children.end());
 691         IMPL_TYPED_CHILDREN(X509CRL,m_children.end());
 692         IMPL_TYPED_CHILDREN(X509Digest,m_children.end());
 693         IMPL_TYPED_CHILDREN(OCSPResponse,m_children.end());
 694         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 695
 696     protected:
 697         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 698             PROC_TYPED_CHILDREN(X509IssuerSerial,XMLSIG_NS,false);
 699             PROC_TYPED_CHILDREN(X509SKI,XMLSIG_NS,false);
 700             PROC_TYPED_CHILDREN(X509SubjectName,XMLSIG_NS,false);
 701             PROC_TYPED_CHILDREN(X509Certificate,XMLSIG_NS,false);
 702             PROC_TYPED_CHILDREN(X509CRL,XMLSIG_NS,false);
 703             PROC_TYPED_CHILDREN(X509Digest,XMLSIG11_NS,false);
 704             PROC_TYPED_CHILDREN(OCSPResponse,XMLSIG11_NS,false);
 705
 706             // Unknown child.
 707             const XMLCh* nsURI=root->getNamespaceURI();
 708             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 709                 getUnknownXMLObjects().push_back(childXMLObject);
 710                 return;
 711             }
 712
 713             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 714         }
 715     };
 716
 717     class XMLTOOL_DLLLOCAL SPKIDataImpl : public virtual SPKIData,
 718         public AbstractComplexElement,
 719         public AbstractDOMCachingXMLObject,
 720         public AbstractXMLObjectMarshaller,
 721         public AbstractXMLObjectUnmarshaller
 722     {
 723     public:
 724         virtual ~SPKIDataImpl() {}
 725
 726         SPKIDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 727             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 728         }
 729
 730         SPKIDataImpl(const SPKIDataImpl& src)
 731                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 732             VectorOfPairs(SPKISexp,XMLObject) v=getSPKISexps();
 733             for (vector< pair<SPKISexp*,XMLObject*> >::const_iterator i=src.m_SPKISexps.begin(); i!=src.m_SPKISexps.end(); i++) {
 734                 if (i->first) {
 735                     v.push_back(make_pair(i->first->cloneSPKISexp(),(i->second ? i->second->clone() : (XMLObject*)nullptr)));
 736                 }
 737             }
 738         }
 739
 740         IMPL_XMLOBJECT_CLONE(SPKIData);
 741
 742     private:
 743         vector< pair<SPKISexp*,XMLObject*> > m_SPKISexps;
 744
 745     public:
 746         VectorOfPairs(SPKISexp,XMLObject) getSPKISexps() {
 747             return VectorOfPairs(SPKISexp,XMLObject)(this, m_SPKISexps, &m_children, m_children.end());
 748         }
 749
 750         const vector< pair<SPKISexp*,XMLObject*> >& getSPKISexps() const {
 751             return m_SPKISexps;
 752         }
 753
 754     protected:
 755         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 756             if (XMLHelper::isNodeNamed(root,XMLSIG_NS,SPKISexp::LOCAL_NAME)) {
 757                 SPKISexp* typesafe=dynamic_cast<SPKISexp*>(childXMLObject);
 758                 if (typesafe) {
 759                     getSPKISexps().push_back(make_pair(typesafe,(XMLObject*)nullptr));
 760                     return;
 761                 }
 762             }
 763
 764             // Unknown child (has to be paired with the last SPKISexp processed.
 765             const XMLCh* nsURI=root->getNamespaceURI();
 766             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 767                 // Update second half of pair in vector, and in master list.
 768                 if (!m_SPKISexps.empty() && m_SPKISexps.back().second==nullptr) {
 769                     m_SPKISexps.back().second=childXMLObject;
 770                     m_children.back()=childXMLObject;
 771                     return;
 772                 }
 773                 else
 774                     throw UnmarshallingException("Extension element must follow ds:SPKISexp element.");
 775             }
 776
 777             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 778         }
 779     };
 780
 781     class XMLTOOL_DLLLOCAL PGPDataImpl : public virtual PGPData,
 782         public AbstractComplexElement,
 783         public AbstractDOMCachingXMLObject,
 784         public AbstractXMLObjectMarshaller,
 785         public AbstractXMLObjectUnmarshaller
 786     {
 787     public:
 788         virtual ~PGPDataImpl() {}
 789
 790         PGPDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 791                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 792             init();
 793         }
 794
 795         PGPDataImpl(const PGPDataImpl& src)
 796                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 797             init();
 798             if (src.getPGPKeyID())
 799                 setPGPKeyID(src.getPGPKeyID()->clonePGPKeyID());
 800             if (src.getPGPKeyPacket())
 801                 setPGPKeyPacket(src.getPGPKeyPacket()->clonePGPKeyPacket());
 802             VectorOf(XMLObject) v=getUnknownXMLObjects();
 803             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 804                 v.push_back((*i)->clone());
 805         }
 806
 807         void init() {
 808             m_PGPKeyID=nullptr;
 809             m_PGPKeyPacket=nullptr;
 810             m_children.push_back(nullptr);
 811             m_children.push_back(nullptr);
 812             m_pos_PGPKeyID=m_children.begin();
 813             m_pos_PGPKeyPacket=m_pos_PGPKeyID;
 814             ++m_pos_PGPKeyPacket;
 815         }
 816
 817         IMPL_XMLOBJECT_CLONE(PGPData);
 818         IMPL_TYPED_CHILD(PGPKeyID);
 819         IMPL_TYPED_CHILD(PGPKeyPacket);
 820         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 821
 822     protected:
 823         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 824             PROC_TYPED_CHILD(PGPKeyID,XMLSIG_NS,false);
 825             PROC_TYPED_CHILD(PGPKeyPacket,XMLSIG_NS,false);
 826
 827             // Unknown child.
 828             const XMLCh* nsURI=root->getNamespaceURI();
 829             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 830                 getUnknownXMLObjects().push_back(childXMLObject);
 831                 return;
 832             }
 833
 834             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 835         }
 836     };
 837
 838     class XMLTOOL_DLLLOCAL KeyInfoReferenceImpl : public virtual KeyInfoReference,
 839         public AbstractComplexElement,
 840         public AbstractDOMCachingXMLObject,
 841         public AbstractXMLObjectMarshaller,
 842         public AbstractXMLObjectUnmarshaller
 843     {
 844     public:
 845         virtual ~KeyInfoReferenceImpl() {
 846             XMLString::release(&m_Id);
 847             XMLString::release(&m_URI);
 848         }
 849
 850         KeyInfoReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 851             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 852             init();
 853         }
 854
 855         KeyInfoReferenceImpl(const KeyInfoReferenceImpl& src)
 856                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 857             init();
 858             setId(getId());
 859             setURI(getURI());
 860         }
 861
 862         void init() {
 863             m_Id=m_URI=nullptr;
 864         }
 865
 866         IMPL_XMLOBJECT_CLONE(KeyInfoReference);
 867         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 868         IMPL_STRING_ATTRIB(URI);
 869
 870     protected:
 871         void marshallAttributes(DOMElement* domElement) const {
 872             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 873             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 874         }
 875
 876         void processAttribute(const DOMAttr* attribute) {
 877             PROC_ID_ATTRIB(Id,ID,nullptr);
 878             PROC_STRING_ATTRIB(URI,URI,nullptr);
 879             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 880         }
 881     };
 882
 883     class XMLTOOL_DLLLOCAL KeyInfoImpl : public virtual KeyInfo,
 884         public AbstractComplexElement,
 885         public AbstractDOMCachingXMLObject,
 886         public AbstractXMLObjectMarshaller,
 887         public AbstractXMLObjectUnmarshaller
 888     {
 889     public:
 890         virtual ~KeyInfoImpl() {
 891             XMLString::release(&m_Id);
 892         }
 893
 894         KeyInfoImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 895             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Id(nullptr) {
 896         }
 897
 898         KeyInfoImpl(const KeyInfoImpl& src)
 899                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src),
 900                     m_Id(XMLString::replicate(src.m_Id)) {
 901
 902             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 903                 if (*i) {
 904                     X509Data* xd=dynamic_cast<X509Data*>(*i);
 905                     if (xd) {
 906                         getX509Datas().push_back(xd->cloneX509Data());
 907                         continue;
 908                     }
 909
 910                     KeyName* kn=dynamic_cast<KeyName*>(*i);
 911                     if (kn) {
 912                         getKeyNames().push_back(kn->cloneKeyName());
 913                         continue;
 914                     }
 915
 916                     KeyValue* kv=dynamic_cast<KeyValue*>(*i);
 917                     if (kv) {
 918                         getKeyValues().push_back(kv->cloneKeyValue());
 919                         continue;
 920                     }
 921
 922                     DEREncodedKeyValue* ekv=dynamic_cast<DEREncodedKeyValue*>(*i);
 923                     if (ekv) {
 924                         getDEREncodedKeyValues().push_back(ekv->cloneDEREncodedKeyValue());
 925                         continue;
 926                     }
 927
 928                     RetrievalMethod* rm=dynamic_cast<RetrievalMethod*>(*i);
 929                     if (rm) {
 930                         getRetrievalMethods().push_back(rm->cloneRetrievalMethod());
 931                         continue;
 932                     }
 933
 934                     MgmtData* md=dynamic_cast<MgmtData*>(*i);
 935                     if (md) {
 936                         getMgmtDatas().push_back(md->cloneMgmtData());
 937                         continue;
 938                     }
 939
 940                     SPKIData* sd=dynamic_cast<SPKIData*>(*i);
 941                     if (sd) {
 942                         getSPKIDatas().push_back(sd->cloneSPKIData());
 943                         continue;
 944                     }
 945
 946                     PGPData* pd=dynamic_cast<PGPData*>(*i);
 947                     if (pd) {
 948                         getPGPDatas().push_back(pd->clonePGPData());
 949                         continue;
 950                     }
 951
 952                     KeyInfoReference* kref=dynamic_cast<KeyInfoReference*>(*i);
 953                     if (kref) {
 954                         getKeyInfoReferences().push_back(kref->cloneKeyInfoReference());
 955                         continue;
 956                     }
 957
 958                     getUnknownXMLObjects().push_back((*i)->clone());
 959                 }
 960             }
 961         }
 962
 963         IMPL_XMLOBJECT_CLONE(KeyInfo);
 964         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 965         IMPL_TYPED_CHILDREN(KeyName,m_children.end());
 966         IMPL_TYPED_CHILDREN(KeyValue,m_children.end());
 967         IMPL_TYPED_CHILDREN(DEREncodedKeyValue,m_children.end());
 968         IMPL_TYPED_CHILDREN(RetrievalMethod,m_children.end());
 969         IMPL_TYPED_CHILDREN(X509Data,m_children.end());
 970         IMPL_TYPED_CHILDREN(MgmtData,m_children.end());
 971         IMPL_TYPED_CHILDREN(SPKIData,m_children.end());
 972         IMPL_TYPED_CHILDREN(PGPData,m_children.end());
 973         IMPL_TYPED_CHILDREN(KeyInfoReference,m_children.end());
 974         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 975
 976     protected:
 977         void marshallAttributes(DOMElement* domElement) const {
 978             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 979         }
 980
 981         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 982             PROC_TYPED_CHILDREN(X509Data,XMLSIG_NS,false);
 983             PROC_TYPED_CHILDREN(KeyName,XMLSIG_NS,false);
 984             PROC_TYPED_CHILDREN(KeyValue,XMLSIG_NS,false);
 985             PROC_TYPED_CHILDREN(DEREncodedKeyValue,XMLSIG11_NS,false);
 986             PROC_TYPED_CHILDREN(RetrievalMethod,XMLSIG_NS,false);
 987             PROC_TYPED_CHILDREN(MgmtData,XMLSIG_NS,false);
 988             PROC_TYPED_CHILDREN(SPKIData,XMLSIG_NS,false);
 989             PROC_TYPED_CHILDREN(PGPData,XMLSIG_NS,false);
 990             PROC_TYPED_CHILDREN(KeyInfoReference,XMLSIG11_NS,false);
 991
 992             // Unknown child.
 993             const XMLCh* nsURI=root->getNamespaceURI();
 994             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 995                 getUnknownXMLObjects().push_back(childXMLObject);
 996                 return;
 997             }
 998
 999             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
1000         }
1001
1002         void processAttribute(const DOMAttr* attribute) {
1003             PROC_ID_ATTRIB(Id,ID,nullptr);
1004             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
1005         }
1006     };
1007
1008     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,KeyName);
1009     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,MgmtData);
1010     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Modulus);
1011     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Exponent);
1012     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Seed);
1013     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PgenCounter);
1014     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,P);
1015     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Q);
1016     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,G);
1017     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Y);
1018     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,J);
1019     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,XPath);
1020     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509IssuerName);
1021     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SerialNumber);
1022     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SKI);
1023     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SubjectName);
1024     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509Certificate);
1025     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509CRL);
1026     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,SPKISexp);
1027     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyID);
1028     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyPacket);
1029
1030     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,OCSPResponse);
1031     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PublicKey);
1032 };
1033
1034 #if defined (_MSC_VER)
1035     #pragma warning( pop )
1036 #endif
1037
1038 // Builder Implementations
1039
1040 IMPL_XMLOBJECTBUILDER(X509IssuerSerial);
1041 IMPL_XMLOBJECTBUILDER(X509IssuerName);
1042 IMPL_XMLOBJECTBUILDER(X509SerialNumber);
1043 IMPL_XMLOBJECTBUILDER(X509SKI);
1044 IMPL_XMLOBJECTBUILDER(X509SubjectName);
1045 IMPL_XMLOBJECTBUILDER(X509Certificate);
1046 IMPL_XMLOBJECTBUILDER(X509CRL);
1047 IMPL_XMLOBJECTBUILDER(X509Data);
1048 IMPL_XMLOBJECTBUILDER(XPath);
1049 IMPL_XMLOBJECTBUILDER(Transform);
1050 IMPL_XMLOBJECTBUILDER(Transforms);
1051 IMPL_XMLOBJECTBUILDER(RetrievalMethod);
1052 IMPL_XMLOBJECTBUILDER(KeyName);
1053 IMPL_XMLOBJECTBUILDER(MgmtData);
1054 IMPL_XMLOBJECTBUILDER(Modulus);
1055 IMPL_XMLOBJECTBUILDER(Exponent);
1056 IMPL_XMLOBJECTBUILDER(Seed);
1057 IMPL_XMLOBJECTBUILDER(PgenCounter);
1058 IMPL_XMLOBJECTBUILDER(P);
1059 IMPL_XMLOBJECTBUILDER(Q);
1060 IMPL_XMLOBJECTBUILDER(G);
1061 IMPL_XMLOBJECTBUILDER(Y);
1062 IMPL_XMLOBJECTBUILDER(J);
1063 IMPL_XMLOBJECTBUILDER(DSAKeyValue);
1064 IMPL_XMLOBJECTBUILDER(RSAKeyValue);
1065 IMPL_XMLOBJECTBUILDER(KeyValue);
1066 IMPL_XMLOBJECTBUILDER(KeyInfo);
1067 IMPL_XMLOBJECTBUILDER(SPKISexp);
1068 IMPL_XMLOBJECTBUILDER(SPKIData);
1069 IMPL_XMLOBJECTBUILDER(PGPKeyID);
1070 IMPL_XMLOBJECTBUILDER(PGPKeyPacket);
1071 IMPL_XMLOBJECTBUILDER(PGPData);
1072
1073 IMPL_XMLOBJECTBUILDER(DEREncodedKeyValue);
1074 IMPL_XMLOBJECTBUILDER(ECKeyValue);
1075 IMPL_XMLOBJECTBUILDER(KeyInfoReference);
1076 IMPL_XMLOBJECTBUILDER(NamedCurve);
1077 IMPL_XMLOBJECTBUILDER(OCSPResponse);
1078 IMPL_XMLOBJECTBUILDER(PublicKey);
1079 IMPL_XMLOBJECTBUILDER(X509Digest);
1080
1081 // Unicode literals
1082
1083 const XMLCh KeyInfo::LOCAL_NAME[] =                 UNICODE_LITERAL_7(K,e,y,I,n,f,o);
1084 const XMLCh KeyInfo::TYPE_NAME[] =                  UNICODE_LITERAL_11(K,e,y,I,n,f,o,T,y,p,e);
1085 const XMLCh KeyInfo::ID_ATTRIB_NAME[] =             UNICODE_LITERAL_2(I,d);
1086 const XMLCh KeyValue::LOCAL_NAME[] =                UNICODE_LITERAL_8(K,e,y,V,a,l,u,e);
1087 const XMLCh KeyValue::TYPE_NAME[] =                 UNICODE_LITERAL_12(K,e,y,V,a,l,u,e,T,y,p,e);
1088 const XMLCh DSAKeyValue::LOCAL_NAME[] =             UNICODE_LITERAL_11(D,S,A,K,e,y,V,a,l,u,e);
1089 const XMLCh DSAKeyValue::TYPE_NAME[] =              UNICODE_LITERAL_15(D,S,A,K,e,y,V,a,l,u,e,T,y,p,e);
1090 const XMLCh RSAKeyValue::LOCAL_NAME[] =             UNICODE_LITERAL_11(R,S,A,K,e,y,V,a,l,u,e);
1091 const XMLCh RSAKeyValue::TYPE_NAME[] =              UNICODE_LITERAL_15(R,S,A,K,e,y,V,a,l,u,e,T,y,p,e);
1092 const XMLCh MgmtData::LOCAL_NAME[] =                UNICODE_LITERAL_8(M,g,m,t,D,a,t,a);
1093 const XMLCh KeyName::LOCAL_NAME[] =                 UNICODE_LITERAL_7(K,e,y,N,a,m,e);
1094 const XMLCh Modulus::LOCAL_NAME[] =                 UNICODE_LITERAL_7(M,o,d,u,l,u,s);
1095 const XMLCh Exponent::LOCAL_NAME[] =                UNICODE_LITERAL_8(E,x,p,o,n,e,n,t);
1096 const XMLCh Seed::LOCAL_NAME[] =                    UNICODE_LITERAL_4(S,e,e,d);
1097 const XMLCh PgenCounter::LOCAL_NAME[] =             UNICODE_LITERAL_11(P,g,e,n,C,o,u,n,t,e,r);
1098 const XMLCh P::LOCAL_NAME[] =                       UNICODE_LITERAL_1(P);
1099 const XMLCh Q::LOCAL_NAME[] =                       UNICODE_LITERAL_1(Q);
1100 const XMLCh G::LOCAL_NAME[] =                       UNICODE_LITERAL_1(G);
1101 const XMLCh Y::LOCAL_NAME[] =                       UNICODE_LITERAL_1(Y);
1102 const XMLCh J::LOCAL_NAME[] =                       UNICODE_LITERAL_1(J);
1103 const XMLCh XPath::LOCAL_NAME[] =                   UNICODE_LITERAL_5(X,P,a,t,h);
1104 const XMLCh Transform::LOCAL_NAME[] =               UNICODE_LITERAL_9(T,r,a,n,s,f,o,r,m);
1105 const XMLCh Transform::TYPE_NAME[] =                UNICODE_LITERAL_13(T,r,a,n,s,f,o,r,m,T,y,p,e);
1106 const XMLCh Transform::ALGORITHM_ATTRIB_NAME[] =    UNICODE_LITERAL_9(A,l,g,o,r,i,t,h,m);
1107 const XMLCh Transforms::LOCAL_NAME[] =              UNICODE_LITERAL_10(T,r,a,n,s,f,o,r,m,s);
1108 const XMLCh Transforms::TYPE_NAME[] =               UNICODE_LITERAL_14(T,r,a,n,s,f,o,r,m,s,T,y,p,e);
1109 const XMLCh RetrievalMethod::LOCAL_NAME[] =         UNICODE_LITERAL_15(R,e,t,r,i,e,v,a,l,M,e,t,h,o,d);
1110 const XMLCh RetrievalMethod::TYPE_NAME[] =          UNICODE_LITERAL_19(R,e,t,r,i,e,v,a,l,M,e,t,h,o,d,T,y,p,e);
1111 const XMLCh RetrievalMethod::URI_ATTRIB_NAME[] =    UNICODE_LITERAL_3(U,R,I);
1112 const XMLCh RetrievalMethod::TYPE_ATTRIB_NAME[] =   UNICODE_LITERAL_4(T,y,p,e);
1113 const XMLCh SPKISexp::LOCAL_NAME[] =                UNICODE_LITERAL_8(S,P,K,I,S,e,x,p);
1114 const XMLCh SPKIData::LOCAL_NAME[] =                UNICODE_LITERAL_8(S,P,K,I,D,a,t,a);
1115 const XMLCh SPKIData::TYPE_NAME[] =                 UNICODE_LITERAL_12(S,P,K,I,D,a,t,a,T,y,p,e);
1116 const XMLCh PGPKeyID::LOCAL_NAME[] =                UNICODE_LITERAL_8(P,G,P,K,e,y,I,D);
1117 const XMLCh PGPKeyPacket::LOCAL_NAME[] =            UNICODE_LITERAL_12(P,G,P,K,e,y,P,a,c,k,e,t);
1118 const XMLCh PGPData::LOCAL_NAME[] =                 UNICODE_LITERAL_7(P,G,P,D,a,t,a);
1119 const XMLCh PGPData::TYPE_NAME[] =                  UNICODE_LITERAL_11(P,G,P,D,a,t,a,T,y,p,e);
1120
1121 const XMLCh DEREncodedKeyValue::LOCAL_NAME[] =      UNICODE_LITERAL_18(D,E,R,E,n,c,o,d,e,d,K,e,y,V,a,l,u,e);
1122 const XMLCh DEREncodedKeyValue::TYPE_NAME[] =       UNICODE_LITERAL_22(D,E,R,E,n,c,o,d,e,d,K,e,y,V,a,l,u,e,T,y,p,e);
1123 const XMLCh DEREncodedKeyValue::ID_ATTRIB_NAME[] =  UNICODE_LITERAL_2(I,d);
1124 const XMLCh ECKeyValue::LOCAL_NAME[] =              UNICODE_LITERAL_10(E,C,K,e,y,V,a,l,u,e);
1125 const XMLCh ECKeyValue::TYPE_NAME[] =               UNICODE_LITERAL_14(E,C,K,e,y,V,a,l,u,e,T,y,p,e);
1126 const XMLCh ECKeyValue::ID_ATTRIB_NAME[] =          UNICODE_LITERAL_2(I,d);
1127 const XMLCh KeyInfoReference::LOCAL_NAME[] =        UNICODE_LITERAL_16(K,e,y,I,n,f,o,R,e,f,e,r,e,n,c,e);
1128 const XMLCh KeyInfoReference::TYPE_NAME[] =         UNICODE_LITERAL_20(K,e,y,I,n,f,o,R,e,f,e,r,e,n,c,e,T,y,p,e);
1129 const XMLCh KeyInfoReference::ID_ATTRIB_NAME[] =    UNICODE_LITERAL_2(I,d);
1130 const XMLCh KeyInfoReference::URI_ATTRIB_NAME[] =   UNICODE_LITERAL_3(U,R,I);
1131 const XMLCh NamedCurve::LOCAL_NAME[] =              UNICODE_LITERAL_10(N,a,m,e,d,C,u,r,v,e);
1132 const XMLCh NamedCurve::TYPE_NAME[] =               UNICODE_LITERAL_14(N,a,m,e,d,C,u,r,v,e,T,y,p,e);
1133 const XMLCh NamedCurve::URI_ATTRIB_NAME[] =         UNICODE_LITERAL_3(U,R,I);
1134 const XMLCh OCSPResponse::LOCAL_NAME[] =            UNICODE_LITERAL_12(O,C,S,P,R,e,s,p,o,n,s,e);
1135 const XMLCh PublicKey::LOCAL_NAME[] =               UNICODE_LITERAL_9(P,u,b,l,i,c,K,e,y);
1136 const XMLCh X509Digest::ALGORITHM_ATTRIB_NAME[] =   UNICODE_LITERAL_9(A,l,g,o,r,i,t,h,m);
1137
1138 #define XCH(ch) chLatin_##ch
1139 #define XNUM(d) chDigit_##d
1140
1141 const XMLCh X509Data::LOCAL_NAME[] = {
1142     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(D), XCH(a), XCH(t), XCH(a), chNull
1143     };
1144 const XMLCh X509Data::TYPE_NAME[] = {
1145     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(D), XCH(a), XCH(t), XCH(a), XCH(T), XCH(y), XCH(p), XCH(e), chNull
1146     };
1147 const XMLCh X509IssuerSerial::LOCAL_NAME[] = {
1148     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
1149     XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l), chNull
1150     };
1151 const XMLCh X509IssuerSerial::TYPE_NAME[] = {
1152     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
1153     XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l), XCH(T), XCH(y), XCH(p), XCH(e), chNull
1154     };
1155 const XMLCh X509IssuerName::LOCAL_NAME[] = {
1156     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
1157     XCH(N), XCH(a), XCH(m), XCH(e), chNull
1158     };
1159 const XMLCh X509SerialNumber::LOCAL_NAME[] = {
1160     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l),
1161     XCH(N), XCH(u), XCH(m), XCH(b), XCH(e), XCH(r), chNull
1162     };
1163 const XMLCh X509SKI::LOCAL_NAME[] = { XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(K), XCH(I), chNull };
1164 const XMLCh X509SubjectName::LOCAL_NAME[] = {
1165     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(u), XCH(b), XCH(j), XCH(e), XCH(c), XCH(t),
1166     XCH(N), XCH(a), XCH(m), XCH(e), chNull
1167     };
1168 const XMLCh X509Certificate::LOCAL_NAME[] = {
1169     XCH(X), XNUM(5), XNUM(0), XNUM(9),
1170     XCH(C), XCH(e), XCH(r), XCH(t), XCH(i), XCH(f), XCH(i), XCH(c), XCH(a), XCH(t), XCH(e), chNull
1171     };
1172 const XMLCh X509CRL::LOCAL_NAME[] = { XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(C), XCH(R), XCH(L), chNull };
1173 const XMLCh X509Digest::LOCAL_NAME[] = {
1174     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(D), XCH(i), XCH(g), XCH(e), XCH(s), XCH(t), chNull
1175     };
1176 const XMLCh X509Digest::TYPE_NAME[] = {
1177     XCH(X), XNUM(5), XNUM(0), XNUM(9),  XCH(D), XCH(i), XCH(g), XCH(e), XCH(s), XCH(t), XCH(T), XCH(y), XCH(p), XCH(e), chNull
1178     };
1179
1180 const XMLCh RetrievalMethod::TYPE_DSAKEYVALUE[] = {
1181     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
1182     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
1183     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
1184     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
1185     chLatin_D, chLatin_S, chLatin_A, chLatin_K, chLatin_e, chLatin_y, chLatin_V, chLatin_a, chLatin_l, chLatin_u, chLatin_e, chNull
1186     };
1187
1188 const XMLCh RetrievalMethod::TYPE_RSAKEYVALUE[] = {
1189     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
1190     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
1191     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
1192     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
1193     chLatin_R, chLatin_S, chLatin_A, chLatin_K, chLatin_e, chLatin_y, chLatin_V, chLatin_a, chLatin_l, chLatin_u, chLatin_e, chNull
1194     };
1195
1196 const XMLCh RetrievalMethod::TYPE_X509DATA[] = {
1197     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
1198     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
1199     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
1200     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
1201     chLatin_X, chDigit_5, chDigit_0, chDigit_9, chLatin_D, chLatin_a, chLatin_t, chLatin_a, chNull
1202     };