Commit 2db6bf6f authored by Richard Levitte's avatar Richard Levitte
Browse files

Make the definition of EVP_MD opaque 



This moves the definition to crypto/include/internal/evp_int.h and
defines all the necessary method creators, destructors, writers and
accessors.  The name standard for the latter is inspired from the
corresponding functions to manipulate UI methods.

Reviewed-by: default avatarRich Salz <rsalz@openssl.org>
parent 6e59a892

crypto/evp/evp_lib.c

+123 −0
Original line number Diff line number Diff line
@@ -60,6 +60,7 @@ 
#include "internal/cryptlib.h"

#include <openssl/evp.h>

#include <openssl/objects.h>

#include "internal/evp_int.h"

#include "evp_locl.h"



int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
@@ -310,6 +311,128 @@ unsigned long EVP_MD_flags(const EVP_MD *md) 
    return md->flags;

}



EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type)

{

    EVP_MD *md = (EVP_MD *)OPENSSL_zalloc(sizeof(EVP_MD));

    if (md != NULL) {

        md->type = md_type;

        md->pkey_type = pkey_type;

    }

    return md;

}

EVP_MD *EVP_MD_meth_dup(const EVP_MD *md)

{

    EVP_MD *to = EVP_MD_meth_new(md->type, md->pkey_type);

    if (md != NULL)

        memcpy(to, md, sizeof(*to));

    return to;

}

void EVP_MD_meth_free(EVP_MD *md)

{

    OPENSSL_free(md);

}

int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize)

{

    md->block_size = blocksize;

    return 1;

}

int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize)

{

    md->md_size = resultsize;

    return 1;

}

int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize)

{

    md->ctx_size = datasize;

    return 1;

}

int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags)

{

    md->flags = flags;

    return 1;

}

int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx))

{

    md->init = init;

    return 1;

}

int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx,

                                                     const void *data,

                                                     size_t count))

{

    md->update = update;

    return 1;

}

int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx,

                                                   unsigned char *md))

{

    md->final = final;

    return 1;

}

int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to,

                                                 const EVP_MD_CTX *from))

{

    md->copy = copy;

    return 1;

}

int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx))

{

    md->cleanup = cleanup;

    return 1;

}

int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd,

                                                 int p1, void *p2))

{

    md->md_ctrl = ctrl;

    return 1;

}



int EVP_MD_meth_get_input_blocksize(const EVP_MD *md)

{

    return md->block_size;

}

int EVP_MD_meth_get_result_size(const EVP_MD *md)

{

    return md->md_size;

}

int EVP_MD_meth_get_app_datasize(const EVP_MD *md)

{

    return md->ctx_size;

}

unsigned long EVP_MD_meth_get_flags(const EVP_MD *md)

{

    return md->block_size;

}

int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx)

{

    return md->init;

}

int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx,

                                                const void *data,

                                                size_t count)

{

    return md->update;

}

int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx,

                                               unsigned char *md)

{

    return md->final;

}

int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to,

                                              const EVP_MD_CTX *from)

{

    return md->copy;

}

int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx)

{

    return md->cleanup;

}

int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd,

                                              int p1, void *p2)

{

    return md->md_ctrl;

}



const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx)

{

    if (!ctx)

crypto/evp/evp_locl.h

+3 −0
Original line number Diff line number Diff line
@@ -71,9 +71,12 @@ struct evp_md_ctx_st { 
    int (*update) (EVP_MD_CTX *ctx, const void *data, size_t count);

} /* EVP_MD_CTX */ ;



# define M_EVP_MD_size(e)                ((e)->md_size)

# define M_EVP_MD_block_size(e)          ((e)->block_size)

# define M_EVP_MD_CTX_set_flags(ctx,flgs) ((ctx)->flags|=(flgs))

# define M_EVP_MD_CTX_clear_flags(ctx,flgs) ((ctx)->flags&=~(flgs))

# define M_EVP_MD_CTX_test_flags(ctx,flgs) ((ctx)->flags&(flgs))

# define M_EVP_MD_type(e)                        ((e)->type)

# define M_EVP_MD_CTX_type(e)            M_EVP_MD_type(M_EVP_MD_CTX_md(e))

# define M_EVP_MD_CTX_md(e)                      ((e)->digest)

crypto/include/internal/evp_int.h

+17 −0
Original line number Diff line number Diff line
@@ -129,3 +129,20 @@ extern const EVP_PKEY_METHOD dsa_pkey_meth; 
extern const EVP_PKEY_METHOD ec_pkey_meth;

extern const EVP_PKEY_METHOD hmac_pkey_meth;

extern const EVP_PKEY_METHOD rsa_pkey_meth;



struct evp_md_st {

    int type;

    int pkey_type;

    int md_size;

    unsigned long flags;

    int (*init) (EVP_MD_CTX *ctx);

    int (*update) (EVP_MD_CTX *ctx, const void *data, size_t count);

    int (*final) (EVP_MD_CTX *ctx, unsigned char *md);

    int (*copy) (EVP_MD_CTX *to, const EVP_MD_CTX *from);

    int (*cleanup) (EVP_MD_CTX *ctx);

    int block_size;

    int ctx_size;               /* how big does the ctx->md_data need to be */

    /* control function */

    int (*md_ctrl) (EVP_MD_CTX *ctx, int cmd, int p1, void *p2);

} /* EVP_MD */ ;

include/openssl/evp.h

+35 −15
Original line number Diff line number Diff line
@@ -148,21 +148,41 @@ struct evp_pkey_st { 
# define EVP_PKEY_MO_DECRYPT     0x0008



# ifndef EVP_MD

struct evp_md_st {

    int type;

    int pkey_type;

    int md_size;

    unsigned long flags;

    int (*init) (EVP_MD_CTX *ctx);

    int (*update) (EVP_MD_CTX *ctx, const void *data, size_t count);

    int (*final) (EVP_MD_CTX *ctx, unsigned char *md);

    int (*copy) (EVP_MD_CTX *to, const EVP_MD_CTX *from);

    int (*cleanup) (EVP_MD_CTX *ctx);

    int block_size;

    int ctx_size;               /* how big does the ctx->md_data need to be */

    /* control function */

    int (*md_ctrl) (EVP_MD_CTX *ctx, int cmd, int p1, void *p2);

} /* EVP_MD */ ;

EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type);

EVP_MD *EVP_MD_meth_dup(const EVP_MD *md);

void EVP_MD_meth_free(EVP_MD *md);



int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize);

int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize);

int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize);

int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags);

int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx));

int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx,

                                                     const void *data,

                                                     size_t count));

int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx,

                                                   unsigned char *md));

int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to,

                                                 const EVP_MD_CTX *from));

int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx));

int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd,

                                                 int p1, void *p2));



int EVP_MD_meth_get_input_blocksize(const EVP_MD *md);

int EVP_MD_meth_get_result_size(const EVP_MD *md);

int EVP_MD_meth_get_app_datasize(const EVP_MD *md);

unsigned long EVP_MD_meth_get_flags(const EVP_MD *md);

int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx);

int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx,

                                                const void *data,

                                                size_t count);

int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx,

                                               unsigned char *md);

int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to,

                                              const EVP_MD_CTX *from);

int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx);

int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd,

                                              int p1, void *p2);



/* digest can only handle a single block */

#  define EVP_MD_FLAG_ONESHOT     0x0001