pkcs11_softtoken/common/softKeystoreUtil.c

/*
 * 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"

/*
 * Functions used for manipulating the keystore
 */

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>
#include <unistd.h>
#include <pwd.h>
#include <sys/types.h>
#include <dirent.h>
#include <limits.h>
#include <strings.h>
#include <security/cryptoki.h>
#include <cryptoutil.h>
#include "softGlobal.h"
#include "softObject.h"
#include "softKeystore.h"
#include "softKeystoreUtil.h"

#define	MAXPATHLEN	1024
#define	SUNW_PATH	".sunw"		/* top level Sun directory */
#define	KEYSTORE_PATH	"pkcs11_softtoken"	/* keystore directory */
#define	PUB_OBJ_DIR	"public"	/* directory for public objects */
#define	PRI_OBJ_DIR	"private"	/* directory for private objects */
#define	DS_FILE		"objstore_info"	/* keystore description file */
#define	TMP_DS_FILE	"t_info"	/* temp name for keystore desc. file */
#define	OBJ_PREFIX	"obj"	/* prefix of the keystore object file names */
#define	TMP_OBJ_PREFIX	"t_o"	/* prefix of the temp object file names */

/*
 * KEYSTORE DESCRIPTION FILE:
 *
 * The following describes the content of the keystore description file
 *
 * The order AND data type of the fields are very important.
 * All the code in this file assume that they are in the order specified
 * below.  If either order of the fields or their data type changed,
 * you must make sure the ALL the pre-define values are still valid
 *
 * 1) PKCS#11 release number.  It's 2.11 in this release (uchar_t[32])
 * 2) keystore version number: used for synchronizing when different
 *    processes access the keystore at the same time.  It is incremented
 *    when there is a change to the keystore. (uint_32)
 * 3) monotonic-counter: last counter value for name of token object file.
 *    used for assigning unique name to each token (uint_32)
 * 4) salt used for generating encryption key (uint_16)
 * 5) salt used for generating key used for doing HMAC (uint_16)
 * 6) Length of salt used for generating hashed pin (length of salt
 *    is variable)
 * 7) Salt used for generating hashed pin.
 * 8) Hashed pin len (length of hashed pin could be variable, the offset of
 *    where this value lives in the file is calculated at run time)
 * 9) Hashed pin
 *
 */

/* Keystore description file pre-defined values */
#define	KS_PKCS11_VER		"2.20"
#define	KS_PKCS11_OFFSET	0
#define	KS_PKCS11_VER_SIZE	32

#define	KS_VER_OFFSET		(KS_PKCS11_OFFSET + KS_PKCS11_VER_SIZE)
#define	KS_VER_SIZE	4	/* size in bytes of keystore version value */

#define	KS_COUNTER_OFFSET	(KS_VER_OFFSET + KS_VER_SIZE)
#define	KS_COUNTER_SIZE	4	/* size in bytes of the monotonic counter */

#define	KS_KEY_SALT_OFFSET	(KS_COUNTER_OFFSET + KS_COUNTER_SIZE)
#define	KS_KEY_SALT_SIZE	PBKD2_SALT_SIZE

#define	KS_HMAC_SALT_OFFSET	(KS_KEY_SALT_OFFSET + KS_KEY_SALT_SIZE)
#define	KS_HMAC_SALT_SIZE	PBKD2_SALT_SIZE

/* Salt for hashed pin */
#define	KS_HASHED_PIN_SALT_LEN_OFFSET (KS_HMAC_SALT_OFFSET + KS_HMAC_SALT_SIZE)
#define	KS_HASHED_PIN_SALT_LEN_SIZE 8 /* stores length of hashed pin salt */

#define	KS_HASHED_PIN_SALT_OFFSET \
		(KS_HASHED_PIN_SALT_LEN_OFFSET + KS_HASHED_PIN_SALT_LEN_SIZE)

/*
 * hashed pin
 *
 * hashed_pin length offset will be calculated at run time since
 * there's the hashed pin salt size is variable.
 *
 * The offset will be calculated at run time by calling the
 * function calculate_hashed_pin_offset()
 */
static off_t	ks_hashed_pinlen_offset = -1;
#define	KS_HASHED_PINLEN_SIZE	8

/* End of Keystore description file pre-defined values */

/*
 * Metadata for each object
 *
 * The order AND data type of all the fields is very important.
 * All the code in this file assume that they are in the order specified
 * below.  If either order of the fields or their data type is changed,
 * you must make sure the following pre-define value is still valid
 * Each object will have the meta data at the beginning of the object file.
 *
 * 1) object_version: used by softtoken to see if the object
 *    has been modified since it last reads it. (uint_32)
 * 2) iv: initialization vector for encrypted data in the object.  This
 *    value will be 0 for public objects.  (uchar_t[16])
 * 3) obj_hmac: keyed hash as verifier to detect private object
 *    being tampered this value will be 0 for public objects (uchar_t[16])
 */

/* Object metadata pre-defined values */
#define	OBJ_VER_OFFSET	0
#define	OBJ_VER_SIZE	4	/* size of object version in bytes */
#define	OBJ_IV_OFFSET	(OBJ_VER_OFFSET + OBJ_VER_SIZE)
#define	OBJ_IV_SIZE	16
#define	OBJ_HMAC_OFFSET	(OBJ_IV_OFFSET + OBJ_IV_SIZE)
#define	OBJ_HMAC_SIZE	16	/* MD5 HMAC keyed hash */
#define	OBJ_DATA_OFFSET	(OBJ_HMAC_OFFSET + OBJ_HMAC_SIZE)
/* End of object metadata pre-defined values */

#define	ALTERNATE_KEYSTORE_PATH	"SOFTTOKEN_DIR"

static soft_object_t	*enc_key = NULL;
static soft_object_t	*hmac_key = NULL;
static char		keystore_path[MAXPATHLEN];
static boolean_t	keystore_path_initialized = B_FALSE;
static int		desc_fd = 0;

static char *
get_user_home_sunw_path(char *home_path)
{
	struct passwd *user_info;

	user_info = getpwuid(getuid());

	(void) snprintf(home_path, MAXPATHLEN, "%s/%s",
	    user_info ? user_info->pw_dir : "", SUNW_PATH);

	return (home_path);
}

static char *
get_keystore_path()
{
	char *env_val;
	char home_path[MAXPATHLEN];

	if (!keystore_path_initialized) {
		env_val = getenv(ALTERNATE_KEYSTORE_PATH);
		bzero(keystore_path, sizeof (keystore_path));
		/*
		 * If it isn't set or is set to the empty string use the
		 * default location.  We need to check for the empty string
		 * because some users "unset" environment variables by giving
		 * them no value, this isn't the same thing as removing it
		 * from the environment.
		 *
		 * We don't want that to attempt to open /.sunw/pkcs11_sofftoken
		 */
		if ((env_val == NULL) || (strcmp(env_val, "") == 0)) {
			/* alternate path not specified, use user's home dir */
			(void) snprintf(keystore_path, MAXPATHLEN, "%s/%s",
			    get_user_home_sunw_path(home_path), KEYSTORE_PATH);
		} else {
			(void) snprintf(keystore_path, MAXPATHLEN, "%s/%s",
			    env_val, KEYSTORE_PATH);
		}
		keystore_path_initialized = B_TRUE;
	}
	return (keystore_path);
}

static char *
get_pub_obj_path(char *name)
{
	bzero(name, sizeof (name));
	(void) snprintf(name, MAXPATHLEN, "%s/%s",
	    get_keystore_path(), PUB_OBJ_DIR);
	return (name);
}

static char *
get_pri_obj_path(char *name)
{
	bzero(name, sizeof (name));
	(void) snprintf(name, MAXPATHLEN, "%s/%s",
	    get_keystore_path(), PRI_OBJ_DIR);
	return (name);
}

static char *
get_desc_file_path(char *name)
{
	bzero(name, sizeof (name));
	(void) snprintf(name, MAXPATHLEN, "%s/%s",
	    get_keystore_path(), DS_FILE);
	return (name);
}

static char *
get_tmp_desc_file_path(char *name)
{
	bzero(name, sizeof (name));
	(void) snprintf(name, MAXPATHLEN, "%s/%s",
	    get_keystore_path(), TMP_DS_FILE);
	return (name);
}

/*
 * Calculates the offset for hashed_pin length and hashed pin
 *
 * Returns 0 if successful, -1 if there's any error.
 *
 * If successful, global variables "ks_hashed_pinlen_offset" will be set.
 *
 */
static int
calculate_hashed_pin_offset(int fd)
{
	uint64_t salt_length;

	if (lseek(fd, KS_HASHED_PIN_SALT_LEN_OFFSET, SEEK_SET)
	    != KS_HASHED_PIN_SALT_LEN_OFFSET) {
		return (-1);
	}

	if (looping_read(fd, (char *)&salt_length,
	    KS_HASHED_PIN_SALT_LEN_SIZE) != KS_HASHED_PIN_SALT_LEN_SIZE) {
		return (-1);
	}
	salt_length = SWAP64(salt_length);

	ks_hashed_pinlen_offset = KS_HASHED_PIN_SALT_LEN_OFFSET
	    + KS_HASHED_PIN_SALT_LEN_SIZE + salt_length;

	return (0);

}

/*
 * acquire or release read/write lock on a specific file
 *
 * read_lock: true for read lock; false for write lock
 * set_lock:  true to set a lock; false to release a lock
 */
static int
lock_file(int fd, boolean_t read_lock, boolean_t set_lock)
{

	flock_t lock_info;
	int r;

	lock_info.l_whence = SEEK_SET;
	lock_info.l_start = 0;
	lock_info.l_len = 0; /* l_len == 0 means until end of  file */

	if (read_lock) {
		lock_info.l_type = F_RDLCK;
	} else {
		lock_info.l_type = F_WRLCK;
	}

	if (set_lock) {
		while ((r = fcntl(fd, F_SETLKW, &lock_info)) == -1) {
			if (errno != EINTR)
				break;
		}
		if (r == -1) {
			return (-1);
		}
	} else {
		lock_info.l_type = F_UNLCK;
		while ((r = fcntl(fd, F_SETLKW, &lock_info)) == -1) {
			if (errno != EINTR)
				break;
		}
		if (r == -1) {
			return (-1);
		}
	}

	return (0);
}

static int
create_keystore()
{
	int fd, buf;
	uint64_t hashed_pin_len, hashed_pin_salt_len, ulong_buf;
	uchar_t ver_buf[KS_PKCS11_VER_SIZE];
	char pub_obj_path[MAXPATHLEN], pri_obj_path[MAXPATHLEN],
	    ks_desc_file[MAXPATHLEN];
	CK_BYTE salt[KS_KEY_SALT_SIZE];
	char *hashed_pin = NULL, *hashed_pin_salt = NULL;
	char *env_val;

	/* keystore doesn't exist, create keystore directory */
	if (mkdir(get_keystore_path(), S_IRUSR|S_IWUSR|S_IXUSR) < 0) {
		if (errno == EEXIST) {
			return (0);
		}

		if (errno == EACCES) {
			return (-1);
		}

		/* can't create keystore directory */
		if (errno == ENOENT) { /* part of the path doesn't exist */
			/*
			 * try to create $HOME/.sunw if it doesn't
			 * exist.  If it is a alternate path provided by the
			 * user, it should have existed.  Will not
			 * create for them.
			 */
			env_val = getenv(ALTERNATE_KEYSTORE_PATH);
			if ((env_val == NULL) || (strcmp(env_val, "") == 0)) {
				char sunw_path[MAXPATHLEN];

				/* create $HOME/.sunw */
				if (mkdir(get_user_home_sunw_path(sunw_path),
				    S_IRUSR|S_IWUSR|S_IXUSR) < 0) {
					return (-1);
				}

				/* create $HOME/.sunw/pkcs11_softtoken */
				if (mkdir(get_keystore_path(),
				    S_IRUSR|S_IWUSR|S_IXUSR) < 0) {
					return (-1);
				}
			} else {
				return (-1);
			}
		}
	}

	/* create keystore description file */
	while ((fd = open(get_desc_file_path(ks_desc_file),
	    O_RDWR|O_CREAT|O_EXCL|O_NONBLOCK, S_IRUSR|S_IWUSR)) < 0) {
		if (errno != EINTR)
			break;
	}
	if (fd < 0) {
		if (errno == EEXIST) {
			return (0);
		} else {
			/* can't create keystore description file */
			(void) rmdir(get_keystore_path());
			return (-1);
		}
	}

	/* Mark fd as "close on exec" */
	(void) fcntl(fd, F_SETFD, FD_CLOEXEC);

	if (lock_file(fd, B_FALSE, B_TRUE) != 0) {
		(void) unlink(ks_desc_file);
		(void) close(fd);
		(void) rmdir(get_keystore_path());
		return (-1);
	}

	if (mkdir(get_pub_obj_path(pub_obj_path),
	    S_IRUSR|S_IWUSR|S_IXUSR) < 0) {
		/* can't create directory for public objects */
		(void) lock_file(fd, B_FALSE, B_FALSE);
		(void) unlink(ks_desc_file);
		(void) close(fd);
		(void) rmdir(get_keystore_path());
		return (-1);
	}

	if (mkdir(get_pri_obj_path(pri_obj_path),
	    S_IRUSR|S_IWUSR|S_IXUSR) < 0) {
		/* can't create directory for private objects */
		(void) lock_file(fd, B_FALSE, B_FALSE);
		(void) unlink(ks_desc_file);
		(void) close(fd);
		(void) rmdir(get_keystore_path());
		(void) rmdir(pub_obj_path);
		return (-1);
	}


	/* write file format release number */
	bzero(ver_buf, sizeof (ver_buf));
	(void) strcpy((char *)ver_buf, KS_PKCS11_VER);
	if ((looping_write(fd, (char *)ver_buf, sizeof (ver_buf)))
	    != sizeof (ver_buf)) {
		goto cleanup;
	}

	/* write version number, version = 0 since keystore just created */
	buf = SWAP32(0);
	if (looping_write(fd, (void *)&buf, KS_VER_SIZE) != KS_VER_SIZE) {
		goto cleanup;
	}

	/* write monotonic-counter.  Counter for keystore objects start at 1 */
	buf = SWAP32(1);
	if (looping_write(fd, (void *)&buf, KS_COUNTER_SIZE)
	    != KS_COUNTER_SIZE) {
		goto cleanup;
	}

	/* initial encryption key salt should be all NULL */
	bzero(salt, sizeof (salt));
	if (looping_write(fd, (void *)salt, KS_KEY_SALT_SIZE)
	    != KS_KEY_SALT_SIZE) {
		goto cleanup;
	}

	/* initial HMAC key salt should also be all NULL */
	if (looping_write(fd, (void *)salt, KS_HMAC_SALT_SIZE)
	    != KS_HMAC_SALT_SIZE) {
		goto cleanup;
	}

	/* generate the hashed pin salt, and MD5 hashed pin of default pin */
	if (soft_gen_hashed_pin((CK_CHAR_PTR)SOFT_DEFAULT_PIN, &hashed_pin,
	    &hashed_pin_salt) < 0) {
		goto cleanup;
	}

	if ((hashed_pin_salt == NULL) || (hashed_pin == NULL)) {
		goto cleanup;
	}

	hashed_pin_salt_len = (uint64_t)strlen(hashed_pin_salt);
	hashed_pin_len = (uint64_t)strlen(hashed_pin);

	/* write hashed pin salt length */
	ulong_buf = SWAP64(hashed_pin_salt_len);
	if (looping_write(fd, (void *)&ulong_buf, KS_HASHED_PIN_SALT_LEN_SIZE)
	    != KS_HASHED_PIN_SALT_LEN_SIZE) {
		goto cleanup;
	}

	if (looping_write(fd, (void *)hashed_pin_salt,
	    hashed_pin_salt_len) != hashed_pin_salt_len) {
		goto cleanup;
	}

	/* write MD5 hashed pin of the default pin */
	ulong_buf = SWAP64(hashed_pin_len);
	if (looping_write(fd, (void *)&ulong_buf, KS_HASHED_PINLEN_SIZE)
	    != KS_HASHED_PINLEN_SIZE) {
		goto cleanup;
	}

	if (looping_write(fd, (void *)hashed_pin, hashed_pin_len)
	    != hashed_pin_len) {
		goto cleanup;
	}

	(void) lock_file(fd, B_FALSE, B_FALSE);

	(void) close(fd);
	if (hashed_pin_salt)
	    free(hashed_pin_salt);
	return (0);

cleanup:
	(void) lock_file(fd, B_FALSE, B_FALSE);
	(void) unlink(ks_desc_file);
	(void) close(fd);
	(void) rmdir(get_keystore_path());
	(void) rmdir(pub_obj_path);
	(void) rmdir(pri_obj_path);
	return (-1);
}

/*
 * Determines if the file referenced by "fd" has the same
 * inode as the file referenced by "fname".
 *
 * The argument "same" contains the result of determining
 * if the inode is the same or not
 *
 * Returns 0 if there's no error.
 * Returns 1 if there's any error with opening the file.
 *
 *
 */
static int
is_inode_same(int fd, char *fname, boolean_t *same)
{
	struct stat fn_stat, fd_stat;

	if (fstat(fd, &fd_stat) != 0) {
		return (-1);
	}

	if (stat(fname, &fn_stat) != 0) {
		return (-1);
	}

	/* It's the same file if both st_ino and st_dev match */
	if ((fd_stat.st_ino == fn_stat.st_ino) &&
	    (fd_stat.st_dev == fn_stat.st_dev)) {
		*same = B_TRUE;
	} else {
		*same = B_FALSE;
	}
	return (0);
}

static int
acquire_file_lock(int *fd, char *fname, mode_t mode) {

	boolean_t read_lock = B_TRUE, same_inode;

	if ((mode == O_RDWR) || (mode == O_WRONLY)) {
		read_lock = B_FALSE;
	}

	if (lock_file(*fd, read_lock, B_TRUE) != 0) {
		return (-1);
	}

	/*
	 * make sure another process did not modify the file
	 * while we were trying to get the lock
	 */
	if (is_inode_same(*fd, fname, &same_inode) != 0) {
		(void) lock_file(*fd, B_TRUE, B_FALSE); /* unlock file */
		return (-1);
	}

	while (!same_inode) {
		/*
		 * need to unlock file, close, re-open the file,
		 * and re-acquire the lock
		 */

		/* unlock file */
		if (lock_file(*fd, B_TRUE, B_FALSE) != 0) {
			return (-1);
		}

		(void) close(*fd);

		/* re-open */
		while ((*fd = open(fname, mode|O_NONBLOCK)) < 0) {
			if (errno != EINTR)
				break;
		}
		if (*fd < 0) {
			return (-1);
		}

		(void) fcntl(*fd, F_SETFD, FD_CLOEXEC);

		/* acquire lock again */
		if (lock_file(*fd, read_lock, B_TRUE) != 0) {
			return (-1);
		}

		if (is_inode_same(*fd, fname, &same_inode) != 0) {
			(void) lock_file(*fd, B_TRUE, B_FALSE); /* unlock */
			return (-1);
		}

	}

	return (0);
}

/*
 * Open the keystore description file in the specified mode.
 * If the keystore doesn't exist, the "do_create_keystore"
 * argument determines if the keystore should be created
 */
static int
open_and_lock_keystore_desc(mode_t mode, boolean_t do_create_keystore,
    boolean_t lock_held)
{

	int fd;
	char *fname, ks_desc_file[MAXPATHLEN];

	/* open the keystore description file in requested mode */
	fname = get_desc_file_path(ks_desc_file);
	while ((fd = open(fname, mode|O_NONBLOCK)) < 0) {
		if (errno != EINTR)
			break;
	}
	if (fd < 0) {
		soft_token_present = B_FALSE;
		if ((errno == ENOENT) && (do_create_keystore)) {
			if (create_keystore() < 0) {
				goto done;
			}
			while ((fd = open(fname, mode|O_NONBLOCK)) < 0) {
				if (errno != EINTR)
					break;
			}
			if (fd < 0) {
				goto done;
			} else {
				(void) fcntl(fd, F_SETFD, FD_CLOEXEC);
			}
		} else {
			goto done;
		}
	} else {
		(void) fcntl(fd, F_SETFD, FD_CLOEXEC);
	}

	soft_token_present = B_TRUE;

	if (lock_held) {
		/* already hold the lock */
		return (fd);
	}

	if (acquire_file_lock(&fd, fname, mode) != 0) {
		if (fd > 0) {
			(void) close(fd);
		}
		return (-1);
	}

done:
	return (fd);
}


/*
 * Set or remove read or write lock on keystore description file
 *
 * read_lock: true for read lock, false for write lock
 * set_lock: true for set a lock, false to remove a lock
 */
static int
lock_desc_file(boolean_t read_lock, boolean_t set_lock)
{

	char ks_desc_file[MAXPATHLEN];

	if (set_lock) {
		int oflag;

		/*
		 * make sure desc_fd is not already used.  If used, it means
		 * some other lock is already set on the file
		 */
		if (desc_fd > 0) {
			return (-1);
		}

		(void) get_desc_file_path(ks_desc_file);

		if (read_lock) {
			oflag = O_RDONLY;
		} else {
			oflag = O_WRONLY;
		}
		if ((desc_fd = open_and_lock_keystore_desc(oflag,
		    B_FALSE, B_FALSE)) < 0) {
			return (-1);
		}
	} else {
		/* make sure we have a valid fd */
		if (desc_fd <= 0) {
			return (-1);
		}

		if (lock_file(desc_fd, read_lock, B_FALSE) == 1) {
			return (-1);
		}

		(void) close(desc_fd);
		desc_fd = 0;

	}
	return (0);
}

static int
open_and_lock_object_file(ks_obj_handle_t *ks_handle, int oflag,
    boolean_t lock_held)
{
	char obj_fname[MAXPATHLEN];
	int fd;

	if (ks_handle->public) {
		char pub_obj_path[MAXPATHLEN];
		(void) snprintf(obj_fname, MAXPATHLEN, "%s/%s",
		    get_pub_obj_path(pub_obj_path), ks_handle->name);
	} else {
		char pri_obj_path[MAXPATHLEN];
		(void) snprintf(obj_fname, MAXPATHLEN, "%s/%s",
		    get_pri_obj_path(pri_obj_path), ks_handle->name);
	}

	while ((fd = open(obj_fname, oflag|O_NONBLOCK)) < 0) {
		if (errno != EINTR)
			break;
	}
	if (fd < 0) {
		return (-1);
	}

	(void) fcntl(fd, F_SETFD, FD_CLOEXEC);

	if (lock_held) {
		/* already hold the lock */
		return (fd);
	}

	if (acquire_file_lock(&fd, obj_fname, oflag) != 0) {
		if (fd > 0) {
			(void) close(fd);
		}
		return (-1);
	}


	return (fd);
}


/*
 * Update file version number in a temporary file that's
 * a copy of the keystore description file.
 * The update is NOT made to the original keystore description
 * file.  It makes the update in a tempoary file.
 *
 * Name of the temporary file is assumed to be provided, but
 * the file is assumed to not exist.
 *
 * return 0 if creating temp file is successful, returns -1 otherwise
 */
static int
create_updated_keystore_version(int fd, char *tmp_fname)
{
	int version, tmp_fd;
	char buf[BUFSIZ];
	size_t nread;

	/* first, create the tempoary file */
	while ((tmp_fd = open(tmp_fname,
	    O_WRONLY|O_CREAT|O_EXCL|O_NONBLOCK, S_IRUSR|S_IWUSR)) < 0) {
		if (errno != EINTR)
			break;
	}
	if (tmp_fd < 0) {
		return (-1);
	}
	(void) fcntl(tmp_fd, F_SETFD, FD_CLOEXEC);

	/*
	 * copy everything from keystore version to temp file except
	 * the keystore version.  Keystore version is updated
	 *
	 */

	/* pkcs11 version */
	if (looping_read(fd, buf, KS_PKCS11_VER_SIZE) != KS_PKCS11_VER_SIZE) {
		goto cleanup;
	}

	if (looping_write(tmp_fd, buf, KS_PKCS11_VER_SIZE)
	    != KS_PKCS11_VER_SIZE) {
		goto cleanup;
	}

	/* version number, it needs to be updated */

	/* read the current version number */
	if (looping_read(fd, &version, KS_VER_SIZE) != KS_VER_SIZE) {
		goto cleanup;
	}

	version = SWAP32(version);
	version++;
	version = SWAP32(version);

	/* write the updated value to the tmp file */
	if (looping_write(tmp_fd, (void *)&version, KS_VER_SIZE)
	    != KS_VER_SIZE) {
		goto cleanup;
	}

	/* read rest of information, nothing needs to be updated */
	nread = looping_read(fd, buf, BUFSIZ);
	while (nread > 0) {
		if (looping_write(tmp_fd, buf, nread) != nread) {
			goto cleanup;
		}
		nread = looping_read(fd, buf, BUFSIZ);
	}

	(void) close(tmp_fd);
	return (0);	/* no error */

cleanup:
	(void) close(tmp_fd);
	(void) remove(tmp_fname);
	return (-1);
}

static CK_RV
get_all_objs_in_dir(DIR *dirp, ks_obj_handle_t *ks_handle,
    ks_obj_t **result_obj_list, boolean_t lock_held, char *dir_name)
{
	struct dirent *dp = NULL, *result = NULL;
	ks_obj_t *obj;
	CK_RV rv;
	long path_limit;

	if ((path_limit = pathconf(dir_name, _PC_NAME_MAX)) == -1) {
		path_limit = PATH_MAX;
	}

	dp = malloc(path_limit + 1 + sizeof (struct dirent));
	if (dp == NULL) {
		return (CKR_HOST_MEMORY);
	}

	while (readdir_r(dirp, dp, &result) == 0) {
		if (result == NULL) {
			break;
		}


		if ((strcmp(dp->d_name, ".") == 0) ||
		    (strcmp(dp->d_name, "..") == 0)) {
			continue;
		}

		(void) strcpy((char *)ks_handle->name, dp->d_name);
		rv = soft_keystore_get_single_obj(ks_handle, &obj, lock_held);
		if (rv != CKR_OK) {
			free(dp);
			return (rv);
		}
		if (obj != NULL) {
			if (*result_obj_list == NULL) {
				*result_obj_list = obj;
			} else {
				obj->next = *result_obj_list;
				*result_obj_list = obj;
			}
		}
	}
	free(dp);
	return (CKR_OK);
}

/*
 * This function prepares the obj data for encryption by prepending
 * the FULL path of the file that will be used for storing
 * the object.  Having full path of the file as part of
 * of the data for the object will prevent an attacker from
 * copying a "bad" object into the keystore undetected.
 *
 * This function will always allocate:
 *	MAXPATHLEN + buf_len
 * amount of data.  If the full path of the filename doesn't occupy
 * the whole MAXPATHLEN, the rest of the space will just be empty.
 * It is the caller's responsibility to free the buffer allocated here.
 *
 * The allocated buffer is returned in the variable "prepared_buf"
 * if there's no error.
 *
 * Returns 0 if there's no error, -1 otherwise.
 */
static int
prepare_data_for_encrypt(char *obj_path, unsigned char *buf, CK_ULONG buf_len,
    unsigned char **prepared_buf, CK_ULONG *prepared_len)
{
	*prepared_len = MAXPATHLEN + buf_len;
	*prepared_buf = malloc(*prepared_len);
	if (*prepared_buf == NULL) {
		return (-1);
	}

	/*
	 * only zero out the space for the path name.  I could zero out
	 * the whole buffer, but that will be a waste of processing
	 * cycle since the rest of the buffer will be 100% filled all
	 * the time
	 */
	bzero(*prepared_buf, MAXPATHLEN);
	(void) memcpy(*prepared_buf, obj_path, strlen(obj_path));
	(void) memcpy(*prepared_buf + MAXPATHLEN, buf, buf_len);
	return (0);
}

/*
 * retrieves the hashed pin from the keystore
 */
static CK_RV
get_hashed_pin(int fd, char **hashed_pin)
{
	uint64_t hashed_pin_size;

	if (ks_hashed_pinlen_offset == -1) {
		if (calculate_hashed_pin_offset(fd) != 0) {
			return (CKR_FUNCTION_FAILED);
		}
	}

	/* first, get size of the hashed pin */
	if (lseek(fd, ks_hashed_pinlen_offset, SEEK_SET)
	    != ks_hashed_pinlen_offset) {
		return (CKR_FUNCTION_FAILED);
	}

	if (looping_read(fd, (char *)&hashed_pin_size,
	    KS_HASHED_PINLEN_SIZE) != KS_HASHED_PINLEN_SIZE) {
		return (CKR_FUNCTION_FAILED);
	}

	hashed_pin_size = SWAP64(hashed_pin_size);

	*hashed_pin = malloc(hashed_pin_size + 1);
	if (*hashed_pin == NULL) {
		return (CKR_HOST_MEMORY);
	}

	if ((looping_read(fd, *hashed_pin, hashed_pin_size))
	    != (ssize_t)hashed_pin_size) {
		free(*hashed_pin);
		*hashed_pin = NULL;
		return (CKR_FUNCTION_FAILED);
	}
	(*hashed_pin)[hashed_pin_size] = '\0';
	return (CKR_OK);
}


/*
 *	FUNCTION: soft_keystore_lock
 *
 *	ARGUMENTS:
 *		set_lock: TRUE to set readlock on the keystore object file,
 *		          FALSE to remove readlock on keystore object file.
 *
 *	RETURN VALUE:
 *
 *		0: success
 *		-1: failure
 *
 *	DESCRIPTION:
 *
 *		set or remove readlock on the keystore description file.
 */
int
soft_keystore_readlock(boolean_t set_lock)
{

	return (lock_desc_file(B_TRUE, set_lock));
}


/*
 *	FUNCTION: soft_keystore_writelock
 *
 *	ARGUMENTS:
 * 		set_lock: TRUE to set writelock on the keystore description file
 *		        FALSE to remove write lock on keystore description file.
 *
 *	RETURN VALUE:
 *
 *		0: no error
 *		1: some error occurred
 *
 *	DESCRIPTION:
 *		set/reset writelock on the keystore description file.
 */
int
soft_keystore_writelock(boolean_t set_lock)
{
	return (lock_desc_file(B_FALSE, set_lock));

}

/*
 *
 *	FUNCTION: soft_keystore_lock_object
 *
 *	ARGUMENTS:
 *
 *		ks_handle: handle of the keystore object file to be accessed.
 * 		read_lock: TRUE to set readlock on the keystore object file,
 *			  FALSE to set writelock on keystore object file.
 *
 *	RETURN VALUE:
 *
 *		If no error, file descriptor of locked file will be returned
 *		-1: some error occurred
 *
 *	DESCRIPTION:
 *
 *		set readlock or writelock on the keystore object file.
 */
int
soft_keystore_lock_object(ks_obj_handle_t *ks_handle, boolean_t read_lock)
{
	int fd;
	int oflag;

	if (read_lock) {
		oflag = O_RDONLY;
	} else {
		oflag = O_WRONLY;
	}

	if ((fd = open_and_lock_object_file(ks_handle, oflag, B_FALSE)) < 0) {
		return (-1);
	}

	return (fd);
}

/*
 *	FUNCTION: soft_keystore_unlock_object
 *
 *	ARGUMENTS:
 *		fd: file descriptor returned from soft_keystore_lock_object
 *
 *	RETURN VALUE:
 *		0: no error
 *		1: some error occurred while getting the pin
 *
 *	DESCRIPTION:
 *		set/reset writelock on the keystore object file.
 */
int
soft_keystore_unlock_object(int fd)
{
	if (lock_file(fd, B_TRUE, B_FALSE) != 0) {
		return (1);
	}

	(void) close(fd);
	return (0);
}


/*
 *	FUNCTION: soft_keystore_get_version
 *
 *	ARGUMENTS:
 *		version: pointer to caller allocated memory for storing
 *			 the version of the keystore.
 *		lock_held: TRUE if the lock is held by caller.
 *
 *	RETURN VALUE:
 *
 *		0: no error
 *		-1: some error occurred while getting the version number
 *
 *	DESCRIPTION:
 *		get the version number of the keystore from keystore
 *		description file.
 */
int
soft_keystore_get_version(uint_t *version, boolean_t lock_held)
{

	int fd, ret_val = 0;
	uint_t buf;

	if ((fd = open_and_lock_keystore_desc(O_RDONLY,
	    B_TRUE, lock_held)) < 0) {
		return (-1);
	}

	if (lseek(fd, KS_VER_OFFSET, SEEK_SET) != KS_VER_OFFSET) {
		ret_val = -1;
		goto cleanup;
	}

	if (looping_read(fd, (char *)&buf, KS_VER_SIZE) != KS_VER_SIZE) {
		ret_val = -1;
		goto cleanup;
	}
	*version = SWAP32(buf);

cleanup:

	if (!lock_held) {
		if (lock_file(fd, B_TRUE, B_FALSE) < 0) {
			ret_val = -1;
		}
	}

	(void) close(fd);
	return (ret_val);
}

/*
 *	FUNCTION: soft_keystore_get_object_version
 *
 *	ARGUMENTS:
 *
 *		ks_handle: handle of the key store object to be accessed.
 *		version:
 *			pointer to caller allocated memory for storing
 *			the version of the object.
 *		lock_held: TRUE if the lock is held by caller.
 *
 *	RETURN VALUE:
 *
 *		0: no error
 *		-1: some error occurred while getting the pin
 *
 *	DESCRIPTION:
 *		get the version number of the specified token object.
 */
int
soft_keystore_get_object_version(ks_obj_handle_t *ks_handle,
    uint_t *version, boolean_t lock_held)
{
	int fd, ret_val = 0;
	uint_t tmp;

	if ((fd = open_and_lock_object_file(ks_handle, O_RDONLY,
	    lock_held)) < 0) {
		return (-1);
	}

	/*
	 * read version.  Version is always first item in object file
	 * so, no need to do lseek
	 */
	if (looping_read(fd, (char *)&tmp, OBJ_VER_SIZE) != OBJ_VER_SIZE) {
		ret_val = -1;
		goto cleanup;
	}

	*version = SWAP32(tmp);

cleanup:
	if (!lock_held) {
		if (lock_file(fd, B_TRUE, B_FALSE) < 0) {
			ret_val = -1;
		}
	}


	(void) close(fd);
	return (ret_val);
}

/*
 *		FUNCTION: soft_keystore_getpin
 *
 *		ARGUMENTS:
 *			hashed_pin: pointer to caller allocated memory
 *				for storing the pin to be returned.
 *			lock_held: TRUE if the lock is held by caller.
 *
 *		RETURN VALUE:
 *
 *			0: no error
 *			-1: some error occurred while getting the pin
 *
 *		DESCRIPTION:
 *
 *			Reads the MD5 hash from the keystore description
 *			file and return it to the caller in the provided
 *			buffer. If there is no PIN in the description file
 *			because the file is just created, this function
 *			will get a MD5 digest of the string "changeme",
 *			store it in the file, and also return this
 *			string to the caller.
 */
int
soft_keystore_getpin(char **hashed_pin, boolean_t lock_held)
{
	int fd, ret_val = -1;
	CK_RV rv;

	if ((fd = open_and_lock_keystore_desc(O_RDONLY, B_TRUE,
	    lock_held)) < 0) {
		return (-1);
	}

	rv = get_hashed_pin(fd, hashed_pin);
	if (rv == CKR_OK) {
		ret_val = 0;
	}

cleanup:
	if (!lock_held) {
		if (lock_file(fd, B_TRUE, B_FALSE) < 0) {
			ret_val = -1;
		}
	}

	(void) close(fd);
	return (ret_val);
}

/*
 * This function reads all the data until the end of the file, and
 * put the data into the "buf" in argument.  Memory for buf will
 * be allocated in this function.  It is the caller's responsibility
 * to free it.  The number of bytes read will be returned
 * in the argument "bytes_read"
 *
 * returns CKR_OK if no error.  Other CKR error codes if there's an error
 */
static CK_RV
read_obj_data(int old_fd, char **buf, ssize_t *bytes_read)
{

	ssize_t nread, loop_count;
	char *buf1 = NULL;

	*buf = malloc(BUFSIZ);
	if (*buf == NULL) {
		return (CKR_HOST_MEMORY);
	}

	nread = looping_read(old_fd, *buf, BUFSIZ);
	if (nread < 0) {
		free(*buf);
		return (CKR_FUNCTION_FAILED);
	}
	loop_count = 1;
	while (nread == (loop_count * BUFSIZ)) {
		ssize_t nread_tmp;

		loop_count++;
		/* more than BUFSIZ of data */
		buf1 = realloc(*buf, loop_count * BUFSIZ);
		if (buf1 == NULL) {
			free(*buf);
			return (CKR_HOST_MEMORY);
		}
		*buf = buf1;
		nread_tmp = looping_read(old_fd,
		    *buf + ((loop_count - 1) * BUFSIZ), BUFSIZ);
		if (nread_tmp < 0) {
			free(*buf);
			return (CKR_FUNCTION_FAILED);
		}
		nread += nread_tmp;
	}
	*bytes_read = nread;
	return (CKR_OK);
}

/*
 * Re-encrypt an object using the provided new_enc_key.  The new HMAC
 * is calculated using the new_hmac_key.  The global static variables
 * enc_key, and hmac_key will be used for decrypting the original
 * object, and verifying its signature.
 *
 * The re-encrypted object will be stored in the file named
 * in the "new_obj_name" variable.  The content of the "original"
 * file named in "orig_obj_name" is not disturbed.
 *
 * Returns 0 if there's no error, returns -1 otherwise.
 *
 */
static int
reencrypt_obj(soft_object_t *new_enc_key, soft_object_t *new_hmac_key,
    char *orig_obj_name, char *new_obj_name) {

	int old_fd, new_fd, version, ret_val = -1;
	CK_BYTE iv[OBJ_IV_SIZE], old_iv[OBJ_IV_SIZE];
	ssize_t nread;
	CK_ULONG decrypted_len, encrypted_len, hmac_len;
	CK_BYTE hmac[OBJ_HMAC_SIZE], *decrypted_buf = NULL, *buf = NULL;

	while ((old_fd = open(orig_obj_name, O_RDONLY|O_NONBLOCK)) < 0) {
		if (errno != EINTR)
			break;
	}
	if (old_fd < 0) {
		return (-1);
	}

	(void) fcntl(old_fd, F_SETFD, FD_CLOEXEC);

	if (acquire_file_lock(&old_fd, orig_obj_name, O_RDONLY) != 0) {
		if (old_fd > 0) {
			(void) close(old_fd);
		}
		return (-1);
	}

	while ((new_fd = open(new_obj_name,
	    O_WRONLY|O_CREAT|O_EXCL|O_NONBLOCK, S_IRUSR|S_IWUSR)) < 0) {
			if (errno != EINTR)
				break;
	}
	if (new_fd < 0) {
		(void) close(old_fd);
		return (-1);
	}

	(void) fcntl(new_fd, F_SETFD, FD_CLOEXEC);

	if (lock_file(new_fd, B_FALSE, B_TRUE) != 0) {
		/* unlock old file */
		(void) lock_file(old_fd, B_TRUE, B_FALSE);
		(void) close(old_fd);
		(void) close(new_fd);
		return (-1);
	}

	/* read version, increment, and write to tmp file */
	if (looping_read(old_fd, (char *)&version, OBJ_VER_SIZE)
	    != OBJ_VER_SIZE) {
		goto cleanup;
	}

	version = SWAP32(version);
	version++;
	version = SWAP32(version);

	if (looping_write(new_fd, (char *)&version, OBJ_VER_SIZE)
	    != OBJ_VER_SIZE) {
		goto cleanup;
	}

	/* read old iv */
	if (looping_read(old_fd, (char *)old_iv, OBJ_IV_SIZE) != OBJ_IV_SIZE) {
		goto cleanup;
	}

	/* generate new IV */
	if (soft_gen_iv(iv) != CKR_OK) {
		goto cleanup;
	}

	if (looping_write(new_fd, (char *)iv, OBJ_IV_SIZE) != OBJ_IV_SIZE) {
		goto cleanup;
	}

	/* seek to the original encrypted data, and read all of them */
	if (lseek(old_fd, OBJ_DATA_OFFSET, SEEK_SET) != OBJ_DATA_OFFSET) {
		goto cleanup;
	}

	if (read_obj_data(old_fd, (char **)&buf, &nread) != CKR_OK) {
		goto cleanup;
	}

	/* decrypt data using old key */
	decrypted_len = 0;
	if (soft_keystore_crypt(enc_key, old_iv, B_FALSE, buf, nread,
	    NULL, &decrypted_len) != CKR_OK) {
		free(buf);
		goto cleanup;
	}

	decrypted_buf = malloc(decrypted_len);
	if (decrypted_buf == NULL) {
		free(buf);
		goto cleanup;
	}

	if (soft_keystore_crypt(enc_key, old_iv, B_FALSE, buf, nread,
	    decrypted_buf, &decrypted_len) != CKR_OK) {
		free(buf);
		free(decrypted_buf);
		goto cleanup;
	}

	free(buf);

	/* re-encrypt with new key */
	encrypted_len = 0;
	if (soft_keystore_crypt(new_enc_key, iv, B_TRUE, decrypted_buf,
	    decrypted_len, NULL, &encrypted_len) != CKR_OK) {
		free(decrypted_buf);
		goto cleanup;
	}

	buf = malloc(encrypted_len);
	if (buf == NULL) {
		free(decrypted_buf);
		goto cleanup;
	}

	if (soft_keystore_crypt(new_enc_key, iv, B_TRUE, decrypted_buf,
	    decrypted_len, buf, &encrypted_len) != CKR_OK) {
		free(buf);
		free(decrypted_buf);
		goto cleanup;
	}

	free(decrypted_buf);

	/* calculate hmac on re-encrypted data using new hmac key */
	hmac_len = OBJ_HMAC_SIZE;
	if (soft_keystore_hmac(new_hmac_key, B_TRUE, buf,
	    encrypted_len, hmac, &hmac_len) != CKR_OK) {
		free(buf);
		goto cleanup;
	}

	/* just for sanity check */
	if (hmac_len != OBJ_HMAC_SIZE) {
		free(buf);
		goto cleanup;
	}

	/* write new hmac */
	if (looping_write(new_fd, (char *)hmac, OBJ_HMAC_SIZE)
	    != OBJ_HMAC_SIZE) {
		free(buf);
		goto cleanup;
	}

	/* write re-encrypted buffer to temp file */
	if (looping_write(new_fd, (void *)buf, encrypted_len)
	    != encrypted_len) {
		free(buf);
		goto cleanup;
	}
	free(buf);
	ret_val = 0;

cleanup:
	/* unlock the files */
	(void) lock_file(old_fd, B_TRUE, B_FALSE);
	(void) lock_file(new_fd, B_FALSE, B_FALSE);

	(void) close(old_fd);
	(void) close(new_fd);
	if (ret_val != 0) {
		(void) remove(new_obj_name);
	}
	return (ret_val);
}

/*
 *	FUNCTION: soft_keystore_setpin
 *
 *	ARGUMENTS:
 *		newpin: new pin entered by the user.
 *		lock_held: TRUE if the lock is held by caller.
 *
 *	RETURN VALUE:
 *		0: no error
 *		-1: failure
 *
 *	DESCRIPTION:
 *
 *		This function does the following:
 *
 *		1) Generates crypted value of newpin and store it
 *		   in keystore description file.
 *		2) Dervies the new encryption key from the newpin.  This key
 *		   will be used to re-encrypt the private token objects.
 *		3) Re-encrypt all of this user's existing private token
 *		   objects (if any).
 *		4) Increments the keystore version number.
 */
int
soft_keystore_setpin(uchar_t *oldpin, uchar_t *newpin, boolean_t lock_held)
{
	int fd, tmp_ks_fd, version, ret_val = -1;
	soft_object_t *new_crypt_key = NULL, *new_hmac_key = NULL;
	char filebuf[BUFSIZ];
	DIR	*pri_dirp;
	struct dirent *pri_ent = NULL, *result = NULL;
	char pri_obj_path[MAXPATHLEN], ks_desc_file[MAXPATHLEN],
	    tmp_ks_desc_name[MAXPATHLEN];
	typedef struct priobjs {
		char orig_name[MAXPATHLEN];
		char tmp_name[MAXPATHLEN];
		struct priobjs *next;
	} priobjs_t;
	priobjs_t *pri_objs = NULL, *tmp;
	CK_BYTE *crypt_salt = NULL, *hmac_salt = NULL;
	boolean_t pin_never_set = B_FALSE, user_logged_in;
	char *new_hashed_pin = NULL;
	uint64_t hashed_pin_salt_length, new_hashed_pin_len, swaped_val;
	char *hashed_pin_salt = NULL;
	priobjs_t *obj;

	if ((enc_key == NULL) ||
	    (enc_key->magic_marker != SOFTTOKEN_OBJECT_MAGIC)) {
		user_logged_in = B_FALSE;
	} else {
		user_logged_in = B_TRUE;
	}

	if ((fd = open_and_lock_keystore_desc(O_RDWR, B_FALSE,
	    lock_held)) < 0) {
		return (-1);
	}

	(void) get_desc_file_path(ks_desc_file);
	(void) get_tmp_desc_file_path(tmp_ks_desc_name);

	/*
	 * create a tempoary file for the keystore description
	 * file for updating version and counter information
	 */
	while ((tmp_ks_fd = open(tmp_ks_desc_name,
	    O_RDWR|O_CREAT|O_EXCL|O_NONBLOCK, S_IRUSR|S_IWUSR)) < 0) {
		if (errno != EINTR)
			break;
	}
	if (tmp_ks_fd < 0) {
		(void) close(fd);
		return (-1);
	}
	(void) fcntl(tmp_ks_fd, F_SETFD, FD_CLOEXEC);

	/* read and write PKCS version to temp file */
	if (looping_read(fd, filebuf, KS_PKCS11_VER_SIZE)
	    != KS_PKCS11_VER_SIZE) {
		goto cleanup;
	}

	if (looping_write(tmp_ks_fd, filebuf, KS_PKCS11_VER_SIZE)
	    != KS_PKCS11_VER_SIZE) {
		goto cleanup;
	}

	/* get version number, and write updated number to temp file */
	if (looping_read(fd, &version, KS_VER_SIZE) != KS_VER_SIZE) {
		goto cleanup;
	}

	version = SWAP32(version);
	version++;
	version = SWAP32(version);

	if (looping_write(tmp_ks_fd, (void *)&version, KS_VER_SIZE)
	    != KS_VER_SIZE) {
		goto cleanup;
	}


	/* read and write counter, no modification necessary */
	if (looping_read(fd, filebuf, KS_COUNTER_SIZE) != KS_COUNTER_SIZE) {
		goto cleanup;
	}

	if (looping_write(tmp_ks_fd, filebuf, KS_COUNTER_SIZE)
	    != KS_COUNTER_SIZE) {
		goto cleanup;
	}

	/* read old encryption salt */
	crypt_salt = malloc(KS_KEY_SALT_SIZE);
	if (crypt_salt == NULL) {
		goto cleanup;
	}
	if (looping_read(fd, (char *)crypt_salt, KS_KEY_SALT_SIZE)
	    != KS_KEY_SALT_SIZE) {
		goto cleanup;
	}

	/* read old hmac salt */
	hmac_salt = malloc(KS_HMAC_SALT_SIZE);
	if (hmac_salt == NULL) {
		goto cleanup;
	}
	if (looping_read(fd, (char *)hmac_salt, KS_HMAC_SALT_SIZE)
	    != KS_HMAC_SALT_SIZE) {
		goto cleanup;
	}

	/* just create some empty bytes */
	bzero(filebuf, sizeof (filebuf));

	if (memcmp(crypt_salt, filebuf, KS_KEY_SALT_SIZE) == 0) {
		/* PIN as never been set */
		CK_BYTE *new_crypt_salt = NULL, *new_hmac_salt = NULL;

		pin_never_set = B_TRUE;
		if (soft_gen_crypt_key(newpin, &new_crypt_key, &new_crypt_salt)
		    != CKR_OK) {
			goto cleanup;
		}
		if (looping_write(tmp_ks_fd, (void *)new_crypt_salt,
		    KS_KEY_SALT_SIZE) != KS_KEY_SALT_SIZE) {
			free(new_crypt_salt);
			(void) soft_cleanup_object(new_crypt_key);
			goto cleanup;
		}
		free(new_crypt_salt);

		if (soft_gen_hmac_key(newpin, &new_hmac_key, &new_hmac_salt)
		    != CKR_OK) {
			(void) soft_cleanup_object(new_crypt_key);
			goto cleanup;
		}
		if (looping_write(tmp_ks_fd, (void *)new_hmac_salt,
		    KS_HMAC_SALT_SIZE) != KS_HMAC_SALT_SIZE) {
			free(new_hmac_salt);
			goto cleanup3;
		}
		free(new_hmac_salt);
	} else {
		if (soft_gen_crypt_key(newpin, &new_crypt_key,
		    (CK_BYTE **)&crypt_salt) != CKR_OK) {
			goto cleanup;
		}
		/* no change to the encryption salt */
		if (looping_write(tmp_ks_fd, (void *)crypt_salt,
		    KS_KEY_SALT_SIZE) != KS_KEY_SALT_SIZE) {
			(void) soft_cleanup_object(new_crypt_key);
			goto cleanup;
		}

		if (soft_gen_hmac_key(newpin, &new_hmac_key,
		    (CK_BYTE **)&hmac_salt) != CKR_OK) {
			(void) soft_cleanup_object(new_crypt_key);
			goto cleanup;
		}

		/* no change to the hmac salt */
		if (looping_write(tmp_ks_fd, (void *)hmac_salt,
		    KS_HMAC_SALT_SIZE) != KS_HMAC_SALT_SIZE) {
			goto cleanup3;
		}
	}

	/*
	 * read hashed pin salt, and write to updated keystore description
	 * file unmodified.
	 */
	if (looping_read(fd, (char *)&hashed_pin_salt_length,
	    KS_HASHED_PIN_SALT_LEN_SIZE) != KS_HASHED_PIN_SALT_LEN_SIZE) {
		goto cleanup3;
	}

	if (looping_write(tmp_ks_fd, (void *)&hashed_pin_salt_length,
	    KS_HASHED_PIN_SALT_LEN_SIZE) != KS_HASHED_PIN_SALT_LEN_SIZE) {
		goto cleanup3;
	}

	hashed_pin_salt_length = SWAP64(hashed_pin_salt_length);

	hashed_pin_salt = malloc(hashed_pin_salt_length + 1);
	if (hashed_pin_salt == NULL) {
		goto cleanup3;
	}

	if ((looping_read(fd, hashed_pin_salt, hashed_pin_salt_length)) !=
	    (ssize_t)hashed_pin_salt_length) {
		free(hashed_pin_salt);
		goto cleanup3;
	}

	if ((looping_write(tmp_ks_fd, hashed_pin_salt, hashed_pin_salt_length))
	    != (ssize_t)hashed_pin_salt_length) {
		free(hashed_pin_salt);
		goto cleanup3;
	}

	hashed_pin_salt[hashed_pin_salt_length] = '\0';

	/* old hashed pin length and value can be ignored, generate new one */
	if (soft_gen_hashed_pin(newpin, &new_hashed_pin,
	    &hashed_pin_salt) < 0) {
		free(hashed_pin_salt);
		goto cleanup3;
	}

	free(hashed_pin_salt);

	if (new_hashed_pin == NULL) {
		goto cleanup3;
	}

	new_hashed_pin_len = strlen(new_hashed_pin);

	/* write new hashed pin length to file */
	swaped_val = SWAP64(new_hashed_pin_len);
	if (looping_write(tmp_ks_fd, (void *)&swaped_val,
	    KS_HASHED_PINLEN_SIZE) != KS_HASHED_PINLEN_SIZE) {
		goto cleanup3;
	}

	if (looping_write(tmp_ks_fd, (void *)new_hashed_pin,
	    new_hashed_pin_len) != (ssize_t)new_hashed_pin_len) {
		goto cleanup3;
	}

	if (pin_never_set) {
		/* there was no private object, no need to re-encrypt them */
		goto rename_desc_file;
	}

	/* re-encrypt all the private objects */
	pri_dirp = opendir(get_pri_obj_path(pri_obj_path));
	if (pri_dirp == NULL) {
		/*
		 * this directory should exist, even if it doesn't contain
		 * any objects.  Don't want to update the pin if the
		 * keystore is somehow messed up.
		 */

		goto cleanup3;
	}

	/* if user did not login, need to set the old pin */
	if (!user_logged_in) {
		if (soft_keystore_authpin(oldpin) != 0) {
			goto cleanup3;
		}
	}

	pri_ent = malloc(pathconf(pri_obj_path, _PC_NAME_MAX) + 1
	    + sizeof (struct dirent));
	if (pri_ent == NULL) {
		goto cleanup2;
	}

	while (readdir_r(pri_dirp, pri_ent, &result) == 0) {
		if (result == NULL) {
			break;
		}

		if ((strcmp(pri_ent->d_name, ".") == 0) ||
		    (strcmp(pri_ent->d_name, "..") == 0) ||
		    (strncmp(pri_ent->d_name, TMP_OBJ_PREFIX,
		    strlen(TMP_OBJ_PREFIX)) == 0)) {
			continue;
		}

		obj = malloc(sizeof (priobjs_t));
		if (obj == NULL) {
			free(pri_ent);
			goto cleanup2;
		}
		(void) snprintf(obj->orig_name, MAXPATHLEN,
		    "%s/%s", pri_obj_path, pri_ent->d_name);
		(void) snprintf(obj->tmp_name, MAXPATHLEN, "%s/%s%s",
		    pri_obj_path, TMP_OBJ_PREFIX,
		    (pri_ent->d_name) + strlen(OBJ_PREFIX));
		if (reencrypt_obj(new_crypt_key, new_hmac_key,
		    obj->orig_name, obj->tmp_name) != 0) {
			free(pri_ent);
			free(obj);
			goto cleanup2;
		}

		/* insert into list of file to be renamed */
		if (pri_objs == NULL) {
			obj->next = NULL;
			pri_objs = obj;
		} else {
			obj->next = pri_objs;
			pri_objs = obj;
		}
	}
	free(pri_ent);

	/* rename all the private objects */
	tmp = pri_objs;
	while (tmp) {
		(void) rename(tmp->tmp_name, tmp->orig_name);
		tmp = tmp->next;
	}

rename_desc_file:

	/* destroy the old encryption key, and hmac key */
	if ((!pin_never_set) && (user_logged_in)) {
		(void) soft_cleanup_object(enc_key);
		(void) soft_cleanup_object(hmac_key);
	}

	if (user_logged_in) {
		enc_key = new_crypt_key;
		hmac_key = new_hmac_key;
	}
	(void) rename(tmp_ks_desc_name, ks_desc_file);

	ret_val = 0;

cleanup2:
	if (pri_objs != NULL) {
		priobjs_t *p = pri_objs;
		while (p) {
			tmp = p->next;
			free(p);
			p = tmp;
		}
	}
	if (!pin_never_set) {
		(void) closedir(pri_dirp);
	}

	if ((!user_logged_in) && (!pin_never_set)) {
		(void) soft_cleanup_object(enc_key);
		(void) soft_cleanup_object(hmac_key);
		enc_key = NULL;
		hmac_key = NULL;
	}
cleanup3:
	if ((ret_val != 0) || (!user_logged_in)) {
		(void) soft_cleanup_object(new_crypt_key);
		(void) soft_cleanup_object(new_hmac_key);
	}

cleanup:
	if (!lock_held) {
		if (lock_file(fd, B_FALSE, B_FALSE) < 0) {
			ret_val = 1;
		}
	}
	if (crypt_salt != NULL) {
		free(crypt_salt);
	}
	if (hmac_salt != NULL) {
		free(hmac_salt);
	}
	(void) close(fd);
	(void) close(tmp_ks_fd);
	if (ret_val != 0) {
		(void) remove(tmp_ks_desc_name);
	}
	return (ret_val);
}

/*
 *	FUNCTION: soft_keystore_authpin
 *
 *	ARGUMENTS:
 *		pin: pin specified by the user for logging into
 *		     the keystore.
 *
 *	RETURN VALUE:
 *		0: if no error
 *		-1: if there is any error
 *
 *	DESCRIPTION:
 *
 *		This function takes the pin specified in the argument
 *		and generates an encryption key based on the pin.
 *		The generated encryption key will be used for
 *		all future encryption and decryption for private
 *		objects.  Before this function is called, none
 *		of the keystore related interfaces is able
 *		to decrypt/encrypt any private object.
 */
int
soft_keystore_authpin(uchar_t  *pin)
{
	int fd;
	int ret_val = -1;
	CK_BYTE *crypt_salt = NULL, *hmac_salt;

	/* get the salt from the keystore description file */
	if ((fd = open_and_lock_keystore_desc(O_RDONLY,
	    B_FALSE, B_FALSE)) < 0) {
		return (-1);
	}

	crypt_salt = malloc(KS_KEY_SALT_SIZE);
	if (crypt_salt == NULL) {
		goto cleanup;
	}

	if (lseek(fd, KS_KEY_SALT_OFFSET, SEEK_SET) != KS_KEY_SALT_OFFSET) {
		goto cleanup;
	}

	if (looping_read(fd, (char *)crypt_salt, KS_KEY_SALT_SIZE)
	    != KS_KEY_SALT_SIZE) {
		goto cleanup;
	}

	if (soft_gen_crypt_key(pin, &enc_key, (CK_BYTE **)&crypt_salt)
	    != CKR_OK) {
		goto cleanup;
	}

	hmac_salt = malloc(KS_HMAC_SALT_SIZE);
	if (hmac_salt == NULL) {
		goto cleanup;
	}

	if (lseek(fd, KS_HMAC_SALT_OFFSET, SEEK_SET) != KS_HMAC_SALT_OFFSET) {
		goto cleanup;
	}

	if (looping_read(fd, (char *)hmac_salt, KS_HMAC_SALT_SIZE)
	    != KS_HMAC_SALT_SIZE) {
		goto cleanup;
	}

	if (soft_gen_hmac_key(pin, &hmac_key, (CK_BYTE **)&hmac_salt)
	    != CKR_OK) {
		goto cleanup;
	}

	ret_val = 0;

cleanup:
	/* unlock the file */
	(void) lock_file(fd, B_TRUE, B_FALSE);
	(void) close(fd);
	if (crypt_salt != NULL) {
		free(crypt_salt);
	}
	if (hmac_salt != NULL) {
		free(hmac_salt);
	}
	return (ret_val);
}

/*
 * 	FUNCTION: soft_keystore_get_objs
 *
 *	ARGUMENTS:
 *
 *		search_type: Specify type of objects to return.
 *		lock_held: TRUE if the lock is held by caller.
 *
 *
 *	RETURN VALUE:
 *
 *		NULL: if there are no object in the database.
 *
 *		Otherwise, linked list of objects as requested
 *		in search type.
 *
 *		The linked list returned will need to be freed
 *		by the caller.
 *
 *	DESCRIPTION:
 *
 *		Returns objects as requested.
 *
 *		If private objects is requested, and the caller
 *		has not previously passed in the pin or if the pin
 *		passed in is wrong, private objects will not
 *		be returned.
 *
 *		The buffers returned for private objects are already
 *		decrypted.
 */
CK_RV
soft_keystore_get_objs(ks_search_type_t search_type,
    ks_obj_t **result_obj_list, boolean_t lock_held)
{
	DIR *dirp;
	ks_obj_handle_t ks_handle;
	CK_RV rv;
	ks_obj_t *tmp;
	int ks_fd;

	*result_obj_list = NULL;

	/*
	 * lock the keystore description file in "read" mode so that
	 * objects won't get added/deleted/modified while we are
	 * doing the search
	 */
	if ((ks_fd = open_and_lock_keystore_desc(O_RDONLY, B_TRUE,
	    B_FALSE)) < 0) {
		return (CKR_FUNCTION_FAILED);
	}

	if ((search_type == ALL_TOKENOBJS) || (search_type == PUB_TOKENOBJS)) {

		char pub_obj_path[MAXPATHLEN];

		ks_handle.public = B_TRUE;

		if ((dirp = opendir(get_pub_obj_path(pub_obj_path))) == NULL) {
			(void) lock_file(ks_fd, B_TRUE, B_FALSE);
			(void) close(ks_fd);
			return (CKR_FUNCTION_FAILED);
		}
		rv = get_all_objs_in_dir(dirp, &ks_handle, result_obj_list,
		    lock_held, pub_obj_path);
		if (rv != CKR_OK) {
			(void) closedir(dirp);
			goto cleanup;
		}

		(void) closedir(dirp);
	}

	if ((search_type == ALL_TOKENOBJS) || (search_type == PRI_TOKENOBJS)) {

		char pri_obj_path[MAXPATHLEN];

		if ((enc_key == NULL) ||
		    (enc_key->magic_marker != SOFTTOKEN_OBJECT_MAGIC)) {
			/* has not login - no need to go any further */
			(void) lock_file(ks_fd, B_TRUE, B_FALSE);
			(void) close(ks_fd);
			return (CKR_OK);
		}

		ks_handle.public = B_FALSE;

		if ((dirp = opendir(get_pri_obj_path(pri_obj_path))) == NULL) {
			(void) lock_file(ks_fd, B_TRUE, B_FALSE);
			(void) close(ks_fd);
			return (CKR_OK);
		}
		rv = get_all_objs_in_dir(dirp, &ks_handle, result_obj_list,
		    lock_held, pri_obj_path);
		if (rv != CKR_OK) {
			(void) closedir(dirp);
			goto cleanup;
		}

		(void) closedir(dirp);
	}
	/* close the keystore description file */
	(void) lock_file(ks_fd, B_TRUE, B_FALSE);
	(void) close(ks_fd);
	return (CKR_OK);
cleanup:

	/* close the keystore description file */
	(void) lock_file(ks_fd, B_TRUE, B_FALSE);
	(void) close(ks_fd);

	/* free all the objects found before hitting the error */
	tmp = *result_obj_list;
	while (tmp) {
		*result_obj_list = tmp->next;
		free(tmp->buf);
		free(tmp);
		tmp = *result_obj_list;
	}
	*result_obj_list = NULL;
	return (rv);
}


/*
 *	FUNCTION: soft_keystore_get_single_obj
 *
 *	ARGUMENTS:
 *		ks_handle: handle of the key store object to be accessed
 *		lock_held: TRUE if the lock is held by caller.
 *
 *	RETURN VALUE:
 *
 *		NULL: if handle doesn't match any object
 *
 *		Otherwise, the object is returned in
 *		the same structure used in soft_keystore_get_objs().
 *		The structure need to be freed by the caller.
 *
 *	DESCRIPTION:
 *
 *		Retrieves the object specified by the object
 *		handle to the caller.
 *
 *		If a private object is requested, and the caller
 *		has not previously passed in the pin or if the pin
 *		passed in is wrong, the requested private object will not
 *		be returned.
 *
 *		The buffer returned for the requested private object
 *		is already decrypted.
 */
CK_RV
soft_keystore_get_single_obj(ks_obj_handle_t *ks_handle,
    ks_obj_t **return_obj, boolean_t lock_held)
{

	ks_obj_t *obj;
	uchar_t iv[OBJ_IV_SIZE], obj_hmac[OBJ_HMAC_SIZE];
	uchar_t *buf, *decrypted_buf;
	int fd;
	ssize_t nread;
	CK_RV rv = CKR_FUNCTION_FAILED;

	if (!(ks_handle->public)) {
		if ((enc_key == NULL) ||
		    (enc_key->magic_marker != SOFTTOKEN_OBJECT_MAGIC)) {
			return (CKR_FUNCTION_FAILED);
		}
	}

	if ((fd = open_and_lock_object_file(ks_handle, O_RDONLY,
	    lock_held)) < 0) {
		return (CKR_FUNCTION_FAILED);
	}

	obj = malloc(sizeof (ks_obj_t));
	if (obj == NULL) {
		return (CKR_HOST_MEMORY);
	}

	obj->next = NULL;

	(void) strcpy((char *)((obj->ks_handle).name),
	    (char *)ks_handle->name);
	(obj->ks_handle).public = ks_handle->public;

	/* 1st get the version */
	if (looping_read(fd, &(obj->obj_version), OBJ_VER_SIZE)
	    != OBJ_VER_SIZE) {
		goto cleanup;
	}
	obj->obj_version = SWAP32(obj->obj_version);

	/* Then, read the IV */
	if (looping_read(fd, iv, OBJ_IV_SIZE) != OBJ_IV_SIZE) {
		goto cleanup;
	}

	/* Then, read the HMAC */
	if (looping_read(fd, obj_hmac, OBJ_HMAC_SIZE) != OBJ_HMAC_SIZE) {
		goto cleanup;
	}

	/* read the object */
	rv = read_obj_data(fd, (char **)&buf, &nread);
	if (rv != CKR_OK) {
		goto cleanup;
	}

	if (ks_handle->public) {
		obj->size = nread;
		obj->buf = buf;
		*return_obj = obj;
	} else {

		CK_ULONG out_len = 0, hmac_size;

		/* verify HMAC of the object, make sure it matches */
		hmac_size = OBJ_HMAC_SIZE;
		if (soft_keystore_hmac(hmac_key, B_FALSE, buf,
		    nread, obj_hmac, &hmac_size) != CKR_OK) {
			free(buf);
			rv = CKR_FUNCTION_FAILED;
			goto cleanup;
		}

		/* decrypt object */
		if (soft_keystore_crypt(enc_key, iv, B_FALSE, buf, nread,
		    NULL, &out_len) != CKR_OK) {
			free(buf);
			rv = CKR_FUNCTION_FAILED;
			goto cleanup;
		}

		decrypted_buf = malloc(sizeof (uchar_t) * out_len);
		if (decrypted_buf == NULL) {
			free(buf);
			rv = CKR_HOST_MEMORY;
			goto cleanup;
		}

		if (soft_keystore_crypt(enc_key, iv, B_FALSE, buf, nread,
		    decrypted_buf, &out_len) != CKR_OK) {
			free(decrypted_buf);
			free(buf);
			rv = CKR_FUNCTION_FAILED;
			goto cleanup;
		}

		obj->size = out_len - MAXPATHLEN;

		/*
		 * decrypted buf here actually contains full path name of
		 * object plus the actual data.  so, need to skip the
		 * full pathname.
		 * See prepare_data_for_encrypt() function in the file
		 * to understand how and why the pathname is added.
		 */
		obj->buf = malloc(sizeof (uchar_t) * (out_len - MAXPATHLEN));
		if (obj->buf == NULL) {
			free(decrypted_buf);
			free(buf);
			rv = CKR_HOST_MEMORY;
			goto cleanup;
		}
		(void) memcpy(obj->buf, decrypted_buf + MAXPATHLEN, obj->size);
		free(decrypted_buf);
		free(buf);
		*return_obj = obj;
	}

cleanup:

	if (rv != CKR_OK) {
		free(obj);
	}

	/* unlock the file after reading */
	if (!lock_held) {
		(void) lock_file(fd, B_TRUE, B_FALSE);
	}

	(void) close(fd);

	return (rv);
}


/*
 * 	FUNCTION: soft_keystore_put_new_obj
 *
 *	ARGUMENTS:
 *		buf: buffer containing un-encrypted data
 *		     to be stored in keystore.
 *		len: length of data
 *		public:  TRUE if it is a public object,
 *			 FALSE if it is private obj
 *		lock_held: TRUE if the lock is held by caller.
 *		keyhandle: pointer to object handle to
 *			   receive keyhandle for new object
 *
 *	RETURN VALUE:
 *		0: object successfully stored in file
 *		-1: some error occurred, object is not stored in file.
 *
 *	DESCRIPTION:
 *		This API is used to write a newly created token object
 *		to keystore.
 *
 *		This function does the following:
 *
 *		1) Creates a token object file based on "public" parameter.
 *		2) Generates a new IV and stores it in obj_meta_data_t if it is
 *		   private object.
 *		3) Set object version number to 1.
 *		4) If it is a private object, it will be encrypted before
 *		   being written to the newly created keystore token object
 *		   file.
 *		5) Calculates the obj_chksum in obj_meta_data_t.
 *		6) Calculates the pin_chksum in obj_meta_data_t.
 *		7) Increments the keystore version number.
 */
int
soft_keystore_put_new_obj(uchar_t *buf, size_t len, boolean_t public,
    boolean_t lock_held, ks_obj_handle_t *keyhandle)
{

	int fd, tmp_ks_fd, obj_fd;
	unsigned int counter, version;
	uchar_t obj_hmac[OBJ_HMAC_SIZE];
	CK_BYTE iv[OBJ_IV_SIZE];
	char obj_name[MAXPATHLEN], tmp_ks_desc_name[MAXPATHLEN];
	char filebuf[BUFSIZ];
	char pub_obj_path[MAXPATHLEN], pri_obj_path[MAXPATHLEN],
	    ks_desc_file[MAXPATHLEN];
	CK_ULONG hmac_size;
	ssize_t nread;

	if (keyhandle == NULL) {
		return (-1);
	}

	/* if it is private object, make sure we have the key */
	if (!public) {
		if ((enc_key == NULL) ||
		    (enc_key->magic_marker != SOFTTOKEN_OBJECT_MAGIC)) {
			return (-1);
		}
	}

	/* open keystore, and set write lock */
	if ((fd = open_and_lock_keystore_desc(O_RDWR, B_TRUE,
	    lock_held)) < 0) {
		return (-1);
	}

	(void) get_desc_file_path(ks_desc_file);
	(void) get_tmp_desc_file_path(tmp_ks_desc_name);

	/*
	 * create a tempoary file for the keystore description
	 * file for updating version and counter information
	 */
	while ((tmp_ks_fd = open(tmp_ks_desc_name,
	    O_RDWR|O_CREAT|O_EXCL|O_NONBLOCK, S_IRUSR|S_IWUSR)) < 0) {
		if (errno != EINTR)
			break;
	}
	if (tmp_ks_fd < 0) {
		(void) close(fd);
		return (-1);
	}

	(void) fcntl(tmp_ks_fd, F_SETFD, FD_CLOEXEC);

	/* read and write pkcs11 version */
	if (looping_read(fd, filebuf, KS_PKCS11_VER_SIZE)
	    != KS_PKCS11_VER_SIZE) {
		goto cleanup;
	}

	if (looping_write(tmp_ks_fd, filebuf, KS_PKCS11_VER_SIZE)
	    != KS_PKCS11_VER_SIZE) {
		goto cleanup;
	}

	/* get version number, and write updated number to temp file */
	if (looping_read(fd, &version, KS_VER_SIZE) != KS_VER_SIZE) {
		goto cleanup;
	}

	version = SWAP32(version);
	version++;
	version = SWAP32(version);

	if (looping_write(tmp_ks_fd, (void *)&version,
	    KS_VER_SIZE) != KS_VER_SIZE) {
		goto cleanup;
	}

	/* get object count value */
	if (looping_read(fd, &counter, KS_COUNTER_SIZE) != KS_COUNTER_SIZE) {
		goto cleanup;
	}
	counter = SWAP32(counter);

	bzero(obj_name, sizeof (obj_name));
	if (public) {
		(void) snprintf(obj_name, MAXPATHLEN,  "%s/%s%d",
		    get_pub_obj_path(pub_obj_path), OBJ_PREFIX, counter);
	} else {
		(void) snprintf(obj_name, MAXPATHLEN,  "%s/%s%d",
		    get_pri_obj_path(pri_obj_path), OBJ_PREFIX, counter);
	}

	/* create object file */
	while ((obj_fd = open(obj_name,
	    O_WRONLY|O_CREAT|O_EXCL|O_NONBLOCK, S_IRUSR|S_IWUSR)) < 0) {
		if (errno != EINTR)
			break;
	}
	if (obj_fd < 0) {
		/* can't create object file */
		goto cleanup;
	}

	/* mark obj_fd "close on exec" */
	(void) fcntl(obj_fd, F_SETFD, FD_CLOEXEC);

	/* lock object file for writing */
	if (lock_file(obj_fd, B_FALSE, B_TRUE) != 0) {
		(void) close(obj_fd);
		goto cleanup2;
	}

	/* write object meta data */
	version = SWAP32(1);
	if (looping_write(obj_fd, (void *)&version, sizeof (version))
	    != sizeof (version)) {
		goto cleanup2;
	}

	if (public) {
		bzero(iv, sizeof (iv));
	} else {
		/* generate an IV */
		if (soft_gen_iv(iv) != CKR_OK) {
			goto cleanup2;
		}

	}

	if (looping_write(obj_fd, (void *)iv, sizeof (iv)) != sizeof (iv)) {
		goto cleanup2;
	}

	if (public) {

		bzero(obj_hmac, sizeof (obj_hmac));
		if (looping_write(obj_fd, (void *)obj_hmac,
		    sizeof (obj_hmac)) != sizeof (obj_hmac)) {
			goto cleanup2;
		}

		if (looping_write(obj_fd, (char *)buf, len) != len) {
			goto cleanup2;
		}

	} else {

		uchar_t *encrypted_buf, *prepared_buf;
		CK_ULONG out_len = 0, prepared_len;

		if (prepare_data_for_encrypt(obj_name, buf, len,
		    &prepared_buf, &prepared_len) != 0) {
			goto cleanup2;
		}

		if (soft_keystore_crypt(enc_key, iv,
		    B_TRUE, prepared_buf, prepared_len,
		    NULL, &out_len) != CKR_OK) {
			free(prepared_buf);
			goto cleanup2;
		}

		encrypted_buf = malloc(out_len * sizeof (char));
		if (encrypted_buf == NULL) {
			free(prepared_buf);
			goto cleanup2;
		}

		if (soft_keystore_crypt(enc_key, iv,
		    B_TRUE, prepared_buf, prepared_len,
		    encrypted_buf, &out_len) != CKR_OK) {
			free(encrypted_buf);
			free(prepared_buf);
			goto cleanup2;
		}
		free(prepared_buf);

		/* calculate HMAC of encrypted object */
		hmac_size = OBJ_HMAC_SIZE;
		if (soft_keystore_hmac(hmac_key, B_TRUE, encrypted_buf,
		    out_len, obj_hmac, &hmac_size) != CKR_OK) {
			free(encrypted_buf);
			goto cleanup2;
		}

		if (hmac_size != OBJ_HMAC_SIZE) {
			free(encrypted_buf);
			goto cleanup2;
		}

		/* write hmac */
		if (looping_write(obj_fd, (void *)obj_hmac,
		    sizeof (obj_hmac)) != sizeof (obj_hmac)) {
			free(encrypted_buf);
			goto cleanup2;
		}

		/* write encrypted object */
		if (looping_write(obj_fd, (void *)encrypted_buf, out_len)
		    != out_len) {
			free(encrypted_buf);
			goto cleanup2;
		}

		free(encrypted_buf);
	}


	(void) close(obj_fd);
	(void) snprintf((char *)keyhandle->name, sizeof (keyhandle->name),
	    "obj%d", counter);
	keyhandle->public = public;

	/*
	 * store new counter to temp keystore description file.
	 */
	counter++;
	counter = SWAP32(counter);
	if (looping_write(tmp_ks_fd, (void *)&counter,
	    sizeof (counter)) != sizeof (counter)) {
		goto cleanup2;
	}

	/* read rest of keystore description file and store into temp file */
	nread = looping_read(fd, filebuf, sizeof (filebuf));
	while (nread > 0) {
		if (looping_write(tmp_ks_fd, filebuf, nread) != nread) {
			goto cleanup2;
		}
		nread = looping_read(fd, filebuf, sizeof (filebuf));
	}

	(void) close(tmp_ks_fd);
	(void) rename(tmp_ks_desc_name, ks_desc_file);

	if (!lock_held) {
		/* release lock on description file */
		if (lock_file(fd, B_FALSE, B_FALSE) != 0) {
			(void) close(fd);
			return (-1);
		}
	}
	(void) close(fd);
	return (0);

cleanup2:

	/* remove object file.  No need to remove lock first */
	(void) unlink(obj_name);

cleanup:

	(void) close(tmp_ks_fd);
	(void) remove(tmp_ks_desc_name);
	if (!lock_held) {
		/* release lock on description file */
		(void) lock_file(fd, B_FALSE, B_FALSE);
	}

	(void) close(fd);
	return (-1);
}

/*
 *	FUNCTION: soft_keystore_modify_obj
 *
 *	ARGUMENTS:
 *		ks_handle: handle of the key store object to be modified
 *		buf: buffer containing un-encrypted data
 *		     to be modified in keystore.
 *		len: length of data
 *		lock_held: TRUE if the lock is held by caller.
 *
 *	RETURN VALUE:
 *		-1: if any error occurred.
 *		Otherwise, 0 is returned.
 *
 *	DESCRIPTION:
 *
 *		This API is used to write a modified token object back
 *		to keystore.   This function will do the following:
 *
 *		1) If it is a private object, it will be encrypted before
 *		   being written to the corresponding keystore token
 *		   object file.
 *		2) Record incremented object version number.
 *		3) Record incremented keystore version number.
 */
int
soft_keystore_modify_obj(ks_obj_handle_t *ks_handle, uchar_t *buf,
    size_t len, boolean_t lock_held)
{
	int fd, ks_fd, tmp_fd, version;
	char orig_name[MAXPATHLEN], tmp_name[MAXPATHLEN],
	    tmp_ks_name[MAXPATHLEN];
	uchar_t iv[OBJ_IV_SIZE], obj_hmac[OBJ_HMAC_SIZE];
	char pub_obj_path[MAXPATHLEN], pri_obj_path[MAXPATHLEN],
	    ks_desc_file[MAXPATHLEN];
	CK_ULONG hmac_size;

	/* if it is private object, make sure we have the key */
	if (!(ks_handle->public)) {
		if ((enc_key == NULL) ||
		    (enc_key->magic_marker != SOFTTOKEN_OBJECT_MAGIC)) {
			return (-1);
		}
	}

	/* open and lock keystore description file */
	if ((ks_fd = open_and_lock_keystore_desc(O_RDWR, B_FALSE,
	    B_FALSE)) < 0) {
		return (-1);
	}

	(void) get_desc_file_path(ks_desc_file);

	/* update the version of for keystore file in tempoary file */
	(void) get_tmp_desc_file_path(tmp_ks_name);
	if (create_updated_keystore_version(ks_fd, tmp_ks_name) != 0) {
		/* unlock keystore description file */
		(void) lock_file(ks_fd, B_FALSE, B_FALSE);
		(void) close(ks_fd);
		return (-1);
	}

	/* open object file */
	if ((fd = open_and_lock_object_file(ks_handle, O_RDWR,
	    lock_held)) < 0) {
		goto cleanup;
	}

	/*
	 * make the change in a temporary file.  Create the temp
	 * file in the same directory as the token object.  That
	 * way, the "rename" later will be an atomic operation
	 */
	if (ks_handle->public) {
		(void) snprintf(orig_name, MAXPATHLEN, "%s/%s",
		    get_pub_obj_path(pub_obj_path), ks_handle->name);
		(void) snprintf(tmp_name, MAXPATHLEN, "%s/%s%s",
		    pub_obj_path, TMP_OBJ_PREFIX,
		    (ks_handle->name) + strlen(OBJ_PREFIX));
	} else {
		(void) snprintf(orig_name, MAXPATHLEN, "%s/%s",
		    get_pri_obj_path(pri_obj_path), ks_handle->name);
		(void) snprintf(tmp_name, MAXPATHLEN, "%s/%s%s",
		    pri_obj_path, TMP_OBJ_PREFIX,
		    (ks_handle->name) + strlen(OBJ_PREFIX));
	}

	while ((tmp_fd = open(tmp_name,
	    O_WRONLY|O_CREAT|O_EXCL|O_NONBLOCK, S_IRUSR|S_IWUSR)) < 0) {
		if (errno != EINTR)
			break;
	}
	if (tmp_fd < 0) {
		/* can't create tmp object file */
		goto cleanup1;
	}
	(void) fcntl(tmp_fd, F_SETFD, FD_CLOEXEC);

	/* read version, increment, and write to tmp file */
	if (looping_read(fd, (char *)&version, OBJ_VER_SIZE) != OBJ_VER_SIZE) {
		goto cleanup2;
	}

	version = SWAP32(version);
	version++;
	version = SWAP32(version);

	if (looping_write(tmp_fd, (char *)&version, OBJ_VER_SIZE)
	    != OBJ_VER_SIZE) {
		goto cleanup2;
	}

	/* generate a new IV for the object, old one can be ignored */
	if (soft_gen_iv(iv) != CKR_OK) {
		goto cleanup2;
	}

	if (looping_write(tmp_fd, (char *)iv, OBJ_IV_SIZE) != OBJ_IV_SIZE) {
		goto cleanup2;
	}

	if (ks_handle->public) {

		/* hmac is always NULL for public objects */
		bzero(obj_hmac, sizeof (obj_hmac));
		if (looping_write(tmp_fd, (char *)obj_hmac, OBJ_HMAC_SIZE)
		    != OBJ_HMAC_SIZE) {
			goto cleanup2;
		}

		/* write updated object */
		if (looping_write(tmp_fd, (char *)buf, len) != len) {
			goto cleanup2;
		}

	} else {

		uchar_t *encrypted_buf, *prepared_buf;
		CK_ULONG out_len = 0, prepared_len;

		if (prepare_data_for_encrypt(orig_name, buf, len,
		    &prepared_buf, &prepared_len) != 0) {
			goto cleanup2;
		}

		/* encrypt the data */
		if (soft_keystore_crypt(enc_key, iv, B_TRUE, prepared_buf,
		    prepared_len, NULL, &out_len) != CKR_OK) {
			free(prepared_buf);
			goto cleanup2;
		}

		encrypted_buf = malloc(out_len * sizeof (char));
		if (encrypted_buf == NULL) {
			free(prepared_buf);
			goto cleanup2;
		}

		if (soft_keystore_crypt(enc_key, iv, B_TRUE, prepared_buf,
		    prepared_len, encrypted_buf, &out_len) != CKR_OK) {
			free(encrypted_buf);
			free(prepared_buf);
			goto cleanup2;
		}

		free(prepared_buf);

		/* calculate hmac on encrypted buf */
		hmac_size = OBJ_HMAC_SIZE;
		if (soft_keystore_hmac(hmac_key, B_TRUE, encrypted_buf,
		    out_len, obj_hmac, &hmac_size) != CKR_OK) {
			free(encrypted_buf);
			goto cleanup2;
		}

		if (hmac_size != OBJ_HMAC_SIZE) {
			free(encrypted_buf);
			goto cleanup2;
		}

		if (looping_write(tmp_fd, (char *)obj_hmac, OBJ_HMAC_SIZE)
		    != OBJ_HMAC_SIZE) {
			free(encrypted_buf);
			goto cleanup2;
		}

		if (looping_write(tmp_fd, (void *)encrypted_buf, out_len)
		    != out_len) {
			free(encrypted_buf);
			goto cleanup2;
		}
		free(encrypted_buf);
	}
	(void) close(tmp_fd);

	/* rename updated temporary object file */
	if (rename(tmp_name, orig_name) != 0) {
		(void) unlink(tmp_name);
		return (-1);
	}

	/* rename updated keystore description file */
	if (rename(tmp_ks_name, ks_desc_file) != 0) {
		(void) unlink(tmp_name);
		(void) unlink(tmp_ks_name);
		return (-1);
	}

	/* determine need to unlock file or not */
	if (!lock_held) {
		if (lock_file(fd, B_FALSE, B_FALSE) < 0) {
			(void) close(fd);
			(void) unlink(tmp_name);
			return (-1);
		}
	}

	/* unlock keystore description file */
	if (lock_file(ks_fd, B_FALSE, B_FALSE) != 0) {
		(void) close(ks_fd);
		(void) close(fd);
		return (-1);
	}

	(void) close(ks_fd);

	(void) close(fd);

	return (0); /* All operations completed successfully */

cleanup2:
	(void) close(tmp_fd);
	(void) remove(tmp_name);

cleanup1:
	(void) close(fd);

cleanup:
	/* unlock keystore description file */
	(void) lock_file(ks_fd, B_FALSE, B_FALSE);
	(void) close(ks_fd);
	(void) remove(tmp_ks_name);
	return (-1);
}

/*
 *	FUNCTION: soft_keystore_del_obj
 *
 *	ARGUMENTS:
 *		ks_handle: handle of the key store object to be deleted
 *		lock_held: TRUE if the lock is held by caller.
 *
 *	RETURN VALUE:
 *		-1: if any error occurred.
 *		0: object successfully deleted from keystore.
 *
 *	DESCRIPTION:
 *		This API is used to delete a particular token object from
 *		the keystore.  The corresponding token object file will be
 *		removed from the file system.
 *		Any future reference to the deleted file will
 *		return an CKR_OBJECT_HANDLE_INVALID error.
 */
int
soft_keystore_del_obj(ks_obj_handle_t *ks_handle, boolean_t lock_held)
{
	char objname[MAXPATHLEN], tmp_ks_name[MAXPATHLEN];
	int fd;
	char pub_obj_path[MAXPATHLEN], pri_obj_path[MAXPATHLEN],
	    ks_desc_file[MAXPATHLEN];
	int ret_val = -1;
	int obj_fd;

	if ((fd = open_and_lock_keystore_desc(O_RDWR, B_FALSE,
	    lock_held)) < 0) {
		return (-1);
	}

	(void) get_desc_file_path(ks_desc_file);
	(void) get_tmp_desc_file_path(tmp_ks_name);
	if (create_updated_keystore_version(fd, tmp_ks_name) != 0) {
		goto cleanup;
	}

	if (ks_handle->public) {
		(void) snprintf(objname, MAXPATHLEN, "%s/%s",
		    get_pub_obj_path(pub_obj_path), ks_handle->name);
	} else {
		(void) snprintf(objname, MAXPATHLEN, "%s/%s",
		    get_pri_obj_path(pri_obj_path), ks_handle->name);
	}

	/*
	 * make sure no other process is reading/writing the file
	 * by acquiring the lock on the file
	 */
	if ((obj_fd = open_and_lock_object_file(ks_handle, O_WRONLY,
	    B_FALSE)) < 0) {
		return (-1);
	}

	if (unlink(objname) != 0) {
		(void) lock_file(obj_fd, B_FALSE, B_FALSE);
		(void) close(obj_fd);
		goto cleanup;
	}

	(void) lock_file(obj_fd, B_FALSE, B_FALSE);
	(void) close(obj_fd);

	if (rename(tmp_ks_name, ks_desc_file) != 0) {
		goto cleanup;
	}
	ret_val = 0;

cleanup:
	/* unlock keystore description file */
	if (!lock_held) {
		if (lock_file(fd, B_FALSE, B_FALSE) != 0) {
			(void) close(fd);
			return (-1);
		}
	}

	(void) close(fd);
	return (ret_val);
}

/*
 * Get the salt used for generating hashed pin from the
 * keystore description file.
 *
 * The result will be stored in the provided buffer "salt" passed
 * in as an argument.
 *
 * Return 0 if no error, return -1 if there's any error.
 */
int
soft_keystore_get_pin_salt(char **salt)
{
	int fd, ret_val = -1;
	uint64_t hashed_pin_salt_size;

	if ((fd = open_and_lock_keystore_desc(O_RDONLY, B_TRUE,
	    B_FALSE)) < 0) {
		return (-1);
	}

	if (lseek(fd, KS_HASHED_PIN_SALT_LEN_OFFSET, SEEK_SET)
	    != KS_HASHED_PIN_SALT_LEN_OFFSET) {
		goto cleanup;
	}

	if (looping_read(fd, (char *)&hashed_pin_salt_size,
	    KS_HASHED_PIN_SALT_LEN_SIZE) != KS_HASHED_PIN_SALT_LEN_SIZE) {
		goto cleanup;
	}
	hashed_pin_salt_size = SWAP64(hashed_pin_salt_size);

	*salt = malloc(hashed_pin_salt_size + 1);
	if (*salt == NULL) {
		goto cleanup;
	}

	if ((looping_read(fd, *salt, hashed_pin_salt_size))
	    != (ssize_t)hashed_pin_salt_size) {
		free(*salt);
		goto cleanup;
	}
	(*salt)[hashed_pin_salt_size] = '\0';

	ret_val = 0;

cleanup:
	if (lock_file(fd, B_TRUE, B_FALSE) < 0) {
		ret_val = -1;
	}

	(void) close(fd);
	return (ret_val);
}

/*
 *	FUNCTION: soft_keystore_pin_initialized
 *
 *	ARGUMENTS:
 *		initialized: This value will be set to true if keystore is
 *			     initialized, and false otherwise.
 *		hashed_pin: If the keystore is initialized, this will contain
 *			    the hashed pin.  It will be NULL if the keystore
 *			    pin is not initialized.  Memory allocated
 *			    for the hashed pin needs to be freed by
 *			    the caller.
 *		lock_held: TRUE if the lock is held by caller.
 *
 *	RETURN VALUE:
 *		CKR_OK: No error
 *		any other appropriate CKR_value
 *
 *	DESCRIPTION:
 *		This API is used to determine if the PIN in the keystore
 *		has been initialized or not.
 *		It makes the determination using the salt for generating the
 *		encryption key.  The salt is stored in the keystore
 *		descryption file.  The salt should be all zero if
 *		the keystore pin has not been initialized.
 *		If the pin has been initialized, it is returned in the
 *		hashed_pin argument.
 */
CK_RV
soft_keystore_pin_initialized(boolean_t *initialized, char **hashed_pin,
    boolean_t lock_held)
{
	int fd;
	CK_BYTE crypt_salt[KS_KEY_SALT_SIZE], tmp_buf[KS_KEY_SALT_SIZE];
	CK_RV ret_val = CKR_OK;

	if ((fd = open_and_lock_keystore_desc(O_RDONLY, B_TRUE,
	    lock_held)) < 0) {
		return (CKR_FUNCTION_FAILED);
	}

	if (lseek(fd, KS_KEY_SALT_OFFSET, SEEK_SET) != KS_KEY_SALT_OFFSET) {
		ret_val = CKR_FUNCTION_FAILED;
		goto cleanup;
	}

	if (looping_read(fd, (char *)crypt_salt, KS_KEY_SALT_SIZE)
	    != KS_KEY_SALT_SIZE) {
		ret_val = CKR_FUNCTION_FAILED;
		goto cleanup;
	}

	(void) bzero(tmp_buf, KS_KEY_SALT_SIZE);

	if (memcmp(crypt_salt, tmp_buf, KS_KEY_SALT_SIZE) == 0) {
		*initialized = B_FALSE;
		hashed_pin = NULL;
	} else {
		*initialized = B_TRUE;
		ret_val = get_hashed_pin(fd, hashed_pin);
	}

cleanup:

	if (!lock_held) {
		if (lock_file(fd, B_TRUE, B_FALSE) < 0) {
			ret_val = CKR_FUNCTION_FAILED;
		}
	}

	(void) close(fd);
	return (ret_val);
}