1 files changed, 110 insertions, 39 deletions

diff --git a/src/lib/libcrypto/evp/evp_enc.c b/src/lib/libcrypto/evp/evp_enc.c
index 5299a65b6a..e2687f9879 100644
--- a/src/lib/libcrypto/evp/evp_enc.c
+++ b/src/lib/libcrypto/evp/evp_enc.c
@@ -59,6 +59,8 @@
 #include <stdio.h>
 #include "cryptlib.h"
 #include <openssl/evp.h>
+#include <openssl/err.h>
+#include "evp_locl.h"
 
 const char *EVP_version="EVP" OPENSSL_VERSION_PTEXT;
 
@@ -68,55 +70,84 @@ void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx)
         /* ctx->cipher=NULL; */
         }
 
-void EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *data,
+int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
              unsigned char *key, unsigned char *iv, int enc)
         {
-        if (enc)
-                EVP_EncryptInit(ctx,data,key,iv);
-        else    
-                EVP_DecryptInit(ctx,data,key,iv);
+        if(enc && (enc != -1)) enc = 1;
+        if (cipher) {
+                ctx->cipher=cipher;
+                ctx->key_len = cipher->key_len;
+                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;
+                        }
+                }
+        } else if(!ctx->cipher) {
+                EVPerr(EVP_F_EVP_CIPHERINIT, EVP_R_NO_CIPHER_SET);
+                return 0;
         }
+        if(!(EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_CUSTOM_IV)) {
+                switch(EVP_CIPHER_CTX_mode(ctx)) {
+
+                        case EVP_CIPH_STREAM_CIPHER:
+                        case EVP_CIPH_ECB_MODE:
+                        break;
+
+                        case EVP_CIPH_CFB_MODE:
+                        case EVP_CIPH_OFB_MODE:
 
-void EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
+                        ctx->num = 0;
+
+                        case EVP_CIPH_CBC_MODE:
+
+                        if(iv) memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx));
+                        memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx));
+                        break;
+
+                        default:
+                        return 0;
+                        break;
+                }
+        }
+
+        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;
+        return 1;
+        }
+
+int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
              unsigned char *in, int inl)
         {
         if (ctx->encrypt)
-                EVP_EncryptUpdate(ctx,out,outl,in,inl);
-        else    EVP_DecryptUpdate(ctx,out,outl,in,inl);
+                return EVP_EncryptUpdate(ctx,out,outl,in,inl);
+        else    return EVP_DecryptUpdate(ctx,out,outl,in,inl);
         }
 
 int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
         {
         if (ctx->encrypt)
-                {
-                EVP_EncryptFinal(ctx,out,outl);
-                return(1);
-                }
+                return EVP_EncryptFinal(ctx,out,outl);
         else    return(EVP_DecryptFinal(ctx,out,outl));
         }
 
-void 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)
         {
-        if (cipher != NULL)
-                ctx->cipher=cipher;
-        ctx->cipher->init(ctx,key,iv,1);
-        ctx->encrypt=1;
-        ctx->buf_len=0;
+        return EVP_CipherInit(ctx, cipher, key, iv, 1);
         }
 
-void 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)
         {
-        if (cipher != NULL)
-                ctx->cipher=cipher;
-        ctx->cipher->init(ctx,key,iv,0);
-        ctx->encrypt=0;
-        ctx->buf_len=0;
+        return EVP_CipherInit(ctx, cipher, key, iv, 0);
         }
 
 
-void 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)
         {
         int i,j,bl;
@@ -124,20 +155,20 @@ void EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
         i=ctx->buf_len;
         bl=ctx->cipher->block_size;
         *outl=0;
-        if ((inl == 0) && (i != bl)) return;
+        if ((inl == 0) && (i != bl)) return 1;
         if (i != 0)
                 {
                 if (i+inl < bl)
                         {
                         memcpy(&(ctx->buf[i]),in,inl);
                         ctx->buf_len+=inl;
-                        return;
+                        return 1;
                         }
                 else
                         {
                         j=bl-i;
                         if (j != 0) memcpy(&(ctx->buf[i]),in,j);
-                        ctx->cipher->do_cipher(ctx,out,ctx->buf,bl);
+                        if(!ctx->cipher->do_cipher(ctx,out,ctx->buf,bl)) return 0;
                         inl-=j;
                         in+=j;
                         out+=bl;
@@ -148,16 +179,17 @@ void EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
         inl-=i;
         if (inl > 0)
                 {
-                ctx->cipher->do_cipher(ctx,out,in,inl);
+                if(!ctx->cipher->do_cipher(ctx,out,in,inl)) return 0;
                 *outl+=inl;
                 }
 
         if (i != 0)
                 memcpy(ctx->buf,&(in[inl]),i);
         ctx->buf_len=i;
+        return 1;
         }
 
-void 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;
 
@@ -165,24 +197,25 @@ void EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
         if (b == 1)
                 {
                 *outl=0;
-                return;
+                return 1;
                 }
         bl=ctx->buf_len;
         n=b-bl;
         for (i=bl; i<b; i++)
                 ctx->buf[i]=n;
-        ctx->cipher->do_cipher(ctx,out,ctx->buf,b);
+        if(!ctx->cipher->do_cipher(ctx,out,ctx->buf,b)) return 0;
         *outl=b;
+        return 1;
         }
 
-void 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)
         {
         int b,bl,n;
         int keep_last=0;
 
         *outl=0;
-        if (inl == 0) return;
+        if (inl == 0) return 1;
 
         b=ctx->cipher->block_size;
         if (b > 1)
@@ -197,13 +230,13 @@ void EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
                                 memcpy(&(ctx->buf[bl]),in,inl);
                                 ctx->buf_len=b;
                                 *outl=0;
-                                return;
+                                return 1;
                                 }
                         keep_last=1;
                         inl-=b; /* don't do the last block */
                         }
                 }
-        EVP_EncryptUpdate(ctx,out,outl,in,inl);
+        if(!EVP_EncryptUpdate(ctx,out,outl,in,inl)) return 0;
 
         /* if we have 'decrypted' a multiple of block size, make sure
          * we have a copy of this last block */
@@ -218,6 +251,7 @@ void EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl,
 #endif
                 ctx->buf_len=b;
                 }
+        return 1;
         }
 
 int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
@@ -234,7 +268,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);
                         }
-                EVP_EncryptUpdate(ctx,ctx->buf,&n,ctx->buf,0);
+                if(!EVP_EncryptUpdate(ctx,ctx->buf,&n,ctx->buf,0)) return 0;
                 if (n != b)
                         return(0);
                 n=ctx->buf[b-1];
@@ -261,10 +295,47 @@ int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl)
         return(1);
         }
 
-void 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))
-                c->cipher->cleanup(c);
+                {
+                if(!c->cipher->cleanup(c)) return 0;
+                }
         memset(c,0,sizeof(EVP_CIPHER_CTX));
+        return 1;
+        }
+
+int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen)
+        {
+        if(c->cipher->flags & EVP_CIPH_CUSTOM_KEY_LENGTH) 
+                return EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_KEY_LENGTH, keylen, NULL);
+        if(c->key_len == keylen) return 1;
+        if((keylen > 0) && (c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH))
+                {
+                c->key_len = keylen;
+                return 1;
+                }
+        EVPerr(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH,EVP_R_INVALID_KEY_LENGTH);
+        return 0;
+        }
+
+int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
+{
+        int ret;
+        if(!ctx->cipher) {
+                EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET);
+                return 0;
+        }
+
+        if(!ctx->cipher->ctrl) {
+                EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED);
+                return 0;
         }
 
+        ret = ctx->cipher->ctrl(ctx, type, arg, ptr);
+        if(ret == -1) {
+                EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED);
+                return 0;
+        }
+        return ret;
+}