src/ssl-gnutls.c

   1 /*
   2     ashd - A Sane HTTP Daemon
   3     Copyright (C) 2008  Fredrik Tolf <fredrik@dolda2000.com>
   4
   5     This program is free software: you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation, either version 3 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include <stdlib.h>
  20 #include <unistd.h>
  21 #include <string.h>
  22 #include <fcntl.h>
  23 #include <sys/socket.h>
  24 #include <netinet/in.h>
  25 #include <arpa/inet.h>
  26 #include <errno.h>
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include <config.h>
  30 #endif
  31 #include <utils.h>
  32 #include <mt.h>
  33 #include <mtio.h>
  34 #include <req.h>
  35 #include <log.h>
  36
  37 #include "htparser.h"
  38
  39 #ifdef HAVE_GNUTLS
  40
  41 #include <gnutls/gnutls.h>
  42
  43 struct sslport {
  44     int fd;
  45     int sport;
  46     gnutls_certificate_credentials_t creds;
  47 };
  48
  49 struct sslconn {
  50     int fd;
  51     struct sslport *port;
  52     struct sockaddr_storage name;
  53     gnutls_session_t sess;
  54     struct charbuf in;
  55 };
  56
  57 static gnutls_dh_params_t dhparams;
  58
  59 static int tlsblock(int fd, gnutls_session_t sess, time_t to)
  60 {
  61     if(gnutls_record_get_direction(sess))
  62         return(block(fd, EV_WRITE, to));
  63     else
  64         return(block(fd, EV_READ, to));
  65 }
  66
  67 static ssize_t sslread(void *cookie, char *buf, size_t len)
  68 {
  69     struct sslconn *ssl = cookie;
  70     ssize_t xf;
  71     int ret;
  72
  73     while(ssl->in.d == 0) {
  74         sizebuf(ssl->in, ssl->in.d + 1024);
  75         ret = gnutls_record_recv(ssl->sess, ssl->in.b + ssl->in.d, ssl->in.s - ssl->in.d);
  76         if((ret == GNUTLS_E_INTERRUPTED) || (ret == GNUTLS_E_AGAIN)) {
  77             if(tlsblock(ssl->fd, ssl->sess, 60) == 0) {
  78                 errno = ETIMEDOUT;
  79                 return(-1);
  80             }
  81         } else if(ret < 0) {
  82             errno = EIO;
  83             return(-1);
  84         } else if(ret == 0) {
  85             return(0);
  86         } else {
  87             ssl->in.d += ret;
  88         }
  89     }
  90     xf = min(ssl->in.d, len);
  91     memcpy(buf, ssl->in.b, xf);
  92     memmove(ssl->in.b, ssl->in.b + xf, ssl->in.d -= xf);
  93     return(xf);
  94 }
  95
  96 static ssize_t sslwrite(void *cookie, const char *buf, size_t len)
  97 {
  98     struct sslconn *ssl = cookie;
  99     int ret;
 100     size_t off;
 101
 102     off = 0;
 103     while(off < len) {
 104         ret = gnutls_record_send(ssl->sess, buf + off, len - off);
 105         if((ret == GNUTLS_E_INTERRUPTED) || (ret == GNUTLS_E_AGAIN)) {
 106             if(tlsblock(ssl->fd, ssl->sess, 60) == 0) {
 107                 if(off == 0) {
 108                     errno = ETIMEDOUT;
 109                     return(-1);
 110                 }
 111                 return(off);
 112             }
 113         } else if(ret < 0) {
 114             if(off == 0) {
 115                 errno = EIO;
 116                 return(-1);
 117             }
 118             return(off);
 119         } else {
 120             off += ret;
 121         }
 122     }
 123     return(off);
 124 }
 125
 126 static int sslclose(void *cookie)
 127 {
 128     return(0);
 129 }
 130
 131 static cookie_io_functions_t iofuns = {
 132     .read = sslread,
 133     .write = sslwrite,
 134     .close = sslclose,
 135 };
 136
 137 static int initreq(struct conn *conn, struct hthead *req)
 138 {
 139     struct sslconn *ssl = conn->pdata;
 140     struct sockaddr_storage sa;
 141     socklen_t salen;
 142     char nmbuf[256];
 143
 144     headappheader(req, "X-Ash-Address", formathaddress((struct sockaddr *)&ssl->name, sizeof(sa)));
 145     if(ssl->name.ss_family == AF_INET) {
 146         headappheader(req, "X-Ash-Address", inet_ntop(AF_INET, &((struct sockaddr_in *)&ssl->name)->sin_addr, nmbuf, sizeof(nmbuf)));
 147         headappheader(req, "X-Ash-Port", sprintf3("%i", ntohs(((struct sockaddr_in *)&ssl->name)->sin_port)));
 148     } else if(ssl->name.ss_family == AF_INET6) {
 149         headappheader(req, "X-Ash-Address", inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&ssl->name)->sin6_addr, nmbuf, sizeof(nmbuf)));
 150         headappheader(req, "X-Ash-Port", sprintf3("%i", ntohs(((struct sockaddr_in6 *)&ssl->name)->sin6_port)));
 151     }
 152     salen = sizeof(sa);
 153     if(!getsockname(ssl->fd, (struct sockaddr *)&sa, &salen))
 154         headappheader(req, "X-Ash-Server-Address", formathaddress((struct sockaddr *)&sa, sizeof(sa)));
 155     headappheader(req, "X-Ash-Server-Port", sprintf3("%i", ssl->port->sport));
 156     headappheader(req, "X-Ash-Protocol", "https");
 157     return(0);
 158 }
 159
 160 static void servessl(struct muth *muth, va_list args)
 161 {
 162     vavar(int, fd);
 163     vavar(struct sockaddr_storage, name);
 164     vavar(struct sslport *, pd);
 165     struct conn conn;
 166     struct sslconn ssl;
 167     gnutls_session_t sess;
 168     int ret;
 169     FILE *in;
 170
 171     int setcreds(gnutls_session_t sess)
 172     {
 173         int i;
 174         unsigned int ntype;
 175         char nambuf[256];
 176         size_t namlen;
 177
 178         for(i = 0; 1; i++) {
 179             namlen = sizeof(nambuf);
 180             if(gnutls_server_name_get(sess, nambuf, &namlen, &ntype, i) != 0)
 181                 break;
 182             if(ntype != GNUTLS_NAME_DNS)
 183                 continue;
 184         }
 185         gnutls_credentials_set(sess, GNUTLS_CRD_CERTIFICATE, pd->creds);
 186         gnutls_certificate_server_set_request(sess, GNUTLS_CERT_REQUEST);
 187         return(0);
 188     }
 189
 190     fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
 191     gnutls_init(&sess, GNUTLS_SERVER);
 192     gnutls_set_default_priority(sess);
 193     gnutls_handshake_set_post_client_hello_function(sess, setcreds);
 194     gnutls_transport_set_ptr(sess, (gnutls_transport_ptr_t)(intptr_t)fd);
 195     while((ret = gnutls_handshake(sess)) != 0) {
 196         if((ret != GNUTLS_E_INTERRUPTED) && (ret != GNUTLS_E_AGAIN))
 197             goto out;
 198         if(tlsblock(fd, sess, 60) <= 0)
 199             goto out;
 200     }
 201     memset(&conn, 0, sizeof(conn));
 202     memset(&ssl, 0, sizeof(ssl));
 203     conn.pdata = &ssl;
 204     conn.initreq = initreq;
 205     ssl.fd = fd;
 206     ssl.port = pd;
 207     ssl.name = name;
 208     ssl.sess = sess;
 209     bufinit(ssl.in);
 210     in = fopencookie(&ssl, "r+", iofuns);
 211     serve(in, &conn);
 212
 213 out:
 214     gnutls_deinit(sess);
 215     close(fd);
 216 }
 217
 218 static void listenloop(struct muth *muth, va_list args)
 219 {
 220     vavar(struct sslport *, pd);
 221     int ns;
 222     struct sockaddr_storage name;
 223     socklen_t namelen;
 224
 225     while(1) {
 226         namelen = sizeof(name);
 227         block(pd->fd, EV_READ, 0);
 228         ns = accept(pd->fd, (struct sockaddr *)&name, &namelen);
 229         if(ns < 0) {
 230             flog(LOG_ERR, "accept: %s", strerror(errno));
 231             goto out;
 232         }
 233         mustart(servessl, ns, name, pd);
 234     }
 235
 236 out:
 237     close(pd->fd);
 238     free(pd);
 239 }
 240
 241 static void init(void)
 242 {
 243     static int inited = 0;
 244     int ret;
 245
 246     if(inited)
 247         return;
 248     inited = 1;
 249     if((ret = gnutls_global_init()) != 0) {
 250         flog(LOG_ERR, "could not initialize GnuTLS: %s", gnutls_strerror(ret));
 251         exit(1);
 252     }
 253     if(((ret = gnutls_dh_params_init(&dhparams)) != 0) ||
 254        ((ret = gnutls_dh_params_generate2(dhparams, 2048)) != 0)) {
 255         flog(LOG_ERR, "GnuTLS could not generate Diffie-Hellman parameters: %s", gnutls_strerror(ret));
 256         exit(1);
 257     }
 258 }
 259
 260 void handlegnussl(int argc, char **argp, char **argv)
 261 {
 262     int i, ret, port, fd;
 263     gnutls_certificate_credentials_t creds;
 264     struct sslport *pd;
 265     char *crtfile, *keyfile;
 266
 267     init();
 268     port = 443;
 269     gnutls_certificate_allocate_credentials(&creds);
 270     keyfile = crtfile = NULL;
 271     for(i = 0; i < argc; i++) {
 272         if(!strcmp(argp[i], "help")) {
 273             printf("ssl handler parameters:\n");
 274             printf("\tcert=CERT-FILE  [mandatory]\n");
 275             printf("\t\tThe name of the file to read the certificate from.\n");
 276             printf("\tkey=KEY-FILE    [same as CERT-FILE]\n");
 277             printf("\t\tThe name of the file to read the private key from.\n");
 278             printf("\ttrust=CA-FILE   [no default]\n");
 279             printf("\t\tThe name of a file to read trusted certificates from.\n");
 280             printf("\t\tMay be given multiple times.\n");
 281             printf("\tcrl=CRL-FILE    [no default]\n");
 282             printf("\t\tThe name of a file to read revocation lists from.\n");
 283             printf("\t\tMay be given multiple times.\n");
 284             printf("\tport=PORT       [443]\n");
 285             printf("\t\tThe TCP port to listen on.\n");
 286             printf("\n");
 287             printf("\tAll X.509 data files must be PEM-encoded.\n");
 288             exit(0);
 289         } else if(!strcmp(argp[i], "cert")) {
 290             crtfile = argv[i];
 291         } else if(!strcmp(argp[i], "key")) {
 292             keyfile = argv[i];
 293         } else if(!strcmp(argp[i], "trust")) {
 294             if((ret = gnutls_certificate_set_x509_trust_file(creds, argv[i], GNUTLS_X509_FMT_PEM)) != 0) {
 295                 flog(LOG_ERR, "ssl: could not load trust file `%s': %s", argv[i], gnutls_strerror(ret));
 296                 exit(1);
 297             }
 298         } else if(!strcmp(argp[i], "crl")) {
 299             if((ret = gnutls_certificate_set_x509_crl_file(creds, argv[i], GNUTLS_X509_FMT_PEM)) != 0) {
 300                 flog(LOG_ERR, "ssl: could not load CRL file `%s': %s", argv[i], gnutls_strerror(ret));
 301                 exit(1);
 302             }
 303         } else if(!strcmp(argp[i], "port")) {
 304             port = atoi(argv[i]);
 305         } else {
 306             flog(LOG_ERR, "unknown parameter `%s' to ssl handler", argp[i]);
 307             exit(1);
 308         }
 309     }
 310     if(crtfile == NULL) {
 311         flog(LOG_ERR, "ssl: needs certificate file at the very least");
 312         exit(1);
 313     }
 314     if(keyfile == NULL)
 315         keyfile = crtfile;
 316     if((ret = gnutls_certificate_set_x509_key_file(creds, crtfile, keyfile, GNUTLS_X509_FMT_PEM)) != 0) {
 317         flog(LOG_ERR, "ssl: could not load certificate or key: %s", gnutls_strerror(ret));
 318         exit(1);
 319     }
 320     gnutls_certificate_set_dh_params(creds, dhparams);
 321     if((fd = listensock6(port)) < 0) {
 322         flog(LOG_ERR, "could not listen on IPv6 port (port %i): %s", port, strerror(errno));
 323         exit(1);
 324     }
 325     omalloc(pd);
 326     pd->fd = fd;
 327     pd->sport = port;
 328     pd->creds = creds;
 329     mustart(listenloop, pd);
 330     if((fd = listensock6(port)) < 0) {
 331         if(errno != EADDRINUSE) {
 332             flog(LOG_ERR, "could not listen on IPv6 port (port %i): %s", port, strerror(errno));
 333             exit(1);
 334         }
 335     } else {
 336         omalloc(pd);
 337         pd->fd = fd;
 338         pd->sport = port;
 339         pd->creds = creds;
 340         mustart(listenloop, pd);
 341     }
 342 }
 343
 344 #endif