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