crypto/evp/bio_ok.c

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