xmltooling/signature/impl/KeyInfoImpl.cpp

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