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 cleancache(int complete)
  86 {
  87     struct cache *c, *n;
  88
  89     for(c = cache; c != NULL; c = n) {
  90         n = c->next;
  91         if(complete || (now - c->lastuse > 3600)) {
  92             if(c->next)
  93                 c->next->prev = c->prev;
  94             if(c->prev)
  95                 c->prev->next = c->next;
  96             if(c == cache)
  97                 cache = c->next;
  98             memset(c->pass, 0, strlen(c->pass));
  99             free(c->user);
 100             free(c->pass);
 101             free(c);
 102         }
 103     }
 104     lastclean = now;
 105 }
 106
 107 static int ckcache(char *user, char *pass)
 108 {
 109     struct cache *c;
 110
 111     for(c = cache; c != NULL; c = c->next) {
 112         if(!strcmp(user, c->user) && !strcmp(pass, c->pass)) {
 113             c->lastuse = now;
 114             return(1);
 115         }
 116     }
 117     return(0);
 118 }
 119
 120 static struct cache *addcache(char *user, char *pass)
 121 {
 122     struct cache *c;
 123
 124     omalloc(c);
 125     c->user = sstrdup(user);
 126     c->pass = sstrdup(pass);
 127     c->lastuse = now;
 128     c->next = cache;
 129     if(cache != NULL)
 130         cache->prev = c;
 131     cache = c;
 132     return(c);
 133 }
 134
 135 static void serve2(struct hthead *req, int fd, char *user)
 136 {
 137     headappheader(req, "X-Ash-Remote-User", user);
 138     if(sendreq(ch, req, fd)) {
 139         flog(LOG_ERR, "htextauth: could not pass request to child: %s", strerror(errno));
 140         exit(1);
 141     }
 142 }
 143
 144 static void serve(struct hthead *req, int fd)
 145 {
 146     char *raw, *dec, *p;
 147     size_t declen;
 148
 149     now = time(NULL);
 150     dec = NULL;
 151     if(reqssl && (((raw = getheader(req, "X-Ash-Protocol")) == NULL) || strcmp(raw, "https"))) {
 152         simpleerror(fd, 403, "Forbidden", "The requested resource must be requested over HTTPS.");
 153         goto out;
 154     }
 155     if(((raw = getheader(req, "Authorization")) == NULL) || strncasecmp(raw, "basic ", 6)) {
 156         reqauth(req, fd);
 157         goto out;
 158     }
 159     if((dec = base64decode(raw + 6, &declen)) == NULL) {
 160         simpleerror(fd, 400, "Invalid request", "The authentication data is not proper base64.");
 161         goto out;
 162     }
 163     memset(raw, 0, strlen(raw));
 164     headrmheader(req, "Authorization");
 165     for(p = dec; *p; p++) {
 166         if(*p < 32) {
 167             simpleerror(fd, 400, "Invalid request", "The authentication data is invalid.");
 168             goto out;
 169         }
 170     }
 171     if((p = strchr(dec, ':')) == NULL) {
 172         simpleerror(fd, 400, "Invalid request", "The authentication data is invalid.");
 173         goto out;
 174     }
 175     *(p++) = 0;
 176     if(docache && ckcache(dec, p)) {
 177         serve2(req, fd, dec);
 178         goto out;
 179     }
 180     if(auth(req, fd, dec, p)) {
 181         if(docache)
 182             addcache(dec, p);
 183         serve2(req, fd, dec);
 184         goto out;
 185     }
 186
 187 out:
 188     if(dec != NULL) {
 189         memset(dec, 0, declen);
 190         free(dec);
 191     }
 192     if(docache && (now - lastclean > 60))
 193         cleancache(0);
 194 }
 195
 196 static int auth(struct hthead *req, int fd, char *user, char *pass)
 197 {
 198     int i, rv, status;
 199     ssize_t len;
 200     char *msg;
 201     struct charbuf ebuf;
 202     pid_t pid;
 203     int pfd[2], efd[2];
 204     FILE *out;
 205
 206     rv = 0;
 207     msg = "The supplied credentials are invalid.";
 208     pipe(pfd);
 209     pipe(efd);
 210     if((pid = fork()) < 0) {
 211         flog(LOG_ERR, "htextauth: could not fork: %s", strerror(errno));
 212         simpleerror(fd, 500, "Server Error", "An internal error occurred.");
 213         close(pfd[0]); close(pfd[1]);
 214         close(efd[0]); close(efd[1]);
 215         return(0);
 216     }
 217     if(pid == 0) {
 218         dup2(pfd[0], 0);
 219         dup2(efd[1], 1);
 220         for(i = 3; i < FD_SETSIZE; i++)
 221             close(i);
 222         execvp(authcmd[0], authcmd);
 223         flog(LOG_ERR, "htextauth: could not exec %s: %s", authcmd[0], strerror(errno));
 224         exit(127);
 225     }
 226     close(pfd[0]);
 227     close(efd[1]);
 228     out = fdopen(pfd[1], "w");
 229     fprintf(out, "%s\n", user);
 230     fprintf(out, "%s\n", pass);
 231     fclose(out);
 232     bufinit(ebuf);
 233     while(1) {
 234         sizebuf(ebuf, ebuf.d + 128);
 235         len = read(efd[0], ebuf.b + ebuf.d, ebuf.s - ebuf.d);
 236         if(len < 0) {
 237             if(errno == EINTR)
 238                 continue;
 239             break;
 240         } else if(len == 0) {
 241             break;
 242         }
 243         ebuf.d += len;
 244     }
 245     if(ebuf.d > 0) {
 246         bufadd(ebuf, 0);
 247         msg = ebuf.b;
 248     }
 249     close(efd[0]);
 250     if(waitpid(pid, &status, 0) < 0) {
 251         flog(LOG_ERR, "htextauth: could not wait: %s", strerror(errno));
 252         simpleerror(fd, 500, "Server Error", "An internal error occurred.");
 253         buffree(ebuf);
 254         return(0);
 255     }
 256     if(WIFEXITED(status) && (WEXITSTATUS(status) == 0))
 257         rv = 1;
 258     else
 259         simpleerror(fd, 401, "Invalid authentication", msg);
 260     buffree(ebuf);
 261     return(rv);
 262 }
 263
 264 static void usage(FILE *out)
 265 {
 266     fprintf(out, "usage: htextauth [-hCs] [-r REALM] AUTHCMD [ARGS...] -- CHILD [ARGS...]\n");
 267 }
 268
 269 static void sighandler(int sig)
 270 {
 271 }
 272
 273 int main(int argc, char **argv)
 274 {
 275     int i, c, ret;
 276     struct charvbuf cbuf;
 277     struct pollfd pfd[2];
 278     struct hthead *req;
 279     int fd;
 280
 281     while((c = getopt(argc, argv, "+hCsr:")) >= 0) {
 282         switch(c) {
 283         case 'h':
 284             usage(stdout);
 285             return(0);
 286         case 'C':
 287             docache = 0;
 288             break;
 289         case 's':
 290             reqssl = 1;
 291             break;
 292         case 'r':
 293             realm = optarg;
 294             break;
 295         default:
 296             usage(stderr);
 297             return(1);
 298         }
 299     }
 300     bufinit(cbuf);
 301     for(i = optind; i < argc; i++) {
 302         if(!strcmp(argv[i], "--"))
 303             break;
 304         bufadd(cbuf, argv[i]);
 305     }
 306     if((cbuf.d == 0) || (i == argc)) {
 307         usage(stderr);
 308         return(1);
 309     }
 310     bufadd(cbuf, NULL);
 311     authcmd = cbuf.b;
 312     i++;
 313     if(i == argc) {
 314         usage(stderr);
 315         return(1);
 316     }
 317     if((ch = stdmkchild(argv + i, NULL, NULL)) < 0) {
 318         flog(LOG_ERR, "htextauth: could not fork child: %s", strerror(errno));
 319         return(1);
 320     }
 321     signal(SIGCHLD, sighandler);
 322     signal(SIGPIPE, sighandler);
 323     while(1) {
 324         memset(pfd, 0, sizeof(pfd));
 325         pfd[0].fd = 0;
 326         pfd[0].events = POLLIN;
 327         pfd[1].fd = ch;
 328         pfd[1].events = POLLHUP;
 329         if((ret = poll(pfd, 2, -1)) < 0) {
 330             if(errno != EINTR) {
 331                 flog(LOG_ERR, "htextauth: error in poll: %s", strerror(errno));
 332                 exit(1);
 333             }
 334         }
 335         if(pfd[0].revents) {
 336             if((fd = recvreq(0, &req)) < 0) {
 337                 if(errno == 0)
 338                     break;
 339                 flog(LOG_ERR, "htextauth: error in recvreq: %s", strerror(errno));
 340                 exit(1);
 341             }
 342             serve(req, fd);
 343             freehthead(req);
 344             close(fd);
 345         }
 346         if(pfd[1].revents & POLLHUP)
 347             break;
 348     }
 349     cleancache(1);
 350     return(0);
 351 }