Keep the backend id in GObj

This is necessary for key derivation & wrapping, when one object
creates another.

Update SW and TZ backend.

Change-Id: I898b75b0cc093414d089ed4130827571d592315f

diff --git a/src/manager/crypto/generic-backend/gobj.h b/src/manager/crypto/generic-backend/gobj.h
index 9da3b88..b7a43c4 100644 (file)
--- a/src/manager/crypto/generic-backend/gobj.h
+++ b/src/manager/crypto/generic-backend/gobj.h
@@ -26,13 +26,14 @@
 #include <ckm/ckm-type.h>
 
 #include <generic-backend/exception.h>
+#include <crypto-backend.h>
 
 namespace CKM {
 namespace Crypto {
 
 class GObj {
 protected:
-       GObj() {}
+       explicit GObj(CryptoBackend backendId) : m_backendId(backendId) {}
 
 public:
        virtual RawBuffer getBinary() const
@@ -64,6 +65,11 @@ public:
        virtual ~GObj()
        {
        }
+
+       CryptoBackend backendId() const { return m_backendId; }
+
+private:
+       const CryptoBackend m_backendId;
 };
 
 typedef std::unique_ptr<GObj> GObjUPtr;

diff --git a/src/manager/crypto/generic-backend/gstore.h b/src/manager/crypto/generic-backend/gstore.h
index 2e26bda..191dc99 100644 (file)
--- a/src/manager/crypto/generic-backend/gstore.h
+++ b/src/manager/crypto/generic-backend/gstore.h
@@ -70,6 +70,11 @@ protected:
        {
        }
 
+       template <typename T, typename ...Args>
+       GObjUPtr make(Args&&... args) {
+               return std::make_unique<T>(m_backendId, std::forward<Args>(args)...);
+       }
+
        CryptoBackend m_backendId;
 };
 

diff --git a/src/manager/crypto/sw-backend/obj.h b/src/manager/crypto/sw-backend/obj.h
index 094075e..a00a478 100644 (file)
--- a/src/manager/crypto/sw-backend/obj.h
+++ b/src/manager/crypto/sw-backend/obj.h
@@ -25,6 +25,7 @@
 #include <openssl/evp.h>
 
 #include <generic-backend/gobj.h>
+#include <generic-backend/gstore.h>
 #include <data-type.h>
 
 namespace CKM {
@@ -35,8 +36,8 @@ typedef std::shared_ptr<EVP_PKEY> EvpShPtr;
 
 class BData : public GObj {
 public:
-       BData(RawBuffer buffer, DataType keyType) :
-               m_raw(std::move(buffer)), m_type(keyType) {}
+       BData(CryptoBackend backendId, RawBuffer buffer, DataType keyType) :
+               GObj(backendId), m_raw(std::move(buffer)), m_type(keyType) {}
 
        RawBuffer getBinary() const override
        {
@@ -50,8 +51,8 @@ protected:
 
 class SKey : public BData {
 public:
-       SKey(RawBuffer buffer, DataType keyType) :
-               BData(std::move(buffer), keyType) {}
+       SKey(CryptoBackend backendId, RawBuffer buffer, DataType keyType) :
+               BData(backendId, std::move(buffer), keyType) {}
 
        RawBuffer encrypt(const CryptoAlgorithm &, const RawBuffer &) override;
        RawBuffer decrypt(const CryptoAlgorithm &, const RawBuffer &) override;
@@ -59,8 +60,8 @@ public:
 
 class AKey : public BData {
 public:
-       AKey(RawBuffer buffer, DataType dataType) :
-               BData(std::move(buffer), dataType) {}
+       AKey(CryptoBackend backendId, RawBuffer buffer, DataType dataType) :
+               BData(backendId, std::move(buffer), dataType) {}
 
        RawBuffer sign(const CryptoAlgorithm &alg, const RawBuffer &message) override;
        int verify(const CryptoAlgorithm &alg,
@@ -77,8 +78,8 @@ protected:
 
 class Cert : public AKey {
 public:
-       Cert(RawBuffer buffer, DataType dataType) :
-               AKey(std::move(buffer), dataType) {}
+       Cert(CryptoBackend backendId, RawBuffer buffer, DataType dataType) :
+               AKey(backendId, std::move(buffer), dataType) {}
 
 protected:
        EvpShPtr getEvpShPtr() override;

diff --git a/src/manager/crypto/sw-backend/store.cpp b/src/manager/crypto/sw-backend/store.cpp
index a75d078..86bd5c5 100644 (file)
--- a/src/manager/crypto/sw-backend/store.cpp
+++ b/src/manager/crypto/sw-backend/store.cpp
@@ -165,16 +165,16 @@ GObjUPtr Store::getObject(const Token &token, const Password &pass)
        RawBuffer data = unpack(token.data, pass);
 
        if (token.dataType.isKeyPrivate() || token.dataType.isKeyPublic())
-               return std::make_unique<AKey>(data, token.dataType);
+               return make<AKey>(std::move(data), token.dataType);
 
        if (token.dataType.isSKey())
-               return std::make_unique<SKey>(data, token.dataType);
+               return make<SKey>(std::move(data), token.dataType);
 
        if (token.dataType.isCertificate() || token.dataType.isChainCert())
-               return std::make_unique<Cert>(data, token.dataType);
+               return make<Cert>(std::move(data), token.dataType);
 
        if (token.dataType.isBinaryData())
-               return std::make_unique<BData>(data, token.dataType);
+               return make<BData>(std::move(data), token.dataType);
 
        ThrowErr(Exc::Crypto::DataTypeNotSupported,
                         "This type of data is not supported by openssl backend: ", token.dataType);

diff --git a/src/manager/crypto/tz-backend/obj.h b/src/manager/crypto/tz-backend/obj.h
index 32c6444..2d9bec8 100644 (file)
--- a/src/manager/crypto/tz-backend/obj.h
+++ b/src/manager/crypto/tz-backend/obj.h
@@ -59,9 +59,10 @@ private:
 
 class BData : public GObj {
 public:
-       explicit BData(RawBuffer buffer) : m_raw(std::move(buffer)) {}
+       explicit BData(CryptoBackend backendId, RawBuffer buffer) :
+               GObj(backendId), m_raw(std::move(buffer)) {}
 
-       virtual RawBuffer getBinary() const override
+       RawBuffer getBinary() const override
        {
                return m_raw;
        }
@@ -72,8 +73,8 @@ protected:
 
 class Key : public BData {
 public:
-       Key(int scheme, RawBuffer buffer, Pwd pwd, DataType dataType) :
-               BData(std::move(buffer)),
+       Key(CryptoBackend backendId, int scheme, RawBuffer buffer, Pwd pwd, DataType dataType) :
+               BData(backendId, std::move(buffer)),
                m_scheme(scheme),
                m_password(std::move(pwd)),
                m_type(dataType) {}
@@ -96,8 +97,8 @@ protected:
 
 class SKey : public Key {
 public:
-       SKey(int scheme, RawBuffer buffer, Pwd pwd, DataType dataType) :
-               Key(scheme, std::move(buffer), std::move(pwd), dataType) {}
+       SKey(CryptoBackend backendId, int scheme, RawBuffer buffer, Pwd pwd, DataType dataType) :
+               Key(backendId, scheme, std::move(buffer), std::move(pwd), dataType) {}
 
        virtual RawBuffer encrypt(const CryptoAlgorithm &, const RawBuffer &);
        virtual RawBuffer decrypt(const CryptoAlgorithm &, const RawBuffer &);
@@ -105,8 +106,8 @@ public:
 
 class AKey : public Key {
 public:
-       AKey(int scheme, RawBuffer buffer, Pwd pwd, DataType dataType) :
-               Key(scheme, std::move(buffer), std::move(pwd), dataType) {}
+       AKey(CryptoBackend backendId, int scheme, RawBuffer buffer, Pwd pwd, DataType dataType) :
+               Key(backendId, scheme, std::move(buffer), std::move(pwd), dataType) {}
 
        virtual RawBuffer sign(const CryptoAlgorithm &alg, const RawBuffer &message);
        virtual int verify(const CryptoAlgorithm &alg, const RawBuffer &message,
@@ -118,8 +119,8 @@ public:
 
 class Cert : public AKey {
 public:
-       Cert(int scheme, RawBuffer buffer, Pwd pwd, DataType dataType) :
-               AKey(scheme, std::move(buffer), std::move(pwd), dataType) {}
+       Cert(CryptoBackend backendId, int scheme, RawBuffer buffer, Pwd pwd, DataType dataType) :
+               AKey(backendId, scheme, std::move(buffer), std::move(pwd), dataType) {}
 
        virtual ~Cert() {}
 };

diff --git a/src/manager/crypto/tz-backend/store.cpp b/src/manager/crypto/tz-backend/store.cpp
index d5c348d..5035f74 100644 (file)
--- a/src/manager/crypto/tz-backend/store.cpp
+++ b/src/manager/crypto/tz-backend/store.cpp
@@ -109,17 +109,17 @@ GObjUPtr Store::getObject(const Token &token, const Password &pass)
        }
 
        if (token.dataType.isKeyPrivate() || token.dataType.isKeyPublic())
-               return std::make_unique<AKey>(scheme, id, Pwd(pass, iv, tag), token.dataType);
+               return make<AKey>(scheme, std::move(id), Pwd(pass, iv, tag), token.dataType);
 
        if (token.dataType.isSKey())
-               return std::make_unique<SKey>(scheme, id, Pwd(pass, iv, tag), token.dataType);
+               return make<SKey>(scheme, std::move(id), Pwd(pass, iv, tag), token.dataType);
 
        if (token.dataType.isCertificate() || token.dataType.isChainCert())
-               return std::make_unique<Cert>(scheme, id, Pwd(pass, iv, tag), token.dataType);
+               return make<Cert>(scheme, std::move(id), Pwd(pass, iv, tag), token.dataType);
 
        if (token.dataType.isBinaryData()) {
-               RawBuffer exported_data = Internals::getData(id, Pwd(pass, iv, tag));
-               return std::make_unique<BData>(std::move(exported_data));
+               RawBuffer exported_data = Internals::getData(std::move(id), Pwd(pass, iv, tag));
+               return make<BData>(std::move(exported_data));
        }
 
        ThrowErr(Exc::Crypto::DataTypeNotSupported,

diff --git a/unit-tests/test_generic-backend.cpp b/unit-tests/test_generic-backend.cpp
index 6bac2c1..f4ca579 100644 (file)
--- a/unit-tests/test_generic-backend.cpp
+++ b/unit-tests/test_generic-backend.cpp
@@ -26,7 +26,7 @@ namespace {
 
 class GObjTest : public Crypto::GObj {
 public:
-       GObjTest() : Crypto::GObj() {}
+       GObjTest() : Crypto::GObj(CryptoBackend::None) {}
 };
 
 struct TestException : public std::exception {};

diff --git a/unit-tests/test_sw-backend.cpp b/unit-tests/test_sw-backend.cpp
index 9ac80c3..fe7da08 100644 (file)
--- a/unit-tests/test_sw-backend.cpp
+++ b/unit-tests/test_sw-backend.cpp
@@ -126,7 +126,9 @@ EvpPtrPair generateEvpPair(AlgoType algo, int param)
 {
        class AKeyHelper : public AKey {
        private:
-               using AKey::AKey;
+               AKeyHelper(RawBuffer buffer, DataType dataType) :
+                       AKey(CryptoBackend::OpenSSL, std::move(buffer), dataType)
+               {}
 
        public:
                static EvpPtrPair getEvps(const GObjUPtrPair& objPair, DataType prvType, DataType pubType)
@@ -220,7 +222,9 @@ const RawBuffer X509_CERT = {
 };
 
 struct CertHelper : public Cert {
-       using Cert::Cert;
+       CertHelper(RawBuffer buffer, DataType dataType) :
+               Cert(CryptoBackend::OpenSSL, std::move(buffer), dataType) {}
+
        using Cert::getEvpShPtr;
 };
 
@@ -440,7 +444,7 @@ NEGATIVE_TEST_CASE(symmetricEncryptDecrypt)
                ca2.setParam(ParamName::ED_IV, iv);
 
                // short key
-               SKey shortKey(createRandom(128/8 - 1), DataType::KEY_AES);
+               SKey shortKey(CryptoBackend::OpenSSL, createRandom(128/8 - 1), DataType::KEY_AES);
                BOOST_REQUIRE_THROW(shortKey.encrypt(ca2, data), Exc::Crypto::InternalError);
 
                // proper encrypt
@@ -484,7 +488,7 @@ NEGATIVE_TEST_CASE(symmetricEncryptDecryptGcm)
        ca.setParam(ParamName::ED_IV, iv);
 
        // short key
-       SKey shortKey(createRandom(15), DataType::KEY_AES);
+       SKey shortKey(CryptoBackend::OpenSSL, createRandom(15), DataType::KEY_AES);
        BOOST_REQUIRE_THROW(shortKey.encrypt(ca, data), Exc::Crypto::InternalError);
 
        // wrong tag length
@@ -519,7 +523,7 @@ NEGATIVE_TEST_CASE(symmetricEncryptDecryptGcm)
        // wrong key
        auto wrongBuffer = key->getBinary();
        wrongBuffer[0] ^= 0x1;
-       SKey wrongKey(std::move(wrongBuffer), DataType::KEY_AES);
+       SKey wrongKey(CryptoBackend::OpenSSL, std::move(wrongBuffer), DataType::KEY_AES);
 
        BOOST_REQUIRE_THROW(wrongKey.decrypt(ca2, encrypted), Exc::Crypto::InputParam);
 
@@ -807,7 +811,7 @@ NEGATIVE_TEST_CASE(sign)
                            Exc::Crypto::InputParam);
 
        // Obj API with wrong key type
-       AKey wrongKey(createRandom(16), DataType::KEY_AES);
+       AKey wrongKey(CryptoBackend::OpenSSL, createRandom(16), DataType::KEY_AES);
        BOOST_REQUIRE_THROW(wrongKey.sign(signRsa, shortMsg), Exc::Crypto::InputParam);
 
        auto invalidSign = [&](const RawBuffer& msg,