Pastebin launched a little side project called VERYVIRAL.com, check it out ;-) Want more features on Pastebin? Sign Up, it's FREE!
Guest

WTF - HOW A CLIENT SAYS HELLO

By: a guest on Apr 10th, 2014  |  syntax: C  |  size: 26.35 KB  |  views: 22,544  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. static int ssl23_client_hello(SSL *s)                                          
  2.     {                                                                          
  3.     unsigned char *buf;                                                        
  4.     unsigned char *p,*d;                                                        
  5.     int i,ch_len;                                                              
  6.     unsigned long l;                                                            
  7.     int ssl2_compat;                                                            
  8.     int version = 0, version_major, version_minor;                              
  9.     int al = 0;                                                                
  10. #ifndef OPENSSL_NO_COMP                                                        
  11.     int j;                                                                      
  12.     SSL_COMP *comp;                                                            
  13. #endif                                                                          
  14.     int ret;                                                                    
  15.     unsigned long mask, options = s->options;                                  
  16.                                                                                
  17.     ssl2_compat = (options & SSL_OP_NO_SSLv2) ? 0 : 1;                          
  18.                                                                                
  19.     if (ssl2_compat && !ssl_security(s, SSL_SECOP_SSL2_COMPAT, 0, 0, NULL))    
  20.         ssl2_compat = 0;                                                        
  21.     if (ssl2_compat && ssl23_no_ssl2_ciphers(s))                                
  22.         ssl2_compat = 0;                                                        
  23.                                                                                
  24.     /*                                                                          
  25.      * SSL_OP_NO_X disables all protocols above X *if* there are                
  26.      * some protocols below X enabled. This is required in order                
  27.      * to maintain "version capability" vector contiguous. So                  
  28.      * that if application wants to disable TLS1.0 in favour of                
  29.      * TLS1>=1, it would be insufficient to pass SSL_NO_TLSv1, the              
  30.      * answer is SSL_OP_NO_TLSv1|SSL_OP_NO_SSLv3|SSL_OP_NO_SSLv2.              
  31.      */                                                                        
  32.     mask =  SSL_OP_NO_TLSv1_1|SSL_OP_NO_TLSv1                                  
  33. #if !defined(OPENSSL_NO_SSL3)                                                  
  34.         |SSL_OP_NO_SSLv3                                                        
  35. #endif                                                                          
  36. #if !defined(OPENSSL_NO_SSL2)                                                  
  37.         |(ssl2_compat?SSL_OP_NO_SSLv2:0)                                        
  38. #endif                                                                          
  39.         ;                                                                      
  40. #if !defined(OPENSSL_NO_TLS1_2_CLIENT)                                          
  41.     version = TLS1_2_VERSION;                                                  
  42.                                                                                
  43.     if ((options & SSL_OP_NO_TLSv1_2) && (options & mask) != mask)              
  44.         version = TLS1_1_VERSION;                                              
  45. #else                                                                          
  46.     version = TLS1_1_VERSION;                                                  
  47. #endif                                                                          
  48.     mask &= ~SSL_OP_NO_TLSv1_1;                                                
  49.     if ((options & SSL_OP_NO_TLSv1_1) && (options & mask) != mask)              
  50.         version = TLS1_VERSION;                                                
  51.     mask &= ~SSL_OP_NO_TLSv1;                                                  
  52. #if !defined(OPENSSL_NO_SSL3)                                                  
  53.     if ((options & SSL_OP_NO_TLSv1) && (options & mask) != mask)                
  54.         version = SSL3_VERSION;                                                
  55.     mask &= ~SSL_OP_NO_SSLv3;                                                  
  56. #endif
  57. #if !defined(OPENSSL_NO_SSL2)                                                  
  58.     if ((options & SSL_OP_NO_SSLv3) && (options & mask) != mask)                
  59.         version = SSL2_VERSION;                                                
  60. #endif                                                                          
  61.                                                                                
  62. #ifndef OPENSSL_NO_TLSEXT                                                      
  63.     if (version != SSL2_VERSION)                                                
  64.         {                                                                      
  65.         /* have to disable SSL 2.0 compatibility if we need TLS extensions */  
  66.                                                                                
  67.         if (s->tlsext_hostname != NULL)                                        
  68.             ssl2_compat = 0;                                                    
  69.         if (s->tlsext_status_type != -1)                                        
  70.             ssl2_compat = 0;                                                    
  71. #ifdef TLSEXT_TYPE_opaque_prf_input                                            
  72.         if (s->ctx->tlsext_opaque_prf_input_callback != 0 || s->tlsext_opaque_prf_input != NULL)
  73.             ssl2_compat = 0;                                                    
  74. #endif                                                                          
  75.         if (s->ctx->custom_cli_ext_records_count != 0)                          
  76.             ssl2_compat = 0;                                                    
  77.         if (s->ctx->cli_supp_data_records_count != 0)                          
  78.             ssl2_compat = 0;                                                    
  79.         }                                                                      
  80. #endif                                                                          
  81.                                                                                
  82.     buf=(unsigned char *)s->init_buf->data;                                    
  83.     if (s->state == SSL23_ST_CW_CLNT_HELLO_A)                                  
  84.         {                                                                      
  85. #if 0                                                                          
  86.         /* don't reuse session-id's */                                          
  87.         if (!ssl_get_new_session(s,0))                                          
  88.             {                                                                  
  89.             return(-1);                                                        
  90.             }                                                                  
  91. #endif        
  92.        p=s->s3->client_random;                                                
  93.         if (ssl_fill_hello_random(s, 0, p, SSL3_RANDOM_SIZE) <= 0)              
  94.             return -1;                                                          
  95.                                                                                
  96.         if (version == TLS1_2_VERSION)                                          
  97.             {                                                                  
  98.             version_major = TLS1_2_VERSION_MAJOR;                              
  99.             version_minor = TLS1_2_VERSION_MINOR;                              
  100.             }                                                                  
  101.         else if (tls1_suiteb(s))                                                
  102.             {                                                                  
  103.             SSLerr(SSL_F_SSL23_CLIENT_HELLO,                                    
  104.                     SSL_R_ONLY_TLS_1_2_ALLOWED_IN_SUITEB_MODE);                
  105.             return -1;                                                          
  106.             }                                                                  
  107.         else if (version == TLS1_1_VERSION)                                    
  108.             {                                                                  
  109.             version_major = TLS1_1_VERSION_MAJOR;                              
  110.             version_minor = TLS1_1_VERSION_MINOR;                              
  111.             }                                                                  
  112.         else if (version == TLS1_VERSION)                                      
  113.             {                                                                  
  114.             version_major = TLS1_VERSION_MAJOR;                                
  115.             version_minor = TLS1_VERSION_MINOR;                                
  116.             }                                                                  
  117. #ifdef OPENSSL_FIPS                                                            
  118.         else if(FIPS_mode())                                                    
  119.             {                                                                  
  120.             SSLerr(SSL_F_SSL23_CLIENT_HELLO,                                    
  121.                     SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);                      
  122.             return -1;                                                          
  123.             }                                                                  
  124. #endif                                                                          
  125.         else if (version == SSL3_VERSION)                                      
  126.             {                                                                  
  127.             version_major = SSL3_VERSION_MAJOR;                                
  128.             version_minor = SSL3_VERSION_MINOR;                                
  129.             }                                                                  
  130.         else if (version == SSL2_VERSION)                                      
  131.             {                                                                  
  132.             version_major = SSL2_VERSION_MAJOR;                                
  133.             version_minor = SSL2_VERSION_MINOR;                                
  134.             }                                                                  
  135.         else                                                                    
  136.             {                                                                  
  137.             SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_PROTOCOLS_AVAILABLE);      
  138.             return(-1);                                                        
  139.             }                                                                  
  140.                                                                                
  141.         s->client_version = version;                                            
  142.                                                                                
  143.         if (ssl2_compat)                                                        
  144.             {                                                                  
  145.             /* create SSL 2.0 compatible Client Hello */                        
  146.                                                                                
  147.             /* two byte record header will be written last */                  
  148.             d = &(buf[2]);                                                      
  149.             p = d + 9; /* leave space for message type, version, individual length fields */
  150.                                                                                
  151.             *(d++) = SSL2_MT_CLIENT_HELLO;                                      
  152.             *(d++) = version_major;                                            
  153.             *(d++) = version_minor;                                            
  154.                                                                                
  155.             /* Ciphers supported */                                            
  156.             i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),p,0);              
  157.             if (i == 0)                                                        
  158.                 {                                                              
  159.                 /* no ciphers */                                                
  160.                 SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE);    
  161.                return -1;                                                      
  162.                 }                                                              
  163.             s2n(i,d);                                                          
  164.             p+=i;                                                              
  165.                                                                                
  166.             /* put in the session-id length (zero since there is no reuse) */  
  167. #if 0                                                                          
  168.             s->session->session_id_length=0;                                    
  169. #endif                                                                          
  170.             s2n(0,d);                                                          
  171.                                                                                
  172.             if (s->options & SSL_OP_NETSCAPE_CHALLENGE_BUG)                    
  173.                 ch_len=SSL2_CHALLENGE_LENGTH;                                  
  174.             else                                                                
  175.                 ch_len=SSL2_MAX_CHALLENGE_LENGTH;                              
  176.                                                                                
  177.             /* write out sslv2 challenge */                                    
  178.             /* Note that ch_len must be <= SSL3_RANDOM_SIZE (32),              
  179.                because it is one of SSL2_MAX_CHALLENGE_LENGTH (32)              
  180.                or SSL2_MAX_CHALLENGE_LENGTH (16), but leave the                
  181.                check in for futurproofing */                                    
  182.             if (SSL3_RANDOM_SIZE < ch_len)                                      
  183.                 i=SSL3_RANDOM_SIZE;                                            
  184.             else                                                                
  185.                 i=ch_len;                                                      
  186.             s2n(i,d);                                                          
  187.             memset(&(s->s3->client_random[0]),0,SSL3_RANDOM_SIZE);              
  188.             if (RAND_pseudo_bytes(&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i) <= 0)
  189.                 return -1;                                                      
  190.                                                                                
  191.             memcpy(p,&(s->s3->client_random[SSL3_RANDOM_SIZE-i]),i);            
  192.             p+=i;                                                              
  193.                                                                                
  194.             i= p- &(buf[2]);                                                    
  195.             buf[0]=((i>>8)&0xff)|0x80;                                          
  196.             buf[1]=(i&0xff);                                                    
  197.                                                                                
  198.             /* number of bytes to write */                                      
  199.             s->init_num=i+2;                                                    
  200.             s->init_off=0;                                                      
  201.                                                                                
  202.             ssl3_finish_mac(s,&(buf[2]),i);                                    
  203.             }                                                                  
  204.         else                                                                    
  205.             {                                                                  
  206.             /* create Client Hello in SSL 3.0/TLS 1.0 format */                
  207.                                                                                
  208.             /* do the record header (5 bytes) and handshake message header (4 bytes) last */
  209.             d = p = &(buf[9]);                                                  
  210.                                                                                
  211.             *(p++) = version_major;                                            
  212.             *(p++) = version_minor;                                            
  213.                                                                                
  214.             /* Random stuff */                                                  
  215.             memcpy(p, s->s3->client_random, SSL3_RANDOM_SIZE);                  
  216.             p += SSL3_RANDOM_SIZE;                                              
  217.                                                                                
  218.             /* Session ID (zero since there is no reuse) */                    
  219.             *(p++) = 0;                                                        
  220.                                                                                
  221.             /* Ciphers supported (using SSL 3.0/TLS 1.0 format) */              
  222.             i=ssl_cipher_list_to_bytes(s,SSL_get_ciphers(s),&(p[2]),ssl3_put_cipher_by_char);
  223.             if (i == 0)                                                        
  224.                 {                                                              
  225.                 SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_NO_CIPHERS_AVAILABLE);    
  226.                 return -1;                                                      
  227.                 }                                                              
  228. #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH                                        
  229.             /* Some servers hang if client hello > 256 bytes                    
  230.              * as hack workaround chop number of supported ciphers              
  231.              * to keep it well below this if we use TLS v1.2                    
  232.              */                                                                
  233.             if (TLS1_get_version(s) >= TLS1_2_VERSION                          
  234.                 && i > OPENSSL_MAX_TLS1_2_CIPHER_LENGTH)                        
  235.                 i = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;                      
  236. #endif                                                                          
  237.             s2n(i,p);                                                          
  238.             p+=i;                                                              
  239.                                                                                
  240.             /* COMPRESSION */                                                  
  241. #ifdef OPENSSL_NO_COMP                                                          
  242.             *(p++)=1;                                                          
  243. #else                                                                          
  244.             if (!ssl_allow_compression(s) || !s->ctx->comp_methods)            
  245.                 j=0;                                                            
  246.             else                                                                
  247.                 j=sk_SSL_COMP_num(s->ctx->comp_methods);                        
  248.             *(p++)=1+j;                                                        
  249.             for (i=0; i<j; i++)                                                
  250.                 {                                                              
  251.                 comp=sk_SSL_COMP_value(s->ctx->comp_methods,i);                
  252.                 *(p++)=comp->id;                                                
  253.                 }                                                              
  254. #endif                                                                          
  255.             *(p++)=0; /* Add the NULL method */                                
  256.                                                                                
  257. #ifndef OPENSSL_NO_TLSEXT                                                      
  258.             /* TLS extensions*/                                                
  259.             if (ssl_prepare_clienthello_tlsext(s) <= 0)                        
  260.                 {                                                              
  261.                 SSLerr(SSL_F_SSL23_CLIENT_HELLO,SSL_R_CLIENTHELLO_TLSEXT);      
  262.                 return -1;                                                      
  263.                 }                                                              
  264.             if ((p = ssl_add_clienthello_tlsext(s, p, buf+SSL3_RT_MAX_PLAIN_LENGTH, &al)) == NULL)
  265.                 {                                                              
  266.                 ssl3_send_alert(s,SSL3_AL_FATAL,al);                            
  267.                 SSLerr(SSL_F_SSL23_CLIENT_HELLO,ERR_R_INTERNAL_ERROR);          
  268.                 return -1;                                              
  269.  
  270.                }                                                              
  271. #endif                                                                          
  272.                                                                                
  273.             l = p-d;                                                            
  274.                                                                                
  275.             /* fill in 4-byte handshake header */                              
  276.             d=&(buf[5]);                                                        
  277.             *(d++)=SSL3_MT_CLIENT_HELLO;                                        
  278.             l2n3(l,d);                                                          
  279.                                                                                
  280.             l += 4;                                                            
  281.                                                                                
  282.             if (l > SSL3_RT_MAX_PLAIN_LENGTH)                                  
  283.                 {                                                              
  284.                 SSLerr(SSL_F_SSL23_CLIENT_HELLO,ERR_R_INTERNAL_ERROR);          
  285.                 return -1;                                                      
  286.                 }                                                              
  287.                                                                                
  288.             /* fill in 5-byte record header */                                  
  289.             d=buf;                                                              
  290.             *(d++) = SSL3_RT_HANDSHAKE;                                        
  291.             *(d++) = version_major;                                            
  292.             /* Some servers hang if we use long client hellos                  
  293.              * and a record number > TLS 1.0.                                  
  294.              */                                                                
  295.             if (TLS1_get_client_version(s) > TLS1_VERSION)                      
  296.                 *(d++) = 1;                                                    
  297.             else                                                                
  298.                 *(d++) = version_minor;                                        
  299.             s2n((int)l,d);                                                      
  300.                                                                                
  301.             /* number of bytes to write */                                      
  302.             s->init_num=p-buf;                                                  
  303.             s->init_off=0;                                                      
  304.                                                                                
  305.             ssl3_finish_mac(s,&(buf[5]), s->init_num - 5);                      
  306.             }                                                                  
  307.                                                                                
  308.         s->state=SSL23_ST_CW_CLNT_HELLO_B;                                      
  309.         s->init_off=0;                                                          
  310.         }                                                                      
  311.                                                                                
  312.     /* SSL3_ST_CW_CLNT_HELLO_B */                                              
  313.     ret = ssl23_write_bytes(s);                                                
  314.                                                                                
  315.     if ((ret >= 2) && s->msg_callback)                                          
  316.         {                                                                      
  317.         /* Client Hello has been sent; tell msg_callback */                    
  318.                                                                                
  319.         if (ssl2_compat)                                                        
  320.             s->msg_callback(1, SSL2_VERSION, 0, s->init_buf->data+2, ret-2, s, s->msg_callback_arg);
  321.         else                                                                    
  322.             {                                                                  
  323.             s->msg_callback(1, version, SSL3_RT_HEADER, s->init_buf->data, 5, s, s->msg_callback_arg);
  324.             s->msg_callback(1, version, SSL3_RT_HANDSHAKE, s->init_buf->data+5, ret-5, s, s->msg_callback_arg);
  325.             }                                                                  
  326.         }                                                                      
  327.                                                                                
  328.     return ret;                                                                
  329.     }