Deduplicate sw backend keyPair creation

Change-Id: Iff7d579d02e54e841140ba419aa6fffd19086dd3

diff --git a/src/manager/crypto/sw-backend/internals.cpp b/src/manager/crypto/sw-backend/internals.cpp
index 493d586..a2a9054 100644 (file)
--- a/src/manager/crypto/sw-backend/internals.cpp
+++ b/src/manager/crypto/sw-backend/internals.cpp
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2015 - 2020 Samsung Electronics Co., Ltd All Rights Reserved
+ *  Copyright (c) 2015-2020 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.
@@ -380,84 +380,83 @@ int getRsaPadding(const RSAPaddingAlgorithm padAlgo)
        }
 }
 
-DataPair createKeyPairRSA(const int size)
+EvpPkeyCtxUPtr newCtx(int id)
 {
-       EvpPkeyUPtr pkey;
-
-       // validateParams<IsAsymGeneration> should prevent it
-       assert(size == 1024 || size == 2048 || size == 4096);
+       if (auto ctx = EVP_PKEY_CTX_new_id(id, NULL))
+               return EvpPkeyCtxUPtr(ctx, EVP_PKEY_CTX_free);
 
-       EvpPkeyCtxUPtr ctx(EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL), EVP_PKEY_CTX_free);
-
-       if (!ctx)
-               ThrowErr(Exc::Crypto::InternalError,
-                                "Error in EVP_PKEY_CTX_new_id function !!");
+       ThrowErr(Exc::Crypto::InternalError, "Error in EVP_PKEY_CTX_new_id function");
+}
 
-       OPENSSL_ERROR_HANDLE(EVP_PKEY_keygen_init(ctx.get()));
+EvpPkeyCtxUPtr newCtx(EVP_PKEY *pkey)
+{
+       if (auto ctx = EVP_PKEY_CTX_new(pkey, NULL))
+               return EvpPkeyCtxUPtr(ctx, EVP_PKEY_CTX_free);
 
-       OPENSSL_ERROR_HANDLE(EVP_PKEY_CTX_set_rsa_keygen_bits(ctx.get(), size));
+       ThrowErr(Exc::Crypto::InternalError, "Error in EVP_PKEY_CTX_new function");
+}
 
+DataPair keyPair(const EvpPkeyCtxUPtr &ctx, KeyType prv, KeyType pub)
+{
        EVP_PKEY *pkeyTmp = NULL;
 
        OPENSSL_ERROR_HANDLE(EVP_PKEY_keygen(ctx.get(), &pkeyTmp));
 
-       pkey = EvpPkeyUPtr(pkeyTmp, EVP_PKEY_free);
+       auto pkey = EvpPkeyUPtr(pkeyTmp, EVP_PKEY_free);
 
        return std::make_pair<Data, Data>(
-       {DataType(KeyType::KEY_RSA_PRIVATE), i2d(i2d_PrivateKey_bio, pkey.get())},
-       {DataType(KeyType::KEY_RSA_PUBLIC), i2d(i2d_PUBKEY_bio, pkey.get())});
+                       {DataType(prv), i2d(i2d_PrivateKey_bio, pkey.get())},
+                       {DataType(pub), i2d(i2d_PUBKEY_bio, pkey.get())});
 }
 
-DataPair createKeyPairDSA(const int size)
+DataPair createKeyPairRSA(const int size)
 {
-       EvpPkeyUPtr pkey;
-       EvpPkeyUPtr pparam;
-
        // validateParams<IsAsymGeneration> should prevent it
-       assert(size == 1024 || size == 2048 || size == 3072 || size == 4096);
+       assert(size == 1024 || size == 2048 || size == 4096);
 
-       /* Create the context for generating the parameters */
-       EvpPkeyCtxUPtr pctx(EVP_PKEY_CTX_new_id(EVP_PKEY_DSA, NULL), EVP_PKEY_CTX_free);
+       auto ctx = newCtx(EVP_PKEY_RSA);
 
-       if (!pctx)
-               ThrowErr(Exc::Crypto::InternalError, "Error in EVP_PKEY_CTX_new_id function");
+       OPENSSL_ERROR_HANDLE(EVP_PKEY_keygen_init(ctx.get()));
 
-       OPENSSL_ERROR_HANDLE(EVP_PKEY_paramgen_init(pctx.get()));
+       OPENSSL_ERROR_HANDLE(EVP_PKEY_CTX_set_rsa_keygen_bits(ctx.get(), size));
 
-       OPENSSL_ERROR_HANDLE(EVP_PKEY_CTX_set_dsa_paramgen_bits(pctx.get(), size));
+       return keyPair(ctx, KeyType::KEY_RSA_PRIVATE, KeyType::KEY_RSA_PUBLIC);
+}
 
+DataPair paramgenKeyPair(const EvpPkeyCtxUPtr &pctx, KeyType prv, KeyType pub)
+{
        /* Generate parameters */
        EVP_PKEY *pparamTmp = NULL;
-
        OPENSSL_ERROR_HANDLE(EVP_PKEY_paramgen(pctx.get(), &pparamTmp));
 
-       pparam = EvpPkeyUPtr(pparamTmp, EVP_PKEY_free);
+       auto pparam = EvpPkeyUPtr(pparamTmp, EVP_PKEY_free);
 
        // Start to generate key
-       EvpPkeyCtxUPtr kctx(EVP_PKEY_CTX_new(pparam.get(), NULL), EVP_PKEY_CTX_free);
-
-       if (!kctx)
-               ThrowErr(Exc::Crypto::InternalError, "Error in EVP_PKEY_CTX_new function");
+       auto kctx = newCtx(pparam.get());
 
        OPENSSL_ERROR_HANDLE(EVP_PKEY_keygen_init(kctx.get()));
 
-       /* Generate the key */
-       EVP_PKEY *pkeyTmp = NULL;
+       return keyPair(kctx, prv, pub);
+}
 
-       OPENSSL_ERROR_HANDLE(EVP_PKEY_keygen(kctx.get(), &pkeyTmp));
+DataPair createKeyPairDSA(const int size)
+{
+       // validateParams<IsAsymGeneration> should prevent it
+       assert(size == 1024 || size == 2048 || size == 3072 || size == 4096);
 
-       pkey = EvpPkeyUPtr(pkeyTmp, EVP_PKEY_free);
+       /* Create the context for generating the parameters */
+       auto pctx = newCtx(EVP_PKEY_DSA);
 
-       return std::make_pair<Data, Data>(
-       {DataType(KeyType::KEY_DSA_PRIVATE), i2d(i2d_PrivateKey_bio, pkey.get())},
-       {DataType(KeyType::KEY_DSA_PUBLIC), i2d(i2d_PUBKEY_bio, pkey.get())});
+       OPENSSL_ERROR_HANDLE(EVP_PKEY_paramgen_init(pctx.get()));
+
+       OPENSSL_ERROR_HANDLE(EVP_PKEY_CTX_set_dsa_paramgen_bits(pctx.get(), size));
+
+       return paramgenKeyPair(pctx, KeyType::KEY_DSA_PRIVATE, KeyType::KEY_DSA_PUBLIC);
 }
 
 DataPair createKeyPairECDSA(ElipticCurve type)
 {
        int ecCurve;
-       EvpPkeyUPtr pkey;
-       EvpPkeyUPtr pparam;
 
        switch (type) {
        default:
@@ -476,40 +475,13 @@ DataPair createKeyPairECDSA(ElipticCurve type)
        }
 
        /* Create the context for generating the parameters */
-       EvpPkeyCtxUPtr pctx(EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL), EVP_PKEY_CTX_free);
-
-       if (!pctx)
-               ThrowErr(Exc::Crypto::InternalError, "Error in EVP_PKEY_CTX_new_id function");
+       auto pctx = newCtx(EVP_PKEY_EC);
 
        OPENSSL_ERROR_HANDLE(EVP_PKEY_paramgen_init(pctx.get()));
 
        OPENSSL_ERROR_HANDLE(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx.get(), ecCurve));
 
-       /* Generate parameters */
-       EVP_PKEY *pparamTmp = NULL;
-
-       OPENSSL_ERROR_HANDLE(EVP_PKEY_paramgen(pctx.get(), &pparamTmp));
-
-       pparam = EvpPkeyUPtr(pparamTmp, EVP_PKEY_free);
-
-       // Start to generate key
-       EvpPkeyCtxUPtr kctx(EVP_PKEY_CTX_new(pparam.get(), NULL), EVP_PKEY_CTX_free);
-
-       if (!kctx)
-               ThrowErr(Exc::Crypto::InternalError, "Error in EVP_PKEY_CTX_new function");
-
-       OPENSSL_ERROR_HANDLE(EVP_PKEY_keygen_init(kctx.get()));
-
-       /* Generate the key */
-       EVP_PKEY *pkeyTmp = NULL;
-
-       OPENSSL_ERROR_HANDLE(EVP_PKEY_keygen(kctx.get(), &pkeyTmp));
-
-       pkey = EvpPkeyUPtr(pkeyTmp, EVP_PKEY_free);
-
-       return std::make_pair<Data, Data>(
-       {DataType(KeyType::KEY_ECDSA_PRIVATE), i2d(i2d_PrivateKey_bio, pkey.get())},
-       {DataType(KeyType::KEY_ECDSA_PUBLIC), i2d(i2d_PUBKEY_bio, pkey.get())});
+       return paramgenKeyPair(pctx, KeyType::KEY_ECDSA_PRIVATE, KeyType::KEY_ECDSA_PUBLIC);
 }
 
 Data createKeyAES(const int sizeBits)
@@ -534,10 +506,7 @@ RawBuffer signMessage(EVP_PKEY *privKey,
        if (EVP_PKEY_type(EVP_PKEY_id(privKey)) != EVP_PKEY_RSA)
                ThrowErr(Exc::Crypto::InputParam, "Only RSA supports no hash option");
 
-       EvpPkeyCtxUPtr pctx(EVP_PKEY_CTX_new(privKey, NULL), EVP_PKEY_CTX_free);
-
-       if (!pctx.get())
-               ThrowErr(Exc::Crypto::InternalError, "Error in EVP_PKEY_CTX_new function");
+       auto pctx = newCtx(privKey);
 
        OPENSSL_ERROR_HANDLE(EVP_PKEY_sign_init(pctx.get()));
 
@@ -609,10 +578,7 @@ int verifyMessage(EVP_PKEY *pubKey,
        if (EVP_PKEY_type(EVP_PKEY_id(pubKey)) != EVP_PKEY_RSA)
                ThrowErr(Exc::Crypto::InputParam, "Only RSA supports no hash option");
 
-       EvpPkeyCtxUPtr pctx(EVP_PKEY_CTX_new(pubKey, NULL), EVP_PKEY_CTX_free);
-
-       if (!pctx.get())
-               ThrowErr(Exc::Crypto::InternalError, "Error in EVP_PKEY_CTX_new function");
+       auto pctx = newCtx(pubKey);
 
        OPENSSL_ERROR_HANDLE(EVP_PKEY_verify_init(pctx.get()));