1 /*- 2 * Copyright (c) 2002 Jacques A. Vidrine <nectar@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 #include <sys/cdefs.h> 27 __FBSDID("$FreeBSD$"); 28 29 #include <sys/param.h> 30 #include <errno.h> 31 #include <stdio.h> 32 #include <stdlib.h> 33 #include <string.h> 34 #include <unistd.h> 35 36 #include <krb5.h> 37 38 #define PAM_SM_AUTH 39 #define PAM_SM_CRED 40 #include <security/pam_appl.h> 41 #include <security/pam_modules.h> 42 #include <security/pam_mod_misc.h> 43 44 static const char superuser[] = "root"; 45 46 static long get_su_principal(krb5_context, const char *, const char *, 47 char **, krb5_principal *); 48 static int auth_krb5(pam_handle_t *, krb5_context, const char *, 49 krb5_principal); 50 51 PAM_EXTERN int 52 pam_sm_authenticate(pam_handle_t *pamh, int flags __unused, 53 int argc __unused, const char *argv[] __unused) 54 { 55 krb5_context context; 56 krb5_principal su_principal; 57 const char *user; 58 const void *ruser; 59 char *su_principal_name; 60 long rv; 61 int pamret; 62 63 pamret = pam_get_user(pamh, &user, NULL); 64 if (pamret != PAM_SUCCESS) 65 return (pamret); 66 PAM_LOG("Got user: %s", user); 67 pamret = pam_get_item(pamh, PAM_RUSER, &ruser); 68 if (pamret != PAM_SUCCESS) 69 return (pamret); 70 PAM_LOG("Got ruser: %s", (const char *)ruser); 71 rv = krb5_init_context(&context); 72 if (rv != 0) { 73 const char *msg = krb5_get_error_message(context, rv); 74 PAM_LOG("krb5_init_context failed: %s", msg); 75 krb5_free_error_message(context, msg); 76 return (PAM_SERVICE_ERR); 77 } 78 rv = get_su_principal(context, user, ruser, &su_principal_name, &su_principal); 79 if (rv != 0) 80 return (PAM_AUTH_ERR); 81 PAM_LOG("kuserok: %s -> %s", su_principal_name, user); 82 rv = krb5_kuserok(context, su_principal, user); 83 pamret = rv ? auth_krb5(pamh, context, su_principal_name, su_principal) : PAM_AUTH_ERR; 84 free(su_principal_name); 85 krb5_free_principal(context, su_principal); 86 krb5_free_context(context); 87 return (pamret); 88 } 89 90 PAM_EXTERN int 91 pam_sm_setcred(pam_handle_t *pamh __unused, int flags __unused, 92 int ac __unused, const char *av[] __unused) 93 { 94 95 return (PAM_SUCCESS); 96 } 97 98 /* Authenticate using Kerberos 5. 99 * pamh -- The PAM handle. 100 * context -- An initialized krb5_context. 101 * su_principal_name -- The target principal name, used only for password prompts. 102 * If NULL, the password prompts will not include a principal 103 * name. 104 * su_principal -- The target krb5_principal. 105 * Note that a valid keytab in the default location with a host entry 106 * must be available, and that the PAM application must have sufficient 107 * privileges to access it. 108 * Returns PAM_SUCCESS if authentication was successful, or an appropriate 109 * PAM error code if it was not. 110 */ 111 static int 112 auth_krb5(pam_handle_t *pamh, krb5_context context, const char *su_principal_name, 113 krb5_principal su_principal) 114 { 115 krb5_creds creds; 116 krb5_get_init_creds_opt *gic_opt; 117 krb5_verify_init_creds_opt vic_opt; 118 const char *pass; 119 char *prompt; 120 long rv; 121 int pamret; 122 123 prompt = NULL; 124 krb5_verify_init_creds_opt_init(&vic_opt); 125 if (su_principal_name != NULL) 126 (void)asprintf(&prompt, "Password for %s:", su_principal_name); 127 else 128 (void)asprintf(&prompt, "Password:"); 129 if (prompt == NULL) 130 return (PAM_BUF_ERR); 131 pass = NULL; 132 pamret = pam_get_authtok(pamh, PAM_AUTHTOK, &pass, prompt); 133 free(prompt); 134 if (pamret != PAM_SUCCESS) 135 return (pamret); 136 rv = krb5_get_init_creds_opt_alloc(context, &gic_opt); 137 if (rv != 0) { 138 const char *msg = krb5_get_error_message(context, rv); 139 PAM_LOG("krb5_get_init_creds_opt_alloc: %s", msg); 140 krb5_free_error_message(context, msg); 141 return (PAM_AUTH_ERR); 142 } 143 rv = krb5_get_init_creds_password(context, &creds, su_principal, 144 pass, NULL, NULL, 0, NULL, gic_opt); 145 krb5_get_init_creds_opt_free(context, gic_opt); 146 if (rv != 0) { 147 const char *msg = krb5_get_error_message(context, rv); 148 PAM_LOG("krb5_get_init_creds_password: %s", msg); 149 krb5_free_error_message(context, msg); 150 return (PAM_AUTH_ERR); 151 } 152 krb5_verify_init_creds_opt_set_ap_req_nofail(&vic_opt, 1); 153 rv = krb5_verify_init_creds(context, &creds, NULL, NULL, NULL, 154 &vic_opt); 155 krb5_free_cred_contents(context, &creds); 156 if (rv != 0) { 157 const char *msg = krb5_get_error_message(context, rv); 158 PAM_LOG("krb5_verify_init_creds: %s", msg); 159 krb5_free_error_message(context, msg); 160 return (PAM_AUTH_ERR); 161 } 162 return (PAM_SUCCESS); 163 } 164 165 /* Determine the target principal given the current user and the target user. 166 * context -- An initialized krb5_context. 167 * target_user -- The target username. 168 * current_user -- The current username. 169 * su_principal_name -- (out) The target principal name. 170 * su_principal -- (out) The target krb5_principal. 171 * When the target user is `root', the target principal will be a `root 172 * instance', e.g. `luser/root@REA.LM'. Otherwise, the target principal 173 * will simply be the current user's default principal name. Note that 174 * in any case, if KRB5CCNAME is set and a credentials cache exists, the 175 * principal name found there will be the `starting point', rather than 176 * the ruser parameter. 177 * 178 * Returns 0 for success, or a com_err error code on failure. 179 */ 180 static long 181 get_su_principal(krb5_context context, const char *target_user, const char *current_user, 182 char **su_principal_name, krb5_principal *su_principal) 183 { 184 krb5_principal default_principal; 185 krb5_ccache ccache; 186 char *principal_name, *ccname, *p; 187 long rv; 188 uid_t euid, ruid; 189 190 *su_principal = NULL; 191 default_principal = NULL; 192 /* Unless KRB5CCNAME was explicitly set, we won't really be able 193 * to look at the credentials cache since krb5_cc_default will 194 * look at getuid(). 195 */ 196 ruid = getuid(); 197 euid = geteuid(); 198 rv = seteuid(ruid); 199 if (rv != 0) 200 return (errno); 201 p = getenv("KRB5CCNAME"); 202 if (p != NULL) 203 ccname = strdup(p); 204 else 205 (void)asprintf(&ccname, "%s%lu", KRB5_DEFAULT_CCROOT, (unsigned long)ruid); 206 if (ccname == NULL) 207 return (errno); 208 rv = krb5_cc_resolve(context, ccname, &ccache); 209 free(ccname); 210 if (rv == 0) { 211 rv = krb5_cc_get_principal(context, ccache, &default_principal); 212 krb5_cc_close(context, ccache); 213 if (rv != 0) 214 default_principal = NULL; /* just to be safe */ 215 } 216 rv = seteuid(euid); 217 if (rv != 0) 218 return (errno); 219 if (default_principal == NULL) { 220 rv = krb5_make_principal(context, &default_principal, NULL, current_user, NULL); 221 if (rv != 0) { 222 PAM_LOG("Could not determine default principal name."); 223 return (rv); 224 } 225 } 226 /* Now that we have some principal, if the target account is 227 * `root', then transform it into a `root' instance, e.g. 228 * `user@REA.LM' -> `user/root@REA.LM'. 229 */ 230 rv = krb5_unparse_name(context, default_principal, &principal_name); 231 krb5_free_principal(context, default_principal); 232 if (rv != 0) { 233 const char *msg = krb5_get_error_message(context, rv); 234 PAM_LOG("krb5_unparse_name: %s", msg); 235 krb5_free_error_message(context, msg); 236 return (rv); 237 } 238 PAM_LOG("Default principal name: %s", principal_name); 239 if (strcmp(target_user, superuser) == 0) { 240 p = strrchr(principal_name, '@'); 241 if (p == NULL) { 242 PAM_LOG("malformed principal name `%s'", principal_name); 243 free(principal_name); 244 return (rv); 245 } 246 *p++ = '\0'; 247 *su_principal_name = NULL; 248 (void)asprintf(su_principal_name, "%s/%s@%s", principal_name, superuser, p); 249 free(principal_name); 250 } else 251 *su_principal_name = principal_name; 252 253 if (*su_principal_name == NULL) 254 return (errno); 255 rv = krb5_parse_name(context, *su_principal_name, &default_principal); 256 if (rv != 0) { 257 const char *msg = krb5_get_error_message(context, rv); 258 PAM_LOG("krb5_parse_name `%s': %s", *su_principal_name, msg); 259 krb5_free_error_message(context, msg); 260 free(*su_principal_name); 261 return (rv); 262 } 263 PAM_LOG("Target principal name: %s", *su_principal_name); 264 *su_principal = default_principal; 265 return (0); 266 } 267 268 PAM_MODULE_ENTRY("pam_ksu"); 269