2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
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
8 // http://www.apache.org/licenses/LICENSE-2.0
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.
18 * @file FIo_SecureIoUtil.cpp
19 * @brief This is the implementation file for the %_SecureIoUilt class.
25 #include <sys/types.h>
32 #include <unique_ptr.h>
34 #include <FBaseString.h>
36 #include <FBaseResult.h>
37 #include <FSecSecretKey.h>
38 #include <FSecSecretKeyGenerator.h>
39 #include <FSecCryptoSha1Hash.h>
40 #include <FSecCryptoAesCipher.h>
42 #include <FBase_NativeError.h>
43 #include <FBaseSysLog.h>
44 #include <FBase_StringConverter.h>
45 #include <FIo_SecureIoUtil.h>
46 #include <FIo_FileUtil.h>
47 #include <FApp_AppInfo.h>
50 using namespace Tizen::Base;
51 using namespace Tizen::Security;
52 using namespace Tizen::Security::Crypto;
53 using namespace Tizen::App;
55 namespace Tizen { namespace Io
58 static const int SECURE_IO_4_BITS = 4;
59 static const int SECURE_IO_8_BITS = 8;
60 static const int SECURE_IO_3_BYTES = 3;
61 static const int SECURE_IO_4_BYTES = 4;
62 static const int SECURE_IO_5_BYTES = 5;
63 static const int SECURE_IO_8_BYTES = 8;
64 static const int SECURE_IO_9_BYTES = 9;
65 static const int SECURE_IO_HEX_0F = 0x0f;
66 static const int SECURE_IO_HEX_FC = 0xfc;
67 static const int SECURE_IO_HEX_FD = 0xfd;
68 static const int SECURE_IO_HEX_FE = 0xfe;
69 static const int SECURE_IO_HEX_FF = 0xff;
70 static const int DATABASE_KEY_LENGTH = 16;
71 static const int AES_KEY_LENGTH = 16;
73 const char SECURE_FILE_HEADER_STRING[] = {0x74, 0x69, 0x7a, 0x65, 0x6e, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x66, 0x69, 0x6c, 0x65};
74 const char SECURE_REG_HEADER_STRING[] = {0x74, 0x69, 0x7a, 0x65, 0x6e, 0x20, 0x73, 0x65, 0x63, 0x75, 0x72, 0x65, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79};
75 static const wchar_t* _CIPHER_INFORMATION = L"CBC/128/NOPADDING";
78 _SecureIoUtil::GetSecureKeyN(const ByteBuffer* pUserKey)
82 unique_ptr< Tizen::Base::ByteBuffer > pKey(new (std::nothrow) ByteBuffer());
83 SysTryReturn(NID_IO, pKey != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
85 r = pKey->Construct(AES_KEY_LENGTH);
86 SysTryReturn(NID_IO, !IsFailed(r), null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
88 if (pUserKey->GetRemaining() >= AES_KEY_LENGTH)
90 r = pKey->SetArray(pUserKey->GetPointer(), 0, AES_KEY_LENGTH);
91 SysTryReturn(NID_IO, !IsFailed(r), null, r, "[%s] Propagated.", GetErrorMessage(r));
97 int tempLength = pUserKey->GetRemaining();
98 int loopCount = AES_KEY_LENGTH / tempLength;
100 for(int i = 0; i < loopCount; i++)
103 r = pKey->SetArray(pUserKey->GetPointer(), 0, tempLength);
104 SysTryReturn(NID_IO, !IsFailed(r), null, r, "[%s] Propagated.", GetErrorMessage(r));
108 if (AES_KEY_LENGTH % tempLength)
110 r = pKey->SetArray(pUserKey->GetPointer(), 0, (AES_KEY_LENGTH % tempLength));
111 SysTryReturn(NID_IO, !IsFailed(r), null, r, "[%s] Propagated.", GetErrorMessage(r));
121 return pKey.release();
125 _SecureIoUtil::DoCipherAesN(const String transformation, const ByteBuffer& input, const ByteBuffer& key, CipherOperation encMode)
127 result r = E_SUCCESS;
130 SecretKeyGenerator secKeyGenerator;
132 static byte ivArray[] = {0x3E, 0xB5, 0x01, 0x45, 0xE4, 0xF8, 0x75, 0x3F, 0x08, 0x9D, 0x9F, 0x57, 0x3B, 0x63, 0xEF, 0x4B };
134 r = aesCipher.Construct(transformation, encMode);
135 SysTryReturn(NID_IO, !IsFailed(r), null, r, "[%s] Propagated.", GetErrorMessage(r));
137 r = ivBuffer.Construct(sizeof(ivArray));
138 SysTryReturn(NID_IO, !IsFailed(r), null, r, "[%s] Propagated.", GetErrorMessage(r));
140 r = ivBuffer.SetArray(ivArray, 0, sizeof(ivArray));
141 SysTryReturn(NID_IO, !IsFailed(r), null, r, "[%s] Propagated.", GetErrorMessage(r));
145 r = aesCipher.SetInitialVector(ivBuffer);
146 SysTryReturn(NID_IO, !IsFailed(r), null, r, "[%s] Propagated.", GetErrorMessage(r));
148 r = secKeyGenerator.Construct(key);
149 SysTryReturn(NID_IO, !IsFailed(r), null, r, "[%s] Propagated.", GetErrorMessage(r));
151 unique_ptr< ISecretKey > pKey(reinterpret_cast< ISecretKey* >(secKeyGenerator.GenerateKeyN()));
152 SysTryReturn(NID_IO, pKey != null, null, GetLastResult(), "[%s] Failed to generate key.", GetErrorMessage(GetLastResult()));
154 r = aesCipher.SetKey(*pKey.get());
155 SysTryReturn(NID_IO, !IsFailed(r), null, r, "[%s] Failed to set secret key.", GetErrorMessage(r));
157 unique_ptr< ByteBuffer > pOutBuf(null);
159 if (encMode == CIPHER_ENCRYPT)
161 pOutBuf = unique_ptr< ByteBuffer >(aesCipher.EncryptN(input));
165 pOutBuf = unique_ptr< ByteBuffer >(aesCipher.DecryptN(input));
168 SysTryReturn(NID_IO, pOutBuf != null, null, GetLastResult(), "[%s] Failed to decrypt data.", GetErrorMessage(GetLastResult()));
170 SetLastResult(E_SUCCESS);
171 return pOutBuf.release();
175 _SecureIoUtil::IsEndOfFile(_NormalFile* pNormalFile)
177 result r = E_SUCCESS;
180 int current = pNormalFile->Tell();
181 SysTryReturn(NID_IO, current != -1, false, GetLastResult(), "[%s] Failed to tell in file.", GetErrorMessage(GetLastResult()));
183 int ret = pNormalFile->Read(&flag, 1); //ignore ret as we are only looking for EOF.
184 if (GetLastResult() == E_END_OF_FILE && ret == 0)
189 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, current);
190 SysTryReturn(NID_IO, !IsFailed(r), false, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
196 _SecureIoUtil::InsertSecureFileHeader(_NormalFile* pNormalFile)
198 result r = E_SUCCESS;
200 byte secureHeader[SECURE_FILE_HEADER_SIZE_V1];
201 byte reservedValue[SECURE_IO_STATIC_BIN_LEN] = {0xCA, 0xFE, 0xBE, 0xBE, 0xDA, 0xEF, 0xEB, 0xEB};
204 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, 0);
205 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
207 ret = pNormalFile->Read(secureHeader, SECURE_FILE_HEADER_SIZE_V1);
208 if (ret < SECURE_FILE_HEADER_SIZE_V1)
212 if (ret == 0 && IsEndOfFile(pNormalFile)) //is true
214 memcpy(secureHeader, SECURE_FILE_HEADER_STRING, SECURE_FILE_HEADER_STRING_SIZE);
215 memcpy(secureHeader + SECURE_FILE_HEADER_STRING_SIZE, reservedValue, SECURE_IO_STATIC_BIN_LEN);
216 secureHeader[SECURE_FILE_HEADER_STRING_SIZE + SECURE_IO_STATIC_BIN_LEN] = SECURE_IO_2_BYTES;
217 secureHeader[SECURE_FILE_HEADER_STRING_SIZE + SECURE_IO_STATIC_BIN_LEN + SECURE_IO_FLAG_SIZE] = 0;
218 memset(secureHeader + SECURE_FILE_HEADER_STRING_SIZE + SECURE_IO_STATIC_BIN_LEN + SECURE_IO_FLAG_SIZE + SECURE_IO_INDEX_SIZE, 0, SECURE_IO_LOF_SIZE);
219 memset(secureHeader + SECURE_FILE_HEADER_STRING_SIZE + SECURE_IO_STATIC_BIN_LEN + SECURE_IO_FLAG_SIZE + SECURE_IO_INDEX_SIZE + SECURE_IO_LOF_SIZE, 0, SECURE_IO_LOF_SIZE);
221 r = pNormalFile->Write(secureHeader, SECURE_FILE_HEADER_SIZE_V1);
222 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] [%s] Failed to write in file.", GetErrorMessage(r));
227 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
229 } //Else it means that header is already written
235 _SecureIoUtil::SaveLengthOfFile(_NormalFile* pNormalFile)
237 result r = E_SUCCESS;
239 byte lengthOfFile[SECURE_IO_LOF_SIZE] = {0, 0, 0, 0};
242 r = pNormalFile->Seek(FILESEEKPOSITION_END, 0);
243 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
245 length = pNormalFile->Tell();
246 SysTryReturn(NID_IO, length != -1, GetLastResult(), GetLastResult(), "[%s] Failed to tell in file.", GetErrorMessage(GetLastResult()));
248 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, SECURE_FILE_HEADER_STRING_SIZE + SECURE_IO_10_BYTES);
249 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
251 if (sizeof(length) != SECURE_IO_LOF_SIZE)
253 memcpy(lengthOfFile + SECURE_IO_LOF_SIZE - sizeof(length), &length, sizeof(length));
257 memcpy(lengthOfFile, &length, SECURE_IO_LOF_SIZE);
260 r = pNormalFile->Write(lengthOfFile, SECURE_IO_LOF_SIZE);
261 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to write in file.", GetErrorMessage(r));
267 _SecureIoUtil::SelectCipherBlock(_NormalFile* pNormalFile, long virtualFilePointer, int* pPosition)
269 result r = E_SUCCESS;
273 long blockDataSize = 0;
274 byte secureHeader[SECURE_FILE_HEADER_SIZE_V1] = {0, };
275 byte blockHeader[CIPHER_BLOCK_HEADER_SIZE] = {0, 0, 0};
276 byte* pBlockDataCur = null;
279 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, 0);
282 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
284 ret = pNormalFile->Read(secureHeader, SECURE_FILE_HEADER_SIZE_V1);
285 if (ret < SECURE_FILE_HEADER_SIZE_V1)
289 if (ret == 0 && IsEndOfFile(pNormalFile))
294 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
298 //read 1byte to check padding size
301 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, count * (CIPHER_BLOCK_SIZE + CIPHER_BLOCK_HEADER_SIZE) + SECURE_FILE_HEADER_SIZE_V1);
302 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
304 ret = pNormalFile->Read(blockHeader, CIPHER_BLOCK_HEADER_SIZE);
305 if (ret < CIPHER_BLOCK_HEADER_SIZE) //less data read
309 if (ret == 0 && IsEndOfFile(pNormalFile))
314 SysLog(NID_IO, "[%s] Failed to read data from file", GetErrorMessage(r));
320 pBlockDataCur = (byte*) (&blockDataSize);
321 *pBlockDataCur = blockHeader[SECURE_IO_2_BYTES];
322 *(pBlockDataCur + 1) = blockHeader[1];
323 *(pBlockDataCur + SECURE_IO_2_BYTES) = blockHeader[0];
325 if (virtualFilePointer <= dataSize + blockDataSize)
327 *pPosition = virtualFilePointer - dataSize;
328 if (*pPosition == CIPHER_BLOCK_SIZE)
330 r = pNormalFile->Seek(FILESEEKPOSITION_CURRENT, CIPHER_BLOCK_SIZE);
335 r = pNormalFile->Seek(FILESEEKPOSITION_CURRENT, -CIPHER_BLOCK_HEADER_SIZE);
339 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
344 dataSize = dataSize + blockDataSize;
354 _SecureIoUtil::DetectNewLine(byte* pData, int readSize, int preReadSize, int* pTerminationCur, int* newLineSize)
360 for (count = preReadSize; count < readSize; count++)
362 if (pData[count] == '\r' && pData[count + 1] == '\n')
364 *pTerminationCur = count;
365 *newLineSize = SECURE_IO_2_BYTES;
369 if (pData[count] == '\n')
371 *pTerminationCur = count;
381 _SecureIoUtil::MakeCipherBlock(byte* pData, int dataSize, byte** ppEncryptedData, int* pEncryptedDataSize, const ByteBuffer& key)
383 result r = E_SUCCESS;
385 int lastDataSize = 0;
388 byte* pTempRealloc = null;
389 byte* pTempEncryptedData = null;
392 SysTryReturnResult(NID_SEC, dataSize > 0, E_INVALID_ARG, "Input data is not valid.");
395 *pEncryptedDataSize = 0;
397 blockCount = dataSize / CIPHER_BLOCK_SIZE;
398 lastDataSize = dataSize % CIPHER_BLOCK_SIZE;
399 if (lastDataSize != 0)
401 blockCount = blockCount + 1;
405 lastDataSize = CIPHER_BLOCK_SIZE;
408 for (int i = 0; i < blockCount; i++)
410 if (i == blockCount - 1)
412 tempSize = lastDataSize;
416 tempSize = CIPHER_BLOCK_SIZE;
419 inputSize = tempSize;
421 if (tempSize % ONE_BLOCK_SIZE != 0)
423 tempSize = (tempSize / ONE_BLOCK_SIZE) * ONE_BLOCK_SIZE + ONE_BLOCK_SIZE;
426 r = input.Construct(tempSize);
427 SysTryCatch(NID_IO, !IsFailed(r), , r, "[%s] Propagated.", GetErrorMessage(r));
429 r = input.SetArray((byte*) (pData + i * CIPHER_BLOCK_SIZE), 0, inputSize);
430 SysTryCatch(NID_IO, !IsFailed(r), , r, "[%s] Propagated.", GetErrorMessage(r));
432 if (inputSize < tempSize)
434 unique_ptr< char[] > pFill(new (std::nothrow) char[tempSize - inputSize]);
435 SysTryCatch(NID_IO, pFill != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
437 memset(pFill.get(), 0, tempSize - inputSize);
439 r = input.SetArray(reinterpret_cast< byte* >(pFill.get()), 0, tempSize - inputSize);
440 SysTryCatch(NID_IO, !IsFailed(r), , r, "[%s] Propagated.", GetErrorMessage(r));
446 unique_ptr< ByteBuffer > pEncryptedBuffer(DoCipherAesN(_CIPHER_INFORMATION, input, key, CIPHER_ENCRYPT));
447 SysTryCatch(NID_IO, pEncryptedBuffer != null, r = E_IO, E_IO, "[E_IO] Failed to encrypt data.");
449 pTempEncryptedData = const_cast< byte* >(pEncryptedBuffer->GetPointer());
450 SysTryCatch(NID_IO, pTempEncryptedData != null, , r, "[%s] Failed to get encrypted data.", GetErrorMessage(r));
452 pTempRealloc = (byte*) new (std::nothrow) byte[*pEncryptedDataSize + tempSize + CIPHER_BLOCK_HEADER_SIZE];
453 SysTryCatch(NID_IO, pTempRealloc != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
455 if (*ppEncryptedData)
457 memcpy(pTempRealloc, *ppEncryptedData, *pEncryptedDataSize);
459 delete[]* ppEncryptedData;
460 *ppEncryptedData = null;
463 *ppEncryptedData = pTempRealloc;
465 if (i == blockCount - 1)
468 *(*ppEncryptedData + i * (CIPHER_BLOCK_SIZE + CIPHER_BLOCK_HEADER_SIZE) + SECURE_IO_2_BYTES) \
469 = (byte) (lastDataSize & SECURE_IO_HEX_FF);
470 *(*ppEncryptedData + i * (CIPHER_BLOCK_SIZE + CIPHER_BLOCK_HEADER_SIZE) + 1) \
471 = (byte) ((lastDataSize >> SECURE_IO_8_BITS) & SECURE_IO_HEX_FF);
472 *(*ppEncryptedData + i * (CIPHER_BLOCK_SIZE + CIPHER_BLOCK_HEADER_SIZE)) \
473 = (byte) ((lastDataSize >> (SECURE_IO_8_BITS * SECURE_IO_2_BYTES)) & SECURE_IO_HEX_FF);
477 *(*ppEncryptedData + i * (CIPHER_BLOCK_SIZE + CIPHER_BLOCK_HEADER_SIZE) + SECURE_IO_2_BYTES) \
478 = (byte) (CIPHER_BLOCK_SIZE & SECURE_IO_HEX_FF);
479 *(*ppEncryptedData + i * (CIPHER_BLOCK_SIZE + CIPHER_BLOCK_HEADER_SIZE) + 1) \
480 = (byte) ((CIPHER_BLOCK_SIZE >> SECURE_IO_8_BITS) & SECURE_IO_HEX_FF);
481 *(*ppEncryptedData + i * (CIPHER_BLOCK_SIZE + CIPHER_BLOCK_HEADER_SIZE)) \
482 = (byte) ((CIPHER_BLOCK_SIZE >> (SECURE_IO_8_BITS * SECURE_IO_2_BYTES)) & SECURE_IO_HEX_FF);
485 memcpy(*ppEncryptedData + i * (CIPHER_BLOCK_SIZE + CIPHER_BLOCK_HEADER_SIZE) + CIPHER_BLOCK_HEADER_SIZE, pTempEncryptedData, tempSize);
486 *pEncryptedDataSize = *pEncryptedDataSize + tempSize + CIPHER_BLOCK_HEADER_SIZE;
493 *pEncryptedDataSize = 0;
494 delete[]* ppEncryptedData;
495 *ppEncryptedData = null;
502 _SecureIoUtil::WriteDataInCipherBlock(_NormalFile* pNormalFile, int dataPosition, bool eofSet, int dataSize, byte* pData, const ByteBuffer& key)
504 result r = E_SUCCESS;
505 int availableSize = 0;
506 int encryptedDataSize = 0;
508 long blockDataSize = 0;
509 long tempBlockDataSize = 0;
510 bool isFirstBlockSet = false;
511 byte* pBlockDataCur = null;
512 byte* pCipherBlockData = null;
513 byte* pDataPos = null;
514 byte blockHeader[CIPHER_BLOCK_HEADER_SIZE] = {0, 0, 0};
522 if (eofSet != false && dataPosition == 0)
524 r = MakeCipherBlock(pDataPos, dataSize, &pCipherBlockData, &encryptedDataSize, key);
525 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to make cipher block for file.", GetErrorMessage(r));
527 unique_ptr< byte[] > pEncryptedBlockData(pCipherBlockData);
528 pCipherBlockData = null;
530 SysTryReturn(NID_IO, pEncryptedBlockData != null, r, r, "[%s] Failed to make cipher block for file.", GetErrorMessage(r));
532 r = pNormalFile->Write(pEncryptedBlockData.get(), encryptedDataSize);
533 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to make cipher block for file.", GetErrorMessage(r));
538 ret = pNormalFile->Read(blockHeader, CIPHER_BLOCK_HEADER_SIZE);
539 if (ret < CIPHER_BLOCK_HEADER_SIZE)
543 if (ret == 0 && IsEndOfFile(pNormalFile))
548 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
553 pBlockDataCur = (byte*) (&blockDataSize);
554 *pBlockDataCur = blockHeader[SECURE_IO_2_BYTES];
555 *(pBlockDataCur + 1) = blockHeader[1];
556 *(pBlockDataCur + SECURE_IO_2_BYTES) = blockHeader[0];
558 unique_ptr< byte[] > pTempEncryptedData(new (std::nothrow) byte[CIPHER_BLOCK_SIZE]);
559 SysTryReturnResult(NID_IO, pTempEncryptedData != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
561 memset(pTempEncryptedData.get(), 0, CIPHER_BLOCK_SIZE);
563 if (blockDataSize % ONE_BLOCK_SIZE != 0)
565 tempBlockDataSize = blockDataSize + ONE_BLOCK_SIZE - blockDataSize % ONE_BLOCK_SIZE;
569 tempBlockDataSize = blockDataSize;
572 ret = pNormalFile->Read(pTempEncryptedData.get(), tempBlockDataSize);
573 if (ret < tempBlockDataSize)
577 if (ret == 0 && IsEndOfFile(pNormalFile))
582 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
586 r = input.Construct(tempBlockDataSize);
587 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
589 r = input.SetArray(pTempEncryptedData.get(), 0, tempBlockDataSize);
591 pTempEncryptedData.reset(null);
593 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
597 unique_ptr< ByteBuffer > pDecryptedBuffer(DoCipherAesN(_CIPHER_INFORMATION, input, key, CIPHER_DECRYPT));
598 SysTryReturn(NID_IO, pDecryptedBuffer != null, E_IO, E_IO, "[E_IO] Failed to encrypt data.");
600 unique_ptr< byte[] > pDecryptedBlockData(new (std::nothrow) byte[tempBlockDataSize]);
601 SysTryReturnResult(NID_IO, pDecryptedBlockData != null, E_OUT_OF_MEMORY, "The memory is insufficient");
603 r = pDecryptedBuffer->GetArray(reinterpret_cast< byte* >(pDecryptedBlockData.get()), 0, tempBlockDataSize);
604 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to get decrypted buffer.", GetErrorMessage(r));
606 pDecryptedBuffer->Flip();
608 pDecryptedBuffer.reset(null);
610 if (isFirstBlockSet == false)
612 availableSize = CIPHER_BLOCK_SIZE - dataPosition;
613 if (availableSize >= dataSize)
615 if (tempBlockDataSize < dataPosition + dataSize)
617 unique_ptr< byte[] > pTempRealloc(new (std::nothrow) byte[dataPosition + dataSize]);
618 SysTryReturnResult(NID_IO, pTempRealloc != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
620 memcpy(pTempRealloc.get(), pDecryptedBlockData.get(), tempBlockDataSize);
622 pDecryptedBlockData.reset(null);
623 pDecryptedBlockData = move(pTempRealloc);
626 memcpy(reinterpret_cast< byte* >(pDecryptedBlockData.get()) + dataPosition, pDataPos, dataSize);
628 if (blockDataSize < dataPosition + dataSize)
630 r = MakeCipherBlock(pDecryptedBlockData.get(), dataPosition + dataSize, &pCipherBlockData, &encryptedDataSize, key);
634 r = MakeCipherBlock(pDecryptedBlockData.get(), blockDataSize, &pCipherBlockData, &encryptedDataSize, key);
637 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to make cipher block for file.", GetErrorMessage(r));
639 unique_ptr< byte[] > pEncryptedBlockData(pCipherBlockData);
640 pCipherBlockData = null;
642 SysTryReturn(NID_IO, pEncryptedBlockData != null, r, r, "[%s] Failed to make cipher block for file.", GetErrorMessage(r));
644 r = pNormalFile->Seek(FILESEEKPOSITION_CURRENT, -(tempBlockDataSize + CIPHER_BLOCK_HEADER_SIZE));
645 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
647 r = pNormalFile->Write(pEncryptedBlockData.get(), encryptedDataSize);
648 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to write in file.", GetErrorMessage(r));
653 else //(availableSize < dataSize)
655 if (tempBlockDataSize < dataPosition + availableSize)
657 unique_ptr< byte[] > pTempRelloc(new (std::nothrow) byte[dataPosition + availableSize]);
658 SysTryReturnResult(NID_IO, pTempRelloc != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
660 memcpy(pTempRelloc.get(), pDecryptedBlockData.get(), tempBlockDataSize);
662 pDecryptedBlockData.reset(null);
663 pDecryptedBlockData = move(pTempRelloc);
666 memcpy(reinterpret_cast< byte* >(pDecryptedBlockData.get()) + dataPosition, pDataPos, availableSize);
668 pDataPos = pDataPos + availableSize;
669 dataSize = dataSize - availableSize;
671 r = MakeCipherBlock(pDecryptedBlockData.get(), CIPHER_BLOCK_SIZE, &pCipherBlockData, &encryptedDataSize, key);
672 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to make cipher block for file.", GetErrorMessage(r));
674 unique_ptr< byte[] > pEncryptedBlockData(pCipherBlockData);
675 pCipherBlockData = null;
676 SysTryReturn(NID_IO, pEncryptedBlockData != null, r, r, "[%s] Failed to make cipher block for file.", GetErrorMessage(r));
678 r = pNormalFile->Seek(FILESEEKPOSITION_CURRENT, -(tempBlockDataSize + CIPHER_BLOCK_HEADER_SIZE));
679 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
681 r = pNormalFile->Write(pEncryptedBlockData.get(), encryptedDataSize);
682 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to write in file.", GetErrorMessage(r));
688 isFirstBlockSet = true;
692 availableSize = CIPHER_BLOCK_SIZE;
693 if (availableSize >= dataSize)
695 if (tempBlockDataSize < dataSize)
697 unique_ptr< byte[] > pTempRelloc(new (std::nothrow) byte[dataSize]);
698 SysTryReturnResult(NID_IO, pTempRelloc != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
700 memcpy(pTempRelloc.get(), pDecryptedBlockData.get(), tempBlockDataSize);
702 pDecryptedBlockData.reset(null);
703 pDecryptedBlockData = move(pTempRelloc);
706 memcpy(pDecryptedBlockData.get(), pDataPos, dataSize);
708 if (blockDataSize < dataPosition + dataSize)
710 r = MakeCipherBlock(pDecryptedBlockData.get(), dataSize, &pCipherBlockData, &encryptedDataSize, key);
714 r = MakeCipherBlock(pDecryptedBlockData.get(), blockDataSize, &pCipherBlockData, &encryptedDataSize, key);
717 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to make cipher block for file.", GetErrorMessage(r));
719 unique_ptr< byte[] > pEncryptedBlockData(pCipherBlockData);
720 pCipherBlockData = null;
722 SysTryReturn(NID_IO, pEncryptedBlockData != null, r, r, "[%s] Failed to make cipher block for file.", GetErrorMessage(r));
724 r = pNormalFile->Seek(FILESEEKPOSITION_CURRENT, -(tempBlockDataSize + CIPHER_BLOCK_HEADER_SIZE));
725 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
727 r = pNormalFile->Write(pEncryptedBlockData.get(), encryptedDataSize);
728 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to write in file.", GetErrorMessage(r));
732 else //availableSize < dataSize
734 if (tempBlockDataSize < availableSize)
736 unique_ptr< byte[] > pTempRelloc(new (std::nothrow) byte[availableSize]);
737 SysTryReturnResult(NID_IO, pTempRelloc != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
739 memcpy(pTempRelloc.get(), pDecryptedBlockData.get(), tempBlockDataSize);
741 pDecryptedBlockData.reset(null);
742 pDecryptedBlockData = move(pTempRelloc);
745 memcpy(pDecryptedBlockData.get(), pDataPos, availableSize);
747 pDataPos = pDataPos + availableSize;
748 dataSize = dataSize - availableSize;
750 r = MakeCipherBlock(pDecryptedBlockData.get(), CIPHER_BLOCK_SIZE, &pCipherBlockData, &encryptedDataSize, key);
751 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to make cipher block for file.", GetErrorMessage(r));
753 unique_ptr< byte[] > pEncryptedBlockData(pCipherBlockData);
754 pCipherBlockData = null;
756 SysTryReturn(NID_IO, pEncryptedBlockData != null, r, r, "[%s] Failed to make cipher block for file.", GetErrorMessage(r));
758 r = pNormalFile->Seek(FILESEEKPOSITION_CURRENT, -(tempBlockDataSize + CIPHER_BLOCK_HEADER_SIZE));
759 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
761 r = pNormalFile->Write(pEncryptedBlockData.get(), encryptedDataSize);
762 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to write in file.", GetErrorMessage(r));
769 eofSet = IsEndOfFile(pNormalFile);
776 _SecureIoUtil::ReadDataFromCipherBlock(_NormalFile* pNormalFile, int dataPosition, int bufferSize, byte* pData, _DataFormat dataMode, int* readItems, const ByteBuffer& key)
778 result r = E_SUCCESS;
781 int terminationCur = 0;
785 long blockDataSize = 0;
786 long tempBlockDataSize = 0;
787 byte* pBlockDataCur = null;
788 byte* pDecryptedBlockData = null;
789 byte blockHeader[CIPHER_BLOCK_HEADER_SIZE] = {0, 0, 0};
793 ret = pNormalFile->Read(blockHeader, CIPHER_BLOCK_HEADER_SIZE);
794 if (ret < CIPHER_BLOCK_HEADER_SIZE)
798 if (ret == 0 && IsEndOfFile(pNormalFile))
803 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
808 pBlockDataCur = (byte*) (&blockDataSize);
809 *pBlockDataCur = blockHeader[SECURE_IO_2_BYTES];
810 *(pBlockDataCur + 1) = blockHeader[1];
811 *(pBlockDataCur + SECURE_IO_2_BYTES) = blockHeader[0];
813 unique_ptr< byte[] > pBlockData(new (std::nothrow) byte[CIPHER_BLOCK_SIZE]);
814 SysTryReturnResult(NID_IO, pBlockData != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
816 memset(pBlockData.get(), 0, CIPHER_BLOCK_SIZE);
818 if (blockDataSize % ONE_BLOCK_SIZE != 0)
820 tempBlockDataSize = blockDataSize + ONE_BLOCK_SIZE - blockDataSize % ONE_BLOCK_SIZE;
824 tempBlockDataSize = blockDataSize;
827 ret = pNormalFile->Read(pBlockData.get(), tempBlockDataSize);
828 if (ret < tempBlockDataSize)
832 if (ret == 0 && IsEndOfFile(pNormalFile))
837 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
841 readingSize = blockDataSize - dataPosition;
842 SysTryReturn(NID_IO, readingSize != 0, r = E_END_OF_FILE, r, "[%s] Failed to get positive value of readingSize.", GetErrorMessage(r));
844 r = input.Construct(tempBlockDataSize);
845 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
847 r = input.SetArray(pBlockData.get(), 0, tempBlockDataSize);
848 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
852 unique_ptr< ByteBuffer > pDecryptedBuffer(DoCipherAesN(_CIPHER_INFORMATION, input, key, CIPHER_DECRYPT));
853 SysTryReturn(NID_IO, pDecryptedBuffer != null, E_IO, E_IO, "[E_IO] Failed to encrypt data.");
855 pDecryptedBlockData = const_cast< byte* >(pDecryptedBuffer->GetPointer());
856 SysTryReturn(NID_IO, pDecryptedBlockData, r, r, "[%s] Failed to get encrypted data.", GetErrorMessage(r));
858 unique_ptr< byte[] > pTemp(new (std::nothrow) byte[readingSize]);
859 SysTryReturnResult(NID_IO, pTemp != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
861 memcpy(pTemp.get(), pDecryptedBlockData + dataPosition, readingSize);
863 pDecryptedBuffer.reset(null);
867 eofSet = IsEndOfFile(pNormalFile);
869 if (dataMode == DATA_FORMAT_BYTE && (readingSize >= bufferSize))
871 memcpy(pData, pTemp.get(), bufferSize);
872 *readItems = bufferSize;
875 else if (dataMode == DATA_FORMAT_STRING && ((readingSize >= bufferSize) || DetectNewLine(pTemp.get(), readingSize, tempSize, &terminationCur, &newLineSize)))
877 if (terminationCur != 0)
879 memcpy(pData, pTemp.get(), terminationCur);
880 *(pData + terminationCur) = '\n';
881 *readItems = terminationCur + newLineSize;
885 memcpy(pData, pTemp.get(), bufferSize);
886 *readItems = bufferSize;
890 else if (eofSet && (readingSize < bufferSize))
892 memcpy(pData, pTemp.get(), readingSize);
893 *readItems = readingSize;
898 ret = pNormalFile->Read(blockHeader, CIPHER_BLOCK_HEADER_SIZE);
899 if (ret < CIPHER_BLOCK_HEADER_SIZE)
903 if (ret == 0 && IsEndOfFile(pNormalFile))
909 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
914 pBlockDataCur = (byte*) (&blockDataSize);
915 *pBlockDataCur = blockHeader[SECURE_IO_2_BYTES];
916 *(pBlockDataCur + 1) = blockHeader[1];
917 *(pBlockDataCur + SECURE_IO_2_BYTES) = blockHeader[0];
919 memset(pBlockData.get(), 0, CIPHER_BLOCK_SIZE);
921 if (blockDataSize % ONE_BLOCK_SIZE != 0)
923 tempBlockDataSize = blockDataSize + ONE_BLOCK_SIZE - blockDataSize % ONE_BLOCK_SIZE;
927 tempBlockDataSize = blockDataSize;
930 ret = pNormalFile->Read(pBlockData.get(), tempBlockDataSize);
931 if (ret < tempBlockDataSize)
935 if (ret == 0 && IsEndOfFile(pNormalFile))
940 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
944 r = input.Construct(tempBlockDataSize);
945 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
947 r = input.SetArray(pBlockData.get(), 0, tempBlockDataSize);
948 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
952 unique_ptr< ByteBuffer > pDecryptedNextBuffer(DoCipherAesN(_CIPHER_INFORMATION, input, key, CIPHER_DECRYPT));
953 SysTryReturn(NID_IO, pDecryptedNextBuffer != null, E_IO, E_IO, "[E_IO] Failed to encrypt data.");
955 pDecryptedBlockData = const_cast< byte* >(pDecryptedNextBuffer->GetPointer());
956 SysTryReturn(NID_IO, pDecryptedBlockData != null, r, r, "[%s] Failed to get encrypted data.", GetErrorMessage(r));
958 tempSize = readingSize;
959 readingSize = readingSize + blockDataSize;
961 unique_ptr< byte[] > pTempRealloc(new (std::nothrow) byte[readingSize]);
962 SysTryReturnResult(NID_IO, pTempRealloc != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
964 memcpy(pTempRealloc.get(), pTemp.get(), tempSize);
967 pTemp = move(pTempRealloc);
969 memcpy(reinterpret_cast< byte* >(pTemp.get()) + tempSize, pDecryptedBlockData, blockDataSize);
978 _SecureIoUtil::GetDataLengh(_NormalFile* pNormalFile, long int* dataLength)
980 result r = E_SUCCESS;
982 long blockDataSize = 0;
983 byte* pBlockDataCur = null;
984 byte secureHeader[SECURE_FILE_HEADER_SIZE_V1];
985 byte blockHeader[CIPHER_BLOCK_HEADER_SIZE] = {0, 0, 0};
990 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, 0);
991 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
993 ret = pNormalFile->Read(secureHeader, SECURE_FILE_HEADER_SIZE_V1);
994 if (ret < SECURE_FILE_HEADER_SIZE_V1)
998 if (ret == 0 && IsEndOfFile(pNormalFile))
1003 SysLog(NID_IO, "[%s] Failed to seek in file", GetErrorMessage(r));
1008 ret = pNormalFile->Read(blockHeader, CIPHER_BLOCK_HEADER_SIZE);
1009 if (ret < CIPHER_BLOCK_HEADER_SIZE)
1011 r = GetLastResult();
1013 if (ret == 0 && IsEndOfFile(pNormalFile))
1019 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
1024 pBlockDataCur = (byte*) (&blockDataSize);
1025 *pBlockDataCur = blockHeader[SECURE_IO_2_BYTES];
1026 *(pBlockDataCur + 1) = blockHeader[1];
1027 *(pBlockDataCur + SECURE_IO_2_BYTES) = blockHeader[0];
1028 *dataLength = *dataLength + blockDataSize;
1030 if (blockDataSize % ONE_BLOCK_SIZE != 0)
1032 r = pNormalFile->Seek(FILESEEKPOSITION_CURRENT, blockDataSize + ONE_BLOCK_SIZE - blockDataSize % ONE_BLOCK_SIZE);
1036 r = pNormalFile->Seek(FILESEEKPOSITION_CURRENT, blockDataSize);
1039 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
1043 return pNormalFile->Seek(FILESEEKPOSITION_END, 0);
1047 _SecureIoUtil::CheckSecureFileHeader(const Tizen::Base::String& filePath, const ByteBuffer* pSecretKey)
1049 byte secureFileHeader[SECURE_FILE_HEADER_SIZE_V1] = { 0, };
1050 byte reservedValue[SECURE_IO_STATIC_BIN_LEN] = { 0xCA, 0xFE, 0xBE, 0xBE, 0xDA, 0xEF, 0xEB, 0xEB };
1052 _NormalFile normalFile;
1053 result r = normalFile.Construct(filePath, "r");
1054 SysTryReturnResult(NID_IO, !IsFailed(r), r, "Failed to open the file (%ls).", filePath.GetPointer());
1056 int ret = normalFile.Read(secureFileHeader, SECURE_FILE_HEADER_SIZE_V1);
1057 if (ret < SECURE_FILE_HEADER_SIZE_V1)
1059 r = GetLastResult();
1060 if (IsEndOfFile(&normalFile))
1062 if (ret && pSecretKey)
1074 // Checks if the file is encrypted file. (in normal or secure mode)
1075 ret = memcmp(secureFileHeader, SECURE_FILE_HEADER_STRING, SECURE_FILE_HEADER_STRING_SIZE);
1076 ret |= memcmp(secureFileHeader + SECURE_FILE_HEADER_STRING_SIZE, reservedValue, SECURE_IO_STATIC_BIN_LEN);
1077 SysTryReturnResult(NID_IO, !(ret && pSecretKey), E_INVALID_ARG, "Failed to match secure header in file.");
1085 _SecureIoUtil::SetRegistryFlag(void* pFileSecure, _FlagState flag)
1087 result r = E_SUCCESS;
1090 byte currentFlag = 0;
1091 _FileImpl* pFile = (_FileImpl*) pFileSecure;
1094 current = pFile->Tell();
1095 SysTryReturn(NID_IO, current != -1, GetLastResult(), GetLastResult(), "[%s] Tell file has failed.", GetErrorMessage(GetLastResult()));
1097 r = pFile->Seek(FILESEEKPOSITION_BEGIN, SECURE_REG_HEADER_STRING_SIZE + SECURE_IO_STATIC_BIN_LEN);
1098 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
1100 readItems = pFile->Read(¤tFlag, 1);
1101 SysTryReturn(NID_IO, readItems == 1, r = E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Tell file has failed.");
1103 if (flag == FLAG_STATE_CVF)
1105 currentFlag = currentFlag | SECURE_IO_2_BYTES;
1106 currentFlag = currentFlag & SECURE_IO_HEX_FE;
1108 else if (flag == FLAG_STATE_CTF)
1110 currentFlag = currentFlag | 1;
1111 currentFlag = currentFlag & SECURE_IO_HEX_FD;
1113 else if (flag == FLAG_STATE_CVF_CTF)
1115 currentFlag = currentFlag | SECURE_IO_3_BYTES;
1117 else if (flag == FLAG_STATE_NONE)
1119 currentFlag = currentFlag & SECURE_IO_HEX_FC;
1123 return E_INVALID_STATE;
1126 r = pFile->Seek(FILESEEKPOSITION_BEGIN, SECURE_REG_HEADER_STRING_SIZE + SECURE_IO_STATIC_BIN_LEN);
1127 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
1129 r = pFile->Write(¤tFlag, 1);
1130 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to write data in file.", GetErrorMessage(r));
1132 r = pFile->Seek(FILESEEKPOSITION_BEGIN, current);
1133 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
1139 _SecureIoUtil::CheckRegistryFlag(byte* pHeader)
1142 byte flag = *(pHeader + SECURE_REG_HEADER_STRING_SIZE + SECURE_IO_STATIC_BIN_LEN);
1144 if (((flag | SECURE_IO_HEX_FD) == SECURE_IO_HEX_FF) && ((flag | SECURE_IO_HEX_FE) != SECURE_IO_HEX_FF))
1146 return FLAG_STATE_CVF;
1148 else if (((flag | SECURE_IO_HEX_FD) != SECURE_IO_HEX_FF) && ((flag | SECURE_IO_HEX_FE) == SECURE_IO_HEX_FF))
1150 return FLAG_STATE_CTF;
1152 else if ((flag | SECURE_IO_HEX_FC) == SECURE_IO_HEX_FF)
1154 return FLAG_STATE_CVF_CTF;
1158 return FLAG_STATE_NONE;
1163 _SecureIoUtil::MakeRegistryReplica(const String fileName, byte* pNameIndex)
1165 result r = E_SUCCESS;
1167 int nameIndex = *pNameIndex;
1172 SysTryReturn(NID_IO, nameIndex <= SECURE_IO_HEX_64, replicaName, E_INVALID_ARG, "[E_INVALID_ARG] Index number is too big.");
1176 replicaName = fileName + L".rpa ";
1177 if (!File::IsFileExist(replicaName))
1184 replicaName = fileName + L"_";
1185 replicaName.Append((int) nameIndex);
1186 replicaName.Append(L".rpa");
1188 if (!File::IsFileExist(replicaName))
1197 *pNameIndex = nameIndex;
1199 if (_FileImpl::IsFileExist(fileName))
1201 r = _FileImpl::Copy(fileName, replicaName, true);
1202 SysTryReturn(NID_IO, !IsFailed(r), replicaName, r, "[%s] Failed to copy file.", GetErrorMessage(r));
1206 // open registry replica file
1208 r = fileImpl.Construct(replicaName, "w", false, null);
1209 SysTryReturn(NID_IO, !IsFailed(r), replicaName, r, "[%s] Failed to create empty file.", GetErrorMessage(r));
1217 _SecureIoUtil::DeleteRegistryReplica(byte* pHeader, const String fileName)
1219 result r = E_SUCCESS;
1221 byte nameIndex = *(pHeader + SECURE_REG_HEADER_STRING_SIZE + SECURE_IO_9_BYTES);
1225 SysTryReturnResult(NID_IO, nameIndex <= SECURE_IO_HEX_64, E_INVALID_ARG, "Index number is too big.");
1229 replicaName = fileName + L".rpa ";
1233 replicaName = fileName + L"_";
1234 replicaName.Append((int) nameIndex);
1235 replicaName.Append(L".rpa");
1238 _FileImpl::Remove(replicaName);
1244 _SecureIoUtil::LoadRegistryReplica(byte** pHeader, int* pHeaderLen, const String fileName)
1246 result r = E_SUCCESS;
1249 char indexStr[MAX_BLOCK_INDEX_LEN];
1252 _FileImpl replicaFile;
1255 memset(indexStr, 0, MAX_BLOCK_INDEX_LEN);
1256 nameIndex = *(*pHeader + SECURE_REG_HEADER_STRING_SIZE + SECURE_IO_9_BYTES);
1262 SysTryReturnResult(NID_IO, nameIndex <= SECURE_IO_HEX_64, E_INVALID_ARG, "Index number is too big.");
1266 replicaName = fileName + L".rpa ";
1270 replicaName = fileName + L"_";
1271 replicaName.Append((int) nameIndex);
1272 replicaName.Append(L".rpa");
1275 if (Tizen::Io::_FileImpl::IsFileExist(replicaName))
1277 r = replicaFile.Construct(replicaName, "r", false, null);
1278 SysTryCatch(NID_IO, !IsFailed(r), , r, "[%s] Constructing the file has failed.", GetErrorMessage(r));
1280 r = replicaFile.Seek(FILESEEKPOSITION_END, 0);
1281 SysTryCatch(NID_IO, !IsFailed(r), , r, "[%s] Failed to seek in file.", GetErrorMessage(r));
1283 length = replicaFile.Tell();
1286 *pHeader = new (std::nothrow) byte[length];
1287 SysTryCatch(NID_IO, *pHeader != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
1288 *pHeaderLen = length;
1290 r = replicaFile.Seek(FILESEEKPOSITION_BEGIN, 0);
1291 SysTryCatch(NID_IO, !IsFailed(r), , r, "[%s] Failed to seek in file.", GetErrorMessage(r));
1293 readItems = replicaFile.Read(*pHeader, length);
1294 SysTryCatch(NID_IO, readItems >= length, r = GetLastResult(), GetLastResult(), "[%s] Failed to read data from file.", GetErrorMessage(GetLastResult()));
1311 _SecureIoUtil::CheckSecureRegistryHeader(byte** pHeader, int* pHeaderLen, const String strFilePathPath, bool secureMode)
1313 result r = E_SUCCESS;
1317 _FlagState flag = FLAG_STATE_NONE;
1318 byte reservedValue[SECURE_IO_STATIC_BIN_LEN] = {0xCA, 0xFE, 0xBE, 0xBE, 0xDA, 0xEF, 0xEB, 0xEB};
1319 byte* pSecureRegistryHeader = *pHeader;
1322 //check if the registry is encrypted . (in normal and secure mode)
1323 ret = memcmp(pSecureRegistryHeader, SECURE_REG_HEADER_STRING, SECURE_REG_HEADER_STRING_SIZE);
1324 ret |= memcmp(pSecureRegistryHeader + SECURE_REG_HEADER_STRING_SIZE, reservedValue, SECURE_IO_STATIC_BIN_LEN);
1325 SysTryReturnResult(NID_IO, !(ret && secureMode == true), E_INVALID_ARG, "Failed to match secure header in file.");
1329 flag = CheckRegistryFlag(pSecureRegistryHeader);
1331 if (_FileImpl::IsFileExist(strFilePathPath) && !_SecureIoUtil::IsEmpty(strFilePathPath))
1333 r = fileImpl.Construct(strFilePathPath, "a+", false, null);
1334 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Constructing the file has failed.", GetErrorMessage(r));
1336 if (flag == FLAG_STATE_CVF_CTF)
1338 r = DeleteRegistryReplica(pSecureRegistryHeader, strFilePathPath);
1339 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to delete registry replica.", GetErrorMessage(r));
1341 r = SetRegistryFlag(&fileImpl, FLAG_STATE_CVF);
1342 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to set registry flags.", GetErrorMessage(r));
1345 else if (flag == FLAG_STATE_CTF)
1347 r = LoadRegistryReplica(pHeader, &readLen, strFilePathPath);
1348 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to load registry replica.", GetErrorMessage(r));
1350 SysTryReturn(NID_IO, *pHeader, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Failed to read secure registry file header.");
1352 pSecureRegistryHeader = *pHeader;
1353 *pHeaderLen = readLen;
1355 r = DeleteRegistryReplica(pSecureRegistryHeader, strFilePathPath);
1356 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to delete registry replica.", GetErrorMessage(r));
1358 r = SetRegistryFlag(&fileImpl, FLAG_STATE_CVF);
1359 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to set registry flags.", GetErrorMessage(r));
1361 else if (flag == FLAG_STATE_CVF)
1367 r = E_INVALID_STATE;
1376 _SecureIoUtil::CheckFlag(_NormalFile* pNormalFile, _FlagState* pFlag)
1378 result r = E_SUCCESS;
1383 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, SECURE_FILE_HEADER_STRING_SIZE + SECURE_IO_STATIC_BIN_LEN);
1388 ret = pNormalFile->Read(&flag, SECURE_IO_FLAG_SIZE);
1392 r = GetLastResult();
1393 SysTryReturnResult(NID_IO, !(ret == 0 && r == E_END_OF_FILE), E_INVALID_ARG, "Failed to read secure file header.");
1395 r = GetLastResult();
1397 if (ret == 0 && IsEndOfFile(pNormalFile))
1402 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
1407 if (((flag | SECURE_IO_HEX_FD) == SECURE_IO_HEX_FF) && ((flag | SECURE_IO_HEX_FE) != SECURE_IO_HEX_FF))
1409 *pFlag = FLAG_STATE_CVF;
1411 else if (((flag | SECURE_IO_HEX_FD) != SECURE_IO_HEX_FF) && ((flag | SECURE_IO_HEX_FE) == SECURE_IO_HEX_FF))
1413 *pFlag = FLAG_STATE_CTF;
1415 else if ((flag | SECURE_IO_HEX_FC) == SECURE_IO_HEX_FF)
1417 *pFlag = FLAG_STATE_CVF_CTF;
1421 *pFlag = FLAG_STATE_NONE;
1428 _SecureIoUtil::SetFlag(_NormalFile* pNormalFile, _FlagState flag)
1430 result r = E_SUCCESS;
1433 byte currentFlag = 0;
1436 current = pNormalFile->Tell();
1439 r = GetLastResult();
1440 SysLog(NID_IO, "[%s] Failed to tell in file", GetErrorMessage(r));
1444 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, SECURE_FILE_HEADER_STRING_SIZE + SECURE_IO_STATIC_BIN_LEN);
1445 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file", GetErrorMessage(r));
1447 readItems = pNormalFile->Read(¤tFlag, SECURE_IO_FLAG_SIZE);
1450 r = GetLastResult();
1452 if (readItems == 0 && IsEndOfFile(pNormalFile))
1457 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
1461 if (flag == FLAG_STATE_CVF)
1463 currentFlag = currentFlag | SECURE_IO_2_BYTES;
1464 currentFlag = currentFlag & SECURE_IO_HEX_FE;
1466 else if (flag == FLAG_STATE_CTF)
1468 currentFlag = currentFlag | 1;
1469 currentFlag = currentFlag & SECURE_IO_HEX_FD;
1471 else if (flag == FLAG_STATE_CVF_CTF)
1473 currentFlag = currentFlag | SECURE_IO_3_BYTES;
1475 else if (flag == FLAG_STATE_NONE)
1477 currentFlag = currentFlag & SECURE_IO_HEX_FC;
1481 SysAssert(false); // should not happen!
1483 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, SECURE_FILE_HEADER_STRING_SIZE + SECURE_IO_STATIC_BIN_LEN);
1484 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file", GetErrorMessage(r));
1486 r = pNormalFile->Write(¤tFlag, SECURE_IO_FLAG_SIZE);
1487 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to write in file", GetErrorMessage(r));
1489 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, current);
1490 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file", GetErrorMessage(r));
1496 _SecureIoUtil::DeleteBlockReplica(_NormalFile* pNormalFile, const String filePath)
1498 result r = E_SUCCESS;
1504 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, SECURE_FILE_HEADER_STRING_SIZE + SECURE_IO_9_BYTES);
1505 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file", GetErrorMessage(r));
1507 readItems = pNormalFile->Read(&nameIndex, SECURE_IO_INDEX_SIZE);
1510 r = GetLastResult();
1512 if (readItems == 0 && IsEndOfFile(pNormalFile))
1517 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
1521 SysTryReturnResult(NID_IO, nameIndex <= SECURE_IO_HEX_64, E_INVALID_ARG, "Index number is too big.");
1525 replicaName = filePath + L".rpa ";
1529 replicaName = filePath + L"_";
1530 replicaName.Append((int) nameIndex);
1531 replicaName.Append(L".rpa");
1534 _FileImpl::Remove(replicaName);
1540 _SecureIoUtil::RestoreCorruptBlock(_NormalFile* pNormalFile, String fileName)
1542 result r = E_SUCCESS;
1543 String blockName = null;
1545 byte blockHeader[CIPHER_BLOCK_HEADER_SIZE] = {0, 0, 0};
1546 byte* pBlockDataCur = null;
1547 _NormalFile replicaFile;
1548 int startBlockNum = 0;
1554 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, SECURE_FILE_HEADER_STRING_SIZE + SECURE_IO_9_BYTES);
1555 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file", GetErrorMessage(r));
1557 readItems = pNormalFile->Read(&nameIndex, SECURE_IO_INDEX_SIZE); // read index of temporary block name
1558 if (readItems < SECURE_IO_INDEX_SIZE)
1560 r = GetLastResult();
1562 if (readItems == 0 && IsEndOfFile(pNormalFile))
1567 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
1571 readItems = pNormalFile->Read(&dataLen, SECURE_IO_LOF_SIZE);
1572 if (readItems < SECURE_IO_LOF_SIZE)
1574 r = GetLastResult();
1576 if (readItems == 0 && IsEndOfFile(pNormalFile))
1581 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
1585 SysTryReturnResult(NID_IO, nameIndex < SECURE_IO_HEX_64, E_INVALID_ARG, "Index number is too big.");
1589 blockName = fileName + L".rpa ";
1593 blockName = fileName + L"_";
1594 blockName.Append((int) nameIndex);
1595 blockName.Append(L".rpa");
1598 if (_FileUtil::IsFileExist(blockName))
1600 r = replicaFile.Construct(blockName, "r");
1601 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to conctruct replica file.", GetErrorMessage(r));
1603 readItems = replicaFile.Read(blockHeader, CIPHER_BLOCK_HEADER_SIZE); //Read start block number (3bytes)
1604 if (readItems < CIPHER_BLOCK_HEADER_SIZE)
1606 r = GetLastResult();
1608 if (readItems == 0 && IsEndOfFile(pNormalFile))
1613 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
1617 pBlockDataCur = (byte*) (&startBlockNum);
1618 *pBlockDataCur = blockHeader[SECURE_IO_2_BYTES];
1619 *(pBlockDataCur + 1) = blockHeader[1];
1620 *(pBlockDataCur + SECURE_IO_2_BYTES) = blockHeader[0];
1622 r = replicaFile.Seek(FILESEEKPOSITION_END, 0);
1623 fileLength = replicaFile.Tell();
1624 SysTryReturn(NID_IO, fileLength != -1, GetLastResult(), GetLastResult(), "[%s] Failed to tell in file.", GetErrorMessage(GetLastResult()));
1626 r = replicaFile.Seek(FILESEEKPOSITION_BEGIN, CIPHER_BLOCK_HEADER_SIZE);
1627 unique_ptr< byte[] > pBlock(new (std::nothrow) byte[fileLength - CIPHER_BLOCK_HEADER_SIZE]);
1628 SysTryReturnResult(NID_IO, pBlock != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
1630 memset(pBlock.get(), 0, fileLength - CIPHER_BLOCK_HEADER_SIZE);
1632 readItems = replicaFile.Read(pBlock.get(), fileLength - CIPHER_BLOCK_HEADER_SIZE);
1633 if (readItems < (fileLength - CIPHER_BLOCK_HEADER_SIZE))
1635 r = GetLastResult();
1637 if (readItems == 0 && IsEndOfFile(pNormalFile))
1642 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
1646 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, SECURE_FILE_HEADER_SIZE_V1 + (CIPHER_BLOCK_SIZE + CIPHER_BLOCK_HEADER_SIZE) * startBlockNum);
1648 r = pNormalFile->Write(pBlock.get(), fileLength - CIPHER_BLOCK_HEADER_SIZE);
1649 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to write in file.", GetErrorMessage(r));
1653 r = pNormalFile->Truncate(dataLen);
1654 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to truncate in file.", GetErrorMessage(r));
1660 _SecureIoUtil::MakeCipherBlockReplica(_NormalFile* pNormalFile, const String filePath, int dataPosition, int dataSize)
1662 result r = E_SUCCESS;
1663 int totalDataSize = 0;
1667 int startBlockNum = 0;
1669 long blockDataSize = 0;
1670 bool isEndOfBlock = false;
1672 byte* pBlockDataCur = null;
1673 byte blockHeader[CIPHER_BLOCK_HEADER_SIZE] = {0, 0, 0};
1675 _NormalFile tempBlockFile;
1677 totalDataSize = dataPosition + dataSize;
1680 headPos = pNormalFile->Tell();
1681 SysTryReturn(NID_IO, headPos != -1, GetLastResult(), GetLastResult(), "[%s] Failed to tell in file.", GetErrorMessage(GetLastResult()));
1683 ret = pNormalFile->Read(blockHeader, CIPHER_BLOCK_HEADER_SIZE);
1684 if (ret < CIPHER_BLOCK_HEADER_SIZE)
1686 r = GetLastResult();
1688 if (ret == 0 && IsEndOfFile(pNormalFile))
1693 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
1700 pBlockDataCur = (byte*) (&blockDataSize);
1701 *pBlockDataCur = blockHeader[SECURE_IO_2_BYTES];
1702 *(pBlockDataCur + 1) = blockHeader[1];
1703 *(pBlockDataCur + SECURE_IO_2_BYTES) = blockHeader[0];
1704 blockSize = blockSize + blockDataSize;
1706 if (blockSize >= totalDataSize)
1708 isEndOfBlock = true;
1711 if (blockDataSize % ONE_BLOCK_SIZE != 0)
1713 r = pNormalFile->Seek(FILESEEKPOSITION_CURRENT, blockDataSize + ONE_BLOCK_SIZE - blockDataSize % ONE_BLOCK_SIZE);
1717 r = pNormalFile->Seek(FILESEEKPOSITION_CURRENT, blockDataSize);
1720 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
1727 if (IsEndOfFile(pNormalFile))
1732 ret = pNormalFile->Read(blockHeader, CIPHER_BLOCK_HEADER_SIZE);
1733 if (ret < CIPHER_BLOCK_HEADER_SIZE)
1735 r = GetLastResult();
1737 if (ret == 0 && IsEndOfFile(pNormalFile))
1742 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
1748 tailPos = pNormalFile->Tell();
1749 SysTryReturn(NID_IO, tailPos != -1, GetLastResult(), GetLastResult(), "[%s] Failed to tell in file.", GetErrorMessage(GetLastResult()));
1751 startBlockNum = (headPos - SECURE_FILE_HEADER_SIZE_V1) / (CIPHER_BLOCK_SIZE + CIPHER_BLOCK_HEADER_SIZE);
1753 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, headPos);
1754 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
1756 unique_ptr< byte[] > pBlockReplica(new (std::nothrow) byte[tailPos - headPos + CIPHER_BLOCK_HEADER_SIZE]);
1757 SysTryReturnResult(NID_IO, pBlockReplica != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
1759 *(reinterpret_cast< byte* >(pBlockReplica.get()) + SECURE_IO_2_BYTES) = (byte) (startBlockNum & SECURE_IO_HEX_FF);
1760 *(reinterpret_cast< byte* >(pBlockReplica.get()) + 1) = (byte) ((startBlockNum >> SECURE_IO_8_BITS) & SECURE_IO_HEX_FF);
1761 *(reinterpret_cast< byte* >(pBlockReplica.get())) = (byte) ((startBlockNum >> (SECURE_IO_8_BITS * SECURE_IO_2_BYTES)) & SECURE_IO_HEX_FF);
1763 ret = pNormalFile->Read(reinterpret_cast< byte* >(pBlockReplica.get()) + CIPHER_BLOCK_HEADER_SIZE, tailPos - headPos);
1764 if (ret < (tailPos - headPos))
1766 r = GetLastResult();
1768 if (ret == 0 && IsEndOfFile(pNormalFile))
1773 SysLog(NID_IO, "[%s] Failed to read data from file.", GetErrorMessage(r));
1779 SysTryReturnResult(NID_IO, nameIndex <= SECURE_IO_HEX_64, E_INVALID_ARG, "Index number is too big.");
1783 replicaName = filePath + L".rpa ";
1784 if (!File::IsFileExist(replicaName))
1791 replicaName = filePath + L"_";
1792 replicaName.Append((int) nameIndex);
1793 replicaName.Append(L".rpa");
1795 if (!File::IsFileExist(replicaName))
1803 r = tempBlockFile.Construct(replicaName, "w");
1804 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to call construct.", GetErrorMessage(r));
1806 r = tempBlockFile.Write(pBlockReplica.get(), tailPos - headPos + CIPHER_BLOCK_HEADER_SIZE);
1807 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to write in file.", GetErrorMessage(r));
1809 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, 25);
1810 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
1812 r = pNormalFile->Write(&nameIndex, 1);
1813 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to write in file.", GetErrorMessage(r));
1815 r = pNormalFile->Seek(FILESEEKPOSITION_BEGIN, headPos);
1816 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
1822 _SecureIoUtil::IsNormalDatabase(_DatabaseMode mode)
1825 if (mode == DATABASE_MODE_NORMAL)
1833 _SecureIoUtil::IsSecureDatabase(_DatabaseMode mode)
1836 if (mode == DATABASE_MODE_SECURE)
1844 _SecureIoUtil::GetDatabaseMode(char* pStrPhysicalDbPath)
1846 result r = E_SUCCESS;
1848 unsigned long readBytes = 0;
1849 char buffer[SQLITE_HEADER_SIZE] = {0, };
1850 char magicNum1[SECURE_IO_MAGIC_NUMBER_SIZE] = {0xCA, 0xFE, 0xBE, 0xBE};
1851 char magicNum2[SECURE_IO_MAGIC_NUMBER_SIZE] = {0xDA, 0xEF, 0xEF, 0xEB};
1852 _NormalFile normalFile;
1856 r = normalFile.Construct(pStrPhysicalDbPath, "r");
1857 SysTryReturn(NID_IO, !IsFailed(r), DATABASE_MODE_ERROR, r, "[%s] Failed to open file (%s) in read mode", GetErrorMessage(r), pStrPhysicalDbPath);
1859 r = normalFile.Seek(FILESEEKPOSITION_END, 0);
1860 SysTryReturn(NID_IO, !IsFailed(r), DATABASE_MODE_ERROR, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
1862 fileLength = normalFile.Tell();
1863 if (fileLength <= 0)
1865 return DATABASE_MODE_NONE;
1868 r = normalFile.Seek(FILESEEKPOSITION_BEGIN, 0);
1869 SysTryReturn(NID_IO, !IsFailed(r), DATABASE_MODE_ERROR, r, "[%s] Failed to seek in file.", GetErrorMessage(r));
1871 readBytes = normalFile.Read(buffer, SQLITE_HEADER_SIZE);
1872 r = GetLastResult();
1873 SysTryReturn(NID_IO, readBytes > 0, DATABASE_MODE_ERROR, r, "[%s] File is not opened for reading or else failed to read data from file.", GetErrorMessage(r));
1875 if (!strncmp(buffer, "SQLite format 3", SQLITE_FORMAT_STR_SIZE))
1877 return DATABASE_MODE_NORMAL;
1879 else if (!memcmp((void*) buffer, magicNum1, SECURE_IO_MAGIC_NUMBER_SIZE) && !memcmp((void*) (buffer + SECURE_IO_12_BYTES), magicNum2, SECURE_IO_MAGIC_NUMBER_SIZE))
1881 return DATABASE_MODE_SECURE;
1884 return DATABASE_MODE_ERROR;
1888 _SecureIoUtil::GenerateDatabaseKeyN(const Tizen::Base::ByteBuffer* pUserKey)
1893 byte* pDbKey = null;
1897 unique_ptr< ByteBuffer > pKeyBuffer(GetSecureKeyN(pUserKey));
1899 SysTryReturn(NID_IO, pKeyBuffer != null, null, E_INVALID_ARG, "[E_INVALID_ARG] Failed to generate secure key.");
1901 pKey = const_cast< byte* >(pKeyBuffer->GetPointer());
1903 pDbKey = new (std::nothrow) byte[DATABASE_KEY_LENGTH * SECURE_IO_2_BYTES + 1];
1904 SysTryReturn(NID_IO, pDbKey != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
1906 memset(pDbKey, 0, DATABASE_KEY_LENGTH * SECURE_IO_2_BYTES + 1);
1908 for (int i = 0; i < DATABASE_KEY_LENGTH; i++)
1910 lowByte = pKey[i] & SECURE_IO_HEX_0F;
1911 highByte = (pKey[i] >> SECURE_IO_4_BITS) & SECURE_IO_HEX_0F;
1912 if (lowByte <= SECURE_IO_9_BYTES)
1914 pDbKey[i * SECURE_IO_2_BYTES + 1] = lowByte + '0';
1918 pDbKey[i * SECURE_IO_2_BYTES + 1] = lowByte - SECURE_IO_10_BYTES + 'A';
1921 if (highByte <= SECURE_IO_9_BYTES)
1923 pDbKey[i * SECURE_IO_2_BYTES] = highByte + '0';
1927 pDbKey[i * SECURE_IO_2_BYTES] = highByte - SECURE_IO_10_BYTES + 'A';
1935 _SecureIoUtil::IsEmpty(const String& filePath)
1937 result r = E_SUCCESS;
1938 FileAttributes attribute;
1941 r = File::GetAttributes(filePath, attribute);
1948 if (attribute.GetFileSize() == 0)