Update the dasync engine to add a pipeline cipher

Implement aes128-cbc as a pipeline capable cipher in the dasync engine.
As dasync is just a dummy engine, it actually just performs the parallel
encrypts/decrypts in serial.

Reviewed-by: Tim Hudson <tjh@openssl.org>

crypto/evp/evp_lib.c

@@ -261,6 +261,16 @@ void *EVP_CIPHER_CTX_cipher_data(const EVP_CIPHER_CTX *ctx)
     return ctx->cipher_data;
 }
 
+void *EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data)
+{
+    void *old_cipher_data;
+
+    old_cipher_data = ctx->cipher_data;
+    ctx->cipher_data = cipher_data;
+
+    return old_cipher_data;
+}
+
 int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
 {
     return cipher->iv_len;

doc/crypto/EVP_CIPHER_meth_new.pod

@@ -207,6 +207,9 @@ I could use some help explaining this one!
 
 =back
 
+EVP_CIPHER_meth_set_impl_ctx_size() sets the size of the EVP_CIPHER's
+implementation context so that it can be automatically allocated.
+
 EVP_CIPHER_meth_set_init() sets the cipher init function for
 B<cipher>.
 The cipher init function is called by EVP_CipherInit(),

engines/e_dasync.c

@@ -60,6 +60,8 @@
 #include <openssl/async.h>
 #include <openssl/bn.h>
 #include <openssl/crypto.h>
+#include <openssl/ssl.h>
+#include <openssl/modes.h>
 
 #if (defined(OPENSSL_SYS_UNIX) || defined(OPENSSL_SYS_CYGWIN)) && defined(OPENSSL_THREADS)
 # undef ASYNC_POSIX
@@ -176,6 +178,70 @@ static RSA_METHOD dasync_rsa_method = {
 };
 
 
+/* AES */
+
+static int dasync_aes128_cbc_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg,
+                                  void *ptr);
+
+static int dasync_aes128_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+                                  const unsigned char *iv, int enc);
+
+static int dasync_aes128_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                                    const unsigned char *in, size_t inl);
+
+static int dasync_aes128_cbc_cleanup(EVP_CIPHER_CTX *ctx);
+
+struct aes_128_cbc_pipeline_ctx {
+    void *inner_cipher_data;
+    unsigned char dummy[256];
+    unsigned int numpipes;
+    unsigned char **inbufs;
+    unsigned char **outbufs;
+    size_t *lens;
+};
+
+static EVP_CIPHER *_hidden_aes_128_cbc = NULL;
+static const EVP_CIPHER *dasync_aes_128_cbc(void)
+{
+    if (_hidden_aes_128_cbc == NULL)
+        _hidden_aes_128_cbc = EVP_CIPHER_meth_new(NID_aes_128_cbc,
+                                                  16 /* block size */,
+                                                  16 /* key len */);
+    if (_hidden_aes_128_cbc == NULL
+            || !EVP_CIPHER_meth_set_iv_length(_hidden_aes_128_cbc,16)
+            || !EVP_CIPHER_meth_set_flags(_hidden_aes_128_cbc,
+                                          EVP_CIPH_FLAG_DEFAULT_ASN1
+                                          | EVP_CIPH_CBC_MODE
+                                          | EVP_CIPH_FLAG_PIPELINE)
+            || !EVP_CIPHER_meth_set_init(_hidden_aes_128_cbc,
+                                         dasync_aes128_init_key)
+            || !EVP_CIPHER_meth_set_do_cipher(_hidden_aes_128_cbc,
+                                              dasync_aes128_cbc_cipher)
+            || !EVP_CIPHER_meth_set_cleanup(_hidden_aes_128_cbc,
+                                            dasync_aes128_cbc_cleanup)
+            || !EVP_CIPHER_meth_set_ctrl(_hidden_aes_128_cbc,
+                                         dasync_aes128_cbc_ctrl)
+            || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_aes_128_cbc,
+                                sizeof(struct aes_128_cbc_pipeline_ctx))) {
+        EVP_CIPHER_meth_free(_hidden_aes_128_cbc);
+        _hidden_aes_128_cbc = NULL;
+    }
+    return _hidden_aes_128_cbc;
+}
+
+
+static int dasync_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
+                                   const int **nids, int nid);
+
+#  ifdef NID_aes_128_cbc_hmac_sha256
+static int dasync_cipher_nids[] = {
+    NID_aes_128_cbc,
+    0
+};
+#  else
+static int dasync_cipher_nids[] = { 0 };
+#endif
+
 static int bind_dasync(ENGINE *e)
 {
     /* Ensure the dasync error handling is set up */
@@ -185,6 +251,7 @@ static int bind_dasync(ENGINE *e)
         || !ENGINE_set_name(e, engine_dasync_name)
         || !ENGINE_set_RSA(e, &dasync_rsa_method)
         || !ENGINE_set_digests(e, dasync_digests)
+        || !ENGINE_set_ciphers(e, dasync_ciphers)
         || !ENGINE_set_destroy_function(e, dasync_destroy)
         || !ENGINE_set_init_function(e, dasync_init)
         || !ENGINE_set_finish_function(e, dasync_finish)) {
@@ -271,6 +338,29 @@ static int dasync_digests(ENGINE *e, const EVP_MD **digest,
     return ok;
 }
 
+static int dasync_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
+                                   const int **nids, int nid)
+{
+    int ok = 1;
+    if (!cipher) {
+        /* We are returning a list of supported nids */
+        *nids = dasync_cipher_nids;
+        return (sizeof(dasync_cipher_nids) -
+                1) / sizeof(dasync_cipher_nids[0]);
+    }
+    /* We are being asked for a specific cipher */
+    switch (nid) {
+    case NID_aes_128_cbc:
+        *cipher = dasync_aes_128_cbc();
+        break;
+    default:
+        ok = 0;
+        *cipher = NULL;
+        break;
+    }
+    return ok;
+}
+
 static void wait_cleanup(ASYNC_WAIT_CTX *ctx, const void *key,
                          OSSL_ASYNC_FD readfd, void *pvwritefd)
 {
@@ -431,3 +521,103 @@ static int dasync_rsa_finish(RSA *rsa)
 {
     return RSA_PKCS1_OpenSSL()->finish(rsa);
 }
+
+/*
+ * AES128 Implementation
+ */
+
+static int dasync_aes128_cbc_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg,
+                                  void *ptr)
+{
+    struct aes_128_cbc_pipeline_ctx *pipe_ctx =
+        (struct aes_128_cbc_pipeline_ctx *)EVP_CIPHER_CTX_cipher_data(ctx);
+
+    if (pipe_ctx == NULL)
+        return 0;
+
+    switch (type) {
+        case EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS:
+            pipe_ctx->numpipes = arg;
+            pipe_ctx->outbufs = (unsigned char **)ptr;
+            break;
+
+        case EVP_CTRL_SET_PIPELINE_INPUT_BUFS:
+            pipe_ctx->numpipes = arg;
+            pipe_ctx->inbufs = (unsigned char **)ptr;
+            break;
+
+        case EVP_CTRL_SET_PIPELINE_INPUT_LENS:
+            pipe_ctx->numpipes = arg;
+            pipe_ctx->lens = (size_t *)ptr;
+            break;
+
+        default:
+            return 0;
+    }
+
+    return 1;
+}
+
+static int dasync_aes128_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+                             const unsigned char *iv, int enc)
+{
+    int ret;
+    struct aes_128_cbc_pipeline_ctx *pipe_ctx =
+        (struct aes_128_cbc_pipeline_ctx *)EVP_CIPHER_CTX_cipher_data(ctx);
+
+    if (pipe_ctx->inner_cipher_data == NULL
+            && EVP_CIPHER_impl_ctx_size(EVP_aes_128_cbc()) != 0) {
+        pipe_ctx->inner_cipher_data = OPENSSL_zalloc(
+            EVP_CIPHER_impl_ctx_size(EVP_aes_128_cbc()));
+        if (pipe_ctx->inner_cipher_data == NULL) {
+            DASYNCerr(DASYNC_F_DASYNC_AES128_INIT_KEY,
+                        ERR_R_MALLOC_FAILURE);
+            return 0;
+        }
+    }
+
+    pipe_ctx->numpipes = 0;
+
+    EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx->inner_cipher_data);
+    ret = EVP_CIPHER_meth_get_init(EVP_aes_128_cbc())(ctx, key, iv, enc);
+    EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx);
+
+    return ret;
+}
+
+static int dasync_aes128_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                               const unsigned char *in, size_t inl)
+{
+    int ret = 1;
+    unsigned int i, pipes;
+    struct aes_128_cbc_pipeline_ctx *pipe_ctx =
+        (struct aes_128_cbc_pipeline_ctx *)EVP_CIPHER_CTX_cipher_data(ctx);
+
+    pipes = pipe_ctx->numpipes;
+    EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx->inner_cipher_data);
+    if (pipes == 0) {
+        ret = EVP_CIPHER_meth_get_do_cipher(EVP_aes_128_cbc())
+                                           (ctx, out, in, inl);
+    } else {
+        for (i = 0; i < pipes; i++) {
+            ret = ret && EVP_CIPHER_meth_get_do_cipher(EVP_aes_128_cbc())
+                                   (ctx, pipe_ctx->outbufs[i],
+                                    pipe_ctx->inbufs[i],
+                                    pipe_ctx->lens[i]);
+        }
+        pipe_ctx->numpipes = 0;
+    }
+    EVP_CIPHER_CTX_set_cipher_data(ctx, pipe_ctx);
+    return ret;
+}
+
+static int dasync_aes128_cbc_cleanup(EVP_CIPHER_CTX *ctx)
+{
+    struct aes_128_cbc_pipeline_ctx *pipe_ctx =
+        (struct aes_128_cbc_pipeline_ctx *)EVP_CIPHER_CTX_cipher_data(ctx);
+
+    OPENSSL_clear_free(pipe_ctx->inner_cipher_data,
+                       EVP_CIPHER_impl_ctx_size(EVP_aes_128_cbc()));
+
+    return 1;
+}

engines/e_dasync_err.c

@@ -52,7 +52,8 @@
  *
  */
 
-/* NOTE: this file was auto generated by the mkerr.pl script: any changes
+/*
+ * NOTE: this file was auto generated by the mkerr.pl script: any changes
  * made to it will be overwritten when the script next updates this file,
  * only reason strings will be preserved.
  */
@@ -64,83 +65,79 @@
 /* BEGIN ERROR CODES */
 #ifndef OPENSSL_NO_ERR
 
-#define ERR_FUNC(func) ERR_PACK(0,func,0)
+# define ERR_FUNC(func) ERR_PACK(0,func,0)
-#define ERR_REASON(reason) ERR_PACK(0,0,reason)
+# define ERR_REASON(reason) ERR_PACK(0,0,reason)
 
-static ERR_STRING_DATA DASYNC_str_functs[]=
+static ERR_STRING_DATA DASYNC_str_functs[] = {
-	{
+    {ERR_FUNC(DASYNC_F_BIND_DASYNC), "BIND_DASYNC"},
-{ERR_FUNC(DASYNC_F_BIND_DASYNC),	"BIND_DASYNC"},
+    {ERR_FUNC(DASYNC_F_CIPHER_AES_128_CBC_CODE), "CIPHER_AES_128_CBC_CODE"},
-{ERR_FUNC(DASYNC_F_CIPHER_AES_128_CBC_CODE),	"CIPHER_AES_128_CBC_CODE"},
+    {ERR_FUNC(DASYNC_F_DASYNC_AES128_INIT_KEY), "DASYNC_AES128_INIT_KEY"},
-{ERR_FUNC(DASYNC_F_DASYNC_BN_MOD_EXP),	"DASYNC_BN_MOD_EXP"},
+    {ERR_FUNC(DASYNC_F_DASYNC_BN_MOD_EXP), "DASYNC_BN_MOD_EXP"},
-{ERR_FUNC(DASYNC_F_DASYNC_MOD_EXP),	"DASYNC_MOD_EXP"},
+    {ERR_FUNC(DASYNC_F_DASYNC_MOD_EXP), "DASYNC_MOD_EXP"},
-{ERR_FUNC(DASYNC_F_DASYNC_PRIVATE_DECRYPT),	"DASYNC_PRIVATE_DECRYPT"},
+    {ERR_FUNC(DASYNC_F_DASYNC_PRIVATE_DECRYPT), "DASYNC_PRIVATE_DECRYPT"},
-{ERR_FUNC(DASYNC_F_DASYNC_PRIVATE_ENCRYPT),	"DASYNC_PRIVATE_ENCRYPT"},
+    {ERR_FUNC(DASYNC_F_DASYNC_PRIVATE_ENCRYPT), "DASYNC_PRIVATE_ENCRYPT"},
-{ERR_FUNC(DASYNC_F_DASYNC_PUBLIC_DECRYPT),	"DASYNC_PUBLIC_DECRYPT"},
+    {ERR_FUNC(DASYNC_F_DASYNC_PUBLIC_DECRYPT), "DASYNC_PUBLIC_DECRYPT"},
-{ERR_FUNC(DASYNC_F_DASYNC_PUBLIC_ENCRYPT),	"DASYNC_PUBLIC_ENCRYPT"},
+    {ERR_FUNC(DASYNC_F_DASYNC_PUBLIC_ENCRYPT), "DASYNC_PUBLIC_ENCRYPT"},
-{0,NULL}
+    {0, NULL}
-	};
+};
 
-static ERR_STRING_DATA DASYNC_str_reasons[]=
+static ERR_STRING_DATA DASYNC_str_reasons[] = {
-	{
+    {ERR_REASON(DASYNC_R_INIT_FAILED), "init failed"},
-{ERR_REASON(DASYNC_R_INIT_FAILED)        ,"init failed"},
+    {ERR_REASON(DASYNC_R_LENGTH_NOT_BLOCK_ALIGNED),
-{ERR_REASON(DASYNC_R_LENGTH_NOT_BLOCK_ALIGNED),"length not block aligned"},
+     "length not block aligned"},
-{ERR_REASON(DASYNC_R_UNKNOWN_FAULT)      ,"unknown fault"},
+    {ERR_REASON(DASYNC_R_UNKNOWN_FAULT), "unknown fault"},
-{0,NULL}
+    {0, NULL}
-	};
+};
 
 #endif
 
 #ifdef DASYNC_LIB_NAME
-static ERR_STRING_DATA DASYNC_lib_name[]=
+static ERR_STRING_DATA DASYNC_lib_name[] = {
-        {
+    {0, DASYNC_LIB_NAME},
-{0	,DASYNC_LIB_NAME},
+    {0, NULL}
-{0,NULL}
+};
-	};
 #endif
 
-
+static int DASYNC_lib_error_code = 0;
-static int DASYNC_lib_error_code=0;
+static int DASYNC_error_init = 1;
-static int DASYNC_error_init=1;
 
 static void ERR_load_DASYNC_strings(void)
-	{
+{
     if (DASYNC_lib_error_code == 0)
-		DASYNC_lib_error_code=ERR_get_next_error_library();
+        DASYNC_lib_error_code = ERR_get_next_error_library();
 
-	if (DASYNC_error_init)
+    if (DASYNC_error_init) {
-		{
+        DASYNC_error_init = 0;
-		DASYNC_error_init=0;
 #ifndef OPENSSL_NO_ERR
-		ERR_load_strings(DASYNC_lib_error_code,DASYNC_str_functs);
+        ERR_load_strings(DASYNC_lib_error_code, DASYNC_str_functs);
-		ERR_load_strings(DASYNC_lib_error_code,DASYNC_str_reasons);
+        ERR_load_strings(DASYNC_lib_error_code, DASYNC_str_reasons);
 #endif
 
 #ifdef DASYNC_LIB_NAME
-		DASYNC_lib_name->error = ERR_PACK(DASYNC_lib_error_code,0,0);
+        DASYNC_lib_name->error = ERR_PACK(DASYNC_lib_error_code, 0, 0);
-		ERR_load_strings(0,DASYNC_lib_name);
+        ERR_load_strings(0, DASYNC_lib_name);
 #endif
     }
-	}
+}
 
 static void ERR_unload_DASYNC_strings(void)
-	{
+{
-	if (DASYNC_error_init == 0)
+    if (DASYNC_error_init == 0) {
-		{
 #ifndef OPENSSL_NO_ERR
-		ERR_unload_strings(DASYNC_lib_error_code,DASYNC_str_functs);
+        ERR_unload_strings(DASYNC_lib_error_code, DASYNC_str_functs);
-		ERR_unload_strings(DASYNC_lib_error_code,DASYNC_str_reasons);
+        ERR_unload_strings(DASYNC_lib_error_code, DASYNC_str_reasons);
 #endif
 
 #ifdef DASYNC_LIB_NAME
-		ERR_unload_strings(0,DASYNC_lib_name);
+        ERR_unload_strings(0, DASYNC_lib_name);
 #endif
-		DASYNC_error_init=1;
+        DASYNC_error_init = 1;
-		}
     }
+}
 
 static void ERR_DASYNC_error(int function, int reason, char *file, int line)
-	{
+{
     if (DASYNC_lib_error_code == 0)
-		DASYNC_lib_error_code=ERR_get_next_error_library();
+        DASYNC_lib_error_code = ERR_get_next_error_library();
-	ERR_PUT_error(DASYNC_lib_error_code,function,reason,file,line);
+    ERR_PUT_error(DASYNC_lib_error_code, function, reason, file, line);
-	}
+}

engines/e_dasync_err.h

@@ -60,7 +60,8 @@ extern "C" {
 #endif
 
 /* BEGIN ERROR CODES */
-/* The following lines are auto generated by the script mkerr.pl. Any changes
+/*
+ * The following lines are auto generated by the script mkerr.pl. Any changes
  * made after this point may be overwritten when the script is next run.
  */
 static void ERR_load_DASYNC_strings(void);
@@ -71,19 +72,20 @@ static void ERR_DASYNC_error(int function, int reason, char *file, int line);
 /* Error codes for the DASYNC functions. */
 
 /* Function codes. */
-#define DASYNC_F_BIND_DASYNC				 107
+# define DASYNC_F_BIND_DASYNC                             107
-#define DASYNC_F_CIPHER_AES_128_CBC_CODE		 100
+# define DASYNC_F_CIPHER_AES_128_CBC_CODE                 100
-#define DASYNC_F_DASYNC_BN_MOD_EXP			 101
+# define DASYNC_F_DASYNC_AES128_INIT_KEY                  108
-#define DASYNC_F_DASYNC_MOD_EXP				 102
+# define DASYNC_F_DASYNC_BN_MOD_EXP                       101
-#define DASYNC_F_DASYNC_PRIVATE_DECRYPT			 103
+# define DASYNC_F_DASYNC_MOD_EXP                          102
-#define DASYNC_F_DASYNC_PRIVATE_ENCRYPT			 104
+# define DASYNC_F_DASYNC_PRIVATE_DECRYPT                  103
-#define DASYNC_F_DASYNC_PUBLIC_DECRYPT			 105
+# define DASYNC_F_DASYNC_PRIVATE_ENCRYPT                  104
-#define DASYNC_F_DASYNC_PUBLIC_ENCRYPT			 106
+# define DASYNC_F_DASYNC_PUBLIC_DECRYPT                   105
+# define DASYNC_F_DASYNC_PUBLIC_ENCRYPT                   106
 
 /* Reason codes. */
-#define DASYNC_R_INIT_FAILED				 102
+# define DASYNC_R_INIT_FAILED                             102
-#define DASYNC_R_LENGTH_NOT_BLOCK_ALIGNED		 100
+# define DASYNC_R_LENGTH_NOT_BLOCK_ALIGNED                100
-#define DASYNC_R_UNKNOWN_FAULT				 101
+# define DASYNC_R_UNKNOWN_FAULT                           101
 
 #ifdef  __cplusplus
 }

include/openssl/evp.h

@@ -496,6 +496,7 @@ int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in);
 void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx);
 void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data);
 void *EVP_CIPHER_CTX_cipher_data(const EVP_CIPHER_CTX *ctx);
+void *EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data);
 # define EVP_CIPHER_CTX_type(c)         EVP_CIPHER_type(EVP_CIPHER_CTX_cipher(c))
 # if OPENSSL_API_COMPAT < 0x10100000L
 #  define EVP_CIPHER_CTX_flags(c)       EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(c))

util/libcrypto.num

@@ -4041,3 +4041,4 @@ lh_doall                                3906	1_1_0	EXIST::FUNCTION:
 PKCS8_pkey_get0_attrs                   3907	1_1_0	EXIST::FUNCTION:
 PKCS8_pkey_add1_attr_by_NID             3908	1_1_0	EXIST::FUNCTION:
 ASYNC_is_capable                        3909	1_1_0	EXIST::FUNCTION:
+EVP_CIPHER_CTX_set_cipher_data          3910	1_1_0	EXIST::FUNCTION: