_ Git - BearSSL/blob - samples/client_basic.c

   1 /*
   2  * Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining
   5  * a copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sublicense, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <stdint.h>
  29 #include <errno.h>
  30 #include <signal.h>
  31
  32 #include <sys/types.h>
  33 #include <sys/socket.h>
  34 #include <netdb.h>
  35 #include <netinet/in.h>
  36 #include <arpa/inet.h>
  37 #include <unistd.h>
  38
  39 #include "bearssl.h"
  40
  41 /*
  42  * Connect to the specified host and port. The connected socket is
  43  * returned, or -1 on error.
  44  */
  45 static int
  46 host_connect(const char *host, const char *port)
  47 {
  48         struct addrinfo hints, *si, *p;
  49         int fd;
  50         int err;
  51
  52         memset(&hints, 0, sizeof hints);
  53         hints.ai_family = PF_UNSPEC;
  54         hints.ai_socktype = SOCK_STREAM;
  55         err = getaddrinfo(host, port, &hints, &si);
  56         if (err != 0) {
  57                 fprintf(stderr, "ERROR: getaddrinfo(): %s\n",
  58                         gai_strerror(err));
  59                 return -1;
  60         }
  61         fd = -1;
  62         for (p = si; p != NULL; p = p->ai_next) {
  63                 struct sockaddr *sa;
  64                 void *addr;
  65                 char tmp[INET6_ADDRSTRLEN + 50];
  66
  67                 sa = (struct sockaddr *)p->ai_addr;
  68                 if (sa->sa_family == AF_INET) {
  69                         addr = &((struct sockaddr_in *)sa)->sin_addr;
  70                 } else if (sa->sa_family == AF_INET6) {
  71                         addr = &((struct sockaddr_in6 *)sa)->sin6_addr;
  72                 } else {
  73                         addr = NULL;
  74                 }
  75                 if (addr != NULL) {
  76                         inet_ntop(p->ai_family, addr, tmp, sizeof tmp);
  77                 } else {
  78                         sprintf(tmp, "<unknown family: %d>",
  79                                 (int)sa->sa_family);
  80                 }
  81                 fprintf(stderr, "connecting to: %s\n", tmp);
  82                 fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
  83                 if (fd < 0) {
  84                         perror("socket()");
  85                         continue;
  86                 }
  87                 if (connect(fd, p->ai_addr, p->ai_addrlen) < 0) {
  88                         perror("connect()");
  89                         close(fd);
  90                         continue;
  91                 }
  92                 break;
  93         }
  94         if (p == NULL) {
  95                 freeaddrinfo(si);
  96                 fprintf(stderr, "ERROR: failed to connect\n");
  97                 return -1;
  98         }
  99         freeaddrinfo(si);
 100         fprintf(stderr, "connected.\n");
 101         return fd;
 102 }
 103
 104 /*
 105  * Low-level data read callback for the simplified SSL I/O API.
 106  */
 107 static int
 108 sock_read(void *ctx, unsigned char *buf, size_t len)
 109 {
 110         for (;;) {
 111                 ssize_t rlen;
 112
 113                 rlen = read(*(int *)ctx, buf, len);
 114                 if (rlen <= 0) {
 115                         if (rlen < 0 && errno == EINTR) {
 116                                 continue;
 117                         }
 118                         return -1;
 119                 }
 120                 return (int)rlen;
 121         }
 122 }
 123
 124 /*
 125  * Low-level data write callback for the simplified SSL I/O API.
 126  */
 127 static int
 128 sock_write(void *ctx, const unsigned char *buf, size_t len)
 129 {
 130         for (;;) {
 131                 ssize_t wlen;
 132
 133                 wlen = write(*(int *)ctx, buf, len);
 134                 if (wlen <= 0) {
 135                         if (wlen < 0 && errno == EINTR) {
 136                                 continue;
 137                         }
 138                         return -1;
 139                 }
 140                 return (int)wlen;
 141         }
 142 }
 143
 144 /*
 145  * The hardcoded trust anchors. These are the two DN + public key that
 146  * correspond to the self-signed certificates cert-root-rsa.pem and
 147  * cert-root-ec.pem.
 148  *
 149  * C code for hardcoded trust anchors can be generated with the "brssl"
 150  * command-line tool (with the "ta" command).
 151  */
 152
 153 static const unsigned char TA0_DN[] = {
 154         0x30, 0x1C, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
 155         0x02, 0x43, 0x41, 0x31, 0x0D, 0x30, 0x0B, 0x06, 0x03, 0x55, 0x04, 0x03,
 156         0x13, 0x04, 0x52, 0x6F, 0x6F, 0x74
 157 };
 158
 159 static const unsigned char TA0_RSA_N[] = {
 160         0xB6, 0xD9, 0x34, 0xD4, 0x50, 0xFD, 0xB3, 0xAF, 0x7A, 0x73, 0xF1, 0xCE,
 161         0x38, 0xBF, 0x5D, 0x6F, 0x45, 0xE1, 0xFD, 0x4E, 0xB1, 0x98, 0xC6, 0x60,
 162         0x83, 0x26, 0xD2, 0x17, 0xD1, 0xC5, 0xB7, 0x9A, 0xA3, 0xC1, 0xDE, 0x63,
 163         0x39, 0x97, 0x9C, 0xF0, 0x5E, 0x5C, 0xC8, 0x1C, 0x17, 0xB9, 0x88, 0x19,
 164         0x6D, 0xF0, 0xB6, 0x2E, 0x30, 0x50, 0xA1, 0x54, 0x6E, 0x93, 0xC0, 0xDB,
 165         0xCF, 0x30, 0xCB, 0x9F, 0x1E, 0x27, 0x79, 0xF1, 0xC3, 0x99, 0x52, 0x35,
 166         0xAA, 0x3D, 0xB6, 0xDF, 0xB0, 0xAD, 0x7C, 0xCB, 0x49, 0xCD, 0xC0, 0xED,
 167         0xE7, 0x66, 0x10, 0x2A, 0xE9, 0xCE, 0x28, 0x1F, 0x21, 0x50, 0xFA, 0x77,
 168         0x4C, 0x2D, 0xDA, 0xEF, 0x3C, 0x58, 0xEB, 0x4E, 0xBF, 0xCE, 0xE9, 0xFB,
 169         0x1A, 0xDA, 0xA3, 0x83, 0xA3, 0xCD, 0xA3, 0xCA, 0x93, 0x80, 0xDC, 0xDA,
 170         0xF3, 0x17, 0xCC, 0x7A, 0xAB, 0x33, 0x80, 0x9C, 0xB2, 0xD4, 0x7F, 0x46,
 171         0x3F, 0xC5, 0x3C, 0xDC, 0x61, 0x94, 0xB7, 0x27, 0x29, 0x6E, 0x2A, 0xBC,
 172         0x5B, 0x09, 0x36, 0xD4, 0xC6, 0x3B, 0x0D, 0xEB, 0xBE, 0xCE, 0xDB, 0x1D,
 173         0x1C, 0xBC, 0x10, 0x6A, 0x71, 0x71, 0xB3, 0xF2, 0xCA, 0x28, 0x9A, 0x77,
 174         0xF2, 0x8A, 0xEC, 0x42, 0xEF, 0xB1, 0x4A, 0x8E, 0xE2, 0xF2, 0x1A, 0x32,
 175         0x2A, 0xCD, 0xC0, 0xA6, 0x46, 0x2C, 0x9A, 0xC2, 0x85, 0x37, 0x91, 0x7F,
 176         0x46, 0xA1, 0x93, 0x81, 0xA1, 0x74, 0x66, 0xDF, 0xBA, 0xB3, 0x39, 0x20,
 177         0x91, 0x93, 0xFA, 0x1D, 0xA1, 0xA8, 0x85, 0xE7, 0xE4, 0xF9, 0x07, 0xF6,
 178         0x10, 0xF6, 0xA8, 0x27, 0x01, 0xB6, 0x7F, 0x12, 0xC3, 0x40, 0xC3, 0xC9,
 179         0xE2, 0xB0, 0xAB, 0x49, 0x18, 0x3A, 0x64, 0xB6, 0x59, 0xB7, 0x95, 0xB5,
 180         0x96, 0x36, 0xDF, 0x22, 0x69, 0xAA, 0x72, 0x6A, 0x54, 0x4E, 0x27, 0x29,
 181         0xA3, 0x0E, 0x97, 0x15
 182 };
 183
 184 static const unsigned char TA0_RSA_E[] = {
 185         0x01, 0x00, 0x01
 186 };
 187
 188 static const unsigned char TA1_DN[] = {
 189         0x30, 0x1C, 0x31, 0x0B, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
 190         0x02, 0x43, 0x41, 0x31, 0x0D, 0x30, 0x0B, 0x06, 0x03, 0x55, 0x04, 0x03,
 191         0x13, 0x04, 0x52, 0x6F, 0x6F, 0x74
 192 };
 193
 194 static const unsigned char TA1_EC_Q[] = {
 195         0x04, 0x71, 0x74, 0xBA, 0xAB, 0xB9, 0x30, 0x2E, 0x81, 0xD5, 0xE5, 0x57,
 196         0xF9, 0xF3, 0x20, 0x68, 0x0C, 0x9C, 0xF9, 0x64, 0xDB, 0xB4, 0x20, 0x0D,
 197         0x6D, 0xEA, 0x40, 0xD0, 0x4A, 0x6E, 0x42, 0xFD, 0xB6, 0x9A, 0x68, 0x25,
 198         0x44, 0xF6, 0xDF, 0x7B, 0xC4, 0xFC, 0xDE, 0xDD, 0x7B, 0xBB, 0xC5, 0xDB,
 199         0x7C, 0x76, 0x3F, 0x41, 0x66, 0x40, 0x6E, 0xDB, 0xA7, 0x87, 0xC2, 0xE5,
 200         0xD8, 0xC5, 0xF3, 0x7F, 0x8D
 201 };
 202
 203 static const br_x509_trust_anchor TAs[2] = {
 204         {
 205                 { (unsigned char *)TA0_DN, sizeof TA0_DN },
 206                 BR_X509_TA_CA,
 207                 {
 208                         BR_KEYTYPE_RSA,
 209                         { .rsa = {
 210                                 (unsigned char *)TA0_RSA_N, sizeof TA0_RSA_N,
 211                                 (unsigned char *)TA0_RSA_E, sizeof TA0_RSA_E,
 212                         } }
 213                 }
 214         },
 215         {
 216                 { (unsigned char *)TA1_DN, sizeof TA1_DN },
 217                 BR_X509_TA_CA,
 218                 {
 219                         BR_KEYTYPE_EC,
 220                         { .ec = {
 221                                 BR_EC_secp256r1,
 222                                 (unsigned char *)TA1_EC_Q, sizeof TA1_EC_Q,
 223                         } }
 224                 }
 225         }
 226 };
 227
 228 #define TAs_NUM   2
 229
 230 /*
 231  * Main program: this is a simple program that expects 2 or 3 arguments.
 232  * The first two arguments are a hostname and a port; the program will
 233  * open a SSL connection with that server and port. It will then send
 234  * a simple HTTP GET request, using the third argument as target path
 235  * ("/" is used as path if no third argument was provided). The HTTP
 236  * response, complete with header and contents, is received and written
 237  * on stdout.
 238  */
 239 int
 240 main(int argc, char *argv[])
 241 {
 242         const char *host, *port, *path;
 243         int fd;
 244         br_ssl_client_context sc;
 245         br_x509_minimal_context xc;
 246         unsigned char iobuf[BR_SSL_BUFSIZE_BIDI];
 247         br_sslio_context ioc;
 248
 249         /*
 250          * Parse command-line argument: host, port, and path. The path
 251          * is optional; if absent, "/" is used.
 252          */
 253         if (argc < 3 || argc > 4) {
 254                 return EXIT_FAILURE;
 255         }
 256         host = argv[1];
 257         port = argv[2];
 258         if (argc == 4) {
 259                 path = argv[3];
 260         } else {
 261                 path = "/";
 262         }
 263
 264         /*
 265          * Ignore SIGPIPE to avoid crashing in case of abrupt socket close.
 266          */
 267         signal(SIGPIPE, SIG_IGN);
 268
 269         /*
 270          * Open the socket to the target server.
 271          */
 272         fd = host_connect(host, port);
 273         if (fd < 0) {
 274                 return EXIT_FAILURE;
 275         }
 276
 277         /*
 278          * Initialise the client context:
 279          * -- Use the "full" profile (all supported algorithms).
 280          * -- The provided X.509 validation engine is initialised, with
 281          *    the hardcoded trust anchor.
 282          */
 283         br_ssl_client_init_full(&sc, &xc, TAs, TAs_NUM);
 284
 285         /*
 286          * Set the I/O buffer to the provided array. We allocated a
 287          * buffer large enough for full-duplex behaviour with all
 288          * allowed sizes of SSL records, hence we set the last argument
 289          * to 1 (which means "split the buffer into separate input and
 290          * output areas").
 291          */
 292         br_ssl_engine_set_buffer(&sc.eng, iobuf, sizeof iobuf, 1);
 293
 294         /*
 295          * Reset the client context, for a new handshake. We provide the
 296          * target host name: it will be used for the SNI extension. The
 297          * last parameter is 0: we are not trying to resume a session.
 298          */
 299         br_ssl_client_reset(&sc, host, 0);
 300
 301         /*
 302          * Initialise the simplified I/O wrapper context, to use our
 303          * SSL client context, and the two callbacks for socket I/O.
 304          */
 305         br_sslio_init(&ioc, &sc.eng, sock_read, &fd, sock_write, &fd);
 306
 307         /*
 308          * Note that while the context has, at that point, already
 309          * assembled the ClientHello to send, nothing happened on the
 310          * network yet. Real I/O will occur only with the next call.
 311          *
 312          * We write our simple HTTP request. We could test each call
 313          * for an error (-1), but this is not strictly necessary, since
 314          * the error state "sticks": if the context fails for any reason
 315          * (e.g. bad server certificate), then it will remain in failed
 316          * state and all subsequent calls will return -1 as well.
 317          */
 318         br_sslio_write_all(&ioc, "GET ", 4);
 319         br_sslio_write_all(&ioc, path, strlen(path));
 320         br_sslio_write_all(&ioc, " HTTP/1.0\r\nHost: ", 17);
 321         br_sslio_write_all(&ioc, host, strlen(host));
 322         br_sslio_write_all(&ioc, "\r\n\r\n", 4);
 323
 324         /*
 325          * SSL is a buffered protocol: we make sure that all our request
 326          * bytes are sent onto the wire.
 327          */
 328         br_sslio_flush(&ioc);
 329
 330         /*
 331          * Read the server's response. We use here a small 512-byte buffer,
 332          * but most of the buffering occurs in the client context: the
 333          * server will send full records (up to 16384 bytes worth of data
 334          * each), and the client context buffers one full record at a time.
 335          */
 336         for (;;) {
 337                 int rlen;
 338                 unsigned char tmp[512];
 339
 340                 rlen = br_sslio_read(&ioc, tmp, sizeof tmp);
 341                 if (rlen < 0) {
 342                         break;
 343                 }
 344                 fwrite(tmp, 1, rlen, stdout);
 345         }
 346
 347         /*
 348          * Close the socket.
 349          */
 350         close(fd);
 351
 352         /*
 353          * Check whether we closed properly or not. If the engine is
 354          * closed, then its error status allows to distinguish between
 355          * a normal closure and a SSL error.
 356          *
 357          * If the engine is NOT closed, then this means that the
 358          * underlying network socket was closed or failed in some way.
 359          * Note that many Web servers out there do not properly close
 360          * their SSL connections (they don't send a close_notify alert),
 361          * which will be reported here as "socket closed without proper
 362          * SSL termination".
 363          */
 364         if (br_ssl_engine_current_state(&sc.eng) == BR_SSL_CLOSED) {
 365                 int err;
 366
 367                 err = br_ssl_engine_last_error(&sc.eng);
 368                 if (err == 0) {
 369                         fprintf(stderr, "closed.\n");
 370                         return EXIT_SUCCESS;
 371                 } else {
 372                         fprintf(stderr, "SSL error %d\n", err);
 373                         return EXIT_FAILURE;
 374                 }
 375         } else {
 376                 fprintf(stderr,
 377                         "socket closed without proper SSL termination\n");
 378                 return EXIT_FAILURE;
 379         }
 380 }