EVP_DecryptInit() should call EVP_CipherInit() not EVP_CipherInit_ex().

[openssl.git] / crypto / evp / evp_enc.c

diff --git a/crypto/evp/evp_enc.c b/crypto/evp/evp_enc.c
index d67f0cda431901fa07d2e74abb79146159cc60e7..ccfcc7e1b15ba815daad602608af989f1e979540 100644 (file)
--- a/crypto/evp/evp_enc.c
+++ b/crypto/evp/evp_enc.c
@@ -60,10 +60,9 @@
 #include "cryptlib.h"
 #include <openssl/evp.h>
 #include <openssl/err.h>
 #include "cryptlib.h"
 #include <openssl/evp.h>
 #include <openssl/err.h>

+#include <openssl/engine.h>

 #include "evp_locl.h"
 
 #include "evp_locl.h"
 

-#include <assert.h>
-

 const char *EVP_version="EVP" OPENSSL_VERSION_PTEXT;
 
 void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx)
 const char *EVP_version="EVP" OPENSSL_VERSION_PTEXT;
 
 void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx)


@@ -72,33 +71,99 @@ void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx)
        /* ctx->cipher=NULL; */
        }
 
        /* ctx->cipher=NULL; */
        }
 

+

 int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,

-            unsigned char *key, unsigned char *iv, int enc)
+            const unsigned char *key, const unsigned char *iv, int enc)

        {
        {

-       if(enc && (enc != -1)) enc = 1;
+       if (cipher)
+               EVP_CIPHER_CTX_init(ctx);
+       return EVP_CipherInit_ex(ctx,cipher,NULL,key,iv,enc);
+       }
+
+int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
+            const unsigned char *key, const unsigned char *iv, int enc)
+       {
+       if (enc == -1)
+               enc = ctx->encrypt;
+       else
+               {
+               if (enc)
+                       enc = 1;
+               ctx->encrypt = enc;
+               }
+       /* Whether it's nice or not, "Inits" can be used on "Final"'d contexts
+        * so this context may already have an ENGINE! Try to avoid releasing
+        * the previous handle, re-querying for an ENGINE, and having a
+        * reinitialisation, when it may all be unecessary. */
+       if (ctx->engine && ctx->cipher && (!cipher ||
+                       (cipher && (cipher->nid == ctx->cipher->nid))))
+               goto skip_to_init;

        if (cipher)
                {
        if (cipher)
                {

-               if(ctx->cipher_data)
-                       OPENSSL_free(ctx->cipher_data);
+               /* Ensure a context left lying around from last time is cleared
+                * (the previous check attempted to avoid this if the same
+                * ENGINE and EVP_CIPHER could be used). */
+               EVP_CIPHER_CTX_cleanup(ctx);
+
+               /* Restore encrypt field: it is zeroed by cleanup */
+               ctx->encrypt = enc;
+               if(impl)
+                       {
+                       if (!ENGINE_init(impl))
+                               {
+                               EVPerr(EVP_F_EVP_CIPHERINIT, EVP_R_INITIALIZATION_ERROR);
+                               return 0;
+                               }
+                       }
+               else
+                       /* Ask if an ENGINE is reserved for this job */
+                       impl = ENGINE_get_cipher_engine(cipher->nid);
+               if(impl)
+                       {
+                       /* There's an ENGINE for this job ... (apparently) */
+                       const EVP_CIPHER *c = ENGINE_get_cipher(impl, cipher->nid);
+                       if(!c)
+                               {
+                               /* One positive side-effect of US's export
+                                * control history, is that we should at least
+                                * be able to avoid using US mispellings of
+                                * "initialisation"? */
+                               EVPerr(EVP_F_EVP_CIPHERINIT, EVP_R_INITIALIZATION_ERROR);
+                               return 0;
+                               }
+                       /* We'll use the ENGINE's private cipher definition */
+                       cipher = c;
+                       /* Store the ENGINE functional reference so we know
+                        * 'cipher' came from an ENGINE and we need to release
+                        * it when done. */
+                       ctx->engine = impl;
+                       }
+               else
+                       ctx->engine = NULL;
+

                ctx->cipher=cipher;
                ctx->cipher_data=OPENSSL_malloc(ctx->cipher->ctx_size);
                ctx->key_len = cipher->key_len;
                ctx->flags = 0;
                ctx->cipher=cipher;
                ctx->cipher_data=OPENSSL_malloc(ctx->cipher->ctx_size);
                ctx->key_len = cipher->key_len;
                ctx->flags = 0;

-               if(ctx->cipher->flags & EVP_CIPH_CTRL_INIT) {
-                       if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) {
+               if(ctx->cipher->flags & EVP_CIPH_CTRL_INIT)
+                       {
+                       if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL))
+                               {

                                EVPerr(EVP_F_EVP_CIPHERINIT, EVP_R_INITIALIZATION_ERROR);
                                return 0;
                                EVPerr(EVP_F_EVP_CIPHERINIT, EVP_R_INITIALIZATION_ERROR);
                                return 0;

+                               }

                        }
                }
                        }
                }

-       } else if(!ctx->cipher) {
+       else if(!ctx->cipher)
+               {

                EVPerr(EVP_F_EVP_CIPHERINIT, EVP_R_NO_CIPHER_SET);
                return 0;
                EVPerr(EVP_F_EVP_CIPHERINIT, EVP_R_NO_CIPHER_SET);
                return 0;

-       }
-
+               }
+skip_to_init:

        /* we assume block size is a power of 2 in *cryptUpdate */
        /* we assume block size is a power of 2 in *cryptUpdate */

-       assert(ctx->cipher->block_size == 1
-              || ctx->cipher->block_size == 8
-              || ctx->cipher->block_size == 16);
+       OPENSSL_assert(ctx->cipher->block_size == 1
+           || ctx->cipher->block_size == 8
+           || ctx->cipher->block_size == 16);

 
        if(!(EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_CUSTOM_IV)) {
                switch(EVP_CIPHER_CTX_mode(ctx)) {
 
        if(!(EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_CUSTOM_IV)) {
                switch(EVP_CIPHER_CTX_mode(ctx)) {


@@ -114,6 +179,7 @@ int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 
                        case EVP_CIPH_CBC_MODE:
 
 
                        case EVP_CIPH_CBC_MODE:
 

+                       OPENSSL_assert(EVP_CIPHER_CTX_iv_length(ctx) <= sizeof ctx->iv);

                        if(iv) memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
                        memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));
                        break;
                        if(iv) memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
                        memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));
                        break;


@@ -127,7 +193,6 @@ int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
        if(key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) {
                if(!ctx->cipher->init(ctx,key,iv,enc)) return 0;
        }
        if(key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) {
                if(!ctx->cipher->init(ctx,key,iv,enc)) return 0;
        }

-       if(enc != -1) ctx->encrypt=enc;

        ctx->buf_len=0;
        ctx->final_used=0;
        ctx->block_mask=ctx->cipher->block_size-1;
        ctx->buf_len=0;
        ctx->final_used=0;
        ctx->block_mask=ctx->cipher->block_size-1;


@@ -135,37 +200,57 @@ int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
        }
 
 int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
        }
 
 int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,

-            unsigned char *in, int inl)
+            const unsigned char *in, int inl)

        {
        if (ctx->encrypt)
                return EVP_EncryptUpdate(ctx,out,outl,in,inl);
        else    return EVP_DecryptUpdate(ctx,out,outl,in,inl);
        }
 
        {
        if (ctx->encrypt)
                return EVP_EncryptUpdate(ctx,out,outl,in,inl);
        else    return EVP_DecryptUpdate(ctx,out,outl,in,inl);
        }
 

+int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
+       {
+       if (ctx->encrypt)
+               return EVP_EncryptFinal_ex(ctx,out,outl);
+       else    return EVP_DecryptFinal_ex(ctx,out,outl);
+       }
+

 int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
        {
        if (ctx->encrypt)
                return EVP_EncryptFinal(ctx,out,outl);
 int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
        {
        if (ctx->encrypt)
                return EVP_EncryptFinal(ctx,out,outl);

-       else    return(EVP_DecryptFinal(ctx,out,outl));
+       else    return EVP_DecryptFinal(ctx,out,outl);

        }
 
 int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
        }
 
 int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,

-            unsigned char *key, unsigned char *iv)
+            const unsigned char *key, const unsigned char *iv)

        {
        return EVP_CipherInit(ctx, cipher, key, iv, 1);
        }
 
        {
        return EVP_CipherInit(ctx, cipher, key, iv, 1);
        }
 

+int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx,const EVP_CIPHER *cipher, ENGINE *impl,
+               const unsigned char *key, const unsigned char *iv)
+       {
+       return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 1);
+       }
+

 int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,

-            unsigned char *key, unsigned char *iv)
+            const unsigned char *key, const unsigned char *iv)

        {
        return EVP_CipherInit(ctx, cipher, key, iv, 0);
        }
 
        {
        return EVP_CipherInit(ctx, cipher, key, iv, 0);
        }
 

+int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
+            const unsigned char *key, const unsigned char *iv)
+       {
+       return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 0);
+       }
+

 int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
 int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,

-            unsigned char *in, int inl)
+            const unsigned char *in, int inl)

        {
        int i,j,bl;
 
        {
        int i,j,bl;
 

+       OPENSSL_assert(inl > 0);

        if(ctx->buf_len == 0 && (inl&(ctx->block_mask)) == 0)
                {
                if(ctx->cipher->do_cipher(ctx,out,in,inl))
        if(ctx->buf_len == 0 && (inl&(ctx->block_mask)) == 0)
                {
                if(ctx->cipher->do_cipher(ctx,out,in,inl))


@@ -181,6 +266,7 @@ int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
                }
        i=ctx->buf_len;
        bl=ctx->cipher->block_size;
                }
        i=ctx->buf_len;
        bl=ctx->cipher->block_size;

+       OPENSSL_assert(bl <= sizeof ctx->buf);

        if (i != 0)
                {
                if (i+inl < bl)
        if (i != 0)
                {
                if (i+inl < bl)


@@ -219,9 +305,17 @@ int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
 
 int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
        {
 
 int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
        {

-       int i,n,b,bl;
+       int ret;
+       ret = EVP_EncryptFinal_ex(ctx, out, outl);
+       return ret;
+       }
+
+int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
+       {
+       int i,n,b,bl,ret;

 
        b=ctx->cipher->block_size;
 
        b=ctx->cipher->block_size;

+       OPENSSL_assert(b <= sizeof ctx->buf);

        if (b == 1)
                {
                *outl=0;
        if (b == 1)
                {
                *outl=0;


@@ -238,18 +332,23 @@ int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
                *outl = 0;
                return 1;
                }
                *outl = 0;
                return 1;
                }

+

        n=b-bl;
        for (i=bl; i<b; i++)
                ctx->buf[i]=n;
        n=b-bl;
        for (i=bl; i<b; i++)
                ctx->buf[i]=n;

-       if(!ctx->cipher->do_cipher(ctx,out,ctx->buf,b)) return 0;
-       *outl=b;
-       return 1;
+       ret=ctx->cipher->do_cipher(ctx,out,ctx->buf,b);
+
+
+       if(ret)
+               *outl=b;
+
+       return ret;

        }
 
 int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
        }
 
 int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,

-            unsigned char *in, int inl)
+            const unsigned char *in, int inl)

        {
        {

-       int b;
+       int b, fix_len;

 
        if (inl == 0)
                {
 
        if (inl == 0)
                {


@@ -261,12 +360,18 @@ int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
                return EVP_EncryptUpdate(ctx, out, outl, in, inl);
 
        b=ctx->cipher->block_size;
                return EVP_EncryptUpdate(ctx, out, outl, in, inl);
 
        b=ctx->cipher->block_size;

+       OPENSSL_assert(b <= sizeof ctx->final);
+

        if(ctx->final_used)
                {
                memcpy(out,ctx->final,b);
                out+=b;
        if(ctx->final_used)
                {
                memcpy(out,ctx->final,b);
                out+=b;

+               fix_len = 1;

                }
                }

-               
+       else
+               fix_len = 0;
+
+

        if(!EVP_EncryptUpdate(ctx,out,outl,in,inl))
                return 0;
 
        if(!EVP_EncryptUpdate(ctx,out,outl,in,inl))
                return 0;
 


@@ -274,22 +379,27 @@ int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
         * we have a copy of this last block */
        if (b > 1 && !ctx->buf_len)
                {
         * we have a copy of this last block */
        if (b > 1 && !ctx->buf_len)
                {

-               if(!ctx->final_used)
-                       {
-                       *outl-=b;
-                       ctx->final_used=1;
-                       }
+               *outl-=b;
+               ctx->final_used=1;

                memcpy(ctx->final,&out[*outl],b);
                }
                memcpy(ctx->final,&out[*outl],b);
                }

-       else if(ctx->final_used)
-               {
-               ctx->final_used=0;
-               *outl+=b;
-               }
+       else
+               ctx->final_used = 0;
+
+       if (fix_len)
+               *outl += b;
+               

        return 1;
        }
 
 int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
        return 1;
        }
 
 int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)

+       {
+       int ret;
+       ret = EVP_DecryptFinal_ex(ctx, out, outl);
+       return ret;
+       }
+
+int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)

        {
        int i,b;
        int n;
        {
        int i,b;
        int n;


@@ -313,6 +423,7 @@ int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
                        EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_WRONG_FINAL_BLOCK_LENGTH);
                        return(0);
                        }
                        EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_WRONG_FINAL_BLOCK_LENGTH);
                        return(0);
                        }

+               OPENSSL_assert(b <= sizeof ctx->final);

                n=ctx->final[b-1];
                if (n > b)
                        {
                n=ctx->final[b-1];
                if (n > b)
                        {


@@ -339,11 +450,20 @@ int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
 
 int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c)
        {
 
 int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c)
        {

-       if ((c->cipher != NULL) && (c->cipher->cleanup != NULL))
+       if (c->cipher != NULL)

                {
                {

-               if(!c->cipher->cleanup(c)) return 0;
+               if(c->cipher->cleanup && !c->cipher->cleanup(c))
+                       return 0;
+               /* Cleanse cipher context data */
+               if (c->cipher_data)
+                       OPENSSL_cleanse(c->cipher_data, c->cipher->ctx_size);

                }
                }

-       OPENSSL_free(c->cipher_data);
+       if (c->cipher_data)
+               OPENSSL_free(c->cipher_data);
+       if (c->engine)
+               /* The EVP_CIPHER we used belongs to an ENGINE, release the
+                * functional reference we held for this reason. */
+               ENGINE_finish(c->engine);

        memset(c,0,sizeof(EVP_CIPHER_CTX));
        return 1;
        }
        memset(c,0,sizeof(EVP_CIPHER_CTX));
        return 1;
        }