src/htextauth.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 <stdio.h>
  21 #include <unistd.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <sys/poll.h>
  25 #include <sys/wait.h>
  26 #include <time.h>
  27 #include <signal.h>
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include <config.h>
  31 #endif
  32 #include <utils.h>
  33 #include <log.h>
  34 #include <req.h>
  35 #include <proc.h>
  36 #include <resp.h>
  37
  38 struct cache {
  39     struct cache *next, *prev;
  40     char *user, *pass;
  41     time_t lastuse;
  42 };
  43
  44 static int ch;
  45 static char **authcmd;
  46 static char *realm;
  47 static int docache = 1, reqssl;
  48 static struct cache *cache;
  49 static time_t now, lastclean;
  50
  51 static int auth(struct hthead *req, int fd, char *user, char *pass);
  52
  53 static void reqauth(struct hthead *req, int fd)
  54 {
  55     struct charbuf buf;
  56     FILE *out;
  57     char *rn;
  58
  59     rn = realm;
  60     if(rn == NULL)
  61         rn = "auth";
  62     bufinit(buf);
  63     bufcatstr(buf, "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>\r\n");
  64     bufcatstr(buf, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\r\n");
  65     bufcatstr(buf, "<html xmlns=\"http://www.w3.org/1999/xhtml\" lang=\"en-US\" xml:lang=\"en-US\">\r\n");
  66     bufcatstr(buf, "<head>\r\n");
  67     bprintf(&buf, "<title>Authentication Required</title>\r\n");
  68     bufcatstr(buf, "</head>\r\n");
  69     bufcatstr(buf, "<body>\r\n");
  70     bprintf(&buf, "<h1>Authentication Required</h1>\r\n");
  71     bprintf(&buf, "<p>You need to authenticate to access the requested resource.</p>\r\n");
  72     bufcatstr(buf, "</body>\r\n");
  73     bufcatstr(buf, "</html>\r\n");
  74     out = fdopen(dup(fd), "w");
  75     fprintf(out, "HTTP/1.1 401 Authentication Required\n");
  76     fprintf(out, "WWW-Authenticate: Basic realm=\"%s\"\n", rn);
  77     fprintf(out, "Content-Type: text/html\n");
  78     fprintf(out, "Content-Length: %zi\n", buf.d);
  79     fprintf(out, "\n");
  80     fwrite(buf.b, 1, buf.d, out);
  81     fclose(out);
  82     buffree(buf);
  83 }
  84
  85 static void authinval(struct hthead *req, int fd, char *msg)
  86 {
  87     struct charbuf buf;
  88     FILE *out;
  89     char *rn;
  90
  91     rn = realm;
  92     if(rn == NULL)
  93         rn = "auth";
  94     bufinit(buf);
  95     bufcatstr(buf, "<?xml version=\"1.0\" encoding=\"US-ASCII\"?>\r\n");
  96     bufcatstr(buf, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\r\n");
  97     bufcatstr(buf, "<html xmlns=\"http://www.w3.org/1999/xhtml\" lang=\"en-US\" xml:lang=\"en-US\">\r\n");
  98     bufcatstr(buf, "<head>\r\n");
  99     bprintf(&buf, "<title>Invalid authentication</title>\r\n");
 100     bufcatstr(buf, "</head>\r\n");
 101     bufcatstr(buf, "<body>\r\n");
 102     bprintf(&buf, "<h1>Invalid authentication</h1>\r\n");
 103     bprintf(&buf, "<p>%s</p>\r\n", htmlquote(msg));
 104     bufcatstr(buf, "</body>\r\n");
 105     bufcatstr(buf, "</html>\r\n");
 106     out = fdopen(dup(fd), "w");
 107     fprintf(out, "HTTP/1.1 401 Invalid authentication\n");
 108     fprintf(out, "WWW-Authenticate: Basic realm=\"%s\"\n", rn);
 109     fprintf(out, "Content-Type: text/html\n");
 110     fprintf(out, "Content-Length: %zi\n", buf.d);
 111     fprintf(out, "\n");
 112     fwrite(buf.b, 1, buf.d, out);
 113     fclose(out);
 114     buffree(buf);
 115 }
 116
 117 static void cleancache(int complete)
 118 {
 119     struct cache *c, *n;
 120
 121     for(c = cache; c != NULL; c = n) {
 122         n = c->next;
 123         if(complete || (now - c->lastuse > 3600)) {
 124             if(c->next)
 125                 c->next->prev = c->prev;
 126             if(c->prev)
 127                 c->prev->next = c->next;
 128             if(c == cache)
 129                 cache = c->next;
 130             memset(c->pass, 0, strlen(c->pass));
 131             free(c->user);
 132             free(c->pass);
 133             free(c);
 134         }
 135     }
 136     lastclean = now;
 137 }
 138
 139 static int ckcache(char *user, char *pass)
 140 {
 141     struct cache *c;
 142
 143     for(c = cache; c != NULL; c = c->next) {
 144         if(!strcmp(user, c->user) && !strcmp(pass, c->pass)) {
 145             c->lastuse = now;
 146             return(1);
 147         }
 148     }
 149     return(0);
 150 }
 151
 152 static struct cache *addcache(char *user, char *pass)
 153 {
 154     struct cache *c;
 155
 156     omalloc(c);
 157     c->user = sstrdup(user);
 158     c->pass = sstrdup(pass);
 159     c->lastuse = now;
 160     c->next = cache;
 161     if(cache != NULL)
 162         cache->prev = c;
 163     cache = c;
 164     return(c);
 165 }
 166
 167 static void serve2(struct hthead *req, int fd, char *user)
 168 {
 169     headappheader(req, "X-Ash-Remote-User", user);
 170     if(sendreq(ch, req, fd)) {
 171         flog(LOG_ERR, "htextauth: could not pass request to child: %s", strerror(errno));
 172         exit(1);
 173     }
 174 }
 175
 176 static void serve(struct hthead *req, int fd)
 177 {
 178     char *raw, *dec, *p;
 179     size_t declen;
 180
 181     now = time(NULL);
 182     dec = NULL;
 183     if(reqssl && (((raw = getheader(req, "X-Ash-Protocol")) == NULL) || strcmp(raw, "https"))) {
 184         simpleerror(fd, 403, "Forbidden", "The requested resource must be requested over HTTPS.");
 185         goto out;
 186     }
 187     if(((raw = getheader(req, "Authorization")) == NULL) || strncasecmp(raw, "basic ", 6)) {
 188         reqauth(req, fd);
 189         goto out;
 190     }
 191     if((dec = base64decode(raw + 6, &declen)) == NULL) {
 192         simpleerror(fd, 400, "Invalid request", "The authentication data is not proper base64.");
 193         goto out;
 194     }
 195     memset(raw, 0, strlen(raw));
 196     headrmheader(req, "Authorization");
 197     for(p = dec; *p; p++) {
 198         if(*p < 32) {
 199             simpleerror(fd, 400, "Invalid request", "The authentication data is invalid.");
 200             goto out;
 201         }
 202     }
 203     if((p = strchr(dec, ':')) == NULL) {
 204         simpleerror(fd, 400, "Invalid request", "The authentication data is invalid.");
 205         goto out;
 206     }
 207     *(p++) = 0;
 208     if(docache && ckcache(dec, p)) {
 209         serve2(req, fd, dec);
 210         goto out;
 211     }
 212     if(auth(req, fd, dec, p)) {
 213         if(docache)
 214             addcache(dec, p);
 215         serve2(req, fd, dec);
 216         goto out;
 217     }
 218
 219 out:
 220     if(dec != NULL) {
 221         memset(dec, 0, declen);
 222         free(dec);
 223     }
 224     if(docache && (now - lastclean > 60))
 225         cleancache(0);
 226 }
 227
 228 static int auth(struct hthead *req, int fd, char *user, char *pass)
 229 {
 230     int i, rv, status;
 231     ssize_t len;
 232     char *msg;
 233     struct charbuf ebuf;
 234     pid_t pid;
 235     int pfd[2], efd[2];
 236     FILE *out;
 237
 238     rv = 0;
 239     msg = "The supplied credentials are invalid.";
 240     pipe(pfd);
 241     pipe(efd);
 242     if((pid = fork()) < 0) {
 243         flog(LOG_ERR, "htextauth: could not fork: %s", strerror(errno));
 244         simpleerror(fd, 500, "Server Error", "An internal error occurred.");
 245         close(pfd[0]); close(pfd[1]);
 246         close(efd[0]); close(efd[1]);
 247         return(0);
 248     }
 249     if(pid == 0) {
 250         dup2(pfd[0], 0);
 251         dup2(efd[1], 1);
 252         for(i = 3; i < FD_SETSIZE; i++)
 253             close(i);
 254         execvp(authcmd[0], authcmd);
 255         flog(LOG_ERR, "htextauth: could not exec %s: %s", authcmd[0], strerror(errno));
 256         exit(127);
 257     }
 258     close(pfd[0]);
 259     close(efd[1]);
 260     out = fdopen(pfd[1], "w");
 261     fprintf(out, "%s\n", user);
 262     fprintf(out, "%s\n", pass);
 263     fclose(out);
 264     bufinit(ebuf);
 265     while(1) {
 266         sizebuf(ebuf, ebuf.d + 128);
 267         len = read(efd[0], ebuf.b + ebuf.d, ebuf.s - ebuf.d);
 268         if(len < 0) {
 269             if(errno == EINTR)
 270                 continue;
 271             break;
 272         } else if(len == 0) {
 273             break;
 274         }
 275         ebuf.d += len;
 276     }
 277     if(ebuf.d > 0) {
 278         bufadd(ebuf, 0);
 279         msg = ebuf.b;
 280     }
 281     close(efd[0]);
 282     if(waitpid(pid, &status, 0) < 0) {
 283         flog(LOG_ERR, "htextauth: could not wait: %s", strerror(errno));
 284         simpleerror(fd, 500, "Server Error", "An internal error occurred.");
 285         buffree(ebuf);
 286         return(0);
 287     }
 288     if(WIFEXITED(status) && (WEXITSTATUS(status) == 0))
 289         rv = 1;
 290     else
 291         authinval(req, fd, msg);
 292     buffree(ebuf);
 293     return(rv);
 294 }
 295
 296 static void usage(FILE *out)
 297 {
 298     fprintf(out, "usage: htextauth [-hCs] [-r REALM] AUTHCMD [ARGS...] -- CHILD [ARGS...]\n");
 299 }
 300
 301 static void sighandler(int sig)
 302 {
 303 }
 304
 305 int main(int argc, char **argv)
 306 {
 307     int i, c, ret;
 308     struct charvbuf cbuf;
 309     struct pollfd pfd[2];
 310     struct hthead *req;
 311     int fd;
 312
 313     while((c = getopt(argc, argv, "+hCsr:")) >= 0) {
 314         switch(c) {
 315         case 'h':
 316             usage(stdout);
 317             return(0);
 318         case 'C':
 319             docache = 0;
 320             break;
 321         case 's':
 322             reqssl = 1;
 323             break;
 324         case 'r':
 325             realm = optarg;
 326             break;
 327         default:
 328             usage(stderr);
 329             return(1);
 330         }
 331     }
 332     bufinit(cbuf);
 333     for(i = optind; i < argc; i++) {
 334         if(!strcmp(argv[i], "--"))
 335             break;
 336         bufadd(cbuf, argv[i]);
 337     }
 338     if((cbuf.d == 0) || (i == argc)) {
 339         usage(stderr);
 340         return(1);
 341     }
 342     bufadd(cbuf, NULL);
 343     authcmd = cbuf.b;
 344     i++;
 345     if(i == argc) {
 346         usage(stderr);
 347         return(1);
 348     }
 349     if((ch = stdmkchild(argv + i, NULL, NULL)) < 0) {
 350         flog(LOG_ERR, "htextauth: could not fork child: %s", strerror(errno));
 351         return(1);
 352     }
 353     signal(SIGCHLD, sighandler);
 354     signal(SIGPIPE, sighandler);
 355     while(1) {
 356         memset(pfd, 0, sizeof(pfd));
 357         pfd[0].fd = 0;
 358         pfd[0].events = POLLIN;
 359         pfd[1].fd = ch;
 360         pfd[1].events = POLLHUP;
 361         if((ret = poll(pfd, 2, -1)) < 0) {
 362             if(errno != EINTR) {
 363                 flog(LOG_ERR, "htextauth: error in poll: %s", strerror(errno));
 364                 exit(1);
 365             }
 366         }
 367         if(pfd[0].revents) {
 368             if((fd = recvreq(0, &req)) < 0) {
 369                 if(errno == 0)
 370                     break;
 371                 flog(LOG_ERR, "htextauth: error in recvreq: %s", strerror(errno));
 372                 exit(1);
 373             }
 374             serve(req, fd);
 375             freehthead(req);
 376             close(fd);
 377         }
 378         if(pfd[1].revents & POLLHUP)
 379             break;
 380     }
 381     cleancache(1);
 382     return(0);
 383 }