src/security/cert/FSecCert_CertDbStore.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   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  * @file                FSecCert_CertDbStore.cpp
  19  * @brief               This file contains implementation of X509 Certificate Database.
  20 */
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include <error.h>
  26 #include <new>
  27 #include <sys/stat.h>
  28 #include <assert.h>
  29 #include <dirent.h>
  30 #include <FIoDatabase.h>
  31 #include <FIoDbEnumerator.h>
  32 #include <FIoDbStatement.h>
  33 #include <unique_ptr.h>
  34 #include <FIoFile.h>
  35 #include <FBaseByteBuffer.h>
  36 #include <FBaseString.h>
  37 #include <FBaseResult.h>
  38 #include <FBaseSysLog.h>
  39 #include <FBaseUtilStringUtil.h>
  40 #include "FSecCert_CertDbStore.h"
  41 #include "FSecCert_Base64.h"
  42
  43 using namespace Tizen::Io;
  44 using namespace Tizen::Base;
  45
  46 namespace Tizen { namespace Security { namespace Cert
  47 {
  48
  49 _CertDbStore::_CertDbStore(void)
  50 {
  51         __rootCaCertTableCreated = Database::Exists(_CERT_ROOT_CA_CERT_TABLE);
  52         __userCertTableCreated = Database::Exists(_CERT_USER_CERT_TABLE);
  53 }
  54
  55 _CertDbStore::~_CertDbStore(void)
  56 {
  57         //Empty body
  58 }
  59
  60 result
  61 _CertDbStore::IsRootCaCertTableCreated(void)
  62 {
  63         if (!Database::Exists(_CERT_ROOT_CA_CERT_TABLE))
  64         {
  65                 return E_SYSTEM;
  66         }
  67
  68         return E_SUCCESS;
  69 }
  70
  71 result
  72 _CertDbStore::IsUserCertTableCreated(void)
  73 {
  74         if (!Database::Exists(_CERT_USER_CERT_TABLE))
  75         {
  76                 return E_SYSTEM;
  77         }
  78
  79         return E_SUCCESS;
  80
  81 }
  82
  83 result
  84 _CertDbStore::CreateCertificateTables(void)
  85 {
  86         result r = E_SUCCESS;
  87         String sql;
  88         String sql2;
  89         std::unique_ptr< Database > pRootCaDatabase(new (std::nothrow) Database());
  90         SysTryReturnResult(NID_SEC_CERT, pRootCaDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory.");
  91
  92         r = pRootCaDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, true);
  93         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
  94
  95         sql.Append(L"CREATE TABLE IF NOT EXISTS rootcert (\
  96                                   certId            INTEGER PRIMARY KEY AUTOINCREMENT,\
  97                                   certType          SMALLINT DEFAULT 0,\
  98                                   certFormat        SMALLINT DEFAULT 0,\
  99                                   fileName                      VARCHAR,\
 100                                   subjectNameLen        SMALLINT DEFAULT 20,\
 101                                   subjectName           VARCHAR,\
 102                                   issuerNameLen         SMALLINT DEFAULT 20,\
 103                                   issuerName            VARCHAR,\
 104                                   parentCa                      SMALLINT,\
 105                                   installed                     VARCHAR,\
 106                                   serialNo                      VARCHAR,\
 107                               serialNoLen               SMALLINT DEFAULT 20)");
 108
 109         r = pRootCaDatabase->ExecuteSql(sql, true);
 110         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql.", GetErrorMessage(r));
 111
 112         std::unique_ptr< Database > pUserCertDatabase(new (std::nothrow) Database());
 113         SysTryReturnResult(NID_SEC_CERT, pUserCertDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory.");
 114
 115         r = pUserCertDatabase->Construct(_CERT_USER_CERT_TABLE, true);
 116         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to create certificate table. ", GetErrorMessage(r));
 117
 118         // Create a database table
 119         sql2.Append(L"CREATE TABLE IF NOT EXISTS usercert (\
 120                   certId            INTEGER PRIMARY KEY AUTOINCREMENT,\
 121                   certPubKeyHash                        VARCHAR DEFAULT null,\
 122                   certFormat     SMALLINT DEFAULT 0,\
 123                   fileName      VARCHAR,\
 124                   subjectNameLen        SMALLINT DEFAULT 20,\
 125                   subjectName           VARCHAR,\
 126                   issuerNameLen         SMALLINT DEFAULT 20,\
 127                   issuerName            VARCHAR,\
 128                   prvKeyPath            VARCHAR DEFAULT null,\
 129                   prvKeyLen                     SMALLINT DEFAULT 0,\
 130                   parentCa                      SMALLINT DEFAULT 0,\
 131                   installed                     VARCHAR,\
 132                   serialNo                      VARCHAR,\
 133                   serialNoLen           SMALLINT DEFAULT 20)");
 134
 135         r = pUserCertDatabase->ExecuteSql(sql2, true);
 136         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql.", GetErrorMessage(r));
 137
 138         return r;
 139 }
 140
 141 result
 142 _CertDbStore::DeleteCaCertFiles(void)
 143 {
 144         result r = E_SUCCESS;
 145         String strVal;
 146
 147         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 148         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory.");
 149
 150         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
 151         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to create certificate table.", GetErrorMessage(r));
 152
 153         r = pDatabase->BeginTransaction();
 154         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
 155
 156         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(L"SELECT * from rootcert"));
 157         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "Failed to get data.");
 158
 159         while (pEnum->MoveNext() == E_SUCCESS)
 160         {
 161                 r = pEnum->GetStringAt(3, strVal);
 162                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to get string.", GetErrorMessage(r));
 163                 Tizen::Io::File::Remove(strVal);
 164         }
 165
 166         return r;
 167 }
 168
 169 result
 170 _CertDbStore::DeleteUserCertFiles(void)
 171 {
 172         result r = E_SUCCESS;
 173         Database database;
 174         String strVal;
 175
 176         r = database.Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
 177         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to open user cert database.", GetErrorMessage(r));
 178
 179         std::unique_ptr< DbEnumerator > pEnum(database.QueryN(L"SELECT * from usercert"));
 180         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "Failed to find any user certificate in database.");
 181
 182         while (pEnum->MoveNext() == E_SUCCESS)
 183         {
 184                 r = pEnum->GetStringAt(3, strVal);
 185                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to get string.", GetErrorMessage(r));
 186                 Tizen::Io::File::Remove(strVal);
 187         }
 188
 189         return r;
 190 }
 191
 192 result
 193 _CertDbStore::DropCertificateTables(void)
 194 {
 195         result r = E_SUCCESS;
 196         Database database;
 197
 198         r = Database::Delete(_CERT_ROOT_CA_CERT_TABLE);
 199         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to delete CA table.", GetErrorMessage(r));
 200
 201         r = Database::Delete(_CERT_USER_CERT_TABLE);
 202         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to delete user table.", GetErrorMessage(r));
 203
 204         //Remove root certificates from the file system
 205         DeleteCaCertFiles();
 206
 207         return r;
 208 }
 209
 210 result
 211 _CertDbStore::RemoveCertificateById(int certId)
 212 {
 213         return E_FAILURE;
 214 }
 215
 216 result
 217 _CertDbStore::RemoveAllCertificates(void)
 218 {
 219         return E_FAILURE;
 220 }
 221
 222 result
 223 _CertDbStore::GetNumberOfCertificates(int& count)
 224 {
 225         return E_FAILURE;
 226 }
 227
 228
 229 _CaCertDbStore::_CaCertDbStore(void)
 230 {
 231 }
 232
 233 _CaCertDbStore::~_CaCertDbStore(void)
 234 {
 235 }
 236
 237 result
 238 _CaCertDbStore::InsertCaCertificate(CaCertRecord* pCertRecord)
 239 {
 240         result r = E_SUCCESS;
 241         byte subjectNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 242         byte issuerNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 243         byte base64SerialNum[_MAX_SERIAL_NUMBER_SIZE] = {0, };
 244         int subjectNameBase64Len = 0;
 245         int base64IssuerNameLen = 0;
 246         int base64SerialNumLen = 0;
 247         String statement;
 248
 249         SysTryReturnResult(NID_SEC_CERT, pCertRecord != null, E_INVALID_ARG, "Invalid input parameter.");
 250
 251         memcpy(subjectNameBase64, pCertRecord->subjectName, pCertRecord->subjectNameLen);
 252         memcpy(issuerNameBase64, pCertRecord->issuerName, pCertRecord->issuerNameLen);
 253         memcpy(base64SerialNum, pCertRecord->serialNo, _MAX_SERIAL_NUMBER_SIZE);
 254         memset(pCertRecord->subjectName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 255         memset(pCertRecord->issuerName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 256         memset(pCertRecord->serialNo, 0, _MAX_SERIAL_NUMBER_SIZE);
 257
 258         subjectNameBase64Len = _Base64::GetEncodedSize(pCertRecord->subjectNameLen);
 259         memset(pCertRecord->subjectName, 0, sizeof(pCertRecord->subjectName));
 260         r = _Base64::Encode(static_cast< byte* >(subjectNameBase64), pCertRecord->subjectNameLen, pCertRecord->subjectName, subjectNameBase64Len);
 261         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode subject name of certificate.");
 262
 263         pCertRecord->subjectNameLen = subjectNameBase64Len;
 264
 265         base64IssuerNameLen = _Base64::GetEncodedSize(pCertRecord->issuerNameLen);
 266         memset(pCertRecord->issuerName, 0, sizeof(pCertRecord->issuerName));
 267         r = _Base64::Encode(static_cast< byte* >(issuerNameBase64), pCertRecord->issuerNameLen, pCertRecord->issuerName, base64IssuerNameLen);
 268         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode issuer name of certificate.");
 269
 270         pCertRecord->issuerNameLen = base64IssuerNameLen;
 271
 272         base64SerialNumLen = _Base64::GetEncodedSize(pCertRecord->serialNoLen);
 273         memset(pCertRecord->serialNo, 0, sizeof(pCertRecord->serialNo));
 274         r = _Base64::Encode(static_cast< byte* >(base64SerialNum), pCertRecord->serialNoLen, pCertRecord->serialNo, base64SerialNumLen);
 275         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode serial number of certificate.");
 276
 277         pCertRecord->serialNoLen = base64SerialNumLen;
 278
 279         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 280         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory.");
 281
 282         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
 283         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 284
 285         r = pDatabase->BeginTransaction();
 286         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Begin transaction failed.", GetErrorMessage(r));
 287
 288         statement.Append(L"INSERT INTO rootcert (certId, certType, certFormat, fileName, subjectNameLen, subjectName, issuerNameLen, issuerName, parentCa, installed, serialNo, serialNoLen) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?)");
 289
 290         std::unique_ptr< DbStatement > pStmt(pDatabase->CreateStatementN(statement));
 291
 292         r = pStmt->BindInt(1, pCertRecord->certType);
 293         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun 1 in database statement.", GetErrorMessage(r));
 294         r = pStmt->BindInt(2, pCertRecord->certFormat);
 295         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun 2 in database statement.", GetErrorMessage(r));
 296         r = pStmt->BindString(3, pCertRecord->fileName);
 297         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun 3 in database statement.", GetErrorMessage(r));
 298         r = pStmt->BindInt(4, pCertRecord->subjectNameLen);
 299         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun 4 in database statement.", GetErrorMessage(r));
 300         r = pStmt->BindString(5, pCertRecord->subjectName);
 301         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun 5 in database statement.", GetErrorMessage(r));
 302         r = pStmt->BindInt(6, pCertRecord->issuerNameLen);
 303         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun 6 in database statement.", GetErrorMessage(r));
 304         r = pStmt->BindString(7, pCertRecord->issuerName);
 305         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun 7 in database statement.", GetErrorMessage(r));
 306         r = pStmt->BindInt(8, pCertRecord->parentCa);
 307         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun 8 in database statement.", GetErrorMessage(r));
 308         r = pStmt->BindString(9, pCertRecord->installed);
 309         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun 9 in database statement.", GetErrorMessage(r));
 310         r = pStmt->BindString(10, pCertRecord->serialNo);
 311         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun 10 in database statement.", GetErrorMessage(r));
 312         r = pStmt->BindInt(11, pCertRecord->serialNoLen);
 313         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun 11 in database statement.", GetErrorMessage(r));
 314
 315         std::unique_ptr< DbEnumerator > pEnum(pDatabase->ExecuteStatementN(*pStmt));
 316         AppAssert(!pEnum);
 317
 318         r = pDatabase->CommitTransaction();
 319         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Commit transaction failed.", GetErrorMessage(r));
 320
 321         return r;
 322 }
 323
 324 result
 325 _CaCertDbStore::UpdateCaCertificate(CaCertRecord* pCertRecord, CaCertRecord* pUpdateCertRecord)
 326 {
 327         result r = E_SUCCESS;
 328         String statement(_MAX_QUERY_LEN);
 329         int subjectNameBase64Len = 0;
 330         int base64IssuerNameLen = 0;
 331         byte subjectNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 332         byte issuerNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 333
 334         SysTryReturnResult(NID_SEC_CERT, !(pCertRecord == null || pUpdateCertRecord == null), E_INVALID_ARG, "Invalid input parameter.");
 335
 336         memcpy(subjectNameBase64, pCertRecord->subjectName, pCertRecord->subjectNameLen);
 337         memcpy(issuerNameBase64, pCertRecord->issuerName, pCertRecord->issuerNameLen);
 338         memset(pCertRecord->subjectName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 339         memset(pCertRecord->issuerName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 340
 341         subjectNameBase64Len = _Base64::GetEncodedSize(pCertRecord->subjectNameLen);
 342         memset(pCertRecord->subjectName, 0, sizeof(pCertRecord->subjectName));
 343         r = _Base64::Encode(static_cast< byte* >(subjectNameBase64), pCertRecord->subjectNameLen, pCertRecord->subjectName, subjectNameBase64Len);
 344         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode subject name of certificate.");
 345
 346         pCertRecord->subjectNameLen = subjectNameBase64Len;
 347
 348         base64IssuerNameLen = _Base64::GetEncodedSize(pCertRecord->issuerNameLen);
 349         memset(pCertRecord->issuerName, 0, sizeof(pCertRecord->issuerName));
 350         r = _Base64::Encode(static_cast< byte* >(issuerNameBase64), pCertRecord->issuerNameLen, pCertRecord->issuerName, base64IssuerNameLen);
 351         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode issuer name of certificate.");
 352
 353         pCertRecord->issuerNameLen = base64IssuerNameLen;
 354
 355         memset(subjectNameBase64, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 356         memset(issuerNameBase64, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 357         subjectNameBase64Len = 0;
 358         base64IssuerNameLen = 0;
 359         memcpy(subjectNameBase64, pUpdateCertRecord->subjectName, pUpdateCertRecord->subjectNameLen);
 360         memcpy(issuerNameBase64, pUpdateCertRecord->issuerName, pUpdateCertRecord->issuerNameLen);
 361         memset(pUpdateCertRecord->subjectName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 362         memset(pUpdateCertRecord->issuerName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 363
 364         subjectNameBase64Len = _Base64::GetEncodedSize(pUpdateCertRecord->subjectNameLen);
 365         memset(pCertRecord->subjectName, 0, sizeof(pCertRecord->subjectName));
 366         r = _Base64::Encode(static_cast< byte* >(subjectNameBase64), pUpdateCertRecord->subjectNameLen, pUpdateCertRecord->subjectName, subjectNameBase64Len);
 367         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode subject name of certificate.");
 368
 369         pUpdateCertRecord->subjectNameLen = subjectNameBase64Len;
 370
 371         base64IssuerNameLen = _Base64::GetEncodedSize(pUpdateCertRecord->issuerNameLen);
 372         memset(pCertRecord->issuerName, 0, sizeof(pCertRecord->issuerName));
 373         r = _Base64::Encode(static_cast< byte* >(issuerNameBase64), pUpdateCertRecord->issuerNameLen, pUpdateCertRecord->issuerName, base64IssuerNameLen);
 374         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode issuer name of certificate.");
 375
 376         pUpdateCertRecord->issuerNameLen = base64IssuerNameLen;
 377
 378         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 379         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory.");
 380
 381         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
 382         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Construct of update ca certificate failed.", GetErrorMessage(r));
 383
 384         r = pDatabase->BeginTransaction();
 385         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
 386
 387         statement.Format(_MAX_QUERY_LEN, L"UPDATE rootcert SET subjectNameLen = %d, subjectName = '%s', issuerNameLen = %d, issuerName = '%s' WHERE subjectName = '%s' and issuerName = '%s' and certType = %d and certId = %d", pUpdateCertRecord->subjectNameLen, pUpdateCertRecord->subjectName, pUpdateCertRecord->issuerNameLen, pUpdateCertRecord->issuerName, pCertRecord->subjectName, pCertRecord->issuerName, pCertRecord->certType, pCertRecord->certId);
 388         r = pDatabase->ExecuteSql(statement, true);
 389         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql.", GetErrorMessage(r));
 390
 391         r = pDatabase->CommitTransaction();
 392         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction .", GetErrorMessage(r));
 393
 394         return r;
 395 }
 396
 397 result
 398 _CaCertDbStore::UpdateParentCa(int certId, int parentCa)
 399 {
 400         result r = E_SUCCESS;
 401         String statement(_MAX_QUERY_LEN);
 402
 403         SysTryReturnResult(NID_SEC_CERT, certId > 0, E_INVALID_ARG, "Invalid input parameter certificate identifier.");
 404         SysTryReturnResult(NID_SEC_CERT, parentCa > 0, E_INVALID_ARG, "Invalid input parameter parent certificate identifier.");
 405
 406         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 407         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory.");
 408
 409         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
 410
 411         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 412
 413         r = pDatabase->BeginTransaction();
 414         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
 415
 416         statement.Format(_MAX_QUERY_LEN, L"UPDATE rootcert SET parentCa = '%d' WHERE certId = '%d'", parentCa, certId);
 417         r = pDatabase->ExecuteSql(statement, true);
 418         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql statement.", GetErrorMessage(r));
 419
 420         r = pDatabase->CommitTransaction();
 421         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
 422
 423         return r;
 424 }
 425
 426 result
 427 _CaCertDbStore::RemoveCertificateBySubjectName(_CaCertType certType, byte* pSubjectName, int subjectNameLen)
 428 {
 429         result r = E_SUCCESS;
 430         char subjectNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 431         int subjectNameBase64Len = 0;
 432         String statement(_MAX_QUERY_LEN);
 433
 434         SysTryReturnResult(NID_SEC_CERT, !((pSubjectName == null) || (subjectNameLen <= 0) || (certType < _MIN_CERT_TYPE) || (certType > _MAX_CERT_TYPE)),
 435                                            E_INVALID_ARG, "Invalid input parameter subjetname or invalid subject name length.");
 436
 437         subjectNameBase64Len = _Base64::GetEncodedSize(subjectNameLen);
 438         memset(subjectNameBase64, 0, sizeof(subjectNameBase64));
 439         r = _Base64::Encode(static_cast< byte* >(pSubjectName), subjectNameLen, subjectNameBase64, subjectNameBase64Len);
 440         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode subject name of certificate.");
 441
 442         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 443         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory.");
 444
 445         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
 446         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 447
 448         r = pDatabase->BeginTransaction();
 449         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
 450
 451         statement.Format(_MAX_QUERY_LEN, L"DELETE FROM rootcert WHERE subjectName = '%s' and subjectNameLen = '%d' and certType = '%d'", subjectNameBase64, subjectNameBase64Len, certType);
 452
 453         r = pDatabase->ExecuteSql(statement, true);
 454         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql statement.", GetErrorMessage(r));
 455
 456         r = pDatabase->CommitTransaction();
 457         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit tranction.", GetErrorMessage(r));
 458
 459         return r;
 460 }
 461
 462 result
 463 _CaCertDbStore::RemoveCertificateByIssuerNameAndSerialNo(_CaCertType certType, byte* issuerName, int issuerNameLen, byte* serialNo)
 464 {
 465         result r = E_SUCCESS;
 466         char issuerNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 467         char base64SerialNum[_MAX_SERIAL_NUMBER_SIZE] = {0, };
 468         int base64IssuerNameLen = 0;
 469         int base64SerialNoLen = 0;
 470         int serialNoLen = 0;
 471         String statement(_MAX_QUERY_LEN);
 472
 473         SysTryReturnResult(NID_SEC_CERT, !((issuerName == null) || (issuerNameLen <= 0) || (serialNo == null) || (certType < _MIN_CERT_TYPE) || (certType > _MAX_CERT_TYPE)),
 474                                            E_INVALID_ARG, "Invalid input parameter issuer name or length of issuer name.");
 475
 476         base64IssuerNameLen = _Base64::GetEncodedSize(issuerNameLen);
 477         memset(issuerNameBase64, 0, sizeof(issuerNameBase64));
 478         r = _Base64::Encode(issuerName, issuerNameLen, issuerNameBase64, base64IssuerNameLen);
 479         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode issuer name of certificate.");
 480
 481         serialNoLen = strlen(reinterpret_cast< const char* >(serialNo));
 482
 483         base64SerialNoLen = _Base64::GetEncodedSize(serialNoLen);
 484         memset(base64SerialNum, 0, sizeof(base64SerialNum));
 485         r = _Base64::Encode(serialNo, serialNoLen, base64SerialNum, base64SerialNoLen);
 486         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode serial number of certificate.");
 487
 488         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 489         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory.");
 490
 491         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
 492         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 493
 494         r = pDatabase->BeginTransaction();
 495         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
 496
 497         statement.Format(_MAX_QUERY_LEN, L"DELETE FROM rootcert WHERE issuerName = '%s' and issuerNameLen = '%d' and certType = '%d' and serialNo = '%s'", issuerNameBase64, base64IssuerNameLen, certType, base64SerialNum);
 498         r = pDatabase->ExecuteSql(statement, true);
 499         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql statement.", GetErrorMessage(r));
 500
 501         r = pDatabase->CommitTransaction();
 502         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
 503
 504         return r;
 505 }
 506
 507 result
 508 _CaCertDbStore::RemoveAllCertificateByCondition(byte* pCondition)
 509 {
 510         result r = E_SUCCESS;
 511         int curCertId = 0;
 512         CaCertRecord certRecord = {0, };
 513
 514         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Invalid input parameter.");
 515
 516         r = GetNextRecordByCondition(pCondition, &certRecord, curCertId);
 517
 518         while (!IsFailed(r))
 519         {
 520                 curCertId = certRecord.certId;
 521
 522                 r = _CaCertDbStore::RemoveCertificateById(certRecord.certId);
 523                 if (!IsFailed(r))
 524                 {
 525                         Tizen::Io::File::Remove(certRecord.fileName);
 526                 }
 527
 528                 r = GetNextRecordByCondition(pCondition, &certRecord, curCertId);
 529
 530         }
 531
 532         return E_SUCCESS;
 533 }
 534
 535 result
 536 _CaCertDbStore::CheckDuplicateCertificate(_CaCertType certType, byte* pSubjectName, int subjectNameLen)
 537 {
 538         result r = E_SUCCESS;
 539         char subjectNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 540         int subjectNameBase64Len = 0;
 541         String statement;
 542         String query;
 543
 544         SysTryReturnResult(NID_SEC_CERT, pSubjectName != null, E_INVALID_ARG, "Invalid input parameter subject name.");
 545         SysTryReturnResult(NID_SEC_CERT, subjectNameLen >= 0, E_INVALID_ARG, "Invalid input parameter subject name length.");
 546         SysTryReturnResult(NID_SEC_CERT, certType >= _MIN_CERT_TYPE, E_INVALID_ARG, "Invalid input parameter certificate identifier(value less than minimum index).");
 547         SysTryReturnResult(NID_SEC_CERT, certType <= _MAX_CERT_TYPE, E_INVALID_ARG, "Invalid input parameter certificate identifier(value greater than maximim index).");
 548
 549         subjectNameBase64Len = _Base64::GetEncodedSize(subjectNameLen);
 550         memset(subjectNameBase64, 0, sizeof(subjectNameBase64));
 551         r = _Base64::Encode(static_cast< byte* >(pSubjectName), subjectNameLen, subjectNameBase64, subjectNameBase64Len);
 552         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode subject name of certificate.");
 553
 554         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 555         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory.");
 556
 557         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 558         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 559
 560         r = pDatabase->BeginTransaction();
 561         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
 562
 563         statement.Format(_MAX_QUERY_LEN, L"SELECT * from rootcert where certType = '%d' and subjectName = '%s' and subjectNameLen = '%d'", certType, subjectNameBase64, subjectNameBase64Len);
 564         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
 565         r = GetLastResult();
 566         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r) , r, "Failed to get query result.");
 567         SysTryReturnResult(NID_SEC_CERT, pEnum != null , E_DATA_NOT_FOUND, "No certificate found in database.");
 568
 569         return r;
 570 }
 571
 572 result
 573 _CaCertDbStore::CheckDuplicateCertificate(_CaCertType certType, byte* issuerName, int issuerNameLen, byte* pSerialNumber)
 574 {
 575         result r = E_SUCCESS;
 576         char issuerNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 577         char base64SerialNo[_MAX_SERIAL_NUMBER_SIZE] = {0, };
 578         int base64IssuerNameLen = 0;
 579         int base64SerialNoLen = 0;
 580         int serialNoLen = 0;
 581         String statement(_MAX_QUERY_LEN);
 582
 583         SysTryReturnResult(NID_SEC_CERT, issuerName != null, E_INVALID_ARG, "Invalid input parameter issuer name.");
 584         SysTryReturnResult(NID_SEC_CERT, issuerNameLen >= 0, E_INVALID_ARG, "Invalid input parameter issuer name length.");
 585         SysTryReturnResult(NID_SEC_CERT, pSerialNumber != null, E_INVALID_ARG, "Invalid input parameter serial number.");
 586         SysTryReturnResult(NID_SEC_CERT, certType >= _MIN_CERT_TYPE, E_INVALID_ARG, "Invalid input parameter certificate identifier (value is less than minimum index).");
 587         SysTryReturnResult(NID_SEC_CERT, certType <= _MAX_CERT_TYPE, E_INVALID_ARG, "Invalid input parameter certificate identifier (value is greater than maximum index).");
 588
 589         base64IssuerNameLen = _Base64::GetEncodedSize(issuerNameLen);
 590         memset(issuerNameBase64, 0, sizeof(issuerNameBase64));
 591         r = _Base64::Encode(issuerName, issuerNameLen, issuerNameBase64, base64IssuerNameLen);
 592         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode issuer name of certificate.");
 593
 594         serialNoLen = strlen(reinterpret_cast< const char* >(pSerialNumber));
 595
 596         base64SerialNoLen = _Base64::GetEncodedSize(serialNoLen);
 597         memset(base64SerialNo, 0, sizeof(base64SerialNo));
 598         r = _Base64::Encode(pSerialNumber, serialNoLen, base64SerialNo, base64SerialNoLen);
 599         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode serial number of certificate.");
 600
 601         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 602         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 603
 604         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 605         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 606
 607         r = pDatabase->BeginTransaction();
 608         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed begin transaction.", GetErrorMessage(r));
 609
 610         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM rootcert WHERE certType = '%d' AND issuerName = '%s' AND issuerNameLen = '%d' AND serialNo = '%s'", certType, issuerNameBase64, base64IssuerNameLen, base64SerialNo);
 611         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
 612         r = GetLastResult();
 613         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r) , r, "Failed to get query result.");
 614         SysTryReturnResult(NID_SEC_CERT, pEnum != null , E_DATA_NOT_FOUND, "No certificate found in database.");
 615
 616         return r;
 617 }
 618
 619 result
 620 _CaCertDbStore::GetFirstRecordByConditions(byte* pCondition, CaCertRecord* pCertRecord)
 621 {
 622         result r = E_SUCCESS;
 623         String statement(_MAX_QUERY_LEN);
 624         char tmpName[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 625         String strVal;
 626
 627         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Invalid input parameter.");
 628         SysTryReturnResult(NID_SEC_CERT, pCertRecord != null, E_INVALID_ARG, "Invalid input parameter.");
 629
 630         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 631         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 632
 633         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 634         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 635
 636         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM rootcert WHERE %s ORDER BY certId", pCondition);
 637         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
 638         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
 639
 640         r = pEnum->MoveNext();
 641         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to move next.", GetErrorMessage(r));
 642
 643         r = pEnum->GetIntAt(0, pCertRecord->certId);
 644         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 0.", GetErrorMessage(r));
 645
 646         r = pEnum->GetIntAt(1, pCertRecord->certType);
 647         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 1.", GetErrorMessage(r));
 648
 649         r = pEnum->GetIntAt(2, pCertRecord->certFormat);
 650         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 2.", GetErrorMessage(r));
 651
 652         r = pEnum->GetStringAt(3, strVal);
 653         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 3.", GetErrorMessage(r));
 654
 655         std::unique_ptr< ByteBuffer > pTempBuf(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 656         r = GetLastResult();
 657         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 658
 659         memcpy(pCertRecord->fileName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 660         pCertRecord->fileName[pTempBuf->GetRemaining()] = '\0';
 661
 662         r = pEnum->GetIntAt(4, pCertRecord->subjectNameLen);
 663         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 4.", GetErrorMessage(r));
 664
 665         r = pEnum->GetStringAt(5, strVal);
 666         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 5.", GetErrorMessage(r));
 667
 668         memset(tmpName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 669
 670         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 671
 672         r = GetLastResult();
 673         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 674
 675         memcpy(tmpName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pCertRecord->subjectNameLen);
 676         _Base64::Decode(tmpName, pCertRecord->subjectNameLen, reinterpret_cast< byte* >(pCertRecord->subjectName), pCertRecord->subjectNameLen);
 677
 678         r = pEnum->GetIntAt(6, pCertRecord->issuerNameLen);
 679         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 6.", GetErrorMessage(r));
 680
 681         r = pEnum->GetStringAt(7, strVal);
 682         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 7.", GetErrorMessage(r));
 683
 684         memset(tmpName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 685
 686         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 687         r = GetLastResult();
 688         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 689
 690         memcpy(tmpName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pCertRecord->issuerNameLen);
 691         _Base64::Decode(tmpName, pCertRecord->issuerNameLen, reinterpret_cast< byte* >(pCertRecord->issuerName), pCertRecord->issuerNameLen);
 692
 693         r = pEnum->GetIntAt(8, pCertRecord->parentCa);
 694         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 8.", GetErrorMessage(r));
 695
 696         r = pEnum->GetStringAt(9, strVal);
 697         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 9.", GetErrorMessage(r));
 698
 699         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 700         r = GetLastResult();
 701         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 702
 703         memcpy(pCertRecord->installed, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 704         pCertRecord->installed[pTempBuf->GetRemaining()] = '\0';
 705
 706         r = pEnum->GetStringAt(10, strVal);
 707         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 10.", GetErrorMessage(r));
 708
 709         r = pEnum->GetIntAt(11, pCertRecord->serialNoLen);
 710         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 11.", GetErrorMessage(r));
 711
 712         memset(tmpName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 713
 714         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 715         r = GetLastResult();
 716         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 717
 718         memcpy(tmpName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 719         _Base64::Decode(tmpName, pCertRecord->serialNoLen, reinterpret_cast< byte* >(pCertRecord->serialNo), pCertRecord->serialNoLen);
 720
 721         return r;
 722 }
 723
 724 result
 725 _CaCertDbStore::GetNextRecordByCondition(byte* pCondition, CaCertRecord* pCertRecord, int curCertId)
 726 {
 727         result r = E_SUCCESS;
 728         String statement(_MAX_QUERY_LEN);
 729         String strVal;
 730
 731         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Invalid input parameter.");
 732         SysTryReturnResult(NID_SEC_CERT, pCertRecord != null, E_INVALID_ARG, "Invalid input parameter.");
 733
 734         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 735         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 736
 737         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 738         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 739
 740         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM rootcert WHERE %s AND certId > '%d'  ORDER BY certId", pCondition, curCertId);
 741         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
 742         if (pEnum == null)
 743         {
 744                 return E_DATA_NOT_FOUND;
 745         }
 746
 747         r = pEnum->MoveNext();
 748         r = pEnum->GetIntAt(0, pCertRecord->certId);
 749         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 0.", GetErrorMessage(r));
 750
 751         r = pEnum->GetIntAt(1, pCertRecord->certType);
 752         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 1.", GetErrorMessage(r));
 753
 754         r = pEnum->GetIntAt(2, pCertRecord->certFormat);
 755         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 2.", GetErrorMessage(r));
 756
 757         r = pEnum->GetStringAt(3, strVal);
 758         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 3.");
 759
 760         std::unique_ptr< ByteBuffer > pTempBuf(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 761         r = GetLastResult();
 762         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 763
 764         memcpy(pCertRecord->fileName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 765         pCertRecord->fileName[pTempBuf->GetRemaining()] = '\0';
 766
 767         r = pEnum->GetIntAt(4, pCertRecord->subjectNameLen);
 768         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 4.", GetErrorMessage(r));
 769
 770         r = pEnum->GetStringAt(5, strVal);
 771         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 5.", GetErrorMessage(r));
 772
 773         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 774         r = GetLastResult();
 775         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 776
 777         memcpy(pCertRecord->subjectName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 778         pCertRecord->subjectName[pTempBuf->GetRemaining()] = '\0';
 779
 780         r = pEnum->GetIntAt(6, pCertRecord->issuerNameLen);
 781         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 6.", GetErrorMessage(r));
 782
 783         r = pEnum->GetStringAt(7, strVal);
 784         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 7.", GetErrorMessage(r));
 785
 786         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 787         r = GetLastResult();
 788         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 789
 790         memcpy(pCertRecord->issuerName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 791         pCertRecord->issuerName[pTempBuf->GetRemaining()] = '\0';
 792
 793         r = pEnum->GetIntAt(8, pCertRecord->parentCa);
 794         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 8.", GetErrorMessage(r));
 795
 796         r = pEnum->GetStringAt(9, strVal);
 797         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 9.", GetErrorMessage(r));
 798
 799         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 800         r = GetLastResult();
 801         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 802
 803         memcpy(pCertRecord->installed, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 804         pCertRecord->installed[pTempBuf->GetRemaining()] = '\0';
 805
 806         r = pEnum->GetStringAt(10, strVal);
 807         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 10.", GetErrorMessage(r));
 808
 809         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 810         r = GetLastResult();
 811         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 812
 813         memcpy(pCertRecord->serialNo, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 814         pCertRecord->serialNo[pTempBuf->GetRemaining()] = '\0';
 815
 816         r = pEnum->GetIntAt(11, pCertRecord->serialNoLen);
 817         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 11.", GetErrorMessage(r));
 818
 819         return r;
 820 }
 821
 822 result
 823 _CaCertDbStore::GetCurrentCertId(int& curCertId)
 824 {
 825         result r = E_SUCCESS;
 826         int certId = 0;
 827
 828         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 829         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 830
 831         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 832         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 833
 834         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN("SELECT seq FROM sqlite_sequence"));
 835         if (pEnum == null)
 836         {
 837                 return E_DATA_NOT_FOUND;
 838         }
 839
 840         while (pEnum->MoveNext() == E_SUCCESS)
 841         {
 842                 r = pEnum->GetIntAt(0, certId);
 843                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
 844         }
 845         curCertId = certId;
 846
 847         return r;
 848 }
 849
 850 result
 851 _CaCertDbStore::CheckIfSameParent(int certId)
 852 {
 853         result r = E_SUCCESS;
 854         int curCertId = 0;
 855         int count = 0;
 856         String statement;
 857
 858         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 859         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 860
 861         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 862         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 863
 864         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM rootcert where parentCa = %d ORDER BY certId", certId);
 865
 866         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
 867         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
 868
 869         while (pEnum->MoveNext() == E_SUCCESS)
 870         {
 871                 r = pEnum->GetIntAt(0, curCertId);
 872                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
 873                 count++;
 874         }
 875
 876         SysTryReturnResult(NID_SEC_CERT, count > 1, E_SYSTEM, "Failed to get record.");
 877
 878         return r;
 879 }
 880
 881 result
 882 _CaCertDbStore::SelectCaCertificateBycertId(int certId, CaCertRecord* pCertRecord)
 883 {
 884         byte condition[_MAX_TYPE_CONST_SIZE] = {0, };
 885
 886         return _CaCertDbStore::GetNextRecordByCondition(static_cast< byte* >(condition), pCertRecord, certId);
 887
 888 }
 889
 890 result
 891 _CaCertDbStore::RemoveCertificateById(int certId)
 892 {
 893         result r = E_SUCCESS;
 894         String statement;
 895
 896         SysTryReturnResult(NID_SEC_CERT, certId > 0, E_INVALID_ARG, "Invalid input parameter.");
 897
 898         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 899         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 900
 901         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
 902         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 903
 904         r = pDatabase->BeginTransaction();
 905         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
 906
 907         statement.Append(L"DELETE FROM rootcert WHERE certId = ?");
 908         std::unique_ptr< DbStatement > pStmt(pDatabase->CreateStatementN(statement));
 909         SysTryReturn(NID_SEC_CERT, pStmt != null, r, r, "[%s] Failed to create statement.", GetErrorMessage(r));
 910
 911         r = pStmt->BindInt(0, certId);
 912         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
 913
 914         pDatabase->ExecuteStatementN(*pStmt);
 915
 916         r = pDatabase->CommitTransaction();
 917         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
 918
 919         return r;
 920 }
 921
 922 result
 923 _CaCertDbStore::RemoveAllCertificates(void)
 924 {
 925         result r = E_SUCCESS;
 926         String statement;
 927
 928         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 929         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 930
 931         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
 932         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 933
 934         r = pDatabase->BeginTransaction();
 935         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
 936
 937         statement.Append(L"DELETE from rootcert");
 938
 939         r = pDatabase->ExecuteSql(statement, true);
 940         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql.", GetErrorMessage(r));
 941
 942         r = pDatabase->CommitTransaction();
 943         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
 944
 945         return r;
 946 }
 947
 948 result
 949 _CaCertDbStore::GetNumberOfCertificates(int& count)
 950 {
 951         result r = E_SUCCESS;
 952
 953         String statement;
 954         int certCount = 0;
 955
 956         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 957         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 958
 959         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 960         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 961
 962         statement.Append(L"SELECT * FROM rootcert");
 963         std::unique_ptr< DbStatement > pStmt(pDatabase->CreateStatementN(statement));
 964         std::unique_ptr< DbEnumerator > pEnum(pDatabase->ExecuteStatementN(*pStmt));
 965         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
 966
 967         while (pEnum->MoveNext() == E_SUCCESS)
 968         {
 969                 certCount++;
 970         }
 971
 972         count = certCount;
 973
 974         return r;
 975 }
 976
 977 _UserCertDbStore::_UserCertDbStore(void)
 978 {
 979 }
 980
 981 _UserCertDbStore::~_UserCertDbStore(void)
 982 {
 983 }
 984
 985 result
 986 _UserCertDbStore::InsertUserCertificate(UserCertRecord* pCertRecord)
 987 {
 988         result r = E_SUCCESS;
 989         byte subjectNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 990         byte issuerNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 991         byte base64SerialNum[_MAX_SERIAL_NUMBER_SIZE] = {0, };
 992         int subjectNameBase64Len = 0;
 993         int base64IssuerNameLen = 0;
 994         int base64SerialNumLen = 0;
 995         String statement;
 996
 997         SysTryReturnResult(NID_SEC_CERT, pCertRecord != null, E_INVALID_ARG, "Invalid input parameter.");
 998
 999         memcpy(subjectNameBase64, pCertRecord->subjectName, pCertRecord->subjectNameLen);
1000         memcpy(issuerNameBase64, pCertRecord->issuerName, pCertRecord->issuerNameLen);
1001         memcpy(base64SerialNum, pCertRecord->serialNo, _MAX_SERIAL_NUMBER_SIZE);
1002         memset(pCertRecord->subjectName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
1003         memset(pCertRecord->issuerName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
1004         memset(pCertRecord->serialNo, 0, _MAX_SERIAL_NUMBER_SIZE);
1005
1006         subjectNameBase64Len = _Base64::GetEncodedSize(pCertRecord->subjectNameLen);
1007         memset(pCertRecord->subjectName, 0, sizeof(pCertRecord->subjectName));
1008         r = _Base64::Encode(static_cast< byte* >(subjectNameBase64), pCertRecord->subjectNameLen, pCertRecord->subjectName, subjectNameBase64Len);
1009         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode subject name of certificate.");
1010
1011         pCertRecord->subjectNameLen = subjectNameBase64Len;
1012
1013         base64IssuerNameLen = _Base64::GetEncodedSize(pCertRecord->issuerNameLen);
1014         memset(pCertRecord->issuerName, 0, sizeof(pCertRecord->issuerName));
1015         r = _Base64::Encode(static_cast< byte* >(issuerNameBase64), pCertRecord->issuerNameLen, pCertRecord->issuerName, base64IssuerNameLen);
1016         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode issuer name of certificate.");
1017
1018         pCertRecord->issuerNameLen = base64IssuerNameLen;
1019
1020         base64SerialNumLen = _Base64::GetEncodedSize(pCertRecord->serialNoLen);
1021         memset(pCertRecord->serialNo, 0, sizeof(pCertRecord->serialNo));
1022         r = _Base64::Encode(static_cast< byte* >(base64SerialNum), pCertRecord->serialNoLen, pCertRecord->serialNo, base64SerialNumLen);
1023         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode serial number of certificate.");
1024
1025         pCertRecord->serialNoLen = base64SerialNumLen;
1026
1027         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1028         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1029
1030         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
1031         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "Failed to construct database instance.");
1032
1033         r = pDatabase->BeginTransaction();
1034         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1035
1036         statement.Append(L"INSERT INTO usercert (certId, certPubKeyHash, certFormat, fileName, subjectNameLen, subjectName, issuerNameLen, issuerName, prvKeyPath, prvKeyLen, parentCa, installed, serialNo, serialNoLen) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?)");
1037         std::unique_ptr< DbStatement > pStmt(pDatabase->CreateStatementN(statement));
1038         r = pStmt->BindString(1, pCertRecord->certPubKeyHash);
1039         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1040         r = pStmt->BindInt(2, pCertRecord->certFormat);
1041         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1042         r = pStmt->BindString(3, pCertRecord->fileName);
1043         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1044         r = pStmt->BindInt(4, pCertRecord->subjectNameLen);
1045         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1046         r = pStmt->BindString(5, pCertRecord->subjectName);
1047         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1048         r = pStmt->BindInt(6, pCertRecord->issuerNameLen);
1049         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1050         r = pStmt->BindString(7, pCertRecord->issuerName);
1051         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1052         r = pStmt->BindString(8, pCertRecord->prvKeyPath);
1053         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1054         r = pStmt->BindInt(9, pCertRecord->prvKeyLen);
1055         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1056         r = pStmt->BindInt(10, pCertRecord->parentCa);
1057         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1058         r = pStmt->BindString(11, pCertRecord->installed);
1059         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1060         r = pStmt->BindString(12, pCertRecord->serialNo);
1061         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1062         r = pStmt->BindInt(13, pCertRecord->serialNoLen);
1063         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1064         std::unique_ptr< DbEnumerator > pEnum(pDatabase->ExecuteStatementN(*pStmt));
1065         AppAssert(!pEnum);
1066
1067         r = pDatabase->CommitTransaction();
1068         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
1069
1070         return r;
1071 }
1072
1073 result
1074 _UserCertDbStore::UpdateParentCa(int certId, int parentCa)
1075 {
1076         result r = E_SUCCESS;
1077         String statement(_MAX_QUERY_LEN);
1078
1079         SysTryReturnResult(NID_SEC_CERT, certId > 0, E_INVALID_ARG, "Invalid input parameter.");
1080         SysTryReturnResult(NID_SEC_CERT, parentCa > 0, E_INVALID_ARG, "Invalid input parameter.");
1081
1082         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1083         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory.");
1084
1085         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
1086         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1087
1088         r = pDatabase->BeginTransaction();
1089         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1090
1091         statement.Format(_MAX_QUERY_LEN, L"UPDATE usercert SET parentCa = '%d' WHERE certId = '%d'", parentCa, certId);
1092         r = pDatabase->ExecuteSql(statement, true);
1093         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql.", GetErrorMessage(r));
1094
1095         r = pDatabase->CommitTransaction();
1096         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
1097
1098         return r;
1099 }
1100
1101 result
1102 _UserCertDbStore::UpdateRecordByCondition(byte* pCondition)
1103 {
1104         result r = E_SUCCESS;
1105         String statement(_MAX_QUERY_LEN);
1106
1107         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Invalid input parameter.");
1108
1109         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1110         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1111
1112         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
1113         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1114
1115         r = pDatabase->BeginTransaction();
1116         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1117
1118         statement.Format(_MAX_QUERY_LEN, L"UPDATE usercert SET %s", pCondition);
1119
1120         r = pDatabase->ExecuteSql(statement, true);
1121         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql statement.", GetErrorMessage(r));
1122
1123         r = pDatabase->CommitTransaction();
1124         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transactoin.", GetErrorMessage(r));
1125
1126         return r;
1127 }
1128
1129 result
1130 _UserCertDbStore::RemoveCertificateByCondition(byte* pCondition)
1131 {
1132         result r = E_SUCCESS;
1133
1134
1135         int curCertId = 0;
1136         String statement(_MAX_QUERY_LEN);
1137         String strVal;
1138
1139         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Invalid input parameter.");
1140
1141         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1142         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1143
1144         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
1145         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1146
1147         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM usercert WHERE %s ORDER BY certId", pCondition);
1148         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1149         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
1150
1151
1152         while (pEnum->MoveNext() == E_SUCCESS)
1153         {
1154                 r = pEnum->GetIntAt(0, curCertId);
1155                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
1156
1157                 r = _UserCertDbStore::RemoveCertificateById(curCertId);
1158                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to delete record from database.", GetErrorMessage(r));
1159
1160                 r = pEnum->GetStringAt(4, strVal);
1161                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
1162
1163                 Tizen::Io::File::Remove(strVal);
1164         }
1165
1166         return r;
1167 }
1168
1169 result
1170 _UserCertDbStore::CheckDuplicateCertificate(byte* pSubjectName, int subjectNameLen)
1171 {
1172         result r = E_SUCCESS;
1173         char subjectNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
1174         int subjectNameBase64Len = 0;
1175         String statement(_MAX_QUERY_LEN);
1176
1177         SysTryReturnResult(NID_SEC_CERT, pSubjectName != null, E_INVALID_ARG, "Invalid input parameter.");
1178         SysTryReturnResult(NID_SEC_CERT, subjectNameLen > 0, E_INVALID_ARG, "Invalid input parameter.");
1179
1180         subjectNameBase64Len = _Base64::GetEncodedSize(subjectNameLen);
1181         memset(subjectNameBase64, 0, sizeof(subjectNameBase64));
1182         r = _Base64::Encode(static_cast< byte* >(pSubjectName), subjectNameLen, subjectNameBase64, subjectNameBase64Len);
1183         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode subject name of certificate.");
1184
1185         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1186         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1187
1188         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1189         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1190
1191         r = pDatabase->BeginTransaction();
1192         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1193
1194         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM usercert WHERE subjectName = '%s' AND subjectNameLen = '%d'", subjectNameBase64, subjectNameBase64Len);
1195
1196         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1197         r = GetLastResult();
1198         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r) , r, "Failed to get query result.");
1199         SysTryReturnResult(NID_SEC_CERT, pEnum != null , E_DATA_NOT_FOUND, "No certificate found in database.");
1200
1201         return r;
1202 }
1203
1204 result
1205 _UserCertDbStore::CheckDuplicateCertificate(byte* pIssuerName, int issuerNameLen, byte* pSerialNumber)
1206 {
1207         result r = E_SUCCESS;
1208         char issuerNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
1209         char base64SerialNo[_MAX_SERIAL_NUMBER_SIZE] = {0, };
1210         int base64IssuerNameLen = 0;
1211         int base64SerialNoLen = 0;
1212         int serialNoLen = 0;
1213         String statement(_MAX_QUERY_LEN);
1214
1215         SysTryReturnResult(NID_SEC_CERT, pIssuerName != null, E_INVALID_ARG, "Invald input parameter");
1216         SysTryReturnResult(NID_SEC_CERT, issuerNameLen >= 0, E_INVALID_ARG, "Invald input parameter");
1217         SysTryReturnResult(NID_SEC_CERT, pSerialNumber != null, E_INVALID_ARG, "Invald input parameter");
1218
1219         base64IssuerNameLen = _Base64::GetEncodedSize(issuerNameLen);
1220         memset(issuerNameBase64, 0, sizeof(issuerNameBase64));
1221         r = _Base64::Encode(pIssuerName, issuerNameLen, issuerNameBase64, base64IssuerNameLen);
1222         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode issuer name of certificate.");
1223
1224         serialNoLen = strlen(reinterpret_cast< const char* >(pSerialNumber));
1225
1226         base64SerialNoLen = _Base64::GetEncodedSize(serialNoLen);
1227         memset(base64SerialNo, 0, sizeof(base64SerialNo));
1228         r = _Base64::Encode(pSerialNumber, serialNoLen, base64SerialNo, base64SerialNoLen);
1229         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode serial number of certificate.");
1230
1231         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1232         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1233
1234         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1235         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1236
1237         r = pDatabase->BeginTransaction();
1238         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1239
1240         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM usercert WHERE issuerName = '%s' AND issuerNameLen = '%d' AND serialNo = '%s'", issuerNameBase64, base64IssuerNameLen, base64SerialNo);
1241         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1242         r = GetLastResult();
1243         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r) , r, "Failed to get query result.");
1244         SysTryReturnResult(NID_SEC_CERT, pEnum != null , E_DATA_NOT_FOUND, "No certificate found in database.");
1245
1246         return r;
1247 }
1248
1249 result
1250 _UserCertDbStore::GetFirstRecordByConditions(byte* pCondition, UserCertRecord* pCertRecord)
1251 {
1252         result r = E_SUCCESS;
1253         String statement(_MAX_QUERY_LEN);
1254         char tmpName[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
1255         int len = 0;
1256         String strVal;
1257
1258         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Invalid input parameter");
1259         SysTryReturnResult(NID_SEC_CERT, pCertRecord != null, E_INVALID_ARG, "Invalid input parameter");
1260
1261         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1262         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1263
1264         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1265         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1266
1267         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM usercert WHERE %s", pCondition);
1268         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1269         SysTryReturn(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, E_DATA_NOT_FOUND, "No certificate found in database.");
1270
1271
1272         r = pEnum->MoveNext();
1273         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
1274
1275         r = pEnum->GetIntAt(0, pCertRecord->certId);
1276         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 0.", GetErrorMessage(r));
1277
1278         r = pEnum->GetStringAt(1, strVal);
1279         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 1.", GetErrorMessage(r));
1280
1281         std::unique_ptr< ByteBuffer > pTempBuf(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1282         r = GetLastResult();
1283         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1284
1285         memcpy(pCertRecord->certPubKeyHash, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1286         pCertRecord->certPubKeyHash[pTempBuf->GetRemaining()] = '\0';
1287
1288         r = pEnum->GetIntAt(2, pCertRecord->certFormat);
1289         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 2.", GetErrorMessage(r));
1290
1291         r = pEnum->GetStringAt(3, strVal);
1292         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 3.", GetErrorMessage(r));
1293
1294         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1295         r = GetLastResult();
1296         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1297
1298         memcpy(pCertRecord->fileName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1299         pCertRecord->fileName[pTempBuf->GetRemaining()] = '\0';
1300
1301         r = pEnum->GetIntAt(4, pCertRecord->subjectNameLen);
1302         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 4.", GetErrorMessage(r));
1303
1304         r = pEnum->GetStringAt(5, strVal);
1305         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 5.", GetErrorMessage(r));
1306
1307         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1308         r = GetLastResult();
1309         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1310
1311         memset(tmpName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
1312         memcpy(tmpName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1313         _Base64::Decode(tmpName, pCertRecord->subjectNameLen, reinterpret_cast< byte* >(pCertRecord->subjectName), pCertRecord->subjectNameLen);
1314
1315         r = pEnum->GetIntAt(6, pCertRecord->issuerNameLen);
1316         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 6.", GetErrorMessage(r));
1317
1318         r = pEnum->GetStringAt(7, strVal);
1319         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 7.", GetErrorMessage(r));
1320
1321         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1322         r = GetLastResult();
1323         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1324
1325
1326         memset(tmpName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
1327         memcpy(tmpName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1328         _Base64::Decode(tmpName, pCertRecord->issuerNameLen, reinterpret_cast< byte* >(pCertRecord->issuerName), pCertRecord->issuerNameLen);
1329
1330         r = pEnum->GetStringAt(8, strVal);
1331         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 8.", GetErrorMessage(r));
1332
1333         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1334         if (pTempBuf)
1335         {
1336                 memcpy(pCertRecord->prvKeyPath, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1337         }
1338         else
1339         {
1340                 memset(pCertRecord->prvKeyPath, 0, _MAX_PRV_KEY_PATH_SIZE_SIZE);
1341         }
1342
1343         r = pEnum->GetIntAt(9, pCertRecord->prvKeyLen);
1344         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 9.", GetErrorMessage(r));
1345
1346         r = pEnum->GetIntAt(10, pCertRecord->parentCa);
1347         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 10.", GetErrorMessage(r));
1348
1349         r = pEnum->GetStringAt(11, strVal);
1350         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 11.", GetErrorMessage(r));
1351
1352         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1353         r = GetLastResult();
1354         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1355
1356         memcpy(pCertRecord->installed, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1357         pCertRecord->installed[pTempBuf->GetRemaining()] = '\0';
1358
1359         r = pEnum->GetStringAt(12, strVal);
1360         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 12.", GetErrorMessage(r));
1361
1362         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1363         r = GetLastResult();
1364         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1365
1366         memset(tmpName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
1367         memcpy(tmpName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1368
1369         len = pTempBuf->GetRemaining();
1370         _Base64::Decode(tmpName, len, reinterpret_cast< byte* >(pCertRecord->serialNo), len);
1371
1372         r = pEnum->GetIntAt(13, pCertRecord->serialNoLen);
1373         pCertRecord->serialNoLen = _Base64::GetDecodedSize(pCertRecord->serialNoLen);
1374         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 13.", GetErrorMessage(r));
1375
1376         return r;
1377 }
1378
1379 result
1380 _UserCertDbStore::GetNextRecordByCondition(byte* pCondition, UserCertRecord* pCertRecord, int curCertId)
1381 {
1382         result r = E_SUCCESS;
1383         String statement(_MAX_QUERY_LEN);
1384         String strVal;
1385
1386         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Input parameters are invalid");
1387         SysTryReturnResult(NID_SEC_CERT, pCertRecord != null, E_INVALID_ARG, "Input parameters are invalid");
1388
1389         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1390         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1391
1392         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1393         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1394
1395         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM usercert WHERE %s AND certId > '%d'", pCondition, curCertId);
1396         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1397         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
1398
1399         r = pEnum->MoveNext();
1400         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
1401
1402         r = pEnum->GetIntAt(0, pCertRecord->certId);
1403         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 0.", GetErrorMessage(r));
1404
1405         r = pEnum->GetStringAt(1, strVal);
1406         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 1.", GetErrorMessage(r));
1407
1408         std::unique_ptr< ByteBuffer > pTempBuf(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1409         r = GetLastResult();
1410         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1411
1412         memcpy(pCertRecord->certPubKeyHash, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1413         pCertRecord->certPubKeyHash[pTempBuf->GetRemaining()] = '\0';
1414
1415         r = pEnum->GetIntAt(2, pCertRecord->certFormat);
1416         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 2.", GetErrorMessage(r));
1417
1418         r = pEnum->GetStringAt(3, strVal);
1419         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 3.", GetErrorMessage(r));
1420
1421         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1422         r = GetLastResult();
1423         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1424
1425         memcpy(pCertRecord->fileName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1426         pCertRecord->fileName[pTempBuf->GetRemaining()] = '\0';
1427
1428         r = pEnum->GetIntAt(4, pCertRecord->subjectNameLen);
1429         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 4.", GetErrorMessage(r));
1430
1431         r = pEnum->GetStringAt(5, strVal);
1432         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 5.", GetErrorMessage(r));
1433
1434         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1435         r = GetLastResult();
1436         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1437
1438         memcpy(pCertRecord->subjectName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1439         pCertRecord->subjectName[pTempBuf->GetRemaining()] = '\0';
1440
1441         r = pEnum->GetIntAt(6, pCertRecord->issuerNameLen);
1442         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 6.", GetErrorMessage(r));
1443
1444         r = pEnum->GetStringAt(7, strVal);
1445         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 7.", GetErrorMessage(r));
1446
1447         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1448         r = GetLastResult();
1449         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1450
1451         memcpy(pCertRecord->issuerName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1452         pCertRecord->issuerName[pTempBuf->GetRemaining()] = '\0';
1453
1454         r = pEnum->GetStringAt(8, strVal);
1455         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 8.", GetErrorMessage(r));
1456
1457         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1458         if (pTempBuf)
1459         {
1460                 memcpy(pCertRecord->prvKeyPath, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1461         }
1462         else
1463         {
1464                 memset(pCertRecord->prvKeyPath, 0, _MAX_PRV_KEY_PATH_SIZE_SIZE);
1465         }
1466
1467         r = pEnum->GetIntAt(9, pCertRecord->prvKeyLen);
1468         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 9.", GetErrorMessage(r));
1469
1470         r = pEnum->GetIntAt(10, pCertRecord->parentCa);
1471         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 10.", GetErrorMessage(r));
1472
1473         r = pEnum->GetStringAt(11, strVal);
1474         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 11.", GetErrorMessage(r));
1475
1476         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1477         r = GetLastResult();
1478         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1479
1480         memcpy(pCertRecord->installed, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1481         pCertRecord->installed[pTempBuf->GetRemaining()] = '\0';
1482
1483         r = pEnum->GetStringAt(12, strVal);
1484         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 12.", GetErrorMessage(r));
1485
1486         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1487         r = GetLastResult();
1488         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1489
1490         memcpy(pCertRecord->serialNo, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1491         pCertRecord->serialNo[pTempBuf->GetRemaining()] = '\0';
1492
1493         r = pEnum->GetIntAt(13, pCertRecord->serialNoLen);
1494         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 13.", GetErrorMessage(r));
1495
1496         return r;
1497 }
1498
1499 result
1500 _UserCertDbStore::GetCurrentCertId(int& curCertId)
1501 {
1502         result r = E_SUCCESS;
1503         int certId = 0;
1504
1505         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1506         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1507
1508         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1509         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1510
1511         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN("SELECT seq FROM sqlite_sequence"));
1512         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
1513
1514         r = pEnum->MoveNext();
1515         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to move next.", GetErrorMessage(r));
1516
1517         r = pEnum->GetIntAt(0, certId);
1518         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
1519
1520         curCertId = certId;
1521
1522         return r;
1523 }
1524
1525 result
1526 _UserCertDbStore::GetCountByCondition(byte* pCondition, int& count)
1527 {
1528         result r = E_SUCCESS;
1529         int certCount = 0;
1530         String statement(_MAX_QUERY_LEN);
1531
1532         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Input parameter are invalid");
1533
1534         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1535         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1536
1537         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1538         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Construct fails.", GetErrorMessage(r));
1539
1540         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM usercert WHERE %s", pCondition);
1541         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1542         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in Db.");
1543
1544         while (pEnum->MoveNext() == E_SUCCESS)
1545         {
1546                 certCount++;
1547         }
1548
1549         count = certCount;
1550
1551         return r;
1552 }
1553
1554 result
1555 _UserCertDbStore::GetParentCaByCondition(byte* pCondition, int& parentCa)
1556 {
1557         result r = E_SUCCESS;
1558         int currParentCa = 0;
1559         String statement(_MAX_QUERY_LEN);
1560
1561         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Input parameter are invalid");
1562
1563         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1564         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1565
1566         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1567         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1568
1569         statement.Format(_MAX_QUERY_LEN, L"SELECT parentCa FROM usercert WHERE %s", pCondition);
1570         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1571         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
1572
1573         if (pEnum->MoveNext() == E_SUCCESS)
1574         {
1575                 r = pEnum->GetIntAt(10, currParentCa);
1576                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
1577         }
1578
1579         parentCa = currParentCa;
1580
1581         return r;
1582 }
1583
1584 result
1585 _UserCertDbStore::SelectUserCertificateBycertId(int certId, UserCertRecord* pCertRecord)
1586 {
1587         byte condition[_MAX_TYPE_CONST_SIZE] = {0, };
1588
1589         return _UserCertDbStore::GetNextRecordByCondition(static_cast< byte* >(condition), pCertRecord, certId);
1590
1591 }
1592
1593 result
1594 _UserCertDbStore::RemoveCertificateById(int certId)
1595 {
1596         result r = E_SUCCESS;
1597         String statement;
1598
1599         SysTryReturnResult(NID_SEC_CERT, certId > 0, E_INVALID_ARG, "Invalid input certificate id.");
1600
1601         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1602         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1603
1604         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
1605         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1606
1607         r = pDatabase->BeginTransaction();
1608         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1609
1610         statement.Append(L"DELETE FROM usercert WHERE certId = ?");
1611         std::unique_ptr< DbStatement > pStmt(pDatabase->CreateStatementN(statement));
1612         SysTryReturn(NID_SEC_CERT, pStmt, GetLastResult(), GetLastResult(), "[%s] Failed to create statement.", GetErrorMessage(GetLastResult()));
1613
1614         r = pStmt->BindInt(0, certId);
1615         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1616
1617         pDatabase->ExecuteStatementN(*pStmt);
1618
1619         r = pDatabase->CommitTransaction();
1620         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
1621
1622         return r;
1623 }
1624
1625 result
1626 _UserCertDbStore::RemoveAllCertificates(void)
1627 {
1628         result r = E_SUCCESS;
1629         String statement;
1630
1631         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1632         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1633
1634         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
1635         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1636
1637         r = pDatabase->BeginTransaction();
1638         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1639
1640         statement.Append(L"DELETE from usercert");
1641         r = pDatabase->ExecuteSql(statement, true);
1642         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql.", GetErrorMessage(r));
1643
1644         r = pDatabase->CommitTransaction();
1645         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
1646
1647         return r;
1648 }
1649
1650 result
1651 _UserCertDbStore::GetNumberOfCertificates(int& count)
1652 {
1653         result r = E_SUCCESS;
1654         String statement;
1655         int certCount = 0;
1656
1657         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1658         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1659
1660         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1661         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1662
1663         statement.Append(L"SELECT * FROM usercert");
1664
1665         std::unique_ptr< DbStatement > pStmt(pDatabase->CreateStatementN(statement));
1666         SysTryReturnResult(NID_SEC_CERT, pStmt != null, E_DATA_NOT_FOUND, "Failed to create statement for user certifcates.");
1667
1668         std::unique_ptr< DbEnumerator > pEnum(pDatabase->ExecuteStatementN(*pStmt.get()));
1669         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
1670
1671         while (pEnum->MoveNext() == E_SUCCESS)
1672         {
1673                 certCount++;
1674         }
1675
1676         count = certCount;
1677
1678         return r;
1679 }
1680
1681 } } } //Tizen::Security::Cert