mark all block comments that need format preserving so that
[openssl.git] / crypto / evp / bio_enc.c
index 05f4249..2ceb802 100644 (file)
@@ -71,7 +71,7 @@ static int enc_new(BIO *h);
 static int enc_free(BIO *data);
 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
+#define BUF_OFFSET     (EVP_MAX_BLOCK_LENGTH*2)
 
 typedef struct enc_struct
        {
@@ -110,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;
@@ -132,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;
@@ -198,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[BUF_OFFSET]),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
@@ -257,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;
 
@@ -271,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;
@@ -298,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_ex(&(ctx->cipher),NULL,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 */
@@ -325,10 +334,7 @@ again:
                        {
                        i=enc_write(b,NULL,0);
                        if (i < 0)
-                               {
-                               ret=i;
-                               break;
-                               }
+                               return i;
                        }
 
                if (!ctx->finished)
@@ -364,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);
@@ -388,7 +396,7 @@ static long enc_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
        return(ret);
        }
 
-/*
+/*-
 void BIO_set_cipher_ctx(b,c)
 BIO *b;
 EVP_CIPHER_ctx *c;
@@ -408,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_ex(&(ctx->cipher),c,NULL, 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;
        }