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         if(pEnum == null)
 568         {
 569                 r = E_DATA_NOT_FOUND;
 570         }
 571
 572         return r;
 573 }
 574
 575 result
 576 _CaCertDbStore::CheckDuplicateCertificate(_CaCertType certType, byte* issuerName, int issuerNameLen, byte* pSerialNumber)
 577 {
 578         result r = E_SUCCESS;
 579         char issuerNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 580         char base64SerialNo[_MAX_SERIAL_NUMBER_SIZE] = {0, };
 581         int base64IssuerNameLen = 0;
 582         int base64SerialNoLen = 0;
 583         int serialNoLen = 0;
 584         String statement(_MAX_QUERY_LEN);
 585
 586         SysTryReturnResult(NID_SEC_CERT, issuerName != null, E_INVALID_ARG, "Invalid input parameter issuer name.");
 587         SysTryReturnResult(NID_SEC_CERT, issuerNameLen >= 0, E_INVALID_ARG, "Invalid input parameter issuer name length.");
 588         SysTryReturnResult(NID_SEC_CERT, pSerialNumber != null, E_INVALID_ARG, "Invalid input parameter serial number.");
 589         SysTryReturnResult(NID_SEC_CERT, certType >= _MIN_CERT_TYPE, E_INVALID_ARG, "Invalid input parameter certificate identifier (value is less than minimum index).");
 590         SysTryReturnResult(NID_SEC_CERT, certType <= _MAX_CERT_TYPE, E_INVALID_ARG, "Invalid input parameter certificate identifier (value is greater than maximum index).");
 591
 592         base64IssuerNameLen = _Base64::GetEncodedSize(issuerNameLen);
 593         memset(issuerNameBase64, 0, sizeof(issuerNameBase64));
 594         r = _Base64::Encode(issuerName, issuerNameLen, issuerNameBase64, base64IssuerNameLen);
 595         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode issuer name of certificate.");
 596
 597         serialNoLen = strlen(reinterpret_cast< const char* >(pSerialNumber));
 598
 599         base64SerialNoLen = _Base64::GetEncodedSize(serialNoLen);
 600         memset(base64SerialNo, 0, sizeof(base64SerialNo));
 601         r = _Base64::Encode(pSerialNumber, serialNoLen, base64SerialNo, base64SerialNoLen);
 602         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode serial number of certificate.");
 603
 604         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 605         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 606
 607         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 608         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 609
 610         r = pDatabase->BeginTransaction();
 611         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed begin transaction.", GetErrorMessage(r));
 612
 613         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);
 614         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
 615         r = GetLastResult();
 616         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r) , r, "Failed to get query result.");
 617         SysTryReturnResult(NID_SEC_CERT, pEnum != null , E_DATA_NOT_FOUND, "No certificate found in database.");
 618
 619         return r;
 620 }
 621
 622 result
 623 _CaCertDbStore::GetFirstRecordByConditions(byte* pCondition, CaCertRecord* pCertRecord)
 624 {
 625         result r = E_SUCCESS;
 626         String statement(_MAX_QUERY_LEN);
 627         char tmpName[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 628         String strVal;
 629
 630         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Invalid input parameter.");
 631         SysTryReturnResult(NID_SEC_CERT, pCertRecord != null, E_INVALID_ARG, "Invalid input parameter.");
 632
 633         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 634         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 635
 636         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 637         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 638
 639         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM rootcert WHERE %s ORDER BY certId", pCondition);
 640         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
 641         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
 642
 643         r = pEnum->MoveNext();
 644         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to move next.", GetErrorMessage(r));
 645
 646         r = pEnum->GetIntAt(0, pCertRecord->certId);
 647         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 0.", GetErrorMessage(r));
 648
 649         r = pEnum->GetIntAt(1, pCertRecord->certType);
 650         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 1.", GetErrorMessage(r));
 651
 652         r = pEnum->GetIntAt(2, pCertRecord->certFormat);
 653         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 2.", GetErrorMessage(r));
 654
 655         r = pEnum->GetStringAt(3, strVal);
 656         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 3.", GetErrorMessage(r));
 657
 658         std::unique_ptr< ByteBuffer > pTempBuf(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 659         r = GetLastResult();
 660         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 661
 662         memcpy(pCertRecord->fileName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 663         pCertRecord->fileName[pTempBuf->GetRemaining()] = '\0';
 664
 665         r = pEnum->GetIntAt(4, pCertRecord->subjectNameLen);
 666         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 4.", GetErrorMessage(r));
 667
 668         r = pEnum->GetStringAt(5, strVal);
 669         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 5.", GetErrorMessage(r));
 670
 671         memset(tmpName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 672
 673         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 674
 675         r = GetLastResult();
 676         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 677
 678         memcpy(tmpName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pCertRecord->subjectNameLen);
 679         _Base64::Decode(tmpName, pCertRecord->subjectNameLen, reinterpret_cast< byte* >(pCertRecord->subjectName), pCertRecord->subjectNameLen);
 680
 681         r = pEnum->GetIntAt(6, pCertRecord->issuerNameLen);
 682         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 6.", GetErrorMessage(r));
 683
 684         r = pEnum->GetStringAt(7, strVal);
 685         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 7.", GetErrorMessage(r));
 686
 687         memset(tmpName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 688
 689         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 690         r = GetLastResult();
 691         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 692
 693         memcpy(tmpName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pCertRecord->issuerNameLen);
 694         _Base64::Decode(tmpName, pCertRecord->issuerNameLen, reinterpret_cast< byte* >(pCertRecord->issuerName), pCertRecord->issuerNameLen);
 695
 696         r = pEnum->GetIntAt(8, pCertRecord->parentCa);
 697         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 8.", GetErrorMessage(r));
 698
 699         r = pEnum->GetStringAt(9, strVal);
 700         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 9.", GetErrorMessage(r));
 701
 702         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 703         r = GetLastResult();
 704         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 705
 706         memcpy(pCertRecord->installed, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 707         pCertRecord->installed[pTempBuf->GetRemaining()] = '\0';
 708
 709         r = pEnum->GetStringAt(10, strVal);
 710         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 10.", GetErrorMessage(r));
 711
 712         r = pEnum->GetIntAt(11, pCertRecord->serialNoLen);
 713         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 11.", GetErrorMessage(r));
 714
 715         memset(tmpName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
 716
 717         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 718         r = GetLastResult();
 719         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 720
 721         memcpy(tmpName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 722         _Base64::Decode(tmpName, pCertRecord->serialNoLen, reinterpret_cast< byte* >(pCertRecord->serialNo), pCertRecord->serialNoLen);
 723
 724         return r;
 725 }
 726
 727 result
 728 _CaCertDbStore::GetNextRecordByCondition(byte* pCondition, CaCertRecord* pCertRecord, int curCertId)
 729 {
 730         result r = E_SUCCESS;
 731         String statement(_MAX_QUERY_LEN);
 732         String strVal;
 733
 734         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Invalid input parameter.");
 735         SysTryReturnResult(NID_SEC_CERT, pCertRecord != null, E_INVALID_ARG, "Invalid input parameter.");
 736
 737         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 738         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 739
 740         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 741         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 742
 743         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM rootcert WHERE %s AND certId > '%d'  ORDER BY certId", pCondition, curCertId);
 744         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
 745         if (pEnum == null)
 746         {
 747                 return E_DATA_NOT_FOUND;
 748         }
 749
 750         r = pEnum->MoveNext();
 751         r = pEnum->GetIntAt(0, pCertRecord->certId);
 752         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 0.", GetErrorMessage(r));
 753
 754         r = pEnum->GetIntAt(1, pCertRecord->certType);
 755         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 1.", GetErrorMessage(r));
 756
 757         r = pEnum->GetIntAt(2, pCertRecord->certFormat);
 758         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 2.", GetErrorMessage(r));
 759
 760         r = pEnum->GetStringAt(3, strVal);
 761         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 3.");
 762
 763         std::unique_ptr< ByteBuffer > pTempBuf(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 764         r = GetLastResult();
 765         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 766
 767         memcpy(pCertRecord->fileName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 768         pCertRecord->fileName[pTempBuf->GetRemaining()] = '\0';
 769
 770         r = pEnum->GetIntAt(4, pCertRecord->subjectNameLen);
 771         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 4.", GetErrorMessage(r));
 772
 773         r = pEnum->GetStringAt(5, strVal);
 774         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 5.", GetErrorMessage(r));
 775
 776         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 777         r = GetLastResult();
 778         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 779
 780         memcpy(pCertRecord->subjectName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 781         pCertRecord->subjectName[pTempBuf->GetRemaining()] = '\0';
 782
 783         r = pEnum->GetIntAt(6, pCertRecord->issuerNameLen);
 784         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 6.", GetErrorMessage(r));
 785
 786         r = pEnum->GetStringAt(7, strVal);
 787         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 7.", GetErrorMessage(r));
 788
 789         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 790         r = GetLastResult();
 791         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 792
 793         memcpy(pCertRecord->issuerName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 794         pCertRecord->issuerName[pTempBuf->GetRemaining()] = '\0';
 795
 796         r = pEnum->GetIntAt(8, pCertRecord->parentCa);
 797         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 8.", GetErrorMessage(r));
 798
 799         r = pEnum->GetStringAt(9, strVal);
 800         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 9.", GetErrorMessage(r));
 801
 802         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 803         r = GetLastResult();
 804         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 805
 806         memcpy(pCertRecord->installed, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 807         pCertRecord->installed[pTempBuf->GetRemaining()] = '\0';
 808
 809         r = pEnum->GetStringAt(10, strVal);
 810         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 10.", GetErrorMessage(r));
 811
 812         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
 813         r = GetLastResult();
 814         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
 815
 816         memcpy(pCertRecord->serialNo, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
 817         pCertRecord->serialNo[pTempBuf->GetRemaining()] = '\0';
 818
 819         r = pEnum->GetIntAt(11, pCertRecord->serialNoLen);
 820         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database of column 11.", GetErrorMessage(r));
 821
 822         return r;
 823 }
 824
 825 result
 826 _CaCertDbStore::GetCurrentCertId(int& curCertId)
 827 {
 828         result r = E_SUCCESS;
 829         int certId = 0;
 830
 831         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 832         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 833
 834         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 835         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 836
 837         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN("SELECT seq FROM sqlite_sequence"));
 838         if (pEnum == null)
 839         {
 840                 return E_DATA_NOT_FOUND;
 841         }
 842
 843         while (pEnum->MoveNext() == E_SUCCESS)
 844         {
 845                 r = pEnum->GetIntAt(0, certId);
 846                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
 847         }
 848         curCertId = certId;
 849
 850         return r;
 851 }
 852
 853 result
 854 _CaCertDbStore::CheckIfSameParent(int certId)
 855 {
 856         result r = E_SUCCESS;
 857         int curCertId = 0;
 858         int count = 0;
 859         String statement;
 860
 861         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 862         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 863
 864         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 865         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 866
 867         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM rootcert where parentCa = %d ORDER BY certId", certId);
 868
 869         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
 870         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
 871
 872         while (pEnum->MoveNext() == E_SUCCESS)
 873         {
 874                 r = pEnum->GetIntAt(0, curCertId);
 875                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
 876                 count++;
 877         }
 878
 879         SysTryReturnResult(NID_SEC_CERT, count > 1, E_SYSTEM, "Failed to get record.");
 880
 881         return r;
 882 }
 883
 884 result
 885 _CaCertDbStore::SelectCaCertificateBycertId(int certId, CaCertRecord* pCertRecord)
 886 {
 887         byte condition[_MAX_TYPE_CONST_SIZE] = {0, };
 888
 889         return _CaCertDbStore::GetNextRecordByCondition(static_cast< byte* >(condition), pCertRecord, certId);
 890
 891 }
 892
 893 result
 894 _CaCertDbStore::RemoveCertificateById(int certId)
 895 {
 896         result r = E_SUCCESS;
 897         String statement;
 898
 899         SysTryReturnResult(NID_SEC_CERT, certId > 0, E_INVALID_ARG, "Invalid input parameter.");
 900
 901         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 902         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 903
 904         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
 905         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 906
 907         r = pDatabase->BeginTransaction();
 908         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
 909
 910         statement.Append(L"DELETE FROM rootcert WHERE certId = ?");
 911         std::unique_ptr< DbStatement > pStmt(pDatabase->CreateStatementN(statement));
 912         SysTryReturn(NID_SEC_CERT, pStmt != null, r, r, "[%s] Failed to create statement.", GetErrorMessage(r));
 913
 914         r = pStmt->BindInt(0, certId);
 915         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
 916
 917         pDatabase->ExecuteStatementN(*pStmt);
 918
 919         r = pDatabase->CommitTransaction();
 920         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
 921
 922         return r;
 923 }
 924
 925 result
 926 _CaCertDbStore::RemoveAllCertificates(void)
 927 {
 928         result r = E_SUCCESS;
 929         String statement;
 930
 931         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 932         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 933
 934         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
 935         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 936
 937         r = pDatabase->BeginTransaction();
 938         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
 939
 940         statement.Append(L"DELETE from rootcert");
 941
 942         r = pDatabase->ExecuteSql(statement, true);
 943         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql.", GetErrorMessage(r));
 944
 945         r = pDatabase->CommitTransaction();
 946         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
 947
 948         return r;
 949 }
 950
 951 result
 952 _CaCertDbStore::GetNumberOfCertificates(int& count)
 953 {
 954         result r = E_SUCCESS;
 955
 956         String statement;
 957         int certCount = 0;
 958
 959         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
 960         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
 961
 962         r = pDatabase->Construct(_CERT_ROOT_CA_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
 963         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
 964
 965         statement.Append(L"SELECT * FROM rootcert");
 966         std::unique_ptr< DbStatement > pStmt(pDatabase->CreateStatementN(statement));
 967         std::unique_ptr< DbEnumerator > pEnum(pDatabase->ExecuteStatementN(*pStmt));
 968         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
 969
 970         while (pEnum->MoveNext() == E_SUCCESS)
 971         {
 972                 certCount++;
 973         }
 974
 975         count = certCount;
 976
 977         return r;
 978 }
 979
 980 _UserCertDbStore::_UserCertDbStore(void)
 981 {
 982 }
 983
 984 _UserCertDbStore::~_UserCertDbStore(void)
 985 {
 986 }
 987
 988 result
 989 _UserCertDbStore::InsertUserCertificate(UserCertRecord* pCertRecord)
 990 {
 991         result r = E_SUCCESS;
 992         byte subjectNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 993         byte issuerNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
 994         byte base64SerialNum[_MAX_SERIAL_NUMBER_SIZE] = {0, };
 995         int subjectNameBase64Len = 0;
 996         int base64IssuerNameLen = 0;
 997         int base64SerialNumLen = 0;
 998         String statement;
 999
1000         SysTryReturnResult(NID_SEC_CERT, pCertRecord != null, E_INVALID_ARG, "Invalid input parameter.");
1001
1002         memcpy(subjectNameBase64, pCertRecord->subjectName, pCertRecord->subjectNameLen);
1003         memcpy(issuerNameBase64, pCertRecord->issuerName, pCertRecord->issuerNameLen);
1004         memcpy(base64SerialNum, pCertRecord->serialNo, _MAX_SERIAL_NUMBER_SIZE);
1005         memset(pCertRecord->subjectName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
1006         memset(pCertRecord->issuerName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
1007         memset(pCertRecord->serialNo, 0, _MAX_SERIAL_NUMBER_SIZE);
1008
1009         subjectNameBase64Len = _Base64::GetEncodedSize(pCertRecord->subjectNameLen);
1010         memset(pCertRecord->subjectName, 0, sizeof(pCertRecord->subjectName));
1011         r = _Base64::Encode(static_cast< byte* >(subjectNameBase64), pCertRecord->subjectNameLen, pCertRecord->subjectName, subjectNameBase64Len);
1012         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode subject name of certificate.");
1013
1014         pCertRecord->subjectNameLen = subjectNameBase64Len;
1015
1016         base64IssuerNameLen = _Base64::GetEncodedSize(pCertRecord->issuerNameLen);
1017         memset(pCertRecord->issuerName, 0, sizeof(pCertRecord->issuerName));
1018         r = _Base64::Encode(static_cast< byte* >(issuerNameBase64), pCertRecord->issuerNameLen, pCertRecord->issuerName, base64IssuerNameLen);
1019         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode issuer name of certificate.");
1020
1021         pCertRecord->issuerNameLen = base64IssuerNameLen;
1022
1023         base64SerialNumLen = _Base64::GetEncodedSize(pCertRecord->serialNoLen);
1024         memset(pCertRecord->serialNo, 0, sizeof(pCertRecord->serialNo));
1025         r = _Base64::Encode(static_cast< byte* >(base64SerialNum), pCertRecord->serialNoLen, pCertRecord->serialNo, base64SerialNumLen);
1026         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode serial number of certificate.");
1027
1028         pCertRecord->serialNoLen = base64SerialNumLen;
1029
1030         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1031         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1032
1033         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
1034         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "Failed to construct database instance.");
1035
1036         r = pDatabase->BeginTransaction();
1037         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1038
1039         statement.Append(L"INSERT INTO usercert (certId, certPubKeyHash, certFormat, fileName, subjectNameLen, subjectName, issuerNameLen, issuerName, prvKeyPath, prvKeyLen, parentCa, installed, serialNo, serialNoLen) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?)");
1040         std::unique_ptr< DbStatement > pStmt(pDatabase->CreateStatementN(statement));
1041         r = pStmt->BindString(1, pCertRecord->certPubKeyHash);
1042         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1043         r = pStmt->BindInt(2, pCertRecord->certFormat);
1044         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1045         r = pStmt->BindString(3, pCertRecord->fileName);
1046         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1047         r = pStmt->BindInt(4, pCertRecord->subjectNameLen);
1048         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1049         r = pStmt->BindString(5, pCertRecord->subjectName);
1050         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1051         r = pStmt->BindInt(6, pCertRecord->issuerNameLen);
1052         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1053         r = pStmt->BindString(7, pCertRecord->issuerName);
1054         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1055         r = pStmt->BindString(8, pCertRecord->prvKeyPath);
1056         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1057         r = pStmt->BindInt(9, pCertRecord->prvKeyLen);
1058         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1059         r = pStmt->BindInt(10, pCertRecord->parentCa);
1060         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1061         r = pStmt->BindString(11, pCertRecord->installed);
1062         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1063         r = pStmt->BindString(12, pCertRecord->serialNo);
1064         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1065         r = pStmt->BindInt(13, pCertRecord->serialNoLen);
1066         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1067         std::unique_ptr< DbEnumerator > pEnum(pDatabase->ExecuteStatementN(*pStmt));
1068         AppAssert(!pEnum);
1069
1070         r = pDatabase->CommitTransaction();
1071         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
1072
1073         return r;
1074 }
1075
1076 result
1077 _UserCertDbStore::UpdateParentCa(int certId, int parentCa)
1078 {
1079         result r = E_SUCCESS;
1080         String statement(_MAX_QUERY_LEN);
1081
1082         SysTryReturnResult(NID_SEC_CERT, certId > 0, E_INVALID_ARG, "Invalid input parameter.");
1083         SysTryReturnResult(NID_SEC_CERT, parentCa > 0, E_INVALID_ARG, "Invalid input parameter.");
1084
1085         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1086         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory.");
1087
1088         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
1089         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1090
1091         r = pDatabase->BeginTransaction();
1092         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1093
1094         statement.Format(_MAX_QUERY_LEN, L"UPDATE usercert SET parentCa = '%d' WHERE certId = '%d'", parentCa, certId);
1095         r = pDatabase->ExecuteSql(statement, true);
1096         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql.", GetErrorMessage(r));
1097
1098         r = pDatabase->CommitTransaction();
1099         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
1100
1101         return r;
1102 }
1103
1104 result
1105 _UserCertDbStore::UpdateRecordByCondition(byte* pCondition)
1106 {
1107         result r = E_SUCCESS;
1108         String statement(_MAX_QUERY_LEN);
1109
1110         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Invalid input parameter.");
1111
1112         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1113         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1114
1115         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
1116         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1117
1118         r = pDatabase->BeginTransaction();
1119         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1120
1121         statement.Format(_MAX_QUERY_LEN, L"UPDATE usercert SET %s", pCondition);
1122
1123         r = pDatabase->ExecuteSql(statement, true);
1124         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql statement.", GetErrorMessage(r));
1125
1126         r = pDatabase->CommitTransaction();
1127         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transactoin.", GetErrorMessage(r));
1128
1129         return r;
1130 }
1131
1132 result
1133 _UserCertDbStore::RemoveCertificateByCondition(byte* pCondition)
1134 {
1135         result r = E_SUCCESS;
1136
1137
1138         int curCertId = 0;
1139         String statement(_MAX_QUERY_LEN);
1140         String strVal;
1141
1142         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Invalid input parameter.");
1143
1144         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1145         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1146
1147         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
1148         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1149
1150         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM usercert WHERE %s ORDER BY certId", pCondition);
1151         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1152         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
1153
1154
1155         while (pEnum->MoveNext() == E_SUCCESS)
1156         {
1157                 r = pEnum->GetIntAt(0, curCertId);
1158                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
1159
1160                 r = _UserCertDbStore::RemoveCertificateById(curCertId);
1161                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to delete record from database.", GetErrorMessage(r));
1162
1163                 r = pEnum->GetStringAt(4, strVal);
1164                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
1165
1166                 Tizen::Io::File::Remove(strVal);
1167         }
1168
1169         return r;
1170 }
1171
1172 result
1173 _UserCertDbStore::CheckDuplicateCertificate(byte* pSubjectName, int subjectNameLen)
1174 {
1175         result r = E_SUCCESS;
1176         char subjectNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
1177         int subjectNameBase64Len = 0;
1178         String statement(_MAX_QUERY_LEN);
1179
1180         SysTryReturnResult(NID_SEC_CERT, pSubjectName != null, E_INVALID_ARG, "Invalid input parameter.");
1181         SysTryReturnResult(NID_SEC_CERT, subjectNameLen > 0, E_INVALID_ARG, "Invalid input parameter.");
1182
1183         subjectNameBase64Len = _Base64::GetEncodedSize(subjectNameLen);
1184         memset(subjectNameBase64, 0, sizeof(subjectNameBase64));
1185         r = _Base64::Encode(static_cast< byte* >(pSubjectName), subjectNameLen, subjectNameBase64, subjectNameBase64Len);
1186         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode subject name of certificate.");
1187
1188         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1189         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1190
1191         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1192         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1193
1194         r = pDatabase->BeginTransaction();
1195         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1196
1197         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM usercert WHERE subjectName = '%s' AND subjectNameLen = '%d'", subjectNameBase64, subjectNameBase64Len);
1198
1199         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1200         r = GetLastResult();
1201         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r) , r, "Failed to get query result.");
1202         SysTryReturnResult(NID_SEC_CERT, pEnum != null , E_DATA_NOT_FOUND, "No certificate found in database.");
1203
1204         return r;
1205 }
1206
1207 result
1208 _UserCertDbStore::CheckDuplicateCertificate(byte* pIssuerName, int issuerNameLen, byte* pSerialNumber)
1209 {
1210         result r = E_SUCCESS;
1211         char issuerNameBase64[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
1212         char base64SerialNo[_MAX_SERIAL_NUMBER_SIZE] = {0, };
1213         int base64IssuerNameLen = 0;
1214         int base64SerialNoLen = 0;
1215         int serialNoLen = 0;
1216         String statement(_MAX_QUERY_LEN);
1217
1218         SysTryReturnResult(NID_SEC_CERT, pIssuerName != null, E_INVALID_ARG, "Invald input parameter");
1219         SysTryReturnResult(NID_SEC_CERT, issuerNameLen >= 0, E_INVALID_ARG, "Invald input parameter");
1220         SysTryReturnResult(NID_SEC_CERT, pSerialNumber != null, E_INVALID_ARG, "Invald input parameter");
1221
1222         base64IssuerNameLen = _Base64::GetEncodedSize(issuerNameLen);
1223         memset(issuerNameBase64, 0, sizeof(issuerNameBase64));
1224         r = _Base64::Encode(pIssuerName, issuerNameLen, issuerNameBase64, base64IssuerNameLen);
1225         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode issuer name of certificate.");
1226
1227         serialNoLen = strlen(reinterpret_cast< const char* >(pSerialNumber));
1228
1229         base64SerialNoLen = _Base64::GetEncodedSize(serialNoLen);
1230         memset(base64SerialNo, 0, sizeof(base64SerialNo));
1231         r = _Base64::Encode(pSerialNumber, serialNoLen, base64SerialNo, base64SerialNoLen);
1232         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_ENCODING_FAILED, "Failed to encode serial number of certificate.");
1233
1234         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1235         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1236
1237         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1238         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1239
1240         r = pDatabase->BeginTransaction();
1241         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1242
1243         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM usercert WHERE issuerName = '%s' AND issuerNameLen = '%d' AND serialNo = '%s'", issuerNameBase64, base64IssuerNameLen, base64SerialNo);
1244         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1245         r = GetLastResult();
1246         SysTryReturnResult(NID_SEC_CERT, !IsFailed(r) , r, "Failed to get query result.");
1247         SysTryReturnResult(NID_SEC_CERT, pEnum != null , E_DATA_NOT_FOUND, "No certificate found in database.");
1248
1249         return r;
1250 }
1251
1252 result
1253 _UserCertDbStore::GetFirstRecordByConditions(byte* pCondition, UserCertRecord* pCertRecord)
1254 {
1255         result r = E_SUCCESS;
1256         String statement(_MAX_QUERY_LEN);
1257         char tmpName[_MAX_ISSUER_SUBJECT_NAME_SIZE] = {0, };
1258         int len = 0;
1259         String strVal;
1260
1261         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Invalid input parameter");
1262         SysTryReturnResult(NID_SEC_CERT, pCertRecord != null, E_INVALID_ARG, "Invalid input parameter");
1263
1264         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1265         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1266
1267         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1268         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1269
1270         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM usercert WHERE %s", pCondition);
1271         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1272         SysTryReturn(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, E_DATA_NOT_FOUND, "No certificate found in database.");
1273
1274
1275         r = pEnum->MoveNext();
1276         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
1277
1278         r = pEnum->GetIntAt(0, pCertRecord->certId);
1279         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 0.", GetErrorMessage(r));
1280
1281         r = pEnum->GetStringAt(1, strVal);
1282         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 1.", GetErrorMessage(r));
1283
1284         std::unique_ptr< ByteBuffer > pTempBuf(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1285         r = GetLastResult();
1286         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1287
1288         memcpy(pCertRecord->certPubKeyHash, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1289         pCertRecord->certPubKeyHash[pTempBuf->GetRemaining()] = '\0';
1290
1291         r = pEnum->GetIntAt(2, pCertRecord->certFormat);
1292         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 2.", GetErrorMessage(r));
1293
1294         r = pEnum->GetStringAt(3, strVal);
1295         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 3.", GetErrorMessage(r));
1296
1297         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1298         r = GetLastResult();
1299         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1300
1301         memcpy(pCertRecord->fileName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1302         pCertRecord->fileName[pTempBuf->GetRemaining()] = '\0';
1303
1304         r = pEnum->GetIntAt(4, pCertRecord->subjectNameLen);
1305         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 4.", GetErrorMessage(r));
1306
1307         r = pEnum->GetStringAt(5, strVal);
1308         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 5.", GetErrorMessage(r));
1309
1310         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1311         r = GetLastResult();
1312         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1313
1314         memset(tmpName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
1315         memcpy(tmpName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1316         _Base64::Decode(tmpName, pCertRecord->subjectNameLen, reinterpret_cast< byte* >(pCertRecord->subjectName), pCertRecord->subjectNameLen);
1317
1318         r = pEnum->GetIntAt(6, pCertRecord->issuerNameLen);
1319         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 6.", GetErrorMessage(r));
1320
1321         r = pEnum->GetStringAt(7, strVal);
1322         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 7.", GetErrorMessage(r));
1323
1324         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1325         r = GetLastResult();
1326         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1327
1328
1329         memset(tmpName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
1330         memcpy(tmpName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1331         _Base64::Decode(tmpName, pCertRecord->issuerNameLen, reinterpret_cast< byte* >(pCertRecord->issuerName), pCertRecord->issuerNameLen);
1332
1333         r = pEnum->GetStringAt(8, strVal);
1334         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 8.", GetErrorMessage(r));
1335
1336         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1337         if (pTempBuf)
1338         {
1339                 memcpy(pCertRecord->prvKeyPath, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1340         }
1341         else
1342         {
1343                 memset(pCertRecord->prvKeyPath, 0, _MAX_PRV_KEY_PATH_SIZE_SIZE);
1344         }
1345
1346         r = pEnum->GetIntAt(9, pCertRecord->prvKeyLen);
1347         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 9.", GetErrorMessage(r));
1348
1349         r = pEnum->GetIntAt(10, pCertRecord->parentCa);
1350         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 10.", GetErrorMessage(r));
1351
1352         r = pEnum->GetStringAt(11, strVal);
1353         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 11.", GetErrorMessage(r));
1354
1355         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1356         r = GetLastResult();
1357         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1358
1359         memcpy(pCertRecord->installed, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1360         pCertRecord->installed[pTempBuf->GetRemaining()] = '\0';
1361
1362         r = pEnum->GetStringAt(12, strVal);
1363         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 12.", GetErrorMessage(r));
1364
1365         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1366         r = GetLastResult();
1367         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1368
1369         memset(tmpName, 0, _MAX_ISSUER_SUBJECT_NAME_SIZE);
1370         memcpy(tmpName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1371
1372         len = pTempBuf->GetRemaining();
1373         _Base64::Decode(tmpName, len, reinterpret_cast< byte* >(pCertRecord->serialNo), len);
1374
1375         r = pEnum->GetIntAt(13, pCertRecord->serialNoLen);
1376         pCertRecord->serialNoLen = _Base64::GetDecodedSize(pCertRecord->serialNoLen);
1377         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 13.", GetErrorMessage(r));
1378
1379         return r;
1380 }
1381
1382 result
1383 _UserCertDbStore::GetNextRecordByCondition(byte* pCondition, UserCertRecord* pCertRecord, int curCertId)
1384 {
1385         result r = E_SUCCESS;
1386         String statement(_MAX_QUERY_LEN);
1387         String strVal;
1388
1389         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Input parameters are invalid");
1390         SysTryReturnResult(NID_SEC_CERT, pCertRecord != null, E_INVALID_ARG, "Input parameters are invalid");
1391
1392         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1393         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1394
1395         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1396         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1397
1398         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM usercert WHERE %s AND certId > '%d'", pCondition, curCertId);
1399         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1400         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
1401
1402         r = pEnum->MoveNext();
1403         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
1404
1405         r = pEnum->GetIntAt(0, pCertRecord->certId);
1406         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 0.", GetErrorMessage(r));
1407
1408         r = pEnum->GetStringAt(1, strVal);
1409         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 1.", GetErrorMessage(r));
1410
1411         std::unique_ptr< ByteBuffer > pTempBuf(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1412         r = GetLastResult();
1413         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1414
1415         memcpy(pCertRecord->certPubKeyHash, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1416         pCertRecord->certPubKeyHash[pTempBuf->GetRemaining()] = '\0';
1417
1418         r = pEnum->GetIntAt(2, pCertRecord->certFormat);
1419         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 2.", GetErrorMessage(r));
1420
1421         r = pEnum->GetStringAt(3, strVal);
1422         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 3.", GetErrorMessage(r));
1423
1424         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1425         r = GetLastResult();
1426         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1427
1428         memcpy(pCertRecord->fileName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1429         pCertRecord->fileName[pTempBuf->GetRemaining()] = '\0';
1430
1431         r = pEnum->GetIntAt(4, pCertRecord->subjectNameLen);
1432         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 4.", GetErrorMessage(r));
1433
1434         r = pEnum->GetStringAt(5, strVal);
1435         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 5.", GetErrorMessage(r));
1436
1437         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1438         r = GetLastResult();
1439         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1440
1441         memcpy(pCertRecord->subjectName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1442         pCertRecord->subjectName[pTempBuf->GetRemaining()] = '\0';
1443
1444         r = pEnum->GetIntAt(6, pCertRecord->issuerNameLen);
1445         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 6.", GetErrorMessage(r));
1446
1447         r = pEnum->GetStringAt(7, strVal);
1448         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 7.", GetErrorMessage(r));
1449
1450         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1451         r = GetLastResult();
1452         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1453
1454         memcpy(pCertRecord->issuerName, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1455         pCertRecord->issuerName[pTempBuf->GetRemaining()] = '\0';
1456
1457         r = pEnum->GetStringAt(8, strVal);
1458         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 8.", GetErrorMessage(r));
1459
1460         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1461         if (pTempBuf)
1462         {
1463                 memcpy(pCertRecord->prvKeyPath, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1464         }
1465         else
1466         {
1467                 memset(pCertRecord->prvKeyPath, 0, _MAX_PRV_KEY_PATH_SIZE_SIZE);
1468         }
1469
1470         r = pEnum->GetIntAt(9, pCertRecord->prvKeyLen);
1471         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 9.", GetErrorMessage(r));
1472
1473         r = pEnum->GetIntAt(10, pCertRecord->parentCa);
1474         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 10.", GetErrorMessage(r));
1475
1476         r = pEnum->GetStringAt(11, strVal);
1477         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 11.", GetErrorMessage(r));
1478
1479         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1480         r = GetLastResult();
1481         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1482
1483         memcpy(pCertRecord->installed, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1484         pCertRecord->installed[pTempBuf->GetRemaining()] = '\0';
1485
1486         r = pEnum->GetStringAt(12, strVal);
1487         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 12.", GetErrorMessage(r));
1488
1489         pTempBuf.reset(Tizen::Base::Utility::StringUtil::StringToUtf8N(strVal));
1490         r = GetLastResult();
1491         SysTryReturn(NID_SEC_CERT, pTempBuf != null, r, r, "[%s] String to Utf8 function failed.", GetErrorMessage(r));
1492
1493         memcpy(pCertRecord->serialNo, reinterpret_cast< const char* >(pTempBuf->GetPointer()), pTempBuf->GetRemaining());
1494         pCertRecord->serialNo[pTempBuf->GetRemaining()] = '\0';
1495
1496         r = pEnum->GetIntAt(13, pCertRecord->serialNoLen);
1497         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database from column 13.", GetErrorMessage(r));
1498
1499         return r;
1500 }
1501
1502 result
1503 _UserCertDbStore::GetCurrentCertId(int& curCertId)
1504 {
1505         result r = E_SUCCESS;
1506         int certId = 0;
1507
1508         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1509         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1510
1511         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1512         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1513
1514         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN("SELECT seq FROM sqlite_sequence"));
1515         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
1516
1517         r = pEnum->MoveNext();
1518         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to move next.", GetErrorMessage(r));
1519
1520         r = pEnum->GetIntAt(0, certId);
1521         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
1522
1523         curCertId = certId;
1524
1525         return r;
1526 }
1527
1528 result
1529 _UserCertDbStore::GetCountByCondition(byte* pCondition, int& count)
1530 {
1531         result r = E_SUCCESS;
1532         int certCount = 0;
1533         String statement(_MAX_QUERY_LEN);
1534
1535         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Input parameter are invalid");
1536
1537         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1538         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1539
1540         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1541         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Construct fails.", GetErrorMessage(r));
1542
1543         statement.Format(_MAX_QUERY_LEN, L"SELECT * FROM usercert WHERE %s", pCondition);
1544         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1545         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in Db.");
1546
1547         while (pEnum->MoveNext() == E_SUCCESS)
1548         {
1549                 certCount++;
1550         }
1551
1552         count = certCount;
1553
1554         return r;
1555 }
1556
1557 result
1558 _UserCertDbStore::GetParentCaByCondition(byte* pCondition, int& parentCa)
1559 {
1560         result r = E_SUCCESS;
1561         int currParentCa = 0;
1562         String statement(_MAX_QUERY_LEN);
1563
1564         SysTryReturnResult(NID_SEC_CERT, pCondition != null, E_INVALID_ARG, "Input parameter are invalid");
1565
1566         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1567         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1568
1569         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1570         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1571
1572         statement.Format(_MAX_QUERY_LEN, L"SELECT parentCa FROM usercert WHERE %s", pCondition);
1573         std::unique_ptr< DbEnumerator > pEnum(pDatabase->QueryN(statement));
1574         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
1575
1576         if (pEnum->MoveNext() == E_SUCCESS)
1577         {
1578                 r = pEnum->GetIntAt(10, currParentCa);
1579                 SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Unable to get data from database.", GetErrorMessage(r));
1580         }
1581
1582         parentCa = currParentCa;
1583
1584         return r;
1585 }
1586
1587 result
1588 _UserCertDbStore::SelectUserCertificateBycertId(int certId, UserCertRecord* pCertRecord)
1589 {
1590         byte condition[_MAX_TYPE_CONST_SIZE] = {0, };
1591
1592         return _UserCertDbStore::GetNextRecordByCondition(static_cast< byte* >(condition), pCertRecord, certId);
1593
1594 }
1595
1596 result
1597 _UserCertDbStore::RemoveCertificateById(int certId)
1598 {
1599         result r = E_SUCCESS;
1600         String statement;
1601
1602         SysTryReturnResult(NID_SEC_CERT, certId > 0, E_INVALID_ARG, "Invalid input certificate id.");
1603
1604         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1605         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1606
1607         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
1608         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1609
1610         r = pDatabase->BeginTransaction();
1611         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1612
1613         statement.Append(L"DELETE FROM usercert WHERE certId = ?");
1614         std::unique_ptr< DbStatement > pStmt(pDatabase->CreateStatementN(statement));
1615         SysTryReturn(NID_SEC_CERT, pStmt, GetLastResult(), GetLastResult(), "[%s] Failed to create statement.", GetErrorMessage(GetLastResult()));
1616
1617         r = pStmt->BindInt(0, certId);
1618         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to bind colmun in database statement.", GetErrorMessage(r));
1619
1620         pDatabase->ExecuteStatementN(*pStmt);
1621
1622         r = pDatabase->CommitTransaction();
1623         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
1624
1625         return r;
1626 }
1627
1628 result
1629 _UserCertDbStore::RemoveAllCertificates(void)
1630 {
1631         result r = E_SUCCESS;
1632         String statement;
1633
1634         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1635         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1636
1637         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_WRITE, 0);
1638         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1639
1640         r = pDatabase->BeginTransaction();
1641         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to begin transaction.", GetErrorMessage(r));
1642
1643         statement.Append(L"DELETE from usercert");
1644         r = pDatabase->ExecuteSql(statement, true);
1645         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to execute sql.", GetErrorMessage(r));
1646
1647         r = pDatabase->CommitTransaction();
1648         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to commit transaction.", GetErrorMessage(r));
1649
1650         return r;
1651 }
1652
1653 result
1654 _UserCertDbStore::GetNumberOfCertificates(int& count)
1655 {
1656         result r = E_SUCCESS;
1657         String statement;
1658         int certCount = 0;
1659
1660         std::unique_ptr< Database > pDatabase(new (std::nothrow) Database());
1661         SysTryReturnResult(NID_SEC_CERT, pDatabase != null, E_OUT_OF_MEMORY, "Failed to allocate memory");
1662
1663         r = pDatabase->Construct(_CERT_USER_CERT_TABLE, DB_OPEN_READ_ONLY, 0);
1664         SysTryReturn(NID_SEC_CERT, !IsFailed(r), r, r, "[%s] Failed to construct database instance.", GetErrorMessage(r));
1665
1666         statement.Append(L"SELECT * FROM usercert");
1667
1668         std::unique_ptr< DbStatement > pStmt(pDatabase->CreateStatementN(statement));
1669         SysTryReturnResult(NID_SEC_CERT, pStmt != null, E_DATA_NOT_FOUND, "Failed to create statement for user certifcates.");
1670
1671         std::unique_ptr< DbEnumerator > pEnum(pDatabase->ExecuteStatementN(*pStmt.get()));
1672         SysTryReturnResult(NID_SEC_CERT, pEnum != null, E_DATA_NOT_FOUND, "No certificate found in database.");
1673
1674         while (pEnum->MoveNext() == E_SUCCESS)
1675         {
1676                 certCount++;
1677         }
1678
1679         count = certCount;
1680
1681         return r;
1682 }
1683
1684 } } } //Tizen::Security::Cert