smbclnt/netsmb/smb_pass.c

	smb_pass.c revision 02d09e03eb27f3a2dc299de704e45dae5173f43f
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Password Keychain storage mechanism.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/sysmacros.h>
#include <sys/uio.h>
#include <sys/buf.h>
#include <sys/modctl.h>
#include <sys/open.h>
#include <sys/file.h>
#include <sys/kmem.h>
#include <sys/conf.h>
#include <sys/cmn_err.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunldi.h>
#include <sys/policy.h>
#include <sys/zone.h>
#include <sys/pathname.h>
#include <sys/mount.h>
#include <sys/sdt.h>
#include <fs/fs_subr.h>
#include <sys/devops.h>
#include <sys/thread.h>
#include <sys/mkdev.h>
#include <sys/avl.h>
#include <sys/avl_impl.h>
#include <sys/u8_textprep.h>

#include <netsmb/smb_osdep.h>

#include <netsmb/smb.h>
#include <netsmb/smb_conn.h>
#include <netsmb/smb_subr.h>
#include <netsmb/smb_dev.h>
#include <netsmb/smb_pass.h>

/*
 * The smb_ptd is a cache of Uid's, User names, passwords and domain names.
 * It will be used for storing the password information for a user and will
 * be used to for connections without entering the pasword again if its
 * already keyed in by the user. Its a kind of Key-Chain mechanism
 * implemented by Apple folks.
 */

/*
 * Information stored in the nodes:
 * UID:  Uid of the person who initiated the login request.
 * ZoneID: ZoneID of the zone from where the login request is initiated.
 * Username: Username in the CIFS server.
 * Srvdom: Domain name/ Server name of the CIFS server.
 * Password: Password of the user.
 * For more information, see smb_pass.h and sys/avl.h
 */

/*
 * Information retrieved from the node.
 * Node/password information can only be retrived with a call
 * to smb_pkey_getpw(). Password never gets copied to the userspace.
 * It will be copied to the Kernel data structure smbioc_ossn->ioc_password
 * when needed for doing the "Session Setup". All other calls will return
 * either a success or a failure.
 */

avl_tree_t smb_ptd; /* AVL password tree descriptor */
unsigned int smb_list_len = 0;  /* No. of elements in the tree. */
kmutex_t smb_ptd_lock;  /* Mutex lock for controlled access */

int smb_pkey_check(smbioc_pk_t *pk, cred_t *cr);
int smb_pkey_deluid(uid_t ioc_uid, cred_t *cr);

/*
 * This routine is called by AVL tree calls when they want to find a
 * node, find the next position in the tree to add or for deletion.
 * Compare nodes from the tree to find the actual node based on
 * uid/zoneid/username/domainname.
 */
int
smb_pkey_cmp(const void *a, const void *b)
{
    const smb_passid_t *pa = (smb_passid_t *)a;
    const smb_passid_t *pb = (smb_passid_t *)b;
    int duser, dsrv, error;

    ASSERT(MUTEX_HELD(&smb_ptd_lock));

    /*
     * The nodes are added sorted on the uid/zoneid/domainname/username
     * We will do this:
     * Compare uid's. The owner who stored the node gets access.
     * Then zoneid to check if the access is from the same zone.
     * Compare usernames.
     * If the above are same, then compare domain/server names.
     */
    if (pa->uid < pb->uid)
        return (-1);
    if (pa->uid > pb->uid)
        return (+1);
    if (pa->zoneid < pb->zoneid)
        return (-1);
    if (pa->zoneid > pb->zoneid)
        return (+1);
    dsrv = u8_strcmp(pa->srvdom, pb->srvdom, 0,
        U8_STRCMP_CI_LOWER, U8_UNICODE_LATEST, &error);
    if (dsrv < 0)
        return (-1);
    if (dsrv > 0)
        return (+1);
    duser = u8_strcmp(pa->username, pb->username, 0,
        U8_STRCMP_CI_LOWER, U8_UNICODE_LATEST, &error);
    if (duser < 0)
        return (-1);
    if (duser > 0)
        return (+1);
    return (0);
}

/*
 * Initialization of the code that deals with uid and passwords.
 */
void
smb_pkey_init()
{
    avl_create(&smb_ptd,
        smb_pkey_cmp,
        sizeof (smb_passid_t),
        offsetof(smb_passid_t,
        cpnode));
    mutex_init(&smb_ptd_lock, NULL, MUTEX_DEFAULT, NULL);
}

/*
 * Destroy the full AVL tree.
 * Called just before unload.
 */
void
smb_pkey_fini()
{
    (void) smb_pkey_deluid((uid_t)-1, kcred);
    avl_destroy(&smb_ptd);
    mutex_destroy(&smb_ptd_lock);
}

/*
 * Driver unload calls this to ask if we
 * have any stored passwords
 */
int
smb_pkey_idle()
{
    int n;

    mutex_enter(&smb_ptd_lock);
    n = avl_numnodes(&smb_ptd);
    mutex_exit(&smb_ptd_lock);

    return ((n) ? EBUSY : 0);
}

static void
smb_pkey_delete(smb_passid_t *tmp)
{
    ASSERT(MUTEX_HELD(&smb_ptd_lock));
    avl_remove(&smb_ptd, tmp);
    strfree(tmp->srvdom);
    strfree(tmp->username);
    kmem_free(tmp, sizeof (*tmp));
}


/*
 * Remove a node from the AVL tree identified by cpid.
 */
int
smb_pkey_del(smbioc_pk_t *pk, cred_t *cr)
{
    avl_index_t where;
    smb_passid_t buf, *cpid, *tmp;
    uid_t uid;

    tmp = &buf;
    uid = pk->pk_uid;
    if (uid == (uid_t)-1)
        uid = crgetruid(cr);
    else {
        if (secpolicy_smbfs_login(cr, uid))
            return (EPERM);
    }
    tmp->uid = uid;
    tmp->zoneid = getzoneid();
    tmp->srvdom = pk->pk_dom;
    tmp->username = pk->pk_usr;

    mutex_enter(&smb_ptd_lock);
    if ((cpid = (smb_passid_t *)avl_find(&smb_ptd,
        tmp, &where)) != NULL) {
        smb_pkey_delete(cpid);
    }
    mutex_exit(&smb_ptd_lock);

    return (0);
}

/*
 * Delete the entries owned by a particular user
 * based on uid. We go through all the nodes and
 * delete the nodes whereever the uid matches.
 *
 * Also implements "delete all" when uid == -1.
 *
 * You must have privilege to use any uid other
 * than your real uid.
 */
int
smb_pkey_deluid(uid_t ioc_uid, cred_t *cr)
{
    smb_passid_t *cpid, *tmp;

    if (secpolicy_smbfs_login(cr, ioc_uid))
        return (EPERM);

    mutex_enter(&smb_ptd_lock);
    for (tmp = avl_first(&smb_ptd); tmp != NULL;
        tmp = cpid) {
        cpid = AVL_NEXT(&smb_ptd, tmp);
        if (ioc_uid == (uid_t)-1 ||
            ioc_uid == tmp->uid) {
            /*
             * Delete the node.
             */
            smb_pkey_delete(tmp);
        }
    }
    mutex_exit(&smb_ptd_lock);

    return (0);
}

/*
 * Add entry or modify existing.
 * Check for existing entry..
 * If present, delete.
 * Now, add the new entry.
 */
int
smb_pkey_add(smbioc_pk_t *pk, cred_t *cr)
{
    avl_tree_t *t = &smb_ptd;
    avl_index_t where;
    smb_passid_t *tmp, *cpid;
    int ret;
    uid_t uid;

    uid = pk->pk_uid;
    if (uid == (uid_t)-1)
        uid = crgetruid(cr);
    else {
        if (secpolicy_smbfs_login(cr, uid))
            return (EPERM);
    }
    cpid = kmem_zalloc(sizeof (smb_passid_t), KM_SLEEP);
    cpid->uid = uid;
    cpid->zoneid = getzoneid();
    cpid->srvdom = strdup(pk->pk_dom);
    cpid->username = strdup(pk->pk_usr);
    bcopy(pk->pk_lmhash, cpid->lmhash, SMBIOC_HASH_SZ);
    bcopy(pk->pk_nthash, cpid->nthash, SMBIOC_HASH_SZ);

    /*
     * XXX: Instead of calling smb_pkey_check here,
     * should call avl_find directly, and hold the
     * lock across: avl_find, avl_remove, avl_insert.
     */

    /* If it already exists, delete it. */
    ret = smb_pkey_check(pk, cr);
    if (ret == 0) {
        (void) smb_pkey_del(pk, cr);
    }

    mutex_enter(&smb_ptd_lock);
    tmp = (smb_passid_t *)avl_find(t, cpid, &where);
    if (tmp == NULL) {
        avl_insert(t, cpid, where);
    } else {
        strfree(cpid->srvdom);
        strfree(cpid->username);
        kmem_free(cpid, sizeof (smb_passid_t));
    }
    mutex_exit(&smb_ptd_lock);

    return (0);
}

/*
 * Determine if a node with uid,zoneid, uname & dname exists in the tree
 * given the information, and if found, return the hashes.
 */
int
smb_pkey_check(smbioc_pk_t *pk, cred_t *cr)
{
    avl_tree_t *t = &smb_ptd;
    avl_index_t where;
    smb_passid_t *tmp, *cpid;
    int error = ENOENT;
    uid_t uid;

    uid = pk->pk_uid;
    if (uid == (uid_t)-1)
        uid = crgetruid(cr);
    else {
        if (secpolicy_smbfs_login(cr, uid))
            return (EPERM);
    }
    cpid = kmem_alloc(sizeof (smb_passid_t), KM_SLEEP);
    cpid->uid = uid;
    cpid->zoneid = getzoneid();
    cpid->srvdom = pk->pk_dom;
    cpid->username = pk->pk_usr;

    mutex_enter(&smb_ptd_lock);
    tmp = (smb_passid_t *)avl_find(t, cpid, &where);
    mutex_exit(&smb_ptd_lock);

    if (tmp != NULL) {
        bcopy(tmp->lmhash, pk->pk_lmhash, SMBIOC_HASH_SZ);
        bcopy(tmp->nthash, pk->pk_nthash, SMBIOC_HASH_SZ);
        error = 0;
    }

    kmem_free(cpid, sizeof (smb_passid_t));
    return (error);
}


int
smb_pkey_ioctl(int cmd, intptr_t arg, int flags, cred_t *cr)
{
    smbioc_pk_t  *pk;
    uid_t uid;
    int err = 0;

    pk = kmem_alloc(sizeof (*pk), KM_SLEEP);

    switch (cmd) {
    case SMBIOC_PK_ADD:
    case SMBIOC_PK_DEL:
    case SMBIOC_PK_CHK:
        if (ddi_copyin((void *)arg, pk,
            sizeof (*pk), flags)) {
            err = EFAULT;
            goto out;
        }
        /* Make strlen (etc) on these safe. */
        pk->pk_dom[SMBIOC_MAX_NAME-1] = '\0';
        pk->pk_usr[SMBIOC_MAX_NAME-1] = '\0';
        break;
    }

    switch (cmd) {
    case SMBIOC_PK_ADD:
        err = smb_pkey_add(pk, cr);
        break;

    case SMBIOC_PK_DEL:
        err = smb_pkey_del(pk, cr);
        break;

    case SMBIOC_PK_CHK:
        err = smb_pkey_check(pk, cr);
        /* This is just a hash now. */
        (void) ddi_copyout(pk, (void *)arg,
            sizeof (*pk), flags);
        break;

    case SMBIOC_PK_DEL_OWNER:
        uid = crgetruid(cr);
        err = smb_pkey_deluid(uid, cr);
        break;

    case SMBIOC_PK_DEL_EVERYONE:
        uid = (uid_t)-1;
        err = smb_pkey_deluid(uid, cr);
        break;

    default:
        err = ENODEV;
    }

out:
    kmem_free(pk, sizeof (*pk));
    return (err);
}