LCOV - code coverage report
Current view: top level - security/keys - request_key.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 7 336 2.1 %
Date: 2022-04-01 14:17:54 Functions: 1 14 7.1 %
Branches: 3 171 1.8 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /* Request a key from userspace
       3                 :            :  *
       4                 :            :  * Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved.
       5                 :            :  * Written by David Howells (dhowells@redhat.com)
       6                 :            :  *
       7                 :            :  * See Documentation/security/keys/request-key.rst
       8                 :            :  */
       9                 :            : 
      10                 :            : #include <linux/export.h>
      11                 :            : #include <linux/sched.h>
      12                 :            : #include <linux/kmod.h>
      13                 :            : #include <linux/err.h>
      14                 :            : #include <linux/keyctl.h>
      15                 :            : #include <linux/slab.h>
      16                 :            : #include <net/net_namespace.h>
      17                 :            : #include "internal.h"
      18                 :            : #include <keys/request_key_auth-type.h>
      19                 :            : 
      20                 :            : #define key_negative_timeout    60      /* default timeout on a negative key's existence */
      21                 :            : 
      22                 :          0 : static struct key *check_cached_key(struct keyring_search_context *ctx)
      23                 :            : {
      24                 :            : #ifdef CONFIG_KEYS_REQUEST_CACHE
      25                 :            :         struct key *key = current->cached_requested_key;
      26                 :            : 
      27                 :            :         if (key &&
      28                 :            :             ctx->match_data.cmp(key, &ctx->match_data) &&
      29                 :            :             !(key->flags & ((1 << KEY_FLAG_INVALIDATED) |
      30                 :            :                             (1 << KEY_FLAG_REVOKED))))
      31                 :            :                 return key_get(key);
      32                 :            : #endif
      33                 :          0 :         return NULL;
      34                 :            : }
      35                 :            : 
      36                 :          0 : static void cache_requested_key(struct key *key)
      37                 :            : {
      38                 :            : #ifdef CONFIG_KEYS_REQUEST_CACHE
      39                 :            :         struct task_struct *t = current;
      40                 :            : 
      41                 :            :         key_put(t->cached_requested_key);
      42                 :            :         t->cached_requested_key = key_get(key);
      43                 :            :         set_tsk_thread_flag(t, TIF_NOTIFY_RESUME);
      44                 :            : #endif
      45                 :            : }
      46                 :            : 
      47                 :            : /**
      48                 :            :  * complete_request_key - Complete the construction of a key.
      49                 :            :  * @authkey: The authorisation key.
      50                 :            :  * @error: The success or failute of the construction.
      51                 :            :  *
      52                 :            :  * Complete the attempt to construct a key.  The key will be negated
      53                 :            :  * if an error is indicated.  The authorisation key will be revoked
      54                 :            :  * unconditionally.
      55                 :            :  */
      56                 :          0 : void complete_request_key(struct key *authkey, int error)
      57                 :            : {
      58         [ #  # ]:          0 :         struct request_key_auth *rka = get_request_key_auth(authkey);
      59                 :          0 :         struct key *key = rka->target_key;
      60                 :            : 
      61                 :          0 :         kenter("%d{%d},%d", authkey->serial, key->serial, error);
      62                 :            : 
      63         [ #  # ]:          0 :         if (error < 0)
      64                 :          0 :                 key_negate_and_link(key, key_negative_timeout, NULL, authkey);
      65                 :            :         else
      66                 :          0 :                 key_revoke(authkey);
      67                 :          0 : }
      68                 :            : EXPORT_SYMBOL(complete_request_key);
      69                 :            : 
      70                 :            : /*
      71                 :            :  * Initialise a usermode helper that is going to have a specific session
      72                 :            :  * keyring.
      73                 :            :  *
      74                 :            :  * This is called in context of freshly forked kthread before kernel_execve(),
      75                 :            :  * so we can simply install the desired session_keyring at this point.
      76                 :            :  */
      77                 :          0 : static int umh_keys_init(struct subprocess_info *info, struct cred *cred)
      78                 :            : {
      79                 :          0 :         struct key *keyring = info->data;
      80                 :            : 
      81                 :          0 :         return install_session_keyring_to_cred(cred, keyring);
      82                 :            : }
      83                 :            : 
      84                 :            : /*
      85                 :            :  * Clean up a usermode helper with session keyring.
      86                 :            :  */
      87                 :          0 : static void umh_keys_cleanup(struct subprocess_info *info)
      88                 :            : {
      89                 :          0 :         struct key *keyring = info->data;
      90                 :          0 :         key_put(keyring);
      91                 :          0 : }
      92                 :            : 
      93                 :            : /*
      94                 :            :  * Call a usermode helper with a specific session keyring.
      95                 :            :  */
      96                 :          0 : static int call_usermodehelper_keys(const char *path, char **argv, char **envp,
      97                 :            :                                         struct key *session_keyring, int wait)
      98                 :            : {
      99                 :          0 :         struct subprocess_info *info;
     100                 :            : 
     101                 :          0 :         info = call_usermodehelper_setup(path, argv, envp, GFP_KERNEL,
     102                 :            :                                           umh_keys_init, umh_keys_cleanup,
     103                 :            :                                           session_keyring);
     104         [ #  # ]:          0 :         if (!info)
     105                 :            :                 return -ENOMEM;
     106                 :            : 
     107         [ #  # ]:          0 :         key_get(session_keyring);
     108                 :          0 :         return call_usermodehelper_exec(info, wait);
     109                 :            : }
     110                 :            : 
     111                 :            : /*
     112                 :            :  * Request userspace finish the construction of a key
     113                 :            :  * - execute "/sbin/request-key <op> <key> <uid> <gid> <keyring> <keyring> <keyring>"
     114                 :            :  */
     115                 :          0 : static int call_sbin_request_key(struct key *authkey, void *aux)
     116                 :            : {
     117                 :          0 :         static char const request_key[] = "/sbin/request-key";
     118                 :          0 :         struct request_key_auth *rka = get_request_key_auth(authkey);
     119                 :          0 :         const struct cred *cred = current_cred();
     120                 :          0 :         key_serial_t prkey, sskey;
     121                 :          0 :         struct key *key = rka->target_key, *keyring, *session, *user_session;
     122                 :          0 :         char *argv[9], *envp[3], uid_str[12], gid_str[12];
     123                 :          0 :         char key_str[12], keyring_str[3][12];
     124                 :          0 :         char desc[20];
     125                 :          0 :         int ret, i;
     126                 :            : 
     127                 :          0 :         kenter("{%d},{%d},%s", key->serial, authkey->serial, rka->op);
     128                 :            : 
     129                 :          0 :         ret = look_up_user_keyrings(NULL, &user_session);
     130         [ #  # ]:          0 :         if (ret < 0)
     131                 :          0 :                 goto error_us;
     132                 :            : 
     133                 :            :         /* allocate a new session keyring */
     134                 :          0 :         sprintf(desc, "_req.%u", key->serial);
     135                 :            : 
     136         [ #  # ]:          0 :         cred = get_current_cred();
     137                 :          0 :         keyring = keyring_alloc(desc, cred->fsuid, cred->fsgid, cred,
     138                 :            :                                 KEY_POS_ALL | KEY_USR_VIEW | KEY_USR_READ,
     139                 :            :                                 KEY_ALLOC_QUOTA_OVERRUN, NULL, NULL);
     140                 :          0 :         put_cred(cred);
     141         [ #  # ]:          0 :         if (IS_ERR(keyring)) {
     142                 :          0 :                 ret = PTR_ERR(keyring);
     143                 :          0 :                 goto error_alloc;
     144                 :            :         }
     145                 :            : 
     146                 :            :         /* attach the auth key to the session keyring */
     147                 :          0 :         ret = key_link(keyring, authkey);
     148         [ #  # ]:          0 :         if (ret < 0)
     149                 :          0 :                 goto error_link;
     150                 :            : 
     151                 :            :         /* record the UID and GID */
     152         [ #  # ]:          0 :         sprintf(uid_str, "%d", from_kuid(&init_user_ns, cred->fsuid));
     153         [ #  # ]:          0 :         sprintf(gid_str, "%d", from_kgid(&init_user_ns, cred->fsgid));
     154                 :            : 
     155                 :            :         /* we say which key is under construction */
     156                 :          0 :         sprintf(key_str, "%d", key->serial);
     157                 :            : 
     158                 :            :         /* we specify the process's default keyrings */
     159                 :          0 :         sprintf(keyring_str[0], "%d",
     160         [ #  # ]:          0 :                 cred->thread_keyring ? cred->thread_keyring->serial : 0);
     161                 :            : 
     162                 :          0 :         prkey = 0;
     163         [ #  # ]:          0 :         if (cred->process_keyring)
     164                 :          0 :                 prkey = cred->process_keyring->serial;
     165                 :          0 :         sprintf(keyring_str[1], "%d", prkey);
     166                 :            : 
     167                 :          0 :         session = cred->session_keyring;
     168         [ #  # ]:          0 :         if (!session)
     169                 :          0 :                 session = user_session;
     170                 :          0 :         sskey = session->serial;
     171                 :            : 
     172                 :          0 :         sprintf(keyring_str[2], "%d", sskey);
     173                 :            : 
     174                 :            :         /* set up a minimal environment */
     175                 :          0 :         i = 0;
     176                 :          0 :         envp[i++] = "HOME=/";
     177                 :          0 :         envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
     178                 :          0 :         envp[i] = NULL;
     179                 :            : 
     180                 :            :         /* set up the argument list */
     181                 :          0 :         i = 0;
     182                 :          0 :         argv[i++] = (char *)request_key;
     183                 :          0 :         argv[i++] = (char *)rka->op;
     184                 :          0 :         argv[i++] = key_str;
     185                 :          0 :         argv[i++] = uid_str;
     186                 :          0 :         argv[i++] = gid_str;
     187                 :          0 :         argv[i++] = keyring_str[0];
     188                 :          0 :         argv[i++] = keyring_str[1];
     189                 :          0 :         argv[i++] = keyring_str[2];
     190                 :          0 :         argv[i] = NULL;
     191                 :            : 
     192                 :            :         /* do it */
     193                 :          0 :         ret = call_usermodehelper_keys(request_key, argv, envp, keyring,
     194                 :            :                                        UMH_WAIT_PROC);
     195                 :          0 :         kdebug("usermode -> 0x%x", ret);
     196         [ #  # ]:          0 :         if (ret >= 0) {
     197                 :            :                 /* ret is the exit/wait code */
     198   [ #  #  #  # ]:          0 :                 if (test_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags) ||
     199                 :          0 :                     key_validate(key) < 0)
     200                 :            :                         ret = -ENOKEY;
     201                 :            :                 else
     202                 :            :                         /* ignore any errors from userspace if the key was
     203                 :            :                          * instantiated */
     204                 :            :                         ret = 0;
     205                 :            :         }
     206                 :            : 
     207                 :          0 : error_link:
     208                 :          0 :         key_put(keyring);
     209                 :            : 
     210                 :          0 : error_alloc:
     211                 :          0 :         key_put(user_session);
     212                 :          0 : error_us:
     213                 :          0 :         complete_request_key(authkey, ret);
     214                 :          0 :         kleave(" = %d", ret);
     215                 :          0 :         return ret;
     216                 :            : }
     217                 :            : 
     218                 :            : /*
     219                 :            :  * Call out to userspace for key construction.
     220                 :            :  *
     221                 :            :  * Program failure is ignored in favour of key status.
     222                 :            :  */
     223                 :          0 : static int construct_key(struct key *key, const void *callout_info,
     224                 :            :                          size_t callout_len, void *aux,
     225                 :            :                          struct key *dest_keyring)
     226                 :            : {
     227                 :          0 :         request_key_actor_t actor;
     228                 :          0 :         struct key *authkey;
     229                 :          0 :         int ret;
     230                 :            : 
     231                 :          0 :         kenter("%d,%p,%zu,%p", key->serial, callout_info, callout_len, aux);
     232                 :            : 
     233                 :            :         /* allocate an authorisation key */
     234                 :          0 :         authkey = request_key_auth_new(key, "create", callout_info, callout_len,
     235                 :            :                                        dest_keyring);
     236         [ #  # ]:          0 :         if (IS_ERR(authkey))
     237                 :          0 :                 return PTR_ERR(authkey);
     238                 :            : 
     239                 :            :         /* Make the call */
     240                 :          0 :         actor = call_sbin_request_key;
     241         [ #  # ]:          0 :         if (key->type->request_key)
     242                 :          0 :                 actor = key->type->request_key;
     243                 :            : 
     244                 :          0 :         ret = actor(authkey, aux);
     245                 :            : 
     246                 :            :         /* check that the actor called complete_request_key() prior to
     247                 :            :          * returning an error */
     248   [ #  #  #  #  :          0 :         WARN_ON(ret < 0 &&
                   #  # ]
     249                 :            :                 !test_bit(KEY_FLAG_INVALIDATED, &authkey->flags));
     250                 :            : 
     251                 :          0 :         key_put(authkey);
     252                 :          0 :         kleave(" = %d", ret);
     253                 :          0 :         return ret;
     254                 :            : }
     255                 :            : 
     256                 :            : /*
     257                 :            :  * Get the appropriate destination keyring for the request.
     258                 :            :  *
     259                 :            :  * The keyring selected is returned with an extra reference upon it which the
     260                 :            :  * caller must release.
     261                 :            :  */
     262                 :          0 : static int construct_get_dest_keyring(struct key **_dest_keyring)
     263                 :            : {
     264                 :          0 :         struct request_key_auth *rka;
     265         [ #  # ]:          0 :         const struct cred *cred = current_cred();
     266                 :          0 :         struct key *dest_keyring = *_dest_keyring, *authkey;
     267                 :          0 :         int ret;
     268                 :            : 
     269                 :          0 :         kenter("%p", dest_keyring);
     270                 :            : 
     271                 :            :         /* find the appropriate keyring */
     272         [ #  # ]:          0 :         if (dest_keyring) {
     273                 :            :                 /* the caller supplied one */
     274                 :          0 :                 key_get(dest_keyring);
     275                 :            :         } else {
     276                 :          0 :                 bool do_perm_check = true;
     277                 :            : 
     278                 :            :                 /* use a default keyring; falling through the cases until we
     279                 :            :                  * find one that we actually have */
     280   [ #  #  #  #  :          0 :                 switch (cred->jit_keyring) {
                #  #  # ]
     281                 :          0 :                 case KEY_REQKEY_DEFL_DEFAULT:
     282                 :            :                 case KEY_REQKEY_DEFL_REQUESTOR_KEYRING:
     283         [ #  # ]:          0 :                         if (cred->request_key_auth) {
     284                 :          0 :                                 authkey = cred->request_key_auth;
     285                 :          0 :                                 down_read(&authkey->sem);
     286                 :          0 :                                 rka = get_request_key_auth(authkey);
     287         [ #  # ]:          0 :                                 if (!test_bit(KEY_FLAG_REVOKED,
     288                 :          0 :                                               &authkey->flags))
     289                 :          0 :                                         dest_keyring =
     290         [ #  # ]:          0 :                                                 key_get(rka->dest_keyring);
     291                 :          0 :                                 up_read(&authkey->sem);
     292         [ #  # ]:          0 :                                 if (dest_keyring) {
     293                 :            :                                         do_perm_check = false;
     294                 :            :                                         break;
     295                 :            :                                 }
     296                 :            :                         }
     297                 :            : 
     298                 :            :                         /* fall through */
     299                 :            :                 case KEY_REQKEY_DEFL_THREAD_KEYRING:
     300         [ #  # ]:          0 :                         dest_keyring = key_get(cred->thread_keyring);
     301         [ #  # ]:          0 :                         if (dest_keyring)
     302                 :            :                                 break;
     303                 :            : 
     304                 :            :                         /* fall through */
     305                 :            :                 case KEY_REQKEY_DEFL_PROCESS_KEYRING:
     306         [ #  # ]:          0 :                         dest_keyring = key_get(cred->process_keyring);
     307         [ #  # ]:          0 :                         if (dest_keyring)
     308                 :            :                                 break;
     309                 :            : 
     310                 :            :                         /* fall through */
     311                 :            :                 case KEY_REQKEY_DEFL_SESSION_KEYRING:
     312         [ #  # ]:          0 :                         dest_keyring = key_get(cred->session_keyring);
     313                 :            : 
     314         [ #  # ]:          0 :                         if (dest_keyring)
     315                 :            :                                 break;
     316                 :            : 
     317                 :            :                         /* fall through */
     318                 :            :                 case KEY_REQKEY_DEFL_USER_SESSION_KEYRING:
     319                 :          0 :                         ret = look_up_user_keyrings(NULL, &dest_keyring);
     320         [ #  # ]:          0 :                         if (ret < 0)
     321                 :            :                                 return ret;
     322                 :            :                         break;
     323                 :            : 
     324                 :          0 :                 case KEY_REQKEY_DEFL_USER_KEYRING:
     325                 :          0 :                         ret = look_up_user_keyrings(&dest_keyring, NULL);
     326         [ #  # ]:          0 :                         if (ret < 0)
     327                 :            :                                 return ret;
     328                 :            :                         break;
     329                 :            : 
     330                 :          0 :                 case KEY_REQKEY_DEFL_GROUP_KEYRING:
     331                 :            :                 default:
     332                 :          0 :                         BUG();
     333                 :            :                 }
     334                 :            : 
     335                 :            :                 /*
     336                 :            :                  * Require Write permission on the keyring.  This is essential
     337                 :            :                  * because the default keyring may be the session keyring, and
     338                 :            :                  * joining a keyring only requires Search permission.
     339                 :            :                  *
     340                 :            :                  * However, this check is skipped for the "requestor keyring" so
     341                 :            :                  * that /sbin/request-key can itself use request_key() to add
     342                 :            :                  * keys to the original requestor's destination keyring.
     343                 :            :                  */
     344   [ #  #  #  # ]:          0 :                 if (dest_keyring && do_perm_check) {
     345                 :          0 :                         ret = key_permission(make_key_ref(dest_keyring, 1),
     346                 :            :                                              KEY_NEED_WRITE);
     347         [ #  # ]:          0 :                         if (ret) {
     348                 :          0 :                                 key_put(dest_keyring);
     349                 :          0 :                                 return ret;
     350                 :            :                         }
     351                 :            :                 }
     352                 :            :         }
     353                 :            : 
     354                 :          0 :         *_dest_keyring = dest_keyring;
     355                 :          0 :         kleave(" [dk %d]", key_serial(dest_keyring));
     356                 :          0 :         return 0;
     357                 :            : }
     358                 :            : 
     359                 :            : /*
     360                 :            :  * Allocate a new key in under-construction state and attempt to link it in to
     361                 :            :  * the requested keyring.
     362                 :            :  *
     363                 :            :  * May return a key that's already under construction instead if there was a
     364                 :            :  * race between two thread calling request_key().
     365                 :            :  */
     366                 :          0 : static int construct_alloc_key(struct keyring_search_context *ctx,
     367                 :            :                                struct key *dest_keyring,
     368                 :            :                                unsigned long flags,
     369                 :            :                                struct key_user *user,
     370                 :            :                                struct key **_key)
     371                 :            : {
     372                 :          0 :         struct assoc_array_edit *edit = NULL;
     373                 :          0 :         struct key *key;
     374                 :          0 :         key_perm_t perm;
     375                 :          0 :         key_ref_t key_ref;
     376                 :          0 :         int ret;
     377                 :            : 
     378                 :          0 :         kenter("%s,%s,,,",
     379                 :            :                ctx->index_key.type->name, ctx->index_key.description);
     380                 :            : 
     381                 :          0 :         *_key = NULL;
     382                 :          0 :         mutex_lock(&user->cons_lock);
     383                 :            : 
     384                 :          0 :         perm = KEY_POS_VIEW | KEY_POS_SEARCH | KEY_POS_LINK | KEY_POS_SETATTR;
     385                 :          0 :         perm |= KEY_USR_VIEW;
     386         [ #  # ]:          0 :         if (ctx->index_key.type->read)
     387                 :          0 :                 perm |= KEY_POS_READ;
     388         [ #  # ]:          0 :         if (ctx->index_key.type == &key_type_keyring ||
     389         [ #  # ]:          0 :             ctx->index_key.type->update)
     390                 :          0 :                 perm |= KEY_POS_WRITE;
     391                 :            : 
     392                 :          0 :         key = key_alloc(ctx->index_key.type, ctx->index_key.description,
     393                 :            :                         ctx->cred->fsuid, ctx->cred->fsgid, ctx->cred,
     394                 :            :                         perm, flags, NULL);
     395         [ #  # ]:          0 :         if (IS_ERR(key))
     396                 :          0 :                 goto alloc_failed;
     397                 :            : 
     398                 :          0 :         set_bit(KEY_FLAG_USER_CONSTRUCT, &key->flags);
     399                 :            : 
     400         [ #  # ]:          0 :         if (dest_keyring) {
     401                 :          0 :                 ret = __key_link_lock(dest_keyring, &ctx->index_key);
     402         [ #  # ]:          0 :                 if (ret < 0)
     403                 :          0 :                         goto link_lock_failed;
     404                 :          0 :                 ret = __key_link_begin(dest_keyring, &ctx->index_key, &edit);
     405         [ #  # ]:          0 :                 if (ret < 0)
     406                 :          0 :                         goto link_prealloc_failed;
     407                 :            :         }
     408                 :            : 
     409                 :            :         /* attach the key to the destination keyring under lock, but we do need
     410                 :            :          * to do another check just in case someone beat us to it whilst we
     411                 :            :          * waited for locks */
     412                 :          0 :         mutex_lock(&key_construction_mutex);
     413                 :            : 
     414                 :          0 :         rcu_read_lock();
     415                 :          0 :         key_ref = search_process_keyrings_rcu(ctx);
     416                 :          0 :         rcu_read_unlock();
     417         [ #  # ]:          0 :         if (!IS_ERR(key_ref))
     418                 :          0 :                 goto key_already_present;
     419                 :            : 
     420         [ #  # ]:          0 :         if (dest_keyring)
     421                 :          0 :                 __key_link(key, &edit);
     422                 :            : 
     423                 :          0 :         mutex_unlock(&key_construction_mutex);
     424         [ #  # ]:          0 :         if (dest_keyring)
     425                 :          0 :                 __key_link_end(dest_keyring, &ctx->index_key, edit);
     426                 :          0 :         mutex_unlock(&user->cons_lock);
     427                 :          0 :         *_key = key;
     428                 :          0 :         kleave(" = 0 [%d]", key_serial(key));
     429                 :          0 :         return 0;
     430                 :            : 
     431                 :            :         /* the key is now present - we tell the caller that we found it by
     432                 :            :          * returning -EINPROGRESS  */
     433                 :            : key_already_present:
     434                 :          0 :         key_put(key);
     435                 :          0 :         mutex_unlock(&key_construction_mutex);
     436         [ #  # ]:          0 :         key = key_ref_to_ptr(key_ref);
     437         [ #  # ]:          0 :         if (dest_keyring) {
     438                 :          0 :                 ret = __key_link_check_live_key(dest_keyring, key);
     439         [ #  # ]:          0 :                 if (ret == 0)
     440                 :          0 :                         __key_link(key, &edit);
     441                 :          0 :                 __key_link_end(dest_keyring, &ctx->index_key, edit);
     442         [ #  # ]:          0 :                 if (ret < 0)
     443                 :          0 :                         goto link_check_failed;
     444                 :            :         }
     445                 :          0 :         mutex_unlock(&user->cons_lock);
     446                 :          0 :         *_key = key;
     447                 :          0 :         kleave(" = -EINPROGRESS [%d]", key_serial(key));
     448                 :          0 :         return -EINPROGRESS;
     449                 :            : 
     450                 :            : link_check_failed:
     451                 :          0 :         mutex_unlock(&user->cons_lock);
     452                 :          0 :         key_put(key);
     453                 :          0 :         kleave(" = %d [linkcheck]", ret);
     454                 :          0 :         return ret;
     455                 :            : 
     456                 :            : link_prealloc_failed:
     457                 :          0 :         __key_link_end(dest_keyring, &ctx->index_key, edit);
     458                 :          0 : link_lock_failed:
     459                 :          0 :         mutex_unlock(&user->cons_lock);
     460                 :          0 :         key_put(key);
     461                 :          0 :         kleave(" = %d [prelink]", ret);
     462                 :          0 :         return ret;
     463                 :            : 
     464                 :            : alloc_failed:
     465                 :          0 :         mutex_unlock(&user->cons_lock);
     466                 :          0 :         kleave(" = %ld", PTR_ERR(key));
     467                 :          0 :         return PTR_ERR(key);
     468                 :            : }
     469                 :            : 
     470                 :            : /*
     471                 :            :  * Commence key construction.
     472                 :            :  */
     473                 :          0 : static struct key *construct_key_and_link(struct keyring_search_context *ctx,
     474                 :            :                                           const char *callout_info,
     475                 :            :                                           size_t callout_len,
     476                 :            :                                           void *aux,
     477                 :            :                                           struct key *dest_keyring,
     478                 :            :                                           unsigned long flags)
     479                 :            : {
     480                 :          0 :         struct key_user *user;
     481                 :          0 :         struct key *key;
     482                 :          0 :         int ret;
     483                 :            : 
     484                 :          0 :         kenter("");
     485                 :            : 
     486         [ #  # ]:          0 :         if (ctx->index_key.type == &key_type_keyring)
     487                 :            :                 return ERR_PTR(-EPERM);
     488                 :            : 
     489                 :          0 :         ret = construct_get_dest_keyring(&dest_keyring);
     490         [ #  # ]:          0 :         if (ret)
     491                 :          0 :                 goto error;
     492                 :            : 
     493                 :          0 :         user = key_user_lookup(current_fsuid());
     494         [ #  # ]:          0 :         if (!user) {
     495                 :          0 :                 ret = -ENOMEM;
     496                 :          0 :                 goto error_put_dest_keyring;
     497                 :            :         }
     498                 :            : 
     499                 :          0 :         ret = construct_alloc_key(ctx, dest_keyring, flags, user, &key);
     500                 :          0 :         key_user_put(user);
     501                 :            : 
     502         [ #  # ]:          0 :         if (ret == 0) {
     503                 :          0 :                 ret = construct_key(key, callout_info, callout_len, aux,
     504                 :            :                                     dest_keyring);
     505         [ #  # ]:          0 :                 if (ret < 0) {
     506                 :          0 :                         kdebug("cons failed");
     507                 :          0 :                         goto construction_failed;
     508                 :            :                 }
     509         [ #  # ]:          0 :         } else if (ret == -EINPROGRESS) {
     510                 :            :                 ret = 0;
     511                 :            :         } else {
     512                 :          0 :                 goto error_put_dest_keyring;
     513                 :            :         }
     514                 :            : 
     515                 :          0 :         key_put(dest_keyring);
     516                 :          0 :         kleave(" = key %d", key_serial(key));
     517                 :          0 :         return key;
     518                 :            : 
     519                 :            : construction_failed:
     520                 :          0 :         key_negate_and_link(key, key_negative_timeout, NULL, NULL);
     521                 :          0 :         key_put(key);
     522                 :          0 : error_put_dest_keyring:
     523                 :          0 :         key_put(dest_keyring);
     524                 :          0 : error:
     525                 :          0 :         kleave(" = %d", ret);
     526                 :          0 :         return ERR_PTR(ret);
     527                 :            : }
     528                 :            : 
     529                 :            : /**
     530                 :            :  * request_key_and_link - Request a key and cache it in a keyring.
     531                 :            :  * @type: The type of key we want.
     532                 :            :  * @description: The searchable description of the key.
     533                 :            :  * @domain_tag: The domain in which the key operates.
     534                 :            :  * @callout_info: The data to pass to the instantiation upcall (or NULL).
     535                 :            :  * @callout_len: The length of callout_info.
     536                 :            :  * @aux: Auxiliary data for the upcall.
     537                 :            :  * @dest_keyring: Where to cache the key.
     538                 :            :  * @flags: Flags to key_alloc().
     539                 :            :  *
     540                 :            :  * A key matching the specified criteria (type, description, domain_tag) is
     541                 :            :  * searched for in the process's keyrings and returned with its usage count
     542                 :            :  * incremented if found.  Otherwise, if callout_info is not NULL, a key will be
     543                 :            :  * allocated and some service (probably in userspace) will be asked to
     544                 :            :  * instantiate it.
     545                 :            :  *
     546                 :            :  * If successfully found or created, the key will be linked to the destination
     547                 :            :  * keyring if one is provided.
     548                 :            :  *
     549                 :            :  * Returns a pointer to the key if successful; -EACCES, -ENOKEY, -EKEYREVOKED
     550                 :            :  * or -EKEYEXPIRED if an inaccessible, negative, revoked or expired key was
     551                 :            :  * found; -ENOKEY if no key was found and no @callout_info was given; -EDQUOT
     552                 :            :  * if insufficient key quota was available to create a new key; or -ENOMEM if
     553                 :            :  * insufficient memory was available.
     554                 :            :  *
     555                 :            :  * If the returned key was created, then it may still be under construction,
     556                 :            :  * and wait_for_key_construction() should be used to wait for that to complete.
     557                 :            :  */
     558                 :          0 : struct key *request_key_and_link(struct key_type *type,
     559                 :            :                                  const char *description,
     560                 :            :                                  struct key_tag *domain_tag,
     561                 :            :                                  const void *callout_info,
     562                 :            :                                  size_t callout_len,
     563                 :            :                                  void *aux,
     564                 :            :                                  struct key *dest_keyring,
     565                 :            :                                  unsigned long flags)
     566                 :            : {
     567                 :          0 :         struct keyring_search_context ctx = {
     568                 :            :                 .index_key.type         = type,
     569                 :            :                 .index_key.domain_tag   = domain_tag,
     570                 :            :                 .index_key.description  = description,
     571                 :          0 :                 .index_key.desc_len     = strlen(description),
     572         [ #  # ]:          0 :                 .cred                   = current_cred(),
     573                 :            :                 .match_data.cmp         = key_default_cmp,
     574                 :            :                 .match_data.raw_data    = description,
     575                 :            :                 .match_data.lookup_type = KEYRING_SEARCH_LOOKUP_DIRECT,
     576                 :            :                 .flags                  = (KEYRING_SEARCH_DO_STATE_CHECK |
     577                 :            :                                            KEYRING_SEARCH_SKIP_EXPIRED |
     578                 :            :                                            KEYRING_SEARCH_RECURSE),
     579                 :            :         };
     580                 :          0 :         struct key *key;
     581                 :          0 :         key_ref_t key_ref;
     582                 :          0 :         int ret;
     583                 :            : 
     584                 :          0 :         kenter("%s,%s,%p,%zu,%p,%p,%lx",
     585                 :            :                ctx.index_key.type->name, ctx.index_key.description,
     586                 :            :                callout_info, callout_len, aux, dest_keyring, flags);
     587                 :            : 
     588         [ #  # ]:          0 :         if (type->match_preparse) {
     589                 :          0 :                 ret = type->match_preparse(&ctx.match_data);
     590         [ #  # ]:          0 :                 if (ret < 0) {
     591                 :          0 :                         key = ERR_PTR(ret);
     592                 :          0 :                         goto error;
     593                 :            :                 }
     594                 :            :         }
     595                 :            : 
     596                 :          0 :         key = check_cached_key(&ctx);
     597                 :          0 :         if (key)
     598                 :            :                 goto error_free;
     599                 :            : 
     600                 :            :         /* search all the process keyrings for a key */
     601                 :          0 :         rcu_read_lock();
     602                 :            :         key_ref = search_process_keyrings_rcu(&ctx);
     603                 :          0 :         rcu_read_unlock();
     604                 :            : 
     605         [ #  # ]:          0 :         if (!IS_ERR(key_ref)) {
     606         [ #  # ]:          0 :                 if (dest_keyring) {
     607                 :          0 :                         ret = key_task_permission(key_ref, current_cred(),
     608                 :            :                                                   KEY_NEED_LINK);
     609         [ #  # ]:          0 :                         if (ret < 0) {
     610                 :          0 :                                 key_ref_put(key_ref);
     611                 :          0 :                                 key = ERR_PTR(ret);
     612                 :          0 :                                 goto error_free;
     613                 :            :                         }
     614                 :            :                 }
     615                 :            : 
     616         [ #  # ]:          0 :                 key = key_ref_to_ptr(key_ref);
     617         [ #  # ]:          0 :                 if (dest_keyring) {
     618                 :          0 :                         ret = key_link(dest_keyring, key);
     619         [ #  # ]:          0 :                         if (ret < 0) {
     620                 :          0 :                                 key_put(key);
     621                 :          0 :                                 key = ERR_PTR(ret);
     622                 :          0 :                                 goto error_free;
     623                 :            :                         }
     624                 :            :                 }
     625                 :            : 
     626                 :            :                 /* Only cache the key on immediate success */
     627                 :            :                 cache_requested_key(key);
     628         [ #  # ]:          0 :         } else if (PTR_ERR(key_ref) != -EAGAIN) {
     629                 :            :                 key = ERR_CAST(key_ref);
     630                 :            :         } else  {
     631                 :            :                 /* the search failed, but the keyrings were searchable, so we
     632                 :            :                  * should consult userspace if we can */
     633         [ #  # ]:          0 :                 key = ERR_PTR(-ENOKEY);
     634         [ #  # ]:          0 :                 if (!callout_info)
     635                 :          0 :                         goto error_free;
     636                 :            : 
     637                 :          0 :                 key = construct_key_and_link(&ctx, callout_info, callout_len,
     638                 :            :                                              aux, dest_keyring, flags);
     639                 :            :         }
     640                 :            : 
     641                 :          0 : error_free:
     642         [ #  # ]:          0 :         if (type->match_free)
     643                 :          0 :                 type->match_free(&ctx.match_data);
     644                 :          0 : error:
     645                 :          0 :         kleave(" = %p", key);
     646                 :          0 :         return key;
     647                 :            : }
     648                 :            : 
     649                 :            : /**
     650                 :            :  * wait_for_key_construction - Wait for construction of a key to complete
     651                 :            :  * @key: The key being waited for.
     652                 :            :  * @intr: Whether to wait interruptibly.
     653                 :            :  *
     654                 :            :  * Wait for a key to finish being constructed.
     655                 :            :  *
     656                 :            :  * Returns 0 if successful; -ERESTARTSYS if the wait was interrupted; -ENOKEY
     657                 :            :  * if the key was negated; or -EKEYREVOKED or -EKEYEXPIRED if the key was
     658                 :            :  * revoked or expired.
     659                 :            :  */
     660                 :        418 : int wait_for_key_construction(struct key *key, bool intr)
     661                 :            : {
     662                 :        418 :         int ret;
     663                 :            : 
     664         [ -  + ]:        418 :         ret = wait_on_bit(&key->flags, KEY_FLAG_USER_CONSTRUCT,
     665                 :            :                           intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
     666         [ +  - ]:        418 :         if (ret)
     667                 :            :                 return -ERESTARTSYS;
     668                 :        418 :         ret = key_read_state(key);
     669         [ +  - ]:        418 :         if (ret < 0)
     670                 :            :                 return ret;
     671                 :        418 :         return key_validate(key);
     672                 :            : }
     673                 :            : EXPORT_SYMBOL(wait_for_key_construction);
     674                 :            : 
     675                 :            : /**
     676                 :            :  * request_key_tag - Request a key and wait for construction
     677                 :            :  * @type: Type of key.
     678                 :            :  * @description: The searchable description of the key.
     679                 :            :  * @domain_tag: The domain in which the key operates.
     680                 :            :  * @callout_info: The data to pass to the instantiation upcall (or NULL).
     681                 :            :  *
     682                 :            :  * As for request_key_and_link() except that it does not add the returned key
     683                 :            :  * to a keyring if found, new keys are always allocated in the user's quota,
     684                 :            :  * the callout_info must be a NUL-terminated string and no auxiliary data can
     685                 :            :  * be passed.
     686                 :            :  *
     687                 :            :  * Furthermore, it then works as wait_for_key_construction() to wait for the
     688                 :            :  * completion of keys undergoing construction with a non-interruptible wait.
     689                 :            :  */
     690                 :          0 : struct key *request_key_tag(struct key_type *type,
     691                 :            :                             const char *description,
     692                 :            :                             struct key_tag *domain_tag,
     693                 :            :                             const char *callout_info)
     694                 :            : {
     695                 :          0 :         struct key *key;
     696                 :          0 :         size_t callout_len = 0;
     697                 :          0 :         int ret;
     698                 :            : 
     699         [ #  # ]:          0 :         if (callout_info)
     700                 :          0 :                 callout_len = strlen(callout_info);
     701                 :          0 :         key = request_key_and_link(type, description, domain_tag,
     702                 :            :                                    callout_info, callout_len,
     703                 :            :                                    NULL, NULL, KEY_ALLOC_IN_QUOTA);
     704         [ #  # ]:          0 :         if (!IS_ERR(key)) {
     705                 :          0 :                 ret = wait_for_key_construction(key, false);
     706         [ #  # ]:          0 :                 if (ret < 0) {
     707                 :          0 :                         key_put(key);
     708                 :          0 :                         return ERR_PTR(ret);
     709                 :            :                 }
     710                 :            :         }
     711                 :            :         return key;
     712                 :            : }
     713                 :            : EXPORT_SYMBOL(request_key_tag);
     714                 :            : 
     715                 :            : /**
     716                 :            :  * request_key_with_auxdata - Request a key with auxiliary data for the upcaller
     717                 :            :  * @type: The type of key we want.
     718                 :            :  * @description: The searchable description of the key.
     719                 :            :  * @domain_tag: The domain in which the key operates.
     720                 :            :  * @callout_info: The data to pass to the instantiation upcall (or NULL).
     721                 :            :  * @callout_len: The length of callout_info.
     722                 :            :  * @aux: Auxiliary data for the upcall.
     723                 :            :  *
     724                 :            :  * As for request_key_and_link() except that it does not add the returned key
     725                 :            :  * to a keyring if found and new keys are always allocated in the user's quota.
     726                 :            :  *
     727                 :            :  * Furthermore, it then works as wait_for_key_construction() to wait for the
     728                 :            :  * completion of keys undergoing construction with a non-interruptible wait.
     729                 :            :  */
     730                 :          0 : struct key *request_key_with_auxdata(struct key_type *type,
     731                 :            :                                      const char *description,
     732                 :            :                                      struct key_tag *domain_tag,
     733                 :            :                                      const void *callout_info,
     734                 :            :                                      size_t callout_len,
     735                 :            :                                      void *aux)
     736                 :            : {
     737                 :          0 :         struct key *key;
     738                 :          0 :         int ret;
     739                 :            : 
     740                 :          0 :         key = request_key_and_link(type, description, domain_tag,
     741                 :            :                                    callout_info, callout_len,
     742                 :            :                                    aux, NULL, KEY_ALLOC_IN_QUOTA);
     743         [ #  # ]:          0 :         if (!IS_ERR(key)) {
     744                 :          0 :                 ret = wait_for_key_construction(key, false);
     745         [ #  # ]:          0 :                 if (ret < 0) {
     746                 :          0 :                         key_put(key);
     747                 :          0 :                         return ERR_PTR(ret);
     748                 :            :                 }
     749                 :            :         }
     750                 :            :         return key;
     751                 :            : }
     752                 :            : EXPORT_SYMBOL(request_key_with_auxdata);
     753                 :            : 
     754                 :            : /**
     755                 :            :  * request_key_rcu - Request key from RCU-read-locked context
     756                 :            :  * @type: The type of key we want.
     757                 :            :  * @description: The name of the key we want.
     758                 :            :  * @domain_tag: The domain in which the key operates.
     759                 :            :  *
     760                 :            :  * Request a key from a context that we may not sleep in (such as RCU-mode
     761                 :            :  * pathwalk).  Keys under construction are ignored.
     762                 :            :  *
     763                 :            :  * Return a pointer to the found key if successful, -ENOKEY if we couldn't find
     764                 :            :  * a key or some other error if the key found was unsuitable or inaccessible.
     765                 :            :  */
     766                 :          0 : struct key *request_key_rcu(struct key_type *type,
     767                 :            :                             const char *description,
     768                 :            :                             struct key_tag *domain_tag)
     769                 :            : {
     770                 :          0 :         struct keyring_search_context ctx = {
     771                 :            :                 .index_key.type         = type,
     772                 :            :                 .index_key.domain_tag   = domain_tag,
     773                 :            :                 .index_key.description  = description,
     774                 :          0 :                 .index_key.desc_len     = strlen(description),
     775                 :          0 :                 .cred                   = current_cred(),
     776                 :            :                 .match_data.cmp         = key_default_cmp,
     777                 :            :                 .match_data.raw_data    = description,
     778                 :            :                 .match_data.lookup_type = KEYRING_SEARCH_LOOKUP_DIRECT,
     779                 :            :                 .flags                  = (KEYRING_SEARCH_DO_STATE_CHECK |
     780                 :            :                                            KEYRING_SEARCH_SKIP_EXPIRED),
     781                 :            :         };
     782                 :          0 :         struct key *key;
     783                 :          0 :         key_ref_t key_ref;
     784                 :            : 
     785                 :          0 :         kenter("%s,%s", type->name, description);
     786                 :            : 
     787                 :          0 :         key = check_cached_key(&ctx);
     788                 :          0 :         if (key)
     789                 :            :                 return key;
     790                 :            : 
     791                 :            :         /* search all the process keyrings for a key */
     792                 :          0 :         key_ref = search_process_keyrings_rcu(&ctx);
     793         [ #  # ]:          0 :         if (IS_ERR(key_ref)) {
     794         [ #  # ]:          0 :                 key = ERR_CAST(key_ref);
     795         [ #  # ]:          0 :                 if (PTR_ERR(key_ref) == -EAGAIN)
     796                 :          0 :                         key = ERR_PTR(-ENOKEY);
     797                 :            :         } else {
     798                 :          0 :                 key = key_ref_to_ptr(key_ref);
     799                 :          0 :                 cache_requested_key(key);
     800                 :            :         }
     801                 :            : 
     802                 :          0 :         kleave(" = %p", key);
     803                 :          0 :         return key;
     804                 :            : }
     805                 :            : EXPORT_SYMBOL(request_key_rcu);

Generated by: LCOV version 1.14