Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: BSD-3-Clause
       2                 :            : /*
       3                 :            :  *  linux/net/sunrpc/gss_mech_switch.c
       4                 :            :  *
       5                 :            :  *  Copyright (c) 2001 The Regents of the University of Michigan.
       6                 :            :  *  All rights reserved.
       7                 :            :  *
       8                 :            :  *  J. Bruce Fields   <bfields@umich.edu>
       9                 :            :  */
      10                 :            : 
      11                 :            : #include <linux/types.h>
      12                 :            : #include <linux/slab.h>
      13                 :            : #include <linux/module.h>
      14                 :            : #include <linux/oid_registry.h>
      15                 :            : #include <linux/sunrpc/msg_prot.h>
      16                 :            : #include <linux/sunrpc/gss_asn1.h>
      17                 :            : #include <linux/sunrpc/auth_gss.h>
      18                 :            : #include <linux/sunrpc/svcauth_gss.h>
      19                 :            : #include <linux/sunrpc/gss_err.h>
      20                 :            : #include <linux/sunrpc/sched.h>
      21                 :            : #include <linux/sunrpc/gss_api.h>
      22                 :            : #include <linux/sunrpc/clnt.h>
      23                 :            : 
      24                 :            : #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
      25                 :            : # define RPCDBG_FACILITY        RPCDBG_AUTH
      26                 :            : #endif
      27                 :            : 
      28                 :            : static LIST_HEAD(registered_mechs);
      29                 :            : static DEFINE_SPINLOCK(registered_mechs_lock);
      30                 :            : 
      31                 :            : static void
      32                 :          0 : gss_mech_free(struct gss_api_mech *gm)
      33                 :            : {
      34                 :            :         struct pf_desc *pf;
      35                 :            :         int i;
      36                 :            : 
      37                 :          0 :         for (i = 0; i < gm->gm_pf_num; i++) {
      38                 :          0 :                 pf = &gm->gm_pfs[i];
      39                 :          0 :                 if (pf->domain)
      40                 :          0 :                         auth_domain_put(pf->domain);
      41                 :          0 :                 kfree(pf->auth_domain_name);
      42                 :          0 :                 pf->auth_domain_name = NULL;
      43                 :            :         }
      44                 :          0 : }
      45                 :            : 
      46                 :            : static inline char *
      47                 :          0 : make_auth_domain_name(char *name)
      48                 :            : {
      49                 :            :         static char     *prefix = "gss/";
      50                 :            :         char            *new;
      51                 :            : 
      52                 :          0 :         new = kmalloc(strlen(name) + strlen(prefix) + 1, GFP_KERNEL);
      53                 :          0 :         if (new) {
      54                 :          0 :                 strcpy(new, prefix);
      55                 :          0 :                 strcat(new, name);
      56                 :            :         }
      57                 :          0 :         return new;
      58                 :            : }
      59                 :            : 
      60                 :            : static int
      61                 :          0 : gss_mech_svc_setup(struct gss_api_mech *gm)
      62                 :            : {
      63                 :            :         struct auth_domain *dom;
      64                 :            :         struct pf_desc *pf;
      65                 :            :         int i, status;
      66                 :            : 
      67                 :          0 :         for (i = 0; i < gm->gm_pf_num; i++) {
      68                 :          0 :                 pf = &gm->gm_pfs[i];
      69                 :          0 :                 pf->auth_domain_name = make_auth_domain_name(pf->name);
      70                 :            :                 status = -ENOMEM;
      71                 :          0 :                 if (pf->auth_domain_name == NULL)
      72                 :            :                         goto out;
      73                 :          0 :                 dom = svcauth_gss_register_pseudoflavor(
      74                 :            :                         pf->pseudoflavor, pf->auth_domain_name);
      75                 :          0 :                 if (IS_ERR(dom)) {
      76                 :            :                         status = PTR_ERR(dom);
      77                 :          0 :                         goto out;
      78                 :            :                 }
      79                 :          0 :                 pf->domain = dom;
      80                 :            :         }
      81                 :            :         return 0;
      82                 :            : out:
      83                 :          0 :         gss_mech_free(gm);
      84                 :          0 :         return status;
      85                 :            : }
      86                 :            : 
      87                 :            : /**
      88                 :            :  * gss_mech_register - register a GSS mechanism
      89                 :            :  * @gm: GSS mechanism handle
      90                 :            :  *
      91                 :            :  * Returns zero if successful, or a negative errno.
      92                 :            :  */
      93                 :          0 : int gss_mech_register(struct gss_api_mech *gm)
      94                 :            : {
      95                 :            :         int status;
      96                 :            : 
      97                 :          0 :         status = gss_mech_svc_setup(gm);
      98                 :          0 :         if (status)
      99                 :            :                 return status;
     100                 :            :         spin_lock(&registered_mechs_lock);
     101                 :          0 :         list_add_rcu(&gm->gm_list, &registered_mechs);
     102                 :            :         spin_unlock(&registered_mechs_lock);
     103                 :            :         dprintk("RPC:       registered gss mechanism %s\n", gm->gm_name);
     104                 :          0 :         return 0;
     105                 :            : }
     106                 :            : EXPORT_SYMBOL_GPL(gss_mech_register);
     107                 :            : 
     108                 :            : /**
     109                 :            :  * gss_mech_unregister - release a GSS mechanism
     110                 :            :  * @gm: GSS mechanism handle
     111                 :            :  *
     112                 :            :  */
     113                 :          0 : void gss_mech_unregister(struct gss_api_mech *gm)
     114                 :            : {
     115                 :            :         spin_lock(&registered_mechs_lock);
     116                 :            :         list_del_rcu(&gm->gm_list);
     117                 :            :         spin_unlock(&registered_mechs_lock);
     118                 :            :         dprintk("RPC:       unregistered gss mechanism %s\n", gm->gm_name);
     119                 :          0 :         gss_mech_free(gm);
     120                 :          0 : }
     121                 :            : EXPORT_SYMBOL_GPL(gss_mech_unregister);
     122                 :            : 
     123                 :          0 : struct gss_api_mech *gss_mech_get(struct gss_api_mech *gm)
     124                 :            : {
     125                 :          0 :         __module_get(gm->gm_owner);
     126                 :          0 :         return gm;
     127                 :            : }
     128                 :            : EXPORT_SYMBOL(gss_mech_get);
     129                 :            : 
     130                 :            : static struct gss_api_mech *
     131                 :          0 : _gss_mech_get_by_name(const char *name)
     132                 :            : {
     133                 :            :         struct gss_api_mech     *pos, *gm = NULL;
     134                 :            : 
     135                 :            :         rcu_read_lock();
     136                 :          0 :         list_for_each_entry_rcu(pos, &registered_mechs, gm_list) {
     137                 :          0 :                 if (0 == strcmp(name, pos->gm_name)) {
     138                 :          0 :                         if (try_module_get(pos->gm_owner))
     139                 :          0 :                                 gm = pos;
     140                 :            :                         break;
     141                 :            :                 }
     142                 :            :         }
     143                 :            :         rcu_read_unlock();
     144                 :          0 :         return gm;
     145                 :            : 
     146                 :            : }
     147                 :            : 
     148                 :          0 : struct gss_api_mech * gss_mech_get_by_name(const char *name)
     149                 :            : {
     150                 :            :         struct gss_api_mech *gm = NULL;
     151                 :            : 
     152                 :          0 :         gm = _gss_mech_get_by_name(name);
     153                 :          0 :         if (!gm) {
     154                 :          0 :                 request_module("rpc-auth-gss-%s", name);
     155                 :          0 :                 gm = _gss_mech_get_by_name(name);
     156                 :            :         }
     157                 :          0 :         return gm;
     158                 :            : }
     159                 :            : 
     160                 :          0 : struct gss_api_mech *gss_mech_get_by_OID(struct rpcsec_gss_oid *obj)
     161                 :            : {
     162                 :            :         struct gss_api_mech     *pos, *gm = NULL;
     163                 :            :         char buf[32];
     164                 :            : 
     165                 :          0 :         if (sprint_oid(obj->data, obj->len, buf, sizeof(buf)) < 0)
     166                 :            :                 return NULL;
     167                 :            :         dprintk("RPC:       %s(%s)\n", __func__, buf);
     168                 :          0 :         request_module("rpc-auth-gss-%s", buf);
     169                 :            : 
     170                 :            :         rcu_read_lock();
     171                 :          0 :         list_for_each_entry_rcu(pos, &registered_mechs, gm_list) {
     172                 :          0 :                 if (obj->len == pos->gm_oid.len) {
     173                 :          0 :                         if (0 == memcmp(obj->data, pos->gm_oid.data, obj->len)) {
     174                 :          0 :                                 if (try_module_get(pos->gm_owner))
     175                 :          0 :                                         gm = pos;
     176                 :            :                                 break;
     177                 :            :                         }
     178                 :            :                 }
     179                 :            :         }
     180                 :            :         rcu_read_unlock();
     181                 :          0 :         return gm;
     182                 :            : }
     183                 :            : 
     184                 :            : static inline int
     185                 :            : mech_supports_pseudoflavor(struct gss_api_mech *gm, u32 pseudoflavor)
     186                 :            : {
     187                 :            :         int i;
     188                 :            : 
     189                 :          0 :         for (i = 0; i < gm->gm_pf_num; i++) {
     190                 :          0 :                 if (gm->gm_pfs[i].pseudoflavor == pseudoflavor)
     191                 :            :                         return 1;
     192                 :            :         }
     193                 :            :         return 0;
     194                 :            : }
     195                 :            : 
     196                 :          0 : static struct gss_api_mech *_gss_mech_get_by_pseudoflavor(u32 pseudoflavor)
     197                 :            : {
     198                 :            :         struct gss_api_mech *gm = NULL, *pos;
     199                 :            : 
     200                 :            :         rcu_read_lock();
     201                 :          0 :         list_for_each_entry_rcu(pos, &registered_mechs, gm_list) {
     202                 :          0 :                 if (!mech_supports_pseudoflavor(pos, pseudoflavor))
     203                 :          0 :                         continue;
     204                 :          0 :                 if (try_module_get(pos->gm_owner))
     205                 :          0 :                         gm = pos;
     206                 :            :                 break;
     207                 :            :         }
     208                 :            :         rcu_read_unlock();
     209                 :          0 :         return gm;
     210                 :            : }
     211                 :            : 
     212                 :            : struct gss_api_mech *
     213                 :          0 : gss_mech_get_by_pseudoflavor(u32 pseudoflavor)
     214                 :            : {
     215                 :            :         struct gss_api_mech *gm;
     216                 :            : 
     217                 :          0 :         gm = _gss_mech_get_by_pseudoflavor(pseudoflavor);
     218                 :            : 
     219                 :          0 :         if (!gm) {
     220                 :          0 :                 request_module("rpc-auth-gss-%u", pseudoflavor);
     221                 :          0 :                 gm = _gss_mech_get_by_pseudoflavor(pseudoflavor);
     222                 :            :         }
     223                 :          0 :         return gm;
     224                 :            : }
     225                 :            : 
     226                 :            : /**
     227                 :            :  * gss_mech_list_pseudoflavors - Discover registered GSS pseudoflavors
     228                 :            :  * @array_ptr: array to fill in
     229                 :            :  * @size: size of "array"
     230                 :            :  *
     231                 :            :  * Returns the number of array items filled in, or a negative errno.
     232                 :            :  *
     233                 :            :  * The returned array is not sorted by any policy.  Callers should not
     234                 :            :  * rely on the order of the items in the returned array.
     235                 :            :  */
     236                 :          0 : int gss_mech_list_pseudoflavors(rpc_authflavor_t *array_ptr, int size)
     237                 :            : {
     238                 :            :         struct gss_api_mech *pos = NULL;
     239                 :            :         int j, i = 0;
     240                 :            : 
     241                 :            :         rcu_read_lock();
     242                 :          0 :         list_for_each_entry_rcu(pos, &registered_mechs, gm_list) {
     243                 :          0 :                 for (j = 0; j < pos->gm_pf_num; j++) {
     244                 :          0 :                         if (i >= size) {
     245                 :            :                                 spin_unlock(&registered_mechs_lock);
     246                 :          0 :                                 return -ENOMEM;
     247                 :            :                         }
     248                 :          0 :                         array_ptr[i++] = pos->gm_pfs[j].pseudoflavor;
     249                 :            :                 }
     250                 :            :         }
     251                 :            :         rcu_read_unlock();
     252                 :          0 :         return i;
     253                 :            : }
     254                 :            : 
     255                 :            : /**
     256                 :            :  * gss_svc_to_pseudoflavor - map a GSS service number to a pseudoflavor
     257                 :            :  * @gm: GSS mechanism handle
     258                 :            :  * @qop: GSS quality-of-protection value
     259                 :            :  * @service: GSS service value
     260                 :            :  *
     261                 :            :  * Returns a matching security flavor, or RPC_AUTH_MAXFLAVOR if none is found.
     262                 :            :  */
     263                 :          0 : rpc_authflavor_t gss_svc_to_pseudoflavor(struct gss_api_mech *gm, u32 qop,
     264                 :            :                                          u32 service)
     265                 :            : {
     266                 :            :         int i;
     267                 :            : 
     268                 :          0 :         for (i = 0; i < gm->gm_pf_num; i++) {
     269                 :          0 :                 if (gm->gm_pfs[i].qop == qop &&
     270                 :          0 :                     gm->gm_pfs[i].service == service) {
     271                 :          0 :                         return gm->gm_pfs[i].pseudoflavor;
     272                 :            :                 }
     273                 :            :         }
     274                 :            :         return RPC_AUTH_MAXFLAVOR;
     275                 :            : }
     276                 :            : 
     277                 :            : /**
     278                 :            :  * gss_mech_info2flavor - look up a pseudoflavor given a GSS tuple
     279                 :            :  * @info: a GSS mech OID, quality of protection, and service value
     280                 :            :  *
     281                 :            :  * Returns a matching pseudoflavor, or RPC_AUTH_MAXFLAVOR if the tuple is
     282                 :            :  * not supported.
     283                 :            :  */
     284                 :          0 : rpc_authflavor_t gss_mech_info2flavor(struct rpcsec_gss_info *info)
     285                 :            : {
     286                 :            :         rpc_authflavor_t pseudoflavor;
     287                 :            :         struct gss_api_mech *gm;
     288                 :            : 
     289                 :          0 :         gm = gss_mech_get_by_OID(&info->oid);
     290                 :          0 :         if (gm == NULL)
     291                 :            :                 return RPC_AUTH_MAXFLAVOR;
     292                 :            : 
     293                 :          0 :         pseudoflavor = gss_svc_to_pseudoflavor(gm, info->qop, info->service);
     294                 :            : 
     295                 :            :         gss_mech_put(gm);
     296                 :          0 :         return pseudoflavor;
     297                 :            : }
     298                 :            : 
     299                 :            : /**
     300                 :            :  * gss_mech_flavor2info - look up a GSS tuple for a given pseudoflavor
     301                 :            :  * @pseudoflavor: GSS pseudoflavor to match
     302                 :            :  * @info: rpcsec_gss_info structure to fill in
     303                 :            :  *
     304                 :            :  * Returns zero and fills in "info" if pseudoflavor matches a
     305                 :            :  * supported mechanism.  Otherwise a negative errno is returned.
     306                 :            :  */
     307                 :          0 : int gss_mech_flavor2info(rpc_authflavor_t pseudoflavor,
     308                 :            :                          struct rpcsec_gss_info *info)
     309                 :            : {
     310                 :            :         struct gss_api_mech *gm;
     311                 :            :         int i;
     312                 :            : 
     313                 :          0 :         gm = gss_mech_get_by_pseudoflavor(pseudoflavor);
     314                 :          0 :         if (gm == NULL)
     315                 :            :                 return -ENOENT;
     316                 :            : 
     317                 :          0 :         for (i = 0; i < gm->gm_pf_num; i++) {
     318                 :          0 :                 if (gm->gm_pfs[i].pseudoflavor == pseudoflavor) {
     319                 :          0 :                         memcpy(info->oid.data, gm->gm_oid.data, gm->gm_oid.len);
     320                 :          0 :                         info->oid.len = gm->gm_oid.len;
     321                 :          0 :                         info->qop = gm->gm_pfs[i].qop;
     322                 :          0 :                         info->service = gm->gm_pfs[i].service;
     323                 :            :                         gss_mech_put(gm);
     324                 :            :                         return 0;
     325                 :            :                 }
     326                 :            :         }
     327                 :            : 
     328                 :            :         gss_mech_put(gm);
     329                 :            :         return -ENOENT;
     330                 :            : }
     331                 :            : 
     332                 :            : u32
     333                 :          0 : gss_pseudoflavor_to_service(struct gss_api_mech *gm, u32 pseudoflavor)
     334                 :            : {
     335                 :            :         int i;
     336                 :            : 
     337                 :          0 :         for (i = 0; i < gm->gm_pf_num; i++) {
     338                 :          0 :                 if (gm->gm_pfs[i].pseudoflavor == pseudoflavor)
     339                 :          0 :                         return gm->gm_pfs[i].service;
     340                 :            :         }
     341                 :            :         return 0;
     342                 :            : }
     343                 :            : EXPORT_SYMBOL(gss_pseudoflavor_to_service);
     344                 :            : 
     345                 :            : bool
     346                 :          0 : gss_pseudoflavor_to_datatouch(struct gss_api_mech *gm, u32 pseudoflavor)
     347                 :            : {
     348                 :            :         int i;
     349                 :            : 
     350                 :          0 :         for (i = 0; i < gm->gm_pf_num; i++) {
     351                 :          0 :                 if (gm->gm_pfs[i].pseudoflavor == pseudoflavor)
     352                 :          0 :                         return gm->gm_pfs[i].datatouch;
     353                 :            :         }
     354                 :            :         return false;
     355                 :            : }
     356                 :            : 
     357                 :            : char *
     358                 :          0 : gss_service_to_auth_domain_name(struct gss_api_mech *gm, u32 service)
     359                 :            : {
     360                 :            :         int i;
     361                 :            : 
     362                 :          0 :         for (i = 0; i < gm->gm_pf_num; i++) {
     363                 :          0 :                 if (gm->gm_pfs[i].service == service)
     364                 :          0 :                         return gm->gm_pfs[i].auth_domain_name;
     365                 :            :         }
     366                 :            :         return NULL;
     367                 :            : }
     368                 :            : 
     369                 :            : void
     370                 :          0 : gss_mech_put(struct gss_api_mech * gm)
     371                 :            : {
     372                 :          0 :         if (gm)
     373                 :          0 :                 module_put(gm->gm_owner);
     374                 :          0 : }
     375                 :            : EXPORT_SYMBOL(gss_mech_put);
     376                 :            : 
     377                 :            : /* The mech could probably be determined from the token instead, but it's just
     378                 :            :  * as easy for now to pass it in. */
     379                 :            : int
     380                 :          0 : gss_import_sec_context(const void *input_token, size_t bufsize,
     381                 :            :                        struct gss_api_mech      *mech,
     382                 :            :                        struct gss_ctx           **ctx_id,
     383                 :            :                        time_t                   *endtime,
     384                 :            :                        gfp_t gfp_mask)
     385                 :            : {
     386                 :          0 :         if (!(*ctx_id = kzalloc(sizeof(**ctx_id), gfp_mask)))
     387                 :            :                 return -ENOMEM;
     388                 :          0 :         (*ctx_id)->mech_type = gss_mech_get(mech);
     389                 :            : 
     390                 :          0 :         return mech->gm_ops->gss_import_sec_context(input_token, bufsize,
     391                 :            :                                                 *ctx_id, endtime, gfp_mask);
     392                 :            : }
     393                 :            : 
     394                 :            : /* gss_get_mic: compute a mic over message and return mic_token. */
     395                 :            : 
     396                 :            : u32
     397                 :          0 : gss_get_mic(struct gss_ctx      *context_handle,
     398                 :            :             struct xdr_buf      *message,
     399                 :            :             struct xdr_netobj   *mic_token)
     400                 :            : {
     401                 :          0 :          return context_handle->mech_type->gm_ops
     402                 :          0 :                 ->gss_get_mic(context_handle,
     403                 :            :                               message,
     404                 :            :                               mic_token);
     405                 :            : }
     406                 :            : 
     407                 :            : /* gss_verify_mic: check whether the provided mic_token verifies message. */
     408                 :            : 
     409                 :            : u32
     410                 :          0 : gss_verify_mic(struct gss_ctx           *context_handle,
     411                 :            :                struct xdr_buf           *message,
     412                 :            :                struct xdr_netobj        *mic_token)
     413                 :            : {
     414                 :          0 :         return context_handle->mech_type->gm_ops
     415                 :          0 :                 ->gss_verify_mic(context_handle,
     416                 :            :                                  message,
     417                 :            :                                  mic_token);
     418                 :            : }
     419                 :            : 
     420                 :            : /*
     421                 :            :  * This function is called from both the client and server code.
     422                 :            :  * Each makes guarantees about how much "slack" space is available
     423                 :            :  * for the underlying function in "buf"'s head and tail while
     424                 :            :  * performing the wrap.
     425                 :            :  *
     426                 :            :  * The client and server code allocate RPC_MAX_AUTH_SIZE extra
     427                 :            :  * space in both the head and tail which is available for use by
     428                 :            :  * the wrap function.
     429                 :            :  *
     430                 :            :  * Underlying functions should verify they do not use more than
     431                 :            :  * RPC_MAX_AUTH_SIZE of extra space in either the head or tail
     432                 :            :  * when performing the wrap.
     433                 :            :  */
     434                 :            : u32
     435                 :          0 : gss_wrap(struct gss_ctx *ctx_id,
     436                 :            :          int            offset,
     437                 :            :          struct xdr_buf *buf,
     438                 :            :          struct page    **inpages)
     439                 :            : {
     440                 :          0 :         return ctx_id->mech_type->gm_ops
     441                 :          0 :                 ->gss_wrap(ctx_id, offset, buf, inpages);
     442                 :            : }
     443                 :            : 
     444                 :            : u32
     445                 :          0 : gss_unwrap(struct gss_ctx       *ctx_id,
     446                 :            :            int                  offset,
     447                 :            :            int                  len,
     448                 :            :            struct xdr_buf       *buf)
     449                 :            : {
     450                 :          0 :         return ctx_id->mech_type->gm_ops
     451                 :          0 :                 ->gss_unwrap(ctx_id, offset, len, buf);
     452                 :            : }
     453                 :            : 
     454                 :            : 
     455                 :            : /* gss_delete_sec_context: free all resources associated with context_handle.
     456                 :            :  * Note this differs from the RFC 2744-specified prototype in that we don't
     457                 :            :  * bother returning an output token, since it would never be used anyway. */
     458                 :            : 
     459                 :            : u32
     460                 :          0 : gss_delete_sec_context(struct gss_ctx   **context_handle)
     461                 :            : {
     462                 :            :         dprintk("RPC:       gss_delete_sec_context deleting %p\n",
     463                 :            :                         *context_handle);
     464                 :            : 
     465                 :          0 :         if (!*context_handle)
     466                 :            :                 return GSS_S_NO_CONTEXT;
     467                 :          0 :         if ((*context_handle)->internal_ctx_id)
     468                 :          0 :                 (*context_handle)->mech_type->gm_ops
     469                 :          0 :                         ->gss_delete_sec_context((*context_handle)
     470                 :            :                                                         ->internal_ctx_id);
     471                 :          0 :         gss_mech_put((*context_handle)->mech_type);
     472                 :          0 :         kfree(*context_handle);
     473                 :          0 :         *context_handle=NULL;
     474                 :          0 :         return GSS_S_COMPLETE;
     475                 :            : }