1

#include "ssl_internal.h"

     2

     3

#include <gnutls/x509.h>

     4

     5

#include <stdlib.h>

     6

#include <string.h>

     7

#include <time.h>

     8

     9

// XXX: remove

    10

#include "log.h"

    11

#include <assert.h>

    12

    13

    14

/**

    15

 * Cast a ssl_client to a sock_fd.

    16

 */

    17

#define SSL_CLIENT_FD(client_ptr) (&(client_ptr)->base_tcp.base_trans.base_fd)

    18

    19

/**

    20

 * Cast a ssl_client to a sock_stream.

    21

 */

    22

#define SSL_CLIENT_TRANSPORT(client_ptr) (&(client_ptr)->base_tcp.base_trans.base_fd.base)

    23

    24

    25

    26

/**

    27

 * Enable the TCP events based on the session's gnutls_record_get_direction().

    28

 */

    29

static err_t ssl_client_ev_enable (struct ssl_client *client, error_t *err)

    30

{

    31

    int ret;

    32

    short mask;

    33

    34

    // gnutls_record_get_direction tells us what I/O operation gnutls would have required for the last

    35

    // operation, so we can use that to determine what events to register

    36

    switch ((ret = gnutls_record_get_direction(client->session))) {

    37

        case 0: 

    38

            // read more data

    39

            mask = TRANSPORT_READ;

    40

            break;

    41

    42

        case 1:

    43

            // write buffer full

    44

            mask = TRANSPORT_WRITE;

    45

            break;

    46

    47

        default:

    48

            // random error

    49

            RETURN_SET_ERROR_EXTRA(err, ERR_GNUTLS_RECORD_GET_DIRECTION, ret);

    50

    }

    51

    52

    // do the enabling

    53

    if ((ERROR_CODE(err) = transport_fd_enable(SSL_CLIENT_FD(client), mask)))

    54

        return ERROR_CODE(err);

    55

    56

    57

    return SUCCESS;

    58

}

    59

    60

/**

    61

 * Translate a set of gnutls_certificate_status_t values to a constant error message

    62

 */

    63

static const char* ssl_client_verify_error (unsigned int status)

    64

{

    65

    if (status & GNUTLS_CERT_REVOKED)

    66

        return "certificate was revoked";

    67

    68

    else if (status & GNUTLS_CERT_INVALID) {

    69

        if (status & GNUTLS_CERT_SIGNER_NOT_FOUND)

    70

            return "certificate signer was not found";

    71

    72

        else if (status & GNUTLS_CERT_SIGNER_NOT_CA)

    73

            return "certificate signer is not a Certificate Authority";

    74

    75

        else if (status & GNUTLS_CERT_INSECURE_ALGORITHM)

    76

            return "certificate signed using an insecure algorithm";

    77

    78

        else

    79

            return "certificate could not be verified";

    80

    81

    } else

    82

        return "unknown error";

    83

    84

}

    85

    86

/**

    87

 * Perform the certificate validation procedure on the peer cert.

    88

 *

    89

 * Based on the GnuTLS examples/ex-rfc2818.c

    90

 */

    91

static err_t ssl_client_verify (struct ssl_client *client, error_t *err)

    92

{

    93

    unsigned int status;

    94

    const gnutls_datum_t *cert_list;

    95

    unsigned int cert_list_size;

    96

    gnutls_x509_crt_t cert = NULL;

    97

    time_t t, now;

    98

    99

    // init

   100

    RESET_ERROR(err);

   101

    now = time(NULL);

   102

   103

    // inspect the peer's cert chain using the installed trusted CAs

   104

    if ((ERROR_EXTRA(err) = gnutls_certificate_verify_peers2(client->session, &status)))

   105

        JUMP_SET_ERROR(err, ERR_GNUTLS_CERT_VERIFY_PEERS2);

   106

   107

    // verify errors?

   108

    if (status)

   109

        JUMP_SET_ERROR_STR(err, ERR_GNUTLS_CERT_VERIFY, ssl_client_verify_error(status));

   110

   111

    // import the main cert

   112

    assert(gnutls_certificate_type_get(client->session) == GNUTLS_CRT_X509);

   113

   114

    if ((ERROR_EXTRA(err) = gnutls_x509_crt_init(&cert)))

   115

        JUMP_SET_ERROR_STR(err, ERR_GNUTLS_CERT_VERIFY, "gnutls_x509_crt_init");

   116

   117

    if ((cert_list = gnutls_certificate_get_peers(client->session, &cert_list_size)) == NULL)

   118

        JUMP_SET_ERROR_STR(err, ERR_GNUTLS_CERT_VERIFY, "gnutls_certificate_get_peers");

   119

   120

    if (!cert_list_size)

   121

        JUMP_SET_ERROR_STR(err, ERR_GNUTLS_CERT_VERIFY, "cert_list_size");

   122

   123

    if ((ERROR_EXTRA(err) = gnutls_x509_crt_import(cert, &cert_list[0], GNUTLS_X509_FMT_DER)))

   124

        JUMP_SET_ERROR_STR(err, ERR_GNUTLS_CERT_VERIFY, "gnutls_x509_crt_import");

   125

   126

    // check expire/activate... not sure if we need to do this

   127

    if ((t = gnutls_x509_crt_get_expiration_time(cert)) == ((time_t) -1) || t < now)

   128

        JUMP_SET_ERROR_STR(err, ERR_GNUTLS_CERT_VERIFY, "gnutls_x509_crt_get_expiration_time");

   129

   130

    if ((t = gnutls_x509_crt_get_activation_time(cert)) == ((time_t) -1) || t > now)

   131

        JUMP_SET_ERROR_STR(err, ERR_GNUTLS_CERT_VERIFY, "gnutls_x509_crt_get_activation_time");

   132

   133

    // check hostname

   134

    if (!gnutls_x509_crt_check_hostname(cert, client->hostname))

   135

        JUMP_SET_ERROR_STR(err, ERR_GNUTLS_CERT_VERIFY, "gnutls_x509_crt_check_hostname");

   136

   137

error:

   138

    // cleanup

   139

    if (cert)

   140

        gnutls_x509_crt_deinit(cert);

   141

   142

    // should be SUCCESS

   143

    return ERROR_CODE(err);    

   144

}

   145

   146

   147

/**

   148

 * Our handshake driver. This will execute the next gnutls_handshake step, handling E_AGAIN.

   149

 *

   150

 * This updates the ssl_client::handshake state internally, as used by ssl_client_event_handler.

   151

 *

   152

 * If the client is marked as verify, this will perform the verification, returning on any errors, and then unset the

   153

 * verify flag - this ensures that the peer cert is only verified once per connection...

   154

 *

   155

 * @return >0 for finished handshake, 0 for handshake-in-progress, -err_t for errors.

   156

 */

   157

static int ssl_client_handshake (struct ssl_client *client, error_t *err)

   158

{

   159

    int ret;

   160

   161

    // perform the handshake

   162

    if ((ret = gnutls_handshake(client->session)) < 0 && ret != GNUTLS_E_AGAIN)

   163

        JUMP_SET_ERROR_EXTRA(err, ERR_GNUTLS_HANDSHAKE, ret);

   164

   165

    // complete?

   166

    if (ret == 0) {

   167

        // update state

   168

        client->handshake = false;

   169

   170

        // verify?

   171

        if (client->verify) {

   172

            // perform the validation

   173

            if (ssl_client_verify(client, err))

   174

                goto error;

   175

   176

            // unmark

   177

            client->verify = false;

   178

        }

   179

   180

        // handshake done

   181

        return 1;

   182

   183

    } else {

   184

        // set state, isn't really needed every time, but easier this way

   185

        client->handshake = true;

   186

   187

        // re-enable the event for the next iteration

   188

        return ssl_client_ev_enable(client, err);

   189

    }

   190

   191

error:

   192

    return -ERROR_CODE(err);    

   193

}

   194

   195

/**

   196

 * Our transport_fd event handler. Drive the handshake if that's current, otherwise, invoke user callbacks.

   197

 */

   198

static void ssl_client_on_event (struct transport_fd *fd, short what, void *arg)

   199

{

   200

    struct ssl_client *client = arg;

   201

    error_t err;

   202

   203

    (void) fd;

   204

   205

    // XXX: timeouts

   206

    (void) what;

   207

   208

    // are we in the handshake cycle?

   209

    if (client->handshake) {

   210

        RESET_ERROR(&err);

   211

   212

        // perform the next handshake step

   213

        // this returns zero when the handshake is not yet done, errors/completion then trigger the else-if-else below

   214

        if (ssl_client_handshake(client, &err) == 0) {

   215

            // handshake continues

   216

   217

        } else if (!SSL_CLIENT_TRANSPORT(client)->connected) {

   218

            // the async connect+handshake process has completed

   219

            // invoke the user connect callback directly with appropriate error

   220

            transport_connected(SSL_CLIENT_TRANSPORT(client), ERROR_CODE(&err) ? &err : NULL, true);

   221

   222

        } else {

   223

            // in-connection re-handshake completed

   224

            if (ERROR_CODE(&err))

   225

                // the re-handshake failed, so this transport is dead

   226

                transport_error(SSL_CLIENT_TRANSPORT(client), &err);

   227

   228

            else

   229

                // re-handshake completed, so continue with the transport_callbacks

   230

                transport_invoke(SSL_CLIENT_TRANSPORT(client), what);

   231

        }

   232

   233

    } else {

   234

        // normal transport operation

   235

        // gnutls might be able to proceed now, so invoke user callbacks

   236

        transport_invoke(SSL_CLIENT_TRANSPORT(client), what);

   237

    }

   238

}

   239

   240

static err_t ssl_client__read (transport_t *transport, void *buf, size_t *len, error_t *err)

   241

{

   242

    struct ssl_client *client = transport_check(transport, &ssl_client_type);

   243

    int ret;

   244

   245

    // read gnutls record

   246

    do {

   247

        ret = gnutls_record_recv(client->session, buf, *len);

   248

   249

    } while (ret == GNUTLS_E_INTERRUPTED);

   250

   251

    // errors

   252

    // XXX: E_REHANDSHAKE?

   253

    if (ret < 0 && ret != GNUTLS_E_AGAIN)

   254

        RETURN_SET_ERROR_EXTRA(err, ERR_GNUTLS_RECORD_RECV, ret);

   255

   256

    else if (ret == 0)

   257

        return SET_ERROR(err, ERR_EOF);

   258

   259

   260

    // EAGAIN?

   261

    if (ret < 0) {

   262

        *len = 0;

   263

   264

    } else {

   265

        // updated length

   266

        *len = ret;

   267

   268

    }

   269

   270

    return SUCCESS;

   271

}

   272

   273

static err_t ssl_client__write (transport_t *transport, const void *buf, size_t *len, error_t *err)

   274

{

   275

    struct ssl_client *client = transport_check(transport, &ssl_client_type);

   276

    int ret;

   277

   278

    // read gnutls record

   279

    do {

   280

        ret = gnutls_record_send(client->session, buf, *len);

   281

   282

    } while (ret == GNUTLS_E_INTERRUPTED);

   283

   284

    // errors

   285

    if (ret < 0 && ret != GNUTLS_E_AGAIN)

   286

        RETURN_SET_ERROR_EXTRA(err, ERR_GNUTLS_RECORD_SEND, ret);

   287

   288

    else if (ret == 0)

   289

        return SET_ERROR(err, ERR_WRITE_EOF);

   290

   291

   292

    // eagain?

   293

    if (ret < 0) {

   294

        *len = 0;

   295

   296

    } else {

   297

        // updated length

   298

        *len = ret;

   299

    }

   300

   301

    return SUCCESS;

   302

}

   303

   304

void ssl_client_deinit (struct ssl_client *client)

   305

{

   306

    // close the session rudely

   307

    gnutls_deinit(client->session);

   308

    client->session = NULL;

   309

   310

    // terminate the TCP transport

   311

    tcp_client_deinit(&client->base_tcp);

   312

   313

    if (client->cred) {

   314

        // drop the cred ref

   315

        ssl_client_cred_put(client->cred);

   316

   317

        client->cred = NULL;

   318

    }

   319

   320

    // free

   321

    free(client->hostname);

   322

    client->hostname = NULL;

   323

}

   324

   325

   326

static void ssl_client__deinit (transport_t *transport)

   327

{

   328

    struct ssl_client *client = transport_check(transport, &ssl_client_type);

   329

   330

    // die

   331

    ssl_client_deinit(client);

   332

}

   333

   334

/**

   335

 * Our tcp_client-invoked connect handler

   336

 */

   337

static void ssl_client__connected (transport_t *transport, const error_t *tcp_err)

   338

{

   339

    struct ssl_client *client = transport_check(transport, &ssl_client_type);

   340

    error_t err;

   341

   342

    // trap errors to let the user handle them directly

   343

    if (tcp_err)

   344

        JUMP_SET_ERROR_INFO(&err, tcp_err);

   345

   346

    // bind default transport functions (recv/send) to use the TCP fd

   347

    gnutls_transport_set_ptr(client->session, (gnutls_transport_ptr_t) (long int) SSL_CLIENT_FD(client)->fd);

   348

   349

    // add ourselves as the event handler

   350

    if ((ERROR_CODE(&err) = transport_fd_setup(SSL_CLIENT_FD(client), ssl_client_on_event, client)))

   351

        goto error;

   352

   353

    // start handshake

   354

    if (ssl_client_handshake(client, &err))

   355

        // this should complete with SUCCESS if it returns >0

   356

        goto error;

   357

   358

    // ok, so we wait...

   359

    return;

   360

   361

error:

   362

    // tell the user

   363

    transport_connected(transport, &err, true);

   364

}

   365

   366

struct transport_type ssl_client_type = {

   367

    .base_type = {

   368

        .parent     = &tcp_client_type.base_type,

   369

    },

   370

    .methods = {

   371

        .read       = ssl_client__read,

   372

        .write      = ssl_client__write,

   373

        .deinit     = ssl_client__deinit,

   374

        ._connected = ssl_client__connected,

   375

    },

   376

};

   377

   378

   379

   380

static void ssl_client_destroy (struct ssl_client *client)

   381

{

   382

    ssl_client_deinit(client);

   383

   384

    free(client);

   385

}

   386

   387

err_t ssl_connect (const struct transport_info *info, transport_t **transport_ptr, 

   388

        const char *hostname, const char *service,

   389

        struct ssl_client_cred *cred,

   390

        error_t *err

   391

    )

   392

{

   393

    struct ssl_client *client = NULL;

   394

   395

    // alloc

   396

    if ((client = calloc(1, sizeof(*client))) == NULL)

   397

        return SET_ERROR(err, ERR_CALLOC);

   398

   399

    // initialize base

   400

    transport_init(SSL_CLIENT_TRANSPORT(client), &ssl_client_type, info);

   401

   402

    if (!cred) {

   403

        // default credentials

   404

        cred = &ssl_client_cred_anon;

   405

   406

    } else {

   407

        // take a ref

   408

        client->cred = cred;

   409

        cred->refcount++;

   410

    };

   411

   412

    // do verify?

   413

    if (cred->verify)

   414

        client->verify = true;

   415

   416

    // init

   417

    if ((client->hostname = strdup(hostname)) == NULL)

   418

        JUMP_SET_ERROR(err, ERR_STRDUP);

   419

   420

    // initialize TCP

   421

    tcp_client_init(&client->base_tcp);

   422

   423

    // initialize client session

   424

    if ((ERROR_EXTRA(err) = gnutls_init(&client->session, GNUTLS_CLIENT)) < 0)

   425

        JUMP_SET_ERROR(err, ERR_GNUTLS_INIT);

   426

   427

    // ...default priority stuff

   428

    if ((ERROR_EXTRA(err) = gnutls_set_default_priority(client->session)))

   429

        JUMP_SET_ERROR(err, ERR_GNUTLS_SET_DEFAULT_PRIORITY);

   430

   431

    // XXX: silly hack for OpenSSL interop

   432

    gnutls_dh_set_prime_bits(client->session, 512);

   433

   434

    // bind credentials

   435

    if ((ERROR_EXTRA(err) = gnutls_credentials_set(client->session, GNUTLS_CRD_CERTIFICATE, cred->x509)))

   436

        JUMP_SET_ERROR(err, ERR_GNUTLS_CRED_SET);

   437

   438

    // TCP connect

   439

    if (tcp_client_connect_async(&client->base_tcp, hostname, service, err))

   440

        goto error;

   441

   442

    // done, wait for the connect to complete

   443

    *transport_ptr = SSL_CLIENT_TRANSPORT(client);

   444

   445

    return SUCCESS;

   446

   447

error:

   448

    // cleanup

   449

    ssl_client_destroy(client);

   450

   451

    return ERROR_CODE(err);    

   452

}

   453

   454