sunrpc/auth_unix.c

   1 /* @(#)auth_unix.c      2.2 88/08/01 4.0 RPCSRC */
   2 /*
   3  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
   4  * unrestricted use provided that this legend is included on all tape
   5  * media and as a part of the software program in whole or part.  Users
   6  * may copy or modify Sun RPC without charge, but are not authorized
   7  * to license or distribute it to anyone else except as part of a product or
   8  * program developed by the user.
   9  *
  10  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  11  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  12  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  13  *
  14  * Sun RPC is provided with no support and without any obligation on the
  15  * part of Sun Microsystems, Inc. to assist in its use, correction,
  16  * modification or enhancement.
  17  *
  18  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  19  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  20  * OR ANY PART THEREOF.
  21  *
  22  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  23  * or profits or other special, indirect and consequential damages, even if
  24  * Sun has been advised of the possibility of such damages.
  25  *
  26  * Sun Microsystems, Inc.
  27  * 2550 Garcia Avenue
  28  * Mountain View, California  94043
  29  */
  30 #if !defined(lint) && defined(SCCSIDS)
  31 static char sccsid[] = "@(#)auth_unix.c 1.19 87/08/11 Copyr 1984 Sun Micro";
  32 #endif
  33
  34 /*
  35  * auth_unix.c, Implements UNIX style authentication parameters.
  36  *
  37  * Copyright (C) 1984, Sun Microsystems, Inc.
  38  *
  39  * The system is very weak.  The client uses no encryption for it's
  40  * credentials and only sends null verifiers.  The server sends backs
  41  * null verifiers or optionally a verifier that suggests a new short hand
  42  * for the credentials.
  43  *
  44  */
  45
  46 #include <limits.h>
  47 #include <stdio.h>
  48 #include <string.h>
  49 #include <unistd.h>
  50 #include <sys/param.h>
  51
  52 #include <rpc/types.h>
  53 #include <rpc/xdr.h>
  54 #include <rpc/auth.h>
  55 #include <rpc/auth_unix.h>
  56
  57 /*
  58  * Unix authenticator operations vector
  59  */
  60 static void authunix_nextverf (AUTH *);
  61 static bool_t authunix_marshal (AUTH *, XDR *);
  62 static bool_t authunix_validate (AUTH *, struct opaque_auth *);
  63 static bool_t authunix_refresh (AUTH *);
  64 static void authunix_destroy (AUTH *);
  65
  66 static struct auth_ops auth_unix_ops =
  67 {
  68   authunix_nextverf,
  69   authunix_marshal,
  70   authunix_validate,
  71   authunix_refresh,
  72   authunix_destroy
  73 };
  74
  75 /*
  76  * This struct is pointed to by the ah_private field of an auth_handle.
  77  */
  78 struct audata
  79   {
  80     struct opaque_auth au_origcred;     /* original credentials */
  81     struct opaque_auth au_shcred;       /* short hand cred */
  82     u_long au_shfaults;         /* short hand cache faults */
  83     char au_marshed[MAX_AUTH_BYTES];
  84     u_int au_mpos;              /* xdr pos at end of marshed */
  85   };
  86 #define AUTH_PRIVATE(auth)      ((struct audata *)auth->ah_private)
  87
  88 static bool_t marshal_new_auth (AUTH *) internal_function;
  89
  90
  91 /*
  92  * Create a unix style authenticator.
  93  * Returns an auth handle with the given stuff in it.
  94  */
  95 AUTH *
  96 authunix_create (machname, uid, gid, len, aup_gids)
  97      char *machname;
  98      uid_t uid;
  99      gid_t gid;
 100      int len;
 101      gid_t *aup_gids;
 102 {
 103   struct authunix_parms aup;
 104   char mymem[MAX_AUTH_BYTES];
 105   struct timeval now;
 106   XDR xdrs;
 107   AUTH *auth;
 108   struct audata *au;
 109
 110   /*
 111    * Allocate and set up auth handle
 112    */
 113   auth = (AUTH *) mem_alloc (sizeof (*auth));
 114   if (auth == NULL)
 115     {
 116       (void) fprintf (stderr, _("authunix_create: out of memory\n"));
 117       return NULL;
 118     }
 119   au = (struct audata *) mem_alloc (sizeof (*au));
 120   if (au == NULL)
 121     {
 122       (void) fprintf (stderr, _("authunix_create: out of memory\n"));
 123       return NULL;
 124     }
 125   auth->ah_ops = &auth_unix_ops;
 126   auth->ah_private = (caddr_t) au;
 127   auth->ah_verf = au->au_shcred = _null_auth;
 128   au->au_shfaults = 0;
 129
 130   /*
 131    * fill in param struct from the given params
 132    */
 133   (void) gettimeofday (&now, (struct timezone *) 0);
 134   aup.aup_time = now.tv_sec;
 135   aup.aup_machname = machname;
 136   aup.aup_uid = uid;
 137   aup.aup_gid = gid;
 138   aup.aup_len = (u_int) len;
 139   aup.aup_gids = aup_gids;
 140
 141   /*
 142    * Serialize the parameters into origcred
 143    */
 144   xdrmem_create (&xdrs, mymem, MAX_AUTH_BYTES, XDR_ENCODE);
 145   if (!xdr_authunix_parms (&xdrs, &aup))
 146     abort ();
 147   au->au_origcred.oa_length = len = XDR_GETPOS (&xdrs);
 148   au->au_origcred.oa_flavor = AUTH_UNIX;
 149   if ((au->au_origcred.oa_base = mem_alloc ((u_int) len)) == NULL)
 150     {
 151       (void) fprintf (stderr, _("authunix_create: out of memory\n"));
 152       return NULL;
 153     }
 154   bcopy (mymem, au->au_origcred.oa_base, (u_int) len);
 155
 156   /*
 157    * set auth handle to reflect new cred.
 158    */
 159   auth->ah_cred = au->au_origcred;
 160   marshal_new_auth (auth);
 161   return auth;
 162 }
 163
 164 /*
 165  * Returns an auth handle with parameters determined by doing lots of
 166  * syscalls.
 167  */
 168 AUTH *
 169 authunix_create_default (void)
 170 {
 171   int len;
 172   char machname[MAX_MACHINE_NAME + 1];
 173   uid_t uid;
 174   gid_t gid;
 175   int max_nr_groups = sysconf (_SC_NGROUPS_MAX);
 176   gid_t gids[max_nr_groups];
 177
 178   if (gethostname (machname, MAX_MACHINE_NAME) == -1)
 179     abort ();
 180   machname[MAX_MACHINE_NAME] = 0;
 181   uid = geteuid ();
 182   gid = getegid ();
 183
 184   if ((len = getgroups (max_nr_groups, gids)) < 0)
 185     abort ();
 186   /* This braindamaged Sun code forces us here to truncate the
 187      list of groups to NGRPS members since the code in
 188      authuxprot.c transforms a fixed array.  Grrr.  */
 189   return authunix_create (machname, uid, gid, MIN (NGRPS, len), gids);
 190 }
 191
 192 /*
 193  * authunix operations
 194  */
 195
 196 static void
 197 authunix_nextverf (AUTH *auth)
 198 {
 199   /* no action necessary */
 200 }
 201
 202 static bool_t
 203 authunix_marshal (AUTH *auth, XDR *xdrs)
 204 {
 205   struct audata *au = AUTH_PRIVATE (auth);
 206
 207   return XDR_PUTBYTES (xdrs, au->au_marshed, au->au_mpos);
 208 }
 209
 210 static bool_t
 211 authunix_validate (AUTH *auth, struct opaque_auth *verf)
 212 {
 213   struct audata *au;
 214   XDR xdrs;
 215
 216   if (verf->oa_flavor == AUTH_SHORT)
 217     {
 218       au = AUTH_PRIVATE (auth);
 219       xdrmem_create (&xdrs, verf->oa_base, verf->oa_length,
 220                      XDR_DECODE);
 221
 222       if (au->au_shcred.oa_base != NULL)
 223         {
 224           mem_free (au->au_shcred.oa_base,
 225                     au->au_shcred.oa_length);
 226           au->au_shcred.oa_base = NULL;
 227         }
 228       if (xdr_opaque_auth (&xdrs, &au->au_shcred))
 229         {
 230           auth->ah_cred = au->au_shcred;
 231         }
 232       else
 233         {
 234           xdrs.x_op = XDR_FREE;
 235           (void) xdr_opaque_auth (&xdrs, &au->au_shcred);
 236           au->au_shcred.oa_base = NULL;
 237           auth->ah_cred = au->au_origcred;
 238         }
 239       marshal_new_auth (auth);
 240     }
 241   return TRUE;
 242 }
 243
 244 static bool_t
 245 authunix_refresh (AUTH *auth)
 246 {
 247   struct audata *au = AUTH_PRIVATE (auth);
 248   struct authunix_parms aup;
 249   struct timeval now;
 250   XDR xdrs;
 251   int stat;
 252
 253   if (auth->ah_cred.oa_base == au->au_origcred.oa_base)
 254     {
 255       /* there is no hope.  Punt */
 256       return FALSE;
 257     }
 258   au->au_shfaults++;
 259
 260   /* first deserialize the creds back into a struct authunix_parms */
 261   aup.aup_machname = NULL;
 262   aup.aup_gids = (gid_t *) NULL;
 263   xdrmem_create (&xdrs, au->au_origcred.oa_base,
 264                  au->au_origcred.oa_length, XDR_DECODE);
 265   stat = xdr_authunix_parms (&xdrs, &aup);
 266   if (!stat)
 267     goto done;
 268
 269   /* update the time and serialize in place */
 270   (void) gettimeofday (&now, (struct timezone *) 0);
 271   aup.aup_time = now.tv_sec;
 272   xdrs.x_op = XDR_ENCODE;
 273   XDR_SETPOS (&xdrs, 0);
 274   stat = xdr_authunix_parms (&xdrs, &aup);
 275   if (!stat)
 276     goto done;
 277   auth->ah_cred = au->au_origcred;
 278   marshal_new_auth (auth);
 279 done:
 280   /* free the struct authunix_parms created by deserializing */
 281   xdrs.x_op = XDR_FREE;
 282   (void) xdr_authunix_parms (&xdrs, &aup);
 283   XDR_DESTROY (&xdrs);
 284   return stat;
 285 }
 286
 287 static void
 288 authunix_destroy (AUTH *auth)
 289 {
 290   struct audata *au = AUTH_PRIVATE (auth);
 291
 292   mem_free (au->au_origcred.oa_base, au->au_origcred.oa_length);
 293
 294   if (au->au_shcred.oa_base != NULL)
 295     mem_free (au->au_shcred.oa_base, au->au_shcred.oa_length);
 296
 297   mem_free (auth->ah_private, sizeof (struct audata));
 298
 299   if (auth->ah_verf.oa_base != NULL)
 300     mem_free (auth->ah_verf.oa_base, auth->ah_verf.oa_length);
 301
 302   mem_free ((caddr_t) auth, sizeof (*auth));
 303 }
 304
 305 /*
 306  * Marshals (pre-serializes) an auth struct.
 307  * sets private data, au_marshed and au_mpos
 308  */
 309 static bool_t
 310 internal_function
 311 marshal_new_auth (AUTH *auth)
 312 {
 313   XDR xdr_stream;
 314   XDR *xdrs = &xdr_stream;
 315   struct audata *au = AUTH_PRIVATE (auth);
 316
 317   xdrmem_create (xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
 318   if ((!xdr_opaque_auth (xdrs, &(auth->ah_cred))) ||
 319       (!xdr_opaque_auth (xdrs, &(auth->ah_verf))))
 320     {
 321       perror (_("auth_none.c - Fatal marshalling problem"));
 322     }
 323   else
 324     {
 325       au->au_mpos = XDR_GETPOS (xdrs);
 326     }
 327   XDR_DESTROY (xdrs);
 328
 329   return TRUE;
 330 }