bio_b64.c revision 120631
128257Smsmith/* crypto/evp/bio_b64.c */ 228257Smsmith/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 328257Smsmith * All rights reserved. 428257Smsmith * 528257Smsmith * This package is an SSL implementation written 628257Smsmith * by Eric Young (eay@cryptsoft.com). 728257Smsmith * The implementation was written so as to conform with Netscapes SSL. 828257Smsmith * 928257Smsmith * This library is free for commercial and non-commercial use as long as 1028257Smsmith * the following conditions are aheared to. The following conditions 1128257Smsmith * apply to all code found in this distribution, be it the RC4, RSA, 1228257Smsmith * lhash, DES, etc., code; not just the SSL code. The SSL documentation 1328257Smsmith * included with this distribution is covered by the same copyright terms 1428257Smsmith * except that the holder is Tim Hudson (tjh@cryptsoft.com). 1528257Smsmith * 1628257Smsmith * Copyright remains Eric Young's, and as such any Copyright notices in 1728257Smsmith * the code are not to be removed. 1828257Smsmith * If this package is used in a product, Eric Young should be given attribution 1928257Smsmith * as the author of the parts of the library used. 2028257Smsmith * This can be in the form of a textual message at program startup or 2128257Smsmith * in documentation (online or textual) provided with the package. 2228257Smsmith * 2328257Smsmith * Redistribution and use in source and binary forms, with or without 2428257Smsmith * modification, are permitted provided that the following conditions 2528257Smsmith * are met: 2650477Speter * 1. Redistributions of source code must retain the copyright 2728257Smsmith * notice, this list of conditions and the following disclaimer. 2828257Smsmith * 2. Redistributions in binary form must reproduce the above copyright 2928257Smsmith * notice, this list of conditions and the following disclaimer in the 3028257Smsmith * documentation and/or other materials provided with the distribution. 3128257Smsmith * 3. All advertising materials mentioning features or use of this software 3239134Snsouch * must display the following acknowledgement: 3339134Snsouch * "This product includes cryptographic software written by 3439134Snsouch * Eric Young (eay@cryptsoft.com)" 3539134Snsouch * The word 'cryptographic' can be left out if the rouines from the library 3639134Snsouch * being used are not cryptographic related :-). 3739134Snsouch * 4. If you include any Windows specific code (or a derivative thereof) from 3839134Snsouch * the apps directory (application code) you must include an acknowledgement: 3939134Snsouch * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 4039134Snsouch * 4139134Snsouch * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 4239134Snsouch * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 4339134Snsouch * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 4439134Snsouch * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 4539134Snsouch * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 4639134Snsouch * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 4739134Snsouch * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 4839134Snsouch * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 4939134Snsouch * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 5039134Snsouch * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 5139134Snsouch * SUCH DAMAGE. 5239134Snsouch * 5339134Snsouch * The licence and distribution terms for any publically available version or 5439134Snsouch * derivative of this code cannot be changed. i.e. this code cannot simply be 5539134Snsouch * copied and put under another distribution licence 5639134Snsouch * [including the GNU Public Licence.] 5739134Snsouch */ 5839134Snsouch 5939134Snsouch#include <stdio.h> 6039134Snsouch#include <errno.h> 6139134Snsouch#include "cryptlib.h" 6239134Snsouch#include <openssl/buffer.h> 6339134Snsouch#include <openssl/evp.h> 6439134Snsouch 6539134Snsouchstatic int b64_write(BIO *h, const char *buf, int num); 6639134Snsouchstatic int b64_read(BIO *h, char *buf, int size); 6739134Snsouch/*static int b64_puts(BIO *h, const char *str); */ 6839134Snsouch/*static int b64_gets(BIO *h, char *str, int size); */ 6942475Snsouchstatic long b64_ctrl(BIO *h, int cmd, long arg1, void *arg2); 7042475Snsouchstatic int b64_new(BIO *h); 7142475Snsouchstatic int b64_free(BIO *data); 7242475Snsouchstatic long b64_callback_ctrl(BIO *h,int cmd,bio_info_cb *fp); 7342475Snsouch#define B64_BLOCK_SIZE 1024 7442475Snsouch#define B64_BLOCK_SIZE2 768 7542475Snsouch#define B64_NONE 0 7642475Snsouch#define B64_ENCODE 1 7742475Snsouch#define B64_DECODE 2 7842475Snsouch 7928257Smsmithtypedef struct b64_struct 8042475Snsouch { 8142475Snsouch /*BIO *bio; moved to the BIO structure */ 8242475Snsouch int buf_len; 8342475Snsouch int buf_off; 8439134Snsouch int tmp_len; /* used to find the start when decoding */ 8542475Snsouch int tmp_nl; /* If true, scan until '\n' */ 8642475Snsouch int encode; 8742475Snsouch int start; /* have we started decoding yet? */ 8842475Snsouch int cont; /* <= 0 when finished */ 8942475Snsouch EVP_ENCODE_CTX base64; 9042475Snsouch char buf[EVP_ENCODE_LENGTH(B64_BLOCK_SIZE)+10]; 9138061Smsmith char tmp[B64_BLOCK_SIZE]; 9242475Snsouch } BIO_B64_CTX; 9342475Snsouch 9442475Snsouchstatic BIO_METHOD methods_b64= 9542475Snsouch { 9642475Snsouch BIO_TYPE_BASE64,"base64 encoding", 9742475Snsouch b64_write, 9842475Snsouch b64_read, 9942475Snsouch NULL, /* b64_puts, */ 10042475Snsouch NULL, /* b64_gets, */ 10142475Snsouch b64_ctrl, 10242475Snsouch b64_new, 10342475Snsouch b64_free, 10442475Snsouch b64_callback_ctrl, 10542475Snsouch }; 10642475Snsouch 10742475SnsouchBIO_METHOD *BIO_f_base64(void) 10842475Snsouch { 10942475Snsouch return(&methods_b64); 11042475Snsouch } 11155939Snsouch 11255939Snsouchstatic int b64_new(BIO *bi) 11355939Snsouch { 11428257Smsmith BIO_B64_CTX *ctx; 11555939Snsouch 11655939Snsouch ctx=(BIO_B64_CTX *)OPENSSL_malloc(sizeof(BIO_B64_CTX)); 11755939Snsouch if (ctx == NULL) return(0); 11855939Snsouch 11955957Snsouch ctx->buf_len=0; 12055957Snsouch ctx->tmp_len=0; 12139134Snsouch ctx->tmp_nl=0; 12255939Snsouch ctx->buf_off=0; 12355939Snsouch ctx->cont=1; 12455939Snsouch ctx->start=1; 12542475Snsouch ctx->encode=0; 12628257Smsmith 127 bi->init=1; 128 bi->ptr=(char *)ctx; 129 bi->flags=0; 130 return(1); 131 } 132 133static int b64_free(BIO *a) 134 { 135 if (a == NULL) return(0); 136 OPENSSL_free(a->ptr); 137 a->ptr=NULL; 138 a->init=0; 139 a->flags=0; 140 return(1); 141 } 142 143static int b64_read(BIO *b, char *out, int outl) 144 { 145 int ret=0,i,ii,j,k,x,n,num,ret_code=0; 146 BIO_B64_CTX *ctx; 147 unsigned char *p,*q; 148 149 if (out == NULL) return(0); 150 ctx=(BIO_B64_CTX *)b->ptr; 151 152 if ((ctx == NULL) || (b->next_bio == NULL)) return(0); 153 154 if (ctx->encode != B64_DECODE) 155 { 156 ctx->encode=B64_DECODE; 157 ctx->buf_len=0; 158 ctx->buf_off=0; 159 ctx->tmp_len=0; 160 EVP_DecodeInit(&(ctx->base64)); 161 } 162 163 /* First check if there are bytes decoded/encoded */ 164 if (ctx->buf_len > 0) 165 { 166 i=ctx->buf_len-ctx->buf_off; 167 if (i > outl) i=outl; 168 OPENSSL_assert(ctx->buf_off+i < sizeof ctx->buf); 169 memcpy(out,&(ctx->buf[ctx->buf_off]),i); 170 ret=i; 171 out+=i; 172 outl-=i; 173 ctx->buf_off+=i; 174 if (ctx->buf_len == ctx->buf_off) 175 { 176 ctx->buf_len=0; 177 ctx->buf_off=0; 178 } 179 } 180 181 /* At this point, we have room of outl bytes and an empty 182 * buffer, so we should read in some more. */ 183 184 ret_code=0; 185 while (outl > 0) 186 { 187 188 if (ctx->cont <= 0) 189 break; 190 191 i=BIO_read(b->next_bio,&(ctx->tmp[ctx->tmp_len]), 192 B64_BLOCK_SIZE-ctx->tmp_len); 193 194 if (i <= 0) 195 { 196 ret_code=i; 197 198 /* Should be continue next time we are called? */ 199 if (!BIO_should_retry(b->next_bio)) 200 { 201 ctx->cont=i; 202 /* If buffer empty break */ 203 if(ctx->tmp_len == 0) 204 break; 205 /* Fall through and process what we have */ 206 else 207 i = 0; 208 } 209 /* else we retry and add more data to buffer */ 210 else 211 break; 212 } 213 i+=ctx->tmp_len; 214 ctx->tmp_len = i; 215 216 /* We need to scan, a line at a time until we 217 * have a valid line if we are starting. */ 218 if (ctx->start && (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL)) 219 { 220 /* ctx->start=1; */ 221 ctx->tmp_len=0; 222 } 223 else if (ctx->start) 224 { 225 q=p=(unsigned char *)ctx->tmp; 226 for (j=0; j<i; j++) 227 { 228 if (*(q++) != '\n') continue; 229 230 /* due to a previous very long line, 231 * we need to keep on scanning for a '\n' 232 * before we even start looking for 233 * base64 encoded stuff. */ 234 if (ctx->tmp_nl) 235 { 236 p=q; 237 ctx->tmp_nl=0; 238 continue; 239 } 240 241 k=EVP_DecodeUpdate(&(ctx->base64), 242 (unsigned char *)ctx->buf, 243 &num,p,q-p); 244 if ((k <= 0) && (num == 0) && (ctx->start)) 245 EVP_DecodeInit(&ctx->base64); 246 else 247 { 248 if (p != (unsigned char *) 249 &(ctx->tmp[0])) 250 { 251 i-=(p- (unsigned char *) 252 &(ctx->tmp[0])); 253 for (x=0; x < i; x++) 254 ctx->tmp[x]=p[x]; 255 } 256 EVP_DecodeInit(&ctx->base64); 257 ctx->start=0; 258 break; 259 } 260 p=q; 261 } 262 263 /* we fell off the end without starting */ 264 if (j == i) 265 { 266 /* Is this is one long chunk?, if so, keep on 267 * reading until a new line. */ 268 if (p == (unsigned char *)&(ctx->tmp[0])) 269 { 270 /* Check buffer full */ 271 if (i == B64_BLOCK_SIZE) 272 { 273 ctx->tmp_nl=1; 274 ctx->tmp_len=0; 275 } 276 } 277 else if (p != q) /* finished on a '\n' */ 278 { 279 n=q-p; 280 for (ii=0; ii<n; ii++) 281 ctx->tmp[ii]=p[ii]; 282 ctx->tmp_len=n; 283 } 284 /* else finished on a '\n' */ 285 continue; 286 } 287 else 288 ctx->tmp_len=0; 289 } 290 /* If buffer isn't full and we can retry then 291 * restart to read in more data. 292 */ 293 else if ((i < B64_BLOCK_SIZE) && (ctx->cont > 0)) 294 continue; 295 296 if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL) 297 { 298 int z,jj; 299 300 jj=(i>>2)<<2; 301 z=EVP_DecodeBlock((unsigned char *)ctx->buf, 302 (unsigned char *)ctx->tmp,jj); 303 if (jj > 2) 304 { 305 if (ctx->tmp[jj-1] == '=') 306 { 307 z--; 308 if (ctx->tmp[jj-2] == '=') 309 z--; 310 } 311 } 312 /* z is now number of output bytes and jj is the 313 * number consumed */ 314 if (jj != i) 315 { 316 memcpy((unsigned char *)ctx->tmp, 317 (unsigned char *)&(ctx->tmp[jj]),i-jj); 318 ctx->tmp_len=i-jj; 319 } 320 ctx->buf_len=0; 321 if (z > 0) 322 { 323 ctx->buf_len=z; 324 i=1; 325 } 326 else 327 i=z; 328 } 329 else 330 { 331 i=EVP_DecodeUpdate(&(ctx->base64), 332 (unsigned char *)ctx->buf,&ctx->buf_len, 333 (unsigned char *)ctx->tmp,i); 334 ctx->tmp_len = 0; 335 } 336 ctx->buf_off=0; 337 if (i < 0) 338 { 339 ret_code=0; 340 ctx->buf_len=0; 341 break; 342 } 343 344 if (ctx->buf_len <= outl) 345 i=ctx->buf_len; 346 else 347 i=outl; 348 349 memcpy(out,ctx->buf,i); 350 ret+=i; 351 ctx->buf_off=i; 352 if (ctx->buf_off == ctx->buf_len) 353 { 354 ctx->buf_len=0; 355 ctx->buf_off=0; 356 } 357 outl-=i; 358 out+=i; 359 } 360 BIO_clear_retry_flags(b); 361 BIO_copy_next_retry(b); 362 return((ret == 0)?ret_code:ret); 363 } 364 365static int b64_write(BIO *b, const char *in, int inl) 366 { 367 int ret=inl,n,i; 368 BIO_B64_CTX *ctx; 369 370 ctx=(BIO_B64_CTX *)b->ptr; 371 BIO_clear_retry_flags(b); 372 373 if (ctx->encode != B64_ENCODE) 374 { 375 ctx->encode=B64_ENCODE; 376 ctx->buf_len=0; 377 ctx->buf_off=0; 378 ctx->tmp_len=0; 379 EVP_EncodeInit(&(ctx->base64)); 380 } 381 382 n=ctx->buf_len-ctx->buf_off; 383 while (n > 0) 384 { 385 i=BIO_write(b->next_bio,&(ctx->buf[ctx->buf_off]),n); 386 if (i <= 0) 387 { 388 BIO_copy_next_retry(b); 389 return(i); 390 } 391 ctx->buf_off+=i; 392 n-=i; 393 } 394 /* at this point all pending data has been written */ 395 ctx->buf_off=0; 396 ctx->buf_len=0; 397 398 if ((in == NULL) || (inl <= 0)) return(0); 399 400 while (inl > 0) 401 { 402 n=(inl > B64_BLOCK_SIZE)?B64_BLOCK_SIZE:inl; 403 404 if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL) 405 { 406 if (ctx->tmp_len > 0) 407 { 408 n=3-ctx->tmp_len; 409 /* There's a teoretical possibility for this */ 410 if (n > inl) 411 n=inl; 412 memcpy(&(ctx->tmp[ctx->tmp_len]),in,n); 413 ctx->tmp_len+=n; 414 if (ctx->tmp_len < 3) 415 break; 416 ctx->buf_len=EVP_EncodeBlock( 417 (unsigned char *)ctx->buf, 418 (unsigned char *)ctx->tmp, 419 ctx->tmp_len); 420 /* Since we're now done using the temporary 421 buffer, the length should be 0'd */ 422 ctx->tmp_len=0; 423 } 424 else 425 { 426 if (n < 3) 427 { 428 memcpy(&(ctx->tmp[0]),in,n); 429 ctx->tmp_len=n; 430 break; 431 } 432 n-=n%3; 433 ctx->buf_len=EVP_EncodeBlock( 434 (unsigned char *)ctx->buf, 435 (unsigned char *)in,n); 436 } 437 } 438 else 439 { 440 EVP_EncodeUpdate(&(ctx->base64), 441 (unsigned char *)ctx->buf,&ctx->buf_len, 442 (unsigned char *)in,n); 443 } 444 inl-=n; 445 in+=n; 446 447 ctx->buf_off=0; 448 n=ctx->buf_len; 449 while (n > 0) 450 { 451 i=BIO_write(b->next_bio,&(ctx->buf[ctx->buf_off]),n); 452 if (i <= 0) 453 { 454 BIO_copy_next_retry(b); 455 return((ret == 0)?i:ret); 456 } 457 n-=i; 458 ctx->buf_off+=i; 459 } 460 ctx->buf_len=0; 461 ctx->buf_off=0; 462 } 463 return(ret); 464 } 465 466static long b64_ctrl(BIO *b, int cmd, long num, void *ptr) 467 { 468 BIO_B64_CTX *ctx; 469 long ret=1; 470 int i; 471 472 ctx=(BIO_B64_CTX *)b->ptr; 473 474 switch (cmd) 475 { 476 case BIO_CTRL_RESET: 477 ctx->cont=1; 478 ctx->start=1; 479 ctx->encode=B64_NONE; 480 ret=BIO_ctrl(b->next_bio,cmd,num,ptr); 481 break; 482 case BIO_CTRL_EOF: /* More to read */ 483 if (ctx->cont <= 0) 484 ret=1; 485 else 486 ret=BIO_ctrl(b->next_bio,cmd,num,ptr); 487 break; 488 case BIO_CTRL_WPENDING: /* More to write in buffer */ 489 ret=ctx->buf_len-ctx->buf_off; 490 if ((ret == 0) && (ctx->encode != B64_NONE) 491 && (ctx->base64.num != 0)) 492 ret=1; 493 else if (ret <= 0) 494 ret=BIO_ctrl(b->next_bio,cmd,num,ptr); 495 break; 496 case BIO_CTRL_PENDING: /* More to read in buffer */ 497 ret=ctx->buf_len-ctx->buf_off; 498 if (ret <= 0) 499 ret=BIO_ctrl(b->next_bio,cmd,num,ptr); 500 break; 501 case BIO_CTRL_FLUSH: 502 /* do a final write */ 503again: 504 while (ctx->buf_len != ctx->buf_off) 505 { 506 i=b64_write(b,NULL,0); 507 if (i < 0) 508 return i; 509 } 510 if (BIO_get_flags(b) & BIO_FLAGS_BASE64_NO_NL) 511 { 512 if (ctx->tmp_len != 0) 513 { 514 ctx->buf_len=EVP_EncodeBlock( 515 (unsigned char *)ctx->buf, 516 (unsigned char *)ctx->tmp, 517 ctx->tmp_len); 518 ctx->buf_off=0; 519 ctx->tmp_len=0; 520 goto again; 521 } 522 } 523 else if (ctx->encode != B64_NONE && ctx->base64.num != 0) 524 { 525 ctx->buf_off=0; 526 EVP_EncodeFinal(&(ctx->base64), 527 (unsigned char *)ctx->buf, 528 &(ctx->buf_len)); 529 /* push out the bytes */ 530 goto again; 531 } 532 /* Finally flush the underlying BIO */ 533 ret=BIO_ctrl(b->next_bio,cmd,num,ptr); 534 break; 535 536 case BIO_C_DO_STATE_MACHINE: 537 BIO_clear_retry_flags(b); 538 ret=BIO_ctrl(b->next_bio,cmd,num,ptr); 539 BIO_copy_next_retry(b); 540 break; 541 542 case BIO_CTRL_DUP: 543 break; 544 case BIO_CTRL_INFO: 545 case BIO_CTRL_GET: 546 case BIO_CTRL_SET: 547 default: 548 ret=BIO_ctrl(b->next_bio,cmd,num,ptr); 549 break; 550 } 551 return(ret); 552 } 553 554static long b64_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp) 555 { 556 long ret=1; 557 558 if (b->next_bio == NULL) return(0); 559 switch (cmd) 560 { 561 default: 562 ret=BIO_callback_ctrl(b->next_bio,cmd,fp); 563 break; 564 } 565 return(ret); 566 } 567 568