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         void init() {
  59             m_P=nullptr;
  60             m_Q=nullptr;
  61             m_G=nullptr;
  62             m_Y=nullptr;
  63             m_J=nullptr;
  64             m_Seed=nullptr;
  65             m_PgenCounter=nullptr;
  66             m_children.push_back(nullptr);
  67             m_children.push_back(nullptr);
  68             m_children.push_back(nullptr);
  69             m_children.push_back(nullptr);
  70             m_children.push_back(nullptr);
  71             m_children.push_back(nullptr);
  72             m_children.push_back(nullptr);
  73             m_pos_P=m_children.begin();
  74             m_pos_Q=m_pos_P;
  75             ++m_pos_Q;
  76             m_pos_G=m_pos_Q;
  77             ++m_pos_G;
  78             m_pos_Y=m_pos_G;
  79             ++m_pos_Y;
  80             m_pos_J=m_pos_Y;
  81             ++m_pos_J;
  82             m_pos_Seed=m_pos_J;
  83             ++m_pos_Seed;
  84             m_pos_PgenCounter=m_pos_Seed;
  85             ++m_pos_PgenCounter;
  86         }
  87
  88     public:
  89         virtual ~DSAKeyValueImpl() {}
  90
  91         DSAKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
  92             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
  93             init();
  94         }
  95
  96         DSAKeyValueImpl(const DSAKeyValueImpl& src)
  97                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
  98             init();
  99             if (src.getP())
 100                 setP(src.getP()->cloneP());
 101             if (src.getQ())
 102                 setQ(src.getQ()->cloneQ());
 103             if (src.getG())
 104                 setG(src.getG()->cloneG());
 105             if (src.getY())
 106                 setY(src.getY()->cloneY());
 107             if (src.getJ())
 108                 setJ(src.getJ()->cloneJ());
 109             if (src.getSeed())
 110                 setSeed(src.getSeed()->cloneSeed());
 111             if (src.getPgenCounter())
 112                 setPgenCounter(src.getPgenCounter()->clonePgenCounter());
 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         void init() {
 144             m_Modulus=nullptr;
 145             m_Exponent=nullptr;
 146             m_children.push_back(nullptr);
 147             m_children.push_back(nullptr);
 148             m_pos_Modulus=m_children.begin();
 149             m_pos_Exponent=m_pos_Modulus;
 150             ++m_pos_Exponent;
 151         }
 152
 153     public:
 154         virtual ~RSAKeyValueImpl() {}
 155
 156         RSAKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 157                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 158             init();
 159         }
 160
 161         RSAKeyValueImpl(const RSAKeyValueImpl& src)
 162                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 163             init();
 164             if (src.getModulus())
 165                 setModulus(src.getModulus()->cloneModulus());
 166             if (src.getExponent())
 167                 setExponent(src.getExponent()->cloneExponent());
 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), m_URI(nullptr) {
 195         }
 196
 197         NamedCurveImpl(const NamedCurveImpl& src)
 198                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src), m_URI(nullptr) {
 199             setURI(src.getURI());
 200         }
 201
 202         IMPL_XMLOBJECT_CLONE(NamedCurve);
 203         IMPL_STRING_ATTRIB(URI);
 204
 205     protected:
 206         void marshallAttributes(DOMElement* domElement) const {
 207             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 208         }
 209
 210         void processAttribute(const DOMAttr* attribute) {
 211             PROC_STRING_ATTRIB(URI,URI,nullptr);
 212             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 213         }
 214     };
 215
 216     class XMLTOOL_DLLLOCAL ECKeyValueImpl : public virtual ECKeyValue,
 217         public AbstractComplexElement,
 218         public AbstractDOMCachingXMLObject,
 219         public AbstractXMLObjectMarshaller,
 220         public AbstractXMLObjectUnmarshaller
 221     {
 222         void init() {
 223             m_Id=nullptr;
 224             m_ECParameters=nullptr;
 225             m_NamedCurve=nullptr;
 226             m_PublicKey=nullptr;
 227             m_children.push_back(nullptr);
 228             m_children.push_back(nullptr);
 229             m_children.push_back(nullptr);
 230             m_pos_ECParameters=m_children.begin();
 231             m_pos_NamedCurve=m_pos_ECParameters;
 232             ++m_pos_NamedCurve;
 233             m_pos_PublicKey=m_pos_NamedCurve;
 234             ++m_pos_PublicKey;
 235         }
 236
 237     public:
 238         virtual ~ECKeyValueImpl() {
 239             XMLString::release(&m_Id);
 240         }
 241
 242         ECKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 243                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 244             init();
 245         }
 246
 247         ECKeyValueImpl(const ECKeyValueImpl& src)
 248                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 249             init();
 250             setId(src.getId());
 251             if (src.getECParameters())
 252                 setECParameters(src.getECParameters()->clone());
 253             if (src.getNamedCurve())
 254                 setNamedCurve(src.getNamedCurve()->cloneNamedCurve());
 255             if (src.getPublicKey())
 256                 setPublicKey(src.getPublicKey()->clonePublicKey());
 257         }
 258
 259         IMPL_XMLOBJECT_CLONE(ECKeyValue);
 260         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 261         IMPL_XMLOBJECT_CHILD(ECParameters);
 262         IMPL_TYPED_CHILD(NamedCurve);
 263         IMPL_TYPED_CHILD(PublicKey);
 264
 265     protected:
 266         void marshallAttributes(DOMElement* domElement) const {
 267             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 268         }
 269
 270         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 271             PROC_TYPED_CHILD(NamedCurve,XMLSIG11_NS,false);
 272             PROC_TYPED_CHILD(PublicKey,XMLSIG11_NS,false);
 273
 274             // Not really "unknown", but currently unwrapped.
 275             static const XMLCh _ECParameters[] = UNICODE_LITERAL_12(E,C,P,a,r,a,m,e,t,e,r,s);
 276             if (XMLString::equals(root->getLocalName(), _ECParameters) && XMLString::equals(root->getNamespaceURI(), XMLSIG11_NS)) {
 277                 setECParameters(childXMLObject);
 278                 return;
 279             }
 280
 281             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 282         }
 283
 284         void processAttribute(const DOMAttr* attribute) {
 285             PROC_ID_ATTRIB(Id,ID,nullptr);
 286             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 287         }
 288     };
 289
 290     class XMLTOOL_DLLLOCAL KeyValueImpl : public virtual KeyValue,
 291         public AbstractComplexElement,
 292         public AbstractDOMCachingXMLObject,
 293         public AbstractXMLObjectMarshaller,
 294         public AbstractXMLObjectUnmarshaller
 295     {
 296         void init() {
 297             m_DSAKeyValue=nullptr;
 298             m_RSAKeyValue=nullptr;
 299             m_ECKeyValue=nullptr;
 300             m_UnknownXMLObject=nullptr;
 301             m_children.push_back(nullptr);
 302             m_children.push_back(nullptr);
 303             m_children.push_back(nullptr);
 304             m_children.push_back(nullptr);
 305             m_pos_DSAKeyValue=m_children.begin();
 306             m_pos_RSAKeyValue=m_pos_DSAKeyValue;
 307             ++m_pos_RSAKeyValue;
 308             m_pos_ECKeyValue=m_pos_RSAKeyValue;
 309             ++m_pos_ECKeyValue;
 310             m_pos_UnknownXMLObject=m_pos_ECKeyValue;
 311             ++m_pos_UnknownXMLObject;
 312         }
 313
 314     public:
 315         virtual ~KeyValueImpl() {}
 316
 317         KeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 318                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 319             init();
 320         }
 321
 322         KeyValueImpl(const KeyValueImpl& src)
 323                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 324             init();
 325             if (src.getDSAKeyValue())
 326                 setDSAKeyValue(src.getDSAKeyValue()->cloneDSAKeyValue());
 327             if (src.getRSAKeyValue())
 328                 setRSAKeyValue(src.getRSAKeyValue()->cloneRSAKeyValue());
 329             if (src.getECKeyValue())
 330                 setECKeyValue(src.getECKeyValue()->cloneECKeyValue());
 331             if (src.getUnknownXMLObject())
 332                 setUnknownXMLObject(src.getUnknownXMLObject()->clone());
 333         }
 334
 335         IMPL_XMLOBJECT_CLONE(KeyValue);
 336         IMPL_TYPED_CHILD(DSAKeyValue);
 337         IMPL_TYPED_CHILD(RSAKeyValue);
 338         IMPL_TYPED_CHILD(ECKeyValue);
 339         IMPL_XMLOBJECT_CHILD(UnknownXMLObject);
 340
 341     protected:
 342         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 343             PROC_TYPED_CHILD(DSAKeyValue,XMLSIG_NS,false);
 344             PROC_TYPED_CHILD(RSAKeyValue,XMLSIG_NS,false);
 345             PROC_TYPED_CHILD(ECKeyValue,XMLSIG11_NS,false);
 346
 347             // Unknown child.
 348             const XMLCh* nsURI=root->getNamespaceURI();
 349             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 350                 setUnknownXMLObject(childXMLObject);
 351                 return;
 352             }
 353
 354             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 355         }
 356     };
 357
 358     class XMLTOOL_DLLLOCAL DEREncodedKeyValueImpl : public virtual DEREncodedKeyValue,
 359         public AbstractSimpleElement,
 360         public AbstractDOMCachingXMLObject,
 361         public AbstractXMLObjectMarshaller,
 362         public AbstractXMLObjectUnmarshaller
 363     {
 364     public:
 365         virtual ~DEREncodedKeyValueImpl() {
 366             XMLString::release(&m_Id);
 367         }
 368
 369         DEREncodedKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 370                 : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Id(nullptr) {
 371         }
 372
 373         DEREncodedKeyValueImpl(const DEREncodedKeyValueImpl& src)
 374                 : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src), m_Id(nullptr) {
 375             setId(src.getId());
 376         }
 377
 378         IMPL_XMLOBJECT_CLONE(DEREncodedKeyValue);
 379         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 380
 381     protected:
 382         void marshallAttributes(DOMElement* domElement) const {
 383             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 384         }
 385
 386         void processAttribute(const DOMAttr* attribute) {
 387             PROC_ID_ATTRIB(Id,ID,nullptr);
 388             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 389         }
 390     };
 391
 392     class XMLTOOL_DLLLOCAL TransformImpl : public virtual Transform,
 393         public AbstractComplexElement,
 394         public AbstractDOMCachingXMLObject,
 395         public AbstractXMLObjectMarshaller,
 396         public AbstractXMLObjectUnmarshaller
 397     {
 398     public:
 399         virtual ~TransformImpl() {
 400             XMLString::release(&m_Algorithm);
 401         }
 402
 403         TransformImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 404             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Algorithm(nullptr) {
 405         }
 406
 407         TransformImpl(const TransformImpl& src)
 408                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src), m_Algorithm(nullptr) {
 409             setAlgorithm(src.getAlgorithm());
 410             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 411                 if (*i) {
 412                     XPath* x=dynamic_cast<XPath*>(*i);
 413                     if (x) {
 414                         getXPaths().push_back(x->cloneXPath());
 415                         continue;
 416                     }
 417
 418                     if (*i) {
 419                         getUnknownXMLObjects().push_back((*i)->clone());
 420                     }
 421                 }
 422             }
 423         }
 424
 425         IMPL_XMLOBJECT_CLONE(Transform);
 426         IMPL_STRING_ATTRIB(Algorithm);
 427         IMPL_TYPED_CHILDREN(XPath,m_children.end());
 428         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 429
 430     protected:
 431         void marshallAttributes(DOMElement* domElement) const {
 432             MARSHALL_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 433         }
 434
 435         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 436             PROC_TYPED_CHILDREN(XPath,XMLSIG_NS,false);
 437
 438             // Unknown child.
 439             const XMLCh* nsURI=root->getNamespaceURI();
 440             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 441                 getUnknownXMLObjects().push_back(childXMLObject);
 442                 return;
 443             }
 444
 445             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 446         }
 447
 448         void processAttribute(const DOMAttr* attribute) {
 449             PROC_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 450             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 451         }
 452     };
 453
 454     class XMLTOOL_DLLLOCAL TransformsImpl : public virtual Transforms,
 455         public AbstractComplexElement,
 456         public AbstractDOMCachingXMLObject,
 457         public AbstractXMLObjectMarshaller,
 458         public AbstractXMLObjectUnmarshaller
 459     {
 460     public:
 461         virtual ~TransformsImpl() {}
 462
 463         TransformsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 464             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 465         }
 466
 467         TransformsImpl(const TransformsImpl& src)
 468                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 469             for (vector<Transform*>::const_iterator i=src.m_Transforms.begin(); i!=src.m_Transforms.end(); i++) {
 470                 if (*i) {
 471                     getTransforms().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         void init() {
 493             m_URI=m_Type=nullptr;
 494             m_Transforms=nullptr;
 495             m_children.push_back(nullptr);
 496             m_pos_Transforms=m_children.begin();
 497         }
 498
 499     public:
 500         virtual ~RetrievalMethodImpl() {
 501             XMLString::release(&m_URI);
 502             XMLString::release(&m_Type);
 503         }
 504
 505         RetrievalMethodImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 506             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 507             init();
 508         }
 509
 510         RetrievalMethodImpl(const RetrievalMethodImpl& src)
 511                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 512             init();
 513             setURI(src.getURI());
 514             setType(src.getType());
 515             if (src.getTransforms())
 516                 setTransforms(src.getTransforms()->cloneTransforms());
 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         void init() {
 549             m_X509IssuerName=nullptr;
 550             m_X509SerialNumber=nullptr;
 551             m_children.push_back(nullptr);
 552             m_children.push_back(nullptr);
 553             m_pos_X509IssuerName=m_children.begin();
 554             m_pos_X509SerialNumber=m_pos_X509IssuerName;
 555             ++m_pos_X509SerialNumber;
 556         }
 557
 558     public:
 559         virtual ~X509IssuerSerialImpl() {}
 560
 561         X509IssuerSerialImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 562                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 563             init();
 564         }
 565
 566         X509IssuerSerialImpl(const X509IssuerSerialImpl& src)
 567                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 568             init();
 569             if (src.getX509IssuerName())
 570                 setX509IssuerName(src.getX509IssuerName()->cloneX509IssuerName());
 571             if (src.getX509SerialNumber())
 572                 setX509SerialNumber(src.getX509SerialNumber()->cloneX509SerialNumber());
 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                     if (*i) {
 682                         getUnknownXMLObjects().push_back((*i)->clone());
 683                     }
 684                 }
 685             }
 686         }
 687
 688         IMPL_XMLOBJECT_CLONE(X509Data);
 689         IMPL_TYPED_CHILDREN(X509IssuerSerial,m_children.end());
 690         IMPL_TYPED_CHILDREN(X509SKI,m_children.end());
 691         IMPL_TYPED_CHILDREN(X509SubjectName,m_children.end());
 692         IMPL_TYPED_CHILDREN(X509Certificate,m_children.end());
 693         IMPL_TYPED_CHILDREN(X509CRL,m_children.end());
 694         IMPL_TYPED_CHILDREN(X509Digest,m_children.end());
 695         IMPL_TYPED_CHILDREN(OCSPResponse,m_children.end());
 696         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 697
 698     protected:
 699         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 700             PROC_TYPED_CHILDREN(X509IssuerSerial,XMLSIG_NS,false);
 701             PROC_TYPED_CHILDREN(X509SKI,XMLSIG_NS,false);
 702             PROC_TYPED_CHILDREN(X509SubjectName,XMLSIG_NS,false);
 703             PROC_TYPED_CHILDREN(X509Certificate,XMLSIG_NS,false);
 704             PROC_TYPED_CHILDREN(X509CRL,XMLSIG_NS,false);
 705             PROC_TYPED_CHILDREN(X509Digest,XMLSIG11_NS,false);
 706             PROC_TYPED_CHILDREN(OCSPResponse,XMLSIG11_NS,false);
 707
 708             // Unknown child.
 709             const XMLCh* nsURI=root->getNamespaceURI();
 710             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 711                 getUnknownXMLObjects().push_back(childXMLObject);
 712                 return;
 713             }
 714
 715             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 716         }
 717     };
 718
 719     class XMLTOOL_DLLLOCAL SPKIDataImpl : public virtual SPKIData,
 720         public AbstractComplexElement,
 721         public AbstractDOMCachingXMLObject,
 722         public AbstractXMLObjectMarshaller,
 723         public AbstractXMLObjectUnmarshaller
 724     {
 725         vector< pair<SPKISexp*,XMLObject*> > m_SPKISexps;
 726
 727     public:
 728         virtual ~SPKIDataImpl() {}
 729
 730         SPKIDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 731             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 732         }
 733
 734         SPKIDataImpl(const SPKIDataImpl& src)
 735                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 736             for (vector< pair<SPKISexp*,XMLObject*> >::const_iterator i=src.m_SPKISexps.begin(); i!=src.m_SPKISexps.end(); i++) {
 737                 if (i->first) {
 738                     getSPKISexps().push_back(make_pair(i->first->cloneSPKISexp(),(i->second ? i->second->clone() : (XMLObject*)nullptr)));
 739                 }
 740             }
 741         }
 742
 743         IMPL_XMLOBJECT_CLONE(SPKIData);
 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         void init() {
 788             m_PGPKeyID=nullptr;
 789             m_PGPKeyPacket=nullptr;
 790             m_children.push_back(nullptr);
 791             m_children.push_back(nullptr);
 792             m_pos_PGPKeyID=m_children.begin();
 793             m_pos_PGPKeyPacket=m_pos_PGPKeyID;
 794             ++m_pos_PGPKeyPacket;
 795         }
 796
 797     public:
 798         virtual ~PGPDataImpl() {}
 799
 800         PGPDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 801                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 802             init();
 803         }
 804
 805         PGPDataImpl(const PGPDataImpl& src)
 806                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 807             init();
 808             if (src.getPGPKeyID())
 809                 setPGPKeyID(src.getPGPKeyID()->clonePGPKeyID());
 810             if (src.getPGPKeyPacket())
 811                 setPGPKeyPacket(src.getPGPKeyPacket()->clonePGPKeyPacket());
 812             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i) {
 813                 if (*i) {
 814                     getUnknownXMLObjects().push_back((*i)->clone());
 815                 }
 816             }
 817         }
 818
 819         IMPL_XMLOBJECT_CLONE(PGPData);
 820         IMPL_TYPED_CHILD(PGPKeyID);
 821         IMPL_TYPED_CHILD(PGPKeyPacket);
 822         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 823
 824     protected:
 825         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 826             PROC_TYPED_CHILD(PGPKeyID,XMLSIG_NS,false);
 827             PROC_TYPED_CHILD(PGPKeyPacket,XMLSIG_NS,false);
 828
 829             // Unknown child.
 830             const XMLCh* nsURI=root->getNamespaceURI();
 831             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 832                 getUnknownXMLObjects().push_back(childXMLObject);
 833                 return;
 834             }
 835
 836             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 837         }
 838     };
 839
 840     class XMLTOOL_DLLLOCAL KeyInfoReferenceImpl : public virtual KeyInfoReference,
 841         public AbstractComplexElement,
 842         public AbstractDOMCachingXMLObject,
 843         public AbstractXMLObjectMarshaller,
 844         public AbstractXMLObjectUnmarshaller
 845     {
 846         void init() {
 847             m_Id=m_URI=nullptr;
 848         }
 849
 850     public:
 851         virtual ~KeyInfoReferenceImpl() {
 852             XMLString::release(&m_Id);
 853             XMLString::release(&m_URI);
 854         }
 855
 856         KeyInfoReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 857             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 858             init();
 859         }
 860
 861         KeyInfoReferenceImpl(const KeyInfoReferenceImpl& src)
 862                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 863             init();
 864             setId(src.getId());
 865             setURI(src.getURI());
 866         }
 867
 868         IMPL_XMLOBJECT_CLONE(KeyInfoReference);
 869         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 870         IMPL_STRING_ATTRIB(URI);
 871
 872     protected:
 873         void marshallAttributes(DOMElement* domElement) const {
 874             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 875             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 876         }
 877
 878         void processAttribute(const DOMAttr* attribute) {
 879             PROC_ID_ATTRIB(Id,ID,nullptr);
 880             PROC_STRING_ATTRIB(URI,URI,nullptr);
 881             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 882         }
 883     };
 884
 885     class XMLTOOL_DLLLOCAL KeyInfoImpl : public virtual KeyInfo,
 886         public AbstractComplexElement,
 887         public AbstractDOMCachingXMLObject,
 888         public AbstractXMLObjectMarshaller,
 889         public AbstractXMLObjectUnmarshaller
 890     {
 891     public:
 892         virtual ~KeyInfoImpl() {
 893             XMLString::release(&m_Id);
 894         }
 895
 896         KeyInfoImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 897             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Id(nullptr) {
 898         }
 899
 900         KeyInfoImpl(const KeyInfoImpl& src)
 901                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src), m_Id(nullptr) {
 902             setId(src.getId());
 903             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 904                 if (*i) {
 905                     X509Data* xd=dynamic_cast<X509Data*>(*i);
 906                     if (xd) {
 907                         getX509Datas().push_back(xd->cloneX509Data());
 908                         continue;
 909                     }
 910
 911                     KeyName* kn=dynamic_cast<KeyName*>(*i);
 912                     if (kn) {
 913                         getKeyNames().push_back(kn->cloneKeyName());
 914                         continue;
 915                     }
 916
 917                     KeyValue* kv=dynamic_cast<KeyValue*>(*i);
 918                     if (kv) {
 919                         getKeyValues().push_back(kv->cloneKeyValue());
 920                         continue;
 921                     }
 922
 923                     DEREncodedKeyValue* ekv=dynamic_cast<DEREncodedKeyValue*>(*i);
 924                     if (ekv) {
 925                         getDEREncodedKeyValues().push_back(ekv->cloneDEREncodedKeyValue());
 926                         continue;
 927                     }
 928
 929                     RetrievalMethod* rm=dynamic_cast<RetrievalMethod*>(*i);
 930                     if (rm) {
 931                         getRetrievalMethods().push_back(rm->cloneRetrievalMethod());
 932                         continue;
 933                     }
 934
 935                     MgmtData* md=dynamic_cast<MgmtData*>(*i);
 936                     if (md) {
 937                         getMgmtDatas().push_back(md->cloneMgmtData());
 938                         continue;
 939                     }
 940
 941                     SPKIData* sd=dynamic_cast<SPKIData*>(*i);
 942                     if (sd) {
 943                         getSPKIDatas().push_back(sd->cloneSPKIData());
 944                         continue;
 945                     }
 946
 947                     PGPData* pd=dynamic_cast<PGPData*>(*i);
 948                     if (pd) {
 949                         getPGPDatas().push_back(pd->clonePGPData());
 950                         continue;
 951                     }
 952
 953                     KeyInfoReference* kref=dynamic_cast<KeyInfoReference*>(*i);
 954                     if (kref) {
 955                         getKeyInfoReferences().push_back(kref->cloneKeyInfoReference());
 956                         continue;
 957                     }
 958
 959                     if (*i) {
 960                         getUnknownXMLObjects().push_back((*i)->clone());
 961                     }
 962                 }
 963             }
 964         }
 965
 966         IMPL_XMLOBJECT_CLONE(KeyInfo);
 967         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 968         IMPL_TYPED_CHILDREN(KeyName,m_children.end());
 969         IMPL_TYPED_CHILDREN(KeyValue,m_children.end());
 970         IMPL_TYPED_CHILDREN(DEREncodedKeyValue,m_children.end());
 971         IMPL_TYPED_CHILDREN(RetrievalMethod,m_children.end());
 972         IMPL_TYPED_CHILDREN(X509Data,m_children.end());
 973         IMPL_TYPED_CHILDREN(MgmtData,m_children.end());
 974         IMPL_TYPED_CHILDREN(SPKIData,m_children.end());
 975         IMPL_TYPED_CHILDREN(PGPData,m_children.end());
 976         IMPL_TYPED_CHILDREN(KeyInfoReference,m_children.end());
 977         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 978
 979     protected:
 980         void marshallAttributes(DOMElement* domElement) const {
 981             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 982         }
 983
 984         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 985             PROC_TYPED_CHILDREN(X509Data,XMLSIG_NS,false);
 986             PROC_TYPED_CHILDREN(KeyName,XMLSIG_NS,false);
 987             PROC_TYPED_CHILDREN(KeyValue,XMLSIG_NS,false);
 988             PROC_TYPED_CHILDREN(DEREncodedKeyValue,XMLSIG11_NS,false);
 989             PROC_TYPED_CHILDREN(RetrievalMethod,XMLSIG_NS,false);
 990             PROC_TYPED_CHILDREN(MgmtData,XMLSIG_NS,false);
 991             PROC_TYPED_CHILDREN(SPKIData,XMLSIG_NS,false);
 992             PROC_TYPED_CHILDREN(PGPData,XMLSIG_NS,false);
 993             PROC_TYPED_CHILDREN(KeyInfoReference,XMLSIG11_NS,false);
 994
 995             // Unknown child.
 996             const XMLCh* nsURI=root->getNamespaceURI();
 997             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 998                 getUnknownXMLObjects().push_back(childXMLObject);
 999                 return;
1000             }
1001
1002             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
1003         }
1004
1005         void processAttribute(const DOMAttr* attribute) {
1006             PROC_ID_ATTRIB(Id,ID,nullptr);
1007             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
1008         }
1009     };
1010
1011     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,KeyName);
1012     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,MgmtData);
1013     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Modulus);
1014     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Exponent);
1015     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Seed);
1016     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PgenCounter);
1017     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,P);
1018     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Q);
1019     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,G);
1020     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Y);
1021     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,J);
1022     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,XPath);
1023     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509IssuerName);
1024     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SerialNumber);
1025     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SKI);
1026     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SubjectName);
1027     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509Certificate);
1028     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509CRL);
1029     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,SPKISexp);
1030     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyID);
1031     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyPacket);
1032
1033     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,OCSPResponse);
1034     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PublicKey);
1035 };
1036
1037 #if defined (_MSC_VER)
1038     #pragma warning( pop )
1039 #endif
1040
1041 // Builder Implementations
1042
1043 IMPL_XMLOBJECTBUILDER(X509IssuerSerial);
1044 IMPL_XMLOBJECTBUILDER(X509IssuerName);
1045 IMPL_XMLOBJECTBUILDER(X509SerialNumber);
1046 IMPL_XMLOBJECTBUILDER(X509SKI);
1047 IMPL_XMLOBJECTBUILDER(X509SubjectName);
1048 IMPL_XMLOBJECTBUILDER(X509Certificate);
1049 IMPL_XMLOBJECTBUILDER(X509CRL);
1050 IMPL_XMLOBJECTBUILDER(X509Data);
1051 IMPL_XMLOBJECTBUILDER(XPath);
1052 IMPL_XMLOBJECTBUILDER(Transform);
1053 IMPL_XMLOBJECTBUILDER(Transforms);
1054 IMPL_XMLOBJECTBUILDER(RetrievalMethod);
1055 IMPL_XMLOBJECTBUILDER(KeyName);
1056 IMPL_XMLOBJECTBUILDER(MgmtData);
1057 IMPL_XMLOBJECTBUILDER(Modulus);
1058 IMPL_XMLOBJECTBUILDER(Exponent);
1059 IMPL_XMLOBJECTBUILDER(Seed);
1060 IMPL_XMLOBJECTBUILDER(PgenCounter);
1061 IMPL_XMLOBJECTBUILDER(P);
1062 IMPL_XMLOBJECTBUILDER(Q);
1063 IMPL_XMLOBJECTBUILDER(G);
1064 IMPL_XMLOBJECTBUILDER(Y);
1065 IMPL_XMLOBJECTBUILDER(J);
1066 IMPL_XMLOBJECTBUILDER(DSAKeyValue);
1067 IMPL_XMLOBJECTBUILDER(RSAKeyValue);
1068 IMPL_XMLOBJECTBUILDER(KeyValue);
1069 IMPL_XMLOBJECTBUILDER(KeyInfo);
1070 IMPL_XMLOBJECTBUILDER(SPKISexp);
1071 IMPL_XMLOBJECTBUILDER(SPKIData);
1072 IMPL_XMLOBJECTBUILDER(PGPKeyID);
1073 IMPL_XMLOBJECTBUILDER(PGPKeyPacket);
1074 IMPL_XMLOBJECTBUILDER(PGPData);
1075
1076 IMPL_XMLOBJECTBUILDER(DEREncodedKeyValue);
1077 IMPL_XMLOBJECTBUILDER(ECKeyValue);
1078 IMPL_XMLOBJECTBUILDER(KeyInfoReference);
1079 IMPL_XMLOBJECTBUILDER(NamedCurve);
1080 IMPL_XMLOBJECTBUILDER(OCSPResponse);
1081 IMPL_XMLOBJECTBUILDER(PublicKey);
1082 IMPL_XMLOBJECTBUILDER(X509Digest);
1083
1084 // Unicode literals
1085
1086 const XMLCh KeyInfo::LOCAL_NAME[] =                 UNICODE_LITERAL_7(K,e,y,I,n,f,o);
1087 const XMLCh KeyInfo::TYPE_NAME[] =                  UNICODE_LITERAL_11(K,e,y,I,n,f,o,T,y,p,e);
1088 const XMLCh KeyInfo::ID_ATTRIB_NAME[] =             UNICODE_LITERAL_2(I,d);
1089 const XMLCh KeyValue::LOCAL_NAME[] =                UNICODE_LITERAL_8(K,e,y,V,a,l,u,e);
1090 const XMLCh KeyValue::TYPE_NAME[] =                 UNICODE_LITERAL_12(K,e,y,V,a,l,u,e,T,y,p,e);
1091 const XMLCh DSAKeyValue::LOCAL_NAME[] =             UNICODE_LITERAL_11(D,S,A,K,e,y,V,a,l,u,e);
1092 const XMLCh DSAKeyValue::TYPE_NAME[] =              UNICODE_LITERAL_15(D,S,A,K,e,y,V,a,l,u,e,T,y,p,e);
1093 const XMLCh RSAKeyValue::LOCAL_NAME[] =             UNICODE_LITERAL_11(R,S,A,K,e,y,V,a,l,u,e);
1094 const XMLCh RSAKeyValue::TYPE_NAME[] =              UNICODE_LITERAL_15(R,S,A,K,e,y,V,a,l,u,e,T,y,p,e);
1095 const XMLCh MgmtData::LOCAL_NAME[] =                UNICODE_LITERAL_8(M,g,m,t,D,a,t,a);
1096 const XMLCh KeyName::LOCAL_NAME[] =                 UNICODE_LITERAL_7(K,e,y,N,a,m,e);
1097 const XMLCh Modulus::LOCAL_NAME[] =                 UNICODE_LITERAL_7(M,o,d,u,l,u,s);
1098 const XMLCh Exponent::LOCAL_NAME[] =                UNICODE_LITERAL_8(E,x,p,o,n,e,n,t);
1099 const XMLCh Seed::LOCAL_NAME[] =                    UNICODE_LITERAL_4(S,e,e,d);
1100 const XMLCh PgenCounter::LOCAL_NAME[] =             UNICODE_LITERAL_11(P,g,e,n,C,o,u,n,t,e,r);
1101 const XMLCh P::LOCAL_NAME[] =                       UNICODE_LITERAL_1(P);
1102 const XMLCh Q::LOCAL_NAME[] =                       UNICODE_LITERAL_1(Q);
1103 const XMLCh G::LOCAL_NAME[] =                       UNICODE_LITERAL_1(G);
1104 const XMLCh Y::LOCAL_NAME[] =                       UNICODE_LITERAL_1(Y);
1105 const XMLCh J::LOCAL_NAME[] =                       UNICODE_LITERAL_1(J);
1106 const XMLCh XPath::LOCAL_NAME[] =                   UNICODE_LITERAL_5(X,P,a,t,h);
1107 const XMLCh Transform::LOCAL_NAME[] =               UNICODE_LITERAL_9(T,r,a,n,s,f,o,r,m);
1108 const XMLCh Transform::TYPE_NAME[] =                UNICODE_LITERAL_13(T,r,a,n,s,f,o,r,m,T,y,p,e);
1109 const XMLCh Transform::ALGORITHM_ATTRIB_NAME[] =    UNICODE_LITERAL_9(A,l,g,o,r,i,t,h,m);
1110 const XMLCh Transforms::LOCAL_NAME[] =              UNICODE_LITERAL_10(T,r,a,n,s,f,o,r,m,s);
1111 const XMLCh Transforms::TYPE_NAME[] =               UNICODE_LITERAL_14(T,r,a,n,s,f,o,r,m,s,T,y,p,e);
1112 const XMLCh RetrievalMethod::LOCAL_NAME[] =         UNICODE_LITERAL_15(R,e,t,r,i,e,v,a,l,M,e,t,h,o,d);
1113 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);
1114 const XMLCh RetrievalMethod::URI_ATTRIB_NAME[] =    UNICODE_LITERAL_3(U,R,I);
1115 const XMLCh RetrievalMethod::TYPE_ATTRIB_NAME[] =   UNICODE_LITERAL_4(T,y,p,e);
1116 const XMLCh SPKISexp::LOCAL_NAME[] =                UNICODE_LITERAL_8(S,P,K,I,S,e,x,p);
1117 const XMLCh SPKIData::LOCAL_NAME[] =                UNICODE_LITERAL_8(S,P,K,I,D,a,t,a);
1118 const XMLCh SPKIData::TYPE_NAME[] =                 UNICODE_LITERAL_12(S,P,K,I,D,a,t,a,T,y,p,e);
1119 const XMLCh PGPKeyID::LOCAL_NAME[] =                UNICODE_LITERAL_8(P,G,P,K,e,y,I,D);
1120 const XMLCh PGPKeyPacket::LOCAL_NAME[] =            UNICODE_LITERAL_12(P,G,P,K,e,y,P,a,c,k,e,t);
1121 const XMLCh PGPData::LOCAL_NAME[] =                 UNICODE_LITERAL_7(P,G,P,D,a,t,a);
1122 const XMLCh PGPData::TYPE_NAME[] =                  UNICODE_LITERAL_11(P,G,P,D,a,t,a,T,y,p,e);
1123
1124 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);
1125 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);
1126 const XMLCh DEREncodedKeyValue::ID_ATTRIB_NAME[] =  UNICODE_LITERAL_2(I,d);
1127 const XMLCh ECKeyValue::LOCAL_NAME[] =              UNICODE_LITERAL_10(E,C,K,e,y,V,a,l,u,e);
1128 const XMLCh ECKeyValue::TYPE_NAME[] =               UNICODE_LITERAL_14(E,C,K,e,y,V,a,l,u,e,T,y,p,e);
1129 const XMLCh ECKeyValue::ID_ATTRIB_NAME[] =          UNICODE_LITERAL_2(I,d);
1130 const XMLCh KeyInfoReference::LOCAL_NAME[] =        UNICODE_LITERAL_16(K,e,y,I,n,f,o,R,e,f,e,r,e,n,c,e);
1131 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);
1132 const XMLCh KeyInfoReference::ID_ATTRIB_NAME[] =    UNICODE_LITERAL_2(I,d);
1133 const XMLCh KeyInfoReference::URI_ATTRIB_NAME[] =   UNICODE_LITERAL_3(U,R,I);
1134 const XMLCh NamedCurve::LOCAL_NAME[] =              UNICODE_LITERAL_10(N,a,m,e,d,C,u,r,v,e);
1135 const XMLCh NamedCurve::TYPE_NAME[] =               UNICODE_LITERAL_14(N,a,m,e,d,C,u,r,v,e,T,y,p,e);
1136 const XMLCh NamedCurve::URI_ATTRIB_NAME[] =         UNICODE_LITERAL_3(U,R,I);
1137 const XMLCh OCSPResponse::LOCAL_NAME[] =            UNICODE_LITERAL_12(O,C,S,P,R,e,s,p,o,n,s,e);
1138 const XMLCh PublicKey::LOCAL_NAME[] =               UNICODE_LITERAL_9(P,u,b,l,i,c,K,e,y);
1139 const XMLCh X509Digest::ALGORITHM_ATTRIB_NAME[] =   UNICODE_LITERAL_9(A,l,g,o,r,i,t,h,m);
1140
1141 #define XCH(ch) chLatin_##ch
1142 #define XNUM(d) chDigit_##d
1143
1144 const XMLCh X509Data::LOCAL_NAME[] = {
1145     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(D), XCH(a), XCH(t), XCH(a), chNull
1146     };
1147 const XMLCh X509Data::TYPE_NAME[] = {
1148     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
1149     };
1150 const XMLCh X509IssuerSerial::LOCAL_NAME[] = {
1151     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
1152     XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l), chNull
1153     };
1154 const XMLCh X509IssuerSerial::TYPE_NAME[] = {
1155     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
1156     XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l), XCH(T), XCH(y), XCH(p), XCH(e), chNull
1157     };
1158 const XMLCh X509IssuerName::LOCAL_NAME[] = {
1159     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
1160     XCH(N), XCH(a), XCH(m), XCH(e), chNull
1161     };
1162 const XMLCh X509SerialNumber::LOCAL_NAME[] = {
1163     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l),
1164     XCH(N), XCH(u), XCH(m), XCH(b), XCH(e), XCH(r), chNull
1165     };
1166 const XMLCh X509SKI::LOCAL_NAME[] = { XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(K), XCH(I), chNull };
1167 const XMLCh X509SubjectName::LOCAL_NAME[] = {
1168     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(u), XCH(b), XCH(j), XCH(e), XCH(c), XCH(t),
1169     XCH(N), XCH(a), XCH(m), XCH(e), chNull
1170     };
1171 const XMLCh X509Certificate::LOCAL_NAME[] = {
1172     XCH(X), XNUM(5), XNUM(0), XNUM(9),
1173     XCH(C), XCH(e), XCH(r), XCH(t), XCH(i), XCH(f), XCH(i), XCH(c), XCH(a), XCH(t), XCH(e), chNull
1174     };
1175 const XMLCh X509CRL::LOCAL_NAME[] = { XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(C), XCH(R), XCH(L), chNull };
1176 const XMLCh X509Digest::LOCAL_NAME[] = {
1177     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(D), XCH(i), XCH(g), XCH(e), XCH(s), XCH(t), chNull
1178     };
1179 const XMLCh X509Digest::TYPE_NAME[] = {
1180     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
1181     };
1182
1183 const XMLCh RetrievalMethod::TYPE_DSAKEYVALUE[] = {
1184     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
1185     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
1186     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
1187     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
1188     chLatin_D, chLatin_S, chLatin_A, chLatin_K, chLatin_e, chLatin_y, chLatin_V, chLatin_a, chLatin_l, chLatin_u, chLatin_e, chNull
1189     };
1190
1191 const XMLCh RetrievalMethod::TYPE_RSAKEYVALUE[] = {
1192     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
1193     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
1194     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
1195     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
1196     chLatin_R, chLatin_S, chLatin_A, chLatin_K, chLatin_e, chLatin_y, chLatin_V, chLatin_a, chLatin_l, chLatin_u, chLatin_e, chNull
1197     };
1198
1199 const XMLCh RetrievalMethod::TYPE_X509DATA[] = {
1200     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
1201     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
1202     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
1203     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
1204     chLatin_X, chDigit_5, chDigit_0, chDigit_9, chLatin_D, chLatin_a, chLatin_t, chLatin_a, chNull
1205     };