Update the dasync engine to add a pipeline cipher
authorMatt Caswell <matt@openssl.org>
Tue, 22 Sep 2015 10:11:24 +0000 (11:11 +0100)
committerMatt Caswell <matt@openssl.org>
Mon, 7 Mar 2016 21:26:04 +0000 (21:26 +0000)
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
doc/crypto/EVP_CIPHER_meth_new.pod
engines/e_dasync.c
engines/e_dasync_err.c
engines/e_dasync_err.h
include/openssl/evp.h
util/libcrypto.num

index a163628..7135381 100644 (file)
@@ -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;
index 75b2d61..30596b5 100644 (file)
@@ -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(),
index 25dd233..018175c 100644 (file)
@@ -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;
+}
index 33d4a90..570a54e 100644 (file)
@@ -6,7 +6,7 @@
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer. 
+ *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ -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.
  */
 /* BEGIN ERROR CODES */
 #ifndef OPENSSL_NO_ERR
 
-#define ERR_FUNC(func) ERR_PACK(0,func,0)
-#define ERR_REASON(reason) ERR_PACK(0,0,reason)
-
-static ERR_STRING_DATA DASYNC_str_functs[]=
-       {
-{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_DASYNC_BN_MOD_EXP), "DASYNC_BN_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_ENCRYPT),    "DASYNC_PRIVATE_ENCRYPT"},
-{ERR_FUNC(DASYNC_F_DASYNC_PUBLIC_DECRYPT),     "DASYNC_PUBLIC_DECRYPT"},
-{ERR_FUNC(DASYNC_F_DASYNC_PUBLIC_ENCRYPT),     "DASYNC_PUBLIC_ENCRYPT"},
-{0,NULL}
-       };
-
-static ERR_STRING_DATA DASYNC_str_reasons[]=
-       {
-{ERR_REASON(DASYNC_R_INIT_FAILED)        ,"init failed"},
-{ERR_REASON(DASYNC_R_LENGTH_NOT_BLOCK_ALIGNED),"length not block aligned"},
-{ERR_REASON(DASYNC_R_UNKNOWN_FAULT)      ,"unknown fault"},
-{0,NULL}
-       };
+# define ERR_FUNC(func) ERR_PACK(0,func,0)
+# define ERR_REASON(reason) ERR_PACK(0,0,reason)
+
+static ERR_STRING_DATA DASYNC_str_functs[] = {
+    {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_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_MOD_EXP), "DASYNC_MOD_EXP"},
+    {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_PUBLIC_DECRYPT), "DASYNC_PUBLIC_DECRYPT"},
+    {ERR_FUNC(DASYNC_F_DASYNC_PUBLIC_ENCRYPT), "DASYNC_PUBLIC_ENCRYPT"},
+    {0, NULL}
+};
+
+static ERR_STRING_DATA DASYNC_str_reasons[] = {
+    {ERR_REASON(DASYNC_R_INIT_FAILED), "init failed"},
+    {ERR_REASON(DASYNC_R_LENGTH_NOT_BLOCK_ALIGNED),
+     "length not block aligned"},
+    {ERR_REASON(DASYNC_R_UNKNOWN_FAULT), "unknown fault"},
+    {0, NULL}
+};
 
 #endif
 
 #ifdef DASYNC_LIB_NAME
-static ERR_STRING_DATA DASYNC_lib_name[]=
-        {
-{0     ,DASYNC_LIB_NAME},
-{0,NULL}
-       };
+static ERR_STRING_DATA DASYNC_lib_name[] = {
+    {0, DASYNC_LIB_NAME},
+    {0, NULL}
+};
 #endif
 
-
-static int DASYNC_lib_error_code=0;
-static int DASYNC_error_init=1;
+static int DASYNC_lib_error_code = 0;
+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();
+{
+    if (DASYNC_lib_error_code == 0)
+        DASYNC_lib_error_code = ERR_get_next_error_library();
 
-       if (DASYNC_error_init)
-               {
-               DASYNC_error_init=0;
+    if (DASYNC_error_init) {
+        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_reasons);
+        ERR_load_strings(DASYNC_lib_error_code, DASYNC_str_functs);
+        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);
-               ERR_load_strings(0,DASYNC_lib_name);
+        DASYNC_lib_name->error = ERR_PACK(DASYNC_lib_error_code, 0, 0);
+        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_reasons);
+        ERR_unload_strings(DASYNC_lib_error_code, DASYNC_str_functs);
+        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();
-       ERR_PUT_error(DASYNC_lib_error_code,function,reason,file,line);
-       }
+{
+    if (DASYNC_lib_error_code == 0)
+        DASYNC_lib_error_code = ERR_get_next_error_library();
+    ERR_PUT_error(DASYNC_lib_error_code, function, reason, file, line);
+}
index a34a099..af5241e 100644 (file)
@@ -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_CIPHER_AES_128_CBC_CODE                100
-#define DASYNC_F_DASYNC_BN_MOD_EXP                      101
-#define DASYNC_F_DASYNC_MOD_EXP                                 102
-#define DASYNC_F_DASYNC_PRIVATE_DECRYPT                         103
-#define DASYNC_F_DASYNC_PRIVATE_ENCRYPT                         104
-#define DASYNC_F_DASYNC_PUBLIC_DECRYPT                  105
-#define DASYNC_F_DASYNC_PUBLIC_ENCRYPT                  106
+# define DASYNC_F_BIND_DASYNC                             107
+# define DASYNC_F_CIPHER_AES_128_CBC_CODE                 100
+# define DASYNC_F_DASYNC_AES128_INIT_KEY                  108
+# define DASYNC_F_DASYNC_BN_MOD_EXP                       101
+# define DASYNC_F_DASYNC_MOD_EXP                          102
+# define DASYNC_F_DASYNC_PRIVATE_DECRYPT                  103
+# define DASYNC_F_DASYNC_PRIVATE_ENCRYPT                  104
+# 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_LENGTH_NOT_BLOCK_ALIGNED               100
-#define DASYNC_R_UNKNOWN_FAULT                          101
+# define DASYNC_R_INIT_FAILED                             102
+# define DASYNC_R_LENGTH_NOT_BLOCK_ALIGNED                100
+# define DASYNC_R_UNKNOWN_FAULT                           101
 
 #ifdef  __cplusplus
 }
index aecb871..55ed438 100644 (file)
@@ -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))
index 2b77bd5..0cf2abe 100644 (file)
@@ -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: