pppd/eap-tls.c

   1 /* * eap-tls.c - EAP-TLS implementation for PPP
   2  *
   3  * Copyright (c) Beniamino Galvani 2005 All rights reserved.
   4  *               Jan Just Keijser  2006-2019 All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  *
  18  * 3. The name(s) of the authors of this software must not be used to
  19  *    endorse or promote products derived from this software without
  20  *    prior written permission.
  21  *
  22  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
  23  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  24  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
  25  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  26  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  27  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  28  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  29  *
  30  */
  31
  32 #include <string.h>
  33 #include <strings.h>
  34 #include <unistd.h>
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <fcntl.h>
  38
  39 #include <openssl/conf.h>
  40 #include <openssl/engine.h>
  41 #include <openssl/hmac.h>
  42 #include <openssl/err.h>
  43 #include <openssl/ui.h>
  44 #include <openssl/x509v3.h>
  45
  46 #include "pppd.h"
  47 #include "eap.h"
  48 #include "eap-tls.h"
  49 #include "fsm.h"
  50 #include "lcp.h"
  51 #include "pathnames.h"
  52
  53 typedef struct pw_cb_data
  54 {
  55     const void *password;
  56     const char *prompt_info;
  57 } PW_CB_DATA;
  58
  59 /* The openssl configuration file and engines can be loaded only once */
  60 static CONF   *ssl_config  = NULL;
  61 static ENGINE *cert_engine = NULL;
  62 static ENGINE *pkey_engine = NULL;
  63
  64 /* TLSv1.3 do we have a session ticket ? */
  65 static int have_session_ticket = 0;
  66
  67 int ssl_verify_callback(int, X509_STORE_CTX *);
  68 void ssl_msg_callback(int write_p, int version, int ct, const void *buf,
  69               size_t len, SSL * ssl, void *arg);
  70 int ssl_new_session_cb(SSL *s, SSL_SESSION *sess);
  71
  72 X509 *get_X509_from_file(char *filename);
  73 int ssl_cmp_certs(char *filename, X509 * a);
  74
  75 #ifdef MPPE
  76
  77 #define EAPTLS_MPPE_KEY_LEN     32
  78
  79 /*
  80  *  OpenSSL 1.1+ introduced a generic TLS_method()
  81  *  For older releases we substitute the appropriate method
  82  */
  83
  84 #if OPENSSL_VERSION_NUMBER < 0x10100000L
  85
  86 #define TLS_method SSLv23_method
  87
  88 #define SSL3_RT_HEADER  0x100
  89
  90 #ifndef SSL_CTX_set_max_proto_version
  91 /** Mimics SSL_CTX_set_max_proto_version for OpenSSL < 1.1 */
  92 static inline int SSL_CTX_set_max_proto_version(SSL_CTX *ctx, long tls_ver_max)
  93 {
  94     long sslopt = 0;
  95
  96     if (tls_ver_max < TLS1_VERSION)
  97     {
  98         sslopt |= SSL_OP_NO_TLSv1;
  99     }
 100 #ifdef SSL_OP_NO_TLSv1_1
 101     if (tls_ver_max < TLS1_1_VERSION)
 102     {
 103         sslopt |= SSL_OP_NO_TLSv1_1;
 104     }
 105 #endif
 106 #ifdef SSL_OP_NO_TLSv1_2
 107     if (tls_ver_max < TLS1_2_VERSION)
 108     {
 109         sslopt |= SSL_OP_NO_TLSv1_2;
 110     }
 111 #endif
 112     SSL_CTX_set_options(ctx, sslopt);
 113
 114     return 1;
 115 }
 116 #endif /* SSL_CTX_set_max_proto_version */
 117
 118 #endif /* OPENSSL_VERSION_NUMBER < 0x10100000L */
 119
 120
 121 /*
 122  *  Generate keys according to RFC 2716 and add to reply
 123  */
 124 void eaptls_gen_mppe_keys(struct eaptls_session *ets, int client)
 125 {
 126     unsigned char  out[4*EAPTLS_MPPE_KEY_LEN];
 127     const char    *prf_label;
 128     size_t         prf_size;
 129     unsigned char  eap_tls13_context[] = { EAPT_TLS };
 130     unsigned char *context = NULL;
 131     size_t         context_len = 0;
 132     unsigned char *p;
 133
 134     dbglog("EAP-TLS generating MPPE keys");
 135     if (ets->tls_v13)
 136     {
 137         prf_label = "EXPORTER_EAP_TLS_Key_Material";
 138         context   = eap_tls13_context;
 139         context_len = 1;
 140     }
 141     else
 142     {
 143         prf_label = "client EAP encryption";
 144     }
 145
 146     dbglog("EAP-TLS PRF label = %s", prf_label);
 147     prf_size = strlen(prf_label);
 148     if (SSL_export_keying_material(ets->ssl, out, sizeof(out), prf_label, prf_size,
 149                                    context, context_len, 0) != 1)
 150     {
 151         warn( "EAP-TLS: Failed generating keying material" );
 152         return;
 153     }
 154
 155     /*
 156      * We now have the master send and receive keys.
 157      * From these, generate the session send and receive keys.
 158      * (see RFC3079 / draft-ietf-pppext-mppe-keys-03.txt for details)
 159      */
 160     if (client)
 161     {
 162         p = out;
 163         BCOPY( p, mppe_send_key, sizeof(mppe_send_key) );
 164         p += EAPTLS_MPPE_KEY_LEN;
 165         BCOPY( p, mppe_recv_key, sizeof(mppe_recv_key) );
 166     }
 167     else
 168     {
 169         p = out;
 170         BCOPY( p, mppe_recv_key, sizeof(mppe_recv_key) );
 171         p += EAPTLS_MPPE_KEY_LEN;
 172         BCOPY( p, mppe_send_key, sizeof(mppe_send_key) );
 173     }
 174
 175     mppe_keys_set = 1;
 176 }
 177
 178 #endif /* MPPE */
 179
 180 void log_ssl_errors( void )
 181 {
 182     unsigned long ssl_err = ERR_get_error();
 183
 184     if (ssl_err != 0)
 185         dbglog("EAP-TLS SSL error stack:");
 186     while (ssl_err != 0) {
 187         dbglog( ERR_error_string( ssl_err, NULL ) );
 188         ssl_err = ERR_get_error();
 189     }
 190 }
 191
 192
 193 int password_callback (char *buf, int size, int rwflag, void *u)
 194 {
 195     if (buf)
 196     {
 197         strlcpy (buf, passwd, size);
 198         return strlen (buf);
 199     }
 200     return 0;
 201 }
 202
 203
 204 CONF *eaptls_ssl_load_config( void )
 205 {
 206     CONF        *config;
 207     int          ret_code;
 208     long         error_line = 33;
 209
 210     config = NCONF_new( NULL );
 211     dbglog( "Loading OpenSSL config file" );
 212     ret_code = NCONF_load( config, _PATH_OPENSSLCONFFILE, &error_line );
 213     if (ret_code == 0)
 214     {
 215         warn( "EAP-TLS: Error in OpenSSL config file %s at line %d", _PATH_OPENSSLCONFFILE, error_line );
 216         NCONF_free( config );
 217         config = NULL;
 218         ERR_clear_error();
 219     }
 220
 221     dbglog( "Loading OpenSSL built-ins" );
 222     ENGINE_load_builtin_engines();
 223     OPENSSL_load_builtin_modules();
 224
 225     dbglog( "Loading OpenSSL configured modules" );
 226     if (CONF_modules_load( config, NULL, 0 ) <= 0 )
 227     {
 228         warn( "EAP-TLS: Error loading OpenSSL modules" );
 229         log_ssl_errors();
 230         config = NULL;
 231     }
 232
 233     return config;
 234 }
 235
 236 ENGINE *eaptls_ssl_load_engine( char *engine_name )
 237 {
 238     ENGINE      *e = NULL;
 239
 240     dbglog( "Enabling OpenSSL auto engines" );
 241     ENGINE_register_all_complete();
 242
 243     dbglog( "Loading OpenSSL '%s' engine support", engine_name );
 244     e = ENGINE_by_id( engine_name );
 245     if (!e)
 246     {
 247         dbglog( "EAP-TLS: Cannot load '%s' engine support, trying 'dynamic'", engine_name );
 248         e = ENGINE_by_id( "dynamic" );
 249         if (e)
 250         {
 251             if (!ENGINE_ctrl_cmd_string(e, "SO_PATH", engine_name, 0)
 252              || !ENGINE_ctrl_cmd_string(e, "LOAD", NULL, 0))
 253             {
 254                 warn( "EAP-TLS: Error loading dynamic engine '%s'", engine_name );
 255                 log_ssl_errors();
 256                 ENGINE_free(e);
 257                 e = NULL;
 258             }
 259         }
 260         else
 261         {
 262             warn( "EAP-TLS: Cannot load dynamic engine support" );
 263         }
 264     }
 265
 266     if (e)
 267     {
 268         dbglog( "Initialising engine" );
 269         if(!ENGINE_set_default(e, ENGINE_METHOD_ALL))
 270         {
 271             warn( "EAP-TLS: Cannot use that engine" );
 272             log_ssl_errors();
 273             ENGINE_free(e);
 274             e = NULL;
 275         }
 276     }
 277
 278     return e;
 279 }
 280
 281
 282
 283 /*
 284  * Initialize the SSL stacks and tests if certificates, key and crl
 285  * for client or server use can be loaded.
 286  */
 287 SSL_CTX *eaptls_init_ssl(int init_server, char *cacertfile, char *capath,
 288             char *certfile, char *peer_certfile, char *privkeyfile)
 289 {
 290     char        *cert_engine_name = NULL;
 291     char        *cert_identifier = NULL;
 292     char        *pkey_engine_name = NULL;
 293     char        *pkey_identifier = NULL;
 294     SSL_CTX     *ctx;
 295     SSL         *ssl;
 296     X509_STORE  *certstore;
 297     X509_LOOKUP *lookup;
 298     X509        *tmp;
 299     int          ret;
 300 #if defined(TLS1_2_VERSION)
 301     long         tls_version = TLS1_2_VERSION;
 302 #elif defined(TLS1_1_VERSION)
 303     long         tls_version = TLS1_1_VERSION;
 304 #else
 305     long         tls_version = TLS1_VERSION;
 306 #endif
 307
 308     /*
 309      * Without these can't continue
 310      */
 311     if (!(cacertfile[0] || capath[0]))
 312     {
 313         error("EAP-TLS: CA certificate file or path missing");
 314         return NULL;
 315     }
 316
 317     if (!certfile[0])
 318     {
 319         error("EAP-TLS: Certificate missing");
 320         return NULL;
 321     }
 322
 323     if (!privkeyfile[0])
 324     {
 325         error("EAP-TLS: Private key missing");
 326         return NULL;
 327     }
 328
 329     SSL_library_init();
 330     SSL_load_error_strings();
 331
 332     /* load the openssl config file only once and load it before triggering
 333        the loading of a global openssl config file via SSL_CTX_new()
 334      */
 335     if (!ssl_config)
 336         ssl_config = eaptls_ssl_load_config();
 337
 338     ctx = SSL_CTX_new(TLS_method());
 339
 340     if (!ctx) {
 341         error("EAP-TLS: Cannot initialize SSL CTX context");
 342         goto fail;
 343     }
 344
 345     /* if the certificate filename is of the form engine:id. e.g.
 346         pkcs11:12345
 347        then we try to load and use this engine.
 348        If the certificate filename starts with a / or . then we
 349        ALWAYS assume it is a file and not an engine/pkcs11 identifier
 350      */
 351     if ( index( certfile, '/' ) == NULL && index( certfile, '.') == NULL )
 352     {
 353         cert_identifier = index( certfile, ':' );
 354
 355         if (cert_identifier)
 356         {
 357             cert_engine_name = certfile;
 358             *cert_identifier = '\0';
 359             cert_identifier++;
 360
 361             dbglog( "Found certificate engine '%s'", cert_engine_name );
 362             dbglog( "Found certificate identifier '%s'", cert_identifier );
 363         }
 364     }
 365
 366     /* if the privatekey filename is of the form engine:id. e.g.
 367         pkcs11:12345
 368        then we try to load and use this engine.
 369        If the privatekey filename starts with a / or . then we
 370        ALWAYS assume it is a file and not an engine/pkcs11 identifier
 371      */
 372     if ( index( privkeyfile, '/' ) == NULL && index( privkeyfile, '.') == NULL )
 373     {
 374         pkey_identifier = index( privkeyfile, ':' );
 375
 376         if (pkey_identifier)
 377         {
 378             pkey_engine_name = privkeyfile;
 379             *pkey_identifier = '\0';
 380             pkey_identifier++;
 381
 382             dbglog( "Found privatekey engine '%s'", pkey_engine_name );
 383             dbglog( "Found privatekey identifier '%s'", pkey_identifier );
 384         }
 385     }
 386
 387     if (cert_identifier && pkey_identifier)
 388     {
 389         if (strlen( cert_identifier ) == 0)
 390         {
 391             if (strlen( pkey_identifier ) == 0)
 392                 error( "EAP-TLS: both the certificate and privatekey identifiers are missing!" );
 393             else
 394             {
 395                 dbglog( "Substituting privatekey identifier for certificate identifier" );
 396                 cert_identifier = pkey_identifier;
 397             }
 398         }
 399         else
 400         {
 401             if (strlen( pkey_identifier ) == 0)
 402             {
 403                 dbglog( "Substituting certificate identifier for privatekey identifier" );
 404                 pkey_identifier = cert_identifier;
 405             }
 406         }
 407     }
 408
 409     if (ssl_config && cert_engine_name)
 410         cert_engine = eaptls_ssl_load_engine( cert_engine_name );
 411
 412     if (ssl_config && pkey_engine_name)
 413     {
 414         /* don't load the same engine twice */
 415         if ( cert_engine && strcmp( cert_engine_name, pkey_engine_name) == 0 )
 416             pkey_engine = cert_engine;
 417         else
 418             pkey_engine = eaptls_ssl_load_engine( pkey_engine_name );
 419     }
 420
 421     SSL_CTX_set_default_passwd_cb (ctx, password_callback);
 422
 423     if (strlen(cacertfile) == 0) cacertfile = NULL;
 424     if (strlen(capath) == 0)     capath = NULL;
 425
 426     if (!SSL_CTX_load_verify_locations(ctx, cacertfile, capath))
 427     {
 428         error("EAP-TLS: Cannot load verify locations");
 429         if (cacertfile) dbglog("CA certificate file = [%s]", cacertfile);
 430         if (capath) dbglog("CA certificate path = [%s]", capath);
 431         goto fail;
 432     }
 433
 434     if (init_server)
 435         SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file(cacertfile));
 436
 437     if (cert_engine)
 438     {
 439         struct
 440         {
 441             const char *s_slot_cert_id;
 442             X509 *cert;
 443         } cert_info;
 444
 445         cert_info.s_slot_cert_id = cert_identifier;
 446         cert_info.cert = NULL;
 447
 448         if (!ENGINE_ctrl_cmd( cert_engine, "LOAD_CERT_CTRL", 0, &cert_info, NULL, 0 ) )
 449         {
 450             error( "EAP-TLS: Error loading certificate with id '%s' from engine", cert_identifier );
 451             goto fail;
 452         }
 453
 454         if (cert_info.cert)
 455         {
 456             dbglog( "Got the certificate, adding it to SSL context" );
 457             dbglog( "subject = %s", X509_NAME_oneline( X509_get_subject_name( cert_info.cert ), NULL, 0 ) );
 458             if (SSL_CTX_use_certificate(ctx, cert_info.cert) <= 0)
 459             {
 460                 error("EAP-TLS: Cannot use PKCS11 certificate %s", cert_identifier);
 461                 goto fail;
 462             }
 463         }
 464         else
 465         {
 466             warn("EAP-TLS: Cannot load PKCS11 key %s", cert_identifier);
 467             log_ssl_errors();
 468         }
 469     }
 470     else
 471     {
 472         if (!SSL_CTX_use_certificate_chain_file(ctx, certfile))
 473         {
 474             error( "EAP-TLS: Cannot use public certificate %s", certfile );
 475             goto fail;
 476         }
 477     }
 478
 479
 480     /*
 481      *  Check the Before and After dates of the certificate
 482      */
 483     ssl = SSL_new(ctx);
 484     tmp = SSL_get_certificate(ssl);
 485
 486     ret = X509_cmp_time(X509_get_notBefore(tmp), NULL);
 487     if (ret == 0)
 488     {
 489         warn( "EAP-TLS: Failed to read certificate notBefore field.");
 490     }
 491     if (ret > 0)
 492     {
 493         warn( "EAP-TLS: Your certificate is not yet valid!");
 494     }
 495
 496     ret = X509_cmp_time(X509_get_notAfter(tmp), NULL);
 497     if (ret == 0)
 498     {
 499         warn( "EAP-TLS: Failed to read certificate notAfter field.");
 500     }
 501     if (ret < 0)
 502     {
 503         warn( "EAP-TLS: Your certificate has expired!");
 504     }
 505     SSL_free(ssl);
 506
 507     if (pkey_engine)
 508     {
 509         EVP_PKEY   *pkey = NULL;
 510         PW_CB_DATA  cb_data;
 511         UI_METHOD* transfer_pin = NULL;
 512
 513         cb_data.password = passwd;
 514         cb_data.prompt_info = pkey_identifier;
 515
 516         if (passwd[0] != 0)
 517         {
 518             UI_METHOD* transfer_pin = UI_create_method("transfer_pin");
 519
 520             int writer (UI *ui, UI_STRING *uis)
 521             {
 522                 PW_CB_DATA* cb_data = (PW_CB_DATA*)UI_get0_user_data(ui);
 523                 UI_set_result(ui, uis, cb_data->password);
 524                 return 1;
 525             };
 526             int stub (UI* ui) {return 1;};
 527             int stub_reader (UI *ui, UI_STRING *uis) {return 1;};
 528
 529             UI_method_set_writer(transfer_pin,  writer);
 530             UI_method_set_opener(transfer_pin,  stub);
 531             UI_method_set_closer(transfer_pin,  stub);
 532             UI_method_set_flusher(transfer_pin, stub);
 533             UI_method_set_reader(transfer_pin,  stub_reader);
 534
 535             dbglog( "Using our private key '%s' in engine", pkey_identifier );
 536             pkey = ENGINE_load_private_key(pkey_engine, pkey_identifier, transfer_pin, &cb_data);
 537         }
 538         else {
 539             dbglog( "Loading private key '%s' from engine", pkey_identifier );
 540             pkey = ENGINE_load_private_key(pkey_engine, pkey_identifier, NULL, NULL);
 541         }
 542         if (pkey)
 543         {
 544             dbglog( "Got the private key, adding it to SSL context" );
 545             if (SSL_CTX_use_PrivateKey(ctx, pkey) <= 0)
 546             {
 547                 error("EAP-TLS: Cannot use PKCS11 key %s", pkey_identifier);
 548                 goto fail;
 549             }
 550         }
 551         else
 552         {
 553             warn("EAP-TLS: Cannot load PKCS11 key %s", pkey_identifier);
 554             log_ssl_errors();
 555         }
 556
 557         if (transfer_pin) UI_destroy_method(transfer_pin);
 558     }
 559     else
 560     {
 561         if (!SSL_CTX_use_PrivateKey_file(ctx, privkeyfile, SSL_FILETYPE_PEM))
 562         {
 563             error("EAP-TLS: Cannot use private key %s", privkeyfile);
 564             goto fail;
 565         }
 566     }
 567
 568     if (SSL_CTX_check_private_key(ctx) != 1) {
 569         error("EAP-TLS: Private key %s fails security check", privkeyfile);
 570         goto fail;
 571     }
 572
 573     /* Explicitly set the NO_TICKETS flag to support Win7/Win8 clients */
 574     SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3
 575 #ifdef SSL_OP_NO_TICKET
 576     | SSL_OP_NO_TICKET
 577 #endif
 578     );
 579
 580     /* OpenSSL 1.1.1+ does not include RC4 ciphers by default.
 581      * This causes totally obsolete WinXP clients to fail. If you really
 582      * need ppp+EAP-TLS+openssl 1.1.1+WinXP then enable RC4 cipers and
 583      * make sure that you use an OpenSSL that supports them
 584
 585     SSL_CTX_set_cipher_list(ctx, "RC4");
 586      */
 587
 588
 589     /* Set up a SSL Session cache with a callback. This is needed for TLSv1.3+.
 590      * During the initial handshake the server signals to the client early on
 591      * that the handshake is finished, even before the client has sent its
 592      * credentials to the server. The actual connection (and moment that the
 593      * client sends its credentials) only starts after the arrival of the first
 594      * session ticket. The 'ssl_new_session_cb' catches this ticket.
 595      */
 596     SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_CLIENT | SSL_SESS_CACHE_NO_INTERNAL_STORE);
 597     SSL_CTX_sess_set_new_cb(ctx, ssl_new_session_cb);
 598
 599     /* As EAP-TLS+TLSv1.3 is highly experimental we offer the user a chance to override */
 600     if (max_tls_version)
 601     {
 602         if (strncmp(max_tls_version, "1.0", 3) == 0)
 603             tls_version = TLS1_VERSION;
 604         else if (strncmp(max_tls_version, "1.1", 3) == 0)
 605             tls_version = TLS1_1_VERSION;
 606         else if (strncmp(max_tls_version, "1.2", 3) == 0)
 607 #ifdef TLS1_2_VERSION
 608             tls_version = TLS1_2_VERSION;
 609 #else
 610         {
 611             warn("TLSv1.2 not available. Defaulting to TLSv1.1");
 612             tls_version = TLS_1_1_VERSION;
 613         }
 614 #endif
 615         else if (strncmp(max_tls_version, "1.3", 3) == 0)
 616 #ifdef TLS1_3_VERSION
 617             tls_version = TLS1_3_VERSION;
 618 #else
 619             warn("TLSv1.3 not available.");
 620 #endif
 621     }
 622
 623     dbglog("EAP-TLS: Setting max protocol version to 0x%X", tls_version);
 624     SSL_CTX_set_max_proto_version(ctx, tls_version);
 625
 626     SSL_CTX_set_verify_depth(ctx, 5);
 627     SSL_CTX_set_verify(ctx,
 628                SSL_VERIFY_PEER |
 629                SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
 630                &ssl_verify_callback);
 631
 632     if (crl_dir) {
 633         if (!(certstore = SSL_CTX_get_cert_store(ctx))) {
 634             error("EAP-TLS: Failed to get certificate store");
 635             goto fail;
 636         }
 637
 638         if (!(lookup =
 639              X509_STORE_add_lookup(certstore, X509_LOOKUP_hash_dir()))) {
 640             error("EAP-TLS: Store lookup for CRL failed");
 641
 642             goto fail;
 643         }
 644
 645         X509_LOOKUP_add_dir(lookup, crl_dir, X509_FILETYPE_PEM);
 646         X509_STORE_set_flags(certstore, X509_V_FLAG_CRL_CHECK);
 647     }
 648
 649     if (crl_file) {
 650         FILE     *fp  = NULL;
 651         X509_CRL *crl = NULL;
 652
 653         fp = fopen(crl_file, "r");
 654         if (!fp) {
 655             error("EAP-TLS: Cannot open CRL file '%s'", crl_file);
 656             goto fail;
 657         }
 658
 659         crl = PEM_read_X509_CRL(fp, NULL, NULL, NULL);
 660         if (!crl) {
 661             error("EAP-TLS: Cannot read CRL file '%s'", crl_file);
 662             goto fail;
 663         }
 664
 665         if (!(certstore = SSL_CTX_get_cert_store(ctx))) {
 666             error("EAP-TLS: Failed to get certificate store");
 667             goto fail;
 668         }
 669         if (!X509_STORE_add_crl(certstore, crl)) {
 670             error("EAP-TLS: Cannot add CRL to certificate store");
 671             goto fail;
 672         }
 673         X509_STORE_set_flags(certstore, X509_V_FLAG_CRL_CHECK);
 674
 675     }
 676
 677     /*
 678      * If a peer certificate file was specified, it must be valid, else fail
 679      */
 680     if (peer_certfile[0]) {
 681         if (!(tmp = get_X509_from_file(peer_certfile))) {
 682             error("EAP-TLS: Error loading client certificate from file %s",
 683                  peer_certfile);
 684             goto fail;
 685         }
 686         X509_free(tmp);
 687     }
 688
 689     return ctx;
 690
 691 fail:
 692     log_ssl_errors();
 693     SSL_CTX_free(ctx);
 694     return NULL;
 695 }
 696
 697 /*
 698  * Determine the maximum packet size by looking at the LCP handshake
 699  */
 700
 701 int eaptls_get_mtu(int unit)
 702 {
 703     int mtu, mru;
 704
 705     lcp_options *wo = &lcp_wantoptions[unit];
 706     lcp_options *go = &lcp_gotoptions[unit];
 707     lcp_options *ho = &lcp_hisoptions[unit];
 708     lcp_options *ao = &lcp_allowoptions[unit];
 709
 710     mtu = ho->neg_mru? ho->mru: PPP_MRU;
 711     mru = go->neg_mru? MAX(wo->mru, go->mru): PPP_MRU;
 712     mtu = MIN(MIN(mtu, mru), ao->mru)- PPP_HDRLEN - 10;
 713
 714     dbglog("MTU = %d", mtu);
 715     return mtu;
 716 }
 717
 718
 719 /*
 720  * Init the ssl handshake (server mode)
 721  */
 722 int eaptls_init_ssl_server(eap_state * esp)
 723 {
 724     struct eaptls_session *ets;
 725     char servcertfile[MAXWORDLEN];
 726     char clicertfile[MAXWORDLEN];
 727     char cacertfile[MAXWORDLEN];
 728     char capath[MAXWORDLEN];
 729     char pkfile[MAXWORDLEN];
 730     /*
 731      * Allocate new eaptls session
 732      */
 733     esp->es_server.ea_session = malloc(sizeof(struct eaptls_session));
 734     if (!esp->es_server.ea_session)
 735         fatal("Allocation error");
 736     ets = esp->es_server.ea_session;
 737
 738     if (!esp->es_server.ea_peer) {
 739         error("EAP-TLS: Error: client name not set (BUG)");
 740         return 0;
 741     }
 742
 743     strlcpy(ets->peer, esp->es_server.ea_peer, MAXWORDLEN-1);
 744
 745     dbglog( "getting eaptls secret" );
 746     if (!get_eaptls_secret(esp->es_unit, esp->es_server.ea_peer,
 747                    esp->es_server.ea_name, clicertfile,
 748                    servcertfile, cacertfile, capath, pkfile, 1)) {
 749         error( "EAP-TLS: Cannot get secret/password for client \"%s\", server \"%s\"",
 750                 esp->es_server.ea_peer, esp->es_server.ea_name );
 751         return 0;
 752     }
 753
 754     ets->mtu = eaptls_get_mtu(esp->es_unit);
 755
 756     ets->ctx = eaptls_init_ssl(1, cacertfile, capath, servcertfile, clicertfile, pkfile);
 757     if (!ets->ctx)
 758         goto fail;
 759
 760     if (!(ets->ssl = SSL_new(ets->ctx)))
 761         goto fail;
 762
 763     /*
 764      * Set auto-retry to avoid timeouts on BIO_read
 765      */
 766     SSL_set_mode(ets->ssl, SSL_MODE_AUTO_RETRY);
 767
 768     /*
 769      * Initialize the BIOs we use to read/write to ssl engine
 770      */
 771     ets->into_ssl = BIO_new(BIO_s_mem());
 772     ets->from_ssl = BIO_new(BIO_s_mem());
 773     SSL_set_bio(ets->ssl, ets->into_ssl, ets->from_ssl);
 774
 775     SSL_set_msg_callback(ets->ssl, ssl_msg_callback);
 776     SSL_set_msg_callback_arg(ets->ssl, ets);
 777
 778     /*
 779      * Attach the session struct to the connection, so we can later
 780      * retrieve it when doing certificate verification
 781      */
 782     SSL_set_ex_data(ets->ssl, 0, ets);
 783
 784     SSL_set_accept_state(ets->ssl);
 785
 786     ets->tls_v13 = 0;
 787
 788     ets->data = NULL;
 789     ets->datalen = 0;
 790     ets->alert_sent = 0;
 791     ets->alert_recv = 0;
 792
 793     /*
 794      * If we specified the client certificate file, store it in ets->peercertfile,
 795      * so we can check it later in ssl_verify_callback()
 796      */
 797     if (clicertfile[0])
 798         strlcpy(&ets->peercertfile[0], clicertfile, MAXWORDLEN);
 799     else
 800         ets->peercertfile[0] = 0;
 801
 802     return 1;
 803
 804 fail:
 805     SSL_CTX_free(ets->ctx);
 806     return 0;
 807 }
 808
 809 /*
 810  * Init the ssl handshake (client mode)
 811  */
 812 int eaptls_init_ssl_client(eap_state * esp)
 813 {
 814     struct eaptls_session *ets;
 815     char servcertfile[MAXWORDLEN];
 816     char clicertfile[MAXWORDLEN];
 817     char cacertfile[MAXWORDLEN];
 818     char capath[MAXWORDLEN];
 819     char pkfile[MAXWORDLEN];
 820
 821     /*
 822      * Allocate new eaptls session
 823      */
 824     esp->es_client.ea_session = malloc(sizeof(struct eaptls_session));
 825     if (!esp->es_client.ea_session)
 826         fatal("Allocation error");
 827     ets = esp->es_client.ea_session;
 828
 829     /*
 830      * If available, copy server name in ets; it will be used in cert
 831      * verify
 832      */
 833     if (esp->es_client.ea_peer)
 834         strlcpy(ets->peer, esp->es_client.ea_peer, MAXWORDLEN-1);
 835     else
 836         ets->peer[0] = 0;
 837
 838     ets->mtu = eaptls_get_mtu(esp->es_unit);
 839
 840     dbglog( "calling get_eaptls_secret" );
 841     if (!get_eaptls_secret(esp->es_unit, esp->es_client.ea_name,
 842                    ets->peer, clicertfile,
 843                    servcertfile, cacertfile, capath, pkfile, 0)) {
 844         error( "EAP-TLS: Cannot get secret/password for client \"%s\", server \"%s\"",
 845                 esp->es_client.ea_name, ets->peer );
 846         return 0;
 847     }
 848
 849     dbglog( "calling eaptls_init_ssl" );
 850     ets->ctx = eaptls_init_ssl(0, cacertfile, capath, clicertfile, servcertfile, pkfile);
 851     if (!ets->ctx)
 852         goto fail;
 853
 854     ets->ssl = SSL_new(ets->ctx);
 855
 856     if (!ets->ssl)
 857         goto fail;
 858
 859     /*
 860      * Initialize the BIOs we use to read/write to ssl engine
 861      */
 862     dbglog( "Initializing SSL BIOs" );
 863     ets->into_ssl = BIO_new(BIO_s_mem());
 864     ets->from_ssl = BIO_new(BIO_s_mem());
 865     SSL_set_bio(ets->ssl, ets->into_ssl, ets->from_ssl);
 866
 867     SSL_set_msg_callback(ets->ssl, ssl_msg_callback);
 868     SSL_set_msg_callback_arg(ets->ssl, ets);
 869
 870     /*
 871      * Attach the session struct to the connection, so we can later
 872      * retrieve it when doing certificate verification
 873      */
 874     SSL_set_ex_data(ets->ssl, 0, ets);
 875
 876     SSL_set_connect_state(ets->ssl);
 877
 878     ets->tls_v13 = 0;
 879
 880     ets->data = NULL;
 881     ets->datalen = 0;
 882     ets->alert_sent = 0;
 883     ets->alert_recv = 0;
 884
 885     /*
 886      * If we specified the server certificate file, store it in
 887      * ets->peercertfile, so we can check it later in
 888      * ssl_verify_callback()
 889      */
 890     if (servcertfile[0])
 891         strlcpy(ets->peercertfile, servcertfile, MAXWORDLEN);
 892     else
 893         ets->peercertfile[0] = 0;
 894
 895     return 1;
 896
 897 fail:
 898     dbglog( "eaptls_init_ssl_client: fail" );
 899     SSL_CTX_free(ets->ctx);
 900     return 0;
 901
 902 }
 903
 904 void eaptls_free_session(struct eaptls_session *ets)
 905 {
 906     if (ets->ssl)
 907         SSL_free(ets->ssl);
 908
 909     if (ets->ctx)
 910         SSL_CTX_free(ets->ctx);
 911
 912     free(ets);
 913 }
 914
 915
 916 int eaptls_is_init_finished(struct eaptls_session *ets)
 917 {
 918     if (ets->ssl && SSL_is_init_finished(ets->ssl))
 919     {
 920         if (ets->tls_v13)
 921             return have_session_ticket;
 922         else
 923             return 1;
 924     }
 925
 926     return 0;
 927 }
 928
 929 /*
 930  * Handle a received packet, reassembling fragmented messages and
 931  * passing them to the ssl engine
 932  */
 933 int eaptls_receive(struct eaptls_session *ets, u_char * inp, int len)
 934 {
 935     u_char flags;
 936     u_int tlslen = 0;
 937     u_char dummy[65536];
 938
 939     if (len < 1) {
 940         warn("EAP-TLS: received no or invalid data");
 941         return 1;
 942     }
 943
 944     GETCHAR(flags, inp);
 945     len--;
 946
 947     if (flags & EAP_TLS_FLAGS_LI && len > 4) {
 948         /*
 949          * LenghtIncluded flag set -> this is the first packet of a message
 950         */
 951
 952         /*
 953          * the first 4 octets are the length of the EAP-TLS message
 954          */
 955         GETLONG(tlslen, inp);
 956         len -= 4;
 957
 958         if (!ets->data) {
 959
 960             if (tlslen > EAP_TLS_MAX_LEN) {
 961                 error("EAP-TLS: TLS message length > %d, truncated", EAP_TLS_MAX_LEN);
 962                 tlslen = EAP_TLS_MAX_LEN;
 963             }
 964
 965             /*
 966              * Allocate memory for the whole message
 967             */
 968             ets->data = malloc(tlslen);
 969             if (!ets->data)
 970                 fatal("EAP-TLS: allocation error\n");
 971
 972             ets->datalen = 0;
 973             ets->tlslen = tlslen;
 974         }
 975         else
 976             warn("EAP-TLS: non-first LI packet? that's odd...");
 977     }
 978     else if (!ets->data) {
 979         /*
 980          * A non fragmented message without LI flag
 981         */
 982
 983         ets->data = malloc(len);
 984         if (!ets->data)
 985             fatal("EAP-TLS: allocation error\n");
 986
 987         ets->datalen = 0;
 988         ets->tlslen = len;
 989     }
 990
 991     if (flags & EAP_TLS_FLAGS_MF)
 992         ets->frag = 1;
 993     else
 994         ets->frag = 0;
 995
 996     if (len < 0) {
 997         warn("EAP-TLS: received malformed data");
 998         return 1;
 999     }
1000
1001     if (len + ets->datalen > ets->tlslen) {
1002         warn("EAP-TLS: received data > TLS message length");
1003         return 1;
1004     }
1005
1006     BCOPY(inp, ets->data + ets->datalen, len);
1007     ets->datalen += len;
1008
1009     if (!ets->frag) {
1010
1011         /*
1012          * If we have the whole message, pass it to ssl
1013          */
1014
1015         if (ets->datalen != ets->tlslen) {
1016             warn("EAP-TLS: received data != TLS message length");
1017             return 1;
1018         }
1019
1020         if (BIO_write(ets->into_ssl, ets->data, ets->datalen) == -1)
1021             log_ssl_errors();
1022
1023         SSL_read(ets->ssl, dummy, 65536);
1024
1025         free(ets->data);
1026         ets->data = NULL;
1027         ets->datalen = 0;
1028     }
1029
1030     return 0;
1031 }
1032
1033 /*
1034  * Return an eap-tls packet in outp.
1035  * A TLS message read from the ssl engine is buffered in ets->data.
1036  * At each call we control if there is buffered data and send a
1037  * packet of mtu bytes.
1038  */
1039 int eaptls_send(struct eaptls_session *ets, u_char ** outp)
1040 {
1041     bool first = 0;
1042     int size;
1043     u_char fromtls[65536];
1044     int res;
1045     u_char *start;
1046
1047     start = *outp;
1048
1049     if (!ets->data)
1050     {
1051         if(!ets->alert_sent)
1052         {
1053             res = SSL_read(ets->ssl, fromtls, 65536);
1054         }
1055
1056         /*
1057          * Read from ssl
1058          */
1059         if ((res = BIO_read(ets->from_ssl, fromtls, 65536)) == -1)
1060         {
1061             warn("EAP-TLS send: No data from BIO_read");
1062             return 1;
1063         }
1064
1065         ets->datalen = res;
1066
1067         ets->data = malloc(ets->datalen);
1068         BCOPY(fromtls, ets->data, ets->datalen);
1069
1070         ets->offset = 0;
1071         first = 1;
1072
1073     }
1074
1075     size = ets->datalen - ets->offset;
1076
1077     if (size > ets->mtu) {
1078         size = ets->mtu;
1079         ets->frag = 1;
1080     } else
1081         ets->frag = 0;
1082
1083     PUTCHAR(EAPT_TLS, *outp);
1084
1085     /*
1086      * Set right flags and length if necessary
1087      */
1088     if (ets->frag && first) {
1089         PUTCHAR(EAP_TLS_FLAGS_LI | EAP_TLS_FLAGS_MF, *outp);
1090         PUTLONG(ets->datalen, *outp);
1091     } else if (ets->frag) {
1092         PUTCHAR(EAP_TLS_FLAGS_MF, *outp);
1093     } else
1094         PUTCHAR(0, *outp);
1095
1096     /*
1097      * Copy the data in outp
1098      */
1099     BCOPY(ets->data + ets->offset, *outp, size);
1100     INCPTR(size, *outp);
1101
1102     /*
1103      * Copy the packet in retransmission buffer
1104      */
1105     BCOPY(start, &ets->rtx[0], *outp - start);
1106     ets->rtx_len = *outp - start;
1107
1108     ets->offset += size;
1109
1110     if (ets->offset >= ets->datalen) {
1111
1112         /*
1113          * The whole message has been sent
1114          */
1115
1116         free(ets->data);
1117         ets->data = NULL;
1118         ets->datalen = 0;
1119         ets->offset = 0;
1120     }
1121
1122     return 0;
1123 }
1124
1125 /*
1126  * Get the sent packet from the retransmission buffer
1127  */
1128 void eaptls_retransmit(struct eaptls_session *ets, u_char ** outp)
1129 {
1130     BCOPY(ets->rtx, *outp, ets->rtx_len);
1131     INCPTR(ets->rtx_len, *outp);
1132 }
1133
1134 /*
1135  * Verify a certificate.
1136  * Most of the work (signatures and issuer attributes checking)
1137  * is done by ssl; we check the CN in the peer certificate
1138  * against the peer name.
1139  */
1140 int ssl_verify_callback(int ok, X509_STORE_CTX * ctx)
1141 {
1142     char subject[256];
1143     char cn_str[256];
1144     X509 *peer_cert;
1145     int err, depth;
1146     SSL *ssl;
1147     struct eaptls_session *ets;
1148
1149     peer_cert = X509_STORE_CTX_get_current_cert(ctx);
1150     err = X509_STORE_CTX_get_error(ctx);
1151     depth = X509_STORE_CTX_get_error_depth(ctx);
1152
1153     dbglog("certificate verify depth: %d", depth);
1154
1155     if (auth_required && !ok) {
1156         X509_NAME_oneline(X509_get_subject_name(peer_cert),
1157                   subject, 256);
1158
1159         X509_NAME_get_text_by_NID(X509_get_subject_name(peer_cert),
1160                       NID_commonName, cn_str, 256);
1161
1162         dbglog("Certificate verification error:\n depth: %d CN: %s"
1163                "\n err: %d (%s)\n", depth, cn_str, err,
1164                X509_verify_cert_error_string(err));
1165
1166         return 0;
1167     }
1168
1169     ssl = X509_STORE_CTX_get_ex_data(ctx,
1170                        SSL_get_ex_data_X509_STORE_CTX_idx());
1171
1172     ets = (struct eaptls_session *)SSL_get_ex_data(ssl, 0);
1173
1174     if (ets == NULL) {
1175         error("Error: SSL_get_ex_data returned NULL");
1176         return 0;
1177     }
1178
1179     log_ssl_errors();
1180
1181     if (!depth)
1182     {
1183         /* This is the peer certificate */
1184
1185         X509_NAME_oneline(X509_get_subject_name(peer_cert),
1186                   subject, 256);
1187
1188         X509_NAME_get_text_by_NID(X509_get_subject_name(peer_cert),
1189                       NID_commonName, cn_str, 256);
1190
1191         /*
1192          * If acting as client and the name of the server wasn't specified
1193          * explicitely, we can't verify the server authenticity
1194          */
1195         if (!ets->peer[0]) {
1196             warn("Peer name not specified: no check");
1197             return ok;
1198         }
1199
1200         /*
1201          * Check the CN
1202          */
1203         if (strcmp(cn_str, ets->peer)) {
1204             error
1205                 ("Certificate verification error: CN (%s) != peer_name (%s)",
1206                  cn_str, ets->peer);
1207             return 0;
1208         }
1209
1210         warn("Certificate CN: %s , peer name %s", cn_str, ets->peer);
1211
1212         /*
1213          * If a peer certificate file was specified, here we check it
1214          */
1215         if (ets->peercertfile[0]) {
1216             if (ssl_cmp_certs(&ets->peercertfile[0], peer_cert)
1217                 != 0) {
1218                 error
1219                     ("Peer certificate doesn't match stored certificate");
1220                 return 0;
1221             }
1222         }
1223     }
1224
1225     return ok;
1226 }
1227
1228 /*
1229  * Compare a certificate with the one stored in a file
1230  */
1231 int ssl_cmp_certs(char *filename, X509 * a)
1232 {
1233     X509 *b;
1234     int ret;
1235
1236     if (!(b = get_X509_from_file(filename)))
1237         return 1;
1238
1239     ret = X509_cmp(a, b);
1240     X509_free(b);
1241
1242     return ret;
1243
1244 }
1245
1246 X509 *get_X509_from_file(char *filename)
1247 {
1248     FILE *fp;
1249     X509 *ret;
1250
1251     if (!(fp = fopen(filename, "r")))
1252         return NULL;
1253
1254     ret = PEM_read_X509(fp, NULL, NULL, NULL);
1255
1256     fclose(fp);
1257
1258     return ret;
1259 }
1260
1261 /*
1262  * Every sent & received message this callback function is invoked,
1263  * so we know when alert messages have arrived or are sent and
1264  * we can print debug information about TLS handshake.
1265  */
1266 void
1267 ssl_msg_callback(int write_p, int version, int content_type,
1268          const void *buf, size_t len, SSL * ssl, void *arg)
1269 {
1270     char string[256];
1271     struct eaptls_session *ets = (struct eaptls_session *)arg;
1272     unsigned char code;
1273     const unsigned char*msg = buf;
1274     int hvers = msg[1] << 8 | msg[2];
1275
1276     if(write_p)
1277         strcpy(string, " -> ");
1278     else
1279         strcpy(string, " <- ");
1280
1281     switch(content_type) {
1282
1283     case SSL3_RT_HEADER:
1284         strcat(string, "SSL/TLS Header: ");
1285         switch(hvers) {
1286         case SSL3_VERSION:
1287                 strcat(string, "SSL 3.0");
1288                 break;
1289         case TLS1_VERSION:
1290                 strcat(string, "TLS 1.0");
1291                 break;
1292         case TLS1_1_VERSION:
1293                 strcat(string, "TLS 1.1");
1294                 break;
1295         case TLS1_2_VERSION:
1296                 strcat(string, "TLS 1.2");
1297                 break;
1298         default:
1299             sprintf(string, "SSL/TLS Header: Unknown version (%d)", hvers);
1300         }
1301         break;
1302
1303     case SSL3_RT_ALERT:
1304         strcat(string, "Alert: ");
1305         code = msg[1];
1306
1307         if (write_p) {
1308             ets->alert_sent = 1;
1309             ets->alert_sent_desc = code;
1310         } else {
1311             ets->alert_recv = 1;
1312             ets->alert_recv_desc = code;
1313         }
1314
1315         strcat(string, SSL_alert_desc_string_long(code));
1316         break;
1317
1318     case SSL3_RT_CHANGE_CIPHER_SPEC:
1319         strcat(string, "ChangeCipherSpec");
1320         break;
1321
1322 #ifdef SSL3_RT_INNER_CONTENT_TYPE
1323     case SSL3_RT_INNER_CONTENT_TYPE:
1324         strcat(string, "InnerContentType (TLS1.3)");
1325         break;
1326 #endif
1327
1328     case SSL3_RT_HANDSHAKE:
1329
1330         strcat(string, "Handshake: ");
1331         code = msg[0];
1332
1333         switch(code) {
1334             case SSL3_MT_HELLO_REQUEST:
1335                 strcat(string,"Hello Request");
1336                 break;
1337             case SSL3_MT_CLIENT_HELLO:
1338                 strcat(string,"Client Hello");
1339                 break;
1340             case SSL3_MT_SERVER_HELLO:
1341                 strcat(string,"Server Hello");
1342                 break;
1343 #ifdef SSL3_MT_NEWSESSION_TICKET
1344             case SSL3_MT_NEWSESSION_TICKET:
1345                 strcat(string,"New Session Ticket");
1346                 break;
1347 #endif
1348 #ifdef SSL3_MT_END_OF_EARLY_DATA
1349             case SSL3_MT_END_OF_EARLY_DATA:
1350                 strcat(string,"End of Early Data");
1351                 break;
1352 #endif
1353 #ifdef SSL3_MT_ENCRYPTED_EXTENSIONS
1354             case SSL3_MT_ENCRYPTED_EXTENSIONS:
1355                 strcat(string,"Encryped Extensions");
1356                 break;
1357 #endif
1358             case SSL3_MT_CERTIFICATE:
1359                 strcat(string,"Certificate");
1360                 break;
1361             case SSL3_MT_SERVER_KEY_EXCHANGE:
1362                 strcat(string,"Server Key Exchange");
1363                 break;
1364             case SSL3_MT_CERTIFICATE_REQUEST:
1365                 strcat(string,"Certificate Request");
1366                 break;
1367             case SSL3_MT_SERVER_DONE:
1368                 strcat(string,"Server Hello Done");
1369                 break;
1370             case SSL3_MT_CERTIFICATE_VERIFY:
1371                 strcat(string,"Certificate Verify");
1372                 break;
1373             case SSL3_MT_CLIENT_KEY_EXCHANGE:
1374                 strcat(string,"Client Key Exchange");
1375                 break;
1376             case SSL3_MT_FINISHED:
1377                 strcat(string,"Finished: ");
1378                 hvers = SSL_version(ssl);
1379                 switch(hvers){
1380                     case SSL3_VERSION:
1381                         strcat(string, "SSL 3.0");
1382                         break;
1383                     case TLS1_VERSION:
1384                         strcat(string, "TLS 1.0");
1385                         break;
1386                     case TLS1_1_VERSION:
1387                         strcat(string, "TLS 1.1");
1388                         break;
1389                     case TLS1_2_VERSION:
1390                         strcat(string, "TLS 1.2");
1391                         break;
1392 #ifdef TLS1_3_VERSION
1393                     case TLS1_3_VERSION:
1394                         strcat(string, "TLS 1.3 (experimental)");
1395                         ets->tls_v13 = 1;
1396                         break;
1397 #endif
1398                     default:
1399                         strcat(string, "Unknown version");
1400                 }
1401                 break;
1402             default:
1403                 sprintf( string, "Handshake: Unknown SSL3 code received: %d", code );
1404         }
1405         break;
1406
1407     default:
1408         sprintf( string, "SSL message contains unknown content type: %d", content_type );
1409     }
1410
1411     /* Alert messages must always be displayed */
1412     if(content_type == SSL3_RT_ALERT)
1413         error("%s", string);
1414     else
1415         dbglog("%s", string);
1416 }
1417
1418 int
1419 ssl_new_session_cb(SSL *s, SSL_SESSION *sess)
1420 {
1421     dbglog("EAP-TLS: Post-Handshake New Session Ticket arrived:");
1422     have_session_ticket = 1;
1423
1424     /* always return success */
1425     return 1;
1426 }
1427