nis_attr.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/errno.h>
#include <pwd.h>
#include <unistd.h>
#include <syslog.h>
#include <netdb.h>
#include <rpc/rpc.h>
#include <rpcsvc/yppasswd.h>
#include <rpcsvc/ypclnt.h>
#include <rpcsvc/yp_prot.h>
#include "passwdutil.h"
int nis_getattr(char *name, attrlist *item, pwu_repository_t *rep);
int nis_getpwnam(char *name, attrlist *items, pwu_repository_t *rep,
void **buf);
int nis_update(attrlist *items, pwu_repository_t *rep, void *buf);
int nis_putpwnam(char *name, char *oldpw, char *dummy,
pwu_repository_t *rep, void *buf);
int nis_user_to_authenticate(char *user, pwu_repository_t *rep,
char **auth_user, int *privileged);
/*
* nis function pointer table, used by passwdutil_init to initialize
* the global Repository-OPerations table "rops"
*/
struct repops nis_repops = {
NULL, /* checkhistory */
nis_getattr,
nis_getpwnam,
nis_update,
nis_putpwnam,
nis_user_to_authenticate,
NULL, /* lock */
NULL /* unlock */
};
/*
* structure used to keep state between get/update/put calls
*/
typedef struct {
char *domain;
char *master;
char *scratch;
int scratchlen;
char *c2scratch;
int c2scratchlen;
struct passwd *pwd;
} nisbuf_t;
/*
* Are we a 'privileged' process? Yes if we are running on the
* NIS server AND we are root...
*/
int
nis_privileged(nisbuf_t *nisbuf)
{
char thishost[MAXHOSTNAMELEN];
if (gethostname(thishost, sizeof (thishost)) == -1) {
syslog(LOG_ERR, "passwdutil.so: Can't get hostname");
return (0);
}
if (strcmp(nisbuf->master, thishost) != 0)
return (0);
/* We're running on the NIS server. */
return (getuid() == 0);
}
/*
* nis_to_pwd()
*
* convert password-entry-line to "struct passwd"
*/
void
nis_to_pwd(char *nis, struct passwd *pwd)
{
pwd->pw_name = strsep(&nis, ":");
pwd->pw_passwd = strsep(&nis, ":");
pwd->pw_uid = atoi(strsep(&nis, ":"));
pwd->pw_gid = atoi(strsep(&nis, ":"));
pwd->pw_gecos = strsep(&nis, ":");
pwd->pw_dir = strsep(&nis, ":");
pwd->pw_shell = nis;
if (pwd->pw_shell[0])
pwd->pw_shell[strlen(pwd->pw_shell)-1] = '\0';
}
/*
* nis_user_to_authenticate(name, rep, auth_user, privileged)
*
*/
/*ARGSUSED*/
int
nis_user_to_authenticate(char *user, pwu_repository_t *rep,
char **auth_user, int *privileged)
{
nisbuf_t *buf = NULL;
int res;
attrlist attr_tmp[1];
uid_t uid;
/*
* special NIS case: don't bother to get "root" from NIS
*/
if (strcmp(user, "root") == 0)
return (PWU_NOT_FOUND);
attr_tmp[0].type = ATTR_UID;
attr_tmp[0].next = NULL;
res = nis_getpwnam(user, &attr_tmp[0], rep, (void **)&buf);
if (res != PWU_SUCCESS)
return (res);
if (nis_privileged(buf)) {
*privileged = 1;
*auth_user = NULL;
res = PWU_SUCCESS;
} else {
uid = getuid();
*privileged = (uid == (uid_t)0);
/* root, or user herself can change attributes */
if (uid == 0 || uid == buf->pwd->pw_uid) {
*auth_user = strdup(user);
res = PWU_SUCCESS;
} else {
res = PWU_DENIED;
}
}
/*
* Do not release buf->domain.
* It's been set by yp_get_default_domain()
* and must not be freed.
* See man page yp_get_default_domain(3NSL)
* for details.
*/
if (buf->master)
free(buf->master);
if (buf->scratch)
free(buf->scratch);
if (buf->c2scratch)
free(buf->c2scratch);
free(buf->pwd);
free(buf);
return (res);
}
/*
* nis_getattr(name, items, rep)
*
* get account attributes specified in 'items'
*/
int
nis_getattr(char *name, attrlist *items, pwu_repository_t *rep)
{
nisbuf_t *nisbuf = NULL;
struct passwd *pw;
attrlist *w;
int res;
res = nis_getpwnam(name, items, rep, (void **)&nisbuf);
if (res != PWU_SUCCESS)
return (res);
pw = nisbuf->pwd;
for (w = items; w != NULL; w = w->next) {
switch (w->type) {
case ATTR_NAME:
if ((w->data.val_s = strdup(pw->pw_name)) == NULL)
res = PWU_NOMEM;
break;
case ATTR_COMMENT:
if ((w->data.val_s = strdup(pw->pw_comment)) == NULL)
res = PWU_NOMEM;
break;
case ATTR_GECOS:
if ((w->data.val_s = strdup(pw->pw_gecos)) == NULL)
res = PWU_NOMEM;
break;
case ATTR_HOMEDIR:
if ((w->data.val_s = strdup(pw->pw_dir)) == NULL)
res = PWU_NOMEM;
break;
case ATTR_SHELL:
if ((w->data.val_s = strdup(pw->pw_shell)) == NULL)
res = PWU_NOMEM;
break;
case ATTR_PASSWD:
case ATTR_PASSWD_SERVER_POLICY:
if ((w->data.val_s = strdup(pw->pw_passwd)) == NULL)
res = PWU_NOMEM;
break;
case ATTR_REP_NAME:
if ((w->data.val_s = strdup("nis")) == NULL)
res = PWU_NOMEM;
break;
/* integer values */
case ATTR_UID:
w->data.val_i = nisbuf->pwd->pw_uid;
break;
case ATTR_GID:
w->data.val_i = nisbuf->pwd->pw_gid;
break;
case ATTR_LSTCHG:
case ATTR_MIN:
case ATTR_MAX:
case ATTR_WARN:
case ATTR_INACT:
case ATTR_EXPIRE:
case ATTR_FLAG:
case ATTR_AGE:
w->data.val_i = -1; /* not used for NIS */
break;
default:
break;
}
}
/*
* Do not release nisbuf->domain.
* It's been set by yp_get_default_domain()
* and must not be freed.
* See man page yp_get_default_domain(3NSL)
* for details.
*/
if (nisbuf->master)
free(nisbuf->master);
if (nisbuf->scratch)
free(nisbuf->scratch);
if (nisbuf->c2scratch)
free(nisbuf->c2scratch);
free(nisbuf->pwd);
free(nisbuf);
return (res);
}
/*
* nis_getpwnam(name, items, rep)
*
* Get the account information of user 'name'
*/
/*ARGSUSED*/
int
nis_getpwnam(char *name, attrlist *items, pwu_repository_t *rep,
void **buf)
{
nisbuf_t *nisbuf;
int nisresult;
nisbuf = calloc(sizeof (*nisbuf), 1);
if (nisbuf == NULL)
return (PWU_NOMEM);
nisbuf->pwd = malloc(sizeof (struct passwd));
if (nisbuf->pwd == NULL) {
free(nisbuf);
return (PWU_NOMEM);
}
/*
* Do not release nisbuf->domain.
* It is going to be set by yp_get_default_domain()
* and must not be freed.
* See man page yp_get_default_domain(3NSL)
* for details.
*/
if (yp_get_default_domain(&nisbuf->domain) != 0) {
syslog(LOG_ERR, "passwdutil.so: can't get domain");
free(nisbuf->pwd);
free(nisbuf);
return (PWU_SERVER_ERROR);
}
if (yp_master(nisbuf->domain, "passwd.byname", &nisbuf->master) != 0) {
syslog(LOG_ERR,
"passwdutil.so: can't get master for passwd map");
if (nisbuf->master)
free(nisbuf->master);
free(nisbuf->pwd);
free(nisbuf);
return (PWU_SERVER_ERROR);
}
nisresult = yp_match(nisbuf->domain, "passwd.byname", name,
strlen(name), &(nisbuf->scratch),
&(nisbuf->scratchlen));
if (nisresult != 0) {
(void) free(nisbuf->pwd);
if (nisbuf->scratch)
(void) free(nisbuf->scratch);
if (nisbuf->master)
(void) free(nisbuf->master);
(void) free(nisbuf);
return (PWU_NOT_FOUND);
}
nis_to_pwd(nisbuf->scratch, nisbuf->pwd);
/*
* check for the C2 security flag "##" in the passwd field.
* If the first 2 chars in the passwd field is "##", get
* the user's passwd from passwd.adjunct.byname map.
* The lookup to this passwd.adjunct.byname map will only
* succeed if the caller's uid is 0 because only root user
* can use privilege port.
*/
if (nisbuf->pwd->pw_passwd[0] == '#' &&
nisbuf->pwd->pw_passwd[1] == '#') {
char *key = &nisbuf->pwd->pw_passwd[2];
int keylen;
char *p;
keylen = strlen(key);
nisresult = yp_match(nisbuf->domain, "passwd.adjunct.byname",
key, keylen, &(nisbuf->c2scratch),
&(nisbuf->c2scratchlen));
if (nisresult == 0 && nisbuf->c2scratch != NULL) {
/* Skip username (first field), and pick up password */
p = nisbuf->c2scratch;
(void) strsep(&p, ":");
nisbuf->pwd->pw_passwd = strsep(&p, ":");
}
}
*buf = (void *)nisbuf;
return (PWU_SUCCESS);
}
/*
* nis_update(items, rep, buf)
*
* update the information in "buf" with the attribute/values
* specified in "items".
*/
/*ARGSUSED*/
int
nis_update(attrlist *items, pwu_repository_t *rep, void *buf)
{
attrlist *p;
nisbuf_t *nisbuf = (nisbuf_t *)buf;
char *salt;
for (p = items; p != NULL; p = p->next) {
switch (p->type) {
case ATTR_NAME:
break;
/*
* Nothing special needs to be done for
* server policy
*/
case ATTR_PASSWD:
case ATTR_PASSWD_SERVER_POLICY:
salt = crypt_gensalt(
nisbuf->pwd->pw_passwd, nisbuf->pwd);
if (salt == NULL) {
if (errno == ENOMEM)
return (PWU_NOMEM);
else {
/* algorithm problem? */
syslog(LOG_AUTH | LOG_ALERT,
"passwdutil: crypt_gensalt "
"%m");
return (PWU_UPDATE_FAILED);
}
}
nisbuf->pwd->pw_passwd = crypt(p->data.val_s, salt);
free(salt);
break;
case ATTR_UID:
nisbuf->pwd->pw_uid = (uid_t)p->data.val_i;
break;
case ATTR_GID:
nisbuf->pwd->pw_gid = (gid_t)p->data.val_i;
break;
case ATTR_AGE:
nisbuf->pwd->pw_age = p->data.val_s;
break;
case ATTR_COMMENT:
nisbuf->pwd->pw_comment = p->data.val_s;
break;
case ATTR_GECOS:
nisbuf->pwd->pw_gecos = p->data.val_s;
break;
case ATTR_HOMEDIR:
nisbuf->pwd->pw_dir = p->data.val_s;
break;
case ATTR_SHELL:
nisbuf->pwd->pw_shell = p->data.val_s;
break;
case ATTR_LSTCHG:
case ATTR_MIN:
case ATTR_MAX:
case ATTR_WARN:
case ATTR_INACT:
case ATTR_EXPIRE:
case ATTR_FLAG:
default:
break;
}
}
return (PWU_SUCCESS);
}
/*
* nis_putpwnam(name, oldpw, dummy, rep, buf)
*
* Update the NIS server. The passwd structure in buf will be sent to
* the server for user "name" authenticating with password "oldpw".
* The dummy parameter is a placeholder where for NIS+ where the
* old RPC password is passwd.
*/
/*ARGSUSED*/
int
nis_putpwnam(char *name, char *oldpw, char *dummy, pwu_repository_t *rep,
void *buf)
{
nisbuf_t *nisbuf = (nisbuf_t *)buf;
struct yppasswd yppasswd;
struct netconfig *nconf;
int ok;
enum clnt_stat ans;
CLIENT *client;
struct timeval timeout;
if (strcmp(name, "root") == 0)
return (PWU_NOT_FOUND);
yppasswd.oldpass = oldpw ? oldpw : "";
yppasswd.newpw = *nisbuf->pwd;
/*
* If we are privileged, we create a ticlts connection to the
* NIS server so that it can check our credentials
*/
if (nis_privileged(nisbuf)) {
nconf = getnetconfigent("ticlts");
if (!nconf) {
syslog(LOG_ERR,
"passwdutil.so: Couldn't get netconfig entry");
return (PWU_SYSTEM_ERROR);
}
client = clnt_tp_create(nisbuf->master, YPPASSWDPROG,
YPPASSWDVERS, nconf);
freenetconfigent(nconf);
} else {
/* Try IPv6 first */
client = clnt_create(nisbuf->master, YPPASSWDPROG,
YPPASSWDVERS, "udp6");
if (client == NULL)
client = clnt_create(nisbuf->master, YPPASSWDPROG,
YPPASSWDVERS, "udp");
}
if (client == NULL) {
syslog(LOG_ERR,
"passwdutil.so: couldn't create client to YP master");
return (PWU_SERVER_ERROR);
}
timeout.tv_usec = 0;
timeout.tv_sec = 55; /* ndp uses 55 seconds */
ans = CLNT_CALL(client, YPPASSWDPROC_UPDATE, xdr_yppasswd,
(char *)&yppasswd, xdr_int, (char *)&ok, timeout);
if (nisbuf->pwd)
(void) free(nisbuf->pwd);
if (nisbuf->master)
(void) free(nisbuf->master);
if (nisbuf->scratch)
(void) free(nisbuf->scratch);
if (nisbuf->c2scratch)
(void) free(nisbuf->c2scratch);
(void) clnt_destroy(client);
if (ans != RPC_SUCCESS) {
return (PWU_UPDATE_FAILED);
}
/* These errors are obtained from the yppasswdd.c code */
switch (ok) {
case 2: return (PWU_DENIED);
case 8: return (PWU_BUSY);
case 9: return (PWU_SERVER_ERROR);
case 4: return (PWU_NOT_FOUND);
case 3: return (PWU_NO_CHANGE);
case 7: return (PWU_DENIED);
case 0: return (PWU_SUCCESS);
default: return (PWU_SYSTEM_ERROR);
}
}