1 // SPDX-License-Identifier: LGPL-2.1 2 /* 3 * SPNEGO upcall management for CIFS 4 * 5 * Copyright (c) 2007 Red Hat, Inc. 6 * Author(s): Jeff Layton (jlayton@redhat.com) 7 * 8 */ 9 10 #include <linux/list.h> 11 #include <linux/slab.h> 12 #include <linux/string.h> 13 #include <keys/user-type.h> 14 #include <linux/key-type.h> 15 #include <linux/keyctl.h> 16 #include <linux/inet.h> 17 #include "cifsglob.h" 18 #include "cifs_spnego.h" 19 #include "cifs_debug.h" 20 #include "cifsproto.h" 21 static const struct cred *spnego_cred; 22 23 /* create a new cifs key */ 24 static int 25 cifs_spnego_key_instantiate(struct key *key, struct key_preparsed_payload *prep) 26 { 27 char *payload; 28 int ret; 29 30 ret = -ENOMEM; 31 payload = kmemdup(prep->data, prep->datalen, GFP_KERNEL); 32 if (!payload) 33 goto error; 34 35 /* attach the data */ 36 key->payload.data[0] = payload; 37 ret = 0; 38 39 error: 40 return ret; 41 } 42 43 static void 44 cifs_spnego_key_destroy(struct key *key) 45 { 46 kfree(key->payload.data[0]); 47 } 48 49 50 /* 51 * keytype for CIFS spnego keys 52 */ 53 struct key_type cifs_spnego_key_type = { 54 .name = "cifs.spnego", 55 .instantiate = cifs_spnego_key_instantiate, 56 .destroy = cifs_spnego_key_destroy, 57 .describe = user_describe, 58 }; 59 60 /* length of longest version string e.g. strlen("ver=0xFF") */ 61 #define MAX_VER_STR_LEN 8 62 63 /* length of longest security mechanism name, eg in future could have 64 * strlen(";sec=ntlmsspi") */ 65 #define MAX_MECH_STR_LEN 13 66 67 /* strlen of ";host=" */ 68 #define HOST_KEY_LEN 6 69 70 /* strlen of ";ip4=" or ";ip6=" */ 71 #define IP_KEY_LEN 5 72 73 /* strlen of ";uid=0x" */ 74 #define UID_KEY_LEN 7 75 76 /* strlen of ";creduid=0x" */ 77 #define CREDUID_KEY_LEN 11 78 79 /* strlen of ";user=" */ 80 #define USER_KEY_LEN 6 81 82 /* strlen of ";pid=0x" */ 83 #define PID_KEY_LEN 7 84 85 /* strlen of ";upcall_target=" */ 86 #define UPCALL_TARGET_KEY_LEN 15 87 88 /* get a key struct with a SPNEGO security blob, suitable for session setup */ 89 struct key * 90 cifs_get_spnego_key(struct cifs_ses *sesInfo, 91 struct TCP_Server_Info *server) 92 { 93 struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr; 94 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr; 95 char *description, *dp; 96 size_t desc_len; 97 struct key *spnego_key; 98 const char *hostname = server->hostname; 99 const struct cred *saved_cred; 100 101 /* length of fields (with semicolons): ver=0xyz ip4=ipaddress 102 host=hostname sec=mechanism uid=0xFF user=username */ 103 desc_len = MAX_VER_STR_LEN + 104 HOST_KEY_LEN + strlen(hostname) + 105 IP_KEY_LEN + INET6_ADDRSTRLEN + 106 MAX_MECH_STR_LEN + 107 UID_KEY_LEN + (sizeof(uid_t) * 2) + 108 CREDUID_KEY_LEN + (sizeof(uid_t) * 2) + 109 PID_KEY_LEN + (sizeof(pid_t) * 2) + 1; 110 111 if (sesInfo->user_name) 112 desc_len += USER_KEY_LEN + strlen(sesInfo->user_name); 113 114 if (sesInfo->upcall_target == UPTARGET_MOUNT) 115 desc_len += UPCALL_TARGET_KEY_LEN + 5; // strlen("mount") 116 else 117 desc_len += UPCALL_TARGET_KEY_LEN + 3; // strlen("app") 118 119 spnego_key = ERR_PTR(-ENOMEM); 120 description = kzalloc(desc_len, GFP_KERNEL); 121 if (description == NULL) 122 goto out; 123 124 dp = description; 125 /* start with version and hostname portion of UNC string */ 126 spnego_key = ERR_PTR(-EINVAL); 127 sprintf(dp, "ver=0x%x;host=%s;", CIFS_SPNEGO_UPCALL_VERSION, 128 hostname); 129 dp = description + strlen(description); 130 131 /* add the server address */ 132 if (server->dstaddr.ss_family == AF_INET) 133 sprintf(dp, "ip4=%pI4", &sa->sin_addr); 134 else if (server->dstaddr.ss_family == AF_INET6) 135 sprintf(dp, "ip6=%pI6", &sa6->sin6_addr); 136 else 137 goto out; 138 139 dp = description + strlen(description); 140 141 /* for now, only sec=krb5 and sec=mskrb5 are valid */ 142 if (server->sec_kerberos) 143 sprintf(dp, ";sec=krb5"); 144 else if (server->sec_mskerberos) 145 sprintf(dp, ";sec=mskrb5"); 146 else { 147 cifs_dbg(VFS, "unknown or missing server auth type, use krb5\n"); 148 sprintf(dp, ";sec=krb5"); 149 } 150 151 dp = description + strlen(description); 152 sprintf(dp, ";uid=0x%x", 153 from_kuid_munged(&init_user_ns, sesInfo->linux_uid)); 154 155 dp = description + strlen(description); 156 sprintf(dp, ";creduid=0x%x", 157 from_kuid_munged(&init_user_ns, sesInfo->cred_uid)); 158 159 if (sesInfo->user_name) { 160 dp = description + strlen(description); 161 sprintf(dp, ";user=%s", sesInfo->user_name); 162 } 163 164 dp = description + strlen(description); 165 sprintf(dp, ";pid=0x%x", current->pid); 166 167 if (sesInfo->upcall_target == UPTARGET_MOUNT) { 168 dp = description + strlen(description); 169 sprintf(dp, ";upcall_target=mount"); 170 } else { 171 dp = description + strlen(description); 172 sprintf(dp, ";upcall_target=app"); 173 } 174 175 cifs_dbg(FYI, "key description = %s\n", description); 176 saved_cred = override_creds(spnego_cred); 177 spnego_key = request_key(&cifs_spnego_key_type, description, ""); 178 revert_creds(saved_cred); 179 180 #ifdef CONFIG_CIFS_DEBUG2 181 if (cifsFYI && !IS_ERR(spnego_key)) { 182 struct cifs_spnego_msg *msg = spnego_key->payload.data[0]; 183 cifs_dump_mem("SPNEGO reply blob:", msg->data, min(1024U, 184 msg->secblob_len + msg->sesskey_len)); 185 } 186 #endif /* CONFIG_CIFS_DEBUG2 */ 187 188 out: 189 kfree(description); 190 return spnego_key; 191 } 192 193 int 194 init_cifs_spnego(void) 195 { 196 struct cred *cred; 197 struct key *keyring; 198 int ret; 199 200 cifs_dbg(FYI, "Registering the %s key type\n", 201 cifs_spnego_key_type.name); 202 203 /* 204 * Create an override credential set with special thread keyring for 205 * spnego upcalls. 206 */ 207 208 cred = prepare_kernel_cred(&init_task); 209 if (!cred) 210 return -ENOMEM; 211 212 keyring = keyring_alloc(".cifs_spnego", 213 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred, 214 (KEY_POS_ALL & ~KEY_POS_SETATTR) | 215 KEY_USR_VIEW | KEY_USR_READ, 216 KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL); 217 if (IS_ERR(keyring)) { 218 ret = PTR_ERR(keyring); 219 goto failed_put_cred; 220 } 221 222 ret = register_key_type(&cifs_spnego_key_type); 223 if (ret < 0) 224 goto failed_put_key; 225 226 /* 227 * instruct request_key() to use this special keyring as a cache for 228 * the results it looks up 229 */ 230 set_bit(KEY_FLAG_ROOT_CAN_CLEAR, &keyring->flags); 231 cred->thread_keyring = keyring; 232 cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING; 233 spnego_cred = cred; 234 235 cifs_dbg(FYI, "cifs spnego keyring: %d\n", key_serial(keyring)); 236 return 0; 237 238 failed_put_key: 239 key_put(keyring); 240 failed_put_cred: 241 put_cred(cred); 242 return ret; 243 } 244 245 void 246 exit_cifs_spnego(void) 247 { 248 key_revoke(spnego_cred->thread_keyring); 249 unregister_key_type(&cifs_spnego_key_type); 250 put_cred(spnego_cred); 251 cifs_dbg(FYI, "Unregistered %s key type\n", cifs_spnego_key_type.name); 252 } 253