tests/client.c

   1 /*
   2  * Simple GnuTLS client used for testing.
   3  *
   4  * Copyright (C) 2011-2013  Simon Ruderich
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <config.h>
  21
  22 #include <arpa/inet.h>
  23 #include <errno.h>
  24 #include <netdb.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <sys/socket.h>
  29 #include <sys/types.h>
  30 #include <unistd.h>
  31
  32 #include <gnutls/gnutls.h>
  33 #include <gnutls/x509.h>
  34
  35
  36 #define MAX_REQUEST_LINE 4096
  37
  38 static int fdopen_read_write(int socket, FILE **read_fd, FILE **write_fd);
  39 static int connect_to_host(const char *hostname, const char *port);
  40 static int read_http_request(FILE *client_fd, char *request, size_t length);
  41
  42
  43 int main (int argc, char *argv[]) {
  44     int result, response;
  45     unsigned int status;
  46     char buffer[MAX_REQUEST_LINE];
  47     int server;
  48     FILE *fd_read, *fd_write;
  49
  50     gnutls_session_t session;
  51     gnutls_certificate_credentials_t xcred;
  52
  53     gnutls_x509_crt_t cert;
  54     const gnutls_datum_t *cert_list;
  55     unsigned int cert_list_size;
  56
  57     if (argc != 5 && argc != 6) {
  58         fprintf(stderr,
  59                 "Usage: %s <ca-file> <hostname> <port> <hostname-verify> "
  60                           "[<digest-authentication>]\n",
  61                 argv[0]);
  62         return EXIT_FAILURE;
  63     }
  64
  65     gnutls_global_init();
  66     gnutls_certificate_allocate_credentials(&xcred);
  67
  68     gnutls_certificate_set_x509_trust_file(xcred,
  69                                            argv[1], GNUTLS_X509_FMT_PEM);
  70
  71     gnutls_init(&session, GNUTLS_CLIENT);
  72     gnutls_priority_set_direct(session, "NORMAL", NULL);
  73     gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, xcred);
  74
  75     server = connect_to_host("localhost", "4711");
  76     if (server == -1) {
  77         return EXIT_FAILURE;
  78     }
  79     if (fdopen_read_write(server, &fd_read, &fd_write) != 0) {
  80         return EXIT_FAILURE;
  81     }
  82
  83     /* Talk to tlsproxy. */
  84     fprintf(fd_write, "CONNECT %s:%s HTTP/1.0\r\n", argv[2], argv[3]);
  85     if (argc == 6) {
  86         fprintf(fd_write, "Proxy-Authorization: Basic %s\r\n", argv[5]);
  87     }
  88     fprintf(fd_write, "\r\n");
  89     fflush(fd_write);
  90     if (read_http_request(fd_read, buffer, sizeof(buffer)) == -1) {
  91         fprintf(stderr, "invalid proxy response\n");
  92         return EXIT_FAILURE;
  93     }
  94
  95     printf("response: %s\n", buffer);
  96
  97     if (sscanf(buffer, "HTTP/1.0 %d", &response) != 1) {
  98         fprintf(stderr, "invalid proxy response: %s\n", buffer);
  99         return EXIT_FAILURE;
 100     }
 101
 102     if (response != 200) {
 103         fprintf(stderr, "proxy failure\n");
 104         return EXIT_FAILURE;
 105     }
 106
 107     gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t)server);
 108
 109     result = gnutls_handshake(session);
 110     if (result != GNUTLS_E_SUCCESS) {
 111         fprintf(stderr, "gnutls_handshake() failed\n");
 112         gnutls_perror(result);
 113         return EXIT_FAILURE;
 114     }
 115
 116     /* Verify the proxy certificate. */
 117     result = gnutls_certificate_verify_peers2(session, &status);
 118     if (result < 0) {
 119         fprintf(stderr, "gnutls_certificate_verify_peers2() failed\n");
 120         gnutls_perror(result);
 121         return EXIT_FAILURE;
 122     }
 123
 124     if (status & GNUTLS_CERT_INVALID) {
 125         fprintf(stderr, "certificate invalid\n");
 126     }
 127
 128     /* Get proxy certificate. */
 129     if ((result = gnutls_x509_crt_init(&cert)) < 0) {
 130         fprintf(stderr, "gnutls_x509_crt_init() failed");
 131         gnutls_perror(result);
 132         return EXIT_FAILURE;
 133     }
 134
 135     cert_list = gnutls_certificate_get_peers(session, &cert_list_size);
 136     if (cert_list == NULL) {
 137         fprintf(stderr, "gnutls_certificate_get_peers() failed");
 138         return EXIT_FAILURE;
 139     }
 140
 141     if ((result = gnutls_x509_crt_import(cert, &cert_list[0],
 142                                          GNUTLS_X509_FMT_DER)) < 0) {
 143         fprintf(stderr, "gnutls_x509_crt_import() failed");
 144         gnutls_perror(result);
 145         return EXIT_FAILURE;
 146     }
 147
 148     /* Check hostname. */
 149     if (!gnutls_x509_crt_check_hostname(cert, argv[4])) {
 150         fprintf(stderr, "hostname didn't match '%s'\n", argv[4]);
 151         return EXIT_FAILURE;
 152     }
 153
 154     gnutls_x509_crt_deinit(cert);
 155
 156     gnutls_bye(session, GNUTLS_SHUT_RDWR);
 157     fclose(fd_read);
 158     fclose(fd_write);
 159
 160     gnutls_deinit(session);
 161     gnutls_certificate_free_credentials(xcred);
 162     gnutls_global_deinit();
 163
 164     return EXIT_SUCCESS;
 165 }
 166
 167
 168 /* Copied from src/connection.c (and removed LOG_* stuff)! Don't modify. */
 169
 170 static int fdopen_read_write(int socket, FILE **read_fd, FILE **write_fd) {
 171     *read_fd = fdopen(socket, "r");
 172     if (*read_fd == NULL) {
 173         perror("fdopen_read_write(): fdopen(\"r\") failed");
 174         return -1;
 175     }
 176
 177     *write_fd = fdopen(dup(socket), "w");
 178     if (*write_fd == NULL) {
 179         perror("fdopen_read_write(): fdopen(\"w\") failed");
 180         fclose(*read_fd);
 181         *read_fd = NULL; /* "tell" caller read_fd is already closed */
 182         return -1;
 183     }
 184
 185     return 0;
 186 }
 187
 188 static int connect_to_host(const char *hostname, const char *port) {
 189     struct addrinfo gai_hints;
 190     struct addrinfo *gai_result;
 191     int gai_return;
 192
 193     int server_socket;
 194     struct addrinfo *server;
 195
 196     if (hostname == NULL || port == NULL) {
 197         return -1;
 198     }
 199
 200     /* Get IP of hostname server. */
 201     memset(&gai_hints, 0, sizeof(gai_hints));
 202     gai_hints.ai_family   = AF_UNSPEC;
 203     gai_hints.ai_socktype = SOCK_STREAM;
 204     gai_hints.ai_protocol = 0;
 205     gai_hints.ai_flags    = AI_NUMERICSERV /* given port is numeric */
 206                           | AI_ADDRCONFIG  /* supported by this computer */
 207                           | AI_V4MAPPED;   /* support IPv4 through IPv6 */
 208     gai_return = getaddrinfo(hostname, port, &gai_hints, &gai_result);
 209     if (gai_return != 0) {
 210         if (gai_return == EAI_SYSTEM) {
 211             perror("connect_to_host(): getaddrinfo()");
 212         } else {
 213             fprintf(stderr, "connect_to_host(): getaddrinfo(): %s",
 214                             gai_strerror(gai_return));
 215         }
 216         return -1;
 217     }
 218
 219     /* Now try to connect to each server returned by getaddrinfo(), use the
 220      * first successful connect. */
 221     for (server = gai_result; server != NULL; server = server->ai_next) {
 222         server_socket = socket(server->ai_family,
 223                                server->ai_socktype,
 224                                server->ai_protocol);
 225         if (server_socket < 0) {
 226             perror("connect_to_host(): socket(), trying next");
 227             continue;
 228         }
 229
 230         if (connect(server_socket, server->ai_addr, server->ai_addrlen) == 0) {
 231             break;
 232         }
 233         perror("connect_to_host(): connect(), trying next");
 234
 235         close(server_socket);
 236     }
 237     /* Make sure we free the result from getaddrinfo(). */
 238     freeaddrinfo(gai_result);
 239
 240     if (server == NULL) {
 241         perror("connect_to_host(): no server found, abort");
 242         return -1;
 243     }
 244
 245     return server_socket;
 246 }
 247
 248 static int read_http_request(FILE *client_fd, char *request, size_t length) {
 249     char buffer[MAX_REQUEST_LINE];
 250
 251     if (fgets(request, (int)length, client_fd) == NULL) {
 252         if (ferror(client_fd)) {
 253             perror("read_http_request(): fgets()");
 254             return -1;
 255         }
 256         /* EOF */
 257         return -2;
 258     }
 259
 260     while (fgets(buffer, sizeof(buffer), client_fd) != NULL) {
 261         /* End of header. */
 262         if (!strcmp(buffer, "\n") || !strcmp(buffer, "\r\n")) {
 263             break;
 264         }
 265     }
 266     if (ferror(client_fd)) {
 267         perror("read_http_request(): fgets()");
 268         return -1;
 269     }
 270
 271     return 0;
 272 }