Guile 1.8 fixes.
[doldaconnect.git] / 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, struct socket *sk, 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                 free(msg);
309                 return(AUTH_DENIED);
310             }
311             free(msg);
312             if(apopt & AP_OPTS_MUTUAL_REQUIRED)
313             {
314                 if((ret = krb5_mk_rep(k5context, data->context, &k5d)) != 0)
315                 {
316                     flog(LOG_WARNING, "krb5_mk_rep returned an error: %s", error_message(ret));
317                     return(AUTH_ERR);
318                 }
319                 msg = hexencode(k5d.data, k5d.length);
320                 if(auth->text != NULL)
321                     free(auth->text);
322                 auth->text = icmbstowcs(msg, "us-ascii");
323                 free(msg);
324                 free(k5d.data);
325             } else {
326                 if(auth->text != NULL)
327                     free(auth->text);
328                 auth->text = swcsdup(L"");
329             }
330             data->state = 2;
331             return(AUTH_PASS);
332         case 2:
333             ret = atoi(msg);
334             free(msg);
335             if(ret == 1)
336             {
337                 /* That is, the client has accepted us as a valid
338                  * server.  Now check if the client is authorized. */
339                 if((ret = krb5_unparse_name(k5context, data->ticket->enc_part2->client, &data->cname)) != 0)
340                 {
341                     flog(LOG_ERR, "krb_unparse_name returned an error: %s", error_message(ret));
342                     return(AUTH_ERR);
343                 }
344                 authorized = 0;
345                 if(!authorized && my_krb5_kuserok(k5context, data->ticket->enc_part2->client, data->username, "/.k5login", 1))
346                     authorized = 1;
347                 /* Allow a seperate ACL for DC principals */
348                 if(!authorized && my_krb5_kuserok(k5context, data->ticket->enc_part2->client, data->username, "/.dc-k5login", 0))
349                     authorized = 1;
350                 if(authorized)
351                 {
352                     flog(LOG_INFO, "krb5 principal %s successfully authorized as %s%s", data->cname, data->username, (data->creds == NULL)?"":" (with fwd creds)");
353                     return(AUTH_SUCCESS);
354                 } else {
355                     flog(LOG_INFO, "krb5 principal %s not authorized as %s", data->cname, data->username);
356                 }
357             }
358             if(ret == 2)
359             {
360                 if(auth->text != NULL)
361                     free(auth->text);
362                 auth->text = swcsdup(L"");
363                 data->state = 3;
364                 return(AUTH_PASS);
365             }
366             return(AUTH_DENIED);
367         case 3:
368             k5d.length = msglen;
369             k5d.data = msg;
370             if((ret = krb5_rd_cred(k5context, data->context, &k5d, &fwdcreds, NULL)) != 0)
371             {
372                 flog(LOG_ERR, "krb5_rd_cred returned an error: %s", error_message(ret));
373                 free(msg);
374                 return(AUTH_ERR);
375             }
376             free(msg);
377             if(*fwdcreds == NULL)
378             {
379                 flog(LOG_ERR, "forwarded credentials array was empty (from %s)", data->username);
380                 krb5_free_tgt_creds(k5context, fwdcreds);
381                 return(AUTH_ERR);
382             }
383             /* Copy only the first credential. (Change this if it becomes a problem) */
384             ret = krb5_copy_creds(k5context, *fwdcreds, &data->creds);
385             krb5_free_tgt_creds(k5context, fwdcreds);
386             if(ret != 0)
387             {
388                 flog(LOG_ERR, "could not copy forwarded credentials: %s", error_message(ret));
389                 return(AUTH_ERR);
390             }
391             if(confgetint("auth-krb5", "renewcreds"))
392             {
393                 data->renew = 1;
394                 setrenew(data);
395             }
396             if(auth->text != NULL)
397                 free(auth->text);
398             auth->text = swcsdup(L"");
399             data->state = 2;
400             return(AUTH_PASS);
401         default:
402             free(msg);
403             flog(LOG_ERR, "BUG? Invalid state encountered in krbauth: %i", data->state);
404             return(AUTH_ERR);
405         }
406     }
407 }
408
409 static int opensess(struct authhandle *auth)
410 {
411     int ret;
412     struct krb5data *data;
413     char *buf, *buf2;
414     int fd;
415     struct passwd *pwent;
416     
417     data = auth->mechdata;
418     if(data->creds != NULL)
419     {
420         if((pwent = getpwnam(data->username)) == NULL)
421         {
422             flog(LOG_ERR, "could not get passwd entry for forwarded tickets (user %s): %s", data->username, strerror(errno));
423             return(AUTH_ERR);
424         }
425         if(!confgetint("auth-krb5", "usedefcc"))
426         {
427             buf = sprintf2("/tmp/krb5cc_dc_%i_XXXXXX", pwent->pw_uid);
428             if((fd = mkstemp(buf)) < 0)
429             {
430                 free(buf);
431                 flog(LOG_ERR, "could not create temporary file for ccache: %s", strerror(errno));
432                 return(AUTH_ERR);
433             }
434             close(fd);
435             buf2 = sprintf2("FILE:%s", buf);
436             if((ret = krb5_cc_resolve(k5context, buf2, &data->ccache)) != 0)
437             {
438                 free(buf);
439                 free(buf2);
440                 flog(LOG_ERR, "could not resolve ccache name \"%s\": %s", buf2, error_message(ret));
441                 return(AUTH_ERR);
442             }
443             setenv("KRB5CCNAME", buf2, 1);
444             free(buf2);
445             if((ret = krb5_cc_initialize(k5context, data->ccache, data->ticket->enc_part2->client)) != 0)
446             {
447                 free(buf);
448                 flog(LOG_ERR, "could not initialize ccache: %s", error_message(ret));
449                 return(AUTH_ERR);
450             }
451             if((ret = krb5_cc_store_cred(k5context, data->ccache, data->creds)) != 0)
452             {
453                 free(buf);
454                 flog(LOG_ERR, "could not store forwarded TGT into ccache: %s", error_message(ret));
455                 return(AUTH_ERR);
456             }
457             if(chown(buf, pwent->pw_uid, pwent->pw_gid))
458             {
459                 free(buf);
460                 flog(LOG_ERR, "could not chown new ccache to %i:%i: %s", pwent->pw_uid, pwent->pw_gid, strerror(errno));
461                 return(AUTH_ERR);
462             }
463             free(buf);
464         } else {
465             if((buf = (char *)krb5_cc_default_name(k5context)) == NULL) {
466                 flog(LOG_ERR, "could not get default ccache name");
467                 return(AUTH_ERR);
468             }
469             if((ret = krb5_cc_resolve(k5context, buf, &data->ccache)) != 0)
470             {
471                 flog(LOG_ERR, "could not resolve ccache name \"%s\": %s", buf2, error_message(ret));
472                 return(AUTH_ERR);
473             }
474             setenv("KRB5CCNAME", buf, 1);
475             if((ret = krb5_cc_initialize(k5context, data->ccache, data->ticket->enc_part2->client)) != 0)
476             {
477                 flog(LOG_ERR, "could not initialize ccache: %s", error_message(ret));
478                 return(AUTH_ERR);
479             }
480             if((ret = krb5_cc_store_cred(k5context, data->ccache, data->creds)) != 0)
481             {
482                 flog(LOG_ERR, "could not store forwarded TGT into ccache: %s", error_message(ret));
483                 return(AUTH_ERR);
484             }
485         }
486     }
487     return(AUTH_SUCCESS);
488 }
489
490 static int closesess(struct authhandle *auth)
491 {
492     struct krb5data *data;
493     
494     data = auth->mechdata;
495     if(data->ccache != NULL)
496     {
497         krb5_cc_destroy(k5context, data->ccache);
498         data->ccache = NULL;
499     }
500     return(AUTH_SUCCESS);
501 }
502
503 struct authmech authmech_krb5 =
504 {
505     .inithandle = inithandle,
506     .release = release,
507     .authenticate = krbauth,
508     .opensess = opensess,
509     .closesess = closesess,
510     .name = L"krb5",
511     .enabled = 1
512 };
513
514 static int init(int hup)
515 {
516     int ret;
517     char *buf;
518     krb5_principal newprinc;
519     
520     if(!hup)
521     {
522         regmech(&authmech_krb5);
523         if((ret = krb5_init_context(&k5context)))
524         {
525             flog(LOG_CRIT, "could not initialize Kerberos context: %s", error_message(ret));
526             return(1);
527         }
528         if((buf = icwcstombs(confgetstr("auth-krb5", "service"), NULL)) == NULL)
529         {
530             flog(LOG_CRIT, "could not convert service name (%ls) into local charset: %s", confgetstr("auth-krb5", "service"), strerror(errno));
531             return(1);
532         } else {
533             if((ret = krb5_sname_to_principal(k5context, NULL, buf, KRB5_NT_SRV_HST, &myprinc)) != 0)
534             {
535                 flog(LOG_CRIT, "could not get principal for service %s: %s", buf, error_message(ret));
536                 free(buf);
537                 return(1);
538             }
539             free(buf);
540         }
541         if((buf = icwcstombs(confgetstr("auth-krb5", "keytab"), NULL)) == NULL)
542         {
543             flog(LOG_ERR, "could not convert keytab name (%ls) into local charset: %s, using default keytab instead", confgetstr("auth-krb5", "keytab"), strerror(errno));
544             keytab = NULL;
545         } else {
546             if((ret = krb5_kt_resolve(k5context, buf, &keytab)) != 0)
547             {
548                 flog(LOG_ERR, "could not open keytab %s: %s, using default keytab instead", buf, error_message(ret));
549                 keytab = NULL;
550             }
551             free(buf);
552         }
553     }
554     if(hup)
555     {
556         if((buf = icwcstombs(confgetstr("auth-krb5", "service"), NULL)) == NULL)
557         {
558             flog(LOG_CRIT, "could not convert service name (%ls) into local charset: %s, not updating principal", confgetstr("auth-krb5", "service"), strerror(errno));
559         } else {
560             if((ret = krb5_sname_to_principal(k5context, NULL, buf, KRB5_NT_SRV_HST, &newprinc)) != 0)
561             {
562                 flog(LOG_CRIT, "could not get principal for service %s: %s, not updating principal", buf, error_message(ret));
563             } else {
564                 krb5_free_principal(k5context, myprinc);
565                 myprinc = newprinc;
566             }
567             free(buf);
568         }
569         if(keytab != NULL)
570             krb5_kt_close(k5context, keytab);
571         if((buf = icwcstombs(confgetstr("auth-krb5", "keytab"), NULL)) == NULL)
572         {
573             flog(LOG_ERR, "could not convert keytab name (%ls) into local charset: %s, using default keytab instead", confgetstr("auth-krb5", "keytab"), strerror(errno));
574             keytab = NULL;
575         } else {
576             if((ret = krb5_kt_resolve(k5context, buf, &keytab)) != 0)
577             {
578                 flog(LOG_ERR, "could not open keytab %s: %s, using default keytab instead", buf, error_message(ret));
579                 keytab = NULL;
580             }
581             free(buf);
582         }
583     }
584     return(0);
585 }
586
587 static void terminate(void)
588 {
589     if(keytab != NULL)
590         krb5_kt_close(k5context, keytab);
591     krb5_free_principal(k5context, myprinc);
592     krb5_free_context(k5context);
593 }
594
595 static struct configvar myvars[] =
596 {
597     /** The name of the service principal to use for Kerberos V
598      * authentication. */
599     {CONF_VAR_STRING, "service", {.str = L"doldacond"}},
600     /** The path to an alternative keytab file. If unspecified, the
601      * system default keytab will be used. */
602     {CONF_VAR_STRING, "keytab", {.str = L""}},
603     /** Whether to renew renewable credentials automatically before
604      * they expire. */
605     {CONF_VAR_BOOL, "renewcreds", {.num = 1}},
606     /** If true, the default credentials cache will be used, which is
607      * useful for e.g. Linux kernel key handling. If false, a file
608      * credentials cache will be created using mkstemp(3), using the
609      * pattern /tmp/krb5cc_dc_$UID_XXXXXX. */
610     {CONF_VAR_BOOL, "usedefcc", {.num = 0}},
611     {CONF_VAR_END}
612 };
613
614 static struct module me =
615 {
616     .conf =
617     {
618         .vars = myvars
619     },
620     .init = init,
621     .terminate = terminate,
622     .name = "auth-krb5"
623 };
624
625 MODULE(me);
626
627 #endif /* HAVE_KRB5 */