tests/anonself.c

   1 /*
   2  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
   3  * Foundation, Inc.
   4  *
   5  * Author: Simon Josefsson
   6  *
   7  * This file is part of GNUTLS.
   8  *
   9  * GNUTLS is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * GNUTLS is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with GNUTLS; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 /* Parts copied from GnuTLS example programs. */
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include <config.h>
  28 #endif
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <sys/types.h>
  34 #include <netinet/in.h>
  35 #include <sys/socket.h>
  36 #include <sys/wait.h>
  37 #include <arpa/inet.h>
  38 #include <unistd.h>
  39 #include <gnutls/gnutls.h>
  40
  41 #include "tcp.c"
  42
  43 #include "utils.h"
  44
  45 static void
  46 tls_log_func (int level, const char *str)
  47 {
  48   fprintf (stderr, "|<%d>| %s", level, str);
  49 }
  50
  51 /* A very basic TLS client, with anonymous authentication.
  52  */
  53
  54 #define MAX_BUF 1024
  55 #define MSG "Hello TLS"
  56
  57 static void
  58 client (void)
  59 {
  60   int ret, sd, ii;
  61   gnutls_session_t session;
  62   char buffer[MAX_BUF + 1];
  63   gnutls_anon_client_credentials_t anoncred;
  64   /* Need to enable anonymous KX specifically. */
  65   const int kx_prio[] = { GNUTLS_KX_ANON_DH, 0 };
  66
  67   gnutls_global_init ();
  68
  69   gnutls_global_set_log_function (tls_log_func);
  70   if (debug)
  71     gnutls_global_set_log_level (4711);
  72
  73   gnutls_anon_allocate_client_credentials (&anoncred);
  74
  75   /* Initialize TLS session
  76    */
  77   gnutls_init (&session, GNUTLS_CLIENT);
  78
  79   /* Use default priorities */
  80   gnutls_set_default_priority (session);
  81   gnutls_kx_set_priority (session, kx_prio);
  82
  83   /* put the anonymous credentials to the current session
  84    */
  85   gnutls_credentials_set (session, GNUTLS_CRD_ANON, anoncred);
  86
  87   /* connect to the peer
  88    */
  89   sd = tcp_connect ();
  90
  91   gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
  92
  93   /* Perform the TLS handshake
  94    */
  95   ret = gnutls_handshake (session);
  96
  97   if (ret < 0)
  98     {
  99       fail ("client: Handshake failed\n");
 100       gnutls_perror (ret);
 101       goto end;
 102     }
 103   else
 104     {
 105       success ("client: Handshake was completed\n");
 106     }
 107
 108   success ("client: TLS version is: %s\n",
 109            gnutls_protocol_get_name (gnutls_protocol_get_version (session)));
 110
 111   gnutls_record_send (session, MSG, strlen (MSG));
 112
 113   ret = gnutls_record_recv (session, buffer, MAX_BUF);
 114   if (ret == 0)
 115     {
 116       success ("client: Peer has closed the TLS connection\n");
 117       goto end;
 118     }
 119   else if (ret < 0)
 120     {
 121       fail ("client: Error: %s\n", gnutls_strerror (ret));
 122       goto end;
 123     }
 124
 125   printf ("- Received %d bytes: ", ret);
 126   for (ii = 0; ii < ret; ii++)
 127     {
 128       fputc (buffer[ii], stdout);
 129     }
 130   fputs ("\n", stdout);
 131
 132   gnutls_bye (session, GNUTLS_SHUT_RDWR);
 133
 134 end:
 135
 136   tcp_close (sd);
 137
 138   gnutls_deinit (session);
 139
 140   gnutls_anon_free_client_credentials (anoncred);
 141
 142   gnutls_global_deinit ();
 143 }
 144
 145 /* This is a sample TLS 1.0 echo server, for anonymous authentication only.
 146  */
 147
 148 #define SA struct sockaddr
 149 #define MAX_BUF 1024
 150 #define PORT 5556               /* listen to 5556 port */
 151 #define DH_BITS 1024
 152
 153 /* These are global */
 154 gnutls_anon_server_credentials_t anoncred;
 155
 156 static gnutls_session_t
 157 initialize_tls_session (void)
 158 {
 159   gnutls_session_t session;
 160   const int kx_prio[] = { GNUTLS_KX_ANON_DH, 0 };
 161
 162   gnutls_init (&session, GNUTLS_SERVER);
 163
 164   /* avoid calling all the priority functions, since the defaults
 165    * are adequate.
 166    */
 167   gnutls_set_default_priority (session);
 168   gnutls_kx_set_priority (session, kx_prio);
 169
 170   gnutls_credentials_set (session, GNUTLS_CRD_ANON, anoncred);
 171
 172   gnutls_dh_set_prime_bits (session, DH_BITS);
 173
 174   return session;
 175 }
 176
 177 static gnutls_dh_params_t dh_params;
 178
 179 static int
 180 generate_dh_params (void)
 181 {
 182   const gnutls_datum_t p3 = { (char *) pkcs3, strlen (pkcs3) };
 183   /* Generate Diffie-Hellman parameters - for use with DHE
 184    * kx algorithms. These should be discarded and regenerated
 185    * once a day, once a week or once a month. Depending on the
 186    * security requirements.
 187    */
 188   gnutls_dh_params_init (&dh_params);
 189   return gnutls_dh_params_import_pkcs3 (dh_params, &p3, GNUTLS_X509_FMT_PEM);
 190 }
 191
 192 int err, listen_sd, i;
 193 int sd, ret;
 194 struct sockaddr_in sa_serv;
 195 struct sockaddr_in sa_cli;
 196 int client_len;
 197 char topbuf[512];
 198 gnutls_session_t session;
 199 char buffer[MAX_BUF + 1];
 200 int optval = 1;
 201
 202 static void
 203 server_start (void)
 204 {
 205   /* Socket operations
 206    */
 207   listen_sd = socket (AF_INET, SOCK_STREAM, 0);
 208   if (err == -1)
 209     {
 210       perror ("socket");
 211       fail ("server: socket failed\n");
 212       return;
 213     }
 214
 215   memset (&sa_serv, '\0', sizeof (sa_serv));
 216   sa_serv.sin_family = AF_INET;
 217   sa_serv.sin_addr.s_addr = INADDR_ANY;
 218   sa_serv.sin_port = htons (PORT);      /* Server Port number */
 219
 220   setsockopt (listen_sd, SOL_SOCKET, SO_REUSEADDR, (void *) &optval,
 221               sizeof (int));
 222
 223   err = bind (listen_sd, (SA *) & sa_serv, sizeof (sa_serv));
 224   if (err == -1)
 225     {
 226       perror ("bind");
 227       fail ("server: bind failed\n");
 228       return;
 229     }
 230
 231   err = listen (listen_sd, 1024);
 232   if (err == -1)
 233     {
 234       perror ("listen");
 235       fail ("server: listen failed\n");
 236       return;
 237     }
 238
 239   success ("server: ready. Listening to port '%d'.\n", PORT);
 240 }
 241
 242 static void
 243 server (void)
 244 {
 245   /* this must be called once in the program
 246    */
 247   gnutls_global_init ();
 248
 249   gnutls_global_set_log_function (tls_log_func);
 250   if (debug)
 251     gnutls_global_set_log_level (4711);
 252
 253   gnutls_anon_allocate_server_credentials (&anoncred);
 254
 255   success ("Launched, generating DH parameters...\n");
 256
 257   generate_dh_params ();
 258
 259   gnutls_anon_set_server_dh_params (anoncred, dh_params);
 260
 261   client_len = sizeof (sa_cli);
 262
 263   session = initialize_tls_session ();
 264
 265   sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
 266
 267   success ("server: connection from %s, port %d\n",
 268            inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
 269                       sizeof (topbuf)), ntohs (sa_cli.sin_port));
 270
 271   gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
 272   ret = gnutls_handshake (session);
 273   if (ret < 0)
 274     {
 275       close (sd);
 276       gnutls_deinit (session);
 277       fail ("server: Handshake has failed (%s)\n\n", gnutls_strerror (ret));
 278       return;
 279     }
 280   success ("server: Handshake was completed\n");
 281
 282   success ("server: TLS version is: %s\n",
 283            gnutls_protocol_get_name (gnutls_protocol_get_version (session)));
 284
 285   /* see the Getting peer's information example */
 286   /* print_info(session); */
 287
 288   i = 0;
 289   for (;;)
 290     {
 291       memset (buffer, 0, MAX_BUF + 1);
 292       ret = gnutls_record_recv (session, buffer, MAX_BUF);
 293
 294       if (ret == 0)
 295         {
 296           success ("server: Peer has closed the GNUTLS connection\n");
 297           break;
 298         }
 299       else if (ret < 0)
 300         {
 301           fail ("server: Received corrupted data(%d). Closing...\n", ret);
 302           break;
 303         }
 304       else if (ret > 0)
 305         {
 306           /* echo data back to the client
 307            */
 308           gnutls_record_send (session, buffer, strlen (buffer));
 309         }
 310     }
 311   /* do not wait for the peer to close the connection.
 312    */
 313   gnutls_bye (session, GNUTLS_SHUT_WR);
 314
 315   close (sd);
 316   gnutls_deinit (session);
 317
 318   close (listen_sd);
 319
 320   gnutls_anon_free_server_credentials (anoncred);
 321
 322   gnutls_dh_params_deinit (dh_params);
 323
 324   gnutls_global_deinit ();
 325
 326   success ("server: finished\n");
 327 }
 328
 329 void
 330 doit (void)
 331 {
 332   pid_t child;
 333
 334   server_start ();
 335   if (error_count)
 336     return;
 337
 338   child = fork ();
 339   if (child < 0)
 340     {
 341       perror ("fork");
 342       fail ("fork");
 343       return;
 344     }
 345
 346   if (child)
 347     {
 348       int status;
 349       /* parent */
 350       server ();
 351       wait (&status);
 352     }
 353   else
 354     client ();
 355 }