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