tests/mini-handshake-timeout.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 #include <string.h>
  30
  31 #if defined(_WIN32)
  32
  33 int main()
  34 {
  35   exit(77);
  36 }
  37
  38 #else
  39
  40 #include <sys/types.h>
  41 #include <netinet/in.h>
  42 #include <sys/socket.h>
  43 #include <sys/wait.h>
  44 #include <arpa/inet.h>
  45 #include <unistd.h>
  46 #include <gnutls/gnutls.h>
  47 #include <gnutls/dtls.h>
  48 #include <signal.h>
  49
  50 #include "utils.h"
  51
  52 /* This program tests whether the handshake timeout value is enforced.
  53  */
  54
  55 static void
  56 server_log_func (int level, const char *str)
  57 {
  58   fprintf (stderr, "server|<%d>| %s", level, str);
  59 }
  60
  61 static void
  62 client_log_func (int level, const char *str)
  63 {
  64   fprintf (stderr, "client|<%d>| %s", level, str);
  65 }
  66
  67 /* A very basic TLS client, with anonymous authentication.
  68  */
  69
  70 static int counter;
  71 static int packet_to_lose;
  72 gnutls_session_t session;
  73
  74 static void
  75 client (int fd, int wait)
  76 {
  77   int ret;
  78   gnutls_anon_client_credentials_t anoncred;
  79   /* Need to enable anonymous KX specifically. */
  80
  81   gnutls_global_init ();
  82
  83   if (debug)
  84     {
  85       gnutls_global_set_log_function (client_log_func);
  86       gnutls_global_set_log_level (4711);
  87     }
  88
  89   gnutls_anon_allocate_client_credentials (&anoncred);
  90
  91   /* Initialize TLS session
  92    */
  93   gnutls_init (&session, GNUTLS_CLIENT);
  94   gnutls_handshake_set_timeout( session, 10*1000);
  95
  96   /* Use default priorities */
  97   gnutls_priority_set_direct (session, "NORMAL:+ANON-ECDH", NULL);
  98
  99   /* put the anonymous credentials to the current session
 100    */
 101   gnutls_credentials_set (session, GNUTLS_CRD_ANON, anoncred);
 102
 103   counter = 0;
 104
 105   gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) fd);
 106
 107   /* Perform the TLS handshake
 108    */
 109   do
 110     {
 111       ret = gnutls_handshake (session);
 112     }
 113   while (ret < 0 && gnutls_error_is_fatal(ret) == 0);
 114
 115   gnutls_deinit(session);
 116   gnutls_anon_free_client_credentials(anoncred);
 117   gnutls_global_deinit();
 118
 119   if (ret < 0)
 120     {
 121       if (ret != GNUTLS_E_TIMEDOUT || wait == 0)
 122         {
 123           if (debug) fail("client: unexpected error: %s\n", gnutls_strerror(ret));
 124           exit(1);
 125         }
 126       if (debug) success("client: expected timeout occured\n");
 127       exit(0);
 128     }
 129   else
 130     {
 131       if (wait != 0)
 132         {
 133           fail ("client: handshake was completed unexpectedly\n");
 134           gnutls_perror (ret);
 135           exit(1);
 136         }
 137     }
 138
 139   exit(0);
 140 }
 141
 142
 143 /* These are global */
 144 gnutls_anon_server_credentials_t anoncred;
 145 pid_t child;
 146
 147 static gnutls_session_t
 148 initialize_tls_session (void)
 149 {
 150   gnutls_session_t session;
 151
 152   gnutls_init (&session, GNUTLS_SERVER);
 153
 154   /* avoid calling all the priority functions, since the defaults
 155    * are adequate.
 156    */
 157   gnutls_priority_set_direct (session, "NORMAL:+ANON-ECDH", NULL);
 158
 159   gnutls_credentials_set (session, GNUTLS_CRD_ANON, anoncred);
 160
 161   return session;
 162 }
 163
 164 static void
 165 server (int fd, int wait)
 166 {
 167 int ret;
 168   /* this must be called once in the program
 169    */
 170   gnutls_global_init ();
 171
 172   if (debug)
 173     {
 174       gnutls_global_set_log_function (server_log_func);
 175       gnutls_global_set_log_level (4711);
 176     }
 177
 178   gnutls_anon_allocate_server_credentials (&anoncred);
 179
 180   session = initialize_tls_session ();
 181
 182   counter = 0;
 183
 184   gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) fd);
 185
 186   if (wait) sleep(15);
 187   else do
 188     {
 189       ret = gnutls_handshake (session);
 190     }
 191   while (ret < 0 && gnutls_error_is_fatal(ret) == 0);
 192
 193   gnutls_deinit (session);
 194   gnutls_anon_free_server_credentials(anoncred);
 195   gnutls_global_deinit();
 196
 197   if (ret < 0)
 198     {
 199       return;
 200     }
 201 }
 202
 203 static void start (int wait)
 204 {
 205   int fd[2];
 206   int ret;
 207
 208   if (debug && wait)
 209     fprintf(stderr, "\nWill test timeout\n");
 210
 211   ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
 212   if (ret < 0)
 213     {
 214       perror("socketpair");
 215       exit(1);
 216     }
 217
 218   child = fork ();
 219   if (child < 0)
 220     {
 221       perror ("fork");
 222       fail ("fork");
 223       exit(1);
 224     }
 225
 226   if (child)
 227     {
 228       /* parent */
 229       close(fd[1]);
 230       server (fd[0], wait);
 231       close(fd[0]);
 232     }
 233   else
 234     {
 235       close(fd[0]);
 236       client (fd[1], wait);
 237       close(fd[1]);
 238       exit(0);
 239     }
 240 }
 241
 242 static void ch_handler(int sig)
 243 {
 244 int status;
 245   wait(&status);
 246   if (WEXITSTATUS(status) != 0)
 247     fail("Child died with status %d\n", WEXITSTATUS(status));
 248   return;
 249 }
 250
 251 void
 252 doit (void)
 253 {
 254   signal(SIGCHLD, ch_handler);
 255
 256   /* make sure that normal handshake occurs */
 257   start(0);
 258
 259   /* check the handshake with an expected timeout */
 260   start(1);
 261 }
 262
 263 #endif /* _WIN32 */