crypto/evp/bio_ok.c

   1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   2  * All rights reserved.
   3  *
   4  * This package is an SSL implementation written
   5  * by Eric Young (eay@cryptsoft.com).
   6  * The implementation was written so as to conform with Netscapes SSL.
   7  *
   8  * This library is free for commercial and non-commercial use as long as
   9  * the following conditions are aheared to.  The following conditions
  10  * apply to all code found in this distribution, be it the RC4, RSA,
  11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  12  * included with this distribution is covered by the same copyright terms
  13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  14  *
  15  * Copyright remains Eric Young's, and as such any Copyright notices in
  16  * the code are not to be removed.
  17  * If this package is used in a product, Eric Young should be given attribution
  18  * as the author of the parts of the library used.
  19  * This can be in the form of a textual message at program startup or
  20  * in documentation (online or textual) provided with the package.
  21  *
  22  * Redistribution and use in source and binary forms, with or without
  23  * modification, are permitted provided that the following conditions
  24  * are met:
  25  * 1. Redistributions of source code must retain the copyright
  26  *    notice, this list of conditions and the following disclaimer.
  27  * 2. Redistributions in binary form must reproduce the above copyright
  28  *    notice, this list of conditions and the following disclaimer in the
  29  *    documentation and/or other materials provided with the distribution.
  30  * 3. All advertising materials mentioning features or use of this software
  31  *    must display the following acknowledgement:
  32  *    "This product includes cryptographic software written by
  33  *     Eric Young (eay@cryptsoft.com)"
  34  *    The word 'cryptographic' can be left out if the rouines from the library
  35  *    being used are not cryptographic related :-).
  36  * 4. If you include any Windows specific code (or a derivative thereof) from
  37  *    the apps directory (application code) you must include an acknowledgement:
  38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  50  * SUCH DAMAGE.
  51  *
  52  * The licence and distribution terms for any publically available version or
  53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  54  * copied and put under another distribution licence
  55  * [including the GNU Public Licence.]
  56  */
  57
  58 /*-
  59         From: Arne Ansper <arne@cyber.ee>
  60
  61         Why BIO_f_reliable?
  62
  63         I wrote function which took BIO* as argument, read data from it
  64         and processed it. Then I wanted to store the input file in
  65         encrypted form. OK I pushed BIO_f_cipher to the BIO stack
  66         and everything was OK. BUT if user types wrong password
  67         BIO_f_cipher outputs only garbage and my function crashes. Yes
  68         I can and I should fix my function, but BIO_f_cipher is
  69         easy way to add encryption support to many existing applications
  70         and it's hard to debug and fix them all.
  71
  72         So I wanted another BIO which would catch the incorrect passwords and
  73         file damages which cause garbage on BIO_f_cipher's output.
  74
  75         The easy way is to push the BIO_f_md and save the checksum at
  76         the end of the file. However there are several problems with this
  77         approach:
  78
  79         1) you must somehow separate checksum from actual data.
  80         2) you need lot's of memory when reading the file, because you
  81         must read to the end of the file and verify the checksum before
  82         letting the application to read the data.
  83
  84         BIO_f_reliable tries to solve both problems, so that you can
  85         read and write arbitrary long streams using only fixed amount
  86         of memory.
  87
  88         BIO_f_reliable splits data stream into blocks. Each block is prefixed
  89         with it's length and suffixed with it's digest. So you need only
  90         several Kbytes of memory to buffer single block before verifying
  91         it's digest.
  92
  93         BIO_f_reliable goes further and adds several important capabilities:
  94
  95         1) the digest of the block is computed over the whole stream
  96         -- so nobody can rearrange the blocks or remove or replace them.
  97
  98         2) to detect invalid passwords right at the start BIO_f_reliable
  99         adds special prefix to the stream. In order to avoid known plain-text
 100         attacks this prefix is generated as follows:
 101
 102                 *) digest is initialized with random seed instead of
 103                 standardized one.
 104                 *) same seed is written to output
 105                 *) well-known text is then hashed and the output
 106                 of the digest is also written to output.
 107
 108         reader can now read the seed from stream, hash the same string
 109         and then compare the digest output.
 110
 111         Bad things: BIO_f_reliable knows what's going on in EVP_Digest. I
 112         initially wrote and tested this code on x86 machine and wrote the
 113         digests out in machine-dependent order :( There are people using
 114         this code and I cannot change this easily without making existing
 115         data files unreadable.
 116
 117 */
 118
 119 #include <stdio.h>
 120 #include <errno.h>
 121 #include <assert.h>
 122 #include "internal/cryptlib.h"
 123 #include <openssl/buffer.h>
 124 #include "internal/bio.h"
 125 #include <openssl/evp.h>
 126 #include <openssl/rand.h>
 127 #include "internal/evp_int.h"
 128
 129 static int ok_write(BIO *h, const char *buf, int num);
 130 static int ok_read(BIO *h, char *buf, int size);
 131 static long ok_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 132 static int ok_new(BIO *h);
 133 static int ok_free(BIO *data);
 134 static long ok_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp);
 135
 136 static __owur int sig_out(BIO *b);
 137 static __owur int sig_in(BIO *b);
 138 static __owur int block_out(BIO *b);
 139 static __owur int block_in(BIO *b);
 140 #define OK_BLOCK_SIZE   (1024*4)
 141 #define OK_BLOCK_BLOCK  4
 142 #define IOBS            (OK_BLOCK_SIZE+ OK_BLOCK_BLOCK+ 3*EVP_MAX_MD_SIZE)
 143 #define WELLKNOWN "The quick brown fox jumped over the lazy dog's back."
 144
 145 typedef struct ok_struct {
 146     size_t buf_len;
 147     size_t buf_off;
 148     size_t buf_len_save;
 149     size_t buf_off_save;
 150     int cont;                   /* <= 0 when finished */
 151     int finished;
 152     EVP_MD_CTX *md;
 153     int blockout;               /* output block is ready */
 154     int sigio;                  /* must process signature */
 155     unsigned char buf[IOBS];
 156 } BIO_OK_CTX;
 157
 158 static const BIO_METHOD methods_ok = {
 159     BIO_TYPE_CIPHER, "reliable",
 160     ok_write,
 161     ok_read,
 162     NULL,                       /* ok_puts, */
 163     NULL,                       /* ok_gets, */
 164     ok_ctrl,
 165     ok_new,
 166     ok_free,
 167     ok_callback_ctrl,
 168 };
 169
 170 const BIO_METHOD *BIO_f_reliable(void)
 171 {
 172     return (&methods_ok);
 173 }
 174
 175 static int ok_new(BIO *bi)
 176 {
 177     BIO_OK_CTX *ctx;
 178
 179     ctx = OPENSSL_zalloc(sizeof(*ctx));
 180     if (ctx == NULL)
 181         return 0;
 182
 183     ctx->cont = 1;
 184     ctx->sigio = 1;
 185     ctx->md = EVP_MD_CTX_new();
 186     if (ctx->md == NULL) {
 187         OPENSSL_free(ctx);
 188         return 0;
 189     }
 190     BIO_set_init(bi, 0);
 191     BIO_set_data(bi, ctx);
 192
 193     return 1;
 194 }
 195
 196 static int ok_free(BIO *a)
 197 {
 198     BIO_OK_CTX *ctx;
 199
 200     if (a == NULL)
 201         return 0;
 202
 203     ctx = BIO_get_data(a);
 204
 205     EVP_MD_CTX_free(ctx->md);
 206     OPENSSL_clear_free(ctx, sizeof(BIO_OK_CTX));
 207     BIO_set_data(a, NULL);
 208     BIO_set_init(a, 0);
 209
 210     return 1;
 211 }
 212
 213 static int ok_read(BIO *b, char *out, int outl)
 214 {
 215     int ret = 0, i, n;
 216     BIO_OK_CTX *ctx;
 217     BIO *next;
 218
 219     if (out == NULL)
 220         return 0;
 221
 222     ctx = BIO_get_data(b);
 223     next = BIO_next(b);
 224
 225     if ((ctx == NULL) || (next == NULL) || (BIO_get_init(b) == 0))
 226         return 0;
 227
 228     while (outl > 0) {
 229
 230         /* copy clean bytes to output buffer */
 231         if (ctx->blockout) {
 232             i = ctx->buf_len - ctx->buf_off;
 233             if (i > outl)
 234                 i = outl;
 235             memcpy(out, &(ctx->buf[ctx->buf_off]), i);
 236             ret += i;
 237             out += i;
 238             outl -= i;
 239             ctx->buf_off += i;
 240
 241             /* all clean bytes are out */
 242             if (ctx->buf_len == ctx->buf_off) {
 243                 ctx->buf_off = 0;
 244
 245                 /*
 246                  * copy start of the next block into proper place
 247                  */
 248                 if (ctx->buf_len_save - ctx->buf_off_save > 0) {
 249                     ctx->buf_len = ctx->buf_len_save - ctx->buf_off_save;
 250                     memmove(ctx->buf, &(ctx->buf[ctx->buf_off_save]),
 251                             ctx->buf_len);
 252                 } else {
 253                     ctx->buf_len = 0;
 254                 }
 255                 ctx->blockout = 0;
 256             }
 257         }
 258
 259         /* output buffer full -- cancel */
 260         if (outl == 0)
 261             break;
 262
 263         /* no clean bytes in buffer -- fill it */
 264         n = IOBS - ctx->buf_len;
 265         i = BIO_read(next, &(ctx->buf[ctx->buf_len]), n);
 266
 267         if (i <= 0)
 268             break;              /* nothing new */
 269
 270         ctx->buf_len += i;
 271
 272         /* no signature yet -- check if we got one */
 273         if (ctx->sigio == 1) {
 274             if (!sig_in(b)) {
 275                 BIO_clear_retry_flags(b);
 276                 return 0;
 277             }
 278         }
 279
 280         /* signature ok -- check if we got block */
 281         if (ctx->sigio == 0) {
 282             if (!block_in(b)) {
 283                 BIO_clear_retry_flags(b);
 284                 return 0;
 285             }
 286         }
 287
 288         /* invalid block -- cancel */
 289         if (ctx->cont <= 0)
 290             break;
 291
 292     }
 293
 294     BIO_clear_retry_flags(b);
 295     BIO_copy_next_retry(b);
 296     return ret;
 297 }
 298
 299 static int ok_write(BIO *b, const char *in, int inl)
 300 {
 301     int ret = 0, n, i;
 302     BIO_OK_CTX *ctx;
 303     BIO *next;
 304
 305     if (inl <= 0)
 306         return inl;
 307
 308     ctx = BIO_get_data(b);
 309     next = BIO_next(b);
 310     ret = inl;
 311
 312     if ((ctx == NULL) || (next == NULL) || (BIO_get_init(b) == 0))
 313         return (0);
 314
 315     if (ctx->sigio && !sig_out(b))
 316         return 0;
 317
 318     do {
 319         BIO_clear_retry_flags(b);
 320         n = ctx->buf_len - ctx->buf_off;
 321         while (ctx->blockout && n > 0) {
 322             i = BIO_write(next, &(ctx->buf[ctx->buf_off]), n);
 323             if (i <= 0) {
 324                 BIO_copy_next_retry(b);
 325                 if (!BIO_should_retry(b))
 326                     ctx->cont = 0;
 327                 return (i);
 328             }
 329             ctx->buf_off += i;
 330             n -= i;
 331         }
 332
 333         /* at this point all pending data has been written */
 334         ctx->blockout = 0;
 335         if (ctx->buf_len == ctx->buf_off) {
 336             ctx->buf_len = OK_BLOCK_BLOCK;
 337             ctx->buf_off = 0;
 338         }
 339
 340         if ((in == NULL) || (inl <= 0))
 341             return (0);
 342
 343         n = (inl + ctx->buf_len > OK_BLOCK_SIZE + OK_BLOCK_BLOCK) ?
 344             (int)(OK_BLOCK_SIZE + OK_BLOCK_BLOCK - ctx->buf_len) : inl;
 345
 346         memcpy(&ctx->buf[ctx->buf_len], in, n);
 347         ctx->buf_len += n;
 348         inl -= n;
 349         in += n;
 350
 351         if (ctx->buf_len >= OK_BLOCK_SIZE + OK_BLOCK_BLOCK) {
 352             if (!block_out(b)) {
 353                 BIO_clear_retry_flags(b);
 354                 return 0;
 355             }
 356         }
 357     } while (inl > 0);
 358
 359     BIO_clear_retry_flags(b);
 360     BIO_copy_next_retry(b);
 361     return (ret);
 362 }
 363
 364 static long ok_ctrl(BIO *b, int cmd, long num, void *ptr)
 365 {
 366     BIO_OK_CTX *ctx;
 367     EVP_MD *md;
 368     const EVP_MD **ppmd;
 369     long ret = 1;
 370     int i;
 371     BIO *next;
 372
 373     ctx = BIO_get_data(b);
 374     next = BIO_next(b);
 375
 376     switch (cmd) {
 377     case BIO_CTRL_RESET:
 378         ctx->buf_len = 0;
 379         ctx->buf_off = 0;
 380         ctx->buf_len_save = 0;
 381         ctx->buf_off_save = 0;
 382         ctx->cont = 1;
 383         ctx->finished = 0;
 384         ctx->blockout = 0;
 385         ctx->sigio = 1;
 386         ret = BIO_ctrl(next, cmd, num, ptr);
 387         break;
 388     case BIO_CTRL_EOF:         /* More to read */
 389         if (ctx->cont <= 0)
 390             ret = 1;
 391         else
 392             ret = BIO_ctrl(next, cmd, num, ptr);
 393         break;
 394     case BIO_CTRL_PENDING:     /* More to read in buffer */
 395     case BIO_CTRL_WPENDING:    /* More to read in buffer */
 396         ret = ctx->blockout ? ctx->buf_len - ctx->buf_off : 0;
 397         if (ret <= 0)
 398             ret = BIO_ctrl(next, cmd, num, ptr);
 399         break;
 400     case BIO_CTRL_FLUSH:
 401         /* do a final write */
 402         if (ctx->blockout == 0)
 403             if (!block_out(b))
 404                 return 0;
 405
 406         while (ctx->blockout) {
 407             i = ok_write(b, NULL, 0);
 408             if (i < 0) {
 409                 ret = i;
 410                 break;
 411             }
 412         }
 413
 414         ctx->finished = 1;
 415         ctx->buf_off = ctx->buf_len = 0;
 416         ctx->cont = (int)ret;
 417
 418         /* Finally flush the underlying BIO */
 419         ret = BIO_ctrl(next, cmd, num, ptr);
 420         break;
 421     case BIO_C_DO_STATE_MACHINE:
 422         BIO_clear_retry_flags(b);
 423         ret = BIO_ctrl(next, cmd, num, ptr);
 424         BIO_copy_next_retry(b);
 425         break;
 426     case BIO_CTRL_INFO:
 427         ret = (long)ctx->cont;
 428         break;
 429     case BIO_C_SET_MD:
 430         md = ptr;
 431         if (!EVP_DigestInit_ex(ctx->md, md, NULL))
 432             return 0;
 433         BIO_set_init(b, 1);
 434         break;
 435     case BIO_C_GET_MD:
 436         if (BIO_get_init(b)) {
 437             ppmd = ptr;
 438             *ppmd = EVP_MD_CTX_md(ctx->md);
 439         } else
 440             ret = 0;
 441         break;
 442     default:
 443         ret = BIO_ctrl(next, cmd, num, ptr);
 444         break;
 445     }
 446     return ret;
 447 }
 448
 449 static long ok_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
 450 {
 451     long ret = 1;
 452     BIO *next;
 453
 454     next = BIO_next(b);
 455
 456     if (next == NULL)
 457         return 0;
 458
 459     switch (cmd) {
 460     default:
 461         ret = BIO_callback_ctrl(next, cmd, fp);
 462         break;
 463     }
 464
 465     return ret;
 466 }
 467
 468 static void longswap(void *_ptr, size_t len)
 469 {
 470     const union {
 471         long one;
 472         char little;
 473     } is_endian = {
 474         1
 475     };
 476
 477     if (is_endian.little) {
 478         size_t i;
 479         unsigned char *p = _ptr, c;
 480
 481         for (i = 0; i < len; i += 4) {
 482             c = p[0], p[0] = p[3], p[3] = c;
 483             c = p[1], p[1] = p[2], p[2] = c;
 484         }
 485     }
 486 }
 487
 488 static int sig_out(BIO *b)
 489 {
 490     BIO_OK_CTX *ctx;
 491     EVP_MD_CTX *md;
 492     const EVP_MD *digest;
 493     int md_size;
 494     void *md_data;
 495
 496     ctx = BIO_get_data(b);
 497     md = ctx->md;
 498     digest = EVP_MD_CTX_md(md);
 499     md_size = EVP_MD_size(digest);
 500     md_data = EVP_MD_CTX_md_data(md);
 501
 502     if (ctx->buf_len + 2 * md_size > OK_BLOCK_SIZE)
 503         return 1;
 504
 505     if (!EVP_DigestInit_ex(md, digest, NULL))
 506         goto berr;
 507     /*
 508      * FIXME: there's absolutely no guarantee this makes any sense at all,
 509      * particularly now EVP_MD_CTX has been restructured.
 510      */
 511     if (RAND_bytes(md_data, md_size) <= 0)
 512         goto berr;
 513     memcpy(&(ctx->buf[ctx->buf_len]), md_data, md_size);
 514     longswap(&(ctx->buf[ctx->buf_len]), md_size);
 515     ctx->buf_len += md_size;
 516
 517     if (!EVP_DigestUpdate(md, WELLKNOWN, strlen(WELLKNOWN)))
 518         goto berr;
 519     if (!EVP_DigestFinal_ex(md, &(ctx->buf[ctx->buf_len]), NULL))
 520         goto berr;
 521     ctx->buf_len += md_size;
 522     ctx->blockout = 1;
 523     ctx->sigio = 0;
 524     return 1;
 525  berr:
 526     BIO_clear_retry_flags(b);
 527     return 0;
 528 }
 529
 530 static int sig_in(BIO *b)
 531 {
 532     BIO_OK_CTX *ctx;
 533     EVP_MD_CTX *md;
 534     unsigned char tmp[EVP_MAX_MD_SIZE];
 535     int ret = 0;
 536     const EVP_MD *digest;
 537     int md_size;
 538     void *md_data;
 539
 540     ctx = BIO_get_data(b);
 541     md = ctx->md;
 542     digest = EVP_MD_CTX_md(md);
 543     md_size = EVP_MD_size(digest);
 544     md_data = EVP_MD_CTX_md_data(md);
 545
 546     if ((int)(ctx->buf_len - ctx->buf_off) < 2 * md_size)
 547         return 1;
 548
 549     if (!EVP_DigestInit_ex(md, digest, NULL))
 550         goto berr;
 551     memcpy(md_data, &(ctx->buf[ctx->buf_off]), md_size);
 552     longswap(md_data, md_size);
 553     ctx->buf_off += md_size;
 554
 555     if (!EVP_DigestUpdate(md, WELLKNOWN, strlen(WELLKNOWN)))
 556         goto berr;
 557     if (!EVP_DigestFinal_ex(md, tmp, NULL))
 558         goto berr;
 559     ret = memcmp(&(ctx->buf[ctx->buf_off]), tmp, md_size) == 0;
 560     ctx->buf_off += md_size;
 561     if (ret == 1) {
 562         ctx->sigio = 0;
 563         if (ctx->buf_len != ctx->buf_off) {
 564             memmove(ctx->buf, &(ctx->buf[ctx->buf_off]),
 565                     ctx->buf_len - ctx->buf_off);
 566         }
 567         ctx->buf_len -= ctx->buf_off;
 568         ctx->buf_off = 0;
 569     } else {
 570         ctx->cont = 0;
 571     }
 572     return 1;
 573  berr:
 574     BIO_clear_retry_flags(b);
 575     return 0;
 576 }
 577
 578 static int block_out(BIO *b)
 579 {
 580     BIO_OK_CTX *ctx;
 581     EVP_MD_CTX *md;
 582     unsigned long tl;
 583     const EVP_MD *digest;
 584     int md_size;
 585
 586     ctx = BIO_get_data(b);
 587     md = ctx->md;
 588     digest = EVP_MD_CTX_md(md);
 589     md_size = EVP_MD_size(digest);
 590
 591     tl = ctx->buf_len - OK_BLOCK_BLOCK;
 592     ctx->buf[0] = (unsigned char)(tl >> 24);
 593     ctx->buf[1] = (unsigned char)(tl >> 16);
 594     ctx->buf[2] = (unsigned char)(tl >> 8);
 595     ctx->buf[3] = (unsigned char)(tl);
 596     if (!EVP_DigestUpdate(md,
 597                           (unsigned char *)&(ctx->buf[OK_BLOCK_BLOCK]), tl))
 598         goto berr;
 599     if (!EVP_DigestFinal_ex(md, &(ctx->buf[ctx->buf_len]), NULL))
 600         goto berr;
 601     ctx->buf_len += md_size;
 602     ctx->blockout = 1;
 603     return 1;
 604  berr:
 605     BIO_clear_retry_flags(b);
 606     return 0;
 607 }
 608
 609 static int block_in(BIO *b)
 610 {
 611     BIO_OK_CTX *ctx;
 612     EVP_MD_CTX *md;
 613     unsigned long tl = 0;
 614     unsigned char tmp[EVP_MAX_MD_SIZE];
 615     int md_size;
 616
 617     ctx = BIO_get_data(b);
 618     md = ctx->md;
 619     md_size = EVP_MD_size(EVP_MD_CTX_md(md));
 620
 621     assert(sizeof(tl) >= OK_BLOCK_BLOCK); /* always true */
 622     tl = ctx->buf[0];
 623     tl <<= 8;
 624     tl |= ctx->buf[1];
 625     tl <<= 8;
 626     tl |= ctx->buf[2];
 627     tl <<= 8;
 628     tl |= ctx->buf[3];
 629
 630     if (ctx->buf_len < tl + OK_BLOCK_BLOCK + md_size)
 631         return 1;
 632
 633     if (!EVP_DigestUpdate(md,
 634                           (unsigned char *)&(ctx->buf[OK_BLOCK_BLOCK]), tl))
 635         goto berr;
 636     if (!EVP_DigestFinal_ex(md, tmp, NULL))
 637         goto berr;
 638     if (memcmp(&(ctx->buf[tl + OK_BLOCK_BLOCK]), tmp, md_size) == 0) {
 639         /* there might be parts from next block lurking around ! */
 640         ctx->buf_off_save = tl + OK_BLOCK_BLOCK + md_size;
 641         ctx->buf_len_save = ctx->buf_len;
 642         ctx->buf_off = OK_BLOCK_BLOCK;
 643         ctx->buf_len = tl + OK_BLOCK_BLOCK;
 644         ctx->blockout = 1;
 645     } else {
 646         ctx->cont = 0;
 647     }
 648     return 1;
 649  berr:
 650     BIO_clear_retry_flags(b);
 651     return 0;
 652 }