Adjust tests to use proper backends for tests

Change-Id: I979a4285f252c166d56fd08c5a514b78d9460138

diff --git a/src/ckm/unprivileged/encryption-decryption.cpp b/src/ckm/unprivileged/encryption-decryption.cpp
index 17d5c27336754b11b3facb57b1ce9afb8bca47e6..006370b629da75501d34cd9ad7dadd065981ea2e 100644 (file)
--- a/src/ckm/unprivileged/encryption-decryption.cpp
+++ b/src/ckm/unprivileged/encryption-decryption.cpp
@@ -29,6 +29,7 @@
 #include <ckm-common.h>
 #include <ckmc/ckmc-manager.h>
 #include <ckm/ckm-type.h>
+#include <ckm/ckm-manager.h>
 #include <encryption-decryption-env.h>
 
 using namespace CKM;
@@ -56,6 +57,34 @@ 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);
+}
+
+inline CKM::Policy _toCkmPolicy(const ckmc_policy_s &policy, PolicyBackend backend)
+{
+    return CKM::Policy(_tostring(policy.password), policy.extractable, backend);
+}
+
 EncryptionError apiDecrypt(ckmc_param_list_h params,
                         const char *key_alias,
                         const char *password,
@@ -65,6 +94,7 @@ EncryptionError apiDecrypt(ckmc_param_list_h params,
     return g_api->decrypt(params, key_alias, password, encrypted, ppdecrypted);
 }
 
+
 template <typename F, typename... Args>
 void assert_crypto_result(EncryptionError expected, F&& func, Args... args)
 {
@@ -175,7 +205,11 @@ KeyAliasPair AlgoAes::keyGen(const char* pass, const char* suffix)
     policy.extractable = false;
     policy.password = passPtr.get();
 
-    assert_positive(ckmc_create_key_aes, m_keyLen, aliases.prv.c_str(), policy);
+    auto mgr = CKM::Manager::create();
+    RUNNER_ASSERT_MSG(CKM_API_SUCCESS == mgr->createKeyAES(m_keyLen, Alias(aliases.prv.c_str()),
+                        _toCkmPolicy(policy, g_backend)),
+                        "AES key creation failed");
+
     return aliases;
 }
 
@@ -209,12 +243,13 @@ KeyAliasPair AlgoRsa::keyGen(const char* pass, const char* suffix)
     policyPub.password = passPtr.get();
     policyPub.extractable = 0;
 
-    assert_positive(ckmc_create_key_pair_rsa,
-                    m_keyLen,
-                    aliases.prv.c_str(),
-                    aliases.pub.c_str(),
-                    policyPrv,
-                    policyPub);
+    auto mgr = CKM::Manager::create();
+
+    RUNNER_ASSERT_MSG(CKM_API_SUCCESS == mgr->createKeyPairRSA(static_cast<int>(m_keyLen),
+                                                CKM::Alias(aliases.prv.c_str()),
+                                                CKM::Alias(aliases.pub.c_str()),
+                                                _toCkmPolicy(policyPrv, g_backend),
+                                                _toCkmPolicy(policyPub, g_backend)), "RSA key pair generation failed" );
     return aliases;
 }
 
@@ -1146,6 +1181,7 @@ 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(AES_CBC_128, false);
     testEncryptDecryptDifferentKeys(AES_CBC_192, false);
     testEncryptDecryptDifferentKeys(AES_CBC_256, false);
@@ -1220,61 +1256,73 @@ 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(AES_CBC_128);
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_aes_cbc_192, SyncEnv, AsyncEnv)
 {
+    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData(AES_CBC_192);
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_aes_cbc_256, SyncEnv, AsyncEnv)
 {
+    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData(AES_CBC_256);
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_aes_gcm_128, SyncEnv, AsyncEnv)
 {
+    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData(AES_GCM_128);
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_aes_gcm_192, SyncEnv, AsyncEnv)
 {
+    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData(AES_GCM_192);
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_aes_gcm_256, SyncEnv, AsyncEnv)
 {
+    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData(AES_GCM_256);
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_aes_ctr_128, SyncEnv, AsyncEnv)
 {
+    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData(AES_CTR_128);
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_aes_ctr_192, SyncEnv, AsyncEnv)
 {
+    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData(AES_CTR_192);
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_aes_ctr_256, SyncEnv, AsyncEnv)
 {
+    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData(AES_CTR_256);
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_aes_cfb_128, SyncEnv, AsyncEnv)
 {
+    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData(AES_CFB_128);
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_aes_cfb_192, SyncEnv, AsyncEnv)
 {
+    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData(AES_CFB_192);
 }
 
 RUNNER_TEST_MULTIPLE(TED_0400_encrypt_decrypt_big_data_aes_cfb_256, SyncEnv, AsyncEnv)
 {
+    testBackend b(PolicyBackend::FORCE_SOFTWARE);
     testEncryptDecryptBigData(AES_CFB_256);
 }
 
@@ -1385,6 +1433,7 @@ 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(AES_GCM_128);
     testGcmEncryptionTagLen(AES_GCM_192);
     testGcmEncryptionTagLen(AES_GCM_256);
@@ -1392,6 +1441,7 @@ 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(AES_GCM_128);
     testGcmDecryptionTagLen(AES_GCM_192);
     testGcmDecryptionTagLen(AES_GCM_256);
@@ -1399,6 +1449,7 @@ 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(AES_GCM_128);
     testGcmWrongTag(AES_GCM_192);
     testGcmWrongTag(AES_GCM_256);
@@ -1413,6 +1464,7 @@ 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(AES_GCM_128, CKMC_PARAM_ED_AAD);
     encryptionWithCustomData(AES_GCM_192, CKMC_PARAM_ED_AAD);
     encryptionWithCustomData(AES_GCM_256, CKMC_PARAM_ED_AAD);