tests/mini-dtls-heartbeat.c

   1 /*
   2  * Copyright (C) 2012 Free Software Foundation, Inc.
   3  *
   4  * Author: Nikos Mavrogiannopoulos
   5  *
   6  * This file is part of GnuTLS.
   7  *
   8  * GnuTLS is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * GnuTLS is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with GnuTLS; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29
  30 #if defined(_WIN32)
  31
  32 int
  33 main ()
  34 {
  35     exit (77);
  36 }
  37
  38 #else
  39
  40 #include <string.h>
  41 #include <sys/types.h>
  42 #include <netinet/in.h>
  43 #include <sys/socket.h>
  44 #include <sys/wait.h>
  45 #include <arpa/inet.h>
  46 #include <unistd.h>
  47 #include <gnutls/gnutls.h>
  48 #include <gnutls/dtls.h>
  49
  50 #include "utils.h"
  51
  52 static void terminate (void);
  53
  54 /* This program tests the rehandshake in DTLS
  55  */
  56
  57 static void
  58 server_log_func (int level, const char *str)
  59 {
  60     fprintf (stderr, "server|<%d>| %s", level, str);
  61 }
  62
  63 static void
  64 client_log_func (int level, const char *str)
  65 {
  66     fprintf (stderr, "client|<%d>| %s", level, str);
  67 }
  68
  69 /* These are global */
  70 static pid_t child;
  71
  72 /* A very basic DTLS client, with anonymous authentication, that exchanges heartbeats.
  73  */
  74
  75 #define MAX_BUF 1024
  76
  77
  78 static void
  79 client (int fd, int server_init)
  80 {
  81     gnutls_session_t session;
  82     int ret, ret2;
  83     char buffer[MAX_BUF + 1];
  84     gnutls_anon_client_credentials_t anoncred;
  85     /* Need to enable anonymous KX specifically. */
  86
  87     gnutls_global_init ();
  88
  89     if (debug)
  90       {
  91           gnutls_global_set_log_function (client_log_func);
  92           gnutls_global_set_log_level (4711);
  93       }
  94
  95     gnutls_anon_allocate_client_credentials (&anoncred);
  96
  97     /* Initialize TLS session
  98      */
  99     gnutls_init (&session, GNUTLS_CLIENT | GNUTLS_DATAGRAM);
 100     gnutls_heartbeat_enable (session, GNUTLS_HB_PEER_ALLOWED_TO_SEND);
 101     gnutls_dtls_set_mtu (session, 1500);
 102
 103     /* Use default priorities */
 104     gnutls_priority_set_direct (session,
 105                                 "NONE:+VERS-DTLS1.0:+CIPHER-ALL:+MAC-ALL:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+CURVE-ALL",
 106                                 NULL);
 107
 108     /* put the anonymous credentials to the current session
 109      */
 110     gnutls_credentials_set (session, GNUTLS_CRD_ANON, anoncred);
 111
 112     gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) fd);
 113
 114     /* Perform the TLS handshake
 115      */
 116     do
 117       {
 118           ret = gnutls_handshake (session);
 119       }
 120     while (ret < 0 && gnutls_error_is_fatal (ret) == 0);
 121
 122     if (ret < 0)
 123       {
 124           fail ("client: Handshake failed\n");
 125           gnutls_perror (ret);
 126           exit (1);
 127       }
 128     else
 129       {
 130           if (debug)
 131               success ("client: Handshake was completed\n");
 132       }
 133
 134     if (debug)
 135         success ("client: DTLS version is: %s\n",
 136                  gnutls_protocol_get_name (gnutls_protocol_get_version
 137                                            (session)));
 138
 139     if (!server_init)
 140       {
 141           do
 142             {
 143                 ret =
 144                     gnutls_record_recv (session, buffer, sizeof (buffer));
 145
 146                 if (ret == GNUTLS_E_HEARTBEAT_PING_RECEIVED)
 147                   {
 148                       if (debug)
 149                           success ("Ping received. Replying with pong.\n");
 150                       ret2 = gnutls_heartbeat_pong (session, 0);
 151                       if (ret2 < 0)
 152                         {
 153                             fail ("pong: %s\n", gnutls_strerror (ret));
 154                             terminate ();
 155                         }
 156                   }
 157             }
 158           while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED
 159                  || ret == GNUTLS_E_HEARTBEAT_PING_RECEIVED);
 160       }
 161     else
 162       {
 163           do
 164             {
 165                 ret =
 166                     gnutls_heartbeat_ping (session, 256, 5,
 167                                            GNUTLS_HEARTBEAT_WAIT);
 168
 169                 if (debug)
 170                   success ("Ping sent.\n");
 171             }
 172           while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
 173
 174           if (ret < 0)
 175             {
 176                 fail ("ping: %s\n", gnutls_strerror (ret));
 177                 terminate ();
 178             }
 179       }
 180
 181     gnutls_bye (session, GNUTLS_SHUT_WR);
 182
 183     close (fd);
 184
 185     gnutls_deinit (session);
 186
 187     gnutls_anon_free_client_credentials (anoncred);
 188
 189     gnutls_global_deinit ();
 190 }
 191
 192
 193
 194 static gnutls_session_t
 195 initialize_tls_session (void)
 196 {
 197     gnutls_session_t session;
 198
 199     gnutls_init (&session, GNUTLS_SERVER | GNUTLS_DATAGRAM);
 200     gnutls_heartbeat_enable (session, GNUTLS_HB_PEER_ALLOWED_TO_SEND);
 201     gnutls_dtls_set_mtu (session, 1500);
 202
 203     /* avoid calling all the priority functions, since the defaults
 204      * are adequate.
 205      */
 206     gnutls_priority_set_direct (session,
 207                                 "NONE:+VERS-DTLS1.0:+CIPHER-ALL:+MAC-ALL:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+CURVE-ALL",
 208                                 NULL);
 209
 210     return session;
 211 }
 212
 213 static void
 214 terminate (void)
 215 {
 216     int status;
 217
 218     kill (child, SIGTERM);
 219     wait (&status);
 220     exit (1);
 221 }
 222
 223 static void
 224 server (int fd, int server_init)
 225 {
 226     int ret, ret2;
 227     char buffer[MAX_BUF + 1];
 228     gnutls_session_t session;
 229     gnutls_anon_server_credentials_t anoncred;
 230     /* this must be called once in the program
 231      */
 232     gnutls_global_init ();
 233
 234     if (debug)
 235       {
 236           gnutls_global_set_log_function (server_log_func);
 237           gnutls_global_set_log_level (4711);
 238       }
 239
 240     gnutls_anon_allocate_server_credentials (&anoncred);
 241
 242     session = initialize_tls_session ();
 243     gnutls_credentials_set (session, GNUTLS_CRD_ANON, anoncred);
 244
 245     gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) fd);
 246
 247     do
 248       {
 249           ret = gnutls_handshake (session);
 250       }
 251     while (ret < 0 && gnutls_error_is_fatal (ret) == 0);
 252     if (ret < 0)
 253       {
 254           close (fd);
 255           gnutls_deinit (session);
 256           fail ("server: Handshake has failed (%s)\n\n",
 257                 gnutls_strerror (ret));
 258           terminate ();
 259       }
 260     if (debug)
 261         success ("server: Handshake was completed\n");
 262
 263     if (debug)
 264         success ("server: TLS version is: %s\n",
 265                  gnutls_protocol_get_name (gnutls_protocol_get_version
 266                                            (session)));
 267
 268     /* see the Getting peer's information example */
 269     /* print_info(session); */
 270
 271     if (server_init)
 272       {
 273           do
 274             {
 275                 ret =
 276                     gnutls_record_recv (session, buffer, sizeof (buffer));
 277
 278                 if (ret == GNUTLS_E_HEARTBEAT_PING_RECEIVED)
 279                   {
 280                       if (debug)
 281                           success ("Ping received. Replying with pong.\n");
 282                       ret2 = gnutls_heartbeat_pong (session, 0);
 283                       if (ret2 < 0)
 284                         {
 285                             fail ("pong: %s\n", gnutls_strerror (ret));
 286                             terminate ();
 287                         }
 288                   }
 289             }
 290           while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED
 291                  || ret == GNUTLS_E_HEARTBEAT_PING_RECEIVED);
 292       }
 293     else
 294       {
 295           do
 296             {
 297                 ret =
 298                     gnutls_heartbeat_ping (session, 256, 5,
 299                                            GNUTLS_HEARTBEAT_WAIT);
 300
 301                 if (debug)
 302                   success ("Ping sent.\n");
 303             }
 304           while (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED);
 305
 306           if (ret < 0)
 307             {
 308                 fail ("ping: %s\n", gnutls_strerror (ret));
 309                 terminate ();
 310             }
 311       }
 312
 313     /* do not wait for the peer to close the connection.
 314      */
 315     gnutls_bye (session, GNUTLS_SHUT_WR);
 316
 317     close (fd);
 318     gnutls_deinit (session);
 319
 320     gnutls_anon_free_server_credentials (anoncred);
 321
 322     gnutls_global_deinit ();
 323
 324     if (debug)
 325         success ("server: finished\n");
 326 }
 327
 328 static void
 329 start (int server_initiated)
 330 {
 331     int fd[2];
 332     int ret;
 333
 334     ret = socketpair (AF_UNIX, SOCK_DGRAM, 0, fd);
 335     if (ret < 0)
 336       {
 337           perror ("socketpair");
 338           exit (1);
 339       }
 340
 341     child = fork ();
 342     if (child < 0)
 343       {
 344           perror ("fork");
 345           fail ("fork");
 346           exit (1);
 347       }
 348
 349     if (child)
 350       {
 351           int status;
 352           /* parent */
 353
 354           server (fd[0], server_initiated);
 355           wait (&status);
 356           if (WEXITSTATUS (status) != 0)
 357               fail ("Child died with status %d\n", WEXITSTATUS (status));
 358       }
 359     else
 360       {
 361           close (fd[0]);
 362           client (fd[1], server_initiated);
 363           exit (0);
 364       }
 365 }
 366
 367 void
 368 doit (void)
 369 {
 370     start (0);
 371     start (1);
 372 }
 373
 374 #endif /* _WIN32 */