migrate_1.sql
migrate_2.sql
migrate_3.sql
+ migrate_4.sql
DESTINATION ${RO_DATA_DIR}/scripts)
JOIN PERMISSIONS AS P ON P.idx=N.idx;
CREATE VIEW IF NOT EXISTS [join_all_tables] AS
- SELECT N.*, P.permissionLabel, P.permissionMask, O.dataType FROM NAMES AS N
+ SELECT N.*, P.permissionLabel, P.permissionMask, O.* FROM NAMES AS N
JOIN OBJECTS AS O ON O.idx=N.idx
JOIN PERMISSIONS AS P ON P.idx=N.idx;
--- /dev/null
+/*
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+
+-- update schema
+DROP VIEW IF EXISTS join_all_tables;
+
+CREATE VIEW [join_all_tables] AS
+ SELECT N.*, P.permissionLabel, P.permissionMask, O.* FROM NAMES AS N
+ JOIN OBJECTS AS O ON O.idx=N.idx
+ JOIN PERMISSIONS AS P ON P.idx=N.idx;
\ No newline at end of file
// verify everything has been removed
for (unsigned l = 0; l < OWNERS; l++) {
generate_owner(l, owner);
- OwnerNameVector expect_no_data;
- BOOST_REQUIRE_NO_THROW(m_db.listNames(owner, expect_no_data,
+ AliasInfoVector expect_no_data;
+ BOOST_REQUIRE_NO_THROW(m_db.listInfos(owner, expect_no_data,
DataType::BINARY_DATA));
BOOST_REQUIRE(0 == expect_no_data.size());
}
unsigned seed = 0;
// actual test - random lookup
- Perf perf("listNames", ITERATIONS);
+ Perf perf("listInfos", ITERATIONS);
for (unsigned t = 0; t < ITERATIONS; t++) {
- OwnerNameVector ret_list;
+ AliasInfoVector ret_list;
generate_owner(rand_r(&seed) % OWNERS, owner);
- BOOST_REQUIRE_NO_THROW(m_db.listNames(owner, ret_list, DataType::BINARY_DATA));
+ BOOST_REQUIRE_NO_THROW(m_db.listInfos(owner, ret_list, DataType::BINARY_DATA));
BOOST_REQUIRE(NAMES == ret_list.size());
ret_list.clear();
}
* ClientId is optional
*/
typedef std::string Alias;
+
/*
* ClientId is an identifier of the API caller returned by security-manager(pkgid).
* It can be an application or a system component.
* or just a client in general.
*/
typedef std::string ClientId;
+/*
+ * Name is an object identifier. It is unique among names of objects owned by given owner (ClientId)
+ */
+typedef std::string Name;
+
typedef std::vector<Alias> AliasVector;
// backend identifiers
};
struct AliasInfo {
- bool passwordProtected;
+ Alias alias;
+ int type;
BackendId backend;
+
+ AliasInfo() : type(0), backend(BackendId::SW) {}
+ AliasInfo(const Alias& alias, int type, BackendId backend) :
+ alias(alias),
+ type(type),
+ backend(backend)
+ {
+ }
};
-typedef std::vector<std::pair<Alias, AliasInfo>> AliasInfoVector;
+typedef std::vector<AliasInfo> AliasInfoVector;
enum class KeyType : int {
KEY_NONE = 0,
{
DataType dataType;
int retCode = 0;
- OwnerNameVector ownerNameVector;
- m_buffer.Deserialize(retCode, dataType, ownerNameVector);
+ AliasInfoVector aliasInfoVector;
+ AliasInfoSerializableVector aisv(aliasInfoVector);
+ m_buffer.Deserialize(retCode, dataType, aisv);
// check error code
if (retCode != CKM_API_SUCCESS) {
AliasVector aliasVector;
- for (const auto &it : ownerNameVector)
- aliasVector.push_back(AliasSupport::merge(it.first, it.second));
+ for (const auto &it : aliasInfoVector)
+ aliasVector.push_back(it.alias);
if (dataType.isKey())
m_observer->ReceivedKeyAliasVector(std::move(aliasVector));
};
int _ckmc_alias_info_new(const char* alias,
- bool is_password_protected,
+ int type,
ckmc_backend_id_e backend,
ckmc_alias_info_s** info)
{
free(_info);
return CKMC_ERROR_OUT_OF_MEMORY;
}
- _info->is_password_protected = is_password_protected;
+ _info->type = type;
_info->backend = backend;
*info = _info;
return CKMC_ERROR_NONE;
if (previous != nullptr)
previous->next = plist;
- const auto& info = std::get<1>(it);
- ret = _ckmc_alias_info_new(std::get<0>(it).c_str(),
- info.passwordProtected,
- static_cast<ckmc_backend_id_e>(info.backend),
+ ret = _ckmc_alias_info_new(it.alias.c_str(),
+ it.type,
+ static_cast<ckmc_backend_id_e>(it.backend),
&plist->info);
if (ret != CKMC_ERROR_NONE)
break;
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
-#include <ckm/ckm-type.h>
+#include <ckm/ckm-manager.h>
#include <ckmc/ckmc-type.h>
#include <ckmc/ckmc-error.h>
#include <ckmc-type-converter.h>
if (info == NULL || is_password_protected == NULL)
return CKMC_ERROR_INVALID_PARAMETER;
- *is_password_protected = info->is_password_protected;
+ EXCEPTION_GUARD_START_CAPI
+
+ auto mgr = CKM::Manager::create();
+ bool status;
+ int ret;
+ CKM::DataType dt(static_cast<CKM::DataType::Type>(info->type));
+ if (dt.isBinaryData())
+ ret = mgr->getDataEncryptionStatus(info->alias, status);
+ else if (dt.isKey())
+ ret = mgr->getKeyEncryptionStatus(info->alias, status);
+ else if (dt.isCertificate() || dt.isChainCert())
+ ret = mgr->getCertificateEncryptionStatus(info->alias, status);
+ else
+ return CKMC_ERROR_SERVER_ERROR;
+
+ if (ret != CKM_API_SUCCESS)
+ return to_ckmc_error(ret);
+
+ *is_password_protected = status;
return CKMC_ERROR_NONE;
-}
+ EXCEPTION_GUARD_END
+}
KEY_MANAGER_CAPI
void ckmc_alias_info_list_all_free(ckmc_alias_info_list_s *first)
return m_sock;
}
-AliasSupport::AliasSupport(const Alias &alias)
-{
- std::size_t separator_pos = alias.rfind(CKM::ALIAS_SEPARATOR);
-
- if (separator_pos == Alias::npos) {
- m_owner.clear();
- m_name = alias;
- } else {
- m_owner = alias.substr(0, separator_pos);
- m_name = alias.substr(separator_pos + strlen(CKM::ALIAS_SEPARATOR));
- }
-}
-
-Alias AliasSupport::merge(const ClientId &owner, const Name &name)
-{
- if (owner.empty())
- return name;
-
- std::stringstream output;
- output << owner << std::string(CKM::ALIAS_SEPARATOR) << name;
- return output.str();
-}
-
-const Name &AliasSupport::getName() const
-{
- return m_name;
-}
-
-const ClientId &AliasSupport::getOwner() const
-{
- return m_owner;
-}
-
-bool AliasSupport::isOwnerEmpty() const
-{
- return m_owner.empty();
-}
-
ServiceConnection::ServiceConnection(const char *service_interface)
{
if (service_interface)
struct ckmc_alias_info_s {
char* alias;
- bool is_password_protected;
+ int type;
ckmc_backend_id_e backend;
};
namespace CKM {
-class AliasSupport {
-public:
- explicit AliasSupport(const Alias &alias);
-
- const ClientId &getOwner() const;
- const Name &getName() const;
- bool isOwnerEmpty() const;
-
- static Alias merge(const ClientId &owner, const Name &alias);
-
-private:
- Name m_name;
- ClientId m_owner;
-};
-
class SockRAII {
public:
SockRAII();
return recvDataType.isBinaryData() ? CKM_API_SUCCESS : CKM_API_ERROR_BAD_RESPONSE;
}
-int Manager::Impl::getBinaryDataAliasVectorHelper(DataType dataType,
- OwnerNameVector &ownerNameVector)
+int Manager::Impl::getAliasInfoVectorHelper(DataType dataType, AliasInfoVector &aliasInfoVector)
{
DataType tmpDataType;
- return Request(*this, LogicCommand::GET_LIST, m_storageConnection,
- dataType
- ).maybeDeserialize(tmpDataType, ownerNameVector);
-}
-
-int Manager::Impl::getBinaryDataAliasVector(DataType dataType,
- AliasVector &aliasVector)
-{
- EXCEPTION_GUARD_START_CPPAPI
- OwnerNameVector ownerNameVector;
- int retCode = getBinaryDataAliasVectorHelper(dataType, ownerNameVector);
-
- if (retCode != CKM_API_SUCCESS)
- return retCode;
-
- for (const auto &it : ownerNameVector)
- aliasVector.push_back(AliasSupport::merge(it.first, it.second));
-
- return CKM_API_SUCCESS;
- EXCEPTION_GUARD_END
+ AliasInfoSerializableVector aisv(aliasInfoVector);
+ return Request(*this,
+ LogicCommand::GET_LIST,
+ m_storageConnection,
+ dataType).maybeDeserialize(tmpDataType, aisv);
}
-int Manager::Impl::getBinaryDataAliasInfoVector(DataType dataType,
- AliasInfoVector &aliasInfoVector)
+int Manager::Impl::getAliasVectorHelper(DataType dataType, AliasVector &aliasVector)
{
EXCEPTION_GUARD_START_CPPAPI
- OwnerNameVector ownerNameVector;
- OwnerNameEncryptionStatusVector ownerNameEncryptionStatusVector;
- int retCode = getBinaryDataAliasVectorHelper(dataType, ownerNameVector);
+ AliasInfoVector aliasInfoVector;
+ int retCode = getAliasInfoVectorHelper(dataType, aliasInfoVector);
if (retCode != CKM_API_SUCCESS)
return retCode;
- for (const auto &it : ownerNameVector)
- {
- Alias alias = AliasSupport::merge(std::get<0>(it), std::get<1>(it));
- bool status;
- retCode = getBinaryDataEncryptionStatus(dataType, alias, status);
-
- if (retCode != CKM_API_SUCCESS)
- return retCode;
+ for (const auto &it : aliasInfoVector)
+ aliasVector.push_back(it.alias);
- // TODO get the actual backend
- aliasInfoVector.push_back(std::make_pair(alias, AliasInfo({status, BackendId::SW})));
- }
return CKM_API_SUCCESS;
EXCEPTION_GUARD_END
}
{
// in fact datatype has no meaning here - if not certificate or binary data
// then manager decides to list all between DB_KEY_FIRST and DB_KEY_LAST
- return getBinaryDataAliasVector(DataType::DB_KEY_LAST, aliasVector);
+ return getAliasVectorHelper(DataType::DB_KEY_LAST, aliasVector);
}
int Manager::Impl::getCertificateAliasVector(AliasVector &aliasVector)
{
- return getBinaryDataAliasVector(DataType::CERTIFICATE, aliasVector);
+ return getAliasVectorHelper(DataType::CERTIFICATE, aliasVector);
}
int Manager::Impl::getDataAliasVector(AliasVector &aliasVector)
{
- return getBinaryDataAliasVector(DataType::BINARY_DATA, aliasVector);
+ return getAliasVectorHelper(DataType::BINARY_DATA, aliasVector);
}
int Manager::Impl::getKeyAliasInfoVector(AliasInfoVector &aliasInfoVector)
{
- return getBinaryDataAliasInfoVector(DataType::DB_KEY_LAST, aliasInfoVector);
+ return getAliasInfoVectorHelper(DataType::DB_KEY_LAST, aliasInfoVector);
}
int Manager::Impl::getKeyEncryptionStatus(const Alias &alias, bool &status)
int Manager::Impl::getCertificateAliasInfoVector(AliasInfoVector &aliasInfoVector)
{
- return getBinaryDataAliasInfoVector(DataType::CERTIFICATE, aliasInfoVector);
+ return getAliasInfoVectorHelper(DataType::CERTIFICATE, aliasInfoVector);
}
int Manager::Impl::getCertificateEncryptionStatus(const Alias &alias, bool &status)
int Manager::Impl::getDataAliasInfoVector(AliasInfoVector &aliasInfoVector)
{
- return getBinaryDataAliasInfoVector(DataType::BINARY_DATA, aliasInfoVector);
+ return getAliasInfoVectorHelper(DataType::BINARY_DATA, aliasInfoVector);
}
int Manager::Impl::getDataEncryptionStatus(const Alias &alias, bool &status)
const Alias &alias,
bool &status);
- int getBinaryDataAliasVector(
+ int getAliasVectorHelper(
DataType sendDataType,
AliasVector &aliasVector);
- int getBinaryDataAliasVectorHelper(
- DataType sendDataType,
- OwnerNameVector &ownerNameVector);
-
- int getBinaryDataAliasInfoVector(
- DataType sendDataType,
+ int getAliasInfoVectorHelper(
+ DataType dataType,
AliasInfoVector &aliasInfoVector);
int createKeyPair(
}
}
+
+AliasInfoSerializableVector::AliasInfoSerializableVector(AliasInfoVector &v) : aliasInfoVector(v)
+{
+}
+
+void AliasInfoSerializableVector::Deserialize(IStream &stream)
+{
+ size_t size;
+ Deserialization::Deserialize(stream, size);
+ aliasInfoVector.clear();
+ aliasInfoVector.reserve(size);
+ for (size_t i = 0; i < size; i++) {
+ AliasInfo ai;
+ Deserialization::Deserialize(stream, ai.alias);
+ Deserialization::Deserialize(stream, ai.type);
+ Deserialization::Deserialize(stream, ai.backend);
+ aliasInfoVector.push_back(std::move(ai));
+ }
+}
+
+void AliasInfoSerializableVector::Serialize(IStream &stream) const
+{
+ Serialization::Serialize(stream, aliasInfoVector.size());
+ for (const auto& ai : aliasInfoVector) {
+ Serialization::Serialize(stream, ai.alias);
+ Serialization::Serialize(stream, ai.type);
+ Serialization::Serialize(stream, ai.backend);
+ }
+}
+
+AliasSupport::AliasSupport(const Alias &alias)
+{
+ std::size_t separator_pos = alias.rfind(CKM::ALIAS_SEPARATOR);
+
+ if (separator_pos == Alias::npos) {
+ m_owner.clear();
+ m_name = alias;
+ } else {
+ m_owner = alias.substr(0, separator_pos);
+ m_name = alias.substr(separator_pos + strlen(CKM::ALIAS_SEPARATOR));
+ }
+}
+
+Alias AliasSupport::merge(const ClientId &owner, const Name &name)
+{
+ if (owner.empty())
+ return name;
+
+ std::stringstream output;
+ output << owner << std::string(CKM::ALIAS_SEPARATOR) << name;
+ return output.str();
+}
+
+const Name &AliasSupport::getName() const
+{
+ return m_name;
+}
+
+const ClientId &AliasSupport::getOwner() const
+{
+ return m_owner;
+}
+
+bool AliasSupport::isOwnerEmpty() const
+{
+ return m_owner.empty();
+}
+
} // namespace CKM
COMMON_API extern char const *const CLIENT_ID_SYSTEM;
COMMON_API extern char const *const CLIENT_ID_ADMIN_USER;
-typedef std::string Name;
typedef std::vector<std::pair<ClientId, Name>> OwnerNameVector;
-typedef std::vector<std::tuple<ClientId, Name, bool>> OwnerNameEncryptionStatusVector;
class IStream;
void Deserialize(IStream &) override;
};
+struct COMMON_API AliasInfoSerializableVector : public ISerializable {
+ explicit AliasInfoSerializableVector(AliasInfoVector &);
+ void Serialize(IStream &) const override;
+ void Deserialize(IStream &) override;
+private:
+ AliasInfoVector& aliasInfoVector;
+};
+
+class COMMON_API AliasSupport {
+public:
+ explicit AliasSupport(const Alias &alias);
+
+ const ClientId &getOwner() const;
+ const Name &getName() const;
+ bool isOwnerEmpty() const;
+
+ static Alias merge(const ClientId &owner, const Name &alias);
+
+private:
+ Name m_name;
+ ClientId m_owner;
+};
+
} // namespace CKM
return SerializeMessage(msgId, retCode, output);
}
-int CKMLogic::getDataListHelper(const Credentials &cred,
- const DataType dataType,
- OwnerNameVector &ownerNameVector)
+int CKMLogic::getAliasInfoListHelper(const Credentials &cred,
+ const DataType dataType,
+ AliasInfoVector &aliasInfoVector)
{
int retCode = CKM_API_ERROR_DB_LOCKED;
auto &database = m_userDataMap[cred.clientUid].database;
retCode = tryRet<CKM_API_ERROR_DB_ERROR>([&] {
- OwnerNameVector tmpVector;
+ AliasInfoVector tmpVector;
if (dataType.isKey()) {
// list all key types
- database.listNames(cred.client,
+ database.listInfos(cred.client,
tmpVector,
DataType::DB_KEY_FIRST,
DataType::DB_KEY_LAST);
} else {
// list anything else
- database.listNames(cred.client,
- tmpVector,
- dataType);
+ database.listInfos(cred.client, tmpVector, dataType);
}
- ownerNameVector.insert(ownerNameVector.end(), tmpVector.begin(),
- tmpVector.end());
+ aliasInfoVector.insert(aliasInfoVector.end(), tmpVector.begin(), tmpVector.end());
return CKM_API_SUCCESS;
});
}
int msgId,
DataType dataType)
{
- OwnerNameVector systemVector;
- OwnerNameVector userVector;
- OwnerNameVector ownerNameVector;
+ AliasInfoVector systemVector;
+ AliasInfoVector userVector;
+ AliasInfoVector aliasInfoVector;
int retCode = unlockSystemDB();
// system database
if (m_accessControl.isSystemService(cred)) {
// lookup system DB
- retCode = getDataListHelper(Credentials(SYSTEM_DB_UID, CLIENT_ID_SYSTEM),
- dataType,
- systemVector);
+ retCode = getAliasInfoListHelper(Credentials(SYSTEM_DB_UID, CLIENT_ID_SYSTEM),
+ dataType,
+ systemVector);
} else {
// user - lookup system, then client DB
- retCode = getDataListHelper(Credentials(SYSTEM_DB_UID, cred.client),
- dataType,
- systemVector);
+ retCode = getAliasInfoListHelper(Credentials(SYSTEM_DB_UID, cred.client),
+ dataType,
+ systemVector);
// private database
if (retCode == CKM_API_SUCCESS) {
- retCode = getDataListHelper(cred,
- dataType,
- userVector);
+ retCode = getAliasInfoListHelper(cred,
+ dataType,
+ userVector);
}
}
}
if (retCode == CKM_API_SUCCESS) {
- ownerNameVector.insert(ownerNameVector.end(), systemVector.begin(),
+ aliasInfoVector.insert(aliasInfoVector.end(), systemVector.begin(),
systemVector.end());
- ownerNameVector.insert(ownerNameVector.end(), userVector.begin(),
+ aliasInfoVector.insert(aliasInfoVector.end(), userVector.begin(),
userVector.end());
}
- return SerializeMessage(msgId, retCode, dataType, ownerNameVector);
+ return SerializeMessage(msgId, retCode, dataType, AliasInfoSerializableVector(aliasInfoVector));
}
int CKMLogic::importInitialData(
bool useTrustedSystemCertificates,
RawBufferVector &chainRawVector);
- int getDataListHelper(
+ int getAliasInfoListHelper(
const Credentials &cred,
const DataType dataType,
- OwnerNameVector &ownerNameVector);
+ AliasInfoVector &aliasInfoVector);
void migrateSecureStorageData(bool isAdminUser);
#include <map>
#include <ckm/ckm-type.h>
-#include <db-crypto.h>
#include <exception.h>
+#include <db-row.h>
namespace CKM {
* increment and update DB_VERSION_CURRENT,
* then provide migration mechanism!
*/
- DB_VERSION_CURRENT = 4
+ DB_VERSION_CURRENT = 5
};
const char *SCRIPT_CREATE_SCHEMA = "create_schema";
* objects accessible by L1 the query will produce one result (L1, N1) for each allowed
* accessor but GROUP BY will reduce them to one so L1 will have (L1, N1) on its list only once
*/
-const char *DB_CMD_NAME_SELECT_BY_TYPE_AND_PERMISSION =
- "SELECT label, name FROM [join_all_tables] "
+const char *DB_CMD_INFO_SELECT_BY_TYPE_AND_PERMISSION =
+ "SELECT label, name, dataType, backendId FROM [join_all_tables] "
" WHERE dataType>=?001 AND dataType<=?002 "
" AND permissionLabel=?104 AND permissionMask&?004!=0 GROUP BY idx;";
}
" name ", name, " with owner label ", owner);
}
-void Crypto::listNames(
- const ClientId &owner,
- OwnerNameVector &ownerNameVector,
- DataType type)
+void Crypto::listInfos(const ClientId &owner,
+ AliasInfoVector &aliasInfoVector,
+ DataType type)
{
- listNames(owner, ownerNameVector, type, type);
+ listInfos(owner, aliasInfoVector, type, type);
}
-void Crypto::listNames(
- const ClientId &owner,
- OwnerNameVector &ownerNameVector,
- DataType typeRangeStart,
- DataType typeRangeStop)
+void Crypto::listInfos(const ClientId &owner,
+ AliasInfoVector &aliasInfoVector,
+ DataType typeRangeStart,
+ DataType typeRangeStop)
{
try {
Transaction transaction(this);
SqlConnection::DataCommandUniquePtr selectCommand =
- m_connection->PrepareDataCommand(DB_CMD_NAME_SELECT_BY_TYPE_AND_PERMISSION);
+ m_connection->PrepareDataCommand(DB_CMD_INFO_SELECT_BY_TYPE_AND_PERMISSION);
selectCommand->BindInteger(1, typeRangeStart);
selectCommand->BindInteger(2, typeRangeStop);
selectCommand->BindString(104, owner.c_str());
static_cast<int>(Permission::READ | Permission::REMOVE));
while (selectCommand->Step()) {
- ClientId itemOwner = selectCommand->GetColumnString(0);
- Name itemName = selectCommand->GetColumnString(1);
- ownerNameVector.push_back(std::make_pair(itemOwner, itemName));
+ ClientId owner = selectCommand->GetColumnString(0);
+ Name name = selectCommand->GetColumnString(1);
+ int type = selectCommand->GetColumnInteger(2);
+ auto cryptoBackend = static_cast<CryptoBackend>(selectCommand->GetColumnInteger(3));
+ BackendId backendId;
+ switch (cryptoBackend) {
+ case CryptoBackend::OpenSSL:
+ backendId = BackendId::SW;
+ break;
+ case CryptoBackend::TrustZone:
+ backendId = BackendId::TZ;
+ break;
+ default:
+ ThrowErr(Exc::DatabaseFailed,
+ "Unexpected backend: ",
+ static_cast<unsigned>(cryptoBackend));
+ }
+ aliasInfoVector.emplace_back(AliasSupport::merge(owner, name), type, backendId);
}
return;
DataType typeRangeStop,
RowVector &output);
- void listNames(
+ void listInfos(
const ClientId &owner,
- OwnerNameVector &ownerNameVector,
+ AliasInfoVector &aliasInfoVector,
DataType type);
- void listNames(
+ void listInfos(
const ClientId &owner,
- OwnerNameVector &ownerNameVector,
+ AliasInfoVector &aliasInfoVector,
DataType typeRangeStart,
DataType typeRangeStop);
resources/testme_ver2.db
resources/testme_ver3.db
resources/testme0_ver4.db
+ resources/testme0_ver5.db
resources/KDFCTR_gen.rsp
DESTINATION ${DB_TEST_DIR}
)
*/
#include <boost_macros_wrapper.h>
#include <ckm/ckm-type.h>
+#include <protocols.h>
#include <test_common.h>
#include <DBFixture.h>
for (auto name : NAMES)
insert_row(name, m_default_owner);
- OwnerNameVector ownerNameVector;
- BOOST_REQUIRE_NO_THROW(m_db.listNames(m_default_owner, ownerNameVector, DataType::BINARY_DATA));
- BOOST_REQUIRE(ownerNameVector.size() == NAME_CNT);
+ AliasInfoVector aliasInfoVector;
+ BOOST_REQUIRE_NO_THROW(m_db.listInfos(m_default_owner, aliasInfoVector, DataType::BINARY_DATA));
+ BOOST_REQUIRE(aliasInfoVector.size() == NAME_CNT);
BOOST_REQUIRE_NO_THROW(m_db.deleteKey(m_default_owner));
- ownerNameVector.clear();
- BOOST_REQUIRE_NO_THROW(m_db.listNames(m_default_owner, ownerNameVector, DataType::BINARY_DATA));
- BOOST_REQUIRE(ownerNameVector.empty());
+ aliasInfoVector.clear();
+ BOOST_REQUIRE_NO_THROW(m_db.listInfos(m_default_owner, aliasInfoVector, DataType::BINARY_DATA));
+ BOOST_REQUIRE(aliasInfoVector.empty());
BOOST_REQUIRE_NO_THROW(keyOpt = m_db.getKey(m_default_owner));
BOOST_REQUIRE(!keyOpt);
fixture.generate_owner(migration_reference_owner_idx, reference_owner);
// check number of elements accessible to the reference owner
- OwnerNameVector ret_list;
- BOOST_REQUIRE_NO_THROW(fixture.m_db.listNames(reference_owner, ret_list,
+ AliasInfoVector ret_list;
+ BOOST_REQUIRE_NO_THROW(fixture.m_db.listInfos(reference_owner, ret_list,
DataType::BINARY_DATA));
BOOST_REQUIRE((migration_names / migration_owners)/*own items*/ +
(migration_owners - 1)/*other owners'*/ == ret_list.size());
ClientId current_owner;
fixture.generate_owner(l, current_owner);
- BOOST_REQUIRE_NO_THROW(fixture.m_db.listNames(current_owner, ret_list,
+ BOOST_REQUIRE_NO_THROW(fixture.m_db.listInfos(current_owner, ret_list,
DataType::BINARY_DATA));
BOOST_REQUIRE((migration_names / migration_owners) == ret_list.size());
for (auto& it : ret_list)
- BOOST_REQUIRE(it.first == current_owner);
+ BOOST_REQUIRE(CKM::AliasSupport(it.alias).getOwner() == current_owner);
ret_list.clear();
}
NEGATIVE_TEST_CASE(DBMigrationInvalid)
{
- DBFixture(DB_TEST_DIR "/testme0_ver4.db", nullptr,
- DBFixture::DBCryptoThrows::yes);
+ DBFixture(DB_TEST_DIR "/testme0_ver4.db", nullptr, DBFixture::DBCryptoThrows::yes);
}
NEGATIVE_TEST_CASE(DBMigrationInvalidUncleanBoot)
NEGATIVE_TEST_CASE(DBMigrationInvalid0)
{
- DBFixture(nullptr, DB_TEST_DIR "/testme_ver3.db",
- DBFixture::DBCryptoThrows::yes);
+ DBFixture(nullptr, DB_TEST_DIR "/testme_ver3.db", DBFixture::DBCryptoThrows::yes);
+}
+
+POSITIVE_TEST_CASE(DB0MigrationDBVer5)
+{
+ verifyDBisValid(nullptr, DB_TEST_DIR "/testme0_ver5.db");
}
POSITIVE_TEST_CASE(DBMigrationDBCurrent)
projects / platform / core / security / key-manager.git / commitdiff