reactos/dll/win32/libtirpc/src/auth_unix.c

   1 /*
   2  * Copyright (c) 2009, Sun Microsystems, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  * - Redistributions of source code must retain the above copyright notice,
   8  *   this list of conditions and the following disclaimer.
   9  * - Redistributions in binary form must reproduce the above copyright notice,
  10  *   this list of conditions and the following disclaimer in the documentation
  11  *   and/or other materials provided with the distribution.
  12  * - Neither the name of Sun Microsystems, Inc. nor the names of its
  13  *   contributors may be used to endorse or promote products derived
  14  *   from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 //#include <sys/cdefs.h>
  30
  31 /*
  32  * auth_unix.c, Implements UNIX style authentication parameters.
  33  *
  34  * Copyright (C) 1984, Sun Microsystems, Inc.
  35  *
  36  * The system is very weak.  The client uses no encryption for it's
  37  * credentials and only sends null verifiers.  The server sends backs
  38  * null verifiers or optionally a verifier that suggests a new short hand
  39  * for the credentials.
  40  *
  41  */
  42
  43 /* NFSv4.1 client for Windows
  44  * Copyright © 2012 The Regents of the University of Michigan
  45  *
  46  * Olga Kornievskaia <aglo@umich.edu>
  47  * Casey Bodley <cbodley@umich.edu>
  48  *
  49  * This library is free software; you can redistribute it and/or modify it
  50  * under the terms of the GNU Lesser General Public License as published by
  51  * the Free Software Foundation; either version 2.1 of the License, or (at
  52  * your option) any later version.
  53  *
  54  * This library is distributed in the hope that it will be useful, but
  55  * without any warranty; without even the implied warranty of merchantability
  56  * or fitness for a particular purpose.  See the GNU Lesser General Public
  57  * License for more details.
  58  *
  59  * You should have received a copy of the GNU Lesser General Public License
  60  * along with this library; if not, write to the Free Software Foundation,
  61  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  62  */
  63
  64 #include <wintirpc.h>
  65 //#include <pthread.h>
  66 #include <reentrant.h>
  67 //#include <sys/param.h>
  68
  69 #include <assert.h>
  70 //#include <err.h>
  71 #include <stdio.h>
  72 #include <stdlib.h>
  73 //#include <unistd.h>
  74 #include <string.h>
  75
  76 #include <rpc/types.h>
  77 #include <rpc/xdr.h>
  78 #include <rpc/auth.h>
  79 #include <rpc/auth_unix.h>
  80
  81 /* auth_unix.c */
  82 static void authunix_nextverf (AUTH *);
  83 static bool_t authunix_marshal (AUTH *, XDR *, u_int *seq);
  84 static bool_t authunix_validate (AUTH *, struct opaque_auth *, u_int);
  85 static bool_t authunix_refresh (AUTH *, void *);
  86 static void authunix_destroy (AUTH *);
  87 static void marshal_new_auth (AUTH *);
  88 static struct auth_ops *authunix_ops (void);
  89
  90 /*
  91  * This struct is pointed to by the ah_private field of an auth_handle.
  92  */
  93 struct audata {
  94         struct opaque_auth      au_origcred;    /* original credentials */
  95         struct opaque_auth      au_shcred;      /* short hand cred */
  96         u_long                  au_shfaults;    /* short hand cache faults */
  97         char                    au_marshed[MAX_AUTH_BYTES];
  98         u_int                   au_mpos;        /* xdr pos at end of marshed */
  99 };
 100 #define AUTH_PRIVATE(auth)      ((struct audata *)auth->ah_private)
 101
 102 /*
 103  * Create a unix style authenticator.
 104  * Returns an auth handle with the given stuff in it.
 105  */
 106 AUTH *
 107 authunix_create(machname, uid, gid, len, aup_gids)
 108         char *machname;
 109         uid_t uid;
 110         gid_t gid;
 111         int len;
 112         gid_t *aup_gids;
 113 {
 114         struct authunix_parms aup;
 115         char mymem[MAX_AUTH_BYTES];
 116         struct timeval now;
 117         XDR xdrs;
 118         AUTH *auth;
 119         struct audata *au;
 120
 121         /*
 122          * Allocate and set up auth handle
 123          */
 124         au = NULL;
 125         auth = mem_alloc(sizeof(*auth));
 126 #ifndef _KERNEL
 127         if (auth == NULL) {
 128                 // XXX warnx("authunix_create: out of memory");
 129                 goto cleanup_authunix_create;
 130         }
 131 #endif
 132         au = mem_alloc(sizeof(*au));
 133 #ifndef _KERNEL
 134         if (au == NULL) {
 135                 // XXX warnx("authunix_create: out of memory");
 136                 goto cleanup_authunix_create;
 137         }
 138 #endif
 139         auth->ah_ops = authunix_ops();
 140         auth->ah_private = (caddr_t)au;
 141         auth->ah_verf = au->au_shcred = _null_auth;
 142         au->au_shfaults = 0;
 143         au->au_origcred.oa_base = NULL;
 144
 145         /*
 146          * fill in param struct from the given params
 147          */
 148         (void)gettimeofday(&now, NULL);
 149         aup.aup_time = now.tv_sec;
 150         aup.aup_machname = machname;
 151         aup.aup_uid = uid;
 152         aup.aup_gid = gid;
 153         aup.aup_len = (u_int)len;
 154         aup.aup_gids = aup_gids;
 155
 156         /*
 157          * Serialize the parameters into origcred
 158          */
 159         xdrmem_create(&xdrs, mymem, MAX_AUTH_BYTES, XDR_ENCODE);
 160         if (! xdr_authunix_parms(&xdrs, &aup))
 161                 abort();
 162         au->au_origcred.oa_length = len = XDR_GETPOS(&xdrs);
 163         au->au_origcred.oa_flavor = AUTH_UNIX;
 164 #ifdef _KERNEL
 165         au->au_origcred.oa_base = mem_alloc((u_int) len);
 166 #else
 167         if ((au->au_origcred.oa_base = mem_alloc((u_int) len)) == NULL) {
 168                 // XXX warnx("authunix_create: out of memory");
 169                 goto cleanup_authunix_create;
 170         }
 171 #endif
 172         memmove(au->au_origcred.oa_base, mymem, (size_t)len);
 173
 174         /*
 175          * set auth handle to reflect new cred.
 176          */
 177         auth->ah_cred = au->au_origcred;
 178         marshal_new_auth(auth);
 179         return (auth);
 180 #ifndef _KERNEL
 181  cleanup_authunix_create:
 182         if (auth)
 183                 mem_free(auth, sizeof(*auth));
 184         if (au) {
 185                 if (au->au_origcred.oa_base)
 186                         mem_free(au->au_origcred.oa_base, (u_int)len);
 187                 mem_free(au, sizeof(*au));
 188         }
 189         return (NULL);
 190 #endif
 191 }
 192
 193 /*
 194  * Returns an auth handle with parameters determined by doing lots of
 195  * syscalls.
 196  */
 197 AUTH *
 198 authunix_create_default()
 199 {
 200         int len;
 201         char machname[MAXHOSTNAMELEN + 1];
 202         uid_t uid;
 203         gid_t gid;
 204         gid_t gids[NGRPS];
 205
 206         if (gethostname(machname, sizeof machname) == -1)
 207                 abort();
 208         machname[sizeof(machname) - 1] = 0;
 209 #if 0
 210         uid = geteuid();
 211         gid = getegid();
 212         if ((len = getgroups(NGRPS, gids)) < 0)
 213                 abort();
 214 #else
 215         // XXX Need to figure out what to do here!
 216         uid = 666;
 217         gid = 777;
 218         gids[0] = 0;
 219         len = 0;
 220 #endif
 221         /* XXX: interface problem; those should all have been unsigned */
 222         return (authunix_create(machname, uid, gid, len, gids));
 223 }
 224
 225 /*
 226  * authunix operations
 227  */
 228
 229 /* ARGSUSED */
 230 static void
 231 authunix_nextverf(auth)
 232         AUTH *auth;
 233 {
 234         /* no action necessary */
 235 }
 236
 237 static bool_t
 238 authunix_marshal(auth, xdrs, seq)
 239         AUTH *auth;
 240         XDR *xdrs;
 241     u_int *seq;
 242 {
 243         struct audata *au;
 244
 245         assert(auth != NULL);
 246         assert(xdrs != NULL);
 247
 248         au = AUTH_PRIVATE(auth);
 249         return (XDR_PUTBYTES(xdrs, au->au_marshed, au->au_mpos));
 250 }
 251
 252 static bool_t
 253 authunix_validate(auth, verf, seq)
 254         AUTH *auth;
 255         struct opaque_auth *verf;
 256     u_int seq;
 257 {
 258         struct audata *au;
 259         XDR xdrs;
 260
 261         assert(auth != NULL);
 262         assert(verf != NULL);
 263
 264         if (verf->oa_flavor == AUTH_SHORT) {
 265                 au = AUTH_PRIVATE(auth);
 266                 xdrmem_create(&xdrs, verf->oa_base, verf->oa_length,
 267                     XDR_DECODE);
 268
 269                 if (au->au_shcred.oa_base != NULL) {
 270                         mem_free(au->au_shcred.oa_base,
 271                             au->au_shcred.oa_length);
 272                         au->au_shcred.oa_base = NULL;
 273                 }
 274                 if (xdr_opaque_auth(&xdrs, &au->au_shcred)) {
 275                         auth->ah_cred = au->au_shcred;
 276                 } else {
 277                         xdrs.x_op = XDR_FREE;
 278                         (void)xdr_opaque_auth(&xdrs, &au->au_shcred);
 279                         au->au_shcred.oa_base = NULL;
 280                         auth->ah_cred = au->au_origcred;
 281                 }
 282                 marshal_new_auth(auth);
 283         }
 284         return (TRUE);
 285 }
 286
 287 static bool_t
 288 authunix_refresh(AUTH *auth, void *dummy)
 289 {
 290         struct audata *au = AUTH_PRIVATE(auth);
 291         struct authunix_parms aup;
 292         struct timeval now;
 293         XDR xdrs;
 294         int stat;
 295
 296         assert(auth != NULL);
 297
 298         if (auth->ah_cred.oa_base == au->au_origcred.oa_base) {
 299                 /* there is no hope.  Punt */
 300                 return (FALSE);
 301         }
 302         au->au_shfaults ++;
 303
 304         /* first deserialize the creds back into a struct authunix_parms */
 305         aup.aup_machname = NULL;
 306         aup.aup_gids = NULL;
 307         xdrmem_create(&xdrs, au->au_origcred.oa_base,
 308             au->au_origcred.oa_length, XDR_DECODE);
 309         stat = xdr_authunix_parms(&xdrs, &aup);
 310         if (! stat)
 311                 goto done;
 312
 313         /* update the time and serialize in place */
 314         (void)gettimeofday(&now, NULL);
 315         aup.aup_time = now.tv_sec;
 316         xdrs.x_op = XDR_ENCODE;
 317         XDR_SETPOS(&xdrs, 0);
 318         stat = xdr_authunix_parms(&xdrs, &aup);
 319         if (! stat)
 320                 goto done;
 321         auth->ah_cred = au->au_origcred;
 322         marshal_new_auth(auth);
 323 done:
 324         /* free the struct authunix_parms created by deserializing */
 325         xdrs.x_op = XDR_FREE;
 326         (void)xdr_authunix_parms(&xdrs, &aup);
 327         XDR_DESTROY(&xdrs);
 328         return (stat);
 329 }
 330
 331 static void
 332 authunix_destroy(auth)
 333         AUTH *auth;
 334 {
 335         struct audata *au;
 336
 337         assert(auth != NULL);
 338
 339         au = AUTH_PRIVATE(auth);
 340         mem_free(au->au_origcred.oa_base, au->au_origcred.oa_length);
 341
 342         if (au->au_shcred.oa_base != NULL)
 343                 mem_free(au->au_shcred.oa_base, au->au_shcred.oa_length);
 344
 345         mem_free(auth->ah_private, sizeof(struct audata));
 346
 347         if (auth->ah_verf.oa_base != NULL)
 348                 mem_free(auth->ah_verf.oa_base, auth->ah_verf.oa_length);
 349
 350         mem_free(auth, sizeof(*auth));
 351 }
 352
 353 /*
 354  * Marshals (pre-serializes) an auth struct.
 355  * sets private data, au_marshed and au_mpos
 356  */
 357 static void
 358 marshal_new_auth(auth)
 359         AUTH *auth;
 360 {
 361         XDR     xdr_stream;
 362         XDR     *xdrs = &xdr_stream;
 363         struct audata *au;
 364
 365         assert(auth != NULL);
 366
 367         au = AUTH_PRIVATE(auth);
 368         xdrmem_create(xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
 369         if ((! xdr_opaque_auth(xdrs, &(auth->ah_cred))) ||
 370             (! xdr_opaque_auth(xdrs, &(auth->ah_verf))))
 371                 assert(0); // XXX
 372                 // XXX warnx("auth_none.c - Fatal marshalling problem");
 373         else
 374                 au->au_mpos = XDR_GETPOS(xdrs);
 375         XDR_DESTROY(xdrs);
 376 }
 377
 378 static bool_t
 379 #ifndef __REACTOS__
 380 authunix_wrap(AUTH *auth, XDR *xdrs, xdrproc_t func, caddr_t args, u_int seq)
 381 #else
 382 authunix_wrap(AUTH *auth, XDR *xdrs, xdrproc_t func, caddr_t args)
 383 #endif
 384 {
 385     return ((*func)(xdrs, args));
 386 }
 387 #ifdef __REACTOS__
 388 static bool_t
 389 authunix_unwrap(AUTH *auth, XDR *xdrs, xdrproc_t func, caddr_t args, u_int seq)
 390 {
 391     return ((*func)(xdrs, args));
 392 }
 393 #endif
 394
 395 static struct auth_ops *
 396 authunix_ops()
 397 {
 398         static struct auth_ops ops;
 399         extern mutex_t ops_lock;
 400
 401         /* VARIABLES PROTECTED BY ops_lock: ops */
 402
 403         mutex_lock(&ops_lock);
 404         if (ops.ah_nextverf == NULL) {
 405                 ops.ah_nextverf = authunix_nextverf;
 406                 ops.ah_marshal = authunix_marshal;
 407                 ops.ah_validate = authunix_validate;
 408                 ops.ah_refresh = authunix_refresh;
 409                 ops.ah_destroy = authunix_destroy;
 410                 ops.ah_wrap = authunix_wrap;
 411 #ifndef __REACTOS__
 412                 ops.ah_unwrap = authunix_wrap;
 413 #else
 414                 ops.ah_unwrap = authunix_unwrap;
 415 #endif
 416         }
 417         mutex_unlock(&ops_lock);
 418         return (&ops);
 419 }