tests/mini-dtls-srtp.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 static void
  76 client (int fd, int profile)
  77 {
  78     gnutls_session_t session;
  79     int ret;
  80     gnutls_anon_client_credentials_t anoncred;
  81     /* Need to enable anonymous KX specifically. */
  82
  83     gnutls_global_init ();
  84
  85     if (debug)
  86       {
  87           gnutls_global_set_log_function (client_log_func);
  88           gnutls_global_set_log_level (4711);
  89       }
  90
  91     gnutls_anon_allocate_client_credentials (&anoncred);
  92
  93     /* Initialize TLS session
  94      */
  95     gnutls_init (&session, GNUTLS_CLIENT | GNUTLS_DATAGRAM);
  96     gnutls_heartbeat_enable (session, GNUTLS_HB_PEER_ALLOWED_TO_SEND);
  97     gnutls_dtls_set_mtu (session, 1500);
  98
  99     /* Use default priorities */
 100     gnutls_priority_set_direct (session,
 101                                 "NONE:+VERS-DTLS1.0:+CIPHER-ALL:+MAC-ALL:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+CURVE-ALL",
 102                                 NULL);
 103     if (profile)
 104       ret = gnutls_srtp_set_profile_direct(session, "SRTP_AES128_CM_SHA1_80",
 105                                            NULL);
 106     else
 107       ret = gnutls_srtp_set_profile_direct(session, "SRTP_NULL_SHA1_80",
 108                                            NULL);
 109     if (ret < 0)
 110       {
 111         gnutls_perror(ret);
 112         exit(1);
 113       }
 114
 115
 116     /* put the anonymous credentials to the current session
 117      */
 118     gnutls_credentials_set (session, GNUTLS_CRD_ANON, anoncred);
 119
 120     gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) fd);
 121
 122     /* Perform the TLS handshake
 123      */
 124     do
 125       {
 126           ret = gnutls_handshake (session);
 127       }
 128     while (ret < 0 && gnutls_error_is_fatal (ret) == 0);
 129
 130     if (ret < 0)
 131       {
 132           fail ("client: Handshake failed\n");
 133           gnutls_perror (ret);
 134           exit (1);
 135       }
 136     else
 137       {
 138           if (debug)
 139               success ("client: Handshake was completed\n");
 140       }
 141
 142     if (debug)
 143         success ("client: DTLS version is: %s\n",
 144                  gnutls_protocol_get_name (gnutls_protocol_get_version
 145                                            (session)));
 146
 147 /*
 148     ret = gnutls_prf(session, sizeof("EXTRACTOR-dtls_srtp")-1, "EXTRACTOR-dtls_srtp", 0, ctx_len, ctx, 32, out);
 149     if (ret < 0)
 150       {
 151         gnutls_perror(ret);
 152         exit(1);
 153       }
 154 */
 155     gnutls_bye (session, GNUTLS_SHUT_WR);
 156
 157     close (fd);
 158
 159     gnutls_deinit (session);
 160
 161     gnutls_anon_free_client_credentials (anoncred);
 162
 163     gnutls_global_deinit ();
 164 }
 165
 166 static void
 167 terminate (void)
 168 {
 169     int status;
 170
 171     kill (child, SIGTERM);
 172     wait (&status);
 173     exit (1);
 174 }
 175
 176 static void
 177 server (int fd, int profile)
 178 {
 179     int ret;
 180     gnutls_session_t session;
 181     gnutls_anon_server_credentials_t anoncred;
 182     /* this must be called once in the program
 183      */
 184     gnutls_global_init ();
 185
 186     if (debug)
 187       {
 188           gnutls_global_set_log_function (server_log_func);
 189           gnutls_global_set_log_level (4711);
 190       }
 191
 192     gnutls_anon_allocate_server_credentials (&anoncred);
 193
 194     gnutls_init (&session, GNUTLS_SERVER | GNUTLS_DATAGRAM);
 195     gnutls_heartbeat_enable (session, GNUTLS_HB_PEER_ALLOWED_TO_SEND);
 196     gnutls_dtls_set_mtu (session, 1500);
 197
 198     /* avoid calling all the priority functions, since the defaults
 199      * are adequate.
 200      */
 201     gnutls_priority_set_direct (session,
 202                                 "NONE:+VERS-DTLS1.0:+CIPHER-ALL:+MAC-ALL:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+CURVE-ALL",
 203                                 NULL);
 204
 205     if (profile)
 206       ret = gnutls_srtp_set_profile_direct(session, "SRTP_AES128_CM_SHA1_80",
 207                                            NULL);
 208     else
 209       ret = gnutls_srtp_set_profile_direct(session, "SRTP_NULL_SHA1_80",
 210                                            NULL);
 211     if (ret < 0)
 212       {
 213         gnutls_perror(ret);
 214         exit(1);
 215       }
 216
 217     gnutls_credentials_set (session, GNUTLS_CRD_ANON, anoncred);
 218
 219     gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) fd);
 220
 221     do
 222       {
 223           ret = gnutls_handshake (session);
 224       }
 225     while (ret < 0 && gnutls_error_is_fatal (ret) == 0);
 226     if (ret < 0)
 227       {
 228           close (fd);
 229           gnutls_deinit (session);
 230           fail ("server: Handshake has failed (%s)\n\n",
 231                 gnutls_strerror (ret));
 232           terminate ();
 233       }
 234     if (debug)
 235         success ("server: Handshake was completed\n");
 236
 237     if (debug)
 238         success ("server: TLS version is: %s\n",
 239                  gnutls_protocol_get_name (gnutls_protocol_get_version
 240                                            (session)));
 241
 242 /*
 243     ret = gnutls_prf(session, sizeof("EXTRACTOR-dtls_srtp")-1, "EXTRACTOR-dtls_srtp", 0, ctx_len, ctx, 32, out);
 244     if (ret < 0)
 245       {
 246         gnutls_perror(ret);
 247         exit(1);
 248       }
 249 */
 250
 251     /* do not wait for the peer to close the connection.
 252      */
 253     gnutls_bye (session, GNUTLS_SHUT_WR);
 254
 255     close (fd);
 256     gnutls_deinit (session);
 257
 258     gnutls_anon_free_server_credentials (anoncred);
 259
 260     gnutls_global_deinit ();
 261
 262     if (debug)
 263         success ("server: finished\n");
 264 }
 265
 266 static void
 267 start (int profile)
 268 {
 269     int fd[2];
 270     int ret;
 271
 272     ret = socketpair (AF_UNIX, SOCK_DGRAM, 0, fd);
 273     if (ret < 0)
 274       {
 275           perror ("socketpair");
 276           exit (1);
 277       }
 278
 279     child = fork ();
 280     if (child < 0)
 281       {
 282           perror ("fork");
 283           fail ("fork");
 284           exit (1);
 285       }
 286
 287     if (child)
 288       {
 289           int status;
 290           /* parent */
 291
 292           server (fd[0], profile);
 293           wait (&status);
 294           if (WEXITSTATUS (status) != 0)
 295               fail ("Child died with status %d\n", WEXITSTATUS (status));
 296       }
 297     else
 298       {
 299           close (fd[0]);
 300           client (fd[1], profile);
 301           exit (0);
 302       }
 303 }
 304
 305 void
 306 doit (void)
 307 {
 308     start (0);
 309     start (1);
 310 }
 311
 312 #endif /* _WIN32 */