LCOV - code coverage report
Current view: top level - security/keys - keyctl.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 54 508 10.6 %
Date: 2020-09-30 20:25:40 Functions: 8 36 22.2 %
Branches: 27 437 6.2 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /* Userspace key control operations
       3                 :            :  *
       4                 :            :  * Copyright (C) 2004-5 Red Hat, Inc. All Rights Reserved.
       5                 :            :  * Written by David Howells (dhowells@redhat.com)
       6                 :            :  */
       7                 :            : 
       8                 :            : #include <linux/init.h>
       9                 :            : #include <linux/sched.h>
      10                 :            : #include <linux/sched/task.h>
      11                 :            : #include <linux/slab.h>
      12                 :            : #include <linux/syscalls.h>
      13                 :            : #include <linux/key.h>
      14                 :            : #include <linux/keyctl.h>
      15                 :            : #include <linux/fs.h>
      16                 :            : #include <linux/capability.h>
      17                 :            : #include <linux/cred.h>
      18                 :            : #include <linux/string.h>
      19                 :            : #include <linux/err.h>
      20                 :            : #include <linux/vmalloc.h>
      21                 :            : #include <linux/security.h>
      22                 :            : #include <linux/uio.h>
      23                 :            : #include <linux/uaccess.h>
      24                 :            : #include <keys/request_key_auth-type.h>
      25                 :            : #include "internal.h"
      26                 :            : 
      27                 :            : #define KEY_MAX_DESC_SIZE 4096
      28                 :            : 
      29                 :            : static const unsigned char keyrings_capabilities[2] = {
      30                 :            :         [0] = (KEYCTL_CAPS0_CAPABILITIES |
      31                 :            :                (IS_ENABLED(CONFIG_PERSISTENT_KEYRINGS)  ? KEYCTL_CAPS0_PERSISTENT_KEYRINGS : 0) |
      32                 :            :                (IS_ENABLED(CONFIG_KEY_DH_OPERATIONS)    ? KEYCTL_CAPS0_DIFFIE_HELLMAN : 0) |
      33                 :            :                (IS_ENABLED(CONFIG_ASYMMETRIC_KEY_TYPE)  ? KEYCTL_CAPS0_PUBLIC_KEY : 0) |
      34                 :            :                (IS_ENABLED(CONFIG_BIG_KEYS)             ? KEYCTL_CAPS0_BIG_KEY : 0) |
      35                 :            :                KEYCTL_CAPS0_INVALIDATE |
      36                 :            :                KEYCTL_CAPS0_RESTRICT_KEYRING |
      37                 :            :                KEYCTL_CAPS0_MOVE
      38                 :            :                ),
      39                 :            :         [1] = (KEYCTL_CAPS1_NS_KEYRING_NAME |
      40                 :            :                KEYCTL_CAPS1_NS_KEY_TAG),
      41                 :            : };
      42                 :            : 
      43                 :      12637 : static int key_get_type_from_user(char *type,
      44                 :            :                                   const char __user *_type,
      45                 :            :                                   unsigned len)
      46                 :            : {
      47                 :            :         int ret;
      48                 :            : 
      49                 :      12637 :         ret = strncpy_from_user(type, _type, len);
      50         [ +  - ]:      12637 :         if (ret < 0)
      51                 :            :                 return ret;
      52         [ +  - ]:      12638 :         if (ret == 0 || ret >= len)
      53                 :            :                 return -EINVAL;
      54         [ +  - ]:      12638 :         if (type[0] == '.')
      55                 :            :                 return -EPERM;
      56                 :      12638 :         type[len - 1] = '\0';
      57                 :      12638 :         return 0;
      58                 :            : }
      59                 :            : 
      60                 :            : /*
      61                 :            :  * Extract the description of a new key from userspace and either add it as a
      62                 :            :  * new key to the specified keyring or update a matching key in that keyring.
      63                 :            :  *
      64                 :            :  * If the description is NULL or an empty string, the key type is asked to
      65                 :            :  * generate one from the payload.
      66                 :            :  *
      67                 :            :  * The keyring must be writable so that we can attach the key to it.
      68                 :            :  *
      69                 :            :  * If successful, the new key's serial number is returned, otherwise an error
      70                 :            :  * code is returned.
      71                 :            :  */
      72                 :      25269 : SYSCALL_DEFINE5(add_key, const char __user *, _type,
      73                 :            :                 const char __user *, _description,
      74                 :            :                 const void __user *, _payload,
      75                 :            :                 size_t, plen,
      76                 :            :                 key_serial_t, ringid)
      77                 :            : {
      78                 :            :         key_ref_t keyring_ref, key_ref;
      79                 :            :         char type[32], *description;
      80                 :            :         void *payload;
      81                 :            :         long ret;
      82                 :            : 
      83                 :            :         ret = -EINVAL;
      84         [ +  + ]:      12635 :         if (plen > 1024 * 1024 - 1)
      85                 :            :                 goto error;
      86                 :            : 
      87                 :            :         /* draw all the data into kernel space */
      88                 :      12631 :         ret = key_get_type_from_user(type, _type, sizeof(type));
      89         [ +  + ]:      12638 :         if (ret < 0)
      90                 :            :                 goto error;
      91                 :            : 
      92                 :            :         description = NULL;
      93         [ +  - ]:      12635 :         if (_description) {
      94                 :      12637 :                 description = strndup_user(_description, KEY_MAX_DESC_SIZE);
      95         [ -  + ]:      12638 :                 if (IS_ERR(description)) {
      96                 :            :                         ret = PTR_ERR(description);
      97                 :          0 :                         goto error;
      98                 :            :                 }
      99         [ -  + ]:      12638 :                 if (!*description) {
     100                 :          0 :                         kfree(description);
     101                 :            :                         description = NULL;
     102   [ -  +  #  # ]:      12638 :                 } else if ((description[0] == '.') &&
     103                 :          0 :                            (strncmp(type, "keyring", 7) == 0)) {
     104                 :            :                         ret = -EPERM;
     105                 :            :                         goto error2;
     106                 :            :                 }
     107                 :            :         }
     108                 :            : 
     109                 :            :         /* pull the payload in if one was supplied */
     110                 :            :         payload = NULL;
     111                 :            : 
     112         [ +  - ]:      12635 :         if (plen) {
     113                 :            :                 ret = -ENOMEM;
     114                 :            :                 payload = kvmalloc(plen, GFP_KERNEL);
     115         [ +  + ]:      12637 :                 if (!payload)
     116                 :            :                         goto error2;
     117                 :            : 
     118                 :            :                 ret = -EFAULT;
     119         [ +  - ]:      12638 :                 if (copy_from_user(payload, _payload, plen) != 0)
     120                 :            :                         goto error3;
     121                 :            :         }
     122                 :            : 
     123                 :            :         /* find the target keyring (which must be writable) */
     124                 :      12638 :         keyring_ref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_NEED_WRITE);
     125         [ -  + ]:      12637 :         if (IS_ERR(keyring_ref)) {
     126                 :            :                 ret = PTR_ERR(keyring_ref);
     127                 :          0 :                 goto error3;
     128                 :            :         }
     129                 :            : 
     130                 :            :         /* create or update the requested key and add it to the target
     131                 :            :          * keyring */
     132                 :      12637 :         key_ref = key_create_or_update(keyring_ref, type, description,
     133                 :            :                                        payload, plen, KEY_PERM_UNDEF,
     134                 :            :                                        KEY_ALLOC_IN_QUOTA);
     135         [ +  - ]:      12638 :         if (!IS_ERR(key_ref)) {
     136                 :      12638 :                 ret = key_ref_to_ptr(key_ref)->serial;
     137                 :            :                 key_ref_put(key_ref);
     138                 :            :         }
     139                 :            :         else {
     140                 :            :                 ret = PTR_ERR(key_ref);
     141                 :            :         }
     142                 :            : 
     143                 :            :         key_ref_put(keyring_ref);
     144                 :            :  error3:
     145                 :      12638 :         kvfree_sensitive(payload, plen);
     146                 :            :  error2:
     147                 :      12641 :         kfree(description);
     148                 :            :  error:
     149                 :      12645 :         return ret;
     150                 :            : }
     151                 :            : 
     152                 :            : /*
     153                 :            :  * Search the process keyrings and keyring trees linked from those for a
     154                 :            :  * matching key.  Keyrings must have appropriate Search permission to be
     155                 :            :  * searched.
     156                 :            :  *
     157                 :            :  * If a key is found, it will be attached to the destination keyring if there's
     158                 :            :  * one specified and the serial number of the key will be returned.
     159                 :            :  *
     160                 :            :  * If no key is found, /sbin/request-key will be invoked if _callout_info is
     161                 :            :  * non-NULL in an attempt to create a key.  The _callout_info string will be
     162                 :            :  * passed to /sbin/request-key to aid with completing the request.  If the
     163                 :            :  * _callout_info string is "" then it will be changed to "-".
     164                 :            :  */
     165                 :          0 : SYSCALL_DEFINE4(request_key, const char __user *, _type,
     166                 :            :                 const char __user *, _description,
     167                 :            :                 const char __user *, _callout_info,
     168                 :            :                 key_serial_t, destringid)
     169                 :            : {
     170                 :            :         struct key_type *ktype;
     171                 :            :         struct key *key;
     172                 :            :         key_ref_t dest_ref;
     173                 :            :         size_t callout_len;
     174                 :            :         char type[32], *description, *callout_info;
     175                 :            :         long ret;
     176                 :            : 
     177                 :            :         /* pull the type into kernel space */
     178                 :          0 :         ret = key_get_type_from_user(type, _type, sizeof(type));
     179         [ #  # ]:          0 :         if (ret < 0)
     180                 :            :                 goto error;
     181                 :            : 
     182                 :            :         /* pull the description into kernel space */
     183                 :          0 :         description = strndup_user(_description, KEY_MAX_DESC_SIZE);
     184         [ #  # ]:          0 :         if (IS_ERR(description)) {
     185                 :            :                 ret = PTR_ERR(description);
     186                 :          0 :                 goto error;
     187                 :            :         }
     188                 :            : 
     189                 :            :         /* pull the callout info into kernel space */
     190                 :            :         callout_info = NULL;
     191                 :            :         callout_len = 0;
     192         [ #  # ]:          0 :         if (_callout_info) {
     193                 :          0 :                 callout_info = strndup_user(_callout_info, PAGE_SIZE);
     194         [ #  # ]:          0 :                 if (IS_ERR(callout_info)) {
     195                 :            :                         ret = PTR_ERR(callout_info);
     196                 :          0 :                         goto error2;
     197                 :            :                 }
     198                 :          0 :                 callout_len = strlen(callout_info);
     199                 :            :         }
     200                 :            : 
     201                 :            :         /* get the destination keyring if specified */
     202                 :            :         dest_ref = NULL;
     203         [ #  # ]:          0 :         if (destringid) {
     204                 :          0 :                 dest_ref = lookup_user_key(destringid, KEY_LOOKUP_CREATE,
     205                 :            :                                            KEY_NEED_WRITE);
     206         [ #  # ]:          0 :                 if (IS_ERR(dest_ref)) {
     207                 :            :                         ret = PTR_ERR(dest_ref);
     208                 :          0 :                         goto error3;
     209                 :            :                 }
     210                 :            :         }
     211                 :            : 
     212                 :            :         /* find the key type */
     213                 :          0 :         ktype = key_type_lookup(type);
     214         [ #  # ]:          0 :         if (IS_ERR(ktype)) {
     215                 :            :                 ret = PTR_ERR(ktype);
     216                 :          0 :                 goto error4;
     217                 :            :         }
     218                 :            : 
     219                 :            :         /* do the search */
     220                 :          0 :         key = request_key_and_link(ktype, description, NULL, callout_info,
     221                 :            :                                    callout_len, NULL, key_ref_to_ptr(dest_ref),
     222                 :            :                                    KEY_ALLOC_IN_QUOTA);
     223         [ #  # ]:          0 :         if (IS_ERR(key)) {
     224                 :            :                 ret = PTR_ERR(key);
     225                 :          0 :                 goto error5;
     226                 :            :         }
     227                 :            : 
     228                 :            :         /* wait for the key to finish being constructed */
     229                 :          0 :         ret = wait_for_key_construction(key, 1);
     230         [ #  # ]:          0 :         if (ret < 0)
     231                 :            :                 goto error6;
     232                 :            : 
     233                 :          0 :         ret = key->serial;
     234                 :            : 
     235                 :            : error6:
     236                 :          0 :         key_put(key);
     237                 :            : error5:
     238                 :          0 :         key_type_put(ktype);
     239                 :            : error4:
     240                 :            :         key_ref_put(dest_ref);
     241                 :            : error3:
     242                 :          0 :         kfree(callout_info);
     243                 :            : error2:
     244                 :          0 :         kfree(description);
     245                 :            : error:
     246                 :          0 :         return ret;
     247                 :            : }
     248                 :            : 
     249                 :            : /*
     250                 :            :  * Get the ID of the specified process keyring.
     251                 :            :  *
     252                 :            :  * The requested keyring must have search permission to be found.
     253                 :            :  *
     254                 :            :  * If successful, the ID of the requested keyring will be returned.
     255                 :            :  */
     256                 :          0 : long keyctl_get_keyring_ID(key_serial_t id, int create)
     257                 :            : {
     258                 :            :         key_ref_t key_ref;
     259                 :            :         unsigned long lflags;
     260                 :            :         long ret;
     261                 :            : 
     262                 :          0 :         lflags = create ? KEY_LOOKUP_CREATE : 0;
     263                 :          0 :         key_ref = lookup_user_key(id, lflags, KEY_NEED_SEARCH);
     264         [ #  # ]:          0 :         if (IS_ERR(key_ref)) {
     265                 :            :                 ret = PTR_ERR(key_ref);
     266                 :          0 :                 goto error;
     267                 :            :         }
     268                 :            : 
     269                 :          0 :         ret = key_ref_to_ptr(key_ref)->serial;
     270                 :            :         key_ref_put(key_ref);
     271                 :            : error:
     272                 :          0 :         return ret;
     273                 :            : }
     274                 :            : 
     275                 :            : /*
     276                 :            :  * Join a (named) session keyring.
     277                 :            :  *
     278                 :            :  * Create and join an anonymous session keyring or join a named session
     279                 :            :  * keyring, creating it if necessary.  A named session keyring must have Search
     280                 :            :  * permission for it to be joined.  Session keyrings without this permit will
     281                 :            :  * be skipped over.  It is not permitted for userspace to create or join
     282                 :            :  * keyrings whose name begin with a dot.
     283                 :            :  *
     284                 :            :  * If successful, the ID of the joined session keyring will be returned.
     285                 :            :  */
     286                 :      12845 : long keyctl_join_session_keyring(const char __user *_name)
     287                 :            : {
     288                 :            :         char *name;
     289                 :            :         long ret;
     290                 :            : 
     291                 :            :         /* fetch the name from userspace */
     292                 :            :         name = NULL;
     293         [ -  + ]:      12845 :         if (_name) {
     294                 :          0 :                 name = strndup_user(_name, KEY_MAX_DESC_SIZE);
     295         [ #  # ]:          0 :                 if (IS_ERR(name)) {
     296                 :            :                         ret = PTR_ERR(name);
     297                 :          0 :                         goto error;
     298                 :            :                 }
     299                 :            : 
     300                 :            :                 ret = -EPERM;
     301         [ #  # ]:          0 :                 if (name[0] == '.')
     302                 :            :                         goto error_name;
     303                 :            :         }
     304                 :            : 
     305                 :            :         /* join the session */
     306                 :      12845 :         ret = join_session_keyring(name);
     307                 :            : error_name:
     308                 :      12845 :         kfree(name);
     309                 :            : error:
     310                 :      12845 :         return ret;
     311                 :            : }
     312                 :            : 
     313                 :            : /*
     314                 :            :  * Update a key's data payload from the given data.
     315                 :            :  *
     316                 :            :  * The key must grant the caller Write permission and the key type must support
     317                 :            :  * updating for this to work.  A negative key can be positively instantiated
     318                 :            :  * with this call.
     319                 :            :  *
     320                 :            :  * If successful, 0 will be returned.  If the key type does not support
     321                 :            :  * updating, then -EOPNOTSUPP will be returned.
     322                 :            :  */
     323                 :          0 : long keyctl_update_key(key_serial_t id,
     324                 :            :                        const void __user *_payload,
     325                 :            :                        size_t plen)
     326                 :            : {
     327                 :            :         key_ref_t key_ref;
     328                 :            :         void *payload;
     329                 :            :         long ret;
     330                 :            : 
     331                 :            :         ret = -EINVAL;
     332         [ #  # ]:          0 :         if (plen > PAGE_SIZE)
     333                 :            :                 goto error;
     334                 :            : 
     335                 :            :         /* pull the payload in if one was supplied */
     336                 :            :         payload = NULL;
     337         [ #  # ]:          0 :         if (plen) {
     338                 :            :                 ret = -ENOMEM;
     339                 :            :                 payload = kvmalloc(plen, GFP_KERNEL);
     340         [ #  # ]:          0 :                 if (!payload)
     341                 :            :                         goto error;
     342                 :            : 
     343                 :            :                 ret = -EFAULT;
     344         [ #  # ]:          0 :                 if (copy_from_user(payload, _payload, plen) != 0)
     345                 :            :                         goto error2;
     346                 :            :         }
     347                 :            : 
     348                 :            :         /* find the target key (which must be writable) */
     349                 :          0 :         key_ref = lookup_user_key(id, 0, KEY_NEED_WRITE);
     350         [ #  # ]:          0 :         if (IS_ERR(key_ref)) {
     351                 :            :                 ret = PTR_ERR(key_ref);
     352                 :          0 :                 goto error2;
     353                 :            :         }
     354                 :            : 
     355                 :            :         /* update the key */
     356                 :          0 :         ret = key_update(key_ref, payload, plen);
     357                 :            : 
     358                 :            :         key_ref_put(key_ref);
     359                 :            : error2:
     360                 :          0 :         kvfree_sensitive(payload, plen);
     361                 :            : error:
     362                 :          0 :         return ret;
     363                 :            : }
     364                 :            : 
     365                 :            : /*
     366                 :            :  * Revoke a key.
     367                 :            :  *
     368                 :            :  * The key must be grant the caller Write or Setattr permission for this to
     369                 :            :  * work.  The key type should give up its quota claim when revoked.  The key
     370                 :            :  * and any links to the key will be automatically garbage collected after a
     371                 :            :  * certain amount of time (/proc/sys/kernel/keys/gc_delay).
     372                 :            :  *
     373                 :            :  * Keys with KEY_FLAG_KEEP set should not be revoked.
     374                 :            :  *
     375                 :            :  * If successful, 0 is returned.
     376                 :            :  */
     377                 :          0 : long keyctl_revoke_key(key_serial_t id)
     378                 :            : {
     379                 :            :         key_ref_t key_ref;
     380                 :            :         struct key *key;
     381                 :            :         long ret;
     382                 :            : 
     383                 :          0 :         key_ref = lookup_user_key(id, 0, KEY_NEED_WRITE);
     384         [ #  # ]:          0 :         if (IS_ERR(key_ref)) {
     385                 :            :                 ret = PTR_ERR(key_ref);
     386         [ #  # ]:          0 :                 if (ret != -EACCES)
     387                 :            :                         goto error;
     388                 :          0 :                 key_ref = lookup_user_key(id, 0, KEY_NEED_SETATTR);
     389         [ #  # ]:          0 :                 if (IS_ERR(key_ref)) {
     390                 :            :                         ret = PTR_ERR(key_ref);
     391                 :          0 :                         goto error;
     392                 :            :                 }
     393                 :            :         }
     394                 :            : 
     395                 :            :         key = key_ref_to_ptr(key_ref);
     396                 :            :         ret = 0;
     397         [ #  # ]:          0 :         if (test_bit(KEY_FLAG_KEEP, &key->flags))
     398                 :            :                 ret = -EPERM;
     399                 :            :         else
     400                 :          0 :                 key_revoke(key);
     401                 :            : 
     402                 :            :         key_ref_put(key_ref);
     403                 :            : error:
     404                 :          0 :         return ret;
     405                 :            : }
     406                 :            : 
     407                 :            : /*
     408                 :            :  * Invalidate a key.
     409                 :            :  *
     410                 :            :  * The key must be grant the caller Invalidate permission for this to work.
     411                 :            :  * The key and any links to the key will be automatically garbage collected
     412                 :            :  * immediately.
     413                 :            :  *
     414                 :            :  * Keys with KEY_FLAG_KEEP set should not be invalidated.
     415                 :            :  *
     416                 :            :  * If successful, 0 is returned.
     417                 :            :  */
     418                 :          0 : long keyctl_invalidate_key(key_serial_t id)
     419                 :            : {
     420                 :            :         key_ref_t key_ref;
     421                 :            :         struct key *key;
     422                 :            :         long ret;
     423                 :            : 
     424                 :            :         kenter("%d", id);
     425                 :            : 
     426                 :          0 :         key_ref = lookup_user_key(id, 0, KEY_NEED_SEARCH);
     427         [ #  # ]:          0 :         if (IS_ERR(key_ref)) {
     428                 :            :                 ret = PTR_ERR(key_ref);
     429                 :            : 
     430                 :            :                 /* Root is permitted to invalidate certain special keys */
     431         [ #  # ]:          0 :                 if (capable(CAP_SYS_ADMIN)) {
     432                 :          0 :                         key_ref = lookup_user_key(id, 0, 0);
     433         [ #  # ]:          0 :                         if (IS_ERR(key_ref))
     434                 :            :                                 goto error;
     435         [ #  # ]:          0 :                         if (test_bit(KEY_FLAG_ROOT_CAN_INVAL,
     436                 :            :                                      &key_ref_to_ptr(key_ref)->flags))
     437                 :            :                                 goto invalidate;
     438                 :            :                         goto error_put;
     439                 :            :                 }
     440                 :            : 
     441                 :            :                 goto error;
     442                 :            :         }
     443                 :            : 
     444                 :            : invalidate:
     445                 :            :         key = key_ref_to_ptr(key_ref);
     446                 :            :         ret = 0;
     447         [ #  # ]:          0 :         if (test_bit(KEY_FLAG_KEEP, &key->flags))
     448                 :            :                 ret = -EPERM;
     449                 :            :         else
     450                 :          0 :                 key_invalidate(key);
     451                 :            : error_put:
     452                 :            :         key_ref_put(key_ref);
     453                 :            : error:
     454                 :            :         kleave(" = %ld", ret);
     455                 :          0 :         return ret;
     456                 :            : }
     457                 :            : 
     458                 :            : /*
     459                 :            :  * Clear the specified keyring, creating an empty process keyring if one of the
     460                 :            :  * special keyring IDs is used.
     461                 :            :  *
     462                 :            :  * The keyring must grant the caller Write permission and not have
     463                 :            :  * KEY_FLAG_KEEP set for this to work.  If successful, 0 will be returned.
     464                 :            :  */
     465                 :          0 : long keyctl_keyring_clear(key_serial_t ringid)
     466                 :            : {
     467                 :            :         key_ref_t keyring_ref;
     468                 :            :         struct key *keyring;
     469                 :            :         long ret;
     470                 :            : 
     471                 :          0 :         keyring_ref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_NEED_WRITE);
     472         [ #  # ]:          0 :         if (IS_ERR(keyring_ref)) {
     473                 :            :                 ret = PTR_ERR(keyring_ref);
     474                 :            : 
     475                 :            :                 /* Root is permitted to invalidate certain special keyrings */
     476         [ #  # ]:          0 :                 if (capable(CAP_SYS_ADMIN)) {
     477                 :          0 :                         keyring_ref = lookup_user_key(ringid, 0, 0);
     478         [ #  # ]:          0 :                         if (IS_ERR(keyring_ref))
     479                 :            :                                 goto error;
     480         [ #  # ]:          0 :                         if (test_bit(KEY_FLAG_ROOT_CAN_CLEAR,
     481                 :            :                                      &key_ref_to_ptr(keyring_ref)->flags))
     482                 :            :                                 goto clear;
     483                 :            :                         goto error_put;
     484                 :            :                 }
     485                 :            : 
     486                 :            :                 goto error;
     487                 :            :         }
     488                 :            : 
     489                 :            : clear:
     490                 :            :         keyring = key_ref_to_ptr(keyring_ref);
     491         [ #  # ]:          0 :         if (test_bit(KEY_FLAG_KEEP, &keyring->flags))
     492                 :            :                 ret = -EPERM;
     493                 :            :         else
     494                 :          0 :                 ret = keyring_clear(keyring);
     495                 :            : error_put:
     496                 :            :         key_ref_put(keyring_ref);
     497                 :            : error:
     498                 :          0 :         return ret;
     499                 :            : }
     500                 :            : 
     501                 :            : /*
     502                 :            :  * Create a link from a keyring to a key if there's no matching key in the
     503                 :            :  * keyring, otherwise replace the link to the matching key with a link to the
     504                 :            :  * new key.
     505                 :            :  *
     506                 :            :  * The key must grant the caller Link permission and the the keyring must grant
     507                 :            :  * the caller Write permission.  Furthermore, if an additional link is created,
     508                 :            :  * the keyring's quota will be extended.
     509                 :            :  *
     510                 :            :  * If successful, 0 will be returned.
     511                 :            :  */
     512                 :       1448 : long keyctl_keyring_link(key_serial_t id, key_serial_t ringid)
     513                 :            : {
     514                 :            :         key_ref_t keyring_ref, key_ref;
     515                 :            :         long ret;
     516                 :            : 
     517                 :       1448 :         keyring_ref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_NEED_WRITE);
     518         [ -  + ]:       1448 :         if (IS_ERR(keyring_ref)) {
     519                 :            :                 ret = PTR_ERR(keyring_ref);
     520                 :          0 :                 goto error;
     521                 :            :         }
     522                 :            : 
     523                 :       1448 :         key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE, KEY_NEED_LINK);
     524         [ -  + ]:       1448 :         if (IS_ERR(key_ref)) {
     525                 :            :                 ret = PTR_ERR(key_ref);
     526                 :          0 :                 goto error2;
     527                 :            :         }
     528                 :            : 
     529                 :       1448 :         ret = key_link(key_ref_to_ptr(keyring_ref), key_ref_to_ptr(key_ref));
     530                 :            : 
     531                 :            :         key_ref_put(key_ref);
     532                 :            : error2:
     533                 :            :         key_ref_put(keyring_ref);
     534                 :            : error:
     535                 :       1448 :         return ret;
     536                 :            : }
     537                 :            : 
     538                 :            : /*
     539                 :            :  * Unlink a key from a keyring.
     540                 :            :  *
     541                 :            :  * The keyring must grant the caller Write permission for this to work; the key
     542                 :            :  * itself need not grant the caller anything.  If the last link to a key is
     543                 :            :  * removed then that key will be scheduled for destruction.
     544                 :            :  *
     545                 :            :  * Keys or keyrings with KEY_FLAG_KEEP set should not be unlinked.
     546                 :            :  *
     547                 :            :  * If successful, 0 will be returned.
     548                 :            :  */
     549                 :          0 : long keyctl_keyring_unlink(key_serial_t id, key_serial_t ringid)
     550                 :            : {
     551                 :            :         key_ref_t keyring_ref, key_ref;
     552                 :            :         struct key *keyring, *key;
     553                 :            :         long ret;
     554                 :            : 
     555                 :          0 :         keyring_ref = lookup_user_key(ringid, 0, KEY_NEED_WRITE);
     556         [ #  # ]:          0 :         if (IS_ERR(keyring_ref)) {
     557                 :            :                 ret = PTR_ERR(keyring_ref);
     558                 :          0 :                 goto error;
     559                 :            :         }
     560                 :            : 
     561                 :          0 :         key_ref = lookup_user_key(id, KEY_LOOKUP_FOR_UNLINK, 0);
     562         [ #  # ]:          0 :         if (IS_ERR(key_ref)) {
     563                 :            :                 ret = PTR_ERR(key_ref);
     564                 :          0 :                 goto error2;
     565                 :            :         }
     566                 :            : 
     567                 :            :         keyring = key_ref_to_ptr(keyring_ref);
     568                 :            :         key = key_ref_to_ptr(key_ref);
     569   [ #  #  #  # ]:          0 :         if (test_bit(KEY_FLAG_KEEP, &keyring->flags) &&
     570                 :            :             test_bit(KEY_FLAG_KEEP, &key->flags))
     571                 :            :                 ret = -EPERM;
     572                 :            :         else
     573                 :          0 :                 ret = key_unlink(keyring, key);
     574                 :            : 
     575                 :            :         key_ref_put(key_ref);
     576                 :            : error2:
     577                 :            :         key_ref_put(keyring_ref);
     578                 :            : error:
     579                 :          0 :         return ret;
     580                 :            : }
     581                 :            : 
     582                 :            : /*
     583                 :            :  * Move a link to a key from one keyring to another, displacing any matching
     584                 :            :  * key from the destination keyring.
     585                 :            :  *
     586                 :            :  * The key must grant the caller Link permission and both keyrings must grant
     587                 :            :  * the caller Write permission.  There must also be a link in the from keyring
     588                 :            :  * to the key.  If both keyrings are the same, nothing is done.
     589                 :            :  *
     590                 :            :  * If successful, 0 will be returned.
     591                 :            :  */
     592                 :          0 : long keyctl_keyring_move(key_serial_t id, key_serial_t from_ringid,
     593                 :            :                          key_serial_t to_ringid, unsigned int flags)
     594                 :            : {
     595                 :            :         key_ref_t key_ref, from_ref, to_ref;
     596                 :            :         long ret;
     597                 :            : 
     598         [ #  # ]:          0 :         if (flags & ~KEYCTL_MOVE_EXCL)
     599                 :            :                 return -EINVAL;
     600                 :            : 
     601                 :          0 :         key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE, KEY_NEED_LINK);
     602         [ #  # ]:          0 :         if (IS_ERR(key_ref))
     603                 :          0 :                 return PTR_ERR(key_ref);
     604                 :            : 
     605                 :          0 :         from_ref = lookup_user_key(from_ringid, 0, KEY_NEED_WRITE);
     606         [ #  # ]:          0 :         if (IS_ERR(from_ref)) {
     607                 :            :                 ret = PTR_ERR(from_ref);
     608                 :          0 :                 goto error2;
     609                 :            :         }
     610                 :            : 
     611                 :          0 :         to_ref = lookup_user_key(to_ringid, KEY_LOOKUP_CREATE, KEY_NEED_WRITE);
     612         [ #  # ]:          0 :         if (IS_ERR(to_ref)) {
     613                 :            :                 ret = PTR_ERR(to_ref);
     614                 :          0 :                 goto error3;
     615                 :            :         }
     616                 :            : 
     617                 :          0 :         ret = key_move(key_ref_to_ptr(key_ref), key_ref_to_ptr(from_ref),
     618                 :            :                        key_ref_to_ptr(to_ref), flags);
     619                 :            : 
     620                 :            :         key_ref_put(to_ref);
     621                 :            : error3:
     622                 :            :         key_ref_put(from_ref);
     623                 :            : error2:
     624                 :            :         key_ref_put(key_ref);
     625                 :          0 :         return ret;
     626                 :            : }
     627                 :            : 
     628                 :            : /*
     629                 :            :  * Return a description of a key to userspace.
     630                 :            :  *
     631                 :            :  * The key must grant the caller View permission for this to work.
     632                 :            :  *
     633                 :            :  * If there's a buffer, we place up to buflen bytes of data into it formatted
     634                 :            :  * in the following way:
     635                 :            :  *
     636                 :            :  *      type;uid;gid;perm;description<NUL>
     637                 :            :  *
     638                 :            :  * If successful, we return the amount of description available, irrespective
     639                 :            :  * of how much we may have copied into the buffer.
     640                 :            :  */
     641                 :          0 : long keyctl_describe_key(key_serial_t keyid,
     642                 :            :                          char __user *buffer,
     643                 :            :                          size_t buflen)
     644                 :            : {
     645                 :            :         struct key *key, *instkey;
     646                 :            :         key_ref_t key_ref;
     647                 :            :         char *infobuf;
     648                 :            :         long ret;
     649                 :            :         int desclen, infolen;
     650                 :            : 
     651                 :          0 :         key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, KEY_NEED_VIEW);
     652         [ #  # ]:          0 :         if (IS_ERR(key_ref)) {
     653                 :            :                 /* viewing a key under construction is permitted if we have the
     654                 :            :                  * authorisation token handy */
     655         [ #  # ]:          0 :                 if (PTR_ERR(key_ref) == -EACCES) {
     656                 :          0 :                         instkey = key_get_instantiation_authkey(keyid);
     657         [ #  # ]:          0 :                         if (!IS_ERR(instkey)) {
     658                 :          0 :                                 key_put(instkey);
     659                 :          0 :                                 key_ref = lookup_user_key(keyid,
     660                 :            :                                                           KEY_LOOKUP_PARTIAL,
     661                 :            :                                                           0);
     662         [ #  # ]:          0 :                                 if (!IS_ERR(key_ref))
     663                 :            :                                         goto okay;
     664                 :            :                         }
     665                 :            :                 }
     666                 :            : 
     667                 :            :                 ret = PTR_ERR(key_ref);
     668                 :          0 :                 goto error;
     669                 :            :         }
     670                 :            : 
     671                 :            : okay:
     672                 :            :         key = key_ref_to_ptr(key_ref);
     673                 :          0 :         desclen = strlen(key->description);
     674                 :            : 
     675                 :            :         /* calculate how much information we're going to return */
     676                 :            :         ret = -ENOMEM;
     677                 :          0 :         infobuf = kasprintf(GFP_KERNEL,
     678                 :            :                             "%s;%d;%d;%08x;",
     679                 :          0 :                             key->type->name,
     680                 :          0 :                             from_kuid_munged(current_user_ns(), key->uid),
     681                 :          0 :                             from_kgid_munged(current_user_ns(), key->gid),
     682                 :            :                             key->perm);
     683         [ #  # ]:          0 :         if (!infobuf)
     684                 :            :                 goto error2;
     685                 :          0 :         infolen = strlen(infobuf);
     686                 :          0 :         ret = infolen + desclen + 1;
     687                 :            : 
     688                 :            :         /* consider returning the data */
     689         [ #  # ]:          0 :         if (buffer && buflen >= ret) {
     690   [ #  #  #  # ]:          0 :                 if (copy_to_user(buffer, infobuf, infolen) != 0 ||
     691                 :          0 :                     copy_to_user(buffer + infolen, key->description,
     692                 :          0 :                                  desclen + 1) != 0)
     693                 :            :                         ret = -EFAULT;
     694                 :            :         }
     695                 :            : 
     696                 :          0 :         kfree(infobuf);
     697                 :            : error2:
     698                 :            :         key_ref_put(key_ref);
     699                 :            : error:
     700                 :          0 :         return ret;
     701                 :            : }
     702                 :            : 
     703                 :            : /*
     704                 :            :  * Search the specified keyring and any keyrings it links to for a matching
     705                 :            :  * key.  Only keyrings that grant the caller Search permission will be searched
     706                 :            :  * (this includes the starting keyring).  Only keys with Search permission can
     707                 :            :  * be found.
     708                 :            :  *
     709                 :            :  * If successful, the found key will be linked to the destination keyring if
     710                 :            :  * supplied and the key has Link permission, and the found key ID will be
     711                 :            :  * returned.
     712                 :            :  */
     713                 :          0 : long keyctl_keyring_search(key_serial_t ringid,
     714                 :            :                            const char __user *_type,
     715                 :            :                            const char __user *_description,
     716                 :            :                            key_serial_t destringid)
     717                 :            : {
     718                 :            :         struct key_type *ktype;
     719                 :            :         key_ref_t keyring_ref, key_ref, dest_ref;
     720                 :            :         char type[32], *description;
     721                 :            :         long ret;
     722                 :            : 
     723                 :            :         /* pull the type and description into kernel space */
     724                 :          0 :         ret = key_get_type_from_user(type, _type, sizeof(type));
     725         [ #  # ]:          0 :         if (ret < 0)
     726                 :            :                 goto error;
     727                 :            : 
     728                 :          0 :         description = strndup_user(_description, KEY_MAX_DESC_SIZE);
     729         [ #  # ]:          0 :         if (IS_ERR(description)) {
     730                 :            :                 ret = PTR_ERR(description);
     731                 :          0 :                 goto error;
     732                 :            :         }
     733                 :            : 
     734                 :            :         /* get the keyring at which to begin the search */
     735                 :          0 :         keyring_ref = lookup_user_key(ringid, 0, KEY_NEED_SEARCH);
     736         [ #  # ]:          0 :         if (IS_ERR(keyring_ref)) {
     737                 :            :                 ret = PTR_ERR(keyring_ref);
     738                 :          0 :                 goto error2;
     739                 :            :         }
     740                 :            : 
     741                 :            :         /* get the destination keyring if specified */
     742                 :            :         dest_ref = NULL;
     743         [ #  # ]:          0 :         if (destringid) {
     744                 :          0 :                 dest_ref = lookup_user_key(destringid, KEY_LOOKUP_CREATE,
     745                 :            :                                            KEY_NEED_WRITE);
     746         [ #  # ]:          0 :                 if (IS_ERR(dest_ref)) {
     747                 :            :                         ret = PTR_ERR(dest_ref);
     748                 :          0 :                         goto error3;
     749                 :            :                 }
     750                 :            :         }
     751                 :            : 
     752                 :            :         /* find the key type */
     753                 :          0 :         ktype = key_type_lookup(type);
     754         [ #  # ]:          0 :         if (IS_ERR(ktype)) {
     755                 :            :                 ret = PTR_ERR(ktype);
     756                 :          0 :                 goto error4;
     757                 :            :         }
     758                 :            : 
     759                 :            :         /* do the search */
     760                 :          0 :         key_ref = keyring_search(keyring_ref, ktype, description, true);
     761         [ #  # ]:          0 :         if (IS_ERR(key_ref)) {
     762                 :            :                 ret = PTR_ERR(key_ref);
     763                 :            : 
     764                 :            :                 /* treat lack or presence of a negative key the same */
     765         [ #  # ]:          0 :                 if (ret == -EAGAIN)
     766                 :            :                         ret = -ENOKEY;
     767                 :            :                 goto error5;
     768                 :            :         }
     769                 :            : 
     770                 :            :         /* link the resulting key to the destination keyring if we can */
     771         [ #  # ]:          0 :         if (dest_ref) {
     772                 :            :                 ret = key_permission(key_ref, KEY_NEED_LINK);
     773         [ #  # ]:          0 :                 if (ret < 0)
     774                 :            :                         goto error6;
     775                 :            : 
     776                 :          0 :                 ret = key_link(key_ref_to_ptr(dest_ref), key_ref_to_ptr(key_ref));
     777         [ #  # ]:          0 :                 if (ret < 0)
     778                 :            :                         goto error6;
     779                 :            :         }
     780                 :            : 
     781                 :          0 :         ret = key_ref_to_ptr(key_ref)->serial;
     782                 :            : 
     783                 :            : error6:
     784                 :            :         key_ref_put(key_ref);
     785                 :            : error5:
     786                 :          0 :         key_type_put(ktype);
     787                 :            : error4:
     788                 :            :         key_ref_put(dest_ref);
     789                 :            : error3:
     790                 :            :         key_ref_put(keyring_ref);
     791                 :            : error2:
     792                 :          0 :         kfree(description);
     793                 :            : error:
     794                 :          0 :         return ret;
     795                 :            : }
     796                 :            : 
     797                 :            : /*
     798                 :            :  * Call the read method
     799                 :            :  */
     800                 :          0 : static long __keyctl_read_key(struct key *key, char *buffer, size_t buflen)
     801                 :            : {
     802                 :            :         long ret;
     803                 :            : 
     804                 :          0 :         down_read(&key->sem);
     805                 :          0 :         ret = key_validate(key);
     806         [ #  # ]:          0 :         if (ret == 0)
     807                 :          0 :                 ret = key->type->read(key, buffer, buflen);
     808                 :          0 :         up_read(&key->sem);
     809                 :          0 :         return ret;
     810                 :            : }
     811                 :            : 
     812                 :            : /*
     813                 :            :  * Read a key's payload.
     814                 :            :  *
     815                 :            :  * The key must either grant the caller Read permission, or it must grant the
     816                 :            :  * caller Search permission when searched for from the process keyrings.
     817                 :            :  *
     818                 :            :  * If successful, we place up to buflen bytes of data into the buffer, if one
     819                 :            :  * is provided, and return the amount of data that is available in the key,
     820                 :            :  * irrespective of how much we copied into the buffer.
     821                 :            :  */
     822                 :          0 : long keyctl_read_key(key_serial_t keyid, char __user *buffer, size_t buflen)
     823                 :            : {
     824                 :            :         struct key *key;
     825                 :            :         key_ref_t key_ref;
     826                 :            :         long ret;
     827                 :            :         char *key_data = NULL;
     828                 :            :         size_t key_data_len;
     829                 :            : 
     830                 :            :         /* find the key first */
     831                 :          0 :         key_ref = lookup_user_key(keyid, 0, 0);
     832         [ #  # ]:          0 :         if (IS_ERR(key_ref)) {
     833                 :            :                 ret = -ENOKEY;
     834                 :            :                 goto out;
     835                 :            :         }
     836                 :            : 
     837                 :            :         key = key_ref_to_ptr(key_ref);
     838                 :            : 
     839                 :          0 :         ret = key_read_state(key);
     840         [ #  # ]:          0 :         if (ret < 0)
     841                 :            :                 goto key_put_out; /* Negatively instantiated */
     842                 :            : 
     843                 :            :         /* see if we can read it directly */
     844                 :            :         ret = key_permission(key_ref, KEY_NEED_READ);
     845         [ #  # ]:          0 :         if (ret == 0)
     846                 :            :                 goto can_read_key;
     847         [ #  # ]:          0 :         if (ret != -EACCES)
     848                 :            :                 goto key_put_out;
     849                 :            : 
     850                 :            :         /* we can't; see if it's searchable from this process's keyrings
     851                 :            :          * - we automatically take account of the fact that it may be
     852                 :            :          *   dangling off an instantiation key
     853                 :            :          */
     854         [ #  # ]:          0 :         if (!is_key_possessed(key_ref)) {
     855                 :            :                 ret = -EACCES;
     856                 :            :                 goto key_put_out;
     857                 :            :         }
     858                 :            : 
     859                 :            :         /* the key is probably readable - now try to read it */
     860                 :            : can_read_key:
     861         [ #  # ]:          0 :         if (!key->type->read) {
     862                 :            :                 ret = -EOPNOTSUPP;
     863                 :            :                 goto key_put_out;
     864                 :            :         }
     865                 :            : 
     866         [ #  # ]:          0 :         if (!buffer || !buflen) {
     867                 :            :                 /* Get the key length from the read method */
     868                 :          0 :                 ret = __keyctl_read_key(key, NULL, 0);
     869                 :          0 :                 goto key_put_out;
     870                 :            :         }
     871                 :            : 
     872                 :            :         /*
     873                 :            :          * Read the data with the semaphore held (since we might sleep)
     874                 :            :          * to protect against the key being updated or revoked.
     875                 :            :          *
     876                 :            :          * Allocating a temporary buffer to hold the keys before
     877                 :            :          * transferring them to user buffer to avoid potential
     878                 :            :          * deadlock involving page fault and mmap_sem.
     879                 :            :          *
     880                 :            :          * key_data_len = (buflen <= PAGE_SIZE)
     881                 :            :          *              ? buflen : actual length of key data
     882                 :            :          *
     883                 :            :          * This prevents allocating arbitrary large buffer which can
     884                 :            :          * be much larger than the actual key length. In the latter case,
     885                 :            :          * at least 2 passes of this loop is required.
     886                 :            :          */
     887         [ #  # ]:          0 :         key_data_len = (buflen <= PAGE_SIZE) ? buflen : 0;
     888                 :            :         for (;;) {
     889         [ #  # ]:          0 :                 if (key_data_len) {
     890                 :            :                         key_data = kvmalloc(key_data_len, GFP_KERNEL);
     891         [ #  # ]:          0 :                         if (!key_data) {
     892                 :            :                                 ret = -ENOMEM;
     893                 :            :                                 goto key_put_out;
     894                 :            :                         }
     895                 :            :                 }
     896                 :            : 
     897                 :          0 :                 ret = __keyctl_read_key(key, key_data, key_data_len);
     898                 :            : 
     899                 :            :                 /*
     900                 :            :                  * Read methods will just return the required length without
     901                 :            :                  * any copying if the provided length isn't large enough.
     902                 :            :                  */
     903         [ #  # ]:          0 :                 if (ret <= 0 || ret > buflen)
     904                 :            :                         break;
     905                 :            : 
     906                 :            :                 /*
     907                 :            :                  * The key may change (unlikely) in between 2 consecutive
     908                 :            :                  * __keyctl_read_key() calls. In this case, we reallocate
     909                 :            :                  * a larger buffer and redo the key read when
     910                 :            :                  * key_data_len < ret <= buflen.
     911                 :            :                  */
     912         [ #  # ]:          0 :                 if (ret > key_data_len) {
     913         [ #  # ]:          0 :                         if (unlikely(key_data))
     914                 :          0 :                                 kvfree_sensitive(key_data, key_data_len);
     915                 :            :                         key_data_len = ret;
     916                 :          0 :                         continue;       /* Allocate buffer */
     917                 :            :                 }
     918                 :            : 
     919         [ #  # ]:          0 :                 if (copy_to_user(buffer, key_data, ret))
     920                 :            :                         ret = -EFAULT;
     921                 :            :                 break;
     922                 :          0 :         }
     923                 :          0 :         kvfree_sensitive(key_data, key_data_len);
     924                 :            : 
     925                 :            : key_put_out:
     926                 :          0 :         key_put(key);
     927                 :            : out:
     928                 :          0 :         return ret;
     929                 :            : }
     930                 :            : 
     931                 :            : /*
     932                 :            :  * Change the ownership of a key
     933                 :            :  *
     934                 :            :  * The key must grant the caller Setattr permission for this to work, though
     935                 :            :  * the key need not be fully instantiated yet.  For the UID to be changed, or
     936                 :            :  * for the GID to be changed to a group the caller is not a member of, the
     937                 :            :  * caller must have sysadmin capability.  If either uid or gid is -1 then that
     938                 :            :  * attribute is not changed.
     939                 :            :  *
     940                 :            :  * If the UID is to be changed, the new user must have sufficient quota to
     941                 :            :  * accept the key.  The quota deduction will be removed from the old user to
     942                 :            :  * the new user should the attribute be changed.
     943                 :            :  *
     944                 :            :  * If successful, 0 will be returned.
     945                 :            :  */
     946                 :          0 : long keyctl_chown_key(key_serial_t id, uid_t user, gid_t group)
     947                 :            : {
     948                 :            :         struct key_user *newowner, *zapowner = NULL;
     949                 :            :         struct key *key;
     950                 :            :         key_ref_t key_ref;
     951                 :            :         long ret;
     952                 :            :         kuid_t uid;
     953                 :            :         kgid_t gid;
     954                 :            : 
     955                 :          0 :         uid = make_kuid(current_user_ns(), user);
     956                 :          0 :         gid = make_kgid(current_user_ns(), group);
     957                 :            :         ret = -EINVAL;
     958   [ #  #  #  # ]:          0 :         if ((user != (uid_t) -1) && !uid_valid(uid))
     959                 :            :                 goto error;
     960   [ #  #  #  # ]:          0 :         if ((group != (gid_t) -1) && !gid_valid(gid))
     961                 :            :                 goto error;
     962                 :            : 
     963                 :            :         ret = 0;
     964         [ #  # ]:          0 :         if (user == (uid_t) -1 && group == (gid_t) -1)
     965                 :            :                 goto error;
     966                 :            : 
     967                 :          0 :         key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE | KEY_LOOKUP_PARTIAL,
     968                 :            :                                   KEY_NEED_SETATTR);
     969         [ #  # ]:          0 :         if (IS_ERR(key_ref)) {
     970                 :            :                 ret = PTR_ERR(key_ref);
     971                 :          0 :                 goto error;
     972                 :            :         }
     973                 :            : 
     974                 :            :         key = key_ref_to_ptr(key_ref);
     975                 :            : 
     976                 :            :         /* make the changes with the locks held to prevent chown/chown races */
     977                 :            :         ret = -EACCES;
     978                 :          0 :         down_write(&key->sem);
     979                 :            : 
     980         [ #  # ]:          0 :         if (!capable(CAP_SYS_ADMIN)) {
     981                 :            :                 /* only the sysadmin can chown a key to some other UID */
     982   [ #  #  #  # ]:          0 :                 if (user != (uid_t) -1 && !uid_eq(key->uid, uid))
     983                 :            :                         goto error_put;
     984                 :            : 
     985                 :            :                 /* only the sysadmin can set the key's GID to a group other
     986                 :            :                  * than one of those that the current process subscribes to */
     987   [ #  #  #  #  :          0 :                 if (group != (gid_t) -1 && !gid_eq(gid, key->gid) && !in_group_p(gid))
                   #  # ]
     988                 :            :                         goto error_put;
     989                 :            :         }
     990                 :            : 
     991                 :            :         /* change the UID */
     992   [ #  #  #  # ]:          0 :         if (user != (uid_t) -1 && !uid_eq(uid, key->uid)) {
     993                 :            :                 ret = -ENOMEM;
     994                 :          0 :                 newowner = key_user_lookup(uid);
     995         [ #  # ]:          0 :                 if (!newowner)
     996                 :            :                         goto error_put;
     997                 :            : 
     998                 :            :                 /* transfer the quota burden to the new user */
     999         [ #  # ]:          0 :                 if (test_bit(KEY_FLAG_IN_QUOTA, &key->flags)) {
    1000                 :            :                         unsigned maxkeys = uid_eq(uid, GLOBAL_ROOT_UID) ?
    1001         [ #  # ]:          0 :                                 key_quota_root_maxkeys : key_quota_maxkeys;
    1002                 :            :                         unsigned maxbytes = uid_eq(uid, GLOBAL_ROOT_UID) ?
    1003         [ #  # ]:          0 :                                 key_quota_root_maxbytes : key_quota_maxbytes;
    1004                 :            : 
    1005                 :            :                         spin_lock(&newowner->lock);
    1006   [ #  #  #  # ]:          0 :                         if (newowner->qnkeys + 1 > maxkeys ||
    1007         [ #  # ]:          0 :                             newowner->qnbytes + key->quotalen > maxbytes ||
    1008                 :            :                             newowner->qnbytes + key->quotalen <
    1009                 :            :                             newowner->qnbytes)
    1010                 :            :                                 goto quota_overrun;
    1011                 :            : 
    1012                 :          0 :                         newowner->qnkeys++;
    1013                 :          0 :                         newowner->qnbytes += key->quotalen;
    1014                 :            :                         spin_unlock(&newowner->lock);
    1015                 :            : 
    1016                 :          0 :                         spin_lock(&key->user->lock);
    1017                 :          0 :                         key->user->qnkeys--;
    1018                 :          0 :                         key->user->qnbytes -= key->quotalen;
    1019                 :          0 :                         spin_unlock(&key->user->lock);
    1020                 :            :                 }
    1021                 :            : 
    1022                 :          0 :                 atomic_dec(&key->user->nkeys);
    1023                 :          0 :                 atomic_inc(&newowner->nkeys);
    1024                 :            : 
    1025         [ #  # ]:          0 :                 if (key->state != KEY_IS_UNINSTANTIATED) {
    1026                 :          0 :                         atomic_dec(&key->user->nikeys);
    1027                 :          0 :                         atomic_inc(&newowner->nikeys);
    1028                 :            :                 }
    1029                 :            : 
    1030                 :          0 :                 zapowner = key->user;
    1031                 :          0 :                 key->user = newowner;
    1032                 :          0 :                 key->uid = uid;
    1033                 :            :         }
    1034                 :            : 
    1035                 :            :         /* change the GID */
    1036         [ #  # ]:          0 :         if (group != (gid_t) -1)
    1037                 :          0 :                 key->gid = gid;
    1038                 :            : 
    1039                 :            :         ret = 0;
    1040                 :            : 
    1041                 :            : error_put:
    1042                 :          0 :         up_write(&key->sem);
    1043                 :          0 :         key_put(key);
    1044         [ #  # ]:          0 :         if (zapowner)
    1045                 :          0 :                 key_user_put(zapowner);
    1046                 :            : error:
    1047                 :          0 :         return ret;
    1048                 :            : 
    1049                 :            : quota_overrun:
    1050                 :            :         spin_unlock(&newowner->lock);
    1051                 :            :         zapowner = newowner;
    1052                 :            :         ret = -EDQUOT;
    1053                 :          0 :         goto error_put;
    1054                 :            : }
    1055                 :            : 
    1056                 :            : /*
    1057                 :            :  * Change the permission mask on a key.
    1058                 :            :  *
    1059                 :            :  * The key must grant the caller Setattr permission for this to work, though
    1060                 :            :  * the key need not be fully instantiated yet.  If the caller does not have
    1061                 :            :  * sysadmin capability, it may only change the permission on keys that it owns.
    1062                 :            :  */
    1063                 :      12638 : long keyctl_setperm_key(key_serial_t id, key_perm_t perm)
    1064                 :            : {
    1065                 :            :         struct key *key;
    1066                 :            :         key_ref_t key_ref;
    1067                 :            :         long ret;
    1068                 :            : 
    1069                 :            :         ret = -EINVAL;
    1070         [ +  - ]:      12638 :         if (perm & ~(KEY_POS_ALL | KEY_USR_ALL | KEY_GRP_ALL | KEY_OTH_ALL))
    1071                 :            :                 goto error;
    1072                 :            : 
    1073                 :      12638 :         key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE | KEY_LOOKUP_PARTIAL,
    1074                 :            :                                   KEY_NEED_SETATTR);
    1075         [ -  + ]:      12628 :         if (IS_ERR(key_ref)) {
    1076                 :            :                 ret = PTR_ERR(key_ref);
    1077                 :          0 :                 goto error;
    1078                 :            :         }
    1079                 :            : 
    1080                 :            :         key = key_ref_to_ptr(key_ref);
    1081                 :            : 
    1082                 :            :         /* make the changes with the locks held to prevent chown/chmod races */
    1083                 :            :         ret = -EACCES;
    1084                 :      12628 :         down_write(&key->sem);
    1085                 :            : 
    1086                 :            :         /* if we're not the sysadmin, we can only change a key that we own */
    1087   [ -  +  #  # ]:      12638 :         if (capable(CAP_SYS_ADMIN) || uid_eq(key->uid, current_fsuid())) {
    1088                 :      12624 :                 key->perm = perm;
    1089                 :            :                 ret = 0;
    1090                 :            :         }
    1091                 :            : 
    1092                 :      12638 :         up_write(&key->sem);
    1093                 :      12638 :         key_put(key);
    1094                 :            : error:
    1095                 :      12638 :         return ret;
    1096                 :            : }
    1097                 :            : 
    1098                 :            : /*
    1099                 :            :  * Get the destination keyring for instantiation and check that the caller has
    1100                 :            :  * Write permission on it.
    1101                 :            :  */
    1102                 :          0 : static long get_instantiation_keyring(key_serial_t ringid,
    1103                 :            :                                       struct request_key_auth *rka,
    1104                 :            :                                       struct key **_dest_keyring)
    1105                 :            : {
    1106                 :            :         key_ref_t dkref;
    1107                 :            : 
    1108                 :          0 :         *_dest_keyring = NULL;
    1109                 :            : 
    1110                 :            :         /* just return a NULL pointer if we weren't asked to make a link */
    1111         [ #  # ]:          0 :         if (ringid == 0)
    1112                 :            :                 return 0;
    1113                 :            : 
    1114                 :            :         /* if a specific keyring is nominated by ID, then use that */
    1115         [ #  # ]:          0 :         if (ringid > 0) {
    1116                 :          0 :                 dkref = lookup_user_key(ringid, KEY_LOOKUP_CREATE, KEY_NEED_WRITE);
    1117         [ #  # ]:          0 :                 if (IS_ERR(dkref))
    1118                 :          0 :                         return PTR_ERR(dkref);
    1119                 :          0 :                 *_dest_keyring = key_ref_to_ptr(dkref);
    1120                 :          0 :                 return 0;
    1121                 :            :         }
    1122                 :            : 
    1123         [ #  # ]:          0 :         if (ringid == KEY_SPEC_REQKEY_AUTH_KEY)
    1124                 :            :                 return -EINVAL;
    1125                 :            : 
    1126                 :            :         /* otherwise specify the destination keyring recorded in the
    1127                 :            :          * authorisation key (any KEY_SPEC_*_KEYRING) */
    1128         [ #  # ]:          0 :         if (ringid >= KEY_SPEC_REQUESTOR_KEYRING) {
    1129                 :          0 :                 *_dest_keyring = key_get(rka->dest_keyring);
    1130                 :          0 :                 return 0;
    1131                 :            :         }
    1132                 :            : 
    1133                 :            :         return -ENOKEY;
    1134                 :            : }
    1135                 :            : 
    1136                 :            : /*
    1137                 :            :  * Change the request_key authorisation key on the current process.
    1138                 :            :  */
    1139                 :          0 : static int keyctl_change_reqkey_auth(struct key *key)
    1140                 :            : {
    1141                 :            :         struct cred *new;
    1142                 :            : 
    1143                 :          0 :         new = prepare_creds();
    1144         [ #  # ]:          0 :         if (!new)
    1145                 :            :                 return -ENOMEM;
    1146                 :            : 
    1147                 :          0 :         key_put(new->request_key_auth);
    1148                 :          0 :         new->request_key_auth = key_get(key);
    1149                 :            : 
    1150                 :          0 :         return commit_creds(new);
    1151                 :            : }
    1152                 :            : 
    1153                 :            : /*
    1154                 :            :  * Instantiate a key with the specified payload and link the key into the
    1155                 :            :  * destination keyring if one is given.
    1156                 :            :  *
    1157                 :            :  * The caller must have the appropriate instantiation permit set for this to
    1158                 :            :  * work (see keyctl_assume_authority).  No other permissions are required.
    1159                 :            :  *
    1160                 :            :  * If successful, 0 will be returned.
    1161                 :            :  */
    1162                 :          0 : long keyctl_instantiate_key_common(key_serial_t id,
    1163                 :            :                                    struct iov_iter *from,
    1164                 :            :                                    key_serial_t ringid)
    1165                 :            : {
    1166                 :          0 :         const struct cred *cred = current_cred();
    1167                 :            :         struct request_key_auth *rka;
    1168                 :            :         struct key *instkey, *dest_keyring;
    1169         [ #  # ]:          0 :         size_t plen = from ? iov_iter_count(from) : 0;
    1170                 :            :         void *payload;
    1171                 :            :         long ret;
    1172                 :            : 
    1173                 :            :         kenter("%d,,%zu,%d", id, plen, ringid);
    1174                 :            : 
    1175         [ #  # ]:          0 :         if (!plen)
    1176                 :            :                 from = NULL;
    1177                 :            : 
    1178                 :            :         ret = -EINVAL;
    1179         [ #  # ]:          0 :         if (plen > 1024 * 1024 - 1)
    1180                 :            :                 goto error;
    1181                 :            : 
    1182                 :            :         /* the appropriate instantiation authorisation key must have been
    1183                 :            :          * assumed before calling this */
    1184                 :            :         ret = -EPERM;
    1185                 :          0 :         instkey = cred->request_key_auth;
    1186         [ #  # ]:          0 :         if (!instkey)
    1187                 :            :                 goto error;
    1188                 :            : 
    1189                 :          0 :         rka = instkey->payload.data[0];
    1190         [ #  # ]:          0 :         if (rka->target_key->serial != id)
    1191                 :            :                 goto error;
    1192                 :            : 
    1193                 :            :         /* pull the payload in if one was supplied */
    1194                 :            :         payload = NULL;
    1195                 :            : 
    1196         [ #  # ]:          0 :         if (from) {
    1197                 :            :                 ret = -ENOMEM;
    1198                 :            :                 payload = kvmalloc(plen, GFP_KERNEL);
    1199         [ #  # ]:          0 :                 if (!payload)
    1200                 :            :                         goto error;
    1201                 :            : 
    1202                 :            :                 ret = -EFAULT;
    1203         [ #  # ]:          0 :                 if (!copy_from_iter_full(payload, plen, from))
    1204                 :            :                         goto error2;
    1205                 :            :         }
    1206                 :            : 
    1207                 :            :         /* find the destination keyring amongst those belonging to the
    1208                 :            :          * requesting task */
    1209                 :          0 :         ret = get_instantiation_keyring(ringid, rka, &dest_keyring);
    1210         [ #  # ]:          0 :         if (ret < 0)
    1211                 :            :                 goto error2;
    1212                 :            : 
    1213                 :            :         /* instantiate the key and link it into a keyring */
    1214                 :          0 :         ret = key_instantiate_and_link(rka->target_key, payload, plen,
    1215                 :            :                                        dest_keyring, instkey);
    1216                 :            : 
    1217                 :          0 :         key_put(dest_keyring);
    1218                 :            : 
    1219                 :            :         /* discard the assumed authority if it's just been disabled by
    1220                 :            :          * instantiation of the key */
    1221         [ #  # ]:          0 :         if (ret == 0)
    1222                 :          0 :                 keyctl_change_reqkey_auth(NULL);
    1223                 :            : 
    1224                 :            : error2:
    1225                 :          0 :         kvfree_sensitive(payload, plen);
    1226                 :            : error:
    1227                 :          0 :         return ret;
    1228                 :            : }
    1229                 :            : 
    1230                 :            : /*
    1231                 :            :  * Instantiate a key with the specified payload and link the key into the
    1232                 :            :  * destination keyring if one is given.
    1233                 :            :  *
    1234                 :            :  * The caller must have the appropriate instantiation permit set for this to
    1235                 :            :  * work (see keyctl_assume_authority).  No other permissions are required.
    1236                 :            :  *
    1237                 :            :  * If successful, 0 will be returned.
    1238                 :            :  */
    1239                 :          0 : long keyctl_instantiate_key(key_serial_t id,
    1240                 :            :                             const void __user *_payload,
    1241                 :            :                             size_t plen,
    1242                 :            :                             key_serial_t ringid)
    1243                 :            : {
    1244         [ #  # ]:          0 :         if (_payload && plen) {
    1245                 :            :                 struct iovec iov;
    1246                 :            :                 struct iov_iter from;
    1247                 :            :                 int ret;
    1248                 :            : 
    1249                 :          0 :                 ret = import_single_range(WRITE, (void __user *)_payload, plen,
    1250                 :            :                                           &iov, &from);
    1251         [ #  # ]:          0 :                 if (unlikely(ret))
    1252                 :            :                         return ret;
    1253                 :            : 
    1254                 :          0 :                 return keyctl_instantiate_key_common(id, &from, ringid);
    1255                 :            :         }
    1256                 :            : 
    1257                 :          0 :         return keyctl_instantiate_key_common(id, NULL, ringid);
    1258                 :            : }
    1259                 :            : 
    1260                 :            : /*
    1261                 :            :  * Instantiate a key with the specified multipart payload and link the key into
    1262                 :            :  * the destination keyring if one is given.
    1263                 :            :  *
    1264                 :            :  * The caller must have the appropriate instantiation permit set for this to
    1265                 :            :  * work (see keyctl_assume_authority).  No other permissions are required.
    1266                 :            :  *
    1267                 :            :  * If successful, 0 will be returned.
    1268                 :            :  */
    1269                 :          0 : long keyctl_instantiate_key_iov(key_serial_t id,
    1270                 :            :                                 const struct iovec __user *_payload_iov,
    1271                 :            :                                 unsigned ioc,
    1272                 :            :                                 key_serial_t ringid)
    1273                 :            : {
    1274                 :          0 :         struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
    1275                 :            :         struct iov_iter from;
    1276                 :            :         long ret;
    1277                 :            : 
    1278         [ #  # ]:          0 :         if (!_payload_iov)
    1279                 :            :                 ioc = 0;
    1280                 :            : 
    1281                 :          0 :         ret = import_iovec(WRITE, _payload_iov, ioc,
    1282                 :            :                                     ARRAY_SIZE(iovstack), &iov, &from);
    1283         [ #  # ]:          0 :         if (ret < 0)
    1284                 :            :                 return ret;
    1285                 :          0 :         ret = keyctl_instantiate_key_common(id, &from, ringid);
    1286                 :          0 :         kfree(iov);
    1287                 :          0 :         return ret;
    1288                 :            : }
    1289                 :            : 
    1290                 :            : /*
    1291                 :            :  * Negatively instantiate the key with the given timeout (in seconds) and link
    1292                 :            :  * the key into the destination keyring if one is given.
    1293                 :            :  *
    1294                 :            :  * The caller must have the appropriate instantiation permit set for this to
    1295                 :            :  * work (see keyctl_assume_authority).  No other permissions are required.
    1296                 :            :  *
    1297                 :            :  * The key and any links to the key will be automatically garbage collected
    1298                 :            :  * after the timeout expires.
    1299                 :            :  *
    1300                 :            :  * Negative keys are used to rate limit repeated request_key() calls by causing
    1301                 :            :  * them to return -ENOKEY until the negative key expires.
    1302                 :            :  *
    1303                 :            :  * If successful, 0 will be returned.
    1304                 :            :  */
    1305                 :          0 : long keyctl_negate_key(key_serial_t id, unsigned timeout, key_serial_t ringid)
    1306                 :            : {
    1307                 :          0 :         return keyctl_reject_key(id, timeout, ENOKEY, ringid);
    1308                 :            : }
    1309                 :            : 
    1310                 :            : /*
    1311                 :            :  * Negatively instantiate the key with the given timeout (in seconds) and error
    1312                 :            :  * code and link the key into the destination keyring if one is given.
    1313                 :            :  *
    1314                 :            :  * The caller must have the appropriate instantiation permit set for this to
    1315                 :            :  * work (see keyctl_assume_authority).  No other permissions are required.
    1316                 :            :  *
    1317                 :            :  * The key and any links to the key will be automatically garbage collected
    1318                 :            :  * after the timeout expires.
    1319                 :            :  *
    1320                 :            :  * Negative keys are used to rate limit repeated request_key() calls by causing
    1321                 :            :  * them to return the specified error code until the negative key expires.
    1322                 :            :  *
    1323                 :            :  * If successful, 0 will be returned.
    1324                 :            :  */
    1325                 :          0 : long keyctl_reject_key(key_serial_t id, unsigned timeout, unsigned error,
    1326                 :            :                        key_serial_t ringid)
    1327                 :            : {
    1328                 :          0 :         const struct cred *cred = current_cred();
    1329                 :            :         struct request_key_auth *rka;
    1330                 :            :         struct key *instkey, *dest_keyring;
    1331                 :            :         long ret;
    1332                 :            : 
    1333                 :            :         kenter("%d,%u,%u,%d", id, timeout, error, ringid);
    1334                 :            : 
    1335                 :            :         /* must be a valid error code and mustn't be a kernel special */
    1336         [ #  # ]:          0 :         if (error <= 0 ||
    1337                 :          0 :             error >= MAX_ERRNO ||
    1338                 :          0 :             error == ERESTARTSYS ||
    1339         [ #  # ]:          0 :             error == ERESTARTNOINTR ||
    1340         [ #  # ]:          0 :             error == ERESTARTNOHAND ||
    1341                 :            :             error == ERESTART_RESTARTBLOCK)
    1342                 :            :                 return -EINVAL;
    1343                 :            : 
    1344                 :            :         /* the appropriate instantiation authorisation key must have been
    1345                 :            :          * assumed before calling this */
    1346                 :            :         ret = -EPERM;
    1347                 :          0 :         instkey = cred->request_key_auth;
    1348         [ #  # ]:          0 :         if (!instkey)
    1349                 :            :                 goto error;
    1350                 :            : 
    1351                 :          0 :         rka = instkey->payload.data[0];
    1352         [ #  # ]:          0 :         if (rka->target_key->serial != id)
    1353                 :            :                 goto error;
    1354                 :            : 
    1355                 :            :         /* find the destination keyring if present (which must also be
    1356                 :            :          * writable) */
    1357                 :          0 :         ret = get_instantiation_keyring(ringid, rka, &dest_keyring);
    1358         [ #  # ]:          0 :         if (ret < 0)
    1359                 :            :                 goto error;
    1360                 :            : 
    1361                 :            :         /* instantiate the key and link it into a keyring */
    1362                 :          0 :         ret = key_reject_and_link(rka->target_key, timeout, error,
    1363                 :            :                                   dest_keyring, instkey);
    1364                 :            : 
    1365                 :          0 :         key_put(dest_keyring);
    1366                 :            : 
    1367                 :            :         /* discard the assumed authority if it's just been disabled by
    1368                 :            :          * instantiation of the key */
    1369         [ #  # ]:          0 :         if (ret == 0)
    1370                 :          0 :                 keyctl_change_reqkey_auth(NULL);
    1371                 :            : 
    1372                 :            : error:
    1373                 :          0 :         return ret;
    1374                 :            : }
    1375                 :            : 
    1376                 :            : /*
    1377                 :            :  * Read or set the default keyring in which request_key() will cache keys and
    1378                 :            :  * return the old setting.
    1379                 :            :  *
    1380                 :            :  * If a thread or process keyring is specified then it will be created if it
    1381                 :            :  * doesn't yet exist.  The old setting will be returned if successful.
    1382                 :            :  */
    1383                 :          0 : long keyctl_set_reqkey_keyring(int reqkey_defl)
    1384                 :            : {
    1385                 :            :         struct cred *new;
    1386                 :            :         int ret, old_setting;
    1387                 :            : 
    1388                 :          0 :         old_setting = current_cred_xxx(jit_keyring);
    1389                 :            : 
    1390         [ #  # ]:          0 :         if (reqkey_defl == KEY_REQKEY_DEFL_NO_CHANGE)
    1391                 :            :                 return old_setting;
    1392                 :            : 
    1393                 :          0 :         new = prepare_creds();
    1394         [ #  # ]:          0 :         if (!new)
    1395                 :            :                 return -ENOMEM;
    1396                 :            : 
    1397   [ #  #  #  # ]:          0 :         switch (reqkey_defl) {
    1398                 :            :         case KEY_REQKEY_DEFL_THREAD_KEYRING:
    1399                 :          0 :                 ret = install_thread_keyring_to_cred(new);
    1400         [ #  # ]:          0 :                 if (ret < 0)
    1401                 :            :                         goto error;
    1402                 :            :                 goto set;
    1403                 :            : 
    1404                 :            :         case KEY_REQKEY_DEFL_PROCESS_KEYRING:
    1405                 :          0 :                 ret = install_process_keyring_to_cred(new);
    1406         [ #  # ]:          0 :                 if (ret < 0)
    1407                 :            :                         goto error;
    1408                 :            :                 goto set;
    1409                 :            : 
    1410                 :            :         case KEY_REQKEY_DEFL_DEFAULT:
    1411                 :            :         case KEY_REQKEY_DEFL_SESSION_KEYRING:
    1412                 :            :         case KEY_REQKEY_DEFL_USER_KEYRING:
    1413                 :            :         case KEY_REQKEY_DEFL_USER_SESSION_KEYRING:
    1414                 :            :         case KEY_REQKEY_DEFL_REQUESTOR_KEYRING:
    1415                 :            :                 goto set;
    1416                 :            : 
    1417                 :            :         case KEY_REQKEY_DEFL_NO_CHANGE:
    1418                 :            :         case KEY_REQKEY_DEFL_GROUP_KEYRING:
    1419                 :            :         default:
    1420                 :            :                 ret = -EINVAL;
    1421                 :            :                 goto error;
    1422                 :            :         }
    1423                 :            : 
    1424                 :            : set:
    1425                 :          0 :         new->jit_keyring = reqkey_defl;
    1426                 :          0 :         commit_creds(new);
    1427                 :          0 :         return old_setting;
    1428                 :            : error:
    1429                 :          0 :         abort_creds(new);
    1430                 :          0 :         return ret;
    1431                 :            : }
    1432                 :            : 
    1433                 :            : /*
    1434                 :            :  * Set or clear the timeout on a key.
    1435                 :            :  *
    1436                 :            :  * Either the key must grant the caller Setattr permission or else the caller
    1437                 :            :  * must hold an instantiation authorisation token for the key.
    1438                 :            :  *
    1439                 :            :  * The timeout is either 0 to clear the timeout, or a number of seconds from
    1440                 :            :  * the current time.  The key and any links to the key will be automatically
    1441                 :            :  * garbage collected after the timeout expires.
    1442                 :            :  *
    1443                 :            :  * Keys with KEY_FLAG_KEEP set should not be timed out.
    1444                 :            :  *
    1445                 :            :  * If successful, 0 is returned.
    1446                 :            :  */
    1447                 :          0 : long keyctl_set_timeout(key_serial_t id, unsigned timeout)
    1448                 :            : {
    1449                 :            :         struct key *key, *instkey;
    1450                 :            :         key_ref_t key_ref;
    1451                 :            :         long ret;
    1452                 :            : 
    1453                 :          0 :         key_ref = lookup_user_key(id, KEY_LOOKUP_CREATE | KEY_LOOKUP_PARTIAL,
    1454                 :            :                                   KEY_NEED_SETATTR);
    1455         [ #  # ]:          0 :         if (IS_ERR(key_ref)) {
    1456                 :            :                 /* setting the timeout on a key under construction is permitted
    1457                 :            :                  * if we have the authorisation token handy */
    1458         [ #  # ]:          0 :                 if (PTR_ERR(key_ref) == -EACCES) {
    1459                 :          0 :                         instkey = key_get_instantiation_authkey(id);
    1460         [ #  # ]:          0 :                         if (!IS_ERR(instkey)) {
    1461                 :          0 :                                 key_put(instkey);
    1462                 :          0 :                                 key_ref = lookup_user_key(id,
    1463                 :            :                                                           KEY_LOOKUP_PARTIAL,
    1464                 :            :                                                           0);
    1465         [ #  # ]:          0 :                                 if (!IS_ERR(key_ref))
    1466                 :            :                                         goto okay;
    1467                 :            :                         }
    1468                 :            :                 }
    1469                 :            : 
    1470                 :            :                 ret = PTR_ERR(key_ref);
    1471                 :          0 :                 goto error;
    1472                 :            :         }
    1473                 :            : 
    1474                 :            : okay:
    1475                 :            :         key = key_ref_to_ptr(key_ref);
    1476                 :            :         ret = 0;
    1477         [ #  # ]:          0 :         if (test_bit(KEY_FLAG_KEEP, &key->flags))
    1478                 :            :                 ret = -EPERM;
    1479                 :            :         else
    1480                 :          0 :                 key_set_timeout(key, timeout);
    1481                 :          0 :         key_put(key);
    1482                 :            : 
    1483                 :            : error:
    1484                 :          0 :         return ret;
    1485                 :            : }
    1486                 :            : 
    1487                 :            : /*
    1488                 :            :  * Assume (or clear) the authority to instantiate the specified key.
    1489                 :            :  *
    1490                 :            :  * This sets the authoritative token currently in force for key instantiation.
    1491                 :            :  * This must be done for a key to be instantiated.  It has the effect of making
    1492                 :            :  * available all the keys from the caller of the request_key() that created a
    1493                 :            :  * key to request_key() calls made by the caller of this function.
    1494                 :            :  *
    1495                 :            :  * The caller must have the instantiation key in their process keyrings with a
    1496                 :            :  * Search permission grant available to the caller.
    1497                 :            :  *
    1498                 :            :  * If the ID given is 0, then the setting will be cleared and 0 returned.
    1499                 :            :  *
    1500                 :            :  * If the ID given has a matching an authorisation key, then that key will be
    1501                 :            :  * set and its ID will be returned.  The authorisation key can be read to get
    1502                 :            :  * the callout information passed to request_key().
    1503                 :            :  */
    1504                 :          0 : long keyctl_assume_authority(key_serial_t id)
    1505                 :            : {
    1506                 :            :         struct key *authkey;
    1507                 :            :         long ret;
    1508                 :            : 
    1509                 :            :         /* special key IDs aren't permitted */
    1510                 :            :         ret = -EINVAL;
    1511         [ #  # ]:          0 :         if (id < 0)
    1512                 :            :                 goto error;
    1513                 :            : 
    1514                 :            :         /* we divest ourselves of authority if given an ID of 0 */
    1515         [ #  # ]:          0 :         if (id == 0) {
    1516                 :          0 :                 ret = keyctl_change_reqkey_auth(NULL);
    1517                 :          0 :                 goto error;
    1518                 :            :         }
    1519                 :            : 
    1520                 :            :         /* attempt to assume the authority temporarily granted to us whilst we
    1521                 :            :          * instantiate the specified key
    1522                 :            :          * - the authorisation key must be in the current task's keyrings
    1523                 :            :          *   somewhere
    1524                 :            :          */
    1525                 :          0 :         authkey = key_get_instantiation_authkey(id);
    1526         [ #  # ]:          0 :         if (IS_ERR(authkey)) {
    1527                 :            :                 ret = PTR_ERR(authkey);
    1528                 :          0 :                 goto error;
    1529                 :            :         }
    1530                 :            : 
    1531                 :          0 :         ret = keyctl_change_reqkey_auth(authkey);
    1532         [ #  # ]:          0 :         if (ret == 0)
    1533                 :          0 :                 ret = authkey->serial;
    1534                 :          0 :         key_put(authkey);
    1535                 :            : error:
    1536                 :          0 :         return ret;
    1537                 :            : }
    1538                 :            : 
    1539                 :            : /*
    1540                 :            :  * Get a key's the LSM security label.
    1541                 :            :  *
    1542                 :            :  * The key must grant the caller View permission for this to work.
    1543                 :            :  *
    1544                 :            :  * If there's a buffer, then up to buflen bytes of data will be placed into it.
    1545                 :            :  *
    1546                 :            :  * If successful, the amount of information available will be returned,
    1547                 :            :  * irrespective of how much was copied (including the terminal NUL).
    1548                 :            :  */
    1549                 :          0 : long keyctl_get_security(key_serial_t keyid,
    1550                 :            :                          char __user *buffer,
    1551                 :            :                          size_t buflen)
    1552                 :            : {
    1553                 :            :         struct key *key, *instkey;
    1554                 :            :         key_ref_t key_ref;
    1555                 :            :         char *context;
    1556                 :            :         long ret;
    1557                 :            : 
    1558                 :          0 :         key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, KEY_NEED_VIEW);
    1559         [ #  # ]:          0 :         if (IS_ERR(key_ref)) {
    1560         [ #  # ]:          0 :                 if (PTR_ERR(key_ref) != -EACCES)
    1561                 :            :                         return PTR_ERR(key_ref);
    1562                 :            : 
    1563                 :            :                 /* viewing a key under construction is also permitted if we
    1564                 :            :                  * have the authorisation token handy */
    1565                 :          0 :                 instkey = key_get_instantiation_authkey(keyid);
    1566         [ #  # ]:          0 :                 if (IS_ERR(instkey))
    1567                 :          0 :                         return PTR_ERR(instkey);
    1568                 :          0 :                 key_put(instkey);
    1569                 :            : 
    1570                 :          0 :                 key_ref = lookup_user_key(keyid, KEY_LOOKUP_PARTIAL, 0);
    1571         [ #  # ]:          0 :                 if (IS_ERR(key_ref))
    1572                 :          0 :                         return PTR_ERR(key_ref);
    1573                 :            :         }
    1574                 :            : 
    1575                 :            :         key = key_ref_to_ptr(key_ref);
    1576                 :          0 :         ret = security_key_getsecurity(key, &context);
    1577         [ #  # ]:          0 :         if (ret == 0) {
    1578                 :            :                 /* if no information was returned, give userspace an empty
    1579                 :            :                  * string */
    1580                 :            :                 ret = 1;
    1581   [ #  #  #  # ]:          0 :                 if (buffer && buflen > 0 &&
    1582                 :            :                     copy_to_user(buffer, "", 1) != 0)
    1583                 :            :                         ret = -EFAULT;
    1584         [ #  # ]:          0 :         } else if (ret > 0) {
    1585                 :            :                 /* return as much data as there's room for */
    1586         [ #  # ]:          0 :                 if (buffer && buflen > 0) {
    1587         [ #  # ]:          0 :                         if (buflen > ret)
    1588                 :            :                                 buflen = ret;
    1589                 :            : 
    1590         [ #  # ]:          0 :                         if (copy_to_user(buffer, context, buflen) != 0)
    1591                 :            :                                 ret = -EFAULT;
    1592                 :            :                 }
    1593                 :            : 
    1594                 :          0 :                 kfree(context);
    1595                 :            :         }
    1596                 :            : 
    1597                 :            :         key_ref_put(key_ref);
    1598                 :          0 :         return ret;
    1599                 :            : }
    1600                 :            : 
    1601                 :            : /*
    1602                 :            :  * Attempt to install the calling process's session keyring on the process's
    1603                 :            :  * parent process.
    1604                 :            :  *
    1605                 :            :  * The keyring must exist and must grant the caller LINK permission, and the
    1606                 :            :  * parent process must be single-threaded and must have the same effective
    1607                 :            :  * ownership as this process and mustn't be SUID/SGID.
    1608                 :            :  *
    1609                 :            :  * The keyring will be emplaced on the parent when it next resumes userspace.
    1610                 :            :  *
    1611                 :            :  * If successful, 0 will be returned.
    1612                 :            :  */
    1613                 :          0 : long keyctl_session_to_parent(void)
    1614                 :            : {
    1615                 :            :         struct task_struct *me, *parent;
    1616                 :            :         const struct cred *mycred, *pcred;
    1617                 :            :         struct callback_head *newwork, *oldwork;
    1618                 :            :         key_ref_t keyring_r;
    1619                 :            :         struct cred *cred;
    1620                 :            :         int ret;
    1621                 :            : 
    1622                 :          0 :         keyring_r = lookup_user_key(KEY_SPEC_SESSION_KEYRING, 0, KEY_NEED_LINK);
    1623         [ #  # ]:          0 :         if (IS_ERR(keyring_r))
    1624                 :          0 :                 return PTR_ERR(keyring_r);
    1625                 :            : 
    1626                 :            :         ret = -ENOMEM;
    1627                 :            : 
    1628                 :            :         /* our parent is going to need a new cred struct, a new tgcred struct
    1629                 :            :          * and new security data, so we allocate them here to prevent ENOMEM in
    1630                 :            :          * our parent */
    1631                 :          0 :         cred = cred_alloc_blank();
    1632         [ #  # ]:          0 :         if (!cred)
    1633                 :            :                 goto error_keyring;
    1634                 :          0 :         newwork = &cred->rcu;
    1635                 :            : 
    1636                 :          0 :         cred->session_keyring = key_ref_to_ptr(keyring_r);
    1637                 :            :         keyring_r = NULL;
    1638                 :            :         init_task_work(newwork, key_change_session_keyring);
    1639                 :            : 
    1640                 :          0 :         me = current;
    1641                 :            :         rcu_read_lock();
    1642                 :          0 :         write_lock_irq(&tasklist_lock);
    1643                 :            : 
    1644                 :            :         ret = -EPERM;
    1645                 :            :         oldwork = NULL;
    1646                 :          0 :         parent = rcu_dereference_protected(me->real_parent,
    1647                 :            :                                            lockdep_is_held(&tasklist_lock));
    1648                 :            : 
    1649                 :            :         /* the parent mustn't be init and mustn't be a kernel thread */
    1650   [ #  #  #  # ]:          0 :         if (parent->pid <= 1 || !parent->mm)
    1651                 :            :                 goto unlock;
    1652                 :            : 
    1653                 :            :         /* the parent must be single threaded */
    1654         [ #  # ]:          0 :         if (!thread_group_empty(parent))
    1655                 :            :                 goto unlock;
    1656                 :            : 
    1657                 :            :         /* the parent and the child must have different session keyrings or
    1658                 :            :          * there's no point */
    1659                 :          0 :         mycred = current_cred();
    1660                 :          0 :         pcred = __task_cred(parent);
    1661   [ #  #  #  # ]:          0 :         if (mycred == pcred ||
    1662                 :          0 :             mycred->session_keyring == pcred->session_keyring) {
    1663                 :            :                 ret = 0;
    1664                 :            :                 goto unlock;
    1665                 :            :         }
    1666                 :            : 
    1667                 :            :         /* the parent must have the same effective ownership and mustn't be
    1668                 :            :          * SUID/SGID */
    1669   [ #  #  #  # ]:          0 :         if (!uid_eq(pcred->uid,       mycred->euid) ||
    1670         [ #  # ]:          0 :             !uid_eq(pcred->euid, mycred->euid) ||
    1671         [ #  # ]:          0 :             !uid_eq(pcred->suid, mycred->euid) ||
    1672         [ #  # ]:          0 :             !gid_eq(pcred->gid,       mycred->egid) ||
    1673         [ #  # ]:          0 :             !gid_eq(pcred->egid, mycred->egid) ||
    1674                 :            :             !gid_eq(pcred->sgid, mycred->egid))
    1675                 :            :                 goto unlock;
    1676                 :            : 
    1677                 :            :         /* the keyrings must have the same UID */
    1678   [ #  #  #  # ]:          0 :         if ((pcred->session_keyring &&
    1679         [ #  # ]:          0 :              !uid_eq(pcred->session_keyring->uid, mycred->euid)) ||
    1680                 :            :             !uid_eq(mycred->session_keyring->uid, mycred->euid))
    1681                 :            :                 goto unlock;
    1682                 :            : 
    1683                 :            :         /* cancel an already pending keyring replacement */
    1684                 :          0 :         oldwork = task_work_cancel(parent, key_change_session_keyring);
    1685                 :            : 
    1686                 :            :         /* the replacement session keyring is applied just prior to userspace
    1687                 :            :          * restarting */
    1688                 :          0 :         ret = task_work_add(parent, newwork, true);
    1689         [ #  # ]:          0 :         if (!ret)
    1690                 :            :                 newwork = NULL;
    1691                 :            : unlock:
    1692                 :          0 :         write_unlock_irq(&tasklist_lock);
    1693                 :            :         rcu_read_unlock();
    1694         [ #  # ]:          0 :         if (oldwork)
    1695                 :          0 :                 put_cred(container_of(oldwork, struct cred, rcu));
    1696         [ #  # ]:          0 :         if (newwork)
    1697                 :          0 :                 put_cred(cred);
    1698                 :          0 :         return ret;
    1699                 :            : 
    1700                 :            : error_keyring:
    1701                 :            :         key_ref_put(keyring_r);
    1702                 :          0 :         return ret;
    1703                 :            : }
    1704                 :            : 
    1705                 :            : /*
    1706                 :            :  * Apply a restriction to a given keyring.
    1707                 :            :  *
    1708                 :            :  * The caller must have Setattr permission to change keyring restrictions.
    1709                 :            :  *
    1710                 :            :  * The requested type name may be a NULL pointer to reject all attempts
    1711                 :            :  * to link to the keyring.  In this case, _restriction must also be NULL.
    1712                 :            :  * Otherwise, both _type and _restriction must be non-NULL.
    1713                 :            :  *
    1714                 :            :  * Returns 0 if successful.
    1715                 :            :  */
    1716                 :          0 : long keyctl_restrict_keyring(key_serial_t id, const char __user *_type,
    1717                 :            :                              const char __user *_restriction)
    1718                 :            : {
    1719                 :            :         key_ref_t key_ref;
    1720                 :            :         char type[32];
    1721                 :            :         char *restriction = NULL;
    1722                 :            :         long ret;
    1723                 :            : 
    1724                 :          0 :         key_ref = lookup_user_key(id, 0, KEY_NEED_SETATTR);
    1725         [ #  # ]:          0 :         if (IS_ERR(key_ref))
    1726                 :          0 :                 return PTR_ERR(key_ref);
    1727                 :            : 
    1728                 :            :         ret = -EINVAL;
    1729         [ #  # ]:          0 :         if (_type) {
    1730         [ #  # ]:          0 :                 if (!_restriction)
    1731                 :            :                         goto error;
    1732                 :            : 
    1733                 :          0 :                 ret = key_get_type_from_user(type, _type, sizeof(type));
    1734         [ #  # ]:          0 :                 if (ret < 0)
    1735                 :            :                         goto error;
    1736                 :            : 
    1737                 :          0 :                 restriction = strndup_user(_restriction, PAGE_SIZE);
    1738         [ #  # ]:          0 :                 if (IS_ERR(restriction)) {
    1739                 :            :                         ret = PTR_ERR(restriction);
    1740                 :          0 :                         goto error;
    1741                 :            :                 }
    1742                 :            :         } else {
    1743         [ #  # ]:          0 :                 if (_restriction)
    1744                 :            :                         goto error;
    1745                 :            :         }
    1746                 :            : 
    1747         [ #  # ]:          0 :         ret = keyring_restrict(key_ref, _type ? type : NULL, restriction);
    1748                 :          0 :         kfree(restriction);
    1749                 :            : error:
    1750                 :            :         key_ref_put(key_ref);
    1751                 :          0 :         return ret;
    1752                 :            : }
    1753                 :            : 
    1754                 :            : /*
    1755                 :            :  * Get keyrings subsystem capabilities.
    1756                 :            :  */
    1757                 :          0 : long keyctl_capabilities(unsigned char __user *_buffer, size_t buflen)
    1758                 :            : {
    1759                 :            :         size_t size = buflen;
    1760                 :            : 
    1761         [ #  # ]:          0 :         if (size > 0) {
    1762         [ #  # ]:          0 :                 if (size > sizeof(keyrings_capabilities))
    1763                 :            :                         size = sizeof(keyrings_capabilities);
    1764         [ #  # ]:          0 :                 if (copy_to_user(_buffer, keyrings_capabilities, size) != 0)
    1765                 :            :                         return -EFAULT;
    1766   [ #  #  #  # ]:          0 :                 if (size < buflen &&
    1767                 :          0 :                     clear_user(_buffer + size, buflen - size) != 0)
    1768                 :            :                         return -EFAULT;
    1769                 :            :         }
    1770                 :            : 
    1771                 :            :         return sizeof(keyrings_capabilities);
    1772                 :            : }
    1773                 :            : 
    1774                 :            : /*
    1775                 :            :  * The key control system call
    1776                 :            :  */
    1777                 :      53862 : SYSCALL_DEFINE5(keyctl, int, option, unsigned long, arg2, unsigned long, arg3,
    1778                 :            :                 unsigned long, arg4, unsigned long, arg5)
    1779                 :            : {
    1780   [ -  +  -  -  :      26931 :         switch (option) {
          -  -  +  -  -  
          -  -  +  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
             -  -  -  -  
                      + ]
    1781                 :            :         case KEYCTL_GET_KEYRING_ID:
    1782                 :          0 :                 return keyctl_get_keyring_ID((key_serial_t) arg2,
    1783                 :            :                                              (int) arg3);
    1784                 :            : 
    1785                 :            :         case KEYCTL_JOIN_SESSION_KEYRING:
    1786                 :      12840 :                 return keyctl_join_session_keyring((const char __user *) arg2);
    1787                 :            : 
    1788                 :            :         case KEYCTL_UPDATE:
    1789                 :          0 :                 return keyctl_update_key((key_serial_t) arg2,
    1790                 :            :                                          (const void __user *) arg3,
    1791                 :            :                                          (size_t) arg4);
    1792                 :            : 
    1793                 :            :         case KEYCTL_REVOKE:
    1794                 :          0 :                 return keyctl_revoke_key((key_serial_t) arg2);
    1795                 :            : 
    1796                 :            :         case KEYCTL_DESCRIBE:
    1797                 :          0 :                 return keyctl_describe_key((key_serial_t) arg2,
    1798                 :            :                                            (char __user *) arg3,
    1799                 :            :                                            (unsigned) arg4);
    1800                 :            : 
    1801                 :            :         case KEYCTL_CLEAR:
    1802                 :          0 :                 return keyctl_keyring_clear((key_serial_t) arg2);
    1803                 :            : 
    1804                 :            :         case KEYCTL_LINK:
    1805                 :       1448 :                 return keyctl_keyring_link((key_serial_t) arg2,
    1806                 :            :                                            (key_serial_t) arg3);
    1807                 :            : 
    1808                 :            :         case KEYCTL_UNLINK:
    1809                 :          0 :                 return keyctl_keyring_unlink((key_serial_t) arg2,
    1810                 :            :                                              (key_serial_t) arg3);
    1811                 :            : 
    1812                 :            :         case KEYCTL_SEARCH:
    1813                 :          0 :                 return keyctl_keyring_search((key_serial_t) arg2,
    1814                 :            :                                              (const char __user *) arg3,
    1815                 :            :                                              (const char __user *) arg4,
    1816                 :            :                                              (key_serial_t) arg5);
    1817                 :            : 
    1818                 :            :         case KEYCTL_READ:
    1819                 :          0 :                 return keyctl_read_key((key_serial_t) arg2,
    1820                 :            :                                        (char __user *) arg3,
    1821                 :            :                                        (size_t) arg4);
    1822                 :            : 
    1823                 :            :         case KEYCTL_CHOWN:
    1824                 :          0 :                 return keyctl_chown_key((key_serial_t) arg2,
    1825                 :            :                                         (uid_t) arg3,
    1826                 :            :                                         (gid_t) arg4);
    1827                 :            : 
    1828                 :            :         case KEYCTL_SETPERM:
    1829                 :      12638 :                 return keyctl_setperm_key((key_serial_t) arg2,
    1830                 :            :                                           (key_perm_t) arg3);
    1831                 :            : 
    1832                 :            :         case KEYCTL_INSTANTIATE:
    1833                 :          0 :                 return keyctl_instantiate_key((key_serial_t) arg2,
    1834                 :            :                                               (const void __user *) arg3,
    1835                 :            :                                               (size_t) arg4,
    1836                 :            :                                               (key_serial_t) arg5);
    1837                 :            : 
    1838                 :            :         case KEYCTL_NEGATE:
    1839                 :          0 :                 return keyctl_negate_key((key_serial_t) arg2,
    1840                 :            :                                          (unsigned) arg3,
    1841                 :            :                                          (key_serial_t) arg4);
    1842                 :            : 
    1843                 :            :         case KEYCTL_SET_REQKEY_KEYRING:
    1844                 :          0 :                 return keyctl_set_reqkey_keyring(arg2);
    1845                 :            : 
    1846                 :            :         case KEYCTL_SET_TIMEOUT:
    1847                 :          0 :                 return keyctl_set_timeout((key_serial_t) arg2,
    1848                 :            :                                           (unsigned) arg3);
    1849                 :            : 
    1850                 :            :         case KEYCTL_ASSUME_AUTHORITY:
    1851                 :          0 :                 return keyctl_assume_authority((key_serial_t) arg2);
    1852                 :            : 
    1853                 :            :         case KEYCTL_GET_SECURITY:
    1854                 :          0 :                 return keyctl_get_security((key_serial_t) arg2,
    1855                 :            :                                            (char __user *) arg3,
    1856                 :            :                                            (size_t) arg4);
    1857                 :            : 
    1858                 :            :         case KEYCTL_SESSION_TO_PARENT:
    1859                 :          0 :                 return keyctl_session_to_parent();
    1860                 :            : 
    1861                 :            :         case KEYCTL_REJECT:
    1862                 :          0 :                 return keyctl_reject_key((key_serial_t) arg2,
    1863                 :            :                                          (unsigned) arg3,
    1864                 :            :                                          (unsigned) arg4,
    1865                 :            :                                          (key_serial_t) arg5);
    1866                 :            : 
    1867                 :            :         case KEYCTL_INSTANTIATE_IOV:
    1868                 :          0 :                 return keyctl_instantiate_key_iov(
    1869                 :            :                         (key_serial_t) arg2,
    1870                 :            :                         (const struct iovec __user *) arg3,
    1871                 :            :                         (unsigned) arg4,
    1872                 :            :                         (key_serial_t) arg5);
    1873                 :            : 
    1874                 :            :         case KEYCTL_INVALIDATE:
    1875                 :          0 :                 return keyctl_invalidate_key((key_serial_t) arg2);
    1876                 :            : 
    1877                 :            :         case KEYCTL_GET_PERSISTENT:
    1878                 :            :                 return keyctl_get_persistent((uid_t)arg2, (key_serial_t)arg3);
    1879                 :            : 
    1880                 :            :         case KEYCTL_DH_COMPUTE:
    1881                 :            :                 return keyctl_dh_compute((struct keyctl_dh_params __user *) arg2,
    1882                 :            :                                          (char __user *) arg3, (size_t) arg4,
    1883                 :            :                                          (struct keyctl_kdf_params __user *) arg5);
    1884                 :            : 
    1885                 :            :         case KEYCTL_RESTRICT_KEYRING:
    1886                 :          0 :                 return keyctl_restrict_keyring((key_serial_t) arg2,
    1887                 :            :                                                (const char __user *) arg3,
    1888                 :            :                                                (const char __user *) arg4);
    1889                 :            : 
    1890                 :            :         case KEYCTL_PKEY_QUERY:
    1891         [ #  # ]:          0 :                 if (arg3 != 0)
    1892                 :            :                         return -EINVAL;
    1893                 :          0 :                 return keyctl_pkey_query((key_serial_t)arg2,
    1894                 :            :                                          (const char __user *)arg4,
    1895                 :            :                                          (struct keyctl_pkey_query __user *)arg5);
    1896                 :            : 
    1897                 :            :         case KEYCTL_PKEY_ENCRYPT:
    1898                 :            :         case KEYCTL_PKEY_DECRYPT:
    1899                 :            :         case KEYCTL_PKEY_SIGN:
    1900                 :          0 :                 return keyctl_pkey_e_d_s(
    1901                 :            :                         option,
    1902                 :            :                         (const struct keyctl_pkey_params __user *)arg2,
    1903                 :            :                         (const char __user *)arg3,
    1904                 :            :                         (const void __user *)arg4,
    1905                 :            :                         (void __user *)arg5);
    1906                 :            : 
    1907                 :            :         case KEYCTL_PKEY_VERIFY:
    1908                 :          0 :                 return keyctl_pkey_verify(
    1909                 :            :                         (const struct keyctl_pkey_params __user *)arg2,
    1910                 :            :                         (const char __user *)arg3,
    1911                 :            :                         (const void __user *)arg4,
    1912                 :            :                         (const void __user *)arg5);
    1913                 :            : 
    1914                 :            :         case KEYCTL_MOVE:
    1915                 :          0 :                 return keyctl_keyring_move((key_serial_t)arg2,
    1916                 :            :                                            (key_serial_t)arg3,
    1917                 :            :                                            (key_serial_t)arg4,
    1918                 :            :                                            (unsigned int)arg5);
    1919                 :            : 
    1920                 :            :         case KEYCTL_CAPABILITIES:
    1921                 :          0 :                 return keyctl_capabilities((unsigned char __user *)arg2, (size_t)arg3);
    1922                 :            : 
    1923                 :            :         default:
    1924                 :            :                 return -EOPNOTSUPP;
    1925                 :            :         }
    1926                 :            : }

Generated by: LCOV version 1.14