daemon/auth-krb5.c

   1 /*
   2  *  Dolda Connect - Modular multiuser Direct Connect-style client
   3  *  Copyright (C) 2004 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 2 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, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 */
  19
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <pwd.h>
  25 #include <time.h>
  26 #include <sys/stat.h>
  27 #include <sys/param.h>
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include <config.h>
  31 #endif
  32 #include "auth.h"
  33 #include "utils.h"
  34 #include "conf.h"
  35 #include "log.h"
  36 #include "module.h"
  37 #include "sysevents.h"
  38
  39 #ifdef HAVE_KRB5
  40
  41 #include <krb5.h>
  42 #include <com_err.h>
  43
  44 struct krb5data
  45 {
  46     int state;
  47     krb5_auth_context context;
  48     krb5_ticket *ticket;
  49     krb5_creds *creds;
  50     krb5_ccache ccache;
  51     int renew;
  52     struct timer *renewtimer;
  53     char *username, *cname;
  54 };
  55
  56 static void setrenew(struct krb5data *data);
  57
  58 static krb5_context k5context;
  59 static krb5_principal myprinc;
  60 static krb5_keytab keytab;
  61
  62 static void releasekrb5(struct krb5data *data)
  63 {
  64     if(data->renewtimer != NULL)
  65         canceltimer(data->renewtimer);
  66     if(data->context != NULL)
  67         krb5_auth_con_free(k5context, data->context);
  68     if(data->ticket != NULL)
  69         krb5_free_ticket(k5context, data->ticket);
  70     if(data->creds != NULL)
  71         krb5_free_creds(k5context, data->creds);
  72     if(data->username != NULL)
  73         free(data->username);
  74     if(data->cname != NULL)
  75         free(data->cname);
  76     free(data);
  77 }
  78
  79 static void release(struct authhandle *auth)
  80 {
  81     releasekrb5((struct krb5data *)auth->mechdata);
  82 }
  83
  84 static struct krb5data *newkrb5data(void)
  85 {
  86     struct krb5data *new;
  87
  88     new = smalloc(sizeof(*new));
  89     memset(new, 0, sizeof(*new));
  90     return(new);
  91 }
  92
  93 static int inithandle(struct authhandle *auth, char *username)
  94 {
  95     int ret;
  96     struct krb5data *data;
  97
  98     data = newkrb5data();
  99     if((ret = krb5_auth_con_init(k5context, &data->context)) != 0)
 100     {
 101         flog(LOG_ERR, "could initialize Kerberos auth context: %s", error_message(ret));
 102         releasekrb5(data);
 103         return(1);
 104     }
 105     krb5_auth_con_setflags(k5context, data->context, KRB5_AUTH_CONTEXT_DO_SEQUENCE);
 106     data->username = sstrdup(username);
 107     data->state = 0;
 108     auth->mechdata = data;
 109     return(0);
 110 }
 111
 112 /* Copied from MIT Kerberos 5 1.3.3*/
 113 static krb5_boolean my_krb5_kuserok(krb5_context context, krb5_principal principal, const char *luser, const char *loginfile, int authbydef)
 114 {
 115     struct stat sbuf;
 116     struct passwd *pwd;
 117     char pbuf[MAXPATHLEN];
 118     krb5_boolean isok = FALSE;
 119     FILE *fp;
 120     char kuser[65];
 121     char *princname;
 122     char linebuf[BUFSIZ];
 123     char *newline;
 124     int gobble;
 125
 126     /* no account => no access */
 127     if ((pwd = getpwnam(luser)) == NULL) {
 128         return(FALSE);
 129     }
 130     (void) strncpy(pbuf, pwd->pw_dir, sizeof(pbuf) - 1);
 131     pbuf[sizeof(pbuf) - 1] = '\0';
 132     (void) strncat(pbuf, loginfile, sizeof(pbuf) - 1 - strlen(pbuf));
 133
 134     if (access(pbuf, F_OK)) {    /* not accessible */
 135         /*
 136          * if he's trying to log in as himself, and there is no .k5login file,
 137          * let him.  To find out, call
 138          * krb5_aname_to_localname to convert the principal to a name
 139          * which we can string compare.
 140          */
 141         if (authbydef) {
 142             if (!(krb5_aname_to_localname(context, principal,
 143                                           sizeof(kuser), kuser))
 144                 && (strcmp(kuser, luser) == 0)) {
 145                 return(TRUE);
 146             }
 147         } else {
 148             return(FALSE);
 149         }
 150     }
 151     if (krb5_unparse_name(context, principal, &princname))
 152         return(FALSE);                  /* no hope of matching */
 153
 154     /* open ~/.k5login */
 155     if ((fp = fopen(pbuf, "r")) == NULL) {
 156         free(princname);
 157         return(FALSE);
 158     }
 159     /*
 160      * For security reasons, the .k5login file must be owned either by
 161      * the user himself, or by root.  Otherwise, don't grant access.
 162      */
 163     if (fstat(fileno(fp), &sbuf)) {
 164         fclose(fp);
 165         free(princname);
 166         return(FALSE);
 167     }
 168     if ((sbuf.st_uid != pwd->pw_uid) && sbuf.st_uid) {
 169         fclose(fp);
 170         free(princname);
 171         return(FALSE);
 172     }
 173
 174     /* check each line */
 175     while (!isok && (fgets(linebuf, BUFSIZ, fp) != NULL)) {
 176         /* null-terminate the input string */
 177         linebuf[BUFSIZ-1] = '\0';
 178         newline = NULL;
 179         /* nuke the newline if it exists */
 180         if ((newline = strchr(linebuf, '\n')))
 181             *newline = '\0';
 182         if (!strcmp(linebuf, princname)) {
 183             isok = TRUE;
 184             continue;
 185         }
 186         /* clean up the rest of the line if necessary */
 187         if (!newline)
 188             while (((gobble = getc(fp)) != EOF) && gobble != '\n');
 189     }
 190     free(princname);
 191     fclose(fp);
 192     return(isok);
 193 }
 194
 195 static void renewcreds(int cancelled, struct krb5data *data)
 196 {
 197     int ret;
 198     char ccnambuf[50];
 199     krb5_ccache tmpcc;
 200     krb5_creds newcreds;
 201     static int ccserial = 0;
 202
 203     data->renewtimer = NULL;
 204     if(cancelled)
 205         return;
 206     memset(&newcreds, 0, sizeof(newcreds));
 207     snprintf(ccnambuf, sizeof(ccnambuf), "MEMORY:%i", ccserial++);
 208     if((ret = krb5_cc_resolve(k5context, ccnambuf, &tmpcc)) != 0)
 209     {
 210         flog(LOG_ERR, "could not resolve a temporary ccache `%s': %s", ccnambuf, error_message(ret));
 211         data->renew = 0;
 212         return;
 213     }
 214     if((ret = krb5_cc_initialize(k5context, tmpcc, data->ticket->enc_part2->client)) != 0)
 215     {
 216         flog(LOG_ERR, "could not initialize temporary ccache: %s", error_message(ret));
 217         krb5_cc_destroy(k5context, tmpcc);
 218         data->renew = 0;
 219         return;
 220     }
 221     if((ret = krb5_cc_store_cred(k5context, tmpcc, data->creds)) != 0)
 222     {
 223         flog(LOG_ERR, "could not store creds into temporary ccache: %s", error_message(ret));
 224         krb5_cc_destroy(k5context, tmpcc);
 225         data->renew = 0;
 226         return;
 227     }
 228     if((ret = krb5_get_renewed_creds(k5context, &newcreds, data->ticket->enc_part2->client, tmpcc, NULL)) != 0)
 229     {
 230         flog(LOG_ERR, "could not get renewed tickets for %s: %s", data->username, error_message(ret));
 231         krb5_cc_destroy(k5context, tmpcc);
 232         data->renew = 0;
 233         return;
 234     }
 235     krb5_free_creds(k5context, data->creds);
 236     data->creds = NULL;
 237     if((ret = krb5_copy_creds(k5context, &newcreds, &data->creds)) != 0)
 238     {
 239         flog(LOG_ERR, "could not copy renewed creds: %s", error_message(ret));
 240         krb5_cc_destroy(k5context, tmpcc);
 241         data->renew = 0;
 242         return;
 243     }
 244     krb5_free_cred_contents(k5context, &newcreds);
 245     krb5_cc_destroy(k5context, tmpcc);
 246     flog(LOG_ERR, "successfully renewed krb5 creds for %s", data->username);
 247     setrenew(data);
 248 }
 249
 250 static void setrenew(struct krb5data *data)
 251 {
 252     krb5_ticket_times times;
 253     time_t now, good;
 254
 255     times = data->creds->times;
 256     if(!times.starttime)
 257         times.starttime = times.authtime;
 258     now = time(NULL);
 259     if(times.endtime < now)
 260     {
 261         flog(LOG_DEBUG, "tickets already expired, cannot renew");
 262         data->renew = 0;
 263         return;
 264     }
 265     good = times.starttime + (((times.endtime - times.starttime) * 9) / 10);
 266     data->renewtimer = timercallback(good, (void (*)(int, void *))renewcreds, data);
 267 }
 268
 269 static int krbauth(struct authhandle *auth, char *passdata)
 270 {
 271     int ret;
 272     struct krb5data *data;
 273     char *msg;
 274     size_t msglen;
 275     int authorized;
 276     krb5_data k5d;
 277     krb5_flags apopt;
 278     krb5_creds **fwdcreds;
 279
 280     data = auth->mechdata;
 281     if(passdata == NULL)
 282     {
 283         auth->prompt = AUTH_PR_AUTO;
 284         if(auth->text != NULL)
 285             free(auth->text);
 286         auth->text = swcsdup(L"Send hex-encoded krb5 data");
 287         data->state = 1;
 288         return(AUTH_PASS);
 289     } else {
 290         if((msg = hexdecode(passdata, &msglen)) == NULL)
 291         {
 292             if(auth->text != NULL)
 293                 free(auth->text);
 294             auth->text = swcsdup(L"Invalid hex encoding");
 295             return(AUTH_DENIED);
 296         }
 297         switch(data->state)
 298         {
 299         case 1:
 300             k5d.length = msglen;
 301             k5d.data = msg;
 302             if((ret = krb5_rd_req(k5context, &data->context, &k5d, myprinc, keytab, &apopt, &data->ticket)) != 0)
 303             {
 304                 flog(LOG_INFO, "kerberos authentication failed for %s: %s", data->username, error_message(ret));
 305                 if(auth->text != NULL)
 306                     free(auth->text);
 307                 auth->text = icmbstowcs((char *)error_message(ret), NULL);
 308                 return(AUTH_DENIED);
 309             }
 310             free(msg);
 311             if(apopt & AP_OPTS_MUTUAL_REQUIRED)
 312             {
 313                 if((ret = krb5_mk_rep(k5context, data->context, &k5d)) != 0)
 314                 {
 315                     flog(LOG_WARNING, "krb5_mk_rep returned an error: %s", error_message(ret));
 316                     return(AUTH_ERR);
 317                 }
 318                 msg = hexencode(k5d.data, k5d.length);
 319                 if(auth->text != NULL)
 320                     free(auth->text);
 321                 auth->text = icmbstowcs(msg, "us-ascii");
 322                 free(msg);
 323                 free(k5d.data);
 324             } else {
 325                 if(auth->text != NULL)
 326                     free(auth->text);
 327                 auth->text = swcsdup(L"");
 328             }
 329             data->state = 2;
 330             return(AUTH_PASS);
 331         case 2:
 332             ret = atoi(msg);
 333             free(msg);
 334             if(ret == 1)
 335             {
 336                 /* That is, the client has accepted us as a valid
 337                  * server.  Now check if the client is authorized. */
 338                 if((ret = krb5_unparse_name(k5context, data->ticket->enc_part2->client, &data->cname)) != 0)
 339                 {
 340                     flog(LOG_ERR, "krb_unparse_name returned an error: %s", error_message(ret));
 341                     return(AUTH_ERR);
 342                 }
 343                 authorized = 0;
 344                 if(!authorized && my_krb5_kuserok(k5context, data->ticket->enc_part2->client, data->username, "/.k5login", 1))
 345                     authorized = 1;
 346                 /* Allow a seperate ACL for DC principals */
 347                 if(!authorized && my_krb5_kuserok(k5context, data->ticket->enc_part2->client, data->username, "/.dc-k5login", 0))
 348                     authorized = 1;
 349                 if(authorized)
 350                 {
 351                     flog(LOG_INFO, "krb5 principal %s successfully authorized as %s", data->cname, data->username);
 352                     return(AUTH_SUCCESS);
 353                 } else {
 354                     flog(LOG_INFO, "krb5 principal %s not authorized as %s", data->cname, data->username);
 355                 }
 356             }
 357             if(ret == 2)
 358             {
 359                 if(auth->text != NULL)
 360                     free(auth->text);
 361                 auth->text = swcsdup(L"");
 362                 data->state = 3;
 363                 return(AUTH_PASS);
 364             }
 365             return(AUTH_DENIED);
 366         case 3:
 367             k5d.length = msglen;
 368             k5d.data = msg;
 369             if((ret = krb5_rd_cred(k5context, data->context, &k5d, &fwdcreds, NULL)) != 0)
 370             {
 371                 flog(LOG_ERR, "krb5_rd_cred returned an error: %s", error_message(ret));
 372                 return(AUTH_ERR);
 373             }
 374             if(*fwdcreds == NULL)
 375             {
 376                 flog(LOG_ERR, "forwarded credentials array was empty (from %s)", data->username);
 377                 krb5_free_tgt_creds(k5context, fwdcreds);
 378                 return(AUTH_ERR);
 379             }
 380             flog(LOG_INFO, "received forwarded credentials for %s", data->username);
 381             /* Copy only the first credential. (Change this if it becomes a problem) */
 382             ret = krb5_copy_creds(k5context, *fwdcreds, &data->creds);
 383             krb5_free_tgt_creds(k5context, fwdcreds);
 384             if(ret != 0)
 385             {
 386                 flog(LOG_ERR, "could not copy forwarded credentials: %s", error_message(ret));
 387                 return(AUTH_ERR);
 388             }
 389             if(confgetint("auth-krb5", "renewcreds"))
 390             {
 391                 data->renew = 1;
 392                 setrenew(data);
 393             }
 394             if(auth->text != NULL)
 395                 free(auth->text);
 396             auth->text = swcsdup(L"");
 397             data->state = 2;
 398             return(AUTH_PASS);
 399         default:
 400             free(msg);
 401             flog(LOG_ERR, "BUG? Invalid state encountered in krbauth: %i", data->state);
 402             return(AUTH_ERR);
 403         }
 404     }
 405 }
 406
 407 static int opensess(struct authhandle *auth)
 408 {
 409     int ret;
 410     struct krb5data *data;
 411     char *buf, *buf2;
 412     int fd;
 413     struct passwd *pwent;
 414
 415     data = auth->mechdata;
 416     if(data->creds != NULL)
 417     {
 418         if((pwent = getpwnam(data->username)) == NULL)
 419         {
 420             flog(LOG_ERR, "could not get passwd entry for forwarded tickets (user %s): %s", data->username, strerror(errno));
 421             return(AUTH_ERR);
 422         }
 423         buf = sprintf2("/tmp/krb5cc_dc_%i_XXXXXX", pwent->pw_uid);
 424         if((fd = mkstemp(buf)) < 0)
 425         {
 426             free(buf);
 427             flog(LOG_ERR, "could not create temporary file for ccache: %s", strerror(errno));
 428             return(AUTH_ERR);
 429         }
 430         close(fd);
 431         buf2 = sprintf2("FILE:%s", buf);
 432         if((ret = krb5_cc_resolve(k5context, buf2, &data->ccache)) != 0)
 433         {
 434             free(buf);
 435             free(buf2);
 436             flog(LOG_ERR, "could not resolve ccache name \"%s\": %s", buf2, error_message(ret));
 437             return(AUTH_ERR);
 438         }
 439         setenv("KRB5CCNAME", buf2, 1);
 440         free(buf2);
 441         if((ret = krb5_cc_initialize(k5context, data->ccache, data->ticket->enc_part2->client)) != 0)
 442         {
 443             free(buf);
 444             flog(LOG_ERR, "could not initialize ccache: %s", error_message(ret));
 445             return(AUTH_ERR);
 446         }
 447         if((ret = krb5_cc_store_cred(k5context, data->ccache, data->creds)) != 0)
 448         {
 449             free(buf);
 450             flog(LOG_ERR, "could not store forwarded TGT into ccache: %s", error_message(ret));
 451             return(AUTH_ERR);
 452         }
 453         if(chown(buf, pwent->pw_uid, pwent->pw_gid))
 454         {
 455             free(buf);
 456             flog(LOG_ERR, "could not chown new ccache to %i:%i: %s", pwent->pw_uid, pwent->pw_gid, strerror(errno));
 457             return(AUTH_ERR);
 458         }
 459         free(buf);
 460     }
 461     return(AUTH_SUCCESS);
 462 }
 463
 464 static int closesess(struct authhandle *auth)
 465 {
 466     struct krb5data *data;
 467
 468     data = auth->mechdata;
 469     if(data->ccache != NULL)
 470     {
 471         krb5_cc_destroy(k5context, data->ccache);
 472         data->ccache = NULL;
 473     }
 474     return(AUTH_SUCCESS);
 475 }
 476
 477 struct authmech authmech_krb5 =
 478 {
 479     .inithandle = inithandle,
 480     .release = release,
 481     .authenticate = krbauth,
 482     .opensess = opensess,
 483     .closesess = closesess,
 484     .name = L"krb5",
 485     .enabled = 1
 486 };
 487
 488 static int init(int hup)
 489 {
 490     int ret;
 491     char *buf;
 492     krb5_principal newprinc;
 493
 494     if(!hup)
 495     {
 496         regmech(&authmech_krb5);
 497         if((ret = krb5_init_context(&k5context)))
 498         {
 499             flog(LOG_CRIT, "could not initialize Kerberos context: %s", error_message(ret));
 500             return(1);
 501         }
 502         if((buf = icwcstombs(confgetstr("auth-krb5", "service"), NULL)) == NULL)
 503         {
 504             flog(LOG_CRIT, "could not convert service name (%ls) into local charset: %s", confgetstr("auth-krb5", "service"), strerror(errno));
 505             return(1);
 506         } else {
 507             if((ret = krb5_sname_to_principal(k5context, NULL, buf, KRB5_NT_SRV_HST, &myprinc)) != 0)
 508             {
 509                 flog(LOG_CRIT, "could not get principal for service %s: %s", buf, error_message(ret));
 510                 free(buf);
 511                 return(1);
 512             }
 513             free(buf);
 514         }
 515         if((buf = icwcstombs(confgetstr("auth-krb5", "keytab"), NULL)) == NULL)
 516         {
 517             flog(LOG_ERR, "could not convert keytab name (%ls) into local charset: %s, using default keytab instead", confgetstr("auth-krb5", "keytab"), strerror(errno));
 518             keytab = NULL;
 519         } else {
 520             if((ret = krb5_kt_resolve(k5context, buf, &keytab)) != 0)
 521             {
 522                 flog(LOG_ERR, "could not open keytab %s: %s, using default keytab instead", buf, error_message(ret));
 523                 keytab = NULL;
 524             }
 525             free(buf);
 526         }
 527     }
 528     if(hup)
 529     {
 530         if((buf = icwcstombs(confgetstr("auth-krb5", "service"), NULL)) == NULL)
 531         {
 532             flog(LOG_CRIT, "could not convert service name (%ls) into local charset: %s, not updating principal", confgetstr("auth-krb5", "service"), strerror(errno));
 533         } else {
 534             if((ret = krb5_sname_to_principal(k5context, NULL, buf, KRB5_NT_SRV_HST, &newprinc)) != 0)
 535             {
 536                 flog(LOG_CRIT, "could not get principal for service %s: %s, not updating principal", buf, error_message(ret));
 537             } else {
 538                 krb5_free_principal(k5context, myprinc);
 539                 myprinc = newprinc;
 540             }
 541             free(buf);
 542         }
 543         if(keytab != NULL)
 544             krb5_kt_close(k5context, keytab);
 545         if((buf = icwcstombs(confgetstr("auth-krb5", "keytab"), NULL)) == NULL)
 546         {
 547             flog(LOG_ERR, "could not convert keytab name (%ls) into local charset: %s, using default keytab instead", confgetstr("auth-krb5", "keytab"), strerror(errno));
 548             keytab = NULL;
 549         } else {
 550             if((ret = krb5_kt_resolve(k5context, buf, &keytab)) != 0)
 551             {
 552                 flog(LOG_ERR, "could not open keytab %s: %s, using default keytab instead", buf, error_message(ret));
 553                 keytab = NULL;
 554             }
 555             free(buf);
 556         }
 557     }
 558     return(0);
 559 }
 560
 561 static void terminate(void)
 562 {
 563     if(keytab != NULL)
 564         krb5_kt_close(k5context, keytab);
 565     krb5_free_principal(k5context, myprinc);
 566     krb5_free_context(k5context);
 567 }
 568
 569 static struct configvar myvars[] =
 570 {
 571     {CONF_VAR_STRING, "service", {.str = L"doldacond"}},
 572     {CONF_VAR_STRING, "keytab", {.str = L""}},
 573     {CONF_VAR_BOOL, "renewcreds", {.num = 1}},
 574     {CONF_VAR_END}
 575 };
 576
 577 static struct module me =
 578 {
 579     .conf =
 580     {
 581         .vars = myvars
 582     },
 583     .init = init,
 584     .terminate = terminate,
 585     .name = "auth-krb5"
 586 };
 587
 588 MODULE(me);
 589
 590 #endif /* HAVE_KRB5 */