Fix issue with SM4-CCM & GCM enable flag

Signed-off-by: Amit Kumar <amit1x.kumar@intel.com>

Author: amitk18x

e_qat.c

@@ -110,9 +110,12 @@
 # include "qat_sw_ec.h"
 # include "qat_sw_polling.h"
 # include "crypto_mb/cpu_features.h"
-# include "crypto_mb/sm4.h"
-# include "crypto_mb/sm4_gcm.h"
-# include "crypto_mb/sm4_ccm.h"
+# ifdef ENABLE_QAT_SW_SM4_GCM
+#  include "crypto_mb/sm4_gcm.h"
+# endif
+# ifdef ENABLE_QAT_SW_SM4_CCM
+#  include "crypto_mb/sm4_ccm.h"
+# endif
 #endif
 
 #ifdef QAT_SW_IPSEC

qat_evp.c

@@ -88,14 +88,17 @@
 # include "qat_sw_sm3.h"
 # ifndef QAT_BORINGSSL
 # include "qat_sw_sm4_cbc.h"
-# include "qat_sw_sm4_gcm.h"
-# include "qat_sw_sm4_ccm.h"
-# include "crypto_mb/sm4.h"
 # endif /* QAT_BORINGSSL */
 # include "crypto_mb/cpu_features.h"
 # ifndef QAT_BORINGSSL
-# include "crypto_mb/sm4_gcm.h"
-# include "crypto_mb/sm4_ccm.h"
+#  ifdef ENABLE_QAT_SW_SM4_GCM
+#   include "qat_sw_sm4_gcm.h"
+#   include "crypto_mb/sm4_gcm.h"
+#  endif
+#  ifdef ENABLE_QAT_SW_SM4_CCM
+#   include "qat_sw_sm4_ccm.h"
+#   include "crypto_mb/sm4_ccm.h"
+#  endif
 # endif /* QAT_BORINGSSL */
 #endif
 
@@ -856,7 +859,6 @@ const EVP_CIPHER *qat_create_sm4_cbc_cipher_meth(int nid, int keylen)
  *   Create a new EVP_CIPHER based on requested nid for qat_sw
  ******************************************************************************/
 #ifdef ENABLE_QAT_SW_SM4_GCM
-# if !defined(QAT_OPENSSL_3) && !defined(QAT_OPENSSL_PROVIDER)
 const EVP_CIPHER *qat_create_sm4_gcm_cipher_meth(int nid, int keylen)
 {
     EVP_CIPHER *c = NULL;
@@ -899,7 +901,6 @@ const EVP_CIPHER *qat_create_sm4_gcm_cipher_meth(int nid, int keylen)
     }
     return c;
 }
-# endif
 #endif /* ENABLE_QAT_SW_SM4_GCM */
 
 /******************************************************************************
@@ -914,13 +915,10 @@ const EVP_CIPHER *qat_create_sm4_gcm_cipher_meth(int nid, int keylen)
  *   Create a new EVP_CIPHER based on requested nid for qat_sw
  ******************************************************************************/
 #ifdef ENABLE_QAT_SW_SM4_CCM
-# if !defined(QAT_OPENSSL_3) && !defined(QAT_OPENSSL_PROVIDER)
 const EVP_CIPHER *qat_create_sm4_ccm_cipher_meth(int nid, int keylen)
 {
     EVP_CIPHER *c = NULL;
-#ifdef ENABLE_QAT_SW_SM4_CCM
     int res = 1;
-#endif
 
     if ((c = EVP_CIPHER_meth_new(nid, SM4_BLOCK_SIZE, keylen)) == NULL) {
         QATerr(QAT_F_QAT_CREATE_SM4_CCM_CIPHER_METH, QAT_R_SM4_MALLOC_FAILED);
@@ -960,7 +958,6 @@ const EVP_CIPHER *qat_create_sm4_ccm_cipher_meth(int nid, int keylen)
     }
     return c;
 }
-# endif
 #endif /* ENABLE_QAT_SW_SM4_CCM */
 
 void qat_create_ciphers(void)

qat_evp.h

@@ -130,7 +130,7 @@ int qat_sw_sm3_update(EVP_MD_CTX *ctx, const void *in, size_t len);
 int qat_sw_sm3_final(EVP_MD_CTX *ctx, unsigned char *md);
 # endif
 
-#ifdef ENABLE_QAT_SW_SM4_GCM
+# ifdef ENABLE_QAT_SW_SM4_GCM
 int qat_sw_sm4_gcm_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
         const unsigned char *iv, int enc);
 int qat_sw_sm4_gcm_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
@@ -139,14 +139,14 @@ int qat_sw_sm4_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 int qat_sw_sm4_gcm_cleanup(EVP_CIPHER_CTX *ctx);
 # endif
 
-#ifdef ENABLE_QAT_SW_SM4_CCM
+# ifdef ENABLE_QAT_SW_SM4_CCM
 int qat_sw_sm4_ccm_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
         const unsigned char *iv, int enc);
 int qat_sw_sm4_ccm_ctrl(EVP_CIPHER_CTX *ctx, int type, int p1, void *p2);
 int qat_sw_sm4_ccm_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
         const unsigned char *in, size_t len);
 int qat_sw_sm4_ccm_cleanup(EVP_CIPHER_CTX *ctx);
-#endif
+# endif
 
 int qat_pkey_methods(ENGINE *e, EVP_PKEY_METHOD **pmeth,
                      const int **nids, int nid);

qat_sw_freelist.c

@@ -1537,6 +1537,7 @@ sm4_cbc_cipher_op_data
     return item;
 }
 
+#ifdef ENABLE_QAT_SW_SM4_GCM
 mb_flist_sm4_gcm_encrypt *mb_flist_sm4_gcm_encrypt_create()
 {
     mb_flist_sm4_gcm_encrypt *freelist = NULL;
@@ -1722,7 +1723,9 @@ sm4_gcm_decrypt_op_data
 
     return item;
 }
+#endif
 
+#ifdef ENABLE_QAT_SW_SM4_CCM
 mb_flist_sm4_ccm_encrypt *mb_flist_sm4_ccm_encrypt_create()
 {
     mb_flist_sm4_ccm_encrypt *freelist = NULL;
@@ -1908,3 +1911,4 @@ sm4_ccm_decrypt_op_data
 
     return item;
 }
+#endif

qat_sw_freelist.h

@@ -148,6 +148,7 @@ typedef struct _mb_flist_sm4_cbc_cipher
     sm4_cbc_cipher_op_data *head;
 } mb_flist_sm4_cbc_cipher;
 
+# ifdef ENABLE_QAT_SW_SM4_GCM
 typedef struct _mb_flist_sm4_gcm_encrypt
 {
     pthread_mutex_t mb_flist_mutex;
@@ -159,7 +160,9 @@ typedef struct _mb_flist_sm4_gcm_decrypt
     pthread_mutex_t mb_flist_mutex;
     sm4_gcm_decrypt_op_data *head;
 } mb_flist_sm4_gcm_decrypt;
+# endif
 
+# ifdef ENABLE_QAT_SW_SM4_CCM
 typedef struct _mb_flist_sm4_ccm_encrypt
 {
     pthread_mutex_t mb_flist_mutex;
@@ -171,6 +174,7 @@ typedef struct _mb_flist_sm4_ccm_decrypt
     pthread_mutex_t mb_flist_mutex;
     sm4_ccm_decrypt_op_data *head;
 } mb_flist_sm4_ccm_decrypt;
+# endif
 
 typedef struct _mb_thread_data{
     pthread_t polling_thread;
@@ -242,17 +246,20 @@ typedef struct _mb_thread_data{
     mb_queue_sm4_cbc_cipher *sm4_cbc_cipher_queue;
     mb_queue_sm4_cbc_cipher *sm4_cbc_cipher_dec_queue;
     /* SM4_GCM */
+# ifdef ENABLE_QAT_SW_SM4_GCM
     mb_flist_sm4_gcm_encrypt *sm4_gcm_encrypt_freelist;
     mb_flist_sm4_gcm_decrypt *sm4_gcm_decrypt_freelist;
     mb_queue_sm4_gcm_encrypt *sm4_gcm_encrypt_queue;
     mb_queue_sm4_gcm_decrypt *sm4_gcm_decrypt_queue;
+# endif
 
     /* SM4_CCM */
+# ifdef ENABLE_QAT_SW_SM4_CCM
     mb_flist_sm4_ccm_encrypt *sm4_ccm_encrypt_freelist;
     mb_flist_sm4_ccm_decrypt *sm4_ccm_decrypt_freelist;
     mb_queue_sm4_ccm_encrypt *sm4_ccm_encrypt_queue;
     mb_queue_sm4_ccm_decrypt *sm4_ccm_decrypt_queue;
-
+# endif
 } mb_thread_data;
 
 mb_flist_rsa_priv * mb_flist_rsa_priv_create();
@@ -356,6 +363,7 @@ int mb_flist_sm4_cbc_cipher_push(mb_flist_sm4_cbc_cipher *freelist,
 sm4_cbc_cipher_op_data
     *mb_flist_sm4_cbc_cipher_pop(mb_flist_sm4_cbc_cipher *flist);
 
+# ifdef ENABLE_QAT_SW_SM4_GCM
 mb_flist_sm4_gcm_encrypt * mb_flist_sm4_gcm_encrypt_create();
 int mb_flist_sm4_gcm_encrypt_cleanup(mb_flist_sm4_gcm_encrypt *freelist);
 int mb_flist_sm4_gcm_encrypt_push(mb_flist_sm4_gcm_encrypt *freelist,
@@ -369,7 +377,9 @@ int mb_flist_sm4_gcm_decrypt_push(mb_flist_sm4_gcm_decrypt *freelist,
                                sm4_gcm_decrypt_op_data *item);
 sm4_gcm_decrypt_op_data
     *mb_flist_sm4_gcm_decrypt_pop(mb_flist_sm4_gcm_decrypt *flist);
+# endif
 
+# ifdef ENABLE_QAT_SW_SM4_CCM
 mb_flist_sm4_ccm_encrypt * mb_flist_sm4_ccm_encrypt_create();
 int mb_flist_sm4_ccm_encrypt_cleanup(mb_flist_sm4_ccm_encrypt *freelist);
 int mb_flist_sm4_ccm_encrypt_push(mb_flist_sm4_ccm_encrypt *freelist,
@@ -383,5 +393,5 @@ int mb_flist_sm4_ccm_decrypt_push(mb_flist_sm4_ccm_decrypt *freelist,
                                sm4_ccm_decrypt_op_data *item);
 sm4_ccm_decrypt_op_data
     *mb_flist_sm4_ccm_decrypt_pop(mb_flist_sm4_ccm_decrypt *flist);
-
+# endif
 #endif /* QAT_SW_FREELIST_H */

qat_sw_queue.c

@@ -3752,6 +3752,7 @@ int mb_queue_sm4_cbc_cipher_get_size(mb_queue_sm4_cbc_cipher *queue)
     return queue->num_items;
 }
 
+#ifdef ENABLE_QAT_SW_SM4_GCM
 mb_queue_sm4_gcm_encrypt * mb_queue_sm4_gcm_encrypt_create()
 {
     mb_queue_sm4_gcm_encrypt *queue = NULL;
@@ -4011,7 +4012,9 @@ int mb_queue_sm4_gcm_decrypt_get_size(mb_queue_sm4_gcm_decrypt *queue)
 
     return queue->num_items;
 }
+#endif
 
+#ifdef ENABLE_QAT_SW_SM4_CCM
 mb_queue_sm4_ccm_encrypt * mb_queue_sm4_ccm_encrypt_create()
 {
     mb_queue_sm4_ccm_encrypt *queue = NULL;
@@ -4271,3 +4274,4 @@ int mb_queue_sm4_ccm_decrypt_get_size(mb_queue_sm4_ccm_decrypt *queue)
 
     return queue->num_items;
 }
+#endif

qat_sw_queue.h

@@ -302,6 +302,7 @@ typedef struct _mb_queue_sm4_cbc_cipher
     int disabled;
 } mb_queue_sm4_cbc_cipher;
 
+# ifdef ENABLE_QAT_SW_SM4_GCM
 typedef struct _mb_queue_sm4_gcm_encrypt
 {
     pthread_mutex_t mb_queue_mutex;
@@ -319,7 +320,9 @@ typedef struct _mb_queue_sm4_gcm_decrypt
     int num_items;
     int disabled;
 } mb_queue_sm4_gcm_decrypt;
+# endif
 
+# ifdef ENABLE_QAT_SW_SM4_CCM
 typedef struct _mb_queue_sm4_ccm_encrypt
 {
     pthread_mutex_t mb_queue_mutex;
@@ -337,6 +340,7 @@ typedef struct _mb_queue_sm4_ccm_decrypt
     int num_items;
     int disabled;
 } mb_queue_sm4_ccm_decrypt;
+# endif
 
 mb_queue_rsa2k_priv * mb_queue_rsa2k_priv_create();
 int mb_queue_rsa2k_priv_disable(mb_queue_rsa2k_priv * queue);
@@ -592,6 +596,7 @@ sm4_cbc_cipher_op_data
     *mb_queue_sm4_cbc_cipher_dec_dequeue(mb_queue_sm4_cbc_cipher *queue);
 
 /* SM4_GCM encrypt */
+# ifdef ENABLE_QAT_SW_SM4_GCM
 mb_queue_sm4_gcm_encrypt * mb_queue_sm4_gcm_encrypt_create();
 int mb_queue_sm4_gcm_encrypt_disable(mb_queue_sm4_gcm_encrypt * queue);
 int mb_queue_sm4_gcm_encrypt_cleanup(mb_queue_sm4_gcm_encrypt * queue);
@@ -610,8 +615,10 @@ int mb_queue_sm4_gcm_decrypt_enqueue(mb_queue_sm4_gcm_decrypt *queue,
 sm4_gcm_decrypt_op_data
     *mb_queue_sm4_gcm_decrypt_dequeue(mb_queue_sm4_gcm_decrypt *queue);
 int mb_queue_sm4_gcm_decrypt_get_size(mb_queue_sm4_gcm_decrypt *queue);
+# endif /*  ENABLE_QAT_SW_SM4_GCM */
 
 /* SM4_CCM */
+# ifdef ENABLE_QAT_SW_SM4_CCM
 mb_queue_sm4_ccm_encrypt * mb_queue_sm4_ccm_encrypt_create();
 int mb_queue_sm4_ccm_encrypt_disable(mb_queue_sm4_ccm_encrypt * queue);
 int mb_queue_sm4_ccm_encrypt_cleanup(mb_queue_sm4_ccm_encrypt * queue);
@@ -629,5 +636,5 @@ int mb_queue_sm4_ccm_decrypt_enqueue(mb_queue_sm4_ccm_decrypt *queue,
 sm4_ccm_decrypt_op_data
     *mb_queue_sm4_ccm_decrypt_dequeue(mb_queue_sm4_ccm_decrypt *queue);
 int mb_queue_sm4_ccm_decrypt_get_size(mb_queue_sm4_ccm_decrypt *queue);
-
+# endif /* ENABLE_QAT_SW_SM4_CCM */
 #endif /* QAT_SW_QUEUE_H */

qat_sw_request.h

@@ -61,9 +61,12 @@
 /* Crypto_mb includes */
 #include "crypto_mb/sm3.h"
 #include "crypto_mb/sm4.h"
-# include "crypto_mb/sm4_gcm.h"
-# include "crypto_mb/sm4_ccm.h"
-
+# ifdef ENABLE_QAT_SW_SM4_GCM
+#  include "crypto_mb/sm4_gcm.h"
+# endif
+# ifdef ENABLE_QAT_SW_SM4_CCM
+#  include "crypto_mb/sm4_ccm.h"
+# endif
 #define X25519_KEYLEN 32
 #define MAX_KEYLEN  57
 #define IV_LEN 16
@@ -292,6 +295,7 @@ typedef struct _sm4_cbc_cipher_op_data {
     int in_enc;
 } sm4_cbc_cipher_op_data;
 
+# ifdef ENABLE_QAT_SW_SM4_GCM
 typedef struct _sm4_gcm_encrypt_op_data {
     struct _sm4_gcm_encrypt_op_data *next;
     struct _sm4_gcm_encrypt_op_data *prev;
@@ -329,7 +333,9 @@ typedef struct _sm4_gcm_decrypt_op_data {
     int sm4_taglen;
     int *sts;
 } sm4_gcm_decrypt_op_data;
+# endif
 
+# ifdef ENABLE_QAT_SW_SM4_CCM
 typedef struct _sm4_ccm_encrypt_op_data {
     struct _sm4_ccm_encrypt_op_data *next;
     struct _sm4_ccm_encrypt_op_data *prev;
@@ -369,5 +375,5 @@ typedef struct _sm4_ccm_decrypt_op_data {
     int sm4_msglen;
     int *sts;
 } sm4_ccm_decrypt_op_data;
-
+# endif /* ENABLE_QAT_SW_SM4_CCM */
 #endif /* QAT_SW_REQUEST_H */

qat_sw_sm4_ccm.c

@@ -66,12 +66,12 @@
 #include "qat_sw_sm4_ccm.h"
 
 /* Crypto_mb includes */
-#include "crypto_mb/sm4.h"
-#include "crypto_mb/sm4_ccm.h"
+#ifdef ENABLE_QAT_SW_SM4_CCM
+ #include "crypto_mb/sm4_ccm.h"
+#endif
 #include "crypto_mb/cpu_features.h"
 
 #ifdef ENABLE_QAT_SW_SM4_CCM
- #if !defined(QAT_OPENSSL_3) && !defined(QAT_OPENSSL_PROVIDER)
 
 # define GET_SW_CIPHER(ctx) \
     sm4_cipher_sw_impl(EVP_CIPHER_CTX_nid((ctx)))
@@ -1138,5 +1138,4 @@ int qat_sw_sm4_ccm_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
     }
     return ret_val;
 }
- #endif
 #endif

qat_sw_sm4_gcm.c

@@ -65,12 +65,13 @@
 #include "qat_sw_sm4_gcm.h"
 
 /* Crypto_mb includes */
-#include "crypto_mb/sm4.h"
-#include "crypto_mb/sm4_gcm.h"
+
+#ifdef ENABLE_QAT_SW_SM4_GCM
+ #include "crypto_mb/sm4_gcm.h"
+#endif
 #include "crypto_mb/cpu_features.h"
 
 #ifdef ENABLE_QAT_SW_SM4_GCM
-# if !defined(QAT_OPENSSL_3) && !defined(QAT_OPENSSL_PROVIDER)
 
 # define GET_SW_CIPHER(ctx) \
     sm4_cipher_sw_impl(EVP_CIPHER_CTX_nid((ctx)))
@@ -241,11 +242,9 @@ void process_mb_sm4_gcm_encrypt_reqs(mb_thread_data *tlv)
     STOP_RDTSC(&sm4_gcm_cycles_encrypt_execute, 1, "[SM4_GCM:encrypt_execute]");
     DEBUG("Processed SM4_GCM encrypt Request\n");
 }
-# endif
 #endif /* ENABLE_QAT_SW_SM4_GCM */
 
 #ifdef ENABLE_QAT_SW_SM4_GCM
-# if !defined(QAT_OPENSSL_3) && !defined(QAT_OPENSSL_PROVIDER)
 int qat_sw_sm4_gcm_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
         const unsigned char *iv, int enc)
 {
@@ -1234,5 +1233,4 @@ int qat_sw_sm4_gcm_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 err:
     return sts;
 }
-# endif
 #endif /* ENABLE_QAT_SW_SM4_GCM */