pam_krb5auto.c

   1 /*
   2  *  pam_krb5auto - Gets initial credentials non-interactively
   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 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <unistd.h>
  22 #include <string.h>
  23 #include <stdarg.h>
  24 #include <malloc.h>
  25 #include <syslog.h>
  26 #include <krb5.h>
  27 #include <pwd.h>
  28 #include <errno.h>
  29
  30 #define PAM_SM_AUTH
  31
  32 #include <security/pam_modules.h>
  33
  34 #define DEF_INSTANCE "autologin"
  35
  36 struct options
  37 {
  38     char *realm;
  39     char *instance;
  40     char *keytab;
  41     int debug;
  42     int forwardable;
  43     int renewable;
  44 };
  45
  46 struct data
  47 {
  48     krb5_context ctx;
  49     krb5_ccache cc;
  50     krb5_principal me;
  51     krb5_creds initcreds;
  52     int hascreds;
  53     uid_t uid;
  54     gid_t gid;
  55 };
  56
  57 static void log(int prio, char *format, ...)
  58 {
  59     va_list args;
  60     char buf[1024];
  61
  62     va_start(args, format);
  63     snprintf(buf, sizeof(buf), "pam_krb5auto[%i]: %s", getpid(), format);
  64     vsyslog(prio, buf, args);
  65     va_end(args);
  66 }
  67
  68 static struct options *parseopts(int argc, const char **argv)
  69 {
  70     int i;
  71     struct options *opts;
  72     const char *p;
  73     int unit;
  74
  75     opts = malloc(sizeof(*opts));
  76     memset(opts, 0, sizeof(*opts));
  77     for(i = 0; i < argc; i++) {
  78         if(!strncmp(argv[i], "realm=", 6))
  79             opts->realm = strdup(argv[i] + 6);
  80         if(!strncmp(argv[i], "instance=", 9))
  81             opts->instance = strdup(argv[i] + 9);
  82         if(!strncmp(argv[i], "keytab=", 7))
  83             opts->keytab = strdup(argv[i] + 7);
  84         if(!strncmp(argv[i], "renew=", 6)) {
  85             p = argv[i] + strlen(argv[i]) - 1;
  86             unit = 1;
  87             if((*p >= 'a') && (*p <= 'z')) {
  88                 if(*p == 'm')
  89                     unit = 60;
  90                 else if(*p == 'h')
  91                     unit = 3600;
  92                 else if(*p == 'd')
  93                     unit = 86400;
  94                 else
  95                     unit = 1;
  96             }
  97             opts->renewable = atoi(argv[i] + 6) * unit;
  98         }
  99         if(!strcmp(argv[i], "forwardable"))
 100             opts->forwardable = 1;
 101         if(!strcmp(argv[i], "debug"))
 102             opts->debug = 1;
 103     }
 104     return(opts);
 105 }
 106
 107 static void freeopts(struct options *opts)
 108 {
 109     if(opts->realm != NULL)
 110         free(opts->realm);
 111     if(opts->instance != NULL)
 112         free(opts->instance);
 113     if(opts->keytab != NULL)
 114         free(opts->keytab);
 115     free(opts);
 116 }
 117
 118 static void freedata(struct data *data)
 119 {
 120     if(data->hascreds)
 121         krb5_free_cred_contents(data->ctx, &data->initcreds);
 122     if(data->cc != NULL)
 123         krb5_cc_close(data->ctx, data->cc);
 124     if(data->me != NULL)
 125         krb5_free_principal(data->ctx, data->me);
 126     if(data->ctx != NULL)
 127         krb5_free_context(data->ctx);
 128     free(data);
 129 }
 130
 131 static void cleanupdata(pam_handle_t *pamh, struct data *data, int error_status)
 132 {
 133     freedata(data);
 134 }
 135
 136 static struct data *getdata(pam_handle_t *pamh, struct options *opts)
 137 {
 138     int ret;
 139     struct data *data;
 140     char buf[1024];
 141     const char *user, *instance;
 142     struct passwd *pwent;
 143
 144     data = NULL;
 145     pam_get_data(pamh, "krb5auto-data", (const void **)&data);
 146     if(data == NULL) {
 147         if(opts->debug)
 148             log(LOG_DEBUG, "creating new instance");
 149         data = malloc(sizeof(*data));
 150         memset(data, 0, sizeof(*data));
 151         pam_get_user(pamh, &user, NULL);
 152         if(user == NULL) {
 153             log(LOG_ERR, "could not get user name");
 154             freedata(data);
 155             return(NULL);
 156         }
 157         errno = 0;
 158         if((pwent = getpwnam(user)) == NULL) {
 159             log(LOG_ERR, "could not user information for `%s': %s", user, (errno == 0)?"user not found":strerror(errno));
 160             freedata(data);
 161             return(NULL);
 162         }
 163         data->uid = pwent->pw_uid;
 164         data->gid = pwent->pw_gid;
 165         if((ret = krb5_init_context(&data->ctx)) != 0) {
 166             log(LOG_CRIT, "could not create krb5 context: %s", error_message(ret));
 167             freedata(data);
 168             return(NULL);
 169         }
 170         if(opts->instance)
 171             instance = opts->instance;
 172         else
 173             instance = DEF_INSTANCE;
 174         if(opts->realm)
 175             snprintf(buf, sizeof(buf), "%s/%s@%s", user, instance, opts->realm);
 176         else
 177             snprintf(buf, sizeof(buf), "%s/%s", user, instance);
 178         if((ret = krb5_parse_name(data->ctx, buf, &data->me)) != 0) {
 179             log(LOG_ERR, "could not parse principal name `%s': %s", buf, error_message(ret));
 180             freedata(data);
 181             return(NULL);
 182         }
 183         pam_set_data(pamh, "krb5auto-data", data, (void (*)(pam_handle_t *, void *, int))cleanupdata);
 184     }
 185     return(data);
 186 }
 187
 188 static int savecreds(pam_handle_t *pamh, struct options *opts, struct data *data)
 189 {
 190     int ret, fd;
 191     krb5_keytab kt;
 192     krb5_get_init_creds_opt icopts;
 193     char buf[1024], *ccname, *filename;
 194
 195     krb5_get_init_creds_opt_init(&icopts);
 196     kt = NULL;
 197
 198     if(opts->keytab) {
 199         if((ret = krb5_kt_resolve(data->ctx, opts->keytab, &kt)) != 0) {
 200             log(LOG_ERR, "could not resolve keytab `%s': %s", opts->keytab, error_message(ret));
 201             ret = PAM_SERVICE_ERR;
 202             goto out;
 203         }
 204         if(opts->debug)
 205             log(LOG_DEBUG, "using keytab `%s'", opts->keytab);
 206     }
 207     krb5_get_init_creds_opt_set_forwardable(&icopts, opts->forwardable);
 208     krb5_get_init_creds_opt_set_renew_life(&icopts, opts->renewable);
 209     if(data->hascreds) {
 210         krb5_free_cred_contents(data->ctx, &data->initcreds);
 211         data->hascreds = 0;
 212     }
 213     if((ret = krb5_get_init_creds_keytab(data->ctx, &data->initcreds, data->me, kt, 0, NULL, &icopts)) != 0) {
 214         log(LOG_ERR, "could not get credentials: %s", error_message(ret));
 215         ret = PAM_SERVICE_ERR;
 216         goto out;
 217     }
 218     data->hascreds = 1;
 219     if(opts->debug)
 220         log(LOG_DEBUG, "got creds successfully");
 221     snprintf(buf, sizeof(buf), "KRB5CCNAME=FILE:/tmp/krb5cc_%i_XXXXXX", data->uid);
 222     ccname = buf + sizeof("KRB5CCNAME=") - 1;
 223     filename = ccname + sizeof("FILE:") - 1;
 224     if((fd = mkstemp(filename)) < 0) {
 225         log(LOG_ERR, "could not create tempfile for credentials cache: %s", strerror(errno));
 226         ret = PAM_SERVICE_ERR;
 227         goto out;
 228     }
 229     close(fd);
 230     if(opts->debug)
 231         log(LOG_DEBUG, "created ccache `%s'", filename);
 232     if((ret = krb5_cc_resolve(data->ctx, ccname, &data->cc)) != 0) {
 233         log(LOG_ERR, "could not resolve ccache `%s': %s", ccname, error_message(ret));
 234         unlink(filename);
 235         ret = PAM_SERVICE_ERR;
 236         goto out;
 237     }
 238     if((ret = krb5_cc_initialize(data->ctx, data->cc, data->me)) != 0) {
 239         log(LOG_ERR, "could not initialize credentials cache `%s': %s", ccname, error_message(ret));
 240         unlink(filename);
 241         ret = PAM_SERVICE_ERR;
 242         goto out;
 243     }
 244     if((ret = krb5_cc_store_cred(data->ctx, data->cc, &data->initcreds)) != 0) {
 245         log(LOG_ERR, "could not store credentials: %s", error_message(ret));
 246         unlink(filename);
 247         ret = PAM_SERVICE_ERR;
 248         goto out;
 249     }
 250     chown(filename, data->uid, data->gid);
 251     pam_putenv(pamh, strdup(buf));
 252     if(opts->debug)
 253         log(LOG_DEBUG, "successfully initialized ccache");
 254     ret = PAM_SUCCESS;
 255
 256  out:
 257     if(kt != NULL)
 258         krb5_kt_close(data->ctx, kt);
 259     return(ret);
 260 }
 261
 262 static int delcreds(pam_handle_t *pamh, struct options *opts, struct data *data)
 263 {
 264     if(opts->debug)
 265         log(LOG_DEBUG, "deleting credentials");
 266     if(data->hascreds) {
 267         krb5_free_cred_contents(data->ctx, &data->initcreds);
 268         data->hascreds = 0;
 269         if(opts->debug)
 270             log(LOG_DEBUG, "freed internal creds");
 271     }
 272     if(data->cc != NULL) {
 273         krb5_cc_destroy(data->ctx, data->cc);
 274         data->cc = NULL;
 275         if(opts->debug)
 276             log(LOG_DEBUG, "destroyed ccache");
 277     }
 278     return(PAM_SUCCESS);
 279 }
 280
 281 PAM_EXTERN int pam_sm_authenticate(pam_handle_t *pamh, int flags, int argc, const char **argv)
 282 {
 283     struct options *opts;
 284
 285     opts = parseopts(argc, argv);
 286     if(opts->debug)
 287         log(LOG_DEBUG, "pam_sm_authenticate called");
 288     freeopts(opts);
 289     return(PAM_IGNORE);
 290 }
 291
 292 PAM_EXTERN int pam_sm_setcred(pam_handle_t *pamh, int flags, int argc, const char **argv)
 293 {
 294     struct options *opts;
 295     struct data *data;
 296     int ret;
 297
 298     opts = parseopts(argc, argv);
 299     if(opts->debug)
 300         log(LOG_DEBUG, "pam_sm_setcred called");
 301     data = getdata(pamh, opts);
 302     if(data == NULL) {
 303         log(LOG_ERR, "could not get data, erroring out");
 304         return(PAM_SERVICE_ERR);
 305     }
 306     ret = PAM_SERVICE_ERR;
 307     if(flags & PAM_ESTABLISH_CRED) {
 308         ret = savecreds(pamh, opts, data);
 309     } else if(flags & PAM_DELETE_CRED) {
 310         ret = delcreds(pamh, opts, data);
 311     }
 312     freeopts(opts);
 313     return(ret);
 314 }
 315
 316 /*
 317  * Local Variables:
 318  * compile-command: "gcc -Wall -g --shared -fPIC -o pam_krb5auto.so pam_krb5auto.c -lkrb5"
 319  * End:
 320  */