/*      $NetBSD: auth_unix.c,v 1.28 2024/01/23 17:24:38 christos Exp $  */

/*
* Copyright (c) 2010, Oracle America, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
*     * Redistributions of source code must retain the above copyright
*       notice, this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above
*       copyright notice, this list of conditions and the following
*       disclaimer in the documentation and/or other materials
*       provided with the distribution.
*     * Neither the name of the "Oracle America, Inc." nor the names of its
*       contributors may be used to endorse or promote products derived
*       from this software without specific prior written permission.
*
*   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
*   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
*   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
*   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
*   COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
*   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
*   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
*   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
*   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
*   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
*   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
*   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
#if defined(LIBC_SCCS) && !defined(lint)
#if 0
static char *sccsid = "@(#)auth_unix.c 1.19 87/08/11 Copyr 1984 Sun Micro";
static char *sccsid = "@(#)auth_unix.c  2.2 88/08/01 4.0 RPCSRC";
#else
__RCSID("$NetBSD: auth_unix.c,v 1.28 2024/01/23 17:24:38 christos Exp $");
#endif
#endif

/*
* auth_unix.c, Implements UNIX style authentication parameters.
*
* Copyright (C) 1984, Sun Microsystems, Inc.
*
* The system is very weak.  The client uses no encryption for its
* credentials and only sends null verifiers.  The server sends backs
* null verifiers or optionally a verifier that suggests a new short hand
* for the credentials.
*
*/

#include "namespace.h"
#include "reentrant.h"
#include <sys/param.h>

#include <assert.h>
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <rpc/types.h>
#include <rpc/xdr.h>
#include <rpc/rpc.h>
#include <rpc/auth.h>
#include <rpc/auth_unix.h>

#include "rpc_internal.h"

#ifdef __weak_alias
__weak_alias(authunix_create,_authunix_create)
__weak_alias(authunix_create_default,_authunix_create_default)
#endif


/* auth_unix.c */
static void authunix_nextverf(AUTH *);
static bool_t authunix_marshal(AUTH *, XDR *);
static bool_t authunix_validate(AUTH *, struct opaque_auth *);
static bool_t authunix_refresh(AUTH *);
static void authunix_destroy(AUTH *);
static void marshal_new_auth(AUTH *);
static const struct auth_ops *authunix_ops(void);

/*
* This struct is pointed to by the ah_private field of an auth_handle.
*/
struct audata {
       struct opaque_auth      au_origcred;    /* original credentials */
       struct opaque_auth      au_shcred;      /* short hand cred */
       u_long                  au_shfaults;    /* short hand cache faults */
       char                    au_marshed[MAX_AUTH_BYTES];
       u_int                   au_mpos;        /* xdr pos at end of marshed */
};
#define AUTH_PRIVATE(auth)      ((struct audata *)auth->ah_private)

/*
* Create a unix style authenticator.
* Returns an auth handle with the given stuff in it.
*/
AUTH *
authunix_create(char *machname, int uid, int gid, int len, int *aup_gids)
{
       struct authunix_parms aup;
       char mymem[MAX_AUTH_BYTES];
       struct timeval now;
       XDR xdrs;
       AUTH *auth;
       struct audata *au;

       /*
        * Allocate and set up auth handle
        */
       au = NULL;
       auth = mem_alloc(sizeof(*auth));
#ifndef KERNEL
       if (auth == NULL) {
               warn("%s: out of memory", __func__);
               goto cleanup_authunix_create;
       }
#endif
       au = mem_alloc(sizeof(*au));
#ifndef KERNEL
       if (au == NULL) {
               warn("%s: out of memory", __func__);
               goto cleanup_authunix_create;
       }
#endif
       auth->ah_ops = authunix_ops();
       auth->ah_private = au;
       auth->ah_verf = au->au_shcred = _null_auth;
       au->au_shfaults = 0;
       au->au_origcred.oa_base = NULL;

       /*
        * fill in param struct from the given params
        */
       (void)gettimeofday(&now, NULL);
       aup.aup_time = (u_long)now.tv_sec;      /* XXX: truncate on 32 bit */
       aup.aup_machname = machname;
       aup.aup_uid = uid;
       aup.aup_gid = gid;
       aup.aup_len = (u_int)len;
       aup.aup_gids = aup_gids;

       /*
        * Serialize the parameters into origcred
        */
       xdrmem_create(&xdrs, mymem, MAX_AUTH_BYTES, XDR_ENCODE);
       if (! xdr_authunix_parms(&xdrs, &aup))
               abort();
       au->au_origcred.oa_length = len = XDR_GETPOS(&xdrs);
       au->au_origcred.oa_flavor = AUTH_UNIX;
#ifdef KERNEL
       au->au_origcred.oa_base = mem_alloc((size_t)len);
#else
       if ((au->au_origcred.oa_base = mem_alloc((size_t)len)) == NULL) {
               warn("%s: out of memory", __func__);
               goto cleanup_authunix_create;
       }
#endif
       memmove(au->au_origcred.oa_base, mymem, (size_t)len);

       /*
        * set auth handle to reflect new cred.
        */
       auth->ah_cred = au->au_origcred;
       marshal_new_auth(auth);
       return (auth);
#ifndef KERNEL
cleanup_authunix_create:
       if (auth)
               mem_free(auth, sizeof(*auth));
       if (au) {
               if (au->au_origcred.oa_base)
                       mem_free(au->au_origcred.oa_base, (u_int)len);
               mem_free(au, sizeof(*au));
       }
       return (NULL);
#endif
}

/*
* Some servers will refuse mounts if the group list is larger
* than it expects (like 8). This allows the application to set
* the maximum size of the group list that will be sent.
*/
static int maxgrplist = NGROUPS;

void
set_rpc_maxgrouplist(int num)
{
       if (num < NGROUPS)
               maxgrplist = num;
}

/*
* Returns an auth handle with parameters determined by doing lots of
* syscalls.
*/
AUTH *
authunix_create_default(void)
{
       int len;
       char machname[MAXHOSTNAMELEN + 1];
       uid_t uid;
       gid_t gid;
       gid_t gids[NGRPS];

       if (gethostname(machname, sizeof machname) == -1)
               abort();
       machname[sizeof(machname) - 1] = 0;
       uid = geteuid();
       gid = getegid();
       if ((len = getgroups(NGRPS, gids)) < 0)
               abort();
       if (len > maxgrplist)
               len = maxgrplist;
       /* XXX: interface problem; those should all have been unsigned */
       return (authunix_create(machname, (int)uid, (int)gid, len,
           (int *)gids));
}

/*
* authunix operations
*/

/* ARGSUSED */
static void
authunix_nextverf(AUTH *auth)
{
       /* no action necessary */
}

static bool_t
authunix_marshal(AUTH *auth, XDR *xdrs)
{
       struct audata *au;

       _DIAGASSERT(auth != NULL);
       _DIAGASSERT(xdrs != NULL);

       au = AUTH_PRIVATE(auth);
       return (XDR_PUTBYTES(xdrs, au->au_marshed, au->au_mpos));
}

static bool_t
authunix_validate(AUTH *auth, struct opaque_auth *verf)
{
       struct audata *au;
       XDR xdrs;

       _DIAGASSERT(auth != NULL);
       _DIAGASSERT(verf != NULL);

       if (verf->oa_flavor == AUTH_SHORT) {
               au = AUTH_PRIVATE(auth);
               xdrmem_create(&xdrs, verf->oa_base, verf->oa_length,
                   XDR_DECODE);

               if (au->au_shcred.oa_base != NULL) {
                       mem_free(au->au_shcred.oa_base,
                           au->au_shcred.oa_length);
                       au->au_shcred.oa_base = NULL;
               }
               if (xdr_opaque_auth(&xdrs, &au->au_shcred)) {
                       auth->ah_cred = au->au_shcred;
               } else {
                       xdrs.x_op = XDR_FREE;
                       (void)xdr_opaque_auth(&xdrs, &au->au_shcred);
                       au->au_shcred.oa_base = NULL;
                       auth->ah_cred = au->au_origcred;
               }
               marshal_new_auth(auth);
       }
       return (TRUE);
}

static bool_t
authunix_refresh(AUTH *auth)
{
       struct audata *au = AUTH_PRIVATE(auth);
       struct authunix_parms aup;
       struct timeval now;
       XDR xdrs;
       int stat;

       _DIAGASSERT(auth != NULL);

       if (auth->ah_cred.oa_base == au->au_origcred.oa_base) {
               /* there is no hope.  Punt */
               return (FALSE);
       }
       au->au_shfaults++;

       /* first deserialize the creds back into a struct authunix_parms */
       aup.aup_machname = NULL;
       aup.aup_gids = NULL;
       xdrmem_create(&xdrs, au->au_origcred.oa_base,
           au->au_origcred.oa_length, XDR_DECODE);
       stat = xdr_authunix_parms(&xdrs, &aup);
       if (! stat)
               goto done;

       /* update the time and serialize in place */
       (void)gettimeofday(&now, NULL);
       aup.aup_time = (u_long)now.tv_sec;      /* XXX: truncate on 32 bit */
       xdrs.x_op = XDR_ENCODE;
       XDR_SETPOS(&xdrs, 0);
       stat = xdr_authunix_parms(&xdrs, &aup);
       if (! stat)
               goto done;
       auth->ah_cred = au->au_origcred;
       marshal_new_auth(auth);
done:
       /* free the struct authunix_parms created by deserializing */
       xdrs.x_op = XDR_FREE;
       (void)xdr_authunix_parms(&xdrs, &aup);
       XDR_DESTROY(&xdrs);
       return (stat);
}

static void
authunix_destroy(AUTH *auth)
{
       struct audata *au;

       _DIAGASSERT(auth != NULL);

       au = AUTH_PRIVATE(auth);
       mem_free(au->au_origcred.oa_base, au->au_origcred.oa_length);

       if (au->au_shcred.oa_base != NULL)
               mem_free(au->au_shcred.oa_base, au->au_shcred.oa_length);

       mem_free(auth->ah_private, sizeof(struct audata));

       if (auth->ah_verf.oa_base != NULL)
               mem_free(auth->ah_verf.oa_base, auth->ah_verf.oa_length);

       mem_free(auth, sizeof(*auth));
}

/*
* Marshals (pre-serializes) an auth struct.
* sets private data, au_marshed and au_mpos
*/
static void
marshal_new_auth(AUTH *auth)
{
       XDR     xdr_stream;
       XDR     *xdrs = &xdr_stream;
       struct audata *au;

       _DIAGASSERT(auth != NULL);

       au = AUTH_PRIVATE(auth);
       xdrmem_create(xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
       if ((! xdr_opaque_auth(xdrs, &(auth->ah_cred))) ||
           (! xdr_opaque_auth(xdrs, &(auth->ah_verf))))
               warnx("%s: Fatal marshalling problem", __func__);
       else
               au->au_mpos = XDR_GETPOS(xdrs);
       XDR_DESTROY(xdrs);
}

static const struct auth_ops *
authunix_ops(void)
{
       static struct auth_ops ops;

       /* VARIABLES PROTECTED BY ops_lock: ops */

       mutex_lock(&ops_lock);
       if (ops.ah_nextverf == NULL) {
               ops.ah_nextverf = authunix_nextverf;
               ops.ah_marshal = authunix_marshal;
               ops.ah_validate = authunix_validate;
               ops.ah_refresh = authunix_refresh;
               ops.ah_destroy = authunix_destroy;
       }
       mutex_unlock(&ops_lock);
       return (&ops);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.