generic-library/openssl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

PR: 2258

Browse Source 
Submitted By: Ger Hobbelt <ger@hobbelt.com>

Base64 BIO fixes:

Use OPENSSL_assert() instead of assert().
Use memmove() as buffers overlap.
Fix write retry logic.
This commit is contained in:
Dr. Stephen Henson 2010-05-27 12:41:05 +00:00
parent 3d4fc82c0e
commit cb877ccb35
1 changed files with 54 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
crypto/evp/bio_b64.c
View File

@ -64,7 +64,7 @@
static int b64_write(BIO *h, const char *buf, int num); static int b64_write(BIO *h, const char *buf, int num);
static int b64_read(BIO *h, char *buf, int size); static int b64_read(BIO *h, char *buf, int size);
/*static int b64_puts(BIO *h, const char *str); */ static int b64_puts(BIO *h, const char *str);
/*static int b64_gets(BIO *h, char *str, int size); */ /*static int b64_gets(BIO *h, char *str, int size); */
static long b64_ctrl(BIO *h, int cmd, long arg1, void *arg2); static long b64_ctrl(BIO *h, int cmd, long arg1, void *arg2);
static int b64_new(BIO *h); static int b64_new(BIO *h);
@ -96,7 +96,7 @@ static BIO_METHOD methods_b64=
BIO_TYPE_BASE64,"base64 encoding", BIO_TYPE_BASE64,"base64 encoding",
b64_write, b64_write,
b64_read, b64_read,
NULL, /* b64_puts, */ b64_puts,
NULL, /* b64_gets, */ NULL, /* b64_gets, */
b64_ctrl, b64_ctrl,
b64_new, b64_new,
@ -127,6 +127,7 @@ static int b64_new(BIO *bi)
bi->init=1; bi->init=1;
bi->ptr=(char *)ctx; bi->ptr=(char *)ctx;
bi->flags=0; bi->flags=0;
bi->num = 0;
return(1); return(1);
} }
@ -151,6 +152,8 @@ static int b64_read(BIO *b, char *out, int outl)
if ((ctx == NULL) || (b->next_bio == NULL)) return(0); if ((ctx == NULL) || (b->next_bio == NULL)) return(0);
BIO_clear_retry_flags(b);
if (ctx->encode != B64_DECODE) if (ctx->encode != B64_DECODE)
{ {
ctx->encode=B64_DECODE; ctx->encode=B64_DECODE;
@ -163,6 +166,7 @@ static int b64_read(BIO *b, char *out, int outl)
/* First check if there are bytes decoded/encoded */ /* First check if there are bytes decoded/encoded */
if (ctx->buf_len > 0) if (ctx->buf_len > 0)
{ {
OPENSSL_assert(ctx->buf_len >= ctx->buf_off);
i=ctx->buf_len-ctx->buf_off; i=ctx->buf_len-ctx->buf_off;
if (i > outl) i=outl; if (i > outl) i=outl;
OPENSSL_assert(ctx->buf_off+i < (int)sizeof(ctx->buf)); OPENSSL_assert(ctx->buf_off+i < (int)sizeof(ctx->buf));
@ -184,7 +188,6 @@ static int b64_read(BIO *b, char *out, int outl)
ret_code=0; ret_code=0;
while (outl > 0) while (outl > 0)
{ {
if (ctx->cont <= 0) if (ctx->cont <= 0)
break; break;
@ -195,7 +198,7 @@ static int b64_read(BIO *b, char *out, int outl)
{ {
ret_code=i; ret_code=i;
/* Should be continue next time we are called? */ /* Should we continue next time we are called? */
if (!BIO_should_retry(b->next_bio)) if (!BIO_should_retry(b->next_bio))
{ {
ctx->cont=i; ctx->cont=i;
@ -285,19 +288,27 @@ static int b64_read(BIO *b, char *out, int outl)
continue; continue;
} }
else else
{
ctx->tmp_len=0; ctx->tmp_len=0;
} }
/* If buffer isn't full and we can retry then }
* restart to read in more data.
*/
else if ((i < B64_BLOCK_SIZE) && (ctx->cont > 0)) else if ((i < B64_BLOCK_SIZE) && (ctx->cont > 0))
{
/* If buffer isn't full and we can retry then
* restart to read in more data.
*/
continue; continue;
}
if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL) if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)
{ {
int z,jj; int z,jj;
#if 0
jj=(i>>2)<<2; jj=(i>>2)<<2;
#else
jj = i & ~3; /* process per 4 */
#endif
z=EVP_DecodeBlock((unsigned char *)ctx->buf, z=EVP_DecodeBlock((unsigned char *)ctx->buf,
(unsigned char *)ctx->tmp,jj); (unsigned char *)ctx->tmp,jj);
if (jj > 2) if (jj > 2)
@ -313,18 +324,15 @@ static int b64_read(BIO *b, char *out, int outl)
* number consumed */ * number consumed */
if (jj != i) if (jj != i)
{ {
memcpy((unsigned char *)ctx->tmp, memmove(ctx->tmp, &ctx->tmp[jj], i-jj);
(unsigned char *)&(ctx->tmp[jj]),i-jj);
ctx->tmp_len=i-jj; ctx->tmp_len=i-jj;
} }
ctx->buf_len=0; ctx->buf_len=0;
if (z > 0) if (z > 0)
{ {
ctx->buf_len=z; ctx->buf_len=z;
i=1;
} }
else i=z;
i=z;
} }
else else
{ {
@ -357,14 +365,16 @@ static int b64_read(BIO *b, char *out, int outl)
outl-=i; outl-=i;
out+=i; out+=i;
} }
BIO_clear_retry_flags(b); /* BIO_clear_retry_flags(b); */
BIO_copy_next_retry(b); BIO_copy_next_retry(b);
return((ret == 0)?ret_code:ret); return((ret == 0)?ret_code:ret);
} }
static int b64_write(BIO *b, const char *in, int inl) static int b64_write(BIO *b, const char *in, int inl)
{ {
int ret=inl,n,i; int ret=0;
int n;
int i;
BIO_B64_CTX *ctx; BIO_B64_CTX *ctx;
ctx=(BIO_B64_CTX *)b->ptr; ctx=(BIO_B64_CTX *)b->ptr;
@ -379,6 +389,9 @@ static int b64_write(BIO *b, const char *in, int inl)
EVP_EncodeInit(&(ctx->base64)); EVP_EncodeInit(&(ctx->base64));
} }
OPENSSL_assert(ctx->buf_off < (int)sizeof(ctx->buf));
OPENSSL_assert(ctx->buf_len <= (int)sizeof(ctx->buf));
OPENSSL_assert(ctx->buf_len >= ctx->buf_off);
n=ctx->buf_len-ctx->buf_off; n=ctx->buf_len-ctx->buf_off;
while (n > 0) while (n > 0)
{ {
@ -388,7 +401,10 @@ static int b64_write(BIO *b, const char *in, int inl)
BIO_copy_next_retry(b); BIO_copy_next_retry(b);
return(i); return(i);
} }
OPENSSL_assert(i <= n);
ctx->buf_off+=i; ctx->buf_off+=i;
OPENSSL_assert(ctx->buf_off <= (int)sizeof(ctx->buf));
OPENSSL_assert(ctx->buf_len >= ctx->buf_off);
n-=i; n-=i;
} }
/* at this point all pending data has been written */ /* at this point all pending data has been written */
@ -405,18 +421,19 @@ static int b64_write(BIO *b, const char *in, int inl)
{ {
if (ctx->tmp_len > 0) if (ctx->tmp_len > 0)
{ {
OPENSSL_assert(ctx->tmp_len <= 3);
n=3-ctx->tmp_len; n=3-ctx->tmp_len;
/* There's a teoretical possibility for this */ /* There's a theoretical possibility for this */
if (n > inl) if (n > inl)
n=inl; n=inl;
memcpy(&(ctx->tmp[ctx->tmp_len]),in,n); memcpy(&(ctx->tmp[ctx->tmp_len]),in,n);
ctx->tmp_len+=n; ctx->tmp_len+=n;
ret += n;
if (ctx->tmp_len < 3) if (ctx->tmp_len < 3)
break; break;
ctx->buf_len=EVP_EncodeBlock( ctx->buf_len=EVP_EncodeBlock((unsigned char *)ctx->buf,(unsigned char *)ctx->tmp,ctx->tmp_len);
(unsigned char *)ctx->buf, OPENSSL_assert(ctx->buf_len <= (int)sizeof(ctx->buf));
(unsigned char *)ctx->tmp, OPENSSL_assert(ctx->buf_len >= ctx->buf_off);
ctx->tmp_len);
/* Since we're now done using the temporary /* Since we're now done using the temporary
buffer, the length should be 0'd */ buffer, the length should be 0'd */
ctx->tmp_len=0; ctx->tmp_len=0;
@ -425,14 +442,16 @@ static int b64_write(BIO *b, const char *in, int inl)
{ {
if (n < 3) if (n < 3)
{ {
memcpy(&(ctx->tmp[0]),in,n); memcpy(ctx->tmp,in,n);
ctx->tmp_len=n; ctx->tmp_len=n;
ret += n;
break; break;
} }
n-=n%3; n-=n%3;
ctx->buf_len=EVP_EncodeBlock( ctx->buf_len=EVP_EncodeBlock((unsigned char *)ctx->buf,(const unsigned char *)in,n);
(unsigned char *)ctx->buf, OPENSSL_assert(ctx->buf_len <= (int)sizeof(ctx->buf));
(unsigned char *)in,n); OPENSSL_assert(ctx->buf_len >= ctx->buf_off);
ret += n;
} }
} }
else else
@ -440,6 +459,9 @@ static int b64_write(BIO *b, const char *in, int inl)
EVP_EncodeUpdate(&(ctx->base64), EVP_EncodeUpdate(&(ctx->base64),
(unsigned char *)ctx->buf,&ctx->buf_len, (unsigned char *)ctx->buf,&ctx->buf_len,
(unsigned char *)in,n); (unsigned char *)in,n);
OPENSSL_assert(ctx->buf_len <= (int)sizeof(ctx->buf));
OPENSSL_assert(ctx->buf_len >= ctx->buf_off);
ret += n;
} }
inl-=n; inl-=n;
in+=n; in+=n;
@ -454,8 +476,11 @@ static int b64_write(BIO *b, const char *in, int inl)
BIO_copy_next_retry(b); BIO_copy_next_retry(b);
return((ret == 0)?i:ret); return((ret == 0)?i:ret);
} }
OPENSSL_assert(i <= n);
n-=i; n-=i;
ctx->buf_off+=i; ctx->buf_off+=i;
OPENSSL_assert(ctx->buf_off <= (int)sizeof(ctx->buf));
OPENSSL_assert(ctx->buf_len >= ctx->buf_off);
} }
ctx->buf_len=0; ctx->buf_len=0;
ctx->buf_off=0; ctx->buf_off=0;
@ -486,6 +511,7 @@ static long b64_ctrl(BIO *b, int cmd, long num, void *ptr)
ret=BIO_ctrl(b->next_bio,cmd,num,ptr); ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
break; break;
case BIO_CTRL_WPENDING: /* More to write in buffer */ case BIO_CTRL_WPENDING: /* More to write in buffer */
OPENSSL_assert(ctx->buf_len >= ctx->buf_off);
ret=ctx->buf_len-ctx->buf_off; ret=ctx->buf_len-ctx->buf_off;
if ((ret == 0) && (ctx->encode != B64_NONE) if ((ret == 0) && (ctx->encode != B64_NONE)
&& (ctx->base64.num != 0)) && (ctx->base64.num != 0))
@ -494,6 +520,7 @@ static long b64_ctrl(BIO *b, int cmd, long num, void *ptr)
ret=BIO_ctrl(b->next_bio,cmd,num,ptr); ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
break; break;
case BIO_CTRL_PENDING: /* More to read in buffer */ case BIO_CTRL_PENDING: /* More to read in buffer */
OPENSSL_assert(ctx->buf_len >= ctx->buf_off);
ret=ctx->buf_len-ctx->buf_off; ret=ctx->buf_len-ctx->buf_off;
if (ret <= 0) if (ret <= 0)
ret=BIO_ctrl(b->next_bio,cmd,num,ptr); ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
@ -565,3 +592,7 @@ static long b64_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
return(ret); return(ret);
} }
static int b64_puts(BIO *b, const char *str)
{
return b64_write(b,str,strlen(str));
}