corrected copyright notices
[gnutls.git] / tests / resume.c
blobb6b47d7c47b44f96fcdc29f47e91c249895706d0
1 /*
2 * Copyright (C) 2004-2012 Free Software Foundation, Inc.
4 * Author: Simon Josefsson
6 * This file is part of GnuTLS.
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.
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.
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
23 /* Parts copied from GnuTLS example programs. */
25 #ifdef HAVE_CONFIG_H
26 #include <config.h>
27 #endif
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <sys/types.h>
33 #include <sys/socket.h>
34 #if !defined(_WIN32)
35 #include <sys/wait.h>
36 #include <netinet/in.h>
37 #include <arpa/inet.h>
38 #endif
39 #include <unistd.h>
40 #include <gnutls/gnutls.h>
42 #include "tcp.c"
44 #include "utils.h"
46 static void wrap_db_init (void);
47 static void wrap_db_deinit (void);
48 static int wrap_db_store (void *dbf, gnutls_datum_t key, gnutls_datum_t data);
49 static gnutls_datum_t wrap_db_fetch (void *dbf, gnutls_datum_t key);
50 static int wrap_db_delete (void *dbf, gnutls_datum_t key);
52 #define TLS_SESSION_CACHE 50
54 struct params_res
56 const char *desc;
57 int enable_db;
58 int enable_session_ticket_server;
59 int enable_session_ticket_client;
60 int expect_resume;
63 pid_t child;
65 struct params_res resume_tests[] = {
66 {"try to resume from db", 50, 0, 0, 1},
67 {"try to resume from session ticket", 0, 1, 1, 1},
68 {"try to resume from session ticket (server only)", 0, 1, 0, 0},
69 {"try to resume from session ticket (client only)", 0, 0, 1, 0},
70 {NULL, -1}
73 /* A very basic TLS client, with anonymous authentication.
76 #define MAX_BUF 5*1024
77 #define MSG "Hello TLS"
79 static void
80 tls_log_func (int level, const char *str)
82 fprintf (stderr, "%s |<%d>| %s", child ? "server" : "client", level, str);
85 static void
86 client (struct params_res *params)
88 int ret, sd, ii;
89 gnutls_session_t session;
90 char buffer[MAX_BUF + 1];
91 gnutls_anon_client_credentials_t anoncred;
92 /* Need to enable anonymous KX specifically. */
94 /* variables used in session resuming
96 int t;
97 gnutls_datum_t session_data;
99 if (debug)
101 gnutls_global_set_log_function (tls_log_func);
102 gnutls_global_set_log_level (2);
104 gnutls_global_init ();
106 gnutls_anon_allocate_client_credentials (&anoncred);
108 for (t = 0; t < 2; t++)
109 { /* connect 2 times to the server */
110 /* connect to the peer
112 sd = tcp_connect ();
114 /* Initialize TLS session
116 gnutls_init (&session, GNUTLS_CLIENT|GNUTLS_NO_EXTENSIONS);
118 /* Use default priorities */
119 gnutls_priority_set_direct (session, "NONE:+VERS-TLS-ALL:+CIPHER-ALL:+MAC-ALL:+SIGN-ALL:+COMP-ALL:+ANON-DH", NULL);
121 /* put the anonymous credentials to the current session
123 gnutls_credentials_set (session, GNUTLS_CRD_ANON, anoncred);
125 if (params->enable_session_ticket_client)
126 gnutls_session_ticket_enable_client (session);
128 if (t > 0)
130 /* if this is not the first time we connect */
131 gnutls_session_set_data (session, session_data.data,
132 session_data.size);
133 gnutls_free (session_data.data);
136 gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
138 /* Perform the TLS handshake
140 ret = gnutls_handshake (session);
142 if (ret < 0)
144 fail ("client: Handshake failed\n");
145 gnutls_perror (ret);
146 goto end;
148 else
150 if (debug)
151 success ("client: Handshake was completed\n");
154 if (t == 0)
155 { /* the first time we connect */
156 /* get the session data size */
157 ret = gnutls_session_get_data2 (session, &session_data);
158 if (ret < 0)
159 fail ("Getting resume data failed\n");
161 else
162 { /* the second time we connect */
164 /* check if we actually resumed the previous session */
165 if (gnutls_session_is_resumed (session) != 0)
167 if (params->expect_resume)
169 if (debug)
170 success ("- Previous session was resumed\n");
172 else
173 fail ("- Previous session was resumed\n");
175 else
177 if (params->expect_resume)
179 fail ("*** Previous session was NOT resumed\n");
181 else
183 if (debug)
184 success
185 ("*** Previous session was NOT resumed (expected)\n");
190 gnutls_record_send (session, MSG, strlen (MSG));
192 ret = gnutls_record_recv (session, buffer, MAX_BUF);
193 if (ret == 0)
195 if (debug)
196 success ("client: Peer has closed the TLS connection\n");
197 goto end;
199 else if (ret < 0)
201 fail ("client: Error: %s\n", gnutls_strerror (ret));
202 goto end;
205 if (debug )
207 printf ("- Received %d bytes: ", ret);
208 for (ii = 0; ii < ret; ii++)
210 fputc (buffer[ii], stdout);
212 fputs ("\n", stdout);
215 gnutls_bye (session, GNUTLS_SHUT_RDWR);
218 tcp_close (sd);
220 gnutls_deinit (session);
223 end:
224 gnutls_anon_free_client_credentials (anoncred);
227 /* This is a sample TLS 1.0 echo server, for anonymous authentication only.
230 #define SA struct sockaddr
231 #define PORT 5556 /* listen to 5556 port */
232 #define DH_BITS 1024
234 /* These are global */
235 gnutls_anon_server_credentials_t anoncred;
236 static gnutls_datum_t session_ticket_key = { NULL, 0 };
238 static gnutls_session_t
239 initialize_tls_session (struct params_res *params)
241 gnutls_session_t session;
243 gnutls_init (&session, GNUTLS_SERVER);
245 /* avoid calling all the priority functions, since the defaults
246 * are adequate.
248 gnutls_priority_set_direct (session, "NONE:+VERS-TLS-ALL:+CIPHER-ALL:+MAC-ALL:+SIGN-ALL:+COMP-ALL:+ANON-DH", NULL);
250 gnutls_credentials_set (session, GNUTLS_CRD_ANON, anoncred);
252 gnutls_dh_set_prime_bits (session, DH_BITS);
254 if (params->enable_db)
256 gnutls_db_set_retrieve_function (session, wrap_db_fetch);
257 gnutls_db_set_remove_function (session, wrap_db_delete);
258 gnutls_db_set_store_function (session, wrap_db_store);
259 gnutls_db_set_ptr (session, NULL);
262 if (params->enable_session_ticket_server)
263 gnutls_session_ticket_enable_server (session, &session_ticket_key);
265 return session;
268 static gnutls_dh_params_t dh_params;
270 static int
271 generate_dh_params (void)
273 const gnutls_datum_t p3 = { (void *) pkcs3, strlen (pkcs3) };
274 /* Generate Diffie-Hellman parameters - for use with DHE
275 * kx algorithms. These should be discarded and regenerated
276 * once a day, once a week or once a month. Depending on the
277 * security requirements.
279 gnutls_dh_params_init (&dh_params);
280 return gnutls_dh_params_import_pkcs3 (dh_params, &p3, GNUTLS_X509_FMT_PEM);
283 int err, listen_sd, i;
284 int sd, ret;
285 struct sockaddr_in sa_serv;
286 struct sockaddr_in sa_cli;
287 socklen_t client_len;
288 char topbuf[512];
289 gnutls_session_t session;
290 char buffer[MAX_BUF + 1];
291 int optval = 1;
293 static void
294 global_start (void)
296 /* Socket operations
298 listen_sd = socket (AF_INET, SOCK_STREAM, 0);
299 if (err == -1)
301 perror ("socket");
302 fail ("server: socket failed\n");
303 return;
306 memset (&sa_serv, '\0', sizeof (sa_serv));
307 sa_serv.sin_family = AF_INET;
308 sa_serv.sin_addr.s_addr = INADDR_ANY;
309 sa_serv.sin_port = htons (PORT); /* Server Port number */
311 setsockopt (listen_sd, SOL_SOCKET, SO_REUSEADDR, (void *) &optval,
312 sizeof (int));
314 err = bind (listen_sd, (SA *) & sa_serv, sizeof (sa_serv));
315 if (err == -1)
317 perror ("bind");
318 fail ("server: bind failed\n");
319 return;
322 err = listen (listen_sd, 1024);
323 if (err == -1)
325 perror ("listen");
326 fail ("server: listen failed\n");
327 return;
330 if (debug)
331 success ("server: ready. Listening to port '%d'.\n", PORT);
334 static void
335 global_stop (void)
337 if (debug)
338 success ("global stop\n");
340 gnutls_anon_free_server_credentials (anoncred);
342 gnutls_dh_params_deinit (dh_params);
344 gnutls_global_deinit ();
346 shutdown (listen_sd, SHUT_RDWR);
349 static void
350 server (struct params_res *params)
352 size_t t;
354 /* this must be called once in the program, it is mostly for the server.
356 if (debug)
358 gnutls_global_set_log_function (tls_log_func);
359 gnutls_global_set_log_level (2);
362 gnutls_global_init ();
363 gnutls_anon_allocate_server_credentials (&anoncred);
365 if (debug)
366 success ("Launched, generating DH parameters...\n");
368 generate_dh_params ();
370 gnutls_anon_set_server_dh_params (anoncred, dh_params);
372 if (params->enable_db)
374 wrap_db_init ();
377 if (params->enable_session_ticket_server)
378 gnutls_session_ticket_key_generate (&session_ticket_key);
380 for (t = 0; t < 2; t++)
382 client_len = sizeof (sa_cli);
384 session = initialize_tls_session (params);
386 sd = accept (listen_sd, (SA *) & sa_cli, &client_len);
388 if (debug)
389 success ("server: connection from %s, port %d\n",
390 inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf,
391 sizeof (topbuf)), ntohs (sa_cli.sin_port));
393 gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd);
394 ret = gnutls_handshake (session);
395 if (ret < 0)
397 close (sd);
398 gnutls_deinit (session);
399 fail ("server: Handshake has failed (%s)\n\n",
400 gnutls_strerror (ret));
401 return;
403 if (debug)
404 success ("server: Handshake was completed\n");
406 /* see the Getting peer's information example */
407 /* print_info(session); */
409 i = 0;
410 for (;;)
412 memset (buffer, 0, MAX_BUF + 1);
413 ret = gnutls_record_recv (session, buffer, MAX_BUF);
415 if (ret == 0)
417 if (debug)
418 success ("server: Peer has closed the GnuTLS connection\n");
419 break;
421 else if (ret < 0)
423 fail ("server: Received corrupted data(%d). Closing...\n", ret);
424 break;
426 else if (ret > 0)
428 /* echo data back to the client
430 gnutls_record_send (session, buffer, strlen (buffer));
433 /* do not wait for the peer to close the connection.
435 gnutls_bye (session, GNUTLS_SHUT_WR);
437 close (sd);
439 gnutls_deinit (session);
442 close (listen_sd);
444 if (params->enable_db)
446 wrap_db_deinit ();
449 gnutls_free (session_ticket_key.data);
450 session_ticket_key.data = NULL;
452 if (debug)
453 success ("server: finished\n");
456 void
457 doit (void)
459 int i;
461 for (i = 0; resume_tests[i].desc; i++)
463 printf ("%s\n", resume_tests[i].desc);
465 global_start ();
466 if (error_count)
467 return;
469 child = fork ();
470 if (child < 0)
472 perror ("fork");
473 fail ("fork");
474 return;
477 if (child)
479 int status;
480 /* parent */
481 server (&resume_tests[i]);
482 wait (&status);
483 if (WEXITSTATUS(status) > 0)
484 error_count++;
485 global_stop ();
487 else
489 client (&resume_tests[i]);
490 gnutls_global_deinit ();
491 if (error_count)
492 exit(1);
493 exit (0);
498 /* Functions and other stuff needed for session resuming.
499 * This is done using a very simple list which holds session ids
500 * and session data.
503 #define MAX_SESSION_ID_SIZE 32
504 #define MAX_SESSION_DATA_SIZE 1024
506 typedef struct
508 unsigned char session_id[MAX_SESSION_ID_SIZE];
509 unsigned int session_id_size;
511 char session_data[MAX_SESSION_DATA_SIZE];
512 int session_data_size;
513 } CACHE;
515 static CACHE *cache_db;
516 static int cache_db_ptr = 0;
518 static void
519 wrap_db_init (void)
522 /* allocate cache_db */
523 cache_db = calloc (1, TLS_SESSION_CACHE * sizeof (CACHE));
526 static void
527 wrap_db_deinit (void)
529 free (cache_db);
530 cache_db = NULL;
531 return;
534 static int
535 wrap_db_store (void *dbf, gnutls_datum_t key, gnutls_datum_t data)
537 if (debug)
539 unsigned int i;
540 fprintf (stderr, "resume db storing (%d-%d): ", key.size, data.size);
541 for (i = 0; i < key.size; i++)
543 fprintf (stderr, "%02x", key.data[i] & 0xFF);
545 fprintf (stderr, "\n");
546 fprintf (stderr, "data: ");
547 for (i = 0; i < data.size; i++)
549 fprintf (stderr, "%02x", data.data[i] & 0xFF);
551 fprintf (stderr, "\n");
554 if (cache_db == NULL)
555 return -1;
557 if (key.size > MAX_SESSION_ID_SIZE)
559 fail("Key size is too large\n");
560 return -1;
563 if (data.size > MAX_SESSION_DATA_SIZE)
565 fail("Data size is too large\n");
566 return -1;
569 memcpy (cache_db[cache_db_ptr].session_id, key.data, key.size);
570 cache_db[cache_db_ptr].session_id_size = key.size;
572 memcpy (cache_db[cache_db_ptr].session_data, data.data, data.size);
573 cache_db[cache_db_ptr].session_data_size = data.size;
575 cache_db_ptr++;
576 cache_db_ptr %= TLS_SESSION_CACHE;
578 return 0;
581 static gnutls_datum_t
582 wrap_db_fetch (void *dbf, gnutls_datum_t key)
584 gnutls_datum_t res = { NULL, 0 };
585 int i;
587 if (debug)
589 unsigned int i;
591 fprintf (stderr, "resume db looking for (%d): ", key.size);
592 for (i = 0; i < key.size; i++)
594 fprintf (stderr, "%02x", key.data[i] & 0xFF);
596 fprintf (stderr, "\n");
599 if (cache_db == NULL)
600 return res;
602 for (i = 0; i < TLS_SESSION_CACHE; i++)
604 if (key.size == cache_db[i].session_id_size &&
605 memcmp (key.data, cache_db[i].session_id, key.size) == 0)
607 if (debug)
608 success ("resume db fetch... return info\n");
610 res.size = cache_db[i].session_data_size;
612 res.data = gnutls_malloc (res.size);
613 if (res.data == NULL)
614 return res;
616 memcpy (res.data, cache_db[i].session_data, res.size);
618 if (debug)
620 unsigned int i;
621 printf ("data:\n");
622 for (i = 0; i < res.size; i++)
624 printf ("%02x ", res.data[i] & 0xFF);
625 if ((i + 1) % 16 == 0)
626 printf ("\n");
628 printf ("\n");
631 return res;
635 if (debug)
636 success ("resume db fetch... NOT FOUND\n");
637 return res;
640 static int
641 wrap_db_delete (void *dbf, gnutls_datum_t key)
643 int i;
645 if (cache_db == NULL)
646 return -1;
648 for (i = 0; i < TLS_SESSION_CACHE; i++)
650 if (key.size == cache_db[i].session_id_size &&
651 memcmp (key.data, cache_db[i].session_id, key.size) == 0)
654 cache_db[i].session_id_size = 0;
655 cache_db[i].session_data_size = 0;
657 return 0;
661 return -1;