CKM: Make encryption tests runnable on both backends

Depending on the TZ_BACKEND define the encryption tests will be executed on SW
or TZ backend. Tests need to be adjusted to properly work in both cases.

Change-Id: Ib59553faa0bb70958a71ea965cefd469cc5a8ef7

diff --git a/src/ckm/CMakeLists.txt b/src/ckm/CMakeLists.txt
index 7a13769..90b0d4f 100644 (file)
--- a/src/ckm/CMakeLists.txt
+++ b/src/ckm/CMakeLists.txt
@@ -29,6 +29,10 @@ ENDIF (DEFINED SECURITY_MDFPP_STATE_ENABLED)
 
 ADD_DEFINITIONS("-DCKM_TEST_DIR=\"${CKM_TEST_DIR}\"")
 ADD_DEFINITIONS("-DCKM_RW_DATA_DIR=\"${CKM_RW_DATA_DIR}\"")
+OPTION("TZ_BACKEND" OFF)
+IF(TZ_BACKEND)
+    ADD_DEFINITIONS("-DTZ_BACKEND")
+ENDIF(TZ_BACKEND)
 
 OPTION("TZ_BACKEND" OFF)
 IF(TZ_BACKEND)

diff --git a/src/ckm/unprivileged/encryption-decryption.cpp b/src/ckm/unprivileged/encryption-decryption.cpp
index 9b19a0f..0643380 100644 (file)
--- a/src/ckm/unprivileged/encryption-decryption.cpp
+++ b/src/ckm/unprivileged/encryption-decryption.cpp
@@ -57,24 +57,6 @@ EncryptionError apiEncrypt(ckmc_param_list_h params,
     return g_api->encrypt(params, key_alias, password, decrypted, ppencrypted);
 }
 
-// Policy backend to use in subsequent operations (global for each test case)
-PolicyBackend g_backend = PolicyBackend::DEFAULT;
-
-class testBackend {
-public:
-    testBackend(PolicyBackend backend){
-        m_backend = g_backend;
-        g_backend = backend;
-    }
-
-    virtual ~testBackend(){
-        //restore in destructor
-        g_backend = m_backend;
-    }
-private:
-    PolicyBackend m_backend;
-};
-
 inline CKM::Password _tostring(const char *str)
 {
     return (str == nullptr) ? Password() : Password(str);
@@ -177,11 +159,11 @@ ckmc_raw_buffer_s* IV128;
 ckmc_raw_buffer_s* AAD32;
 ckmc_raw_buffer_s* AAD64;
 
-void generateSymmetricKeys(ManagerShPtr& manager, size_t bitLen)
+void generateSymmetricKeys(ManagerShPtr& manager, PolicyBackend backend, size_t bitLen)
 {
     for (int i = 0; i < KEY_IDX_MAX; i++)
     {
-        Policy p(Password(), true, g_backend);
+        Policy p(Password(), false, backend);
         if (i == PASSWORD_PROTECTED)
             p.password.assign(PASSWORD);
 
@@ -194,20 +176,21 @@ void generateSymmetricKeys(ManagerShPtr& manager, size_t bitLen)
     }
 }
 
-void generateRsaKeys(ManagerShPtr& manager, size_t bitLen)
+void generateRsaKeys(ManagerShPtr& manager, PolicyBackend backend, size_t bitLen)
 {
     for (int i = 0; i < KEY_IDX_MAX; i++)
     {
-        Policy p(Password(), true, g_backend);
+        Policy prvPolicy(Password(), false, backend);
+        Policy pubPolicy(Password(), true, backend);
         if (i == PASSWORD_PROTECTED) {
-            p.password.assign(PASSWORD);
-            //p.extractable = false;
+            prvPolicy.password.assign(PASSWORD);
+            pubPolicy.password.assign(PASSWORD);
         }
 
         KeyAliasPair alias;
         alias.prv = std::string("akey_") + std::to_string(bitLen) + std::string("_") + std::to_string(i);
         alias.pub = std::string("pub") + alias.prv;
-        int ret = manager->createKeyPairRSA(bitLen, alias.prv, alias.pub, p);
+        int ret = manager->createKeyPairRSA(bitLen, alias.prv, alias.pub, prvPolicy, pubPolicy);
         if (ret != CKM_API_SUCCESS)
             RUNNER_ERROR_MSG("RSA key creation failed");
 
@@ -236,6 +219,13 @@ public:
         if (ret != CKMC_ERROR_NONE)
             RUNNER_ERROR_MSG("DB unlock failed: " << CKMCErrorToString(ret));
 
+        // Policy backend to use in subsequent operations (global for each test case)
+#ifdef TZ_BACKEND
+        PolicyBackend backend = PolicyBackend::FORCE_HARDWARE;
+#else
+        PolicyBackend backend = PolicyBackend::FORCE_SOFTWARE;
+#endif
+
         // generate keys
         auto manager = Manager::create();
         generateSymmetricKeys(manager, 128);
@@ -246,7 +236,11 @@ public:
         generateRsaKeys(manager, 4096);
 
         PLAIN_DATA = create_raw_buffer(createRandomBufferCAPI(BUF_LEN));
+#ifdef TZ_BACKEND
+        BIG_DATA = create_raw_buffer(createRandomBufferCAPI(100000));
+#else
         BIG_DATA = create_raw_buffer(createRandomBufferCAPI(5000000));
+#endif
         DEFAULT_IV = createRandomBufferCAPI(DEFAULT_IV_LEN);
         IV11 = createRandomBufferCAPI(11);
         IV12 = createRandomBufferCAPI(12);
@@ -1116,7 +1110,6 @@ RUNNER_TEST_MULTIPLE(TED_0140_decrypt_no_output_buffer, SyncEnv, AsyncEnv)
 
 RUNNER_TEST_MULTIPLE(TED_0200_encrypt_decrypt_different_keys, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptDifferentKeys({CKMC_ALGO_AES_GCM, 128}, false);
     testEncryptDecryptDifferentKeys({CKMC_ALGO_AES_GCM, 192}, false);
     testEncryptDecryptDifferentKeys({CKMC_ALGO_AES_GCM, 256}, false);
@@ -1186,73 +1179,61 @@ RUNNER_TEST_MULTIPLE(TED_0310_encrypt_decrypt_password, SyncEnv, AsyncEnv)
 // long test split into smaller ones
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_AES_CBC_128, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData({CKMC_ALGO_AES_CBC, 128});
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_AES_CBC_192, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData({CKMC_ALGO_AES_CBC, 192});
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_AES_CBC_256, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData({CKMC_ALGO_AES_CBC, 256});
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_AES_GCM_128, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData({CKMC_ALGO_AES_GCM, 128});
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_AES_GCM_192, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData({CKMC_ALGO_AES_GCM, 192});
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_AES_GCM_256, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData({CKMC_ALGO_AES_GCM, 256});
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_AES_CTR_128, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData({CKMC_ALGO_AES_CTR, 128});
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_AES_CTR_192, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData({CKMC_ALGO_AES_CTR, 192});
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_AES_CTR_256, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData({CKMC_ALGO_AES_CTR, 256});
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_AES_CFB_128, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData({CKMC_ALGO_AES_CFB, 128});
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_AES_CFB_192, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData({CKMC_ALGO_AES_CFB, 192});
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_AES_CFB_256, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData({CKMC_ALGO_AES_CFB, 256});
 }
 
@@ -1363,7 +1344,6 @@ RUNNER_TEST_MULTIPLE(TED_1115_ctr_decryption_valid_length, SyncEnv, AsyncEnv)
 
 RUNNER_TEST_MULTIPLE(TED_1200_gcm_encryption_tag_len, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testGcmEncryptionTagLen({CKMC_ALGO_AES_GCM, 128});
     testGcmEncryptionTagLen({CKMC_ALGO_AES_GCM, 192});
     testGcmEncryptionTagLen({CKMC_ALGO_AES_GCM, 256});
@@ -1371,7 +1351,6 @@ RUNNER_TEST_MULTIPLE(TED_1200_gcm_encryption_tag_len, SyncEnv, AsyncEnv)
 
 RUNNER_TEST_MULTIPLE(TED_1210_gcm_decryption_tag_len, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testGcmDecryptionTagLen({CKMC_ALGO_AES_GCM, 128});
     testGcmDecryptionTagLen({CKMC_ALGO_AES_GCM, 192});
     testGcmDecryptionTagLen({CKMC_ALGO_AES_GCM, 256});
@@ -1379,7 +1358,6 @@ RUNNER_TEST_MULTIPLE(TED_1210_gcm_decryption_tag_len, SyncEnv, AsyncEnv)
 
 RUNNER_TEST_MULTIPLE(TED_1230_gcm_wrong_tag, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testGcmWrongTag({CKMC_ALGO_AES_GCM, 128});
     testGcmWrongTag({CKMC_ALGO_AES_GCM, 192});
     testGcmWrongTag({CKMC_ALGO_AES_GCM, 256});
@@ -1394,7 +1372,6 @@ RUNNER_TEST_MULTIPLE(TED_1240_gcm_different_iv_sizes, SyncEnv, AsyncEnv)
 
 RUNNER_TEST_MULTIPLE(TED_1250_gcm_aad, SyncEnv, AsyncEnv)
 {
-    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     encryptionWithCustomData({CKMC_ALGO_AES_GCM, 128}, CKMC_PARAM_ED_AAD);
     encryptionWithCustomData({CKMC_ALGO_AES_GCM, 192}, CKMC_PARAM_ED_AAD);
     encryptionWithCustomData({CKMC_ALGO_AES_GCM, 256}, CKMC_PARAM_ED_AAD);