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>

diff --git a/crypto/evp/evp_lib.c b/crypto/evp/evp_lib.c
index a1636284c05de8d066f875898774ca03ed4b4c84..7135381a21a0898c35f740f62d0b906d16ca208e 100644 (file)
--- a/crypto/evp/evp_lib.c
+++ b/crypto/evp/evp_lib.c
@@ -261,6 +261,16 @@ void *EVP_CIPHER_CTX_cipher_data(const EVP_CIPHER_CTX *ctx)
     return ctx->cipher_data;
 }
 
     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;
 int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
 {
     return cipher->iv_len;

diff --git a/doc/crypto/EVP_CIPHER_meth_new.pod b/doc/crypto/EVP_CIPHER_meth_new.pod
index 75b2d614154cb0d24c6f1371b87bb6d18c1e9ebb..30596b5e0a72bc6ca374e66c9595bd124a8753fd 100644 (file)
--- a/doc/crypto/EVP_CIPHER_meth_new.pod
+++ b/doc/crypto/EVP_CIPHER_meth_new.pod
@@ -207,6 +207,9 @@ I could use some help explaining this one!
 
 =back
 
 
 =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(),
 EVP_CIPHER_meth_set_init() sets the cipher init function for
 B<cipher>.
 The cipher init function is called by EVP_CipherInit(),

diff --git a/engines/e_dasync.c b/engines/e_dasync.c
index 25dd233769dc21e451b886c4ee1f0008a83765f4..018175c9e481651fce31ad212f899ff0d166bddf 100644 (file)
--- a/engines/e_dasync.c
+++ b/engines/e_dasync.c
@@ -60,6 +60,8 @@
 #include <openssl/async.h>
 #include <openssl/bn.h>
 #include <openssl/crypto.h>
 #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
 
 #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 */
 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_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)) {
         || !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;
 }
 
     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)
 {
 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);
 }
 {
     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;
+}

diff --git a/engines/e_dasync_err.c b/engines/e_dasync_err.c
index 33d4a90e1a49b67613830c9168be37045f87f40e..570a54ed37f44759bcc105361bf67b210ac6d790 100644 (file)
--- a/engines/e_dasync_err.c
+++ b/engines/e_dasync_err.c
@@ -6,7 +6,7 @@
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  * 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
  *
  * 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.
  */
  * 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
 
 /* 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
 
 #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
 
 #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)
 
 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
 #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
 #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
 #endif

-               }
-       }
+    }
+}

 
 static void ERR_unload_DASYNC_strings(void)
 
 static void ERR_unload_DASYNC_strings(void)

-       {
-       if (DASYNC_error_init == 0)
-               {
+{
+    if (DASYNC_error_init == 0) {

 #ifndef OPENSSL_NO_ERR
 #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
 #endif
 
 #ifdef DASYNC_LIB_NAME

-               ERR_unload_strings(0,DASYNC_lib_name);
+        ERR_unload_strings(0, DASYNC_lib_name);

 #endif
 #endif

-               DASYNC_error_init=1;
-               }
-       }
+        DASYNC_error_init = 1;
+    }
+}

 
 static void ERR_DASYNC_error(int function, int reason, char *file, int line)
 
 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);
+}

diff --git a/engines/e_dasync_err.h b/engines/e_dasync_err.h
index a34a0993922a92fdb99a108e2c5079943a833247..af5241e572f2cf2fa3849b7602418edc44f1982c 100644 (file)
--- a/engines/e_dasync_err.h
+++ b/engines/e_dasync_err.h
@@ -60,7 +60,8 @@ extern "C" {
 #endif
 
 /* BEGIN ERROR CODES */
 #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);
  * 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. */
 /* 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. */
 
 /* 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
 }
 
 #ifdef  __cplusplus
 }

diff --git a/include/openssl/evp.h b/include/openssl/evp.h
index aecb871e6bb531c84582bcde92d54ae28c79bdb6..55ed438d9714f2186eea87ad764d0e76e848c26d 100644 (file)
--- a/include/openssl/evp.h
+++ b/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_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))
 # 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))

diff --git a/util/libcrypto.num b/util/libcrypto.num
index 2b77bd5b4ce0c89460964ad066c60d11d980f25b..0cf2abeca8800f44b360e0be670c6f98deed3e09 100644 (file)
--- a/util/libcrypto.num
+++ b/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:
 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: