modules/vcore/src/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 "SignatureReader.h"
  23
  24 #include "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(
 166         TOKEN_SIGNATURE_PROPERTIES,
 167         XML_NAMESPACE,
 168         &SignatureReader::
 169             tokenSignatureProperties);
 170     m_parserSchema.addBeginTagCallback(TOKEN_SIGNATURE_PROPERTY,
 171                                        XML_NAMESPACE,
 172                                        &SignatureReader::blankFunction);
 173     m_parserSchema.addBeginTagCallback(TOKEN_PROFILE,
 174                                        XML_OBJ_NS,
 175                                        &SignatureReader::tokenProfile);
 176     m_parserSchema.addBeginTagCallback(TOKEN_ROLE,
 177                                        XML_OBJ_NS,
 178                                        &SignatureReader::tokenRole);
 179     m_parserSchema.addBeginTagCallback(TOKEN_IDENTIFIER,
 180                                        XML_OBJ_NS,
 181                                        &SignatureReader::blankFunction);
 182     m_parserSchema.addBeginTagCallback(TOKEN_KEY_VALUE,
 183                                        XML_NAMESPACE,
 184                                        &SignatureReader::blankFunction);
 185     m_parserSchema.addBeginTagCallback(TOKEN_DSAKEYVALUE,
 186                                        XML_NAMESPACE,
 187                                        &SignatureReader::blankFunction);
 188     m_parserSchema.addBeginTagCallback(TOKEN_DSA_P_COMPONENT,
 189                                        XML_NAMESPACE,
 190                                        &SignatureReader::blankFunction);
 191     m_parserSchema.addBeginTagCallback(TOKEN_DSA_Q_COMPONENT,
 192                                        XML_NAMESPACE,
 193                                        &SignatureReader::blankFunction);
 194     m_parserSchema.addBeginTagCallback(TOKEN_DSA_G_COMPONENT,
 195                                        XML_NAMESPACE,
 196                                        &SignatureReader::blankFunction);
 197     m_parserSchema.addBeginTagCallback(TOKEN_DSA_Y_COMPONENT,
 198                                        XML_NAMESPACE,
 199                                        &SignatureReader::blankFunction);
 200     m_parserSchema.addBeginTagCallback(TOKEN_DSA_J_COMPONENT,
 201                                        XML_NAMESPACE,
 202                                        &SignatureReader::blankFunction);
 203     m_parserSchema.addBeginTagCallback(TOKEN_DSA_SEED_COMPONENT,
 204                                        XML_NAMESPACE,
 205                                        &SignatureReader::blankFunction);
 206     m_parserSchema.addBeginTagCallback(TOKEN_DSA_PGENCOUNTER_COMPONENT,
 207                                        XML_NAMESPACE,
 208                                        &SignatureReader::blankFunction);
 209     m_parserSchema.addBeginTagCallback(TOKEN_RSA_KEY_VALUE,
 210                                        XML_NAMESPACE,
 211                                        &SignatureReader::blankFunction);
 212     m_parserSchema.addBeginTagCallback(TOKEN_MODULUS_COMPONENT,
 213                                        XML_NAMESPACE,
 214                                        &SignatureReader::blankFunction);
 215     m_parserSchema.addBeginTagCallback(TOKEN_EXPONENT_COMPONENT,
 216                                        XML_NAMESPACE,
 217                                        &SignatureReader::blankFunction);
 218     m_parserSchema.addBeginTagCallback(TOKEN_TARGET_RESTRICTION,
 219                                        XML_NAMESPACE_DIGITALSIG,
 220                                        &SignatureReader::tokenTargetRestriction);
 221
 222     m_parserSchema.addEndTagCallback(TOKEN_SIGNATURE,
 223                                      XML_NAMESPACE,
 224                                      &SignatureReader::blankFunction);
 225     m_parserSchema.addEndTagCallback(TOKEN_SIGNED_INFO,
 226                                      XML_NAMESPACE,
 227                                      &SignatureReader::blankFunction);
 228     m_parserSchema.addEndTagCallback(TOKEN_CANONICALIZATION_METHOD,
 229                                      XML_NAMESPACE,
 230                                      &SignatureReader::blankFunction);
 231     m_parserSchema.addEndTagCallback(TOKEN_SIGNATURE_METHOD,
 232                                      XML_NAMESPACE,
 233                                      &SignatureReader::blankFunction);
 234     m_parserSchema.addEndTagCallback(TOKEN_REFERENCE,
 235                                      XML_NAMESPACE,
 236                                      &SignatureReader::blankFunction);
 237     m_parserSchema.addEndTagCallback(TOKEN_TRANSFORMS,
 238                                      XML_NAMESPACE,
 239                                      &SignatureReader::blankFunction);
 240     m_parserSchema.addEndTagCallback(TOKEN_TRANSFORM,
 241                                      XML_NAMESPACE,
 242                                      &SignatureReader::blankFunction);
 243     m_parserSchema.addEndTagCallback(TOKEN_DIGEST_METHOD,
 244                                      XML_NAMESPACE,
 245                                      &SignatureReader::blankFunction);
 246     m_parserSchema.addEndTagCallback(TOKEN_DIGEST_VALUE,
 247                                      XML_NAMESPACE,
 248                                      &SignatureReader::blankFunction);
 249     m_parserSchema.addEndTagCallback(TOKEN_SIGNATURE_VALUE,
 250                                      XML_NAMESPACE,
 251                                      &SignatureReader::blankFunction);
 252     m_parserSchema.addEndTagCallback(TOKEN_KEY_INFO,
 253                                      XML_NAMESPACE,
 254                                      &SignatureReader::tokenEndKeyInfo);
 255     m_parserSchema.addEndTagCallback(TOKEN_X509DATA,
 256                                      XML_NAMESPACE,
 257                                      &SignatureReader::tokenEndX509Data);
 258     m_parserSchema.addEndTagCallback(TOKEN_X509CERTIFICATE,
 259                                      XML_NAMESPACE,
 260                                      &SignatureReader::tokenEndX509Certificate);
 261     m_parserSchema.addEndTagCallback(TOKEN_ECKEY_VALUE,
 262                                      XML_NAMESPACE,
 263                                      &SignatureReader::tokenEndECKeyValue);
 264     m_parserSchema.addEndTagCallback(TOKEN_PUBLIC_KEY,
 265                                      XML_NAMESPACE,
 266                                      &SignatureReader::tokenEndPublicKey);
 267     m_parserSchema.addEndTagCallback(TOKEN_OBJECT,
 268                                      XML_NAMESPACE,
 269                                      &SignatureReader::tokenEndObject);
 270     m_parserSchema.addEndTagCallback(TOKEN_SIGNATURE_PROPERTIES,
 271                                      XML_NAMESPACE,
 272                                      &SignatureReader::blankFunction);
 273     m_parserSchema.addEndTagCallback(TOKEN_SIGNATURE_PROPERTY,
 274                                      XML_NAMESPACE,
 275                                      &SignatureReader::blankFunction);
 276     m_parserSchema.addEndTagCallback(TOKEN_PROFILE,
 277                                      XML_OBJ_NS,
 278                                      &SignatureReader::blankFunction);
 279     m_parserSchema.addEndTagCallback(TOKEN_ROLE,
 280                                      XML_OBJ_NS,
 281                                      &SignatureReader::blankFunction);
 282     m_parserSchema.addEndTagCallback(TOKEN_IDENTIFIER,
 283                                      XML_OBJ_NS,
 284                                      &SignatureReader::tokenEndIdentifier);
 285     m_parserSchema.addEndTagCallback(TOKEN_KEY_VALUE,
 286                                      XML_NAMESPACE,
 287                                      &SignatureReader::blankFunction);
 288     m_parserSchema.addEndTagCallback(TOKEN_DSAKEYVALUE,
 289                                      XML_NAMESPACE,
 290                                      &SignatureReader::tokenEndDSAKeyValue);
 291     m_parserSchema.addEndTagCallback(TOKEN_DSA_P_COMPONENT,
 292                                      XML_NAMESPACE,
 293                                      &SignatureReader::tokenEndDSAPComponent);
 294     m_parserSchema.addEndTagCallback(TOKEN_DSA_Q_COMPONENT,
 295                                      XML_NAMESPACE,
 296                                      &SignatureReader::tokenEndDSAQComponent);
 297     m_parserSchema.addEndTagCallback(TOKEN_DSA_G_COMPONENT,
 298                                      XML_NAMESPACE,
 299                                      &SignatureReader::tokenEndDSAGComponent);
 300     m_parserSchema.addEndTagCallback(TOKEN_DSA_Y_COMPONENT,
 301                                      XML_NAMESPACE,
 302                                      &SignatureReader::tokenEndDSAYComponent);
 303     m_parserSchema.addEndTagCallback(TOKEN_DSA_J_COMPONENT,
 304                                      XML_NAMESPACE,
 305                                      &SignatureReader::tokenEndDSAJComponent);
 306     m_parserSchema.addEndTagCallback(TOKEN_DSA_SEED_COMPONENT,
 307                                      XML_NAMESPACE,
 308                                      &SignatureReader::tokenEndDSASeedComponent);
 309     m_parserSchema.addEndTagCallback(
 310         TOKEN_DSA_PGENCOUNTER_COMPONENT,
 311         XML_NAMESPACE,
 312         &SignatureReader::
 313             tokenEndDSAPGenCounterComponent);
 314     m_parserSchema.addEndTagCallback(TOKEN_RSA_KEY_VALUE,
 315                                      XML_NAMESPACE,
 316                                      &SignatureReader::tokenEndRSAKeyValue);
 317     m_parserSchema.addEndTagCallback(TOKEN_MODULUS_COMPONENT,
 318                                      XML_NAMESPACE,
 319                                      &SignatureReader::tokenEndKeyModulus);
 320     m_parserSchema.addEndTagCallback(TOKEN_EXPONENT_COMPONENT,
 321                                      XML_NAMESPACE,
 322                                      &SignatureReader::tokenEndKeyExponent);
 323     m_parserSchema.addEndTagCallback(TOKEN_TARGET_RESTRICTION,
 324                                      XML_NAMESPACE,
 325                                      &SignatureReader::blankFunction);
 326 }
 327
 328 void SignatureReader::tokenKeyInfo(SignatureData &signatureData)
 329 {
 330     (void)signatureData;
 331 }
 332 void SignatureReader::tokenX509Data(SignatureData &signatureData)
 333 {
 334     (void)signatureData;
 335 }
 336 void SignatureReader::tokenX509Certificate(SignatureData &signatureData)
 337 {
 338     (void)signatureData;
 339 }
 340 void SignatureReader::tokenPublicKey(SignatureData &signatureData)
 341 {
 342     (void)signatureData;
 343 }
 344
 345 void SignatureReader::tokenNamedCurve(SignatureData &signatureData)
 346 {
 347     (void)signatureData;
 348     m_nameCurveURI = m_parserSchema.getReader().attribute(TOKEN_URI);
 349 }
 350
 351 void SignatureReader::tokenTargetRestriction(SignatureData &signatureData)
 352 {
 353     std::string IMEI = m_parserSchema.getReader().attribute(
 354             TOKEN_IMEI,
 355             SaxReader::
 356                 THROW_DISABLE);
 357     std::string MEID = m_parserSchema.getReader().attribute(
 358             TOKEN_MEID,
 359             SaxReader::
 360                 THROW_DISABLE);
 361
 362     //less verbose way to say (IMEI && MEID) || (!IMEI && !MEID)
 363     if (IMEI.empty() == MEID.empty()) {
 364         //WAC 2.0 WR-4650 point 4
 365         ThrowMsg(Exception::TargetRestrictionException,
 366                  "TargetRestriction should contain exactly one attribute.");
 367         return;
 368     }
 369
 370     if (!IMEI.empty()) {
 371         signatureData.m_imeiList.push_back(IMEI);
 372     }
 373     if (!MEID.empty()) {
 374         signatureData.m_meidList.push_back(MEID);
 375     }
 376 }
 377
 378 void SignatureReader::tokenEndKeyInfo(SignatureData &signatureData)
 379 {
 380     (void)signatureData;
 381 }
 382
 383 void SignatureReader::tokenEndX509Data(SignatureData &signatureData)
 384 {
 385     (void)signatureData;
 386 }
 387
 388 void SignatureReader::tokenEndX509Certificate(SignatureData &signatureData)
 389 {
 390     CertificateLoader loader;
 391     if (CertificateLoader::NO_ERROR !=
 392         loader.loadCertificateFromRawData(m_parserSchema.getText())) {
 393         LogWarning("Certificate could not be loaded!");
 394         ThrowMsg(ParserSchemaException::CertificateLoaderError,
 395                  "Certificate could not be loaded.");
 396     }
 397     signatureData.m_certList.push_back(loader.getCertificatePtr());
 398 }
 399 // KW void SignatureReader::tokenEndKeyName(SignatureData &signatureData){
 400 // KW     CertificateLoader loader;
 401 // KW     if(CertificateLoader::NO_ERROR != loader.loadCertificateBasedOnSubjectName(m_parserSchema.getText())){
 402 // KW         LogError("Certificate could not be loaded!");
 403 // KW         ThrowMsg(ParserSchemaException::CertificateLoaderError, "Certificate could not be loaded.");
 404 // KW     }
 405 // KW     signatureData.m_certList.push_back(loader);
 406 // KW }
 407
 408 void SignatureReader::tokenEndRSAKeyValue(SignatureData &signatureData)
 409 {
 410     CertificateLoader loader;
 411     if (CertificateLoader::NO_ERROR !=
 412         loader.loadCertificateBasedOnExponentAndModulus(m_modulus,
 413                                                         m_exponent)) {
 414         LogWarning("Certificate could not be loaded!");
 415         ThrowMsg(ParserSchemaException::CertificateLoaderError,
 416                  "Certificate could not be loaded.");
 417     }
 418     signatureData.m_certList.push_back(loader.getCertificatePtr());
 419 }
 420
 421 void SignatureReader::tokenEndKeyModulus(SignatureData &signatureData)
 422 {
 423     (void)signatureData;
 424     m_modulus = m_parserSchema.getText();
 425 }
 426
 427 void SignatureReader::tokenEndKeyExponent(SignatureData &signatureData)
 428 {
 429     (void)signatureData;
 430     m_exponent = m_parserSchema.getText();
 431 }
 432
 433 void SignatureReader::tokenEndPublicKey(SignatureData &signatureData)
 434 {
 435     (void)signatureData;
 436     m_publicKey = m_parserSchema.getText();
 437 }
 438
 439 void SignatureReader::tokenEndECKeyValue(SignatureData &signatureData)
 440 {
 441     CertificateLoader loader;
 442     if (CertificateLoader::NO_ERROR !=
 443         loader.loadCertificateWithECKEY(m_nameCurveURI, m_publicKey)) {
 444         ThrowMsg(ParserSchemaException::CertificateLoaderError,
 445                  "Certificate could not be loaded.");
 446     }
 447     signatureData.m_certList.push_back(loader.getCertificatePtr());
 448 }
 449
 450 void SignatureReader::tokenEndObject(SignatureData &signatureData)
 451 {
 452     m_signaturePropertiesCounter = 0;
 453
 454     if (((!signatureData.m_imeiList.empty()) ||
 455          (!signatureData.m_meidList.empty())) &&
 456         m_targetRestrictionObjectFound) {
 457         //WAC 2.0 WR-4650 point 1
 458         ThrowMsg(
 459             Exception::TargetRestrictionException,
 460             "TargetRestriction should contain exactly one ds:Object containing zero or more wac:TargetRestriction children.");
 461         return;
 462     }
 463     if ((!signatureData.m_imeiList.empty()) ||
 464         (!signatureData.m_meidList.empty())) {
 465         m_targetRestrictionObjectFound = true;
 466     }
 467 }
 468 void SignatureReader::tokenEndDSAPComponent(SignatureData& signatureData)
 469 {
 470     (void)signatureData;
 471     m_dsaKeyPComponent = m_parserSchema.getText();
 472 }
 473
 474 void SignatureReader::tokenEndDSAQComponent(SignatureData& signatureData)
 475 {
 476     (void)signatureData;
 477     m_dsaKeyQComponent = m_parserSchema.getText();
 478 }
 479
 480 void SignatureReader::tokenEndDSAGComponent(SignatureData& signatureData)
 481 {
 482     (void)signatureData;
 483     m_dsaKeyGComponent = m_parserSchema.getText();
 484 }
 485
 486 void SignatureReader::tokenEndDSAYComponent(SignatureData& signatureData)
 487 {
 488     (void)signatureData;
 489     m_dsaKeyYComponent = m_parserSchema.getText();
 490 }
 491
 492 void SignatureReader::tokenEndDSAJComponent(SignatureData& signatureData)
 493 {
 494     (void)signatureData;
 495     m_dsaKeyJComponent = m_parserSchema.getText();
 496 }
 497
 498 void SignatureReader::tokenEndDSASeedComponent(SignatureData& signatureData)
 499 {
 500     (void)signatureData;
 501     m_dsaKeySeedComponent = m_parserSchema.getText();
 502 }
 503
 504 void SignatureReader::tokenEndDSAPGenCounterComponent(
 505         SignatureData& signatureData)
 506 {
 507     (void)signatureData;
 508     m_dsaKeyPGenCounter = m_parserSchema.getText();
 509 }
 510
 511 void SignatureReader::tokenEndDSAKeyValue(SignatureData& signatureData)
 512 {
 513     CertificateLoader loader;
 514
 515     if (CertificateLoader::NO_ERROR !=
 516         loader.loadCertificateBasedOnDSAComponents(m_dsaKeyPComponent,
 517                                                    m_dsaKeyQComponent,
 518                                                    m_dsaKeyGComponent,
 519                                                    m_dsaKeyYComponent,
 520                                                    m_dsaKeyJComponent,
 521                                                    m_dsaKeySeedComponent,
 522                                                    m_dsaKeyPGenCounter)) {
 523         LogWarning("Certificate could not be loaded.");
 524         ThrowMsg(ParserSchemaException::CertificateLoaderError,
 525                  "Certificate could not be loaded.");
 526     }
 527     signatureData.m_certList.push_back(loader.getCertificatePtr());
 528 }
 529
 530 void SignatureReader::tokenRole(SignatureData &signatureData)
 531 {
 532     if (!signatureData.m_roleURI.empty()) {
 533         LogWarning("Multiple definition of Role is not allowed.");
 534         ThrowMsg(ParserSchemaException::UnsupportedValue,
 535                  "Multiple definition of Role is not allowed.");
 536     }
 537     signatureData.m_roleURI = m_parserSchema.getReader().attribute(TOKEN_URI);
 538 }
 539
 540 void SignatureReader::tokenProfile(SignatureData &signatureData)
 541 {
 542     if (!signatureData.m_profileURI.empty()) {
 543         LogWarning("Multiple definition of Profile is not allowed.");
 544         ThrowMsg(ParserSchemaException::UnsupportedValue,
 545                  "Multiple definition of Profile is not allowed.");
 546     }
 547     signatureData.m_profileURI = m_parserSchema.getReader().attribute(TOKEN_URI);
 548 }
 549
 550 void SignatureReader::tokenEndIdentifier(SignatureData &signatureData)
 551 {
 552     if (!signatureData.m_identifier.empty()) {
 553         LogWarning("Multiple definition of Identifier is not allowed.");
 554         ThrowMsg(ParserSchemaException::UnsupportedValue,
 555                  "Multiple definition of Identifier is not allowed.");
 556     }
 557     signatureData.m_identifier = m_parserSchema.getText();
 558 }
 559
 560 void SignatureReader::tokenObject(SignatureData &signatureData)
 561 {
 562     std::string id = m_parserSchema.getReader().attribute(TOKEN_ID);
 563
 564     if (id.empty()) {
 565         LogWarning("Unsupported value of Attribute Id in Object tag.");
 566         ThrowMsg(ParserSchemaException::UnsupportedValue,
 567                  "Unsupported value of Attribute Id in Object tag.");
 568     }
 569
 570     signatureData.m_objectList.push_back(id);
 571 }
 572
 573 void SignatureReader::tokenSignatureProperties(SignatureData &signatureData)
 574 {
 575     (void)signatureData;
 576     if (++m_signaturePropertiesCounter > 1) {
 577         LogWarning("Only one SignatureProperties tag is allowed in Object");
 578         ThrowMsg(ParserSchemaException::UnsupportedValue,
 579                  "Only one SignatureProperties tag is allowed in Object");
 580     }
 581 }
 582 } // namespace ValidationCore