mark all block comments that need format preserving so that

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

diff --git a/crypto/evp/bio_enc.c b/crypto/evp/bio_enc.c
index 129e2e30a4086efc95c80a1f8c9f24aff16985d0..2ceb802f047802703f09942dfe1099044a9c85cb 100644 (file)
--- a/crypto/evp/bio_enc.c
+++ b/crypto/evp/bio_enc.c
@@ -69,8 +69,9 @@ static int enc_read(BIO *h, char *buf, int size);
 static long enc_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 static int enc_new(BIO *h);
 static int enc_free(BIO *data);
-static long enc_callback_ctrl(BIO *h, int cmd, void (*fp)());
+static long enc_callback_ctrl(BIO *h, int cmd, bio_info_cb *fps);
 #define ENC_BLOCK_SIZE (1024*4)
+#define BUF_OFFSET     (EVP_MAX_BLOCK_LENGTH*2)
 
 typedef struct enc_struct
        {
@@ -80,7 +81,10 @@ typedef struct enc_struct
        int finished;
        int ok;                 /* bad decrypt */
        EVP_CIPHER_CTX cipher;
-       char buf[ENC_BLOCK_SIZE+10];
+       /* buf is larger than ENC_BLOCK_SIZE because EVP_DecryptUpdate
+        * can return up to a block more data than is presented to it
+        */
+       char buf[ENC_BLOCK_SIZE+BUF_OFFSET+2];
        } BIO_ENC_CTX;
 
 static BIO_METHOD methods_enc=
@@ -106,8 +110,8 @@ static int enc_new(BIO *bi)
        BIO_ENC_CTX *ctx;
 
        ctx=(BIO_ENC_CTX *)OPENSSL_malloc(sizeof(BIO_ENC_CTX));
-       EVP_CIPHER_CTX_init(&ctx->cipher);
        if (ctx == NULL) return(0);
+       EVP_CIPHER_CTX_init(&ctx->cipher);
 
        ctx->buf_len=0;
        ctx->buf_off=0;
@@ -128,7 +132,7 @@ static int enc_free(BIO *a)
        if (a == NULL) return(0);
        b=(BIO_ENC_CTX *)a->ptr;
        EVP_CIPHER_CTX_cleanup(&(b->cipher));
-       memset(a->ptr,0,sizeof(BIO_ENC_CTX));
+       OPENSSL_cleanse(a->ptr,sizeof(BIO_ENC_CTX));
        OPENSSL_free(a->ptr);
        a->ptr=NULL;
        a->init=0;
@@ -170,9 +174,9 @@ static int enc_read(BIO *b, char *out, int outl)
                {
                if (ctx->cont <= 0) break;
 
-               /* read in at offset 8, read the EVP_Cipher
+               /* read in at IV offset, read the EVP_Cipher
                 * documentation about why */
-               i=BIO_read(b->next_bio,&(ctx->buf[8]),ENC_BLOCK_SIZE);
+               i=BIO_read(b->next_bio,&(ctx->buf[BUF_OFFSET]),ENC_BLOCK_SIZE);
 
                if (i <= 0)
                        {
@@ -180,7 +184,7 @@ static int enc_read(BIO *b, char *out, int outl)
                        if (!BIO_should_retry(b->next_bio))
                                {
                                ctx->cont=i;
-                               i=EVP_CipherFinal(&(ctx->cipher),
+                               i=EVP_CipherFinal_ex(&(ctx->cipher),
                                        (unsigned char *)ctx->buf,
                                        &(ctx->buf_len));
                                ctx->ok=i;
@@ -194,9 +198,13 @@ static int enc_read(BIO *b, char *out, int outl)
                        }
                else
                        {
-                       EVP_CipherUpdate(&(ctx->cipher),
+                       if (!EVP_CipherUpdate(&(ctx->cipher),
                                (unsigned char *)ctx->buf,&ctx->buf_len,
-                               (unsigned char *)&(ctx->buf[8]),i);
+                               (unsigned char *)&(ctx->buf[BUF_OFFSET]),i))
+                               {
+                               BIO_clear_retry_flags(b);
+                               return 0;
+                               }       
                        ctx->cont=1;
                        /* Note: it is possible for EVP_CipherUpdate to
                         * decrypt zero bytes because this is or looks like
@@ -253,9 +261,13 @@ static int enc_write(BIO *b, const char *in, int inl)
        while (inl > 0)
                {
                n=(inl > ENC_BLOCK_SIZE)?ENC_BLOCK_SIZE:inl;
-               EVP_CipherUpdate(&(ctx->cipher),
+               if (!EVP_CipherUpdate(&(ctx->cipher),
                        (unsigned char *)ctx->buf,&ctx->buf_len,
-                       (unsigned char *)in,n);
+                       (unsigned char *)in,n))
+                       {
+                       BIO_clear_retry_flags(b);
+                       return 0;
+                       }
                inl-=n;
                in+=n;
 
@@ -267,7 +279,7 @@ static int enc_write(BIO *b, const char *in, int inl)
                        if (i <= 0)
                                {
                                BIO_copy_next_retry(b);
-                               return(i);
+                               return (ret == inl) ? i : ret - inl;
                                }
                        n-=i;
                        ctx->buf_off+=i;
@@ -294,8 +306,9 @@ static long enc_ctrl(BIO *b, int cmd, long num, void *ptr)
        case BIO_CTRL_RESET:
                ctx->ok=1;
                ctx->finished=0;
-               EVP_CipherInit(&(ctx->cipher),NULL,NULL,NULL,
-                       ctx->cipher.encrypt);
+               if (!EVP_CipherInit_ex(&(ctx->cipher),NULL,NULL,NULL,NULL,
+                       ctx->cipher.encrypt))
+                       return 0;
                ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
                break;
        case BIO_CTRL_EOF:      /* More to read */
@@ -321,17 +334,14 @@ again:
                        {
                        i=enc_write(b,NULL,0);
                        if (i < 0)
-                               {
-                               ret=i;
-                               break;
-                               }
+                               return i;
                        }
 
                if (!ctx->finished)
                        {
                        ctx->finished=1;
                        ctx->buf_off=0;
-                       ret=EVP_CipherFinal(&(ctx->cipher),
+                       ret=EVP_CipherFinal_ex(&(ctx->cipher),
                                (unsigned char *)ctx->buf,
                                &(ctx->buf_len));
                        ctx->ok=(int)ret;
@@ -360,8 +370,10 @@ again:
        case BIO_CTRL_DUP:
                dbio=(BIO *)ptr;
                dctx=(BIO_ENC_CTX *)dbio->ptr;
-               memcpy(&(dctx->cipher),&(ctx->cipher),sizeof(ctx->cipher));
-               dbio->init=1;
+               EVP_CIPHER_CTX_init(&dctx->cipher);
+               ret = EVP_CIPHER_CTX_copy(&dctx->cipher,&ctx->cipher);
+               if (ret)
+                       dbio->init=1;
                break;
        default:
                ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
@@ -370,7 +382,7 @@ again:
        return(ret);
        }
 
-static long enc_callback_ctrl(BIO *b, int cmd, void (*fp)())
+static long enc_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
        {
        long ret=1;
 
@@ -384,7 +396,7 @@ static long enc_callback_ctrl(BIO *b, int cmd, void (*fp)())
        return(ret);
        }
 
-/*
+/*-
 void BIO_set_cipher_ctx(b,c)
 BIO *b;
 EVP_CIPHER_ctx *c;
@@ -404,22 +416,24 @@ EVP_CIPHER_ctx *c;
        }
 */
 
-void BIO_set_cipher(BIO *b, const EVP_CIPHER *c, unsigned char *k,
-            unsigned char *i, int e)
+int BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k,
+            const unsigned char *i, int e)
        {
        BIO_ENC_CTX *ctx;
 
-       if (b == NULL) return;
+       if (b == NULL) return 0;
 
        if ((b->callback != NULL) &&
                (b->callback(b,BIO_CB_CTRL,(const char *)c,BIO_CTRL_SET,e,0L) <= 0))
-               return;
+               return 0;
 
        b->init=1;
        ctx=(BIO_ENC_CTX *)b->ptr;
-       EVP_CipherInit(&(ctx->cipher),c,k,i,e);
+       if (!EVP_CipherInit_ex(&(ctx->cipher),c,NULL, k,i,e))
+               return 0;
        
        if (b->callback != NULL)
-               b->callback(b,BIO_CB_CTRL,(const char *)c,BIO_CTRL_SET,e,1L);
+               return b->callback(b,BIO_CB_CTRL,(const char *)c,BIO_CTRL_SET,e,1L);
+       return 1;
        }