Commit 98ee7543 authored by Matt Caswell's avatar Matt Caswell
Browse files

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: default avatarTim Hudson <tjh@openssl.org>
parent 4e392522

crypto/evp/evp_lib.c

+10 −0
Original line number Diff line number Diff line
@@ -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

+3 −0
Original line number Diff line number Diff line
@@ -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

+190 −0
Original line number Diff line number Diff line
@@ -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

+56 −59
Original line number Diff line number Diff line
@@ -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.

 */
@@ -67,10 +68,10 @@ 
# 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[]=

	{

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"},
@@ -80,10 +81,10 @@ static ERR_STRING_DATA DASYNC_str_functs[]= 
    {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_LENGTH_NOT_BLOCK_ALIGNED),"length not block aligned"},

    {ERR_REASON(DASYNC_R_LENGTH_NOT_BLOCK_ALIGNED),

     "length not block aligned"},

    {ERR_REASON(DASYNC_R_UNKNOWN_FAULT), "unknown fault"},

    {0, NULL}

};
@@ -91,14 +92,12 @@ static ERR_STRING_DATA DASYNC_str_reasons[]= 
#endif



#ifdef DASYNC_LIB_NAME

static ERR_STRING_DATA DASYNC_lib_name[]=

        {

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;
@@ -107,8 +106,7 @@ static void ERR_load_DASYNC_strings(void) 
    if (DASYNC_lib_error_code == 0)

        DASYNC_lib_error_code = ERR_get_next_error_library();



	if (DASYNC_error_init)

		{

    if (DASYNC_error_init) {

        DASYNC_error_init = 0;

#ifndef OPENSSL_NO_ERR

        ERR_load_strings(DASYNC_lib_error_code, DASYNC_str_functs);
@@ -124,8 +122,7 @@ static void ERR_load_DASYNC_strings(void) 


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);

engines/e_dasync_err.h

+14 −12
Original line number Diff line number Diff line
@@ -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);
@@ -73,6 +74,7 @@ static void ERR_DASYNC_error(int function, int reason, char *file, int line); 
/* Function codes. */

# 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