sunrpc/svcauth_des.c

   1 /*
   2  * Copyright (c) 2010, Oracle America, Inc.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  *       notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  *       copyright notice, this list of conditions and the following
  12  *       disclaimer in the documentation and/or other materials
  13  *       provided with the distribution.
  14  *     * Neither the name of the "Oracle America, Inc." nor the names of its
  15  *       contributors may be used to endorse or promote products derived
  16  *       from this software without specific prior written permission.
  17  *
  18  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  21  *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  22  *   COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  23  *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  *   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  25  *   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  27  *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  28  *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  *
  31  * svcauth_des.c, server-side des authentication
  32  *
  33  * We insure for the service the following:
  34  * (1) The timestamp microseconds do not exceed 1 million.
  35  * (2) The timestamp plus the window is less than the current time.
  36  * (3) The timestamp is not less than the one previously
  37  *     seen in the current session.
  38  *
  39  * It is up to the server to determine if the window size is
  40  * too small .
  41  *
  42  */
  43
  44 #include <limits.h>
  45 #include <string.h>
  46 #include <sys/param.h>
  47 #include <netinet/in.h>
  48 #include <rpc/rpc.h>
  49 #include <rpc/xdr.h>
  50 #include <rpc/auth.h>
  51 #include <rpc/auth_des.h>
  52 #include <rpc/svc_auth.h>
  53 #include <rpc/svc.h>
  54 #include <rpc/des_crypt.h>
  55
  56 #define debug(msg)              /*printf("svcauth_des: %s\n", msg) */
  57
  58 #define USEC_PER_SEC ((uint32_t) 1000000L)
  59 #define BEFORE(t1, t2) timercmp(t1, t2, <)
  60
  61 /*
  62  * LRU cache of conversation keys and some other useful items.
  63  */
  64 #define AUTHDES_CACHESZ 64
  65 struct cache_entry
  66   {
  67     des_block key;              /* conversation key */
  68     char *rname;                /* client's name */
  69     u_int window;               /* credential lifetime window */
  70     struct rpc_timeval laststamp;       /* detect replays of creds */
  71     char *localcred;            /* generic local credential */
  72   };
  73 #ifdef _RPC_THREAD_SAFE_
  74 #define authdes_cache RPC_THREAD_VARIABLE(authdes_cache_s)
  75 #define authdes_lru RPC_THREAD_VARIABLE(authdes_lru_s)
  76 #else
  77 static struct cache_entry *authdes_cache;
  78 static int *authdes_lru;
  79 #endif
  80
  81 static void cache_init (void) internal_function; /* initialize the cache */
  82 static short cache_spot (des_block *, char *, struct rpc_timeval *)
  83      internal_function;         /* find an entry in the cache */
  84 static void cache_ref (uint32_t sid) internal_function;
  85                                 /* note that sid was ref'd */
  86
  87 static void invalidate (char *cred) internal_function;
  88                                 /* invalidate entry in cache */
  89
  90 /*
  91  * cache statistics
  92  */
  93 struct
  94   {
  95     u_long ncachehits;          /* times cache hit, and is not replay */
  96     u_long ncachereplays;       /* times cache hit, and is replay */
  97     u_long ncachemisses;        /* times cache missed */
  98   }
  99 svcauthdes_stats;
 100
 101 /*
 102  * Service side authenticator for AUTH_DES
 103  */
 104 enum auth_stat
 105 _svcauth_des (register struct svc_req *rqst, register struct rpc_msg *msg)
 106 {
 107   register uint32_t *ixdr;
 108   des_block cryptbuf[2];
 109   register struct authdes_cred *cred;
 110   struct authdes_verf verf;
 111   int status;
 112   register struct cache_entry *entry;
 113   uint32_t sid = 0;
 114   des_block *sessionkey;
 115   des_block ivec;
 116   u_int window;
 117   struct rpc_timeval timestamp;
 118   uint32_t namelen;
 119   struct area
 120     {
 121       struct authdes_cred area_cred;
 122       char area_netname[MAXNETNAMELEN + 1];
 123     }
 124    *area;
 125
 126   if (authdes_cache == NULL)
 127     cache_init ();
 128   if (authdes_cache == NULL) /* No free memory */
 129     return AUTH_FAILED;
 130
 131   area = (struct area *) rqst->rq_clntcred;
 132   cred = (struct authdes_cred *) &area->area_cred;
 133
 134   /*
 135    * Get the credential
 136    */
 137   if (msg->rm_call.cb_cred.oa_length <= 0 ||
 138       msg->rm_call.cb_cred.oa_length > MAX_AUTH_BYTES)
 139     return AUTH_BADCRED;
 140
 141   ixdr = (uint32_t *) msg->rm_call.cb_cred.oa_base;
 142   cred->adc_namekind = IXDR_GET_ENUM (ixdr, enum authdes_namekind);
 143   switch (cred->adc_namekind)
 144     {
 145     case ADN_FULLNAME:
 146       namelen = IXDR_GET_U_INT32 (ixdr);
 147       if (namelen > MAXNETNAMELEN)
 148         {
 149           return AUTH_BADCRED;
 150         }
 151       cred->adc_fullname.name = area->area_netname;
 152       memcpy (cred->adc_fullname.name, (char *) ixdr, namelen);
 153       cred->adc_fullname.name[namelen] = 0;
 154       ixdr += (RNDUP (namelen) / BYTES_PER_XDR_UNIT);
 155       cred->adc_fullname.key.key.high = *ixdr++;
 156       cred->adc_fullname.key.key.low = *ixdr++;
 157       cred->adc_fullname.window = *ixdr++;
 158       break;
 159     case ADN_NICKNAME:
 160       cred->adc_nickname = *ixdr++;
 161       break;
 162     default:
 163       return AUTH_BADCRED;
 164     }
 165
 166   /*
 167    * Get the verifier
 168    */
 169   if (msg->rm_call.cb_verf.oa_length <= 0 ||
 170       msg->rm_call.cb_verf.oa_length > MAX_AUTH_BYTES)
 171     return AUTH_BADCRED;
 172
 173   ixdr = (uint32_t *) msg->rm_call.cb_verf.oa_base;
 174   verf.adv_xtimestamp.key.high = *ixdr++;
 175   verf.adv_xtimestamp.key.low = *ixdr++;
 176   verf.adv_int_u = *ixdr++;
 177
 178   /*
 179    * Get the conversation key
 180    */
 181   if (cred->adc_namekind == ADN_FULLNAME)
 182     {
 183       netobj pkey;
 184       char pkey_data[1024];
 185
 186       sessionkey = &cred->adc_fullname.key;
 187       if (!getpublickey (cred->adc_fullname.name, pkey_data))
 188         {
 189           debug("getpublickey");
 190           return AUTH_BADCRED;
 191         }
 192       pkey.n_bytes = pkey_data;
 193       pkey.n_len = strlen (pkey_data) + 1;
 194       if (key_decryptsession_pk (cred->adc_fullname.name, &pkey,
 195                                  sessionkey) < 0)
 196         {
 197           debug ("decryptsessionkey");
 198           return AUTH_BADCRED;  /* key not found */
 199         }
 200     }
 201   else
 202     {                           /* ADN_NICKNAME */
 203       if (cred->adc_nickname >= AUTHDES_CACHESZ)
 204         {
 205           debug ("bad nickname");
 206           return AUTH_BADCRED;  /* garbled credential */
 207         }
 208       else
 209         sid = cred->adc_nickname;
 210
 211       /* XXX This could be wrong, but else we have a
 212          security problem */
 213       if (authdes_cache[sid].rname == NULL)
 214         return AUTH_BADCRED;
 215       sessionkey = &authdes_cache[sid].key;
 216     }
 217
 218
 219   /*
 220    * Decrypt the timestamp
 221    */
 222   cryptbuf[0] = verf.adv_xtimestamp;
 223   if (cred->adc_namekind == ADN_FULLNAME)
 224     {
 225       cryptbuf[1].key.high = cred->adc_fullname.window;
 226       cryptbuf[1].key.low = verf.adv_winverf;
 227       ivec.key.high = ivec.key.low = 0;
 228       status = cbc_crypt ((char *) sessionkey, (char *) cryptbuf,
 229                           2 * sizeof (des_block), DES_DECRYPT | DES_HW,
 230                           (char *) &ivec);
 231     }
 232   else
 233     status = ecb_crypt ((char *) sessionkey, (char *) cryptbuf,
 234                         sizeof (des_block), DES_DECRYPT | DES_HW);
 235
 236   if (DES_FAILED (status))
 237     {
 238       debug ("decryption failure");
 239       return AUTH_FAILED;       /* system error */
 240     }
 241
 242   /*
 243    * XDR the decrypted timestamp
 244    */
 245   ixdr = (uint32_t *) cryptbuf;
 246   timestamp.tv_sec = IXDR_GET_INT32 (ixdr);
 247   timestamp.tv_usec = IXDR_GET_INT32 (ixdr);
 248
 249   /*
 250    * Check for valid credentials and verifiers.
 251    * They could be invalid because the key was flushed
 252    * out of the cache, and so a new session should begin.
 253    * Be sure and send AUTH_REJECTED{CRED, VERF} if this is the case.
 254    */
 255   {
 256     struct timeval current;
 257     int nick;
 258     u_int winverf;
 259
 260     if (cred->adc_namekind == ADN_FULLNAME)
 261       {
 262         short tmp_spot;
 263
 264         window = IXDR_GET_U_INT32 (ixdr);
 265         winverf = IXDR_GET_U_INT32 (ixdr);
 266         if (winverf != window - 1)
 267           {
 268             debug ("window verifier mismatch");
 269             return AUTH_BADCRED;        /* garbled credential */
 270           }
 271         tmp_spot = cache_spot (sessionkey, cred->adc_fullname.name,
 272                                &timestamp);
 273         if (tmp_spot < 0 || tmp_spot > AUTHDES_CACHESZ)
 274           {
 275             debug ("replayed credential");
 276             return AUTH_REJECTEDCRED;           /* replay */
 277           }
 278         sid = tmp_spot;
 279         nick = 0;
 280       }
 281     else
 282       {                         /* ADN_NICKNAME */
 283         window = authdes_cache[sid].window;
 284         nick = 1;
 285       }
 286
 287     if (timestamp.tv_usec >= USEC_PER_SEC)
 288       {
 289         debug ("invalid usecs");
 290         /* cached out (bad key), or garbled verifier */
 291         return nick ? AUTH_REJECTEDVERF : AUTH_BADVERF;
 292       }
 293     if (nick && BEFORE (&timestamp, &authdes_cache[sid].laststamp))
 294       {
 295         debug ("timestamp before last seen");
 296         return AUTH_REJECTEDVERF;       /* replay */
 297       }
 298     __gettimeofday (&current, (struct timezone *) NULL);
 299     current.tv_sec -= window;   /* allow for expiration */
 300     if (!BEFORE (&current, &timestamp))
 301       {
 302         debug ("timestamp expired");
 303         /* replay, or garbled credential */
 304         return nick ? AUTH_REJECTEDVERF : AUTH_BADCRED;
 305       }
 306   }
 307
 308   /*
 309    * Set up the reply verifier
 310    */
 311   verf.adv_nickname = sid;
 312
 313   /*
 314    * xdr the timestamp before encrypting
 315    */
 316   ixdr = (uint32_t *) cryptbuf;
 317   IXDR_PUT_INT32 (ixdr, timestamp.tv_sec - 1);
 318   IXDR_PUT_INT32 (ixdr, timestamp.tv_usec);
 319
 320   /*
 321    * encrypt the timestamp
 322    */
 323   status = ecb_crypt ((char *) sessionkey, (char *) cryptbuf,
 324                       sizeof (des_block), DES_ENCRYPT | DES_HW);
 325   if (DES_FAILED (status))
 326     {
 327       debug ("encryption failure");
 328       return AUTH_FAILED;       /* system error */
 329     }
 330   verf.adv_xtimestamp = cryptbuf[0];
 331
 332   /*
 333    * Serialize the reply verifier, and update rqst
 334    */
 335   ixdr = (uint32_t *) msg->rm_call.cb_verf.oa_base;
 336   *ixdr++ = verf.adv_xtimestamp.key.high;
 337   *ixdr++ = verf.adv_xtimestamp.key.low;
 338   *ixdr++ = verf.adv_int_u;
 339
 340   rqst->rq_xprt->xp_verf.oa_flavor = AUTH_DES;
 341   rqst->rq_xprt->xp_verf.oa_base = msg->rm_call.cb_verf.oa_base;
 342   rqst->rq_xprt->xp_verf.oa_length =
 343     (char *) ixdr - msg->rm_call.cb_verf.oa_base;
 344
 345   /*
 346    * We succeeded, commit the data to the cache now and
 347    * finish cooking the credential.
 348    */
 349   entry = &authdes_cache[sid];
 350   entry->laststamp = timestamp;
 351   cache_ref (sid);
 352   if (cred->adc_namekind == ADN_FULLNAME)
 353     {
 354       size_t full_len;
 355
 356       cred->adc_fullname.window = window;
 357       cred->adc_nickname = sid; /* save nickname */
 358       if (entry->rname != NULL)
 359         mem_free (entry->rname, strlen (entry->rname) + 1);
 360       full_len = strlen (cred->adc_fullname.name) + 1;
 361       entry->rname = mem_alloc ((u_int) full_len);
 362       if (entry->rname != NULL)
 363         memcpy (entry->rname, cred->adc_fullname.name, full_len);
 364       else
 365         {
 366           debug ("out of memory");
 367           return AUTH_FAILED; /* out of memory is bad */
 368         }
 369       entry->key = *sessionkey;
 370       entry->window = window;
 371       invalidate (entry->localcred);    /* mark any cached cred invalid */
 372     }
 373   else
 374     {                           /* ADN_NICKNAME */
 375       /*
 376        * nicknames are cooked into fullnames
 377        */
 378       cred->adc_namekind = ADN_FULLNAME;
 379       cred->adc_fullname.name = entry->rname;
 380       cred->adc_fullname.key = entry->key;
 381       cred->adc_fullname.window = entry->window;
 382     }
 383   return AUTH_OK;               /* we made it! */
 384 }
 385
 386
 387 /*
 388  * Initialize the cache
 389  */
 390 static void
 391 internal_function
 392 cache_init (void)
 393 {
 394   register int i;
 395
 396   authdes_cache = (struct cache_entry *)
 397     calloc (sizeof (struct cache_entry) * AUTHDES_CACHESZ, 1);
 398   if (authdes_cache == NULL)
 399     return;
 400
 401   authdes_lru = (int *) mem_alloc (sizeof (int) * AUTHDES_CACHESZ);
 402   /*
 403    * Initialize the lru list
 404    */
 405   for (i = 0; i < AUTHDES_CACHESZ; ++i)
 406     authdes_lru[i] = i;
 407 }
 408
 409
 410 /*
 411  * Find the lru victim
 412  */
 413 static short
 414 cache_victim (void)
 415 {
 416   return authdes_lru[AUTHDES_CACHESZ - 1];
 417 }
 418
 419 /*
 420  * Note that sid was referenced
 421  */
 422 static void
 423 internal_function
 424 cache_ref (register uint32_t sid)
 425 {
 426   register int i;
 427   register int curr;
 428   register int prev;
 429
 430   prev = authdes_lru[0];
 431   authdes_lru[0] = sid;
 432   for (i = 1; prev != sid; ++i)
 433     {
 434       curr = authdes_lru[i];
 435       authdes_lru[i] = prev;
 436       prev = curr;
 437     }
 438 }
 439
 440 /*
 441  * Find a spot in the cache for a credential containing
 442  * the items given.  Return -1 if a replay is detected, otherwise
 443  * return the spot in the cache.
 444  */
 445 static short
 446 internal_function
 447 cache_spot (register des_block *key, char *name,
 448             struct rpc_timeval *timestamp)
 449 {
 450   register struct cache_entry *cp;
 451   register int i;
 452   register uint32_t hi;
 453
 454   hi = key->key.high;
 455   for (cp = authdes_cache, i = 0; i < AUTHDES_CACHESZ; ++i, ++cp)
 456     {
 457       if (cp->key.key.high == hi &&
 458           cp->key.key.low == key->key.low &&
 459           cp->rname != NULL &&
 460           memcmp (cp->rname, name, strlen (name) + 1) == 0)
 461         {
 462           if (BEFORE (timestamp, &cp->laststamp))
 463             {
 464               ++svcauthdes_stats.ncachereplays;
 465               return -1;        /* replay */
 466             }
 467           ++svcauthdes_stats.ncachehits;
 468           return i;             /* refresh */
 469         }
 470     }
 471   ++svcauthdes_stats.ncachemisses;
 472   return cache_victim ();       /* new credential */
 473 }
 474
 475 /*
 476  * Local credential handling stuff.
 477  * NOTE: bsd unix dependent.
 478  * Other operating systems should put something else here.
 479  */
 480 #define UNKNOWN         -2      /* grouplen, if cached cred is unknown user */
 481 #define INVALID         -1      /* grouplen, if cache entry is invalid */
 482
 483 struct bsdcred
 484 {
 485   uid_t uid;                    /* cached uid */
 486   gid_t gid;                    /* cached gid */
 487   int grouplen;                 /* length of cached groups */
 488   int grouplen_max;             /* length of allocated cached groups */
 489   gid_t groups[0];              /* cached groups */
 490 };
 491
 492 /*
 493  * Map a des credential into a unix cred.
 494  * We cache the credential here so the application does
 495  * not have to make an rpc call every time to interpret
 496  * the credential.
 497  */
 498 int
 499 authdes_getucred (const struct authdes_cred *adc, uid_t * uid, gid_t * gid,
 500                   short *grouplen, gid_t * groups)
 501 {
 502   unsigned sid;
 503   register int i;
 504   uid_t i_uid;
 505   gid_t i_gid;
 506   int i_grouplen;
 507   struct bsdcred *cred;
 508
 509   sid = adc->adc_nickname;
 510   if (sid >= AUTHDES_CACHESZ)
 511     {
 512       debug ("invalid nickname");
 513       return 0;
 514     }
 515   cred = (struct bsdcred *) authdes_cache[sid].localcred;
 516   if (cred == NULL || cred->grouplen == INVALID)
 517     {
 518       /*
 519        * not in cache: lookup
 520        */
 521       if (!netname2user (adc->adc_fullname.name, &i_uid, &i_gid,
 522                          &i_grouplen, groups))
 523         {
 524           debug ("unknown netname");
 525           if (cred != NULL)
 526             cred->grouplen = UNKNOWN;   /* mark as lookup up, but not found */
 527           return 0;
 528         }
 529
 530       if (cred != NULL && cred->grouplen_max < i_grouplen)
 531         {
 532           /* We already have an allocated data structure.  But it is
 533              too small.  */
 534           free (cred);
 535           authdes_cache[sid].localcred = NULL;
 536           cred = NULL;
 537         }
 538
 539       if (cred == NULL)
 540         {
 541           /* We should allocate room for at least NGROUPS groups.  */
 542           int ngroups_max = MAX (i_grouplen, NGROUPS);
 543
 544           cred = (struct bsdcred *) mem_alloc (sizeof (struct bsdcred)
 545                                                + ngroups_max * sizeof (gid_t));
 546           if (cred == NULL)
 547             return 0;
 548
 549           authdes_cache[sid].localcred = (char *) cred;
 550           cred->grouplen = INVALID;
 551           cred->grouplen_max = ngroups_max;
 552         }
 553
 554       debug ("missed ucred cache");
 555       *uid = cred->uid = i_uid;
 556       *gid = cred->gid = i_gid;
 557       cred->grouplen = i_grouplen;
 558       for (i = i_grouplen - 1; i >= 0; --i)
 559         cred->groups[i] = groups[i];
 560       /* Make sure no too large values are reported.  */
 561       *grouplen = MIN (SHRT_MAX, i_grouplen);
 562       return 1;
 563     }
 564   else if (cred->grouplen == UNKNOWN)
 565     {
 566       /*
 567        * Already lookup up, but no match found
 568        */
 569       return 0;
 570     }
 571
 572   /*
 573    * cached credentials
 574    */
 575   *uid = cred->uid;
 576   *gid = cred->gid;
 577
 578   /* Another stupidity in the interface: *grouplen is of type short.
 579      So we might have to cut the information passed up short.  */
 580   int grouplen_copy = MIN (SHRT_MAX, cred->grouplen);
 581   *grouplen = grouplen_copy;
 582   for (i = grouplen_copy - 1; i >= 0; --i)
 583     groups[i] = cred->groups[i];
 584   return 1;
 585 }
 586 libc_hidden_nolink (authdes_getucred, GLIBC_2_1)
 587
 588 static void
 589 internal_function
 590 invalidate (char *cred)
 591 {
 592   if (cred == NULL)
 593     return;
 594   ((struct bsdcred *) cred)->grouplen = INVALID;
 595 }