vcore/vcore/SignatureReader.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   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  * @file        SignatureReader.cpp
  18  * @author      Bartlomiej Grzelewski (b.grzelewski@samsung.com)
  19  * @version     1.0
  20  * @brief       SignatureReader is used to parse widget digital signature.
  21  */
  22 #include <vcore/SignatureReader.h>
  23
  24 #include <vcore/CertificateLoader.h>
  25
  26 namespace ValidationCore {
  27 static const std::string XML_NAMESPACE =
  28     "http://www.w3.org/2000/09/xmldsig#";
  29 static const std::string XML_NAMESPACE_DIGITALSIG =
  30     "http://wacapps.net/ns/digsig";
  31 static const std::string XML_OBJ_NS =
  32     "http://www.w3.org/2009/xmldsig-properties";
  33
  34 // TAG TOKENS
  35 static const std::string TOKEN_SIGNATURE = "Signature";
  36 static const std::string TOKEN_SIGNED_INFO = "SignedInfo";
  37 static const std::string TOKEN_CANONICALIZATION_METHOD =
  38     "CanonicalizationMethod";
  39 static const std::string TOKEN_SIGNATURE_METHOD = "SignatureMethod";
  40 static const std::string TOKEN_REFERENCE = "Reference";
  41 static const std::string TOKEN_TRANSFORMS = "Transforms";
  42 static const std::string TOKEN_TRANSFORM = "Transform";
  43 static const std::string TOKEN_DIGEST_METHOD = "DigestMethod";
  44 static const std::string TOKEN_DIGEST_VALUE = "DigestValue";
  45 static const std::string TOKEN_SIGNATURE_VALUE = "SignatureValue";
  46 static const std::string TOKEN_KEY_INFO = "KeyInfo";
  47 static const std::string TOKEN_X509DATA = "X509Data";
  48 static const std::string TOKEN_X509CERTIFICATE = "X509Certificate";
  49 static const std::string TOKEN_KEY_VALUE = "KeyValue";
  50 static const std::string TOKEN_RSA_KEY_VALUE = "RSAKeyValue";
  51 static const std::string TOKEN_MODULUS_COMPONENT = "Modulus";
  52 static const std::string TOKEN_EXPONENT_COMPONENT = "Exponent";
  53 static const std::string TOKEN_ECKEY_VALUE = "ECKeyValue";
  54 static const std::string TOKEN_NAMED_CURVE = "NamedCurve";
  55 static const std::string TOKEN_PUBLIC_KEY = "PublicKey";
  56 static const std::string TOKEN_OBJECT = "Object";
  57 static const std::string TOKEN_SIGNATURE_PROPERTIES = "SignatureProperties";
  58 static const std::string TOKEN_SIGNATURE_PROPERTY = "SignatureProperty";
  59 static const std::string TOKEN_PROFILE = "Profile";
  60 static const std::string TOKEN_ROLE = "Role";
  61 static const std::string TOKEN_IDENTIFIER = "Identifier";
  62 static const std::string TOKEN_DSAKEYVALUE = "DSAKeyValue";
  63 static const std::string TOKEN_DSA_P_COMPONENT = "P";
  64 static const std::string TOKEN_DSA_Q_COMPONENT = "Q";
  65 static const std::string TOKEN_DSA_G_COMPONENT = "G";
  66 static const std::string TOKEN_DSA_Y_COMPONENT = "Y";
  67 static const std::string TOKEN_DSA_J_COMPONENT = "J";
  68 static const std::string TOKEN_DSA_SEED_COMPONENT = "Seed";
  69 static const std::string TOKEN_DSA_PGENCOUNTER_COMPONENT = "PgenCounter";
  70 static const std::string TOKEN_TARGET_RESTRICTION = "TargetRestriction";
  71
  72 // ATTRIBUTTE TOKENS
  73
  74 static const std::string TOKEN_ALGORITHM = "Algorithm";
  75 static const std::string TOKEN_URI = "URI";
  76 static const std::string TOKEN_ID = "Id";
  77 static const std::string TOKEN_TARGET = "Target";
  78 static const std::string TOKEN_IMEI = "IMEI";
  79 static const std::string TOKEN_MEID = "MEID";
  80
  81 // ATTIRUBTE VALUES
  82
  83 static const std::string TOKEN_ATTR_PROFILE = "profile";
  84 static const std::string TOKEN_ATTR_ROLE = "role";
  85 static const std::string TOKEN_ATTR_IDENTIFIER = "identifier";
  86
  87 // ALGORITHMS
  88
  89 //static const std::string TOKEN_ALGORITHM_XML_EXC_CAN   =
  90 //            "http://www.w3.org/2001/10/xml-exc-c14n#";
  91 //static const std::string TOKEN_ALGORITHM_RSA_SHA256    =
  92 //            "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256";
  93 //static const std::string TOKEN_ALGORITHM_DSA_SHA1      =
  94 //            "http://www.w3.org/2000/09/xmldsig#dsa-sha1";
  95 //static const std::string TOKEN_ALGORITHM_ECDSA_SHA256  =
  96 //            "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256";
  97 //static const std::string TOKEN_ALGORITHM_SHA1          =
  98 //            "http://www.w3.org/2000/09/xmldsig#sha1";
  99 //static const std::string TOKEN_ALGORITHM_SHA256        =
 100 //            "http://www.w3.org/2001/04/xmlenc#sha256";
 101 //static const std::string TOKEN_ALGORITHM_SHA384        =
 102 //            "http://www.w3.org/2001/04/xmldsig-more#sha384";
 103 //static const std::string TOKEN_ALGORITHM_SHA512        =
 104 //            "http://www.w3.org/2001/04/xmlenc#sha512";
 105
 106 SignatureReader::SignatureReader() :
 107     m_signaturePropertiesCounter(0),
 108     m_targetRestrictionObjectFound(false),
 109     m_parserSchema(this)
 110 {
 111     /**
 112      * member func pointers map
 113      */
 114     m_parserSchema.addBeginTagCallback(TOKEN_SIGNATURE,
 115                                        XML_NAMESPACE,
 116                                        &SignatureReader::blankFunction);
 117     m_parserSchema.addBeginTagCallback(TOKEN_SIGNED_INFO,
 118                                        XML_NAMESPACE,
 119                                        &SignatureReader::blankFunction);
 120     m_parserSchema.addBeginTagCallback(TOKEN_CANONICALIZATION_METHOD,
 121                                        XML_NAMESPACE,
 122                                        &SignatureReader::blankFunction);
 123     m_parserSchema.addBeginTagCallback(TOKEN_SIGNATURE_METHOD,
 124                                        XML_NAMESPACE,
 125                                        &SignatureReader::blankFunction);
 126     m_parserSchema.addBeginTagCallback(TOKEN_REFERENCE,
 127                                        XML_NAMESPACE,
 128                                        &SignatureReader::blankFunction);
 129     m_parserSchema.addBeginTagCallback(TOKEN_TRANSFORMS,
 130                                        XML_NAMESPACE,
 131                                        &SignatureReader::blankFunction);
 132     m_parserSchema.addBeginTagCallback(TOKEN_TRANSFORM,
 133                                        XML_NAMESPACE,
 134                                        &SignatureReader::blankFunction);
 135     m_parserSchema.addBeginTagCallback(TOKEN_DIGEST_METHOD,
 136                                        XML_NAMESPACE,
 137                                        &SignatureReader::blankFunction);
 138     m_parserSchema.addBeginTagCallback(TOKEN_DIGEST_VALUE,
 139                                        XML_NAMESPACE,
 140                                        &SignatureReader::blankFunction);
 141     m_parserSchema.addBeginTagCallback(TOKEN_SIGNATURE_VALUE,
 142                                        XML_NAMESPACE,
 143                                        &SignatureReader::blankFunction);
 144     m_parserSchema.addBeginTagCallback(TOKEN_KEY_INFO,
 145                                        XML_NAMESPACE,
 146                                        &SignatureReader::tokenKeyInfo);
 147     m_parserSchema.addBeginTagCallback(TOKEN_X509DATA,
 148                                        XML_NAMESPACE,
 149                                        &SignatureReader::tokenX509Data);
 150     m_parserSchema.addBeginTagCallback(TOKEN_X509CERTIFICATE,
 151                                        XML_NAMESPACE,
 152                                        &SignatureReader::tokenX509Certificate);
 153     m_parserSchema.addBeginTagCallback(TOKEN_ECKEY_VALUE,
 154                                        XML_NAMESPACE,
 155                                        &SignatureReader::blankFunction);
 156     m_parserSchema.addBeginTagCallback(TOKEN_NAMED_CURVE,
 157                                        XML_NAMESPACE,
 158                                        &SignatureReader::tokenNamedCurve);
 159     m_parserSchema.addBeginTagCallback(TOKEN_PUBLIC_KEY,
 160                                        XML_NAMESPACE,
 161                                        &SignatureReader::tokenPublicKey);
 162     m_parserSchema.addBeginTagCallback(TOKEN_OBJECT,
 163                                        XML_NAMESPACE,
 164                                        &SignatureReader::tokenObject);
 165     m_parserSchema.addBeginTagCallback(TOKEN_SIGNATURE_PROPERTIES,
 166                                        XML_NAMESPACE,
 167                                        &SignatureReader::tokenSignatureProperties);
 168     m_parserSchema.addBeginTagCallback(TOKEN_SIGNATURE_PROPERTY,
 169                                        XML_NAMESPACE,
 170                                        &SignatureReader::blankFunction);
 171     m_parserSchema.addBeginTagCallback(TOKEN_PROFILE,
 172                                        XML_OBJ_NS,
 173                                        &SignatureReader::tokenProfile);
 174     m_parserSchema.addBeginTagCallback(TOKEN_ROLE,
 175                                        XML_OBJ_NS,
 176                                        &SignatureReader::tokenRole);
 177     m_parserSchema.addBeginTagCallback(TOKEN_IDENTIFIER,
 178                                        XML_OBJ_NS,
 179                                        &SignatureReader::blankFunction);
 180     m_parserSchema.addBeginTagCallback(TOKEN_KEY_VALUE,
 181                                        XML_NAMESPACE,
 182                                        &SignatureReader::blankFunction);
 183     m_parserSchema.addBeginTagCallback(TOKEN_DSAKEYVALUE,
 184                                        XML_NAMESPACE,
 185                                        &SignatureReader::blankFunction);
 186     m_parserSchema.addBeginTagCallback(TOKEN_DSA_P_COMPONENT,
 187                                        XML_NAMESPACE,
 188                                        &SignatureReader::blankFunction);
 189     m_parserSchema.addBeginTagCallback(TOKEN_DSA_Q_COMPONENT,
 190                                        XML_NAMESPACE,
 191                                        &SignatureReader::blankFunction);
 192     m_parserSchema.addBeginTagCallback(TOKEN_DSA_G_COMPONENT,
 193                                        XML_NAMESPACE,
 194                                        &SignatureReader::blankFunction);
 195     m_parserSchema.addBeginTagCallback(TOKEN_DSA_Y_COMPONENT,
 196                                        XML_NAMESPACE,
 197                                        &SignatureReader::blankFunction);
 198     m_parserSchema.addBeginTagCallback(TOKEN_DSA_J_COMPONENT,
 199                                        XML_NAMESPACE,
 200                                        &SignatureReader::blankFunction);
 201     m_parserSchema.addBeginTagCallback(TOKEN_DSA_SEED_COMPONENT,
 202                                        XML_NAMESPACE,
 203                                        &SignatureReader::blankFunction);
 204     m_parserSchema.addBeginTagCallback(TOKEN_DSA_PGENCOUNTER_COMPONENT,
 205                                        XML_NAMESPACE,
 206                                        &SignatureReader::blankFunction);
 207     m_parserSchema.addBeginTagCallback(TOKEN_RSA_KEY_VALUE,
 208                                        XML_NAMESPACE,
 209                                        &SignatureReader::blankFunction);
 210     m_parserSchema.addBeginTagCallback(TOKEN_MODULUS_COMPONENT,
 211                                        XML_NAMESPACE,
 212                                        &SignatureReader::blankFunction);
 213     m_parserSchema.addBeginTagCallback(TOKEN_EXPONENT_COMPONENT,
 214                                        XML_NAMESPACE,
 215                                        &SignatureReader::blankFunction);
 216     m_parserSchema.addBeginTagCallback(TOKEN_TARGET_RESTRICTION,
 217                                        XML_NAMESPACE_DIGITALSIG,
 218                                        &SignatureReader::tokenTargetRestriction);
 219
 220     m_parserSchema.addEndTagCallback(TOKEN_SIGNATURE,
 221                                      XML_NAMESPACE,
 222                                      &SignatureReader::blankFunction);
 223     m_parserSchema.addEndTagCallback(TOKEN_SIGNED_INFO,
 224                                      XML_NAMESPACE,
 225                                      &SignatureReader::blankFunction);
 226     m_parserSchema.addEndTagCallback(TOKEN_CANONICALIZATION_METHOD,
 227                                      XML_NAMESPACE,
 228                                      &SignatureReader::blankFunction);
 229     m_parserSchema.addEndTagCallback(TOKEN_SIGNATURE_METHOD,
 230                                      XML_NAMESPACE,
 231                                      &SignatureReader::blankFunction);
 232     m_parserSchema.addEndTagCallback(TOKEN_REFERENCE,
 233                                      XML_NAMESPACE,
 234                                      &SignatureReader::blankFunction);
 235     m_parserSchema.addEndTagCallback(TOKEN_TRANSFORMS,
 236                                      XML_NAMESPACE,
 237                                      &SignatureReader::blankFunction);
 238     m_parserSchema.addEndTagCallback(TOKEN_TRANSFORM,
 239                                      XML_NAMESPACE,
 240                                      &SignatureReader::blankFunction);
 241     m_parserSchema.addEndTagCallback(TOKEN_DIGEST_METHOD,
 242                                      XML_NAMESPACE,
 243                                      &SignatureReader::blankFunction);
 244     m_parserSchema.addEndTagCallback(TOKEN_DIGEST_VALUE,
 245                                      XML_NAMESPACE,
 246                                      &SignatureReader::blankFunction);
 247     m_parserSchema.addEndTagCallback(TOKEN_SIGNATURE_VALUE,
 248                                      XML_NAMESPACE,
 249                                      &SignatureReader::blankFunction);
 250     m_parserSchema.addEndTagCallback(TOKEN_KEY_INFO,
 251                                      XML_NAMESPACE,
 252                                      &SignatureReader::tokenEndKeyInfo);
 253     m_parserSchema.addEndTagCallback(TOKEN_X509DATA,
 254                                      XML_NAMESPACE,
 255                                      &SignatureReader::tokenEndX509Data);
 256     m_parserSchema.addEndTagCallback(TOKEN_X509CERTIFICATE,
 257                                      XML_NAMESPACE,
 258                                      &SignatureReader::tokenEndX509Certificate);
 259     m_parserSchema.addEndTagCallback(TOKEN_ECKEY_VALUE,
 260                                      XML_NAMESPACE,
 261                                      &SignatureReader::tokenEndECKeyValue);
 262     m_parserSchema.addEndTagCallback(TOKEN_PUBLIC_KEY,
 263                                      XML_NAMESPACE,
 264                                      &SignatureReader::tokenEndPublicKey);
 265     m_parserSchema.addEndTagCallback(TOKEN_OBJECT,
 266                                      XML_NAMESPACE,
 267                                      &SignatureReader::tokenEndObject);
 268     m_parserSchema.addEndTagCallback(TOKEN_SIGNATURE_PROPERTIES,
 269                                      XML_NAMESPACE,
 270                                      &SignatureReader::blankFunction);
 271     m_parserSchema.addEndTagCallback(TOKEN_SIGNATURE_PROPERTY,
 272                                      XML_NAMESPACE,
 273                                      &SignatureReader::blankFunction);
 274     m_parserSchema.addEndTagCallback(TOKEN_PROFILE,
 275                                      XML_OBJ_NS,
 276                                      &SignatureReader::blankFunction);
 277     m_parserSchema.addEndTagCallback(TOKEN_ROLE,
 278                                      XML_OBJ_NS,
 279                                      &SignatureReader::blankFunction);
 280     m_parserSchema.addEndTagCallback(TOKEN_IDENTIFIER,
 281                                      XML_OBJ_NS,
 282                                      &SignatureReader::tokenEndIdentifier);
 283     m_parserSchema.addEndTagCallback(TOKEN_KEY_VALUE,
 284                                      XML_NAMESPACE,
 285                                      &SignatureReader::blankFunction);
 286     m_parserSchema.addEndTagCallback(TOKEN_DSAKEYVALUE,
 287                                      XML_NAMESPACE,
 288                                      &SignatureReader::tokenEndDSAKeyValue);
 289     m_parserSchema.addEndTagCallback(TOKEN_DSA_P_COMPONENT,
 290                                      XML_NAMESPACE,
 291                                      &SignatureReader::tokenEndDSAPComponent);
 292     m_parserSchema.addEndTagCallback(TOKEN_DSA_Q_COMPONENT,
 293                                      XML_NAMESPACE,
 294                                      &SignatureReader::tokenEndDSAQComponent);
 295     m_parserSchema.addEndTagCallback(TOKEN_DSA_G_COMPONENT,
 296                                      XML_NAMESPACE,
 297                                      &SignatureReader::tokenEndDSAGComponent);
 298     m_parserSchema.addEndTagCallback(TOKEN_DSA_Y_COMPONENT,
 299                                      XML_NAMESPACE,
 300                                      &SignatureReader::tokenEndDSAYComponent);
 301     m_parserSchema.addEndTagCallback(TOKEN_DSA_J_COMPONENT,
 302                                      XML_NAMESPACE,
 303                                      &SignatureReader::tokenEndDSAJComponent);
 304     m_parserSchema.addEndTagCallback(TOKEN_DSA_SEED_COMPONENT,
 305                                      XML_NAMESPACE,
 306                                      &SignatureReader::tokenEndDSASeedComponent);
 307     m_parserSchema.addEndTagCallback(TOKEN_DSA_PGENCOUNTER_COMPONENT,
 308                                      XML_NAMESPACE,
 309                                      &SignatureReader::tokenEndDSAPGenCounterComponent);
 310     m_parserSchema.addEndTagCallback(TOKEN_RSA_KEY_VALUE,
 311                                      XML_NAMESPACE,
 312                                      &SignatureReader::tokenEndRSAKeyValue);
 313     m_parserSchema.addEndTagCallback(TOKEN_MODULUS_COMPONENT,
 314                                      XML_NAMESPACE,
 315                                      &SignatureReader::tokenEndKeyModulus);
 316     m_parserSchema.addEndTagCallback(TOKEN_EXPONENT_COMPONENT,
 317                                      XML_NAMESPACE,
 318                                      &SignatureReader::tokenEndKeyExponent);
 319     m_parserSchema.addEndTagCallback(TOKEN_TARGET_RESTRICTION,
 320                                      XML_NAMESPACE,
 321                                      &SignatureReader::blankFunction);
 322 }
 323
 324
 325 void SignatureReader::initialize(
 326     SignatureData &signatureData,
 327     const std::string &xmlscheme)
 328 {
 329     m_parserSchema.initialize(
 330             signatureData.getSignatureFileName(),
 331             true,
 332             SaxReader::VALIDATION_XMLSCHEME,
 333             xmlscheme);
 334 }
 335
 336 void SignatureReader::read(SignatureData &signatureData)
 337 {
 338     m_parserSchema.read(signatureData);
 339 }
 340
 341 void SignatureReader::blankFunction(SignatureData &)
 342 {
 343 }
 344
 345 void SignatureReader::tokenKeyInfo(SignatureData &)
 346 {
 347 }
 348
 349 void SignatureReader::tokenX509Data(SignatureData &)
 350 {
 351 }
 352
 353 void SignatureReader::tokenX509Certificate(SignatureData &)
 354 {
 355 }
 356
 357 void SignatureReader::tokenPublicKey(SignatureData &)
 358 {
 359 }
 360
 361 void SignatureReader::tokenNamedCurve(SignatureData &)
 362 {
 363     m_nameCurveURI = m_parserSchema.getReader().attribute(TOKEN_URI);
 364 }
 365
 366 void SignatureReader::tokenTargetRestriction(SignatureData &signatureData)
 367 {
 368     std::string IMEI = m_parserSchema.getReader().attribute(TOKEN_IMEI);
 369     std::string MEID = m_parserSchema.getReader().attribute(TOKEN_MEID);
 370
 371     //less verbose way to say (IMEI && MEID) || (!IMEI && !MEID)
 372     if (IMEI.empty() == MEID.empty()) {
 373         //WAC 2.0 WR-4650 point 4
 374         VcoreThrowMsg(SignatureReader::Exception::TargetRestriction,
 375                       "TargetRestriction should contain exactly one attribute.");
 376     }
 377
 378     if (!IMEI.empty()) {
 379         signatureData.m_imeiList.push_back(IMEI);
 380     }
 381     if (!MEID.empty()) {
 382         signatureData.m_meidList.push_back(MEID);
 383     }
 384 }
 385
 386 void SignatureReader::tokenEndKeyInfo(SignatureData &)
 387 {
 388 }
 389
 390 void SignatureReader::tokenEndX509Data(SignatureData &)
 391 {
 392 }
 393
 394 void SignatureReader::tokenEndX509Certificate(SignatureData &signatureData)
 395 {
 396     CertificateLoader loader;
 397     if (CertificateLoader::NO_ERROR !=
 398         loader.loadCertificateFromRawData(m_parserSchema.getText())) {
 399         fprintf(stderr, "## [validate error]: Certificate could not be loaded\n");
 400         VcoreThrowMsg(ParserSchemaException::CertificateLoaderError,
 401                       "Certificate could not be loaded");
 402     }
 403     signatureData.m_certList.push_back(loader.getCertificatePtr());
 404 }
 405
 406 void SignatureReader::tokenEndRSAKeyValue(SignatureData &signatureData)
 407 {
 408     CertificateLoader loader;
 409     if (CertificateLoader::NO_ERROR !=
 410         loader.loadCertificateBasedOnExponentAndModulus(m_modulus,
 411                                                         m_exponent)) {
 412         fprintf(stderr, "## [validate error]: Certificate could not be loaded\n");
 413         VcoreThrowMsg(ParserSchemaException::CertificateLoaderError,
 414                       "Certificate could not be loaded");
 415     }
 416     signatureData.m_certList.push_back(loader.getCertificatePtr());
 417 }
 418
 419 void SignatureReader::tokenEndKeyModulus(SignatureData &)
 420 {
 421     m_modulus = m_parserSchema.getText();
 422 }
 423
 424 void SignatureReader::tokenEndKeyExponent(SignatureData &)
 425 {
 426     m_exponent = m_parserSchema.getText();
 427 }
 428
 429 void SignatureReader::tokenEndPublicKey(SignatureData &)
 430 {
 431     m_publicKey = m_parserSchema.getText();
 432 }
 433
 434 void SignatureReader::tokenEndECKeyValue(SignatureData &signatureData)
 435 {
 436     CertificateLoader loader;
 437     if (CertificateLoader::NO_ERROR !=
 438         loader.loadCertificateWithECKEY(m_nameCurveURI, m_publicKey)) {
 439         fprintf(stderr, "## [validate error]: Certificate could not be loaded\n");
 440         VcoreThrowMsg(ParserSchemaException::CertificateLoaderError,
 441                       "Certificate could not be loaded");
 442     }
 443     signatureData.m_certList.push_back(loader.getCertificatePtr());
 444 }
 445
 446 void SignatureReader::tokenEndObject(SignatureData &signatureData)
 447 {
 448     m_signaturePropertiesCounter = 0;
 449
 450     if (((!signatureData.m_imeiList.empty()) ||
 451          (!signatureData.m_meidList.empty())) &&
 452         m_targetRestrictionObjectFound) {
 453         //WAC 2.0 WR-4650 point 1
 454         VcoreThrowMsg(SignatureReader::Exception::TargetRestriction,
 455                       "TargetRestriction should contain exactly one ds:Object "
 456                       "containing zero or more wac:TargetRestriction children.");
 457     }
 458
 459     if ((!signatureData.m_imeiList.empty()) ||
 460         (!signatureData.m_meidList.empty())) {
 461         m_targetRestrictionObjectFound = true;
 462     }
 463
 464 }
 465 void SignatureReader::tokenEndDSAPComponent(SignatureData &)
 466 {
 467     m_dsaKeyPComponent = m_parserSchema.getText();
 468 }
 469
 470 void SignatureReader::tokenEndDSAQComponent(SignatureData &)
 471 {
 472     m_dsaKeyQComponent = m_parserSchema.getText();
 473 }
 474
 475 void SignatureReader::tokenEndDSAGComponent(SignatureData &)
 476 {
 477     m_dsaKeyGComponent = m_parserSchema.getText();
 478 }
 479
 480 void SignatureReader::tokenEndDSAYComponent(SignatureData &)
 481 {
 482     m_dsaKeyYComponent = m_parserSchema.getText();
 483 }
 484
 485 void SignatureReader::tokenEndDSAJComponent(SignatureData &)
 486 {
 487     m_dsaKeyJComponent = m_parserSchema.getText();
 488 }
 489
 490 void SignatureReader::tokenEndDSASeedComponent(SignatureData &)
 491 {
 492     m_dsaKeySeedComponent = m_parserSchema.getText();
 493 }
 494
 495 void SignatureReader::tokenEndDSAPGenCounterComponent(SignatureData &)
 496 {
 497     m_dsaKeyPGenCounter = m_parserSchema.getText();
 498 }
 499
 500 void SignatureReader::tokenEndDSAKeyValue(SignatureData &signatureData)
 501 {
 502     CertificateLoader loader;
 503
 504     if (CertificateLoader::NO_ERROR !=
 505         loader.loadCertificateBasedOnDSAComponents(m_dsaKeyPComponent,
 506                                                    m_dsaKeyQComponent,
 507                                                    m_dsaKeyGComponent,
 508                                                    m_dsaKeyYComponent,
 509                                                    m_dsaKeyJComponent,
 510                                                    m_dsaKeySeedComponent,
 511                                                    m_dsaKeyPGenCounter)) {
 512         fprintf(stderr, "## [validate error]: Certificate could not be loaded\n");
 513         VcoreThrowMsg(ParserSchemaException::CertificateLoaderError,
 514                       "Certificate could not be loaded.");
 515     }
 516     signatureData.m_certList.push_back(loader.getCertificatePtr());
 517 }
 518
 519 void SignatureReader::tokenRole(SignatureData &signatureData)
 520 {
 521     if (!signatureData.m_roleURI.empty()) {
 522         fprintf(stderr, "## [validate error]: Multiple definition of Role is not allowed\n");
 523         VcoreThrowMsg(ParserSchemaException::UnsupportedValue,
 524                       "Multiple definition of Role is not allowed.");
 525     }
 526     signatureData.m_roleURI = m_parserSchema.getReader().attribute(TOKEN_URI);
 527 }
 528
 529 void SignatureReader::tokenProfile(SignatureData &signatureData)
 530 {
 531     if (!signatureData.m_profileURI.empty()) {
 532         fprintf(stderr, "## [validate error]: Multiple definition of Profile is not allowed\n");
 533         VcoreThrowMsg(ParserSchemaException::UnsupportedValue,
 534                       "Multiple definition of Profile is not allowed.");
 535     }
 536     signatureData.m_profileURI = m_parserSchema.getReader().attribute(TOKEN_URI);
 537 }
 538
 539 void SignatureReader::tokenEndIdentifier(SignatureData &signatureData)
 540 {
 541     if (!signatureData.m_identifier.empty()) {
 542         fprintf(stderr, "## [validate error]: Multiple definition of Identifier is not allowed\n");
 543         VcoreThrowMsg(ParserSchemaException::UnsupportedValue,
 544                       "Multiple definition of Identifier is not allowed.");
 545     }
 546     signatureData.m_identifier = m_parserSchema.getText();
 547 }
 548
 549 void SignatureReader::tokenObject(SignatureData &signatureData)
 550 {
 551     std::string id = m_parserSchema.getReader().attribute(TOKEN_ID);
 552
 553     if (id.empty()) {
 554         fprintf(stderr, "## [validate error]: Unsupported value of Attribute Id in Object tag\n");
 555         VcoreThrowMsg(ParserSchemaException::UnsupportedValue,
 556                       "Unsupported value of Attribute Id in Object tag.");
 557     }
 558
 559     signatureData.m_objectList.push_back(id);
 560 }
 561
 562 void SignatureReader::tokenSignatureProperties(SignatureData &)
 563 {
 564     if (++m_signaturePropertiesCounter > 1) {
 565         fprintf(stderr, "## [validate error]: Only one SignatureProperties tag is allowed in Object\n");
 566         VcoreThrowMsg(ParserSchemaException::UnsupportedValue,
 567                       "Only one SignatureProperties tag is allowed in Object");
 568     }
 569 }
 570 } // namespace ValidationCore