1: /* ssl/s2_lib.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: #include "ssl_locl.h"
   60: #ifndef OPENSSL_NO_SSL2
   61: #include <stdio.h>
   62: #include <openssl/objects.h>
   63: #include <openssl/evp.h>
   64: #include <openssl/md5.h>
   65: 
   66: const char ssl2_version_str[]="SSLv2" OPENSSL_VERSION_PTEXT;
   67: 
   68: #define SSL2_NUM_CIPHERS (sizeof(ssl2_ciphers)/sizeof(SSL_CIPHER))
   69: 
   70: /* list of available SSLv2 ciphers (sorted by id) */
   71: OPENSSL_GLOBAL SSL_CIPHER ssl2_ciphers[]={
   72: /* NULL_WITH_MD5 v3 */
   73: #if 0
   74:         {
   75:         1,
   76:         SSL2_TXT_NULL_WITH_MD5,
   77:         SSL2_CK_NULL_WITH_MD5,
   78:         SSL_kRSA|SSL_aRSA|SSL_eNULL|SSL_MD5|SSL_SSLV2,
   79:         SSL_EXPORT|SSL_EXP40|SSL_STRONG_NONE,
   80:         0,
   81:         0,
   82:         0,
   83:         SSL_ALL_CIPHERS,
   84:         SSL_ALL_STRENGTHS,
   85:         },
   86: #endif
   87: /* RC4_128_WITH_MD5 */
   88:         {
   89:         1,
   90:         SSL2_TXT_RC4_128_WITH_MD5,
   91:         SSL2_CK_RC4_128_WITH_MD5,
   92:         SSL_kRSA|SSL_aRSA|SSL_RC4|SSL_MD5|SSL_SSLV2,
   93:         SSL_NOT_EXP|SSL_MEDIUM,
   94:         0,
   95:         128,
   96:         128,
   97:         SSL_ALL_CIPHERS,
   98:         SSL_ALL_STRENGTHS,
   99:         },
  100: /* RC4_128_EXPORT40_WITH_MD5 */
  101:         {
  102:         1,
  103:         SSL2_TXT_RC4_128_EXPORT40_WITH_MD5,
  104:         SSL2_CK_RC4_128_EXPORT40_WITH_MD5,
  105:         SSL_kRSA|SSL_aRSA|SSL_RC4|SSL_MD5|SSL_SSLV2,
  106:         SSL_EXPORT|SSL_EXP40,
  107:         SSL2_CF_5_BYTE_ENC,
  108:         40,
  109:         128,
  110:         SSL_ALL_CIPHERS,
  111:         SSL_ALL_STRENGTHS,
  112:         },
  113: /* RC2_128_CBC_WITH_MD5 */
  114:         {
  115:         1,
  116:         SSL2_TXT_RC2_128_CBC_WITH_MD5,
  117:         SSL2_CK_RC2_128_CBC_WITH_MD5,
  118:         SSL_kRSA|SSL_aRSA|SSL_RC2|SSL_MD5|SSL_SSLV2,
  119:         SSL_NOT_EXP|SSL_MEDIUM,
  120:         0,
  121:         128,
  122:         128,
  123:         SSL_ALL_CIPHERS,
  124:         SSL_ALL_STRENGTHS,
  125:         },
  126: /* RC2_128_CBC_EXPORT40_WITH_MD5 */
  127:         {
  128:         1,
  129:         SSL2_TXT_RC2_128_CBC_EXPORT40_WITH_MD5,
  130:         SSL2_CK_RC2_128_CBC_EXPORT40_WITH_MD5,
  131:         SSL_kRSA|SSL_aRSA|SSL_RC2|SSL_MD5|SSL_SSLV2,
  132:         SSL_EXPORT|SSL_EXP40,
  133:         SSL2_CF_5_BYTE_ENC,
  134:         40,
  135:         128,
  136:         SSL_ALL_CIPHERS,
  137:         SSL_ALL_STRENGTHS,
  138:         },
  139: /* IDEA_128_CBC_WITH_MD5 */
  140: #ifndef OPENSSL_NO_IDEA
  141:         {
  142:         1,
  143:         SSL2_TXT_IDEA_128_CBC_WITH_MD5,
  144:         SSL2_CK_IDEA_128_CBC_WITH_MD5,
  145:         SSL_kRSA|SSL_aRSA|SSL_IDEA|SSL_MD5|SSL_SSLV2,
  146:         SSL_NOT_EXP|SSL_MEDIUM,
  147:         0,
  148:         128,
  149:         128,
  150:         SSL_ALL_CIPHERS,
  151:         SSL_ALL_STRENGTHS,
  152:         },
  153: #endif
  154: /* DES_64_CBC_WITH_MD5 */
  155:         {
  156:         1,
  157:         SSL2_TXT_DES_64_CBC_WITH_MD5,
  158:         SSL2_CK_DES_64_CBC_WITH_MD5,
  159:         SSL_kRSA|SSL_aRSA|SSL_DES|SSL_MD5|SSL_SSLV2,
  160:         SSL_NOT_EXP|SSL_LOW,
  161:         0,
  162:         56,
  163:         56,
  164:         SSL_ALL_CIPHERS,
  165:         SSL_ALL_STRENGTHS,
  166:         },
  167: /* DES_192_EDE3_CBC_WITH_MD5 */
  168:         {
  169:         1,
  170:         SSL2_TXT_DES_192_EDE3_CBC_WITH_MD5,
  171:         SSL2_CK_DES_192_EDE3_CBC_WITH_MD5,
  172:         SSL_kRSA|SSL_aRSA|SSL_3DES|SSL_MD5|SSL_SSLV2,
  173:         SSL_NOT_EXP|SSL_HIGH,
  174:         0,
  175:         168,
  176:         168,
  177:         SSL_ALL_CIPHERS,
  178:         SSL_ALL_STRENGTHS,
  179:         },
  180: /* RC4_64_WITH_MD5 */
  181: #if 0
  182:         {
  183:         1,
  184:         SSL2_TXT_RC4_64_WITH_MD5,
  185:         SSL2_CK_RC4_64_WITH_MD5,
  186:         SSL_kRSA|SSL_aRSA|SSL_RC4|SSL_MD5|SSL_SSLV2,
  187:         SSL_NOT_EXP|SSL_LOW,
  188:         SSL2_CF_8_BYTE_ENC,
  189:         64,
  190:         64,
  191:         SSL_ALL_CIPHERS,
  192:         SSL_ALL_STRENGTHS,
  193:         },
  194: #endif
  195: /* NULL SSLeay (testing) */
  196: #if 0
  197:         {      
  198:         0,
  199:         SSL2_TXT_NULL,
  200:         SSL2_CK_NULL,
  201:         0,
  202:         SSL_STRONG_NONE,
  203:         0,
  204:         0,
  205:         0,
  206:         SSL_ALL_CIPHERS,
  207:         SSL_ALL_STRENGTHS,
  208:         },
  209: #endif
  210: 
  211: /* end of list :-) */
  212:         };
  213: 
  214: long ssl2_default_timeout(void)
  215:         {
  216:         return(300);
  217:         }
  218: 
  219: IMPLEMENT_ssl2_meth_func(sslv2_base_method,
  220:                         ssl_undefined_function,
  221:                         ssl_undefined_function,
  222:                         ssl_bad_method)
  223: 
  224: int ssl2_num_ciphers(void)
  225:         {
  226:         return(SSL2_NUM_CIPHERS);
  227:         }
  228: 
  229: SSL_CIPHER *ssl2_get_cipher(unsigned int u)
  230:         {
  231:         if (u < SSL2_NUM_CIPHERS)
  232:                 return(&(ssl2_ciphers[SSL2_NUM_CIPHERS-1-u]));
  233:         else
  234:                 return(NULL);
  235:         }
  236: 
  237: int ssl2_pending(const SSL *s)
  238:         {
  239:         return SSL_in_init(s) ? 0 : s->s2->ract_data_length;
  240:         }
  241: 
  242: int ssl2_new(SSL *s)
  243:         {
  244:         SSL2_STATE *s2;
  245: 
  246:         if ((s2=OPENSSL_malloc(sizeof *s2)) == NULL) goto err;
  247:         memset(s2,0,sizeof *s2);
  248: 
  249: #if SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER + 3 > SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER + 2
  250: #  error "assertion failed"
  251: #endif
  252: 
  253:         if ((s2->rbuf=OPENSSL_malloc(
  254:                 SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER+2)) == NULL) goto err;
  255:         /* wbuf needs one byte more because when using two-byte headers,
  256:          * we leave the first byte unused in do_ssl_write (s2_pkt.c) */
  257:         if ((s2->wbuf=OPENSSL_malloc(
  258:                 SSL2_MAX_RECORD_LENGTH_2_BYTE_HEADER+3)) == NULL) goto err;
  259:         s->s2=s2;
  260: 
  261:         ssl2_clear(s);
  262:         return(1);
  263: err:
  264:         if (s2 != NULL)
  265:                 {
  266:                 if (s2->wbuf != NULL) OPENSSL_free(s2->wbuf);
  267:                 if (s2->rbuf != NULL) OPENSSL_free(s2->rbuf);
  268:                 OPENSSL_free(s2);
  269:                 }
  270:         return(0);
  271:         }
  272: 
  273: void ssl2_free(SSL *s)
  274:         {
  275:         SSL2_STATE *s2;
  276: 
  277:         if(s == NULL)
  278:             return;
  279: 
  280:         s2=s->s2;
  281:         if (s2->rbuf != NULL) OPENSSL_free(s2->rbuf);
  282:         if (s2->wbuf != NULL) OPENSSL_free(s2->wbuf);
  283:         OPENSSL_cleanse(s2,sizeof *s2);
  284:         OPENSSL_free(s2);
  285:         s->s2=NULL;
  286:         }
  287: 
  288: void ssl2_clear(SSL *s)
  289:         {
  290:         SSL2_STATE *s2;
  291:         unsigned char *rbuf,*wbuf;
  292: 
  293:         s2=s->s2;
  294: 
  295:         rbuf=s2->rbuf;
  296:         wbuf=s2->wbuf;
  297: 
  298:         memset(s2,0,sizeof *s2);
  299: 
  300:         s2->rbuf=rbuf;
  301:         s2->wbuf=wbuf;
  302:         s2->clear_text=1;
  303:         s->packet=s2->rbuf;
  304:         s->version=SSL2_VERSION;
  305:         s->packet_length=0;
  306:         }
  307: 
  308: long ssl2_ctrl(SSL *s, int cmd, long larg, void *parg)
  309:         {
  310:         int ret=0;
  311: 
  312:         switch(cmd)
  313:                 {
  314:         case SSL_CTRL_GET_SESSION_REUSED:
  315:                 ret=s->hit;
  316:                 break;
  317:         default:
  318:                 break;
  319:                 }
  320:         return(ret);
  321:         }
  322: 
  323: long ssl2_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
  324:         {
  325:         return(0);
  326:         }
  327: 
  328: long ssl2_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
  329:         {
  330:         return(0);
  331:         }
  332: 
  333: long ssl2_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
  334:         {
  335:         return(0);
  336:         }
  337: 
  338: /* This function needs to check if the ciphers required are actually
  339:  * available */
  340: SSL_CIPHER *ssl2_get_cipher_by_char(const unsigned char *p)
  341:         {
  342:         SSL_CIPHER c,*cp;
  343:         unsigned long id;
  344: 
  345:         id=0x02000000L|((unsigned long)p[0]<<16L)|
  346:                 ((unsigned long)p[1]<<8L)|(unsigned long)p[2];
  347:         c.id=id;
  348:         cp = (SSL_CIPHER *)OBJ_bsearch((char *)&c,
  349:                 (char *)ssl2_ciphers,
  350:                 SSL2_NUM_CIPHERS,sizeof(SSL_CIPHER),
  351:                 FP_ICC ssl_cipher_id_cmp);
  352:         if ((cp == NULL) || (cp->valid == 0))
  353:                 return NULL;
  354:         else
  355:                 return cp;
  356:         }
  357: 
  358: int ssl2_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p)
  359:         {
  360:         long l;
  361: 
  362:         if (p != NULL)
  363:                 {
  364:                 l=c->id;
  365:                 if ((l & 0xff000000) != 0x02000000) return(0);
  366:                 p[0]=((unsigned char)(l>>16L))&0xFF;
  367:                 p[1]=((unsigned char)(l>> 8L))&0xFF;
  368:                 p[2]=((unsigned char)(l     ))&0xFF;
  369:                 }
  370:         return(3);
  371:         }
  372: 
  373: int ssl2_generate_key_material(SSL *s)
  374:         {
  375:         unsigned int i;
  376:         EVP_MD_CTX ctx;
  377:         unsigned char *km;
  378:         unsigned char c='0';
  379:         const EVP_MD *md5;
  380: 
  381:         md5 = EVP_md5();
  382: 
  383: #ifdef CHARSET_EBCDIC
  384:         c = os_toascii['0']; /* Must be an ASCII '0', not EBCDIC '0',
  385:                                 see SSLv2 docu */
  386: #endif
  387:         EVP_MD_CTX_init(&ctx);
  388:         km=s->s2->key_material;
  389: 
  390:         if (s->session->master_key_length < 0 ||
  391:                         s->session->master_key_length > (int)sizeof(s->session->master_key))
  392:                 {
  393:                 SSLerr(SSL_F_SSL2_GENERATE_KEY_MATERIAL, ERR_R_INTERNAL_ERROR);
  394:                 return 0;
  395:                 }
  396: 
  397:         for (i=0; i<s->s2->key_material_length; i += EVP_MD_size(md5))
  398:                 {
  399:                 if (((km - s->s2->key_material) + EVP_MD_size(md5)) >
  400:                                 (int)sizeof(s->s2->key_material))
  401:                         {
  402:                         /* EVP_DigestFinal_ex() below would write beyond buffer */
  403:                         SSLerr(SSL_F_SSL2_GENERATE_KEY_MATERIAL, ERR_R_INTERNAL_ERROR);
  404:                         return 0;
  405:                         }
  406: 
  407:                 EVP_DigestInit_ex(&ctx, md5, NULL);
  408: 
  409:                 OPENSSL_assert(s->session->master_key_length >= 0
  410:                     && s->session->master_key_length
  411:                     < (int)sizeof(s->session->master_key));
  412:                 EVP_DigestUpdate(&ctx,s->session->master_key,s->session->master_key_length);
  413:                 EVP_DigestUpdate(&ctx,&c,1);
  414:                 c++;
  415:                 EVP_DigestUpdate(&ctx,s->s2->challenge,s->s2->challenge_length);
  416:                 EVP_DigestUpdate(&ctx,s->s2->conn_id,s->s2->conn_id_length);
  417:                 EVP_DigestFinal_ex(&ctx,km,NULL);
  418:                 km += EVP_MD_size(md5);
  419:                 }
  420: 
  421:         EVP_MD_CTX_cleanup(&ctx);
  422:         return 1;
  423:         }
  424: 
  425: void ssl2_return_error(SSL *s, int err)
  426:         {
  427:         if (!s->error)
  428:                 {
  429:                 s->error=3;
  430:                 s->error_code=err;
  431: 
  432:                 ssl2_write_error(s);
  433:                 }
  434:         }
  435: 
  436: 
  437: void ssl2_write_error(SSL *s)
  438:         {
  439:         unsigned char buf[3];
  440:         int i,error;
  441: 
  442:         buf[0]=SSL2_MT_ERROR;
  443:         buf[1]=(s->error_code>>8)&0xff;
  444:         buf[2]=(s->error_code)&0xff;
  445: 
  446: /*      state=s->rwstate;*/
  447: 
  448:         error=s->error; /* number of bytes left to write */
  449:         s->error=0;
  450:         OPENSSL_assert(error >= 0 && error <= (int)sizeof(buf));
  451:         i=ssl2_write(s,&(buf[3-error]),error);
  452: 
  453: /*      if (i == error) s->rwstate=state; */
  454: 
  455:         if (i < 0)
  456:                 s->error=error;
  457:         else
  458:                 {
  459:                 s->error=error-i;
  460: 
  461:                 if (s->error == 0)
  462:                         if (s->msg_callback)
  463:                                 s->msg_callback(1, s->version, 0, buf, 3, s, s->msg_callback_arg); /* ERROR */
  464:                 }
  465:         }
  466: 
  467: int ssl2_shutdown(SSL *s)
  468:         {
  469:         s->shutdown=(SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN);
  470:         return(1);
  471:         }
  472: #else /* !OPENSSL_NO_SSL2 */
  473: 
  474: # if PEDANTIC
  475: static void *dummy=&dummy;
  476: # endif
  477: 
  478: #endif