epan/dissectors/packet-ssl-utils.c

   1 /* packet-ssl-utils.c
   2  *
   3  * $Id$
   4  *
   5  * ssl manipulation functions
   6  * By Paolo Abeni <paolo.abeni@email.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include "config.h"
  25 #endif
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include "packet-ssl-utils.h"
  31
  32 #include <epan/emem.h>
  33
  34 static gint ver_major, ver_minor, ver_patch;
  35
  36 void
  37 ssl_data_set(StringInfo* str, const guchar* data, guint len)
  38 {
  39     memcpy(str->data, data, len);
  40     str->data_len = len;
  41 }
  42
  43 #ifdef HAVE_LIBGNUTLS
  44
  45 /* hmac abstraction layer */
  46 #define SSL_HMAC gcry_md_hd_t
  47
  48 static inline void
  49 ssl_hmac_init(SSL_HMAC* md, const void * key, gint len, gint algo)
  50 {
  51     gcry_md_open(md,algo, GCRY_MD_FLAG_HMAC);
  52     gcry_md_setkey (*(md), key, len);
  53 }
  54 static inline void
  55 ssl_hmac_update(SSL_HMAC* md, const void* data, gint len)
  56 {
  57     gcry_md_write(*(md), data, len);
  58 }
  59 static inline void
  60 ssl_hmac_final(SSL_HMAC* md, guchar* data, guint* datalen)
  61 {
  62     gint algo;
  63     guint len;
  64     algo = gcry_md_get_algo (*(md));
  65     len = gcry_md_get_algo_dlen(algo);
  66     memcpy(data, gcry_md_read(*(md), algo), len);
  67     *datalen =len;
  68 }
  69 static inline void
  70 ssl_hmac_cleanup(SSL_HMAC* md)
  71 {
  72     gcry_md_close(*(md));
  73 }
  74
  75 /* memory digest abstraction layer*/
  76 #define SSL_MD gcry_md_hd_t
  77
  78 static inline void
  79 ssl_md_init(SSL_MD* md, gint algo)
  80 {
  81     gcry_md_open(md,algo, 0);
  82 }
  83 static inline void
  84 ssl_md_update(SSL_MD* md, guchar* data, gint len)
  85 {
  86     gcry_md_write(*(md), data, len);
  87 }
  88 static inline void
  89 ssl_md_final(SSL_MD* md, guchar* data, guint* datalen)
  90 {
  91     gint algo;
  92     gint len;
  93     algo = gcry_md_get_algo (*(md));
  94     len = gcry_md_get_algo_dlen (algo);
  95     memcpy(data, gcry_md_read(*(md),  algo), len);
  96     *datalen = len;
  97 }
  98 static inline void
  99 ssl_md_cleanup(SSL_MD* md)
 100 {
 101     gcry_md_close(*(md));
 102 }
 103
 104 /* md5 /sha abstraction layer */
 105 #define SSL_SHA_CTX gcry_md_hd_t
 106 #define SSL_MD5_CTX gcry_md_hd_t
 107
 108 static inline void
 109 ssl_sha_init(SSL_SHA_CTX* md)
 110 {
 111     gcry_md_open(md,GCRY_MD_SHA1, 0);
 112 }
 113 static inline void
 114 ssl_sha_update(SSL_SHA_CTX* md, guchar* data, gint len)
 115 {
 116     gcry_md_write(*(md), data, len);
 117 }
 118 static inline void
 119 ssl_sha_final(guchar* buf, SSL_SHA_CTX* md)
 120 {
 121     memcpy(buf, gcry_md_read(*(md),  GCRY_MD_SHA1),
 122         gcry_md_get_algo_dlen(GCRY_MD_SHA1));
 123 }
 124 static inline void
 125 ssl_sha_cleanup(SSL_SHA_CTX* md)
 126 {
 127     gcry_md_close(*(md));
 128 }
 129
 130 static inline gint
 131 ssl_md5_init(SSL_MD5_CTX* md)
 132 {
 133     return gcry_md_open(md,GCRY_MD_MD5, 0);
 134 }
 135 static inline void
 136 ssl_md5_update(SSL_MD5_CTX* md, guchar* data, gint len)
 137 {
 138     gcry_md_write(*(md), data, len);
 139 }
 140 static inline void
 141 ssl_md5_final(guchar* buf, SSL_MD5_CTX* md)
 142 {
 143     memcpy(buf, gcry_md_read(*(md),  GCRY_MD_MD5),
 144         gcry_md_get_algo_dlen(GCRY_MD_MD5));
 145 }
 146 static inline void
 147 ssl_md5_cleanup(SSL_MD5_CTX* md)
 148 {
 149     gcry_md_close(*(md));
 150 }
 151
 152 gint
 153 ssl_cipher_setiv(SSL_CIPHER_CTX *cipher, guchar* iv, gint iv_len)
 154 {
 155   /* guchar * ivp; */
 156   gint ret;
 157   /* gint i; */
 158   gcry_cipher_hd_t c;
 159   ret=0;
 160   c=(gcry_cipher_hd_t)*cipher;
 161
 162   ssl_debug_printf("--------------------------------------------------------------------");
 163   /*for(ivp=c->iv,i=0; i < iv_len; i++ )
 164     {
 165       ssl_debug_printf("%d ",ivp[i]);
 166       i++;
 167     }
 168   */
 169   ssl_debug_printf("--------------------------------------------------------------------");
 170   ret = gcry_cipher_setiv(*(cipher), iv, iv_len);
 171   /*for(ivp=c->iv,i=0; i < iv_len; i++ )
 172     {
 173       ssl_debug_printf("%d ",ivp[i]);
 174       i++;
 175     }
 176   */
 177   ssl_debug_printf("--------------------------------------------------------------------");
 178   return ret;
 179 }
 180 /* stream cipher abstraction layer*/
 181 static gint
 182 ssl_cipher_init(gcry_cipher_hd_t *cipher, gint algo, guchar* sk,
 183         guchar* iv, gint mode)
 184 {
 185     gint gcry_modes[]={GCRY_CIPHER_MODE_STREAM,GCRY_CIPHER_MODE_CBC};
 186     gint err;
 187     err = gcry_cipher_open(cipher, algo, gcry_modes[mode], 0);
 188     if (err !=0)
 189         return  -1;
 190     err = gcry_cipher_setkey(*(cipher), sk, gcry_cipher_get_algo_keylen (algo));
 191     if (err != 0)
 192         return -1;
 193     err = gcry_cipher_setiv(*(cipher), iv, gcry_cipher_get_algo_blklen (algo));
 194     if (err != 0)
 195         return -1;
 196     return 0;
 197 }
 198 static inline gint
 199 ssl_cipher_decrypt(gcry_cipher_hd_t *cipher, guchar * out, gint outl,
 200                    const guchar * in, gint inl)
 201 {
 202     return gcry_cipher_decrypt ( *(cipher), out, outl, in, inl);
 203 }
 204 static inline gint
 205 ssl_get_digest_by_name(const gchar*name)
 206 {
 207     return gcry_md_map_name(name);
 208 }
 209 static inline gint
 210 ssl_get_cipher_by_name(const gchar* name)
 211 {
 212     return gcry_cipher_map_name(name);
 213 }
 214
 215 static inline void
 216 ssl_cipher_cleanup(gcry_cipher_hd_t *cipher)
 217 {
 218     gcry_cipher_close(*cipher);
 219     *cipher = NULL;
 220 }
 221
 222 /* private key abstraction layer */
 223 static inline gint
 224 ssl_get_key_len(SSL_PRIVATE_KEY* pk) {return gcry_pk_get_nbits (pk); }
 225
 226 gcry_err_code_t
 227 _gcry_rsa_decrypt (int algo, gcry_mpi_t *result, gcry_mpi_t *data,
 228                    gcry_mpi_t *skey, gint flags);
 229
 230 #define PUBKEY_FLAG_NO_BLINDING (1 << 0)
 231
 232 /* decrypt data with private key. Store decrypted data directly into input
 233  * buffer */
 234 int
 235 ssl_private_decrypt(guint len, guchar* encr_data, SSL_PRIVATE_KEY* pk)
 236 {
 237     gint rc;
 238     size_t decr_len;
 239     gcry_sexp_t  s_data, s_plain;
 240     gcry_mpi_t encr_mpi;
 241     size_t i, encr_len;
 242     guchar* decr_data_ptr;
 243     gcry_mpi_t text;
 244     decr_len = 0;
 245     encr_len = len;
 246     text=NULL;
 247     /* build up a mpi rappresentation for encrypted data */
 248     rc = gcry_mpi_scan(&encr_mpi, GCRYMPI_FMT_USG,encr_data, encr_len, &encr_len);
 249     if (rc != 0 ) {
 250         ssl_debug_printf("pcry_private_decrypt: can't convert encr_data to mpi (size %d):%s\n",
 251             len, gcry_strerror(rc));
 252         return 0;
 253     }
 254
 255 #ifndef SSL_FAST
 256     /* put the data into a simple list */
 257     rc = gcry_sexp_build(&s_data, NULL, "(enc-val(rsa(a%m)))", encr_mpi);
 258     if (rc != 0) {
 259         ssl_debug_printf("pcry_private_decrypt: can't build encr_sexp:%s \n",
 260              gcry_strerror(rc));
 261         return 0;
 262     }
 263
 264     /* pass it to libgcrypt */
 265     rc = gcry_pk_decrypt(&s_plain, s_data, pk);
 266     gcry_sexp_release(s_data);
 267     if (rc != 0)
 268     {
 269         ssl_debug_printf("pcry_private_decrypt: can't decrypt key:%s\n",
 270             gcry_strerror(rc));
 271         goto out;
 272     }
 273
 274     /* convert plain text sexp to mpi format */
 275     text = gcry_sexp_nth_mpi(s_plain, 0, 0);
 276
 277     /* compute size requested for plaintext buffer */
 278     decr_len = len;
 279     if (gcry_mpi_print(GCRYMPI_FMT_USG, NULL, decr_len, &decr_len, text) != 0) {
 280         ssl_debug_printf("pcry_private_decrypt: can't compute decr size:%s\n",
 281             gcry_strerror(rc));
 282         decr_len = 0;
 283         goto out;
 284     }
 285
 286     /* sanity check on out buffer */
 287     if (decr_len > len) {
 288         ssl_debug_printf("pcry_private_decrypt: decrypted data is too long ?!? (%d max %d)\n",
 289             decr_len, len);
 290         return 0;
 291     }
 292
 293     /* write plain text to encrypted data buffer */
 294     decr_data_ptr = encr_data;
 295     if (gcry_mpi_print( GCRYMPI_FMT_USG, decr_data_ptr, decr_len, &decr_len,
 296             text) != 0) {
 297         ssl_debug_printf("pcry_private_decrypt: can't print decr data to mpi (size %d):%s\n",
 298             decr_len, gcry_strerror(rc));
 299         g_free(decr_data_ptr);
 300         decr_len = 0;
 301         goto out;
 302     }
 303
 304     /* strip the padding*/
 305     rc = 0;
 306     for (i = 1; i < decr_len; i++) {
 307         if (decr_data_ptr[i] == 0) {
 308             rc = i+1;
 309             break;
 310         }
 311     }
 312
 313     ssl_debug_printf("pcry_private_decrypt: stripping %d bytes, decr_len %d\n",
 314         rc, decr_len);
 315     ssl_print_data("decypted_unstrip_pre_master", decr_data_ptr, decr_len);
 316     g_memmove(decr_data_ptr, &decr_data_ptr[rc], decr_len - rc);
 317     decr_len -= rc;
 318
 319 out:
 320     gcry_sexp_release(s_plain);
 321 #else /* SSL_FAST */
 322     rc = _gcry_rsa_decrypt(0, &text,  &encr_mpi, pk,0);
 323     gcry_mpi_print( GCRYMPI_FMT_USG, 0, 0, &decr_len, text);
 324
 325     /* sanity check on out buffer */
 326     if (decr_len > len) {
 327         ssl_debug_printf("pcry_private_decrypt: decrypted data is too long ?!? (%d max %d)\n",
 328             decr_len, len);
 329         return 0;
 330     }
 331
 332     /* write plain text to newly allocated buffer */
 333     decr_data_ptr = encr_data;
 334     if (gcry_mpi_print( GCRYMPI_FMT_USG, decr_data_ptr, decr_len, &decr_len,
 335             text) != 0) {
 336         ssl_debug_printf("pcry_private_decrypt: can't print decr data to mpi (size %d):%s\n",
 337             decr_len, gcry_strerror(rc));
 338         return 0;
 339     }
 340
 341     /* strip the padding*/
 342     rc = 0;
 343     for (i = 1; i < decr_len; i++) {
 344         if (decr_data_ptr[i] == 0) {
 345             rc = i+1;
 346             break;
 347         }
 348     }
 349
 350     ssl_debug_printf("pcry_private_decrypt: stripping %d bytes, decr_len %d\n",
 351         rc, decr_len);
 352     ssl_print_data("decypted_unstrip_pre_master", decr_data_ptr, decr_len);
 353     g_memmove(decr_data_ptr, &decr_data_ptr[rc], decr_len - rc);
 354     decr_len -= rc;
 355 #endif /* SSL_FAST */
 356     gcry_mpi_release(text);
 357     return decr_len;
 358 }
 359
 360 /* stringinfo interface */
 361 static gint
 362 ssl_data_alloc(StringInfo* str, guint len)
 363 {
 364     str->data = g_malloc(len);
 365     if (!str->data)
 366         return -1;
 367     str->data_len = len;
 368     return 0;
 369 }
 370
 371 #define PRF(ssl,secret,usage,rnd1,rnd2,out) ((ssl->version_netorder==SSLV3_VERSION)? \
 372         ssl3_prf(secret,usage,rnd1,rnd2,out): \
 373         tls_prf(secret,usage,rnd1,rnd2,out))
 374
 375 static const gchar *digests[]={
 376      "MD5",
 377      "SHA1"
 378 };
 379
 380 static const gchar *ciphers[]={
 381      "DES",
 382      "3DES",
 383      "ARCFOUR", /* gnutls does not support rc4, but this should be 100% compatible*/
 384      "RC2",
 385      "IDEA",
 386      "AES",
 387      "AES256",
 388      "*UNKNOWN*"
 389 };
 390
 391 /* look in openssl/ssl/ssl_lib.c for a complete list of available cipersuite*/
 392 static SslCipherSuite cipher_suites[]={
 393     {1,KEX_RSA,SIG_RSA,ENC_NULL,0,0,0,DIG_MD5,16,0, SSL_CIPHER_MODE_STREAM},
 394     {2,KEX_RSA,SIG_RSA,ENC_NULL,0,0,0,DIG_SHA,20,0, SSL_CIPHER_MODE_STREAM},
 395     {3,KEX_RSA,SIG_RSA,ENC_RC4,1,128,40,DIG_MD5,16,1, SSL_CIPHER_MODE_STREAM},
 396     {4,KEX_RSA,SIG_RSA,ENC_RC4,1,128,128,DIG_MD5,16,0, SSL_CIPHER_MODE_STREAM},
 397     {5,KEX_RSA,SIG_RSA,ENC_RC4,1,128,128,DIG_SHA,20,0, SSL_CIPHER_MODE_STREAM},
 398     {6,KEX_RSA,SIG_RSA,ENC_RC2,8,128,40,DIG_SHA,20,1, SSL_CIPHER_MODE_STREAM},
 399     {7,KEX_RSA,SIG_RSA,ENC_IDEA,8,128,128,DIG_SHA,20,0, SSL_CIPHER_MODE_STREAM},
 400     {8,KEX_RSA,SIG_RSA,ENC_DES,8,64,40,DIG_SHA,20,1, SSL_CIPHER_MODE_CBC},
 401     {9,KEX_RSA,SIG_RSA,ENC_DES,8,64,64,DIG_SHA,20,0, SSL_CIPHER_MODE_CBC},
 402     {10,KEX_RSA,SIG_RSA,ENC_3DES,8,192,192,DIG_SHA,20,0, SSL_CIPHER_MODE_CBC},
 403     {11,KEX_DH,SIG_DSS,ENC_DES,8,64,40,DIG_SHA,20,1, SSL_CIPHER_MODE_STREAM},
 404     {12,KEX_DH,SIG_DSS,ENC_DES,8,64,64,DIG_SHA,20,0, SSL_CIPHER_MODE_STREAM},
 405     {13,KEX_DH,SIG_DSS,ENC_3DES,8,192,192,DIG_SHA,20,0, SSL_CIPHER_MODE_STREAM},
 406     {14,KEX_DH,SIG_RSA,ENC_DES,8,64,40,DIG_SHA,20,1, SSL_CIPHER_MODE_STREAM},
 407     {15,KEX_DH,SIG_RSA,ENC_DES,8,64,64,DIG_SHA,20,0, SSL_CIPHER_MODE_STREAM},
 408     {16,KEX_DH,SIG_RSA,ENC_3DES,8,192,192,DIG_SHA,20,0, SSL_CIPHER_MODE_STREAM},
 409     {17,KEX_DH,SIG_DSS,ENC_DES,8,64,40,DIG_SHA,20,1, SSL_CIPHER_MODE_STREAM},
 410     {18,KEX_DH,SIG_DSS,ENC_DES,8,64,64,DIG_SHA,20,0, SSL_CIPHER_MODE_STREAM},
 411     {19,KEX_DH,SIG_DSS,ENC_3DES,8,192,192,DIG_SHA,20,0, SSL_CIPHER_MODE_STREAM},
 412     {20,KEX_DH,SIG_RSA,ENC_DES,8,64,40,DIG_SHA,20,1, SSL_CIPHER_MODE_STREAM},
 413     {21,KEX_DH,SIG_RSA,ENC_DES,8,64,64,DIG_SHA,20,0, SSL_CIPHER_MODE_STREAM},
 414     {22,KEX_DH,SIG_RSA,ENC_3DES,8,192,192,DIG_SHA,20,0, SSL_CIPHER_MODE_STREAM},
 415     {23,KEX_DH,SIG_NONE,ENC_RC4,1,128,40,DIG_MD5,16,1, SSL_CIPHER_MODE_STREAM},
 416     {24,KEX_DH,SIG_NONE,ENC_RC4,1,128,128,DIG_MD5,16,0, SSL_CIPHER_MODE_STREAM},
 417     {25,KEX_DH,SIG_NONE,ENC_DES,8,64,40,DIG_MD5,16,1, SSL_CIPHER_MODE_STREAM},
 418     {26,KEX_DH,SIG_NONE,ENC_DES,8,64,64,DIG_MD5,16,0, SSL_CIPHER_MODE_STREAM},
 419     {27,KEX_DH,SIG_NONE,ENC_3DES,8,192,192,DIG_MD5,16,0, SSL_CIPHER_MODE_STREAM},
 420     {47,KEX_RSA,SIG_RSA,ENC_AES,16,128,128,DIG_SHA,20,0, SSL_CIPHER_MODE_CBC},
 421     {53,KEX_RSA,SIG_RSA,ENC_AES256,16,256,256,DIG_SHA,20,0, SSL_CIPHER_MODE_CBC},
 422     {96,KEX_RSA,SIG_RSA,ENC_RC4,1,128,56,DIG_MD5,16,1, SSL_CIPHER_MODE_STREAM},
 423     {97,KEX_RSA,SIG_RSA,ENC_RC2,1,128,56,DIG_MD5,16,1, SSL_CIPHER_MODE_STREAM},
 424     {98,KEX_RSA,SIG_RSA,ENC_DES,8,64,64,DIG_SHA,20,1, SSL_CIPHER_MODE_STREAM},
 425     {99,KEX_DH,SIG_DSS,ENC_DES,8,64,64,DIG_SHA,16,1, SSL_CIPHER_MODE_STREAM},
 426     {100,KEX_RSA,SIG_RSA,ENC_RC4,1,128,56,DIG_SHA,20,1, SSL_CIPHER_MODE_STREAM},
 427     {101,KEX_DH,SIG_DSS,ENC_RC4,1,128,56,DIG_SHA,20,1, SSL_CIPHER_MODE_STREAM},
 428     {102,KEX_DH,SIG_DSS,ENC_RC4,1,128,128,DIG_SHA,20,0, SSL_CIPHER_MODE_STREAM},
 429     {-1, 0,0,0,0,0,0,0,0,0, 0}
 430 };
 431
 432 #define MAX_BLOCK_SIZE 16
 433 #define MAX_KEY_SIZE 32
 434
 435 int
 436 ssl_find_cipher(int num,SslCipherSuite* cs)
 437 {
 438     SslCipherSuite *c;
 439
 440     for(c=cipher_suites;c->number!=-1;c++){
 441         if(c->number==num){
 442             *cs=*c;
 443             return 0;
 444         }
 445     }
 446
 447     return -1;
 448 }
 449
 450 static gint
 451 tls_hash(StringInfo* secret,
 452         StringInfo* seed, gint md, StringInfo* out)
 453 {
 454     guint8 *ptr;
 455     guint left;
 456     gint tocpy;
 457     guint8 *A;
 458     guint8 _A[20],tmp[20];
 459     guint A_l,tmp_l;
 460     SSL_HMAC hm;
 461     ptr=out->data;
 462     left=out->data_len;
 463
 464
 465     ssl_print_string("tls_hash: hash secret", secret);
 466     ssl_print_string("tls_hash: hash seed", seed);
 467     A=seed->data;
 468     A_l=seed->data_len;
 469
 470     while(left){
 471         ssl_hmac_init(&hm,secret->data,secret->data_len,md);
 472         ssl_hmac_update(&hm,A,A_l);
 473         ssl_hmac_final(&hm,_A,&A_l);
 474         ssl_hmac_cleanup(&hm);
 475         A=_A;
 476
 477         ssl_hmac_init(&hm,secret->data,secret->data_len,md);
 478         ssl_hmac_update(&hm,A,A_l);
 479         ssl_hmac_update(&hm,seed->data,seed->data_len);
 480         ssl_hmac_final(&hm,tmp,&tmp_l);
 481         ssl_hmac_cleanup(&hm);
 482
 483         tocpy=MIN(left,tmp_l);
 484         memcpy(ptr,tmp,tocpy);
 485         ptr+=tocpy;
 486         left-=tocpy;
 487     }
 488
 489     ssl_print_string("hash out", out);
 490     return (0);
 491 }
 492
 493 static gint
 494 tls_prf(StringInfo* secret, const gchar *usage,
 495         StringInfo* rnd1, StringInfo* rnd2, StringInfo* out)
 496 {
 497     StringInfo seed, sha_out, md5_out;
 498     guint8 *ptr;
 499     StringInfo s1, s2;
 500     guint i,s_l, r;
 501     gint usage_len;
 502     r=-1;
 503     usage_len = strlen(usage);
 504
 505     /* initalize buffer for sha, md5 random seed*/
 506     if (ssl_data_alloc(&sha_out, MAX(out->data_len,20)) < 0)
 507         return -1;
 508     if (ssl_data_alloc(&md5_out, MAX(out->data_len,16)) < 0)
 509         goto free_sha;
 510     if (ssl_data_alloc(&seed, usage_len+rnd1->data_len+rnd2->data_len) < 0)
 511         goto free_md5;
 512
 513     ptr=seed.data;
 514     memcpy(ptr,usage,usage_len); ptr+=usage_len;
 515     memcpy(ptr,rnd1->data,rnd1->data_len); ptr+=rnd1->data_len;
 516     memcpy(ptr,rnd2->data,rnd2->data_len); ptr+=rnd2->data_len;
 517
 518     /* initalize buffer for client/server seeds*/
 519     s_l=secret->data_len/2 + secret->data_len%2;
 520     if (ssl_data_alloc(&s1, s_l) < 0)
 521         goto free_seed;
 522     if (ssl_data_alloc(&s2, s_l) < 0)
 523         goto free_s1;
 524
 525     memcpy(s1.data,secret->data,s_l);
 526     memcpy(s2.data,secret->data + (secret->data_len - s_l),s_l);
 527
 528     ssl_debug_printf("tls_prf: tls_hash(md5 secret_len %d seed_len %d )\n", s1.data_len, seed.data_len);
 529     if(tls_hash(&s1,&seed,ssl_get_digest_by_name("MD5"),&md5_out) != 0)
 530         goto free_all;
 531     ssl_debug_printf("tls_prf: tls_hash(sha)\n");
 532     if(tls_hash(&s2,&seed,ssl_get_digest_by_name("SHA1"),&sha_out) != 0)
 533         goto free_all;
 534
 535     for(i=0;i<out->data_len;i++)
 536       out->data[i]=md5_out.data[i] ^ sha_out.data[i];
 537     r =0;
 538
 539     ssl_print_string("PRF out",out);
 540 free_all:
 541     free(s2.data);
 542 free_s1:
 543     free(s1.data);
 544 free_seed:
 545     free(seed.data);
 546 free_md5:
 547     free(md5_out.data);
 548 free_sha:
 549     free(sha_out.data);
 550     return r;
 551 }
 552
 553 static gint
 554 ssl3_generate_export_iv(StringInfo* r1,
 555         StringInfo* r2, StringInfo* out)
 556 {
 557     SSL_MD5_CTX md5;
 558     guint8 tmp[16];
 559
 560     ssl_md5_init(&md5);
 561     ssl_md5_update(&md5,r1->data,r1->data_len);
 562     ssl_md5_update(&md5,r2->data,r2->data_len);
 563     ssl_md5_final(tmp,&md5);
 564     ssl_md5_cleanup(&md5);
 565
 566     memcpy(out->data,tmp,out->data_len);
 567     ssl_print_string("export iv", out);
 568
 569     return(0);
 570 }
 571
 572 static gint
 573 ssl3_prf(StringInfo* secret, const gchar* usage,
 574         StringInfo* r1,
 575         StringInfo* r2,StringInfo* out)
 576 {
 577     SSL_MD5_CTX md5;
 578     SSL_SHA_CTX sha;
 579     StringInfo *rnd1,*rnd2;
 580     guint off;
 581     gint i=0,j;
 582     guint8 buf[20];
 583
 584     rnd1=r1; rnd2=r2;
 585
 586     for(off=0;off<out->data_len;off+=16){
 587         guchar outbuf[16];
 588         gint tocpy;
 589         i++;
 590
 591         ssl_debug_printf("ssl3_prf: sha1_hash(%d)\n",i);
 592         /* A, BB, CCC,  ... */
 593         for(j=0;j<i;j++){
 594             buf[j]=64+i;
 595         }
 596
 597         ssl_sha_init(&sha);
 598         ssl_sha_update(&sha,buf,i);
 599         ssl_sha_update(&sha,secret->data,secret->data_len);
 600
 601         if(!strcmp(usage,"client write key") || !strcmp(usage,"server write key")){
 602             ssl_sha_update(&sha,rnd2->data,rnd2->data_len);
 603             ssl_sha_update(&sha,rnd1->data,rnd1->data_len);
 604         }
 605         else{
 606             ssl_sha_update(&sha,rnd1->data,rnd1->data_len);
 607             ssl_sha_update(&sha,rnd2->data,rnd2->data_len);
 608         }
 609
 610         ssl_sha_final(buf,&sha);
 611         ssl_sha_cleanup(&sha);
 612
 613         ssl_debug_printf("ssl3_prf: md5_hash(%d) datalen %d\n",i,
 614             secret->data_len);
 615         ssl_md5_init(&md5);
 616         ssl_md5_update(&md5,secret->data,secret->data_len);
 617         ssl_md5_update(&md5,buf,20);
 618         ssl_md5_final(outbuf,&md5);
 619         ssl_md5_cleanup(&md5);
 620
 621         tocpy=MIN(out->data_len-off,16);
 622         memcpy(out->data+off,outbuf,tocpy);
 623     }
 624
 625     return(0);
 626 }
 627
 628 static gint
 629 ssl_create_decoder(SslDecoder *dec, SslCipherSuite *cipher_suite,
 630         guint8 *mk, guint8 *sk, guint8 *iv)
 631 {
 632     gint ciph;
 633     ciph=0;
 634     /* Find the SSLeay cipher */
 635     if(cipher_suite->enc!=ENC_NULL) {
 636         ssl_debug_printf("ssl_create_decoder CIPHER: %s\n", ciphers[cipher_suite->enc-0x30]);
 637         ciph=ssl_get_cipher_by_name(ciphers[cipher_suite->enc-0x30]);
 638     }
 639     if (ciph == 0) {
 640         ssl_debug_printf("ssl_create_decoder can't find cipher %s\n",
 641             ciphers[(cipher_suite->enc-0x30) > 7 ? 7 : (cipher_suite->enc-0x30)]);
 642         return -1;
 643     }
 644
 645     /* init mac buffer: mac storage is embedded into decoder struct to save a
 646      memory allocation and waste samo more memory*/
 647     dec->cipher_suite=cipher_suite;
 648     dec->mac_key.data = dec->_mac_key;
 649     ssl_data_set(&dec->mac_key, mk, cipher_suite->dig_len);
 650     dec->seq = 0;
 651
 652     if (dec->evp)
 653         ssl_cipher_cleanup(&dec->evp);
 654
 655     if (ssl_cipher_init(&dec->evp,ciph,sk,iv,cipher_suite->mode) < 0) {
 656         ssl_debug_printf("ssl_create_decoder: can't create cipher id:%d mode:%d\n",
 657             ciph, cipher_suite->mode);
 658         return -1;
 659     }
 660
 661     ssl_debug_printf("decoder initialized (digest len %d)\n", cipher_suite->dig_len);
 662     return 0;
 663 }
 664
 665 int
 666 ssl_generate_keyring_material(SslDecryptSession*ssl_session)
 667 {
 668     StringInfo key_block;
 669     guint8 _iv_c[MAX_BLOCK_SIZE],_iv_s[MAX_BLOCK_SIZE];
 670     guint8 _key_c[MAX_KEY_SIZE],_key_s[MAX_KEY_SIZE];
 671     gint needed;
 672     guint8 *ptr,*c_wk,*s_wk,*c_mk,*s_mk,*c_iv = _iv_c,*s_iv = _iv_s;
 673
 674     /* if master_key is not yet generate, create it now*/
 675     if (!(ssl_session->state & SSL_MASTER_SECRET)) {
 676         ssl_debug_printf("ssl_generate_keyring_material:PRF(pre_master_secret)\n");
 677         if (PRF(ssl_session,&ssl_session->pre_master_secret,"master secret",
 678                 &ssl_session->client_random,
 679                 &ssl_session->server_random, &ssl_session->master_secret)) {
 680             ssl_debug_printf("ssl_generate_keyring_material can't generate master_secret\n");
 681             return -1;
 682         }
 683         ssl_print_string("master secret",&ssl_session->master_secret);
 684     }
 685
 686     /* Compute the key block. First figure out how much data we need*/
 687     needed=ssl_session->cipher_suite.dig_len*2;
 688     needed+=ssl_session->cipher_suite.bits / 4;
 689     if(ssl_session->cipher_suite.block>1)
 690         needed+=ssl_session->cipher_suite.block*2;
 691
 692     key_block.data_len = needed;
 693     key_block.data = g_malloc(needed);
 694     if (!key_block.data) {
 695         ssl_debug_printf("ssl_generate_keyring_material can't allacate key_block\n");
 696         return -1;
 697     }
 698     ssl_debug_printf("ssl_generate_keyring_material sess key generation\n");
 699     if (PRF(ssl_session,&ssl_session->master_secret,"key expansion",
 700             &ssl_session->server_random,&ssl_session->client_random,
 701             &key_block)) {
 702         ssl_debug_printf("ssl_generate_keyring_material can't generate key_block\n");
 703         goto fail;
 704     }
 705     ssl_print_string("key expansion", &key_block);
 706
 707     ptr=key_block.data;
 708     c_mk=ptr; ptr+=ssl_session->cipher_suite.dig_len;
 709     s_mk=ptr; ptr+=ssl_session->cipher_suite.dig_len;
 710
 711     c_wk=ptr; ptr+=ssl_session->cipher_suite.eff_bits/8;
 712     s_wk=ptr; ptr+=ssl_session->cipher_suite.eff_bits/8;
 713
 714     if(ssl_session->cipher_suite.block>1){
 715         c_iv=ptr; ptr+=ssl_session->cipher_suite.block;
 716         s_iv=ptr; ptr+=ssl_session->cipher_suite.block;
 717     }
 718
 719     if(ssl_session->cipher_suite.export){
 720         StringInfo iv_c,iv_s;
 721         StringInfo key_c,key_s;
 722         StringInfo k;
 723
 724         if(ssl_session->cipher_suite.block>1){
 725
 726             /* We only have room for MAX_BLOCK_SIZE bytes IVs, but that's
 727              all we should need. This is a sanity check */
 728             if(ssl_session->cipher_suite.block>MAX_BLOCK_SIZE) {
 729                 ssl_debug_printf("ssl_generate_keyring_material cipher suite block must be at most %d nut is %d\n",
 730                     MAX_BLOCK_SIZE, ssl_session->cipher_suite.block);
 731                 goto fail;
 732             }
 733
 734             iv_c.data = _iv_c;
 735             iv_c.data_len = ssl_session->cipher_suite.block;
 736             iv_s.data = _iv_s;
 737             iv_s.data_len = ssl_session->cipher_suite.block;
 738
 739             if(ssl_session->version_netorder==SSLV3_VERSION){
 740                 ssl_debug_printf("ssl_generate_keyring_material ssl3_generate_export_iv\n");
 741                 if (ssl3_generate_export_iv(&ssl_session->client_random,
 742                         &ssl_session->server_random,&iv_c)) {
 743                     ssl_debug_printf("ssl_generate_keyring_material can't generate sslv3 client iv\n");
 744                     goto fail;
 745                 }
 746                 ssl_debug_printf("ssl_generate_keyring_material ssl3_generate_export_iv(2)\n");
 747                 if (ssl3_generate_export_iv(&ssl_session->server_random,
 748                         &ssl_session->client_random,&iv_s)) {
 749                     ssl_debug_printf("ssl_generate_keyring_material can't generate sslv3 server iv\n");
 750                     goto fail;
 751                 }
 752             }
 753             else{
 754                 guint8 _iv_block[MAX_BLOCK_SIZE * 2];
 755                 StringInfo iv_block;
 756                 StringInfo key_null;
 757                 guint8 _key_null;
 758
 759                 key_null.data = &_key_null;
 760                 key_null.data_len = 0;
 761
 762                 iv_block.data = _iv_block;
 763                 iv_block.data_len = ssl_session->cipher_suite.block*2;
 764
 765                 ssl_debug_printf("ssl_generate_keyring_material prf(iv_block)\n");
 766                 if(PRF(ssl_session,&key_null, "IV block",
 767                         &ssl_session->client_random,
 768                         &ssl_session->server_random,&iv_block)) {
 769                     ssl_debug_printf("ssl_generate_keyring_material can't generate tls31 iv block\n");
 770                     goto fail;
 771                 }
 772
 773                 memcpy(_iv_c,iv_block.data,ssl_session->cipher_suite.block);
 774                 memcpy(_iv_s,iv_block.data+ssl_session->cipher_suite.block,
 775                     ssl_session->cipher_suite.block);
 776             }
 777
 778             c_iv=_iv_c;
 779             s_iv=_iv_s;
 780         }
 781
 782         if (ssl_session->version_netorder==SSLV3_VERSION){
 783
 784             SSL_MD5_CTX md5;
 785             ssl_debug_printf("ssl_generate_keyring_material MD5(client_random)\n");
 786
 787             ssl_md5_init(&md5);
 788             ssl_md5_update(&md5,c_wk,ssl_session->cipher_suite.eff_bits/8);
 789             ssl_md5_update(&md5,ssl_session->client_random.data,
 790                 ssl_session->client_random.data_len);
 791             ssl_md5_update(&md5,ssl_session->server_random.data,
 792                 ssl_session->server_random.data_len);
 793             ssl_md5_final(_key_c,&md5);
 794             ssl_md5_cleanup(&md5);
 795             c_wk=_key_c;
 796
 797             ssl_md5_init(&md5);
 798             ssl_debug_printf("ssl_generate_keyring_material MD5(server_random)\n");
 799             ssl_md5_update(&md5,s_wk,ssl_session->cipher_suite.eff_bits/8);
 800             ssl_md5_update(&md5,ssl_session->server_random.data,
 801                 ssl_session->server_random.data_len);
 802             ssl_md5_update(&md5,ssl_session->client_random.data,
 803                 ssl_session->client_random.data_len);
 804             ssl_md5_final(_key_s,&md5);
 805             ssl_md5_cleanup(&md5);
 806             s_wk=_key_s;
 807         }
 808         else{
 809             key_c.data = _key_c;
 810             key_c.data_len = sizeof(_key_c);
 811             key_s.data = _key_s;
 812             key_s.data_len = sizeof(_key_s);
 813
 814             k.data = c_wk;
 815             k.data_len = ssl_session->cipher_suite.eff_bits/8;
 816             ssl_debug_printf("ssl_generate_keyring_material PRF(key_c)\n");
 817             if (PRF(ssl_session,&k,"client write key",
 818                     &ssl_session->client_random,
 819                     &ssl_session->server_random, &key_c)) {
 820                 ssl_debug_printf("ssl_generate_keyring_material can't generate tll31 server key \n");
 821                 goto fail;
 822             }
 823             c_wk=_key_c;
 824
 825             k.data = s_wk;
 826             k.data_len = ssl_session->cipher_suite.eff_bits/8;
 827             ssl_debug_printf("ssl_generate_keyring_material PRF(key_s)\n");
 828             if(PRF(ssl_session,&k,"server write key",
 829                     &ssl_session->client_random,
 830                     &ssl_session->server_random, &key_s)) {
 831                 ssl_debug_printf("ssl_generate_keyring_material can't generate tll31 client key \n");
 832                 goto fail;
 833             }
 834             s_wk=_key_s;
 835         }
 836     }
 837
 838     /* show key material info */
 839     ssl_print_data("Client MAC key",c_mk,ssl_session->cipher_suite.dig_len);
 840     ssl_print_data("Server MAC key",s_mk,ssl_session->cipher_suite.dig_len);
 841     ssl_print_data("Client Write key",c_wk,ssl_session->cipher_suite.bits/8);
 842     ssl_print_data("Server Write key",s_wk,ssl_session->cipher_suite.bits/8);
 843
 844     if(ssl_session->cipher_suite.block>1) {
 845         ssl_print_data("Client Write IV",c_iv,ssl_session->cipher_suite.block);
 846         ssl_print_data("Server Write IV",s_iv,ssl_session->cipher_suite.block);
 847     }
 848     else {
 849         ssl_print_data("Client Write IV",c_iv,8);
 850         ssl_print_data("Server Write IV",s_iv,8);
 851     }
 852
 853     /* create both client and server ciphers*/
 854     ssl_debug_printf("ssl_generate_keyring_material ssl_create_decoder(client)\n");
 855     if (ssl_create_decoder(&ssl_session->client,
 856             &ssl_session->cipher_suite,c_mk,c_wk,c_iv)) {
 857         ssl_debug_printf("ssl_generate_keyring_material can't init client decoder\n");
 858         goto fail;
 859     }
 860     ssl_debug_printf("ssl_generate_keyring_material ssl_create_decoder(server)\n");
 861     if (ssl_create_decoder(&ssl_session->server,
 862             &ssl_session->cipher_suite,s_mk,s_wk,s_iv)) {
 863         ssl_debug_printf("ssl_generate_keyring_material can't init client decoder\n");
 864         goto fail;
 865     }
 866
 867     ssl_debug_printf("ssl_generate_keyring_material client seq %d server seq %d\n",
 868         ssl_session->client.seq, ssl_session->server.seq);
 869     g_free(key_block.data);
 870     return 0;
 871
 872 fail:
 873     g_free(key_block.data);
 874     return -1;
 875 }
 876
 877 int
 878 ssl_decrypt_pre_master_secret(SslDecryptSession*ssl_session,
 879     StringInfo* entrypted_pre_master, SSL_PRIVATE_KEY *pk)
 880 {
 881     gint i;
 882
 883     if(ssl_session->cipher_suite.kex!=KEX_RSA) {
 884         ssl_debug_printf("ssl_decrypt_pre_master_secret key %d diferent from KEX_RSA(%d)\n",
 885             ssl_session->cipher_suite.kex, KEX_RSA);
 886         return(-1);
 887     }
 888
 889     /* with tls key loading will fail if not rsa type, so no need to check*/
 890     ssl_print_string("pre master encrypted",entrypted_pre_master);
 891     ssl_debug_printf("ssl_decrypt_pre_master_secret:RSA_private_decrypt\n");
 892     i=ssl_private_decrypt(entrypted_pre_master->data_len,
 893         entrypted_pre_master->data, pk);
 894
 895     if (i!=48) {
 896         ssl_debug_printf("ssl_decrypt_pre_master_secret wrong "
 897             "pre_master_secret lenght (%d, expected %d)\n", i, 48);
 898         return -1;
 899     }
 900
 901     /* the decrypted data has been written into the pre_master key buffer */
 902     ssl_session->pre_master_secret.data = entrypted_pre_master->data;
 903     ssl_session->pre_master_secret.data_len=48;
 904     ssl_print_string("pre master secret",&ssl_session->pre_master_secret);
 905
 906     /* Remove the master secret if it was there.
 907        This force keying material regeneration in
 908        case we're renegotiating */
 909     ssl_session->state &= ~(SSL_MASTER_SECRET|SSL_HAVE_SESSION_KEY);
 910     return 0;
 911 }
 912
 913 /* convert network byte order 32 byte number to right-aligned host byte order *
 914  * 8 bytes buffer */
 915 static gint fmt_seq(guint32 num, guint8* buf)
 916 {
 917     guint32 netnum;
 918
 919     memset(buf,0,8);
 920     netnum=g_htonl(num);
 921     memcpy(buf+4,&netnum,4);
 922
 923     return(0);
 924 }
 925
 926 static gint
 927 tls_check_mac(SslDecoder*decoder, gint ct, gint ver, guint8* data,
 928         guint32 datalen, guint8* mac)
 929 {
 930     SSL_HMAC hm;
 931     gint md;
 932     guint32 len;
 933     guint8 buf[20];
 934
 935     md=ssl_get_digest_by_name(digests[decoder->cipher_suite->dig-0x40]);
 936     ssl_debug_printf("tls_check_mac mac type:%s md %d\n",
 937         digests[decoder->cipher_suite->dig-0x40], md);
 938
 939     ssl_hmac_init(&hm,decoder->mac_key.data,decoder->mac_key.data_len,md);
 940
 941     /* hash sequence number */
 942     fmt_seq(decoder->seq,buf);
 943
 944     decoder->seq++;
 945
 946     ssl_hmac_update(&hm,buf,8);
 947
 948     /* hash content type */
 949     buf[0]=ct;
 950     ssl_hmac_update(&hm,buf,1);
 951
 952     /* hash version,data lenght and data*/
 953     *((gint16*)buf) = g_htons(ver);
 954     ssl_hmac_update(&hm,buf,2);
 955
 956     *((gint16*)buf) = g_htons(datalen);
 957     ssl_hmac_update(&hm,buf,2);
 958     ssl_hmac_update(&hm,data,datalen);
 959
 960     /* get digest and digest len*/
 961     ssl_hmac_final(&hm,buf,&len);
 962     ssl_print_data("Mac", buf, len);
 963     if(memcmp(mac,buf,len))
 964         return -1;
 965
 966     ssl_hmac_cleanup(&hm);
 967     return(0);
 968 }
 969
 970 int
 971 ssl3_check_mac(SslDecoder*decoder,int ct,guint8* data,
 972         guint32 datalen, guint8* mac)
 973 {
 974     SSL_MD mc;
 975     gint md;
 976     guint32 len;
 977     guint8 buf[64],dgst[20];
 978     gint pad_ct;
 979
 980     pad_ct=(decoder->cipher_suite->dig==DIG_SHA)?40:48;
 981
 982     /* get cipher used for digest comptuation */
 983     md=ssl_get_digest_by_name(digests[decoder->cipher_suite->dig-0x40]);
 984     ssl_md_init(&mc,md);
 985
 986     /* do hash computation on data && padding */
 987     ssl_md_update(&mc,decoder->mac_key.data,decoder->mac_key.data_len);
 988
 989     /* hash padding*/
 990     memset(buf,0x36,pad_ct);
 991     ssl_md_update(&mc,buf,pad_ct);
 992
 993     /* hash sequence number */
 994     fmt_seq(decoder->seq,buf);
 995     decoder->seq++;
 996     ssl_md_update(&mc,buf,8);
 997
 998     /* hash content type */
 999     buf[0]=ct;
1000     ssl_md_update(&mc,buf,1);
1001
1002     /* hash data lenght in network byte order and data*/
1003     *((gint16* )buf) = g_htons(datalen);
1004     ssl_md_update(&mc,buf,2);
1005     ssl_md_update(&mc,data,datalen);
1006
1007     /* get partial digest */
1008     ssl_md_final(&mc,dgst,&len);
1009     ssl_md_cleanup(&mc);
1010
1011     ssl_md_init(&mc,md);
1012
1013     /* hash mac key */
1014     ssl_md_update(&mc,decoder->mac_key.data,decoder->mac_key.data_len);
1015
1016     /* hash padding and partial digest*/
1017     memset(buf,0x5c,pad_ct);
1018     ssl_md_update(&mc,buf,pad_ct);
1019     ssl_md_update(&mc,dgst,len);
1020
1021     ssl_md_final(&mc,dgst,&len);
1022     ssl_md_cleanup(&mc);
1023
1024     if(memcmp(mac,dgst,len))
1025         return -1;
1026
1027     return(0);
1028 }
1029
1030 #if 0
1031 static gint
1032 dtls_check_mac(SslDecoder*decoder, gint ct,int ver, guint8* data,
1033         guint32 datalen, guint8* mac)
1034 {
1035     SSL_HMAC hm;
1036     gint md;
1037     guint32 len;
1038     guint8 buf[20];
1039     guint32 netnum;
1040     md=ssl_get_digest_by_name(digests[decoder->cipher_suite->dig-0x40]);
1041     ssl_debug_printf("dtls_check_mac mac type:%s md %d\n",
1042         digests[decoder->cipher_suite->dig-0x40], md);
1043
1044     ssl_hmac_init(&hm,decoder->mac_key.data,decoder->mac_key.data_len,md);
1045     ssl_debug_printf("dtls_check_mac seq: %d epoch: %d\n",decoder->seq,decoder->epoch);
1046     /* hash sequence number */
1047     fmt_seq(decoder->seq,buf);
1048     buf[0]=decoder->epoch>>8;
1049     buf[1]=decoder->epoch;
1050
1051     ssl_hmac_update(&hm,buf,8);
1052
1053     /* hash content type */
1054     buf[0]=ct;
1055     ssl_hmac_update(&hm,buf,1);
1056
1057     /* hash version,data lenght and data */
1058     *((gint16*)buf) = g_htons(ver);
1059     ssl_hmac_update(&hm,buf,2);
1060
1061     *((gint16*)buf) = g_htons(datalen);
1062     ssl_hmac_update(&hm,buf,2);
1063     ssl_hmac_update(&hm,data,datalen);
1064     /* get digest and digest len */
1065     ssl_hmac_final(&hm,buf,&len);
1066     ssl_print_data("Mac", buf, len);
1067     if(memcmp(mac,buf,len))
1068         return -1;
1069
1070     ssl_hmac_cleanup(&hm);
1071     return(0);
1072 }
1073 #endif
1074
1075
1076 int
1077 ssl_decrypt_record(SslDecryptSession*ssl,SslDecoder* decoder, gint ct,
1078         const guchar* in, gint inl, guchar*out, gint* outl)
1079 {
1080     gint pad, worklen;
1081     guint8 *mac;
1082
1083
1084     ssl_debug_printf("ssl_decrypt_record ciphertext len %d\n", inl);
1085     ssl_print_data("Ciphertext",in, inl);
1086
1087     /* First decrypt*/
1088     if ((pad = ssl_cipher_decrypt(&decoder->evp,out,*outl,in,inl))!= 0)
1089         ssl_debug_printf("ssl_decrypt_record: %s %s\n", gcry_strsource (pad),
1090                     gcry_strerror (pad));
1091
1092     ssl_print_data("Plaintext",out,inl);
1093     worklen=inl;
1094
1095     /* Now strip off the padding*/
1096     if(decoder->cipher_suite->block!=1){
1097         pad=out[inl-1];
1098         worklen-=(pad+1);
1099         ssl_debug_printf("ssl_decrypt_record found padding %d final len %d\n",
1100             pad, worklen);
1101     }
1102
1103     /* And the MAC */
1104     worklen-=decoder->cipher_suite->dig_len;
1105     if (worklen < 0)
1106     {
1107         ssl_debug_printf("ssl_decrypt_record wrong record len/padding outlen %d\n work %d\n",*outl, worklen);
1108         return -1;
1109     }
1110     mac=out+worklen;
1111
1112     /* if TLS 1.1 we use the transmitted IV and remove it after (to not modify dissector in others parts)*/
1113     if(ssl->version_netorder==TLSV1DOT1_VERSION){
1114         worklen=worklen-decoder->cipher_suite->block;
1115         memcpy(out,out+decoder->cipher_suite->block,worklen);
1116    }
1117   if(ssl->version_netorder==DTLSV1DOT0_VERSION){
1118         worklen=worklen-decoder->cipher_suite->block;
1119         memcpy(out,out+decoder->cipher_suite->block,worklen);
1120    }
1121     /* Now check the MAC */
1122     ssl_debug_printf("checking mac (len %d, version %X, ct %d seq %d)\n",
1123         worklen, ssl->version_netorder, ct, decoder->seq);
1124     if(ssl->version_netorder==SSLV3_VERSION){
1125         if(ssl3_check_mac(decoder,ct,out,worklen,mac) < 0) {
1126             ssl_debug_printf("ssl_decrypt_record: mac failed\n");
1127             return -1;
1128         }
1129     }
1130     else if(ssl->version_netorder==TLSV1_VERSION || ssl->version_netorder==TLSV1DOT1_VERSION){
1131         if(tls_check_mac(decoder,ct,ssl->version_netorder,out,worklen,mac)< 0) {
1132             ssl_debug_printf("ssl_decrypt_record: mac failed\n");
1133             return -1;
1134         }
1135     }
1136     else if(ssl->version_netorder==DTLSV1DOT0_VERSION){
1137       /* follow the openssl dtls errors the rigth test is : dtls_check_mac(decoder,ct,ssl->version_netorder,out,worklen,mac)< 0 */
1138         if(tls_check_mac(decoder,ct,TLSV1_VERSION,out,worklen,mac)< 0) {
1139             ssl_debug_printf("ssl_decrypt_record: mac failed\n");
1140             return -1;
1141         }
1142     }
1143     ssl_debug_printf("ssl_decrypt_record: mac ok\n");
1144     *outl = worklen;
1145     return(0);
1146 }
1147
1148 static void
1149 ssl_get_version(gint* major, gint* minor, gint* patch)
1150 {
1151   *major = ver_major;
1152   *minor = ver_minor;
1153   *patch = ver_patch;
1154 }
1155
1156
1157 SSL_PRIVATE_KEY*
1158 ssl_load_key(FILE* fp)
1159 {
1160     /* gnutls make our work much harded, since we have to work internally with
1161      * s-exp formatted data, but PEM loader export only in "gnutls_datum"
1162      * format, and a datum -> s-exp convertion function does not exist.
1163      */
1164     struct gnutls_x509_privkey_int* priv_key;
1165     gnutls_datum key;
1166     gnutls_datum m, e, d, p,q, u;
1167     gint size, major, minor, patch;
1168     guint bytes;
1169     guint tmp_size;
1170 #ifdef SSL_FAST
1171     gcry_mpi_t* rsa_params = g_malloc(sizeof(gcry_mpi_t)*6);
1172 #else
1173     gcry_mpi_t rsa_params[6];
1174 #endif
1175     gcry_sexp_t rsa_priv_key;
1176
1177     /* init private key data*/
1178     gnutls_x509_privkey_init(&priv_key);
1179
1180     /* compute file size and load all file contents into a datum buffer*/
1181     if (fseek(fp, 0, SEEK_END) < 0) {
1182         ssl_debug_printf("ssl_load_key: can't fseek file\n");
1183         return NULL;
1184     }
1185     if ((size = ftell(fp)) < 0) {
1186         ssl_debug_printf("ssl_load_key: can't ftell file\n");
1187         return NULL;
1188     }
1189     if (fseek(fp, 0, SEEK_SET) < 0) {
1190         ssl_debug_printf("ssl_load_key: can't refseek file\n");
1191         return NULL;
1192     }
1193     key.data = g_malloc(size);
1194     key.size = size;
1195     bytes = fread(key.data, 1, key.size, fp);
1196     if (bytes < key.size) {
1197         ssl_debug_printf("ssl_load_key: can't read from file %d bytes, got %d\n",
1198             key.size, bytes);
1199         return NULL;
1200     }
1201
1202     /* import PEM data*/
1203     if (gnutls_x509_privkey_import(priv_key, &key, GNUTLS_X509_FMT_PEM)!=0) {
1204         ssl_debug_printf("ssl_load_key: can't import pem data\n");
1205         return NULL;
1206     }
1207     free(key.data);
1208
1209     /* RSA get parameter */
1210     if (gnutls_x509_privkey_export_rsa_raw(priv_key, &m, &e, &d, &p, &q, &u) != 0) {
1211         ssl_debug_printf("ssl_load_key: can't export rsa param (is a rsa private key file ?!?)\n");
1212         return NULL;
1213     }
1214
1215     /* convert each rsa parameter to mpi format*/
1216     if (gcry_mpi_scan( &rsa_params[0], GCRYMPI_FMT_USG, m.data,  m.size, &tmp_size) !=0) {
1217         ssl_debug_printf("ssl_load_key: can't convert m rsa param to int (size %d)\n", m.size);
1218         return NULL;
1219     }
1220
1221     if (gcry_mpi_scan( &rsa_params[1], GCRYMPI_FMT_USG, e.data,  e.size, &tmp_size) != 0) {
1222         ssl_debug_printf("ssl_load_key: can't convert e rsa param to int (size %d)\n", e.size);
1223         return NULL;
1224     }
1225
1226     /*
1227      * note: openssl and gnutls use 'p' and 'q' with opposite meaning:
1228      * our 'p' must be equal to 'q' as provided from openssl and viceversa
1229      */
1230     if (gcry_mpi_scan( &rsa_params[2], GCRYMPI_FMT_USG, d.data,  d.size, &tmp_size) !=0) {
1231         ssl_debug_printf("ssl_load_key: can't convert d rsa param to int (size %d)\n", d.size);
1232         return NULL;
1233     }
1234
1235     if (gcry_mpi_scan( &rsa_params[3], GCRYMPI_FMT_USG, q.data,  q.size, &tmp_size) !=0) {
1236         ssl_debug_printf("ssl_load_key: can't convert q rsa param to int (size %d)\n", q.size);
1237         return NULL;
1238     }
1239
1240     if (gcry_mpi_scan( &rsa_params[4], GCRYMPI_FMT_USG, p.data,  p.size, &tmp_size) !=0) {
1241         ssl_debug_printf("ssl_load_key: can't convert p rsa param to int (size %d)\n", p.size);
1242         return NULL;
1243     }
1244
1245     if (gcry_mpi_scan( &rsa_params[5], GCRYMPI_FMT_USG, u.data,  u.size, &tmp_size) !=0) {
1246         ssl_debug_printf("ssl_load_key: can't convert u rsa param to int (size %d)\n", m.size);
1247         return NULL;
1248     }
1249
1250     ssl_get_version(&major, &minor, &patch);
1251
1252     /* certain versions of gnutls require swap of rsa params 'p' and 'q' */
1253     if ((major <= 1) && (minor <= 0) && (patch <=13))
1254     {
1255         gcry_mpi_t tmp;
1256         ssl_debug_printf("ssl_load_key: swapping p and q parametes\n");
1257         tmp = rsa_params[4];
1258         rsa_params[4] = rsa_params[3];
1259         rsa_params[3] = tmp;
1260     }
1261
1262     if  (gcry_sexp_build( &rsa_priv_key, NULL,
1263             "(private-key(rsa((n%m)(e%m)(d%m)(p%m)(q%m)(u%m))))", rsa_params[0],
1264             rsa_params[1], rsa_params[2], rsa_params[3], rsa_params[4],
1265             rsa_params[5]) != 0) {
1266         ssl_debug_printf("ssl_load_key: can't built rsa private key s-exp\n");
1267         return NULL;
1268     }
1269
1270 #if SSL_FAST
1271     return rsa_params;
1272 #else
1273     {
1274         gint i;
1275         for (i=0; i< 6; i++)
1276             gcry_mpi_release(rsa_params[i]);
1277     }
1278     return rsa_priv_key;
1279 #endif
1280 }
1281
1282 void ssl_free_key(SSL_PRIVATE_KEY* key)
1283 {
1284 #if SSL_FAST
1285     gint i;
1286     for (i=0; i< 6; i++)
1287         gcry_mpi_release(key[i]);
1288 #else
1289     gcry_sexp_release(key);
1290 #endif
1291 }
1292
1293 void
1294 ssl_lib_init(void)
1295 {
1296     const gchar* str = gnutls_check_version(NULL);
1297
1298     /* get library version */
1299     /* old relase of gnutls does not define the appropriate macros, so get
1300      * them from the string*/
1301     ssl_debug_printf("gnutls version: %s\n", str);
1302     sscanf(str, "%d.%d.%d", &ver_major, &ver_minor, &ver_patch);
1303 }
1304
1305 #else /* HAVE_LIBGNUTLS */
1306 /* no libgnutl: dummy operation to keep interface consistent*/
1307 void
1308 ssl_lib_init(void)
1309 {
1310 }
1311
1312 SSL_PRIVATE_KEY*
1313 ssl_load_key(FILE* fp)
1314 {
1315     ssl_debug_printf("ssl_load_key: impossible without glutls. fp %p\n",fp);
1316     return NULL;
1317 }
1318
1319 void
1320 ssl_free_key(SSL_PRIVATE_KEY* key _U_)
1321 {
1322 }
1323
1324 int
1325 ssl_find_cipher(int num,SslCipherSuite* cs)
1326 {
1327     ssl_debug_printf("ssl_find_cipher: dummy without glutls. num %d cs %p\n",
1328         num,cs);
1329     return 0;
1330 }
1331 int
1332 ssl_generate_keyring_material(SslDecryptSession*ssl)
1333 {
1334     ssl_debug_printf("ssl_generate_keyring_material: impossible without glutls. ssl %p\n",
1335         ssl);
1336     return 0;
1337 }
1338 int
1339 ssl_decrypt_pre_master_secret(SslDecryptSession* ssl_session,
1340     StringInfo* entrypted_pre_master, SSL_PRIVATE_KEY *pk)
1341 {
1342     ssl_debug_printf("ssl_decrypt_pre_master_secret: impossible without glutls."
1343         " ssl %p entrypted_pre_master %p pk %p\n", ssl_session,
1344         entrypted_pre_master, pk);
1345     return 0;
1346 }
1347
1348 int
1349 ssl_decrypt_record(SslDecryptSession*ssl, SslDecoder* decoder, gint ct,
1350         const guchar* in, gint inl, guchar*out, gint* outl)
1351 {
1352     ssl_debug_printf("ssl_decrypt_record: impossible without gnutls. ssl %p"
1353         "decoder %p ct %d, in %p inl %d out %p outl %p\n", ssl, decoder, ct,
1354         in, inl, out, outl);
1355     return 0;
1356 }
1357
1358 gint
1359 ssl_cipher_setiv(SSL_CIPHER_CTX *cipher, guchar* iv, gint iv_len)
1360 {
1361     ssl_debug_printf("ssl_cipher_setiv: impossible without glutls.\n");
1362     return 0;
1363 }
1364
1365 #endif /* HAVE_LIBGNUTLS */
1366
1367 /* get ssl data for this session. if no ssl data is found allocate a new one*/
1368 void
1369 ssl_session_init(SslDecryptSession* ssl_session)
1370 {
1371     ssl_debug_printf("ssl_session_init: initializing ptr %p size %lu\n",
1372         ssl_session, (gulong)sizeof(SslDecryptSession));
1373
1374     ssl_session->master_secret.data = ssl_session->_master_secret;
1375     ssl_session->session_id.data = ssl_session->_session_id;
1376     ssl_session->client_random.data = ssl_session->_client_random;
1377     ssl_session->server_random.data = ssl_session->_server_random;
1378     ssl_session->master_secret.data_len = 48;
1379     ssl_session->server_data_for_iv.data = 0;
1380     ssl_session->server_data_for_iv.data = ssl_session->_server_data_for_iv;
1381     ssl_session->client_data_for_iv.data = 0;
1382     ssl_session->client_data_for_iv.data = ssl_session->_client_data_for_iv;
1383     ssl_session->app_data_segment.data=NULL;
1384     ssl_session->app_data_segment.data_len=0;
1385 }
1386
1387 /* Hash Functions for TLS/DTLS sessions table and private keys table*/
1388 gint
1389 ssl_equal (gconstpointer v, gconstpointer v2)
1390 {
1391   const StringInfo *val1;
1392   const StringInfo *val2;
1393   val1 = (const StringInfo *)v;
1394   val2 = (const StringInfo *)v2;
1395
1396   if (val1->data_len == val2->data_len &&
1397       !memcmp(val1->data, val2->data, val2->data_len)) {
1398     return 1;
1399   }
1400   return 0;
1401 }
1402
1403 guint
1404 ssl_hash  (gconstpointer v)
1405 {
1406   guint l,hash;
1407   StringInfo* id;
1408   guint* cur;
1409   hash = 0;
1410   id = (StringInfo*) v;
1411   cur = (guint*) id->data;
1412
1413   for (l=4; (l<id->data_len); l+=4, cur++)
1414     hash = hash ^ (*cur);
1415
1416   return hash;
1417 }
1418
1419 gint
1420 ssl_private_key_equal (gconstpointer v, gconstpointer v2)
1421 {
1422   const SslService *val1;
1423   const SslService *val2;
1424   val1 = (const SslService *)v;
1425   val2 = (const SslService *)v2;
1426
1427   if ((val1->port == val2->port) &&
1428       ! CMP_ADDRESS(&val1->addr, &val2->addr)) {
1429     return 1;
1430   }
1431   return 0;
1432 }
1433
1434 guint
1435 ssl_private_key_hash  (gconstpointer v)
1436 {
1437   const SslService *key;
1438   guint l, hash, len ;
1439   guint* cur;
1440   key = (const SslService *)v;
1441   hash = key->port;
1442   len = key->addr.len;
1443   cur = (guint*) key->addr.data;
1444
1445   for (l=4; (l<len); l+=4, cur++)
1446     hash = hash ^ (*cur);
1447
1448   return hash;
1449 }
1450
1451 /* private key table entries have a scope 'larger' then packet capture,
1452  * so we can't relay on se_alloc** function */
1453 void
1454 ssl_private_key_free(gpointer id, gpointer key, gpointer dummy _U_)
1455 {
1456   g_free(id);
1457   ssl_free_key((SSL_PRIVATE_KEY*) key);
1458 }
1459
1460 /* handling of association between tls/dtls ports and clear text protocol */
1461 void
1462 ssl_association_add(GTree* associations, dissector_handle_t handle, guint port, const gchar *protocol, gboolean tcp, gboolean from_key_list)
1463 {
1464
1465   SslAssociation* assoc;
1466   assoc = g_malloc(sizeof(SslAssociation));
1467
1468   assoc->tcp = tcp;
1469   assoc->ssl_port = port;
1470   assoc->info=g_malloc(strlen(protocol)+1);
1471   strcpy(assoc->info, protocol);
1472   assoc->handle = find_dissector(protocol);
1473   assoc->from_key_list = from_key_list;
1474
1475   ssl_debug_printf("association_add %s port %d protocol %s handle %p\n",
1476                    (assoc->tcp)?"TCP":"UDP", port, protocol, assoc->handle);
1477
1478
1479   if (!assoc->handle) {
1480     ssl_debug_printf("association_add could not find handle for protocol '%s', try to find 'data' dissector\n", protocol);
1481     assoc->handle = find_dissector("data");
1482   }
1483
1484   if(!assoc->handle){
1485     fprintf(stderr, "association_add() could not find handle for protocol:%s\n",protocol);
1486   } else {
1487     if(tcp)
1488       dissector_add("tcp.port", port, handle);
1489     else
1490       dissector_add("udp.port", port, handle);
1491     g_tree_insert(associations, assoc, assoc);
1492   }
1493 }
1494
1495 void
1496 ssl_association_remove(GTree* associations, SslAssociation *assoc)
1497 {
1498   ssl_debug_printf("ssl_association_remove removing %s %u - %s handle %p\n",
1499                    (assoc->tcp)?"TCP":"UDP", assoc->ssl_port, assoc->info, assoc->handle);
1500   if (assoc->handle)
1501     dissector_delete((assoc->tcp)?"tcp.port":"udp.port", assoc->ssl_port, assoc->handle);
1502
1503   g_tree_remove(associations, assoc);
1504   g_free(assoc);
1505 }
1506
1507 gint
1508 ssl_association_cmp(gconstpointer a, gconstpointer b)
1509 {
1510   const SslAssociation *assoc_a=a, *assoc_b=b;
1511   if (assoc_a->tcp != assoc_b->tcp) return (assoc_a->tcp)?1:-1;
1512   return assoc_a->ssl_port - assoc_b->ssl_port;
1513 }
1514
1515 SslAssociation*
1516 ssl_association_find(GTree * associations, guint port, gboolean tcp)
1517 {
1518   register SslAssociation* ret;
1519   SslAssociation assoc_tmp;
1520
1521   assoc_tmp.tcp = tcp;
1522   assoc_tmp.ssl_port = port;
1523   ret = g_tree_lookup(associations, &assoc_tmp);
1524
1525   ssl_debug_printf("association_find: %s port %d found %p\n", (tcp)?"TCP":"UDP", port, ret);
1526   return ret;
1527 }
1528
1529 gint
1530 ssl_assoc_from_key_list(gpointer key _U_, gpointer data, gpointer user_data)
1531 {
1532   if (((SslAssociation*)data)->from_key_list)
1533     ep_stack_push((ep_stack_t)user_data, data);
1534   return FALSE;
1535 }
1536
1537 int
1538 ssl_packet_from_server(GTree* associations, guint port, gboolean tcp)
1539 {
1540   register gint ret;
1541   ret = ssl_association_find(associations, port, tcp) != 0;
1542
1543   ssl_debug_printf("packet_from_server: is from server %d\n", ret);
1544   return ret;
1545 }
1546
1547 /* add to packet data a newly allocated tvb with the specified real data*/
1548 void
1549 ssl_add_record_info(gint proto, packet_info *pinfo, guchar* data, gint data_len, gint record_id)
1550 {
1551   guchar* real_data;
1552   SslRecordInfo* rec;
1553   SslPacketInfo* pi;
1554   real_data = se_alloc(data_len);
1555   rec = se_alloc(sizeof(SslRecordInfo));
1556   pi = p_get_proto_data(pinfo->fd, proto);
1557
1558   if (!pi)
1559     {
1560       pi = se_alloc0(sizeof(SslPacketInfo));
1561       p_add_proto_data(pinfo->fd, proto,pi);
1562     }
1563
1564   rec->id = record_id;
1565   rec->tvb = tvb_new_real_data(real_data, data_len, data_len);
1566   memcpy(real_data, data, data_len);
1567
1568   /* head insertion */
1569   rec->next= pi->handshake_data;
1570   pi->handshake_data = rec;
1571 }
1572
1573
1574 /* search in packet data the tvbuff associated to the specified id */
1575 tvbuff_t*
1576 ssl_get_record_info(int proto, packet_info *pinfo, gint record_id)
1577 {
1578   SslRecordInfo* rec;
1579   SslPacketInfo* pi;
1580   pi = p_get_proto_data(pinfo->fd, proto);
1581
1582   if (!pi)
1583     return NULL;
1584
1585   for (rec = pi->handshake_data; rec; rec = rec->next)
1586     if (rec->id == record_id)
1587       return rec->tvb;
1588
1589   return NULL;
1590 }
1591
1592 /* initialize/reset per capture state data (ssl sessions cache) */
1593 void
1594 ssl_common_init(GHashTable **session_hash , StringInfo * decrypted_data)
1595 {
1596   if (*session_hash)
1597     g_hash_table_destroy(*session_hash);
1598   *session_hash = g_hash_table_new(ssl_hash, ssl_equal);
1599   if (decrypted_data->data)
1600     g_free(decrypted_data->data);
1601   decrypted_data->data = g_malloc0(32);
1602   decrypted_data->data_len = 32;
1603 }
1604
1605 /* parse ssl related preferences (private keys and ports association strings) */
1606 void
1607 ssl_parse_key_list(const gchar * keys_list, GHashTable *key_hash, GTree* associations, dissector_handle_t handle, gboolean tcp)
1608 {
1609   gchar* end;
1610   gchar* start;
1611   gchar* tmp;
1612   guchar* ip;
1613   SslService* service;
1614   SSL_PRIVATE_KEY * private_key;
1615   FILE* fp;
1616
1617   start = strdup(keys_list);
1618   tmp = start;
1619   ssl_debug_printf("ssl_init keys string:\n%s\n", start);
1620   do {
1621     gchar* addr, *port, *protocol, *filename;
1622
1623     addr = start;
1624     /* split ip/file couple with ';' separator*/
1625     end = strpbrk(start, ";\n\r");
1626     if (end) {
1627       *end = 0;
1628       start = end+1;
1629     }
1630
1631     /* skip comments (in file) */
1632     if (addr[0] == '#') continue;
1633
1634     /* for each entry split ip, port, protocol, filename with ',' separator */
1635     ssl_debug_printf("ssl_init found host entry %s\n", addr);
1636     port = strchr(addr, ',');
1637     if (!port)
1638       {
1639         ssl_debug_printf("ssl_init entry malformed can't find port in '%s'\n", addr);
1640         continue;
1641       }
1642     *port = 0;
1643     port++;
1644
1645     protocol = strchr(port,',');
1646     if (!protocol)
1647       {
1648         ssl_debug_printf("ssl_init entry malformed can't find protocol in %s\n", port);
1649         continue;
1650       }
1651     *protocol=0;
1652     protocol++;
1653
1654     filename = strchr(protocol,',');
1655     if (!filename)
1656       {
1657         ssl_debug_printf("ssl_init entry malformed can't find filename in %s\n", port);
1658         continue;
1659       }
1660     *filename=0;
1661     filename++;
1662
1663     /* convert ip and port string to network rappresentation*/
1664     service = g_malloc(sizeof(SslService) + 4);
1665     service->addr.type = AT_IPv4;
1666     service->addr.len = 4;
1667     service->addr.data = ip = ((guchar*)service) + sizeof(SslService);
1668     sscanf(addr, "%hhu.%hhu.%hhu.%hhu", &ip[0], &ip[1], &ip[2], &ip[3]);
1669     service->port = atoi(port);
1670     ssl_debug_printf("ssl_init addr %hhu.%hhu.%hhu.%hhu port %d filename %s\n",
1671                      ip[0], ip[1], ip[2], ip[3], service->port, filename);
1672
1673     /* try to load pen file*/
1674     fp = fopen(filename, "rb");
1675     if (!fp) {
1676       fprintf(stderr, "can't open file %s \n",filename);
1677       continue;
1678     }
1679
1680     private_key = ssl_load_key(fp);
1681     if (!private_key) {
1682       fprintf(stderr,"can't load private key from %s\n",
1683               filename);
1684       continue;
1685     }
1686     fclose(fp);
1687
1688     ssl_debug_printf("ssl_init private key file %s successfully loaded\n",
1689                      filename);
1690     g_hash_table_insert(key_hash, service, private_key);
1691
1692     ssl_association_add(associations, handle, atoi(port), protocol, tcp, TRUE);
1693
1694   } while (end != NULL);
1695   free(tmp);
1696 }
1697
1698 /* store master secret into session data cache */
1699 void
1700 ssl_save_session(SslDecryptSession* ssl, GHashTable *session_hash)
1701 {
1702   /* allocate stringinfo chunks for session id and master secret data*/
1703   StringInfo* session_id;
1704   StringInfo* master_secret;
1705   session_id = se_alloc0(sizeof(StringInfo) + ssl->session_id.data_len);
1706   master_secret = se_alloc0(48 + sizeof(StringInfo));
1707
1708   master_secret->data = ((guchar*)master_secret+sizeof(StringInfo));
1709   session_id->data = ((guchar*)session_id+sizeof(StringInfo));
1710
1711   ssl_data_set(session_id, ssl->session_id.data, ssl->session_id.data_len);
1712   ssl_data_set(master_secret, ssl->master_secret.data, ssl->master_secret.data_len);
1713   g_hash_table_insert(session_hash, session_id, master_secret);
1714   ssl_print_string("ssl_save_session stored session id", session_id);
1715   ssl_print_string("ssl_save_session stored master secret", master_secret);
1716 }
1717
1718 void
1719 ssl_restore_session(SslDecryptSession* ssl, GHashTable *session_hash)
1720 {
1721   StringInfo* ms;
1722   ms = g_hash_table_lookup(session_hash, &ssl->session_id);
1723
1724   if (!ms) {
1725     ssl_debug_printf("ssl_restore_session can't find stored session\n");
1726     return;
1727   }
1728   ssl_data_set(&ssl->master_secret, ms->data, ms->data_len);
1729   ssl->state |= SSL_MASTER_SECRET;
1730   ssl_debug_printf("ssl_restore_session master key retrived\n");
1731 }
1732
1733 int
1734 ssl_is_valid_content_type(guint8 type)
1735 {
1736   if (type >= 0x14 && type <= 0x17)
1737     {
1738       return 1;
1739     }
1740
1741   return 0;
1742 }
1743
1744 #ifdef SSL_DECRYPT_DEBUG
1745
1746 static FILE* ssl_debug_file=NULL;
1747
1748 void
1749 ssl_set_debug(char* name)
1750 {
1751     static gint debug_file_must_be_closed;
1752     gint use_stderr;
1753     debug_file_must_be_closed = 0;
1754     use_stderr = name?(strcmp(name, SSL_DEBUG_USE_STDERR) == 0):0;
1755
1756     if (debug_file_must_be_closed)
1757         fclose(ssl_debug_file);
1758     if (use_stderr)
1759         ssl_debug_file = stderr;
1760     else if (!name || (strcmp(name, "") ==0))
1761         ssl_debug_file = NULL;
1762     else
1763         ssl_debug_file = fopen(name, "w");
1764     if (!use_stderr && ssl_debug_file)
1765         debug_file_must_be_closed = 1;
1766 }
1767
1768
1769 void
1770 ssl_debug_printf(const gchar* fmt, ...)
1771 {
1772     va_list ap;
1773     gint ret;
1774     ret=0;
1775
1776     if (!ssl_debug_file)
1777         return;
1778
1779     va_start(ap, fmt);
1780     ret += vfprintf(ssl_debug_file, fmt, ap);
1781     va_end(ap);
1782     fflush(ssl_debug_file);
1783 }
1784
1785 void
1786 ssl_print_text_data(const gchar* name, const guchar* data, gint len)
1787 {
1788     gint i;
1789     if (!ssl_debug_file)
1790         return;
1791     fprintf(ssl_debug_file,"%s: ",name);
1792     for (i=0; i< len; i++) {
1793       fprintf(ssl_debug_file,"%c",data[i]);
1794     }
1795     fprintf(ssl_debug_file,"\n");
1796     fflush(ssl_debug_file);
1797 }
1798
1799 void
1800 ssl_print_data(const gchar* name, const guchar* data, gint len)
1801 {
1802     gint i;
1803     if (!ssl_debug_file)
1804         return;
1805     fprintf(ssl_debug_file,"%s[%d]:\n",name, len);
1806     for (i=0; i< len; i++) {
1807         if ((i>0) && (i%16 == 0))
1808             fprintf(ssl_debug_file,"\n");
1809         fprintf(ssl_debug_file,"%.2x ",data[i]&255);
1810     }
1811     fprintf(ssl_debug_file,"\n");
1812     fflush(ssl_debug_file);
1813 }
1814
1815 void
1816 ssl_print_string(const gchar* name, const StringInfo* data)
1817 {
1818     ssl_print_data(name, data->data, data->data_len);
1819 }
1820 #endif /* SSL_DECRYPT_DEBUG */